dancealgorithm 0.1.3__py3-none-any.whl → 0.1.4__py3-none-any.whl

dancealgorithm/__init__.py

@@ -9,7 +9,7 @@ import sys
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Union
 
-__version__ = "0.1.3"
+__version__ = "0.1.4"
 
 # Import bundled assignments registry and sheets
 from dancealgorithm.assignments import ASSIGNMENTS_DIR, REGISTRY, SHEETS

dancealgorithm/assignments/LC - Delivery/Solution.java

@@ -1,152 +1,180 @@
-import java.util.*;
-
-public class Solution {
-    static final double INF = 1e9;
-
-    static class Node implements Comparable<Node> {
-        double[][] matrix;
-        List<Integer> path;
-        double cost;
-        int city, level;
-
-        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
-            this.matrix = copy(m);
-            this.path = new ArrayList<>(p);
-            this.path.add(city);
-            this.city = city;
-            this.level = level;
-            this.cost = cost;
-        }
-
-        public int compareTo(Node o) {
-            return Double.compare(this.cost, o.cost);
-        }
-    }
-
-    static double[][] copy(double[][] m) {
-        double[][] res = new double[m.length][m.length];
-        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
-        return res;
-    }
-
-    static double reduce(double[][] m) {
-        int n = m.length;
-        double reduction = 0;
-
-        // Row reduction
-        for (int i = 0; i < n; i++) {
-            double min = INF;
-            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-
-        // Column reduction
-        for (int j = 0; j < n; j++) {
-            double min = INF;
-            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-        return reduction;
-    }
-
-    static void solveTSP(double[][] graph, String[] locations) {
-        int n = graph.length;
-        double[][] initial = copy(graph);
-        double rootCost = reduce(initial);
-
-        PriorityQueue<Node> pq = new PriorityQueue<>();
-        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
-
-        double bestCost = INF;
-        List<Integer> bestTour = null;
-
-        while (!pq.isEmpty()) {
-            Node curr = pq.poll();
-            if (curr.cost >= bestCost) continue;
-
-            if (curr.level == n) {
-                int last = curr.city;
-                if (graph[last][0] < INF) {
-                    double tourCost = 0;
-                    for (int i = 0; i < n - 1; i++) {
-                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
-                    }
-                    tourCost += graph[last][0];
-                    if (tourCost < bestCost) {
-                        bestCost = tourCost;
-                        bestTour = new ArrayList<>(curr.path);
-                        bestTour.add(0);
-                    }
-                }
-                continue;
-            }
-
-            int u = curr.city;
-            for (int v = 0; v < n; v++) {
-                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
-                    double[][] child = copy(curr.matrix);
-                    double edge = curr.matrix[u][v];
-
-                    for (int j = 0; j < n; j++) child[u][j] = INF;
-                    for (int i = 0; i < n; i++) child[i][v] = INF;
-                    if (curr.level < n - 1) child[v][0] = INF;
-
-                    double childCost = curr.cost + edge + reduce(child);
-                    if (childCost < bestCost) {
-                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
-                    }
-                }
-            }
-        }
-
-        if (bestTour == null) {
-            System.out.println("\nNo complete round-trip route exists.");
-            return;
-        }
-
-        System.out.printf("\nOptimal Round-Trip Delivery Cost: Rs. %.2f\n", bestCost);
-        System.out.print("Optimal Delivery Tour: ");
-        for (int i = 0; i < bestTour.size(); i++) {
-            System.out.print(locations[bestTour.get(i)] + (i < bestTour.size() - 1 ? " -> " : "\n"));
-        }
-    }
-
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-
-        System.out.print("Enter number of locations: ");
-        int n = sc.nextInt();
-        sc.nextLine();
-
-        String[] locations = new String[n];
-        for (int i = 0; i < n; i++) {
-            System.out.print("Enter location " + (i + 1) + ": ");
-            locations[i] = sc.nextLine().trim();
-        }
-
-        double[][] graph = new double[n][n];
-        System.out.println("\nEnter travel cost matrix:");
-        System.out.println("Enter -1 if there is no direct route.");
-
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                if (i == j) {
-                    graph[i][j] = INF;
-                } else {
-                    System.out.print("Cost from " + locations[i] + " to " + locations[j] + ": ");
-                    double val = sc.nextDouble();
-                    graph[i][j] = (val == -1) ? INF : val;
-                }
-            }
-        }
-
-        solveTSP(graph, locations);
-        sc.close();
-    }
-}
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// Main solution
+public class Solution {
+    // O(n! * n^2)
+    static final double INF = 1e9;
+
+    // Search node
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        int[] path;
+        int level;
+        double cost;
+        int city;
+
+        Node(double[][] mat, int[] path, int level, double cost, int city) {
+            int n = mat.length;
+            this.matrix = new double[n][n];
+            for (int i = 0; i < n; i++) {
+                System.arraycopy(mat[i], 0, this.matrix[i], 0, n);
+            }
+            this.path = Arrays.copyOf(path, path.length);
+            this.level = level;
+            this.cost = cost;
+            this.city = city;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Double.compare(this.cost, other.cost);
+        }
+    }
+
+    // Matrix reduction
+    public static double reduceMatrix(double[][] mat, int n) {
+        double reduction = 0;
+
+        for (int i = 0; i < n; i++) {
+            double rmin = INF;
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] < rmin) rmin = mat[i][j];
+            }
+            if (rmin > 0 && rmin < INF) {
+                reduction += rmin;
+                for (int j = 0; j < n; j++) {
+                    if (mat[i][j] < INF) mat[i][j] -= rmin;
+                }
+            }
+        }
+
+        for (int j = 0; j < n; j++) {
+            double cmin = INF;
+            for (int i = 0; i < n; i++) {
+                if (mat[i][j] < cmin) cmin = mat[i][j];
+            }
+            if (cmin > 0 && cmin < INF) {
+                reduction += cmin;
+                for (int i = 0; i < n; i++) {
+                    if (mat[i][j] < INF) mat[i][j] -= cmin;
+                }
+            }
+        }
+
+        return reduction;
+    }
+
+    // Branch and bound TSP
+    public static void solveLCBB_TSP(double[][] costMatrix, String[] locations) {
+        int n = costMatrix.length;
+
+        double[][] initialMat = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            System.arraycopy(costMatrix[i], 0, initialMat[i], 0, n);
+        }
+
+        double rootCost = reduceMatrix(initialMat, n);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        int[] rootPath = {0};
+        pq.add(new Node(initialMat, rootPath, 1, rootCost, 0));
+
+        double bestCost = INF;
+        int[] bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+
+            if (curr.cost >= bestCost) {
+                continue;
+            }
+
+            if (curr.level == n) {
+                int lastCity = curr.city;
+                if (costMatrix[lastCity][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += costMatrix[curr.path[i]][curr.path[i + 1]];
+                    }
+                    tourCost += costMatrix[lastCity][0];
+
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new int[n + 1];
+                        System.arraycopy(curr.path, 0, bestTour, 0, n);
+                        bestTour[n] = 0;
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+
+            for (int v = 0; v < n; v++) {
+                boolean visited = false;
+                for (int p : curr.path) {
+                    if (p == v) { visited = true; break; }
+                }
+
+                if (!visited && curr.matrix[u][v] < INF) {
+                    double[][] childMat = new double[n][n];
+                    for (int i = 0; i < n; i++) {
+                        System.arraycopy(curr.matrix[i], 0, childMat[i], 0, n);
+                    }
+                    double edgeVal = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) childMat[u][j] = INF;
+                    for (int i = 0; i < n; i++) childMat[i][v] = INF;
+                    if (curr.level < n - 1) {
+                        childMat[v][0] = INF;
+                    }
+
+                    double reduction = reduceMatrix(childMat, n);
+                    double childCost = curr.cost + edgeVal + reduction;
+
+                    if (childCost < bestCost) {
+                        int[] childPath = Arrays.copyOf(curr.path, curr.path.length + 1);
+                        childPath[childPath.length - 1] = v;
+                        pq.add(new Node(childMat, childPath, curr.level + 1, childCost, v));
+                    }
+                }
+            }
+        }
+
+        System.out.printf("%nOptimal Round-Trip Delivery Cost: Rs. %.2f%n", bestCost);
+        System.out.print("Optimal Delivery Tour Sequence  : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(locations[bestTour[i]]);
+                if (i < n) System.out.print(" -> ");
+            }
+        }
+        System.out.println();
+    }
+
+    // Driver code
+    public static void main(String args[]) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 22: SwiftShip Delivery Route TSP - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        String locations[] = {
+            "Central Depot (Connaught Place)",
+            "East Hub (Anand Vihar)",
+            "North Hub (Rohini)",
+            "West Hub (Dwarka)",
+            "South Hub (Saket)"
+        };
+
+        double costMatrix[][] = {
+            {INF, 20, 30, 10, 11},
+            {15, INF, 16, 4,  2},
+            {3,  5,  INF, 2,  4},
+            {19, 6,  18, INF, 3},
+            {16, 4,  7,  16, INF}
+        };
+
+        solveLCBB_TSP(costMatrix, locations);
+    }
+}

