洛谷P2482 猪国杀题解

最新推荐文章于 2024-07-30 15:57:45 发布
原创 最新推荐文章于 2024-07-30 15:57:45 发布 · 2.2k 阅读 · 5 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

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

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

- 题目简介：

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

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

- 题解正文：

1.三种Pig各自的特点：

MP[主猪]：
  1. 游戏开始时所有Pig就已经知道MP的身份，所以init函数要在游戏开始前把MP的way设为1（跳忠）。
  2. MP有可能会去攻击way为3的Pig（类反猪）,需要特殊处理。
  3. MP也会攻击FP。
  4. 如果MP寄了游戏结束。
ZP[忠猪]:
  1. 当MP对ZP使用F时，ZP只能被动挨打，真惨不能使用K。
  2. 只会攻击已经跳反的Pig。
  3. 如果跳忠就把它的way设为1。
FP[反猪]:
  1. 只会攻击已经跳忠的Pig。
  2. 只会对MP使用F。
  3. 如果跳反就把它的way设为2。
  4. 如果所有的FP都寄了就游戏结束。

2. 八种牌的注意事项：

P[桃]：
  1. P只能在自己回合或者血量小于等于0的时候才可以使用。在自己回合时血量最多可以回满，但在其它Pig的回合时最多将血量恢复到1。
K[杀]：
  1. 如果没有Z每回合只能打一张K。
  2. 对方使用F或N的时候会不予余力的弃置（MP攻击ZP除外）。
  3. 使用后要查看游戏是否结束。
  4. 只能在条件成立时攻击逆时针数第一只Pig。
D[闪]:
  1. 对方使用K或W的时候会不予余力的弃置。
F[决斗]:
  1. 使用F的Pig（攻击方）有可能会寄掉（Pig真聪明），如果寄掉的话要立刻停止关于它的所有函数。
  2. 需要判断攻击方和被攻击方卡牌的变化：干掉FP会摸三张牌和MP干掉ZP的话MP的牌会被清空这两种情况。
  3. 要注意双方K的消耗，被攻击方先出K。如果攻击方的K的数量 < 被攻击方的K的数量的话，因为被攻击方先出K，所以被攻击方要消耗攻击方的K的数量+1张K，否则攻击方要消耗被攻击方的K的数量张K。
  4. 使用后要查看游戏是否结束。
N[南猪入侵] 和 W[万箭齐发]:

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

  1. 只要还有N和W就会不断出直到游戏结束或出完。
  2. 分清这两种卡分别使用哪种卡来抵消（N用K抵消，W用D抵消）。
  3. 每循环到一只Pig就要查看游戏是否结束。
  4. 如果攻击方没有表明身份就要把它的way设为3（类反猪）。
Z[猪哥连弩]：
  1. 在遇到第一个K时判断是否已经装备Z，如果没有Z就从头到尾全部搜索一遍，一旦遇到Z就停止查找并装备上。
  2. 在搜到Z时就将它装备上。
J[无懈可击]：
  1. 使用前要看对方的身份，在通过自己的身份来确定为跳忠或跳反。
  2. 忠猪不会跳反，反猪不会跳忠，需要使用的时候会不予余力的弃置。Pig们会在符合条件的情况下不断出J直到出完。
  3. 不会对未表明身份的Pig献殷勤或表敌意，包括自己。
  4. 因为无懈可击可以被无懈可击给无懈可击掉，所以需要不断的循环直到没有Pig出无懈可击时才能结束判断。
  5. 全场只要有Pig出F，W，N和J这4种牌就运行。

3. 一些细节：

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

