Submission #19495216

---

Source Code Expand

//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
//#include <atcoder/all>
#include <ext/pb_ds/assoc_container.hpp>
using namespace __gnu_pbds;
template <typename T>
using ordered_set = tree<T, null_type, std::less<T>, rb_tree_tag, tree_order_statistics_node_update>;
using namespace std;
#define all(n) begin(n), end(n)
const long long INF = INT_MAX / 2;
typedef long long ll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef unsigned long long ull;
template <class T>
bool chmax(T &a, const T &b)
{
    if (a < b)
    {
        a = b;
        return 1;
    }
    return 0;
}
template <class T>
bool chmin(T &a, const T &b)
{
    if (b < a)
    {
        a = b;
        return 1;
    }
    return 0;
}
template <typename T>
vector<T> make_v(size_t a) { return vector<T>(a); }

template <typename T, typename... Ts>
auto make_v(size_t a, Ts... ts)
{
    return vector<decltype(make_v<T>(ts...))>(a, make_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type
fill_v(T &t, const V &v) { t = v; }

template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type
fill_v(T &t, const V &v)
{
    for (auto &e : t)
        fill_v(e, v);
}
int main()
{
    ios::sync_with_stdio(false);
    cin.tie(0);
    // 解法
    // 与えられたグラフを G = (V,E) とする
    // 頂点集合 V を半分に分割する。それを V_1,V_2 とおく
    // V_1 の部分集合を列挙する(たかだか2^20個)
    // S_1 ⊂ V_1 に対して、S_1 が独立集合かどうかを判定する ... (1)
    // もしそうなら、S_1 の任意の点と繋がっていないような V_2 の頂点全体を U とする ... (2)
    // U の最大独立集合を求めて ... (3) 、それを S_2 とする
    // max { |S_1| + |S_2| } がこたえ

    // (1) bitDPでできる。 dp[S] := S が独立集合のとき、かつその時に限り true とする. true で初期化しておく
    // (v,u) ∈ E , v,u ∈ V_1 に対し、 dp[{v,u}] = false

    // 遷移 : dp[S] = false のとき、 任意の v ∈ V_1 \ S に対して dp[S ⋃ {v}] = false

    // (2) これも bitDP でできる。 dp[S] := S の任意の点と繋がっていないような V_2 の頂点全体の集合 とすると
    // dp[{}] = V_2
    // dp[{v}] = V_2 \ {u | u ∈ V_2, (v,u) ∈ E}
    // dp[S ⋃ {v}] = dp[S] \ {u | u ∈ V_2, (v,u) ∈ E} = dp[S] ⋂ dp[{v}]

    // (3) これも bitDP でできる。 dp[S] := S の最大独立集合のサイズ とすると、
    // dp[S] = if S が独立集合 then |S| else 0
    // と初期化しておいて、
    // dp[S ⋃ {v}] = max(dp[S ⋃ {v}],dp[S]) としたらよい
    int n, m;
    cin >> n >> m;
    int n1 = n / 2, n2 = n - n1; // V_1 と V_2 のサイズ
    const int MAX = 1 << 20;
    vector<bool> is_independ1(MAX, true), is_independ2(MAX, true);
    vector<int> disjoint_set(MAX);
    vector<int> independ_size(MAX);

    vint a(m), b(m);
    for (int i = 0; i < m; i++)
    {
        cin >> a[i] >> b[i];
        a[i]--;
        b[i]--;
        if (a[i] < n1 and b[i] < n1)
        {
            is_independ1[(1 << a[i]) | (1 << b[i])] = false;
        }
        if (a[i] >= n1 and b[i] >= n1)
        {
            is_independ2[(1 << (a[i] - n1)) | (1 << (b[i] - n1))] = false;
        }
    }
    for (int bit = 0; bit < (1 << n1); bit++)
    {
        if (!is_independ1[bit])
        {
            for (int i = 0; i < n1; i++)
            {
                is_independ1[bit | (1 << i)] = false;
            }
        }
    }
    for (int bit = 0; bit < (1 << n2); bit++)
    {
        if (!is_independ2[bit])
        {
            for (int i = 0; i < n2; i++)
            {
                is_independ2[bit | (1 << i)] = false;
            }
        }
    }
    disjoint_set[0] = (1 << n2) - 1;
    for (int i = 0; i < n1; i++)
    {
        disjoint_set[(1 << i)] = disjoint_set[0];
        for (int j = 0; j < m; j++)
        {
            if (a[j] == i and b[j] >= n1)
            {
                disjoint_set[(1 << i)] &= ~(1 << (b[j] - n1));
            }
            else if (b[j] == i and a[j] >= n1)
            {
                disjoint_set[(1 << i)] &= ~(1 << (a[j] - n1));
            }
        }
    }
    for (int bit = 0; bit < (1 << n2); bit++)
    {
        for (int i = 0; i < n2; i++)
        {
            disjoint_set[bit | (1 << i)] = disjoint_set[bit] & disjoint_set[(1 << i)];
        }
    }
    for (int bit = 0; bit < (1 << n2); bit++)
    {
        if (is_independ2[bit])
            independ_size[bit] = __builtin_popcount(bit);
    }
    for (int bit = 0; bit < (1 << n2); bit++)
    {
        for (int i = 0; i < n2; i++)
        {
            chmax(independ_size[bit | (1 << i)], independ_size[bit]);
        }
    }
    int ans = 0;
    for (int bit = 0; bit < (1 << n1); bit++)
    {
        if (is_independ1[bit])
        {
            int u = disjoint_set[bit];
            int s1 = __builtin_popcount(bit), s2 = independ_size[u];
            chmax(ans, s1 + s2);
        }
    }
    cout << ans << endl;
    return 0;
}

Submission Info

Judge Result