数据结构与算法——动态规划

例1:爬楼梯(easy)

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

例2:打家劫舍(easy)

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

例3:最大字段和(easy)

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 (dp[i] >= max_res) {
    max_res = dp[i];
   }
  }
  return max_res;
 }
};

例4:找零钱(medium)

class Solution {
public:
 int coinChange(std::vector<int>& coins, int amount) {
  std::vector<int> dp(amount + 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];
 }
};

例5:三角形(medium)

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

例6:最长上升子序列(medium,hard)

class Solution {
public:
 int lengthOfLIS(vector<int>& nums) {
  if (nums.size() == 0) {
   return 0;
  }
  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 {
    for (int j = 0; j < stack.size(); j++) {
     if (stack[j] >= nums[i]) {
      stack[j] = nums[i];
      break;
     }
    }
   }
  }
  return stack.size();
 }
};

class Solution {
public:
 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 < 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 (LIS < dp[i]) {
    LIS = dp[i];
   }
  }
  return LIS;
 }
};

例7:最小路径和(medium)

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

例8:地牢游戏(hard)

class Solution {
public:
 int calculateMinimumHP(vector<vector<int>>& dungeon) {
  if (dungeon.size() == 0) {
   return 0;
  }
  vector<vector<int>> dp(dungeon);
  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 i = row - 2; i >= 0; i--) {
   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];
 }
};