二刷 动态规划

最新推荐文章于 2024-09-28 10:13:25 发布
最新推荐文章于 2024-09-28 10:13:25 发布
阅读量985 收藏 30
点赞数 25
文章标签： 动态规划 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_56047026/article/details/140117381
版权

什么是动态规划 Dynamic Programming DP

如果某一问题有很多重叠子问题，使用动态规划时最有效的

动态规划中每一个状态是由上一个状态推导出来的。

动规五部曲

1.确定dp数组以及下标的含义

2.确定递归公式

3.dp数组如何初始化

4.确定遍历顺序

5.举例推导dp数组

509.斐波那契数

1.确定dp数组和下标的含义

dp[i]:第i个数的斐波那契数值是dp[i]

2.确定递推公式

dp[i] = dp[i-1]+dp-i-2

3.dp数组如何初始化

dp[0] = 0;

dp[1]=  1

4.确定遍历顺序

dp[i]依赖dp[i-1],dp[i-2]，因此是从前向后

5.举例推导

0 1 1 2 3 5 8 13

class Solution {
public:
    int fib(int n) {
        //如果是0,1,直接返回
        if(n <= 1) return n;
        //创建dp数组
        vector<int> dp(n+1);
        //初始化
        dp[0] = 0;
        dp[1] = 1;
        for (int i = 2; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];

    }
};

70.爬楼梯

假设你正在爬楼梯。需要 n 阶你才能到达楼顶。

每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？

注意：给定 n 是一个正整数。

示例 1：

  • 输入： 2
  • 输出： 2
  • 解释： 有两种方法可以爬到楼顶。
    • 1 阶 + 1 阶
    • 2 阶

1.确定dp数组及下标含义

dp[i]:爬上i楼有dp[i]种方法

2.确定递推公式

第一层有一种方法

第二层有两种方法

第一层跨两步到第三层；第二层跨一步到第三层；

所以第三层楼梯的状态可以由第二层楼梯和到第一层楼梯的状态推导出来

dp[i-1]，上i-1层楼梯，有dp[i-1]种方法，再一步跳一个台阶到dp[i]

dp[i-2]，上i-2层楼梯，有dp[i-2]种方法，再一步跳两个台阶就是dp[i]。

dp = dp[i-1]+dp[i-2]

3.dp数组初始化

dp[1] = 1

dp[2] = 2

4.确定遍历顺序

从前向后

5.模拟

class Solution {
public:
    int climbStairs(int n) {
        if ( n <= 1) return n;
        vector<int> dp(n+1);
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
        }
        return dp[n];
    }
};

746. 使用最小花费爬楼梯

给你一个整数数组 cost ，其中 cost[i] 是从楼梯第 i 个台阶向上爬需要支付的费用。一旦你支付此费用，即可选择向上爬一个或者两个台阶。

你可以选择从下标为 0 或下标为 1 的台阶开始爬楼梯。

请你计算并返回达到楼梯顶部的最低花费。

1.确定dp数组和下标含义

dp[i]:到达i楼层的最低花费是dp[i]

2.确定递推公式

dp[i] = dp[i-1] + cost[i -1]

dp[i] = dp[i-2] + cost[i -2]

dp[i] = min(dp[i-1] + cost[i-1], dp[i-2] + cost[i-2]);

3.初始化

到达第0和第1台阶不需要花费体力

dp[0] = 0;

dp[1] = 0;

4.遍历顺序

从前向后

5.模拟

