点分治学习笔记
前言：
\(Point~divide~and~rule\)
使用
淀粉质就是在树上，依靠不停的递归和分治，解决相同的子问题
先来看看模板题: \(Tree\)
就是找树上\(<=K\)的路径有多少
我们可以分两种情况讨论
\(1.\) 经过根节点\(p\)的路径
\(2.\) 不经过根节点\(p\)的路径
第二种情况可以通过递归来处理，我们直接来讨论第一种情况
设当前的树根节点为 \(p\)
显然一条经过\(p\)路径可以由两条到端点为\(p\)的链组成
显然，会出现重复的情况，例如:
(好大...
这两条链组成的已经不是一条路径了，我们需要去除这种非法情况，这里提供两种方法
\(1.\)容斥
我们只需要统计\(p\)树内子节点到\(p\)的距离，排序后，用双指针做,再把\(p\)子节点的非法情况用种方法去除
\(2.~treap\)，强烈安利---\(fhq-treap\)
我们只需要把\(p\)树的子树依次处理，对于\(p\)的一棵子树\(y\),先把所有在\(y\)树里的路径长度\(Dis\)统计出来，再在\(treap\)里找\(<=K-Dis\)的个数,最后将这些路径放入\(treap\)
(推荐使用这一种，一般来说大多数题目都需要不用\(treap\)，暴力开桶就行了，这种技巧十分重要
这两种方法都要会掌握
统计完成了，那我们怎么递归呢?
这里有一个核心，我们每次选择只选重心来递归，由于中心的子节点\(size\)永远不会超过\(Root~size/2\)，所以我们的递归层数不会超过\(log(n)\)
每一次计算是\(nlogn\),递归层数\(log(n)\),总时间复杂度是\(O(nlognlogn)\),巧妙的暴力
\(code:\)(这里用的是第一种去重方法,太懒了）
#include<bits/stdc++.h>
using namespace std;
const long long N=4e4+10;
struct data {
long long val,stb,to;
} a[N*2];
long long head[N],max_size[N],size[N],vis[N],Root,k,Dis[N],cnt,n,tot,ans,size_sontree;
void insert(long long x,long long y,long long z) {
a[++tot].to=y;
a[tot].stb=head[x];
a[tot].val=z;
head[x]=tot;
}
long long get_root(long long x,long long fa) {
size[x]=1;
max_size[x]=0;
for(long long i=head[x]; i; i=a[i].stb) {
long long xx=a[i].to;
if(xx==fa||vis[xx]) continue;
get_root(xx,x);
size[x]+=size[xx];
max_size[x]=max(max_size[x],size[xx]);
}
max_size[x]=max(max_size[x],size_sontree-size[x]);
if(max_size[x]<max_size[Root]) Root=x;
}
long long find_dis(long long x,long long fa,long long D) {
Dis[++cnt]=D;
for(long long i=head[x]; i; i=a[i].stb) {
long long xx=a[i].to;
if(xx==fa||vis[xx]) continue;
find_dis(xx,x,D+a[i].val);
}
}
long long find_ans(long long x,long long fa,long long D) {
cnt=0;
find_dis(x,0,D);
sort(Dis+1,Dis+cnt+1);
long long l=1,r=cnt,sum=0;
while(1) {
while(Dis[l]+Dis[r]>k&&r) r--;
if(l>r) break;
sum+=r-l;
l++;
}
return sum;
}
void slove(long long x) {
vis[x]=1;
ans+=find_ans(x,0,0);
for(long long i=head[x]; i; i=a[i].stb) {
long long xx=a[i].to;
if(!vis[xx]) {
ans-=find_ans(xx,x,a[i].val);
Root=0;
size_sontree=size[xx];
get_root(xx,x);
slove(Root);
}
}
}
int main() {
scanf("%lld",&n);
for(long long i=1,x,y,z; i<=n-1; i++) {
scanf("%lld%lld%lld",&x,&y,&z);
insert(x,y,z);
insert(y,x,z);
}
scanf("%lld",&k);
max_size[0]=INT_MAX;
size_sontree=n;
get_root(1,0);
slove(1);
printf("%lld",ans);
}
其他例题
[Noip模拟题]树上路径
找出最小的\(Dis>=S\)即可，由于是取最小值，所以容斥就不行了，这里使用的是\(set\)
\(code:\)(在线格式化不要嫌丑
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 10;
int max_size[N], size_sontree, size[N], head[N], Dis[N], vis[N], Root, tot, cnt, n, S, E, ans;
struct data {
int stb, to, val;
} a[N * 2];
void insert( int x, int y, int z )
{
a[++tot].to = y;
a[tot].stb = head[x];
a[tot].val = z;
head[x] = tot;
}
int get_root( int x, int fa )
{
size[x] = 1, max_size[x] = 0;
for ( int i = head[x]; i; i = a[i].stb )
{
int xx = a[i].to;
if ( xx == fa || vis[xx] )
continue;
get_root( xx, x );
size[x] += size[xx];
max_size[x] = max( max_size[x], size[xx] );
}
max_size[x] = max( max_size[x], size_sontree - size[x] );
/* printf("mxsize[%d]=%d\n",x,max_size[x]); */
if ( max_size[x] < max_size[Root] )
Root = x;
}
void find_dis( int x, int fa, int D )
{
Dis[++cnt] = D;
for ( int i = head[x]; i; i = a[i].stb )
{
int xx = a[i].to;
if ( xx == fa || vis[xx] )
continue;
find_dis( xx, x, D + a[i].val );
}
}
int calc( int x )
{
cnt = 0;
set<int>q;
q.insert( 0 );
for ( int i = head[x]; i; i = a[i].stb )
{
int xx = a[i].to;
if ( vis[xx] )
continue;
cnt = 0;
find_dis( xx, x, a[i].val );
for ( int l = 1; l <= cnt; l++ )
{
/* cout<<Dis[l]<<" "; */
set<int>::iterator r = q.lower_bound( S - Dis[l] );
if ( r == q.end() )
continue;
ans = min( ans, Dis[l] + *r );
}
for ( int j = 1; j <= cnt; j++ )
q.insert( Dis[j] );
}
}
void Slove( int x )
{
vis[x] = 1;
calc( x );
/* printf("Root:%d\n",x); */
for ( int i = head[x]; i; i = a[i].stb )
{
int xx = a[i].to;
if ( vis[xx] )
continue;
Root = 0;
size_sontree = size[xx];
get_root( xx, x );
Slove( Root );
}
}
int main()
{
ans = INT_MAX;
scanf( "%d%d%d", &n, &S, &E );
for ( int i = 1; i <= n - 1; i++ )
{
int x, y, z;
scanf( "%d%d%d", &x, &y, &z );
insert( x, y, z );
insert( y, x, z );
}
max_size[0] = INT_MAX;
size_sontree = n;
get_root( 1, 0 );
Slove( Root );
if ( ans <= E )
printf( "%d", ans );
else printf( "-1" );
}
[黑白配]（http://www.forioi.com/p/6547）
这里有两个条件:
\(1.\)路径上黑色边与白色边的数量相同。
\(2.\)路径中存在一个不同于起始点和终点的点，它到终点的路径也满足\(1\)。
把黑看成\(1\)，白看成\(-1\),两条链的\(Dis\)为相反数即可满足\(1\)条件
讨论第二种条件：
如果一条链\(p->u\)的\(Dis\)在这条链中间任意一点\(p->v\)的\(Dis\)也出现过，那么\(u->v\)的\(Dis\)就为\(0\)，我们称这条链为\(can\)链，
处理\(can\)链可以用递归来做，开个\(map\)统计\(Dis\)的出现
我们发现，只要两条链只要有一条\(can\)链，就能满足条件\(2\)，开两个\(2维map\)来统计\(can链\)和非\(can链\)的个数，用类似第二种情况去重,还需要特判单独一条链的情况
\(code:\)(此题细节较多)
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e6 + 10;
long long max_size[N], size_sontree, size[N], head[N], Dis[N], vis[N], Root, tot, cnt, n, S, E, ans, use[N];
map<long long, long long > duck;
map<long long, long long > mp1;
map<long long, long long > mp0;
struct data {
long long stb, to, val;
} a[N * 2];
void insert( long long x, long long y, long long z )
{
a[++tot].to = y;
a[tot].stb = head[x];
a[tot].val = z;
head[x] = tot;
}
long long get_root( long long x, long long fa )
{
size[x] = 1, max_size[x] = 0;
for ( long long i = head[x]; i; i = a[i].stb )
{
long long xx = a[i].to;
if ( xx == fa || vis[xx] )
continue;
get_root( xx, x );
size[x] += size[xx];
max_size[x] = max( max_size[x], size[xx] );
}
max_size[x] = max( max_size[x], size_sontree - size[x] );
if ( max_size[x] < max_size[Root] )
Root = x;
}
void find_dis( long long x, long long fa, long long D )
{
Dis[++cnt] = D;
if ( duck[D] )
{
if ( D == 0 && duck[0] != 1e6 )
ans++;
use[cnt] = 1;
}
duck[D]++;
for ( long long i = head[x]; i; i = a[i].stb )
{
long long xx = a[i].to;
if ( xx == fa || vis[xx] )
continue;
find_dis( xx, x, D + a[i].val );
}
duck[D]--;
}
long long calc( long long x )
{
cnt = 0;
int last = 0;
for ( long long i = head[x]; i; i = a[i].stb )
{
long long xx = a[i].to;
if ( vis[xx] )
continue;
duck[0] = 1e6;
find_dis( xx, x, a[i].val );
for ( long long l = last + 1; l <= cnt; l++ )
{
ans += mp1[-Dis[l]];
if ( use[l] )
ans += mp0[-Dis[l]];
}
for ( long long l = last + 1; l <= cnt; l++ )
{
if ( use[l] )
mp1[Dis[l]]++;
else mp0[Dis[l]]++;
}
last = cnt;
}
for ( long long l = 1; l <= cnt; l++ )
{
if ( use[l] )
mp1[Dis[l]]--, use[l]--;
else mp0[Dis[l]]--;
}
}
void Slove( long long x )
{
vis[x] = 1;
calc( x );
for ( long long i = head[x]; i; i = a[i].stb )
{
long long xx = a[i].to;
if ( vis[xx] )
continue;
Root = 0;
size_sontree = size[xx];
get_root( xx, x );
Slove( Root );
}
}
int main()
{
scanf( "%lld", &n );
for ( long long i = 1; i <= n - 1; i++ )
{
long long x, y, z;
scanf( "%lld%lld%lld", &x, &y, &z );
if ( z == 0 )
z = -1;
insert( x, y, z );
insert( y, x, z );
}
max_size[0] = INT_MAX;
size_sontree = n;
get_root( 1, 0 );
Slove( Root );
printf( "%lld", ans );
}
总结:
其他的直接套模板，主要是去重
\(1.\)找路径<=\(K\),用容斥
\(2.\)找路径\(=K\)，暴力用桶
\(3.\)找最值，用\(set\)
\(fhq-treap\)并没卵用
完结撒花
you are both faker
