算法:回溯题目总结

已于 2023-09-20 17:48:43 修改
阅读量102 收藏
点赞数
文章标签： 算法
于 2023-09-18 22:45:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42455789/article/details/133000378
版权

回溯法解决的问题

回溯法，一般可以解决如下几种问题：

组合问题：N个数里面按一定规则找出k个数的集合
切割问题：一个字符串按一定规则有几种切割方式
子集问题：一个N个数的集合里有多少符合条件的子集
排列问题：N个数按一定规则全排列，有几种排列方式
棋盘问题：N皇后，解数独等等

组合问题

题目1：77. 组合

思路：循环套递归加回溯
1）递归法

class Solution {
    List<List<Integer>> res=new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> combine(int n, int k) {
        backtracking(n,k,1);
        return res;
    }
    //n是范围 k是k个数的组合 startIndex是控制取下一个节点继续组合
    public void backtracking(int n,int k,int startIndex){
        //收集结果
        if(path.size()==k){
            //说明拿到了一个个数为k的组合
            res.add(new ArrayList<>(path));
        }
        //for循环控制节点不重复 取到的组合也不重复
        for(int i=startIndex;i<=n;i++){
            path.add(i);
            //递归
            backtracking(n,k,i+1);
            //回溯
            path.removeLast();
        }
    }
}
题目2：216. 组合总和 III

思路：回溯模版变种题
1）递归法

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

    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k,n,0,1);
        return result;
    }

    public void backtracking(int k,int n,int sum ,int startIndex){
        //如果和为n 并且 结果是k个 收集结果
        if(sum==n&&path.size()==k){
            result.add(new ArrayList<>(path));
        }
        for(int i=startIndex;i<=9;i++){
            path.add(i);
            sum+=i;
            backtracking(k,n,sum,i+1);
            //回溯
            sum-=i;
            path.removeLast();
        }
    }
}

剪枝优化后的代码

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

    public List<List<Integer>> combinationSum3(int k, int n) {
        backtracking(k,n,0,1);
        return result;
    }

    public void backtracking(int k,int n,int sum ,int startIndex){
    	// 剪枝操作
        if (sum > n) { 
            return;
        }    
        // 剪枝操作 收集的元素比k大 
        if (path.size() > k) return;
        //如果和为n 并且 结果是k个 收集结果
        if(sum==n&&path.size()==k){
            result.add(new ArrayList<>(path));
        }
        for(int i=startIndex;i<=9;i++){
            path.add(i);
            sum+=i;
            backtracking(k,n,sum,i+1);
            //回溯
            sum-=i;
            path.removeLast();
        }
    }
}
*题目3：17. 电话号码的字母组合

思路：得复习 还挺难理解
1）递归法

class Solution {

