BZOJ 1972 [Sdoi2010]猪国杀
|
题解
|
阅读次
|
4.6k 字
|
22 分钟

  • 概述

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

  • 游戏目的

    • 主猪（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();
}
本文作者 : NekoMio
知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议进行许可。
本文链接 : https://www.nekomio.com/2017/10/10/113/
上一篇
下一篇