[SDOI2010]猪国杀

最新推荐文章于 2020-01-22 20:51:23 发布
最新推荐文章于 2020-01-22 20:51:23 发布
阅读量512 收藏
点赞数 1
分类专栏： 模拟
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/DntcryBecthlev/article/details/84074299
版权

好久没写博客了，就放个毒瘤的东西吧。
这题就是纯暴力的模拟。
特判一下献殷勤和表敌意。
注意无懈可以要分是对 “谁对谁献殷勤” 使用，还是 “谁对谁表敌意” 使用的。
注意只能杀下家（这是三国杀？）
其他的打tag就好了。
善用debug，不然真的会调到吐。
代码实在太长不建议模仿。
毕竟变量名很长。

#include <algorithm>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
 
#define R register
#define ll long long
#define ull unsigned long long
#define db double
#define ld long double
#define sqr(_x) ((_x) * (_x))
#pragma GCC optimize("2") //You can't see me
#define Cmax(_a, _b) ((_a) < (_b) ? (_a) = (_b), 1 : 0)
#define Cmin(_a, _b) ((_a) > (_b) ? (_a) = (_b), 1 : 0)
#define Max(_a, _b) ((_a) > (_b) ? (_a) : (_b))
#define Min(_a, _b) ((_a) < (_b) ? (_a) : (_b))
#define Abs(_x) (_x < 0 ? (-(_x)) : (_x))
 
#ifdef DEBUG
	#define debug(a...) ((fprintf(stderr,a),fflush(stderr)))
#else
	#define debug(a...) (1)
#endif
 
using namespace std;
 
