bzoj1972: [Sdoi2010]猪国杀

最新推荐文章于 2019-04-08 14:08:18 发布
最新推荐文章于 2019-04-08 14:08:18 发布
阅读量2.4k 收藏
点赞数
CC 4.0 BY-SA版权
文章标签： bzoj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/u012739450/article/details/28128391

刚开博客，放几道大模拟

猪国杀 20多k ....

www.lydsy.com/JudgeOnline/problem.php?id=1972

#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <vector>
#include <algorithm>
using namespace std;
#define MAXM 2001

#define Tao     ('P')
#define Sha     ('K')
#define Shan    ('D')
#define JueDou  ('F')
#define NanZhu  ('N')
#define WanJian ('W')
#define WuXie   ('J')
#define ZhuGe   ('Z')
#define DiYi    (-1)
#define None     0
#define YinQin   1

int LeftFan;
typedef struct PigBase *PtrPig;
typedef struct PigLink *PigLinker;
void MoPai(PtrPig, int);
void Win();
struct PigBase
{
    vector<char> ShouPai;
    bool dead, tiao, HaveZhuGe;
    int blood;
    PigBase(bool _tiao, char c1, char c2, char c3, char c4)
        : dead(false), tiao(_tiao), HaveZhuGe(false), blood(4)
    {
        ShouPai.push_back(c1);
        ShouPai.push_back(c2);
        ShouPai.push_back(c3);
        ShouPai.push_back(c4);
    }
    virtual bool IsZhu()const
    {
        return false;
    }
    virtual bool IsZhong()const
    {
        return false;
    }
    virtual bool IsFan()const
    {
        return false;
    }
    void PrintInfo()
    {
        if (dead)
            printf("DEAD\n");
        else
        {
            if (ShouPai.size() == 0)
            {
                putchar('\n');
                return;
            }
            for (vector<char>::iterator i = ShouPai.begin(); i + 1 != ShouPai.end(); ++i)
                printf("%c ", *i);
            printf("%c\n", ShouPai.back());
        }
    }
    virtual void ChuPai() = 0;
    void BinSi(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Tao);
        if (p == ShouPai.end())
        {
            dead = true;
            if (IsFan())
                --LeftFan;
            Win();
            if (IsFan())
                MoPai(sender, 3);
            if (IsZhong() && sender->IsZhu())
            {
                sender->ShouPai.clear();
                sender->HaveZhuGe = false;
            }
        }
        else
        {
            ShouPai.erase(p);
            ++blood;
        }
    }
    void GotSha(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Shan);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
            ShouPai.erase(p);
    }
    virtual bool QuaryWuXie(PtrPig, PtrPig, PigLinker, int) = 0;
    virtual void GotJueDou(PtrPig) = 0;
    virtual void GotNanZhu(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Sha);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
            ShouPai.erase(p);
    }
    virtual void GotWanJian(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Shan);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
            ShouPai.erase(p);
    }
    void Tiao();
};
struct PigZhu: public PigBase
{
    vector<PtrPig> LeiFan;
    PigZhu(char c1, char c2, char c3, char c4)
        : PigBase(true, c1, c2, c3, c4) {}
    bool IsZhu()const
    {
        return true;
    }
    void ChuPai();
    bool QuaryWuXie(PtrPig, PtrPig, PigLinker, int);
    void GotJueDou(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Sha);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
        {
            ShouPai.erase(p);
            sender->GotJueDou(this);
        }
    }
    void GotNanZhu(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Sha);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
            if (!sender->tiao && find(LeiFan.begin(), LeiFan.end(), sender) == LeiFan.end())
                LeiFan.push_back(sender);
        }
        else
            ShouPai.erase(p);
    }
    void GotWanJian(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Shan);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
            if (!sender->tiao && find(LeiFan.begin(), LeiFan.end(), sender) == LeiFan.end())
                LeiFan.push_back(sender);
        }
        else
            ShouPai.erase(p);
    }
};
struct PigZhong: public PigBase
{
    PigZhong(char c1, char c2, char c3, char c4)
        : PigBase(false, c1, c2, c3, c4) {}
    bool IsZhong()const
    {
        return true;
    }
    void ChuPai();
    bool QuaryWuXie(PtrPig, PtrPig, PigLinker, int);
    void GotJueDou(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Sha);
        if (sender->IsZhu() || p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
        {
            ShouPai.erase(p);
            sender->GotJueDou(this);
        }
    }
};
struct PigFan: public PigBase
{
    PigFan(char c1, char c2, char c3, char c4)
        : PigBase(false, c1, c2, c3, c4) {}
    bool IsFan()const
    {
        return true;
    }
    void ChuPai();
    bool QuaryWuXie(PtrPig, PtrPig, PigLinker, int);
    void GotJueDou(PtrPig sender)
    {
        vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), Sha);
        if (p == ShouPai.end())
        {
            --blood;
            if (blood == 0)
                BinSi(sender);
        }
        else
        {
            ShouPai.erase(p);
            sender->GotJueDou(this);
        }
    }
};

