C++博客-Darren-随笔分类-图论

Pku 3169 Layout

Darren — Mon, 20 Jul 2009 11:55:00 GMT

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

#define N 1005
#define inf 1<<29

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

int n, ml, md, s = 0 ;
Edge  ege[ 20010 ];
int dist[N];

int bell_man(){
     for ( int i = 1 ; i <= n; ++ i ) dist[i] = inf;
    dist[ 1 ] = 0 ;

     int flag = 0 ;
     for ( int i = 1 ; i <= n; ++ i ){
        flag = 0 ;
         for ( int j = 0 ; j < s; ++ j ){
             int u = ege[j].u, v = ege[j].v, w = ege[j].d;
             if ( dist[u] + w < dist[v] ) dist[v] = dist[u] + w, flag = 1 ;
        }
         if ( ! flag ) break ;
    }
     if ( flag ) return - 1 ;
     else if ( dist[n] == inf ) return - 2 ;
     else return dist[n];
}

int main(){
    scanf( " %d%d%d " , & n, & ml, & md );
     int u, v, d;
     while ( ml -- ){
        scanf( " %d%d%d " , & u, & v, & d );
        ege[s ++ ] = Edge( u, v, d );
    }
     while ( md -- ){
        scanf( " %d%d%d " , & u, & v, & d );
        ege[s ++ ] = Edge( v, u, - d );
    }
    printf( " %d\n " , bell_man() );

     return 0 ;
}

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

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 1258 Agri-Net

Darren — Wed, 05 Nov 2008 08:30:00 GMT

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

#define   N  110

int   n,result;
int   map[N][N];
bool visite[N];
int   dis[N];

void   Prim()
{
    memset( visite, false , sizeof (visite) );
    visite[ 0 ] = true ;  result = 0 ;

     for ( int i = 0 ; i < n; ++ i )  dis[i] = map[ 0 ][i];

     for ( int i = 1 ; i < n; ++ i )
     {
         int min = INT_MAX, k;

         for ( int j = 0 ; j < n; ++ j )
         if ( ! visite[j] && dis[j] < min ) min = dis[j], k = j;

        visite[k] = true ;  result += dis[k];
         for ( int j = 0 ; j < n; ++ j )
         if ( ! visite[j] && map[k][j] > 0 && map[k][j] < dis[j] )
              dis[j] = map[k][j];
    }
}

int main()
{
     while ( scanf( " %d " , & n) != EOF )
     {
         for ( int i = 0 ; i < n; ++ i )
            for ( int j = 0 ; j < n; ++ j )
           scanf( " %d " , & map[i][j] );

        Prim();
        printf( " %d\n " , result );
    }

     return 0 ;
}

Darren 2008-11-05 16:30 发表评论

Pku 1047 Round and Round We Go

Darren — Thu, 30 Oct 2008 13:16:00 GMT

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

int    visite[ 15 ];
char   str[ 100 ];
int    d[ 100 ];
int    len;

bool multi( int n )
{
     int t[ 100 ];
     int v[ 15 ];
     for ( int i = 0 ; i < len; ++ i ) t[i] = d[i];
     for ( int i = 0 ; i < 15 ; ++ i  ) v[i] = visite[i];

     for ( int i = 0 ; i < len; ++ i )
    t[i] *= n;

     for ( int i = len - 1 ; i > 0 ; i -- )
    {
        t[i - 1 ] += t[i] / 10 ;
        t[i] %= 10 ;
    }

     if ( t[ 0 ] >= 10 ) return false ;
     for ( int i = 0 ; i < len; ++ i )   if ( -- v[ t[i] ] < 0 ) return false ;

     return true ;
}

bool isok()
{
     for ( int i = 2 ; i <= len; ++ i )
     if ( ! multi( i ) ) return false ;

     return true ;
}

int main()
{
     while ( scanf( " %s " ,str) != EOF )
    {
        len = strlen( str );
        memset( visite, 0 , sizeof (visite) );

         for ( int i = 0 ; i < len; ++ i ) { d[i] = str[i] - ' 0 ' ; visite[ d[i] ] ++ ; }

         if ( isok() ) printf( " %s is cyclic\n " , str );
         else          printf( " %s is not cyclic\n " , str );
    }

     return 0 ;
}

