社区讨论

25pts求调

P2482[SDOI2010] 猪国杀参与者 3已保存回复 3

讨论操作

快速查看讨论及其快照的属性,并进行相关操作。

当前回复
3 条
当前快照
1 份
快照标识符
@mm0hnhvy
此快照首次捕获于
2026/02/24 18:54
2 周前
此快照最后确认于
2026/02/26 10:30
2 周前
查看原帖
CPP
#include<bits/stdc++.h>
using namespace std;
int n,m,t,nxt[15],pre[15],mp,zp,fp;
struct Pig
{
    int type,hp=4,z=0;
    bool lf=false,tf=false,tz=false,dead=false,killed=false;
    vector<char>sp;
}p[15];
int win=-1;
string s;
char pd[2005],x;
void mopai(int id)
{
    t++;
    if(t>m) t=m;
    p[id].sp.push_back(pd[t]);
}
void clean()
{
    p[mp].sp.clear();
    p[mp].z=0;
}
void dead(int id)
{
    nxt[pre[id]]=nxt[id];
    pre[nxt[id]]=pre[id];
}
void game_over();
void peach(int id);
bool check(int tar,int from)
{
    while(p[tar].hp<=0)
    {
        bool found=false;
        for(auto &v:p[tar].sp)
        {
            if(p[tar].hp>0)
                return false;
            if(v=='P')
            {
                v=' ';
                found=true;
                peach(tar);
            }
        }
        if(!found) break;
    }
    if(p[tar].hp>0) return false;
    p[tar].dead=true;
    if(p[tar].type==1)
    {
        game_over();
        exit(0);
    }
    if(p[tar].type==3)
    {
        fp--;
        if(fp==0) game_over();
        else
        {
            mopai(from);
            mopai(from);
            mopai(from);
        }
    }
    if(p[tar].type==2)
    {
        if(p[from].type==1) clean();
        zp--;
    }
    if(fp==0)game_over();
    return true;
}
void game_over()
{
    if(!fp)cout<<"MP\n";
    else cout<<"FP\n";
    for(int i=1;i<=n;i++)
    {
        if(p[i].dead)cout<<"DEAD\n";
        else
        {
            for(auto &v: p[i].sp)
                if(v!=' ')
                    cout<<v<<" ";
            cout<<endl;
        }
    }
    win=0;
    exit(0);
}
void peach(int id)
{
    p[id].hp++;
}
void Kill(int from,int tar)
{
    bool flag=true;
    for(auto &v: p[tar].sp)
        if(v=='D')
        {
            flag=false;
            v=' ';
            break;
        }
    if(flag) p[tar].hp--;
    if(check(tar,from)) dead(tar);
}
bool wuxie(int id,int to);
void fight(int a,int b)
{
    if(p[a].type==1&&p[b].type==2)
    {
        p[b].hp--;
        if(check(b,a))dead(b);
        return;
    }
    //------------------无懈----------------------------
    if(p[b].tf||p[b].tz||p[b].type==1)
    {
        for(auto &v:p[b].sp)
            if(v=='J')
            {
                v=' ';
                if(wuxie(b,b))
                return;
            }
    }
    //--------------------------------------------------
    int cur=b;
    while(1)
    {
        bool used=false;
        for(auto &v: p[cur].sp)
            if(v=='K')
            {
                v=' ';
                used=true;
                break;
            }
        if(!used)
        {
            p[cur].hp--;
            if(cur==b)
            {
                if(check(b,a)) 
                { 
                    dead(b); 
                    break; 
                }
            }
            else
                if(check(a,b)) 
                { 
                    dead(a); 
                    break; 
                }
            break;
        }
        cur=(cur==a)?b:a;
    }
}
void nanman(int from)
{
    int cur=nxt[from];
    while(cur!=from)
    {
        if(p[cur].dead)
        {
            cur=nxt[cur];
            continue;
        }
        //------------------无懈----------------------------
        if(p[cur].tf||p[cur].tz||p[cur].type==1)
        {
            bool ok=false;
            for(auto &v:p[cur].sp)
                if(v=='J')
                {
                    v=' ';
                    if(wuxie(cur,cur))
                    {
                        ok=true;
                        break;
                    }
                }
            if(ok)
            {
                cur=nxt[cur];
                continue;
            }
        }
        //-------------------------------------------------
        bool used=false;
        for(auto &v: p[cur].sp)
            if(v=='K')
            {
                used=true;
                break;
            }
        if(!used)
        {
            p[cur].hp--;
            if(p[cur].type==1 && !p[from].tf && !p[from].tz)
                p[from].lf=true;
        }
        if(check(cur,from)) dead(cur);
        cur=nxt[cur];
    }
}
void wanjian(int from)
{
    int cur=nxt[from];
    while(cur!=from)
    {
        if(p[cur].dead)
        {
            cur=nxt[cur];
            continue;
        }
        //------------------无懈----------------------------
        if(p[cur].tf||p[cur].tz||p[cur].type==1)
        {
            bool ok=false;
            for(auto &v:p[cur].sp)
                if(v=='J')
                {
                    v=' ';
                    if(wuxie(cur,cur))
                    {
                        ok=true;
                        break;
                    }
                }
            if(ok)
            {
                cur=nxt[cur];
                continue;
            }
        }
        //-------------------------------------------------
        bool used=false;
        for(auto &v: p[cur].sp)
            if(v=='D')
            {
                v=' ';
                used=true;
                break;
            }
        if(!used)
        {
            p[cur].hp--;
            if(p[cur].type==1&&!p[from].tf&&!p[from].tz)
                p[from].lf=true;
        }
        if(check(cur,from)) dead(cur);
        cur=nxt[cur];
    }
}
bool wuxie(int id,int to)
{
    int cur=nxt[id];
    while(cur!=id)
    {
        if(p[cur].type==1||p[cur].type==2)
            if(p[id].tf||p[id].lf)
            {
                for(auto &v:p[cur].sp)
                {
                    if(v=='J')
                    {
                        v=' ';
                        return wuxie(cur,id);
                    }
                }
            }
        if(p[cur].type==2)
            if(p[id].tf)
            {
                for(auto &v:p[cur].sp)
                {
                    if(v=='J')
                    {
                        v=' ';
                        return wuxie(cur,id);
                    }
                }
            }
        if(p[cur].type==3)
            if(p[id].tz||p[id].type==1)
            {
                for(auto &v:p[cur].sp)
                {
                    if(v=='J')
                    {
                        v=' ';
                        return wuxie(cur,id);
                    }
                }
            }
        cur=nxt[cur];
    }
    return true;
}
void zhuge(int id)
{
    p[id].z=1;
}
void chupai(int id)
{
    p[id].killed=false;
    bool can_use=true;
    while(can_use)
    {
        can_use=false;
        for(auto &pai: p[id].sp)
        {
            if(pai=='P'&&p[id].hp<4)
            {
                peach(id);
                pai=' ';
                can_use=true;
                if(p[id].dead) return;
            }
            if(pai=='K'&&(p[id].killed==false||p[id].z>0))
            {
                if(p[id].type==1&&(p[nxt[id]].tf||p[nxt[id]].lf))
                {
                    pai=' ';
                    Kill(id,nxt[id]);
                    p[id].killed=true;
                    can_use=true;
                    if(p[id].dead) return;
                }
                if(p[id].type==2&&p[nxt[id]].tf)
                {
                    pai=' ';
                    Kill(id,nxt[id]);
                    p[id].killed=true;
                    p[id].tz=true;
                    p[id].lf=false;
                    can_use=true;
                    if(p[id].dead) return;
                }
                if(p[id].type==3&&(p[nxt[id]].tz||p[nxt[id]].type==1))
                {
                    pai=' ';
                    Kill(id,nxt[id]);
                    p[id].killed=true;
                    p[id].tf=true;
                    p[id].lf=false;
                    can_use=true;
                    if(p[id].dead)return;
                }
            }
            if(pai=='F')
            {
                int cur=nxt[id];
                if(p[id].type==3)
                {
                    pai=' ';
                    can_use=true;
                    fight(id,mp);
                    if(p[id].dead)return;
                }
                else
                    while(cur!=id)
                    {
                        if(p[id].type==1&&(p[cur].tf||p[cur].lf))
                        {
                            pai=' ';
                            can_use=true;
                            fight(id,cur);
                            if(p[id].dead)return;
                            break;
                        }
                        if(p[id].type==2&&p[cur].tf)
                        {
                            pai=' ';
                            fight(id,cur);
                            p[id].tz=true;
                            p[id].lf=false;
                            can_use=true;
                            if(p[id].dead) return;
                            break;
                        }
                        cur=nxt[cur];
                    }
            }
            if(pai=='N')
            {
                pai=' ';
                nanman(id);
                can_use=true;
                if(p[id].dead) return;
            }
            if(pai=='W')
            {
                pai=' ';
                wanjian(id);
                can_use=true;
                if(p[id].dead) return;
            }
            if(pai=='Z')
            {
                pai=' ';
                zhuge(id);
                can_use=true;
                if(p[id].dead) return;
            }
            if(can_use)break;
        }
    }
}
int main()
{
    cin>>n>>m;
    for(int i=1;i<=n;i++)
    {
        cin>>s;
        if(s=="MP")p[i].type=1,mp=i;
        if(s=="ZP")p[i].type=2,zp++;
        if(s=="FP")p[i].type=3,fp++;
        for(int j=1;j<=4;j++)
        {
            cin>>x;
            p[i].sp.push_back(x);
        }
    }
    for(int i=1;i<=m;i++) 
        cin>>pd[i];
    for(int i=1;i<n;i++) 
        nxt[i]=i+1;
    nxt[n]=1;
    for(int i=2;i<=n;i++) 
        pre[i]=i-1;
    pre[1]=n;
    int cur=1;
    while(win==-1)
    {
        if(p[cur].dead)
        {
            cur=nxt[cur];
            continue;
        }
        mopai(cur);
        mopai(cur);
        chupai(cur);
        cur=nxt[cur];
    }
    return 0;
}
蒟蒻刚学模拟,调了2个月,实在调不出来了喵T_T。
悬赏一个关注喵>_<

回复

3 条回复,欢迎继续交流。

正在加载回复...