dancealgorithm 0.1.2__py3-none-any.whl → 0.1.3__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.3"
 
 # Import bundled assignments registry and sheets
 from dancealgorithm.assignments import ASSIGNMENTS_DIR, REGISTRY, SHEETS

dancealgorithm/assignments/LC - Delivery/Solution.java

@@ -1,261 +1,152 @@
-
 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;
+        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 other) {
-            return Double.compare(this.dCost, other.dCost);
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
         }
     }
 
-    // 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;
+    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;
+    }
 
-                for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                    if (dGraph[iCnt][jCnt] < INF) {
-                        dGraph[iCnt][jCnt] -= dMin;
-                    }
-                }
+    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 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;
-                    }
-                }
+        // 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 dReduction;
+        return reduction;
     }
 
-    // 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);
+    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));
 
-        int iPath[] = { 0 };
-
-        pq.add(new Node(dInitial, iPath, 1, dRootCost, 0));
-
-        double dBestCost = INF;
-        int iBestTour[] = null;
+        double bestCost = INF;
+        List<Integer> bestTour = 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]];
+            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)];
                     }
-
-                    dTourCost += dGraph[iLast][0];
-
-                    if (dTourCost < dBestCost) {
-                        dBestCost = dTourCost;
-                        iBestTour = Arrays.copyOf(curr.iPath, iSize + 1);
-                        iBestTour[iSize] = 0;
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
                     }
                 }
-
                 continue;
             }
 
-            int iU = curr.iCity;
+            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];
 
-            // 9. Generate Child Nodes
-            for (int iV = 0; iV < iSize; iV++) {
-                boolean bVisited = false;
+                    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;
 
-                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));
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
                     }
                 }
             }
         }
 
-        // 10. Display Optimal Tour
-        if (iBestTour == null) {
+        if (bestTour == 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.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"));
+        }
+    }
 
-        for (int iCnt = 0; iCnt <= iSize; iCnt++) {
-            System.out.print(sLocations[iBestTour[iCnt]]);
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
 
-            if (iCnt < iSize) {
-                System.out.print(" -> ");
+        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;
+                }
             }
         }
 
-        System.out.println();
+        solveTSP(graph, locations);
+        sc.close();
     }
 }

dancealgorithm/assignments/LC - Drilling/Solution.java

@@ -1,275 +1,164 @@
-
 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 drilling points (including Home): ");
-        int iSize = sc.nextInt();
-
-        Hole holes[] = new Hole[iSize];
-
-        // 2. Get Hole Coordinates
-        sc.nextLine();
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            System.out.println("\nEnter details for Point " + iCnt);
-
-            System.out.print("Point Name: ");
-            String sName = sc.nextLine();
-
-            System.out.print("X Coordinate: ");
-            double dX = sc.nextDouble();
-
-            System.out.print("Y Coordinate: ");
-            double dY = sc.nextDouble();
-
-            sc.nextLine();
-
-            holes[iCnt] = new Hole(dX, dY, sName);
-        }
-
-        // 3. Create Distance Matrix
-        double dGraph[][] = new double[iSize][iSize];
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                if (iCnt == jCnt) {
-                    dGraph[iCnt][jCnt] = INF;
-                } else {
-                    dGraph[iCnt][jCnt] = Math.hypot(
-                            holes[iCnt].dX - holes[jCnt].dX,
-                            holes[iCnt].dY - holes[jCnt].dY);
-                }
-            }
-        }
-
-        // 4. Apply LC Branch and Bound
-        SolveTSP(dGraph, holes);
-
-        sc.close();
-    }
-
-    // 5. Hole Entity
     static class Hole {
-        double dX, dY;
-        String sName;
-
-        Hole(double dX, double dY, String sName) {
-            this.dX = dX;
-            this.dY = dY;
-            this.sName = sName;
+        String name;
+        double x, y;
+        Hole(String name, double x, double y) {
+            this.name = name;
+            this.x = x;
+            this.y = y;
         }
     }
 
-    // 6. 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;
+        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 other) {
-            return Double.compare(this.dCost, other.dCost);
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
         }
     }
 
-    // 7. 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;
+    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;
+    }
 
-                for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                    if (dGraph[iCnt][jCnt] < INF) {
-                        dGraph[iCnt][jCnt] -= dMin;
-                    }
-                }
+    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 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;
-                    }
-                }
+        // 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 dReduction;
+        return reduction;
     }
 
