代码随想录-贪心

鼠鼠想回浪浪山

已于 2024-04-07 20:21:26 修改

阅读量180

点赞数 3

文章标签： java 算法开发语言

于 2024-04-05 15:17:35 首次发布

本文链接：https://blog.csdn.net/m0_71894372/article/details/137380242

版权

分发饼干：

. - 力扣（LeetCode）

class Solution {
     public int findContentChildren(int[] g, int[] s) {
        Arrays.sort(g);
        Arrays.sort(s);
        int ge=g.length-1;
        int se=s.length-1;
        while (ge>=0&&se>=0){
            if (g[ge]>s[se]){
                ge--;
            }else{
                se--;
                ge--;
            }
        }
        return s.length-se-1;
    }
}

*********************摆动序列：

感觉自己没有脑子。

. - 力扣（LeetCode）

public int wiggleMaxLength(int[] nums) {
        if (nums.length <= 1) {
            return nums.length;
        }
        //当前差值
        int curDiff = 0;
        //上一个差值
        int preDiff = 0;
        int count = 1;
        for (int i = 1; i < nums.length; i++) {
            //得到当前差值
            curDiff = nums[i] - nums[i - 1];
            //如果当前差值和上一个差值为一正一负
            //等于0的情况表示初始时的preDiff
            if ((curDiff > 0 && preDiff <= 0) || (curDiff < 0 && preDiff >= 0)) {
                count++;
                preDiff = curDiff;
            }
        }
        return count;
    }

动态规划解法：

public int wiggleMaxLength(int[] nums) {
        int[][] dp=new int[nums.length][2];
        //1为波谷，0为波峰
        dp[0][0]=dp[0][1]=1;
        for (int i = 1; i <nums.length; i++) {
            dp[i][0]=dp[i][1]=1;
            for (int j = 0; j < i; j++) {
                if (nums[i]<nums[j]){
                    dp[i][1]=Math.max(dp[i][1],dp[j][0]+1);
                }
            }
            for (int j = 0; j < i; j++) {
                if (nums[i]>nums[j]){
                    dp[i][0]=Math.max(dp[i][0],dp[j][1]+1);
                }
                
            }
        }
        return Math.max(dp[nums.length-1][0],dp[nums.length-1][1]);
    }

最大子数组和

. - 力扣（LeetCode）

class Solution {
     public int maxSubArray(int[] nums) {
        if (nums.length==1){
            return nums[0];
        }
        int sum=nums[0];
        int max=nums[0];
        for (int i = 1; i < nums.length; i++) {
            if (sum<0){
                sum=nums[i];
            }else{
                sum+=nums[i];
            }
            max=Math.max(sum,max);
        }
        return max;
    }
}

贪心一点想不到

只收集利润为正的：

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

***跳跃游戏：

 public boolean canJump(int[] nums) {
        if (nums.length==1){
            return true;
        }
        for (int i = 0; i < nums.length-1; i++) {
            if (nums[i]==0){
                int j=i;
                while (j>=0){
                    if (j+nums[j]>i){
                        break;
                    }
                    j--;
                }
                if (j<0){
                    return false;
                }
            }
        }
        return true;
    }

****************************

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

*************跳跃游戏II:

. - 力扣（LeetCode）

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

*******************加油站：

. - 力扣（LeetCode）

超时暴力解法：

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int oil=0;
        for (int i = 0; i < gas.length; i++) {
            int j=i;
            oil=gas[i];
            while (oil>=cost[j]){
                oil-=cost[j];
                j=(j+1)%gas.length;
                oil+=gas[j];
                if (j==i){
                    return i;
                }
            }
        }
        return -1;
    }
}

贪心1：

class Solution {
     public int canCompleteCircuit(int[] gas, int[] cost) {
        int sum=0,min=0;
        for (int i = 0; i < gas.length; i++) {
            int rest=gas[i]-cost[i];
            sum+=rest;
            min=Math.min(min,sum);
        }
        if (sum<0) return -1;
        //剩余油量最少的时候也大于0
        if (min>=0) return 0;
        for (int i = gas.length-1; i >=0; i--) {
            int rest=gas[i]-cost[i];
            min+=rest;//查看哪个可以将缺少的油量填补
            if (min>=0){
                return i;
            }
        }
        return -1;
    }
}

class Solution {
     public int canCompleteCircuit(int[] gas, int[] cost) {
        int sum=0,start=0,cursum=0;
        for (int i = 0; i < gas.length; i++) {
            int rest=gas[i]-cost[i];
            sum+=rest;
            cursum+=rest;
            if (cursum<0){
                start=i+1;
                cursum=0;
            }
        }
        if (sum<0) return -1;
        return start;
    }
}

