算法之美-java图的表示(邻接矩阵、邻接表、有向、无向图)

算法之美-java图的表示(邻接矩阵、邻接表、有向、无向图)

图是用来表示结点之间相互连接的一种状态,无向图是一种特殊的有向图。

所以无论是邻接矩阵还是邻接表都可以用来表示有向或者无向图。

一般情况下直接告诉你那个节点是互相连接的问题相对比较简单的,而给出一个二维矩阵的时候需要根据条件进行判断了,并不一定上下左右相邻的节点就是相互连接的节点。

一般有些时候会很明确的告诉你哪些点是连接在一起的,比如下面的例子:

7 12
1 2
6 1
3 1
2 3
2 4
2 5
2 7
3 4
4 5
5 6
5 7
6 7

直接告诉你1和2、6和1是互相连接的了

 

而在二维矩阵中,告诉你移动的规则,需要进一步的加工来确定节点间有无连接

只能向右或向下移动,经过1最多的路线。向右向下表示下边的和右边的节点与本身节点是相连的。

6
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
1 1 0 0 0 0
1 0 1 0 0 0 
1 0 0 1 0 0 

只能向左或向右移动矩阵中值的步数,到右下角经过的最小的路线

4
1 2 0 3
1 3 2 1
2 3 2 3
1 2 1 1 

只能由高的数字往低的数字移动,经过的最长路线,表示上下左右数字低的节点与自己是相连的

4 4
7 8 9 10
6 15 16 11
5 14 13 12
4 3 2 1

当然了,矩阵也可以是无向图

比如下面计算有几个区块,表示上下左右只要是1的就与自己相连了。

4 5
1 1 0 1 0
1 0 1 0 1
0 1 0 1 0
1 0 0 1 1

 

经典案例:

广度优先下的邻接表的使用

需要把要遍历的点放入队列中

只能从高的数字往低的数字移动,计算可以移动的最大距离

 4 4
 7 8 9 10
 6 15 16 11
 5 14 13 12
 4 3 2 1

需要把二维数组转为一维数组,从上下左右的相对位置来查看点与点之间哪些是直接连接的

import java.util.ArrayList;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;

public class Test{
	static List<LinkedList<Integer>> totallist;
	static int[][] Map;
	static boolean[] visited;
	static int MaxCount;
	static int Count;
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int R = scanner.nextInt();
		int C = scanner.nextInt();
		totallist = new ArrayList<LinkedList<Integer>>();
		Map = new int[R][C];
		for(int i=0;i<R;i++) {
			for(int j=0;j<C;j++) {
				totallist.add(new LinkedList<Integer>());
				Map[i][j] = scanner.nextInt();
			}
		}
		for(int i=0;i<R;i++) {
			for(int j=0;j<C;j++) {
				if(i-1>=0&&Map[i][j]-Map[i-1][j]>0) {
					totallist.get(i*C+j).add((i-1)*C+j);
				}
				if(i+1<R&&Map[i][j]-Map[i+1][j]>0) {
					totallist.get(i*C+j).add((i+1)*C+j);
				}
				if(j-1>=0&&Map[i][j]-Map[i][j-1]>0) {
					totallist.get(i*C+j).add(i*C+j-1);
				}
				if(j+1<C&&Map[i][j]-Map[i][j+1]>0) {
					totallist.get(i*C+j).add(i*C+j+1);
				}
			}
		}
		MaxCount=0;
		for(int i=0;i<totallist.size();i++) {
			Count = 0;
			visited = new boolean[R*C];
			Queue<Integer> queue = new LinkedList<Integer>();
			queue.add(i);
			visited[i] = true;
			while(!queue.isEmpty()) {
				Integer top = queue.poll();
				for(Integer item:totallist.get(top)) {
					if(!visited[item]) {
						Count++;
						visited[item] = true;
						queue.add(item);
					}
				}
			}
			MaxCount = MaxCount>Count?MaxCount:Count;
		}
		System.out.println(MaxCount);
		
	}
}

输出:

 

广度优先下的邻接矩阵

统计区块的个数(相邻的结点统计数要除2然后四舍五入)

4 5
1 1 0 1 0
1 0 1 0 1
0 1 0 1 0 
1 0 0 1 1

