poj3580:SuperMemo（块状链表/Splay）

最新推荐文章于 2019-11-17 11:08:32 发布
最新推荐文章于 2019-11-17 11:08:32 发布
阅读量358 收藏
点赞数 1
分类专栏： 平衡树 文章标签： 块状链表 Splay poj
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35649707/article/details/75268557
版权

传送门

  • 题意：

题目要求实现一种数据结构，支持6种操作：
add x,y D：第x个数到第y个数之间的数每个加D；
reverse x y：第x个数到第y个数之间全部数翻转；
revolve x y T：第x个数到第y个数之间的数，向后循环流动T次，即后面T个数变成这段子序列的最前面T个，前面的被挤到后面。
Insert x P：在第x个数后面插入一个数P。
Delete x：删除第x个数。
Min x，y：求第x个数到第y个数之间的最小数字。

  • 题解

1.块状链表。这是很好想而且很好写的，全是暴力操作。感兴趣的可以自己学习学习。（1400ms）

2.Splay。虽然时间复杂度比块状链表优（1087ms，其实也没优什么，主要是Splay常数大），但是代码特别长（块状链表250行，Splay400行）。用Splay主要注意两点，一是打标记（Add，Reverse操作），二是提取区间（即要操作的区间），提取方法很简单，将区间前一位置于rt,将区间后一位置于rt的右儿子，那么对rt右儿子的左儿子操作即可。

主要是Revolve操作有点难写，下面给出做法：

很显然是将[r-c+1,r]的区间提取到[l,r-c]之前，那么先提取前面的区间，再将l-1置为根节点，将l置为l-1的右儿子，将刚才提取的区间置为l左儿子即可。

（注意判断边界以及及时更新。。。）

  • Code1（块状链表）：1454MS
#include <algorithm> 
#include <iostream> 
#include <cstring> 
#include <cstdio> 
#include <cmath> 
using namespace std; 

inline int read(); 
const int N = 1e5 + 5, INF = 0x7fffffff, SIZEINT = sizeof(int); 
const int SQRTN = 500, B = 1000, SMIN = SQRTN / 2, SMAX = SQRTN * 2; 
int n, m, a[N]; 

typedef struct Block* PBlock; 
typedef struct List* PList; 
struct Block 
{ 
    int a[SQRTN * 5]; 
    int size, tag, rev, ans; 

    inline void calc() 
    { 
        tag = rev = 0; ans = INF; 
        for (int i = 0; i < size; ++i) 
        if (a[i] < ans) ans = a[i]; 
    } 

    inline void downdate() 
    { 
        if (tag != 0)
        { 
            for (int i = 0; i < size; ++i)a[i] += tag; 
            tag = 0; 
        } 
        if (rev)
        { 
            rev = 0; 
            for (int i = 0; i << 1 < size; ++i)
            { 
                int t = a[i]; 
                a[i] = a[size - i - 1]; 
                a[size - i - 1] = t; 
            } 
        } 
    } 
}used[B]; 

PBlock pool, *top, unused[B]; 
struct List 
{ 
    PBlock a; 
    PList last, next; 
}USED[B]; 

PList head, tail, POOL, *TOP, UNUSED[B]; 

inline PBlock newBlock() 
{ 
    if (top != unused) return *--top; 
    return pool++; 
} 

inline void delBlock(PBlock x) 
{ 
    *top++ = x; 
} 

inline PList newList() 
{ 
    if (TOP != UNUSED) return *--TOP; 
    return POOL++; 
} 

inline void delList(PList x) 
{ 
    *TOP++ = x; 
} 

inline void Build(int *a, const int &n, PList *h, PList *t) 
{ 
    for (int i = 0; i < n; i += SQRTN) 
    { 
        PList p = newList(); 
        p->a = newBlock(); 
        p->a->size = i + SQRTN < n ? SQRTN : n - i; 
        memcpy(p->a->a, a + i, SIZEINT * p->a->size); 
        p->a->calc(); 
        p->last = *t; p->next = NULL; 
        if (*t != NULL) (*t)->next = p; 
        else *h = p; 
        *t = p; 
    } 
} 

inline void merge(PList x) 
{ 
    PList p = x->next; 
    x->a->downdate(); 
    p->a->downdate(); 
    memcpy(x->a->a + x->a->size, p->a->a, SIZEINT * p->a->size); 
    x->a->size += p->a->size; 
    x->a->calc(); 
    x->next = p->next; 
    if (p->next) p->next->last = x; 
    else tail = x; 
    delBlock(p->a); 
    delList(p); 
} 