此处的n是cost.size(）

class Solution {
public:
    int minCostClimbingStairs(vector<int>& cost) {
        vector<int> dp(cost.size() + 1);
        dp[0] = 0;
        dp[1] = 0;
        for (int i = 2; i <= cost.size(); i++) {
            dp[i] = min (dp[i-1] + cost[i - 1], dp[i-2] + cost[i - 2]);
        }
        return dp[cost.size()];
    }
};

62.不同路径

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为 “Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为 “Finish” ）。

问总共有多少条不同的路径？

机器人从00出发到m-1,n-1

1.确定dp数组和下标含义

dp[i][j]：从00出发到ij有dp[i][j]条不同的路径

2.确定递推公式

只有两个方向能来

dp[i][j] = dp[i-1][j] + dp[i][j-1];

3.初始化

for  dp[i][0] = 1

for  dp[0][j] = 1

4.遍历顺序

从左到右一层一层遍历

注意最后一个点是m-1，n-1

class Solution {
public:
    int uniquePaths(int m, int n) {
        vector<vector<int>> dp(m, vector<int>(n, 0));
        for(int i = 0; i < m; i++) dp[i][0] = 1;
        for(int j = 0; j < n; j++) dp[0][j] = 1;
        //双层循环
        for(int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++){
                dp[i][j] = dp[i][j - 1] + dp[i - 1][j];
            }
        }
        return dp[m - 1][n - 1];
    }
};

63. 不同路径 II

一个机器人位于一个 m x n 网格的左上角 （起始点在下图中标记为“Start” ）。

机器人每次只能向下或者向右移动一步。机器人试图达到网格的右下角（在下图中标记为“Finish”）。

现在考虑网格中有障碍物。那么从左上角到右下角将会有多少条不同的路径？

思路：

1.确定dp数组和下标含义

dp[i][j]:从00到m-1,n-1有dp[i-1][j-1]条路径

2.确定递推公式

没有障碍情况下

if（obstacleGrid[i][j] == 0）

dp[i][j] = dp[i-1][j] + dp[i][j-1]

3.确定初始化

没有障碍才能为1

4.左上到右下

class Solution {
public:
    int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) {
        int m = obstacleGrid.size();
        int n = obstacleGrid[0].size();
        //起点或终点有障碍物,直接返回0;
        if (obstacleGrid[0][0] == 1 || obstacleGrid[m-1][n-1] == 1) return 0;
        vector<vector<int>> dp(m, vector<int>(n, 0));
        // 初始化，没有障碍物才能为1，遇到障碍物就为0
        for (int i = 0; i < m && obstacleGrid[i][0] == 0; i++) dp[i][0] = 1;
        for (int j = 0; j < n && obstacleGrid[0][j] == 0; j++) dp[0][j] = 1; 
        //遍历，遇到障碍物就跳过
        for (int i = 1; i < m; i++) {
            for (int j = 1; j < n; j++) {
                if (obstacleGrid[i][j] == 1) continue;
                dp[i][j] = dp[i-1][j] + dp[i][j-1];
            }
        }
        return dp[m-1][n-1];
    }
};

343. 整数拆分

给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。

示例 1:

  • 输入: 2
  • 输出: 1
  • 解释: 2 = 1 + 1, 1 × 1 = 1。

1.确定dp数组和下标的含义

dp[i]:正整数i划分后得到的最大乘积

2.确定递推公式

从1遍历j，

将i划分为两个数 ：dp = j*(i-j)

继续划分：j*dp[i-j]

dp[i] = max({dp[i], j*(i-j),j*dp[i-j]})

3.初始化

dp[2] = 1

4.递归顺序

从前向后

class Solution {
public:
    int integerBreak(int n) {
        vector<int> dp(n + 1);
        dp[2] = 1;
        for (int i = 3; i <= n; i++) {
            //i/2：一般乘积最大 是中间的数
            for (int j = 1; j <= i/2; j++) {
                //j * (i-j)表示分成两个数字；j*dp[i - j]表示分成两个以上数字
                dp[i] = max(dp[i], max(j * (i - j), j * dp[i - j]));
            }
        }
        return dp[n];
    }
};

96.不同的二叉搜索树

给定一个整数 n，求以 1 ... n 为节点组成的二叉搜索树有多少种？

1.确定dp[i]数组及下标的含义

dp[i]:以1-i为节点组成的二叉搜索树由dp[i]种

2.确定递推公式

n=3时

元素1为头节点搜索树的数量 = 右子树有2个元素的搜索树数量*左子树有0个元素的搜索树数量

元素2为头结点搜索树的数量 = 右子树有1个元素的搜索树数量*左子树有1个元素的搜索树数量

元素3为头结点搜索树的数量 = 右子树有0个元素的搜索树数量*左子树有2个元素的搜索树数量

