偷西瓜

描述

對於農村的孩子來說最大的樂趣，莫過於和小夥伴們一塊下地偷西瓜了，雖然孩子們條件不是很好，但是往往他們很聰明，他們總在計算著到達瓜田的距離，以及逃跑的路線，他們總是以最短的距離衝到瓜田裡面，然後以最短的距離回到出發的地方，不過瓜田的大人們已經在他們來的路上等待他們。於是聰明的小夥伴們便不走過的路，即每條路只走一遍,如果小夥伴們回不到出發的地方，他們就說“eating”，

我們假設 有 n (n<=100)個 村莊 m條路(m<=1000)小夥伴們總是從1號村莊出發，而瓜田總是在n號村莊.如果小夥伴們到達不了n號村莊，或者回不到1號村莊請輸出"eating";

輸入

多組資料
第一行一個整數 n 
第二行 一個整數 m
隨後的m行 有 三個數u,v,w 表示u 到 v村莊的距離為w(w<=1000);

輸出

求小夥伴們從1號村莊出發，到 n號村莊，再回到1號村莊所用的最短距離，如果不能回到1號村莊請輸出“eating”.

樣例輸入

2
1
1 2 999
3
3
1 3 10
2 1 20
3 2 50

樣例輸出

eating
80

上傳者

分析：求一個最短路和一個次短路的和。

那麼我們用spfa求一次從1到n的最短路，然後順便記錄路徑，然後求完之後把走過的路徑刪去。然後在求一次1到n的最短路。

spfa講解：http://blog.csdn.net/y990041769/article/details/18367665

程式碼：

1. #include <cstdio>
2. #include <vector>
3. #include <iostream>
4. #include <stack>
5. #include <cstdio>
6. #include <string>
7. #include <cstring>
8. #include <cmath>
9. #include <algorithm>
10. #include <queue>
11. usingnamespace
     std;  
12. constint inf = 0x3f3f3f3f;  
13. constint N = 300;  
14. struct Point  
15. {  
16.     int x,y;  
17.     int r;  
18.     int num;  
19. };  
20. Point a[N];  
21. struct Node  
22. {  
23.     int v,len;  
24. };  
25. vector<Node> map[N];  
26. int n,m;  
27. void spfa(int s,int dis[])  
28. {  
29.     int i,pre[N];  
30.     bool used[N];  
31.     queue<int> q;  
32.     memset(used,0,sizeof(used));  
33.     memset(pre,-1,sizeof(pre));  
34.     for(i=0; i<N; i++)  
35.         dis[i]=inf;  
36.     dis[s]=0;  
37.     used[s]=true;  
38.     q.push(s);  
39.     while(!q.empty())  
40.     {  
41.         int u=q.front();  
42.         q.pop();  
43.         used[u]=false;  
44.         for(i=0; i<map[u].size(); i++)  
45.         {  
46.             Node p=map[u][i];  
47.             if(dis[p.v]>dis[u]+p.len)  
48.             {  
49.                 dis[p.v]=dis[u]+p.len;  
50.                 pre[p.v]=u;  
51.                 if(!used[p.v])  
52.                 {  
53.                     used[p.v]=true;  
54.                     q.push(p.v);  
55.                 }  
56.             }  
57.         }  
58.     }  
59.     for(int i=n;pre[i]!=-1;i=pre[i])  
60.     {  
61. //        printf("%d ",pre[i]);
62.         for(int j=0;j<map[i].size();j++)  
63.         {  
64.             if(map[i][j].v==pre[i])  
65.                 map[i].erase(map[i].begin()+j);  
66.         }  
67.         for(int j=0;j<map[pre[i]].size();j++)  
68.         {  
69.             if(map[pre[i]][j].v==i)  
70.                 map[pre[i]].erase(map[pre[i]].begin()+j);  
71.         }  
72.     }  
73. }  
74. int main()  
75. {  
76.     int dis1[N];  
77.     while(~scanf("%d%d",&n,&m))  
78.     {  
79.         for(int i=0;i<=n;i++)  
80.             map[i].clear();  
81.         for(int i=0;i<m;i++)  
82.         {  
83.             int x,y,z;  
84.             scanf("%d%d%d",&x,&y,&z);  
85.             Node tmp;  
86.             tmp.v=y,tmp.len=z;  
87.             map[x].push_back(tmp);  
88.             tmp.v=x;  
89.             map[y].push_back(tmp);  
90.         }  
91.         int ans=0;  
92.         spfa(1,dis1);  
93.         ans+=dis1[n];  
94.         spfa(1,dis1);  
95.         ans+=dis1[n];  
96.         if(ans>=inf)  
97.             printf("eating\n");  
98.         else
99.             printf("%d\n",ans);  
100.     }  
101.     return 0;  
102. }