回溯算法总结篇

最新推荐文章于 2024-09-26 00:03:11 发布
最新推荐文章于 2024-09-26 00:03:11 发布
阅读量369 收藏 5
点赞数 5
分类专栏： 数据结构与算法 力扣！ 文章标签： 算法 深度优先 回溯 回溯算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/guojiaqi_/article/details/142424522
版权

组合问题：N个数里面按一定规则找出k个数的集合

如果题目要求的是组合的具体信息，则只能使用回溯算法，如果题目只是要求组合的某些最值，个数等信息，则使用动态规划（比如求组合中元素最少的组合，求组合的个数等）

77. 组合

List<List<Integer>> res = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();

public List<List<Integer>> combine(int n, int k) {
    dfs(1, n, k);
    return res;
}

private void dfs(int start, int n, int k) {
    if (path.size() == k) {
        res.add(new ArrayList<>(path));
        return;
    }
    // for循环的作用，固定第一个值，比如 1~4，分别固定1~4，如果start为2，则不会遍历到1
    for (int i = start; i <= n; i++) {
        path.push(i); // 记录
        dfs(i + 1, n, k);
        path.pop(); // 回溯
    }
}

39. 组合总和

List<List<Integer>> res = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();

public List<List<Integer>> combinationSum(int[] candidates, int target) {
    dfs(0, candidates, target);
    return res;
}

private void dfs(int start, int[] candidates, int target) {
    // 如果target为0，说明找到解
    if (0 == target) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        int candidate = candidates[i];
        if (target < candidate) {
            continue;   // 剪枝
        }
        path.push(candidate);
        dfs(i, candidates, target - candidate); //  // 关键点:不用i+1了，表示可以重复读取当前的数
        path.pop();
    }
}

40. 组合总和 II

List<List<Integer>> result = new LinkedList<>();
LinkedList<Integer> stack = new LinkedList<>();
boolean[] visited;

public List<List<Integer>> combinationSum2(int[] candidates, int target) {
    Arrays.sort(candidates); // 排序，将相同的元素相邻放置
    visited = new boolean[candidates.length];
    dfs(0, candidates, target);
    return result;
}

public void dfs(int start, int[] candidates, int target) {
    if (target == 0) {
        result.add(new LinkedList<>(stack));
        return;
    }
    for (int i = start; i < candidates.length; i++) {
        int candidate = candidates[i];
        if (target < candidate) {
            continue; // 减枝
        }
        // 如果相邻的两个值相等，且前一个值还没有被访问，则跳过循环
        // （相邻的值只有一个可以被先访问，防止组合结果出现重复）比如：【521，512】
        if (i > 0 && candidate == candidates[i - 1] && !visited[i - 1]) {
            continue;
        }
        visited[i] = true;
        stack.push(candidate);
        // 不同点，从当前遍历到的元素后面开始递归，start = i+1;排除自身（使得结果中一个元素只能出现一次）
        dfs(i + 1, candidates, target - candidate);
        stack.pop();
        visited[i] = false;
    }
}

216. 组合总和 III

List<List<Integer>> res = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();

public List<List<Integer>> combinationSum3(int k, int n) {
    dfs(1, k, n);
    return res;
}

private void dfs(int start, int k, int target) {
    if (target == 0 && path.size() == k) {
        res.add(new ArrayList<>(path));
        return;
    }
    for (int i = start; i <= 9; i++) {
        if (target < i) {
            continue; // 剪枝
        }
        if (path.size() == k) {
            continue; // 剪枝
        }
        path.push(i);
        dfs(i + 1, k, target - i);
        path.pop();
    }
}

17. 电话号码的字母组合

List<String> res = new ArrayList<>(); // 存放最终的结果集合
StringBuilder temp = new StringBuilder(); // 每个结果

public List<String> letterCombinations(String digits) {
    if (digits == null || digits.isEmpty()) {
        return res;
    }
    // 数字和字符串的映射关系，比如数组下标为2时，numString[2] == "abc"
    String[] numString = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
    // 递归
    dfs(digits, numString, 0);
    return res;
}

/**
 *
 * @param digits 题目的参数，比如”23”
 * @param numString 数字和字符串的映射关系
 * @param i 当前正在处理的字符串的索引 比如0，则表示正在处理 digits的第一个字符串，也是就2对应的字符串‘abc’
 */
