Posts published in “Difficulty”

花花酱 LeetCode 783. Minimum Distance Between BST Nodes

By zxi on February 10, 2018

Given a Binary Search Tree (BST) with the root node root, return the minimum difference between the values of any two different nodes in the tree.

Example :

Input: root = [4,2,6,1,3,null,null]

Output: 1

Explanation:

Note that root is a TreeNode object, not an array.

The given tree [4,2,6,1,3,null,null] is represented by the following diagram:

/ \

2 6

/ \

1 3

while the minimum difference in this tree is 1, it occurs between node 1 and node 2, also between node 3 and node 2.

Note:

The size of the BST will be between 2 and 100.
The BST is always valid, each node’s value is an integer, and each node’s value is different.

Solution 1: In order traversal

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 783

class Solution {

public:

int minDiffInBST(TreeNode* root) {

min_diff_ = INT_MAX;

prev_ = nullptr;

minDiff(root);

return min_diff_;

}

private:

int min_diff_;

int* prev_;

void minDiff(TreeNode* root) {

if (root == nullptr) return;

minDiff(root->left);

if (prev_ != nullptr)

min_diff_ = min(min_diff_, abs(root->val - *prev_));

prev_ = &root->val;

minDiff(root->right);

}

};

Related Problems:

花花酱 LeetCode 530. Minimum Absolute Difference in BST

花花酱 LeetCode 769. Max Chunks To Make Sorted

By zxi on February 2, 2018

题目大意：给你一个0 ~ n-1的排列，问你最多能分成几组，每组分别排序后能够组成0 ~ n-1。

Given an array arr that is a permutation of [0, 1, ..., arr.length - 1], we split the array into some number of “chunks” (partitions), and individually sort each chunk. After concatenating them, the result equals the sorted array.

What is the most number of chunks we could have made?

Example 1:

Input: arr = [4,3,2,1,0]

Output: 1

Explanation:

Splitting into two or more chunks will not return the required result.

For example, splitting into [4, 3], [2, 1, 0] will result in [3, 4, 0, 1, 2], which isn't sorted.

Example 2:

Input: arr = [1,0,2,3,4]

Output: 4

Explanation:

We can split into two chunks, such as [1, 0], [2, 3, 4].

However, splitting into [1, 0], [2], [3], [4] is the highest number of chunks possible.

Note:

arr will have length in range [1, 10].
arr[i] will be a permutation of [0, 1, ..., arr.length - 1].

Solution 1: Max so far / Set

Time complexity: O(nlogn)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 3 ms

class Solution {

public:

int maxChunksToSorted(vector<int>& arr) {

int ans = 0;

set<int> s;

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

s.insert(arr[i]);

if (*s.rbegin() == i) ++ans;

}

return ans;

}

};

Solution 2: Max so far

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int maxChunksToSorted(vector<int>& arr) {

int ans = 0;

int m = 0;

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

m = max(m, arr[i]);

if (m == i) ++ans;

}

return ans;

}

};

Java

// Author: Huahua

// Running time: 5 ms

class Solution {

public int maxChunksToSorted(int[] arr) {

int max = 0;

int ans = 0;

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

max = Math.max(max, arr[i]);

if (max == i) ++ans;

}

return ans;

}

Python3

"""

Author: Huahua

Running time: 53 ms

"""

class Solution:

def maxChunksToSorted(self, arr):

m = 0

ans = 0

for i, n in enumerate(arr):

if n > m: m = n

if m == i: ans += 1

return ans

花花酱 LeetCode 766. Toeplitz Matrix

By zxi on February 2, 2018

A matrix is Toeplitz if every diagonal from top-left to bottom-right has the same element.

Now given an M x N matrix, return True if and only if the matrix is Toeplitz.
Example 1:

Input: matrix = [[1,2,3,4],[5,1,2,3],[9,5,1,2]]

Output: True

Explanation:

1234

5123

9512

In the above grid, the diagonals are "[9]", "[5, 5]", "[1, 1, 1]", "[2, 2, 2]", "[3, 3]", "[4]", and in each diagonal all elements are the same, so the answer is True.

