POJ 3020 / POJ 3041 关于二分图最大匹配的一些变形

其实这两个题早就过了，本想着等看完KM算法一块发的，可是最近一直在忙考试和CF，迟迟没写出来，感觉再拖下去这两个就要忘了，所以还是先发出来吧。

POJ 3020 二分图的最小顶点覆盖 等于 最大匹配

定义：设K为G的一部分的点的集合，若图G中的每一条边至少有一个顶点在K中，则称K为G的一点顶点覆盖。

    若G中不存在满足|K'| < |K|的点覆盖K' 则称K为G的最小点集覆盖。

设G为二分图，M为G的最大匹配，S为最小顶点覆盖的点集。

因为匹配M中的边两两没有交点，所以覆盖这M条边至少需要M个点。

若G中仍然存在两端都不为匹配点的边，则存在一条增广路，与M为最大匹配相矛盾。

对于一对匹配点，选择其中一个加入S时，若存在一条边未被覆盖，则将该点删除，加入另一点。

若两种情况均存在一天未被覆盖的边则说明崔在一条增广路，与M为最大匹配相矛盾。

故肯定存在一种选择方案使得在M对匹配点中选择M个点，使得所有的边均被覆盖，又因为覆盖M条

匹配边至少需要M个点，所以|s| == M。

POJ 3041  最大独立点集 等于 点的个数减去最大匹配

定义：设K为G的一部分的点的集合，若K中任意两点均不相邻，则称K为G的一个独立点集。

    若G中不存在满足|K'| > |K|的独立点集K'，则称K为G的最大独立点集。

在一个图中，独立集和顶点覆盖有互补的性质。

T是G的独立点集  <=>  G中每条边至少有一个顶点在V(G) - T 中 <=> V(G) - T是G的一个顶点覆盖

而在二分图中最小点集覆盖等于最大二分匹配，所以最大独立点集等于点的个数减去最大匹配。

上述证明完全是自己瞎作的，不当之处，望不吝赐教。

下面说一下这两个题的思路：

其实两个题难度差不许多，基本属于拿来测代码的。

POJ 3041 可以将给出的点看成边，X，Y轴上的整数坐标位置看成点，则就抽象出了二分图，剩下的问题就迎刃而解了。

POJ 3020  给出的点作为点，两个相邻的点之间加一条边，因为不存在奇环，所以必为二分图。

POJ 3020

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>

#pragma comment(linker, "/STACK:1024000000");
#define LL unsigned long long int

using namespace std;

struct N
{
    int v;
    N *next;
}*head[410];

N *creat()
{
    N *p = (N*)malloc(sizeof(N));
    p->next = NULL;
    return p;
};

int point[41][11];

char s[41][11];

int jx[] = {-1, 0, 1, 0};
int jy[] = { 0,-1, 0, 1};

int Matching_Point[410];
bool mark[410];

bool dfs(int s)
{
    for(N *p = head[s]->next; p != NULL; p = p->next)
    {
        if(mark[p->v] == false)
        {
            mark[p->v] = true;
            if(Matching_Point[p->v] == -1 || dfs(Matching_Point[p->v]))
            {
                Matching_Point[p->v] = s;
                Matching_Point[s] = p->v;
                return true;
            }
        }
    }
    return false;
}

int Cal_Maximal_Matching(int n)
{
    memset(Matching_Point,-1,sizeof(Matching_Point));

    int i,ans = 0;

    for(i = 1; i < n; ++i)
    {
        if(Matching_Point[i] == -1)
        {
            memset(mark,false,sizeof(mark));
            if(dfs(i))
            {
                ans++;
            }
        }
    }
    return ans;
}

int main()
{
    int T,n,m,i,j,k,top,x,y;
    N *p;

    for(i = 0; i < 401; ++i)
    {
        head[i] = creat();
    }

    scanf("%d",&T);

    while(T--)
    {
        scanf("%d %d",&n,&m);

        for(i = 0; i <= n*m; ++i)
        {
            head[i]->next = NULL;
        }

        for(i = 0; i < n; ++i)
        {
            scanf("%*c%s",s[i]);
        }

        top = 1;
        memset(point,-1,sizeof(point));

        for(i = 0; i < n; ++i)
        {
            for(j = 0; j < m; ++j)
            {
                if(s[i][j] == '*')
                {
                    point[i][j] = top++;
                }
            }
        }

        for(i = 0; i < n; ++i)
        {
            for(j = 0; j < m; ++j)
            {
                if(point[i][j] != -1)
                {
                    for(k = 0; k < 4; ++k)
                    {
                        x = i+jx[k];
                        y = j+jy[k];
                        if(0 <= x && x < n && 0 <= y && y < m && point[x][y] != -1)
                        {

                            p = creat();
                            p->v = point[x][y];
                            p->next = head[point[i][j]]->next;
                            head[point[i][j]]->next = p;
                        }
                    }
                }
            }
        }
        printf("%d\n",top-1-Cal_Maximal_Matching(top));
    }
    return 0 ;
}

POJ  3041

#include <iostream>
#include <algorithm>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <queue>
#include <stack>

#pragma comment(linker, "/STACK:1024000000");
#define LL long long int

using namespace std;

const int MAXN = 1010;

struct N
{
    int v;
    N *next;
}*head[MAXN];

N *creat()
{
    N *p = (N *)malloc(sizeof(N));
    p->next = NULL;
    return p;
}

bool mark[MAXN];

int color[MAXN];

int Match_Point[MAXN];

bool dfs(int t)
{
    for(N *p = head[t]->next; p != NULL; p = p->next)
    {
        if(mark[p->v] == false)
        {
            mark[p->v] = true;
            if(Match_Point[p->v] == -1 || dfs(Match_Point[p->v]))
            {
                Match_Point[p->v] = t;
                Match_Point[t] = p->v;
                return true;
            }
        }
    }
    return false;
}

bool bfs(int n)
{
    queue<int> q;
    int s,i;
    N *p;

    for(i = 1;i <= n; ++i)
    {
        if(color[i] == -1)
        {

            q.push(i);
            color[i] = 0;

            while(q.empty() == false)
            {
                s = q.front();
                q.pop();

                for(p = head[s]->next; p != NULL; p = p->next)
                {
                    if(color[p->v] == -1)
                    {
                        color[p->v] = (color[s] == 1 ? 0 : 1);
                        q.push(p->v);
                    }
                    else if(color[p->v] == color[s])
                    {
                        return true;
                    }
                }
            }
        }
    }

    return false;
}

int Cal_Maximal_Matching(int n)
{
    int i,ans = 0;

    memset(Match_Point,-1,sizeof(Match_Point));

    for(i = 1;i <= n; ++i)
    {
        if(Match_Point[i] == -1)
        {
            memset(mark,false,sizeof(mark));
            if(dfs(i))
                ans++;
        }
    }
    return ans;
}

int main()
{
    int i,n,m,u,v;
    N *p;

    for(i = 0;i <= MAXN*2; ++i)
    {
        head[i] = creat();
    }

    while(scanf("%d %d",&n,&m) != EOF)
    {
        for(i = 1;i <= n; ++i)
        {
            head[i]->next = NULL;
        }

        while(m--)
        {
            scanf("%d %d",&u,&v);
            v += n;
            p = creat();
            p->v = v;
            p->next = head[u]->next;
            head[u]->next = p;
            p = creat();
            p->v = u;
            p->next = head[v]->next;
            head[v]->next = p;
        }

        printf("%d\n",Cal_Maximal_Matching(n*2));

    }
    return 0;
}