POJ1486 Sorting Slides(二分图匹配必须边）

题目链接

题意：
$\ \ \ \ $有$n$个矩形$n$个数字，给出矩形范围和数字坐标，每个数字只能匹配一个矩形，问哪些匹配是固定的。

思路：
$\ \ \ \ $先求二分图最大匹配，求出来之后，匹配边从右往左定向，非匹配边从左往右定向，如果匹配边$(u, v)$在$scc$中在同一个强连通分量，那么该边就不是必须边，否则是必须边。

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<vector>
#include<iostream>
typedef long long ll;
const int maxn = 2e2 + 10;
using namespace std;

int from[maxn], use[maxn];
int n, m, edge[maxn][maxn];
vector<int> G[maxn], rG[maxn], vs;
int X1[maxn], X2[maxn], Y1[maxn], Y2[maxn];
int topo[maxn]; ///拓扑排序

void add(int f, int t) {
    G[f].push_back(t);
    rG[t].push_back(f);
}

void dfs(int u) {
    use[u] = 1;
    for(int i = 0; i < G[u].size(); i++) {
        int v = G[u][i];
        if(!use[v]) dfs(v);
    }
    vs.push_back(u);
}

void rdfs(int u, int k) {
    use[u] = 1; topo[u] = k;
    for(int i = 0; i < rG[u].size(); i++) {
        int v = rG[u][i];
        if(!use[v]) rdfs(v, k);
    }
}

int scc(int n) {
    int k = 1;
    memset(use, 0, sizeof(use));
    vs.clear();
    for(int i = 1; i <= n; i++) {
        if(!use[i]) dfs(i);
    }
    memset(use, 0, sizeof(use));
    for(int i = vs.size() - 1; i >= 0; i--) {
        int v = vs[i];
        if(!use[v]) rdfs(v, k++);
    }
    return k - 1;
}


bool match(int x) {
    for(int i = 0; i < G[x].size(); i++) {
        int v = G[x][i];
        if(use[v]) continue;
        use[v] = 1;
        if(~from[v] && !match(from[v])) continue;
        from[v] = x; return true;
    }
    return false;
}

int max_match() {
    memset(from, -1, sizeof from);
    int ans = 0;
    for(int i = 1; i <= n; i++) {
        memset(use, 0, sizeof use);
        ans += match(i);
    }
    return ans;
}

bool cover(int x, int y, int id) {
    if(X1[id] <= x && x <= X2[id] && Y1[id] <= y && y <= Y2[id]) return true;
    return false;
}

int main() {
    int kase = 1;
    while(cin >> n && n) {
        memset(edge, 0, sizeof edge);
        memset(topo, -1, sizeof topo);
        for(int i = 1; i <= n; i++) G[i].clear();
        for(int i = 1; i <= n; i++) 
            cin >> X1[i] >> X2[i] >> Y1[i] >> Y2[i];
        for(int i = 1; i <= n; i++) {
            int x, y; cin >> x >> y;
            for(int j = 1; j <= n; j++) if(cover(x, y, j)) G[j].push_back(i);
        }
        int ans = max_match();
        memset(edge, 0, sizeof edge);
        for(int i = 1; i <= n; i++) {
            int v = from[i];
            if(~v) edge[i + n][v] = 1;
        } 
        for(int i = 1; i <= n; i++) {
            for(int j = 0; j < G[i].size(); j++) {
                int x = G[i][j];
                if(!edge[x + n][i]) edge[i][x + n] = 1;
            }
        }
        for(int i = 1; i <= 2 * n; i++) {
            G[i].clear();
            rG[i].clear();
        }
        for(int i = 1; i <= 2 * n; i++) {
            for(int j = 1; j <= 2 * n; j++) {
                if(edge[i][j]) add(i, j); 
            }
        }
        scc(2 * n);
        vector<pair<char, int> > vec;
        for(int i = 1; i <= n; i++) {
            int x = from[i];
            if(~x && topo[x] != topo[i + n]) vec.push_back(pair<char, int>('A' + x - 1, i));
        }
        sort(vec.begin(), vec.end());
        printf("Heap %d\n", kase++);
        if(!vec.size()) cout << "none" << endl << endl;
        else {
            for(int i = 0; i < vec.size(); i++) printf("(%c,%d)%c", vec[i].first, vec[i].second, i < vec.size() - 1 ? ' ' : '\n');
            cout << endl;
        }
    }
    return 0;
}