提高此算法的时间复杂度？

Question

I have created this algorithm which all it does is finds the pairs of integers that have the same product and the integers in the pairs have to be different. The product must not exceed the 1024. This is the easiest way I could come up to doing it, is there a way I could improve the efficiency and time complexity of this algorithm?

Thanks

import java.util.ArrayList;

public class Pairs {

    public static void main(String [] args){

        int nums[] = new int[1024];
        for(int i = 1;i<=1024;i++){
            nums[i-1] = i;
        }
        findPairs(nums);

    }

    static void findPairs(int [] nums){


        ArrayList<IntPair> pairs = new ArrayList<IntPair>();
        ArrayList<Products> products = new ArrayList<Products>();

        IntPair tempObject;
        Products tempProduct;
        int tempMultiplication = 0;

        for(int i =0;i<nums.length;i++){

            for(int j=0;j<nums.length;j++){

                tempObject = new IntPair(nums[i],nums[j]);
                pairs.add(tempObject);

                }


            }

        for(IntPair p:pairs){
            tempProduct = new Products(p.x,p.y);

            if(tempProduct.product <= 1024){
                products.add(tempProduct);
            }


        }


        for(int i = 0;i<products.size();i++){

            tempMultiplication = products.get(i).product;

            for(int j = 0;j<products.size();j++){

                 if(products.get(j).product == tempMultiplication)
                 {
                    if(products.get(i).x == products.get(j).x || products.get(i).y == products.get(j).y) {


                     }
                    else if (products.get(i).x == products.get(j).y || products.get(j).x == products.get(j).y || products.get(i).x == products.get(i).y){


                    }
                     else{
                         System.out.println("Matching pair found:("+ products.get(i).x + ","+products.get(i).y+")"  + "("+ products.get(j).x + ","+products.get(j).y+")" );
                     }


                 }


            }

        }


    }


}

Answer 1

You can't improve the time complexity of your algorithm. It is O(n^2) , which is as good as you can do if you are comparing all pairs in the input.

But that's not to say that you can't improve the running time . Not all O(n^2) algorithms are equally good; you can make it run faster by getting it to do less work; in this case, that basically means skipping checking of numbers whose product can't be equal.

Put the pairs into buckets which have equal product:

Map<Integer, List<int[]>> map = new HashMap<>();
for (int i = 0; i < nums.length; ++i) {
  for (int j = i+1; j < nums.length; ++j) {
    if (nums[i] == nums[j] || nums[i]*nums[j] > 1024) continue;

    map.computeIfAbsent(nums[i]*nums[j], ArrayList::new)
        .add(new int[] {nums[i], nums[j]});
  }
}

Then just iterate all of the pairs of pairs within each bucket:

for (List<int[]> list : map.values()) {
  for (int i = 0; i < list.size(); ++i) {
    for (int j = 1; j < list.size(); ++j) {
      System.out.printf(
          "Matching pair found: %s %s%n",
          Arrays.toString(list.get(i)),
          Arrays.toString(list.get(j)));
    }
  }
}

This is still O(n^2) in the worst case, which is where all pairs of numbers have an equal product, meaning that the iteration over pairs with equal product is just iterating all pairs. I doubt that's actually possible, though, without all numbers being equal, which is prohibited by the check that the numbers in the pair are distinct.

You may be able to shave off a bit of time by sorting nums first, and then breaking the top inner loop once nums[i]*nums[j] > 1024 rather than continuing; it depends on how big nums is as to whether it is worth sorting it (having potentially copied it, if you don't want to change the input array).