[luogu p2482] [SDOI2010]猪国杀

传送门

[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

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\%\) 的数据没有无懈可击。

分析

最近太颓,逼自己刷一道大模拟。

这可以看做是一篇娱乐文章了吧……没有题解。

况且这种大模拟没啥好讲的。

代码

/*
 * @Author: crab-in-the-northeast 
 * @Date: 2020-09-08 20:12:24 
 * @Last Modified by: crab-in-the-northeast
 * @Last Modified time: 2020-09-09 22:47:29
 */
#include <iostream>
#include <cstdio>
#include <string>

const int maxm = 2005;
const int maxn = 15;

struct node {
    int cardnum, health, next, last;
    char identity, card[maxm];
    bool Z;
}a[maxn];

char cards[maxm];

char identity[maxn];

int n, m;

int fpnum;

bool ended;

void GetCard(int idx) {
    if (m == 0) m = 1;
    a[idx].card[++a[idx].cardnum] = cards[m];
    --m;
}

void all_kill(int killer, int deader) {
    for (int i = 1; i <= a[deader].cardnum; ++i) {
        if (a[deader].card[i] == 'P') {
            a[deader].card[i] = 'X';
            ++a[deader].health;
            return ;
        }
    }

    a[a[deader].last].next = a[deader].next;
    a[a[deader].next].last = a[deader].last;

    if (deader == 1) {
        ended = true;
        return ;
    }

    if (a[deader].identity == 'F') --fpnum;
    if (fpnum == 0) {
        ended = true;
        return ;
    }

    if (a[deader].identity == 'F') {
        for (int i = 1; i <= 3; ++i)
            GetCard(killer);
    }

    if (a[killer].identity == 'M' && a[deader].identity == 'Z') {
        a[killer].cardnum = 0;
        a[killer].Z = false;
    }
}

void kill(int killer, int hurter) {
    for (int i = 1; i <= a[hurter].cardnum; ++i) {
        if (a[hurter].card[i] == 'D') {
            a[hurter].card[i] = 'X';
            return ;
        }
    }

    --a[hurter].health;
    if (a[hurter].health == 0) all_kill(killer, hurter);
}

bool NoMoreHurts(int x1, int x2, bool f) {
    for (int i = x1; true; i = a[i].next) {
        if (f) {
            if (identity[x2] == a[i].identity || (identity[x2] == 'Z' && a[i].identity == 'M') || (identity[x2] == 'M' && a[i].identity == 'Z')) {
                for (int j = 1; j <= a[i].cardnum; ++j) {
                    if (a[i].card[j] == 'J') {
                        a[i].card[j] = 'X';
                        identity[i] = a[i].identity;
                        return !NoMoreHurts(i, x1, false);
                    }
                }
            }
        } else {
            if (((a[i].identity == 'Z' || a[i].identity == 'M') && identity[x1] == 'F') || (a[i].identity == 'F' && (identity[x1] == 'Z' || identity[x1] == 'M'))) {
                for (int j = 1; j <= a[i].cardnum; ++j) {
                    if (a[i].card[j] == 'J') {
                        a[i].card[j] = 'X';
                        identity[i] = a[i].identity;
                        return !NoMoreHurts(i, x1, false);
                    }
                }
            }
        }

        if (a[i].next == x1) break;
    }

    return false;
}

void NanZhuInvade(int x) {
    for (int i = a[x].next; i != x; i = a[i].next) {
        if (!NoMoreHurts(x, i, true)) {
            int j;
            for (j = 1; j <= a[i].cardnum; ++j) {
                if (a[i].card[j] == 'K') {
                    a[i].card[j] = 'X';
                    break;
                }
            }
            if (a[i].cardnum < j) {
                --a[i].health;
                if (i == 1 && identity[x] == 'X')
                    identity[x] = 'L';
                if (a[i].health == 0)
                    all_kill(x, i);
                if (ended) return ;
            }
        }
    }
}

void battle(int x1, int x2) {
    if (NoMoreHurts(x1, x2, true)) return ;
    if (x1 == 1 && a[x2].identity == 'Z') {
        --a[x2].health;
        if (a[x2].health == 0) all_kill(x1, x2);
        return ;
    }

    for (int j = 1, k = 1;;) {
        while (a[x2].card[j] != 'K' && j <= a[x2].cardnum) ++j;
        if (a[x2].cardnum < j) {
            --a[x2].health;
            if (a[x2].health == 0) all_kill(x1, x2);
            return ;
        } else
            a[x2].card[j] = 'X';
        
        while (a[x1].card[k] != 'K' && k <= a[x1].cardnum) ++k;
        if (a[x1].cardnum < k) {
            --a[x1].health;
            if (a[x1].health == 0) all_kill(x2, x1);
            return ;
        } else
            a[x1].card[k] = 'X';
    }
}

