BZOJ 1500 NOI 2005 维修数列 Splay

最新推荐文章于 2024-07-06 14:24:03 发布
最新推荐文章于 2024-07-06 14:24:03 发布
阅读量1.2k 收藏
点赞数
分类专栏： BZOJ 文章标签： Splay tree 平衡树 NOI2005 数据结构 维修数列
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jiangyuze831/article/details/39098481
版权

题意：见下图


传说级别的NOI数据结构神题，像我这种弱渣花了一下午的时间才A掉，最后发现竟然是边界值的问题没处理好。。


这个题对Splay的所有操作基本是全了。

插入：新建一颗Splay Tree，然后把对应节点Splay到根的右儿子上，再把新建的树连上。

删除：把要删除的区间Splay到根的右儿子的左儿子上，递归free掉。（这里可以用数组优化，可以避免递归free节省时间）

修改，翻转：打标记，在需要的时候下传标记，和线段树差不多，翻转标记下传时，要将左右儿子的左右儿子分别交换。

求和：维护一个sum域。

求最大子列和：与线段树类似。维护一个区间从左边开始连续最大值，从右边开始连续最大值，整体的连续最大值。更新的时候注意下细节。不会的可以先去写vijos的小白逛公园，线段树的最大子列和，要比这个简单一些。详情见代码。


CODE（BZOJ5988ms）：


#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define MAX 600010
#define INF 0x7f7f7f7f
using namespace std;
const char INSERT[] = "INSERT";
const char DELETE[] = "DELETE";
const char REVERSE[] = "REVERSE";
const char GET_SUM[] = "GET-SUM";
const char MAX_SUM[] = "MAX-SUM";
const char MAKE_SAME[] = "MAKE-SAME";
 
struct Complex{
    int val,size;
    bool change,reverse;
    int change_into;
    int sum;
    int l,r,all;
    Complex *son[2],*father;
     
    bool Check() {
        return father->son[1] == this;
    }
    void Combine(Complex *a,bool dir) {
        son[dir] = a;
        a->father = this;
    }
    void Reverse() {
        reverse ^= 1;
        swap(son[0],son[1]);
        swap(l,r);
    }
    void Change(int x) {
        val = x;
        sum = x * size;
        l = r = all = max(sum,val);
        change = true;
        change_into = x;
    }
}none,*nil = &none,*root = nil;
 
void Pretreatment();
inline Complex *NewComplex(int x);  
inline void Rotate(Complex *a,bool dir);
inline void Splay(Complex *a,Complex *aim);
Complex *BuildTree(int l,int r);
inline void SplaySeg(int st,int ed);    
inline void PushUp(Complex *a); 
inline void PushDown(Complex *a);
void Delete(Complex *a);
Complex *FindK(Complex *a,int k);
 
void Print(Complex *a)
{
    if(a == nil)    return ;
    PushDown(a);
    PushUp(a);
    Print(a->son[0]);
    printf("%d ",a->val);
    Print(a->son[1]);
}
 
int cnt,asks;
int pos,num;
 
int temp[MAX];
char s[20];
 
int main()
{
    cin >> cnt >> asks;
    Pretreatment();
    for(int i = 1;i <= cnt; ++i) 
        scanf("%d",&temp[i]);
    root = BuildTree(0,cnt + 1);
    root->father = nil;
    for(int i = 1;i <= asks; ++i) {
        scanf("%s",s);
        if(!strcmp(s,INSERT)) {
            scanf("%d%d",&pos,&cnt),pos++;
            for(int i = 1;i <= cnt; ++i)
                scanf("%d",&temp[i]);
            Splay(FindK(root,pos),nil);
            Splay(FindK(root,pos + 1),root);
            root->son[1]->Combine(BuildTree(1,cnt),false);
            PushUp(root->son[1]),PushUp(root);
        }
        else if(!strcmp(s,DELETE)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            Delete(root->son[1]->son[0]);
            root->son[1]->son[0] = nil;
            PushUp(root->son[1]),PushUp(root);
        }
        else if(!strcmp(s,MAKE_SAME)) {
            scanf("%d%d%d",&pos,&cnt,&num);
            SplaySeg(pos,pos + cnt - 1);
            root->son[1]->son[0]->Change(num);
            PushUp(root->son[1]),PushUp(root);           
        }
        else if(!strcmp(s,REVERSE)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            root->son[1]->son[0]->Reverse();
            PushUp(root->son[1]),PushUp(root);           
        }
        else if(!strcmp(s,GET_SUM)) {
            scanf("%d%d",&pos,&cnt);
            SplaySeg(pos,pos + cnt - 1);
            printf("%d\n",root->son[1]->son[0]->sum);
        }
        else if(!strcmp(s,MAX_SUM)) {
            int temp = root->size;
            Splay(FindK(root,1),nil);
            Splay(FindK(root,temp),root);
            printf("%d\n",root->son[1]->son[0]->all);
        }
    }
    return 0;
}
 
