C++博客-心如止水-随笔分类-题目分类：图论

UVa 10269 Adventure of Super Mario

lee1r — Fri, 04 Nov 2011 01:25:00 GMT

先求任意两点之间不经过城堡的最短路。d[i][j]表示到达i点使用了j次鞋子的最短路长度。
以下是我的代码：

#include <queue>
#include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;

const int kMaxn = 107;
const int kMaxm = kMaxn * kMaxn;
const int kInf = 0x7f7f7f7f;

int A, B, M, L, K, g[kMaxn][kMaxn];
int d[kMaxn][17];
bool inq[kMaxn][17];

struct State {
    State ( const int &_u, const int &_k ) : u ( _u ), k ( _k ) { }
    int u, k;
};

void Input () {
    memset ( g, 0x7f, sizeof ( g ) );
    scanf ( "%d%d%d%d%d", &A, &B, &M, &L, &K );
    while ( M-- ) {
        int u, v, w;
        scanf ( "%d%d%d", &u, &v, &w );
        g[u][v] = g[v][u] = w;
    }
}

void Solve () {
    for ( int k = 1; k <= A; k++ )
        for ( int i = 1; i <= A+B; i++ )
            for ( int j = 1; j <= A+B; j++ )
                if ( g[i][k] < kInf && g[k][j] < kInf && g[i][j] > g[i][k] + g[k][j] )
                    g[i][j] = g[i][k] + g[k][j];

    queue<State> q;
    memset ( d, 0x7f, sizeof ( d ) );
    memset ( inq, false, sizeof ( inq ) );
    d[A+B][0] = 0;
    q.push ( State ( A+B, 0 ) );
    while ( !q.empty() ) {
        int u = q.front().u, k = q.front().k;
        q.pop(); inq[u][k] = false;
        for ( int v = 1; v <= A + B; v++ ) {
            if ( k < K && g[u][v] <= L ) {
                if ( d[v][k+1] > d[u][k] ) {
                    d[v][k+1] = d[u][k];
                    if ( !inq[v][k+1] ) {
                        q.push ( State ( v, k+1 ) );
                        inq[v][k+1] = true;
                    }
                }
                if ( d[v][k] > d[u][k] + g[u][v] ) {
                    d[v][k] = d[u][k] + g[u][v];
                    if ( !inq[v][k] ) {
                        q.push ( State ( v, k ) );
                        inq[v][k] = true;
                    }
                }
            }
            else {
                if ( d[v][k] > d[u][k] + g[u][v] ) {
                    d[v][k] = d[u][k] + g[u][v];
                    if ( !inq[v][k] ) {
                        q.push ( State ( v, k ) );
                        inq[v][k] = true;
                    }
                }
            }
        }
    }
    int ans = kInf;
    for ( int i = 0; i <= K; i++ )
        ans = min ( ans, d[1][i] );
    printf ( "%d\n", ans );
}

int main () {
#ifndef ONLINE_JUDGE
    freopen ( "data.in", "r", stdin );
#endif
    int T;
    scanf ( "%d", &T );
    while ( T-- ) {
        Input ();
        Solve ();
    }
    return 0;
}

lee1r 2011-11-04 09:25 发表评论

UVa 10278 Fire Station

lee1r — Wed, 07 Sep 2011 16:08:00 GMT

题目大意就不说啦～
直接枚举新加入的结点即可。
以下是我的代码：

#include <iostream>
#include <sstream>
#include <string>
#include <queue>
#include <cstdio>
#include <cstring>
using namespace std;

const int kMaxn = 507;
const int kInf = 0x7f7f7f7f;

struct Edge
{
    int v, w;
};

int f, n, r[107];
int cnt, first[kMaxn], next[ kMaxn * 40 ];
Edge e[ kMaxn * 40 ];
int ans,value,d[107][kMaxn], near[kMaxn];

void Clear ()
{
    cnt=-1;
    memset ( first, -1, sizeof ( first ) );
}

void AddEdge ( int u, int v, int w )
{
    cnt++;
    e[cnt].v = v;
    e[cnt].w = w;
    next[cnt] = first[u];
    first[u] = cnt;
}

void Input ()
{
    scanf ( "%d%d", &f, &n );
    for ( int i = 1; i <= f; i++ )
        scanf ( "%d", &r[i] );
    //printf ( "%d\n", r[1] );
    getchar ();
    Clear ();
    string in;
    while ( getline ( cin, in ) && !in.empty() )
    {
        int u, v, w;
        istringstream ( in ) >> u >> v >> w;
        //printf ( "%d %d %d\n", u, v, w );
        AddEdge ( u, v, w );
        AddEdge ( v, u, w );
    }
}

void SPFA ( int start, int *dist )
{
    deque<int> q;
    bool inq[kMaxn];
    memset ( inq, false, sizeof ( inq ) );
    //memset ( dist, 0x7f, sizeof ( dist ) );
    for ( int i = 1; i <= n; i++ )
        dist[i] = kInf;
    dist[start] = 0;
    q.push_back( start );
    while ( !q.empty() )
    {
        int u = q.front(); q.pop_front();
        inq[u] = false;
        for ( int i = first[u]; i != -1; i = next[i] )
        {
            int v = e[i].v;
            if ( dist[v] > dist[u] + e[i].w )
            {
                dist[v] = dist[u] + e[i].w;
                if ( !inq[v] )
                {
                    if ( !q.empty() && dist[v] < dist[q.front()] )
                        q.push_front( v );
                    else
                        q.push_back( v );
                    inq[v] = true;
                }
            }
        }
    }
}

void Solve ()
{
    for ( int i = 1; i <= f; i++ )
        SPFA ( r[i], d[i] );

    //for ( int i = 1; i <= f; i++ )
    //{
        //for ( int j = 1; j <= n; j++)
            //printf ( "%d ", d[i][j] );
        //puts ( "" );
    //}

    memset ( near, 0x7f, sizeof ( near ) );
    for ( int i = 1; i <= n; i++ )
        for ( int j = 1; j <= f; j++ )
            near[i] = min ( near[i], d[j][i] );
    value = kInf;
    for ( int i = 1; i <= n; i++ )
    {
        SPFA ( i, d[f+1] );
        int t = 0;
        for ( int j = 1; j <= n; j++ )
            t = max ( t, min ( near[j], d[f+1][j] ) );
        if ( value > t)
        {
            ans = i;
            value = t;
        }
    }
}

int main ()
{
#ifndef ONLINE_JUDGE
    freopen ( "data.in", "r", stdin );
#endif

    int T;
    bool first_case = true;
    scanf ( "%d", &T );
    while ( T-- )
    {
        Input ();
        Solve ();

        if ( first_case )
            first_case = false;
        else
            puts ( "" );
        printf ( "%d\n", ans );
    }

    return 0;
}

lee1r 2011-09-08 00:08 发表评论

UVa 10276 Hanoi Tower Troubles Again!

lee1r — Sat, 27 Aug 2011 02:43:00 GMT

此题使用了交表。打表的做法参见本博客的另一篇文章《网络流24题》。
以下是我的代码：

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

const int kMaxn(1350);
const int kMaxm(1000007);

struct Edge
{
    int u,v;
};

int ans,nx,ny;
int cnt,first[kMaxn],next[kMaxm];
Edge e[kMaxm];
int maxmatch,cx[kMaxn],cy[kMaxn];
int distx[kMaxn],disty[kMaxn];
int head,tail,q[kMaxn];

void Clear()
{
    cnt=0;
    for(int i=1;i<=ans;i++)
        first[i]=-1;
}

void AddEdge(int u,int v)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    next[cnt]=first[u];
    first[u]=cnt;
}

bool OK(int a,int b)
{
    return ((int)sqrt((double)a+b))*((int)sqrt((double)a+b))==a+b;
}

void Build()
{
    nx=ny=ans;
    for(int i=1;i<=ans;i++)
        for(int j=i+1;j<=ans;j++)
            if(OK(i,j))
                AddEdge(i,j);
}

bool BFS()
{
    bool re(false);
    head=tail=0;
    memset(distx,0,sizeof(distx));
    memset(disty,0,sizeof(disty));
    for(int i=1;i<=nx;i++)
        if(cx[i]==-1)
            q[tail++]=i;
    while(head!=tail)
    {
        int h,t;
        for(h=head,t=tail;h!=t;h=(h+1)%kMaxn)
        {
            int u(q[h]);
            for(int i=first[u];i!=-1;i=next[i])
            {
                int v(e[i].v);
                if(!disty[v])
                {
                    disty[v]=distx[u]+1;
                    if(cy[v]==-1)
                        re=true;
                    else
                    {
                        distx[cy[v]]=disty[v]+1;
                        q[tail]=cy[v];
                        tail=(tail+1)%kMaxn;
                    }
                }
            }
        }
        head=t;
    }
    return re;
}

