有向图的邻接矩阵结构、拓扑排序、关键路径：

最新推荐文章于 2025-06-30 17:05:59 发布

原创最新推荐文章于 2025-06-30 17:05:59 发布 · 1.7k 阅读

5 ·

CC 4.0 BY-SA版权

这篇博客深入探讨了有向图的数据结构，包括邻接矩阵表示，详细阐述了如何进行拓扑排序，并且讲解了如何计算关键路径中的每个事件的最迟发生时间和最早发生时间。通过示例代码辅助理解，为读者提供清晰的图论概念和算法实现。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

图的构建：：

class  Graph {
	final int  max=32767;
	final int num=100;
	String []s;
	int a[][];
	int vnum,anum;
	public Graph(int vnum, int anum) {
		super();
		this.vnum = vnum;
		this.anum = anum;
		s=new String[vnum];
		a=new int[vnum][vnum];
	}
	public void create() {
		
		Scanner scanner=new Scanner(System.in);
		System.out.println("请输入顶点:");
		for(int i=0;i<vnum;i++)
			s[i]=scanner.next();
		for(int i=0;i<vnum;i++)
			for(int j=0;j<vnum;j++)
				a[i][j]=max;
		System.out.println("请输入边和权值:");
		int k;
		for(k=0;k<anum;k++) {
			int w;
			String s1=null;
			String s2=null;
			s1=scanner.next();
			s2=scanner.next();
			w=scanner.nextInt();
			
			int c=0,d = 0;
			for(int t=0;t<vnum;t++) {
				if(s[t].equals(s1)) {
					c=t;
				}
				if(s[t].equals(s2))
					d=t;
			}
			a[c][d]=w;
			if(k<anum-1)
			System.out.println("请输入边:");
		}
	}
	
}

测试代码：

import java.util.*;
public class AMGraph {

	public static void main(String[] args) {
		Graph g=new Graph(9,11);
		g.create();
		for(int i=0;i<g.vnum;i++) {
			for(int j=0;j<g.vnum;j++) {
				//if(g.a[i][j]!=32767)
				System.out.print(g.a[i][j]+"    ");
			}
			System.out.println();
		}
		criticalPath(g);
		
//		String[] s=topological(g);
//		System.out.println(Arrays.toString(s));
		
//		int e[]=early(g);
//		System.err.println(Arrays.toString(e));
//		
		
		}

关键路径：

	public static void  criticalPath(Graph g) {
	int []ve=early(g);
	int []vl=late(g);
	System.out.println(Arrays.toString(ve));
	System.out.println(Arrays.toString(vl));
	for(int i=0;i<g.vnum;i++) {
		for(int j=0;j<g.vnum;j++) {
			if(g.a[i][j]!=32767) {
				if(ve[i]==vl[j]-g.a[i][j]) {
					System.out.println("v"+i+" "+"v"+j);
				}
			}
		}
	}
	}

每个事件的最迟发生时间：

	public static  int [] late(Graph g) {
		int vl[]=new int[g.vnum];
		String []s=topological(g);
		int n=g.vnum;
		for(int i=0;i<vl.length;i++)
			vl[i]=early(g)[n-1];
		String str=null;
		for(int i=n-1;i>=0;i--) {
			str=s[i].substring(1);
			int k=Integer.valueOf(str);
			for(int j=0;j<n;j++) {
				if(g.a[j][k]!=32767) {
					if(vl[j]>vl[i]-g.a[j][k]) {
						vl[j]=vl[i]-g.a[j][k];
					}
				}
			}
		}
		return vl; 
	}

求每个事件的最早发生时间：

	public static int[] early(Graph g) {
		int[]ve=new int[g.vnum];
		String[] s=topological(g);
		for(int i=0;i<g.vnum;i++)
			ve[i]=0;
		String str=null;
		for(int i=0;i<g.vnum;i++) {
			str=s[i].substring(1);
			int k=Integer.valueOf(str);
			for(int j=0;j<g.vnum;j++) {
				if(g.a[k][j]!=32767) {
					if(ve[j]<ve[k]+g.a[k][j])
					{ve[j]=ve[k]+g.a[k][j];}
				//	System.out.println(e[j]);
				}
			}
		}
		return ve;
	}

拓扑排序：

	public static String[] topological(Graph g) {
		 int []r=new int[g.vnum];
	 String []str=new String[g.vnum];
	 int [][]a1=new int[g.vnum][g.vnum];
	 for(int i=0;i<g.vnum;i++) {
		 for(int j=0;j<g.vnum;j++) {
			 a1[i][j]=g.a[i][j];
		 }	 
	 }
	 for(int i=0;i<g.vnum;i++) {
		 int k=0;
		 for(int j=0;j<g.vnum;j++) {
			 if(a1[j][i]<32767) {
				 k++;
			 }
		 }	 
		 r[i]=k;
	 }
	 String s1;
	Stack s=new Stack();
	 int n=0;
	 while(n<g.vnum) {
	   for(int i=0;i<g.vnum;i++) {
		 if(r[i]==0) {
			 s1="v"+i;
			 int v=Integer.valueOf(i);
			 str[n++]=s1;
			 s.push(v);
		 }
	 }
	 while(!s.isEmpty()) {
		int  x=(int) s.pop();
		r[x]=1;
		 for(int i=0;i<g.vnum;i++)
			 if(g.a[x][i]<32767)
				 r[i]--;
	 }
	 }	
	
	 
	 
	 return str;
 }
}