[SDOI2010] 猪国杀

于 2024-08-27 12:09:55 发布
阅读量314 收藏 6
点赞数 12
分类专栏： 算法 文章标签： 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/wuzihenb/article/details/141575639
版权

猪国杀

前言

这道题是一道大模拟，个人认为还是挺锻炼码力的，所以本蒟蒻花一天的时间，爆肝一周的时间终于写完了。。。

题意

题目传送门

游戏目的

主猪 / MP \texttt{MP} MP：自己存活的情况下消灭所有的反猪。
忠猪 / ZP \texttt{ZP} ZP：不惜一切保护主猪，胜利条件与主猪相同。
反猪 / FP \texttt{FP} FP：杀死主猪。

游戏过程

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

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

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

  • 摸牌阶段：从牌堆顶部摸 2 2 2 张牌，依次放到手牌的最右边；
  • 出牌阶段：你可以使用任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。当然，要满足如下规则：
    1. 如果没有猪哥连弩，每个出牌阶段只能使用 1 1 1 次「杀」来攻击；
    2. 任何牌被使用后被弃置（武器是装备上）；被弃置的牌以后都不能再用，即与游戏无关。

牌的种类

基本牌

  • 『桃 / P \texttt{P} P』在自己的回合内，如果自己的体力值不等于体力上限，那么使用 1 1 1 个桃可以为自己补充 1 1 1 点体力，否则不能使用桃；桃只能对自己使用；在自己的回合外，如果自己的血变为 0 0 0 或者更低，那么也可以使用。

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

  • 『闪 / D \texttt{D} D』当你受到杀的攻击时，可以弃置 1 1 1 张闪来抵消杀的效果。

锦囊牌

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

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

  • 『万箭齐发 / W \texttt{W} W』和南猪入侵类似，不过要弃置的不是杀而是闪。

  • 『无懈可击 / J \texttt{J} J』在目标锦囊生效前抵消其效果。每次有 1 1 1 张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会；效果：用于决斗时，决斗无效并弃置；用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对 1 1 1 个角色产生效果）；用于无懈可击时，成为目标的无懈可击被无效。

装备牌
  • 『猪哥连弩 / Z \texttt{Z} Z』武器，攻击范围 1 1 1 ，出牌阶段你可以使用任意张杀; 同一时刻最多只能装 1 1 1 把武器；如果先前已经有了 1 1 1 把武器，那么之后再装武器的话，会弃置以前的武器来装现在的武器。

特殊事件及概念解释

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

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

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

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

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

现在，我们已经知道每只猪的角色、手牌，还有牌堆初始情况，并且假设每个角色会按照如下的行为准则进行游戏，你需要做的就是告诉小猪 iPig 最后的结果。

几种行为

  • 献殷勤：使用无懈可击挡下南猪入侵、万箭齐发、决斗；使用无懈可击抵消表敌意；
  • 表敌意：对某个角色使用杀、决斗；使用无懈可击抵消献殷勤；
  • 跳忠：即通过行动表示自己是忠猪。跳忠行动就是对主猪或对某只已经跳忠的猪献殷勤，或者对某只已经跳反的猪表敌意；
  • 跳反：即通过行动表示自己是反猪。跳反行动就是对主猪或对某只已经跳忠的猪表敌意，或者对某只已经跳反的猪献殷勤。

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

行动准则

共性
  • 每个角色如果手里有桃且生命值未满，那么必然吃掉；
  • 有南猪入侵、万箭齐发、必然使用；有装备必然装上；
  • 受到杀时，有闪必然弃置；
  • 响应南猪入侵或者万箭齐发时候，有杀 / 闪必然弃置；
  • 不会对未表明身份的猪献殷勤（包括自己）。
特性
  • 主猪：
    • 主猪会认为「没有跳身份，且用南猪入侵 / 万箭齐发对自己造成伤害的猪」是类反猪（没伤害到不算，注意类反猪并没有表明身份），如果之后跳了，那么主猪会重新认识这只猪；
    • 对于每种表敌意的方式，对逆时针方向能够执行到的第一只类反猪或者已跳反猪表；如果没有，那么就不表敌意；
    • 决斗时会不遗余力弃置杀；
    • 如果能对已经跳忠的猪或自己献殷勤，那么一定献；如果能够对已经跳反的猪表敌意，那么一定表。
  • 忠猪：
    • 对于每种表敌意的方式，对「逆时针方向能够执行到的第一只已经跳反的猪」表，如果没有，那么就不表敌意；
    • 决斗时，如果对方是主猪，那么不会弃置杀，否则，会不遗余力弃置杀；
    • 如果有机会对主猪或者已经跳忠的猪献殷勤，那么一定献。
  • 反猪：
    • 对于每种表敌意的方式，如果有机会则对主猪表，否则，对「逆时针方向能够执行到的第一只已经跳忠的猪」表，如果没有，那么就不表敌意；
    • 决斗时会不遗余力弃置杀；
    • 如果有机会对已经跳反的猪献殷勤，那么一定献。

