【UOJ150】【NOIP2015】运输计划

Author Avatar
q234rty 7月 22, 2016

二分答案+树上差分即可。

考虑到答案是所有任务所用时间的最大值，因此二分答案。

这样原问题就变成了一个判定性的问题：是否可以在给定时间内完成所有任务。

先预处理出所有方案两个点的lca，以及dfs序。

对于每个答案，显然改造成虫洞的边一是所有所用时间大于答案的任务对应的链的交上的边中边权最大的一条。

于是我们求出链的交，选择边权最大的一条边，判断所用时间最长的任务的时间减去最大边权后是否不大于答案即可。

那么如何求链交？注意到如果我们把一条链上的所有边对应的值都加上 1 ,最后对应的值恰好等于链的个数的边一定是链交的一部分。我们定义对于每个点 i ,其到根的路径上的所有边的值都要加上 mark[i] 。对于每条链，我们只要使其两端的点的 mark 值 +1 ,其两端点的lca的 mark 值 -2 就可以啦。

对于每个点 i ,我们定义 val[i] 为其子树中所有点的 mark 值之和不难发现这也是其到它父亲的边对应的值。

这样，只要按照dfs序从后往前扫，对于每个点 i 把 val[i] 加上 mark[i] ,并把 val[fa[i]] 加上 val[i] 。如果 val[i] 等于链的个数，说明点 i 到其父亲的边是链交的一部分，更新最大值即可。

我使用了树链剖分求lca，时间复杂度 O(n\log{1000n}) 。

Code

  1. #include <cctype>
  2. #include <cstdio>
  3. #include <cstring>
  4. #include <algorithm>
  5. using namespace std;
  6. const int MAXSIZE=10000020;
  7. const int INF=0x3f3f3f3f;
  8. int bufpos;
  9. char buf[MAXSIZE];
  10. void init(){
  11.     #ifdef LOCAL
  12.         freopen("4326.txt","r",stdin);
  13.     #endif // LOCAL
  14.     buf[fread(buf,1,MAXSIZE,stdin)]='\0';
  15.     bufpos=0;
  16. }
  17. int readint(){
  18.     int val=0;
  19.     for(;!isdigit(buf[bufpos]);bufpos++);
  20.     for(;isdigit(buf[bufpos]);bufpos++)
  21.         val=val*10+buf[bufpos]-'0';
  22.     return val;
  23. }
  24. const int maxn=300001;
  25. const int maxq=300001;
  26. const int maxm=600001;
  27. struct query{
  28.     int u,v,lc,len;
  29.     bool operator < (const query& rhs)const{
  30.         return len>rhs.len;
  31.     }
  32. };
  33. struct edge{
  34.     int to,cost,next;
  35. };
  36. struct graph{
  37.     int n,m;
  38.     edge e[maxm];
  39.     int first[maxn];
  40.     int dep[maxn],fa[maxn],top[maxn],sz[maxn],son[maxn],mark[maxn],dist[maxn],w[maxn],val[maxn],b[maxn];
  41.     query q[maxq];
  42.     int cur;
  43.     void init(int n){
  44.         this->n=n;
  45.         m=0;
  46.         memset(first,0,sizeof(first));
  47.     }
  48.     void addedge(int from,int to,int cost){
  49.         e[++m]=(edge){to,cost,first[from]};
  50.         first[from]=m;
  51.     }
  52.     void dfs(int u){
  53.         sz[u]=1;
  54.         for(int i=first[u];i;i=e[i].next){
  55.             int v=e[i].to;
  56.             if (dep[v])
  57.                 continue;
  58.             fa[v]=u;
  59.             dep[v]=dep[u]+1;
  60.             dist[v]=dist[u]+e[i].cost;
  61.             w[v]=e[i].cost;
  62.             dfs(v);
  63.             sz[u]+=sz[v];
  64.             if (!son[u] || sz[v]>sz[son[u]])
  65.                 son[u]=v;
  66.         }
  67.     }
  68.     void dfs2(int u,int tp){
  69.         top[u]=tp;
  70.         b[++cur]=u;
  71.         if (son[u])
  72.             dfs2(son[u],tp);
  73.         for(int i=first[u];i;i=e[i].next){
  74.             int v=e[i].to;
  75.             if (!top[v])
  76.                 dfs2(v,v);
  77.         }
  78.     }
  79.     void prepare(){
  80.         dep[1]=1;
  81.         dist[1]=0;
  82.         fa[1]=-1;
  83.         dfs(1);
  84.         cur=0;
  85.         dfs2(1,1);
  86.         cur=0;
  87.     }
  88.     int lca(int u,int v){
  89.         for(;top[u]!=top[v];u=fa[top[u]])
  90.             if (dep[top[u]]<dep[top[v]])
  91.                 swap(u,v);
  92.         return dep[u]<dep[v]?u:v;
  93.     }
  94.     void addquery(int u,int v){  //O(log n)
  95.         int lc=lca(u,v);
  96.         q[++cur]=(query){u,v,lc,dist[u]+dist[v]-2*dist[lc]};
  97.     }
  98.     int num,mmax;
  99.     bool check(int x){  //O(n)
  100.         memset(mark,0,sizeof(mark));
  101.         memset(val,0,sizeof(val));
  102.         num=mmax=0;
  103.         for(int i=1;q[i].len>x && i<=cur;i++){
  104.             num++;
  105.             mark[q[i].u]++;
  106.             mark[q[i].v]++;
  107.             mark[q[i].lc]-=2;
  108.         }
  109.         //puts("WTF");
  110.         for(int i=n;i>=2;i--){
  111.             val[b[i]]+=mark[b[i]];
  112.             if (val[b[i]]==num)
  113.                 mmax=max(mmax,w[b[i]]);
  114.             val[fa[b[i]]]+=val[b[i]];
  115.         }
  116.         //printf("check(%d)=%d\n",x,(q[1].len-mmax)<=x);
  117.         return (q[1].len-mmax)<=x;
  118.     }
  119.     int get(){ //O(nlogn)
  120.         sort(q+1,q+cur+1);
  121.         //binary search
  122.         int low=0,high=q[1].len+1;
  123.         while(low<high){
  124.             int mid=(low+high)/2;
  125.             if (check(mid))
  126.                 high=mid;
  127.             else low=mid+1;
  128.         }
  129.         return low;
  130.     }
  131. }g;
  132. int main(){
  133.     init();
  134.     int n=readint(),m=readint();
  135.     g.init(n);
  136.     for(int i=1;i<=n-1;i++){
  137.         int x=readint(),y=readint(),z=readint();
  138.         g.addedge(x,y,z);
  139.         g.addedge(y,x,z);
  140.     }
  141.     g.prepare();
  142.     //puts("WTF");
  143.     for(int i=1;i<=m;i++){
  144.         int u=readint(),v=readint();
  145.         g.addquery(u,v);
  146.     }
  147.     //puts("WTF");
  148.     printf("%d\n",g.get());
  149. }

知识共享许可协议
本作品采用知识共享署名-相同方式共享 4.0 国际许可协议进行许可。
本文链接：https://www.q234rty.top/2016/07/22/uoj150/

隐藏