最短路径树问题

最短路径树问题

时间限制: 1 Sec 内存限制: 128 MB
题目描述
给一个包含n个点，m条边的无向连通图。从顶点1出发，往其余所有点分别走一次并返回。
往某一个点走时，选择总长度最短的路径走。若有多条长度最短的路径，则选择经过的顶点序列字典序最小的那条路径（如路径A为1，32，11，路径B为1, 3, 2, 11，路径B字典序较小。注意是序列的字典序的最小，而非路径中节点编号相连的字符串字典序最小）。到达该点后按原路返回，然后往其他点走，直到所有点都走过。
可以知道，经过的边会构成一棵最短路径树。请问，在这棵最短路径树上，最长的包含K个点的简单路径长度为多长？长度为该最长长度的不同路径有多少条？

输入
第1行: 3个正整数n，m，K，表示有n个点m条边，要求的路径需要经过K个点。
接下来输入m行，每行三个正整数Ai,Bi,Ci (1<=Ai,Bi<=n,1<=Ci<=10000)，表示Ai和Bi间有一条长度为Ci的边。
数据保证输入的是连通的无向图。

输出
输出一行2个整数，以一个空格隔开.
第1个整数表示包含K个点的路径最长为多长
第2个整数表示这样的不同的最长路径有多少条。

样例输入
6 6 4
1 2 1
2 3 1
3 4 1
2 5 1
3 6 1
5 6 1

样例输出
3 4

【数据规模】
对于40%的数据n<=5000,m<=10000.
对于所有数据n<=30000, m<=60000, 2<=K<=n。
数据保证最短路径树上至少存在一条长度为K的路径。

来源
FJOI2014day1

题解

先用spfa跑出最短路网，然后在最短路网上对于每个节点按照孩子编号从小到大跑dfs，就可以得到题意描述中的那棵树。
对于这棵树，定义状态f[i][j]表示从i号点出发经过j个点的最长路径长度，g[i][j]表示最长路径的数量。
转移，分为子数内和跨越子数转移。
优化：在一棵子数内，一条路径只能是向下延伸或跨越2个子树，对于前者dfs解决，对于后者，这显然是一个可以分治的问题，用点分治可以把复杂度降到O(nlogn)即可。

代码

#include<iostream>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<string>
#include<cmath>
#include<algorithm>
#define N 45010
#define inf 1050000000
using namespace std;
int n,m,K,ans1,ans2,dep[N],dis[N],f[N],g[N];
int tot,lx[N],fx[N*4],k,la[N],ff[N*2],maxdep;
int q[N],flag[N],w[N],cnt,fa[N],size[N];
struct node{int a,b,c;}e[N*4],map[N*2];
struct wbs{
  int a,b;
  bool operator<(const wbs &x)
  const{return a<x.a;}
}t[N];
int next(int x){return ++x>30005?1:x;}

void add1(int a,int b,int c)
{
  e[++tot]=(node){a,b,c};fx[tot]=lx[a];lx[a]=tot;
  e[++tot]=(node){b,a,c};fx[tot]=lx[b];lx[b]=tot;
}

void add2(int a,int b,int c)
{
  map[++k]=(node){a,b,c};ff[k]=la[a];la[a]=k;
  map[++k]=(node){b,a,c};ff[k]=la[b];la[b]=k;
}

void spfa()
{
  for(int i=1;i<=n;i++)w[i]=inf;
  int l=1,r=2;q[1]=1;flag[1]=1;w[1]=0;
  while(l!=r)
  {
    int x=q[l];l=next(l);flag[x]=0;
    for(int a=lx[x];a;a=fx[a])
      if(w[e[a].b]>w[x]+e[a].c)
      {
        w[e[a].b]=w[x]+e[a].c;
        if(!flag[e[a].b])
          q[r]=e[a].b,flag[q[r]]=1,r=next(r);
      }
  }
}

void dfs(int x)
{
  flag[x]=1;int st=cnt+1,end;
  for(int a=lx[x];a;a=fx[a])
    if(w[e[a].b]==w[x]+e[a].c)
      t[++cnt].a=e[a].b,t[cnt].b=e[a].c;
  if(st>cnt)return;
  end=cnt;sort(t+st,t+end+1);
  for(int i=st;i<=end;i++)
    if(!flag[t[i].a])
      add2(x,t[i].a,t[i].b),dfs(t[i].a);
}

int find(int x)
{
  int l=1,r=2,res,num=inf;q[1]=x;flag[x]=1;fa[x]=0;
  while(l<r)
  {
    int x=q[l];w[x]=0;size[x]=1;l++;
    for(int a=la[x];a;a=ff[a])
      if(!flag[map[a].b])
        q[r]=map[a].b,flag[q[r]]=1,fa[q[r]]=x,r++;
  }
  if(r<K)return -1;
  for(int i=r-1;i;i--)
  {
    int x=q[i];flag[x]=0;
    if(fa[x])size[fa[x]]+=size[x],w[fa[x]]=max(w[fa[x]],size[x]);
    if(num>max(w[x],r-size[x]-1))num=max(w[x],r-size[x]-1),res=x;
  }
  return res;
}

void work(int S,int val)
{
  int l=1,r=2;q[1]=S;flag[S]=1;dis[S]=val;dep[S]=1;
  while(l<r)
  {
    int x=q[l];maxdep=max(maxdep,dep[x]);l++;
    if(dep[x]==K)break;
    for(int a=la[x];a;a=ff[a])
      if(!flag[map[a].b])
      {
        q[r]=map[a].b;flag[q[r]]=1;
        dis[q[r]]=dis[x]+map[a].c;
        dep[q[r]]=dep[x]+1;r++;
      }
  }
  for(int i=r-1;i;i--)
  {
    int x=q[i];flag[x]=0;
    if(!g[K-dep[x]])continue;
    if(f[K-dep[x]]+dis[x]==ans1)ans2+=g[K-dep[x]];
    if(f[K-dep[x]]+dis[x]>ans1)ans1=dis[x]+f[K-dep[x]],ans2=g[K-dep[x]];
  }
  for(int i=r-1;i;i--)
  {
    int x=q[i];
    if(dis[x]==f[dep[x]])g[dep[x]]++;
    if(dis[x]>f[dep[x]])f[dep[x]]=dis[x],g[dep[x]]=1;
  }
}

void solve(int x)
{
  int rt=find(x);maxdep=0;
  if(rt==-1)return;flag[rt]=1;
  for(int a=la[rt];a;a=ff[a])
    if(!flag[map[a].b])work(map[a].b,map[a].c);
  for(int i=1;i<=maxdep;i++)f[i]=0,g[i]=0;
  for(int a=la[rt];a;a=ff[a])
    if(!flag[map[a].b])solve(map[a].b);
}

int main()
{
  int a,b,c;
  scanf("%d%d%d",&n,&m,&K);K--;
  for(int i=1;i<=m;i++)
    scanf("%d%d%d",&a,&b,&c),add1(a,b,c);
  spfa();dfs(1);
  memset(flag,0,sizeof(flag));
  g[0]=1;solve(1);
  printf("%d %d\n",ans1,ans2);
  return 0;
}