class Solution {
public int rob(int[] nums) {
if(nums.length == 0) return 0 ;
if(nums.length == 1) return nums[0] ;
return Math.max(rob1(nums, 0 , nums.length -2), rob1(nums, 1 , nums.length-1 ));
}
public int rob1(int[] nums,int start , int end){
int[] dp = new int[nums.length];
dp[start] = nums[start];
dp[start + 1] = Math.max(nums[start],nums[start +1]);
for(int i = start + 2 ; i <= end ; i++){
dp[i] = Math.max(dp[i-2] + nums[i] , dp[i-1]);
}
return dp[end];
}
}
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* TreeNode left;
* TreeNode right;
* TreeNode() {}
* TreeNode(int val) { this.val = val; }
* TreeNode(int val, TreeNode left, TreeNode right) {
* this.val = val;
* this.left = left;
* this.right = right;
* }
* }
*/
class Solution {
public int rob(TreeNode root) {
int[] res = rob2(root);
return Math.max(res[0], res[1]);
}
public int[] rob2(TreeNode root){
int[] res = new int[2];
if(root == null){
return res;
}
int[] left = rob2(root.left);
int[] right = rob2(root.right);
//递归
res[0]= Math.max(left[0], left[1]) + Math.max(right[0], right[1]);
res[1]= root.val + left[0] + right[0];
return res;
}
}
class Solution {
public int maxProfit(int[] prices) {
int low = Integer.MAX_VALUE;
int res = 0;
for(int i = 1 ; i < prices.length ;i++){
low = Math.min(prices[i], low);
res = Math.max(res, prices[i] - low);
}
return res;
}
}
class Solution {
public int maxProfit(int[] prices) {
int[][] dp = new int[prices.length][2];
dp[0][0] = 0;//不持有
dp[0][1] = -prices[0];//持有
for(int i = 1 ; i < prices.length ;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[prices.length -1][0];
}
}