HDU ACM 1224 Free DIY Tour （SPFA）

Free DIY Tour

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 65536/32768 K (Java/Others)
Total Submission(s): 2735    Accepted Submission(s): 889

【题目链接】http://acm.hdu.edu.cn/showproblem.php?pid=1224

【题目意思】题目是说给你一个有环的图，结点之间有路径，每个结点都有个兴趣值，现在给你起点，找一条路径再次回到起点，使经过的结点的兴趣值总和最大，问最大的总和是多少并且输出其路径

【解题思路】其实这题是找最长路径，因为只能从编号小的结点到达编号高的结点，所以其是有向图，所以可以将结点的兴趣值赋值到相连的边上，而转换为求最长路径的问题，因为人水，也是刚开始接触图论算法，一开始选择Dijkstra算法通过修改其中的小部分步骤去计算最长路径，提交一次WA了，后来找到了原因也就是每次当前找到的不一定是最长的路径，这点随便认真地想一下便清楚了，后来想到Bellman-Ford算法，其可以将所有的边考虑到，最终便可以计算出最长的路径，当然写代码的时候还是用回SPFA即对Bellman-Ford算法的一个优化。

为什么可以用Dellman-Ford算法而不可以用Dijsktra算法，因为Dijsktral用的是贪心的思想，每次在当前找到了最短的路径修改之后就不再考虑以后有没有更短的路径，这也是Dijsktra不能用在有负权边的原因，而Delman-Ford是到最后算法结束之后才能确定源点到当前点的最短距离，所以这也是为什么可以用在求最长路径上，而能用在求最长路径上的前提是其不能有环，而这题虽然说有环，但是好在题目说明终点的编号是（N+1）且该图是有向的。

 #include <cstdio>
 #include <queue>
 #include <cstring>

 using namespace std;

 const int NV = ;
 const int NE = ;
 const int INF = <<;
 int ne, nv, tot, max_node;
 bool vis[NV];
 int dist[NV];
 int pre[NV];
 struct Edge{
     int u, v, cost, next;
     Edge(){}
     Edge(int a, int c){u = a, cost = c;}
     Edge(int a, int b, int c, int d){u = a, v = b, cost = c, next = d;}
     bool operator < (const Edge& x) const
     {
         return cost < x.cost;
     }
 }edge[NE];
 int eh[NV];
 int wei[NV];

 void SPFA(int s = )
 {
     for(int i = ; i <= nv; ++i) dist[i] = i == s ?  : -INF;
     queue<Edge> que;
     que.push(Edge(s, ));
     vis[s] = true;
     while(!que.empty())
     {
         Edge tmp = que.front();
         int u = tmp.u;
         que.pop();
         vis[u] = false;
         for(int i = eh[u]; i != -; i = edge[i].next)
         {
             int v = edge[i].v;
             if(dist[v] < edge[i].cost + dist[u])
             {
                 dist[v] = edge[i].cost + dist[u];
                 pre[v] = u;
                 if(!vis[v])
                 {
                     que.push(Edge(v, dist[v]));
                     vis[v] = true;
                 }

             }
         }
     }
     return;
 }

 void addedge(int u, int v, int cost)
 {
     Edge e = Edge(u, v, cost, eh[u]);
     edge[tot] = e;
     eh[u] = tot++;
     return;
 }

 int main()
 {
     #ifndef ONLINE_JUDGE
     freopen("input.txt", "r", stdin);
     #endif
     int T;
     scanf("%d", &T);
     for(int t = ; t <= T; ++t)
     {
         memset(vis, false, sizeof(vis));
         memset(eh, -, sizeof(eh));
         scanf("%d", &nv);
         for(int i = ; i <= nv; ++i)
             scanf("%d", &wei[i]);
         wei[++nv] = wei[];
         scanf("%d", &ne);
         for(int i = , u, v; i < ne; ++i)
         {
             scanf("%d%d", &u, &v);
             if(u > v) { u ^= v, v ^= u, u ^= v; }
             addedge(u, v, wei[v]);
         }
         SPFA();
         printf("CASE %d#\n", t);
         printf("points : %d\n", dist[nv]);
         printf("circuit : 1");
         int cnt = ;
         for(int j = pre[nv]; j != ; ++cnt, j = pre[j])
             eh[cnt] = j;
          for(int i = cnt-; i >= ; --i)
              printf("->%d", eh[i]);
         printf("->1\n");
         if(t != T) printf("\n");
     }
     return ;
 }