[BZOJ2117]Crash的旅游计划

Description

眼看着假期就要到了，Crash由于长期切题而感到无聊了，因此他决定利用这个假期和好友陶陶一起出去旅游。

Crash和陶陶所要去的城市里有N (N > 1) 个景点，Crash用正整数1到N给景点标号。

这些景点之间通过N - 1条无向道路相连，每条道路有一个长度，并且保证任意两个景点之间都有且仅有一条路径相连。

现在对于一个景点s，Crash和陶陶从s出发，然后访问一个景点序列{v0, v1, v2, … , vk}，

其中v0就是s，且vi-1和vi(0 < i ≤ k)之间有道路相连。

需要注意的是，陶陶和Crash访问的景点序列中不会只有景点s。

为了使旅程不显得乏味，在一个景点序列里他们不会重复走某条道路。

我们定义这个序列的旅游代价为经过道路的长度和。下面问题出现了：

陶陶：我们走一条景点数最多的景点序列吧。

Crash：倒，你想把我累死啊。

陶陶：谁叫你整天坐在电脑前面，不出来锻炼，这下子傻了吧，哈哈哈哈~~

Crash：不行，如果你非要走景点数最多的我就不陪你走了。

陶陶：笑喷油你很跳嘛！

Crash：这样吧，我们来写伸展树，如果我写的比你快，你就要听我的。

陶陶：这样不公平哎，我们来玩PES吧，当然你要让我选法国队，如果你输了你就要听我的。

Crash：倒，你这是欺负我，T_T~

陶陶：笑喷油好说话哎。

Crash：囧……

……

这样搞了半天，最终陶陶和Crash用很多次包剪锤决定出选择旅游代价第K小的景点序列。

不过呢Crash和陶陶还没确定开始旅行的景点s，因此他希望你对于每个景点i，计算从景点i开始的景点序列中旅游代价第K小的值。

Input

共N行。

第1行包含一个字符和两个正整数，字符为ABCD中的一个，用来表示这个测试数据的类型

（详见下面的数据规模和约定），另外两个正整数分别表示N和K (K < N),N<=100000

第2行至第N行，每行有三个正整数u、v和w (u, v ≤ N，w ≤ 10000)。

表示u号景点和v号景点之间有一条道路，长度为w。

输入文件保证符合题目的约定，即任意两个景点之间都有且仅有一条路径相连。

Output

共N行，每行有一个正整数。

第i行的正整数表示从i号景点开始的景点序列中旅游代价第K小的代价。

Sample Input

A 6 3
1 2 2
1 3 4
1 4 3
3 5 1
3 6 2

Sample Output

4
6
4
7
5
6
//样例1中输出对应的景点序列分别为：
1号景点是{1, 3}，2号景点是{2, 1, 3}，3号景点是{3, 1}，4号景点是{4, 1, 3}，5号景点是{5, 3, 1}，6号景点是{6, 3, 1}。
保证每个景点到1号景点需要经过的道路数不超过30

二分答案，然后点分树上二分$vector$判定

代码：

 #include<iostream>

 #include<cstdio>

 #include<cstring>

 #include<vector>

 #include<algorithm>

 #define M 100010

 using namespace std;

 int n,m,num,S,root,k;

 int deep[M],f[M],fa[M],sz[M],size[M];

 int head[M],dis[M],son[M],maxn[M],top[M];

 bool vis[M];

 struct point{int to,next,dis;}e[M<<];

 vector<int>S1[M],S2[M];

 void add(int from,int to,int dis) {

     e[++num].next=head[from];

     e[num].to=to;

     e[num].dis=dis;

     head[from]=num;

 }

 void dfs1(int x) {

     deep[x]=deep[f[x]]+,sz[x]=;

     for(int i=head[x];i;i=e[i].next) {

         int to=e[i].to;

         if(to==f[x]) continue;

         f[to]=x,dis[to]=dis[x]+e[i].dis;

         dfs1(to),sz[x]+=sz[to];

         if(sz[son[x]]<sz[to]) son[x]=to;

     }

 }

 void dfs2(int x,int tp) {

     top[x]=tp;

     if(son[x]) dfs2(son[x],tp);

     for(int i=head[x];i;i=e[i].next)

         if(e[i].to!=f[x]&&e[i].to!=son[x])

             dfs2(e[i].to,e[i].to);

 }

 int lca(int x,int y) {

     while(top[x]!=top[y]) {

         if(deep[top[x]]<deep[top[y]]) swap(x,y);

         x=f[top[x]];

     }

     return deep[x]<deep[y]?x:y;

 }

 int getdis(int x,int y) {

     return dis[x]+dis[y]-*dis[lca(x,y)];

 }

 void getroot(int x,int fa) {

     size[x]=;maxn[x]=;

     for(int i=head[x];i;i=e[i].next) {

         int to=e[i].to;

         if(fa==to||vis[to]) continue;

         getroot(to,x);size[x]+=size[to];

         maxn[x]=max(maxn[x],size[to]);

     }

     maxn[x]=max(maxn[x],S-size[x]);

     if(maxn[x]<maxn[root]) root=x;

 }

 void solve(int x,int ff) {

     fa[x]=ff;vis[x]=true;

     for(int i=head[x];i;i=e[i].next) {

         int to=e[i].to;

         if(vis[to]) continue;

         S=size[to],root=,getroot(to,x);

         solve(root,x);

     }

 }

 void update(int x) {

     S1[x].push_back();

     for(int i=x;fa[i];i=fa[i]) {

         int dt=getdis(x,fa[i]);

         S1[fa[i]].push_back(dt);

         S2[i].push_back(dt);

     }

 }

 int get1(int id,int d) {

     int l=,r=S1[id].size()-,ans=;

     while(l<=r) {

         int mid=(l+r)/;

         if(S1[id][mid]<=d) l=mid+,ans=mid+;

         else r=mid-;

     }

     return ans;

 }

 int get2(int id,int d) {

     int l=,r=S2[id].size()-,ans=;

     while(l<=r) {

         int mid=(l+r)/;

         if(S2[id][mid]<=d) l=mid+,ans=mid+;

         else r=mid-;

     }

     return ans;

 }

 int query(int x,int d) {

     int ans=get1(x,d);

     for(int i=x;fa[i];i=fa[i]) {

         int dt=getdis(fa[i],x);

         if(dt>d) continue;

         ans+=get1(fa[i],d-dt);

         ans-=get2(i,d-dt);

     }

     return ans;

 }

 int main() {

     char s[];scanf("%s",s);

     scanf("%d%d",&n,&k);k++;

     for(int i=;i<n;i++) {

         int a,b,c;scanf("%d%d%d",&a,&b,&c);

         add(a,b,c),add(b,a,c);

     }

     dfs1(),dfs2(,);

     maxn[]=S=n,getroot(,),solve(root,);

     for(int i=;i<=n;i++)

         update(i);

     for(int i=;i<=n;i++) {

         if(!S1[i].empty()) sort(S1[i].begin(),S1[i].end());

         if(!S2[i].empty()) sort(S2[i].begin(),S2[i].end());

     }

     for(int i=;i<=n;i++) {

         int l=,r=1e9,ans=1e9;

         while(l<=r) {

             int mid=(l+r)/;

             if(query(i,mid)>=k) ans=mid,r=mid-;

             else l=mid+;

         }

         printf("%d\n",ans);

     }

     return ;

 }