You are given a square board of characters. You can move on the board starting at the bottom right square marked with the character 'S'.

You need to reach the top left square marked with the character 'E'. The rest of the squares are labeled either with a numeric character 1, 2, ..., 9 or with an obstacle 'X'. In one move you can go up, left or up-left (diagonally) only if there is no obstacle there.

Return a list of two integers: the first integer is the maximum sum of numeric characters you can collect, and the second is the number of such paths that you can take to get that maximum sum, taken modulo 10^9 + 7.

In case there is no path, return [0, 0].

Example 1:

Input: board = ["E23","2X2","12S"]
Output: [7,1]

Example 2:

Input: board = ["E12","1X1","21S"]
Output: [4,2]

Example 3:

Input: board = ["E11","XXX","11S"]
Output: [0,0]

Constraints:

• 2 <= board.length == board[i].length <= 100

Solution: DP

dp[i][j] := max score when reach (j, i)
count[i][j] := path to reach (j, i) with max score

m = max(dp[i + 1][j], dp[i][j+1], dp[i+1][j+1])
dp[i][j] = board[i][j] + m
count[i][j] += count[i+1][j] if dp[i+1][j] == m
count[i][j] += count[i][j+1] if dp[i][j+1] == m
count[i][j] += count[i+1][j+1] if dp[i+1][j+1] == m

Time complexity: O(n^2)
Space complexity: O(n^2)

// Author: Huahua
class Solution {
public:
  vector<int> pathsWithMaxScore(vector<string>& board) {
    constexpr int kMod = 1e9 + 7;
    const int n = board.size();
    vector<vector<int>> dp(n + 1, vector<int>(n + 1));
    vector<vector<int>> cc(n + 1, vector<int>(n + 1, 0));
    board[n - 1][n - 1] = board[0][0] = '0';
    cc[n - 1][n - 1] = 1;
    for (int i = n - 1; i >= 0; --i)
      for (int j = n - 1; j >= 0; --j) {
        if (board[i][j] != 'X') {          
          int m = max({dp[i + 1][j], dp[i][j + 1], dp[i + 1][j + 1]});
          dp[i][j] = (board[i][j] - '0') + m;
          if (dp[i + 1][j] == m) 
            cc[i][j] = (cc[i][j] + cc[i + 1][j]) % kMod;
          if (dp[i][j + 1] == m)
            cc[i][j] = (cc[i][j] + cc[i][j + 1]) % kMod;
          if (dp[i + 1][j + 1] == m)
            cc[i][j] = (cc[i][j] + cc[i + 1][j + 1]) % kMod;
        }
      }
    return {cc[0][0] ? dp[0][0] : 0, cc[0][0]};
  }
};

The post 花花酱 LeetCode 1301. Number of Paths with Max Score appeared first on Huahua's Tech Road.

Given a 2D board containing 'X' and 'O' (the letter O), capture all regions surrounded by 'X'.

A region is captured by flipping all 'O's into 'X's in that surrounded region.

Example:

X X X X
X O O X
X X O X
X O X X

After running your function, the board should be:

X X X X
X X X X
X X X X
X O X X

Explanation:

Surrounded regions shouldn’t be on the border, which means that any 'O' on the border of the board are not flipped to 'X'. Any 'O' that is not on the border and it is not connected to an 'O' on the border will be flipped to 'X'. Two cells are connected if they are adjacent cells connected horizontally or vertically.

Solution: DFS

Time complexity: O(m*n)
Space complexity: O(m*n)

Only starts DFS at border cells of O.