dancealgorithm/assignments/LC - Drilling/Solution.java

@@ -1,164 +1,197 @@
-import java.util.*;
-
-public class Solution {
-    static final double INF = 1e9;
-
-    static class Hole {
-        String name;
-        double x, y;
-        Hole(String name, double x, double y) {
-            this.name = name;
-            this.x = x;
-            this.y = y;
-        }
-    }
-
-    static class Node implements Comparable<Node> {
-        double[][] matrix;
-        List<Integer> path;
-        double cost;
-        int city, level;
-
-        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
-            this.matrix = copy(m);
-            this.path = new ArrayList<>(p);
-            this.path.add(city);
-            this.city = city;
-            this.level = level;
-            this.cost = cost;
-        }
-
-        public int compareTo(Node o) {
-            return Double.compare(this.cost, o.cost);
-        }
-    }
-
-    static double[][] copy(double[][] m) {
-        double[][] res = new double[m.length][m.length];
-        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
-        return res;
-    }
-
-    static double reduce(double[][] m) {
-        int n = m.length;
-        double reduction = 0;
-
-        // Row reduction
-        for (int i = 0; i < n; i++) {
-            double min = INF;
-            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-
-        // Column reduction
-        for (int j = 0; j < n; j++) {
-            double min = INF;
-            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-        return reduction;
-    }
-
-    static void solveTSP(double[][] graph, Hole[] holes) {
-        int n = graph.length;
-        double[][] initial = copy(graph);
-        double rootCost = reduce(initial);
-
-        PriorityQueue<Node> pq = new PriorityQueue<>();
-        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
-
-        double bestCost = INF;
-        List<Integer> bestTour = null;
-
-        while (!pq.isEmpty()) {
-            Node curr = pq.poll();
-            if (curr.cost >= bestCost) continue;
-
-            if (curr.level == n) {
-                int last = curr.city;
-                if (graph[last][0] < INF) {
-                    double tourCost = 0;
-                    for (int i = 0; i < n - 1; i++) {
-                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
-                    }
-                    tourCost += graph[last][0];
-                    if (tourCost < bestCost) {
-                        bestCost = tourCost;
-                        bestTour = new ArrayList<>(curr.path);
-                        bestTour.add(0);
-                    }
-                }
-                continue;
-            }
-
-            int u = curr.city;
-            for (int v = 0; v < n; v++) {
-                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
-                    double[][] child = copy(curr.matrix);
-                    double edge = curr.matrix[u][v];
-
-                    for (int j = 0; j < n; j++) child[u][j] = INF;
-                    for (int i = 0; i < n; i++) child[i][v] = INF;
-                    if (curr.level < n - 1) child[v][0] = INF;
-
-                    double childCost = curr.cost + edge + reduce(child);
-                    if (childCost < bestCost) {
-                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
-                    }
-                }
-            }
-        }
-
-        if (bestTour == null) {
-            System.out.println("\nNo complete drilling tour exists.");
-            return;
-        }
-
-        System.out.printf("\nTotal Drill Head Travel Distance: %.2f mm\n", bestCost);
-        System.out.print("Optimal Drilling Toolpath: ");
-        for (int i = 0; i < bestTour.size(); i++) {
-            System.out.print(holes[bestTour.get(i)].name + (i < bestTour.size() - 1 ? " -> " : "\n"));
-        }
-    }
-
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-
-        System.out.print("Enter number of drilling points (including Home): ");
-        int n = sc.nextInt();
-        sc.nextLine();
-
-        Hole[] holes = new Hole[n];
-        for (int i = 0; i < n; i++) {
-            System.out.println("\nEnter details for Point " + i);
-            System.out.print("Point Name: ");
-            String name = sc.nextLine().trim();
-            System.out.print("X Coordinate: ");
-            double x = sc.nextDouble();
-            System.out.print("Y Coordinate: ");
-            double y = sc.nextDouble();
-            sc.nextLine();
-            holes[i] = new Hole(name, x, y);
-        }
-
-        double[][] graph = new double[n][n];
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                if (i == j) {
-                    graph[i][j] = INF;
-                } else {
-                    graph[i][j] = Math.hypot(holes[i].x - holes[j].x, holes[i].y - holes[j].y);
-                }
-            }
-        }
-
-        solveTSP(graph, holes);
-        sc.close();
-    }
-}
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// Main solution
+public class Solution {
+    // O(n! * n^2)
+    static final double INF = 1e9;
+
+    static class Hole {
+        double x, y;
+        String label;
+
+        Hole(double x, double y, String label) {
+            this.x = x;
+            this.y = y;
+            this.label = label;
+        }
+    }
+
+    // Search node
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        int[] path;
+        int level;
+        double cost;
+        int city;
+
+        Node(double[][] mat, int[] path, int level, double cost, int city) {
+            int n = mat.length;
+            this.matrix = new double[n][n];
+            for (int i = 0; i < n; i++) {
+                System.arraycopy(mat[i], 0, this.matrix[i], 0, n);
+            }
+            this.path = Arrays.copyOf(path, path.length);
+            this.level = level;
+            this.cost = cost;
+            this.city = city;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Double.compare(this.cost, other.cost);
+        }
+    }
+
+    // Matrix reduction
+    public static double reduceMatrix(double[][] mat, int n) {
+        double reduction = 0;
+
+        for (int i = 0; i < n; i++) {
+            double rmin = INF;
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] < rmin) rmin = mat[i][j];
+            }
+            if (rmin > 0 && rmin < INF) {
+                reduction += rmin;
+                for (int j = 0; j < n; j++) {
+                    if (mat[i][j] < INF) mat[i][j] -= rmin;
+                }
+            }
+        }
+
+        for (int j = 0; j < n; j++) {
+            double cmin = INF;
+            for (int i = 0; i < n; i++) {
+                if (mat[i][j] < cmin) cmin = mat[i][j];
+            }
+            if (cmin > 0 && cmin < INF) {
+                reduction += cmin;
+                for (int i = 0; i < n; i++) {
+                    if (mat[i][j] < INF) mat[i][j] -= cmin;
+                }
+            }
+        }
+
+        return reduction;
+    }
+
+    // Branch and bound TSP
+    public static void solveLCBB_TSP(double[][] costMatrix, Hole[] holes) {
+        int n = costMatrix.length;
+
+        double[][] initialMat = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            System.arraycopy(costMatrix[i], 0, initialMat[i], 0, n);
+        }
+
+        double rootCost = reduceMatrix(initialMat, n);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        int[] rootPath = {0};
+        pq.add(new Node(initialMat, rootPath, 1, rootCost, 0));
+
+        double bestCost = INF;
+        int[] bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+
+            if (curr.cost >= bestCost) {
+                continue;
+            }
+
+            if (curr.level == n) {
+                int lastCity = curr.city;
+                if (costMatrix[lastCity][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += costMatrix[curr.path[i]][curr.path[i + 1]];
+                    }
+                    tourCost += costMatrix[lastCity][0];
+
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new int[n + 1];
+                        System.arraycopy(curr.path, 0, bestTour, 0, n);
+                        bestTour[n] = 0;
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+
+            for (int v = 0; v < n; v++) {
+                boolean visited = false;
+                for (int p : curr.path) {
+                    if (p == v) { visited = true; break; }
+                }
+
+                if (!visited && curr.matrix[u][v] < INF) {
+                    double[][] childMat = new double[n][n];
+                    for (int i = 0; i < n; i++) {
+                        System.arraycopy(curr.matrix[i], 0, childMat[i], 0, n);
+                    }
+                    double edgeVal = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) childMat[u][j] = INF;
+                    for (int i = 0; i < n; i++) childMat[i][v] = INF;
+                    if (curr.level < n - 1) {
+                        childMat[v][0] = INF;
+                    }
+
+                    double reduction = reduceMatrix(childMat, n);
+                    double childCost = curr.cost + edgeVal + reduction;
+
+                    if (childCost < bestCost) {
+                        int[] childPath = Arrays.copyOf(curr.path, curr.path.length + 1);
+                        childPath[childPath.length - 1] = v;
+                        pq.add(new Node(childMat, childPath, curr.level + 1, childCost, v));
+                    }
+                }
+            }
+        }
+
+        System.out.printf("%nTotal Drill Head Travel Distance : %.2f mm%n", bestCost);
+        System.out.print("Optimal Drilling Toolpath Sequence : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(holes[bestTour[i]].label);
+                if (i < n) System.out.print(" -> ");
+            }
+        }
+        System.out.println();
+    }
+
+    // Driver code
+    public static void main(String args[]) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 24: CircuitPro PCB CNC Drilling - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        Hole holes[] = {
+            new Hole(0.0,  0.0,  "Home (0,0)"),
+            new Hole(10.0, 45.0, "Hole-1 (10,45)"),
+            new Hole(25.0, 80.0, "Hole-2 (25,80)"),
+            new Hole(60.0, 75.0, "Hole-3 (60,75)"),
+            new Hole(85.0, 30.0, "Hole-4 (85,30)"),
+            new Hole(40.0, 10.0, "Hole-5 (40,10)")
+        };
+
+        int n = holes.length;
+        double costMatrix[][] = new double[n][n];
+
+        for (int i = 0; i < n; i++) {
+            for (int j = 0; j < n; j++) {
+                if (i == j) {
+                    costMatrix[i][j] = INF;
+                } else {
+                    costMatrix[i][j] = Math.hypot(holes[i].x - holes[j].x, holes[i].y - holes[j].y);
+                }
+            }
+        }
+
+        solveLCBB_TSP(costMatrix, holes);
+    }
+}

