bzoj 1171 并查集优化顺序枚举 | 线段树套单调队列

详见vfleaking在discuss里的题解.

收获: 当我们要顺序枚举一个序列,并且跳过某些元素,那么我们可以用并查集将要跳过的元素合并到一起,这样当一长串元素需要跳过时,可以O(1)跳过.

暴力:

 /**************************************************************
     Problem: 1171
     User: idy002
     Language: C++
     Result: Accepted
     Time:1908 ms
     Memory:6732 kb
 ****************************************************************/

 #include <cstdio>
 #include <cstring>
 #define min(a,b) ((a)<(b)?(a):(b))
 #define max(a,b) ((a)>(b)?(a):(b))
 #define oo 0x3f3f3f3f
 #define N 250010

 int n, L;
 int x[N], y[N], d[N];
 int dp[N], fa[N], qu[N], bg, ed;

 int find( int i ) {
     return i==fa[i] ? i : fa[i]=find(fa[i]);
 }
 int main() {
     scanf( "%d%d", &n, &L );
     d[] = ;
     x[] = ;
     y[] = ;
     for( int i=; i<=n; i++ )
         scanf( "%d%d%d", x+i, y+i, d+i );
     for( int i=; i<=n; i++ )
         fa[i] = i;
     memset( dp, 0x3f, sizeof(dp) );

     dp[] = ;
     qu[bg=ed=] = ;
     while( bg<=ed ) {
         int i=qu[bg++];
         for( int j=find(i)+; j<=n && d[j]-d[i]<=L; j=find(j)+ ) {
             if( dp[j]!=oo ) continue;
             int xx = max( x[i], x[j] );
             int yy = min( y[i], y[j] );
             if( xx<=yy ) {
                 dp[j] = dp[i]+;
                 qu[++ed] = j;
                 if( dp[j-]!=oo ) fa[j-]=j;
                 if( dp[j+]!=oo ) fa[j]=j+;
             }
         }
     }
     for( int i=; i<=n; i++ )
         printf( "%d\n", dp[i]==oo ? - : dp[i] );
 }

线段树套单调队列:

 #include <cstdio>
 #include <list>
 #include <algorithm>
 #define N 250010
 #define oo 0x3f3f3f3f
 using namespace std;

 struct Pair {
     int d, v;
     Pair( int d, int v ):d(d),v(v){}
 };
 struct Queue {
     list<Pair> q;
     void push( const Pair &p ) {
         while( !q.empty() && q.back().v >= p.v ) q.pop_back();
         q.push_back( p );
     }
     int pop( int d ) {
         while( !q.empty() && q.front().d<d ) q.pop_front();
         return q.empty() ? oo : q.front().v;
     }
 };
 struct Node {
     Queue qa, qb;
     int lf, rg;
     Node *ls, *rs;
     void modify( int L, int R, const Pair &p ) {
         qb.push(p);
         if( L<=lf && rg<=R ) {
             qa.push(p);
             return;
         }
         int mid=(lf+rg)>>;
         if( L<=mid ) ls->modify(L,R,p);
         if( R>mid ) rs->modify(L,R,p);
     }
     int query( int L, int R, int d ) {
         if( L<=lf && rg<=R ) return qb.pop(d);
         int rt = qa.pop(d);
         int mid=(lf+rg)>>;
         if( L<=mid ) {
             int t = ls->query(L,R,d);
             rt = min( rt, t );
         }
         if( R>mid ) {
             int t = rs->query(L,R,d);
             rt = min( rt, t );
         }
         return rt;
     }
 }pool[N**], *tail=pool, *root;

 int n, L;
 int x[N], y[N], d[N];
 int disc[N*], dtot;

 Node *build( int lf, int rg ) {
     Node *nd = ++tail;
     nd->lf=lf, nd->rg=rg;
     if( lf==rg ) {
         return nd;
     } else {
         int mid=(lf+rg)>>;
         nd->ls = build( lf, mid );
         nd->rs = build( mid+, rg );
         return nd;
     }
 }
 int main() {
     scanf( "%d%d", &n, &L );
     x[] = ;
     y[] = ;
     disc[++dtot] = x[];
     disc[++dtot] = y[];
     d[] = ;
     for( int i=; i<=n; i++ ) {
         scanf( "%d%d%d", x+i, y+i, d+i );
         disc[++dtot] = x[i];
         disc[++dtot] = y[i];
     }
     sort( disc+, disc++dtot );
     dtot = unique( disc+, disc++dtot ) - disc - ;
     for( int i=; i<=n; i++ ) {
         x[i] = lower_bound( disc+, disc++dtot, x[i] ) - disc;
         y[i] = lower_bound( disc+, disc++dtot, y[i] ) - disc;
     }
     root = build( , dtot );
     root->modify( x[], y[], Pair(,) );
     for( int i=; i<=n; i++ ) {
         int ans = root->query( x[i], y[i], d[i]-L );
         if( ans==oo ) {
             printf( "-1\n" );
         } else {
             ans++;
             printf( "%d\n", ans );
             root->modify( x[i], y[i], Pair(d[i],ans) );
         }
     }
 }