void Pretreatment()
{
    nil->son[0] = nil->son[1] = nil;
    nil->father = nil;
    nil->size = 0;
    nil->all = -INF;
    temp[0] = temp[cnt + 1] = -INF;
}
 
inline Complex *NewComplex(int x)
{
    Complex *re = new Complex();
    re->son[0] = re->son[1] = nil;
    re->size = 1;
    re->sum = re->l = re->r = re->all = re->val = x;
    re->change = re->reverse = false;
    return re;
}
 
inline void Rotate(Complex *a,bool dir)
{
    Complex *f = a->father;
    PushDown(f),PushDown(a);
    f->son[!dir] = a->son[dir];
    f->son[!dir]->father = f;
    a->son[dir] = f;
    a->father = f->father;
    f->father->son[f->Check()] = a;
    f->father = a;
    PushUp(f);
    if(root == f)   root = a;
}
 
inline void Splay(Complex *a,Complex *aim)
{
    while(a->father != aim) {
        if(a->father->father == aim) 
            Rotate(a,!a->Check());
        else if(!a->father->Check()) {
            if(!a->Check()) {
                Rotate(a->father,true);
                Rotate(a,true);
            }
            else {
                Rotate(a,false);
                Rotate(a,true);
            }
        }
        else {
            if(a->Check()) {
                Rotate(a->father,false);
                Rotate(a,false);
            }
            else {
                Rotate(a,true);
                Rotate(a,false);
            }
        }
        PushUp(a);
    }
}
 
Complex *BuildTree(int l,int r)
{
    if(l > r)    return nil;
    int mid = (l + r) >> 1;
    Complex *now = NewComplex(temp[mid]);
    now->Combine(BuildTree(l,mid - 1),false);
    now->Combine(BuildTree(mid + 1,r),true);
    if(l != r)
        PushUp(now);
    return now;
}
 
void Delete(Complex *a)
{
    if(a == nil)    return ;
    Delete(a->son[0]),Delete(a->son[1]);
    free(a);
}
 
inline void SplaySeg(int st,int ed)
{
    st += 1,ed += 1;
    Splay(FindK(root,st - 1),nil);
    Splay(FindK(root,ed + 1),root);
}
 
Complex *FindK(Complex *a,int k)
{
    PushDown(a);
    if(k <= a->son[0]->size)
        return FindK(a->son[0],k);
    k -= a->son[0]->size;
    if(k == 1)  return a;
    --k;
    return FindK(a->son[1],k);
}
 
inline void PushDown(Complex *a)
{
    if(a == nil)    return ;
    if(a->change) {
        if(a->son[0] != nil)
            a->son[0]->Change(a->change_into);
        if(a->son[1] != nil)
            a->son[1]->Change(a->change_into);
        a->change = false;
    }
    if(a->reverse) {
        if(a->son[0] != nil)
            a->son[0]->Reverse();
        if(a->son[1] != nil)
            a->son[1]->Reverse();
        a->reverse = false;
    }
}
 
inline void PushUp(Complex *a)
{
    if(a == nil)    return ;
    a->size = a->son[0]->size + a->son[1]->size + 1;
    a->sum = a->son[0]->sum + a->son[1]->sum + a->val;
    a->l = max(a->son[0]->l,a->son[0]->sum + a->val + max(0,a->son[1]->l));
    a->r = max(a->son[1]->r,a->son[1]->sum + a->val + max(0,a->son[0]->r));
    a->all = max(max(a->son[0]->all,a->son[1]->all),a->val+max(0,a->son[0]->r)+max(0,a->son[1]->l));
}


奉上读入优化版本，因为有的OJ卡这个题的常数（比如我们学校自己的oj）

同学帮着写的，效率十分可观，BZOJ3472ms就过了


CODE（读入优化）：


