UOJ #181. 【UR #12】密码锁 背包

题意

给你个竞赛图，和几条有向边的定向的概率，其余的边的定向的概率都是0.5，求出期望强连通数

分析

先考虑m=0的情况：
竞赛图缩点之后，就剩一条链
然后对于这样的一条链，有两种算法可以求出强连通数期望：
一个是枚举链最后的一个强连通分量的大小：
$f[n] = \sum\limits_{i=1}^{n} f[n-i] \binom{n}{i} g[i] (\frac{1}{2})^{i(n-i)}$
$g[n]$是n个点变成一个强连通的方案数的期望

然后这个的话又要预处理很多东西，而且因为有些边的概率是不一样的，在处理$g[i]$的时候时间和空间与n为指数有关，感觉有点凉

换个方向：

$f[S] = 1+\sum\limits_{T\subset S,T\neq \emptyset} \prod\limits_{x\in T,y \in S-T}P(x,y)$

对于任意一条这样的链，强连通的个数等于从这条链中切开后，变成两边的集合互相不连边的方案数+1，我们对于每个这样的“切开”单独考虑，乘上概率即可，对于S集合和S-T集合长什么样，我们不用考虑，只要知道贡献加了1，即可

然后对于这道题，如果有一些边的概率为$p$,则把这条边看成$2p$，这样的话我们就可以把所有边的概率变成0.5来处理，在过程中乘上$2p$即可

我们把概率为0.5的边先不看，对答案有影响的是有给定概率的边，然后把这些边建出来，变成很多个弱联通分量，对于每个弱联通分量求出对答案的贡献，我们发现答案只要知道有多少个点在S集中，就可以求出来，那么对于这样的一个弱联通分量，也求出有多少个点在S集中，然后不同的弱联通分量通过背包，就可以得到答案

枚举弱联通分量的哪些点在S集，然后一条边有贡献当且仅当两个端点一个在S集，一个在T集，具体可以看代码

代码

#include <bits/stdc++.h>
#define bin(i) (1<<(i))
#define cl clear
#define pb push_back
using namespace std;
typedef long long ll;
const ll N = 40;
const ll Mod = 998244353;
inline ll read()
{
  ll p=0; ll f=1; char ch=getchar();
  while(ch<'0' || ch>'9'){if(ch=='-') f=-1; ch=getchar();}
  while(ch>='0' && ch<='9'){p=p*10+ch-'0'; ch=getchar();}
  return p*f;
}

void upd(ll &x,ll y){x=(x+y)%Mod;}
ll qpow(ll x,ll k,ll mo){ll s=1; while(k){if(k&1) s=s*x%mo; x=x*x%mo; k>>=1;} return s;}

struct node{ll x,y,next,d;}edge[N]; ll len,first[N];
void ins(ll x,ll y,ll d){len++; edge[len].x=x; edge[len].y=y; edge[len].d=d; edge[len].next=first[x]; first[x]=len;}
vector<ll>g[N];

ll ny2[N*N];

ll vis[N],scnt,id[N]; vector<ll> V;
void dfs(ll x)
{
  id[x] = V.size(); vis[x] = scnt; V.pb(x);
  for(ll i=0;i<g[x].size();i++)
  {
    ll y = g[x][i];
    if(!vis[y]) dfs(y);
  }
}

ll h[N][N],f[N][N],n,m;

void calc()
{
  for(ll s=0;s<bin(V.size());s++)
  {
    ll sum = 1;
    for(ll j=1;j<=m;j++)
    {
      ll u = edge[j].x; ll v = edge[j].y;
      if(vis[u] != scnt) continue;
      if( ( (s>>id[u]) & 1) != ( (s>>id[v]) & 1) ) 
        sum = sum * 2 % Mod * ( ( (s>>id[u]) & 1) ? edge[j].d : (1 - edge[j].d + Mod) ) % Mod; 
    }
    upd(h[scnt][__builtin_popcount(s)],sum);
  }
}

int main()
{

  n = read(); m = read(); len = 0; memset(first,-1,sizeof(first)); ll ny = qpow(10000,Mod-2,Mod);
  for(ll i=1;i<=m;i++){ll x = read(); ll y = read(); ll d = read(); d = d * ny % Mod; ins(x,y,d); g[x].pb(y); g[y].pb(x);}
  ny2[0] = 1; ny2[1] = qpow(2,Mod-2,Mod); for(ll i=2;i<=n*n;i++) ny2[i] = ny2[i-1] * ny2[1] % Mod;
  scnt = 0; memset(vis,0,sizeof(vis)); for(ll i=1;i<=n;i++) if(!vis[i]) {scnt++; V.cl(); dfs(i); calc();}

  for(ll j=0;j<=n;j++) f[1][j] = h[1][j];
  for(ll i=2;i<=scnt;i++)
  {
    for(ll j=0;j<=n;j++) for(ll k=0;k<=j;k++)
      upd(f[i][j] , f[i-1][j-k] * h[i][k]);
  }

  for(ll i=1;i<=n;i++) f[scnt][i] = f[scnt][i] * ny2[i * (n-i)] % Mod;
  ll ans = 0;
  for(ll i=1;i<=n;i++) upd(ans , f[scnt][i]);
  ans = ans * qpow(10000 , n*(n-1) , Mod) % Mod;

  return printf("%lld\n",ans),0;
}