Alternate room connection algorithm; caching

void ConnectClosestRooms(List<Room> allRooms) {
    List<Connection> connections = new List<Connection> ();
    Dictionary<Coord, Connection> connectionCache = new Dictionary<Coord, Connection>();

    // lists representing indices of visited/unvisited rooms
    List<int> visitedRooms = new List<int> ();
    List<int> unvisitedRooms = new List<int> ();

    // populate lists
    visitedRooms.Add (0);
    for (int i = 1; i < allRooms.Count; i++) {
        unvisitedRooms.Add (i);
    }


    // search until all rooms have been visited
    while (unvisitedRooms.Count > 0) {

        // Find best connection between visited and unvisited rooms
        Connection bestConnection = new Connection ();
        bestConnection.distance = int.MaxValue;
        Connection other = new Connection ();

        for (int i = 0; i < visitedRooms.Count; i++) {
            for (int j = 0; j < unvisitedRooms.Count; j++) {
                int roomA = visitedRooms [i];
                int roomB = unvisitedRooms [j];
                Coord key = new Coord (roomA, roomB);

                Connection bestLocalConnection = new Connection ();
                bestLocalConnection.distance = int.MaxValue;

                if (connectionCache.ContainsKey (key)) {
                    bestLocalConnection = connectionCache [key];
                }
                else {
                    // search all tiles to find shortest connection between room A and B
                    for (int tileIndexA = 0; tileIndexA < allRooms [roomA].edgeTiles.Count; tileIndexA++) {
                        for (int tileIndexB = 0; tileIndexB < allRooms [roomB].edgeTiles.Count; tileIndexB++) {
                            int dX = allRooms [roomA].edgeTiles [tileIndexA].tileX - allRooms [roomB].edgeTiles [tileIndexB].tileX;
                            int dY = allRooms [roomA].edgeTiles [tileIndexA].tileY - allRooms [roomB].edgeTiles [tileIndexB].tileY;
                            int distanceBetweenRooms = dX * dX + dY * dY;

                            if (distanceBetweenRooms < bestLocalConnection.distance) {
                                bestLocalConnection = new Connection (roomA, tileIndexA, roomB, tileIndexB, distanceBetweenRooms);
                            }
                        }
                    }

                    connectionCache.Add (key, bestLocalConnection);
                }

                if (bestLocalConnection.distance < bestConnection.distance) {
                    bestConnection = bestLocalConnection;
                }

            }
        }
        connections.Add (bestConnection);
        visitedRooms.Add (bestConnection.roomIndexB);
        unvisitedRooms.Remove (bestConnection.roomIndexB);
    }


    // Create passages
    foreach (Connection connection in connections) {
        Coord tileA = allRooms [connection.roomIndexA].edgeTiles [connection.tileA];
        Coord tileB = allRooms [connection.roomIndexB].edgeTiles [connection.tileB];
        CreatePassage (allRooms [connection.roomIndexA], allRooms [connection.roomIndexB], tileA, tileB);
    }

}

struct Connection {
    public int roomIndexA;
    public int tileA;
    public int roomIndexB;
    public int tileB;
    public int distance;

    public Connection (int roomIndexA, int tileA, int roomIndexB, int tileB, int distance)
    {
        this.roomIndexA = roomIndexA;
        this.tileA = tileA;
        this.roomIndexB = roomIndexB;
        this.tileB = tileB;
        this.distance = distance;
    }
}