\n\n\n## Credits\n\nThanks to Peter Korgan for Maven and Gradle support.\n"
},
{
"path": "USING-MAVEN.md",
"content": "This file provides brief instructions on how to add this repository to\na Maven build, from Eclipse, NetBeans, IntelliJ, or the command line.\nSpecifically, it provides instructions on creating a version of algs4.jar\nthat you can use as a dependency in your projects.\n\nThese instructions assume that you already have installed Java 7\n(JDK 1.7) or above.\n\n\nUsing Maven in Eclipse for Java Developers\n------------------------------------------\nIf m2e (Maven plugin) is not built into Eclipse, follow these steps to install the plugin:\n\n * Open Eclipse.\n * Go to Help -> Eclipse Marketplace.\n * Search for Maven.\n * Click \"Install\" button at \"Maven Integration for Eclipse\" or \"m2e\" section.\n * Follow the instruction step by step.,\n\nRestart Eclipse after installing m2e.\n\nNow you can import algs4 as \"Maven Project\" into Eclipse:\n\n * Open menu: File-> Import-> Maven-> Existing Maven Projects...\n * Choose directory of algs4.\n * Confirm import.\n\nTo complete dependencies resolution after import:\n * Right click on the project, choose Maven -> Update Project...\n * Confirm project update.\n\nTo build project in Eclipse:\nEclipse automatically builds the project every time it saved.\nBut if you want enforce build, do following:\n * Right click on the project in Eclipse.\n * Choose Run as... Maven build.\n\nMaven will put algs4-.jar in the directory /target.\nYou can use this jar as a dependency in your projects.\n\n\nUsing Maven in IntelliJ IDEA\n----------------------------\nImport algs4 as \"Maven Project\" into IntelliJ IDEA:\n\n1. Open menu: File -> New -> Module from Existing Sources...\n2. Choose directory of algs4.\n3. Choose Import module from external model - Maven.\n4. Finish.\n\nLast, edit `pom.xml` to add dependency:\n```xml\n\n edu.princeton.cs\n algs4\n 1.0.0.0\n\n```\n\nUsing Maven in Netbeans\n-----------------------\n\n\nUsing Maven from the Windows Command Prompt\n-------------------------------------------\nDownload and install Maven by following the instructions at\nhttps://maven.apache.org.\n\nLocate the installation directory for Maven, e.g., C:\\\n\nLocate the installation directory for Java, e.g., C:\\Program Files\\Java\\\n\nSet the following environment variables:\n\nset JAVA_HOME=C:\\Program Files\\Java\\\nset PATH=%JAVA_HOME%\\bin;%PATH%\nset M2_HOME=C:\\\nset PATH=%M2_HOME%\\bin;%PATH%\n\nTo create the algs4-.jar package and install it in the local\nrepository for reuse from other projects, change to the directory of\nthe algs4 repository and run Maven.\n\ncd \nmvn clean install\n\nMaven will put algs4-.jar in the directory /target.\nYou can use this jar as a dependency in your projects.\n\n\n\nUsing Maven from the Linux / Mac OS X bash shell\n------------------------------------------------\nDownload and install Maven, either by using your favorite package\nmanager (such as apt-get) or by following the instructions at\nhttps://maven.apache.org.\n\nLocate the installation directory for Maven, e.g., /my/maven/\n\nLocate the installation directory for Java, e.g., /my/java/\n\nSet the following environment variables:\n\nexport JAVA_HOME=/my/java/\nexport PATH=$JAVA_HOME/bin:$PATH\nexport M2_HOME=/my/maven/\nexport PATH=$M2_HOME/bin:$PATH\n\nTo create the algs4-.jar package and install it in the local\nrepository for reuse from other projects, change to the directory of\nthe algs4 repository and run Maven.\n\ncd \nmvn clean install\n\nMaven will put algs4-.jar in the directory /target.\nYou can use this jar as a dependency in your projects.\n\n"
},
{
"path": "build.gradle",
"content": "buildscript {\n repositories {\n jcenter()\n }\n}\n\nplugins {\n id \"com.jfrog.bintray\" version \"1.7\"\n}\n\ngroup = 'edu.princeton.cs'\nversion = '1.0.1'\n\n\nallprojects {\n repositories {\n jcenter()\n }\n apply plugin: 'java'\n apply plugin: 'eclipse'\n apply plugin: 'idea'\n apply plugin: 'maven-publish'\n\n sourceCompatibility = 1.7\n targetCompatibility = 1.7\n}\n\ntask sourcesJar(type: Jar, dependsOn:classes) {\n classifier = 'sources'\n from sourceSets.main.allSource\n}\n\ntask javadocJar(type: Jar) {\n classifier = 'javadoc'\n from javadoc.destinationDir\n}\n\nartifacts {\n archives sourcesJar\n archives javadocJar\n}\n\npublishing {\n publications {\n MyPublication(MavenPublication) {\n from components.java\n artifact sourcesJar\n artifact javadocJar\n groupId 'edu.princeton.cs'\n artifactId 'algs4'\n version '1.0.2'\n }\n }\n}\n\nbintray {\n user = project.hasProperty('bintrayUser') ? project.property('bintrayUser') : System.getenv('BINTRAY_USER')\n key = project.hasProperty('bintrayApiKey') ? project.property('bintrayApiKey') : System.getenv('BINTRAY_API_KEY')\n publications = ['MyPublication']\n publish = true\n override = false\n pkg {\n repo = 'maven'\n name = 'algs4'\n userOrg = 'algs4'\n desc = 'Source Code for Algorithms, 4th Edition'\n licenses = ['GPL-3.0']\n vcsUrl = 'https://github.com/kevin-wayne/algs4.git'\n websiteUrl = 'https://github.com/kevin-wayne/algs4'\n labels = ['algorithms', 'java', 'Robert Sedgewick', 'Kevin Wayne']\n publicDownloadNumbers = true\n githubRepo = 'kevin-wayne/algs4'\n githubReleaseNotesFile = 'README.md'\n version {\n name = '1.0.2'\n vcsTag = '1.0.2'\n }\n }\n}\n\nwrapper {\n gradleVersion = '2.6'\n}"
},
{
"path": "pom.xml",
"content": "\n\n\t4.0.0\n\tedu.princeton.cs\n\talgs4\n\tjar\n\t1.0.0.0\n\talgs4\n\t\n\t\t\n\t\t\tGNU GENERAL PUBLIC LICENSE\n\t\t\thttp://www.gnu.org/licenses/gpl-3.0.en.html\n\t\t\n\t\n\t\n\t\t\n\t\t\tkevin\n\t\t\tKevin Wayne\n\t\t\twayne@CS.Princeton.EDU\n\t\t\thttps://www.cs.princeton.edu/~wayne/contact/\n\t\t\tPrinceton University \n\t\t\thttps://www.cs.princeton.edu\n\t\t\t\n\t\t\t\tauthor\n\t\t\t\tdeveloper\n\t\t\t\n\t\t\tUTC/GMT -4:00 hours\n\t\t\t\n\t\t\t\thttps://www.cs.princeton.edu/~wayne/contact/KevinWayne.jpg\n\t\t\t\n\t\t\n\t\t\n\t\t\trobert\n\t\t\tRobert Sedgewick\n\t\t\t\n\t\t\t\tauthor\n\t\t\t\n\t\t\n\t\n\t\n\t\tgithub.com\n\t\thttps://github.com/kevin-wayne/algs4/issues\n\t\n\t\n\t\t\n\t\t\tmain-build\n\t\t\t\t\n\t\t\t\t\ttrue\n\t\t\t\t\n\t\t\t\n\t\t\t\tUTF-8\n\t\t\t\t1.8\n\t\t\t\n\t\t\t\n\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\torg.apache.maven.plugins\n\t\t\t\t\t\tmaven-compiler-plugin\n\t\t\t\t\t\t3.3\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t${java.version}\n\t\t\t\t\t\t\t${java.version}\n\t\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\t\torg.apache.maven.plugins\n\t\t\t\t\t\tmaven-source-plugin\n\t\t\t\t\t\t3.0.1\n\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\tattach-sources\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\t\tjar\n\t\t\t\t\t\t\t\t\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\n\t\t\t\t\t\n\t\t\t\t\n\t\t\t\n\t\t\t\n\t\t\t\n\t\t\n\t\n\t\n\t \n\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AVLTreeST.java",
"content": "/******************************************************************************\n * Compilation: javac AVLTreeST.java\n * Execution: java AVLTreeST < input.txt\n * Dependencies: StdIn.java StdOut.java \n * Data files: https://algs4.cs.princeton.edu/33balanced/tinyST.txt \n * \n * A symbol table implemented using an AVL tree.\n *\n * % more tinyST.txt\n * S E A R C H E X A M P L E\n * \n * % java AVLTreeST < tinyST.txt\n * A 8\n * C 4\n * E 12\n * H 5\n * L 11\n * M 9\n * P 10\n * R 3\n * S 0\n * X 7\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code AVLTreeST} class represents an ordered symbol table of\n * generic key-value pairs. It supports the usual put, get,\n * contains, delete, size, and is-empty\n * methods. It also provides ordered methods for finding the minimum,\n * maximum, floor, and ceiling. It also provides a\n * keys method for iterating over all of the keys. A symbol table\n * implements the associative array abstraction: when associating a\n * value with a key that is already in the symbol table, the convention is to\n * replace the old value with the new value. Unlike {@link java.util.Map}, this\n * class uses the convention that values cannot be {@code null}\n * —setting the value associated with a key to {@code null} is\n * equivalent to deleting the key from the symbol table.\n *
\n * This symbol table implementation uses internally an\n * AVL tree (Georgy\n * Adelson-Velsky and Evgenii Landis' tree) which is a self-balancing BST.\n * In an AVL tree, the heights of the two child subtrees of any\n * node differ by at most one; if at any time they differ by more than one,\n * rebalancing is done to restore this property.\n *
\n * This implementation requires that the key type implements the\n * {@code Comparable} interface and calls the {@code compareTo()} and\n * method to compare two keys. It does not call either {@code equals()} or\n * {@code hashCode()}. The put, get, contains,\n * delete, minimum, maximum, ceiling, and\n * floor operations each take logarithmic time in the worst case. The\n * size, and is-empty operations take constant time.\n * Construction also takes constant time.\n * \n * For other implementations of the same API, see {@link ST}, {@link BinarySearchST},\n * {@link SequentialSearchST}, {@link BST}, {@link RedBlackBST},\n * {@link SeparateChainingHashST}, and {@link LinearProbingHashST}.\n * \n * @author Marcelo Silva\n */\n\npublic class AVLTreeST, Value> {\n\n /**\n * The root node.\n */\n private Node root;\n\n /**\n * This class represents an inner node of the AVL tree.\n */\n private class Node {\n private final Key key; // the key\n private Value val; // the associated value\n private int height; // height of the subtree\n private int size; // number of nodes in subtree\n private Node left; // left subtree\n private Node right; // right subtree\n\n public Node(Key key, Value val, int height, int size) {\n this.key = key;\n this.val = val;\n this.size = size;\n this.height = height;\n }\n }\n\n /**\n * Initializes an empty symbol table.\n */\n public AVLTreeST() {\n }\n\n /**\n * Checks if the symbol table is empty.\n * \n * @return {@code true} if the symbol table is empty.\n */\n public boolean isEmpty() {\n return root == null;\n }\n\n /**\n * Returns the number key-value pairs in the symbol table.\n * \n * @return the number key-value pairs in the symbol table\n */\n public int size() {\n return size(root);\n }\n\n /**\n * Returns the number of nodes in the subtree.\n * \n * @param x the subtree\n * \n * @return the number of nodes in the subtree\n */\n private int size(Node x) {\n if (x == null) return 0;\n return x.size;\n }\n\n /**\n * Returns the height of the internal AVL tree. It is assumed that the\n * height of an empty tree is -1 and the height of a tree with just one node\n * is 0.\n * \n * @return the height of the internal AVL tree\n */\n public int height() {\n return height(root);\n }\n\n /**\n * Returns the height of the subtree.\n * \n * @param x the subtree\n * \n * @return the height of the subtree.\n */\n private int height(Node x) {\n if (x == null) return -1;\n return x.height;\n }\n\n /**\n * Returns the value associated with the given key.\n * \n * @param key the key\n * @return the value associated with the given key if the key is in the\n * symbol table and {@code null} if the key is not in the\n * symbol table\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Value get(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to get() is null\");\n Node x = get(root, key);\n if (x == null) return null;\n return x.val;\n }\n\n /**\n * Returns value associated with the given key in the subtree or\n * {@code null} if no such key.\n * \n * @param x the subtree\n * @param key the key\n * @return value associated with the given key in the subtree or\n * {@code null} if no such key\n */\n private Node get(Node x, Key key) {\n if (x == null) return null;\n int cmp = key.compareTo(x.key);\n if (cmp < 0) return get(x.left, key);\n else if (cmp > 0) return get(x.right, key);\n else return x;\n }\n\n /**\n * Checks if the symbol table contains the given key.\n * \n * @param key the key\n * @return {@code true} if the symbol table contains {@code key}\n * and {@code false} otherwise\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public boolean contains(Key key) {\n return get(key) != null;\n }\n\n /**\n * Inserts the specified key-value pair into the symbol table, overwriting\n * the old value with the new value if the symbol table already contains the\n * specified key. Deletes the specified key (and its associated value) from\n * this symbol table if the specified value is {@code null}.\n * \n * @param key the key\n * @param val the value\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void put(Key key, Value val) {\n if (key == null) throw new IllegalArgumentException(\"first argument to put() is null\");\n if (val == null) {\n delete(key);\n return;\n }\n root = put(root, key, val);\n assert check();\n }\n\n /**\n * Inserts the key-value pair in the subtree. It overrides the old value\n * with the new value if the symbol table already contains the specified key\n * and deletes the specified key (and its associated value) from this symbol\n * table if the specified value is {@code null}.\n * \n * @param x the subtree\n * @param key the key\n * @param val the value\n * @return the subtree\n */\n private Node put(Node x, Key key, Value val) {\n if (x == null) return new Node(key, val, 0, 1);\n int cmp = key.compareTo(x.key);\n if (cmp < 0) {\n x.left = put(x.left, key, val);\n }\n else if (cmp > 0) {\n x.right = put(x.right, key, val);\n }\n else {\n x.val = val;\n return x;\n }\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n return balance(x);\n }\n\n /**\n * Restores the AVL tree property of the subtree.\n * \n * @param x the subtree\n * @return the subtree with restored AVL property\n */\n private Node balance(Node x) {\n if (balanceFactor(x) < -1) {\n if (balanceFactor(x.right) > 0) {\n x.right = rotateRight(x.right);\n }\n x = rotateLeft(x);\n }\n else if (balanceFactor(x) > 1) {\n if (balanceFactor(x.left) < 0) {\n x.left = rotateLeft(x.left);\n }\n x = rotateRight(x);\n }\n return x;\n }\n\n /**\n * Returns the balance factor of the subtree. The balance factor is defined\n * as the difference in height of the left subtree and right subtree, in\n * this order. Therefore, a subtree with a balance factor of -1, 0 or 1 has\n * the AVL property since the heights of the two child subtrees differ by at\n * most one.\n * \n * @param x the subtree\n * @return the balance factor of the subtree\n */\n private int balanceFactor(Node x) {\n return height(x.left) - height(x.right);\n }\n\n /**\n * Rotates the given subtree to the right.\n * \n * @param x the subtree\n * @return the right rotated subtree\n */\n private Node rotateRight(Node x) {\n Node y = x.left;\n x.left = y.right;\n y.right = x;\n y.size = x.size;\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n y.height = 1 + Math.max(height(y.left), height(y.right));\n return y;\n }\n\n /**\n * Rotates the given subtree to the left.\n * \n * @param x the subtree\n * @return the left rotated subtree\n */\n private Node rotateLeft(Node x) {\n Node y = x.right;\n x.right = y.left;\n y.left = x;\n y.size = x.size;\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n y.height = 1 + Math.max(height(y.left), height(y.right));\n return y;\n }\n\n /**\n * Removes the specified key and its associated value from the symbol table\n * (if the key is in the symbol table).\n * \n * @param key the key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void delete(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to delete() is null\");\n if (!contains(key)) return;\n root = delete(root, key);\n assert check();\n }\n\n /**\n * Removes the specified key and its associated value from the given\n * subtree.\n * \n * @param x the subtree\n * @param key the key\n * @return the updated subtree\n */\n private Node delete(Node x, Key key) {\n int cmp = key.compareTo(x.key);\n if (cmp < 0) {\n x.left = delete(x.left, key);\n }\n else if (cmp > 0) {\n x.right = delete(x.right, key);\n }\n else {\n if (x.left == null) {\n return x.right;\n }\n else if (x.right == null) {\n return x.left;\n }\n else {\n Node y = x;\n x = min(y.right);\n x.right = deleteMin(y.right);\n x.left = y.left;\n }\n }\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n return balance(x);\n }\n\n /**\n * Removes the smallest key and associated value from the symbol table.\n * \n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMin() {\n if (isEmpty()) throw new NoSuchElementException(\"called deleteMin() with empty symbol table\");\n root = deleteMin(root);\n assert check();\n }\n\n /**\n * Removes the smallest key and associated value from the given subtree.\n * \n * @param x the subtree\n * @return the updated subtree\n */\n private Node deleteMin(Node x) {\n if (x.left == null) return x.right;\n x.left = deleteMin(x.left);\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n return balance(x);\n }\n\n /**\n * Removes the largest key and associated value from the symbol table.\n * \n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMax() {\n if (isEmpty()) throw new NoSuchElementException(\"called deleteMax() with empty symbol table\");\n root = deleteMax(root);\n assert check();\n }\n\n /**\n * Removes the largest key and associated value from the given subtree.\n * \n * @param x the subtree\n * @return the updated subtree\n */\n private Node deleteMax(Node x) {\n if (x.right == null) return x.left;\n x.right = deleteMax(x.right);\n x.size = 1 + size(x.left) + size(x.right);\n x.height = 1 + Math.max(height(x.left), height(x.right));\n return balance(x);\n }\n\n /**\n * Returns the smallest key in the symbol table.\n * \n * @return the smallest key in the symbol table\n * @throws NoSuchElementException if the symbol table is empty\n */\n public Key min() {\n if (isEmpty()) throw new NoSuchElementException(\"called min() with empty symbol table\");\n return min(root).key;\n }\n\n /**\n * Returns the node with the smallest key in the subtree.\n * \n * @param x the subtree\n * @return the node with the smallest key in the subtree\n */\n private Node min(Node x) {\n if (x.left == null) return x;\n return min(x.left);\n }\n\n /**\n * Returns the largest key in the symbol table.\n * \n * @return the largest key in the symbol table\n * @throws NoSuchElementException if the symbol table is empty\n */\n public Key max() {\n if (isEmpty()) throw new NoSuchElementException(\"called max() with empty symbol table\");\n return max(root).key;\n }\n\n /**\n * Returns the node with the largest key in the subtree.\n * \n * @param x the subtree\n * @return the node with the largest key in the subtree\n */\n private Node max(Node x) {\n if (x.right == null) return x;\n return max(x.right);\n }\n\n /**\n * Returns the largest key in the symbol table less than or equal to\n * {@code key}.\n * \n * @param key the key\n * @return the largest key in the symbol table less than or equal to\n * {@code key}\n * @throws NoSuchElementException if the symbol table is empty\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key floor(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to floor() is null\");\n if (isEmpty()) throw new NoSuchElementException(\"called floor() with empty symbol table\");\n Node x = floor(root, key);\n if (x == null) return null;\n else return x.key;\n }\n\n /**\n * Returns the node in the subtree with the largest key less than or equal\n * to the given key.\n * \n * @param x the subtree\n * @param key the key\n * @return the node in the subtree with the largest key less than or equal\n * to the given key\n */\n private Node floor(Node x, Key key) {\n if (x == null) return null;\n int cmp = key.compareTo(x.key);\n if (cmp == 0) return x;\n if (cmp < 0) return floor(x.left, key);\n Node y = floor(x.right, key);\n if (y != null) return y;\n else return x;\n }\n\n /**\n * Returns the smallest key in the symbol table greater than or equal to\n * {@code key}.\n * \n * @param key the key\n * @return the smallest key in the symbol table greater than or equal to\n * {@code key}\n * @throws NoSuchElementException if the symbol table is empty\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key ceiling(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to ceiling() is null\");\n if (isEmpty()) throw new NoSuchElementException(\"called ceiling() with empty symbol table\");\n Node x = ceiling(root, key);\n if (x == null) return null;\n else return x.key;\n }\n\n /**\n * Returns the node in the subtree with the smallest key greater than or\n * equal to the given key.\n * \n * @param x the subtree\n * @param key the key\n * @return the node in the subtree with the smallest key greater than or\n * equal to the given key\n */\n private Node ceiling(Node x, Key key) {\n if (x == null) return null;\n int cmp = key.compareTo(x.key);\n if (cmp == 0) return x;\n if (cmp > 0) return ceiling(x.right, key);\n Node y = ceiling(x.left, key);\n if (y != null) return y;\n else return x;\n }\n\n /**\n * Returns the kth smallest key in the symbol table.\n * \n * @param k the order statistic\n * @return the kth smallest key in the symbol table\n * @throws IllegalArgumentException unless {@code k} is between 0 and\n * {@code size() -1 }\n */\n public Key select(int k) {\n if (k < 0 || k >= size()) throw new IllegalArgumentException(\"k is not in range 0-\" + (size() - 1));\n Node x = select(root, k);\n return x.key;\n }\n\n /**\n * Returns the node with key the kth smallest key in the subtree.\n * \n * @param x the subtree\n * @param k the kth smallest key in the subtree\n * @return the node with key the kth smallest key in the subtree\n */\n private Node select(Node x, int k) {\n if (x == null) return null;\n int t = size(x.left);\n if (t > k) return select(x.left, k);\n else if (t < k) return select(x.right, k - t - 1);\n else return x;\n }\n\n /**\n * Returns the number of keys in the symbol table strictly less than\n * {@code key}.\n * \n * @param key the key\n * @return the number of keys in the symbol table strictly less than\n * {@code key}\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public int rank(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to rank() is null\");\n return rank(key, root);\n }\n\n /**\n * Returns the number of keys in the subtree less than key.\n * \n * @param key the key\n * @param x the subtree\n * @return the number of keys in the subtree less than key\n */\n private int rank(Key key, Node x) {\n if (x == null) return 0;\n int cmp = key.compareTo(x.key);\n if (cmp < 0) return rank(key, x.left);\n else if (cmp > 0) return 1 + size(x.left) + rank(key, x.right);\n else return size(x.left);\n }\n\n /**\n * Returns all keys in the symbol table.\n * \n * @return all keys in the symbol table\n */\n public Iterable keys() {\n return keysInOrder();\n }\n\n /**\n * Returns all keys in the symbol table following an in-order traversal.\n * \n * @return all keys in the symbol table following an in-order traversal\n */\n public Iterable keysInOrder() {\n Queue queue = new Queue();\n keysInOrder(root, queue);\n return queue;\n }\n\n /**\n * Adds the keys in the subtree to queue following an in-order traversal.\n * \n * @param x the subtree\n * @param queue the queue\n */\n private void keysInOrder(Node x, Queue queue) {\n if (x == null) return;\n keysInOrder(x.left, queue);\n queue.enqueue(x.key);\n keysInOrder(x.right, queue);\n }\n\n /**\n * Returns all keys in the symbol table following a level-order traversal.\n * \n * @return all keys in the symbol table following a level-order traversal.\n */\n public Iterable keysLevelOrder() {\n Queue queue = new Queue();\n if (!isEmpty()) {\n Queue queue2 = new Queue();\n queue2.enqueue(root);\n while (!queue2.isEmpty()) {\n Node x = queue2.dequeue();\n queue.enqueue(x.key);\n if (x.left != null) {\n queue2.enqueue(x.left);\n }\n if (x.right != null) {\n queue2.enqueue(x.right);\n }\n }\n }\n return queue;\n }\n\n /**\n * Returns all keys in the symbol table in the given range.\n * \n * @param lo the lowest key\n * @param hi the highest key\n * @return all keys in the symbol table between {@code lo} (inclusive)\n * and {@code hi} (exclusive)\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public Iterable keys(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to keys() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to keys() is null\");\n Queue queue = new Queue();\n keys(root, queue, lo, hi);\n return queue;\n }\n\n /**\n * Adds the keys between {@code lo} and {@code hi} in the subtree\n * to the {@code queue}.\n * \n * @param x the subtree\n * @param queue the queue\n * @param lo the lowest key\n * @param hi the highest key\n */\n private void keys(Node x, Queue queue, Key lo, Key hi) {\n if (x == null) return;\n int cmplo = lo.compareTo(x.key);\n int cmphi = hi.compareTo(x.key);\n if (cmplo < 0) keys(x.left, queue, lo, hi);\n if (cmplo <= 0 && cmphi >= 0) queue.enqueue(x.key);\n if (cmphi > 0) keys(x.right, queue, lo, hi);\n }\n\n /**\n * Returns the number of keys in the symbol table in the given range.\n * \n * @param lo minimum endpoint\n * @param hi maximum endpoint\n * @return the number of keys in the symbol table between {@code lo}\n * (inclusive) and {@code hi} (exclusive)\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public int size(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to size() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to size() is null\");\n if (lo.compareTo(hi) > 0) return 0;\n if (contains(hi)) return rank(hi) - rank(lo) + 1;\n else return rank(hi) - rank(lo);\n }\n\n /**\n * Checks if the AVL tree invariants are fine.\n * \n * @return {@code true} if the AVL tree invariants are fine\n */\n private boolean check() {\n if (!isBST()) StdOut.println(\"Symmetric order not consistent\");\n if (!isAVL()) StdOut.println(\"AVL property not consistent\");\n if (!isSizeConsistent()) StdOut.println(\"Subtree counts not consistent\");\n if (!isRankConsistent()) StdOut.println(\"Ranks not consistent\");\n return isBST() && isAVL() && isSizeConsistent() && isRankConsistent();\n }\n\n /**\n * Checks if AVL property is consistent.\n * \n * @return {@code true} if AVL property is consistent.\n */\n private boolean isAVL() {\n return isAVL(root);\n }\n\n /**\n * Checks if AVL property is consistent in the subtree.\n * \n * @param x the subtree\n * @return {@code true} if AVL property is consistent in the subtree\n */\n private boolean isAVL(Node x) {\n if (x == null) return true;\n int bf = balanceFactor(x);\n if (bf > 1 || bf < -1) return false;\n return isAVL(x.left) && isAVL(x.right);\n }\n\n /**\n * Checks if the symmetric order is consistent.\n * \n * @return {@code true} if the symmetric order is consistent\n */\n private boolean isBST() {\n return isBST(root, null, null);\n }\n\n /**\n * Checks if the tree rooted at x is a BST with all keys strictly between\n * min and max (if min or max is null, treat as empty constraint) Credit:\n * Bob Dondero's elegant solution\n * \n * @param x the subtree\n * @param min the minimum key in subtree\n * @param max the maximum key in subtree\n * @return {@code true} if if the symmetric order is consistent\n */\n private boolean isBST(Node x, Key min, Key max) {\n if (x == null) return true;\n if (min != null && x.key.compareTo(min) <= 0) return false;\n if (max != null && x.key.compareTo(max) >= 0) return false;\n return isBST(x.left, min, x.key) && isBST(x.right, x.key, max);\n }\n\n /**\n * Checks if size is consistent.\n * \n * @return {@code true} if size is consistent\n */\n private boolean isSizeConsistent() {\n return isSizeConsistent(root);\n }\n\n /**\n * Checks if the size of the subtree is consistent.\n * \n * @return {@code true} if the size of the subtree is consistent\n */\n private boolean isSizeConsistent(Node x) {\n if (x == null) return true;\n if (x.size != size(x.left) + size(x.right) + 1) return false;\n return isSizeConsistent(x.left) && isSizeConsistent(x.right);\n }\n\n /**\n * Checks if rank is consistent.\n * \n * @return {@code true} if rank is consistent\n */\n private boolean isRankConsistent() {\n for (int i = 0; i < size(); i++)\n if (i != rank(select(i))) return false;\n for (Key key : keys())\n if (key.compareTo(select(rank(key))) != 0) return false;\n return true;\n }\n\n /**\n * Unit tests the {@code AVLTreeST} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n AVLTreeST st = new AVLTreeST();\n for (int i = 0; !StdIn.isEmpty(); i++) {\n String key = StdIn.readString();\n st.put(key, i);\n }\n for (String s : st.keys())\n StdOut.println(s + \" \" + st.get(s));\n StdOut.println();\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Accumulator.java",
"content": "/******************************************************************************\n * Compilation: javac Accumulator.java\n * Execution: java Accumulator < input.txt\n * Dependencies: StdOut.java StdIn.java\n *\n * Mutable data type that calculates the mean, sample standard\n * deviation, and sample variance of a stream of real numbers\n * use a stable, one-pass algorithm.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n\n/**\n * The {@code Accumulator} class is a data type for computing the running\n * mean, sample standard deviation, and sample variance of a stream of real\n * numbers. It provides an example of a mutable data type and a streaming\n * algorithm.\n *
\n * This implementation uses a one-pass algorithm that is less susceptible\n * to floating-point roundoff error than the more straightforward\n * implementation based on saving the sum of the squares of the numbers.\n * This technique is due to\n * B. P. Welford.\n * Each operation takes constant time in the worst case.\n * The amount of memory is constant - the data values are not stored.\n *
\n * For additional documentation,\n * see Section 1.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Accumulator {\n private int n = 0; // number of data values\n private double sum = 0.0; // sample variance * (n-1)\n private double mu = 0.0; // sample mean\n\n /**\n * Initializes an accumulator.\n */\n public Accumulator() {\n }\n\n /**\n * Adds the specified data value to the accumulator.\n * @param x the data value\n */\n public void addDataValue(double x) {\n n++;\n double delta = x - mu;\n mu += delta / n;\n sum += ((double) (n - 1) / n) * delta * delta;\n }\n\n /**\n * Returns the mean of the data values.\n * @return the mean of the data values\n */\n public double mean() {\n return mu;\n }\n\n /**\n * Returns the sample variance of the data values.\n * @return the sample variance of the data values\n */\n public double var() {\n if (n <= 1) return Double.NaN;\n return sum / (n - 1);\n }\n\n /**\n * Returns the sample standard deviation of the data values.\n * @return the sample standard deviation of the data values\n */\n public double stddev() {\n return Math.sqrt(this.var());\n }\n\n /**\n * Returns the number of data values.\n * @return the number of data values\n */\n public int count() {\n return n;\n }\n\n /**\n * Returns a string representation of this accumulator.\n * @return a string representation of this accumulator\n */\n public String toString() {\n return \"n = \" + n + \", mean = \" + mean() + \", stddev = \" + stddev();\n }\n\n /**\n * Unit tests the {@code Accumulator} data type.\n * Reads in a stream of real number from standard input;\n * adds them to the accumulator; and prints the mean,\n * sample standard deviation, and sample variance to standard\n * output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Accumulator stats = new Accumulator();\n while (!StdIn.isEmpty()) {\n double x = StdIn.readDouble();\n stats.addDataValue(x);\n }\n\n StdOut.printf(\"n = %d\\n\", stats.count());\n StdOut.printf(\"mean = %.5f\\n\", stats.mean());\n StdOut.printf(\"stddev = %.5f\\n\", stats.stddev());\n StdOut.printf(\"var = %.5f\\n\", stats.var());\n StdOut.println(stats);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AcyclicLP.java",
"content": "/******************************************************************************\n * Compilation: javac AcyclicLP.java\n * Execution: java AcyclicP V E\n * Dependencies: EdgeWeightedDigraph.java DirectedEdge.java Topological.java\n * Data files: https://algs4.cs.princeton.edu/44sp/tinyEWDAG.txt\n *\n * Computes longest paths in an edge-weighted acyclic digraph.\n *\n * Remark: should probably check that graph is a DAG before running\n *\n * % java AcyclicLP tinyEWDAG.txt 5\n * 5 to 0 (2.44) 5->1 0.32 1->3 0.29 3->6 0.52 6->4 0.93 4->0 0.38\n * 5 to 1 (0.32) 5->1 0.32\n * 5 to 2 (2.77) 5->1 0.32 1->3 0.29 3->6 0.52 6->4 0.93 4->7 0.37 7->2 0.34\n * 5 to 3 (0.61) 5->1 0.32 1->3 0.29\n * 5 to 4 (2.06) 5->1 0.32 1->3 0.29 3->6 0.52 6->4 0.93\n * 5 to 5 (0.00)\n * 5 to 6 (1.13) 5->1 0.32 1->3 0.29 3->6 0.52\n * 5 to 7 (2.43) 5->1 0.32 1->3 0.29 3->6 0.52 6->4 0.93 4->7 0.37\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AcyclicLP} class represents a data type for solving the\n * single-source longest paths problem in edge-weighted directed\n * acyclic graphs (DAGs). The edge weights can be positive, negative, or zero.\n *
\n * This implementation uses a topological-sort based algorithm.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and\n * E is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the\n * edge-weighted digraph).\n *
\n * This correctly computes longest paths if all arithmetic performed is\n * without floating-point rounding error or arithmetic overflow.\n * This is the case if all edge weights are integers and if none of the\n * intermediate results exceeds 252. Since all intermediate\n * results are sums of edge weights, they are bounded by V C,\n * where V is the number of vertices and C is the maximum\n * absolute value of any edge weight.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class AcyclicLP {\n private double[] distTo; // distTo[v] = distance of longest s->v path\n private DirectedEdge[] edgeTo; // edgeTo[v] = last edge on longest s->v path\n\n /**\n * Computes a longest paths tree from {@code s} to every other vertex in\n * the directed acyclic graph {@code digraph}.\n * @param digraph the acyclic digraph\n * @param s the source vertex\n * @throws IllegalArgumentException if the digraph is not acyclic\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public AcyclicLP(EdgeWeightedDigraph digraph, int s) {\n distTo = new double[digraph.V()];\n edgeTo = new DirectedEdge[digraph.V()];\n\n validateVertex(s);\n\n for (int v = 0; v < digraph.V(); v++)\n distTo[v] = Double.NEGATIVE_INFINITY;\n distTo[s] = 0.0;\n\n // relax vertices in topological order\n Topological topological = new Topological(digraph);\n if (!topological.hasOrder())\n throw new IllegalArgumentException(\"Digraph is not acyclic.\");\n for (int v : topological.order()) {\n for (DirectedEdge e : digraph.adj(v))\n relax(e);\n }\n }\n\n // relax edge e, but update if you find a *longer* path\n private void relax(DirectedEdge e) {\n int v = e.from(), w = e.to();\n if (distTo[w] < distTo[v] + e.weight()) {\n distTo[w] = distTo[v] + e.weight();\n edgeTo[w] = e;\n }\n }\n\n /**\n * Returns the length of a longest path from the source vertex {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return the length of a longest path from the source vertex {@code s} to vertex {@code v};\n * {@code Double.NEGATIVE_INFINITY} if no such path\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public double distTo(int v) {\n validateVertex(v);\n return distTo[v];\n }\n\n /**\n * Is there a path from the source vertex {@code s} to vertex {@code v}?\n * @param v the destination vertex\n * @return {@code true} if there is a path from the source vertex\n * {@code s} to vertex {@code v}, and {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return distTo[v] > Double.NEGATIVE_INFINITY;\n }\n\n /**\n * Returns a longest path from the source vertex {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return a longest path from the source vertex {@code s} to vertex {@code v}\n * as an iterable of edges, and {@code null} if no such path\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {\n path.push(e);\n }\n return path;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = distTo.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code AcyclicLP} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n int s = Integer.parseInt(args[1]);\n EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(in);\n\n AcyclicLP lp = new AcyclicLP(digraph, s);\n\n for (int v = 0; v < digraph.V(); v++) {\n if (lp.hasPathTo(v)) {\n StdOut.printf(\"%d to %d (%.2f) \", s, v, lp.distTo(v));\n for (DirectedEdge e : lp.pathTo(v)) {\n StdOut.print(e + \" \");\n }\n StdOut.println();\n }\n else {\n StdOut.printf(\"%d to %d no path\\n\", s, v);\n }\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AcyclicSP.java",
"content": "/******************************************************************************\n * Compilation: javac AcyclicSP.java\n * Execution: java AcyclicSP V E\n * Dependencies: EdgeWeightedDigraph.java DirectedEdge.java Topological.java\n * Data files: https://algs4.cs.princeton.edu/44sp/tinyEWDAG.txt\n *\n * Computes shortest paths in an edge-weighted acyclic digraph.\n *\n * % java AcyclicSP tinyEWDAG.txt 5\n * 5 to 0 (0.73) 5->4 0.35 4->0 0.38\n * 5 to 1 (0.32) 5->1 0.32\n * 5 to 2 (0.62) 5->7 0.28 7->2 0.34\n * 5 to 3 (0.61) 5->1 0.32 1->3 0.29\n * 5 to 4 (0.35) 5->4 0.35\n * 5 to 5 (0.00)\n * 5 to 6 (1.13) 5->1 0.32 1->3 0.29 3->6 0.52\n * 5 to 7 (0.28) 5->7 0.28\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AcyclicSP} class represents a data type for solving the\n * single-source shortest paths problem in edge-weighted directed acyclic\n * graphs (DAGs). The edge weights can be positive, negative, or zero.\n *
\n * This implementation uses a topological-sort based algorithm.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and\n * E is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the\n * edge-weighted digraph).\n *
\n * This correctly computes shortest paths if all arithmetic performed is\n * without floating-point rounding error or arithmetic overflow.\n * This is the case if all edge weights are integers and if none of the\n * intermediate results exceeds 252. Since all intermediate\n * results are sums of edge weights, they are bounded by V C,\n * where V is the number of vertices and C is the maximum\n * absolute value of any edge weight.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class AcyclicSP {\n private double[] distTo; // distTo[v] = distance of shortest s->v path\n private DirectedEdge[] edgeTo; // edgeTo[v] = last edge on shortest s->v path\n\n\n /**\n * Computes a shortest paths tree from {@code s} to every other vertex in\n * the directed acyclic graph {@code digraph}.\n * @param digraph the acyclic digraph\n * @param s the source vertex\n * @throws IllegalArgumentException if the digraph is not acyclic\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public AcyclicSP(EdgeWeightedDigraph digraph, int s) {\n distTo = new double[digraph.V()];\n edgeTo = new DirectedEdge[digraph.V()];\n\n validateVertex(s);\n\n for (int v = 0; v < digraph.V(); v++)\n distTo[v] = Double.POSITIVE_INFINITY;\n distTo[s] = 0.0;\n\n // visit vertices in topological order\n Topological topological = new Topological(digraph);\n if (!topological.hasOrder())\n throw new IllegalArgumentException(\"Digraph is not acyclic.\");\n for (int v : topological.order()) {\n for (DirectedEdge e : digraph.adj(v))\n relax(e);\n }\n }\n\n // relax edge e\n private void relax(DirectedEdge e) {\n int v = e.from(), w = e.to();\n if (distTo[w] > distTo[v] + e.weight()) {\n distTo[w] = distTo[v] + e.weight();\n edgeTo[w] = e;\n }\n }\n\n /**\n * Returns the length of a shortest path from the source vertex {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return the length of a shortest path from the source vertex {@code s} to vertex {@code v};\n * {@code Double.POSITIVE_INFINITY} if no such path\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public double distTo(int v) {\n validateVertex(v);\n return distTo[v];\n }\n\n /**\n * Is there a path from the source vertex {@code s} to vertex {@code v}?\n * @param v the destination vertex\n * @return {@code true} if there is a path from the source vertex\n * {@code s} to vertex {@code v}, and {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return distTo[v] < Double.POSITIVE_INFINITY;\n }\n\n /**\n * Returns a shortest path from the source vertex {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return a shortest path from the source vertex {@code s} to vertex {@code v}\n * as an iterable of edges, and {@code null} if no such path\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {\n path.push(e);\n }\n return path;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = distTo.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code AcyclicSP} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n int s = Integer.parseInt(args[1]);\n EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(in);\n\n // find shortest path from s to each other vertex in DAG\n AcyclicSP sp = new AcyclicSP(digraph, s);\n for (int v = 0; v < digraph.V(); v++) {\n if (sp.hasPathTo(v)) {\n StdOut.printf(\"%d to %d (%.2f) \", s, v, sp.distTo(v));\n for (DirectedEdge e : sp.pathTo(v)) {\n StdOut.print(e + \" \");\n }\n StdOut.println();\n }\n else {\n StdOut.printf(\"%d to %d no path\\n\", s, v);\n }\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AdjMatrixEdgeWeightedDigraph.java",
"content": "/******************************************************************************\n * Compilation: javac AdjMatrixEdgeWeightedDigraph.java\n * Execution: java AdjMatrixEdgeWeightedDigraph V E\n * Dependencies: StdOut.java\n *\n * An edge-weighted digraph, implemented using an adjacency matrix.\n * Parallel edges are disallowed; self-loops are allowed.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.Iterator;\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code AdjMatrixEdgeWeightedDigraph} class represents an edge-weighted\n * digraph of vertices named 0 through V - 1, where each\n * directed edge is of type {@link DirectedEdge} and has a real-valued weight.\n * It supports the following two primary operations: add a directed edge\n * to the digraph and iterate over all of edges incident from a given vertex.\n * It also provides\n * methods for returning the number of vertices V and the number\n * of edges E. Parallel edges are disallowed; self-loops are permitted.\n *
\n * This implementation uses an adjacency-matrix representation.\n * All operations take constant time (in the worst case) except\n * iterating over the edges incident from a given vertex, which takes\n * time proportional to V.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class AdjMatrixEdgeWeightedDigraph {\n private static final String NEWLINE = System.getProperty(\"line.separator\");\n\n private final int V;\n private int E;\n private DirectedEdge[][] adj;\n\n /**\n * Initializes an empty edge-weighted digraph with {@code V} vertices and 0 edges.\n * @param V the number of vertices\n * @throws IllegalArgumentException if {@code V < 0}\n */\n public AdjMatrixEdgeWeightedDigraph(int V) {\n if (V < 0) throw new IllegalArgumentException(\"number of vertices must be non-negative\");\n this.V = V;\n this.E = 0;\n this.adj = new DirectedEdge[V][V];\n }\n\n /**\n * Initializes a random edge-weighted digraph with {@code V} vertices and E edges.\n * @param V the number of vertices\n * @param E the number of edges\n * @throws IllegalArgumentException if {@code V < 0}\n * @throws IllegalArgumentException if {@code E < 0}\n */\n public AdjMatrixEdgeWeightedDigraph(int V, int E) {\n this(V);\n if (E < 0) throw new IllegalArgumentException(\"number of edges must be non-negative\");\n if (E > V*V) throw new IllegalArgumentException(\"too many edges\");\n\n // can be inefficient\n while (this.E != E) {\n int v = StdRandom.uniformInt(V);\n int w = StdRandom.uniformInt(V);\n double weight = 0.01 * StdRandom.uniformInt(0, 100);\n addEdge(new DirectedEdge(v, w, weight));\n }\n }\n\n /**\n * Returns the number of vertices in the edge-weighted digraph.\n * @return the number of vertices in the edge-weighted digraph\n */\n public int V() {\n return V;\n }\n\n /**\n * Returns the number of edges in the edge-weighted digraph.\n * @return the number of edges in the edge-weighted digraph\n */\n public int E() {\n return E;\n }\n\n /**\n * Adds the directed edge {@code e} to the edge-weighted digraph (if there\n * is not already an edge with the same endpoints).\n * @param e the edge\n */\n public void addEdge(DirectedEdge e) {\n int v = e.from();\n int w = e.to();\n validateVertex(v);\n validateVertex(w);\n if (adj[v][w] == null) {\n E++;\n adj[v][w] = e;\n }\n }\n\n /**\n * Returns the directed edges incident from vertex {@code v}.\n * @param v the vertex\n * @return the directed edges incident from vertex {@code v} as an Iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable adj(int v) {\n validateVertex(v);\n return new AdjIterator(v);\n }\n\n // support iteration over graph vertices\n private class AdjIterator implements Iterator, Iterable {\n private int v;\n private int w = 0;\n\n public AdjIterator(int v) {\n this.v = v;\n }\n\n public Iterator iterator() {\n return this;\n }\n\n public boolean hasNext() {\n while (w < V) {\n if (adj[v][w] != null) return true;\n w++;\n }\n return false;\n }\n\n public DirectedEdge next() {\n if (!hasNext()) {\n throw new NoSuchElementException();\n }\n return adj[v][w++];\n }\n\n public void remove() {\n throw new UnsupportedOperationException();\n }\n }\n\n /**\n * Returns a string representation of the edge-weighted digraph. This method takes\n * time proportional to V2.\n * @return the number of vertices V, followed by the number of edges E,\n * followed by the V adjacency lists of edges\n */\n public String toString() {\n StringBuilder s = new StringBuilder();\n s.append(V + \" \" + E + NEWLINE);\n for (int v = 0; v < V; v++) {\n s.append(v + \": \");\n for (DirectedEdge e : adj(v)) {\n s.append(e + \" \");\n }\n s.append(NEWLINE);\n }\n return s.toString();\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n\n /**\n * Unit tests the {@code AdjMatrixEdgeWeightedDigraph} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int V = Integer.parseInt(args[0]);\n int E = Integer.parseInt(args[1]);\n AdjMatrixEdgeWeightedDigraph G = new AdjMatrixEdgeWeightedDigraph(V, E);\n StdOut.println(G);\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AllowFilter.java",
"content": "/******************************************************************************\n * Compilation: javac AllowFilter.java\n * Execution: java AllowFilter allowlist.txt < input.txt\n * Dependencies: SET In.java StdIn.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/35applications/tinyTale.txt\n * https://algs4.cs.princeton.edu/35applications/allowlist.txt\n *\n * Reads an allowlist of words from a file. Then readsa list of\n * words from standard input and prints all those words that\n * are in the first file.\n *\n * % more tinyTale.txt\n * it was the best of times it was the worst of times\n * it was the age of wisdom it was the age of foolishness\n * it was the epoch of belief it was the epoch of incredulity\n * it was the season of light it was the season of darkness\n * it was the spring of hope it was the winter of despair\n *\n * % more list.txt\n * was it the of\n *\n * % java AllowFilter list.txt < tinyTale.txt\n * it was the of it was the of\n * it was the of it was the of\n * it was the of it was the of\n * it was the of it was the of\n * it was the of it was the of\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AllowFilter} class provides a client for reading in an allowlist\n * of words from a file; then, reading in a sequence of words from standard input,\n * printing out each word that appears in the file.\n * It is useful as a test client for various symbol-table implementations.\n *
\n * For additional documentation,\n * see Section 3.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class AllowFilter {\n\n // Do not instantiate.\n private AllowFilter() { }\n\n public static void main(String[] args) {\n SET set = new SET();\n\n // read in strings and add to set\n In in = new In(args[0]);\n while (!in.isEmpty()) {\n String word = in.readString();\n set.add(word);\n }\n\n // read in string from standard input, printing out all exceptions\n while (!StdIn.isEmpty()) {\n String word = StdIn.readString();\n if (set.contains(word))\n StdOut.println(word);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Allowlist.java",
"content": "/******************************************************************************\n * Compilation: javac Allowlist.java\n * Execution: java Allowlist allowlist.txt < data.txt\n * Dependencies: StaticSetOfInts.java In.java StdOut.java\n *\n * Data files: https://algs4.cs.princeton.edu/11model/tinyAllowlist.txt\n * https://algs4.cs.princeton.edu/11model/tinyText.txt\n * https://algs4.cs.princeton.edu/11model/largeAllowlist.txt\n * https://algs4.cs.princeton.edu/11model/largeText.txt\n *\n * Allowlist filter.\n *\n *\n * % java Allowlist tinyAllowlist.txt < tinyText.txt\n * 50\n * 99\n * 13\n *\n * % java Allowlist largeAllowlist.txt < largeText.txt | more\n * 499569\n * 984875\n * 295754\n * 207807\n * 140925\n * 161828\n * [367,966 total values]\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Allowlist} class provides a client for reading in\n * a set of integers from a file; reading in a sequence of integers\n * from standard input; and printing to standard output those\n * integers not in the allowlist.\n *
\n * For additional documentation,\n * see Section 1.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Allowlist {\n\n // Do not instantiate.\n private Allowlist() { }\n\n /**\n * Reads in a sequence of integers from the allowlist file, specified as\n * a command-line argument. Reads in integers from standard input and\n * prints to standard output those integers that are not in the file.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n int[] white = in.readAllInts();\n StaticSETofInts set = new StaticSETofInts(white);\n\n // Read key, print if not in allowlist.\n while (!StdIn.isEmpty()) {\n int key = StdIn.readInt();\n if (!set.contains(key))\n StdOut.println(key);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Alphabet.java",
"content": "/******************************************************************************\n * Compilation: javac Alphabet.java\n * Execution: java Alphabet\n * Dependencies: StdOut.java\n * \n * A data type for alphabets, for use with string-processing code\n * that must convert between an alphabet of size R and the integers\n * 0 through R-1.\n *\n * Warning: supports only the basic multilingual plane (BMP), i.e,\n * Unicode characters between U+0000 and U+FFFF.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\npublic class Alphabet {\n\n /**\n * The binary alphabet { 0, 1 }.\n */\n public static final Alphabet BINARY = new Alphabet(\"01\");\n\n /**\n * The octal alphabet { 0, 1, 2, 3, 4, 5, 6, 7 }.\n */\n public static final Alphabet OCTAL = new Alphabet(\"01234567\");\n\n /**\n * The decimal alphabet { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }.\n */\n public static final Alphabet DECIMAL = new Alphabet(\"0123456789\");\n\n /**\n * The hexadecimal alphabet { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F }.\n */\n public static final Alphabet HEXADECIMAL = new Alphabet(\"0123456789ABCDEF\");\n\n /**\n * The DNA alphabet { A, C, T, G }.\n */\n public static final Alphabet DNA = new Alphabet(\"ACGT\");\n\n /**\n * The lowercase alphabet { a, b, c, ..., z }.\n */\n public static final Alphabet LOWERCASE = new Alphabet(\"abcdefghijklmnopqrstuvwxyz\");\n\n /**\n * The uppercase alphabet { A, B, C, ..., Z }.\n */\n\n public static final Alphabet UPPERCASE = new Alphabet(\"ABCDEFGHIJKLMNOPQRSTUVWXYZ\");\n\n /**\n * The protein alphabet { A, C, D, E, F, G, H, I, K, L, M, N, P, Q, R, S, T, V, W, Y }.\n */\n public static final Alphabet PROTEIN = new Alphabet(\"ACDEFGHIKLMNPQRSTVWY\");\n\n /**\n * The base-64 alphabet (64 characters).\n */\n public static final Alphabet BASE64 = new Alphabet(\"ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/\");\n\n /**\n * The ASCII alphabet (0-127).\n */\n public static final Alphabet ASCII = new Alphabet(128);\n\n /**\n * The extended ASCII alphabet (0-255).\n */\n public static final Alphabet EXTENDED_ASCII = new Alphabet(256);\n\n /**\n * The Unicode 16 alphabet (0-65,535).\n */\n public static final Alphabet UNICODE16 = new Alphabet(65536);\n\n\n private char[] alphabet; // the characters in the alphabet\n private int[] inverse; // indices\n private final int R; // the radix of the alphabet\n\n /**\n * Initializes a new alphabet from the given set of characters.\n *\n * @param alpha the set of characters\n */\n public Alphabet(String alpha) {\n\n // check that alphabet contains no duplicate chars\n boolean[] unicode = new boolean[Character.MAX_VALUE];\n for (int i = 0; i < alpha.length(); i++) {\n char c = alpha.charAt(i);\n if (unicode[c])\n throw new IllegalArgumentException(\"Illegal alphabet: repeated character = '\" + c + \"'\");\n unicode[c] = true;\n }\n\n alphabet = alpha.toCharArray();\n R = alpha.length();\n inverse = new int[Character.MAX_VALUE];\n for (int i = 0; i < inverse.length; i++)\n inverse[i] = -1;\n\n // can't use char since R can be as big as 65,536\n for (int c = 0; c < R; c++)\n inverse[alphabet[c]] = c;\n }\n\n /**\n * Initializes a new alphabet using characters 0 through R-1.\n *\n * @param radix the number of characters in the alphabet (the radix R)\n */\n private Alphabet(int radix) {\n this.R = radix;\n alphabet = new char[R];\n inverse = new int[R];\n\n // can't use char since R can be as big as 65,536\n for (int i = 0; i < R; i++)\n alphabet[i] = (char) i;\n for (int i = 0; i < R; i++)\n inverse[i] = i;\n }\n\n /**\n * Initializes a new alphabet using characters 0 through 255.\n */\n public Alphabet() {\n this(256);\n }\n\n /**\n * Returns true if the argument is a character in this alphabet.\n *\n * @param c the character\n * @return {@code true} if {@code c} is a character in this alphabet;\n * {@code false} otherwise\n */\n public boolean contains(char c) {\n return inverse[c] != -1;\n }\n\n /**\n * Returns the number of characters in this alphabet (the radix).\n * \n * @return the number of characters in this alphabet\n * @deprecated Replaced by {@link #radix()}.\n */\n @Deprecated\n public int R() {\n return R;\n }\n\n /**\n * Returns the number of characters in this alphabet (the radix).\n * \n * @return the number of characters in this alphabet\n */\n public int radix() {\n return R;\n }\n\n /**\n * Returns the binary logarithm of the number of characters in this alphabet.\n * \n * @return the binary logarithm (rounded up) of the number of characters in this alphabet\n */\n public int lgR() {\n int lgR = 0;\n for (int t = R-1; t >= 1; t /= 2)\n lgR++;\n return lgR;\n }\n\n /**\n * Returns the index corresponding to the argument character.\n * \n * @param c the character\n * @return the index corresponding to the character {@code c}\n * @throws IllegalArgumentException unless {@code c} is a character in this alphabet\n */\n public int toIndex(char c) {\n if (c >= inverse.length || inverse[c] == -1) {\n throw new IllegalArgumentException(\"Character \" + c + \" not in alphabet\");\n }\n return inverse[c];\n }\n\n /**\n * Returns the indices corresponding to the argument characters.\n * \n * @param s the characters\n * @return the indices corresponding to the characters {@code s}\n * @throws IllegalArgumentException unless every character in {@code s}\n * is a character in this alphabet\n */\n public int[] toIndices(String s) {\n char[] source = s.toCharArray();\n int[] target = new int[s.length()];\n for (int i = 0; i < source.length; i++)\n target[i] = toIndex(source[i]);\n return target;\n }\n\n /**\n * Returns the character corresponding to the argument index.\n * \n * @param index the index\n * @return the character corresponding to the index {@code index}\n * @throws IllegalArgumentException unless {@code 0 <= index < R}\n */\n public char toChar(int index) {\n if (index < 0 || index >= R) {\n throw new IllegalArgumentException(\"index must be between 0 and \" + R + \": \" + index);\n }\n return alphabet[index];\n }\n\n /**\n * Returns the characters corresponding to the argument indices.\n * \n * @param indices the indices\n * @return the characters corresponding to the indices {@code indices}\n * @throws IllegalArgumentException unless {@code 0 < indices[i] < R}\n * for every {@code i}\n */\n public String toChars(int[] indices) {\n StringBuilder s = new StringBuilder(indices.length);\n for (int i = 0; i < indices.length; i++)\n s.append(toChar(indices[i]));\n return s.toString();\n }\n\n /**\n * Unit tests the {@code Alphabet} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int[] encoded1 = Alphabet.BASE64.toIndices(\"NowIsTheTimeForAllGoodMen\");\n String decoded1 = Alphabet.BASE64.toChars(encoded1);\n StdOut.println(decoded1);\n \n int[] encoded2 = Alphabet.DNA.toIndices(\"AACGAACGGTTTACCCCG\");\n String decoded2 = Alphabet.DNA.toChars(encoded2);\n StdOut.println(decoded2);\n\n int[] encoded3 = Alphabet.DECIMAL.toIndices(\"01234567890123456789\");\n String decoded3 = Alphabet.DECIMAL.toChars(encoded3);\n StdOut.println(decoded3);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AmericanFlag.java",
"content": "/******************************************************************************\n * Compilation: javac AmericanFlag.java\n * Execution: java AmericanFlag < input.txt\n * java AmericanFlag int < input-non-negative-ints.txt\n * Dependencies: StdIn.java StdOut.java Stack.java\n * Data files: https://algs4.cs.princeton.edu/51radix/words3.txt\n * https://algs4.cs.princeton.edu/51radix/shells.txt\n *\n * Sort an array of strings or integers in-place using American flag sort.\n *\n * % java AmericanFlag < shells.txt\n * are\n * by\n * sea\n * seashells\n * seashells\n * sells\n * sells\n * she\n * she\n * shells\n * shore\n * surely\n * the\n * the\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AmericanFlag} class provides static methods for sorting an\n * array of extended ASCII strings or integers in-place using\n * American flag sort. This is a non-recursive implementation.\n *
\n * For additional documentation,\n * see Section 5.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne\n * and \n * Engineering Radix Sort by McIlroy and Bostic.\n * For a version that uses only one auxiliary array, see {@link AmericanFlagX}.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n * @author Ivan Pesin\n */\n\npublic class AmericanFlag {\n private static final int BITS_PER_BYTE = 8;\n private static final int BITS_PER_INT = 32; // each Java int is 32 bits\n private static final int R = 256; // extend ASCII alphabet size\n private static final int CUTOFF = 15; // cutoff to insertion sort\n\n // do not instantiate\n private AmericanFlag() { }\n\n // return dth character of s, -1 if d = length of string\n private static int charAt(String s, int d) {\n assert d >= 0 && d <= s.length();\n if (d == s.length()) return -1;\n return s.charAt(d);\n }\n\n /**\n * Rearranges the array of extended ASCII strings in ascending order.\n * This is an unstable sorting algorithm.\n *\n * @param a the array to be sorted\n */\n public static void sort(String[] a) {\n sort(a, 0, a.length - 1);\n }\n\n // sort from a[lo] to a[hi], starting at the dth character\n public static void sort(String[] a, int lo, int hi) {\n // one-time allocation of data structures\n Stack st = new Stack();\n int[] first = new int[R+2];\n int[] next = new int[R+2];\n int d = 0; // character index to sort by\n\n st.push(lo);\n st.push(hi);\n st.push(d);\n\n while (!st.isEmpty()) {\n d = st.pop();\n hi = st.pop();\n lo = st.pop();\n\n if (hi <= lo + CUTOFF) {\n insertion(a, lo, hi, d);\n continue;\n }\n\n // compute frequency counts\n for (int i = lo; i <= hi; i++) {\n int c = charAt(a[i], d) + 1; // account for -1 representing end-of-string\n first[c+1]++;\n }\n\n // first[c] = location of first string whose dth character = c\n first[0] = lo;\n for (int c = 0; c <= R; c++) {\n first[c+1] += first[c];\n\n if (c > 0 && first[c+1]-1 > first[c]) {\n // add subproblem for character c (excludes sentinel c == 0)\n st.push(first[c]);\n st.push(first[c+1] - 1);\n st.push(d+1);\n }\n }\n\n // next[c] = location to place next string whose dth character = c\n for (int c = 0; c < R+2; c++)\n next[c] = first[c];\n\n // permute data in place\n for (int k = lo; k <= hi; k++) {\n int c = charAt(a[k], d) + 1;\n while (first[c] > k) {\n exch(a, k, next[c]++);\n c = charAt(a[k], d) + 1;\n }\n next[c]++;\n }\n\n // clear first[] and next[] arrays\n for (int c = 0; c < R+2; c++) {\n first[c] = 0;\n next[c] = 0;\n }\n }\n }\n\n // insertion sort a[lo..hi], starting at dth character\n private static void insertion(String[] a, int lo, int hi, int d) {\n for (int i = lo; i <= hi; i++)\n for (int j = i; j > lo && less(a[j], a[j-1], d); j--)\n exch(a, j, j-1);\n }\n\n // exchange a[i] and a[j]\n private static void exch(String[] a, int i, int j) {\n String temp = a[i];\n a[i] = a[j];\n a[j] = temp;\n }\n\n // is v less than w, starting at character d\n private static boolean less(String v, String w, int d) {\n // assert v.substring(0, d).equals(w.substring(0, d));\n for (int i = d; i < Math.min(v.length(), w.length()); i++) {\n if (v.charAt(i) < w.charAt(i)) return true;\n if (v.charAt(i) > w.charAt(i)) return false;\n }\n return v.length() < w.length();\n }\n\n /**\n * Rearranges the array of 32-bit integers in ascending order.\n * Currently, assumes that the integers are nonnegative.\n *\n * @param a the array to be sorted\n */\n public static void sort(int[] a) {\n sort(a, 0, a.length-1);\n }\n\n // MSD sort from a[lo] to a[hi]\n private static void sort(int[] a, int lo, int hi) {\n // one-time allocation of data structures\n Stack st = new Stack();\n int[] first = new int[R+1];\n int[] next = new int[R+1];\n int mask = R - 1; // 0xFF;\n int d = 0; // byte to sort by\n\n st.push(lo);\n st.push(hi);\n st.push(d);\n\n while (!st.isEmpty()) {\n d = st.pop();\n hi = st.pop();\n lo = st.pop();\n\n if (hi <= lo + CUTOFF) {\n insertion(a, lo, hi, d);\n continue;\n }\n\n // compute frequency counts (need R = 256)\n int shift = BITS_PER_INT - BITS_PER_BYTE*d - BITS_PER_BYTE;\n for (int i = lo; i <= hi; i++) {\n int c = (a[i] >> shift) & mask;\n first[c+1]++;\n }\n\n // first[c] = location of first int whose dth byte = c\n first[0] = lo;\n for (int c = 0; c < R; c++) {\n first[c+1] += first[c];\n\n if (d < 3 && first[c+1]-1 > first[c]) {\n // add subproblem for byte c\n st.push(first[c]);\n st.push(first[c+1] - 1);\n st.push(d+1);\n }\n }\n\n // next[c] = location to place next string whose dth byte = c\n for (int c = 0; c < R+1; c++)\n next[c] = first[c];\n\n // permute data in place\n for (int k = lo; k <= hi; k++) {\n int c = (a[k] >> shift) & mask;\n while (first[c] > k) {\n exch(a, k, next[c]++);\n c = (a[k] >> shift) & mask;\n }\n next[c]++;\n }\n\n // clear first[] and next[] arrays\n for (int c = 0; c < R+1; c++) {\n first[c] = 0;\n next[c] = 0;\n }\n }\n }\n\n // insertion sort a[lo..hi], starting at dth byte\n private static void insertion(int[] a, int lo, int hi, int d) {\n for (int i = lo; i <= hi; i++)\n for (int j = i; j > lo && less(a[j], a[j-1], d); j--)\n exch(a, j, j-1);\n }\n\n // exchange a[i] and a[j]\n private static void exch(int[] a, int i, int j) {\n int temp = a[i];\n a[i] = a[j];\n a[j] = temp;\n }\n\n // is v less than w, starting at byte d\n private static boolean less(int v, int w, int d) {\n int mask = R - 1; // 0xFF;\n for (int i = d; i < 4; i++) {\n int shift = BITS_PER_INT - BITS_PER_BYTE*i - BITS_PER_BYTE;\n int a = (v >> shift) & mask;\n int b = (w >> shift) & mask;\n if (a < b) return true;\n if (a > b) return false;\n }\n return false;\n }\n\n /**\n * Reads in a sequence of extended ASCII strings or non-negative ints from standard input;\n * American flag sorts them;\n * and prints them to standard output in ascending order.\n *\n * @param args the command-line arguments: \"int\" to read input as non-negative integers\n */\n public static void main(String[] args) {\n if (args.length > 0 && args[0].equals(\"int\")) {\n int[] a = StdIn.readAllInts();\n sort(a);\n\n // print results\n for (int i = 0; i < a.length; i++)\n StdOut.println(a[i]);\n }\n\n else {\n String[] a = StdIn.readAllStrings();\n sort(a);\n // print results\n for (int i = 0; i < a.length; i++)\n StdOut.println(a[i]);\n }\n }\n}\n\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AmericanFlagX.java",
"content": "/******************************************************************************\n * Compilation: javac AmericanFlagX.java\n * Execution: java AmericanFlagX < input.txt\n * Dependencies: StdIn.java StdOut.java Stack.java\n * Data files: https://algs4.cs.princeton.edu/51radix/words3.txt\n * https://algs4.cs.princeton.edu/51radix/shells.txt\n *\n * Sort an array of strings or integers in-place using American Flag sort.\n *\n * % java AmericanFlagX < shells.txt\n * are\n * by\n * sea\n * seashells\n * seashells\n * sells\n * sells\n * she\n * she\n * shells\n * shore\n * surely\n * the\n * the\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AmericanFlagX} class provides static methods for sorting an\n * array of extended ASCII strings or integers in-place using\n * American Flag sort. This implementation is non-recursive and uses only\n * one auxiliary array.\n *
\n * For additional documentation,\n * see Section 5.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne\n * and \n * Engineering Radix Sort by McIlroy and Bostic.\n * For a version that uses two auxiliary arrays, see {@link AmericanFlag}.\n *\n * @author Ivan Pesin\n */\n\npublic class AmericanFlagX {\n private static final int R = 256; // extend ASCII alphabet size\n private static final int CUTOFF = 15; // cutoff to insertion sort\n\n // do not instantiate\n private AmericanFlagX() { }\n\n // return dth character of s, -1 if d = length of string\n private static int charAt(String s, int d) {\n assert d >= 0 && d <= s.length();\n if (d == s.length()) return -1;\n return s.charAt(d);\n }\n\n /**\n * Rearranges the array of extended ASCII strings in ascending order.\n * This is an unstable in-place sorting algorithm.\n *\n * @param a the array to be sorted\n */\n public static void sort(String[] a) {\n sort(a, 0, a.length - 1);\n }\n\n // sort from a[lo] to a[hi], starting at the dth character\n public static void sort(String[] a, int lo, int hi) {\n // one-time allocation of data structures\n Stack st = new Stack();\n int[] count = new int[R+1];\n int d = 0; // character index to sort by\n\n st.push(lo);\n st.push(hi);\n st.push(d);\n\n while (!st.isEmpty()) {\n d = st.pop();\n hi = st.pop();\n lo = st.pop();\n\n if (hi <= lo + CUTOFF) {\n insertion(a, lo, hi, d);\n continue;\n }\n\n // compute frequency counts\n for (int i = lo; i <= hi; i++) {\n int c = charAt(a[i], d) + 1; // account for -1 representing end-of-string\n count[c]++;\n }\n\n // accumulate counts relative to a[0], so that\n // count[c] is the number of keys <= c\n count[0] += lo;\n for (int c = 0; c < R; c++) {\n count[c+1] += count[c];\n\n if (c > 0 && count[c+1]-1 > count[c]) {\n // add subproblem for character c (excludes sentinel c == 0)\n st.push(count[c]);\n st.push(count[c+1]-1);\n st.push(d+1);\n }\n }\n\n // permute data in place\n // for details and proof see Knuth Theorem 5.1.2B and ch 5.2 exercise 13.\n for (int r = hi; r >= lo; r--) {\n\n // locate element that must be shifted right of r\n int c = charAt(a[r], d) + 1;\n while (r >= lo && count[c]-1 <= r) {\n if (count[c]-1 == r) count[c]--;\n r--;\n if (r >= lo) c = charAt(a[r], d) + 1;\n }\n\n // if r < lo the subarray is sorted.\n if (r < lo) break;\n\n // permute a[r] until correct element is in place\n while (--count[c] != r) {\n exch(a, r, count[c]);\n c = charAt(a[r], d) + 1;\n }\n }\n\n // clear count[] array\n for (int c = 0; c < R+1; c++)\n count[c] = 0;\n }\n }\n\n // insertion sort a[lo..hi], starting at dth character\n private static void insertion(String[] a, int lo, int hi, int d) {\n for (int i = lo; i <= hi; i++)\n for (int j = i; j > lo && less(a[j], a[j-1], d); j--)\n exch(a, j, j-1);\n }\n\n // exchange a[i] and a[j]\n private static void exch(String[] a, int i, int j) {\n String temp = a[i];\n a[i] = a[j];\n a[j] = temp;\n }\n\n // is v less than w, starting at character d\n private static boolean less(String v, String w, int d) {\n // assert v.substring(0, d).equals(w.substring(0, d));\n for (int i = d; i < Math.min(v.length(), w.length()); i++) {\n if (v.charAt(i) < w.charAt(i)) return true;\n if (v.charAt(i) > w.charAt(i)) return false;\n }\n return v.length() < w.length();\n }\n\n /**\n * Reads in a sequence of extended ASCII strings or non-negative ints from standard input;\n * American flag sorts them;\n * and prints them to standard output in ascending order.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n String[] a = StdIn.readAllStrings();\n sort(a);\n // print results\n for (int i = 0; i < a.length; i++)\n StdOut.println(a[i]);\n }\n}\n\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Arbitrage.java",
"content": "/******************************************************************************\n * Compilation: javac Arbitrage.java\n * Execution: java Arbitrage < input.txt\n * Dependencies: EdgeWeightedDigraph.java DirectedEdge.java\n * BellmanFordSP.java\n * Data file: https://algs4.cs.princeton.edu/44sp/rates.txt\n *\n * Arbitrage detection.\n *\n * % more rates.txt\n * 5\n * USD 1 0.741 0.657 1.061 1.005\n * EUR 1.349 1 0.888 1.433 1.366\n * GBP 1.521 1.126 1 1.614 1.538\n * CHF 0.942 0.698 0.619 1 0.953\n * CAD 0.995 0.732 0.650 1.049 1\n *\n * % java Arbitrage < rates.txt\n * 1000.00000 USD = 741.00000 EUR\n * 741.00000 EUR = 1012.20600 CAD\n * 1012.20600 CAD = 1007.14497 USD\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Arbitrage} class provides a client that finds an arbitrage\n * opportunity in a currency exchange table by constructing a\n * complete-digraph representation of the exchange table and then finding\n * a negative cycle in the digraph.\n *
\n * This implementation uses the Bellman-Ford algorithm to find a\n * negative cycle in the complete digraph.\n * The running time is proportional to V3 in the\n * worst case, where V is the number of currencies.\n *
\n * This code is guaranteed to find an arbitrage opportunity in a\n * currency exchange table (or report that no such arbitrage\n * opportunity exists) under the assumption that all arithmetic\n * performed is without floating-point rounding error or arithmetic\n * overflow. Since the code computes the logarithms of the edge weights,\n * floating-point rounding error will be present, and it may fail on\n * some pathological inputs.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Arbitrage {\n\n // this class cannot be instantiated\n private Arbitrage() { }\n\n /**\n * Reads the currency exchange table from standard input and\n * prints an arbitrage opportunity to standard output (if one exists).\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // V currencies\n int V = StdIn.readInt();\n String[] name = new String[V];\n\n // create complete network\n EdgeWeightedDigraph G = new EdgeWeightedDigraph(V);\n for (int v = 0; v < V; v++) {\n name[v] = StdIn.readString();\n for (int w = 0; w < V; w++) {\n double rate = StdIn.readDouble();\n DirectedEdge e = new DirectedEdge(v, w, -Math.log(rate));\n G.addEdge(e);\n }\n }\n\n // find negative cycle\n BellmanFordSP spt = new BellmanFordSP(G, 0);\n if (spt.hasNegativeCycle()) {\n double stake = 1000.0;\n for (DirectedEdge e : spt.negativeCycle()) {\n StdOut.printf(\"%10.5f %s \", stake, name[e.from()]);\n stake *= Math.exp(-e.weight());\n StdOut.printf(\"= %10.5f %s\\n\", stake, name[e.to()]);\n }\n }\n else {\n StdOut.println(\"No arbitrage opportunity\");\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/AssignmentProblem.java",
"content": "/******************************************************************************\n * Compilation: javac AssignmentProblem.java\n * Execution: java AssignmentProblem n\n * Dependencies: DijkstraSP.java DirectedEdge.java\n *\n * Solve an n-by-n assignment problem in n^3 log n time using the\n * successive shortest path algorithm.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code AssignmentProblem} class represents a data type for computing\n * an optimal solution to an n-by-nassignment problem.\n * The assignment problem is to find a minimum weight matching in an\n * edge-weighted complete bipartite graph.\n *
\n * The data type supplies methods for determining the optimal solution\n * and the corresponding dual solution.\n *
\n * This implementation uses the successive shortest paths algorithm.\n * The order of growth of the running time in the worst case is\n * O(n^3 log n) to solve an n-by-n\n * instance.\n *
\n * This computes correct results if all arithmetic performed is\n * without floating-point rounding error or arithmetic overflow.\n * This is the case if all edge weights are integers and if none of the\n * intermediate results exceeds 252.\n *
\n * For additional documentation, see\n * Section 6.5\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class AssignmentProblem {\n private static final double FLOATING_POINT_EPSILON = 1.0E-14;\n private static final int UNMATCHED = -1;\n\n private int n; // number of rows and columns\n private double[][] weight; // the n-by-n cost matrix\n private double minWeight; // minimum value of any weight\n private double[] px; // px[i] = dual variable for row i\n private double[] py; // py[j] = dual variable for col j\n private int[] xy; // xy[i] = j means i-j is a match\n private int[] yx; // yx[j] = i means i-j is a match\n\n /**\n * Determines an optimal solution to the assignment problem.\n *\n * @param weight the n-by-n matrix of weights\n * @throws IllegalArgumentException unless all weights are nonnegative\n * @throws IllegalArgumentException if {@code weight} is {@code null}\n */\n public AssignmentProblem(double[][] weight) {\n if (weight == null) throw new IllegalArgumentException(\"constructor argument is null\");\n\n n = weight.length;\n this.weight = new double[n][n];\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (Double.isNaN(weight[i][j]))\n throw new IllegalArgumentException(\"weight \" + i + \"-\" + j + \" is NaN\");\n if (weight[i][j] < minWeight) minWeight = weight[i][j];\n this.weight[i][j] = weight[i][j];\n }\n }\n\n // dual variables\n px = new double[n];\n py = new double[n];\n\n // initial matching is empty\n xy = new int[n];\n yx = new int[n];\n for (int i = 0; i < n; i++)\n xy[i] = UNMATCHED;\n for (int j = 0; j < n; j++)\n yx[j] = UNMATCHED;\n\n // add n edges to matching\n for (int k = 0; k < n; k++) {\n assert isDualFeasible();\n assert isComplementarySlack();\n augment();\n }\n assert certifySolution();\n }\n\n // find shortest augmenting path and update\n private void augment() {\n\n // build residual graph\n EdgeWeightedDigraph G = new EdgeWeightedDigraph(2*n+2);\n int s = 2*n, t = 2*n+1;\n for (int i = 0; i < n; i++) {\n if (xy[i] == UNMATCHED)\n G.addEdge(new DirectedEdge(s, i, 0.0));\n }\n for (int j = 0; j < n; j++) {\n if (yx[j] == UNMATCHED)\n G.addEdge(new DirectedEdge(n+j, t, py[j]));\n }\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (xy[i] == j) G.addEdge(new DirectedEdge(n+j, i, 0.0));\n else G.addEdge(new DirectedEdge(i, n+j, reducedCost(i, j)));\n }\n }\n\n // compute shortest path from s to every other vertex\n DijkstraSP spt = new DijkstraSP(G, s);\n\n // augment along alternating path\n for (DirectedEdge e : spt.pathTo(t)) {\n int i = e.from(), j = e.to() - n;\n if (i < n) {\n xy[i] = j;\n yx[j] = i;\n }\n }\n\n // update dual variables\n for (int i = 0; i < n; i++)\n px[i] += spt.distTo(i);\n for (int j = 0; j < n; j++)\n py[j] += spt.distTo(n+j);\n }\n\n // reduced cost of i-j\n // (subtracting off minWeight re-weights all weights to be non-negative)\n private double reducedCost(int i, int j) {\n double reducedCost = (weight[i][j] - minWeight) + px[i] - py[j];\n\n // to avoid issues with floating-point precision\n double magnitude = Math.abs(weight[i][j]) + Math.abs(px[i]) + Math.abs(py[j]);\n if (Math.abs(reducedCost) <= FLOATING_POINT_EPSILON * magnitude) return 0.0;\n\n assert reducedCost >= 0.0;\n return reducedCost;\n }\n\n /**\n * Returns the dual optimal value for the specified row.\n *\n * @param i the row index\n * @return the dual optimal value for row {@code i}\n * @throws IllegalArgumentException unless {@code 0 <= i < n}\n *\n */\n // dual variable for row i\n public double dualRow(int i) {\n validate(i);\n return px[i];\n }\n\n /**\n * Returns the dual optimal value for the specified column.\n *\n * @param j the column index\n * @return the dual optimal value for column {@code j}\n * @throws IllegalArgumentException unless {@code 0 <= j < n}\n *\n */\n public double dualCol(int j) {\n validate(j);\n return py[j];\n }\n\n /**\n * Returns the column associated with the specified row in the optimal solution.\n *\n * @param i the row index\n * @return the column matched to row {@code i} in the optimal solution\n * @throws IllegalArgumentException unless {@code 0 <= i < n}\n *\n */\n public int sol(int i) {\n validate(i);\n return xy[i];\n }\n\n /**\n * Returns the total weight of the optimal solution\n *\n * @return the total weight of the optimal solution\n *\n */\n public double weight() {\n double total = 0.0;\n for (int i = 0; i < n; i++) {\n if (xy[i] != UNMATCHED)\n total += weight[i][xy[i]];\n }\n return total;\n }\n\n private void validate(int i) {\n if (i < 0 || i >= n) throw new IllegalArgumentException(\"index is not between 0 and \" + (n-1) + \": \" + i);\n }\n\n\n /**************************************************************************\n *\n * The code below is solely for testing correctness of the data type.\n *\n **************************************************************************/\n\n // check that dual variables are feasible\n private boolean isDualFeasible() {\n // check that all edges have >= 0 reduced cost\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (reducedCost(i, j) < 0) {\n StdOut.println(\"Dual variables are not feasible\");\n return false;\n }\n }\n }\n return true;\n }\n\n // check that primal and dual variables are complementary slack\n private boolean isComplementarySlack() {\n\n // check that all matched edges have 0-reduced cost\n for (int i = 0; i < n; i++) {\n if ((xy[i] != UNMATCHED) && (reducedCost(i, xy[i]) != 0)) {\n StdOut.println(\"Primal and dual variables are not complementary slack\");\n return false;\n }\n }\n return true;\n }\n\n // check that primal variables are a perfect matching\n private boolean isPerfectMatching() {\n\n // check that xy[] is a perfect matching\n boolean[] perm = new boolean[n];\n for (int i = 0; i < n; i++) {\n if (perm[xy[i]]) {\n StdOut.println(\"Not a perfect matching\");\n return false;\n }\n perm[xy[i]] = true;\n }\n\n // check that xy[] and yx[] are inverses\n for (int j = 0; j < n; j++) {\n if (xy[yx[j]] != j) {\n StdOut.println(\"xy[] and yx[] are not inverses\");\n return false;\n }\n }\n for (int i = 0; i < n; i++) {\n if (yx[xy[i]] != i) {\n StdOut.println(\"xy[] and yx[] are not inverses\");\n return false;\n }\n }\n\n return true;\n }\n\n // check optimality conditions\n private boolean certifySolution() {\n return isPerfectMatching() && isDualFeasible() && isComplementarySlack();\n }\n\n /**\n * Unit tests the {@code AssignmentProblem} data type.\n * Takes a command-line argument n; creates a random n-by-n matrix;\n * solves the n-by-n assignment problem; and prints the optimal\n * solution.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // create random n-by-n matrix\n int n = Integer.parseInt(args[0]);\n double[][] weight = new double[n][n];\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n weight[i][j] = StdRandom.uniformInt(900) + 100; // 3 digits\n }\n }\n\n // solve assignment problem\n AssignmentProblem assignment = new AssignmentProblem(weight);\n StdOut.printf(\"weight = %.0f\\n\", assignment.weight());\n StdOut.println();\n\n // print n-by-n matrix and optimal solution\n if (n >= 20) return;\n for (int i = 0; i < n; i++) {\n for (int j = 0; j < n; j++) {\n if (j == assignment.sol(i))\n StdOut.printf(\"*%.0f \", weight[i][j]);\n else\n StdOut.printf(\" %.0f \", weight[i][j]);\n }\n StdOut.println();\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Average.java",
"content": "/******************************************************************************\n * Compilation: javac Average.java\n * Execution: java Average < data.txt\n * Dependencies: StdIn.java StdOut.java\n *\n * Reads in a sequence of real numbers, and computes their average.\n *\n * % java Average\n * 10.0 5.0 6.0\n * 3.0 7.0 32.0\n * [Ctrl-d]\n * Average is 10.5\n *\n * Note [Ctrl-d] signifies the end of file on Unix.\n * On windows use [Ctrl-z].\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Average} class provides a client for reading in a sequence\n * of real numbers and printing out their average.\n *
\n * For additional documentation, see Section 1.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Average {\n\n // this class should not be instantiated\n private Average() { }\n\n /**\n * Reads in a sequence of real numbers from standard input and prints\n * out their average to standard output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int count = 0; // number input values\n double sum = 0.0; // sum of input values\n\n // read data and compute statistics\n while (!StdIn.isEmpty()) {\n double value = StdIn.readDouble();\n sum += value;\n count++;\n }\n\n // compute the average\n double average = sum / count;\n\n // print results\n StdOut.println(\"Average is \" + average);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BST.java",
"content": "/******************************************************************************\n * Compilation: javac BST.java\n * Execution: java BST\n * Dependencies: StdIn.java StdOut.java Queue.java\n * Data files: https://algs4.cs.princeton.edu/32bst/tinyST.txt\n *\n * A symbol table implemented with a binary search tree.\n *\n * % more tinyST.txt\n * S E A R C H E X A M P L E\n *\n * % java BST < tinyST.txt\n * A 8\n * C 4\n * E 12\n * H 5\n * L 11\n * M 9\n * P 10\n * R 3\n * S 0\n * X 7\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code BST} class represents an ordered symbol table of generic\n * key-value pairs.\n * It supports the usual put, get, contains,\n * delete, size, and is-empty methods.\n * It also provides ordered methods for finding the minimum,\n * maximum, floor, select, ceiling.\n * It also provides a keys method for iterating over all of the keys.\n * A symbol table implements the associative array abstraction:\n * when associating a value with a key that is already in the symbol table,\n * the convention is to replace the old value with the new value.\n * Unlike {@link java.util.Map}, this class uses the convention that\n * values cannot be {@code null}—setting the\n * value associated with a key to {@code null} is equivalent to deleting the key\n * from the symbol table.\n *
\n * It requires that\n * the key type implements the {@code Comparable} interface and calls the\n * {@code compareTo()} and method to compare two keys. It does not call either\n * {@code equals()} or {@code hashCode()}.\n *
\n * This implementation uses an (unbalanced) binary search tree.\n * The put, contains, remove, minimum,\n * maximum, ceiling, floor, select, and\n * rank operations each take Θ(n) time in the worst\n * case, where n is the number of key-value pairs.\n * The size and is-empty operations take Θ(1) time.\n * The keys method takes Θ(n) time in the worst case.\n * Construction takes Θ(1) time.\n *
\n * For alternative implementations of the symbol table API, see {@link ST},\n * {@link BinarySearchST}, {@link SequentialSearchST}, {@link RedBlackBST},\n * {@link SeparateChainingHashST}, and {@link LinearProbingHashST},\n * For additional documentation, see\n * Section 3.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BST, Value> {\n private Node root; // root of BST\n\n private class Node {\n private Key key; // sorted by key\n private Value val; // associated data\n private Node left, right; // left and right subtrees\n private int size; // number of nodes in subtree\n\n public Node(Key key, Value val, int size) {\n this.key = key;\n this.val = val;\n this.size = size;\n }\n }\n\n /**\n * Initializes an empty symbol table.\n */\n public BST() {\n }\n\n /**\n * Returns true if this symbol table is empty.\n * @return {@code true} if this symbol table is empty; {@code false} otherwise\n */\n public boolean isEmpty() {\n return size() == 0;\n }\n\n /**\n * Returns the number of key-value pairs in this symbol table.\n * @return the number of key-value pairs in this symbol table\n */\n public int size() {\n return size(root);\n }\n\n // return number of key-value pairs in BST rooted at x\n private int size(Node node) {\n if (node == null) return 0;\n else return node.size;\n }\n\n /**\n * Does this symbol table contain the given key?\n *\n * @param key the key\n * @return {@code true} if this symbol table contains {@code key} and\n * {@code false} otherwise\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public boolean contains(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to contains() is null\");\n return get(key) != null;\n }\n\n /**\n * Returns the value associated with the given key.\n *\n * @param key the key\n * @return the value associated with the given key if the key is in the symbol table\n * and {@code null} if the key is not in the symbol table\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Value get(Key key) {\n return get(root, key);\n }\n\n private Value get(Node node, Key key) {\n if (key == null) throw new IllegalArgumentException(\"calls get() with a null key\");\n if (node == null) return null;\n int cmp = key.compareTo(node.key);\n if (cmp < 0) return get(node.left, key);\n else if (cmp > 0) return get(node.right, key);\n else return node.val;\n }\n\n /**\n * Inserts the specified key-value pair into the symbol table, overwriting the old\n * value with the new value if the symbol table already contains the specified key.\n * Deletes the specified key (and its associated value) from this symbol table\n * if the specified value is {@code null}.\n *\n * @param key the key\n * @param val the value\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void put(Key key, Value val) {\n if (key == null) throw new IllegalArgumentException(\"calls put() with a null key\");\n if (val == null) {\n delete(key);\n return;\n }\n root = put(root, key, val);\n assert check();\n }\n\n private Node put(Node node, Key key, Value val) {\n if (node == null) return new Node(key, val, 1);\n int cmp = key.compareTo(node.key);\n if (cmp < 0) node.left = put(node.left, key, val);\n else if (cmp > 0) node.right = put(node.right, key, val);\n else node.val = val;\n node.size = 1 + size(node.left) + size(node.right);\n return node;\n }\n\n\n /**\n * Removes the smallest key and associated value from the symbol table.\n *\n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMin() {\n if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow\");\n root = deleteMin(root);\n assert check();\n }\n\n private Node deleteMin(Node node) {\n if (node.left == null) return node.right;\n node.left = deleteMin(node.left);\n node.size = size(node.left) + size(node.right) + 1;\n return node;\n }\n\n /**\n * Removes the largest key and associated value from the symbol table.\n *\n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMax() {\n if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow\");\n root = deleteMax(root);\n assert check();\n }\n\n private Node deleteMax(Node node) {\n if (node.right == null) return node.left;\n node.right = deleteMax(node.right);\n node.size = size(node.left) + size(node.right) + 1;\n return node;\n }\n\n /**\n * Removes the specified key and its associated value from this symbol table\n * (if the key is in this symbol table).\n *\n * @param key the key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void delete(Key key) {\n if (key == null) throw new IllegalArgumentException(\"calls delete() with a null key\");\n root = delete(root, key);\n assert check();\n }\n\n private Node delete(Node node, Key key) {\n if (node == null) return null;\n\n int cmp = key.compareTo(node.key);\n if (cmp < 0) node.left = delete(node.left, key);\n else if (cmp > 0) node.right = delete(node.right, key);\n else {\n if (node.right == null) return node.left;\n if (node.left == null) return node.right;\n Node temp = node;\n node = min(temp.right);\n node.right = deleteMin(temp.right);\n node.left = temp.left;\n }\n node.size = size(node.left) + size(node.right) + 1;\n return node;\n }\n\n\n /**\n * Returns the smallest key in the symbol table.\n *\n * @return the smallest key in the symbol table\n * @throws NoSuchElementException if the symbol table is empty\n */\n public Key min() {\n if (isEmpty()) throw new NoSuchElementException(\"calls min() with empty symbol table\");\n return min(root).key;\n }\n\n private Node min(Node node) {\n if (node.left == null) return node;\n else return min(node.left);\n }\n\n /**\n * Returns the largest key in the symbol table.\n *\n * @return the largest key in the symbol table\n * @throws NoSuchElementException if the symbol table is empty\n */\n public Key max() {\n if (isEmpty()) throw new NoSuchElementException(\"calls max() with empty symbol table\");\n return max(root).key;\n }\n\n private Node max(Node node) {\n if (node.right == null) return node;\n else return max(node.right);\n }\n\n /**\n * Returns the largest key in the symbol table less than or equal to {@code key}.\n *\n * @param key the key\n * @return the largest key in the symbol table less than or equal to {@code key}\n * @throws NoSuchElementException if there is no such key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key floor(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to floor() is null\");\n if (isEmpty()) throw new NoSuchElementException(\"calls floor() with empty symbol table\");\n Node node = floor(root, key);\n if (node == null) throw new NoSuchElementException(\"argument to floor() is too small\");\n else return node.key;\n }\n\n private Node floor(Node node, Key key) {\n if (node == null) return null;\n int cmp = key.compareTo(node.key);\n if (cmp == 0) return node;\n if (cmp < 0) return floor(node.left, key);\n Node t = floor(node.right, key);\n if (t != null) return t;\n else return node;\n }\n\n public Key floor2(Key key) {\n Key floor = floor2(root, key, null);\n if (floor == null) throw new NoSuchElementException(\"argument to floor() is too small\");\n else return floor;\n\n }\n\n private Key floor2(Node node, Key key, Key champ) {\n if (node == null) return champ;\n int cmp = key.compareTo(node.key);\n if (cmp < 0) return floor2(node.left, key, champ);\n else if (cmp > 0) return floor2(node.right, key, node.key);\n else return node.key;\n }\n\n /**\n * Returns the smallest key in the symbol table greater than or equal to {@code key}.\n *\n * @param key the key\n * @return the smallest key in the symbol table greater than or equal to {@code key}\n * @throws NoSuchElementException if there is no such key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key ceiling(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to ceiling() is null\");\n if (isEmpty()) throw new NoSuchElementException(\"calls ceiling() with empty symbol table\");\n Node node = ceiling(root, key);\n if (node == null) throw new NoSuchElementException(\"argument to ceiling() is too large\");\n else return node.key;\n }\n\n private Node ceiling(Node node, Key key) {\n if (node == null) return null;\n int cmp = key.compareTo(node.key);\n if (cmp == 0) return node;\n if (cmp < 0) {\n Node t = ceiling(node.left, key);\n if (t != null) return t;\n else return node;\n }\n return ceiling(node.right, key);\n }\n\n /**\n * Return the key in the symbol table of a given {@code rank}.\n * This key has the property that there are {@code rank} keys in\n * the symbol table that are smaller. In other words, this key is the\n * ({@code rank}+1)st smallest key in the symbol table.\n *\n * @param rank the order statistic\n * @return the key in the symbol table of given {@code rank}\n * @throws IllegalArgumentException unless {@code rank} is between 0 and\n * n–1\n */\n public Key select(int rank) {\n if (rank < 0 || rank >= size()) {\n throw new IllegalArgumentException(\"argument to select() is invalid: \" + rank);\n }\n return select(root, rank);\n }\n\n // Return key in BST rooted at x of given rank.\n // Precondition: rank is in legal range.\n private Key select(Node node, int rank) {\n if (node == null) return null;\n int leftSize = size(node.left);\n if (leftSize > rank) return select(node.left, rank);\n else if (leftSize < rank) return select(node.right, rank - leftSize - 1);\n else return node.key;\n }\n\n /**\n * Return the number of keys in the symbol table strictly less than {@code key}.\n *\n * @param key the key\n * @return the number of keys in the symbol table strictly less than {@code key}\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public int rank(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to rank() is null\");\n return rank(key, root);\n }\n\n // Number of keys in the subtree less than key.\n private int rank(Key key, Node node) {\n if (node == null) return 0;\n int cmp = key.compareTo(node.key);\n if (cmp < 0) return rank(key, node.left);\n else if (cmp > 0) return 1 + size(node.left) + rank(key, node.right);\n else return size(node.left);\n }\n\n /**\n * Returns all keys in the symbol table in ascending order,\n * as an {@code Iterable}.\n * To iterate over all of the keys in the symbol table named {@code st},\n * use the foreach notation: {@code for (Key key : st.keys())}.\n *\n * @return all keys in the symbol table in ascending order\n */\n public Iterable keys() {\n if (isEmpty()) return new Queue();\n return keys(min(), max());\n }\n\n /**\n * Returns all keys in the symbol table in the given range\n * in ascending order, as an {@code Iterable}.\n *\n * @param lo minimum endpoint\n * @param hi maximum endpoint\n * @return all keys in the symbol table between {@code lo}\n * (inclusive) and {@code hi} (inclusive) in ascending order\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public Iterable keys(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to keys() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to keys() is null\");\n\n Queue queue = new Queue();\n keys(root, queue, lo, hi);\n return queue;\n }\n\n private void keys(Node node, Queue queue, Key lo, Key hi) {\n if (node == null) return;\n int cmplo = lo.compareTo(node.key);\n int cmphi = hi.compareTo(node.key);\n if (cmplo < 0) keys(node.left, queue, lo, hi);\n if (cmplo <= 0 && cmphi >= 0) queue.enqueue(node.key);\n if (cmphi > 0) keys(node.right, queue, lo, hi);\n }\n\n /**\n * Returns the number of keys in the symbol table in the given range.\n *\n * @param lo minimum endpoint\n * @param hi maximum endpoint\n * @return the number of keys in the symbol table between {@code lo}\n * (inclusive) and {@code hi} (inclusive)\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public int size(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to size() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to size() is null\");\n\n if (lo.compareTo(hi) > 0) return 0;\n if (contains(hi)) return rank(hi) - rank(lo) + 1;\n else return rank(hi) - rank(lo);\n }\n\n /**\n * Returns the height of the BST (for debugging).\n *\n * @return the height of the BST (a 1-node tree has height 0)\n */\n public int height() {\n return height(root);\n }\n private int height(Node node) {\n if (node == null) return -1;\n return 1 + Math.max(height(node.left), height(node.right));\n }\n\n /**\n * Returns the keys in the BST in level order (for debugging).\n *\n * @return the keys in the BST in level order traversal\n */\n public Iterable levelOrder() {\n Queue keys = new Queue();\n Queue queue = new Queue();\n queue.enqueue(root);\n while (!queue.isEmpty()) {\n Node node = queue.dequeue();\n if (node == null) continue;\n keys.enqueue(node.key);\n queue.enqueue(node.left);\n queue.enqueue(node.right);\n }\n return keys;\n }\n\n /*************************************************************************\n * Check integrity of BST data structure.\n ***************************************************************************/\n private boolean check() {\n if (!isBST()) StdOut.println(\"Not in symmetric order\");\n if (!isSizeConsistent()) StdOut.println(\"Subtree counts not consistent\");\n if (!isRankConsistent()) StdOut.println(\"Ranks not consistent\");\n return isBST() && isSizeConsistent() && isRankConsistent();\n }\n\n // does this binary tree satisfy symmetric order?\n // Note: this test also ensures that data structure is a binary tree since order is strict\n private boolean isBST() {\n return isBST(root, null, null);\n }\n\n // is the tree rooted at x a BST with all keys strictly between min and max\n // (if min or max is null, treat as empty constraint)\n // Credit: elegant solution due to Bob Dondero\n private boolean isBST(Node node, Key min, Key max) {\n if (node == null) return true;\n if (min != null && node.key.compareTo(min) <= 0) return false;\n if (max != null && node.key.compareTo(max) >= 0) return false;\n return isBST(node.left, min, node.key) && isBST(node.right, node.key, max);\n }\n\n // are the size fields correct?\n private boolean isSizeConsistent() { return isSizeConsistent(root); }\n private boolean isSizeConsistent(Node node) {\n if (node == null) return true;\n if (node.size != size(node.left) + size(node.right) + 1) return false;\n return isSizeConsistent(node.left) && isSizeConsistent(node.right);\n }\n\n // check that ranks are consistent\n private boolean isRankConsistent() {\n for (int i = 0; i < size(); i++)\n if (i != rank(select(i))) return false;\n for (Key key : keys())\n if (key.compareTo(select(rank(key))) != 0) return false;\n return true;\n }\n\n\n /**\n * Unit tests the {@code BST} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n BST st = new BST();\n for (int i = 0; !StdIn.isEmpty(); i++) {\n String key = StdIn.readString();\n st.put(key, i);\n }\n\n for (String s : st.levelOrder())\n StdOut.println(s + \" \" + st.get(s));\n\n StdOut.println();\n\n for (String s : st.keys())\n StdOut.println(s + \" \" + st.get(s));\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BTree.java",
"content": "/******************************************************************************\n * Compilation: javac BTree.java\n * Execution: java BTree\n * Dependencies: StdOut.java\n *\n * B-tree.\n *\n * Limitations\n * -----------\n * - Assumes M is even and M >= 4\n * - should b be an array of children or list (it would help with\n * casting to make it a list)\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BTree} class represents an ordered symbol table of generic\n * key-value pairs.\n * It supports the put, get, contains,\n * size, and is-empty methods.\n * A symbol table implements the associative array abstraction:\n * when associating a value with a key that is already in the symbol table,\n * the convention is to replace the old value with the new value.\n * Unlike {@link java.util.Map}, this class uses the convention that\n * values cannot be {@code null}—setting the\n * value associated with a key to {@code null} is equivalent to deleting the key\n * from the symbol table.\n *
\n * This implementation uses a B-tree. It requires that\n * the key type implements the {@code Comparable} interface and calls the\n * {@code compareTo()} and method to compare two keys. It does not call either\n * {@code equals()} or {@code hashCode()}.\n * The get, put, and contains operations\n * each make logm(n) probes in the worst case,\n * where n is the number of key-value pairs\n * and m is the branching factor.\n * The size, and is-empty operations take constant time.\n * Construction takes constant time.\n *
\n * For additional documentation, see\n * Section 6.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n */\npublic class BTree, Value> {\n // max children per B-tree node = M-1\n // (must be even and greater than 2)\n private static final int M = 4;\n\n private Node root; // root of the B-tree\n private int height; // height of the B-tree\n private int n; // number of key-value pairs in the B-tree\n\n // helper B-tree node data type\n private static final class Node {\n private int m; // number of children\n private Entry[] children = new Entry[M]; // the array of children\n\n // create a node with k children\n private Node(int k) {\n m = k;\n }\n }\n\n // internal nodes: only use key and next\n // external nodes: only use key and value\n private static class Entry {\n private Comparable key;\n private Object val;\n private Node next; // helper field to iterate over array entries\n public Entry(Comparable key, Object val, Node next) {\n this.key = key;\n this.val = val;\n this.next = next;\n }\n }\n\n /**\n * Initializes an empty B-tree.\n */\n public BTree() {\n root = new Node(0);\n }\n\n /**\n * Returns true if this symbol table is empty.\n * @return {@code true} if this symbol table is empty; {@code false} otherwise\n */\n public boolean isEmpty() {\n return size() == 0;\n }\n\n /**\n * Returns the number of key-value pairs in this symbol table.\n * @return the number of key-value pairs in this symbol table\n */\n public int size() {\n return n;\n }\n\n /**\n * Returns the height of this B-tree (for debugging).\n *\n * @return the height of this B-tree\n */\n public int height() {\n return height;\n }\n\n\n /**\n * Returns the value associated with the given key.\n *\n * @param key the key\n * @return the value associated with the given key if the key is in the symbol table\n * and {@code null} if the key is not in the symbol table\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Value get(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to get() is null\");\n return search(root, key, height);\n }\n\n private Value search(Node x, Key key, int ht) {\n Entry[] children = x.children;\n\n // external node\n if (ht == 0) {\n for (int j = 0; j < x.m; j++) {\n if (eq(key, children[j].key)) return (Value) children[j].val;\n }\n }\n\n // internal node\n else {\n for (int j = 0; j < x.m; j++) {\n if (j+1 == x.m || less(key, children[j+1].key))\n return search(children[j].next, key, ht-1);\n }\n }\n return null;\n }\n\n\n /**\n * Inserts the key-value pair into the symbol table, overwriting the old value\n * with the new value if the key is already in the symbol table.\n * If the value is {@code null}, this effectively deletes the key from the symbol table.\n *\n * @param key the key\n * @param val the value\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void put(Key key, Value val) {\n if (key == null) throw new IllegalArgumentException(\"argument key to put() is null\");\n Node u = insert(root, key, val, height);\n n++;\n if (u == null) return;\n\n // need to split root\n Node t = new Node(2);\n t.children[0] = new Entry(root.children[0].key, null, root);\n t.children[1] = new Entry(u.children[0].key, null, u);\n root = t;\n height++;\n }\n\n private Node insert(Node h, Key key, Value val, int ht) {\n int j;\n Entry t = new Entry(key, val, null);\n\n // external node\n if (ht == 0) {\n for (j = 0; j < h.m; j++) {\n if (less(key, h.children[j].key)) break;\n }\n }\n\n // internal node\n else {\n for (j = 0; j < h.m; j++) {\n if ((j+1 == h.m) || less(key, h.children[j+1].key)) {\n Node u = insert(h.children[j++].next, key, val, ht-1);\n if (u == null) return null;\n t.key = u.children[0].key;\n t.val = null;\n t.next = u;\n break;\n }\n }\n }\n\n for (int i = h.m; i > j; i--)\n h.children[i] = h.children[i-1];\n h.children[j] = t;\n h.m++;\n if (h.m < M) return null;\n else return split(h);\n }\n\n // split node in half\n private Node split(Node h) {\n Node t = new Node(M/2);\n h.m = M/2;\n for (int j = 0; j < M/2; j++)\n t.children[j] = h.children[M/2+j];\n return t;\n }\n\n /**\n * Returns a string representation of this B-tree (for debugging).\n *\n * @return a string representation of this B-tree.\n */\n public String toString() {\n return toString(root, height, \"\") + \"\\n\";\n }\n\n private String toString(Node h, int ht, String indent) {\n StringBuilder s = new StringBuilder();\n Entry[] children = h.children;\n\n if (ht == 0) {\n for (int j = 0; j < h.m; j++) {\n s.append(indent + children[j].key + \" \" + children[j].val + \"\\n\");\n }\n }\n else {\n for (int j = 0; j < h.m; j++) {\n if (j > 0) s.append(indent + \"(\" + children[j].key + \")\\n\");\n s.append(toString(children[j].next, ht-1, indent + \" \"));\n }\n }\n return s.toString();\n }\n\n\n // comparison functions - make Comparable instead of Key to avoid casts\n private boolean less(Comparable k1, Comparable k2) {\n return k1.compareTo(k2) < 0;\n }\n\n private boolean eq(Comparable k1, Comparable k2) {\n return k1.compareTo(k2) == 0;\n }\n\n\n /**\n * Unit tests the {@code BTree} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n BTree st = new BTree();\n\n st.put(\"www.cs.princeton.edu\", \"128.112.136.12\");\n st.put(\"www.cs.princeton.edu\", \"128.112.136.11\");\n st.put(\"www.princeton.edu\", \"128.112.128.15\");\n st.put(\"www.yale.edu\", \"130.132.143.21\");\n st.put(\"www.simpsons.com\", \"209.052.165.60\");\n st.put(\"www.apple.com\", \"17.112.152.32\");\n st.put(\"www.amazon.com\", \"207.171.182.16\");\n st.put(\"www.ebay.com\", \"66.135.192.87\");\n st.put(\"www.cnn.com\", \"64.236.16.20\");\n st.put(\"www.google.com\", \"216.239.41.99\");\n st.put(\"www.nytimes.com\", \"199.239.136.200\");\n st.put(\"www.microsoft.com\", \"207.126.99.140\");\n st.put(\"www.dell.com\", \"143.166.224.230\");\n st.put(\"www.slashdot.org\", \"66.35.250.151\");\n st.put(\"www.espn.com\", \"199.181.135.201\");\n st.put(\"www.weather.com\", \"63.111.66.11\");\n st.put(\"www.yahoo.com\", \"216.109.118.65\");\n\n\n StdOut.println(\"cs.princeton.edu: \" + st.get(\"www.cs.princeton.edu\"));\n StdOut.println(\"hardvardsucks.com: \" + st.get(\"www.harvardsucks.com\"));\n StdOut.println(\"simpsons.com: \" + st.get(\"www.simpsons.com\"));\n StdOut.println(\"apple.com: \" + st.get(\"www.apple.com\"));\n StdOut.println(\"ebay.com: \" + st.get(\"www.ebay.com\"));\n StdOut.println(\"dell.com: \" + st.get(\"www.dell.com\"));\n StdOut.println();\n\n StdOut.println(\"size: \" + st.size());\n StdOut.println(\"height: \" + st.height());\n StdOut.println(st);\n StdOut.println();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Bag.java",
"content": "/******************************************************************************\n * Compilation: javac Bag.java\n * Execution: java Bag < input.txt\n * Dependencies: StdIn.java StdOut.java\n *\n * A generic bag or multiset, implemented using a singly linked list.\n *\n * % more tobe.txt\n * to be or not to - be - - that - - - is\n *\n * % java Bag < tobe.txt\n * size of bag = 14\n * is\n * -\n * -\n * -\n * that\n * -\n * -\n * be\n * -\n * to\n * not\n * or\n * be\n * to\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.Iterator;\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code Bag} class represents a bag (or multiset) of\n * generic items. It supports insertion and iterating over the\n * items in arbitrary order.\n *
\n * This implementation uses a singly linked list with a static nested class Node.\n * See {@link LinkedBag} for the version from the\n * textbook that uses a non-static nested class.\n * See {@link ResizingArrayBag} for a version that uses a resizing array.\n * The add, isEmpty, and size operations\n * take constant time. Iteration takes time proportional to the number of items.\n *
\n * For additional documentation, see Section 1.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n *\n * @param the generic type of each item in this bag\n */\npublic class Bag implements Iterable {\n private Node first; // beginning of bag\n private int n; // number of elements in bag\n\n // helper linked list class\n private static class Node {\n private Item item;\n private Node next;\n }\n\n /**\n * Initializes an empty bag.\n */\n public Bag() {\n first = null;\n n = 0;\n }\n\n /**\n * Returns true if this bag is empty.\n *\n * @return {@code true} if this bag is empty;\n * {@code false} otherwise\n */\n public boolean isEmpty() {\n return first == null;\n }\n\n /**\n * Returns the number of items in this bag.\n *\n * @return the number of items in this bag\n */\n public int size() {\n return n;\n }\n\n /**\n * Adds the item to this bag.\n *\n * @param item the item to add to this bag\n */\n public void add(Item item) {\n Node oldfirst = first;\n first = new Node();\n first.item = item;\n first.next = oldfirst;\n n++;\n }\n\n\n /**\n * Returns an iterator that iterates over the items in this bag in arbitrary order.\n *\n * @return an iterator that iterates over the items in this bag in arbitrary order\n */\n public Iterator iterator() {\n return new LinkedIterator(first);\n }\n\n private class LinkedIterator implements Iterator {\n private Node current;\n\n public LinkedIterator(Node first) {\n current = first;\n }\n\n public boolean hasNext() {\n return current != null;\n }\n\n public Item next() {\n if (!hasNext()) throw new NoSuchElementException();\n Item item = current.item;\n current = current.next;\n return item;\n }\n }\n\n /**\n * Unit tests the {@code Bag} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Bag bag = new Bag();\n while (!StdIn.isEmpty()) {\n String item = StdIn.readString();\n bag.add(item);\n }\n\n StdOut.println(\"size of bag = \" + bag.size());\n for (String s : bag) {\n StdOut.println(s);\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BellmanFordSP.java",
"content": "/******************************************************************************\n * Compilation: javac BellmanFordSP.java\n * Execution: java BellmanFordSP filename.txt s\n * Dependencies: EdgeWeightedDigraph.java DirectedEdge.java Queue.java\n * EdgeWeightedDirectedCycle.java\n * Data files: https://algs4.cs.princeton.edu/44sp/tinyEWDn.txt\n * https://algs4.cs.princeton.edu/44sp/tinyEWDnc.txt\n * https://algs4.cs.princeton.edu/44sp/mediumEWD.txt\n * https://algs4.cs.princeton.edu/44sp/largeEWD.txt\n *\n * Bellman-Ford shortest path algorithm. Computes the shortest path tree in\n * edge-weighted digraph G from vertex s, or finds a negative cost cycle\n * reachable from s.\n *\n * % java BellmanFordSP tinyEWDn.txt 0\n * 0 to 0 ( 0.00)\n * 0 to 1 ( 0.93) 0->2 0.26 2->7 0.34 7->3 0.39 3->6 0.52 6->4 -1.25 4->5 0.35 5->1 0.32\n * 0 to 2 ( 0.26) 0->2 0.26\n * 0 to 3 ( 0.99) 0->2 0.26 2->7 0.34 7->3 0.39\n * 0 to 4 ( 0.26) 0->2 0.26 2->7 0.34 7->3 0.39 3->6 0.52 6->4 -1.25\n * 0 to 5 ( 0.61) 0->2 0.26 2->7 0.34 7->3 0.39 3->6 0.52 6->4 -1.25 4->5 0.35\n * 0 to 6 ( 1.51) 0->2 0.26 2->7 0.34 7->3 0.39 3->6 0.52\n * 0 to 7 ( 0.60) 0->2 0.26 2->7 0.34\n *\n * % java BellmanFordSP tinyEWDnc.txt 0\n * 4->5 0.35\n * 5->4 -0.66\n *\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BellmanFordSP} class represents a data type for solving the\n * single-source shortest paths problem in edge-weighted digraphs with\n * no negative cycles.\n * The edge weights can be positive, negative, or zero.\n * This class finds either a shortest path from the source vertex s\n * to every other vertex or a negative cycle reachable from the source vertex.\n *
\n * This implementation uses a queue-based implementation of\n * the Bellman-Ford-Moore algorithm.\n * The constructor takes Θ(EV) time\n * in the worst case, where V is the number of vertices and\n * E is the number of edges. In practice, it performs much better.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the\n * edge-weighted digraph).\n *
\n * This correctly computes shortest paths if all arithmetic performed is\n * without floating-point rounding error or arithmetic overflow.\n * This is the case if all edge weights are integers and if none of the\n * intermediate results exceeds 252. Since all intermediate\n * results are sums of edge weights, they are bounded by V C,\n * where V is the number of vertices and C is the maximum\n * absolute value of any edge weight.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BellmanFordSP {\n // for floating-point precision issues\n private static final double EPSILON = 1E-14;\n\n private double[] distTo; // distTo[v] = distance of shortest s->v path\n private DirectedEdge[] edgeTo; // edgeTo[v] = last edge on shortest s->v path\n private boolean[] onQueue; // onQueue[v] = is v currently on the queue?\n private Queue queue; // queue of vertices to relax\n private int cost; // number of calls to relax()\n private Iterable cycle; // negative cycle (or null if no such cycle)\n\n /**\n * Computes a shortest paths tree from {@code s} to every other vertex in\n * the edge-weighted {@code digraph}.\n * @param digraph the acyclic digraph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public BellmanFordSP(EdgeWeightedDigraph digraph, int s) {\n distTo = new double[digraph.V()];\n edgeTo = new DirectedEdge[digraph.V()];\n onQueue = new boolean[digraph.V()];\n for (int v = 0; v < digraph.V(); v++)\n distTo[v] = Double.POSITIVE_INFINITY;\n distTo[s] = 0.0;\n\n // Bellman-Ford algorithm\n queue = new Queue();\n queue.enqueue(s);\n onQueue[s] = true;\n while (!queue.isEmpty() && !hasNegativeCycle()) {\n int v = queue.dequeue();\n onQueue[v] = false;\n relax(digraph, v);\n }\n\n assert check(digraph, s);\n }\n\n // relax vertex v and put other endpoints on queue if changed\n private void relax(EdgeWeightedDigraph digraph, int v) {\n for (DirectedEdge e : digraph.adj(v)) {\n int w = e.to();\n if (distTo[w] > distTo[v] + e.weight() + EPSILON) {\n distTo[w] = distTo[v] + e.weight();\n edgeTo[w] = e;\n if (!onQueue[w]) {\n queue.enqueue(w);\n onQueue[w] = true;\n }\n }\n if (++cost % digraph.V() == 0) {\n findNegativeCycle();\n if (hasNegativeCycle()) return; // found a negative cycle\n }\n }\n }\n\n /**\n * Is there a negative cycle reachable from the source vertex {@code s}?\n * @return {@code true} if there is a negative cycle reachable from the\n * source vertex {@code s}, and {@code false} otherwise\n */\n public boolean hasNegativeCycle() {\n return cycle != null;\n }\n\n /**\n * Returns a negative cycle reachable from the source vertex {@code s}, or {@code null}\n * if there is no such cycle.\n * @return a negative cycle reachable from the source vertex {@code s}\n * as an iterable of edges, and {@code null} if there is no such cycle\n */\n public Iterable negativeCycle() {\n return cycle;\n }\n\n // by finding a cycle in predecessor graph\n private void findNegativeCycle() {\n int V = edgeTo.length;\n EdgeWeightedDigraph spt = new EdgeWeightedDigraph(V);\n for (int v = 0; v < V; v++)\n if (edgeTo[v] != null)\n spt.addEdge(edgeTo[v]);\n\n EdgeWeightedDirectedCycle finder = new EdgeWeightedDirectedCycle(spt);\n cycle = finder.cycle();\n }\n\n /**\n * Returns the length of a shortest path from the source vertex {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return the length of a shortest path from the source vertex {@code s} to vertex {@code v};\n * {@code Double.POSITIVE_INFINITY} if no such path\n * @throws UnsupportedOperationException if there is a negative cost cycle reachable\n * from the source vertex {@code s}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public double distTo(int v) {\n validateVertex(v);\n if (hasNegativeCycle())\n throw new UnsupportedOperationException(\"Negative cost cycle exists\");\n return distTo[v];\n }\n\n /**\n * Is there a path from the source {@code s} to vertex {@code v}?\n * @param v the destination vertex\n * @return {@code true} if there is a path from the source vertex\n * {@code s} to vertex {@code v}, and {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return distTo[v] < Double.POSITIVE_INFINITY;\n }\n\n /**\n * Returns a shortest path from the source {@code s} to vertex {@code v}.\n * @param v the destination vertex\n * @return a shortest path from the source {@code s} to vertex {@code v}\n * as an iterable of edges, and {@code null} if no such path\n * @throws UnsupportedOperationException if there is a negative cost cycle reachable\n * from the source vertex {@code s}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (hasNegativeCycle())\n throw new UnsupportedOperationException(\"Negative cost cycle exists\");\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n for (DirectedEdge e = edgeTo[v]; e != null; e = edgeTo[e.from()]) {\n path.push(e);\n }\n return path;\n }\n\n // check optimality conditions: either\n // (i) there exists a negative cycle reachable from s\n // or\n // (ii) for all edges e = v->w: distTo[w] <= distTo[v] + e.weight()\n // (ii') for all edges e = v->w on the SPT: distTo[w] == distTo[v] + e.weight()\n private boolean check(EdgeWeightedDigraph digraph, int s) {\n\n // has a negative cycle\n if (hasNegativeCycle()) {\n double weight = 0.0;\n for (DirectedEdge e : negativeCycle()) {\n weight += e.weight();\n }\n if (weight >= 0.0) {\n System.err.println(\"error: weight of negative cycle = \" + weight);\n return false;\n }\n }\n\n // no negative cycle reachable from source\n else {\n\n // check that distTo[v] and edgeTo[v] are consistent\n if (distTo[s] != 0.0 || edgeTo[s] != null) {\n System.err.println(\"distanceTo[s] and edgeTo[s] inconsistent\");\n return false;\n }\n for (int v = 0; v < digraph.V(); v++) {\n if (v == s) continue;\n if (edgeTo[v] == null && distTo[v] != Double.POSITIVE_INFINITY) {\n System.err.println(\"distTo[] and edgeTo[] inconsistent\");\n return false;\n }\n }\n\n // check that all edges e = v->w satisfy distTo[w] <= distTo[v] + e.weight()\n for (int v = 0; v < digraph.V(); v++) {\n for (DirectedEdge e : digraph.adj(v)) {\n int w = e.to();\n if (distTo[v] + e.weight() < distTo[w]) {\n System.err.println(\"edge \" + e + \" not relaxed\");\n return false;\n }\n }\n }\n\n // check that all edges e = v->w on SPT satisfy distTo[w] == distTo[v] + e.weight()\n for (int w = 0; w < digraph.V(); w++) {\n if (edgeTo[w] == null) continue;\n DirectedEdge e = edgeTo[w];\n int v = e.from();\n if (w != e.to()) return false;\n if (distTo[v] + e.weight() != distTo[w]) {\n System.err.println(\"edge \" + e + \" on shortest path not tight\");\n return false;\n }\n }\n }\n\n StdOut.println(\"Satisfies optimality conditions\");\n StdOut.println();\n return true;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = distTo.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code BellmanFordSP} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n int s = Integer.parseInt(args[1]);\n EdgeWeightedDigraph digraph = new EdgeWeightedDigraph(in);\n\n BellmanFordSP sp = new BellmanFordSP(digraph, s);\n\n // print negative cycle\n if (sp.hasNegativeCycle()) {\n for (DirectedEdge e : sp.negativeCycle())\n StdOut.println(e);\n }\n\n // print shortest paths\n else {\n for (int v = 0; v < digraph.V(); v++) {\n if (sp.hasPathTo(v)) {\n StdOut.printf(\"%d to %d (%5.2f) \", s, v, sp.distTo(v));\n for (DirectedEdge e : sp.pathTo(v)) {\n StdOut.print(e + \" \");\n }\n StdOut.println();\n }\n else {\n StdOut.printf(\"%d to %d no path\\n\", s, v);\n }\n }\n }\n\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryDump.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryDump.java\n * Execution: java BinaryDump n < file\n * Dependencies: BinaryStdIn.java\n * Data file: https://introcs.cs.princeton.edu/stdlib/abra.txt\n *\n * Reads in a binary file and writes out the bits, n per line.\n *\n * % more abra.txt\n * ABRACADABRA!\n *\n * % java BinaryDump 16 < abra.txt\n * 0100000101000010\n * 0101001001000001\n * 0100001101000001\n * 0100010001000001\n * 0100001001010010\n * 0100000100100001\n * 96 bits\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BinaryDump} class provides a client for displaying the contents\n * of a binary file in binary.\n *
\n * For more full-featured versions, see the Unix utilities\n * {@code od} (octal dump) and {@code hexdump} (hexadecimal dump).\n *
\n * For additional documentation,\n * see Section 5.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *
\n * See also {@link HexDump} and {@link PictureDump}.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BinaryDump {\n\n // Do not instantiate.\n private BinaryDump() { }\n\n /**\n * Reads in a sequence of bytes from standard input and writes\n * them to standard output in binary, k bits per line,\n * where k is given as a command-line integer (defaults\n * to 16 if no integer is specified); also writes the number\n * of bits.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int bitsPerLine = 16;\n if (args.length == 1) {\n bitsPerLine = Integer.parseInt(args[0]);\n }\n\n int count;\n for (count = 0; !BinaryStdIn.isEmpty(); count++) {\n if (bitsPerLine == 0) {\n BinaryStdIn.readBoolean();\n continue;\n }\n else if (count != 0 && count % bitsPerLine == 0) StdOut.println();\n if (BinaryStdIn.readBoolean()) StdOut.print(1);\n else StdOut.print(0);\n }\n if (bitsPerLine != 0) StdOut.println();\n StdOut.println(count + \" bits\");\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryIn.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryIn.java\n * Execution: java BinaryIn input output\n * Dependencies: none\n *\n * This library is for reading binary data from an input stream.\n *\n * % java BinaryIn https://introcs.cs.princeton.edu/java/cover.png output.png\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.io.BufferedInputStream;\nimport java.io.File;\nimport java.io.FileInputStream;\nimport java.io.IOException;\nimport java.io.InputStream;\nimport java.net.Socket;\n\nimport java.net.URI;\nimport java.net.URISyntaxException;\nimport java.net.URL;\nimport java.net.URLConnection;\n\nimport java.util.NoSuchElementException;\n\n/**\n * The BinaryIn data type provides methods for reading\n * in bits from a binary input stream. It can process the bits\n * one bit at a time (as a {@code boolean}),\n * 8 bits at a time (as a {@code byte} or {@code char}),\n * 16 bits at a time (as a {@code short}),\n * 32 bits at a time (as an {@code int} or {@code float}), or\n * 64 bits at a time (as a {@code double} or {@code long}).\n *
\n * The binary input stream can be from standard input, a filename,\n * a URL name, a Socket, or an InputStream.\n *
\n * All primitive types are assumed to be represented using their\n * standard Java representations, in big-endian (most significant\n * byte first) order.\n *
\n * The client should not intermix calls to {@code BinaryIn} with calls\n * to {@code In}; otherwise unexpected behavior will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryIn {\n private static final int EOF = -1; // end of file\n\n private BufferedInputStream in; // the input stream\n private int buffer; // one character buffer\n private int n; // number of bits left in buffer\n\n /**\n * Initializes a binary input stream from standard input.\n */\n public BinaryIn() {\n in = new BufferedInputStream(System.in);\n fillBuffer();\n }\n\n /**\n * Initializes a binary input stream from an {@code InputStream}.\n *\n * @param is the {@code InputStream} object\n */\n public BinaryIn(InputStream is) {\n in = new BufferedInputStream(is);\n fillBuffer();\n }\n\n /**\n * Initializes a binary input stream from a socket.\n *\n * @param socket the socket\n */\n public BinaryIn(Socket socket) {\n try {\n InputStream is = socket.getInputStream();\n in = new BufferedInputStream(is);\n fillBuffer();\n }\n catch (IOException ioe) {\n System.err.println(\"could not read socket: \" + socket);\n }\n }\n\n /**\n * Initializes a binary input stream from a URL.\n *\n * @param url the URL\n */\n public BinaryIn(URL url) {\n try {\n URLConnection site = url.openConnection();\n InputStream is = site.getInputStream();\n in = new BufferedInputStream(is);\n fillBuffer();\n }\n catch (IOException ioe) {\n System.err.println(\"could not open URL: '\" + url + \"'\");\n }\n }\n\n /**\n * Initializes a binary input stream from a filename or URL name.\n *\n * @param name the name of the file or URL\n */\n public BinaryIn(String name) {\n\n try {\n // first try to read file from local file system\n File file = new File(name);\n if (file.exists()) {\n FileInputStream fis = new FileInputStream(file);\n in = new BufferedInputStream(fis);\n fillBuffer();\n return;\n }\n\n // next try for files included in jar\n URL url = getClass().getResource(name);\n\n // or URL from web\n if (url == null) {\n URI uri = new URI(name);\n if (uri.isAbsolute()) url = uri.toURL();\n else throw new IllegalArgumentException(\"could not read: '\" + name+ \"'\");\n }\n\n URLConnection site = url.openConnection();\n InputStream is = site.getInputStream();\n in = new BufferedInputStream(is);\n fillBuffer();\n }\n catch (IOException | URISyntaxException e) {\n System.err.println(\"could not open: '\" + name + \"'\");\n }\n }\n\n private void fillBuffer() {\n try {\n buffer = in.read();\n n = 8;\n }\n catch (IOException e) {\n System.err.println(\"EOF\");\n buffer = EOF;\n n = -1;\n }\n }\n\n /**\n * Returns true if this binary input stream exists.\n *\n * @return {@code true} if this binary input stream exists;\n * {@code false} otherwise\n */\n public boolean exists() {\n return in != null;\n }\n\n /**\n * Returns true if this binary input stream is empty.\n *\n * @return {@code true} if this binary input stream is empty;\n * {@code false} otherwise\n */\n public boolean isEmpty() {\n return buffer == EOF;\n }\n\n /**\n * Reads the next bit of data from this binary input stream and return as a boolean.\n *\n * @return the next bit of data from this binary input stream as a {@code boolean}\n * @throws NoSuchElementException if this binary input stream is empty\n */\n public boolean readBoolean() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n--;\n boolean bit = ((buffer >> n) & 1) == 1;\n if (n == 0) fillBuffer();\n return bit;\n }\n\n /**\n * Reads the next 8 bits from this binary input stream and return as an 8-bit char.\n *\n * @return the next 8 bits of data from this binary input stream as a {@code char}\n * @throws NoSuchElementException if there are fewer than 8 bits available\n */\n public char readChar() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n // special case when aligned byte\n if (n == 8) {\n int x = buffer;\n fillBuffer();\n return (char) (x & 0xff);\n }\n\n // combine last N bits of current buffer with first 8-N bits of new buffer\n int x = buffer;\n x <<= (8 - n);\n int oldN = n;\n fillBuffer();\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n = oldN;\n x |= (buffer >>> n);\n return (char) (x & 0xff);\n // the above code doesn't quite work for the last character if N = 8\n // because buffer will be -1\n }\n\n\n /**\n * Reads the next r bits from this binary input stream and return\n * as an r-bit character.\n *\n * @param r number of bits to read\n * @return the next {@code r} bits of data from this binary input stream as a {@code char}\n * @throws NoSuchElementException if there are fewer than {@code r} bits available\n * @throws IllegalArgumentException unless {@code 1 <= r <= 16}\n */\n public char readChar(int r) {\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 8 case\n if (r == 8) return readChar();\n\n char x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n\n /**\n * Reads the remaining bytes of data from this binary input stream and return as a string.\n *\n * @return the remaining bytes of data from this binary input stream as a {@code String}\n * @throws NoSuchElementException if this binary input stream is empty or if the number of bits\n * available is not a multiple of 8 (byte-aligned)\n */\n public String readString() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n StringBuilder sb = new StringBuilder();\n while (!isEmpty()) {\n char c = readChar();\n sb.append(c);\n }\n return sb.toString();\n }\n\n\n /**\n * Reads the next 16 bits from this binary input stream and return as a 16-bit short.\n *\n * @return the next 16 bits of data from this binary input stream as a {@code short}\n * @throws NoSuchElementException if there are fewer than 16 bits available\n */\n public short readShort() {\n short x = 0;\n for (int i = 0; i < 2; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next 32 bits from this binary input stream and return as a 32-bit int.\n *\n * @return the next 32 bits of data from this binary input stream as a {@code int}\n * @throws NoSuchElementException if there are fewer than 32 bits available\n */\n public int readInt() {\n int x = 0;\n for (int i = 0; i < 4; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next r bits from this binary input stream return\n * as an r-bit int.\n *\n * @param r number of bits to read\n * @return the next {@code r} bits of data from this binary input stream as a {@code int}\n * @throws NoSuchElementException if there are fewer than r bits available\n * @throws IllegalArgumentException unless {@code 1 <= r <= 32}\n */\n public int readInt(int r) {\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 32 case\n if (r == 32) return readInt();\n\n int x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n /**\n * Reads the next 64 bits from this binary input stream and return as a 64-bit long.\n *\n * @return the next 64 bits of data from this binary input stream as a {@code long}\n * @throws NoSuchElementException if there are fewer than 64 bits available\n */\n public long readLong() {\n long x = 0;\n for (int i = 0; i < 8; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next 64 bits from this binary input stream and return as a 64-bit double.\n *\n * @return the next 64 bits of data from this binary input stream as a {@code double}\n * @throws NoSuchElementException if there are fewer than 64 bits available\n */\n public double readDouble() {\n return Double.longBitsToDouble(readLong());\n }\n\n /**\n * Reads the next 32 bits from this binary input stream and return as a 32-bit float.\n *\n * @return the next 32 bits of data from this binary input stream as a {@code float}\n * @throws NoSuchElementException if there are fewer than 32 bits available\n */\n public float readFloat() {\n return Float.intBitsToFloat(readInt());\n }\n\n\n /**\n * Reads the next 8 bits from this binary input stream and return as an 8-bit byte.\n *\n * @return the next 8 bits of data from this binary input stream as a {@code byte}\n * @throws NoSuchElementException if there are fewer than 8 bits available\n */\n public byte readByte() {\n char c = readChar();\n return (byte) (c & 0xff);\n }\n\n /**\n * Unit tests the {@code BinaryIn} data type.\n * Reads the name of a file or URL (first command-line argument)\n * and writes it to a file (second command-line argument).\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n BinaryIn in = new BinaryIn(args[0]);\n BinaryOut out = new BinaryOut(args[1]);\n\n // read one 8-bit char at a time\n while (!in.isEmpty()) {\n char c = in.readChar();\n out.write(c);\n }\n out.flush();\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryInsertion.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryInsertion.java\n * Execution: java BinaryInsertion < input.txt\n * Dependencies: StdOut.java StdIn.java\n * Data files: https://algs4.cs.princeton.edu/21elementary/tiny.txt\n * https://algs4.cs.princeton.edu/21elementary/words3.txt\n *\n * Sorts a sequence of strings from standard input using\n * binary insertion sort with half exchanges.\n *\n * % more tiny.txt\n * S O R T E X A M P L E\n *\n * % java BinaryInsertion < tiny.txt\n * A E E L M O P R S T X [ one string per line ]\n *\n * % more words3.txt\n * bed bug dad yes zoo ... all bad yet\n *\n * % java BinaryInsertion < words3.txt\n * all bad bed bug dad ... yes yet zoo [ one string per line ]\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BinaryInsertion} class provides a static method for sorting an\n * array using an optimized binary insertion sort with half exchanges.\n *
\n * In the worst case, this implementation makes\n * ~ n log2n compares to sort an array of length\n * n. However, in the worst case, the running time is\n * Θ(n2) because the number of array accesses\n * can be quadratic.\n * As such, it is not suitable for sorting large arrays\n * (unless the number of inversions is small).\n *
\n * This sorting algorithm is stable.\n * It uses Θ(1) extra memory (not including the input array).\n *
\n * For additional documentation,\n * see Section 2.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Ivan Pesin\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BinaryInsertion {\n\n // This class should not be instantiated.\n private BinaryInsertion() { }\n\n /**\n * Rearranges the array in ascending order, using the natural order.\n * @param a the array to be sorted\n */\n public static void sort(Comparable[] a) {\n int n = a.length;\n for (int i = 1; i < n; i++) {\n\n // binary search to determine index j at which to insert a[i]\n Comparable v = a[i];\n int lo = 0, hi = i;\n while (lo < hi) {\n int mid = lo + (hi - lo) / 2;\n if (less(v, a[mid])) hi = mid;\n else lo = mid + 1;\n }\n\n // insertion sort with \"half exchanges\"\n // (insert a[i] at index j and shift a[j], ..., a[i-1] to right)\n for (int j = i; j > lo; --j)\n a[j] = a[j-1];\n a[lo] = v;\n }\n assert isSorted(a);\n }\n\n\n\n /***************************************************************************\n * Helper sorting function.\n ***************************************************************************/\n\n // is v < w ?\n private static boolean less(Comparable v, Comparable w) {\n return v.compareTo(w) < 0;\n }\n\n /***************************************************************************\n * Check if array is sorted - useful for debugging.\n ***************************************************************************/\n private static boolean isSorted(Comparable[] a) {\n return isSorted(a, 0, a.length - 1);\n }\n\n // is the array sorted from a[lo] to a[hi]\n private static boolean isSorted(Comparable[] a, int lo, int hi) {\n for (int i = lo+1; i <= hi; i++)\n if (less(a[i], a[i-1])) return false;\n return true;\n }\n\n // print array to standard output\n private static void show(Comparable[] a) {\n for (int i = 0; i < a.length; i++) {\n StdOut.println(a[i]);\n }\n }\n\n /**\n * Reads in a sequence of strings from standard input; insertion sorts them;\n * and prints them to standard output in ascending order.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n String[] a = StdIn.readAllStrings();\n BinaryInsertion.sort(a);\n show(a);\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryOut.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryOut.java\n * Execution: java BinaryOut\n * Dependencies: none\n *\n * Write binary data to an output stream, either one 1-bit boolean,\n * one 8-bit char, one 32-bit int, one 64-bit double, one 32-bit float,\n * or one 64-bit long at a time. The output stream can be standard\n * output, a file, an OutputStream or a Socket.\n *\n * The bytes written are not aligned.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.io.BufferedOutputStream;\nimport java.io.FileOutputStream;\nimport java.io.IOException;\nimport java.io.OutputStream;\nimport java.net.Socket;\n\n/**\n * The BinaryOut data type provides a basic capability for\n * converting primitive type variables ({@code boolean}, {@code byte},\n * {@code char}, {@code int}, {@code long}, {@code float}, and {@code double})\n * to sequences of bits and writing them to an output stream.\n * The output stream can be standard output, a file, an OutputStream or a Socket.\n * Uses big-endian (most-significant byte first).\n *
\n * The client must {@code flush()} the output stream when finished writing bits.\n *
\n * The client should not intermix calls to {@code BinaryOut} with calls\n * to {@code Out}; otherwise unexpected behavior will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryOut {\n\n private BufferedOutputStream out; // the output stream\n private int buffer; // 8-bit buffer of bits to write out\n private int n; // number of bits remaining in buffer\n\n\n /**\n * Initializes a binary output stream from standard output.\n */\n public BinaryOut() {\n out = new BufferedOutputStream(System.out);\n }\n\n /**\n * Initializes a binary output stream from an {@code OutputStream}.\n * @param os the {@code OutputStream}\n */\n public BinaryOut(OutputStream os) {\n out = new BufferedOutputStream(os);\n }\n\n /**\n * Initializes a binary output stream from a file.\n * @param filename the name of the file\n * @throws IllegalArgumentException if {@code filename} is {@code null}\n * @throws IllegalArgumentException if {@code filename} is the empty string\n * @throws IllegalArgumentException if cannot write the file {@code filename}\n */\n public BinaryOut(String filename) {\n if (filename == null) {\n throw new IllegalArgumentException(\"filename argument is null\");\n }\n\n if (filename.length() == 0) {\n throw new IllegalArgumentException(\"filename argument is the empty string\");\n }\n\n try {\n OutputStream os = new FileOutputStream(filename);\n out = new BufferedOutputStream(os);\n }\n catch (IOException e) {\n throw new IllegalArgumentException(\"could not create file '\" + filename + \"' for writing\", e);\n }\n }\n\n /**\n * Initializes a binary output stream from a socket.\n * @param socket the socket\n * @throws IllegalArgumentException if {@code filename} is {@code null}\n * @throws IllegalArgumentException if cannot create output stream from socket\n */\n public BinaryOut(Socket socket) {\n if (socket == null) {\n throw new IllegalArgumentException(\"socket argument is null\");\n }\n\n try {\n OutputStream os = socket.getOutputStream();\n out = new BufferedOutputStream(os);\n }\n catch (IOException e) {\n throw new IllegalArgumentException(\"could not create output stream from socket\", e);\n }\n }\n\n\n /**\n * Writes the specified bit to the binary output stream.\n * @param x the bit\n */\n private void writeBit(boolean x) {\n // add bit to buffer\n buffer <<= 1;\n if (x) buffer |= 1;\n\n // if buffer is full (8 bits), write out as a single byte\n n++;\n if (n == 8) clearBuffer();\n }\n\n /**\n * Writes the 8-bit byte to the binary output stream.\n * @param x the byte\n */\n private void writeByte(int x) {\n assert x >= 0 && x < 256;\n\n // optimized if byte-aligned\n if (n == 0) {\n try {\n out.write(x);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n return;\n }\n\n // otherwise write one bit at a time\n for (int i = 0; i < 8; i++) {\n boolean bit = ((x >>> (8 - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n // write out any remaining bits in buffer to the binary output stream, padding with 0s\n private void clearBuffer() {\n if (n == 0) return;\n if (n > 0) buffer <<= (8 - n);\n try {\n out.write(buffer);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n n = 0;\n buffer = 0;\n }\n\n /**\n * Flushes the binary output stream, padding 0s if number of bits written so far\n * is not a multiple of 8.\n */\n public void flush() {\n clearBuffer();\n try {\n out.flush();\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Flushes and closes the binary output stream.\n * Once it is closed, bits can no longer be written.\n */\n public void close() {\n flush();\n try {\n out.close();\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n\n /**\n * Writes the specified bit to the binary output stream.\n * @param x the {@code boolean} to write\n */\n public void write(boolean x) {\n writeBit(x);\n }\n\n /**\n * Writes the 8-bit byte to the binary output stream.\n * @param x the {@code byte} to write.\n */\n public void write(byte x) {\n writeByte(x & 0xff);\n }\n\n /**\n * Writes the 32-bit int to the binary output stream.\n * @param x the {@code int} to write\n */\n public void write(int x) {\n writeByte((x >>> 24) & 0xff);\n writeByte((x >>> 16) & 0xff);\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Writes the r-bit int to the binary output stream.\n *\n * @param x the {@code int} to write\n * @param r the number of relevant bits in the char\n * @throws IllegalArgumentException unless {@code r} is between 1 and 32\n * @throws IllegalArgumentException unless {@code x} is between 0 and 2r - 1\n */\n public void write(int x, int r) {\n if (r == 32) {\n write(x);\n return;\n }\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n\n /**\n * Writes the 64-bit double to the binary output stream.\n * @param x the {@code double} to write\n */\n public void write(double x) {\n write(Double.doubleToRawLongBits(x));\n }\n\n /**\n * Writes the 64-bit long to the binary output stream.\n * @param x the {@code long} to write\n */\n public void write(long x) {\n writeByte((int) ((x >>> 56) & 0xff));\n writeByte((int) ((x >>> 48) & 0xff));\n writeByte((int) ((x >>> 40) & 0xff));\n writeByte((int) ((x >>> 32) & 0xff));\n writeByte((int) ((x >>> 24) & 0xff));\n writeByte((int) ((x >>> 16) & 0xff));\n writeByte((int) ((x >>> 8) & 0xff));\n writeByte((int) ((x >>> 0) & 0xff));\n }\n\n /**\n * Writes the 32-bit float to the binary output stream.\n * @param x the {@code float} to write\n */\n public void write(float x) {\n write(Float.floatToRawIntBits(x));\n }\n\n /**\n * Write the 16-bit int to the binary output stream.\n * @param x the {@code short} to write.\n */\n public void write(short x) {\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Writes the 8-bit char to the binary output stream.\n *\n * @param x the {@code char} to write\n * @throws IllegalArgumentException unless {@code x} is between 0 and 255\n */\n public void write(char x) {\n if (x >= 256) throw new IllegalArgumentException(\"Illegal 8-bit char = \" + x);\n writeByte(x);\n }\n\n /**\n * Writes the r-bit char to the binary output stream.\n *\n * @param x the {@code char} to write\n * @param r the number of relevant bits in the char\n * @throws IllegalArgumentException unless {@code r} is between 1 and 16\n * @throws IllegalArgumentException unless {@code x} is between 0 and 2r - 1\n */\n public void write(char x, int r) {\n if (r == 8) {\n write(x);\n return;\n }\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n /**\n * Writes the string of 8-bit characters to the binary output stream.\n *\n * @param s the {@code String} to write\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 255\n */\n public void write(String s) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i));\n }\n\n\n /**\n * Writes the string of r-bit characters to the binary output stream.\n * @param s the {@code String} to write\n * @param r the number of relevant bits in each character\n * @throws IllegalArgumentException unless r is between 1 and 16\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 2r - 1\n */\n public void write(String s, int r) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i), r);\n }\n\n\n /**\n * Test client. Read bits from standard input and write to the file\n * specified on command line.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // create binary output stream to write to file\n String filename = args[0];\n BinaryOut out = new BinaryOut(filename);\n BinaryIn in = new BinaryIn();\n\n // read from standard input and write to file\n while (!in.isEmpty()) {\n char c = in.readChar();\n out.write(c);\n }\n out.flush();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinarySearch.java",
"content": "/******************************************************************************\n * Compilation: javac BinarySearch.java\n * Execution: java BinarySearch allowlist.txt < input.txt\n * Dependencies: In.java StdIn.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/11model/tinyAllowlist.txt\n * https://algs4.cs.princeton.edu/11model/tinyText.txt\n * https://algs4.cs.princeton.edu/11model/largeAllowlist.txt\n * https://algs4.cs.princeton.edu/11model/largeText.txt\n *\n * % java BinarySearch tinyAllowlist.txt < tinyText.txt\n * 50\n * 99\n * 13\n *\n * % java BinarySearch largeAllowlist.txt < largeText.txt | more\n * 499569\n * 984875\n * 295754\n * 207807\n * 140925\n * 161828\n * [367,966 total values]\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.Arrays;\n\n/**\n * The {@code BinarySearch} class provides a static method for binary\n * searching for an integer in a sorted array of integers.\n *
\n * The indexOf operations takes logarithmic time in the worst case.\n *
\n * For additional documentation, see Section 1.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BinarySearch {\n\n /**\n * This class should not be instantiated.\n */\n private BinarySearch() { }\n\n /**\n * Returns the index of the specified key in the specified array.\n *\n * @param a the array of integers, must be sorted in ascending order\n * @param key the search key\n * @return index of key in array {@code a} if present; {@code -1} otherwise\n */\n public static int indexOf(int[] a, int key) {\n int lo = 0;\n int hi = a.length - 1;\n while (lo <= hi) {\n // Key is in a[lo..hi] or not present.\n int mid = lo + (hi - lo) / 2;\n if (key < a[mid]) hi = mid - 1;\n else if (key > a[mid]) lo = mid + 1;\n else return mid;\n }\n return -1;\n }\n\n /**\n * Returns the index of the specified key in the specified array.\n * This function is poorly named because it does not give the rank\n * if the array has duplicate keys or if the key is not in the array.\n *\n * @param key the search key\n * @param a the array of integers, must be sorted in ascending order\n * @return index of key in array {@code a} if present; {@code -1} otherwise\n * @deprecated Replaced by {@link #indexOf(int[], int)}.\n */\n @Deprecated\n public static int rank(int key, int[] a) {\n return indexOf(a, key);\n }\n\n /**\n * Reads in a sequence of integers from the allowlist file, specified as\n * a command-line argument; reads in integers from standard input;\n * prints to standard output those integers that do not appear in the file.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // read the integers from a file\n In in = new In(args[0]);\n int[] allowlist = in.readAllInts();\n\n // sort the array\n Arrays.sort(allowlist);\n\n // read integer key from standard input; print if not in allowlist\n while (!StdIn.isEmpty()) {\n int key = StdIn.readInt();\n if (BinarySearch.indexOf(allowlist, key) == -1)\n StdOut.println(key);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinarySearchST.java",
"content": "/******************************************************************************\n * Compilation: javac BinarySearchST.java\n * Execution: java BinarySearchST\n * Dependencies: StdIn.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/31elementary/tinyST.txt\n *\n * Symbol table implementation with binary search in an ordered array.\n *\n * % more tinyST.txt\n * S E A R C H E X A M P L E\n *\n * % java BinarySearchST < tinyST.txt\n * A 8\n * C 4\n * E 12\n * H 5\n * L 11\n * M 9\n * P 10\n * R 3\n * S 0\n * X 7\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code BST} class represents an ordered symbol table of generic\n * key-value pairs.\n * It supports the usual put, get, contains,\n * delete, size, and is-empty methods.\n * It also provides ordered methods for finding the minimum,\n * maximum, floor, select, and ceiling.\n * It also provides a keys method for iterating over all of the keys.\n * A symbol table implements the associative array abstraction:\n * when associating a value with a key that is already in the symbol table,\n * the convention is to replace the old value with the new value.\n * Unlike {@link java.util.Map}, this class uses the convention that\n * values cannot be {@code null}—setting the\n * value associated with a key to {@code null} is equivalent to deleting the key\n * from the symbol table.\n *
\n * It requires that\n * the key type implements the {@code Comparable} interface and calls the\n * {@code compareTo()} and method to compare two keys. It does not call either\n * {@code equals()} or {@code hashCode()}.\n *
\n * This implementation uses a sorted array.\n * The put and remove operations take Θ(n)\n * time in the worst case.\n * The contains, ceiling, floor,\n * and rank operations take Θ(log n) time in the worst\n * case.\n * The size, is-empty, minimum, maximum,\n * and select operations take Θ(1) time.\n * Construction takes Θ(1) time.\n *
\n * For alternative implementations of the symbol table API,\n * see {@link ST}, {@link BST}, {@link SequentialSearchST}, {@link RedBlackBST},\n * {@link SeparateChainingHashST}, and {@link LinearProbingHashST},\n * For additional documentation,\n * see Section 3.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n */\npublic class BinarySearchST, Value> {\n private static final int INIT_CAPACITY = 2;\n private Key[] keys;\n private Value[] vals;\n private int n = 0;\n\n /**\n * Initializes an empty symbol table.\n */\n public BinarySearchST() {\n this(INIT_CAPACITY);\n }\n\n /**\n * Initializes an empty symbol table with the specified initial capacity.\n * @param capacity the maximum capacity\n */\n public BinarySearchST(int capacity) {\n keys = (Key[]) new Comparable[capacity];\n vals = (Value[]) new Object[capacity];\n }\n\n // resize the underlying arrays\n private void resize(int capacity) {\n assert capacity >= n;\n Key[] tempk = (Key[]) new Comparable[capacity];\n Value[] tempv = (Value[]) new Object[capacity];\n for (int i = 0; i < n; i++) {\n tempk[i] = keys[i];\n tempv[i] = vals[i];\n }\n vals = tempv;\n keys = tempk;\n }\n\n /**\n * Returns the number of key-value pairs in this symbol table.\n *\n * @return the number of key-value pairs in this symbol table\n */\n public int size() {\n return n;\n }\n\n /**\n * Returns true if this symbol table is empty.\n *\n * @return {@code true} if this symbol table is empty;\n * {@code false} otherwise\n */\n public boolean isEmpty() {\n return size() == 0;\n }\n\n\n /**\n * Does this symbol table contain the given key?\n *\n * @param key the key\n * @return {@code true} if this symbol table contains {@code key} and\n * {@code false} otherwise\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public boolean contains(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to contains() is null\");\n return get(key) != null;\n }\n\n /**\n * Returns the value associated with the given key in this symbol table.\n *\n * @param key the key\n * @return the value associated with the given key if the key is in the symbol table\n * and {@code null} if the key is not in the symbol table\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Value get(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to get() is null\");\n if (isEmpty()) return null;\n int i = rank(key);\n if (i < n && keys[i].compareTo(key) == 0) return vals[i];\n return null;\n }\n\n /**\n * Returns the number of keys in this symbol table strictly less than {@code key}.\n *\n * @param key the key\n * @return the number of keys in the symbol table strictly less than {@code key}\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public int rank(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to rank() is null\");\n\n int lo = 0, hi = n-1;\n while (lo <= hi) {\n int mid = lo + (hi - lo) / 2;\n int cmp = key.compareTo(keys[mid]);\n if (cmp < 0) hi = mid - 1;\n else if (cmp > 0) lo = mid + 1;\n else return mid;\n }\n return lo;\n }\n\n\n\n /**\n * Inserts the specified key-value pair into the symbol table, overwriting the old\n * value with the new value if the symbol table already contains the specified key.\n * Deletes the specified key (and its associated value) from this symbol table\n * if the specified value is {@code null}.\n *\n * @param key the key\n * @param val the value\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void put(Key key, Value val) {\n if (key == null) throw new IllegalArgumentException(\"first argument to put() is null\");\n\n if (val == null) {\n delete(key);\n return;\n }\n\n int i = rank(key);\n\n // key is already in table\n if (i < n && keys[i].compareTo(key) == 0) {\n vals[i] = val;\n return;\n }\n\n // insert new key-value pair\n if (n == keys.length) resize(2*keys.length);\n\n for (int j = n; j > i; j--) {\n keys[j] = keys[j-1];\n vals[j] = vals[j-1];\n }\n keys[i] = key;\n vals[i] = val;\n n++;\n\n assert check();\n }\n\n /**\n * Removes the specified key and associated value from this symbol table\n * (if the key is in the symbol table).\n *\n * @param key the key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public void delete(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to delete() is null\");\n if (isEmpty()) return;\n\n // compute rank\n int i = rank(key);\n\n // key not in table\n if (i == n || keys[i].compareTo(key) != 0) {\n return;\n }\n\n for (int j = i; j < n-1; j++) {\n keys[j] = keys[j+1];\n vals[j] = vals[j+1];\n }\n\n n--;\n keys[n] = null; // to avoid loitering\n vals[n] = null;\n\n // resize if 1/4 full\n if (n > 0 && n == keys.length/4) resize(keys.length/2);\n\n assert check();\n }\n\n /**\n * Removes the smallest key and associated value from this symbol table.\n *\n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMin() {\n if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow error\");\n delete(min());\n }\n\n /**\n * Removes the largest key and associated value from this symbol table.\n *\n * @throws NoSuchElementException if the symbol table is empty\n */\n public void deleteMax() {\n if (isEmpty()) throw new NoSuchElementException(\"Symbol table underflow error\");\n delete(max());\n }\n\n\n /***************************************************************************\n * Ordered symbol table methods.\n ***************************************************************************/\n\n /**\n * Returns the smallest key in this symbol table.\n *\n * @return the smallest key in this symbol table\n * @throws NoSuchElementException if this symbol table is empty\n */\n public Key min() {\n if (isEmpty()) throw new NoSuchElementException(\"called min() with empty symbol table\");\n return keys[0];\n }\n\n /**\n * Returns the largest key in this symbol table.\n *\n * @return the largest key in this symbol table\n * @throws NoSuchElementException if this symbol table is empty\n */\n public Key max() {\n if (isEmpty()) throw new NoSuchElementException(\"called max() with empty symbol table\");\n return keys[n-1];\n }\n\n /**\n * Return the kth smallest key in this symbol table.\n *\n * @param k the order statistic\n * @return the {@code k}th smallest key in this symbol table\n * @throws IllegalArgumentException unless {@code k} is between 0 and\n * n–1\n */\n public Key select(int k) {\n if (k < 0 || k >= size()) {\n throw new IllegalArgumentException(\"called select() with invalid argument: \" + k);\n }\n return keys[k];\n }\n\n /**\n * Returns the largest key in this symbol table less than or equal to {@code key}.\n *\n * @param key the key\n * @return the largest key in this symbol table less than or equal to {@code key}\n * @throws NoSuchElementException if there is no such key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key floor(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to floor() is null\");\n int i = rank(key);\n if (i < n && key.compareTo(keys[i]) == 0) return keys[i];\n if (i == 0) throw new NoSuchElementException(\"argument to floor() is too small\");\n else return keys[i-1];\n }\n\n /**\n * Returns the smallest key in this symbol table greater than or equal to {@code key}.\n *\n * @param key the key\n * @return the smallest key in this symbol table greater than or equal to {@code key}\n * @throws NoSuchElementException if there is no such key\n * @throws IllegalArgumentException if {@code key} is {@code null}\n */\n public Key ceiling(Key key) {\n if (key == null) throw new IllegalArgumentException(\"argument to ceiling() is null\");\n int i = rank(key);\n if (i == n) throw new NoSuchElementException(\"argument to ceiling() is too large\");\n else return keys[i];\n }\n\n /**\n * Returns the number of keys in this symbol table in the specified range.\n *\n * @param lo minimum endpoint\n * @param hi maximum endpoint\n * @return the number of keys in this symbol table between {@code lo}\n * (inclusive) and {@code hi} (inclusive)\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public int size(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to size() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to size() is null\");\n\n if (lo.compareTo(hi) > 0) return 0;\n if (contains(hi)) return rank(hi) - rank(lo) + 1;\n else return rank(hi) - rank(lo);\n }\n\n /**\n * Returns all keys in this symbol table as an {@code Iterable}.\n * To iterate over all of the keys in the symbol table named {@code st},\n * use the foreach notation: {@code for (Key key : st.keys())}.\n *\n * @return all keys in this symbol table\n */\n public Iterable keys() {\n return keys(min(), max());\n }\n\n /**\n * Returns all keys in this symbol table in the given range,\n * as an {@code Iterable}.\n *\n * @param lo minimum endpoint\n * @param hi maximum endpoint\n * @return all keys in this symbol table between {@code lo}\n * (inclusive) and {@code hi} (inclusive)\n * @throws IllegalArgumentException if either {@code lo} or {@code hi}\n * is {@code null}\n */\n public Iterable keys(Key lo, Key hi) {\n if (lo == null) throw new IllegalArgumentException(\"first argument to keys() is null\");\n if (hi == null) throw new IllegalArgumentException(\"second argument to keys() is null\");\n\n Queue queue = new Queue();\n if (lo.compareTo(hi) > 0) return queue;\n for (int i = rank(lo); i < rank(hi); i++)\n queue.enqueue(keys[i]);\n if (contains(hi)) queue.enqueue(keys[rank(hi)]);\n return queue;\n }\n\n\n /***************************************************************************\n * Check internal invariants.\n ***************************************************************************/\n\n private boolean check() {\n return isSorted() && rankCheck();\n }\n\n // are the items in the array in ascending order?\n private boolean isSorted() {\n for (int i = 1; i < size(); i++)\n if (keys[i].compareTo(keys[i-1]) < 0) return false;\n return true;\n }\n\n // check that rank(select(i)) = i\n private boolean rankCheck() {\n for (int i = 0; i < size(); i++)\n if (i != rank(select(i))) return false;\n for (int i = 0; i < size(); i++)\n if (keys[i].compareTo(select(rank(keys[i]))) != 0) return false;\n return true;\n }\n\n\n /**\n * Unit tests the {@code BinarySearchST} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n BinarySearchST st = new BinarySearchST();\n for (int i = 0; !StdIn.isEmpty(); i++) {\n String key = StdIn.readString();\n st.put(key, i);\n }\n for (String s : st.keys())\n StdOut.println(s + \" \" + st.get(s));\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryStdIn.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryStdIn.java\n * Execution: java BinaryStdIn < input > output\n * Dependencies: none\n *\n * Supports reading binary data from standard input.\n *\n * % java BinaryStdIn < input.jpg > output.jpg\n * % diff input.jpg output.jpg\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.io.BufferedInputStream;\nimport java.io.IOException;\nimport java.util.NoSuchElementException;\n\n/**\n * The BinaryStdIn class provides static methods for reading\n * in bits from standard input. It can process the bits\n * one bit at a time (as a {@code boolean}),\n * 8 bits at a time (as a {@code byte} or {@code char}),\n * 16 bits at a time (as a {@code short}), 32 bits at a time\n * (as an {@code int} or {@code float}), or 64 bits at a time (as a\n * {@code double} or {@code long}).\n *
\n * All primitive types are assumed to be represented using their\n * standard Java representations, in big-endian (most significant\n * byte first) order.\n *
\n * The client should not intermix calls to {@code BinaryStdIn} with calls\n * to {@code StdIn} or {@code System.in};\n * otherwise unexpected behavior will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryStdIn {\n private static final int EOF = -1; // end of file\n\n private static BufferedInputStream in; // input stream\n private static int buffer; // one character buffer\n private static int n; // number of bits left in buffer\n private static boolean isInitialized; // has BinaryStdIn been called for first time?\n\n // don't instantiate\n private BinaryStdIn() { }\n\n // fill buffer\n private static void initialize() {\n in = new BufferedInputStream(System.in);\n buffer = 0;\n n = 0;\n fillBuffer();\n isInitialized = true;\n }\n\n private static void fillBuffer() {\n try {\n buffer = in.read();\n n = 8;\n }\n catch (IOException e) {\n System.out.println(\"EOF\");\n buffer = EOF;\n n = -1;\n }\n }\n\n /**\n * Close this input stream and release any associated system resources.\n */\n public static void close() {\n if (!isInitialized) initialize();\n try {\n in.close();\n isInitialized = false;\n }\n catch (IOException ioe) {\n throw new IllegalStateException(\"Could not close BinaryStdIn\", ioe);\n }\n }\n\n /**\n * Returns true if standard input is empty.\n * @return true if and only if standard input is empty\n */\n public static boolean isEmpty() {\n if (!isInitialized) initialize();\n return buffer == EOF;\n }\n\n /**\n * Reads the next bit of data from standard input and return as a boolean.\n *\n * @return the next bit of data from standard input as a {@code boolean}\n * @throws NoSuchElementException if standard input is empty\n */\n public static boolean readBoolean() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n--;\n boolean bit = ((buffer >> n) & 1) == 1;\n if (n == 0) fillBuffer();\n return bit;\n }\n\n /**\n * Reads the next 8 bits from standard input and return as an 8-bit char.\n * Note that {@code char} is a 16-bit type;\n * to read the next 16 bits as a char, use {@code readChar(16)}.\n *\n * @return the next 8 bits of data from standard input as a {@code char}\n * @throws NoSuchElementException if there are fewer than 8 bits available on standard input\n */\n public static char readChar() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n // special case when aligned byte\n if (n == 8) {\n int x = buffer;\n fillBuffer();\n return (char) (x & 0xff);\n }\n\n // combine last n bits of current buffer with first 8-n bits of new buffer\n int x = buffer;\n x <<= (8 - n);\n int oldN = n;\n fillBuffer();\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n n = oldN;\n x |= (buffer >>> n);\n return (char) (x & 0xff);\n // the above code doesn't quite work for the last character if n = 8\n // because buffer will be -1, so there is a special case for aligned byte\n }\n\n /**\n * Reads the next r bits from standard input and return as an r-bit character.\n *\n * @param r number of bits to read.\n * @return the next r bits of data from standard input as a {@code char}\n * @throws NoSuchElementException if there are fewer than {@code r} bits available on standard input\n * @throws IllegalArgumentException unless {@code 1 <= r <= 16}\n */\n public static char readChar(int r) {\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 8 case\n if (r == 8) return readChar();\n\n char x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n /**\n * Reads the remaining bytes of data from standard input and return as a string.\n *\n * @return the remaining bytes of data from standard input as a {@code String}\n * @throws NoSuchElementException if standard input is empty or if the number of bits\n * available on standard input is not a multiple of 8 (byte-aligned)\n */\n public static String readString() {\n if (isEmpty()) throw new NoSuchElementException(\"Reading from empty input stream\");\n\n StringBuilder sb = new StringBuilder();\n while (!isEmpty()) {\n char c = readChar();\n sb.append(c);\n }\n return sb.toString();\n }\n\n\n /**\n * Reads the next 16 bits from standard input and return as a 16-bit short.\n *\n * @return the next 16 bits of data from standard input as a {@code short}\n * @throws NoSuchElementException if there are fewer than 16 bits available on standard input\n */\n public static short readShort() {\n short x = 0;\n for (int i = 0; i < 2; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next 32 bits from standard input and return as a 32-bit int.\n *\n * @return the next 32 bits of data from standard input as a {@code int}\n * @throws NoSuchElementException if there are fewer than 32 bits available on standard input\n */\n public static int readInt() {\n int x = 0;\n for (int i = 0; i < 4; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n /**\n * Reads the next r bits from standard input and return as an r-bit int.\n *\n * @param r number of bits to read.\n * @return the next r bits of data from standard input as a {@code int}\n * @throws NoSuchElementException if there are fewer than {@code r} bits available on standard input\n * @throws IllegalArgumentException unless {@code 1 <= r <= 32}\n */\n public static int readInt(int r) {\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value of r = \" + r);\n\n // optimize r = 32 case\n if (r == 32) return readInt();\n\n int x = 0;\n for (int i = 0; i < r; i++) {\n x <<= 1;\n boolean bit = readBoolean();\n if (bit) x |= 1;\n }\n return x;\n }\n\n /**\n * Reads the next 64 bits from standard input and return as a 64-bit long.\n *\n * @return the next 64 bits of data from standard input as a {@code long}\n * @throws NoSuchElementException if there are fewer than 64 bits available on standard input\n */\n public static long readLong() {\n long x = 0;\n for (int i = 0; i < 8; i++) {\n char c = readChar();\n x <<= 8;\n x |= c;\n }\n return x;\n }\n\n\n /**\n * Reads the next 64 bits from standard input and return as a 64-bit double.\n *\n * @return the next 64 bits of data from standard input as a {@code double}\n * @throws NoSuchElementException if there are fewer than 64 bits available on standard input\n */\n public static double readDouble() {\n return Double.longBitsToDouble(readLong());\n }\n\n /**\n * Reads the next 32 bits from standard input and return as a 32-bit float.\n *\n * @return the next 32 bits of data from standard input as a {@code float}\n * @throws NoSuchElementException if there are fewer than 32 bits available on standard input\n */\n public static float readFloat() {\n return Float.intBitsToFloat(readInt());\n }\n\n\n /**\n * Reads the next 8 bits from standard input and return as an 8-bit byte.\n *\n * @return the next 8 bits of data from standard input as a {@code byte}\n * @throws NoSuchElementException if there are fewer than 8 bits available on standard input\n */\n public static byte readByte() {\n char c = readChar();\n return (byte) (c & 0xff);\n }\n\n /**\n * Test client. Reads in a binary input file from standard input and writes\n * it to standard output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // read one 8-bit char at a time\n while (!BinaryStdIn.isEmpty()) {\n char c = BinaryStdIn.readChar();\n BinaryStdOut.write(c);\n }\n BinaryStdOut.flush();\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinaryStdOut.java",
"content": "/******************************************************************************\n * Compilation: javac BinaryStdOut.java\n * Execution: java BinaryStdOut\n * Dependencies: none\n *\n * Write binary data to standard output, either one 1-bit boolean,\n * one 8-bit char, one 32-bit int, one 64-bit double, one 32-bit float,\n * or one 64-bit long at a time.\n *\n * The bytes written are not aligned.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.io.BufferedOutputStream;\nimport java.io.IOException;\n\n/**\n * The BinaryStdOut class provides static methods for converting\n * primitive type variables ({@code boolean}, {@code byte}, {@code char},\n * {@code int}, {@code long}, {@code float}, and {@code double})\n * to sequences of bits and writing them to standard output.\n * Uses big-endian (most-significant byte first).\n *
\n * The client must {@code flush()} the output stream when finished writing bits.\n *
\n * The client should not intermix calls to {@code BinaryStdOut} with calls\n * to {@code StdOut} or {@code System.out}; otherwise unexpected behavior\n * will result.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic final class BinaryStdOut {\n private static BufferedOutputStream out; // output stream (standard output)\n private static int buffer; // 8-bit buffer of bits to write\n private static int n; // number of bits remaining in buffer\n private static boolean isInitialized; // has BinaryStdOut been called for first time?\n\n // don't instantiate\n private BinaryStdOut() { }\n\n // initialize BinaryStdOut\n private static void initialize() {\n out = new BufferedOutputStream(System.out);\n buffer = 0;\n n = 0;\n isInitialized = true;\n }\n\n /**\n * Writes the specified bit to standard output.\n */\n private static void writeBit(boolean bit) {\n if (!isInitialized) initialize();\n\n // add bit to buffer\n buffer <<= 1;\n if (bit) buffer |= 1;\n\n // if buffer is full (8 bits), write out as a single byte\n n++;\n if (n == 8) clearBuffer();\n }\n\n /**\n * Writes the 8-bit byte to standard output.\n */\n private static void writeByte(int x) {\n if (!isInitialized) initialize();\n\n assert x >= 0 && x < 256;\n\n // optimized if byte-aligned\n if (n == 0) {\n try {\n out.write(x);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n return;\n }\n\n // otherwise write one bit at a time\n for (int i = 0; i < 8; i++) {\n boolean bit = ((x >>> (8 - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n // write out any remaining bits in buffer to standard output, padding with 0s\n private static void clearBuffer() {\n if (!isInitialized) initialize();\n\n if (n == 0) return;\n if (n > 0) buffer <<= (8 - n);\n try {\n out.write(buffer);\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n n = 0;\n buffer = 0;\n }\n\n /**\n * Flushes standard output, padding 0s if number of bits written so far\n * is not a multiple of 8.\n */\n public static void flush() {\n clearBuffer();\n try {\n out.flush();\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n /**\n * Flushes and closes standard output. Once standard output is closed, you can no\n * longer write bits to it.\n */\n public static void close() {\n flush();\n try {\n out.close();\n isInitialized = false;\n }\n catch (IOException e) {\n e.printStackTrace();\n }\n }\n\n\n /**\n * Writes the specified bit to standard output.\n * @param x the {@code boolean} to write.\n */\n public static void write(boolean x) {\n writeBit(x);\n }\n\n /**\n * Writes the 8-bit byte to standard output.\n * @param x the {@code byte} to write.\n */\n public static void write(byte x) {\n writeByte(x & 0xff);\n }\n\n /**\n * Writes the 32-bit int to standard output.\n * @param x the {@code int} to write.\n */\n public static void write(int x) {\n writeByte((x >>> 24) & 0xff);\n writeByte((x >>> 16) & 0xff);\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Writes the r-bit int to standard output.\n * @param x the {@code int} to write.\n * @param r the number of relevant bits in the char.\n * @throws IllegalArgumentException if {@code r} is not between 1 and 32.\n * @throws IllegalArgumentException if {@code x} is not between 0 and 2r - 1.\n */\n public static void write(int x, int r) {\n if (r == 32) {\n write(x);\n return;\n }\n if (r < 1 || r > 32) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x < 0 || x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n\n\n\n\n /**\n * Writes the 64-bit double to standard output.\n * @param x the {@code double} to write.\n */\n public static void write(double x) {\n write(Double.doubleToRawLongBits(x));\n }\n\n /**\n * Writes the 64-bit long to standard output.\n * @param x the {@code long} to write.\n */\n public static void write(long x) {\n writeByte((int) ((x >>> 56) & 0xff));\n writeByte((int) ((x >>> 48) & 0xff));\n writeByte((int) ((x >>> 40) & 0xff));\n writeByte((int) ((x >>> 32) & 0xff));\n writeByte((int) ((x >>> 24) & 0xff));\n writeByte((int) ((x >>> 16) & 0xff));\n writeByte((int) ((x >>> 8) & 0xff));\n writeByte((int) ((x >>> 0) & 0xff));\n }\n\n /**\n * Writes the 32-bit float to standard output.\n * @param x the {@code float} to write.\n */\n public static void write(float x) {\n write(Float.floatToRawIntBits(x));\n }\n\n /**\n * Writes the 16-bit int to standard output.\n * @param x the {@code short} to write.\n */\n public static void write(short x) {\n writeByte((x >>> 8) & 0xff);\n writeByte((x >>> 0) & 0xff);\n }\n\n /**\n * Writes the 8-bit char to standard output.\n * @param x the {@code char} to write.\n * @throws IllegalArgumentException if {@code x} is not between 0 and 255.\n */\n public static void write(char x) {\n if (x < 0 || x >= 256) throw new IllegalArgumentException(\"Illegal 8-bit char = \" + x);\n writeByte(x);\n }\n\n /**\n * Writes the r-bit char to standard output.\n * @param x the {@code char} to write.\n * @param r the number of relevant bits in the char.\n * @throws IllegalArgumentException if {@code r} is not between 1 and 16.\n * @throws IllegalArgumentException if {@code x} is not between 0 and 2r - 1.\n */\n public static void write(char x, int r) {\n if (r == 8) {\n write(x);\n return;\n }\n if (r < 1 || r > 16) throw new IllegalArgumentException(\"Illegal value for r = \" + r);\n if (x >= (1 << r)) throw new IllegalArgumentException(\"Illegal \" + r + \"-bit char = \" + x);\n for (int i = 0; i < r; i++) {\n boolean bit = ((x >>> (r - i - 1)) & 1) == 1;\n writeBit(bit);\n }\n }\n\n /**\n * Writes the string of 8-bit characters to standard output.\n * @param s the {@code String} to write.\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 255.\n */\n public static void write(String s) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i));\n }\n\n /**\n * Writes the string of r-bit characters to standard output.\n * @param s the {@code String} to write.\n * @param r the number of relevant bits in each character.\n * @throws IllegalArgumentException if r is not between 1 and 16.\n * @throws IllegalArgumentException if any character in the string is not\n * between 0 and 2r - 1.\n */\n public static void write(String s, int r) {\n for (int i = 0; i < s.length(); i++)\n write(s.charAt(i), r);\n }\n\n /**\n * Tests the methods in this class.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int m = Integer.parseInt(args[0]);\n\n // write n integers to binary standard output\n for (int i = 0; i < m; i++) {\n BinaryStdOut.write(i);\n }\n BinaryStdOut.flush();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BinomialMinPQ.java",
"content": "/******************************************************************************\n * Compilation: javac BinomialMinPQ.java\n * Execution:\n * \n * A binomial heap.\n * \n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.Iterator;\nimport java.util.Comparator;\nimport java.util.NoSuchElementException;\n\n/**\n * The BinomialMinPQ class represents a priority queue of generic keys.\n * It supports the usual insert and delete-the-minimum operations, \n * along with the merging of two heaps together.\n * It also supports methods for peeking at the minimum key,\n * testing if the priority queue is empty, and iterating through\n * the keys.\n * It is possible to build the priority queue using a Comparator.\n * If not, the natural order relation between the keys will be used.\n * \n * This implementation uses a binomial heap.\n * The insert, delete-the-minimum, union, min-key\n * and size operations take logarithmic time.\n * The is-empty and constructor operations take constant time.\n * \n * @author Tristan Claverie\n */\npublic class BinomialMinPQ implements Iterable {\n\tprivate Node head; \t\t\t\t//head of the list of roots\n\tprivate final Comparator comp;\t//Comparator over the keys\n\t\n\t//Represents a Node of a Binomial Tree\n\tprivate class Node {\n\t\tKey key;\t\t\t\t\t\t//Key contained by the Node\n\t\tint order;\t\t\t\t\t\t//The order of the Binomial Tree rooted by this Node\n\t\tNode child, sibling;\t\t\t//child and sibling of this Node\n\t}\n\t\n\t/**\n\t * Initializes an empty priority queue\n\t * Worst case is O(1)\n\t */\n\tpublic BinomialMinPQ() {\n\t\tcomp = new MyComparator();\n\t}\n\t\n\t/**\n\t * Initializes an empty priority queue using the given Comparator\n\t * Worst case is O(1)\n\t * @param C a comparator over the keys\n\t */\n\tpublic BinomialMinPQ(Comparator C) {\n\t\tcomp = C;\n\t}\n\t\n\t/**\n\t * Initializes a priority queue with given keys\n\t * Worst case is O(n*log(n))\n\t * @param a an array of keys\n\t */\n\tpublic BinomialMinPQ(Key[] a) {\n\t\tcomp = new MyComparator();\n\t\tfor (Key k : a) insert(k);\n\t}\n\t\n\t/**\n\t * Initializes a priority queue with given keys using the given Comparator\n\t * Worst case is O(n*log(n))\n\t * @param C a comparator over the keys\n\t * @param a an array of keys\n\t */\n\tpublic BinomialMinPQ(Comparator C, Key[] a) {\n\t\tcomp = C;\n\t\tfor (Key k : a) insert(k);\n\t}\n\n\t/**\n\t * Whether the priority queue is empty\n\t * Worst case is O(1)\n\t * @return true if the priority queue is empty, false if not\n\t */\n\tpublic boolean isEmpty() {\n\t\treturn head == null;\n\t}\n\n\t/**\n\t * Number of elements currently on the priority queue\n\t * Worst case is O(log(n))\n\t * @throws java.lang.ArithmeticException if there are more than 2^63-1 elements in the queue\n\t * @return the number of elements on the priority queue\n\t */\n\tpublic int size() {\n\t\tint result = 0, tmp;\n\t\tfor (Node node = head; node != null; node = node.sibling) {\n\t\t\tif (node.order > 30) { throw new ArithmeticException(\"The number of elements cannot be evaluated, but the priority queue is still valid.\"); }\n\t\t\ttmp = 1 << node.order;\n\t\t\tresult |= tmp;\n\t\t}\n\t\treturn result;\n\t}\n\n\t/**\n\t * Puts a Key in the heap\n\t * Worst case is O(log(n))\n\t * @param key a Key\n\t */\n\tpublic void insert(Key key) {\n\t\tNode x = new Node();\n\t\tx.key = key;\n\t\tx.order = 0;\n\t\tBinomialMinPQ H = new BinomialMinPQ(); //The Comparator oh the H heap is not used\n\t\tH.head = x;\n\t\tthis.head = this.union(H).head;\n\t}\n\n\t/**\n\t * Get the minimum key currently in the queue\n\t * Worst case is O(log(n))\n\t * @throws java.util.NoSuchElementException if the priority queue is empty\n\t * @return the minimum key currently in the priority queue\n\t */\n\tpublic Key minKey() {\n\t\tif (isEmpty()) throw new NoSuchElementException(\"Priority queue is empty\");\n\t\tNode min = head;\n\t\tNode current = head;\n\t\twhile (current.sibling != null) {\n\t\t\tmin = (greater(min.key, current.sibling.key)) ? current : min;\n\t\t\tcurrent = current.sibling;\n\t\t}\n\t\treturn min.key;\n\t}\n\n\t/**\n\t * Deletes the minimum key\n\t * Worst case is O(log(n))\n\t * @throws java.util.NoSuchElementException if the priority queue is empty\n\t * @return the minimum key\n\t */\n\tpublic Key delMin() {\n\t\tif(isEmpty()) throw new NoSuchElementException(\"Priority queue is empty\");\n\t\tNode min = eraseMin();\n\t\tNode x = (min.child == null) ? min : min.child;\n\t\tif (min.child != null) {\n\t\t\tmin.child = null;\n\t\t\tNode prevx = null, nextx = x.sibling;\n\t\t\twhile (nextx != null) {\n\t\t\t\tx.sibling = prevx;\n\t\t\t\tprevx = x;\n\t\t\t\tx = nextx;nextx = nextx.sibling;\n\t\t\t}\n\t\t\tx.sibling = prevx;\n\t\t\tBinomialMinPQ H = new BinomialMinPQ();\n\t\t\tH.head = x;\n\t\t\thead = union(H).head;\n\t\t}\n\t\treturn min.key;\n\t}\n\t\n\t/**\n\t * Merges two Binomial heaps together\n\t * This operation is destructive\n\t * Worst case is O(log(n))\n\t * @param heap a Binomial Heap to be merged with the current heap\n\t * @throws java.lang.IllegalArgumentException if the heap in parameter is null\n\t * @return the union of two heaps\n\t */\n\tpublic BinomialMinPQ union(BinomialMinPQ heap) {\n\t\tif (heap == null) throw new IllegalArgumentException(\"Cannot merge a Binomial Heap with null\");\n\t\tthis.head = merge(new Node(), this.head, heap.head).sibling;\n\t\tNode x = this.head;\n\t\tNode prevx = null, nextx = x.sibling;\n\t\twhile (nextx != null) {\n\t\t\tif (x.order < nextx.order ||\n\t\t\t (nextx.sibling != null && nextx.sibling.order == x.order)) {\n\t\t\t\tprevx = x; x = nextx;\n\t\t\t} else if (greater(nextx.key, x.key)) {\n\t\t\t\tx.sibling = nextx.sibling;\n\t\t\t\tlink(nextx, x);\n\t\t\t} else {\n\t\t\t\tif (prevx == null) { this.head = nextx; }\n\t\t\t\telse { prevx.sibling = nextx; }\n\t\t\t\tlink(x, nextx);\n\t\t\t\tx = nextx;\n\t\t\t}\n\t\t\tnextx = x.sibling;\n\t\t}\n\t\treturn this;\n\t}\n\t\n\t/*************************************************\n\t * General helper functions\n\t ************************************************/\n\t\n\t//Compares two keys\n\tprivate boolean greater(Key n, Key m) {\n\t\tif (n == null) return false;\n\t\tif (m == null) return true;\n\t\treturn comp.compare(n, m) > 0;\n\t}\n\t\n\t//Assuming root1 holds a greater key than root2, root2 becomes the new root\n\tprivate void link(Node root1, Node root2) {\n\t\troot1.sibling = root2.child;\n\t\troot2.child = root1;\n\t\troot2.order++;\n\t}\n\t\n\t//Deletes and return the node containing the minimum key\n\tprivate Node eraseMin() {\n\t\tNode min = head;\n\t\tNode previous = null;\n\t\tNode current = head;\n\t\twhile (current.sibling != null) {\n\t\t\tif (greater(min.key, current.sibling.key)) {\n\t\t\t\tprevious = current;\n\t\t\t\tmin = current.sibling;\n\t\t\t}\n\t\t\tcurrent = current.sibling;\n\t\t}\n\t\tprevious.sibling = min.sibling;\n\t\tif (min == head) head = min.sibling;\n\t\treturn min;\n\t}\n\t\n\t/**************************************************\n\t * Functions for inserting a key in the heap\n\t *************************************************/\n\t\n\t//Merges two root lists into one, there can be up to 2 Binomial Trees of same order\n private Node merge(Node h, Node x, Node y) {\n if (x == null && y == null) return h;\n else if (x == null) h.sibling = merge(y, null, y.sibling);\n else if (y == null) h.sibling = merge(x, x.sibling, null);\n else if (x.order < y.order) h.sibling = merge(x, x.sibling, y);\n else h.sibling = merge(y, x, y.sibling);\n return h;\n\t}\n\t\n\t/******************************************************************\n\t * Iterator\n\t *****************************************************************/\n\t\n\t/**\n\t * Gets an Iterator over the keys in the priority queue in ascending order\n\t * The Iterator does not implement the remove() method\n\t * iterator() : Worst case is O(n)\n\t * next() : \tWorst case is O(log(n))\n\t * hasNext() : \tWorst case is O(1)\n\t * @return an Iterator over the keys in the priority queue in ascending order\n\t */\n\tpublic Iterator iterator() {\n\t\treturn new MyIterator();\n\t}\n\t\n\tprivate class MyIterator implements Iterator {\n\t\tBinomialMinPQ data;\n\t\t\n\t\t//Constructor clones recursively the elements in the queue\n\t\t//It takes linear time\n\t\tpublic MyIterator() {\n\t\t\tdata = new BinomialMinPQ(comp);\n\t\t\tdata.head = clone(head, null);\n\t\t}\n\t\t\n\t\tprivate Node clone(Node x, Node parent) {\n\t\t\tif (x == null) return null;\n\t\t\tNode node = new Node();\n\t\t\tnode.key = x.key;\n\t\t\tnode.sibling = clone(x.sibling, parent);\n\t\t\tnode.child = clone(x.child, node);\n\t\t\treturn node;\n\t\t}\n\t\t\n\t\tpublic boolean hasNext() {\n\t\t\treturn !data.isEmpty();\n\t\t}\n\t\t\n\t\tpublic Key next() {\n if (!hasNext()) throw new NoSuchElementException();\n\t\t\treturn data.delMin();\n\t\t}\n\t\t\n\t\tpublic void remove() {\n\t\t\tthrow new UnsupportedOperationException();\n\t\t}\n\t}\n\t\n\t/***************************\n\t * Comparator\n\t **************************/\n\t\n\t//default Comparator\n\tprivate class MyComparator implements Comparator {\n\t\t@Override\n\t\tpublic int compare(Key key1, Key key2) {\n\t\t\treturn ((Comparable) key1).compareTo(key2);\n\t\t}\n\t}\n\t\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Bipartite.java",
"content": "/******************************************************************************\n * Compilation: javac Bipartite.java\n * Execution: java Bipartite V E F\n * Dependencies: Graph.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n * https://algs4.cs.princeton.edu/41graph/largeG.txt\n *\n * Given a graph, find either (i) a bipartition or (ii) an odd-length cycle.\n * Runs in O(E + V) time.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n\n/**\n * The {@code Bipartite} class represents a data type for\n * determining whether an undirected graph is bipartite or whether\n * it has an odd-length cycle.\n * A graph is bipartite if and only if it has no odd-length cycle.\n * The isBipartite operation determines whether the graph is\n * bipartite. If so, the color operation determines a\n * bipartition; if not, the oddCycle operation determines a\n * cycle with an odd number of edges.\n *
\n * This implementation uses depth-first search.\n * The constructor takes Θ(V + E) time in\n * the worst case, where V is the number of vertices and E\n * is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n * See {@link BipartiteX} for a nonrecursive version that uses breadth-first\n * search.\n *
\n * For additional documentation, see Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Bipartite {\n private boolean isBipartite; // is the graph bipartite?\n private boolean[] color; // color[v] gives vertices on one side of bipartition\n private boolean[] marked; // marked[v] = true iff v has been visited in DFS\n private int[] edgeTo; // edgeTo[v] = last edge on path to v\n private Stack cycle; // odd-length cycle\n\n /**\n * Determines whether an undirected graph is bipartite and finds either a\n * bipartition or an odd-length cycle.\n *\n * @param graph the graph\n */\n public Bipartite(Graph graph) {\n isBipartite = true;\n color = new boolean[graph.V()];\n marked = new boolean[graph.V()];\n edgeTo = new int[graph.V()];\n\n for (int v = 0; v < graph.V(); v++) {\n if (!marked[v]) {\n dfs(graph, v);\n }\n }\n assert check(graph);\n }\n\n private void dfs(Graph graph, int v) {\n marked[v] = true;\n for (int w : graph.adj(v)) {\n\n // short circuit if odd-length cycle found\n if (cycle != null) return;\n\n // found uncolored vertex, so recur\n if (!marked[w]) {\n edgeTo[w] = v;\n color[w] = !color[v];\n dfs(graph, w);\n }\n\n // if v-w create an odd-length cycle, find it\n else if (color[w] == color[v]) {\n isBipartite = false;\n cycle = new Stack();\n cycle.push(w); // don't need this unless you want to include start vertex twice\n for (int x = v; x != w; x = edgeTo[x]) {\n cycle.push(x);\n }\n cycle.push(w);\n }\n }\n }\n\n /**\n * Returns true if the graph is bipartite.\n *\n * @return {@code true} if the graph is bipartite; {@code false} otherwise\n */\n public boolean isBipartite() {\n return isBipartite;\n }\n\n /**\n * Returns the side of the bipartite that vertex {@code v} is on.\n *\n * @param v the vertex\n * @return the side of the bipartition that vertex {@code v} is on; two vertices\n * are in the same side of the bipartition if and only if they have the\n * same color\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n * @throws UnsupportedOperationException if this method is called when the graph\n * is not bipartite\n */\n public boolean color(int v) {\n validateVertex(v);\n if (!isBipartite)\n throw new UnsupportedOperationException(\"graph is not bipartite\");\n return color[v];\n }\n\n /**\n * Returns an odd-length cycle if the graph is not bipartite, and\n * {@code null} otherwise.\n *\n * @return an odd-length cycle if the graph is not bipartite\n * (and hence has an odd-length cycle), and {@code null}\n * otherwise\n */\n public Iterable oddCycle() {\n return cycle;\n }\n\n private boolean check(Graph graph) {\n // graph is bipartite\n if (isBipartite) {\n for (int v = 0; v < graph.V(); v++) {\n for (int w : graph.adj(v)) {\n if (color[v] == color[w]) {\n System.err.printf(\"edge %d-%d with %d and %d in same side of bipartition\\n\", v, w, v, w);\n return false;\n }\n }\n }\n }\n\n // graph has an odd-length cycle\n else {\n // verify cycle\n int first = -1, last = -1;\n for (int v : oddCycle()) {\n if (first == -1) first = v;\n last = v;\n }\n if (first != last) {\n System.err.printf(\"cycle begins with %d and ends with %d\\n\", first, last);\n return false;\n }\n }\n\n return true;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code Bipartite} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int V1 = Integer.parseInt(args[0]);\n int V2 = Integer.parseInt(args[1]);\n int E = Integer.parseInt(args[2]);\n int F = Integer.parseInt(args[3]);\n\n // create random bipartite graph with V1 vertices on left side,\n // V2 vertices on right side, and E edges; then add F random edges\n Graph graph = GraphGenerator.bipartite(V1, V2, E);\n for (int i = 0; i < F; i++) {\n int v = StdRandom.uniformInt(V1 + V2);\n int w = StdRandom.uniformInt(V1 + V2);\n graph.addEdge(v, w);\n }\n\n StdOut.println(graph);\n\n\n Bipartite b = new Bipartite(graph);\n if (b.isBipartite()) {\n StdOut.println(\"Graph is bipartite\");\n for (int v = 0; v < graph.V(); v++) {\n StdOut.println(v + \": \" + b.color(v));\n }\n }\n else {\n StdOut.print(\"Graph has an odd-length cycle: \");\n for (int x : b.oddCycle()) {\n StdOut.print(x + \" \");\n }\n StdOut.println();\n }\n }\n\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BipartiteMatching.java",
"content": "/******************************************************************************\n * Compilation: javac BipartiteMatching.java\n * Execution: java BipartiteMatching V1 V2 E\n * Dependencies: BipartiteX.java\n *\n * Find a maximum cardinality matching (and minimum cardinality vertex cover)\n * in a bipartite graph using the alternating path algorithm.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BipartiteMatching} class represents a data type for computing a\n * maximum (cardinality) matching and a\n * minimum (cardinality) vertex cover in a bipartite graph.\n * A bipartite graph in a graph whose vertices can be partitioned\n * into two disjoint sets such that every edge has one endpoint in either set.\n * A matching in a graph is a subset of its edges with no common\n * vertices. A maximum matching is a matching with the maximum number\n * of edges.\n * A perfect matching is a matching which matches all vertices in the graph.\n * A vertex cover in a graph is a subset of its vertices such that\n * every edge is incident to at least one vertex. A minimum vertex cover\n * is a vertex cover with the minimum number of vertices.\n * By Konig's theorem, in any bipartite\n * graph, the maximum number of edges in matching equals the minimum number\n * of vertices in a vertex cover.\n * The maximum matching problem in nonbipartite graphs is\n * also important, but all known algorithms for this more general problem\n * are substantially more complicated.\n *
\n * This implementation uses the alternating-path algorithm.\n * It is equivalent to reducing to the maximum-flow problem and running\n * the augmenting-path algorithm on the resulting flow network, but it\n * does so with less overhead.\n * The constructor takes O((E + V) V)\n * time, where E is the number of edges and V is the\n * number of vertices in the graph.\n * It uses Θ(V) extra space (not including the graph).\n *
\n * See also {@link HopcroftKarp}, which solves the problem in\n * O(E sqrt(V)) using the Hopcroft-Karp\n * algorithm and\n * BipartiteMatchingToMaxflow,\n * which solves the problem in O((E + V) V)\n * time via a reduction to maxflow.\n *
\n * For additional documentation, see\n * Section 6.5\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BipartiteMatching {\n private static final int UNMATCHED = -1;\n\n private final int V; // number of vertices in the graph\n private BipartiteX bipartition; // the bipartition\n private int cardinality; // cardinality of current matching\n private int[] mate; // mate[v] = w if v-w is an edge in current matching\n // = -1 if v is not in current matching\n private boolean[] inMinVertexCover; // inMinVertexCover[v] = true iff v is in min vertex cover\n private boolean[] marked; // marked[v] = true iff v is reachable via alternating path\n private int[] edgeTo; // edgeTo[v] = last edge on alternating path to v\n\n /**\n * Determines a maximum matching (and a minimum vertex cover)\n * in a bipartite graph.\n *\n * @param G the bipartite graph\n * @throws IllegalArgumentException if {@code G} is not bipartite\n */\n public BipartiteMatching(Graph G) {\n bipartition = new BipartiteX(G);\n if (!bipartition.isBipartite()) {\n throw new IllegalArgumentException(\"graph is not bipartite\");\n }\n\n this.V = G.V();\n\n // initialize empty matching\n mate = new int[V];\n for (int v = 0; v < V; v++)\n mate[v] = UNMATCHED;\n\n // alternating path algorithm\n while (hasAugmentingPath(G)) {\n\n // find one endpoint t in alternating path\n int t = -1;\n for (int v = 0; v < G.V(); v++) {\n if (!isMatched(v) && edgeTo[v] != -1) {\n t = v;\n break;\n }\n }\n\n // update the matching according to alternating path in edgeTo[] array\n for (int v = t; v != -1; v = edgeTo[edgeTo[v]]) {\n int w = edgeTo[v];\n mate[v] = w;\n mate[w] = v;\n }\n cardinality++;\n }\n\n // find min vertex cover from marked[] array\n inMinVertexCover = new boolean[V];\n for (int v = 0; v < V; v++) {\n if (bipartition.color(v) && !marked[v]) inMinVertexCover[v] = true;\n if (!bipartition.color(v) && marked[v]) inMinVertexCover[v] = true;\n }\n\n assert certifySolution(G);\n }\n\n\n /*\n * is there an augmenting path?\n * - if so, upon termination adj[] contains the level graph;\n * - if not, upon termination marked[] specifies those vertices reachable via an alternating\n * path from one side of the bipartition\n *\n * an alternating path is a path whose edges belong alternately to the matching and not\n * to the matching\n *\n * an augmenting path is an alternating path that starts and ends at unmatched vertices\n *\n * this implementation finds a shortest augmenting path (fewest number of edges), though there\n * is no particular advantage to do so here\n */\n private boolean hasAugmentingPath(Graph G) {\n marked = new boolean[V];\n\n edgeTo = new int[V];\n for (int v = 0; v < V; v++)\n edgeTo[v] = -1;\n\n // breadth-first search (starting from all unmatched vertices on one side of bipartition)\n Queue queue = new Queue();\n for (int v = 0; v < V; v++) {\n if (bipartition.color(v) && !isMatched(v)) {\n queue.enqueue(v);\n marked[v] = true;\n }\n }\n\n // run BFS, stopping as soon as an alternating path is found\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : G.adj(v)) {\n\n // either (1) forward edge not in matching or (2) backward edge in matching\n if (isResidualGraphEdge(v, w) && !marked[w]) {\n edgeTo[w] = v;\n marked[w] = true;\n if (!isMatched(w)) return true;\n queue.enqueue(w);\n }\n }\n }\n\n return false;\n }\n\n // is the edge v-w a forward edge not in the matching or a reverse edge in the matching?\n private boolean isResidualGraphEdge(int v, int w) {\n if ((mate[v] != w) && bipartition.color(v)) return true;\n if ((mate[v] == w) && !bipartition.color(v)) return true;\n return false;\n }\n\n /**\n * Returns the vertex to which the specified vertex is matched in\n * the maximum matching computed by the algorithm.\n *\n * @param v the vertex\n * @return the vertex to which vertex {@code v} is matched in the\n * maximum matching; {@code -1} if the vertex is not matched\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n *\n */\n public int mate(int v) {\n validate(v);\n return mate[v];\n }\n\n /**\n * Returns true if the specified vertex is matched in the maximum matching\n * computed by the algorithm.\n *\n * @param v the vertex\n * @return {@code true} if vertex {@code v} is matched in maximum matching;\n * {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n *\n */\n public boolean isMatched(int v) {\n validate(v);\n return mate[v] != UNMATCHED;\n }\n\n /**\n * Returns the number of edges in a maximum matching.\n *\n * @return the number of edges in a maximum matching\n */\n public int size() {\n return cardinality;\n }\n\n /**\n * Returns true if the graph contains a perfect matching.\n * That is, the number of edges in a maximum matching is equal to one half\n * of the number of vertices in the graph (so that every vertex is matched).\n *\n * @return {@code true} if the graph contains a perfect matching;\n * {@code false} otherwise\n */\n public boolean isPerfect() {\n return cardinality * 2 == V;\n }\n\n /**\n * Returns true if the specified vertex is in the minimum vertex cover\n * computed by the algorithm.\n *\n * @param v the vertex\n * @return {@code true} if vertex {@code v} is in the minimum vertex cover;\n * {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean inMinVertexCover(int v) {\n validate(v);\n return inMinVertexCover[v];\n }\n\n private void validate(int v) {\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**************************************************************************\n *\n * The code below is solely for testing correctness of the data type.\n *\n **************************************************************************/\n\n // check that mate[] and inVertexCover[] define a max matching and min vertex cover, respectively\n private boolean certifySolution(Graph G) {\n\n // check that mate(v) = w iff mate(w) = v\n for (int v = 0; v < V; v++) {\n if (mate(v) == -1) continue;\n if (mate(mate(v)) != v) return false;\n }\n\n // check that size() is consistent with mate()\n int matchedVertices = 0;\n for (int v = 0; v < V; v++) {\n if (mate(v) != -1) matchedVertices++;\n }\n if (2*size() != matchedVertices) return false;\n\n // check that size() is consistent with minVertexCover()\n int sizeOfMinVertexCover = 0;\n for (int v = 0; v < V; v++)\n if (inMinVertexCover(v)) sizeOfMinVertexCover++;\n if (size() != sizeOfMinVertexCover) return false;\n\n // check that mate() uses each vertex at most once\n boolean[] isMatched = new boolean[V];\n for (int v = 0; v < V; v++) {\n int w = mate[v];\n if (w == -1) continue;\n if (v == w) return false;\n if (v >= w) continue;\n if (isMatched[v] || isMatched[w]) return false;\n isMatched[v] = true;\n isMatched[w] = true;\n }\n\n // check that mate() uses only edges that appear in the graph\n for (int v = 0; v < V; v++) {\n if (mate(v) == -1) continue;\n boolean isEdge = false;\n for (int w : G.adj(v)) {\n if (mate(v) == w) isEdge = true;\n }\n if (!isEdge) return false;\n }\n\n // check that inMinVertexCover() is a vertex cover\n for (int v = 0; v < V; v++)\n for (int w : G.adj(v))\n if (!inMinVertexCover(v) && !inMinVertexCover(w)) return false;\n\n return true;\n }\n\n /**\n * Unit tests the {@code HopcroftKarp} data type.\n * Takes three command-line arguments {@code V1}, {@code V2}, and {@code E};\n * creates a random bipartite graph with {@code V1} + {@code V2} vertices\n * and {@code E} edges; computes a maximum matching and minimum vertex cover;\n * and prints the results.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int V1 = Integer.parseInt(args[0]);\n int V2 = Integer.parseInt(args[1]);\n int E = Integer.parseInt(args[2]);\n Graph G = GraphGenerator.bipartite(V1, V2, E);\n\n if (G.V() < 1000) StdOut.println(G);\n\n BipartiteMatching matching = new BipartiteMatching(G);\n\n // print maximum matching\n StdOut.printf(\"Number of edges in max matching = %d\\n\", matching.size());\n StdOut.printf(\"Number of vertices in min vertex cover = %d\\n\", matching.size());\n StdOut.printf(\"Graph has a perfect matching = %b\\n\", matching.isPerfect());\n StdOut.println();\n\n if (G.V() >= 1000) return;\n\n StdOut.print(\"Max matching: \");\n for (int v = 0; v < G.V(); v++) {\n int w = matching.mate(v);\n if (matching.isMatched(v) && v < w) // print each edge only once\n StdOut.print(v + \"-\" + w + \" \");\n }\n StdOut.println();\n\n // print minimum vertex cover\n StdOut.print(\"Min vertex cover: \");\n for (int v = 0; v < G.V(); v++)\n if (matching.inMinVertexCover(v))\n StdOut.print(v + \" \");\n StdOut.println();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BipartiteX.java",
"content": "/******************************************************************************\n * Compilation: javac BipartiteX.java\n * Execution: java Bipartite V E F\n * Dependencies: Graph.java\n *\n * Given a graph, find either (i) a bipartition or (ii) an odd-length cycle.\n * Runs in O(E + V) time.\n *\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n\n/**\n * The {@code BipartiteX} class represents a data type for\n * determining whether an undirected graph is bipartite or whether\n * it has an odd-length cycle.\n * A graph is bipartite if and only if it has no odd-length cycle.\n * The isBipartite operation determines whether the graph is\n * bipartite. If so, the color operation determines a\n * bipartition; if not, the oddCycle operation determines a\n * cycle with an odd number of edges.\n *
\n * This implementation uses breadth-first search and is nonrecursive.\n * The constructor takes Θ(V + E) time in\n * in the worst case, where V is the number of vertices\n * and E is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n * See {@link Bipartite} for a recursive version that uses depth-first search.\n *
\n * For additional documentation,\n * see Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BipartiteX {\n private static final boolean WHITE = false;\n private static final boolean BLACK = true;\n\n private boolean isBipartite; // is the graph bipartite?\n private boolean[] color; // color[v] gives vertices on one side of bipartition\n private boolean[] marked; // marked[v] = true iff v has been visited in DFS\n private int[] edgeTo; // edgeTo[v] = last edge on path to v\n private Queue cycle; // odd-length cycle\n\n /**\n * Determines whether an undirected graph is bipartite and finds either a\n * bipartition or an odd-length cycle.\n *\n * @param graph the graph\n */\n public BipartiteX(Graph graph) {\n isBipartite = true;\n color = new boolean[graph.V()];\n marked = new boolean[graph.V()];\n edgeTo = new int[graph.V()];\n\n for (int v = 0; v < graph.V() && isBipartite; v++) {\n if (!marked[v]) {\n bfs(graph, v);\n }\n }\n assert check(graph);\n }\n\n private void bfs(Graph graph, int s) {\n Queue queue = new Queue();\n color[s] = WHITE;\n marked[s] = true;\n queue.enqueue(s);\n\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n marked[w] = true;\n edgeTo[w] = v;\n color[w] = !color[v];\n queue.enqueue(w);\n }\n else if (color[w] == color[v]) {\n isBipartite = false;\n\n // to form odd cycle, consider s-v path and s-w path\n // and let x be closest node to v and w common to two paths\n // then (w-x path) + (x-v path) + (edge v-w) is an odd-length cycle\n // Note: distTo[v] == distTo[w];\n cycle = new Queue();\n Stack stack = new Stack();\n int x = v, y = w;\n while (x != y) {\n stack.push(x);\n cycle.enqueue(y);\n x = edgeTo[x];\n y = edgeTo[y];\n }\n stack.push(x);\n while (!stack.isEmpty())\n cycle.enqueue(stack.pop());\n cycle.enqueue(w);\n return;\n }\n }\n }\n }\n\n /**\n * Returns true if the graph is bipartite.\n *\n * @return {@code true} if the graph is bipartite; {@code false} otherwise\n */\n public boolean isBipartite() {\n return isBipartite;\n }\n\n /**\n * Returns the side of the bipartite that vertex {@code v} is on.\n *\n * @param v the vertex\n * @return the side of the bipartition that vertex {@code v} is on; two vertices\n * are in the same side of the bipartition if and only if they have the\n * same color\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n * @throws UnsupportedOperationException if this method is called when the graph\n * is not bipartite\n */\n public boolean color(int v) {\n validateVertex(v);\n if (!isBipartite)\n throw new UnsupportedOperationException(\"Graph is not bipartite\");\n return color[v];\n }\n\n\n /**\n * Returns an odd-length cycle if the graph is not bipartite, and\n * {@code null} otherwise.\n *\n * @return an odd-length cycle if the graph is not bipartite\n * (and hence has an odd-length cycle), and {@code null}\n * otherwise\n */\n public Iterable oddCycle() {\n return cycle;\n }\n\n private boolean check(Graph graph) {\n // graph is bipartite\n if (isBipartite) {\n for (int v = 0; v < graph.V(); v++) {\n for (int w : graph.adj(v)) {\n if (color[v] == color[w]) {\n System.err.printf(\"edge %d-%d with %d and %d in same side of bipartition\\n\", v, w, v, w);\n return false;\n }\n }\n }\n }\n\n // graph has an odd-length cycle\n else {\n // verify cycle\n int first = -1, last = -1;\n for (int v : oddCycle()) {\n if (first == -1) first = v;\n last = v;\n }\n if (first != last) {\n System.err.printf(\"cycle begins with %d and ends with %d\\n\", first, last);\n return false;\n }\n }\n return true;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code BipartiteX} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int V1 = Integer.parseInt(args[0]);\n int V2 = Integer.parseInt(args[1]);\n int E = Integer.parseInt(args[2]);\n int F = Integer.parseInt(args[3]);\n\n // create random bipartite graph with V1 vertices on left side,\n // V2 vertices on right side, and E edges; then add F random edges\n Graph graph = GraphGenerator.bipartite(V1, V2, E);\n for (int i = 0; i < F; i++) {\n int v = StdRandom.uniformInt(V1 + V2);\n int w = StdRandom.uniformInt(V1 + V2);\n graph.addEdge(v, w);\n }\n\n StdOut.println(graph);\n\n\n BipartiteX b = new BipartiteX(graph);\n if (b.isBipartite()) {\n StdOut.println(\"Graph is bipartite\");\n for (int v = 0; v < graph.V(); v++) {\n StdOut.println(v + \": \" + b.color(v));\n }\n }\n else {\n StdOut.print(\"Graph has an odd-length cycle: \");\n for (int x : b.oddCycle()) {\n StdOut.print(x + \" \");\n }\n StdOut.println();\n }\n }\n\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BlockFilter.java",
"content": "/******************************************************************************\n * Compilation: javac BlockFilter.java\n * Execution: java BlockFilter blocklist.txt < input.txt\n * Dependencies: SET In.java StdIn.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/35applications/tinyTale.txt\n * https://algs4.cs.princeton.edu/35applications/blocklist.txt\n *\n * Reads a blocklist of words from a file. Then reads a list of\n * words from standard input and print all those words that\n * are not in the first file.\n *\n * % more tinyTale.txt\n * it was the best of times it was the worst of times\n * it was the age of wisdom it was the age of foolishness\n * it was the epoch of belief it was the epoch of incredulity\n * it was the season of light it was the season of darkness\n * it was the spring of hope it was the winter of despair\n *\n * % more list.txt\n * was it the of\n *\n * % java BlockFilter list.txt < tinyTale.txt\n * best times worst times\n * age wisdom age foolishness\n * epoch belief epoch incredulity\n * season light season darkness\n * spring hope winter despair\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BlockFilter} class provides a client for reading in a blocklist\n * of words from a file; then, reading in a sequence of words from standard input,\n * printing out each word that does not appear in the file.\n * It is useful as a test client for various symbol-table implementations.\n *
\n * For additional documentation,\n * see Section 3.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BlockFilter {\n\n // Do not instantiate.\n private BlockFilter() { }\n\n public static void main(String[] args) {\n SET set = new SET();\n\n // read in strings and add to set\n In in = new In(args[0]);\n while (!in.isEmpty()) {\n String word = in.readString();\n set.add(word);\n }\n\n // read in string from standard input, printing out all exceptions\n while (!StdIn.isEmpty()) {\n String word = StdIn.readString();\n if (!set.contains(word))\n StdOut.println(word);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BoruvkaMST.java",
"content": "/******************************************************************************\n * Compilation: javac BoruvkaMST.java\n * Execution: java BoruvkaMST filename.txt\n * Dependencies: EdgeWeightedGraph.java Edge.java Bag.java\n * UF.java In.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/43mst/tinyEWG.txt\n * https://algs4.cs.princeton.edu/43mst/mediumEWG.txt\n * https://algs4.cs.princeton.edu/43mst/largeEWG.txt\n *\n * Compute a minimum spanning forest using Boruvka's algorithm.\n *\n * % java BoruvkaMST tinyEWG.txt\n * 0-2 0.26000\n * 6-2 0.40000\n * 5-7 0.28000\n * 4-5 0.35000\n * 2-3 0.17000\n * 1-7 0.19000\n * 0-7 0.16000\n * 1.81000\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BoruvkaMST} class represents a data type for computing a\n * minimum spanning tree in an edge-weighted graph.\n * The edge weights can be positive, zero, or negative and need not\n * be distinct. If the graph is not connected, it computes a minimum\n * spanning forest, which is the union of minimum spanning trees\n * in each connected component. The {@code weight()} method returns the\n * weight of a minimum spanning tree and the {@code edges()} method\n * returns its edges.\n *
\n * This implementation uses Boruvka's algorithm and the union-find\n * data type.\n * The constructor takes Θ(E log V) time in\n * the worst case, where V is the number of vertices and\n * E is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the\n * edge-weighted graph).\n *
\n * This {@code weight()} method correctly computes the weight of the MST\n * if all arithmetic performed is without floating-point rounding error\n * or arithmetic overflow.\n * This is the case if all edge weights are non-negative integers\n * and the weight of the MST does not exceed 252.\n *
\n * For additional documentation,\n * see Section 4.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n * For alternate implementations, see {@link LazyPrimMST}, {@link PrimMST},\n * and {@link KruskalMST}.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BoruvkaMST {\n private static final double FLOATING_POINT_EPSILON = 1.0E-12;\n\n private Bag mst = new Bag(); // edges in MST\n private double weight; // weight of MST\n\n /**\n * Compute a minimum spanning tree (or forest) of an edge-weighted graph.\n * @param graph the edge-weighted graph\n */\n public BoruvkaMST(EdgeWeightedGraph graph) {\n UF uf = new UF(graph.V());\n\n // repeat at most log V times or until we have V-1 edges\n for (int t = 1; t < graph.V() && mst.size() < graph.V() - 1; t = t + t) {\n\n // foreach tree in forest, find closest edge\n // if edge weights are equal, ties are broken in favor of first edge in graph.edges()\n Edge[] closest = new Edge[graph.V()];\n for (Edge e : graph.edges()) {\n int v = e.either(), w = e.other(v);\n int i = uf.find(v), j = uf.find(w);\n if (i == j) continue; // same tree\n if (closest[i] == null || less(e, closest[i])) closest[i] = e;\n if (closest[j] == null || less(e, closest[j])) closest[j] = e;\n }\n\n // add newly discovered edges to MST\n for (int i = 0; i < graph.V(); i++) {\n Edge e = closest[i];\n if (e != null) {\n int v = e.either(), w = e.other(v);\n // don't add the same edge twice\n if (uf.find(v) != uf.find(w)) {\n mst.add(e);\n weight += e.weight();\n uf.union(v, w);\n }\n }\n }\n }\n\n // check optimality conditions\n assert check(graph);\n }\n\n /**\n * Returns the edges in a minimum spanning tree (or forest).\n * @return the edges in a minimum spanning tree (or forest) as\n * an iterable of edges\n */\n public Iterable edges() {\n return mst;\n }\n\n\n /**\n * Returns the sum of the edge weights in a minimum spanning tree (or forest).\n * @return the sum of the edge weights in a minimum spanning tree (or forest)\n */\n public double weight() {\n return weight;\n }\n\n // is the weight of edge e strictly less than that of edge f?\n private static boolean less(Edge e, Edge f) {\n return e.compareTo(f) < 0;\n }\n\n // check optimality conditions (takes time proportional to E V lg* V)\n private boolean check(EdgeWeightedGraph graph) {\n\n // check weight\n double totalWeight = 0.0;\n for (Edge e : edges()) {\n totalWeight += e.weight();\n }\n if (Math.abs(totalWeight - weight()) > FLOATING_POINT_EPSILON) {\n System.err.printf(\"Weight of edges does not equal weight(): %f vs. %f\\n\", totalWeight, weight());\n return false;\n }\n\n // check that it is acyclic\n UF uf = new UF(graph.V());\n for (Edge e : edges()) {\n int v = e.either(), w = e.other(v);\n if (uf.find(v) == uf.find(w)) {\n System.err.println(\"Not a forest\");\n return false;\n }\n uf.union(v, w);\n }\n\n // check that it is a spanning forest\n for (Edge e : graph.edges()) {\n int v = e.either(), w = e.other(v);\n if (uf.find(v) != uf.find(w)) {\n System.err.println(\"Not a spanning forest\");\n return false;\n }\n }\n\n // check that it is a minimal spanning forest (cut optimality conditions)\n for (Edge e : edges()) {\n\n // all edges in MST except e\n uf = new UF(graph.V());\n for (Edge f : mst) {\n int x = f.either(), y = f.other(x);\n if (f != e) uf.union(x, y);\n }\n\n // check that e is min weight edge in crossing cut\n for (Edge f : graph.edges()) {\n int x = f.either(), y = f.other(x);\n if (uf.find(x) != uf.find(y)) {\n if (f.weight() < e.weight()) {\n System.err.println(\"Edge \" + f + \" violates cut optimality conditions\");\n return false;\n }\n }\n }\n\n }\n\n return true;\n }\n\n /**\n * Unit tests the {@code BoruvkaMST} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n EdgeWeightedGraph graph = new EdgeWeightedGraph(in);\n BoruvkaMST mst = new BoruvkaMST(graph);\n for (Edge e : mst.edges()) {\n StdOut.println(e);\n }\n StdOut.printf(\"%.5f\\n\", mst.weight());\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BoyerMoore.java",
"content": "/******************************************************************************\n * Compilation: javac BoyerMoore.java\n * Execution: java BoyerMoore pattern text\n * Dependencies: StdOut.java\n *\n * Reads in two strings, the pattern and the input text, and\n * searches for the pattern in the input text using the\n * bad-character rule part of the Boyer-Moore algorithm.\n * (does not implement the strong good suffix rule)\n *\n * % java BoyerMoore abracadabra abacadabrabracabracadabrabrabracad\n * text: abacadabrabracabracadabrabrabracad\n * pattern: abracadabra\n *\n * % java BoyerMoore rab abacadabrabracabracadabrabrabracad\n * text: abacadabrabracabracadabrabrabracad\n * pattern: rab\n *\n * % java BoyerMoore bcara abacadabrabracabracadabrabrabracad\n * text: abacadabrabracabracadabrabrabracad\n * pattern: bcara\n *\n * % java BoyerMoore rabrabracad abacadabrabracabracadabrabrabracad\n * text: abacadabrabracabracadabrabrabracad\n * pattern: rabrabracad\n *\n * % java BoyerMoore abacad abacadabrabracabracadabrabrabracad\n * text: abacadabrabracabracadabrabrabracad\n * pattern: abacad\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BoyerMoore} class finds the first occurrence of a pattern string\n * in a text string.\n *
\n * This implementation uses the Boyer-Moore algorithm (with the bad-character\n * rule, but not the strong good suffix rule).\n *
\n * For additional documentation,\n * see Section 5.3 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n */\npublic class BoyerMoore {\n private final int R; // the radix\n private int[] right; // the bad-character skip array\n\n private char[] pattern; // store the pattern as a character array\n private String pat; // or as a string\n\n /**\n * Preprocesses the pattern string.\n *\n * @param pat the pattern string\n */\n public BoyerMoore(String pat) {\n this.R = 256;\n this.pat = pat;\n\n // position of rightmost occurrence of c in the pattern\n right = new int[R];\n for (int c = 0; c < R; c++)\n right[c] = -1;\n for (int j = 0; j < pat.length(); j++)\n right[pat.charAt(j)] = j;\n }\n\n /**\n * Preprocesses the pattern string.\n *\n * @param pattern the pattern string\n * @param R the alphabet size\n */\n public BoyerMoore(char[] pattern, int R) {\n this.R = R;\n this.pattern = new char[pattern.length];\n for (int j = 0; j < pattern.length; j++)\n this.pattern[j] = pattern[j];\n\n // position of rightmost occurrence of c in the pattern\n right = new int[R];\n for (int c = 0; c < R; c++)\n right[c] = -1;\n for (int j = 0; j < pattern.length; j++)\n right[pattern[j]] = j;\n }\n\n /**\n * Returns the index of the first occurrence of the pattern string\n * in the text string.\n *\n * @param txt the text string\n * @return the index of the first occurrence of the pattern string\n * in the text string; n if no such match\n */\n public int search(String txt) {\n int m = pat.length();\n int n = txt.length();\n int skip;\n for (int i = 0; i <= n - m; i += skip) {\n skip = 0;\n for (int j = m-1; j >= 0; j--) {\n if (pat.charAt(j) != txt.charAt(i+j)) {\n skip = Math.max(1, j - right[txt.charAt(i+j)]);\n break;\n }\n }\n if (skip == 0) return i; // found\n }\n return n; // not found\n }\n\n\n /**\n * Returns the index of the first occurrence of the pattern string\n * in the text string.\n *\n * @param text the text string\n * @return the index of the first occurrence of the pattern string\n * in the text string; n if no such match\n */\n public int search(char[] text) {\n int m = pattern.length;\n int n = text.length;\n int skip;\n for (int i = 0; i <= n - m; i += skip) {\n skip = 0;\n for (int j = m-1; j >= 0; j--) {\n if (pattern[j] != text[i+j]) {\n skip = Math.max(1, j - right[text[i+j]]);\n break;\n }\n }\n if (skip == 0) return i; // found\n }\n return n; // not found\n }\n\n\n /**\n * Takes a pattern string and an input string as command-line arguments;\n * searches for the pattern string in the text string; and prints\n * the first occurrence of the pattern string in the text string.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n String pat = args[0];\n String txt = args[1];\n char[] pattern = pat.toCharArray();\n char[] text = txt.toCharArray();\n\n BoyerMoore boyermoore1 = new BoyerMoore(pat);\n BoyerMoore boyermoore2 = new BoyerMoore(pattern, 256);\n int offset1 = boyermoore1.search(txt);\n int offset2 = boyermoore2.search(text);\n\n // print results\n StdOut.println(\"text: \" + txt);\n\n StdOut.print(\"pattern: \");\n for (int i = 0; i < offset1; i++)\n StdOut.print(\" \");\n StdOut.println(pat);\n\n StdOut.print(\"pattern: \");\n for (int i = 0; i < offset2; i++)\n StdOut.print(\" \");\n StdOut.println(pat);\n }\n}\n\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BreadthFirstDirectedPaths.java",
"content": "/******************************************************************************\n * Compilation: javac BreadthFirstDirectedPaths.java\n * Execution: java BreadthFirstDirectedPaths digraph.txt s\n * Dependencies: Digraph.java Queue.java Stack.java\n * Data files: https://algs4.cs.princeton.edu/42digraph/tinyDG.txt\n * https://algs4.cs.princeton.edu/42digraph/mediumDG.txt\n * https://algs4.cs.princeton.edu/42digraph/largeDG.txt\n *\n * Run breadth-first search on a digraph.\n * Runs in O(E + V) time.\n *\n * % java BreadthFirstDirectedPaths tinyDG.txt 3\n * 3 to 0 (2): 3->2->0\n * 3 to 1 (3): 3->2->0->1\n * 3 to 2 (1): 3->2\n * 3 to 3 (0): 3\n * 3 to 4 (2): 3->5->4\n * 3 to 5 (1): 3->5\n * 3 to 6 (-): not connected\n * 3 to 7 (-): not connected\n * 3 to 8 (-): not connected\n * 3 to 9 (-): not connected\n * 3 to 10 (-): not connected\n * 3 to 11 (-): not connected\n * 3 to 12 (-): not connected\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code BreadthDirectedFirstPaths} class represents a data type for\n * finding shortest paths (number of edges) from a source vertex s\n * (or set of source vertices) to every other vertex in the digraph.\n *
\n * This implementation uses breadth-first search.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and E is\n * the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the digraph).\n *
\n * For additional documentation,\n * see Section 4.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BreadthFirstDirectedPaths {\n private static final int INFINITY = Integer.MAX_VALUE;\n private boolean[] marked; // marked[v] = is there an s->v path?\n private int[] edgeTo; // edgeTo[v] = last edge on shortest s->v path\n private int[] distTo; // distTo[v] = length of shortest s->v path\n\n /**\n * Computes the shortest path from {@code s} and every other vertex in {@code digraph}.\n * @param digraph the digraph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public BreadthFirstDirectedPaths(Digraph digraph, int s) {\n marked = new boolean[digraph.V()];\n distTo = new int[digraph.V()];\n edgeTo = new int[digraph.V()];\n for (int v = 0; v < digraph.V(); v++)\n distTo[v] = INFINITY;\n validateVertex(s);\n bfs(digraph, s);\n }\n\n /**\n * Computes the shortest path from any one of the source vertices in {@code sources}\n * to every other vertex in {@code digraph}.\n * @param digraph the digraph\n * @param sources the source vertices\n * @throws IllegalArgumentException if {@code sources} is {@code null}\n * @throws IllegalArgumentException if {@code sources} contains no vertices\n * @throws IllegalArgumentException unless each vertex {@code v} in\n * {@code sources} satisfies {@code 0 <= v < V}\n */\n public BreadthFirstDirectedPaths(Digraph digraph, Iterable sources) {\n marked = new boolean[digraph.V()];\n distTo = new int[digraph.V()];\n edgeTo = new int[digraph.V()];\n for (int v = 0; v < digraph.V(); v++)\n distTo[v] = INFINITY;\n validateVertices(sources);\n bfs(digraph, sources);\n }\n\n // BFS from single source\n private void bfs(Digraph digraph, int s) {\n Queue queue = new Queue();\n marked[s] = true;\n distTo[s] = 0;\n queue.enqueue(s);\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : digraph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n distTo[w] = distTo[v] + 1;\n marked[w] = true;\n queue.enqueue(w);\n }\n }\n }\n }\n\n // BFS from multiple sources\n private void bfs(Digraph digraph, Iterable sources) {\n Queue queue = new Queue();\n for (int s : sources) {\n marked[s] = true;\n distTo[s] = 0;\n queue.enqueue(s);\n }\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : digraph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n distTo[w] = distTo[v] + 1;\n marked[w] = true;\n queue.enqueue(w);\n }\n }\n }\n }\n\n /**\n * Is there a directed path from the source {@code s} (or sources) to vertex {@code v}?\n * @param v the vertex\n * @return {@code true} if there is a directed path, {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return marked[v];\n }\n\n /**\n * Returns the number of edges in a shortest path from the source {@code s}\n * (or sources) to vertex {@code v}?\n * @param v the vertex\n * @return the number of edges in such a shortest path\n * (or {@code Integer.MAX_VALUE} if there is no such path)\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int distTo(int v) {\n validateVertex(v);\n return distTo[v];\n }\n\n /**\n * Returns a shortest path from {@code s} (or sources) to {@code v}, or\n * {@code null} if no such path.\n * @param v the vertex\n * @return the sequence of vertices on a shortest path, as an Iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n int x;\n for (x = v; distTo[x] != 0; x = edgeTo[x])\n path.push(x);\n path.push(x);\n return path;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n // throw an IllegalArgumentException if vertices is null, has zero vertices,\n // or has a vertex not between 0 and V-1\n private void validateVertices(Iterable vertices) {\n if (vertices == null) {\n throw new IllegalArgumentException(\"argument is null\");\n }\n int vertexCount = 0;\n for (Integer v : vertices) {\n vertexCount++;\n if (v == null) {\n throw new IllegalArgumentException(\"vertex is null\");\n }\n validateVertex(v);\n }\n if (vertexCount == 0) {\n throw new IllegalArgumentException(\"zero vertices\");\n }\n }\n\n /**\n * Unit tests the {@code BreadthFirstDirectedPaths} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Digraph digraph = new Digraph(in);\n // StdOut.println(digraph);\n\n int s = Integer.parseInt(args[1]);\n BreadthFirstDirectedPaths bfs = new BreadthFirstDirectedPaths(digraph, s);\n\n for (int v = 0; v < digraph.V(); v++) {\n if (bfs.hasPathTo(v)) {\n StdOut.printf(\"%d to %d (%d): \", s, v, bfs.distTo(v));\n for (int x : bfs.pathTo(v)) {\n if (x == s) StdOut.print(x);\n else StdOut.print(\"->\" + x);\n }\n StdOut.println();\n }\n\n else {\n StdOut.printf(\"%d to %d (-): not connected\\n\", s, v);\n }\n\n }\n }\n\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/BreadthFirstPaths.java",
"content": "/******************************************************************************\n * Compilation: javac BreadthFirstPaths.java\n * Execution: java BreadthFirstPaths G s\n * Dependencies: Graph.java Queue.java Stack.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyCG.txt\n * https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n * https://algs4.cs.princeton.edu/41graph/largeG.txt\n *\n * Run breadth first search on an undirected graph.\n * Runs in O(E + V) time.\n *\n * % java Graph tinyCG.txt\n * 6 8\n * 0: 2 1 5\n * 1: 0 2\n * 2: 0 1 3 4\n * 3: 5 4 2\n * 4: 3 2\n * 5: 3 0\n *\n * % java BreadthFirstPaths tinyCG.txt 0\n * 0 to 0 (0): 0\n * 0 to 1 (1): 0-1\n * 0 to 2 (1): 0-2\n * 0 to 3 (2): 0-2-3\n * 0 to 4 (2): 0-2-4\n * 0 to 5 (1): 0-5\n *\n * % java BreadthFirstPaths largeG.txt 0\n * 0 to 0 (0): 0\n * 0 to 1 (418): 0-932942-474885-82707-879889-971961-...\n * 0 to 2 (323): 0-460790-53370-594358-780059-287921-...\n * 0 to 3 (168): 0-713461-75230-953125-568284-350405-...\n * 0 to 4 (144): 0-460790-53370-310931-440226-380102-...\n * 0 to 5 (566): 0-932942-474885-82707-879889-971961-...\n * 0 to 6 (349): 0-932942-474885-82707-879889-971961-...\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n\n/**\n * The {@code BreadthFirstPaths} class represents a data type for finding\n * shortest paths (number of edges) from a source vertex s\n * (or a set of source vertices)\n * to every other vertex in an undirected graph.\n *
\n * This implementation uses breadth-first search.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and E\n * is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n *
\n * For additional documentation,\n * see Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class BreadthFirstPaths {\n private static final int INFINITY = Integer.MAX_VALUE;\n private boolean[] marked; // marked[v] = is there an s-v path\n private int[] edgeTo; // edgeTo[v] = previous edge on shortest s-v path\n private int[] distTo; // distTo[v] = number of edges shortest s-v path\n\n /**\n * Computes the shortest path between the source vertex {@code s}\n * and every other vertex in the undirected graph {@code graph}.\n * @param graph the graph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public BreadthFirstPaths(Graph graph, int s) {\n marked = new boolean[graph.V()];\n distTo = new int[graph.V()];\n edgeTo = new int[graph.V()];\n validateVertex(s);\n bfs(graph, s);\n\n assert check(graph, s);\n }\n\n /**\n * Computes the shortest path between any one of the source vertices in {@code sources}\n * and every other vertex in {@code graph}.\n * @param graph the graph\n * @param sources the source vertices\n * @throws IllegalArgumentException if {@code sources} is {@code null}\n * @throws IllegalArgumentException if {@code sources} contains no vertices\n * @throws IllegalArgumentException unless {@code 0 <= s < V} for each vertex\n * {@code s} in {@code sources}\n */\n public BreadthFirstPaths(Graph graph, Iterable sources) {\n marked = new boolean[graph.V()];\n distTo = new int[graph.V()];\n edgeTo = new int[graph.V()];\n for (int v = 0; v < graph.V(); v++)\n distTo[v] = INFINITY;\n validateVertices(sources);\n bfs(graph, sources);\n }\n\n\n // breadth-first search from a single source\n private void bfs(Graph graph, int s) {\n Queue queue = new Queue();\n for (int v = 0; v < graph.V(); v++)\n distTo[v] = INFINITY;\n distTo[s] = 0;\n marked[s] = true;\n queue.enqueue(s);\n\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n distTo[w] = distTo[v] + 1;\n marked[w] = true;\n queue.enqueue(w);\n }\n }\n }\n }\n\n // breadth-first search from multiple sources\n private void bfs(Graph graph, Iterable sources) {\n Queue queue = new Queue();\n for (int s : sources) {\n marked[s] = true;\n distTo[s] = 0;\n queue.enqueue(s);\n }\n while (!queue.isEmpty()) {\n int v = queue.dequeue();\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n distTo[w] = distTo[v] + 1;\n marked[w] = true;\n queue.enqueue(w);\n }\n }\n }\n }\n\n /**\n * Is there a path between the source vertex {@code s} (or sources) and vertex {@code v}?\n * @param v the vertex\n * @return {@code true} if there is a path, and {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return marked[v];\n }\n\n /**\n * Returns the number of edges in a shortest path between the source vertex {@code s}\n * (or sources) and vertex {@code v}?\n * @param v the vertex\n * @return the number of edges in such a shortest path\n * (or {@code Integer.MAX_VALUE} if there is no such path)\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int distTo(int v) {\n validateVertex(v);\n return distTo[v];\n }\n\n /**\n * Returns a shortest path between the source vertex {@code s} (or sources)\n * and {@code v}, or {@code null} if no such path.\n * @param v the vertex\n * @return the sequence of vertices on a shortest path, as an Iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n int x;\n for (x = v; distTo[x] != 0; x = edgeTo[x])\n path.push(x);\n path.push(x);\n return path;\n }\n\n\n // check optimality conditions for single source\n private boolean check(Graph graph, int s) {\n\n // check that the distance of s = 0\n if (distTo[s] != 0) {\n StdOut.println(\"distance of source \" + s + \" to itself = \" + distTo[s]);\n return false;\n }\n\n // check that for each edge v-w dist[w] <= dist[v] + 1\n // provided v is reachable from s\n for (int v = 0; v < graph.V(); v++) {\n for (int w : graph.adj(v)) {\n if (hasPathTo(v) != hasPathTo(w)) {\n StdOut.println(\"edge \" + v + \"-\" + w);\n StdOut.println(\"hasPathTo(\" + v + \") = \" + hasPathTo(v));\n StdOut.println(\"hasPathTo(\" + w + \") = \" + hasPathTo(w));\n return false;\n }\n if (hasPathTo(v) && (distTo[w] > distTo[v] + 1)) {\n StdOut.println(\"edge \" + v + \"-\" + w);\n StdOut.println(\"distTo[\" + v + \"] = \" + distTo[v]);\n StdOut.println(\"distTo[\" + w + \"] = \" + distTo[w]);\n return false;\n }\n }\n }\n\n // check that v = edgeTo[w] satisfies distTo[w] = distTo[v] + 1\n // provided v is reachable from s\n for (int w = 0; w < graph.V(); w++) {\n if (!hasPathTo(w) || w == s) continue;\n int v = edgeTo[w];\n if (distTo[w] != distTo[v] + 1) {\n StdOut.println(\"shortest path edge \" + v + \"-\" + w);\n StdOut.println(\"distTo[\" + v + \"] = \" + distTo[v]);\n StdOut.println(\"distTo[\" + w + \"] = \" + distTo[w]);\n return false;\n }\n }\n\n return true;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n // throw an IllegalArgumentException if vertices is null, has zero vertices,\n // or has a vertex not between 0 and V-1\n private void validateVertices(Iterable vertices) {\n if (vertices == null) {\n throw new IllegalArgumentException(\"argument is null\");\n }\n int vertexCount = 0;\n for (Integer v : vertices) {\n vertexCount++;\n if (v == null) {\n throw new IllegalArgumentException(\"vertex is null\");\n }\n validateVertex(v);\n }\n if (vertexCount == 0) {\n throw new IllegalArgumentException(\"zero vertices\");\n }\n }\n\n /**\n * Unit tests the {@code BreadthFirstPaths} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Graph graph = new Graph(in);\n // StdOut.println(graph);\n\n int s = Integer.parseInt(args[1]);\n BreadthFirstPaths bfs = new BreadthFirstPaths(graph, s);\n\n for (int v = 0; v < graph.V(); v++) {\n if (bfs.hasPathTo(v)) {\n StdOut.printf(\"%d to %d (%d): \", s, v, bfs.distTo(v));\n for (int x : bfs.pathTo(v)) {\n if (x == s) StdOut.print(x);\n else StdOut.print(\"-\" + x);\n }\n StdOut.println();\n }\n\n else {\n StdOut.printf(\"%d to %d (-): not connected\\n\", s, v);\n }\n\n }\n }\n\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/CC.java",
"content": "/******************************************************************************\n * Compilation: javac CC.java\n * Execution: java CC filename.txt\n * Dependencies: Graph.java StdOut.java Queue.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n * https://algs4.cs.princeton.edu/41graph/largeG.txt\n *\n * Compute connected components using depth first search.\n * Runs in O(E + V) time.\n *\n * % java CC tinyG.txt\n * 3 components\n * 0 1 2 3 4 5 6\n * 7 8\n * 9 10 11 12\n *\n * % java CC mediumG.txt\n * 1 components\n * 0 1 2 3 4 5 6 7 8 9 10 ...\n *\n * % java -Xss50m CC largeG.txt\n * 1 components\n * 0 1 2 3 4 5 6 7 8 9 10 ...\n *\n * Note: This implementation uses a recursive DFS. To avoid needing\n * a potentially very large stack size, replace with a nonrecursive\n * DFS ala NonrecursiveDFS.java.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code CC} class represents a data type for\n * determining the connected components in an undirected graph.\n * The id operation determines in which connected component\n * a given vertex lies; the connected operation\n * determines whether two vertices are in the same connected component;\n * the count operation determines the number of connected\n * components; and the size operation determines the number\n * of vertices in the connect component containing a given vertex.\n *
\n * The component identifier of a vertex is an integer between\n * 0 and k–1, where k is the number of connected components.\n * Two vertices have the same component identifier if and only if\n * they are in the same connected component.\n *
\n * This implementation uses depth-first search.\n * The constructor takes Θ(V + E) time,\n * where V is the number of vertices and E is the\n * number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n *
\n * For additional documentation, see\n * Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class CC {\n private boolean[] marked; // marked[v] = has vertex v been marked?\n private int[] id; // id[v] = id of connected component containing v\n private int[] size; // size[id] = number of vertices in given component\n private int count; // number of connected components\n\n /**\n * Computes the connected components of the undirected graph {@code graph}.\n *\n * @param graph the undirected graph\n */\n public CC(Graph graph) {\n marked = new boolean[graph.V()];\n id = new int[graph.V()];\n size = new int[graph.V()];\n for (int v = 0; v < graph.V(); v++) {\n if (!marked[v]) {\n dfs(graph, v);\n count++;\n }\n }\n }\n\n /**\n * Computes the connected components of the edge-weighted graph {@code graph}.\n *\n * @param graph the edge-weighted graph\n */\n public CC(EdgeWeightedGraph graph) {\n marked = new boolean[graph.V()];\n id = new int[graph.V()];\n size = new int[graph.V()];\n for (int v = 0; v < graph.V(); v++) {\n if (!marked[v]) {\n dfs(graph, v);\n count++;\n }\n }\n }\n\n // depth-first search for a Graph\n private void dfs(Graph graph, int v) {\n marked[v] = true;\n id[v] = count;\n size[count]++;\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n dfs(graph, w);\n }\n }\n }\n\n // depth-first search for an EdgeWeightedGraph\n private void dfs(EdgeWeightedGraph graph, int v) {\n marked[v] = true;\n id[v] = count;\n size[count]++;\n for (Edge e : graph.adj(v)) {\n int w = e.other(v);\n if (!marked[w]) {\n dfs(graph, w);\n }\n }\n }\n\n\n /**\n * Returns the component id of the connected component containing vertex {@code v}.\n *\n * @param v the vertex\n * @return the component id of the connected component containing vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int id(int v) {\n validateVertex(v);\n return id[v];\n }\n\n /**\n * Returns the number of vertices in the connected component containing vertex {@code v}.\n *\n * @param v the vertex\n * @return the number of vertices in the connected component containing vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int size(int v) {\n validateVertex(v);\n return size[id[v]];\n }\n\n /**\n * Returns the number of connected components in the graph {@code G}.\n *\n * @return the number of connected components in the graph {@code G}\n */\n public int count() {\n return count;\n }\n\n /**\n * Returns true if vertices {@code v} and {@code w} are in the same\n * connected component.\n *\n * @param v one vertex\n * @param w the other vertex\n * @return {@code true} if vertices {@code v} and {@code w} are in the same\n * connected component; {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n * @throws IllegalArgumentException unless {@code 0 <= w < V}\n */\n public boolean connected(int v, int w) {\n validateVertex(v);\n validateVertex(w);\n return id(v) == id(w);\n }\n\n /**\n * Returns true if vertices {@code v} and {@code w} are in the same\n * connected component.\n *\n * @param v one vertex\n * @param w the other vertex\n * @return {@code true} if vertices {@code v} and {@code w} are in the same\n * connected component; {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n * @throws IllegalArgumentException unless {@code 0 <= w < V}\n * @deprecated Replaced by {@link #connected(int, int)}.\n */\n @Deprecated\n public boolean areConnected(int v, int w) {\n validateVertex(v);\n validateVertex(w);\n return id(v) == id(w);\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code CC} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Graph graph = new Graph(in);\n CC cc = new CC(graph);\n\n // number of connected components\n int m = cc.count();\n StdOut.println(m + \" components\");\n\n // compute list of vertices in each connected component\n Queue[] components = (Queue[]) new Queue[m];\n for (int i = 0; i < m; i++) {\n components[i] = new Queue();\n }\n for (int v = 0; v < graph.V(); v++) {\n components[cc.id(v)].enqueue(v);\n }\n\n // print results\n for (int i = 0; i < m; i++) {\n for (int v : components[i]) {\n StdOut.print(v + \" \");\n }\n StdOut.println();\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/CPM.java",
"content": "/******************************************************************************\n * Compilation: javac CPM.java\n * Execution: java CPM < input.txt\n * Dependencies: EdgeWeightedDigraph.java AcyclicDigraphLP.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/44sp/jobsPC.txt\n *\n * Critical path method.\n *\n * % java CPM < jobsPC.txt\n * job start finish\n * --------------------\n * 0 0.0 41.0\n * 1 41.0 92.0\n * 2 123.0 173.0\n * 3 91.0 127.0\n * 4 70.0 108.0\n * 5 0.0 45.0\n * 6 70.0 91.0\n * 7 41.0 73.0\n * 8 91.0 123.0\n * 9 41.0 70.0\n * Finish time: 173.0\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code CPM} class provides a client that solves the\n * parallel precedence-constrained job scheduling problem\n * via the critical path method. It reduces the problem\n * to the longest-paths problem in edge-weighted DAGs.\n * It builds an edge-weighted digraph (which must be a DAG)\n * from the job-scheduling problem specification,\n * finds the longest-paths tree, and computes the longest-paths\n * lengths (which are precisely the start times for each job).\n *
\n * This implementation uses {@link AcyclicLP} to find a longest\n * path in a DAG.\n * The program takes Θ(V + E) time in\n * the worst case, where V is the number of jobs and\n * E is the number of precedence constraints.\n *
\n * For additional documentation,\n * see Section 4.4 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class CPM {\n\n // this class cannot be instantiated\n private CPM() { }\n\n /**\n * Reads the precedence constraints from standard input\n * and prints a feasible schedule to standard output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n // number of jobs\n int n = StdIn.readInt();\n\n // source and sink\n int source = 2*n;\n int sink = 2*n + 1;\n\n // build network\n EdgeWeightedDigraph G = new EdgeWeightedDigraph(2*n + 2);\n for (int i = 0; i < n; i++) {\n double duration = StdIn.readDouble();\n G.addEdge(new DirectedEdge(source, i, 0.0));\n G.addEdge(new DirectedEdge(i+n, sink, 0.0));\n G.addEdge(new DirectedEdge(i, i+n, duration));\n\n // precedence constraints\n int m = StdIn.readInt();\n for (int j = 0; j < m; j++) {\n int precedent = StdIn.readInt();\n G.addEdge(new DirectedEdge(n+i, precedent, 0.0));\n }\n }\n\n // compute longest path\n AcyclicLP lp = new AcyclicLP(G, source);\n\n // print results\n StdOut.println(\" job start finish\");\n StdOut.println(\"--------------------\");\n for (int i = 0; i < n; i++) {\n StdOut.printf(\"%4d %7.1f %7.1f\\n\", i, lp.distTo(i), lp.distTo(i+n));\n }\n StdOut.printf(\"Finish time: %7.1f\\n\", lp.distTo(sink));\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Cat.java",
"content": "/******************************************************************************\n * Compilation: javac Cat.java\n * Execution: java Cat input0.txt input1.txt ... output.txt\n * Dependencies: In.java Out.java\n * Data files: https://algs4.cs.princeton.edu/11model/in1.txt\n * https://algs4.cs.princeton.edu/11model/in2.txt\n *\n * Reads in text files specified as the first command-line\n * arguments, concatenates them, and writes the result to\n * filename specified as the last command-line arguments.\n *\n * % more in1.txt\n * This is\n *\n * % more in2.txt\n * a tiny\n * test.\n *\n * % java Cat in1.txt in2.txt out.txt\n *\n * % more out.txt\n * This is\n * a tiny\n * test.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Cat} class provides a client for concatenating the results\n * of several text files.\n *
\n * For additional documentation, see Section 1.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Cat {\n\n // this class should not be instantiated\n private Cat() { }\n\n /**\n * Reads in a sequence of text files specified as the first command-line\n * arguments, concatenates them, and writes the results to the file\n * specified as the last command-line argument.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Out out = new Out(args[args.length - 1]);\n for (int i = 0; i < args.length - 1; i++) {\n In in = new In(args[i]);\n String s = in.readAll();\n out.println(s);\n in.close();\n }\n out.close();\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/ClosestPair.java",
"content": "/******************************************************************************\n * Compilation: javac ClosestPair.java\n * Execution: java ClosestPair < input.txt\n * Dependencies: Point2D.java\n * Data files: https://algs4.cs.princeton.edu/99hull/rs1423.txt\n * https://algs4.cs.princeton.edu/99hull/kw1260.txt\n *\n * Given n points in the plane, find the closest pair in n log n time.\n *\n * Note: could speed it up by comparing square of Euclidean distances\n * instead of Euclidean distances.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.Arrays;\n\n/**\n * The {@code ClosestPair} data type computes a closest pair of points\n * in a set of n points in the plane and provides accessor methods\n * for getting the closest pair of points and the distance between them.\n * The distance between two points is their Euclidean distance.\n *
\n * This implementation uses a divide-and-conquer algorithm.\n * It runs in O(n log n) time in the worst case and uses\n * O(n) extra space.\n *
\n * See also {@link FarthestPair}.\n *
\n * For additional documentation, see Section 9.9 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class ClosestPair {\n\n // closest pair of points and their Euclidean distance\n private Point2D best1, best2;\n private double bestDistance = Double.POSITIVE_INFINITY;\n\n /**\n * Computes the closest pair of points in the specified array of points.\n *\n * @param points the array of points\n * @throws IllegalArgumentException if {@code points} is {@code null} or if any\n * entry in {@code points[]} is {@code null}\n */\n public ClosestPair(Point2D[] points) {\n if (points == null) throw new IllegalArgumentException(\"constructor argument is null\");\n for (int i = 0; i < points.length; i++) {\n if (points[i] == null) throw new IllegalArgumentException(\"array element \" + i + \" is null\");\n }\n\n int n = points.length;\n if (n <= 1) return;\n\n // sort by x-coordinate (breaking ties by y-coordinate via stability)\n Point2D[] pointsByX = new Point2D[n];\n for (int i = 0; i < n; i++)\n pointsByX[i] = points[i];\n Arrays.sort(pointsByX, Point2D.Y_ORDER);\n Arrays.sort(pointsByX, Point2D.X_ORDER);\n\n // check for coincident points\n for (int i = 0; i < n-1; i++) {\n if (pointsByX[i].equals(pointsByX[i+1])) {\n bestDistance = 0.0;\n best1 = pointsByX[i];\n best2 = pointsByX[i+1];\n return;\n }\n }\n\n // sort by y-coordinate (but not yet sorted)\n Point2D[] pointsByY = new Point2D[n];\n for (int i = 0; i < n; i++)\n pointsByY[i] = pointsByX[i];\n\n // auxiliary array\n Point2D[] aux = new Point2D[n];\n\n closest(pointsByX, pointsByY, aux, 0, n-1);\n }\n\n // find closest pair of points in pointsByX[lo..hi]\n // precondition: pointsByX[lo..hi] and pointsByY[lo..hi] are the same sequence of points\n // precondition: pointsByX[lo..hi] sorted by x-coordinate\n // postcondition: pointsByY[lo..hi] sorted by y-coordinate\n private double closest(Point2D[] pointsByX, Point2D[] pointsByY, Point2D[] aux, int lo, int hi) {\n if (hi <= lo) return Double.POSITIVE_INFINITY;\n\n int mid = lo + (hi - lo) / 2;\n Point2D median = pointsByX[mid];\n\n // compute closest pair with both endpoints in left subarray or both in right subarray\n double delta1 = closest(pointsByX, pointsByY, aux, lo, mid);\n double delta2 = closest(pointsByX, pointsByY, aux, mid+1, hi);\n double delta = Math.min(delta1, delta2);\n\n // merge back so that pointsByY[lo..hi] are sorted by y-coordinate\n merge(pointsByY, aux, lo, mid, hi);\n\n // aux[0..m-1] = sequence of points closer than delta, sorted by y-coordinate\n int m = 0;\n for (int i = lo; i <= hi; i++) {\n if (Math.abs(pointsByY[i].x() - median.x()) < delta)\n aux[m++] = pointsByY[i];\n }\n\n // compare each point to its neighbors with y-coordinate closer than delta\n for (int i = 0; i < m; i++) {\n // a geometric packing argument shows that this loop iterates at most 7 times\n for (int j = i+1; (j < m) && (aux[j].y() - aux[i].y() < delta); j++) {\n double distance = aux[i].distanceTo(aux[j]);\n if (distance < delta) {\n delta = distance;\n if (distance < bestDistance) {\n bestDistance = delta;\n best1 = aux[i];\n best2 = aux[j];\n // StdOut.println(\"better distance = \" + delta + \" from \" + best1 + \" to \" + best2);\n }\n }\n }\n }\n return delta;\n }\n\n /**\n * Returns one of the points in the closest pair of points.\n *\n * @return one of the two points in the closest pair of points;\n * {@code null} if no such point (because there are fewer than 2 points)\n */\n public Point2D either() {\n return best1;\n }\n\n /**\n * Returns the other point in the closest pair of points.\n *\n * @return the other point in the closest pair of points\n * {@code null} if no such point (because there are fewer than 2 points)\n */\n public Point2D other() {\n return best2;\n }\n\n /**\n * Returns the Euclidean distance between the closest pair of points.\n *\n * @return the Euclidean distance between the closest pair of points\n * {@code Double.POSITIVE_INFINITY} if no such pair of points\n * exist (because there are fewer than 2 points)\n */\n public double distance() {\n return bestDistance;\n }\n\n // is v < w ?\n private static boolean less(Comparable v, Comparable w) {\n return v.compareTo(w) < 0;\n }\n\n // stably merge a[lo .. mid] with a[mid+1 ..hi] using aux[lo .. hi]\n // precondition: a[lo .. mid] and a[mid+1 .. hi] are sorted subarrays\n private static void merge(Comparable[] a, Comparable[] aux, int lo, int mid, int hi) {\n // copy to aux[]\n for (int k = lo; k <= hi; k++) {\n aux[k] = a[k];\n }\n\n // merge back to a[]\n int i = lo, j = mid+1;\n for (int k = lo; k <= hi; k++) {\n if (i > mid) a[k] = aux[j++];\n else if (j > hi) a[k] = aux[i++];\n else if (less(aux[j], aux[i])) a[k] = aux[j++];\n else a[k] = aux[i++];\n }\n }\n\n\n\n /**\n * Unit tests the {@code ClosestPair} data type.\n * Reads in an integer {@code n} and {@code n} points (specified by\n * their x- and y-coordinates) from standard input;\n * computes a closest pair of points; and prints the pair to standard\n * output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int n = StdIn.readInt();\n Point2D[] points = new Point2D[n];\n for (int i = 0; i < n; i++) {\n double x = StdIn.readDouble();\n double y = StdIn.readDouble();\n points[i] = new Point2D(x, y);\n }\n ClosestPair closest = new ClosestPair(points);\n StdOut.println(closest.distance() + \" from \" + closest.either() + \" to \" + closest.other());\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/CollisionSystem.java",
"content": "/******************************************************************************\n * Compilation: javac CollisionSystem.java\n * Execution: java CollisionSystem n (n random particles)\n * java CollisionSystem < input.txt (from a file)\n * Dependencies: StdDraw.java Particle.java MinPQ.java\n * Data files: https://algs4.cs.princeton.edu/61event/diffusion.txt\n * https://algs4.cs.princeton.edu/61event/diffusion2.txt\n * https://algs4.cs.princeton.edu/61event/diffusion3.txt\n * https://algs4.cs.princeton.edu/61event/brownian.txt\n * https://algs4.cs.princeton.edu/61event/brownian2.txt\n * https://algs4.cs.princeton.edu/61event/billiards5.txt\n * https://algs4.cs.princeton.edu/61event/pendulum.txt\n *\n * Creates n random particles and simulates their motion according\n * to the laws of elastic collisions.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.awt.Color;\n\n/**\n * The {@code CollisionSystem} class represents a collection of particles\n * moving in the unit box, according to the laws of elastic collision.\n * This event-based simulation relies on a priority queue.\n *
\n * For additional documentation,\n * see Section 6.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class CollisionSystem {\n private static final double HZ = 0.5; // number of redraw events per clock tick\n\n private MinPQ pq; // the priority queue\n private double t = 0.0; // simulation clock time\n private Particle[] particles; // the array of particles\n\n /**\n * Initializes a system with the specified collection of particles.\n * The individual particles will be mutated during the simulation.\n *\n * @param particles the array of particles\n */\n public CollisionSystem(Particle[] particles) {\n this.particles = particles.clone(); // defensive copy\n }\n\n // updates priority queue with all new events for particle a\n private void predict(Particle a, double limit) {\n if (a == null) return;\n\n // particle-particle collisions\n for (int i = 0; i < particles.length; i++) {\n double dt = a.timeToHit(particles[i]);\n if (t + dt <= limit)\n pq.insert(new Event(t + dt, a, particles[i]));\n }\n\n // particle-wall collisions\n double dtX = a.timeToHitVerticalWall();\n double dtY = a.timeToHitHorizontalWall();\n if (t + dtX <= limit) pq.insert(new Event(t + dtX, a, null));\n if (t + dtY <= limit) pq.insert(new Event(t + dtY, null, a));\n }\n\n // redraw all particles\n private void redraw(double limit) {\n StdDraw.clear();\n for (int i = 0; i < particles.length; i++) {\n particles[i].draw();\n }\n StdDraw.show();\n StdDraw.pause(20);\n if (t < limit) {\n pq.insert(new Event(t + 1.0 / HZ, null, null));\n }\n }\n\n\n /**\n * Simulates the system of particles for the specified amount of time.\n *\n * @param limit the amount of time\n */\n public void simulate(double limit) {\n\n // initialize PQ with collision events and redraw event\n pq = new MinPQ();\n for (int i = 0; i < particles.length; i++) {\n predict(particles[i], limit);\n }\n pq.insert(new Event(0, null, null)); // redraw event\n\n\n // the main event-driven simulation loop\n while (!pq.isEmpty()) {\n\n // get impending event, discard if invalidated\n Event e = pq.delMin();\n if (!e.isValid()) continue;\n Particle a = e.a;\n Particle b = e.b;\n\n // physical collision, so update positions, and then simulation clock\n for (int i = 0; i < particles.length; i++)\n particles[i].move(e.time - t);\n t = e.time;\n\n // process event\n if (a != null && b != null) a.bounceOff(b); // particle-particle collision\n else if (a != null && b == null) a.bounceOffVerticalWall(); // particle-wall collision\n else if (a == null && b != null) b.bounceOffHorizontalWall(); // particle-wall collision\n else if (a == null && b == null) redraw(limit); // redraw event\n\n // update the priority queue with new collisions involving a or b\n predict(a, limit);\n predict(b, limit);\n }\n }\n\n\n /***************************************************************************\n * An event during a particle collision simulation. Each event contains\n * the time at which it will occur (assuming no supervening actions)\n * and the particles a and b involved.\n *\n * - a and b both null: redraw event\n * - a null, b not null: collision with vertical wall\n * - a not null, b null: collision with horizontal wall\n * - a and b both not null: binary collision between a and b\n *\n ***************************************************************************/\n private static class Event implements Comparable {\n private final double time; // time that event is scheduled to occur\n private final Particle a, b; // particles involved in event, possibly null\n private final int countA, countB; // collision counts at event creation\n\n\n // create a new event to occur at time t involving a and b\n public Event(double t, Particle a, Particle b) {\n this.time = t;\n this.a = a;\n this.b = b;\n if (a != null) countA = a.count();\n else countA = -1;\n if (b != null) countB = b.count();\n else countB = -1;\n }\n\n // compare times when two events will occur\n public int compareTo(Event that) {\n return Double.compare(this.time, that.time);\n }\n\n // has any collision occurred between when event was created and now?\n public boolean isValid() {\n if (a != null && a.count() != countA) return false;\n if (b != null && b.count() != countB) return false;\n return true;\n }\n\n }\n\n\n /**\n * Unit tests the {@code CollisionSystem} data type.\n * Reads in the particle collision system from a standard input\n * (or generates {@code N} random particles if a command-line integer\n * is specified); simulates the system.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n\n StdDraw.setCanvasSize(600, 600);\n\n // enable double buffering\n StdDraw.enableDoubleBuffering();\n\n // the array of particles\n Particle[] particles;\n\n // create n random particles\n if (args.length == 1) {\n int n = Integer.parseInt(args[0]);\n particles = new Particle[n];\n for (int i = 0; i < n; i++)\n particles[i] = new Particle();\n }\n\n // or read from standard input\n else {\n int n = StdIn.readInt();\n particles = new Particle[n];\n for (int i = 0; i < n; i++) {\n double rx = StdIn.readDouble();\n double ry = StdIn.readDouble();\n double vx = StdIn.readDouble();\n double vy = StdIn.readDouble();\n double radius = StdIn.readDouble();\n double mass = StdIn.readDouble();\n int r = StdIn.readInt();\n int g = StdIn.readInt();\n int b = StdIn.readInt();\n Color color = new Color(r, g, b);\n particles[i] = new Particle(rx, ry, vx, vy, radius, mass, color);\n }\n }\n\n // create collision system and simulate\n CollisionSystem system = new CollisionSystem(particles);\n system.simulate(10000);\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Complex.java",
"content": "/******************************************************************************\n * Compilation: javac Complex.java\n * Execution: java Complex\n * Dependencies: StdOut.java\n *\n * Data type for complex numbers.\n *\n * The data type is \"immutable\" so once you create and initialize\n * a Complex object, you cannot change it. The \"final\" keyword\n * when declaring re and im enforces this rule, making it a\n * compile-time error to change the .re or .im fields after\n * they've been initialized.\n *\n * % java Complex\n * a = 5.0 + 6.0i\n * b = -3.0 + 4.0i\n * Re(a) = 5.0\n * Im(a) = 6.0\n * b + a = 2.0 + 10.0i\n * a - b = 8.0 + 2.0i\n * a * b = -39.0 + 2.0i\n * b * a = -39.0 + 2.0i\n * a / b = 0.36 - 1.52i\n * (a / b) * b = 5.0 + 6.0i\n * conj(a) = 5.0 - 6.0i\n * |a| = 7.810249675906654\n * tan(a) = -6.685231390246571E-6 + 1.0000103108981198i\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Complex} class represents a complex number.\n * Complex numbers are immutable: their values cannot be changed after they\n * are created.\n * It includes methods for addition, subtraction, multiplication, division,\n * conjugation, and other common functions on complex numbers.\n *
\n * This computes correct results if all arithmetic performed is\n * without floating-point rounding error or arithmetic overflow.\n * In practice, there will be floating-point rounding error.\n *
\n * For additional documentation, see Section 9.9 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Complex {\n private final double re; // the real part\n private final double im; // the imaginary part\n\n /**\n * Initializes a complex number from the specified real and imaginary parts.\n *\n * @param real the real part\n * @param imag the imaginary part\n */\n public Complex(double real, double imag) {\n re = real;\n im = imag;\n }\n\n /**\n * Returns a string representation of this complex number.\n *\n * @return a string representation of this complex number,\n * of the form 34 - 56i.\n */\n public String toString() {\n if (im == 0) return re + \"\";\n if (re == 0) return im + \"i\";\n if (im < 0) return re + \" - \" + (-im) + \"i\";\n return re + \" + \" + im + \"i\";\n }\n\n /**\n * Returns the absolute value of this complex number.\n * This quantity is also known as the modulus or magnitude.\n *\n * @return the absolute value of this complex number\n */\n public double abs() {\n return Math.hypot(re, im);\n }\n\n /**\n * Returns the phase of this complex number.\n * This quantity is also known as the angle or argument.\n *\n * @return the phase of this complex number, a real number between -pi and pi\n */\n public double phase() {\n return Math.atan2(im, re);\n }\n\n /**\n * Returns the sum of this complex number and the specified complex number.\n *\n * @param that the other complex number\n * @return the complex number whose value is {@code (this + that)}\n */\n public Complex plus(Complex that) {\n double real = this.re + that.re;\n double imag = this.im + that.im;\n return new Complex(real, imag);\n }\n\n /**\n * Returns the result of subtracting the specified complex number from\n * this complex number.\n *\n * @param that the other complex number\n * @return the complex number whose value is {@code (this - that)}\n */\n public Complex minus(Complex that) {\n double real = this.re - that.re;\n double imag = this.im - that.im;\n return new Complex(real, imag);\n }\n\n /**\n * Returns the product of this complex number and the specified complex number.\n *\n * @param that the other complex number\n * @return the complex number whose value is {@code (this * that)}\n */\n public Complex times(Complex that) {\n double real = this.re * that.re - this.im * that.im;\n double imag = this.re * that.im + this.im * that.re;\n return new Complex(real, imag);\n }\n\n /**\n * Returns the product of this complex number and the specified scalar.\n *\n * @param alpha the scalar\n * @return the complex number whose value is {@code (alpha * this)}\n */\n public Complex scale(double alpha) {\n return new Complex(alpha * re, alpha * im);\n }\n\n /**\n * Returns the product of this complex number and the specified scalar.\n *\n * @param alpha the scalar\n * @return the complex number whose value is {@code (alpha * this)}\n * @deprecated Replaced by {@link #scale(double)}.\n */\n @Deprecated\n public Complex times(double alpha) {\n return new Complex(alpha * re, alpha * im);\n }\n\n /**\n * Returns the complex conjugate of this complex number.\n *\n * @return the complex conjugate of this complex number\n */\n public Complex conjugate() {\n return new Complex(re, -im);\n }\n\n /**\n * Returns the reciprocal of this complex number.\n *\n * @return the complex number whose value is {@code (1 / this)}\n */\n public Complex reciprocal() {\n double scale = re*re + im*im;\n return new Complex(re / scale, -im / scale);\n }\n\n /**\n * Returns the real part of this complex number.\n *\n * @return the real part of this complex number\n */\n public double re() {\n return re;\n }\n\n /**\n * Returns the imaginary part of this complex number.\n *\n * @return the imaginary part of this complex number\n */\n public double im() {\n return im;\n }\n\n /**\n * Returns the result of dividing the specified complex number into\n * this complex number.\n *\n * @param that the other complex number\n * @return the complex number whose value is {@code (this / that)}\n */\n public Complex divides(Complex that) {\n return this.times(that.reciprocal());\n }\n\n /**\n * Returns the complex exponential of this complex number.\n *\n * @return the complex exponential of this complex number\n */\n public Complex exp() {\n return new Complex(Math.exp(re) * Math.cos(im), Math.exp(re) * Math.sin(im));\n }\n\n /**\n * Returns the complex sine of this complex number.\n *\n * @return the complex sine of this complex number\n */\n public Complex sin() {\n return new Complex(Math.sin(re) * Math.cosh(im), Math.cos(re) * Math.sinh(im));\n }\n\n /**\n * Returns the complex cosine of this complex number.\n *\n * @return the complex cosine of this complex number\n */\n public Complex cos() {\n return new Complex(Math.cos(re) * Math.cosh(im), -Math.sin(re) * Math.sinh(im));\n }\n\n /**\n * Returns the complex tangent of this complex number.\n *\n * @return the complex tangent of this complex number\n */\n public Complex tan() {\n return sin().divides(cos());\n }\n\n\n /**\n * Unit tests the {@code Complex} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Complex a = new Complex(5.0, 6.0);\n Complex b = new Complex(-3.0, 4.0);\n\n StdOut.println(\"a = \" + a);\n StdOut.println(\"b = \" + b);\n StdOut.println(\"Re(a) = \" + a.re());\n StdOut.println(\"Im(a) = \" + a.im());\n StdOut.println(\"b + a = \" + b.plus(a));\n StdOut.println(\"a - b = \" + a.minus(b));\n StdOut.println(\"a * b = \" + a.times(b));\n StdOut.println(\"b * a = \" + b.times(a));\n StdOut.println(\"a / b = \" + a.divides(b));\n StdOut.println(\"(a / b) * b = \" + a.divides(b).times(b));\n StdOut.println(\"conj(a) = \" + a.conjugate());\n StdOut.println(\"|a| = \" + a.abs());\n StdOut.println(\"tan(a) = \" + a.tan());\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Count.java",
"content": "/******************************************************************************\n * Compilation: javac Count.java\n * Execution: java Count alpha < input.txt\n * Dependencies: Alphabet.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/50strings/abra.txt\n * https://algs4.cs.princeton.edu/50strings/pi.txt\n *\n * Create an alphabet specified on the command line, read in a\n * sequence of characters over that alphabet (ignoring characters\n * not in the alphabet), computes the frequency of occurrence of\n * each character, and print out the results.\n *\n * % java Count ABCDR < abra.txt\n * A 5\n * B 2\n * C 1\n * D 1\n * R 2\n *\n * % java Count 0123456789 < pi.txt\n * 0 99959\n * 1 99757\n * 2 100026\n * 3 100230\n * 4 100230\n * 5 100359\n * 6 99548\n * 7 99800\n * 8 99985\n * 9 100106\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n\n/**\n * The {@code Count} class provides an {@link Alphabet} client for reading\n * in a piece of text and computing the frequency of occurrence of each\n * character over a given alphabet.\n *
\n * For additional documentation,\n * see Section 5.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Count {\n\n // Do not instantiate.\n private Count() { }\n\n /**\n * Reads in text from standard input; calculates the frequency of\n * occurrence of each character over the alphabet specified as a\n * command-line argument; and prints the frequencies to standard\n * output.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Alphabet alphabet = new Alphabet(args[0]);\n final int R = alphabet.radix();\n int[] count = new int[R];\n while (StdIn.hasNextChar()) {\n char c = StdIn.readChar();\n if (alphabet.contains(c))\n count[alphabet.toIndex(c)]++;\n }\n for (int c = 0; c < R; c++)\n StdOut.println(alphabet.toChar(c) + \" \" + count[c]);\n }\n}\n\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Counter.java",
"content": "/******************************************************************************\n * Compilation: javac Counter.java\n * Execution: java Counter n trials\n * Dependencies: StdRandom.java StdOut.java\n *\n * A mutable data type for an integer counter.\n *\n * The test clients create n counters and performs trials increment\n * operations on random counters.\n *\n * java Counter 6 600000\n * 100140 counter0\n * 100273 counter1\n * 99848 counter2\n * 100129 counter3\n * 99973 counter4\n * 99637 counter5\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Counter} class is a mutable data type to encapsulate a counter.\n *
\n * For additional documentation,\n * see Section 1.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Counter implements Comparable {\n\n private final String name; // counter name\n private int count = 0; // current value\n\n /**\n * Initializes a new counter starting at 0, with the given id.\n *\n * @param id the name of the counter\n */\n public Counter(String id) {\n name = id;\n }\n\n /**\n * Increments the counter by 1.\n */\n public void increment() {\n count++;\n }\n\n /**\n * Returns the current value of this counter.\n *\n * @return the current value of this counter\n */\n public int tally() {\n return count;\n }\n\n /**\n * Returns a string representation of this counter.\n *\n * @return a string representation of this counter\n */\n public String toString() {\n return count + \" \" + name;\n }\n\n /**\n * Compares this counter to the specified counter.\n *\n * @param that the other counter\n * @return {@code 0} if the value of this counter equals\n * the value of that counter; a negative integer if\n * the value of this counter is less than the value of\n * that counter; and a positive integer if the value\n * of this counter is greater than the value of that\n * counter\n */\n @Override\n public int compareTo(Counter that) {\n return Integer.compare(this.count, that.count);\n }\n\n\n /**\n * Reads two command-line integers n and trials; creates n counters;\n * increments trials counters at random; and prints results.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n int n = Integer.parseInt(args[0]);\n int trials = Integer.parseInt(args[1]);\n\n // create n counters\n Counter[] hits = new Counter[n];\n for (int i = 0; i < n; i++) {\n hits[i] = new Counter(\"counter\" + i);\n }\n\n // increment trials counters at random\n for (int t = 0; t < trials; t++) {\n hits[StdRandom.uniformInt(n)].increment();\n }\n\n // print results\n for (int i = 0; i < n; i++) {\n StdOut.println(hits[i]);\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Cycle.java",
"content": "/******************************************************************************\n * Compilation: javac Cycle.java\n * Execution: java Cycle filename.txt\n * Dependencies: Graph.java Stack.java In.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n * https://algs4.cs.princeton.edu/41graph/largeG.txt\n *\n * Identifies a cycle.\n * Runs in O(E + V) time.\n *\n * % java Cycle tinyG.txt\n * 3 4 5 3\n *\n * % java Cycle mediumG.txt\n * 15 0 225 15\n *\n * % java Cycle largeG.txt\n * 996673 762 840164 4619 785187 194717 996673\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Cycle} class represents a data type for\n * determining whether an undirected graph has a simple cycle.\n * The hasCycle operation determines whether the graph has\n * a cycle and, if so, the cycle operation returns one.\n *
\n * This implementation uses depth-first search.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and\n * E is the number of edges.\n * (The depth-first search part takes only O(V) time;\n * however, checking for self-loops and parallel edges takes\n * Θ(V + E) time in the worst case.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n *\n *
\n * For additional documentation, see\n * Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Cycle {\n private boolean[] marked;\n private int[] edgeTo;\n private Stack cycle;\n\n /**\n * Determines whether the undirected graph {@code graph} has a cycle and,\n * if so, finds such a cycle.\n *\n * @param graph the undirected graph\n */\n public Cycle(Graph graph) {\n // need special case to identify parallel edge as a cycle\n if (hasParallelEdges(graph)) return;\n\n // don't need special case to identify self-loop as a cycle\n // if (hasSelfLoop(graph)) return;\n\n marked = new boolean[graph.V()];\n edgeTo = new int[graph.V()];\n for (int v = 0; v < graph.V(); v++)\n if (!marked[v])\n dfs(graph, -1, v);\n }\n\n\n // does this graph have a self loop?\n // side effect: initialize cycle to be self loop\n private boolean hasSelfLoop(Graph graph) {\n for (int v = 0; v < graph.V(); v++) {\n for (int w : graph.adj(v)) {\n if (v == w) {\n cycle = new Stack();\n cycle.push(v);\n cycle.push(v);\n return true;\n }\n }\n }\n return false;\n }\n\n // does this graph have two parallel edges?\n // side effect: initialize cycle to be two parallel edges\n private boolean hasParallelEdges(Graph graph) {\n marked = new boolean[graph.V()];\n\n for (int v = 0; v < graph.V(); v++) {\n\n // check for parallel edges incident to v\n for (int w : graph.adj(v)) {\n if (marked[w]) {\n cycle = new Stack();\n cycle.push(v);\n cycle.push(w);\n cycle.push(v);\n return true;\n }\n marked[w] = true;\n }\n\n // reset so marked[v] = false for all v\n for (int w : graph.adj(v)) {\n marked[w] = false;\n }\n }\n return false;\n }\n\n /**\n * Returns true if {@code graph} has a cycle.\n *\n * @return {@code true} if the graph has a cycle; {@code false} otherwise\n */\n public boolean hasCycle() {\n return cycle != null;\n }\n\n /**\n * Returns a cycle in the graph {@code G}.\n * @return a cycle if the graph {@code G} has a cycle,\n * and {@code null} otherwise\n */\n public Iterable cycle() {\n return cycle;\n }\n\n private void dfs(Graph graph, int u, int v) {\n marked[v] = true;\n for (int w : graph.adj(v)) {\n\n // short circuit if cycle already found\n if (cycle != null) return;\n\n if (!marked[w]) {\n edgeTo[w] = v;\n dfs(graph, v, w);\n }\n\n // check for cycle (but disregard reverse of edge leading to v)\n else if (w != u) {\n cycle = new Stack();\n for (int x = v; x != w; x = edgeTo[x]) {\n cycle.push(x);\n }\n cycle.push(w);\n cycle.push(v);\n }\n }\n }\n\n /**\n * Unit tests the {@code Cycle} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Graph graph = new Graph(in);\n Cycle finder = new Cycle(graph);\n if (finder.hasCycle()) {\n for (int v : finder.cycle()) {\n StdOut.print(v + \" \");\n }\n StdOut.println();\n }\n else {\n StdOut.println(\"Graph is acyclic\");\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Date.java",
"content": "/******************************************************************************\n * Compilation: javac Date.java\n * Execution: java Date\n * Dependencies: StdOut.java\n *\n * An immutable data type for dates.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code Date} class is an immutable data type to encapsulate a\n * date (day, month, and year).\n *
\n * For additional documentation,\n * see Section 1.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class Date implements Comparable {\n private static final int[] DAYS = { 0, 31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31 };\n\n private final int month; // month (between 1 and 12)\n private final int day; // day (between 1 and DAYS[month]\n private final int year; // year\n\n /**\n * Initializes a new date from the month, day, and year.\n * @param month the month (between 1 and 12)\n * @param day the day (between 1 and 28-31, depending on the month)\n * @param year the year\n * @throws IllegalArgumentException if this date is invalid\n */\n public Date(int month, int day, int year) {\n if (!isValid(month, day, year)) throw new IllegalArgumentException(\"Invalid date\");\n this.month = month;\n this.day = day;\n this.year = year;\n }\n\n /**\n * Initializes new date specified as a string in form MM/DD/YYYY.\n * @param date the string representation of this date\n * @throws IllegalArgumentException if this date is invalid\n */\n public Date(String date) {\n String[] fields = date.split(\"/\");\n if (fields.length != 3) {\n throw new IllegalArgumentException(\"Invalid date\");\n }\n month = Integer.parseInt(fields[0]);\n day = Integer.parseInt(fields[1]);\n year = Integer.parseInt(fields[2]);\n if (!isValid(month, day, year)) throw new IllegalArgumentException(\"Invalid date\");\n }\n\n /**\n * Return the month.\n * @return the month (an integer between 1 and 12)\n */\n public int month() {\n return month;\n }\n\n /**\n * Returns the day.\n * @return the day (an integer between 1 and 31)\n */\n public int day() {\n return day;\n }\n\n /**\n * Returns the year.\n * @return the year\n */\n public int year() {\n return year;\n }\n\n\n // is the given date valid?\n private static boolean isValid(int m, int d, int y) {\n if (m < 1 || m > 12) return false;\n if (d < 1 || d > DAYS[m]) return false;\n if (m == 2 && d == 29 && !isLeapYear(y)) return false;\n return true;\n }\n\n // is y a leap year?\n private static boolean isLeapYear(int y) {\n if (y % 400 == 0) return true;\n if (y % 100 == 0) return false;\n return y % 4 == 0;\n }\n\n /**\n * Returns the next date in the calendar.\n *\n * @return a date that represents the next day after this day\n */\n public Date next() {\n if (isValid(month, day + 1, year)) return new Date(month, day + 1, year);\n else if (isValid(month + 1, 1, year)) return new Date(month + 1, 1, year);\n else return new Date(1, 1, year + 1);\n }\n\n /**\n * Compares two dates chronologically.\n *\n * @param that the other date\n * @return {@code true} if this date is after that date; {@code false} otherwise\n */\n public boolean isAfter(Date that) {\n return compareTo(that) > 0;\n }\n\n /**\n * Compares two dates chronologically.\n *\n * @param that the other date\n * @return {@code true} if this date is before that date; {@code false} otherwise\n */\n public boolean isBefore(Date that) {\n return compareTo(that) < 0;\n }\n\n /**\n * Compares two dates chronologically.\n *\n * @return the value {@code 0} if the argument date is equal to this date;\n * a negative integer if this date is chronologically less than\n * the argument date; and a positive integer if this date is\n * chronologically after the argument date\n */\n @Override\n public int compareTo(Date that) {\n if (this.year < that.year) return -1;\n if (this.year > that.year) return +1;\n if (this.month < that.month) return -1;\n if (this.month > that.month) return +1;\n if (this.day < that.day) return -1;\n if (this.day > that.day) return +1;\n return 0;\n }\n\n /**\n * Returns a string representation of this date.\n *\n * @return the string representation in the format MM/DD/YYYY\n */\n @Override\n public String toString() {\n return month + \"/\" + day + \"/\" + year;\n }\n\n /**\n * Compares this date to the specified date.\n *\n * @param other the other date\n * @return {@code true} if this date equals {@code other}; {@code false} otherwise\n */\n @Override\n public boolean equals(Object other) {\n if (other == this) return true;\n if (other == null) return false;\n if (other.getClass() != this.getClass()) return false;\n Date that = (Date) other;\n return (this.month == that.month) && (this.day == that.day) && (this.year == that.year);\n }\n\n /**\n * Returns an integer hash code for this date.\n *\n * @return an integer hash code for this date\n */\n @Override\n public int hashCode() {\n return day + 31*month + 31*12*year;\n }\n\n /**\n * Unit tests the {@code Date} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n Date today = new Date(2, 25, 2004);\n StdOut.println(today);\n for (int i = 0; i < 10; i++) {\n today = today.next();\n StdOut.println(today);\n }\n\n StdOut.println(today.isAfter(today.next()));\n StdOut.println(today.isAfter(today));\n StdOut.println(today.next().isAfter(today));\n\n\n Date birthday = new Date(10, 16, 1971);\n StdOut.println(birthday);\n for (int i = 0; i < 10; i++) {\n birthday = birthday.next();\n StdOut.println(birthday);\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DeDup.java",
"content": "/******************************************************************************\n * Compilation: javac DeDup.java\n * Execution: java DeDup < input.txt\n * Dependencies: SET StdIn.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/35applications/tinyTale.txt\n *\n * Read in a list of words from standard input and print out\n * each word, removing any duplicates.\n *\n * % more tinyTale.txt\n * it was the best of times it was the worst of times\n * it was the age of wisdom it was the age of foolishness\n * it was the epoch of belief it was the epoch of incredulity\n * it was the season of light it was the season of darkness\n * it was the spring of hope it was the winter of despair\n *\n * % java DeDup < tinyTale.txt\n * it\n * was\n * the\n * best\n * of\n * times\n * worst\n * age\n * wisdom\n * ...\n * winter\n * despair\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DeDup} class provides a client for reading in a sequence of\n * words from standard input and printing each word, removing any duplicates.\n * It is useful as a test client for various symbol table implementations.\n *
\n * For additional documentation, see Section 3.5 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DeDup {\n\n // Do not instantiate.\n private DeDup() { }\n\n public static void main(String[] args) {\n SET set = new SET();\n\n // read in strings and add to set\n while (!StdIn.isEmpty()) {\n String key = StdIn.readString();\n if (!set.contains(key)) {\n set.add(key);\n StdOut.println(key);\n }\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DegreesOfSeparation.java",
"content": "/******************************************************************************\n * Compilation: javac DegreesOfSeparation.java\n * Execution: java DegreesOfSeparation filename delimiter source\n * Dependencies: SymbolGraph.java Graph.java BreadthFirstPaths.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/41graph/routes.txt\n * https://algs4.cs.princeton.edu/41graph/movies.txt\n *\n *\n * % java DegreesOfSeparation routes.txt \" \" \"JFK\"\n * LAS\n * JFK\n * ORD\n * DEN\n * LAS\n * DFW\n * JFK\n * ORD\n * DFW\n * EWR\n * Not in database.\n *\n * % java DegreesOfSeparation movies.txt \"/\" \"Bacon, Kevin\"\n * Kidman, Nicole\n * Bacon, Kevin\n * Woodsman, The (2004)\n * Grier, David Alan\n * Bewitched (2005)\n * Kidman, Nicole\n * Grant, Cary\n * Bacon, Kevin\n * Planes, Trains & Automobiles (1987)\n * Martin, Steve (I)\n * Dead Men Don't Wear Plaid (1982)\n * Grant, Cary\n *\n * % java DegreesOfSeparation movies.txt \"/\" \"Animal House (1978)\"\n * Titanic (1997)\n * Animal House (1978)\n * Allen, Karen (I)\n * Raiders of the Lost Ark (1981)\n * Taylor, Rocky (I)\n * Titanic (1997)\n * To Catch a Thief (1955)\n * Animal House (1978)\n * Vernon, John (I)\n * Topaz (1969)\n * Hitchcock, Alfred (I)\n * To Catch a Thief (1955)\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DegreesOfSeparation} class provides a client for finding\n * the degree of separation between one distinguished individual and\n * every other individual in a social network.\n * As an example, if the social network consists of actors in which\n * two actors are connected by a link if they appeared in the same movie,\n * and Kevin Bacon is the distinguished individual, then the client\n * computes the Kevin Bacon number of every actor in the network.\n *
\n * The running time is proportional to the number of individuals and\n * connections in the network. If the connections are given implicitly,\n * as in the movie network example (where every two actors are connected\n * if they appear in the same movie), the efficiency of the algorithm\n * is improved by allowing both movie and actor vertices and connecting\n * each movie to all of the actors that appear in that movie.\n *
\n * For additional documentation,\n * see Section 4.1 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DegreesOfSeparation {\n\n // this class cannot be instantiated\n private DegreesOfSeparation() { }\n\n /**\n * Reads in a social network from a file, and then repeatedly reads in\n * individuals from standard input and prints out their degrees of\n * separation.\n * Takes three command-line arguments: the name of a file,\n * a delimiter, and the name of the distinguished individual.\n * Each line in the file contains the name of a vertex, followed by a\n * list of the names of the vertices adjacent to that vertex,\n * separated by the delimiter.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n String filename = args[0];\n String delimiter = args[1];\n String source = args[2];\n\n // StdOut.println(\"Source: \" + source);\n\n SymbolGraph sg = new SymbolGraph(filename, delimiter);\n Graph graph = sg.graph();\n if (!sg.contains(source)) {\n StdOut.println(source + \" not in database.\");\n return;\n }\n\n int s = sg.indexOf(source);\n BreadthFirstPaths bfs = new BreadthFirstPaths(graph, s);\n\n while (!StdIn.isEmpty()) {\n String sink = StdIn.readLine();\n if (sg.contains(sink)) {\n int t = sg.indexOf(sink);\n if (bfs.hasPathTo(t)) {\n for (int v : bfs.pathTo(t)) {\n StdOut.println(\" \" + sg.nameOf(v));\n }\n }\n else {\n StdOut.println(\"Not connected\");\n }\n }\n else {\n StdOut.println(\" Not in database.\");\n }\n }\n }\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DepthFirstDirectedPaths.java",
"content": "/******************************************************************************\n * Compilation: javac DepthFirstDirectedPaths.java\n * Execution: java DepthFirstDirectedPaths digraph.txt s\n * Dependencies: Digraph.java Stack.java\n * Data files: https://algs4.cs.princeton.edu/42digraph/tinyDG.txt\n * https://algs4.cs.princeton.edu/42digraph/mediumDG.txt\n * https://algs4.cs.princeton.edu/42digraph/largeDG.txt\n *\n * Determine reachability in a digraph from a given vertex using\n * depth-first search.\n * Runs in O(E + V) time.\n *\n * % java DepthFirstDirectedPaths tinyDG.txt 3\n * 3 to 0: 3-5-4-2-0\n * 3 to 1: 3-5-4-2-0-1\n * 3 to 2: 3-5-4-2\n * 3 to 3: 3\n * 3 to 4: 3-5-4\n * 3 to 5: 3-5\n * 3 to 6: not connected\n * 3 to 7: not connected\n * 3 to 8: not connected\n * 3 to 9: not connected\n * 3 to 10: not connected\n * 3 to 11: not connected\n * 3 to 12: not connected\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DepthFirstDirectedPaths} class represents a data type for\n * finding directed paths from a source vertex s to every\n * other vertex in the digraph.\n *
\n * This implementation uses depth-first search.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and E\n * is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the digraph).\n *
\n * For additional documentation,\n * see Section 4.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DepthFirstDirectedPaths {\n private boolean[] marked; // marked[v] = true iff v is reachable from s\n private int[] edgeTo; // edgeTo[v] = last edge on path from s to v\n private final int s; // source vertex\n\n /**\n * Computes a directed path from {@code s} to every other vertex in {@code digraph}.\n * @param digraph the digraph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public DepthFirstDirectedPaths(Digraph digraph, int s) {\n marked = new boolean[digraph.V()];\n edgeTo = new int[digraph.V()];\n this.s = s;\n validateVertex(s);\n dfs(digraph, s);\n }\n\n private void dfs(Digraph digraph, int v) {\n marked[v] = true;\n for (int w : digraph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n dfs(digraph, w);\n }\n }\n }\n\n /**\n * Is there a directed path from the source vertex {@code s} to vertex {@code v}?\n * @param v the vertex\n * @return {@code true} if there is a directed path from the source\n * vertex {@code s} to vertex {@code v}, {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return marked[v];\n }\n\n\n /**\n * Returns a directed path from the source vertex {@code s} to vertex {@code v}, or\n * {@code null} if no such path.\n * @param v the vertex\n * @return the sequence of vertices on a directed path from the source vertex\n * {@code s} to vertex {@code v}, as an Iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n for (int x = v; x != s; x = edgeTo[x])\n path.push(x);\n path.push(s);\n return path;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code DepthFirstDirectedPaths} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Digraph digraph = new Digraph(in);\n // StdOut.println(digraph);\n\n int s = Integer.parseInt(args[1]);\n DepthFirstDirectedPaths dfs = new DepthFirstDirectedPaths(digraph, s);\n\n for (int v = 0; v < digraph.V(); v++) {\n if (dfs.hasPathTo(v)) {\n StdOut.printf(\"%d to %d: \", s, v);\n for (int x : dfs.pathTo(v)) {\n if (x == s) StdOut.print(x);\n else StdOut.print(\"-\" + x);\n }\n StdOut.println();\n }\n\n else {\n StdOut.printf(\"%d to %d: not connected\\n\", s, v);\n }\n\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DepthFirstOrder.java",
"content": "/******************************************************************************\n * Compilation: javac DepthFirstOrder.java\n * Execution: java DepthFirstOrder digraph.txt\n * Dependencies: Digraph.java Queue.java Stack.java StdOut.java\n * EdgeWeightedDigraph.java DirectedEdge.java\n * Data files: https://algs4.cs.princeton.edu/42digraph/tinyDAG.txt\n * https://algs4.cs.princeton.edu/42digraph/tinyDG.txt\n *\n * Compute preorder and postorder for a digraph or edge-weighted digraph.\n * Runs in O(E + V) time.\n *\n * % java DepthFirstOrder tinyDAG.txt\n * v pre post\n * --------------\n * 0 0 8\n * 1 3 2\n * 2 9 10\n * 3 10 9\n * 4 2 0\n * 5 1 1\n * 6 4 7\n * 7 11 11\n * 8 12 12\n * 9 5 6\n * 10 8 5\n * 11 6 4\n * 12 7 3\n * Preorder: 0 5 4 1 6 9 11 12 10 2 3 7 8\n * Postorder: 4 5 1 12 11 10 9 6 0 3 2 7 8\n * Reverse postorder: 8 7 2 3 0 6 9 10 11 12 1 5 4\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DepthFirstOrder} class represents a data type for\n * determining depth-first search ordering of the vertices in a digraph\n * or edge-weighted digraph, including preorder, postorder, and reverse postorder.\n *
\n * This implementation uses depth-first search.\n * Each constructor takes Θ(V + E) time,\n * where V is the number of vertices and E is the\n * number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the digraph).\n *
\n * For additional documentation,\n * see Section 4.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DepthFirstOrder {\n private boolean[] marked; // marked[v] = has v been marked in dfs?\n private int[] pre; // pre[v] = preorder number of v\n private int[] post; // post[v] = postorder number of v\n private Queue preorder; // vertices in preorder\n private Queue postorder; // vertices in postorder\n private int preCounter; // counter or preorder numbering\n private int postCounter; // counter for postorder numbering\n\n /**\n * Determines a depth-first order for a digraph.\n * @param digraph the digraph\n */\n public DepthFirstOrder(Digraph digraph) {\n pre = new int[digraph.V()];\n post = new int[digraph.V()];\n postorder = new Queue();\n preorder = new Queue();\n marked = new boolean[digraph.V()];\n for (int v = 0; v < digraph.V(); v++)\n if (!marked[v]) dfs(digraph, v);\n\n assert check();\n }\n\n /**\n * Determines a depth-first order for an edge-weighted digraph.\n * @param digraph the edge-weighted digraph\n */\n public DepthFirstOrder(EdgeWeightedDigraph digraph) {\n pre = new int[digraph.V()];\n post = new int[digraph.V()];\n postorder = new Queue();\n preorder = new Queue();\n marked = new boolean[digraph.V()];\n for (int v = 0; v < digraph.V(); v++)\n if (!marked[v]) dfs(digraph, v);\n }\n\n // run DFS in the digraph from vertex v and compute preorder/postorder\n private void dfs(Digraph digraph, int v) {\n marked[v] = true;\n pre[v] = preCounter++;\n preorder.enqueue(v);\n for (int w : digraph.adj(v)) {\n if (!marked[w]) {\n dfs(digraph, w);\n }\n }\n postorder.enqueue(v);\n post[v] = postCounter++;\n }\n\n // run DFS in an edge-weighted digraph from vertex v and compute preorder/postorder\n private void dfs(EdgeWeightedDigraph digraph, int v) {\n marked[v] = true;\n pre[v] = preCounter++;\n preorder.enqueue(v);\n for (DirectedEdge e : digraph.adj(v)) {\n int w = e.to();\n if (!marked[w]) {\n dfs(digraph, w);\n }\n }\n postorder.enqueue(v);\n post[v] = postCounter++;\n }\n\n /**\n * Returns the preorder number of vertex {@code v}.\n * @param v the vertex\n * @return the preorder number of vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int pre(int v) {\n validateVertex(v);\n return pre[v];\n }\n\n /**\n * Returns the postorder number of vertex {@code v}.\n * @param v the vertex\n * @return the postorder number of vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int post(int v) {\n validateVertex(v);\n return post[v];\n }\n\n /**\n * Returns the vertices in postorder.\n * @return the vertices in postorder, as an iterable of vertices\n */\n public Iterable post() {\n return postorder;\n }\n\n /**\n * Returns the vertices in preorder.\n * @return the vertices in preorder, as an iterable of vertices\n */\n public Iterable pre() {\n return preorder;\n }\n\n /**\n * Returns the vertices in reverse postorder.\n * @return the vertices in reverse postorder, as an iterable of vertices\n */\n public Iterable reversePost() {\n Stack reverse = new Stack();\n for (int v : postorder)\n reverse.push(v);\n return reverse;\n }\n\n\n // check that pre() and post() are consistent with pre(v) and post(v)\n private boolean check() {\n\n // check that post(v) is consistent with post()\n int r = 0;\n for (int v : post()) {\n if (post(v) != r) {\n StdOut.println(\"post(v) and post() inconsistent\");\n return false;\n }\n r++;\n }\n\n // check that pre(v) is consistent with pre()\n r = 0;\n for (int v : pre()) {\n if (pre(v) != r) {\n StdOut.println(\"pre(v) and pre() inconsistent\");\n return false;\n }\n r++;\n }\n\n return true;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code DepthFirstOrder} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Digraph digraph = new Digraph(in);\n\n DepthFirstOrder dfs = new DepthFirstOrder(digraph);\n StdOut.println(\" v pre post\");\n StdOut.println(\"--------------\");\n for (int v = 0; v < digraph.V(); v++) {\n StdOut.printf(\"%4d %4d %4d\\n\", v, dfs.pre(v), dfs.post(v));\n }\n\n StdOut.print(\"Preorder: \");\n for (int v : dfs.pre()) {\n StdOut.print(v + \" \");\n }\n StdOut.println();\n\n StdOut.print(\"Postorder: \");\n for (int v : dfs.post()) {\n StdOut.print(v + \" \");\n }\n StdOut.println();\n\n StdOut.print(\"Reverse postorder: \");\n for (int v : dfs.reversePost()) {\n StdOut.print(v + \" \");\n }\n StdOut.println();\n\n\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DepthFirstPaths.java",
"content": "/******************************************************************************\n * Compilation: javac DepthFirstPaths.java\n * Execution: java DepthFirstPaths G s\n * Dependencies: Graph.java Stack.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyCG.txt\n * https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n * https://algs4.cs.princeton.edu/41graph/largeG.txt\n *\n * Run depth-first search on an undirected graph.\n *\n * % java Graph tinyCG.txt\n * 6 8\n * 0: 2 1 5\n * 1: 0 2\n * 2: 0 1 3 4\n * 3: 5 4 2\n * 4: 3 2\n * 5: 3 0\n *\n * % java DepthFirstPaths tinyCG.txt 0\n * 0 to 0: 0\n * 0 to 1: 0-2-1\n * 0 to 2: 0-2\n * 0 to 3: 0-2-3\n * 0 to 4: 0-2-3-4\n * 0 to 5: 0-2-3-5\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DepthFirstPaths} class represents a data type for finding\n * paths from a source vertex s to every other vertex\n * in an undirected graph.\n *
\n * This implementation uses depth-first search.\n * The constructor takes Θ(V + E) time in the\n * worst case, where V is the number of vertices and\n * E is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n *
\n * For additional documentation, see\n * Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DepthFirstPaths {\n private boolean[] marked; // marked[v] = is there an s-v path?\n private int[] edgeTo; // edgeTo[v] = last edge on s-v path\n private final int s; // source vertex\n\n /**\n * Computes a path between {@code s} and every other vertex in {@code graph}.\n * @param graph the graph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public DepthFirstPaths(Graph graph, int s) {\n this.s = s;\n edgeTo = new int[graph.V()];\n marked = new boolean[graph.V()];\n validateVertex(s);\n dfs(graph, s);\n }\n\n // depth first search from v\n private void dfs(Graph graph, int v) {\n marked[v] = true;\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n edgeTo[w] = v;\n dfs(graph, w);\n }\n }\n }\n\n /**\n * Is there a path between the source vertex {@code s} and vertex {@code v}?\n * @param v the vertex\n * @return {@code true} if there is a path, {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean hasPathTo(int v) {\n validateVertex(v);\n return marked[v];\n }\n\n /**\n * Returns a path between the source vertex {@code s} and vertex {@code v}, or\n * {@code null} if no such path.\n * @param v the vertex\n * @return the sequence of vertices on a path between the source vertex\n * {@code s} and vertex {@code v}, as an Iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable pathTo(int v) {\n validateVertex(v);\n if (!hasPathTo(v)) return null;\n Stack path = new Stack();\n for (int x = v; x != s; x = edgeTo[x])\n path.push(x);\n path.push(s);\n return path;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code DepthFirstPaths} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Graph graph = new Graph(in);\n int s = Integer.parseInt(args[1]);\n DepthFirstPaths dfs = new DepthFirstPaths(graph, s);\n\n for (int v = 0; v < graph.V(); v++) {\n if (dfs.hasPathTo(v)) {\n StdOut.printf(\"%d to %d: \", s, v);\n for (int x : dfs.pathTo(v)) {\n if (x == s) StdOut.print(x);\n else StdOut.print(\"-\" + x);\n }\n StdOut.println();\n }\n\n else {\n StdOut.printf(\"%d to %d: not connected\\n\", s, v);\n }\n\n }\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DepthFirstSearch.java",
"content": "/******************************************************************************\n * Compilation: javac DepthFirstSearch.java\n * Execution: java DepthFirstSearch filename.txt s\n * Dependencies: Graph.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/41graph/tinyG.txt\n * https://algs4.cs.princeton.edu/41graph/mediumG.txt\n *\n * Run depth first search on an undirected graph.\n * Runs in O(E + V) time.\n *\n * % java DepthFirstSearch tinyG.txt 0\n * 0 1 2 3 4 5 6\n * NOT connected\n *\n * % java DepthFirstSearch tinyG.txt 9\n * 9 10 11 12\n * NOT connected\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DepthFirstSearch} class represents a data type for\n * determining the vertices connected to a given source vertex s\n * in an undirected graph. For versions that find the paths, see\n * {@link DepthFirstPaths} and {@link BreadthFirstPaths}.\n *
\n * This implementation uses depth-first search.\n * See {@link NonrecursiveDFS} for a non-recursive version.\n * The constructor takes Θ(V + E) time in the worst\n * case, where V is the number of vertices and E\n * is the number of edges.\n * Each instance method takes Θ(1) time.\n * It uses Θ(V) extra space (not including the graph).\n *
\n * For additional documentation, see\n * Section 4.1\n * of Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DepthFirstSearch {\n private boolean[] marked; // marked[v] = is there an s-v path?\n private int count; // number of vertices connected to s\n\n /**\n * Computes the vertices in {@code graph} that are\n * connected to the source vertex {@code s}.\n * @param graph the graph\n * @param s the source vertex\n * @throws IllegalArgumentException unless {@code 0 <= s < V}\n */\n public DepthFirstSearch(Graph graph, int s) {\n marked = new boolean[graph.V()];\n validateVertex(s);\n dfs(graph, s);\n }\n\n // depth first search from v\n private void dfs(Graph graph, int v) {\n count++;\n marked[v] = true;\n for (int w : graph.adj(v)) {\n if (!marked[w]) {\n dfs(graph, w);\n }\n }\n }\n\n /**\n * Is there a path between the source vertex {@code s} and vertex {@code v}?\n * @param v the vertex\n * @return {@code true} if there is a path, {@code false} otherwise\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public boolean marked(int v) {\n validateVertex(v);\n return marked[v];\n }\n\n /**\n * Returns the number of vertices connected to the source vertex {@code s}.\n * @return the number of vertices connected to the source vertex {@code s}\n */\n public int count() {\n return count;\n }\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n int V = marked.length;\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Unit tests the {@code DepthFirstSearch} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Graph graph = new Graph(in);\n int s = Integer.parseInt(args[1]);\n DepthFirstSearch search = new DepthFirstSearch(graph, s);\n for (int v = 0; v < graph.V(); v++) {\n if (search.marked(v))\n StdOut.print(v + \" \");\n }\n\n StdOut.println();\n if (search.count() != graph.V()) StdOut.println(\"NOT connected\");\n else StdOut.println(\"connected\");\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/Digraph.java",
"content": "/******************************************************************************\n * Compilation: javac Digraph.java\n * Execution: java Digraph filename.txt\n * Dependencies: Bag.java In.java StdOut.java\n * Data files: https://algs4.cs.princeton.edu/42digraph/tinyDG.txt\n * https://algs4.cs.princeton.edu/42digraph/mediumDG.txt\n * https://algs4.cs.princeton.edu/42digraph/largeDG.txt\n *\n * A graph, implemented using an array of lists.\n * Parallel edges and self-loops are permitted.\n *\n * % java Digraph tinyDG.txt\n * 13 vertices, 22 edges\n * 0: 5 1\n * 1:\n * 2: 0 3\n * 3: 5 2\n * 4: 3 2\n * 5: 4\n * 6: 9 4 8 0\n * 7: 6 9\n * 8: 6\n * 9: 11 10\n * 10: 12\n * 11: 4 12\n * 12: 9\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\nimport java.util.NoSuchElementException;\n\n/**\n * The {@code Digraph} class represents a directed graph of vertices\n * named 0 through V - 1.\n * It supports the following two primary operations: add an edge to the digraph,\n * iterate over all of the vertices adjacent from a given vertex.\n * It also provides\n * methods for returning the indegree or outdegree of a vertex,\n * the number of vertices V in the digraph,\n * the number of edges E in the digraph, and the reverse digraph.\n * Parallel edges and self-loops are permitted.\n *
\n * This implementation uses an adjacency-lists representation, which\n * is a vertex-indexed array of {@link Bag} objects.\n * It uses Θ(E + V) space, where E is\n * the number of edges and V is the number of vertices.\n * The reverse() method takes Θ(E + V) time\n * and space; all other instance methods take Θ(1) time. (Though, iterating over\n * the vertices returned by {@link #adj(int)} takes time proportional\n * to the outdegree of the vertex.)\n * Constructing an empty digraph with V vertices takes\n * Θ(V) time; constructing a digraph with E edges\n * and V vertices takes Θ(E + V) time.\n *
\n * For additional documentation,\n * see Section 4.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\n\npublic class Digraph {\n private static final String NEWLINE = System.getProperty(\"line.separator\");\n\n private final int V; // number of vertices in this digraph\n private int E; // number of edges in this digraph\n private Bag[] adj; // adj[v] = adjacency list for vertex v\n private int[] indegree; // indegree[v] = indegree of vertex v\n\n /**\n * Initializes an empty digraph with V vertices.\n *\n * @param V the number of vertices\n * @throws IllegalArgumentException if {@code V < 0}\n */\n public Digraph(int V) {\n if (V < 0) throw new IllegalArgumentException(\"Number of vertices in a Digraph must be non-negative\");\n this.V = V;\n this.E = 0;\n indegree = new int[V];\n adj = (Bag[]) new Bag[V];\n for (int v = 0; v < V; v++) {\n adj[v] = new Bag();\n }\n }\n\n /**\n * Initializes a digraph from the specified input stream.\n * The format is the number of vertices V,\n * followed by the number of edges E,\n * followed by E pairs of vertices, with each entry separated by whitespace.\n *\n * @param in the input stream\n * @throws IllegalArgumentException if {@code in} is {@code null}\n * @throws IllegalArgumentException if the endpoints of any edge are not in prescribed range\n * @throws IllegalArgumentException if the number of vertices or edges is negative\n * @throws IllegalArgumentException if the input stream is in the wrong format\n */\n public Digraph(In in) {\n if (in == null) throw new IllegalArgumentException(\"argument is null\");\n try {\n this.V = in.readInt();\n if (V < 0) throw new IllegalArgumentException(\"number of vertices in a Digraph must be non-negative\");\n indegree = new int[V];\n adj = (Bag[]) new Bag[V];\n for (int v = 0; v < V; v++) {\n adj[v] = new Bag();\n }\n int E = in.readInt();\n if (E < 0) throw new IllegalArgumentException(\"number of edges in a Digraph must be non-negative\");\n for (int i = 0; i < E; i++) {\n int v = in.readInt();\n int w = in.readInt();\n addEdge(v, w);\n }\n }\n catch (NoSuchElementException e) {\n throw new IllegalArgumentException(\"invalid input format in Digraph constructor\", e);\n }\n }\n\n /**\n * Initializes a new digraph that is a deep copy of the specified digraph.\n *\n * @param digraph the digraph to copy\n * @throws IllegalArgumentException if {@code digraph} is {@code null}\n */\n public Digraph(Digraph digraph) {\n if (digraph == null) throw new IllegalArgumentException(\"argument is null\");\n\n this.V = digraph.V();\n this.E = digraph.E();\n if (V < 0) throw new IllegalArgumentException(\"Number of vertices in a Digraph must be non-negative\");\n\n // update indegrees\n indegree = new int[V];\n for (int v = 0; v < V; v++)\n this.indegree[v] = digraph.indegree(v);\n\n // update adjacency lists\n adj = (Bag[]) new Bag[V];\n for (int v = 0; v < V; v++) {\n adj[v] = new Bag();\n }\n\n for (int v = 0; v < digraph.V(); v++) {\n // reverse so that adjacency list is in same order as original\n Stack reverse = new Stack();\n for (int w : digraph.adj[v]) {\n reverse.push(w);\n }\n for (int w : reverse) {\n adj[v].add(w);\n }\n }\n }\n\n /**\n * Returns the number of vertices in this digraph.\n *\n * @return the number of vertices in this digraph\n */\n public int V() {\n return V;\n }\n\n /**\n * Returns the number of edges in this digraph.\n *\n * @return the number of edges in this digraph\n */\n public int E() {\n return E;\n }\n\n\n // throw an IllegalArgumentException unless {@code 0 <= v < V}\n private void validateVertex(int v) {\n if (v < 0 || v >= V)\n throw new IllegalArgumentException(\"vertex \" + v + \" is not between 0 and \" + (V-1));\n }\n\n /**\n * Adds the directed edge v→w to this digraph.\n *\n * @param v the tail vertex\n * @param w the head vertex\n * @throws IllegalArgumentException unless both {@code 0 <= v < V} and {@code 0 <= w < V}\n */\n public void addEdge(int v, int w) {\n validateVertex(v);\n validateVertex(w);\n adj[v].add(w);\n indegree[w]++;\n E++;\n }\n\n /**\n * Returns the vertices adjacent from vertex {@code v} in this digraph.\n *\n * @param v the vertex\n * @return the vertices adjacent from vertex {@code v} in this digraph, as an iterable\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public Iterable adj(int v) {\n validateVertex(v);\n return adj[v];\n }\n\n /**\n * Returns the number of directed edges incident from vertex {@code v}.\n * This is known as the outdegree of vertex {@code v}.\n *\n * @param v the vertex\n * @return the outdegree of vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int outdegree(int v) {\n validateVertex(v);\n return adj[v].size();\n }\n\n /**\n * Returns the number of directed edges incident to vertex {@code v}.\n * This is known as the indegree of vertex {@code v}.\n *\n * @param v the vertex\n * @return the indegree of vertex {@code v}\n * @throws IllegalArgumentException unless {@code 0 <= v < V}\n */\n public int indegree(int v) {\n validateVertex(v);\n return indegree[v];\n }\n\n /**\n * Returns the reverse of the digraph.\n *\n * @return the reverse of the digraph\n */\n public Digraph reverse() {\n Digraph reverse = new Digraph(V);\n for (int v = 0; v < V; v++) {\n for (int w : adj(v)) {\n reverse.addEdge(w, v);\n }\n }\n return reverse;\n }\n\n /**\n * Returns a string representation of the graph.\n *\n * @return the number of vertices V, followed by the number of edges E,\n * followed by the V adjacency lists\n */\n public String toString() {\n StringBuilder s = new StringBuilder();\n s.append(V + \" vertices, \" + E + \" edges \" + NEWLINE);\n for (int v = 0; v < V; v++) {\n s.append(String.format(\"%d: \", v));\n for (int w : adj[v]) {\n s.append(String.format(\"%d \", w));\n }\n s.append(NEWLINE);\n }\n return s.toString();\n }\n\n /**\n * Returns a string representation of this digraph in DOT format,\n * suitable for visualization with Graphviz.\n *\n * To visualize the digraph, install Graphviz (e.g., \"brew install graphviz\").\n * Then use one of the graph visualization tools\n * - dot (hierarchical or layer drawing)\n * - neato (spring model)\n * - fdp (force-directed placement)\n * - sfdp (scalable force-directed placement)\n * - twopi (radial layout)\n *\n * For example, the following commands will create graph drawings in SVG\n * and PDF formats\n * - dot input.dot -Tsvg -o output.svg\n * - dot input.dot -Tpdf -o output.pdf\n *\n * To change the digraph attributes (e.g., vertex and edge shapes, arrows, colors)\n * in the DOT format, see https://graphviz.org/doc/info/lang.html\n *\n * @return a string representation of this digraph in DOT format\n */\n public String toDot() {\n StringBuilder s = new StringBuilder();\n s.append(\"digraph {\" + NEWLINE);\n s.append(\"node[shape=circle, style=filled, fixedsize=true, width=0.3, fontsize=\\\"10pt\\\"]\" + NEWLINE);\n s.append(\"edge[arrowhead=normal]\" + NEWLINE);\n for (int v = 0; v < V; v++) {\n for (int w : adj[v]) {\n s.append(v + \" -> \" + w + NEWLINE);\n }\n }\n s.append(\"}\" + NEWLINE);\n return s.toString();\n }\n\n /**\n * Unit tests the {@code Digraph} data type.\n *\n * @param args the command-line arguments\n */\n public static void main(String[] args) {\n In in = new In(args[0]);\n Digraph graph = new Digraph(in);\n StdOut.println(graph);\n }\n\n}\n\n/******************************************************************************\n * Copyright 2002-2025, Robert Sedgewick and Kevin Wayne.\n *\n * This file is part of algs4.jar, which accompanies the textbook\n *\n * Algorithms, 4th edition by Robert Sedgewick and Kevin Wayne,\n * Addison-Wesley Professional, 2011, ISBN 0-321-57351-X.\n * http://algs4.cs.princeton.edu\n *\n *\n * algs4.jar is free software: you can redistribute it and/or modify\n * it under the terms of the GNU General Public License as published by\n * the Free Software Foundation, either version 3 of the License, or\n * (at your option) any later version.\n *\n * algs4.jar is distributed in the hope that it will be useful,\n * but WITHOUT ANY WARRANTY; without even the implied warranty of\n * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the\n * GNU General Public License for more details.\n *\n * You should have received a copy of the GNU General Public License\n * along with algs4.jar. If not, see http://www.gnu.org/licenses.\n ******************************************************************************/\n"
},
{
"path": "src/main/java/edu/princeton/cs/algs4/DigraphGenerator.java",
"content": "/******************************************************************************\n * Compilation: javac DigraphGenerator.java\n * Execution: java DigraphGenerator V E\n * Dependencies: Digraph.java\n *\n * A digraph generator.\n *\n ******************************************************************************/\n\npackage edu.princeton.cs.algs4;\n\n/**\n * The {@code DigraphGenerator} class provides static methods for creating\n * various digraphs, including Erdos-Renyi random digraphs, random DAGs,\n * random rooted trees, random rooted DAGs, random tournaments, path digraphs,\n * cycle digraphs, and the complete digraph.\n *
\n * For additional documentation, see Section 4.2 of\n * Algorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\n *\n * @author Robert Sedgewick\n * @author Kevin Wayne\n */\npublic class DigraphGenerator {\n private static final class Edge implements Comparable {\n private final int v;\n private final int w;\n\n private Edge(int v, int w) {\n this.v = v;\n this.w = w;\n }\n\n public int compareTo(Edge that) {\n if (this.v < that.v) return -1;\n if (this.v > that.v) return +1;\n if (this.w < that.w) return -1;\n if (this.w > that.w) return +1;\n return 0;\n }\n }\n\n // this class cannot be instantiated\n private DigraphGenerator() { }\n\n /**\n * Returns a random simple digraph containing {@code V} vertices and {@code E} edges.\n * @param V the number of vertices\n * @param E the number of vertices\n * @return a random simple digraph on {@code V} vertices, containing a total\n * of {@code E} edges\n * @throws IllegalArgumentException if no such simple digraph exists\n */\n public static Digraph simple(int V, int E) {\n if (E > (long) V*(V-1)) throw new IllegalArgumentException(\"Too many edges\");\n if (E < 0) throw new IllegalArgumentException(\"Too few edges\");\n Digraph digraph = new Digraph(V);\n SET set = new SET();\n while (digraph.E() < E) {\n int v = StdRandom.uniformInt(V);\n int w = StdRandom.uniformInt(V);\n Edge e = new Edge(v, w);\n if ((v != w) && !set.contains(e)) {\n set.add(e);\n digraph.addEdge(v, w);\n }\n }\n return digraph;\n }\n\n /**\n * Returns a random simple digraph on {@code V} vertices, with an\n * edge between any two vertices with probability {@code p}. This is sometimes\n * referred to as the Erdos-Renyi random digraph model.\n * This implementations takes time proportional to V^2 (even if {@code p} is small).\n * @param V the number of vertices\n * @param p the probability of choosing an edge\n * @return a random simple digraph on {@code V} vertices, with an edge between\n * any two vertices with probability {@code p}\n * @throws IllegalArgumentException if probability is not between 0 and 1\n */\n public static Digraph simple(int V, double p) {\n if (p < 0.0 || p > 1.0)\n throw new IllegalArgumentException(\"Probability must be between 0 and 1\");\n Digraph digraph = new Digraph(V);\n for (int v = 0; v < V; v++)\n for (int w = 0; w < V; w++)\n if (v != w)\n if (StdRandom.bernoulli(p))\n digraph.addEdge(v, w);\n return digraph;\n }\n\n /**\n * Returns the complete digraph on {@code V} vertices.\n * In a complete digraph, every pair of distinct vertices is connected\n * by two antiparallel edges. There are {@code V*(V-1)} edges.\n * @param V the number of vertices\n * @return the complete digraph on {@code V} vertices\n */\n public static Digraph complete(int V) {\n Digraph digraph = new Digraph(V);\n for (int v = 0; v < V; v++)\n for (int w = 0; w < V; w++)\n if (v != w) digraph.addEdge(v, w);\n return digraph;\n }\n\n /**\n * Returns a random simple DAG containing {@code V} vertices and {@code E} edges.\n * Note: it is not uniformly selected at random among all such DAGs.\n * @param V the number of vertices\n * @param E the number of vertices\n * @return a random simple DAG on {@code V} vertices, containing a total\n * of {@code E} edges\n * @throws IllegalArgumentException if no such simple DAG exists\n */\n public static Digraph dag(int V, int E) {\n if (E > (long) V*(V-1) / 2) throw new IllegalArgumentException(\"Too many edges\");\n if (E < 0) throw new IllegalArgumentException(\"Too few edges\");\n Digraph digraph = new Digraph(V);\n SET set = new SET();\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n while (digraph.E() < E) {\n int v = StdRandom.uniformInt(V);\n int w = StdRandom.uniformInt(V);\n Edge e = new Edge(v, w);\n if ((v < w) && !set.contains(e)) {\n set.add(e);\n digraph.addEdge(vertices[v], vertices[w]);\n }\n }\n return digraph;\n }\n\n /**\n * Returns a random tournament digraph on {@code V} vertices. A tournament digraph\n * is a digraph in which, for every pair of vertices, there is one and only one\n * directed edge connecting them. A tournament is an oriented complete graph.\n * @param V the number of vertices\n * @return a random tournament digraph on {@code V} vertices\n */\n public static Digraph tournament(int V) {\n Digraph digraph = new Digraph(V);\n for (int v = 0; v < digraph.V(); v++) {\n for (int w = v+1; w < digraph.V(); w++) {\n if (StdRandom.bernoulli(0.5)) digraph.addEdge(v, w);\n else digraph.addEdge(w, v);\n }\n }\n return digraph;\n }\n\n /**\n * Returns a complete rooted-in DAG on {@code V} vertices.\n * A rooted in-tree is a DAG in which there is a single vertex\n * reachable from every other vertex. A complete rooted in-DAG\n * has V*(V-1)/2 edges.\n * @param V the number of vertices\n * @return a complete rooted-in DAG on {@code V} vertices\n */\n public static Digraph completeRootedInDAG(int V) {\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n for (int i = 0; i < V; i++)\n for (int j = i+1; j < V; j++)\n digraph.addEdge(vertices[i], vertices[j]);\n\n return digraph;\n }\n\n /**\n * Returns a random rooted-in DAG on {@code V} vertices and {@code E} edges.\n * A rooted in-tree is a DAG in which there is a single vertex\n * reachable from every other vertex.\n * The DAG returned is not chosen uniformly at random among all such DAGs.\n * @param V the number of vertices\n * @param E the number of edges\n * @return a random rooted-in DAG on {@code V} vertices and {@code E} edges\n */\n public static Digraph rootedInDAG(int V, int E) {\n if (E > (long) V*(V-1) / 2) throw new IllegalArgumentException(\"Too many edges\");\n if (E < V-1) throw new IllegalArgumentException(\"Too few edges\");\n Digraph digraph = new Digraph(V);\n SET set = new SET();\n\n // fix a topological order\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n\n // one edge pointing from each vertex, other than the root = vertices[V-1]\n for (int v = 0; v < V-1; v++) {\n int w = StdRandom.uniformInt(v+1, V);\n Edge e = new Edge(v, w);\n set.add(e);\n digraph.addEdge(vertices[v], vertices[w]);\n }\n\n while (digraph.E() < E) {\n int v = StdRandom.uniformInt(V);\n int w = StdRandom.uniformInt(V);\n Edge e = new Edge(v, w);\n if ((v < w) && !set.contains(e)) {\n set.add(e);\n digraph.addEdge(vertices[v], vertices[w]);\n }\n }\n return digraph;\n }\n\n /**\n * Returns a complete rooted-out DAG on {@code V} vertices.\n * A rooted out-tree is a DAG in which every vertex is reachable\n * from a single vertex. A complete rooted in-DAG has V*(V-1)/2 edges.\n * @param V the number of vertices\n * @return a complete rooted-out DAG on {@code V} vertices\n */\n public static Digraph completeRootedOutDAG(int V) {\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n for (int i = 0; i < V; i++)\n for (int j = i+1; j < V; j++)\n digraph.addEdge(vertices[j], vertices[i]);\n\n return digraph;\n }\n\n /**\n * Returns a random rooted-out DAG on {@code V} vertices and {@code E} edges.\n * A rooted out-tree is a DAG in which every vertex is reachable from a\n * single vertex.\n * The DAG returned is not chosen uniformly at random among all such DAGs.\n * @param V the number of vertices\n * @param E the number of edges\n * @return a random rooted-out DAG on {@code V} vertices and {@code E} edges\n */\n public static Digraph rootedOutDAG(int V, int E) {\n if (E > (long) V*(V-1) / 2) throw new IllegalArgumentException(\"Too many edges\");\n if (E < V-1) throw new IllegalArgumentException(\"Too few edges\");\n Digraph digraph = new Digraph(V);\n SET set = new SET();\n\n // fix a topological order\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n\n // one edge pointing from each vertex, other than the root = vertices[V-1]\n for (int v = 0; v < V-1; v++) {\n int w = StdRandom.uniformInt(v+1, V);\n Edge e = new Edge(w, v);\n set.add(e);\n digraph.addEdge(vertices[w], vertices[v]);\n }\n\n while (digraph.E() < E) {\n int v = StdRandom.uniformInt(V);\n int w = StdRandom.uniformInt(V);\n Edge e = new Edge(w, v);\n if ((v < w) && !set.contains(e)) {\n set.add(e);\n digraph.addEdge(vertices[w], vertices[v]);\n }\n }\n return digraph;\n }\n\n /**\n * Returns a random rooted-in tree on {@code V} vertices.\n * A rooted in-tree is an oriented tree in which there is a single vertex\n * reachable from every other vertex.\n * The tree returned is not chosen uniformly at random among all such trees.\n * @param V the number of vertices\n * @return a random rooted-in tree on {@code V} vertices\n */\n public static Digraph rootedInTree(int V) {\n return rootedInDAG(V, V-1);\n }\n\n /**\n * Returns a random rooted-out tree on {@code V} vertices. A rooted out-tree\n * is an oriented tree in which each vertex is reachable from a single vertex.\n * It is also known as a arborescence or branching.\n * The tree returned is not chosen uniformly at random among all such trees.\n * @param V the number of vertices\n * @return a random rooted-out tree on {@code V} vertices\n */\n public static Digraph rootedOutTree(int V) {\n return rootedOutDAG(V, V-1);\n }\n\n /**\n * Returns a path digraph on {@code V} vertices.\n * @param V the number of vertices in the path\n * @return a digraph that is a directed path on {@code V} vertices\n */\n public static Digraph path(int V) {\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n for (int i = 0; i < V-1; i++) {\n digraph.addEdge(vertices[i], vertices[i+1]);\n }\n return digraph;\n }\n\n /**\n * Returns a complete binary tree digraph on {@code V} vertices.\n * @param V the number of vertices in the binary tree\n * @return a digraph that is a complete binary tree on {@code V} vertices\n */\n public static Digraph binaryTree(int V) {\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n for (int i = 1; i < V; i++) {\n digraph.addEdge(vertices[i], vertices[(i-1)/2]);\n }\n return digraph;\n }\n\n /**\n * Returns a cycle digraph on {@code V} vertices.\n * @param V the number of vertices in the cycle\n * @return a digraph that is a directed cycle on {@code V} vertices\n */\n public static Digraph cycle(int V) {\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[V];\n for (int i = 0; i < V; i++)\n vertices[i] = i;\n StdRandom.shuffle(vertices);\n for (int i = 0; i < V-1; i++) {\n digraph.addEdge(vertices[i], vertices[i+1]);\n }\n digraph.addEdge(vertices[V-1], vertices[0]);\n return digraph;\n }\n\n /**\n * Returns an Eulerian cycle digraph on {@code V} vertices.\n *\n * @param V the number of vertices in the cycle\n * @param E the number of edges in the cycle\n * @return a digraph that is a directed Eulerian cycle on {@code V} vertices\n * and {@code E} edges\n * @throws IllegalArgumentException if either {@code V <= 0} or {@code E <= 0}\n */\n public static Digraph eulerianCycle(int V, int E) {\n if (E <= 0)\n throw new IllegalArgumentException(\"An Eulerian cycle must have at least one edge\");\n if (V <= 0)\n throw new IllegalArgumentException(\"An Eulerian cycle must have at least one vertex\");\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[E];\n for (int i = 0; i < E; i++)\n vertices[i] = StdRandom.uniformInt(V);\n for (int i = 0; i < E-1; i++) {\n digraph.addEdge(vertices[i], vertices[i+1]);\n }\n digraph.addEdge(vertices[E-1], vertices[0]);\n return digraph;\n }\n\n /**\n * Returns an Eulerian path digraph on {@code V} vertices.\n *\n * @param V the number of vertices in the path\n * @param E the number of edges in the path\n * @return a digraph that is a directed Eulerian path on {@code V} vertices\n * and {@code E} edges\n * @throws IllegalArgumentException if either {@code V <= 0} or {@code E < 0}\n */\n public static Digraph eulerianPath(int V, int E) {\n if (E < 0)\n throw new IllegalArgumentException(\"negative number of edges\");\n if (V <= 0)\n throw new IllegalArgumentException(\"An Eulerian path must have at least one vertex\");\n Digraph digraph = new Digraph(V);\n int[] vertices = new int[E+1];\n for (int i = 0; i < E+1; i++)\n vertices[i] = StdRandom.uniformInt(V);\n for (int i = 0; i < E; i++) {\n digraph.addEdge(vertices[i], vertices[i+1]);\n }\n return digraph;\n }\n\n /**\n * Returns a random simple digraph on {@code V} vertices, {@code E}\n * edges and (at least) {@code c} strong components. The vertices are randomly\n * assigned integer labels between {@code 0} and {@code c-1} (corresponding to\n * strong components). Then, a strong component is creates among the vertices\n * with the same label. Next, random edges (either between two vertices with\n * the same labels or from a vertex with a smaller label to a vertex with a\n * larger label). The number of components will be equal to the number of\n * distinct labels that are assigned to vertices.\n *\n * @param V the number of vertices\n * @param E the number of edges\n * @param c the (maximum) number of strong components\n * @return a random simple digraph on {@code V} vertices and\n {@code E} edges, with (at most) {@code c} strong components\n * @throws IllegalArgumentException if {@code c} is larger than {@code V}\n */\n public static Digraph strong(int V, int E, int c) {\n if (c >= V || c <= 0)\n throw new IllegalArgumentException(\"Number of components must be between 1 and V\");\n if (E <= 2*(V-c))\n throw new IllegalArgumentException(\"Number of edges must be at least 2(V-c)\");\n if (E > (long) V*(V-1) / 2)\n throw new IllegalArgumentException(\"Too many edges\");\n\n // the digraph\n Digraph digraph = new Digraph(V);\n\n // edges added to G (to avoid duplicate edges)\n SET set = new SET
![\"Algorithms](\"http://algs4.cs.princeton.edu/cover.png\")
\nThis public repository\ncontains the Java source code\nfor the algorithms and clients in the textbook\nAlgorithms, 4th Edition by Robert Sedgewick and Kevin Wayne.\nThe official version at https://github.com/kevin-wayne/algs4\nis actively maintained and updated by the authors.\nThe programs are organized in the package