回溯Backtracking Algorithm

news2025/1/12 1:55:15

目录

1) 入门例子

2) 全排列-Leetcode 46

3) 全排列II-Leetcode 47

4) 组合-Leetcode 77

5) 组合总和-Leetcode 39

6) 组合总和 II-Leetcode 40

7) 组合总和 III-Leetcode 216

8) N 皇后 Leetcode 51

9) 解数独-Leetcode37

10) 黄金矿工-Leetcode1219

其它题目

1) 入门例子

/**
 * 回溯
 * 
 * 程序在运行过程中分成了多个阶段
 * 通过某些手段,将数据恢复到之前某一阶段,这就称之为回溯
 * 手段包括
 *      方法栈
 *      自定义栈
 */
public class Backtracking {
    public static void main(String[] args) {
        rec(1);
    }

    private static void rec(int n) {
        if(n==3){
            return ;
        }
        System.out.println(n);
        rec(n+1);
        System.out.println(n);
    }
}

 

 方法栈

如果是集合又有什么样的效果呢?

如果用的是可变的集合或者数组必须手动的恢复集合状态
public class Backtracking {
    public static void main(String[] args) {
        rec(1, new LinkedList<>());
    }

    static void rec(int n, LinkedList<String> list) {
        if (n == 3) {
            return;
        }
        System.out.println("before:" + list);
        list.push("a");
        rec(n + 1, list);
        list.pop();
        System.out.println("after:" + list);
    }
}

2) 全排列-Leetcode 46

public class PermuteLeetcode46 {
    static List<List<Integer>> permute(int[] nums) {
        boolean[] visited = new boolean[nums.length];
        LinkedList<Integer> stack = new LinkedList<>();
        List<List<Integer>> r = new ArrayList<>();
        rec(nums, visited, stack, r);
        return r;
    }

    static void rec(int[] nums, boolean[] visited, LinkedList<Integer> stack, List<List<Integer>> r) {
        if (stack.size() == nums.length) {
            r.add(new ArrayList<>(stack));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if(visited[i]){
                continue;
            }
            stack.push(nums[i]);
            visited[i] = true;
            rec(nums, visited, stack, r);
            stack.pop();
            visited[i] = false;
        }
    }

    public static void main(String[] args) {
        List<List<Integer>> permute = permute(new int[]{1, 2, 3});
        for (List<Integer> s : permute) {
            System.out.println(s);
        }
    }
}

3) 全排列II-Leetcode 47

47. 全排列 II - 力扣（LeetCode）

public class PermuteLeetcode47 {

    static List<List<Integer>> permuteUnique(int[] nums) {
        Arrays.sort(nums);
        List<List<Integer>> result = new ArrayList<>();
        dfs(nums, new boolean[nums.length], new LinkedList<>(), result);
        return result;
    }

    static void dfs(int[] nums, boolean[] visited, LinkedList<Integer> stack, List<List<Integer>> result) {
        if (stack.size() == nums.length) {
            result.add(new ArrayList<>(stack));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if (i > 0 && nums[i] == nums[i - 1] && !visited[i-1]) { // 找出重复数字
                continue;
            }
            if (!visited[i]) {
                stack.push(nums[i]);
                visited[i] = true;
                dfs(nums, visited, stack, result);
                visited[i] = false;
                stack.pop();
            }
        }
    }

    public static void main(String[] args) {
        int[] nums = {1, 1, 3};        
        List<List<Integer>> permute = permuteUnique(nums);
        for (List<Integer> list : permute) {
            System.out.println(list);
        }
    }
}

  • 排好序，这样重复的数字会相邻

  • 定好规则：必须 1 固定之后才能固定 1'，即 1 的 visited = true 才能继续处理 1'

  • 在遍历时，遇到了 nums[i] == nums[i - 1]（即 1 和 1‘ 这种情况），进一步检查 i-1 位置的数字有没有 visited，没有，则不处理（剪枝）

4) 组合-Leetcode 77

k=2 

k=3 

 

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>>result = new ArrayList<>();
        LinkedList<Integer>stack = new LinkedList<>();
        dfs(1,n,k,stack,result);
        return result;
    }

    public void dfs(int start,int n,int k,LinkedList<Integer>stack,List<List<Integer>>result){
        if(stack.size()==k){
            result.add(new ArrayList<>(stack));
            return;
        }

        for(int i = start;i<=n;i++){
            stack.push(i);
            dfs(i+1,n,k,stack,result);
            stack.pop();
            
        }
    }
}

 