做法

本蒟蒻刚刚看到题一脸懵逼，主要是卡在了无懈可击的生效前的意思，举个例子， A A A 使出了『南猪入侵』，逆时针结算到 B B B 时，若 A A A 与 B B B 不是相同的组别，与 A A A 一队的猪就会努力使锦囊生效，与 B B B 为一个组别的猪就会想法设法的使锦囊失效。

其中这题的部分分为：

  • 10 10 10 分：没有锦囊牌。
  • 30 30 30 分：没有无懈可击。
  • 100 100 100 分： n ≤ 10 n \le10 n≤10， m ≤ 1000 m \le 1000 m≤1000。

10 10 10 分，没有锦囊牌

辅助数组

一下只列举出比较重要的几个函数。

  1. string pig[i]：表示第 i i i 只猪的身份。
  2. char c[i][j]：表示第 i i i 只猪的第 j j j 张卡牌是多少。
  3. int bld[i]：blood 的缩写，意思为第 i i i 只猪的血量。
  4. int tot[i]：表示第 i i i 只猪的总卡牌数量（被用掉的也算），主要是为了实现一些卡牌删除与加入。
  5. int lpig[i]：表示第 i i i 只猪的左边一只猪是几号，其中 1 1 1 的左边是 n n n。
  6. int rpig[i]：表示第 i i i 只猪的右边一只猪是几号，其中 n n n 的右边是 1 1 1。

其中 lpig[i] 与 rpig[i] 为类似双链表的东西。

  1. bool tfpig[i]：表示第 i i i 只猪是否为类反猪。
  2. bool iden[i]：表示第 i i i 只猪是否跳身份。
  3. bool flag[i][j]：表示第 i i i 只猪的第 j j j 张卡牌是否被用。
辅助函数
  1. count(x, t)：表示第 i i i 只猪的卡牌中有几张为 t t t 的卡牌。
int count(int x, char t) { 
	int res = 0;
	for (int i = 1; i <= tot[x]; i++)
		if (!flag[x][i] && c[x][i] == t)
			res++;
	return res;
}
  1. del(x, k, t)：从c[x]中删除k个字符t。
void del(int x, int k, char t) { 
	if (k <= 0) return;
	int cnt = 0;
	for (int i = 1; i <= tot[x] && cnt < k; i++)
		if (!flag[x][i] && c[x][i] == t)
			flag[x][i] = true, cnt++;
}
  1. peach(i)：在自己的回合回血。
void peach(int x) {
	if (bld[x] < 4) { bld[x]++; del(x, 1, 'P'); }
}
  1. bld_back(i)：在别人的回合内回血。
bool bld_back(int x) {
	if (bld[x] > 0) return false;
	bool ok = false; // 是否阵亡
	int P = count(x, 'P');
	if (abs(bld[x]) + 1 <= P) { del(x, abs(bld[x]) + 1, 'P'); bld[x] = 1; }
	else { ok = true; thrw(x); }
	return ok;
}

要注意 peach 和 bld_back 这两个函数的区别：peach 是最多只能回到 4 4 4，而 bld_back 是当前这头猪在血量小于等于 0 0 0 时，用桃将其血量回到 1 1 1。
5. Dead(x, y)：表示 x x x 将 y y y 弄（可能是南猪入侵、万箭齐发、决斗或者杀）死后的处理：

  • p i g [ y ] pig[y] pig[y] 为主猪，直接输出
  • p i g [ y ] pig[y] pig[y] 为反猪，若反猪数量为 0 0 0，直接输出，否则 x x x 加 3 3 3 张牌。
  • p i g [ x ] pig[x] pig[x] 为主猪，则将主猪的所有牌弃置。
