一文搞懂全排列、組合、子集問題(建議收藏)

前言

Hello，你們好，我是bigsai，long time no see！在刷題和麪試過程當中，咱們常常遇到一些排列組合類的問題，而全排列、組合、子集等問題更是很是經典問題。本篇文章就帶你完全搞懂全排列！

求全排列？

全排列即：n個元素取n個元素(全部元素)的全部排列組合狀況。

求組合？

組合即：n個元素取m個元素的全部組合狀況(非排列)。

求子集？

子集即：n個元素的全部子集(全部可能的組合狀況)。

總的來講全排列數值個數是全部元素，不一樣的是排列順序；而組合是選取固定個數的組合狀況(不看排列)；子集是對組合拓展，全部可能的組合狀況(同不考慮排列)。

固然，這三種問題，有類似之處又略有所不一樣，咱們接觸到的全排列可能更多，因此你能夠把組合和子集問題認爲是全排列的拓展變形。且問題可能會遇到待處理字符是否有重複的狀況。採起不一樣的策略去去重也是至關關鍵和重要的！在各個問題的具體求解上方法可能很多，在全排列上最流行的就是鄰里互換法和回溯法，而其餘的組合和子集問題是經典回溯問題。而本篇最重要和基礎的就是要掌握這兩種方法實現的無重複全排列，其餘的都是基於這個進行變換和拓展。

全排列問題

全排列，元素總數爲最大，不一樣是排列的順序。

無重複序列的全排列

這個問題恰好在力扣46題是原題的，你們學完能夠去a試試。

問題描述：

給定一個 沒有重複 數字的序列，返回其全部可能的全排列。

示例：

輸入: [1,2,3]
輸出:
[
  [1,2,3],
  [1,3,2],
  [2,1,3],
  [2,3,1],
  [3,1,2],
  [3,2,1]
]

回溯法實現無重複全排列

回溯算法用來解決搜索問題，而全排列恰好也是一種搜索問題，先回顧一下什麼是回溯算法：

回溯算法實際上一個相似枚舉的搜索嘗試過程，主要是在搜索嘗試過程當中尋找問題的解，當發現已不知足求解條件時，就「回溯」返回，嘗試別的路徑.

而全排列恰好可使用試探的方法去枚舉全部中可能性。一個長度爲n的序列或者集合。它的全部排列組合的可能性共有n！種。具體的試探策略以下：

1. 從待選集合中選取第一個元素(共有n種狀況)，並標記該元素已經被使用不能再使用。
2. 在步驟1的基礎上進行遞歸到下一層，從剩餘n-1個元素中按照1的方法找到一個元素並標記，繼續向下遞歸。
3. 當全部元素被標記後，順序收集被標記的元素存儲到結果中，當前層遞歸結束，回到上一層(同時將當前層標記的元素清除標記)。這樣一直執行到最後。

回溯的流程若是從僞代碼流程大體爲這樣：

遞歸函數：
  若是集合全部元素被標記：
      將臨時儲存添加到結果集中
  不然：
      從集合中未標記的元素中選取一個存儲到臨時集合中
      標記該元素被使用
      下一層遞歸函數
      (這層遞歸結束)標記該元素未被使用

若是用序列 1 2 3 4來表示這麼回溯的一個過程，能夠用這張圖來顯示：

用代碼來實現思路也是比較多的，須要一個List去存儲臨時結果是頗有必要的，可是對於原集合咱們標記也有兩種處理思路，第一種是使用List存儲集合，使用過就移除而後遞歸下一層，遞歸完畢後再添加到原來位置。另外一種思路就是使用固定數組存儲，使用過對應位置使用一個boolean數組對應位置標記一下，遞歸結束後再還原。由於List頻繁查找插入刪除效率通常比較低，因此咱們通常使用一個boolean數組去標記該位置元素是否被使用。

具體實現的代碼爲：

List<List<Integer>> list;
public List<List<Integer>> permuteUnique(int[] nums) {
    list=new ArrayList<List<Integer>>();//最終的結果
    List<Integer> team=new ArrayList<Integer>();//回溯過程收集元素
    boolean jud[]=new boolean[nums.length];//用來標記
    dfs(jud, nums, team, 0);
    return list;
}
private  void dfs(boolean[] jud, int[] nums, List<Integer> team, int index) {
    int len = nums.length;
    if (index == len)// 中止
    {
        list.add(new ArrayList<Integer>(team));
    } else
        for (int i = 0; i < len; i++) {
            if (jud[i]) //當前數字被用過 當前即不可用
                continue;
            team.add(nums[i]);
            jud[i]=true;//標記該元素被使用
            dfs(jud, nums, team, index + 1);
            jud[i] = false;// 還原
            team.remove(index);//將結果移除臨時集合
        }
}

