图之单源Dijkstra算法、带负权值最短路径算法

1、图类基本组成

存储在邻接表中的基本项

/**
 * Represents an edge in the graph
 * 
 */
class Edge implements Comparable<Edge> {
    public Vertex dest;　　//Second vertex in Edge
    public double cost;　　//Edge cost

    public Edge(Vertex d, double c) {
        dest = d;
        cost = c;
    }

    @Override
    public int compareTo(Edge o) {
        double otherCost = o.cost;
        return cost < otherCost ? -1 : cost > otherCost ? 1 : 0;
    }

    @Override
    public String toString() {
        return "Edge{" + "dest=" + dest + ", cost=" + cost + '}';
    }
}

存储每个顶点信息

/**
 * Represents a vertex in the graph
 */
class Vertex {
    public String name;
    public List<Edge> adj;//Adjacent vertices
    public double dist;
    public Vertex prev;
    public int scratch;//Extra variable used in algorithm

    public Vertex(String name) {
        this.name = name;
        adj = new LinkedList<Edge>();
        reset();
    }

    public void reset() {
        dist = Graph.INFINITY;
        prev = null;
        scratch = 0;
    }

    @Override
    public String toString() {
        return "Vertex{" + "name='" + name + '\'' + ", prev=" + prev + ", adj=" + adj + ", dist=" + dist + '}';
    }
}

图类的框架

import java.util.*;

/**
 * Created by Vanguard on 2017/4/6.
 */
public class Graph {
    public static final double INFINITY = Double.MAX_VALUE;
    private Map<String, Vertex> vertexMap = new HashMap<String, Vertex>();

    public void addEdge(String sourceName, String destName, double cost) {
        Vertex v = getVertex(sourceName);
        Vertex w = getVertex(destName);
        v.adj.add(new Edge(w, cost));
    }

    /**
     * 通过查询图的表，打印最短路径
     *
     * @param destName
     */
    public void printPath(String destName) {
        Vertex w = vertexMap.get(destName);
        if (w == null) {
            System.out.println("NoSuchElementException");
            return;
        } else if (w.dist == INFINITY) {
            System.out.println(destName + " is unreachable.");
        } else {
            System.out.print("(Cost is: " + w.dist + ") ");
            printPath(w);
            System.out.println();
        }
    }

    private void printPath(Vertex dest) {
        if (dest.prev != null) {
            printPath(dest.prev);
            System.out.print(" --> ");
        }
        System.out.print(dest.name);
    }


    private Vertex getVertex(String vertexName) {
        Vertex v = vertexMap.get(vertexName);
        if (v == null) {    //create if not exist.
            v = new Vertex(vertexName);
            vertexMap.put(vertexName, v);
        }
        return v;
    }

    private void clearAll() {
        for (Vertex v : vertexMap.values()) {
            v.reset();
        }
    }
}

 

2、最短路径算法

广度优先搜索

/**
 * Single-source unweighted shortest-path algorithm.
 * 无权单源最短路径算法——广度优先搜索
 *
 * @param startName
 */
public void unweighted(String startName) {
    clearAll();
    Vertex start = vertexMap.get(startName);
    if (start == null) {
        throw new NoSuchElementException("Start vertex not fond.");
    }
    Queue<Vertex> q = new LinkedList<Vertex>();
    q.add(start);
    start.dist = 0;
    while (!q.isEmpty()) {
        Vertex v = q.remove();
        for (Edge e : v.adj) {
            Vertex w = e.dest;
            if (w.dist == INFINITY) {
                w.dist = v.dist + 1;
                w.prev = v;
                q.add(w);
            }
        }
    }
}

 

Dijstra算法

/**
 * Single-source unweighted shortest-path algorithm.
 * 无权单源最短路径算法——广度优先搜索
 *
 * @param startName
 */
public void unweighted(String startName) {
    clearAll();
    Vertex start = vertexMap.get(startName);
    if (start == null) {
        throw new NoSuchElementException("Start vertex not fond.");
    }
    Queue<Vertex> q = new LinkedList<Vertex>();
    q.add(start);
    start.dist = 0;
    while (!q.isEmpty()) {
        Vertex v = q.remove();
        for (Edge e : v.adj) {
            Vertex w = e.dest;
            if (w.dist == INFINITY) {
                w.dist = v.dist + 1;
                w.prev = v;
                q.add(w);
            }
        }
    }
}

 

带负权值得最短路径算法

/**
 * Single-source negative-weighted shortest-path algorithm.
 * 带负权值得最短路径算法
 *
 * @param startName
 */
public void negative(String startName) {
    clearAll();

    Vertex start = vertexMap.get(startName);
    if (start == null) {
        throw new NoSuchElementException("Start vertex not fond.");
    }
    Queue<Vertex> q = new LinkedList<>();
    q.add(start);
    start.dist = 0;
    start.scratch++;
    while (!q.isEmpty()) {
        Vertex v = q.remove();
        if (v.scratch++ > 2 * vertexMap.size()) {
            System.out.println("Negative cycle detected.");
        }
        for (Edge e : v.adj) {
            Vertex w = e.dest;
            double costvw = e.cost;
            if (w.dist > v.dist + costvw) {
                w.dist = v.dist + costvw;
                w.prev = v;
                //Enqueue only if not already on the queue
                if (w.scratch++ % 2 == 0)
                    q.add(w);
                else
                    w.scratch--;
            }
        }

    }
}

 

 

 

 

 

 

 

 

THE END.