题解-贪心猫的鱼干大分配 | 豆包MarsCode AI刷题

为了解决这个问题，我们需要确保每只猫获得的鱼干数量满足以下条件：

1. 每只猫至少获得一斤鱼干。
2. 如果一只猫的等级值高于其邻居，则它获得的鱼干数量必须多于其邻居。

我们可以使用贪心算法来解决这个问题。具体步骤如下：

1. 初始化鱼干数组：创建一个数组 fish，长度与猫的数量相同，初始值全部为1，因为每只猫至少获得一斤鱼干。
2. 从左到右扫描：确保每只猫的鱼干数量大于其左边的邻居（如果等级值更高）。
3. 从右到左扫描：确保每只猫的鱼干数量大于其右边的邻居（如果等级值更高）。
4. 计算总鱼干数量：将 fish 数组中的所有值相加，得到所需的最少鱼干数量。

代码实现

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static int solution(int n, List<Integer> cats_levels) {
        // 初始化鱼干数组，每只猫至少获得一斤鱼干
        int[] fish = new int[n];
        for (int i = 0; i < n; i++) {
            fish[i] = 1;
        }

        // 从左到右扫描，确保每只猫的鱼干数量大于其左边的邻居（如果等级值更高）
        for (int i = 1; i < n; i++) {
            if (cats_levels.get(i) > cats_levels.get(i - 1)) {
                fish[i] = fish[i - 1] + 1;
            }
        }

        // 从右到左扫描，确保每只猫的鱼干数量大于其右边的邻居（如果等级值更高）
        for (int i = n - 2; i >= 0; i--) {
            if (cats_levels.get(i) > cats_levels.get(i + 1)) {
                fish[i] = Math.max(fish[i], fish[i + 1] + 1);
            }
        }

        // 计算总鱼干数量
        int totalFish = 0;
        for (int f : fish) {
            totalFish += f;
        }

        return totalFish;
    }

    public static void main(String[] args) {
        List<Integer> catsLevels1 = new ArrayList<>();
        catsLevels1.add(1);
        catsLevels1.add(2);
        catsLevels1.add(2);

        List<Integer> catsLevels2 = new ArrayList<>();
        catsLevels2.add(6);
        catsLevels2.add(5);
        catsLevels2.add(4);
        catsLevels2.add(3);
        catsLevels2.add(2);
        catsLevels2.add(16);

        List<Integer> catsLevels3 = new ArrayList<>();
        catsLevels3.add(1);
        catsLevels3.add(2);
        catsLevels3.add(2);
        catsLevels3.add(3);
        catsLevels3.add(3);
        catsLevels3.add(20);
        catsLevels3.add(1);
        catsLevels3.add(2);
        catsLevels3.add(3);
        catsLevels3.add(3);
        catsLevels3.add(2);
        catsLevels3.add(1);
        catsLevels3.add(5);
        catsLevels3.add(6);
        catsLevels3.add(6);
        catsLevels3.add(5);
        catsLevels3.add(5);
        catsLevels3.add(7);
        catsLevels3.add(7);
        catsLevels3.add(4);

        System.out.println(solution(3, catsLevels1) == 4);
        System.out.println(solution(6, catsLevels2) == 17);
        System.out.println(solution(20, catsLevels3) == 35);
    }
}

解释

1. 初始化鱼干数组：fish 数组初始化为1，因为每只猫至少获得一斤鱼干。
2. 从左到右扫描：确保每只猫的鱼干数量大于其左边的邻居（如果等级值更高）。
3. 从右到左扫描：确保每只猫的鱼干数量大于其右边的邻居（如果等级值更高）。
4. 计算总鱼干数量：将 fish 数组中的所有值相加，得到所需的最少鱼干数量。

测试用例

• 样例1：

  • 输入：n = 3, cats_levels = [1, 2, 2]
  • 输出：4

• 样例2：

  • 输入：n = 6, cats_levels = [6, 5, 4, 3, 2, 16]
  • 输出：17

• 样例3：

  • 输入：n = 20, cats_levels = [1, 2, 2, 3, 3, 20, 1, 2, 3, 3, 2, 1, 5, 6, 6, 5, 5, 7, 7, 4]
  • 输出：35

希望这个解决方案能够帮助你解决问题。如果有任何问题，请随时在评论区交流讨论。