LightOj 1074 Extended Traffic (spfa+负权环)

题目链接：

　　http://lightoj.com/volume_showproblem.php?problem=1074

题目大意：

　　有一个大城市有n个十字交叉口，有m条路，城市十分拥挤，因此每一个路都有一个拥挤度，政府就出台了一个政策，对每一条路收取过路费，收取标准为（终点拥挤度 - 起点拥挤度 ）^3,，问每次询问m，输出1到m的最小花费，如果不能到达或者最小化费小于3的时候输出‘？’。

解题思路：

　　用spfa。标记负环。

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

#define maxn 210
#define INF 0x3f3f3f3f

struct Edge
{
    int e, w;
    Edge(int e=0, int w=0):e(e),w(w){}
};

vector<Edge>G[maxn];
int dist[maxn], n;
bool Cin[maxn];
void init();
int spfa ();
void dfs (int u);

int main ()
{
    int m, t, l=0, map[maxn];
    scanf ("%d", &t);

    while (t --)
    {
        printf ("Case %d:
", ++l);
        init ();
        scanf ("%d", &n);

        for (int i=1; i<=n; i++)
            scanf ("%d", &map[i]);

        scanf ("%d", &m);
        while (m --)
        {
            int a, b, num;
            scanf ("%d %d", &b, &a);
            num = (map[a] - map[b]) * (map[a] - map[b]) * (map[a] - map[b]);
            G[b].push_back (Edge(a, num));
        }
        spfa ();
        scanf ("%d", &m);
        while (m --)
        {
            int num;
            scanf ("%d", &num);
            if (Cin[num] || dist[num] < 3 || dist[num] == INF)
                printf ("?
");
            else
                printf ("%d
", dist[num]);
        }
    }
}
void init()
{
    int i, j;
    memset (Cin, false, sizeof(Cin));
    for (i=0; i<maxn; i++)
    {
        G[i].clear();
        dist[i] = INF;
    }
}

int spfa ()
{
    queue<int>Q;
    bool vis[maxn];
    int cnt[maxn];
    memset (vis, false, sizeof(vis));
    memset (cnt, 0, sizeof(cnt));
    Q.push (1);
    cnt[1] = 1;
    dist[1] = 0;

    while (!Q.empty())
    {
        int s = Q.front ();
        Q.pop ();
        vis[s] = false;
        int len = G[s].size();

        for (int i=0; i<len; i++)
        {
            Edge x = G[s][i];
            if (Cin[x.e])
                continue;
            if (dist[x.e] > dist[s] + x.w)
            {
                dist[x.e] = dist[s] + x.w;
                if (!vis[x.e])
                {
                    vis[x.e] = true;
                    Q.push (x.e);
                    cnt[x.e] ++;
                    if (cnt[x.e] == n)//只要x.e在负环内，则在负环内的点可以到达的点，都没有最短路径
                        dfs(x.e);
                }
            }
        }
    }
}

void dfs (int u)
{
    int len = G[u].size();
    Cin[u] = true;
    for (int i=0; i<len; i++)//u后面的点都没有最短回路，都应该标记
        
    {
        if (!Cin[G[u][i].e])
            dfs (G[u][i].e);
    }
}