华为OD机试真题----最佳观光组合

给你一个正整数数组 values，其中 values[i] 表示第 i 个观光景点的评分，并且两个景点 i 和 j 之间的 距离 为 j - i。

一对景点（i < j）组成的观光组合的得分为 values[i] + values[j] + i - j ，也就是景点的评分之和 减去 它们两者之间的距离。

返回一对观光景点能取得的最高分。

示例 1：

输入：values = [8,1,5,2,6]
输出：11
解释：i = 0, j = 2, values[i] + values[j] + i - j = 8 + 5 + 0 - 2 = 11

示例 2：

输入：values = [1,2]
输出：2

提示：

• 2 <= values.length <= 5 * 104
• 1 <= values[i] <= 1000

public class maxScoreSightseeingPair1014 {
    private static final Logger log = LoggerFactory.getLogger(maxScoreSightseeingPair1014.class);

    /**
     * 计算最大的观光对分数
     * 观光对的分数定义为两个景点的价值之和减去它们之间的距离
     *
     * @param values 表示每个景点的价值的整数数组
     * @return 返回最大的观光对分数
     */
    public static int maxScoreSightseeingPair(int[] values) {
        // 如果数组为空或长度小于2，则无法形成观光对，返回0
        if(values == null || values.length < 2) {
            return 0;
        }
        // 用于存储最大的观光对分数
        int maxScore = 0;
        log.error("初始化最大的观光对分数:{}", maxScore);
        // 初始化当前最大价值索引为数组的第一个元素
        int maxValueIndex = values[0];
        log.error("初始化当前最大价值索引:{}", maxValueIndex);
        // 遍历数组，从第二个元素开始
        for(int i = 1; i < values.length; i++) {
            log.error("----------------------------------------");
            if(values[i] < 0) {
                log.error("警告：无效的 values[i] 值：" + values[i]);
                continue;
            }
            log.error("当前下标索引:{}, 当前对应元素:{}", i, values[i]);
            // 计算当前观光对的分数
            int score = maxValueIndex + values[i] - i;
            log.error("当前观光对的分数:{}", score);
            // 更新最大的观光对分数
            maxScore = Math.max(maxScore, score);
            log.error("更新最大的观光对分数:{}", maxScore);
            // 更新当前最大价值索引，考虑索引i的价值和索引i的距离之和
            maxValueIndex = Math.max(maxValueIndex, values[i] + i);
            log.error("更新当前最大价值索引:{}", maxValueIndex);
        }
        // 返回最大的观光对分数
        return maxScore;
    }


    public static void main(String[] args) {
        int[] values = {1,8,5,2,6};
        System.out.println(maxScoreSightseeingPair(values));

    }
}

后续回过头来发现以上代码中，有几个关键的地方需要调整和优化，以确保代码的正确性和效率。首先，让我们纠正和详细说明代码中的一些错误和概念。

问题纠正

1. 初始化 maxValueIndex:
   maxValueIndex 应该初始化为 values[0] + 0，即 values[0] 的值加上它的索引（0）。这是因为我们要计算的是 values[i] + i 的最大值，这会影响到观光对的分数计算。

2. 日志记录:
   虽然日志记录对于调试很有帮助，但在生产代码中通常不会使用。这里为了详细解释，我们暂时保留日志，但在实际提交或运行环境中应移除。

3. 无效值检查:
   values[i] < 0 的检查是不必要的，因为题目已经说明了 1 <= values[i] <= 1000。

详细解释和优化后的代码

public class MaxScoreSightseeingPair {

    /**
     * 计算最大的观光对分数
     * 观光对的分数定义为两个景点的价值之和减去它们之间的距离
     *
     * @param values 表示每个景点的价值的整数数组
     * @return 返回最大的观光对分数
     */
    public static int maxScoreSightseeingPair(int[] values) {
        // 如果数组为空或长度小于2，则无法形成观光对，返回0
        if (values == null || values.length < 2) {
            return 0;
        }
        
        // 用于存储最大的观光对分数
        int maxScore = 0;
        
        // 初始化当前最大价值（考虑索引的值和索引之和）为数组的第一个元素及其索引之和
        int maxValueWithIndex = values[0] + 0;
        
        // 遍历数组，从第二个元素开始
        for (int i = 1; i < values.length; i++) {
            // 计算当前观光对的分数
            // 注意这里我们用的是 maxValueWithIndex 而不是之前的 maxValueIndex
            int score = maxValueWithIndex - i + values[i];
            
            // 更新最大的观光对分数
            maxScore = Math.max(maxScore, score);
            
            // 更新当前最大价值（考虑索引的值和索引之和）
            maxValueWithIndex = Math.max(maxValueWithIndex, values[i] + i);
        }
        
        // 返回最大的观光对分数
        return maxScore;
    }

    public static void main(String[] args) {
        int[] values = {8, 1, 5, 2, 6};
        System.out.println("最大观光对分数: " + maxScoreSightseeingPair(values)); // 输出应为11

        // 测试更多例子
        int[] values2 = {1, 2};
        System.out.println("最大观光对分数: " + maxScoreSightseeingPair(values2)); // 输出应为2
    }
}

代码解释

• 输入检查:
  首先检查输入数组是否为空或长度小于2，这是形成观光对的基本条件。

• 初始化:
  maxScore 初始化为0，用于存储最大观光对分数。
  maxValueWithIndex 初始化为 values[0] + 0，表示第一个景点的值加上其索引（0）。

• 遍历数组:
  从第二个元素开始遍历数组，对于每个元素 values[i]，计算观光对分数 maxValueWithIndex - i + values[i]。
  更新 maxScore 为当前最大分数和之前计算的最大分数中的较大值。
  更新 maxValueWithIndex 为当前 maxValueWithIndex 和 values[i] + i 中的较大值，以便在后续计算中使用。

• 输出结果:
  最后输出计算得到的最大观光对分数。

这样，代码不仅更加清晰，而且符合题目的要求，能够正确计算出最大的观光对分数。