-    // 8. LC Branch and Bound TSP
-    static void SolveTSP(double dGraph[][], Hole holes[]) {
-        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);
+    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));
 
-        int iPath[] = { 0 };
-
-        pq.add(new Node(dInitial, iPath, 1, dRootCost, 0));
-
-        double dBestCost = INF;
-        int iBestTour[] = null;
+        double bestCost = INF;
+        List<Integer> bestTour = null;
 
-        // 9. 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]];
+            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)];
                     }
-
-                    dTourCost += dGraph[iLast][0];
-
-                    if (dTourCost < dBestCost) {
-                        dBestCost = dTourCost;
-                        iBestTour = Arrays.copyOf(curr.iPath, iSize + 1);
-                        iBestTour[iSize] = 0;
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
                     }
                 }
-
                 continue;
             }
 
-            int iU = curr.iCity;
+            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];
 
-            // 10. Generate Child Nodes
-            for (int iV = 0; iV < iSize; iV++) {
-                boolean bVisited = false;
+                    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;
 
-                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));
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
                     }
                 }
             }
         }
 
-        // 11. Display Optimal Drilling Tour
-        if (iBestTour == null) {
+        if (bestTour == null) {
             System.out.println("\nNo complete drilling tour exists.");
             return;
         }
 
-        System.out.printf("\nTotal Drill Head Travel Distance: %.2f mm%n",
-                dBestCost);
-
+        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();
 
-        for (int iCnt = 0; iCnt <= iSize; iCnt++) {
-            System.out.print(holes[iBestTour[iCnt]].sName);
+        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);
+        }
 
-            if (iCnt < iSize) {
-                System.out.print(" -> ");
+        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);
+                }
             }
         }
 
-        System.out.println();
+        solveTSP(graph, holes);
+        sc.close();
     }
 }

dancealgorithm/assignments/LC - Flight/Solution.java

@@ -1,261 +1,152 @@
-
 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 airports: ");
-        int iSize = sc.nextInt();
-
-        String sAirports[] = new String[iSize];
-
-        // 2. Get Airport Names
-        sc.nextLine();
-
-        for (int iCnt = 0; iCnt < iSize; iCnt++) {
-            System.out.print("Enter airport " + (iCnt + 1) + ": ");
-            sAirports[iCnt] = sc.nextLine();
-        }
-
-        // 3. Get Cost Matrix
-        double dGraph[][] = new double[iSize][iSize];
-
-        System.out.println("\nEnter flight operational cost matrix:");
-        System.out.println("Enter -1 if no direct flight exists.");
-
-        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 " + sAirports[iCnt] +
-                            " to " + sAirports[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, sAirports);
-
-        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;
+        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 other) {
-            return Double.compare(this.dCost, other.dCost);
+        public int compareTo(Node o) {
+            return Double.compare(this.cost, o.cost);
         }
     }
 
-    // 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;
+    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;
+    }
 
-                for (int jCnt = 0; jCnt < iSize; jCnt++) {
-                    if (dGraph[iCnt][jCnt] < INF) {
-                        dGraph[iCnt][jCnt] -= dMin;
-                    }
-                }
+    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 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;
-                    }
-                }
+        // 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 dReduction;
+        return reduction;
     }
 
-    // 7. LC Branch and Bound TSP
-    static void SolveTSP(double dGraph[][], String sAirports[]) {
-        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);
+    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));
 
-        int iPath[] = { 0 };
-
-        pq.add(new Node(dInitial, iPath, 1, dRootCost, 0));
-
-        double dBestCost = INF;
-        int iBestTour[] = null;
+        double bestCost = INF;
+        List<Integer> bestTour = 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]];
+            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)];
                     }
-
-                    dTourCost += dGraph[iLast][0];
-
-                    if (dTourCost < dBestCost) {
-                        dBestCost = dTourCost;
-                        iBestTour = Arrays.copyOf(curr.iPath, iSize + 1);
-                        iBestTour[iSize] = 0;
+                    tourCost += graph[last][0];
+                    if (tourCost < bestCost) {
+                        bestCost = tourCost;
+                        bestTour = new ArrayList<>(curr.path);
+                        bestTour.add(0);
                     }
                 }
-
                 continue;
             }
 
-            int iU = curr.iCity;
+            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];
 