bool DFS(int u)
{
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v(e[i].v);
        if(disty[v]==distx[u]+1)
        {
            disty[v]=0;
            if(cy[v]==-1 || DFS(cy[v]))
            {
                cx[u]=v;
                cy[v]=u;
                return true;
            }
        }
    }
    return false;
}

void HopcroftKarp()
{
    maxmatch=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));

    while(BFS())
        for(int i=1;i<=nx;i++)
            if(cx[i]==-1 && DFS(i))
                maxmatch++;
}

int Solve()
{
    Clear();
    Build();
    HopcroftKarp();
    return ans-maxmatch;
}

int r[57];

void Init()
{
    memset(r,-1,sizeof(r));
    for(ans=1;r[50]==-1;ans++)
    {
        int t(Solve());
        if(t>=1 && r[t-1]==-1)
        {
            r[t-1]=ans-1;
            printf("%d\n",r[t-1]);
        }
    }
}

int main()
{
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);

    Init();

    int T;
    scanf("%d",&T);
    while(T--)
    {
        int n;
        scanf("%d",&n);

        printf("%d\n",r[n]);
    }
}

lee1r 2011-08-27 10:43 发表评论

POJ 3715 Blue and Red

lee1r — Fri, 19 Aug 2011 14:07:00 GMT

题目就是让求一个二分图的最小点覆盖，然后输出字典序最小的方案。
依次从二分图中删除0..N-1中的一个点，如果此时最大匹配数减少了，就永久删除这个点，然后输出这个点，否则将该点恢复。
使用Hopcroft Karp算法157ms。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/19 21:40:58
* File Name: poj3715.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) ((x)<<1|1)
#define Half(x) ((x)>>1)
#define Lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef unsigned int uint;
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(207);
const int kMaxm(20007);

struct Edge
{
    int u,v;
};

int N,M,r[kMaxn];
int cnt,first[kMaxn],next[kMaxm];Edge e[kMaxm];
int maxmatch,cx[kMaxn],cy[kMaxn];
int distx[kMaxn],disty[kMaxn];
int head,tail,q[kMaxn];
bool used[kMaxn];

void Clear()
{
    cnt=0;
    memset(first,-1,sizeof(first));
}

void AddEdge(int u,int v)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    next[cnt]=first[u];
    first[u]=cnt;
}

bool BFS()
{
    bool re(false);
    head=tail=0;
    memset(distx,0,sizeof(distx));
    memset(disty,0,sizeof(disty));
    for(int i=0;i<N;i++)
        if(used[i] && !r[i] && cx[i]==-1)
            q[tail++]=i;
    while(head!=tail)
    {
        int h,t;
        for(h=head,t=tail;h!=t;h=(h+1)%kMaxn)
        {
            int u(q[h]);
            for(int i=first[u];i!=-1;i=next[i])
            {
                int v(e[i].v);
                if(!used[v])
                    continue;
                if(!disty[v])
                {
                    disty[v]=distx[u]+1;
                    if(cy[v]==-1)
                        re=true;
                    else
                    {
                        distx[cy[v]]=disty[v]+1;
                        q[tail]=cy[v];
                        tail=(tail+1)%kMaxn;
                    }
                }
            }
        }
        head=t;
    }
    return re;
}

bool DFS(int u)
{
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v(e[i].v);
        if(!used[v])
            continue;
        if(disty[v]==distx[u]+1)
        {
            disty[v]=0;
            if(cy[v]==-1 || DFS(cy[v]))
            {
                cx[u]=v;
                cy[v]=u;
                return true;
            }
        }
    }
    return false;
}

void HopcroftKarp()
{
    maxmatch=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));

    while(BFS())
        for(int i=0;i<N;i++)
            if(used[i] && !r[i] && cx[i]==-1 && DFS(i))
                maxmatch++;
}

int main()
{
    #ifndef ONLINE_JUDGE
    //freopen("data.in","r",stdin);
    #endif

    int T;
    scanf("%d",&T);
    while(T--)
    {
        Clear();

        scanf("%d%d",&N,&M);
        for(int i=0;i<N;i++)
            scanf("%d",&r[i]);
        while(M--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            if(r[u]!=r[v])
            {
                if(r[u]==0)
                    AddEdge(u,v);
                else
                    AddEdge(v,u);
            }
        }

        for(int i=0;i<N;i++)
            used[i]=true;
        HopcroftKarp();
        int ans(maxmatch);
        printf("%d",ans);
        for(int i=0;i<N && ans;i++)
        {
            used[i]=false;
            HopcroftKarp();
            if(maxmatch<ans)
                printf(" %d",i);
            else
                used[i]=true;
            ans=maxmatch;
        }
        printf("\n");
    }

    return 0;
}

lee1r 2011-08-19 22:07 发表评论

HDU 3861 The King’s Problem

lee1r — Tue, 16 Aug 2011 16:07:00 GMT

题目大意：给出一个有向图，问最多能够分成多少个区域，使得每个区域内的任意一对顶点X、Y间，要么X能达到Y，要么Y能到达X。
不错的题目！
具体做法是这样的，因为强连通分量内部的点肯定能互相到达，因此先缩点；然后问题就转化成了有向无环图的最小路径覆盖问题，因为缩点之后的图上的任意一条路径都是满足要求的。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/15 11:04:01
* File Name: hdu3861.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define Lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef unsigned int uint;
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(5007);
const int kMaxm(100007);

struct Edge
{
    int u,v;
};
int N,M,cnt,first2[kMaxn],next2[kMaxm],e2[kMaxm];
int n,dfscnt,dfsn[kMaxn],low[kMaxn],id[kMaxn];
stack<int> s;
bool instack[kMaxn];
int nx,ny,maxmatch,first[kMaxn],next[kMaxm];Edge e[kMaxm];
int cx[kMaxn],cy[kMaxn],distx[kMaxn],disty[kMaxn];
int head,tail,q[kMaxn];

void Input()
{
    cnt=0;
    memset(first2,-1,sizeof(first2));

    scanf("%d%d",&N,&M);
    for(int i=1;i<=M;i++)
    {
        int u,v;
        scanf("%d%d",&u,&v);
        cnt++;
        e2[cnt]=v;
        next2[cnt]=first2[u];
        first2[u]=cnt;
    }
}

void dfs(int u)
{
    dfsn[u]=low[u]=++dfscnt;
    s.push(u);
    instack[u]=true;
    for(int i=first2[u];i!=-1;i=next2[i])
    {
        int v(e2[i]);
        if(!dfsn[v])
        {
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else if(instack[v])
            low[u]=min(low[u],dfsn[v]);
    }
    if(dfsn[u]==low[u])
    {
        n++;
        int v;
        do
        {
            v=s.top();s.pop();
            instack[v]=false;
            id[v]=n;
        }while(v!=u);
    }
}

void Tarjan()
{
    n=dfscnt=0;
    memset(dfsn,0,sizeof(dfsn));
    memset(instack,false,sizeof(instack));
    for(int i=1;i<=N;i++)
        if(!dfsn[i])
            dfs(i);
}

void Rebuild()
{
    cnt=0;
    nx=ny=n;
    memset(first,-1,sizeof(first));
    for(int u=1;u<=N;u++)
        for(int i=first2[u];i!=-1;i=next2[i])
        {
            int v(id[e2[i]]);
            if(id[u]==v)
                continue;
            bool found(false);
            for(int j=first[id[u]];j!=-1;j=next[j])
                if(e[j].v==v)
                {
                    found=true;
                    break;
                }
            if(found)
                continue;
            cnt++;
            e[cnt].u=id[u];e[cnt].v=v;
            next[cnt]=first[id[u]];
            first[id[u]]=cnt;
        }
}

bool BFS()
{
    bool re(false);
    head=tail=0;
    memset(distx,0,sizeof(distx));
    memset(disty,0,sizeof(disty));
    for(int i=1;i<=nx;i++)
        if(cx[i]==-1)
            q[tail++]=i;
    while(head!=tail)
    {
        int h,t;
        for(h=head,t=tail;h!=t;h=(h+1)%kMaxn)
        {
            int u(q[h]);
            for(int i=first[u];i!=-1;i=next[i])
            {
                int v(e[i].v);
                if(!disty[v])
                {
                    disty[v]=distx[u]+1;
                    if(cy[v]==-1)
                        re=true;
                    else
                    {
                        distx[cy[v]]=disty[v]+1;
                        q[tail]=cy[v];
                        tail=(tail+1)%kMaxn;
                    }
                }
            }
        }
        head=t;
    }
    return re;
}

bool DFS(int u)
{
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v(e[i].v);
        if(disty[v]==distx[u]+1)
        {
            disty[v]=0;
            if(cy[v]==-1 || DFS(cy[v]))
            {
                cx[u]=v;
                cy[v]=u;
                return true;
            }
        }
    }
    return false;
}

