2018年3月1日训练日记

今天看了 一般图匹配的带花树算法。
看了几个大佬的博客，也是有点懵：
寻找增广路的做法是：从一个还没被匹配的点（exposed vertex）出发，中间形成交错路径，最后停止在一个没被匹配的点，这就是一条增广路。
定义：在路径上给这些点从1开始标号，奇数的点我们称为外点，偶数的点我们称为内点，可以发现他们恰好对应两个集合（X为外点的集合，Y为内点的集合）

直接寻找增广路做法不适用于一般图匹配的原因：寻找增广路时会形成环，导致有些点既是内点又是外点。找到增广路时都会把未匹配边变成匹配边，匹配边变成未匹配边，若是有些点既是外点又是内点，会匹配出错，即一个点存在于两个匹配中
注意：一般图中只会出现root连两条未匹配边，因为寻找增广路都是从未匹配点开始的。
带花树的做法是：
像匈牙利算法那样不断枚举点寻找增广路，
当找到环时，找到u和v的最近公共祖先，
分别从u和v跑到最近公共祖先的过程中，把环里面的边从有向变成无向的，并环中点的所在集合都设为root



（以上内容大部分为大佬的博客部分内容）

题目:
Ural-1099 Work scheduling 带花树模板题

ZJU 3316 Game 是否存在完美匹配，如果不是先手就可以走未匹配的点，必赢

HDU 3446 daizhenyang's chess  两次匹配，第一次不带king第二次带。若匹配数增加就说明king开始有一条增广路，必赢。

HDU 4687 Boke and Tsukkomi 先求出最大匹配sum，然后枚举每个匹配，删除这个匹配再求最大匹配，若为sum-1就说明这个匹配不是多余的，否则就是多余的

HDU 3551 hard problem 因为要删边使度数减少，所以先拆边，每条边拆成两个点，连边，然后我们把每个点拆成deg[i]-D[i]个点（deg[i]为原图度数，D[i]为子图度数），然后对所有该点和他的边(i,e)组成的点连一条边，表示这个点缺少的度数，可以由这儿得到。接着，求匹配，如果是完美匹配，即：每个度数都找到了可以使他减少的边。这个子图可以得到。

