Huahua’s Tech Road

花花酱 LeetCode 71. Simplify Path

By zxi on October 1, 2019

Given an absolute path for a file (Unix-style), simplify it. Or in other words, convert it to the canonical path.

In a UNIX-style file system, a period . refers to the current directory. Furthermore, a double period .. moves the directory up a level. For more information, see: Absolute path vs relative path in Linux/Unix

Note that the returned canonical path must always begin with a slash /, and there must be only a single slash / between two directory names. The last directory name (if it exists) must not end with a trailing /. Also, the canonical path must be the shortest string representing the absolute path.

Example 1:

Input: "/home/"
Output: "/home"
Explanation: Note that there is no trailing slash after the last directory name.

Example 2:

Input: "/../"
Output: "/"
Explanation: Going one level up from the root directory is a no-op, as the root level is the highest level you can go.

Example 3:

Input: "/home//foo/"
Output: "/home/foo"
Explanation: In the canonical path, multiple consecutive slashes are replaced by a single one.

Example 4:

Input: "/a/./b/../../c/"
Output: "/c"

Example 5:

Input: "/a/../../b/../c//.//"
Output: "/c"

Example 6:

Input: "/a//b////c/d//././/.."
Output: "/a/b/c"

Solution: Stack

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

C++

// Author: Huahua

class Solution {

public:

string simplifyPath(string path) {

vector<string> s;

int start = 1;

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

if (i == path.length() || path[i] == '/') {

string p = path.substr(start, i - start);

if (p == "/") continue;

if (p == "..") {

if (!s.empty()) s.pop_back();

} else if (p.length() > 0 && p != ".") {

s.push_back(std::move(p));

}

start = i + 1;

}

string ans;

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

ans += "/" + s[i];

return ans.empty() ? "/" : ans;

}

};

花花酱 LeetCode 75. Sort Colors

By zxi on October 1, 2019

Given an array with n objects colored red, white or blue, sort them in-place so that objects of the same color are adjacent, with the colors in the order red, white and blue.

Here, we will use the integers 0, 1, and 2 to represent the color red, white, and blue respectively.

Note: You are not suppose to use the library’s sort function for this problem.

Example:

Input: [2,0,2,1,1,0]
Output: [0,0,1,1,2,2]

Follow up:

A rather straight forward solution is a two-pass algorithm using counting sort.
First, iterate the array counting number of 0’s, 1’s, and 2’s, then overwrite array with total number of 0’s, then 1’s and followed by 2’s.
Could you come up with a one-pass algorithm using only constant space?

Solution 1: Counting sort

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

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

vector<int> c(3);

for (int x : nums)

++c[x];

auto it = begin(nums);

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

while (c[i]--)

*it++ = i;

}

};

Solution 2: Two pointers

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

C++

// Author: Huahua

class Solution {

public:

void sortColors(vector<int>& nums) {

const int n = nums.size();

int l = 0;

int r = n - 1;

for (int i = 0; i < n; ++i) {

if (nums[i] == 0) {

swap(nums[i], nums[l++]);

} else if (nums[i] == 2 && i < r) {

swap(nums[i--], nums[r--]);

}

};

花花酱 LeetCode 77. Combinations

By zxi on September 30, 2019

Given two integers n and k, return all possible combinations of k numbers out of 1 … n.

Example:

Input: n = 4, k = 2
Output:
[
  [2,4],
  [3,4],
  [2,3],
  [1,2],
  [1,3],
  [1,4],
]

Solution: DFS

Time complexity: O(C(n, k))
Space complexity: O(k)

C++

// Author: Huahua

class Solution {

public:

vector<vector<int>> combine(int n, int k) {

vector<vector<int>> ans;

vector<int> cur;

function<void(int)> dfs = [&](int s) {

if (cur.size() == k) {

ans.push_back(cur);

return;

}

for (int i = s; i < n; ++i) {

cur.push_back(i + 1);

dfs(i + 1);

cur.pop_back();

}

};

dfs(0);

return ans;

}

};

花花酱 LeetCode 80. Remove Duplicates from Sorted Array II

By zxi on September 30, 2019

Given a sorted array nums, remove the duplicates in-place such that duplicates appeared at most twice and return the new length.

Do not allocate extra space for another array, you must do this by modifying the input array in-place with O(1) extra memory.

Example 1:

Given nums = [1,1,1,2,2,3],

Your function should return length = 5, with the first five elements of nums being 1, 1, 2, 2 and 3 respectively.

It doesn't matter what you leave beyond the returned length.

Example 2:

Given nums = [0,0,1,1,1,1,2,3,3],

Your function should return length = 7, with the first seven elements of nums being modified to 0, 0, 1, 1, 2, 3 and 3 respectively.

It doesn't matter what values are set beyond the returned length.

Solution:

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

C++

// Author: Huahua

class Solution {

public:

int removeDuplicates(vector<int>& nums) {

const int n = nums.size();

if (n <= 2) return n;

int index = 1;

int len = 1;

int last = nums[0];

while (index < n) {

int count = 1;

while (index < n && nums[index] == last) {

++count;

++index;

}

if (count >= 2) nums[len++] = last;

if (index < n) {

last = nums[index++];

nums[len++] = last;

}

return len;

}

};

花花酱 LeetCode 71. Simplify Path

Solution: Stack

C++

花花酱 LeetCode 75. Sort Colors

Solution 1: Counting sort

C++

Solution 2: Two pointers

C++

花花酱 LeetCode 77. Combinations

Solution: DFS

C++

Related Problems

花花酱 LeetCode 80. Remove Duplicates from Sorted Array II

Solution:

C++

Related Problems

Huahua's Tech Road

花花酱 LeetCode 71. Simplify Path

Solution: Stack

C++

花花酱 LeetCode 75. Sort Colors

Solution 1: Counting sort

C++

Solution 2: Two pointers

C++

花花酱 LeetCode 77. Combinations

Solution: DFS

C++

Related Problems

花花酱 LeetCode 80. Remove Duplicates from Sorted Array II

Solution:

C++

Related Problems

花花酱 LeetCode 82. Remove Duplicates from Sorted List II

Solution:

C++

Related Problems