void Dead(int x, int y) {
	dead[y] = true;
	rpig[lpig[y]] = rpig[y];
	lpig[rpig[y]] = lpig[y];
	if (x == y) return;
	if (pig[y] == "MP") { Print(); exit(0); }
	else if (pig[y] == "FP") {
		if (--fpig == 0) { Print(); exit(0); }
		In(x, 3);
	} else if (pig[x] == "MP") thrw(x);
}

其中 In(i, 3) 表示 i i i 加入两张牌，thrw(i)：表示将 i i i 的所有牌弃置（包括装备牌）。

将以上的代码组成一个程序即可，这里就不在做详细的解释了，但是为了代码简洁清晰，强烈推荐使用switch case。

代码
#include <iostream>
#include <algorithm>
using namespace std;
int n, m, bld[15], fpig, idx = 0, tot[15], rpig[15], lpig[15];
char c[15][10010], card[10010];
bool tfpig[15], arm[15], flag[15][10010], iden[15], dead[15];
string pig[15];
// c[i][j]：表示第i只猪的第j张牌为c[i][j]。
// tot[i]：表示第i只猪有多少张牌。
// pig[i]：表示第i只猪的角色。
// bld[i]：表示第i只猪的血量值。
// fpig：表示活的反猪的数量。
// tfpig[i]：表示第i只猪是否为类反猪。
// arm[i]：表示第i只猪是否有装备。
// flag[i][j]：表示第i只猪的第j张牌是否被用过。
// iden[i]：表示第i只猪是否已经跳身份。
void Read() {
	iden[1] = true;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> pig[i];
		bld[i] = 4;
		for (int j = 1; j <= 4; j++) cin >> c[i][++tot[i]];
		if (pig[i] == "FP") fpig++;
		if (i == n) rpig[i] = 1;
		else rpig[i] = i + 1;
		if (i == 1) lpig[i] = n;
		else lpig[i] = i - 1;
	}
	for (int i = 1; i <= m; i++) cin >> card[i];
} // 读入
void Print() {
	if (fpig == 0) cout << "MP" << endl;
	else cout << "FP" << endl;
	for (int i = 1; i <= n; i++)
		if (dead[i]) cout << "DEAD" << endl;
		else {
			int cnt = 0, res = 0;
			for (int j = 1; j <= tot[i]; j++) if (!flag[i][j]) cnt++;
			for (int j = 1; j <= tot[i]; j++)
				if (!flag[i][j] && res != cnt - 1) cout << c[i][j] << " ";
				else if (!flag[i][j] && res == cnt - 1) cout << c[i][j];
			if (!cnt) cout << " ";
			cout << endl;
		}
}
void thrw(int x) {
	for (int i = 1; i <= tot[x]; i++) flag[x][i] = true;
	arm[x] = false;
} // 将第i只猪的手牌和装备弃置
void In(int x, int k) { 
	for (int i = idx + 1; i <= idx + k; i++) c[x][++tot[x]] = card[min(m, i)];
	idx += k;
}// 摸k张牌
int count(int x, char t) { 
	int res = 0;
	for (int i = 1; i <= tot[x]; i++)
		if (!flag[x][i] && c[x][i] == t)
			res++;
	return res;
}// 统计第i只猪有几张t这张牌
void del(int x, int k, char t) { 
	if (k <= 0) return;
	int cnt = 0;
	for (int i = 1; i <= tot[x] && cnt < k; i++)
		if (!flag[x][i] && c[x][i] == t)
			flag[x][i] = true, cnt++;
}// 从c[x]中删除k个字符t。
void peach(int x) {
	if (bld[x] < 4) { bld[x]++; del(x, 1, 'P'); }
} // 在自己的回合回血
bool bld_back(int x) {
	if (bld[x] > 0) return false;
	bool ok = false; // 是否阵亡
	int P = count(x, 'P');
	if (abs(bld[x]) + 1 <= P) { del(x, abs(bld[x]) + 1, 'P'); bld[x] = 1; }
	else { ok = true; thrw(x); }
	return ok;
} // 在别人的回合回血
void Dead(int x, int y) {
	dead[y] = true;
	rpig[lpig[y]] = rpig[y];
	lpig[rpig[y]] = lpig[y];
	if (x == y) return;
	if (pig[y] == "MP") { Print(); exit(0); }
	else if (pig[y] == "FP") {
		if (--fpig == 0) { Print(); exit(0); }
		In(x, 3);
	} else if (pig[x] == "MP") thrw(x);
} // x杀死了y。
void kill(int i, int pos) {
	iden[i] = true;
	int D = count(pos, 'D'); // 统计闪的数量
	int K = 1;
	if (D >= 1) { K = 0; del(pos, 1, 'D'); }
	del(i, 1, 'K');
	bld[pos] -= K;
	if (bld[pos] <= 0) { bool f = bld_back(pos); if (f) Dead(i, pos); } // 对pos这头猪回血
} // i对pos使用杀

