2024华为OD试题及答案-A026-快递业务站

题目描述

快递业务范围有 N 个站点，A 站点与 B 站点可以中转快递，则认为 A-B 站可达，
如果 A-B 可达，B-C 可达，则 A-C 可达。
现在给 N 个站点编号 0、1、…n-1，用 s[i][j]表示 i-j 是否可达，
s[i][j] = 1表示 i-j可达，s[i][j] = 0表示 i-j 不可达。
现用二维数组给定N个站点的可达关系，请计算至少选择从几个主站点出发，才能可达所有站点（覆盖所有站点业务）。
说明：s[i][j]与s[j][i]取值相同。

输入描述

第一行输入为 N，N表示站点个数。 1 < N < 10000
之后 N 行表示站点之间的可达关系，第i行第j个数值表示编号为i和j之间是否可达。

输出描述

输出站点个数，表示至少需要多少个主站点。

用例

输入	4 1 1 1 1 1 1 1 0 1 1 1 0 1 0 0 1
输出	1
说明	选择 0 号站点作为主站点， 0 站点可达其他所有站点， 所以至少选择 1 个站点作为主站才能覆盖所有站点业务。

输入	4 1 1 0 0 1 1 0 0 0 0 1 0 0 0 0 1
输出	3
说明	选择 0 号站点可以覆盖 0、1 站点， 选择 2 号站点可以覆盖 2 号站点， 选择 3 号站点可以覆盖 3 号站点， 所以至少选择 3 个站点作为主站才能覆盖所有站点业务。

题目解析

问题描述

给定一个由 N 个站点组成的快递业务网络，其中站点之间的可达性由一个 N x N 的矩阵表示。矩阵中的元素 s[i][j]s[i][j]s[i][j] 表示从站点 iii 到站点 jjj 是否可达，1 表示可达，0 表示不可达。通过某些站点可以中转连接其他站点，即如果 A 到 B 可达，B 到 C 可达，则 A 到 C 也可达。

现在要求计算最少需要选择多少个主站点，使得从这些主站点出发可以覆盖所有的站点（覆盖所有站点业务）。

输入描述

1. 第一行输入为 N，表示站点个数，1<N<=100001 < N <= 100001<N<=10000。
2. 接下来 N 行，每行包含 N 个整数，表示站点之间的可达关系。

输出描述

输出一个整数，表示至少需要多少个主站点。

示例

输入：

4
1 1 1 1
1 1 1 0
1 1 1 0
1 0 0 1

输出：

1

解释：选择 0 号站点作为主站点，0 站点可以覆盖其他所有站点，因此至少选择 1 个站点作为主站点。

输入：

4
1 1 0 0
1 1 0 0
0 0 1 0
0 0 0 1

输出：

3

解释：选择 0 号站点覆盖 0、1 站点，选择 2 号站点覆盖 2 号站点，选择 3 号站点覆盖 3 号站点，因此需要选择 3 个站点作为主站点。

解题思路

1. 图的连通性：这是一个关于图的连通性的经典问题。可以将其看作有向图，要求找到最小的顶点覆盖集。
2. 求强连通分量：使用 Kosaraju 算法或 Tarjan 算法求图的强连通分量。
3. 构建缩点后的新图：强连通分量缩点后形成新的有向无环图（DAG），找到入度为0的点的个数即为结果。

C++代码实现

#include <iostream>
#include <vector>
#include <stack>
#include <algorithm>

using namespace std;

void tarjan(int u, int &dfnIndex, vector<vector<int>> &adj, vector<int> &dfn, vector<int> &low, stack<int> &stk, vector<bool> &inStack, vector<int> &scc, int &sccCount) {
    dfn[u] = low[u] = ++dfnIndex;
    stk.push(u);
    inStack[u] = true;

    for (int v : adj[u]) {
        if (dfn[v] == -1) {
            tarjan(v, dfnIndex, adj, dfn, low, stk, inStack, scc, sccCount);
            low[u] = min(low[u], low[v]);
        } else if (inStack[v]) {
            low[u] = min(low[u], dfn[v]);
        }
    }

    if (dfn[u] == low[u]) {
        while (true) {
            int v = stk.top();
            stk.pop();
            inStack[v] = false;
            scc[v] = sccCount;
            if (u == v) break;
        }
        sccCount++;
    }
}

