You must find the minimum number of months needed to complete all the courses following these rules:

• You may start taking a course at any time if the prerequisites are met.
• Any number of courses can be taken at the same time.

Return the minimum number of months needed to complete all the courses.

Note: The test cases are generated such that it is possible to complete every course (i.e., the graph is a directed acyclic graph).

Example 1:

Input: n = 3, relations = [[1,3],[2,3]], time = [3,2,5]
Output: 8
Explanation: The figure above represents the given graph and the time required to complete each course. 
We start course 1 and course 2 simultaneously at month 0.
Course 1 takes 3 months and course 2 takes 2 months to complete respectively.
Thus, the earliest time we can start course 3 is at month 3, and the total time required is 3 + 5 = 8 months.

Example 2:

Input: n = 5, relations = [[1,5],[2,5],[3,5],[3,4],[4,5]], time = [1,2,3,4,5]
Output: 12
Explanation: The figure above represents the given graph and the time required to complete each course.
You can start courses 1, 2, and 3 at month 0.
You can complete them after 1, 2, and 3 months respectively.
Course 4 can be taken only after course 3 is completed, i.e., after 3 months. It is completed after 3 + 4 = 7 months.
Course 5 can be taken only after courses 1, 2, 3, and 4 have been completed, i.e., after max(1,2,3,7) = 7 months.
Thus, the minimum time needed to complete all the courses is 7 + 5 = 12 months.

Constraints:

• 1 <= n <= 5 * 104
• 0 <= relations.length <= min(n * (n - 1) / 2, 5 * 104)
• relations[j].length == 2
• 1 <= prevCoursej, nextCoursej <= n
• prevCoursej != nextCoursej
• All the pairs [prevCoursej, nextCoursej] are unique.
• time.length == n
• 1 <= time[i] <= 104
• The given graph is a directed acyclic graph.

Solution: Topological Sorting

Time complexity: O(V+E)
Space complexity: O(V+E)

// Author: Huahua
class Solution {
public:
  int minimumTime(int n, vector<vector<int>>& relations, vector<int>& time) {
    vector<vector<int>> g(n);  
    for (const auto& r: relations)
      g[r[0] - 1].push_back(r[1] - 1);    
    vector<int> t(n, -1);
    function<int(int)> dfs = [&](int u) {
      if (t[u] != -1) return t[u];
      t[u] = 0;
      for (int v : g[u])
        t[u] = max(t[u], dfs(v));
      return t[u] += time[u];
    };
    int ans = 0;
    for (int i = 0; i < n; ++i)
      ans = max(ans, dfs(i));
    return ans;
  }
};

class Solution:
  def minimumTime(self, n: int, relations: List[List[int]], time: List[int]) -> int:
    g = [[] for _ in range(n)]
    for u, v in relations: g[u - 1].append(v - 1)
    @cache
    def dfs(u: int) -> int:      
      return max([dfs(v) for v in g[u]] + [0]) + time[u]
    return max(dfs(u) for u in range(n))

The post 花花酱 LeetCode 2050. Parallel Courses III appeared first on Huahua's Tech Road.

You are given a string colors where colors[i] is a lowercase English letter representing the color of the ith node in this graph (0-indexed). You are also given a 2D array edges where edges[j] = [aj, bj] indicates that there is a directed edge from node aj to node bj.

A valid path in the graph is a sequence of nodes x1 -> x2 -> x3 -> ... -> xk such that there is a directed edge from xi to xi+1 for every 1 <= i < k. The color value of the path is the number of nodes that are colored the most frequently occurring color along that path.

Return the largest color value of any valid path in the given graph, or -1 if the graph contains a cycle.

Example 1:

Input: colors = "abaca", edges = [[0,1],[0,2],[2,3],[3,4]]
Output: 3
Explanation: The path 0 -> 2 -> 3 -> 4 contains 3 nodes that are colored "a" (red in the above image).

Example 2:

Input: colors = "a", edges = [[0,0]]
Output: -1
Explanation: There is a cycle from 0 to 0.

Constraints:

• n == colors.length
• m == edges.length
• 1 <= n <= 105
• 0 <= m <= 105
• colors consists of lowercase English letters.
• 0 <= aj, bj < n

Solution: Topological Sorting

freq[n][c] := max freq of color c after visiting node n.

Time complexity: O(n)
Space complexity: O(n*26)

