刷题小笔记 -- 求拜访路径方案数

---

题目描述

现在有一个城市销售经理，需要从公司出发，去拜访市内的商家，已知他的位置以及商家的位置，但是由于城市道路交通的原因，他只能在左右中选择一个方向，在上下中选择一个方向，现在问他有多少种方案到达商家地址。

给定一个地图map及它的长宽n和m，其中1代表经理位置，2代表商家位置，-1代表不能经过的地区，0代表可以经过的地区，请返回方案数，保证一定存在合法路径。保证矩阵的长宽都小于等于10

题目解析

首先需要找到商家与经理的位置，不一定在矩阵顶点。求路径方案数有多种算法，如动态规划、BFS等。

方法一：BFS

使用广度优先算法，遍历所有合法的路径，计算方案数。
代码

public class Visit {
	// 用Point类表示位置
    static class Point{
        int x;
        int y;
        public Point(){}
        public Point(int x,int y){
            this.x = x;
            this.y = y;
        }
    }
    
    // 计算路径方案数
    public int countPath(int[][] map, int n, int m) {
        Point manager = null;
        Point buss = null;
        // 查找经理和商家的位置
        for(int i = 0;i < n;i++){
            for(int j = 0;j < m;j++){
                if(map[i][j] == 1){
                    manager = new Point(i,j);
                }
                if(map[i][j] == 2){
                    buss = new Point(i,j);
                }
            }
        }
        // 定义方向，第一行表示横坐标，第二行表示纵坐标
        int[][] dir = new int[2][2];
        // 从经理所在位置出发，朝向商家的方向前进
        dir[0][0] = manager.x <= buss.x ? 1 : -1;
        dir[1][1] = manager.y <= buss.y ? 1 : -1;
		// 使用BFS遍历所有路径
        int count = 0;
        // 记录已经访问过的节点，避免循环访问
        boolean[][] visit = new boolean[n][m];
        //队列存储待访问的节点
        Queue<Point> queue = new LinkedList<>();
        queue.offer(manager);
        while(!queue.isEmpty()){
            Point top = queue.poll();
            int x = top.x;
            int y = top.y;
            // 判断是否到达商家位置
            if(top.x == buss.x && top.y == buss.y){
                count++;
                visit[x][y] = true;
                continue;
            }
			//将下一步要访问的节点加到队列中
            for(int i = 0;i < 2;i++){
                int xx = dir[0][i] + x;
                int yy = dir[1][i] + y;
                if(xx >= 0 && xx < n && yy >= 0 && yy < m && map[xx][yy] != -1 && !visit[xx][yy]){
                    queue.offer(new Point(xx,yy));
                }
            }
        }
        return count;
    }
}

方法二：DFS

使用深度优先遍历，查找所有的方案数

public int countPath(int[][] map, int n, int m){
   int[] manager = new int[2];
   int[] buss = new int[2];
   // 查找经理和商家的位置
   for(int i = 0;i < n;i++){
       for(int j = 0;j < m;j++){
           if(map[i][j] == 1){
               manager[0] = i;
               manager[1] = j;
           }
           if(map[i][j] == 2){
               buss[0] = i;
               buss[1] = j;
           }
       }
   }
   // 定义方向，横坐标和纵坐标
   int[] dir = new int[2];
   dir[0] = manager[0] <= buss[0] ? 1 : -1;
   dir[1] = buss[1] <= buss[1] ? 1 : -1;
   return dfs(map,manager[0],manager[1],buss,dir);
}
// 递归实现DFS算法
private int dfs(int[][] map,int x,int y,int[] buss,int[] dir){
	// 达到终点，方案数为1
   if(x == buss[0] && y == buss[1]){
       return 1;
   }
   // 和商家在同一行
   else if(x == buss[0]){
   		// 不能通过，无法抵达
       if(map[x][y] == -1){
           return 0;
       }
       // 前进到下一位置
       return dfs(map,x,y + dir[1],buss,dir);
   }
    // 和商家在同一列
   else if(y == buss[1]){
   		// 不能通过，无法抵达
       if(map[x][y] == -1){
           return 0;
       }
       // 前进到下一位置
       return dfs(map,x + dir[0],y,buss,dir);
   }
   else{
       if(map[x][y] == -1){
           return 0;
       }
       // 结果等于左右前进和上下移动的方案总和
       return dfs(map,x + dir[0],y,buss,dir) + dfs(map,x,y + dir[1],buss,dir);
   }
}

方法三：动态规划

public int countPathDF(int[][] map, int n, int m){
     int[] manager = new int[2];
     int[] buss = new int[2];
     // 查找经理和商家位置
     for(int i = 0;i < n;i++){
         for(int j = 0;j < m;j++){
             if(map[i][j] == 1){
                 manager[0] = i;
                 manager[1] = j;
             }
             if(map[i][j] == 2){
                 buss[0] = i;
                 buss[1] = j;
             }
         }
     }
     // 确定前进方向
     int[] dir = new int[2];
     dir[0] = manager[0] < buss[0] ? 1 : -1;
     dir[1] = buss[1] < buss[1] ? 1 : -1;
     // 动态规划矩阵
     int[][] dp = new int[n][m];
      // 设置边界
     dp[manager[0]][manager[1]] = 1;
     for(int i = manager[0] + dir[0];i != buss[0] + dir[0];i += dir[0]){
         dp[i][manager[1]] = map[i][manager[1]] == -1 ? 0 : dp[i - dir[0]][manager[1]];
     }
     for(int j = manager[1] + dir[1];j != buss[1] + dir[1];j += dir[1]){
         dp[manager[0]][j] = map[manager[0]][j] == -1 ? 0 : dp[manager[0]][j - dir[1]];
     }
     // 动态转移方程
     for(int i = manager[0] + dir[0];i != buss[0] + dir[0];i += dir[0]){
         for(int j = manager[1] + dir[1];j != buss[1] + dir[1];j += dir[1]){
             dp[i][j] = map[i][j] == -1 ? 0 : dp[i - dir[0]][j] + dp[i][j - dir[1]];
         }
     }
     return dp[buss[0]][buss[1]];
 }