C++博客-Darren-随笔分类-数据结构

HDU 1255

Darren — Thu, 06 Aug 2009 01:59:00 GMT

#include < iostream >
#include < algorithm >

using namespace std;

#define N 2110

struct Tree {
     double length, len;
     int     cnt;
    Tree() { length = 0 ; cnt = 0 ; }
     void init() { length = 0 ; cnt = 0 ; len = 0 ; }
} tb[ 10100 ];

double x1[N], y1[N], x2[N], y2[N], xx[N], idx[N];
int pos, n;

struct Line {
     double y, x1, x2;
     bool type;
} line[N];

bool operator < ( Line const & a, Line const & b ) {
     return a.y < b.y; }

inline int bsearch( double value ) {
     int low = 1 , high = pos + 1 ;
     while ( low <= high ) {
         int mid = (low + high) >> 1 ;
         if ( idx[mid] > value ) high = mid - 1 ;
         else if ( idx[mid] < value ) low = mid + 1 ;
         else return mid; }
}

inline void update( int rt, int l, int r ) {
     if ( tb[rt].cnt ) tb[rt].length = idx[r] - idx[l];
     else if ( l + 1 == r ) tb[rt].length = 0 ;
     else tb[rt].length = tb[rt << 1 ].length + tb[(rt << 1 ) + 1 ].length;
}

inline void update2( int rt, int l, int r ) {
     if ( tb[rt].cnt > 1 ) tb[rt].len = idx[r] - idx[l];
     else if ( tb[rt].cnt == 1 ) tb[rt].len = tb[rt << 1 ].length + tb[(rt << 1 ) + 1 ].length;
     else tb[rt].len = tb[rt << 1 ].len + tb[(rt << 1 ) + 1 ].len; }

void deal( int rt, int l, int r, int a, int b, int t ) {
     if ( a <= l && b >= r ) {
        tb[rt].cnt += t; update( rt, l, r ); update2( rt, l, r );   return ; }

     int mid = (l + r) >> 1 ;
     if ( a < mid ) deal( rt << 1 , l, mid, a, b, t);
     if ( b > mid ) deal( (rt << 1 ) + 1 , mid, r, a, b, t );

    update( rt, l, r ); update2( rt, l, r );
}

int main() {
     int test = 1 ;
    scanf( " %d " , & test );
     while ( test -- ) {
        scanf( " %d " , & n);
         for ( int i = 0 ; i <= 10000 ; ++ i ) tb[i].init();
         for ( int i = 0 ; i < n; ++ i ) {
            scanf( " %lf%lf%lf%lf " , x1 + i, y1 + i, x2 + i, y2 + i );
            line[ 2 * i].y = y1[i];   line[ 2 * i].x1 = x1[i];
            line[ 2 * i].x2 = x2[i];  line[ 2 * i].type = 0 ;

            xx[ 2 * i] = x1[i]; xx[ 2 * i + 1 ] = x2[i];
            line[ 2 * i + 1 ].y = y2[i];  line[ 2 * i + 1 ].x1 = x1[i];
            line[ 2 * i + 1 ].x2 = x2[i]; line[ 2 * i + 1 ].type = 1 ;
        }
        sort( xx, xx + 2 * n );    sort( line, line + 2 * n );
        pos = 1 ; idx[ 1 ] = xx[ 0 ];
         for ( int i = 1 ; i < 2 * n; ++ i )
         if ( xx[i] != xx[i - 1 ] ) idx[ ++ pos] = xx[i];

         double ans = 0 ;
         for ( int i = 0 ; i < 2 * n - 1 ; ++ i ) {
             int u = bsearch( line[i].x1 ), v = bsearch( line[i].x2 );
             if ( line[i].type == 0 ) deal( 1 , 1 , pos, u, v, 1 );
             else deal( 1 , 1 , pos, u, v, - 1 );

            ans += tb[ 1 ].len * ( line[i + 1 ].y - line[i].y );
        }
        printf( " %.2lf\n " , ans );
    }

     return 0 ;
}

