Your task is to form target using the given words under the following rules:

• target should be formed from left to right.
• To form the ith character (0-indexed) of target, you can choose the kth character of the jth string in words if target[i] = words[j][k].
• Once you use the kth character of the jth string of words, you can no longer use the xth character of any string in words where x <= k. In other words, all characters to the left of or at index k become unusuable for every string.
• Repeat the process until you form the string target.

Notice that you can use multiple characters from the same string in words provided the conditions above are met.

Return the number of ways to form target from words. Since the answer may be too large, return it modulo 109 + 7.

Example 1:

Input: words = ["acca","bbbb","caca"], target = "aba"
Output: 6
Explanation: There are 6 ways to form target.
"aba" -> index 0 ("acca"), index 1 ("bbbb"), index 3 ("caca")
"aba" -> index 0 ("acca"), index 2 ("bbbb"), index 3 ("caca")
"aba" -> index 0 ("acca"), index 1 ("bbbb"), index 3 ("acca")
"aba" -> index 0 ("acca"), index 2 ("bbbb"), index 3 ("acca")
"aba" -> index 1 ("caca"), index 2 ("bbbb"), index 3 ("acca")
"aba" -> index 1 ("caca"), index 2 ("bbbb"), index 3 ("caca")

Example 2:

Input: words = ["abba","baab"], target = "bab"
Output: 4
Explanation: There are 4 ways to form target.
"bab" -> index 0 ("baab"), index 1 ("baab"), index 2 ("abba")
"bab" -> index 0 ("baab"), index 1 ("baab"), index 3 ("baab")
"bab" -> index 0 ("baab"), index 2 ("baab"), index 3 ("baab")
"bab" -> index 1 ("abba"), index 2 ("baab"), index 3 ("baab")

Example 3:

Input: words = ["abcd"], target = "abcd"
Output: 1

Example 4:

Input: words = ["abab","baba","abba","baab"], target = "abba"
Output: 16

Constraints:

• 1 <= words.length <= 1000
• 1 <= words[i].length <= 1000
• All strings in words have the same length.
• 1 <= target.length <= 1000
• words[i] and target contain only lowercase English letters.

Solution: DP

dp[i][j] := # of ways to form target[0~j] where the j-th letter is from the i-th column of words.
count[i][j] := # of words that have word[i] == target[j]

dp[i][j] = dp[i-1][j-1] * count[i][j]

Time complexity: O(mn)
Space complexity: O(mn) -> O(n)

class Solution {
public:
  int numWays(vector<string>& words, string target) {
    constexpr int kMod = 1e9 + 7;
    const int n = target.length();
    const int m = words[0].length();
    
    vector<long> dp(n); // dp[j] = # of ways to form t[0~j]
    for (int i = 0; i < m; ++i) {
      vector<int> count(26);
      for (const string& word: words)
        ++count[word[i] - 'a'];      
      for (int j = min(i, n - 1); j >= 0; --j)
        dp[j] = (dp[j] + (j > 0 ? dp[j - 1] : 1) * 
                    count[target[j] - 'a']) % kMod;
    }
    return dp[n - 1];
  }
};

The post 花花酱 LeetCode 1639. Number of Ways to Form a Target String Given a Dictionary appeared first on Huahua's Tech Road.

• 1 which means a street connecting the left cell and the right cell.
• 2 which means a street connecting the upper cell and the lower cell.
• 3 which means a street connecting the left cell and the lower cell.
• 4 which means a street connecting the right cell and the lower cell.
• 5 which means a street connecting the left cell and the upper cell.
• 6 which means a street connecting the right cell and the upper cell.

You will initially start at the street of the upper-left cell (0,0). A valid path in the grid is a path which starts from the upper left cell (0,0) and ends at the bottom-right cell (m - 1, n - 1). The path should only follow the streets.

Notice that you are not allowed to change any street.

Return true if there is a valid path in the grid or false otherwise.

Example 1:

Input: grid = [[2,4,3],[6,5,2]]
Output: true
Explanation: As shown you can start at cell (0, 0) and visit all the cells of the grid to reach (m - 1, n - 1).