减枝

k- stack.length  还差几个能凑满

n - i +1 还剩下几个备用数字   if(k-stack.length >n-i+1) continue;

class Solution {
    public List<List<Integer>> combine(int n, int k) {
        List<List<Integer>>result = new ArrayList<>();
        LinkedList<Integer>stack = new LinkedList<>();
        dfs(1,n,k,stack,result);
        return result;
    }

    public void dfs(int start,int n,int k,LinkedList<Integer>stack,List<List<Integer>>result){
        if(stack.size()==k){
            result.add(new ArrayList<>(stack));
            return;
        }

        for(int i = start;i<=n;i++){
            if(k - stack.size() > n-i+1){
                continue;
            }
            stack.push(i);
            dfs(i+1,n,k,stack,result);
            stack.pop();

        }
    }
}

 

public class CombinationLeetcode77 {
    static List<List<Integer>> combinationSum(int n, int k) {
        List<List<Integer>> result = new ArrayList<>();
        dfs(n, k, 1, new LinkedList<>(), result);
        return result;
    }
    static int count = 0;

    static void dfs(int n, int k, int start, LinkedList<Integer> stack, List<List<Integer>> result) {
        count++;
        if (k == 0) {
            result.add(new ArrayList<>(stack));
            System.out.println(stack);
            return;
        }
//      if (k > n - start + 1) { return; }
        for (int i = start; i <= n; i++) {
//            System.out.printf("k-1=%d n=%d i=%d %n", k - 1, n, i);
            if (k > n - i + 1) {
                continue;
            }
            stack.push(i);
            dfs(n, k - 1, i + 1, stack, result);
            stack.pop();
        }
    }

    public static void main(String[] args) {
        List<List<Integer>> lists = combinationSum(5, 4);
//        for (List<Integer> list : lists) {
//            System.out.println(list);
//        }
        System.out.println(count);
    }
}

 

  • k 代表剩余要组合的个数

  • n - i + 1 代表剩余可用数字

  • 剪枝条件是：剩余可用数字要大于剩余组合数

  • 为啥放在外面不行？即这行代码：if (k > n - start + 1) { return; }

    • 因为它只考虑了 start 一种情况，而实际在循环内要处理的是 start，start+1 ... n 这多种情况

似乎 ArrayList 作为 stack 性能高一些，见下面代码，但是这道题在 leetcode 上执行时间不稳定，相同代码都会有较大时间差异（15ms vs 9ms）

class Solution {
    public List<List<Integer>> combine(int n, int k) {        
        List<List<Integer>> result = new ArrayList<>();
        if(k == 0 || n < k) return result;
        dfs(n, k, 1, new ArrayList<>(), result);
        return result;
    }

    static void dfs(int n, int k, int start, ArrayList<Integer> stack, List<List<Integer>> result) {
        if (k == 0) {
            result.add(new ArrayList<>(stack));
            return;
        }
        for (int i = start; i <= n; i++) {
            if (k-1 > n - i) {
                continue;
            }
            stack.add(i);
            dfs(n, k - 1, i + 1, stack, result);
            stack.remove(stack.size()-1);
        }
    }
}

5) 组合总和-Leetcode 39

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>>result = new ArrayList<>();
        LinkedList<Integer> stack= new LinkedList<>();
        dfs(0,candidates,target,stack,result);
        return result;
    }

    public void dfs(int start,int[] candidates,int target,LinkedList<Integer>stack,List<List<Integer>>result){
        if(target<0)
            return ;
        if(target==0){
            result.add(new ArrayList<>(stack));
            return;
        }
        for(int i = start;i<candidates.length;i++){
            int candidate = candidates[i];
            stack.push(candidate);
            dfs(i,candidates,target-candidate,stack,result);
            stack.pop();
        }
    }
}

 

class Solution {
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        List<List<Integer>>result = new ArrayList<>();
        LinkedList<Integer> stack= new LinkedList<>();
        dfs(0,candidates,target,stack,result);
        return result;
    }

    public void dfs(int start,int[] candidates,int target,LinkedList<Integer>stack,List<List<Integer>>result){
        if(target==0){
            result.add(new ArrayList<>(stack));
            return;
        }
        for(int i = start;i<candidates.length;i++){
            int candidate = candidates[i];
            if(target<candidate){
                continue;
            }
            stack.push(candidate);
            dfs(i,candidates,target-candidate,stack,result);
            stack.pop();
        }
    }
}

