花花酱 LeetCode 890. Find and Replace Pattern

By zxi on August 19, 2018

Problem

You have a list of words and a pattern, and you want to know which words in words matches the pattern.

A word matches the pattern if there exists a permutation of letters p so that after replacing every letter x in the pattern with p(x), we get the desired word.

(Recall that a permutation of letters is a bijection from letters to letters: every letter maps to another letter, and no two letters map to the same letter.)

Return a list of the words in words that match the given pattern.

You may return the answer in any order.

Example 1:

Input: words = ["abc","deq","mee","aqq","dkd","ccc"], pattern = "abb"
Output: ["mee","aqq"]
Explanation: "mee" matches the pattern because there is a permutation {a -> m, b -> e, ...}. 
"ccc" does not match the pattern because {a -> c, b -> c, ...} is not a permutation,
since a and b map to the same letter.

Note:

1 <= words.length <= 50
1 <= pattern.length = words[i].length <= 20

Solution: Remember the last pos of each char.

Time complexity: O(n*l)

Space complexity: O(128) -> O(26)

C++

// Author: Huahua

// Running time: 0 ms

class Solution {

public:

vector<string> findAndReplacePattern(vector<string>& words, string pattern) {

vector<string> ans;

for (const string& w : words)

if (match(w, pattern)) ans.push_back(w);

return ans;

}

private:

bool match(const string& w, const string& p) {

vector<int> last_pos_w(128, INT_MIN); // last pos of x in w

vector<int> last_pos_p(128, INT_MIN); // last pos of x in p

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

if (last_pos_w[w[i]] != last_pos_p[p[i]]) {

return false;

} else {

last_pos_w[w[i]] = last_pos_p[p[i]] = i;

}

return true;

}

};

花花酱 LeetCode 888. Fair Candy Swap

By zxi on August 19, 2018

Problem

Alice and Bob have candy bars of different sizes: A[i] is the size of the i-th bar of candy that Alice has, and B[j] is the size of the j-th bar of candy that Bob has.

Since they are friends, they would like to exchange one candy bar each so that after the exchange, they both have the same total amount of candy. (The total amount of candy a person has is the sum of the sizes of candy bars they have.)

Return an integer array ans where ans[0] is the size of the candy bar that Alice must exchange, and ans[1] is the size of the candy bar that Bob must exchange.

If there are multiple answers, you may return any one of them. It is guaranteed an answer exists.

Example 1:

Input: A = [1,1], B = [2,2]
Output: [1,2]

Example 2:

Input: A = [1,2], B = [2,3]
Output: [1,2]

Example 3:

Input: A = [2], B = [1,3]
Output: [2,3]

Example 4:

Input: A = [1,2,5], B = [2,4]
Output: [5,4]

Note:

1 <= A.length <= 10000
1 <= B.length <= 10000
1 <= A[i] <= 100000
1 <= B[i] <= 100000
It is guaranteed that Alice and Bob have different total amounts of candy.
It is guaranteed there exists an answer.

Solution: HashTable

Time complexity: O(A+B)

Space complexity: O(B)

Clean version

// Author: Huahua

// Running time: 132 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = accumulate(begin(B), end(B), 0);

unordered_set<int> s(begin(B), end(B));

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};

Faster version

// Author: Huahua

// Running time: 68 ms

class Solution {

public:

vector<int> fairCandySwap(vector<int>& A, vector<int>& B) {

int sum_a = accumulate(begin(A), end(A), 0);

int sum_b = 0;

unordered_set<int> s;

for (int b : B) {

sum_b += b;

s.insert(b);

}

int diff = (sum_b - sum_a) / 2;

for (int a : A)

if (s.count(a + diff)) return {a, a + diff};

}

};

花花酱 LeetCode 617. Merge Two Binary Trees

By zxi on August 17, 2018

Problem

Given two binary trees and imagine that when you put one of them to cover the other, some nodes of the two trees are overlapped while the others are not.

You need to merge them into a new binary tree. The merge rule is that if two nodes overlap, then sum node values up as the new value of the merged node. Otherwise, the NOT null node will be used as the node of new tree.

Example 1:

Input: 
	Tree 1                     Tree 2                  
          1                         2                             
         / \                       / \                            
        3   2                     1   3                        
       /                           \   \                      
      5                             4   7                  
Output: 
Merged tree:
	     3
	    / \
	   4   5
	  / \   \ 
	 5   4   7

Note: The merging process must start from the root nodes of both trees.

Solution: Recursion

Reuse t1/t2

// Author: Huahua

// Running time: 52 ms

class Solution {

public:

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

if (t1 == nullptr) return t2;

if (t2 == nullptr) return t1;

auto root = t1;

root->val += t2->val;

root->left = mergeTrees(t1->left, t2->left);

root->right = mergeTrees(t1->right, t2->right);

return root;

}

};

Create a copy

// Author: Huahua

// Running time: 52 ms

class Solution {

public:

TreeNode* mergeTrees(TreeNode* t1, TreeNode* t2) {

if (t1 == nullptr) return copyTree(t2);

if (t2 == nullptr) return copyTree(t1);

TreeNode* root = new TreeNode(t1->val + t2->val);

root->left = mergeTrees(t1->left, t2->left);

root->right = mergeTrees(t1->right, t2->right);

return root;

}

private:

TreeNode* copyTree(TreeNode* root) {

if (root == nullptr) return nullptr;

TreeNode* r = new TreeNode(root->val);

r->left = copyTree(root->left);

r->right = copyTree(root->right);

return r;

}

};

