BZOJ 2560 及其加强

有$n$个点，在$i,j$两个点之间连边的方案数有$c_{i,j}$种，也可以不连。求不同的连通导出子图个数（即有多少种连边方案使得整个图连通）。

$$nle16$$

加强：

$$nle20$$

令$g_S$为点集$S$的导出子图个数，$f_S$为点集$S$的连通导出子图个数。特别地，$f_{varnothing}=g_{varnothing}=0$。

$g$是好求的，由定义知

$$g_S=prod_{i,jin S}c_{i,j}+1$$

可以$O(n2^n)$求。

考虑怎么求$f$，在$nle16$时，直接子集$ ext{dp}$算不连通导出子图个数即可，即

$$f_S=g_S-sum_{1 in T land T subset S}f_Tg_{Ssetminus T}$$

时间复杂度$O(3^n)$。

但在$n$更大的时候，这个复杂度是不可接受的。

考虑集合幂级数，定义乘法为子集卷积，则

$$1+g=sum_{kge0}frac{f^k}{k!}$$

即

$$1+g=e^f$$

转换一下，得

$$f=ln(1+g)$$

那么对$g$做$ ext{FMT}$之后对每一项暴力递推求$ln$即可。

时间复杂度$O(n^22^n)$。

#include <bits/stdc++.h>

#define IL __inline__ __attribute__((always_inline))

#define For(i, a, b) for (int i = (a), i##end = (b); i <= i##end; ++ i)
#define FOR(i, a, b) for (int i = (a), i##end = (b); i < i##end; ++ i)
#define Rep(i, a, b) for (int i = (a), i##end = (b); i >= i##end; -- i)
#define REP(i, a, b) for (int i = (a) - 1, i##end = (b); i >= i##end; -- i)

typedef long long LL;

template <class T>
IL bool chkmax(T &a, const T &b) {
  return a < b ? ((a = b), 1) : 0;
}

template <class T>
IL bool chkmin(T &a, const T &b) {
  return a > b ? ((a = b), 1) : 0;
}

template <class T>
IL T mymax(const T &a, const T &b) {
  return a > b ? a : b;
}

template <class T>
IL T mymin(const T &a, const T &b) {
  return a < b ? a : b;
}

template <class T>
IL T myabs(const T &a) {
  return a > 0 ? a : -a;
}

const int INF = 0X3F3F3F3F;
const double EPS = 1E-8, PI = acos(-1.0);

#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
#define OK DEBUG("Passing [%s] in LINE %d...
", __FUNCTION__, __LINE__)

const int MASK = 20, MOD = 1000000007;

IL int add(int a, int b) {
  a += b;
  return a >= MOD ? a - MOD : a;
}

IL int sub(int a, int b) {
  a -= b;
  return a < 0 ? a + MOD : a;
}

IL int mul(int a, int b) {
  return (LL)a * b % MOD;
}

IL int quickPow(int a, int p) {
  int result = 1;
  for (; p; p >>= 1, a = mul(a, a)) {
    if (p & 1) {
      result = mul(result, a);
    }
  }
  return result;
}

typedef int PowerSeries[MASK + 1];

PowerSeries f[1 << MASK];
int g[1 << MASK], val[MASK][MASK], inv[MASK + 1], n;

IL void add(PowerSeries &a, const PowerSeries &b) {
  For(i, 0, n) {
    a[i] = add(a[i], b[i]);
  }
}

IL void sub(PowerSeries &a, const PowerSeries &b) {
  For(i, 0, n) {
    a[i] = sub(a[i], b[i]);
  }
}

IL void FMT(PowerSeries *f) {
  FOR(i, 0, n) {
    FOR(S, 0, 1 << n) {
      if (S & (1 << i)) {
        add(f[S], f[S ^ (1 << i)]);
      }
    }
  }
}

IL void IFMT(PowerSeries *f) {
  FOR(i, 0, n) {
    FOR(S, 0, 1 << n) {
      if (S & (1 << i)) {
        sub(f[S], f[S ^ (1 << i)]);
      }
    }
  }
}

IL void ln(PowerSeries &f) {
  PowerSeries tp;
  memcpy(tp, f, sizeof f);
  FOR(i, 1, n) {
    int cur = 0;
    FOR(j, 0, i) {
      cur = add(cur, mul(j + 1, mul(f[j + 1], tp[i - j])));
    }
    cur = mul(cur, inv[i + 1]);
    f[i + 1] = sub(f[i + 1], cur);
  }
}

int main() {
  scanf("%d", &n);
  For(i, 1, n) {
    inv[i] = quickPow(i, MOD - 2);
  }
  FOR(i, 0, n) {
    FOR(j, 0, n) {
      scanf("%d", &val[i][j]);
      val[i][j] = add(val[i][j], 1);
    }
  }
  g[0] = 1;
  FOR(S, 1, 1 << n) {
    int last = 0;
    FOR(i, 0, n) {
      if (S & (1 << i)) {
        last = i;
      }
    }
    g[S] = g[S - (1 << last)];
    FOR(i, 0, last) {
      if (S & (1 << i)) {
        g[S] = mul(g[S], val[i][last]);
      }
    }
    f[S][__builtin_popcount(S)] = g[S];
  }
  g[0] = 0;
  FMT(f);
  FOR(i, 0, 1 << n) {
    ln(f[i]);
  }
  IFMT(f);
  printf("%d
", f[(1 << n) - 1][n]);
  return 0;
}