排列组合和回溯算法-面试题
排列组合
排列组合通常用于在字符串或序列的排列和组合中，其特点是固定的解法和统一的代码风格。通常有两种方法：第一种是类似动态规划的分期摊还的方式，即保存中间结果，依次附上新元素，产生新的中间结果；第二种是递归法，通常是在递归函数里，使用for循环，遍历所有排列或组合的可能，然后在for循环语句内调用递归函数。
回溯
回溯算法也叫试探法，它是一种系统地搜索问题的解的方法。回溯算法的基本思想是：从一条路往前走，能进则进，不能进则退回来
，换一条路再试。用回溯算法解决问题的一般步骤为：
1、定义一个解空间，它包含问题的解。
2、利用适于搜索的方法组织解空间。
3、利用深度优先法搜索解空间。
4、利用限界函数避免移动到不可能产生解的子空间。
问题的解空间通常是在搜索问题的解的过程中动态产生的，这是回溯算法的一个重要特性。
，换一条路再试。用回溯算法解决问题的一般步骤为：
1、定义一个解空间，它包含问题的解。
2、利用适于搜索的方法组织解空间。
3、利用深度优先法搜索解空间。
4、利用限界函数避免移动到不可能产生解的子空间。
问题的解空间通常是在搜索问题的解的过程中动态产生的，这是回溯算法的一个重要特性。
方案一
对于长度为n的数组，我们需要依次确认每个位置上的元素。初始问题：从a[0]开始依次确认n个元素。如果我们确认a[0]之后，问题就变成从a[1]开始从剩余元素中选择一个元素确定a[1]。每次选择都有多种可能性，我们依次尝试（尝试后还原），并递归解决选择之后的产生的子问题，并定义出口。
public List> permute(int[] nums) {
ArrayList numsArray=new ArrayList();
for(int i:nums){
numsArray.add(i);
}
Collections.sort(numsArray);
List> res=new ArrayList>();
solve(res,numsArray,0);
return res;
}
private void solve(List> res,ArrayList nums,int index){
if(index>=nums.size()){
List permutation=new ArrayList(nums);
res.add(permutation); }
for(int i=index;i<=nums.size()-1;i++){
Collections.swap(nums, i, index);
solve(res,nums,index+1);
Collections.swap(nums, i, index);
}
}
用一个标记数组标记元素是否已经使用过，每次从剩余元素中尝试添加新元素到临时解中，当没有新的元素可添加时，临时解就为最终的一个解。此方案比方法一要更加直观。
public List> permute(int[] nums) {
ArrayList numsArray=new ArrayList();
for(int i:nums){
numsArray.add(i);
}
boolean[] used=new boolean[numsArray.size()];
Collections.sort(numsArray);
List> res=new ArrayList>();
ArrayList subSet=new ArrayList();
solve(res,numsArray,subSet,used);
return res;
}
private void solve(List> res,ArrayList nums,ArrayList subSet,boolean[] used){
if(subSet.size()==nums.size()){
ArrayList clone=new ArrayList(subSet);
res.add(clone);
return;
}
for(int i=0;i 
分析
相比上一个问题，元素可以重复，因此我们应该在算法中增加相应的判断来避免重复结果。例如元素[1,2,2,3,3,3]，在选择添加第一个新元素时，只考虑第一个1，第一个2，第一个3。注：仔细理清楚避免重复的逻辑，后面会多次用到。
public List> permuteUnique(int[] nums) {
ArrayList numsArray=new ArrayList();
for(int i:nums){
numsArray.add(i);
}
boolean[] used=new boolean[numsArray.size()];
Collections.sort(numsArray);
List> res=new ArrayList>();
ArrayList subSet=new ArrayList();
solve(res,numsArray,subSet,used);
return res;
}
private void solve(List> res,ArrayList nums,ArrayList subSet,boolean[] used){
if(subSet.size()==nums.size()){
ArrayList clone=new ArrayList(subSet);
res.add(clone);
return;
}
for(int i=0;i0&&!used[i-1]&&nums.get(i).equals(nums.get(i-1)))) continue;
subSet.add(nums.get(i));//加入新元素，并递归调用下一个元素
used[i]=true;
solve(res,nums,subSet,used);
subSet.remove(subSet.size()-1);//还原
used[i]=false;
}
} 
分析
我们将排列看成一个n位整数，下一个排列组合就是当前整数增加并且保证增量最小。为了保证增量最小，因此我们需要保证变化的范围尽量限制在低位。因此我们采用如下策略：
1、从后往前寻找第一组相邻元素a[i]
2、为了让变化范围最小化，我们需要将a[i]后面“大于a[i]且最接近a[i]的元素”与a[i]交换，交换后的a[i]后面依然是递减序列，为了进一步减小增量，我们将a[i]后面的元素逆序，得到如下算法。
public void nextPermutation(int[] nums) {
int index=nums.length-1;
//寻找第一对非递减序列
while(index-1>=0&&nums[index-1]>=nums[index]) index--;
if(index==0){
reverse(nums,0,nums.length-1);
return;
}
int smallerIndex=index-1,change=index;
//寻找恰当交换元素
while(change+1nums[smallerIndex])change++;
int t=nums[smallerIndex];nums[smallerIndex]=nums[change];nums[change]=t;
reverse(nums,index,nums.length-1);
}
private void reverse(int[] nums,int begin,int end){
int t;
while(begin 
分析
方案一：我们可以采用暴力枚举，调用k-1次nextPermutation。我们只需要第k个排列，但是我们却计算了前k个，比较耗时。
方案二：n个不同元素的排列种数位n!，我们将[1,2,3,4,5]变换成[2,1,3,4,5]需要多少次变换呢？答案是4！次。
证明：[1,2,3,4,5]变换成[1,5,4,3,2]需要4！-1次，[1,5,4,3,2]变换成[2,1,3,4,5]需要一次，共4！次。
同理：[2,1,3,4,5]变换成[2,3,1,4,5]需要经过3！次变换。
综上所述：将a[i]与“其后大于a[i]且最接近a[i]的元素”进行交换，即代表（n-i）！，1<=i<=n(在这里下标从1开始)次变换。
因此第k个排列，即为初始排列变换k-1次。得到如下算法
public String getPermutation(int n, int k) {
int[] arr=new int[n+1];
for(int i=1;i<=n;i++){
arr[i]=i;
}
k=(k-1)%factorial(n);
int index=1;
while(k>0){
if(k>=factorial(n-index)){
int change=index+1;
while(arr[change]
分析
我们采用分期摊还的方法，从数字字符串的第一个字符开始扫描，记录之前数字产生的所有组合，然后将当前数字映射的字符附加到之前产生的所有组合中，产生新的结果集。
public List letterCombinations(String digits) {
String[] strMap={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
ArrayList res=new ArrayList();
if(digits.equals("")||digits==null) return res;
res.add("");
for(int i=0;i t=new ArrayList();
for(int j=0;j 
分析
类似全排列，采用分期摊还方法，不过需要注意过滤重复组合。
public List> combine(int n, int k) {
List> res=new ArrayList>();
int[] nums=new int[n];
ArrayList r=new ArrayList();
boolean[] used=new boolean[n];
for(int i=0;i> res,ArrayList r,int[] nums,int k,boolean[] used){
if(r.size()==k){
ArrayList clone=new ArrayList(r);
res.add(clone);
return ;
}
int index=r.size();
for(int i=index;i 
分析
先将候选数组排序，我们将问题理解为从a[0]开始选择整数，使得和为target。如果我们选择了a[0]，那么问题变换成从a[0]开始选择整数，使得和为target-a[0]（因为可以重复选择）。如果没有选择a[0]，那么问题变换为从a[1]开始选择整数，使得和为target。因此得到如下递归解法：
public List> combinationSum(int[] candidates, int target) {
Arrays.sort(candidates);
List> res=new ArrayList>();
ArrayList r=new ArrayList();
solve(res,r,candidates,target,0);
return res;
}
public void solve(List> res,ArrayList r,int[] candidates,int target,int index){
if(target==0){
ArrayList clone=new ArrayList(r);
res.add(clone);
return;
}
if(index>=candidates.length||target 
public List> combinationSum2(int[] candidates, int target) {
Arrays.sort(candidates);
List> res=new ArrayList>();
ArrayList r=new ArrayList();
solve(res,r,candidates,target,0);
return res;
}
public void solve(List> res,ArrayList r,int[] candidates,int target,int index){
if(target==0){
ArrayList clone=new ArrayList(r);
res.add(clone);
return;
}
if(index>=candidates.length||target 
public List> combinationSum3(int k, int n) {
List> res=new ArrayList>();
ArrayList sub=new ArrayList();
solve(res,sub,k,n,1);
return res;
}
private void solve(List> res,ArrayList sub,int k,int n,int start){
if(sub.size()==k&&n==0){
ArrayList clone=new ArrayList(sub);
res.add(clone);
return;
}
if(n<0||start==10||(sub.size()==k&&n!=0)){
return;
}
//选择当前元素
sub.add(start);
solve(res,sub,k,n-start,start+1);
sub.remove(sub.size()-1);
//不选择当前元素
solve(res,sub,k,n,start+1);
} 
分析
对于合法的括号表达式，从左边往右边看时，每时每刻左括号的个数大于等于右括号的个数。
我们可以将问题看成是对于长为2 n的字符串，从第一个位置开始我们选择'('或者')'，同时要保证左括号个数永远大于右边括号的个数，并且最终左括号和右括号的个数都等于n。当我们做完所有的选择就得到了合法的括号表达式。
因此得到如下递归解法：
public List generateParenthesis(int n) {
List res=new ArrayList();
if(n==0){
res.add("");
return res;
}
StringBuilder r=new StringBuilder();
solve(n,0,0,res,r);
return res;
}
private void solve(int n,int left,int right,List res,StringBuilder r){
if(r.length()==2*n){
System.out.println(r.toString());
res.add(r.toString());
return;
}
if(left 
分析
采用分期摊还的方法。
public List> subsets(int[] nums) {
List> res=new ArrayList>();
res.add(new ArrayList());
for(int i=0;i> t=new ArrayList>();
for(List r:res){
t.add(r);
ArrayList clone=new ArrayList(r);
clone.add(nums[i]);
t.add(clone);
}
res=t;
}
return res;
} 
分析
因为元素可以重复，并且需要过滤重复的集合，我们需要对生成子集的过程进行进一步的控制。我们将问题理解为，从a[0]开始求所有的子集，该问题可以分为两个问题1、选择a[0]，从a[1]开始求所有子集并对每个子集加上a[0]；2从a[1]开始求所有的子集。因此得到如下递归解法。
注：由于需要消除重复子集，因此我们在选择当前元素a[i]时，如果a[i-1]等于a[i]且我们没有选择，我们就必定不能选择a[i]。
public List> subsetsWithDup(int[] nums) {
Arrays.sort(nums);
boolean[] used=new boolean[nums.length];
List> res=new ArrayList>();
ArrayList sub=new ArrayList();
solve(res,0,sub,nums,used);
return res;
}
private void solve(List> res,int start,ArrayList sub,int[] nums,boolean[] used){
if(start==nums.length){
ArrayList clone=new ArrayList(sub);
res.add(clone);
return;
}
//选择当前元素
if(start>0&&nums[start]==nums[start-1]&&!used[start-1]){
//do nothing
}else{
used[start]=true;
sub.add(nums[start]);
solve(res,start+1,sub,nums,used);
sub.remove(sub.size()-1);
used[start]=false;
}
//不选择当前元素
solve(res,start+1,sub,nums,used);
} 
分析
我们从每一个位置开始回溯，并标记元素是否已经使用过。
public boolean exist(char[][] board, String word) {
boolean used[][]=new boolean[board.length][board[0].length];
for(int i=0;i思考：如果我们有很多的单词需要查找时，如何避免重复的搜索过程呢？我们可以先建立trie树(单词查找树)，然后对trie中的不同路径进行搜索。见leetcode 212 Word Search II
分析
对于每一个字符，我们首先找到以该字符为首的回文字符串，然后我们依次其中的回文传，并递归求解选择后的问题。
public List> partition(String s) {
List> res=new ArrayList>();
List sub=new ArrayList();
solve(res,sub,s,0);
return res;
}
private void solve(List> res,List sub,String s,int start){
if(start==s.length()){
List clone=new ArrayList(sub);
res.add(clone);
return;
}
List ends=new ArrayList();
for(int i=start;i 
分析
对于每个待填的空位我们可以尝试1-9所有可能性，如果解决了问题就直接结束。如果所有尝试都没能解决问题，就需要调整之前已经确认的空位，回溯到调整上一个空位的值。因此，此处调用子问题时必须返回是否能够解决问题的转态，以便回溯。
public void solveSudoku(char[][] board) {
ArrayList> emptyLocations=
new ArrayList>();
for(int row=0;row<9;row++){
for(int col=0;col<9;col++){
if(board[row][col]=='.'){
ArrayList location=new ArrayList();
location.add(row);location.add(col);
emptyLocations.add(location);
}
}
}
solve(board,0,emptyLocations);
}
private boolean solve(char[][] board,int index,ArrayList> emptyLocations){
if(index==emptyLocations.size()){
return true;
}
ArrayList location=emptyLocations.get(index);
int row=location.get(0),col=location.get(1);
for(char c='1';c<='9';c++){
if(isValid(board,row,col,c)){
board[row][col]=c;
if(solve(board,index+1,emptyLocations)){
return true;
}else{
board[row][col]='.';
}
}
}
return false;
}
public boolean isValid(char[][] board,int row,int col,char c){
//验证行
for(int i=0;i<9;i++){
if(board[row][i]==c)
return false;
}
//验证列
for(int i=0;i<9;i++){
if(board[i][col]==c)
return false;
}
//验证3*3格子
for(int i=(row/3)*3;i<(row/3)*3+3;i++){
for(int j=(col/3)*3;j<(col/3)*3+3;j++){
if(board[i][j]==c)
return false;
}
}
return true;
} 
分析
我们知道N皇后问题通常采用回溯法求解。
方案一
对于每行每个位置进行尝试，并判断是否合法。
public List> solveNQueens(int n) {
ArrayList locations=new ArrayList();
List> res=new ArrayList>();
solve(res,locations,n);
return res;
}
private void solve(List> res,ArrayList locations,int n){
if(n==locations.size()){
addRes(res,locations);
return;
}
for(int i=0;i locations,int location){
for(int i=0;i> res,ArrayList locations){
List r=new ArrayList();
for(int i=0;i
方案二
我们将每行中皇后的位置用1-N表示，共N行。这1-N的任意排列，即可满足任意两个皇后不在同行或同列，我们只需要对产生的全排列进行验证即可。
public List> solveNQueens(int n) {
int[] locations=new int[n+1];
for(int i=1;i<=n;i++){
locations[i]=i;
}
List> res=new ArrayList>();
solve(res,locations,1);
return res;
}
private void solve(List> res,int[] locations,int index){
if(index==locations.length){
addRes(res,locations);
return;
}
for(int i=index;i<=locations.length-1;i++){
if(isValid(locations,index,i)){
int t=locations[index];locations[index]=locations[i];locations[i]=t;
solve(res,locations,index+1);
t=locations[index];locations[index]=locations[i];locations[i]=t;
}
}
}
private boolean isValid(int[] locations,int index,int change){
for(int i=1;i> res,int[] locations){
List r=new ArrayList();
for(int i=1;i<=locations.length-1;i++){
StringBuilder builder=new StringBuilder();
for(int j=1;j<=locations.length-1;j++){
if(locations[i]==j){
builder.append("Q");
}else{
builder.append(".");
}
}
r.add(builder.toString());
}
res.add(r);
} 
注：在统计结果数量时，由于Java本身都是按值传递参数的（对于对象传递的是地址值），因此我们不用用int类型统计结果数量，同时由于Integer是不可变的，因此也不能使用Integer。这里我采用Integer容器来统计数量，此外还可以利用AtomicInteger原子整型或自定义引用类型来进行统计，也可以在方法调用中返回结果数量。如有更好的方法忘指教，谢谢！！
public int totalNQueens(int n) {
ArrayList locations=new ArrayList();
Stack count=new Stack();
count.add(new Integer(0));
solve(locations,n,count);
return count.get(0);
}
private void solve(ArrayList locations,int n,Stack count){
if(n==locations.size()){
count.push(new Integer(count.pop()+1));
return;
}
for(int i=0;i locations,int location){
for(int i=0;i