Topological Sort and Deadlock (cycle detection)

 Cycle Detection:

To detect a cycle in graph we need to use dfs algorithm, we need to maintain a stack while traversing, we will do this for every node.

 Pseudocode:

       function checkCycle(v):

                    if inStack[v] = =true:

                            return true;

                    if visited[v] = =true:

                            return false:

                    inStack[v] = true 

                     visited[v] =true

                       for each neighbor of v:

                                    if(checkCycle(child of v)):

                                             return v 

                        inStack[v]=false;

                        return false; 

 function check():

            for each node v:

                    if(checkCycle(v))

                                return true

             return false

    So for each node we will start depth check and keep adding items in stack, if at any point any item already present in stack comes again then we will return cycle is true, we make sure to remove elements from stack while backtracking.

Topological sort:

  We can extend above algorithm to find topological order of the graph.

    Topological order is a order where if there is a path between u->v then u will come before v. there can be multiple such order but this one rule should follow. This ordering is done for directed graph and cycle should not be present i.e Directed Acyclic Graph (DAG).

 In above algorithm if we add a stack, and we add elements when a node comes with no children or when all the children of a node is itereated.

 

Pseudocode:

       function checkCycle(v):

                    if inStack[v] = =true:

                            return true;

                    if visited[v] = =true:

                            return false:

                    inStack[v] = true 

                     visited[v] =true

                       for each neighbor of v:

                                    if(checkCycle(child of v)):

                                             return v 

                        orderedList.add(v);

(orderedList is a stack or a list in which elements are added at first) 

                        inStack[v]=false;

                        return false; 

 function check():

            for each node v:

                    if(checkCycle(v))

                                return true

             return false

 Questions Solved:

https://leetcode.com/problems/course-schedule/

https://leetcode.com/problems/course-schedule-ii/


  

Comments

Post a Comment

Popular posts from this blog

LeetCode 3Sum

Question Given an integer array nums, return all the triplets [nums[i], nums[j], nums[k]] such that i != j, i != k, and j != k, and nums[i] + nums[j] + nums[k] == 0. Notice that the solution set must not contain duplicate triplets. Brute force We can run 3 loops to check each possible triplets, we also need to eliminate the duplicates from both sides. this method will work but will work but will give time limit exceed after time constraints. To do this in given time limit we need to sort the array first and Create a loop that fixes the left most integer. This reduces the problem to 2sum for remaining array. For each loop iteration where duplicates are skipped, we need to do a left/right iteration using while loop. my code:
Read more

30. Substring with Concatenation of All Words

Problem Statement You are given a string s and an array of strings words. All the strings of words are of the same length. A concatenated substring in s is a substring that contains all the strings of any permutation of words concatenated. For example, if words = ["ab","cd","ef"], then "abcdef", "abefcd", "cdabef", "cdefab", "efabcd", and "efcdab" are all concatenated strings. "acdbef" is not a concatenated substring because it is not the concatenation of any permutation of words. Return the starting indices of all the concatenated substrings in s. You can return the answer in any order. Example 1: Input: s = "barfoothefoobarman", words = ["foo","bar"] Output: [0,9] Explanation: Since words.length == 2 and words[i].length == 3, the concatenated substring has to be of length 6. The substring starting at 0 is "barfoo". It is the concaten...
Read more

Lowest common ancestor in a binary Tree

Approach Define a recursive function rec that takes three parameters: root (the current node), p (first node to find the lowest common ancestor for), and q (second node to find the lowest common ancestor for). Check if the current node root is null or if it is either p or q . If any of these conditions is true, return the current node root as the lowest common ancestor. Recursively call the rec function for the left subtree of the current node and assign the result to a variable l . Recursively call the rec function for the right subtree of the current node and assign the result to a variable r . Check if both l and r are not null. If so, it means that p and q are found on different subtrees of the current node, and the current node root is their lowest common ancestor. Return the current node root . If l is null, it means that both p and q are on the right subtree (or not present in the tree). Return r . If none of the above conditions are met, it means ...
Read more