Return true if the square is white, and false if the square is black.

The coordinate will always represent a valid chessboard square. The coordinate will always have the letter first, and the number second.

Example 1:

Input: coordinates = "a1"
Output: false
Explanation: From the chessboard above, the square with coordinates "a1" is black, so return false.

Example 2:

Input: coordinates = "h3"
Output: true
Explanation: From the chessboard above, the square with coordinates "h3" is white, so return true.

Example 3:

Input: coordinates = "c7"
Output: false

Constraints:

• coordinates.length == 2
• 'a' <= coordinates[0] <= 'h'
• '1' <= coordinates[1] <= '8'

Solution: Mod2

return (row_index + col_index) % 2 == 0

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

class Solution {
public:
  bool squareIsWhite(string coordinates) {
    return ((coordinates[0] - 'a') + (coordinates[1] - '0')) % 2 == 0;
  }
};

The post 花花酱 LeetCode 1812. Determine Color of a Chessboard Square appeared first on Huahua's Tech Road.

Given an array of integer coordinates queens that represents the positions of the Black Queens, and a pair of coordinates king that represent the position of the White King, return the coordinates of all the queens (in any order) that can attack the King.

Example 1:

Input: queens = [[0,1],[1,0],[4,0],[0,4],[3,3],[2,4]], king = [0,0]
Output: [[0,1],[1,0],[3,3]]
Explanation:  
The queen at [0,1] can attack the king cause they're in the same row. 
The queen at [1,0] can attack the king cause they're in the same column. 
The queen at [3,3] can attack the king cause they're in the same diagnal. 
The queen at [0,4] can't attack the king cause it's blocked by the queen at [0,1]. 
The queen at [4,0] can't attack the king cause it's blocked by the queen at [1,0]. 
The queen at [2,4] can't attack the king cause it's not in the same row/column/diagnal as the king.

Example 2:

Input: queens = [[0,0],[1,1],[2,2],[3,4],[3,5],[4,4],[4,5]], king = [3,3]
Output: [[2,2],[3,4],[4,4]]

Example 3:

Input: queens = [[5,6],[7,7],[2,1],[0,7],[1,6],[5,1],[3,7],[0,3],[4,0],[1,2],[6,3],[5,0],[0,4],[2,2],[1,1],[6,4],[5,4],[0,0],[2,6],[4,5],[5,2],[1,4],[7,5],[2,3],[0,5],[4,2],[1,0],[2,7],[0,1],[4,6],[6,1],[0,6],[4,3],[1,7]], king = [3,4]
Output: [[2,3],[1,4],[1,6],[3,7],[4,3],[5,4],[4,5]]

Constraints:

• 1 <= queens.length <= 63
• queens[0].length == 2
• 0 <= queens[i][j] < 8
• king.length == 2
• 0 <= king[0], king[1] < 8
• At most one piece is allowed in a cell.

Solution2: Simulation

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {    
    vector<vector<int>> b(8, vector<int>(8));
    for (const auto& q : queens)
      b[q[0]][q[1]] = 1;
    vector<vector<int>> ans;
    for (const auto& q : queens) {
      for (int dx = -1; dx <= 1; ++dx)
        for (int dy = -1; dy <= 1; ++dy) {
          if (dx == 0 && dy == 0) continue;
          int x = q[1] + dx;
          int y = q[0] + dy;
          while (x >= 0 && y >= 0 && x < 8 && y < 8 && !b[y][x]) {
            if (x == king[1] && y == king[0])
              ans.push_back(q);            
            x += dx;
            y += dy;
          }
        }
    }
    return ans;
  }
};

Solution 2: HashTable + Binary Search

Time complexity: O(nlogn)
Space complexity: O(n)

Support arbitrarily large boards, e.g. 1e9 x 1e9 with 1e6 # of queens.

// Author: Huahua
class Solution {
public:
  vector<vector<int>> queensAttacktheKing(vector<vector<int>>& queens, vector<int>& king) {    
    unordered_map<int, map<int, vector<int>>> rows, cols, diag1, diag2;    
    for (const auto& q : queens) {
      const int x = q[1];
      const int y = q[0];
      rows[y][x] = q;
      cols[x][y] = q;
      diag1[x + y][x] = q;
      diag2[x - y][x] = q;
    }
    
    const int x = king[1];
    const int y = king[0];
    vector<vector<int>> ans;
    find(rows, y, x, ans);
    find(cols, x, y, ans);
    find(diag1, x + y, x, ans);
    find(diag2, x - y, x, ans);
    return ans;
  }
private:
  void find(const unordered_map<int, map<int, vector<int>>>& m, int idx, int key, vector<vector<int>>& ans) {    
    if (!m.count(idx)) return;
    const auto& d = m.at(idx);
    auto it = d.upper_bound(key);
    if (it != end(d))
      ans.push_back(it->second);
    if (it != begin(d))
      ans.push_back(prev(it)->second);    
  }
};

The post 花花酱 LeetCode 1222. Queens That Can Attack the King 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.

Problem

https://leetcode.com/problems/knight-dialer/description/

A chess knight can move as indicated in the chess diagram below:

 .           

This time, we place our chess knight on any numbered key of a phone pad (indicated above), and the knight makes N-1 hops.  Each hop must be from one key to another numbered key.

