Codeforces 1296F Berland Beauty

题目链接：http://codeforces.com/problemset/problem/1296/F

思路：

1————2————3————4————5————6

1->3 2

2->4 3

3->5 3

4->6 5

题目说 （u->v w）途中所有边 e1,e2,e3,...en∈E，满足任意|ex| >= w(ex∈E)，

上面图中  3->5 3    4->6 5,说明（|e(4->5)| >= 3 && |e(4->5)| >= 5）  ==>  |e(4->5)| >= 5。

通过这个想法，我们可以把边以（w）排序，大到小，先染色w大的，w小的不能去重新染色w大的，只能

染色未被染色的部分或者w相同的部分，例如（2->4）（3->5）w都是3,那么,如果某次（u->v w）无法染色，

说明就是"-1".

用了lca去优化（u->v）的寻路过程。

 #include <iostream>
 #include <algorithm>
 #include <map>
 #include <vector>
 #include <cstdio>
 using namespace std;

 const int N = (int)5e3+,INF = (int)1e6;
 struct node{
     int to,nxt;
 }e[N<<];
 struct Info{
     int u,v,w;
     bool friend operator<(const Info& a,const Info& b){
         return a.w > b.w;
     }
 }info[N];
 map<pair<int,int>, int > mp;//边
 pair<int,int > pii;
 vector<pair<int,int > > vii;
 int n,m,u,v,w,tot,tim;
 int head[N],dfn[N],fa[N];

 inline void add(int u,int v){
     e[tot].to = v; e[tot].nxt = head[u]; head[u] = tot++;
     e[tot].to = u; e[tot].nxt = head[v]; head[v] = tot++;
 }

 void dfs_dfn(int now,int pre){
     dfn[now] = ++tim;
     for(int o = head[now]; ~o; o = e[o].nxt){
         if(e[o].to == pre) continue;
         dfs_dfn(e[o].to,now);
     }
 }

 void dfs_mp(int now,int pre){
     for(int o = head[now]; ~o; o = e[o].nxt){
         int to = e[o].to;
         if(to == pre) continue;
         fa[dfn[to]] = dfn[now];
         mp[make_pair(dfn[now],dfn[to])] = INF;//初始化边INF，把边的两点转化为dfn，总是以dnf小的在first位置
         　　　　　　　　　　　　　　　　　　　　　　 //输出答案的时候，通过dfn[u],dfn[v]去得到这条边
         dfs_mp(e[o].to,now);
     }
 }

 void show(){
     for(int i = ; i <= n; ++i)
         printf("u = %d dfn = %d\n",i,dfn[i]);
     for(int i = ; i <= m; ++i) cout << info[i].w << endl;
     for(int i = ; i <= n; ++i)
         printf("u = %d fa = %d\n",i,fa[dfn[i]]);
 }

 bool lca(int u,int v,int w){
     int u_dfn = dfn[u],v_dfn = dfn[v],tmp_w;
     bool ok = ;
     while(u_dfn != v_dfn){
         while(u_dfn > v_dfn){
             pii.first = fa[u_dfn]; pii.second = u_dfn;
             tmp_w = mp[pii];
             if(tmp_w == INF || tmp_w == w){//未被染色，或者w相同
                 ok = ;
                 mp[pii] = w;
             }
             u_dfn = pii.first;
         }
         while(u_dfn < v_dfn){
             pii.first = fa[v_dfn]; pii.second = v_dfn;
             tmp_w = mp[pii];
             if(tmp_w == INF || tmp_w == w){
                 ok = ;
                 mp[pii] = w;
             }
             v_dfn = pii.first;
         }
     }
     return ok;
 }

 void solve(){
     for(int i = ; i <= n; ++i) head[i] = -; tot = ;
     for(int i = ; i <= n-; ++i){
         scanf("%d%d",&u,&v);
         vii.push_back(make_pair(u,v));
         add(u,v);
     }
     dfs_dfn(,);//初始化dfn序
     fa[] = ;
     dfs_mp(,);//初始化边长和fa[]数组
     scanf("%d",&m);
     for(int i = ; i <= m; ++i){
         scanf("%d%d%d",&info[i].u,&info[i].v,&info[i].w);
     }

     sort(info+,info++m);//边按W排序
     for(int i = ; i <= m; ++i){
         if(lca(info[i].u,info[i].v,info[i].w)) continue;
         printf("-1\n"); return;
     }
     int l = vii.size();
     int dfn1,dfn2;
     for(int i = ; i < l; ++i){
         dfn1 = dfn[vii[i].first];
         dfn2 = dfn[vii[i].second];
         if(dfn1 > dfn2) swap(dfn1,dfn2);
         pii.first = dfn1; pii.second = dfn2;
         printf("%d ",mp[pii]);
     }cout << endl;
 }

 int main(){

     scanf("%d",&n);
     solve();

     return ;
 }