[BZOJ1972][Sdoi2010]猪国杀（大模拟）-CSDN博客

本文链接：https://blog.csdn.net/Clove_unique/article/details/58348122

吐槽

这题真的写了一天啊…
虽然我码力太弱是主要因素，但是题面确实是挺难懂的！
所以自己将题面和数据范围做了改进，避免了一些不必要的坑点，最后又加入了一些自己写的时候发现的奇奇怪怪的问题，应该会比原题面清楚些，欢迎大家来读…

题目描述

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

游戏目的

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

游戏过程

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

各种牌介绍

每张手牌用一个字母表示，字母代表牌的种类。

◎基本牌：
『桃(P)』：
桃只能对自己使用。
在自己的回合内，如果自己的体力值不等于体力上限，那么使用一个桃可以为自己补充一点体力，否则不能使用桃。
在自己的回合外，如果自己的血变为0或者更低，那么也可以使用。
『杀(K)』：
在自己的回合内，对攻击范围内除自己以外的一名角色使用。
如果没有被『闪』抵消，则造成1点伤害。无论有无武器，杀的攻击范围都是1。
『闪(D)』：
当你受到杀的攻击时，可以弃置一张闪来抵消杀的效果。

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

◎锦囊牌：
『决斗(F)』：
出牌阶段，对除自己以外任意一名角色使用。
由目标角色先开始，自己和目标角色轮流弃置一张杀，首先没有杀可弃的一方受到1点伤害，另一方视为此伤害的来源。
『南猪入侵(N)』：
出牌阶段，对除你以外所有角色使用。
按逆时针顺序从使用者下家开始依次结算，除非弃置一张杀，否则受到1点伤害。
『万箭齐发(W)』：
和南猪入侵类似，不过要弃置的不是杀而是闪。
『无懈可击(J)』：
在目标锦囊生效前抵消其效果。
每次有一张锦囊即将生效前，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会。
效果：
用于决斗时，决斗无效并弃置。
用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对一个角色产生效果）。
用于无懈可击时，成为目标的无懈可击被无效。

特殊事件及概念解释

◎伤害来源：
杀、南猪入侵、万箭齐发的伤害来源均是使用该牌的猪，决斗的伤害来源如上。
◎距离：
两只猪的距离定义为沿着逆时针方向间隔的猪数＋1。即初始时1和2的距离为1，但是2和1的距离就是n-1。注意一个角色的死亡会导致一些猪距离的改变。
◎玩家死亡：
如果该玩家的体力降到0或者更低，并且自己手中没有足够的桃使得自己的体力值回到1，那么就死亡了，死亡后所有的牌（装备区，手牌区）被弃置。
◎奖励与惩罚：
反猪死亡时，最后一个伤害来源处（即使是反猪）立即摸三张牌。
忠猪死亡时，如果最后一个伤害来源是主猪，那么主猪所有装备牌、手牌被弃置。
◎注意，一旦达成胜利条件，游戏立刻结束，因此即使会摸3张牌或者还有牌可以用也不用执行了。

游戏当中，每个角色都会按照如下的行为准则进行游戏。

几种行为

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

行动准则

共性：
每个角色如果手里有桃且生命值未满，那么必然吃掉。
有南猪入侵/万箭齐发、必然使用。
有装备必然装上。
受到杀时，有闪必然弃置。
响应南猪入侵或者万箭齐发时候，有杀/闪必然弃置。
不会对未表明身份的猪献殷勤（包括自己）。

特性：
◎主猪：
主猪会认为没有跳身份，且用南猪入侵/万箭齐发对自己造成伤害的猪是“类反猪”（没伤害到不算，注意类反猪并没有表明身份），如果之后跳了，那么主猪会重新认识这只猪。
对于每种表敌意的方式，对逆时针方向能够执行到的第一只类反猪或者已跳反猪表；如果没有，那么就不表敌意。
决斗时会不遗余力弃置杀。
如果能对已经跳忠的猪或自己献殷勤，那么一定献；如果能够对已经跳反的猪表敌意，那么一定表。
◎忠猪：
对于每种表敌意的方式，对逆时针方向能够执行到的第一只已经跳反的猪表，如果没有，那么就不表敌意。
决斗时，如果对方是主猪，那么不会弃置杀，否则，会不遗余力弃置杀（注意这里不算对主猪献殷勤）。
如果有机会对主猪或者已经跳忠的猪献殷勤，那么一定献。
◎反猪：
对于每种表敌意的方式，如果有机会则对主猪表，否则，对逆时针方向能够执行到的第一只已经跳忠的猪表，如果没有，那么就不表敌意。
决斗时会不遗余力弃置杀。
如果有机会对已经跳反的猪献殷勤，那么一定献。