struct PigLink
{
    PtrPig data;
    PigLinker next;
    PigLink(PtrPig _data = NULL, PigLinker _next = NULL)
        : data(_data), next(_next) {}
};

char PaiDui[MAXM];
int PaiDui_head;
int m;
PigLinker PigList;
PigLinker Zhu;

void Init()
{
    LeftFan = 0;
    int n;
    scanf("%d%d", &n, &m);
    char c1, c2, c3, c4, s[4];
    for (int i = 0; i < n; ++i)
    {
        scanf("%s %c %c %c %c", s, &c1, &c2, &c3, &c4);
        if (i == 0)
            Zhu = PigList = new PigLink(new PigZhu(c1, c2, c3, c4));
        else if (strcmp(s, "ZP") == 0)
        {
            PigList->next = new PigLink(new PigZhong(c1, c2, c3, c4));
            PigList = PigList->next;
        }
        else
        {
            PigList->next = new PigLink(new PigFan(c1, c2, c3, c4));
            PigList = PigList->next;
            ++LeftFan;
        }
    }
    PigList->next = Zhu;
    PigList = Zhu;
    PaiDui_head = 0;
    for (int i = 0; i < m; ++i)
        scanf(" %c", &PaiDui[i]);
}

void MoPai(PtrPig x, int t)
{
    for (int i = 0; i < t; ++i)
    {
        x->ShouPai.push_back(PaiDui[PaiDui_head++]);
        if (PaiDui_head == m)
            --PaiDui_head;
    }
}

void Win()
{
    if (Zhu->data->dead || !LeftFan)
    {
        printf(LeftFan ? "FP\n" : "MP\n");
        Zhu->data->PrintInfo();
        for (PigLinker i = Zhu->next; i != Zhu; i = i->next)
            i->data->PrintInfo();
        exit(0);
    }
}

int main()
{
    long ct = 1;
    for (Init();; PigList = PigList->next, ++ct)
    {
//        printf("%ld %d\n", ct, PaiDui_head);
        if (PigList->data->dead)
            continue;
        MoPai(PigList->data, 2);
        PigList->data->ChuPai();
    }
    return 0;
}

bool AllQuaryWuXie(PigLinker sender, PtrPig receiver, int k = 0)
{
    if (sender->data->QuaryWuXie(sender->data, receiver, sender, k))
        return true;
    for (PigLinker i = sender->next; i != sender; i = i->next)
        if (!i->data->dead && i->data->QuaryWuXie(sender->data, receiver, i, k))
            return true;
    return false;
}

void AllGotNanZhu(PigLinker sender)
{
    for (PigLinker i = sender->next; i != sender; i = i->next)
        if (!i->data->dead && !AllQuaryWuXie(sender, i->data))
            i->data->GotNanZhu(sender->data);
}

void AllGotWanJian(PigLinker sender)
{
    for (PigLinker i = sender->next; i != sender; i = i->next)
        if (!i->data->dead && !AllQuaryWuXie(sender, i->data))
            i->data->GotWanJian(sender->data);
}

