「C++」复杂模拟【壹】

建议开启目录食用

阅读本文之前建议您先看这里，如果您已经看完了，那么就可以放心大胆的学习本文了。

我认为其实本文的难度还是比较大的，今天我们题是来自山东省省选，所以建议大家谨慎阅读，如果您是专业程序员当我没说。

OK，那么事不宜迟，咱们来看第一题

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

分析

看到这可恶的题目描述，大家的脑海里略过的第一反应是不是不想读？

没关系，这里有一个简化版的：

简化版题目

《猪国杀》是一款基于三国杀规则的回合制策略游戏，玩家扮演主猪、忠猪或反猪三种角色。游戏目标因角色而异，主猪需消灭所有反猪，忠猪协助主猪，反猪则致力于杀死主猪。游戏过程中，玩家通过摸牌、出牌等阶段，利用基本牌、锦囊牌和装备牌等策略进行攻击、防御和辅助。特殊事件包括伤害来源、距离计算、玩家死亡和奖励惩罚等规则。玩家的行为包括献殷勤、表敌意以及跳忠或跳反，以表明自己的身份和策略。最终目标是判断特定玩家（如小猪iPig）的游戏结果。《猪国杀》游戏中的行动准则分为共性和特性两部分。共性规则包括在特定条件下自动执行的行为，如体力未满时吃桃、使用锦囊牌、装备武器、弃置闪以抵消杀的效果等。同时，所有角色都不会对未表明身份的猪（包括自己）献殷勤。

特性规则则针对三种角色（主猪、忠猪、反猪）的不同身份设定了各自的独特行为。主猪会对类反猪或已跳反猪表敌意，对跳忠猪或自己献殷勤，并在决斗时全力弃置杀。忠猪则主要对跳反猪表敌意，为主猪或跳忠猪献殷勤，并在主猪作为决斗对象时避免弃置杀。反猪则主要对主猪表敌意，为跳反猪献殷勤，并在决斗时全力弃置杀。

由于iPig只会使用P++语言进行简单的计算，他请求使用Pigcal（Pascal）、P（C）或P++（C++）语言来预测游戏的最终结果。

代码分析

实现原理与准备工作

这道题是一个工程量十分巨大的模拟题，题解里面几乎每一个人都用了$$\ge 100$$行代码，有极个别案例在码风炸裂的情况下硬是撑到了93行，但是，我们从来不是比代码的行数，而是比代码的优劣。

这里我们先定义一个结构体和几个变量为下文的代码做一个铺垫：

struct node{
    int cs, hp, next, last;//cs 手牌数 hp 生命值 
    char id, card[2010];//id 身份 
	bool zgln; //是否装备了「诸葛连弩」
}a[20];
char kn[11], kpd[2010], sss[10];//kn表示在主公眼里这只猪的身份 kpd 卡牌堆 
int n, m, fz;//fz 反贼数量 
bool ed;

首先呢，这里有八种卡牌，这里我们可以对应到八个函数或代码段上面，至于具体的函数怎么写，让我们逐个分析。

『桃 / P』

技能简介：在自己的回合内，如果自己的体力值不等于体力上限，那么使用 1 个桃可以为自己补充 1 点体力，否则不能使用桃；桃只能对自己使用；在自己的回合外，如果自己的血变为 0 或者更低，那么也可以使用。

分析：首先我们可以注意到这样一个特殊条件：如果自己的体力值不等于体力上限，这个很好判断，剩下的直接进行小模拟即可。

『杀 / K』

技能简介：在自己的回合内，对攻击范围内除自己以外的 1 名角色使用。如果没有被『闪』抵消，则造成 1 点伤害。无论有无武器，杀的攻击范围都是 1。

分析：这个也是很简单对吧，只需要判断一下是否会被『闪』抵消就可以了（当然现实要是想实现也是比较难的，到时候看完整代码）。

『闪 / D』

技能简介：当你受到杀的攻击时，可以弃置 1 张闪来抵消杀的效果。

分析：略。

『决斗 / F』

技能简介：出牌阶段，对除自己以外任意 1 名角色使用，由目标角色先开始，自己和目标角色轮流弃置 1 张杀，首先没有杀可弃的一方受到 1 点伤害，另一方视为此伤害的来源。

分析：这句话其实是理解起来比较困难，首先弃置就是指丢弃或者使用，然后这里首先没有杀可弃的一方受到 1 点伤害意思就是没有杀的人受到一点伤害，紧接着还有另一方视为此伤害的来源意思就是前者的对立方（出牌人居多）看做此伤害的来源。

『南猪入侵 / N』

会不会还有七擒孟猪

