「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;
}

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