CodeForces Gym101173 Bipartite Blanket

最新推荐文章于 2021-10-28 19:09:47 发布

原创最新推荐文章于 2021-10-28 19:09:47 发布 · 424 阅读

0 ·

CC 4.0 BY-SA版权

图论------------------------- 同时被 2 个专栏收录

10 篇文章

订阅专栏

图论-二分图

2 篇文章

订阅专栏

本文介绍了一种利用二分图匹配和Hall定理解决特定问题的方法。该问题要求找出所有点权之和不低于给定阈值的子集，并确保这些子集能被某次匹配所覆盖。文章通过左右拆分的方式简化问题，并使用Hall定理验证子集的有效性。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

$Source:$ 2016-2017 ACM-ICPC, Central Europe Regional Contest (CERC 16)

$Problem:$ 给你一个二分图，每个点都有点权，问这个图有多少个子集，满足点权之和不小于给定值 $t$ ，并且被某个匹配覆盖。

$Idea:$
容易证明若 $X$ 集存在子集 $A$ 属于某一匹配， $Y$ 集存在子集 $B$ 属于某一匹配，那么 $A$ ， $B$ 一定同属于某一匹配，这样就可以左右拆开来做了。
而判定子集是否合法，可以用到Hall定理。

Hall定理：
若二分图存在完美匹配，且大小为 $n$ ，那么取任意 $1\le k\le n$ ，均满足 $X$ 集选出 $k$ 个不同的点，它们连向 $Y$ 集的点的个数不小于 $k$ 。

$Code:$

#include<bits/stdc++.h>
using namespace std;

#define fi first
#define se second
#define pb push_back
#define ALL(A) (A).begin(), (A).end()
#define CLR(A, X) memset(A, X, sizeof(A))
typedef long long LL;
typedef pair<int, int> PII;
const double eps = 1e-10;
const double PI = acos(-1.0);
const auto INF = 0x3f3f3f3f;
int dcmp(double x) { if(fabs(x) < eps) return 0; return x<0?-1:1; }

const int MAXN = 20;

int lt[1<<20], rt[1<<20], ok[1<<20], cnt[1<<20];
int a[20], b[20];
vector<int> g1, g2;

void update(int *A, int *C, int n, vector<int> &g) {
    for(int S = 0; S < (1<<n); S++) {
        int sum = 0;
        ok[S] = 1;
        for(int i = 0; i < n; i++) if(S & (1<<i)) {
            A[S] |= A[S^(1<<i)];
            ok[S] &= ok[S^(1<<i)];
            sum += C[i];
        }
        if(ok[S] && cnt[A[S]]>=cnt[S]) g.pb(sum);
        else ok[S] = 0;
    }
}

int main() {
    int n, m, x;
    scanf("%d%d", &n, &m);
    for(int i = 0; i < n; i++) {
        for(int j = 0; j < m; j++) {
            scanf("%1d", &x);
            if(x) {
                lt[1<<i] |= 1<<j;
                rt[1<<j] |= 1<<i;
            }
        }
    }
    for(int i = 0; i < n; i++) {
        scanf("%d", &a[i]);
    }
    for(int i = 0; i < m; i++) {
        scanf("%d", &b[i]);
    }
    int nm = max(n, m);
    for(int S = 0; S < (1<<nm); S++) {
        cnt[S] = cnt[S>>1]+(S&1);
    }
    update(lt, a, n, g1);
    update(rt, b, m, g2);
    scanf("%d", &x);
    sort(ALL(g1));
    LL ans = 0;
    for(int y:g2) {
        int t = lower_bound(ALL(g1), x-y)-g1.begin();
        ans += g1.size()-t;
    }
    printf("%lld\n", ans);
    return 0;
}