java实现最长广播响应

---

描述

某通信网络中有N个网络结点，用1到N进行标识。
网络中的结点互联互通，且结点之间的消息传递有时延，相连结点的时延均为一个时间单位。
现给定网络结点的连接关系link[]={u,v}，其中u和v表示网络结点。
当指定一个结点向其他结点进行广播，所有被广播结点收到消息后都会在原路径上回复一条响应消息，请计算发送结点至少需要等待几个时间单位才能收到所有被广播结点的响应消息。

注:
1.N的取值范围为[1,100]；
2.连接关系link的长度不超过3000，且1<=u,v<= N；
3.网络中任意结点间均是可达的。

输入描述：
输入的第一行为两个正整数，分别表示网络结点的个数N，以及时延列表的长度T;接下来的T行输入，表示结点间的连接关系列表；
最后一行的输入为一个正整数，表示指定的广播结点序号。

输出描述：
输出一个整数，表示发送结点接收到所有响应消息至少需要等待。

用例：

String consen = "5 7";
        List<String> relcon = new ArrayList<>();
        relcon.add("1 4");
        relcon.add("2 1");
        relcon.add("2 3");
        relcon.add("2 4");
        relcon.add("3 4");
        relcon.add("3 5");
        relcon.add("4 5");
        int start = 2;

输出：4

java实现

我不知道这样做有没有问题，是出了结果了，有大佬看见的话，指导一下。

package com.des.data.test;

import java.util.*;

public class LongestBroadcastResponse {
    public static void main(String[] args) {
        String consen = "5 7";
        List<String> relcon = new ArrayList<>();
        relcon.add("1 4");
        relcon.add("2 1");
        relcon.add("2 3");
        relcon.add("2 4");
        relcon.add("3 4");
        relcon.add("3 5");
        relcon.add("4 5");
        int start = 2;
        System.out.println(solution(consen, relcon, 2));
    }

    public static int solution(String consen, List<String> relon, int start) {
        String[] a = consen.split(" ");
        int num = Integer.parseInt(a[0]);
        int size = Integer.parseInt(a[1]);
        int dis = 0;
        HashMap<Integer, List<Integer>> graph = new HashMap<>();
        for (int i = 1; i < num + 1; i++) {
            List<Integer> nexts = new ArrayList<>();
            for (int j = 0; j < size; j++) {
                String[] c = relon.get(j).split(" ");
                int st = Integer.parseInt(c[0]);
                int et = Integer.parseInt(c[1]);
                if (st == i) {
                    nexts.add(et);
                }
            }
            graph.put(i, nexts);
        }
        boolean visited[] = new boolean[num];
        visited[start - 1] = true;
        LinkedHashMap<Integer, List<Integer>> map = new LinkedHashMap<>();
        map.put(start, graph.get(start));
        for (int i = 0; i < num - 1; i++) {//最多num-1个时间片就能全部接收到回复
            boolean vable = false;
            for (int j = 0; j < visited.length; j++) {
                if (!visited[j]) {
                    vable = true;
                    break;
                }
            }
            if (vable) {
                dis++;
                LinkedHashMap<Integer, List<Integer>> mapN = new LinkedHashMap<>();
                for (Map.Entry<Integer, List<Integer>> entry : map.entrySet()) {
                    int key = entry.getKey();
                    List<Integer> values = entry.getValue();
                    if (!visited[key - 1]) {
                        continue;
                    }
                    for (Map.Entry<Integer, List<Integer>> entryL : graph.entrySet()) {
                        int keyL = entryL.getKey();
                        List<Integer> valuesL = entryL.getValue();
                        if (values.contains(keyL)) {
                            mapN.put(keyL, valuesL);
                            visited[keyL - 1] = true;
                        }
                    }
                }
                map = mapN;
            }
        }
        return dis*2;
    }
}