slides

Author: williamfiset

com/williamfiset/algorithms/graphtheory/treealgorithms/TreeIsomorphism.java

@@ -38,8 +38,8 @@ public int id() {
       return id;
     }
 
-    public boolean isLeaf() {
-      return children.size() == 0;
+    public TreeNode parent() {
+      return parent;
     }
 
     public List<TreeNode> children() {
@@ -52,23 +52,48 @@ public String toString() {
     }
   }
 
-  private static TreeNode rootTree(List<List<Integer>> graph, int rootId) {
-    TreeNode root = new TreeNode(rootId);
-    return buildTree(graph, root, /*parent=*/ null);
-  }
+  // Determines if two unrooted trees are isomorphic
+  public static boolean treesAreIsomorphic(List<List<Integer>> tree1, List<List<Integer>> tree2) {
+    if (tree1.isEmpty() || tree2.isEmpty()) {
+      throw new IllegalArgumentException("Empty tree input");
+    }
 
-  // Do dfs to construct rooted tree.
-  private static TreeNode buildTree(List<List<Integer>> graph, TreeNode node, TreeNode parent) {
-    for (int childId : graph.get(node.id)) {
-      // Ignore adding an edge pointing back to parent.
-      if (parent != null && childId == parent.id) continue;
+    List<Integer> centers1 = findTreeCenters(tree1);
+    List<Integer> centers2 = findTreeCenters(tree2);
 
-      TreeNode child = new TreeNode(childId, node);
-      node.addChildren(child);
+    TreeNode rootedTree1 = rootTree(tree1, centers1.get(0));
+    String tree1Encoding = encode(rootedTree1);
 
-      buildTree(graph, child, node);
+    for (int center : centers2) {
+      TreeNode rootedTree2 = rootTree(tree2, center);
+      String tree2Encoding = encode(rootedTree2);
+
+      if (tree1Encoding.equals(tree2Encoding)) {
+        return true;
+      }
     }
-    return node;
+    return false;
+  }
+
+  private static boolean areIsomorphic(TreeNode root1, TreeNode root2) {
+    return encode(root1).equals(encode(root2));
+  }
+
+  // Constructs the canonical form representation of a tree as a string.
+  public static String encode(TreeNode node) {
+    if (node == null) {
+      return "";
+    }
+    List<String> labels = new LinkedList<>();
+    for (TreeNode child : node.children()) {
+      labels.add(encode(child));
+    }
+    Collections.sort(labels);
+    StringBuilder sb = new StringBuilder();
+    for (String label : labels) {
+      sb.append(label);
+    }
+    return "(" + sb.toString() + ")";
   }
 
   private static List<Integer> findTreeCenters(List<List<Integer>> tree) {
@@ -85,9 +110,7 @@ private static List<Integer> findTreeCenters(List<List<Integer>> tree) {
 
     int processedLeafs = leaves.size();
 
-    // Remove leaf nodes and decrease the degree of
-    // each node adding new leaf nodes progressively
-    // until only the centers remain.
+    // Iteratively remove all leaf nodes layer by layer until only the centers remain.
     while (processedLeafs < n) {
       List<Integer> newLeaves = new ArrayList<>();
       for (int node : leaves) {
@@ -104,43 +127,23 @@ private static List<Integer> findTreeCenters(List<List<Integer>> tree) {
     return leaves;
   }
 
-  // Determines if two unrooted trees are isomorphic
-  public static boolean treesAreIsomorphic(List<List<Integer>> tree1, List<List<Integer>> tree2) {
-    if (tree1.isEmpty() || tree2.isEmpty()) {
-      throw new IllegalArgumentException("Empty tree input");
-    }
-
-    List<Integer> centers1 = findTreeCenters(tree1);
-    List<Integer> centers2 = findTreeCenters(tree2);
-
-    TreeNode rootedTree1 = rootTree(tree1, centers1.get(0));
-    for (int center : centers2) {
-      if (areIsomorphic(rootedTree1, rootTree(tree2, center))) {
-        return true;
-      }
-    }
-    return false;
+  private static TreeNode rootTree(List<List<Integer>> graph, int rootId) {
+    TreeNode root = new TreeNode(rootId);
+    return buildTree(graph, root, /*parent=*/ null);
   }
 
-  private static boolean areIsomorphic(TreeNode root1, TreeNode root2) {
-    return encode(root1).equals(encode(root2));
-  }
+  // Do dfs to construct rooted tree.
+  private static TreeNode buildTree(List<List<Integer>> graph, TreeNode node, TreeNode parent) {
+    for (int childId : graph.get(node.id)) {
+      // Ignore adding an edge pointing back to parent.
+      if (parent != null && childId == parent.id) continue;
 
-  // Constructs the canonical form representation of a tree as a string.
-  public static String encode(TreeNode node) {
-    if (node == null) {
-      return "";
-    }
-    List<String> labels = new LinkedList<>();
-    for (TreeNode child : node.children()) {
-      labels.add(encode(child));
-    }
-    Collections.sort(labels);
-    StringBuilder sb = new StringBuilder();
-    for (String label : labels) {
-      sb.append(label);
+      TreeNode child = new TreeNode(childId, node);
+      node.addChildren(child);
+
+      buildTree(graph, child, node);
     }
-    return "(" + sb.toString() + ")";
+    return node;
   }
 
   /* Graph/Tree creation helper methods. */

slides/graphtheory/trees.txt

@@ -756,15 +756,55 @@ and subscribe for more mathematics and computer science videos.
 
 Isomorphism source code
 
+Hello and welcome, my name is William, today we're going to take a 
+look at some source code for identifying isomorphic trees.
 
+In the previous video, we talked about identifying isomorphic trees by first
+serializing the tree into a string and then using that as a means for equality.
+Today we will be looking at the same approach in more details, so make sure
+you've given the previous video a watch if you haven't done so. There should be
+a link in the description below.
 
+All the source code you see today can be found on Github at github dot com slash
+william fiset slash algorithms. Alright, let's jump in.
 
+Alright, here we are in the source code for identifying isomorphic trees written
+in Java.
 
+The first thing I do is define a TreeNode object we'll be using to represent our
+rooted trees. TreeNode's are straightforward, they only contain three members,
+a unique id, a parent node reference and a list of references to all its children.
 
+To create a TreeNode, all you need is to give that TreeNode a unique id, you can
+also optionally create a TreeNode with an id and a parent node.
 
+The one useful method I've added to this class is the ability to add children
+to this TreeNode. Simply pass in any number of TreeNodes you wish to add as child
+node to this node and they'll get added to the children's list.
 
+The rest of the methods in this class are just getter methods.
 
+The next interesting method is the treesAreIsomorphic method which takes as
+input two undirected tree stored as adjacency lists tree1 and tree2.
 
+Just so that we don't have to worry about it, I check if either trees are empty
+and throw an exception.
+
+After that, I find the center or centers of both trees.
+
+TODO(waf): descripbe the whole flow here before moving on,
+
+
+Then I root tree1 using its first center node.
+Afterwhich I loop through bot of tree2's centers and do the isomorphism check.
+You need to 
+
+Now the next thing we want to do is encode the
+second tree and compare the encoded results, but if the tree has 2 centers we
+don't know which center node in the second tree is the correct one, so we need
+to try both. For this, iterate over both centers and root the tree comparing the
+encoded result with the one from the first tree. If there's any match then we 
+know the trees are isomorphic.