【C++】AcWing在线题库 145. 超市 （贪心+并查集）

原题链接

问题描述

超市里有 N 件商品，每件商品都有利润 pi 和过期时间 di，每天只能卖一件商品，过期商品不能再卖。

求合理安排每天卖的商品的情况下，可以得到的最大收益是多少。

输入格式

输入包含多组测试用例。

每组测试用例，以输入整数 N 开始，接下来输入 N 对 pi 和 di，分别代表第 i 件商品的利润和过期时间。

在输入中，数据之间可以自由穿插任意个空格或空行，输入至文件结尾时终止输入，保证数据正确。

输出格式

对于每组产品，输出一个该组的最大收益值。

每个结果占一行。

数据范围

0≤N≤10000,
1≤pi,di≤10000
最多有 14 组测试样例

输入样例：

4  50 2  10 1   20 2   30 1

7  20 1   2 1   10 3  100 2   8 2
   5 20  50 10

输出样例：

80
185

问题分析

贪心+优先队列也可以解决这个问题，特点是把所有商品按照过期时间排序，并从小到大分析，这里不详细说明。

贪心+并查集则是把所有商品按照利润从大到小排序，并开始遍历（即优先考虑最大利润的商品来卖），然后要找其过期日期及之前的最晚日期来卖出这个商品，而一天最多只能卖出一件商品，问题的关键在于如何高效地找到这个日期，这里就使用并查集的方法。

（1）输入处理

对于像本题这样有多个测试样例的问题，都可以把主要代码用函数封装，然后重复调用，使代码更清晰易读：

int main()
{
    while (scanf("%d", &N) != EOF)
        Supermarket();
    return 0;
}

题目要求：在输入中，数据之间可以自由穿插任意个空格或空行，输入至文件结尾时终止输入，保证数据正确。

其实无关紧要，因为scanf函数本身就可以忽略空白。

（2）排序

把所有商品按照利润从大到小排序，每次都是取利润大的商品分析。

由于商品有利润和过期时间两个属性，可以定义一个类来存储每个商品：

class Com
{
public:
    bool operator<(const Com &_ano) const
    {
        return this->profit > _ano.profit;
    }
    int profit, expire;
};

对于只有两个属性的类，也可以用pair来表示，这里我们就用这个方法：

    pair<int, int> p[10010]; /*first表示利润，second表示过期时间*/

接受完输入后，我们就要排序，注意sort对pair默认是怎样排序的：

    for (int i = 0; i < N; ++i)
        scanf("%d%d", &p[i].first, &p[i].second);
    sort(p, p + N); /*用sort的话，pair 默认对first升序，当first相同时对second升序。因此这里是对利润升序排序*/

后面只要反向遍历p数组就可以了。

（3）并查集

这里我使用了自己之前按照课本上写过的并查集数据结构来使用，对于本题要做出修改，把合并操作的方法修改成了forward方法。

使用并查集是为了维护高效地查找距离某个日期“x”前面的、最近的、没有卖出过商品的日期“y”。具体来说，就是并查集的每个元素下标表示某个日期，其值表示要求的日期“y”。根据并查集的思路，一开始这些元素都初始为本身，即每一个日期的“y”就是本日期，当分析一个商品时，就把这个商品的过期日期在并查集中使用查找集合的方法UfsetFind来找到y，y就是可以卖的日期，注意还要进行路径压缩。如果y不等于0，说明有空余日期可以卖出。因为这一天已经卖出东西了，后面如果有商品也在这一天卖，我们只能找这一天前面的“y”，因此用forward方法把下标为x的元素设置成x-1。这样通过并查集就能高效地查找距离某个日期“x”前面的、最近的、没有卖出过商品的日期“y”了。

/*并查集（父结点数组实现）。对于这一个题要改造一下*/

#include <malloc.h>
typedef struct ufset *UFset; /*并查集*/
typedef struct ufset
{
    int *parent; // 若root[x]为1，则parent[x]表示结点x所在集合元素个数，否则表示其父结点
    int *root;   // root[x]表示结点x是否是根节点
} UFS;

/**
 * @brief 创建有size个元素的并查集
 */
