Граф на основе матрицы смежностей

        Map<String, List<String>> vertexMap = graph.getVertexMap();
        Collection<List<String>> values = vertexMap.values();
        Iterator<List<String>> iterator = values.iterator();
        while(iterator.hasNext())
        {
            List<String> next = iterator.next();
            next.iterator();
            while ...
        }

Map<String, List<String>> vertexMap = graph.getVertexMap();
StringBuilder sb = new StringBuilder();
for(Map.Entry<String,List<String>> line : vertexMap.entrySet()) {
    sb.append(line.getKey()).append(" : ");
    for(String name : line.getValue())
        sb.append(name).append(", "); 
    sb.append("\n");
}

        String[] names = {"Vasya", "Petya", "Kolya"};
        double [][] matrix = {
                {0, 1, 1.1},
                {1, 0, 1.2},
                {1.1, 1, 0}
        };
 
        for (int i = 0; i < matrix.length; ++i)
            for (int j = 0; j < matrix[i].length; ++j)
                if (matrix[i][j] == 0)
                    System.out.printf("No path from %s to %s\n", names[i], names[j]);
                else
                    System.out.printf("Path from %s to %s weights %.2f\n", names[i], names[j], matrix[i][j]);
    }

        double [][] matrix = {
                {1, 1, 0},
                {1, 0, 1},
                {0, 0, 0}

        String [] names = {"Vasya", "Kolya", "Petya", "Ivan"};
 
        double [][] matrix = {
                {0, 1.1, 1, 3},
                {1, 0, 1.2, 2.2},
                {2, 1, 0, 0.25},
                {2, 1, 0, 0}
        };
 
        Queue<Integer> queue = new LinkedList<Integer>(Arrays.asList(0));
 
        while (!queue.isEmpty()) {
            int current = queue.poll();
            for (int i = current + 1; i < names.length; ++i)
                if (matrix[current][i] > 0) {
                    queue.add(i);
                    System.out.printf("Route from %s to %s costs %.2f\n", names[current], names[i], matrix[current][i]);
                    System.out.printf("Queue size is %d\n", queue.size());
                }
        }

package isenbaev;
 
import java.util.Map;
import java.util.List;
import java.util.HashMap;
import java.util.ArrayList;
import java.util.Collections;
 
public class UndirectedGraph {
 
    private HashMap<String, List<String>> vertexMap = new HashMap<String, List<String>>();
 
    public void addVertex(String vertexName) {
        if (!hasVertex(vertexName)) {
            vertexMap.put(vertexName, new ArrayList<String>());
        }
    }
 
    public boolean hasVertex(String vertexName) {
        return vertexMap.containsKey(vertexName);
    }
 
    public boolean hasEdge(String vertexName1, String vertexName2) {
        if (!hasVertex(vertexName1)) return false;
        List<String> edges = vertexMap.get(vertexName1);
        return Collections.binarySearch(edges, vertexName2) != -1;
    }
 
    public void addEdge(String vertexName1, String vertexName2) {
        if (!hasVertex(vertexName1)) addVertex(vertexName1);
        if (!hasVertex(vertexName2)) addVertex(vertexName2);
        List<String> edges1 = vertexMap.get(vertexName1);
        List<String> edges2 = vertexMap.get(vertexName2);
        edges1.add(vertexName2);
        edges2.add(vertexName1);
        Collections.sort(edges1);
        Collections.sort(edges2);
    }
 
    public Map<String, List<String>> getVertexMap() {
        return vertexMap;
    }
}

package isenbaev;
 
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;
import java.util.TreeSet;
 
/**
 *
 * @author Gepar
 */
 
public class Isenbaev {
    
    static int getPos(String[] array, String whoNeed)
    {
        for(int i=0;i<array.length;i++)
            if(array[i].compareTo(whoNeed)==0)
                return i;
        return 0;
    }
    
    
    
    @SuppressWarnings("empty-statement")
    public static void main(String[] args) throws FileNotFoundException
    {
        Scanner scanner = new Scanner(new FileInputStream("input.txt"));
        TreeSet<String> hash = new TreeSet<>();//позволяет хранить список уникальных строк
        int size = scanner.nextInt();
        
        //считывание из файла фамилии учатсников комманд
        while(scanner.hasNext())
        {
            String s = scanner.nextLine();
            String[] split = s.split(" ");
            if(split.length!=3)//если в строке не 3 комманды значит попался какой-то мусор (или просто \n)
                continue;
            else //иначе добавляем все 3 фамилии в список
            {
                hash.add(split[0]);
                hash.add(split[1]);
                hash.add(split[2]);
            }
        }
        int peopleCount = hash.size();//сохраним количество уникальных фамилий
        
        //Массив для хранения уникальных фамилий
        //просто вытянем из списка все элементы по очереди в него
        String[] names = new String[peopleCount];
        Iterator<String> iterator = hash.iterator();
        int x=0;
        while(iterator.hasNext())
            names[x++]=iterator.next();
        scanner.close();//закрываем файл
        
        //открываем файл снова, на сей раз чтобы анализировать кто в какой команде находится
        scanner = new Scanner(new FileInputStream("input.txt"));
        scanner.nextLine();
        
        int [][] associates = new int[peopleCount][peopleCount];//матрица смежностей
        
        while(scanner.hasNext())
        {
            String s = scanner.nextLine();
            String[] split = s.split(" ");
            if(split.length!=3)
                continue;
            else
            {
                //получаем номера людей из команды в списке
                //(чтобы правильно заполнить матрицу смежностей)
                int first=getPos(names, split[0]);
                int second=getPos(names, split[1]);
                int third=getPos(names, split[2]);
                //System.out.println(split[0]+first+" "+split[1]+second+" "+split[2]+third);
                
                //добавляем связи между этими фамилиями в матрицу смежностей устанавливая 
                associates[first][first]=1;
                associates[first][second]=1;
                associates[first][third]=1;
                associates[second][first]=1;
                associates[second][second]=1;
                associates[second][third]=1;
                associates[third][first]=1;
                associates[third][second]=1;
                associates[third][third]=1;
            }
        }
        
        
        for(int i=0;i<associates.length;i++)
        {
            System.out.print(names[i]+" ");
            for(int j=0;j<associates[i].length;j++)
                System.out.print(associates[i][j]+" ");
            System.out.println();
        }
        System.out.print("\n\n\n\n");
        //  bool associates[][] = матрица смежности
//  int peopleCount = её размер
//  int isenbaevNumber[] = номера, заполнены INT_MAX, у Исенбаева сразу ноль
        int isenbaevPos = getPos(names,"Isenbaev");//узнаем номер Исенбаева в матрице смежностей чтобы установить его число = 0
        
        int[] isenbaevNumber = new int[peopleCount];//массив для хранения числа Исенбаева у каждого участника
        
        for(int i=0;i<peopleCount;i++)
            isenbaevNumber[i]= Integer.MAX_VALUE;
        isenbaevNumber[isenbaevPos]=0;
        
        Queue<Integer> queue = new LinkedList<>();
        Queue<Integer> queue2 = new LinkedList<>();
        boolean visited[] = new boolean[peopleCount];
        queue.add(isenbaevPos); // <-- номер Исенбаева
        int nextIsenbaevNumber = 1;
        while (!queue.isEmpty()) {
            while (!queue.isEmpty()) 
            {
            int next = queue.poll();
            if (visited[next]) {
                continue;
            }
            visited[next] = true;
            for (int i = 0; i < peopleCount; ++i) {
                if (associates[next][i]==1) {
                    if (isenbaevNumber[i] > nextIsenbaevNumber) {
                        isenbaevNumber[i] = nextIsenbaevNumber;
                    }
                    queue2.add(i);
                }
            }
        }
        Queue<Integer> temp = queue; queue = queue2; queue2 = temp;
        ++nextIsenbaevNumber;
    }
        
        //распечатка результатов
        for(int i=0;i<isenbaevNumber.length;i++)
        {
            System.out.print(names[i]+": ");
            if(isenbaevNumber[i]!= Integer.MAX_VALUE)
                System.out.println(isenbaevNumber[i]);
            else System.out.println("undefined");
        } 
    }
}