UVALive6900 Road Repair（树的点分治）

题目大概说一棵树，树边有费用和收益两个属性，求一条收益和最大的路径满足费用和不超过C。

树上任意两点的路径都可以看成是过某一个子树根的路径，显然树分治。

治的时候要解决的一个问题是，找到费用小于等于某个数且收益最大的值。

这个很容易想到用线段树，不过不想写线段树。。

想了想，想到可以先排序，从小到大去找，之前找到哪现在就继续从那儿开始找，这样最多也就遍历一遍待查找数组，具体看代码。

两次排序占大头，最后时间复杂度是O(nlog²n)。

WA了一次，因为只考虑了两端都过根的路径，忽略了一端点是根的路径。。之前写树分治也是因为这个WA。。

 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 using namespace std;
 #define INF (1<<30)
 #define MAXN 22222
 struct Edge{
     int v,b,c,next;
 }edge[MAXN<<];
 int NE,head[MAXN];
 void addEdge(int u,int v,int b,int c){
     edge[NE].v=v; edge[NE].b=b; edge[NE].c=c; edge[NE].next=head[u];
     head[u]=NE++;
 }
 bool vis[MAXN];
 int size[MAXN];
 void getsize(int u,int fa){
     size[u]=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(v==fa || vis[v]) continue;
         getsize(v,u);
         size[u]+=size[v];
     }
 }
 int mm,cen;
 void getcen(int u,int fa,int &tot){
     int res=tot-size[u];
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(v==fa || vis[v]) continue;
         getcen(v,u,tot);
         res=max(res,size[v]);
     }
     if(res<mm){
         mm=res;
         cen=u;
     }
 }
 int getcen(int u){
     getsize(u,u);
     mm=INF;
     getcen(u,u,size[u]);
     return cen;
 }
 struct Rec{
     int b,c;
     bool operator<(const Rec &r)const{
         return c<r.c;
     }
 }ra[MAXN],rb[MAXN];
 int tot,an,bn;
 void dfs(int u,int fa,int benfit,int cost){
     rb[bn].b=benfit;
     rb[bn].c=cost;
     bn++;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(v==fa || vis[v]) continue;
         dfs(v,u,benfit+edge[i].b,cost+edge[i].c);
     }
 }
 int ans;
 void conqur(int u){
     an=;
     ra[].b=; ra[].c=;
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v]) continue;
         bn=;
         dfs(v,v,edge[i].b,edge[i].c);
         sort(ra,ra+an);
         sort(rb,rb+bn);
         int pa=an-,pb=;
         while(pb<bn){
             int mx=-;
             for(int j=pa; j>=; --j){
                 if(ra[j].c+rb[pb].c<=tot){
                     if(mx<ra[j].b+rb[pb].b){
                         mx=ra[j].b+rb[pb].b;
                         pa=j;
                     }
                 }
             }
             if(mx==-) break;
             ans=max(ans,mx);
             ++pb;
         }
         for(int j=; j<bn; ++j){
             ra[an++]=rb[j];
         }
     }
 }
 void divide(int u){
     u=getcen(u);
     vis[u]=;
     conqur(u);
     for(int i=head[u]; i!=-; i=edge[i].next){
         int v=edge[i].v;
         if(vis[v]) continue;
         divide(v);
     }
 }
 int main(){
     int t,n,a,b,c,d;
     scanf("%d",&t);
     while(t--){
         scanf("%d",&n);
         NE=;
         memset(head,-,sizeof(head));
         for(int i=; i<n; ++i){
             scanf("%d%d%d%d",&a,&b,&c,&d);
             addEdge(a,b,d,c);
             addEdge(b,a,d,c);
         }
         scanf("%d",&tot);
         ans=;
         memset(vis,,sizeof(vis));
         divide();
         printf("%d\n",ans);
     }
     return ;
 }