private void dfs(String digits, String[] numString, int i) {
    if (digits.length() == temp.length()) {
        // 将结果加入集合
        res.add(temp.toString());
        return;
    }
    // 取当前应该处理的字符串
    // digits.charAt(i)表示取参数中的数字，比如“2”  -'0'操作将其转化为2~9范围内的int类型
    // numString[digits.charAt(i) - '0']; 则表示在映射关系中取当前数字对应的字符串
    char charAt = digits.charAt(i);
    String str = numString[charAt - '0'];
    for (int j = 0; j < str.length(); j++) {
        temp.append(str.charAt(j));
        dfs(digits, numString, i + 1); // 取下一个字符串一个一个处理
        // 比如“digits”为“23”，则先取2对应的字符串“abc”，然后固定'a'，递归处理3对应的字符串'def',固定'd'，则返回'ad'
        temp.deleteCharAt(temp.length() - 1);
    }
}

切割问题：一个字符串按一定规则有几种切割方式

  • 在for (int i = startIndex; i < s.size(); i++)循环中，我们 定义了起始位置startIndex，那么 [startIndex, i] 就是要截取的子串。

131. 分割回文串

class Solution {
    //保持前几题一贯的格式
    List<List<String>> res = new ArrayList<>();
    List<String> cur = new ArrayList<>();

    public List<List<String>> partition(String s) {
        backtracking(s, 0, new StringBuilder());
        return res;
    }

    private void backtracking(String s, int start, StringBuilder sb) {
        //因为是起始位置一个一个加的，所以结束时start一定等于s.length,因为进入backtracking时一定末尾也是回文，所以cur是满足条件的
        if (start == s.length()) {
            //注意创建一个新的copy
            res.add(new ArrayList<>(cur));
            return;
        }
        //像前两题一样从前往后搜索，如果发现回文，进入backtracking,起始位置后移一位，循环结束照例移除cur的末位
        for (int i = start; i < s.length(); i++) {
            sb.append(s.charAt(i));
            if (check(sb)) {
                cur.add(sb.toString());
                backtracking(s, i + 1, new StringBuilder());
                cur.remove(cur.size() - 1);
            }
        }
    }

    //helper method, 检查是否是回文，前后指针指向的元素不同，则不是回文
    private boolean check(StringBuilder sb) {
        for (int i = 0; i < sb.length() / 2; i++) {
            if (sb.charAt(i) != sb.charAt(sb.length() - 1 - i)) {
                return false;
            }
        }
        return true;
    }

}

93. 复原 IP 地址❤️

class Solution {
        LinkedList<String> res = new LinkedList<>();

        public List<String> restoreIpAddresses(String s) {
            if (s.length() > 12) {
                return res;
            }
            backTrack(s, 0, 0);
            return res;
        }

        private void backTrack(String s, int startIndex, int pointNum) {
            if (pointNum == 3) {
                if (isValid(s, startIndex, s.length() - 1)) {
                    res.add(s);
                }
                return;
            }
            for (int i = startIndex; i < s.length(); i++) {
                if (isValid(s, startIndex, i)) {
                    s = s.substring(0, i + 1) + '.' + s.substring(i + 1);
                    pointNum++;
                    backTrack(s, i + 2, pointNum);
                    pointNum--;
                    s = s.substring(0, i + 1) + s.substring(i + 2);
                } else {
                    break;
                }
            }
        }

        /**
         *  验证当前子串是否符合下面三个条件
         *  1.子串的第一个字符不为0
         *  2.子串总数不大于255
         *  3.子串为正整数
         */
        private boolean isValid(String s, int start, int end) {
            if (start > end) {
                return false;
            }
            if (s.charAt(start) == '0' && start != end) {
                return false;
            }
            int num = 0;
            for (int i = start; i <= end; i++) {
                num = num * 10 + s.charAt(i) - '0';
                if (num > 255) {
                    return false;
                }
            }
            return true;
        }
    }

子集问题：一个N个数的集合里有多少符合条件的子集

求取子集问题，不需要任何剪枝！因为子集就是要遍历整棵树。

78. 子集❤️

List<List<Integer>> list = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();

public List<List<Integer>> subsets(int[] nums) {
    dfs(0, nums);
    return list;
}

private void dfs(int start, int[] nums) {
    // 子集是收集树形结构中树的所有节点的结果。
    list.add(new ArrayList<>(path));
    for (int i = start; i < nums.length; i++) {
        int num = nums[i];
        path.push(num);
        dfs(i + 1, nums);
        path.pop();
    }
}

90. 子集 II

子集II问题：这种需要回溯解决的题目，组合问题，子集问题，切割问题，如果遇到原先给你的集合中有重复元素，而输出的结果中不允许有重复结果的，需要先将原始数组排序，然后使用一个boolean类型的数组，标记每个元素是否被访问，对于重复的元素，如果前一个元素没有被访问，则不允许访问第二个元素

List<List<Integer>> result = new ArrayList<>();
LinkedList<Integer> path = new LinkedList<>();
boolean[] used; // 元素是否被访问

public List<List<Integer>> subsetsWithDup(int[] nums) {
    if (nums.length == 0) {
        result.add(path);
        return result;
    }
    Arrays.sort(nums);
    used = new boolean[nums.length];
    dfs(nums, 0);
    return result;
}

private void dfs(int[] nums, int startIndex) {
    result.add(new ArrayList<>(path));
    if (startIndex >= nums.length) { // 终止条件
        return;
    }
    for (int i = startIndex; i < nums.length; i++) {
        // 去重，递归树层去重，如果nums中有重复，则必须先访问前面的元素才能访问后面的元素
        if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
            // 如果出现重复，前面一个还没访问，则跳出循环
            continue;
        }
        int num = nums[i];
        path.push(num);
        used[i] = true;
        dfs(nums, i + 1);
        path.pop();
        used[i] = false;
    }
}

491. 非递减子序列

List<List<Integer>> res = new ArrayList<>();
List<Integer> path = new ArrayList<>();

public List<List<Integer>> findSubsequences(int[] nums) {
    dfs(0, nums);
    return res;
}

public void dfs(int start, int[] nums) {
    if (path.size() > 1) {
        res.add(new ArrayList<>(path));
    }
    // 使用数组去重，第一遇到一个值将对应数组下标置位1，如果再次遇到1，则说明已经访问过，跳过
    int[] used = new int[201];
    for (int i = start; i < nums.length; i++) {
        int num = nums[i];
        if (!path.isEmpty() && path.get(path.size() - 1) > num ||
                used[num + 100] == 1) {
            continue;
        }
        used[num + 100] = 1;
        path.add(num);
        dfs(i + 1, nums);
        path.remove(path.size() - 1);
    }
}

排列问题：N个数按一定规则全排列，有几种排列方式

  • 每层都是从0开始搜索而不是startIndex

  • 需要used数组记录path里都放了哪些元素了

46. 全排列❤️❤️

class Solution {
   List<List<Integer>> res = new LinkedList<>();
    List<Integer> path = new LinkedList<>();
    boolean[] used;

    public List<List<Integer>> permute(int[] nums) {
        used = new boolean[nums.length];
        dfs( nums);
        return res;
    }

    private void dfs(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new ArrayList<>(path));
            return;
        }
        for (int i = 0; i < nums.length; i++) {
            if(!used[i]){
                used[i]  =true;
                path.add(nums[i]);
                dfs(nums);
                used[i] = false;
                path.remove(path.size()-1);
            }
        }
    }
}

47. 全排列 II❤️

class Solution {
       List<List<Integer>> res = new LinkedList<>();
    LinkedList<Integer> path = new LinkedList<>();
    boolean[] used; // 判断一个元素是否被访问

    public List<List<Integer>> permuteUnique(int[] nums) {
        used = new boolean[nums.length];
        // 定义一个集合存放结果
        /******************************和46的区别*******************************/
        Arrays.sort(nums); // 排序
        /******************************和46的区别*******************************/
        doPermute(nums);
        return res;
    }

    private void doPermute(int[] nums) {
        if (path.size() == nums.length) {
            res.add(new LinkedList<>(path));
        }
        for (int i = 0; i < nums.length; i++) {
            /******************************和46的区别*******************************/
            if (i > 0 && nums[i] == nums[i - 1] && !used[i - 1]) {
                continue; // 相邻元素如果相等且前一个元素还没有被处理，则跳过 【两个相邻元素只有一个可以先被处理，排除重复】
            }
            /******************************和46的区别*******************************/
            if (!used[i]) {
                path.push(nums[i]);
                used[i] = true;
                doPermute(nums); // 递归
                path.pop(); // 回溯
                used[i] = false;  // 回溯
            }
        }
    }
}

