Java-贪心算法-浅学习一下

前言

想要实现贪心算法，题目就必需要满足，可以从局部的最优达到全局的最优。

贪心算法没有什么固定的套路，他比其他的算法思想更想一种思想，因为我们有时候就会这样思考，然后把题目解出来，但是却不会去实实在在的推导证明，尤其是稍复杂的。按照本小白的理解，我们如果在按贪心的思路去解决问题的时候，提不出反例的话，就可以尝试贪心了。

通过下面的几道并不复杂的题，浅理解一下贪心，其中很多题可以使用动态规划，说明贪心能办到的事情，也挺多的。

通过题目理解

1.Leet_445分发饼干

假设你是一位很棒的家长，想要给你的孩子们一些小饼干。但是，每个孩子最多只能给一块饼干。

对每个孩子 i，都有一个胃口值 g[i]，这是能让孩子们满足胃口的饼干的最小尺寸；
并且每块饼干 j，都有一个尺寸 s[j] 。如果 s[j] >= g[i]，我们可以将这个饼干 j
分配给孩子 i ，这个孩子会得到满足。你的目标是尽可能满足越多数量的孩子，
并输出这个最大数值。

本题之中，我们就完全可以使用贪心的思路，我们应该尽可能的把每个小孩分配他们满足的最小的，这样的话可以做到最小的浪费，可以优先考虑饼干，也可以优先考虑小孩。考虑饼干的话，就把最小的饼干，给它能满足的最小的小孩需求。

    public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);//小孩排序
        Arrays.sort(s);//饼干排序

        int num=0;
        int start=0;
        //优先考虑饼干  小孩有满足的 才会到下一个小孩
        for(int i=0;start<g.length&&i<s.length ;i++){
            if(s[i]>g[start]){
                start++;
                num++;
            }


        }
        return num;

    }
//测试Leet_455
    @Test
    public void test1(){
        int[] g={1,2,2};
        int[] s={3};
        int x= new Leet_455().findContentChildren(g,s);
        System.out.println(x);
    }

2.Leet_53最大子序和

给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。

示例: 输入: [-2,1,-3,4,-1,2,1,-5,4] 输出: 6 解释: 连续子数组 [4,-1,2,1] 的和最大，为 6

这道题虽然只是一个简单题，但是可解的方法非常多，而且不同的方法之间差别非常大，而且我们可以使用贪心的思想来做。本小白的心理思路都写在代码注释了，然后写的比较繁琐，因为在解决这个问题的时候，考虑到了非常多的问题，但是都在这简短的代码中都得到了解决。本题最主要的思想，就是只考虑一个范围内的最大值，至于其中有什么数，都可以不关心。

//贪心解法
    //[-2,1,-3,4,-1,2,1,-5,4]
    public int maxSubArray(int[] nums) {
        if(nums.length==1){
            return nums[0];
        }
        int sum=Integer.MIN_VALUE;//取整型最小值
        int count=0;//相当于可以重置的锚点
        for(int i=0;i<nums.length;i++){
            count=count+nums[i];
            //取区间累计得最大值
            sum=Math.max(sum,count);
            if(count<=0){
                count=0;//重置最大子序起始位置 因为遇到负数一定是拉低总和
                //而且也意味着在当前区间 在一段增长之后 面临的都是下降
                //我们不必把下降的部分放入下一个区间 反正我们已经在这个区间取到了这个的
                //最大值。如果下面是仍然在下降的话 仍然归零 直到遇到一个上升的部分
                //有任何一个就继续是重复前面的逻辑 而且必然可以避免 比如4前面的
                //不管是任何的负数都不会和4有什么牵连 如果4前面的负数与4有牵连
                //就说明前面是正的那么加上4是在变大的。
                //这个贪心和暴力解法没有什么大的差别 但是把我绕了一下 最后把最大的
            }
        }
        return sum;//只需要返回最大值就行了

    }
    //暴力解法
    public int maxSubArray2(int[] nums) {
        int sum=Integer.MIN_VALUE;
        int count=0;

        for(int i=0;i<nums.length;i++){
            count=0;
            for(int j=i;j<nums.length;j++){
                count+=nums[j];
                sum=Math.max(sum,count);

            }
        }
        return sum;
    }

3.Leet_45 跳跃游戏

给定一个非负整数数组，你最初位于数组的第一个位置。

数组中的每个元素代表你在该位置可以跳跃的最大长度。

你的目标是使用最少的跳跃次数到达数组的最后一个位置。

示例:

    输入: [2,3,1,1,4]
    输出: 2
    解释: 跳到最后一个位置的最小跳跃数是 2。从下标为 0 跳到下标为 1 的位置，跳 1 步，然后跳 3 步到达数组的最后一个位置。

说明: 假设你总是可以到达数组的最后一个位置

贪心就是这样，我们不必搞清楚所有的数据，我们只要能够得到我们需要的结果，就可以了。感觉和递归很想，有一种大处着眼，小处着手的感觉，我们从全局去操作，因为搞清楚所有的数据，本来就很困难。这道题也一样，相当于我们处于一个位置，那么在这个位置的能够到达的最大距离之间的这个范围，我们可以寻找一个位置，能够使下一步所到达的位置最大，比较在本位置范围的都可以到达。于是一遍一遍的寻找最优，就找到了最大的解。虽然是简单题，但是还是给本小白有很大的教育，所以还要更加加油冲冲冲。

public int jump(int[] nums) {
        if(nums == null||nums.length==0||nums.length==1){
            return 0;
        }
        //记录结果次数
        int count = 0;
        //当前的覆盖的区域
        int cur=0;
        //最大覆盖区域
        int max=0;
        for(int i=0;i<nums.length;i++){
            //在可覆盖的区域内不断更新最大的
            max=Math.max(max,i+nums[i]);
            if(max>=nums.length-1){
                count++;
                break;
            }

            //不需要管一步走了多少 走到那里了 只需要知道 走到了能够让下一步最大的地方
            //i==cur 意味着 遍历到了这一步能够到的最大距离
            //这个时候也已经知道了 在这个范围下一步走到哪里会有更大的下一个区域
            //就可以把下一个区域赋值给当前
            if(i==cur){
                cur=max;
                count++;
            }
        }
        return count;

    }

上面是比较简单的三道小题，但是感觉给我的”贪心感“很不错。而且有的题使用一些其他方法的，代码也挺多，贪心还是挺牛的。

以上纯纯是本小白的个人感想，发出来也想要收到大佬们的指点和交流，也希望能帮到和我一样小白的人，如果对我的文章感兴趣的话，麻烦给我鼓励支持哦。（标题竟然不能包含小白和菜鸟。。。。）