class Solution:
  def largestPathValue(self, colors: str, edges: List[List[int]]) -> int:
    INF = 1e9
    n = len(colors)
    g = [[] for _ in range(n)]
    for u, v in edges:
      g[u].append(v)    
    visited = [0] * n
    freq = [[0] * 26 for _ in range(n)]
    def dfs(u: int) -> int:
      idx = ord(colors[u]) - ord('a')
      if not visited[u]:
        visited[u] = 1 # visiting
        for v in g[u]:
          if (dfs(v) == INF):
            return INF
          for c in range(26):
            freq[u][c] = max(freq[u][c], freq[v][c])
        freq[u][idx] += 1
        visited[u] = 2 # done
      return freq[u][idx] if visited[u] == 2 else INF
    ans = 0
    for u in range(n):
      ans = max(ans, dfs(u))
      if ans == INF: break
    return -1 if ans == INF else ans

The post 花花酱 LeetCode 1857. Largest Color Value in a Directed Graph appeared first on Huahua's Tech Road.

• On each turn, the printer will print a solid rectangular pattern of a single color on the grid. This will cover up the existing colors in the rectangle.
• Once the printer has used a color for the above operation, the same color cannot be used again.

You are given a m x n matrix targetGrid, where targetGrid[row][col] is the color in the position (row, col) of the grid.

Return true if it is possible to print the matrix targetGrid, otherwise, return false.

Example 1:

Input: targetGrid = [[1,1,1,1],[1,2,2,1],[1,2,2,1],[1,1,1,1]]
Output: true

Example 2:

Input: targetGrid = [[1,1,1,1],[1,1,3,3],[1,1,3,4],[5,5,1,4]]
Output: true

Example 3:

Input: targetGrid = [[1,2,1],[2,1,2],[1,2,1]]
Output: false
Explanation: It is impossible to form targetGrid because it is not allowed to print the same color in different turns.

Example 4:

Input: targetGrid = [[1,1,1],[3,1,3]]
Output: false

Constraints:

• m == targetGrid.length
• n == targetGrid[i].length
• 1 <= m, n <= 60
• 1 <= targetGrid[row][col] <= 60

Solution: Dependency graph

For each color C find the maximum rectangle to cover it. Any other color C’ in this rectangle is a dependency of C, e.g. C’ must be print first in order to print C.

Then this problem reduced to check if there is any cycle in the dependency graph.

e.g.
1 2 1
2 1 2
1 2 1
The maximum rectangle for 1 and 2 are both [0, 0] ~ [2, 2]. 1 depends on 2, and 2 depends on 1. This is a circular reference and no way to print.

Time complexity: O(C*M*N)
Space complexity: O(C*C)

class Solution {
public:
  bool isPrintable(vector<vector<int>>& targetGrid) {
    constexpr int kMaxC = 60;
    const int m = targetGrid.size();
    const int n = targetGrid[0].size();
    vector<unordered_set<int>> deps(kMaxC + 1);
    for (int c = 1; c <= kMaxC; ++c) {
      int l = n, r = -1, t = m, b = -1;      
      for (int i = 0; i < m; ++i)
        for (int j = 0; j < n; ++j)
          if (targetGrid[i][j] == c)
            l = min(l, j), r = max(r, j), t = min(t, i), b = max(b, i);
      if (l == -1) continue;
      for (int i = t; i <= b; ++i)
        for (int j = l; j <= r; ++j)
          if (targetGrid[i][j] != c) 
            deps[c].insert(targetGrid[i][j]);
    }
    vector<int> seen(kMaxC + 1);
    function<bool(int)> hasCycle = [&](int c) {
      if (seen[c] == 1) return true;
      if (seen[c] == 2) return false;
      seen[c] = 1;
      for (int t : deps[c])
        if (hasCycle(t)) return true;
      seen[c] = 2;
      return false;
    };
    for (int c = 1; c <= kMaxC; ++c)
      if (hasCycle(c)) return false;
    return true;
  }
};

The post 花花酱 LeetCode 1591. Strange Printer II appeared first on Huahua's Tech Road.

Problem

https://leetcode.com/problems/find-eventual-safe-states/description/

题目大意：给一个有向图，找出所有不可能进入环的节点。

In a directed graph, we start at some node and every turn, walk along a directed edge of the graph.  If we reach a node that is terminal (that is, it has no outgoing directed edges), we stop.

Now, say our starting node is eventually safe if and only if we must eventually walk to a terminal node.  More specifically, there exists a natural number K so that for any choice of where to walk, we must have stopped at a terminal node in less than K steps.

Which nodes are eventually safe?  Return them as an array in sorted order.

The directed graph has N nodes with labels 0, 1, ..., N-1, where N is the length of graph.  The graph is given in the following form: graph[i] is a list of labels j such that (i, j) is a directed edge of the graph.

Example:
Input: graph = [[1,2],[2,3],[5],[0],[5],[],[]]
Output: [2,4,5,6]
Here is a diagram of the above graph.

Note:

