764. Largest Plus Sign
Вам given intero n. У вас есть бинарная сетка размером n x n, в которой все значения изначально равны 1, за исключением некоторых индексов, указанных в arrayе mines. element arrayа mines с индексом i определяется как mines[i] = [xi, yi], где grid[xi][yi] == 0.
return порядок самого большого крестообразного знака из 1, выровненного по осям, который содержится в сетке. Если такого знака нет, return 0.
Крестообразный знак из 1 порядка k имеет некоторый центр grid[r][c] == 1, а также четыре луча длиной k - 1, идущих вверх, вниз, влево и вправо, состоящие из 1. Обратите внимание, что за пределами лучей креста могут быть 0 или 1, проверяется только соответствующая область крестообразного знака на наличие 1.
Esempio:
Input: n = 5, mines = [[4,2]]
Output: 2
Explanation: In the above grid, the largest plus sign can only be of order 2. One of them is shown.
C# soluzione
abbinato/originalepublic class Solution {
public int OrderOfLargestPlusSign(int N, int[][] mines) {
var banned = new HashSet<int>();
foreach (var mine in mines) {
banned.Add(mine[0] * N + mine[1]);
}
int ans = 0;
for (int r = 0; r < N; ++r) {
for (int c = 0; c < N; ++c) {
int k = 0;
while (k <= r && r < N - k && k <= c && c < N - k &&
!banned.Contains((r - k) * N + c) &&
!banned.Contains((r + k) * N + c) &&
!banned.Contains(r * N + c - k) &&
!banned.Contains(r * N + c + k)) {
k++;
}
ans = Math.Max(ans, k);
}
}
return ans;
}
}C++ soluzione
bozza automatica, rivedere prima dell'invio#include <bits/stdc++.h>
using namespace std;
// Auto-generated C++ draft from the C# solution. Review containers, LINQ and helper types before submit.
class Solution {
public:
public int OrderOfLargestPlusSign(int N, int[][] mines) {
var banned = new HashSet<int>();
foreach (var mine in mines) {
banned.push_back(mine[0] * N + mine[1]);
}
int ans = 0;
for (int r = 0; r < N; ++r) {
for (int c = 0; c < N; ++c) {
int k = 0;
while (k <= r && r < N - k && k <= c && c < N - k &&
!banned.Contains((r - k) * N + c) &&
!banned.Contains((r + k) * N + c) &&
!banned.Contains(r * N + c - k) &&
!banned.Contains(r * N + c + k)) {
k++;
}
ans = max(ans, k);
}
}
return ans;
}
}Java soluzione
abbinato/originaleclass Solution {
public int orderOfLargestPlusSign(int N, int[][] mines) {
Set<Integer> banned = new HashSet<>();
for (int[] mine : mines)
banned.add(mine[0] * N + mine[1]);
int ans = 0;
for (int r = 0; r < N; ++r) {
for (int c = 0; c < N; ++c) {
int k = 0;
while (k <= r && r < N - k && k <= c && c < N - k &&
!banned.contains((r - k) * N + c) &&
!banned.contains((r + k) * N + c) &&
!banned.contains(r * N + c - k) &&
!banned.contains(r * N + c + k)) {
k++;
}
ans = Math.max(ans, k);
}
}
return ans;
}
}JavaScript soluzione
abbinato/originaleclass Solution {
orderOfLargestPlusSign(N, mines) {
const banned = new Set();
for (const mine of mines) {
banned.add(mine[0] * N + mine[1]);
}
let ans = 0;
for (let r = 0; r < N; ++r) {
for (let c = 0; c < N; ++c) {
let k = 0;
while (k <= r && r < N - k && k <= c && c < N - k &&
!banned.has((r - k) * N + c) &&
!banned.has((r + k) * N + c) &&
!banned.has(r * N + c - k) &&
!banned.has(r * N + c + k)) {
k++;
}
ans = Math.max(ans, k);
}
}
return ans;
}
}Python soluzione
abbinato/originaleclass Solution:
def orderOfLargestPlusSign(self, N: int, mines: List[List[int]]) -> int:
banned = set()
for mine in mines:
banned.add(mine[0] * N + mine[1])
ans = 0
for r in range(N):
for c in range(N):
k = 0
while k <= r and r < N - k and k <= c and c < N - k and \
(r - k) * N + c not in banned and \
(r + k) * N + c not in banned and \
r * N + c - k not in banned and \
r * N + c + k not in banned:
k += 1
ans = max(ans, k)
return ansGo soluzione
abbinato/originalefunc orderOfLargestPlusSign(n int, mines [][]int) int {
grid := make([][]int, n)
for i := range grid {
grid[i] = make([]int, n)
for j := range grid[i] {
grid[i][j] = n // максимальная возможная длина
}
}
for _, mine := range mines {
grid[mine[0]][mine[1]] = 0
}
for i := 0; i < n; i++ {
count := 0
for j := 0; j < n; j++ { // слева направо
if grid[i][j] == 0 {
count = 0
} else {
count++
grid[i][j] = min(grid[i][j], count)
}
}
count = 0
for j := n - 1; j >= 0; j-- { // справа налево
if grid[i][j] == 0 {
count = 0
} else {
count++
grid[i][j] = min(grid[i][j], count)
}
}
}
for j := 0; j < n; j++ {
count := 0
for i := 0; i < n; i++ { // сверху вниз
if grid[i][j] == 0 {
count = 0
} else {
count++
grid[i][j] = min(grid[i][j], count)
}
}
count = 0
for i := n - 1; i >= 0; i-- { // снизу вверх
if grid[i][j] == 0 {
count = 0
} else {
count++
grid[i][j] = min(grid[i][j], count)
}
}
}
res := 0
for i := 0; i < n; i++ {
for j := 0; j < n; j++ {
res = max(res, grid[i][j])
}
}
return res
}
func min(a, b int) int {
if a < b {
return a
}
return b
}
func max(a, b int) int {
if a > b {
return a
}
return b
}Algorithm
Создайте сетку размером n x n, заполненную единицами. Затем используйте array mines, чтобы установить значения нулей в соответствующих ячейках сетки.
Для каждой ячейки в сетке создайте четыре дополнительных сетки: left, right, up и down, которые будут хранить длину непрерывных единиц, простирающихся в соответствующем направлении от каждой ячейки.
Пройдите по всей сетке и для каждой ячейки определите минимальную длину луча среди четырех направлений. Эта минимальная длина будет определять порядок крестообразного знака с центром в данной ячейке. Обновите maximum порядок крестообразного знака и return его после завершения обхода всей сетки. Если такого знака нет, return 0.
😎
Vacancies for this task
offerte attive with overlapping task tags are mostrati.