Posts tagged as “medium”

花花酱 LeetCode 207. Course Schedule

By zxi on October 20, 2017

Problem:

There are a total of n courses you have to take, labeled from 0 to n - 1.

Some courses may have prerequisites, for example to take course 0 you have to first take course 1, which is expressed as a pair: [0,1]

Given the total number of courses and a list of prerequisite pairs, is it possible for you to finish all courses?

For example:

1	2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So it is possible.

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

There are a total of 2 courses to take. To take course 1 you should have finished course 0, and to take course 0 you should also have finished course 1. So it is impossible.

Idea:

Finding cycles O(n^2) -> Topological sort O(n)

Solution 1: Topological Sort

C++

// Author: Huahua

// Time complexity: O(n)

// Runtime: 12 ms

class Solution {

public:

bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {

graph_ = vector<vector<int>>(numCourses);

for(const auto& p : prerequisites)

graph_[p.first].push_back(p.second);

// states: 0 = unkonwn, 1 == visiting, 2 = visited

vector<int> v(numCourses, 0);

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

if(dfs(i, v)) return false;

return true;

}

private:

vector<vector<int>> graph_;

bool dfs(int cur, vector<int>& v) {

if(v[cur] == 1) return true;

if(v[cur] == 2) return false;

v[cur] = 1;

for(const int t : graph_[cur])

if(dfs(t, v)) return true;

v[cur] = 2;

return false;

}

};

Java

// Author: Huahua

// Runtime: 6 ms

// HashMap is slower than ArrayList in this problem.

class Solution {

public boolean canFinish(int numCourses, int[][] prerequisites) {

ArrayList<ArrayList<Integer>> graph = new ArrayList<>();

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

graph.add(new ArrayList<Integer>());

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

int course = prerequisites[i][0];

int prerequisite = prerequisites[i][1];

graph.get(course).add(prerequisite);

}

int[] visited = new int[numCourses];

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

if (dfs(i, graph, visited)) return false;

return true;

}

private boolean dfs(int curr, ArrayList<ArrayList<Integer>> graph, int[] visited) {

if (visited[curr] == 1) return true;

if (visited[curr] == 2) return false;

visited[curr] = 1;

for (int next : graph.get(curr))

if (dfs(next, graph, visited)) return true;

visited[curr] = 2;

return false;

}

Solution 2: DFS Finding cycles

Time complexity: O(n^2)

Space complexity: O(n)

C++

// Author: Huahua

// Time complexity: O(n^2)

// Runtime: 179 ms

class Solution {

public:

bool canFinish(int numCourses, vector<pair<int, int>>& prerequisites) {

graph_.clear();

for(const auto& p : prerequisites)

graph_[p.first].insert(p.second);

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

vector<int> visited(numCourses, 0);

if (cycle(i, i, visited)) return false;

}

return true;

}

private:

unordered_map<int, unordered_set<int>> graph_;

bool cycle(int start, int curr, vector<int>& visited) {

if (curr == start && visited[start]) return true;

if (!graph_.count(curr)) return false;

for (const int next : graph_.at(curr)) {

if (visited[next]) continue;

visited[next] = true;

if (cycle(start, next, visited)) return true;

}

return false;

}

};

Related Pr0blems:

花花酱 LeetCode 687. Longest Univalue Path

By zxi on October 1, 2017

题目大意：给你一棵二叉树，返回一条最长的路径，要求路径上所有的节点值都相同。

https://leetcode.com/problems/longest-univalue-path/description/

Problem:

Given a binary tree, find the length of the longest path where each node in the path has the same value. This path may or may not pass through the root.

Note: The length of path between two nodes is represented by the number of edges between them.

Example 1:

Input:

Output:

Example 2:

Input:

Output:

Note: The given binary tree has not more than 10000 nodes. The height of the tree is not more than 1000.

Idea:

DFS

Solution: Recursion

Time complexity: O(n)

Space complexity: O(n)

C++

// Author: Huahua

// Runtime: 69 ms

class Solution {

public:

int longestUnivaluePath(TreeNode* root) {

if (root == nullptr) return 0;

int ans = 0;

univaluePath(root, &ans);

return ans;

}

private:

int univaluePath(TreeNode* root, int* ans) {

if (root == nullptr) return 0;

int l = univaluePath(root->left, ans);

int r = univaluePath(root->right, ans);

int pl = 0;

int pr = 0;

if (root->left && root->val == root->left->val) pl = l + 1;

if (root->right && root->val == root->right->val) pr = r + 1;

*ans = max(*ans, pl + pr);

return max(pl, pr);

}

};

Java

// Author: Huahua

// Runtime: 12 ms