#include <cstdio>  
#include <cstring>  
#include <iostream>  
#include <algorithm> 
#include <cctype>

#define MAX 600010  
#define INF 0x7f7f7f7f  
using namespace std;  

inline int getc() {
    static const int L = 1 << 15;
    static char buf[L], *S = buf, *T = buf;
    if (S == T) {
        T = (S = buf) + fread(buf, 1, L, stdin);
        if (S == T)
            return EOF;
    }
    return *S++;
}
inline int getint() {
    int c;
    while(!isdigit(c = getc()) && c != '-');
    bool sign = c == '-';
    int tmp = sign ? 0 : c - '0';
    while(isdigit(c = getc()))
        tmp = (tmp << 1) + (tmp << 3) + c - '0';
    return sign ? -tmp : tmp;
}

struct Twochar {
    char c0, c1;
    Twochar(char _c0 = 0, char _c1 = 0):c0(_c0),c1(_c1){}
};
inline Twochar getch() {
    int c;
    while((c = getc()) != 'I' && c != 'D' && c != 'M' && c != 'R' && c != 'G');
    int c2 = getc();
    c2 = getc();
    if(c == 'I'&&c2=='S')getc(),getc(),getc();
    if(c == 'D'&&c2=='L')getc(),getc(),getc();
    if(c=='M'&&c2=='K')getc(),getc(),getc(),getc(),getc();
    if(c=='R'&&c2=='V')getc(),getc(),getc(),getc();
    if(c=='G'&&c2=='T')getc(),getc(),getc(),getc();
    if(c=='M'&&c2=='X')getc(),getc(),getc(),getc();
    return Twochar(c, c2);
} 

struct Complex{  
    int val,size;  
    bool change,reverse;  
    int change_into;  
    int sum;  
    int l,r,all;  
    Complex *son[2],*father;  
       
    bool Check() {  
        return father->son[1] == this;  
    }  
    void Combine(Complex *a,bool dir) {  
        son[dir] = a;  
        a->father = this;  
    }  
    void Reverse() {  
        reverse ^= 1;  
        swap(son[0],son[1]);  
        swap(l,r);  
    }  
    void Change(int x) {  
        val = x;  
        sum = x * size;  
        l = r = all = max(sum,val);  
        change = true;  
        change_into = x;  
    }  
}none,*nil = &none,*root = nil;  
   
void Pretreatment();  
inline Complex *NewComplex(int x);    
inline void Rotate(Complex *a,bool dir);  
inline void Splay(Complex *a,Complex *aim);  
Complex *BuildTree(int l,int r);  
inline void SplaySeg(int st,int ed);      
inline void PushUp(Complex *a);   
inline void PushDown(Complex *a);  
void Delete(Complex *a);  
Complex *FindK(Complex *a,int k);  
   
int cnt,asks;  
int pos,num;  
   
int temp[MAX];  
   
int main()  
{  
    cnt = getint();
    asks = getint();
    Pretreatment();  
    for(int i = 1;i <= cnt; ++i)   
        temp[i] = getint();
    root = BuildTree(0,cnt + 1);  
    root->father = nil; 

    Twochar s;
    for(int i = 1;i <= asks; ++i) {  
        s = getch();
        if(s.c0 == 'I' && s.c1 == 'S') {  
           pos=getint(),cnt=getint(),pos++;  
            for(int i = 1;i <= cnt; ++i)  
                temp[i]=getint();
            Splay(FindK(root,pos),nil);  
            Splay(FindK(root,pos + 1),root);  
            root->son[1]->Combine(BuildTree(1,cnt),false);  
            PushUp(root->son[1]),PushUp(root);  
        }  
        else if(s.c0 == 'D' && s.c1 == 'L') {  
            pos=getint(),cnt=getint();
            SplaySeg(pos,pos + cnt - 1);  
            Delete(root->son[1]->son[0]);  
            root->son[1]->son[0] = nil;  
            PushUp(root->son[1]),PushUp(root);  
        }  
        else if(s.c0 == 'M' && s.c1 == 'K') {  
            pos=getint(),cnt=getint(),num=getint();
            SplaySeg(pos,pos + cnt - 1);  
            root->son[1]->son[0]->Change(num);  
            PushUp(root->son[1]),PushUp(root);             
        }  
        else if(s.c0 == 'R' && s.c1 == 'V') {  
            pos=getint(),cnt=getint(); 
            SplaySeg(pos,pos + cnt - 1);  
            root->son[1]->son[0]->Reverse();  
            PushUp(root->son[1]),PushUp(root);             
        }  
        else if(s.c0 == 'G' && s.c1 == 'T') {  
            pos=getint(),cnt=getint(); 
            SplaySeg(pos,pos + cnt - 1);  
            printf("%d\n",root->son[1]->son[0]->sum);  
        }  
        else if(s.c0 == 'M' && s.c1 == 'X') {  
            int temp = root->size;  
            Splay(FindK(root,1),nil);  
            Splay(FindK(root,temp),root);  
            printf("%d\n",root->son[1]->son[0]->all);  
        }  
    }  
    return 0;  
}  
   