技能简介：出牌阶段，对除你以外所有角色使用，按逆时针顺序从使用者下家开始依次结算，除非弃置 1 张杀，否则受到 1 点伤害。

分析：这个也是很好理解，意思就是从使用者开始丢弃一张杀，你不丢的话就来一刀。

『万箭齐发 / W』

技能简介：出牌阶段，对除你以外所有角色使用，按逆时针顺序从使用者下家开始依次结算，除非弃置 1 张闪，否则受到 1 点伤害。

分析：略。

『无懈可击 / J』

技能简介：在目标锦囊生效前抵消其效果。每次有 1 张锦囊即将生效时，从使用这张锦囊的猪开始，按照逆时针顺序，依次得到使用无懈可击的机会；效果：用于决斗时，决斗无效并弃置；用于南猪入侵或万箭齐发时，当结算到某个角色时才能使用，当前角色不需弃置牌并且不会受到伤害（仅对 1 个角色产生效果）；用于无懈可击时，成为目标的无懈可击被无效。

分析：很简单，就是抵消目标锦囊对一名角色产生的效果；或抵消另一张无懈可击产生的效果。

『猪哥连弩 / Z』

诸葛亮：我的名字叫猪哥亮？

技能简介：武器，攻击范围 1 ，出牌阶段你可以使用任意张杀; 同一时刻最多只能装 1 把武器；如果先前已经有了 1 把武器，那么之后再装武器的话，会弃置以前的武器来装现在的武器。

分析：这个只用分析是否可以使用就行了。

剩下的自己看吧，反正都是很简单的，老子不想写了。

代码

#include<bits/stdc++.h>
using namespace std;

struct node{
    int cs, hp, next, last;
    char id, card[2010];
	bool zgln;
}a[20];

char kn[11], kpd[2010], sss[10];
int n, m, fz;
bool ed;

void mp(int x) {
    if(!m) m++;
    a[x].card[++a[x].cs] = kpd[m];
    m--;
}

void js(int x1,int x2) {
    for(int i = 1; i <= a[x2].cs; ++ i)
        if(a[x2].card[i] == 'P') {
            a[x2].card[i] = 'U';
            a[x2].hp ++;
            return;
        }
    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;}
    if(a[x2].id == 'F') mp(x1), mp(x1), mp(x1);
    if(a[x2].id=='Z' && a[x1].id=='M') a[x1].cs = 0, a[x1].zgln = false;
}

void Kil(int x1,int 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);
}

bool wxkj(int x1, int x2, int x3) {
    int i = x1, pd = x3 ? x2 : x1;
    while(1) {
        if(x3 == 1) {
            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 {
            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) {
    int i, j, k;
    if(wxkj(x1, x2, 1)) return;
    if(x1 == 1 && a[x2].id == 'Z') {
        a[x2].hp --;
        if(!a[x2].hp) js(x1,x2);
        return;
    }
    j = k = 1;
    while(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);
            return;
        }
        else a[x2].card[j] = 'U';
        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);
            return;
        }
        else a[x1].card[k] = 'U';
    }
}

void hh() {
    char nc;
    ed = true;
    if(fz) ed = false;
    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') {
                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;
                    if(a[i].id == 'M' && kn[a[i].next] != 'L' && kn[a[i].next] != 'F') continue;
                    if(a[i].id == 'Z' && kn[a[i].next] != 'F') continue;
                    if(a[i].id == 'F' && kn[a[i].next] != 'Z' && kn[a[i].next] != 'M') 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')	{
                    if(a[i].id == 'F') {
                        a[i].card[j] = 'U', jd(i, 1);
                        kn[i] = a[i].id;
                        if(ed) return ;
                        j = 0;
                        continue;
                    }
                    for(int k = a[i].next; k != i; k = a[k].next)
                        if((a[i].id == 'M' && (kn[k] == 'L' || kn[k] == 'F')) || (a[i].id == 'Z' && kn[k] == 'F')) {
                            a[i].card[j] = 'U', jd(i, k);
                            kn[i] = a[i].id;
                            if(ed) return;
                            j = 0;
                            break;
                        }
                    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;
    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 = a[i].hp = 4; 
        if(a[i].id == 'F') ++ fz;
        a[i].zgln = false;
    }
    for(int i = 2; i <= n; ++ i) kn[i] = 'U';
    kn[1] = '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");
        else {
            for(int j = 1; j <= a[i].cs; ++ j)
                if(a[i].card[j] != 'U') printf("%c ",a[i].card[j]);
            printf("\n");
        }
    }
    return 0;
}

本博客工程量巨大，现在打字手都是颤抖的，大家记得点个推荐支持一下作者哦！

posted @ 2024-06-20 19:40  Charzie  阅读(92)  评论(2)  编辑  收藏  举报