hdu6301 Distinct Values（优先队列）

求解DistinctValues问题

原创于 2019-04-26 16:18:59 发布 · 199 阅读

1 ·

CC 4.0 BY-SA版权

hdu 同时被 2 个专栏收录

12 篇文章

订阅专栏

堆

4 篇文章

订阅专栏

针对DistincValues问题，采用小根堆维护可插入区间的数值，通过排序区间并逐个处理，确保每两个元素不相等，寻找字典序最小的数组。此算法适用于处理多个测试案例，确保在给定的时间和内存限制下找到最优解。

Distinct Values

Time Limit: 4000/2000 MS (Java/Others) Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 5774 Accepted Submission(s): 1952

Problem Description

Chiaki has an array of n positive integers. You are told some facts about the array: for every two elements ai and aj in the subarray al..r (l≤i<j≤r), ai≠ajholds.
Chiaki would like to find a lexicographically minimal array which meets the facts.

Input

There are multiple test cases. The first line of input contains an integer T, indicating the number of test cases. For each test case:

The first line contains two integers n and m (1≤n,m≤105) -- the length of the array and the number of facts. Each of the next m lines contains two integers li and ri (1≤li≤ri≤n).

It is guaranteed that neither the sum of all n nor the sum of all m exceeds 106.

Output

For each test case, output n integers denoting the lexicographically minimal array. Integers should be separated by a single space, and no extra spaces are allowed at the end of lines.

Sample Input

3 2 1 1 2 4 2 1 2 3 4 5 2 1 3 2 4

Sample Output

1 2 1 2 1 2 1 2 3 1 1

Source

2018 Multi-University Training Contest 1

解题思路

用小根堆维护可以放入区间中的数。先初始化序列全为1，并把1-n存入优先队列中。将区间排序，l小的在前面，如果l一样，则r大的在前面。对于排序后的区间，将第一组对应的区间按照从左到右的顺序赋值堆顶元素，出队。用pre表示上一组区间，初始化为第一组区间。因为堆是维护可以放入区间的数，所以，把没有和上一组重合的部分重新入队。再一个个出队赋值。要注意的是，只要处理r大于pre.r的区间，小于等于的和前面的区间完全重合了，没有处理的必要。处理完一个区间后，让pre等于该区间。

代码如下

#include <iostream>
#include <cstdio>
#include <set>
#include <vector>
#include <algorithm>
#include <cstring>
#include <queue>
#define maxn 100005
using namespace std;
struct T{
    int l, r;
    T(int l, int r): l(l), r(r){    }
    bool operator<(const T& a)const{
        if(l != a.l)
            return l < a.l;
        else
            return r > a.r;
    }
};
vector<T> vec;
int ans[maxn];
int main()
{
    int t;
    cin >> t;
    while(t --){
        int n, m;
        scanf("%d%d", &n, &m);
        priority_queue<int, vector<int>, greater<int>> que;
        for(int i = 1; i <= n; i ++){
            ans[i] = 1;
            que.push(i);
        }        
        for(int i = 1; i <= m; i ++){
            int l, r;
            scanf("%d%d", &l, &r);
            vec.push_back(T(l, r));
        }
        sort(vec.begin(), vec.end());
        T pre = vec[0];   //上一个处理的区间 
        for(int i = vec[0].l; i <= vec[0].r; i ++){
            ans[i] = que.top();
            que.pop();
        }
        for(int i = 1; i < vec.size(); i ++){
            if(vec[i].r > pre.r){
                for(int j = pre.l; j < min(vec[i].l, pre.r + 1); j ++)
                    que.push(ans[j]);
                for(int j = max(vec[i].l, pre.r + 1); j <= vec[i].r; j ++){
                    ans[j] = que.top();
                    que.pop();
                }
                pre = vec[i];  //更新pre 
            }
        }                
        for(int i = 1; i <= n; i ++){
            if(i != 1)
                putchar(' ');
            printf("%d", ans[i]);
        }
        putchar('\n');
        vec.clear();
    }
    return 0;
}