Example 2:

Input: grid = [[1,2,1],[1,2,1]]
Output: false
Explanation: As shown you the street at cell (0, 0) is not connected with any street of any other cell and you will get stuck at cell (0, 0)

Example 3:

Input: grid = [[1,1,2]]
Output: false
Explanation: You will get stuck at cell (0, 1) and you cannot reach cell (0, 2).

Example 4:

Input: grid = [[1,1,1,1,1,1,3]]
Output: true

Example 5:

Input: grid = [[2],[2],[2],[2],[2],[2],[6]]
Output: true

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 300
• 1 <= grid[i][j] <= 6

Solution: BFS

Need to check both sides (x, y) -> (tx, ty) and (tx, ty) -> (x, y) to make sure a path exist.

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

// Author: Huahua
class Solution {
public:
  bool hasValidPath(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<int> dirs{0, -1, 0, 1, 0}; // [up, left, down, right]    
    vector<set<int>> rules{
      {1, 3}, {0, 2}, {1, 2}, 
      {2, 3}, {0, 1}, {0, 3}};
    queue<int> q{{0}};
    vector<int> seen(m * n);
    seen[0] = 1;
    while (!q.empty()) {
      int cx = q.front() % n;
      int cy = q.front() / n;      
      q.pop();
      if (cx == n - 1 && cy == m - 1) return true;      
      for (int d : rules[grid[cy][cx] - 1]) {
        int x = cx + dirs[d];
        int y = cy + dirs[d + 1];
        int key = y * n + x;
        if (x < 0 || x >= n || y < 0 || y >= m || seen[key] 
           || !rules[grid[y][x] - 1].count((d + 2) % 4)) continue;
        seen[key] = 1;
        q.push(key);
      }
    }
    return false;
  }
};

The post 花花酱 LeetCode 1391. Check if There is a Valid Path in a Grid appeared first on Huahua's Tech Road.

A lucky number is an element of the matrix such that it is the minimum element in its row and maximum in its column.

Example 1:

Input: matrix = [[3,7,8],[9,11,13],[15,16,17]]
Output: [15]
Explanation: 15 is the only lucky number since it is the minimum in its row and the maximum in its column

Example 2:

Input: matrix = [[1,10,4,2],[9,3,8,7],[15,16,17,12]]
Output: [12]
Explanation: 12 is the only lucky number since it is the minimum in its row and the maximum in its column.

Example 3:

Input: matrix = [[7,8],[1,2]]
Output: [7]

Constraints:

• m == mat.length
• n == mat[i].length
• 1 <= n, m <= 50
• 1 <= matrix[i][j] <= 10^5.
• All elements in the matrix are distinct.

Solution: Pre-processing

Two pass. First pass, record the min val of each row, and max val of each column.
Second pass, identify lucky numbers.

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

// Author: Huahua
class Solution {
public:
  vector<int> luckyNumbers (vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    vector<int> rows(m, INT_MAX);
    vector<int> cols(n, INT_MIN);
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        rows[i] = min(rows[i], matrix[i][j]);
        cols[j] = max(cols[j], matrix[i][j]);
      }
    vector<int> ans;
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) 
        if (matrix[i][j] == rows[i] &&
            matrix[i][j] == cols[j])
          ans.push_back(matrix[i][j]);
    return ans;
  }
};

The post 花花酱 LeetCode 1380. Lucky Numbers in a Matrix appeared first on Huahua's Tech Road.

Given a m x ngrid. Each cell of the grid has a sign pointing to the next cell you should visit if you are currently in this cell. The sign of grid[i][j] can be:

• 1 which means go to the cell to the right. (i.e go from grid[i][j] to grid[i][j + 1])
• 2 which means go to the cell to the left. (i.e go from grid[i][j] to grid[i][j - 1])
• 3 which means go to the lower cell. (i.e go from grid[i][j] to grid[i + 1][j])
• 4 which means go to the upper cell. (i.e go from grid[i][j] to grid[i - 1][j])

