以前用 d f s dfs dfs做的,用基尔霍夫矩阵真的玄啊
首先这道题有这么几个定理:(来自Z-Y-Y-S的博客)
定理一:如果
A
,
B
A, B
A,B 同为
G
G
G 的最小生成树,且
A
A
A 的边权从小到大为
w
(
a
1
)
,
w
(
a
2
)
,
w
(
a
3
)
,
⋯
w
(
a
n
)
w(a_1), w(a_2), w(a_3), \cdots w(a_n)
w(a1),w(a2),w(a3),⋯w(an),
B
B
B 的边权从小到大为
w
(
b
1
)
,
w
(
b
2
)
,
w
(
b
3
)
,
⋯
w
(
b
n
)
w(b_1), w(b_2), w(b_3), \cdots w(b_n)
w(b1),w(b2),w(b3),⋯w(bn),则有
w
(
a
i
)
=
w
(
b
i
)
w(a_i) = w(b_i)
w(ai)=w(bi)。
证明:设
A
,
B
A, B
A,B 第一个不同的边的下标为
i
i
i,不妨设
w
(
a
i
)
≤
w
(
b
i
)
w(a_i) \le w(b_i)
w(ai)≤w(bi),如果不存在这样的
i
i
i,无需证明。
情况一:
a
i
a_i
ai 在
B
B
B 中,为
b
j
b_j
bj。那么显然有
j
>
i
j>i
j>i(否则
i
i
i 不是第一个不同的边),则有
w
(
a
i
)
≤
w
(
b
i
)
≤
w
(
b
j
)
=
w
(
a
i
)
w(a_i)\le w(b_i) \le w(b_j) = w(a_i)
w(ai)≤w(bi)≤w(bj)=w(ai),所以有
w
(
a
i
)
=
w
(
b
i
)
=
w
(
b
j
)
w(a_i) = w(b_i) = w(b_j)
w(ai)=w(bi)=w(bj),所以可以调换
b
i
,
b
j
b_i, b_j
bi,bj 的位置,
B
B
B 的权值排列不会改变,
A
A
A 与
B
B
B 这样前
i
i
i 条边均为相等,可以递归下去证明。
情况二:
a
i
a_i
ai 不在
B
B
B 中。考虑将
a
i
a_i
ai 加入
B
B
B,则形成了一个环,环中的权值
v
≤
w
(
a
i
)
v\le w(a_i)
v≤w(ai)(否则
B
B
B 不是最小生成树),且一定有一条边
b
j
b_j
bj 不在
B
B
B 中,此时仍有
j
>
i
j>i
j>i(否则
i
i
i 不是第一个不同的边),所以有
w
(
a
i
)
≤
w
(
b
i
)
≤
w
(
b
j
)
≤
w
(
a
i
)
w(a_i)\le w(b_i) \le w(b_j) \le w(a_i)
w(ai)≤w(bi)≤w(bj)≤w(ai),所以仍有
w
(
a
i
)
=
w
(
b
i
)
=
w
(
b
j
)
w(a_i) = w(b_i) = w(b_j)
w(ai)=w(bi)=w(bj),可以将
b
j
b_j
bj 替换为
a
i
a_i
ai,
B
B
B 的权值排列不会改变且仍为最小生成树,仍然调换
b
i
,
b
j
b_i, b_j
bi,bj 的位置,
B
B
B 的权值排列仍会改变,这样
A
A
A 与
B
B
B 前
i
i
i 条边均为相等,可以递归下去证明。这样换边不会有问题,因为 Kruskal 算法中唯一的状态就是连通性,我们没有改变其连通性,所以是可以递归证明的。
定理二:如果
A
,
B
A, B
A,B 同为
G
G
G 的最小生成树,如果
A
,
B
A, B
A,B 都从零开始从小到大加边(
A
A
A 加
A
A
A 的边,
B
B
B 加
B
B
B 的边)的话,每种权值加完后图的联通性相同。
证明:归纳法证明,没有边时显然成立,假设对于权值小于
v
v
v 的成立。考虑权值为
v
v
v 的边,如果连通性不相同,必然存在
u
,
v
u, v
u,v 两点间连通性不同,假设
A
A
A 中
u
,
v
u, v
u,v 联通,根据
A
,
B
A, B
A,B 所有小于
v
v
v 的边连通性相同,所以必然存在一条
u
→
v
u\rightarrow v
u→v 权值为
v
v
v 的边,而根据 Kruskal 算法的执行过程,
B
B
B 不可能不加这条边,所以两棵最小生成树
A
,
B
A, B
A,B 各自权值小于等于
v
v
v 的边仍然满足连通性相同。由归纳法可知定理二成立。
定理三:如果在最小生成树
A
A
A 中权值为
v
v
v 的边有
k
k
k 条,用任意
k
k
k 条权值为
v
v
v 的边替换
A
A
A 中的权为
v
v
v 的边且不产生环的方案都是一棵合法最小生成树。
证明:根据之前的定理,其余的边造成的连通性是定的,权值和也是定的,那么选
k
k
k 条不产生环一定能形成一棵树,而且权值与最小生成树的权值一样,故也是最小生成树。
有了这些定理,就可以基尔霍夫矩阵来算方案,每次乘起来,但算的时候要先“缩点”,其实就是排个序去重之类的,然后算完方案随便找一种连起来,但注意算方案的时候有可能不能构成生成树,还需要先把图再连一下使它能有生成树。
细节很多,写的时候一定要脑子清楚
代码如下:(改动比较多,有点丑)
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
#define N 105
#define M 1005
#define LL long long
#define int LL
using namespace std;
inline int rd(){
int x=0,f=1;char c=' ';
while(c<'0' || c>'9') f=c=='-'?-1:1,c=getchar();
while(c<='9' && c>='0') x=x*10+c-'0',c=getchar();
return x*f;
}
int n,m,a[N][N],fa[N],fa2[N],ans=1,c[N<<1],sum;
const int mod=31011;
struct EDGE{
int fr,to,w;
bool operator <(const EDGE &x) const{
return w<x.w;
}
}edge[M],tmp[M];
inline int Matrix_tree(int tot){
for(int i=1;i<tot;i++)
for(int j=1;j<tot;j++)
a[i][j]=(a[i][j]+mod)%mod;
int ans=1,f=1;
for(int i=1;i<tot;i++){
for(int j=i+1;j<tot;j++){
if(!a[j][i]) continue;
int A=a[i][i],B=a[j][i];
while(B){
int t=A/B;
A%=B; swap(A,B);
for(int k=i;k<tot;k++) a[i][k]=(a[i][k]-1LL*t*a[j][k]+mod)%mod;
for(int k=i;k<tot;k++) swap(a[i][k],a[j][k]); f=-f;
}
}
if(!a[i][i]) return 0;
ans=1LL*ans*a[i][i]%mod;
}
if(f==-1) ans=mod-ans%mod;
return (ans+mod)%mod;
}
inline int find(int x){
if(x==fa[x]) return x;
return fa[x]=find(fa[x]);
}
inline int find2(int x){
if(x==fa2[x]) return x;
return fa2[x]=find2(fa2[x]);
}
inline int solve(int l,int r){
int cnt=0,num=0;
for(int i=l;i<=r;i++){
int x=find(edge[i].fr),y=find(edge[i].to);
tmp[i].fr=x,tmp[i].to=y;
if(x!=y)
c[++num]=x,c[++num]=y;
}
sort(c+1,c+num+1); num=unique(c+1,c+num+1)-c-1;
for(int i=1;i<=num;i++) fa2[i]=i;
for(int i=l;i<=r;i++){
if(tmp[i].fr==tmp[i].to) continue;
int u=find(tmp[i].fr),v=find(tmp[i].to);
if(u!=v) sum--,fa[u]=v;
u=lower_bound(c+1,c+num+1,tmp[i].fr)-c; v=lower_bound(c+1,c+num+1,tmp[i].to)-c;
a[u][u]++,a[u][v]--,a[v][v]++,a[v][u]--;
int x=find2(u),y=find2(v);
if(x!=y) fa2[x]=y;
}
for(int i=2;i<=num;i++)
if(find2(i)!=find2(i-1)){
int u=find2(i),v=find2(i-1);
a[u][u]++,a[u][v]--,a[v][v]++,a[v][u]--;
fa2[u]=v;
}
ans=1LL*ans*Matrix_tree(num)%mod;
}
signed main(){
n=rd(); m=rd();
for(int i=1;i<=m;i++) edge[i].fr=rd(),edge[i].to=rd(),edge[i].w=rd();
sort(edge+1,edge+m+1); int u,v; sum=n;
for(int i=1;i<=n;i++) fa[i]=i;
for(int i=1;i<=m;){
int j=i; while(edge[j].w==edge[i].w) j++; j--;
if(i==j){
u=find(edge[i].fr),v=find(edge[i].to);
if(u!=v) fa[u]=v,sum--;
}
else{
memset(a,0,sizeof a); solve(i,j);
}
i=j+1;
}
if(sum>1) puts("0");
else printf("%lld\n",ans);
return 0;
}