比赛难度(HDU4546)

比赛难度

Time Limit: 3000/1000 MS (Java/Others)    Memory Limit: 65535/32768 K (Java/Others)
Total Submission(s): 768    Accepted Submission(s): 263

Problem Description

　　最近，小明出了一些ACM编程题，决定在HDOJ举行一场公开赛。
　　假设题目的数量一共是n道，这些题目的难度被评级为一个不超过1000的非负整数，并且一场比赛至少需要一个题，而这场比赛的难度，就是所有题目的难度之和，同时，我们认为一场比赛与本场题目的顺序无关，而且题目也不会重复。
　　显而易见，很容易得到如下信息：
　　假设比赛只用1个题目，有n种方案；
　　假设比赛使用2个题目，有(n-1)*n/2种方案；
　　假设比赛使用3个题目，有(n-2)*(n-1)*n/6种方案；
　　............
　　假设比赛使用全部的n个题目，此时方案只有1种。
　　
　　经过简单估算，小明发现总方案数几乎是一个天文数字！
　　为了简化问题，现在小明只想知道在所有的方案里面第m小的方案，它的比赛难度是多少呢？

 

Input

输入数据的第一行为一个整数T（1 <= T <= 20），表示有T组测试数据。
每组测试数据第一行为两个整数n, m（0 < n, m <= 10000），表示现在有n个题目，现在要求第m小的方案的比赛难度。接下来第二行有n个数字，分别表示这n个题目的难度值。

 

Output

对于每组测试数据，输出一行"Case #c: ans"（不包含引号），ans 表示要求的第m小的比赛难度，输入数据保证存在第m小的方案，具体参见样例。

 

Sample Input

2

5 6

1 1 1 1 1

5 25

1 2 3 4 5

Sample Output

Case #1: 2

Case #2: 11

Source

2013金山西山居创意游戏程序挑战赛——初赛（1）

 

Recommend

liuyiding   |   We have carefully selected several similar problems for you:  5609 5608 5607 5605 5604 

思路：贪心。

由于数据很大所以不可能一个一个枚举也就是2^n.

每个数选或不选。。

先把难度按升序排。

那没还是考虑每个数选或不选，由于题目只要求最大就前1000个数，所以可以把最小的找出来，也就是nandu[0];

开结构体记录当前状态下，选这个数的和，和不选这个数的和，同时记录这个数的数组下标，开优先队列，以难度升序，那么先将第一个状态入队。

然后每次取出顶层的，就是当前所有状态最小的。

然后由这个最小状态去找他的下一个状态，也就是它的后一个元素选或不选，再加入队列即可，取出的所要求的个数，就是排第几位。

#include<stdio.h>
#include<algorithm>
#include<iostream>
#include<string.h>
#include<math.h>
#include<queue>
#include<string.h>
#include<stack>
#include<vector>
#include<map>
#define sc(x) scanf("%I64d",&x)
#define pr(x) printf("%I64d",x)
#define prr(x) printf("%I64d
",x)
#define prrr(x) printf(" %I64d",x)
#define FOR(i,p,q) for(int i=p;i<=q;i++)
typedef struct pp
{
    int x;//没有选id的状态
    int y;//选了id的状态
    int id;
    bool operator<(const pp&cx)const//优先队列按难度升序排
    {
        return cx.y<y;
    }
} ss;
using namespace std;
int nandu[10005];
int main(void)
{
    int n,m,i,j,k,p,q;
    scanf("%d",&k);
    for(i=1; i<=k; i++)
    {
        priority_queue<ss>que;
        scanf("%d %d",&p,&q);
        for(j=0; j<p; j++)
        {
            scanf("%d",&nandu[j]);
        }
        sort(nandu,nandu+p);
        ss fi;//定义初始状态，也就是难度最小的
        fi.x=0;
        fi.y=nandu[0];
        fi.id=0;
        que.push(fi);
        int cc;
        while(q--)
        {
            ss lk;
            lk=que.top();
            if(q==0)
            {
                cc=lk.y;
            }
            que.pop();
            ss dd;
            if(lk.id<p-1)//当前最小的状态
            {
                dd.x=lk.x;//当前最小状态没有选nandu[lk.id];
                dd.y=lk.x+nandu[lk.id+1];
                dd.id=lk.id+1;
                que.push(dd);
                dd.x=lk.y;//当前最小状态选nandu[lk.id]
                dd.y=lk.y+nandu[lk.id+1];
                dd.id=lk.id+1;
                que.push(dd);
            }
        }
        printf("Case #%d: %d
",i,cc);
    }
    return 0;

}