花花酱 LeetCode 1274. Number of Ships in a Rectangle

By zxi on December 1, 2019

(This problem is an interactive problem.)

On the sea represented by a cartesian plane, each ship is located at an integer point, and each integer point may contain at most 1 ship.

You have a function Sea.hasShips(topRight, bottomLeft) which takes two points as arguments and returns true if and only if there is at least one ship in the rectangle represented by the two points, including on the boundary.

Given two points, which are the top right and bottom left corners of a rectangle, return the number of ships present in that rectangle. It is guaranteed that there are at most 10 ships in that rectangle.

Submissions making more than 400 calls to hasShips will be judged Wrong Answer. Also, any solutions that attempt to circumvent the judge will result in disqualification.

Example :

Input: 
ships = [[1,1],[2,2],[3,3],[5,5]], topRight = [4,4], bottomLeft = [0,0]
Output: 3
Explanation: From [0,0] to [4,4] we can count 3 ships within the range.

Constraints:

On the input ships is only given to initialize the map internally. You must solve this problem “blindfolded”. In other words, you must find the answer using the given hasShips API, without knowing the ships position.
0 <= bottomLeft[0] <= topRight[0] <= 1000
0 <= bottomLeft[1] <= topRight[1] <= 1000

Solution: Divide and Conquer

If the current rectangle contains ships, subdivide it into 4 smaller ones until
1) no ships contained
2) the current rectangle is a single point (e.g. topRight == bottomRight)

Time complexity: O(logn)
Space complexity: O(logn)

C++

// Author: Huahua

class Solution {

public:

// Modify the interface to pass sea as a reference.

int countShips(Sea& sea, vector<int> topRight, vector<int> bottomLeft) {

int x1 = bottomLeft[0], y1 = bottomLeft[1];

int x2 = topRight[0], y2 = topRight[1];

if (x1 > x2 || y1 > y2 || !sea.hasShips(topRight, bottomLeft))

return 0;

if (x1 == x2 && y1 == y2)

return 1;

int xm = x1 + (x2 - x1) / 2;

int ym = y1 + (y2 - y1) / 2;

return countShips(sea, {xm, ym}, {x1, y1}) + countShips(sea, {xm, y2}, {x1, ym + 1})

+ countShips(sea, {x2, ym}, {xm + 1, y1}) + countShips(sea, {x2, y2}, {xm + 1, ym + 1});

}

};

花花酱 LeetCode 23. Merge k Sorted Lists

By zxi on June 22, 2019

Merge k sorted linked lists and return it as one sorted list. Analyze and describe its complexity.

Example:

Input:
[
  1->4->5,
  1->3->4,
  2->6
]
Output: 1->1->2->3->4->4->5->6

Solution 1: Min heap

Time complexity: O(nklogk)
Space complexity: O(k)

C++

// Author: Huahua

class Solution {

public:

ListNode* mergeKLists(vector<ListNode*>& lists) {

ListNode dummy(0);

ListNode *tail = &dummy;

auto comp = [](ListNode* a, ListNode* b) { return a->val > b->val; };

priority_queue<ListNode*, vector<ListNode*>, decltype(comp)> q(comp);

for (ListNode* list : lists)

if (list) q.push(list);

while (!q.empty()) {

tail->next = q.top(); q.pop();

tail = tail->next;

if (tail->next) q.push(tail->next);

}

return dummy.next;

}

};

Solution 2: Merge Sort

Time complexity: O(nklogk)
Space complexity: O(logk)

C++

// Author: Huahua

class Solution {

public:

ListNode* mergeKLists(vector<ListNode*>& lists) {

return merge(lists, 0, lists.size() - 1);

}

private:

ListNode* merge(vector<ListNode*>& lists, int l, int r) {

if (l > r) return nullptr;

if (l == r) return lists[l];

if (l + 1 == r) return mergeTwoLists(lists[l], lists[r]);

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

auto l1 = merge(lists, l, m);

auto l2 = merge(lists, m + 1, r);

return mergeTwoLists(l1, l2);

}

ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {

ListNode dummy(0);

ListNode* tail = &dummy;

while (l1 && l2) {

if (l1->val > l2->val) swap(l1, l2);

tail->next = l1;

l1 = l1->next;

tail = tail->next;

}

if (l1) tail->next = l1;

if (l2) tail->next = l2;

return dummy.next;

}

};

花花酱 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 856. Score of Parentheses

By zxi on June 26, 2018

Problem

Given a balanced parentheses string S, compute the score of the string based on the following rule:

() has score 1
AB has score A + B, where A and B are balanced parentheses strings.
(A) has score 2 * A, where A is a balanced parentheses string.

Example 1:

Input: "()"
Output: 1

Example 2:

Input: "(())"
Output: 2

Example 3:

Input: "()()"
Output: 2

Example 4:

Input: "(()(()))"
Output: 6

Solution1: Recursion

Time complexity: O(n^2)

Space complexity: O(n)

// Author: Huahua

// Running time: 4ms

class Solution {

public:

int scoreOfParentheses(string S) {

return score(S, 0, S.length() - 1);

}

private:

int score(const string& S, int l, int r) {

if (r - l == 1) return 1; // "()"

int b = 0;

for (int i = l; i < r; ++i) {

if (S[i] == '(') ++b;

if (S[i] == ')') --b;

if (b == 0) // balanced

// score("(A)(B)") = score("(A)") + score("(B)")

return score(S, l, i) + score(S, i + 1, r);

}

// score("(A)") = 2 * score("A")

return 2 * score(S, l + 1, r - 1);

}

};

Solution2: Counting

Time complexity: O(n)

Space complexity: O(1)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

int scoreOfParentheses(string S) {

int ans = 0;

int d = -1;

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

d += S[i] == '(' ? 1 : -1;

if (S[i] == '(' && S[i + 1] == ')')

ans += 1 << d;

}

return ans;

}

};

Posts tagged as “divide and conquer”

花花酱 LeetCode 1274. Number of Ships in a Rectangle

Solution: Divide and Conquer

C++

花花酱 LeetCode 23. Merge k Sorted Lists

Solution 1: Min heap

C++

Solution 2: Merge Sort

C++

花花酱 LeetCode 775. Global and Local Inversions

Problem

Solution1: Brute Force (TLE)

Solution2: MergeSort

Solution3: Input Property

花花酱 LeetCode 856. Score of Parentheses

Problem

Solution1: Recursion

Solution2: Counting