4Sum

Given an array S of n integers, are there elements a, b, c, and d in S such that a + b + c + d = target? Find all unique quadruplets in the array which gives the sum of target.

Note:

• Elements in a quadruplet (a,b,c,d) must be in non-descending order. (ie, a ≤ b ≤ c ≤ d)
• The solution set must not contain duplicate quadruplets.

 

    For example, given array S = {1 0 -1 0 -2 2}, and target = 0.

    A solution set is:
    (-1,  0, 0, 1)
    (-2, -1, 1, 2)
    (-2,  0, 0, 2)

这题的难点在于面向接口编程。 那个 声明 result 的方法很考究。

List<List<Integer>> test = new ArrayList<List<Integer>>();
List<Integer> row = new ArrayList<Integer>();
test.add(row);

 

public class Solution {
    public List<List<Integer>> fourSum(int[] num, int target) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
        if(num == null || num.length < 4) return result;
        Arrays.sort(num);
        int len = num.length;
        for(int a = 0; a < len - 3; a ++){
            if(a == 0 || num[a] != num[a - 1]){
                for(int b = a + 1; b < len - 2; b ++){
                    if(b == a + 1 || num[b] != num[b - 1]){
                        int c = b + 1, d = len - 1;
                        int goal = target - num[a] - num[b];
                        while(c < d){
                            if(num[c] + num[d] < goal) c ++;
                            else if(num[c] + num[d] > goal) d--;
                            else{
                                ArrayList<Integer> row = new ArrayList<Integer>();
                                row.add(num[a]);
                                row.add(num[b]);
                                row.add(num[c]);
                                row.add(num[d]);
                                result.add(row);
                                int cc = num[c], dd = num[d];
                                while(c < d && num[c] == cc) c ++;
                                while(c < d && num[d] == dd) d --;
                            } 
                        }
                    }
                }
            }
        }
        return result;
    }
}

 n^2 的算法：

4sum的hash算法：

O(N^2)把所有pair存入hash表，并且每个hash值下面可以跟一个list做成map， map[hashvalue] = list，每个list中的元素就是一个pair, 这个pair的和就是这个hash值，那么接下来求4sum就变成了在所有的pair value中求 2sum，这个就成了线性算法了，注意这里的线性又是针对pair数量(N^2)的线性，所以整体上这个算法是O(N^2)，而且因为我们挂了list, 所以只要符合4sum的我们都可以找到对应的是哪四个数字。

public class Solution {
    public List<List<Integer>> fourSum(int[] num, int target) {
        ArrayList<List<Integer>> result = new ArrayList<List<Integer>> ();
        if(num == null || num.length < 4) return result;
        Arrays.sort(num);
        HashMap<Integer, ArrayList<Integer[]>> pair = new HashMap<Integer, ArrayList<Integer[]>> ();
        for(int i = 0; i < num.length; i ++){
            if(i == 0 || num[i] != num[i - 1]){
                for(int j = i + 1; j < num.length; j ++){
                    if(j == i + 1 || num[j] != num[j - 1]){
                        Integer sum = num[i] + num[j];
                        if(pair.containsKey(sum)) pair.get(sum).add(new Integer[]{num[i], num[j]});
                        else {
                            ArrayList<Integer[]> list = new ArrayList<Integer[]> ();
                            list.add(new Integer[]{num[i], num[j]});
                            pair.put(sum, list);
                        }
                    }
                }
            }
        }
        
        HashMap<Integer, Integer> maxAppear = new HashMap<Integer, Integer>();
        for(int i = 0; i < num.length; i ++){
            if(maxAppear.containsKey(num[i])) maxAppear.put(num[i], maxAppear.get(num[i]) + 1);
            else maxAppear.put(num[i], 1);
        }
        
        HashSet<Integer> resultSet = new HashSet<Integer>();
        
        Iterator point = pair.entrySet().iterator();
        while(point.hasNext()){
            Map.Entry pairs = (Map.Entry)point.next();
            Integer goal = target - (int)pairs.getKey();
            if(pair.containsKey(goal)){
                ArrayList<Integer[]> right = pair.get(goal);
                ArrayList<Integer[]> left = (ArrayList<Integer[]>)pairs.getValue();
                for(int i = 0; i < left.size(); i ++){
                    for(int j = 0; j < right.size(); j ++){
                        int[] row = isValidList(left.get(i), right.get(j),new HashMap<Integer, Integer>(maxAppear));
                        if(row != null){
                            int rowValue = ((row[0] * 31 + row[1]) * 31 + row[2]) * 31 + row[3];
                            if(!resultSet.contains(rowValue)){
                                ArrayList<Integer> oneRow = new ArrayList<Integer>();
                                oneRow.add(row[0]);
                                oneRow.add(row[1]);
                                oneRow.add(row[2]);
                                oneRow.add(row[3]);
                                result.add(oneRow);
                                resultSet.add(rowValue);
                            }
                        }
                    }
                }
            }
        }
        return result;
    }
    
    public int[] isValidList(Integer[] first, Integer[] second, HashMap<Integer, Integer> maxAppear){
        if(first[1] > second[0]) return (int[]) null;
        int[] result = new int[4];
        result[0] = first[0];
        result[1] = first[1];
        result[2] = second[0];
        result[3] = second[1];
        for(int i = 0; i < 4; i ++){
            if(maxAppear.containsKey(result[i]) && maxAppear.get(result[i]) > 0) maxAppear.put(result[i], maxAppear.get(result[i]) - 1);
            else return (int[]) null;
        }
        return result;
    }
}

 

迭代器（Iterator）

　　迭代器是一种设计模式，它是一个对象，它可以遍历并选择序列中的对象，而开发人员不需要了解该序列的底层结构。迭代器通常被称为“轻量级”对象，因为创建它的代价小。

　　Java中的Iterator功能比较简单，并且只能单向移动：

　　(1) 使用方法iterator()要求容器返回一个Iterator。第一次调用Iterator的next()方法时，它返回序列的第一个元素。注意：iterator()方法是java.lang.Iterable接口,被Collection继承。

　　(2) 使用next()获得序列中的下一个元素。

　　(3) 使用hasNext()检查序列中是否还有元素。

　　(4) 使用remove()将迭代器新返回的元素删除。

　　Iterator是Java迭代器最简单的实现，为List设计的ListIterator具有更多的功能，它可以从两个方向遍历List，也可以从List中插入和删除元素。

迭代器应用：
 list l = new ArrayList();
 l.add("aa");
 l.add("bb");
 l.add("cc");
 for (Iterator iter = l.iterator(); iter.hasNext();) {
  String str = (String)iter.next();
  System.out.println(str);
 }
 /*迭代器用于while循环
 Iterator iter = l.iterator();
 while(iter.hasNext()){
  String str = (String) iter.next();
  System.out.println(str);
 }
 */