力扣--回溯篇(2)

最近在疯狂摆烂啊啊啊啊

11.子集 90. 子集 II - 力扣（LeetCode）

java 复制代码

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    //关键在于去重
    public void backTracing(int i,int[] nums)
    {
        if(i==nums.length)
        {ans.add(new ArrayList<>(path));
        return;}
        //选x
        int x=nums[i];
        path.add(x);
        backTracing(i+1,nums);
        path.removeLast();

        //不选，那么后面所有等于x的数都不选，不然会导致重复
        i++;
        while(i<nums.length&&nums[i]==x)
        {
            i++;
        }
        backTracing(i,nums);
    }
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        Arrays.sort(nums);
        backTracing(0,nums);
        return ans;
    }
}

12.递增子序列 491. 非递减子序列 - 力扣（LeetCode）

13.全排列 46. 全排列 - 力扣（LeetCode）

java 复制代码

class Solution {
    List<List<Integer>> ans = new ArrayList<>();
    List<Integer> path = new ArrayList<>();

    public void swap(int a, int b)
    {
        int x=path.get(a);
        path.set(a,path.get(b));
        path.set(b,x);
    }

    public void backTracing(int i, int[] nums)
    {
        if(i==nums.length)
        {
            ans.add(new ArrayList<>(path));
            return;
        }
        for(int j=i;j<nums.length;j++)
        {
            swap(i,j);
            backTracing(i+1,nums);
            swap(i,j);
        }
    }

    public List<List<Integer>> permute(int[] nums) {
        for(int num:nums)
        {
            path.add(num);
        }
        backTracing(0,nums);
        return ans;
    }
}

14.全排列

java 复制代码

class Solution {
    public List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        int n = nums.length;
        List<List<Integer>> ans = new ArrayList<>();
        List<Integer> path = Arrays.asList(new Integer[nums.length]); // 所有排列的长度都是 n
        boolean[] onPath = new boolean[n]; // onPath[j] 表示 nums[j] 是否已经填入排列
        dfs(0, nums, path, onPath, ans);
        return ans;
    }

    // i 表示当前要填排列的第几个数
    private void dfs(int i, int[] nums, List<Integer> path, boolean[] onPath, List<List<Integer>> ans) {
        if (i == nums.length) { // 填完了
            ans.add(new ArrayList<>(path));
            return;
        }
        // 枚举 nums[j] 填入 path[i]
        for (int j = 0; j < nums.length; j++) {
            // 如果 nums[j] 已填入排列，continue
            // 如果 nums[j] 和前一个数 nums[j-1] 相等，且 nums[j-1] 没填入排列，continue
            if (onPath[j] || j > 0 && nums[j] == nums[j - 1] && !onPath[j - 1]) {
                continue;
            }
            path.set(i, nums[j]); // 填入排列
            onPath[j] = true; // nums[j] 已填入排列（注意标记的是下标，不是值）
            dfs(i + 1, nums, path, onPath, ans); // 填排列的下一个数
            onPath[j] = false; // 恢复现场
            // 注意 path 无需恢复现场，因为排列长度固定，直接覆盖 path[i] 就行
        }
    }
}

15.N皇后

16.单词搜索 79. 单词搜索 - 力扣（LeetCode）

java 复制代码

class Solution {
    //标记是否匹配到
    private boolean found = false;
    //四个方向
    private int[][] dirs={{-1,0},{1,0},{0,1},{0,-1}};

    private void dfs(char[][] board, String word, int i, int x, int y, boolean[][] visited){
        //找到单词
        if(found)
        {
            return;
        }
        //匹配到末尾 说明找到
        if(i==word.length())
        {
            found=true;
            return;
        }
        //越界或者不等于 直接返回
        int rows=board.length,cols=board[0].length;
        if(x<0||x>=rows||y<0||y>=cols||board[x][y]!=word.charAt(i)||visited[x][y]==true)
        {
            return;
        }
        visited[x][y]=true;
        for(int[] dir : dirs){
            int newX=x+dir[0];
            int newY=y+dir[1];
            dfs(board,word,i+1,newX,newY,visited);
        }
        //回溯
        visited[x][y]=false;
    }

    public boolean exist(char[][] board, String word) {
        if(board==null||board.length==0||board[0].length==0||word==null||word.isEmpty()){
            return false;
        }
        int rows=board.length;
        int cols=board[0].length;
        boolean[][] visited=new boolean[rows][cols];
        for(int i=0;i<rows;i++){
            for(int j=0;j<cols;j++){
                if(!visited[i][j])
                dfs(board,word,0,i,j,visited);
                if(found){
                    return true;
                }
            }
        }
        return false;
    }
}