最短路径算法

最短路径算法

Dijkstra

algorithm description

1. Select a source, and initialize the distance of other nodes to the source and finished as false
2. Find the minimum distance from dis[] and the node must be not finished
3. Update all the dis[] based on the current selected node
4. Repeat until all the nodes are finished.

time complexity: O(|V|²)

void dijkstra(int[][] graph, int source)
    {
        int[] distance = new int[V];
        Boolean[] finished = new Boolean[V];
        for (int i = 0; i < V; i++)
        {
            distance[i] = Integer.MAX_VALUE;
            finished[i] = false;
        }
        distance[source] = 0;
        //v-1个node
        for (int count = 0; count < V-1; count++)
        {
            int u = minDistance(distance, finished);
            finished[u] = true;
            for (int v = 0; v < V; v++)
                if (!finished[v] && graph[u][v]!=0 &&
                        distance[u] != Integer.MAX_VALUE &&
                        distance[u]+graph[u][v] < distance[v])
                    distance[v] = distance[u] + graph[u][v];
        }
    }
    int minDistance(int[] distance, Boolean[] finished)
    {
        int min = Integer.MAX_VALUE, min_index=-1;
        for (int v = 0; v < V; v++) {
            if (!finished[v] && distance[v] <= min) {
                min = distance[v];
                min_index = v;
            }
        }
        return min_index;
    }

However, Dijkstra cannot sovle graph with negative weight.

Flyod

 Floyd–Warshall algorithm is an algorithm based on Dynamic Programming for finding shortest paths in a weighted graph with both positive and negative edge weights.

The Floyd–Warshall algorithm compares all possible paths through the graph between each pair of vertices.

Find shortest possible path from i to j using vertices only from the set {1, 2, ..., k} as intermediate points along the way.

time complexity: O(|V|³)

core code is pretty simple

for (int k = 0; k < n; ++k)
            for (int i = 0; i < n; ++i)
                for (int j = 0; j < n; ++j) {
                    if(A[i][j]>A[i][k]+A[j][k]){
                        A[i][j]=A[i][k]+A[j][k];
                        path[i][j]=k;
                    }
                }

 But Floyd still cannot solve problems with negative cycles.