洛谷P2482 [SDOI2010]猪国杀

题目：https://www.luogu.org/problemnew/show/P2482

题目描述

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

游戏目的：

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

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

反猪（AP）：杀死主猪。

游戏过程：

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

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

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

◎摸牌阶段：从牌堆顶部摸两张牌，依次放到手牌的最右边；

◎出牌阶段：你可以使用0张到任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。当然，要满足如下规则：

1.如果没有猪哥连弩，每个出牌阶段只能使用一次“杀”来攻击；

2.任何牌被使用后被弃置（武器是装备上）；

被弃置的牌以后都不能再用，即与游戏无关；

各种牌介绍：

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

◎基本牌：

『桃(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 <= 5) （这地方数据范围错误应该开到至少20吧）和m( m <= 2000)，分别代表玩家数和牌堆中牌的数量。数据保证牌的数量够用。（实际上，牌不够用时要一直摸最后一张）

接下来n行，每行5个字符串，依次表示对第i只猪的角色和初始4张手牌描述。编号为1的肯定是主猪。

再接下来一行，一共m个字符串，按照从牌堆顶部到牌堆底部的顺序描述每张牌。

所有的相邻的两个字符串都严格用1个空格隔开，行尾没有多余空格。

 

输出格式：

 

输出数据第一行包含一个字符串代表游戏结果。如果是主猪胜利，那么输出“MP”，否则输出“FP”。数据保证游戏总会结束。

接下来n行，第i行是对第i只猪的手牌描述（注意只需要输出手牌），按照手牌从左往右的顺序输出，相邻两张牌用一个空格隔开，行末尾没有多余空格。如果这只猪已阵亡，那么只要输出“DEAD”即可。注意如果要输出手牌而没有手牌的话，那么只需输出一个空行。

 

输入输出样例

输入样例#1： 

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

输出样例#1： 

FP
DEAD
DEAD
J J J J J J D

说明

样例1说明：第一回合主猪没有目标可以表敌意；接下来忠猪使用了3张南猪入侵，主猪掉了3点体力，并认为该角色为类反猪，3号角色尽管手里有无懈可击，但是因为自己未表明身份，所以同样不能对自己用，乖乖掉3点体力；下一回合反猪无牌可出；接下来主猪对着类反猪爆发，使用4张决斗，忠猪死亡，结果主猪弃掉所有牌；下来反猪摸到一张杀直接杀死主猪获胜。

数据说明：一共20组测试数据，每个点5分。10%的数据没有锦囊牌，另外20%的数据没有无懈可击

 

解析

这道题我真的没啥话可说了。

首先，题面有错误。

①玩家不止5个，尽量开大点吧。

②牌可能不够用，要一直摸最后一张。

其次，这道题考察代码能力和读题水平非常高。

下面总结几个坑点（自己+其他大佬）：

①弃牌要弃装备。

②如果一个人打出无懈可击，则从他开始询问是否无懈无懈可击。

③一个人每打出一张牌，要重新从他的第一张手牌判断是否可以打出，因为aoe技能会导致一些人跳身份，决斗或者杀会影响距离，诸葛会使得可以用前面的杀。

④对他人决斗可能导致自己死亡，要及时终止出牌阶段。

⑤题目中的距离与平常意义上的距离不一样，是逆时针旋转的距离。

⑥.反贼的决斗都会直接打向主公。

⑦出锦囊的人是有可能无懈掉这个锦囊的。

⑧别人对你出决斗/aoe技能，你可能因自己没有亮身份而不使用无懈可击。

⑨无懈可击出了，身份就亮了。

⑩（个人的）判断决斗时，有三种情况，要用int不能用bool。