修改一下輸出的結果和上面思惟導圖也是一致的：

鄰里互換法實現無重複全排列

回溯的測試是試探性填充，是對每一個位置進行單獨考慮賦值。而鄰里互換的方法雖然是也是遞歸實現的，可是他是一種基於交換的策略和思路。而理解起來也是很是簡單，鄰里互換的思路是從左向右進行考慮。

由於序列是沒有重複的，咱們開始將數組分紅兩個部分：暫時肯定部分和未肯定部分。開始的時候均是未肯定部分，咱們須要妥善處理的就是未肯定部分。在未肯定部分的序列中，咱們須要讓後面未肯定的每一位都有機會處在未肯定的首位，因此未肯定部分的第一個元素就要和每個依次進行交換(包括本身)，交換完成以後再向下進行遞歸求解其餘的可能性，求解完畢以後要交換回來(還原)再和後面的進行交換。這樣當遞歸進行到最後一層的時候就將數組的值添加到結果集中。若是不理解能夠參考下圖進行理解：

實現代碼爲：

class Solution {
     public List<List<Integer>> permute(int[] nums) {
        List<List<Integer>>list=new ArrayList<List<Integer>>();
        arrange(nums,0,nums.length-1,list);
        return list;
     }

    private void arrange(int[] nums, int start, int end, List<List<Integer>> list) {
          if(start==end)//到最後一個 添加到結果中
          {
              List<Integer>list2=new ArrayList<Integer>();
              for(int a:nums)
              {
                  list2.add(a);
              }
              list.add(list2);
          }
          for(int i=start;i<=end;i++)//未肯定部分開始交換
          {
              swap(nums,i,start);
              arrange(nums, start+1, end, list);
              swap(nums, i, start);//還原
          }
        
    }
    private void swap(int[] nums, int i, int j) {
        int team=nums[i];
        nums[i]=nums[j];
        nums[j]=team;
    }
}

那麼鄰里互換和回溯求解的全排列有什麼區別呢?首先回溯法求得的全排列若是這個序列有序獲得的結果是字典序的，由於其策略是填充，先小後大有序，而鄰里互換沒有這個特徵。其次鄰里互換在這種狀況下的效率要高於回溯算法的，雖然量級差很少可是回溯算法須要維護一個集合頻繁增刪等佔用必定的資源。

有重複序列的全排列

有重複對應的是力扣第47題 ，題目描述爲：

給定一個可包含重複數字的序列 nums ， 按任意順序 返回全部不重複的全排列。

示例 1：

輸入：nums = [1,1,2]
輸出：
[[1,1,2],
 [1,2,1],
 [2,1,1]]

示例 2：

輸入：nums = [1,2,3]
輸出：[[1,2,3],[1,3,2],[2,1,3],[2,3,1],[3,1,2],[3,2,1]]

提示：

1 <= nums.length <= 8
-10 <= nums[i] <= 10

這個和上面不重複的全排列略有不一樣，這個輸入數組中可能包含重複的序列，咱們怎麼樣採起合適的策略去重複纔是相當重要的。咱們一樣針對回溯和鄰里互換兩種方法進行分析。

回溯剪枝法
由於回溯完整的比直接遞歸慢，因此剛開始並無考慮使用回溯算法，可是這裏用回溯剪枝相比遞歸鄰里互換方法更好一些，對於不使用哈希去重的方法，首先進行排序預處理是沒有懸念的，而回溯法去重的關鍵就是避免相同的數字由於相對次序問題形成重複，因此在這裏相同數字在使用上相對位置必須不變，而具體剪枝條的規則以下：

• 先對序列進行排序

• 試探性將數據放到當前位置

  • 若是當前位置數字已經被使用，那麼不可以使用
  • 若是當前數字和前一個相等可是前一個沒有被使用，那麼當前不能使用，須要使用前一個數字。

思路很簡單，實現起來也很簡單：

