[ARC105F] Lights Out on Connected Graph 题解

合集 - 题解(65)

1.[ARC126C] Maximize GCD 题解2023-08-142.[ARC126D] Pure Straight 题解2023-08-143.[ABC215D] Coprime 2 题解2023-08-144.CF793F Julia the snail 题解2023-08-145.CF1845D Rating System 题解2023-08-146.[JOI 2023 Final] Advertisement 2 题解2023-08-157.CF1513D GCD and MST 题解2023-08-158.「JOISC 2016 Day 2」雇佣计划 题解2023-08-159.[ABC134F] Permutation Oddness 题解2023-08-1510.CF1188D Make Equal 题解2023-08-1511.[ARC096E] Everything on It 题解2023-08-1512.[ARC117D] Miracle Tree 题解2023-08-1713.[JOISC 2014 Day3] 电压 题解2023-08-1714.CF803C Maximal GCD 题解2023-08-1715.CF1787E The Harmonization of XOR 题解2023-08-1716.CF1762D GCD Queries 题解2023-08-1717.[AGC061C] First Come First Serve 题解2023-08-1818.CF1575G GCD Festival 题解2023-08-1819.CF1656D K-good 题解2023-08-1920.CF1823F Random Walk 题解2023-08-2021.[ABC297G] Constrained Nim 2 题解2023-08-2022.CF1762E Tree Sum 题解2023-08-2123.CF1798E Multitest Generator 题解2023-08-2224.P7486 「Stoi2031」彩虹 题解2023-08-2225.CF1485C Floor and Mod 题解2023-08-2326.CF1681E Labyrinth Adventures 题解2023-08-2327.CF1023F Mobile Phone Network 题解2023-08-2428.CF258D Little Elephant and Broken Sorting 题解2023-08-2529.P7485 「Stoi2031」枫 题解2023-08-2530.[AGC030D] Inversion Sum 题解2023-08-2531.CF1815D XOR Counting 题解2023-08-2632.CF1864B Swap and Reverse 题解2023-08-3033.CF1864C Divisor Chain 题解2023-08-3034.CF1174E Ehab and the Expected GCD Problem 题解2023-08-3135.[AGC051B] Bowling 题解2023-09-0136.CF1626F A Random Code Problem 题解2023-09-0137.CF915G Coprime Arrays 题解2023-09-0238.[ABC318E] Sandwiches 题解2023-09-0339.[ABC318G] Typical Path Problem 题解2023-09-0340.CF838D Airplane Arrangements 题解2023-09-0341.[ABC319G] Counting Shortest Paths 题解2023-09-1142.[ABC313F] Flip Machines 题解2023-09-1543.[ABC320F] Fuel Round Trip 题解2023-09-1744.[ARC125B] Squares 题解2023-09-2745.[ARC124C] LCM of GCDs 题解2023-09-2746.[ARC135C] XOR to All 题解2023-09-2847.CF1874C Jellyfish and EVA 题解2023-10-0148.[ARC136C] Circular Addition 题解2023-10-0249.[ARC150D] Removing Gacha 题解2023-10-0350.高橋君 题解2023-10-0451.CF1842G Tenzing and Random Operations 题解2023-10-1052.[ARC167D] Good Permutation 题解2023-10-1653.[AGC061A] Long Shuffle 题解2023-10-2654.[ARC104B] DNA Sequence 题解2023-11-0255.[ARC104C] Fair Elevator 题解2023-11-0256.[ARC104D] Multiset Mean 题解2023-11-0257.[ARC104E] Random LIS 题解2023-11-0358.[ABC327G] Many Good Tuple Problems 题解2023-11-0559.[ARC105C] Camels and Bridge 题解2023-11-0660.[ARC105D] Let's Play Nim 题解2023-11-0661.[ARC105E] Keep Graph Disconnected 题解2023-11-06

62.[ARC105F] Lights Out on Connected Graph 题解2023-11-07

63.[ARC106E] Medals 题解2023-11-1364.[ARC107F] Sum of Abs 题解2023-11-1565.[ARC106F] Figures 题解2023-11-16

收起

题意

给定一个 $N$ 个点 $M$ 条边的简单无向联通图 $G$。每个边有红和蓝两种颜色，初始时每条边均是红色。

现在通过移除 $G$ 中的一些边来获得一个新的无向图 $G^{\prime }$，求在所有的 $2^M$ 种方案中有多少种方案可以使得 $G^{\prime }$ 满足如下条件：

• $G^{\prime }$ 是联通图

• 通过采取如下操作可以使得所有的边变为蓝色：

  • 选择一个点 $u$，将与 $u$ 相邻的所有边变为蓝色

对 $998244353$ 取模。

