分治思想：劃分子問題，解決子問題，合併子問題

題目：POJ1741
題意：給定一棵含有n個節點的無向帶權樹，滿足距離≤k的兩點共有多少對？（n≤1e4）

題解：
（1）首先找到樹A的重心，（重心指的是一個節點，將該節點刪去之後剩下的最大子樹的節點數最小）將其作為樹A的根。在數列的分治之中我們是直接去區間的中間為分界線，但是這裡，如果隨意將某個點刪去，最壞的情況可能是這棵樹退化成一條鏈，遞迴的深度變成了O(n)。而將重心刪去後，剩餘子樹中的最大子樹大小≤n/2（必然），遞迴深度為O(logn)。

（2）找到樹A重心為根節點之後，將其劃分為以兒子為根的眾多子樹，再新增一個只有一個節點子樹，該節點直接連線根節點且邊權為0。計算滿足答案且經過根節點的（i，j）的對數（前面新增的單節點子樹就是計算根節點到其餘節點的答案）累加到ans。但是這裡面得到的答案包含了來自同一棵子樹的（i，j），因為他們經過了根節點的路徑並不是最短路，而在後續的子問題解決中還會計算到，因此在這裡需要減去來自同一棵子樹的（i，j）的答案數。

（3）將根節點刪去之後，分治解決子樹相同問題

原始碼如下

#include <iostream>
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define pb push_back

using namespace std;
const int maxn = 10005, inf = 0x3f3f3f3f;

struct Edge
{
	int to, next, dist;
}edge[maxn<<1];
int head[maxn], cnt;

void addedge(int u, int v, int w)
{
	edge[cnt].to = v;
	edge[cnt].dist = w;
	edge[cnt].next = head[u];
	head[u] = cnt++;
}

int n, k, ans;
int num[maxn];//num[i]表示以i為根的樹 的節點數
int dp[maxn];//一維滾動。dp[i]將i刪去後 當前樹的最大聯通塊的大小

int Stack[maxn], top1;//棧
bool vis[maxn] ;//true表刪除
int size;//當前樹的節點數
int root;//根節點

void get_root(int u, int fa)//深搜遍歷的同時找尋樹的重心root
{
	dp[u] = 0;
	num[u] = 1;//初始化

	for(int i = head[u]; ~i; i  = edge[i].next)
	{
		int v = edge[i].to;
		if(v!=fa && !vis[v]	)
		{//保證不回溯
			get_root(v, u);
			num[u] += num[v];//加上兒子的節點數就是根的節點數
			dp[u] = max(num[v], dp[u]);//最大聯通塊大小可能是子樹大小
		}
	}
	//最大聯通塊還有可能是當前樹刪除子樹u之後的樹大小
	dp[u] = max(dp[u] , size - num[u]);
	//最後跟目前的重心對比
	if(dp[u]<dp[root])	root = u;
}

int dist[maxn];//到根節點的距離
inline bool cmp(int i, int j)
{
	return dist[i] < dist[j];
}

void Find_dist(int u, int fa , int d)
{//計算當前樹的所有節點到根的距離，並將點入棧
	Stack[++top1] = u;
	dist[u] = d;
	for(int i = head[u]; ~i ; i = edge[i].next)
	{
		int v = edge[i].to;
		if(vis[v] || v==fa)	continue ;
		Find_dist(v, u, d+edge[i].dist);
	}
}

int calc(int l, int r)//計算滿足距離≤k的（i，j）個數
{
	int j = r, Ans = 0;//此時stack中l到r是按照dist升序排好的，ij一前一後往中間掃
	for(int i = l; i <= r; i ++)
	{
		while(dist[Stack[i]]+dist[Stack[j]]>k && j>i) j--;
		if(i==j)	break ;
		Ans += j-i;
		//Stack[i+1]~Stack[j]都是滿足條件的
	}
	return Ans;
}

void solve(int u, int fa)
{
	dp[0] = maxn;
	size = num[u];
	root = 0;
	
	get_root(u, fa);//找到重心並將之轉換為當前樹的根

	top1 = 0;
	int top2 = 0;
	for(int i = head[root]; ~i; i = edge[i].next)
	{
		int v = edge[i].to;
		if(vis[v])	continue;
		top2 = top1;
		Find_dist(v, root, edge[i].dist);
		//top2+1 到top1+1為子樹v的所有節點
		sort(Stack+top2+1, Stack+top1+1, cmp);
		ans -= calc(top2+1, top1);//減去在同一棵子樹且經過根節點（即非最短距離）的答案數
	}
	
	Stack[++top1] = root;
	dist[root ] = 0;
	sort(Stack+1, Stack+top1+1, cmp);
	ans += calc(1, top1);

	vis[root] = 1;

	for(int i = head[root]; ~i; i = edge[i].next)
		if(!vis[edge[i].to])
			solve(edge[i].to, root);//分治解決
}

void init()
{
	memset(head, -1, sizeof head);
	memset(vis, 0, sizeof vis);
	ans = 0;
	cnt = 0;
}

int main()
{
	while(scanf("%d %d", &n, &k), n&&k)
	{
		init();
		for(int i = 1; i < n; i ++)
		{
			int u, v, d;
			scanf("%d %d %d", &u, &v, &d);
			addedge(u, v, d);
			addedge(v, u, d);
		}
		num[1] = n;
		solve(1, 0);
		printf("%d\n", ans);
	}
    return 0;
}