算法Ⅰ（动态规划）

爬楼梯

最简单的题了~~~

class Solution {
 public:
  int climbStairs(int n) {
    if (n <= 2) return n;
    int dp[n + 1];
    dp[1] = 1;
    dp[2] = 2;
    for (int i = 3; i <= n; i++) {
      dp[i] = dp[i - 1] + dp[i - 2];
    }
    return dp[n];
  }
};

买卖股票的最佳时机

给定一个数组 prices ，它的第 i 个元素 prices[i] 表示一支给定股票第 i 天的价格。

你只能选择 某一天 买入这只股票，并选择在 未来的某一个不同的日子 卖出该股票。设计一个算法来计算你所能获取的最大利润。

返回你可以从这笔交易中获取的最大利润。如果你不能获取任何利润，返回 0 。

class Solution {
 public:
  //双指针
  int maxProfit(vector<int>& prices) {
    int len = prices.size();
    if (len < 1) return 0;
    if (len == 2) return prices[0] > prices[1] ? 0 : prices[1] - prices[0];
    int maxPro = 0, minV = prices[0];
    for (int i = 1; i < len; i++) {
      minV = min(minV, prices[i]);
      maxPro = max(prices[i] - minV, maxPro);
    }
    return maxPro;
  }
};

//dp
  int maxProfit(vector<int>& prices) {
    int len = prices.size();
    if (len == 0) return 0;

    //定义二维数组dp[length][2]
    // dp[i][0]表示第i+1天（i是从0开始的）结束的时候没持有股票的最大利润，
    // dp[i][1]表示第i+1天结束的时候持有股票的最大利润
    int dp[len][2];
    //边界条件：
    //第一天不持有股票
    dp[0][0] = 0;
    //第一天持有股票
    dp[0][1] = -prices[0];

    for (int i = 1; i < len; i++) {
      //第i+1天我们即没买也没卖，那么最大利润就是第i天 没持有
      //股票的最大利润dp[i-1][0]
      //或者第i+1天我们卖了一支股票，那么最大利润就是第i天持有股票的最大利润（这个是负的，并且也不一定是第i天开始持有的，有可能在第i天之前就已经持有了）加上第i+1天卖出股票的最大利润，dp[i-1][1]+prices[i]。
      dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]);

      //同理我们可以得出第i+1天结束的时候我们 持有 股票的最大利润
      dp[i][1] = max(dp[i - 1][1], -prices[i]);
    }
    //手里没有股票利润最大
    return dp[len - 1][0];
  }

最大子序和

给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

子数组 是数组中的一个连续部分。

//dp[i]表示以num[i]为结尾的最大子序列和
class Solution {
 public:
  int maxSubArray(vector<int>& nums) {
    int len = nums.size();
    if (len == 1) return nums[0];
    int dp[len];
    dp[0] = nums[0];
    for (int i = 1; i < len; i++) {
      dp[i] = max(dp[i - 1] + nums[i], nums[i]);
    }
    int ans = INT_MIN;
    for (int i = 0; i < len; i++) {
      ans = max(ans, dp[i]);
    }
    return ans;
  }
};

打家劫舍

你是一个专业的小偷，计划偷窃沿街的房屋。每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。

给定一个代表每个房屋存放金额的非负整数数组，计算你 不触动警报装置的情况下 ，一夜之内能够偷窃到的最高金额。

class Solution {
 public:
  int rob(vector<int>& nums) {
    int len = nums.size();
    if (len == 1) return nums[0];

    // dp用于保存以nums第i个元素为结尾的最高偷盗金额
    int dp[len];
    //递归边界，由于不能连续两天偷
    dp[0] = nums[0];
    dp[1] = nums[1];
    for (int i = 2; i < len; i++) {
      //先计算步长为1的dp[i]
      dp[i] = max(dp[i - 1], dp[i - 2] + nums[i]);
      //然后计算所有步长的dp[i]
      for (int j = 0; j < i - 1; j++) {
        dp[i] = max(dp[i], dp[j] + nums[i]);
      }
    }
    int maxV = 0;
    for (int i = 0; i < len; i++) {
      maxV = max(maxV, dp[i]);
    }
    return maxV;
  }
};