第9章 图论算法

拓扑排序是对有向无圈图的顶点的一种排序，使得如果存在一条从Vi到Vj的路径，那么在排序中Vj就出现在Vi的后面。

一个简单的求拓扑排序的算法是先找出任意一个没有入边的顶点。然后显示出该顶点，并将它及其边一起从图中删除。然后，我们对图的其余部分同样应用这样的方法处理。 

简单拓扑排序的伪代码

    /**
     * void topsort() throws CycleFoundException
     * {
     *     for(int counter = 0; counter < NUM_VERTICES; counter++)
     *     {
     *         Vertex v = findNewVertexOfIndegreeZero();
     *         if(v = null)
     *              throw new CycleFoundException();
     *         v.topNum = counter;
     *         for each Vertex w adjacent to v
     *              w.indegree--;
     *     }
     * }
     */

入度的计算由下面的代码实现，同理可见此计算的花销也是O(|E| + |V|)，虽然其中有嵌套的循环。

    /**
     * for each Vertex v
     *      v.indegree = 0;
     *
     * for each Vertex v
     *      for each Vertex w adjacent to v
     *          w.indegree++;
     */

我们可以通过将所有（未分配拓扑编号）的入度为0的顶点放在一个特殊的盒子中而消除这种无效的劳动。此时findNewVertexOfIndegreeZero方法返回（并删除）的是该盒子中的任一项点。当我们降低它的邻接顶点的入度时，检查每一个顶点并在它的入度降为0时把它放入盒子中。

为实现这个盒子，我们可以使用一个栈或一个队列。首先，对每个顶点计算它的入度。然后，将所有入度为0的顶点放入一个初始为空的队列中。当队列不空时，删除一个顶点v，并将v邻接的所有顶点的入度均减1。只要一个顶点的入度降为0，就把该顶点放入队列中。此时，拓扑排序就是顶点出队的顺序。

    /**
     * void topsort() throws CycleFoundException
     * {
     *     Queue<Vertex> q = new Queue<Vertex>( );
     *     int count = 0;
     *     
     *     for each Vertex v
     *          if(v.indegree == 0)
     *                  q.enqueue(v);
     *                  
     *     while(!q.isEmpty( ))
     *     {
     *         Vertex v = q.dequeue();l
     *         v.topNum = ++counter;
     *         
     *         for each Vertex w adjacent to v
     *              if(--w.indegree == 0)
     *                      q.enqueue(w);
     *     }
     *     if(counter != NUM_VERTICES)
     *          throw new CycleFoundException;
     * }
     */

广度优先搜索

无权最短路径算法的伪代码1

    /**
     * void unweighted(Vertex s)
     * {
     *     for each Vertex v
     *     {
     *         v.dist = INFINITY;
     *         v.known = false;
     *     }
     *
     *     s.dist = 0;
     *
     *     for(int currDist = 0; currDist < NUM_VERTICES; currDist++)
     *          for each Vertex x
     *              if(!v.known && v.dist == currDist)
     *              {
     *                  v.known = true;
     *                  for each Vertex w adjacent to v
     *                      if(w.dist == INFINITY)
     *                      {
     *                          w.dist = currDist + 1;
     *                          w.path = x;
     *                      }
     *              }
     * }
     */

无权最短路径算法的伪代码2

在迭代开始的时候，队列只含有距离为currDist的那些顶点。当添加距离为currDist + 1的那些邻接顶点时，由于它们自队尾入队，因此这就保证它们直到所有距离为currDist的顶点都被处理之后才被处理。在距离currDist处的最后一个顶点出队并被处理之后，队列只含有距离为currDist + 1的顶点，因此该过程将不断进行下去。

    /**
     * void unweighted(Vertex s)
     * {
     *     Queue<Vertex> q = new Queue<Vertex>;
     *
     *     for each Vertex v
     *          v.dist = INFINITY;
     *
     *     s.dist = 0;
     *     q.enqueue(s);
     *
     *     while(!q.isEmpty())
     *     {
     *         Vertex v = q.dequeue();
     *         
     *         for each Vertex w adjacent to v
     *              if(w.dist == INFINITY)
     *              {
     *                  w.dist = v.dist + 1;
     *                  w.path = v;
     *                  q.enqueue(w);
     *              }
     *     }
     * }
     */

