This approach involves using Breadth-First Search (BFS) to precompute the minimum Manhattan distance from each cell to any thief in the grid, and then using this information to find the maximum safeness factor for reaching the bottom-right corner.
Time Complexity: O(n2 log n), where n is the grid size, due to the Dijkstra-like process.
Space Complexity: O(n2) for storing distances and safeness factors.
1class SafestPathFinder {
2 constructor() {
3 this.directions = [[0, 1], [1, 0], [0, -1], [-1, 0]];
4 }
5
6 maxSafenessFactor(grid) {
7 const n = grid.length;
8 const distance = Array.from({ length: n }, () => Array(n).fill(Infinity));
9 const queue = [];
10
11 for (let r = 0; r < n; r++) {
12 for (let c = 0; c < n; c++) {
13 if (grid[r][c] === 1) {
14 queue.push([r, c]);
15 distance[r][c] = 0;
16 }
17 }
18 }
19
20 let idx = 0;
21 while (idx < queue.length) {
22 const [r, c] = queue[idx++];
23 for (const [dr, dc] of this.directions) {
24 const nr = r + dr, nc = c + dc;
25 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distance[nr][nc] === Infinity) {
26 distance[nr][nc] = distance[r][c] + 1;
27 queue.push([nr, nc]);
28 }
29 }
30 }
31
32 const heap = new MaxPriorityQueue({ priority: x => x[2] });
33 heap.enqueue([0, 0, distance[0][0]]);
34
35 const visited = Array.from({ length: n }, () => Array(n).fill(false));
36
37 while (!heap.isEmpty()) {
38 const { element: [r, c, safeness] } = heap.dequeue();
39 if (r === n - 1 && c === n - 1) return safeness;
40 if (visited[r][c]) continue;
41 visited[r][c] = true;
42
43 for (const [dr, dc] of this.directions) {
44 const nr = r + dr, nc = c + dc;
45 if (nr >= 0 && nr < n && nc >= 0 && nc < n && !visited[nr][nc]) {
46 const newSafeness = Math.min(safeness, distance[nr][nc]);
47 heap.enqueue([nr, nc, newSafeness]);
48 }
49 }
50 }
51 return 0;
52 }
53}
54
55const spf = new SafestPathFinder();
56const grid = [[0, 0, 1], [0, 0, 0], [0, 0, 0]];
57console.log(spf.maxSafenessFactor(grid)); // Output: 2
58JavaScript solution leverages a BFS to determine distances from each grid cell to thieves, followed by a priority-based strategy using a max-heap to compile the path with the greatest safeness factor.
This approach considers processing from both the starting and ending points in a bidirectional BFS style, potentially meeting in the middle for optimized distance calculations and safeness factor determination.
Time Complexity: O(n2) due to simultaneous BFS processing.
Space Complexity: O(n2) as distances from both ends are computed.
1using System;
2using System.Collections.Generic;
3
4public class SafestPathFinder {
5 private static int[][] directions = new int[4][] {
6 new int[] { 0, 1 },
7 new int[] { 1, 0 },
8 new int[] { 0, -1 },
9 new int[] { -1, 0 }
10 };
11
12 public int BidirectionalSafenessFactor(int[][] grid) {
13 int n = grid.Length;
14 int[][] distFromStart = new int[n][];
15 int[][] distFromEnd = new int[n][];
16 for (int i = 0; i < n; i++) {
17 distFromStart[i] = new int[n];
18 distFromEnd[i] = new int[n];
19 Array.Fill(distFromStart[i], int.MaxValue);
20 Array.Fill(distFromEnd[i], int.MaxValue);
21 }
22
23 Queue<(int, int)> startQueue = new();
24 startQueue.Enqueue((0, 0));
25 distFromStart[0][0] = 0;
26
27 Queue<(int, int)> endQueue = new();
28 endQueue.Enqueue((n - 1, n - 1));
29 distFromEnd[n - 1][n - 1] = 0;
30
31 while (startQueue.Count > 0 || endQueue.Count > 0) {
32 if (startQueue.Count > 0) {
33 var (r, c) = startQueue.Dequeue();
34 foreach (var dir in directions) {
35 int nr = r + dir[0];
36 int nc = c + dir[1];
37 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distFromStart[nr][nc] == int.MaxValue) {
38 distFromStart[nr][nc] = distFromStart[r][c] + 1;
39 startQueue.Enqueue((nr, nc));
40 }
41 }
42 }
43
44 if (endQueue.Count > 0) {
45 var (r, c) = endQueue.Dequeue();
46 foreach (var dir in directions) {
47 int nr = r + dir[0];
48 int nc = c + dir[1];
49 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distFromEnd[nr][nc] == int.MaxValue) {
50 distFromEnd[nr][nc] = distFromEnd[r][c] + 1;
51 endQueue.Enqueue((nr, nc));
52 }
53 }
54 }
55
56 // Check overlapping
57data switching
58 for (int i = 0; i < n; ++i) {
59 for (int j = 0; j < n; ++j) {
60 if (distFromStart[i][j] != int.MaxValue && distFromEnd[i][j] != int.MaxValue) {
61 return distFromStart[i][j] + distFromEnd[i][j];
62 }
63 }
64 }
65 }
66
67 return -1;
68 }
69
70 public static void Main() {
71 SafestPathFinder spf = new();
72 int[][] grid = new int[][] {
73 new int[] { 0, 0, 1 },
74 new int[] { 0, 0, 0 },
75 new int[] { 0, 0, 0 }
76 };
77 Console.WriteLine(spf.BidirectionalSafenessFactor(grid)); // Output: Safeness factor
78 }
79}
80The C# method leverages bidirectional BFS to concurrently expand from both initial and final cell locations until intersection occurs. It's highly efficient in discovering paths by reducing each direction BFS depth.