[SDOI2010]猪国杀

DntcryBecthlev DntcryBecthlev 博客等级 墨衍会员 · AI 创作全网分发 墨衍智能分发 本文由作者通过墨衍一键同步至各平台 1分发平台 600+累计阅读 629平均单平台 已同步平台 优快云 微信公众号 微博 知乎 掘金 百家号 博客园 抖音 小红书 你的文章也可以这样分发 墨衍会员 ¥399起/年，写一次发全网 我也要 码龄9年
关注
原创 最新推荐文章于 2026-03-10 00:02:35 发布 629 阅读 AI 写同款· GEO 优化 ›
SDOI知识点大复习 马上就要考一轮了，也该复习一下模板了，把以前的题整理一下，再做一些经典题吧。 阅读详情

好久没写博客了，就放个毒瘤的东西吧。
这题就是纯暴力的模拟。
特判一下献殷勤和表敌意。
注意无懈可以要分是对 “谁对谁献殷勤” 使用，还是 “谁对谁表敌意” 使用的。
注意只能杀下家（这是三国杀？）
其他的打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();
}
收录于
模拟

当前文章被收录于：

模拟
1 篇文章 0 人学习
订阅专栏 查看详情
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
[SDOI2010]猪国杀 解题报告 这道题作为一道省选题，质量真是差到了极点！！强烈建议千万不要去做！ 首先，这题意与数据不合，而样例怎么看都是错的，反猪明明有6张无懈！ 题意与数据之龃龉： ①题目中n ②题目中明确指出不会出现牌不够用的情况，而实际上你需要不断地抽最后一张牌。 ③题目中说杀可以杀距离自己距离为1的猪，而数据中杀只能杀下家。 也就是说，如果你按照题目要求写的话，你的最终得分将是：35分。。。 阅读详情

相关推荐

【模拟】【bzoj1972】【SDOI2010】猪国杀

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

Unlimited的博客 609

SDOI2010 猪国杀

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

YangHao5的博客 3808

P2482 [SDOI2010]猪国杀 【题解】

题目简述： 这是一道非常善良的凉心模拟题。。。 <身份>： 主猪（主公）：MP 忠猪（忠臣）：ZP 反猪（反贼）：FP <基本牌>： 杀：K 闪：D 桃：P <锦囊牌>： 万箭齐发：W 南猪入侵：N 无懈可击：J 决斗：F <装备牌>： 猪哥连弩：Z <概念> 伤害来源： 杀、南猪入侵、决斗、万箭齐发的伤害来源均是使用该牌的猪 距离： ...

魃魈魁鬾魑魅魍魉的博客 1103

BestCoder Round #59 (div.2) 1001 SDOI 模拟题

问题描述 一年一度的全国信息学奥林匹克竞赛（NOI）即将举办，SD省组织进行了一次省队选拔，一共有 n (n \leq 100)n(n≤100)名选手参加了这次省队选拔。 今年，SD省的省队名额为 m (m \leq 50)m(m≤50) 人，即，今年的SD省队有 mm 名队员。 按照惯例，SD省的省队选拔有两轮比赛，依次为“Round1”和“Round2”，每个Round的满分为 30030

AC_Gibson的专栏 672

STM32之W5500网络通信_w5500 profinet

*初始化8个socket*/setSHAR(ConfigMsg.mac);/*配置Mac地址*/setSUBR(ConfigMsg.sub);/*配置子网掩码*/setSIPR(ConfigMsg.lip);/*配置Ip地址*/setGAR(ConfigMsg.gw);/*配置默认网关*/setRTR(2000);/*设置溢出时间值*/setRCR(3);/*设置最大重新发送次数*/

2501_90250923的博客 1461

从星形到三角形：永磁同步电机FOC+SVPWM控制的相位偏移与扇区重构

本文深入探讨了将FOC+SVPWM控制方案从星形接法永磁同步电机移植到三角形接法时遇到的核心挑战。文章重点解析了由绕组连接方式差异导致的30度相位偏移问题，并详细阐述了如何为此重构扇区判断逻辑、矢量作用时间计算以及电流采样变换，为工程师提供了从理论到实践的完整移植指南。

