Go through each index i in arr starting from index 0 and paint the cell in mat containing the integer arr[i].

Return the smallest index i at which either a row or a column will be completely painted in mat.

Example 1:

Input: arr = [1,3,4,2], mat = [[1,4],[2,3]]
Output: 2
Explanation: The moves are shown in order, and both the first row and second column of the matrix become fully painted at arr[2].

Example 2:

Input: arr = [2,8,7,4,1,3,5,6,9], mat = [[3,2,5],[1,4,6],[8,7,9]]
Output: 3
Explanation: The second column becomes fully painted at arr[3].

Constraints:

• m == mat.length
• n = mat[i].length
• arr.length == m * n
• 1 <= m, n <= 105
• 1 <= m * n <= 105
• 1 <= arr[i], mat[r][c] <= m * n
• All the integers of arr are unique.
• All the integers of mat are unique.

Solution: Map + Counter

Use a map to store the position of each integer.

Use row counters and column counters to track how many elements have been painted.

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

// Author: Huahua
class Solution {
public:
  int firstCompleteIndex(vector<int>& arr, vector<vector<int>>& mat) {
    const int m = mat.size();
    const int n = mat[0].size();
    vector<int> rows(m);
    vector<int> cols(n);
    vector<pair<int, int>> pos(m * n + 1);
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        pos[mat[i][j]] = {i, j};
    
    for (int i = 0; i < arr.size(); ++i) {
      auto [r, c] = pos[arr[i]];
      if (++rows[r] == n) return i;
      if (++cols[c] == m) return i;
    }
    return -1;
  }
};

The post 花花酱 LeetCode 2661. First Completely Painted Row or Column appeared first on Huahua's Tech Road.

• For example, if grid = [[-10], [3], [12]], the width of the only column is 3 since -10 is of length 3.

Return an integer array ans of size n where ans[i] is the width of the ith column.

The length of an integer x with len digits is equal to len if x is non-negative, and len + 1 otherwise.

Example 1:

Input: grid = [[1],[22],[333]]
Output: [3]
Explanation: In the 0th column, 333 is of length 3.

Example 2:

Input: grid = [[-15,1,3],[15,7,12],[5,6,-2]]
Output: [3,1,2]
Explanation: 
In the 0th column, only -15 is of length 3.
In the 1st column, all integers are of length 1. 
In the 2nd column, both 12 and -2 are of length 2.

Constraints:

• m == grid.length
• n == grid[i].length
• 1 <= m, n <= 100
• -109 <= grid[r][c] <= 109

Solution: Simulation

Note: width of ‘0’ is 1.

Time complexity: O(m*n*log(x))
Space complexity: O(1)