class Solution {

private int ans;

public int longestUnivaluePath(TreeNode root) {

if (root == null) return 0;

this.ans = 0;

univaluePath(root);

return this.ans;

}

private int univaluePath(TreeNode root) {

if (root == null) return 0;

int l = univaluePath(root.left);

int r = univaluePath(root.right);

int pl = 0;

int pr = 0;

if (root.left != null && root.val == root.left.val) pl = l + 1;

if (root.right != null && root.val == root.right.val) pr = r + 1;

this.ans = Math.max(this.ans, pl + pr);

return Math.max(pl, pr);

}

Python3

"""

Author: Huahua

Runtime: 899 ms

"""

class Solution:

def longestUnivaluePath(self, root):

self.ans = 0

self._univaluePath(root)

return self.ans

def _univaluePath(self, root):

if root is None: return 0

l = self._univaluePath(root.left) if root.left is not None else -1

r = self._univaluePath(root.right) if root.right is not None else -1

pl = l + 1 if l >= 0 and root.val == root.left.val else 0

pr = r + 1 if r >= 0 and root.val == root.right.val else 0

self.ans = max(self.ans, pl + pr)

return max(pl, pr)

Solution 1: BFS

C++

// Author: Huahua

// Running time: 93 ms

class Solution {

public:

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {

unordered_set<string> dict(wordList.begin(), wordList.end());

if (!dict.count(endWord)) return 0;

queue<string> q;

q.push(beginWord);

int l = beginWord.length();

int step = 0;

while (!q.empty()) {

++step;

for (int size = q.size(); size > 0; size--) {

string w = q.front();

q.pop();

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

char ch = w[i];

for (int j = 'a'; j <= 'z'; j++) {

w[i] = j;

// Found the solution

if (w == endWord) return step + 1;

// Not in dict, skip it

if (!dict.count(w)) continue;

// Remove new word from dict

dict.erase(w);

// Add new word into queue

q.push(w);

}

w[i] = ch;

}

return 0;

}

};

Java

// Author: Huahua

// Running time: 92 ms (<76.61%)

class Solution {

public int ladderLength(String beginWord, String endWord, List<String> wordList) {

Set<String> dict = new HashSet<>();

for (String word : wordList) dict.add(word);

if (!dict.contains(endWord)) return 0;

Queue<String> q = new ArrayDeque<>();

q.offer(beginWord);

int l = beginWord.length();

int steps = 0;

while (!q.isEmpty()) {

++steps;

for (int s = q.size(); s > 0; --s) {

String w = q.poll();

char[] chs = w.toCharArray();

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

char ch = chs[i];

for (char c = 'a'; c <= 'z'; ++c) {

if (c == ch) continue;

chs[i] = c;

String t = new String(chs);

if (t.equals(endWord)) return steps + 1;

if (!dict.contains(t)) continue;

dict.remove(t);

q.offer(t);

}

chs[i] = ch;

}

return 0;

}

Solution 2: Bidirectional BFS

C++

// Author: Huahua

// Running time: 32 ms (better than 96.6%)

class Solution {

public:

int ladderLength(string beginWord, string endWord, vector<string>& wordList) {

unordered_set<string> dict(wordList.begin(), wordList.end());

if (!dict.count(endWord)) return 0;

int l = beginWord.length();

unordered_set<string> q1{beginWord};

unordered_set<string> q2{endWord};

int step = 0;

while (!q1.empty() && !q2.empty()) {

++step;

// Always expend the smaller queue first

if (q1.size() > q2.size())

std::swap(q1, q2);

unordered_set<string> q;

for (string w : q1) {

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

char ch = w[i];

for (int j = 'a'; j <= 'z'; j++) {

w[i] = j;

if (q2.count(w)) return step + 1;

if (!dict.count(w)) continue;

dict.erase(w);

q.insert(w);

}

w[i] = ch;

}

std::swap(q, q1);

}

return 0;

}

};

Java

// Author: Huahua

// Running time: 31 ms (<95.17%)

class Solution {

public int ladderLength(String beginWord, String endWord, List<String> wordList) {

Set<String> dict = new HashSet<>();

for (String word : wordList) dict.add(word);

if (!dict.contains(endWord)) return 0;

Set<String> q1 = new HashSet<>();

Set<String> q2 = new HashSet<>();

q1.add(beginWord);

q2.add(endWord);

int l = beginWord.length();

int steps = 0;

while (!q1.isEmpty() && !q2.isEmpty()) {

++steps;

if (q1.size() > q2.size()) {

Set<String> tmp = q1;

q1 = q2;

q2 = tmp;

}

Set<String> q = new HashSet<>();

for (String w : q1) {

char[] chs = w.toCharArray();

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

char ch = chs[i];

for (char c = 'a'; c <= 'z'; ++c) {

chs[i] = c;

String t = new String(chs);

if (q2.contains(t)) return steps + 1;

if (!dict.contains(t)) continue;

dict.remove(t);

q.add(t);

}

chs[i] = ch;

}

q1 = q;

}

return 0;

}

Python

"""

Author: Huahua

Running time: 115 ms (better than 96.84%)

"""

class Solution(object):

def ladderLength(self, beginWord, endWord, wordList):

wordDict = set(wordList)

if endWord not in wordDict: return 0

l = len(beginWord)

s1 = {beginWord}

s2 = {endWord}

wordDict.remove(endWord)

step = 0

while len(s1) > 0 and len(s2) > 0:

step += 1

if len(s1) > len(s2): s1, s2 = s2, s1

s = set()

for w in s1:

new_words = [

w[:i] + t + w[i+1:] for t in string.ascii_lowercase for i in xrange(l)]

for new_word in new_words:

if new_word in s2: return step + 1

if new_word not in wordDict: continue

wordDict.remove(new_word)

s.add(new_word)

s1 = s

return 0

Solution: DFS

C++

// Author: Huahua

// Time complexity: O(n^2)

// Space complexity: O(n)

// Running Time: 25 ms

class Solution {

public:

int findCircleNum(vector<vector<int>>& M) {

if (M.empty()) return 0;

int n = M.size();

int ans = 0;

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

if (!M[i][i]) continue;

++ans;

dfs(M, i, n);

}

return ans;

}

private:

void dfs(vector<vector<int>>& M, int curr, int n) {

// Visit all friends (neighbors)

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

if (!M[curr][i]) continue;

M[curr][i] = M[i][curr] = 0;

dfs(M, i, n);

}

};

Java

// Author: Huahua

// Time complexity: O(n^2)

// Space complexity: O(n)

// Running Time: 20 ms

class Solution {

public int findCircleNum(int[][] M) {

int n = M.length;

if (n == 0) return 0;

int ans = 0;

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

if (M[i][i] == 0) continue;

++ans;

dfs(M, i, n);

}

return ans;

}

private void dfs(int[][] M, int curr, int n) {

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

if (M[curr][i] == 0) continue;

M[curr][i] = M[i][curr] = 0;

dfs(M, i, n);

}

Python

"""

Author: Huahua

Time complexity: O(n^2)

Space complexity: O(n)

Running Time: 162 ms

"""

class Solution(object):

def findCircleNum(self, M):

"""

:type M: List[List[int]]

:rtype: int

"""

def dfs(M, curr, n):

for i in xrange(n):

if M[curr][i] == 1:

M[curr][i] = M[i][curr] = 0

dfs(M, i, n)

n = len(M)

ans = 0

for i in xrange(n):

if M[i][i] == 1:

ans += 1

dfs(M, i, n)

return ans

Solution 2: Union Find

C++

// Author: Huahua

// Runtime: 19 ms

class UnionFindSet {

public:

UnionFindSet(int n) {

parents_ = vector<int>(n + 1, 0);

ranks_ = vector<int>(n + 1, 0);

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

parents_[i] = i;

}

bool Union(int u, int v) {

int pu = Find(u);

int pv = Find(v);

if (pu == pv) return false;

if (ranks_[pu] > ranks_[pv]) {

parents_[pv] = pu;

} else if (ranks_[pv] > ranks_[pu]) {

parents_[pu] = pv;

} else {

parents_[pu] = pv;

++ranks_[pv];

}

return true;

}

int Find(int id) {

if (id != parents_[id])

parents_[id] = Find(parents_[id]);

return parents_[id];

}

private:

vector<int> parents_;

vector<int> ranks_;

};

class Solution {

public:

int findCircleNum(vector<vector<int>>& M) {

int n = M.size();

UnionFindSet s(n);

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

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

if (M[i][j] == 1) s.Union(i, j);

unordered_set<int> circles;

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

circles.insert(s.Find(i));

return circles.size();

}

};

Posts tagged as “medium”

花花酱 LeetCode 207. Course Schedule

Solution 1: Topological Sort

C++

Java

Solution 2: DFS Finding cycles

C++

Related Pr0blems:

花花酱 LeetCode 687. Longest Univalue Path

Solution: Recursion

C++

Java

Python3

Related Problems

花花酱 LeetCode 127. Word Ladder

Solution 1: BFS

C++

Java

Solution 2: Bidirectional BFS

C++

Java

Python

Related Problems

花花酱 LeetCode 547. Friend Circles

Solution: DFS

C++

Java

Python

Solution 2: Union Find

C++

Related Problems

花花酱 LeetCode 677. Map Sum Pairs