贪心

分发饼干 题目 解析

结果由饼干数决定，所以遍历饼干，每次与孩子的胃口匹配。

class Solution {
    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int count = 0, j = 0;
        for (int i = 0; i < s.length; i++) {
            if (j < g.length && s[i] >= g[j]) {
                j++;
                count++;
            }
        }
        return count;
    }
}

 

最大子序列和 题目 解析

贪心

class Solution {
    public int maxSubArray(int[] nums) {
        int res = Integer.MIN_VALUE;
        int count = 0;
        for (int i = 0; i < nums.length; i++) {
            count += nums[i];
            if (count > res) {
                res = count;
            }
            if (count < 0) count = 0;
        }
        return res;
    }
}

动态规划

class Solution {
    public int maxSubArray(int[] nums) {
        int n = nums.length;
        if (n < 2) return nums[0];
        int[][] dp = new int[n][2];
        dp[0][0] = nums[0]; //有我
        dp[0][1] = Integer.MIN_VALUE / 2;  //没我
        for (int i = 1; i < nums.length; i++) {
            dp[i][0] = Math.max(dp[i-1][0] + nums[i], nums[i]);
            dp[i][1] = Math.max(dp[i-1][1], dp[i-1][0]); 
        }
        return Math.max(dp[n-1][0], dp[n-1][1]);
    }
}

 

摆动序列 题目 解析

画出折线图，求波峰的波谷的数量和就好。

class Solution {
    public int wiggleMaxLength(int[] nums) {
        if (nums.length == 0) return 0;  
        int res = 1, prediff = 0;
        for (int i = 1; i < nums.length; i++) {
            int curdiff = nums[i] - nums[i-1];
            if (curdiff < 0 && prediff >= 0 || curdiff > 0 && prediff <= 0) {
                res++;
                prediff = curdiff;
            }
        }
        return res;
    }
}

 

买股票的最佳时机 题目 解析

看折线图，只要今天能赚就买

class Solution {
    public int maxProfit(int[] prices) {
        int res = 0;
        for (int i = 1; i < prices.length; i++) {
            res += Math.max(0, prices[i] - prices[i-1]);
        } 
        return res;
    }
}

 

跳跃游戏 题目 解析

在当下能够跳跃的范围内找出下次跳跃可以到达的最大范围

class Solution {
    public boolean canJump(int[] nums) {
        int cover = 0;
        for (int i = 0; i <= cover; i++) {
            cover = cover > i + nums[i] ? cover : i + nums[i];
            if (cover >= nums.length-1) return true;
        }
        return false;
    }
}

 

跳跃游戏Ⅱ 题目 解析

和上面一样，在当前可跳跃范围找到下次可以到达的最大距离。

class Solution {
    public int jump(int[] nums) {
        if (nums.length <= 1) return 0;
        int count = 1;
        int step = nums[0], nextstep = 0;
        for (int i = 1; i < nums.length; i++) {
            if (step >= nums.length - 1) return count;
            nextstep = Math.max(i + nums[i], nextstep);
            if (step == i) {
                step = nextstep;
                count++;
            }
        }
        return count;
    }
}