Darren 2009-08-06 09:59 发表评论

PKU　　1151

Darren — Wed, 05 Aug 2009 16:49:00 GMT

摘要: #include < iostream > #include < algorithm > using namespace std; ... 阅读全文

Darren 2009-08-06 00:49 发表评论

ZJU 3228 Searching the String ( AC 自动机 )

Darren — Sun, 02 Aug 2009 14:05:00 GMT

摘要: #include < iostream > #include < queue > using namespace std; #define N 100010 ... 阅读全文

Darren 2009-08-02 22:05 发表评论

Pku 1986 Distance Queries

Darren — Mon, 20 Jul 2009 02:56:00 GMT

#include < iostream >
#include < vector >

using namespace std;

#define N 40010
typedef pair < int , int > PAIR;

int m, n;
vector < PAIR > query[N], map[N];

int uset[N] = { 0 }, acs[N], flag[N] = { 0 }, dis[N] = { 0 }, ans[N], visite[N] = { 0 };

int find( int x ){
     while ( x != uset[x] ) x = uset[x];
     return x; }

void join( int x, int y ){  uset[ find(x) ] = uset[ find(y) ]; }

void dfs( int u, int d ){
    uset[u] = u; acs[u] = u; dis[u] = d; visite[u] = 1 ;
     for ( size_t i = 0 ; i < map[u].size(); ++ i ){
         int v = map[u][i].first, w = map[u][i].second;
         if ( ! visite[v] ){
            dfs( v, d + w );
            join( u, v ); acs[ find(u) ] = u;  }
    }

    flag[u] = 1 ;
     for ( size_t i = 0 ; i < query[u].size(); ++ i ){
         int v = query[u][i].first, w = query[u][i].second;

         if ( flag[v] ) ans[w] = dis[u] + dis[v] - 2 * dis[ acs[ find(v) ] ];
    }
}

int main(){
     int u, v, d;
     char s[ 10 ];

    scanf( " %d%d " , & n, & m);
     while ( m -- ){
        scanf( " %d%d%d%s " , & u, & v, & d,s );
        map[u].push_back( PAIR(v,d) );
        map[v].push_back( PAIR(u,d) );
    }

    scanf( " %d " , & m );
     for ( int i = 1 ; i <= m; ++ i ){
        scanf( " %d%d " , & u, & v );
        query[u].push_back( PAIR(v,i) );
        query[v].push_back( PAIR(u,i) );
    }
    memset( flag, 0 , sizeof (flag) );
    memset( visite, 0 , sizeof (visite) );

    dfs( 1 , 0 );
     for ( int i = 1 ; i <= m; ++ i ) printf( " %d\n " , ans[i] );

     return 0 ;
}

Darren 2009-07-20 10:56 发表评论

Pku 3277 City Horizon

Darren — Wed, 15 Jul 2009 04:39:00 GMT

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

using namespace std;

#define N 40001
#define max(a,b) ( (a)>(b)?(a):(b) )

int n,d[N << 1 ], idx[N << 1 ], pos, f[N << 1 ];

struct Node{
     int x, y, ht;
    Node( int a = 0 , int b = 0 , int c = 0 ):x(a), y(b), ht(c) {}
};

bool operator < ( Node const & a, Node const & b ){
     return a.ht < b.ht; }
Node xyh[N];

int bsearch( int v ){
     int left = 0 , right = n * 2 ;
     while ( left + 1 < right ){
         int m = (left + right) >> 1 ;
         if ( d[m] > v ) right = m;
         else if ( d[m] < v ) left = m;
         else return idx[m];
    }
     return idx[left]; }

int tb[N * 8 ] = { 0 };

