BZOJ 4016 最短路径树问题 [最短路+树分治]

Description

给一个包含n个点，m条边的无向连通图。从顶点1出发，往其余所有点分别走一次并返回。

往某一个点走时，选择总长度最短的路径走。若有多条长度最短的路径，则选择经过的顶点序列字典序最小的那条路径(如路径A为1,32,11，路径B为1,3,2,11，路径B字典序较小。注意是序列的字典序的最小，而非路径中节点编号相连的字符串字典序最小)。到达该点后按原路返回，然后往其他点走，直到所有点都走过。

可以知道，经过的边会构成一棵最短路径树。请问，在这棵最短路径树上，最长的包含K个点的简单路径长度为多长？长度为该最长长度的不同路径有多少条？

这里的简单路径是指：对于一个点最多只经过一次的路径。不同路径是指路径两端端点至少有一个不同，点A到点B的路径和点B到点A视为同一条路径。

题意：给出一图，边有权，先根据此图建最短路径树（保证每个点的父节点字典序最小），然后询问树上恰好经过K个点的路径中，边权和的最大值，以及达到最大值的路径数。

解法：树形DP时，因为K很大，发现很难处理恰好K个点这个问题，考虑树分治，分治后，计算经过分治重心的路径，记maxval[x]，为子树中经过x个点的最大值，那么枚举每一个点，根据此点的深度来计算需要的x，将maxval[X]与此点的dis[X]求和更新答案即可。（枚举的时候需要保证前面maxval[]数组中的数据，与当前点不在同一个重心儿子的子树中）

代码：（有一个小优化，若当前分治子树的节点数<K，那么可以直接返回，不再继续分治）

#include<stdio.h>
#include<string.h>
#include<algorithm>
#include<math.h>
#include<iostream>
#include<stdlib.h>
#include<set>
#include<map>
#include<queue>
#include<vector>
#include<bitset>
#pragma comment(linker, "/STACK:1024000000,1024000000")
template <class T>
bool scanff(T &ret){ //Faster Input
    char c; int sgn; T bit=0.1;
    if(c=getchar(),c==EOF) return 0;
    while(c!='-'&&c!='.'&&(c<'0'||c>'9')) c=getchar();
    sgn=(c=='-')?-1:1;
    ret=(c=='-')?0:(c-'0');
    while(c=getchar(),c>='0'&&c<='9') ret=ret*10+(c-'0');
    if(c==' '||c=='\n'){ ret*=sgn; return 1; }
    while(c=getchar(),c>='0'&&c<='9') ret+=(c-'0')*bit,bit/=10;
    ret*=sgn;
    return 1;
}
#define inf 1073741823
#define llinf 4611686018427387903LL
#define PI acos(-1.0)
#define lth (th<<1)
#define rth (th<<1|1)
#define rep(i,a,b) for(int i=int(a);i<=int(b);i++)
#define drep(i,a,b) for(int i=int(a);i>=int(b);i--)
#define gson(i,root) for(int i=ptx[root];~i;i=ed[i].next)
#define tdata int testnum;scanff(testnum);for(int cas=1;cas<=testnum;cas++)
#define mem(x,val) memset(x,val,sizeof(x))
#define mkp(a,b) make_pair(a,b)
#define findx(x) lower_bound(b+1,b+1+bn,x)-b
#define pb(x) push_back(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;

#define NN 30030
#define MM 60060

int ptx[NN],lnum;
int n,m,k;
int dis[NN],dn;
bool vis[NN];
int fa[NN],w[NN];

struct edge{
    int v,next,w;
    edge(){}
    edge(int v,int next,int w){this->v=v;this->next=next;this->w=w;}
}ed[MM*2];
void addline(int x,int y,int w){
    ed[lnum]=edge(y,ptx[x],w);
    ptx[x]=lnum++;
}
void init(){
    lnum=0;
    rep(i,1,n)ptx[i]=-1,vis[i]=0;
}

