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.
1#include <iostream>
2#include <vector>
3#include <queue>
4#include <climits>
5
6using namespace std;
7
8const int directions[4][2] = {{0, 1}, {1, 0}, {0, -1}, {-1, 0}};
9
10int maxSafenessFactor(vector<vector<int>>& grid) {
11 int n = grid.size();
12 vector<vector<int>> distance(n, vector<int>(n, INT_MAX));
13 queue<pair<int, int>> q;
14
15 // BFS to calculate initial distances to the nearest thief
16 for (int r = 0; r < n; ++r) {
17 for (int c = 0; c < n; ++c) {
18 if (grid[r][c] == 1) {
19 q.push({r, c});
20 distance[r][c] = 0;
21 }
22 }
23 }
24
25 while (!q.empty()) {
26 auto [r, c] = q.front(); q.pop();
27 for (auto& dir : directions) {
28 int nr = r + dir[0], nc = c + dir[1];
29 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distance[nr][nc] == INT_MAX) {
30 distance[nr][nc] = distance[r][c] + 1;
31 q.push({nr, nc});
32 }
33 }
34 }
35
36 // Use max-heap for Dijkstra's algorithm to find the path with the max safeness factor
37 vector<vector<int>> maxSafeness(n, vector<int>(n, -1));
38 priority_queue<pair<int, pair<int, int>>> pq;
39 pq.push({distance[0][0], {0, 0}});
40 maxSafeness[0][0] = distance[0][0];
41
42 while (!pq.empty()) {
43 auto [safeness, pos] = pq.top(); pq.pop();
44 auto [r, c] = pos;
45
46 for (auto& dir : directions) {
47 int nr = r + dir[0], nc = c + dir[1];
48 if (nr >= 0 && nr < n && nc >= 0 && nc < n) {
49 int newSafeness = min(safeness, distance[nr][nc]);
50 if (newSafeness > maxSafeness[nr][nc]) {
51 maxSafeness[nr][nc] = newSafeness;
52 pq.push({newSafeness, {nr, nc}});
53 }
54 }
55 }
56 }
57
58 return maxSafeness[n-1][n-1];
59}
60
61int main() {
62 vector<vector<int>> grid = {{0, 0, 1}, {0, 0, 0}, {0, 0, 0}};
63 cout << maxSafenessFactor(grid) << endl; // Output: 2
64 return 0;
65}
66This C++ solution employs a BFS to determine the minimum Manhattan distance from every cell to any thief. A priority queue (max-heap) then executes Dijkstra's algorithm to ascertain the path with the maximum safeness factor to the target cell.
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.
1#include <stdio.h>
2#include <stdlib.h>
3#include <limits.h>
4#include <stdbool.h>
5#include <string.h>
6
7#define MAX 400
8
9int grid[MAX][MAX];
10int n;
11
12int direction[4][2] = {{0,1}, {1,0}, {0,-1}, {-1,0}};
13
14int bidirectionalSafenessFactor(int grid[][MAX], int n) {
15 // Distance from start and end
16 int distanceStart[MAX][MAX];
17 int distanceEnd[MAX][MAX];
18
19 memset(distanceStart, INT_MAX, sizeof(distanceStart));
20 memset(distanceEnd, INT_MAX, sizeof(distanceEnd));
21
22 // BFS start queue
23 int queueStart[MAX*MAX][2];
24 int frontStart = 0, rearStart = 0;
25
26 queueStart[rearStart][0] = 0;
27 queueStart[rearStart][1] = 0;
28 rearStart++;
29 distanceStart[0][0] = 0;
30
31 // BFS end queue
32 int queueEnd[MAX*MAX][2];
33 int frontEnd = 0, rearEnd = 0;
34
35 queueEnd[rearEnd][0] = n-1;
36 queueEnd[rearEnd][1] = n-1;
37 rearEnd++;
38 distanceEnd[n-1][n-1] = 0;
39
40 while (frontStart < rearStart && frontEnd < rearEnd) {
41 // Expand from start
42 int r = queueStart[frontStart][0], c = queueStart[frontStart][1];
43 frontStart++;
44
45 for (int d = 0; d < 4; ++d) {
46 int nr = r + direction[d][0], nc = c + direction[d][1];
47 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distanceStart[nr][nc] == INT_MAX) {
48 distanceStart[nr][nc] = distanceStart[r][c] + 1;
49 queueStart[rearStart][0] = nr;
50 queueStart[rearStart][1] = nc;
51 rearStart++;
52 }
53 }
54
55 // Expand from end
56 r = queueEnd[frontEnd][0], c = queueEnd[frontEnd][1];
57 frontEnd++;
58
59 for (int d = 0; d < 4; ++d) {
60 int nr = r + direction[d][0], nc = c + direction[d][1];
61 if (nr >= 0 && nr < n && nc >= 0 && nc < n && distanceEnd[nr][nc] == INT_MAX) {
62 distanceEnd[nr][nc] = distanceEnd[r][c] + 1;
63 queueEnd[rearEnd][0] = nr;
64 queueEnd[rearEnd][1] = nc;
65 rearEnd++;
66 }
67 }
68
69 // Check overlap
70 for (int i = 0; i < n; ++i) {
71 for (int j = 0; j < n; ++j) {
72 if (distanceStart[i][j] != INT_MAX && distanceEnd[i][j] != INT_MAX) {
73 return distanceStart[i][j] + distanceEnd[i][j];
74 }
75 }
76 }
77 }
78
79 return -1;
80}
81
82int main() {
83 int gridExample[MAX][MAX] = {{0, 0, 1}, {0, 0, 0}, {0, 0, 0}};
84 int n = 3;
85 printf("%d\n", bidirectionalSafenessFactor(gridExample, n));
86 return 0;
87}
88The C solution processes the grid using bidirectional BFS starting from both the top-left corner and the bottom-right corner simultaneously, aiming to explore overlapping paths and maximize their safeness factor.