poj1486（二分图匹配）

/*
translation:
    有一堆透明的讲义堆叠在一起，每个讲义上的随机一个位置会有讲义的标号。因为讲义是透明的，所以堆叠在
    一起的讲义使得这些标号分不清各自对应的讲义。现在要求你求出那些能够确定对应关系的讲义以及对应的标号。
solution:
    二分图匹配
    首先当标号的位置落进某一个讲义的覆盖面积之内，这个标号很可能就是讲义对应的标号。所以连上一条边。
    依次就可以形成一个二分图。接下来就是先跑一遍hangary，然后考察已经匹配上的每一条边。去掉这条边后，
    如果再跑一遍hangary还是完美匹配的话，那么这个对应关系就不是唯一的。反之就是唯一的，存入答案里面。
note:
*/
#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
#include <utility>

using namespace std;
const int maxn = 100;

typedef pair<int, int> P;
int match[maxn], n, m, V;
bool used[maxn];
vector<int> G[maxn];

struct Slide
{
    int xmin, ymin, xmax, ymax;
    Slide(){}
    Slide(int xmin_, int ymin_, int xmax_, int ymax_):xmin(xmin_),ymin(ymin_),xmax(xmax_),ymax(ymax_){}
} slides[maxn];

struct PageId
{
    int x, y;
    PageId(){}
    PageId(int x_, int y_):x(x_),y(y_){}
} pid[maxn];

void add_edge(int u, int v)
{
    //printf("add edge from %d to %d\n", u, v);
    G[u].push_back(v);
    G[v].push_back(u);
}

bool dfs(int v)
{
    used[v] = true;
    for(int i = 0; i < G[v].size(); i++) {
        int u = G[v][i], w = match[u];
        if(w < 0 || !used[w] && dfs(w)) {
            match[v] = u;
            match[u] = v;
            return true;
        }
    }
    return false;
}

int hangary()
{
    int res = 0;
    memset(match, -1, sizeof(match));
    for(int v = 0; v < V; v++) {
        if(match[v] < 0) {
            memset(used, 0, sizeof(used));
            if(dfs(v))  res++;
        }
    }
    return res;
}

bool inside(const PageId& p, const Slide& s)
{
    return p.x > s.xmin && p.x < s.xmax && p.y > s.ymin && p.y < s.ymax;
}

void build_graph(const vector<P>& vec)
{
    for(int i = 0; i < maxn; i++)   G[i].clear();
    for(int i = 0; i < vec.size(); i++)
        add_edge(vec[i].first, vec[i].second);
}

bool cmp(const P& lhs, const P& rhs)
{
    return lhs.second < rhs.second;
}

int main()
{
    //freopen("in.txt", "r", stdin);
    int kase = 0;
    while(~scanf("%d", &n) && n) {
        for(int i = 0; i < n; i++)
            scanf("%d%d%d%d", &slides[i].xmin, &slides[i].xmax, &slides[i].ymin, &slides[i].ymax);
        for(int i = 0; i < n; i++)
            scanf("%d%d", &pid[i].x, &pid[i].y);

        vector<P> edges;        //first:page id, second:slides id
        for(int i = 0; i < n; i++) {
            for(int j = 0; j < n; j++) {
                if(inside(pid[i], slides[j]))
                    edges.push_back(make_pair(i, j + n));
            }
        }

        V = 2 * n;
        build_graph(edges);
        int tmp = hangary();

        printf("Heap %d\n", ++kase);
        if(tmp < n) printf("none\n\n");
        else {
            vector<P> matches;
            for(int i = 0; i < n; i++) {
                matches.push_back(make_pair(i, match[i]));
            }

            vector<P> tmp_edges, ans;
            for(int i = 0; i < matches.size(); i++) {
                for(int j = 0; j < edges.size(); j++) {
                    if(edges[j].first == matches[i].first && edges[j].second == matches[i].second
                       || edges[j].first == matches[i].second && edges[j].second == matches[i].first)
                        continue;
                    tmp_edges.push_back(make_pair(edges[j].first, edges[j].second));
                }
                build_graph(tmp_edges);
                if(hangary() != n)  ans.push_back(make_pair(matches[i].first, matches[i].second));
                tmp_edges.clear();
            }

            if(ans.size() == 0) printf("none\n\n");
            else {
                char ch = 'A';
                sort(ans.begin(), ans.end(), cmp);
                for(int i = 0; i < ans.size(); i++)
                    printf("(%c,%d)%c", ch + ans[i].second - n, ans[i].first + 1, i + 1 == ans.size() ? '\n' : ' ');
                printf("\n");
            }
        }
    }
    return 0;
}