BZOJ4016【最短路】【点分治】

/* I will wait for you */

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <string>
#define make(a,b) make_pair(a,b)
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef map<int, int> mii;

const int maxn = 100010;
const int maxm = 1010;
const int maxs = 26;
const int inf = 0x3f3f3f3f;
const int P = 1000000007;
const double error = 1e-9;

inline ll read()
{
	ll x = 0, f = 1; char ch = getchar();
	while (ch > '9' || ch < '0' )
		f = (ch == '-' ? -1 : 1), ch = getchar();
	while (ch <= '9' && ch >= '0')
		x = x * 10 + ch - '0', ch = getchar();
	return f * x;
}

struct edge
{
	int v, w, next;
} e[maxn * 2];

int n, m, cnt, sum, root, head[maxn], deep[maxn], del[maxn],
    size[maxn], val[maxn], K, _ans[2], g[maxn][2], 
    f[maxn][2], dis[maxn], vis[maxn], _max[maxn];

priority_queue<pii, vector<pii>, greater<pii> > q, _next[maxn];

void insert(int u, int v, int w)
{
	e[cnt] = (edge) {v, w, head[u]}, head[u] = cnt++;
}

void dijkstra()
{
	memset(dis, 0x3f, sizeof dis), dis[1] = 0;

	for (int i = 1; i <= n; i++)
		q.push(make(dis[i], i));

	for (int i = 1; i <= n; i++) {
		while (q.top().fi != dis[q.top().se])
			q.pop();
		int u = q.top().se; q.pop();

		for (int i = head[u]; ~i; i = e[i].next) {
			int v = e[i].v;
			if (dis[v] > dis[u] + e[i].w) {
				dis[v] = dis[u] + e[i].w;
				q.push(make(dis[v], v));
			}
		}
	}
}

void _dfs(int u)
{
	vis[u] = 1;
	while (!_next[u].empty()) {
		pii v = _next[u].top(); _next[u].pop();
		if (!vis[v.fi]) {
			insert(u, v.fi, v.se);
		       	insert(v.fi, u, v.se);
			_dfs(v.fi);
		}
	}
}

void find_root(int u, int p)
{
	size[u] = 1, _max[u] = 0;
	for (int i = head[u]; ~i; i = e[i].next) {
		int v = e[i].v;
		if (v != p && !del[v]) {
			find_root(v, u), size[u] += size[v];
			_max[u] = max(_max[u], size[v]);
		}
	}
	_max[u] = max(_max[u], sum - size[u]);
	if (_max[u] < _max[root]) root = u;
}

void __dfs(int u, int p)
{
	if (val[u] > g[deep[u]][0])
		g[deep[u]][0] = val[u], g[deep[u]][1] = 0;
	if (val[u] == g[deep[u]][0])
		g[deep[u]][1] += 1;

	for (int i = head[u]; ~i; i = e[i].next) {
		int v = e[i].v;
		if (v != p && !del[v]) {
			deep[v] = deep[u] + 1;
			val[v] = val[u] + e[i].w;
			__dfs(v, u);
		}
	}
}

void get_size(int u, int p)
{
	size[u] = 1;
	for (int i = head[u]; ~i; i = e[i].next) {
		int v = e[i].v;
		if (v != p && !del[v])
			get_size(v, u), size[u] += size[v];
	}
}

void solve(int u)
{
	del[u] = 1; get_size(u, 0);

	for (int i = 0; i <= size[u]; i++)
		f[i][0] = f[i][1] = 0;
	f[0][0] = 0, f[0][1] = 1;

	for (int i = head[u]; ~i; i = e[i].next) {
		int v = e[i].v;
		if (!del[v]) {
			for (int j = 0; j <= size[v]; j++)
				g[j][0] = g[j][1] = 0;
			deep[v] = 1, val[v] = e[i].w, __dfs(v, u);

			for (int j = 1; j <= K && j <= size[v]; j++) {
				if (g[j][0] + f[K - j][0] > _ans[0])
					_ans[0] = g[j][0] + f[K - j][0], _ans[1] = 0;
				if (g[j][0] + f[K - j][0] == _ans[0])
					_ans[1] += g[j][1] * f[K - j][1];
			}
			
			for (int j = 1; j <= size[v]; j++) {
				if (g[j][0] > f[j][0])
					f[j][0] = g[j][0], f[j][1] = 0;
				if (g[j][0] == f[j][0])
					f[j][1] += g[j][1];
			}
		}
	}

	for (int i = head[u]; ~i; i = e[i].next) {
		int v = e[i].v;
		if (!del[v]) {
			sum = size[u], root = 0;
			find_root(v, u), solve(root);
		}
	}
}	

int main()
{
	n = read(), m = read(), K = read() - 1;

	memset(head, -1, sizeof head);	
	for (int i = 1; i <= m; i++) {
		int u =read(), v = read(), w = read();
		insert(u, v, w), insert(v, u, w);
	}

	dijkstra();
	
	for (int i = 0; i < cnt; i++)
		if (dis[e[i].v] == dis[e[i ^ 1].v] + e[i].w)
			_next[e[i ^ 1].v].push(make(e[i].v, e[i].w));
	memset(head, -1, sizeof head);
	cnt = 0, _dfs(1);
	
	sum = _max[0] = n, root = 0;	
	find_root(1, 0), solve(root);

	printf("%d %d\n", _ans[0], _ans[1]);
	

	return 0;
}