// Author: Huahua
class Solution {
public:
  vector<int> findColumnWidth(vector<vector<int>>& grid) {
    vector<int> ans;
    for (int j = 0; j < grid[0].size(); ++j) {
      int maxWidth = 1;
      for (int i = 0; i < grid.size(); ++i) {
        int x = grid[i][j];
        int width = 0;        
        if (x < 0) {
          x = -x;
          ++width;
        }
        while (x) {
          x /= 10;
          ++width;
        }        
        maxWidth = max(maxWidth, width);
      }
      ans.push_back(maxWidth);
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2639. Find the Width of Columns of a Grid appeared first on Huahua's Tech Road.

In case there are multiple rows that have the maximum count of ones, the row with the smallest row number should be selected.

Return an array containing the index of the row, and the number of ones in it.

Example 1:

Input: mat = [[0,1],[1,0]]
Output: [0,1]
Explanation: Both rows have the same number of 1's. So we return the index of the smaller row, 0, and the maximum count of ones (1). So, the answer is [0,1]. 

Example 2:

Input: mat = [[0,0,0],[0,1,1]]
Output: [1,2]
Explanation: The row indexed 1 has the maximum count of ones (2). So we return its index, 1, and the count. So, the answer is [1,2].

Example 3:

Input: mat = [[0,0],[1,1],[0,0]]
Output: [1,2]
Explanation: The row indexed 1 has the maximum count of ones (2). So the answer is [1,2].

Constraints:

• m == mat.length 
• n == mat[i].length 
• 1 <= m, n <= 100 
• mat[i][j] is either 0 or 1.

Solution: Counting

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

// Author: Huahua
class Solution {
public:
  vector<int> rowAndMaximumOnes(vector<vector<int>>& mat) {
    vector<int> ans(2);
    for (int i = 0; i < mat.size(); ++i) {
      int ones = accumulate(begin(mat[i]), end(mat[i]), 0);
      if (ones > ans[1]) {
        ans[0] = i;
        ans[1] = ones;
      }
    }
    return ans;
  }
};

The post 花花酱 LeetCode 2643. Row With Maximum Ones appeared first on Huahua's Tech Road.

Generate an integer matrix maxLocal of size (n - 2) x (n - 2) such that:

• maxLocal[i][j] is equal to the largest value of the 3 x 3 matrix in grid centered around row i + 1 and column j + 1.

In other words, we want to find the largest value in every contiguous 3 x 3 matrix in grid.

Return the generated matrix.

Example 1:

Input: grid = [[9,9,8,1],[5,6,2,6],[8,2,6,4],[6,2,2,2]]
Output: [[9,9],[8,6]]
Explanation: The diagram above shows the original matrix and the generated matrix.
Notice that each value in the generated matrix corresponds to the largest value of a contiguous 3 x 3 matrix in grid.

Example 2:

Input: grid = [[1,1,1,1,1],[1,1,1,1,1],[1,1,2,1,1],[1,1,1,1,1],[1,1,1,1,1]]
Output: [[2,2,2],[2,2,2],[2,2,2]]
Explanation: Notice that the 2 is contained within every contiguous 3 x 3 matrix in grid.

Constraints:

• n == grid.length == grid[i].length
• 3 <= n <= 100
• 1 <= grid[i][j] <= 100

Solution: Brute Force

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> largestLocal(vector<vector<int>>& grid) {    
    const int m = grid.size() - 2;
    vector<vector<int>> ans(m, vector<int>(m));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < m; ++j)        
        for (int dy = 0; dy <= 2; ++dy)
          for (int dx = 0; dx <= 2; ++dx)
            ans[i][j] = max(ans[i][j], grid[i + dy][j + dx]);        
    return ans;
  }
};

The post 花花酱 LeetCode 2373. Largest Local Values in a Matrix appeared first on Huahua's Tech Road.

There is one laser beam between any two security devices if both conditions are met:

• The two devices are located on two different rows: r1 and r2, where r1 < r2.
• For each row i where r1 < i < r2, there are no security devices in the ith row.

Laser beams are independent, i.e., one beam does not interfere nor join with another.

Return the total number of laser beams in the bank.

Example 1:

Input: bank = ["011001","000000","010100","001000"]
Output: 8
Explanation: Between each of the following device pairs, there is one beam. In total, there are 8 beams:
 * bank[0][1] -- bank[2][1]
 * bank[0][1] -- bank[2][3]
 * bank[0][2] -- bank[2][1]
 * bank[0][2] -- bank[2][3]
 * bank[0][5] -- bank[2][1]
 * bank[0][5] -- bank[2][3]
 * bank[2][1] -- bank[3][2]
 * bank[2][3] -- bank[3][2]
Note that there is no beam between any device on the 0th row with any on the 3rd row.
This is because the 2nd row contains security devices, which breaks the second condition.

Example 2:

Input: bank = ["000","111","000"]
Output: 0
Explanation: There does not exist two devices located on two different rows.

Constraints:

• m == bank.length
• n == bank[i].length
• 1 <= m, n <= 500
• bank[i][j] is either '0' or '1'.

Solution: Rule of product

Just need to remember the # of devices of prev non-empty row.
# of beams between two non-empty row equals to row[i] * row[j]
ans += prev * curr

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

// Author: Huahua
class Solution {
public:
  int numberOfBeams(vector<string>& bank) {    
    int ans = 0;
    int prev = 0;
    for (const string& row : bank)    
      if (int curr = count(begin(row), end(row), '1')) {
        ans += prev * curr;
        prev = curr;
      }
    return ans;
  }
};

# Author: Huahua
class Solution:
  def numberOfBeams(self, bank: List[str]) -> int:
    ans = prev = 0
    for row in bank:
      if curr := row.count('1'):
        ans += prev * curr
        prev = curr
    return ans

The post 花花酱 LeetCode 2125. Number of Laser Beams in a Bank appeared first on Huahua's Tech Road.

• Choose any two adjacent elements of matrix and multiply each of them by -1.

Two elements are considered adjacent if and only if they share a border.

Your goal is to maximize the summation of the matrix’s elements. Return the maximum sum of the matrix’s elements using the operation mentioned above.

Example 1:

Input: matrix = [[1,-1],[-1,1]]
Output: 4
Explanation: We can follow the following steps to reach sum equals 4:
- Multiply the 2 elements in the first row by -1.
- Multiply the 2 elements in the first column by -1.

Example 2:

Input: matrix = [[1,2,3],[-1,-2,-3],[1,2,3]]
Output: 16
Explanation: We can follow the following step to reach sum equals 16:
- Multiply the 2 last elements in the second row by -1.

Constraints:

• n == matrix.length == matrix[i].length
• 2 <= n <= 250
• -105 <= matrix[i][j] <= 105

Solution: Math

Count the number of negative numbers.
1. Even negatives, we can always flip all the negatives to positives. ans = sum(abs(matrix)).
2. Odd negatives, there will be one negative left, we found the smallest abs(element) and let it become negative. ans = sum(abs(matrix))) – 2 * min(abs(matrix))

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