// Author: Huahua
class Solution {
public:
  void solve(vector<vector<char>>& board) {
    const int m = board.size();
    if (m == 0) return;
    const int n = board[0].size();    
    
    function<void(int, int)> dfs = [&](int x, int y) {
      if (x < 0 || x >= n || y < 0 || y >= m || board[y][x] != 'O') return;
      board[y][x] = 'G'; // mark it as good      
      dfs(x - 1, y);
      dfs(x + 1, y);
      dfs(x, y - 1);
      dfs(x, y + 1);
    };
    
    for (int y = 0; y < m; ++y)
      dfs(0, y), dfs(n - 1, y);    
    
    for (int x = 0; x < n; ++x)
      dfs(x, 0), dfs(x, m - 1);    
    
    map<char, char> v{{'G','O'},{'O','X'}, {'X','X'}};
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        board[y][x] = v[board[y][x]];
  }
};

The post 花花酱 LeetCode 130. Surrounded Regions appeared first on Huahua's Tech Road.

Initially, some number of lamps are on.  lamps[i] tells us the location of the i-th lamp that is on.  Each lamp that is on illuminates every square on its x-axis, y-axis, and both diagonals (similar to a Queen in chess).

For the i-th query queries[i] = (x, y), the answer to the query is 1 if the cell (x, y) is illuminated, else 0.

After each query (x, y) [in the order given by queries], we turn off any lamps that are at cell (x, y) or are adjacent 8-directionally (ie., share a corner or edge with cell (x, y).)

Return an array of answers.  Each value answer[i] should be equal to the answer of the i-th query queries[i].

Example 1:

Input: N = 5, lamps = [[0,0],[4,4]], queries = [[1,1],[1,0]]
Output: [1,0]
Explanation: 
Before performing the first query we have both lamps [0,0] and [4,4] on.
The grid representing which cells are lit looks like this, where [0,0] is the top left corner, and [4,4] is the bottom right corner:
1 1 1 1 1
1 1 0 0 1
1 0 1 0 1
1 0 0 1 1
1 1 1 1 1
Then the query at [1, 1] returns 1 because the cell is lit.  After this query, the lamp at [0, 0] turns off, and the grid now looks like this:
1 0 0 0 1
0 1 0 0 1
0 0 1 0 1
0 0 0 1 1
1 1 1 1 1
Before performing the second query we have only the lamp [4,4] on.  Now the query at [1,0] returns 0, because the cell is no longer lit.

Note:

1. 1 <= N <= 10^9
2. 0 <= lamps.length <= 20000
3. 0 <= queries.length <= 20000
4. lamps[i].length == queries[i].length == 2

Solution: HashTable

use lx, ly, lp, lq to track the # of lamps that covers each row, col, diagonal, antidiagonal

Time complexity: O(|L| + |Q|)
Space complexity: O(|L|)

// Author: Huahua, running time: 460 ms, 82.2 MB
class Solution {
public:
  vector<int> gridIllumination(int N, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
    unordered_set<long> s;
    unordered_map<int, int> lx, ly, lp, lq;
    for (const auto& lamp : lamps) {
      const int x = lamp[0];
      const int y = lamp[1];
      s.insert(static_cast<long>(x) << 32 | y);
      ++lx[x];
      ++ly[y];
      ++lp[x + y];
      ++lq[x - y];
    }
    vector<int> ans;
    for (const auto& query : queries) {
      const int x = query[0];
      const int y = query[1];      
      if (lx.count(x) || ly.count(y) || lp.count(x + y) || lq.count(x - y)) {
        ans.push_back(1);       
        for (int tx = x - 1; tx <= x + 1; ++tx)
          for (int ty = y - 1; ty <= y + 1; ++ty) {
            if (tx < 0 || tx >= N || ty < 0 || ty >= N) continue;
            const long key = static_cast<long>(tx) << 32 | ty;
            if (!s.count(key)) continue;
            s.erase(key);
            if (--lx[tx] == 0) lx.erase(tx);
            if (--ly[ty] == 0) ly.erase(ty);
            if (--lp[tx + ty] == 0) lp.erase(tx + ty);
            if (--lq[tx - ty] == 0) lq.erase(tx - ty);
          }
      } else {
        ans.push_back(0);
      }
    }
    return ans;
  }
};

