算法导论-java实现-单源最短路径DAG算法BellmanFord算法

package graph;

class MEdge {
 public int u;
 public int v;
 public int w;

 public MEdge(int u, int v, int w) {
  this.u = u;
  this.v = v;
  this.w = w;
 }
}

public class SingleSourceShortest {
 public static void main(String args[]) {
  MEdge[] E = new MEdge[10];
  E[0] = new MEdge(0, 1, 3);
  E[1] = new MEdge(0, 4, 5);
  E[2] = new MEdge(1, 4, 2);
  E[3] = new MEdge(4, 1, 1);
  E[4] = new MEdge(3, 0, 3);
  E[5] = new MEdge(4, 2, 4);
  E[6] = new MEdge(1, 2, 6);
  E[7] = new MEdge(2, 3, 2);
  E[8] = new MEdge(3, 2, 7);
  E[9] = new MEdge(4, 3, 6);
  new SingleSourceShortest(5, E);
 }

 private int[] d;
 private int[] pi;
 private int[] f;
 private int[] sequence;
 private int[] color;// 0,1,2
 private int infinite;
 private int s;
 private int num;
 private MEdge[] E;
 private int time;

 public SingleSourceShortest(int num, MEdge[] E) {
  this.time = 0;
  this.num = num;
  this.d = new int[num];
  this.pi = new int[num];
  this.f = new int[num];
  this.color = new int[num];
  this.sequence = new int[num];
  this.infinite = 1000;
  this.s = 0;
  this.E = E;
  if (bellmanFord()) {
   print();
  }
  /*if (dagShortest()) {
   print();
  }*/
 }

 public boolean dagShortest() {
  initializeSingleSource(s);
  this.time = 0;
  dfs(s);
  /*
   * for (int i = 0; i < f.length; i++) { System.out.println(f[i]); }
   */
  for (int i = num; i >= 1; i--) {
   for (int j = 1; j < i; j++) {
    if (f[j] > f[j - 1]) {
     int temp;
     temp = sequence[j];
     sequence[j] = sequence[j - 1];
     sequence[j - 1] = temp;
     // temp=f[j];
     // f[j]=f[j-1];
     // f[j-1]=temp;
    }
   }
  }
  // for(int i=0;i<num;i++){
  // System.out.println(f[i]+"  "+sequence[i]);
  // }
  int uu;
  for (int i = 0; i < num; i++) {
   uu = sequence[i];
   // System.out.println(uu);
   for (int j = 0; j < num; j++) {
    if (E[j].u == uu) {
     System.out.println("松弛" + E[j].u + " " + E[j].v + " "
       + E[j].w);
     relax(E[j].u, E[j].v, E[j].w);
    }
   }
  }
  return true;
 }

 public void dfs(int s) {
  color[s] = 1;
  time++;
  for (int i = 0; i < E.length; i++) {
   if (E[i].u == s) {
    if (color[E[i].v] == 0) {
     // System.out.println(E[i].v);
     dfs(E[i].v);
    }
   }
  }
  time++;
  f[s] = time;
  color[s] = 2;
 }

 public void print() {
  int index = s + 1;
  int temp;
  for (int i = 1; i < num; i++) {
   System.out.print("从" + s + "到" + index + "的最短路径是:" + index);
   temp = pi[index];
   while (temp != -1) {
    System.out.print("<-" + temp);
    temp = pi[temp];
   }
   System.out.println("*****权值为:" + d[index]);
   index = (index + 1) % num;
  }
 }

 public boolean bellmanFord() {
  initializeSingleSource(s);
  for (int i = 1; i < num; i++) {
   for (int j = 0; j < E.length; j++) {
    relax(E[j].u, E[j].v, E[j].w);
   }
  }
  for (int i = 0; i < E.length; i++) {
   if (d[E[i].v] > d[E[i].u] + E[i].w)
    return false;
  }
  return true;
 }

 public void initializeSingleSource(int s) {
  for (int i = 0; i < d.length; i++) {
   d[i] = infinite;
   pi[i] = -1;
   color[i] = 0;
   f[i] = -1;
   sequence[i] = i;
  }
  d[s] = 0;
 }

 public void relax(int u, int v, int w) {
  if (d[v] > d[u] + w) {
   d[v] = d[u] + w;
   pi[v] = u;
  }
 }
}