Uncategorized – Huahua's Tech Road

花花酱 LeetCode 1281. Subtract the Product and Sum of Digits of an Integer

By zxi on December 8, 2019

Given an integer number n, return the difference between the product of its digits and the sum of its digits.

Example 1:

Input: n = 234

Output: 15

Explanation:

Product of digits = 2 * 3 * 4 = 24

Sum of digits = 2 + 3 + 4 = 9

Result = 24 - 9 = 15

Example 2:

Input: n = 4421

Output: 21

Explanation:

Product of digits = 4 * 4 * 2 * 1 = 32

Sum of digits = 4 + 4 + 2 + 1 = 11

Result = 32 - 11 = 21

Constraints:

1 <= n <= 10^5

Solution: Simulation

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

C++

// Author: Huahua

class Solution {

public:

int subtractProductAndSum(int n) {

int p = 1;

int s = 0;

while (n) {

const int d = n % 10;

p *= d;

s += d;

n /= 10;

}

return p - s;

}

};

花花酱 LeetCode 59. Spiral Matrix II

By zxi on September 30, 2019

Given a positive integer n, generate a square matrix filled with elements from 1 to n² in spiral order.

Example:

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

Solution: Simulation

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

C++

// Author: Huahua

class Solution {

public:

vector<vector<int> > generateMatrix(int n) {

vector<vector<int>> ans(n, vector<int>(n));

int dir = 2, x = 0, y = 0;

int max_x = n - 1, max_y = n - 1;

int min_x = 0, min_y = 1;

int i = 0;

while (++i <= n*n) {

ans[y][x] = i;

switch (dir) {

// up

case 1: if (--y == min_y) { dir = 2; ++min_y; } break;

// right

case 2: if (++x == max_x) { dir = 3; --max_x; } break;

// down

case 3: if (++y == max_y) { dir = 4; --max_y; } break;

// left

case 4: if (--x == min_x) { dir = 1; ++min_x; } break;

}

return ans;

}

};

花花酱 LeetCode 226. Invert Binary Tree

By zxi on July 23, 2019

Invert a binary tree.

Example:

Input:

     4
   /   \
  2     7
 / \   / \
1   3 6   9

Output:

     4
   /   \
  7     2
 / \   / \
9   6 3   1

Trivia:
This problem was inspired by this original tweet by Max Howell:

Google: 90% of our engineers use the software you wrote (Homebrew), but you can’t invert a binary tree on a whiteboard so f*** off.

Solution: Recursion

Recursive invert the left and right subtrees and swap them.

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

C++

// Author: Huahua

class Solution {

public:

TreeNode* invertTree(TreeNode* root) {

if (!root) return nullptr;

TreeNode* tmp = root->right;

root->right = invertTree(root->left);

root->left = invertTree(tmp);

return root;

}

};

Python3

# Author: Huahua

class Solution:

def invertTree(self, root: TreeNode) -> TreeNode:

if not root: return None

root.left, root.right = self.invertTree(root.right), self.invertTree(root.left)

return root

花花酱 LeetCode 1124. Longest Well-Performing Interval

By zxi on July 14, 2019

We are given hours, a list of the number of hours worked per day for a given employee.

A day is considered to be a tiring day if and only if the number of hours worked is (strictly) greater than 8.

A well-performing interval is an interval of days for which the number of tiring days is strictly larger than the number of non-tiring days.

Return the length of the longest well-performing interval.

Example 1:

Input: hours = [9,9,6,0,6,6,9]
Output: 3
Explanation: The longest well-performing interval is [9,9,6].

Constraints:

1 <= hours.length <= 10000
0 <= hours[i] <= 16

Solution: Target sum == 1

This problem can be reduced to find the longest subarray with sum of 1, or the longest subarray starting from left-most that has a sum greater than 0.

e.g. [6, 6, (6, 9, 9), 6, 6] => sum = 1
e.g. [9, 9, 9] => sum = 3

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

C++

// Author: Huahua

class Solution {

public:

int longestWPI(vector<int>& hours) {

const int n = hours.size();

for (int& v : hours) v = v > 8 ? 1 : -1;

int s = 0;

unordered_map<int, int> idx;

int ans = 0;

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

s += hours[i];

if (s > 0)

ans = i + 1;

if (!idx.count(s))

idx[s] = i;

if (idx.count(s - 1))

ans = max(ans, i - idx[s - 1]);

}

return ans;

}

};

