initial commit

codes/core/dijkstra/heap_dijkstra.py

@@ -0,0 +1,46 @@
+class DijkstraStats:
+    def __init__(self):
+        self.extract_min_calls = 0
+        self.relax_attempts = 0
+        self.relax_success = 0
+        # self.decrease_key_calls = 0
+        # self.add_calls = 0
+
+def heap_dijkstra(nodes, adj, heap, start, end):
+    INF = float('inf')
+    dist = [INF] * nodes
+    visited = [False] * nodes
+    stats = DijkstraStats()
+
+    dist[start] = 0
+
+    for v in range(nodes):
+        heap.add(v, dist[v])
+        # stats.add_calls += 1
+    
+    while True:
+        res = heap.extract_min()
+        stats.extract_min_calls += 1
+        if res is None:
+            break
+        cur, cur_dist = res
+
+        if cur_dist == INF:
+            break
+
+        if cur == end:
+            break
+
+        for nxt, d in adj[cur]:
+            stats.relax_attempts += 1
+            if visited[nxt]:
+                continue
+            new = cur_dist + d
+            if new < dist[nxt]:
+                stats.relax_success += 1
+                dist[nxt] = new
+                heap.decrease_key(nxt, new)
+        
+        visited[cur] = True
+    
+    return dist[end], stats

codes/core/dijkstra/pure_dijkstra.py

@@ -0,0 +1,32 @@
+def pure_dijkstra(nodes, adj, start, end):
+    dist = [float('inf')] * nodes
+    dist[start] = 0
+    visited = [False] * nodes
+
+    cur = start
+    
+    while True:
+        if cur == -1:
+            break
+
+        if cur == end:
+            break
+
+        for next, d in adj[cur]:
+            if not visited[next]:
+                new = dist[cur] + d
+                if new < dist[next]:
+                    dist[next] = new
+        
+        visited[cur] = True
+        
+        # Finding min node
+        min_node = -1
+        min_val = float('inf')
+        for n in range(nodes):
+            if not visited[n] and dist[n] < min_val:
+                min_node = n
+                min_val = dist[n]
+        cur = min_node
+    
+    return dist[end]

codes/core/heaps/binary_heap.py

@@ -0,0 +1,75 @@
+class BinHeap:
+    def __init__(self, nodes):
+        self.heap = []
+        self.pos = [-1] * nodes
+
+    def sift_up(self, idx):
+        heap = self.heap
+        pos = self.pos
+
+        backup = heap[idx]
+        cur = idx
+
+        while cur > 0:
+            par = (cur - 1) // 2
+            if backup[1] >= heap[par][1]:
+                break
+            heap[cur] = heap[par]
+            pos[heap[cur][0]] = cur
+            cur = par
+        heap[cur] = backup
+        pos[backup[0]] = cur
+
+    def sift_down(self, idx):
+        heap = self.heap
+        pos = self.pos
+        
+        n = len(heap)
+
+        backup = heap[idx]
+        cur = idx
+        
+        while True:
+            left = cur * 2 + 1
+            if left >= n:
+                break
+            right = left + 1
+            tar = right if right < n and heap[right][1] < heap[left][1] else left
+            if backup[1] <= heap[tar][1]:
+                break
+            heap[cur] = heap[tar]
+            pos[heap[cur][0]] = cur
+            cur = tar
+        heap[cur] = backup
+        pos[backup[0]] = cur
+        
+    def add(self, key, dist):
+        idx = len(self.heap)
+        self.heap.append([key, dist])
+        self.pos[key] = idx
+        self.sift_up(idx)
+    
+    def extract_min(self):
+        heap = self.heap
+        pos = self.pos
+        if not heap:
+            return None
+        min_node, min_dist = heap[0]
+        pos[min_node] = -1
+
+        last = heap.pop()
+        if heap:
+            heap[0] = last
+            pos[last[0]] = 0
+            self.sift_down(0)
+        return (min_node, min_dist)
+    
+    def decrease_key(self, key, new_dist):
+        idx = self.pos[key]
+        if idx == -1:
+            return None
+        node = self.heap[idx]
+        if new_dist >= node[1]:
+            return None
+        node[1] = new_dist
+        self.sift_up(idx) 

codes/core/heaps/fibonacci_heap.py

