BZOJ5206 [Jsoi2017]原力[根号分治]

这是一个三元环计数的裸题，只是多了一个颜色的区分和权值的计算罢了。

有一种根号分治的做法（by gxz）

这种复杂度的证明特别显然，思路非常简单，不过带一个log，可以用unordered_map或者bitset之类的$O(1)$判连通。

---

我的做法的话采用了一个比较奇怪的思路？每条边，度数大的点向度数小的点连有向边，然后枚举第一层点，枚举出发到达的第二层点，这两层加起来复杂度总的是$O(m)$，然后从第二层点枚举出边到第三层点，看第三层点和第一层点是不是连通的，这个复杂度我好像在这里写过证明，就不贴了。注意一下重边的话，只要把相同颜色的权值累加起来做乘法就行（line47）。

理论上说是根号的做法，但是我跑了9s？？？

人家带一个log的都比我跑的快一倍，莫非我复杂度是假的？

不清楚，如果有神仙指导不胜感激。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #define mst(x) memset(x,0,sizeof x)
 #define dbg(x) cerr << #x << " = " << x <<endl
 #define dbg2(x,y) cerr<< #x <<" = "<< x <<"  "<< #y <<" = "<< y <<endl
 using namespace std;
 typedef long long ll;
 typedef double db;
 typedef pair<int,int> pii;
 template<typename T>inline T _min(T A,T B){return A<B?A:B;}
 template<typename T>inline T _max(T A,T B){return A>B?A:B;}
 template<typename T>inline char MIN(T&A,T B){return A>B?(A=B,):;}
 template<typename T>inline char MAX(T&A,T B){return A<B?(A=B,):;}
 template<typename T>inline void _swap(T&A,T&B){A^=B^=A^=B;}
 template<typename T>inline T read(T&x){
     x=;int f=;char c;while(!isdigit(c=getchar()))if(c=='-')f=;else if(c=='R'||c=='G'||c=='B'){x=c;break;}
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=1e5+,P=1e9+;
 struct thxorz{
     int head[N],w[N<<],nxt[N<<],to[N<<],typ[N<<],tot;
     thxorz(){tot=;}
     inline void add(int x,int y,int z,int ty){to[++tot]=y,nxt[tot]=head[x],head[x]=tot,w[tot]=z,typ[tot]=ty;}
 }G,E;
 inline void add(int&a,int b){a+=b;a>=P&&(a-=P);}
 inline int mod(int a){return a>=P?a-=P:a;}
 int deg[N],vis[N][],val[N][];
 int n,m,ans;
 inline int cmp(int a,int b){return deg[a]==deg[b]?a<b:deg[a]<deg[b];}

 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(n),read(m);
     for(register int i=;i<=m<<;i+=)++deg[read(E.to[i])],++deg[read(E.to[i+])],read(E.w[i]),read(E.typ[i]);
     for(register int i=;i<=m<<;i+=){
         if(!cmp(E.to[i],E.to[i+]))G.add(E.to[i+],E.to[i],E.w[i],E.typ[i]=='R'?:(E.typ[i]=='G'?:));
         else G.add(E.to[i],E.to[i+],E.w[i],E.typ[i]=='R'?:(E.typ[i]=='G'?:));
     }
     for(register int x=;x<=n;++x){//x
         #define y G.to[j]
         #define t G.typ[j]
         for(register int j=G.head[x];j;j=G.nxt[j]){
             if(vis[y][t]^x)vis[y][t]=x,val[y][t]=G.w[j];
             else add(val[y][t],G.w[j]);
         }
         #define z G.to[k]
         #define tt G.typ[k]
         for(register int j=G.head[x];j;j=G.nxt[j]){//y
             for(register int k=G.head[y];k;k=G.nxt[k])if(t^tt){//z
                 if(vis[z][-t-tt]==x)add(ans,G.w[j]*1ll*G.w[k]%P*val[z][-t-tt]%P);
             }
         }
     }
     printf("%d\n",ans);
     return ;
 }

总结：这相当于是把原来$O(mn)$的做法尝试通过连边、度数等减少枚举。。