void insert( int l, int r, int a, int b, int rt, int h ){
     if ( l == a && r == b ){
        tb[rt] = max( tb[rt], h ); return ; }
     if ( tb[rt] != 0 ){
        tb[rt << 1 ] = tb[rt];
        tb[(rt << 1 ) + 1 ] = tb[rt];
        tb[rt] = 0 ; }
     int m = (l + r) >> 1 ;
     if ( b <= m ) insert( l, m, a, b, rt << 1 , h );
     else if ( a >= m ) insert( m, r, a, b, (rt << 1 ) + 1 , h );
     else {
        insert( l, m, a, m, rt << 1 , h );
        insert( m, r, m, b, (rt << 1 ) + 1 , h ); }
}

typedef __int64 INT;

INT ans;
void sum( int l, int r, int rt ){
     if ( tb[rt] > 0 ){
        ans = ans + (INT)( f[r] - f[l] ) * (INT)tb[rt];
         return ; }
     if ( r > l + 1 ){
         int m = (l + r) >> 1 ;
        sum( l, m, rt << 1 );
        sum( m, r, (rt << 1 ) + 1 );
    }
}

inline int read(){
     char ch;
     int d;
     while ( (ch = getchar()), ch < ' 0 ' || ch > ' 9 ' );
    d = ch - ' 0 ' ;
     while ( (ch = getchar()), ch >= ' 0 ' && ch <= ' 9 ' ) d = d * 10 + ch - ' 0 ' ;
     return d; }

int main(){
     int a, b, h;
    scanf( " %d " , & n);
     for ( int i = 0 ; i < n; ++ i ){
        a = read(), b = read(), h = read();
        xyh[i] = Node( a, b, h );
        d[i << 1 ] = a, d[(i << 1 ) + 1 ] = b; }
    sort( d, d + n * 2 );
    pos = 1 ; idx[ 0 ] = 1 ; f[ 1 ] = d[ 0 ];
     for ( int i = 1 ; i < n * 2 ; ++ i ){
         if ( d[i] != d[i - 1 ] ) idx[i] = ++ pos;
         else idx[i] = idx[i - 1 ];
        f[ idx[i] ] = d[i];
    }
    sort( xyh, xyh + n );
     for ( int i = 0 ; i < n; ++ i ){
        a = bsearch( xyh[i].x ), b = bsearch( xyh[i].y );
        insert( 1 , pos, a, b, 1 , xyh[i].ht );
    }
    ans = 0 ;
    sum( 1 , pos, 1 );
    printf( " %I64d\n " , ans );

     return 0 ;
}

Darren 2009-07-15 12:39 发表评论

Pku 2528 Mayor's posters

Darren — Tue, 14 Jul 2009 12:19:00 GMT

#include < iostream >
#include < algorithm >

using namespace std;

#define N 10010

struct Node{
     int x, y;
    Node( int a = 0 , int b = 0 ):x(a), y(b) {}
};

int   n, idx[N * 2 ], data[N * 2 ], pos;
Node d[N];

int bfind( int v ){
     int left = 0 , right = n * 2 ;
     while ( left + 1 < right ){
         int m = (left + right) >> 1 ;
         if ( data[m] < v ) left = m;
         else if ( data[m] > v ) right = m;
         else return idx[m];
    }
     return idx[left];
}

int tb[N * 8 ], flag[N];
void insert( int l, int r, int a, int b, int rt, int c ){
     if ( l == a && r == b ){
        tb[rt] = c; return ; }
     int m = (l + r) >> 1 ;
     if ( tb[rt] > 0 ){
        tb[rt << 1 ] = tb[rt], tb[(rt << 1 ) + 1 ] = tb[rt], tb[rt] = 0 ; }
     if ( b <= m ) insert( l, m, a, b, rt << 1 , c );
     else if ( a > m ) insert( m + 1 , r, a, b, (rt << 1 ) + 1 , c );
     else {
        insert( l, m, a, m, rt << 1 , c );
        insert( m + 1 , r, m + 1 , b, (rt << 1 ) + 1 , c ); }
}
void calc( int l, int r, int rt ){
     if ( tb[rt] > 0 ) { flag[ tb[rt] ] = 1 ; return ; }
     else {
         if ( l == r ) return ;
         int m = (l + r) >> 1 ;
        calc( l, m, rt << 1 );
        calc( m + 1 , r, (rt << 1 ) + 1 );
    }
}

