Qumulo phone interview failed (tad verbose)

昨天电话面试了Qumulo，phone + collabedit.com。题目是一道算法题，和 相同。不同之处是矩阵中包含了fire和j

您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
使用VIP即刻解锁阅读权限或查看其他获取积分的方式

游客，您好！
本帖隐藏的内容需要积分高于 188 才可浏览
您当前积分为 0。
VIP即刻解锁阅读权限 或 查看其他获取积分的方式
Unlock interview details and practice with AI
Curated Interview Questions from Top Companies

was tad verbose.” 唉还得练练啊。

1. // Today, we’re going to be helping Joe. Joe works in a maze.
   
2. // Unfortunately, portions of the maze have caught on fire, and
   
3. // Joe doesn’t have the maze escape manual in his back pocket.
   
4. //
   
5. // Poor Joe! But you can help Joe escape the maze.
   
6. //
   
7. // Given a maze with both Joe and the squares that are on fire, you
   
8. // must determine whether Joe can exit the maze before the fire
   
9. // reaches him, and how long it takes him to do it (in minutes).
   
10. //
    
11. // Joe and the fire each move one square per minute, vertically or
    
12. // horizontally (not diagonally). The fire spreads in four directions
    
13. // from each square that is on fire. Joe may exit the maze from any
    
14. // square that borders the edge of the maze. Neither Joe nor the fire
    
15. // may enter a square that is occupied by a wall.
    
16. //
    
17. // As an example, consider the maze below:
    
18. //
    
19. // #############   Legend: J = Joe, F = fire, # = wall, |_ = exit
    
20. // # J         #   It will take Joe 14 minutes to exit this maze.
    
21. // ####  ##### #   The fire will be right behind him.
    
22. // |  #  #   # #
    
23. // |  #F #   # #
    
24. // |__#______#_|
    
25. //
    
26. // The maze is represented by the data structure below. I’ve written
    
27. // it in Java, but you can use whatever language you’re most
    
28. // proficient in to solve the problem.
    
29. 
    
30. public enum Square { Open, Wall, Fire, Joe };
    
31. public class Maze {
    
32. //Square[][] cells;
    
33. vector<vector<Square> > cells;
    
34. };
    
35. 
    
36. public static int escapeTheMaze(Maze maze) {
    
37.     queue<Maze> maze_queue;
    
38.     maze_queue.push(maze);
    
39.     int time = 0;
    
40.     while (! maze_queue.empty()) {
    
41.         size_t size = maze_queue.size();
    
42.         for (size_t i = 0; i < size; ++ i) {
    
43.             Maze current = maze_queue.top();
    
44.             maze_queue.pop();
    
45.             size_t joe[2];
    
46.             for (size_t j = 0; j < current.cells.size(); ++ j) {
    
47.                 for (size_t k = 0; k < current.cells[j].size(); ++ k) {
    
48.                     if (Joe  == current.cells[j][k]) {
    
49.                         if (0 == j || j + 1 == current.cells.size() || 0 == k || k + 1 == current.cells[j].size()) {
    
50.                             return time;
    
51.                         }
    
52.                         joe[0] = j;
    
53.                         joe[1] = k;
    
54.                         current.cells[j][k] = Open;
    
55.                         break;
    
56.                     }
    
57.                 }
    
58.             }
    
59.             Maze new_maze(current);
    
60.             for (size_t j = 0; j < current.cells.size(); ++ j) {
    
61.                 for (size_t k = 0; k < current.cells[j].size(); ++ k) {
    
62.                     if (Fire == current.cells[j][k]) {
    
63.                         if (j > 0 && Wall != current.cells[j - 1][k]) {
    
64.                             new_maze[j - 1][k] = Fire;
    
65.                         }
    
66.                         if (j + 1 < current.cells.size() && Wall != current.cells[j + 1][k]) {
    
67.                             new_maze[j + 1][k] = Fire;
    
68.                         }
    
69.                         if (k > 0 && Wall != current.cells[j][k - 1]) {
    
70.                             new_maze[j][k - 1] = Fire;
    
71.                         }
    
72.                         if (k + 1 < current.cells[j].size() && Wall != current.cells[j][k + 1]) {
    
73.                             new_maze[j][k + 1] = Fire;
    
74.                         }
    
75.                     }
    
76.                 }
    
77.             }
    
78.             current = new_maze;
    
79.             if (joe[0] > 0 && Open == current.cells[joe[0] - 1][joe[1]]) {
    
80.                 Maze temp(current);
    
81.                 temp.cells[joe[0] - 1][joe[1]] = Joe;
    
82.                 maze_queue.push(temp);
    
83.             }
    
84.             if (joe[0] + 1 < current.cells.size() && Open == current.cells[joe[0] + 1][joe[1]]) {
    
85.                 Maze temp(current);
    
86.                 temp.cells[joe[0] + 1][joe[1]] = Joe;
    
87.                 maze_queue.push(temp);
    
88.             }
    
89.             if (joe[1] > 0 && Open == current.cells[joe[0]][joe[1] - 1]) {
    
90.                 Maze temp(current);
    
91.                 temp.cells[joe[0]][joe[1] - 1] = Joe;
    
92.                 maze_queue.push(temp);
    
93.             }
    
94.             if (joe[1] + 1 < current.cells[joe[0]].size() && Open == current.cells[joe[0]][joe[1] + 1]) {
    
95.                 Maze temp(current);
    
96.                 temp.cells[joe[0]][joe[1] + 1] = Joe;
    
97.                 maze_queue.push(temp);
    
98.             }
    
99.         }
    
100.         ++ time;
     
101.     }
     
102.     return -1;
     
103. }

复制代码

我的接口不一样，maze里面包含了fire和joe。我就合在一起写了。

请问下楼主， 这个题是在collabedit上写不用compile是吗？

因为我注意到你的代码中不是都是标准函数，所以只要功能逻辑正确就行 无所谓语法？

谢谢

size_t 是什么呀？