void HopcroftKarp()
{
    maxmatch=0;
    memset(cx,-1,sizeof(cx));
    memset(cy,-1,sizeof(cy));

    while(BFS())
    {
        for(int i=1;i<=nx;i++)
            if(cx[i]==-1 && DFS(i))
                maxmatch++;
    }
}

void Output()
{
    printf("%d\n",n-maxmatch);
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        Input();
        Tarjan();
        Rebuild();
        HopcroftKarp();
        Output();
    }

    return 0;
}

lee1r 2011-08-17 00:07 发表评论

POJ 3041 Asteroids

lee1r — Thu, 11 Aug 2011 04:03:00 GMT

二分图最大匹配。
以下是我的代码：

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

const int kMaxn(50007);
const int kMaxm(150007);

struct Edge
{
    int u,v;
};

int nx,ny,m;
int cnt,first[kMaxn],next[kMaxm];
Edge e[kMaxm];
int cx[kMaxn],cy[kMaxn];
int distx[kMaxn],disty[kMaxn];
int head,tail,q[kMaxn];
int maxmatch;

void Clear()
{
    cnt=0;
    for(int i=1;i<=nx;i++)
        first[i]=-1;
}

void AddEdge(int u,int v)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    next[cnt]=first[u];
    first[u]=cnt;
}

bool BFS()
{
    bool re(false);
    head=tail=0;
    for(int i=1;i<=nx;i++)
        distx[i]=0;
    for(int i=1;i<=ny;i++)
        disty[i]=0;
    for(int i=1;i<=nx;i++)
        if(cx[i]==-1)
            q[tail++]=i;
    while(head!=tail)
    {
        int h,t;
        for(h=head,t=tail;h!=t;h=(h+1)%kMaxn)
        {
            int u(q[h]);
            for(int i=first[u];i!=-1;i=next[i])
            {
                int v(e[i].v);
                if(!disty[v])
                {
                    disty[v]=distx[u]+1;
                    if(cy[v]==-1)
                        re=true;
                    else
                    {
                        distx[cy[v]]=disty[v]+1;
                        q[tail]=cy[v];
                        tail=(tail+1)%kMaxn;
                    }
                }
            }
        }
        head=t;
    }
    return re;
}

bool DFS(int u)
{
    for(int i=first[u];i!=-1;i=next[i])
    {
        int v(e[i].v);
        if(disty[v]==distx[u]+1)
        {
            disty[v]=0;
            if(cy[v]==-1 || DFS(cy[v]))
            {
                cx[u]=v;
                cy[v]=u;
                return true;
            }
        }
    }
    return false;
}

void HopcroftKarp()
{
    maxmatch=0;
    for(int i=1;i<=nx;i++)
        cx[i]=-1;
    for(int i=1;i<=ny;i++)
        cy[i]=-1;

    while(BFS())
    {
        for(int i=1;i<=nx;i++)
            if(cx[i]==-1 && DFS(i))
                maxmatch++;
    }
}

int main()
{
    while(scanf("%d%d",&nx,&m)==2)
    {
        ny=nx;
        Clear();

        while(m--)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            AddEdge(u,v);
        }

        HopcroftKarp();

        printf("%d\n",maxmatch);
    }
}

lee1r 2011-08-11 12:03 发表评论

POJ 1860 Currency Exchange

lee1r — Fri, 05 Aug 2011 04:00:00 GMT

不断松弛，直到符合条件或不能松弛。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/5 10:15:15
* File Name: poj1860.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-8);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(107);

struct Edge
{
    int u,v;
    double rate,comm;
};

int n,m,s;
double v;
Edge e[kMaxn*kMaxn*2];int cnt;

void AddEdge(int u,int v,double rate,double comm)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].rate=rate;
    e[cnt].comm=comm;
}

bool BellmanFord()
{
    double dist[kMaxn];
    for(int i=1;i<=n;i++)
        dist[i]=(i==s?v:0.0);
    while(dist[s]-v<=kEps)
    {
        bool found(false);
        for(int j=1;j<=cnt;j++)
            if(dist[e[j].v]-(dist[e[j].u]-e[j].comm)*e[j].rate<-kEps)
            {
                dist[e[j].v]=(dist[e[j].u]-e[j].comm)*e[j].rate;
                found=true;
            }
        if(!found)
            return dist[s]-v>kEps;
    }
    return (dist[s]-v)>kEps;
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d%d%d%lf",&n,&m,&s,&v)==4)
    {
        cnt=0;
        while(m--)
        {
            int a,b;
            double t1,t2,t3,t4;
            scanf("%d%d%lf%lf%lf%lf",&a,&b,&t1,&t2,&t3,&t4);
            AddEdge(a,b,t1,t2);
            AddEdge(b,a,t3,t4);
        }

        if(BellmanFord())
            printf("YES\n");
        else
            printf("NO\n");
    }

    return 0;
}

lee1r 2011-08-05 12:00 发表评论

ZOJ 2770 Burn the Linked Camp

lee1r — Tue, 02 Aug 2011 12:19:00 GMT

差分约束系统。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 19:46:45
* File Name: zoj2770.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const long long kInf(0x7f7f7f7f7f7f7f7fll);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(1007);
const int kMaxm(20007);

struct Edge
{
    int u,v,w;
};

int n,m,cnt;
Edge e[kMaxm];
int64 ans;

void AddEdge(int u,int v,int w)
{
    cnt++;
    e[cnt].u=u;
    e[cnt].v=v;
    e[cnt].w=w;
}

int64 BellmanFord()
{
    int64 d[kMaxn];
    d[n]=0;
    for(int i=0;i<n;i++)
        d[i]=kInf;
    for(int i=0;i<n;i++)
        for(int j=1;j<=cnt;j++)
            if(d[e[j].u]<kInf && d[e[j].v]>d[e[j].u]+e[j].w)
                d[e[j].v]=d[e[j].u]+e[j].w;
    for(int i=1;i<=cnt;i++)
        if(d[e[i].v]>d[e[i].u]+e[i].w)
            return -1;
    return d[0];
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        cnt=0;
        for(int i=1;i<=n;i++)
        {
            int t;
            scanf("%d",&t);
            AddEdge(i-1,i,t);
            AddEdge(i,i-1,0);
        }
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(v,u-1,-w);
        }

        ans=BellmanFord();

        if(ans==-1)
            printf("Bad Estimations\n");
        else
            cout<<-ans<<endl;
    }

    return 0;
}

lee1r 2011-08-02 20:19 发表评论

POJ 1125 Stockbroker Grapevine

lee1r — Tue, 02 Aug 2011 11:25:00 GMT

求最短路的最大值。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 19:13:45
* File Name: poj1125.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(107);

int n,ans,pos,g[kMaxn][kMaxn];

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        memset(g,0x7f,sizeof(g));

        for(int i=1;i<=n;i++)
        {
            int m;
            scanf("%d",&m);
            for(int j=1;j<=m;j++)
            {
                int a,t;
                scanf("%d%d",&a,&t);
                g[i][a]=t;
            }
        }

        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    if(g[i][k]<kInf && g[k][j]<kInf && g[i][j]>g[i][k]+g[k][j])
                        g[i][j]=g[i][k]+g[k][j];

        ans=kInf;
        for(int i=1;i<=n;i++)
        {
            int t(0);
            for(int j=1;j<=n;j++)
                if(i!=j)
                t=max(t,g[i][j]);
            if(ans>t)
            {
                ans=t;
                pos=i;
            }
        }

        if(ans<kInf)
            printf("%d %d\n",pos,ans);
        else
            printf("disjoint\n");
    }

    return 0;
}

lee1r 2011-08-02 19:25 发表评论

POJ 2472 106 miles to Chicago

lee1r — Tue, 02 Aug 2011 10:18:00 GMT

概率上的最长路可以使用Dijkstra解决，因为乘以一个[0,1]的数不会比原来的值大。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 16:42:25
* File Name: poj2472.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(200);
const double kEps(1e-11);
typedef long long int64;
typedef unsigned long long uint64;

const int kMaxn(107);

int n,m;
double g[kMaxn][kMaxn],d[kMaxn];

void Dijkstra()
{
    bool visited[kMaxn];
    memset(visited,false,sizeof(visited));
    d[1]=1;
    for(int i=2;i<=n;i++)
        d[i]=0;
    for(int i=1;i<=n;i++)
    {
        int v(-1);
        double w(0);
        for(int j=1;j<=n;j++)
            if(!visited[j] && w<d[j])
            {
                v=j;
                w=d[j];
            }
        if(v==-1)
            break;
        visited[v]=true;
        for(int j=1;j<=n;j++)
            if(d[j]<d[v]*g[v][j])
                d[j]=d[v]*g[v][j];
    }
}

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        memset(g,0,sizeof(g));

        scanf("%d",&m);
        while(m--)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            g[u][v]=g[v][u]=w/100.0;
        }

        Dijkstra();

        printf("%.6f percent\n",d[n]*100);
    }

    return 0;
}