Darren 2008-10-30 21:16 发表评论

Pku 1089 Intervals

Darren — Wed, 29 Oct 2008 15:01:00 GMT

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

#define N 50001

struct Node
{
     int a, b;
} ;

Node d[N];
int   n;

int cmp( const void * a, const void * b )
{
    Node * ta = (Node * )a;
    Node * tb = (Node * )b;

     if ( ta -> a == tb -> a ) return ta -> b - tb -> b;

     return ta -> a - tb -> a;
}

int main()
{
    scanf( " %d " , & n);

     for ( int i = 0 ; i < n; ++ i )  scanf( " %d%d " , & d[i].a, & d[i].b );
    qsort( d, n, sizeof ( d[ 0 ] ), cmp );

     int min = d[ 0 ].a, max = d[ 0 ].b;
     for ( int i = 1 ; i < n; ++ i )
     {
         if ( d[i].a > max )
         {
            printf( " %d %d\n " , min, max );
            min = d[i].a, max = d[i].b;
        }
         else if ( d[i].b > max ) max = d[i].b;
    }
    printf( " %d %d\n " , min, max );

     return 0 ;
}

Darren 2008-10-29 23:01 发表评论

Pku 1062 昂贵的聘礼

Darren — Wed, 29 Oct 2008 13:01:00 GMT

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

#define N 110

int graph[N][N];
int rank[N];
int value[N];
int m, n, len;

bool   findrank( int t )
{
     for ( int i = 0 ; i < t; ++ i )
     if ( value[i] == t ) return true ;

     return false ;
}

int dis( int Rank )
{
     bool visite[N];
     int   result[N];
    rank[ 0 ] = Rank;

     for ( int i = 1 ; i <= n; ++ i )
     {
         int t = Rank - rank[i];

         if ( t <= m && t >= 0 ) { visite[i] = false ;  result[i] = graph[ 0 ][i]; }
         else                   { visite[i] = true ;   result[i] = - 1 ; }
    }

    visite[ 0 ] = true ;
     for ( int t = 1 ; t <= n; ++ t )
     {
         int   min = INT_MAX;
         int   k = - 1 ;

         for ( int i = 0 ; i <= n; ++ i )
         if ( ! visite[i] && result[i] >= 0 && result[i] < min  )
         {
            min = result[i];
            k = i;
        }
         if ( k == - 1 ) break ;

        visite[k] = true ;
         for ( int i = 1 ; i <= n; ++ i )
         {
             if ( ! visite[i] &&   graph[k][i] >= 0 && result[k] >= 0
                         && ( result[k] + graph[k][i] < result[i] || result[i] == - 1 ) )
            result[i] = result[k] + graph[k][i];
        }
    }

     return result[ 1 ];
}

int main()
{
    scanf( " %d%d " , & m, & n);
    len = 0 ;

    memset( graph, - 1 , sizeof ( int ) * N * N );

     for ( int i = 1 ; i <= n; ++ i )
     {
         int va, ra, nn;

        scanf( " %d%d%d " , & va, & ra, & nn );
        graph[ 0 ][i] = va;
        rank[i] = ra;

         if ( ! findrank( ra ) ) value[len ++ ] = ra;

         for ( int j = 0 ; j < nn; ++ j )
         {
             int a, b;
            scanf( " %d%d " , & a, & b);

            graph[a][i] = b;
        }
    }

     int min = INT_MAX;
     for ( int i = 0 ; i < len; ++ i )
         {
             int t = dis( value[i] );

             if ( t < min && t != - 1 ) min = t;
        }

    printf( " %d\n " , min );

     return 0 ;
}

Darren 2008-10-29 21:01 发表评论

Pku 1094 Sorting It All Out

Darren — Thu, 02 Oct 2008 17:35:00 GMT

#include < iostream >
#include < stack >
#include < vector >

int    n, m;
int    degree[ 26 ];
int    data[ 26 ][ 26 ];
bool   exist[ 26 ];

std::vector < char > re;

int length()
{
     int num = 0 ;
     for ( int i = 0 ; i < n; ++ i )
         if ( exist[i] )
            num ++ ;

     return num;
}

