指针法解决5243同积元组

第一次做：用的DFS ，超时了😭

class Solution {

    int res = 0;

    public void dfs(int[]nums, int n, int j1, int j2, boolean sign[]){

        if(j1 != 0 && j1 == j2 && n == 4){
            res+=1;
            return;
        }
        
        if(n >= 4){
            return;
        }

        for(int i=0; i<nums.length; i++){
            if(sign[i]){
                continue;
            }
            if(n == 0){
                sign[i] = true;
                dfs(nums, n+1, nums[i], j2, sign);
                sign[i] = false;
            }else if(n == 1){
                sign[i] = true;
                dfs(nums, n+1, j1 * nums[i], j2, sign);
                sign[i] = false;
            }else if(n == 2){
                if(nums[i] > j1){
                    continue;
                }
                sign[i] = true;
                dfs(nums, n+1, j1, nums[i], sign);
                sign[i] = false;
            }else if(n == 3){
                sign[i] = true;
                dfs(nums, n+1, j1, nums[i]*j2, sign);
                sign[i] = false;
            }
        }
    }

    public int tupleSameProduct(int[] nums) {
        if(nums.length < 4){
            return 0;
        }

        boolean sign[] = new boolean[nums.length];
        dfs(nums, 0, 0, 0, sign);
        return res;
    }
}

然后，我想，用指针法做吧，通过了😄

class Solution {
    int res = 0;
    public int tupleSameProduct(int[] nums) {
        
         if(nums.length < 4){
            return 0;
        }
        
        Arrays.sort(nums);

        int i = 0;

        int j = nums.length-1;

        while(i < nums.length){
            while(j > i){
                int i2 = i+1;
                int j2 = j-1;

                while(i2 < j2){
                    if(nums[i2] * nums[j2] == nums[i] * nums[j]){
                        res+=1;
                         i2++;
                        j2--;
                    }
                    if(nums[i2] * nums[j2] < nums[i] * nums[j]){
                        i2++;
                    }
                    if(nums[i2] * nums[j2] > nums[i] * nums[j]){
                        j2--;
                    }
                }
                j--;
            }
            j = nums.length-1;
            i++;
        }


        return res*8;
    }
}

然后看了答案，发现自己想复杂了......

class Solution {
    // 目标是计算两个数的积，在不同的数组是否重复出现
    public int tupleSameProduct(int[] nums) {
        if(nums == null || nums.length == 0){
            return 0;
        }
        Map<Integer, Integer> map = new HashMap<>();
        int len = nums.length;
        int ans = 0;
        for(int i = 0; i < len - 1; i++){
            for(int j = i + 1; j < len; j++ ){ // 遍历 获得两两组合的积，并且不会出现重复
                int mutil = nums[i] * nums[j]; // 计算两两的积
                if(map.containsKey(mutil)){ // 如果积已经存在map
                    ans +=  map.get(mutil); // 结果加上value，因为重复出现2次以上，组合会增多，不能只加1
                    map.put(mutil, map.get(mutil) + 1); // 出现次数加1
                }else{ // 未出现在map
                    map.put(mutil, 1); // 次数加1
                } 
            }
        }
        return ans*8; // 相同数字的四元组，能够组合成2的4次方，也就是8次
    }
}