inline void split(PList x, const int &n) 
{ 
    PList p = newList(); 
    p->a = newBlock(); 
    x->a->downdate(); 
    p->a->size = x->a->size - n; 
    memcpy(p->a->a, x->a->a + n, SIZEINT * p->a->size); 
    x->a->size = n; 
    x->a->calc(); 
    p->a->calc(); 
    p->next = x->next; 
    if (x->next) x->next->last = p; 
    else tail = p; 
    x->next = p; p->last = x; 
} 

inline void Balance() 
{ 
    for (PList p = head; p; p = p->next) 
    { 
        while (p != tail && p->a->size < SMIN)merge(p); 
        if (p->a->size > SMAX)split(p, SQRTN); 
    } 
} 

inline void Delete(PList x) 
{ 
    if (x->last != NULL) x->last->next = x->next; 
    else head = x->next; 
    if (x->next != NULL) x->next->last = x->last; 
    else tail = x->last; 
    delBlock(x->a); 
    delList(x); 
} 

inline PList findl(int n) 
{ 
    PList p = head; 
    for (; n > p->a->size; p = p->next) n -= p->a->size; 
    if (n != 1) 
    { 
        split(p, n - 1); 
        p = p->next; 
    } 
    return p; 
} 

inline PList findr(int n) 
{ 
    PList p = head; 
    for (; n > p->a->size; p = p->next) n -= p->a->size; 
    if (n != p->a->size) split(p, n); 
    return p; 
} 

inline void Init() 
{ 
    pool = used; POOL = USED; 
    top = unused; TOP = UNUSED; 
    head = tail = NULL; 
} 

char ch; 
inline int read() 
{ 
    int res = 0, sgn = 0; 
    while (ch = getchar(), ch < '0' || ch > '9') if (ch == '-') sgn = 1; 
    res = ch - 48; 
    while (ch = getchar(), ch >= '0' && ch <= '9') res = res * 10 + ch - 48; 

    return sgn ? -res : res; 
} 

int main() 
{ 
    Init(); 
    n = read(); 
    for (int i = 0; i < n; ++i) a[i] = read(); 
    Build(a, n, &head, &tail); 
    m = read(); 
    char type; 
    int l, r, v; 
    PList fr, en, t; 
    PBlock tmp; 
    while (m--) 
    { 
        Balance(); 
        while (type = getchar(), type < 'A' || type > 'Z'); 
        if (type == 'A') 
        { 
            l = read(); r = read(); v = read(); 
            if (l > r) swap(l, r); 
            fr = findl(l); en = findr(r); 
            for (en = en->next; fr != en; fr = fr->next) 
            { 
                fr->a->tag += v; 
                fr->a->ans += v; 
            } 
        } 
        else if (type == 'I') 
        { 
            l = read(); r = read(); 
            fr = findr(l); 
            fr->a->downdate(); 
            fr->a->a[fr->a->size++] = r; 
            if (r < fr->a->ans) fr->a->ans = r; 
        } 
        else if (type == 'D') 
        { 
            l = read(); 
            fr = findl(l); 
            if (fr->a->size != 1) 
            split(fr, 1); 
            Delete(fr); 
        } 
        else if (type == 'M') 
        { 
            l = read(); r = read(); 
            if (l > r) swap(l, r); 
            fr = findl(l); en = findr(r); 
            int ans = INF; 
            for (en = en->next; fr != en; fr = fr->next) 
            if (fr->a->ans < ans) ans = fr->a->ans; 
            printf("%d\n", ans); 
        } 
        else 
        { 
            getchar(); getchar(); type = getchar(); 
            if (type == 'E') 
            { 
                l = read(); r = read(); 
                if (l > r) swap(l, r); 
                fr = findl(l); en = findr(r); 
                while (fr != en && fr != en->next) 
                { 
                    fr->a->rev ^= 1; en->a->rev ^= 1; 
                    tmp = fr->a; 
                    fr->a = en->a; 
                    en->a = tmp; 
                    fr = fr->next; 
                    en = en->last; 
                } 
            if (fr == en) fr->a->rev ^= 1; 
            } 
            else 
            { 
                l = read(); r = read(); 
                if (l > r) swap(l, r); 
                v = read() % (r - l + 1); 
                if (v == 0 || l == r) continue; 
                v = r - l + 1 - v; 
                fr = findl(l); en = findr(r); 
                for (t = fr; v > t->a->size; t = t->next) v -= t->a->size; 
                if (v != t->a->size) 
                { 
                    split(t, v); 
                    if (en == t) en = en->next; 
                } 
                PList p1 = fr->last, p2 = fr, p3 = t, p4 = t->next, p5 = en, 
                p6 = en->next; 
                if (p1 != NULL) 
                { 
                    p1->next = p4; 
                    p4->last = p1; 
                } 
                else head = p4, p4->last = NULL; 
                if (p6 != NULL)
                { 
                    p6->last = p3; 
                    p3->next = p6; 
                } 
                else tail = p3, p3->next = NULL; 
                p5->next = p2; 
                p2->last = p5; 
            } 
        } 
    } 
     return 0; 
}
  • Code2（Splay）:1047ms
