Simple - Intuitive Explanation - Beats 99% in theory as well as compute 😉[PYTHON]
Points to remember\n1. About the START:\n\t It\'s a continuous graph - there is a START vertex - we chose this and every other vertex can be visited/discovered 
# **Points to remember**\n1. About the **START**:\n\t* It\'s a continuous graph - there is a START vertex - we chose this and every other vertex can be visited/discovered by just doing Depth First Traversal from START\n\t* With respect to START every vertex will be visited/discovered/explored in the process of DFTraversal - If the graph was a straight line with no back-paths/bypass/shortcuts/cycle each node would be discovered linearly in time for e.g. if graph looked like **A**-B-C-D  where we chose A to be the start 0-1-2-3 will be the respective discovery time.\n\n2. About **any other NODE** in the graph:\n\t* For any node let\'s call all its **neighbors (except parent)** its **children** and this current node to be the **parent**.\n\t* Every **parent** expects it\'s children  to be **discovered later than themselves** as the parent blindly expects that the only connection with the child is of his. This parent is the only one to guide this child - That\'s what every parent expects and they do their best.\n\t* If the **expectaion meets the reality** can we say that there is no cycle (no bypass or back path from **uncle/aunt** or any **grandparent** to the child node)? \n\t* **If** expectation meets reality then its a **critical edge** - No one except the parent is there to guide this child - sure it\'s critical.\n\t* **Else** there exists other connections may be from an uncle or aunt or may be from a grandparent and that makes the connection between the parent and child not so critical.\n\n3. About **low** a.k.a **low-links** or think of them **as the distance of a single node or a cycle from START** (if there is a cycle, all nodes in the cycle will have the same low value as the node which is the entry point of the cycle - entry point w.r.t the start node)\n\n\t* **low** or **rank** are nothing but the distance from the start - a cycle is grouped and represented by all nodes in that cycle having the same low value.\n\t* Again assume if the graph is linear - a single line of nodes - the low/rank of every node will just be the discovery time of that node e.g. A-B-C-D if **A is the start** 0-1-2-3 will be the lows.\n\t* JUST FOR ILLUSTRATION  - But if there is a bypass/back path or a shortcut A-**B**-C-D-**B** (here **B** is same node - I just cant draw a loop here - Please imagine \uD83D\uDE1D) then the lows would be 0-1-1-1-1 as B-C-D-B is a cycle and is grouped by all of the individual nodes having same low as the exepcted (as well as actual - it\'s same for **B**) dicovery time of **B** from the start. \n\t\n# **Critical Key**\nThe intuition is in points 2 and 3 and **use of backpropagation (return) of the low[node]** to tell the parent that what it **expects** is either right or wrong. The parent can then make the decision to add the edge (parent, child) as critical or not.\n\n1. If **expectaion meets the reality** or **actual_discovery_time_of_child >= expected_discovery_time_of_child** then the edge is critical as **no uncle or aunt or grandparent** are able to reach the child faster then the current parent.\n2. Else there is a backpath or other parent/uncle/grandparent is also conencted to the child.\n\n\n```python\n\nclass Solution:\n    def criticalConnections(self, n: int, connections: List[List[int]]) -> List[List[int]]:\n        \n        # node is index, neighbors are in the list\n        graph = [[] for i in range(n)]\n        \n        # build graph\n        for n1, n2 in connections:\n            graph[n1].append(n2)\n            graph[n2].append(n1)\n        \n        # min_discovery_time of nodes at respective indices from start node\n        # 1. default to max which is the depth of continuous graph\n        lows = [n] * n\n        \n        # critical edges \n        critical = []\n        \n        # args: node, node discovery_time in dfs, parent of this node\n        def dfs(node, discovery_time, parent):\n            \n            # if the low is not yet discovered for this node\n            if lows[node] == n:\n                \n                # 2. default it to the depth or discovery time of this node\n                lows[node] = discovery_time\n                \n                # iterate over neighbors\n                for neighbor in graph[node]:\n                    \n                    # all neighbors except parent\n                    if neighbor != parent:\n                        \n                        expected_discovery_time_of_child = discovery_time + 1\n                        actual_discovery_time_of_child = dfs(neighbor, expected_discovery_time_of_child, node)\n                        \n                        # nothing wrong - parent got what was expected => no back path\n                        # this step is skipped if there is a back path\n                        if actual_discovery_time_of_child >= expected_discovery_time_of_child:\n                            critical.append((node, neighbor))\n                        \n                        # low will be equal to discovery time of this node or discovery time of child\n                        # whichever one is minm\n                        # if its discovery time of child - then there is a backpath\n                        lows[node] = min(lows[node], actual_discovery_time_of_child)\n                        \n\n            # return low of this node discovered previously or during this call \n            return lows[node]\n        \n        dfs(n-1, 0, -1)\n        \n        return critical     \n```\n\n\nLet me know if there\'s any typo/mistake or any thing is missing!!\n\nLove \u2764\uFE0F and **UPVOTE** for everyone to read - \u270C\uFE0FI\'ll add more explanations if you guys find this simple enough..
['Graph', 'Python', 'Python3']