二分图的一些性质
二分图的一些性质：
- 最大匹配：选一些边，选出的边无公共点
- 最小点覆盖：用最少的点覆盖边；
- 最大独立集：选出的点之间没有边
- 二分图==染色法不矛盾 == 不存在奇数环
- 二分图上的最小点覆盖 == 最大匹配数（每条边至少选一点）
- 二分图上最大独立集=总点数-最大匹配数
- 二分图上的最小互不相交路径点覆盖=点数-最大匹配数
- 二分图上的最小路径重复点覆盖=先在原图上传递闭包+二分图上的最小互不相交路径点覆盖
————————————————
转自：谁是凶手1703
HDU1045 Fire Net
思路
二分图最大匹配匈牙利算法
如何建立模型
转自:xuyaun160322
图片转自:lllllan.
对图进行建模，对同一行缩点构成X图，对同一列缩点构成Y图，这里构成的边即缩点区域相交的位置, 映射成图的某个坐标位置。
"1"要素:
从左边图选x,右边图选y， 即是图的某个具体位置，选定的(x, y)这条边只能唯一，(唯一边占用两类资源), 即x不能被选两次或y不能被选两次，否则那样就会互相攻击。
"0"要素
某个集合内部没有交集，即没有边。
代码
#include <iostream>
#include <cstring>
#include <algorithm>
#define sd(x) scanf("%d", &x)
#define rep(i, a, b) for (int i = a; i <= b; i++)
using namespace std;
const int N = 6;
int num1[N][N];
int num2[N][N];
bool edges[20][20];
bool st[20];
int match[20];
int n;
char g[N][N];
int cnt1, cnt2;
void build()
{
memset(num1, 0, sizeof num1);
memset(num2, 0, sizeof num2);
memset(edges, false, sizeof edges);
memset(match, -1, sizeof match);
// 对X图取编号
cnt1 = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n + 1; j++)
{
if (g[i][j] == '.')
{
num1[i][j] = cnt1;
}
else if (g[i][j - 1] == '.')
{
++cnt1;
}
}
// 对y图取编号
cnt2 = 1;
for (int i = 0; i < n; i++)
for (int j = 0; j < n + 1; j++)
{
if (g[j][i] == '.')
{
num2[j][i] = cnt2;
}
else if (g[j - 1][i] == '.')
{
++cnt2;
}
}
// 连边
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
{
if (g[i][j] == '.')
{
edges[num1[i][j]][num2[i][j]] = true;
}
}
}
// 二分图最大匹配
bool dfs(int x)
{
for (int i = 1; i <= cnt2; i++)
{
if (!st[i] && edges[x][i])
{
st[i] = true;
if (match[i] == -1 || dfs(match[i]))
{
match[i] = x;
return true;
}
}
}
return false;
}
int main()
{
while (cin >> n && n)
{
int ans = 0;
memset(g, ' ', sizeof g);
for (int i = 0; i < n; i++)
cin >> g[i];
// 建图
build();
// 最后++了，要减掉
--cnt1;
--cnt2;
for (int i = 1; i <= cnt1; i++)
{
memset(st, false, sizeof st);
if (dfs(i))
ans++;
}
cout << ans << endl;
}
}
HDU2444 The Accomodation
思路
板子。二分图判定+二分图最大匹配
#include<iostream>
#include<cstring>
#include<algorithm>
#define sd(x) scanf("%d", &x)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
using namespace std;
const int N = 210, M = N * (N - 1) / 2;
int h[N], e[M], ne[M], idx;
int match[N];
bool st[N];
int color[N];
int n, m;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a]; h[a] = idx ++;
}
void init() {
memset(h, -1, sizeof h);
idx = 0;
memset(match, -1, sizeof match);
memset(color, 0, sizeof color);
}
int dfs1(int u, int c) {
color[u] = c;
for(int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if(!color[j]) {
if(!dfs1(j, 3 - c)) return false;
}
else if(color[j] == c) return false;
}
return true;
}
int dfs2(int u) {
for(int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
if(st[j]) continue;
st[j] = true;
if(match[j] == -1 || dfs2(match[j])){
match[j] = u;
return true;
}
}
return false;
}
int main() {
while(~scanf("%d%d", &n, &m)) {
int ans = 0;
init();
while(m --) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
bool flag = true;
rep(i, 1, n) {
if(!color[i]) {
if(!dfs1(i, 1)) {
flag = false;
break;
}
}
}
if(flag) {
rep(i, 1, n) {
memset(st, false, sizeof st);
if(dfs2(i)) ans ++;
}
printf("%d\n", ans);
}
else {
puts("No");
}
}
return 0;
}
HDU2819 Swap
思路
这种二维图，建二分图还是那样标准建法。
每行对应每列的匹配。
既然男女能够做匹配，那么花和草也能，行和列也能
有解的情况
最大匹配必须为n
什么时候不是n，存在某行或某列全是0，则最大匹配不会达到n，即无论如何交换都无法满足题目要求
如何存解
最终目的是通过交换变成: match[i] = i
我们可以通过只交换列的方式来得到答案。
依次遍历行，若某一行match[i] != i,假如match[i] = x 则找j, 若满足match[j] = i, 交换列号，即它们的老婆交换一下，变成match[i] = i, match[j] = x
此过程以此类推，得到所有交换过程
代码
#include<iostream>
#include<algorithm>
#include<cstring>
#define rep(i, a, b) for(int i = a; i <= b; i ++)
#define sd(x) scanf("%d", &x)
using namespace std;
typedef pair<int, int> PII;
const int N = 210;
int n;
int g[N][N];
bool st[N];
int match[N];
PII ans[N];
int k;
void init() {
k = 0;
memset(g, 0, sizeof g);
memset(match, -1, sizeof match);
}
bool dfs(int u) {
rep(i, 1, n) {
if(g[u][i] && !st[i]) {
st[i] = true;
if(match[i] == -1 || dfs(match[i])) {
match[i] = u;
return true;
}
}
}
return false;
}
int hungarian() {
int res = 0;
rep(i, 1, n) {
memset(st, false, sizeof st);
if(dfs(i)) res ++;
}
return res;
}
int main() {
while(cin >> n) {
init();
rep(i, 1, n)
rep(j, 1, n) {
sd(g[i][j]);
}
int cnt = hungarian();
if(cnt != n) {
puts("-1");
}
else {
rep(i, 1, n) {
if(match[i] != i) {
rep(j, 1, n) {
if(match[j] == i) {
ans[++ k].first = i;
ans[k].second = j;
// 交换老婆
swap(match[i], match[j]);
break;
}
}
}
}
printf("%d\n", k);
rep(i, 1, k) {
printf("C %d %d\n", ans[i].first, ans[i].second);
}
}
}
return 0;
}
HDU1281棋盘游戏
思路
建图和上题一模一样。
该题有两问：
- 最多能放多少个车(二分图最大匹配)
- 在第一问情况下有多少个车的位置写死了不能改变。(通过删已匹配边，跑一次匈牙利，看是否还能完成最大匹配，若不能，则这个位置不能改变)
代码不想写了，摘自:serendipityLB
代码
#include<cstdio>
#include<cstring>
#include<cmath>
#include<algorithm>
#include<iostream>
#include<sstream>
#include<string>
#include<queue>
#include<vector>
#include<set>
#include<stack>
#include<map>
#define lowbit(x) x&(-x)
#define ll long long
#define inf 0x3f3f3f3f
using namespace std;
const int maxn=110;
int mp[maxn][maxn];
int match1[maxn],vis[maxn],match2[maxn];
int n,m,k;
int Find(int i){
for(int j=1;j<=m;j++){
if(vis[j]==0&&mp[i][j]){
vis[j]=1;
if(Find(match1[j])||match1[j]==0){
match1[j]=i;
return 1;
}
}
}
return 0;
}
int solve(){
memset(match1,0,sizeof(match1)); //每次初始化
int ans=0;
for(int i=1;i<=n;i++){
memset(vis,0,sizeof(vis));
if(Find(i)){
ans++;
}
}
return ans;
}
int main(){
int cas=1;
while(~scanf("%d%d%d",&n,&m,&k)){
memset(mp,0,sizeof(mp));
int u,v;
while(k--){
scanf("%d%d",&u,&v);
mp[u][v]=1;
}
int num=solve();
int ans=0;
memcpy(match2,match1,sizeof(match1));
for(int v=1;v<=n;v++){
if(match2[v]==0){
continue;
}
int u=match2[v];
mp[u][v]=0;
int x=solve();
if(x!=num){
ans++;
}
mp[u][v]=1;
}
printf("Board %d have %d important blanks for %d chessmen.\n",cas++,ans,num);
}
return 0;
}
HDU 4185 Oil Skiming
题意
可以看做一个地图上#的地方可以放置东西。然后问最多能够放多少1x2的小方格。求一下最大匹配即可。
思路
棋盘覆盖问题。
二分图的X图为i+j为奇数的点，Y图为i+j为偶数的点。
对上下左右的点连边(可以的情况下)。
代码也懒得写了。复制的，都是一个性质的题目
代码
#include <cstring>
#include <cstdio>
#include <algorithm>
using namespace std;
const int N = 605;
pair<int, int> mat[N][N];
char s[N][N];
int t, n;
int dx[4] = {1, 0, 0, -1};
int dy[4] = {0, 1, -1, 0};
bool vis[N][N];
bool dfs(int x, int y) {
for (int i = 0; i < 4; i++) {
int fx = x + dx[i];
int fy = y + dy[i];
if (fx <= 0 || fy <= 0 || fx > n || fy > n || vis[fx][fy] || s[fx][fy] == '.') continue;
vis[fx][fy] = true;
int u = mat[fx][fy].first, v = mat[fx][fy].second;
if (!u || dfs(u, v)) {
mat[fx][fy] = make_pair(x, y); return true;
}
}
return false;
}
void init() {
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) mat[i][j].first = 0, mat[i][j].second = 0;
}
}
int main() {
scanf("%d", &t); int T = 1;
while (t--) {
scanf("%d", &n);
init();
for (int i = 1; i <= n; i++) scanf("%s", s[i] + 1);
int ans = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= n; j++) {
if (s[i][j] == '.' || ((i + j) & 1)) continue;
memset(vis, false ,sizeof(vis));
if (dfs(i, j)) ans++;
}
}
printf("Case %d: %d\n", T++, ans);
}
return 0;
}
POJ3020 Antenna Placement
题意
用 1 * 2面积覆盖 所有的 ‘*’
思路
常规操作：拆点
建图：
将一点拆成X图入度和Y图出度，向右方向和下方向(防止重复)连无向边。
则该题是 无向图的最小边覆盖 板子题
公式: 最小边数量 = |V|(顶点数) - 最大匹配/2
证明：2*|V| = 2*二分图的最大匹配数 + 二分图中未匹配的点
二分图最大匹配数+未匹配点 = 2*|V| - 二分图最大匹配数
左边为最小边覆盖数量，但是所有顶点都覆盖了两次，除以2
得 最小边覆盖数量 = |V| - 二分图最大匹配/2
代码
#include<iostream>
#include<cstring>
#include<algorithm>
#define sd(x) scanf("%d", &x)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
using namespace std;
const int N = 155, M = N * N;
char g[N][N];
int a[N][N];
int num;
int n, m, e[M], ne[M], h[M], idx;
bool st[M];
int match[M];
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
bool find(int x) {
for(int i = h[x]; ~i; i = ne[i]) {
int j = e[i];
if(st[j]) continue;
st[j] = true;
if(!match[j] || find(match[j])) {
match[j] = x;
return true;
}
}
return false;
}
void solve() {
num = 0, idx = 0;
int n, m;
scanf("%d%d", &n, &m);
memset(h, -1, sizeof h);
memset(a, 0, sizeof a);
memset(match, 0, sizeof match);
rep(i, 1, n) {
scanf("%s", g[i] + 1);
rep(j, 1, m) {
if(g[i][j] == '*') a[i][j] = ++ num;
}
}
rep(i, 1, n) {
rep(j, 1, m){
if(a[i][j]) {
int right = a[i][j + 1], down = a[i + 1][j];
if(right) {
add(a[i][j], right);
add(right, a[i][j]);
}
if(down) {
add(down, a[i][j]);
add(a[i][j], down);
}
}
}
}
int res = 0;
rep(i, 1, num) {
memset(st, false, sizeof st);
if(find(i)) res ++;
}
printf("%d\n", num - res / 2);
}
int main() {
int T;
sd(T);
while(T --) {
solve();
}
return 0;
}
HDU1054 Strategic Game
思路
二分图解法:
无向图 最小点覆盖问题 == 最大匹配 / 2
建图每个点拆成 入度和出度，并且是无向边(一条边add两次)
树形dp解法(建有向图):
父节点没选，则子节点必选。父节点已选，子节点选与不选取min
状态表示:
状态表示
f[u][0]：所有以u为根的子树中选择，并且不选u这个点的方案f[u][1]：所有以u为根的子树中选择，并且选u这个点的方案
代码1
#include <cstdio>
#include <cstring>
using namespace std;
const int N = 1505, M = N * N;
struct E {
int v, next;
} e[M];
int n, len, h[N], mat[N];
bool vis[N];
void add(int u, int v) {
e[++len].v = v; e[len].next = h[u]; h[u] = len;
}
bool dfs(int u) {
for (int j = h[u]; j; j = e[j].next) {
int v = e[j].v;
if (vis[v]) continue; vis[v] = true;
if (!mat[v] || dfs(mat[v])) {
mat[v] = u; return true;
}
}
return false;
}
int main() {
while (~scanf("%d", &n)) {
memset(h, 0, sizeof(h)); len = 0;
memset(mat, 0, sizeof(mat));
for (int i = 1; i <= n; i++) {
int u, v, len;
scanf("%d:(%d)", &u, &len);
while (len--) {
scanf("%d", &v);
add(u, v); add(v, u);
}
}
int ans = 0;
for (int i = 0; i < n; i++) {
memset(vis, false, sizeof(vis));
if (dfs(i)) ans++;
}
printf("%d\n", ans / 2);
}
return 0;
}
代码2
#include<cstring>
#include<algorithm>
#include<iostream>
using namespace std;
const int N = 1510, M = N * N;
int f[N][2];
int h[N], e[M], ne[M], idx;
bool st[N];
int n;
void add(int a, int b) {
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
void dfs(int u) {
f[u][0] = 0, f[u][1] = 1;
for(int i = h[u]; ~i; i = ne[i]) {
int j = e[i];
dfs(j);
f[u][0] += f[j][1];
f[u][1] += min(f[j][0], f[j][1]);
}
}
int main(){
while(~scanf("%d", &n)) {
memset(h, -1, sizeof h);
memset(st, 0, sizeof st);
idx = 0;
int cnt, id;
for(int i = 0; i < n; i ++) {
scanf("%d:(%d)", &id, &cnt);
while(cnt --) {
int ver;
scanf("%d", &ver);
add(id, ver);
st[ver] = true;
}
}
int root = 0;
while(st[root]) root ++;
dfs(root);
printf("%d\n", min(f[root][0], f[root][1]));
}
return 0;
}
HDU1151 Air Raid
思路
最少路径点覆盖模板题
注意，注意该题路径不能相交，即某点不会被重复遍历。
如果可重复，就是最少路径重复点覆盖问题，要先求一遍传递闭包。
代码
#include<iostream>
#include<cstring>
#include<algorithm>
#define sd(x) scanf("%d", &x)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
using namespace std;
const int N = 1010;
int h[N], e[N], ne[N], idx;
int match[N];
bool st[N];
int n, m;
void add(int a, int b){
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
bool find(int x){
for(int i = h[x]; i != -1; i = ne[i]){
int j = e[i];
if(!st[j]){
st[j] = true;
if(!match[j] || find(match[j])){
match[j] = x;
return true;
}
}
}
return false;
}
int main() {
int T;
sd(T);
while(T --) {
memset(h, -1, sizeof h);
idx = 0;
memset(match, 0, sizeof match);
scanf("%d%d", &n, &m);
while(m --) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
int res = 0;
rep(i, 1, n) {
memset(st, false, sizeof st);
if(find(i)) res ++;
}
printf("%d\n", n - res);
}
return 0;
}
POJ2594 Treasure Exploration
题意
给定一个有向图，可以在任意一个点上放置一个机器人，每个机器人可以沿一条有向简单路径移动，求使得所有节点都至少被一条路径经过需要的最少机器人数量。
思路
最少路径重复点覆盖 模板题
ans = n - 最大匹配
代码
#include<iostream>
#include<cstring>
#include<algorithm>
#define sd(x) scanf("%d", &x)
#define rep(i, a, b) for(int i = a; i <= b; i ++)
using namespace std;
const int N = 1010;
int h[N], e[N], ne[N], idx;
int match[N];
bool st[N];
int n, m;
void add(int a, int b){
e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}
bool find(int x){
for(int i = h[x]; i != -1; i = ne[i]){
int j = e[i];
if(!st[j]){
st[j] = true;
if(!match[j] || find(match[j])){
match[j] = x;
return true;
}
}
}
return false;
}
int main() {
int T;
sd(T);
while(T --) {
memset(h, -1, sizeof h);
idx = 0;
memset(match, 0, sizeof match);
scanf("%d%d", &n, &m);
while(m --) {
int a, b;
scanf("%d%d", &a, &b);
add(a, b);
}
int res = 0;
rep(i, 1, n) {
memset(st, false, sizeof st);
if(find(i)) res ++;
}
printf("%d\n", n - res);
}
return 0;
}
441
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
