本来应是简单题-没看懂-想多了
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 (ie, buy one and sell one share of the stock multiple times). However, you may not engage in multiple transactions at the same time (ie, you must sell the stock before you buy again).
public class Solution {
public int maxProfit(int[] prices) {int x;
int profit=0;
for(x=0;x<prices.length-1;x++){
int p = prices[x+1]-prices[x];
if (p>0){
profit+=p;
}
}
return profit;
}
}
Say you have an array for which the ith element is the price of a given stock on day i.
If you were only permitted to complete at most one transaction (ie, buy one and sell one share of the stock), design an algorithm to find the maximum profit.
At first glance, you might think that finding the minimum and maximum value would do, but it does have a hidden restriction, that is: You must buy before you can sell.
The question is equivalent to the following:
There is an obvious O(N2) solution, but in fact we can do better in just O(N).
To solve this problem efficiently, you would need to track the minimum value’s index. As you traverse, update the minimum value’s index when a new minimum is met. Then, compare the difference of the current element with the minimum value. Save the buy and sell time when the difference exceeds our maximum difference (also update the maximum difference).
思路:保留当前最小值,然后随着时间推移选得差最大的即最大收益。
public class Solution {
public int maxProfit(int[] prices) {
int x;
if (prices.length<=0)
return 0;
int min=prices[0];
int profit=0;
for(x=1;x<prices.length;x++){
min = Math.min(min,prices[x]);
profit=Math.max(prices[x]-min, profit);
}
return profit;
}
}