zoj 3765 块状链表 OR splay

各种操作o(╯□╰)o...不过都挺简单，不需要lazy标记。

方法1：块状链表

块状链表太强大了，区间操作实现起来简单暴力，效率比splay稍微慢一点，内存开销小很多。

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 900;
const int LOW = 260;
const int UP = 320;
int sz[N];
int next[N];
int g[N][2];
int n, m, ps, bl;

struct B
{
    int v, s;
} b[N][N];

int gcd( int x, int y )
{
    if ( y ) return gcd( y, x % y );
    return x;
}

void update( int cur, int stu )
{
    g[cur][stu] = 0;
    for ( int i = 0; i < sz[cur]; i++ )
    {
        if ( b[cur][i].s == stu )
        {
            g[cur][stu] = gcd( g[cur][stu], b[cur][i].v );
        }
    }
}

void spilt( int cur )
{
    int tmp = next[cur];
    int ncur = bl++;
    next[cur] = ncur;
    next[ncur] = tmp;
    for ( int i = sz[cur] / 2; i < sz[cur]; i++ )
    {
        b[ncur][sz[ncur]++] = b[cur][i];
    }
    sz[cur] = sz[cur] / 2;
    update( cur, 0 );
    update( cur, 1 );
    update( ncur, 0 );
    update( ncur, 1 );
}

void insert( int pos, int val, int stu )
{
    int cur = 0, p = sz[cur];
    while ( p < pos + 1 && next[cur] != -1 )
    {
        cur = next[cur];
        p += sz[cur];
    }
    if ( p < pos + 1 )
    {
        pos = p;
    }
    p -= sz[cur];
    pos -= p;
    for ( int j = sz[cur] - 1; j >= pos; j-- )
    {
        b[cur][j + 1] = b[cur][j];
    }
    b[cur][pos].v = val;
    b[cur][pos].s = stu;
    sz[cur]++;
    if ( sz[cur] > UP )
    {
        spilt(cur);
    }
    else
    {
        g[cur][stu] = gcd( g[cur][stu], val );
    }
}

void remove( int pos )
{
    int cur = 0, p = sz[cur];
    while ( p < pos + 1 && next[cur] != -1 )
    {
        cur = next[cur];
        p += sz[cur];
    }   
    if ( p < pos + 1 )
    {
        return ;
    }
    else
    {
        p -= sz[cur];
        pos -= p;
        int tt = b[cur][pos].s;
        for ( int j = pos; j < sz[cur] - 1; j++ )
        {
            b[cur][j] = b[cur][j + 1];
        }
        sz[cur]--;
        update( cur, tt );
    }
}

void reverse( int pos )
{
    int cur = 0, p = sz[cur];
    while ( p < pos + 1 && next[cur] != -1 )
    {
        cur = next[cur];
        p += sz[cur];
    }   
    if ( p < pos + 1 )
    {
        return ;
    }
    else
    {
        p -= sz[cur];
        pos -= p;
        int tt = b[cur][pos].s;
        b[cur][pos].s ^= 1;
        update( cur, tt );
        g[cur][tt ^ 1] = gcd( g[cur][tt ^ 1], b[cur][pos].v );
    }
}

void modify( int pos, int val )
{
    int cur = 0, p = sz[cur];
    while ( p < pos + 1 && next[cur] != -1 )
    {
        cur = next[cur];
        p += sz[cur];
    }   
    if ( p < pos + 1 )
    {
        return ;
    }
    else
    {
        p -= sz[cur];
        pos -= p;
        b[cur][pos].v = val;
        update( cur, b[cur][pos].s );
    }
}