• graph will have length at most 10000.
• The number of edges in the graph will not exceed 32000.
• Each graph[i] will be a sorted list of different integers, chosen within the range [0, graph.length - 1].

Idea: Finding Cycles

Solution 1: DFS

 A node is safe if and only if: itself and all of its neighbors do not have any cycles.

Time complexity: O(V + E)

Space complexity: O(V + E)

// Author: Huahua
// Running time: 155 ms
class Solution {
public:
  vector<int> eventualSafeNodes(vector<vector<int>>& graph) {    
    vector<State> states(graph.size(), UNKNOWN);
    vector<int> ans;
    for (int i = 0; i < graph.size(); ++i)      
      if (dfs(graph, i, states) == SAFE)
        ans.push_back(i);
    return ans;
  }
private:
  enum State {UNKNOWN, VISITING, SAFE, UNSAFE};
  State dfs(const vector<vector<int>>& g, int cur, vector<State>& states) {
    if (states[cur] == VISITING)
      return states[cur] = UNSAFE;
    if (states[cur] != UNKNOWN)
      return states[cur];
    states[cur] = VISITING;
    for (int next : g[cur])
      if (dfs(g, next, states) == UNSAFE) 
        return states[cur] = UNSAFE;
    return states[cur] = SAFE;
  }
};

Related Problems

• [解题报告] LeetCode 207. Course Schedule
• 花花酱 LeetCode 210. Course Schedule II
• [解题报告] LeetCode 684. Redundant Connection 花花酱

The post 花花酱 LeetCode 802. Find Eventual Safe States appeared first on Huahua's Tech Road.

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, return the ordering of courses you should take to finish all courses.

There may be multiple correct orders, you just need to return one of them. If it is impossible to finish all courses, return an empty array.

For example:

2, [[1,0]]

There are a total of 2 courses to take. To take course 1 you should have finished course 0. So the correct course order is [0,1]

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

There are a total of 4 courses to take. To take course 3 you should have finished both courses 1 and 2. Both courses 1 and 2 should be taken after you finished course 0. So one correct course order is [0,1,2,3]. Another correct ordering is[0,2,1,3].

Note:

1. The input prerequisites is a graph represented by a list of edges, not adjacency matrices. Read more about how a graph is represented.
2. You may assume that there are no duplicate edges in the input prerequisites.

题目大意：

给你一些课程和它的先修课程，让你输出修课顺序。如果无法修完所有课程，返回空数组。

Idea

Topological sorting

拓扑排序

Solution 1: Topological Sorting

Time complexity: O(V+E)

Space complexity: O(V+E)

// Author: Huahua
// Runtime: 16 ms
class Solution {
public:
  vector<int> findOrder(int numCourses, vector<pair<int, int>>& prerequisites) {
    vector<vector<int>> graph(numCourses);    
    for(const auto& p : prerequisites)
      graph[p.second].push_back(p.first);

    // states: 0 = unkonwn, 1 == visiting, 2 = visited
    vector<int> v(numCourses, 0);
    vector<int> ans;
    
    for (int i = 0; i < numCourses; ++i)
      if (dfs(i, graph, v, ans)) return {};

    std::reverse(ans.begin(), ans.end());
    return ans;
  }
private:
  bool dfs(int cur, vector<vector<int>>& graph, vector<int>& v, vector<int>& ans) {
    if (v[cur] == 1) return true;
    if (v[cur] == 2) return false;

    v[cur] = 1;
    
    for (const int t : graph[cur])
      if (dfs(t, graph, v, ans)) return true;
    
    v[cur] = 2;
    ans.push_back(cur);

    return false;
  }
};

// Author: Huahua
// Runtime: 83 ms
class Solution {
    public int[] findOrder(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];
        List<Integer> ans = new ArrayList<Integer>();
        Integer index = numCourses;
        for (int i = 0; i < numCourses; ++i)
            if (dfs(i, graph, visited, ans)) return new int[0];        
        
        return ans.stream().mapToInt(i->i).toArray();
    }
    
    private boolean dfs(int curr, ArrayList<ArrayList<Integer>> graph, int[] visited, List<Integer> ans) {
        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, ans)) return true;
        
        visited[curr] = 2;
        ans.add(curr);
        
        return false;
    }    
}

Related Problems:

• [解题报告] LeetCode 207. Course Schedule
• 花花酱 LeetCode 802. Find Eventual Safe States

The post 花花酱 LeetCode 210. Course Schedule II appeared first on Huahua's Tech Road.

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:

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.

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

// 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;
    }
};

// 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)

// 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 210. Course Schedule II
• 花花酱 LeetCode 802. Find Eventual Safe States

The post 花花酱 LeetCode 207. Course Schedule appeared first on Huahua's Tech Road.