lee1r 2011-08-02 18:18 发表评论

POJ 2263 Heavy Gargo

lee1r — Tue, 02 Aug 2011 08:37:00 GMT

题目大意是，给出一个无向图，求两点间某条路径上的边的容量的最大值。可以使用Floyed算法实现，用d[i][j]表示从第i个点到第j个点的全部的路径上的容量最大值，则d[i][j]=max(d[i][j],min(d[i][k],d[k][j]))。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 16:17:25
* File Name: poj2263.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
const int kInf(0x7f7f7f7f);
typedef long long int64;
typedef unsigned long long uint64;
const int kMaxn(207);

int T,n,m,cnt,d[kMaxn][kMaxn];
map<string,int> id;

int main()
{
    //freopen("data.in","r",stdin);

    T=0;
    while(scanf("%d%d",&n,&m)==2 && (n || m))
    {
        cnt=0;
        id.clear();
        memset(d,0,sizeof(d));
        /*
        for(int i=0;i            d[i][i]=kInf;
        */
        string a,b;
        for(int i=1;i<=m;i++)
        {
            int w;
            cin>>a>>b;
            scanf("%d",&w);
            if(!id.count(a))
                id[a]=++cnt;
            if(!id.count(b))
                id[b]=++cnt;
            d[id[a]][id[b]]=d[id[b]][id[a]]=w;
        }
        /*
        for(int i=1;i<=n;i++)
        {
            for(int j=1;j<=n;j++)
                printf("%d ",d[i][j]);
            printf("\n");
        }
        */
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    d[i][j]=max(d[i][j],min(d[i][k],d[k][j]));

        cin>>a>>b;
        printf("Scenario #%d\n",++T);
        printf("%d tons\n\n",d[id[a]][id[b]]);
    }

    return 0;
}

lee1r 2011-08-02 16:37 发表评论

POJ 2570 Fiber Network

lee1r — Tue, 02 Aug 2011 08:13:00 GMT

题目大意是，某条道路由一些公司修建，修建道路的公司可以提供这条路上的连通，询问哪些公司可以提供从A到B的路径。
类似于Floyed的算法。用二进制数表示一个集合。
以下是我的代码：

/*
* Author:  lee1r
* Created Time:  2011/8/2 15:57:29
* File Name: poj2570.cpp
*/
#include<iostream>
#include<sstream>
#include<fstream>
#include<vector>
#include<list>
#include<deque>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<bitset>
#include<algorithm>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cctype>
#include<cmath>
#include<ctime>
#define L(x) ((x)<<1)
#define R(x) (((x)<<1)+1)
#define Half(x) ((x)>>1)
#define lowbit(x) ((x)&(-(x)))
using namespace std;
typedef long long int64;
typedef unsigned long long uint64;
const int kMaxn(207);

int n,cnt,d[kMaxn][kMaxn];
map<string,int> id;

int main()
{
    //freopen("data.in","r",stdin);

    while(scanf("%d",&n)==1 && n)
    {
        cnt=0;
        memset(d,0,sizeof(d));
        int u,v;
        while(scanf("%d%d",&u,&v)==2 && (u || v))
        {
            string company;
            cin>>company;
            for(int i=0;i<company.size();i++)
                d[u][v]|=(1<<(company[i]-'a'));
        }
        for(int k=1;k<=n;k++)
            for(int i=1;i<=n;i++)
                for(int j=1;j<=n;j++)
                    d[i][j]|=d[i][k]&d[k][j];
        while(scanf("%d%d",&u,&v)==2 && (u || v))
        {
            bool found(false);
            for(int i=0;i<26;i++)
                if(d[u][v]&(1<<i))
                {
                    printf("%c",(char)(i+'a'));
                    found=true;
                }
            if(!found)
                printf("-");
            printf("\n");
        }
        printf("\n");
    }

    return 0;
}

lee1r 2011-08-02 16:13 发表评论

POJ 3268 Silver Cow Party

lee1r — Sun, 31 Jul 2011 01:52:00 GMT

正向图反向图各求一次单源最短路。
以下是我的代码：

#include<iostream>
#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(1007);
const int kMaxm(100007);
const long long kInf(0x7f7f7f7f7f7f7f7fll);
struct Edge
{
    int v,w;
};

int n,m,x;
int cnt,first[kMaxn],next[kMaxm];Edge e[kMaxm];
int first2[kMaxn],next2[kMaxm];Edge e2[kMaxm];
long long d1[kMaxn],d2[kMaxn];

void SPFA(int first[kMaxn],int next[kMaxn],Edge e[kMaxm],int start,long long dist[kMaxn])
{
    queue<int> q;
    bool inq[kMaxn]={false};
    for(int i=1;i<=n;i++)
        dist[i]=(i==start?0:kInf);
    q.push(start);
    inq[start]=true;
    while(!q.empty())
    {
        int u(q.front());q.pop();
        inq[u]=false;
        for(int i=first[u];i!=-1;i=next[i])
        {
            int v(e[i].v),w(e[i].w);
            if(dist[v]>dist[u]+w)
            {
                dist[v]=dist[u]+w;
                if(!inq[v])
                {
                    q.push(v);
                    inq[v]=true;
                }
            }
        }
    }
}

int main()
{
    while(scanf("%d%d%d",&n,&m,&x)==3)
    {
        cnt=0;
        memset(first,-1,sizeof(first));
        memset(first2,-1,sizeof(first));
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            cnt++;
            e[cnt].v=v;e[cnt].w=w;
            next[cnt]=first[u];
            first[u]=cnt;
            e2[cnt].v=u;e2[cnt].w=w;
            next2[cnt]=first2[v];
            first2[v]=cnt;
        }

        SPFA(first,next,e,x,d1);
        SPFA(first2,next2,e2,x,d2);

        long long ans(0);
        for(int i=1;i<=n;i++)
            ans=max(ans,d1[i]+d2[i]);

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-07-31 09:52 发表评论

POJ 3259 Wormholes

lee1r — Sun, 31 Jul 2011 01:51:00 GMT

SPFA判负权回路。
以下是我的代码：

#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(507);
const int kMaxm(5207);
const long long kInf(0x7f7f7f7f7f7f7f7fll);

struct Edge
{
    int v,w;
};

int n,m,w;
int cnt,first[kMaxn],next[kMaxm];Edge e[kMaxm];

void AddEdge(int u,int v,int w)
{
    cnt++;
    e[cnt].v=v;e[cnt].w=w;
    next[cnt]=first[u];
    first[u]=cnt;
}

bool SPFA()
{
    long long dist[kMaxn];
    queue<int> q;
    int num[kMaxn]={0};
    bool inq[kMaxn]={false};
    for(int i=1;i<=n;i++)
        dist[i]=(i==1?0:kInf);
    q.push(1);
    inq[1]=true;
    num[1]++;
    while(!q.empty())
    {
        int u(q.front());q.pop();
        inq[u]=false;
        if(num[u]>n)
            return true;
        for(int i=first[u];i!=-1;i=next[i])
        {
            int v(e[i].v),w(e[i].w);
            if(dist[v]>dist[u]+w)
            {
                dist[v]=dist[u]+w;
                if(!inq[v])
                {
                    q.push(v);
                    inq[v]=true;
                    num[v]++;
                }
            }
        }
    }
    return false;
}

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        scanf("%d%d%d",&n,&m,&w);
        cnt=0;
        memset(first,-1,sizeof(first));
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(u,v,w);
            AddEdge(v,u,w);
        }
        for(int i=1;i<=w;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            AddEdge(u,v,-w);
        }

        if(SPFA())
            printf("YES\n");
        else
            printf("NO\n");
    }

    return 0;
}

lee1r 2011-07-31 09:51 发表评论

POJ 2240 Arbitrage

lee1r — Sun, 31 Jul 2011 01:47:00 GMT

用BellmanFord求最长路。
以下是我的代码：

#include<iostream>
#include<string>
#include<map>
#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(37);
struct Edge
{
    int u,v;
    double w;
};

int n,m;
Edge e[kMaxn*kMaxn];

