输入格式: 1、第一行输入武将个数N，关系数量M，2<N<1000，我们给他们分别编号为1到N。 2、随后M行，按以下格式依次给出每一个人的关系： ID[1] K ID[2] ... ID[N] 为1号武将与其他武将的两两关系为K。 其中第1个数为指定武将编号，第2个数K是关系数，后面分别是和指定武将有关系为K的武将编号。 3、最后一行输入两个整数S和T，用于查询武将编号S和T的羁绊最小值。 输出格式: 输出一个整数，为编号S和T武将的羁绊值的最小值（考虑直接或间接羁绊）。 输入样例: 在这里给出一组输入。例如： 4 3 1 2 2 3 1 3 4 3 3 2 4 2 4 输出样例: 在这里给出相应的输出。例如： 5

这是一道关于图的最短路径问题，可以用 Dijkstra 算法解决。以下是 Java 代码实现：

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int n = scanner.nextInt();
        int m = scanner.nextInt();
        int[][] graph = new int[n+1][n+1];
        for (int i = 1; i <= n; i++) {
            Arrays.fill(graph[i], Integer.MAX_VALUE);
            graph[i][i] = 0;
        }
        for (int i = 0; i < m; i++) {
            int s = scanner.nextInt();
            int k = scanner.nextInt();
            for (int j = 0; j < k; j++) {
                int t = scanner.nextInt();
                graph[s][t] = graph[t][s] = 1;
            }
        }
        int s = scanner.nextInt();
        int t = scanner.nextInt();
        int[] dist = new int[n+1];
        boolean[] visited = new boolean[n+1];
        Arrays.fill(dist, Integer.MAX_VALUE);
        dist[s] = 0;
        for (int i = 1; i <= n; i++) {
            int u = -1;
            int minDist = Integer.MAX_VALUE;
            for (int j = 1; j <= n; j++) {
                if (!visited[j] && dist[j] < minDist) {
                    u = j;
                    minDist = dist[j];
                }
            }
            if (u == -1) {
                break;
            }
            visited[u] = true;
            for (int v = 1; v <= n; v++) {
                if (!visited[v] && graph[u][v] != Integer.MAX_VALUE && dist[u] + graph[u][v] < dist[v]) {
                    dist[v] = dist[u] + graph[u][v];
                }
            }
        }
        System.out.println(dist[t] == Integer.MAX_VALUE ? -1 : dist[t]);
    }
}

算法的时间复杂度为 $O(n^2)$，其中 $n$ 是武将数量。