4042 字
20 分钟
BZOJ 1972 [Sdoi2010]猪国杀
2017-10-10
  • 概述
    • 《猪国杀》是一种多猪牌类回合制游戏,一共有三种角色:主猪,忠猪,反猪。
    • 每局游戏主猪有且只有一只,忠猪和反猪可以有多只,每只猪扮演一种角色。
  • 游戏目的

    • 主猪(MP):自己存活的情况下消灭所有的反猪。
    • 忠猪(ZP):不惜一切保护主猪,胜利条件与主猪相同。
    • 反猪(FP):杀死主猪。
  • 游戏过程

    • 游戏开始时候,每个玩家手里都会有 4 张牌,且体力上限和初始体力都是 4 。
    • 开始游戏时,从主猪开始,按照逆时针方向(数据中就是按照编号从 1, 2, 3…n, 1… 的顺序)依次行动。
    • 每个玩家自己的回合可以分为 4 个阶段
      • 摸牌阶段
        • 从牌堆顶部摸两张牌,依次放到手牌的最右边。
      • 出牌阶段
        • 你可以使用 0 张到任意张牌,每次使用牌的时候都使用最靠左的能够使用的牌。
        • 当然,要满足如下规则
          • 如果没有猪哥连弩,每个出牌阶段只能使用一次“杀”来攻击。
          • 任何牌被使用后被弃置(武器是装备上)。
          • 被弃置的牌以后都不能再用,即与游戏无关。
  • 各种牌介绍

    • 每张手牌用一个字母表示,字母代表牌的种类。
    • 基本牌
      • 『桃(P)』
        • 在自己的回合内,如果自己的体力值不等于体力上限,那么使用一个桃可以为自己补充一点体力;否则不能使用桃。 桃只能对自己使用。
        • 在自己的回合外,如果自己的血变为 0 或者更低,那么也可以使用。
      • 『杀(K)』
        • 在自己的回合内,对攻击范围内除自己以外的一名角色使用。
        • 如果没有被『闪』抵消,则造成 1 点伤害。
        • 无论有无武器,杀的攻击范围都是 1。
      • 『闪(D)』
        • 当你受到杀的攻击时,可以弃置一张闪来抵消杀的效果。
    • 锦囊牌
      • 『决斗(F)』
        • 出牌阶段,对除自己以外任意一名角色使用,由目标角色先开始,自己和目标角色轮流弃置一张杀,首先没有杀可弃的一方受到1点伤害,另一方视为此伤害的来源。
      • 『南猪入侵(N)』
        • 出牌阶段,对除你以外所有角色使用,按逆时针顺序从使用者下家开始依次结算,除非弃置一张杀,否则受到1点伤害。
      • 『万箭齐发(W)』
        • 和南猪入侵类似,不过要弃置的不是杀而是闪。
      • 『无懈可击(J)』
        • 在目标锦囊生效前抵消其效果。
        • 每次有一张锦囊即将生效时,从使用这张锦囊的猪开始,按照逆时针顺序,依次得到使用无懈可击的机会。
        • 效果
          • 用于决斗时,决斗无效并弃置。
          • 用于南猪入侵或万箭齐发时,当结算到某个角色时才能使用,当前角色不需弃置牌并且不会受到伤害(仅对一个角色产生效果)。
          • 用于无懈可击时,成为目标的无懈可击被无效。
    • 装备牌
      • 『猪哥连弩(Z)』
        • 武器,攻击范围 1,出牌阶段你可以使用任意张杀。 同一时刻最多只能装一个武器。
        • 如果先前已经有了一把武器,那么之后再装武器的话,会弃置以前的武器来装现在的武器。
  • 特殊事件及概念解释

    • 伤害来源
      • 杀、南猪入侵、万箭齐发的伤害来源均是使用该牌的猪。
      • 决斗的伤害来源如上。
    • 距离
      • 两只猪的距离定义为沿着逆时针方向间隔的猪数 +1。即初始时 1 和 2 的距离为 1 ,但是 2 和 1 的距离就是 n - 1 。
      • 注意一个角色的死亡会导致一些猪距离的改变。
    • 玩家死亡
      • 如果该玩家的体力降到 0 或者更低,并且自己手中没有足够的桃使得自己的体力值回到 1,那么就死亡了,死亡后所有的牌(装备区,手牌区)被弃置、
    • 奖励与惩罚
      • 反猪死亡时,最后一个伤害来源处(即使是反猪)立即摸三张牌。
      • 忠猪死亡时,如果最后一个伤害来源是主猪,那么主猪所有装备牌、手牌被弃置。
      • 注意,一旦达成胜利条件,游戏立刻结束,因此即使会摸 3 张牌或者还有牌可以用也不用执行了。
  • 现在,我们已经知道每只猪的角色、手牌,还有牌堆初始情况,并且假设每个角色会按照如下的行为准则进行游戏,你需要做的就是告诉小猪 iPig 最后的结果。

  • 几种行为

    • 献殷勤
      • 使用无懈可击挡下南猪入侵、万箭齐发、决斗。
      • 使用无懈可击抵消表敌意。
    • 表敌意
      • 对某个角色使用杀、决斗。
      • 使用无懈可击抵消献殷勤。
    • 跳忠
      • 即通过行动表示自己是忠猪。
      • 跳忠行动就是对主猪或对某只已经跳忠的猪献殷勤,或者对某只已经跳反的猪表敌意。
    • 跳反
      • 即通过行动表示自己是反猪。
      • 跳反行动就是对主猪或对某只已经跳忠的猪表敌意,或者对某只已经跳反的猪献殷勤。
      • 忠猪不会跳反,反猪也不会跳忠。
      • 不管是忠猪还是反猪,能够跳必然跳。
  • 行动准则

    • 共性
      • 每个角色如果手里有桃且生命值未满,那么必然吃掉。
      • 有南猪入侵、万箭齐发、必然使用。
      • 有装备必然装上。
      • 受到杀时,有闪必然弃置。
      • 响应南猪入侵或者万箭齐发时候,有杀/闪必然弃置。
      • 不会对未表明身份的猪献殷勤(包括自己)。
    • 特性
      • 主猪
        • 主猪会认为没有跳身份,且用南猪入侵/万箭齐发对自己造成伤害的猪是“类反猪”(没伤害到不算,注意“类反猪”并没有表明身份),如果之后跳了,那么主猪会重新认识这只猪。 对于每种表敌意的方式,对逆时针方向能够执行到的第一只“类反猪”或者已跳反猪表;如果没有,那么就不表敌意。 决斗时会不遗余力弃置杀。
        • 如果能对已经跳忠的猪或自己献殷勤,那么一定献。
        • 如果能够对已经跳反的猪表敌意,那么一定表。
      • 忠猪
        • 对于每种表敌意的方式,对逆时针方向能够执行到的第一只已经跳反的猪表;如果没有,那么就不表敌意。
        • 决斗时,如果对方是主猪,那么不会弃置杀,否则,会不遗余力弃置杀。
        • 如果有机会对主猪或者已经跳忠的猪献殷勤,那么一定献。
      • 反猪
        • 对于每种表敌意的方式,如果有机会则对主猪表,否则,对逆时针方向能够执行到的第一只已经跳忠的猪表;如果没有,那么就不表敌意。
        • 决斗时会不遗余力弃置杀。
        • 如果有机会对已经跳反的猪献殷勤,那么一定献。
  • 限于 iPig 只会用 P++ 语言写 A + B,他请你用 Pigcal(Pascal)、P(C) 或 P++(C++) 语言来帮他预测最后的结果。

  • 输入

    • 第一行包含两个正整数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 D