bool BellmanFord(int s)
{
    double d[kMaxn];
    for(int i=1;i<=n;i++)
        d[i]=(i==s?1:0);
    for(int i=1;i<=n;i++)
        for(int j=1;j<=m;j++)
        {
            int u(e[j].u),v(e[j].v);
            double w(e[j].w);
            d[v]=max(d[v],d[u]*w);
        }
    return d[s]>1;
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T(0);
    while(cin>>n && n)
    {
        map<string,int> id;
        for(int i=1;i<=n;i++)
        {
            string t;
            cin>>t;
            id[t]=i;
        }
        cin>>m;
        for(int i=1;i<=m;i++)
        {
            string t1,t2;
            cin>>t1>>e[i].w>>t2;
            e[i].u=id[t1];
            e[i].v=id[t2];
        }

        bool success(false);
        for(int i=1;i<=n;i++)
            if(BellmanFord(i))
            {
                success=true;
                break;
            }

        printf("Case %d: ",++T);
        if(success)
            printf("Yes\n");
        else
            printf("No\n");
    }

    return 0;
}

lee1r 2011-07-31 09:47 发表评论

POJ 2031 Building a Space Station

lee1r — Sun, 31 Jul 2011 01:46:00 GMT

MST问题。
以下是我的代码：

#include<cstdio>
#include<cmath>
using namespace std;
const int kMaxn(107);

int n;
double x[kMaxn],y[kMaxn],z[kMaxn],r[kMaxn];
double g[kMaxn][kMaxn];
double mst,lowcost[kMaxn];
bool visited[kMaxn];

double distance(int a,int b)
{
    return sqrt((x[a]-x[b])*(x[a]-x[b])+(y[a]-y[b])*(y[a]-y[b])+(z[a]-z[b])*(z[a]-z[b]));
}

void Prim()
{
    mst=.0;
    for(int i=1;i<=n;i++)
    {
        lowcost[i]=g[1][i];
        visited[i]=false;
    }
    visited[1]=true;

    for(int i=1;i<n;i++)
    {
        int v(-1);
        double w(0x7f7f7f7f+.0);
        for(int j=1;j<=n;j++)
            if(!visited[j] && w>lowcost[j])
            {
                v=j;
                w=lowcost[j];
            }
        if(v!=-1)
        {
            mst+=w;
            visited[v]=true;
            for(int j=1;j<=n;j++)
                if(!visited[j] && lowcost[j]>g[v][j])
                    lowcost[j]=g[v][j];
        }
    }
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    while(scanf("%d",&n)==1 && n)
    {
        for(int i=1;i<=n;i++)
        {
            scanf("%lf%lf%lf%lf",&x[i],&y[i],&z[i],&r[i]);
            for(int j=1;j<i;j++)
            {
                double t(distance(i,j));
                if(t>r[i]+r[j])
                    g[i][j]=g[j][i]=t-r[i]-r[j];
                else
                    g[i][j]=g[j][i]=.0;
            }
        }

        Prim();

        printf("%.3f\n",mst);
    }

    return 0;
}

lee1r 2011-07-31 09:46 发表评论

POJ 1861 Network

lee1r — Sun, 31 Jul 2011 01:44:00 GMT

MST问题。
以下是我的代码：

#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(1007);
const int kMaxm(15007);
struct Edge
{
    int u,v,w;
};
bool operator<(const Edge &a,const Edge &b)
{
    return (a.w<b.w);
}

int n,m,f[kMaxn];
Edge e[kMaxm],ans[kMaxn];

int Getf(int x)
{
    if(x==f[x])
        return x;
    f[x]=Getf(f[x]);
    return f[x];
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=1;i<=n;i++)
            f[i]=i;

        for(int i=1;i<=m;i++)
            scanf("%d%d%d",&e[i].u,&e[i].v,&e[i].w);

        sort(e+1,e+m+1);

        for(int i=1,j=0;i<=m && j<n-1;i++)
        {
            int u(e[i].u),v(e[i].v),fu(Getf(u)),fv(Getf(v));
            if(fu!=fv)
            {
                f[fu]=fv;
                j++;
                ans[j].u=u;
                ans[j].v=v;
                ans[j].w=e[i].w;
            }
        }

        printf("%d\n",ans[n-1].w);
        printf("%d\n",n-1);
        for(int i=1;i<n;i++)
            printf("%d %d\n",ans[i].u,ans[i].v);
    }

    return 0;
}

lee1r 2011-07-31 09:44 发表评论

POJ 1789 Truck History

lee1r — Sun, 31 Jul 2011 01:41:00 GMT

MST问题。
以下是我的代码：

#include<iostream>
#include<string>
#include<cstdio>
using namespace std;
const int kMaxn(2007);
const int kInf(0x7f7f7f7f);

int n,g[kMaxn][kMaxn];
string name[kMaxn];
int mst,lowcost[kMaxn];

int dist(int a,int b)
{
    int re(0);
    for(int i=0;i<7;i++)
        if(name[a][i]!=name[b][i])
            re++;
    return re;
}

void Prim()
{
    mst=0;
    for(int i=1;i<=n;i++)
        lowcost[i]=g[1][i];
    lowcost[1]=-1;
    for(int i=1;i<=n-1;i++)
    {
        int v(-1),w(kInf);
        for(int j=1;j<=n;j++)
            if(lowcost[j]!=-1 && w>lowcost[j])
            {
                v=j;
                w=lowcost[j];
            }
        if(v!=-1)
        {
            mst+=w;
            lowcost[v]=-1;
            for(int j=1;j<=n;j++)
                if(lowcost[j]!=-1 && lowcost[j]>g[v][j])
                    lowcost[j]=g[v][j];
        }
    }
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    while(cin>>n && n)
    {
        for(int i=1;i<=n;i++)
            cin>>name[i];
        for(int i=2;i<=n;i++)
            for(int j=1;j<=i-1;j++)
                g[i][j]=g[j][i]=dist(i,j);

        Prim();

        printf("The highest possible quality is 1/%d.\n",mst);
    }

    return 0;
}

lee1r 2011-07-31 09:41 发表评论

POJ 1511 Invitation Cards

lee1r — Sun, 31 Jul 2011 01:34:00 GMT

构造反向图，分别求单源最短路，然后求和即可。
以下是我的代码：

#include<iostream>
#include<queue>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(1000007);
const int kMaxm(1000007);
const long long kInf(0x7f7f7f7f7f7f7f7f);
struct Edge
{
    int v,w;
};

void SPFA(int n,int first[kMaxn],int next[kMaxm],Edge e[kMaxm],long long d[kMaxn])
{
    queue<int> q;
    bool inq[kMaxn];
    memset(inq,false,sizeof(inq));
    for(int i=1;i<=n;i++)
        d[i]=kInf;
    d[1]=0;
    q.push(1);
    inq[1]=true;
    while(!q.empty())
    {
        int u(q.front());q.pop();
        inq[u]=false;
        for(int i=first[u];i!=-1;i=next[i])
        {
            int v(e[i].v),w(e[i].w);
            if(d[v]>d[u]+w)
            {
                d[v]=d[u]+w;
                if(!inq[v])
                {
                    q.push(v);
                    inq[v]=true;
                }
            }
        }
    }
}

int n,m;
int cnt,first[kMaxn],next[kMaxm];Edge e[kMaxm];
int cnt2,first2[kMaxn],next2[kMaxm];Edge e2[kMaxm];
long long d[kMaxn],d2[kMaxn];

int main()
{
    int T;
    scanf("%d",&T);
    while(T--)
    {
        cnt=cnt2=0;
        memset(first,-1,sizeof(first));
        memset(first2,-1,sizeof(first2));

        scanf("%d%d",&n,&m);
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);

            cnt++;
            e[cnt].v=v;e[cnt].w=w;
            next[cnt]=first[u];
            first[u]=cnt;

            cnt2++;
            e2[cnt2].v=u;e2[cnt2].w=w;
            next2[cnt2]=first2[v];
            first2[v]=cnt2;
        }

        SPFA(n,first,next,e,d);
        SPFA(n,first2,next2,e2,d2);

        long long ans(0);
        for(int i=1;i<=n;i++)
            ans+=d[i]+d2[i];

        cout<<ans<<endl;
    }

    return 0;
}

lee1r 2011-07-31 09:34 发表评论

POJ 1135 Domino Effect

lee1r — Sun, 31 Jul 2011 01:32:00 GMT

最终的骨牌要么是关键点，要么是两个关键点中间的两个点。先求最短路，然后求出每条边上的骨牌完全倒下的时间。
以下是我的代码：

#include<algorithm>
#include<cstdio>
using namespace std;
const int kMaxn(507);
const int kInf(0x7f7f7f7f);

int n,m,g[kMaxn][kMaxn];
int d[kMaxn];