代码还是比较长的。。。
附个人带花树算法模板（Ural-1099 Work scheduling）：#pragma comment(linker,"/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
#include<vector>
#define maxn 250
#define maxm maxn*maxn*2
#define INF 1e9
using namespace std;
inline int read()
{
register int c=getchar(),fg=1,sum=0;
while(c>'9'||c<'0') {if(c == '-')fg = -1;c=getchar();}
while(c<='9'&&c>='0'){sum=sum*10+c-'0';c=getchar();}
return fg*sum;
}
deque<int>Q;
bool lk[maxn][maxn];
int n,m,k,p,ans,sum,g[maxm],ql,qr,pre[maxn],base[maxn],tim;
bool inq[maxn],inb[maxn],inp[maxn];
struct node{
int u,v;
}e[maxm];
int lca(int x,int y){
memset(inp,0,sizeof(inp));
while(1){
x=base[x];
inp[x]=1;
if(g[x]==-1) break;
x=pre[g[x]];
}
while(1){
y=base[y];
if(inp[y]) return y;
y=pre[g[y]];
}
}
void sk(int x,int p){
while(x!=p)
{
int y=g[x];
inb[base[x]]=1;
inb[base[y]]=1;
y=pre[y];
if(base[y]!=p) pre[y]=g[x];
x=y;
}
}
void ct(int x,int y,int n)
{
int anc=lca(x,y);
memset(inb,0,sizeof(inb));
sk(x,anc);sk(y,anc);
if(base[x]!=anc) pre[x]=y;
if(base[y]!=anc) pre[y]=x;
for(int i=1;i<=n;i++)
{
if(inb[base[i]]){
base[i]=anc;
if(!inq[i]){
Q.push_back(i);
inq[i]=1;
}
}
}
}
bool dfs(int s,int n){
for(int i=0;i<=n;i++) {pre[i]=-1;inq[i]=0;base[i]=i;}
Q.clear();Q.push_back(s);inq[s]=1;
while(!Q.empty()){
int u=Q.front();Q.pop_front();
for(int v=1;v<=n;v++)
{
if(lk[u][v]&&base[v]!=base[u]&&g[u]!=v)
{
if(v==s||(g[v]!=-1&&pre[g[v]]!=-1)) ct(u,v,n);
else if(pre[v]==-1){
pre[v]=u;
if(g[v]!=-1){
Q.push_back(g[v]);
inq[g[v]]=1;
}
else {
u=v;
while(u!=-1)
{
v=pre[u];
int w=g[v];
g[u]=v;
g[v]=u;
u=w;
}
return 1;
}
}
}
}
}
return 0;
}
int solve()
{
int ans=0;
memset(g,-1,sizeof(g));
for(int i=1;i<=n;i++)
if(g[i]==-1&&dfs(i,n)) ans++;
return ans;
}
int main()
{
int T,cas=1,x,y,c;
scanf("%d",&n);
{
memset(lk,0,sizeof(lk));
int u,v;
while(scanf("%d%d",&u,&v)==2)
{lk[u][v]=lk[v][u]=1;}
int sum=solve();
printf("%d\n",sum*2);
for(int i=1;i<=n;++i){
if(i<g[i])printf("%d %d\n",i,g[i]);
}
}
return 0;
}另外，贴上F题用到的二分图最大匹配高效率的HK算法个人模板（HDU 2389）：复杂度O(sqrt(n)*E)#pragma comment(linker,"/STACK:102400000,102400000")
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
#include<vector>
#define maxn 3010
#define INF 1e9
using namespace std;
inline int read()
{
register int c=getchar(),fg=1,sum=0;
while(c>'9'||c<'0') {if(c == '-')fg = -1;c=getchar();}
while(c<='9'&&c>='0'){sum=sum*10+c-'0';c=getchar();}
return fg*sum;
}
int n,m,k,p,ans,sum;
vector<int>G[maxn];
int mx[maxn],my[maxn];
int dx[maxn],dy[maxn];
int dis;
bool used[maxn];
bool findp()
{
queue<int> Q;
dis=INF;
memset(dx,-1,sizeof(dx));
memset(dy,-1,sizeof(dy));
for(int i=0;i<n;i++)
if(mx[i]==-1){
Q.push(i);
dx[i]=0;
}
while(!Q.empty())
{
int u=Q.front();
Q.pop();
if(dx[u]>dis) break;
for(int i=0;i<G[u].size();i++)
{
int v=G[u][i];
if(dy[v]==-1)
{
dy[v]=dx[u]+1;
if(my[v]==-1) dis=dy[v];
else
{
dx[my[v]]=dy[v]+1;
Q.push(my[v]);
}
}
}
}
return dis!=INF;
}
bool dfs(int u)
{
for(int i=0;i<G[u].size();i++)
{
int v=G[u][i];
if(!used[v]&&dy[v]==dx[u]+1)
{
used[v]=1;
if(my[v]!=-1&&dy[v]==dis) continue;
if(my[v]==-1||dfs(my[v]))
{
my[v]=u;
mx[u]=v;
return 1;
}
}
}
return 0;
}
int solve()
{
int ans=0;
memset(mx,-1,sizeof(mx));
memset(my,-1,sizeof(my));
while(findp())
{
memset(used,0,sizeof(used));
for(int i=0;i<n;i++)
if(mx[i]==-1&&dfs(i)) ans++;
}
return ans;
}
struct node{
int x,y,s;
}n1[maxn],n2[maxn];
int col(node a,node b)
{
return (a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y);
}
int main()
{
int T,t,cas=0;
T=read();
while(T--)
{
++cas;
t=read();
n=read();
for(int i=0;i<=n;i++) G[i].clear();
for(int i=0;i<n;i++)
scanf("%d%d%d",&n1[i].x,&n1[i].y,&n1[i].s);
m=read();
for(int i=0;i<m;i++)
scanf("%d%d",&n2[i].x,&n2[i].y);
for(int i=0;i<n;i++)
for(int j=0;j<m;j++)
if(col(n1[i],n2[j])<=n1[i].s*n1[i].s*t*t)
G[i].push_back(j);
printf("Scenario #%d:\n",cas);
printf("%d\n\n",solve());
}
return 0;
}