int main(){
     int test;
    scanf( " %d " , & test);
     while ( test -- ){
        scanf( " %d " , & n );
         int u, v;
         for ( int i = 0 ; i < n; ++ i ){
            scanf( " %d%d " , & u, & v );
            d[i] = Node( u, v );
            data[i << 1 ] = u, data[(i << 1 ) + 1 ] = v;
        }
        sort( data, data + n * 2 );
        pos = 1 ; idx[ 0 ] = 1 ;
         for ( int i = 1 ; i < n * 2 ; ++ i )
         if ( data[i] != data[i - 1 ] ) idx[i] = ++ pos;
         else   idx[i] = pos;

        memset( tb, 0 , sizeof (tb) );
        memset( flag, 0 , sizeof (flag) );
         for ( int i = 0 ; i < n; ++ i ){
            u = bfind( d[i].x ), v = bfind( d[i].y );
            insert( 1 , pos, u, v, 1 , i + 1 );
        }
        calc( 1 , pos, 1 );
         int ans = 0 ;
         for ( int i = 1 ; i <= n; ++ i )
         if ( flag[i] ) ans ++ ;
        printf( " %d\n " , ans );
    }
     return 0 ;
}

Darren 2009-07-14 20:19 发表评论

Pku 2985 The k-th Largest Group

Darren — Tue, 14 Jul 2009 05:31:00 GMT

#include < iostream >

using namespace std;

int n, m;
#define N  200010
#define lowbit(x)  ( (x)&(-(x)) )

struct TArray{
     int cnt[N];
    TArray(){ init(); }
     void update( int p, int v ){
         for ( int x = p; x <= n; cnt[x] += v, x += lowbit(x) ); }
     int   sum( int p ){
         int x = p, s = 0 ;
         for ( ; x; s += cnt[x], x -= lowbit(x) );
         return s; }
     int   rank( int k ){
        k = sum(n) + 1 - k;
         int left = 1 , right = n;
         while ( left + 1 < right ){
             int m = (left + right) >> 1 ;
             int s = sum(m);
             if ( s >= k ) right = m;
             else         left = m;
        }
         if ( sum(left) >= k ) return left;
         return right;
    }
     void init(){   for ( int i = 0 ; i <= n; ++ i ) cnt[i] = 0 ; }
};

TArray tay;
struct U_find{
     int find[N], num[N];
    U_find(){ clear();}
     int parent( int t ){
         int u = t, v;    while ( u != find[u] ) u = find[u];
         while ( t != u ) { v = find[t]; find[t] = u; t = find[v]; }
         return u;  }
     bool is_friend( int u, int v ){ return parent(u) == parent(v); }
     void set_friend( int u, int v ){
         int a = parent(u), b = parent(v);
         if ( a == b ) return ;
         if ( num[a] > num[b] ) {
            find[b] = a;
            tay.update( num[b], - 1 );
            tay.update( num[a], - 1 );
            num[a] += num[b];
            tay.update( num[a], 1 );
        }
         else {
            find[a] = b;
            tay.update(  num[a], - 1 );
            tay.update(  num[b], - 1 );
            num[b] += num[a];
            tay.update( num[b], 1 );
        }
    }
     void clear(){ for ( int i = 0 ; i < N; ++ i ) find[i] = i, num[i] = 1 ; }
};

U_find uf;

