leetcode--动态规划

xiayto

已于 2023-07-06 13:21:50 修改

阅读量337

点赞数

分类专栏： leetcode 文章标签： leetcode 动态规划算法

于 2018-01-21 02:58:44 首次发布

本文链接：https://blog.csdn.net/xiayto/article/details/78944400

版权

leetcode 专栏收录该内容

13 篇文章 0 订阅

订阅专栏

基础知识：

动态规划：
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];
    }
};

xiayto

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
leetcode--动态规划

基础知识：动态规划： 1、确认原问题和子问题 2、确认状态 3、确认边界条件 4、确认转移方程leetcode题目70. Climbing Stairs题意：每次可以上1阶和2阶，上n阶楼梯，有多少中可能的情况。解题思路：最暴力的做法是递归，时间复杂度O(2^n)会超时：class Solution {public: int c
复制链接

扫一扫

专栏目录