4016: [FJOI2014]最短路径树问题

Description

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

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

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

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

Input

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

Output

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

Sample Input

6 6 4
1 2 1
2 3 1
3 4 1
2 5 1
3 6 1
5 6 1

Sample Output

3 4

HINT

对于所有数据n<=30000,m<=60000，2<=K<=n。数据保证最短路径树上至少存在一条长度为K的路径。

Source

点分治

首先我们考虑如何求出最短路径树 我们先找出最短路DAG，然后在最短路DAG上dfs即可

然后点分治统计答案即可

由于这题输出方案 所以就有一些细节

比如更新答案时 要判断方案数*方案数是否为0 否则会统计到错误答案

对于我的代码 即hf[]*hg[]!=0

然后中间的注释就是debug用的了 可以参考

http://blog.youkuaiyun.com/wxh010910/article/details/53471181

[cpp]  view plain  copy

1. #include<bits/stdc++.h>  
2.   
3. using namespace std;  
4.   
5. const int maxn=30030;  
6.   
7. int n,m,K,cnt,ans,mxdep;  
8.   
9. long long tot;  
10.   
11. int dist[maxn],head[maxn],size[maxn],dis[maxn],dep[maxn];  
12.   
13. int f[maxn],g[maxn],fa[maxn],hf[maxn],hg[maxn];  
14.   
15. bool inq[maxn],vis[maxn];  
16.   
17. vector <pair<int ,int > > G[maxn];  
18.   
19. struct edge  
20. {  
21.     int to,nxt,val;  
22. }e[maxn<<1],E[maxn<<2];  
23.   
24. inline void add(int x,int y,int w)  
25. {  
26.     E[++cnt].to=y;  
27.     E[cnt].nxt=head[x];  
28.     head[x]=cnt;  
29.     E[cnt].val=w;  
30. }  
31.   
32. inline void Addedge(int x,int y,int w)  
33. {  
34.     e[++cnt].to=y;  
35.     e[cnt].nxt=head[x];  
36.     head[x]=cnt;  
37.     e[cnt].val=w;  
38. }  
39.   
40. inline void addedge(int x,int y,int w) { Addedge(x,y,w); Addedge(y,x,w); }  
41.   
42. inline void spfa()  
43. {  
44.     memset(dist,0x7f,sizeof(dist));  
45.     queue <int > q;  
46.     q.push(1);  
47.     dist[1]=0;  
48.     while(!q.empty())  
49.     {  
50.         int x=q.front();q.pop();inq[x]=0;  
51.         for(int i=head[x];i;i=E[i].nxt)  
52.         {  
53.             int y=E[i].to;  
54.             if(dist[y]>dist[x]+E[i].val)  
55.             {  
56.                 dist[y]=dist[x]+E[i].val;  
57.                 if(!inq[y]) inq[y]=1,q.push(y);  
58.             }  
59.         }  
60.     }  
61.     for(int x=1;x<=n;x++)  
62.         for(int i=head[x];i;i=E[i].nxt)  
63.             if(dist[E[i].to]==dist[x]+E[i].val)  
64.                 G[x].push_back(make_pair(E[i].to,E[i].val));  
65.     for(int i=1;i<=n;i++) sort(G[i].begin(),G[i].end());  
66.     memset(head,0,sizeof(head));  
67. }  
68.   
69. void dfs(int x)  
70. {  
71.     vis[x]=1;  
72.     for(int i=0;i<G[x].size();i++)  
73.         if(!vis[G[x][i].first])  
74.             addedge(x,G[x][i].first,G[x][i].second),dfs(G[x][i].first);  
75. }  
76.   
77. void getroot(int x,int Size,int &cg)  
78. {  
79.     bool flag=true;  
80.     size[x]=1;  
81.     for(int i=head[x];i;i=e[i].nxt)  
82.     {  
83.         int y=e[i].to;  
84.         if(!vis[y]&&fa[x]!=y)  
85.         {  
86.             fa[y]=x;  
87.             getroot(y,Size,cg);  
88.             size[x]+=size[y];  
89.             if(size[y]>Size/2) flag=false;  
90.         }  
91.     }  
92.     if(size[x]<Size/2) flag=false;  
93.     if(flag) cg=x;  
94. }  
95.   
96. void dfs2(int x)  
97. {  
98.     size[x]=1;  
99.     for(int i=head[x];i;i=e[i].nxt)  
100.     {  
101.         int y=e[i].to;  
102.         if(!vis[y]&&fa[x]!=y)  
103.         {  
104.             fa[y]=x;  
105.             dep[y]=dep[x]+1;  
106.             dis[y]=dis[x]+e[i].val;  
107.             mxdep=max(mxdep,dep[y]);  
108.             if(f[dep[y]]<dis[y])  
109.                 f[dep[y]]=dis[y],hf[dep[y]]=1;  
110.             else if(f[dep[y]]==dis[y])  
111.                 hf[dep[y]]++;  
112.             dfs2(y);  
113.             size[x]+=size[y];  
114.         }  
115.     }  
116. }  
117.   
118. void solve(int x,int Size)  
119. {  
120. //  printf("-------------------------------------------\n");  
121.     int cg,mx=0;  
122.     f[x]=0;  
123.     getroot(x,Size,cg);  
124.     vis[cg]=1;size[fa[cg]]=Size-size[cg];fa[cg]=0;  
125.     hg[0]=1;  
126. //  printf("[%d]\n",cg);  
127.     for(int i=head[cg];i;i=e[i].nxt)  
128.         if(!vis[e[i].to])  
129.         {  
130.             dis[e[i].to]=e[i].val;  
131.             dep[e[i].to]=1;  
132.             fa[e[i].to]=cg;  
133.             mxdep=1;  
134.             f[1]=e[i].val,hf[1]++;  
135.             dfs2(e[i].to);  
136.             mx=max(mx,mxdep);  
137.             for(int j=0;j<=mxdep;j++)  
138.             {  
139.                 if(hf[j]&&hg[K-1-j])  
140.                 {  
141.                     if(ans<f[j]+g[K-1-j])   
142.                         ans=f[j]+g[K-1-j],tot=1ll*hf[j]*hg[K-1-j];  
143.                     else if(ans==f[j]+g[K-1-j])  
144.                         tot+=1ll*hf[j]*hg[K-1-j];  
145. //                  cout<<ans<<" "<<tot<<" "<<j<<" "<<f[j]<<" "<<g[K-1-j]<<" "<<hf[j]<<" "<<hg[K-1-j]<<endl;  
146.                 }  
147.             }  
148. //          putchar(10);  
149.             for(int j=0;j<=mxdep;j++)  
150.             {  
151.                 if(f[j]>g[j])  
152.                     g[j]=f[j],hg[j]=hf[j];  
153.                 else if(f[j]==g[j])  
154.                     hg[j]+=hf[j];  
155.                 f[j]=0,hf[j]=0;  
156.             }  
157.         }  
158.     for(int i=0;i<=mx;i++) g[i]=0,hg[i]=0;  
159.     for(int i=head[cg];i;i=e[i].nxt) if(!vis[e[i].to]) solve(e[i].to,size[e[i].to]);  
160. }  
161.   
162. int main()  
163. {  
164.     scanf("%d%d%d",&n,&m,&K);  
165.     for(int i=1;i<=m;i++)  
166.     {  
167.         int x,y,w;  
168.         scanf("%d%d%d",&x,&y,&w);  
169.         add(x,y,w);add(y,x,w);  
170.     }  
171.     spfa();  
172.     dfs(1);  
173.     memset(vis,0,sizeof(vis));  
174.     solve(1,n);  
175.     return printf("%d %lld\n",ans,tot),0;  
176. }