****柠檬水找零：

. - 力扣（LeetCode）

class Solution {
     public boolean lemonadeChange(int[] bills) {
        Map<Integer,Integer> map=new HashMap<>();
        for (int bill : bills) {
            if (bill==5){
                map.put(5,map.getOrDefault(5,0)+1);
            }
            if (bill==10){
                map.put(10,map.getOrDefault(10,0)+1);
                if (map.containsKey(5)&&map.get(5)>0){
                    map.put(5,map.getOrDefault(5,0)-1);
                }else{
                    return false;
                }
            }
            if (bill==20){
                if (map.containsKey(10)&&map.get(10)>0){
                    if (map.containsKey(5)&&map.get(5)>0){
                        map.put(10,map.getOrDefault(10,0)-1);
                        map.put(5,map.getOrDefault(5,0)-1);
                        map.put(20,map.getOrDefault(20,0)+1);
                    }else{
                        return false;
                    }
                }else{
                    if (map.containsKey(5)&&map.get(5)>=3){
                        map.put(5,map.getOrDefault(5,0)-3);
                    }else{
                        return false;
                    }
                }
            }
        }
        return true;
    }
}

使用变量替换map，效率更高

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int five=0,ten=0,twenty=0;
        for (int bill : bills) {
            if (bill==5){
                five++;
            }
            if (bill==10){
                if (five<=0) return false;
                five--;
                ten++;
            }
            if (bill==20){
                if (ten>0){
                    ten--;
                    if (five<=0) return false;
                    five--;
                    twenty++;
                }else{
                    if (five<3) return false;
                    five-=3;
                    twenty++;
                }
            }
        }
        return true;
    }
}

********************分发糖果：

. - 力扣（LeetCode）

class Solution {
    public int candy(int[] ratings) {
        int[] candy=new int[ratings.length];
        Arrays.fill(candy,1);
        for (int i = 1; i < ratings.length; i++) {
            if (ratings[i]>ratings[i-1]){
                candy[i]=candy[i-1]+1;
            }
        }
        for (int i = ratings.length-2; i>=0 ; i--) {
            if (ratings[i]>ratings[i+1]){
                candy[i]=Math.max(candy[i],candy[i+1]+1);
            }
        }
        int result=0;
        for (int i = 0; i < candy.length; i++) {
            result+=candy[i];
        }
        return  result;
    }
}

************根据身高重建队列：

. - 力扣（LeetCode）

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0]==o2[0]) return o1[1]-o2[1];
                return o2[0]-o1[0];
            }
        });
        LinkedList<int[]> queue=new LinkedList();
        for (int[] person : people) {
            queue.add(person[1],person);
        }
        return queue.toArray(new int[people.length][]);
    }
}

*********用最少数量的箭引爆气球：

. - 力扣（LeetCode）

 public int findMinArrowShots(int[][] points) {
        Arrays.sort(points, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0]==o2[0])
                    return Integer.compare(o1[1],o2[1]);
                else
                    return Integer.compare(o1[0],o2[0]);
            }
        });
        int count=1;
        for (int i = 1; i < points.length; i++) {
            if (points[i][0]>points[i-1][1]){
                count++;
            }else{
                points[i][1]=Math.min(points[i][1],points[i-1][1]);
            }
        }
        return count;
    }

******无重叠区间：

. - 力扣（LeetCode）

public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[0]==o2[0]){
                    return Integer.compare(o1[1],o2[1]);
                }else{
                    return Integer.compare(o1[0],o2[0]);
                }
            }
        });
        int count=0;
        int end=intervals[0][1];
        for (int i = 1; i <intervals.length; i++) {
            if (intervals[i][0]<end){
                count++;
                end=Integer.min(intervals[i][1],end);
            }else{
                end=intervals[i][1];
            }
        }
        return count;
    }

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals, new Comparator<int[]>() {
            @Override
            public int compare(int[] o1, int[] o2) {
                if (o1[1]==o2[1]){
                    return Integer.compare(o1[0],o2[0]);
                }else{
                    return Integer.compare(o1[1],o2[1]);
                }
            }
        });
        int end=intervals[0][1];
        int count=1;
        for (int i = 1; i < intervals.length; i++) {
            if (intervals[i][0]>=end){
                count++;
                end=intervals[i][1];
            }else{
                end=Integer.min(end,intervals[i][1]);
            }
        }
        return intervals.length-count;
    }
}