实训四—贪婪算法专题—第2关：求一个数列的极差

• 任务描述
• 编程要求
• 测试说明

---

任务描述

本关任务：将 n 个正整数作成的一个数列，进行如下操作：每一次删除其中的两个数 a 和 b，然后在数列中加入一个数a×b+1，如此下去直至数列中剩下一个数。

在所有按这种操作方式最后得到的数中，最大的记作 max，最小的记作 min，则该数列的极差定义为M=max-min，请你使用贪心算法设计编程输出他们的极差。

编程要求

请在右侧编辑器Begin-End处补充代码，完成本关任务（注意已经为你获取输入数据）。

测试说明

平台会对你编写的代码进行测试，比对你输出的数值与实际正确数值，只有所有数据全部计算正确才能通过测试：

测试输入：

1. 7 //输入7（n）个整数
2. 3 //此行及以下为具体的每个数据
3. 5
4. 7
5. 9
6. 11
7. 13
8. 15

预期输出：Max=max-min=2221298-2038489=182809

#include <stdio.h>

// 函数原型声明
int get_min(int a[], int num);
int get_max(int a[], int num);

void main() {
    int i, num;
    scanf("%d", &num);
    int a[num+1];
    for (i = 1; i <= num; i++)
        scanf("%d", &a[i]);

    int min_value = get_min(a, num);
    int max_value = get_max(a, num);
    int M = min_value - max_value;

    printf("Max=max-min=%d-%d=%d\n", min_value, max_value, M);
}

        // 函数用于计算最小值
        int get_min(int a[], int num) {
        int min_queue[num+1], min_size = 0;

        for (int i = 1; i <= num; i++) {
        min_queue[min_size++] = a[i];
            }

        // 模拟最小堆的功能
        while (min_size > 1) {
        // 找到两个最小的数
        int min1 = min_queue[0], min1_index = 0;
        for (int i = 1; i < min_size; i++) {
                if (min_queue[i] < min1) {
                min1 = min_queue[i];
                min1_index = i;
                }       
        }

            // 将第一个最小的数移到末尾
            min_queue[min1_index] = min_queue[--min_size];

            int min2 = min_queue[0], min2_index = 0;
            for (int i = 1; i < min_size; i++) {
        if (min_queue[i] < min2) {
        min2 = min_queue[i];
        min2_index = i;
            }
            }

            // 将第二个最小的数移到末尾
            min_queue[min2_index] = min_queue[--min_size];

            // 合并两个最小的数
            int new_num = min1 * min2 + 1;
            min_queue[min_size++] = new_num;
        }

            return min_queue[0];
            }

            // 函数用于计算最大值
            int get_max(int a[], int num) {
        int max_queue[num+1], max_size = 0;

            for (int i = 1; i <= num; i++) {
            max_queue[max_size++] = a[i];
        }

            // 模拟最大堆的功能
        while (max_size > 1) {
        // 找到两个最大的数
        int max1 = max_queue[0], max1_index = 0;
        for (int i = 1; i < max_size; i++) {
            if (max_queue[i] > max1) {
            max1 = max_queue[i];
            max1_index = i;
        }
        }

        // 将第一个最大的数移到末尾
        max_queue[max1_index] = max_queue[--max_size];

        int max2 = max_queue[0], max2_index = 0;
        for (int i = 1; i < max_size; i++) {
            if (max_queue[i] > max2) {
            max2 = max_queue[i];
            max2_index = i;
        }
        }

        // 将第二个最大的数移到末尾
        max_queue[max2_index] = max_queue[--max_size];

        // 合并两个最大的数
        int new_num = max1 * max2 + 1;
        max_queue[max_size++] = new_num;
            }

        return max_queue[0];
}