回溯法经典题

回溯法的框架

void backtracking(参数) {
    if (终止条件) {
        存放结果;
        return;
    }

    for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) {
        处理节点;
        backtracking(路径，选择列表); // 递归
        回溯，撤销处理结果
    }
}

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> list = new LinkedList<>();
        recure(nums,list);
        return res;
    }

    public void recure(int[] nums,LinkedList<Integer> list){
        if(list.size()==nums.length){
            res.add(new LinkedList<>(list));
            return;
        }
        for(int i = 0;i<nums.length;i++){
            if(list.contains(nums[i])) continue;
            list.add(nums[i]);
            recure(nums,list);
            list.removeLast();
        }

    }
}

方法二 此回溯是通过交换位置来进行（与字符串全排列类似）

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    public List<List<Integer>> permute(int[] nums) {
        recure(nums,0);
        return res;
    }
    public void recure(int[] nums,int pos){
        if(pos==nums.length-1){
            List<Integer> list = new ArrayList<>();
            for(int x:nums){
                list.add(x);
            }
            res.add(list);
        }
        for(int i = pos;i<nums.length;i++){
            swap(nums,i,pos);
            recure(nums,pos+1);
            swap(nums,i,pos);
        }

    }
    public void swap(int[] nums,int i,int j){
        int temp = nums[i];
        nums[i] = nums[j];
        nums[j] = temp;
    }


}

class Solution {
    List<String> res = new ArrayList<>();
    StringBuffer sb = new StringBuffer();
    public List<String> letterCombinations(String digits) {
        if(digits==null || digits.length()==0) return res;
        Map<Character,String> map = new HashMap<>();
        map.put('2',"abc");
        map.put('3',"def");
        map.put('4',"ghi");
        map.put('5',"jkl");
        map.put('6',"mno");
        map.put('7',"pqrs");
        map.put('8',"tuv");
        map.put('9',"wxyz");
        recure(map,digits,0);
        return res;
    }

    public void recure(Map<Character,String>map,String digits,int index){
        if(sb.length()==digits.length()){
            res.add(sb.toString());
            return;
        }
        String str = map.get(digits.charAt(index));
        for(char ch:str.toCharArray()){
            sb.append(ch);
            recure(map,digits,index+1);
            sb.deleteCharAt(sb.length()-1);
        }

    }

}

通过map存入每个按键的字符。每次递归用index来取输入的字符串中的字符作为map的key。

注意for()循环中，要把字符串转为字符数组才可以用增强for循环来遍历。

-------------------------------------------------------------------------------------------

class Solution {
    public boolean exist(char[][] board, String word) {
 		char[] arr = word.toCharArray();
 		int board.length = m,board[0].length = n;
 		boolean[][] judge = new boolean[m][n];
 		for(int i = 0;i<m;i++){
 			for(int j = 0;j<n;j++){
				if(recure(board,judge,arr,i,j,0))
					return true;			
			}
 		}
 		return false;
 	
 	} 
	
	public boolean recure(char[][] board,boolean[][] judge,char[] arr,int i,int j int pos){
	参数为矩阵，标记数组，word字符数组，查找的行，列，字符数组中的第几个字符
	if(i>=board.length||i<0||j>=board[0].length||j<0||judge[i][j]==true||boolean[i][j]!=arr[pos]) return false;
	if(pos==arr.length-1) return true;
	judge[i][j] = true;
	boolean res =  recure(board,judge,arr,i+1,j,pos+1) || recure(board,judge,arr,i,j+1,pos+1) || recure(board,judge,arr,i-1,j,pos+1) || recure(board,judge,arr,i,j-1,pos+1);
	judge[i][j] = false;
	return res;
	}

 }
    

从矩阵第一个字符开始搜索是否符合字符串中的字符，若当前位符合则递归寻找下一个字符。建立标记数组，每次走过的路都标记为true，防止走回头路，在每次递归结束后，再把走过的路改回flase。