Add files via upload

Author: DanielAvdar

bfs.py

@@ -0,0 +1,71 @@
+# Uses python3
+##############################
+# @author Daniel Avdar
+# @input: #edges, #vertices (one line)
+#         the graph's edges (following lines)
+#         the vertices u,v to find the path between them (last line)
+# @output: the minimum number of edges in a path from 𝑢 to 𝑣,
+#          or −1 if there is no path.
+# @description: bfs algorithm for finding the shortest path in a graph
+#
+##############################
+
+import sys
+import queue
+
+q = queue.Queue()
+from numpy import inf
+
+
+def generate_DWG_raph(edges, n):
+    graph = {}
+    for i in range(1, n + 1):
+        graph[i] = [False, dict(), False, [inf, i]]
+    for (a, b) in edges:
+        graph[a][1][b] = 1
+        graph[b][1][a] = 1
+    return graph
+
+
+def distance(graph, s, t):
+    qu = queue.Queue()
+
+    def set_v(v, w):
+        graph[v][3][0] = min(w, graph[v][3][0])
+
+    set_v(s, 0)
+    qu.put(graph[s][3])
+    graph[s][2] = True
+    while not qu.empty():
+        w, v = qu.get()
+        graph[v][0] = True
+        for i in graph[v][1].keys():
+            if graph[i][0]:
+                continue
+
+            set_v(i, w + graph[v][1][i])
+            if graph[i][2]:
+                continue
+            graph[i][2] = True
+            qu.put(graph[i][3])
+
+    return graph[t][3][0] if graph[t][3][0] != inf else -1
+
+
+def main():
+    input = sys.stdin.read()
+    data = list(map(int, input.split()))
+    n, m = data[0:2]
+    data = data[2:]
+    edges = list(zip(data[0:(2 * m):2], data[1:(2 * m):2]))
+    g = generate_DWG_raph(edges, n)
+    if not data:
+        print(-1)
+        return
+    s, t = data[-2], data[-1]
+    print(distance(g, s, t))
+
+
+if __name__ == '__main__':
+    main()
+# todo git

dijkstra.py

@@ -0,0 +1,69 @@
+# Uses python3
+##############################
+# @author Daniel Avdar
+# @input: #edges, #vertices (one line)
+#         the graph's edges (following lines)
+#         the vertices s,t to find the path between them (last line)
+# @output: the minimum weight of a path from s to t,
+#          or −1 if there is no path.
+# @description: Dijkstra algorithm for finding the shortest path in a weighted graph
+#
+##############################
+
+import sys
+import heapq
+from numpy import inf
+
+heap = []
+
+
+def generateDWGraph(edges, n):
+    graph = {}
+    for i in range(1, n + 1):
+        graph[i] = [False, dict(), None, [inf, i]]
+        heap.append(graph[i][3])
+    for ((a, b), w) in edges:
+        graph[a][1][b] = w
+
+    return graph
+
+
+def distance(graph, s, t):
+    heap_ = heap
+
+    def set_v(v, w):
+        graph[v][3][0] = min(w, graph[v][3][0])
+
+    set_v(s, 0)
+    heapq.heapify(heap_)
+
+    while heap_:
+        w, v = heapq.heappop(heap_)
+        graph[v][0] = True
+        for i in graph[v][1].keys():
+            if graph[i][0]:
+                continue
+            set_v(i, w + graph[v][1][i])
+        heapq.heapify(heap_)
+    return graph[t][3][0] if graph[t][3][0] != inf else -1
+
+
+def main():
+    input_ = sys.stdin.read()
+    data = list(map(int, input_.split()))
+    n, m = data[0:2]
+    data = data[2:]
+    edges = list(zip(zip(data[0:(3 * m):3], data[1:(3 * m):3]), data[2:(3 * m):3]))
+
+    if not data:
+        print(0)
+        return
+
+    s, t = data[-2], data[-1]
+    g = generateDWGraph(edges, n)
+    print(distance(g, s, t))
+
+
+if __name__ == '__main__':
+    main()
+# todo git

eulerian_path.py