Notice that there could be some invalid signs on the cells of the grid which points outside the grid.

You will initially start at the upper left cell (0,0). A valid path in the grid is a path which starts from the upper left cell (0,0) and ends at the bottom-right cell (m - 1, n - 1) following the signs on the grid. The valid path doesn’t have to be the shortest.

You can modify the sign on a cell with cost = 1. You can modify the sign on a cell one time only.

Return the minimum cost to make the grid have at least one valid path.

Example 1:

Input: grid = [[1,1,1,1],[2,2,2,2],[1,1,1,1],[2,2,2,2]]
Output: 3
Explanation: You will start at point (0, 0).
The path to (3, 3) is as follows. (0, 0) --> (0, 1) --> (0, 2) --> (0, 3) change the arrow to down with cost = 1 --> (1, 3) --> (1, 2) --> (1, 1) --> (1, 0) change the arrow to down with cost = 1 --> (2, 0) --> (2, 1) --> (2, 2) --> (2, 3) change the arrow to down with cost = 1 --> (3, 3)
The total cost = 3.

Example 2:

Input: grid = [[1,1,3],[3,2,2],[1,1,4]]
Output: 0
Explanation: You can follow the path from (0, 0) to (2, 2).

Example 3:

Input: grid = [[1,2],[4,3]]
Output: 1

Example 4:

Input: grid = [[2,2,2],[2,2,2]]
Output: 3

Example 5:

Input: grid = [[4]]
Output: 0

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100

Solution 1: Lazy BFS (fake DP)

dp[i][j] := min steps to reach (i, j)

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

// Author: Huahua
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    int m = grid.size();
    int n = grid[0].size();
    vector<vector<int>> dp(m, vector<int>(n, INT_MAX / 2));    
        
    dp[0][0] = 0;
    auto solve = [&](int x, int y) {
      int& v = dp[y][x];
      if (x > 0) v = min(v, dp[y][x - 1] + (grid[y][x - 1] != 1));
      if (y > 0) v = min(v, dp[y - 1][x] + (grid[y - 1][x] != 3));
      if (x < n - 1) v = min(v, dp[y][x + 1] + (grid[y][x + 1] != 2));
      if (y < m - 1) v = min(v, dp[y + 1][x] + (grid[y + 1][x] != 4));
    };
    
    // At most m + n steps to propagate the results to (m - 1, n -1).
    for (int k = 0; k <= (m + n); ++k) {
      for (int y = 0; y < m; ++y)
        for (int x = 0; x < n; ++x)
          solve(x, y);
      for (int y = m - 1; y >= 0; --y)
        for (int x = n - 1; x >= 0; --x)
          solve(x, y);
    }
    return dp[m - 1][n - 1];
  }
};

// Author: Huahua, 88 ms / 22.9 MB
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<int>> dp(m, vector<int>(n, INT_MAX / 2));
    dp[0][0] = 0;
    while (true) {
      auto prev(dp);
      for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j) {
          if (i > 0) dp[i][j] = min(dp[i][j], dp[i - 1][j] + (grid[i - 1][j] != 3));
          if (j > 0) dp[i][j] = min(dp[i][j], dp[i][j - 1] + (grid[i][j - 1] != 1));
        }            
      for (int i = m - 1; i >= 0; --i)
        for (int j = n - 1; j >= 0; --j) {
          if (i != m - 1) dp[i][j] = min(dp[i][j], dp[i + 1][j] + (grid[i + 1][j] != 4));
          if (j != n - 1) dp[i][j] = min(dp[i][j], dp[i][j + 1] + (grid[i][j + 1] != 2));
        }
      if (prev == dp) break; // optimal solution obtained.
    }
    return dp[m - 1][n - 1];
  }
};

Solution 2: 0-1 BFS

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