    List<String> result=new ArrayList<>();
    StringBuilder path=new StringBuilder();  
    public List<String> letterCombinations(String digits) {
        if(digits==null || digits.length()==0){
            return result;
        }
        String[] numString={"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
        backtracking(digits,numString,0);
        return result;
    }

    public void backtracking(String digits,String[] numString,int startIndex){
       //收集结果
       if(startIndex==digits.length()){
           result.add(path.toString());
           return;
       }
       //取出数字startIndex对应的字母
        String str=numString[digits.charAt(startIndex)-'0'];
        for(int i=0;i<str.length();i++){
            path.append(str.charAt(i));
            backtracking(digits,numString,startIndex+1);
            path.deleteCharAt(path.length()-1);
        }
    }
}
题目4：39. 组合总和

思路：这个是可以重复选取元素的题 与前两题不同 就是一个递归参数的变化 不加一就可以
1）递归法

class Solution {
    private List<List<Integer>> result=new ArrayList<>();
    private LinkedList<Integer> path=new LinkedList<Integer>();
    public List<List<Integer>> combinationSum(int[] candidates, int target) {
        if(candidates.length==0){
            return result;
        }
        bracktracking(candidates,target,0,0);
        return result;
    }
    public void bracktracking(int[] candidates, int target,int sum,int startIndex){
        if(sum>target){
            return;
        }
        if(sum==target){
            result.add(new ArrayList<>(path));
        }
        for(int i=startIndex;i<candidates.length;i++){
            sum+=candidates[i];
            path.add(candidates[i]);
            //注意 此时i不+1
            bracktracking(candidates,target,sum,i);
            sum-=candidates[i];
            path.removeLast();
        }
    }
}
*题目5：40. 组合总和 II

思路：这题有重复元素需先排序 其次要借助一下used数组来数层剪枝 有难度 需复习
1）递归法

class Solution {
    private List<List<Integer>> result=new ArrayList<>();
    private LinkedList<Integer> path=new LinkedList<Integer>();
    public List<List<Integer>> combinationSum2(int[] candidates, int target) {
         if(candidates.length==0){
            return result;
         }
        //排序
        Arrays.sort(candidates);
        int[] used=new int[candidates.length];
        bracktracking(candidates,target,0,0,used);
        return result;
    }
    public void bracktracking(int[] candidates, int target,int sum,int startIndex,int[] used){
        if(sum>target){
            return;
        }
        if(sum==target){
            result.add(new ArrayList<>(path));
        }
        for(int i=startIndex;i<candidates.length;i++){
        	//去重逻辑
            if(i>0&&candidates[i]==candidates[i-1]&&used[i-1]==0){
                continue;
            }
            sum+=candidates[i];
            path.add(candidates[i]);
            used[i]=1;
            bracktracking(candidates,target,sum,i+1,used);
            sum-=candidates[i];
            path.removeLast();
            used[i]=0;
        }
    }
}

切割问题

*题目6：131. 分割回文串

思路：因为切割过的地方，不能重复切割 和组合的回溯过程差不多 双指针法判断回文串
难点：
切割问题可以抽象为组合问题
如何模拟那些切割线
切割问题中递归如何终止
*在递归循环中如何截取子串
如何判断回文
1）递归法

class Solution {
    List<List<String>> res=new ArrayList<>();
    LinkedList<String> path=new LinkedList<>();
    public List<List<String>> partition(String s) {
        backtracking(s,0);
        return res;
    }
    private void backtracking(String s,int startIndex){
        //如果起始位置大于s的大小，说明找到了一组分割方案
        if (startIndex >= s.length()) {
            res.add(new ArrayList(path));
            return;
        }
        for(int i=startIndex;i<s.length();i++){
            //判断是否是回文串(难点)
            if(checkPalindRome(s,startIndex,i)){
                //切割子串(难点)
                String str = s.substring(startIndex, i+1);
                path.add(str);
            } else {
                continue;
            }
            backtracking(s, i + 1);
            path.removeLast();
        }
    }

    private boolean checkPalindRome(String s, int start, int end){
        for (int i = start, j = end; i < j; i++, j--) {
            if (s.charAt(i) != s.charAt(j)) {
                return false;
            }
        }
        return true;
    }
}
**题目7：93. 复原 IP 地址

思路：
1）递归法

class Solution {
    List<String> res = new ArrayList<>();
    public List<String> restoreIpAddresses(String s) {
        StringBuilder sb = new StringBuilder(s);
        backTracking(sb, 0, 0);
        return res;
    }
    private void backTracking(StringBuilder s, int startIndex, int dotCount){
        if(dotCount==3){
            if(isValid(s, startIndex, s.length() - 1)){
                res.add(s.toString());
            }
            return;
        }
        for(int i = startIndex; i < s.length(); i++){
            if(isValid(s, startIndex, i)){
                //如果字符串合法拼上.
                s.insert(i + 1, '.');
                //递归i+2是因为i+1是.
                backTracking(s, i + 2, dotCount + 1);
                //回溯 把字符串还原
                s.deleteCharAt(i + 1);
            }else{
                break;
            }
        }
    }
    //[start, end]
    private boolean isValid(StringBuilder s, int start, int end){
        if(start > end) return false;
        // 0开头的数字不合法
        if(s.charAt(start) == '0' && start != end) return false;
        //当前字符串拼接的数
        int num = 0;
        for(int i = start; i <= end; i++){
            //当前字符串对应的数字
            int digit = s.charAt(i) - '0';
            num = num * 10 + digit;
            if(num > 255) return false;
        }
        return true;
    }
}

子集问题

组合问题和分割问题收集结果的时候相当于收集的是部分 而子集收集的是全部 所以没有判断==k去收集结果

题目8：78. 子集

思路：
1）递归法

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> subsets(int[] nums) {
        if(nums.length==0){
            return result;
        }
        bracktrack(nums,0);
        return result;
    }
    void bracktrack(int[] nums,int startIndex){
        result.add(new ArrayList<Integer>(path));
        for(int i=startIndex;i<nums.length;i++){
            path.add(nums[i]);
            bracktrack(nums,i+1);
            path.removeLast();
        }
    }

}
*题目9：90. 子集 II