使用与对拓扑排序进行同样的分析，我们看到，只要使用邻接表，则运行时间就是O(|E| + |V|)。

Dijkstra算法

Dijkstra算法中的Vertex类

    /**
     * class Vertex
     * {
     *     public List adj;         // Adjacency List
     *     public boolean known;
     *     public DistType dist;    // DistType is probably int
     *     public Vertex path;
     *          // Other fields and methods as needed
     * }
     */

显示实际最短路径的例程

    /**
     * void printPath(Vertex v)
     * {
     *     if(v != null)
     *     {
     *         printPath(v.path)
     *         System.out.print("to");
     *     }
     *     System.out.print(v);
     * }
     */

Dijkstra算法的伪代码

    /**
     * void dijkstra(Vertex s)
     * {
     *     for each Vertex v
     *     {
     *         v.dist = INFINITY;
     *         v.known = false;
     *     }
     *
     *     s.dist = 0;
     *
     *     while(there is an unknown distance vertex)
     *     {
     *         Vertex v = smallest unknown distance vertex;
     *
     *         v.known = true;
     *
     *         for each Vertex w adjacent to v
     *              if(!w.known)
     *              {
     *                  DistType cvw = cost of edge from v to w;
     *
     *                  if(v.dist + cvw < w.dist)
     *                  {
     *                      // Update w
     *                      decrease(w.dist to v.dist + cvw);
     *                      w.path = v;
     *                  }
     *              }
     *     }
     * }
     */

具有负边值的赋权最短路径算法的伪代码

   /**
     * void weightedNegative(Vertex v)
     * {
     *     Queue<Vertex> q = new Queue<Vertex>( );
     *
     *     for each Vertex v
     *          v.dist = INFINITY;
     *
     *     s.dist = 0;
     *     q.enqueue(s);
     *
     *     while(!q.isEmpty())
     *     {
     *         Vertex v = q.dequeue();
     *
     *         for each Vertex w adjacent to v
     *              if(v.dist + cvw < w.dist)
     *              {
     *                  //Update w
     *                  w.dist = v.dist + cvw;
     *                  w.path = v;
     *                  if(w is not already in q)
     *                      q.enqueue(w);
     *              }
     *     }
     * }
     */

事件节点图

为了找出方案的最早完成时间，我们只要找出从第一个事件到最后一个事件的最长路径的长。

借助顶点的拓扑顺序计算它们的最早完成时间，而最晚完成时间则通过倒转它们的拓扑顺序来计算。

事件节点图中每条边的松弛时间代表对应动作可以被延迟而又不至于推迟整体的完成的时间量。

松弛时间 = 最晚完成时间 - 最早完成时间。

某些动作的松弛时间为零，这些动作是关键性的动作，它们必须按计划结束。至少存在一种完全由零-松弛边组成的路径，这样的路径是关键路径

最短路径，求词梯的Java例程

第一个例程是findChain，它利用Map表示邻接表和两个要被连接的单词，同时返回一个Map，在该Map中，关键字是单词，而相应的值是位于从first开始的最短词梯上的关键字前面的那个单词。

getChainFromPreviousMap使用prev Map和second，它是Map中的一个关键字并返回用于形成词梯的那些单词，通过prev向后工作。通过使用LinkedList并在前头插入，我们得到以正确顺序排列的词梯。

    public static List<String>
    findChain(Map<String, List<String>>adjacentWords, String first, String second)
    {
        Map<String, String> previousWord = new HashMap<>();
        LinkedList<String> q = new LinkedList<>();

        q.addLast(first);
        while (!q.isEmpty())
        {
            String current = q.removeFirst();
            List<String> adj = adjacentWords.get(current);

            if (adj != null)
                for (String adjWord : adj)
                    if (previousWord.get(adjWord) == null)
                    {
                        previousWord.put(adjWord, current);
                        q.addLast(adjWord);
                    }
        }
        previousWord.put(first, null);

        return getChainFromPreviousMap(previousWord, first, second);
    }

    public static List<String> getChainFromPreviousMap(Map<String, String> prev, String first, String second)
    {
        LinkedList<String>result = null;

        if (prev.get(second) != null)
        {
            result = new LinkedList<>();
            for (String str = second; str != null; str = prev.get(str))
                result.addLast(str);
        }
        return result;
    }