// Author: Huahua
class Solution {
public:
  long long maxMatrixSum(vector<vector<int>>& matrix) {
    const int n = matrix.size();
    long long ans = 0;
    int count = 0;
    int lo = INT_MAX;
    for (int i = 0; i < n; ++i)
      for (int j = 0; j < n; ++j) {
        ans += abs(matrix[i][j]);
        lo = min(lo, abs(matrix[i][j]));
        count += matrix[i][j] < 0;          
      }    
    return ans - (count & 1) * 2 * lo;
  }
};

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

We translate one image however we choose by sliding all the 1 bits left, right, up, and/or down any number of units. We then place it on top of the other image. We can then calculate the overlap by counting the number of positions that have a 1 in both images.

Note also that a translation does not include any kind of rotation. Any 1 bits that are translated outside of the matrix borders are erased.

Return the largest possible overlap.

Example 1:

Input: img1 = [[1,1,0],[0,1,0],[0,1,0]], img2 = [[0,0,0],[0,1,1],[0,0,1]]
Output: 3
Explanation: We translate img1 to right by 1 unit and down by 1 unit.

The number of positions that have a 1 in both images is 3 (shown in red).

Example 2:

Input: img1 = [[1]], img2 = [[1]]
Output: 1

Example 3:

Input: img1 = [[0]], img2 = [[0]]
Output: 0

Constraints:

• n == img1.length == img1[i].length
• n == img2.length == img2[i].length
• 1 <= n <= 30
• img1[i][j] is either 0 or 1.
• img2[i][j] is either 0 or 1.

Solution: Hashtable of offsets

Enumerate all pairs of 1 cells (x1, y1) (x2, y2), the key / offset will be ((x1-x2), (y1-y2)), i.e how should we shift the image to have those two cells overlapped. Use a counter to find the most common/best offset.

Time complexity: O(n⁴) Note: this is the same as brute force / simulation method if the matrix is dense.
Space complexity: O(n²)

// Author: Huahua
class Solution {
public:
  int largestOverlap(vector<vector<int>>& img1, vector<vector<int>>& img2) {
    const int n = img1.size();
    unordered_map<int, int> m;
    for (int y1 = 0; y1 < n; ++y1)
      for (int x1 = 0; x1 < n; ++x1)
        if (img1[y1][x1])
          for (int y2 = 0; y2 < n; ++y2) 
            for (int x2 = 0; x2 < n; ++x2)
              if (img2[y2][x2])                 
                ++m[(x1 - x2) * 100 + (y1 - y2)];
    int ans = 0;
    for (const auto [key, count] : m)
      ans = max(ans, count);
    return ans;
  }
};

The post 花花酱 LeetCode 835. Image Overlap appeared first on Huahua's Tech Road.

The elements from indices 0 to n - 1 (inclusive) of original should form the first row of the constructed 2D array, the elements from indices n to 2 * n - 1 (inclusive) should form the second row of the constructed 2D array, and so on.

Return an m x n 2D array constructed according to the above procedure, or an empty 2D array if it is impossible.

Example 1:

Input: original = [1,2,3,4], m = 2, n = 2
Output: [[1,2],[3,4]]
Explanation:
The constructed 2D array should contain 2 rows and 2 columns.
The first group of n=2 elements in original, [1,2], becomes the first row in the constructed 2D array.
The second group of n=2 elements in original, [3,4], becomes the second row in the constructed 2D array.