Each time it lands on a key (including the initial placement of the knight), it presses the number of that key, pressing N digits total.

How many distinct numbers can you dial in this manner?

Since the answer may be large, output the answer modulo 10^9 + 7.

Example 1:

Input: 1
Output: 10

Example 2:

Input: 2
Output: 20

Example 3:

Input: 3
Output: 46

Note:

• 1 <= N <= 5000

Solution: DP

V1

Similar to 花花酱 688. Knight Probability in Chessboard

We can define dp[k][i][j] as # of ways to dial and the last key is (j, i) after k steps

Note: dp[*][3][0], dp[*][3][2] are always zero for all the steps.

Init: dp[0][i][j] = 1

Transition: dp[k][i][j] = sum(dp[k – 1][i + dy][j + dx]) 8 ways of move from last step.

ans = sum(dp[k])

Time complexity: O(kmn) or O(k * 12 * 8) = O(k)

Space complexity: O(kmn) -> O(mn) or O(12*8) = O(1)

V2

define dp[k][i] as # of ways to dial and the last key is i after k steps

init: dp[0][0:10] = 1

transition: dp[k][i] = sum(dp[k-1][j]) that j can move to i

ans: sum(dp[k])

Time complexity: O(k * 10) = O(k)

Space complexity: O(k * 10) -> O(10) = O(1)

// Author: Huahua, 96 ms
class Solution {
public:
  int knightDialer(int N) {
    constexpr int kMod = 1e9 + 7;
    int dirs[8][2] = {{-2, -1}, {-2, 1}, {-1, -2}, {-1, 2}, {1, -2}, {1, 2}, {2, -1}, {2, 1}};
    vector<vector<int>> dp(4, vector<int>(3, 1));
    dp[3][0] = dp[3][2] = 0;    
    for (int k = 1; k < N; ++k) {
      vector<vector<int>> tmp(4, vector<int>(3));
      for (int i = 0; i < 4; ++i)
        for (int j = 0; j < 3; ++j) {
          if (i == 3 && j != 1) continue;
          for (int d = 0; d < 8; ++d) {           
            int tx = j + dirs[d][0];
            int ty = i + dirs[d][1];
            if (tx < 0 || ty < 0 || tx >= 3 || ty >= 4) continue;
            tmp[i][j] = (tmp[i][j] + dp[ty][tx]) % kMod;
          }          
        }
      dp.swap(tmp);
    }
    int ans = 0;
    for (int i = 0; i < 4; ++i)
      for (int j = 0; j < 3; ++j)
        ans = (ans + dp[i][j]) % kMod;
    return ans;
  }
};

// Author: Huahua, 24 ms
public:
  int knightDialer(int N) {
    constexpr int kMod = 1e9 + 7;
    vector<vector<int>> moves{{4,6},{8,6},{7,9},{4,8},{3,9,0},{},{1,7,0},{2,6},{1,3},{2,4}};
    vector<int> dp(10, 1);
    for (int k = 1; k < N; ++k) {
      vector<int> tmp(10);
      for (int i = 0; i < 10; ++i)
        for (int nxt : moves[i])
          tmp[nxt] = (tmp[nxt] + dp[i]) % kMod;        
      dp.swap(tmp);
    }
    int ans = 0;
    for (int i = 0; i < 10; ++i)
      ans = (ans + dp[i]) % kMod;
    return ans;
  }
};

Related Problem

• 花花酱 688. Knight Probability in Chessboard
• 花花酱 LeetCode 576. Out of Boundary Paths

The post 花花酱 LeetCode 935. Knight Dialer appeared first on Huahua's Tech Road.

https://leetcode.com/problems/knight-probability-in-chessboard/description/

Problem:

Input: 3, 2, 0, 0
Output: 0.0625
Explanation: There are two moves (to (1,2), (2,1)) that will keep the knight on the board.
From each of those positions, there are also two moves that will keep the knight on 
the board. The total probability the knight stays on the board is 0.0625.

// Author: Huahua
// Runtime: 6 ms
class Solution {
public:
    double knightProbability(int N, int K, int r, int c) {
        vector<vector<double>> dp0(N, vector<double>(N, 0.0));
        dp0[r][c] = 1.0;
        int dirs[8][2] = {{1, 2}, {-1, -2}, {1, -2}, {-1, 2},
                          {2, 1}, {-2, -1}, {2, -1}, {-2, 1}};
        for (int k = 0; k < K; ++k) {            
            vector<vector<double>> dp1(N, vector<double>(N, 0.0));
            for (int i = 0; i < N; ++i)
                for (int j = 0; j < N; ++j) 
                    for (int m = 0; m < 8; ++m) {
                        int x = j + dirs[m][0];
                        int y = i + dirs[m][1];
                        if (x < 0 || y < 0 || x >= N || y >= N) continue;
                        dp1[i][j] += dp0[y][x];
                    }
            std::swap(dp0, dp1);
        }
        
        double total = 0;
        for (int i = 0; i < N; ++i)
            for (int j = 0; j < N; ++j)
                total += dp0[i][j];
        
        return total / pow(8, K);
    }
};

Related problems:

• [解题报告] LeetCode 62. Unique Paths
• [解题报告] LeetCode 63. Unique Paths II

The post 花花酱 688. Knight Probability in Chessboard appeared first on Huahua's Tech Road.