2020牛客多校训练1 I 1or2（拆点拆边带花树&一般图最大匹配）

2020牛客多校第一场 I 1or2


题意：问选择任意选择一些边能否让各点的度数刚好等于题目所要求的度数

正解：一般图最大匹配（带花树）

水解：最大流

由于题目数据太水，我用HDU3551的一组样例来举例：

输入：

4 4
1 2
3 4
2 3
1 4
1
2
1
0

输出

Yes

不同于我能找到的那些题解的思路，直接拆度拆边（我不知道为什么我那样写写挂了），而是先
记录每一条边对点的度数总贡献，

1.如果总贡献都达不到给出的要求，直接输出$No$

2.如果刚好，则不用去管与这个点相连的边，直接全选即可（少选就满足不了，无多的可选）

首先拆边，记录每个点能获得的总度数，并开一个$vector$记录每条边拆开的点是属于原图的哪个点，并将拆边拆开的点连边

判断1，直接$break$

判断2，如果满足，不用管

3如果边对一个点的度数贡献大于它所需要的，建虚点连接所有原点对应的拆边的点

跑带花树

上图：

对于上面这组样例：
边对每个点的度数的总贡献都为2

而只有 点2 的需求为2

所以对其他点进行建立虚点：
9对应1的虚点（1需求1，边贡献2）

10对应3的虚点（3需求1，边贡献2）

11,12对应4的虚点（4需求0，边贡献2）

其实这种做法就相当于删去不必要的边，如果能跑出完美匹配，则代表每个多余的边都被虚点匹配走了，原图的各点度数则刚好符合题目要求的度数

9 匹配走了 7
10 匹配走了 3
11 匹配走了 4
12 匹配走了 8
最终原图剩下的就是 $1-2$, $2-3$这两条边，刚好符合题目要求，输出$Yes$
（图中每个点逗号后面的数字代表原点）

代码：

#include<bits/stdc++.h>
using namespace std;
const int maxn=1005,maxm=2e5+5;
int n,m,cnt=1,head[maxn],num;
int match[maxn],pre[maxn],f[maxn],vis[maxn],idx,tim[maxn],deg[maxn];
struct edge{
	int v,nex;
}e[maxm];
inline void add(int u,int v){
	e[++cnt].v=v;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
int find(int x){
	return x==f[x]?x:f[x]=find(f[x]);
}
int lca(int x,int y) {
    idx++;
    while(true){
        if(x){
            x=find(x);
            if(tim[x]==idx)return x;
            tim[x]=idx;
            x=pre[match[x]];
        }
        swap(x,y);
    }
}
queue<int>q;
void blossom(int x,int y,int w){
	while(find(x)!=w){
		pre[x]=y;
		y=match[x];
		if(vis[y]==2){
			vis[y]=1;
			q.push(y);
		}
		if(find(x)==x)f[x]=w;
		if(find(y)==y)f[y]=w;
		x=pre[y];
	}
}
int aug(int s){
	for(int i=1;i<=n;i++){
		f[i]=i;
		vis[i]=pre[i]=0;
	}
	while(!q.empty()){
		q.pop();
	}
	q.push(s);
	vis[s]=1;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			if(find(u)==find(v)||vis[v]==2)continue;
			if(!vis[v]){
				vis[v]=2;
				pre[v]=u;
				if(!match[v]){
					for(int x=v,last;x;x=last){
						last=match[pre[x]];
						match[x]=pre[x];
						match[pre[x]]=x;
					}
					return 1;
				}
				vis[match[v]]=1;
				q.push(match[v]);
			}
			else{
				int w=lca(u,v);
				blossom(u,v,w);
				blossom(v,u,w);
			}
		}
	}
	return 0;
}
int d[maxn];
vector<int>mp[maxn];
int main(){
    while(scanf("%d%d", &num, &m)==2) {
        for(int i=1;i<=num;i++)
            scanf("%d",&d[i]);
        for(int i=1;i<=m;i++) {
            int u, v;
            scanf("%d%d",&u,&v);
            add(i*2-1,i*2);
            add(i*2,i*2-1);
            deg[u]++;
            deg[v]++;
            mp[u].push_back(i*2-1);
            mp[v].push_back(i*2);
        }
        n=2*m;
        bool ok=true;
        for(int i=1;i<=num;i++) {
            if(deg[i]<d[i]){
                ok=false;
                break;
            }
            for(int j=1;j<=deg[i]-d[i];j++) {
                n++;
                for(auto v:mp[i]){
                	add(n,v);
                	add(v,n);
                }
            }
        }
        if(!ok)
            printf("No\n");
        else {
            int ans=0;
            for(int i=1;i<=n;i++) {
                if(!match[i])ans+=aug(i);
            }
            if(ans*2==n)printf("Yes\n");
            else printf("No\n");
        }
        idx=0;
        cnt=1;
        memset(head,0,sizeof head);
        for(int i=1; i<=num;i++) {
            mp[i].clear();
            deg[i]=0;
        }
        for(int i=1;i<=n;i++) {
            match[i]=tim[i]=0;
        }
    }
    return 0;
}