int query( int l, int r, int stu )
{
    int cur = 0, p = sz[cur];
    while ( p < l + 1 && next[cur] != -1 )
    {
        cur = next[cur];
        p += sz[cur];
    }        
    p -= sz[cur];
    l -= p;  
    int ncur = 0, q = sz[ncur];
    while ( q < r + 1 && next[ncur] != -1 )
    {
        ncur = next[ncur];
        q += sz[ncur];
    }        
    q -= sz[ncur];
    r -= q;  
    int ans = 0;
    if ( cur != ncur )
    {
        for ( int i = next[cur]; i != ncur; i = next[i] )
        {
            if ( g[i][stu] == 0 ) continue;
            ans = gcd( ans, g[i][stu] );
        }
        for ( int j = l; j < sz[cur]; j++ )
        {
            if ( b[cur][j].s == stu )
            {
                ans = gcd( ans, b[cur][j].v ); 
            }
        }
        for ( int j = 0; j <= r; j++ )
        {
            if ( b[ncur][j].s == stu )
            {
                ans = gcd( ans, b[ncur][j].v );
            }
        }
    }
    else
    {
        for ( int j = l; j <= r; j++ )
        {
            if ( b[cur][j].s == stu )
            {
                ans = gcd( ans, b[cur][j].v );
            }
        }
    }
    if ( ans == 0 ) ans = -1;
    return ans;
}

int main ()
{
    while ( scanf("%d%d", &n, &m) != EOF )
    {
        ps = LOW;
        memset( sz, 0, sizeof(sz) );
        memset( next, -1, sizeof(next) );
        memset( g, 0, sizeof(g) );
        for ( int i = 0; i < n; i++ )
        {
            int la = i / ps, lb = i % ps;
            scanf("%d%d", &b[la][lb].v, &b[la][lb].s);
        }
        int k = 0;
        while ( ( k + 1 ) * ps < n ) k++;
        for ( int i = 0; i < k; i++ )
        {
            sz[i] = ps;
            next[i] = i + 1;
        }
        sz[k] = n - k * ps;
        for ( int i = 0; i <= k; i++ )
        {
            g[i][0] = g[i][1] = 0;
            for ( int j = 0; j < sz[i]; j++ )
            {
                int ss = b[i][j].s;
                g[i][ss] = gcd( g[i][ss], b[i][j].v );
            }
        }
        bl = k + 1;
        char op[2];
        int num1, num2, num3;
        while ( m-- )
        {
            scanf("%s", op);
            if ( op[0] == 'Q' )
            {
                scanf("%d%d%d", &num1, &num2, &num3);
                num1--;
                num2--;
                printf("%d\n", query( num1, num2, num3 ));
            }
            else if ( op[0] == 'I' )
            {
                scanf("%d%d%d", &num1, &num2, &num3);
                insert( num1, num2, num3 );
            }
            else if ( op[0] == 'D' )
            {
                scanf("%d", &num1);
                num1--;
                remove(num1);
            }
            else if ( op[0] == 'R' )
            {
                scanf("%d", &num1);
                num1--;
                reverse(num1);      
            }
            else if ( op[0] == 'M' )
            {
                scanf("%d%d", &num1, &num2);
                num1--;
                modify( num1, num2 );
            }
        }
    }
    return 0;
}

方法2：splay

写起来也不算特别长。

#include <iostream>
#include <cstring>
#include <cstdio>
using namespace std;

const int N = 200002;
int v[N];
int s[N];
int n, m;

int gcd( int x, int y )
{
    if ( y ) return gcd( y, x % y );
    return x;
}

struct Node 
{
    Node * ch[2];
    int g[2];
    int val;
    int stu;
    int rank;
    int sz;

    int cmp( int x ) const 
    {
        if ( x == rank ) return -1;
        return x < rank ? 0 : 1;
    }

