二分图的匹配

Acwing257 关押罪犯

S 城现有两座监狱，一共关押着 N 名罪犯，编号分别为1~N。

他们之间的关系自然也极不和谐。

很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。

我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。

如果两名怨气值为 c 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为 c 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 S 城 Z 市长那里。

公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

在详细考察了 N 名罪犯间的矛盾关系后，警察局长觉得压力巨大。

他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。

假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。那么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？

 

输入格式

第一行为两个正整数 N 和 M，分别表示罪犯的数目以及存在仇恨的罪犯对数。

接下来的 M 行每行为三个正整数aj，bj，cj，表示aj号和bj号罪犯之间存在仇恨，其怨气值为cj。

数据保证1≤aj<bj<N,0<cj≤1000000000 且每对罪犯组合只出现一次。

 

输出格式

输出共1行，为 Z 市长看到的那个冲突事件的影响力。

如果本年内监狱中未发生任何冲突事件，请输出0。

 

数据范围

N≤20000,M≤100000

 

输入样例：

4 6
1 4 2534
2 3 3512
1 2 28351
1 3 6618
2 4 1805
3 4 12884

 

输出样例：

3512

//并查集解法
#include
using namespace std;
const int N = 1e5 + 7;
int par[N], n, m;
struct Node {
    int x, y, c;
}e[N];
int find(int x) {
    return x == par[x] ? x : par[x] = find(par[x]);
}
void merge(int x, int y) {
    int fx = find(x), fy = find(y);
    if (fx == fy) return;
    par[fx] = fy;
}
bool same(int x, int y) {
    return find(x) == find(y);
}
void init() {
    for (int i = 0; i < N; i++) par[i] = i;
}
bool check(int x) {
    init();
    for (int i = 1; i <= m; i++) {
        if (e[i].c <= x) continue;
        if (same(e[i].x, e[i].y)) return false;
        merge(e[i].x + n, e[i].y);
        merge(e[i].x, e[i].y + n);
    }
    return true;
}
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
        scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].c);
    int l = 0, r = 1e9;
    while (l <= r) {
        int k = (l + r) >> 1;
        if (check(k))
            r = k - 1;
        else
            l = k + 1;
    }
    printf("%d\n", l);
    return 0;
}

 

//二分图解法
#include
using namespace std;
const int N = 2e5 + 7;
namespace Graph {
    int head[N], ver[N], nex[N], col[N], tot, n, f;
    void init(int x) {
        tot = 0; f = 0;
        n = x;
        memset(col, 0, sizeof(col));
        memset(head, 0, sizeof(head));
    }
    void add(int x, int y) {
        ver[++tot] = y;
        nex[tot] = head[x];
        head[x] = tot;
    }
    void printGraph() {
        for (int i = 1; i <= n; i++) {
            printf("%d: ", i);
            for (int j = head[i]; j; j = nex[j]) {
                printf("%d ", ver[j]);
            }
            printf("\n");
        }
    }
    void dfs(int x, int c) {
        col[x] = c;
        for (int i = head[x]; i; i = nex[i]) {
            int y = ver[i];
            if (!col[y])
                dfs(y, 3 - c);
            else if (col[y] == c) {
                f = 1;
            }
        }
    }
    void solve() {
        for (int i = 1; i <= n; i++) {
            if (!col[i]) dfs(i, 1);
        }
    }
    int status() {
        return f;
    }
}
struct Node {
    int x, y, c;
}e[N];
int n, m;
int main() {
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; i++)
        scanf("%d%d%d", &e[i].x, &e[i].y, &e[i].c);
    int l = 0, r = 1e9;
    while (l <= r) {
        int k = (l + r) >> 1;
        Graph::init(n);
        for (int i = 1; i <= m; i++) {
            if (e[i].c > k) {
                Graph::add(e[i].x, e[i].y);
                Graph::add(e[i].y, e[i].x);
            }
        }
        //Graph::printGraph();
        Graph::solve();
        //printf("%d\n", Graph::f);
        if (!Graph::status())
            r = k - 1;
        else
            l = k + 1;
    }
    printf("%d\n", l);
    return 0;
}

 

Acwing372 棋盘覆盖

给定一个N行N列的棋盘，已知某些格子禁止放置。

求最多能往棋盘上放多少块的长度为2、宽度为1的骨牌，骨牌的边界与格线重合（骨牌占用两个格子），并且任意两张骨牌都不重叠。

输入格式

第一行包含两个整数N和t，其中t为禁止放置的格子的数量。

接下来t行每行包含两个整数x和y，表示位于第x行第y列的格子禁止放置，行列数从1开始。

输出格式

输出一个整数，表示结果。

数据范围

1≤N≤100

输出样例：

8 0

输出样例：

32

#include
#include
using namespace std;
typedef long long LL;
const int N = 2e2 + 7;
int a[N][N], head[N * N], nex[N * N], vis[N * N], ver[N * N], match[N * N], tot;
const int delta[4][2] = {{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
namespace MyStd {
#define isDigit(ch) (ch >= '0' && ch <= '9')

    inline int read() {
        char ch = getchar();
        int x = 0, f = 1;
        while (!isDigit(ch)) {
            if (ch == '-') f = -1;
            ch = getchar();
        }
        while (isDigit(ch)) {
            x = x * 10 + ch - '0';
            ch = getchar();
        }
        return x * f;
    }
    inline int max(int x, int y) { return x < y ? y : x; }
    inline int min(int x, int y) { return x < y ? x : y; }
    template
    inline T ksm(T a, T b, T mod) {
        T ans = 1;
        while (b) {
            if (b & 1) ans = ans * a % mod;
            a = a * a % mod;
            b >>= 1;
        }
        return ans;
    }
}
void add(int x, int y) {
    ver[++tot] = y;
    nex[tot] = head[x];
    head[x] = tot;
}
bool dfs(int x) {
    for (int i = head[x]; i; i = nex[i]) {
        int y = ver[i];
        if (!vis[y]) {
            vis[y] = 1;
            if (!match[y] || dfs(match[y])) {
                match[y] = x; return true;
            }
        }
    }
    return false;
}
int solve(int n) {
    int ans = 0;
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if ((i + j) & 1 || a[i][j]) continue;
            memset(vis, 0, sizeof(vis));
            if (dfs((i - 1) * n + j)) ans++;
        }
    }
    return ans;
}
int main() {
    int n = MyStd::read();
    int t = MyStd::read();
    while (t--) {
        int x = MyStd::read();
        int y = MyStd::read();
        a[x][y] = 1;
    }
    for (int i = 1; i <= n; i++) {
        for (int j = 1; j <= n; j++) {
            if ((i + j) & 1 || a[i][j]) continue;
            for (int k = 0; k < 4; k++) {
                int x = i + delta[k][0];
                int y = j + delta[k][1];
                if (x >= 1 && x <= n && y >= 1 && y <= n && !a[x][y]) {
                    add((i - 1) * n + j, (x - 1) * n + y);
                }
            }
        }
    }
    printf("%d\n", solve(n));
    return 0;
}