// Author: Huahua, running time: 444 ms, 82.2 MB
class Solution {
public:
  vector<int> gridIllumination(int N, vector<vector<int>>& lamps, vector<vector<int>>& queries) {
    unordered_set<long> s;
    unordered_map<int, int> lx, ly, lp, lq;
    for (const auto& lamp : lamps) {
      const int x = lamp[0];
      const int y = lamp[1];
      s.insert(static_cast<long>(x) << 32 | y);
      ++lx[x];
      ++ly[y];
      ++lp[x + y];
      ++lq[x - y];
    }
    vector<int> ans;
    auto dec = [](unordered_map<int, int>& m, int key) {
      auto it = m.find(key);
      if (it->second == 1)
        m.erase(it);
      else
        --it->second;
    };
    for (const auto& query : queries) {
      const int x = query[0];
      const int y = query[1];      
      if (lx.count(x) || ly.count(y) || lp.count(x + y) || lq.count(x - y)) {
        ans.push_back(1);       
        for (int tx = x - 1; tx <= x + 1; ++tx)
          for (int ty = y - 1; ty <= y + 1; ++ty) {
            if (tx < 0 || tx >= N || ty < 0 || ty >= N) continue;
            const long key = static_cast<long>(tx) << 32 | ty;
            auto it = s.find(key);
            if (it == s.end()) continue;
            s.erase(it);
            dec(lx, tx);
            dec(ly, ty);
            dec(lp, tx + ty);
            dec(lq, tx - ty);            
          }
      } else {
        ans.push_back(0);
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1001. Grid Illumination appeared first on Huahua's Tech Road.

The rook moves as in the rules of Chess: it chooses one of four cardinal directions (north, east, west, and south), then moves in that direction until it chooses to stop, reaches the edge of the board, or captures an opposite colored pawn by moving to the same square it occupies.  Also, rooks cannot move into the same square as other friendly bishops.

Return the number of pawns the rook can capture in one move.

Example 1:

Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","R",".",".",".","p"],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 3
Explanation: 
In this example the rook is able to capture all the pawns.

Example 2:

Input: [[".",".",".",".",".",".",".","."],[".","p","p","p","p","p",".","."],[".","p","p","B","p","p",".","."],[".","p","B","R","B","p",".","."],[".","p","p","B","p","p",".","."],[".","p","p","p","p","p",".","."],[".",".",".",".",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 0
Explanation: 
Bishops are blocking the rook to capture any pawn.

Example 3:

Input: [[".",".",".",".",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".","p",".",".",".","."],["p","p",".","R",".","p","B","."],[".",".",".",".",".",".",".","."],[".",".",".","B",".",".",".","."],[".",".",".","p",".",".",".","."],[".",".",".",".",".",".",".","."]]
Output: 3
Explanation: 
The rook can capture the pawns at positions b5, d6 and f5.

Note:

1. board.length == board[i].length == 8
2. board[i][j] is either 'R', '.', 'B', or 'p'
3. There is exactly one cell with board[i][j] == 'R'

Solution: Simulation

Time complexity: O(1)
Space complexity: O(1)

class Solution {
public:
  int numRookCaptures(vector<vector<char>>& board) {        
    int ans = 0;
    auto check = [&board](int x, int y, int dx, int dy) {
      x += dx;
      y += dy;
      while (x >= 0 && x < 8 && y >= 0 && y < 8) {
        if (board[y][x] == 'p') return 1;
        if (board[y][x] != '.') break;
        x += dx;
        y += dy;
      }
      return 0;
    };
    
    array<int, 5> dirs{1, 0, -1, 0, 1};
    for (int i = 0; i < 8; ++i)
      for (int j = 0; j < 8; ++j)
        if (board[i][j] == 'R')
          for (int d = 0; d < 4; ++d)          
            ans += check(j, i, dirs[d], dirs[d + 1]);
    return ans;
  }
};

The post 花花酱 LeetCode 999. Available Captures for Rook appeared first on Huahua's Tech Road.

On an N x N board, the numbers from 1 to N*N are written boustrophedonically starting from the bottom left of the board, and alternating direction each row.  For example, for a 6 x 6 board, the numbers are written as follows:

You start on square 1 of the board (which is always in the last row and first column).  Each move, starting from square x, consists of the following:

• You choose a destination square S with number x+1, x+2, x+3, x+4, x+5, or x+6, provided this number is <= N*N.
  • (This choice simulates the result of a standard 6-sided die roll: ie., there are always at most 6 destinations.)
• If S has a snake or ladder, you move to the destination of that snake or ladder.  Otherwise, you move to S.

A board square on row r and column c has a “snake or ladder” if board[r][c] != -1.  The destination of that snake or ladder is board[r][c].

Note that you only take a snake or ladder at most once per move: if the destination to a snake or ladder is the start of another snake or ladder, you do not continue moving.  (For example, if the board is [[4,-1],[-1,3]], and on the first move your destination square is 2, then you finish your first move at 3, because you do notcontinue moving to 4.)

Return the least number of moves required to reach square N*N.  If it is not possible, return -1.

Example 1:

Input: [
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,-1,-1,-1,-1,-1],
[-1,35,-1,-1,13,-1],
[-1,-1,-1,-1,-1,-1],
[-1,15,-1,-1,-1,-1]]
Output: 4
Explanation: 
At the beginning, you start at square 1 [at row 5, column 0].
You decide to move to square 2, and must take the ladder to square 15.
You then decide to move to square 17 (row 3, column 5), and must take the snake to square 13.
You then decide to move to square 14, and must take the ladder to square 35.
You then decide to move to square 36, ending the game.
It can be shown that you need at least 4 moves to reach the N*N-th square, so the answer is 4.

Note:

1. 2 <= board.length = board[0].length <= 20
2. board[i][j] is between 1 and N*N or is equal to -1.
3. The board square with number 1 has no snake or ladder.
4. The board square with number N*N has no snake or ladder.

Solution: BFS

Time complexity: O(n*n)

Space complexity: O(n*n)

// Author: Huahua, 8 ms (beats 100%)
class Solution {
public:
  int snakesAndLadders(vector<vector<int>>& board) {
    const int N = board.size();
    int steps = 0;
    vector<int> seen(N * N + 1, 0);
    queue<int> q;
    q.push(1);
    seen[1] = 1;
    while (!q.empty()) {
      int size = q.size();
      ++steps;
      while (size--) {
        int s = q.front(); q.pop();        
        for (int x = s + 1; x <= min(s + 6, N * N); ++x) {          
          int r, c;
          getRC(x, N, &r, &c);
          int nx = board[r][c] == -1 ? x : board[r][c];          
          if (seen[nx]) continue;
          if (nx == N * N) return steps;
          q.push(nx);
          seen[nx] = 1;
        } 
      }      
    }
    return -1;
  }
private:
  void getRC(int s, int N, int* r, int* c) {
    int y = (s - 1) / N;
    int x = (s - 1) % N;
    *r = N - 1 - y;
    *c = (y % 2) ?  N - 1 - x : x;
  }
};

The post 花花酱 LeetCode 909. Snakes and Ladders appeared first on Huahua's Tech Road.

class Solution {
public:
    int countBattleships(vector<vector<char>>& board) {
        int count = 0;
        for(int i=0;i<board.size();++i)
            for(int j=0;j<board[i].size();++j) {
                if(board[i][j] == 'X'
                   && (i==0 || board[i-1][j] == '.')
                   && (j==0 || board[i][j-1] == '.')) ++count;
            }
        return count;
    }
};

The post 花花酱 Leetcode 419. Battleships in a Board appeared first on Huahua's Tech Road.