牛客多校1——1or2

题意

　　给定一张n点m边的图，以及每个点的理想出入度，求是否能够通过选择某些边来使得新图上每个点的出入度为理想出入度

做法

　　由于d[i]的范围为1~2，说明新图中的连通分量要么是链，要么是环。对于此类最大匹配问题，可以用网络流来解决，但是由于可能存在奇环，这将导致找增广路时，传统的dinic算法时间复杂度陡增。

　　如何处理带奇环的图最大匹配问题，可以使用带花树算法来做，也就是一般图最大图匹配问题。

　　当两个点的出入度都等于1时，直接把两个点连起来

　　当两个相连点的出入度都等于2时，把点点之间的连接，转化成每个点拆成出入两个点，把边看做是一个单独的点，拆成出入两个点，将每个点的出入点与夹边的出入点相连接，并且将夹边的入点连向出点

　　当相连的两个点出入度有一个为2一个为1时，不仅将两个点同时相连，还需要将出入度为1的点像出入度为2的点的出点连接。

　　如此我们可以构造出一个一般图

　　然后利用带花树算法跑此图的最大匹配

　　注意一个特判，由于链有两端，所以最后得到的点的总度数之和不可以为奇数。

　　最后判断一下跑出来的最大匹配是否等于总度数之和即可

CODE

#include <bits/stdc++.h>
#define dbg(x) cout << #x << "=" << x << endl
#define eps 1e-8
#define pi acos(-1.0)

using namespace std;
typedef long long LL;

const int inf = 0x3f3f3f3f;

template<class T>inline void read(T &res)
{
    char c;T flag=1;
    while((c=getchar())<'0'||c>'9')if(c=='-')flag=-1;res=c-'0';
    while((c=getchar())>='0'&&c<='9')res=res*10+c-'0';res*=flag;
}

namespace _buff {
    const size_t BUFF = 1 << 19;
    char ibuf[BUFF], *ib = ibuf, *ie = ibuf;
    char getc() {
        if (ib == ie) {
            ib = ibuf;
            ie = ibuf + fread(ibuf, 1, BUFF, stdin);
        }
        return ib == ie ? -1 : *ib++;
    }
}

int qread() {
    using namespace _buff;
    int ret = 0;
    bool pos = true;
    char c = getc();
    for (; (c < '0' || c > '9') && c != '-'; c = getc()) {
        assert(~c);
    }
    if (c == '-') {
        pos = false;
        c = getc();
    }
    for (; c >= '0' && c <= '9'; c = getc()) {
        ret = (ret << 3) + (ret << 1) + (c ^ 48);
    }
    return pos ? ret : -ret;
}

const int maxn = 1e6 + 7;

int n;
int m, m1;
int ti;

//一般图最大匹配模板

int fs[maxn], nt[maxn <<1];
int dt[maxn << 1], pre[maxn], match[maxn];
int f[maxn], bz[maxn], bp[maxn], d[maxn];

void link(int x,int y)
{
    nt[++m1]=fs[x];
    dt[fs[x]=m1]=y;
}
int getf(int k)
{
    return (f[k]==k)?k:f[k]=getf(f[k]);
}
int lca(int x,int y)//整个lca实现比较巧妙，由于是BFS，那么这两个点在当前奇环上的深度一定相等，交替暴力寻找lca即可。
{
    ti++;x=getf(x),y=getf(y);
    while(bp[x]!=ti)
    {
        bp[x]=ti;//此处仅仅是一个标记，无其他作用
        x=getf(pre[match[x]]);
        if(y) swap(x,y);
    }
    return x;
}
void make(int x,int y,int w)//缩环（开花）过程
{
    while(getf(x)!=w)
    {
        pre[x]=y,y=match[x];//x是原本的黑点，y是原本的白点，将原本的pre边变成双向。
        if(bz[y]==2) bz[y]=1,d[++d[0]]=y;//若y还是白点则染黑
        if(getf(x)==x) f[x]=w;
        if(getf(y)==y) f[y]=w;
        x=pre[y];
    }
}
bool find(int st)//主过程
{
    for ( int i = 1; i <= n; ++i ) {
        f[i]=i,pre[i] = bz[i] = 0;
    }
    d[d[0] = 1] = st,bz[st] = 1;
    int l = 0;
    while(l<d[0])
    {
        int k = d[++l];
        for(int i = fs[k];i;i = nt[i])
        {
            int p = dt[i];
            if(getf(p) == getf(k)||bz[p] == 2) continue;//如果找到一个已经缩过的奇环或者偶环则跳过
            if(!bz[p])
            {
                bz[p] = 2,pre[p] = k;
                if(!match[p])//找到增广路
                {
                    for(int x = p,y;x;x = y) y = match[pre[x]],match[x] = pre[x],match[pre[x]] = x;//返回修改匹配
                    return 1;
                }
                bz[match[p]] = 1,d[++d[0]] = match[p];//否则将其匹配点加入队列
            }
            else
            {
                int w = lca(k,p);
                make(k,p,w);
                make(p,k,w);//以上分别修改k到lca的路径以及p到lca的路径（环的两半）
            }
        }
    }
    return 0;
}
//一般图最大匹配模板

int idx[maxn],ide[maxn],deg[maxn];

int main() {
    while(cin >> n >> m) {
        int nn = n, sum = 0, ss = 0;
   
        int ok = 1, t = 0;
        for ( int i = 1; i <= n; ++i ) {
            read(deg[i]);
            sum += deg[i];
            idx[i] = ++ss;
            if(deg[i] == 2)
                ++ss;
        }
        for ( int i = 1; i <= m; ++i ) {
            int u,v;
            read(u); read(v);
            if(deg[u] == 2 && deg[v] == 2) {
                ide[i] = ++ss;
                ss++;
            }
    
            if(deg[u] == 1&& deg[v] == 1)
                link(idx[u],idx[v]),link(idx[v],idx[u]);
            else if(deg[u] == 2 && deg[v] == 2) {
                link(idx[u],ide[i]);link(ide[i],idx[u]);
                link(idx[u]+1,ide[i]);link(ide[i],idx[u]+1);
    
                link(ide[i],ide[i]+1);link(ide[i]+1,ide[i]);
    
                link(idx[v],ide[i]+1);link(ide[i]+1,idx[v]);
                link(idx[v]+1,ide[i]+1);link(ide[i]+1,idx[v]+1);
            }
            else {
                if(deg[u] == 2) {
                    swap(u,v);
                }
                link(idx[v],idx[u]);link(idx[u],idx[v]);
                link(idx[v]+1,idx[u]);link(idx[u],idx[v]+1);
            }
        }
        if(sum & 1)
            ok = 0;
        n = ss;
    
        for ( int i = 1; i <= nn; ++i ) {
            if(!match[idx[i]]) {
                find(idx[i]);
            }
            if(deg[i] > 1 && !match[idx[i]+1]) {
                find(idx[i]+1);
            }
        }
    
        for ( int i = 1; i <= nn; ++i ) {
            if(match[idx[i]])
                t++;
            if(deg[i] > 1 && match[idx[i]+1])
                t++;
        }
        
        if(t != sum || ok == 0) {
            puts("No");
        }
        else {
            puts("Yes");
        }
        m1 = 0;
        for ( int i = 0; i <= n; ++i ) {
            fs[i] = nt[i] = dt[i] = pre[i] = match[i] = f[i] = bz[i] = bp[i] = 0;
        }
        ti = 0;
    }
    return 0;
}