dancealgorithm/assignments/LC - Flight/Solution.java

@@ -1,152 +1,180 @@
-import java.util.*;
-
-public class Solution {
-    static final double INF = 1e9;
-
-    static class Node implements Comparable<Node> {
-        double[][] matrix;
-        List<Integer> path;
-        double cost;
-        int city, level;
-
-        Node(double[][] m, List<Integer> p, int city, int level, double cost) {
-            this.matrix = copy(m);
-            this.path = new ArrayList<>(p);
-            this.path.add(city);
-            this.city = city;
-            this.level = level;
-            this.cost = cost;
-        }
-
-        public int compareTo(Node o) {
-            return Double.compare(this.cost, o.cost);
-        }
-    }
-
-    static double[][] copy(double[][] m) {
-        double[][] res = new double[m.length][m.length];
-        for (int i = 0; i < m.length; i++) res[i] = m[i].clone();
-        return res;
-    }
-
-    static double reduce(double[][] m) {
-        int n = m.length;
-        double reduction = 0;
-
-        // Row reduction
-        for (int i = 0; i < n; i++) {
-            double min = INF;
-            for (int j = 0; j < n; j++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int j = 0; j < n; j++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-
-        // Column reduction
-        for (int j = 0; j < n; j++) {
-            double min = INF;
-            for (int i = 0; i < n; i++) if (m[i][j] < min) min = m[i][j];
-            if (min > 0 && min < INF) {
-                reduction += min;
-                for (int i = 0; i < n; i++) if (m[i][j] < INF) m[i][j] -= min;
-            }
-        }
-        return reduction;
-    }
-
-    static void solveTSP(double[][] graph, String[] airports) {
-        int n = graph.length;
-        double[][] initial = copy(graph);
-        double rootCost = reduce(initial);
-
-        PriorityQueue<Node> pq = new PriorityQueue<>();
-        pq.add(new Node(initial, new ArrayList<>(), 0, 1, rootCost));
-
-        double bestCost = INF;
-        List<Integer> bestTour = null;
-
-        while (!pq.isEmpty()) {
-            Node curr = pq.poll();
-            if (curr.cost >= bestCost) continue;
-
-            if (curr.level == n) {
-                int last = curr.city;
-                if (graph[last][0] < INF) {
-                    double tourCost = 0;
-                    for (int i = 0; i < n - 1; i++) {
-                        tourCost += graph[curr.path.get(i)][curr.path.get(i + 1)];
-                    }
-                    tourCost += graph[last][0];
-                    if (tourCost < bestCost) {
-                        bestCost = tourCost;
-                        bestTour = new ArrayList<>(curr.path);
-                        bestTour.add(0);
-                    }
-                }
-                continue;
-            }
-
-            int u = curr.city;
-            for (int v = 0; v < n; v++) {
-                if (!curr.path.contains(v) && curr.matrix[u][v] < INF) {
-                    double[][] child = copy(curr.matrix);
-                    double edge = curr.matrix[u][v];
-
-                    for (int j = 0; j < n; j++) child[u][j] = INF;
-                    for (int i = 0; i < n; i++) child[i][v] = INF;
-                    if (curr.level < n - 1) child[v][0] = INF;
-
-                    double childCost = curr.cost + edge + reduce(child);
-                    if (childCost < bestCost) {
-                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
-                    }
-                }
-            }
-        }
-
-        if (bestTour == null) {
-            System.out.println("\nNo complete round-trip flight route exists.");
-            return;
-        }
-
-        System.out.printf("\nMinimum Total Aircraft Operational Cost: Rs. %.2f Lakhs\n", bestCost);
-        System.out.print("Optimal Flight Tour: ");
-        for (int i = 0; i < bestTour.size(); i++) {
-            System.out.print(airports[bestTour.get(i)] + (i < bestTour.size() - 1 ? " -> " : "\n"));
-        }
-    }
-
-    public static void main(String[] args) {
-        Scanner sc = new Scanner(System.in);
-
-        System.out.print("Enter number of airports: ");
-        int n = sc.nextInt();
-        sc.nextLine();
-
-        String[] airports = new String[n];
-        for (int i = 0; i < n; i++) {
-            System.out.print("Enter airport " + (i + 1) + ": ");
-            airports[i] = sc.nextLine().trim();
-        }
-
-        double[][] graph = new double[n][n];
-        System.out.println("\nEnter flight operational cost matrix:");
-        System.out.println("Enter -1 if no direct flight exists.");
-
-        for (int i = 0; i < n; i++) {
-            for (int j = 0; j < n; j++) {
-                if (i == j) {
-                    graph[i][j] = INF;
-                } else {
-                    System.out.print("Cost from " + airports[i] + " to " + airports[j] + ": ");
-                    double val = sc.nextDouble();
-                    graph[i][j] = (val == -1) ? INF : val;
-                }
-            }
-        }
-
-        solveTSP(graph, airports);
-        sc.close();
-    }
-}
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+// Main solution
+public class Solution {
+    // O(n! * n^2)
+    static final double INF = 1e9;
+
+    // Search node
+    static class Node implements Comparable<Node> {
+        double[][] matrix;
+        int[] path;
+        int level;
+        double cost;
+        int city;
+
+        Node(double[][] mat, int[] path, int level, double cost, int city) {
+            int n = mat.length;
+            this.matrix = new double[n][n];
+            for (int i = 0; i < n; i++) {
+                System.arraycopy(mat[i], 0, this.matrix[i], 0, n);
+            }
+            this.path = Arrays.copyOf(path, path.length);
+            this.level = level;
+            this.cost = cost;
+            this.city = city;
+        }
+
+        @Override
+        public int compareTo(Node other) {
+            return Double.compare(this.cost, other.cost);
+        }
+    }
+
+    // Matrix reduction
+    public static double reduceMatrix(double[][] mat, int n) {
+        double reduction = 0;
+
+        for (int i = 0; i < n; i++) {
+            double rmin = INF;
+            for (int j = 0; j < n; j++) {
+                if (mat[i][j] < rmin) rmin = mat[i][j];
+            }
+            if (rmin > 0 && rmin < INF) {
+                reduction += rmin;
+                for (int j = 0; j < n; j++) {
+                    if (mat[i][j] < INF) mat[i][j] -= rmin;
+                }
+            }
+        }
+
+        for (int j = 0; j < n; j++) {
+            double cmin = INF;
+            for (int i = 0; i < n; i++) {
+                if (mat[i][j] < cmin) cmin = mat[i][j];
+            }
+            if (cmin > 0 && cmin < INF) {
+                reduction += cmin;
+                for (int i = 0; i < n; i++) {
+                    if (mat[i][j] < INF) mat[i][j] -= cmin;
+                }
+            }
+        }
+
+        return reduction;
+    }
+
+    // Branch and bound TSP
+    public static void solveLCBB_TSP(double[][] costMatrix, String[] airports) {
+        int n = costMatrix.length;
+
+        double[][] initialMat = new double[n][n];
+        for (int i = 0; i < n; i++) {
+            System.arraycopy(costMatrix[i], 0, initialMat[i], 0, n);
+        }
+
+        double rootCost = reduceMatrix(initialMat, n);
+
+        PriorityQueue<Node> pq = new PriorityQueue<>();
+        int[] rootPath = {0};
+        pq.add(new Node(initialMat, rootPath, 1, rootCost, 0));
+
+        double bestCost = INF;
+        int[] bestTour = null;
+
+        while (!pq.isEmpty()) {
+            Node curr = pq.poll();
+
+            if (curr.cost >= bestCost) {
+                continue;
+            }
+
+            if (curr.level == n) {
+                int lastCity = curr.city;
+                if (costMatrix[lastCity][0] < INF) {
+                    double tourCost = 0;
+                    for (int i = 0; i < n - 1; i++) {
+                        tourCost += costMatrix[curr.path[i]][curr.path[i + 1]];
+                    }
+                    tourCost += costMatrix[lastCity][0];
+
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new int[n + 1];
+                        System.arraycopy(curr.path, 0, bestTour, 0, n);
+                        bestTour[n] = 0;
+                    }
+                }
+                continue;
+            }
+
+            int u = curr.city;
+
+            for (int v = 0; v < n; v++) {
+                boolean visited = false;
+                for (int p : curr.path) {
+                    if (p == v) { visited = true; break; }
+                }
+
+                if (!visited && curr.matrix[u][v] < INF) {
+                    double[][] childMat = new double[n][n];
+                    for (int i = 0; i < n; i++) {
+                        System.arraycopy(curr.matrix[i], 0, childMat[i], 0, n);
+                    }
+                    double edgeVal = curr.matrix[u][v];
+
+                    for (int j = 0; j < n; j++) childMat[u][j] = INF;
+                    for (int i = 0; i < n; i++) childMat[i][v] = INF;
+                    if (curr.level < n - 1) {
+                        childMat[v][0] = INF;
+                    }
+
+                    double reduction = reduceMatrix(childMat, n);
+                    double childCost = curr.cost + edgeVal + reduction;
+
+                    if (childCost < bestCost) {
+                        int[] childPath = Arrays.copyOf(curr.path, curr.path.length + 1);
+                        childPath[childPath.length - 1] = v;
+                        pq.add(new Node(childMat, childPath, curr.level + 1, childCost, v));
+                    }
+                }
+            }
+        }
+
+        System.out.printf("%nTotal Operational Aircraft Fuel & Gate Cost: Rs. %.2f (Lakhs)%n", bestCost);
+        System.out.print("Optimal Aircraft Tour Circuit              : ");
+        if (bestTour != null) {
+            for (int i = 0; i <= n; i++) {
+                System.out.print(airports[bestTour[i]]);
+                if (i < n) System.out.print(" -> ");
+            }
+        }
+        System.out.println();
+    }
+
+    // Driver code
+    public static void main(String args[]) {
+        System.out.println("=======================================================================");
+        System.out.println("PS 23: AeroConnect Aircraft Circuit Tour - LC Branch & Bound (Java)");
+        System.out.println("=======================================================================");
+
+        String airports[] = {
+            "Delhi (DL)",
+            "Mumbai (MH)",
+            "Pune (MH)",
+            "Ahmedabad (GJ)",
+            "Bengaluru (KA)"
+        };
+
+        double costMatrix[][] = {
+            {INF, 12, 29, 45, 38},
+            {14, INF, 19, 36, 42},
+            {30, 21, INF, 18, 55},
+            {48, 38, 17, INF, 50},
+            {39, 40, 52, 49, INF}
+        };
+
+        solveLCBB_TSP(costMatrix, airports);
+    }
+}

dancealgorithm/downloader.py

@@ -15,7 +15,7 @@ import zipfile
 from pathlib import Path
 from typing import Dict, List, Optional, Tuple
 
-USER_AGENT = "DanceAlgorithm-CLI/0.1.3"
+USER_AGENT = "DanceAlgorithm-CLI/0.1.4"
 MAX_ARCHIVE_SIZE_BYTES = 300 * 1024 * 1024  # 300 MB limit
 MAX_FILE_COUNT = 10000                      # 10,000 files limit
 

{dancealgorithm-0.1.3.dist-info → dancealgorithm-0.1.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dancealgorithm
-Version: 0.1.3
+Version: 0.1.4
 Summary: DanceAlgorithm: Instant DAA Algorithms, Lab Problem Sheets, Datasets, and Code Vault.
 Author: DanceAlgorithm Maintainer
 License-Expression: MIT

{dancealgorithm-0.1.3.dist-info → dancealgorithm-0.1.4.dist-info}/RECORD

@@ -1,8 +1,8 @@
-dancealgorithm/__init__.py,sha256=-Ab304-q9HMimR-_dcbOqZOdwhf2Dnf6G8AqjvHsPpw,4102
+dancealgorithm/__init__.py,sha256=Y-KLgv0bCO4WA5Q_Zr5W6xzbvCWHgBIIf8OOcQn6TVk,4102
 dancealgorithm/__main__.py,sha256=o7NdtuZ8z0YCl_VHH-K-ScUaLzsEF-aJvBhEE83e_bA,147
 dancealgorithm/cli.py,sha256=c8iLHbPfxXj7nByjj6S07rPP87nJZHjcWKBITOBRkKY,11400
 dancealgorithm/config.py,sha256=DkKqK5KzWarrffRgOBXNMcP-6WO0plH7sWgRtJ_Clog,3469
-dancealgorithm/downloader.py,sha256=g0GJ2YvKUttHoxWGmSOTcajD5RuD8CtO4vbt3w-M5NI,10914
+dancealgorithm/downloader.py,sha256=kQUS0YTgv7g3TdB1TWTdFtnWzO8p51C6-Y3QlCBZiH0,10914
 dancealgorithm/assignments/DA.txt,sha256=ApbF0CgOHjkxpu1U3mz9eKAFmms4YQTCIXSCI0tmGHY,821
 dancealgorithm/assignments/FK.txt,sha256=jkYwT6a9kHoLBGlqY49johxZ5nZ7hFvLB4rhO5Ta6Yc,677
 dancealgorithm/assignments/GC.txt,sha256=QYL1Bo4oZC1btUjj7tZJi-Toh3uDE9klzYJGDp9at9g,788
@@ -36,11 +36,11 @@ dancealgorithm/assignments/K - Disaster/Solution.java,sha256=MEtGgOqiwP9oWPnDszL
 dancealgorithm/assignments/K - Disaster/__init__.py,sha256=yMf72b6rZmC_KytRvo3lRT7blYagOS6Owi6COLTlGfA,1244
 dancealgorithm/assignments/K - Hospital/Solution.java,sha256=LrvcnmmErFjBs6y29e42JsIuu4JnZElFP3s-fTaAy7o,3737
 dancealgorithm/assignments/K - Hospital/__init__.py,sha256=zLAICmZYB3VbovKbQYNCfn-n59HcGeeLYneXpEu_NYA,1244
-dancealgorithm/assignments/LC - Delivery/Solution.java,sha256=qfWcV0uSTR29clF9Dd3B3H293wJK7tyNpqfd4WU-8rM,5046
+dancealgorithm/assignments/LC - Delivery/Solution.java,sha256=179RRi8_wJLsVi1YjkrOeA2dnzrJILvSfi-1Vil_5qA,6080
 dancealgorithm/assignments/LC - Delivery/__init__.py,sha256=mG6F5WJxD_6CpQxdvuz6ktkQdyefcHiioBf8sVFNnwc,1245
-dancealgorithm/assignments/LC - Drilling/Solution.java,sha256=8Tg973jHIay0vOF4jargR9JreoaFfWzsU-75ZOLvXYc,5314
+dancealgorithm/assignments/LC - Drilling/Solution.java,sha256=H6u8IsYGBXwJbk0IduW2Tya6XGeuCyGPqTgwWNW2vkg,6609
 dancealgorithm/assignments/LC - Drilling/__init__.py,sha256=m6h04f3RWoA4Bwp7V91s-B_pKtVdVbKdQ_wuNCjLCwM,1245
-dancealgorithm/assignments/LC - Flight/Solution.java,sha256=9bNOvZYzD3qPFl1lYbabIiloSUjDt3N74_V1RgwvFRA,5066
+dancealgorithm/assignments/LC - Flight/Solution.java,sha256=xVKAGAALyPWNsAN3jbW73sfvrfyuw20ppq4QOW9tpuQ,6067
 dancealgorithm/assignments/LC - Flight/__init__.py,sha256=7mrQt2JC3WcswbLrKSComS5uKgkAwPHSAPR3A7qX6jQ,1243
 dancealgorithm/assignments/MS - Commerce/Solution.java,sha256=KZlxjeT0Zw1I06SnfsEfM5GJ-HFs8j4y5Nuoe5YaMmw,4457
 dancealgorithm/assignments/MS - Commerce/__init__.py,sha256=zUTiYHn2ZC1xr5yvpgdYob5Fkj8_5pYbauC-56UZhkw,1245
@@ -66,9 +66,9 @@ dancealgorithm/assignments/QS - Movie/dataset.csv,sha256=rsnfsXCCQWrRfNEB_lUdNWi
 dancealgorithm/assignments/QS - Online/Solution.java,sha256=A8bALrw4QDgazRTUKpYZ1nBr1rVXezoFWjnvSQKHk_I,3747
 dancealgorithm/assignments/QS - Online/__init__.py,sha256=6HfCKL8PWcjMerKOJDq6qUglHp5XmvlF-x-YXpRaBfQ,1243
 dancealgorithm/assignments/QS - Online/dataset.csv,sha256=jLrUusfK5fqLRT9ZmJKZPDZ5s2Zw94JixGrKJGoGHNc,631
-dancealgorithm-0.1.3.dist-info/licenses/LICENSE,sha256=eE9Hj40DYTIwVR4OoOhSuK0sijGtFXOK9_atK1Lz6-A,1083
-dancealgorithm-0.1.3.dist-info/METADATA,sha256=b7xMljFTUDeK9Jfjwsx1jt_VdRgFCfQeRiHEKgcTHnk,6736
-dancealgorithm-0.1.3.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-dancealgorithm-0.1.3.dist-info/entry_points.txt,sha256=y31VtV8oOHRSQbU5bVTxqQndGGOyRCOaK_Cmd9bUcyI,91
-dancealgorithm-0.1.3.dist-info/top_level.txt,sha256=gst6Jq05KzE4EKbhCzRDSKtchmLdmeYDIqlqry342lM,15
-dancealgorithm-0.1.3.dist-info/RECORD,,
+dancealgorithm-0.1.4.dist-info/licenses/LICENSE,sha256=eE9Hj40DYTIwVR4OoOhSuK0sijGtFXOK9_atK1Lz6-A,1083
+dancealgorithm-0.1.4.dist-info/METADATA,sha256=NpfigU7uCkr3_3d2dPpACSLzkqz3CSkDEsdE1W3JFmU,6736
+dancealgorithm-0.1.4.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
+dancealgorithm-0.1.4.dist-info/entry_points.txt,sha256=y31VtV8oOHRSQbU5bVTxqQndGGOyRCOaK_Cmd9bUcyI,91
+dancealgorithm-0.1.4.dist-info/top_level.txt,sha256=gst6Jq05KzE4EKbhCzRDSKtchmLdmeYDIqlqry342lM,15
+dancealgorithm-0.1.4.dist-info/RECORD,,