LeetCode122——Best Time to Buy and Sell Stock II

题目：

Say you have an array for which the ith element is the price of a given stock on day i.

Design an algorithm to find the maximum profit. You may complete as many transactions as you like (i.e., buy one and sell one share of the stock multiple times).

Note: You may not engage in multiple transactions at the same time (i.e., you must sell the stock before you buy again).

class Solution:

    def maxProfit(self, prices):

        trans_flag = 0  # 0 表示未购买或者已卖出，1 表示已购买未卖出

        profit = 0

        end_day = len(prices)

        if end_day < 2:

        	print("总收益：{}".format(profit))

        	return 0

        for i in range(end_day - 1):

            if prices[i] < prices[i + 1] and trans_flag == 0:

                print("买入第{}天的股票".format(i + 1))

                trans_flag = 1

                current_i = i

                profit -= prices[i]

                continue

            if prices[i] < prices[i + 1] and trans_flag == 1:

                print("继续持有股票")

                continue

            if prices[i] > prices[i + 1] and trans_flag == 1:

                print("卖出第{}天的股票".format(i + 1))

                profit += prices[i]

                current_i = 0

                trans_flag = 0

                continue

            if prices[i] > prices[i + 1] and trans_flag == 0:

                print("暂不购买")

                continue

            print("当前收益：{}".format(profit))

        # 第一个问题：这里加一步验证一直持有到最后一天未卖出，所以收益没计算完全的问题，同时要小心很小的数据集，比如只有一个

        # 第二个问题：与上一天比较时不一定要大于，可能两者相等

        if prices[end_day - 1] >= prices[end_day - 2] and trans_flag == 1:

            trans_flag = 1

            profit += prices[end_day - 1]

        print("总收益：{}".format(profit))

if __name__ == '__main__':

    prices1 = [7, 1, 5, 3, 6, 4]

    prices2 = [1, 2, 3, 4, 5]

    prices3 = [7, 6, 4, 3, 1]

    prices4 = [2,3]

    prices5 = [1,9,6,9,1,7,1,1,5,9,9,9]

    Mine = Solution()

    Mine.maxProfit(prices5)

zip() 函数用于将可迭代的对象作为参数，将对象中对应的元素打包成一个个元组，然后返回由这些元组组成的对象，这样做的好处是节约了不少的内存。

我们可以使用 list() 转换来输出列表。如果各个迭代器的元素个数不一致，则返回列表长度与最短的对象相同，利用 * 号操作符，可以将元组解压为列表。

>>>a = [1,2,3]

>>> b = [4,5,6]

>>> c = [4,5,6,7,8]

>>> zipped = zip(a,b)     # 返回一个对象

>>> zipped

<zip object at 0x103abc288>

>>> list(zipped)  # list() 转换为列表

[(1, 4), (2, 5), (3, 6)]

>>> list(zip(a,c))              # 元素个数与最短的列表一致

[(1, 4), (2, 5), (3, 6)]

>>> a1, a2 = zip(*zip(a,b))          # 与 zip 相反，zip(*) 可理解为解压，返回二维矩阵式

>>> list(a1)

[1, 2, 3]

>>> list(a2)

[4, 5, 6]

>>>

在这里就是将range函数变为迭代器，每次从prices的当前位置和下一个位置取出x和y，然后依然判断求和