洛谷 P2482 loj #2885 [SDOI2010]猪国杀 题解【模拟】【贪心】【搜索】

好玩的模拟题。

以后要经常写模拟题鸭

题目描述

游戏背景

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

游戏目的

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

游戏过程

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

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

每个玩家自己的回合可以分为\(2\)个阶段：

• 摸牌阶段：从牌堆顶部摸\(2\)张牌，依次放到手牌的最右边；
• 出牌阶段：你可以使用任意张牌，每次使用牌的时候都使用最靠左的能够使用的牌。当然，要满足如下规则：
  1. 如果没有猪哥连弩，每个出牌阶段只能使用\(1\)次「杀」来攻击；
  2. 任何牌被使用后被弃置（武器是装备上）；被弃置的牌以后都不能再用，即与游戏无关。

各种牌介绍

每张手牌用\(1\)个字母表示，字母代表牌的种类。

基本牌

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

锦囊牌

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

装备牌

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

特殊事件及概念解释

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

现在，我们已经知道每只猪的角色、手牌，还有牌堆初始情况，并且假设每个角色会按照如下的行为准则进行游戏，你需要做的就是告诉小猪 iPig 最后的结果。

几种行为

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

注意：忠猪不会跳反，反猪也不会跳忠；不管是忠猪还是反猪，能够跳必然跳。

行动准则

共性

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

特性

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

限于 iPig 只会用 P++ 语言写 A + B，他请你用 Pigcal (Pascal)、P (C) 或 P++ (C++) 语言来帮他预测最后的结果。

输入格式

输入文件第一行包含两个正整数\(n(2\leqslant n\leqslant10)\)和\(m(m\leqslant 2000)\)，分别代表玩家数和牌堆中牌的数量。数据保证牌的数量够用。

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

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

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

输出格式

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

接下来\(n\)行，第\(i\)行是对第\(i\)只猪的手牌描述（注意只需要输出手牌），按照手牌从左往右的顺序输出，相邻两张牌用\(1\)个空格隔开，行末尾没有多余空格。如果这只猪已阵亡，那么只要输出 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

样例输出

FP
DEAD
DEAD
J J J J J J D

样例解释

第一回合：

• 主猪没有目标可以表敌意；
• 接下来忠猪使用了\(3\)张南猪入侵，主猪掉了\(3\)点体力，并认为该角色为类反猪，\(3\)号角色尽管手里有无懈可击，但是因为自己未表明身份，所以同样不能对自己用，乖乖掉\(3\)点体力；

下一回合：

• 反猪无牌可出；
• 接下来主猪对着类反猪爆发，使用\(4\)张决斗，忠猪死亡，结果主猪弃掉所有牌；
• 接下来反猪摸到\(1\)张杀直接杀死主猪获胜。

数据范围与提示

一共\(20\)组测试数据，每个点\(5\)分。

\(10\%\)的数据没有锦囊牌，另外\(20\%\)的数据没有无懈可击。

题面可真够长的。

题解

模拟即可。

---

以上就是题解，但是写博客的目的是把这个题的坑点和注意事项记录下来。毕竟是写了快一天的题。

因为有很多小操作都需要重复执行，因此写很多函数一定没有什么坏处。

同时当判断条件很多时，最好把它们写在同一个if里，使得{}里的内容不至于重复多次。

• 当决斗被无懈可击抵消掉时，该决斗也算表敌意。
• 反猪可以对主猪使用无懈可击来表敌意，每头猪对「逆时针方向可以执行到的第一只猪/类反猪」表敌意的方式只有杀/决斗。
• std::vector中删除元素v[i]（复杂度\(O(size)\)）的方式是v.erase(v.begin()+i)。
• 本题中，最下面一张牌有无限张。
• 回合中可能被自己砍死，这也是判断回合结束的条件。
• 每次使用一张牌后，都要从头开始找下一张可用的牌开始使用。
• 杀只有在被使用后，才能受每回合只能出一张杀的影响。
• 忠猪在主猪的决斗面前无缚鸡之力。

Code：

