【leetcode】dp---中等（1）*****309. 最佳买卖股票时机含冷冻期_dp股票_买入卖出（2）322. 零钱兑换_dp步长因子_类丑数（3）338. 比特位计数_dp步长

309、给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​

设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:

1.    你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
2.    卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。

示例:

输入: [1,2,3,0,2]
输出: 3 
解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]

将「买入」和「卖出」分开进行考虑：「买入」为负收益，而「卖出」为正收益。

1. 初入股市时，只有「买入」的权利，只能获得负收益。买入-prices[i]
2. 「买入」之后，你就有了「卖出」的权利，可以获得正收益。卖出+prices[i]

维护在股市中每一天结束后可以获得的「累计最大收益」，并以此进行状态转移。

股票题集合 

dp[i][j]：i--天数，j--三种状态（0持有股票，1无股票当日卖出，2无股票冷冻期，3空窗期
状态转移：1）i天持有股票：a] i-1冷冻期，i买入；b] i-1空窗期，i买入; c] i-1也持有股票
                  2）i天无股票当日卖出：i天卖出
                  3）i天处于冷冻期：i-1卖出股票
                  4）i天空窗：a] i-1处于冷冻期，且i天不做操作；b] i-1空窗
// dp[i][0] = max(dp[i-1][2] - prices[i], dp[i-1][3] - prices[i], dp[i-1][0])
// dp[i][1] = dp[i-1][0] + prices[i]
// dp[i][2] = dp[i-1][1]
// dp[i][3] = max(dp[i-1][2], dp[i-1][3])

// dp[i][j]：获i天在j状态下得的最大利润。（有无股票，是否处在冷冻期）
//           i:天数。j:三种状态---0持有股票，1无股票当日卖出，2无股票冷冻期，3空窗期
// 状态转移：1）i天持有股票：a]i-1冷冻期，i买入；b]i-1空窗期，i买入; c]i-1也持有股票
//          2）i天无股票当日卖出：i天卖出
//          3）i天处于冷冻期：i-1卖出股票
//          4）i天空窗：a]i-1处于冷冻期，且i天不做操作；b]i-1空窗
// dp[i][0] = max(dp[i-1][2] - prices[i], dp[i-1][3] - prices[i], dp[i-1][0])
// dp[i][1] = dp[i-1][0] + prices[i]
// dp[i][2] = dp[i-1][1]
// dp[i][3] = max(dp[i-1][2], dp[i-1][3])
class Solution {
public:
    int maxProfit(vector<int>& prices) {
        if(prices.size() == 0) return 0;
        int n = prices.size();
        vector<vector<int>> dp(n, vector<int>(4, 0));
        dp[0][0] -= prices[0];
        for(int i = 1; i < n; i++){
            dp[i][0] = max(max(dp[i-1][2], dp[i-1][3]) - prices[i], dp[i-1][0]);
            dp[i][1] = dp[i-1][0] + prices[i];
            dp[i][2] = dp[i-1][1];
            dp[i][3] = max(dp[i-1][2], dp[i-1][3]);
        }
        int ans = max(max(dp[n-1][0], dp[n-1][1]), max(dp[n-1][2], dp[n-1][3]));
        if(ans <= 0) return 0;
        else return ans;
    }
};

结果：

执行用时：12 ms, 在所有 C++ 提交中击败了20.87% 的用户

内存消耗：11.9 MB, 在所有 C++ 提交中击败了30.42% 的用户

 

322、给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

示例 1:

输入: coins = [1, 2, 5], amount = 11
输出: 3 
解释: 11 = 5 + 5 + 1

 状态转移：步长状态转移，步长为coins的大小。    类似丑数II

dp[i] = min(dp[i-coins[j]] + 1)

// dp[i] : 第i个数字，组成所需的最少硬币数
// 状态转移：步长状态转移，步长为coins的大小
// dp[i] = min(dp[i-coins[j]] + 1)
class Solution {
public:
    int coinChange(vector<int>& coins, int amount) {
        if(amount == 0) return 0;
        int m = coins.size();
        if(m == 0) return -1;
        vector<int> dp(amount + 1, 0);
        for(int j = 0; j < m; j++) if(coins[j] <= amount) dp[coins[j]] = 1;
        for(int i = 1; i <= amount; i++){
            for(int j = 0; j < m; j++){
               if(i-coins[j] >= 1 && dp[i-coins[j]]) {
                   if(dp[i] == 0) dp[i] = dp[i-coins[j]] + 1;
                   else dp[i] = min(dp[i], dp[i-coins[j]] + 1);
                }
            }
        }
        if(dp[amount] == 0) return -1;
        else return dp[amount];
    }
};

结果：

执行用时：144 ms, 在所有 C++ 提交中击败了44.09% 的用户

内存消耗：14.1 MB, 在所有 C++ 提交中击败了25.02% 的用户

 

338、给定一个非负整数 num。对于 0 ≤ i ≤ num 范围中的每个数字 i ，计算其二进制数中的 1 的数目并将它们作为数组返回。

示例 1:

输入: 2
输出: [0,1,1]

 状态转移：步长2^j

dp[i] = dp[i-2^j] + 1;

// dp[i]:第i个数字，所需最少的以2的幂为因子的因子个数
// 步长为2^j
// dp[i] = dp[i-2^j] + 1;
class Solution {
public:
    vector<int> countBits(int num) {
        if(num == 0) return {0};
        vector<int> dp(num + 1, 0);
        vector<int> step(30, 1);
        for(int i = 1; i < 30; i++) step[i] = step[i-1] * 2;
        int j = 0;
        for(int i = 1; i <= num; i++){
            if(step[j] == i) dp[i] = 1, j++;
            else dp[i] = dp[i-step[j-1]] + 1;
        }
        return dp;
    }
};

结果：

执行用时：16 ms, 在所有 C++ 提交中击败了9.68% 的用户

内存消耗：8 MB, 在所有 C++ 提交中击败了48.94% 的用户