add

Author: nemkin

src/lib/code/en/bf/algo/bellman_ford.py

@@ -0,0 +1,47 @@
+infinity = float('inf')
+
+def reverse_graph(G):
+  n = len(G)
+  G_rev = [[] for v in range(n)]
+  for u in range(n):
+    for v, weight in G[u]:
+      G_rev[v].append((u, weight))
+  return G_rev
+
+def bellman_ford(G_in, s):
+  n = len(G_in)
+  dist = [infinity] * n; dist[s] = 0
+  prev = [None] * n
+
+  for _ in range(n-1):
+    dist_new = [None] * n; dist_new[s] = 0
+    prev_new = [None] * n
+    for v in range(n):
+      if v == s:
+        continue
+      dist_new[v] = dist[v]
+      prev_new[v] = prev[v]
+      for u, weight in G_in[v]:
+        if dist[u] + weight < dist_new[v]:
+          dist_new[v] = dist[u] + weight
+          prev_new[v] = u
+    dist = dist_new
+    prev = prev_new
+
+  return dist, prev
+
+n, m = map(int, input().split())
+G = [[] for _ in range(n)]
+for i in range(m):
+  u, v, weight = map(int, input().split())
+  G[u].append((v, weight))
+s = int(input())
+
+G_in = reverse_graph(G)
+
+MEASURE_START()
+dist, prev = bellman_ford(G_in, s)
+MEASURE_STOP()
+
+print("Shortest paths:"); print(dist); print()
+print("Parents for the shortest paths:"); print(prev); print()

src/lib/code/en/bf/generator/erdos_renyi_0.2.py

@@ -0,0 +1,24 @@
+import random
+rng = random.Random(42)
+
+# Erdős-Rényi directed graph generator (positive weights)
+def generate_graph(n, p):
+  edges = []
+  for u in range(n):
+    for v in range(n):
+      if u != v and rng.random() < p:
+        weight = rng.randint(1, 50)
+        edges.append((u, v, weight))
+  return edges
+
+p = 0.2
+sizes = [(i+1)*100 for i in range(5)]
+
+for n in sizes:
+  edges = generate_graph(n, p)
+  m = len(edges)
+  lines = [f"{n} {m}"]
+  for u, v, weight in edges:
+    lines.append(f"{u} {v} {weight}")
+  lines.append(f"0")
+  INPUT("\n".join(lines))

src/lib/code/en/bf/generator/erdos_renyi_0.8.py

@@ -0,0 +1,24 @@
+import random
+rng = random.Random(42)
+
+# Erdős-Rényi directed graph generator (positive weights)
+def generate_graph(n, p):
+  edges = []
+  for u in range(n):
+    for v in range(n):
+      if u != v and rng.random() < p:
+        weight = rng.randint(1, 50)
+        edges.append((u, v, weight))
+  return edges
+
+p = 0.8
+sizes = [(i+1)*100 for i in range(5)]
+
+for n in sizes:
+  edges = generate_graph(n, p)
+  m = len(edges)
+  lines = [f"{n} {m}"]
+  for u, v, weight in edges:
+    lines.append(f"{u} {v} {weight}")
+  lines.append(f"0")
+  INPUT("\n".join(lines))

src/lib/code/en/bf/input.txt

@@ -0,0 +1,10 @@
+5 8
+0 1 6
+0 3 7
+1 2 5
+1 3 8
+1 4 -4
+2 1 -2
+3 2 -3
+3 4 9
+0

src/lib/code/hu/bf/algo/bellman_ford.py

@@ -0,0 +1,47 @@
+vegtelen = float('inf')
+
+def grafot_megfordit(G):
+  n = len(G)
+  G_ford = [[] for v in range(n)]
+  for u in range(n):
+    for v, suly in G[u]:
+      G_ford[v].append((u, suly))
+  return G_ford
+
+def bellman_ford(G_be, s):
+  n = len(G_be)
+  tav = [vegtelen] * n; tav[s] = 0
+  elozo = [None] * n
+
+  for _ in range(n-1):
+    tav_uj = [None] * n; tav_uj[s] = 0
+    elozo_uj = [None] * n
+    for v in range(n):
+      if v == s:
+        continue
+      tav_uj[v] = tav[v]
+      elozo_uj[v] = elozo[v]
+      for u, suly in G_be[v]:
+        if tav[u] + suly < tav_uj[v]:
+          tav_uj[v] = tav[u] + suly
+          elozo_uj[v] = u
+    tav = tav_uj
+    elozo = elozo_uj
+
+  return tav, elozo
+
+n, m = map(int, input().split())
+G = [[] for _ in range(n)]
+for i in range(m):
+  u, v, suly = map(int, input().split())
+  G[u].append((v, suly))
+s = int(input())
+
+G_be = grafot_megfordit(G)
+
+MERES_KEZD()
+tav, elozo = bellman_ford(G_be, s)
+MERES_VEG()
+
+print("Legrövidebb utak:"); print(tav); print()
+print("Legrövidebb utak szülői:"); print(elozo); print()