struct node{
    int idx,val;
    node(){}
    node(int idx,int val){this->idx=idx;this->val=val;}
    bool operator <(node const temp)const{return val>temp.val;}
};
priority_queue<node> q;
void getmindis(int x){
    while(!q.empty())q.pop();
    rep(i,1,n)dis[i]=inf,vis[i]=0;
    dis[x]=0;vis[x]=1;
    q.push(node(x,0));
    rep(i,1,n){
        gson(j,x){
            int y=ed[j].v;
            if(vis[y])continue;
            if(dis[x]+ed[j].w<dis[y]){
                dis[y]=dis[x]+ed[j].w;
                q.push(node(y,dis[y]));
                fa[y]=x;
                w[y]=ed[j].w;
            }
            else if(dis[x]+ed[j].w==dis[y])fa[y]=min(fa[y],x),w[y]=ed[j].w;
        }
        while(!q.empty()&&vis[q.top().idx])q.pop();
        if(q.empty())break;
        x=q.top().idx;
        vis[x]=1;
        q.pop();
    }
}

int sz[NN],maxv[NN],maxval,len[NN],ln;
int center;
int getsize(int x,int fa){
    sz[x]=1;
    gson(i,x){
        int y=ed[i].v;
        if(y==fa||vis[y])continue;
        sz[x]+=getsize(y,x);
    }
    return sz[x];
}
int getcenter(int r,int x,int fa){
    maxv[x]=0;
    gson(i,x){
        int y=ed[i].v;
        if(y==fa||vis[y])continue;
        getcenter(r,y,x);
        maxv[x]=max(maxv[x],sz[y]);
    }
    maxv[x]=max(maxv[x],sz[r]-sz[x]);
    if(maxv[x]<maxval)maxval=maxv[x],center=x;
}

int anslen,anscot;
struct node2{
    int dis,len,idx;
}dx[NN];


int getdis(int r,int x,int fa,int d,int l){
    if(l<k){
    dn++;
    dx[dn].dis=d;
    dx[dn].len=l;
    dx[dn].idx=r;
    gson(i,x){
        int y=ed[i].v;
        if(y==fa||vis[y])continue;
        getdis(r,y,x,d+ed[i].w,l+1);
    }
}
}

int cot[NN];
int calc(int x){
    dn=0;
    gson(i,x){
        int y=ed[i].v;
        if(vis[y])continue;
        getdis(y,y,0,ed[i].w,1);
    }
    maxv[0]=0;
    cot[0]=1;
    rep(i,1,dn)cot[i]=maxv[i]=0;
    rep(i,1,dn){
        if(i==1||dx[i].idx!=dx[i-1].idx){
            rep(j,i,dn){
                if(dx[j].idx!=dx[i].idx)break;
                if(dx[j].len<k&&cot[k-dx[j].len-1]){
                    if(dx[j].dis+maxv[k-dx[j].len-1]>anslen){
                        anslen=dx[j].dis+maxv[k-dx[j].len-1];
                        anscot=cot[k-dx[j].len-1];
                    }
                    else if(dx[j].dis+maxv[k-dx[j].len-1]==anslen){
                        anscot+=cot[k-dx[j].len-1];
                    }
                }
            }
        }
        if(maxv[dx[i].len]<dx[i].dis){
            maxv[dx[i].len]=dx[i].dis;
            cot[dx[i].len]=1;
        }
        else if(maxv[dx[i].len]==dx[i].dis)cot[dx[i].len]++;
    }
}
void solve(int x){
    maxval=inf;
    getsize(x,0);
    if(sz[x]<k)return; //优化加速
    getcenter(x,x,0);
    vis[center]=true;
    calc(center);
    gson(i,center){
        int y=ed[i].v;
        if(vis[y])continue;
        solve(y);
    }
}


int main(){
    scanff(n);
    scanff(m);
    scanff(k);
    init();
    rep(i,1,m){
        int x,y,w;
        scanff(x);
        scanff(y);
        scanff(w);
        addline(x,y,w);
        addline(y,x,w);
    }
    getmindis(1);
    init();
    rep(i,2,n){
        addline(i,fa[i],w[i]);
        addline(fa[i],i,w[i]);
    }
    anslen=0;
    anscot=0;
    solve(1);
    printf("%d %d\n",anslen,anscot);
    return 0;
}
/*
8 7 2
1 2 3
1 3 2
2 4 2
2 5 1
5 8 1
3 6 3
3 7 3
*/