[Sdoi2010]猪国杀

[Sdoi2010]猪国杀

题目

我能说太长了不想粘吗QAQ——自己的幕布（比博客可读多了QAQ）

《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。

每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。

游戏目的

主猪（MP）：自己存活的情况下消灭所有的反猪。

忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。

反猪（AP）：杀死主猪。

游戏过程

游戏开始时候，每个玩家手里都会有 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++) 语言来帮他预测最后的结果

INPUT

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

OUTPUT

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

SAMPLE

INPUT

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

OUTPUT

FP

DEAD

DEAD

J J J J J D

解题报告

打了我多长时间，466行，9.32 KB，太可怕了太可怕了

不要相信鬼题面，牌堆没了一直抽最后一张就好了QAQ

看注释看注释，大模拟真的没啥可写的QAQ

虽然还是很恶心QAQ

#include<iostream>
#include<cstring>
#include<cstdio>
using namespace std;
char card[5005],paidui[5005],op[5];//card 所有牌 paidui 牌堆
int pre[5005],nxt[5005],cnt;//牌的链表
int top,bot,m,n;//top 牌堆顶 bot 读入时往牌堆里压
int sumf;//sumf 反贼数量
int zhugong;//主公
bool gameover;
inline char get_card(){
    if(top!=m)
        ++top;
    return paidui[top];//听说没牌了要一直摸最后一张
}
inline void kill(int,int);
inline void fight(int,int);
inline void nanman(int);
inline void wanjian(int);
inline void hurt(int,int);
inline void godie(int,int);
inline bool wuxiekeji(int,bool);
struct piggy{
    int id,appear,blood,num;//id 身份 1主公 2忠臣 3反贼 appear 跳的情况 0 没跳 1 类反 2跳忠 3跳反 num 几号
    int nump,numk,numd,numf,numn,numw,numj;//各牌的数量 p 桃 k 杀 d 闪 f 决斗 n 南蛮 w 万箭 j 无懈
    bool zhuge,dead;//诸葛 死没死
    int prepig,nxtpig,head,last,now,tmp;//链表 牌的链表
    int attack;//首要攻击目标
    piggy():appear(0),blood(4),nump(0),numk(0),numd(0),numf(0),numn(0),numw(0),numj(0),head(0),last(0),now(0),attack(0){}
    inline void mopai(){//摸一张牌
        card[++cnt]=get_card();
        pre[cnt]=last;
        if(!head)head=last=cnt;
        else nxt[last]=cnt,last=cnt;//更新链表
        if(card[cnt]=='P')++nump;
        if(card[cnt]=='K')++numk;
        if(card[cnt]=='D')++numd;
        if(card[cnt]=='F')++numf;
        if(card[cnt]=='N')++numn;
        if(card[cnt]=='W')++numw;
        if(card[cnt]=='J')++numj;
    }
    inline void award(){//杀一个的奖励
        mopai(),mopai(),mopai();
    }
    inline void punish(){//杀错的惩罚
        head=last=now=nump=numk=numd=numf=numn=numw=numj=0;
        zhuge=false;
    }
    inline void mopaistage(){//摸牌阶段
        mopai(),mopai();
    }
    inline void use(int x){//打出一张牌
        if(card[x]=='P')--nump;
        if(card[x]=='K')--numk;
        if(card[x]=='D')--numd;
        if(card[x]=='F')--numf;
        if(card[x]=='N')--numn;
        if(card[x]=='W')--numw;
        if(card[x]=='J')--numj;
        if(x==head&&x==last)head=last=0;
        else
            if(x==head)
                head=nxt[x],pre[head]=0;
            else
                if(x==last)
                    last=pre[x],nxt[last]=0;
                else
                    pre[nxt[x]]=pre[x],nxt[pre[x]]=nxt[x];//更新链表
    }
    inline char get_nxt(){//找下一张牌
        if(!now)return 0;
        tmp=now;
        now=nxt[now];
        return card[tmp];
    }
    inline int findp(){//找桃
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='P')
                return tmp;
    }
    inline int findk(){//找杀
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='K')
                return tmp;
    }
    inline int findd(){//找闪
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='D')
                return tmp;
    }
    inline int findf(){//找决斗
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='F')
                return tmp;
    }
    inline int findn(){//找南蛮
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='N')
                return tmp;
    }
    inline int findw(){//找万箭
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='W')
                return tmp;
    }
    inline int findj(){//找无懈
        now=head;
        char tp;
        while(tp=get_nxt())
            if(tp=='J')
                return tmp;
    }
    inline bool qiup(){//尝试出桃，返回是否出成桃
        if(nump){
            use(findp());
            return true;
        }
        return false;
    }
    inline bool qiuk(){//尝试出杀
        if(numk){
            use(findk());
            return true;
        }
        return false;
    }
    inline bool qiud(){//尝试出闪
        if(numd){
            use(findd());
            return true;
        }
        return false;
    }
    inline bool qiuf(){//尝试出决斗
        if(numf){
            use(findf());
            return true;
        }
        return false;
    }
    inline bool qiun(){//尝试出南蛮
        if(numn){
            use(findn());
            return true;
        }
        return false;
    }
    inline bool qiuw(){//尝试出万箭
        if(numw){
            use(findw());
            return true;
        }
        return false;
    }
    inline bool qiuj(){//尝试出无懈
        if(numj){
            use(findj());
            return true;
        }
        return false;
    }
    inline void round(){//回合
        mopaistage();
//      cout<<"mopai is over "<<cnt<<endl;
        now=head;
        char tp;
        bool usedsha(false);
        while((tp=get_nxt())&&!gameover){
//          cout<<"now the card is "<<tp<<endl;
            if(tp=='D'||tp=='J')continue;
            if(tp=='P'){
                if(blood<4)
                    ++blood,use(tmp);
                continue;
            }
            if(tp=='K'){
                if(attack==nxtpig){
                    if(!usedsha||zhuge){
                        use(tmp);
                        kill(num,attack);
                        usedsha=true;
                        now=head;
                        if(gameover)return;
                    }
                }
                continue;
            }
            if(tp=='F'){
                if(!attack)continue;
                use(tmp);
                if(id==3)fight(num,1);
                else fight(num,attack);
                now=head;
                if(gameover||dead)return;//决斗可以自杀
                continue;
            }
            if(tp=='N'){
                use(tmp);
                nanman(num);
                now=head;
                if(gameover)return;
                continue;
            }
            if(tp=='W'){
                use(tmp);
                wanjian(num);
                now=head;
                if(gameover)return;
                continue;
            }
            if(tp=='Z'){
                use(tmp);
                zhuge=true;
                now=head;//从头开始出，因为诸葛可以让前面的杀出来，前面的也是这个作用
                continue;
            }
        }
    }
    inline void print(){
        if(dead)puts("DEAD");
        else{
            while(head){
                printf("%c",card[head]);
                if(head!=last)putchar(' ');
                head=nxt[head];
            }
            puts("");
        }
    }
}a[15];
inline void cal_attack(int x){//计算攻击目标
    int y(a[x].nxtpig);
    if(a[x].id==1){
        while(y!=x){
            if(a[y].appear==1||a[y].appear==3){
                a[x].attack=y;
                return;
            }
            y=a[y].nxtpig;
        }
    }
    if(a[x].id==2){
        while(y!=x){
            if(a[y].appear==3){
                a[x].attack=y;
                return;
            }
            y=a[y].nxtpig;
        }
    }
    if(a[x].id==3){
        while(y!=x){
            if(a[y].appear==2||a[y].id==1){
                a[x].attack=y;
                return;
            }
            y=a[y].nxtpig;
        }
    }
    a[x].attack=0;
}
inline void allcal(){//所有猪计算一遍
    int x(a[zhugong].nxtpig);
    cal_attack(zhugong);
    while(x!=zhugong){
        cal_attack(x);
        x=a[x].nxtpig;
    }
}
inline void hurt(int x,int y){//x对y造成伤害
    --a[y].blood;
//  cout<<"now "<<x<<" hurt "<<y<<endl;
    if(!a[y].blood){
        if(a[y].qiup())++a[y].blood;
        else godie(x,y);
    }
}
inline void godie(int x,int y){//x杀死了y
    a[y].dead=true;
    if(a[y].id==1){
        gameover=true;
        return;
    }
    if(a[y].id==3){
        --sumf;
        if(!sumf){
            gameover=true;
            return;
        }
        a[x].award();
    }
    if(a[y].id==2&&a[x].id==1)
        a[x].punish();
    a[a[y].prepig].nxtpig=a[y].nxtpig;
    a[a[y].nxtpig].prepig=a[y].prepig;
    allcal();
}
inline void kill(int x,int y){//x对y使用了一张杀
    if(a[x].id!=1&&a[x].appear<2){
        if(a[y].id==3)a[x].appear=2;
        else a[x].appear=3;
        allcal();
    }
    if(a[y].qiud())return;
    hurt(x,y);
}
inline void fight(int x,int y){//x对y决斗
    if(a[x].id!=1&&a[x].appear<2){
        if(a[y].id==3)a[x].appear=2;
        else a[x].appear=3;
        allcal();
    }
    if(a[y].id==1||a[y].appear==2)
        if(wuxiekeji(x,0))
            return;
    if(a[y].appear==3)
        if(wuxiekeji(x,1))
            return;
    if(a[x].id==1&&a[y].id==2){
        hurt(x,y);
        return;
    }
    while(1){
        if(!a[y].qiuk()){
            hurt(x,y);
            return;
        }
        if(!a[x].qiuk()){
            hurt(y,x);
            return;
        }
    }
}
inline void nanman(int x){//x使用了南蛮
    int y(a[x].nxtpig);
//  cout<<"now "<<x<<" is nanmaning"<<endl;
    while(y!=x){
        if(a[y].id==1||a[y].appear==2)
            if(wuxiekeji(x,0)){
//              cout<<"wuxiekeji "<<y<<endl;
                y=a[y].nxtpig;
                continue;
            }
        if(a[y].appear==3)
            if(wuxiekeji(x,1)){
//              cout<<"wuxiekeji "<<y<<endl;
                y=a[y].nxtpig;
                continue;
            }
        if(!a[y].qiuk()){
            hurt(x,y);
            if(gameover)return;
            if(y==1&&a[x].appear==0){
                a[x].appear=1;
                allcal();
            }
        }
        y=a[y].nxtpig;
    }
}
inline void wanjian(int x){//x使用了万箭
    int y(a[x].nxtpig);
    while(y!=x){
        if(a[y].id==1||a[y].appear==2)
            if(wuxiekeji(x,0)){
                y=a[y].nxtpig;
                continue;
            }
        if(a[y].appear==3)
            if(wuxiekeji(x,1)){
                y=a[y].nxtpig;
                continue;
            }
        if(!a[y].qiud()){
            hurt(x,y);
            if(gameover)return;
            if(y==1&&a[x].appear==0){
                a[x].appear=1;
                allcal();
            }
        }
        y=a[y].nxtpig;
    }
}
inline bool wuxiekeji(int pos,bool fan){
    bool st(fan);
    int last(pos),x(pos);
    if(fan==(a[x].id==3)){
        if(a[x].qiuj()){
            last=x;
            fan=!fan;
            if(a[x].appear<=2){
                a[x].appear=3-fan;
                allcal();
            }
        }
    }
    x=a[x].nxtpig;
    while(x!=last){
        if(fan==(a[x].id==3)){
            if(a[x].qiuj()){
                last=x;
                fan=!fan;
                if(a[x].appear<=2){
                    a[x].appear=3-fan;
                    allcal();
                }
            }
        }
        x=a[x].nxtpig;
    }
    return st!=fan;
}
int main(){
    scanf("%d%d",&n,&m);
    for(int i=1;i<=n;++i)
        a[i].prepig=i-1,a[i].nxtpig=i+1;
    a[1].prepig=n,a[n].nxtpig=1;
    for(int i=1;i<=n;++i){
        scanf("%s",op);
        if(op[0]=='M')a[i].id=1,zhugong=i;
        if(op[0]=='Z')a[i].id=2;
        if(op[0]=='F')a[i].id=3,++sumf;
        for(int j=1;j<=4;++j){
            scanf("%s",op);
            paidui[++bot]=op[0];
        }
    }
    for(int i=1;i<=m;++i){
        scanf("%s",op);
        paidui[++bot]=op[0];
    }
    m+=(n<<2);
    for(int i=1;i<=n;++i){
        a[i].mopaistage();
        a[i].mopaistage();
        a[i].num=i;
    }
    allcal();
    int now(1);
    while(!gameover){
//      cout<<"now start "<<now<<" turn"<<endl;
        a[now].round();
        now=a[now].nxtpig;
//      cout<<"check the blood"<<endl;
//      for(int i=1;i<=n;++i)
//          cout<<i<<" is "<<((a[i].dead)?"dead\0":"live\0")<<" blood "<<a[i].blood<<endl;
    }
    if(a[zhugong].dead)puts("FP");
    else puts("MP");
    for(int i=1;i<=n;++i)
        a[i].print();
}