List<List<Integer>> list;
public List<List<Integer>> permuteUnique(int[] nums) {
    list=new ArrayList<List<Integer>>();
    List<Integer> team=new ArrayList<Integer>();
    boolean jud[]=new boolean[nums.length];
    Arrays.sort(nums);
    dfs(jud, nums, team, 0);
    return list;
}
private  void dfs(boolean[] jud, int[] nums, List<Integer> team, int index) {
    // TODO Auto-generated method stub
    int len = nums.length;
    if (index == len)// 中止
    {
        list.add(new ArrayList<Integer>(team));
    } else
        for (int i = 0; i < len; i++) {
            if (jud[i]||(i>0&&nums[i]==nums[i-1]&&!jud[i-1])) //當前數字被用過 或者前一個相等的還沒用，當前即不可用
                continue;
              team.add(nums[i]);
              jud[i]=true;
              dfs(jud, nums, team, index + 1);
            jud[i] = false;// 還原
            team.remove(index);
        }
}

鄰里互換法

咱們在執行遞歸全排列的時候，主要考的是要把重複的狀況搞下去，鄰里互換又要怎麼去重呢？

使用HashSet這種方式這裏就不討論啦，咱們在進行交換swap的時候從前日後，前面的肯定以後就不會在動，因此咱們要慎重考慮和誰交換。好比1 1 2 3第一個數有三種狀況而不是四種狀況(兩個1 1 2 3爲一個結果)：

1 1 2 3 // 0 0位置交換
2 1 1 3 // 0 2位置交換
3 1 2 1 // 0 3位置交換

另外好比3 1 1序列,3和本身交換，和後面兩個1只能和其中一個進行交換，咱們這裏能夠約定和第一個出現的進行交換，咱們看一個圖解部分過程：

因此，當咱們從一個index開始的時候要記住如下的規則：同一個數只交換一次(包括值等於本身的數)。在判斷後面值是否出現的時候，你能夠遍歷，也可使用hashSet().固然這種方法的痛點就是判斷後面出現的數字效率較低。因此在可能重複的狀況這種方法效率通常般。

具體實現的代碼爲：

public List<List<Integer>> permuteUnique(int[] nums) {
         List<List<Integer>> list=new ArrayList<List<Integer>>();
         arrange(nums, 0, nums.length-1, list);
         return list;
     }

private void arrange(int[] nums, int start, int end, List<List<Integer>> list) {
      if(start==end)
      {
          List<Integer>list2=new ArrayList<Integer>();
          for(int a:nums)
          {
              list2.add(a);
          }
          list.add(list2);
      }
      Set<Integer>set=new HashSet<Integer>();      
      for(int i=start;i<=end;i++)
      {
          if(set.contains(nums[i]))
              continue;
             set.add(nums[i]);             
          swap(nums,i,start);
          arrange(nums, start+1, end, list);
          swap(nums, i, start);
      }    
}
private void swap(int[] nums, int i, int j) {
    int team=nums[i];
    nums[i]=nums[j];
    nums[j]=team;
}

組合問題

組合問題能夠認爲是全排列的變種，問題描述（力扣77題）:

給定兩個整數 n 和 k，返回 1 ... n 中全部可能的 k 個數的組合。

示例:

輸入: n = 4, k = 2
輸出:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

分析：

這個問題經典回溯問題。組合須要記住只看元素而不看元素的順序，好比a b和b a 是同一個組合。要避免這樣的重複是核心，而避免這樣的重複，須要藉助一個int類型保存當前選擇元素的位置，下次只能遍歷選取下標位置後面的數字，而k個數，能夠經過一個數字類型來記錄回溯到當前層處理數字的個數來控制。

具體實現也很容易，須要建立一個數組儲存對應數字，用boolean數組判斷對應位置數字是否使用，這裏就不用List存儲數字了，最後經過判斷boolean數組將數值添加到結果中也是可行的。實現代碼爲：

class Solution { 
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>> valueList=new ArrayList<List<Integer>>();//結果
        int num[]=new int[n];//數組存儲1-n
        boolean jud[]=new boolean[n];//用於判斷是否使用
        for(int i=0;i<n;i++)
        {
            num[i]=i+1;
        }
    
        List<Integer>team=new ArrayList<Integer>();
        dfs(num,-1,k,valueList,jud,n);
        return valueList;
    }
    private void dfs(int[] num,int index, int count,List<List<Integer>> valueList,boolean jud[],int n) {
        if(count==0)//k個元素滿
        {
            List<Integer>list=new ArrayList<Integer>();
            for(int i=0;i<n;i++)
            {
                if (jud[i]) {
                    list.add(i+1);
                }
            }
            valueList.add(list);
        }
        else {
            for(int i=index+1;i<n;i++)//只能在index後遍歷 回溯向下
            {
                jud[i]=true;
                dfs(num, i, count-1, valueList,jud,n);
                jud[i]=false;//還原
            
            }
        }    
    }
}

