花花酱 LeetCode 538. Convert BST to Greater Tree

By zxi on March 21, 2018

Problem

题目大意：把二叉搜索树的每个节点加上比他大的节点的和。

https://leetcode.com/problems/convert-bst-to-greater-tree/description/

Given a Binary Search Tree (BST), convert it to a Greater Tree such that every key of the original BST is changed to the original key plus sum of all keys greater than the original key in BST.

Example:

Input: The root of a Binary Search Tree like this:
              5
            /   \
           2     13

Output: The root of a Greater Tree like this:
             18
            /   \
          20     13

Solution: reversed inorder traversal

in a BST, we can visit every node in the decreasing order. Using a member sum to track the sum of all visited nodes.

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 56 ms

class Solution {

public:

TreeNode* convertBST(TreeNode* root) {

sum = 0;

inorder(root);

return root;

}

private:

int sum;

void rinorder(TreeNode* root) {

if (root == nullptr) return;

rinorder(root->right);

root->val = (sum += root->val);

rinorder(root->left);

}

};

花花酱 LeetCode 563. Binary Tree Tilt

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/binary-tree-tilt/description/

题目大意：返回树的总tilt值。对于一个节点的tilt值定义为左右子树元素和的绝对之差。

Given a binary tree, return the tilt of the whole tree.

The tilt of a tree node is defined as the absolute difference between the sum of all left subtree node values and the sum of all right subtree node values. Null node has tilt 0.

The tilt of the whole tree is defined as the sum of all nodes’ tilt.

Example:

Input: 
         1
       /   \
      2     3
Output: 1
Explanation: 
Tilt of node 2 : 0
Tilt of node 3 : 0
Tilt of node 1 : |2-3| = 1
Tilt of binary tree : 0 + 0 + 1 = 1

Note:

The sum of node values in any subtree won’t exceed the range of 32-bit integer.
All the tilt values won’t exceed the range of 32-bit integer.

Solution: Recursion

Time complexity: O(n)

Space complexity: O(h)

C++

// Author: Huahua

// Running time: 17 ms

class Solution {

public:

int findTilt(TreeNode* root) {

int sum;

return findTilt(root, sum);

}

private:

// return the total tilt and sum of the root.

int findTilt(TreeNode* root, int& sum) {

if (root == nullptr) return 0;

int ls = 0;

int rs = 0;

int tl = findTilt(root->left, ls);

int tr = findTilt(root->right, rs);

sum = root->val + ls + rs;

return tl + tr + abs(ls - rs);

}

};

v1-2

// Author: Huahua

// Running time: 17 ms

class Solution {

public:

int findTilt(TreeNode* root) {

return findTiltSum(root).first;

}

private:

pair<int, int> findTiltSum(TreeNode* root) {

if (root == nullptr) return {0, 0};

auto l = findTiltSum(root->left);

auto r = findTiltSum(root->right);

return { l.first + r.first + abs(l.second - r.second),

root->val + l.second + r.second };

}

};

// Author: Huahua

// Running time: 16 ms

class Solution {

public:

int findTilt(TreeNode* root) {

ans_ = 0;

sum(root);

return ans_;

}

private:

int ans_;

int sum(TreeNode* root) {

if (root == nullptr) return 0;

int l = sum(root->left);

int r = sum(root->right);

ans_ += abs(l - r);

return root->val + l + r;

}

};

Python3

"""

Author: Huahua

Running time: 112 ms

"""

class Solution:

def findTilt(self, root):

def findTilt(root):

if not root: return 0, 0

tl, sl = findTilt(root.left)

tr, sr = findTilt(root.right)

return tl + tr + abs(sl - sr), root.val + sl + sr

return findTilt(root)[0]

花花酱 LeetCode 609. Find Duplicate File in System

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/find-duplicate-file-in-system/description/

题目大意：输出系统中文件内容相同的文件名。

Given a list of directory info including directory path, and all the files with contents in this directory, you need to find out all the groups of duplicate files in the file system in terms of their paths.

A group of duplicate files consists of at least two files that have exactly the same content.

A single directory info string in the input list has the following format:

"root/d1/d2/.../dm f1.txt(f1_content) f2.txt(f2_content) ... fn.txt(fn_content)"

It means there are n files (f1.txt, f2.txt … fn.txt with content f1_content, f2_content … fn_content, respectively) in directory root/d1/d2/.../dm. Note that n >= 1 and m >= 0. If m = 0, it means the directory is just the root directory.

The output is a list of group of duplicate file paths. For each group, it contains all the file paths of the files that have the same content. A file path is a string that has the following format:

"directory_path/file_name.txt"

Example 1:

Input:
["root/a 1.txt(abcd) 2.txt(efgh)", "root/c 3.txt(abcd)", "root/c/d 4.txt(efgh)", "root 4.txt(efgh)"]
Output:  
[["root/a/2.txt","root/c/d/4.txt","root/4.txt"],["root/a/1.txt","root/c/3.txt"]]

Note:

No order is required for the final output.
You may assume the directory name, file name and file content only has letters and digits, and the length of file content is in the range of [1,50].
The number of files given is in the range of [1,20000].
You may assume no files or directories share the same name in the same directory.
You may assume each given directory info represents a unique directory. Directory path and file info are separated by a single blank space.

Follow-up beyond contest:

Imagine you are given a real file system, how will you search files? DFS or BFS?
If the file content is very large (GB level), how will you modify your solution?
If you can only read the file by 1kb each time, how will you modify your solution?
What is the time complexity of your modified solution? What is the most time-consuming part and memory consuming part of it? How to optimize?
How to make sure the duplicated files you find are not false positive?

Solution: HashTable

Key: content, Value: Array of filenames

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

// Running time: 80ms (beats 94.68%)

class Solution {

public:

vector<vector<string>> findDuplicate(vector<string>& paths) {

unordered_map<string, vector<string>> files; // content -> filenames

for (const string& path : paths) {

string folder;

int i = 0;

while (path[i] != ' ') folder += path[i++];

while (i < path.length()) {

string filename;

string content;

++i; // ' '

while (path[i] != '(') filename += path[i++];

++i; // '('

while (path[i] != ')') content += path[i++];

++i; // ')'

files[content].push_back(folder + "/" + filename);

}

vector<vector<string>> ans;

for (auto& kv : files)

if (kv.second.size() > 1)

ans.push_back(std::move(kv.second));

return ans;

}

};

花花酱 LeetCode 598. Range Addition II

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/range-addition-ii/description/

Given an m * n matrix M initialized with all 0‘s and several update operations.

Operations are represented by a 2D array, and each operation is represented by an array with two positiveintegers a and b, which means M[i][j] should be added by one for all 0 <= i < a and 0 <= j < b.

You need to count and return the number of maximum integers in the matrix after performing all the operations.

Example 1:

Input: 
m = 3, n = 3
operations = [[2,2],[3,3]]
Output: 4
Explanation: 
Initially, M = 
[[0, 0, 0],
 [0, 0, 0],
 [0, 0, 0]]

After performing [2,2], M = 
[[1, 1, 0],
 [1, 1, 0],
 [0, 0, 0]]

After performing [3,3], M = 
[[2, 2, 1],
 [2, 2, 1],
 [1, 1, 1]]

So the maximum integer in M is 2, and there are four of it in M. So return 4.

Note:

The range of m and n is [1,40000].
The range of a is [1,m], and the range of b is [1,n].
The range of operations size won’t exceed 10,000.

Solution:

Time Complexity: O(n)

Space Complexity: O(1)

C++

// Author: Huahua

// Running time: 9 ms

class Solution {

public:

int maxCount(int m, int n, vector<vector<int>>& ops) {

for (const auto& range : ops) {

m = min(m, range[0]);

n = min(n, range[1]);

}

return m * n;

}

};

花花酱 LeetCode 594. Longest Harmonious Subsequence

By zxi on March 20, 2018

Problem

https://leetcode.com/problems/longest-harmonious-subsequence/description/

题目大意：找一个最长子序列，要求子序列中最大值和最小值的差是1。

We define a harmonious array is an array where the difference between its maximum value and its minimum value is exactly 1.

Now, given an integer array, you need to find the length of its longest harmonious subsequence among all its possible subsequences.

Example 1:

Input: [1,3,2,2,5,2,3,7]
Output: 5
Explanation: The longest harmonious subsequence is [3,2,2,2,3].

Note: The length of the input array will not exceed 20,000.

Solution1: HashTable

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

C++

// Author: Huahua

// Running time: 127 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums) {

++counts[num];

int l = counts[num - 1];

int h = counts[num + 1];

if (l || h)

ans = max(ans, counts[num] + max(l, h));

}

return ans;

}

};

// Running time: 109 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums) {

const int c = ++counts[num];

auto it1 = counts.find(num - 1);

auto it2 = counts.find(num + 1);

if (it1 != counts.end())

ans = max(ans, c + it1->second);

if (it2 != counts.end())

ans = max(ans, c + it2->second);

}

return ans;

}

};

// Author: Huahua

// Running time: 102 ms

class Solution {

public:

int findLHS(vector<int>& nums) {

unordered_map<int, int> counts;

int ans = 0;

for (int num : nums)

++counts[num];

for (const auto& p : counts) {

auto it1 = counts.find(p.first - 1);

auto it2 = counts.find(p.first + 1);

if (it1 != counts.end())

ans = max(ans, p.second + it1->second);

if (it2 != counts.end())

ans = max(ans, p.second + it2->second);

}

return ans;

}

};

Huahua's Tech Road

花花酱 LeetCode 538. Convert BST to Greater Tree

Problem

Solution: reversed inorder traversal

花花酱 LeetCode 563. Binary Tree Tilt

Problem

Solution: Recursion

花花酱 LeetCode 609. Find Duplicate File in System

Problem

Follow-up beyond contest:

Solution: HashTable

花花酱 LeetCode 598. Range Addition II

Problem

Solution:

花花酱 LeetCode 594. Longest Harmonious Subsequence

Problem

Solution1: HashTable