Example 2:

Input: original = [1,2,3], m = 1, n = 3
Output: [[1,2,3]]
Explanation:
The constructed 2D array should contain 1 row and 3 columns.
Put all three elements in original into the first row of the constructed 2D array.

Example 3:

Input: original = [1,2], m = 1, n = 1
Output: []
Explanation:
There are 2 elements in original.
It is impossible to fit 2 elements in a 1x1 2D array, so return an empty 2D array.

Example 4:

Input: original = [3], m = 1, n = 2
Output: []
Explanation:
There is 1 element in original.
It is impossible to make 1 element fill all the spots in a 1x2 2D array, so return an empty 2D array.

Constraints:

• 1 <= original.length <= 5 * 104
• 1 <= original[i] <= 105
• 1 <= m, n <= 4 * 104

Solution: Brute Force

the i-th element in original array will have index (i//n, i % n) in the 2D array.

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

class Solution {
public:
  vector<vector<int>> construct2DArray(vector<int>& original, int m, int n) {
    if (original.size() != m * n) return {};
    vector<vector<int>> ans(m, vector<int>(n));
    for (int i = 0; i < m * n; ++i)
      ans[i / n][i % n] = original[i];
    return ans;
  }
};

The post 花花酱 LeetCode 2022. Convert 1D Array Into 2D Array appeared first on Huahua's Tech Road.

Example 1:

Input: mat = [[0,1],[1,0]], target = [[1,0],[0,1]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise to make mat equal target.

Example 2:

Input: mat = [[0,1],[1,1]], target = [[1,0],[0,1]]
Output: false
Explanation: It is impossible to make mat equal to target by rotating mat.

Example 3:

Input: mat = [[0,0,0],[0,1,0],[1,1,1]], target = [[1,1,1],[0,1,0],[0,0,0]]
Output: true
Explanation: We can rotate mat 90 degrees clockwise two times to make mat equal target.

Constraints:

• n == mat.length == target.length
• n == mat[i].length == target[i].length
• 1 <= n <= 10
• mat[i][j] and target[i][j] are either 0 or 1.

Solution: Simulation

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

// Author: Huahua
class Solution {
public:
  bool findRotation(vector<vector<int>>& mat, vector<vector<int>>& target) {    
    const int n = mat.size();
    auto rot = [n](vector<vector<int>>& mat) {      
      for (int i = 0; i < n; ++i)
        for (int j = i; j < n; ++j)
          swap(mat[i][j], mat[j][i]);
      for (int j = 0; j < n; j++)
        for (int i = 0; i < n / 2; ++i)
          swap(mat[i][j], mat[n - i - 1][j]);
      return mat;
    };
    for (int i = 0; i < 4; ++i)
      if (rot(mat) == target) return true;    
    return false;
  }
};

The post 花花酱 LeetCode 1886. Determine Whether Matrix Can Be Obtained By Rotation appeared first on Huahua's Tech Road.

You are given a binary matrix matrix of size m x n, and you are allowed to rearrange the columns of the matrix in any order.

Return the area of the largest submatrix within matrix where every element of the submatrix is 1 after reordering the columns optimally.

Example 1:

Input: matrix = [[0,0,1],[1,1,1],[1,0,1]]
Output: 4
Explanation: You can rearrange the columns as shown above.
The largest submatrix of 1s, in bold, has an area of 4.

Example 2:

Input: matrix = [[1,0,1,0,1]]
Output: 3
Explanation: You can rearrange the columns as shown above.
The largest submatrix of 1s, in bold, has an area of 3.

Example 3:

Input: matrix = [[1,1,0],[1,0,1]]
Output: 2
Explanation: Notice that you must rearrange entire columns, and there is no way to make a submatrix of 1s larger than an area of 2.

Example 4:

Input: matrix = [[0,0],[0,0]]
Output: 0
Explanation: As there are no 1s, no submatrix of 1s can be formed and the area is 0.

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m * n <= 105
• matrix[i][j] is 0 or 1.

Solution: DP + Sorting

Preprocess each column, for col j, matrix[i][j] := length consecutive ones of col j.

[0,0,1]    [0,0,1]
[1,1,1] => [1,1,2]
[1,0,1]    [2,0,3]

Then we enumerate ending row, for each ending row i, we sort row[i] in deceasing order

e.g. i = 2

[0,0,1]                  [-,-,-]
[1,1,2] sort by row 2 => [-,-,-]
[2,0,3]                  [3,2,0]

row[2][1] = 3, means there is a 3×1 all ones sub matrix, area = 3
row[2][2] = 2, means there is a 2×2 all ones sub matrix, area = 4.

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

// Author: Huahua
class Solution {
public:
  int largestSubmatrix(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    for (int j = 0; j < n; ++j)
      for (int i = 1; i < m; ++i)      
        if (matrix[i][j]) matrix[i][j] += matrix[i - 1][j];          
    
    int ans = 0;
    for (int i = 0; i < m; ++i) {
      sort(rbegin(matrix[i]), rend(matrix[i]));
      for (int j = 0; j < n; ++j)
        ans = max(ans, (j + 1) * matrix[i][j]);        
    }
    return ans;    
  }
};

The post 花花酱 LeetCode 1727. Largest Submatrix With Rearrangements appeared first on Huahua's Tech Road.

A customer’s wealth is the amount of money they have in all their bank accounts. The richest customer is the customer that has the maximum wealth.

Example 1:

Input: accounts = [[1,2,3],[3,2,1]]
Output: 6
Explanation:
1st customer has wealth = 1 + 2 + 3 = 6
2nd customer has wealth = 3 + 2 + 1 = 6
Both customers are considered the richest with a wealth of 6 each, so return 6.

Example 2:

Input: accounts = [[1,5],[7,3],[3,5]]
Output: 10
Explanation: 
1st customer has wealth = 6
2nd customer has wealth = 10 
3rd customer has wealth = 8
The 2nd customer is the richest with a wealth of 10.

Example 3:

Input: accounts = [[2,8,7],[7,1,3],[1,9,5]]
Output: 17

Constraints:

• m == accounts.length
• n == accounts[i].length
• 1 <= m, n <= 50
• 1 <= accounts[i][j] <= 100

Solution: Sum each row up

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

// Author: Huahua
class Solution {
public:
  int maximumWealth(vector<vector<int>>& accounts) {
    int ans = 0;
    for (const vector<int>& row : accounts)
      ans = max(ans, accumulate(begin(row), end(row), 0));
    return ans;
  }
};

# Author: Huahua
class Solution:
  def maximumWealth(self, accounts: List[List[int]]) -> int:
    return max(sum(account) for account in accounts)

The post 花花酱 LeetCode 1672. Richest Customer Wealth appeared first on Huahua's Tech Road.

The rank is an integer that represents how large an element is compared to other elements. It is calculated using the following rules:

• The rank is an integer starting from 1.
• If two elements p and q are in the same row or column, then:
  • If p < q then rank(p) < rank(q)
  • If p == q then rank(p) == rank(q)
  • If p > q then rank(p) > rank(q)
• The rank should be as small as possible.

It is guaranteed that answer is unique under the given rules.

Example 1:

Input: matrix = [[1,2],[3,4]]
Output: [[1,2],[2,3]]
Explanation:
The rank of matrix[0][0] is 1 because it is the smallest integer in its row and column.
The rank of matrix[0][1] is 2 because matrix[0][1] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][0] is 2 because matrix[1][0] > matrix[0][0] and matrix[0][0] is rank 1.
The rank of matrix[1][1] is 3 because matrix[1][1] > matrix[0][1], matrix[1][1] > matrix[1][0], and both matrix[0][1] and matrix[1][0] are rank 2.

Example 2:

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

Example 3:

Input: matrix = [[20,-21,14],[-19,4,19],[22,-47,24],[-19,4,19]]
Output: [[4,2,3],[1,3,4],[5,1,6],[1,3,4]]

Example 4:

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

Constraints:

• m == matrix.length
• n == matrix[i].length
• 1 <= m, n <= 500
• -109 <= matrix[row][col] <= 109

Solution: Union Find

Group cells by their values, process groups (cells that have the same value) in ascending order (smaller number has smaller rank).

For cells that are in the same row and same cols union them using union find, they should have the same rank which equals to max(max_rank_x[cols], max_rank_y[rows]) + 1.

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

// Author: Huahua
class DSU {
public:
  DSU(int n): p_(n, -1) {}
  int find(int x) {
    return p_[x] == -1 ? x : p_[x] = find(p_[x]);
  }  
  void merge(int x, int y) {
    x = find(x), y = find(y);
    if (x != y) p_[x] = y;    
  }
private:
  vector<int> p_;
};

class Solution {
public:
  vector<vector<int>> matrixRankTransform(vector<vector<int>>& matrix) {
    const int m = matrix.size();
    const int n = matrix[0].size();
    vector<vector<int>> ans(m, vector<int>(n));
    map<int, vector<pair<int, int>>> mp; // val -> {positions}
    for (int y = 0; y < m; ++y)
      for (int x = 0; x < n; ++x)
        mp[matrix[y][x]].emplace_back(x, y);
    vector<int> rx(n), ry(m);
    for (const auto& [val, ps]: mp) {
      DSU dsu(n + m);
      vector<vector<pair<int, int>>> cc(n + m); // val -> {positions}
      for (const auto& [x, y]: ps)
        dsu.merge(x, y + n);
      for (const auto& [x, y]: ps)        
        cc[dsu.find(x)].emplace_back(x, y);      
      for (const auto& ps: cc) {
        int rank = 1;
        for (const auto& [x, y]: ps)
          rank = max(rank, max(rx[x], ry[y]) + 1);
        for (const auto& [x, y]: ps)
          rx[x] = ry[y] = ans[y][x] = rank;   
      }      
    }
    return ans;
  }
};

The post 花花酱 LeetCode 1632. Rank Transform of a Matrix appeared first on Huahua's Tech Road.

Find any matrix of non-negative integers of size rowSum.length x colSum.length that satisfies the rowSum and colSum requirements.

Return a 2D array representing any matrix that fulfills the requirements. It’s guaranteed that at least one matrix that fulfills the requirements exists.

Example 1:

Input: rowSum = [3,8], colSum = [4,7]
Output: [[3,0],
         [1,7]]
Explanation:
0th row: 3 + 0 = 0 == rowSum[0]
1st row: 1 + 7 = 8 == rowSum[1]
0th column: 3 + 1 = 4 == colSum[0]
1st column: 0 + 7 = 7 == colSum[1]
The row and column sums match, and all matrix elements are non-negative.
Another possible matrix is: [[1,2],
                             [3,5]]

Example 2:

Input: rowSum = [5,7,10], colSum = [8,6,8]
Output: [[0,5,0],
         [6,1,0],
         [2,0,8]]

Example 3:

Input: rowSum = [14,9], colSum = [6,9,8]
Output: [[0,9,5],
         [6,0,3]]

Example 4:

Input: rowSum = [1,0], colSum = [1]
Output: [[1],
         [0]]

Example 5:

Input: rowSum = [0], colSum = [0]
Output: [[0]]

Constraints:

• 1 <= rowSum.length, colSum.length <= 500
• 0 <= rowSum[i], colSum[i] <= 108
• sum(rows) == sum(columns)

Solution: Greedy

Let a = min(row[i], col[j]), m[i][j] = a, row[i] -= a, col[j] -=a

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

// Author: Huahua
class Solution {
public:
  vector<vector<int>> restoreMatrix(vector<int>& rowSum, vector<int>& colSum) {
    const int m = rowSum.size();
    const int n = colSum.size();
    vector<vector<int>> ans(m, vector<int>(n));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        ans[i][j] = min(rowSum[i], colSum[j]);
        rowSum[i] -= ans[i][j];
        colSum[j] -= ans[i][j];
      }
    return ans;
  }
};

