Codeforces Round #372 (Div. 1) B. Complete The Graph

题目链接：传送门

题目大意：给你一副无向图，边有权值，初始权值>=0，若权值==0，则需要把它变为一个正整数（不超过1e18），现在问你有没有一种方法，

　　　　　使图中的边权值都变为正整数的时候，从 S 到 T 的最短路恰好等于 L。

　　　　　若没有输出 "NO"，否则输出 "YES",同时输出新图中的所有边权值。

题目思路：二分+最短路（spfa or dijkstra）

　　　　　

闲谈：先%一发杜教，思路来源于看他的代码。然后蒟蒻spfa 982ms，杜教 dijkstra 93ms（毕竟1000个点，严格nlogn，spfa不稳定）

详细方法：

　　　　　以下把题目中权值为0 的边称为 重构边 ，

　　　　　        无穷大设为1e9+1（因为 L 最大1e9，所以只要重构边权值为1e9+1，则任何经过该重构边的路径均不合法，因为>L）

　　　　　题目要求所有边都要为正，那么我们验证时首先验证 重构边 权值为 1 的情况。

　　　　　　　　若此时从 S 到 T 的最短路 >L，则为NO

　　　　　　　　因为我们在题目要求范围里无法找到一条路径使 S 到 T 的最短路更短，所以不成立

　　　　　再验证所有重构边 权值为 无穷大的情况。

　　　　　　　　若此时从 S 到 T 的最短路 <L，同样为NO

　　　　　　　　因为重构边设为无穷大之后，最短路只会走原图上的 非重构边，而这些边权值是不能改变的，及时重构边边权减小，

　　　　　　　　也只会使 最短路变得更短，所以不合法

　　　　　这就是不合法的情况，除此之外的所有情况都会找到一种重构方法使题目有解。

　　　　　上面第一种方法如果最短路<L,则可通过增加重构边边权的方法使最短路==L，第二种情况同理可减小边权使之成立

分割线/***----------------------------------------------------------------------------------------------------------------------***/

　　　　现在是如何找到一种边权分配方法使最短路==L

　　　　首先我们要弄明白一个结论

　　　　　　　　1.如果最短路不经过重构边（对应上面第二种情况）且最短路恰等于L，则重构边边权任意正整数。

　　　　　　　　2.如果最短路经过重构边{

　　　　　　　　　　无论最短路==L的路径有多少条，我们只需找到一条路径即可，其他路径上的重构边权值就算设为无穷大

　　　　　　　　　　对题目没有影响（因为已经找到一条）。我们只需要把选好的这条路径上的重构边边权设置好就行。

　　　　　　　　}

　　　　　　　　那么怎样设置边权？

　　　　　　　　可能你会问为什么不先找一条路径？其实我们只需要不断给每条边分配边权并且匹配最短路是否合法就行。

　　　　　　　　也就是说我们给每条重构边机会，如果不行，把它设为无穷大，否则分配边权给它看它是否能满足我们最短路的要求。

　　　　　　　　这样会很简单也不会出错。

　　　　　　　　设置边权的过程用二分来实现，二分的值是所有边的权值总和。然后从给每一条边分配权值，如果最短路==L，则成功

　　　　　　　　否则如果最短路<L，增加边权。如果最短路>L，减少边权。

　　　　　　　　最短路用 spfa or dijkstra 即可。此题点少，dijkstra很快。

 #include <iostream>
 #include <cstdio>
 #include <cstdlib>
 #include <cmath>
 #include <algorithm>
 #include <cstring>
 #include <stack>
 #include <cctype>
 #include <queue>
 #include <string>
 #include <vector>
 #include <set>
 #include <map>
 #include <climits>
 #define lson rt<<1,l,mid
 #define rson rt<<1|1,mid+1,r
 #define fi first
 #define se second
 #define ping(x,y) ((x-y)*(x-y))
 #define mst(x,y) memset(x,y,sizeof(x))
 #define mcp(x,y) memcpy(x,y,sizeof(y))
 using namespace std;
 #define gamma 0.5772156649015328606065120
 #define mod 1000000007
 #define inf 0x3f3f3f3f
 #define N 1005050
 #define maxn 20005
 typedef pair<int,int> PII;
 typedef long long LL;

 int n,m,k,x,y,v;
 int S,T,L;
 int head[N],hcnt;
 struct Node{
     int to,nxt,v;
 }node[maxn];
 int d[N],vis[N],s[maxn];
 vector<int>eg;  ///存重构边
 queue<int>q;
 int spfa(){
     for(int i=;i<n;++i) d[i]=(int)1e9+; d[S]=;
     mst(vis,); q.push(S);
     while(!q.empty()){
         int x=q.front();q.pop(); vis[x]=;
         for(int i=head[x];~i;i=node[i].nxt){
             int e=node[i].to;
             if(d[e]>d[x]+node[i].v){
                 d[e]=d[x]+node[i].v;
                 if(!vis[e]){vis[e]=;q.push(e);}
             }
         }
     }
     return d[T];
 }
 int check(LL sum){  ///判断是否合法
     for(int u:eg){
         node[u].v=node[u|].v=+min(sum,1000000000ll);
                     ///给每个重构边分配权值
         sum-=node[u].v-;
     }
     return spfa();
 }
 inline void add(int x,int y,int v){
     node[hcnt].to=y;node[hcnt].nxt=head[x];node[hcnt].v=v;head[x]=hcnt++;
 }
 int main(){
     int i,j,group;
     mst(head,-);
     scanf("%d%d%d%d%d",&n,&m,&L,&S,&T);
     for(i=;i<=m;++i){
         scanf("%d%d%d",&x,&y,&v);
         if(!v)eg.push_back(hcnt);
         s[hcnt]=x;
         add(x,y,v);
         add(y,x,v);
     }
     LL l=,r=eg.size()*LL(1e9);
     if(check()>L||check(r)<L)return *printf("NO\n");
     LL ans;
     while(l<=r){
         LL mid=l+r>>,temp=check(mid);
         if(temp>L)ans=mid,r=mid-;
         else if(temp<L)l=mid+;
         else break;
     }
     printf("YES\n");
     for(i=;i<m*;i+=)printf("%d %d %d\n",s[i],node[i].to,node[i].v);
     return ;
 }