# 1192. Critical Connections in a Network

#### Hard

***

There are `n` servers numbered from `0` to `n - 1` connected by undirected server-to-server `connections` forming a network where `connections[i] = [ai, bi]` represents a connection between servers `ai` and `bi`. Any server can reach other servers directly or indirectly through the network.

A *critical connection* is a connection that, if removed, will make some servers unable to reach some other server.

Return all critical connections in the network in any order.

 

**Example 1:**

![](https://assets.leetcode.com/uploads/2019/09/03/1537_ex1_2.png)

```
Input: n = 4, connections = [[0,1],[1,2],[2,0],[1,3]]
Output: [[1,3]]
Explanation: [[3,1]] is also accepted.
```

**Example 2:**

```
Input: n = 2, connections = [[0,1]]
Output: [[0,1]]
```

 

**Constraints:**

* `2 <= n <= 105`
* `n - 1 <= connections.length <= 105`
* `0 <= ai, bi <= n - 1`
* `ai != bi`
* There are no repeated connections.

```python
class Solution:
    def criticalConnections(self, n: int, connections: List[List[int]]) -> List[List[int]]:
        self.visited = set()
        self.low = {}
        self.d = defaultdict(list)
        self.result = []
        for source, destination in connections:
            self.d[source].append(destination)
            self.d[destination].append(source)
        self.dfs(0,-1,0)
        return self.result
    
    def dfs(self, node, parent, rank):
        self.low[node] = rank
        self.visited.add(node)
        for adj in self.d[node]:
            if adj == parent:
                continue
            if adj not in self.visited:
                self.dfs(adj, node, rank+1)
            self.low[node] = min(self.low[node], self.low[adj])
            if rank < self.low[adj]:
                self.result.append([node, adj])
                
            
```