54三数之和55 56有无重复元素的全排列

54 三数之和

首先想到的就是之前的两数之和，只要在外层遍历一遍，对每个元素用之前的两数之和的哈希做法，就刚好是O(n^2)
但是有坑的地方在于需要去重，并且输出的三元组也是需要顺序的！！然后我用set去重和重写比较器花了较多时间

import java.util.*;
public class Solution {

    public ArrayList<ArrayList<Integer>> threeSum(int[] num) {
        //固定一个之后就是两数之和
        ArrayList<ArrayList<Integer>>res = new ArrayList<ArrayList<Integer>>();
        Set<ArrayList<Integer>> s = new HashSet<ArrayList<Integer>>();
        for(int i=0;i<num.length;i++){
            Map<Integer,Integer> p = new HashMap<>();  
            int sum=-1*num[i];
            for(int j=i+1;j<num.length;j++){
                if(p.containsKey(num[j])){
                    ArrayList<Integer> row = new ArrayList<Integer>();
                    row.add(num[i]);
                    row.add(sum-num[j]);
                    row.add(num[j]);
                    row.sort((a,b)->a-b);                   
                    s.add(row);                  
                }
                if(!p.containsKey(sum-num[j])){
                    p.put(sum-num[j],j);
                }       
            }
        }//用set去重
        for(Iterator<ArrayList<Integer>> i=s.iterator();i.hasNext();){
            res.add(i.next());
        }
        //三元组也要排序输出
        Collections.sort(res,new Comparator<ArrayList<Integer>>(){
            @Override
            public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
                for(int i=0;i<3;i++){
                    if(o1.get(i)!=o2.get(i))
                      return o1.get(i)-o2.get(i);
                }
                return 0;
            }
        }); 
        return res;      
    }
}

学到的：set的遍历：

for(Iterator<ArrayList<Integer>> i=s.iterator();i.hasNext();){
            res.add(i.next());
}

比较器的自定义:

Collections.sort(res,new Comparator<ArrayList<Integer>>(){
	  @Override
	  public int compare(ArrayList<Integer> o1, ArrayList<Integer> o2) {
	      for(int i=0;i<3;i++){
	          if(o1.get(i)!=o2.get(i))
	            return o1.get(i)-o2.get(i);
	      }
	      return 0;
	  }
	}); 

注意这里是直接返回 o1.get(i)-o2.get(i);，如果是降序排列就是 o2.get(i)-o1.get(i);！！！compare的返回值如果为负数，表示不用交换o1和o2,如果为正再交换。不用if判断！！！

55没有重复项数字的全排列

这道题知道要递归也不知道怎么写，一开始看了很久的题解还是没理解，最后还是看了深搜的回溯算法才最终理解：

比如我现在要往3个盒子里填3个数字，全排列的话，用dfs，参数index表示我当前要添入的盒子的下标（0，1，2）

递归需要边界条件和当前处理逻辑：
边界条件：已经全部填完，当前索引==num.size
当前逻辑：遍历所有元素，如果还没放到盒子中，就放入，递归到放index+1个空盒子
最重点在于回溯：满了之后就从末尾撤回一个，才能尝试其他可能

import java.util.*;

public class Solution {
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> list = new ArrayList<Integer>();
    public ArrayList<ArrayList<Integer>> permute(int[] num) {
        
        dfs(num,0);
        return res;
        
    }
    public void dfs(int[] num,int index){
        //递归结束条件
        if(index==num.length){
            res.add(new ArrayList<Integer>(list));//重点！！
            return;
        } 
        //递归执行
        for(int i=0;i<num.length;i++){//遍历所有元素 不是从i=index开始
            if(list.contains(num[i])) continue;
            list.add(num[i]);
            dfs(num,index+1);
            //回溯：撤销末尾的
            list.remove(list.size()-1);//注意不是remove(num[i])
        }
    }
}

除了算法，用java实现也有几个要注意的地方：

1.res.add(new ArrayList(list));//添加进res的时候要复制一个新list,否则直接res.add(list)，始终是同一个list对象，后面的list的各种操作还会体现到res里，这显然不是我们要的！！

时间复杂度：O(n∗n!)O(n*n!)O(n∗n!)，n个元素的数组进行全排列的递归，每次递归都要遍历数组
空间复杂度：O(n)O(n)O(n)，递归栈的最大深度为数组长度n，res属于返回必要空间

55有重复项数字的全排列

思想和上题一样，只是多存了一个count数组记录每个元素对应的个数

import java.util.*;

public class Solution {
    int[] count = new int[8];//存-1 5对应数字个数 -1 5映射到index 1 7 全局默认初始化为0
    ArrayList<ArrayList<Integer>> res = new ArrayList<ArrayList<Integer>>();
    ArrayList<Integer> list = new ArrayList<Integer>();
    //去掉重复的
    HashSet<ArrayList<Integer>> set = new HashSet<ArrayList<Integer>>();
    public ArrayList<ArrayList<Integer>> permuteUnique(int[] num) {
        for(int i=0;i<num.length;i++) count[num[i]+2]++;
        dfs(num,0);
        for(Iterator<ArrayList<Integer>> it=set.iterator();it.hasNext();){
            res.add(it.next());
        }
        //字典序排列输出
        Collections.sort(res,new Comparator<ArrayList<Integer>>(){
            @Override
            public int compare(ArrayList<Integer> a, ArrayList<Integer> b){
                for(int i=0;i<a.size();i++){
                    if(a.get(i)!=b.get(i)) return a.get(i)-b.get(i);
                }
                return 0;
            }
        });
        return res;
        
    }
    public void dfs(int[] num, int index){
        if(index==num.length){
            set.add(new ArrayList<Integer>(list));
            return;
        }
        for(int i=0;i<num.length;i++){
            if(count[num[i]+2]>0){
                list.add(num[i]);
                count[num[i]+2]--;
                dfs(num,index+1);
                list.remove(list.size()-1);
                count[num[i]+2]++;
            }
        }
    }
}