64.英雄决斗的最大胜利次数

问题理解

小 U 和小 F 正在进行一场由 n 轮组成的英雄决斗比赛。每一轮中，小 U 和小 F 各自从他们的英雄队伍中选出一位英雄进行对决，英雄的能力值将决定比赛的胜负，能力值高者获胜。小 U 已经按照固定的能力顺序 1, 2, 3, ..., n 安排了他的英雄出场顺序。

小 F 希望通过调整他的英雄出场顺序，最大化他的获胜轮数。我们需要帮助小 F 确定一个最佳的出场顺序，以获得最多的胜利。

数据结构的选择逻辑

1. 排序：由于小 U 的英雄能力值是固定的顺序 1, 2, 3, ..., n，我们可以通过排序小 F 的英雄能力值来简化问题。排序后，我们可以更容易地找到一个比小 U 当前英雄能力值大的最小英雄。
2. 贪心策略：我们可以使用贪心算法来解决这个问题。贪心算法的核心思想是每一步都做出当前看起来最优的选择，以期望最终结果是最优的。

算法步骤

1. 排序：首先对小 F 的英雄能力值进行排序。
2. 贪心匹配：从小 F 的能力值最小的英雄开始，尝试找到一个比小 U 当前英雄能力值大的最小英雄。
3. 计数获胜次数：如果找到了合适的英雄，则小 F 获胜，获胜次数加一，并且跳过这个已经用过的英雄。

具体步骤

1. 排序：对小 F 的英雄能力值数组进行排序。

2. 初始化：初始化一个变量 wins 用于记录小 F 的获胜次数，初始值为 0。

3. 双指针遍历：使用两个指针 i 和 j，i 表示小 U 的英雄，j 表示小 F 的英雄。

   • i 从小到大遍历，表示小 U 的英雄能力值为 i + 1。
   • j 从小到大遍历，表示小 F 的英雄能力值。

4. 贪心匹配：

   • 如果小 F 的英雄能力值 heroes[j] 小于等于小 U 的英雄能力值 i + 1，则继续向后查找。
   • 如果找到一个比小 U 当前英雄能力值大的最小英雄，则小 F 获胜，获胜次数 wins 加一，并且 j 指针向后移动一位。

5. 返回结果：最终返回 wins，即小 F 可以获得的最大胜利轮数。

总结

通过排序和贪心策略，我们可以有效地解决这个问题。排序使得我们可以更容易地找到一个比小 U 当前英雄能力值大的最小英雄，而贪心策略确保我们在每一步都做出最优的选择，以最大化小 F 的获胜次数。

solution完整代码

    public static int solution(int number, int[] heroes) {
        // 对小 Y 的英雄能力值进行排序
        Arrays.sort(heroes);
        
        // 初始化获胜次数
        int wins = 0;
        
        // 从小 Y 的能力值最小的英雄开始，尝试找到一个比小 W 当前英雄能力值大的最小英雄
        int j = 0;
        for (int i = 0; i < number; i++) {
            // 小 W 的英雄能力值为 i + 1
            int w_hero = i + 1;
            
            // 找到一个比小 W 当前英雄能力值大的最小英雄
            while (j < number && heroes[j] <= w_hero) {
                j++;
            }
            
            // 如果找到了，则小 Y 获胜
            if (j < number) {
                wins++;
                j++; // 这个英雄已经用过了，跳过
            }
        }
        
        return wins;
    }