补上直接拆点拆点版本：

把每一个点按度数拆成$du[i]$个点

把每一条边拆开为两个点

每一个度点（把点按度拆开的点）都需要对应那么多个边点跟它匹配，这样就达到的题目的要求，那多余的边点怎么办？不用管，直接让一条边上的两个边点匹配起来就可以了，就相当于没有选择这一条边，所以跑出完美匹配即为$Yes$

#include<bits/stdc++.h>
using namespace std;
const int maxn=1005,maxm=2e5+5;
int n,m,cnt=1,head[maxn],num;
int match[maxn],pre[maxn],f[maxn],vis[maxn],idx,tim[maxn],deg[maxn];
struct edge{
	int v,nex;
}e[maxm];
inline void add(int u,int v){
	e[++cnt].v=v;
	e[cnt].nex=head[u];
	head[u]=cnt;
}
int find(int x){
	return x==f[x]?x:f[x]=find(f[x]);
}
int lca(int x,int y) {
    idx++;
    while(true){
        if(x){
            x=find(x);
            if(tim[x]==idx)return x;
            tim[x]=idx;
            x=pre[match[x]];
        }
        swap(x,y);
    }
}
queue<int>q;
void blossom(int x,int y,int w){
	while(find(x)!=w){
		pre[x]=y;
		y=match[x];
		if(vis[y]==2){
			vis[y]=1;
			q.push(y);
		}
		if(find(x)==x)f[x]=w;
		if(find(y)==y)f[y]=w;
		x=pre[y];
	}
}
int aug(int s){
	for(int i=1;i<=n;i++){
		f[i]=i;
		vis[i]=pre[i]=0;
	}
	while(!q.empty()){
		q.pop();
	}
	q.push(s);
	vis[s]=1;
	while(!q.empty()){
		int u=q.front();
		q.pop();
		for(int i=head[u];i;i=e[i].nex){
			int v=e[i].v;
			if(find(u)==find(v)||vis[v]==2)continue;
			if(!vis[v]){
				vis[v]=2;
				pre[v]=u;
				if(!match[v]){
					for(int x=v,last;x;x=last){
						last=match[pre[x]];
						match[x]=pre[x];
						match[pre[x]]=x;
					}
					return 1;
				}
				vis[match[v]]=1;
				q.push(match[v]);
			}
			else{
				int w=lca(u,v);
				blossom(u,v,w);
				blossom(v,u,w);
			}
		}
	}
	return 0;
}
int du[maxn];
int id[maxn][maxn],x[maxn],y[maxn];
void build(){
	int cnt=0;
	for(int i=1;i<=n;i++)
		for(int j=1;j<=du[i];j++)
			id[i][j]=++cnt;
	for(int i=1;i<=m;i++){
		add(cnt+1,cnt+2);
		add(cnt+2,cnt+1);
		for(int j=1;j<=du[x[i]];j++){
			add(id[x[i]][j],cnt+1);
			add(cnt+1,id[x[i]][j]);
		}
		for(int j=1;j<=du[y[i]];j++){
			add(cnt+2,id[y[i]][j]);
			add(id[y[i]][j],cnt+2);
		}
		cnt+=2;
	}
	n=cnt;
}
int fwt(){
	int ans=0;
	for(int i=1;i<=n;i++){
		if(!match[i]&&aug(i)){
			ans++;
		}
	}
	return ans;
}
inline void init(){
	cnt=1;
	memset(id,0,sizeof id);
	memset(match,0,sizeof match);
	memset(head,0,sizeof head);
	memset(f,0,sizeof f);
	memset(tim,0,sizeof tim);
	idx=0;
}
int main(){
    while(scanf("%d%d",&n,&m)==2) {
    	init();
        for(int i=1;i<=n;i++){
        	scanf("%d",&du[i]);
		}
		for(int i=1;i<=m;i++){
			scanf("%d%d",&x[i],&y[i]);
		}
		build();
		if(fwt()*2==n){
			puts("Yes");
		}
		else puts("No");
    }
    return 0;
}

（带花树的原理好抽象，先拿着当板子用）

（我太蒻了）

（这是个HDU的原题）

（这不就是带花树拆点裸题吗）