void PigZhu::ChuPai()
{
    bool UsedSha = false;
    for (vector<char>::iterator i = ShouPai.begin(); i != ShouPai.end();)
        if (*i == Tao)
        {
            if (blood != 4)
            {
                i = ShouPai.erase(i);
                ++blood;
            }
            else
                ++i;
        }
        else if (*i == Sha)
        {
            if (!UsedSha || HaveZhuGe)
            {
                PigLinker j;
                for (j = PigList->next; j != PigList; j = j->next)
                {
                    if (j->data->dead)
                        continue;
                    if (j->data->IsFan() && j->data->tiao)
                        break;
                    if (find(LeiFan.begin(), LeiFan.end(), j->data) != LeiFan.end())
                        break;
                    j = PigList;
                    break;
                }
                if (j != PigList)
                {
                    ShouPai.erase(i);
                    UsedSha = true;
                    j->data->GotSha(this);
                    i = ShouPai.begin();
                }
                else
                    ++i;
            }
            else
                ++i;
        }
        else if (*i == Shan)
        {
            ++i;
            continue;
        }
        else if (*i == JueDou)
        {
            PigLinker j;
            for (j = PigList->next; j != PigList; j = j->next)
            {
                if (j->data->dead)
                    continue;
                if (j->data->IsFan() && j->data->tiao)
                    break;
                if (find(LeiFan.begin(), LeiFan.end(), j->data) != LeiFan.end())
                    break;
            }
            if (j != PigList)
            {
                ShouPai.erase(i);
                if (!AllQuaryWuXie(PigList, j->data, DiYi))
                    j->data->GotJueDou(this);
                i = ShouPai.begin();
            }
            else
                ++i;
        }
        else if (*i == NanZhu)
        {
            ShouPai.erase(i);
            AllGotNanZhu(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WanJian)
        {
            ShouPai.erase(i);
            AllGotWanJian(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WuXie)
        {
            ++i;
            continue;
        }
        else if (*i == ZhuGe)
        {
            ShouPai.erase(i);
            HaveZhuGe = true;
            i = ShouPai.begin();
        }
}

void PigZhong::ChuPai()
{
    bool UsedSha = false;
    for (vector<char>::iterator i = ShouPai.begin(); i != ShouPai.end();)
        if (*i == Tao)
        {
            if (blood != 4)
            {
                i = ShouPai.erase(i);
                ++blood;
            }
            else
                ++i;
        }
        else if (*i == Sha)
        {
            if (!UsedSha || HaveZhuGe)
            {
                PigLinker j;
                for (j = PigList->next; j != PigList; j = j->next)
                {
                    if (j->data->dead)
                        continue;
                    if (j->data->IsFan() && j->data->tiao)
                        break;
                    j = PigList;
                    break;
                }
                if (j != PigList)
                {
                    PigList->data->Tiao();
                    ShouPai.erase(i);
                    UsedSha = true;
                    j->data->GotSha(this);
                    i = ShouPai.begin();
                }
                else
                    ++i;
            }
            else
                ++i;
        }
        else if (*i == Shan)
        {
            ++i;
            continue;
        }
        else if (*i == JueDou)
        {
            PigLinker j;
            for (j = PigList->next; j != PigList; j = j->next)
            {

                if (j->data->dead)
                    continue;
                if (j->data->IsFan() && j->data->tiao)
                    break;
            }
            if (j != PigList)
            {
                ShouPai.erase(i);
                PigList->data->Tiao();
                if (!AllQuaryWuXie(PigList, j->data, DiYi))
                {
                    j->data->GotJueDou(this);
                    if (dead)
                        return;
                }
                i = ShouPai.begin();
            }
            else
                ++i;
        }
        else if (*i == NanZhu)
        {
            ShouPai.erase(i);
            AllGotNanZhu(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WanJian)
        {
            ShouPai.erase(i);
            AllGotWanJian(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WuXie)
        {
            ++i;
            continue;
        }
        else if (*i == ZhuGe)
        {
            ShouPai.erase(i);
            HaveZhuGe = true;
            i = ShouPai.begin();
        }
}

void PigFan::ChuPai()
{
    bool UsedSha = false;
    for (vector<char>::iterator i = ShouPai.begin(); i != ShouPai.end();)
        if (*i == Tao)
        {
            if (blood != 4)
            {
                i = ShouPai.erase(i);
                ++blood;
            }
            else
                ++i;
        }
        else if (*i == Sha)
        {
            if (!UsedSha || HaveZhuGe)
            {
                PigLinker j;
                for (j = PigList->next; j != PigList; j = j->next)
                {
                    if (j->data->dead)

                        continue;
                    if (j->data->IsZhu() || (j->data->IsZhong() && j->data->tiao))
                        break;
                    j = PigList;
                    break;
                }
                if (j != PigList)
                {
                    PigList->data->Tiao();
                    ShouPai.erase(i);
                    UsedSha = true;
                    j->data->GotSha(this);
                    i = ShouPai.begin();
                }
                else
                    ++i;
            }
            else
                ++i;
        }
        else if (*i == Shan)
        {
            ++i;
            continue;
        }
        else if (*i == JueDou)
        {
            PigList->data->Tiao();
            ShouPai.erase(i);
            if (!AllQuaryWuXie(PigList, Zhu->data, DiYi))
            {
                Zhu->data->GotJueDou(this);
                if (dead)
                    return;
            }
            i = ShouPai.begin();
        }
        else if (*i == NanZhu)
        {
            ShouPai.erase(i);
            AllGotNanZhu(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WanJian)
        {
            ShouPai.erase(i);
            AllGotWanJian(PigList);
            i = ShouPai.begin();
        }
        else if (*i == WuXie)
        {
            ++i;
            continue;
        }
        else if (*i == ZhuGe)
        {
            ShouPai.erase(i);
            HaveZhuGe = true;
            i = ShouPai.begin();
        }
}

bool PigZhu::QuaryWuXie(PtrPig sender, PtrPig receiver, PigLinker me, int k)
{
    vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), WuXie);
    if (p == ShouPai.end())
        return false;
    if (k == DiYi)
    {
        if (!receiver->tiao)
            return false;
        if (receiver == this || receiver->IsZhong()
            || (sender->IsFan() && sender->tiao))
        {
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == None)
    {
        if (!receiver->tiao)
            return false;
        if (receiver == this || receiver->IsZhong())
        {
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == YinQin)
    {
        if ((sender->IsFan() && sender->tiao) || (receiver->IsFan() && receiver->tiao))
        {
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, DiYi);
        }
    }
    return false;
}
bool PigZhong::QuaryWuXie(PtrPig sender, PtrPig receiver, PigLinker me, int k)
{
    vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), WuXie);
    if (p == ShouPai.end())
        return false;
    if (k == DiYi)
    {
        if (!receiver->tiao)
            return false;
        if (receiver->IsZhu() || receiver->IsZhong()
            || (sender->IsFan() && sender->tiao))
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == None)
    {
        if (!receiver->tiao)
            return false;
        if (receiver->IsZhu() || receiver->IsZhong())
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == YinQin)
    {
        if ((sender->IsFan() && sender->tiao) || (receiver->IsFan() && receiver->tiao))
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, DiYi);
        }
    }
    return false;
}
bool PigFan::QuaryWuXie(PtrPig sender, PtrPig receiver, PigLinker me, int k)
{
    vector<char>::iterator p = find(ShouPai.begin(), ShouPai.end(), WuXie);
    if (p == ShouPai.end())
        return false;
    if (k == DiYi)
    {
        if (!receiver->tiao)
            return false;
        if (receiver->IsFan() || sender->IsZhu()
            || (sender->IsZhong() && sender->tiao))
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == None)
    {
        if (!receiver->tiao)
            return false;
        if (receiver->IsFan())
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, receiver, YinQin);
        }
    }
    else if (k == YinQin)
    {
        if (sender->IsZhu() || (sender->IsZhong() && receiver->tiao)
            || receiver->IsZhu() || (receiver->IsZhong() && receiver->tiao))
        {
            Tiao();
            ShouPai.erase(p);
            return !AllQuaryWuXie(me, sender, DiYi) && !AllQuaryWuXie(me, receiver, DiYi);
        }
    }
    return false;
}

