SDOI2010 猪国杀

最新推荐文章于 2019-08-08 22:36:00 发布

YangHao5

最新推荐文章于 2019-08-08 22:36:00 发布

阅读量3.5k

点赞数 1

分类专栏：信息学|模拟

本文链接：https://blog.csdn.net/YangHao5/article/details/89009996

版权

信息学|模拟专栏收录该内容

12 篇文章 0 订阅

订阅专栏

题目描述

《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。

游戏目的：

主猪（MP）：自己存活的情况下消灭所有的反猪。

忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。

反猪（FP）：杀死主猪。

游戏过程：

游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。

开始游戏时，从主猪开始，按照逆时针方向（数据中就是按照编号从1,2,3…n,1…的顺序）依次行动。

每个玩家自己的回合可以分为下面的阶段：

◎摸牌阶段：从牌堆顶部摸两张牌，依次放到手牌的最右边；

◎出牌阶段：你可以使用0张到任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。当然，要满足如下规则：

1.如果没有猪哥连弩，每个出牌阶段只能使用一次“杀”来攻击；

2.任何牌被使用后被弃置（武器是装备上）；

被弃置的牌以后都不能再用，即与游戏无关；

各种牌介绍：

每张手牌用一个字母表示，字母代表牌的种类。

◎基本牌：

『桃§』：在自己的回合内，如果自己的体力值不等于体力上限，那么使用一个桃可以为自己补充一点体力，否则不能使用桃；桃只能对自己使用；在自己的回合外，如果自己的血变为0或者更低，那么也可以使用；

『杀(K)』：在自己的回合内，对攻击范围内除自己以外的一名角色使用。如果没有被『闪』抵消，则造成1点伤害。无论有无武器，杀的攻击范围都是1；

『闪(D)』：当你受到杀的攻击时，可以弃置一张闪来抵消杀的效果；

◎锦囊牌：

『决斗(F)』：出牌阶段，对除自己以外任意一名角色使用，由目标角色先开始，自己和目标角色轮流弃置一张杀，首先没有杀可弃的一方受到1点伤害，另一方视为此伤害的来源；

『南猪入侵(N)』：出牌阶段，对除你以外所有角色使用，按逆时针顺序从使用者下家开始依次结算，除非弃置一张杀，否则受到1点伤害；

『万箭齐发(W)』：和南猪入侵类似，不过要弃置的不是杀而是闪；

『无懈可击(J)』：在目标锦囊生效前抵消其效果。每次有一张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会；

效果：用于决斗时，决斗无效并弃置；用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对一个角色产生效果）；用于无懈可击时，成为目标的无懈可击被无效。

◎装备牌：

『猪哥连弩(Z)』：武器，攻击范围1，出牌阶段你可以使用任意张杀；

同一时刻最多只能装一个武器；如果先前已经有了一把武器，那么之后再装武器的话，会弃置以前的武器来装现在的武器；

特殊事件及概念解释：

◎伤害来源：杀、南猪入侵、万箭齐发的伤害来源均是使用该牌的猪，决斗的伤害来源如上；

◎距离：两只猪的距离定义为沿着逆时针方向间隔的猪数＋1。即初始时1和2的距离为1，但是2和1的距离就是n-1。注意一个角色的死亡会导致一些猪距离的改变；

◎玩家死亡：如果该玩家的体力降到0或者更低，并且自己手中没有足够的桃使得自己的体力值回到1，那么就死亡了，死亡后所有的牌（装备区，手牌区）被弃置；

◎奖励与惩罚：反猪死亡时，最后一个伤害来源处（即使是反猪）立即摸三张牌。忠猪死亡时，如果最后一个伤害来源是主猪，那么主猪所有装备牌、手牌被弃置；

◎注意，一旦达成胜利条件，游戏立刻结束，因此即使会摸3张牌或者还有牌可以用也不用执行了。

几种行为：

◎献殷勤：使用无懈可击挡下南猪入侵、万箭齐发、决斗；使用无懈可击抵消表敌意；

◎表敌意：对某个角色使用杀、决斗；使用无懈可击抵消献殷勤；

◎跳忠：即通过行动表示自己是忠猪。跳忠行动就是对主猪或对某只已经跳忠的猪献殷勤，或者对某只已经跳反的猪表敌意；

◎跳反：即通过行动表示自己是反猪。跳反行动就是对主猪或对某只已经跳忠的猪表敌意，或者对某只已经跳反的猪献殷勤；

