洛谷2482猪国杀

P2482 [SDOI2010] 猪国杀

题目描述

游戏背景

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

游戏目的

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

游戏过程

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

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

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

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

各种牌介绍

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

基本牌

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

锦囊牌

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

装备牌

『猪哥连弩 / $\texttt{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 \leqslant 10) $ 和 $m$ $ (m \leqslant 2000) $，分别代表玩家数和牌堆中牌的数量。数据保证牌的数量够用。

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

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

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

输出格式

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

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

注意：如果要输出手牌而没有手牌的话，那么只需输出 $1$ 个空行。

由于数据问题，若牌堆已空，按照每次抽牌抽到的都是最后一张。

输入输出样例 #1

输入 #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

说明/提示

样例解释

第一回合：

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

下一回合：

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

子任务

一共 $20$ 组测试数据，每个点 $5$ 分。

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

一道超级大模拟题目，想要写出来至少需要几天。一下是答案及注释

// 注释想到哪写到哪吧
#include <bits/stdc++.h>
using namespace std;
struct node {
    int cs,hp,next,last;//cs是手牌最大下标，hp是血量，next下一位，last上一位
    char id,card[2010];//M主公 Z忠臣 F反贼，card'U'代表废牌
    bool zgln;//是否装备诸葛连弩
}a[20];
char kn[11],kpd[2010],sss[10];
//kn：公开跳身份 U未跳 M主 Z忠 F反 L类反；kpd全局牌堆；sss输入缓存
int n,m,fz;//玩家数、初始牌堆数量、存活反贼计数
bool ed;//游戏结束标记 true=结束

void mp(int x) {
    //摸一张牌，牌堆空则永久摸最后一张
    if (!m) m++;
    a[x].card[++a[x].cs] = kpd[m];
    m--;
}

void js(int x1,int x2) {
    //濒死结算：x2濒死，x1是伤害来源，先吃桃救回，救不回执行死亡处理
    for (int i=1;i<=a[x2].cs;i++) {
        if (a[x2].card[i] == 'P') {
            a[x2].card[i] = 'U';
            a[x2].hp++;
            return;
        }
    }
    //救不回，从双向链表移除x2
    a[a[x2].next].last = a[x2].last;
    a[a[x2].last].next = a[x2].next;

    if (x2 == 1) {ed = true; return;} //主公阵亡，反贼胜
    if (a[x2].id == 'F') fz--;
    if (!fz) {ed = true; return;} //无存活反贼，主忠胜

    //击杀反贼摸3张
    if (a[x2].id == 'F') {
        mp(x1), mp(x1), mp(x1);
    }
    //主公击杀忠臣，清空主公手牌+武器
    if (a[x2].id == 'Z' && a[x1].id == 'M') {
        a[x1].zgln = false;
        for(int i=1;i<=a[x1].cs;i++) a[x1].card[i]='U';
        a[x1].cs = 0;
    }
}

void Kil(int x1,int x2) {
    //x1对x2出杀结算
    for (int i=1;i<=a[x2].cs;i++) {
        if (a[x2].card[i] == 'D') {
            a[x2].card[i] = 'U';
            return;
        }
    }
    //无闪扣血濒死
    a[x2].hp--;
    if (!a[x2].hp) {
        js(x1, x2);
        if(ed) return;
    }
}

