花花酱 LeetCode 541. Reverse String II

By zxi on March 21, 2018

Problem

题目大意：把字符串分成块，每块长度2k，单独反转每一块的前k的字符。

https://leetcode.com/problems/reverse-string-ii/description/

Given a string and an integer k, you need to reverse the first k characters for every 2k characters counting from the start of the string. If there are less than k characters left, reverse all of them. If there are less than 2k but greater than or equal to k characters, then reverse the first k characters and left the other as original.Example:

Input: s = "abcdefg", k = 2
Output: "bacdfeg"

Restrictions:

The string consists of lower English letters only.
Length of the given string and k will in the range [1, 10000]

Solution

C++

// Author: Huahua

// Running time: 9 ms

class Solution {

public:

string reverseStr(string s, int k) {

const int n = s.length();

for (int i = 0; i <= n / k; i += 2)

std::reverse(s.begin() + i * k, s.begin() + min(n, (i + 1) * k));

return s;

}

};

Problem

Given a list of 24-hour clock time points in “Hour:Minutes” format, find the minimum minutes difference between any two time points in the list.

Example 1:

Input: ["23:59","00:00"]
Output: 1

Note:

The number of time points in the given list is at least 2 and won’t exceed 20000.
The input time is legal and ranges from 00:00 to 23:59.

Solution

Time complexity: O(nlog1440)

Space complexity: O(n)

C++

// Author: huahua

// Running time: 16 ms

class Solution {

public:

int findMinDifference(vector<string>& timePoints) {

constexpr int kMins = 24 * 60;

set<int> seen;

for (const string& time : timePoints) {

int m = stoi(time.substr(0, 2)) * 60 + stoi(time.substr(3));

if (!seen.insert(m).second) return 0;

}

int ans = (*seen.begin() - *seen.rbegin() + kMins) % kMins;

const int* l = nullptr;

for (const int& t : seen) {

if (l) ans = min(ans, t - *l);

l = &t;

}

return ans;

}

};

花花酱 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 541. Reverse String II

Problem

Solution

Related Problems

花花酱 LeetCode 539. Minimum Time Difference

Problem

Solution

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

Huahua's Tech Road

花花酱 LeetCode 541. Reverse String II

Problem

Solution

Related Problems

花花酱 LeetCode 539. Minimum Time Difference

Problem

Solution

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