#153 is started

Author: Hamid Gasmi

4-np-complete-problems/2-coping_with_np_completeness/plan_party.py

@@ -4,65 +4,45 @@
 
 # This problem can be reduced to Independent Set problem (ISP) which is an NP problem
 # It's a special case of ISP 
-# It's can be solved effeciently with Dynamic Programming technique:
-# Let's W(v) reprensents the Total Fun (weight) in the party, then:
-# F(v) = Max(weight(v) + sum(weight(u) for all u grand-children of v),
-#                        sum(weight(u) for all u children of v))
-
-class Vertex:
-    def __init__(self, weight):
-        self.weight = weight
-        self.children = []
+# It's can be solved effeciently with Greedy Algorithm technique:
+# Greedy Choice: Select all leaves of the tree and Remove all their parents + Iterate
+# This choice is safe: 
+#   since the number of leaves >= the leaves' parents
+#   This choice guarantees to get an IS longer or equal to the IS that we would have got if we selected the parents
 
 class Tree:
-    def __init__(self, size, weights):
+    def __init__(self, size, edges):
         self.size = size
-        self.weights = [weights[i] for i in range(size)]
-
-        
-def ReadTree():
-    
-    
-
-def dfs(tree, vertex, parent):
-    for child in tree[vertex].children:
-        if child != parent:
-            dfs(tree, child, vertex)
-
-    # This is a template function for processing a tree using depth-first search.
-    # Write your code here.
-    # You may need to add more parameters to this function for child processing.
+        self.build_children_list(edges)
 
+    def build_children_list(self, edges):
+        self.children_list = [[] for _ in range(self.size)]
+        for p, c in edges:
+            self.children_list[p - 1].append(c - 1)
+            self.children_list[c - 1].append(p - 1)
 
-def MaxWeightIndependentTreeSubset(tree):
-    size = len(tree)
-    if size == 0:
-        return 0
-    dfs(tree, 0, -1)
-    # You must decide what to return.
-    return 0
-
+    def isp_dfs(self, v, parent):
 
+        list = []
+        return list
+        
 def main():
-    tree = ReadTree()
-    weight = MaxWeightIndependentTreeSubset(tree)
-    print(weight)
+    
+    size = int(input())
+    edges = []
+    for _ in range(1, size):
+        edges.append(list(map(int, input().split())))
+    tree = Tree(size, edges)
+
+    isp_list = tree.isp_dfs(0, -1)
+    print(len(isp_list))
+    print(isp_list)
 
 if __name__ == "__main__":
 
     # To avoid stack overflow issues
     sys.setrecursionlimit(10**6) # max depth of recursion
     threading.stack_size(2**26)  # new thread will get stack of such size
 
-    size = int(input())
-    weights = map(int, input().split())
-    print(weights)
-    #tree = [Vertex(w) for w in map(int, input().split())]
-    #for i in range(1, size):
-    #    a, b = list(map(int, input().split()))
-    #    tree[a - 1].children.append(b - 1)
-    #    tree[b - 1].children.append(a - 1)
-    #return tree
-
     # This is to avoid stack overflow issues
-    #threading.Thread(target=main).start()
+    threading.Thread(target=main).start()