可以组成网络的服务器

题目要求

在一个机房中，服务器的位置标识在n*m的整数矩阵网格中，1表示单元格上有服务器，0表示没有。如果两台服务器位于同一行或者同一列中紧邻的位置，则认为它们之间可以组成一个局域网，请你统计机房中最大的局域网包含的服务器个数。

输入描述

第一行输入两个正整数，n和m，0<n,m<=100

之后为n*m的二维数组，代表服务器信息

输出描述

最大局域网包含的服务器个数。

示例1

输入：
5 12
1 0 0 0 1
1 1 1 1 1
1 0 0 1 1
1 0 0 1 1
1 0 0 1 1
1 0 0 1 1
0 0 0 0 0
1 1 1 1 1
1 0 0 1 1
1 0 0 1 1
1 0 0 1 1
1 0 0 1 1

输出：
19

解题思路

1. 相互连接等于多点发散
2. 发散的同时可能造成重复
3. 断开后的点可能还有别的起点

综上

1. 遍历所有的点
2. 每次遍历的时候，判断当前点是否是服务器
3. 是服务器，则用队列收集起来，用作起点，并向上下左右发散
4. 每次发散，是服务器，则继续收集到队列，且作为发散的原点要移出
5. 进行队列判空，当没有可发散的点，则路径收集完毕
6. 路径的收集可以用集合，再用集合判是否包含，确认该点是否被发散过
7. 收集到的每条路径，判断起元素的多少即为服务器的数量，且需要一个大集合一并收集，再最外层的遍历的时候判断是否已经收集过

代码

package com.example.demo.algorithm;

import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

/**
 * @Desc: 可以组成网络的服务器
 * @Auther:chenLing
 * @Date: 2024/7/17 16:13
 */
public class Test01 {
    static final int[] DX = {0, 1, 0, -1};
    static final int[] DY = {1, 0, -1, 0};
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int[] input = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        int n = input[0];
        int m = input[1];
        int[][] arr = new int[m][n];
        for (int i = 0; i < m; i++) {
            arr[i] = Arrays.stream(sc.nextLine().split(" ")).mapToInt(Integer::parseInt).toArray();
        }
        sc.close();
        List<String> allLoad = new ArrayList<>();
        Integer max = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                String key = i + "," + j;
                // 非服务器或服务器已统计过
                if (arr[i][j] == 0 || allLoad.contains(key)) {
                    continue;
                }
                // 收集服务器坐标
                List<String> load = new ArrayList<>();
                load.add(key);
                // 收集每个服务器的扩散点
                Queue<int[]> queue = new ArrayDeque<>();
                queue.add(new int[]{i, j});
                while (!queue.isEmpty()) {
                    int[] poll = queue.poll();
                    for (int k = 0; k < 4; k++) {
                        int xx = DX[k] + poll[0];
                        int yy = DY[k] + poll[1];
                        // 越界或者已经统计，则移出
                        if (xx < 0 || yy < 0 || xx >= arr.length || yy >= arr[0].length
                            || load.contains(xx + "," + yy)
                            || arr[xx][yy] == 0) {
                            continue;
                        }
                        load.add(xx + "," + yy);
                        queue.offer(new int[]{xx, yy});
                    }
                }

                allLoad.addAll(load);
                if (load.size() > max) {
                    max = load.size();
                }
            }
        }
        System.out.println(max);
    }
}