方法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]; } }