Assignment 10: mst init

10-labMST/.gitignore

@@ -0,0 +1,105 @@
+### Intellij template
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### Java template
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+replay_pid*
+

10-labMST/.idea/.gitignore

@@ -0,0 +1,10 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Environment-dependent path to Maven home directory
+/mavenHomeManager.xml
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

10-labMST/Assignment.java

@@ -0,0 +1,114 @@
+package labMST;
+
+import java.io.*;
+import java.util.*;
+
+public class Assignment {
+
+    static class Graph {
+        private int n; // No. of vertices
+        private List<List<Integer>> adj; // An array of adjacency lists
+        private Map<String, Integer> weightMap;
+
+        public Graph(int n) {
+            this.n = n;
+            this.adj = new ArrayList<>(n);
+            for (int i = 0; i < n; i++) {
+                this.adj.add(new LinkedList<>());
+            }
+            this.weightMap = new HashMap<>();
+        }
+
+        public void addEdge(int u, int v) {
+            this.adj.get(u).add(v);
+        }
+
+        public void addEdgeWeight(int u, int v, int w) {
+            String e = u + "," + v;
+            this.weightMap.put(e, w);
+        }
+
+        public int getWeight(int u, int v) {
+            String e = u + "," + v;
+            return this.weightMap.get(e);
+        }
+
+        public List<Integer> getAdjacent(int u) {
+            return this.adj.get(u);
+        }
+
+        public int getLength() {
+            return this.n;
+        }
+
+        public void show() {
+            for (int v = 0; v < n; v++) {
+                System.out.print(v + ":");
+                for (int i : this.adj.get(v)) {
+                    System.out.print(i + ";");
+                }
+                System.out.println();
+            }
+        }
+    }
+
+    static class QNode {
+        int id;
+        int key;
+        boolean isValid;
+        int pi;
+
+        public QNode() {
+            id = -1;
+            key = -1;
+            isValid = true;
+            pi = -1;
+        }
+    }
+
+    // Implement Prim's Algorithm for finding the Minimum Spanning Tree.
+    // Return the QNode for each vertex in the graph, indicating the parent (pi)
+    // of every vertex in the resulting tree. Other fields of QNode are optional
+    // but may be useful in your implementation.
+    public static List<QNode> Prim(Graph g) {
+        return new ArrayList<QNode>(Collections.nCopies(g.getLength(), new QNode()));
+    }
+
+    public static void run(String inputPath) {
+        try (BufferedReader br = new BufferedReader(new FileReader(inputPath))) {
+
+            // Read graph
+            // n is # of nodes. nodes are indexed by 0, 1, 2, ..., n -1
+            int n = Integer.parseInt(br.readLine().trim());
+
+            // # of edges.
+            int m = Integer.parseInt(br.readLine().trim());
+
+            // Build the graph based on the edges on remaining input lines
+            Graph g = new Graph(n);
+            for (int i = 0; i < m; i++) {
+                String[] parts = br.readLine().trim().split(" ");
+                int s = Integer.parseInt(parts[0]);
+                int t = Integer.parseInt(parts[1]);
+                g.addEdge(s, t);
+                int w = Integer.parseInt(parts[2]);
+                g.addEdgeWeight(s, t, w);
+                g.addEdge(t, s);
+                g.addEdgeWeight(t, s, w);
+            }
+
+            // Your implementation must return a list of QNode. One QNode for
+            // each vertex, in the order 0, 1, 2, ..., n-1
+            List<QNode> pQNode = Prim(g);
+
+            // The correctness of your implementation will be judged by printing
+            // the parent of each vertex, line by line
+            for (int i = 1; i < n; i++) {
+                System.out.println(pQNode.get(i).pi);
+            }
+
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+    }
+}

10-labMST/TestAll.java

@@ -0,0 +1,103 @@
+package labMST;
+
+import java.io.File;
+import java.net.URL;
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.PrintStream;
+import java.io.ByteArrayOutputStream;
+
+public class TestAll {
+    public static void main(String[] args) {
+        processInputFiles();
+    }
+
+    public static void processInputFiles() {
+        try {
+            // Get the inputs and outputs directories
+            URL input_url = TestAll.class.getResource("inputs");
+            URL output_url = TestAll.class.getResource("outputs");
+            if (input_url == null) {
+                System.out.println("Cannot find folder \"inputs\"");
+                return;
+            }
+            if (output_url == null) {
+                System.out.println("Cannot find folder \"outputs\"");
+                return;
+            }
+
+            // Get the names of all the files in either directory
+            File input_folder = new File(input_url.getPath());
+            File[] input_files = input_folder.listFiles();
+            File output_folder = new File(output_url.getPath());
+            if (input_files == null) {
+                System.out.printf("No files in folder: %s\n", input_folder.getPath());
+                return;
+            }
+            // No need to check if output files exist, can still run inputs
+
+            // Capture the print statements from the assignment into printstream
+            ByteArrayOutputStream captured_bytestream = new ByteArrayOutputStream();
+            PrintStream captured_printstream = new PrintStream(captured_bytestream);
+            // Replace System.out with a local variable to capture prints
+            PrintStream stdout = System.out;
+            System.setOut(captured_printstream);
+            Integer total_tests = 0, passed_tests = 0;
+
+            for (File input_file : input_files) {
+                if (!input_file.isFile()) {
+                    continue;
+                }
+                // Print which test is currently being run
+                stdout.println("Processing file: " + input_file.getName());
+                // Run the assignment on this input file
+                Assignment.run(input_file.getAbsolutePath());
+                // Ensure all the output from assignment goes to local variable
+                System.out.flush();
+                // Get the output from assignment into a String
+                String assignment_output = captured_bytestream.toString();
+                captured_bytestream.reset();
+                // Get the file contents for comparison
+                File output_file = new File(output_folder, input_file.getName());
+                // Check if a corresponding output file exists
+                if (!output_file.exists()) {
+                    // Print the output to the console without grading
+                    stdout.println("No corresponding output, result shown:");
+                    stdout.println(assignment_output);
+                    continue;
+                }
+                // Read the contents of the corresponding output file
+                total_tests++;
+                BufferedReader buffered_reader = new BufferedReader(new FileReader(output_file.getAbsolutePath()));
+                StringBuilder string_builder = new StringBuilder();
+                String line;
+                while ((line = buffered_reader.readLine()) != null) {
+                    string_builder.append(line).append(System.lineSeparator());
+                }
+                buffered_reader.close();
+
+                String correct_output = string_builder.toString();
+                if (assignment_output.equals(correct_output)) {
+                    // This test passes
+                    passed_tests++;
+                    stdout.println("Test Pass");
+                } else {
+                    // This test does not pass
+                    stdout.println("Test Fail:");
+                    stdout.println("Expected:");
+                    stdout.println(correct_output);
+                    stdout.println("Actual:");
+                    stdout.println(assignment_output);
+                }
+
+                // Indicate this test is done
+                stdout.println("=====");
+            }
+            stdout.printf("Result: %d/%d Tests Passed\n", passed_tests, total_tests);
+            System.setOut(stdout);
+
+        } catch (Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

10-labMST/inputs/test01.txt

@@ -0,0 +1,16 @@
+9
+14
+0 1 40
+0 7 85
+1 2 80
+1 7 110
+2 3 70
+2 5 45
+2 8 22
+3 4 90
+3 5 140
+4 5 100
+5 6 25
+6 7 10
+6 8 60
+7 8 75

10-labMST/inputs/test02.txt

@@ -0,0 +1,16 @@
+9
+14
+0 1 13
+0 7 6
+1 2 1
+1 7 12
+2 3 10
+2 5 5
+2 8 7
+3 4 4
+3 5 11
+4 5 3
+5 6 2
+6 7 8
+6 8 14
+7 8 9

10-labMST/inputs/test03.txt

@@ -0,0 +1,16 @@
+9
+14
+0 1 13
+0 7 6
+1 2 25
+1 7 12
+2 3 10
+2 5 5
+2 8 77
+3 4 4
+3 5 19
+4 5 3
+5 6 2
+6 7 8
+6 8 14
+7 8 9

10-labMST/inputs/test04.txt

@@ -0,0 +1,17 @@
+9
+15
+0 1 13
+0 7 6
+1 2 8
+1 7 12
+2 3 10
+2 5 5
+2 8 7
+3 4 4
+3 5 11
+3 7 20
+4 5 3
+5 6 2
+6 7 1
+6 8 14
+7 8 9

10-labMST/inputs/test05.txt

@@ -0,0 +1,17 @@
+9
+15
+0 1 13
+0 7 6
+1 2 8
+1 7 12
+2 3 10
+2 5 5
+2 8 7
+3 4 4
+3 5 11
+3 7 20
+4 5 3
+5 6 29
+6 7 31
+6 8 14
+7 8 9

10-labMST/outputs/test01.txt

@@ -0,0 +1,8 @@
+0
+1
+2
+3
+2
+5
+6
+2

10-labMST/outputs/test02.txt

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

10-labMST/outputs/test03.txt

@@ -0,0 +1,8 @@
+7
+5
+4
+5
+6
+7
+0
+7

10-labMST/outputs/test04.txt

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

10-labMST/outputs/test05.txt

@@ -0,0 +1,8 @@
+2
+8
+4
+5
+2
+8
+0
+7