HDU 5360 Hiking （贪心+优先队列）

本文纯属原创，转载注明出处：http://blog.csdn.net/zip_fan。谢谢。

传送门：http://acm.hdu.edu.cn/showproblem.php?pid=5360

Time Limit: 6000/3000 MS (Java/Others)    Memory Limit: 131072/131072 K (Java/Others)
Special Judge

Problem Description

There are  n  soda conveniently labeled by  1,2,…,n . beta, their best friends, wants to invite some soda to go hiking. The  i -th soda will go hiking if the total number of soda that go hiking except him is no less than  li  and no larger than  ri . beta will follow the rules below to invite soda one by one:
1. he selects a soda not invited before;
2. he tells soda the number of soda who agree to go hiking by now;
3. soda will agree or disagree according to the number he hears.

Note: beta will always tell the truth and soda will agree if and only if the number he hears is no less than  li  and no larger than  ri , otherwise he will disagree. Once soda agrees to go hiking he will not regret even if the final total number fails to meet some soda's will.

Help beta design an invitation order that the number of soda who agree to go hiking is maximum.

 

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 contains an integer  n   (1≤n≤105) , the number of soda. The second line constains  n  integers  l1,l2,…,ln . The third line constains  n  integers  r1,r2,…,rn .  (0≤li≤ri≤n)
It is guaranteed that the total number of soda in the input doesn't exceed 1000000. The number of test cases in the input doesn't exceed 600.

 

Output

For each test case, output the maximum number of soda. Then in the second line output a permutation of  1,2,…,n  denoting the invitation order. If there are multiple solutions, print any of them.

 

Sample Input

  
  

   
   4
8
4 1 3 2 2 1 0 3
5 3 6 4 2 1 7 6
8
3 3 2 0 5 0 3 6
4 5 2 7 7 6 7 6
8
2 2 3 3 3 0 0 2
7 4 3 6 3 2 2 5
8
5 6 5 3 3 1 2 4
6 7 7 6 5 4 3 5
  
  

 

Sample Output

  
  

   
   7
1 7 6 5 2 4 3 8
8
4 6 3 1 2 5 8 7
7
3 6 7 1 5 2 8 4
0
1 2 3 4 5 6 7 8
  
  
  
  


  
  

题意：现在有n个人等待邀请，但是第i个人可以被邀请的要求是邀请他的时候，已经邀请的人不少于ai个且不多于bi个。当一个人被邀请之后不会反悔离开。

求最多邀请的人数，以及邀请的顺序（邀请了不来也得写上）

很简单很明确的一个贪心。

首先按每个人至少的要求排序。每次把当前达到最少要求的人取出来放入优先队列，然后每次抉择的时候按至多要求的人数最小的开始邀请即可。

下面贴代码。

#include <cstdio>
#include <cmath>
#include <cstring>
#include <string>
#include <map>
#include <queue>
#include <vector>
#include <iostream>
#include <algorithm>
#define moo 1000000007//10^9+7
#define PI acos(-1.0)
#define eps 1e-5
using namespace std;
struct People
{
    int Min,Max,id;
}peo[100000+10];
bool operator <(People x,People y)
{
    return x.Max>y.Max;
}//优先队列内以至多值从小到大排序
bool cmp(People x,People y)
{
    return x.Min<y.Min;
}
priority_queue<People>Q;
vector<int>ans;
int main()
{
    int T;
    cin>>T;
    while(T--)
    {
        while(!Q.empty())
            Q.pop();
        ans.clear();
        int n;
        scanf("%d",&n);
        for(int i=1;i<=n;peo[i].id=i,i++)
            scanf("%d",&peo[i].Min);
        for(int i=1;i<=n;i++)
            scanf("%d",&peo[i].Max);
        sort(peo+1,peo+n+1,cmp);
        int cnt=0,use=1;//cnt存已经成功邀请的人，use未达到最小值的当前的人
        do
        {
            if(!Q.empty())
            {
                if(Q.top().Max>=cnt)
                    cnt++;
                ans.push_back(Q.top().id);
                Q.pop();
            }//首先判断当前队列首的人会不会已经超过了上限，
            for(;use<=n;use++)//判断当前人的最小值是否被满足，如果满足，就加入优先队列
                if(peo[use].Min<=cnt)
                    Q.push(peo[use]);
                else
                    break;
        }while(!Q.empty());//当队列为空说明不会有人再满足最小值了
        int flag=0;
        cout<<cnt<<endl;
        for(int i=0;i<ans.size();flag=1,i++)//按顺序输出满足过最小值的人
            printf(flag==0?"%d":" %d",ans[i]);
        for(;use<=n;flag=1,use++)//将未满足最小值的人输出
            printf(flag==0?"%d":" %d",peo[use].id);
        printf("\n");
    }
    return 0;
}