代码随想录Day20

维克吐蛙

于 2024-09-16 00:11:50 发布

阅读量320

点赞数 3

文章标签：算法 leetcode 数据结构

本文链接：https://blog.csdn.net/qq_43797723/article/details/142252983

版权

1、45. 跳跃游戏 II

2、1005. K 次取反后最大化的数组和

1、45. 跳跃游戏 II

有点难想

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

2、1005. K 次取反后最大化的数组和

Arrays.stream(nums).sum() 求和

class Solution {
    public int largestSumAfterKNegations(int[] nums, int k) {
        Arrays.sort(nums);
        for(int i = 0; i < nums.length && k > 0; ++i)
        {
            if(nums[i] <= 0)
            {
                nums[i] = -nums[i];
                --k;
            }    
            else
                break;      
        }
        if(k > 0 && k % 2 == 1)
        {
            Arrays.sort(nums);
            nums[0] = -nums[0];
        }
        return Arrays.stream(nums).sum();
    }
}

3、134. 加油站

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

4、135. 分发糖果

遍历两次，左右两边分开看

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 + 1] + 1,candy[i]);
        }
        return Arrays.stream(candy).sum();
    }
}

5、860. 柠檬水找零

这题简单

class Solution {
    public boolean lemonadeChange(int[] bills) {
        int[] money = new int[2];
        for(int i = 0; i < bills.length; ++i)
        {
            if(bills[i] == 5) money[0] += 1;
            if(bills[i] == 10)
            {
                if(money[0] > 0)
                {
                    --money[0];
                    ++money[1];
                }
                else return false;
            }
            if(bills[i] == 20)
            {
                if(money[0] > 0)
                {
                    if(money[1] > 0)
                    {
                        --money[1];
                        --money[0];
                    }
                    else
                    {
                        if(money[0] > 2)
                        {
                            money[0] -= 3;
                        }
                        else return false;
                    }
                }
                else return false;
            }
        }
        return true;
    }
}

6、406. 根据身高重建队列

先看一个维度，再看另一个维度

LinkedList变数组

que.toArray(new int[people.length][]);

class Solution {
    public int[][] reconstructQueue(int[][] people) {
        Arrays.sort(people,(a,b) -> {if(a[0] == b[0]) return a[1] - b[1]; return b[0] - a[0];});
        LinkedList<int[]> que = new LinkedList<>();
        for(int[] p : people)
        {
            que.add(p[1],p);
        }
        return que.toArray(new int[people.length][]);
    }
}

7、452. 用最少数量的箭引爆气球

使用Integer内置比较方法，不会溢出

class Solution {
    public int findMinArrowShots(int[][] points) {
        Arrays.sort(points,(a,b)->Integer.compare(a[0], b[0]));
        int l = points[0][0], r = points[0][1];
        int res = 1;
        for(int i = 1; i < points.length; ++i)
        {
            if(points[i][0] >= l && points[i][0] <= r)
            {
                l = points[i][0];
                r = Math.min(points[i][1],r);
            }
            else
            {
                l = points[i][0];
                r = points[i][1];
                ++res;
            }
        }
        return res;
    }
}

8、435. 无重叠区间

和上一题差不多

class Solution {
    public int eraseOverlapIntervals(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->Integer.compare(a[0], b[0]));
        int res = 0;
        for(int i = 1; i < intervals.length; ++i)
        {
            if(intervals[i][0] < intervals[i - 1][1])
            {
                intervals[i][1] = Math.min(intervals[i][1],intervals[i - 1][1]);
                ++res;
            }
        }
        return res;
    }
}

9、763. 划分字母区间

class Solution {
    public List<Integer> partitionLabels(String s) {
        int[] record = new int[26];
        Arrays.fill(record,-1);
        List<Integer> res = new LinkedList<>();
        for(int i = 0; i < s.length(); ++i)
        {
            record[s.charAt(i) - 'a'] = i;
        }
        int tmpIndex = -1;
        int rBorder = record[s.charAt(0) - 'a'];
        for(int i = 0; i < s.length(); ++i)
        {   
            rBorder = Math.max(record[s.charAt(i) - 'a'], rBorder);
            if(i == rBorder)
            {
                res.add(rBorder - tmpIndex);
                tmpIndex = i;
            }
        }
        return res;
    }
}

10、56. 合并区间

和前面的差不多

class Solution {
    public int[][] merge(int[][] intervals) {
        Arrays.sort(intervals,(a,b)->Integer.compare(a[0],b[0]));
        List<int[]> res = new LinkedList<>();
        int start = intervals[0][0];
        int end = intervals[0][1];
        for(int i = 0; i < intervals.length; ++i)
        {
            if(intervals[i][0] <= end)
            {
                end = Math.max(intervals[i][1],end);
            }
            else
            {
                res.add(new int[]{start,end});
                start = intervals[i][0];
                end = intervals[i][1];
            }
        }
        res.add(new int[]{start,end});
        return res.toArray(new int[res.size()][]);
    }
}

11、738. 单调递增的数字

从后往前看

class Solution {
    public int monotoneIncreasingDigits(int n) {
        String s = String.valueOf(n);
        char[] nums = s.toCharArray();
        if(nums.length == 1) return n;
        int start = nums.length;
        for(int i = nums.length - 1; i > 0 ; --i)
        {
            if(nums[i] < nums[i - 1])
            {
                --nums[i - 1];
                start = i;
            } 
        }
        for(int i = start; i < nums.length; ++i)
            nums[i] = '9';
        return Integer.parseInt(String.valueOf(nums));
    }
}

12、968. 监控二叉树

递归

class Solution {
    int res = 0;
    public int minCameraCover(TreeNode root) {
        if(traversal(root) == 0) ++res;
        return res;
    }
    public int traversal(TreeNode root)
    {
        if(root == null) return 2;
        int left = traversal(root.left);
        int right = traversal(root.right);
        if(left == 2 && right == 2) return 0;
        else if(left == 0 || right == 0)
        {
            ++res;
            return 1;
        }
        else return 2;
    }
}