花花酱 LeetCode 628. Maximum Product of Three Numbers

By zxi on August 17, 2018

Problem

Given an integer array, find three numbers whose product is maximum and output the maximum product.

Example 1:

Input: [1,2,3]
Output: 6

Example 2:

Input: [1,2,3,4]
Output: 24

Note:

The length of the given array will be in range [3,10⁴] and all elements are in the range [-1000, 1000].
Multiplication of any three numbers in the input won’t exceed the range of 32-bit signed integer.

Idea:

Find the top 3 numbers t1, t2, t3, and bottom 2 numbers, b1, b2.

If all numbers are positives, answer must be t1 * t2 * t3.

Since the number can go negative, the answer must be either t1*t2*t3 or b1 * b2 * t1, if b1 and b2 are both negatives.

ex. nums: [5, 1, -6, 3, -1]

t1, t2, t3: 5, 3, 1

b1, b2: -6, -1

t1 * t2 * t3 = 15

t1 * b1 * b2 = 30

Solution 1: Manual Tracking

Time complexity: O(n)

Space complexity: O(1)

// Author: Huahua

// Running time: 28 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

int max1 = INT_MIN;

int max2 = INT_MIN;

int max3 = INT_MIN;

int min1 = INT_MAX;

int min2 = INT_MAX;

for (const int num: nums) {

if (num > max1) {

max3 = max2;

max2 = max1;

max1 = num;

} else if (num > max2) {

max3 = max2;

max2 = num;

} else if (num > max3) {

max3=num;

}

if (num < min1) {

min2 = min1;

min1 = num;

} else if (num < min2) {

min2=num;

}

return max(max1*max2*max3, max1*min1*min2);

}

};

Solution 2: Sorting

Time complexity: O(nlogn)

Space complexity: O(1)

// Author: Huahua

// Running time: 48 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

int n = nums.size();

sort(nums.rbegin(), nums.rend());

return max(nums[0] * nums[1] * nums[2], nums[0] * nums[n - 1] * nums[n - 2]);

}

};

Solution 3: Two Heaps (Priority Queues)

Time complexity: O(nlog3)

Space complexity: O(2 + 3)

// Author: Huahua

// Running time: 40 ms

class Solution {

public:

int maximumProduct(vector<int>& nums) {

priority_queue<int, vector<int>, less<int>> min_q; // max_heap

priority_queue<int, vector<int>, greater<int>> max_q; // min_heap

for (int num : nums) {

max_q.push(num);

if (max_q.size() > 3) max_q.pop();

min_q.push(num);

if (min_q.size() > 2) min_q.pop();

}

int max3 = max_q.top(); max_q.pop();

int max2 = max_q.top(); max_q.pop();

int max1 = max_q.top(); max_q.pop();

int min2 = min_q.top(); min_q.pop();

int min1 = min_q.top(); min_q.pop();

return max(max1 * max2 * max3, max1 * min1 * min2);

}

};

花花酱 LeetCode 463. Island Perimeter

By zxi on August 17, 2018

Problem

You are given a map in form of a two-dimensional integer grid where 1 represents land and 0 represents water. Grid cells are connected horizontally/vertically (not diagonally). The grid is completely surrounded by water, and there is exactly one island (i.e., one or more connected land cells). The island doesn’t have “lakes” (water inside that isn’t connected to the water around the island). One cell is a square with side length 1. The grid is rectangular, width and height don’t exceed 100. Determine the perimeter of the island.

Example:

[[0,1,0,0],
 [1,1,1,0],
 [0,1,0,0],
 [1,1,0,0]]

Answer: 16
Explanation: The perimeter is the 16 yellow stripes in the image below:

Solution: Counting

If a land has 0 neighbour, it contributes 4 to the perimeter

If a land has 1 neighbour, it contributes 3 to the perimeter

If a land has 2 neighbours, it contributes 2 to the perimeter

If a land has 3 neighbours, it contributes 1 to the perimeter

If a land has 4 neighbours, it contributes 0 to the perimeter

perimeter = area * 4 – total_neighbours

Time complexity: O(mn)

Space complexity: O(1)

// Author: Huahua

// Running time: 148 ms

class Solution {

public:

int islandPerimeter(vector<vector<int>>& grid) {

if (grid.empty()) return 0;

int m = grid.size();

int n = grid[0].size();

int area = 0;

int conn = 0;

for (int y = 0; y < m; ++y)

for (int x = 0; x < n; ++x)

if (grid[y][x] == 1) {

++area;

if (y > 0 && grid[y - 1][x] == 1) ++conn;

if (x > 0 && grid[y][x - 1] == 1) ++conn;

}

return area*4 - conn*2;

}

};

Huahua's Tech Road

花花酱 LeetCode 890. Find and Replace Pattern

Problem

Solution: Remember the last pos of each char.

花花酱 LeetCode 888. Fair Candy Swap

Problem

Solution: HashTable

花花酱 LeetCode 617. Merge Two Binary Trees

Problem

Solution: Recursion

花花酱 LeetCode 628. Maximum Product of Three Numbers

Problem

Idea:

Solution 1: Manual Tracking

Solution 2: Sorting

Solution 3: Two Heaps (Priority Queues)

花花酱 LeetCode 463. Island Perimeter

Problem

Solution: Counting