NOI模拟（5.14） JSOID1T2 防御网络 （bzoj5315）

防御网络

题目背景：

5.14 模拟 JSOI2018D1T2

分析：树型DP

 

不太显然的树型DP，显然原图就是一棵树上面有一些返祖边，对于一条不在任何一个环上的树边，只要在这条边的两边都有选点那么这条边就有贡献，而对于一个环，贡献为环长减去最大的空隙，空隙的定义就是，以这个环为根，其中的点如果整个子树中都没有点被选择，那这个点就是空点，一段连续的空点就是空隙。考虑如何进行环的dp，我们定义以环为根，得到环上每一个点的子树大小，然后枚举起点s和最长空隙l的长度，定义dp[i][0/1]表示，当前决定了s ~ j的选择方案，0表示还没有一个等于l的空隙，1表示已经有一个长度等于l的空隙。记录sum[i][0/1]表示，dp[s ~ i][0/1]之和，定义f[i]表示，2^size[i]- 1（选择i为根中的一个子集的方案数）转移就比较明显了。

dp[i][1] = dp[i][1]+ f[i] * (dp[i - len][0] + dp[i - len][1]) dp[i][1] = dp[i][1] + (sum[i - 1][1]- sum[i - len][1])

dp[i][0] = dp[i][0]+ (sum[i - 1][0] - sum[i - len][0])

值得注意的是，我们在dp过程中做出决策的只有s ~ i，那么另一半是没有决策的，也就是说，i + 1 ~ s也是一个空隙，那么最后这种方案的贡献应该是min(环长 - l, s - i)，直接用dp[i][1]统计贡献即可。详见代码，复杂度O(n³)

 

Source:

 

/*
	created by scarlyw
*/
#include <cstdio>
#include <string>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <set>
#include <queue>
#include <ctime>
#include <deque>
#include <iterator>
#include <map>

inline char read() {
	static const int IN_LEN = 1024 * 1024;
	static char buf[IN_LEN], *s, *t;
	if (s == t) {
		t = (s = buf) + fread(buf, 1, IN_LEN, stdin);
		if (s == t) return -1;
	}
	return *s++;
}

///*
template<class T>
inline void R(T &x) {
	static char c;
	static bool iosig;
	for (c = read(), iosig = false; !isdigit(c); c = read()) {
		if (c == -1) return ;
		if (c == '-') iosig = true;	
	}
	for (x = 0; isdigit(c); c = read()) 
		x = ((x << 2) + x << 1) + (c ^ '0');
	if (iosig) x = -x;
}
//*/

const int OUT_LEN = 1024 * 1024;
char obuf[OUT_LEN], *oh = obuf;
inline void write_char(char c) {
	if (oh == obuf + OUT_LEN) fwrite(obuf, 1, OUT_LEN, stdout), oh = obuf;
	*oh++ = c;
}

template<class T>
inline void W(T x) {
	static int buf[30], cnt;
	if (x == 0) write_char('0');
	else {
		if (x < 0) write_char('-'), x = -x;
		for (cnt = 0; x; x /= 10) buf[++cnt] = x % 10 + 48;
		while (cnt) write_char(buf[cnt--]);
	}
}

inline void flush() {
	fwrite(obuf, 1, oh - obuf, stdout);
}

 /*
template<class T>
inline void R(T &x) {
	static char c;
	static bool iosig;
	for (c = getchar(), iosig = false; !isdigit(c); c = getchar()) {
		if (c == -1) return ;
		if (c == '-') iosig = true;	
	}
	for (x = 0; isdigit(c); c = getchar()) 
		x = ((x << 2) + x << 1) + (c ^ '0');
	if (iosig) x = -x;
}
// */

const int MAXN = 200 + 10;
const int mod = 1000000000 + 7;

int n, m, x, y;
int f[MAXN], size[MAXN], p2[MAXN], father[MAXN], dep[MAXN];
std::vector<int> edge[MAXN];
bool vis[MAXN];
long long ans;

inline int mod_pow(int a, int b) {
    int ans = 1;
    for (; b; b >>= 1, a = (long long)a * a % mod)
        if (b & 1) ans = (long long)ans * a % mod;
    return ans;
}

inline void add_edge(int x, int y) {
    edge[x].push_back(y), edge[y].push_back(x);
}

inline void calc(int s, int len, int n) {
    static long long dp[MAXN][2], sum[MAXN][2];
    for (int i = s - 1; i <= n; ++i) 
        dp[i][0] = dp[i][1] = sum[i][0] = sum[i][1] = 0;
    dp[s][0] = sum[s][0] = f[s];
    for (int i = s + 1; i <= n; ++i) {
        if (i - len >= s) 
            dp[i][1] = (dp[i][1] + (dp[i - len][0] + 
                dp[i - len][1]) * f[i]) % mod;
        int l = std::max(s, i - len + 1) - 1;
        dp[i][1] = (dp[i][1] + (sum[i - 1][1] - sum[l][1] + mod) * f[i]) % mod;
        dp[i][0] = (dp[i][0] + (sum[i - 1][0] - sum[l][0] + mod) * f[i]) % mod;
        sum[i][0] = (sum[i - 1][0] + dp[i][0]) % mod;
        sum[i][1] = (sum[i - 1][1] + dp[i][1]) % mod;
        ans = (ans + std::min(i - s, n - len) * dp[i][1]) % mod;
    }
}

inline void solve(int u, int v) {
    int cnt = 0, last = 0, cur;
    for (cur = v; cur != u; last = cur, cur = father[cur]) 
        f[++cnt] = p2[size[cur] - size[last]], vis[cur] = true;
    f[++cnt] = p2[n - size[last]];
    for (int i = 1; i < cnt; ++i)
        for (int j = 1; j <= cnt - i; ++j)
            calc(i, j, cnt);
}

inline void dfs(int cur, int fa) {
    dep[cur] = dep[fa] + 1, father[cur] = fa, size[cur] = 1;
    for (int p = 0; p < edge[cur].size(); ++p) {
        int v = edge[cur][p];
        if (dep[v] == 0) dfs(v, cur), size[cur] += size[v];
        else if (dep[v] > dep[cur]) solve(cur, v);
    }

}

inline void solve() {
    R(n), R(m), p2[0] = 1;
    for (int i = 1; i <= m; ++i) R(x), R(y), add_edge(x, y);
    for (int i = 1; i <= n; ++i) p2[i] = p2[i - 1] * 2 % mod; 
    for (int i = 1; i <= n; ++i) p2[i]--;
    dfs(1, 0);
    for (int i = 2; i <= n; ++i)
        if (!vis[i]) 
            ans = (ans + (long long)p2[size[i]] * p2[n - size[i]]) % mod;
    ans = ans * mod_pow(p2[n] + 1, mod - 2) % mod;
    std::cout << ans;
}

int main() {
    // freopen("in.in", "r", stdin);
    solve();
    return 0;
}