树上分治详解 超级详细（附带例题 poj1741（给了题目））

}

else if(flag == -1)

{

return last;

}

c = max(count_point[data[n][flag].to], count_point[f] - c - 1);

if(c >= count_point[n])

{

return last;

}

return find_core(data[n][flag].to, n, f);

}

第②种方法：

遍历所有点，不光沿着最大子树走，这样复杂度也只是O(n)，不会超时，并且代码相对简单

（我们最终取递归结果的 .second 即可）

pair<int, int> find_core(int v, int p, int t)

{

pair<int, int> res = make_pair(INF, -1);

int s = 1, m = 0;

for(int i = 0; i < data[v].size(); i++)

{

int w = data[v][i].to;

if(w == p || delete_point[w]) continue;

res = min(res, find_core(w, v, t));

m = max(m, count_point[w]);

s += count_point[w];

}

m = max(m, t - s);

res = min(res, make_pair(m, v));

return res;

}

👌

AC代码

---

（如果还有不会的地方，可以评论或者私信，我们可以一起探讨）

#include

#include <stdio.h>

#include

#include

#define INF 1000000005

using namespace std;

struct edge

{

int to, length;

edge(int t, int l)

{

to = t; length = l;

}

};

vector data[10005];

int N, K;

int count_point[10005];

bool delete_point[10005];

void add_edge(int from, int to, int length)

{

data[from].push_back(edge(to, length));

data[to].push_back(edge(from, length));

}

void tag_point(int n, int last)

{

int ans = 1;

for(int i = 0; i < data[n].size(); i++)

{

int w = data[n][i].to;

if(last != w && !delete_point[w])

{

tag_point(w, n);

ans += count_point[w];

}

}

count_point[n] = ans;

}

int find_core(int n, int last, int f)

{

int flag = -1, c = 0;

for(int i = 0; i < data[n].size(); i++)

{

int w = data[n][i].to;

if(w != last && !delete_point[w])

{

if(flag == -1)

{

flag = i;

}

else

{

真题解析、进阶学习笔记、最新讲解视频、实战项目源码、学习路线大纲
详情关注公中号【编程进阶路】

if(count_point[w] > count_point[data[n][flag].to])

{

flag = i;

}

}

c += count_point[w];

}

}

if(flag == -1 && last == -1)

{

return n;

}

else if(flag == -1)

{

return last;

}

c = max(count_point[data[n][flag].to], count_point[f] - c - 1);

if(c >= count_point[n])

{

return last;

}

return find_core(data[n][flag].to, n, f);

}

void measure(int n, int p, int l, vector &d)

{

d.push_back(l);

for(int i = 0; i < data[n].size(); i++)

{

int w = data[n][i].to;

if(w != p && !delete_point[w])

{

measure(w, n, l + data[n][i].length, d);

}

}

}

int count_num(vector &d)

{

int res = 0, num = d.size();

sort(d.begin(), d.end());

int j = num - 1;

for(int i = 0; i < num && i < j; i++)

{

for(; d[i] + d[j] > K && i < j; j–){}

res += j - i;

}

return res;

}

int solve(int n)

{

int res = 0;

tag_point(n, -1);

int core = find_core(n, -1, n);

delete_point[core] = true;

for(int i = 0; i < data[core].size(); i++)

{

int w = data[core][i].to;

if(!delete_point[w])

{

res += solve(data[core][i].to);

}

}

vector point_sum;

point_sum.push_back(0);

for(int i = 0; i < data[core].size(); i++)

{

int w = data[core][i].to;

if(!delete_point[w])

{

vector point;

measure(data[core][i].to, core, data[core][i].length, point);

res -= count_num(point);

point_sum.insert(point_sum.end(), point.begin(), point.end());

}

}

delete_point[core] = false;

res += count_num(point_sum);

return res;

}

int main()

{

while(1)

{

scanf(“%d %d”, &N, &K);

if(N == 0 && K == 0)

{

break;

}

for(int i = 0; i < N; i++)

JavaScript 和 ES6

在这个过程你会发现，有很多 JS 知识点你并不能更好的理解为什么这么设计，以及这样设计的好处是什么，这就逼着让你去学习这单个知识点的来龙去脉，去哪学？第一，书籍，我知道你不喜欢看，我最近通过刷大厂面试题整理了一份前端核心知识笔记，比较书籍更精简，一句废话都没有，这份笔记也让我通过跳槽从8k涨成20k。