kuangbin带我飞QAQ 最短路

　

1.　poj 1502 Mathches Game

　　裸最短路

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 110;
const int maxn = 110;

struct edge {
    int to, next, val;
}e[maxn*maxn];


int dis[maxn], linjie[maxn];
bool vis[maxn];
int N, cnt, ans;

void addedge( int x, int y, int val )
{
    e[cnt].to = y; e[cnt].next = linjie[x]; e[cnt].val = val; linjie[x] = cnt++; }

void init()
{
    cnt = ans = 0;
    memset( linjie, -1, sizeof(linjie) );
    memset( dis, 0x3f, sizeof(dis) );
    memset( vis, 0, sizeof(vis) );
}

void read()
{
    init();
    string str;
    int tmp = 1;

    for ( int i = 1; i < N; i++ )
    {
        for ( int j = 0; j < tmp; j++ )
        {
            int val = 0;
            cin >> str;

            if ( str == "x" )
                continue;
            int len = str.length();

            int x = 1;
            for ( int k = len - 1; k >= 0; k-- )
            {
                val += (str[k]-'0')*x;
                x *= 10;
            }
            addedge( i, j, val );
            addedge( j, i, val );
        }
        tmp++;
    }
}

void dijkstra()
{
    dis[0] = 0;
    
    for ( int i = 0; i < N; i++ )
    {
        int mindis = inf, mark = -1;
        for ( int j = 0; j < N; j++ )
            if ( !vis[j] && dis[j] < mindis )
            {
                mark = j;
                mindis = dis[j];
            }

        vis[mark] = true;

        for ( int j = linjie[mark]; j+1; j = e[j].next )
            if (!vis[e[j].to])
            {
                int v = e[j].to, val = e[j].val;
                dis[v] = Min(dis[v], dis[mark]+val);
            }
    }
}

int main()
{
    cin >> N;

    read();
    dijkstra();

    for ( int i = 0; i < N; i++ )
        ans = Max( ans, dis[i] );

    cout << ans << endl;
    return 0;
}

2. poj 3660 cow contest

　　floyd 求传递闭包

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 110;
const int maxn = 110;

bool mmap[maxn][maxn];
int ojbk[maxn];
int N, M;

void floyd()
{
    for ( int k = 1; k <= N; k++ )
        for ( int i = 1; i <= N; i++ )
            for ( int j = 1; j <= N; j++ )
            {
                mmap[i][j] = (mmap[i][j] || (mmap[i][k] && mmap[k][j]));
            }
}

int main()
{
    cin >> N >> M;

    int x, y;
    for ( int i = 1; i <= M; i++ ) 
    {
        scanf("%d %d", &x, &y);
        mmap[x][y] = 1;
    }

    floyd();

    int ans = 0;
    for ( int i = 1; i <= N; i++ )
        for ( int j = 1; j <= N; j++ )
            if ( mmap[i][j] )
            {
                ojbk[i]++;
                ojbk[j]++;
            }

    for ( int i = 1; i <= N; i++ )
        if ( ojbk[i] == N-1 )
            ans++;
    cout << ans << endl;

    return 0;
}

3. poj 1511 Invitation Cards

　　双向最短路，正着求一次，边取反再求一次

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <map>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 110;
const int maxn = 1e6+5;

int num[3*maxn];
int linjie[maxn];
int dis[maxn];
bool vis[maxn];
int P, Q, cnt;
long long ans;

struct edge {
    int to, next, val ;
}e[maxn];

struct cmp {
    bool operator() ( const int a, const int b )
        { return dis[a]>dis[b]; }
};

void addedge( int u, int v, int val )
{ e[cnt].to = v; e[cnt].next = linjie[u]; e[cnt].val = val; linjie[u] = cnt++; }    

void init()
{
    cnt = 0; ans = 0;
    memset( linjie, -1, sizeof(linjie) );
}

void dijkstra()
{
    memset( dis, 0x3f, sizeof(dis) );
    memset( vis, 0, sizeof(vis) );

    priority_queue<int, vector<int>, cmp> q;
    dis[1] = 0;
    q.push(1);

    while (!q.empty())
    {
        int run = q.top(); q.pop();
        int mindis = dis[run];

        vis[run] = true;

        for ( int i = linjie[run]; i+1; i = e[i].next )
            if ( !vis[e[i].to] && dis[e[i].to] >  mindis + e[i].val )
            {
                dis[e[i].to] =  mindis + e[i].val;
                q.push(e[i].to);
            }
    }
    for ( int i = 2; i <= P; i++ )
        ans += (long long)dis[i];
}

