dancealgorithm 0.1.2__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.2"
+__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,261 +1,180 @@
-
-import java.util.*;
-
-public class Solution {
-    static final double INF = 1e9;
-
-    // 1. Main Function
-    public static void main(String args[]) {
-        Scanner sc = new Scanner(System.in);
-
-        System.out.print("Enter number of locations: ");
-        int iSize = sc.nextInt();
-
-        String sLocations[] = new String[iSize];
-
-        // 2. Get Location Names
-        sc.nextLine();
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            System.out.print("Enter location " + (iCnt + 1) + ": ");
-            sLocations[iCnt] = sc.nextLine();
-        }
-
-        // 3. Get Cost Matrix
-        double dGraph[][] = new double[iSize][iSize];
-
-        System.out.println("\nEnter travel cost matrix:");
-        System.out.println("Enter -1 if there is no direct route.");
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                if (iCnt == jCnt) {
-                    dGraph[iCnt][jCnt] = INF;
-                } else {
-                    System.out.print("Cost from " + sLocations[iCnt] +
-                            " to " + sLocations[jCnt] + ": ");
-
-                    double dValue = sc.nextDouble();
-
-                    if (dValue == -1) {
-                        dGraph[iCnt][jCnt] = INF;
-                    } else {
-                        dGraph[iCnt][jCnt] = dValue;
-                    }
-                }
-            }
-        }
-
-        // 4. Apply LC Branch and Bound
-        SolveTSP(dGraph, sLocations);
-
-        sc.close();
-    }
-
-    // 5. Search Node
-    static class Node implements Comparable<Node> {
-        double dMatrix[][];
-        int iPath[];
-        int iLevel;
-        double dCost;
-        int iCity;
-
-        Node(double dGraph[][], int iPath[],
-                int iLevel, double dCost, int iCity) {
-            int iSize = dGraph.length;
-
-            dMatrix = new double[iSize][iSize];
-
-            for (int iCnt = 0; iCnt < iSize; iCnt++) {
-                System.arraycopy(dGraph[iCnt], 0,
-                        dMatrix[iCnt], 0, iSize);
-            }
-
-            this.iPath = Arrays.copyOf(iPath, iPath.length);
-            this.iLevel = iLevel;
-            this.dCost = dCost;
-            this.iCity = iCity;
-        }
-
-        public int compareTo(Node other) {
-            return Double.compare(this.dCost, other.dCost);
-        }
-    }
-
-    // 6. Reduce Cost Matrix
-    static double ReduceMatrix(double dGraph[][], int iSize) {
-        double dReduction = 0;
-
-        // Row Reduction
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            double dMin = INF;
-
-            for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                if (dGraph[iCnt][jCnt] < dMin) {
-                    dMin = dGraph[iCnt][jCnt];
-                }
-            }
-
-            if (dMin > 0 && dMin < INF) {
-                dReduction += dMin;
-
-                for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                    if (dGraph[iCnt][jCnt] < INF) {
-                        dGraph[iCnt][jCnt] -= dMin;
-                    }
-                }
-            }
-        }
-
-        // Column Reduction
-        for (int jCnt = 0; jCnt < iSize; jCnt++) {
-            double dMin = INF;
-
-            for (int iCnt = 0; iCnt < iSize; iCnt++) {
-                if (dGraph[iCnt][jCnt] < dMin) {
-                    dMin = dGraph[iCnt][jCnt];
-                }
-            }
-
-            if (dMin > 0 && dMin < INF) {
-                dReduction += dMin;
-
-                for (int iCnt = 0; iCnt < iSize; iCnt++) {
-                    if (dGraph[iCnt][jCnt] < INF) {
-                        dGraph[iCnt][jCnt] -= dMin;
-                    }
-                }
-            }
-        }
-
-        return dReduction;
-    }
-
-    // 7. LC Branch and Bound TSP
-    static void SolveTSP(double dGraph[][], String sLocations[]) {
-        int iSize = dGraph.length;
-
-        double dInitial[][] = new double[iSize][iSize];
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            System.arraycopy(dGraph[iCnt], 0,
-                    dInitial[iCnt], 0, iSize);
-        }
-
-        double dRootCost = ReduceMatrix(dInitial, iSize);
-
-        PriorityQueue<Node> pq = new PriorityQueue<>();
-
-        int iPath[] = { 0 };
-
-        pq.add(new Node(dInitial, iPath, 1, dRootCost, 0));
-
-        double dBestCost = INF;
-        int iBestTour[] = null;
-
-        // 8. Search for Minimum Cost Tour
-        while (!pq.isEmpty()) {
-            Node curr = pq.poll();
-
-            if (curr.dCost >= dBestCost) {
-                continue;
-            }
-
-            if (curr.iLevel == iSize) {
-                int iLast = curr.iCity;
-
-                if (dGraph[iLast][0] < INF) {
-                    double dTourCost = 0;
-
-                    for (int iCnt = 0; iCnt < iSize - 1; iCnt++) {
-                        dTourCost += dGraph[curr.iPath[iCnt]][curr.iPath[iCnt + 1]];
-                    }
-
-                    dTourCost += dGraph[iLast][0];
-
-                    if (dTourCost < dBestCost) {
-                        dBestCost = dTourCost;
-                        iBestTour = Arrays.copyOf(curr.iPath, iSize + 1);
-                        iBestTour[iSize] = 0;
-                    }
-                }
-
-                continue;
-            }
-
-            int iU = curr.iCity;
-
-            // 9. Generate Child Nodes
-            for (int iV = 0; iV < iSize; iV++) {
-                boolean bVisited = false;
-
-                for (int iCnt = 0; iCnt < curr.iPath.length; iCnt++) {
-                    if (curr.iPath[iCnt] == iV) {
-                        bVisited = true;
-                        break;
-                    }
-                }
-
-                if (!bVisited && curr.dMatrix[iU][iV] < INF) {
-                    double dChild[][] = new double[iSize][iSize];
-
-                    for (int iCnt = 0; iCnt < iSize; iCnt++) {
-                        System.arraycopy(curr.dMatrix[iCnt], 0,
-                                dChild[iCnt], 0, iSize);
-                    }
-
-                    double dEdge = curr.dMatrix[iU][iV];
-
-                    for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                        dChild[iU][jCnt] = INF;
-                    }
-
-                    for (int iCnt = 0; iCnt < iSize; iCnt++) {
-                        dChild[iCnt][iV] = INF;
-                    }
-
-                    if (curr.iLevel < iSize - 1) {
-                        dChild[iV][0] = INF;
-                    }
-
-                    double dReduction = ReduceMatrix(dChild, iSize);
-
-                    double dChildCost = curr.dCost +
-                            dEdge + dReduction;
-
-                    if (dChildCost < dBestCost) {
-                        int iChildPath[] = Arrays.copyOf(
-                                curr.iPath, curr.iPath.length + 1);
-
-                        iChildPath[iChildPath.length - 1] = iV;
-
-                        pq.add(new Node(dChild, iChildPath,
-                                curr.iLevel + 1,
-                                dChildCost, iV));
-                    }
-                }
-            }
-        }
-
-        // 10. Display Optimal Tour
-        if (iBestTour == null) {
-            System.out.println("\nNo complete round-trip route exists.");
-            return;
-        }
-
-        System.out.printf("\nOptimal Round-Trip Delivery Cost: Rs. %.2f%n",
-                dBestCost);
-
-        System.out.print("Optimal Delivery Tour: ");
-
-        for (int iCnt = 0; iCnt <= iSize; iCnt++) {
-            System.out.print(sLocations[iBestTour[iCnt]]);
-
-            if (iCnt < iSize) {
-                System.out.print(" -> ");
-            }
-        }
-
-        System.out.println();
-    }
-}
+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);
+    }
+}