花花酱 LeetCode 546. Remove Boxes

By zxi on August 2, 2018

Problem

Given several boxes with different colors represented by different positive numbers.
You may experience several rounds to remove boxes until there is no box left. Each time you can choose some continuous boxes with the same color (composed of k boxes, k >= 1), remove them and get k*k points.
Find the maximum points you can get.

Example 1:
Input:

1	[1, 3, 2, 2, 2, 3, 4, 3, 1]

Output:

Explanation:

[1, 3, 2, 2, 2, 3, 4, 3, 1] 
----> [1, 3, 3, 4, 3, 1] (3*3=9 points) 
----> [1, 3, 3, 3, 1] (1*1=1 points) 
----> [1, 1] (3*3=9 points) 
----> [] (2*2=4 points)

Note: The number of boxes n would not exceed 100.

Solution: Recursion + Memorization

Use dp[l][r][k] to denote the max score of subarray box[l] ~ box[r] with k boxes after box[r] that have the same color as box[r]

box[l], box[l+1], …, box[r], box[r+1], …, box[r+k]

e.g. “CDABACAAAAA”

dp[2][6][4] is the max score of [ABACA] followed by [AAAA]
dp[2][6][3] is the max score of [ABACA] followed by [AAA]

base case: l > r, empty array, return 0.

Transition:
dp[l][r][k] = max(dp[l][r-1][0] + (k + 1)*(k + 1),  # case 1
                  dp[l][i][k+1] + dp[i+1][r-1][0])  # case 2
# "ABACA|AAAA" 
# case 1: dp("ABAC") + score("AAAAA") drop j and the tail.
# case 2: box[i] == box[r], l <= i < r, try all break points
# max({dp("A|AAAAA") + dp("BAC")}, {dp("ABA|AAAAA") + dp("C")})

Time complexity: O(n^4)

Space complexity: O(n^3)

C++

// Author: Huahua

// Running time: 196 ms

class Solution {

public:

int removeBoxes(vector<int>& boxes) {

const int n = boxes.size();

m_ = vector<vector<vector<int>>>(n, vector<vector<int>>(n, vector<int>(n)));

return dfs(boxes, 0, n - 1, 0);

}

private:

vector<vector<vector<int>>> m_;

int dfs(const vector<int>& boxes, int l, int r, int k) {

if (l > r) return 0;

if (m_[l][r][k] > 0) return m_[l][r][k];

m_[l][r][k] = dfs(boxes, l, r - 1, 0) + (k + 1) * (k + 1);

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

if (boxes[i] == boxes[r])

m_[l][r][k] = max(m_[l][r][k], dfs(boxes, l, i, k + 1) + dfs(boxes, i + 1, r - 1, 0));

return m_[l][r][k];

}

};

Optimized

// Author: Huahua

// Running time: 16 ms

int m[100][100][100];

class Solution {

public:

int removeBoxes(vector<int>& boxes) {

memset(m, 0, sizeof(m));

return dfs(boxes, 0, boxes.size() - 1, 0);

}

private:

int dfs(const vector<int>& boxes, int l, int r, int k) {

if (l > r) return 0;

if (m[l][r][k] > 0) return m[l][r][k];

int rr = r;

int kk = k;

while (l < r && boxes[r - 1] == boxes[r]) {--r; ++k;}

m[l][r][k] = dfs(boxes, l, r - 1, 0) + (k + 1) * (k + 1);

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

if (boxes[i] == boxes[r])

m[l][r][k] = max(m[l][r][k], dfs(boxes, l, i, k + 1) + dfs(boxes, i + 1, r - 1, 0));

for (int d = 1; d <= r - rr; ++d)

m[l][r + d][k - d] = m[l][r][k];

return m[l][r][k];

}

};

Use a HashTable to replace the 3D DP array since the DP array could be sparse when many consecutive boxes are the same color.

// Author: Huahua

// Running time: 8 ms (beats 100%)

class Solution {

public:

int removeBoxes(vector<int>& boxes) {

len_ = vector<int>(boxes.size());

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

if (boxes[i] == boxes[i - 1]) len_[i] = len_[i - 1] + 1;

return dfs(boxes, 0, boxes.size() - 1, 0);

}

private:

unordered_map<int, int> m_;

vector<int> len_;

int dfs(const vector<int>& boxes, int l, int r, int k) {

if (l > r) return 0;

k += len_[r];

r -= len_[r];

int key = (l * 100 + r) * 100 + k;

auto it = m_.find(key);

if (it != m_.end()) return it->second;

int& ans = m_[key];

ans = dfs(boxes, l, r - 1, 0) + (k + 1) * (k + 1);

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

if (boxes[i] == boxes[r])

ans = max(ans, dfs(boxes, l, i, k + 1) + dfs(boxes, i + 1, r - 1, 0));

return ans;

}

};