int main()
{
    int n;
    cin >> n;

    while (n--)
    {
        init();
        scanf( "%d %d", &P, &Q );

        int j = 1;
        for ( int i = 1; i <= Q; i++ )
        {
            scanf( "%d %d %d", &num[j], &num[j+1], &num[j+2] );
            addedge( num[j], num[j+1], num[j+2] );
            j += 3;
        }
        dijkstra();
        
        //重新建边///
        memset( linjie, -1, sizeof(linjie) );
        cnt = 0; j = 1;
        for ( int i = 1; i <= Q; i++ )
        {
            addedge( num[j+1], num[j], num[j+2] );
            j += 3;
        }

        dijkstra();

        printf( "%lld
", ans );
    }

    return 0;
}

4.poj 3159 Candies

　　dijsktra+优先队列优化+差分约束

#include <iostream>  
#include <string.h>  
#include <stdio.h>  
#include <algorithm>  
#include <queue>  
#include <vector>  
#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 200000 + 5;
const int maxn = 50000 + 5;

int linjie[maxn];
int dis[maxn];
bool vis[maxn];
int P, Q, cnt;

struct qnode
{
    int v;
    int c;
    qnode(int _v=0,int _c=0):v(_v),c(_c){}
    bool operator <(const qnode &r)const
    {
        return c>r.c;
    }
};

struct edge {
    int to, next, val ;
}e[maxk];

void addedge( int u, int v, int val )
{ e[cnt].to = v; e[cnt].next = linjie[u]; e[cnt].val = val; linjie[u] = cnt++; }    

void init()
{
    cnt = 0;
    memset( linjie, -1, sizeof(linjie) );
}

void dijkstra()
{
    memset( dis, 0x3f, sizeof(dis) );
    memset( vis, 0, sizeof(vis) );

    priority_queue<qnode> q;
    while(!q.empty()) q.pop();
    dis[1] = 0;
    q.push(qnode(1,0));

    qnode tmp;

    while (!q.empty())
    {
        tmp = q.top(); q.pop();
        int run = tmp.v;
        int mindis = dis[run];

        vis[run] = true;

        for ( int i = linjie[run]; i+1; i = e[i].next )
            if ( !vis[e[i].to] && dis[e[i].to] >  mindis + e[i].val )
            {
                int v = e[i].to;
                dis[v] =  mindis + e[i].val;
                q.push(qnode(v, dis[v]));
            }
    }
}

int main()
{
    init();
    scanf( "%d%d", &P, &Q );

        
    int x, y, z;
    for ( int i = 1; i <= Q; i++ )
    {
        scanf( "%d%d%d", &x, &y, &z );
        addedge(x,y,z);
    }

    dijkstra();

    printf( "%d
", dis[P] );

    return 0;
}

5. poj 3169 Layout

　　spfa+负环+差分约束

　　最经典的差分约束，因为求的是dis[N]-dis[1]的最大值 ，即dis[N]-dis[1] <= x，所以用最短路。用spfa判断若有负环，说明最短路无限小，所以无解；若dis[N] = inf，说明最短路可以无限大，

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <map>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 2e4+5;
const int maxn = 1010;

int N, Ml, Md, cnt;
int linjie[maxn], in[maxn];
bool vis[maxn];
long long dis[maxn];

struct edge {
    int to, next, val;
}e[maxk];

void addedge( int u, int v, int val )
{
    e[cnt].to = v;
    e[cnt].next = linjie[u];
    e[cnt].val = val;
    linjie[u] = cnt++;
}

void init()
{
    cnt = 0;
    memset( linjie, -1, sizeof(linjie) );
}

long long spfa()
{
    memset( dis, 0x3f, sizeof(dis) );

    queue<int> q;
    q.push(1); dis[1] = 0;

    while ( !q.empty() )
    {
        int run = q.front(); q.pop();
        vis[run] = false;

        for ( int i = linjie[run]; i+1; i = e[i].next )
        {
            int v = e[i].to, cost = e[i].val;
            if ( dis[v] > dis[run] + cost )
            {
                dis[v] = dis[run] + cost;
                if (!vis[v])
                {
                    in[v]++;
                    if ( in[v] > N ) return -1;

                    vis[v] = true; 
                    q.push(v); 
                }
            }
        }
    }

    if ( dis[N] == INF ) return -2;
    else
        return dis[N];
}

int main()
{
    init();
    cin >> N >> Ml >> Md;

    //差分约束条件建边
    int a, b, z;
    for ( int i = 1; i <= Ml; i++ )
        { scanf("%d%d%d", &a, &b, &z); addedge(a,b,z); }
    for ( int i = 1; i <= Md; i++ )
        { scanf("%d%d%d", &a, &b, &z); addedge(b,a,-z); }

    printf( "%lld
", spfa() );
    return 0;
}

6. hdu3416 Marriage Match IV

　　dijkstra+最大流dinic当前弧优化

　　hdu的题好难...这题最不一样的是求一共有多少条最短路（路径不可以重复），一个暴力的想法就是求一条最短路再删去该路的所有边，再求最短路，再删边，直到求得最短路长度大于第一次求得的长度为止，不过用脚趾头想都知道数据肯定会卡你的。

其实会发现如果抛弃最短路来看，这道题很像最大流，就是所有边权为1求最大流的题目，不过现在加了约束条件必须在最短路上取最大流。所以我们可以求出所有的最短路径的边并重新建一个边权为1的图，在其上做最大流就可以了，那么怎么求所有最短路径呢？

有个方法是从终点dijkstra一下再从起点dijkstra下（注意要建立反向边图），假设dis1[u]表示start-u之间最短距离，dis2[v]表示v-end之间最短距离，那么只要dis1[u]+dis2[v]+dis[u][v] == 最短路长度，就代表这条边是可以要的

#include <iostream>
#include <string.h>
#include <cstdio>
#include <queue>
#include <map>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#include <math.h>

#define SIGMA_SIZE 26
#pragma warning ( disable : 4996 )

using namespace std;
typedef long long LL;

inline LL LMax(LL a,LL b)    { return a>b?a:b; }
inline LL LMin(LL a,LL b)    { return a>b?b:a; }
inline int Max(int a,int b) { return a>b?a:b; }
inline int Min(int a,int b) { return a>b?b:a; }
inline int gcd( int a, int b ) { return b==0?a:gcd(b,a%b); }
inline int lcm( int a, int b ) { return a/gcd(a,b)*b; }  //a*b = gcd*lcm
const long long INF = 0x3f3f3f3f3f3f3f3f;
const int inf  = 0x3f3f3f3f;
const int mod  = 7;
const int maxk = 1e5+5;
const int maxn = 1010;

int N, M, cnt;
int st, ed;
int num[maxk*3];
int disst[maxn], dised[maxn], cur[maxn];
int linjie1[maxn], linjie2[maxn];
bool vis[maxn];

struct node {
    int to, next, val;
}e1[maxk], e2[maxk];

void addedge1( int u, int v, int val )
{ e1[cnt].to = v; e1[cnt].val = val; e1[cnt].next = linjie1[u]; linjie1[u] = cnt++; }
void addedge2( int u, int v, int val )
{ e2[cnt].to = v; e2[cnt].val = val; e2[cnt].next = linjie2[u]; linjie2[u] = cnt++; }

void init()
{
    cnt = 0;
    memset( linjie1, -1, sizeof(linjie1) );
    memset( linjie2, -1, sizeof(linjie2) );
}

void dijkstra( int x )
{
    memset( vis, 0, sizeof(vis) );
    memset( disst, 0x3f, sizeof(disst) );
    disst[x] = 0;

    for ( int k = 1; k <= N; k++ )
    {
        int mark = -1, mindis = inf;
        for ( int i = 1; i <= N; i++ )
            if ( !vis[i] && disst[i] < mindis )
            {
                mark = i;
                mindis = disst[i];
            }
        vis[mark] = true;

        for ( int i = linjie1[mark]; i+1; i = e1[i].next )
        {
            int v = e1[i].to, cost = e1[i].val;
            if ( !vis[v] && disst[v] > disst[mark] + cost )
                disst[v] = disst[mark] + cost;
        }
    }
}

void make_map()
{
    cnt = 0;
    int mindist = disst[ed];

    for ( int i = 1; i <= N; i++ )
        for ( int j = linjie1[i]; j + 1; j = e1[j].next )
        {
            int v = e1[j].to, cost = e1[j].val;
            if ( disst[i] + cost + dised[v] == mindist )
                addedge2( i, v, 1 );
        }
}

int bfs()
{
    memset( disst, -1, sizeof(disst) );
    queue<int> q;

    q.push(st);
    disst[st] = 0;

    while( !q.empty() )
    {
        int run = q.front(); q.pop();
        for( int i = linjie2[run]; i+1; i = e2[i].next )
        {
            int v = e2[i].to, flow = e2[i].val;
            if( disst[v] < 0 && flow > 0 )
            {
                disst[v] = disst[run] + 1;
                q.push(v);
            }
        }
    }

    if( disst[ed] > 0 )
        return 1;
    else
        return 0;
}

int find( int s, int low )
{
    int ff = 0;
    if( s == ed )
        return low;
    for( int& i = cur[s]; i+1; i = e2[i].next )    //注意int& i = cur[s] 当前弧优化
    {
        int v = e2[i].to, cap = e2[i].val;
        if( cap > 0
            && disst[v] == disst[s] + 1
            && (ff = find(v,Min(cap,low))) )
        {
            e2[i].val -= ff;
            //e2[i^1].val += ff;
            return ff;
        }
    }
    return 0;
}

int dinic()
{
    int ans = 0;
    int tans;
    while( bfs() )
    {
        for( int i = 1; i <= N; i++ )   //当前弧优化
            cur[i] = linjie2[i];
        while( tans = find( st, inf ) )
            ans += tans;
    }
    return ans;
}


int main()
{
    int T; cin >> T;
    while (T--)
    {
        scanf("%d%d", &N, &M);
        
        init();
        for (int i = 1, j = 1; i <= M; i++)
        {
            scanf( "%d%d%d", &num[j], &num[j+1], &num[j+2] );
            addedge1(num[j+1],num[j],num[j+2]);
            j += 3;
        }

        scanf("%d%d", &st, &ed);

        dijkstra(ed);
        for ( int i = 1; i <= N; i++ )
            dised[i] = disst[i];
        cnt = 0;
        memset( linjie1, -1, sizeof(linjie1) );
        for ( int i = 1, j = 1; i <= M; i++ )
        {
            addedge1( num[j], num[j+1], num[j+2] );
            j += 3;
        }
        dijkstra(st);
        make_map();

        printf( "%d
", dinic() );
    }
    return 0;
}