有两个元素的搜索树数量是dp[2]

有1个元素的搜索树数量是dp[1]

有0个元素的搜索树数量是dp[0]

dp[3] = dp[2]*dp[0] + dp[1]*dp[1]+dp[0]*dp[2]

dp[i] += dp[以j为头结点左子树节点数量]*dp[以j为头结点右子树节点数量]

j相当于头节点的元素，从1遍历到i为止

递推公式：dp[i] += dp[j - 1]*dp[i-j]

3.初始化

dp[0] = 1;

4.遍历顺序

i是依靠i之前的节点数的状态

for(int i = 1; i<=n; i++) {

        for (int j = 1;j <= i;j++) {

                dp[i] += dp[j - 1]* dp[i-j] }

}

5.模拟

class Solution {
public:
    int numTrees(int n) {
        vector<int> dp(n + 1);
        dp[0] = 1;
        for (int i = 1; i <= n; i++) {
            for (int j = 1; j <= i; j++) {
                dp[i] += dp[j - 1] * dp[i - j];
            }
        }
        return dp[n];
    }
};

198.打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

  • 示例 1：
  • 输入：[1,2,3,1]
  • 输出：4

1.确定dp[i]数组及下标的含义

dp[i]:考虑下标i以内的房屋，偷窃的最高金额

2.确定递推公式

如果偷第i间房，找出i-2以内的房屋最多可偷的金额+这间房的金额：dp[i] = dp[i - 2] + nums[i]

如果不偷第i间房，则可以考虑第i-1间房，但不一定就要偷i-1：dp[i] = dp[i-1]

dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);

3.初始化

dp[0] = nums[0];

dp[1] = max(nums[0], nums[0]);

4.遍历顺序

从前往后

  

注意要当nums只有一个时，直接返回这个即可。

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        vector<int> dp(nums.size());
        dp[0] = nums[0];
        dp[1] = max(nums[0], nums[1]);
        for (int i = 2; i < nums.size(); i++) {
            dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
        }
        return dp[nums.size() - 1];
    }
};

213.打家劫舍II

你是一个专业的小偷，计划偷窃沿街的房屋，每间房内都藏有一定的现金。这个地方所有的房屋都 围成一圈 ，这意味着第一个房屋和最后一个房屋是紧挨着的。同时，相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警 。

给定一个代表每个房屋存放金额的非负整数数组，计算你 在不触动警报装置的情况下 ，能够偷窃到的最高金额。

示例 1：

  • 输入：nums = [2,3,2]

  • 输出：3

1.确定dp数组和下标的含义

dp[i]:i房屋以内的房屋最大的偷窃金额是dp[i]

2.确定递推公式

考虑两种情况:只包含头和只包含尾分别考虑，取最大值

class Solution {
public:
    int rob(vector<int>& nums) {
        if (nums.size() == 1) return nums[0];
        int result1 = robRange(nums, 0, nums.size() - 2);
        int result2 = robRange(nums, 1, nums.size() - 1);
        return max (result1, result2);
    }

    int robRange(vector<int>& nums, int start, int end) {
    vector<int> dp(nums.size());
    dp[start] = nums[start];
    dp[start + 1] = max(nums[start], nums[start + 1]);
    for (int i = start + 2; i <= end; i++) {
        dp[i] = max(dp[i - 2] + nums[i], dp[i - 1]);
    }
    return dp[end];
}
};

121. 买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

  • 示例 1：

  • 输入：[7,1,5,3,6,4]

  • 输出：5

1.确定dp[i]及下标的含义

dp[i][0]:第i天不持有股票

dp[i][1]:第i天持有股票

2.递推公式

dp[i][0]:第i天不持有股票有两种情况

第i-1天就不持有：dp[i - 1][0]

第i-1天持有，第i天卖出：dp[i - 1][1] + prices[i]

求最大值

dp[i][1]：第i天持有股票有两种情况

第i-1天就持有：dp[i - 1][1]

第i-1天不持有，第i天买入:- prices[i]

---这里 只买一次，第一次买股票 手头现金一定是0，所以直接-prices[i]

