贪心算法的理解及例子

贪心算法（贪婪算法）是指，在对问题求解时，总是做出在当前看来最好的选择，也就是说，不从整体最优上加以考虑，它所作出的是某种意义上的局部最优解。

1、过程：

（1）建立数学模型来描述问题

（2）把求解的问题分成若干个子问题

（3）对每一个子问题求解，得到子问题的局部最优解

（4）把子问题的局部最优解合成原来解问题的一个解

简单来说，即假设一个问题比较复杂，暂时找不到全局最优解，那么我们可以考虑把原问题拆成几个小问题（分而治之思想），分别求每个小问题的最优解，再把这些局部最优解叠起来，就当作整个问题的最优解。

2、以下例子加以理解：

（1）

class Solution {
    public int balancedStringSplit(String s) {
        int count = 0;
        int balance = 0;
        for(int i = 0;i < s.length();i++){
            if(s.charAt(i) == 'R'){
                balance++;
            }else{
                balance--;
            }
            if(balance == 0) count++;
        }
        return count;
    }
}

（2）

 

class Solution {
    public int maxProfit(int[] prices) {
        int profit = 0;
        for(int i = 1;i < prices.length;i++){
            if(prices[i] > prices[i-1]){
                profit += prices[i] - prices[i-1];
            }
        }
        return profit;
    }
}

（3）

 

class Solution {
    public boolean canJump(int[] nums) {
        int maxJump = 0;
        for(int i = 0;i < nums.length;i++){
            if(maxJump >= i){
                maxJump = Math.max(maxJump,i + nums[i]);
                if(maxJump > nums.length) return true;
            }else{
                return false;
            }
        }
        return true;  
    }
}

（4）

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        if(intervals.length == 0) return 0;
        Arrays.sort(intervals,new Comparator<int[]>(){
            public int compare(int[] interval1,int[] interval2){
                return interval1[1] - interval2[1];
            }
        });
        int n = intervals.length;
        int right = intervals[0][1];
        int ans = 1;
        for(int i = 1;i < n;i++){
            if(intervals[i][0] >= right){
                ans++;
                right = intervals[i][1];
            }
        }
        return n - ans;
    }
}