void Pretreatment()  
{  
    nil->son[0] = nil->son[1] = nil;  
    nil->father = nil;  
    nil->size = 0;  
    nil->all = -INF;  
    temp[0] = temp[cnt + 1] = -INF;  
}  
   
inline Complex *NewComplex(int x)  
{  
    Complex *re = new Complex();  
    re->son[0] = re->son[1] = nil;  
    re->size = 1;  
    re->sum = re->l = re->r = re->all = re->val = x;  
    re->change = re->reverse = false;  
    return re;  
}  
   
inline void Rotate(Complex *a,bool dir)  
{  
    Complex *f = a->father;  
    PushDown(f),PushDown(a);  
    f->son[!dir] = a->son[dir];  
    f->son[!dir]->father = f;  
    a->son[dir] = f;  
    a->father = f->father;  
    f->father->son[f->Check()] = a;  
    f->father = a;  
    PushUp(f);  
    if(root == f)   root = a;  
}  
   
inline void Splay(Complex *a,Complex *aim)  
{  
    while(a->father != aim) {  
        if(a->father->father == aim)   
            Rotate(a,!a->Check());  
        else if(!a->father->Check()) {  
            if(!a->Check()) {  
                Rotate(a->father,true);  
                Rotate(a,true);  
            }  
            else {  
                Rotate(a,false);  
                Rotate(a,true);  
            }  
        }  
        else {  
            if(a->Check()) {  
                Rotate(a->father,false);  
                Rotate(a,false);  
            }  
            else {  
                Rotate(a,true);  
                Rotate(a,false);  
            }  
        }  
    }
    PushUp(a);   
}  
   
Complex *BuildTree(int l,int r)  
{  
    if(l > r)    return nil;  
    int mid = (l + r) >> 1;  
    Complex *now = NewComplex(temp[mid]);  
    now->Combine(BuildTree(l,mid - 1),false);  
    now->Combine(BuildTree(mid + 1,r),true);  
    if(l != r)  
        PushUp(now);  
    return now;  
}  
   
void Delete(Complex *a)  
{  
    if(a == nil)    return ;  
    Delete(a->son[0]),Delete(a->son[1]);  
    free(a);  
}  
   
inline void SplaySeg(int st,int ed)  
{  
    st += 1,ed += 1;  
    Splay(FindK(root,st - 1),nil);  
    Splay(FindK(root,ed + 1),root);  
}  
   
Complex *FindK(Complex *a,int k)  
{  
    PushDown(a);  
    if(k <= a->son[0]->size)  
        return FindK(a->son[0],k);  
    k -= a->son[0]->size;  
    if(k == 1)  return a;  
    --k;  
    return FindK(a->son[1],k);  
}  
   
inline void PushDown(Complex *a)  
{  
    if(a == nil)    return ;  
    if(a->change) {  
        if(a->son[0] != nil)  
            a->son[0]->Change(a->change_into);  
        if(a->son[1] != nil)  
            a->son[1]->Change(a->change_into);  
        a->change = false;  
    }  
    if(a->reverse) {  
        if(a->son[0] != nil)  
            a->son[0]->Reverse();  
        if(a->son[1] != nil)  
            a->son[1]->Reverse();  
        a->reverse = false;  
    }  
}  
   
inline void PushUp(Complex *a)  
{  
    if(a == nil)    return ;  
    a->size = a->son[0]->size + a->son[1]->size + 1;  
    a->sum = a->son[0]->sum + a->son[1]->sum + a->val;  
    a->l = max(a->son[0]->l,a->son[0]->sum + a->val + max(0,a->son[1]->l));  
    a->r = max(a->son[1]->r,a->son[1]->sum + a->val + max(0,a->son[0]->r));  
    a->all = max(max(a->son[0]->all,a->son[1]->all),a->val+max(0,a->son[0]->r)+max(0,a->son[1]->l));  
}