Problem

There are two types of soup: type A and type B. Initially we have N ml of each type of soup. There are four kinds of operations:

Serve 100 ml of soup A and 0 ml of soup B
Serve 75 ml of soup A and 25 ml of soup B
Serve 50 ml of soup A and 50 ml of soup B
Serve 25 ml of soup A and 75 ml of soup B

When we serve some soup, we give it to someone and we no longer have it. Each turn, we will choose from the four operations with equal probability 0.25. If the remaining volume of soup is not enough to complete the operation, we will serve as much as we can. We stop once we no longer have some quantity of both types of soup.

Note that we do not have the operation where all 100 ml’s of soup B are used first.

Return the probability that soup A will be empty first, plus half the probability that A and B become empty at the same time.

Example:
Input: N = 50
Output: 0.625
Explanation: 
If we choose the first two operations, A will become empty first. For the third operation, A and B will become empty at the same time. For the fourth operation, B will become empty first. So the total probability of A becoming empty first plus half the probability that A and B become empty at the same time, is 0.25 * (1 + 1 + 0.5 + 0) = 0.625.

Notes:

0 <= N <= 10^9.
Answers within 10^-6 of the true value will be accepted as correct.

Solution 1: Recursion with Memorization

Time complexity: O(N^2) N ~ 5000 / 25 = 200

Space complexity: O(N^2)

C++

// Author: Huahua

// Running time: 4 ms

class Solution {

public:

double soupServings(int N) {

if (N >= 5000) return 1.0;

return prob(N, N);

}

private:

unordered_map<int, unordered_map<int, double>> m_;

double prob(int A, int B) {

static int ops[][2] = {{100, 0}, {75, 25}, {50, 50}, {25, 75}};

if (A <= 0 && B <= 0) return 0.5;

if (A <= 0) return 1.0;

if (B <= 0) return 0.0;

if (m_.count(A) && m_[A].count(B)) return m_[A][B];

m_[A][B] = 0.0;

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

m_[A][B] += 0.25 * prob(A - ops[i][0], B - ops[i][1]);

return m_[A][B];

}

};

花花酱 LeetCode 881. Random Flip Matrix

By zxi on July 31, 2018

Problem

You are given the number of rows n_rows and number of columns n_cols of a 2D binary matrix where all values are initially 0. Write a function flip which chooses a 0 value uniformly at random, changes it to 1, and then returns the position [row.id, col.id] of that value. Also, write a function reset which sets all values back to 0. Try to minimize the number of calls to system’s Math.random() and optimize the time and space complexity.

Note:

1 <= n_rows, n_cols <= 10000
0 <= row.id < n_rows and 0 <= col.id < n_cols
flip will not be called when the matrix has no 0 values left.
the total number of calls to flip and reset will not exceed 1000.

Example 1:

Input: 
["Solution","flip","flip","flip","flip"]
[[2,3],[],[],[],[]]
Output: [null,[0,1],[1,2],[1,0],[1,1]]

Example 2:

Input: 
["Solution","flip","flip","reset","flip"]
[[1,2],[],[],[],[]]
Output: [null,[0,0],[0,1],null,[0,0]]

Explanation of Input Syntax:

The input is two lists: the subroutines called and their arguments. Solution‘s constructor has two arguments, n_rows and n_cols. flip and reset have no arguments. Arguments are always wrapped with a list, even if there aren’t any.

Solution 1: Hashtable + Resample

Time complexity: O(|flip|) = O(1000) = O(1)

Space complexity: O(|flip|) = O(1000) = O(1)

// Author: Huahua

// Running time: 12 ms

class Solution {

public:

Solution(int n_rows, int n_cols):

rows_(n_rows), cols_(n_cols), n_(rows_ * cols_) {}

vector<int> flip() {

int index = rand() % n_;

while (m_.count(index))

index = rand() % n_;

m_.insert(index);

return {index / cols_, index % cols_};

}

void reset() {

m_.clear();

n_ = rows_ * cols_;

}

private:

const int rows_;

const int cols_;

int n_;

unordered_set<int> m_;

};

