回溯-力扣-java

 

class Solution {
    public boolean exist(char[][] board, String word) {
        char []words=word.toCharArray();
        for(int i=0;i<board.length;i++){
            for(int j=0;j<board[0].length;j++){
                if(dfs(board,words,i,j,0)) return true;
            }
        }
        return false;
    }
    boolean dfs(char [][]board,char []word,int i,int j,int k){
        if(i<0||i>=board.length||j<0||j>=board[0].length
        ||board[i][j]!=word[k]) return false;
        if(k==word.length-1) return true;
        char tmp=board[i][j];
        board[i][j]='#';
        boolean res=dfs(board,word,i+1,j,k+1)||dfs(board,word,i-1,j,k+1)
        ||dfs(board,word,i,j+1,k+1)||dfs(board,word,i,j-1,k+1);
        board[i][j]=tmp;
        return res;
    }
}

/**
 * Definition for a binary tree node.
 * public class TreeNode {
 *     int val;
 *     TreeNode left;
 *     TreeNode right;
 *     TreeNode(int x) { val = x; }
 * }
 */
class Solution {
    public List<String> binaryTreePaths(TreeNode root) {
        LinkedList<String>paths=new LinkedList<>();
        solve(root,"",paths);
        return paths;
    }
    public void solve(TreeNode root,String path,LinkedList<String> paths){
        if(root==null) return;
        path+=root.val;
        if(root.left==null&&root.right==null)   当前节点是叶子节点
            paths.add(path);
        else{
            path+="->";    // 当前节点不是叶子节点，继续递归遍历
            solve(root.left,path,paths);
            solve(root.right,path,paths);
        }    
    }
}

 

class Solution {
    List<List<Integer>> res=new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        LinkedList<Integer> track=new LinkedList<>();
        backtrack(nums,track);
        return res;
    }
    public void backtrack(int []nums,LinkedList<Integer> track){
        if(track.size()==nums.length){
            res.add(new LinkedList(track));
            return ;
        }
        for(int i=0;i<nums.length;i++){
            if(track.contains(nums[i]))
                continue;
            track.add(nums[i]);      // 做选择
            backtrack(nums,track);   // 进入下一层决策树
            track.removeLast();      // 取消选择
        }
    }
}
//https://leetcode-cn.com/problems/permutations/solution/hui-su-suan-fa-xiang-jie-by-labuladong-2/