// Author: Huahua
class Solution {
public:
  int minCost(vector<vector<int>>& grid) {
    const int m = grid.size();
    const int n = grid[0].size();
    deque<pair<int, int>> q{{0, 0}};
    vector<char> seen(m * n);
    vector<vector<int>> dirs{{1, 0}, {-1, 0}, {0, 1}, {0, -1}};
    while (!q.empty()) {
      auto [p, cost] = q.front(); q.pop_front();
      int x = p % n, y = p / n;
      if (x == n - 1 && y == m - 1) return cost;
      if (seen[p]++) continue;
      for (int i = 0; i < 4; ++i) {
        int tx = x + dirs[i][0], ty = y + dirs[i][1];
        int tp = ty * n + tx;
        if (tx < 0 || ty < 0 || tx >= n || ty >= m || seen[tp]) continue;
        if (grid[y][x] == i + 1)
          q.emplace_front(tp, cost);
        else
          q.emplace_back(tp, cost + 1);
      }
    }    
    return -1;
  }
};

The post 花花酱 LeetCode 1368. Minimum Cost to Make at Least One Valid Path in a Grid appeared first on Huahua's Tech Road.

Example 1:

Input: mat = [[1,2,3],[4,5,6],[7,8,9]], K = 1
Output: [[12,21,16],[27,45,33],[24,39,28]]

Example 2:

Input: mat = [[1,2,3],[4,5,6],[7,8,9]], K = 2
Output: [[45,45,45],[45,45,45],[45,45,45]]

Constraints:

• m == mat.length
• n == mat[i].length
• 1 <= m, n, K <= 100
• 1 <= mat[i][j] <= 100

Solution: 2D range query

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

// Author: Huahua, 20 ms
class Solution {
public:
  vector<vector<int>> matrixBlockSum(vector<vector<int>>& mat, int K) {
    const int n = mat.size();
    const int m = mat[0].size();
    vector<vector<int>> dp(n + 1, vector<int>(m + 1));
    for (int y = 1; y <= n; ++y)
      for (int x = 1; x <= m; ++x)
        dp[y][x] = dp[y - 1][x] + dp[y][x - 1] + mat[y - 1][x - 1] - dp[y - 1][x - 1];
    auto ans = mat;
    for (int y = 1; y <= n; ++y)
      for (int x = 1; x <= m; ++x) {
        int x1 = max(1, x - K);
        int x2 = min(m, x + K);
        int y1 = max(1, y - K);
        int y2 = min(n, y + K);
        ans[y - 1][x - 1] = dp[y2][x2] - dp[y1 - 1][x2] - dp[y2][x1 - 1] + dp[y1 - 1][x1 - 1];
      }
    return ans;
  }
};

The post 花花酱 LeetCode 1314. Matrix Block Sum appeared first on Huahua's Tech Road.

Example 1:

Input: grid = [[1,0],[0,1]]
Output: 0
Explanation: No servers can communicate with others.

Example 2:

Input: grid = [[1,0],[1,1]]
Output: 3
Explanation: All three servers can communicate with at least one other server.

Example 3:

Input: grid = [[1,1,0,0],[0,0,1,0],[0,0,1,0],[0,0,0,1]]
Output: 4
Explanation: The two servers in the first row can communicate with each other. The two servers in the third column can communicate with each other. The server at right bottom corner can't communicate with any other server.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m <= 250
• 1 <= n <= 250
• grid[i][j] == 0 or 1

Solution: Counting

Two passes:
First pass, count number of computers for each row and each column.
Second pass, count grid[i][j] if rows[i] or cols[j] has more than 1 computer.

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

// Author: Huahua
class Solution {
public:
  int countServers(vector<vector<int>>& grid) {
    const size_t m = grid.size();
    const size_t n = grid[0].size();
    vector<int> rows(m);
    vector<int> cols(n);
    for (size_t i = 0; i < m; ++i)
      for (size_t j = 0; j < n; ++j) {
        rows[i] += grid[i][j];
        cols[j] += grid[i][j];
      }
    int ans = 0;
     for (size_t i = 0; i < m; ++i)
      for (size_t j = 0; j < n; ++j)
        ans += (rows[i] > 1 || cols[j] > 1) ? grid[i][j] : 0;
    return ans;
  }
};