namespace Dntcry
{
	inline int read()
	{
		R int a = 0, b = 1; R char c = getchar();
		for(; c < '0' || c > '9'; c = getchar()) (c == '-') ? b = -1 : 0;
		for(; c >= '0' && c <= '9'; c = getchar()) a = (a << 1) + (a << 3) + c - '0';
		return a * b;
	}
	inline ll lread()
	{
		R ll a = 0, b = 1; R char c = getchar();
		for(; c < '0' || c > '9'; c = getchar()) (c == '-') ? b = -1 : 0;
		for(; c >= '0' && c <= '9'; c = getchar()) a = (a << 1) + (a << 3) + c - '0';
		return a * b;
	}
	const int Maxn = 11, Maxm = 2010;
	int Num_of_Player, m, Now_turned_Player, Card_Pool_Top, Now_Player_Right[Maxn], Now_Player_left[Maxn], Now_Rebel_Lives, All_Player_Still_Lives;
	char Card_Pool[Maxm], str[Maxn];
	bool Kill_used, Allegiance, JumpReverse , Majesty_Killed_aLoyal;
	struct Pig_Node
	{
		int tot, hp, id, Card_Leftest;
		char Card[Maxm << 1];
		bool susp, loyal, rebel, equip, dead;
	}P[Maxn];
	void Get_aCard(R int player)
	{	
		if(Card_Pool_Top == m)
			P[player].Card[++P[player].tot] = Card_Pool[m];
		else P[player].Card[++P[player].tot] = Card_Pool[++Card_Pool_Top];
		debug("玩家 %d 摸到了牌 %c\Num_of_Player", player, P[player].Card[ P[player].tot] ); 
	}
	void Maintenance_the_Hand(R int player)
	{
		while(P[player].Card[ P[player].Card_Leftest ] == 0 && P[player].Card_Leftest <= P[player].tot) P[player].Card_Leftest++;
	}
	void Getcard_before_Round(R int player)
	{
		for(R int i = 0; i < 2; i++) Get_aCard(player);
		return ;
	}
	int Find_SusporRebel()
	{
		for(R int i = Now_Player_Right[0]; i; i = Now_Player_Right[i])
		{
			//printf("i = %d\Num_of_Player", i);
			//printf("now = %d\Num_of_Player susp = %d\Num_of_Player", i, P[i].susp);
			if(P[i].susp || P[i].rebel) 
			{
				debug("找到第一个反贼或类反贼为 %d\Num_of_Player", i);
				return i;
			}
		}
		debug("没有找到反贼或类反贼\n"); 
		return 0;
	}
	int Find_Rebel(R int player)
	{	
		for(R int i = Now_Player_Right[player]; i != player; i = Now_Player_Right[i])
			if(P[i].rebel) 
			{
				debug("找到第一个反贼为 %d\Num_of_Player", i);
				return i;
			}
		debug("没有找到反贼\n"); 
		return 0;
	}
	int Find_Loyal(R int player)
	{	
		for(R int i = Now_Player_Right[player]; i != player; i = Now_Player_Right[i])
			if(P[i].loyal) 
			{
				debug("找到第一个忠臣为 %d\Num_of_Player", i);
				return i;
			}
		debug("没有找到忠臣\n"); 
		return 0;
	}
	bool aCard_Canornot_Play(R char card)
	{
		if(card == 0) return 0;
		if(card == 'P') 
		{
			debug("该牌为桃，体力为 %d ", P[Now_turned_Player].hp);
			if(P[Now_turned_Player].hp < 4) debug("可以使用\n");
			else debug("不能使用\n"); 
			return P[Now_turned_Player].hp < 4;
		}
		if(card == 'K')
		{
			debug("该牌为杀\n"); 
			if(Kill_used && !P[Now_turned_Player].equip) 
			{
				debug("本回合已使用杀，且未装备连弩，无法继续使用杀\n"); 
				return 0;
			}
			if(Now_turned_Player == 0)
			{
				if(P[ Now_Player_Right[Now_turned_Player] ].susp || P[ Now_Player_Right[Now_turned_Player] ].rebel) return 1;
				return 0;
			}
			if(P[Now_turned_Player].id == 1)
			{
				if(P[ Now_Player_Right[Now_turned_Player] ].rebel) return 1;
				return 0;
			}
			if(Now_Player_Right[Now_turned_Player] == 0) return 1;
			if(P[ Now_Player_Right[Now_turned_Player] ].loyal) return 1;
			return 0;
		}
		if(card == 'D' || card == 'J') 
		{
			debug("该牌为闪或无懈可击，无法主动出牌\n");
			return 0;
		} 
		if(card == 'F') 
		{
			debug("该牌为决斗\n");
			if(Now_turned_Player == 0)
			{
				R int tmp = Find_SusporRebel();
				//puts("susp:");
				//for(R int i = 0; i < Num_of_Player; i++) printf("%d ", P[i].susp);
				//printf("tmp = %d\Num_of_Player", tmp);
				if(tmp) return 1;
				//puts("down");
				return 0;
			}
			if(P[Now_turned_Player].id == 1)
			{
				if(Find_Rebel(Now_turned_Player)) return 1;
				return 0;
			}
			return 1;
		}
		if(card == 'N' || card == 'W') 
		{
			debug("该牌为南蛮入侵或万箭齐发\n"); 
			return 1;
		}
		if(card == 'Z') 
		{
			debug("该牌为诸葛连弩\n");
			return 1;
		}
	}
	void Save(R int player)
	{
		debug("玩家 %d 开始自救\n", player);
		for(R int i = P[player].Card_Leftest; i <= P[player].tot; i++)
		{
			if(P[player].Card[i] == 'P') 
			{
				P[player].hp++;
				debug("玩家 %d 使用桃 HP=%d\Num_of_Player", player, P[player].hp);
				P[player].Card[i] = 0;
				Maintenance_the_Hand(player);
			}
			if(P[player].hp) return ;
		}
		return ;
	}
	void Majesty_Fold(R int player)
	{
		P[player].Card[ P[player].tot ] = 0;
		P[player].Card_Leftest = P[player].tot + 1;
		P[player].equip = 0;
	}
	void Debug_ShowitCard(R int player)
	{
		//for(R int i = P[player].Card_Leftest; i <= P[player].tot; i++) if(P[player].Card[i] != 0) debug("%c ", P[player].Card[i]);
		debug("\n");
	}
	void Draw_the_Answer(R int player)
	{
		for(R int i = P[player].Card_Leftest; i <= P[player].tot; i++)
			if(P[player].Card[i] != 0) putchar(P[player].Card[i]), putchar(' ');
		putchar('\n');
	}
	void Draw()
	{
		for(R int i = 0; i < Num_of_Player; i++)
			if(P[i].dead) puts("DEAD");
			else Draw_the_Answer(i);
	}
	void A_Player_Die(R int recieve, R int from)
	{
		//printf("player %d die\Num_of_Player", recieve);
		debug("玩家 %d 被 玩家 %d 杀死\n", recieve, from);
		debug("玩家 %d 的身份是 %d\Num_of_Player", recieve, P[recieve].id);
		Now_Player_Right[ Now_Player_left[recieve] ] = Now_Player_Right[recieve];
		Now_Player_left[ Now_Player_Right[recieve] ] = Now_Player_left[recieve];
		P[recieve].dead = 1;
		--All_Player_Still_Lives;
		if(P[recieve].id == 2) Now_Rebel_Lives--;
		if(recieve == 0) 
		{ 
			///*Kry*/puts("主公死亡 反贼胜利"); 
			puts("FP"); Draw(); exit(0); 
		}
		if(!Now_Rebel_Lives) 
		{ 
			///*Kry*/puts("反贼全部死亡 主公胜利"); 
			puts("MP"); Draw(); exit(0); 
		}
		if(P[recieve].id == 1 && from == 0) 
		{ 
			Majesty_Killed_aLoyal = 1;
			///*Kry*/puts("主公杀死忠臣，弃置所有手牌"); 
			Majesty_Fold(from); 
			///*Kry*/puts("主公的手牌为：");
			 Debug_ShowitCard(0);
		} 
		if(P[recieve].id == 2) 
		{ 
			///*Kry*/puts("反贼死亡 伤害来源摸三张牌"); 
			Get_aCard(from), Get_aCard(from), Get_aCard(from); 
		}
	}
	void Got_kill(R int recieve, R int from)
	{	
		debug("玩家 %d 对玩家 %d 使用了一张杀\n", from, recieve);
		for(R int i = P[recieve].Card_Leftest; i <= P[recieve].tot; i++)
			if(P[recieve].Card[i] == 'D') 
			{
				debug("玩家 %d 使用一张闪\n", recieve);
				P[recieve].Card[i] = 0;
				Maintenance_the_Hand(recieve);
				return ;
			}
		debug("玩家 %d HP-1\Num_of_Player", recieve);
		if(!(--P[recieve].hp))
		{
			debug("玩家 %d 进入濒死阶段\n", recieve);
		 	Save(recieve);
			if(!P[recieve].hp) A_Player_Die(recieve, from);
		}
	}
	int Find_kill(R int recieve)
	{
		for(R int i = P[recieve].Card_Leftest; i <= P[recieve].tot; i++)
			if(P[recieve].Card[i] == 'K') 
				return i;
		return 0;
	}
	int Find_dodge(R int recieve)
	{
		for(R int i = P[recieve].Card_Leftest; i <= P[recieve].tot; i++)
			if(P[recieve].Card[i] == 'D') 
				return i;
		return 0;
	}
	bool Court(R int recieve, R int from, R int flag)
	{
		//printf("fr = %d\Num_of_Player", from);
		//for(R int i = 0; i < Num_of_Player; i++) printf("%d ", Now_Player_Right[i]);
		for(R int i = from, t = 1; t <= All_Player_Still_Lives; t++, i = Now_Player_Right[i])
		{
			//printf("now = %d\Num_of_Player", i);
			if(!flag)
			{
				if(P[i].id == 1 && (P[recieve].loyal || recieve == 0))
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].loyal = 1;
							Allegiance = 1;
							P[i].susp = 0;
							P[i].Card[j] = 0;
							debug("玩家 %d 跳忠\n", i);
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的表敌意\n", recieve);
							if(Court(from, i, 1)) return 0;
							else 
							{
								//printf("loyal %d\Num_of_Player", i);
								return 1;
							}
						}
				}
				if(P[i].id == 2 && (P[recieve].rebel))
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].rebel = 1;
							JumpReverse  = 1;
							P[i].susp = 0;
							P[i].Card[j] = 0;
							debug("玩家 %d 跳反\n", i);
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的表敌意\n", recieve);
							if(Court(from, i, 1)) return 0;
							else 
							{
								//printf("rebel %d\Num_of_Player", i);
								return 1;
							}
						}
				}
				if(i == 0 && (P[recieve].loyal || recieve == 0))
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].Card[j] = 0;
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的表敌意\n", recieve);
							if(Court(from, i, 1)) return 0;
							else 
							{
								//printf("master\Num_of_Player");
								return 1;
							}
						}
				}
			}
			else
			{
				if(P[i].id == 1 && (P[from].rebel))
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].loyal = 1;
							Allegiance = 1;
							P[i].susp = 0;
							P[i].Card[j] = 0;
							debug("玩家 %d 跳忠\n", i);
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的献殷勤\n", recieve);
							if(Court(from, i, 0)) return 0;
							else 
							{
								//printf("loyal %d\Num_of_Player", i);
								return 1;
							}
						}
				}
				if(P[i].id == 2 && (P[from].loyal || from == 0))
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].rebel = 1;
							JumpReverse  = 1;
							P[i].susp = 0;
							P[i].Card[j] = 0;
							debug("玩家 %d 跳反\n", i);
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的献殷勤\n", recieve);
							if(Court(from, i, 0)) return 0;
							else 
							{
								//printf("rebel %d\Num_of_Player", i);
								return 1;
							}
						}
				}
				if(i == 0 && P[from].rebel)
				{
					for(R int j = P[i].Card_Leftest; j <= P[i].tot; j++)
						if(P[i].Card[j] == 'J')
						{
							P[i].Card[j] = 0;
							Maintenance_the_Hand(i);
							debug("玩家 %d 对玩家 %d 使用无懈可击\n", i, from);
							debug("用于无懈他对 %d 的献殷勤\n", recieve);
							if(Court(from, i, 0)) return 0;
							else 
							{
								//printf("master\Num_of_Player");
								return 1;
							}
						}
				}
			}
		}
		return 0;
	}
	void Fight(R int recieve, R int from)
	{
		debug("玩家 %d 对玩家 %d 发起决斗\n", from, recieve);
		if(Court(recieve, from, 0)) return ;
		//puts("down");
		if(P[recieve].id == 1 && from == 0)
		{
			debug("玩家 %d HP - 1\Num_of_Player", recieve);
			if(!(--P[recieve].hp))
			{
				debug("玩家 %d 进入濒死阶段\n", recieve);
			 	Save(recieve);
				if(!P[recieve].hp) A_Player_Die(recieve, from);
			}
			//printf("person %d sups\Num_of_Player", P[recieve].susp);
			return ;
		}
		for(R int opt = 0; ; opt ^= 1)
		{
			R int tmp = Find_kill((!opt) ? recieve : from);
			if(!tmp) 
			{
				debug("玩家 %d HP - 1\Num_of_Player", ((!opt) ? recieve : from));
				if(!(--P[((!opt) ? recieve : from)].hp))
				{
					debug("玩家 %d 进入濒死阶段\n", ((!opt) ? recieve : from));
				 	Save((!opt) ? recieve : from);
					if(!P[((!opt) ? recieve : from)].hp) A_Player_Die(((!opt) ? recieve : from), ((!opt) ? from : recieve));
				}
				return ;
			}
			debug("玩家 %d 对玩家 %d 出了一张杀\n", ((!opt) ? recieve : from), ((!opt) ? from : recieve));
			if(((!opt) ? from : recieve) == 0)
			{
				debug("玩家 %d 跳反\n", ((!opt) ? recieve : from));
				P[((!opt) ? recieve : from)].rebel = 1;
				JumpReverse  = 1;
				P[((!opt) ? recieve : from)].susp = 0;
			}
			P[((!opt) ? recieve : from)].Card[tmp] = 0;
			Maintenance_the_Hand((!opt) ? recieve : from);
		}
	}
	void Barbarian_Breakout(R int recieve)
	{
		debug("玩家 %d 发起南蛮入侵\n", recieve);
		for(R int i = Now_Player_Right[recieve]; i != recieve; i = Now_Player_Right[i])
		{
			//puts("Down");
			if(Court(i, recieve, 0)) continue;
			R int tmp = Find_kill(i);
			if(!tmp)
			{
				debug("玩家 %d HP -1\Num_of_Player", i);
				if(!(--P[i].hp))
				{
					debug("玩家 %d 进入濒死阶段\n", i);
					Save(i);
					if(!P[i].hp) A_Player_Die(i, recieve);
				}
				if(i == 0 && !P[recieve].rebel && !P[recieve].loyal) 
				{
					debug("玩家 %d 被认为是类反贼\n", recieve);
					P[recieve].susp = 1; 
				}
				continue ;
			}
			debug("玩家 %d 打出一张杀\n", i);
			P[i].Card[tmp] = 0;
			Maintenance_the_Hand(i);
		}
	}
	void Rain_of_Arrows(R int recieve)
	{
		debug("玩家 %d 发起万箭齐发\n", recieve);
		for(R int i = Now_Player_Right[recieve]; i != recieve; i = Now_Player_Right[i])
		{
			if(Court(i, recieve, 0)) continue;
			R int tmp = Find_dodge(i);
			if(!tmp)
			{
				debug("玩家 %d HP -1\Num_of_Player", i);
				if(!(--P[i].hp))
				{
					debug("玩家 %d 进入濒死阶段\n", i);
					Save(i);
					if(!P[i].hp) A_Player_Die(i, recieve);
				}
				if(i == 0 && !P[recieve].rebel && !P[recieve].loyal) 
				{
					debug("玩家 %d 被认为是类反贼\n", recieve);
				 	P[recieve].susp = 1; 
				}
				continue ;
			}
			debug("玩家 %d 打出一张闪\n", i);
			P[i].Card[tmp] = 0;
			Maintenance_the_Hand(i);
		}
	}
	void Play_aCard(R char recieve)
	{
		if(recieve == 'P') 
		{ 
			debug("玩家 %d 使用桃 HP+1\Num_of_Player", Now_turned_Player);
			P[Now_turned_Player].hp++; 
			return ;
		}
		if(recieve == 'K')
		{
			Kill_used = 1;
			if(Now_turned_Player == 0) 
			{
				if(P[ Now_Player_Right[Now_turned_Player] ].susp || P[ Now_Player_Right[Now_turned_Player] ].rebel) 
					Got_kill(Now_Player_Right[Now_turned_Player], Now_turned_Player);
				return ;
			}
			if(P[Now_turned_Player].id == 1)
			{
				if(P[ Now_Player_Right[Now_turned_Player] ].rebel) 
				{
					debug("玩家 %d 被认为是忠臣\n", Now_turned_Player);
					 P[Now_turned_Player].susp = 0, P[Now_turned_Player].loyal = 1;
					 Allegiance = 1;
					 Got_kill(Now_Player_Right[Now_turned_Player], Now_turned_Player);
					return ;
				}
				return ;
			}
			if(Now_Player_Right[Now_turned_Player] == 0) 
			{
				P[Now_turned_Player].rebel = 1;
				JumpReverse  = 1;
				P[Now_turned_Player].susp = 0;
				debug("玩家 %d 被认为是反贼\n", Now_turned_Player);
				Got_kill(Now_Player_Right[Now_turned_Player], Now_turned_Player);
				return ;
			}
			if(P[ Now_Player_Right[Now_turned_Player] ].loyal) 
			{
				P[Now_turned_Player].rebel = 1;
				JumpReverse  = 1;
				P[Now_turned_Player].susp = 0;
				debug("玩家 %d 被认为是反贼\n", Now_turned_Player);
				Got_kill(Now_Player_Right[Now_turned_Player], Now_turned_Player);
				return ;
			}
		}
		if(recieve == 'F') 
		{
			if(Now_turned_Player == 0)
			{
				R int obj = Find_SusporRebel();
				//printf("tmp = %d\Num_of_Player", obj);
				Fight(obj, Now_turned_Player);
				return ;
			}
			if(P[Now_turned_Player].id == 1)
			{
				R int obj = Find_Rebel(Now_turned_Player);
				P[Now_turned_Player].loyal = 1;
				Allegiance = 1;
				P[Now_turned_Player].susp = 0;
				debug("玩家 %d 被认为是忠臣\n", Now_turned_Player);
				Fight(obj, Now_turned_Player);
				return ;
			}
			P[Now_turned_Player].rebel = 1;
			JumpReverse  = 1;
			P[Now_turned_Player].susp = 0;
			debug("玩家 %d 被认为是反贼\n", Now_turned_Player);
			Fight(0, Now_turned_Player);
			return ;
		}
		if(recieve == 'Z') {  P[Now_turned_Player].equip = 1; return ; }
		if(recieve == 'N') Barbarian_Breakout(Now_turned_Player);
		if(recieve == 'W') Rain_of_Arrows(Now_turned_Player);
	}
	int Main()
	{
		freopen("1.in", "r", stdin);
		//freopen("1.out", "w", stdout);
		All_Player_Still_Lives = Num_of_Player = read(), m = read();
		for(R int i = 0; i < Num_of_Player; i++)
		{
			scanf("%s", str);
			if(str[0] == 'Z') P[i].id = 1;
			else if(str[0] == 'F') P[i].id = 2, Now_Rebel_Lives++;
			P[i].hp = 4;
			P[i].Card_Leftest = 1;
			for(R int j = 0; j < 4; j++)
				scanf("%s", str), P[i].Card[++P[i].tot] = str[0];
		}
		for(R int i = 0; i < Num_of_Player; i++) Now_Player_left[i] = i - 1, Now_Player_Right[i] = i + 1;
		Now_Player_left[0] = Num_of_Player - 1, Now_Player_Right[Num_of_Player - 1] = 0;
		for(R int i = 1; i <= m; i++)
			scanf("%s", str), Card_Pool[i] = str[0];
		//for(R int i = 0; i < Num_of_Player; i++) printf("r = %d ", Now_Player_Right[i]);cout<<endl;
		for(R int t = 1; ; t++, Now_turned_Player = Now_Player_Right[Now_turned_Player])
		{
			//printf("time = %d\Num_of_Player", t);
			//printf("Now_turned_Player = %d\Num_of_Player", Now_turned_Player);
			debug("--------------------\nROUND %d\Num_of_Player--------------------\n", t);
			debug("现在是 %d 的回合，他的身份是 %d。\n", Now_turned_Player, P[Now_turned_Player].id);
			debug("本轮开始前，所有人的手牌为：\n");
			//for(R int i = 0; i < Num_of_Player; i++) if(P[i].dead) debug("DEAD\Num_of_Player"); else Debug_ShowitCard(i); 
			Majesty_Killed_aLoyal = 0;
			Allegiance = 0;
			JumpReverse  = 0;
			Kill_used = 0;
			Getcard_before_Round(Now_turned_Player);
			Maintenance_the_Hand(Now_turned_Player);
			debug("摸牌后他的手牌是：");
			Debug_ShowitCard(Now_turned_Player);
			///*Kry*/for(R int i = P[Now_turned_Player].Card_Leftest; i <= P[Now_turned_Player].tot; i++) if(P[Now_turned_Player].Card[i]) putchar(P[Now_turned_Player].Card[i]), putchar(' ');
			///*Kry*/putchar('\n'); 
			//for(R int i = P[Now_turned_Player].Card_Leftest; i <= P[Now_turned_Player].tot; i++) if(P[Now_turned_Player].Card[i]) printf("%c ", P[Now_turned_Player].Card[i]); cout<<endl;
			//printf("l = %d r = %d\Num_of_Player", P[Now_turned_Player].Card_Leftest, P[Now_turned_Player].tot);
			for(R int i = P[Now_turned_Player].Card_Leftest; i <= P[Now_turned_Player].tot; i++)
			{
				if(Majesty_Killed_aLoyal) break;
				if(P[Now_turned_Player].dead) break;
				//printf("nowat %c\Num_of_Player", P[Now_turned_Player].Card[i]);
				///puts("hp:");
				//for(R int i = 0; i < Num_of_Player; i++) printf("%d ", P[i].hp); cout<<endl;
				if(aCard_Canornot_Play(P[Now_turned_Player].Card[i])) 
				{
					//printf("i = %d\Num_of_Player", i);
					//printf("nowcard = %c\Num_of_Player", P[Now_turned_Player].Card[i]);
					R char nowcard = P[Now_turned_Player].Card[i];
					P[Now_turned_Player].Card[i] = 0;
					Maintenance_the_Hand(Now_turned_Player);
					Play_aCard(nowcard);
					//puts("down");
					if(nowcard == 'Z') 
					{
						i = P[Now_turned_Player].Card_Leftest - 1;
						debug("装备连弩，重新搜索是否有杀\n"); 
						//printf("Card_Leftest = %d\Num_of_Player", P[Now_turned_Player].Card_Leftest);
					}
				}
				else if(P[Now_turned_Player].Card[i]) debug("该牌不可出\n"); 
					//puts("down");
				if(P[Now_turned_Player].id == 1 && JumpReverse ) JumpReverse  = 0, i = P[Now_turned_Player].Card_Leftest - 1;
				if(P[Now_turned_Player].id == 2 && Allegiance) Allegiance = 0, i = P[Now_turned_Player].Card_Leftest - 1;
				
			}
			debug("本轮结束前，所有人的手牌为：\n");
			//for(R int i = 0; i < Num_of_Player; i++) if(P[i].dead) debug("DEAD\Num_of_Player"); else Debug_ShowitCard(i); 
			//debug("回合结束剩余手牌为：");
			/*Kry*/for(R int i = P[Now_turned_Player].Card_Leftest; i <= P[Now_turned_Player].tot; i++) if(P[Now_turned_Player].Card[i]) putchar(P[Now_turned_Player].Card[i]), putchar(' ');
			/*Kry*/putchar('\n'); 
			debug("\n"); 
			//printf("l = %d r = %d\Num_of_Player", P[Now_turned_Player].Card_Leftest, P[Now_turned_Player].tot);
			//for(R int i = 0; i < Num_of_Player; i++) printf("%d ", P[i].susp); cout<<endl;
		}
		return 0;
	}
}
int main()
{
	return Dntcry :: Main();
}
DntcryBecthlev
关注
专栏目录
[SDOI2010]猪国杀题解
hht的博客
09-16 1393
文章目录题目链接：sol游戏结束、一些数组/变量每个猪的结构体：献殷勤、表敌意、跳忠、跳反伤害、死亡无懈可击主要操作完整代码AC代码观战模式 题目链接： 洛谷P2482 loj2885 bzoj1972 推荐去loj看题，可以下数据因为特别容易出错。 sol 其实这题码量也没那大，格式化后我的代码只有141行，在loj目前最短。最好多些一些函数，给每个猪开一个结构体。 游戏结束、一些数组/变量 之...
P2482 [SDOI2010]猪国杀 【题解】
魃魈魁鬾魑魅魍魉的博客
04-08 854
题目简述： 这是一道非常善良的凉心模拟题。。。 <身份>： 主猪（主公）：MP 忠猪（忠臣）：ZP 反猪（反贼）：FP <基本牌>： 杀：K 闪：D 桃：P <锦囊牌>： 万箭齐发：W 南猪入侵：N 无懈可击：J 决斗：F <装备牌>： 猪哥连弩：Z <概念> 伤害来源： 杀、南猪入侵、决斗、万箭齐发的伤害来源均是使用该牌的猪 距离： ...
模拟 [Sdoi2010]猪国杀
蒟蒻QTY
10-09 793
题目的可读版本有那么几个地方需要注意： 1.使用一个锦囊后，先判无懈可击。 2.如果一个猪出完一个牌后，要从头开始看哪个能出（有可能一次出牌后某只猪跳忠或者跳反了，F，K什么的就可以用了。） 3.游戏结束时，没抓的牌就不用抓了。 4.循环无懈可击 5.行末没空格昨天打的时候，有个没玩过三国杀的dalao问我能不能无懈杀。。。。 其实这种题完全没有思维含量，只要打之前把所有细节构思好，之后
SDOI2010 猪国杀
YangHao5的博客
04-04 3594
题目描述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（FP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。 开始游戏时，从主猪开始，按照...
【模拟】【bzoj1972】【SDOI2010】猪国杀
Unlimited的博客
05-18 425
1972:[SDOI2010]猪国杀 【题目描述】 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（AP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，...
【BZOJ1972】[SDOI2010] 猪国杀（恶心的大模拟）
CXR的博客
10-23 467
点此看题面 大致题意： 让你模拟一个游戏猪国杀的过程。 极大坑点 对于这种模拟题，具体思路就不讲了，就说说有哪些坑点。 题面有锅，反猪是FPFPFP。 数据有锅，牌堆中的牌可能不够用，牌堆为空之后需一直抽最后一张牌。 主猪杀死忠猪后猪哥连弩也要清除。 无懈可击也可以用无懈可击抵消。 使用决斗的猪可能死亡。 无懈可击是从使用锦囊牌的猪开始轮流选择是否响应。 使用完一张牌...
[SDOI2010]猪国杀 解题报告
TA
02-25 2457
这道题作为一道省选题，质量真是差到了极点！！强烈建议千万不要去做！ 首先，这题意与数据不合，而样例怎么看都是错的，反猪明明有6张无懈！ 题意与数据之龃龉： ①题目中n ②题目中明确指出不会出现牌不够用的情况，而实际上你需要不断地抽最后一张牌。 ③题目中说杀可以杀距离自己距离为1的猪，而数据中杀只能杀下家。 也就是说，如果你按照题目要求写的话，你的最终得分将是：35分。。。
1972: [Sdoi2010]猪国杀
limboman的博客
06-21 962
来道大模拟 oi生涯中写过最长代码 #include<cstdio> #include<cstring> #include<cstdlib> #include<cmath> #include<vector> #include<algorithm> #include<deque> #include<queue> #define rep(i,k,n) for(int i=k;i<=(n);i++) #
[SDOI2010]星际竞速
weixin_30830327的博客
03-26 103
题目描述 10年一度的银河系赛车大赛又要开始了。作为全银河最盛大的活动之一，夺得这个项目的冠军无疑是很多人的梦想，来自杰森座α星的悠悠也是其中之一。 赛车大赛的赛场由N颗行星和M条双向星际航路构成，其中每颗行星都有一个不同的引力值。大赛要求车手们从一颗与这N颗行星之间没有任何航路的天体出发，访问这N颗行星每颗恰好一次，首先完成这一目标的人获得胜利。 由于赛制非常开放，很多人驾驶着千奇百怪的自...
BZOJ1972: [Sdoi2010]猪国杀
commonc的博客
03-16 3464
题目大意：出题人给你指定了一种全新形式的自动三国杀规则，你来模拟这个过程（BZOJ题面不全，可以参考这个网站，题面很不错） 真的是一道清新可人的题呢！ //做题过程 从昨天下午4点开始写的，认认真真的写到了6点，然后去看球了... 看球的时候也写了一点点，到晚上8点一共写了6KB左右的样子 今天上午考完试之后就一直在写，大约在三点左右第一次点了编译，当时大约400行，8KB左右吧
bzoj1972: [Sdoi2010]猪国杀
liangjs的专栏
06-02 2372
#include #include #include #include #include using namespace std; #define MAXM 2001 #define Tao ('P') #define Sha ('K') #define Shan ('D') #define JueDou ('F') #define NanZhu ('N')
[SDOI2010]大陆争霸
dilei7762的博客
11-02 113
Description 在一个遥远的世界里有两个国家：位于大陆西端的杰森国和位于大陆东端的克里斯国。两个国家的人民分别信仰两个对立的神：杰森国信仰象征黑暗和毁灭 的神曾·布拉泽，而克里斯国信仰象征光明和永恒的神斯普林·布拉泽。 幻想历8012年1月，杰森国正式宣布曾·布拉泽是他们唯一信仰的神，同 时开始迫害在杰森国的信仰斯普林·布拉泽的...
Luogu P2482 [SDOI2010]猪国杀
macesuted的博客
01-22 765
Pig Country Kill 很古怪的翻译，不过它确实叫猪(Pig)国(Country)杀(Kill)。 我们来好好整理一下这道题目。题面虽较长，但内容基本清晰，只是有部分很Pig的操作部分，很容易让第一次看见这道题目的人百思不得其解。 先整理一下这道长长的题面。 First：人物 四位玩家，初始四张手牌，血量上限444，初始血量444，会告诉你整个牌堆的牌，每位玩家每个回合从牌堆顶部抽走两...
猪国杀
PUBG___的博客
01-16 1028
#include&lt;bits/stdc++.h&gt; using namespace std; const bool diff[3][3]={{0,0,1},{0,0,1},{1,1,0}}; const int M=2005; int n,m,fanzhu,deadfan,rounds,tmp[M],used[M]; char ch,cu; struct PIGS {int iden,bl...
洛谷精选：树形数据结构实战题目及模板
8. **SDOI2009**（HH的项链）： 一道经典的算法竞赛题目，涉及链表操作或其他数据结构，可以用来检验对复杂问题的理解和解决能力。 这份资料为学习者提供了一个全面且深入的树形数据结构学习路径，通过解决这些...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值