-            // 9. Generate Child Nodes
-            for (int iV = 0; iV < iSize; iV++) {
-                boolean bVisited = false;
+                    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;
 
-                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));
+                    double childCost = curr.cost + edge + reduce(child);
+                    if (childCost < bestCost) {
+                        pq.add(new Node(child, curr.path, v, curr.level + 1, childCost));
                     }
                 }
             }
         }
 
-        // 10. Display Optimal Flight Tour
-        if (iBestTour == null) {
+        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",
-                dBestCost);
-
+        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"));
+        }
+    }
 
-        for (int iCnt = 0; iCnt <= iSize; iCnt++) {
-            System.out.print(sAirports[iBestTour[iCnt]]);
+    public static void main(String[] args) {
+        Scanner sc = new Scanner(System.in);
 
-            if (iCnt < iSize) {
-                System.out.print(" -> ");
+        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;
+                }
             }
         }
 
-        System.out.println();
+        solveTSP(graph, airports);
+        sc.close();
     }
 }

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.2"
+USER_AGENT = "DanceAlgorithm-CLI/0.1.3"
 MAX_ARCHIVE_SIZE_BYTES = 300 * 1024 * 1024  # 300 MB limit
 MAX_FILE_COUNT = 10000                      # 10,000 files limit
 

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

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

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

@@ -1,8 +1,8 @@
-dancealgorithm/__init__.py,sha256=5EfM3pGf19Y8wto47xOvv6OVYuRyAN8VNHmMX_vXlxE,4102
+dancealgorithm/__init__.py,sha256=-Ab304-q9HMimR-_dcbOqZOdwhf2Dnf6G8AqjvHsPpw,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=mhCBJegzz1DWK-sq-Yx4hh1-BDKb-SBBMZxzCebyvyo,10914
+dancealgorithm/downloader.py,sha256=g0GJ2YvKUttHoxWGmSOTcajD5RuD8CtO4vbt3w-M5NI,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=alvBruibFkiuJ2e3VE8asZCf8Er-19LQYkhTCaeIi6k,7637
+dancealgorithm/assignments/LC - Delivery/Solution.java,sha256=qfWcV0uSTR29clF9Dd3B3H293wJK7tyNpqfd4WU-8rM,5046
 dancealgorithm/assignments/LC - Delivery/__init__.py,sha256=mG6F5WJxD_6CpQxdvuz6ktkQdyefcHiioBf8sVFNnwc,1245
-dancealgorithm/assignments/LC - Drilling/Solution.java,sha256=pzMQe6V6JyOGx66pdp_-H_SG-1HNHoCqYWR9rnBDpaw,7870
+dancealgorithm/assignments/LC - Drilling/Solution.java,sha256=8Tg973jHIay0vOF4jargR9JreoaFfWzsU-75ZOLvXYc,5314
 dancealgorithm/assignments/LC - Drilling/__init__.py,sha256=m6h04f3RWoA4Bwp7V91s-B_pKtVdVbKdQ_wuNCjLCwM,1245
-dancealgorithm/assignments/LC - Flight/Solution.java,sha256=aQBZXnQvyofhya3NsWonHC28ObaRhLy7zRMgWI3FXNw,7663
+dancealgorithm/assignments/LC - Flight/Solution.java,sha256=9bNOvZYzD3qPFl1lYbabIiloSUjDt3N74_V1RgwvFRA,5066
 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.2.dist-info/licenses/LICENSE,sha256=eE9Hj40DYTIwVR4OoOhSuK0sijGtFXOK9_atK1Lz6-A,1083
-dancealgorithm-0.1.2.dist-info/METADATA,sha256=zOS2jXrbPttDDThkYlhiZiDLmKFdKQA3CKqhh_zWLTw,6736
-dancealgorithm-0.1.2.dist-info/WHEEL,sha256=mOdXR9C3wMVov7cSY8PY-XCzo3SmmWCHvGQr5csJoao,91
-dancealgorithm-0.1.2.dist-info/entry_points.txt,sha256=y31VtV8oOHRSQbU5bVTxqQndGGOyRCOaK_Cmd9bUcyI,91
-dancealgorithm-0.1.2.dist-info/top_level.txt,sha256=gst6Jq05KzE4EKbhCzRDSKtchmLdmeYDIqlqry342lM,15
-dancealgorithm-0.1.2.dist-info/RECORD,,
+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,,