洛谷P2482 猪国杀题解

最新推荐文章于 2024-07-30 15:57:45 发布

原创最新推荐文章于 2024-07-30 15:57:45 发布 · 2.2k 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #数据结构 #链表 #c++

本文详细介绍了P2482猪国杀的算法实现，包括Pig角色特点、卡牌规则及代码实现。强调了在处理Pig删除和卡牌删除操作时使用链表而非数组的便利性，并提供了300行代码的完整解决方案。重点讨论了各种卡牌的使用策略和游戏结束条件的判断。

- 题目简介：

P2482 猪国杀是一道非常好~~特别费劲~~的大模拟。做这道题的时候一定要认真查看每一处细节。按照题意模拟即可。写题解的其他大佬们一两百行就过了，我这个蒟蒻打了300行才过…

这个题可以用数组，也可以用链表，不过我建议使用链表而不是数组，因为用数组处理Pig的删除和卡牌的删除这两个操作有点麻烦。下面是题目讲解，大佬们勿喷。

- 题解正文：

1.三种Pig各自的特点：

MP[主猪]：

游戏开始时所有Pig就已经知道MP的身份，所以init函数要在游戏开始前把MP的way设为1（跳忠）。
MP有可能会去攻击way为3的Pig（类反猪）,需要特殊处理。
MP也会攻击FP。
如果MP寄了游戏结束。

ZP[忠猪]:

当MP对ZP使用F时，ZP只能被动挨打，真惨不能使用K。
只会攻击已经跳反的Pig。
如果跳忠就把它的way设为1。

FP[反猪]:

只会攻击已经跳忠的Pig。
只会对MP使用F。
如果跳反就把它的way设为2。
如果所有的FP都寄了就游戏结束。

2. 八种牌的注意事项：

P[桃]：

P只能在自己回合或者血量小于等于0的时候才可以使用。在自己回合时血量最多可以回满，但在其它Pig的回合时最多将血量恢复到1。

K[杀]：

如果没有Z每回合只能打一张K。
对方使用F或N的时候会不予余力的弃置（MP攻击ZP除外）。
使用后要查看游戏是否结束。
只能在条件成立时攻击逆时针数第一只Pig。

D[闪]:

对方使用K或W的时候会不予余力的弃置。

F[决斗]:

使用F的Pig（攻击方）有可能会寄掉（~~Pig真聪明~~），如果寄掉的话要立刻停止关于它的所有函数。
需要判断攻击方和被攻击方卡牌的变化：干掉FP会摸三张牌和MP干掉ZP的话MP的牌会被清空这两种情况。
要注意双方K的消耗，被攻击方先出K。如果攻击方的K的数量 < 被攻击方的K的数量的话，因为被攻击方先出K，所以被攻击方要消耗攻击方的K的数量+1张K，否则攻击方要消耗被攻击方的K的数量张K。
使用后要查看游戏是否结束。

N[南猪入侵] 和 W[万箭齐发]:

（这两种卡本质上时一样的，可以直接合并）

只要还有N和W就会不断出直到游戏结束或出完。
分清这两种卡分别使用哪种卡来抵消（N用K抵消，W用D抵消）。
每循环到一只Pig就要查看游戏是否结束。
如果攻击方没有表明身份就要把它的way设为3（类反猪）。

Z[猪哥连弩]：

在遇到第一个K时判断是否已经装备Z，如果没有Z就从头到尾全部搜索一遍，一旦遇到Z就停止查找并装备上。
在搜到Z时就将它装备上。

J[无懈可击]：

使用前要看对方的身份，在通过自己的身份来确定为跳忠或跳反。
忠猪不会跳反，反猪不会跳忠，需要使用的时候会不予余力的弃置。Pig们会在符合条件的情况下不断出J直到出完。
不会对未表明身份的Pig献殷勤或表敌意，包括自己。
因为无懈可击可以被无懈可击给无懈可击掉，所以需要不断的循环直到没有Pig出无懈可击时才能结束判断。
全场只要有Pig出F，W，N和J这4种牌就运行。