int main(){
    scanf( " %d%d " , & n, & m );
    tay.update( 1 , n );

     while ( m -- ){
         int t, u, v, k;
        scanf( " %d " , & t );
         if ( t == 0 ){
            scanf( " %d%d " , & u, & v );
            uf.set_friend( u, v  );
        }
         else {
            scanf( " %d " , & k );
            printf( " %d\n " , tay.rank(k) );
        }
    }
     return 0 ;
}

Darren 2009-07-14 13:31 发表评论

Pku 2777 Count Color

Darren — Tue, 14 Jul 2009 02:50:00 GMT

#include < iostream >
#include < cstdio >
#include < cstdlib >
#include < cstring >

using namespace std;

int L, T, O;
int tb[ 300000 ] = { 0 };
void insert( int l, int r, int a, int b, int rt, int c ){
     if ( l == a && r == b ){
        tb[rt] = c; return ; }
     if ( tb[rt] > 0 ){
        tb[rt << 1 ] = tb[rt], tb[(rt << 1 ) + 1 ] = tb[rt]; tb[rt] = 0 ; }
     int m = (l + r) >> 1 ;
     if ( b <= m ) insert( l, m, a, b, rt << 1 , c );
     else if ( a > m ) insert( m + 1 , r, a, b, (rt << 1 ) + 1 , c );
     else {
        insert( l, m, a, m, rt << 1 , c );
        insert( m + 1 , r, m + 1 , b, (rt << 1 ) + 1 , c ); }
}
void query( int l, int r, int a, int b, int rt, int & ans ){
     if ( l == a && r == b && tb[rt] > 0 ){
        ans |= ( 1 << tb[rt]); return ;  }
     if ( tb[rt] > 0 ){
        tb[rt << 1 ] = tb[rt], tb[(rt << 1 ) + 1 ] = tb[rt]; }
     int m = (l + r) >> 1 ;
     if ( b <= m ) query( l, m, a, b, rt << 1 , ans );
     else if ( a > m ) query( m + 1 , r, a, b, (rt << 1 ) + 1 , ans );
     else {
        query( l, m, a, m, rt << 1 , ans );
        query( m + 1 , r, m + 1 , b, (rt << 1 ) + 1 , ans ); }
}
int getnum( int t ){
     int ans = 0 ;
     for ( int i = 1 ; i <= T; ++ i )
     if ( t & ( 1 << i ) ) ans ++ ;
     return ans;}

int main(){
    scanf( " %d%d%d " , & L, & T, & O );
    tb[ 1 ] = 1 ;
     char str[ 5 ];
     int a, b, c, d;
     while ( O -- ){
        scanf( " %s " , str );
         if ( str[ 0 ] == ' C ' ){
            scanf( " %d%d%d " , & a, & b, & c );
             if ( a > b ) { d = a; a = b; b = d; }
            insert( 1 , L, a, b, 1 , c );
        }
         else {
            scanf( " %d%d " , & a, & b ); c = 0 ;
             if ( a > b ) { d = a; a = b; b = d; }
            query( 1 , L, a, b, 1 , c );
            printf( " %d\n " , getnum(c) );
        }
    }
     return 0 ;
}

Darren 2009-07-14 10:50 发表评论

ZJU 2770 Burn the Linked Camp(差分约束系统)

Darren — Sat, 11 Jul 2009 07:32:00 GMT

#include < iostream >
#include < vector >

using namespace std;

struct Edge{
     int u, v, w;
    Edge( int a = 0 , int b = 0 , int c = 0 ):
        u(a), v(b), w(c) {}
};

int n, m;
int c[ 1010 ], sum[ 1010 ], dist[ 1010 ];
vector < Edge > ege;