void Dijkstra()
{
    bool visited[kMaxn]={false};
    for(int i=1;i<=n;i++)
        d[i]=(i==1?0:kInf);
    for(int i=1;i<=n;i++)
    {
        int p(-1);
        for(int j=1;j<=n;j++)
            if(!visited[j] && (p<0 || d[p]>d[j]))
                p=j;
        visited[p]=true;
        for(int j=1;j<=n;j++)
            if(!visited[j] && g[p][j]<kInf && d[j]>d[p]+g[p][j])
                d[j]=d[p]+g[p][j];
    }
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    int T(0);
    while(scanf("%d%d",&n,&m)==2 && (n || m))
    {
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                g[i][j]=(i==j?0:kInf);
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            g[u][v]=g[v][u]=w;
        }

        Dijkstra();

        int ans1(-kInf),key(1);
        for(int i=1;i<=n;i++)
            if(ans1<d[i])
            {
                ans1=d[i];
                key=i;
            }

        double ans2(-kInf);
        int start,end;
        for(int i=1;i<=n;i++)
            for(int j=1;j<=n;j++)
                if(g[i][j]<kInf && ans2<(d[i]+d[j]+g[i][j])/2.0)
                {
                    ans2=(d[i]+d[j]+g[i][j])/2.0;
                    start=i;
                    end=j;
                }

        T++;
        printf("System #%d\n",T);
        if(ans1>=ans2)
            printf("The last domino falls after %.1f seconds, at key domino %d.\n\n",(double)ans1,key);
        else
            printf("The last domino falls after %.1f seconds, between key dominoes %d and %d.\n\n",ans2,start,end);
    }

    return 0;
}

lee1r 2011-07-31 09:32 发表评论

HDU 2544 最短路

lee1r — Sun, 31 Jul 2011 01:26:00 GMT

直接求最短路即可。
昨天学到一种SPFA的优化，是用双端队列实现的。

lee1r 2011-07-31 09:26 发表评论

HDU 1269 迷宫城堡

lee1r — Thu, 02 Jun 2011 07:25:00 GMT

判断一个有向图是否强连通。
以下是我的代码：

#include<list>
#include<stack>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(10007);

int n,m,n2,id[kMaxn];
list<int> g[kMaxn];
int dfscnt,dfsn[kMaxn],low[kMaxn];
stack<int> s;

void dfs(int u)
{
    dfsn[u]=low[u]=++dfscnt;
    s.push(u);
    for(list<int>::iterator i=g[u].begin();i!=g[u].end();i++)
    {
        int v(*i);
        if(!dfsn[v])
        {
            dfs(v);
            low[u]=min(low[u],low[v]);
        }
        else
            low[u]=min(low[u],dfsn[v]);
    }
    if(dfsn[u]==low[u])
    {
        n2++;
        int v;
        do
        {
            v=s.top();s.pop();
            id[v]=n2;
        }while(v!=u);
    }
}

void Tarjan()
{
    n2=dfscnt=0;
    memset(dfsn,0,kMaxn*sizeof(int));
    for(int i=1;i<=n;i++)
        if(!dfsn[i])
            dfs(i);
}

int main()
{
    /*
    freopen("data.in","r",stdin);
    freopen("data.out","w",stdout);
    //*/

    while(scanf("%d%d",&n,&m)==2 && (n || m))
    {
        for(int i=1;i<=n;i++)
            g[i].clear();
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf("%d%d",&u,&v);
            g[u].push_back(v);
        }

        Tarjan();

        if(n2==1)
            printf("Yes\n");
        else
            printf("No\n");
    }

    return 0;
}

lee1r 2011-06-02 15:25 发表评论

POJ 1966 Cable TV Network

lee1r — Wed, 01 Jun 2011 14:33:00 GMT

求无向图的连通度。
以下是我的代码：

#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(107);
const int kInf(0x7f7f7);

int n,m;
bool g[kMaxn][kMaxn];
int source,sink,maxflow,cap[kMaxn][kMaxn],flow[kMaxn][kMaxn];

void SAP()
{
    int d[kMaxn],num[kMaxn],p[kMaxn];

    memset(flow,0,kMaxn*kMaxn*sizeof(int));
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(num,0,kMaxn*sizeof(int));
    queue<int> q;
    d[sink]=0;
    num[0]++;
    q.push(sink);
    while(!q.empty())
    {
        int v(q.front());q.pop();
        for(int u=1;u<=n;u++)
            if(d[u]>=n && cap[u][v]>0)
            {
                d[u]=d[v]+1;
                num[d[u]]++;
                q.push(u);
            }
    }
    maxflow=0;
    int u(source),v;
    while(d[source]<n)
    {
        v=-1;
        for(int i=1;i<=n;i++)
            if(cap[u][i]>flow[u][i] && d[u]==d[i]+1)
            {
                v=i;break;
            }
        if(v!=-1)
        {
            p[v]=u;u=v;
            if(u==sink)
            {
                int add(kInf);
                for(u=sink;u!=source;u=p[u])
                    add=min(add,cap[p[u]][u]-flow[p[u]][u]);
                maxflow+=add;
                for(u=sink;u!=source;u=p[u])
                {
                    flow[p[u]][u]+=add;
                    flow[u][p[u]]-=add;
                }
            }
        }
        else
        {
            num[d[u]]--;
            if(!num[d[u]])
                return;
            d[u]=n;
            for(v=1;v<=n;v++)
                if(cap[u][v]>flow[u][v])
                    d[u]=min(d[u],d[v]+1);
            num[d[u]]++;
            if(u!=source)
                u=p[u];
        }
    }
}

int VertexConnectivityDegree()
{
    int re(kInf);
    memset(cap,0,kMaxn*kMaxn*sizeof(int));
    for(int i=1;i<=n;i++)
        cap[i][i+n]=1;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(g[i][j])
                cap[i+n][j]=kInf;
    for(int i=1;i<=n;i++)
        for(int j=1;j<=n;j++)
            if(i!=j && !g[i][j])
            {
                source=i+n;
                sink=j;
                n<<=1;
                SAP();
                n>>=1;
                re=min(re,maxflow);
            }
    if(re>=kInf)
        re=n-1;
    return re;
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        memset(g,false,kMaxn*kMaxn*sizeof(bool));
        for(int i=1;i<=m;i++)
        {
            int u,v;
            scanf(" (%d,%d)",&u,&v);
            u++;v++;
            g[u][v]=g[v][u]=true;
        }

        int ans(VertexConnectivityDegree());
        if(ans>=n-1)
            printf("%d\n",n);
        else
            printf("%d\n",ans);
    }

    return 0;
}

lee1r 2011-06-01 22:33 发表评论

POJ 1523 SPF

lee1r — Wed, 01 Jun 2011 05:37:00 GMT

求无向连通图的割点，使用Tarjan算法。
以下是我的代码：

#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(1007);

int n,m;
bool g[kMaxn][kMaxn];

int root,root_son,cnt,dfsn[kMaxn],low[kMaxn],subnet[kMaxn];
bool used[kMaxn];

void dfs(int u)
{
    cnt++;
    dfsn[u]=low[u]=cnt;
    used[u]=true;

    for(int v=1;v<=n;v++)
    {
        if(g[u][v])
        {
            if(!used[v])
            {
                dfs(v);
                low[u]=min(low[u],low[v]);
                if(low[v]>=dfsn[u])
                {
                    if(u!=root)
                        subnet[u]++;
                    else
                        root_son++;
                }
            }
            else
                low[u]=min(low[u],dfsn[v]);
        }
    }
}

void Tarjan()
{
    root=n;

    cnt=1;
    root_son=0;
    memset(used,false,kMaxn*sizeof(bool));
    for(int i=1;i<=n;i++)
        subnet[i]=1;

    dfs(root);

    if(root_son>1)
        subnet[root]=root_son;
}

int main()
{

    int T(0),u,v;
    while(true)
    {
        n=0;
        memset(g,false,kMaxn*kMaxn*sizeof(bool));
        bool test(false);
        while(scanf("%d",&u)==1)
        {
            if(u)
            {
                test=true;
                scanf("%d",&v);
                g[u][v]=g[v][u]=true;
                n=max(n,max(u,v));
            }
            else
                break;
        }

        if(!test)
            break;

        T++;
        if(T!=1)
            printf("\n");
        printf("Network #%d\n",T);

        Tarjan();

        bool found(false);
        for(int i=1;i<=n;i++)
            if(subnet[i]>1)
            {
                found=true;
                printf("  SPF node %d leaves %d subnets\n",i,subnet[i]);
            }
        if(!found)
            printf("  No SPF nodes\n");
    }

    return 0;
}

lee1r 2011-06-01 13:37 发表评论

POJ 2112 Optimal Milking

lee1r — Tue, 31 May 2011 14:17:00 GMT

第一次1Y网络流构图的题目。
题目要求最大路径最小，那么不妨让每个奶牛都按照最短路径到达（走了最大路径的奶牛一定是按照最短路到达），这样就可以把一条路径看成从挤奶器到奶牛的一条边，边权为最短路长度。
最大路径不知道是多少，可以使用二分，因为最大路径越大，图中有效的边越多。就是要找到一个最小的最大路径，使得建立的网络流的最大流依然为奶牛总数。
以下是我的代码：

