Huahua's Tech Road

花花酱 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:

花花酱 LeetCode 685. Redundant Connection II

By zxi on October 7, 2017

Problem:

In this problem, a rooted tree is a directed graph such that, there is exactly one node (the root) for which all other nodes are descendants of this node, plus every node has exactly one parent, except for the root node which has no parents.

The given input is a directed graph that started as a rooted tree with N nodes (with distinct values 1, 2, …, N), with one additional directed edge added. The added edge has two different vertices chosen from 1 to N, and was not an edge that already existed.

The resulting graph is given as a 2D-array of edges. Each element of edges is a pair [u, v] that represents a directed edge connecting nodes u and v, where u is a parent of child v.

Return an edge that can be removed so that the resulting graph is a rooted tree of N nodes. If there are multiple answers, return the answer that occurs last in the given 2D-array.

Example 1:

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

Output: [2,3]

Explanation: The given directed graph will be like this:

/ \

v v

2-->3

Example 2:

Input: [[1,2], [2,3], [3,4], [4,1], [1,5]]

Output: [4,1]

Explanation: The given directed graph will be like this:

5 <- 1 -> 2

^ |

| v

4 <- 3

Note:

The size of the input 2D-array will be between 3 and 1000.
Every integer represented in the 2D-array will be between 1 and N, where N is the size of the input array.

Idea:

Union Find

Time complexity: O(nlog*n) ~ O(n)

Space complexity: O(n)

Solution:

C++

// Author: Huahua

// Runtime: 6 ms

class Solution {

public:

vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {

vector<int> parents(edges.size() + 1, 0);

vector<int> roots(edges.size() + 1, 0);

vector<int> sizes(edges.size() + 1, 1);

vector<int> ans1;

vector<int> ans2;

for(auto& edge: edges) {

int u = edge[0];

int v = edge[1];

// A node has two parents

if (parents[v] > 0) {

ans1 = {parents[v], v};

ans2 = edge;

// Delete the later edge

edge[0] = edge[1] = -1;

}

parents[v] = u;

}

for(const auto& edge: edges) {

int u = edge[0];

int v = edge[1];

// Invalid edge (we deleted in step 1)

if (u < 0 || v < 0) continue;

if (!roots[u]) roots[u] = u;

if (!roots[v]) roots[v] = v;

int pu = find(u, roots);

int pv = find(v, roots);

// Both u and v are already in the tree

if (pu == pv)

return ans1.empty() ? edge : ans1;

// Unoin, always merge smaller set (pv) to larger set (pu)

if (sizes[pv] > sizes[pu])

swap(pu, pv);

roots[pv] = pu;

sizes[pu] += sizes[pv];

}

return ans2;

}

private:

int find(int node, vector<int>& roots) {

while (roots[node] != node) {

roots[node] = roots[roots[node]];

node = roots[node];

}

return node;

}

};

C++ / without using Union find

// Author: Huahua

// Runtime: 6 ms

class Solution {

public:

vector<int> findRedundantDirectedConnection(vector<vector<int>>& edges) {

vector<int> parents(edges.size() + 1, 0);

vector<int> ans1;

vector<int> ans2;

bool dup_parents = false;

for(auto& edge: edges) {

int u = edge[0];

int v = edge[1];

// A node has two parents

if (parents[v] > 0) {

ans1 = {parents[v], v};

ans2 = edge;

dup_parents = true;

// Delete the later edge

edge[0] = edge[1] = -1;

} else {

parents[v] = u;

}

// Reset parents

parents = vector<int>(edges.size() + 1, 0);

for(const auto& edge: edges) {

int u = edge[0];

int v = edge[1];

// Invalid edge (we deleted in step 1)

if (u < 0 || v < 0) continue;

parents[v] = u;

if (cycle(v, parents))

return dup_parents ? ans1 : edge;

}

return ans2;

}

private:

bool cycle(int v, const vector<int>& parents) {

int u = parents[v];

while (u) {

if (u == v) return true;

u = parents[u];

}

return false;

}

};

Python

"""

Author: Huahua

Runtime: 62 ms

"""

class Solution:

def findRedundantDirectedConnection(self, edges):

def cycle(v, p):

u = p[v]

while u != 0:

if u == v: return True

u = p[u]

return False

n = len(edges)

p = [0] * (n + 1)

ans1 = []

ans2 = []

dup_p = False

for e in edges:

u, v = e

if p[v] > 0:

ans1 = [p[v], v]

ans2 = [u, v]

dup_p = True

e[0] = e[1] = -1

else:

p[v] = u

p = [0] * (n + 1)

for u, v in edges:

if u < 0: continue

p[v] = u

if cycle(v, p):

return ans1 if dup_p else [u, v]

return ans2