通过上下左右就可以判断哪些节点是直接连接的

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Test{
static int R;
static int C;
static int[][] Map;
static boolean[][] visited;
static int count;
public static void main(String[] args) {
	Scanner scanner = new Scanner(System.in);
	R = scanner.nextInt();
	C = scanner.nextInt();
	Map = new int[R][C];
	visited = new boolean[R][C];
	for(int i=0;i<R;i++) {
		for(int j=0;j<C;j++) {
			Map[i][j] = scanner.nextInt();
		}
	}
	Queue<Integer[]> queue = new LinkedList<Integer[]>();
	int totalCount = 0;
	for(int i=0;i<R;i++) {
		for(int j=0;j<C;j++) {
			count = 0;
			float sum = 0;
			if(Map[i][j]==1&&(!visited[i][j])) {
				visited[i][j] = true;
				count++;
				queue.add(new Integer[] {i,j});
				while(!queue.isEmpty()) {
					Integer[] tops = queue.poll();
					int m = tops[0];
					int n = tops[1];
					if(m<R-1) {//只有右边和下边的,因为从上面来的,说明上面已经visitied了,不会再次访问
						if(Map[i+1][j]==1&&(!visited[i+1][j])) {
							visited[i+1][j] = true;
							count++;
							queue.add(new Integer[] {i+1,j});
						}
					}
					if(n<C-1) {
						if(Map[i][j+1]==1&&(!visited[i][j+1])) {
							visited[i][j+1] = true;
							count++;
							queue.add(new Integer[] {i,j+1});
						}
					}
				}
				sum+=count;
				totalCount+=Math.round(sum/2);
			}
		}
	}
	System.out.println(totalCount);
}
}

 

邻接矩阵下的深度与广度

深度优先

示例:只能向右或者往下走,可以经过最多1的个数

可以传入参数

6
0 0 0 0 0 0
0 0 1 0 0 0
0 0 0 1 0 0
1 1 0 0 0 0
1 1 1 1 0 0
1 1 1 0 0 0
public class DGraph {
    static int[][] Map;
    static boolean[] visited;
    static int MaxCount;
    static int Count;
    static int N;
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		 N = sc.nextInt();//点的个数
		 Map = new int[N][N];
		 visited = new boolean[N*N];
		 for(int i=0;i<N;i++) {
			 for(int j=0;j<N;j++) {
				 int num = sc.nextInt();
				 Map[i][j] = num;
			 }
		 }
		 
		 
		 MaxCount = 0;
		 for(int i =0;i<N;i++) {
			 for(int j =0;j<N;j++) {
				 int sum = Map[i][j];
				 DFS(i,j,sum);
			 }
		 }
		
		 System.out.println(MaxCount);
		
	}
	private static void DFS(int i,int j,int sum) {
		// TODO Auto-generated method stub
		if(i==N-1&&j==N-1) {
			MaxCount = MaxCount<sum?sum:MaxCount;
			return;
		}
		if(i<N-1) {
			DFS(i+1,j, sum+Map[i+1][j]);
		}
		if(j<N-1) {
			DFS(i,j+1, sum+Map[i][j+1]);
		}
	}

}

输出:

广度优先

不用加visited,因为图中的一个点只有可能是从左边或者上边过来的,所以要判断一下从左边过来的大还是从上边过来的大。

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Test {
	static int[][] Map;
	static boolean[][] visited;

	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		Map = new int[N][N];
		visited = new boolean[N][N];

		for (int i = 0; i < N; i++) {
			for (int j = 0; j < N; j++) {
				Map[i][j] = scanner.nextInt();
			}
		}
		int[][] result = new int[N][N];
		int answer = 0;
		Queue<int[]> queue = new LinkedList<int[]>();
		int sum = Map[0][0];
		queue.add(new int[] { 0, 0, sum });
		visited[0][0] = true;
        int startNum = Map[0][0];
        result[0][0] = startNum;
		while (!queue.isEmpty()) {
			int[] top = queue.poll();
			int x = top[0];
			int y = top[1];
			int total = top[2];
			answer = answer > total ? answer : total;
			if (x == N - 1 && y == N - 1) {
				answer = total;
				break;
			}
			if (x < N - 1) {
				result[x + 1][y] = result[x + 1][y]<result[x][y] + Map[x + 1][y]?result[x][y] + Map[x + 1][y]:result[x + 1][y];
				queue.add(new int[] { x + 1, y, result[x + 1][y] });
			}
			if (y < N - 1) {
				result[x][y + 1] = result[x][y+ 1]<result[x][y] + Map[x][y + 1]?result[x][y] + Map[x][y + 1]:result[x][y+ 1];
				queue.add(new int[] { x, y + 1, result[x][y + 1] });

			}
		}
		System.out.println(result[N - 1][N - 1]);
	}

}

输出:

5

 

邻接矩阵下的广度优先

