2015-2016 ACM-ICPC Southwestern Europe Regional Contest (SWERC 15) A.Promotions

Promotions

题目描述

The Fair Inc. administration decided to promote the best
employees and limited the number of promotions to a fixed
interval [A, B]. The directors compared the employees’
performance and their evaluations resulted in a consistent
precedence relation among employees, which has to be respected by promotions. This means that, for every pair of
employees x and y, if x outperformed y, then y may be
promoted only if x is promoted.
In order to understand whether the data collected so far is
enough for ensuring fairness, the executive chairman wants to know:
• How many employees will certainly be promoted in the
interval endpoints (i.e., if the number of promotions is
A and if the number of promotions is B).
• How many employees have no possibility of being
promoted (even if the number of promotions is B).
Consider the example depicted in the figure. There are seven
employees and eight precedence rules. An arrow from an
employee x to an employee y means that x outperformed y. The number of promotions is limited to the interval [3, 4]. Therefore:
• If there are only three promotions, the promoted employees must be:
– either Anne, Bob and Greg,
– or Anne, Eve and Greg.
In this case, two employees (Anne and Greg) will certainly be promoted. Notice that, with the current information, Bob and Eve may or may not win a promotion.
• If there are four promotions, the promoted employees have to be:
– Anne, Bob, Eve and Greg.
So, with four promotions, four employees (Anne, Bob, Eve and Greg) will certainly
be promoted and three employees (Cora, Dan and Fred) have no possibility of being promoted.

Write a program that, given the interval of the number of promotions, the set of employees
and the precedence relation among them, computes, for each of the interval endpoints, the
number of employees that will certainly be promoted, and the number of employees that
have no possibility of being promoted.
The precedence relation is consistent in the sense that, if an employee x outperformed an
employee y, y did not outperform (directly or indirectly) x.

输入描述

The first line of the input has four space separated integers: A, B, E, and P. A and B are the interval endpoints, E is the number of employees and P is the number of precedence rules. Employees are identified by integers, ranging from 0 to E − 1.
Each of the following P lines contains two distinct space separated integers, x and y, which indicate that employee x outperformed employee y.

输出描述

The output consists of three lines. The first line contains the number of employees that will certainly be promoted if there are A promotions. The second line contains the number of employees that will certainly be promoted if there are B promotions. The third line contains the number of employees that have no possibility of being promoted (even if there are B promotions).

数据规模与约定

1 ≤ A < B < E Interval endpoints.
2 ≤ E ≤ 5 000 Number of employees.
1 ≤ P ≤ 20 000 Number of precedence rules.

样例输入

3 4 7 8
0 4
1 2
1 5
5 2
6 4
0 1
2 3
4 5

样例输出

2
4
3

原题

CF——传送门

代码

#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

vector<int> Next[5006]; // 正向图，记录每个点的后继节点
vector<int> Pre[5006];  // 反向图，记录每个点的前驱节点

bool vis[5006]; // 记录该节点是否已经访问过

int dfs_next(int v)
{
    int res = 0;
    for (int i = 0; i < Next[v].size(); i++)
    {
        int u = Next[v][i]; // 后继节点
        if (vis[u])         // 若已访问则跳过
            continue;
        vis[u] = 1; // 标记为已访问
        res += dfs_next(u);
        res++; // 加上该节点本身
    }
    return res;
}

int dfs_pre(int v)
{
    int res = 0;
    for (int i = 0; i < Pre[v].size(); i++)
    {
        int u = Pre[v][i]; // 前驱节点
        if (vis[u])        // 若已访问则跳过
            continue;
        vis[u] = 1; // 标记为已访问
        res += dfs_pre(u);
        res++; // 加上该节点本身
    }
    return res;
}

int main()
{
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);

    int a, b, n, m;
    cin >> a >> b >> n >> m;
    int x, y;
    for (int i = 1; i <= m; i++)
    {
        cin >> x >> y;
        Next[x].push_back(y);
        Pre[y].push_back(x);
    }
    int ans1 = 0;               // 对于晋升a个节点，ans1为确定晋升的节点数量
    int ans2 = 0;               // 对于晋升b个节点，ans2为确定晋升的节点数量
    for (int i = 0; i < n; i++) // 第i个节点
    {
        memset(vis, 0, sizeof(vis)); // 清空标记已访问的数组
        int num = dfs_next(i);       // 在i节点后面的节点数量
        if (num >= n - a)            // 若在该节点后面的节点数量大于等于不晋升的节点数量，那该节点必须晋升
            ans1++;
        if (num >= n - b) // 若在该节点后面的节点数量大于等于不晋升的节点数量，那该节点必须晋升
            ans2++;
    }
    int ans3 = 0;               // 对于晋升b个节点，ans3为确定不会晋升的节点数量
    for (int i = 0; i < n; i++) // 第i个节点
    {
        memset(vis, 0, sizeof(vis)); // 清空标记已访问的数组
        int num = dfs_pre(i);        // 在i节点前面的节点数量
        if (num >= b)                // 若已有b个及以上的节点在其前面，那其必不会晋升
            ans3++;
    }
    cout << ans1 << '\n';
    cout << ans2 << '\n';
    cout << ans3 << '\n';

    return 0;
}