spoj 1825. Free tour II 基于树的点分治

题目大意

　　一颗含有N个顶点的树,节点间有权值, 节点分为黑点和白点.问题是 找一条黑点数量不超过K个的最大路径.

 

解题思路:

　　因为路径只有 过根节点以及不过根节点, 所以我们可以通过找寻树重心分治下去.

　　问题就退化成了处理:

　　　　对于当前以 x 为根的树, 其最大路径

　　　　对于X的所有直接子节点, 定义函数 G( I, J ) 表示子节点 I为根的树不超过J个黑点的最大路径.

　　　　定义函数 dep( i ) 表示以 i为根的树,最多黑点数量.

　　　　则结果为 ans = MAX{ G(u,L1) + G(v,L2) }    ( u != v, 且 L1+L2 <= K - (当前根节点x为黑点则为1,否则为0)  )

　　　　或者 ans = MAX{ G( i, j ) }  这个是当不过根节点的情况.

　　因为 N = 200000 , 两两子节点枚举肯定TLE.

　　我们可以构造一个函数 F( j ), 表示 [1-j] 个黑点的最大路径值

　　对于 以X为根的树, 其子节点 v树, 的函数为 G( v, dep[v] )

　　枚举  dep[i] , 然后 结果即为 MAX{ ans, G(v,dep[i] + F( K-dep[i] )  }   

　　因为路径与子节点顺序无关,我们可以将其以 黑点数量dep 排序. 

　　F( v ) 即为左边 [1-v]个子节点合并的状态.

　　G( v ) 即为当前字节点v节点的状态.

　　处理完当前子节点v后, 合并其进入到F中即可.

　　要特别注意, 虽然边权有负数, 我们可以只取一个顶点的路径, 所以结果最小为0 .

　　所以 ans 初始化要为 0, 不可为无穷小

　　详细见代码注释及其分析

注释代码

#include<iostream>

#include<cstdio>

#include<cstring>

#include<string.h>

#include<math.h>

#include<algorithm>

#include<vector>

using namespace std;

const int maxn=200100;

const int INF=2000100010;

struct edge

{

       int u,v,val,next;

}et[maxn*2];

bool was[maxn];

int has[maxn];

int eh[maxn],tot;

bool cur[maxn];

int f[maxn],g[maxn];

void add(int u,int v,int val)

{

       et[tot].u=u;et[tot].v=v;et[tot].val=val;

       et[tot].next=eh[u];eh[u]=tot;tot++;

}

void addedge(int u,int v,int val)

{

       add(u,v,val);add(v,u,val);

}

int n,K,m;

int mi,hasnode;

int min(int a,int b) {return a<b?a:b;}

int max(int a,int b) {return a>b?a:b;}

void getroot(int x,int fa,int &r) //treedp找重心

{

       has[x]=1; //has[x]存储以x为根节点的子树,节点数量和

       int ma=0; //x的最大子树节点数量

       for(int i=eh[x];i!=-1;i=et[i].next)

       {

              if(et[i].v==fa||cur[et[i].v]) continue;

              getroot(et[i].v,x,r);

              has[x]+=has[et[i].v];

              if(has[et[i].v]>ma) ma=has[et[i].v];

       }

       if(ma<hasnode-has[x]) ma=hasnode-has[x];

       if(ma<mi) {mi=ma;r=x;}

}

int hs;

void gettn(int x,int fa)   //数子结点的个数，顺便数埋子结点是“黑”的个数

{

       hasnode++;

       if(was[x]) hs++;

       for(int i=eh[x];i!=-1;i=et[i].next)

       {

              if(et[i].v==fa||cur[et[i].v]) continue;

              gettn(et[i].v,x);

       }

}

void getg(int x,int fa,int h,int val)   //对x为根结点的树，求函数g

{

       if(g[h]<val) g[h]=val;

       for(int i=eh[x];i!=-1;i=et[i].next)

       {

              int v=et[i].v;

              if(fa==v||cur[v]) continue;

              if(was[v]) getg(v,x,h+1,val+et[i].val);

              else getg(v,x,h,val+et[i].val);

       }

}

struct tt   //纯粹为了sort开的结构体

{

       int v,han; // v为子树根, han为子树黑点数量

       int beval; // 子树v到其根节点边权

}tb[maxn*4];

int cmp(tt a,tt b)

{

       return a.han<b.han;//按黑点数量从小到大排序

}

int ans;

void play(int x,int fa,int rec) // x重心根节点，fa父节点, 存储信息开始下标rec

{

       int i,j,k,hrec=rec; //tb[] 中 rec~hrec是存储了当前所有子结点的缓冲区。

       for(i=eh[x];i!=-1;i=et[i].next)

       {

              int v=et[i].v;

              if(fa==v||cur[v]) continue;

             

              //初始化子树v的节点数量hasnode, 辅助变量mi, 黑点数量 hs

              hasnode=0;mi=INF;hs=0; 

              

              int root; //重心

              

              // 统计子树v,节点总数hasnode, 黑点总数hs 

              gettn(v,x);

             

              // 寻找子树v的重心 root  

              getroot(v,x,root); 

              

              // 存储子树信息

              // han 为子树v黑点数量

              // v 为子树根名

              // beval 为子树v到根节点x的权值

              // 对于当前以x为根的树，其保存的区间 [rec, hrec] 为这一颗树上所有子树的信息

             

              tb[hrec].han=hs;tb[hrec].v=v;  

              tb[hrec].beval=et[i].val;hrec++;

              cur[root]=1; //标记已找出重心root

              play(root,x,hrec); //递归子树root,其根节点为x,使用数组下标从hrec开始

             

              //回溯回来后，需要处理当前子树，当前子树内的标记需要撤销

              cur[root]=0; //回溯,取消标记重心root

       }                                 //直到以上的分治步骤都和PKU 1741的TREE差不多。

       

       //将x的所有子节点按其对应子树黑点数量,从小到大,排序 

       sort(tb+rec,tb+hrec,cmp); 

       

       

       int now=j;

       int kk=K; //当前子树内路径最多黑点数

       if(was[x]) kk--;    //注意如果根是黑点K--

       int ft=-1;   //当前f函数的大小

       

       //遍历根节点x的所有子节点,每个子节点保存了其到根节点长度, 以当前子节点为根的子数最多黑点数量

       // han 为子树v黑点数量

       // v 为子树根名

       // beval 为子树v到根节点x的权值

       // 对于当前以x为根的树，其保存的区间 [rec, hrec] 为这一颗树上所有子树的信息

       for(i=rec;i<hrec;i++) 

       {

              int v=tb[i].v; //子节点

              int hasn=tb[i].han; //子树中最大黑点数量

              if(fa==v||cur[v]) continue;

             

              //初始化g，g[i]表示当前子树小于等于j个黑点的最大路径值

              for(j=0;j<=hasn;j++) g[j]=-INF;

             

              //使用递归函数getg，递归获取 以v为根，父节点为x 的子树 

              // 从x节点到 子树v上任意节点 只有i个黑点的最大路径值 

              if(was[v]) getg(v,x,1,tb[i].beval);

              else       getg(v,x,0,tb[i].beval);

             

              // 每次子树v时，初始化ma为无穷小，用来更新g函数

              int ma=-INF;

              if(i==rec)   //一开始f没东西，赋初值。

              {

                     for(j=0;j<=hasn;j++) // 枚举黑点数量

                     {

                            //若j大于最多节点数量k时

                            if(j>kk) break;

                            ma=max(ma,g[j]);

                            

                            f[j]=ma; // f[j]表示 [1,j]个黑点的最大路径值 

                     }

                     // 当前黑点数量函数值 f的最大值 

                     ft=min(hasn,kk);

              } 

              else

              {

                     for(j=0;j<=hasn;j++)   // 找：以v左边的子树和v的子树之间，过根结点的路径。

                     {

                            // 若当前黑点数量j 大于最大要求黑点数量kk 

                            if(j>kk) break;

                           

                            // 若v子树中j个黑点的最大路径，属于最大路径，

                            // 则此时，还可包含 最多temp个黑点

                            int temp=kk-j; 

                            // 若此时 可放置黑点数量多余 已有数量ft,则放置ft即可    

                            if(temp>ft) temp=ft;

                            

                            // 若 子树v中包含j个黑点的最大路径等于无穷小，或 左边树temp黑点最大路径小于无穷小则 不纳入计算

                            if(f[temp]==-INF||g[j]==-INF) continue;

                          

                            // 最终结果与当前组合取最值

                            ans=max(ans,g[j]+f[temp]);

                     }

                    

                     

                     //把v的子树合并进去左边的所有子树中。 

                     for(j=0;j<=hasn;j++) 

                     {

                            // 若当前黑点数量多与 最大容量则结束 

                            if(j>kk) break;

                           

                            ma=max(ma,g[j]);

                            //注意，这里只有当 左边子树的黑点数量大于目前子树v此时黑点j的时候     

                            if(ft>=j) ma=max(ma,f[j]);

                            

                            //将子树v合并到 左边子树中去，更新 前j个黑点最大路径值    

                            f[j]=ma;

                     }

                    

                     // 因为首先将所有子节点依据黑点数量从小到大排序了，所以我们处理每个新的子树时

                     // 左边集合，黑点数上界为 min( hasn, kk )

                     ft=min(hasn,kk);

              }

       }

       if(ft>=0) ans=max(ans,f[min(ft,kk)]);

}

int main()

{

       int i,j,k;

//     freopen("in.txt","r",stdin);

       scanf("%d%d%d",&n,&K,&m);

       for(i=0;i<=n;i++) {was[i]=cur[i]=0;eh[i]=-1;} //初始化，was[i]黑点，cur[i]目前根节点,eh[i]链表头

       tot=0; 

       for(i=0;i<m;i++)

       {

              int temp;

              scanf("%d",&temp);was[temp]=1; //标记黑点

       }

       for(i=0;i<n-1;i++)

       {

              int u,v,val;

              scanf("%d%d%d",&u,&v,&val);

              addedge(u,v,val); //静态链接添加E( u, v, val )

       }

       mi=INF;   //辅助变量,用于寻找重心 

       int root;    //重心

       hasnode=n;getroot(1,0,root); // hasnode当前子树总节点数量 , 函数getroot获取重心，其中root为引用

       cur[root]=1; // 标记已选重心

       ans=0;    //初始化ans

       play(root,0,0); //求以root为根的子数，不超过K个黑点的最大路径长度

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

       return 0;

}

 

解题代码

View Code

#include<stdio.h>

#include<string.h>

#include<stdlib.h>

#include<iostream>

#include<algorithm>

using namespace std;

typedef long long LL;



#define MAX(a,b) (a)>(b)?(a):(b)

#define MIN(a,b) (a)<(b)?(a):(b)

const int N = 200100;

const int inf = 0x7fffffff;



struct Edge{

    int v, c, nxt;

}edge[N<<2];



int head[N], idx;

int n, m, K;



struct node{

    int sum, max;

}p[N];

struct tree{

    int h, v, c;

    bool operator < (tree tmp) const{

        return h < tmp.h;    

    }

}Q[N<<2];

int G[N], F[N], ans;

int black[N];

int Maxval, hasnode, dep;

bool cur[N];





void addedge( int u, int v, int c )

{

    edge[idx].v = v; edge[idx].c = c; 

    edge[idx].nxt = head[u]; head[u] = idx++;



    edge[idx].v = u; edge[idx].c = c;

    edge[idx].nxt = head[v]; head[v] = idx++;

}

void Input()

{

    memset( head, 0xff, sizeof(head) );

    idx = 0;

    memset( black, 0, sizeof(black) );    

    int u, v, c;

    for(int i = 0; i < m; i++)

    {

        scanf("%d", &u);

        black[u] = 1;

    }

    for(int i = 0; i < n-1; i++)

    {

        scanf("%d%d%d",&u,&v,&c);

        addedge( u, v, c );

    }

}



void GetRoot( int u, int pre, int &rt )

{

    p[u].sum = 1; p[u].max = 0;    

    for(int i = head[u]; ~i; i = edge[i].nxt )

    {

        int v = edge[i].v;

        if( (v!=pre) && (!cur[v]) )

        {

            GetRoot( v, u, rt );

            p[u].max = MAX( p[u].max, p[v].sum );

            p[u].sum += p[v].sum;

        }

    }

    p[u].max = MAX( p[u].max, hasnode-p[u].sum );

    if( p[u].max < Maxval )

    {

        Maxval = p[u].max;

        rt = u;

    }

}

void GetHasnode( int u,int pre )

{

    dep += black[u];

    hasnode++;

    for(int i = head[u]; ~i; i = edge[i].nxt )

    {

        int v = edge[i].v;

        if( (v!=pre) && (!cur[v]) )

            GetHasnode( v, u ); 

    }

}

void GetG( int u, int pre, int hs, int c )

{

    G[hs] = MAX( G[hs], c );

    for(int i = head[u]; ~i; i = edge[i].nxt )

    {

        int v = edge[i].v;

        if( (v!=pre) && (!cur[v]) )

            GetG( v, u, hs+black[v], c+edge[i].c );    

    }

}

void solve(int x, int pre, int rec)

{

    int hrec = rec;

    int kk = K - black[x];



    for(int i = head[x]; ~i; i = edge[i].nxt )

    {

        int v = edge[i].v;

        if( (v != pre) && (!cur[v]) )

        {

            // init     

            hasnode = 0; Maxval = inf; dep = 0; 

            int rt;

            

            // Get hasnode and dep;

            GetHasnode( v, x );

            GetRoot( v, x, rt );

            // save the child informations    

            Q[hrec].h = dep; Q[hrec].v = v; Q[hrec++].c = edge[i].c;

        

            cur[rt] = true;

            solve( rt, x, hrec );

            cur[rt] = false;

        }

    }

    sort( Q+rec, Q+hrec );



    //test

    //printf("rt = %d\n", x );

    int fuck , maxdep = -1;

    for(int i = rec; i < hrec; i++)

    {

        int v = Q[i].v, hs = Q[i].h;    

        if( (v==pre) || (cur[v]) ) continue;    

        for(int j = 0; j <= hs; j++)

            G[j] = -inf;

        fuck = -inf;

        //test

        //printf("v = %d, hs = %d\n", v, hs );    

        GetG( v, x, black[v], Q[i].c );

        //test

        //for(int j = 0; j <= hs; j++)

        //    printf("%d ", G[j] ); printf("\n\n");

        if( i == rec )

        {//first init F function

            for(int j = 0; j <= hs; j++)

            {

                if( j > kk ) break;

                fuck = MAX( fuck, G[j] );         

                F[j] = fuck;    

            }

            maxdep = MIN( hs, kk );    

        }

        else{

            // Get the max loads black point less than kk    

            for(int j = 0; j <= hs; j++)

            {

                if( j > kk ) break;

                int tmp = kk-j;

                if( tmp > maxdep ) tmp = maxdep;

                if( (G[j]==-inf) || (F[tmp]==-inf) ) continue;    

                ans = MAX( ans, G[j]+F[tmp] );

            }

            // union

            for(int j = 0; j <= hs; j++)

            {

                if( j > kk ) break;

                fuck = MAX( fuck, G[j] );

                if( j <= maxdep ) fuck = MAX( fuck, F[j] );    

                F[j] = fuck;    

            }

            maxdep = MIN( hs, kk );    

        }    

    }

    // only one child's way get ans 

    if( maxdep >= 0 ) ans = MAX( ans, F[ MIN(maxdep,kk) ] );



    //getchar();getchar();

}

int main()

{

    scanf("%d%d%d", &n,&K,&m); 

    {

        Input();

        

        int rt;

        Maxval = inf;     

        hasnode = n;

        GetRoot( 1, 0, rt );    

        memset(cur,0,sizeof(cur));

        cur[rt] = true;



        ans = 0;

        solve( rt, 0, 0 );        

        

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

    }

    return 0;

}