UFset UFsetInit(int _size)
{
    UFset U = (UFset)malloc(sizeof(UFS));
    U->parent = (int *)malloc((_size + 1) * sizeof(int));
    U->root = (int *)malloc((_size + 1) * sizeof(int));
    for (int e = 0; e <= _size; ++e)
    {
        U->parent[e] = 1;
        U->root[e] = 1;
    }
    return U;
}

/**
 * @brief 释放并查集所占空间
 */
void UFsetFree(UFset _U)
{
    free(_U->parent);
    free(_U->root);
    free(_U);
}

/**
 * @brief 返回元素e所在集合。常用于判断两个元素是否在同一个集合中。采用了路径压缩技术。
 */
int UFsetFind(UFset _U, int _e)
{
    int i, j = _e;

    /*先依靠j不断上移找到树根*/
    while (!_U->root[j])
        j = _U->parent[j];

    /*此时j是树根了*/

    /*把e的所有长辈的父结点改为j，即路径压缩*/
    while (j != _e)
    {
        i = _U->parent[_e];
        _U->parent[_e] = j;
        _e = i;
    }
    return j;
}

void forward(UFset _U, int _i)
{
    _U->parent[_i] = _i - 1;
    _U->root[_i] = 0;
}

    for (int i = N - 1; i >= 0; --i)
    {
        int m = UFsetFind(U, p[i].second); /*找过期日期及之前可以卖的日子*/
        if (m)
        {
            forward(U, m);
            ans += p[i].first;
        }
    }

完整代码

#include <iostream>
#include <queue>
#include <vector>
#include <algorithm>
using namespace std;

/*并查集（父结点数组实现）。对于这一个题要改造一下*/

#include <malloc.h>
typedef struct ufset *UFset; /*并查集*/
typedef struct ufset
{
    int *parent; // 若root[x]为1，则parent[x]表示结点x所在集合元素个数，否则表示其父结点
    int *root;   // root[x]表示结点x是否是根节点
} UFS;

/**
 * @brief 创建有size个元素的并查集
 */
UFset UFsetInit(int _size)
{
    UFset U = (UFset)malloc(sizeof(UFS));
    U->parent = (int *)malloc((_size + 1) * sizeof(int));
    U->root = (int *)malloc((_size + 1) * sizeof(int));
    for (int e = 0; e <= _size; ++e)
    {
        U->parent[e] = 1;
        U->root[e] = 1;
    }
    return U;
}

/**
 * @brief 释放并查集所占空间
 */
void UFsetFree(UFset _U)
{
    free(_U->parent);
    free(_U->root);
    free(_U);
}

/**
 * @brief 返回元素e所在集合。常用于判断两个元素是否在同一个集合中。采用了路径压缩技术。
 */
int UFsetFind(UFset _U, int _e)
{
    int i, j = _e;

    /*先依靠j不断上移找到树根*/
    while (!_U->root[j])
        j = _U->parent[j];

    /*此时j是树根了*/

    /*把e的所有长辈的父结点改为j，即路径压缩*/
    while (j != _e)
    {
        i = _U->parent[_e];
        _U->parent[_e] = j;
        _e = i;
    }
    return j;
}

void forward(UFset _U, int _i)
{
    _U->parent[_i] = _i - 1;
    _U->root[_i] = 0;
}

/*两个属性的类，可以用pair来表示，也许会更高效吧。*/
// class Com
// {
// public:
//     bool operator<(const Com &_ano) const
//     {
//         return this->profit > _ano.profit;
//     }
//     int profit, expire;
// };

int N, p, d, ans;

void Supermarket()
{
    pair<int, int> p[10010]; /*first表示利润，second表示过期时间*/
    UFset U = UFsetInit(10010);
    ans = 0;
    for (int i = 0; i < N; ++i)
        scanf("%d%d", &p[i].first, &p[i].second);
    sort(p, p + N); /*用sort的话，pair 默认对first升序，当first相同时对second升序。因此这里是对利润升序排序*/
    for (int i = N - 1; i >= 0; --i)
    {
        int m = UFsetFind(U, p[i].second); /*找过期日期及之前可以卖的日子*/
        if (m)
        {
            forward(U, m);
            ans += p[i].first;
        }
    }
    printf("%d\n", ans);
    UFsetFree(U);
}

int main()
{
    while (scanf("%d", &N) != EOF)
        Supermarket();
    return 0;
}