总结一下在某一个人的出牌阶段可能发生的事情：
摸牌阶段，首先摸两张牌。
出牌阶段，对于每一张牌：
如果这张牌为桃，则判断自己体力值是否为上限，若不是，则对自己使用桃，体力+1。
如果这张牌为猪哥连弩，则直接装备。
如果这张牌为南猪入侵/万箭齐发，则直接使用。
如果这张牌为杀，首先判断是否能出杀（有猪哥连弩或者本回合未使用过杀）；如果能，寻找使用对象；如果能找到，对其使用杀，否则不使用。
如果这张牌为决斗，寻找使用对象；如果能找到，对其使用决斗，否则不使用。

如果一只猪体力被攻击成0，如果手中有桃则吃桃并且体力变为1，否则死亡。
如果一只猪死了，首先判断游戏是否结束；否则进行“奖励与惩罚”。
对于每一个对象，在锦囊牌生效之前（“决斗”和“无懈可击”为1个对象，“万箭齐发”为多个对象），从使用锦囊牌的猪开始，逆时针方向判断是否使用“无懈可击”；使用无懈可击的条件是，使用对象身份已经确定（跳身份），并且和自己的身份不冲突。
如果对一只身份已经确定的猪“献殷勤”或是“表敌意”，自己的身份也随之被“跳”。

现在，我们已经知道每只猪的角色、手牌，还有牌堆初始情况，你需要做的就是告诉小猪iPig最后的结果。

输入格式

输入文件第一行包含两个正整数n 和m，分别代表玩家数和牌堆中牌的数量。
接下来n行，每行5个字符串，依次表示对第i只猪的角色和初始4张手牌描述。编号为1的肯定是主猪。
再接下来一行，一共m个字符串，按照从牌堆顶部到牌堆底部的顺序描述每张牌。
所有的相邻的两个字符串都严格用1个空格隔开，行尾没有多余空格。

输出格式

输出数据第一行包含一个字符串代表游戏结果。如果是主猪胜利，那么输出“MP”，否则输出“FP”。数据保证游戏总会结束。
接下来n行，第i行是对第i只猪的手牌描述（注意只需要输出手牌），按照手牌从左往右的顺序输出，相邻两张牌用一个空格隔开，行末尾没有多余空格。如果这只猪已阵亡，那么只要输出“DEAD”即可。注意如果要输出手牌而没有手牌的话，那么只需输出一个空行。

数据范围

对于 $10\%$ 的数据，没有锦囊牌
对于 $30\%$ 的数据，没有无懈可击
对于 $100\%$ 的数据， $2 \le n \le 10，1\le m\le 2000$

题解

大模拟。。。
快写哭我了
题面确实没问题，认真读题！
具体看代码。。。

代码

#include<algorithm>
#include<iostream>
#include<cstring>
#include<cstdio>
#include<cmath>
#define Abs(x) ((x>0)?x:-x)
using namespace std;

int n,m;
struct PIG
{
    // 身份  1：主猪  2：忠猪  -2：未跳忠的忠猪  3：反猪  -3：未跳反的反猪  0：死猪
    int id;
    // 手牌数量
    int cnt;
    // 手牌 P：桃  K：杀  D：闪  F：决斗  N：南猪入侵   W：万箭齐发  J 无懈可击  Z 猪哥连弩
    char card[4005];
    // 这张手牌是否用过，与card相对应，1表示已用过 
    bool flag[4005];
    // 是否有武器
    int gun;
    // 血量
    int blood;
    // 是否是主猪认为的类反猪
    int looks_like;
}pig[20];
//牌堆中的牌 & 指针
char rest[4005];int point;
//当前回合的猪，它后面的猪 双向链表
int nowpig,pre[20],nxt[20];
// 标记当前回合是否已经杀过
int has_killed;
// 标记游戏是否结束以及记录赢家 1表示MZ赢，3表示FZ赢 
int win;
// 反猪的数量  现在已经死了的反猪的数量
int totFZ,deadFZ; 