ujm5678901的博客 544

[SDOI2010] 猪国杀

花了一周的时间终于写完了这个大魔拟。。。

wuzihenb的博客 2165

立创开源TinyAWG：基于ZYNQ7010的35MHz带宽200MSa/s任意波形发生器设计与实现

本文详细解析了立创开源TinyAWG的设计与实现，这是一款基于ZYNQ7010芯片的低成本高性能任意波形发生器。项目实现了35MHz带宽和200MSa/s采样率，核心采用ARM+FPGA协同架构，FPGA负责高速DDS信号生成，ARM运行Linux并搭载LVGL图形界面。文章涵盖了硬件选型、电路设计、软件逻辑及性能测试，为复刻和学习ZYNQ系统设计、高速DAC应用提供了完整参考。

weixin_42576467的博客 435

SDOI2010 魔法猪学院

题目描述 题解： 明显的$k$短路问题，这里提供两种方法。 1.$A$*算法 $A$*可以解决一般的$k$短路问题，但是并不如可持久化可并堆优秀。 $A$*的本质是$f+g$，而估价函数可以用终止节点到终点的最短路表示。 所以先反向建图$dij$，然后小根堆跑$A$*即可。 优化一下，总代价/起点终点最短路就是每个点经过的最大次数。 代码： #include&l...

a6t2007的博客 242

3D Slicer中Auto3DSeg和TotalSegmentator等自动分割插件总是安装失败，怎么办？教你两招

TotalSegmentator, MONAI auto3Dseg,这些工具因分割器官多，准确性高，备受关注。同时，这些自动分割工具被集成在了3D slicer平台，非常方便临床医生做手术规划。详细了解这些工具看之前的教程👇-------- 简单概述 --------其中，MONAIAuto3DSeg扩展附带数十种针对特定临床用例的预训练分割模型，这些模型旨在快速运行，几分钟内即可在任何普通计算机上运行，无需 GPU，甚至在笔记本电脑上。

zzjlhlcd的博客 1698

浅谈一下小波变换和EEG信号处理

浅谈小波变换，总结不是很到位，请大家指正。

qq_45045249的博客 2862

[SDOI2010]猪国杀题解

文章目录题目链接：sol游戏结束、一些数组/变量每个猪的结构体：献殷勤、表敌意、跳忠、跳反伤害、死亡无懈可击主要操作完整代码AC代码观战模式 题目链接： 洛谷P2482 loj2885 bzoj1972 推荐去loj看题，可以下数据因为特别容易出错。 sol 其实这题码量也没那大，格式化后我的代码只有141行，在loj目前最短。最好多些一些函数，给每个猪开一个结构体。 游戏结束、一些数组/变量 之...

hht的博客 1621

PCIe-Orders set Blocks之symbol对齐

有序集的使用场合很多，如在链路link阶段，进入polling后，便开始有序集的发送。一个 Ordered Set Block 包含一个同步头，后跟一个有序集。多通道链路的所有 Lane 必须同时传输相同的有序集，而且有序集的第一个符号定义了有序集的类型。但在PCIE中，8GT/s及以上的速率，采用的是128b/130b编码。128-bit是想要传输的payload，实际会传输130-bit，多出来的2-bit就是sync header。Block有两种，通过Sync header区分：10b：表示data

weixin_44700185的博客 813

[luogu p2482] [SDOI2010]猪国杀

传送门 [SDOI2010]猪国杀 题目描述 游戏背景 《猪国杀》是一种多猪牌类回合制游戏，一共有 \(3\) 种角色：主猪，忠猪，反猪。每局游戏主猪有且只有 \(1\) 只，忠猪和反猪可以有多只，每只猪扮演 $1 $ 种角色。 游戏目的 主猪 / \(\texttt{MP}\)：自己存活的情况下消灭所有的反猪。 忠猪 / \(\texttt{ZP}\)：不惜一切保护主猪，胜利条件与主猪...

