POJ 3268 Silver Cow Party (Dijkstra)

Silver Cow Party

Time Limit: 2000MS		Memory Limit: 65536K
Total Submissions: 13982		Accepted: 6307

Description

One cow from each of N farms (1 ≤ N ≤ 1000) conveniently numbered 1..N is going to attend the big cow party to be held at farm #X (1 ≤ X ≤ N). A total of M (1 ≤ M ≤ 100,000) unidirectional (one-way roads connects pairs of farms; road i requires T_i (1 ≤ T_i ≤ 100) units of time to traverse.

Each cow must walk to the party and, when the party is over, return to her farm. Each cow is lazy and thus picks an optimal route with the shortest time. A cow's return route might be different from her original route to the party since roads are one-way.

Of all the cows, what is the longest amount of time a cow must spend walking to the party and back?

Input

Line 1: Three space-separated integers, respectively: N, M, and X 
Lines 2..M+1: Line i+1 describes road i with three space-separated integers: A_i, B_i, and T_i. The described road runs from farm A_i to farm B_i, requiring T_i time units to traverse.

Output

Line 1: One integer: the maximum of time any one cow must walk.

Sample Input

4 8 2
1 2 4
1 3 2
1 4 7
2 1 1
2 3 5
3 1 2
3 4 4
4 2 3

Sample Output

10

因为迪杰斯特拉求得是一点到其他所有点的最短路径，所以先把起点设成X,跑一次之后算出了每头牛回去的最短路径，然后把边反转，入边变成出边，出边变成入边，然后再把起点设成X，跑一次之后就算出了每头牛来的最短路径，最后把每头牛来回的最短路径加起来，取所有牛的最大值。写得太挫，明天补发其他解法。

#include <iostream>
#include <cstdio>
#include <queue>
#include <vector>
using    namespace    std;

const    int    SIZE = ;
const    int    INF = 0x6fffffff;
int    MAP[SIZE][SIZE];
bool    VIS[SIZE][SIZE];
int    BOX[SIZE];
int    D[SIZE],S[SIZE];
int    N,M,X;
struct    Comp
{
    bool    operator ()(int & a,int & b)
    {
        return    D[a] > D[b];
    }
};
struct    Node
{
    int    vec,cost;
};
vector<Node>    G[SIZE];

void    dijkstra(int);
int    main(void)
{
    Node    temp;
    int    from;

    while(scanf("%d%d%d",&N,&M,&X) != EOF)
    {
        fill(&MAP[][],&MAP[SIZE - ][SIZE - ],INF);
        fill(&VIS[][],&VIS[SIZE - ][SIZE - ],false);
        fill(BOX,BOX + SIZE - ,);
        for(int i = ;i <= N;i ++)
            G[i].clear();
        for(int i = ;i < M;i ++)
        {
            scanf("%d%d%d",&from,&temp.vec,&temp.cost);
            G[from].push_back(temp);
            MAP[from][temp.vec] = temp.cost;
        }
        dijkstra(X);
        for(int i = ;i <= N;i ++)
            BOX[i] = D[i];

        for(int i = ;i <= N;i ++)
            G[i].clear();
        for(int i = ;i <= N;i ++)
            for(int j = ;j <= N;j ++)
            {
                temp.vec = j;
                temp.cost = MAP[j][i];
                G[i].push_back(temp);
            }
        dijkstra(X);
        int    ans = -;
        for(int i = ;i <= N;i ++)
        {
            BOX[i] += D[i];
            ans = ans > BOX[i] ? ans : BOX[i];
        }
        printf("%d\n",ans);
    }

    return    ;
}

void    dijkstra(int s)
{
    fill(D,D + SIZE,INF);
    fill(S,S + SIZE,false);
    priority_queue<int,vector<int>,Comp>    que;
    D[s] = ;
    que.push(s);

    while(!que.empty())
    {
        int    cur = que.top();
        que.pop();
        S[cur] = true;

        for(int i = ;i < G[cur].size();i ++)
            if(!S[G[cur][i].vec] && D[G[cur][i].vec] > D[cur] + G[cur][i].cost)
            {
                D[G[cur][i].vec] = D[cur] + G[cur][i].cost;
                que.push(G[cur][i].vec);
            }
    }
}

