力扣LeetCode算法打卡学习第1天

第1题

给定一个排序数组，你需要在 原地 删除重复出现的元素，使得每个元素只出现一次，返回移除后数组的新长度。

不要使用额外的数组空间，你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。(就是把不重复的内容全都排到数组的前面，返回的新长度n就是让调用此函数的人直接取数组的前n个元素）

解题：用双指针法

因为会改动数组的内容，因此传回删除之后的数组长度时，取此长度的数组内容即可。

public int removeDuplicates(int[] nums) {
    if (nums.length == 0) return 0;
    int i = 0;
    for (int j = 1; j < nums.length; j++) {
        if (nums[j] != nums[i]) {
            i++;
            nums[i] = nums[j];
        }
    }
    return i + 1;
}

下面这串代码是实现这个功能时如何调用的。

// nums 是以“引用”方式传递的。也就是说，不对实参做任何拷贝
int len = removeDuplicates(nums);

// 在函数里修改输入数组对于调用者是可见的。
// 根据你的函数返回的长度, 它会打印出数组中该长度范围内的所有元素。
for (int i = 0; i < len; i++) {
    print(nums[i]);
}

第2题. 买卖股票的最佳时机 II

给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。

设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。

注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
如：

方法一：我写的

class Solution {
    public int maxProfit(int[] prices) {
        int ifbuy=0; //标记购买状态，0为未购买，1为已购买
        int buy=0; //在数组的何处买进
        int sell=0; //在数组的何处卖出
        int benifit=0; //利润总和
        for(int i=1;i<prices.length;i++){
            //如果价格下跌
            if(prices[i]<prices[i-1]){
                // 如果已买进，价格要下跌了，那就得卖出了
                if(ifbuy!=0){
                    ifbuy=0;
                    sell = i-1;
                    benifit = benifit+prices[sell]-prices[buy];
                }
                // 如果还未买进，那么就不买。
                else{
                     buy++;
                     //不买
                } 
            }
            //如果价格上涨或持平
            else{
                // 如果已经是数组的最后一个元素，且已经买了，那应该卖出
                if(i == prices.length-1 && ifbuy==1){
                    benifit = benifit +prices[i]-prices[buy];
                }
                // 如果价格要涨了，但还没买，那应该买进了
                else if(ifbuy==0){
                    buy = i-1;
                    ifbuy=1;
                    // 如果是最后两个元素在相比，那么应该买入，且再卖出
                    if(i == prices.length-1 && ifbuy==1){
                        benifit = benifit +prices[i]-prices[buy];
                }
                }
                else{
                    //价格还在涨，不卖
                }
            }
        }
        return benifit;
    }
}

方法二、标准答案1——动态规划

class Solution {
    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-Solution
链接：https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/solution/mai-mai-gu-piao-de-zui-jia-shi-ji-ii-by-leetcode-s/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

class Solution {
public:
    int maxProfit(vector<int>& prices) {
        int n = prices.size();
        int dp0 = 0, dp1 = -prices[0];
        for (int i = 1; i < n; ++i) {
            int newDp0 = max(dp0, dp1 + prices[i]);
            int newDp1 = max(dp1, dp0 - prices[i]);
            dp0 = newDp0;
            dp1 = newDp1;
        }
        return dp0;
    }
};

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

方法三、标准答案2——贪心算法
即，第一天我买进，第二天涨了，我第二天就卖，如果第三天还涨，那我第二天卖了再买，第三天再卖。（因为题目没有要求一天之内只能一次买卖）
相当于，涨了就买，然后卖，跌了就不买。

class Solution {
    public int maxProfit(int[] prices) {
        int ans = 0;
        int n = prices.length;
        for (int i = 1; i < n; ++i) {
            ans += Math.max(0, prices[i] - prices[i - 1]);
        }
        return ans;
    }
}

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

同样贪心，这个算法更容易理解

public int maxProfit(int[] arr) {
        if (arr == null || arr.length <= 1) return 0;

        int ans = 0;
        for (int i = 1; i < arr.length; i++) {
            if (arr[i] > arr[i-1]) {  // 卖出有利可图
                ans += (arr[i] - arr[i-1]);
            }
        }

        return ans;
    }