必做题Week10

[NOIP2010 提高组] 关押罪犯

题目背景

NOIP2010 提高组 T3

题目描述

S 城现有两座监狱，一共关押着 $N$ 名罪犯，编号分别为 $1\sim N$。他们之间的关系自然也极不和谐。很多罪犯之间甚至积怨已久，如果客观条件具备则随时可能爆发冲突。我们用“怨气值”（一个正整数值）来表示某两名罪犯之间的仇恨程度，怨气值越大，则这两名罪犯之间的积怨越多。如果两名怨气值为 $c$ 的罪犯被关押在同一监狱，他们俩之间会发生摩擦，并造成影响力为 $c$ 的冲突事件。

每年年末，警察局会将本年内监狱中的所有冲突事件按影响力从大到小排成一个列表，然后上报到 S 城 Z 市长那里。公务繁忙的 Z 市长只会去看列表中的第一个事件的影响力，如果影响很坏，他就会考虑撤换警察局长。

在详细考察了 $N$ 名罪犯间的矛盾关系后，警察局长觉得压力巨大。他准备将罪犯们在两座监狱内重新分配，以求产生的冲突事件影响力都较小，从而保住自己的乌纱帽。假设只要处于同一监狱内的某两个罪犯间有仇恨，那么他们一定会在每年的某个时候发生摩擦。

那么，应如何分配罪犯，才能使 Z 市长看到的那个冲突事件的影响力最小？这个最小值是多少？

输入格式

每行中两个数之间用一个空格隔开。第一行为两个正整数 $N,M$，分别表示罪犯的数目以及存在仇恨的罪犯对数。接下来的 $M$ 行每行为三个正整数 $a_j,b_j,c_j$，表示 $a_j$ 号和 $b_j$ 号罪犯之间存在仇恨，其怨气值为 $c_j$。数据保证 $1<a_j\le b_j\le N,0<c_j\le 10^9$，且每对罪犯组合只出现一次。

输出格式

共一行，为 Z 市长看到的那个冲突事件的影响力。如果本年内监狱中未发生任何冲突事件，请输出 0。

样例 #1

样例输入 #1

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

样例输出 #1

3512

提示

输入输出样例说明

罪犯之间的怨气值如下面左图所示，右图所示为罪犯的分配方法，市长看到的冲突事件影响力是 $3512$（由 $2$ 号和 $3$ 号罪犯引发）。其他任何分法都不会比这个分法更优。

数据范围

对于 $30\%$ 的数据有 $N\le 15$。

对于 $70\%$ 的数据有 $N\le 2000,M\le 50000$。

对于 $100\%$ 的数据有 $N\le 20000,M\le 100000$。

思路：用并查集维护集合，从大到小，依次把怨气值大的先分开

代码

#include<iostream>
#include<algorithm>

using namespace std;

struct data1
{
    int x, y, z;
};

const int N = 1e5 + 10;

data1 f[N];
int n, m, p[N], b[N], i;

bool cmp(data1 a, data1 b)
{
    return a.z > b.z;
}

int find(int x)
{
    if(p[x] == x) return x;
    p[x] = find(p[x]);
    return p[x];
}

void ad(int x, int y)
{
    x = find(x);
    y = find(y);
    p[x] = y;
}

bool check(int x, int y)
{
    x = find(x);
    y = find(y);
    if(x == y) return true;
    return false;
}

int main()
{
    cin >> n >> m;
    for(int i = 1; i <= n; i++) p[i] = i;
    for(int i = 1; i <= m; i++) cin >> f[i].x >> f[i].y >> f[i].z;
    sort(f + 1, f + m + 1, cmp);

    for(int i = 1; i <= m + 1; i++)
    {
        if(check(f[i].x, f[i].y)) 
        {
            printf("%d", f[i].z);
            break;
        }
        else
        {
            if(!b[f[i].x]) b[f[i].x] = f[i].y;
            else{
                ad(b[f[i].x], f[i].y);
            }
            if(!b[f[i].y]) b[f[i].y] = f[i].x;
            else{
                ad(b[f[i].y], f[i].x);
            }
        }
    }
    return 0;
}

【模板】二分图最大匹配

题目描述

给定一个二分图，其左部点的个数为 $n$，右部点的个数为 $m$，边数为 $e$，求其最大匹配的边数。

左部点从 $1$ 至 $n$ 编号，右部点从 $1$ 至 $m$ 编号。

输入格式