求最大值

3.初始化

dp[0][0] = 0

dp[0][1] = -prices[0]

4.遍历顺序

5.模拟

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if (prices.size() == 0) return 0;
        vector<vector<int>> dp(prices.size(),vector<int>(2));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < prices.size(); i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max(-prices[i], dp[i - 1][1]);
        }
    //最后一定是选择不持有股票赚的多
        return dp[prices.size() - 1][0];
    }
};

122.买卖股票的最佳时机II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。

  • 示例 1:

  • 输入: [7,1,5,3,6,4]

  • 输出: 7

1.确定dp[i]数组及下标的含义

dp[i][0]:不持有股票

dp[i][1]:持有股票

2.确定递推公式

dp[i][0]:第i天不持有股票

第i-1天就不持有，dp[i-1][0]

第i-1天持有，第i天卖出：dp[i - 1][1] + prices[i]

dp[i][1]:第i天持有股票

第i-1天就持有：dp[i-1][1]

第i-1天不持有,第i天买入：dp[i - 1][0] -prices[i]

唯一不同点：买卖多次股票，买入的时候手头现金非0

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int len = prices.size();
        vector<vector<int>> dp(len, vector<int>(2, 0));
        dp[0][0] = 0;
        dp[0][1] = -prices[0];
        for (int i = 1; i < len; i++) {
            dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);
            dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i]);
        }
        return dp[len - 1][0];
    }
};

647. 回文子串

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

  • 输入："abc"
  • 输出：3
  • 解释：三个回文子串: "a", "b", "c"

1.确定dp[i]及下标的含义

dp[i][j]:[i,j]区间内是否是回文串

2.递推公式

s[i]==s[j]分为三种情况

a, aa都属于i-j<=1,相差一个距离

相差多个距离ababa，要根据dp[i+1][j-1]是否满足回文串了

3.初始化

初始都为false

4.遍历顺序

因为dp[i][j]依赖于dp[i+1][j-1] 所以从下往上从左往右

class Solution {
public:
    int countSubstrings(string s) {
        int len = s.size();
        int result = 0;
        vector<vector<bool>> dp(len, vector<bool>(len, false));
        for (int i = len - 1; i >= 0; i--) {
            for (int j = i; j < len; j++) {//j从i开始
                if (s[i] == s[j]) {
                    if (j - i <= 1) {
                        result++;
                        dp[i][j] = true;
                    } else if (dp[i + 1][j - 1]) {
                        result++;
                        dp[i][j] = true; 
                    }
                }
            }
        }
        return  result;
    }
};

516.最长回文子序列

给定一个字符串 s ，找到其中最长的回文子序列，并返回该序列的长度。可以假设 s 的最大长度为 1000 。

示例 1: 输入: "bbbab" 输出: 4 一个可能的最长回文子序列为 "bbbb"。

示例 2: 输入:"cbbd" 输出: 2 一个可能的最长回文子序列为 "bb"。

回文子序列不连续

1.确定dp[i]数组和下标

dp[i][j]：字符串s在[i,j]范围里最长的回文子序列的长度是dp[i][j]

2.确定递推公式

如果s[i] == s[j] ，dp[i][j] = dp[i+1][j-1]+2

如果s[i] != s[j]， dp[i][j] = max(dp[i+1][j], dp[i][j-1])；看看分别加入s[i]、s[j]哪一个可以组成最长的回文子序列。

3.初始化

i=j相同的时候，初始化为1

其他默认为0

4.遍历顺序

dp[i][j]依赖于dp[i+1][j-1]，从下往上，从左往右

内层循环：for(j = i+1)原因是，j必须大于i，并且j=i已经初始化了

class Solution {
public:
    int longestPalindromeSubseq(string s) {
        vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));
        //i=j的时候,为1
        for(int i = 0; i < s.size(); i++) dp[i][i] =1;
        for(int i = s.size() - 1; i >= 0; i--) {
            for (int j = i + 1; j < s.size(); j++) {
                if (s[i] == s[j]) {
                    dp[i][j] = dp[i + 1][j - 1] + 2;
                }else if (s[i] != s[j]) {
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1]);
                }
            }
        }
        return dp[0][s.size() - 1];
    }
};

