poj3268 Silver Cow Party（两次SPFA || 两次Dijkstra）

题目链接

http://poj.org/problem?id=3268

题意

有向图中有n个结点，编号1~n，输入终点编号x，求其他结点到x结点来回最短路长度的最大值。

思路

最短路问题，有1000个结点，Floyd算法应该会超时，我刚开始使用的Dijkstra算法也超时，原因是因为我使用一个循环遍历结点1~n，每次遍历我都使用两次Dijkstra求i到x和x到i的最短路，时间复杂度太高。降低时间复杂度的方法是先在原矩阵的基础上使用dijkstra求结点x到其余各点的最短路径，然后将矩阵转置，在转置矩阵的基础上使用dijkstra求结点x到其余各点的最短路径，这就相当于在原矩阵上求其余各点到x的最短路径，将两次得到的最短路径的值相加取最大值即可。这题也可以使用SPFA算法解决。

代码

SPFA算法：

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

struct Edge
{
    int s, e, dist;

    Edge() {}
    Edge(int s, int e, int d) :s(s), e(e), dist(d) {}
};

const int INF = 0x3f3f3f;
const int N = 1000 + 10;
vector<Edge> v[N];
int dist[N];
int visit[N];
int n, m, x;

int spfa(int s, int e)    //返回从结点s到结点e的最短路
{
    queue<int> q;
    memset(visit, 0, sizeof(visit));
    memset(dist, INF, sizeof(dist));
    q.push(s);
    visit[s] = 1;
    dist[s] = 0;

    while (!q.empty())
    {
        int s = q.front();
        q.pop();
        visit[s] = 0;
        for (int i = 0; i < v[s].size(); i++)
        {
            int e = v[s][i].e;
            if (dist[e] > dist[s] + v[s][i].dist)
            {
                dist[e] = dist[s] + v[s][i].dist;
                if (!visit[e])
                {
                    visit[e] = 1;
                    q.push(e);
                }
            }
        }
    }
    return dist[e];
}

int main()
{
    //freopen("poj3268.txt", "r", stdin);
    while (scanf("%d%d%d", &n, &m, &x) == 3)
    {
        int a, b, d;
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &a, &b, &d);
            v[a].push_back(Edge(a, b, d));
        }
        int ans = -1;
        for (int i = 1; i <= n; i++)
        {
            if (i != x)
            {
                int dist1 = spfa(i, x);
                int dist2 = spfa(x, i);
                ans = max(ans, dist1 + dist2);
            }
        }
        printf("%d
", ans);
    }
    return 0;
}

Dijkstra算法：

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

const int INF = 0x3f3f3f;
const int N = 1000 + 10;
int map[N][N];
int dist[N], reverse_dist[N];    //记录x到其余各点的最短路径，和其余各点到x的最短路径
int visit[N];
int n, m, x;

void dijkstra(int s)
{
    memset(visit, 0, sizeof(visit));
    for (int i = 1; i <= n; i++)
        dist[i] = map[s][i];
    dist[s] = 0;
    visit[s] = 1;

    int min_dist, now = s;
    for (int i = 1;i <= n; i++)
    {
        min_dist = INF;
        for (int j = 1; j <= n; j++)
        {
            if (!visit[j] && dist[j] < min_dist)
            {
                min_dist = dist[j];
                now = j;
            }
        }
        if (min_dist == INF) break;
        visit[now] = 1;
        for (int j = 1; j <= n; j++)
            dist[j] = min(dist[j], dist[now] + map[now][j]);
    }
}

void reverse_map()    //将原矩阵转置
{
    for (int i = 1;i <= n; i++)
    {
        for (int j = i + 1; j <= n; j++)
        {
            int t = map[i][j];
            map[i][j] = map[j][i];
            map[j][i] = t;
        }
    }
}

int main()
{
    //freopen("poj3268.txt", "r", stdin);
    while (scanf("%d%d%d", &n, &m, &x) == 3)
    {
        memset(map, INF, sizeof(map));
        int a, b, d;
        for (int i = 0; i < m; i++)
        {
            scanf("%d%d%d", &a, &b, &d);
            map[a][b] = d;
        }
        dijkstra(x);
        for (int i = 1; i <= n; i++)
            reverse_dist[i] = dist[i];
        reverse_map();
        dijkstra(x);
        int ans = -1;
        for (int i = 1; i <= n; i++)
            if (i != x)
                ans = max(ans, dist[i] + reverse_dist[i]);
        printf("%d
", ans);
    }
    return 0;
}