POJ 1469 解题报告

/*
ID: thestor1
LANG: C++
TASK: poj1469
*/
#include <iostream>
#include <fstream>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <limits>
#include <string>
#include <vector>
#include <list>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <algorithm>
#include <cassert>

using namespace std;
// See http://www.geeksforgeeks.org/maximum-bipartite-matching/ for more detailed explanation

const int MAXP = 100;
const int MAXN = 300;

// A DFS based recursive function that returns true if a
// matching for vertex u is possible
bool DFS(int u, const bool adjMatrix[][MAXN], const int N, const int M, int match[], bool visited[])
{
// Try every job one by one
for (int v = 0; v < M; ++v)
{
// If applicant u is interested in job v and v is
// not visited
if (adjMatrix[u][v] && !visited[v])
{
// Mark v as visited
visited[v] = true;

// If job 'v' is not assigned to an applicant OR
// previously assigned applicant for job v (which is match[v])
// has an alternate job available.
// Since v is marked as visited in the above line, match[v]
// in the following recursive call will not get job 'v' again
if (match[v] < 0 || DFS(match[v], adjMatrix, N, M, match, visited))
{
match[v] = u;
return true;
}
}
}

return false;
}

// Returns maximum number of matching from N to M

// match: An array to keep track of the applicants assigned to jobs.
// The value of match[i] is the applicant number
// assigned to job i, the value -1 indicates nobody is assigned.
int maximumBipartiteMatching(const bool adjMatrix[][MAXN], const int N, const int M, int match[], bool visited[])
{
// Count of jobs assigned to applicants
int mbm = 0;

// Initially all jobs are available
memset(match, -1, M * sizeof(int));

for (int u = 0; u < N; ++u)
{
// Mark all jobs as not seen for next applicant.
memset(visited, false, M * sizeof(bool));

// Find if the applicant 'u' can get a job
if (DFS(u, adjMatrix, N, M, match, visited))
{
mbm++;
}
}
return mbm;
}

int main()
{
bool adjMatrix[MAXP][MAXN];
int match[MAXN];
bool visited[MAXN];

int T;
scanf("%d", &T);
for (int t = 0; t < T; ++t)
{
int P, N;
scanf("%d%d", &P, &N);
for (int p = 0; p < P; ++p)
{
memset(adjMatrix[p], false, N * sizeof(bool));
}
for (int p = 0; p < P; ++p)
{
int C;
scanf("%d", &C);
for (int c = 0; c < C; ++c)
{
int s;
scanf("%d", &s);
adjMatrix[p][s - 1] = true;
}
}
if (N >= P && maximumBipartiteMatching(adjMatrix, P, N, match, visited) == P)
{
printf("YES\n");
}
else
{
printf("NO\n");
}
}

return 0;
}