算法动态规划20240717

典例1、爬楼梯（easy）

#include <iostream>
#include <vector>

using namespace std;


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];
}

//int climbStair(int n) {
//    if (n == 1 || n == 2) {
//        return n;
//    }
//    return climbStair(n - 1) + climbStair(n - 2);
//}

int main()
{
    printf("%d", climbStairs(4));
    return 0;
}

典例2、打劫（medium）

#include <iostream>
#include <vector>

using namespace std;


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

int main()
{
    vector<int> nums;
    nums.push_back(5);
    nums.push_back(2);
    nums.push_back(6);
    nums.push_back(3);
    nums.push_back(1);
    nums.push_back(7);
    printf("%d\n", rob(nums));
    return 0;
}

典例3、最大字段和（easy）

#include <iostream>
#include <vector>

using namespace std;

int maxSubArray(vector<int>& nums) {
    int n = nums.size();
    vector<int> dp(n, 0);
    dp[0] = nums[0];
    int max_res = dp[0];
    for (int i = 1; i < n; i++) {
        dp[i] = max(dp[i - 1] + nums[i], nums[i]);
        if (max_res < dp[i]) {
            max_res = dp[i];
        }
    }
    return max_res;
}

int main()
{
    vector<int>nums;
    nums.push_back(-2);
    nums.push_back(1);
    nums.push_back(-3);
    nums.push_back(4);
    nums.push_back(-1);
    nums.push_back(2);
    nums.push_back(1);
    nums.push_back(-5);
    nums.push_back(4);
    printf("%d\n", maxSubArray(nums));
    return 0;
}

典例4、找零钱（medium）

#include <iostream>
#include <vector>

using namespace std;

int coinChange(std::vector<int>& coins,int amount) {
    vector<int> dp(50);
    for (int i = 0; i < amount; i++) {
        dp[i + 1] = -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] > dp[i - coins[j]] + 1) {
                    dp[i] = dp[i - coins[j]] + 1;
                }
            }
        }
    }
    return dp[amount];
}

int main()
{
    vector<int> coins;
    coins.push_back(1);
    coins.push_back(2);
    coins.push_back(5);
    coins.push_back(7);
    coins.push_back(10);
    for (int i = 1; i <= 14; i++) {
        printf("dp[%d]=%d\n", i, coinChange(coins, i));
    }
    return 0;
}

典例5、三角形（medium）

#include <iostream>
#include <vector>

using namespace std;

int minimumTotal(vector<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 <= i; 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];
}

int main()
{
    vector<vector<int>>triangle;
    int test[][10] = { {2},{3,4},{6,5,7},{4,1,8,3} };
    for (int i = 0; i < 4; i++) {
        triangle.push_back(vector<int>());
        for (int j = 0; j <= i; j++) {
            triangle[i].push_back(test[i][j]);
        }
    }
    printf("%d\n", minimumTotal(triangle));
    return 0;
}

典例6、最长上升子序列（medium）

#include <iostream>
#include <vector>

using namespace std;

int lengthOfLIS(vector<int>& nums) {
    if (nums.size() == 0) {
        return 0;
    }
    vector<int> dp(nums.size(), 0);
    dp[0] = 1;
    int LIS = 1;
    for (int i = 1; i < dp.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 (LIS < dp[i]) {
            LIS = dp[i];
        }
    }
    return LIS;
}

int main()
{
    int test[] = { 10,9,2,5,3,7,101,18 };
    vector<int>nums;
    int n = sizeof(test) / sizeof(test[0]);
    for (int i = 0; i < n; i++) {
        nums.push_back(test[i]);
    }
    printf("%d\n", lengthOfLIS(nums));
    return 0;
}

典例7、最小路径和（medium）

#include <iostream>
#include <vector>

using namespace std;

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 < column; i++) {
        dp[0][i] = dp[0][i - 1] + grid[0][i];
    }
    for (int i = 1; i < row; i++) {
        dp[i][0] = dp[i - 1][0] + grid[i][0];
        for (int j = 1; j < column; j++) {
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
        }
    }
    return dp[row-1][column-1];
}

int main()
{
    int test[][3] = { {1,3,1},{1,5,1},{4,2,1} };
    vector<vector<int>>grid;
    for (int i = 0; i < 3; i++) {
        grid.push_back(vector<int>());
        for (int j = 0; j < 3; j++) {
            grid[i].push_back(test[i][j]);
        }
    }
    printf("%d\n", minPathSum(grid));
    return 0;
}

典例8、地下城游戏（hard）

#include <iostream>
#include <vector>

using namespace std;

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 = dungeon.size();
    int column = dungeon[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 i = row-2; i >=0; i--) {
        dp[i][column-1] = max(1, dp[i + 1][column-1] - dungeon[i][column-1]);
        for (int j = column-2; j >=0; j--) {
            int dp_min = min(dp[i + 1][j], dp[i][j + 1]);
            dp[i][j] = max(1, dp_min - dungeon[i][j]);
        }
    }
    return dp[0][0];
}

int main()
{
    int test[][3] = { {-2,-3,3},{-5,-10,1},{10,30,-5} };
    vector<vector<int>>dungeon;
    for (int i = 0; i < 3; i++) {
        dungeon.push_back(vector<int>());
        for (int j = 0; j < 3; j++) {
            dungeon[i].push_back(test[i][j]);
        }
    }
    printf("%d\n", calculateMinimumHP(dungeon));
    return 0;
}

题目出处