花花酱 LeetCode 704. Binary Search

By zxi on July 12, 2018

Problem

Given a sorted (in ascending order) integer array nums of n elements and a target value, write a function to search target in nums. If target exists, then return its index, otherwise return -1.

Example 1:

Input: nums = [-1,0,3,5,9,12], target = 9 Output: 4 Explanation: 9 exists in nums and its index is 4

Example 2:

Input: nums = [-1,0,3,5,9,12], target = 2 Output: -1 Explanation: 2 does not exist in nums so return -1

Note:

You may assume that all elements in nums are unique.
n will be in the range [1, 10000].
The value of each element in nums will be in the range [-9999, 9999].

Solution: Binary Search

Time complexity: O(logn)

Space complexity: O(1)

// Author: Huahua

// Running time: 32 ms

class Solution {

public:

int search(vector<int>& nums, int target) {

int l = 0;

int r = nums.size();

while (l < r) {

int m = (r - l) / 2 + l;

if (nums[m] == target)

return m;

else if (nums[m] > target)

r = m;

else

l = m + 1;

}

return -1;

}

};

STL

// Author: Huahua

// Running time: 36 ms

class Solution {

public:

int search(vector<int>& nums, int target) {

auto it = lower_bound(nums.begin(), nums.end(), target);

if (it == nums.end() || *it != target) return -1;

return it - nums.begin();

}

};

花花酱 LeetCode 709. To Lower Case

By zxi on July 12, 2018

Problem

Implement function ToLowerCase() that has a string parameter str, and returns the same string in lowercase.

Solution

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 0 ms

class Solution {

public:

string toLowerCase(string str) {

for (char &c : str)

if (c >= 'A' && c <= 'Z') c = c - 'A' + 'a';

return str;

}

};

Java

// Author: Huahua, 1 ms

