LINK：原力
一张无向图 这道题统计三元环的价值和。有重边但是无自环。
我曾经写过三元环计数 这个和那个题差不太多。
不过有很多额外操作 对于重边问题 我们把所有颜色相同的重边缩在一起 这样的话我们就可以针对点来运算了。
不过这样做开邻接表就很困难了 (直接map爽...
接下来是正规的三元环计数了 我们考虑重新建图 度数小的连向度数大的 度数相等的由编号小的连向编号大的。
可以暴力枚举每个点 标记所到达的点(暴力枚举合并过后的边 再枚举一条边去统计答案 这样就完事了。
可以观察一下复杂度 外层暴力枚举是O(m)的 内层我们考虑再枚举一条边 度数小于sqrt(m)的点复杂度为sqrt(m)
大于sqrt(m)的因为连向的只有>sqrt(m)的所以复杂度还是sqrt(m).
那其实内层均摊msqrt(m) 外层枚举好像跟内层复杂度没有联系 所以总复杂度 msqrt(m).
这里简述另外一种分治法：(这种分治法更容易分析复杂度。
对于三个点度数大于sqrt(m)的 我们可以直接暴力枚举三个点 复杂度显然msqrt(m).
反之 枚举一个点 其两条出边来判断 不重不漏的话我们规定编号最小的点能够枚举到这个环即可。
可以看出后者复杂度 msqrt(m).
对于这两种分治法 一般叫做根号分治 非常行之有效的方法。
运用第一种方法 我T的不省人事。
const int MAXN=100010;
int n,m,len;
struct wy{int x,y;}t[MAXN];
int ru[MAXN];
map<pii,int>H[3];
char a[10];
int lin[MAXN],ver[MAXN],nex[MAXN];
inline void add(int x,int y){ver[++len]=y;nex[len]=lin[x];lin[x]=len;}
int main()
{
//freopen("1.in","r",stdin);
gt(n);gt(m);
rep(1,m,i)
{
int x,y,z;
gt(x);gt(y);gt(z);gc(a);
int w=a[1]=='R'?0:a[1]=='G'?1:2;
if(x>y)swap(x,y);++ru[x];++ru[y];
H[w][mk(x,y)]=(H[w][mk(x,y)]+z)%mod;
t[i]=(wy){x,y};
}
for(int i=1;i<=m;++i)
{
int x=t[i].x,y=t[i].y;
if(ru[x]==ru[y]||ru[x]<ru[y])add(x,y);
else add(y,x);
}
ll ans=0;
for(int i=1;i<=n;++i)
{
for(int j=lin[i];j;j=nex[j])
{
int tn=ver[j];
for(int k=lin[tn];k;k=nex[k])
{
int w1=ver[k];
ans=(ans+(ll)H[1][mk(min(i,tn),max(i,tn))]*H[2][mk(min(tn,w1),max(tn,w1))]*H[0][mk(min(i,w1),max(i,w1))])%mod;
ans=(ans+(ll)H[1][mk(min(i,tn),max(i,tn))]*H[0][mk(min(tn,w1),max(tn,w1))]*H[2][mk(min(i,w1),max(i,w1))])%mod;
ans=(ans+(ll)H[2][mk(min(i,tn),max(i,tn))]*H[1][mk(min(tn,w1),max(tn,w1))]*H[0][mk(min(i,w1),max(i,w1))])%mod;
ans=(ans+(ll)H[2][mk(min(i,tn),max(i,tn))]*H[0][mk(min(tn,w1),max(tn,w1))]*H[1][mk(min(i,w1),max(i,w1))])%mod;
ans=(ans+(ll)H[0][mk(min(i,tn),max(i,tn))]*H[1][mk(min(tn,w1),max(tn,w1))]*H[2][mk(min(i,w1),max(i,w1))])%mod;
ans=(ans+(ll)H[0][mk(min(i,tn),max(i,tn))]*H[2][mk(min(tn,w1),max(tn,w1))]*H[1][mk(min(i,w1),max(i,w1))])%mod;
}
}
}
putl(ans);
//cout<<H[1][mk(min(1,2),max(1,2))]<<endl;
return 0;
}
const int MAXN=100010,M=10000007;
int n,m,len,len1;
struct wy{int x,y,z,e;}t[MAXN];
int ru[MAXN];char a[10];
struct jl
{
int x,y,w;
jl(){x=y=w=0;};
jl(int a,int b,int c){x=a;y=b;w=c;}
inline int friend operator ==(jl a,jl b){return a.x==b.x&&a.y==b.y&&a.w==b.w;}
}s[M],s1;
int lin[MAXN],ver[MAXN],nex[MAXN],e[MAXN],e1[MAXN];
inline void add(int x,int y,int z,int z1){ver[++len]=y;nex[len]=lin[x];lin[x]=len;e[len]=z;e1[len]=z1;}
int lin1[M],nex1[M],v[M];
inline int ha1(int x,int y,int w){return ((x*P+w)%M*P+y+w*y%M*x)*P%M;}
inline int find(int x,int y,int w,int z)
{
s1=jl(x,y,w);
int xx=ha1(x,y,w);
for(int i=lin1[xx];i;i=nex1[i])
if(s1==s[i]){v[i]=(v[i]+z)%mod;return v[i];}
return 0;
}
inline void ha(int x,int y,int w,int z)
{
if(find(x,y,w,z))return;
int ww=((x*P+w)%M*P+y+w*y%M*x)*P%M;
s[++len1]=s1;
nex1[len1]=lin1[ww];
lin1[ww]=len1;
v[len1]=z;
}
int main()
{
freopen("1.in","r",stdin);
gt(n);gt(m);
rep(1,m,i)
{
int x,y,z;
gt(x);gt(y);gt(z);gc(a);
int w=a[1]=='R'?0:a[1]=='G'?1:2;
if(x>y)swap(x,y);++ru[x];++ru[y];
t[i]=(wy){x,y,w,z};ha(x,y,w,z);
}
for(int i=1;i<=m;++i)
{
int x=t[i].x,y=t[i].y,w=t[i].z,z=t[i].e;
if(ru[x]==ru[y]||ru[x]<ru[y])add(x,y,w,z);
else add(y,x,w,z);
}
ll ans=0;
for(int i=1;i<=n;++i)
{
for(int j=lin[i];j;j=nex[j])
{
for(int k=lin[ver[j]];k;k=nex[k])
{
int w1=ver[k];
if(e[k]==e[j])continue;
int w2=i;if(w1>w2)swap(w1,w2);
int ww=find(w1,w2,3-e[j]-e[k],0);
ans=(ans+(ll)e1[j]*e1[k]%mod*ww)%mod;
}
}
}
putl(ans);
return 0;
}
const int MAXN=50010;
struct wy
{
int x,y,z;
wy(){x=y=z=0;}
wy(int a,int b,int c){x=a;y=b;z=c;}
bool operator<(const wy a)const{return x==a.x?y==a.y?z<a.z:y<a.y:x<a.x;}
};
map<wy,int>H;
int lin[MAXN],ver[MAXN<<2],nex[MAXN<<2],e[MAXN<<2],e1[MAXN<<2];
int n,m,si,len,cnt,d[MAXN],id[MAXN],tot;
char a[5];
inline void add(int x,int y,int z,int z1)
{
ver[++len]=y;nex[len]=lin[x];lin[x]=len;e[len]=z;e1[len]=z1;
}
int main()
{
freopen("1.in","r",stdin);
gt(n);gt(m);si=(int)sqrt(m*1.0);
ll ans=0;
rep(1,m,i)
{
int x,y,z;
gt(x);gt(y);gt(z);gc(a);
int w=a[1]=='R'?1:a[1]=='G'?2:3;
add(x,y,z,w);add(y,x,z,w);
++d[x];++d[y];
(H[wy(x,y,w)]+=z)%=mod;(H[wy(y,x,w)]+=z)%=mod;
}
rep(1,n,i)if(d[i]>=si)id[++tot]=i;
rep(1,tot,i)rep(1,tot,j)rep(1,tot,k)
ans=(ans+(ll)H[wy(id[i],id[j],1)]*H[wy(id[j],id[k],2)]%mod*H[wy(id[i],id[k],3)])%mod;
rep(1,n,i)
{
if(d[i]<si)
for(int j=lin[i];j;j=nex[j])
{
if(d[ver[j]]>=si||ver[j]>i)
for(int k=nex[j];k;k=nex[k])
if(e1[j]!=e1[k]&&(d[ver[k]]>=si||ver[k]>i))
ans=(ans+(ll)H[wy(ver[j],ver[k],6-e1[j]-e1[k])]*e[j]%mod*e[k])%mod;
}
}
putl(ans);return 0;
}
上面 是两个版本的 第一种方法外面分析复杂度是正确的 可就是跑的过于慢了 加上hash也是如此。
不得不采用第一种方法 我们把大于sqrt的抽出来单独跑 考虑不重不漏 显然一个三元环我们以唯一方向寻找 那么就不会重复。
考虑小的点 显然我么小的点枚举边 外层O(m) 内层<sqrt(m) 注意不重不漏 那么我们定义一个环由编号最小的节点开始即可。
代码也放上面好了.
郁闷的是 为什么第一种方法一直T 我也不知道为啥。