    void maintain()
    {
        sz = rank = 1;
        g[0] = g[1] = 0;
        g[stu] = val;
        if ( ch[0] != NULL )
        {
            sz += ch[0]->sz;
            rank += ch[0]->sz;
            if ( ch[0]->g[0] ) g[0] = gcd( g[0], ch[0]->g[0] );
            if ( ch[0]->g[1] ) g[1] = gcd( g[1], ch[0]->g[1] );
        }
        if ( ch[1] != NULL )
        {
            sz += ch[1]->sz;
            if ( ch[1]->g[0] ) g[0] = gcd( g[0], ch[1]->g[0] );
            if ( ch[1]->g[1] ) g[1] = gcd( g[1], ch[1]->g[1] );
        }
    }
} * root;

void rotate( Node * & o, int d )
{
    Node * k = o->ch[d ^ 1];
    o->ch[d ^ 1] = k->ch[d];
    k->ch[d] = o;
    o->maintain();
    k->maintain();
    o = k;
}

void splay( Node * & o, int k )
{
    int d = o->cmp(k);
    if ( d != -1 )
    {
        if ( d == 1 ) k -= o->rank;
        Node * p = o->ch[d];
        int d2 = p->cmp(k);
        if ( d2 != -1 )
        {
            int k2 = ( d2 == 0 ? k : k - p->rank );    
            splay( p->ch[d2], k2 );
            if ( d == d2 )
            {
                rotate( o, d ^ 1 );
            }
            else
            {
                rotate( o->ch[d], d );
            }
        }
        rotate( o, d ^ 1 );
    }
}

Node * build( int l, int r )
{
    if ( l > r ) return NULL;
    Node * o = new Node();
    int mid = ( l + r ) >> 1;
    o->sz = r - l + 1;
    o->val = v[mid];
    o->stu = s[mid];
    o->rank = mid - l + 1;
    o->g[0] = o->g[1] = 0;
    o->g[o->stu] = o->val;
    o->ch[0] = build( l, mid - 1 );
    o->ch[1] = build( mid + 1, r );
    o->maintain();
    return o;
}

int query( int l, int r, int stu )
{
    splay( root, l );
    splay( root->ch[1], r - l + 2 );
    return root->ch[1]->ch[0]->g[stu];
}

void insert( int k, int vv, int ss )
{
    splay( root, k );
    splay( root->ch[1], 1 );
    Node * & o = root->ch[1]->ch[0];
    o = new Node();
    o->sz = o->rank = 1;
    o->g[0] = o->g[1] = 0;
    o->val = vv;
    o->stu = ss;
    o->g[ss] = vv;
    root->ch[1]->maintain();
    root->maintain();
}

void remove( int k )
{
    splay( root, k );
    splay( root->ch[1], 2 );
    root->ch[1]->ch[0] = NULL;
    root->ch[1]->maintain();
    root->maintain();
}

void reverse( int k )
{
    splay( root, k );
    root->stu ^= 1;
    root->maintain();
}

void modify( int k, int vv )
{
    splay( root, k );
    root->val = vv;
    root->maintain();
}

int main ()
{
    while ( scanf("%d%d", &n, &m) != EOF )
    {
        for ( int i = 1; i <= n; i++ )
        {
            scanf("%d%d", v + i, s + i);
        }
        root = build( 0, n + 1 );
        char cmd[11];
        int a, b, c;
        while ( m-- )
        {
            scanf("%s", cmd);
            if ( cmd[0] == 'Q' )
            {
                scanf("%d%d%d", &a, &b, &c);
                int tmp = query( a, b, c );
                if ( !tmp ) tmp = -1;
                printf("%d\n", tmp);
            }
            else if ( cmd[0] == 'I' )
            {
                scanf("%d%d%d", &a, &b, &c);
                a++;
                insert( a, b, c );
            }
            else if ( cmd[0] == 'D' )
            {
                scanf("%d", &a);
                remove(a);
            }
            else if ( cmd[0] == 'R' )
            {
                scanf("%d", &a);
                a++;
                reverse(a);
            }
            else if ( cmd[0] == 'M' )
            {
                scanf("%d%d", &a, &b);
                a++;
                modify( a, b );
            }
        }
    }
    return 0;
}