代码随想录算法训练营第三十四天

qq3969189

已于 2023-05-08 23:23:22 修改

阅读量100

点赞数

文章标签： leetcode 算法职场和发展 java

于 2023-05-08 00:35:03 首次发布

本文链接：https://blog.csdn.net/qq3969189/article/details/130549949

版权

文章提供了几道力扣(LeetCode)的编程题目的解决方案，包括K次取反后最大化的数组和问题，采用暴力和贪心算法，以及加油站问题和分发糖果问题，强调了在优化策略中贪心算法的应用，确保局部最优解能导向全局最优解。

摘要由CSDN通过智能技术生成

1005. K 次取反后最大化的数组和 - 力扣（LeetCode）

暴力：循环k次，每次循环时先排序，然后把最小的一个数变为她的反数，最后累计和即可

/**
     * 1005. K 次取反后最大化的数组和---暴力
     * 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
     * 选择某个下标 i并将 nums[i] 替换为 -nums[i] 。
     * 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
     * 以这种方式修改数组后，返回数组 可能的最大和 。
     *
     * @param nums
     * @param k
     * @return
     */
    public int largestSumAfterKNegations(int[] nums, int k) {
        while (true) {
            Arrays.sort(nums);
            k--;
            if (k == 0) {
                break;
            }
            nums[0] = -nums[0];
        }
        int result = 0;
        for (int i = 0; i < nums.length; i++) {
            result += nums[i];
        }
        return result;
    }

贪心：根据绝对值大数进行排序。那么从大到小遍历，遍历时元素为负时则转正且K--。如果k<=0,那么数组和则为最大和，如果k>0且k是奇数,那么把数组最小值变成他的反数。然后统计数组和即可

/**
     * 1005. K 次取反后最大化的数组和---贪心
     * 给你一个整数数组 nums 和一个整数 k ，按以下方法修改该数组：
     * 选择某个下标 i并将 nums[i] 替换为 -nums[i] 。
     * 重复这个过程恰好 k 次。可以多次选择同一个下标 i 。
     * 以这种方式修改数组后，返回数组 可能的最大和 。
     *
     * @param nums
     * @param k
     * @return
     */
    public int largestSumAfterKNegations1(int[] nums, int k) {
        nums = IntStream.of(nums).boxed().sorted(((o1, o2) -> Math.abs(o2) - Math.abs(o1))).mapToInt(Integer::intValue).toArray();
        int length = nums.length;
        for (int i = 0; i < length; i++) {
            if (nums[i] < 0 && k > 0) {
                nums[i] *= -1;
                k--;
            }
        }
        nums[length - 1] = k % 2 == 1 ? -nums[length - 1] : nums[length - 1];
        int result = 0;
        for (int num : nums) {
            result += num;
        }
        return result;
    }

134. 加油站 - 力扣（LeetCode）

贪心：局部最优：当前累加rest[i]的和curSum一旦小于0，起始位置至少要是i+1，因为从i之前开始一定不行。全局最优：找到可以跑一圈的起始位置。反着思考就是totalSum>=0,必然可以跑完，然后遍历完成后curSum<0时，起点是当前索引+1。如果后续没有curSum<0，那么必然当前索引+1可以跑完的起点。

/**
     * 134. 加油站---贪心
     * 在一条环路上有 n个加油站，其中第 i个加油站有汽油gas[i]升。
     * 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1个加油站需要消耗汽油cost[i]升。你从其中的一个加油站出发，开始时油箱为空。
     * 给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
     *
     * @param gas
     * @param cost
     * @return
     */
    public int canCompleteCircuit(int[] gas, int[] cost) {
        int curSum = 0, totalSum = 0, startIndex = 0;
        for (int i = 0; i < gas.length; i++) {
            curSum += gas[i] - cost[i];
            totalSum += gas[i] - cost[i];
            if (curSum < 0) {
                curSum = 0;
                startIndex = i + 1;
            }
        }
        return totalSum >= 0 ? startIndex : -1;
    }

整体最优：

情况一：如果gas的总和小于cost总和，那么无论从哪里出发，一定是跑不了一圈的
情况二：rest[i] = gas[i]-cost[i]为一天剩下的油，i从0开始计算累加到最后一站，如果累加没有出现负数，说明从0出发，油就没有断过，那么0就是起点。
情况三：如果累加的最小值是负数，汽车就要从非0节点出发，从后向前，看哪个节点能把这个负数填平，能把这个负数填平的节点就是出发节点。

