江的福从零开始刷算法（依旧递归-LeetCode 46 全排列等相似算法及小总结）

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Solution {
  private boolean[] flags ;
      private static int count=0;

    public List<List<Integer>> permute(int[] nums) {
         flags=new boolean[nums.length];
        List<List<Integer>> lists =new ArrayList<>();
        List<Integer> list =new ArrayList<>();
        if (nums.length==0){
            return lists;
        }
        Arrays.fill(flags, false);
        permuteNum(nums,lists,0,list);
        return lists;
    }
    public void permuteNum(int[] nums, List<List<Integer>> lists,int index,List<Integer> list){
        if (index ==nums.length){
            List<Integer> list1 =new ArrayList<>();
            list1.addAll(list);
            lists.add(list1);
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!flags[i]){
                list.add(nums[i]);
                flags[i]=true;
                permuteNum(nums, lists, index+1,list);
                flags[i]=false;
                list.remove(list.size()-1);
            }
        }
    }
}

这道题的特点是没有数字重复，并且各个数字也只能被使用一次,还有一个主要特点是每个数字都要被使用到，即，不需要每次循环都应该从0-length，但是已经被选中的值，就不能再次出现，因此使用一个Boolean类型的数组，它的值对应于int数组的每个值，用它来判断每个值在当前的组合是否被用到。

每道题的特点都是因为其他的的特点而凸显出来的，所以再来看几个题

47、全排列二

可以看到本道题的特点是序列可以包含重复数字，这就意味着在最终拿到的组合中，会有重复的元素。
因此，为了避免重复，我们先将这个序列排序，然后当两个相同元素不在一个组合中的同时，后面的这个元素，就不在递归。

 if(i>0&&!flags[i-1]&&nums[i]==nums[i-1]){
                    continue;
                }

全部代码：

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
class Solution {
    private  boolean[] flags ;
    public  List<List<Integer>> permuteUnique(int[] nums) {
        flags=new boolean[nums.length];
        List<List<Integer>> lists =new ArrayList<>();
        List<Integer> list =new ArrayList<>();
        Arrays.fill(flags, false);
        Arrays.sort(nums);
        permuteNum(nums,lists,0,list);
        return lists;
    }
    public  void permuteNum(int[] nums, List<List<Integer>> lists,int index,List<Integer> list){
        if (index ==nums.length){
            List<Integer> list1 =new ArrayList<>();
            list1.addAll(list);
            if (!lists.contains(list1)) {
                lists.add(list1);
            }            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (!flags[i]){
                if(i>0&&!flags[i-1]&&nums[i]==nums[i-1]){
                    continue;
                }
                list.add(nums[i]);
                flags[i]=true;
                permuteNum(nums, lists, index+1,list);
                flags[i]=false;
                list.remove(list.size()-1);
            }
        }

    }
}

这两个题各有特点，但是都是组合问题，下面这个题就些微有些不同，但是依旧是组合问题的一种表现形式。

93、复原ip地址

我们需要遍历所有点，最终将整个字符串分成四部分，并使得每一部分都处于0-255之间。
这里涉及到stringbuilder对字符串的拼接。
关键的部分在于如何遍历，遍历过程中的条件又是什么。
关于如何遍历，我们知道我们得从已经遍历到的后一个元素开始，所有我们会设置一个start，即每次遍历的开始位置，作为下一次遍历赋予i的变量，并且因为每一部分所处的数值范围在0-255之间，我们可以确定每个元素最多只有三位数，因此要控制每次对字符串的substring的范围在start+3<i,即i的for循环条件。
还有要注意的细节是0在开始的话，只能单独存在即长度为1.否则将其break。
最后将截取到的字符串转为数值，判断其是否在规定范围中，来决定是否将其放入list。
每次递归回溯，将list的末尾元素remove。这个因该算是递归回溯的老套路了。
还有一些套路是：递归结束条件，然后是循环中递归，这里的循环初值，条件都是因题而异的。
当然并不是每个题都需要写递归结束的条件，因为递归会因为for循环的结束而自动将结束方法，然后方法栈中下一个方法。
因此也不要一股脑的去硬凑结束条件。比如说有的题就是要递归的路径，而不是递归的结果。
先把这题的代码放这里：

class Solution {
    List<String> res =new ArrayList<String>();
    public List<String> restoreIpAddresses(String s) {
        List<String> list =new ArrayList<String>();
        if(s.equals("")){
            return res;
        }
        dfs(s,0,list);
        return res;
    }
    public void dfs(String s,int start,List<String> list){
        if (start==s.length()){
            if(list.size()==4){
                StringBuilder str =new StringBuilder();
                for(int i=0;i<list.size();i++){
                    str.append(list.get(i));
                    if(i!=list.size()-1){
                        str.append('.');
                    }
                }
                res.add(str.toString());

            }
            return;
        }else{
            //进行遍历
            if(list.size()>=4) return;
            for(int i =start;i<s.length()&&start+3>i;i++){
                String str1=s.substring(start,i+1);
                if(str1.charAt(0)=='0'&&str1.length()!=1) break;
                int num =Integer.parseInt(str1);
                if(num>=0&&num<=255){
                    list.add(str1);
                    dfs(s,i+1,list);
                    list.remove(list.size()-1);
                }else{
                    return;
                }

            }
        }

    }
}

还有一部分题，明天总结。
有些晚了，我是养生的“江的福”，希望健康安乐。