与之前的零钱兑换问题其实是一样的，只是

  • 本题求的是：所有组合的具体信息

  • 零钱兑换问题求的是：所有组合中数字最少的、所有组合个数... [动态规划]

6) 组合总和 II-Leetcode 40

public class CombinationLeetcode40 {
    static List<List<Integer>> combinationSum2(int[] candidates, int target) {
        Arrays.sort(candidates);
        List<List<Integer>> result = new ArrayList<>();
        dfs(target, 0, candidates, new boolean[candidates.length], new LinkedList<>(), result);
        return result;
    }

    static void dfs(int target, int start, int[] candidates, boolean[] visited, LinkedList<Integer> stack, List<List<Integer>> result) {
        if (target == 0) {
            result.add(new ArrayList<>(stack));
            return;
        }
        for (int i = start; i < candidates.length; i++) {
            int candidate = candidates[i];
            if (target < candidate) {
                continue;
            }
            if (i > 0 && candidate == candidates[i - 1] && !visited[i - 1]) {
                continue;
            }
            visited[i] = true;
            stack.push(candidate);
            dfs(target - candidate, i + 1, candidates, visited, stack, result);
            stack.pop();
            visited[i] = false;
        }
    }

    public static void main(String[] args) {
        int[] candidates = {10, 1, 2, 7, 6, 1, 5};        
        List<List<Integer>> lists = combinationSum2(candidates, 8);
        for (List<Integer> list : lists) {
            System.out.println(list);
        }
    }
}

7) 组合总和 III-Leetcode 216

class Solution {
    public List<List<Integer>> combinationSum3(int k, int target ) {
        List<List<Integer>>result = new ArrayList<>();
        dfs(1,target,k,new ArrayList<>(),result);
        return result;
    }
    //static int count = 0;
    static void dfs(int start,int target,int k,ArrayList<Integer>stack,List<List<Integer>>result){
       // count++;
        if(target==0&&stack.size()==k){
            result.add(new ArrayList<>(stack));
            return;
        }
        for(int i = start;i<=9;i++){
            // 还差几个数字       剩余可用数字
          //  if(k-stack.size() > 9-i+1){
            //    continue;
            //} 这个减枝效率较低 设置一个count变量即可查看
            if(target<i){
                continue;
            
            }
            if(stack.size()==k){
                continue;
            }
            stack.addLast(i);
            dfs(i+1,target-i,k,stack,result);
            stack.removeLast();
        }

    }
}

8) N 皇后 Leetcode 51

左斜线处理 i+j 相等i - j

 n-1-(i-j)

 i== n 找到解

public class NQueenLeetcode51 {
    static List<List<String>> solveNQueens(int n) {
        List<List<String>> result = new ArrayList<>();
        char[][] table = new char[n][n];//'.' 'Q'
        boolean[] va = new boolean[n];//列冲突
        boolean[] vb = new boolean[2 * n - 1];//左斜线冲突
        boolean[] vc = new boolean[2 * n - 1];//右斜线冲突
        for (int i = 0; i < n; i++) {
            Arrays.fill(table[i], '.');
        }
        dfs(0, n, table, result, va, vb, vc);
        return result;
    }

    static void dfs(int i, int n, char[][] table, List<List<String>> result, boolean[] va, boolean[] vb, boolean[] vc) {
        if (i == n) {
            ArrayList<String> list = new ArrayList<>();
            for (char[] chars : table) {
                list.add(String.valueOf(chars));
            }
            result.add(list);
            return;
        }
        for (int j = 0; j < n; j++) {
            if (va[j] || vb[i + j] || vc[n - 1-(i-j)]) {
                continue;
            }
            va[j] = true;
            vb[i + j] = true;
            vc[n-1-(i-j)] = true;
            table[i][j] = 'Q';
            dfs(i + 1, n, table, result, va, vb, vc);
            table[i][j] = '.';
            va[j] = false;
            vb[i + j] = false;
            vc[i - j + n - 1] = false;
        }
    }

    public static void main(String[] args) {
        int count = 0;
        for (List<String> table : solveNQueens(4)) {
            for (String row : table) {
                System.out.println(row);
            }
            count++;
            System.out.println("--------------------- " + count);
        }
    }
}
public class NQueenLeetcode51 {
    static List<List<String>> solveNQueens(int n) {
        List<List<String>> result = new ArrayList<>();
        char[][] table = new char[n][n];
        for (int i = 0; i < n; i++) {
            Arrays.fill(table[i], '.');
        }
        dfs(0, n, table, result);
        return result;
    }