子集

子集問題和組合有些類似。這裏講解數組中無重複和有重複的兩種狀況。

無重複數組子集

問題描述(力扣78題)：

給你一個整數數組 nums ，數組中的元素 互不相同 。返回該數組全部可能的子集（冪集）。

解集 不能 包含重複的子集。你能夠按 任意順序 返回解集。

示例 1：

輸入：nums = [1,2,3]
輸出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]

示例 2：

輸入：nums = [0]
輸出：[[],[0]]

提示：

1 <= nums.length <= 10
-10 <= nums[i] <= 10
nums 中的全部元素 互不相同

子集和上面的組合有些類似，固然咱們不須要判斷有多少個，只須要按照組合回溯的策略遞歸進行到最後，每進行的一次遞歸函數都是一種狀況都要加入到結果中(由於採起的策略不會有重複的狀況)。

實現的代碼爲：

class Solution {
   public List<List<Integer>> subsets(int[] nums) {
        List<List<Integer>> valueList=new ArrayList<List<Integer>>();
        boolean jud[]=new boolean[nums.length];
        List<Integer>team=new ArrayList<Integer>();
        dfs(nums,-1,valueList,jud);
        return valueList;
    }
    private void dfs(int[] num,int index,List<List<Integer>> valueList,boolean jud[]) {
        {//每進行遞歸函數都要加入到結果中
            List<Integer>list=new ArrayList<Integer>();
            for(int i=0;i<num.length;i++)
            {
                if (jud[i]) {
                    list.add(num[i]);
                }
            }
            valueList.add(list);
        }
        {
            for(int i=index+1;i<num.length;i++)
            {
                jud[i]=true;
                dfs(num, i, valueList,jud);
                jud[i]=false;
            
            }
        }
    }
}

有重複數組子集

題目描述(力扣90題)：

給定一個可能包含重複元素的整數數組 nums，返回該數組全部可能的子集（冪集）。

說明：解集不能包含重複的子集。

示例:

輸入: [1,2,2]
輸出:
[
  [2],
  [1],
  [1,2,2],
  [2,2],
  [1,2],
  []
]

和上面無重複數組求子集不一樣的是這裏面可能會出現重複的元素。咱們須要在結果中過濾掉重複的元素。

首先，子集問題無疑是使用回溯法求得結果，首先分析若是序列沒有重複的狀況，咱們會藉助一個boolean[]數組標記使用過的元素和index表示當前的下標，在進行回溯的時候咱們只向後進行遞歸而且將枚舉到的那個元素boolean[index]置爲true(回來的時候復原)。每次遞歸收集boolean[]數組中true的元素爲其中一個子集。

而有重複元素的處理上，和前面全排列的處理很類似，首先進行排序，而後在進行遞歸處理的時候遇到相同元素只容許從第一位連續使用而不容許跳着使用，因此在遞歸向下時候須要判斷是否知足條件(第一個元素或和前一個不一樣或和前一個同且前一個已使用)，具體能夠參考這張圖：

實現代碼爲：

class Solution {
  public List<List<Integer>> subsetsWithDup(int[] nums) {
    Arrays.sort(nums);
    boolean jud[]=new boolean[nums.length];
    List<List<Integer>> valueList=new ArrayList<List<Integer>>();
    dfs(nums,-1,valueList,jud);
    return valueList;
  }

    private void dfs(int[] nums, int index, List<List<Integer>> valueList, boolean[] jud)   {
        // TODO Auto-generated method stub
        List<Integer>list=new ArrayList<Integer>();
        for(int i=0;i<nums.length;i++)
        {
            if (jud[i]) {
               list.add(nums[i]);
            }
        }
        valueList.add(list);
        for(int i=index+1;i<nums.length;i++)
        {//第一個元素 或 當前元素不和前面相同  或者相同且前面被使用了能夠繼續進行
            if((i==0)||(nums[i]!=nums[i-1])||(i>0&&jud[i-1]&&nums[i]==nums[i-1]))
            {
                jud[i]=true;
                dfs(nums, i, valueList,jud);
                jud[i]=false;
            }
        }
    }
}

結語

到這裏，本篇的全排列、組合、子集問題就介紹到這裏啦，尤爲要注意問題處理去重的思路和策略。固然和這相似的問題也是不少啦，多刷一刷就能夠很好的掌握，後面敬請期待！

我們下次再見！歡迎關注、點贊！

微信搜一搜：【bigsai】 獲取更多肝貨知識 春風十里，感謝有你