#include<cstdio>
#include<cstring>
#include<cstdlib>
#include<map>
#include<vector>
#include<iostream>
using namespace std;
map<string,int> mp;
int n,m;
int id[11],tid[11],f[11];
//真实身份 是否类 跳出的身份 0表示没跳
int hp[11],z[11];
//血量 是否装备猪哥连弩
vector<int> card[11];
// 1桃 2杀 3闪 4决 5南 6万 7无 8弩
int c[2010],t=0;
string s;
string cd[10]={"","P","K","D","F","N","W","J","Z"};
void k(int p)
{
    for(int i=0;i<card[p].size();++i)
        if(card[p][i]==3)
        {
            card[p].erase(card[p].begin()+i);
            return;
        }
    --hp[p];
}
bool wx(int from,int p,int ty)//ty=0 献殷勤 ty=1 表敌意
{
    int flag=0;
    for(int i=(from-1)%n+1;!flag||i!=from;i=i%n+1)
    {
        if(!hp[i])
            continue;
        flag=1;
        if(id[i]==1)
        {
            if((ty==0&&f[p]==3)||(ty==1&&(f[p]==1||f[p]==2)))//无懈掉对反的殷勤
                for(int j=0;j<card[i].size();++j)
                    if(card[i][j]==7)
                    {
                        card[i].erase(card[i].begin()+j);
                        --j;
                        if(wx(i,p,ty==0&&f[p]==3))
                            continue;
                        return true;
                    }
        }
        if(id[i]==2)//忠无懈掉对主的敌意 无视掉对反的殷勤 无视很重要
        {
            if(ty==1&&(f[p]==1||f[p]==2))
                for(int j=0;j<card[i].size();++j)
                    if(card[i][j]==7)
                    {
                        card[i].erase(card[i].begin()+j);
                        --j;
                        f[i]=id[i];
                        if(wx(i,p,0))
                            continue;
                        return true;
                    }
        }
        if(id[i]==3)//反无懈掉对反的敌意
        {
            if((ty==1&&f[p]==3)||(ty==0&&f[p]==1))
                for(int j=0;j<card[i].size();++j)
                    if(card[i][j]==7)
                    {
                        card[i].erase(card[i].begin()+j);
                        --j;
                        f[i]=id[i];
                        if(wx(i,p,ty==0&&f[p]==1))
                            continue;
                        return true;
                    }
        }
    }
    return false;
}
bool jd(int x,int y)
{
    if(id[x]==2&&id[y]==1)
    {
        --hp[x];
        return true;
    }
    if(id[x]==1&&id[y]==2)
    {
        --hp[y];
        return false;
    }
    while(1)
    {
        int flag=0;
        for(int i=0;i<card[x].size();++i)
            if(card[x][i]==2)
            {
                card[x].erase(card[x].begin()+i);
                flag=1;
                break;
            }
        if(!flag)
        {
            --hp[x];
            return true;
        }

        flag=0;
        for(int i=0;i<card[y].size();++i)
            if(card[y][i]==2)
            {
                card[y].erase(card[y].begin()+i);
                flag=1;
                break;
            }
        if(!flag)
        {
            --hp[y];
            return false;
        }
    }
}
bool heal(int p)
{
    for(int i=0;i<card[p].size();++i)
        if(card[p][i]==1)
        {
            card[p].erase(card[p].begin()+i);
            ++hp[p];
            return true;
        }
    return false;
}
void out()
{
    for(int i=1;i<=n;++i)
        if(!hp[i])
            puts("DEAD");
        else
        {
            for(int j=0;j<card[i].size();++j)
                cout<<cd[card[i][j]]<<" ";
            puts("");
        }
}
bool win()
{
    //是否胜利
    if(!hp[1])
    {
        puts("FP");
        out();
        exit(0);
    }
    for(int i=1;i<=n;++i)
        if(id[i]==3&&hp[i]>0)
            return false;
    puts("MP");
    out();
    exit(0);
}
void die(int from,int p)//伤害来源和濒死者
{
    while(hp[p]<=0)
    {
        if(!heal(p))
        {
            //ta挂了
            win();//判断是否胜利
            if(id[p]==3)
                for(int qaq=1;qaq<=3;++qaq)
                    card[from].push_back(c[++t]);//
            else if(id[from]==1&&id[p]==2)
            {
                card[from].clear();
                z[from]=0;
            }
            break;
        }
    }
}
void debug()
{
    for(int i=1;i<=n;++i)
    {
        for(int j=0;j<card[i].size();++j)
            cout<<cd[card[i][j]]<<" ";
        puts("");
    }
    puts("--------------");
}
int main()
{
    f[1]=1;
    mp["MP"]=1,mp["ZP"]=2,mp["FP"]=3;
    mp["P"]=1,mp["K"]=2,mp["D"]=3,mp["F"]=4;
    mp["N"]=5,mp["W"]=6,mp["J"]=7,mp["Z"]=8;
    cin>>n>>m;
    for(int i=1;i<=n;++i)
    {
        cin>>s;
        id[i]=mp[s];
        hp[i]=4;
        for(int j=1;j<=4;++j)
        {
            cin>>s;
            card[i].push_back(mp[s]);
        }
    }
    for(int i=1;i<=m;++i)
    {
        cin>>s;
        c[i]=mp[s];
    }
    int p=1;
    while(1)
    {
        card[p].push_back(c[++t]);
        if(t==m)
            --t;
        card[p].push_back(c[++t]);
        if(t==m)
            --t;
        int flag=0;
        for(int i=0;hp[p]&&i<card[p].size();++i)//
        {
            if(card[p][i]==1&&hp[p]<4)//桃
            {
                card[p].erase(card[p].begin()+i);
                i=-1;
                ++hp[p];
            }
            else if(card[p][i]==2&&(!flag||z[p]))//杀
            {
                int j=p%n+1;
                while(!hp[j]&&j!=p)
                    j=j%n+1;
                if((id[p]==1&&(f[j]==3||(f[j]==0&&tid[j])))||(id[p]==2&&f[j]==3)||(id[p]==3&&(f[j]==1||f[j]==2)))
                {
                    flag=1;
                    card[p].erase(card[p].begin()+i);
                    i=-1;
                    k(j);
                    f[p]=id[p];//用了杀就算跳了
                    if(hp[j]<=0)
                        die(p,j);
                }
            }
            else if(card[p][i]==4)
            {
                for(int j=p%n+1;j!=p;j=j%n+1)
                    if(hp[j]>0&&((id[p]==1&&(f[j]==3||(f[j]==0&&tid[j])))||(id[p]==2&&f[j]==3)||id[p]==3))
                    {
                        if(id[p]==3)
                            j=1;
                        card[p].erase(card[p].begin()+i);
                        i=-1;
                        f[p]=id[p];//没用出去也算跳
                        if(wx(p,j,1))
                            break;
                        if(jd(j,p))//j输了
                        {
                            if(hp[j]<=0)
                                die(p,j);
                        }
                        else
                        {
                            if(hp[p]<=0)
                                die(j,p);
                        }
                        break;
                    }
            }
            else if(card[p][i]==5||card[p][i]==6)//南
            {
                int tmp=card[p][i];
                card[p].erase(card[p].begin()+i);
                i=-1;
                for(int j=p%n+1;j!=p;j=j%n+1)
                    if(hp[j])
                    {
                        if(wx(p,j,1))
                            continue;
                        int qaq=0;
                        for(int k=0;k<card[j].size();++k)
                            if(card[j][k]==tmp-3)
                            {
                                card[j].erase(card[j].begin()+k);
                                qaq=1;
                                break;
                            }
                        if(qaq)
                            continue;
                        --hp[j];
                        if(j==1)
                            tid[p]=1;
                        if(hp[j]<=0)
                            die(p,j);
                    }
            }
            else if(card[p][i]==8)
            {
                card[p].erase(card[p].begin()+i);
                i=-1;
                z[p]=1;
            }
        }
        p=p%n+1;
        while(!hp[p])
            p=p%n+1;
    }
    return 0;
}