2_33_
关注
java动态规划
weixin_40540942的博客
05-15 2242
存在若干步骤，并且每个步骤都面临若干选择。如果要求列出所有解就是回溯法。如果是求最优解（通常是最大值最小值）就用动态规划。1.波契那亚数列和爬楼梯2.背包问题3.打家劫舍4.股票问题5.子序列问题。
动态规划刷表法
AI_xue
08-13 7329
一.先简单讲下什么是填表法，什么是刷表法。 填表法 ：就是一般的动态规划，当前点的状态，可以直接用状态方程，根据之前点的状态推导出来。 刷表法：由当前点的状态，更新其他点的状态。需要注意：只用当每个状态所依赖的状态对它的影响相互独立。 二.通过例题看刷表 链接：http://exam.upc.edu.cn/problem.php?id=2383 题意：三个数，T表示最大的饱腹值，A表示吃
C++动态规划
闻缺陷则喜何志丹
01-20 2007
动态规划（Dynamic Programming，DP）是运筹学的一个分支，是求解决策过程最优化的过程。每次决策依赖于当前状态，又随即引起状态的转移。一个决策序列就是在变化的状态中产生出来的，所以，这种多阶段最优化决策解决问题的过程就称为动态规划。
动态规划的时间复杂度优化
闻缺陷则喜何志丹
02-26 5161
优化动态规划的时间复杂度，主要有如下几种：
动态规划的解题思想
三翼鸟数字化平台的技术实践分享
09-05 1363
那些忘记过去的人，注定要重蹈覆辙
为什么你学不过动态规划？告别动态规划，谈谈我的经验
热门推荐
帅地
11-24 2万+
动态规划难吗？说实话，我觉得很难，特别是对于初学者来说，我当时入门动态规划的时候，是看 0-1 背包问题，当时真的是一脸懵逼。后来，我遇到动态规划的题，看的懂答案，但就是自己不会做，不知道怎么下手。就像做递归的题，看的懂答案，但下不了手，关于递归的，我之前也写过一篇套路的文章，如果对递归不大懂的，强烈建议看一看：为什么你学不会递归，告别递归，谈谈我的经验 对于动态规划，春招秋招时好多题都会用到动态...
动态规划详解
每天学习一点点，成长一小步
03-23 2万+
以下为最常见的使用动态规划的例子： 一、动态规划的三大步骤 动态规划，无非就是利用历史记录，来避免我们的重复计算。而这些历史记录，我们得需要一些变量来保存，一般是用一维数组或者二维数组来保存。下面我们先来讲下做动态规划题很重要的三个步骤： 第一步骤：定义数组元素的含义，上面说了，我们会用一个数组，来保存历史数组，假设用一维数组 dp[] 吧。这个时候有一个非常非常重要的点，就是规定你这个数组元素的含义，例如你的 dp[i] 是代表什么意思？ 第二步骤：找出数组元素之间的关系式，我觉得动态规划，还是有一点类
推导动态规划问题的公式
Angus
10-18 1247
学如逆水行舟，不进则退。当我堆算法题的概念还停留在1000题的时候，今天打开力扣一看，已经更新到1900道题了。真的是，没有进步就是在退步。 意识到了算法的重要性，也想通过算法来给自己提升一点自信，又或者说给自己增加一点底气！ 我始终认为，算法题这个东西，它是一个闻道有先后的问题，并不是和智商挂钩的问题。但是算法也是始终压在我身上的一座大山。翻不过去，我永远都是弟弟。 最近在摸索一些解题思路，和解题技巧。我会用脑图，加文字，加图片的形式来记录自己的学习和领悟的过程。 正...
备赛蓝桥杯-算法-动态规划
2302_76949164的博客
03-04 1409
动态规划这个思想，是要靠刷题刷出题感的啊
动态规划总结
CSharpIsDog的博客
11-13 667
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 动态规划总结前言一、动态规划是什么？二、什么问题适用于动态规划1.计数问题2.最大最小值问题3.求存在性问题三、求解动态规划的一般步骤1. 确定状态2. 写出状态转移方程3. 初始条件和边界情况4. 计算顺序 前言 刷Leetcode有段时间了，作为初级菜鸟水平，遇到复杂点的算法几乎无从下手，最近做动态规划，总结了一些问题。。 一、动态规划是什么？ 动态规划算法通常用于求解具有某种最优性质的问题。在这类问题中，可能会有许多可行解。每一个
C++之动态规划问题汇总
03-05
#### 二、动态规划基础知识回顾 在深入分析题目之前，先简要回顾一下动态规划的基本概念： - **状态定义**：确定动态规划问题中的状态变量。 - **状态转移方程**：定义如何从一个状态转移到另一个状态。 - **边界...
关于一维/二维数组动态规划的思考(javaScript角度)
m0_60360320的博客
09-25 584
动态规划思想是从运筹学上渗透下来的，用来求解某种有最优性质解的问题。首先得满足三大性质： 1.最优解原理，问题包含的最优解子问题也是最优的 2.无后效性，即是先前状态的确定后，将不会再受之后状态的影响。 3.有重叠子问题，先前状态的解在之后会被用到(但是这个不是必需的) 因此，解题的步骤也比较有“技巧性”的分为几步： 划分阶段：按照问题的时空特征，将问题划分为有序的几个阶段。 确定状态变量：将各个阶段用不同的状态表示出来。 写出状态转移方程：根据上一阶段的状态推导出本阶段的状态。 寻找边界条
二叉树最小深度
2301_80161204的博客
09-27 455
25[0, 105]
使用Python实现图形学的纹理映射算法
qq_42568323的博客
09-27 1263
纹理映射的基本概念是将二维图像（纹理）应用于三维模型的表面，以便在渲染时提供更多的细节和视觉效果。纹理坐标生成：为每个顶点生成对应的纹理坐标，通常使用归一化的二维坐标系统。纹理采样：根据生成的纹理坐标从纹理图像中获取颜色值。光照计算：结合光照模型，计算最终颜色，产生更真实的效果。图像合成：将计算得到的颜色与其他渲染信息合成，生成最终图像。纹理映射不仅可以用于简单的颜色填充，还可以模拟表面细节、光照变化等，提升渲染效果。
904. 水果成篮
YQ20210216的博客
09-27 356
转化，找出一个最长的子数组长度，子数组中不超过两种类型的水果，要记录水果类型和水果数量，所以要使用unord_map，key来记录水果中类，valuse记录水果数量，当right开始增加的时候，将水果种类加入到哈希表中，当水果中类超过两种时，控制left使得水果种类回到两种。你想要尽可能多地收集水果。你正在探访一家农场，农场从左到右种植了一排果树。这些树用一个整数数组。，返回你可以收集的水果的。
【优选算法】（第一篇）
weixin_73861555的博客
09-25 1085
这个⽅法是往后我们学习「快排算法」的时候，「数据划分」过程的重要⼀步。如果将快排算法拆解的话，这⼀段⼩代码就是实现快排算法的「核⼼步骤」。
代码随想录算法训练营|226.翻转二叉树 、 101. 对称二叉树、 104.二叉树的最大深度、 111.二叉树的最小深度
cccoffer的博客
09-27 385
这里只是取最小值是不正确的，因为一旦有一个节点的左或右节点出现了空，此时这个位置成为了最小值，但是不符合题意的，题意是到叶子节点的最小深度。首先交换当前节点的左右子节点，然后递归当前节点的左右子节点（相当于到了子节点还是做同样的操作），知道所有节点遍历完了，就完成了翻转，返回root即可。思路：这题的就是区分高度和深度的题目，不过也可以用求高度的方法求得（即求根节点的高度即可，这个就是用到了后序遍历），求深度就是从根节点开始遍历，直到找到最深的叶子节点即可（相当于前序遍历），这里用前序遍历的方式解题。
560. 和为 K 的子数组
mrjieke6的博客
09-24 298
子数组是数组中元素的连续非空序列。
【反素数】
最新发布
Kent的博客
09-28 375
【代码】【反素数】
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值