思路：
1）递归法

class Solution {
    List<List<Integer>> result =new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> subsetsWithDup(int[] nums) {
        if(nums.length==0){
           return result;
        }
        int[] used=new int[nums.length];
        Arrays.sort(nums);
        bracktrack(nums,0,used);
        return result;
    }
    void bracktrack(int[] nums,int startIndex,int[] used){
        result.add(new ArrayList<Integer>(path));
        for(int i=startIndex;i<nums.length;i++){
        	//树层去重 0就是false
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==0){
                continue;
            }
            path.add(nums[i]);
            used[i]=1;
            bracktrack(nums,i+1,used);
            path.removeLast();
             used[i]=0;
        }
    }
}
*题目10：491. 递增子序列

思路：
1）递归法

class Solution {
    List<List<Integer>> res = new ArrayList<>();
    List<Integer> path = new ArrayList<>();
    public List<List<Integer>> findSubsequences(int[] nums) {
        backTracking(nums, 0);
        return res;
    }
    private void backTracking(int[] nums, int startIndex){
        //题目要求至少有两个元素
        if(path.size() >= 2) res.add(new ArrayList<>(path));            
        HashSet<Integer> hs = new HashSet<>();
        for(int i = startIndex; i < nums.length; i++){
            //如果最后一个元素大于此元素 就不能取了 或者是取到的元素在同一层已经用过了
            if(!path.isEmpty() && path.get(path.size() -1 ) > nums[i] || hs.contains(nums[i]))
                continue;
            hs.add(nums[i]);
            path.add(nums[i]);
            backTracking(nums, i + 1);
            path.remove(path.size() - 1);
        }
    }
}

排列问题

题目11：46. 全排列