#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(237);
const int kInf(0x7f7f7f7f);

int k,c,m,maxdist,dist[kMaxn][kMaxn];
int n,source,sink,maxflow,cap[kMaxn][kMaxn],flow[kMaxn][kMaxn];

void Floyed()
{
    for(int t=1;t<=k+c;t++)
        for(int i=1;i<=k+c;i++)
            for(int j=1;j<=k+c;j++)
                if(dist[i][t]<kInf && dist[t][j]<kInf && dist[i][j]>dist[i][t]+dist[t][j])
                    dist[i][j]=dist[i][t]+dist[t][j];
}

void SAP()
{
    int d[kMaxn],num[kMaxn],p[kMaxn];

    memset(flow,0,kMaxn*kMaxn*sizeof(int));
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(num,0,kMaxn*sizeof(int));
    queue<int> q;
    d[sink]=0;
    num[0]++;
    q.push(sink);
    while(!q.empty())
    {
        int v(q.front());q.pop();
        for(int u=1;u<=n;u++)
            if(d[u]>=n && cap[u][v]>0)
            {
                d[u]=d[v]+1;
                num[d[u]]++;
                q.push(u);
            }
    }

    maxflow=0;
    int u(source),v;
    while(d[source]<n)
    {
        v=-1;
        for(int i=1;i<=n;i++)
            if(cap[u][i]>flow[u][i] && d[u]==d[i]+1)
            {
                v=i;break;
            }
        if(v!=-1)
        {
            p[v]=u;u=v;
            if(u==sink)
            {
                int add(kInf);
                for(u=sink;u!=source;u=p[u])
                    add=min(add,cap[p[u]][u]-flow[p[u]][u]);
                maxflow+=add;
                for(u=sink;u!=source;u=p[u])
                {
                    flow[p[u]][u]+=add;
                    flow[u][p[u]]-=add;
                }
            }
        }
        else
        {
            num[d[u]]--;
            if(!num[d[u]])
                return;
            d[u]=n;
            for(v=1;v<=n;v++)
                if(cap[u][v]>flow[u][v])
                    d[u]=min(d[u],d[v]+1);
            num[d[u]]++;
            if(u!=source)
                u=p[u];
        }
    }
}

int binary(int l,int r)
{
    while(l<r)
    {
        int mid((l+r)>>1);

        source=k+c+1;
        sink=k+c+2;
        n=k+c+2;
        memset(cap,0,kMaxn*kMaxn*sizeof(int));
        for(int i=1;i<=k;i++)
            cap[source][i]=m;
        for(int i=k+1;i<=k+c;i++)
            cap[i][sink]++;
        for(int i=1;i<=k;i++)
            for(int j=k+1;j<=k+c;j++)
                cap[i][j]=(dist[i][j]<=mid);

        SAP();

        if(maxflow<c)
            l=mid+1;
        else
            r=mid;
    }
    return l;
}

int main()
{
    memset(dist,0x7f,kMaxn*kMaxn*sizeof(int));
    scanf("%d%d%d",&k,&c,&m);
    for(int i=1;i<=k+c;i++)
        for(int j=1;j<=k+c;j++)
        {
            int t;
            scanf("%d",&t);
            if(t==0)
                t=kInf;
            dist[i][j]=t;
        }

    Floyed();
    maxdist=0;
    for(int i=1;i<=k+c;i++)
        for(int j=1;j<=k+c;j++)
            if(dist[i][j]<kInf && maxdist<dist[i][j])
                maxdist=dist[i][j];

    printf("%d\n",binary(1,maxdist+1));

    return 0;
}

lee1r 2011-05-31 22:17 发表评论

POJ 1149 PIGS

lee1r — Tue, 31 May 2011 12:35:00 GMT

网络流最大流问题。将顾客看做结点，另外增加一个源点和汇点，构图方式如下：源点和每个猪圈的第一个顾客连边，权值为初始时猪圈中猪的数目；每个顾客和汇点连一条边，权值为希望购买的猪的数目；如果顾客j紧跟着顾客i打开某个猪圈，那么结点i和结点j之间连一条边，权值为kInf。
以下是我的代码：

#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(107);
const int kMaxpig(1007);
const int kInf(0x7f7f7f7f);

int pig,custom,r[kMaxpig],last[kMaxpig];
int n,source,sink,maxflow,cap[kMaxn][kMaxn],flow[kMaxn][kMaxn];

void SAP()
{
    int d[kMaxn],num[kMaxn],p[kMaxn];

    memset(flow,0,kMaxn*kMaxn*sizeof(int));
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(num,0,kMaxn*sizeof(int));
    queue<int> q;
    d[sink]=0;
    num[0]++;
    q.push(sink);
    while(!q.empty())
    {
        int v(q.front());q.pop();
        for(int u=1;u<=n;u++)
            if(d[u]>=n && cap[u][v]>flow[u][v])
            {
                d[u]=d[v]+1;
                num[d[u]]++;
                q.push(u);
            }
    }

    maxflow=0;
    int u(source),v;
    while(d[source]<n)
    {
        v=-1;
        for(int i=1;i<=n;i++)
            if(cap[u][i]>flow[u][i] && d[u]==d[i]+1)
            {
                v=i;break;
            }
        if(v!=-1)
        {
            p[v]=u;u=v;
            if(u==sink)
            {
                int add(kInf);
                for(u=sink;u!=source;u=p[u])
                    add=min(add,cap[p[u]][u]-flow[p[u]][u]);
                maxflow+=add;
                for(u=sink;u!=source;u=p[u])
                {
                    flow[p[u]][u]+=add;
                    flow[u][p[u]]-=add;
                }
            }
        }
        else
        {
            num[d[u]]--;
            if(!num[d[u]])
                return;
            d[u]=n;
            for(v=1;v<=n;v++)
                if(cap[u][v]>flow[u][v])
                    d[u]=min(d[u],d[v]+1);
            num[d[u]]++;
            if(u!=source)
                u=p[u];
        }
    }
}

int main()
{
    scanf("%d%d",&pig,&custom);
    source=custom+1;
    sink=custom+2;
    n=custom+2;
    memset(cap,0,kMaxn*kMaxn*sizeof(int));
    for(int i=1;i<=pig;i++)
        scanf("%d",&r[i]);
    memset(last,0,kMaxpig*sizeof(int));
    for(int i=1;i<=custom;i++)
    {
        int a,b;
        scanf("%d",&a);
        for(int j=1;j<=a;j++)
        {
            int t;
            scanf("%d",&t);
            if(last[t]==0)
            {
                last[t]=i;
                cap[source][i]+=r[t];
            }
            else
            {
                cap[last[t]][i]=kInf;
                last[t]=i;
            }
        }
        scanf("%d",&b);
        cap[i][sink]+=b;
    }

    SAP();

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

    return 0;
}

lee1r 2011-05-31 20:35 发表评论

POJ 1087 A Plug for UNIX

lee1r — Tue, 31 May 2011 11:47:00 GMT

这是本人AC的第一道网络流建模的题目哇～内牛满面！！！做了两天才AC……
网络流题目重在构图。
以下是我的代码：

#include<iostream>
#include<string>
#include<queue>
#include<map>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(507);
const int kInf(77777);

int a,b,c;
map<string,int> r;
int n,source,sink,maxflow,cap[kMaxn][kMaxn],flow[kMaxn][kMaxn];

void SAP()
{
    int d[kMaxn],num[kMaxn],p[kMaxn];

    memset(flow,0,kMaxn*kMaxn*sizeof(int));
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(num,0,kMaxn*sizeof(int));
    queue<int> q;
    d[sink]=0;
    num[0]++;
    q.push(sink);
    while(!q.empty())
    {
        int v(q.front());q.pop();
        for(int u=1;u<=n;u++)
            if(d[u]>=n && cap[u][v]>flow[u][v])
            {
                d[u]=d[v]+1;
                num[d[u]]++;
                q.push(u);
            }
    }

    maxflow=0;
    int u(source),v;
    while(d[source]<n)
    {
        v=-1;
        for(int i=1;i<=n;i++)
            if(cap[u][i]>flow[u][i] && d[u]==d[i]+1)
            {v=i;break;}
        if(v!=-1)
        {
            p[v]=u;u=v;
            if(u==sink)
            {
                int add(kInf);
                for(u=sink;u!=source;u=p[u])
                    add=min(add,cap[p[u]][u]-flow[p[u]][u]);
                maxflow+=add;
                for(u=sink;u!=source;u=p[u])
                {
                    flow[p[u]][u]+=add;
                    flow[u][p[u]]-=add;
                }
            }
        }
        else
        {
            num[d[u]]--;
            if(!num[d[u]])
                return;
            d[u]=n;
            for(v=1;v<=n;v++)
                if(cap[u][v]>flow[u][v])
                    d[u]=min(d[u],d[v]+1);
            num[d[u]]++;
            if(u!=source)
                u=p[u];
        }
    }
}