忠猪不会跳反，反猪也不会跳忠；不管是忠猪还是反猪，能够跳必然跳；

行动准则：

共性：每个角色如果手里有桃且生命值未满，那么必然吃掉；有南猪入侵、万箭齐发、必然使用；有装备必然装上；受到杀时，有闪必然弃置；响应南猪入侵或者万箭齐发时候，有杀/闪必然弃置；不会对未表明身份的猪献殷勤（包括自己）；

特性：

◎主猪：主猪会认为没有跳身份，且用南猪入侵/万箭齐发对自己造成伤害的猪是“类反猪”（没伤害到不算，注意“类反猪”并没有表明身份），如果之后跳了，那么主猪会重新认识这只猪；对于每种表敌意的方式，对逆时针方向能够执行到的第一只“类反猪”或者已跳反猪表；如果没有，那么就不表敌意；决斗时会不遗余力弃置杀；如果能对已经跳忠的猪或自己献殷勤，那么一定献；如果能够对已经跳反的猪表敌意，那么一定表；

◎忠猪：对于每种表敌意的方式，对逆时针方向能够执行到的第一只已经跳反的猪表，如果没有，那么就不表敌意；决斗时，如果对方是主猪，那么不会弃置杀，否则，会不遗余力弃置杀；如果有机会对主猪或者已经跳忠的猪献殷勤，那么一定献；

◎反猪：对于每种表敌意的方式，如果有机会则对主猪表，否则，对逆时针方向能够执行到的第一只已经跳忠的猪表，如果没有，那么就不表敌意；决斗时会不遗余力弃置杀；如果有机会对已经跳反的猪献殷勤，那么一定献；

输入格式

输入文件第一行包含两个正整数n(2 <= n <= 10) 和m( m <= 2000)，分别代表玩家数和牌堆中牌的数量。数据保证牌的数量够用。

接下来n行，每行5个字符串，依次表示对第i只猪的角色和初始4张手牌描述。编号为1的肯定是主猪。

再接下来一行，一共m个字符串，按照从牌堆顶部到牌堆底部的顺序描述每张牌。

所有的相邻的两个字符串都严格用1个空格隔开，行尾没有多余空格。

输出格式

输出数据第一行包含一个字符串代表游戏结果。如果是主猪胜利，那么输出“MP”，否则输出“FP”。数据保证游戏总会结束。

接下来n行，第i行是对第i只猪的手牌描述（注意只需要输出手牌），按照手牌从左往右的顺序输出，相邻两张牌用一个空格隔开，行末尾没有多余空格。如果这只猪已阵亡，那么只要输出“DEAD”即可。注意如果要输出手牌而没有手牌的话，那么只需输出一个空行。

输入样例

3 10
MP D D F F
ZP N N N D
FP J J J J
F F D D J J F F K D

输出样例

FP
DEAD
DEAD
J J J J J J D

数据范围与提示

一共20组测试数据，每个点 $5$ 分。 $10$ 的数据没有锦囊牌，另外 $20$ 的数据没有无懈可击。

#include<cstdio>
#include<cstdlib>
#include<cstring>

int n,m,now;
char str[25];
char Pool[200010];
int len=0;

#define reg register
bool check();

