[BOI2019][第K大问题][暴力剪枝]D2T1 Olympiads

目录

• 题意
• 输入格式
• 输出格式
• 样例
  • Input
  • Output
• 数据范围
• 时间限制
• 思路
• 代码

题意

有\(N\)个人，现在你要从中选出\(K\)个人出来，然后让这\(K\)个人一起参加\(K\)场比赛。其中，每个人都要参加所有的比赛。

定义其中一场比赛的得分为这\(K\)个人的得分的最大值。然后定义这个队的得分为\(K\)场比赛的得分的加和。

例如，\(K=3\)时，有一支3个人的队伍，一共打3场比赛。第1个人在3场比赛中的得分分别为\((4, 5, 3)\)，第2个人在3场比赛中的得分分别为 \((7, 3, 6)\)， 第3个人在3场比赛中的得分分别为 \((3, 4, 5)\)。那么这个队伍的总得分就是\(7+5+6=18\)。

现在你要求出的是，总分最第\(C\)大的队伍的得分是多少。定义两个队伍不同，当且仅当存在两个两个队伍的人的编号不同。

输入格式

第一行3个整数分别表示\(N,K,C\)；

接下来N行，每行K个整数，表示每个人在每场比赛中的得分。

输出格式

一行，输出得分第\(C\)大的队伍的得分。

样例

Input

5 4 4

7 0 4 9

3 0 8 4

1 1 3 7

5 1 3 4

4 2 2 9

Output

24

数据范围

1.(13 points) 1 ≤ N ≤ 500, 1 ≤ K ≤ 2, 1 ≤ C ≤ 2 000.

2.(31 points) 1 ≤ N ≤ 40, 1 ≤ K ≤ 6, 1 ≤ C ≤ 2 000.

3.(24 points) 1 ≤ N ≤ 500, 1 ≤ K ≤ 6, 1 ≤ C ≤ 2 000, 每个人的分数大小不超过10.

4.(32 points) 1 ≤ N ≤ 500, 1 ≤ K ≤ 6, 1 ≤ C ≤ 2 000.

时间限制

\(2\ sec / 30\ sec\)

思路

首先声明这是自己的方法，没有看官方题解...

首先求一个得分最大的队伍出来，怎么求呢？

就是让每一场比赛的得分都尽量大，也就是取所有人中这场比赛得分最大的那个人。然后这样子选完之后可能没有选齐K个人，那么剩余的位置就随便找人来补齐就好了。

然后仿照所有的求第k大的题目的做法，把这个队伍塞到一个大根堆(priority_queue)中去，每次都从队首取出一个当前的最大答案，然后用这个队伍进行拓展，塞入其它没有出现过的其他队伍。

如何拓展呢？

最暴力的想法是，每次都将这个队伍中的一个人换成另外一个人，然后在确定了这支新的队伍没有出现过之后，就将这支队伍也塞到优先队列中去。

如何判断之前是否重复呢？我用的是Hash，然后把Hash值塞到一个set里面去，就可以简单的判重了。

考虑一下时间复杂度：一共要取出C次，就是\(O(C)\)，每次都要枚举将哪个人替换掉，也就是\(O(K)\)。还要枚举替换成哪个人，也就是\(O(N)\)。替换了之后，还要算出新的队伍的得分是多少，也就是\(O(K^2)\)的。然后还有set和priority_queue的时间复杂度，设为\(Const\)。那么总的时间复杂度就是\(O(N*K^3*C*Const)\)，大概有\(216,000,000+\)，好像跑不过...

考虑剪枝。考虑替换一个人的时候，只在N个人当中选出那些替换之后会使得答案变小或不变的那些人进行判重，判断没有出现过之后再选取其中的最大值进行扩展。这样子总共扩展出来的节点数就有原来的\(C*K*N\)变为了\(C*K\)，优先队列和set部分的时间就变小了。然后枚举的时候，也被剪掉了不少。这样子就可以跑到0.3s~0.4s左右。

代码

实现的有点丑，但是算法还是很简单暴力的。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#define MAXN 500
#define MAXK 6
#define MAXC 2000
#define MO 10000007
using namespace std;
typedef long long LL;
struct state
{
	int val;LL st;
	state(){};
	state(int _val,LL _st):val(_val),st(_st){};
};
bool operator < (const state &A,const state &B){return A.val<B.val;}
priority_queue<state> que;
struct node
{
	LL x;
	node *nxt;
}nd[MAXC*MAXN*MAXK+5];
node *ncnt=&nd[0],*Adj[MO+5];
int n,k,c,tmp[MAXK+1];
int scr[MAXN+5][MAXK+1];
LL Encode(int *seq)
{
	LL ret=0;
	for(int i=1;i<=k;i++)
		ret=1LL*ret*n+(1LL*seq[i]-1);
	return ret;
}
void Decode(LL val,int *seq)
{
	for(int i=k;i>=1;i--)
		seq[i]=val%n+1,val/=n;
}
int GetVal(int *seq)
{
	int ret=0;
	for(int j=1;j<=k;j++)
	{
		int mxval=0;
		for(int i=1;i<=k;i++)
			mxval=max(mxval,scr[seq[i]][j]);
		ret+=mxval;
	}
	return ret;
}
void Print(int *seq)
{
	for(int i=1;i<=k;i++)
		printf("%d ",seq[i]);
	printf("\n");
}
void Insert(LL x)
{
	int id=x%MO;
	node *p=++ncnt;
	p->x=x;
	p->nxt=Adj[id];
	Adj[id]=p;
}
bool Find(LL x)
{
	int id=x%MO;
	for(node *p=Adj[id];p!=NULL;p=p->nxt)
		if(p->x==x)
			return true;
	return false;
}
int Solve()
{
	static int tmp1[MAXK+5],tmp2[MAXK+5];
	static bool sp[MAXN+5];
	state fro;
	for(int tmn=1;tmn<c;tmn++)
	{
		fro=que.top();que.pop();
		Decode(fro.st,tmp1);
		for(int i=1;i<=k;i++)
			sp[tmp1[i]]=1;
		for(int i=1;i<=k;i++)
		{
			LL mxst;
			int mxval=-1;
			for(int j=1;j<=n;j++)
				if(sp[j]==false)
				{
					for(int p=1;p<=k;p++)
						tmp2[p]=tmp1[p];
					tmp2[i]=j;
					int val=GetVal(tmp2);
					if(val>fro.val)	continue;
					if(val>mxval)
					{
						sort(tmp2+1,tmp2+1+k);
						LL st=Encode(tmp2);
						if(Find(st))
							continue;
						mxval=val,mxst=st;
					}
				}
			if(mxval==-1)
				continue;
			Insert(mxst);
			Decode(mxst,tmp2);
			que.push(state(mxval,mxst));
		}
		for(int i=1;i<=k;i++)
			sp[tmp1[i]]=0;
	}
	return que.top().val;
}
int main()
{
	freopen("olymp.in","r",stdin);
	freopen("olymp.out","w",stdout);
	scanf("%d %d %d",&n,&k,&c);
	for(int i=1;i<=n;i++)
		for(int j=1;j<=k;j++)
			scanf("%d",&scr[i][j]);
	for(int j=1;j<=k;j++)
	{
		int mxpos=-1;
		for(int i=1;i<=n;i++)
			if(mxpos==-1||scr[mxpos][j]<scr[i][j])
				mxpos=i;
		tmp[j]=mxpos;
	}
	sort(tmp+1,tmp+1+k);
	int len=unique(tmp+1,tmp+1+k)-tmp-1;
	for(int i=len+1;i<=k;i++)
		for(int j=1;j<=n;j++)
		{
			bool Find=false;
			for(int p=1;p<i&&Find==false;p++)
				if(tmp[p]==j)
					Find=true;
			if(Find==false)
			{
				tmp[i]=j;
				break;
			}
		}
	sort(tmp+1,tmp+1+k);
	LL ret=Encode(tmp);
	Insert(ret);
	que.push(state(GetVal(tmp),ret));
	int ans=Solve();
	printf("%d\n",ans);
	return 0;
}
/*
5 4 4
7 0 4 9
3 0 8 4
1 1 3 7
5 1 3 4
4 2 2 9

*/