Huahua’s Tech Road

花花酱 LeetCode 68. Text Justification

By zxi on October 1, 2019

Given an array of words and a width maxWidth, format the text such that each line has exactly maxWidth characters and is fully (left and right) justified.

You should pack your words in a greedy approach; that is, pack as many words as you can in each line. Pad extra spaces ' ' when necessary so that each line has exactly maxWidth characters.

Extra spaces between words should be distributed as evenly as possible. If the number of spaces on a line do not divide evenly between words, the empty slots on the left will be assigned more spaces than the slots on the right.

For the last line of text, it should be left justified and no extra space is inserted between words.

Note:

A word is defined as a character sequence consisting of non-space characters only.
Each word’s length is guaranteed to be greater than 0 and not exceed maxWidth.
The input array words contains at least one word.

Example 1:

Input:
words = ["This", "is", "an", "example", "of", "text", "justification."]
maxWidth = 16
Output:
[
   "This    is    an",
   "example  of text",
   "justification.  "
]

Example 2:

Input:
words = ["What","must","be","acknowledgment","shall","be"]
maxWidth = 16
Output:
[
  "What   must   be",
  "acknowledgment  ",
  "shall be        "
]
Explanation: Note that the last line is "shall be    " instead of "shall     be",
             because the last line must be left-justified instead of fully-justified.
             Note that the second line is also left-justified becase it contains only one word.

Example 3:

Input:
words = ["Science","is","what","we","understand","well","enough","to","explain",
         "to","a","computer.","Art","is","everything","else","we","do"]
maxWidth = 20
Output:
[
  "Science  is  what we",
  "understand      well",
  "enough to explain to",
  "a  computer.  Art is",
  "everything  else  we",
  "do                  "
]

Solution: Simulation

Time complexity: O(sum(len(s))
Space complexity: O(sum(len(s))

C++

// Author: Huahua

class Solution {

public:

vector<string> fullJustify(vector<string> &words, int L) {

size_t i = 0, n = words.size();

vector<string> ans;

while (i < n) {

bool last_line = false;

int ll = 0;

vector<string_view> tw;

while (ll <= L && i < n) {

size_t wl = words[i].length();

int tll = ll + (tw.size() ? 1 : 0) + wl;

if (tll > L) break;

ll = tll;

tw.push_back(string_view(words[i]));

if (++i == n) last_line = true;

if (ll == L) break;

}

string line;

if (!last_line) {

int tl = 0;

for(const auto& w : tw) tl += w.length();

int avg_space = tw.size()==1 ? 0 : ((L-tl) / (tw.size() - 1));

int extra_space = tw.size()==1 ? 0 : (L - avg_space * (tw.size() - 1) - tl);

for (const auto& w : tw) {

if (line.length() > 0) {

line.append(avg_space, ' ');

if (extra_space > 0) {

line += ' ';

--extra_space;

}

line += w;

}

} else {

for (const auto& w : tw) {

if (line.length() > 0)

line += ' ';

line += w;

}

line.append(L - line.length(), ' ');

ans.push_back(std::move(line));

}

return ans;

}

};

花花酱 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 68. Text Justification

C++

花花酱 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 68. Text Justification

C++

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