Only include the sum of all the elements on the primary diagonal and all the elements on the secondary diagonal that are not part of the primary diagonal.

Example 1:

Input: mat = [[1,2,3],
              [4,5,6],
              [7,8,9]]
Output: 25
Explanation: Diagonals sum: 1 + 5 + 9 + 3 + 7 = 25
Notice that element mat[1][1] = 5 is counted only once.

Example 2:

Input: mat = [[1,1,1,1],
              [1,1,1,1],
              [1,1,1,1],
              [1,1,1,1]]
Output: 8

Example 3:

Input: mat = [[5]]
Output: 5

Constraints:

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

Solution: Brute Force

Note: if n is odd, be careful not to double count the center one.

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

class Solution {
public:
  int diagonalSum(vector<vector<int>>& mat) {
    const int n = mat.size();
    int ans = 0;
    for (int i = 0; i < n; ++i)
      ans += mat[i][i] + mat[i][n - i - 1];
    if (n & 1) ans -= mat[n / 2][n / 2];
    return ans;
  }
};

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

Given a list of lists of integers, nums, return all elements of nums in diagonal order as shown in the below images.

Example 1:

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

Example 2:

Input: nums = [[1,2,3,4,5],[6,7],[8],[9,10,11],[12,13,14,15,16]]
Output: [1,6,2,8,7,3,9,4,12,10,5,13,11,14,15,16]

Example 3:

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

Example 4:

Input: nums = [[1,2,3,4,5,6]]
Output: [1,2,3,4,5,6]

Constraints:

• 1 <= nums.length <= 10^5
• 1 <= nums[i].length <= 10^5
• 1 <= nums[i][j] <= 10^9
• There at most 10^5 elements in nums.

Solution: Hashtable

Use diagonal index (i + j) as key.

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

// Author: Huahua
class Solution {
public:
  vector<int> findDiagonalOrder(vector<vector<int>>& nums) {
    vector<vector<int>> m;    
    for (int i = 0; i < nums.size(); ++i)
      for (int j = 0; j < nums[i].size(); ++j) {
        if (m.size() <= i + j) m.push_back({});
        m[i + j].push_back(nums[i][j]);
    }
    vector<int> ans;    
    for (const auto& d : m)
      ans.insert(end(ans), rbegin(d), rend(d));
    return ans;
  }
};

# Author: Huahua
class Solution:
  def findDiagonalOrder(self, nums):
    m = []
    for i, row in enumerate(nums):
      for j, v in enumerate(row):
        if i + j >= len(m): m.append([])
        m[i+j].append(v)
    return [v for d in m for v in reversed(d)]

The post 花花酱 LeetCode 1424. Diagonal Traverse II appeared first on Huahua's Tech Road.

Example 1:

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

Constraints:

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

Solution: HashTable

Collect each diagonal’s (keyed by i – j) elements into an array and sort it separately.
If we offset the key by n, e.g. i – j + n, we can use an array instead of a hashtable.

Time complexity: O(m*n + (m+n) * (m+n) * log(m + n))) = (n^2*logn)
Space complexity: O(m*n)

// Author: Huahua
class Solution {
public:
  vector<vector<int>> diagonalSort(vector<vector<int>>& mat) {
    const int m = mat.size();
    const int n = mat[0].size();
    vector<deque<int>> qs(m + n);
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j)
        qs[i - j + n].push_back(mat[i][j]);
    for (auto& q : qs)
      sort(begin(q), end(q));
    for (int i = 0; i < m; ++i)
      for (int j = 0; j < n; ++j) {
        mat[i][j] = qs[i - j + n].front();
        qs[i - j + n].pop_front();
      }
    return mat;
  }
};

The post 花花酱 LeetCode 1329. Sort the Matrix Diagonally appeared first on Huahua's Tech Road.