题解#

题目就是题解

#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <list>
#include <cstdlib>
int n, m, T, D_F, Z_D_to_M;
char C[2005];
// #define Log 1
namespace Pig
{
bool Died[11];
struct Pig_data
{
/*
Id :
1: 主猪
2: 忠猪
3: 反猪
*/
std::list<char> Card;
std::list<char>::iterator it, it2;
int Identity, Strength;
bool Equipped, Jump, Similar;
void init(int Id, char *s)
{
Strength = 4, Similar = 0;
Identity = Id;
if (Id == 1) Jump = 1;
for (int i = 1; i <= 4; i++)
Card.push_back(s[i]);
}
void Print(int i)
{
it2 = Card.end();
if (it2 == Card.begin())
{
if(i != n)
printf("\n");
return;
}
it2--;
for (it = Card.begin(); it != it2; it++)
printf("%c ", *it);
printf("%c", *it2);
if(i != n) printf ("\n");
}
}Pig[11];
}
namespace Card
{
struct Card_Heap_data
{
char Card_Heap[2005];
int h, t;
void init(char *s, int Num)
{
t = Num;
h = 0;
for (int i = 1; i <= Num; i++)
Card_Heap[i] = s[i];
}
char Get_Card()
{
if (h == t)
return Card_Heap[h];
else
return Card_Heap[++h];
}
}Card;
}
namespace Main
{
void Read_init()
{
#ifdef Log
printf("===========================================\n Read Start\n=================================\n");
#endif
scanf("%d%d", &::n ,&::m);
char s[5], ID[4];
for (int i = 1; i <= n; i++)
{
scanf ("%s", ID);
for (int j = 1; j <= 4; j++)
std::cin >> s[j];
if (ID[0] == 'M')
Pig::Pig[i].init(1, s);
else if (ID[0] == 'Z')
Pig::Pig[i].init(2, s);
else
Pig::Pig[i].init(3, s), T++;
}
#ifdef Log
printf("===========================================\n Read Pig Succeed\n=================================\n");
#endif
memset(Pig::Died, 0, sizeof(Pig::Died));
for (int i = 1; i <= m; i++)
std::cin >> C[i];
#ifdef Log
printf("===========================================\n Read Card Succeed\n=================================\n");
#endif
Card::Card.init(C, m);
#ifdef Log
printf("===========================================\nCard Init Succeed\n=================================\n");
#endif
}
void Get_Card(int x, int t)
{
#ifdef Log
printf("Pig %d Get %d Card\n", x, t);
#endif
while (t--)
{
Pig::Pig[x].Card.push_back(Card::Card.Get_Card());
}
}
int nxt[11];
int next(int x)
{
if (nxt[x] != 0) return nxt[x];
for (int i = x + 1; ; i++)
{
if (i == n + 1) i = 1;
if (!Pig::Died[i])
return nxt[x] = i;
}
}
std::list<char>::iterator it, it2, searchit, eraseit;
bool Over(int &W)
{
bool No_Fan = 1;
int now = 0;
if (Pig::Died[1]) return W = 1, 1;
else now = 1;
int Next_Pig = now;
do
{
if (Pig::Pig[Next_Pig].Identity == 3) No_Fan = 0;
Next_Pig = next(Next_Pig);
}while (Next_Pig != now);
if (No_Fan)
return W = 0, 1;
else
return 0;
}
bool Judge(int x, char c, int K_Num, int &t)
{
if (c == 'P')
{
if (Pig::Pig[x].Strength != 4)
return t = x, 1;
else return 0;
}
else if (c == 'K')
{
if (K_Num && !Pig::Pig[x].Equipped) return 0;
if (Pig::Pig[x].Identity == 1)
{
if (Pig::Pig[next(x)].Similar) return t = next(x), 1;
if (Pig::Pig[next(x)].Identity == 3 && Pig::Pig[next(x)].Jump)
return t = next(x), 1;
else return 0;
}
else if (Pig::Pig[x].Identity == 2)
{
if (Pig::Pig[next(x)].Identity == 3 && Pig::Pig[next(x)].Jump)
return t = next(x), 1;
else return 0;
}
else if (Pig::Pig[x].Identity == 3)
{
if ((Pig::Pig[next(x)].Identity == 1 || Pig::Pig[next(x)].Identity == 2) && Pig::Pig[next(x)].Jump)
return t = next(x), 1;
else return 0;
}
else
{
printf ("ERROR No Identity\n");
}
}
else if (c == 'D') return 0;
else if (c == 'F')
{
bool flag = 0;
int Next_Pig = next(x);
while (Next_Pig != x)
{
if (Pig::Pig[x].Identity == 1)
{
if (Pig::Pig[Next_Pig].Similar) return t = Next_Pig, 1;
if (Pig::Pig[Next_Pig].Identity == 3 && Pig::Pig[Next_Pig].Jump)
return t = Next_Pig, 1;
else goto Restart;
}
else if (Pig::Pig[x].Identity == 2)
{
if (Pig::Pig[Next_Pig].Identity == 3 && Pig::Pig[Next_Pig].Jump)
return t = Next_Pig, 1;
else goto Restart;
}
else if (Pig::Pig[x].Identity == 3)
{
if (Pig::Pig[Next_Pig].Identity == 1)
return t = Next_Pig, 1;
else if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[Next_Pig].Jump)
{
if (!flag) flag = 1, t = Next_Pig;
goto Restart;
}
else goto Restart;
}
else
{
printf ("ERROR No Identity\n");
}
Restart: Next_Pig = next(Next_Pig);
}
if (Pig::Pig[x].Identity == 3 && flag) return 1;
else return 0;
}
else if (c == 'N' || c == 'W')
{
return t = -1, 1;
}
else if (c == 'J')
return 0;
else if (c == 'Z')
return t = x, 1;
else
{
printf ("ERROR in Card ID\n");
exit(0);
return 0;
}
return 0;
}
bool Have(char c, int t)// and erase
{
#ifdef Log
printf("It's %d to return He have ", t);
Pig::Pig[t].Print();
#endif
for (searchit = Pig::Pig[t].Card.begin(); searchit != Pig::Pig[t].Card.end(); searchit++)
if (*searchit == c)
{
#ifdef Log
printf("Pig %d Used %c\n", t, c);
#endif
return Pig::Pig[t].Card.erase(searchit), 1;
}
return 0;
}
bool Need_Wuxie(int x)
{
if (!Have('J', x)) return 0;
Pig::Pig[x].Jump = 1;
Pig::Pig[x].Similar = 0;
return 1;
}
bool Wuxie(int x, bool op)
{
int Next_Pig = x;
do
{
if ((op == 0 && Pig::Pig[Next_Pig].Identity == 3) || (op == 1 && Pig::Pig[Next_Pig].Identity != 3))
{
if (!Need_Wuxie(Next_Pig)) goto again;
if (!Wuxie(Next_Pig, op ^ 1)) return 1;
return 0;
}
again: Next_Pig = next(Next_Pig);
}while (Next_Pig != x);
return 0;
}
bool Okforwuxie(int x, int t)
{
if (!Pig::Pig[t].Jump) return 0;
if (Pig::Pig[t].Identity == 3) return Wuxie(x, 0);
else return Wuxie(x, 1);
}
void UseM(int x, char c, int t)
{
if (c == 'K')
{
#ifdef Log
printf("Pig %d use %c to %d\n", x, c, t);
#endif
if (Pig::Pig[t].Jump) Pig::Pig[x].Jump = 1;
if (!Have('D', t))
{
#ifdef Log
printf("Pig %d not have %c\n", t, 'D');
#endif // Log
Pig::Pig[t].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
#endif // Log
if (Pig::Pig[t].Strength == 0)
{
if (!Have('P', t))
{
#ifdef Log
printf("Pig %d Died\n", t);
#endif // Log
Pig::Died[t] = 1;
memset(nxt, 0, sizeof (nxt));
if (Pig::Died[1] == 1) return;
if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1)
{
Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[t].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(x, 3);
}
}
else
Pig::Pig[t].Strength = 1;
}
}
return;
}
else if (c == 'P')
return Pig::Pig[x].Strength++, void(0);
else if (c == 'F')
{
#ifdef Log
printf("Pig %d use %c to %d\n", x, c, t);
#endif
Pig::Pig[x].Jump = 1, Pig::Pig[x].Similar = 0;
if (Pig::Pig[x].Identity == 1 && Pig::Pig[t].Identity == 2)
{
Pig::Pig[t].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
#endif // Log
if (Pig::Pig[t].Strength == 0)
{
if (!Have('P', t))
{
#ifdef Log
printf("Pig %d Died\n", t);
#endif // Log
Pig::Died[t] = 1;
memset(nxt, 0, sizeof (nxt));
if (Pig::Died[1] == 1) return;
if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1)
{
Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[t].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(t, 3);
}
}
else
Pig::Pig[t].Strength = 1;
}
return;
}
if (Okforwuxie(x, t)) return void(0);
while (1)
{
if (!Have('K', t))
{
Pig::Pig[t].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", t, Pig::Pig[t].Strength);
#endif // Log
if (Pig::Pig[t].Strength == 0)
{
if (!Have('P', t))
{
#ifdef Log
printf("Pig %d Died\n", t);
#endif // Log
Pig::Died[t] = 1;
memset (nxt, 0, sizeof (nxt));
if (Pig::Died[1] == 1) return;
if (Pig::Pig[t].Identity == 2 && Pig::Pig[x].Identity == 1)
{
Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[t].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(x, 3);
}
}
else
Pig::Pig[t].Strength = 1;
}
return;
}
if (!Have('K', x))
{
Pig::Pig[x].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", x, Pig::Pig[x].Strength);
#endif // Log
if (Pig::Pig[x].Strength == 0)
{
if (!Have('P', x))
{
#ifdef Log
printf("Pig %d Died\n", x);
#endif // Log
Pig::Died[x] = 1;
memset (nxt, 0, sizeof (nxt));
if (Pig::Died[1] == 1) return;
if (Pig::Pig[x].Identity == 2 && Pig::Pig[t].Identity == 1)
{
Pig::Pig[t].Card.clear(), Pig::Pig[t].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[x].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(t, 3);
return;
}
}
else
Pig::Pig[x].Strength = 1;
}
return;
}
}
}
else if (c == 'N')
{
#ifdef Log
printf("Pig %d use %c to %d\n", x, c, t);
#endif
int Next_Pig = next(x);
do
{
if (Okforwuxie(x, Next_Pig)) goto END1;
if (!Have('K', Next_Pig))
{
Pig::Pig[Next_Pig].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", Next_Pig, Pig::Pig[Next_Pig].Strength);
#endif // Log
if (Pig::Pig[Next_Pig].Strength == 0)
{
if (!Have('P', Next_Pig))
{
#ifdef Log
printf("Pig %d Died\n", Next_Pig);
#endif // Log
memset (nxt, 0, sizeof (nxt));
Pig::Died[Next_Pig] = 1;
if (Pig::Died[1] == 1) return;
if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[x].Identity == 1)
{
Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[Next_Pig].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(x, 3);
}
}
else
Pig::Pig[Next_Pig].Strength = 1;
}
if (Pig::Pig[Next_Pig].Identity == 1 && Pig::Pig[x].Jump == 0) Pig::Pig[x].Similar = 1;
}
END1:Next_Pig = next(Next_Pig);
}while (Next_Pig != x);
return;
}
else if (c == 'W')
{
#ifdef Log
printf("Pig %d use %c to %d\n", x, c, t);
#endif
int Next_Pig = next(x);
do
{
if (Okforwuxie(x, Next_Pig)) goto END2;
if (!Have('D', Next_Pig))
{
Pig::Pig[Next_Pig].Strength--;
#ifdef Log
printf("Pig %d HP = %d\n", Next_Pig, Pig::Pig[Next_Pig].Strength);
#endif // Log
if (Pig::Pig[Next_Pig].Strength == 0)
{
if (!Have('P', Next_Pig))
{
#ifdef Log
printf("Pig %d Died\n", Next_Pig);
#endif // Log
Pig::Died[Next_Pig] = 1;
memset (nxt, 0, sizeof (nxt));
if (Pig::Died[1] == 1) return;
if (Pig::Pig[Next_Pig].Identity == 2 && Pig::Pig[x].Identity == 1)
{
Pig::Pig[x].Card.clear(), Pig::Pig[x].Equipped = 0;
Z_D_to_M = 1;
}
if (Pig::Pig[Next_Pig].Identity == 3)
{
D_F++;
if (D_F == T) return;
Get_Card(x, 3);
}
}
else
Pig::Pig[Next_Pig].Strength = 1;
}
if (Pig::Pig[Next_Pig].Identity == 1 && Pig::Pig[x].Jump == 0) Pig::Pig[x].Similar = 1;
}
END2:Next_Pig = next(Next_Pig);
}while (Next_Pig != x);
return;
}
else if (c == 'Z')
return Pig::Pig[x].Equipped = 1, void(0);
}
void Use(int x, char c, int t)
{
UseM(x, c, t);
// printf("ERROR in Use at Identity, There is no Id in the Pig\n");
}
void Play(int x)
{
it = Pig::Pig[x].Card.begin();
int K_Num = 0;
int Y = D_F;
for (; it != Pig::Pig[x].Card.end(); it = it2)
{
int t = 0;
if (Judge(x, *it, K_Num, t))
{
#ifdef Log
printf("Pig %d Used %c to %d\n", x, *it, t);
#endif
Use(x, *it, t);
if (Z_D_to_M) return;
if (*it == 'K') K_Num++;
Pig::Pig[x].Card.erase(it);
it2 = Pig::Pig[x].Card.begin();
if (Pig::Died[1] == 1 || Pig::Died[x] == 1 || D_F == T) return;
}
else
{
it2 = it;
it2++;
}
}
}
void Run()
{
int now = 1, W = 0;
while (!Over(W))
{
#ifdef Log
printf("It is %d Paly, It's Identity is %d ", now, Pig::Pig[now].Identity);
if (Pig::Pig[now].Jump == 1)
printf("He Jumped\n");
else
printf("He not Jumped\n");
#endif // Log
Get_Card(now, 2);
#ifdef Log
printf("He has ");
Pig::Pig[now].Print();
#endif
Play(now);
Z_D_to_M = 0;
now = next(now);
}
if (W == 0)
{
printf ("MP\n");
for (int i = 1; i <= n; i++)
{
if (Pig::Died[i])
printf("DEAD\n");
else
Pig::Pig[i].Print(i);
}
}
else
{
printf ("FP\n");
for (int i = 1; i <= n; i++)
{
if (Pig::Died[i])
printf("DEAD\n");
else
Pig::Pig[i].Print(i);
}
}
}
}
int main()
{
// freopen("kopk10.in", "r", stdin);
// freopen("1.out", "w", stdout);
#ifdef Log
printf("======================================\n Start\n======================================\n");
#endif
Main::Read_init();
#ifdef Log
printf("Read Success\n\n");
printf("======================================\nGame Start\n\n");
#endif
Main::Run();
}
BZOJ 1972 [Sdoi2010]猪国杀
https://www.nekomio.com/posts/113/
作者
NekoMio
发布于
2017-10-10
许可协议
CC BY-NC-SA 4.0