The post 花花酱 LeetCode 1605. Find Valid Matrix Given Row and Column Sums appeared first on Huahua's Tech Road.

Among all possible paths starting from the top-left corner (0, 0) and ending in the bottom-right corner (rows - 1, cols - 1), find the path with the maximum non-negative product. The product of a path is the product of all integers in the grid cells visited along the path.

Return the maximum non-negative product modulo 109 + 7. If the maximum product is negative return -1.

Notice that the modulo is performed after getting the maximum product.

Example 1:

Input: grid = [[-1,-2,-3],
               [-2,-3,-3],
               [-3,-3,-2]]
Output: -1
Explanation: It's not possible to get non-negative product in the path from (0, 0) to (2, 2), so return -1.

Example 2:

Input: grid = [[1,-2,1],
               [1,-2,1],
               [3,-4,1]]
Output: 8
Explanation: Maximum non-negative product is in bold (1 * 1 * -2 * -4 * 1 = 8).

Example 3:

Input: grid = [[1, 3],
               [0,-4]]
Output: 0
Explanation: Maximum non-negative product is in bold (1 * 0 * -4 = 0).

Example 4:

Input: grid = [[ 1, 4,4,0],
               [-2, 0,0,1],
               [ 1,-1,1,1]]
Output: 2
Explanation: Maximum non-negative product is in bold (1 * -2 * 1 * -1 * 1 * 1 = 2).