Jerry_Mouse101
关注
洛谷P2482 [SDOI2010]猪国杀 坑点总结
suolk的博客
03-19 734
总结了几个坑点… 使用锦囊牌时可能存在跳反或跳忠（打出无懈可击）的情况，一旦出现了有可能要从头检索是否有可使用的杀或决斗 装备诸葛连弩时同理； 对别人打出决斗自己可能会死，此时需要中断回合； 反猪的决斗一定是对主猪用的； 主猪杀了忠猪后，弃牌的时候不要忘了诸葛连弩； 同时不要忘了此时遍历的手牌已经没了； 但是不能直接中断回合，比如忠猪如果死于万箭齐发，那么在它之后还可能有反猪因此死掉，这种情况下主公会摸三张牌，回合仍可能继续； 角色死后不要鞭尸，南蛮入侵、万箭齐发等需要遍历玩家的情况记得跳过死者； 一有角
[SDOI2010]猪国杀题解
hht的博客
09-16 1559
文章目录题目链接：sol游戏结束、一些数组/变量每个猪的结构体：献殷勤、表敌意、跳忠、跳反伤害、死亡无懈可击主要操作完整代码AC代码观战模式 题目链接： 洛谷P2482 loj2885 bzoj1972 推荐去loj看题，可以下数据因为特别容易出错。 sol 其实这题码量也没那大，格式化后我的代码只有141行，在loj目前最短。最好多些一些函数，给每个猪开一个结构体。 游戏结束、一些数组/变量 之...
三国杀周边--------猪国杀题解
NOI RP++
06-09 2237
大大大大大大大大大模拟--------猪国杀 三国杀周边
洛谷P2482 [SDOI2010]猪国杀 题解
eliyou的博客
05-17 2549
开学快乐，整点活儿
[洛谷P2482][SDOI2010]猪国杀
weixin_34221073的博客
10-26 268
题目大意：猪国杀，又一道大模拟题 题解：模拟，对于一个没有玩过三国杀的人来说，一堆细节不知道，写的十分吃力 卡点：无数，不想说什么了，这告诉我要多玩游戏 C++ Code： #include <algorithm> #include <cstdlib> #include <cstdio> #include <iostream>...
洛谷 P2482 loj #2885 [SDOI2010]猪国杀 题解【模拟】【贪心】【搜索】
wjyyy的博客
02-11 650
好玩的模拟题。 以后要经常写模拟题鸭 题目描述 游戏背景 《猪国杀》是一种多猪牌类回合制游戏，一共有333种角色：主猪，忠猪，反猪。每局游戏主猪有且只有111只，忠猪和反猪可以有多只，每只猪扮演111种角色。 游戏目的 主猪 / MP：自己存活的情况下消灭所有的反猪。 忠猪 / ZP：不惜一切保护主猪，胜利条件与主猪相同。 反猪 / AP：杀死主猪。 游戏过程 游戏开始时，每个玩家手里都会有...
洛谷 P1097 统计数字题解
EricZhourenyu的博客
07-30 684
这道题的代码不难，思路有一点难想。建议初学者和蒟蒻自己认真将题目做一遍之后再来，并且这道题建议大家尝试多种解题方案，这样会更有收获\(^o^)/~。
洛谷P1603 斯诺登的密码 题解
Super500000的博客
05-13 1071
蒟蒻来写题解了 说是水题其实也就是慢慢写能写出来的题吧，这道题有挺多坑的，要注意的点： 1.除了第一位数是个位数，直接输出，其他的个位数都要补0达到两位，例如：925和2509，这里只是单纯讨论输出问题 2.还有一个很多人理解题意容易误解的地方就是925不是比259大吗，为什么输出925，他这里是9和25比较，9比较小，所以就排前面了，和整个数大小无关 3.还有一个坑，读题要仔细，another算1处理，first,a,也算1，both，second算2，third算3 废话不多说，上代码，蒟蒻第一次写洛谷
信息学奥赛c++洛谷scp-s模拟赛题解
09-01
洛谷网校提供的模拟赛题解，能够帮助参赛者更好地理解题目要求，掌握解题技巧，提升实战能力。 在C++编程中，编译命令的选择是基础。通常情况下，编译C++源代码文件使用的命令是g++而非gcc，因为gcc主要用于C语言...
洛谷 P1253 扶苏的问题 题解 线段树
一只摸鱼的bbc
06-07 1403
线段树 区间修改 区间加数 区间最值 洛谷题解 C++代码 附详细注释
洛谷P1724题解（请不要抄袭！）
06-17
洛谷P1427题解，若要复制or下载，请与我联系，如要改编，也请联系，若发现未经我同意的复制、下载、改编，直接举报。
LuoguP2482 [SDOI2010] 猪国杀 题解 大型模拟题
qq_45523675的博客
02-29 1221
当你发现如论如何也想不知道遗漏了什么之后，你可以将题解代码中的输出注释删除，其运行后会输出每一名角色进行的操作以及操作后的角色状态。一群猪玩猪国杀（类似三国杀），按照特定的规则出牌，问谁能获胜，输出获胜时，存活的猪的手牌。按照上面的思路实现，或者按照自己的思路实现，在实现的过程中注意提到的细节即可。注意到上面的点之后，我们便可以开始做题了。
洛谷P2482 [SDOI2010]猪国杀
moyangxian
06-29 255
#include<bits/stdc++.h> using namespace std; const int N = 20; vector<char> P;//牌堆 int n, m, f; int nxt[N], lst[N]; struct Pig { string name;//真实身份 /* 主猪:MP 忠猪:ZP 反猪:FP */ vector<char> p; int hp;//血量 int z;//是否装连弩 int t;//表面身
[SDOI2010]猪国杀
07-14 339
题目：BZOJ1972、洛谷P2482、codevs1834 题目大意：叫你模拟一个叫“猪国杀”的游戏，并要你输出游戏结果。 解题思路：模拟。并没有什么高深的算法，就是模拟，不过东西很多，很容易乱，于是我调了一上午。。。所以建议在写代码时加上注释，并做好写长代码的准备。 其他注意的是，如果牌堆没牌了，就要一直摸最后那一张牌。 C++ Code： #include<cs...
Luogu P2482 [SDOI2010]猪国杀
macesuted的博客
01-22 1288
Pig Country Kill 很古怪的翻译，不过它确实叫猪(Pig)国(Country)杀(Kill)。 我们来好好整理一下这道题目。题面虽较长，但内容基本清晰，只是有部分很Pig的操作部分，很容易让第一次看见这道题目的人百思不得其解。 先整理一下这道长长的题面。 First：人物 四位玩家，初始四张手牌，血量上限444，初始血量444，会告诉你整个牌堆的牌，每位玩家每个回合从牌堆顶部抽走两...
P2482 [SDOI2010]猪国杀 【题解】
魃魈魁鬾魑魅魍魉的博客
04-08 1036
题目简述： 这是一道非常善良的凉心模拟题。。。 <身份>： 主猪（主公）：MP 忠猪（忠臣）：ZP 反猪（反贼）：FP <基本牌>： 杀：K 闪：D 桃：P <锦囊牌>： 万箭齐发：W 南猪入侵：N 无懈可击：J 决斗：F <装备牌>： 猪哥连弩：Z <概念> 伤害来源： 杀、南猪入侵、决斗、万箭齐发的伤害来源均是使用该牌的猪 距离： ...
猪国杀
胡乐安的博客
08-19 1242
猪国杀 #include&amp;lt;iostream&amp;gt; #include&amp;lt;time.h&amp;gt; #include&amp;lt;stdio.h&amp;gt; #include &amp;lt;stdlib.h&amp;gt; using namespace std; struct pai { int paifu; int huase; int yanse; int dianshu; int lei
Bzoj1972: [Sdoi2010]猪国杀 题解（大模拟+耐心+细心）
weixin_34233856的博客
10-10 261
猪国杀 - 可读版本https://mubu.com/doc/2707815814591da4　 　　题目可真长，读题都要一个小时。 　　这道题很多人都说不可做，耗时间，代码量大，于是，本着不做死就不会死的精神，本蒟蒻强行斯巴达了这群猪。 　　为了给后面入坑的人一些提醒，本题题目较长，请耐心读完题目，否则会导致T,WA,E,特别想吃猪肉和丢脸。 　　据说如...
[sdoi]猪国杀 题面
A_Comme_Amour的博客
02-22 1133
题目描述 Description 《猪国杀》是一种多猪牌类回合制游戏，一共有三种角色：主猪，忠猪，反猪。每局游戏主猪有且只有一只，忠猪和反猪可以有多只，每只猪扮演一种角色。 游戏目的： 主猪（MP）：自己存活的情况下消灭所有的反猪。 忠猪（ZP）：不惜一切保护主猪，胜利条件与主猪相同。 反猪（AP）：杀死主猪。 游戏过程： 游戏开始时候，每个玩家手里都会有4张牌，且体力上限和初始体力...
洛谷P3922 中学数学题题解
最新发布
08-16
洛谷 P3922 题目《改变队列》（暂译名，具体题目请以平台为准）是一道涉及队列操作与数据结构设计的题目。题目的核心要求是通过一系列操作来实现队列中元素的调整，以满足特定条件。 ### 问题分析 题目通常要求维护...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值