输入的第一行是三个整数，分别代表 $n$，$m$ 和 $e$。

接下来 $e$ 行，每行两个整数 $u,v$，表示存在一条连接左部点 $u$ 和右部点 $v$ 的边。

输出格式

输出一行一个整数，代表二分图最大匹配的边数。

样例 #1

样例输入 #1

1 1 1
1 1

样例输出 #1

1

样例 #2

样例输入 #2

4 2 7
3 1
1 2
3 2
1 1
4 2
4 1
1 1

样例输出 #2

2

提示

数据规模与约定

对于全部的测试点，保证：

• $1\le n,m\le 500$。
• $1\le e\le 5\times 10^4$。
• $1\le u\le n$，$1\le v\le m$。

不保证给出的图没有重边。

思路：就是二分图的模板

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 510;
int uN, k, m;
int linker[N];
int g[N][N];
bool used[N];

bool dfs(int u)
{
    for(int i = 1; i <= m; i++)
    {
        if(g[u][i] && !used[i])
        {
            used[i] = true;
            if(linker[i] == -1 || dfs(linker[i]))
            {
                linker[i] = u;
                return true;
            }
        }
    }
    return false;
}

int hungary()
{
    int res = 0;
    memset(linker, -1, sizeof linker);
    for(int i = 1; i <= uN; i++)
    {
        memset(used, false, sizeof used);
        if(dfs(i))res++;
    }
    return res;
}
int main()
{
    cin >> uN >> m >> k;

    while(k--)
    {
        int u, v;
        cin >> u >> v;
        if(u != 0 && v != 0)
        g[u][v] = 1;
    }
    printf("%d\n", hungary());
    return 0;
}

[ZJOI2007] 矩阵游戏

题目描述

小 Q 是一个非常聪明的孩子，除了国际象棋，他还很喜欢玩一个电脑益智游戏――矩阵游戏。矩阵游戏在一个 $n\times n$ 黑白方阵进行（如同国际象棋一般，只是颜色是随意的）。每次可以对该矩阵进行两种操作：

• 行交换操作：选择矩阵的任意两行，交换这两行（即交换对应格子的颜色）。
• 列交换操作：选择矩阵的任意两列，交换这两列（即交换对应格子的颜色）。

游戏的目标，即通过若干次操作，使得方阵的主对角线(左上角到右下角的连线)上的格子均为黑色。

对于某些关卡，小 Q 百思不得其解，以致他开始怀疑这些关卡是不是根本就是无解的！于是小 Q 决定写一个程序来判断这些关卡是否有解。

输入格式

本题单测试点内有多组数据。

第一行包含一个整数 $T$，表示数据的组数，对于每组数据，输入格式如下：

第一行为一个整数，代表方阵的大小 $n$。
接下来 $n$ 行，每行 $n$ 个非零即一的整数，代表该方阵。其中 $0$ 表示白色，$1$ 表示黑色。

输出格式

对于每组数据，输出一行一个字符串，若关卡有解则输出 Yes，否则输出 No。

样例 #1

样例输入 #1

2
2
0 0
0 1
3
0 0 1
0 1 0
1 0 0

样例输出 #1

No
Yes

提示

数据规模与约定

• 对于 $20\%$ 的数据，保证 $n\le 7$。
• 对于 $50\%$ 的数据，保证 $n\le 50$。
• 对于 $100\%$ 的数据，保证 $1\le n\le 200$，$1\le T\le 20$。

思路：行列作为左右部分二分，匹配数等于n则可行

代码

#include<bits/stdc++.h>

using namespace std;

const int N = 210;
int g[N][N];
int t, n, match[N];
bool st[N];

bool find(int x)
{
    for(int i = 1; i <= n; i++)
    {
        if(st[i] || g[x][i] == 0)continue;
        st[i] = true;
        if(!match[i] || find(match[i]))
        {
            match[i] = x;
            return true;
        }
    }
    return false;
}

void solve()
{
    memset(match, 0, sizeof match);
    bool flag = true;
    for(int i = 1; i <= n; i++)
    {
        memset(st, false, sizeof st);
        if(!find(i))
        {
            flag = 0;
            break;
        }
    }
    if(flag)puts("Yes");
    else puts("No");
}
int main()
{
    cin >> t;
    while(t--)
    {
        cin >> n;
        for(int i = 1; i <= n; i++)
        {
            for(int j = 1; j <= n; j++)
            {
                scanf("%d", &g[i][j]);
            }
        }
        solve();
    }
    return 0;
}