@@ -0,0 +1,142 @@
+# python3
+##############################
+#
+# @author Daniel Avdar
+#
+# @description: Finds the Eulerian cycles in the graph and returns an Eulerian Path.
+#               That is used for a (circular) genome, that spells Eulerian cycles in
+#               the de Bruijn graph constructed on all k-mers of the genome.
+#
+# @input:The first line contains integers n and m— the number of vertices
+#        and the number of edges,respectively.
+#        Each of the following m lines specifies an edge in the format “u
+#        v”. (As usual, we assume that the vertices of the graph
+#        are {1,2,...,n}.) The graph may contain self-loops
+#        (that is, edges of the form(v,v)) and parallel edges
+#        (that is, several copies of the same edge).
+#        It is guaranteed that the graph is strongly connected.
+#
+# @output:If the graph has no Eulerian cycle, output 0.
+#         Otherwise output 1 in the first line and a sequence v1,v2,...,vm
+#         of vertices in the second line - the given path.
+#
+##############################
+import threading
+import collections
+import sys
+
+sys.setrecursionlimit(8 ** 10)
+threading.stack_size(2 ** 27)
+
+Vertex = collections.namedtuple('Vertex',
+                                ["visited", "neighbors", "self", "num_of_outs", "num_of_ins"])  # "back_neighbors"
+
+
+def dfs(graph, vertex, func):
+    while graph[vertex].num_of_outs > 0:
+        neighbor_ind = len(graph[vertex].neighbors) - graph[vertex].num_of_outs
+        neighbor = graph[graph[vertex].neighbors[neighbor_ind]].self
+        graph[vertex] = graph[vertex]._replace(num_of_outs=graph[vertex].num_of_outs - 1)
+        dfs(graph, neighbor, func)
+    func(vertex)
+
+
+def find_start(graph):
+    start_v = 1
+    for i in graph:
+        outs = graph[i].num_of_outs
+        ins = graph[i].num_of_ins
+        if outs != ins:
+            return 0
+    return start_v
+
+
+def build_graph(edges, max_v_num):
+    graph = dict()
+    for i in range(1, max_v_num + 1):
+        graph[i] = Vertex._make([False, list(), i, 0, 0])
+    for e in edges:
+        graph[e[0]].neighbors.append(e[1])
+        graph[e[0]] = graph[e[0]]._replace(num_of_outs=graph[e[0]].num_of_outs + 1)
+        graph[e[1]] = graph[e[1]]._replace(num_of_ins=graph[e[1]].num_of_ins + 1)
+    start_v = find_start(graph)
+    if start_v == 0:
+        return None
+    return graph
+
+
+def inputer():
+    data = sys.stdin.read().split()
+    data = list(map(lambda i: (int(data[i]), int(data[i + 1])), range(0, len(data) - 1, 2)))
+    n, edges_num = data[0]
+    return n, edges_num, data[1:]
+
+
+def find_eulerian_path(n, data):
+    graph = build_graph(data, n)
+    if graph == None:
+        return 0
+    tmp_res = []
+
+    def func(v):
+        tmp_res.append(v)
+
+    dfs(graph, graph[1].self, func)
+    tmp_res = tmp_res[:len(tmp_res) - 1][::-1]
+    return 1, tmp_res
+
+
+def test(filename):
+    """
+    >>> test("01")
+    1
+    >>> test("02")
+    1
+    >>> test("03")
+    1
+    >>> test("04")
+    1
+    >>> test("05")
+    1
+    >>> test("06")
+    1
+    >>> test("07")
+    """
+    f = open(filename)
+
+    lines = f.readlines()
+
+    n, m = map(int, lines[0].split())
+
+    adj_matrix = [list(map(int, i.split())) for i in lines[1:]]
+
+    f.close()
+    f = open(filename + ".a")
+    lines = f.readlines()
+    expected1 = list(map(int, lines[0].split()))[0]
+    expected2 = None
+    if expected1:
+        expected2 = list(map(int, lines[1].split()))
+    f.close()
+    exist = find_eulerian_path(n, adj_matrix)
+    res = None
+    if exist is not 0:
+        exist, res = exist
+
+    pass_ = exist == expected1 and res == expected2
+    return 1 if pass_ else res
+
+
+def main():
+    n, Edges_num, data = inputer()
+    res = find_eulerian_path(n, data)
+    if res == 0:
+        print(res)
+        return
+    print(res[0])
+    for i in res[1]:
+        print(i, end=' ')
+
+
+threading.Thread(target=main).start()
+# todo git