思路：与以上问题不同的是排列问题不用startIndex参数了，因为排列问题，每次都要从头开始搜索，例如元素1在[1,2]中已经使用过了，但是在[2,1]中还要再使用一次1，而used数组，其实就是记录此时path里都有哪些元素使用了，一个排列里（递归里）一个元素只能使用一次
1）递归法

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> permute(int[] nums) {
        if(nums.length==0) return result;
        boolean[] used=new boolean[nums.length];
        backTrack(nums,used);
        return result;
    }
    public void backTrack(int[] nums,boolean[] used){
        if(path.size()==nums.length){
            result.add(new ArrayList<Integer>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
            if(used[i]==true){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backTrack(nums,used);
            used[i]=false;
            path.removeLast();
        }
    }
}
*题目12：47. 全排列 II

思路：used[i-1]==false是树层上去重，如果需要树枝上去重used[i-1]==true 是同一树枝 这题与子集II与组合总和 II题目 去重逻辑相同
1）递归法

class Solution {
    List<List<Integer>> result=new ArrayList<>();
    LinkedList<Integer> path=new LinkedList<>();
    public List<List<Integer>> permuteUnique(int[] nums) {
        if(nums.length==0){
            return result;
        }
        boolean[] used=new boolean[nums.length];
        Arrays.sort(nums);
        backTrack(nums,used);
        return result;
    }
    public void backTrack(int[]nums,boolean[] used){
        if(nums.length==path.size()){
            result.add(new ArrayList<Integer>(path));
            return;
        }
        for(int i=0;i<nums.length;i++){
        	//去重逻辑
            if(i>0&&nums[i]==nums[i-1]&&used[i-1]==false){
                continue;
            }
            path.add(nums[i]);
            used[i]=true;
            backTrack(nums,used);
            path.removeLast();
            used[i]=false;
        }
    }
}
题目13：332. 重新安排行程

思路：
1）递归法

class Solution {
    private LinkedList<String> res = new LinkedList<>();
    private LinkedList<String> path = new LinkedList<>();
    public List<String> findItinerary(List<List<String>> tickets) {
        //给车票进行排序
        Collections.sort(tickets, (a, b) -> a.get(1).compareTo(b.get(1)));
        path.add("JFK");
        //记录车票是否使用过
        boolean[] used = new boolean[tickets.size()];
        backTracking((ArrayList)tickets, used);
        return res;
    }
    public boolean backTracking(ArrayList<List<String>> tickets, boolean[] used) {
        // 机场的个数=航班数+1 证明找到了一条路径
        if (path.size() == tickets.size() + 1) {
            res = path;
            return true;
        }

        for (int i = 0; i < tickets.size(); i++) {
            //车票没用过并且车票地点与收集的路径到达地点相等 为了保证起始位置
            if (!used[i] && tickets.get(i).get(0).equals(path.getLast())) {
                //把到达地点添加到路径中
                path.add(tickets.get(i).get(1));
                //表示车票已经用过
                used[i] = true;
                if (backTracking(tickets, used)) {
                    return true;
                }
                used[i] = false;
                path.removeLast();
            }
        }
        return false;
    }
}

棋盘问题

题目14：51. N 皇后

思路：
1）递归法

class Solution {
    List<List<String>> res = new ArrayList<>();
    public List<List<String>> solveNQueens(int n) {
        char[][] chessboard = new char[n][n];
        for (char[] c : chessboard) {
            Arrays.fill(c, '.');
        }
        backTrack(n, 0, chessboard);
        return res;
    }
    public void backTrack(int n, int row, char[][] chessboard) {
        //如果递归的row 等于棋盘的行 就收集结果
        if (row == n) {
            List<String> list = new ArrayList<>();
            for (char[] c : chessboard) {
                list.add(String.copyValueOf(c));
            }
            res.add(list);
            return;
        }
        //一个一个去试列
        for (int col = 0;col < n; col++) {
            if (isValid (row, col, n, chessboard)) {
                chessboard[row][col] = 'Q';
                //递归
                backTrack(n, row+1, chessboard);
                //回溯
                chessboard[row][col] = '.';
            }
        }

    }
    public boolean isValid(int row, int col, int n, char[][] chessboard) {
        // 检查列
        for (int i=0; i<row; i++) { // 相当于剪枝
            if (chessboard[i][col] == 'Q') {
                return false;
            }
        }

        // 检查45度对角线
        for (int i=row-1, j=col-1; i>=0 && j>=0; i--, j--) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }

        // 检查135度对角线
        for (int i=row-1, j=col+1; i>=0 && j<=n-1; i--, j++) {
            if (chessboard[i][j] == 'Q') {
                return false;
            }
        }
        return true;
    }
}
题目15：37. 解数独

思路：
1）递归法

class Solution {

