def triangle_finding_strategies():
"""
How to find triangles.
"""
ans = """
One way would be to take one node, and look at its neighbors.
If its neighbors are also connected to one another,
then we have found a triangle.
Another way would be to start at a given node,
and walk out two nodes.
If the starting node is the neighbor of the node two hops away,
then the path we traced traces out the nodes in a triangle.
"""
return render_html(ans)
def bfs_algorithm():
"""
How to design a BFS algorithm.
"""
ans = """
How does the breadth-first search work?
It essentially is as follows:
1. Begin with a queue that has only one element in it: the starting node.
2. Add the neighbors of that node to the queue.
1. If destination node is present in the queue, end.
2. If destination node is not present, proceed.
3. For each node in the queue:
1. Remove node from the queue.
2. Add neighbors of the node to the queue. Check if destination node is present or not.
3. If destination node is present, end. <!--Credit: @cavaunpeu for finding bug in pseudocode.-->
4. If destination node is not present, continue.
"""
return render_html(ans)
def triadic_closure_algorithm():
"""
How to do triadic closure.
"""
ans = """
I would suggest the following strategy:
1. Pick a node
1. For every pair of neighbors:
1. If neighbors are not connected,
then this is a potential triangle to close.
This strategy gives you potential triadic closures
given a "center" node `n`.
The other way is to trace out a path two degrees out
and ask whether the terminal node is a neighbor
of the starting node.
If not, then we have another triadic closure to make.
"""
return render_html(ans)
def simplest_clique():
"""
Answer to "what is the simplest clique".
"""
return render_html("The simplest clique is an edge.")