void GetCard(int x)
{
    if (point<m) ++point;
    ++pig[x].cnt;
    pig[x].card[pig[x].cnt]=rest[point];
    pig[x].flag[pig[x].cnt]=0;
}
bool HaveKill(int x)
{
    for (int i=1;i<=pig[x].cnt;++i)
    {
        if (pig[x].flag[i]) continue;
        if (pig[x].card[i]=='K')
        {
            pig[x].flag[i]=1;
            return 1;
        }
    }
    return 0;
}
bool HaveDodge(int x)
{
    for (int i=1;i<=pig[x].cnt;++i)
    {
        if (pig[x].flag[i]) continue;
        if (pig[x].card[i]=='D')
        {
            pig[x].flag[i]=1;
            return 1;
        }
    }
    return 0;
}
bool HaveWXKJ(int x)
{
    for (int i=1;i<=pig[x].cnt;++i)
    {
        if (pig[x].flag[i]) continue;
        if (pig[x].card[i]=='J')
        {
            pig[x].flag[i]=1;
            return 1;
        }
    }
    return 0;
}
// 从第x只猪开始轮流用无懈可击，用的目的是抵消to的锦囊 
int WuXieKeJi(int x,int to)
{
    int i=x;
    do
    {
        switch(pig[to].id)
        {
            case 1:
                {
                    if (Abs(pig[i].id)==3&&HaveWXKJ(i))
                    {
                        pig[i].id=3;
                        pig[i].looks_like=0;
                        return WuXieKeJi(nxt[i],i)+1;
                    }
                    break;
                }
            case 2:
                {
                    if (Abs(pig[i].id)==3&&HaveWXKJ(i))
                    {
                        pig[i].id=3;
                        pig[i].looks_like=0;
                        return WuXieKeJi(nxt[i],i)+1;
                    }
                    break;
                }
            case 3:
                {
                    if ((Abs(pig[i].id)==2||pig[i].id==1)&&HaveWXKJ(i))
                    {
                        pig[i].id=Abs(pig[i].id);
                        pig[i].looks_like=0;
                        return WuXieKeJi(nxt[i],i)+1;
                    }
                    break;
                }
            default:
                {
                    if (pig[to].looks_like&&pig[i].id==1&&HaveWXKJ(i))
                        return WuXieKeJi(nxt[i],i)+1;
                    break;
                }
        }
        i=nxt[i];
    }
    while (i!=x);
    return 0;
}
// 判断x是否能帮助help 
bool Help(int x,int help)
{
    switch(pig[help].id)
    {
        case 1:
            {
                if ((pig[x].id==1||Abs(pig[x].id)==2)&&HaveWXKJ(x))
                {
                    pig[x].id=Abs(pig[x].id);
                    pig[x].looks_like=0;
                    int trying=WuXieKeJi(nxt[x],x);
                    if (trying%2==0) return 1;
                }
                break;
            }
        case 2:
            {
                if ((Abs(pig[x].id)==2||pig[x].id==1)&&HaveWXKJ(x))
                {
                    pig[x].id=Abs(pig[x].id);
                    pig[x].looks_like=0;
                    int trying=WuXieKeJi(nxt[x],x);
                    if (trying%2==0) return 1;
                }
                break;
            }
        case 3:
            {
                if (Abs(pig[x].id)==3&&HaveWXKJ(x))
                {
                    pig[x].id=3;
                    pig[x].looks_like=0;
                    int trying=WuXieKeJi(nxt[x],x);
                    if (trying%2==0) return 1;
                }
                break;
            }
    }
    return 0;
}
void CheckDeath(int x,int from)
{
    if (pig[x].blood>0) return;
    // 有 桃 吃 桃 
    for (int i=1;i<=pig[x].cnt;++i)
    {
        if (pig[x].flag[i]) continue;
        if (pig[x].card[i]=='P')
        {
            pig[x].blood=1;
            pig[x].flag[i]=1;
            return;
        }
    }
    // 被 杀 死 了... 
    pre[nxt[x]]=pre[x];
    nxt[pre[x]]=nxt[x];
    // 判断游戏是否结束，并且“奖励与惩罚” 
    switch(Abs(pig[x].id))
    {
        case 1:
            {
                // 主猪死亡，反猪获胜 
                win=3;
                break;
            }
        case 2:
            {
                // 忠猪死亡，如果伤害来源为主猪，那么主猪的手牌和装备都被弃置 
                if (from==1)
                {
                    pig[1].cnt=0;
                    pig[1].gun=0;
                }
                break;
            }
        case 3:
            {
                // 反猪死亡，如果反猪全部死亡则主猪胜利，否则伤害来源摸三张牌 
                ++deadFZ;
                if (deadFZ==totFZ) win=1;
                if (!win) GetCard(from),GetCard(from),GetCard(from);
                break;
            }
    }
    pig[x].id=0;
}
bool Killing()
{
    if (has_killed>=1&&!pig[nowpig].gun) return 0;
    int type=Abs(pig[nowpig].id);
    switch(type)
    {
        case 1:
            {
                if (pig[nxt[nowpig]].looks_like||pig[nxt[nowpig]].id==3)
                {
                    ++has_killed;
                    if (!HaveDodge(nxt[nowpig]))
                    {
                        --pig[nxt[nowpig]].blood;
                        CheckDeath(nxt[nowpig],nowpig);
                    }
                    return 1;
                }
                break;
            }
        case 2:
            {
                if (pig[nxt[nowpig]].id==3)
                {
                    pig[nowpig].id=2;
                    pig[nowpig].looks_like=0;
                    ++has_killed;
                    if (!HaveDodge(nxt[nowpig]))
                    {
                        --pig[nxt[nowpig]].blood;
                        CheckDeath(nxt[nowpig],nowpig);
                    }
                    return 1;
                }
                break;
            }
        case 3:
            {
                if (pig[nxt[nowpig]].id==1||pig[nxt[nowpig]].id==2)
                {
                    pig[nowpig].id=3;
                    pig[nowpig].looks_like=0;
                    ++has_killed;
                    if (!HaveDodge(nxt[nowpig]))
                    {
                        --pig[nxt[nowpig]].blood;
                        CheckDeath(nxt[nowpig],nowpig);
                    }
                    return 1;
                }
                break;
            }
    }
    return 0;
}
void fight(int x,int y)
{
    while (1)
    {
        if (!HaveKill(x))
        {
            --pig[x].blood;
            CheckDeath(x,y);
            return;
        }
        if (!HaveKill(y))
        {
            --pig[y].blood;
            CheckDeath(y,x);
            return;
        }
    }
}
bool Duel()
{
    int type=Abs(pig[nowpig].id);
    switch(type)
    {
        case 1:
            {
                // 找一只离它最近的能决斗的 
                for (int i=nxt[nowpig];i!=nowpig;i=nxt[i])
                    if (pig[i].looks_like||pig[i].id==3)
                    {
                        //如果这只猪已经跳身份，判断有没有帮它打无懈可击的 
                        if (pig[i].id>0)
                        {
                            bool can_help=0;
                            int j=nxt[nowpig];
                            do
                            {
                                if (Help(j,i))
                                {
                                    can_help=1;
                                    break;
                                }
                                j=nxt[j];
                            }
                            while (j!=nxt[nowpig]);
                            if (can_help) return 1;
                        }
                        if(Abs(pig[i].id)==2)
                        {
                            --pig[i].blood;
                            CheckDeath(i,nowpig);
                            return 1;
                        }
                        fight(i,nowpig);
                        return 1;
                    }
                break;
            }
        case 2:
            {
                for (int i=nxt[nowpig];i!=nowpig;i=nxt[i])
                    if (pig[i].id==3)
                    {
                        pig[nowpig].id=2;
                        pig[nowpig].looks_like=0;
                        //如果这只猪已经跳身份，判断有没有帮它打无懈可击的 
                        if (pig[i].id>0)
                        {
                            bool can_help=0;
                            int j=nxt[nowpig];
                            do
                            {
                                if (Help(j,i))
                                {
                                    can_help=1;
                                    break;
                                }
                                j=nxt[j];
                            }
                            while (j!=nxt[nowpig]);
                            if (can_help) return 1;
                        }
                        fight(i,nowpig);
                        return 1;
                    }
                break;
            }
        case 3:
            {
                pig[nowpig].id=3;
                pig[nowpig].looks_like=0;
                //如果这只猪已经跳身份，判断有没有帮它打无懈可击的 
                if (pig[1].id>0)
                {
                    bool can_help=0;
                    int j=nxt[nowpig];
                    do
                    {
                        if (Help(j,1))
                        {
                            can_help=1;
                            break;
                        }
                        j=nxt[j];
                    }
                    while (j!=nxt[nowpig]);
                    if (can_help) return 1;
                }
                fight(1,nowpig);
                return 1;
                break;
            }
    }
    return 0;
}
void NanZhuRuQin()
{
    // 从出锦囊的这只猪的下一只猪开始依次结算
    for (int i=nxt[nowpig];i!=nowpig;i=nxt[i])
    {
        if (win) return;

        // 如果这只猪已经跳身份，判断有没有猪能帮它用锦囊 
        if (pig[i].id>0)
        {
            bool can_help=0;
            int j=nowpig;
            do
            {
                if (Help(j,i))
                {
                    can_help=1;
                    break;
                }
                j=nxt[j];
            }
            while (j!=nowpig);
            if (can_help) continue;
        }

        if (HaveKill(i)) continue;

        --pig[i].blood;
        if (pig[i].id==1&&pig[nowpig].id<0) pig[nowpig].looks_like=1;
        CheckDeath(i,nowpig);
    }
}
void WanJianQiFa()
{
    // 从出锦囊的这只猪的下一只猪开始依次结算  
    for (int i=nxt[nowpig];i!=nowpig;i=nxt[i])
    {
        if (win) return;

        // 如果这只猪已经跳身份，判断有没有猪能帮它用锦囊 
        if (pig[i].id>0)
        {
            bool can_help=0;
            int j=nowpig;
            do
            {
                if (Help(j,i))
                {
                    can_help=1;
                    break;
                }
                j=nxt[j];
            }
            while (j!=nowpig);
            if (can_help) continue;
        }

        if (HaveDodge(i)) continue;

        --pig[i].blood;
        if (pig[i].id==1&&pig[nowpig].id<0) pig[nowpig].looks_like=1;
        CheckDeath(i,nowpig);
    }
}
void Arrange(int x)
{
    int c[2005];c[0]=0;
    for (int i=1;i<=pig[x].cnt;++i)
        if (!pig[x].flag[i]) c[++c[0]]=pig[x].card[i];
    pig[x].cnt=c[0];
    for (int i=1;i<=pig[x].cnt;++i)
        pig[x].card[i]=c[i],pig[x].flag[i]=0;
}