The post 花花酱 LeetCode 1267. Count Servers that Communicate appeared first on Huahua's Tech Road.

The function is constantly increasing, i.e.:

• f(x, y) < f(x + 1, y)
• f(x, y) < f(x, y + 1)

The function interface is defined like this: 

interface CustomFunction {
public:
  // Returns positive integer f(x, y) for any given positive integer x and y.
  int f(int x, int y);
};

For custom testing purposes you’re given an integer function_id and a target z as input, where function_id represent one function from an secret internal list, on the examples you’ll know only two functions from the list.  

You may return the solutions in any order.

Example 1:

Input: function_id = 1, z = 5
Output: [[1,4],[2,3],[3,2],[4,1]]
Explanation: function_id = 1 means that f(x, y) = x + y

Example 2:

Input: function_id = 2, z = 5
Output: [[1,5],[5,1]]
Explanation: function_id = 2 means that f(x, y) = x * y

Constraints:

• 1 <= function_id <= 9
• 1 <= z <= 100
• It’s guaranteed that the solutions of f(x, y) == z will be on the range 1 <= x, y <= 1000
• It’s also guaranteed that f(x, y) will fit in 32 bit signed integer if 1 <= x, y <= 1000

Solution1 : Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> findSolution(CustomFunction& customfunction, int z) {
    vector<vector<int>> ans;    
    for (int x = 1; x <= 1000; ++x) {
      if (customfunction.f(x, 1) > z) break;
      for (int y = 1; y <= 1000; ++y) {
        int t = customfunction.f(x, y);
        if (t > z) break;
        if (t == z) ans.push_back({x, y});        
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1237. Find Positive Integer Solution for a Given Equation 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.

A subsequence of a string is a new string generated from the original string with some characters(can be none) deleted without changing the relative order of the remaining characters. (eg, “ace” is a subsequence of “abcde” while “aec” is not). A common subsequence of two strings is a subsequence that is common to both strings.

If there is no common subsequence, return 0.

Example 1:

Input: text1 = "abcde", text2 = "ace" 
Output: 3  
Explanation: The longest common subsequence is "ace" and its length is 3.

Example 2:

Input: text1 = "abc", text2 = "abc"
Output: 3
Explanation: The longest common subsequence is "abc" and its length is 3.

Example 3:

Input: text1 = "abc", text2 = "def"
Output: 0
Explanation: There is no such common subsequence, so the result is 0.

Constraints:

• 1 <= text1.length <= 1000
• 1 <= text2.length <= 1000
• The input strings consist of lowercase English characters only.

Solution: DP

Use dp[i][j] to represent the length of longest common sub-sequence of text1[0:i] and text2[0:j]
dp[i][j] = dp[i – 1][j – 1] + 1 if text1[i – 1] == text2[j – 1] else max(dp[i][j – 1], dp[i – 1][j])

Time complexity: O(mn)
Space complexity: O(mn) -> O(n)

// Author: Huahua, 16ms 14.9 MB
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();
    vector<vector<int>> dp(m + 1, vector<int>(n + 1));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        if (text1[i] == text2[j])
          dp[i + 1][j + 1] = dp[i][j] + 1;
        else
          dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j]);      
    return dp[m][n];
  }
};

// Author: Huahua, 8ms, 8.8MB
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();    
    vector<int> dp(n + 1);    
    for (int i = 0; i < m; ++i) {
      int prev = 0; // dp[i][j]
      for (int j = 0; j < n; ++j) {        
        int curr = dp[j + 1]; // dp[i][j + 1]
        if (text1[i] == text2[j])
          // dp[i + 1][j + 1] = dp[i][j] + 1
          dp[j + 1] = prev + 1; 
        else
          // dp[i + 1][j + 1] = max(dp[i][j + 1], dp[i + 1][j])
          dp[j + 1] = max(curr, dp[j]);
        prev = curr;
      }    
    }    
    return dp[n]; // dp[m][n]
  }
};

