BFS、DFS——求最短通路值

题目：

用一个整形矩阵matirx表示一个网络，1代表有路，0代表无路，每一个位置只要不越界，都有上下左右四个方向，求从左上角到右下角的最短通路值。

例如，matrix为：

                   1   0    1   1   1

                   1   0    1   0   1

                   1   1    1   0   1

                   0   0    0   0   1

通路只有一条，由12个1构成，所以返回12。

 

BFS，直接使用标记是否走过的矩阵flag来记录当前的时间戳。

 

import java.util.*;
public class TestClass {
    public static void main(String args[]) {
	  TestClass test=new TestClass();
        int[][] matrix={{1,0,1,1,1},{1,0,1,0,1},{1,1,1,0,1},{0,0,0,0,1}};
			System.out.println(""+test.minPathValue(matrix));
    }
    public int minPathValue(int[][] matrix)
    {
    	if(matrix == null||matrix.length == 0||matrix[0].length == 0||matrix[0][0] == 0||matrix[matrix.length-1][matrix[0].length-1] == 0)
    		//注意matrix[0][0]和matrix[rows-1][cols-1]的条件。
    		return 0;
    	int rows=matrix.length;
    	int cols=matrix[0].length;
    	LinkedList<Pair> list=new LinkedList();//Pair类存放x,y坐标；
    	list.add(new Pair(0,0));
    	int[][] map=new int[rows][cols];//map存放经过matrix[i][j]时的最小值。！！因为只有第一次路过时赋值，最快被赋值，肯定值最小！！
    	map[0][0]=1;
    	while(list.size()!=0)
    	{
    		Pair pair=list.removeFirst();
    		int x=pair.x;
    		int y=pair.y;
    		if(x == rows-1&&y == cols-1)//在保存结点时，对map赋值，所以map[rows-1][cols-1]已经赋过值了。
    		{
    		   return map[rows-1][cols-1];
    		}
    		addPair(list,map[x][y],x-1,y,map,matrix);
    		addPair(list,map[x][y],x+1,y,map,matrix);
    		addPair(list,map[x][y],x,y-1,map,matrix);
    		addPair(list,map[x][y],x,y+1,map,matrix);
    	}
    	return 0;//当队列为空时还没有遍历到最后说明没有通路，返回0.
    }
    //不断从队列弹出一个位置，然后将这个位置上下左右满足条件的值都遍历。
    public void addPair(LinkedList<Pair> list,int pre,int x,int y,int[][] map,int[][] matrix)
    {
    	if(x<0||x>=map.length||y<0||y>=map[0].length||map[x][y]!=0||matrix[x][y] == 0)
    		return;
    	map[x][y]=pre+1;
    	list.add(new Pair(x,y));
    }   
}
class Pair{
	   int x;
	   int y;
	   public Pair(int x,int y)
	   {
		   this.x=x;
		   this.y=y;
	   }
}

DFS：

1.所求目的为从左上角到右下角的最短路径，使用一个时间戳进行标记

2.起始顶点为（0,0）

3.邻接点为上下左右且在矩阵中的点

4.flag标记该路径是否已经走过，且第一次经过肯定是最短路径。

 

 public int DFSfunc(int[][] data){
    	 int rows=data.length;
    	 int cols=data[0].length;
    	 if(data[0][0] == 0||data[rows-1][cols-1] == 0)
    		 return 0;
    	 boolean[][] flag=new boolean[rows][cols];
    	 int[] min={Integer.MAX_VALUE};
    	 dfs(data,rows,cols,0,0,1,flag,min);
    	 return min[0];
     }
   public void dfs(int[][] data,int rows,int cols,int i,int j,int count,boolean[][] flag,int[] min){
	   if(i == rows-1&&j == cols-1){
		   min[0]=Math.min(min[0],count);
		   return;
	   }
	   if(i < 0||i == rows||j < 0||j == cols||data[i][j]!=1||flag[i][j] == true||count >= min[0])
		   return;
	   flag[i][j]=true;
	   dfs(data,rows,cols,i-1,j,count+1,flag,min);
	   dfs(data,rows,cols,i+1,j,count+1,flag,min);
	   dfs(data,rows,cols,i,j-1,count+1,flag,min);
	   dfs(data,rows,cols,i,j+1,count+1,flag,min);
        flag[i][j]=false;
   }