@@ -0,0 +1,177 @@
+import math
+
+class Node:
+    __slots__ = ('key', 'dist', 'left', 'right', 'parent', 'child', 'degree', 'lost')
+
+    def __init__(self, key, dist):
+        self.key = key
+        self.dist = dist
+
+        self.left = self
+        self.right = self
+
+        self.parent = None
+        self.child = None
+        
+        self.degree = 0
+        self.lost = False
+    
+    def connect_right(self, new_right):
+        old_right = self.right
+        new_left = new_right.left
+        
+        new_right.left = self
+        new_left.right = old_right
+
+        old_right.left = new_left
+        self.right = new_right
+    
+    def remove(self):
+        self.left.right = self.right
+        self.right.left = self.left
+        self.left = self
+        self.right = self
+
+    def connect_child(self, child):
+        child.parent = self
+        child.lost = False
+
+        if self.child is None:
+            self.child = child
+        else:
+            self.child.connect_right(child)
+        
+        self.degree += 1
+
+class FiboHeap:
+    def __init__(self, nodes):
+        self.min = None
+        self.n = 0
+        self.pos = [None] * nodes
+    
+    def cut(self, cur):
+        p = cur.parent
+        if p.child is cur:
+            if cur.right is cur:
+                p.child = None
+            else:
+                p.child = cur.right
+
+        cur.remove()
+        p.degree -= 1
+
+        cur.parent = None
+        cur.lost = False
+
+        self.min.connect_right(cur)
+        if cur.dist < self.min.dist:
+            self.min = cur
+    
+    def cascading_cut(self, cur):
+        while True:
+            p = cur.parent
+            if p is None:
+                return
+            if not cur.lost:
+                cur.lost = True
+                return
+            self.cut(cur)
+            cur = p
+
+    def add(self, key, dist):
+        cur = Node(key, dist)
+
+        if self.min is None:
+            self.min = cur
+        else:
+            self.min.connect_right(cur)
+            if cur.dist < self.min.dist:
+                self.min = cur
+        
+        self.n += 1
+        self.pos[key] = cur
+    
+    def extract_min(self):
+        # 1. Find min node
+        min_node = self.min
+        self.n -= 1
+
+        # 2. Make min node's child into individual tree
+        c = min_node.child
+        if c is not None:
+            start = c
+            cur = c
+            while True:
+                cur.parent = None
+                cur.lost = False
+                cur = cur.right
+                if cur == start:
+                    break
+        
+            min_node.connect_right(start)
+
+        if min_node.right is min_node:
+            self.min = None
+            return (min_node.key, min_node.dist)
+        
+        nxt = min_node.right
+        min_node.remove()
+        self.min = nxt
+
+        min_node.child = None
+        min_node.degree = 0
+        self.pos[min_node.key] = None
+        
+        # 3. Make into binomial tree
+        roots = []
+        start = self.min
+        cur = start
+        while True:
+            roots.append(cur)
+            cur = cur.right
+            if cur == start:
+                break
+        
+        max_deg = int(math.log2(self.n)) + 2 if self.n > 0 else 1 # 여기서 +2 하는 이유는 사실은 log2가 아니라 fibonacci 수열 기반이기 때문에 +1 더 해주는 거임.
+        A = [None] * (max_deg + 1)
+
+        for cur in roots:
+            x = cur
+            d = x.degree
+
+            while A[d] is not None:
+                y = A[d]
+                if y.dist < x.dist:
+                    x, y = y, x
+                y.remove()
+                x.connect_child(y)
+                A[d] = None
+                d = x.degree
+            A[d] = x
+
+        # 4. Find new min
+        self.min = None
+        for cur in A:
+            if cur is None:
+                continue
+            if self.min is None:
+                self.min = cur
+            else:
+                if cur.dist < self.min.dist:
+                    self.min = cur
+
+        return (min_node.key, min_node.dist)
+
+    def decrease_key(self, key, new_dist):
+        cur = self.pos[key]
+        if cur is None or new_dist >= cur.dist:
+            return
+        cur.dist = new_dist
+        p = cur.parent
+
+        if p is not None and cur.dist < p.dist:
+            self.cut(cur)
+            self.cascading_cut(p)
+            
+        if cur.dist < self.min.dist:
+            self.min = cur