Add new algorithm

Hau Nguyen · Hau Nguyen · commit 66f00a6f225b · 2023-08-03T10:45:07.000+07:00
diff --git a/graphs/dijkstra.qs b/graphs/dijkstra.qs
@@ -0,0 +1,62 @@
+namespace QuantumDijkstra {
+    open Microsoft.Quantum.Diagnostics;
+
+    operation Graph(): (Int, Int, Int, Int)[] {
+        return [ (0, 1, 4, 0), (0, 2, 1, 0), (1, 2, 2, 0), (1, 3, 5, 0), (2, 3, 1, 0) ];
+    }
+
+    operation FindMinimumDistanceNode(distances : Qubit[], n : Int) : Int {
+        mutable minIndex = 0;
+        mutable minValue = 1000;
+
+        for (i in 0 .. n - 1) {
+            let value = M(distances[i]);
+            if (value > 0 && value < minValue) {
+                set minIndex = i;
+                set minValue = value;
+            }
+        }
+        return minIndex;
+    }
+
+    operation Dijkstra() : Int[] {
+        let graph = Graph();
+        let n = 4; 
+
+        mutable distances = new Qubit[n];
+        for (i in 0 .. n - 1) {
+            set distances w/= i <- Microsoft.Quantum.Convert.IntAsBool(i == 0);
+        }
+
+
+        for (i in 0 .. n - 1) {
+            let minIndex = FindMinimumDistanceNode(distances, n);
+            Message($"Visiting Node {minIndex}");
+
+            for (edge in graph) {
+                if (edge[0] == minIndex) {
+                    let neighbor = edge[1];
+                    let weight = edge[2];
+                    mutable currentDistance = distances[neighbor];
+                    if (M(currentDistance) == 0) {
+                        set distances w/= neighbor <- Microsoft.Quantum.Convert.IntAsBool(NotBool(M(currentDistance)) or weight < M(distances[minIndex]) + weight);
+                    }
+                }
+            }
+            set distances[minIndex] = One;
+        }
+
+        mutable result = new Int[n];
+        for (i in 0 .. n - 1) {
+            set result w/= i <- M(distances[i]);
+            Reset(distances[i]);
+        }
+
+        return result;
+    }
+
+    entrypoint() : Unit {
+        let shortestDistances = Dijkstra();
+        Message($"Shortest distances: {shortestDistances}");
+    }
+}
diff --git a/search/BinarySearch.qs b/search/BinarySearch.qs
@@ -0,0 +1,23 @@
+namespace MyNamespace {
+    open Microsoft.Quantum.Canon;
+    open Microsoft.Quantum.Intrinsic;
+
+    operation BinarySearch (sortedArray : Int[], target : Int) : Int {
+        mutable left = 0;
+        mutable right = Length(sortedArray) - 1;
+
+        while (left <= right) {
+            let mid = (left + right) / 2;
+            let midValue = sortedArray[mid];
+            
+            if (midValue == target) {
+                return mid;
+            } elif (midValue < target) {
+                set left = mid + 1;
+            } else {
+                set right = mid - 1;
+            }
+        }
+        return -1;
+    }
+}
diff --git a/search/TreeTraversal.qs b/search/TreeTraversal.qs
@@ -0,0 +1,16 @@
+namespace TreeTraversal {
+    open Microsoft.Quantum.Intrinsic;
+    newtype TreeNode = (Int, TreeNode?, TreeNode?);
+    operation DepthFirstTraversal(root : TreeNode) : Unit {
+        BodyTraverse(root);
+    }
+    operation BodyTraverse(node : TreeNode) : Unit {
+        Message($"Visited Node: {node[0]}");
+        if (not IsResultZero(M, node[1])) {
+            BodyTraverse(M!Borrow(node[1]));
+        }
+        if (not IsResultZero(M, node[2])) {
+            BodyTraverse(M!Borrow(node[2]));
+        }
+    }
+}
