【华为OD机试E卷真题】 Linux发行版的数量| 原题+思路+多语言代码（本题100%）（C++、Java、Py）

华为OD机试E卷真题 Linux发行版的数量| 原题+思路+多语言代码（本题100%）（C++、Java、Py）

题目描述

Linux操作系统有多个发行版,distrowatch.com提供了各个发行版的资料。这些发行版互相存在关联，例如Ubuntu基于Debian开发，而Mint又基于Ubuntu开发，那么我们认为Mint同Debian也存在关联。

发行版集是一个或多个相关存在关联的操作系统发行版，集合内不包含没有关联的发行版。

给你一个 n * n 的矩阵 isConnected，其中 isConnected[i][j] = 1 表示第 i 个发行版和第 j 个发行版直接关联，而 isConnected[i][j] = 0 表示二者不直接相连。

返回最大的发行版集中发行版的数量。

输入描述

第一行输入发行版的总数量N，

之后每行表示各发行版间是否直接相关

备注

1 ≤ N ≤ 200

输出描述

输出最大的发行版集中发行版的数量

示例1

输入

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

输出

3

说明

Debian(1)和Unbuntu(2)相关
Mint(3)和Ubuntu(2)相关，
EeulerOS(4)和另外三个都不相关，
所以存在两个发行版集，发行版集中发行版的数量分别是3和1，所以输出3

解题思路

1. DFS或BFS：使用深度优先搜索或广度优先搜索来遍历图，找到每个连通分量的大小。

2. 邻接矩阵：输入的邻接矩阵表示节点之间的连接关系。

3. visited数组：记录每个节点是否被访问过，避免重复访问。

4. 最大连通分量：遍历所有节点，记录每个连通分量的大小，并找出最大的那个

代码

java

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int[][] isConnected = new int[n][n];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < n; j++) {
                isConnected[i][j] = scanner.nextInt();
            }
        }
        scanner.close();

        boolean[] visited = new boolean[n];
        int max = 0;

        for (int i = 0; i < n; i++) {
            if (!visited[i]) {
                int count = dfs(isConnected, visited, i);
                if (count > max) {
                    max = count;
                }
            }
        }

        System.out.println(max);
    }

    private static int dfs(int[][] isConnected, boolean[] visited, int i) {
        visited[i] = true;
        int count = 1;
        for (int j = 0; j < isConnected.length; j++) {
            if (isConnected[i][j] == 1 && !visited[j]) {
                count += dfs(isConnected, visited, j);
            }
        }
        return count;
    }
}

python

def main():
    import sys
    input = sys.stdin.read().split()
    idx = 0
    n = int(input[idx])
    idx += 1

    isConnected = []
    for _ in range(n):
        row = list(map(int, input[idx:idx + n]))
        idx += n
        isConnected.append(row)

    visited = [False] * n
    max_size = 0

    def dfs(i):
        stack = [i]
        visited[i] = True
        count = 1
        while stack:
            node = stack.pop()
            for j in range(n):
                if isConnected[node][j] == 1 and not visited[j]:
                    visited[j] = True
                    count += 1
                    stack.append(j)
        return count

    for i in range(n):
        if not visited[i]:
            size = dfs(i)
            if size > max_size:
                max_size = size

    print(max_size)

if __name__ == "__main__":
    main()

c++

#include <iostream>
#include <vector>
using namespace std;

int main() {
    int n;
    cin >> n;
    vector<vector<int>> isConnected(n, vector<int>(n));
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            cin >> isConnected[i][j];
        }
    }

    vector<bool> visited(n, false);
    int max_size = 0;

    for (int i = 0; i < n; i++) {
        if (!visited[i]) {
            int count = 0;
            stack<int> st;
            st.push(i);
            visited[i] = true;
            count = 1;

            while (!st.empty()) {
                int node = st.top();
                st.pop();

                for (int j = 0; j < n; j++) {
                    if (isConnected[node][j] == 1 && !visited[j]) {
                        visited[j] = true;
                        count++;
                        st.push(j);
                    }
                }
            }

            if (count > max_size) {
                max_size = count;
            }
        }
    }

    cout << max_size << endl;

    return 0;
}