    public void solveSudoku(char[][] board) {
        solveSudokuHelper(board);
    }
    private boolean solveSudokuHelper(char[][] board){
        //一个for循环遍历棋盘的行，一个for循环遍历棋盘的列，
        // 一行一列确定下来之后，递归遍历这个位置放9个数字的可能性
        for (int i = 0; i < 9; i++){ // 遍历行
            for (int j = 0; j < 9; j++){ // 遍历列
                if (board[i][j] != '.'){ // 跳过原始数字
                    continue;
                }
                // (i, j) 这个位置放k是否合适
                for (char k = '1'; k <= '9'; k++){
                    if (isValidSudoku(i, j, k, board)){
                        board[i][j] = k;
                        if (solveSudokuHelper(board)){ // 如果找到合适一组立刻返回
                            return true;
                        }
                        board[i][j] = '.';
                    }
                }
                // 9个数都试完了，都不行，那么就返回false
                return false;
            }
        }
        // 遍历完没有返回false，说明找到了合适棋盘位置了
        return true;
    }
     /**
     * 判断棋盘是否合法有如下三个维度:
     *     同行是否重复
     *     同列是否重复
     *     9宫格里是否重复
     */
    private boolean isValidSudoku(int row, int col, char val, char[][] board){
        // 同行是否重复
        for (int i = 0; i < 9; i++){
            if (board[row][i] == val){
                return false;
            }
        }
        // 同列是否重复
        for (int j = 0; j < 9; j++){
            if (board[j][col] == val){
                return false;
            }
        }
        // 9宫格里是否重复
        int startRow = (row / 3) * 3;
        int startCol = (col / 3) * 3;
        for (int i = startRow; i < startRow + 3; i++){
            for (int j = startCol; j < startCol + 3; j++){
                if (board[i][j] == val){
                    return false;
                }
            }
        }
        return true;
    }
}
qq_42455789
关注
经典实用算法：回溯算法（含例题）
进击的Coder*的博客
09-07 1119
回溯算法思想 回溯算法究其思想而言，十分简单。大部分情况下，可以用于解决类似于搜索的问题。通过枚举所有的解空间，获取满足条件的解。搜索解空间时，如果当前路径满足条件，则继续向下搜索。如果当前路径已不再满足解的条件，可通过剪枝操作去除当前路径，从而避免无效的枚举。 0-1背包、8皇后、图着色、全排列等问题，均可用回溯算法来解决。 全排列问题 给定一个不含重复数字的数组nums，返回其所有可能的全排列。你可以按任意顺序返回答案。 题目来源：leetCode 输入：nums = [1,...
[宫水三叶的刷题日记]：回溯算法1
08-03
【回溯算法】是解决问题的一种策略，常用于解决组合优化问题和搜索问题。它通过尝试所有可能的解来寻找问题的正确答案，就像走迷宫一样，每走到一个岔路口，都尝试一条路径，如果发现这条路不通，就退回上一个岔路口...
【蓝桥杯C/C++】专题五：DFS深度优先搜索
程序员小火龙的知识分享
03-27 1565
本专题将讲解算法竞赛中最常用的算法dfs深度优先搜索，也叫回溯搜索法或者“暴力搜索”法，也就是说在比赛的时候就算遇到没有思路的题，也可以用递归实现暴力搜索来骗分。有的同学可能会过多的去纠结一些概念，比如递归、暴力搜索、回溯法、dfs等，其实我们大可不必去纠结，因为dfs和回溯搜索法本身就是一个算法，是用递归操作来实现的，而“暴力搜索”则是民间赋予的称号！！以下内容，我统称为回溯法（我最喜欢的名字）！回溯法也可以叫做回溯搜索法，它是一种搜索的方式。回溯的本质是穷举。
LeetCode——回溯算法的经典问题
weixin_53598445的博客
03-24 876
17. 电话号码的字母组合 给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按任意顺序 返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。 示例： 输入：digits = "23" 输出：["ad","ae","af","bd","be","bf","cd","ce","cf"] class Solution: def letterCombinations(self, digits: str) -> List[str]:
回溯算法的四道经典题目，组合，子集，图着色和n皇后
m0_64583181的博客
12-13 583
信手拈来，加油！
算法: 回溯
newxuyangcao
06-15 211
回溯算法的本质是对树型或者图型结构进行一次深度优先搜索，是一种暴力搜索算法，因此其时间复杂度是较高的，为指数级别。从题目列表来看，几乎所有的回溯算法全部可以用一个树形图来帮助我们设计程序。只有深刻理解如何绘制树形图，才能设计出回溯算法，并做出相应的剪枝操作来提升算法的效率。代码随想录中总结了一套“回溯三部曲”较为实用，其中还提供了一个回溯算法的代码模板，学习前期可以根据这个模板感受回溯算法的表象，慢慢地再深刻理解其本质，具体内容见参考资料[1]。......
算法：回溯+剪枝
weixin_42067304的博客
12-09 3837
回溯算法的定义： 在包含问题的所有解的解空间树中，按照深度优先的策略，从根结点出发搜索解空间树。算法搜索至解空间树的任一结点时，总是先判断该结点是否肯定不包含问题的解。如果肯定不包含，则跳过对以该结点为根的子树的系统搜索，逐层向其祖先结点回溯。否则，进入该子树，继续按深度优先的策略进行搜索。回溯法在用来求问题的所有解时，要回溯到根，且根结点的所有子树都已被搜索遍才结束。而回溯法在用来求问题的任一解时，只要搜索到问题的一个解就可以结束。 解空间树：依据待解决问题的特性，用树结构表示问题的解结构、用叶子表
回溯算法总结点睛
linping_的博客
06-20 4010
一、基本概念 1、什么是回溯法？ 又称回溯搜索法，说白了就是一种搜索方式。 其实回溯是递归的副产品，只要有递归就会有回溯。 回溯函数也可以称之为递归函数。 2、回溯法的效率 回溯法本质是穷举，因此并不高效 可以通过一些剪枝的操作稍微提高一些效率，但仍是比较低效的算法 3、回溯法解决的问题 经常用来解决以下 5 种问题： * 1）组合问题：**不强调**元素的顺序，N个数里按照一定的规则找出K个数的集合 * 2）排列问题：**强调**元素的顺序，N个数按一定的规则全排列，求有多少排列方式 * 3）切割问题：一
五大经典算法：回溯问题（python版）
胖大xian
03-06 3413
回溯问题（python版） 回溯算法：是五大常用算法之一、回溯算法实际上一个类似枚举的搜索尝试过程。 主要是在搜索尝试过程中寻找问题的解，当发现已不满足求解条件时，就“回溯”返回，尝试别的路径。回溯法是一种选优搜索法，按选优条件向前搜索，以达到目标。但当探索到某一步时，发现原先选择并不优或达不到目标，就退回一步重新选择，这种走不通就退回再走的技术为回溯法，而满足回溯条件的某个状态的点称为“回溯点”。再或者简单点说，用来解决一个不知道要递归多少层的循环体。 一般步骤： 1、 针对所给问题，定义问题的解空间，它
搜索算法——回溯总结01
keepstrivingchy的博客
09-18 2875
回溯算法，常常用于解决连暴力都解不了的一些难题
回溯算法总结
JavanLu的博客
12-05 1490
回溯法17. 电话号码的字母组合22. 括号生成 当遇到组合问题的时候，要想到回溯法。 17. 电话号码的字母组合 class Solution { List<String> res = new ArrayList<>(); // 储存隐射关系:这里要用Character Map<Character,String> map = new HashMap<>(); public List<String> letterCo
动态规划算法+贪心算法+回溯法实验文档
01-07
实验总结部分会总结每个算法的关键点，强调它们的优缺点，以及在实际问题中的适用场景。同时，可能还会讨论如何根据问题特性选择合适的算法，以及如何改进算法性能。 总的来说，这份实验文档通过实例分析和代码实现...
leetcode中文版-leetcode:算法笔记总结。包括《剑指offer》《程序员笔试面试指南》《Leetcode》相关题目
06-29
链表部分题目： LeetCode官方算法精选 初级算法49题： 数组系列： 字符串系列 链表系列 二叉树系列 排序系列 动态规划系列 设计系列 数学系列 其它系列 算法题型分类总结 1.冒泡排序： 原地排序，稳定排序（相邻元素...
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1256
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
二叉树最小深度
2301_80161204的博客
09-27 442
25[0, 105]
904. 水果成篮
YQ20210216的博客
09-27 353
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1082
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
8608 实现二叉排序树的各种算法(2)
最新发布
huang1xiao1sheng的博客
09-30 683
用函数实现如下二叉排序树算法： （1） 插入新结点 （2） 前序、中序、后序遍历二叉树 （3） 中序遍历的非递归算法 （4） 层次遍历二叉树 （5） 在二叉树中查找给定关键字(函数返回值为成功1,失败0) （6） 交换各结点的左右子树 （7） 求二叉树的深度 （8） 叶子结点数 输入格式 第一行：准备建树的结点个数n 第二行：输入n个整数，用空格分隔 第三行：输入待查找的关键字 第四行：输入待查找的关键字 第五行：输入待插入的关键字 输出格式 第一行：二叉树的先序遍历序列
回溯算法：搜索策略与迷宫求解实例
在处理更复杂的道路问题，如题目中的四路口到达B路口的情况，由于每个路口有三条分叉路，回溯算法就显得尤为重要。我们通过系统地搜索和尝试，遵循一定规则（如先尝试主要路径或按照某种顺序），在遇到不可行的路径...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值