fun shortestReach(n: Int, edges: List<Edge>, s: Int) {

    val graphArray = Array(n) { IntArray(n) { 0 } }
    var visited = Array<Boolean>(n) { false }
    var parent = IntArray(n) { -1 }
    var value = IntArray(n) { Int.MAX_VALUE }
    value[s] = 0

    for (i in 0..edges.count() - 1) {
        val start = edges[i].startVertex
        val end = edges[i].endVertex
        val weight = edges[i].weight

        println("s $start  e $end")

        graphArray[start][end] = weight
        graphArray[end][start] = weight
    }

    for (i in 0..graphArray.count() - 1) {
        for (j in 0..graphArray.count() - 1) {

            print(graphArray[i][j])
        }
        println()
    }

    for (i in 0..n - 1) {
        val U : Int = selectMinVertex(visited, value)
        visited[U] = true
        println("..$U")

        for (j in 0..n - 1) {
            if ( graphArray[U][j] != 0 && visited[j] == false && value[U]!= Int.MAX_VALUE
                && value[U] + graphArray[U][j] < value[j] ) {
                value[j] = value[U] + graphArray[U][j]
                parent[j] = U
            }
        }
    }


    for (i in 0..n - 1) {
        /*   val parent = parent[i]
           if (parent >= 0) {
               println("$parent , i $i")
               val wt = graphArray[parent][i]
               println("u- > v: $parent -> $i  wt= $wt")
           }

         */
        var v = value[i]
        println("$i  v = $v")

    }


}

fun selectMinVertex(visited: Array<Boolean>, value: IntArray): Int {
    var mini = Int.MAX_VALUE
    var vertex: Int = 0

    for (i in 0..visited.count() - 1) {
        if (visited[i] == false && value[i] < mini) {
            vertex = i
            mini = value[i]
        }
    }
    return vertex
}

fun main(args: Array<String>) {
    var edges = mutableListOf<Edge>()
    edges.add(Edge(0, 1, 5))
    edges.add(Edge(0, 2, 7))
    edges.add(Edge(0, 3, 3))
    edges.add(Edge(1, 4, 2))
    edges.add(Edge(1, 5, 10))
    edges.add(Edge(2, 6, 1))
    edges.add(Edge(3, 7, 11))
    edges.add(Edge(4, 7, 9))
    edges.add(Edge(5, 7, 4))

    shortestReach(8, edges, 0)
}
//Soon improve the code and implement it Using  Adjacency List Representation
//in same artical here .