POJ 1456 贪心+并查集/贪心+堆

题目描述
A supermarket has a set Prod of products on sale. It earns a profit px for each product x∈Prod sold by a deadline dx that is measured as an integral number of time units starting from the moment the sale begins. Each product takes precisely one unit of time for being sold. A selling schedule is an ordered subset of products Sell ≤ Prod such that the selling of each product x∈Sell, according to the ordering of Sell, completes before the deadline dx or just when dx expires. The profit of the selling schedule is Profit(Sell)=Σx∈Sellpx. An optimal selling schedule is a schedule with a maximum profit.
For example, consider the products Prod={a,b,c,d} with (pa,da)=(50,2), (pb,db)=(10,1), (pc,dc)=(20,2), and (pd,dd)=(30,1). The possible selling schedules are listed in table 1. For instance, the schedule Sell={d,a} shows that the selling of product d starts at time 0 and ends at time 1, while the selling of product a starts at time 1 and ends at time 2. Each of these products is sold by its deadline. Sell is the optimal schedule and its profit is 80.

Write a program that reads sets of products from an input text file and computes the profit of an optimal selling schedule for each set of products.
Input
A set of products starts with an integer 0 <= n <= 10000, which is the number of products in the set, and continues with n pairs pi di of integers, 1 <= pi <= 10000 and 1 <= di <= 10000, that designate the profit and the selling deadline of the i-th product. White spaces can occur freely in input. Input data terminate with an end of file and are guaranteed correct.
Output
For each set of products, the program prints on the standard output the profit of an optimal selling schedule for the set. Each result is printed from the beginning of a separate line.

Sample Input
4 50 2 10 1 20 2 30 1

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

Sample Output
80
185

大致意思：对于每组测试数据，输入一个n表示商品的总数，然后依次输入每一个商品的过期时间和价值，只有在过期前卖出才能得到它的价值，卖出一个商品需要花费1的时间，问最多收获多少价值？

算法1：贪心+堆
从过期最晚的商品的时间从后往前推，每次将目前可以卖出的商品加入堆中。然后从堆中取出最大的元素就是要取的一个商品。

证明：
显然 1 最大值>=此方法得到的值
下证 2 最大值<=此方法得到的值
如果在一次操作中，没有取符合条件的最大值，则最后得到的方案的获利一定小于等于取最大值的方法得到的获利，因此最大值<=此方法得到的值。

#include <queue>
#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;
const int N = 1e4 + 10;
typedef pair<int, int> PII;
PII cmd[N];
int n, p, d;


int main()
{
    while (cin >> n)
    {
        priority_queue<int> q;
        int res = 0, t = 0, idx = n - 1;
        for (int i = 0; i < n; i ++)
        {
            cin >> p >> d;
            cmd[i] = {d, p};
            t = max(t, d);
        }
        sort(cmd, cmd + n);
        
        while (t)
        {
            while (cmd[idx].first >= t && idx >= 0)
            {
                q.push(cmd[idx].second);
                idx --;
            }
            if (q.size())
            {
                int val = q.top();
                q.pop();
                res += val;
            }
            t --;
        }
        cout << res << endl;
    }
}

算法2：贪心+并查集
贪心思想：将价值从大到小进行排序，进行遍历，如果能选择当前商品，则一定要选择。检查能否选择当前商品时，从该商品的过期时间从后往前推，如果找到了空挡，就将该商品放在这个空挡。朴素做法需要从后往前遍历来检查是否合法。因此总的时间复杂度是O（n^2）。如果用并查集来维护，每次选择一个时间t时，将t的父节点设置为t-1，因此只需找到过期时间的父节点就是可以插入的空挡。

#include <queue>
#include <algorithm>
#include <cstring>
#include <iostream>

using namespace std;
const int N = 1e4 + 10;
typedef pair<int, int> PII;
PII cmd[N];
int n, p, d;
int fa[N];
void init(int n)
{
    for (int i = 0; i <= n; i ++)
        fa[i] = i;
}

int find(int x)
{
    if (fa[x] == x) return x;
    return fa[x] = find(fa[x]);
}

int main()
{
    while (cin >> n)
    {
        init(10000);
        int res = 0;
        for (int i = 0; i < n; i ++)
        {
            cin >> p >> d;
            cmd[i] = {p, d};
        }
        sort(cmd, cmd + n);
        
        for (int i = n - 1; i >= 0; i --)
        {
            int px = cmd[i].first;
            int pd = cmd[i].second;
            
            int deadline = find(pd);
            // printf("---px:%d---pd:%d-----deadline:%d\n", px, pd, deadline);
            if (deadline != 0)
            {
                res += px;
                fa[deadline] = deadline - 1;
            }
        }
        cout << res << endl;
    }
}