HDU4871 Shortest-path tree【最短路+点分治】

题意：给出一张图，要求从1点开始跑最短路，并以1为根生产一棵最短路树（长度相同找到字典序最小的），然后求出这个树上恰好经过k个点的最长路径，并输出数量。

从1点跑一遍最短路，然后dfs生产最短路生成树，然后点分治，找到重心之后对重心每条边算一次经过了i个点的最长路，然后还要用数组记录一下前面经过了i个点的最长路。。处理方法在讲点分治的论文上有。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<vector>
using namespace std;
const int MAXN=30010;
const int MAXE=60010;
const int INF=1<<29;
struct EDGE
{
	int v,next;
	int dist;
}edge[MAXE<<1],edge1[MAXE<<1];
struct Node
{
	int v,dis;
	Node(int x,int y)
	{
		v=x,dis=y;
	}
	bool operator < (const Node &rhs) const
	{
		return v>rhs.v;
	}
};
vector<Node> G[MAXN];
int head[MAXN],size;
int head1[MAXN],size1;
void init()
{
	memset(head,-1,sizeof(head));
	memset(head1,-1,sizeof(head1));
	size1=0;
	size=0;
}
void add_edge(int u,int v,int c)
{
	edge[size].v=v;
	edge[size].dist=c;
	edge[size].next=head[u];
	head[u]=size++;
}
void add_edge1(int u,int v,int c)
{
	edge1[size1].v=v;
	edge1[size1].dist=c;
	edge1[size1].next=head1[u];
	head1[u]=size1++;
}
struct HeapNode
{
	int u,d;
	HeapNode(int x,int y)
	{
		u=x,d=y;
	}
	bool operator < (const HeapNode &rhs) const
	{
		return d>rhs.d;
	}
};
int dis[MAXN],n;
bool vis[MAXN];
void dijstra(int s)
{
	for(int i=1;i<=n;i++)
		dis[i]=INF;
	priority_queue<HeapNode> q;
	for(int i=1;i<=n;i++)
			vis[i]=0;
	dis[s]=0;
	q.push(HeapNode(s,0));
	while(!q.empty())
	{
		HeapNode x=q.top();
		q.pop();
		int u=x.u;
		if(vis[u])
			continue;
		vis[u]=1;
		for(int i=head1[u];i!=-1;i=edge1[i].next)
		{
			int v=edge1[i].v;
			if(dis[v]>dis[u]+edge1[i].dist)
			{
				dis[v]=dis[u]+edge1[i].dist;
				q.push(HeapNode(v,dis[v]));
			}
		}
	}
}
void build_map(int u,int fa)
{
	vis[u]=1;
	for(int i=head1[u];i!=-1;i=edge1[i].next)
	{
		int v=edge1[i].v;
		if(v==fa)
			continue;
		if(vis[v])
			continue;
		if(dis[v]==dis[u]+edge1[i].dist)
		{
			add_edge(u,v,edge1[i].dist);
			add_edge(v,u,edge1[i].dist);
			build_map(v,u);
		}
	}
}
int k,root;
int siz[MAXN],num[MAXN],tot_size;
void get_root(int u,int fa)
{
	siz[u]=1;
	num[u]=0;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].v;
		if(vis[v]||v==fa)
			continue;
		get_root(v,u);
		siz[u]+=siz[v];
		num[u]=max(num[u],siz[v]);
	}
	num[u]=max(num[u],tot_size-num[u]);
	if(num[root]>num[u])
		root=u;
}
int dep[MAXN];
int dp[MAXN],cnt[MAXN],f1[MAXN],f2[MAXN];
void get_dep(int u,int fa,int nu)
{
	if(nu>k)
		return;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].v;
		if(v==fa||vis[v])
			continue;
		dep[v]=dep[u]+edge[i].dist;
		if(dep[v]>dp[nu])
		{
			dp[nu]=dep[v];
			cnt[nu]=1;
		}
		else if(dep[v]==dp[nu])
			cnt[nu]++;
		get_dep(v,u,nu+1);
	}
}
int ans,anscnt;
void get_num(int u,int val)
{
	dep[u]=val;
	dp[1]=dep[u];
	cnt[1]=1;
	get_dep(u,-1,2);
	for(int i=1;i<=k-1;i++)
	{
		if(dp[i]+f1[k-i-1]>ans)
		{
			ans=dp[i]+f1[k-i-1];
			anscnt=cnt[i]*f2[k-i-1];
		}
		else if(dp[i]+f1[k-i-1]==ans)
		{
			anscnt+=cnt[i]*f2[k-i-1];
		}
	}
	for(int i=1;i<=k;i++)
	{
		if(dp[i]>f1[i])
		{
			f1[i]=dp[i];
			f2[i]=cnt[i];
		}
		else if(dp[i]==f1[i])	//相同长度要累加起来
			f2[i]+=cnt[i];
		dp[i]=0;
	}
}
void get_size(int u,int fa)
{
	siz[u]=1;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].v;
		if(v==fa||vis[v])
			continue;
		get_size(v,u);
		siz[u]+=siz[v];
	}
}
void dfs(int u)
{
	vis[u]=1;
	for(int i=1;i<=tot_size;i++)
		f1[i]=dp[i]=f2[i]=0;
	f2[0]=1;
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].v;
		if(vis[v])
			continue;
		get_num(v,edge[i].dist);
	}
	for(int i=head[u];i!=-1;i=edge[i].next)
	{
		int v=edge[i].v;
		if(vis[v])
			continue;
		root=0;
		get_size(v,-1);
		tot_size=siz[v];
		get_root(v,-1);
		dfs(root);
	}
}
int main()
{
	int t,m,u,v,c;
	scanf("%d",&t);
	while(t--)
	{
		scanf("%d%d%d",&n,&m,&k);
		init();
		for(int i=1;i<=n;i++)
		{
			G[i].clear();
			num[i]=0;
		}
		while(m--)
		{
			scanf("%d%d%d",&u,&v,&c);
			G[u].push_back(Node(v,c));
			G[v].push_back(Node(u,c));
		}
		for(int i=1;i<=n;i++)
		{
			sort(G[i].begin(),G[i].end());
			for(int j=0;j<(int)G[i].size();j++)
			{
				add_edge1(i,G[i][j].v,G[i][j].dis);
			}
		}
		dijstra(1);
		for(int i=1;i<=n;i++)
			vis[i]=0;
		build_map(1,-1);
		for(int i=1;i<=n;i++)
			vis[i]=0;
		root=0;
		tot_size=n;
		num[root]=INF;
		ans=anscnt=0;
		get_root(1,-1);
		dfs(root);
		printf("%d %d\n",ans,anscnt);
	}
	return 0;
}
/*
2
7 6 3
1 2 1
2 3 2
3 4 1
4 5 1
5 6 1
6 7 1
*/