    static void dfs(int i, int n, char[][] table, List<List<String>> result) {
        if (i == n) {
            ArrayList<String> list = new ArrayList<>();
            for (char[] chars : table) {
                list.add(String.valueOf(chars));
            }
            result.add(list);
            return;
        }
        for (int j = 0; j < n; j++) {
            if (notValid(table, i, j)) {
                continue;
            }
            table[i][j] = 'Q';
            dfs(i + 1, n, table, result);
            table[i][j] = '.';
        }
    }
    /*
        .   .   .   .
        .   .   .   .
        .   ?   .   .
        .   .   .   .
     */

    static boolean notValid(char[][] table, int row, int col) {
        int n = table.length;
        for (int i = 0; i < n; i++) {
            if (table[i][col] == 'Q') { // 上
                return true;
            }
        }
        for (int i = row - 1, j = col - 1; i >= 0 && j >= 0; i--, j--) {
            if (table[i][j] == 'Q') {
                return true;
            }
        }
        for (int i = row - 1, j = col + 1; i >= 0 && j < n; i--, j++) {
            if (table[i][j] == 'Q') {
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) {
        int count = 0;
        for (List<String> table : solveNQueens(8)) {
            for (String row : table) {
                System.out.println(row);
            }
            count++;
            System.out.println("--------------------- " + count);
        }
    }
}

9) 解数独-Leetcode37

判断在那个九宫格 ==>  i/3*3+j/3  

 public void solveSudoku(char[][] board) {
        /*
        1.不断遍历每个未填的空格
            逐一尝试1~9 若行,列,九宫格内没有冲突,则填入
        2.一旦1~9 都尝试失败,回溯到上一次状态,换数字填入
        3.关键还是要记录冲突状态
        */

        // 行冲突状态
        boolean[][] ca =new boolean[9][9];
        // ca[i] = {false,false,true,true,true,true...}
        // 列冲突状态
        boolean[][] cb = new boolean[9][9];
        // cb[j] = {false,true,true....}
        // 九宫格冲突状态
        //i/3*3+j/3 = ..在几号九宫格
        boolean[][] cc = new boolean[9][9];
        //cc[i/3*3+j/3] = {...}
        for(int i =0;i<9;i++){
            for(int j=0;j<9;j++){
                char ch = table[i][j];
                if(ch!='.'){//初始化冲突状态
                    ca[i][ch-'1']=true;     //'5'- '1' --> 4
                    cb[j][ch-'1']=true;
                    cc[i/3*3+j/3][ch-'1'] =true;

                }
            }
        }
        dfs(0,0,table,ca,cb,cc);

    }
    static boolean dfs(int i,int j,char[][] table,boolean[][] ca,boolean[][] cb,boolean[][] cc){
        while(table[i][j]!='.'){ //查找下一个空格
            if(++j>=9){
                j=0;
                i++;//到下一行
            }
            if(i>=9){
                return true; //找到解了
            }
        }
        //填空
        for(int x = 1;x<=9;x++){
            //检查冲突
            if(ca[i][x-1]||cb[j][x-1]||cc[i/3*3+j/3][x-1]){
                continue;
            }
            table[i][j] =(char)x+'0';   //1 -> '1'
            //ca[0][0] = true;  第0行不能存储'1'
            //cb[2][0] = true;  第2列不能存储'1'
            //cc[0][0] = true;  第0个九宫格不能存储'1'
            ca[i][x-1] = true;
            cb[j][x-1] = true;
            cc[i/3*3+j/3][x-1]=true;
            if(dfs(i,j,table,ca,cb,cc)){
                return true;
            }
            table[i][j] = '.';
            ca[i][x-1] = false;
            cb[j][x-1] = false;
            cc[i/3*3+j/3][x-1]=false;

        }
        return false;
    }
public class SudokuLeetcode37 {