void Arm(int x) { arm[x] = true; del(x, 1, 'Z'); }
int find(string op, int i) {
	int pos = -1;
	if (i == n && op == "FP") pos = 1; // 特判
	for (int j = i + 1; j <= n && pos == -1; j++)
		if (op == "MP" && (pig[j] == "FP" && iden[j] || tfpig[j]) && bld[j] > 0) { pos = j; break; }
		else if (op == "ZP" && pig[j] == "FP" && iden[j] && bld[j] > 0) { pos = j; break; }
		else if (op == "FP" && pig[j] == "ZP" && iden[j] && bld[j] > 0) { pos = j; break; }
	for (int j = 1; j < i && pos == -1; j++)
		if (op == "MP" && (pig[j] == "FP" && iden[j] || tfpig[j]) && bld[j] > 0) { pos = j; break; }
		else if (op == "ZP" && pig[j] == "FP" && iden[j] && bld[j] > 0) { pos = j; break; }
		else if (op == "FP" && pig[j] == "ZP" && iden[j] && bld[j] > 0) { pos = j; break; }
	return pos;
} // 找到对应种类的猪所要找到的杀的对象，没找到返回-1。
bool find_to_kill(string op, int x) {
	bool can = false;
	string nxt = pig[rpig[x]];
	if (op == "MP" && (nxt == "FP" && iden[rpig[x]] || tfpig[rpig[x]])) can = true;
	else if (op == "ZP" && nxt != "MP" && iden[rpig[x]] && pig[rpig[x]] == "FP") can = true;
	else if (op == "FP" && nxt != "FP" && (rpig[x] == 1 || iden[rpig[x]] && pig[rpig[x]] == "ZP")) can = true;
	return can;
}
void play(int x) { // 模拟
	In(x, 2);
	bool ok = false, use_K = false;
	for (int i = 1; i <= tot[x]; i++) {
		if (flag[x][i]) continue;
		char now = c[x][i];
		switch (now) {
			case 'P': peach(x); break;
			case 'K':
				if (find_to_kill(pig[x], x) && (!arm[x] && !use_K || arm[x])) { kill(x, rpig[x]), use_K = true; }
				break;
			case 'Z': Arm(x); break;
		}
		if (dead[x]) break;
	}
}
void work() {
	int i = 0;
	while (fpig && bld[1] > 0) {
		i = i % n + 1;
		if (dead[i]) continue;
		else play(i);
	}
}
int main() {
	Read();
	work();
	Print();
	return 0;
}

30 30 30 分，没有无懈可击

决斗

决斗说白了就是两个人同时弃置一张杀，被决斗者先出，谁先没有杀就扣一滴血。假设 x x x 向 y y y 发起了决斗，分别统计 x x x 的杀的数量以及 y y y 杀的数量，记作 x K xK xK 和 y K yK yK。

  • 若 x K ≥ y K xK \ge yK xK≥yK：则 y y y 扣一滴血。
  • 若 x K < y K xK < yK xK<yK：则 x x x 扣一滴血。
void fight(int x, int y) {
	del(x, 1, 'F');
	iden[x] = true;
	if (pig[x] == "MP" && pig[y] == "ZP" && tfpig[y] && !iden[y]) {
		if (--bld[y] <= 0) { int f = bld_back(y); if (f) Dead(x, y); }
		return;
	}
	int xK = count(x, 'K');
	int yK = count(y, 'K');
	int man, toman;
	if (xK >= yK) { toman = x, man = y, bld[y]--; del(x, yK, 'K'), del(y, yK, 'K'); }
	else { man = x, toman = y, bld[x]--; del(y, xK + 1, 'K'), del(x, xK, 'K'); }
	if (bld[man] <= 0) { int f = bld_back(man); if (f) Dead(toman, man); }
}
南猪入侵

从使用者的下一位开始，依次弃置一张杀，若没有就扣一滴血。按意思模拟即可，但是当结算到第 i i i 头猪要判断下是否死亡。假设枚举到了第 i i i 只猪：

  • 有 K K K：啥事都不用干。
  • 没有 K K K：扣一滴血，若 p i g [ i ] pig[i] pig[i] 为主猪，则使用者将成为类反猪（若已经跳身份的不算）。