bool bellman(){
    memset( dist, 0 , sizeof (dist) );
     int len = ege.size();
     for ( int i = 0 ; i < n; ++ i ){
         for ( int j = 0 ; j < len; ++ j )
         if ( dist[ ege[j].u ] + ege[j].w < dist[ ege[j].v ] )
        dist[ ege[j].v ] = dist[ ege[j].u ] + ege[j].w;
    }
     bool flag = false ;
     for ( int j = 0 ; j < len; ++ j )
     if ( dist[ ege[j].u ] + ege[j].w < dist[ ege[j].v ] )
     return false ;

     return true ;
}

int main(){
     while ( scanf( " %d%d " , & n, & m) != EOF ){
        memset( sum, 0 , sizeof (sum) );
         for ( int i = 1 ; i <= n; ++ i ){
             scanf( " %d " , c + i );
             sum[i] = sum[i - 1 ] + c[i];
             ege.push_back( Edge( i - 1 , i, c[i] ) );
             ege.push_back( Edge( i, i - 1 , 0 ) );
        }
         int u, v, w;
         while ( m -- ){
            scanf( " %d%d%d " , & u, & v, & w );
            u -- ;
            ege.push_back( Edge( v, u, - w ) );
            ege.push_back( Edge( u, v, sum[v] - sum[u] ) );
        }
         if ( ! bellman() ) puts( " Bad Estimations " );
         else              printf( " %d\n " ,dist[n] - dist[ 0 ] );

        ege.clear();
    }

     return 0 ;
}

Darren 2009-07-11 15:32 发表评论

Pku 2777 Count Color

Darren — Sun, 12 Oct 2008 04:45:00 GMT

#include < stdio.h >
#include < stdlib.h >
#include < algorithm >
#define single(x) ( ( (x)&( (x)-1 ) )== 0 )

struct   Node
{
     int left,right,colour;
    Node * lchild, * rchild;
} ;

Node * create( Node * t, int a, int b )
{
    t = new Node;

    t -> left = a; t -> right = b; t -> colour = 1 ;
    t -> lchild = NULL; t -> rchild = NULL;

     if ( a < b ) {
        t -> lchild = create( t -> lchild, a, (a + b) / 2 );
        t -> rchild = create( t -> rchild, (a + b) / 2 + 1 , b );
    }
     return t;
}

void insert( Node * root, int a, int b, int c )
{
     if ( root -> left == a && root -> right == b || root -> colour == c )
     {
        root -> colour = c;
         return ;
    }

     if ( single(root -> colour ) )
     {
        root -> lchild -> colour = root -> colour;
        root -> rchild -> colour = root -> colour;
    }

     int middle = (root -> left + root -> right) / 2 ;

     if ( b <= middle )      insert( root -> lchild, a, b, c );
     else if ( a > middle )  insert( root -> rchild, a, b, c );
     else {
        insert( root -> lchild, a, middle, c );
        insert( root -> rchild, middle + 1 , b, c );
    }

     if ( root -> lchild && root -> rchild )
    root -> colour = root -> lchild -> colour | root -> rchild -> colour;
}

void getcout( Node * root, int a, int b, int & cnt )
{
     if ( root -> left == a && root -> right == b || single(root -> colour ) )
     {
        cnt = cnt | root -> colour;
         return ;
    }

     int middle = (root -> left + root -> right) / 2 ;

     if ( b <= middle )       getcout( root -> lchild, a, b, cnt );
     else if ( a > middle )   getcout( root -> rchild, a, b, cnt );
     else {
        getcout( root -> lchild, a, middle,    cnt );
        getcout( root -> rchild, middle + 1 , b, cnt );
    }
}

int count( int i )
{
     int ans = 0 ;
     while ( i > 0 )
     {
         if ( i & 1 ) ans ++ ;
        i >>= 1 ;
    }
     return ans;
}