16bit戦争
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
bzoj 1500 NOI2005 维修数列 [Splay]
C'est la vie.
08-02 474
维修数列Time Limit: 10 Sec Memory Limit: 64 MB Submit: 11839 Solved: 3724Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。 第2行包含N个数字，描述初始时的数列。 以下M行，每行一条命令，格式参见问题描述中的表格。 任何时刻
陈立杰历年课件和BZOJ代码
12-04
【陈立杰历年课件和BZOJ代码】是一个集合，包含了知名算法竞赛选手陈立杰（WJMZBMR）在过去的时间里所使用的课件以及他在BZOJ（Best Wrong Judge Online Judge）平台上提交的大部分代码。这个资源对于学习算法、C++...
BZOJ 1500 NOI2005 维修数列 Splay
世界
09-18 1827
我尽力了。。。从之前的递归版Splay变成非递归，然后各种删除冗余的操作，除了蛋疼的读入优化基本已经精简到底了，连传参都省了-0- 刚交上去是10956MS，差4MS就是BZOJ倒数第一，改完了是9244MS，快了一秒。。。单点测还是死活过不去，等加上读入优化再说吧 题目大意：维护一个序列，支持六种操作： 1.在某个数后面插入一些数字 2.删除从某个数开始的一些数字 3.把从某个数开始的一
[BZOJ1500]NOI2005 维修数列|splay
Tag_king的专栏
04-18 1819
这题号称是noi出过最变态的数据结构题，，感觉还差不多嘛。。一开始我一直在纠结splay上的节点一点要有一个key值的啊，要是以这个数在序列中的位置作为key值的话又要插入又要删除肯定弄不了。。然后想了很久突然顿悟。。貌似我给一个初始顺序以后是不用访问key的&&找第k位的数只要写一个findkth就行了嘛。。（当时太弱） 然后我就一口气写了下来。。 对每个节点维护size，sum，maxsu
BZOJ1500 NOI2005 维修数列 平衡树
a18700013354的博客
02-26 95
题意：给定一个数列，要求维护：1、在p之后加入tot个数 2、删除p之后tot个数 3、将p之后tot个数修改为c 4、翻转p之后tot个数 5、输出p之后tot个数的和 6、输出整个数列的最大子段和。 题解：平衡树很经典的题目了……主要说一下4和6操作，4的话因为翻转操作是可以分治的，所以可以用翻转标记；6我们维护一个节点所维护的区间的的最大子段和ms、从左开始的最大子段和...
bzoj1500 noi2005 维修数列
C_K_Y_的博客
01-14 374
1500: [NOI2005]维修数列Time Limit: 10 Sec  Memory Limit: 64 MBSubmit: 15855  Solved: 5269[Submit][Status][Discuss]DescriptionInput输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。...
BZOJ 1500 NOI2005 维修数列 题解
weixin_30315435的博客
03-16 105
题目大意：要求维护一个序列，支持插入，删除，修改（将一段区间内的数全部设置为c），区间翻转，区间求和，区间最大和。 splay维护。其中区间最大和用一个mmax值来记录，需要用lmax和rmax来辅助（代表前缀最大和和后缀最大和）。 mmax有三种情况：区间全部在左子树中，区间全部在右子树中，区间跨越左右子树。 lmax有两种情况：区间全部在左子树中，区间跨越左右子树。这样更新一下即可。 ...
【bzoj1500】[NOI2005]维修数列
wang_sj的博客
03-25 328
DescriptionInput输入文件的第1行包含两个数N和M，N表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下M行，每行一条命令，格式参见问题描述中的表格。Output对于输入数据中的GET-SUM和MAX-SUM操作，向输出文件依次打印结果，每个答案（数字）占一行。Sample Input9 8 2 -6 3 5 1 -5 -3 6 3 GET
BZOJ1500 [NOI2005]维修数列 splay
weixin_30872789的博客
12-25 71
原文链接http://www.cnblogs.com/zhouzhendong/p/8108676.html 题目传送门 - BZOJ1500 题意概括 Description Input 输入的第1 行包含两个数N 和M(M ≤20 000)，N 表示初始时数列中数的个数，M表示要进行的操作数目。第2行包含N个数字，描述初始时的数列。以下M行，每行一条命令，格式...
洛谷2042 bzoj1500 NOI2005 维护数列
forever_shi的博客
04-02 157
题意： 给你一个数列，你需要对它进行如下操作： 1.在某一个数后面插入连续的一些数 2.从某个数开始连续删除一些数 3.把从某个数开始的连续的一些数全部变为x 4.区间翻转 5.区间求和 6.区间最大子列 由于要区间翻转，所以建两个虚拟节点1号节点和n+2号节点，以便区间翻转。 插入连续的区间的话可以先把这个序列建成一棵平衡的树，再把k+1旋转到根，原来的k+2变为k+1的右子树...
bzoj测试数据118题数据
05-07
八中OJ,又简作BZOJ,以原题巨多而著称，该数据为BZOJ上的1000-1109和1130-1139的测试数据节点，没有题目，有需要题目的可以到https://hydro.ac/d/bzoj/p网站查找对应的题目。
BZOJ全代码
02-05
【标题】"BZOJ全代码"所指的是一份包含BZOJ（BestCoder Zhijiang Online Judge）平台所有编程题目解决方案的压缩文件。BZOJ是一个在线编程竞赛平台，它提供了大量的算法题目供参赛者练习和提交代码，以检验编程能力...
BZOJ第一部分
11-03
【BZOJ第一部分】 BZOJ，全称为“北京邮电大学在线评测系统”（Beijing Zhiyuan Online Judge），是中国最早的一批在线编程竞赛平台之一，它为编程爱好者提供了一个练习和检验编程技能的环境。在这个系统中，用户...
BZOJ3230相似子串测试数据
08-19
标题"BZOJ3230相似子串测试数据"指的是一个与在线判题平台BZOJ（BestCoder ZOJ，中国大学算法竞赛在线评测系统）相关的编程问题，具体问题编号为3230，涉及的主要知识点是"相似子串"的搜索和处理。在编程竞赛中，...
[数据结构] 基于插入的排序 插入排序&希尔排序
水墨不写bug
07-06 955
插入排序&&希尔排序 实现原理
【数据结构】（6.3）堆的应用——堆排序（C语言）
金哥的博客
07-05 357
堆排序（Heap Sort）就是对直接选择排序的一种改进。此话怎讲呢？直接选择排序在待排序的n个数中进行n-1次比较选出最大或者最小的，但是在选出最大或者最小的数后，并没有对原来的序列进行改变，这使得下一次选数时还需要对全部数据进行比较，效率大大降低。堆排序算法是Floyd和Williams在1964年共同发明的，同时他们发明了“堆”这种数据结构。
(5) 深入探索Python-Pandas库的核心数据结构：Series详解
最新发布
架构筑梦的Cherry Yang的博客
07-06 884
# 1. Series 简介 pandas数据结构中的Series是一个一维数组对象，能够保存任何数据类型（整数、字符串、浮点数、Python对象等），并有一个与之关联的标签序列，这些标签被称为“索引”（index）。索引与数据是一一对应的，通过索引可以快速获取、更新或删除数据。Series在pandas数据处理中起着至关重要的作用，是构建更复杂数据结构（如DataFrame）的基础。 以下是关于pandas Series的详细解释： * **定义**：Series类似于一维数组或列表，但它有一个显式的
数据结构第07节：队列
hummhumm的专栏
07-04 486
在计算机科学中，队列是一种抽象数据类型，它遵循先进先出（FIFO）原则，即最先加入队列的元素将是最先被移除的。在学生成绩管理系统中，队列可以用于管理等待处理的成绩更新请求，或者用于存储等待查询成绩的学生ID列表。请注意，这个实现假设所有学生ID都是整数，并且队列的大小是固定的。这个队列将用于管理学生的ID，模拟学生成绩管理系统中可能用到的队列操作。下面，我将以一个简单的学生成绩管理系统中的队列应用为例，用表格形式来详细讲解队列的操作和状态变化。类，它包含书籍的基本信息，例如书名、作者和ISBN号。
bzoj.org俄罗斯方块
05-06
bzoj.org是一个在线的编程题库，其中包含了很多经典算法问题和实际应用中的编程问题。其中包括了很多有趣的游戏算法问题，比如Puzzle，Tetris等。 而bzoj.org俄罗斯方块就是在该平台上的一个经典的俄罗斯方块游戏。...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值