学习笔记——根号分治
根号分治
根号分治与其说是一个算法，更不如说是一种思想
例题1
给出一个正整数\(x\)，和\(n\)个整数\(a_i\)，求\(x^{a_i} \bmod p\)
对于\(100\%\)的数据，\(1\leq n\leq 10^6,1\leq x,a_i<p,p=99824435\color{red}2\)
这很显然可以用二分快速幂来解决，时间复杂度\(O(nlogn)\)，但如果时限为\(0.2s\)呢，二分快速幂就有一点乏力了。
因为发现底数\(x\)不变，考虑打表，将\(x^k\)全部预处理出来，最后直接查询。预处理，时间复杂度\(O(k)\)，空间复杂度\(O(k)\)，查询，时间复杂度\(O(1)\)，这也不行。
但将两种方法结合一下，根号分治，这道题就可以做了：
因为\(x^k = x^{k\%p + p*\lfloor k/p \rfloor} = x^{k\%p} * x^{p*\lfloor k/p \rfloor}\)
那么\(p\)的取值就至关重要，根号分治其实就是\(p=\sqrt n\)，然后分类讨论
对于\(k <= \sqrt n\)时，我们可以\(O(\sqrt n)\)预处理\([1,\sqrt n]\)的\(x^k\)
对于\(k>\sqrt n\)
可以先\(O(\sqrt n)\)求出\((1 <= i <= \sqrt n)\)的\(x^{i * \lfloor k/p \rfloor}\)
然后通过\(x^k = x^{k\%p + p*\lfloor k/p \rfloor} = x^{k\%p} * x^{p*\lfloor k/p \rfloor}\)求得最后答案
预处理\(O(\sqrt n)\)，查询\(O(1)\)
\(code:\)
#include<iostream>
#include<cstdio>
#include<cmath>
using namespace std;
#define ri register int
static char buf[1000000],*p1=buf,*p2=buf,obuf[1000000],*p3=obuf;
#define getchar() p1==p2&&(p2=(p1=buf)+fread(buf,1,1000000,stdin),p1==p2)?EOF:*p1++
#define putchar(x) (p3-obuf<1000000)?(*p3++=x):(fwrite(obuf,p3-obuf,1,stdout),p3=obuf,*p3++=x)
template<typename item>
inline void read(register item &x)
{
x=0;register char c=getchar();
while(c<'0'||c>'9')c=getchar();
while(c>='0'&&c<='9')x=(x<<3)+(x<<1)+(c^48),c=getchar();
}
static char cc[10000];
template<typename item>
inline void print(register item x)
{
register long long len=0;
while(x)cc[len++]=x%10+'0',x/=10;
while(len--)putchar(cc[len]);
}
typedef long long ll;
const ll mod = 998244352;
int n,x,a;
const int MAX_N = 32000;
ll f[MAX_N],ff[MAX_N];
signed main(){
// freopen("P.in","r",stdin);
// freopen("P.out","w",stdout);
read(x),read(n);
f[0]=ff[0]=1;
int m=sqrt(mod);
for(int i=1;i<=m;i++) f[i]=f[i-1]*x%mod;
for(int i=1;i<=m;i++) ff[i]=ff[i-1]*f[m]%mod;
for(ri i=1;i<=n;i++){
read(a);
print(f[a%m]*ff[a/m]%mod);
putchar(' ');
}
fwrite(obuf,p3-obuf,1,stdout);
return 0;
}
例题4：雅加达的摩天楼
印尼首都雅加达市有N座摩天楼，它们排列成一条直线，我从左到右依次将它们编号为0到N-1。除了这N座摩天楼外，雅加达市没有其他摩天楼。
有M只叫做“\(doge\)”的神秘生物在雅加达市居住。它们的编号一次是\(0\)到\(M-1\)。编号为\(i\)的\(doge\)最初居住于标号为\(Bi\)的摩天楼。每只\(doge\)都有一种神秘的力量，使它们能够在摩天楼之间跳跃，编号为\(i\)的\(doge\)的跳跃能力为\(Pi(Pi>0)\)。在一次跳跃中，位于摩天楼 b 而跳跃能力为 \(p\) 的 \(doge\) 可以跳跃到编号为 \(b−p\) （如果 \(0≤b−p<N\)）或 \(b+p\) （如果 \(0≤b+p<N\)）的摩天楼。。
编号为\(0\)的\(doge\)是所有doge的首领，它有一条紧急的消息要尽快传送给编号为\(1\)的\(doge\)。任何一个收到消息的\(doge\)有以下两个选择：
1.跳跃到其他摩天楼上；
2.将消息传递给它当前所在的摩天楼上的其他doge。
请帮助\(doge\)们计算将消息从\(0\)号\(doge\)传递到\(1\)号的\(doge\)所学要的最少总跳跃步数，或者告诉他们消息永远不可能传递到\(1\)号\(doge\)。\(1<=N<=30000,1<=Pi<=30000,2<=M<=30000\)
图论，边数太大，考虑根号分治优化建图，这道题对\(doge\)的跳跃能力进行分治
拆点，把每个点拆出\(\sqrt n\)个点，分别代表距离\(1,2,...,\sqrt n\)
对于点\(i\)，
\(i'\)只连接与\(i\)距离为\(1\)的点
\(i''\)只连接与\(i\)距离为\(2\)的点
\(i'...\)只连接与\(i\)距离为\(\sqrt n\)的点
把两两距离为\(1\)的点连起来
把两两距离为\(2\)的点连起来
\(......\)
把两两距离为\(\sqrt n\)的点连起来
\(i’,i''\)都往\(i\)连边，长度为\(0\)
表示到达\(i'\)或\(i''\)都等价于到达\(i\)
若\(x\)号点上的\(doge\)跳跃距离为\(p\)，且\(p>\sqrt n\)，则直接连边到它能到达的点
这样建边最多\(n\sqrt n\)边
最后跑最短路即可
三元环
给出一张\(n\)个点，\(m\)条边的无向图，问图中有多少个三元环\(\{a,b,c\}\)，满足图中存在\(\{a-b,b-c,c-a\}三条边，即三个点构成环\)
方法一：
转换，对边定向，边的方向由度数较小的节点指向度数较大的节点。若度数相同，则按照节点编号由大到小连边。
结论1，新图一定是有向无环图(\(DAG\))
证明：
反证，假设存在一个环：\(a->b->c->a\)
设\(d_i\)表示原图中\(i\)号点的度数，那么有\(d_a<=d_b<=d_c<=d_a\)，该式子要成立，必须满足\(d_a=d_b=d_c=d_a\)，度数相同的节点由小到大连边，那么有\(a>b>c>a\)，所以\(a>a\)，矛盾，证毕
结论2，新图每个点的出度不超过\(\sqrt m\)
证明：
假设在无向图中点\(u\)的度\(<=\sqrt m\)，定向后其出度肯定不会大于等于它在原图中的度，所以\(out_u<=\sqrt m\)
假如在无向图中\(u\)的度\(>\sqrt m\)，假如有边\(u->v\)，那么原图中\(u\)的度小于等于\(v\)的度，又因为原图中\(u\)的度是\(>\sqrt m\)的，所以满足条件的点\(v\)不超过\(\sqrt m\)个，于是这种情况下\(out_u<\sqrt m\)，证毕
统计三元环
- 枚举每一个点，对于当前点，将它能到达的点打上标记
- 枚举做过标记的点，对于当前被做过标记的点，枚举它能到达的点，假如这个能到达的点是被做过标记的，那么就找到了一个三元环。
三元环是定向的，每个点只会枚举出边，所以每个环被统计的情况是唯一的。
**共\(n\)个点，每个点出度不超过\(\sqrt m\)，所以时间复杂度为\(O(n\sqrt m)\)
\(code:\)求三元环贡献和\(max{a_1,a_2,a_3}\)
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 100000 + 5;
const int MAX_M = 250000 + 5;
struct node{
int a,b;
}edge[MAX_M];
int n,m,d[MAX_N];
ll a[MAX_N];
vector<int> v[MAX_N];
int mark[MAX_N];
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++){
scanf("%lld",&a[i]);
}
for(int i=1;i<=m;i++){
scanf("%d%d",&edge[i].a,&edge[i].b);
d[edge[i].a]++,d[edge[i].b]++;
}
for(int i=1;i<=m;i++){
int x=edge[i].a,y=edge[i].b;
if(d[x]>d[y] || (d[x]==d[y] && x<y)) swap(x,y);
v[x].push_back(y);
}
ll ans=0;
for(int x=1;x<=n;++x){
for(int i=0;i<v[x].size();i++){
int y=v[x][i];
mark[y]=x;
}
for(int i=0;i<v[x].size();i++){
int y=v[x][i];
for(int j=0;j<v[y].size();j++){
if(mark[v[y][j]]==x){
ans+=max(a[v[y][j]],max(a[x],a[y]));
}
}
}
}
printf("%lld",ans);
return 0;
}
方法二：
无向图上进行根号分治（常数较大）
- 统计每个点的度数，度数\(<=\sqrt m\)的分为第\(1\)类，度数\(>\sqrt m\)分为第\(2\)类
- 对于第\(1\)类，暴力枚举每个点，然后暴力枚举这个点相连的任意两条边，再判断这两条边的另一个端点是否相连（因为\(m\)条边最多被遍历一次，出度\(<=\sqrt m\)，所以复杂度为\(O(m\sqrt m)\)）
- 对于第\(2\)类，直接暴力枚举任意三个点，判断这三个点是否构成环（因为这一类点的个数不会超过\(\sqrt m\)，所以复杂度为\(O({(\sqrt m)}^3) = O(m\sqrt m)\)
- 判断两个点是否连接可以用\(set,map,hash\)等
\(code：\)
