如何找到数字中的所有平方（Java）？

Question

I seem to have a mental block, and cannot progress with the following problem. Basically, I want to find all possible squares in a given number, ie N = S*S*A, where N in given number, S*S is a square, and A is some other number. And I need to find all possible combinations of that kind.
So far I have factorized the number N in a sequence of prime number, and build a Map, where keys are unique prime numbers in the sequence, and values are number of occurrences of this prime number.
For example, for some number there might be such sequence:
2 2 2 3 3 5 5 5 5 7 7 7 7 7,
thus, the squares should be 4, 9, 25, 49, 36, 100, 196, 225, 441, 1225. For such sequence, I will have the following map:
2 3
3 2
5 4
7 5
Next, I decrease odd values by one:
2 2
3 2
5 4
7 4
The main question is how to get squares written above from this map. My idea was to run 2 loops (no idea how efficient that is):

for(Map.Entry<BigInteger, Integer> entry : frequency.entrySet()) {
    for(Map.Entry<BigInteger, Integer> ientry : frequency.entrySet()) {
    }
}

It is obvious how to multiply all pairs of keys from the map, but I cannot come up with conditions I have to impose to take multiplicities into account.
Thanks you very much in advance!
Ps Is there any good way without nested loops?

Answer 1

I don't think nested loops are going to help you here; you're entering recursion territory. :-)

The problem you're asking essentially boils down to this. You have a list of numbers, along with the frequencies of those numbers. You want to come up with all unique ways in which you can choose some number of copies of each number. For example, given

2 2
3 4
5 2

You'd want

2 ⁰ 3 ⁰ 5 ⁰

2 ⁰ 3 ⁰ 5 ²

2 ⁰ 3 ² 5 ⁰

2 ⁰ 3 ² 5 ²

2 ⁰ 3 ⁴ 5 ⁰

2 ⁰ 3 ⁴ 5 ²

2 ² 3 ⁰ 5 ⁰

2 ² 3 ⁰ 5 ²

2 ² 3 ² 5 ⁰

2 ² 3 ² 5 ²

2 ² 3 ⁴ 5 ⁰

2 ² 3 ⁴ 5 ²

If we just write the exponents, then we have

0 0 0
0 0 2
0 2 0
0 2 2
0 4 0
0 4 2
2 0 0
2 0 2
2 2 0
2 2 2
2 4 0
2 4 2

So the question is how you can go about generating this. Fortunately, there's a really beautiful recursive formulation for generating these numbers. It goes something like this. We want to write a function AllSquares that takes in a list of pairs of primes and their multiplicities, then returns all possible products that can be formed from those primes that are perfect squares. We'll do this inductively.

As our base case, if you provide the empty list to AllSquares , then there is exactly one square product, which is 1, the empty product of the elements of the empty list.

For the inductive step, suppose that we have a nonempty list whose first element is (prime, multiplicity) and whose remaining elements are "rest." Suppose that we recursively compute the list "combinations" formed by calling AllSquares on the rest of the elements of the list. Then for i = 0, 2, 4, ..., multiplicity, if you take the elements in the list and multiply them by base ⁱ , you'll end up with a new list of perfect squares. If you take the union of all of these values, you'll end up with all the possible perfect squares you can form from the numbers. The cool part about this is that this works even if the multiplicities are odd, since you'll only be considering even exponents.

Here's some simple Java code that implements this algorithm. It's not at all efficient, but it gets the point across:

private static List<Integer> allSquares(List<BaseMultiplicity> elems) {
    /* Base case: If the list is empty, there's only one square. */
    if (elems.isEmpty()) {
        return Collections.singletonList(1);
    }

    /* Recursive case: Compute the answer for the rest of the list. */
    List<BaseMultiplicity> rest = new LinkedList<BaseMultiplicity>(elems);
    rest.remove(0);
    List<Integer> recResult = allSquares(rest);

    /* Now, for each even power of this number, add appropriately-scaled
     * copies of the recursive solution to the result.
     */
    List<Integer> result = new ArrayList<Integer>();
    for (int i = 0, base = 1; i < elems.get(0).multiplicity; 
         i += 2, base *= elems.get(0).prime)
        for (Integer elem: recResult)
            result.add(elem * base * base);

    return result;
}

Hope this helps!

Answer 2

The way that I'd solve this is as a combinatorial problem.

1. factorize and count the prime factors.

2. build a list such that if a factor appears 2N or 2N + 1 times in the original number, the factor appears N times in this list. Thus, for prime factors of 2 2 2 2 2 3 3 5 the list would be 2 2 3

3. the build a list of all combinations of the previous list; eg {2} {2} {3} {2 2} {2 3} {2 3} {2 2 3} .

4. multiply the factors in each set; eg {2 2 3 4 6 6 12} .

5. eliminate duplicates to get the list of S values; eg {2 3 4 6 12} .

Now translate into Java.

(Building the list of all combinations can be done iteratively or recursively ... or by punting and using a third party library. Also, you could eliminate the duplicates in step 3; ie build a set of unique combinations.)

Answer 3

For N = S * S * A compute the divisors of S and square them.

So given your map you can halve each exponent, this gives you the factorization of S .

Then compute the numbers corresponding to all combinations of exponents to get the divisors, as usual.

Here is my function for that:

public static NavigableSet<Long> divisors(long n)
{
    NavigableSet<Long> divisors = new TreeSet<Long>();
    divisors.add(1L);
    final Multiset<Long> factorization = primeFactorization(n);
    for (final long primeFactor : factorization.elementSet())
    {
        final int exponent = factorization.getMultiplicity(primeFactor);

        final NavigableSet<Long> newDivisors = new TreeSet<Long>(divisors);
        for (final long d : divisors)
        {
            for (int i = 0; i <= exponent; i++)
            {
                newDivisors.add(d * pow(primeFactor, i));
            }
        }
        divisors = newDivisors;
    }
    return divisors;
}

Multiset is basically a map from elements to non-negative integers.