花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020)

By zxi on March 31, 2019

1017. Convert to Base -2

Solution: Math / Simulation

Time complexity: O(logn)
Space complexity: O(logn)

C++

// Author: Huahua

class Solution {

public:

string baseNeg2(int N) {

if (N == 0) return "0";

vector<char> ans;

while (N) {

ans.push_back((N & 1) + '0');

N = -(N >> 1);

}

return {rbegin(ans), rend(ans)};

}

};

base K

// Author: Huahua

class Solution {

public:

string baseNeg2(int N) {

if (N == 0) return "0";

return baseNegK(N, -2);

}

private:

string baseNegK(int N, int K) {

vector<char> ans;

while (N) {

int r = N % K;

N /= K;

if (r < 0) {

r += -K;

N += 1;

}

ans.push_back(r + '0');

}

return {rbegin(ans), rend(ans)};

}

};

1018. Binary Prefix Divisible By 5

Solution: Math

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

C++

// Author: Huahua

class Solution {

public:

vector<bool> prefixesDivBy5(vector<int>& A) {

int num = 0;

vector<bool> ans(A.size());

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

num = ((num << 1) | A[i]) % 5;

ans[i] = num == 0;

}

return ans;

}

};

1019. Next Greater Node In Linked List

Solution: Reverse + Monotonic Stack

Process in reverse order and keep a monotonically increasing stack, pop all the elements that are smaller than the current one, then the top of the stack (if exists) will be the next greater node.

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

C++

// Author: Huahua

class Solution {

public:

vector<int> nextLargerNodes(ListNode* head) {

vector<int> nums;

while (head) {

nums.push_back(head->val);

head = head->next;

}

stack<int> s;

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

for (int i = nums.size() - 1; i >= 0; --i) {

while (!s.empty() && s.top() <= nums[i]) s.pop();

ans[i] = s.empty() ? 0 : s.top();

s.push(nums[i]);

}

return ans;

}

};

1020. Number of Enclaves

Solution: DFS / Connected Components

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

C++

// Author: Huahua

class Solution {

public:

int numEnclaves(vector<vector<int>>& A) {

int ans = 0;

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

for (int j = 0; j < A[0].size(); ++j) {

int count = 0;

if (!dfs(A, j, i, count))

ans += count;

}

return ans;

}

private:

static constexpr int dirs[5]{0, -1, 0, 1, 0};

bool dfs(vector<vector<int>>& A, int x, int y, int& count) {

if (x < 0 || x == A[0].size() || y < 0 || y == A.size()) return true;

if (A[y][x] == 0) return false;

++count;

A[y][x] = 0;

bool valid = false;

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

valid |= dfs(A, x + dirs[i], y + dirs[i + 1], count);

return valid;

}

};

Posts published in “Uncategorized”

花花酱 LeetCode 1281. Subtract the Product and Sum of Digits of an Integer

Solution: Simulation

C++

花花酱 LeetCode 59. Spiral Matrix II

Solution: Simulation

C++

花花酱 LeetCode 226. Invert Binary Tree

Solution: Recursion

C++

Python3

花花酱 LeetCode 1124. Longest Well-Performing Interval

Solution: Target sum == 1

C++

花花酱 LeetCode Weekly Contest 130 (1017, 1018, 1019, 1020)

1017. Convert to Base -2

C++

base K

1018. Binary Prefix Divisible By 5

C++

1019. Next Greater Node In Linked List

C++

1020. Number of Enclaves

C++