方法1 :暴力搜索,但是会超时
class Solution {
private int ans;
public int maxProfit(int[] prices) {
if(prices.length < 2) return 0;
this.ans = 0;
dfs(prices,0,0,0,prices.length);//价格,位置,状态,利润
return this.ans;
}//判断的结尾在哪?位置截止即是
public void dfs(int []prices,int pos,int status,int profit,int len){
if(len == pos){
this.ans = Math.max(this.ans,profit);
return;
} //暴力搜索处是选择一种在整个队列里面收益最多的情况,所以必须是在全部结果都找到的情况下,才可以结算,单算一种根本达不到要求
dfs(prices,pos+1,status,profit,len);//不操作
if(status == 0)
dfs(prices,pos+1,1,profit-prices[pos],len);//
else
dfs(prices,pos+1,0,profit+prices[pos],len);//
}
}
方法2:贪心算法,贪心是每个局部最优,但是没有一个状态转移的前后影响的特性。
class Solution {
public int maxProfit(int[] prices) {
int ans = 0;
for(int i = 1; i < prices.length; i++){
int tmp = prices[i] - prices[i-1];
if(tmp > 0) ans += tmp;
}
return ans;
}
}
方法3:动态规划,需要一个状态方程,状态转移,与前后最终的状态。
class Solution {
public int maxProfit(int[] prices) {
int len = prices.length;
if(len < 2) return 0;
int [][]dp = new int[len][2];
dp[0][0] = 0;
dp[0][1] = -prices[0];
for(int i = 1; i < len; 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[len-1][0];
}
}