力扣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;
    }
  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值