1.删除排序数组中的重复项
给你一个 升序排列 的数组 nums ,请你 原地 删除重复出现的元素,使每个元素 只出现一次 ,返回删除后数组的新长度。元素的 相对顺序 应该保持 一致 。
由于在某些语言中不能改变数组的长度,所以必须将结果放在数组nums的第一部分。更规范地说,如果在删除重复项之后有 k 个元素,那么 nums 的前 k 个元素应该保存最终结果。
将最终结果插入 nums 的前 k 个位置后返回 k 。
不要使用额外的空间,你必须在 原地 修改输入数组 并在使用 O(1) 额外空间的条件下完成。
判题标准:
系统会用下面的代码来测试你的题解:
int[] nums = [...]; // 输入数组
int[] expectedNums = [...]; // 长度正确的期望答案
int k = removeDuplicates(nums); // 调用
assert k == expectedNums.length;
for (int i = 0; i < k; i++) {
assert nums[i] == expectedNums[i];
}
如果所有断言都通过,那么您的题解将被 通过。
示例 1:
输入:nums = [1,1,2]
输出:2, nums = [1,2,_]
解释:函数应该返回新的长度 2 ,并且原数组 nums 的前两个元素被修改为 1, 2 。不需要考虑数组中超出新长度后面的元素。
示例 2:
输入:nums = [0,0,1,1,1,2,2,3,3,4]
输出:5, nums = [0,1,2,3,4]
解释:函数应该返回新的长度 5 , 并且原数组 nums 的前五个元素被修改为 0, 1, 2, 3, 4 。不需要考虑数组中超出新长度后面的元素。
提示:
1 <= nums.length <= 3 * 104
-104 <= nums[i] <= 104
nums 已按 升序 排列
算法1:(双指针解决)
使用两个指针,右指针始终往右移动,如果右指针指向的值等于左指针指向的值,左指针不动。如果右指针指向的值不等于左指针指向的值,那么左指针往右移一步,然后再把右指针指向的值赋给左指针。
class Solution {
public int removeDuplicates(int[] nums) {
//双指针解决
//边界条件判断
if ( nums == null || nums.length == 0)
return 0;
int left = 0;
for (int right = 1; right < nums.length; right++)
//如果左指针和右指针指向的值一样,说明有重复的,
//这个时候,左指针不动,右指针继续往右移。如果他俩
//指向的值不一样就把右指针指向的值往前挪
if ( nums[left] != nums[right])
nums[++left] = nums[right];
return ++left;
}
}
算法2:(单指针解决)
class Solution {
public int removeDuplicates(int[] nums) {
int count = 0;//重复的数字个数
for (int right = 1; right <nums.length; right++) {
if (nums[right] == nums[right - 1]) {
//如果有重复的,count要加1
count++;
} else {
//如果没有重复,后面的就往前挪
nums[right - count] = nums[right];
}
}
//数组的长度减去重复的个数
return nums.length - count;
}
}
算法3:(简单算法解决)
循环:i=0,j=1,如果 i 的值不等于 j 的值,那么 i 向后移动一位,并且将 j 的值赋值给 i,最后的个数为i+1
class Solution {
public int removeDuplicates(int[] nums) {
int i = 0;
for (int j = 1; j < nums.length; j++) {
if (nums[i] != nums[j]) {
i++;
nums[i] = nums[j];
}
}
return i + 1;
}
}
2.买卖股票的最佳时机 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
想法:
前面的数 比后面的数小
循环,只要后面数大于前面的,就用后面的数-前面的数
算法1:(动态规划解决)
定义dp[i][0]表示第i天交易完之后手里没有股票的最大利润,dp[i][1]表示第i天交易完之后手里持有股票的最大利润。当天交易完之后手里没有股票可能有两种情况,一种是当天没有进行任何交易,又因为当天手里没有股票,所以当天没有股票的利润只能取前一天手里没有股票的利润。一种是把当天手里的股票给卖了,既然能卖,说明手里是有股票的,所以这个时候当天没有股票的利润要取前一天手里有股票的利润加上当天股票能卖的价格。这两种情况我们取利润最大的即可,所以可以得到
dp[i][0]=max(dp[i-1][0],dp[i-1][1]+prices[i]);
当天交易完之后手里持有股票也有两种情况,一种是当天没有任何交易,又因为当天手里持有股票,所以当天手里持有的股票其实前一天就已经持有了。还一种是当天买入了股票,当天能买股票,说明前一天手里肯定是没有股票的,我们取这两者的最大值,所以可以得到
dp[i][1]=max(dp[i-1][1],dp[i-1][0]-prices[i]);
动态规划的递推公式有了,那么边界条件是什么,就是第一天
如果买入:
dp[0][1]=-prices[0];
如果没买:
dp[0][0]=0;
则:
class Solution {
public int maxProfit(int[] prices) {
int max = 0;
for (int i = 1; i < prices.length; i++) {
if (prices[i] > prices[i - 1]) {
max = max + (prices[i] - prices[i - 1]);
}
}
return max;
}
}
算法2:(代码优化)
上面计算的时候我们看到当天的利润只和前一天有关,没必要使用一个二维数组,只需要使用两个变量,一个记录当天交易完之后手里持有股票的最大利润,一个记录当天交易完之后手里没有股票的最大利润
class Solution {
public int maxProfit(int[] prices) {
if (prices == null || prices.length < 2)
return 0;
int length = prices.length;
//初始条件
int hold = -prices[0];//持有股票
int noHold = 0;//没持有股票
for (int i = 1; i < length; i++) {
//递推公式转化的
noHold = Math.max(noHold, hold + prices[i]);
hold = Math.max(hold, noHold - prices[i]);
}
//最后一天肯定是手里没有股票的时候利润才会最大,
//所以这里返回的是noHold
return noHold;
}
}
算法3:(贪心算法解决)
如果股票一直上涨,只需要找到股票上涨的最大值和股票开始上涨的最小值,计算他们的差就是这段时间内股票的最大利润。如果股票下跌就不用计算,最终只需要把所有股票上涨的时间段内的利润累加就是我们所要求的结果。
class Solution {
public int maxProfit(int[] prices) {
if (prices == null || prices.length < 2)
return 0;
int total = 0, index = 0, length = prices.length;
while (index < length) {
//如果股票下跌就一直找,直到找到股票开始上涨为止
while (index < length - 1 && prices[index] >= prices[index + 1])
index++;
//股票上涨开始的值,也就是这段时间上涨的最小值
int min = prices[index];
//一直找到股票上涨的最大值为止
while (index < length - 1 && prices[index] <= prices[index + 1])
index++;
//计算这段上涨时间的差值,然后累加
total += prices[index++] - min;
}
return total;
}
}
算法4:(贪心算法优化)
class Solution {
public int maxProfit(int[] prices) {
int total = 0;
for (int i = 0; i < prices.length - 1; i++) {
//原数组中如果后一个减去前一个是正数,说明是上涨的,
//我们就要累加,否则就不累加
total += Math.max(prices[i + 1] - prices[i], 0);
}
return total;
}
}
算法5:(简单算法解决)
class Solution {
public int maxProfit(int[] prices) {
if (prices.length == 0) {
return 0;
}
int max = 0;
for (int i = 0; i < prices.length - 1; i++) {
if (prices[i] < prices[i+1]) {
max = max + prices[i+1] - prices[i];
}
}
return max;
}
}