P8867 [NOIP2022] 建造军营

题目链接

算法

Tarjan 缩点, 树形 dp.

题意

给定一个无向连通图, 我们要选择某些点并且选择某些边 (被选择的边不能被删除), 使得当任意一条没有被选择的边被删除后我们选择的点两两连通.

求总共的方案数.

思路

容易发现一条删除后对连通性有影响的边只可能是割边,
我们对一条不是割边的边可看守可不看守,
于是可以考虑将每一个连通分量缩成一个点.

缩完点后, 图将变成一棵树. (因为缩点后形成的图连通且没有环)

我们令 \(E_i\) 表示在 \(i\) 这个连通分量里的边数;
\(P_i\) 表示连通分量 \(i\) 里的点数.

那么这个问题可以转化为:

给定一颗无根树, 每个节点都有 \(2^{E_i}\) 种方案不建造军营和 \((2^{P_i+E_i}-2^{E_i})\) 种方案建造军营.
求总共有多少种方案?

因为要统计所有的方案数, 所以我们可以考虑动态规划.

假定 1 号节点为根.
设 \(f_{u,0/1}\) 表示以 \(u\) 为根的子树中没有/有建造军营的方案总数.
但是对于 \(f_{i,1}\), 我们没法具体知道需要守护子树里的哪一条边, 不好转移.

考虑对状态增加限制.
令 \(f_{u,1}\) 表示以 \(u\) 为根的子树里建造了军营并且所有的军营一定通过已经派兵看守的边与 \(u\) 连通.
对于每个节点 \(u\), 我们强制除 \(u\) 子树外的所有点都不建军营, 同时不选 \(fa_u \rightarrow u\) 的边 (原因具体可以看下图).

令 \(s_u\) 为以 \(u\) 为根的子树内的总边数, 那么 \(s_u = E_u + \sum_{v \in son_u} (s_v+1)\),

则有 \(ans+=f_{u,1}×2^{s_1-s_u-1}\).

而对于 1 号节点, 因为其没有父亲节点, 所以 \(ans+=f_{1,1}\).

接下来考虑转移.

对于 \(f_{u,0}\), \(f_{u,0}=2^{E_u} × \prod_{v \in son_u}2\ f_{v,0}\).
再看 \(f_{u,1}\).

• 1. 如果新增前都还未建造军营, 那么以 \(v\) 为根的子树内一定有军营, 即 \(f_{u,1}×=f_{v,0}×f_{v,1}\).
• 2. 如果新增前已经建造过军营, 那么以 \(v\) 为根的子树中军营可有可无, 且当以 \(v\) 为根的子树中没有军营时, \(v\) 与 \(u\) 是否连通均可, 故 \(f_{u,1}×=(2\ f_{v,0}+f_{v,1})\).

初始化时, \(f_{u,0}=2^{E_u},\ f_{u,1}=2^{P_u+E_u}-2^{E_u}\).

复制代码
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
#include "iostream"
#include "stack"

using namespace std;

const int N = 5e5 + 10, mod = 1e9 + 7;

int n, m;
basic_string<int> g[N];

inline void init()
{
    cin >> n >> m;
    for (int i = 1; i <= m; ++i)
    {
        int u, v;
        cin >> u >> v;
        g[u].push_back(v);
        g[v].push_back(u);
    }
    return;
}

class Solution
{

private:
    #define int long long

    int lw[N], dfn[N], cnt = 0;
    int sz[N], c[N], sccnt = 0;
    bool vis[N];
    stack<int> st;

    inline int qpow(int x, int y)
    {
        int ans = 1;
        while (y)
        {
            if (y & 1)
                ans = (1ll * ans * x) % mod;
            y >>= 1;
            x = (1ll * x * x) % mod;
        }
        return ans;
    }

    void Tarjan(int u, int fa)
    {
        lw[u] = dfn[u] = ++cnt;
        st.push(u), vis[u] = 1;
        for (int v : g[u])
        {
            if (v == fa)
                continue;
            if (!dfn[v])
                Tarjan(v, u), lw[u] = min(lw[u], lw[v]);
            else if (vis[v])
                lw[u] = min(lw[u], dfn[v]);
        }
        if (!(dfn[u] ^ lw[u]))
        {
            int t = -1;
            sccnt++;
            while (t ^ u)
            {
                t = st.top(), st.pop();
                sz[sccnt]++, c[t] = sccnt, vis[t] = 0;
            }
        }
        return;
    }

    basic_string<int> e[N];
    int s[N], ecnt[N];

    void dfs(int u, int fa)
    {
        s[u] = ecnt[u];
        for (int v : e[u])
        {
            if (v == fa)
                continue;
            dfs(v, u);
            s[u] += s[v] + 1;
        }   
        return;
    }

    int f[N][2];
    int ans = 0;

    void dp(int u, int fa)
    {
        for (int v : e[u])
        {
            if (v == fa)
                continue;
            dp(v, u);
            f[u][1] = (1ll * f[u][1] * ((f[v][1] + (f[v][0] << 1) % mod) % mod) % mod + 1ll * f[u][0] * f[v][1] % mod) % mod;
            f[u][0] = 1ll * f[u][0] * ((f[v][0] << 1) % mod) % mod;
        }
        if (!(u ^ 1))
            ans = (ans + f[u][1]) % mod;
        else
            ans = (ans + 1ll * f[u][1] * qpow(2, s[1] - s[u] - 1) % mod) % mod;
        return;
    }

public:
    inline void calculate()
    {

        Tarjan(1, -1);

        for (int i = 1; i <= n; ++i)
            for (int j : g[i])
            {
                if (c[i] != c[j])
                    e[c[i]].push_back(c[j]);
                else
                    ecnt[c[i]]++;
            }

        for (int i = 1; i <= sccnt; ++i)
        {
            ecnt[i] >>= 1;
            f[i][0] = qpow(2, ecnt[i]);
            f[i][1] = (qpow(2, sz[i] + ecnt[i]) - f[i][0] + mod) % mod;
        }
        dfs(1, -1);
        dp(1, -1);

        cout << ans << '\n';

        return;
    }

} sol;

inline void solve()
{
    init();
    sol.calculate();
    return;
}

signed main()
{
    cin.tie(nullptr)->ios::sync_with_stdio(false);
    solve();
    return 0;
}