棋盘问题：N皇后，解数独等等

51. N 皇后

使用三个数组分别标记，列冲突，左斜线冲突，右斜线冲突

根据当前位置的横坐标 X 和纵坐标 Y 计算当前位置所处的左斜线公式：X + Y ，

右斜线公式为 N - 1 - ( X - Y )

class Solution {
    boolean[] currCol;
    boolean[] leftSlash;
    boolean[] rightSlash;
    char[][] chessBoard;
    List<List<String>> res = new ArrayList<>();
    List<String> path = new ArrayList<>();

    public List<List<String>> solveNQueens(int n) {
        currCol = new boolean[n]; // 当前列数组大小和N皇后的N的大小相同
        leftSlash = new boolean[2 * n - 1]; // 左斜线的大小等于2*N-1，因为在N*N大小的棋盘上有2*N-1个对角线
        rightSlash = new boolean[2 * n - 1]; // 右斜线同理
        chessBoard = new char[n][n];
        for (char[] chars : chessBoard) {
            Arrays.fill(chars, '.');
        }
        dfs(0);
        return res;
    }



    private void dfs(int i) {
        int n = currCol.length;
        if (i == n) {
            for (char[] chars : chessBoard) {
                StringBuilder stringBuilder = new StringBuilder();
                for (char c : chars) {
                    stringBuilder.append(c);
                }
                path.add(stringBuilder.toString());
            }
            res.add(new ArrayList<>(path));
            path.clear();
        }
        for (int j = 0; j < n; j++) {
            if (currCol[j] || leftSlash[i + j] || rightSlash[n - 1 - (i - j)]) {
                continue;
            }
            chessBoard[i][j] = 'Q';
            currCol[j] = true;
            leftSlash[i + j] = true;
            rightSlash[n - 1 - (i - j)] = true;
            dfs(i + 1);
            chessBoard[i][j] = '.';
            currCol[j] = false;
            leftSlash[i + j] = false;
            rightSlash[n - 1 - (i - j)] = false;
        }
    }
}

37. 解数独

解数独问题需要使用三个二维数组记录，行冲突，列冲突，九宫格冲突

根据当前位置的横坐标 X 和纵坐标 Y 计算当前位置所处的九宫格公式为：X / 3 * 3 + Y / 3

class Solution {
    boolean[][] ca = new boolean[9][9]; // 行冲突
    boolean[][] cb = new boolean[9][9];// 列冲突
    boolean[][] cc = new boolean[9][9];// 九宫格冲突

    public void solveSudoku(char[][] board) {
        // 记录当前数独中已经存在的数组
        for (int i = 0; i < 9; i++) {
            for (int j = 0; j < 9; j++) {
                char c = board[i][j];
                if (c != '.') { // 如果字符不为'.'
                    ca[i][c - '1'] = true; // 将其所在行的数字c设置为冲突(该行不能再添加c数字)
                    cb[j][c - '1'] = true; // 将其所在列的数字c设置为冲突(该列不能再添加c数字)
                    cc[i / 3 * 3 + j / 3][c - '1'] = true;  // 将其所在九宫格的数字c设置为冲突(该九宫格不能再添加c数字)
                }
            }
        }
        // 参数一：正在处理的行，参数二：正在处理的列，参数三：整个二维数组
        dfs(0, 0, board);
    }

    private boolean dfs(int i, int j, char[][] board) {
        // 跳过数独中已经有数字的地方
        while (board[i][j] != '.') {
            // 超出列长，则列长恢复为0，行++
            if (++j >= 9) {
                j = 0;
                i++;
            }
            // i>=9 说明已经遍历完所有数组中的元素
            if (i >= 9) {
                return true;
            }
        }
        // 通过上面的while跳过数独中有数字的地方，找到了没有数字的地方，开始尝试从1~9放入数字
        for (int x = 1; x <= 9; x++) {
            // 如果添加的数字x在当前行，当前列，当前九宫格中有任意一个冲突，则跳过，尝试下一个数字
            if (ca[i][x - 1] || cb[j][x - 1] || cc[i / 3 * 3 + j / 3][x - 1]) {
                continue;
            }
            // 如果没有冲突，向[i,j]节点添加x数字
            board[i][j] = (char) (x + '0');
            // 添加完数字后，更新冲突数组，把当前行，当前列，当前九宫格中的x-1设置为true
            ca[i][x - 1] = cb[j][x - 1] = cc[i / 3 * 3 + j / 3][x - 1] = true;
            boolean dfs = dfs(i, j, board); // 递归
            if (dfs) {
                return true; // 如果找到解，则直接返回true
            }
            board[i][j] = '.'; // 如果没找到解，回溯
            ca[i][x - 1] = cb[j][x - 1] = cc[i / 3 * 3 + j / 3][x - 1] = false; //回溯
        }
        return false;
    }
}

