codeforces 567 E. President and Roads 【 最短路 桥 】

给出一个有向图，从起点走到终点（必须走最短路），问一条边是否一定会被经过，如果不经过它，可以减小它的多少边权使得经过它（边权不能减少到0）

正反向建图，分别求出起点到每个点的最短距离，终点到每个点的最短距离（用这个可以算出减小的边权）

再将在最短路径上的边重新建图。求出里面的桥，就是必须经过的边

wa了一上午------呜呜呜呜

先wa 19  是因为求桥的时候是无向图，数组开小了一半

然后 wa 46 ，是因为dis[]数组初始化为 1 << 30 -1 ,应该再开大点 ，开成 1 << 50 -1

我写成 1 LL * 50 -----一直wa 19------

5555555555555555555--------sad-------

 #include <cstdio>
 #include <cstring>
 #include <cstdlib>
 #include <cmath>
 #include <vector>
 #include <map>
 #include <set>
 #include <stack>
 #include <queue>
 #include <iostream>
 #include <algorithm>
 using namespace std;
 #define lp (p << 1)
 #define rp (p << 1|1)
 #define getmid(l,r) (l + (r - l) / 2)
 #define MP(a,b) make_pair(a,b)
 typedef long long ll;
 typedef unsigned long long ull;
 typedef pair<int,int> pii;
 const int INF = ( << ) - ;
 const int maxn = ;

 int N,M;
 ll path;
 int first1[maxn],nxt1[ * maxn],ecnt1;
 int first2[maxn],nxt2[ *maxn],ecnt2;
 int first[maxn],nxt[*maxn],ecnt;
 ll dis1[maxn],dis2[maxn];

 int bg[*maxn],vis[*maxn],low[maxn],dfn[maxn];
 int ans[*maxn],res[maxn];
 int tot,num;

 struct edge{
     int v,u,cost;
     int tag;
     int ge;
     int id;
     friend bool operator < (edge a,edge b){
         return a.cost > b.cost;
     }
 };

 edge e1[*maxn],e2[*maxn],e[*maxn];

 void init(){
     ecnt1 = ecnt2 = ecnt = ;
     memset(first1,-,sizeof(first1));
     memset(first2,-,sizeof(first2));
     memset(first,-,sizeof(first));
 }

 void Add_edge1(int u,int v,int c){
     nxt1[++ecnt1] = first1[u];
     e1[ecnt1].u = u;
     e1[ecnt1].v = v;
     e1[ecnt1].cost = c;
     e1[ecnt1].tag = ;
     e1[ecnt1].ge = ;
     first1[u] = ecnt1;
 }

 void Add_edge2(int u,int v,int c){
     nxt2[++ecnt2] = first2[u];
     e2[ecnt2].v = v;
     e2[ecnt2].cost = c;
     e2[ecnt2].tag = ;
     e2[ecnt2].ge = ;
     first2[u] = ecnt2;
 }

 void Add_edge(int u,int v,int c){
     nxt[ecnt] = first[u];
     e[ecnt].v = v;
     e[ecnt].u = u;
     e[ecnt].id = c;
     first[u] = ecnt++;

     nxt[ecnt] = first[v];
     e[ecnt].v = u;
     e[ecnt].u = v;
     e[ecnt].id = c;
     first[v] = ecnt++;
 }

 struct cmp{
     bool operator ()(pii a,pii b){
         return a.first > b.first;
     }
 };

 void Dijstra1(int s){
     priority_queue<pii,vector<pii >,cmp> PQ;
     dis1[s] = ;
     PQ.push(MP(dis1[s],s));
     int cnt = ;
     while(!PQ.empty()){
         pii x = PQ.top(); PQ.pop();
         if(dis1[x.second] < x.first) continue;
         for(int i = first1[x.second]; i != -; i = nxt1[i]){
             int v = e1[i].v;
             if(dis1[v] > dis1[x.second] + e1[i].cost){
                 dis1[v] = dis1[x.second] + e1[i].cost;
                 PQ.push(MP(dis1[v],v));
             }
         }
     }
 }

 void Dijstra2(int s){
     priority_queue<pii,vector<pii >,cmp> PQ;
     dis2[s] = ;
     PQ.push(MP(dis2[s],s));
     int cnt = ;
     while(!PQ.empty()){
         pii x = PQ.top(); PQ.pop();
         if(dis2[x.second] < x.first) continue;
         for(int i = first2[x.second]; i != -; i = nxt2[i]){
             int v = e2[i].v;
             if(dis2[v] > dis2[x.second] + e2[i].cost){
                 dis2[v] = dis2[x.second] + e2[i].cost;
                 PQ.push(MP(dis2[v],v));
             }
         }
     }
 }

 void Dfs(int p,int pre){
     dfn[p] = low[p] = ++tot;
     for(int i = first[p]; ~i; i = nxt[i]){
         int v = e[i].v;
         if(vis[i]) continue;
         vis[i] = vis[i ^ ] = true;
         if(!dfn[v]){
             Dfs(v,p);
             low[p] = min(low[p],low[v]);
             if(low[v] > dfn[p]) {
                 bg[i] = bg[i ^ ] = true;
                 ans[e[i].id] = ;
             }
         }
         else low[p] = min(low[p],dfn[v]);
     }
 }

 void Tarjan(){
     memset(dfn,,sizeof(dfn));
     memset(low,,sizeof(low));
     memset(bg,false,sizeof(bg));
     memset(vis,false,sizeof(vis));
     tot = ;
     for(int i = ; i <= N; ++i) if( dfn[i] == ) Dfs(i,-);
 }

 void solve(){
     memset(res,-,sizeof(res));
     for(int i = ;i <= M;i++){
         int u = e1[i].u;
         int v = e1[i].v;
         if(ans[i] == ) {
             res[i] = ;
             continue;
         }
         ll need = path - dis1[u] - dis2[v];
         if(need > ){
              res[i] = e1[i].cost - need + ;
         }
     }

     for(int i = ;i <= M;i++){
         if(res[i] == ) puts("YES");
         else if(res[i] == -) puts("NO");
         else printf("CAN %d\n",res[i]);
     }
 }

 int main(){
     int a,b,c,s,t;
     num = ;
     while(scanf("%d%d%d%d",&N,&M,&s,&t) != EOF){
         num++;
         init();
         int x;

         for(int i = ; i <= M; ++i){
             scanf("%d%d%d",&a,&b,&c);
             Add_edge1(a,b,c);
             Add_edge2(b,a,c);
         }

         for(int i = ;i <= N;i++) dis1[i] = dis2[i] = 1ll << ;

         Dijstra1(s);
         Dijstra2(t);
         path = dis1[t];

         for(int u = ;u <= N;u++){
             for(int i = first1[u];~i;i = nxt1[i]){
                 int v = e1[i].v;
                 if(dis1[u] + dis2[v] + e1[i].cost == path) {
                     e1[i].tag = ;
                     e2[i].tag = ;
                     Add_edge(u,v,i);
                 }
             }
         }

         memset(ans,,sizeof(ans));
         Tarjan();
         solve();
     }
     return ;
 }