9.5.2 Kruskal算法

    /**
     * ArrayList<Edge>kruskal(List<Edge>edges, int numVertices)
     * {
     *     DisjSets ds = new DisjSets(numVertices);
     *     PriorityQueue<Edge>pq = new Priority<edges>;
     *     List<Edge> mst = new ArrayList<>();
     *
     *     while(mst.size() != numVertices - 1)
     *     {
     *         Edge e = pq.deleteMin();
     *         SetType uset = ds.find(e.getu());
     *         SetType vset = ds.dind(e.getv());
     *
     *         if(uset != vset)
     *         {
     *             // Accept the edge
     *             mst.add(e);
     *             ds.union(uset, vset);
     *         }
     *     }
     *     return mst;
     * }
     */

9.6 深度优先搜索模板（伪代码）

    /**
     * void dfs(Vertex v)
     * {
     *     v.visited = true;
     *     for each Vertex w adjacent to v
     *          if(!w.visited)
     *              dfs(w);
     * }
     */

一个连通的无向图如果不存在被删除之后使得剩下的图不再连通的顶点，那么这样的无向连通图就称为是双连通的

对顶点的Num赋值的例程（伪代码）

    /**
     * void assignNum(Vertex v)
     * {
     *     v.num = counter++;
     *     v.visited = true;
     *     for each Vertex w adjacent to v
     *          if(!w.visited)
     *          {
     *              w.parent = v;
     *              assignNum(w);  
     *          }
     * }
     */

计算Low并检验是否割点的伪代码（忽略对根的检验）

    /**
     * // Assign low; also check for articulation points.
     * void assignLow(Vertex v)
     * {
     *     v.low = v.num;
     *     for each Vertex w adjacent to v
     *     {
     *         if(w.num > v.num)
     *         {
     *             assignLow(w);
     *             if(w.low >= v.num)
     *                  System.out.println(v + "is an articulation point");
     *             v.low = min(v.low, w.low);
     *         }
     *         else
     *         if(v.parent != w)
     *             v.low = min(v.low, w.num);
     *     }
     * }
     */

不存在一个遍历必须是先序遍历或后序遍历的法则。在递归调用前和递归调用后都有可能进行处理

在一次深度优先搜索（忽略对根的测试）中对割点的检测（伪代码）

    /**
     * void findArt(Vertex v)
     * {
     *     v.visited = true;
     *     v.low = v.num = counter++;
     *     for each Vertex w adjacent to v
     *     {
     *         if(!w.visited)
     *         {
     *             w.parent = v;
     *             findArt(w);
     *             if(w.low >= v.num)
     *                  System.out.println(v + " is an articulation point");
     *             v.low = min(v.low, w.low);
     *         }
     *         else
     *         if(v.parent != w)
     *              v.low = min(v.low, w.num);
     *     }
     * }
     */

9.49 编写一个程序计算其单字母替换取值为1，而单字母添加或删除取值p > 0的词梯，取值由用户指定。

import java.io.File;
import java.util.ArrayList;
import java.util.Scanner;

public class WordLadder
{
    static int INFINITY = 99999;

    private static class Vertex
    {
        Vertex()
        {
            adj = new ArrayList<>();
            weight = new ArrayList<>();
        }
        public ArrayList<Integer> adj;      // Adjacent list
        public ArrayList<Integer> weight;   // Weight list
        public boolean known;
        public int dist;
        public String name;
        public int path;
    }

    /**
     * Print shortest path to v after dijkstra has run.
     * Assume that the path exists.
     */
    static void printPath(int vIndex, ArrayList<Vertex>V)
    {
        if (vIndex >= 0 && V.get(vIndex).path > -1)
        {
            printPath(V.get(vIndex).path, V);
            System.out.println(" to ");
        }
        System.out.println(V.get(vIndex).name);
    }