3. 一些细节：

输出游要戏结果的时候要注意最后面几只寄掉的Pig，要再额外再开一个for循环输出DEAD。
每当使用牌时就要让i = i号牌的上一张牌的编号。
注意链表边界的设置。
需要使用循环链表，要让最后一只Pig的nxt = pfront（一般pfront一直等于1），让MP的lst = 最后一只Pig的下表。
删牌的时候要注意判断删掉的牌数不为0后再执行删牌操作。
如果达到游戏结束的条件就要立刻调用over函数并终止其它所有的函数。
注意如果牌堆被摸完的话要摸最底下的那一张。
每头Pig都要添加一张0号牌防止牌被出完。

- 代码(总计300行整)：

#include<iostream>
#include<queue>
using namespace std;
queue<char> q;
struct Card{
    int lst,nxt;
    char card;
};//每只Pig的牌
struct Pig{
    string name;//名称
    Card card[200005];//牌的信息
    int p[10],nxt,lst,way,hp,clen,cend;//p数组记录每种牌有多少，clen记录有多少张牌，Cendant记录最后一张牌的编号
    bool f_Z;//是否有猪哥连弩
}a[20];
char cin_c,mp[10] = {' ','P','K','D','F','N','W','J','Z'};//和map函数搭配使用
int n,m,pfront,pend,plen,num_FP,it_kill,f_J;
bool use_f_x_live,f_over,f_x_live,f_K,f_break,f_k_die,way[4];
int map(char c){
    for(int i = 1;i<=8;i++)
        if(c == mp[i]) return i;
}//查找c是第几号牌
bool can_use(int x,int y,char k){
    return (k == 'F'||k == 'N'||k == 'W'||(k == 'K'&&a[x].nxt == y));
}//查看x是否能使用k攻击到y
void init(){
    for(int i = 1;i<=n;i++){
        for(int j = 1;j<=4;j++){
            j == 4?a[i].card[j].nxt = -1:a[i].card[j].nxt = j+1;
            a[i].card[j].lst = j-1;
            a[i].p[map(a[i].card[j].card)]++;
        }
        a[i].hp = a[i].cend = 4;
        a[i].card[0].nxt = 1;
        a[i].card[0].lst = -1;
        i == n? a[i].nxt = 1:a[i].nxt = i+1;
        i == 1? (a[i].lst = n,a[i].way = 1):(a[i].lst = i-1,a[i].way = 0);
        if(a[i].name == "FP") num_FP++;
    }
    pfront = 1;//第一只Pig的编号
    pend = n;//最后一只Pig的编号
    plen = n;//Pig的数量
    return;
}//初始化
void add(int x,int num){
    for(int i = 1;i<=num;i++){
        a[x].card[++a[x].cend].card = q.front();
        a[x].card[a[x].cend].nxt = -1;
        a[x].card[a[x].cend].lst = a[x].cend-1;
        a[x].card[a[x].card[a[x].cend].lst].nxt = a[x].cend;
        a[x].clen++;
        a[x].p[map(q.front())]++;
        if(q.size() > 1) q.pop();
    }
    return;
}//摸牌
void del_card(int x,char k,int num){
    if(num == 0) return;//判断摸牌的数量是否为0
    int cnt = 0;
    for(int i = a[x].card[0].nxt;i!=-1;i = a[x].card[i].nxt){
        if(a[x].card[i].card == k){
            if(i == a[x].cend){
                a[x].cend = a[x].card[a[x].cend].lst;
                a[x].card[a[x].cend].nxt = -1;
            }
            else{
                a[x].card[a[x].card[i].lst].nxt = a[x].card[i].nxt;
                a[x].card[a[x].card[i].nxt].lst = a[x].card[i].lst;
                a[x].card[i].lst = a[x].card[i].nxt = 0;
            }
            a[x].clen--;
            a[x].p[map(k)]--;
            if(++cnt == num) break;
        }
    }
    return;
}//把第x号猪的k删掉num张
void del_pig(int x){
    if(a[x].name == "FP") num_FP--;
    if(x == pfront){
        pfront = a[pfront].nxt;
        a[pfront].lst = pend;
        a[pend].nxt   = pfront;
    }
    else if(x == pend){
        pend = a[pend].lst;
        a[pend].nxt   = pfront;
        a[pfront].lst = pend;
    }
    else{
        a[a[x].lst].nxt = a[x].nxt;
        a[a[x].nxt].lst = a[x].lst;
    }
    plen--;
    return;
}//删掉第x号Pig
void over(){
    a[1].hp > 0?cout<<"MP"<<endl:cout<<"FP"<<endl;
    int i = pfront,it_lst = 0;
    do{
        for(int j = 1;j<=i-it_lst-1;j++) cout<<"DEAD"<<endl;
        for(int j = a[i].card[0].nxt;j!=-1;j = a[i].card[j].nxt){
            cout<<a[i].card[j].card;
            if(j != a[i].cend)cout<<" ";
        }
        cout<<endl;
        it_lst = i;
        i = a[i].nxt;
    }while(i!=pfront);
    for(int j = pend+1;j<=n;j++) cout<<"DEAD"<<endl;
    f_over = true;
    return;
}//输出结果
int find(int x,char k){
    if(a[x].name == "FP" && can_use(x,1,k)) return 1;
    else{
        if(a[x].name == "MP") way[1] = false,way[2] = way[3] = true;
        else if(a[x].name == "FP")  way[1] = true,way[2] = way[3] = false;
        else way[2] = true,way[1] = way[3] = false;
        int i = a[x].nxt;
        do{
            if(((a[i].way == 1 && way[1]) || (a[i].way == 2 && way[2])
            ||(a[i].way == 3 && way[3])) && can_use(x,i,k)) return i;
            i = a[i].nxt;
        }while(i != x);
        return 0;
    }
}//返回x使用k牌的最近的攻击目标，如果没有就返回0
void check_over(int x,int y){
    f_x_live = true;
    f_k_die  = false;
    if(a[y].hp <= 0){
        while(a[y].hp <= 0 && a[y].p[1] > 0){
            a[y].hp++;
            del_card(y,'P',1);
        }
    }
    if(a[y].hp <= 0){
        f_k_die = true;
        if(use_f_x_live || a[y].name == "ZP") f_x_live = false;
        del_pig(y);
        if(y == 1 || num_FP == 0) over();
        else{
            if(a[y].name == "FP") add(x,3); 
            else if(a[x].name == "MP" && a[y].name == "ZP"){
                for(int i = 1;i<=8;i++) a[x].p[i] = 0;
                a[x].card[0].nxt = a[x].card[0].lst = -1;
                a[x].clen = a[x].cend = 0;
                a[x].f_Z  = false;
            }
        }
    }
    return;
}//检测是否游戏结束
void K(int x,int y){
    del_card(x,'K',1);
    if(a[y].p[3] <= 0) a[y].hp--;
    else del_card(y,'D',1);
    (a[y].way == 1 && x != 1)?a[x].way = 2:a[x].way = 1;
    check_over(x,y);
    return;
}
void use_J(int x,int way){
    del_card(x,'J',1);
    f_J *= -1;
    a[x].way = way;
    f_break  = true;
}//和J函数搭配使用
bool check_team(int x,int y){
    return (a[x].name == a[y].name)||(a[x].name == "MP" && a[y].name == "ZP")
    ||(a[x].name == "ZP" && a[y].name == "MP");
}//检查x和y是否都跳忠或跳反，和J函数搭配使用
bool J(int x,int y){
    f_break = true;
    f_J = 1;
    if(a[y].way == 0) return true;
    while(f_break){
        f_break = false;
        int i = x;
        do{
            if(a[i].p[7] > 0)
                if((a[i].name == "MP" && a[y].way == 3&& f_J == -1)
                ||(!check_team(y,i)&&f_J == -1)) use_J(i,a[y].way == 1?2:1);
                else if(check_team(y,i) && f_J == 1) use_J(i,a[y].way);
            i = a[i].nxt;
        }while(i != x);
    }
    return f_J == 1;
}
void F(int x,int y){
    del_card(x,'F',1);
    if(J(x,y)){
        if(a[x].name == "MP" && a[y].name == "ZP"){
            a[y].hp--;
            check_over(x,y);
        }
        else{
            a[y].way == 1?a[x].way = 2:a[x].way = 1;
            if(a[x].p[2]<a[y].p[2]){
                del_card(y,'K',a[x].p[2]+1);
                del_card(x,'K',a[x].p[2]);
                a[x].hp--;
                use_f_x_live = true;
                check_over(y,x);
            }
            else{
                del_card(x,'K',a[y].p[2]);
                del_card(y,'K',a[y].p[2]);
                a[y].hp--;
                check_over(x,y);
            }
        }
    }
    return;
}
void N_and_W(int x,char k){
    k == 'N'?del_card(x,'N',1):del_card(x,'W',1);
    int i = a[x].nxt,N_W_card;
    do{
        if(f_over) return;
        if(J(x,i)){
            k == 'N'?N_W_card = a[i].p[2]:N_W_card = a[i].p[3];
            if(N_W_card > 0) k == 'N'?del_card(i,'K',1):del_card(i,'D',1);
            else{
                a[i].hp--;
                if(a[x].way == 0) a[x].way = 3;
                check_over(x,i);
            }
        }
        i = a[i].nxt;
    }while(i != x);
    return;
}
bool Z(int x){
    int zcard = a[x].card[0].nxt;
    do{
        if(a[x].card[zcard].card == 'Z'){
            del_card(x,'Z',1);
            return true;
        }
        zcard = a[x].card[zcard].nxt;
    }while(zcard!=-1);
    return false;
}//返回是否有Z
void play(int x){
    use_f_x_live = false;
    f_K = f_x_live = true;
    for(int i = a[x].card[0].nxt;i!=-1;i = a[x].card[i].nxt){
        if(f_over || (a[x].name == "MP" && !f_x_live)) return;
        it_kill = find(x,a[x].card[i].card);
        if(a[x].card[i].card == 'P' && a[x].hp < 4){
            del_card(x,'P',1);
            a[x].hp++;
            i = a[x].card[i].lst;
        }
        else if(a[x].card[i].card == 'Z'){
            del_card(x,'Z',1);
            a[x].f_Z = true;
            i = a[x].card[i].lst; 
        }
        else if(a[x].card[i].card == 'K' && it_kill != 0 && (a[x].f_Z || f_K)){
            K(x,it_kill);
            if(!a[x].f_Z){
                a[x].f_Z = Z(x);
                f_K = false;
            }
            i = a[x].card[i].lst;
        }
        else if(a[x].card[i].card == 'F' && it_kill != 0){
            F(x,it_kill);
            if(use_f_x_live && !f_x_live) break;
            i = a[x].card[i].lst;
        }
        else if(a[x].card[i].card == 'N' || a[x].card[i].card == 'W'){
            N_and_W(x,a[x].card[i].card);
            i = a[x].card[i].lst;
        }
    }
    return;
}//进行第x号Pig的回合
int main(){
    cin>>n>>m;
    for(int i = 1;i<=n;i++){
        cin>>a[i].name;
        for(int j = 1;j<=4;j++) cin>>a[i].card[++a[i].clen].card;
    }
    for(int i = 1;i<=m;i++){
        cin>>cin_c;
        q.push(cin_c);
    }
    init();
    while(!f_over){
        int i = pfront;
        do{
            add(i,2);
            play(i);
            if(f_over) return 0;
            i = a[i].nxt;
        }while(i != pfront);
    }
   return 0;
   //by:Jerry_Mouse666
}

————————————————
版权声明：本文为优快云博主「Jerry_Mouse101」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.youkuaiyun.com/Jerry_Mouse101/article/details/126180404