买卖股票的最佳时机 II

买卖股票的最佳时机 II

给你一个整数数组 prices ，其中 prices[i] 表示某支股票第 i 天的价格。
在每一天，你可以决定是否购买和/或出售股票。你在任何时候 最多 只能持有 一股 股票。你也可以先购买，然后在 同一天 出售。
返回 你能获得的 最大 利润 。
示例 1：
输入：prices = [7,1,5,3,6,4]
输出：7
解释：在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6 - 3 = 3。
最大总利润为 4 + 3 = 7 。
示例 2：
输入：prices = [1,2,3,4,5]
输出：4
解释：在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5 - 1 = 4。
最大总利润为 4 。
示例 3：
输入：prices = [7,6,4,3,1]
输出：0
解释：在这种情况下, 交易无法获得正利润，所以不参与交易可以获得最大利润，最大利润为 0。
提示：
1 <= prices.length <= 3 * 104
0 <= prices[i] <= 104

第一种：贪心算法

    /// <summary>

    /// </summary>
    /// <param name="prices"></param>
    /// <returns></returns>
    public int MaxProfit(int[] prices)
{
        int n = prices.Length;
        if (n == 0) return 0; // 边界条件
        int sumProfit = 0;//设置一个变量用于承接中间值
        for (int i = 1; i < n; i++)
        {
            //如果当前值小于下一个，说明可以盈利
            if (prices[i-1] < prices[i])
            {
                sumProfit += prices[i] - prices[i-1];
            }
        }
        return sumProfit;
}

思路分析：
只要第二天比前天高就卖,不是动态规划，思路来源于上一题。但是计算过程不是实际的买卖过程，只是其中的一个规律。
问：倘若题目要求要返回下标
答如果需要返回下标的情况下，就记录出下标，如下
【1，2】 【2，3】【4，5】【5，6】 【8, 9】
根据下标中相同元素进行合并，最终得到的结果为
【1，3】 【4，6】【8，9】

时间复杂度
O(n): 该方法需要遍历 prices 数组一次。for 循环的迭代次数为 n - 1（其中 n 是 prices 数组的长度），因此时间复杂度为 O(n)。
空间复杂度
O(1): 该方法只使用了常量级别的额外空间来存储变量 sumProfit 和 n。无论输入数组的大小如何，所需的额外空间都是固定的，因此空间复杂度为 O(1)。
总结
时间复杂度: O(n)，其中 n 是 prices 数组的长度。
空间复杂度: O(1)，因为只使用了常量级别的额外空间。

易错写法：没有考虑到一天只能拥有一支股票

            public int MaxProfit1(int[] prices)
            {
                //这种方式是错误的，因为相当于持有两只股票了
                int n = prices.Length;
                if (n == 0) return 0; // 边界条件
                int curPrice = prices[0];
                int sumProfit = 0;//设置一个变量用于承接中间值
                for (int i = 0; i < n; i++)
                {
                    curPrice = prices[i];
                    for (int j = i; j < n; j++)
                    {
                        if (prices[j]>curPrice)
                        {
                            sumProfit += (prices[j] - curPrice);
                            //i = j;
                            break;
                        }
                    }
                }
                return sumProfit;
            }

第二种：动态规划（来源自官方解答）

    public int MaxProfit(int[] prices) {
                int n = prices.Length;
                int[,]dp = new int[n,2];
                dp[0,0] = 0;
                dp[0,1] = -prices[0];//买入所以为负数
                for (int i = 1; i < n; i++)
                {
                    dp[i,0] = Math.Max(dp[i - 1, 0], dp[i - 1, 1] + prices[i]);
                    dp[i, 1] = Math.Max(dp[i - 1, 1], dp[i - 1,0] - prices[i]);
                }
                return dp[n - 1, 0];
    }

思路分析

链接：来源
来源：力扣（LeetCode）

复杂度分析
时间复杂度：O(n)，其中 n 为数组的长度。一共有 2n 个状态，每次状态转移的时间复杂度为 O(1)，因此时间复杂度为 O(2n)=O(n)。
空间复杂度：O(n)。我们需要开辟 O(n) 空间存储动态规划中的所有状态。如果使用空间优化，空间复杂度可以优化至 O(1)

作者：力扣官方题解
链接：https://leetcode.cn/problems/best-time-to-buy-and-sell-stock-ii/solutions/476791/mai-mai-gu-piao-de-zui-jia-shi-ji-ii-by-leetcode-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

总结：
动态规划原理：
1. 最优子结构
解决动态规划问题的关键在于找到最优子结构。最优子结构是指一个问题的整体最优解可以通过利用其子问题的最优解来获得。也就是将问题进行分解，分解成多个相同的子问题
在动态规划中，我们通常将原问题分解为若干个子问题，并从底层的子问题开始逐步解决，将子问题的解保存起来，供后续使用。这种自底向上的解决方式可以避免重复计算，从而大幅提高算法效率。
为了利用最优子结构，我们需要满足两个基本条件：

1. 问题可以被分解为子问题：原问题可以被划分为若干个相似的、但规模较小的子问题。**这些子问题在形式上和原问题是相同的，**只是规模更小。
2. 子问题的最优解能构成原问题的最优解：原问题的最优解可以通过利用子问题的最优解来获得。这就是最优子结构的核心概念。
   通过满足最优子结构的条件，我们可以使用递归或迭代的方式来求解问题。在递归求解时，我们先解决子问题，然后将子问题的解组合成原问题的解。在迭代求解时，我们从子问题的最小规模开始解决，逐步扩展到原问题的规模，并保存子问题的解，以供后续使用。
   举个例子：
   考虑一个经典的动态规划问题：斐波那契数列。斐波那契数列的定义如下：

F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2), 当 n<=2

在这个问题中，我们可以看到每个斐波那契数都可以由它前面的两个数推导得出。这就是最优子结构的体现。

2. 重叠子问题

动态规划的另一个关键特性是重叠子问题，重叠子问题是指在递归求解过程中，同一个子问题被多次重复计算。这些子问题的解是相同的，但由于没有进行记忆化处理，导致在每次遇到相同子问题时都需要重新计算一次，造成了不必要的重复工作。

重叠子问题是动态规划效率低下的一个主要原因。如果我们能够避免重复计算相同的子问题，动态规划算法的执行效率将大大提高。

为了解决重叠子问题，通常采用两种主要的方法：

举例说明重叠子问题：

考虑计算斐波那契数列的例子：
F(0) = 0
F(1) = 1
F(n) = F(n-1) + F(n-2), 当 n<=2

出处
应用实例专门写一个笔记（本文参考了大佬的，仅仅作为个人学习笔记使用）