int toplogicalsort()
{
    std::stack < char > st;
     int * d = new int [n];

    re.clear ();

     for ( int i = 0 ; i < n; ++ i )
        d[i] = degree[i];

     for ( int i = 0 ; i < n; ++ i )
         if ( d[i] == 0 && exist[i] )st.push(i);

     bool ok = true ;
     while ( ! st.empty() )
     {
         if ( ( int )st.size () > 1 )  ok = false ;

         int t = st.top ();
        st.pop();

        re.push_back ( t + ' A ' );

         for ( int i = 0 ; i < n; ++ i )
             if ( data[i][t] == 1 && exist[i] )
             {
                d[i] -- ;
                 if ( d[i] == 0 )   st.push (i);
            }
    }

     int len = length();
     if ( ( int )re.size () < len ) return 2 ;    // exit circle

     if ( ! ok ) return 0 ;
     if ( ( int )re.size () == n )   return 1 ;

     return 0 ;
}

int main()
{
     while ( scanf( " %d%d " , & n, & m), m + n != 0 )
     {
        memset( degree, 0 , sizeof (degree) );
        memset( data,    0 , sizeof (data  ) );
        memset( exist,   false , sizeof (exist) );

         bool isok = true ;
         bool determin = false ;
        getchar();

         for ( int i = 1 ; i <= m; ++ i )
         {
             char a, b;

            a = getchar();
            getchar();
            b = getchar();
            getchar();

            exist[a - ' A ' ] = true ;
            exist[b - ' A ' ] = true ;

             if (   ! determin && isok && (data[a - ' A ' ][b - ' A ' ] == 1 || a == b)  )
             {
                isok = false ;

                printf( " Inconsistency found after %d relations.\n " , i);
            }

             if ( data[b - ' A ' ][a - ' A ' ] == 0 ) degree[b - ' A ' ] ++ ;
            data[b - ' A ' ][a - ' A ' ] = 1 ;

             int type;
             if ( ! determin && isok && (type = toplogicalsort())  )
             {
                 if ( type == 1 )
                 {
                    determin = true ;

                    printf( " Sorted sequence determined after %d relations: " , i );
                     for ( size_t x = 0 ; x < re.size (); ++ x )
                        printf( " %c " , re[x] );
                    printf( " .\n " );
                }
                 else if ( type == 2 )
                 {
                    isok = false ;

                    printf( " Inconsistency found after %d relations.\n " , i);
                }
            }
        }

         if ( ! determin && isok ) printf( " Sorted sequence cannot be determined.\n " );
    }

     return 0 ;
}

Darren 2008-10-03 01:35 发表评论

pku 1797 Heavy Transportation

Darren — Thu, 02 Oct 2008 09:39:00 GMT

#include < iostream >
#include < algorithm >
#include < limits >

int   n,m;
int   graph[ 1001 ][ 1001 ];
bool visite[ 1001 ];
int   result[ 1001 ];

void shortpath()
{
    memset( visite, false , sizeof (visite) );
    memset( result, 0 , sizeof (result) );

    visite[ 1 ] = true ;

     for ( int i = 1 ; i <= n; ++ i )
            result[i] = graph[ 1 ][i];

     for ( int i = 1 ; i < n; ++ i )
     {
         int max = 0 ;
         int k = - 1 ;

         for ( int j = 1 ; j <= n; ++ j )
             if ( ! visite[j] && result[j] > max )
             {
                max = result[j];
                k = j;
            }

        visite[k] = true ;
         for ( int j = 1 ; j <= n; ++ j )
             if ( ! visite[j] && graph[k][j] > 0    && result[j] < std::min( result[k], graph[k][j] ) )
                result[j] = std::min ( result[k], graph[k][j]);
    }

}

int main()
{
     int test;
    scanf( " %d " , & test);

     for ( int t = 1 ; t <= test; ++ t )
     {
        scanf( " %d%d " , & n, & m);
        memset( graph, 0 , sizeof (graph) );

         for ( int i = 0 ; i < m; ++ i )
         {
             int x, y,d;
            scanf( " %d%d%d " , & x, & y, & d);

            graph[x][y] = d;
            graph[y][x] = d;
        }

        shortpath();
        printf( " Scenario #%d:\n " , t );
        printf( " %d\n " , result[n] );
        printf( " \n " );
    }

     return 0 ;
}

