array – Page 22 – Huahua’s Tech Road

花花酱 LeetCode 1351. Count Negative Numbers in a Sorted Matrix

By zxi on February 16, 2020

Given a m * n matrix grid which is sorted in non-increasing order both row-wise and column-wise.

Return the number of negative numbers in grid.

Example 1:

Input: grid = [[4,3,2,-1],[3,2,1,-1],[1,1,-1,-2],[-1,-1,-2,-3]]
Output: 8
Explanation: There are 8 negatives number in the matrix.

Example 2:

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

Example 3:

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

Example 4:

Input: grid = [[-1]]
Output: 1

Constraints:

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

Solution 1: Brute Force

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

C++

// Author: Huahua, 16 ms, 10.4 MB

class Solution {

public:

int countNegatives(vector<vector<int>>& grid) {

int ans = 0;

for (const auto& row : grid)

for (const auto x : row)

ans += x < 0;

return ans;

}

};

Solution 2: Find the frontier

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

C++

// Author: Huahua, 16 ms, 10.4 MB

class Solution {

public:

int countNegatives(vector<vector<int>>& grid) {

int ans = 0;

int m = grid.size();

int n = grid[0].size();

int r = m - 1;

int c = 0;

while (r >= 0 && c < n) {

if (grid[r][c] < 0) {

ans += n - c;

--r;

} else {

++c;

}

return ans;

}

};

花花酱 LeetCode 1331. Rank Transform of an Array

By zxi on January 26, 2020

Given an array of integers arr, replace each element with its rank.

The rank represents how large the element is. The rank has the following rules:

Rank is an integer starting from 1.
The larger the element, the larger the rank. If two elements are equal, their rank must be the same.
Rank should be as small as possible.

Example 1:

Input: arr = [40,10,20,30]
Output: [4,1,2,3]
Explanation: 40 is the largest element. 10 is the smallest. 20 is the second smallest. 30 is the third smallest.

Example 2:

Input: arr = [100,100,100]
Output: [1,1,1]
Explanation: Same elements share the same rank.

Example 3:

Input: arr = [37,12,28,9,100,56,80,5,12]
Output: [5,3,4,2,8,6,7,1,3]

Constraints:

0 <= arr.length <= 10⁵
-10⁹ <= arr[i] <= 10⁹

Solution: Sorting + HashTable

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

C++

// Author: Huahua

class Solution {

public:

vector<int> arrayRankTransform(vector<int>& arr) {

set<int> s(begin(arr), end(arr));

unordered_map<int, int> m;

int r = 0;

for (const int v : s) m[v] = ++r;

vector<int> ans(arr.size());

for (int i = 0; i < arr.size(); ++i)

ans[i] = m[arr[i]];

return ans;

}

};

花花酱 LeetCode 1330. Reverse Subarray To Maximize Array Value

By zxi on January 26, 2020

You are given an integer array nums. The value of this array is defined as the sum of |nums[i]-nums[i+1]| for all 0 <= i < nums.length-1.

You are allowed to select any subarray of the given array and reverse it. You can perform this operation only once.

Find maximum possible value of the final array.

Example 1:

Input: nums = [2,3,1,5,4]
Output: 10
Explanation: By reversing the subarray [3,1,5] the array becomes [2,5,1,3,4] whose value is 10.

Example 2:

Input: nums = [2,4,9,24,2,1,10]
Output: 68

Constraints:

1 <= nums.length <= 3*10^4
-10^5 <= nums[i] <= 10^5

Solution: Greedy

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

C++

// Author: Huahua

class Solution {

public:

int maxValueAfterReverse(vector<int>& nums) {

const int n = nums.size();

int sum = 0;

int gain = 0;

int hi = INT_MIN;

int lo = INT_MAX;

for (int i = 0; i < n - 1; ++i) {

int n1 = nums[i];

int n2 = nums[i + 1];

sum += abs(n1 - n2);

gain = max({gain,

abs(nums[0] - n2) - abs(n1 - n2),

abs(nums[n - 1] - n1) - abs(n1 - n2)});

hi = max(hi, min(n1, n2));

lo = min(lo, max(n1, n2));

}

return sum + max(gain, (hi - lo) * 2);

}

};

花花酱 LeetCode 42. Trapping Rain Water

By zxi on January 15, 2020

Given n non-negative integers representing an elevation map where the width of each bar is 1, compute how much water it is able to trap after raining.

The above elevation map is represented by array [0,1,0,2,1,0,1,3,2,1,2,1]. In this case, 6 units of rain water (blue section) are being trapped. Thanks Marcos for contributing this image!

Example:

Input: [0,1,0,2,1,0,1,3,2,1,2,1]
Output: 6

Solution 1: Brute Force

r[i] = min(max(h[0:i+1]), max(h[i:n]))
ans = sum(r[i])

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

C++

// Author: Huahua

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

int ans = 0;

auto sit = cbegin(height);

auto eit = cend(height);

for (int i = 0; i < n; ++i) {

int l = *max_element(sit, sit + i + 1);

int r = *max_element(sit + i, eit);

ans += min(l, r) - height[i];

}

return ans;

}

};

