did week 13

viikko13/connections.py

@@ -0,0 +1,66 @@
+class Connections:
+    def __init__(self, n_count):
+        self.nodes = [x for x in range(1, n_count + 1)]
+        self.graph = {node: [] for node in self.nodes}
+        self.reverse = {node: [] for node in self.nodes}
+
+    def add_link(self, a, b):
+        self.graph[a].append(b)
+        self.reverse[b].append(a)
+
+    def visit(self, node, phase):
+        if node in self.visited:
+            return
+        self.visited.add(node)
+
+        if phase == 1:
+            graph = self.graph
+        if phase == 2:
+            graph = self.reverse
+
+        for next_node in graph[node]:
+            self.visit(next_node, phase)
+
+        if phase == 1:
+            self.order.append(node)
+
+    def check_network(self):
+        self.target = set(self.nodes)
+        self.visited = set()
+        self.order = []
+        self.last_order = []
+
+        for node in self.nodes:
+            self.visit(node, 1)
+
+
+        self.order.reverse()
+        self.visited.clear()
+
+        count = 0
+        for node in self.order:
+            if node not in self.visited:
+                count += 1
+                self.visit(node, 2)
+
+        return count == 1
+
+
+if __name__ == "__main__":
+    connections = Connections(5)
+
+    connections.add_link(1, 2)
+    connections.add_link(2, 3)
+    connections.add_link(1, 3)
+    connections.add_link(4, 5)
+
+    print(connections.check_network())  # False
+
+    connections.add_link(3, 5)
+    connections.add_link(1, 4)
+
+    print(connections.check_network())  # False
+
+    connections.add_link(5, 1)
+
+    print(connections.check_network())  # True

viikko13/courseplan.py

@@ -0,0 +1,61 @@
+class CoursePlan:
+    def __init__(self):
+        self.nodes = []
+        self.graph = {node: [] for node in self.nodes}
+
+    def add_course(self, course):
+        self.nodes.append(course)
+        self.graph = {node: [] for node in self.nodes} # Recalc things
+
+    def add_requisite(self, course1, course2):
+        self.graph[course1].append(course2) 
+
+    def find_order(self):
+        self.state = {}
+        for node in self.nodes:
+            self.state[node] = 0
+
+        self.order = []
+        self.cycle = False
+
+        for node in self.nodes:
+            if self.state[node] == 0:
+                self.visit(node)
+
+        if self.cycle:
+            return None
+        else:
+            self.order.reverse()
+            return self.order
+
+    def visit(self, node):
+        if self.state[node] == 1:
+            self.cycle = True
+            return
+        if self.state[node] == 2:
+            return
+
+        self.state[node] = 1
+        for next_node in self.graph[node]:
+            self.visit(next_node)
+
+        self.state[node] = 2
+        self.order.append(node)
+
+if __name__ == "__main__":
+    courses = CoursePlan()
+
+    courses.add_course("Ohpe")
+    courses.add_course("Ohja")
+    courses.add_course("Tira")
+    courses.add_course("Jym")
+
+    courses.add_requisite("Ohpe", "Ohja")
+    courses.add_requisite("Ohja", "Tira")
+    courses.add_requisite("Jym", "Tira")
+
+    print(courses.find_order()) # esim. [Ohpe, Jym, Ohja, Tira]
+
+    courses.add_requisite("Tira", "Tira")
+
+    print(courses.find_order()) # None

viikko13/paths1.py

@@ -0,0 +1,42 @@
+class CountPaths:
+    def __init__(self, nodes):
+        self.nodes = nodes
+        self.graph = {node: [] for node in self.nodes}
+
+    def add_edge(self, a, b):
+        self.graph[a].append(b)
+
+    def count_from(self, node):
+        if node in self.result:
+            return self.result[node]
+
+        path_count = 0
+        for next_node in self.graph[node]:
+            path_count += self.count_from(next_node)
+
+        self.result[node] = path_count
+        return path_count
+
+    def count_paths(self, x, y):
+        self.result = {y: 1}
+        return self.count_from(x)
+
+
+def create_edges():
+    result = []
+    for i in range(2, 100):
+        result.extend([(1, i), (i, 100)])
+
+    result.append((97,99))
+    result.append((98,99))
+    return result
+
+
+if __name__ == "__main__":
+    edges = create_edges()
+    print(edges)
+
+    counter = CountPaths(range(1, 100 + 1))
+    for edge in edges:
+        counter.add_edge(edge[0], edge[1])
+    print(counter.count_paths(1, 100))  # 100

viikko13/topological_order.py

@@ -0,0 +1,22 @@
+class Graph:
+    def __init__(self, nodes):
+        self.nodes = nodes
+        self.graph = {node: [] for node in self.nodes}
+
+    def add_edge(self, a, b):
+        self.graph[a].append(b)
+
+
+if __name__ == "__main__":
+    g = Graph([i for i in range(1, 1001)])
+
+    for i in range(1, 1001):
+        for j in range(1, i):
+            g.add_edge(j, i)
+
+    sum = 0
+    for x in g.graph.keys():
+        sum += len(g.graph[x])
+        print(x, g.graph[x])
+
+    print(sum)