// Author: Huahua
class Solution {
public:
  int longestCommonSubsequence(string text1, string text2) {
    int m = text1.length();
    int n = text2.length();    
    vector<int> dp1(n + 1);
    vector<int> dp2(n + 1);
    for (int i = 0; i < m; ++i) {      
      for (int j = 0; j < n; ++j)
        if (text1[i] == text2[j])
          dp2[j + 1] = dp1[j] + 1; 
        else          
          dp2[j + 1] = max(dp1[j + 1], dp2[j]);              
      swap(dp1, dp2);
    }    
    return dp1[n];
  }
};

The post 花花酱 LeetCode 1143. Longest Common Subsequence appeared first on Huahua's Tech Road.

Problem

You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells). The island doesn’t have “lakes” (water inside that isn’t connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don’t exceed 100. Determine the perimeter of the island.

Example:

[[0,1,0,0],
 [1,1,1,0],
 [0,1,0,0],
 [1,1,0,0]]

Answer: 16
Explanation: The perimeter is the 16 yellow stripes in the image below:

Solution: Counting

If a land has 0 neighbour, it contributes 4 to the perimeter

If a land has 1 neighbour, it contributes 3 to the perimeter

If a land has 2 neighbours, it contributes 2 to the perimeter

If a land has 3 neighbours, it contributes 1 to the perimeter

If a land has 4 neighbours, it contributes 0 to the perimeter

perimeter = area * 4 – total_neighbours

Time complexity: O(mn)

Space complexity: O(1)

// Author: Huahua
// Running time: 148 ms
class Solution {
public:
  int islandPerimeter(vector<vector<int>>& grid) {
    if (grid.empty()) return 0;
    int m = grid.size();
    int n = grid[0].size();
    int area = 0;
    int conn = 0;

    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        if (grid[y][x] == 1) {
          ++area;
          if (y > 0 && grid[y - 1][x] == 1) ++conn;
          if (x > 0 && grid[y][x - 1] == 1) ++conn;
        }

    return area*4 - conn*2;
  }
};

The post 花花酱 LeetCode 463. Island Perimeter appeared first on Huahua's Tech Road.

Problem

In MATLAB, there is a very useful function called ‘reshape’, which can reshape a matrix into a new one with different size but keep its original data.

You’re given a matrix represented by a two-dimensional array, and two positive integers r and c representing the row number and column number of the wanted reshaped matrix, respectively.

The reshaped matrix need to be filled with all the elements of the original matrix in the same row-traversing order as they were.

If the ‘reshape’ operation with given parameters is possible and legal, output the new reshaped matrix; Otherwise, output the original matrix.

Example 1:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 1, c = 4
Output: 
[[1,2,3,4]]
Explanation:
The row-traversing of nums is [1,2,3,4]. The new reshaped matrix is a 1 * 4 matrix, fill it row by row by using the previous list.

Example 2:

Input: 
nums = 
[[1,2],
 [3,4]]
r = 2, c = 4
Output: 
[[1,2],
 [3,4]]
Explanation:
There is no way to reshape a 2 * 2 matrix to a 2 * 4 matrix. So output the original matrix.

Note:

1. The height and width of the given matrix is in range [1, 100].
2. The given r and c are all positive.

Solution1: Brute Force

Time complexity: O(mn)

Space complexity: O(mn)

// Author: Huahua
// Running time: 32 ms
class Solution {
public:
    vector<vector<int>> matrixReshape(vector<vector<int>>& nums, int r, int c) {
        if (nums.size() == 0) return nums;
        int m = nums.size();
        int n = nums[0].size();
        if (m * n != r * c) return nums;
        
        // new matrix r*c
        vector<vector<int>> ans(r, vector<int>(c));
        for(int i = 0; i < m * n;++i) {
            int src_y = i / n;
            int src_x = i % n;
            int dst_y = i / c;
            int dst_x = i % c;
            ans[dst_y][dst_x] = nums[src_y][src_x];
        }
        
        return ans;
    }
};

The post 花花酱 LeetCode 566. Reshape the Matrix appeared first on Huahua's Tech Road.

Problem

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int calculateMinimumHP(vector<vector<int>>& dungeon) {      
    const int m = dungeon.size();
    const int n = dungeon[0].size();

    // hp[y][x]: min hp required to reach bottom right (P).
    vector<vector<int>> hp(m + 1, vector<int>(n + 1, INT_MAX));
    hp[m][n - 1] = hp[m - 1][n] = 1;

    for (int y = m - 1; y >= 0; --y)
      for (int x = n - 1; x >= 0; --x)
        hp[y][x] = max(1, min(hp[y + 1][x], hp[y][x + 1]) - dungeon[y][x]);

    return hp[0][0];
  }
};