// 处理
void Initnanzhu(int j, int x) {
	if (bld[j] <= 0) return ;
	int K = count(j, 'K');
	if (K > 0) del(j, 1, 'K');
	else {
		bool f = true;
		if (--bld[j] <= 0) {
			int P = count(j, 'P');
			if (P == 0) Dead(x, j);
			else bld[j]++, del(j, 1, 'P'), f = false;
		}
		if (j == 1 && f) tfpig[x] = true;
	}
}

// 枚举
void nanzhu(int x) {
	del(x, 1, 'N');
	for (int j = x + 1; j <= n; j++) Initnanzhu(j, x);
	for (int j = 1; j < x; j++) Initnanzhu(j, x);
}
万箭齐发

同理南猪入侵，区别为将杀改成了闪。

// 处理
void Initwanjian(int j, int x) {
	if (dead[j]) return;
	int D = count(j, 'D');
	if (D > 0) del(j, 1, 'D'); 
	else {
		bool f = true;
		if (--bld[j] <= 0) {
			int P = count(j, 'P');
			if (P == 0) Dead(x, j);
			else bld[j]++, del(j, 1, 'P'), f = false;
		}
		if (j == 1 && f) tfpig[x] = true;
	}
}

// 枚举
void wanjian(int x) {
	del(x, 1, 'W');
	for (int j = x + 1; j <= n; j++) Initwanjian(j, x);
	for (int j = 1; j < x; j++) Initwanjian(j, x);
}
代码
#include <iostream>
#include <algorithm>
using namespace std;
int n, m, bld[15], fpig, idx = 0, tot[15], rpig[15], lpig[15];
char c[15][10010], card[10010];
bool tfpig[15], arm[15], flag[15][10010], iden[15], dead[15];
string pig[15];
// c[i][j]：表示第i只猪的第j张牌为c[i][j]。
// tot[i]：表示第i只猪有多少张牌。
// pig[i]：表示第i只猪的角色。
// bld[i]：表示第i只猪的血量值。
// fpig：表示活的反猪的数量。
// tfpig[i]：表示第i只猪是否为类反猪。
// arm[i]：表示第i只猪是否有装备。
// flag[i][j]：表示第i只猪的第j张牌是否被用过。
// iden[i]：表示第i只猪是否已经跳身份。
void Read() {
	iden[1] = true;
	cin >> n >> m;
	for (int i = 1; i <= n; i++) {
		cin >> pig[i];
		bld[i] = 4;
		for (int j = 1; j <= 4; j++) cin >> c[i][++tot[i]];
		if (pig[i] == "FP") fpig++;
		if (i == n) rpig[i] = 1;
		else rpig[i] = i + 1;
		if (i == 1) lpig[i] = n;
		else lpig[i] = i - 1;
	}
	for (int i = 1; i <= m; i++) cin >> card[i];
} // 读入
void Print() {
	if (fpig == 0) cout << "MP" << endl;
	else cout << "FP" << endl;
	for (int i = 1; i <= n; i++)
		if (dead[i]) cout << "DEAD" << endl;
		else {
			int cnt = 0, res = 0;
			for (int j = 1; j <= tot[i]; j++) if (!flag[i][j]) cnt++;
			for (int j = 1; j <= tot[i]; j++)
				if (!flag[i][j] && res != cnt - 1) cout << c[i][j] << " ";
				else if (!flag[i][j] && res == cnt - 1) cout << c[i][j];
			if (!cnt) cout << " ";
			cout << endl;
		}
}
void thrw(int x) {
	for (int i = 1; i <= tot[x]; i++) flag[x][i] = true;
	arm[x] = false;
} // 将第i只猪的手牌和装备弃置
void In(int x, int k) { 
	for (int i = idx + 1; i <= idx + k; i++) c[x][++tot[x]] = card[min(m, i)];
	idx += k;
}// 摸k张牌
int count(int x, char t) { 
	int res = 0;
	for (int i = 1; i <= tot[x]; i++)
		if (!flag[x][i] && c[x][i] == t)
			res++;
	return res;
}// 统计第i只猪有几张t这张牌
void del(int x, int k, char t) { 
	if (k <= 0) return;
	int cnt = 0;
	for (int i = 1; i <= tot[x] && cnt < k; i++)
		if (!flag[x][i] && c[x][i] == t)
			flag[x][i] = true, cnt++;
}// 从c[x]中删除k个字符t。
void peach(int x) {
	if (bld[x] < 4) { bld[x]++; del(x, 1, 'P'); }
} // 在自己的回合回血
bool bld_back(int x) {
	if (bld[x] > 0) return false;
	bool ok = false; // 是否阵亡
	int P = count(x, 'P');
	if (abs(bld[x]) + 1 <= P) { del(x, abs(bld[x]) + 1, 'P'); bld[x] = 1; }
	else { ok = true; thrw(x); }
	return ok;
} // 在别人的回合回血
void Dead(int x, int y) {
	dead[y] = true;
	rpig[lpig[y]] = rpig[y];
	lpig[rpig[y]] = lpig[y];
	if (x == y) return;
	if (pig[y] == "MP") { Print(); exit(0); }
	else if (pig[y] == "FP") {
		if (--fpig == 0) { Print(); exit(0); }
		In(x, 3);
	} else if (pig[x] == "MP") thrw(x);
} // x杀死了y。
void kill(int i, int pos) {
	iden[i] = true;
	int D = count(pos, 'D'); // 统计闪的数量
	int K = 1;
	if (D >= 1) { K = 0; del(pos, 1, 'D'); }
	del(i, 1, 'K');
	bld[pos] -= K;
	if (bld[pos] <= 0) { bool f = bld_back(pos); if (f) Dead(i, pos); } // 对pos这头猪回血
} // i对pos使用杀
void fight(int x, int y) {
	del(x, 1, 'F');
	iden[x] = true;
	if (pig[x] == "MP" && pig[y] == "ZP" && tfpig[y] && !iden[y]) {
		if (--bld[y] <= 0) { int f = bld_back(y); if (f) Dead(x, y); }
		return;
	}
	int xK = count(x, 'K');
	int yK = count(y, 'K');
	int man, toman;
	if (xK >= yK) { toman = x, man = y, bld[y]--; del(x, yK, 'K'), del(y, yK, 'K'); }
	else { man = x, toman = y, bld[x]--; del(y, xK + 1, 'K'), del(x, xK, 'K'); }
	if (bld[man] <= 0) { int f = bld_back(man); if (f) Dead(toman, man); }
}// x向y发起决斗
void Initnanzhu(int j, int x) {
	if (bld[j] <= 0) return ;
	int K = count(j, 'K');
	if (K > 0) del(j, 1, 'K');
	else {
		bool f = true;
		if (--bld[j] <= 0) {
			int P = count(j, 'P');
			if (P == 0) Dead(x, j);
			else bld[j]++, del(j, 1, 'P'), f = false;
		}
		if (j == 1 && f) tfpig[x] = true;
	}
}
void Initwanjian(int j, int x) {
	if (dead[j]) return;
	int D = count(j, 'D');
	if (D > 0) del(j, 1, 'D'); 
	else {
		bool f = true;
		if (--bld[j] <= 0) {
			int P = count(j, 'P');
			if (P == 0) Dead(x, j);
			else bld[j]++, del(j, 1, 'P'), f = false;
		}
		if (j == 1 && f) tfpig[x] = true;
	}
}
void nanzhu(int x) {
	del(x, 1, 'N');
	for (int j = x + 1; j <= n; j++) Initnanzhu(j, x);
	for (int j = 1; j < x; j++) Initnanzhu(j, x);
} // x 发起的南猪入侵
void wanjian(int x) {
	del(x, 1, 'W');
	for (int j = x + 1; j <= n; j++) Initwanjian(j, x);
	for (int j = 1; j < x; j++) Initwanjian(j, x);
} // x 发起的万箭齐发
void Arm(int x) { arm[x] = true; del(x, 1, 'Z'); }
int find(string op, int i) {
	int pos = -1;
	if (i == n && op == "FP") pos = 1; // 特判
	for (int j = i + 1; j <= n && pos == -1; j++)
		if (op == "MP" && (pig[j] == "FP" && iden[j] || tfpig[j]) && bld[j] > 0) { pos = j; break; }
		else if (op == "ZP" && pig[j] == "FP" && iden[j] && bld[j] > 0) { pos = j; break; }
		else if (op == "FP" && pig[j] == "ZP" && iden[j] && bld[j] > 0) { pos = j; break; }
	for (int j = 1; j < i && pos == -1; j++)
		if (op == "MP" && (pig[j] == "FP" && iden[j] || tfpig[j]) && bld[j] > 0) { pos = j; break; }
		else if (op == "ZP" && pig[j] == "FP" && iden[j] && bld[j] > 0) { pos = j; break; }
		else if (op == "FP" && pig[j] == "ZP" && iden[j] && bld[j] > 0) { pos = j; break; }
	return pos;
} // 找到对应种类的猪所要找到的杀的对象，没找到返回-1。
bool find_to_kill(string op, int x) {
	bool can = false;
	string nxt = pig[rpig[x]];
	if (op == "MP" && (nxt == "FP" && iden[rpig[x]] || tfpig[rpig[x]])) can = true;
	else if (op == "ZP" && nxt != "MP" && iden[rpig[x]] && pig[rpig[x]] == "FP") can = true;
	else if (op == "FP" && nxt != "FP" && (rpig[x] == 1 || iden[rpig[x]] && pig[rpig[x]] == "ZP")) can = true;
	return can;
}
void play(int x) { // 模拟
		In(x, 2);
		bool ok = false, use_K = false;
		
		for (int i = 1; i <= tot[x]; i++) {
			if (flag[x][i]) continue;
			char now = c[x][i];
			switch (now) {
				case 'P': peach(x); break;
				case 'K':
					if (find_to_kill(pig[x], x) && (!arm[x] && !use_K || arm[x])) { kill(x, rpig[x]), use_K = true; }
					break;
				case 'F':
					if (pig[x] == "FP") fight(x, 1);
					else if (find(pig[x], x) != -1) fight(x, find(pig[x], x));
					break;
				case 'N': nanzhu(x); break;
				case 'W': wanjian(x); break;
				case 'Z': Arm(x); break;
			}
			if (dead[x]) break;
		}
}
void work() {
	int i = 0;
	while (fpig && bld[1] > 0) {
		i = i % n + 1;
		if (dead[i]) continue;
		else play(i);
	}
}
int main() {
	Read();
	work();
	Print();
	return 0;
}

