Twitter OA prepare: K-complementary pair

2sum的夹逼算法，需要sort一下。本身不难，但是tricky的地方在于允许同一个数组元素自己跟自己组成一个pair，比如上例中的[5, 5]。而且数组本身就允许值相等的元素存在，在计算pair时，算成不同的pair，比如数组是[3，3]，K=6，这时的pair有[0, 0], [0, 1], [1, 0], [1, 1]4个。

这个case让这道本来不难的题一下子麻烦了许多。我的对应处理方法是：用HashMap记录每个元素出现次数，用一个变量res记录可行pair数。 像夹逼方法那样，一左一右两个pointer l、r 分别往中间走，如果左右元素和加起来等于K：

1. 如果 l == r, res = res + 1;

2. else, 如果A[l] == A[r], res = res + Math.pow(map.get(A[l]), 2); 加上A[l]出现次数的平方，比如[3, 3]这个例子，加上2^2 ==4, 再如[3, 3, 3], 加9

3. else, 即A[l] != A[r], res = res + 2 * map.get(A[l]) * map.get(A[r]); 比如[1, 1, 5], 加上4；[1, 1, 5, 5]，加上8；[-2, 8], 加上2

然后就是之后左右pointer该怎么跳，我的处理方法是，跳出现次数那么多次，这样就不再重复处理这些出现过的数字

 public int KComplementary(int[] A, int K) {
     if (A==null || A.length==0) return 0;
     int res = 0;
     int l = 0;
     int r = A.length - 1;
     HashMap<Integer, Integer> map = new HashMap<Integer, Integer>();
     for (int i=0; i<A.length; i++) {
         if (map.containsKey(A[i])) {
             map.put(A[i], map.get(A[i])+1);
         }
         else {
             map.put(A[i], 1);
         }
     }
     while (l <= r) {
         if (A[l] + A[r] == K) {
             if (l == r) res += 1;
             else if (A[l] == A[r]) {
                 res += Math.pow(map.get(A[l]), 2);
             }
             else {
                 res += 2 * map.get(A[l]) * map.get(A[r]);
             }
             l = l + map.get(A[l]);
             r = r - map.get(A[r]);
         }
         else if (A[l] + A[r] < K) {
             l = l + map.get(A[l]);
         }
         else {
             r = r - map.get(A[r]);
         }
     }
     return res;
 }