bool wxkj(int x1,int x2,int x3) {
    //无懈可击递归处理
    //x1=当前打出锦囊/无懈的人 x2=目标 x3=1挡普通锦囊 0抵消无懈
    int i = x1;
    while (1) {
        if (x3 == 1) {
            //献殷勤：保护锦囊目标x2，同阵营出J
            if (kn[x2]==a[i].id || (kn[x2]=='M'&&a[i].id=='Z') || (kn[x2]=='Z'&&a[i].id=='M')) {
                for (int j=1;j<=a[i].cs;j++) {
                    if (a[i].card[j] == 'J') {
                        a[i].card[j] = 'U';
                        kn[i] = a[i].id;
                        return !wxkj(i, x1, 0);
                    }
                }
            }
        } else {
            //表敌意：抵消对方打出的无懈x1，敌对才出J
            if(((a[i].id=='M'||a[i].id=='Z') && kn[x1]=='F') || (a[i].id=='F' && (kn[x1]=='M'||kn[x1]=='Z'))) {
                for (int j=1;j<=a[i].cs;j++) {
                    if (a[i].card[j] == 'J') {
                        a[i].card[j] = 'U';
                        kn[i] = a[i].id;
                        return !wxkj(i, x1, 0);
                    }
                }
            }
        }
        i = a[i].next;
        if (i == x1) break;
    }
    return false; //全场无人无懈，锦囊正常生效
}

void nmrq(int x1) {
    //南蛮入侵
    for (int x2=a[x1].next; x2!=x1; x2=a[x2].next) {
        if (!wxkj(x1, x2, 1)) {
            int i;
            for (i=1;i<=a[x2].cs;i++) {
                if (a[x2].card[i] == 'K') {
                    a[x2].card[i] = 'U';
                    break;
                }
            }
            if (i > a[x2].cs) {
                a[x2].hp--;
                if (x2 == 1 && kn[x1] == 'U') kn[x1] = 'L';
                if (!a[x2].hp) {
                    js(x1, x2);
                    if(ed) return;
                }
            }
        }
    }
}

void wjqf(int x1) {
    //万箭齐发
    for (int x2=a[x1].next; x2!=x1; x2=a[x2].next) {
        if (!wxkj(x1, x2, 1)) {
            int i;
            for (i=1;i<=a[x2].cs;i++) {
                if (a[x2].card[i] == 'D') {
                    a[x2].card[i] = 'U';
                    break;
                }
            }
            if (i > a[x2].cs) {
                a[x2].hp--;
                if (x2 == 1 && kn[x1] == 'U') kn[x1] = 'L';
                if (!a[x2].hp) {
                    js(x1, x2);
                    if(ed) return;
                }
            }
        }
    }
}

void jd(int x1,int x2)
//决斗 x1使用者 x2目标
{
    int j,k;
    if (wxkj(x1,x2,1)) return;
    kn[x1] = a[x1].id; //打出决斗表敌意，跳身份

    //规则修正：忠臣决斗主公，忠臣不出杀直接受伤
    if (a[x1].id == 'Z' && x2 == 1) {
        a[x2].hp--;
        if (!a[x2].hp) {
            js(x1,x2);
            if(ed) return;
        }
        return;
    }

    while (1) {
        j = 1; //每轮从头找最左杀
        while (a[x2].card[j]!='K' && j<=a[x2].cs) j++;
        if (j > a[x2].cs) {
            a[x2].hp--;
            if (!a[x2].hp) {
                js(x1,x2);
                if(ed) return;
            }
            return;
        }
        a[x2].card[j]='U';

        k = 1; //每轮从头找最左杀
        while (a[x1].card[k]!='K' && k<=a[x1].cs) k++;
        if (k > a[x1].cs) {
            a[x1].hp--;
            if (!a[x1].hp) {
                js(x2,x1);
                if(ed) return;
            }
            return;
        }
        a[x1].card[k]='U';
    }
}