int main()
{
    Node * root;
     int l, t, o;

    scanf( " %d%d%d " , & l, & t, & o );
    root = create( root, 1 ,l );

     char str[ 5 ];
     for ( int i = 0 ; i < o; ++ i )
     {
        scanf( " %s " ,str);

         if ( str[ 0 ] == ' C ' )
         {
             int x, y, z;
            scanf( " %d%d%d " , & x, & y, & z);

             if ( x > y ) std::swap(x,y);
            insert( root, x, y, 1 << (z - 1 ) );
        }
         else if ( str[ 0 ] == ' P ' )
         {
             int x, y,cnt = 0 ;
            scanf( " %d%d " , & x, & y);
             if ( x > y ) std::swap(x,y);

            getcout( root, x, y, cnt );
            printf( " %d\n " , count(cnt) );
        }
    }

     return 0 ;
}

Darren 2008-10-12 12:45 发表评论

Zoj 1610 Count the Colors

Darren — Wed, 08 Oct 2008 06:29:00 GMT

#include < stdio.h >
#include < stdlib.h >
#include < string .h >

#define NOC -1
#define MUC -2
#define N   8001
#define M   10000

struct   Node
{
     int   leftvalue;
     int   rightvalue;
     int   colour;

    Node *   leftchild;
    Node *   rightchild;
} ;
int    colour[M];

Node * create( Node * r, int left, int right )
{
    Node * temp = new Node;

    temp -> leftvalue = left;
    temp -> rightvalue = right;
    temp -> colour = NOC;

    temp -> rightchild = NULL;
    temp -> leftchild = NULL;

     if ( right - left == 1 ) return temp;
     else {
        temp -> leftchild = create( temp -> leftchild, left, (left + right) / 2 );
        temp -> rightchild = create( temp -> rightchild, (left + right) / 2 , right );
    }

     return temp;
}

void insert( Node * tree, int left, int right, int c )
{
     int middle = ( tree -> leftvalue + tree -> rightvalue ) / 2 ;

     if ( right == tree -> rightvalue && left == tree -> leftvalue || tree -> colour == c)
     {
        tree -> colour =   c;
         return ;
    }

     if ( tree -> colour >= 0 )
     {
        tree -> leftchild -> colour = tree -> colour;
        tree -> rightchild -> colour = tree -> colour;
    }

    tree -> colour = MUC;
     if ( middle >= right )       insert( tree -> leftchild, left, right, c );
     else    if ( middle <= left )  insert( tree -> rightchild, left, right,c );
     else
     {
        insert( tree -> leftchild, left, middle, c );
        insert( tree -> rightchild, middle, right, c );
    }

}

void getcolour( Node * tree, int & col )
{
     if ( tree -> colour >= 0 && tree -> colour != col )
     {
        col = tree -> colour;
        colour[ tree -> colour ] ++ ;
    }
     else if ( tree -> colour == MUC )
     {
        getcolour( tree -> leftchild, col );
        getcolour( tree -> rightchild, col );
    }
     else col = tree -> colour;
}

int main()
{
    Node * root;
     int    n;

     while ( scanf( " %d " , & n) != EOF )
     {
        root = create( root, 0 , N );
         int   a, b, c;
         for ( int i = 0 ; i < n; ++ i )
         {
            scanf( " %d%d%d " , & a, & b, & c);
            insert( root, a, b, c );
        }

        memset( colour, 0 , sizeof (colour) );
         int col = - 1 ;
        getcolour( root, col );

         for ( int i = 0 ; i < M; ++ i )
           if ( colour[i] ) printf( " %d %d\n " , i, colour[i] );
        printf( " \n " );
    }

     return 0 ;
}

Darren 2008-10-08 14:29 发表评论

C++博客-Darren-随笔分类-数据结构

HDU 1255

PKU 1151

ZJU 3228 Searching the String ( AC 自动机 )

Pku 1986 Distance Queries

Pku 3277 City Horizon

Pku 2528 Mayor's posters

Pku 2985 The k-th Largest Group

Pku 2777 Count Color

ZJU 2770 Burn the Linked Camp(差分约束系统)

Pku 2777 Count Color

Zoj 1610 Count the Colors

PKU　　1151