题解1

55. 跳跃游戏

class Solution {
    //maxl记录目前能到达的最远距离，依次计算每一个位置，判断能否到达并更新最远距离
    public boolean canJump(int[] nums) {
        if(nums.length == 1)
            return true;
        int maxl = nums[0];
        for(int i = 1; i < nums.length; i ++){
            if(i > maxl) //如果该位置比最远距离大，不能到达，则返回false
                return false;
            if(maxl < i + nums[i]) //更新最远距离
                maxl = i + nums[i];
        }
        return true;
    }
}

class Solution {
    //len记录目前能走的距离，每走一格，len-1，并更新len，如果len小于等于0，即表示无法到达下一格，则返回false
    public boolean canJump(int[] nums) {
        if(nums.length == 1)
            return true;
        int len = nums[0];
        for(int i = 1; i < nums.length; i ++){
            if(len <= 0)
                return false;
            len --;
            if(len < nums[i])
                len = nums[i]; 
        }
        return true;
    }
}

class Solution {
    //从后向前遍历，len记录需要走的步数，初始为1，如果该格小于len，下一格需要满足的步数就会多1
    public boolean canJump(int[] nums) {
        if(nums.length == 1)
            return true;
        int len = 1;
        for(int i = nums.length-2; i > -1 ; i --){
            if(nums[i] < len)
                len ++;
            else
                len = 1;
        }
        if(len > 1)
            return false;
        return true;
    }
}

496. 下一个更大元素Ⅰ

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        int[] nums = new int[nums1.length];
        int t, index = 0;//t记录是否找到更大的数，index记录该数在nums2中的下标
        for(int i = 0; i < nums1.length; i ++){
            t = 0;
            //找到该数在nums2中的位置
            for(int j = 0; j < nums2.length; j ++){
                if(nums1[i] == nums2[j]){
                    index = j;
                    break;
                }
            }
            //判断右边有没有更大的数
            for(int j = index; j < nums2.length; j ++){
                if(nums2[j] > nums2[index]){
                    nums[i] = nums2[j];
                    t = 1;
                    break;
                }
            }
            if(t == 0)
                nums[i] = -1;
        }
        return nums;
    }
}

class Solution {
    public int[] nextGreaterElement(int[] nums1, int[] nums2) {
        //将nums2[0]入栈，如果第二个元素比该元素大，则将栈顶出栈，将第二个元素入栈，如果第二个元素比该元素小，就将第二个元素出栈，依次判断下一个元素，这样栈中元素保持一个从小到大的顺序
        Stack<Integer> stack = new Stack<>();
        //存储nums2中每个元素对应的更大元素
        HashMap<Integer, Integer> map = new HashMap<>();

        for(int i = 0; i < nums2.length; i ++){
            while(!stack.empty() && nums2[i] > stack.peek())
                map.put(stack.pop(), nums2[i]);
            stack.push(nums2[i]);
        }
        //如果栈不为空，则此时栈中元素的右边都无更大元素，所以他们对应的都是-1
        while(!stack.empty())
            map.put(stack.pop(), -1);
        //建立一个存储更大元素的数组
        int[] nums = new int[nums1.length];
        //直接查找
        for(int i = 0; i < nums1.length; i++){
            nums[i] = map.get(nums1[i]);
        }
        return nums;
    }
}