Constraints:

• 1 <= rows, cols <= 15
• -4 <= grid[i][j] <= 4

Solution: DP

Use two dp arrays,

dp_max[i][j] := max product of matrix[0~i][0~j]
dp_min[i][j] := min product of matrix[0~i][0~j]

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

// Author: Huahua
class Solution {
public:
  int maxProductPath(vector<vector<int>>& grid) {
    constexpr int kMod = 1e9 + 7;
    const int m = grid.size();
    const int n = grid[0].size();
    vector<vector<long>> dp_max(m, vector<long>(n));
    vector<vector<long>> dp_min(m, vector<long>(n));
    dp_max[0][0] = dp_min[0][0] = grid[0][0];
    for (int i = 1; i < m; ++i)
      dp_max[i][0] = dp_min[i][0] = dp_min[i - 1][0] * grid[i][0];
    for (int j = 1; j < n; ++j)
      dp_max[0][j] = dp_min[0][j] = dp_min[0][j - 1] * grid[0][j];
    for (int i = 1; i < m; ++i)
      for (int j = 1; j < n; ++j) {        
        if (grid[i][j] >= 0) {
          dp_max[i][j] = max(dp_max[i - 1][j], dp_max[i][j - 1]) * grid[i][j];
          dp_min[i][j] = min(dp_min[i - 1][j], dp_min[i][j - 1]) * grid[i][j];
        } else {
          dp_max[i][j] = min(dp_min[i - 1][j], dp_min[i][j - 1]) * grid[i][j];
          dp_min[i][j] = max(dp_max[i - 1][j], dp_max[i][j - 1]) * grid[i][j];
        }
      }
    return dp_max[m - 1][n - 1] >= 0 ? dp_max[m - 1][n - 1] % kMod : -1;
  }
};

