2020牛客多校一 I. 1 or 2 (一般图匹配带花树+拆点)

题意：有一个n个点,m条边的图 ，给出每个点的度数，问是否可以成为该图的子图。

题解：一般图匹配带花树
跟 HDU3551 一模一样，不过这题比航电的数据弱。

这篇题解写的很详细了

我们需要拆点，包括点和边。

比如对于边u -> v，我们将这条边分别拆成两个点1和2，再对点u的度deg[u]编号与1建双边，对点v的度deg[v]编号与2建双边。

这是一般图，我们用带花树跑最大匹配，若是完美匹配则能成为子图。

如何证明呢，最大匹配中 度的拆点 与 边的拆点 匹配时，同一边的另一个拆点也匹配到一个度的拆点，就表示这条边相连了。而只有 边的拆点 与 边的拆点 相连时，就是删除的边。完美匹配的话就是度的拆点都有与边的拆点连线。

#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<algorithm>
#include<queue>
#include<stack>
#include<cmath>
#include<vector>
#include<fstream>
#include<set>
#include<map>
#include<sstream>
#include<iomanip>
#define ll long long
using namespace std;

//一般图匹配带花树
const int MAXN = 2500;
int N; //点的个数，点的编号从1到N
bool Graph[MAXN][MAXN];
int Match[MAXN];
bool InQueue[MAXN], InPath[MAXN], InBlossom[MAXN];
int Head, Tail;
int Queue[MAXN];
int Start, Finish;
int NewBase;
int Father[MAXN], Base[MAXN];
int Count;//匹配数，匹配对数是Count/2
void Push(int u) {
    Queue[Tail] = u;
    Tail++;
    InQueue[u] = true;
}
int Pop() {
    int res = Queue[Head];
    Head++;
    return res;
}
int FindCommonAncestor(int u, int v) {
    memset(InPath, false, sizeof(InPath));
    while (true) {
        u = Base[u];
        InPath[u] = true;
        if (u == Start) break;
        u = Father[Match[u]];
    }
    while (true) {
        v = Base[v];
        if (InPath[v])break;
        v = Father[Match[v]];
    }
    return v;
}
void ResetTrace(int u) {
    int v;
    while (Base[u] != NewBase) {
        v = Match[u];
        InBlossom[Base[u]] = InBlossom[Base[v]] = true;
        u = Father[v];
        if (Base[u] != NewBase) Father[u] = v;
    }
}
void BloosomContract(int u, int v) {
    NewBase = FindCommonAncestor(u, v);
    memset(InBlossom, false, sizeof(InBlossom));
    ResetTrace(u);
    ResetTrace(v);
    if (Base[u] != NewBase) Father[u] = v;
    if (Base[v] != NewBase) Father[v] = u;
    for (int tu = 1; tu <= N; tu++)
        if (InBlossom[Base[tu]]) {
            Base[tu] = NewBase;
            if (!InQueue[tu]) Push(tu);
        }
}
void FindAugmentingPath() {
    memset(InQueue, false, sizeof(InQueue));
    memset(Father, 0, sizeof(Father));
    for (int i = 1; i <= N; i++)
        Base[i] = i;
    Head = Tail = 1;
    Push(Start);
    Finish = 0;
    while (Head < Tail) {
        int u = Pop();
        for (int v = 1; v <= N; v++)
            if (Graph[u][v] && (Base[u] != Base[v]) && (Match[u] != v)) {
                if ((v == Start) || ((Match[v] > 0) && Father[Match[v]] > 0))
                    BloosomContract(u, v);
                else if (Father[v] == 0) {
                    Father[v] = u;
                    if (Match[v] > 0)
                        Push(Match[v]);
                    else
                    {
                        Finish = v;
                        return;
                    }
                }
            }
    }
}
void AugmentPath() {
    int u, v, w;
    u = Finish;
    while (u > 0) {
        v = Father[u];
        w = Match[v];
        Match[v] = u;
        Match[u] = v;
        u = w;
    }
}
void Edmonds() {
    memset(Match, 0, sizeof(Match));
    for (int u = 1; u <= N; u++)
        if (Match[u] == 0) {
            Start = u;
            FindAugmentingPath();
            if (Finish > 0)AugmentPath();
        }
}
int n, m, deg[MAXN], u, v, id[MAXN][MAXN];
int main() {
    while (~scanf("%d%d", &n, &m)) {
        memset(Graph, false, sizeof(Graph));
        memset(id, 0, sizeof(id));
        N = 0;
        for (int i = 1; i <= n; i++) {
            scanf("%d", &deg[i]);
            for (int j = 1; j <= deg[i]; j++) id[i][j] = ++N;
        }
        for (int i = 1; i <= m; i++) {
            scanf("%d%d", &u, &v);
            int x = N + 1, y = N + 2;
            Graph[x][y] = true;
            Graph[y][x] = true;
            for (int i = 1; i <= deg[u]; i++) {
                Graph[id[u][i]][x] = true;
                Graph[x][id[u][i]] = true;
            }
            for (int i = 1; i <= deg[v]; i++) {
                Graph[id[v][i]][y] = true;
                Graph[y][id[v][i]] = true;
            }
            N += 2;
        }
        Edmonds();  //进行匹配
        Count = 0;
        for (int u = 1; u <= N; u++)
            if (Match[u] > 0)
                Count++;
        if (Count == N) puts("Yes");
        else puts("No");
    }
    return 0;
}