void ManyShoots(int x) {
    for (int i = a[x].next; i != x; i = a[i].next) {
        if (!NoMoreHurts(x, i, true)) {
            int j;
            for (j = 1; j <= a[i].cardnum; ++j) {
                if (a[i].card[j] == 'D') {
                    a[i].card[j] = 'X';
                    break;
                }
            }
            if (a[i].cardnum < j) {
                --a[i].health;
                if (i == 1 && identity[x] == 'X')
                    identity[x] = 'L';
                if (a[i].health == 0)
                    all_kill(x, i);
                if (ended) return ;
            }
        }
    }
}

void round() {
    if (fpnum == 0) return ;
    ended = false;

    for (int i = 1; i; i = a[i].next) {
        for (int j = 1; j <= 2; ++j)
            GetCard(i);
        bool can_kill = true;

        for (int j = 1; j <= a[i].cardnum; ++j) {
            if (a[i].card[j] != 'X') {
                if (a[i].health == 0) break;
                if (a[i].card[j] == 'P') {
                    if (a[i].health != 4) {
                        a[i].card[j] = 'X';
                        ++a[i].health;
                    }
                } else if (a[i].card[j] == 'K') {
                    if (can_kill || a[i].Z) {
                        if ((a[i].identity != 'M' || identity[a[i].next] == 'L' || identity[a[i].next] == 'F') && (a[i].identity != 'Z' || identity[a[i].next] == 'F') && (a[i].identity != 'F' || identity[a[i].next] == 'Z' || identity[a[i].next] == 'M')) {
                            a[i].card[j] = 'X';
                            kill(i, a[i].next);
                            identity[i] = a[i].identity;
                            can_kill = false;
                            if (ended) return ;
                        }
                    } 
                } else if (a[i].card[j] == 'F') {
                    if (a[i].identity == 'F') {
                        a[i].card[j] = 'X';
                        battle(i, 1);
                        identity[i] = a[i].identity;
                        if (ended) return ;
                        j = 0;
                    } else {
                        for (int k = a[i].next; k != i; k = a[k].next) {
                            if ((a[i].identity == 'M' && (identity[k] == 'L' || identity[k] == 'F')) || (a[i].identity == 'Z' && identity[k] == 'F')) {
                                a[i].card[j] = 'X';
                                battle(i, k);
                                identity[i] = a[i].identity;
                                if (ended) return ;
                                j = 0;
                                break;
                            }
                        }
                    }
                } else if(a[i].card[j] == 'N') {
                    a[i].card[j] = 'X';
                    NanZhuInvade(i);
                    if (ended) return ;
                    j = 0;
                } else if (a[i].card[j] == 'W') {
                    a[i].card[j] = 'X';
                    ManyShoots(i);
                    if (ended) return ;
                    j = 0;
                } else if (a[i].card[j] == 'Z') {
                    a[i].card[j] = 'X';
                    a[i].Z = true;
                    j = 0;
                }
            }
        }
    }
}

int main() {
    std :: scanf("%d%d", &n, &m);
    for (int i = 1; i <= n; ++i) {
        a[i].next = i + 1;
        a[i].last = i - 1;
    }
    a[1].last = n;
    a[n].next = 1;

    for (int i = 1; i <= n; ++i) {
        for (int j = 1; j < maxm; ++j)
            a[i].card[j] = 'X';
        char current_str[maxn];
        std :: scanf("%s", current_str);
        a[i].identity = current_str[0];
        for (int j = 1; j <= 4; ++j) {
            std :: scanf("%s", current_str);
            a[i].card[j] = current_str[0];
        }
        if (a[i].identity == 'F') ++fpnum;
        a[i].cardnum = a[i].health = 4;
        a[i].Z = false;
    }

    identity[1] = 'M';
    for (int i = 2; i <= n; ++i)
        identity[i] = 'X';
    for (int i = 1; i <= m; ++i) {
        char current_card[maxn];
        std :: scanf("%s", current_card);
        cards[m - i + 1] = current_card[0];
    }

    round();

    if (a[1].health > 0)
        puts("MP");
    else
        puts("FP");

    for (int i = 1; i <= n; ++i) {
        if (a[i].health <= 0)
            puts("DEAD");
        else {
            for (int j = 1; j <= a[i].cardnum; ++j)
                if (a[i].card[j] != 'X') {
                    putc(a[i].card[j], stdout);
                    putc(' ', stdout);
                }
            putc('\n', stdout);
        }
    }

    return 0;
}

评测结果

评测结果

posted @ 2020-09-09 22:48  东北小蟹蟹  阅读(102)  评论(0编辑  收藏