花花酱 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;

}

};

花花酱 LeetCode 572. Subtree of Another Tree

By zxi on March 19, 2018

Problem

题目大意：判断一棵树是不是另外一棵树的子树。

https://leetcode.com/problems/subtree-of-another-tree/description/

Given two non-empty binary trees s and t, check whether tree t has exactly the same structure and node values with a subtree of s. A subtree of s is a tree consists of a node in s and all of this node’s descendants. The tree s could also be considered as a subtree of itself.

Example 1:
Given tree s:

/ \

4 5

/ \

1 2

Given tree t:

/ \

1 2

Return true, because t has the same structure and node values with a subtree of s.

Example 2:
Given tree s:

/ \

4 5

/ \

1 2

Given tree t:

/ \

1 2

Return false.

Solution: Recursion

Time complexity: O(max(n, m))

Space complexity: O(max(n, m))

C++

// Author: Huahua

// Running time: 29 ms

class Solution {

public:

bool isSubtree(TreeNode* s, TreeNode* t) {

if (t == nullptr) return true;

if (s == nullptr) return false;

if (isSameTree(s, t)) return true;

return isSubtree(s->left, t) || isSubtree(s->right, t);

}

private:

bool isSameTree(TreeNode* s, TreeNode* t) {

if (s == nullptr && t == nullptr) return true;

if (s == nullptr || t == nullptr) return false;

return (s->val == t->val)

&& isSameTree(s->left, t->left)

&& isSameTree(s->right, t->right);

}

};

Problem

The Hamming distance between two integers is the number of positions at which the corresponding bits are different.

Given two integers x and y, calculate the Hamming distance.

Note:
0 ≤ x, y < 2³¹.

Example:

Input: x = 1, y = 4

Output: 2

Explanation:
1   (0 0 0 1)
4   (0 1 0 0)
       ↑   ↑

The above arrows point to positions where the corresponding bits are different.

Solution: Bit Operation

Time complexity: O(logn)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 6 ms

class Solution {

public:

int hammingDistance(int x, int y) {

int ans = 0;

int t = x^y;

while (t) {

ans += t & 1;

t >>=1;

}

return ans;

}

};

// Author: Huahua

// Running time: 9 ms

class Solution {

public:

int hammingDistance(int x, int y) {

return __builtin_popcount(x ^ y);

}

};

花花酱 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

花花酱 LeetCode 572. Subtree of Another Tree

Problem

Solution: Recursion

Related Problems

花花酱 LeetCode 461. Hamming Distance

Problem

Solution: Bit Operation

Related Problems

Huahua's Tech Road

花花酱 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

花花酱 LeetCode 572. Subtree of Another Tree

Problem

Solution: Recursion

Related Problems

花花酱 LeetCode 461. Hamming Distance

Problem

Solution: Bit Operation

Related Problems