struct node{ //猪类
	int num; //编号
	int type; //对外显示的身份
	int st,ed;
	int hp; //Hitpoint
	int Xbow; //是否有连弩
	int killed;
	int died; //是否死亡
	int ID; //真实身份
	/*	ID=0	ZP
		ID=1	FP
		ID=2	Like-FP
	*/
	int LastFrom; //受到的最后一点伤害的来源
	char card[2010]; //手牌
	void Insert(char c){ //插入手牌
		card[++ed]=c;
	}
	int Pop(char c){ //弹出手牌
		for(reg int i=st;i<=ed;++i)
			if(card[i]==c){
				card[i]=' ';
				return 1;
			}
		return 0;
	}
	node(){
		ID=-1;died=0;hp=4;Xbow=0;
		type=-1;LastFrom=-1;
		st=1;ed=0;
	}
}Pig[15];
void Update(int num){ //更新生命值信息
	if(Pig[num].hp>4) Pig[num].hp=4;
	while(Pig[num].hp<1){
		if(Pig[num].Pop('P'))
			++Pig[num].hp;
		else
			break;
	}
	if(Pig[num].hp>=1)
		return;
	Pig[num].died=1;
	if(!check()) return;
	switch(Pig[num].type){
		case 0: //反贼被杀
			Pig[Pig[num].LastFrom].Insert(Pool[++len]);Pig[Pig[num].LastFrom].Insert(Pool[++len]);Pig[Pig[num].LastFrom].Insert(Pool[++len]);
			break;
		case 1: //主公杀忠臣
			if(Pig[num].LastFrom==1){
				Pig[1].Xbow=0;
				for(reg int i=1;i<=2000;++i)
					Pig[1].card[i]=' ';
			}
			break;
	}
}
int Rejudge(int num,int Target,int type){//判断无懈可击
//	printf("j %d %d\n",num,Target);
	if(Pig[Target].ID==-1||Pig[Target].ID==2||Pig[num].died||Pig[Target].died) return 0;//同阵营不用，下同
	if(type&&Pig[num].type!=Pig[Target].type) return 0;
	if(!type&&Pig[num].type==Pig[Target].type) return 0;
	if(Pig[num].Pop('J')){
//		printf("J %d %d %d %d %d\n",num,Target,type,Pig[num].type,Pig[Target].type);
		Pig[num].ID=type?Pig[Target].ID:!Pig[Target].ID;//亮明身份
		int tf=1;//判断是否有其他人响应此无懈可击
		for(reg int i=num+1;i<=n;++i)
			if(Rejudge(i,num,0)){
				tf=0;
				break;
			}
		if(!tf) return 0;
		for(reg int i=1;i<num;++i)
			if(Rejudge(i,num,0)){
				tf=0;
				break;
			}
//		printf(" tf%d\n",tf);
		return tf;
	}
	return 0;
}
void Poison(int From,int Target,int type){//万箭齐发 / 南蛮入侵
	if(Pig[From].died||Pig[Target].died) return;
	for(reg int i=From;i<=n;++i)
		if(Rejudge(i,Target,1))
			return;
	for(reg int i=1;i<From;++i)
		if(Rejudge(i,Target,1))
			return;
	if(!Pig[Target].Pop(type?'K':'D')){
		--Pig[Target].hp;Pig[Target].LastFrom=From;
		if(Target==1&&Pig[From].ID==-1&&From!=1)
			Pig[From].ID=2;
		Update(Target);
	}
}
void Round(int num){
	if(Pig[num].died) return;
	Pig[num].killed=0;
	Pig[num].Insert(Pool[++len]);Pig[num].Insert(Pool[++len]);
	int first=-1,a,b,ST=0,tf;
	for(reg int i=Pig[num].st;i<=Pig[num].ed;++i){
		if(!check()||Pig[num].died) break;
		if(Pig[num].card[i]!=' '&&first==-1) first=i;
		switch(Pig[num].card[i]){
			case 'P':
				if(Pig[num].hp==4)
					break;
				++Pig[num].hp;
//				printf("-> %c\n",Pig[num].card[i]);
				Pig[num].card[i]=' ';
				break;
			case 'K':
				if(Pig[num].killed&&!Pig[num].Xbow)
					break;
//				printf(".");
				int Target,d;
				Target=num+1;
				while(Target!=num){
					if(Target==n+1)
						Target=1;
					else if(Pig[Target].died)
						++Target;
					else break;
				}
				d=Pig[Target].ID;
				if((num==1&&d>0)||(Pig[num].type&&d==1)||(!Pig[num].type&&!d)){
					if(d>0) Pig[num].ID=0;
					else Pig[num].ID=1;
					if(!Pig[Target].Pop('D')){
						--Pig[Target].hp;
						Pig[Target].LastFrom=num;
						Update(Target);
					}
					Pig[num].killed=1;
//					printf("-> K %d\n",Target);
					Pig[num].card[i]=' ';
				}
				break;
			case 'Z':
				Pig[num].Xbow=1;
				Pig[num].card[i]=' ';
				i=ST;
				break;
			case 'N':
//				printf("-> N\n");
				Pig[num].card[i]=' ';
				for(reg int j=num+1;j<=n;++j){
					if(!check()) break;
					Poison(num,j,1);
				}
				for(reg int j=1;j<num;++j){
					if(!check()) break;
					Poison(num,j,1);
				}
				i=ST;
				break;
			case 'W':
//				printf("-> %c\n",Pig[num].card[i]);
				Pig[num].card[i]=' ';
				for(reg int j=num+1;j<=n;++j){
					if(!check()) break;
					Poison(num,j,0);
				}
				for(reg int j=1;j<num;++j){
					if(!check()) break;
					Poison(num,j,0);
				}
				i=ST;
				break;
			case 'F':
				Target=0;
				if(!Pig[num].type)
					Target=1;
				if(Pig[num].type==1||num==1){
					Target=num+1;
					while(Target!=num){
						if(Target==n+1)
							Target=1;
						else if(Pig[Target].died||Pig[Target].ID<1||(Pig[Target].ID==2&&num!=1))
							++Target;
						else break;
					}
					if(Target==num)
						Target=0;
				}
				if(!Target)
					break;
//				printf("%d Fight %d\n",num,Target);
				if(Pig[Target].ID) Pig[num].ID=0;
				else Pig[num].ID=1;
				Pig[num].card[i]=' ';
				tf=0;i=ST;
				for(reg int j=num;j<=n;++j)
					if(Rejudge(j,Target,1)){
						tf=1;
						break;
					}
				if(tf) break;
				for(reg int j=1;j<num;++j)
					if(Rejudge(j,Target,1)){
						tf=1;
						break;
					}
				if(tf) break;
				a=Target,b=num;
				while(1){
					a^=b^=a^=b;
					if(num==1&&Pig[Target].type){
						--Pig[b].hp;
						Pig[b].LastFrom=a;
						Update(b);
						break;
					}
					if(Pig[b].Pop('K')){
//						printf("%d k\n",b);
						/*for(reg int j=Pig[b].st;j<=Pig[b].ed;++j)
							if(Pig[b].card[j]!=' ')
								printf("%c ",Pig[b].card[j]);
						puts("");*/
						continue;
					}
					--Pig[b].hp;
					Pig[b].LastFrom=a;
					Update(b);
					break;
				}
				if(Pig[Target].died&&Pig[Target].type&&a==1&&a==num){
					i=Pig[num].ed;
//					printf("%d %d %d\n",Pig[num].st,Pig[num].ed,i);
				}
				break;
			case ' ':
				break;
			default:
				break;
		}
	}
	if(first!=-1) Pig[num].st=first;
}
bool check(){
	if(Pig[1].died) return 0;
	for(reg int i=2;i<=n;++i)
		if(!Pig[i].died&&!Pig[i].type)
			return 1;
	return 0;
}
int main(){
//	freopen("data.txt","r",stdin);
//	freopen("yh.txt","w",stdout);
	scanf("%d%d",&n,&m);
	for(reg int i=1;i<=n;++i){
		Pig[i].num=i;
		scanf("%s",str);
		switch(str[0]){
			case 'M':
				Pig[i].ID=0;Pig[i].type=1;
				break;
			case 'Z':
				Pig[i].type=1;
				break;
			case 'F':
				Pig[i].type=0;
				break;
			default:
				break;
		}
		for(reg int j=1;j<=4;++j){
			scanf("%s",str);
			Pig[i].Insert(str[0]);
		}
	}
	for(reg int i=1;i<=m;++i){
		scanf("%s",str);
		Pool[i]=str[0];
	}
	for(reg int i=m+1;i<=200000;++i)
		Pool[i]=Pool[m];
	now=1;
	while(check()){
		Round(now);/*
	if(Pig[1].died)
		puts("FP");
	else
		puts("MP");
	for(reg int i=1;i<=n;++i){
		printf("%d %d Z%d ",Pig[i].hp,Pig[i].ID,Pig[i].Xbow);
		if(Pig[i].died)
			puts("DEAD");
		else{
			for(reg int j=Pig[i].st;j<=Pig[i].ed;++j)
				if(Pig[i].card[j]!=' ')
					printf("%c ",Pig[i].card[j]);
			puts("");
		}
	}
	printf("%d\n",len);
		system("pause>nul");
		puts("--------------------");*/
		++now;
		if(now==n+1) now=1;
//		printf("now%d\n",now);
	}
	if(Pig[1].died)
		puts("FP");
	else
		puts("MP");
	for(reg int i=1;i<=n;++i){
		if(Pig[i].died)
			puts("DEAD");
		else{
			for(reg int j=Pig[i].st;j<=Pig[i].ed;++j)
				if(Pig[i].card[j]!=' ')
					printf("%c ",Pig[i].card[j]);
			puts("");
		}
	}
}

YangHao5

关注

1
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
SDOI2010 猪国杀

题目描述《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。游戏目的：主猪（MP）：自己存活的情况下消灭所有的反猪。忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。反猪（FP）：杀死主猪。游戏过程：游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。开始游戏时，从主猪开始，按照...
复制链接

扫一扫