#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<string>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
const int Maxn=2e5+50;
const int INF=0x3f3f3f3f;
inline int read()
{
    char ch=getchar();int i=0,f=1;
    while(!isdigit(ch)){if(ch=='-')f=-1;ch=getchar();}
    while(isdigit(ch)){i=(i<<1)+(i<<3)+ch-'0';ch=getchar();}
    return i*f;
}

struct node
{
    node *fa,*lc,*rc;
    int val,taga,tagr,mn,sze;
    node():fa(NULL),lc(NULL),rc(NULL){}
    inline void upt()
    {
        sze=(lc?lc->sze:0)+(rc?rc->sze:0)+1;
        mn=min(val,min(lc?lc->mn:INF,rc?rc->mn:INF));
    }
}POOL[Maxn],*pool=POOL,*rt,*que[Maxn];

int n,m,a[Maxn],bg,ed;
char ch[10];

inline void add(node *now,int val)
{
    now->val+=val;
    now->mn+=val;
    now->taga+=val;
}

inline void addr(node *now)
{
    swap(now->lc,now->rc);
    now->tagr^=1;
}

inline node* newnode(int val)
{
    ++pool;
    pool->val=val;
    pool->mn=val;
    pool->sze=1;
    return pool;
}

inline void build(node *&now,int l,int r)
{
    int mid=(l+r)>>1;
    now=newnode(a[mid]);
    if(l<mid)build(now->lc,l,mid-1);
    if(r>mid)build(now->rc,mid+1,r);
    if(now->lc)now->lc->fa=now;
    if(now->rc)now->rc->fa=now;
    now->upt();
}


inline void pushdown(node *now)
{
    if(now->taga)
    {
        if(now->lc)
        {
            now->lc->mn+=now->taga;
            now->lc->val+=now->taga;
            now->lc->taga+=now->taga;
        }
        if(now->rc)
        {
            now->rc->mn+=now->taga;
            now->rc->val+=now->taga;
            now->rc->taga+=now->taga;
        }
        now->taga=0;
    }
    if(now->tagr)
    {
        if(now->lc)
        {
            swap(now->lc->lc,now->lc->rc);
            now->lc->tagr^=1;
        }
        if(now->rc)
        {
            swap(now->rc->lc,now->rc->rc);
            now->rc->tagr^=1;
        }
        now->tagr^=1;   
    }
}

inline node* find(node *now,int k)
{
    pushdown(now);now->upt();
    if((now->lc?now->lc->sze:0)==k-1)return now;
    else if((now->lc?now->lc->sze:0)>k-1)return find(now->lc,k);
    else return find(now->rc,k-(now->lc?now->lc->sze:0)-1);
}

inline void Rotate(node *x)
{
    node *y=x->fa,*z=y->fa;
    y->fa=x;x->fa=z;
    if(z){((z->lc==y)?(z->lc):(z->rc))=x;}
    if(y->lc==x)
    {
        node* b=x->rc;
        if(b)b->fa=y;
        y->lc=b;
        x->rc=y;
    }
    else
    {
        node* b=x->lc;
        if(b)b->fa=y;
        y->rc=b;
        x->lc=y;
    }
    y->upt();x->upt();
}

inline bool which(node* x)
{
    return x->fa->lc==x;
}

