Problem

We are given a 2-dimensional grid. "." is an empty cell, "#" is a wall, "@" is the starting point, ("a", "b", …) are keys, and ("A", "B", …) are locks.

We start at the starting point, and one move consists of walking one space in one of the 4 cardinal directions. We cannot walk outside the grid, or walk into a wall. If we walk over a key, we pick it up. We can’t walk over a lock unless we have the corresponding key.

For some 1 <= K <= 6, there is exactly one lowercase and one uppercase letter of the first K letters of the English alphabet in the grid. This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were chosen in the same order as the English alphabet.

Return the lowest number of moves to acquire all keys. If it’s impossible, return -1.

Example 1:

Input: ["@.a.#","###.#","b.A.B"]
Output: 8

Example 2:

Input: ["@..aA","..B#.","....b"]
Output: 6

Note:

1 <= grid.length <= 30
1 <= grid[0].length <= 30
grid[i][j] contains only '.', '#', '@', 'a'-'f' and 'A'-'F'
The number of keys is in [1, 6]. Each key has a different letter and opens exactly one lock.

Solution: BFS

Time complexity: O(m*n*64)

Space complexity: O(m*n*64)

C++

// Author: Huahua

// Running time: 8 ms

class Solution {

public:

int shortestPathAllKeys(vector<string>& grid) {

int m = grid.size();

int n = grid[0].size();

int all_keys = 0;

queue<int> q;

vector<vector<vector<int>>> seen(m, vector<vector<int>>(n, vector<int>(64, 0)));

// Init

for (int i = 0; i < m; ++i)

for (int j = 0; j < n; ++j) {

const char c = grid[i][j];

if (c == '@') {

q.push((j << 16) | (i << 8));

seen[i][j][0] = 1;

} else if (c >= 'a' && c <= 'f') {

all_keys |= (1 << (c - 'a'));

}

const vector<int> dirs{-1, 0, 1, 0, -1};

int steps = 0;

while (!q.empty()) {

int size = q.size();

while (size--) {

int s = q.front(); q.pop();

int x = s >> 16;

int y = (s >> 8) & 0xFF;

int keys = s & 0xFF;

if (keys == all_keys) return steps;

for (int i = 0; i < 4; ++i) {

int nkeys = keys;

int nx = x + dirs[i];

int ny = y + dirs[i + 1];

if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;

const char c = grid[ny][nx];

if (c == '#') continue; // Wall

// Do not have the key.

if (c >= 'A' && c <= 'F' && !(keys & (1 << (c - 'A')))) continue;

// Update the keys we have.

if (c >= 'a' && c <= 'f') nkeys |= (1 << (c - 'a'));

if (seen[ny][nx][nkeys]) continue;

q.push((nx << 16) | (ny << 8) | nkeys);

seen[ny][nx][nkeys] = 1;

}

++steps;

}

return -1;

}

};

Python3

# Author: Huahua, 390 ms

class Solution:

def shortestPathAllKeys(self, grid):

m, n = len(grid), len(grid[0])

all_keys = 0

seen = [[[None]* 64 for _ in range(n)] for _ in range(m)]

q = collections.deque()

for i in range(m):

for j in range(n):

c = grid[i][j]

if c == '@':

q.append((j << 16) | (i << 8))

seen[i][j][0] = 1

elif c >= 'a' and c <= 'f':

all_keys |= (1 << (ord(c) - ord('a')))

dirs = [-1, 0, 1, 0, -1]

steps = 0

while q:

size = len(q)

while size > 0:

size -= 1

s = q.popleft()

x = s >> 16

y = (s >> 8) & 0xff

keys = s & 0xff

if keys == all_keys: return steps

for i in range(4):

nx, ny, nkeys = x + dirs[i], y + dirs[i + 1], keys

if nx < 0 or nx >= n or ny < 0 or ny >= m: continue

c = grid[ny][nx]

if c == '#': continue

if c in string.ascii_uppercase and keys & (1 << (ord(c) - ord('A'))) == 0: continue

if c in string.ascii_lowercase: nkeys |= (1 << (ord(c) - ord('a')))

if seen[ny][nx][nkeys]: continue

q.append((nx << 16) | (ny << 8) | nkeys)

seen[ny][nx][nkeys] = 1

steps += 1

return -1

Problem

题目大意：给你一个二维地图和每个坐标的大楼高度，求出总增高的最大值使得城市的天际线（投影）保持不变。

In a 2 dimensional array grid, each value grid[i][j] represents the height of a building located there. We are allowed to increase the height of any number of buildings, by any amount (the amounts can be different for different buildings). Height 0 is considered to be a building as well.

At the end, the “skyline” when viewed from all four directions of the grid, i.e. top, bottom, left, and right, must be the same as the skyline of the original grid. A city’s skyline is the outer contour of the rectangles formed by all the buildings when viewed from a distance. See the following example.

What is the maximum total sum that the height of the buildings can be increased?

Example:
Input: grid = [[3,0,8,4],[2,4,5,7],[9,2,6,3],[0,3,1,0]]
Output: 35
Explanation: 
The grid is:
[ [3, 0, 8, 4], 
  [2, 4, 5, 7],
  [9, 2, 6, 3],
  [0, 3, 1, 0] ]

The skyline viewed from top or bottom is: [9, 4, 8, 7]
The skyline viewed from left or right is: [8, 7, 9, 3]

The grid after increasing the height of buildings without affecting skylines is:

gridNew = [ [8, 4, 8, 7],
            [7, 4, 7, 7],
            [9, 4, 8, 7],
            [3, 3, 3, 3] ]

Notes:

1 < grid.length = grid[0].length <= 50.
All heights grid[i][j] are in the range [0, 100].
All buildings in grid[i][j] occupy the entire grid cell: that is, they are a 1 x 1 x grid[i][j] rectangular prism.

Solution: Greedy

Find the max of each row and column, increase the height of building at i,j to min(max_row[i], max_col[j]).

Time Complexity: O(m*n)

Space complexity: O(m+n)

C++

// Author: Huahua

class Solution {

public:

int maxIncreaseKeepingSkyline(vector<vector<int>>& grid) {

int m = grid.size();

int n = grid[0].size();

vector<int> x(n, 0);

vector<int> y(n, 0);

for (int i = 0; i < m; ++i)

for (int j = 0; j < n; ++j) {

x[j] = max(x[j], grid[i][j]);

y[i] = max(y[i], grid[i][j]);

}

int ans = 0;

for (int i = 0; i < m; ++i)

for (int j = 0; j < n; ++j)

ans += min(x[i], y[j]) - grid[i][j];

return ans;

}

};

Posts tagged as “grid”

花花酱 LeetCode 864. Shortest Path to Get All Keys

Problem

Solution: BFS

C++

Python3

Related Problems

花花酱 LeetCode 807. Max Increase to Keep City Skyline

Problem

Solution: Greedy