Huahua’s Tech Road

花花酱 LeetCode 57. Insert Interval

By zxi on October 14, 2017

Problem:

Given a set of non-overlapping intervals, insert a new interval into the intervals (merge if necessary).

You may assume that the intervals were initially sorted according to their start times.

Example 1:
Given intervals [1,3],[6,9], insert and merge [2,5] in as [1,5],[6,9].

Example 2:
Given [1,2],[3,5],[6,7],[8,10],[12,16], insert and merge [4,9] in as [1,2],[3,10],[12,16].

This is because the new interval [4,9] overlaps with [3,5],[6,7],[8,10].

Idea:

Find the position of the new interval, insert it into the list and call MergeIntervals in LeetCode 56

Solution:

C++

// Author: Huahua

// Runtime: 16 ms

class Solution {

public:

vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {

auto it = intervals.begin();

while (it != intervals.end() && newInterval.start > it->start) ++it;

intervals.insert(it, newInterval);

// Merge intervals without sorting

vector<Interval> ans;

for (const auto& interval : intervals) {

if (ans.empty() || interval.start > ans.back().end) {

ans.push_back(interval);

} else {

ans.back().end = max(ans.back().end, interval.end);

}

return ans;

}

};

Python

"""

Author: Huahua

Runtime: 78 ms

"""

class Solution(object):

def insert(self, intervals, newInterval):

index = len(intervals)

for i in range(len(intervals)):

if newInterval.start < intervals[i].start:

index = i

break

intervals.insert(index, newInterval)

ans = []

for interval in intervals:

if not ans or interval.start > ans[-1].end:

ans.append(interval)

else:

ans[-1].end = max(ans[-1].end, interval.end)

return ans

Solution 2:

C++

// Author: Huahua

// Runtime: 13 ms

class Solution {

public:

vector<Interval> insert(vector<Interval>& intervals, Interval newInterval) {

vector<Interval> l;

vector<Interval> r;

int start = newInterval.start;

int end = newInterval.end;

for (const Interval& interval : intervals) {

if (interval.end < start)

l.push_back(interval);

else if (interval.start > end)

r.push_back(interval);

else {

start = min(start, interval.start);

end = max(end, interval.end);

}

vector<Interval> ans(std::move(l));

ans.emplace_back(start, end);

ans.insert(ans.end(), r.begin(), r.end());

return ans;

}

};

Python

"""

Author: Huahua

Runtime: 68 ms

"""

class Solution(object):

def insert(self, intervals, newInterval):

start, end = newInterval.start, newInterval.end

l, r = [], []

for interval in intervals:

if interval.end < start: l += interval,

elif interval.start > end: r += interval,

else:

start = min(start, interval.start)

end = max(end, interval.end)

return l + [Interval(start, end)] + r

Related problems:

花花酱 LeetCode 56. Merge Intervals

By zxi on October 14, 2017

Problem:

Given a collection of intervals, merge all overlapping intervals.

For example,
Given [1,3],[2,6],[8,10],[15,18],
return [1,6],[8,10],[15,18].

Idea:

Sweep line

Solution:

C++

// Author: Huahua

// Runtime: 12 ms

class Solution {

public:

vector<Interval> merge(vector<Interval>& intervals) {

if (intervals.empty()) return {};

std::sort(intervals.begin(), intervals.end(),

[](const Interval& a, const Interval& b){

return a.start < b.start;

});

vector<Interval> ans;

for (const auto& interval : intervals) {

if (ans.empty() || interval.start > ans.back().end) {

ans.push_back(interval);

} else {

ans.back().end = max(ans.back().end, interval.end);

}

return ans;

}

};

Python

"""

Author: Huahua

Runtime: 69 ms

"""

class Solution(object):

def merge(self, intervals):

ans = []

for interval in sorted(intervals, key=lambda x: x.start):

if not ans or interval.start > ans[-1].end:

ans.append(interval)

else:

ans[-1].end = max(ans[-1].end, interval.end)

return ans

Related Problems:

花花酱 LeetCode 488. Zuma Game

By zxi on October 9, 2017

https://leetcode.com/problems/zuma-game/description/

Problem:

Think about Zuma Game. You have a row of balls on the table, colored red(R), yellow(Y), blue(B), green(G), and white(W). You also have several balls in your hand.

Each time, you may choose a ball in your hand, and insert it into the row (including the leftmost place and rightmost place). Then, if there is a group of 3 or more balls in the same color touching, remove these balls. Keep doing this until no more balls can be removed.

Find the minimal balls you have to insert to remove all the balls on the table. If you cannot remove all the balls, output -1.

Examples:
Input: “WRRBBW”, “RB”
Output: -1
Explanation: WRRBBW -> WRR[R]BBW -> WBBW -> WBB[B]W -> WW

Input: “WWRRBBWW”, “WRBRW”
Output: 2
Explanation: WWRRBBWW -> WWRR[R]BBWW -> WWBBWW -> WWBB[B]WW -> WWWW -> empty

Input:“G”, “GGGGG”
Output: 2
Explanation: G -> G[G] -> GG[G] -> empty

Input: “RBYYBBRRB”, “YRBGB”
Output: 3
Explanation: RBYYBBRRB -> RBYY[Y]BBRRB -> RBBBRRB -> RRRB -> B -> B[B] -> BB[B] -> empty

Note:

You may assume that the initial row of balls on the table won’t have any 3 or more consecutive balls with the same color.
The number of balls on the table won’t exceed 20, and the string represents these balls is called “board” in the input.
The number of balls in your hand won’t exceed 5, and the string represents these balls is called “hand” in the input.
Both input strings will be non-empty and only contain characters ‘R’,’Y’,’B’,’G’,’W’.

Idea: Search

Solution1: C++ / Search

// Author: Huahua

// Runtime: 3 ms

class Solution {

public:

int findMinStep(string board, string hand) {

vector<int> h(128, 0);

for (char color : hand) ++h[color];

return dfs(board, h);

}

private:

// Return the min # of balls needed in hand to clear the board.

// Returns -1 if not possible.

int dfs(const string& board, vector<int>& hand) {

if (board.empty()) return 0;

int ans = INT_MAX;

int i = 0;

int j = 0;

while (i < board.size()) {

while (j < board.size() && board[i] == board[j]) ++j;

// board[i] ~ board[j - 1] have the same color

const char color = board[i];

// Number of balls needed to clear board[i] ~ board[j - 1]

const int b = 3 - (j - i);

// Have sufficient balls in hand

if (hand[color] >= b) {

// Remove board[i] ~ board[j - 1] and update the board

string nb = update(board.substr(0, i) + board.substr(j));

// Find the solution on new board with updated hand

hand[color] -= b;

int r = dfs(nb, hand);

if (r >= 0) ans = min(ans, r + b);

// Recover the balls in hand

hand[color] += b;

}

i = j;

}

return ans == INT_MAX ? -1 : ans;

}

// Update the board by removing all consecutive 3+ balls.

// "YWWRRRWWYY" -> "YWWWWYY" -> "YYY" -> ""

string update(string board) {

int i = 0;

while (i < board.size()) {

int j = i;

while (j < board.size() && board[i] == board[j]) ++j;

if (j - i >= 3) {

board = board.substr(0, i) + board.substr(j);

i = 0;

} else {

++i;

}

return board;

}

};

花花酱 LeetCode 693. Binary Number with Alternating Bits

By zxi on October 7, 2017

Problem:

Given a positive integer, check whether it has alternating bits: namely, if two adjacent bits will always have different values.

Example 1:

Input: 5

Output: True

Explanation:

The binary representation of 5 is: 101

Example 2:

Input: 7

Output: False

Explanation:

The binary representation of 7 is: 111.

Example 3:

Input: 11

Output: False

Explanation:

The binary representation of 11 is: 1011.

Example 4:

Input: 10

Output: True

Explanation:

The binary representation of 10 is: 1010.

Idea:

Bit operation

Solution

C++

// Author: Huahua

// Runtime: 6 ms

class Solution {

public:

bool hasAlternatingBits(int n) {

int r = n & 1;

while ((n >>= 1) > 0) {

int t = n & 1;

if (t == r) return false;

r = t;

}

return true;

}

};

花花酱 LeetCode 695. Max Area of Island

By zxi on October 7, 2017

Problem:

Given a non-empty 2D array grid of 0’s and 1’s, an island is a group of 1‘s (representing land) connected 4-directionally (horizontal or vertical.) You may assume all four edges of the grid are surrounded by water.

Find the maximum area of an island in the given 2D array. (If there is no island, the maximum area is 0.)

Example 1:

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

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

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

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

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

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

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

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

Given the above grid, return 6. Note the answer is not 11, because the island must be connected 4-directionally.

Example 2:

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

Given the above grid, return 0.

Note: The length of each dimension in the given grid does not exceed 50.

Idea:

Use DFS to find the connected components

Solution:

C++

// Author: Huahua

// Runtime: 32 ms

class Solution {

public:

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

int h = grid.size();

if (h == 0) return 0;

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

int ans = 0;

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

for (int j = 0; j < w; ++j)

ans = max(ans, area(grid, j, i, w, h));

return ans;

}

private:

int area(vector<vector<int>>& grid, int x, int y, int w, int h) {

if (x < 0 || y < 0 || x >= w || y >= h || grid[y][x] == 0) return 0;

grid[y][x] = 0;

return area(grid, x - 1, y, w, h)

+ area(grid, x + 1, y, w, h)

+ area(grid, x, y - 1, w, h)

+ area(grid, x, y + 1, w, h)

+ 1;

}

};

Related problems:

Huahua's Tech Road

花花酱 LeetCode 57. Insert Interval

花花酱 LeetCode 56. Merge Intervals

花花酱 LeetCode 488. Zuma Game

花花酱 LeetCode 693. Binary Number with Alternating Bits

花花酱 LeetCode 695. Max Area of Island