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=1000000000;
const int MOD=1000000009;

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

vector <Edge> edges;
vector <int> G[2007];
bool vis[4000007];
int dis[2007];
bool inq[2007];
int f[2007];
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-2);
    G[y].push_back(sz-1);
}

void SPFA(){
    dis[1]=0;
    memset(inq,0,sizeof(inq));
    queue<int>q;
    q.push(1);
    inq[1]=1;
    while (!q.empty()){
            int now=q.front();
            int sz=G[now].size();
            q.pop();
            for (int i=0;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]=1;
                                    }
                            }
            }
            inq[now]=0;
    }
}

bool check(int now){
    if (now==1) return 1;
    bool flag=1;
    int sz=G[now].size();
    for (int i=0;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]]=1;
                    vis[G[now][i]^1]=1;
                    if (e.cost==0) flag=false;
                    if (!check(e.to)) flag=false;
            }
    }
    return flag;
}

int work(int now){
    if (f[now]!=-1) return f[now];
    f[now]=0;
    int sz=G[now].size();
    for (int i=0;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]]=1;
                    vis[G[now][i]^1]=1;
                    f[now]=(f[now]+work(e.to))%MOD;
            }
    }
    return f[now];
}


int main(){
    scanf("%d%d",&n,&m);
    for (int i=1;i<=n;i++) dis[i]=INF;
    for (int i=0;i<m;i++){
            int x,y,z;
            scanf("%d%d%d",&x,&y,&z);
            AddEdge(x,y,z);
    }
    SPFA();
    //printf("%d
",dis[n]);
    memset(vis,0,sizeof(vis));
    if (!check(n)){
            printf("-1
");
            return 0;
    }
    memset(vis,0,sizeof(vis));
    memset(f,-1,sizeof(f));
    f[1]=1;
    printf("%d
",work(n));
    return 0;
}
/*
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
*/