    static void solveSudoku(char[][] table) {
        int n = 9;
        boolean[][] va = new boolean[n][n];//行冲突
        boolean[][] vb = new boolean[n][n];//列冲突
        boolean[][][] vc = new boolean[3][3][n];//九宫格冲突
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (table[i][j] != '.') {
                    int x = table[i][j] - '0' - 1;
                    va[i][x] = true;
                    vb[j][x] = true;
                    vc[i / 3][j / 3][x] = true;
                }
            }
        }
        dfs(table, va, vb, vc, 0, 0);
    }

    static boolean dfs(char[][] table, boolean[][] va, boolean[][] vb, boolean[][][] vc, int i, int j) {
        while (table[i][j] != '.') {
            if (++j >= 9) {
                j = 0;
                i++;
            }
            if (i >= 9) {
                return true;
            }
        }
        int n = table.length;
        for (int d = 0; d < n; d++) {
            if (va[i][d] || vb[j][d] || vc[i / 3][j / 3][d]) {
                continue;
            }
            char ch = (char) (d + '0' + 1);
            table[i][j] = ch;
            va[i][d] = true;
            vb[j][d] = true;
            vc[i / 3][j / 3][d] = true;
            boolean dfs = dfs(table, va, vb, vc, i, j);
            if (dfs) {
                return true;
            }
            table[i][j] = '.';
            va[i][d] = false;
            vb[j][d] = false;
            vc[i / 3][j / 3][d] = false;

        }
        return false;
    }

    public static void main(String[] args) {
        char[][] table = {
                {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
                {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
                {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
                {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
                {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
                {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
                {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
                {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
                {'.', '.', '.', '.', '8', '.', '.', '7', '9'}
        };
        solveSudoku(table);

        print(table);
    }

    static char[][] solved = {
            {'5', '3', '4', '6', '7', '8', '9', '1', '2'},
            {'6', '7', '2', '1', '9', '5', '3', '4', '8'},
            {'1', '9', '8', '3', '4', '2', '5', '6', '7'},
            {'8', '5', '9', '7', '6', '1', '4', '2', '3'},
            {'4', '2', '6', '8', '5', '3', '7', '9', '1'},
            {'7', '1', '3', '9', '2', '4', '8', '5', '6'},
            {'9', '6', '1', '5', '3', '7', '2', '8', '4'},
            {'2', '8', '7', '4', '1', '9', '6', '3', '5'},
            {'3', '4', '5', '2', '8', '6', '1', '7', '9'}
    };

    static void print(char[][] table) {
        for (char[] chars : table) {
            System.out.println(new String(chars));
        }
        System.out.println(Arrays.deepEquals(table, solved));
    }
}
public class SudokuLeetcode37 {
    record Pair(int i, int j) {

    }

    static void solveSudoku(char[][] table) {
        int n = 9;
        boolean[][] va = new boolean[n][n];
        boolean[][] vb = new boolean[n][n];
        boolean[][][] vc = new boolean[3][3][n];
        List<Pair> blanks = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                if (table[i][j] != '.') {
                    int x = table[i][j] - '0' - 1;
                    va[i][x] = true;
                    vb[j][x] = true;
                    vc[i / 3][j / 3][x] = true;
                } else {
                    blanks.add(new Pair(i, j));
                }
            }
        }
        dfs(0, blanks, table, va, vb, vc);
    }

    static boolean dfs(int p, List<Pair> blanks, char[][] table, boolean[][] va, boolean[][] vb, boolean[][][] vc) {
        if (p == blanks.size()) {
            print(table);
            return true;
        }
        int n = table.length;
        for (int d = 0; d < n; d++) {
            Pair pair = blanks.get(p);
            if (va[pair.i][d] || vb[pair.j][d] || vc[pair.i / 3][pair.j / 3][d]) {
                continue;
            }
            char ch = (char) (d + '0' + 1);
            table[pair.i][pair.j] = ch;
            va[pair.i][d] = true;
            vb[pair.j][d] = true;
            vc[pair.i / 3][pair.j / 3][d] = true;
            boolean dfs = dfs(p + 1, blanks, table, va, vb, vc);
            if (dfs) {
                return true;
            }
            table[pair.i][pair.j] = '.';
            va[pair.i][d] = false;
            vb[pair.j][d] = false;
            vc[pair.i / 3][pair.j / 3][d] = false;

        }
        return false;
    }

    public static void main(String[] args) {
        char[][] table = {
                {'5', '3', '.', '.', '7', '.', '.', '.', '.'},
                {'6', '.', '.', '1', '9', '5', '.', '.', '.'},
                {'.', '9', '8', '.', '.', '.', '.', '6', '.'},
                {'8', '.', '.', '.', '6', '.', '.', '.', '3'},
                {'4', '.', '.', '8', '.', '3', '.', '.', '1'},
                {'7', '.', '.', '.', '2', '.', '.', '.', '6'},
                {'.', '6', '.', '.', '.', '.', '2', '8', '.'},
                {'.', '.', '.', '4', '1', '9', '.', '.', '5'},
                {'.', '.', '.', '.', '8', '.', '.', '7', '9'}
        };

        solveSudoku(table);

        print(table);
    }

    static char[][] solved = {
            {'5', '3', '4', '6', '7', '8', '9', '1', '2'},
            {'6', '7', '2', '1', '9', '5', '3', '4', '8'},
            {'1', '9', '8', '3', '4', '2', '5', '6', '7'},
            {'8', '5', '9', '7', '6', '1', '4', '2', '3'},
            {'4', '2', '6', '8', '5', '3', '7', '9', '1'},
            {'7', '1', '3', '9', '2', '4', '8', '5', '6'},
            {'9', '6', '1', '5', '3', '7', '2', '8', '4'},
            {'2', '8', '7', '4', '1', '9', '6', '3', '5'},
            {'3', '4', '5', '2', '8', '6', '1', '7', '9'}
    };

    static void print(char[][] table) {
        for (char[] chars : table) {
            System.out.println(new String(chars));
        }
        System.out.println(Arrays.deepEquals(table, solved));
    }
}

10) 黄金矿工-Leetcode1219

1219. 黄金矿工 - 力扣（LeetCode）

class Solution {
    int[][] g;
    boolean[][] vis;
    int m,n;
    int[][] dirs = new int[][]{{1,0},{-1,0},{0,1},{0,-1}};
    public int getMaximumGold(int[][] grid) {
        g = grid;
        m = g.length;n = g[0].length;
        vis= new boolean[m][n];
        int ans = 0;
        for(int i = 0;i<m;i++){
            for(int j = 0;j<n;j++){
                if(g[i][j]!=0){
                    vis[i][j] = true;
                    ans = Math.max(ans,dfs(i,j));
                    vis[i][j] = false;
                }
            }
        }
        return ans;
    }

    int dfs(int x,int y){
        int ans = g[x][y];
        for(int[] d:dirs){
            int nx = x+d[0],ny = y+d[1];
            if(nx<0||nx>=m||ny<0||ny>=n)continue;
            if(g[nx][ny]==0)continue;
            if(vis[nx][ny]) continue;
            vis[nx][ny] = true;
            ans = Math.max(ans,g[x][y] + dfs(nx,ny));
            vis[nx][ny] =false;
        }
        return ans;
    }
}

其它题目

题号标题说明
Leetcode 1219黄金矿工
无马踏棋盘（The Knight’s tour problem）
无Rat in a Maze与 Leetcode 62 不同路径区别在于，该题问的是有多少种走法，而本题只是找到其中一种走法实现

543. 二叉树的直径 - 力扣（LeetCode）

class Solution {
    int ans = 0;

    public int diameterOfBinaryTree(TreeNode root) {
        dfs(root);
        return ans;
    }
    int dfs(TreeNode u){
        if(u==null) return 0;
        int l = dfs(u.left),r=dfs(u.right);
        ans = Math.max(ans,l+r);
//返回最大深度
        return Math.max(l,r)+1;
    }
}

433. 最小基因变化 - 力扣（LeetCode）

class Solution {
    int ans = Integer.MAX_VALUE;

    public int minMutation(String start, String end, String[] bank) {
        backtrack(start, end, bank, new boolean[bank.length], 0);
        return ans == Integer.MAX_VALUE ? -1 : ans;
    }

    public void backtrack(String start, String end, String[] bank, boolean[] used, int t) {
        if (t >= ans) return;
        if (start.equals(end)) {
            ans = Math.min(ans, t);
        } else {
            for (int i = 0, diff = 0; i < bank.length; i++, diff = 0) {
                if (used[i]) continue;
                for (int j = 0; j < start.length(); j++) 
                    diff += start.charAt(j) != bank[i].charAt(j) ? 1 : 0;
                if (diff == 1) {
                    used[i] = true;
                    backtrack(bank[i], end, bank, used, t + 1);
                    used[i] = false;
                }
            }
        }
    }
}

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1635751.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

LeetCode45：跳跃游戏Ⅱ

LeetCode45：跳跃游戏Ⅱ

题目描述 给定一个长度为 n 的 0 索引整数数组 nums。初始位置为 nums[0]。 每个元素 nums[i] 表示从索引 i 向前跳转的最大长度。换句话说&#xff0c;如果你在 nums[i] 处&#xff0c;你可以跳转到任意 nums[i j] 处: 0 < j < nums[i] i j < n 返回到达 nums[n …
阅读更多...
SAP PP学习笔记08 - 作业区（工作中心Work Center），作业区Customize

SAP PP学习笔记08 - 作业区（工作中心Work Center），作业区Customize

上一章讲了作业手顺&#xff08;工艺路线Routing&#xff09;。 SAP PP学习笔记07 - 作业手顺&#xff08;工艺路线Routing&#xff09;-CSDN博客 这一章来讲讲作业区&#xff08;工作中心 Work Center&#xff09;。 1&#xff0c;作业区&#xff08;工作中心&#xff09;中…
阅读更多...
Linux挂载硬盘

Linux挂载硬盘

1、查看硬盘数量 fdisk -l # 可以看到三个磁盘 # /dev/vda 50G # /dev/vdb 100G 新增 # /dev/vdc 100G 新增2、查看当前挂载情况 df -h # 可以看到50G的已经挂载3、格式化待挂载盘 # 对新的数据盘进行挂载前要进行格式化&#xff0c;只有格式化后才可以挂载 mkfs.ext4 /dev/…
阅读更多...
2024年这样做抖音小店，操作简单，起店稳定！

2024年这样做抖音小店，操作简单，起店稳定！

大家好&#xff0c;我是电商糖果 不少朋友说跟糖果抱怨过&#xff0c;说抖音小店越来越难做了。 平台的规则越来越多&#xff0c;商家运营店铺的时候&#xff0c;很容易出现违规预警。 糖果是2020年开始做的抖音小店&#xff0c;现在已经经营了多家小店。 实话实说确实比之…
阅读更多...
一站式AI创作平台：融合GPT会话、GPTs应用、Midjourney视觉艺术与Suno AI音乐合成模块

一站式AI创作平台：融合GPT会话、GPTs应用、Midjourney视觉艺术与Suno AI音乐合成模块

一、系统简介 星河易创AI系统基于ChatGPT的核心技术打造&#xff0c;集成了自然语言问答和艺术创作功能。该系统兼容Midjourney绘画技术&#xff0c;并支持官方GPT模型。它提供了多样化的应用&#xff0c;包括GPTs的多场景应用、实时GPT语音对话能力、GPT-4模型的先进特性&…
阅读更多...
扩展大型视觉-语言模型的视觉词汇：Vary 方法

扩展大型视觉-语言模型的视觉词汇：Vary 方法

在人工智能领域&#xff0c;大型视觉-语言模型&#xff08;LVLMs&#xff09;正变得越来越重要&#xff0c;它们能够处理多种视觉和语言任务&#xff0c;如视觉问答&#xff08;VQA&#xff09;、图像字幕生成和光学字符识别&#xff08;OCR&#xff09;。然而&#xff0c;现有…
阅读更多...
springboot 集成 flowable

springboot 集成 flowable

随着企业对于业务流程管理需求的增加&#xff0c;流程引擎在企业信息化建设中的作用越来越重要。Flowable是一个开源的轻量级业务流程管理&#xff08;BPM&#xff09;和工作流引擎&#xff0c;它支持BPMN 2.0标准。 Flowable的一些特点&#xff1a; 安装集成&#xff1a;Flow…
阅读更多...
基于Springboot 的 Excel表格的导入导出

基于Springboot 的 Excel表格的导入导出

首先 &#xff0c;引入相关依赖EasyPOI <dependency><groupId>cn.afterturn</groupId><artifactId>easypoi-spring-boot-starter</artifactId><version>4.4.0</version></dependency> 编写实体类&#xff1a; Data AllArgs…
阅读更多...
Golang错误处理机制

Golang错误处理机制

文章目录 Golang错误处理机制panic异常recover捕获异常自定义错误 Golang错误处理机制 panic异常 panic异常 Go的类型系统会在编译时捕获很多错误&#xff0c;但有些错误只能在运行时检查&#xff0c;比如除零错误、数组访问越界、空指针引用等&#xff0c;这些运行时错误会引…
阅读更多...
mongodb卸载（win）

mongodb卸载（win）

关闭服务 &#xff08;或者cmd卸载服务&#xff1a;&#xff09; net stop 服务名称卸载应用 至此&#xff0c;卸载完成&#xff01;
阅读更多...
手拉手CentOS 安装 mysql-5.7

手拉手CentOS 安装 mysql-5.7

MySQL是一种关系型数据库管理系统&#xff0c;关系数据库将数据保存在不同的表中&#xff0c;而不是将所有数据放在一个大仓库内&#xff0c;这样就增加了速度并提高了灵活性。 tar.gz包安装 #如没有安装wget则无法使用&#xff0c;以装&#xff0c;则直接省略该步~&#xff…
阅读更多...
DBeaver连接神通数据库

DBeaver连接神通数据库

一、在dbeaver中新建一个驱动 1、打开dbeaver&#xff0c;点击数据库-驱动管理器 2、点击右侧的新建 在【设置】中填写以下信息 类名&#xff1a;com.oscar.Driver URL模板&#xff1a;jdbc:oscar://{host}:{port} 默认端口&#xff1a;2003 在【库】中点击添加文件&#…
阅读更多...
C语言学习/复习37--进阶总结与题目练习

C语言学习/复习37--进阶总结与题目练习

一、题目练习 1. 循环与无符号char的取值范围 注意事项&#xff1a;0~255 -128~127 char类的取值范围看做循环图 2.ASCLL值与循环 3.按位操作与bit位 4 .结构体的大小 注意事项&#xff1a;结构体嵌套结构体的大小计算 5.循环条件 6.数据类型与原反补码 7.指针访问字符串数…
阅读更多...
Python实现智能客服问答系统

Python实现智能客服问答系统

随着人工智能技术的不断发展&#xff0c;机器人客服与聊天系统成为了热门话题。Python作为一种简单易学、功能强大的编程语言&#xff0c;在机器人客服与聊天系统的开发中具有广泛应用。 本文将介绍如何使用Python实现机器人客服与聊天系统&#xff0c;包括实现方式、代码示例和…
阅读更多...
rust将json字符串直接转为map对象或者hashmap对象

rust将json字符串直接转为map对象或者hashmap对象

有些时候我们还真的不清楚返回的json数据里面到底有哪些数据&#xff0c;数据类型是什么等&#xff0c;这个时候就可以使用批处理的方式将json字符串转为一个对象&#xff0c;然后通过这个对象的get方法来获取json里面的数据。 pub async fn test_json(&self) {let json_st…
阅读更多...
综合性练习（后端代码练习2）——用户登录

综合性练习（后端代码练习2）——用户登录

目录 一、准备工作 二、约定前后端交互接口 1、需求分析 2、接口定义 1、输入账户密码界面 2、当前登录的用户界面 三、实现服务端代码 四、调整前端页面代码 1、login.html代码&#xff1a; 页面跳转的三种方式&#xff1a; 2、index.html代码&#xff1a; 五、运…
阅读更多...
推荐一个好用的命令行工具ShellGPT

推荐一个好用的命令行工具ShellGPT

ShellGPT 配置安装常用功能聊天写命令并执行 高级功能函数调用角色管理 总结 这两天突然想到&#xff0c;现有的很多工具都在被大模型重构&#xff0c;比如诞生了像perplexity.ai 这种新交互形式的搜索引擎&#xff0c;就连wps也推出了AI服务&#xff0c;甚至都可以直接生成ppt…
阅读更多...
信源信息数智化招采平台赋能各行业信创生态建设

信源信息数智化招采平台赋能各行业信创生态建设

信创&#xff0c;即“信息化应用创新”&#xff0c;是保障国家数据安全、网络安全的重要基础&#xff0c;也是新基建的重要组成部分。加强IT基础设施、软件、硬件、安全等领域的防护能力&#xff0c;实现国产化自主可控&#xff0c;是招采供应链数字化转型必须面对的课题。 全…
阅读更多...
[二叉树] 二叉树的前中后三序遍历#知二求一

[二叉树] 二叉树的前中后三序遍历#知二求一

标题&#xff1a;[二叉树] 二叉树的前中后三序遍历#知二求一 水墨不写bug &#xff08;图片来源于网络&#xff09; 正文开始&#xff1a; 其实这一类题就是考察对二叉树的结构理解&#xff0c;此类题目的二叉树一般通过数组传入&#xff0c;我们只需根据二叉树的就够特点对数…
阅读更多...
今日科普：认识颅脑肿瘤

今日科普：认识颅脑肿瘤

颅脑肿瘤&#xff0c;这个医学名词常常令人心生畏惧&#xff0c;但其实它是指发生在大脑、小脑、脑膜等部位的肿瘤。这些肿瘤可能源于颅内组织&#xff0c;也可能是由身体其他部位的肿瘤转移而来。令人欣慰的是&#xff0c;并非所有颅内肿瘤都是恶性的&#xff0c;良性肿瘤和恶…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023