秋招笔试惨痛经历之——贪心算法

1. 贪心：跳跃3问、合并区间

1. 跳跃游戏(无负数)

class Solution {
    public boolean canJump(int[] nums) {
        /*
        跳跃游戏
        7.24
        */
        //贪心

        //判断空
        if(nums.length == 0){
            return false;
        }

        //初始化jump
        int jump = nums[0];

        for(int i=0;i= i){
                //提取大的值
                jump = Math.max(i + nums[i],jump);

                //如果叠加后的jump能够大于等于nums.length-1，说明能够到达最后一个位置
                if(jump >= nums.length-1){
                    return true;
                }
            }
        }
        return false;
    }
}

2. 跳跃游戏(有负数)

import java.util.*;

public class Main{
    public static void main(String[] args){
        Scanner sc = new Scanner(System.in);
        String[] str = sc.nextLine().replace("[","").replace("]","").split(",");
        
        int[] nums = new int[str.length];
        for(int i=0;i nums.length-1){
                System.out.println("true");
                return;
            }
        }
        
        System.out.println("false");
    }
}

3. 跳跃游戏最少跳跃次数

class Solution {
    public int jump(int[] nums) {
        /*
        跳跃游戏
        8.3
        */
        //贪心

        if(nums.length == 1){
            return 0;
        }

        int max = 0;
        int step = 0;
        int jump = 0;

        for(int i=0;i= nums.length-1){
                return step+1;      //开始的一跳也要算上
            }

            //使用jump来接收max，用于判断是否要进行下一次跳跃。当jump距离等于i时，需要进行下一次跳跃，jump替换为max，step+1
            if(jump == i){
                jump = max;
                step = step+1;
            }
        }

        return step;
    }
}

4. 合并区间

class Solution {
    public int[][] merge(int[][] intervals) {
        /*
        合并区间
        7.24
        */
        //Arrays.sort(intervals,(a,b) -> (a[0] - b[0]))

        //判断空
        if(intervals.length == 0 || intervals[0].length == 0){
            return new int[0][];
        }

        //使用List存储数组
        List result = new ArrayList<>();
        
        //根据第一列数据升序排序
        Arrays.sort(intervals,(a,b) -> (a[0] - b[0]));

        int index = 0;
        while(index < intervals.length){
            //提取当前行的第一个元素
            int first = intervals[index][0];
            //当前行的第二个元素
            int second = intervals[index][1];

            //while判断second是否大于下一行的第一个元素
            while(index < intervals.length-1 && intervals[index+1][0] <= second){
                //提取下一行的第二个元素作为second
                second = Math.max(intervals[index+1][1],second);
                index++;
            }

            //添加到list
            result.add(new int[]{first,second});

            index++;
        }

        //转为数组
        return result.toArray(new int[0][]);
    }
}

5. 加油站

class Solution {
    public int canCompleteCircuit(int[] gas, int[] cost) {
        /*
        加油站
        8.25
        */

        int toNext = 0;
        int start = 0;
        int total = 0;

        for(int i=0;i