class Solution {

public String toLowerCase(String str) {

char[] s = str.toCharArray();

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

if (s[i] >= 'A' && s[i] <= 'Z') s[i] = (char)(s[i] - 'A' + 'a');

return new String(s);

}

Python3

# Author: Huahua, 40 ms

class Solution:

def toLowerCase(self, str):

ans = ''

for c in str:

if c >= 'A' and c <= 'Z':

ans += chr(ord(c) + 32)

else:

ans += c

return ans

Python3 1-linear

# Author: Huahua, 68 ms

class Solution:

def toLowerCase(self, str):

return ''.join(chr(ord(c) + 32) if c >= 'A' and c <= 'Z' else c for c in str)

花花酱 LeetCode 775. Global and Local Inversions

By zxi on July 9, 2018

Problem

We have some permutation A of [0, 1, ..., N - 1], where N is the length of A.

The number of (global) inversions is the number of i < j with 0 <= i < j < N and A[i] > A[j].

The number of local inversions is the number of i with 0 <= i < N and A[i] > A[i+1].

Return true if and only if the number of global inversions is equal to the number of local inversions.

Example 1:

Input: A = [1,0,2]
Output: true
Explanation: There is 1 global inversion, and 1 local inversion.

Example 2:

Input: A = [1,2,0]
Output: false
Explanation: There are 2 global inversions, and 1 local inversion.

Note:

A will be a permutation of [0, 1, ..., A.length - 1].
A will have length in range [1, 5000].
The time limit for this problem has been reduced.

Solution1: Brute Force (TLE)

Time complexity: O(n^2)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: TLE (208/208 test cases passed)

class Solution {

public:

bool isIdealPermutation(vector<int>& A) {

const int n = A.size();

int local = 0;

for (int i = 0; i < n - 1; ++i)

if (A[i] > A[i + 1]) ++local;

int global = 0;

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

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

if (A[i] > A[j] && ++global > local) return false;

return global == local;

}

};

Solution2: MergeSort

Time complexity: O(nlogn)

Space complexity: O(n)

// Author: Huahua

// Running time: 52 ms (<96.42%)

class Solution {

public:

bool isIdealPermutation(vector<int>& A) {

const int n = A.size();

int local = 0;

for (int i = 0; i < n - 1; ++i)

if (A[i] > A[i + 1]) ++local;

tmp = vector<int>(n);

int global = mergeSort(A, 0, n - 1);

return global == local;

}

private:

vector<int> tmp;

int mergeSort(vector<int>& A, int l, int r) {

if (l >= r) return 0;

const int len = r - l + 1;

int m = (r - l) / 2 + l;

int inv = mergeSort(A, l, m) + mergeSort(A, m + 1, r);

int i = l;

int j = m + 1;

int k = 0;

while (i <= m && j <= r) {

if (A[i] <= A[j]) {

tmp[k++] = A[i++];

} else {

tmp[k++] = A[j++];

inv += m - i + 1;

}

while (i <= m) tmp[k++] = A[i++];

while (j <= r) tmp[k++] = A[j++];

std::copy(tmp.begin(), tmp.begin() + len, A.begin() + l);

return inv;

}

};

// Author: Huahua

// Running time: 208 ms

public class Solution {

public bool IsIdealPermutation(int[] A) {

var n = A.Length;

var localInv = 0;

for (var i = 1; i < n; ++i)

if (A[i] < A[i - 1]) ++localInv;

tmp = new int[n];

var globalInv = MergeSort(A, 0, n - 1);

return localInv == globalInv;

}

private int[] tmp;

private int MergeSort(int[] A, int l, int r) {

if (l >= r) return 0;

int m = (r - l) / 2 + l;

int inv = MergeSort(A, l, m) + MergeSort(A, m + 1, r);

int i = l;

int j = m + 1;

int k = 0;

while (i <= m && j <= r) {

if (A[i] <= A[j]) {

tmp[k++] = A[i++];

} else {

inv += m - i + 1;

tmp[k++] = A[j++];

}

while (i <= m) tmp[k++] = A[i++];

while (j <= r) tmp[k++] = A[j++];

Array.Copy(tmp, 0, A, l, k);

return inv;

}

Solution3: Input Property

Input is a permutation of [0, 1, …, N – 1]

Time Complexity: O(n)

Space Complexity: O(1)

// Author: Huahua

// Running time: 40 ms (<99.26%)

class Solution {

public:

bool isIdealPermutation(vector<int>& A) {

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

if (abs(A[i] - i) > 1) return false;

return true;

}

};

花花酱 LeetCode 864. Shortest Path to Get All Keys

By zxi on July 8, 2018

Problem

We are given a 2-dimensional grid. "." is an empty cell, "#" is a wall, "@" is the starting point, ("a", "b", …) are keys, and ("A", "B", …) are locks.

We start at the starting point, and one move consists of walking one space in one of the 4 cardinal directions. We cannot walk outside the grid, or walk into a wall. If we walk over a key, we pick it up. We can’t walk over a lock unless we have the corresponding key.

For some 1 <= K <= 6, there is exactly one lowercase and one uppercase letter of the first K letters of the English alphabet in the grid. This means that there is exactly one key for each lock, and one lock for each key; and also that the letters used to represent the keys and locks were chosen in the same order as the English alphabet.

Return the lowest number of moves to acquire all keys. If it’s impossible, return -1.

Example 1:

Input: ["@.a.#","###.#","b.A.B"]
Output: 8

Example 2:

Input: ["@..aA","..B#.","....b"]
Output: 6

Note:

1 <= grid.length <= 30
1 <= grid[0].length <= 30
grid[i][j] contains only '.', '#', '@', 'a'-'f' and 'A'-'F'
The number of keys is in [1, 6]. Each key has a different letter and opens exactly one lock.

Solution: BFS

Time complexity: O(m*n*64)

Space complexity: O(m*n*64)

C++

// Author: Huahua

// Running time: 8 ms

class Solution {

public:

int shortestPathAllKeys(vector<string>& grid) {

int m = grid.size();

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

int all_keys = 0;

queue<int> q;

vector<vector<vector<int>>> seen(m, vector<vector<int>>(n, vector<int>(64, 0)));

// Init

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

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

const char c = grid[i][j];

if (c == '@') {

q.push((j << 16) | (i << 8));

seen[i][j][0] = 1;

} else if (c >= 'a' && c <= 'f') {

all_keys |= (1 << (c - 'a'));

}

const vector<int> dirs{-1, 0, 1, 0, -1};

int steps = 0;

while (!q.empty()) {

int size = q.size();

while (size--) {

int s = q.front(); q.pop();

int x = s >> 16;

int y = (s >> 8) & 0xFF;

int keys = s & 0xFF;

if (keys == all_keys) return steps;

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

int nkeys = keys;

int nx = x + dirs[i];

int ny = y + dirs[i + 1];

if (nx < 0 || nx >= n || ny < 0 || ny >= m) continue;

const char c = grid[ny][nx];

if (c == '#') continue; // Wall

// Do not have the key.

if (c >= 'A' && c <= 'F' && !(keys & (1 << (c - 'A')))) continue;

// Update the keys we have.

if (c >= 'a' && c <= 'f') nkeys |= (1 << (c - 'a'));

if (seen[ny][nx][nkeys]) continue;

q.push((nx << 16) | (ny << 8) | nkeys);

seen[ny][nx][nkeys] = 1;

}

++steps;

}

return -1;

}

};

Python3

# Author: Huahua, 390 ms

class Solution:

def shortestPathAllKeys(self, grid):

m, n = len(grid), len(grid[0])

all_keys = 0

seen = [[[None]* 64 for _ in range(n)] for _ in range(m)]

q = collections.deque()

for i in range(m):

for j in range(n):

c = grid[i][j]

if c == '@':

q.append((j << 16) | (i << 8))

seen[i][j][0] = 1

elif c >= 'a' and c <= 'f':

all_keys |= (1 << (ord(c) - ord('a')))

dirs = [-1, 0, 1, 0, -1]

steps = 0

while q:

size = len(q)

while size > 0:

size -= 1

s = q.popleft()

x = s >> 16

y = (s >> 8) & 0xff

keys = s & 0xff

if keys == all_keys: return steps

for i in range(4):

nx, ny, nkeys = x + dirs[i], y + dirs[i + 1], keys

if nx < 0 or nx >= n or ny < 0 or ny >= m: continue

c = grid[ny][nx]

if c == '#': continue

if c in string.ascii_uppercase and keys & (1 << (ord(c) - ord('A'))) == 0: continue

if c in string.ascii_lowercase: nkeys |= (1 << (ord(c) - ord('a')))

if seen[ny][nx][nkeys]: continue

q.append((nx << 16) | (ny << 8) | nkeys)

seen[ny][nx][nkeys] = 1

steps += 1

return -1

Problem

Two strings X and Y are similar if we can swap two letters (in different positions) of X, so that it equals Y.

For example, "tars" and "rats" are similar (swapping at positions 0 and 2), and "rats" and "arts" are similar, but "star" is not similar to "tars", "rats", or "arts".

Together, these form two connected groups by similarity: {"tars", "rats", "arts"} and {"star"}. Notice that "tars" and "arts" are in the same group even though they are not similar. Formally, each group is such that a word is in the group if and only if it is similar to at least one other word in the group.

We are given a list A of strings. Every string in A is an anagram of every other string in A. How many groups are there?

Example 1:

Input: ["tars","rats","arts","star"]
Output: 2

Note:

A.length <= 2000
A[i].length <= 1000
A.length * A[i].length <= 20000
All words in A consist of lowercase letters only.
All words in A have the same length and are anagrams of each other.
The judging time limit has been increased for this question.

Solution: Brute Force + Union Find

Time Complexity: O(n^2 * L)

Space Complexity: O(n)

C++

// Author: Huahua

// Running time: 230 ms (<99.08%)

class DSU {

public:

DSU(int size):size_(size), parent_(size), rank_(size) {

iota(begin(parent_), end(parent_), 0);

}

int Find(int n) {

if (parent_[n] != n)

parent_[n] = Find(parent_[n]);

return parent_[n];

}

void Union(int x, int y) {

int px = Find(x);

int py = Find(y);

if (px == py) return;

if (rank_[py] > rank_[px])

swap(px, py);

else if (rank_[py] == rank_[px])

++rank_[px];

parent_[py] = px;

--size_;

}

int Size() const {

return size_;

}

private:

int size_;

vector<int> ranks_;

vector<int> parent_;

};

class Solution {

public:

int numSimilarGroups(vector<string>& A) {

DSU dsu(A.size());

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

for (int j = i + 1; j < A.size(); ++j)

if (similar(A[i], A[j]))

dsu.Union(i, j);

return dsu.Size();

}

private:

bool similar(const string& a, const string& b) {

int diff = 0;

for (int i = 0; i < a.length(); ++i)

if (a[i] != b[i] && ++diff > 2) return false;

return true;

}

};

花花酱 LeetCode 704. Binary Search

Problem

Solution: Binary Search

花花酱 LeetCode 709. To Lower Case

Problem

Solution

C++

Java

Python3

Python3 1-linear

花花酱 LeetCode 775. Global and Local Inversions

Problem

Solution1: Brute Force (TLE)

Solution2: MergeSort

Solution3: Input Property

花花酱 LeetCode 864. Shortest Path to Get All Keys

Problem

Solution: BFS

C++

Python3

Related Problems

花花酱 LeetCode 839. Similar String Groups

Problem

Solution: Brute Force + Union Find

Huahua's Tech Road

花花酱 LeetCode 704. Binary Search

Problem

Solution: Binary Search

花花酱 LeetCode 709. To Lower Case

Problem

Solution

C++

Java

Python3

Python3 1-linear

花花酱 LeetCode 775. Global and Local Inversions

Problem

Solution1: Brute Force (TLE)

Solution2: MergeSort

Solution3: Input Property

花花酱 LeetCode 864. Shortest Path to Get All Keys

Problem

Solution: BFS

C++

Python3

Related Problems

花花酱 LeetCode 839. Similar String Groups

Problem

Solution: Brute Force + Union Find