The post 花花酱 LeetCode 1594. Maximum Non Negative Product in a Matrix appeared first on Huahua's Tech Road.

A position (i,j) is called special if mat[i][j] == 1 and all other elements in row i and column j are 0 (rows and columns are 0-indexed).

Example 1:

Input: mat = [[1,0,0],
              [0,0,1],
              [1,0,0]]
Output: 1
Explanation: (1,2) is a special position because mat[1][2] == 1 and all other elements in row 1 and column 2 are 0.

Example 2:

Input: mat = [[1,0,0],
              [0,1,0],
              [0,0,1]]
Output: 3
Explanation: (0,0), (1,1) and (2,2) are special positions. 

Example 3:

Input: mat = [[0,0,0,1],
              [1,0,0,0],
              [0,1,1,0],
              [0,0,0,0]]
Output: 2

Example 4:

Input: mat = [[0,0,0,0,0],
              [1,0,0,0,0],
              [0,1,0,0,0],
              [0,0,1,0,0],
              [0,0,0,1,1]]
Output: 3

Constraints:

• rows == mat.length
• cols == mat[i].length
• 1 <= rows, cols <= 100
• mat[i][j] is 0 or 1.

Solution: Sum for each row and column

Brute force:
Time complexity: O(R*C*(R+C))
Space complexity: O(1)

We can pre-compute the sums for each row and each column, ans = sum(mat[r][c] == 1 and rsum[r] == 1 and csum[c] == 1)

Time complexity: O(R*C)
Space complexity: O(R+C)

class Solution {
public:
  int numSpecial(vector<vector<int>>& mat) {
    const int rows = mat.size();
    const int cols = mat[0].size();
    vector<int> rs(rows);
    vector<int> cs(cols);
    for (int r = 0; r < rows; ++r)
      for (int c = 0; c < cols; ++c) {
        rs[r] += mat[r][c];
        cs[c] += mat[r][c];
      }
    int ans = 0;
    for (int r = 0; r < rows; ++r)
      for (int c = 0; c < cols; ++c)
        ans += mat[r][c] && rs[r] == 1 && cs[c] == 1;      
    return ans;
  }
};

The post 花花酱 LeetCode 1582. Special Positions in a Binary Matrix appeared first on Huahua's Tech Road.