cdoj 秋实大哥带我飞 最短路走法 含0权边

//做完这题以后终于理解白书上的边为什么要那样定义了 可以很方便的在o（1） 时间内找到反向边

解法：先跑一边最短路，然后检查最短路上有没有0权边（dfs就好，但是每条边只能走一次，这里就需要用异或找反向边），最后记忆化搜索一遍（每条边也是只能走一次）

 #include<cstdio>
 #include<iostream>
 #include<cmath>
 #include<algorithm>
 #include<cstring>
 #include<cstdlib>
 #include<queue>
 #include<vector>
 #include<map>
 #include<stack>
 #include<string>

 using namespace std;

 const int INF=;
 const int MOD=;

 struct Edge{
     int from,to,cost;
 };

 vector <Edge> edges;
 vector <int> G[];
 bool vis[];
 int dis[];
 bool inq[];
 int f[];
 int n,m;

 void AddEdge(int x,int y,int z){
     edges.push_back((Edge){x,y,z});
     edges.push_back((Edge){y,x,z});
     int sz=edges.size();
     G[x].push_back(sz-);
     G[y].push_back(sz-);
 }

 void SPFA(){
     dis[]=;
     memset(inq,,sizeof(inq));
     queue<int>q;
     q.push();
     inq[]=;
     while (!q.empty()){
             int now=q.front();
             int sz=G[now].size();
             q.pop();
             for (int i=;i<sz;i++){
                             Edge& e=edges[G[now][i]];
                             if (dis[e.to]>dis[now]+e.cost){
                                     dis[e.to]=dis[now]+e.cost;
                                     if (!inq[e.to]){
                                             q.push(e.to);
                                             inq[e.to]=;
                                     }
                             }
             }
             inq[now]=;
     }
 }

 bool check(int now){
     if (now==) return ;
     bool flag=;
     int sz=G[now].size();
     for (int i=;i<sz;i++){
             Edge& e=edges[G[now][i]];
             if (!vis[G[now][i]] && dis[now]==dis[e.to]+e.cost){
                     vis[G[now][i]]=;
                     vis[G[now][i]^]=;
                     if (e.cost==) flag=false;
                     if (!check(e.to)) flag=false;
             }
     }
     return flag;
 }

 int work(int now){
     if (f[now]!=-) return f[now];
     f[now]=;
     int sz=G[now].size();
     for (int i=;i<sz;i++){
             Edge& e=edges[G[now][i]];
             if (!vis[G[now][i]] && dis[now]==dis[e.to]+e.cost){
                     vis[G[now][i]]=;
                     vis[G[now][i]^]=;
                     f[now]=(f[now]+work(e.to))%MOD;
             }
     }
     return f[now];
 }

 int main(){
     scanf("%d%d",&n,&m);
     for (int i=;i<=n;i++) dis[i]=INF;
     for (int i=;i<m;i++){
             int x,y,z;
             scanf("%d%d%d",&x,&y,&z);
             AddEdge(x,y,z);
     }
     SPFA();
     //printf("%d\n",dis[n]);
     memset(vis,,sizeof(vis));
     if (!check(n)){
             printf("-1\n");
             return ;
     }
     memset(vis,,sizeof(vis));
     memset(f,-,sizeof(f));
     f[]=;
     printf("%d\n",work(n));
     return ;
 }
 /*
 4 4
 1 2 1
 1 3 1
 2 4 2
 3 4 2

 4 4
 1 2 0
 1 3 1
 2 4 99
 3 4 99
 */