模拟的巅峰。

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#include<queue>
#include<vector>
using namespace std;
#define maxn 20100
struct pig{
    bool rebel,sim_rebel;
    bool jumped;
    int hp;
    bool zhuge;
    int hands;
    char hand[maxn];
    bool used[maxn];
}player[30];
int n,m;
char restring[maxn];
int rebel_tot;
int now_paidui=1; 
char paidui[maxn];
int gameover=0;
char rech;
void renew_hand(int p){
    int now_h=0,mac=player[p].hands;
    for (int i=1;i<=mac;++i){
        if (player[p].used[i]) continue;
        player[p].hand[++now_h]=player[p].hand[i];
        player[p].used[now_h]=false;
    }
    player[p].hands=now_h;
}
void get_card(int p,int js){
    if (gameover!=0) return;
    for (int i=1;i<=js;++i){
        player[p].hand[++player[p].hands]=paidui[now_paidui];
        player[p].used[player[p].hands]=false;
        now_paidui++;
        if (now_paidui==m+1) now_paidui=m;
    }
}
int get_dis(int a,int b){
    int ans=0;
    while (a!=b){
        ++a;
        if (a==n+1) a=1;
        if (player[a].hp) ++ans;
    }
    return ans;
}
bool useable(int p,char ch){
    for (int i=1;i<=player[p].hands;++i){
        if (player[p].used[i]) continue;
        if (player[p].hand[i]==ch){
            player[p].used[i]=true;
            return true;
        }        
    }
    return false;
}
bool missable(int p){
    return useable(p,'D');
}
bool naiable(int p){
    return useable(p,'P');
}
bool shaable(int p){
    return useable(p,'K');
}
bool wuxieable(int p){
    if (useable(p,'J')){
        player[p].jumped=true;
        return true;
    }
    return false;
}
void gg(int v,int u){
    if (v==1){
        gameover=2;
        return;
    }
    if (player[v].rebel){
        rebel_tot--;
        if (rebel_tot==0){
            gameover=1;
            return;
        }
        get_card(u,3);
        return;
    }
    if ((!player[v].rebel&&v!=1)&&(u==1)){
        player[u].hands=0;
        player[u].zhuge=false;
    }
}
void diaoxie(int v,int u){
    player[v].hp--;
    if (player[v].hp==0){
        if (naiable(v)) player[v].hp++;
        else gg(v,u);
    }
}
bool nilaia(int u,bool ident){
    int now=u;
    do{
        if (player[now].hp&&player[now].rebel==ident){
            if (wuxieable(now)){
                if (!nilaia(now,!ident)) return true;
                else return false;
            }
        }
        now++;
        if (now==n+1) now=1;
    }while (now!=u);
    return false;
}
bool gun(int v,int u){ //wuxiekeji
    if (!player[v].jumped&&v!=1) return false;
    if (nilaia(u,player[v].rebel)) return true;
    return false;
}
bool killable(int p){
    if (player[p].rebel){
        if (get_dis(p,1)==1){
            player[p].jumped=true;
            if (!missable(1)) diaoxie(1,p);
            return true;
        }
    }
    if (p==1){
        for (int i=2;i<=n;++i){
            if (player[i].hp){
                if ((player[i].rebel&&player[i].jumped)||(player[i].sim_rebel&&!player[i].jumped)){
                    if (get_dis(p,i)==1){
                        if (!missable(i)) diaoxie(i,p);
                        return true;
                    }
                }
            }
        }
    }else{
        int now=p+1;
        if (now==n+1) now=1;
        while (now!=p){ 
            if (player[now].hp<=0){
                now++;
                if (now==n+1) now=1;
                continue;
            }
            if ((player[now].rebel!=player[p].rebel)&&player[now].jumped){
                if (get_dis(p,now)==1){
                    player[p].jumped=true;
                    if (!missable(now)) diaoxie(now,p);
                    return true;
                }
            } 
            now++;
            if (now==n+1) now=1;
        }
    }
    return false;
}
int duel_judge(int v,int u){
    if ((!player[v].rebel&&v!=1)&&u==1) return 1;
    if (gun(v,u)) return 2;
    while (true){
        if (!shaable(v)) return 1;
        if (!shaable(u)) return 0;
    }
}
bool duelable(int p){
    if (player[p].rebel){
        player[p].jumped=true;
        int sid=duel_judge(1,p);
        if (sid==1) diaoxie(1,p);
        else if (sid==0) diaoxie(p,1);
        return true;
    }
    if (p==1){
        for (int i=2;i<=n;++i){
            if (player[i].hp){
                if ((player[i].rebel&&player[i].jumped)||(player[i].sim_rebel&&!player[i].jumped)){
                    int sid=duel_judge(i,p);
                    if (sid==1) diaoxie(i,p);
                    else if (sid==0) diaoxie(p,i);
                    return true;
                }
            }
        }
    }else{
        int now=p+1;
        if (now==n+1) now=1;
        while (now!=p){
            if (player[now].hp<=0){
                now++;
                if (now==n+1) now=1;
                continue;
            }
            if ((player[now].rebel!=player[p].rebel)&&player[now].jumped){
                player[p].jumped=true;
                int sid=duel_judge(now,p);
                if (sid==1) diaoxie(now,p);
                else if (sid==0) diaoxie(p,now);
                return true;
            }
            now++; 
            if (now==n+1) now=1;
        }
    }
    return false;
}
void cuo_ding(int p,int kinds){
    if (gameover!=0) return;
    int now=p+1;
    if (now==n+1) now=1;
    while (now!=p){
        if (player[now].hp<=0){
            now++;
            if (now==n+1) now=1;
            continue;
        }
        if (gun(now,p)){
            now++;
            if (now==n+1) now=1;
            continue;
        }
        if (kinds==1){
            if (!shaable(now)){
                if (now==1) player[p].sim_rebel=true;
                diaoxie(now,p);
            }
        }else{
            if (!missable(now)){
                if (now==1) player[p].sim_rebel=true;
                diaoxie(now,p);
            }
        }
        if (gameover!=0) return;
        now++;
        if (now==n+1) now=1;
    }
}
void chupai(int p){
    bool chusha=false;
    for (int i=1;i<=player[p].hands;++i){
        if (gameover!=0||player[p].hp<=0) return;
        if (player[p].used[i]) continue;
        if (player[p].hand[i]=='P'){
            if (player[p].hp<4){
                player[p].hp++;
                player[p].used[i]=true;
                i=0;
            }
        }
        else if (player[p].hand[i]=='K'&&(!chusha||player[p].zhuge)){
            if (killable(p)){
                chusha=true;
                player[p].used[i]=true;
                i=0;
            }
        }
        else if (player[p].hand[i]=='F'){
            if (duelable(p)){
                player[p].used[i]=true;
                if (player[p].hp<=0) return;
                i=0;
            }
        }
        else if (player[p].hand[i]=='Z'){
            player[p].used[i]=true;
            if (player[p].zhuge) continue;
            player[p].zhuge=true;
            i=0;
        }
        else if (player[p].hand[i]=='N'){
            player[p].used[i]=true;
            cuo_ding(p,1); //sha
            i=0;
        }
        else if (player[p].hand[i]=='W'){
            player[p].used[i]=true;
            cuo_ding(p,2); //shan
            i=0;
        }
        if (gameover!=0) return;
    }
}
void start_your_performance(int p){
    if (gameover!=0) return;
    renew_hand(p);
    get_card(p,2);
    chupai(p);
}
void zai_lai_yi_ju(){
    for (int i=1;i<=n;++i){
        if (player[i].hp>=1&&gameover==0){
            start_your_performance(i);
        }
    }
}
void da_ji_da_li_jin_wan_chi_ji(){
    if (gameover==1) printf("MP\n");
    else printf("FP\n");
    for (int i=1;i<=n;++i){
        if (player[i].hp<=0){
            printf("DEAD\n");
            continue;
        }
        renew_hand(i);
        for (int j=1;j<=player[i].hands;++j){
            printf("%c ",player[i].hand[j]);
        }
        printf("\n");
    }
}
int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;++i){
        memset(player[i].hand,0,sizeof(player[i].hand));
        player[i].hands=0;
        player[i].hp=4;
        player[i].jumped=player[i].rebel=player[i].sim_rebel=player[i].zhuge=false;
        memset(player[i].used,false,sizeof(player[i].used));
    }
    for (int i=1;i<=n;++i){
        cin>>rech;
        while (rech<'A'||rech>'Z') cin>>rech,cout<<rech<<endl;
        if (rech=='F'){
            ++rebel_tot;
            player[i].rebel=true;
        }
        cin>>rech;
        for (int j=1;j<=4;++j){
            cin>>rech;
            while (rech<'A'||rech>'Z') cin>>rech;
            player[i].hand[j]=rech;
        }
        player[i].hands=4;
        player[i].hp=4;
    }
    for (int i=1;i<=m;++i){
        cin>>rech;
        while (rech<'A'||rech>'Z') cin>>rech;
        paidui[i]=rech;
    }
    while (gameover==0){
        zai_lai_yi_ju();
    }
    da_ji_da_li_jin_wan_chi_ji();
    return 0;
}