Solution 2: Fisher–Yates shuffle

Generate a random shuffle of 0 to n – 1, one number at a time.

Time complexity: flip: O(1)

Space complexity: O(|flip|) = O(1000) = O(1)

C++

// Author: Huahua

// Running time: 12 ms

class Solution {

public:

Solution(int n_rows, int n_cols):

rows_(n_rows), cols_(n_cols), n_(rows_ * cols_) {}

vector<int> flip() {

int s = rand() % (n_--);

int index = s;

if (m_.count(s))

index = m_[s];

m_[s] = m_.count(n_) ? m_[n_] : n_;

return {index / cols_, index % cols_};

}

void reset() {

m_.clear();

n_ = rows_ * cols_;

}

private:

const int rows_;

const int cols_;

int n_;

unordered_map<int, int> m_;

};

Upgraded to HTTPS

By zxi on July 31, 2018

Purchased a SSL certificate and upgraded the blog to full https.

Please visit https://zxi.mytechroad.com/blog

Let me know if you encounter any problems.

花花酱 LeetCode 855. Exam Room

By zxi on July 29, 2018

Problem

In an exam room, there are N seats in a single row, numbered 0, 1, 2, ..., N-1.

When a student enters the room, they must sit in the seat that maximizes the distance to the closest person. If there are multiple such seats, they sit in the seat with the lowest number. (Also, if no one is in the room, then the student sits at seat number 0.)

Return a class ExamRoom(int N) that exposes two functions: ExamRoom.seat() returning an int representing what seat the student sat in, and ExamRoom.leave(int p) representing that the student in seat number p now leaves the room. It is guaranteed that any calls to ExamRoom.leave(p) have a student sitting in seat p.

Example 1:

Input: ["ExamRoom","seat","seat","seat","seat","leave","seat"], [[10],[],[],[],[],[4],[]]
Output: [null,0,9,4,2,null,5]
Explanation:
ExamRoom(10) -> null
seat() -> 0, no one is in the room, then the student sits at seat number 0.
seat() -> 9, the student sits at the last seat number 9.
seat() -> 4, the student sits at the last seat number 4.
seat() -> 2, the student sits at the last seat number 2.
leave(4) -> null
seat() -> 5, the student sits at the last seat number 5.

Note:

1 <= N <= 10^9
ExamRoom.seat() and ExamRoom.leave() will be called at most 10^4 times across all test cases.
Calls to ExamRoom.leave(p) are guaranteed to have a student currently sitting in seat number p.

Solution: BST

Use a BST (ordered set) to track the current seatings.

Time Complexity:

init: O(1)

seat: O(P)

leave: O(logP)

Space complexity: O(P)

// Author: Huahua

// Running time: 24 ms

class ExamRoom {

public:

ExamRoom(int N): N_(N) {}

int seat() {

int p = 0;

int max_dist = s_.empty() ? 0 : *s_.begin();

auto left = s_.begin();

auto right = left;

while (left != s_.end()) {

++right;

int l = *left;

int r = right != s_.end() ? *right : (2 * (N_ - 1) - *left);

int d = (r - l) / 2;

if (d > max_dist) {

max_dist = d;

p = l + d;

}

left = right;

}

s_.insert(p);

return p;

}

void leave(int p) {

s_.erase(p);

}

private:

const int N_;

set<int> s_;

};

花花酱 LeetCode 546. Remove Boxes

Problem

Solution: Recursion + Memorization

Related Problems

花花酱 LeetCode 808. Soup Servings

Problem

Solution 1: Recursion with Memorization

花花酱 LeetCode 881. Random Flip Matrix

Problem

Solution 1: Hashtable + Resample

Solution 2: Fisher–Yates shuffle

Upgraded to HTTPS

花花酱 LeetCode 855. Exam Room

Problem

Solution: BST

Huahua's Tech Road

花花酱 LeetCode 546. Remove Boxes

Problem

Solution: Recursion + Memorization

Related Problems

花花酱 LeetCode 808. Soup Servings

Problem

Solution 1: Recursion with Memorization

花花酱 LeetCode 881. Random Flip Matrix

Problem

Solution 1: Hashtable + Resample

Solution 2: Fisher–Yates shuffle

Upgraded to HTTPS

花花酱 LeetCode 855. Exam Room

Problem

Solution: BST