UVA 12950 ： Even Obsession（最短路Dijkstra）

https://uva.onlinejudge.org/index.php?option=com_onlinejudge&Itemid=8&page=show_problem&problem=4829

Patricia is an excellent software developer, but, as every brilliant person, she has some strange quirks.
One of those is that everything she does has to be in even quantities. Most often that quirk does not
affect her, even though it may seem strange to others. Some examples: every day she has to eat an
even number of meals; during breakfast, she drinks two cups of coffee, eats two toasts and two slices
of cheese; when she goes to the cinema she buys two tickets (fortunately she always has a friend that
goes with her); she takes two baths per day (or four, our six...).
Some other times, however, that quirk makes the life of Patricia more difficult. For example, no
one wants to travel by car with her because if she has to pay toll, the number of tolls she pays has to
be an even number.
Patricia lives in a country where all roads are two-way and have exactly one toll each. She needs to
visit a client in a different city, and wants to calculate the minimum total value of tolls she has to pay
to go from her city to the client’s city, obeying her strange quirk that she has to pay an even number
of tolls.
Input
The input consists of several test cases. The first line of a test case contains two integers C and V ,
the total number of cities and the number of roads (2 ≤ C ≤ 104 and 0 ≤ V ≤ 50000). The cities
are identified by integer numbers from 1 to C. Each road links two different cities, and there is at
most one road between each pair of cities. Each of the next V lines contains three integers C1, C2
and G, indicating that the toll value of the road linking cities C1 and C2 is G (1 ≤ C1, C2 ≤ C and
1 ≤ G ≤ 104
). Patricia is currently in city 1 and the client’s city is C.
Output
For each test case in the input your program must output exactly one line, containing exactly one
integer, the minimum toll value for Patricia to go from city 1 to city C, paying an even number of tolls,
or, if that is not possible, the value ‘-1’.
Sample Input
4 4
1 2 2
2 3 1
2 4 10
3 4 6
5 6
1 2 3
2 3 5
3 5 2
5 1 8
2 4 1
4 5 4
Sample Output
12
-1

　　题意：要求输出的从1到C的最短路径的边数是偶数，如果无偶数则输出-1。

 /*
 Dijkstra + 优先队列优化
 奇数边 + 一条边 = 偶数边 D数组装奇数边
 偶数边 + 一条边 = 奇数边 d数组装偶数边
 互相优化，若点C 在 d 数组（装偶数边）为INF（没被更新），则无法达到
 否则可以达到并且是最短的
 */
 #include <cstdio>
 #include <algorithm>
 #include <iostream>
 #include <cstring>
 #include <string>
 #include <cmath>
 #include <queue>
 #include <vector>
 using namespace std;
 #define MAXN 100010
 const int inf=;
 struct Node
 {
     int w,next,to;
 }edge[MAXN*];
 struct node
 {
     int x,d;
     node(){}
     node(int a,int b){x=a;d=b;}
     bool operator < (const node &a) const
     {
         if(d==a.d) return x<a.x;
         else return d>a.d;
     }
 };

 int head[MAXN],tot,V,E,d[MAXN],D[MAXN];

 void add(int u,int v,int cost)
 {
     edge[tot].to=v;
     edge[tot].w=cost;
     edge[tot].next=head[u];
     head[u]=tot++;
 }

 void dijkstra()
 {
     priority_queue<node> que;
     while(!que.empty()) que.pop();
     for(int i=;i<=V;i++){
         D[i]=d[i]=inf;
     }
     d[]=;
     que.push(node(,));
     while(!que.empty()){
         node a=que.top();que.pop();
         int top=a.x;
         for(int k=head[top];~k;k=edge[k].next){
             int cost = edge[k].w;
             int v = edge[k].to;
             if( d[top] + cost < D[v] ){
                 D[v] = d[top] + cost;
                 que.push(node(v,D[v]));
             }
             if( D[top] + cost < d[v] ){
                 d[v] = D[top] + cost;
                 que.push(node(v,d[v]));
             }
         }
     }
 }

 int main()
 {
     while(~scanf("%d%d",&V,&E)){
         int u,v,w;
         tot=;
         memset(head,-,sizeof(head));
         for(int i=;i<=E;i++){
             scanf("%d%d%d",&u,&v,&w);
             add(u,v,w);
             add(v,u,w);
         }
         dijkstra();
         long long ans;
         if(d[V]==inf){
             ans=-;
         }
         else ans=d[V];
         printf("%d\n",ans);
     }
     return ;
 }

2016-06-02