Darren 2008-10-02 17:39 发表评论

pku 2253 Frogger

Darren — Thu, 02 Oct 2008 07:24:00 GMT

#include < iostream >
#include < cmath >
#include < limits >

struct Point
{
     int x,y;
} ;

double graph[ 201 ][ 201 ];
Point   data[ 201 ];
int      n;
bool     visite[ 201 ];
double   result[ 201 ];

double Distance( Point & a, Point & b )
{
     return sqrt( ( double )( (a.x - b.x) * (a.x - b.x ) + (a.y - b.y ) * (a.y - b.y ) ) );
}

void shortpath( int t )
{
     for ( int i = 1 ; i <= n; ++ i )
     {
        visite[i] = false ;
        result[i] = 0.0 ;
    }

     for ( int i = 1 ; i <= n; ++ i )
        result[i] = graph[t][i];

    visite[t] = true ;
     for ( int i = 1 ; i <= n - 1 ; ++ i )
     {
         double min = std::numeric_limits < double > ::max();

         int k = - 1 ;
         for ( int j = 1 ; j <= n; ++ j )
             if ( ! visite[j] && result[j] < min )
             {
                min = result[j];
                k = j;
            }

        visite[k] = true ;
         for ( int j = 1 ; j <= n; ++ j )
             if ( ! visite[j] && std::max( graph[k][j], result[k] ) < result[j] )
                result[j] = std::max( graph[k][j], result[k] );
    }
}

int main()
{
     int num = 1 ;
     while ( scanf( " %d " , & n), n != 0 )
     {
         for ( int i = 1 ; i <= n; ++ i )
            scanf( " %d%d " , & data[i].x, & data[i].y );

         for ( int i = 1 ; i <= n; ++ i )
             for ( int j = 1 ; j <= n; ++ j )
                graph[i][j] = Distance( data[i], data[j] );

        shortpath( 1 );
        printf( " Scenario #%d\n " , num ++ );
        printf( " Frog Distance = %.3lf\n " , result[ 2 ] );
        printf( " \n " );
    }

     return 0 ;
}

Darren 2008-10-02 15:24 发表评论

PKU 1018 Communication System

Darren — Wed, 01 Oct 2008 14:06:00 GMT

#include < iostream >
#include < set >
#include < limits >

using namespace std;

struct Node
{
     int broad, price;
    Node() {}
    Node( int & a, int & b)
        :broad(a),price(b)
     {}
} ;

Node data[ 100 ][ 100 ];
int   length[ 100 ];

int main()
{
     int test;
    scanf( " %d " , & test);

     while ( test -- )
     {
         int n;
         set < int > br;

        scanf( " %d " , & n);

         for ( int i = 0 ; i < n; ++ i )
         {
             int d,x,y;
            scanf( " %d " , & d);

            length[i] = d;
             for ( int j = 0 ; j < d; ++ j )
             {
                scanf( " %d%d " , & x, & y);
                data[i][j] = Node(x,y);

                br.insert(x);     //    Save all broad , use set to avoid repeating
            }
        }

         set < int > ::iterator pos;
         double max = numeric_limits < double > ::min();
         for ( pos = br.begin (); pos != br.end (); ++ pos )    //    for every broad
         {
             int    t = * pos;
             int    total = 0 ;
             bool   isok = false ;

             for ( int i = 0 ; i < n; ++ i )    //   n devices
             {
                 int M = INT_MAX;

                 for ( int j = 0 ; j < length[i]; ++ j )
                     if ( data[i][j].broad >= t && data[i][j].price < M )
                        M = data[i][j].price;       //    find  the min price

                 if ( M == INT_MAX )
                 {
                    isok = true ;
                     break ;
                }
                total += M;
            }

             if ( isok ) continue ;

             if ( ( double )t / ( double )total > max ) max = ( double )t / ( double )total;    //   update
        }

        printf( " %.3lf\n " , max );
    }

     return 0 ;
}

Darren 2008-10-01 22:06 发表评论