void hh() {
    //回合主循环，轮流执行存活玩家回合
    char nc;
    ed = (fz == 0); //无反贼直接结束
    if (ed) return;
    for (int i=1; i; i=a[i].next) {
        mp(i), mp(i); //摸两张牌
        bool kill = true; //本回合是否出过杀
        for (int j=1;j<=a[i].cs;j++) {
            if (a[i].card[j] == 'U') continue;
            if (!a[i].hp) break;
            nc = a[i].card[j];

            if (nc == 'P') { //桃
                if (a[i].hp != 4) {
                    a[i].hp++, a[i].card[j]='U';
                }
                continue;
            }
            if (nc == 'K') { //杀
                if (!kill && !a[i].zgln) continue;
                bool canAtk = false;
                if(a[i].id == 'M') {
                    if(kn[a[i].next] == 'L' || kn[a[i].next] == 'F') canAtk = true;
                }else if(a[i].id == 'Z') {
                    if(kn[a[i].next] == 'F') canAtk = true;
                }else if(a[i].id == 'F') {
                    if(kn[a[i].next] == 'M' || kn[a[i].next] == 'Z') canAtk = true;
                }
                if(!canAtk) continue;

                a[i].card[j]='U';
                Kil(i, a[i].next);
                kn[i] = a[i].id;
                kill = false;
                if(ed) return;
                continue;
            }
            if (nc == 'F') { //决斗
                bool used = false;
                if (a[i].id == 'F') { //反贼直接决斗主公
                    a[i].card[j]='U';
                    jd(i, 1);
                    kn[i] = a[i].id;
                    used = true;
                }else { //主公/忠臣逆时针找第一个敌人决斗
                    for (int k=a[i].next; k!=i; k=a[k].next) {
                        bool targetEnemy = false;
                        if(a[i].id == 'M') {
                            if(kn[k] == 'L' || kn[k] == 'F') targetEnemy = true;
                        }else if(a[i].id == 'Z') {
                            if(kn[k] == 'F') targetEnemy = true;
                        }
                        if(targetEnemy) {
                            a[i].card[j]='U';
                            jd(i, k);
                            kn[i] = a[i].id;
                            used = true;
                            break;
                        }
                    }
                }
                if(ed) return;
                if(used) {
                    j = 0;
                    continue;
                }else continue;
            }
            if (nc == 'N') { //南蛮入侵
                a[i].card[j]='U';
                nmrq(i);
                if(ed) return;
                j = 0;
                continue;
            }
            if (nc == 'W') { //万箭齐发
                a[i].card[j]='U';
                wjqf(i);
                if(ed) return;
                j = 0;
                continue;
            }
            if (nc == 'Z') { //诸葛连弩
                a[i].zgln = true;
                a[i].card[j]='U';
                j = 0;
                continue;
            }
        }
    }
}

int main() {
    scanf("%d %d",&n,&m);
    //初始化双向循环链表
    for (int i=1;i<=n;i++) {
        a[i].next = i+1;
        a[i].last = i-1;
    }
    a[n].next = 1;
    a[1].last = n;

    //初始化每个玩家
    fz = 0;
    for (int i=1;i<=n;i++) {
        for (int j=1;j<2010;j++) a[i].card[j]='U';
        scanf("%s",sss);
        a[i].id = sss[0];
        for (int j=1;j<=4;j++) {
            scanf("%s",sss);
            a[i].card[j] = sss[0];
        }
        a[i].cs = 4;
        a[i].hp = 4;
        a[i].zgln = false;
        if(a[i].id == 'F') fz++;
    }
    //初始化公开身份kn
    for (int i=2;i<=n;i++) kn[i]='U';
    kn[1] = 'M';
    //读入牌堆，kpd[1]牌底 kpd[m]牌顶
    for (int i=1;i<=m;i++) {
        scanf("%s",sss);
        kpd[m - i + 1] = sss[0];
    }
    //启动游戏回合
    hh();
    //输出胜负
    if (a[1].hp <= 0) printf("FP\n");
    else printf("MP\n");
    //输出每个人手牌，带空格分隔
    for (int i=1;i<=n;i++) {
        if (a[i].hp <= 0) {
            printf("DEAD\n");
            continue;
        }
        bool first = true;
        for (int j=1;j<=a[i].cs;j++) {
            if (a[i].card[j] == 'U') continue;
            if(!first) printf(" ");
            printf("%c", a[i].card[j]);
            first = false;
        }
        printf("\n");
    }
    return 0;
}

posted @ 2026-06-22 20:39 zidurile 阅读(23) 评论(0) 收藏举报

刷新页面返回顶部

zidurile