    static void dijkstra(int sIndex, int tIndex, ArrayList<Vertex>Vertices)
    {
        int smallestDist;
        int smallestVertex;
        Vertex s, v, t;
        int n = Vertices.size();

        for ( ; ; )
        {
            smallestDist = INFINITY;
            smallestVertex = -1;

            for (int i = 0; i < n; i++)
            {
                if (!Vertices.get(i).known && Vertices.get(i).dist < smallestDist)
                {
                    smallestDist = Vertices.get(i).dist;
                    smallestVertex = i;
                }
            }

            if (smallestVertex < 0 || smallestVertex == tIndex)
                break;

            Vertices.get(smallestVertex).known = true;
            v = Vertices.get(smallestVertex);

            for (int j = 0; j < v.adj.size(); j++)
            {
                if (!(Vertices.get(v.adj.get(j))).known)
                {
                    if (v.dist + v.weight.get(j) < Vertices.get(v.adj.get(j)).dist)
                    {
                        // Update w
                        Vertices.get(v.adj.get(j)).dist = v.dist + v.weight.get(j);
                        Vertices.get(v.adj.get(j)).path = smallestVertex;
                    }
                }
            }
        }
    }

    static ArrayList<Vertex>readWords(Scanner in)
    {
        String oneLine = new String();
        ArrayList<Vertex>v = new ArrayList<>();
        while (in.hasNext())
        {
            oneLine = in.next();
            Vertex w = new Vertex();
            w.name = oneLine;
            w.known = false;
            w.path = -1;
            w.dist = INFINITY;
            v.add(w);
        }
        return v;
    }

    static int oneCharOff(String word1, String word2, int p)
    {
        String big, small, shrink;
        int cost;

        if (Math.abs((int)(word1.length() - word2.length())) > 1)
            return 0;
        else
            if (word1.length() == word2.length())
            {
                int diffs = 0;

                for (int i = 0; i < word1.length(); i++)
                    if (word1.charAt(i) != word2.charAt(i))
                        if (++diffs > 1)
                            return 0;
                if (diffs == 1)
                    return 1;
            }

            if (word2.length() > word1.length())
            {
                big = word2;
                small = word1;
            }
            else
            {
                big = word1;
                small = word2;
            }

            for (int i = 0; i < big.length(); i++)
            {
                shrink = big.substring(0, i) + big.substring(i + 1,big.length());
                if (shrink.compareTo(small) == 0)
                    return p;
            }

            return 0;
    }

    // fills the adjacency lists for all words in the dictionary
    static void fillAdjacencies(ArrayList<Vertex>words, int p)
    {
        int cost;

        for (int i = 0; i < words.size(); i++)
            for (int j = i + 1; j < words.size(); j++)
            {
                cost = oneCharOff(words.get(i).name, words.get(j).name, p);
                if (cost > 0)
                {
                    words.get(i).adj.add(i);
                    words.get(i).weight.add(cost);
                    words.get(j).adj.add(j);
                    words.get(j).weight.add(cost);
                }
            }
    }

    public static void main(String[] args)
    {
        int p = 0;
        int w1Index, w2Index;
        String w1 = new String();
        String w2 = new String();
        Scanner input = new Scanner(System.in);
        Scanner dict;
        try
        {
            dict = new Scanner(new File("dict.txt"));
        }
        catch (Exception e)
        {
            System.out.println("Error opening dictionary file");
            return;
        }

        System.out.println("What is the cost of single char deletions: ");
        p = input.nextInt();

        ArrayList<Vertex>words = readWords(dict);

        do
        {
            System.out.println("Enter two words in the dictionary: ");
            w1 = input.next();
            w2 = input.next();
            // Find their indices(here is where a map would be superior)
            // However all other accesses are now in O(1) time
            for (w1Index = 0; w1Index < words.size() && (words.get(w1Index).name).compareTo(w1) != 0; w1Index++);
            for (w2Index = 0; w2Index < words.size() && (words.get(w2Index).name).compareTo(w2) != 0; w2Index++);
        }while (w1Index >= words.size() || w2Index >= words.size());

        fillAdjacencies(words,p);           // make the adjacency list
        dijkstra(w1Index, w2Index, words);  // use dijkstra's algorithm
        System.out.println();
        printPath(w2Index,words);           // print the result
        System.out.println();
    }
}