截图有重叠，大家将就一下。本人没有参加在线笔试，主要跟大家分享一下思路。

题目的意思就是找到从起始节点开始的定长路径，路径必须包含一个必须要到达的节点。返回所有的路径数，如果不存在这样的路径，则返回0。

既然要找到所有路径，那就采用广搜。如果路径长度达到指定长度，则检查路径中是否包含必须要到达的节点，如果包含，路径数加1；如果路径长度没有达到指定长度，则从当前路径的末节点开始，搜索所有没有被访问的邻居。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.ArrayList;

public class AmazonOnline {
     static ArrayList<Integer> path = new ArrayList<>();
    static int pathCount;
     static int mustVisit;
    static  int num;
    static byte[][] cities;

public static void main(String[] args)
    {
        InputStreamReader ir;
         BufferedReader br;

ir = new InputStreamReader(System.in);
        br = new BufferedReader(ir);

int n,m;
        int start;
        try 
         {
            String[] strs = br.readLine().split(" ");
            n = Integer.parseInt(strs[0]);
            m = Integer.parseInt(strs[1]);
            strs = br.readLine().split(" ");
            cities = new byte[n][m];
            for(int i=0;i<n;i++)
                for(int j=0;j<m;j++)
                {
                     cities[i][j] = Byte.parseByte(strs[i*m+j]);
                     if(cities[i][j]==1)
                    {
                        start = i*m + j;
                        path.add(start);
                    }
                    if(cities[i][j]==2)
                     {
                        mustVisit = i*m + j;
                         cities[i][j] = 0;
                     }
                }
            num = Integer.parseInt(br.readLine());
         } catch (IOException e) {
            e.printStackTrace();
        }
        BFS();
        System.out.println(pathCount);
     }

private static void BFS()
    {
         if(path.size()==num)
        {
            if(path.contains(mustVisit))
                 pathCount++;
             return;
        }
        int i = path.get(path.size()-1)/cities[0].length;
        int j = path.get(path.size()-1)%cities[0].length;

for(int x=i-1;x<=i+1;x++)
             for(int y=j-1;y<=j+1;y++)
             {
                if(x>=0&&x<=cities.length-1&&y>=0&&y<=cities[0].length-1&&cities[x][y]==0)
                {
                     cities[x][y] = 3;
                    path.add(x*cities[0].length+y);
                    BFS();
                     path.remove(path.size()-1);
                     cities[x][y] = 0;
                }
            }
       }
}