// Author: Huahua
// Running time: 4 ms
class Solution {
public:
  int calculateMinimumHP(vector<vector<int>>& dungeon) {      
    const int m = dungeon.size();
    const int n = dungeon[0].size();

    // hp[y][x]: min hp required to reach bottom right (P).
    vector<int> hp(n + 1, INT_MAX);
    hp[n - 1] = 1;

    for (int y = m - 1; y >= 0; --y)
      for (int x = n - 1; x >= 0; --x)
        hp[x] = max(1, min(hp[x], hp[x + 1]) - dungeon[y][x]);

    return hp[0];
  }
};

The post 花花酱 LeetCode 174. Dungeon Game appeared first on Huahua's Tech Road.

Given s1, s2, s3, find whether s3 is formed by the interleaving of s1 and s2.

Example 1:

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbcbcac"
Output: true

Example 2:

Input: s1 = "aabcc", s2 = "dbbca", s3 = "aadbbbaccc"
Output: false

Solution: DP

Subproblems : whether s3[0:i+j] can be formed by interleaving s1[0:i] and s2[0:j].

Time complexity: O(mn)

Space complexity: O(mn)

// Author: Huhaua
// Running time: 0 ms
class Solution {
public:
  bool isInterleave(string s1, string s2, string s3) {
    int l1 = s1.length();
    int l2 = s2.length();
    int l3 = s3.length();
    if (l1 + l2 != l3) return false;
    // dp[i][j]: whehter s3[0:i+j] is a interleva of s1[0:i] and s2[0:j]
    vector<vector<int>> dp(l1 + 1, vector<int>(l2 + 1));
    dp[0][0] = true;
    for (int i = 0; i <= l1; ++i)
      for (int j = 0; j <= l2; ++j) {        
        if (i > 0) dp[i][j] |= dp[i - 1][j] && s1[i - 1] == s3[i + j - 1];
        if (j > 0) dp[i][j] |= dp[i][j - 1] && s2[j - 1] == s3[i + j - 1];        
      }
    return dp[l1][l2];
  }
};

Recursion + Memorization

// Author: Huahua
// Running time: 0 ms
class Solution {
public:
  bool isInterleave(string s1, string s2, string s3) {
    m_ = vector<vector<int>>(s1.length() + 1, vector<int>(s2.length() + 1, INT_MIN));
    return dp(s1, s1.length(), s2, s2.length(), s3, s3.length());
  }
private:
  // m_[i][j]: whehter s3[0:i+j] is a interleva of s1[0:i] and s2[0:j]
  vector<vector<int>> m_;
  
  bool dp(const string& s1, int l1, const string& s2, int l2, const string& s3, int l3) {
    if (l1 + l2 != l3) return false;
    if (l1 == 0 && l2 == 0) return true;
    if (m_[l1][l2] != INT_MIN) return m_[l1][l2];
    if (l1 > 0 & s3[l3 - 1] == s1[l1 - 1] && dp(s1, l1 - 1, s2, l2, s3, l3 - 1)
      ||l2 > 0 & s3[l3 - 1] == s2[l2 - 1] && dp(s1, l1, s2, l2 - 1, s3, l3 - 1))
      m_[l1][l2] = 1;
    else
      m_[l1][l2] = 0;
    return m_[l1][l2];
  }
};

The post 花花酱 LeetCode 97. Interleaving String appeared first on Huahua's Tech Road.