Example 2:

Input: matrix = [[1,2],[2,2]]

Output: False

Explanation:

The diagonal "[1, 2]" has different elements.

Note:

matrix will be a 2D array of integers.
matrix will have a number of rows and columns in range [1, 20].
matrix[i][j] will be integers in range [0, 99].

Idea:

Check m[i][j] with m[i-1][j-1]

Solution: Brute Force

Time complexity: O(n*m)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 32 ms

class Solution {

public:

bool isToeplitzMatrix(vector<vector<int>>& matrix) {

for (int i = 1; i < matrix.size(); ++i)

for (int j = 1; j < matrix[0].size(); ++j)

if (matrix[i][j] != matrix[i - 1][j - 1]) return false;

return true;

}

};

Java

// Author: Huahua

// Running time: 29 ms

class Solution {

public boolean isToeplitzMatrix(int[][] matrix) {

for (int i = 1; i < matrix.length; ++i)

for (int j = 1; j < matrix[0].length; ++j)

if (matrix[i][j] != matrix[i - 1][j - 1]) return false;

return true;

}

Python3

"""

Author: Huahua

Running time: 99 ms

"""

class Solution:

def isToeplitzMatrix(self, matrix):

m = len(matrix)

n = len(matrix[0])

for i in range(1, m):

for j in range(1, n):

if matrix[i][j] != matrix[i - 1][j - 1]: return False

return True

花花酱 LeetCode 282. Expression Add Operators

By zxi on January 30, 2018

题目大意：给你一个字符串，让你在数字之间加上+,-,*使得等式的值等于target。让你输出所有满足条件的表达式。

Given a string that contains only digits 0-9 and a target value, return all possibilities to add binary operators (not unary) +, -, or * between the digits so they evaluate to the target value.

Examples:

"123", 6 -> ["1+2+3", "1*2*3"]

"232", 8 -> ["2*3+2", "2+3*2"]

"105", 5 -> ["1*0+5","10-5"]

"00", 0 -> ["0+0", "0-0", "0*0"]

"3456237490", 9191 -> []

Slides:

Solution 1: DFS

Time complexity: O(4^n)

Space complexity: O(n^2) -> O(n)

C++

// Author: Huahua

// Running time: 128 ms (<79.97%)

class Solution {

public:

vector<string> addOperators(string num, int target) {

vector<string> ans;

dfs(num, target, 0, "", 0, 0, &ans);

return ans;

}

private:

void dfs(const string& num, const int target, // input

int pos, const string& exp, long prev, long curr, // state

vector<string>* ans) { // output

if (pos == num.length()) {

if (curr == target) ans->push_back(exp);

return;

}

for (int l = 1; l <= num.size() - pos; ++l) {

string t = num.substr(pos, l);

if (t[0] == '0' && t.length() > 1) break; // 0X...

long n = std::stol(t);

if (n > INT_MAX) break;

if (pos == 0) {

dfs(num, target, l, t, n, n, ans);

continue;

}

dfs(num, target, pos + l, exp + '+' + t, n, curr + n, ans);

dfs(num, target, pos + l, exp + '-' + t, -n, curr - n, ans);

dfs(num, target, pos + l, exp + '*' + t, prev * n, curr - prev + prev * n, ans);

}

};

C++ / SC O(n)

// Author: Huahua

// Running time: 13 ms (< 99.14%)

class Solution {

public:

vector<string> addOperators(string num, int target) {

vector<string> ans;

string exp(num.length() * 2, '\0');

dfs(num, target, 0, exp, 0, 0, 0, &ans);

return ans;

}

private:

void dfs(const string& num, const int target,

int pos, string& exp, int len, long prev, long curr,

vector<string>* ans) {

if (pos == num.length()) {

if (curr == target) ans->push_back(exp.substr(0, len));

return;

}

long n = 0;

int s = pos;

int l = len;

if (s != 0) ++len;

while (pos < num.size()) {

n = n * 10 + (num[pos] - '0');

if (num[s] == '0' && pos - s > 0) break; // 0X... invalid number

if (n > INT_MAX) break; // too long

exp[len++] = num[pos++];

if (s == 0) {

dfs(num, target, pos, exp, len, n, n, ans);

continue;

}

exp[l] = '+'; dfs(num, target, pos, exp, len, n, curr + n, ans);

exp[l] = '-'; dfs(num, target, pos, exp, len, -n, curr - n, ans);

exp[l] = '*'; dfs(num, target, pos, exp, len, prev * n, curr - prev + prev * n, ans);

}

};

Java

// Author: Huahua

// Running time: 16 ms (<99.17%)

class Solution {

private List<String> ans;

private char[] num;

private char[] exp;

private int target;

public List<String> addOperators(String num, int target) {

this.num = num.toCharArray();

this.ans = new ArrayList<>();

this.target = target;

this.exp = new char[num.length() * 2];

dfs(0, 0, 0, 0);

return ans;

}

private void dfs(int pos, int len, long prev, long curr) {

if (pos == num.length) {

if (curr == target)

ans.add(new String(exp, 0, len));

return;

}

int s = pos;

int l = len;

if (s != 0) ++len;

long n = 0;

while (pos < num.length) {

if (num[s] == '0' && pos - s > 0) break; // 0X...

n = n * 10 + (int)(num[pos] - '0');

if (n > Integer.MAX_VALUE) break; // too long

exp[len++] = num[pos++]; // copy exp

if (s == 0) {

dfs(pos, len, n, n);

continue;

}

exp[l] = '+'; dfs(pos, len, n, curr + n);

exp[l] = '-'; dfs(pos, len, -n, curr - n);

exp[l] = '*'; dfs(pos, len, prev * n, curr - prev + prev * n);

}

花花酱 LeetCode 480. Sliding Window Median

By zxi on January 28, 2018

题目大意：让你求移动窗口的中位数。

Problem:

Median is the middle value in an ordered integer list. If the size of the list is even, there is no middle value. So the median is the mean of the two middle value.

Examples:

[2,3,4] , the median is 3

[2,3], the median is (2 + 3) / 2 = 2.5

Given an array nums, there is a sliding window of size k which is moving from the very left of the array to the very right. You can only see the k numbers in the window. Each time the sliding window moves right by one position. Your job is to output the median array for each window in the original array.

For example,
Given nums = [1,3,-1,-3,5,3,6,7], and k = 3.

Window position Median

--------------- -----

[1 3 -1] -3 5 3 6 7 1

1 [3 -1 -3] 5 3 6 7 -1

1 3 [-1 -3 5] 3 6 7 -1

1 3 -1 [-3 5 3] 6 7 3

1 3 -1 -3 [5 3 6] 7 5

1 3 -1 -3 5 [3 6 7] 6

Therefore, return the median sliding window as [1,-1,-1,3,5,6].

Note:
You may assume k is always valid, ie: k is always smaller than input array’s size for non-empty array.

Solution 0: Brute Force

Time complexity: O(n*klogk) TLE 32/42 test cases passed

Solution 1: Insertion Sort

Time complexity: O(k*logk + (n – k + 1)*k)

Space complexity: O(k)

C++ / vector

// Author: Huahua

// Running time: 99 ms

class Solution {

public:

vector<double> medianSlidingWindow(vector<int>& nums, int k) {

vector<double> ans;

if (k == 0) return ans;

vector<int> window(nums.begin(), nums.begin() + k - 1);

std::sort(window.begin(), window.end());

for (int i = k - 1; i < nums.size(); ++i) {

window.push_back(nums[i]);

auto it = prev(window.end(), 1);

auto const insertion_point =

std::upper_bound(window.begin(), it, *it);

std::rotate(insertion_point, it, it + 1);

ans.push_back((static_cast<double>(window[k / 2]) + window[(k - 1) / 2]) / 2);

window.erase(std::find(window.begin(), window.end(), nums[i - k + 1]));

}

return ans;

}

};

C++ / vector + binary_search for deletion.

// Author: Huahua

// Running time: 84 ms

class Solution {

public:

vector<double> medianSlidingWindow(vector<int>& nums, int k) {

vector<double> ans;

if (k == 0) return ans;

vector<int> window(nums.begin(), nums.begin() + k - 1);

std::sort(window.begin(), window.end());

for (int i = k - 1; i < nums.size(); ++i) {

window.push_back(nums[i]);

auto it = prev(window.end(), 1);

auto const insertion_point =

std::upper_bound(window.begin(), it, *it);

std::rotate(insertion_point, it, it + 1);

ans.push_back((static_cast<double>(window[k / 2]) + window[(k - 1) / 2]) / 2);

window.erase(std::lower_bound(window.begin(), window.end(), nums[i - k + 1]));

}

return ans;

}

};

Java

// Author: Huahua

// Running time: 60 ms

class Solution {

public double[] medianSlidingWindow(int[] nums, int k) {

if (k == 0) return new double[0];

double[] ans = new double[nums.length - k + 1];

int[] window = new int[k];

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

window[i] = nums[i];

Arrays.sort(window);

for (int i = k; i <= nums.length; ++i) {

ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;

if (i == nums.length) break;

remove(window, nums[i - k]);

insert(window, nums[i]);

}

return ans;

}

// Insert val into window, window[k - 1] is empty before inseration

private void insert(int[] window, int val) {

int i = 0;

while (i < window.length - 1 && val > window[i]) ++i;

int j = window.length - 1;

while (j > i) window[j] = window[--j];

window[j] = val;

}

// Remove val from window and shrink it.

private void remove(int[] window, int val) {

int i = 0;

while (i < window.length && val != window[i]) ++i;

while (i < window.length - 1) window[i] = window[++i];

}

Java / Binary Search

// Author: Huahua

// Running time: 47 ms (<98.96%)

class Solution {

public double[] medianSlidingWindow(int[] nums, int k) {

if (k == 0) return new double[0];

double[] ans = new double[nums.length - k + 1];

int[] window = new int[k];

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

window[i] = nums[i];

Arrays.sort(window);

for (int i = k; i <= nums.length; ++i) {

ans[i - k] = ((double)window[k / 2] + window[(k - 1)/2]) / 2;

if (i == nums.length) break;

remove(window, nums[i - k]);

insert(window, nums[i]);

}

return ans;

}

// Insert val into window, window[k - 1] is empty before inseration

private void insert(int[] window, int val) {

int i = Arrays.binarySearch(window, val);

if (i < 0) i = - i - 1;

int j = window.length - 1;

while (j > i) window[j] = window[--j];

window[j] = val;

}

// Remove val from window and shrink it.

private void remove(int[] window, int val) {

int i = Arrays.binarySearch(window, val);

while (i < window.length - 1) window[i] = window[++i];

}

Python

"""

Author: Huahua

Running time: 161 ms (< 93.75%)

"""

class Solution:

def medianSlidingWindow(self, nums, k):

if k == 0: return []

ans = []

window = sorted(nums[0:k])

for i in range(k, len(nums) + 1):

ans.append((window[k // 2] + window[(k - 1) // 2]) / 2.0)

if i == len(nums): break

index = bisect.bisect_left(window, nums[i - k])

window.pop(index)

bisect.insort_left(window, nums[i])

return ans

Solution 2: BST

// Author: Huahua

// Running time: 68 ms

class Solution {

public:

vector<double> medianSlidingWindow(vector<int>& nums, int k) {

vector<double> ans;

if (k == 0) return ans;

multiset<int> window(nums.begin(), nums.begin() + k);

auto mid = next(window.begin(), (k - 1) / 2);

for (int i = k; i <= nums.size(); ++i) {

ans.push_back((static_cast<double>(*mid) +

*next(mid, (k + 1) % 2)) / 2.0);

if (i == nums.size()) break;

window.insert(nums[i]);

if (nums[i] < *mid) --mid;

if (nums[i - k] <= *mid) ++mid;

window.erase(window.lower_bound(nums[i - k]));

}

return ans;

}

};

Related Problems: