BZOJ2208 [Jsoi2010]连通数[缩点/Floyd传递闭包+bitset优化]

显然并不能直接dfs，因为$m$会非常大，复杂度就是$O(mn)$；

这题有三种做法，都用到了bitset的优化。第二种算是一个意外的收获，之前没想到竟然还有这种神仙操作。。

---

方法一：缩点+DAG上bitset优化的统计

做有向图连通问题上来先看可不可以缩点首先一个环内点是可以相互连通的，又发现DAG也许方便统计，于是缩点。。然后变成一张DAG，只要统计每个点可以往后走到的所有点权（指该环包含的点数）的和。并不好直接把后继全加上去，因为会有点被重复统计。为了避免重复统计，只要直接每个点开一个bitset，表示他能走到哪些点，这样dp的时候直接对儿子取or就可以了，然后再统计，不会重复。复杂度$O(\frac{mn}{32})$。实际上是可以卡过去的。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<bitset>
 #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=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=+;
 struct thxorz{
     int to[N*N],nxt[N*N],head[N],tot;
     inline void add(int x,int y){to[++tot]=y,nxt[tot]=head[x],head[x]=tot;}
 }G1,G2;
 int from[N*N];
 char s[N];
 int n,m,ans;
 #define y G1.to[j]
 int dfn[N],low[N],tim,stk[N],instk[N],bel[N],sum[N],val[N],Top;
 void tarjan(int x){
     dfn[x]=low[x]=++tim,stk[++Top]=x,instk[x]=;
     for(register int j=G1.head[x];j;j=G1.nxt[j]){
         if(!dfn[y])tarjan(y),MIN(low[x],low[y]);
         else if(instk[y])MIN(low[x],dfn[y]);
     }
     if(dfn[x]==low[x]){
         int tmp;
         do instk[tmp=stk[Top--]]=,bel[tmp]=x,++sum[x];while(tmp^x);
     }
 }
 #undef y
 #define y G2.to[j]
 bitset<N> S[N];
 void dp(int x){
     if(val[x])return;
     S[x][x]=;
     for(register int j=G2.head[x];j;j=G2.nxt[j])dp(y),S[x]|=S[y];
     for(register int i=;i<=n;++i)if(S[x][i])val[x]+=sum[i];
     val[x]=val[x]*sum[x];
 }
 #undef y
 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(n);
     for(register int i=;i<=n;++i){
         scanf("%s",s+);
         for(register int j=;j<=n;++j)if(i^j&&s[j]=='')G1.add(i,j),from[G1.tot]=i;
     }
     for(register int i=;i<=n;++i)if(!dfn[i])tarjan(i);
     for(register int t=,x,y;t<=G1.tot;++t){
         x=from[t],y=G1.to[t];
         if(bel[x]^bel[y])G2.add(bel[x],bel[y]);
     }
     for(register int i=;i<=n;++i)dp(i),ans+=val[i];
     printf("%d\n",ans);
     return ;
 }

---

方法二：Floyd传递闭包+bitset优化

这个优化真是妙啊，之前学Floyd都没想过这个优化。`````

连通性可以用二元逻辑关系表示，也就是可以用Floyd来做传递闭包。具体来说，就是设$f_{i,j}=0/1$表示$i$到$j$是否可达。然后转移的话是$\text{f[i][j]|=f[i][k]&f[k][j]}$。

注意这个转移。$f_{i,j}$相当于看成对于$i$点，用一个bitset表示他到$1\sim n$各点的可达性。

再观察，$f[i][k]$值已经是定的了，如果是$0$就不转移了，是$1$的话，对于每一位$j$，只要用$f[k]$对应的$j$位or一下就可以了。并且$f[i][k]$在本次转移中是不会变的。

所以，直接用bitset整体进行or操作就行了。$O(\frac{n^3}{32})$。

 #include<iostream>
 #include<cstdio>
 #include<cstring>
 #include<algorithm>
 #include<cmath>
 #include<queue>
 #include<bitset>
 #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=;
     while(isdigit(c))x=x*+(c&),c=getchar();return f?x=-x:x;
 }
 const int N=+;
 bitset<N> f[N];
 int n,ans;
 char s[N];

 int main(){//freopen("test.in","r",stdin);//freopen("test.ans","w",stdout);
     read(n);
     for(register int i=;i<=n;++i){
         scanf("%s",s+);
         for(register int j=;j<=n;++j)f[i][j]=s[j]==''||i==j;
     }
     for(register int k=;k<=n;++k)
         for(register int i=;i<=n;++i)
             if(f[i][k])f[i]|=f[k];
     for(register int i=;i<=n;++i)ans+=f[i].count();
     return printf("%d\n",ans),;
 }

---

方法三：暴力BFS+bitset标记松弛点（手写警告）

对每一个点，直接开始BFS，然后这个做法时间瓶颈在于每次都要枚举到所有边，那么我么尽量让他BFS时候从松弛点去走没有被访问过的点，避免走路径通向访问过的点的。可以用bitset维护目前所有点哪些没有被访问过，每个节点再开一个bitset表示他通往哪些点，每次BFS松弛的时候，把两者and一下，这样所有的$1$位就是没有访问过的，仅取出这些$1$，访问之即可。这样，就使得走过的边数量与点数相同，复杂度就降成了$O(n(\frac{n^2}{32}+n))$。不过，这种方法由于要取出$1$，如果直接对bitset每一位直接检验，复杂度就又回去了，而STL的bitset太垃圾没有这个取$1$复杂度和$1$数量相同的方法，所以我们要手写bitset。。。这种方法是yql讲过的，由于我太菜了，所以我不会写，实际要咕咕咕。