DFS和回溯专题
dfs:状态庞大方案很少。搜索是思想，可以用递归实现也可以用迭代实现。
例 leetcode17 电话号码的字母组合
递归
//对于每个字母遍历他包含的字符c，当前str=str+c，然后递归的遍历下一个字符。
//传参：全局变量字母表，当前str，当前索引，传入的字符串
//递归出口：index等于digits.length（index可以用temp的长度计算出来）
List<String> output = new ArrayList<String>();
String []stringList={
"","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public List<String> letterCombinations(String digits) {
if(digits.length()!=0)
helper("",digits);
return output;
}
public void helper(String tempStr,String digits){
int index=tempStr.length();
if(index==digits.length())
output.add(tempStr);
else{
for(int i=0;i<stringList[digits.charAt(index)-'1'].length();i++)
helper(tempStr+stringList[digits.charAt(index)-'1'].charAt(i),digits);
}
}
循环
样例2345678
state={}
for 每个数字
for c =每个数字的备选字母
for s= state中的所有字符串
s+=c；
state.add(s)；
在一个数组里存储
List<String> output = new ArrayList<String>();
String []stringList={
"","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public List<String> letterCombinations(String digits) {
if(digits.length()==0)
return output;
else{
for(int i=0;i<stringList[digits.charAt(0)-'1'].length();i++)
output.add(String.valueOf(stringList[digits.charAt(0)-'1'].charAt(i)));
for(int j= 1;j<digits.length();j++){
int length = output.size();
for(int i=0;i<stringList[digits.charAt(j)-'1'].length();i++){
for(int k = 0;k<length;k++){
String temp = output.get(k);
if(temp.length()==j){
temp+=stringList[digits.charAt(j)-'1'].charAt(i);
output.add(temp);
}
}
}
}
}
List<String> res = new ArrayList<String>();
for(String s:output){
if(s.length()==digits.length())
res.add(s);
}
return res;
}
不断创建新数组存储
List<String> output = new ArrayList<String>();
String []stringList={
"","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
public List<String> letterCombinations(String digits) {
if(digits.length()==0)
return output;
else{
for(int i=0;i<stringList[digits.charAt(0)-'1'].length();i++)
output.add(String.valueOf(stringList[digits.charAt(0)-'1'].charAt(i)));
for(int j= 1;j<digits.length();j++){
List<String>now = new ArrayList<String>();;
for(int i=0;i<stringList[digits.charAt(j)-'1'].length();i++){
for(String s:output){
s+=stringList[digits.charAt(j)-'1'].charAt(i);
now.add(s);
}
}
output=now;
}
}
return output;
}
例 leetcode79 单词搜索
1.枚举起点
2.从起点开始搜索下一个点的位置（不能往回走，用标记数组标一下）
3.在枚举过程中，要保证和目标单词匹配
4.需要有一个回溯的步骤，恢复操作前的初始状态。这里就是标记数组的复原。（恢复现场）
boolean res=false;
public boolean exist(char[][] board, String word) {
char [][]flag =new char[board.length][board[0].length];
for(int i=0;i<board.length;i++){
for(int j=0;j<board[0].length;j++){
if(word.charAt(0)==board[i][j]){
flag[i][j]=1;
helper(board,word,1,i,j,flag);
flag[i][j]=0;
}
}
}
return res;
}
public boolean helper(char[][]board,String word, int index,int i,int j,char[][]flag){
if(res==true)
return res;
if(index == word.length()){
res=true;
return res;
}
if(i-1>=0&&board[i-1][j]==word.charAt(index)&&flag[i-1][j]==0){
flag[i-1][j]=1;
helper(board,word,index+1,i-1,j,flag);
flag[i-1][j]=0;
}
if(i+1<board.length&&board[i+1][j]==word.charAt(index)&&flag[i+1][j]==0){
flag[i+1][j]=1;
helper(board,word,index+1,i+1,j,flag);
flag[i+1][j]=0;
}
if(j-1>=0&&board[i][j-1]==word.charAt(index)&&flag[i][j-1]==0){
flag[i][j-1]=1;
helper(board,word,index+1,i,j-1,flag);
flag[i][j-1]=0;
}
if(j+1<board[0].length&&board[i][j+1]==word.charAt(index)&&flag[i][j+1]==0){
flag[i][j+1]=1;
helper(board,word,index+1,i,j+1,flag);
flag[i][j+1]=0;
}
return res;
}
例 leetcode46 全排列I
1.搜索顺序，不重复且不遗漏
样例 1 2 3 。没有重复数字。
枚举每个位置上放哪个数。（或者枚举每个数放到哪个位置上）。
LinkedList<List<Integer>> res = new LinkedList<List<Integer>>();
ArrayList<Integer> temp= new ArrayList<Integer>();
int []nums;
boolean []flag;
public List<List<Integer>> permute(int[] nums) {
if(nums == null || nums.length == 0)
return res;
this.nums=nums;
flag=new boolean[nums.length];
helper();
return res;
}
public void helper() {
if(temp.size()==nums.length)
res.add((ArrayList<Integer>)temp.clone());
//这里一定要用clone()浅拷贝，不然后续修改就修改掉了。
//这里还有一个坑，就是声明时一定要写成ArrayList而不是List，否则无法使用clone()函数
else{
for(int i=0;i<nums.length;i++)
if(flag[i]==false){
flag[i]=true;
temp.add(nums[i]);
helper();
temp.remove(Integer.valueOf(nums[i]));
flag[i]=false;
}
}
}
例 leetcode47全排列II
存在重复数。
1.通过排序把相同的数放在一起
2.在遍历过程中重复数只使用一次
3.DFS的状态用temp的size隐含。temp的size代表了枚举到第几个数
4.暂时不考虑用set去重的方法。
public LinkedList<List<Integer>> res = new LinkedList<List<Integer>>();
public ArrayList<Integer> temp= new ArrayList<Integer>();
public int []nums;
public boolean []flag;
public List<List<Integer>> permuteUnique(int[] nums) {
if(nums == null || nums.length == 0)
return res;
this.nums=nums;
flag=new boolean[nums.length];
Arrays.sort(nums);
helper();
return res;
}
public void helper() {
int last=nums[0]-1;
if(temp.size()==nums.length)
res.add((ArrayList<Integer>)temp.clone());//浅拷贝
else{
for(int i=0;i<nums.length;i++)
//这里要保证的是每一轮对每个位置选出的数不重复。
if(flag[i]==false&&nums[i]!=last){
flag[i]=true;
temp.add(nums[i]);
last=nums[i];
int tail=temp.size();
helper();
//恢复现场
temp.remove(temp.size()-1);
flag[i]=false;
}
}
}
例 leetcode78 子集
枚举每个元素，选择进入子集或者不选择，更新状态继续DFS。通过索引记录状态，退出递归。
递归写法
public ArrayList<Integer>curr= new ArrayList<>();
public ArrayList<List<Integer>>result = new ArrayList<List<Integer>>();
public List<List<Integer>> subsets(int[] nums) {
if(nums==null||nums.length==0)
return result;
helper(nums,0);
return result;
}
public void helper(int []nums,int currIdx){
if(currIdx==nums.length){
result.add((ArrayList<Integer>)curr.clone());
}else{
helper(nums,currIdx+1);
curr.add(nums[currIdx]);
helper(nums,currIdx+1);
curr.remove(curr.size()-1);
}
}
迭代写法
二进制优化。对索引进行二进制表示。
样例 1 2 3
000表示空集，001表示第一个元素…111表示全集{1 2 3}。
1.遍历0~2的N次方，对应各个子集。
2.利用移位和逻辑运算，把二进制位为1对应位置的nums[j]填入curr。
3.把curr写入ress
public ArrayList<List<Integer>>result = new ArrayList<List<Integer>>();
public List<List<Integer>> subsets(int[] nums) {
if(nums==null||nums.length==0)
return result;
for(int i=0;i< 1<<nums.length;i++){
ArrayList<Integer>curr= new ArrayList<>();
for(int j=0;j<nums.length;j++)
if(((i>>j)&1)==1)
curr.add(nums[j]);
result.add(curr);
}
return result;
}
例 leetcode 90 子集II
存在重复数字
public ArrayList<Integer>curr= new ArrayList<>();
public ArrayList<List<Integer>>result = new ArrayList<List<Integer>>();
public List<List<Integer>> subsetsWithDup(int[] nums) {
if(nums==null||nums.length==0)
return result;
Arrays.sort(nums);//排序 相同的放在一起
helper(nums,0);//用索引表示状态
return result;
}
public void helper(int []nums,int currIdx){
if(currIdx==nums.length)
result.add((ArrayList<Integer>)curr.clone());
else{
int k=0;
//双指针计数当前索引处值的个数（最少是1）
while(currIdx+k<nums.length&&nums[currIdx+k]==nums[currIdx])
k++;
//放入0--k个
for(int i=0;i<=k;i++){
helper(nums,currIdx+k);//先递归进去，可以把空包含在内。
curr.add(nums[currIdx]);
}
for(int i=0;i<=k;i++)
curr.remove(curr.size()-1);
}
}
例 leetcode216组合总和III
找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
代码
public List<List<Integer>> res=new ArrayList<>();
public ArrayList<Integer> temp = new ArrayList<>();
public List<List<Integer>> combinationSum3(int k, int n) {
int sum=0;
helper(k,1,n,sum);
return res;
}
public void helper(int k,int index,int n,int sum){
if(k==0||index>9){
if(sum==n&&k==0)
res.add((ArrayList<Integer>)temp.clone());
return ;
}
for(int i=index;i<=9;i++){
temp.add(i);
helper(k-1,i+1,n,sum+i);
temp.remove(temp.size()-1);
}
}
例 leetcode52 N皇后II
核心还是枚举顺序！
枚举每行的皇后在每列的情况，行默认不同，则值考虑列和对角线是否可用。
2N-1条对角线，2N-1条反对角线。（y=x+b，y=-x+b）
转换为数组索引x+y x-y+n。避免出现负数。
public int n,res=0;
public boolean [] d,ud,col;
public int totalNQueens(int n) {
//用递归次数代表行
//还需要记录列的情况和两个对角线的情况。
this.n=n;
d=new boolean[2*n];
ud= new boolean[2*n];
col = new boolean[n];
helper(0);
return res;
}
public void helper(int row){
if(row ==n){
res++;
return ;
}
for(int i=0;i<n;i++){
if(col[i]==false&&d[i+row]==false&&ud[row -i+n]==false){
col[i]=true;
d[i+row]=true;
ud[row -i+n]=true;
helper(row +1);
col[i]=false;
d[i+row]=false;
ud[row -i+n]=false;
}
}
}
例 leetcode 解数独
八皇后和解数独都是精确优化问题（目前已经被十字链表完美解决，但是写起来十分麻烦）
每一行1-9是否已经使用row[9][9](前一个代表行，后一个代表数字）
每一列、每个九宫格同上cell[3][3][9]。