OldGj_
关注
专栏目录
「leetcode」最强回溯算法总结篇！历时21天、画了20张树形结构图、14道精选回溯题目精讲
代码随想录
11-19 2万+
20张树形结构图、14道精选回溯题目，21篇回溯法精讲文章，由浅入深，一气呵成，这是全网最强回溯算法总结！
回溯算法总结 -组合篇
Stanly_的博客
05-22 1501
假设存在两个相邻的相同元素， 那么在同一树层中 它们表现为nums[i] = nums[i-1] ，在同一树层中，nums[i-1]会比nums[i]更先被遍历到，所以 当nums[i-1] 在本层进入递归的时候， used[i-1]为true ， 而当它从递归返回到本层的时候，由于回溯， 它会被设为false ，所以，若 (nums[i-1] == nums[i] && used[i-1] == false)的时候，代表nums[i-1]在本层已经被选中过了，序列后面与它相同的元素都不应该再被选中。
回溯算法总结
PETERPARKERRR的博客
11-21 1440
文章目录前言一、pandas是什么？二、使用步骤1.引入库2.读入数据总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具，该工具是为了解决数据分析任务而创建的。 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import p
代码随想录第三十天|回溯算法总结篇、Leetcode332.重新安排行程、Leetcode51. N皇后、Leetcode37. 解数独
muzi_taibai的博客
03-02 269
代码随想录第三十天|回溯算法总结篇、Leetcode332.重新安排行程、Leetcode51. N皇后、Leetcode37. 解数独
Leetcode刷题总结-4.回溯算法篇
weixin_44924725的博客
07-01 391
回溯法解决的问题都可以抽象为树形结构，是的，我指的是所有回溯法的问题都可以抽象为树形结构！因为回溯法解决的都是在集合中递归查找子集，集合的大小就构成了树的宽度，递归的深度，都构成的树的深度，递归就要有终止条件，所以必然是一棵高度有限的树（N叉树）。本文主要是分享回溯算法求解问题的思路，回溯算法基本上也是递归三部曲解决，只是有些具体问题需要对细节分析一下。
一文弄懂回溯算法（例题详解）
2302_79862386的博客
03-02 1736
回溯是递归的副产品，只要有递归就会有回溯」，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都使用了递归。详细地说：可以将回溯算法过程理解成一颗多叉树的遍历过程， 回溯法按深度优先策略搜索问题的解空间树。首先从根节点出发搜索解空间树，当算法搜索至解空间树的某一节点时，先利用剪枝函数判断该节点是否可行（即能得到问题的解）。如果不可行，则跳过对该节点为根的子树的搜索，逐层向其祖先节点回溯；否则，进入该子树，继续按深度优先策略搜索。void backtrack(参数) {
回溯算法篇-01：全排列
From_C的博客
01-19 548
力扣46全排列/回溯算法/解题框架
回溯算法解决问题小套路总结
server643的博客
03-17 3054
回溯算法解决问题小套路总结 最近我在看自己写过的回溯算法，在这儿总结一些博客或者刷题的知识经验，并以这篇文章来总结回溯算法解决的问题。这里建议了解回溯算法的本质后，看这篇文章进行练习搭配也是不错的选择。此外，本文主要以Java语言实现代码及其细节。 1、回溯算法的三步骤 首先这里先介绍刷题中回溯算法的经典要走的三个步骤。这里建议可以结合看第二部分，即具体实例来结合看。 设置递归函数的返回值以及参数。 一般在解决经典的组合问题，暴力枚举是一种非常头铁的做法。在此基础上回溯法构建一种二叉树的结构，在集合中递
回溯算法
天才小熊猫的客栈
05-17 911
1.什么是回溯法 ？ 回溯法也可以叫做回溯搜索法，它是⼀种搜索的⽅式。 回溯是递归的副产品，只要有递归就会有回溯。 所以以下讲解中，回溯函数也就是递归函数，指的都是⼀个函数。 2.回溯法的效率 ： 回溯法并不是什么⾼效的算法。因为回溯的本质是穷举，穷举所有可能，然后选出我们想要的答案，如果想让回溯法⾼效⼀些，可以加⼀些剪枝的操作，但也改不了回溯法就是穷举的本质。 那么既然回溯法并不⾼效为什么还要⽤它呢？ 因为没得选，⼀些问题能暴⼒搜出来就不错了，撑死了再剪枝⼀下，还没有更⾼效的解法。 3.回溯...
算法学习随笔 7_回溯算法整理总结
P_in_k的博客
05-02 757
本章记录一些有关二叉树的一些较为经典或者自己第一次做印象比较深刻的算法以及题型，包含自己作为初学者第一次碰到题目时想到的思路以及网上其他更优秀的思路，本章持续更新中......
回溯java算法_聊聊算法——回溯算法
weixin_30111277的博客
02-27 1025
“递归只应天上有，迭代还须在人间”，从这句话我们可以看出递归的精妙，确实厉害，递归是将问题规模逐渐减小，然后再反推回去，但本质上是从最小的规模开始，直到目标值，思想就是数学归纳法，举个例子，求阶乘 N!=(N-1)！*N ，而迭代是数学中的极限思想，利用前次的结果，逐渐靠近目标值，迭代的过程中规模不变，举例如For循环，直到终止条件。递归的思想不复杂，但代码理解就麻烦了，要理解一个斐波那契数组递归...
Java实现回溯算法入门（排列+组合+子集）
小朱小朱绝不认输的博客
10-27 8185
回溯是递归的副产品，只要有递归就会有回溯，所以回溯法也经常和二叉树遍历，深度优先搜索混在一起，因为这两种方式都是用了递归。 回溯法 采用试错的思想，它尝试分步的去解决一个问题。在分步解决问题的过程中，当它通过尝试发现现有的分步答案不能得到有效的正确的解答的时候，它将取消上一步甚至是上几步的计算，再通过其它的可能的分步解答再次尝试寻找问题的答案。回溯法通常用最简单的递归方法来实现，在反复重复上述的步骤后可能出现两种情况： 找到一个可能存在的正确的答案； 在尝试了所有可能的分步方法后宣告该问题没有答案。 回
代碼隨想錄算法訓練營|第三十二天|332.重新安排行程、51.N皇后、37.解数独、第七章 回溯算法总结篇。刷题心得（c++）
RVLIN的博客
10-07 750
困難點在於自己對於資料結構的不熟悉，以及回溯算法仍需要多加練習，但因為一步步地跟著進度走，所以除了重新安排行程，N皇后跟解數獨理解比較快，重新安排行程，一步步了解整體概念後，也有一些初步的理解了。
【数据结构和算法】--回溯算法(二)---一篇总结带你彻底搞透回溯算法！
weixin_42113716的博客
09-14 90
【数据结构和算法】--回溯算法(二)---一篇总结带你彻底搞透回溯算法！
atcoder abc372 启发式合并， dp
2201_75845839的博客
09-22 476
现在考虑如何存数据。可以用并查集合并两个集合，并且在合并的时候一定要将小的集合合并到大的集合中去，因为小集合合并到大集合中，最后的集合一定大于小集合元素数量的两倍，因此合并的时间复杂度不会超过logn。思路：判断当前变化的位置对结果是否会产生影响，在询问前先计算有多少ABC, 每次变换位置x前后扫描一下[x - 2, x + 2]范围内是否有ABC，变换前有让cnt --， 变换后有让cnt ++思路：三进制转换，可以参考二进制，先把当前可以加入的最大的3的幂次加入,这样一定可以凑出答案。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 793
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
189. 轮转数组（C++）
weixin_45813121的博客
09-25 351
给定一个整数数组nums，将数组中的元素向右轮转k个位置，其中k是非负数。
基于深度学习的图像修复算法
最新发布
weixin_42605076的博客
09-26 345
基于深度学习的图像修复算法旨在通过学习和生成模型来填补图像中的缺失或损坏部分。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值