（六）动态规划【C++刷题】
作者：互联网
圆环回原点问题
1.问题描述
一个环，有n个点，编号从0增加，从原点0出发，每次只能走一步，每步可以顺时针到下一个点，也可以逆时针到上一个点，经过k步回到原点有多少种方法？
2.输入输出
- Input：[0, 1, 2, 3, 4, 5, 6, 7, 8, 9], k=1/2
- Output:0/2
3.算法分析
*【动态规划】回到0点可以从右面回来，也可以从左面回来，有多少种方法。
- dp[k][j]表示从j点走k步到达原点0的方法树，转化为相邻的点经过k-1步回到原点的问题：
4.编程实现
#include <iostream>
#include <vector>
using namespace std;
class Solution {
public:
int getStepNum(vector<int> &nums, int k) {
int n = nums.size();
int dp[k+1][n]; // dp[i][j]表示经过i步到达k点的方法数
dp[0][0] = 1; // 经过0步到达0点的方法数为1
for (int i = 1; i < n; i++) {
dp[0][i] = 0;
}
for (int i = 1; i <= k; i++) {
for (int j = 0; j < n; j++) {
dp[i][j] = dp[i-1][(j+1) % n] + dp[i-1][(j-1+n) % n];
}
}
return dp[k][0];
}
};
int main() {
vector<int> nums = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
int k = 2;
Solution sol;
cout << sol.getStepNum(nums, k);
}
接雨水
leetcode：https://leetcode-cn.com/problems/trapping-rain-water/
Nowcoder：https://www.nowcoder.com/practice/31c1aed01b394f0b8b7734de0324e00f?tpId=188
1.问题描述
给定 n 个非负整数表示每个宽度为 1 的柱子的高度图，计算按此排列的柱子，下雨之后能接多少雨水。
2.输入输出
- Input：height = [0,1,0,2,1,0,1,3,2,1,2,1]
- Output：6
3.算法分析
【解法一：动态规划】对于下标i，下雨后水能到达的最大高度等于下标i两边的最大高度的最小值，下标i处能接到的雨水量等于下标i处的水能到达的最大高度减去height[i]。
思路：从左向右扫描得到每个height获得到左边最大高度，从右到左扫描得到每个height获得右边最大高度，最后遍历一遍每个下标位置即可得到能接的雨水总量。即两个dp数组。
- 时间复杂度：\(O(n)\)
- 空间复杂度：\(O(n)\)
【解法二：单调栈】维护一个单调栈，单调栈存储的是下标，满足从栈底到栈顶的下标对应的数组height中的元素递减。
（1）从左到右遍历数组，遍历到下标i时，如果栈内至少有两个元素，记栈顶元素为top，top的下面一个元素是left，则一定有height[left]≥height[top]。如果height[i]>height[top]，则得到一个可以接雨水的区域，该区域的宽度是i-left-1，高度是min(height[left], height[i]-height[top])，根据宽度和高度计算得到该区域能接的雨水量。
（2）为了得到left，需要将top出栈。对top计算能接的雨水量之后，left变成新的top，重复上述操作，直到栈为空，或者栈顶下标对应的hegiht中的元素大于或等于height[i]。
（3）在对下标i处计算能接的雨水量之后，将i入栈，继续遍历后面的下标，计算能接的雨水量。遍历结束后得到能接的雨水量。
- 时间复杂度：\(O(n)\)
- 空间复杂度：\(O(n)\)
【解法三：双指针】动态规划中，将leftMax和rightMax最小值决定，从左往右和从右往左，用双指针和两个变量代替两个数组。
- 时间复杂度：O(n)
- 空间复杂度：O(1)
4.编程实现
// #include <bits/stdio.h>
#include <iostream>
#include <vector>
#include <stack>
using namespace std;
class Solution {
public:
int trap1(vector<int> &heights) {
// 动态规划法
int n = heights.size();
if (n == 0) return 0;
vector<int> leftMax(n, 0);
leftMax[0] = heights[0];
for (int i = 1; i < n; i++) {
leftMax[i] = max(leftMax[i-1], heights[i]);
}
vector<int> rightMax(n, 0);
rightMax[n-1] = heights[n-1];
for (int i = n-2; i >= 0; i--) {
rightMax[i] = max(rightMax[i+1], heights[i]);
}
int ans = 0;
for (int i = 0; i < n; i++) {
ans += min(leftMax[i], rightMax[i]) - heights[i];
}
return ans;
}
int trap2(vector<int> &heights) {
// 单调栈法
int n = heights.size(), ans = 0;
stack<int> stk;
for (int i = 0; i < n; i++) {
while (!stk.empty() && heights[i] > heights[stk.top()]) {
int top = stk.top();
stk.pop();
if (stk.empty()) break;
int left = stk.top();
int currWidth = i - left - 1;
int currHeight = min(heights[left], heights[i]) - heights[top];
ans += currWidth * currHeight;
}
stk.push(i);
}
return ans;
}
int trap3(vector<int> &heights) {
// 双指针——dp空间压缩法
int ans = 0, left = 0, right = heights.size() - 1;
int leftMax = 0, rightMax = 0;
while (left < right) {
leftMax = max(leftMax, heights[left]);
rightMax = max(rightMax, heights[right]);
if (heights[left] < heights[right]) {
ans += leftMax - heights[left];
++left;
} else {
ans += rightMax - heights[right];
--right;
}
}
return ans;
}
};
int main() {
vector<int> heights;
int val;
Solution sol;
getchar();
while (cin >> val) {
heights.push_back(val);
if (cin.get() == ']') break;
}
cout << sol.trap3(heights) << endl;
return 0;
}
最大子序和
Leetcode：https://leetcode-cn.com/problems/maximum-subarray/)
1.问题描述
给定一个整数数组nums，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
2.输入输出
Input：nums=[-2, -1, -3, 4, -1, 2, 1, -5, 4]
Output：6
3.算法分析
（1）划分子问题：每个数字都可以选择加入前一位的序列或者当前序列重新开始求和。
（2）定义子问题：定义一维数组dp[n]，结果定义sum
（3）确定边界：dp[0] = nums[0]。
（4）状态转移方程确定：dp[i]=max(dp[i-1]+nums[i], nums[i])，sum为max(sum, dp[i])
4.编程实现
#include <iostream>
#include <string>
#include <vector>
using namespace std;
class Solution{
public:
int maxSubArray(vector<int> & nums) {
int n = nums.size();
if (n == 1) return nums[0];
int pre = 0, sum = nums[0];
for (int i = 0; i < n; i++) {
pre = max(pre+nums[i], nums[i]);
sum = max(sum, pre);
}
return sum;
}
};
int main() {
int get;
Solution sol;
vector<int> nums;
getchar();
while (cin >> get) {
nums.push_back(get);
if (cin.get() == ']') break;
}
cout << sol.maxSubArray(nums) << endl;
return 0;
}
标签：nums,int,C++,heights,height,left,动态,dp,刷题 来源： https://www.cnblogs.com/caoer/p/15722425.html