void PigBase::Tiao()
{
    tiao = true;
    vector<PtrPig>::iterator p = find(((PigZhu *)(Zhu->data))->LeiFan.begin(), ((PigZhu *)(Zhu->data))->LeiFan.end(), this);
    if (p != ((PigZhu *)(Zhu->data))->LeiFan.end())
        ((PigZhu *)(Zhu->data))->LeiFan.erase(p);
}


lljjss91
关注
[SDOI2010]猪国杀题解
hht的博客
09-16 1497
文章目录题目链接：sol游戏结束、一些数组/变量每个猪的结构体：献殷勤、表敌意、跳忠、跳反伤害、死亡无懈可击主要操作完整代码AC代码观战模式 题目链接： 洛谷P2482 loj2885 bzoj1972 推荐去loj看题，可以下数据因为特别容易出错。 sol 其实这题码量也没那大，格式化后我的代码只有141行，在loj目前最短。最好多些一些函数，给每个猪开一个结构体。 游戏结束、一些数组/变量 之...
【BZOJ1972】[SDOI2010] 猪国杀（恶心的大模拟）
CXR的博客
10-23 533
点此看题面 大致题意： 让你模拟一个游戏猪国杀的过程。 极大坑点 对于这种模拟题，具体思路就不讲了，就说说有哪些坑点。 题面有锅，反猪是FPFPFP。 数据有锅，牌堆中的牌可能不够用，牌堆为空之后需一直抽最后一张牌。 主猪杀死忠猪后猪哥连弩也要清除。 无懈可击也可以用无懈可击抵消。 使用决斗的猪可能死亡。 无懈可击是从使用锦囊牌的猪开始轮流选择是否响应。 使用完一张牌...
模拟 [Sdoi2010]猪国杀
蒟蒻QTY
10-09 843
题目的可读版本有那么几个地方需要注意： 1.使用一个锦囊后，先判无懈可击。 2.如果一个猪出完一个牌后，要从头开始看哪个能出（有可能一次出牌后某只猪跳忠或者跳反了，F，K什么的就可以用了。） 3.游戏结束时，没抓的牌就不用抓了。 4.循环无懈可击 5.行末没空格昨天打的时候，有个没玩过三国杀的dalao问我能不能无懈杀。。。。 其实这种题完全没有思维含量，只要打之前把所有细节构思好，之后
[SDOI2010]猪国杀
emmmm
11-27 1489
Au爷faebdc:"神犇来做猪国杀吧,我自己做太蛋疼了" 蒟蒻:"好吧" Au爷faebdc“我过了” 蒟蒻:"......" Au爷faebdc:"我rank1了" 蒟蒻:"......" 两天后 蒟蒻:"我过了" Au爷faebdc:"......" --------------------------------------------------------------
SDOI2010 猪国杀
YangHao5的博客
04-04 3721
题目描述 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（FP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力都是4。 开始游戏时，从主猪开始，按照...
【模拟】【bzoj1972】【SDOI2010】猪国杀
Unlimited的博客
05-18 506
1972:[SDOI2010]猪国杀 【题目描述】 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（AP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，...
BZOJ 4698: Sdoi2008 Sandy的卡片
热门推荐
LZJ209的博客
12-30 1万+
这道题看到加几个数就能变成另一个数就知道是差分啦，然后显而易见的就是最后的答案为所有串的最长公共串+1，那我们之后怎么办呢，我们先对所有串建一个广义后缀自动机，然后在自动机上搜寻每一个单词，对单词的每一个节点一直跳parent指针，路径上每一个点的次数加一，统计出所有访问次数为字符串总数的长度最大值就好啦，为了不重复访问，我们将每一个点弄一个标记，为了防止繁琐的清空操作，弄一个时间戳就好啦。我这个傻
bzoj 4818: [Sdoi2017]序列计数 动态规划+矩阵乘法
beginend
04-11 1828
题意Alice想要得到一个长度为nn的序列，序列中的数都是不超过mm的正整数，而且这nn个数的和是pp的倍数。 Alice还希望，这nn个数中，至少有一个数是质数。 Alice想知道，有多少个序列满足她的要求。 对100%100\%的数据，1≤n≤109,1≤m≤2×107,1≤p≤1001\leq n \leq 10^9,1\leq m \leq 2×10^7,1\leq p\leq 100
[BZOJ1972][Sdoi2010]猪国杀（大模拟）
zyf2000
02-28 1136
吐槽这题真的写了一天啊… 虽然我码力太弱是主要因素，但是题面确实是挺难懂的！ 所以自己将题面和数据范围做了改进，避免了一些不必要的坑点，最后又加入了一些自己写的时候发现的奇奇怪怪的问题，应该会比原题面清楚些，欢迎大家来读…题目描述《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的 主猪（MP）：自己
1972: [Sdoi2010]猪国杀
limboman的博客
06-21 1010
来道大模拟 oi生涯中写过最长代码 #include<cstdio> #include<cstring> #include<cstdlib> #include<cmath> #include<vector> #include<algorithm> #include<deque> #include<queue> #define rep(i,k,n) for(int i=k;i<=(n);i++) #
猪国杀
PUBG___的博客
01-16 1107
#include&lt;bits/stdc++.h&gt; using namespace std; const bool diff[3][3]={{0,0,1},{0,0,1},{1,1,0}}; const int M=2005; int n,m,fanzhu,deadfan,rounds,tmp[M],used[M]; char ch,cu; struct PIGS {int iden,bl...
P2482 [SDOI2010]猪国杀 【题解】
魃魈魁鬾魑魅魍魉的博客
04-08 987
题目简述： 这是一道非常善良的凉心模拟题。。。 <身份>： 主猪（主公）：MP 忠猪（忠臣）：ZP 反猪（反贼）：FP <基本牌>： 杀：K 闪：D 桃：P <锦囊牌>： 万箭齐发：W 南猪入侵：N 无懈可击：J 决斗：F <装备牌>： 猪哥连弩：Z <概念> 伤害来源： 杀、南猪入侵、决斗、万箭齐发的伤害来源均是使用该牌的猪 距离： ...
[SDOI2010] 猪国杀
weixin_30915275的博客
11-02 242
NOIp前最后皮一下，祝自己RP++。 从昨天晚上开始写，一直写到现在才A...... 在LXD大佬的帮助下，终于A掉了...... 还发现有两道大模拟，一个是琪露诺的冰雪小屋，一个是杀蚂蚁，有兴趣的可以看一下。 先说这个猪国杀： 洛谷 P2482 传送门 我写了几个指针只是为了简化代码QAQ。 这道题题意挺清楚的，我就说几个坑点。 一个是如果牌堆里没牌了，要一直拿最后一个。 还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值