September 2019 – Page 2 – Huahua’s Tech Road

花花酱 LeetCode 93. Restore IP Addresses

By zxi on September 30, 2019

Given a string containing only digits, restore it by returning all possible valid IP address combinations.

Example:

Input: "25525511135"
Output: ["255.255.11.135", "255.255.111.35"]

Solution: DFS

The range of valid numbers is [0, 255]

Time complexity: O(3^4)
Space complexity: O(1)

C++

// Author: Huahua

class Solution {

public:

vector<string> restoreIpAddresses(string s) {

vector<string> ans;

string ip;

dfs(0, s, ip, ans);

return ans;

}

private:

void dfs(int d, string s, string ip, vector<string> &ans) {

int l = s.length();

if (d == 4) {

if (l == 0) ans.push_back(ip);

return;

}

for (int i = 1; i <= min(3, s[0] == '0' ? 1 : l); i++) {

string ss = s.substr(0, i);

if (i == 3 && stoi(ss) > 255) return;

dfs(d + 1, s.substr(i), ip + (d == 0 ? "" : ".") + ss , ans);

}

};

花花酱 LeetCode 58. Length of Last Word

By zxi on September 30, 2019

Given a string s consists of upper/lower-case alphabets and empty space characters ' ', return the length of last word in the string.

If the last word does not exist, return 0.

Note: A word is defined as a character sequence consists of non-space characters only.

Example:

Input: "Hello World"
Output: 5

Solution:

There can be tailing spaces, e.g. “abc “, we need to trim the string first and then scan the string in reverse order until a space or reach the beginning of the string.

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

C++

// Author: Huahua

class Solution {

public:

int lengthOfLastWord(string s) {

int i = s.length() - 1;

int l = 0;

while (i >= 0 && s[i] == ' ') --i;

while (i >= 0 && s[i] != ' ') {

--i;

++l;

}

return l;

}

};

花花酱 LeetCode 190. Reverse Bits

By zxi on September 30, 2019

Reverse bits of a given 32 bits unsigned integer.

Example 1:

Input: 00000010100101000001111010011100
Output: 00111001011110000010100101000000
Explanation: The input binary string 00000010100101000001111010011100 represents the unsigned integer 43261596, so return 964176192 which its binary representation is 00111001011110000010100101000000.

Example 2:

Input: 11111111111111111111111111111101
Output: 10111111111111111111111111111111
Explanation: The input binary string 11111111111111111111111111111101 represents the unsigned integer 4294967293, so return 3221225471 which its binary representation is 10101111110010110010011101101001.

Note:

Note that in some languages such as Java, there is no unsigned integer type. In this case, both input and output will be given as signed integer type and should not affect your implementation, as the internal binary representation of the integer is the same whether it is signed or unsigned.
In Java, the compiler represents the signed integers using 2’s complement notation. Therefore, in Example 2 above the input represents the signed integer -3 and the output represents the signed integer -1073741825.

Follow up:

If this function is called many times, how would you optimize it?

Solution: Bit operation

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

C++

// Author: Huahua

class Solution {

public:

uint32_t reverseBits(uint32_t n) {

uint32_t ans = 0;

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

ans <<= 1;

ans |= n & 1;

n >>= 1;

}

return ans;

}

};

花花酱 LeetCode 89. Gray Code

By zxi on September 29, 2019

The gray code is a binary numeral system where two successive values differ in only one bit.

Given a non-negative integer n representing the total number of bits in the code, print the sequence of gray code. A gray code sequence must begin with 0.

Example 1:

Input: 2
Output: [0,1,3,2]
Explanation:
00 - 0
01 - 1
11 - 3
10 - 2

For a given n, a gray code sequence may not be uniquely defined.
For example, [0,2,3,1] is also a valid gray code sequence.

00 - 0
10 - 2
11 - 3
01 - 1

Example 2:

Input: 0
Output: [0]
Explanation: We define the gray code sequence to begin with 0.
             A gray code sequence of n has size = 2ⁿ, which for n = 0 the size is 2⁰ = 1.
             Therefore, for n = 0 the gray code sequence is [0].

Solution: DP

dp[0] = 0
dp[i] = dp[i – 1] + [x | 1 << (i – 1) for x in reversed(dp[i – 1])]

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

C++

// Author: Huahua

class Solution {

public:

vector<int> grayCode(int n) {

vector<vector<int>> dp(n + 1);

dp[0] = {0};

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

dp[i] = dp[i - 1];

for (int j = dp[i - 1].size() - 1; j >= 0; --j)

dp[i].push_back(dp[i - 1][j] | (1 << (i - 1)));

}

return dp[n];

}

};

Python3

# Author: Huahua

class Solution:

def grayCode(self, n: int) -> List[int]:

dp = [0]

for i in range(n):

dp = dp + [x | 1 << i for x in reversed(dp)]

return dp

花花酱 LeetCode 99. Recover Binary Search Tree

By zxi on September 29, 2019

Two elements of a binary search tree (BST) are swapped by mistake.

Recover the tree without changing its structure.

Example 1:

Input: [1,3,null,null,2]

   1
  /
 3
  \
   2

Output: [3,1,null,null,2]

   3
  /
 1
  \
   2

Example 2:

Input: [3,1,4,null,null,2]

  3
 / \
1   4
   /
  2

Output: [2,1,4,null,null,3]

  2
 / \
1   4
   /
  3

Follow up:

A solution using O(n) space is pretty straight forward.
Could you devise a constant space solution?

Solution: Inorder traversal

Using inorder traversal to find two nodes that have val < prev.val

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

C++

// Author: Huahua

class Solution {

public:

void recoverTree(TreeNode *root) {

inorder(root);

swap(first->val, second->val);

}

void inorder(TreeNode* root) {

if (!root) return;

inorder(root->left);

if (prev && prev->val > root->val) {

if (!first) first = prev;

second = root;

}

prev = root;

inorder(root->right);

}

private:

TreeNode* first;

TreeNode* second;

TreeNode* prev;

};

Posts published in September 2019

花花酱 LeetCode 93. Restore IP Addresses

Solution: DFS

C++

花花酱 LeetCode 58. Length of Last Word

Solution:

C++

花花酱 LeetCode 190. Reverse Bits

C++

花花酱 LeetCode 89. Gray Code

Solution: DP

C++

Python3

花花酱 LeetCode 99. Recover Binary Search Tree

Solution: Inorder traversal

C++