int main()
{
    source=1;
    sink=2;
    n=2;
    memset(cap,0,kMaxn*kMaxn*sizeof(int));

    cin>>a;
    for(int i=1;i<=a;i++)
    {
        string t;
        cin>>t;
        r[t]=(++n);
        cap[n][sink]++;
    }
    cin>>b;
    for(int i=1;i<=b;i++)
    {
        string t1,t2;
        cin>>t1>>t2;
        r[t1]=(++n);
        cap[source][n]++;
        if(!r.count(t2))
            r[t2]=(++n);
        cap[r[t1]][r[t2]]++;
    }
    cin>>c;
    for(int i=1;i<=c;i++)
    {
        string t1,t2;
        cin>>t1>>t2;
        if(!r.count(t1))
            r[t1]=(++n);
        if(!r.count(t2))
            r[t2]=(++n);
        cap[r[t1]][r[t2]]=kInf;
    }

    SAP();

    printf("%d\n",b-maxflow);

    return 0;
}

lee1r 2011-05-31 19:47 发表评论

POJ 1459 Power Network

lee1r — Mon, 30 May 2011 08:21:00 GMT

多源点汇点的网络流最大流问题。
注意题目要求顶点编号从0开始。我是用SAP算法来做的，用时766ms；EdmondsKarp算法用时1610ms。
以下是我的代码：

#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
#include<cctype>
using namespace std;
const int kMaxn(107);
const int kInf(0x7f7f7f7f);

int n,np,nc,m,s,t,c[kMaxn][kMaxn];
int maxflow,f[kMaxn][kMaxn];

void SAP()
{
    int d[kMaxn],num[kMaxn],p[kMaxn];

    memset(f,0,kMaxn*kMaxn*sizeof(int));
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(num,0,kMaxn*sizeof(int));
    queue<int> q;
    d[t]=0;
    num[0]++;
    q.push(t);
    while(!q.empty())
    {
        int v(q.front());q.pop();
        for(int u=0;u<n;u++)
            if(d[u]>=n && c[u][v]>f[u][v])
            {
                d[u]=d[v]+1;
                num[d[u]]++;
                q.push(u);
            }
    }

    maxflow=0;
    int u(s),v;
    while(d[s]<n)
    {
        v=-1;
        for(int i=0;i<n;i++)
            if(c[u][i]>f[u][i] && d[u]==d[i]+1)
            {v=i;break;}
        if(v!=-1)
        {
            p[v]=u;u=v;
            if(u==t)
            {
                int add(kInf);
                for(u=t;u!=s;u=p[u])
                    add=min(add,c[p[u]][u]-f[p[u]][u]);
                maxflow+=add;
                for(u=t;u!=s;u=p[u])
                {
                    f[p[u]][u]+=add;
                    f[u][p[u]]-=add;
                }
            }
        }
        else
        {
            num[d[u]]--;
            if(!num[d[u]])
                return;
            d[u]=n;
            for(v=0;v<n;v++)
                if(c[u][v]>f[u][v])
                    d[u]=min(d[u],d[v]+1);
            num[d[u]]++;
            if(u!=s)
                u=p[u];
        }
    }
}

int main()
{
    while(scanf("%d%d%d%d",&n,&np,&nc,&m)==4)
    {
        s=n;
        t=n+1;
        n+=2;
        memset(c,0,kMaxn*kMaxn*sizeof(int));
        for(int i=1;i<=m;i++)
        {
            string in;
            cin>>in;
            for(int j=0;j<in.size();j++)
                if(!isdigit(in[j]))
                    in[j]=' ';
            istringstream sin(in);
            int u,v,w;
            sin>>u>>v>>w;
            c[u][v]+=w;
        }
        for(int i=1;i<=np;i++)
        {
            string in;
            cin>>in;
            for(int j=0;j<in.size();j++)
                if(!isdigit(in[j]))
                    in[j]=' ';
            istringstream sin(in);
            int u,v;
            sin>>u>>v;
            c[s][u]+=v;
        }
        for(int i=1;i<=nc;i++)
        {
            string in;
            cin>>in;
            for(int j=0;j<in.size();j++)
                if(!isdigit(in[j]))
                    in[j]=' ';
            istringstream sin(in);
            int u,v;
            sin>>u>>v;
            c[u][t]+=v;
        }

        SAP();

        printf("%d\n",maxflow);
    }

    return 0;
}

lee1r 2011-05-30 16:21 发表评论

POJ 3255 Roadblocks

lee1r — Sat, 28 May 2011 14:45:00 GMT

题目大意：给出n个顶点和m条边，求出顶点1到顶点n的次短路。次短路径允许一条边走多次。
很早就知道这个问题了，也很早就知道算法了，可是一直不知道为什么这么做是正确的，今天听了cw牛的讲解豁然开朗。
假设该问题要求的次短路经过边，注意是有向边，那么d[1][u]+w(u,v)+d[v][n]就是经过这条边的最短路，如果这个值大于最短路的话，它就有可能成为次短路。因此，枚举次短路经过的边即可。
以下是我的代码：

#include<list>
#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
using namespace std;
const int kMaxn(5007);

struct Type
{
    Type(int value1,int value2):v(value1),w(value2) {}
    int v,w;
};

int n,m,ans,d1[kMaxn],dn[kMaxn];
list<Type> g[kMaxn];

void spfa(int s,int *d)
{
    queue<int> q;
    bool inq[kMaxn];
    memset(d,0x7f,kMaxn*sizeof(int));
    memset(inq,false,kMaxn*sizeof(bool));
    d[s]=0;
    q.push(s);
    inq[s]=true;
    while(!q.empty())
    {
        int u(q.front());q.pop();inq[u]=false;
        for(list<Type>::iterator i=g[u].begin();i!=g[u].end();i++)
            if(d[i->v]>d[u]+i->w)
            {
                d[i->v]=d[u]+i->w;
                if(!inq[i->v])
                {
                    q.push(i->v);
                    inq[i->v]=true;
                }
            }
    }
}

int main()
{
    while(scanf("%d%d",&n,&m)==2)
    {
        for(int i=1;i<=n;i++)
            g[i].clear();
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            g[u].push_back(Type(v,w));
            g[v].push_back(Type(u,w));
        }

        spfa(1,d1);
        spfa(n,dn);

        ans=0x7f7f7f7f;
        for(int i=1;i<=n;i++)
            for(list<Type>::iterator j=g[i].begin();j!=g[i].end();j++)
                if(d1[i]+j->w+dn[j->v]>d1[n])
                    ans=min(ans,d1[i]+j->w+dn[j->v]);

        printf("%d\n",ans);
    }

    return 0;
}

lee1r 2011-05-28 22:45 发表评论

POJ 1273 Drainage Ditches

lee1r — Sat, 28 May 2011 08:55:00 GMT

求网络流的最大流。
注意：可能出现重边！比如第一次c[u][v]=w1，又有c[u][v]=w2，那么从u到v的容量应该为w1+w2！
以下是我的代码：

#include<queue>
#include<algorithm>
#include<cstdio>
#include<cstring>
#define kS 1
#define kT n
using namespace std;
const int kMaxn(207);

int n,m,maxflow,c[kMaxn][kMaxn],f[kMaxn][kMaxn];

int main()
{
    while(scanf("%d%d",&m,&n)==2)
    {
        memset(c,0,kMaxn*kMaxn*sizeof(int));
        memset(f,0,kMaxn*kMaxn*sizeof(int));
        for(int i=1;i<=m;i++)
        {
            int u,v,w;
            scanf("%d%d%d",&u,&v,&w);
            c[u][v]+=w;
        }

        maxflow=0;
        while(true)
        {
            int d[kMaxn],p[kMaxn];
            queue<int> q;
            memset(d,0,kMaxn*sizeof(int));
            d[kS]=0x7f7f7f7f;
            q.push(kS);
            while(!q.empty())
            {
                int u(q.front());q.pop();
                for(int v=1;v<=n;v++)
                    if(!d[v] && c[u][v]>f[u][v])
                    {
                        p[v]=u;q.push(v);
                        d[v]=min(d[u],c[u][v]-f[u][v]);
                    }
            }
            if(d[kT]==0)
                break;
            maxflow+=d[kT];
            for(int u=kT;u!=kS;u=p[u])
            {
                f[p[u]][u]+=d[kT];
                f[u][p[u]]-=d[kT];
            }
        }

        printf("%d\n",maxflow);
    }

    return 0;
}

lee1r 2011-05-28 16:55 发表评论