leetcode【高级】四数相加 II Java

题干

给定四个包含整数的数组列表 A , B , C , D ,计算有多少个元组 (i, j, k, l) ，使得 A[i] + B[j] + C[k] + D[l] = 0。

为了使问题简单化，所有的 A, B, C, D 具有相同的长度 N，且 0 ≤ N ≤ 500 。所有整数的范围在 -228 到 228 - 1 之间，最终结果不会超过 231 - 1 。

例如:

输入:
A = [ 1, 2]
B = [-2,-1]
C = [-1, 2]
D = [ 0, 2]

输出:
2

解释:
两个元组如下:
1. (0, 0, 0, 1) -> A[0] + B[0] + C[0] + D[1] = 1 + (-2) + (-1) + 2 = 0
2. (1, 1, 0, 0) -> A[1] + B[1] + C[0] + D[0] = 2 + (-1) + (-1) + 0 = 0

想法

直接遍历每一种组合太过于憨憨了，由于这里是四个数组我们可以让之两两结合
什么意思呢：
先遍历数组AB，将他们的和放入hashmap中，hashmap存储这个数和他出现的次数
再遍历cd，将他们的和记为target，如果-target存在于hashmap,那么就将最后结果加上hahsmap对应的key
由于只需要返回次数，所以这样即可

Java代码

直接看代码很好懂

class Solution {
    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        Map<Integer,Integer> map=new HashMap<>();//存sum和它对应次数
        int count=0;
        for(int i=0;i<A.length;i++){
            for(int j=0;j<B.length;j++){
                int sum=A[i]+B[j];
                if(map.containsKey(sum)){
                    map.put(sum,map.get(sum)+1);//更新次数
                }
                else{
                    map.put(sum,1);
                }
            }
        }
        for(int l=0;l<C.length;l++){
            for(int m=0;m<D.length;m++){
                int target=-(C[l]+D[m]);
                if(map.containsKey(target)){//存在－target即可更新count
                    count+=map.get(target);
                }
            }
        }
        return count;     
    }
}

leetcode上更快的解答

class Solution {

    public class ListNode2 {

        private int value;
        private int visit;
        private ListNode2 next;

        public ListNode2(int value) {
            this.value = value;
        }

        public ListNode2 insert (ListNode2 head, int value){
            ListNode2 tmp = new ListNode2(value);
            tmp.next = head;
            return tmp;
        }

    }

    public class HashMap {

        private int max = 0x7ffff;
        private ListNode2[] myHash = new ListNode2[max];

        public int getKey(int value){
            return value > 0 ? value % max : -(value % max);
        }

        public void insert (int value){
            int key = getKey(value);
            if (myHash[key] == null){
                myHash[key] = new ListNode2(value);
                myHash[key].visit = 1;
                return;
            }
            ListNode2 head = myHash[key];
            while(head != null){
                if (head.value == value){
                    head.visit ++;
                    return;
                }
                head = head.next;
            }
            myHash[key] = myHash[key].insert(myHash[key], value);
            myHash[key].visit = 1;
        }

        public int find (int value){
            int count = 0, key = getKey(value);
            ListNode2 head = myHash[key];
            while(head != null){
                if (head.value == value) {
                    return head.visit;
                }
                head = head.next;
            }
            return count;
        }

    }

    public int fourSumCount(int[] A, int[] B, int[] C, int[] D) {
        HashMap map = new HashMap();
        int count = 0, i, j, sum;
        for (i = 0; i < C.length; i ++) {
            for (j = 0; j < D.length; j ++) {
                map.insert(C[i] + D[j]);
            }
        }
        for (i = 0; i < A.length;  i ++) {
            sum = 0 - A[i];
            for (j = 0; j < B.length; j ++) {
                count += map.find(sum - B[j]);
            }
        }
        return count;
    }

}