int main() {
    int N;
    cin >> N;

    vector<vector<int>> adj(N);
    for (int i = 0; i < N; ++i) {
        for (int j = 0; j < N; ++j) {
            int reachable;
            cin >> reachable;
            if (reachable) adj[i].push_back(j);
        }
    }

    vector<int> dfn(N, -1), low(N, -1), scc(N, -1);
    vector<bool> inStack(N, false);
    stack<int> stk;
    int dfnIndex = 0, sccCount = 0;

    for (int i = 0; i < N; ++i) {
        if (dfn[i] == -1) {
            tarjan(i, dfnIndex, adj, dfn, low, stk, inStack, scc, sccCount);
        }
    }

    vector<int> inDegree(sccCount, 0);
    for (int u = 0; u < N; ++u) {
        for (int v : adj[u]) {
            if (scc[u] != scc[v]) {
                inDegree[scc[v]]++;
            }
        }
    }

    int zeroInDegreeCount = count(inDegree.begin(), inDegree.end(), 0);

    cout << zeroInDegreeCount << endl;

    return 0;
}

代码说明

1. Tarjan算法：用于求解强连通分量。
2. 构建图：读取输入并构建邻接表表示的图。
3. 求解强连通分量：使用 Tarjan 算法求解图的强连通分量。
4. 构建缩点后的新图：计算缩点后的新图的入度，找出入度为0的点的个数。

这个程序能够计算出最少需要多少个主站点，使得从这些主站点出发可以覆盖所有的站点。

python代码实现

def tarjan(u, dfn_index, adj, dfn, low, stack, in_stack, scc, scc_count):
    dfn[u] = low[u] = dfn_index[0]
    dfn_index[0] += 1
    stack.append(u)
    in_stack[u] = True

    for v in adj[u]:
        if dfn[v] == -1:
            tarjan(v, dfn_index, adj, dfn, low, stack, in_stack, scc, scc_count)
            low[u] = min(low[u], low[v])
        elif in_stack[v]:
            low[u] = min(low[u], dfn[v])

    if dfn[u] == low[u]:
        while True:
            v = stack.pop()
            in_stack[v] = False
            scc[v] = scc_count[0]
            if u == v:
                break
        scc_count[0] += 1

def min_main_stations(N, adj):
    dfn = [-1] * N
    low = [-1] * N
    scc = [-1] * N
    in_stack = [False] * N
    stack = []
    dfn_index = [0]
    scc_count = [0]

    for i in range(N):
        if dfn[i] == -1:
            tarjan(i, dfn_index, adj, dfn, low, stack, in_stack, scc, scc_count)

    in_degree = [0] * scc_count[0]
    for u in range(N):
        for v in adj[u]:
            if scc[u] != scc[v]:
                in_degree[scc[v]] += 1

    zero_in_degree_count = in_degree.count(0)
    return zero_in_degree_count

# 读取输入
N = int(input().strip())
adj = []
for i in range(N):
    adj.append([j for j, reachable in enumerate(map(int, input().split())) if reachable == 1])

# 计算并输出最少主站点数
print(min_main_stations(N, adj))

代码说明

1. tarjan函数：实现了 Tarjan 算法，用于求解强连通分量。
2. min_main_stations函数：构建图并计算最少主站点数。使用 Tarjan 算法求解强连通分量，计算缩点后的新图的入度，找出入度为0的点的个数。
3. 读取输入：读取站点数和站点之间的可达性。
4. 计算并输出最少主站点数：调用 min_main_stations 函数计算最少主站点数，并输出结果。

这个 Python 程序能够计算出最少需要多少个主站点，使得从这些主站点出发可以覆盖所有的站点。你可以在 Python 环境中运行这个程序来实现该功能。