基础知识:
动态规划:
1、确认原问题和子问题
2、确认状态
3、确认边界条件
4、确认转移方程
leetcode题目
70. Climbing Stairs
题意:
每次可以上1阶和2阶,上n阶楼梯,有多少中可能的情况。
解题思路:
最暴力的做法是递归,时间复杂度O(2^n)会超时:
class Solution {
public:
int climbStairs(int n) {
if (n == 1 || n== 2){
return n;
}
return climbStairs(n-1) + climbStairs(n-2);
}
};
找出递推关系:
a[n] = a[n-1] + a[n-2]
代码:
class Solution {
public:
int climbStairs(int n) {
vector<int> dp(n+3,0);
dp[1] = 1;
dp[2] = 2;
for (int i = 3; i<=n; i++){
dp[i] = dp[i-1] + dp[i-2];
}
return dp[n];
}
};
198. House Robber
题意:
盗取最多的财宝,但是不能在相邻的房间同时取财宝
解题思路:
尝试了一下贪心算法不行:
如果每次取最大的,遇到[2, 3, 2]的情况,会先取3,但是2+2=4才是最大解。
int compare(pair<int, int> a, pair<int, int> b){
return a.first > b.first;
}
class Solution {
public:
int rob(vector<int>& nums) {
int *able = new int[nums.size()]();
vector<pair<int, int>> nums_pair;
int result = 0;
for (int i = 0; i < nums.size(); i++){
pair<int, int> temp = make_pair(nums[i], i);
nums_pair.push_back(temp);
}
sort(nums_pair.begin(), nums_pair.end(), compare);
for (int j = 0; j < nums_pair.size(); j++){
if (able[nums_pair[j].second] == 0){
result = result + nums_pair[j].first;
if (nums_pair[j].second - 1 >= 0){
able[nums_pair[j].second - 1] = 1;
}
if (nums_pair[j].second + 1 < nums.size()){
able[nums_pair[j].second + 1] = 1;
}
}
}
return result;
}
};
动态规划的方法:
- 转移方程:选不选第i个,如果如果i+dp[i-2]>dp[i-1]则选,否者不选。
- 边界条件:第1个是1个数。第二个是前两个的较大值。
###代码:
class Solution {
public:
int rob(vector<int>& nums) {
vector<int> dp(nums.size(),0);
if (nums.size() == 0){
return 0;
}
if (nums.size() == 1){
return nums[0];
}
dp[0] = nums[0];
dp[1] = max(nums[0], nums[1]);
for (int i = 2; i < nums.size(); i++){
dp[i] = max(dp[i-1], dp[i-2] + nums[i]);
}
return dp[nums.size()-1];
}
};
53. Maximum Subarray
题意:
找数组的最大的一段连续子数组。
解题思路:
- 转移方程:
d[i-1] + i 是否大于 i 如果大于 dp[i] = d[i-1] + i 否则为 i , 同时要维护实时的最大返回值,max_res,如果dp[i] > max_res 则 max_res更新为 dp[i] - 边界条件:
dp[0] = nums[0];
代码:
class Solution {
public:
int maxSubArray(vector<int>& nums) {
vector<int> dp(nums.size(), 0);
dp[0] = nums[0];
int max_res = dp[0];
for (int i = 1; i < nums.size(); i++){
dp[i] = max(dp[i-1] + nums[i], nums[i]);
if (max_res < dp[i]){
max_res = dp[i];
}
}
return max_res;
}
};
322. Coin Change
题意:
给出零钱的面值和零钱的总和,返回最少需要多少个零钱去找零,如果不能找零返回-1。
###解题思路:
要整除才能使用贪心算法,这里不行。
按照钱的面值进行递推,每个面值选取各个零钱面值的前面的最优面值,+1看哪个选择最小,选择这个作为该面值的最优解。
代码:
class Solution {
public:
int coinChange(vector<int>& coins, int amount) {
vector<int> dp;
for (int i = 0; i <= amount; i++){
dp.push_back(-1);
}
dp[0] = 0;
for (int i = 1; i <= amount; i++){
for (int j = 0; j < coins.size(); j++){
if (i - coins[j] >= 0 && dp[i - coins[j]] != -1){
if (dp[i] == -1 || dp[i - coins[j]] + 1 < dp[i]){
dp[i] = dp[i - coins[j]] + 1;
}
}
}
}
return dp[amount];
}
};
120. Triangle
题意:
给出一个三角形,找出从上到下,最短的路径节点和,只能往相邻的节点跳。
解题思路:
从下往上解题能降低一点的计算复杂度。递推的计算出每个dp[i][j]
的最优解。最优解的转移公式是:min(dp[i+1][j], dp[i+1][j+1])+triangle[i][j]
,边界条件是:最下面的一行是triangle的值。
代码:
class Solution {
public:
int minimumTotal(std::vector<std::vector<int> >& triangle){
if (triangle.size() == 0){
return 0;
}
vector<vector<int>> dp;
for (int i = 0; i < triangle.size(); i++){
dp.push_back(vector<int>());
for (int j = 0; j < triangle[i].size(); j++){
dp[i].push_back(0);
}
}
for (int i = 0; i < dp.size(); i++){
dp[dp.size() - 1][i] = triangle[dp.size() - 1][i];
}
for (int i = dp.size() - 2; i >= 0; i --){
for (int j = 0; j < dp[i].size(); j++){
dp[i][j] = min(dp[i+1][j], dp[i+1][j+1]) + triangle[i][j];
}
}
return dp[0][0];
}
};
300. Longest Increasing Subsequence
题意:
求最长的上升子序列,子序列就是每个元素有选与不选两种可能,一共有2^n个子序列。
解题思路:
动态规划:时间复杂度O(n^2)
dp[i]储存的是第i位的最长上升子序列。
转移方程:dp[i]去遍历dp[0]到dp[(i-1)],找出nums[i]比其末尾值大的最大值;
边界条件:dp[i]=1
代码:
class Solution {
public:
int lengthOfLIS(vector<int>& nums) {
if (nums.size() == 0){
return 0;
}
int LIS = 0;
vector<int> dp(nums.size(), 0);
dp[0] = 1;
for (int i = 0; i < nums.size(); i++){
dp[i] = 1;
for (int j = 0; j < i; j++){
if (nums[i] > nums[j] && dp[i] < dp[j] + 1){
dp[i] = dp[j] + 1;
}
}
if (dp[i] > LIS){
LIS = dp[i];
}
}
return LIS;
}
};
解题思路:
用栈的思想解法:时间复杂度O(nlogn)
维护一个栈,栈的size是最长上升子序列的长度,栈i的值是能维持长度i的上升序列的最小的数值。
遍历nums数组,如果大于栈底直接压入,如果小于,找到栈中能插入nums[i]的位置,用二分查找找能把时间复杂度将为nlogn
代码:
int binary_search(std::vector<int> nums, int target){
int index = -1;
int begin = 0;
int end = nums.size() - 1;
while (index == -1){
int mid = (begin + end) / 2;
if (target == nums[mid]){
index = mid;
}
else if (target < nums[mid]){
if (mid == 0 || target > nums[mid - 1]){
index = mid;
}
end = mid - 1;
}
else if (target > nums[mid]){
if (mid == nums.size() - 1 || target < nums[mid + 1]){
index = mid + 1;
}
begin = mid + 1;
}
}
return index;
}
class Solution {
public:
int lengthOfLIS(std::vector<int>& nums) {
if (nums.size() == 0){
return 0;
}
std::vector<int> stack;
stack.push_back(nums[0]);
for (int i = 1; i < nums.size(); i++){
if (nums[i] > stack.back()){
stack.push_back(nums[i]);
}
else{
int pos = binary_search(stack, nums[i]);
stack[pos] = nums[i];
}
}
return stack.size();
}
};
64. Minimum Path Sum
题意:
求最小的路径和,每次只能向右或者下,求最小的路径和。
解题思路:
与三角形题类似。
代码:
class Solution {
public:
int minPathSum(vector<vector<int>>& grid) {
if (grid.size() == 0){
return 0;
}
int row = grid.size();
int column = grid[0].size();
vector<vector<int>> dp(row, vector<int>(column, 0));
dp[0][0] = grid[0][0];
for (int i = 1; i < grid[0].size(); i++){
dp[0][i] = dp[0][i-1] + grid[0][i];
}
for (int i = 1; i < grid.size(); i++){
dp[i][0] = dp[i-1][0] + grid[i][0];
for (int j = 1; j < grid[i].size(); j++){
dp[i][j] = min(dp[i][j-1], dp[i-1][j]) + grid[i][j];
}
}
return dp[row-1][column-1];
}
};
174. Dungeon Game
题意:
骑士从左上走到右下去救公主,只能向右或者下走,走到格子中会扣除或者加上格子上数值的血量,求骑士至少需要的血量。
解题思路:
需要从右下往左上递推。dp[i][j]
维护的是ij位置所需要的最低血量。
转移方程:下面和右边的较小值,减去本格的数值,与1的较大值
边界条件:最下边和最右边。
代码:
class Solution {
public:
int calculateMinimumHP(vector<vector<int>>& dungeon) {
if (dungeon.size() == 0){
return 0;
}
vector<vector<int>> dp(dungeon.size(), vector<int>(dungeon[0].size(), 0));
int row = dp.size();
int column = dp[0].size();
dp[row-1][column-1] = max(1, 1 - dungeon[row-1][column-1]);
for (int i = column - 2; i >= 0; i --){
dp[row-1][i] = max(1, dp[row-1][i+1] - dungeon[row-1][i]);
}
for (int j = row - 2; j >= 0; j--){
dp[j][column-1] = max(1, dp[j+1][column-1] - dungeon[j][column-1]);
}
for (int i = row - 2; i >= 0; i--){
for (int j = column - 2; j >= 0; j--){
dp[i][j] = max(1, min(dp[i][j+1], dp[i+1][j]) -dungeon[i][j]);
}
}
return dp[0][0];
}
};