crab_xbc的博客 235

Android 13.0 设置默认屏幕亮度百分比

在13.0的系统ROM产品开发中，在一些产品开发中，对于设置默认屏幕亮度和屏幕亮度百分比的功能，在开发中也是常见的功能，在10.0的平台设置可能有一些不同，一般的都是在SettingProvider中设置就可以了 在11.0以后的系统中设置默认屏幕亮度的方法就不同了，接下来具体分析功能的实现

安卓兼职framework和app工程师的博客 1560

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件，这是C++版本的破解文件

洛谷P2482 [SDOI2010]猪国杀 题解

开学快乐，整点活儿

eliyou的博客 2773

jre9下载 jdk9

(Java SE Runtime Environment 9.0) 9.0u175 官方最新版 【x86|x64】

Luogu P2482 [SDOI2010]猪国杀

Pig Country Kill 很古怪的翻译，不过它确实叫猪(Pig)国(Country)杀(Kill)。 我们来好好整理一下这道题目。题面虽较长，但内容基本清晰，只是有部分很Pig的操作部分，很容易让第一次看见这道题目的人百思不得其解。 先整理一下这道长长的题面。 First：人物 四位玩家，初始四张手牌，血量上限444，初始血量444，会告诉你整个牌堆的牌，每位玩家每个回合从牌堆顶部抽走两...

macesuted的博客 1364

计算机控制技术及应用

《计算机控制技术及应用》通过总结作者的科研成果和吸收国内外的先进理论、方法和技术，以计算机控制系统的网络化、开放化、智能化和集成化发展趋势为主线索，主要介绍计算机控制系统的基本概念和计算机控制系统的典型形式，计算机控制系统的数学描述与基本分析方法，以及数字PID控制器、最少拍控制系统、达林算法、状态变量设计法等设计方法及其各种改进算法。重点突出计算机控制系统输入输出通道接口的设计方法和典型控制系统的设计案例与实现方法等。

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章，有部分习题没有答案，全英文复分析阿尔福斯(Ahlfors) 第三版答案

[luogu P2482] [SDOI2010]猪国杀

[luogu P2482] [SDOI2010]猪国杀 题目描述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（AP）：杀死主猪。 游戏过程： 游戏开始时候，每...

a8233821的博客 351

Luogu2482 [SDOI2010]猪国杀 ---- 模拟

Luogu2482 [SDOI2010]猪国杀 题意 ...... https://www.luogu.org/problemnew/show/P2482 总结 首先说一下代码的构思： 首先确定了所有的状态表示（例如游戏中游戏结束，不管有没有用），然后确定了所有属性什么的。 然后构思结构体的表达，并且从全局代码考虑需不需要这样设计（因为这个重构了一次，一开始写的结构体内的表示方法代码...

weixin_30569153的博客 242

BZOJ1972：[SDOI2010]猪国杀

我对模拟的理解：https://www.cnblogs.com/AKMer/p/9064018.html 题目传送门：https://www.lydsy.com/JudgeOnline/problem.php?id=1972 一个好看的题面传送门：https://mubu.com/doc/2707815814591da4 因为这两个月比较忙（其实是颓得太多了……），所以猪国杀昨晚\(0\...

aga28832的博客 156

[BZOJ1972][Sdoi2010]猪国杀（大模拟）

吐槽这题真的写了一天啊… 虽然我码力太弱是主要因素，但是题面确实是挺难懂的！ 所以自己将题面和数据范围做了改进，避免了一些不必要的坑点，最后又加入了一些自己写的时候发现的奇奇怪怪的问题，应该会比原题面清楚些，欢迎大家来读…题目描述《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的 主猪（MP）：自己

zyf2000 1271
上一篇： NOIP2018 F游S记T
下一篇： [FJOI2018D1T3]城市路径问题
点赞 1
评论 0
书签 书签 0
DntcryBecthlev
DntcryBecthlev
博客等级 码龄9年 2粉丝 12原创
+ 关注 专栏目录 订阅专栏
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值