• $1\le N\le 17$
• $N-1\le M\le \frac{N(N-1)}{2}$

题解

首先我们可以发现，符合要求的子图 $G^{\prime }$ 一定是二分图。

发现联通的要求很难满足，故考虑先计算不考虑联通限制下的答案。

设 $g(S)$ 表示仅考虑与点集 $S$ 相关的边，求使得图为二分图但不要求联通的方案数。

考虑对图进行黑白染色，通过枚举白色点集合 $T$ 可以完成计算：

$$g(S)=\sum _{T\subseteq S}{2}^{{\mathrm{count}}_S-{\mathrm{count}}_T-{\mathrm{count}}_{S\setminus T}}$$

其中 ${\mathrm{count}}_S$ 表示与点集 $S$ 相关的边的数量。可以发现上式中的指数项即连接黑色点和白色点的边的数量。

${\mathrm{count}}_S$ 的值可以在通过对每个点集枚举所有边来实现，这里不多赘述。

下面考虑如何计算联通的方案数。

设 $f(S)$ 表示仅考虑与点集 $S$ 相关的边，求使得图为二分图且要求联通的方案数。

可以发现 $f(S)$ 中包含的方案实际上是 $g(S)$ 中去除了不联通的方案，因此可以考虑枚举出所有不联通的方案。

若不联通，那么图一定具有至少两个联通块，那么我们可以枚举 $S$ 中编号最小的点所在的联通块，然后枚举该联通块中的点集 $T$，那么 $S\setminus T$ 的连通性是没有限制。设 $u=\underset{x\in S}{min}x$，即点集 $S$ 中的最小元素，那么有转移

$$f(S)=g(S)-\sum _{T\subset S\wedge u\in T}f(T)\times g(S\setminus T)$$

时间复杂度 $O(3^N+2^{N}M)$，空间复杂度 $O(2^N+M)$，可以通过。

Code

#include <bits/stdc++.h>

typedef long long valueType;
typedef std::vector<valueType> ValueVector;
typedef std::pair<valueType, valueType> ValuePair;
typedef std::vector<ValuePair> PairVector;

namespace MODINT {
    constexpr valueType MOD = 998244353;

    template<typename T1, typename T2, typename T3 = valueType>
    void Inc(T1 &a, T2 b, const T3 &mod = MOD) {
        a = a + b;

        if (a >= mod)
            a -= mod;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    void Dec(T1 &a, T2 b, const T3 &mod = MOD) {
        a = a - b;

        if (a < 0)
            a += mod;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    T1 sum(T1 a, T2 b, const T3 &mod = MOD) {
        return a + b >= mod ? a + b - mod : a + b;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    T1 sub(T1 a, T2 b, const T3 &mod = MOD) {
        return a - b < 0 ? a - b + mod : a - b;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    T1 mul(T1 a, T2 b, const T3 &mod = MOD) {
        return (long long) a * b % mod;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    void Mul(T1 &a, T2 b, const T3 &mod = MOD) {
        a = (long long) a * b % mod;
    }

    template<typename T1, typename T2, typename T3 = valueType>
    T1 pow(T1 a, T2 b, const T3 &mod = MOD) {
        T1 result = 1;

        while (b > 0) {
            if (b & 1)
                Mul(result, a, mod);

            Mul(a, a, mod);
            b = b >> 1;
        }

        return result;
    }

    constexpr valueType Inv2 = (MOD + 1) / 2;
}// namespace MODINT

using namespace MODINT;

bool check(valueType x, valueType k) {
    return x & (1 << (k - 1));
}

valueType lowBit(valueType n) {
    return n & -n;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);

    valueType N, M;

    std::cin >> N >> M;

    PairVector edges(M);

    for (auto &iter : edges)
        std::cin >> iter.first >> iter.second;

    valueType const S = 1 << N;

    ValueVector count(S, 0);

    for (valueType s = 0; s < S; ++s) {
        for (valueType i = 0; i < M; ++i) {
            auto [u, v] = edges[i];

            if (check(s, u) && check(s, v))
                Inc(count[s], 1);
        }
    }

    ValueVector G(S, 0), F(S, 0);

    for (valueType s = 0; s < S; ++s) {
        G[s] = 1;

        for (valueType t = s; t > 0; t = (t - 1) & s)
            Inc(G[s], pow(2, count[s] - count[t] - count[s ^ t]));
    }

    for (valueType s = 0; s < S; ++s) {
        F[s] = G[s];

        for (valueType t = s; t > 0; t = (t - 1) & s)
            if (lowBit(t) < lowBit(s ^ t))
                Dec(F[s], mul(F[t], G[s ^ t]));
    }

    std::cout << mul(F[S - 1], Inv2) << std::endl;

    return 0;
}