POJ 2239 Selecting Courses(二分图匹配——匈牙利算法||网络流)解题报告

题目大意:

在大学里有许许多多的课程，现在李明需要去选择课程，他是一个爱学习的人，所以想尽可能多的选择课程。

在学校里有n个课程，每周7天，每天有12节课，一周一共有有7*12节课。某一节课在一周内会上x次，一周内的这x次内容一样，只需要去一次就可以了。同时，某个时间李明最多只能去上一门课程。问李明最多能上多少门课。

输入第一行为n，代表有n个课程。接下来n行，每行第一个数字x代表这个课程在这一周里面需要上x次。然后跟着x对数字，第一个D代表这周的哪一天，第二个C代表这天的哪一节课。

   

解题思路：

       这是一道比较裸的二分图匹配问题，左边的X集合表示各门课程，有边的Y集合表示上课的时间，如果某门课程在某个时间上则连上一条边。构图后，用匈牙利算法或者网络流都可以做。匈牙利算法时间复杂度O(n*m),网络流的E-k算法的时间复杂度为O(n*m²)。运行时间如下，上面的是网络流的E-k算法，下面的是匈牙利算法：

       这道题需要好好揣摩的是它的构图方法，每个点的编号问题。可以把n门课编号为1-n，然后7*12节课编号为n+1-n+7*12。需要注意，星期p的第q结课编号为n+(p-1)*12+q，而不是n+p*12+q，因为从星期一开始，而不是从星期零开始……我在这个细节上WA了两次。

网络流E-K算法代码：

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 305;
const int MAXD = 7*12+5;
int g[MAXN+MAXD+5][MAXN+MAXD+5];
int pre[MAXN+MAXD+5];
int n;
bool bfs(int s,int t)
{
    queue q;
    memset(pre,-1,sizeof(pre));
    q.push(s);
    int u,v;
    while (!q.empty())
    {
        u = q.front();
        q.pop();
        for (v = 1; v <= t; ++v)
        {
            if (g[u][v] && pre[v] == -1)
            {
                pre[v] = u;
                if (v == t)
                    return true;
                q.push(v);
            }
        }
    }
    return false;
}
int ek(int s,int t)
{
    int u,v,res = 0;
    while (bfs(s,t))
    {
        for (u = t; u != s; u = pre[u])
        {
            g[pre[u]][u]--;
            g[u][pre[u]]++;
        }
        ++res;
    }
    return res;
}
int main()
{
    int i,j,num,p,q;
    while (scanf("%d",&n) != EOF)
    {
        memset(g,0,sizeof(g));
        for (i = 1; i <= n; ++i)
        {
            g[0][i] = 1;        //0为源点，n+MAXD为汇点
            scanf("%d",&num);
            for (j = 0; j < num; ++j)
            {
                scanf("%d %d",&p,&q);
                int tmp = (p-1)*12+q+n;
                g[i][tmp] = 1;
                g[tmp][n+MAXD] = 1;
            }
        }
        printf("%d\n",ek(0,n+MAXD));
    }
}

匈牙利算法代码：

#include 
#include 
#include 
#include 
using namespace std;
const int MAXN = 305;
vector adj[MAXN];
int match[MAXN];
bool used[MAXN];
int n;
int dfs(int u)
{
    int i,v;
    for (i = 0; i < adj[u].size(); ++i)
    {
        v = adj[u][i];
        if (!used[v])
        {
            used[v] = true;      //如果本次增广成功，used数组用于在搜索中标记这个点已经被某个X集合中的点占用，如果本次增光失败，used数组用于标记和v配对的X集合中的那个点只能和v配对，不能在后面的dfs中再用
            if (match[v] == 0 || dfs(match[v]))
            {
                match[v] = u;
                return true;
            }
        }
    }
    return false;
}
int hungary()
{
    int u,res = 0;
    for (u = 1; u <= n; ++u)
    {
        memset(used,0,sizeof(used));
        if (dfs(u))
            ++res;
    }
    return res;
}
int main()
{
    int i,u,v,num,p,q;
    while (scanf("%d",&n) != EOF)
    {
        memset(match,0,sizeof(match));
        for (i = 1; i <= n; ++i)
            adj[i].clear();
        for (u = 1; u <= n; ++u)
        {
            scanf("%d",&num);
            for (i = 0; i < num; ++i)
            {
                scanf("%d %d",&p,&q);
                adj[u].push_back(p*12+q);
            }
        }
        printf("%d\n",hungary());
    }
}