inline void Splay(node* x,node* tar=NULL)
{
    que[ed=1]=x;
    for(node* y=x;y!=rt;y=y->fa)que[++ed]=y->fa;
    for(int i=ed;i>=1;i--){node* y=que[i];pushdown(y);}
    while(x->fa!=tar)
    {
        node* y=x->fa,*z=y->fa;
        if(z!=tar)
        {
            if(which(x)^which(y))Rotate(x);
            else Rotate(y);
        }
        Rotate(x);
    }
    if(!tar)rt=x;
}

inline node* split(int l,int r)
{
    if(l&&r<=n)
    {
        node *t1=find(rt,l);
        node *t2=find(rt,r);
        Splay(t1);Splay(t2,rt);
        node *t3=t2->lc;
        t2->lc=NULL;
        t2->upt();
        t3->fa=NULL;
        return t3;
    }
    else if(!l)
    {
        node *t2=find(rt,r);
        Splay(t2);
        node *t3=t2->lc;
        t2->lc=NULL;
        t2->upt();
        t3->fa=NULL;
        return t3;
    }
    else
    {
        node *t1=find(rt,l);
        Splay(t1);
        node *t3=t1->rc;
        t3->fa=NULL;
        t1->rc=NULL;
        t1->upt();
        return t3;
    }
}

int buf[50];
inline void W(int x)
{
    if(!x){putchar('0');return;}
    if(x<0)putchar('-'),x=-x;
    while(x)buf[++buf[0]]=x%10,x/=10;
    while(buf[0])putchar('0'+buf[buf[0]--]);
    return;
}

