最短路(Bellman_Ford) POJ 3259 Wormholes

题目传送门

 /*
     题意：一张有双方向连通和单方向连通的图，单方向的是负权值，问是否能回到过去(权值和为负)
     Bellman_Ford：循环n-1次松弛操作，再判断是否存在负权回路(因为如果有会一直减下去)
     注意：双方向连通要把边起点终点互换后的边加上
 */
 #include <cstdio>
 #include <iostream>
 #include <algorithm>
 #include <cmath>
 #include <cstring>
 #include <string>
 #include <map>
 #include <vector>
 #include <queue>
 using namespace std;

 const int MAXN =  + ;
 const int INF = 0x3f3f3f3f;
 int d[MAXN];
 struct NODE
 {
     int from, to, cost;
 }node[MAXN];

 bool Bellman_Ford(int s, int n, int m)
 {
     int x, y;
     d[s] = ;
     for (int k=; k<=n-; ++k)
     {
         for (int i=; i<=m; ++i)
         {
             NODE e = node[i];
             d[e.to] = min (d[e.to], d[e.from] + e.cost);
         }
     }

     for (int i=; i<=m; ++i)
     {
         NODE e = node[i];
         if (d[e.to] > d[e.from] + e.cost)    return false;
     }

     return true;
 }

 void work(int n, int m)
 {
     bool flag = false;
     flag = Bellman_Ford (, n, m);

     (!flag) ? puts ("YES") : puts ("NO");
 }

 int main(void)        //POJ 3259 Wormholes
 {
     //freopen ("B.in", "r", stdin);

     int N, M, W;
     int t;
     scanf ("%d", &t);
     while (t--)
     {
         scanf ("%d%d%d", &N, &M, &W);
         for (int i=; i<=N; ++i)    d[i] = INF;

         int x, y, z;
         for (int i=; i<=*M; ++i)
         {
             scanf ("%d%d%d", &x, &y, &z);
             node[i].from = x;    node[i].to = y;        node[i].cost = z;
             node[++i].from = y;        node[i].to = x;        node[i].cost = z;
         }

         for (int i=*M+; i<=*M+W; ++i)
         {
             scanf ("%d%d%d", &x, &y, &z);
             node[i].from = x;    node[i].to = y;        node[i].cost = -z;
         }

         work (N, *M+W);
     }

     return ;
 }