Solution 2: DP

l[i] := max(h[0:i+1])
r[i] := max(h[i:n])
ans = sum(min(l[i], r[i]) – h[i])

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

C++

// Author: Huahua

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

vector<int> l(n);

vector<int> r(n);

int ans = 0;

for (int i = 0; i < n; ++i)

l[i] = i == 0 ? height[i] : max(l[i - 1], height[i]);

for (int i = n - 1; i >= 0; --i)

r[i] = i == n - 1 ? height[i] : max(r[i + 1], height[i]);

for (int i = 0; i < n; ++i)

ans += min(l[i], r[i]) - height[i];

return ans;

}

};

Solution 3: Two Pointers

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

C++

// Author: Huahua, 4 ms, 9.1 MB

class Solution {

public:

int trap(vector<int>& height) {

const int n = height.size();

if (n == 0) return 0;

int l = 0;

int r = n - 1;

int max_l = height[l];

int max_r = height[r];

int ans = 0;

while (l < r) {

if (max_l < max_r) {

ans += max_l - height[l];

max_l = max(max_l, height[++l]);

} else {

ans += max_r - height[r];

max_r = max(max_r, height[--r]);

}

return ans;

}

};

花花酱 LeetCode 1304. Find N Unique Integers Sum up to Zero

By zxi on December 29, 2019

Given an integer n, return any array containing n unique integers such that they add up to 0.

Example 1:

Input: n = 5
Output: [-7,-1,1,3,4]
Explanation: These arrays also are accepted [-5,-1,1,2,3] , [-3,-1,2,-2,4].

Example 2:

Input: n = 3
Output: [-1,0,1]

Example 3:

Input: n = 1
Output: [0]

Constraints:

1 <= n <= 1000

Solution: Generation

Use numbers from {-n/2, … n/2} + {0 if n is odd}

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

C++

// Author: Huahua

class Solution {

public:

vector<int> sumZero(int n) {

vector<int> ans;

for (int i = 1; i <= n / 2; ++i) {

ans.push_back(i);

ans.push_back(-i);

}

if (ans.size() != n) ans.push_back(0);

return ans;

}

};

Posts tagged as “array”

花花酱 LeetCode 1351. Count Negative Numbers in a Sorted Matrix

Solution 1: Brute Force

C++

Solution 2: Find the frontier

C++

花花酱 LeetCode 1331. Rank Transform of an Array

Solution: Sorting + HashTable

C++

花花酱 LeetCode 1330. Reverse Subarray To Maximize Array Value

Solution: Greedy

C++

花花酱 LeetCode 42. Trapping Rain Water

Solution 1: Brute Force

C++

Solution 2: DP

C++

Solution 3: Two Pointers

C++

花花酱 LeetCode 1304. Find N Unique Integers Sum up to Zero

Solution: Generation

C++