/**
     * 134. 加油站---整体考虑
     * 在一条环路上有 n个加油站，其中第 i个加油站有汽油gas[i]升。
     * 你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1个加油站需要消耗汽油cost[i]升。你从其中的一个加油站出发，开始时油箱为空。
     * 给定两个整数数组 gas 和 cost ，如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1 。如果存在解，则 保证 它是 唯一 的。
     *
     * @param gas
     * @param cost
     * @return
     */
    public int canCompleteCircuit1(int[] gas, int[] cost) {
        int curSum = 0, min = Integer.MAX_VALUE;
        for (int i = 0; i < gas.length; i++) {
            curSum += gas[i] - cost[i];
            if (curSum < min) {
                min = curSum;
            }
        }
        if (curSum < 0) {
            return -1;
        }
        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;
    }

135. 分发糖果 - 力扣（LeetCode）

贪心：与老师的思考类似，不过考虑的当前元素的大小比较条件比较多。

/**
     * 135. 分发糖果---贪心
     * n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
     * 你需要按照以下要求，给这些孩子分发糖果：
     * 每个孩子至少分配到 1 个糖果。
     * 相邻两个孩子评分更高的孩子会获得更多的糖果。
     * 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
     *
     * @param ratings
     * @return
     */
    public int candy(int[] ratings) {
        int length = ratings.length;
        if (length == 1) {
            return length;
        }
        int[] results = new int[length];
        Arrays.fill(results, 1);
        for (int i = 1; i < length - 1; i++) {
            if (ratings[i] - ratings[i - 1] > 0) {
                results[i] = results[i - 1] + 1;
            }
            if (ratings[i] - ratings[i + 1] > 0) {
                results[i] = results[i + 1] + 1;
            }
            if (ratings[i] - ratings[i - 1] > 0 && ratings[i] - ratings[i + 1] > 0) {
                results[i] = Math.max(results[i - 1], results[i + 1]) + 1;
            }
        }
        for (int i = length - 2; i >= 1; i--) {
            if (ratings[i] - ratings[i - 1] > 0) {
                results[i] = Math.max(results[i - 1] + 1, results[i]);
            }
            if (ratings[i] - ratings[i + 1] > 0) {
                results[i] = Math.max(results[i + 1] + 1, results[i]);
            }
            if (ratings[i] - ratings[i - 1] > 0 && ratings[i] - ratings[i + 1] > 0) {
                results[i] = Math.max(Math.max(results[i - 1], results[i + 1]) + 1, results[i]);
            }
        }
        if (ratings[0] - ratings[1] > 0) {
            results[0] = results[1] + 1;
        }
        if (ratings[length - 1] - ratings[length - 2] > 0) {
            results[length - 1] = results[length - 2] + 1;
        }
        int result = 0;
        for (int i : results) {
            result += i;
        }
        return result;
    }

贪心：

1、先确定右边评分大于左边的情况（也就是从前向后遍历）

此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果。

前向后遍历全局最优：相邻的孩子中，评分高的右孩子获得比左边孩子更多的糖果局部最优可以推出全局最优。

2、然后确定左边评分大于右边的情况（也就是从后向前遍历）

此时局部最优：只要右边评分比左边大，右边的孩子就多一个糖果。（前面有从前向后遍历结果）

那么最终全局最优：相邻的孩子中，评分高的孩子获得比旁边的孩子更多的糖果达到全局最优。

/**
     * 135. 分发糖果---贪心
     * n 个孩子站成一排。给你一个整数数组 ratings 表示每个孩子的评分。
     * 你需要按照以下要求，给这些孩子分发糖果：
     * 每个孩子至少分配到 1 个糖果。
     * 相邻两个孩子评分更高的孩子会获得更多的糖果。
     * 请你给每个孩子分发糖果，计算并返回需要准备的 最少糖果数目 。
     *
     * @param ratings
     * @return
     */
    public int candy1(int[] ratings) {
        int length = ratings.length;
        int[] results = new int[length];
        Arrays.fill(results, 1);
        for (int i = 1; i < length; i++) {
            if (ratings[i] - ratings[i - 1] > 0) {
                results[i] = results[i - 1] + 1;
            }
        }
        for (int i = length - 2; i >= 0; i--) {
            if (ratings[i] - ratings[i + 1] > 0) {
                results[i] = Math.max(results[i + 1] + 1, results[i]);
            }
        }

        int result = 0;
        for (int i : results) {
            result += i;
        }
        return result;
    }