补发贝尔曼和SPFA

 #include <iostream>
 #include <cstdio>
 #include <queue>
 #include <vector>
 using    namespace    std;

 const    int    INF = 0x6fffffff;
 const    int    SIZE = ;
 int    N,M,X;
 int    MAP[SIZE][SIZE],D[SIZE],BOX[SIZE];
 bool    VIS[SIZE];
 struct    Node
 {
     int    vec,cost;
 };
 vector<Node>    G[SIZE];

 void    SPFA(int);
 bool    relax(int,int,int);
 int    main(void)
 {
     int    from,to,cost,ans;
     Node    temp;

     while(scanf("%d%d%d",&N,&M,&X) != EOF)
     {
         fill(BOX,BOX + SIZE,);
         fill(&MAP[][],&MAP[SIZE - ][SIZE - ],INF);

         for(int i = ;i < M;i ++)
         {
             scanf("%d%d%d",&from,&to,&cost);
             MAP[from][to] = cost;
             temp.vec = to;
             temp.cost = cost;
             G[from].push_back(temp);
         }
         SPFA(X);
         for(int i = ;i <= N;i ++)
             BOX[i] += D[i];
         for(int i = ;i <= N;i ++)
         {
             G[i].clear();
             for(int j = ;j <= N;j ++)
             {
                 if(MAP[j][i] == INF)
                     continue;
                 temp.vec = j;
                 temp.cost = MAP[j][i];
                 G[i].push_back(temp);
             }
         }
         SPFA(X);
         ans = -;
         for(int i = ;i <= N;i ++)
         {
             BOX[i] += D[i];
             ans = ans > BOX[i] ? ans : BOX[i];
         }
         printf("%d\n",ans);
     }

     return    ;
 }

 void    SPFA(int s)
 {
     fill(D,D + SIZE,INF);
     fill(VIS,VIS + SIZE,false);
     D[s] = ;
     queue<int>    que;
     que.push(s);
     VIS[s] = true;

     while(!que.empty())
     {
         int    cur = que.front();
         que.pop();
         VIS[cur] = false;

         for(int i = ;i < G[cur].size();i ++)
         {
             if(relax(cur,G[cur][i].vec,G[cur][i].cost))
             {
                 que.push(G[cur][i].vec);
                 VIS[G[cur][i].vec] = true;
             }
         }
     }
 }

 bool    relax(int from,int to,int cost)
 {
     if(D[to] > D[from] + cost)
     {
         D[to] = D[from] + cost;
         return    true;
     }
     return    false;
 }

Bellman_ford

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

const    int    INF = 0x6fffffff;
const    int    SIZE = ;
int    D[SIZE],BOX[SIZE];;
int    N,M,X;
struct    Node
{
    int    from,to,cost;
}G[SIZE * ];

void    Bellman_ford(int);
bool    relax(int,int,int);
int    main(void)
{
    int    ans;

    while(scanf("%d%d%d",&N,&M,&X) != EOF)
    {
        fill(BOX,BOX + SIZE,);
        for(int i = ;i < M;i ++)
            scanf("%d%d%d",&G[i].from,&G[i].to,&G[i].cost);
        Bellman_ford(X);
        for(int i = ;i <= N;i ++)
            BOX[i] += D[i];
        for(int i = ;i < M;i ++)
            swap(G[i].from,G[i].to);
        Bellman_ford(X);
        ans = -;
        for(int i = ;i <= N;i ++)
        {
            BOX[i] += D[i];
            ans = ans > BOX[i] ? ans : BOX[i];
        }
        printf("%d\n",ans);
    }

    return    ;
}

void    Bellman_ford(int x)
{
    fill(D,D + SIZE,INF);
    D[x] = ;

    bool    flag;
    for(int i = ;i < N - ;i ++)
    {
        flag = false;
        for(int j = ;j < M;j ++)
            if(relax(G[j].from,G[j].to,G[j].cost))
                flag = true;
        if(!flag)
            break;
    }
}

bool    relax(int from,int to,int cost)
{
    if(D[to] > D[from] + cost)
    {
        D[to] = D[from] + cost;
        return    true;
    }
    return    false;
}