int main()
{
    n=read();
    for(int i=1;i<=n;i++){a[i]=read();}
    build(rt,1,n);
    m=read();
    while(m--)
    {
        scanf("%s",ch+1);
        if(ch[1]=='A')
        {
            int l=read(),r=read(),v=read();
            if(l==1&&r==n)add(rt,v);
            else if(l==1)
            {
                node* t2=find(rt,r+1);
                Splay(t2);
                add(rt->lc,v);
                rt->upt();
            }
            else if(r==n)
            {
                node* t1=find(rt,l-1);
                Splay(t1);
                add(rt->rc,v);
                rt->upt();
            }
            else 
            {
                node* t1=find(rt,l-1);
                node* t2=find(rt,r+1);
                Splay(t1);
                Splay(t2,rt);
                add(t2->lc,v);
                t2->upt();t1->upt();
            }
        }
        else if(ch[1]=='I')
        {
            int x=read(),y=read();
            if(x!=0&&x!=n)
            {
                node* t1=find(rt,x);
                node* t2=find(rt,x+1);
                Splay(t1);
                Splay(t2,rt);
                t2->lc=newnode(y);
                t2->lc->fa=t2;
                t2->upt();t1->upt();
                n++;
            }
            else if(x!=0)
            {
                node* t1=find(rt,x);
                Splay(t1);
                t1->rc=newnode(y);
                t1->rc->fa=t1;
                t1->upt();
                n++;
            }
            else
            {
                node* t2=find(rt,x+1);
                t2->lc=newnode(y);
                t2->lc->fa=t2;
                t2->upt();
                n++;
            }       
        }
        else if(ch[1]=='D')
        {
            int pos=read();
            if(pos!=1&&pos!=n)
            {
                node* t1=find(rt,pos-1);
                node* t2=find(rt,pos+1);
                Splay(t1);
                Splay(t2,rt);
                t2->lc->fa=NULL;
                t2->lc=NULL;
                t2->upt();
                rt->upt();
                n--;
            }
            else if(pos!=1)
            {
                node* t1=find(rt,pos-1);
                Splay(t1);
                t1->rc->fa=NULL;
                t1->rc=NULL;
                t1->upt();
                n--;
            }
            else
            {
                node* t2=find(rt,pos+1);
                Splay(t2);
                t2->lc->fa=NULL;
                t2->lc=NULL;
                t2->upt();
                n--;
            }
        }
        else if(ch[1]=='M')
        {
            int l=read(),r=read();
            if(l==1&&r==n)W(rt->mn),putchar('\n');
            else if(l==1)
            {
                node* t2=find(rt,r+1);
                Splay(t2);
                W(rt->lc->mn),putchar('\n');
            }
            else if(r==n)
            {
                node* t1=find(rt,l-1);
                Splay(t1);
                W(rt->rc->mn),putchar('\n');
            }
            else 
            {
                node* t1=find(rt,l-1);
                node* t2=find(rt,r+1);
                Splay(t1);
                Splay(t2,rt);
                W(t2->lc->mn),putchar('\n');
            }
        }
        else if(ch[4]=='E')
        {
            int l=read(),r=read();
            if(l==1&&r==n)addr(rt);
            else if(l==1)
            {
                node* t2=find(rt,r+1);
                Splay(t2);
                addr(rt->lc);
            }
            else if(r==n)
            {
                node* t1=find(rt,l-1);
                Splay(t1);
                addr(rt->rc);
            }
            else 
            {
                node* t1=find(rt,l-1);
                node* t2=find(rt,r+1);
                Splay(t1);
                Splay(t2,rt);
                addr(t2->lc);
            }
        }
        else
        {
            int x=read(),y=read(),c=read();
            int l=(y-x+1);
            c%=l;
            if(c==0)continue;
            node* t1=split(y-c,y+1);
            if(x!=1)
            {
                node* t2=find(rt,x-1);
                node* t3=find(rt,x);
                Splay(t2);
                Splay(t3,rt);
                t3->lc=t1;
                t1->fa=t3;
                t3->upt();
                t2->upt();
            }
            else
            {
                node* t3=find(rt,x);
                Splay(t3);
                t3->lc=t1;
                t1->fa=t3;
                t3->upt();
            }
        }
    }
}
DZYO
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【POJ 3580】 SuperMemo
even_bao的博客
03-04 404
【题目链接】           点击打开链接【算法】          本题也是Splay区间操作的模板题，不过要比BZOJ 3223要稍微复杂一些，做完此题后，我终于对Splay有了更深入的理解，有“拨开云雾见青天”的感觉            本题还是有许多细节的，笔者花了5h才通过了此题【代码】          #include &lt;algorithm&gt; #include &l...
POJ 3580 SuperMemo（区间树）
Quack
11-22 557
唯一一个要说的就是REVOLVE操作。别的在笔记上有。 可以发现REVOLVE就是把一段区间砍下来然后接在一个点后面。 那么先把这个区间砍下来（rotateto（l-1,0）rotateto（r+1,root）），然后pushup，然后找到那个点（rotateto（x,0）rotateto（x+1,root）），然后插入回去。最后pushup。#include<iostream> #includ
poj 3580
Dash
04-17 667
平衡树裸题，这是新的平衡树模板。 平衡树，区间加值，区间翻转，区间查询最小值。 我还是太年轻了。。。too young too simple。。。
(POJ) 3580 SuperMemo
一只不争气的蒸汽机的博客
05-06 302
传送门 一道很全的splay模板题，自己搞了半天都不对，只能考别人的代码感受一下AC的味道，真香。 #include<cstdio> #include<iostream> #include<algorithm> #include<string> #include<cstring> #include<queue> #inc...
poj3580 SuperMemo splay --- 从入门到入土
forOnward的博客
11-17 319
(太可怕了，我只是一个刚学懂splay的蒟蒻） poj地址：http://poj.org/problem?id=3580 AcWing地址：https://www.acwing.com/problem/content/268/ 题意： 给你一个数列 A1~An 有几个操作： 输入格式 第一行包含一个整数 n。 接下来 n 行给出了序列中的数。 接下来一行包含一个整数 ...
POJ2092:计数排序,求第K大的元素
04-15
【标题】"POJ2092:计数排序,求第K大的元素"是一个编程题目，主要涉及计数排序算法以及如何在数组中找出第K大的元素。计数排序是一种非基于比较的排序算法，它适用于整数排序，尤其在数据范围不大的情况下效率极高。...
Super-Memo-poj3580.zip_memo
最新发布
09-24
标题中的"Super-Memo-poj3580.zip_memo"暗示了这是一个关于Super-Memo算法的编程解决方案，可能是为了解决某个特定问题，比如在POJ（Programming Online Judge）平台上提交的第3580题。Splay Trees是数据结构领域中...
poj题目分类，关于acm/icpc
02-18
在ACM/ICPC（国际大学生程序设计竞赛）中，训练和准备是非常关键的，而“poj”（编程在线判题系统）是许多参赛者常用的一个平台进行实战练习。这个压缩包文件提供了针对该平台的题目分类，分为初级、中级和高级三个...
poj：我在poj上的解题报告
02-12
1. **数据结构**：在poj的题目中，常见的数据结构包括数组、链表、栈、队列、哈希表、树（二叉树、平衡树如AVL和红黑树等）、图等。Java的内置集合框架提供了丰富的数据结构类，如ArrayList、LinkedList、Stack、...
poj-5346-.rar_5346_poj 5346_site:www.pudn.com
09-19
《POJ 5346：四则运算表达式求值——栈与队列的应用》 在编程竞赛中，POJ 5346是一道经典的算法题目，它要求我们设计一个程序，能够处理四则运算表达式并计算其值。这个任务涉及到计算机科学中的数据结构——栈和...
SuperMemo POJ3580 TREAP
迷途的羔羊正在向前行进
08-09 288
SuperMemo Treap POJ3580-SuperMemo 典型的区间操作水题, 我们要注意的点是REVOLVE操作中的T可能是负数. 我因为modify函数写错了, WA了好几次, 要细心. #include &lt;iostream&gt; #include &lt;algorithm&gt; #include &lt;vector&gt; #include &lt;que...
BZOJ 1895 & POJ 3580 supermemo （splay）
K键盘里的青春K
09-08 1475
SuperMemo Time Limit: 5000MS   Memory Limit: 65536K Total Submissions: 16524   Accepted: 5214 Case Time Limit: 2000MS Description Your friend, Jackson is invited t
POJ3580 SuperMemo
Monster__Yi的博客
05-06 976
splay模板
[poj3580]SuperMemo（splay终结题）
私は Mocha!!
09-23 486
传送门 题意： 你需要维护一组数字，包括这样的几个操作： 给出一个数字序列，有6种操作： 1、 ADD l r d：区间[l,r]的数都加上d。 2、 REVERSE l r ： 将区间[l,r]中的数翻转 。 3、 REVOLVE l r t ：将区间[l,r]旋转t次，如1 2 3 4 5 旋转2次后就变成4 5 1 2 3 。 4、 INSERT p x ：在第p个数后面插入x 。 5、D...
splay__poj3580
zz_ylolita
04-04 765
这真是很让人难过的一道题。。。。。但是我要硬着头皮写完splay TwT题目要求实现一种数据结构，支持6种操作： add x,y D：第x个数到第y个数之间的数每个加D； reverse x y：第x个数到第y个数之间全部数翻转； revolve x y T：第x个数到第y个数之间的数，向后循环流动T次，即后面T个数变成这段子序列的最前面T个，前面的被挤到后面。 Insert x P：在第x
poj 3580 分类： poj templa...
aa288288的博客
04-17 115
平衡树裸题，这是新的平衡树模板。 平衡树，区间加值，区间翻转，区间查询最小值。 要时刻记住维护标记哦~ WA了好几次，对拍了一百多组数据，发现有两个操作没有更新信息。 我还是太年轻了。。。too young too simple。。。 #include<map> #include<queue> #include<...
蓝书（算法竞赛进阶指南）刷题记录——POJ3580 SuperMemo （Splay）
hzk_cpp的博客
05-16 200
题目：POJ3580. 题目大意：给定一个长度为nnn的序列，现在有mmm次操作支持： 1.格式ADD&ThinSpace;x&ThinSpace;y&ThinSpace;vADD\,x\,y\, vADDxyv，表示给区间[x,y][x,y][x,y]加上vvv. 2.格式REVERSE&ThinSpace;x&ThinSpace;yREVERSE\,x\...
POJ 3580 SPLAY树
weixin_30675247的博客
08-22 98
最近补基础数据结构的最后一题，说实话，这题比上一题简单多了。这里面有一个右移T次的操作，其实就是把数列分成[l,r-T],[r-T+1,r]然后把前一段插到后一段后面。这题我写傻逼了，wa了5发，发现我把右移写成了左移。。。 明天回家了，待会买点东西，回来写个Splay树小结！！！ 下面附上这道题的AC代码： #include <iostream> #include &l...
poj 3580 伸展树重口味题
努力奋斗才能梦想成真
09-30 1721
http://poj.org/problem?id=3580 注意，inf设的不要太小，还有对于题目输入数据的各种处理（可能有非法数据），要注意判断，具体见代码 #include #include #include using namespace std; const int inf = ~0u>>2; #define L ch[x][0] #define R ch[x][1] #d
poj解题笔记1
08-08
"这篇解题笔记主要介绍了如何解决POJ3278问题，即‘赶上那头牛’。农夫约翰需要通过两种移动方式在数线上追赶逃犯的牛，采用广度优先搜索（BFS）算法进行求解。" 在《poj解题笔记1》中，讨论的是一个基于数线上的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值