100 100 100 分

其实加入了无懈可击，只不过是给代码贴了一点补丁，只要理解了就能很快写出来，推荐用dfs的方式写，个人认为会更好些一些。。。
这里就不贴代码了，请读者自行完成。

wuzihenb
关注
  • 12
    点赞
  • 踩
  • 6
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
[SDOI2010]猪国杀题解
hht的博客
09-16 1317
文章目录题目链接：sol游戏结束、一些数组/变量每个猪的结构体：献殷勤、表敌意、跳忠、跳反伤害、死亡无懈可击主要操作完整代码AC代码观战模式 题目链接： 洛谷P2482 loj2885 bzoj1972 推荐去loj看题，可以下数据因为特别容易出错。 sol 其实这题码量也没那大，格式化后我的代码只有141行，在loj目前最短。最好多些一些函数，给每个猪开一个结构体。 游戏结束、一些数组/变量 之...
sdoi2017R1D2
04-16
标题 "sdoi2017R1D2" 暗示这可能是一个与编程竞赛或算法挑战相关的项目，可能是2017年某个阶段的比赛数据。"sdoi" 可能代表 "Sphere Online Judge" 或类似的在线评判系统，这是一个用于举办编程比赛的平台。"R1D2" ...
SDOI2010 猪国杀
YangHao5的博客
04-04 3583
题目描述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（FP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。 开始游戏时，从主猪开始，按照...
Luogu P2482 [SDOI2010]猪国杀
macesuted的博客
01-22 750
Pig Country Kill 很古怪的翻译，不过它确实叫猪(Pig)国(Country)杀(Kill)。 我们来好好整理一下这道题目。题面虽较长，但内容基本清晰，只是有部分很Pig的操作部分，很容易让第一次看见这道题目的人百思不得其解。 先整理一下这道长长的题面。 First：人物 四位玩家，初始四张手牌，血量上限444，初始血量444，会告诉你整个牌堆的牌，每位玩家每个回合从牌堆顶部抽走两...
[SDOI2010]猪国杀
a6t2007的博客
11-02 186
题目描述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（AP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。 开...
洛谷2482 BZOJ1972 SDOI2010 猪国杀 模拟
forever_shi的博客
05-20 292
题目链接 题意就不描述了，自己看吧。 题解： 有很多地方的搞法和注意事项都写在代码里了，都是模拟，没有什么算法上值得说的。注意好好读题，然后考虑一定要全面，不要漏掉什么东西，或者自以为是，有些地方和你实际打三国杀是不一样的。 这个题估计是我高中生涯的最后一道OI题了，拿它做最后一题是有特殊意义的。我记得曾经机房里有人写这个题的时候，zyb推荐我也去写这些大模拟题。我当时告诉zyb说，等着我退役后有...
洛谷P2482 [SDOI2010]猪国杀 题解
eliyou的博客
05-17 1723
开学快乐，整点活儿
P2482 [SDOI2010]猪国杀
guapi2333的博客
11-07 242
连写带调歪歪了一天半。。。。。。 注意理解题意上的坑点： 1、类反猪在未亮明身份时，只有主猪会对其表敌意，其他反猪均将其看作未亮明身份的猪，不会对其表敌意or献殷勤。 2、献殷勤or表敌意的对象只会是已亮明身份的猪（顺便注意：第一次献殷勤or表敌意的玩家身份就亮明了）。 3、关于无懈的结算和使用顺序： （题目原话）每次有一张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到...
LuoguP2482 [SDOI2010] 猪国杀 题解 大型模拟题
qq_45523675的博客
02-29 664
当你发现如论如何也想不知道遗漏了什么之后，你可以将题解代码中的输出注释删除，其运行后会输出每一名角色进行的操作以及操作后的角色状态。一群猪玩猪国杀（类似三国杀），按照特定的规则出牌，问谁能获胜，输出获胜时，存活的猪的手牌。按照上面的思路实现，或者按照自己的思路实现，在实现的过程中注意提到的细节即可。注意到上面的点之后，我们便可以开始做题了。
[Sdoi2010]猪国杀
weixin_30892763的博客
10-16 98
概述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。 每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 ...
bzoj1972: [Sdoi2010]猪国杀
liangjs的专栏
06-02 2366
#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')
sdoi2017R1D1
04-16
标题 "sdoi2017R1D1" 暗示这可能是一个与软件开发或信息技术竞赛相关的项目，可能是2017年某个阶段的第一天挑战或任务。"sdoi" 可能是 "Software Development Online Invitation" 的缩写，意味着这是一个在线编程或...
SDOI2018省选一轮day1试题数据
04-27
SDOI2018省选一轮day1试题数据主要涵盖了计算机科学与信息技术竞赛中的编程题目，这类比赛通常涉及算法设计、问题解决以及编程能力的测试。在这个压缩包中，"data"文件夹很可能是包含试题所需的数据集，这些数据可能...
SDOI2018省选第一试DAY1试题
04-27
本部分提供的文本信息主要涉及了2018年NOI山东省选拔赛第一轮第一天的试题。这些试题包括“一双木棋（chess）”和“IIIDX”两个具体问题。接下来，将详细解析这些题目中所蕴含的知识点。 ### 一双木棋（chess） ...
2017年山东省选(SDOI)第一轮题目及解析
04-11
【2017年山东省选(SDOI)第一轮题目及解析】是一场针对信息技术与算法竞赛的活动，主要考察参赛者的编程能力、算法理解和问题解决技巧。SDOI，即Shandong Province Selection for Online Judges，是山东省面向青少年...
趣味算法------试用 6 和 9 组成的最大数字
最新发布
markingyi的博客
08-26 218
给出一个数字，反转其中一位使数字最大化，递归求解。
代码随想录算法训练营19-回溯1
weixin_53416771的博客
08-22 367
画出来的树是这样记录所有组合，一个变量current装当前的处理结果，一个res装所有的处理的结果下面的代码还可以剪枝优化。
算法日记day 45（单调栈之每日温度|接雨水）
m0_74980681的博客
08-22 882
如果大于，则取栈顶元素为中间值并弹出栈顶元素，将遍历的元素与新的栈顶元素值比较取较小者，减去中间值得到高度h，然后栈顶元素下标值减去当前遍历的元素下标值再减一得到宽度w，最后高×宽得到面积，并记录，重复上述操作，直到遍历结束。第三种，如果遍历的元素值大于栈顶元素，用该下标减去栈顶元素下标，并将栈顶元素弹出，继续用该元素与新的栈顶元素比较，如果小于等于，则压入栈，如果大于，重复第三步操作。第一种，如果之后遍历的元素值小于栈顶压入的元素，将该元素的下标压入栈中。如果小于栈顶元素值，则压入栈内。
7-7 数组中能被5整除的数的和
Virgo_616的博客
08-26 124
在一维数组中有10个整数，求出其中能被5整除的所有数的和。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值