src/lib/code/hu/bf/generator/erdos_renyi_0.2.py

@@ -0,0 +1,24 @@
+import random
+rng = random.Random(42)
+
+# Erdős-Rényi irányított gráf generátor (pozitív súlyok)
+def generate_graph(n, p):
+  edges = []
+  for u in range(n):
+    for v in range(n):
+      if u != v and rng.random() < p:
+        weight = rng.randint(1, 50)
+        edges.append((u, v, weight))
+  return edges
+
+p = 0.2
+sizes = [(i+1)*100 for i in range(5)]
+
+for n in sizes:
+  edges = generate_graph(n, p)
+  m = len(edges)
+  lines = [f"{n} {m}"]
+  for u, v, weight in edges:
+    lines.append(f"{u} {v} {weight}")
+  lines.append(f"0")
+  BEMENET("\n".join(lines))

src/lib/code/hu/bf/generator/erdos_renyi_0.8.py

@@ -0,0 +1,24 @@
+import random
+rng = random.Random(42)
+
+# Erdős-Rényi irányított gráf generátor (pozitív súlyok)
+def generate_graph(n, p):
+  edges = []
+  for u in range(n):
+    for v in range(n):
+      if u != v and rng.random() < p:
+        weight = rng.randint(1, 50)
+        edges.append((u, v, weight))
+  return edges
+
+p = 0.8
+sizes = [(i+1)*100 for i in range(5)]
+
+for n in sizes:
+  edges = generate_graph(n, p)
+  m = len(edges)
+  lines = [f"{n} {m}"]
+  for u, v, weight in edges:
+    lines.append(f"{u} {v} {weight}")
+  lines.append(f"0")
+  BEMENET("\n".join(lines))

src/lib/code/hu/bf/input.txt

@@ -0,0 +1,10 @@
+5 8
+0 1 6
+0 3 7
+1 2 5
+1 3 8
+1 4 -4
+2 1 -2
+3 2 -3
+3 4 9
+0

src/lib/code/load-code.js

@@ -97,6 +97,18 @@ function loadHu() {
       "input": {
         "input.txt": { content: file("hu", "dijkstra/input.txt") },
       }
+    },
+    bf: {
+      "algo": {
+        "bellman_ford.py": { content: file("hu", "bf/algo/bellman_ford.py") },
+      },
+      "generator": {
+        "erdos_renyi_0.2.py": { content: file("hu", "bf/generator/erdos_renyi_0.2.py") },
+        "erdos_renyi_0.8.py": { content: file("hu", "bf/generator/erdos_renyi_0.8.py") },
+      },
+      "input": {
+        "input.txt": { content: file("hu", "bf/input.txt") },
+      }
     }
   };
 }
@@ -186,12 +198,24 @@ function loadEn() {
       "input": {
         "input.txt": { content: file("en", "dijkstra/input.txt") },
       }
+    },
+    bf: {
+      "algo": {
+        "bellman_ford.py": { content: file("en", "bf/algo/bellman_ford.py") },
+      },
+      "generator": {
+        "erdos_renyi_0.2.py": { content: file("en", "bf/generator/erdos_renyi_0.2.py") },
+        "erdos_renyi_0.8.py": { content: file("en", "bf/generator/erdos_renyi_0.8.py") },
+      },
+      "input": {
+        "input.txt": { content: file("en", "bf/input.txt") },
+      }
     }
   };
 }
 
 export function loadDefaultCode() {
-  return { version: 29, pages: { hu: loadHu(), en: loadEn() } };
+  return { version: 30, pages: { hu: loadHu(), en: loadEn() } };
 }
 
 export const defaultCode = loadDefaultCode();

src/lib/locales/en.json

@@ -70,6 +70,10 @@
     "dijkstra": {
       "title": "Dijkstra's algorithm",
       "desc": "Single-source shortest paths in directed graphs with non-negative edge weights."
+    },
+    "bf": {
+      "title": "Bellman-Ford algorithm",
+      "desc": "Single-source shortest paths in directed graphs, allowing negative edge weights but no negative cycles."
     }
   }
 }