int main()
{
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i)
    {
        char s[5];scanf("%s",s);
        if (s[0]=='M') pig[i].id=1;
        else if (s[0]=='Z') pig[i].id=-2;
        else pig[i].id=-3,++totFZ;

        pig[i].cnt=pig[i].blood=4;
        scanf(" %c %c %c %c\n",&pig[i].card[1],&pig[i].card[2],&pig[i].card[3],&pig[i].card[4]);
    }
    for (int i=1;i<=n;++i) pre[i]=i-1,nxt[i]=i+1;pre[1]=n;nxt[n]=1;
    for (int i=1;i<m;++i) scanf("%c ",&rest[i]);
    scanf("%c",&rest[m]);point=0;

    nowpig=1;
    while (1)
    {
        if (win) break;
        //begin the round
        has_killed=0;

        // 从牌堆中抽取2张牌，依次放到最右边
        GetCard(nowpig);GetCard(nowpig);

        for (int i=1;i<=pig[nowpig].cnt;++i)
        {
            if (win) break; 
            if (pig[nowpig].id==0) break; 
            if (pig[nowpig].flag[i]) continue;
            switch(pig[nowpig].card[i])
            {
                // 桃：如果血量不满，一定吃 
                case 'P':
                    {
                        if (pig[nowpig].blood<4)
                        {
                            ++pig[nowpig].blood;
                            pig[nowpig].flag[i]=1;
                            i=0;
                        }
                        break;
                    }
                // 杀 
                case 'K':
                    {
                        bool used=Killing();
                        if (used) pig[nowpig].flag[i]=1,i=0;
                        break;
                    }
                // 决斗 
                case 'F':
                    {
                        bool used=Duel();
                        if (used) pig[nowpig].flag[i]=1,i=0;
                        break;
                    }
                // 南猪入侵 
                case 'N':
                    {
                        pig[nowpig].flag[i]=1;
                        NanZhuRuQin();
                        i=0;
                        break;
                    }
                // 万箭齐发 
                case 'W':
                    {
                        pig[nowpig].flag[i]=1;
                        WanJianQiFa();
                        i=0;
                        break;
                    }
                // 猪哥连弩 
                case 'Z':
                    {
                        pig[nowpig].flag[i]=1;
                        if (!pig[nowpig].gun) pig[nowpig].gun=1,i=0;
                        break;
                    }
            }
        }
        //end the round
        for (int i=1;i<=n;++i)
            if (pig[i].id) Arrange(i);
        nowpig=nxt[nowpig];
    }

    if (win==1) puts("MP");
    else puts("FP");
    for (int i=1;i<=n;++i)
    {
        if (pig[i].id==0) puts("DEAD");
        else
        {
            for (int j=1;j<=pig[i].cnt;++j)
            {
                putchar(pig[i].card[j]);
                if (j==pig[i].cnt) putchar('\n');
                else putchar(' ');
            }
            if (!pig[i].cnt) puts(""); 
        }
    }
}

总结

开Warning