# Find minimum number of people to reach to spread a message across all people in twitter

Considering that I'ld would like to spread a promotion message across all people in twitter. Assuming the ideal case, if a person tweets a message, then every follower will re-tweet the message.

You need to find the minimum number of people to reach out (for example, who doesn't follow anyone etc) so that your promotion message is spread out across entire network in twitter.

Also, we need to consider loops like, if A follows B, B follows C, C follows D, D follows A (A -> B -> C -> D -> A) then reaching only one of them is sufficient to spread your message.

Input: A 2x2 matrix like below. In this case, a follows b, b follows c, c follows a.

```
a b c
a 1 1 0
b 0 1 1
c 1 0 1
```

Output: List of people to be reached to spread out message across everyone in the network.

F家

解法：

This is a very interesting graph problem, here is what I would do:

step 1. Build a directed graph based on the input people (nodes) and their relationship (edges).

step 2. Find strongly connected components (SCCs) in the graph. Let's use the wikipedia's graph example, in that case, there are `3`

SCCs: `(a, b, e)`

, `(c, d, h)`

and `(f, g)`

. There are two famous algorithms for getting the SCCs: Kosaraju's algorithm and Tarjan's algorithm.

step 3. Pick one of the nodes from the SCCs we get: `a, c, f`

, now these `3`

nodes form a DAG, we just need to do topological sort for them, eventually `a`

is the root node in the path (or stack), and we can let `a`

spread the message and guarantee all other people will get it.

Sometimes, there could be several topological paths, and the root nodes of those paths will be the minimum people to reach out to spread the message.

Create a directed graph which captures followee -> follower relationship

Now create the topological sort for the entire graph

For each unvisited node in the topological sort result, add it to the final result and then visit all the nodes in that tree

The reason this works is, in the topological sort order the node that appears first is the left most node in the given connected component. So you would use that to traverse the curr node and all its children node.

def min_people(num_people, follows): from collections import defaultdict # in this graph we will store # followee -> follower relation graph = defaultdict(set) # a follows b for a, b in follows: graph[b].add(a) def topo(node, graph, visited, result): visited.add(node) for nei in graph[node]: if nei not in visited: topo(nei, graph, visited, result) result.append(node) visited = set([]) result = [] for i in range(num_people): if i not in visited: topo(i, graph, visited, result) result = list(reversed(result)) def visit(node, visited, graph): visited.add(node) for nei in graph[node]: if nei not in visited: visit(nei, visited, graph) visited = set([]) start_with = [] for r in result: if r not in visited: start_with.append(r) visit(r, visited, graph) return start_with

类似题目：

[LeetCode] 323. Number of Connected Components in an Undirected Graph 无向图中的连通区域的个数