排列组合问题集合

排列组合问题集合

---

无重复数列的子集

问题描述：给定一个无重复数的集合nums，返回所有可能的子集合(包含集合本身和空集)。
比如，如果nums = [1,2,3], 结果是：

[
  [3],
  [1],
  [2],
  [1,2,3],
  [1,3],
  [2,3],
  [1,2],
  []
]

解决代码采用深度优先遍历(dfs)：

class Solution{
    public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        List<Integer> tempList=new ArrayList<>();
        if(nums==null || nums.length==0)
            return result;
        dspSubsets(nums,result,tempList,0);
        return result;
    }

    private void dspSubsets(int[] nums,List<List<Integer>> result, List<Integer> tempList,int start)
    {
        result.add(new ArrayList<>(tempList));
        for(int i=start;i<nums.length;i++){
            tempList.add(nums[i]);
            dspSubsets(nums,result,tempList,i+1);
            tempList.remove(tempList.size()-1);
        }
    }
}

---

有重复数列的子集

问题描述：给定一个可能包含重复数的集合nums，返回所有可能的子集合(包含集合本身和空集)。
比如，如果nums = [1,2,2], 结果是：

[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

解决代码采用深度优先遍历(dfs)：

class Solution{
    public List<List<Integer>> subsetsWithDup(int[] nums) {
         List<List<Integer>> result=new ArrayList<>();
         List<Integer> tempList=new ArrayList<>();
         Arrays.sort(nums);
         dspSubsetsWithDup(nums,result,tempList,0);
         return result;
     }

    private void dspSubsetsWithDup(int[] nums, List<List<Integer>> result, List<Integer> tempList, int start)
    {
      result.add(new ArrayList<>(tempList));
      for(int i=start;i<nums.length;i++)
      {
          if(i==start || i>start && nums[i]!=nums[i-1]){
              tempList.add(nums[i]);
              dspSubsetsWithDup(nums,result,tempList,i+1);
              tempList.remove(tempList.size()-1);
          }
      }
    }
}

---

无重复数列的排列

问题描述：给定一个无重复数的集合nums，返回所有可能的排列。
比如，如果nums = [1,2,3], 结果是：

[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

解决代码采用深度优先遍历(dfs)：

class Solution{
   public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        List<Integer> tempList=new ArrayList<>();
        if(nums==null || nums.length==0)
            return result;
        dspPermute(nums,result,tempList);
        return result;
    }

    private void dspPermute(int[] nums, List<List<Integer>> result, List<Integer> tempList)
    {
        if(tempList.size()==nums.length)
            result.add(new ArrayList<>(tempList));
        else{
            for(int i=0;i<nums.length;i++){
                if(tempList.contains(nums[i])) continue;
                tempList.add(nums[i]);
                dspPermute(nums,result,tempList);
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

---

有重复数列的排列

问题描述：给定一个可能包含重复数的集合nums，返回所有可能的排列。
比如，如果nums = [1,1,2], 结果是：

[
  [1,1,2],
  [1,2,1],
  [2,1,1]
]

解决代码采用深度优先遍历(dfs)：

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        List<List<Integer>> result=new ArrayList<>();
        List<Integer> tempList=new ArrayList<>();
        boolean visited[]=new boolean[nums.length];
        Arrays.sort(nums);
        permuteUnique(nums,result,tempList,visited);
        return result;
    }

    private void permuteUnique(int[] nums,List<List<Integer>> result,List<Integer> tempList,boolean[] visited)
    {
        if(tempList.size()==nums.length)
            result.add(new ArrayList<>(tempList));
        else{
            for(int i=0;i<nums.length;i++){
                if(visited[i] || (i>0 && nums[i]==nums[i-1] && !visited[i-1])) continue;
                visited[i]=true;
                tempList.add(nums[i]);
                permuteUnique(nums,result,tempList,visited);
                tempList.remove(tempList.size()-1);
                visited[i]=false;
            }
        }
    }
}

---

组合数的和

问题描述：给定一个候选数的集合C（不包含重复数）和一个目标数字T，找出在集合C中数字的唯一组合使这些数字的和等于T。
注意：
- 所有的数字都是正整数（包含目标数字）
- 结果不能包含重复的组合
比如，给定候选数集合[2, 3, 6, 7]和目标数字7，
结果集是：

[
  [7],
  [2, 2, 3]
]

解决代码采用深度优先遍历(dfs)：

class Solution{
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<>();
        List<Integer> tempList=new ArrayList<>();
        if(candidates==null || candidates.length==0)
            return result;
        Arrays.sort(candidates);
        dfsCombination(candidates,result,tempList,target,0);
        return result;
    }

    private void dfsCombination(int[] candidates,List<List<Integer>> result,List<Integer> tempList,int target,int index){
        if(target<=0) {
            if (target == 0)
                result.add(new ArrayList<>(tempList));
        }else{
            for(int i=index;i<candidates.length;i++) {
                tempList.add(candidates[i]);
                dfsCombination(candidates,result,tempList,target-candidates[i],i);
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

---

组合数的和Ⅱ

问题描述：给定一个候选数的集合C（不包含重复数）和一个目标数字T，找出在集合C中数字的唯一组合使这些数字的和等于T。
集合中的数字在在组合时只能使用一次。
比如，给定候选数集合[10, 1, 2, 7, 6, 1, 5]和目标数字8，
结果集是：

[
  [1, 7],
  [1, 2, 5],
  [2, 6],
  [1, 1, 6]
]

解决代码采用深度优先遍历(dfs)：

class Solution {
     public List<List<Integer>> combinationSum2(int[] candidates, int target) {
        List<List<Integer>> result=new ArrayList<>();
        List<Integer> tempList=new ArrayList<>();
        if(candidates==null || candidates.length==0)
            return result;
        Arrays.sort(candidates);
        dfsCombinationSum2(candidates,result,tempList,target,0);
        return result;
    }

    private void dfsCombinationSum2(int[] candidates,List<List<Integer>> result,List<Integer> tempList,int target,int index)
    {
        if(target<0) return;
        else if(target==0)
            result.add(new ArrayList<>(tempList));
        else{
            for(int i=index;i<candidates.length;i++){
                if(i>index && candidates[i]==candidates[i-1]) continue;
                tempList.add(candidates[i]);
                dfsCombinationSum2(candidates,result,tempList,target-candidates[i],i+1);
                tempList.remove(tempList.size()-1);
            }
        }
    }
}

---

回文分割

给定一个字符串s，分割这个字符转，让这次分割得到的每一个子字符串都是回文字符串（对称）。
返回所有字符串s的回文分割。
比如，给定s=”aab”,
返回：

[
  ["aa","b"],
  ["a","a","b"]
]

解决代码采用深度优先遍历(dfs)：

class Solution {
     public List<List<String>> partition(String s) {
        List<List<String>> result=new ArrayList<>();
        List<String> tempList=new ArrayList<>();
        if(s==null || s.length()==0)
            return result;
        dfsPartition(s,result,tempList,0);
        return result;
    }

    private void dfsPartition(String s, List<List<String>> result, List<String> tempList, int index)
    {
        if(index==s.length())
            result.add(new ArrayList<>(tempList));
        else{
            for(int i=index;i<s.length();i++){
                if(isPalindrome(s,index,i)){
                    tempList.add(s.substring(index,i+1));
                    dfsPartition(s,result,tempList,i+1);
                    tempList.remove(tempList.size()-1);
                }
            }
        }
    }

    private boolean isPalindrome(String s,int low,int high)
    {
        while (low<high){
            if(s.charAt(low++)!=s.charAt(high--)) return false;
        }
        return true;
    }
}