只能往下或者往右进行移动,移动最大的步数为格子中的数值(可以只移动一步或者最大步数),移动到0不能移动,移动过程中不能换方向(不能往右移动一个格子后再往下移动一格格子),移动到右下角最少的次数。

测试用例

4
1 2 0 3
1 3 2 1
2 3 2 3
1 2 1 1

5
2 0 2 0 0
1 2 1 2 2 
1 2 1 0 0
2 1 0 0 1
0 1 1 0 2

只能向右或向下问题

需要加visited,因为题目的条件往右走之后,就不能往下走了,所以在进入队列的时候就要进行visited了,进入的队列以后一定会访问遍历的。

public class Test{
	static int[][] Map;
	static int[][] result;
	static int N;
	static boolean[][] visited;
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		Map = new int[N][N];
		result = new int[N][N];
		visited = new boolean[N][N];
		for(int i =0;i<N;i++) {
			for(int j =0;j<N;j++) {
				Map[i][j] =  scanner.nextInt();
			}
		}
		Queue<int[]> queue = new LinkedList<int[]>();
		queue.add(new int[] {0,0});
		visited[0][0] = true;
		while(!queue.isEmpty()) {
			int[] top = queue.poll();
			int startIndex = top[0];
			int endIndex = top[1];
			if(startIndex==N-1&&endIndex==N-1) {
				break;
			}
			if(Map[startIndex][endIndex]!=0) {
				for(int i=1;i<=Map[startIndex][endIndex];i++) {
					if(startIndex+i<N&&!visited[startIndex+i][endIndex]) {
						result[startIndex+i][endIndex] = result[startIndex][endIndex]+1;
						visited[startIndex+i][endIndex]  = true;
						queue.add(new int[] {startIndex+i,endIndex});
					}
					if(endIndex+i<N&&!visited[startIndex][endIndex+i]) {
						result[startIndex][endIndex+i] = result[startIndex][endIndex]+1;
						visited[startIndex][endIndex+i]  = true;
						queue.add(new int[] {startIndex,endIndex+i});
					}
				}
			}
		}
		System.out.println(result[N-1][N-1]);
	}
}

输出:

3

输出:

6

 

案例

只能向右或者向下移动,从最上面到右下角,需要通过最短的路径获得最多的值,右-1的格子不能走。

不需要加visited,因为要判断收获最多的值,有可能从上面或者左边过来的。

测试用例

5 5
0 0 0 1 0
0 1 -1 0 0
1 0 0 2 2
1 1 0 0 -1
0 0 1 0 0

邻接矩阵下的广度优先

public class Test{
	static int[][] Map;
	static int[][] result;
	static int N;
	static int M;
	static boolean[][] visited;
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int N = scanner.nextInt();
		int M = scanner.nextInt();
		Map = new int[N][M];
		result = new int[N][M];
		visited = new boolean[N][M];
		for(int i =0;i<N;i++) {
			for(int j =0;j<M;j++) {
				Map[i][j] =  scanner.nextInt();
			}
		}
		Queue<int[]> queue = new LinkedList<int[]>();
		queue.add(new int[] {0,0});
		visited[0][0] = true;
		int startNum = Map[0][0];
		result[0][0] = startNum;
		while(!queue.isEmpty()) {
			int[] top = queue.poll();
			int startIndex = top[0];
			int endIndex = top[1];
			if(startIndex==N-1&&endIndex==N-1) {
				break;
			}
			if(Map[startIndex][endIndex]!=-1) {
				if(startIndex+1<N) {
					result[startIndex+1][endIndex] = result[startIndex+1][endIndex]<result[startIndex][endIndex]+Map[startIndex+1][endIndex]?result[startIndex][endIndex]+Map[startIndex+1][endIndex]:result[startIndex+1][endIndex];
					visited[startIndex+1][endIndex]  = true;
					queue.add(new int[] {startIndex+1,endIndex});
				}
				if(endIndex+1<N) {
					result[startIndex][endIndex+1] = result[startIndex][endIndex+1]<result[startIndex][endIndex]+Map[startIndex][endIndex+1]?result[startIndex][endIndex]+Map[startIndex][endIndex+1]:result[startIndex][endIndex+1];
					visited[startIndex][endIndex+1]  = true;
					queue.add(new int[] {startIndex,endIndex+1});
				}
			}
		}
		System.out.println(result[N-1][M-1]);
	}
}

输出:4

 

 

 

 

 

 

 

 

©️2020 CSDN 皮肤主题: 编程工作室 设计师:CSDN官方博客 返回首页