Copy disabled (too large)
Download .txt
Showing preview only (10,388K chars total). Download the full file to get everything.
Repository: jpa99/Algorithms
Branch: master
Commit: 694d3b302043
Files: 145
Total size: 23.4 MB
Directory structure:
gitextract_4er3oeyk/
├── .gitignore
├── Computational Geometry/
│ ├── GrahamScan.java
│ ├── JarvisMarch.java
│ └── README.md
├── DP/
│ ├── Edit_Distance.java
│ ├── Knapsack.java
│ ├── LCS.java
│ ├── README.md
│ └── maxDonations.java
├── Data Structures/
│ ├── BinaryTree.java
│ ├── Binary_Indexed_Tree.java
│ ├── Edge.java
│ ├── Graphs.java
│ ├── README.md
│ ├── Tree.java
│ └── Vertex.java
├── GoogleCodeJam/
│ ├── ABBA.java
│ ├── Alphabet_Cake.java
│ ├── BFCalculator.java
│ ├── Bathroom_Stalls.java
│ ├── Close_Match.java
│ ├── Coin_Jam.java
│ ├── Counting_Sheep.java
│ ├── CrossOver.java
│ ├── Digits.java
│ ├── Oversized_Pancake_Flipper.java
│ ├── Pancakes.java
│ ├── Prison_Break.java
│ ├── README.md
│ ├── Solution.java
│ ├── Super_Substrings.java
│ └── Tidy_Numbers.java
├── Graph/
│ ├── BFS.java
│ ├── Bellman_Ford.java
│ ├── DFS.java
│ ├── Dijkstra.java
│ ├── Edge.java
│ ├── Floyd_Warshall.java
│ ├── Ford_Fulkerson.java
│ ├── Graph_Traversal.java
│ ├── Graphs.java
│ ├── Johnson
│ ├── Karger.java
│ ├── Prim.java
│ ├── README.md
│ └── Vertex.java
├── LICENSE
├── Math/
│ └── README.md
├── Miscellaneous/
│ ├── Fisher_Yates.java
│ ├── Matrix_Exponentiation.java
│ ├── README.md
│ └── Subarray_Inversions.java
├── Optimization/
│ ├── LightConfigurationOptimization.java
│ ├── LightConfigurationOptimizationSA.java
│ ├── LocationalOptimizationIterative.java
│ └── README.md
├── ProjectEuler/
│ ├── Amicable_numbers.java
│ ├── Coded_triangle_numbers.java
│ ├── Collatz_sequence.java
│ ├── Combinatoric_selections.java
│ ├── Concealed_square.java
│ ├── Consecutive_distinct_prime_factors.java
│ ├── Counting_sundays.java
│ ├── Digit_factorials.java
│ ├── Digit_fifth_power.java
│ ├── Distinct_powers.java
│ ├── Even_fibonacci_sum.java
│ ├── Factorial_digit_sum.java
│ ├── Grid_product_maximum.java
│ ├── Highly_divisible_triangular.java
│ ├── Large_sum.java
│ ├── Largest_consecutive_product.java
│ ├── Lexicogrphic_permutations.java
│ ├── MATH_TOOLBOX.java
│ ├── Names_scores.java
│ ├── Nontrivial_digit_cancelling_fractions.java
│ ├── Nth_digit_powers.java
│ ├── Number_letter_counts.java
│ ├── PLAYGROUND.java
│ ├── Pandigital_prime.java
│ ├── Permuted_multiples.java
│ ├── Prime_Summation.java
│ ├── Prime_factorization.java
│ ├── Pythagorean_triplet.java
│ ├── README.md
│ ├── Reverse_message.java
│ ├── Smallest_multiple.java
│ ├── Square_digit_chains.java
│ ├── Thousand_digit_fibonacci.java
│ ├── Totient_maximum.java
│ ├── Totient_permutations.java
│ └── primes.java
├── README.md
├── Searching/
│ └── README.md
├── Sorting/
│ ├── Bogosort.java
│ ├── Bubble_Sort.java
│ ├── Counting_Sort.java
│ ├── Heapsort.java
│ ├── Insertion_Sort.java
│ ├── Mergesort.java
│ ├── Quicksort.java
│ ├── README.md
│ ├── Radix_Sort.java
│ ├── Selection_Sort.java
│ ├── Sorting.java
│ └── Timsort.java
├── Strings/
│ ├── Boyer_Moore.java
│ ├── KMP.java
│ ├── Naive_String_Searching.java
│ ├── README.md
│ ├── Rabin_Karp.java
│ ├── String_Algorithms.java
│ ├── Strings_d.in
│ └── Strings_random.in
└── USACO/
├── AngryCows.java
├── AngryCows2.java
├── BovineGenomics.java
├── BovineGenomics_bruteforce.java
├── BuildGates.java
├── CircularBarn.java
├── CowCode.java
├── CowDanceShow.java
├── CowTip.java
├── FencePainting.java
├── HPS.java
├── Haybales.java
├── HoofPaperScissors.java
├── LoadBalancing.java
├── MilkPails.java
├── ModernArt.java
├── ModernArt2.java
├── ModernArt2_bruteforce.java
├── MowingField.java
├── NotLast.java
├── PromotionCounting.java
├── README.md
├── SeqSum7.java
├── asdf.java
├── friday.java
├── gift1.java
├── marathon.java
├── reorder.java
├── ride.java
├── sample.java
└── test.java
================================================
FILE CONTENTS
================================================
================================================
FILE: .gitignore
================================================
# Compiled class file
*.class
# Log file
*.log
# BlueJ files
*.ctxt
# Mobile Tools for Java (J2ME)
.mtj.tmp/
# Package Files #
*.jar
*.war
*.ear
*.zip
*.tar.gz
*.rar
# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
hs_err_pid*
================================================
FILE: Computational Geometry/GrahamScan.java
================================================
import java.util.Arrays;
import java.util.Stack;
public class GrahamScan {
/*Graham's Scan
Problem (informal): Find convex hull surrounding a set of points
Algorithm: Find lowest point and sort remaining points by polar angle, push onto stack if left turn
Complexity:
* Time - O(nlogn) due to sorting; actual online algorithm is linear
* Space - O(n) to store set of points
Functions Defined:
* graham() - Graham's scan algorithm
* polarbubblesort() - Sorts points in order of increasing polar angle from minimum
* angle() - Computes angle between two lines given by three points
* dot() - computes dot product between two vectors to easily find angle
* norm() - computes magnitude of a vector
* cross() - finds cross product between two vectors to determine angle concavity
* d() - distance function, computes distance between two poitns
*/
public static void main(String[] args) {
//test set of points
int[][] points = {{0, -2}, {2, 0}, {2, 20}, {1, 1}, {1, 2}, {-2, 0}, {-1, -1}};
//Graham's Scan
Stack<int[]> s = graham(points);
for(int[] x : s){
System.out.println(Arrays.toString(x));
}
}
//Currently O(n^2) because of inefficient polar sort; use O(nlogn) sort to improve
public static Stack<int[]> graham(int[][] points){
Stack<int[]> stack = new Stack<int[]>();
//find lowest point -- guaranteed to be included in
int minindex = 0;
for(int i=0;i<points.length;i++){
if(points[i][1] < points[minindex][1])
minindex = i;
}
//swap lowest point with first point
int[] min = points[minindex];
points[minindex] = points[0];
points[0] = min;
//sort points clockwise aroung p0 by polar angle
int[] parmin = {points[minindex][0] - 1, points[minindex][1]};
points = polarbubblesort(points, min, parmin);
stack.push(points[0]);
stack.push(points[1]);
stack.push(points[2]);
//algorithm -- push if concave
for(int i = 3; i < points.length; i++){
while(angle(stack.get(1), stack.peek(), points[i]) >= 180){
stack.pop();
}
stack.push(points[i]);
}
return stack;
}
//O(n^2) TIME, O(1) SPACE, STABLE
//Improve to O(nlogn)
public static int[][] polarbubblesort(int[][] arr, int[] min, int[] parmin){
for(int i=0;i<arr.length;i++){
for(int j=0; j<arr.length-1;j++){
if(angle(parmin, min, arr[j]) < angle(parmin, min, arr[j+1])){
int[] temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
if(angle(parmin, min, arr[j]) == angle(parmin, min, arr[j+1]) && d(arr[j+1], min) < d(arr[j], min)){
int[] temp = arr[j];
arr[j] = arr[j+1];
arr[j+1] = temp;
}
}
}
return arr;
}
public static double angle(int[] a, int[] b, int[] c){
int[] v1 = {a[0] - b[0], a[1] - b[1]};
int[] v2 = {c[0] - b[0], c[1] - b[1]};
double val = Math.acos(dot(v1, v2)/(norm(v1)*norm(v2)))*180/Math.PI;
if(cross(v1, v2) > 0)
val = 360 - val;
return val;
}
public static double dot(int[] v1, int[] v2){
return v1[0]*v2[0] + v1[1]*v2[1];
}
public static double norm(int[] v){
return Math.sqrt(v[0]*v[0] + v[1]*v[1]);
}
public static int cross(int[] v1, int[] v2){
return v1[0]*v2[1] - v2[0]*v1[1];
}
public static double d(int[] a, int[] b){
return Math.sqrt(Math.pow(b[0] - a[0], 2) + Math.pow(b[1] - a[1], 2));
}
}
================================================
FILE: Computational Geometry/JarvisMarch.java
================================================
import java.util.Arrays;
import java.util.Stack;
public class JarvisMarch {
/*Jarvis March
Problem (informal): Find convex hull surrounding a set of points
Algorithm: Find lowest point and highest points, simulate wrapping string tightly around points
Complexity:
* Time - O(nh) where n is number of points and h is number of points on convex hull
* Space - O(n) to store set of points
Functions Defined:
* jarvis() - Jarvis march algorithm
* angle() - Computes angle between two lines given by three points
* dot() - computes dot product between two vectors to easily find angle
* norm() - computes magnitude of a vector
* cross() - finds cross product between two vectors to determine angle concavity
* d() - distance function, computes distance between two poitns
*/
public static void main(String[] args) {
//test set of points
int[][] points = {{0, -2}, {2, 0}, {2, 20}, {1, 1}, {1, 2}, {-2, 0}, {-1, -1}};
//Graham's Scan
Stack<int[]> s = jarvis(points);
for(int[] x : s){
System.out.println(Arrays.toString(x));
}
}
//Jarvis March algorithm
public static Stack<int[]> jarvis(int[][] points){
Stack<int[]> stack = new Stack<int[]>();
//find lowest & highest points -- guaranteed to be included in convex hull
int minindex = 0, maxindex = 0;
for(int i=0;i<points.length;i++){
if(points[i][1] < points[minindex][1])
minindex = i;
if(points[i][1] > points[maxindex][1])
maxindex = i;
}
int chain = 1;
stack.push(points[minindex]);
int lastindex = minindex;
while(lastindex != minindex || stack.size() == 1){
int[] parmin = {points[lastindex][0] + chain, points[lastindex][1]};
double minangle = 361;
int nextindex = 0;
for(int i=0; i < points.length; i++){
if(i == lastindex) continue;
double angle = angle(points[i], points[lastindex], parmin);
if(angle < minangle){
minangle = angle;
nextindex = i;
}
}
stack.push(points[nextindex]);
lastindex = nextindex;
if(lastindex == maxindex){
chain = -1;
}
}
stack.pop();
return stack;
}
public static double angle(int[] a, int[] b, int[] c){
int[] v1 = {a[0] - b[0], a[1] - b[1]};
int[] v2 = {c[0] - b[0], c[1] - b[1]};
double val = Math.acos(dot(v1, v2)/(norm(v1)*norm(v2)))*180/Math.PI;
if(cross(v1, v2) > 0)
val = 360 - val;
return val;
}
public static double dot(int[] v1, int[] v2){
return v1[0]*v2[0] + v1[1]*v2[1];
}
public static double norm(int[] v){
return Math.sqrt(v[0]*v[0] + v[1]*v[1]);
}
public static int cross(int[] v1, int[] v2){
return v1[0]*v2[1] - v2[0]*v1[1];
}
public static double d(int[] a, int[] b){
return Math.sqrt(Math.pow(b[0] - a[0], 2) + Math.pow(b[1] - a[1], 2));
}
}
================================================
FILE: Computational Geometry/README.md
================================================
# Computational Geometric Algorithms
## Convex Hull
* [Graham's Scan](https://github.com/jpa99/Algorithms/blob/master/Computational%20Geometry/GrahamScan.java)
* [Jarvis March](https://github.com/jpa99/Algorithms/blob/master/Computational%20Geometry/JarvisMarch.java)
================================================
FILE: DP/Edit_Distance.java
================================================
import java.util.Arrays;
public class Edit_Distance {
/*Edit (Levenshtein Distance) Algorithm
Problem (informal): Given two strings, find minimum number of deletions, insertions, or replacements required to transform
Algorithm: If characters are same, continue, else, consider removal, deletion, and replacement and consider minimum recursively
Complexity:
* Time - O(n^2)
* Space - O(n^2) with memoization and O(1) without
Functions Defined:
* editDistanceIterative() - Bottom up implementation, finds minimum iteratively
* editDistanceRecursive() - Top down implementation, recursive
*/
static int[][] dp;
public static void main(String[] args) {
String a = "hey if you like this repository, you should give it a star!";
String b = "I'd appreciate any feedback or requests -- just fork this repo and add to the README.md";
dp = new int [a.length()+1][b.length()+1];
for(int[] row :dp){
Arrays.fill(row, -1);
}
System.out.println(editDistanceIterative(a, b));
System.out.println(editDistanceTD(a, b));
}
public static int editDistanceIterative(String a, String b){
int[][] dp = new int[a.length()+1][b.length()+1];
for(int i=0; i <= a.length();i++){
for(int j=0; j <= b.length();j++){
if(i==0 || j==0)
dp[i][j] = i+j;
else if(a.charAt(i-1) == b.charAt(j-1))
dp[i][j] = dp[i-1][j-1];
else
dp[i][j] = 1 + Math.min(Math.min(dp[i-1][j], dp[i][j-1]), dp[i-1][j-1]);
}
}
return dp[a.length()][b.length()];
}
//minimal # of insertions, substitutions, deletions required to change String a to b
public static int editDistanceTD(String a, String b){
int m = a.length();
int n = b.length();
if(dp[m][n] !=-1){
return dp[m][n];
}
if(m==0 || n==0){
dp[m][n] = m+n;
return dp[m][n];
}
if(a.charAt(m-1) == b.charAt(n-1)){
dp[m][n] = editDistanceTD(a.substring(0, m-1), b.substring(0, n-1));
return dp[m][n];
}
dp[m][n] = 1 + Math.min(Math.min(editDistanceTD(a.substring(0, m-1), b), editDistanceTD(a, b.substring(0, n-1))), editDistanceTD(a.substring(0, m-1), b.substring(0, n-1)));
return dp[m][n];
}
}
================================================
FILE: DP/Knapsack.java
================================================
import cern.colt.Arrays;
import java.util.*;
public class Knapsack {
/*0-1 Knapsack Probelm
Problem (informal): Given set of items with cost and weight, find subset of items such that net weight does not exceed W and set has maximum total cost
Algorithm: Recursive -- try each possible item and calculate max of remaining
Complexity:
* Time - O(nW) where W is the maximum weight possible
* Space - O(n) only one array for number of items.
Functions Defined:
* knapsackTD() - Recursively consideres one less item and maximum of remaining subset
* fractionalknapsack() - Pretty trivial -- greedy algorithm suffices. Solved in O(nlogn) but also possible in O(n) via weighted medians
*/
static int[][] items;
static int maxweight;
public static void main(String[] args){
int[][] itemsx = {{60, 10}, {100, 20}, {120, 30}};
//{cost, weight}
items = itemsx;
maxweight = 50;
boolean[] insert = new boolean[items.length];
//System.out.println(knapsackBU(items, maxweight));
System.out.println(knapsackTD(maxweight, insert));
}
public static int knapsackTD(int maxweight, boolean[] insert){
int max = 0;
for(int i=0;i<items.length;i++){
if(!insert[i] && maxweight >= items[i][1]){
boolean[] insertclone = insert.clone();
insertclone[i] = true;
max = Math.max(items[i][0] + knapsackTD(maxweight - items[i][1], insertclone), max);
}
}
return max;
}
public static void fractionalknapsack(){
//greedy
//I don't think it's necessary to implement this since it's pretty straightforward.
//Just find the item with largest cost and take as much of it as possible. If you take all of it, continue to next largest.
}
}
================================================
FILE: DP/LCS.java
================================================
import java.util.*;
import cern.colt.Arrays;
public class LCS {
/*Longest Common Subsequence (LCS)
Problem (informal): Given two arrays, find largest subsequence of both arrays
Algorithm: If elements at position i are equal, find LCS of subarrays [0, i-1], else find max of both possible cases
Complexity:
* Time - O(n^2)
* Space - O(n^2) with memoization and O(1) without
Functions Defined:
* iterativeLCS() - Bottom up implementation, finds longest length and reconstructs sequence
* recursiveLCS() - Top down implementation, only outputs length of sequence
*/
static int[] arr1;
static int[] arr2;
static int[][] dp;
static Stack<Integer> solution = new Stack<Integer>();
public static void main(String[] args) {
int[] arrA = {1, 2, 3, 4, 7, 5, 9};
int[] arrB = {1, 4, 3, 7, 9, 5};
arr1 = arrA;
arr2 = arrB;
System.out.println(Arrays.toString(iterativeLCS(arrA, arrB)));
}
public static int[] iterativeLCS(int[] a, int[] b){
int[][] dp = new int[a.length+1][b.length+1];
for(int i = 1; i <= a.length; i++){
for(int j = 1; j <= b.length; j++){
if(a[i-1] == b[j-1]){
dp[i][j] = 1 + dp[i-1][j-1];
}
else{
dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
}
}
}
int[] lcs = new int[dp[a.length][b.length]];
int index = lcs.length-1;
int i=a.length; int j = b.length;
while(i > 0 && j > 0){
if(a[i-1] == b[j-1]){
lcs[index] = a[i-1];
i--; j--; index--;
}
else if(dp[i-1][j] >= dp[i][j-1])
i--;
else
j--;
}
return lcs;
}
public static int recursiveLCS(int a, int b){
if(a < 0 || b < 0) return 0;
if(arr1[a] == arr2[b]){
solution.push(arr1[a]);
dp[a][b] = 1 + recursiveLCS(a-1, b-1);
return dp[a][b];
}
int opt1 = recursiveLCS(a, b-1);
int opt2 = recursiveLCS(a-1, b);
if(opt1 >= opt2){
dp[a][b] = opt1;
}
else{
dp[a][b] = opt2;
}
return dp[a][b];
}
}
================================================
FILE: DP/README.md
================================================
# Dynamic Programming Algorithms
* [0-1 Knapsack](https://github.com/jpa99/Algorithms/blob/master/DP/Knapsack.java)
* [Edit (Levenshtein) Distance](https://github.com/jpa99/Algorithms/blob/master/DP/Edit_Distance.java)
* Longest Increasing Subsequence
* [Longest Common Subsequence](https://github.com/jpa99/Algorithms/blob/master/DP/LCS.java)
* [Maximum Nonadjacent Subset Sum](https://github.com/jpa99/Algorithms/blob/master/DP/maxDonations.java)
* Maximum Subset Sum
================================================
FILE: DP/maxDonations.java
================================================
public class maxDonations {
/*Maximum Donations (Topcoder)
Problem (informal): Given set S of values, find subset Q of values with maximum sum such that no two values in Q are adjacent in S
Algorithm: Recursive -- two possibilities at each branch, test both
Complexity:
* Time - O(n^2) - each branches off into two possibilities
* Space - O(n^2) due to DP array
Functions Defined:
* maxDonations() - main algorithm
*/
static int[] arr;
static int len;
static int[][] dp;
public static void main(String[] args) {
int[] arr2 = {10, 3, 2, 5, 7, 8};
//{10, 4, 5}
arr = arr2;
len = arr.length;
dp = new int[len][len];
}
public static int maxDonations(int start, int end){
if(end - start ==2) return Math.max(Math.max(arr[start], arr[end]), arr[start+1]);
if(end - start <=1) return Math.max(arr[start], arr[end]);
int start1 = (start+1)%len;
int val = arr[start];
int start2 = start, end2 = end;
if(start == 0){
start2+=2;
}
else{
start2+=2;
}
dp[start][end] = Math.max(maxDonations(start1, end), val + maxDonations(start2, end2));
return dp[start][end];
}
}
================================================
FILE: Data Structures/BinaryTree.java
================================================
import java.util.*;
import java.util.Arrays;
public class BinaryTree {
public static void main(String[] args) {
//Initialize tree manually
BinaryTreeNode root = new BinaryTreeNode(1);
root.leftChild = new BinaryTreeNode(3);
root.rightChild = new BinaryTreeNode(8);
root.rightChild.rightChild = new BinaryTreeNode(4);
System.out.println(balance(root));
//Initialize and balance tree from array
int[] BinaryTreeArray = {1, 4, 3, 5, 6, 8, 2, 12, 4, 15, 6, 9};
BinaryTreeNode tree = createBinaryTree(BinaryTreeArray);
System.out.println(tree);
System.out.println(balance(tree));
}
public static BinaryTreeNode createBinaryTree(int[] binaryTreeArray){
if(binaryTreeArray.length == 0) return null;
if(binaryTreeArray.length == 1) return new BinaryTreeNode((int) binaryTreeArray[0]);
int mid = (binaryTreeArray.length)/2;
BinaryTreeNode root = new BinaryTreeNode((int) binaryTreeArray[mid]);
root.rightChild = createBinaryTree(Arrays.copyOfRange(binaryTreeArray, mid+1, binaryTreeArray.length));
root.leftChild = createBinaryTree(Arrays.copyOfRange(binaryTreeArray, 0, mid));
return root;
}
//
public static BinaryTreeNode balance(BinaryTreeNode tree){
return createBinaryTree(tree.toArray());
}
//TreeNode data structure
static class BinaryTreeNode{
public int val = -1;
public BinaryTreeNode leftChild;
public BinaryTreeNode rightChild;
public BinaryTreeNode(int val){
this.val = val;
leftChild = null;
rightChild = null;
}
public String toString(){
String left = leftChild == null ? "":leftChild.toString();
String right = rightChild == null ? "":rightChild.toString();
return val+" "+left+right;
}
public ArrayList<Integer> toArrayList(){
ArrayList<Integer> left = leftChild == null ? new ArrayList<Integer>():leftChild.toArrayList();
ArrayList<Integer> right = rightChild == null ? new ArrayList<Integer>():rightChild.toArrayList();
ArrayList<Integer> list = new ArrayList<Integer>();
list.add(val);
list.addAll(left);
list.addAll(right);
return list;
}
public int[] toArray(){
return toArrayList().stream().mapToInt(i -> i).toArray();
}
}
}
================================================
FILE: Data Structures/Binary_Indexed_Tree.java
================================================
public class Binary_Indexed_Tree {
public static void main(String[] args) throws IOException {
//testting BIT
BIT bit = new BIT(12);
bit.update(4, 1);
bit.update(3, 1);
bit.update(5, 1);
bit.update(2, 1);
bit.update(5, 1);
bit.update(4, -1);
int a = bit.read(9);
System.out.println(a);
}
static class BIT{
int[] binary_indexed_tree;
int maxVal;
public BIT(int n){
binary_indexed_tree = new int[++n];
maxVal = n;
}
public void update(int index, int val){
while (index <= maxVal){
tree[index] += val;
index += (index & -index); //last bit removal
}
}
//Returns the cumulative frequency of index index
public int read(int index){
int sum=0;
while (index>0){
sum += tree[index];
index -= (index & -index);
}
return sum;
}
}
}
================================================
FILE: Data Structures/Edge.java
================================================
public class Edge {
//Edge class with built in functions; used for Graph class
private int weight;
private Vertex v1;
private Vertex v2;
private boolean directed=false;
public Edge(int weight, int value1, int value2){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
}
public Edge(int weight, int value1, int value2, boolean directed){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
directed=true;
}
//returns whether or not the edge is incident to the input vertex
public boolean incident(int vertex){
return vertex==v1.getValue() || vertex==v2.getValue();
}
public Vertex getVertex1(){
return v1;
}
public Vertex getVertex2(){
return v2;
}
public int getWeight(){
return weight;
}
public boolean getDirected(){
return directed;
}
public void makeDirected(){
directed=true;
}
public void swap(){
Vertex temp=v2;
v2=v1;
v1=temp;
}
public String toString(){
return weight+"["+v1+","+v2+"]";
}
}
================================================
FILE: Data Structures/Graphs.java
================================================
public class Graphs {
//Graph class with certain built in algorithms
private Edge[] edges;
private Vertex[] vertices;
public Graphs(Vertex[] vertices, Edge[] edges){
this.vertices=vertices;
this.edges=edges;
}
//Returns whether or not graph contains input vertex
public boolean hasVertex(Vertex v){
for(Vertex vertex:vertices){
if(vertex.getValue()==v.getValue()){
return true;
}
}
return false;
}
//returns sum of edge weights in graph
public int getCost(){
int sum=0;
for(Edge e:edges){
sum+=e.getWeight();
}
return sum;
}
public Edge[] getEdges(){
return edges;
}
public String[] vertex(){
String[] v= new String[vertices.length];
for(int i=0;i<vertices.length;i++){
v[i]=vertices[i].toString();
}
return v;
}
public Vertex[] getVertices(){
return vertices;
}
public String toString(){
String ver="";
for(Vertex v:vertices){
ver+=v.toString()+",";
}
String edg="";
for(Edge e:edges){
edg+=e.toString()+" ";
}
return "Vertices: "+ver+"\nEdges: "+edg+"\n";
}
}
================================================
FILE: Data Structures/README.md
================================================
# Data Structures
* [Binary Indexed Tree (Fenwick Tree)](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/Binary_Indexed_Tree.java)
* [Binary Tree](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/BinaryTree.java)
* [Tree](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/Tree.java)
* [Graph](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/Graphs.java)
+ [Edge](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/Edge.java)
+ [Vertex](https://github.com/jpa99/Algorithms/edit/master/Data%20Structures/Vertex.java)
================================================
FILE: Data Structures/Tree.java
================================================
import java.util.*;
public class Tree {
public static void main(String[] args) {
Node<String> tree = new Node<String>("Parent");
tree.add(new Node<String>("child"));
tree.getChildren().get(0);
}
public static class Node<T> {
private List<Node<T>> children = new ArrayList<Node<T>>();
private Node<T> parent = null;
private T data = null;
public Node(T data) {
this.data = data;
}
public Node(T data, Node<T> parent) {
this.data = data;
this.parent = parent;
}
public List<Node<T>> getChildren() {
return children;
}
public void setParent(Node<T> parent) {
parent.add(this);
this.parent = parent;
}
public void add(T data) {
Node<T> child = new Node<T>(data);
child.setParent(this);
this.children.add(child);
}
public void add(Node<T> child) {
child.setParent(this);
this.children.add(child);
}
public T data() {
return this.data;
}
public void setData(T data) {
this.data = data;
}
public boolean isRoot() {
return (this.parent == null);
}
public boolean isLeaf() {
return this.children.size() == 0;
}
public void removeParent() {
this.parent = null;
}
}
public class Graph {
private Edge[] edges;
private Vertex[] vertices;
public Graph(Vertex[] vertices, Edge[] edges){
this.vertices=vertices;
this.edges=edges;
}
//Returns whether or not graph contains input vertex
public boolean hasVertex(Vertex v){
for(Vertex vertex:vertices){
if(vertex.getValue()==v.getValue()){
return true;
}
}
return false;
}
//returns sum of edge weights in graph
public int getCost(){
int sum=0;
for(Edge e:edges){
sum+=e.getWeight();
}
return sum;
}
public Edge[] getEdges(){
return edges;
}
public String[] vertex(){
String[] v= new String[vertices.length];
for(int i=0;i<vertices.length;i++){
v[i]=vertices[i].toString();
}
return v;
}
public Vertex[] getVertices(){
return vertices;
}
public String toString(){
String ver="";
for(Vertex v:vertices){
ver+=v.toString()+",";
}
String edg="";
for(Edge e:edges){
edg+=e.toString()+" ";
}
return "Vertices: "+ver+"\nEdges: "+edg+"\n";
}
}
public class Edge {
private int weight;
private Vertex v1;
private Vertex v2;
private boolean directed=false;
public Edge(int weight, int value1, int value2){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
}
public Edge(int weight, int value1, int value2, boolean directed){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
directed=true;
}
//returns whether or not the edge is incident to the input vertex
public boolean incident(int vertex){
return vertex==v1.getValue() || vertex==v2.getValue();
}
public Vertex getVertex1(){
return v1;
}
public Vertex getVertex2(){
return v2;
}
public int getWeight(){
return weight;
}
public boolean getDirected(){
return directed;
}
public void makeDirected(){
directed=true;
}
public void swap(){
Vertex temp=v2;
v2=v1;
v1=temp;
}
public String toString(){
return weight+"["+v1+","+v2+"]";
}
}
public class Vertex {
int value;
public Vertex(int val){
value=val;
}
public int getValue(){
return value;
}
public String toString(){
return String.valueOf(value);
}
}
}
================================================
FILE: Data Structures/Vertex.java
================================================
static class Vertex{
public int name;
public int distance;
public Vertex(int name, int distance){
this.name = name;
this.distance = distance;
}
public String toString(){
return "Name: "+name+", Weight: "+distance;
}
}
================================================
FILE: GoogleCodeJam/ABBA.java
================================================
public class ABBA {
public static void main(String[] args) throws Exception{
System.out.println(canObtain("B","ABBA"));
System.out.println(canObtain("AB","ABB"));
System.out.println(canObtain("BBAB","ABABABABB"));
System.out.println(canObtain("BBBBABABBBBBBA","BBBBABABBABBBBBBABABBBBBBBBABAABBBAA"));
System.out.println(canObtain("A","BB"));
}
public static String canObtain(String initial, String target){
boolean fwd=true;
while(target.length()>initial.length()){
String ch="";
int len=target.length();
if(fwd){
ch=target.substring(len-1);
target=target.substring(0, len-1);
}
else{
ch=target.substring(0, 1);
target=target.substring(1);
}
if(ch.equals("B")){
fwd=!fwd;
}
}
if(fwd && initial.equals(target))
return "possible";
else if(!fwd){
int l=target.length();
for(int i=0;i<l;i++){
if(!target.substring(l-i-1, l-i).equals(initial.substring(i, i+1))){
return "impossible";
}
}
return "possible";
}
else
return "impossible";
}
}
================================================
FILE: GoogleCodeJam/Alphabet_Cake.java
================================================
import java.util.*;
import java.util.Map.Entry;
import java.io.*;
import java.time.*;
import java.math.*;
import java.awt.*;
public class Alphabet_Cake {
static String input="input.txt";
static String out="output.txt";
static PrintWriter writer;
static Scan scan;
public static void main(String[] args) throws Exception{
writer=new PrintWriter(new BufferedWriter(new FileWriter(out)));
Scan scan=new Scan(input);
int numinputs=scan.nextInt();
for(int cases=1;cases<=numinputs;cases++){
int r=scan.nextInt(); int c=scan.nextInt();
char[][] cake=new char[r][c];
ArrayList<Character> nonfree=new ArrayList<Character>();
HashMap<Character, ArrayList<int[]>> map=new HashMap<Character, ArrayList<int[]>>();
for(int i=0;i<r;i++){
cake[i]=scan.nextLine().toCharArray();
for(int j=0;j<c;j++){
char x=cake[i][j];
int[] asdf={i, j};
ArrayList<int[]> ar=map.get(x);
ar.add(asdf);
map.put(x, ar);
}
}
Iterator<Entry<Character, ArrayList<int[]>>> it = map.entrySet().iterator();
while (it.hasNext()) {
Map.Entry<Character, ArrayList<int[]>> pair = (Map.Entry<Character, ArrayList<int[]>>)it.next();
ArrayList<int[]> arr=pair.getValue();
char cc=pair.getKey();
it.remove();
boolean h=false, v=false;
for(int k=1;k<arr.size();k++){
if(Math.abs(arr.get(k)[0]-arr.get(k-1)[0]) > 1){
int sr=arr.get(0)[0], er=arr.get(arr.size())[0];
int sc=arr.get(0)[1], ec=arr.get(arr.size())[1];
break;
}
if(Math.abs(arr.get(k)[1]-arr.get(k-1)[1]) > 1){
int sr=arr.get(0)[0], er=arr.get(arr.size())[0];
int sc=arr.get(0)[1], ec=arr.get(arr.size())[1];
break;
}
}
if(!(v || h))
continue;
int sr=arr.get(0)[0], er=arr.get(arr.size())[0];
int sc=arr.get(0)[1], ec=arr.get(arr.size())[1];
for(int[] p:pair.getValue()){
cake[p[0]][p[1]]=cc;
}
}
String output="Case #"+cases+": ";
System.out.println(output);
writer.println(output);
}
writer.close();
}
//Print line
public static <T> void print(T t){
System.out.println(t);
}
//Optimized Scanner Class, includes next String, int, Long, double, line
static class Scan{
BufferedReader br;
StringTokenizer st;
public Scan(String file) throws IOException{
br = new BufferedReader(new InputStreamReader(new FileInputStream(file)));
}
String next(){
while (st == null || !st.hasMoreElements()){
try{
st = new StringTokenizer(br.readLine());
}
catch (IOException e){
e.printStackTrace();
}
}
return st.nextToken();
}
int nextInt(){
return Integer.parseInt(next());
}
long nextLong(){
return Long.parseLong(next());
}
double nextDouble(){
return Double.parseDouble(next());
}
String nextLine(){
String str = "";
try{
str = br.readLine();
}
catch (IOException e){
e.printStackTrace();
}
return str;
}
}
}
================================================
FILE: GoogleCodeJam/BFCalculator.java
================================================
public class BFCalculator {
public static void main(String[] args) {
// TODO Auto-generated method stub
}
}
================================================
FILE: GoogleCodeJam/Bathroom_Stalls.java
================================================
import java.io.File;
import java.io.PrintWriter;
import java.util.Arrays;
import java.util.Scanner;
public class Bathroom_Stalls {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("bathroom.in"));
PrintWriter writer=new PrintWriter(new File("output.txt"));
int numCases=scan.nextInt();
for(int cases=1;cases<=numCases;cases++){
int n=scan.nextInt();
int k=scan.nextInt();
k++;
boolean[] stalls=new boolean[n+2];
stalls[0]=true;
stalls[n+1]=true;
for(int x=1;x<=n;x++){
stalls[x]=false;
}
//[true, false, false, false, true]//
int[][] values=new int[n+2][2];
int[] arr={-1, -1};
values[0]=arr;
values[n+1]=arr;
int lastindex=0;
while(--k>0){
int minimax=-1, maximax=-1, nummin=0, indexofmin=0, indexofmax=0;
for(int i=1;i<n+1;i++){
int left=0, right=0, index=i;
if(stalls[i]){
values[i]=arr;
continue;
}
for(int j=i-1;j>=0;j--){
if(stalls[j])
break;
left++;
}
for(int j=i+1;j<n+2;j++){
if(stalls[j])
break;
right++;
}
values[i][0]=left;
values[i][1]=right;
//finds global max and global min of LR
if(Math.min(left, right) > minimax){
minimax=Math.min(left, right);
nummin=0;
indexofmin=i;
maximax=Math.max(left, right);
indexofmax=i;
}
else if(Math.min(left, right) == minimax){
nummin++;
if(Math.max(left, right) > maximax){
maximax=Math.max(left, right);
indexofmax=i;
}
}
}
if(nummin==0){
stalls[indexofmin]=true;
lastindex=indexofmin;
}
else{
stalls[indexofmax]=true;
lastindex=indexofmax;
}
}
int minimum=Math.min(values[lastindex][0], values[lastindex][1]);
int maximum=Math.max(values[lastindex][0], values[lastindex][1]);
System.out.printf("Case #%d: %d %d\n", cases, maximum, minimum);
writer.printf("Case #%d: %d %d\n", cases, maximum, minimum);
}
writer.close();
scan.close();
}
}
================================================
FILE: GoogleCodeJam/Close_Match.java
================================================
import java.util.Scanner;
import java.io.*;
import java.time.*;
import java.math.*;
import java.awt.*;
public class Close_Match {
public static void main(String[] args) throws Exception{
Scanner scan= new Scanner(new File("input.txt"));
PrintWriter writer=new PrintWriter(new File("output.txt"));
int numinputs=scan.nextInt();
scan.nextLine();
for(int cases=1;cases<=numinputs;cases++){
String a=scan.nextLine();
String b=scan.nextLine();
String apat=a.replaceAll("\\*", ".{0,4}");
String bpat=b.replaceAll("\\*", ".{0,4}");
System.out.println(apat);
System.out.println(bpat);
System.out.println("bpat".matches(apat));
//String output="Case #"+cases+": "+"_____";
//System.out.println(output);
//writer.println(output);
}
scan.close();
writer.close();
}
}
================================================
FILE: GoogleCodeJam/Coin_Jam.java
================================================
import java.io.*;
import java.util.*;
import java.util.stream.IntStream;
public class Coin_Jam {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("input.txt"));
PrintWriter writer=new PrintWriter(new File("output.txt"));
int t=scan.nextInt();
int len=scan.nextInt();
int numjams=scan.nextInt();
System.out.println("Case #1:");
//iterate through possibilities, test if jamcoin,
int max=(int) Math.pow(2, len-2);
int jams=0;
for(int i=0;i<max && jams < numjams;i++){
String istring = Integer.toBinaryString(i);
istring = String.format("%"+String.valueOf(len-2)+"s", istring).replace(' ', '0');
istring="1"+istring+"1";
System.out.print(istring+" ");
for(int a=2;a<=10;a++){
System.out.print(convert(istring, a)+" ");
}
System.out.println();
int[] nums=out(istring);
System.out.println(Arrays.toString(nums));/*
if(IntStream.of(nums).anyMatch(x -> x == -1)){
continue;
}
System.out.print(istring+" ");
for(int el:nums){
System.out.print(el+" ");
}
System.out.println();
jams++;*/
}
}
public static int convert(String s, int base){
int num=0;
int len=s.length()-1;
if(len==0)
return Integer.parseInt(s);
if(s.substring(0, 1).equals("1"))
return (int)Math.pow(base, len)+convert(s.substring(1), base);
else
return convert(s.substring(1), base);
}
//input String ofones and zeros, output is integer array of length 9 with index i corresponding to the divisor of the input in base i+2
public static int[] out(String s){
int[] nums=new int[9];
for(int base=2;base<=10;base++){
int num=convert(s, base);
nums[base-2]=-1;
for(int x=2;x<=(int)(Math.sqrt(num))+1;x++){
if(num%x==0){
nums[base-2]=x;
break;
}
}
}
return nums;
}
public static boolean isDiv(String n){
int numdivisors=0;
for(int i=2;i<=10;i++){
int num=convert(n, i);
for(int x=2;x<=(int)(Math.sqrt(num))+1;x++){
if(num%i==0){
numdivisors++;
break;
}
}
}
if(numdivisors==9)
return true;
return false;
}
public static String divisors(String n){
String s="";
for(int i=2;i<=10;i++){
int num=convert(n, i);
for(int x=2;x<=(int)(Math.sqrt(num))+1;x++){
if(num%i==0){
s+=String.valueOf(x)+" ";
break;
}
}
}
return s;
}
//1001/
public static String binary_convert(int n, int len){
//return max power of 2 leq n
if(n==0){
String s="";
for(int i=0;i<len;i++)
s+="0";
return s;
}
if(n==1)
return binary_convert(0, len-1)+"1";
int b=(int)Math.floor(Math.log(n)/Math.log(2));
return "1"+binary_convert(n-(int)(Math.pow(2, b)), b);
}
// binary string --> int
public static int convertss(String s, int base){
int num=0;
int len=s.length()-1;
if(len==0)
return Integer.parseInt(s);
if(s.substring(0, 1).equals("1"))
return (int)Math.pow(base, len)+convert(s.substring(1), base);
else
return convert(s.substring(1), base);
}
public static String[] gen_bin_array(int len){
int n=(int) Math.pow(2, len-1);
String[] arr=new String[n];
for(int i=0; i < n; i++){
arr[i]=binary_convert(i+n, 10);
}
return arr;
}
}
================================================
FILE: GoogleCodeJam/Counting_Sheep.java
================================================
import java.io.*;
import java.util.*;
public class Counting_Sheep {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("A-small-practice.in.txt"));
PrintWriter writer=new PrintWriter(new File("countingsheep.out"));
int n=scan.nextInt();
for(int i=1;i<=n;i++){
int num=scan.nextInt();
boolean possible=true;
if(num==0){
possible=false;
}
String s="";
int mult=1;
while(possible){
s+=String.valueOf(num);
int con=0;
for(int j=0;j<10;j++){
if(s.contains(String.valueOf(j))){
con++;
}
}
mult++;
num*=mult;
num/=mult-1;
if(con==10)
break;
}
num*=mult-1;
num/=mult;
if(possible)
writer.printf("Case #%d: %d\n", i, num);
else
writer.printf("Case #%d: INSOMNIA\n", i);
}
writer.close();
}
}
================================================
FILE: GoogleCodeJam/CrossOver.java
================================================
import java.util.*;
import java.io.*;
public class CrossOver {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("output.txt"));
int n=scan.nextInt();
int[] stocks=new int[n];
double[] LTMA=new double[n+1];
double[] STMA=new double[n+1];
//instantiates with first 300 ints, and scans
int ltma_hash=0, stma_hash=0;
for(int i=1;i<=300;i++){
stocks[i-1]=scan.nextInt();
ltma_hash+=stocks[i-1];
if(i>=241)
stma_hash+=stocks[i-1];
}
LTMA[300]=Math.round(100.0*ltma_hash/300.0)/100.0;
STMA[300]=Math.round(100.0*stma_hash/60.0)/100.0;
for(int i=301;i<n;i++){
stocks[i-1]=scan.nextInt();
ltma_hash+=stocks[i-1];
stma_hash+=stocks[i-1];
ltma_hash-=stocks[i-301];
stma_hash-=stocks[i-61];
LTMA[i]=Math.round(100.0*(ltma_hash)/(300.0))/100.0;
STMA[i]=Math.round(100.0*(stma_hash)/(60.0))/100.0;
if((STMA[i-1] > LTMA[i-1] && STMA[i] <= LTMA[i]) || (STMA[i-1] < LTMA[i-1] && STMA[i] >= LTMA[i]) || (STMA[i-1] == LTMA[i-1] && STMA[i] != LTMA[i])){
System.out.println(i+" "+STMA[i]+" "+LTMA[i]);
}
}
}
}
================================================
FILE: GoogleCodeJam/Digits.java
================================================
import java.util.*;
import java.util.List;
import java.util.stream.Collectors;
import java.io.*;
import java.time.*;
import java.math.*;
import java.awt.*;
public class Digits {
public static void main(String[] args) throws Exception{
Scanner scan= new Scanner(new File("input.txt"));
PrintWriter writer=new PrintWriter(new File("output.txt"));
int numinputs=scan.nextInt();
scan.nextLine();
for(int cases=1;cases<=numinputs;cases++){
int[] nums=new int[10];
int[] removechar=new int[200];
char[] arr=scan.nextLine().toCharArray();
List<Character> list = new ArrayList<Character>();
for(char c : arr) {
if(c=='Z'){
nums[0]++;
removechar['Z']++;
removechar['E']++;
removechar['R']++;
removechar['O']++;
}
else if(c=='W'){
nums[2]++;
removechar['T']++;
removechar['W']++;
removechar['O']++;
}
else if(c=='U'){
nums[4]++;
removechar['F']++;
removechar['O']++;
removechar['U']++;
removechar['R']++;
}
else if(c=='X'){
nums[6]++;
removechar['S']++;
removechar['I']++;
removechar['X']++;
}
else if(c=='G'){
nums[8]++;
removechar['E']++;
removechar['I']++;
removechar['G']++;
removechar['H']++;
removechar['T']++;
}
list.add(c);
}
for(int i=0;i<list.size();i++){
char c=list.get(i);
if(removechar[c]>0){
list.remove(i);
removechar[c]--;
i--;
}
}
for(char c : list) {
if(c=='O'){
nums[1]++;
removechar['O']++;
removechar['N']++;
removechar['E']++;
}
else if(c=='H'){
nums[3]++;
removechar['T']++;
removechar['H']++;
removechar['R']++;
removechar['E']++;
removechar['E']++;
}
else if(c=='F'){
nums[5]++;
removechar['F']++;
removechar['I']++;
removechar['V']++;
removechar['E']++;
}
else if(c=='S'){
nums[7]++;
removechar['S']++;
removechar['E']++;
removechar['V']++;
removechar['E']++;
removechar['N']++;
}
}
for(int i=0;i<list.size();i++){
char c=list.get(i);
if(removechar[c]>0){
list.remove(i);
removechar[c]--;
i--;
}
}
for(char c : list) {
if(c=='I'){
nums[9]++;
}
}
String number="";
for(int n=0;n<nums.length;n++){
String x=String.join("", Collections.nCopies(nums[n], String.valueOf(n)));
number+=x;
}
//r1: z, zero; w, two, u, four; x, six, g, eight
//r2: o, one; h, three; f, five; s, seven
//r3: i, nine
String output="Case #"+cases+": "+number;
System.out.println(output);
writer.println(output);
}
scan.close();
writer.close();
}
}
================================================
FILE: GoogleCodeJam/Oversized_Pancake_Flipper.java
================================================
import java.io.*;
import java.util.*;
public class Oversized_Pancake_Flipper {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("pancakes.in"));
PrintWriter writer=new PrintWriter(new File("pancakes.txt"));
int n=scan.nextInt();
scan.nextLine();
for(int asdf=1;asdf<=n;asdf++){
String[] line=scan.nextLine().split(" ");
String pancake=line[0];
int size=Integer.parseInt(line[1]);
boolean[] row=new boolean[pancake.length()];
for(int i=0;i<row.length;i++){
row[i]=(pancake.substring(i, i+1).equals("+"));
}
int maxstartflip=row.length-size;
int numflips=0;
/*--------------------------------------------------------------------------
* parses input to boolean[] row containing pancake in booleans
*--------------------------------------------------------------------------*/
if(maxstartflip < size){
HashSet<Boolean> set1=new HashSet<Boolean>();
for(int iterator=maxstartflip;iterator<size;iterator++){
set1.add(row[iterator]);
}
if(set1.contains(true) && set1.contains(false)){
System.out.printf("Case #%d: IMPOSSIBLE\n", asdf);
writer.printf("Case #%d: IMPOSSIBLE\n", asdf);
continue;
}
}
/*--------------------------------------------------------------------------
* tests impossibility with intersection of sets
*--------------------------------------------------------------------------*/
boolean impossible=false;
/////////
while(indexOf(row, false)>=0){
int i=indexOf(row, false);
if(i > maxstartflip){
i=maxstartflip;
}
row=flip(i, size, row);
numflips++;
if(numflips > row.length){
impossible=true;
break;
}
}
if(impossible){
System.out.printf("Case #%d: IMPOSSIBLE\n", asdf);
writer.printf("Case #%d: IMPOSSIBLE\n", asdf);
continue;
}
System.out.printf("Case #%d: %d\n", asdf, numflips);
writer.printf("Case #%d: %d\n", asdf, numflips);
}
scan.close();
writer.close();
}
public static boolean[] flip(int start, int size, boolean[] pancakes){
for(int i=0;i<size;i++)
pancakes[i+start]=!pancakes[i+start];
return pancakes;
}
public static int indexOf(boolean[] pancake, boolean element){
for(int i=0;i<pancake.length;i++){
if(pancake[i]==element)
return i;
}
return -1;
}
/*public static int containsthree(int size, boolean[] pancakes){
int numconsec=0;
int start=0;
for(int i=0;i<=pancakes.length-size;i++){
}
}*/
}
================================================
FILE: GoogleCodeJam/Pancakes.java
================================================
import java.io.*;
import java.util.*;
public class Pancakes {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("A-small-practice.in.txt"));
PrintWriter writer=new PrintWriter(new File("countingsheep.out"));
int n=scan.nextInt();
for(int i=1;i<=n;i++){
}
writer.close();
}
}
================================================
FILE: GoogleCodeJam/Prison_Break.java
================================================
import java.io.*;
import java.util.*;
public class Prison_Break {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(System.in);
int n=scan.nextInt();
int m=scan.nextInt();
//intialize prizon 2d arraylist
ArrayList<ArrayList<Integer>> prison=new ArrayList<ArrayList<Integer>>();
for(int r=0;r<=n;r++){
ArrayList<Integer> temp=new ArrayList<Integer>();
for(int c=0;c<=m;c++){
temp.add( 1);
}
prison.add(temp);
}
//horizontal merging
int xnum=scan.nextInt();
int[] x=new int[xnum];
for(int i=0;i<xnum;i++)
x[i]=scan.nextInt();
Arrays.sort(x);
//vertical merging
int ynum=scan.nextInt();
int[] y=new int[ynum];
for(int i=0;i<ynum;i++)
y[i]=scan.nextInt();
Arrays.sort(y);
//removing bar i means that list at i-1 and at i
for(int a=xnum-1;a>=0;a--){
int i=x[a];
for(int cell=0;cell<prison.get(i).size();cell++){
prison.get(i).set(cell, prison.get(i).get(cell)+prison.get(i-1).get(cell));
}
prison.remove(i-1);
}
ArrayList<ArrayList<Integer>> newprison =new ArrayList<ArrayList<Integer>>();
//3 3 3 ---> 3 1
//1 1 1 ---> 3 1
// 3 1
for(int col=0;col<prison.get(0).size();col++){
ArrayList<Integer> temp=new ArrayList<Integer>();
for(int row=0;row<prison.size();row++){
temp.add(prison.get(row).get(col));
}
newprison.add(temp);
}
for(int b=ynum-1;b>=0;b--){
int i=y[b];
for(int cell=0;cell<newprison.get(i).size();cell++){
newprison.get(i).set(cell, newprison.get(i).get(cell)+newprison.get(i-1).get(cell));
}
newprison.remove(i-1);
}
int max=1;
for(ArrayList<Integer> arr:newprison){
for(int num:arr){
if(num>max)
max=num;
}
}
System.out.println(max);
}
}
================================================
FILE: GoogleCodeJam/README.md
================================================
# Google Code Jam Problems
================================================
FILE: GoogleCodeJam/Solution.java
================================================
import java.io.*;
import java.util.*;
import java.text.*;
import java.math.*;
import java.util.regex.*;
public class Solution {
static long prison(int n, int m, int[] h, int[] v) {
ArrayList<ArrayList<Long>> prison=new ArrayList<ArrayList<Long>>();
for(int r=0;r<=n;r++){
ArrayList<Long> temp=new ArrayList<Long>();
for(int c=0;c<=m;c++){
temp.add((long) 1);
}
prison.add(temp);
}
int[] x=h;
int xnum=x.length;
Arrays.sort(x);
int[] y=v;
int ynum=y.length;
Arrays.sort(y);
//removing bar i means that list at i-1 and at i
for(int a=xnum-1;a>=0;a--){
int i=x[a];
for(int cell=0;cell<prison.get(i).size();cell++){
prison.get(i).set(cell, prison.get(i).get(cell)+prison.get(i-1).get(cell));
}
prison.remove(i-1);
}
ArrayList<ArrayList<Long>> newprison =new ArrayList<ArrayList<Long>>();
for(int col=0;col<prison.get(0).size();col++){
ArrayList<Long> temp=new ArrayList<Long>();
for(int row=0;row<prison.size();row++){
temp.add(prison.get(row).get(col));
}
newprison.add(temp);
}
for(int b=ynum-1;b>=0;b--){
int i=y[b];
for(int cell=0;cell<newprison.get(i).size();cell++){
newprison.get(i).set(cell, newprison.get(i).get(cell)+newprison.get(i-1).get(cell));
}
newprison.remove(i-1);
}
long max=1;
for(ArrayList<Long> arr:newprison){
for(long num:arr){
if(num>max)
max=num;
}
}
return max;
}
public static void main(String[] args) throws IOException{
Scanner in = new Scanner(System.in);
final String fileName = System.getenv("OUTPUT_PATH");
BufferedWriter bw = new BufferedWriter(new FileWriter(fileName));
long res;
int _n;
_n = Integer.parseInt(in.nextLine().trim());
int _m;
_m = Integer.parseInt(in.nextLine().trim());
int _h_size = 0;
_h_size = Integer.parseInt(in.nextLine().trim());
int[] _h = new int[_h_size];
int _h_item;
for(int _h_i = 0; _h_i < _h_size; _h_i++) {
_h_item = Integer.parseInt(in.nextLine().trim());
_h[_h_i] = _h_item;
}
int _v_size = 0;
_v_size = Integer.parseInt(in.nextLine().trim());
int[] _v = new int[_v_size];
int _v_item;
for(int _v_i = 0; _v_i < _v_size; _v_i++) {
_v_item = Integer.parseInt(in.nextLine().trim());
_v[_v_i] = _v_item;
}
res = prison(_n, _m, _h, _v);
bw.write(String.valueOf(res));
bw.newLine();
bw.close();
}
}
================================================
FILE: GoogleCodeJam/Super_Substrings.java
================================================
import java.io.File;
import java.util.*;
public class Super_Substrings {
public static void main(String[] args) throws Exception{
Scanner scan=new Scanner(new File("input.txt"));
String n=scan.next();
ArrayList<String> subs=new ArrayList<String>();
for(int i=0;i<n.length();i++){
for(int j=i+1;j<=n.length();j++){
subs.add(n.substring(i, j));
}
}
int count=0;
for(String s:subs){
int num=Integer.parseInt(s);
if(num%6==0 && String.valueOf(num).length()==s.length()){
count++;
}
}
System.out.println(count);
}
public static int sum(int num){
int sum=0;
while (num > 0) {
sum+=num % 10;
num/=10;
}
return sum;
}
}
================================================
FILE: GoogleCodeJam/Tidy_Numbers.java
================================================
import java.util.*;
import java.io.*;
public class Tidy_Numbers {
public static void main(String[] args) throws Exception {
Scanner scan=new Scanner(new File("tidy.in"));
PrintWriter writer=new PrintWriter(new File("output.txt"));
int n=scan.nextInt();
scan.nextLine();
for(int asdf=1;asdf<=n;asdf++){
String num=scan.nextLine();
System.out.println(num);
long nu=Long.parseLong(num);
String tidy;
int i=(int) nu;
while(true){
if(num.contains("0")){
tidy=nines(num);
break;
}
int tid=isTidy(i);
if(tid<0){
tidy=String.valueOf(i);
break;
}
System.out.println(tid);
String str=String.valueOf(i);
String decrement=String.valueOf(Integer.parseInt(str.substring(tid, tid+1))-1);
String len=new String(new char[str.length()-tid-1]).replace("\0", "9");
i=(int) Long.parseLong(str.substring(0, tid)+decrement+len);
}
//parse String
long indignation=Long.parseLong(tidy);
String a="Case #"+asdf+": "+indignation;
System.out.println(a);
writer.println(a);
}
writer.close();
scan.close();
}
//return -1 if tidy or i >=0 where char[i] > char[i+1]
public static int isTidy(long n){
String num=String.valueOf(n);
for(int i=0;i<num.length()-1;i++){
if(Integer.valueOf(num.substring(i, i+1)) > Integer.valueOf(num.substring(i+1, i+2))){
return i;
}
}
return -1;
}
//returns sequence of 9s less than int
public static String nines(String n){
return new String(new char[n.length()-1]).replace("\0", "9");
}
}
================================================
FILE: Graph/BFS.java
================================================
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Paint;
import java.awt.Stroke;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class BFS {
/*Breadth-First Search (BFS)
Problem (informal): Given starting node, traverse a graph by looking at closer nodes before further ones
Algorithm: While nodes at depth d from root are unvisited, visit them, increment d
Complexity:
* Time - O(|V| + |E|) where V is set of vertices and E is set of edges
* Space - O(|V|) to store visited vertices
Functions Defined:
* QueueBFSList() - Queue-based implementation with adjacency list input
* QueueBFSMatrix - Queue-based implementation with adjacency matrix input
* IterativeBFSList() - Loop-based implementation with adjacency list input
* IterativeBFSMatrix() - Loop-based implementation with adjacency matrix input
* mat2list() - Takes adjacency matrix input and returns equivalent adjacency list
* list2mat() - Takes adjacency list input and returns equivalent adjacency matrix
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
Notes:
* IterativeBFS runs 3-4x faster than QueueBFS in practice (on average)
*/
public static void main(String[] args) {
boolean[][] adjmat={/*1*/ {true, true, true, true, false, false, false, false, false},
/*2*/ {true, false, true, false, true, true, false, false, false},
/*3*/ {true, true, false, true, false, true, true, false, false},
/*4*/ {true, false, true, false, false, false, true, false, false},
/*5*/ {false, true, false, false, false, true, false, true, false},
/*6*/ {false, true, true, false, true, false, true, true, false},
/*7*/ {false, false, true, true, false, true, false, true, false},
/*8*/ {false, false, false, false, true, true, true, false, false},
/*9*/ {false, false, false, false, false, false, false, false, false}};
ArrayList<ArrayList<Integer>> adjlist=mat2list(adjmat);
//Starting node
int root=5;
//Prints BFT for graph
//Queue or iterative BFS with input of List/Matrix
System.out.println(QueueBFSList(adjlist, 1).toString());
//Uncomment next line to visualize graph
//display(adj, "Graph");
}
//Queue based implementation (CLRS)
public static ArrayList<Integer> QueueBFSList(ArrayList<ArrayList<Integer>> adjlist, int source){
//BFT maintains list of nodes that havee already been visited (colored black)
//q maintains list of nodes that are scheduled to be visited
boolean[] visited = new boolean[adjlist.size()+1];
Queue<Integer> q=new LinkedList<Integer>();
q.add(source);
visited[source] = true;
ArrayList<Integer> bft = new ArrayList<Integer>();
while(!q.isEmpty()){
int top=q.poll();
bft.add(top);
visited[top] = true;
for(int node:adjlist.get(top-1))
if(!visited[node]){
q.add(node);
visited[node] = true;
}
}
return bft;
}
//3-4x faster implementation on avg!!!
public static ArrayList<Integer> IterativeBFSList(ArrayList<ArrayList<Integer>> adjlist, int source){
boolean[] visited = new boolean[adjlist.size()+1];
ArrayList<Integer> bft=new ArrayList<Integer>();
bft.add(source);
visited[source] = true;
int nodesReached=1;
while(nodesReached<adjlist.size()-1){
for(int i=0;i<bft.size();i++){
for(int neighbor:adjlist.get(bft.get(i)-1)){
if(!visited[neighbor]){
bft.add(neighbor);
visited[neighbor] = true;
nodesReached++;
}
}
}
}
return bft;
}
//Queue based (CLRS) BFS [adjacency matrix input]
public static ArrayList<Integer> QueueBFSMatrix(boolean[][] adjmat, int source){
ArrayList<Integer> bft = new ArrayList<Integer>();
boolean[] visited = new boolean[adjmat.length+1];
Queue<Integer> q=new LinkedList<Integer>();
q.add(source);
visited[source] = true;
while(!q.isEmpty()){
int top=q.poll();
bft.add(top);
visited[top] = true;
for(int node=1; node <= adjmat.length; node++){
boolean[] adj = adjmat[top-1];
if(adj[node-1] && !visited[node]){
q.add(node);
visited[node] = true;
}
}
}
return bft;
}
//Iterative BFS [adjacency matrix input]
public static ArrayList<Integer> IterativeBFSMatrix(boolean[][] adjmat, int source){
ArrayList<Integer> bft=new ArrayList<Integer>();
boolean[] visited = new boolean[adjmat.length+1];
bft.add(source);
visited[source] = true;
int nodesReached=1;
while(nodesReached<adjmat.length-1){
for(int i=0;i<bft.size();i++){
for(int node=1; node <= adjmat.length; node++){
boolean[] adj = adjmat[bft.get(i)-1];
if(adj[node-1] && !visited[node]){
bft.add(node);
visited[node] = true;
nodesReached++;
}
}
}
}
return bft;
}
//converts adjacency matrix to adjacency list
public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
ArrayList<ArrayList<Integer>> adjlist=new ArrayList<ArrayList<Integer>>();
for(int i=0;i<adj.length;i++){
adjlist.add(new ArrayList<Integer>());
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
adjlist.get(i).add(j+1);
}
}
return adjlist;
}
//Converts adjacency list to adjacency matrix
public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjlist){
boolean[][] adjmat = new boolean[adjlist.size()][adjlist.size()];
for(int i=0;i<adjmat.length;i++){
for(int adj : adjlist.get(i)){
adjmat[i][adj-1] = true;
}
}
return adjmat;
}
//adjmat
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
}
================================================
FILE: Graph/Bellman_Ford.java
================================================
import java.awt.*;
import java.util.*;
import java.util.Queue;
import java.util.stream.Collectors;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Bellman_Ford {
/*Bellman-Ford Algorithm
Problem (informal): Given a weighted graph G, source u and sink v, find minimally weighted u~v path in G
Algorithm: Iterates over all vertices and edges and relaxes edges
Complexity:
* Time - O(|V|*|E|) since main loop iterates over all vertices and edges
* Space - O(|V| + |E|) to store edges and vertices
Functions Defined:
* bellman_ford() - Main algorithm to return shortest path or Integer.MIN_VALUE if negative cycle exists
* Vertex() - Custom class to store weighted graphs
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
*/
public static void main(String[] args) {
//Initializing and filling sample array
ArrayList<Vertex>[] adjlist= new ArrayList[5];
adjlist[1] = new ArrayList<Vertex>();
adjlist[2] = new ArrayList<Vertex>();
adjlist[3] = new ArrayList<Vertex>();
adjlist[4] = new ArrayList<Vertex>();
adjlist[1].add(new Vertex(2, -1)); adjlist[1].add(new Vertex(3, 3));
adjlist[2].add(new Vertex(3, 1)); adjlist[2].add(new Vertex(4, 5)); adjlist[2].add(new Vertex(4, -3));
adjlist[3].add(new Vertex(4, 2));
adjlist[4].add(new Vertex(1, 10));
//Starting node
int source = 1;
//Ending node
int dest = 4;
System.out.print(bellman_ford(adjlist, source, dest));
//Uncomment next line to visualize graph (need to convert to array first
//display(adj, "Graph");
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to destination
public static int bellman_ford(ArrayList<Vertex>[] adjlist, int source, int dest){
boolean[] visited = new boolean[adjlist.length];
int[] distance = new int[adjlist.length];
int[] prev = new int[adjlist.length];
Arrays.fill(distance, Integer.MAX_VALUE);
distance[1] = 0;
for(int ver=1;ver<adjlist.length;ver++){ //iterates over all vertices
for(int i=1;i<adjlist.length;i++){ //iterates over all edges
for(Vertex neighbor:adjlist[i]){
if(distance[i] + neighbor.weight < distance[neighbor.val]){
distance[neighbor.val] = distance[i] + neighbor.weight;
prev[neighbor.val] = i;
}
}
}
}
for(int i=1;i<adjlist.length;i++){ //iterates over all edges
for(Vertex neighbor:adjlist[i]){
if(distance[neighbor.val] > neighbor.weight + distance[i])
return Integer.MIN_VALUE; //Negative cycle exists
}
}
return distance[dest];
}
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
//defined Vertex class for weighted graphs to hold edge weights
static class Vertex{
public int val;
public int weight;
public Vertex(int val){
this.val = val;
}
public Vertex(int val, int weight){
this.val = val;
this.weight = weight;
}
public String toString(){
return "Val: "+val+", Weight: "+weight;
}
}
public static int[] list2arr(ArrayList<Integer> list){
return list.stream().mapToInt(i->i).toArray();
}
public static ArrayList<Integer> list2arr(int[] arr){
return (ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
}
}
================================================
FILE: Graph/DFS.java
================================================
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Paint;
import java.awt.Stroke;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Stack;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class DFS {
/*Depth-First Search (DFS)
Problem (informal): Given starting node, traverse a graph by looking at deeper nodes before closer ones
Algorithm: Continue down branch as far as possible, visit deepest unvisited node, backtrack
Complexity:
* Time - O(|V| + |E|) where V is set of vertices and E is set of edges
* Space - O(|V|) to store visited vertices
Functions Defined:
* iterativeDFS() - Iterative stack-based implementation of DFS
* recursiveDFS - Recursive implementation of DFS (calls DFS on unvisited children)
* mat2list() - Takes adjacency matrix input and returns equivalent adjacency list
* list2mat() - Takes adjacency list input and returns equivalent adjacency matrix
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
*/
public static void main(String[] args) {
boolean[][] adjmat={/*1*/ {true, true, true, true, false, false, false, false, false},
/*2*/ {true, false, true, false, true, true, false, false, false},
/*3*/ {true, true, false, true, false, true, true, false, false},
/*4*/ {true, false, true, false, false, false, true, false, false},
/*5*/ {false, true, false, false, false, true, false, true, false},
/*6*/ {false, true, true, false, true, false, true, true, false},
/*7*/ {false, false, true, true, false, true, false, true, false},
/*8*/ {false, false, false, false, true, true, true, false, false},
/*9*/ {false, false, false, false, false, false, false, false, false}};
ArrayList<ArrayList<Integer>> adjlist=mat2list(adjmat);
//Starting node
int root=5;
//Prints DFT for graph
//Recursive or iterative DFS
recursiveDFS(adjlist, root, new boolean[adjlist.size()+1]);
System.out.println(iterativeDFS(adjlist, root));
//Uncomment next line to visualize graph
//display(adjmat, "Graph");
}
//Iterative implementation of DFS
public static ArrayList<Integer> iterativeDFS(ArrayList<ArrayList<Integer>> adjlist, int source){
boolean[] visited = new boolean[adjlist.size()+1];
Stack<Integer> stack=new Stack<Integer>();
stack.add(source);
visited[source] = true;
ArrayList<Integer> dft = new ArrayList<Integer>();
while(!stack.isEmpty()){
int top=stack.peek();
stack.pop();
if(!visited[top]){
dft.add(top);
visited[top] = true;
}
for(int node:adjlist.get(top-1))
if(!visited[node]){
stack.push(node);
}
}
return dft;
}
//Recursive implementation of DFS
public static void recursiveDFS(ArrayList<ArrayList<Integer>> adjlist, int node, boolean[] visited){
visited[node] = true;
//System.out.println(node);
for(int child:adjlist.get(node)){
if(!visited[child]){
recursiveDFS(adjlist, child, visited);
}
}
}
//converts adjacency matrix to adjacency list
public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
ArrayList<ArrayList<Integer>> adjlist=new ArrayList<ArrayList<Integer>>();
for(int i=0;i<adj.length;i++){
adjlist.add(new ArrayList<Integer>());
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
adjlist.get(i).add(j+1);
}
}
return adjlist;
}
//Converts adjacency list to adjacency matrix
public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjlist){
boolean[][] adjmat = new boolean[adjlist.size()][adjlist.size()];
for(int i=0;i<adjmat.length;i++){
for(int adj : adjlist.get(i)){
adjmat[i][adj-1] = true;
}
}
return adjmat;
}
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
}
================================================
FILE: Graph/Dijkstra.java
================================================
import java.awt.*;
import java.util.*;
import java.util.Queue;
import java.util.stream.Collectors;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Dijkstra {
/*Dijkstra's Algorithm
Problem (informal): Given a weighted graph G, source u and sink v, find minimally weighted u~v path in G
Algorithm: BFS with priority queue; maintains distance to certain node and updates along with previous
Complexity:
* Time - O(|E|log|V|) where V is set of vertices and E is set of edges
* Space - O(|V|) to store visited vertices
Functions Defined:
* dijkstra() - Main algorithm to return shortest path between source and destination
* Vertex() - Custom class to store weighted graphs
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
Notes:
* IterativeBFS runs 3-4x faster than QueueBFS in practice (on average)
*/
public static void main(String[] args) {
///*
//Initializing and filling sample array
ArrayList<Vertex>[] adjlist= new ArrayList[5];
adjlist[1] = new ArrayList<Vertex>();
adjlist[2] = new ArrayList<Vertex>();
adjlist[3] = new ArrayList<Vertex>();
adjlist[4] = new ArrayList<Vertex>();
adjlist[1].add(new Vertex(2, 1)); adjlist[1].add(new Vertex(3, 3));
adjlist[2].add(new Vertex(3, 1)); adjlist[2].add(new Vertex(4, 2)); adjlist[2].add(new Vertex(4, 1));
adjlist[3].add(new Vertex(4, 2));
adjlist[4].add(new Vertex(1, 4));
//Starting node
int source = 1;
//Ending node
int dest = 4;
///*
/*
ArrayList<Vertex>[] adjlist= new ArrayList[4];
adjlist[1] = new ArrayList<Vertex>();
adjlist[2] = new ArrayList<Vertex>();
adjlist[3] = new ArrayList<Vertex>();
adjlist[1].add(new Vertex(2, 5)); adjlist[1].add(new Vertex(3, 2));
adjlist[2].add(new Vertex(3, -10));
//Starting node
int source = 1;
//Ending node
int dest = 3;
*/
System.out.print(dijkstra(adjlist, source, dest));
//Uncomment next line to visualize graph (need to convert to array first
//display(adj, "Graph");
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to destination
public static ArrayList<Integer> dijkstra(ArrayList<Vertex>[] adjlist, int source, int destination){
boolean[] visited = new boolean[adjlist.length];
int[] distance = new int[adjlist.length];
int[] prev = new int[adjlist.length];
Arrays.fill(distance, Integer.MAX_VALUE);
PriorityQueue<Vertex> q=new PriorityQueue<Vertex>();
q.add(new Vertex(source, 0));
distance[source] = 0;
visited[source] = true;
ArrayList<Vertex> bft = new ArrayList<Vertex>();
while(!q.isEmpty()){
int top=q.poll().name;
visited[top] = true;
for(Vertex node:adjlist[top]){
if(q.contains(node.name)) continue; //Saves lots of time
if(distance[top] + node.val < distance[node.name]){
prev[node.name] = top;
distance[node.name] = distance[top] + node.val;
}
if(!visited[node.name]){
q.add(new Vertex(node.name, distance[node.name]));
visited[node.name] = true;
}
}
}
ArrayList<Integer> path = new ArrayList<Integer>();
path.add(source);
int current = destination;
while(current != source){
path.add(1, current);
current = prev[current];
}
return path;
}
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
//defined Vertex class for weighted graphs to hold edge weights
static class Vertex implements Comparable<Vertex>{
public int name;
public int val;
public Vertex(int name){
this.name = name;
}
public Vertex(int name, int val){
this.name = name;
this.val = val;
}
public String toString(){
return "Name: "+name+", Value: "+val;
}
public int compareTo(Vertex v){
return Integer.compare(val, v.val);
}
}
public static int[] list2arr(ArrayList<Integer> list){
return list.stream().mapToInt(i->i).toArray();
}
public static ArrayList<Integer> list2arr(int[] arr){
return (ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
}
}
================================================
FILE: Graph/Edge.java
================================================
public class Edge {
//Edge class with built in functions; used for Graph class
private int weight;
private Vertex v1;
private Vertex v2;
private boolean directed=false;
public Edge(int weight, int value1, int value2){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
}
public Edge(int weight, int value1, int value2, boolean directed){
this.weight=weight;
v1=new Vertex(value1);
v2=new Vertex(value2);
directed=true;
}
//returns whether or not the edge is incident to the input vertex
public boolean incident(int vertex){
return vertex==v1.getValue() || vertex==v2.getValue();
}
public Vertex getVertex1(){
return v1;
}
public Vertex getVertex2(){
return v2;
}
public int getWeight(){
return weight;
}
public boolean getDirected(){
return directed;
}
public void makeDirected(){
directed=true;
}
public void swap(){
Vertex temp=v2;
v2=v1;
v1=temp;
}
public String toString(){
return weight+"["+v1+","+v2+"]";
}
}
================================================
FILE: Graph/Floyd_Warshall.java
================================================
import java.awt.*;
import java.util.*;
import java.util.Queue;
import java.util.stream.Collectors;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Floyd_Warshall {
/*Floyd-Warshall Algorithm
Problem (informal): Given a weighted graph G, source u and sink v, find minimally weighted u~v path in G
Algorithm: BFS with priority queue; maintains distance to certain node and updates along with previous
Complexity:
* Time - O(|V|^2) where V is set of vertices and E is set of edges
* Space - O(|V|) to store visited vertices
Functions Defined:
* floyd_warshall() - Main algorithm to return all pairs shortest path
* Vertex() - Custom class to store weighted graphs
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
Notes:
* IterativeBFS runs 3-4x faster than QueueBFS in practice (on average)
*/
public static void main(String[] args) {
//Initializing and filling sample array
ArrayList<Vertex>[] adjlist= new ArrayList[5];
adjlist[1] = new ArrayList<Vertex>();
adjlist[2] = new ArrayList<Vertex>();
adjlist[3] = new ArrayList<Vertex>();
adjlist[4] = new ArrayList<Vertex>();
adjlist[1].add(new Vertex(2, 1)); adjlist[1].add(new Vertex(3, 3));
adjlist[2].add(new Vertex(3, 1)); adjlist[2].add(new Vertex(4, 2)); adjlist[2].add(new Vertex(4, 1));
adjlist[3].add(new Vertex(4, 2));
adjlist[4].add(new Vertex(1, 4));
//Starting node
int source = 1;
//Ending node
int dest = 4;
System.out.print(floyd_warshall(adjlist, source, dest));
//Uncomment next line to visualize graph (need to convert to array first
//display(adj, "Graph");
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to destination
public static ArrayList<Integer> floyd_warshall(ArrayList<Vertex>[] adjlist, int source, int destination){
boolean[] visited = new boolean[adjlist.length];
int[] distance = new int[adjlist.length];
int[] prev = new int[adjlist.length];
Arrays.fill(distance, Integer.MAX_VALUE);
PriorityQueue<Integer> q=new PriorityQueue<Integer>();
q.add(source);
distance[source] = 0;
visited[source] = true;
ArrayList<Vertex> bft = new ArrayList<Vertex>();
while(!q.isEmpty()){
int top=q.poll();
visited[top] = true;
for(Vertex node:adjlist[top]){
if(distance[top] + node.val < distance[node.name]){
prev[node.name] = top;
distance[node.name] = distance[top] + node.val;
}
if(!visited[node.name]){
q.add(node.name);
visited[node.name] = true;
}
}
}
ArrayList<Integer> path = new ArrayList<Integer>();
path.add(source);
int current = destination;
while(current != source){
path.add(1, current);
current = prev[current];
}
return path;
}
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
//defined Vertex class for weighted graphs to hold edge weights
static class Vertex{
public int name;
public int val;
public Vertex(int name){
this.name = name;
}
public Vertex(int name, int val){
this.name = name;
this.val = val;
}
public String toString(){
return "Name: "+name+", Value: "+val;
}
}
public static int[] list2arr(ArrayList<Integer> list){
return list.stream().mapToInt(i->i).toArray();
}
public static ArrayList<Integer> list2arr(int[] arr){
return (ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
}
}
================================================
FILE: Graph/Ford_Fulkerson.java
================================================
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Paint;
import java.awt.Stroke;
import java.util.*;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Ford_Fulkerson {
/*Ford-Fulkerson
Problem (informal): Given a network, find maximum flow from source to sink
Algorithm: Send one unit of flow, look at residual network, find augmenting path
Complexity:
* Time - O(E*f) where E is the number of edges and f is the max flow
* Space - O(|V|^2) to store graph in adjacency matrix
Functions Defined:
* bfs() - returns breath first search sequence
* dfs() - returns depth first search sequence
* residual() - returns residual network given current network and new flow
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
*/
public static void main(String[] args){
int[][] network={{0, 16, 13, 0, 0, 0},
{0, 0, 0, 12, 0, 0},
{0, 4, 0, 0, 14, 0},
{0, 0, 9, 0, 0, 20},
{0, 0, 0, 7, 0, 5},
{0, 0, 0, 0, 0, 0}};
int size=network.length;
int[][] flow=new int[size][size];
for(int u=0;u<flow.length;u++){
for(int v=0;v<flow.length;v++){
flow[u][v]=0;
}
}
ArrayList<Integer> path=new ArrayList<Integer>();
int maxflow=0;
path=dfs(residual(network, flow));
while(path.get(0)!=-1){
for(int i=0;i<path.size()-1;i++){
int u=path.get(i);
int v=path.get(i+1);
if(network[u][v]>0)
flow[u][v]++;
else if(network[v][u]>0)
flow[u][v]--;
if(flow[u][v]<0)
flow[u][v]=1;
}
maxflow++;
try{
path=dfs(residual(network, flow));
} catch(Exception e){
break;
}
}
System.out.println(maxflow+"\n\n");
for(int[] flo:flow){
System.out.println(Arrays.toString(flo));
}
display(network, "graph");
}
public static int[] bfs(int[][] residual)
{
int vertices=residual.length;
int[] parent=new int[vertices];
boolean visited[] = new boolean[vertices];
Arrays.fill(visited, false);
LinkedList<Integer> queue = new LinkedList<Integer>();
queue.add(0);
visited[0] = true;
parent[0]=-1;
parent[vertices-1]=-1;
while (queue.size()!=0)
{
int u = queue.poll();
for (int v=0; v<vertices; v++)
{
if (visited[v]==false && residual[u][v] > 0)
{
queue.add(v);
parent[v] = u;
visited[v] = true;
}
}
}
return parent;
}
public static ArrayList<Integer> dfs(int[][] residual){
int size=residual.length;
boolean[] visited=new boolean[size];
Arrays.fill(visited, false);
ArrayList<Integer> path=new ArrayList<Integer>();
path.add(0);
while(!visited[size-1]){
for(int u=0;u<size;u++){
if(residual[path.get(path.size()-1)][u]>0 && !visited[u]){
path.add(u);
visited[u]=true;
u=0;
continue;
}
}
if(path.get(path.size()-1)==(size-1)){
return path;
}
path.remove(path.size()-1);
}
if(visited[size-1]){
return path;
}
path.set(0, -1);
return path;
}
public static int[][] residual(int[][] network, int[][] flow){
int[][] residual=new int[network.length][network.length];
for(int u=0;u<flow.length;u++){
for(int v=0;v<flow.length;v++){
if(network[u][v]>0)
residual[u][v]=network[u][v]-flow[u][v];
else if(network[v][u]>0)
residual[u][v]=flow[v][u];
else
residual[u][v]=0;
}
}
return residual;
}
public static void display(int[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j]>0)
graph.addEdge(adj[i][j], i, j, EdgeType.DIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
}
================================================
FILE: Graph/Graph_Traversal.java
================================================
import java.awt.BasicStroke;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Paint;
import java.awt.Stroke;
import java.util.*;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Graph_Traversal {
//Collection of graph searching implementations (BFS/DFS) for benchmarking
public static void main(String[] args) {
ArrayList<ArrayList<Integer>> adjlist = new ArrayList<ArrayList<Integer>>() {{
add(new ArrayList<Integer>() {{
add(2);
add(3);
add(4);
}});
add(new ArrayList<Integer>() {{
add(1);
add(3);
add(5);
add(6);
}});
add(new ArrayList<Integer>() {{
add(1);
add(2);
add(4);
add(6);
add(7);
}});
add(new ArrayList<Integer>() {{
add(1);
add(3);
add(7);
}});
add(new ArrayList<Integer>() {{
add(2);
add(6);
add(8);
}});
add(new ArrayList<Integer>() {{
add(2);
add(3);
add(5);
add(7);
add(8);
}});
add(new ArrayList<Integer>() {{
add(3);
add(4);
add(6);
add(8);
}});
add(new ArrayList<Integer>() {{
add(5);
add(6);
add(7);
}});
}};
boolean[][] adj={/*1*/ {false, true, true, true, false, false, false, false},
/*2*/ {true, false, true, false, true, true, false, false},
/*3*/ {true, true, false, true, false, true, true, false},
/*4*/ {true, false, true, false, false, false, true, false},
/*5*/ {false, true, false, false, false, true, false, true},
/*6*/ {false, true, true, false, true, false, true, true},
/*7*/ {false, false, true, true, false, true, false, true},
/*8*/ {false, false, false, false, true, true, true, false}};
boolean[][] adj1={/*1*/ {false, true, true, true, false, false, false, false},
/*2*/ {false, false, true, false, true, true, false, false},
/*3*/ {false, false, false, true, false, true, false, false},
/*4*/ {false, false, false, false, false, false, true, false},
/*5*/ {false, false, false, false, false, true, false, true},
/*6*/ {false, false, false, false, false, false, true, true},
/*7*/ {false, false, true, false, false, false, false, true},
/*8*/ {false, false, false, false, false, false, false, false}};
int root=6;
long start;
System.out.println(bfsmatrix(adj, root));
display(adj1, "");
}
//Iterative implementation of DFS
public static ArrayList<Integer> iterativeDFS(ArrayList<ArrayList<Integer>> adjlist, int source){
boolean[] visited = new boolean[adjlist.size()+1];
Stack<Integer> stack=new Stack<Integer>();
stack.add(source);
visited[source] = true;
ArrayList<Integer> dft = new ArrayList<Integer>();
while(!stack.isEmpty()){
int top=stack.peek();
stack.pop();
if(!visited[top]){
dft.add(top);
visited[top] = true;
}
for(int node:adjlist.get(top-1))
if(!visited[node]){
stack.push(node);
}
}
return dft;
}
//Recursive implementation of DFS
public static void recursiveDFS(ArrayList<ArrayList<Integer>> adjlist, int node, boolean[] visited){
visited[node] = true;
//System.out.println(node);
for(int child:adjlist.get(node)){
if(!visited[child]){
recursiveDFS(adjlist, child, visited);
}
}
}
//Queue based implementation
public static ArrayList<Integer> bfs(ArrayList<ArrayList<Integer>> adjlist, int source){
//BFT maintains list of nodes that havee already been visited (colored black)
//q maintains list of nodes that are scheduled to be visited
boolean[] visited = new boolean[adjlist.size()+1];
Queue<Integer> q=new LinkedList<Integer>();
q.add(source);
visited[source] = true;
ArrayList<Integer> bft = new ArrayList<Integer>();
while(!q.isEmpty()){
int top=q.poll();
bft.add(top);
visited[top] = true;
for(int node:adjlist.get(top-1))
if(!visited[node]){
q.add(node);
visited[node] = true;
}
}
return bft;
}
//3-4x faster implementation on avg
public static ArrayList<Integer> BFS(ArrayList<ArrayList<Integer>> adjlist, int source){
boolean[] visited = new boolean[adjlist.size()+1];
ArrayList<Integer> bft=new ArrayList<Integer>();
bft.add(source);
visited[source] = true;
int nodesReached=1;
while(nodesReached<adjlist.size()-1){
for(int i=0;i<bft.size();i++){
for(int neighbor:adjlist.get(bft.get(i)-1)){
if(!visited[neighbor]){
bft.add(neighbor);
visited[neighbor] = true;
nodesReached++;
}
}
}
}
return bft;
}
public static ArrayList<Integer> bfsmatrix(boolean[][] adjmat, int source){
ArrayList<Integer> bft = new ArrayList<Integer>();
boolean[] visited = new boolean[adjmat.length+1];
Queue<Integer> q=new LinkedList<Integer>();
q.add(source);
visited[source] = true;
while(!q.isEmpty()){
int top=q.poll();
bft.add(top);
visited[top] = true;
for(int node=1; node <= adjmat.length; node++){
boolean[] adj = adjmat[top-1];
if(adj[node-1] && !visited[node]){
q.add(node);
visited[node] = true;
}
}
}
return bft;
}
//about the same
public static ArrayList<Integer> BFSmatrix(boolean[][] adjmat, int source){
ArrayList<Integer> bft=new ArrayList<Integer>();
boolean[] visited = new boolean[adjmat.length+1];
bft.add(source);
visited[source] = true;
int nodesReached=1;
while(nodesReached<adjmat.length-1){
for(int i=0;i<bft.size();i++){
for(int node=1; node <= adjmat.length; node++){
boolean[] adj = adjmat[bft.get(i)-1];
if(adj[node-1] && !visited[node]){
bft.add(node);
visited[node] = true;
nodesReached++;
}
}
}
}
return bft;
}
//converts adjacency matrix to adjacency list
public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
ArrayList<ArrayList<Integer>> adjlist=new ArrayList<ArrayList<Integer>>();
for(int i=0;i<adj.length;i++){
adjlist.add(new ArrayList<Integer>());
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
adjlist.get(i).add(j+1);
}
}
return adjlist;
}
public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjlist){
boolean[][] adjmat = new boolean[adjlist.size()][adjlist.size()];
for(int i=0;i<adjmat.length;i++){
for(int adj : adjlist.get(i)){
adjmat[i][adj-1] = true;
}
}
return adjmat;
}
//adjmat
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
public static <T> void execute(T t, long start){
System.out.println(t);
System.out.printf("%.3f ms\n", (System.nanoTime() - start)*1e-6);
}
}
================================================
FILE: Graph/Graphs.java
================================================
public class Graphs {
//Graph class with certain built in algorithms
private Edge[] edges;
private Vertex[] vertices;
public Graphs(Vertex[] vertices, Edge[] edges){
this.vertices=vertices;
this.edges=edges;
}
//Returns whether or not graph contains input vertex
public boolean hasVertex(Vertex v){
for(Vertex vertex:vertices){
if(vertex.getValue()==v.getValue()){
return true;
}
}
return false;
}
//returns sum of edge weights in graph
public int getCost(){
int sum=0;
for(Edge e:edges){
sum+=e.getWeight();
}
return sum;
}
public Edge[] getEdges(){
return edges;
}
public String[] vertex(){
String[] v= new String[vertices.length];
for(int i=0;i<vertices.length;i++){
v[i]=vertices[i].toString();
}
return v;
}
public Vertex[] getVertices(){
return vertices;
}
public String toString(){
String ver="";
for(Vertex v:vertices){
ver+=v.toString()+",";
}
String edg="";
for(Edge e:edges){
edg+=e.toString()+" ";
}
return "Vertices: "+ver+"\nEdges: "+edg+"\n";
}
}
================================================
FILE: Graph/Johnson
================================================
import java.awt.*;
import java.util.*;
import java.util.Queue;
import java.util.stream.Collectors;
import javax.swing.JFrame;
import org.apache.commons.collections15.Transformer;
import edu.uci.ics.jung.algorithms.layout.CircleLayout;
import edu.uci.ics.jung.algorithms.layout.Layout;
import edu.uci.ics.jung.graph.Graph;
import edu.uci.ics.jung.graph.SparseMultigraph;
import edu.uci.ics.jung.graph.util.EdgeType;
import edu.uci.ics.jung.visualization.VisualizationViewer;
import edu.uci.ics.jung.visualization.control.DefaultModalGraphMouse;
import edu.uci.ics.jung.visualization.control.ModalGraphMouse;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Johnson {
/*Johnson's Algorithm
Problem (informal): Given a weighted graph G, find minimally weighted path in G (all pairs shortest path)
Algorithm: Adds new source with edge to all vertices, runs Bellman-Ford on new graph where h[v] is distance from source to v, removes source (and edges) and rebalances
Complexity:
* Time - O(|V|^2*log|V| + |V|*|E|) where V is set of vertices and E is set of edges
* Space - O(|V|+|E|) to store visited vertices
Functions Defined:
* johnson() - Main algorithm to return all pairs shortest path
* dijkstra() - Dijkstra's Algorithm
* bellman_ford() - Bellman-Ford Algorithm
* Vertex() - Custom class to store weighted graphs
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
*/
public static void main(String[] args) {
//Initializing and filling sample array
ArrayList<Vertex>[] adjlist= new ArrayList[5];
adjlist[1] = new ArrayList<Vertex>();
adjlist[2] = new ArrayList<Vertex>();
adjlist[3] = new ArrayList<Vertex>();
adjlist[4] = new ArrayList<Vertex>();
adjlist[1].add(new Vertex(2, 1)); adjlist[1].add(new Vertex(3, 3));
adjlist[2].add(new Vertex(3, 1)); adjlist[2].add(new Vertex(4, 2)); adjlist[2].add(new Vertex(4, 1));
adjlist[3].add(new Vertex(4, 2));
adjlist[4].add(new Vertex(1, -1));
//Starting node
int source = 1;
//Ending node
int dest = 4;
System.out.print(johnson(adjlist, source, dest));
//Uncomment next line to visualize graph (need to convert to array first
//display(adj, "Graph");
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to destination
public static ArrayList<Integer> johnson(ArrayList<Vertex>[] adjlist, int source, int destination){
int len = adjlist.length;
ArrayList<Vertex>[] adjlist_ext = Arrays.copyOf(adjlist, len+1);
adjlist_ext[len] = new ArrayList<Vertex>();
//Agument graph with new vertex
for(int i=1;i<len;i++){
adjlist_ext[len].add(new Vertex(i, 0));
}
int[] h = bellman_ford(adjlist_ext, source);
if(h==null) return null;
for(int i=1;i<len;i++){
for(Vertex edge : adjlist[i]){
edge.weight += h[i] - h[edge.val];
}
}
int count = 0;
ArrayList<Integer> shortest_path = new ArrayList<Integer>();
shortest_path.add(Integer.MAX_VALUE);
for(int i=1;i<len;i++){
ArrayList<Integer> temp = dijkstra(adjlist, i);
System.out.println(temp);
if(temp.get(0) < shortest_path.get(0))
shortest_path = temp;
System.out.println(temp);
}
return shortest_path;
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to destination
public static int[] bellman_ford(ArrayList<Vertex>[] adjlist, int source){
boolean[] visited = new boolean[adjlist.length];
int[] distance = new int[adjlist.length];
int[] prev = new int[adjlist.length];
Arrays.fill(distance, Integer.MAX_VALUE);
distance[source] = 0;
for(int ver=1;ver<adjlist.length;ver++){ //iterates over all vertices
for(int i=1;i<adjlist.length;i++){ //iterates over all edges
for(Vertex neighbor:adjlist[i]){
if(distance[i] + neighbor.weight < distance[neighbor.val]){
distance[neighbor.val] = distance[i] + neighbor.weight;
prev[neighbor.val] = i;
}
}
}
}
for(int i=1;i<adjlist.length;i++){ //iterates over all edges
for(Vertex neighbor:adjlist[i]){
if(distance[neighbor.val] > neighbor.weight + distance[i])
return null;
}
}
return distance;
}
//Queue based implementation (CLRS)
//Returns value of shortest path from source to all vertices
public static ArrayList<Integer> dijkstra(ArrayList<Vertex>[] adjlist, int source){
boolean[] visited = new boolean[adjlist.length];
int[] distance = new int[adjlist.length];
int[] prev = new int[adjlist.length];
Arrays.fill(distance, Integer.MAX_VALUE);
PriorityQueue<Vertex> q=new PriorityQueue<Vertex>();
q.add(new Vertex(source, 0));
distance[source] = 0;
visited[source] = true;
ArrayList<Vertex> bft = new ArrayList<Vertex>();
while(!q.isEmpty()){
int top=q.poll().val;
visited[top] = true;
for(Vertex node:adjlist[top]){
if(q.contains(node.val)) continue; //Saves lots of time
if(distance[top] + node.weight < distance[node.val]){
prev[node.val] = top;
distance[node.val] = distance[top] + node.weight;
}
if(!visited[node.val]){
q.add(new Vertex(node.val, distance[node.val]));
visited[node.val] = true;
}
}
}
ArrayList<Integer> path = new ArrayList<Integer>();
path.add(source);
int min = Integer.MAX_VALUE;
int destination = 1;
for(int i=1;i<distance.length;i++){
if(i != source && distance[i] < distance[destination])
destination = i;
}
int current = destination;
while(current != source){
path.add(1, current);
current = prev[current];
}
path.add(0, distance[destination]);
return path;
}
//Uses JUNG to display 2D graph
public static void display(boolean[][] adj, String name){
//Populate Graph object
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int i=0;i<adj.length;i++){
graph.addVertex(i+1);
for(int j=0;j<adj[0].length;j++){
if(adj[i][j])
graph.addEdge((int)(Math.random()*Integer.MAX_VALUE), i+1, j+1, EdgeType.UNDIRECTED);
}
}
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(graph);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
return Color.GREEN;
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
//vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
//defined Vertex class for weighted graphs to hold edge weights
static class Vertex implements Comparable<Vertex>{
public int val;
public int weight;
public Vertex(int val){
this.val = val;
}
public Vertex(int val, int weight){
this.weight = weight;
this.val = val;
}
public String toString(){
return "Name: "+val+", Weight: "+weight;
}
public int compareTo(Vertex v){
return Integer.compare(weight, v.weight);
}
}
public static int[] list2arr(ArrayList<Integer> list){
return list.stream().mapToInt(i->i).toArray();
}
public static ArrayList<Integer> list2arr(int[] arr){
return (ArrayList<Integer>) Arrays.stream(arr).boxed().collect(Collectors.toList());
}
}
================================================
FILE: Graph/Karger.java
================================================
import java.awt.*;
import java.util.*;
import javax.swing.*;
import org.apache.commons.collections15.Transformer;
//Uses Java Universal Network/Graph (JUNG) Framework for conveniently displaying graphs
import edu.uci.ics.jung.algorithms.layout.*;
import edu.uci.ics.jung.graph.*;
import edu.uci.ics.jung.graph.util.*;
import edu.uci.ics.jung.visualization.*;
import edu.uci.ics.jung.visualization.control.*;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
public class Karger {
/*Karger's Min-Cut Algorithm
Problem (informal): Given weighted graph, find cut with minimally weighted edges spanning cut
Algorithm: Contract edges randomly until no more possible; remaining cut is probably minimal
Complexity:
* Time - O(|V|^2) = O(|E|)
* Space - O(|V|+|E|) to store lists
Functions Defined:
* edgeContraction() - Contracts a random edge and outputs resulting edge list
* newVertices() - Adjusts list of vertices, collapsing to account for contracted edge
* convertGraph() - converts edge list and vertex list to JUNG Graph type
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
Notes:
* Min Cut = Max Flow :)
*/
public static void main(String[] args) {
int num_Vertices;
int[] vertices= {1, 2, 3, 4, 5, 6, 7};
int[][] edges={{5, 1, 2}, {1, 2, 3}, {2, 3, 1}, {3, 1, 4}, {9, 2, 4}, {20, 3, 4}, {11, 1, 7}, {8, 6, 3}, {10, 5, 6}, {13, 1, 5}, {6, 4, 6}, {7, 7, 2}, {12, 5, 3}, {16, 6, 1}, {14, 5, 2}, {19, 4, 7}, {15, 7, 3}};
int mincut=0;;
display(vertices, edges, "red", "Undirected Sparse Graph");
while(vertices.length>2){
edges=edgeContraction(edges);
vertices=newVertices(vertices, edges);
}
display(vertices, edges, "green", "Min-Cut");
for(int[] edge:edges){
//System.out.println(Arrays.toString(edge));
mincut+=edge[0];
}
//System.out.println(Arrays.toString(vertices));
System.out.println(mincut);
}
public static int[][] edgeContraction(int[][] edges){
//choose random edge # to collapse betwen 0 and edges.length-1
//store vertex 1, vertex 2, delete the edge
//all edges from vertex 2 change to vertex 1;
//int[][] newEdges=new int[edges.length-1][3];
ArrayList<int[]> newEdges=new ArrayList<int[]>();
int randEdge=(int)(Math.random()*edges.length);
int v1=edges[randEdge][1], v2=edges[randEdge][2];
//Populate list of vertices + weights that are connected to edge
for(int i=0;i<edges.length;i++){
if(i==randEdge)
continue;
if(edges[i][1]==v2)
edges[i][1]=v1;
if(edges[i][2]==v2)
edges[i][2]=v1;
if(edges[i][1]!=edges[i][2])
newEdges.add(edges[i]);
}
int[][] edgeprime=new int[newEdges.size()][3];
for(int i=0;i<newEdges.size();i++){
edgeprime[i]=newEdges.get(i);
}
return edgeprime;
}
public static int[] newVertices(int[] vertices, int[][] edges){
int[] newVertices=new int[vertices.length-1];
TreeSet<Integer> set=new TreeSet<Integer>();
for(int[] edge:edges){
set.add(edge[1]); set.add(edge[2]);
}
int count=0;
while(!set.isEmpty()){
int num=set.pollFirst();
set.remove(num);
newVertices[count]=num;
count++;
}
return newVertices;
}
public static Graph<Integer, Integer> convertGraph(int[] vertices, int[][] edges){
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(int v:vertices){
graph.addVertex(v);
}
for(int[] e:edges){
graph.addEdge(e[0], e[1], e[2], EdgeType.UNDIRECTED);
}
return graph;
}
public static void display(int[] vertices, int[][] edges, String color, String name){
Graph<Integer,Integer> g=convertGraph(vertices, edges);
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(g);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
if(color=="green"){
return Color.GREEN;
}
else{
return Color.RED;
}
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
}
================================================
FILE: Graph/Prim.java
================================================
import java.awt.*;
import java.util.*;
import javax.swing.*;
import org.apache.commons.collections15.Transformer;
//Uses Java Universal Network/Graph (JUNG) Framework for conveniently displaying graphs
import edu.uci.ics.jung.algorithms.layout.*;
import edu.uci.ics.jung.graph.*;
import edu.uci.ics.jung.graph.util.*;
import edu.uci.ics.jung.visualization.*;
import edu.uci.ics.jung.visualization.control.*;
import edu.uci.ics.jung.visualization.decorators.ToStringLabeller;
import edu.uci.ics.jung.visualization.renderers.Renderer.VertexLabel.Position;
//Implementation of Prim's Algorithm to Determine Minimum Spanning Tree of Undirected Sparse Multigraph
public class Prim extends JPanel{
/*Prim's Algorithm
Problem (informal): Given graph, finding spanning tree with minimally weighted edges (MST)
Algorithm: Add least weighted edge incident to vertices in current MST at each iteration until all vertices added
Complexity:
* Time - O(|V|^2) searching adjacency matrix (effectively)
* Space - O(|V|+|E|) to store arrays of vertices and edges
Functions Defined:
* adjacentEdges() - Returns all edges adjacent to subgraph
* contains() - Returns whether or not input vertex exists in input array
* minEdge() - Given edge array, returns minimally weighted edge
* addVertex() - Adds input vertex to input graph
* addEdge() - Returns input Graph with added edge
* convertVertices() - Given array of values, returns array of Vertex type values
* convertEdge() - Given array of values with weight and vertices, returns array of Edge type values
* display() - Takes adjacency matrix input and displays GUI graph visualization (*Requires JUNG Library*)
Notes:
* Greedy!
* Should have used AdjacencyList for better performance; Fibonacci heap is optimal DS
*/
public static void main(String[] args) {
int[] values= {1, 2, 3, 4, 5, 6, 7};
int[][] lengths= {{5, 1, 2}, {1, 2, 3}, {2, 3, 1}, {3, 1, 4}, {9, 2, 4}, {20, 3, 4}, {11, 1, 7}, {8, 6, 3}, {10, 5, 6}, {13, 1, 5}, {6, 4, 6}, {7, 7, 2}, {12, 5, 3}, {16, 6, 1}, {14, 5, 2}, {19, 4, 7}, {15, 7, 3}};
Vertex[] vertices=convertVertices(values);
Edge[] edges=convertEdges(lengths);
int numVertices=vertices.length;
int numEdges=edges.length;
Graphs g=new Graphs(vertices, edges);
display(g, "red", "Undirected Sparse Graph");
//Initializes Minimum Spanning Tree with single vertex
Graphs mst=new Graphs(convertVertices(new int[0]), convertEdges(new int[0][0]));
mst=addVertex(mst, g.getVertices()[0]);
Graphs old_mst=mst;
int iteration=0;
//Prim's Algorithm: repeatedly identifies and dynamically adds minimally weighted adjacent edge to minimum spanning tree until all vertices are included
while(convertGraph(mst).getVertexCount()<g.getVertices().length){
//Find minimally weighted adjacent edge
Edge[] adjacentEdges=adjacentEdges(mst, g);
Edge minEdge=minEdge(adjacentEdges);
Vertex v1=minEdge.getVertex1();
Vertex v2=minEdge.getVertex2();
//Add vertex then edge to Minimum Spanning Tree
if(mst.hasVertex(v1)){
mst=addVertex(mst, v2);
}
else{
mst=addVertex(mst, v1);
minEdge.swap();
}
minEdge.makeDirected();
mst=addEdge(mst, minEdge);
iteration++;
System.out.println("Iteration: "+iteration+"\n------------");
System.out.println("Adjacent Edges: "+Arrays.toString(adjacentEdges));
System.out.println("Minimally Weighted Adjacent Edge: "+minEdge.toString()+"\n");
System.out.println(convertGraph(mst).toString()+"\n\n");
display(mst, "green", "Minimum Spanning Tree Iteration "+iteration);
}
System.out.println("\n\nMST Cost: "+mst.getCost());
display(mst, "green", "Minimum Spanning Tree");
}
//Returns all edges in Graph adjacent to (but not included in) vertices of subgraph
public static Edge[] adjacentEdges(Graphs mst, Graphs g){
ArrayList<Edge> adjacentEdges=new ArrayList<Edge>();
Edge[] superEdges=g.getEdges();
Vertex[] subVertices=mst.getVertices();
for(Edge e:superEdges){
if(contains(subVertices, e.getVertex1()) != contains(subVertices, e.getVertex2())){
adjacentEdges.add(e);
}
}
return adjacentEdges.toArray(new Edge[adjacentEdges.size()]);
}
//Returns whether or not input Vertex is included in array of vertices
public static boolean contains(Vertex[] vertices, Vertex v){
for(Vertex vertex:vertices){
if(vertex.getValue()==v.getValue()){
return true;
}
}
return false;
}
//Returns minmally weighted edge in array
public static Edge minEdge(Edge[] edges){
Edge minEdge=edges[0];
for(Edge e:edges){
if(e.getWeight()<minEdge.getWeight()){
minEdge=e;
}
}
return minEdge;
}
//Returns input Graphs with added vertex
public static Graphs addVertex(Graphs g, Vertex vertex){
Vertex[] vertices=g.getVertices();
Vertex[] newvertices=new Vertex[g.getVertices().length+1];
for(int i=0;i<vertices.length;i++){
newvertices[i]=vertices[i];
}
newvertices[newvertices.length-1]=vertex;
return new Graphs(newvertices, g.getEdges());
}
//Returns input Graphs with added edge
public static Graphs addEdge(Graphs g, Edge edge){
Edge[] edges=g.getEdges();
Edge[] newedges=new Edge[g.getEdges().length+1];
for(int i=0;i<edges.length;i++){
newedges[i]=edges[i];
}
newedges[newedges.length-1]=edge;
return new Graphs(g.getVertices(), newedges);
}
//Converts array of integer values to array of Vertex values
public static Vertex[] convertVertices(int[] values){
Vertex[] vertices=new Vertex[values.length];
for(int i=0;i<values.length;i++){
vertices[i]=new Vertex(values[i]);
}
return vertices;
}
//Converts 2D array of values specifying weight and vertices into array of Edge values
public static Edge[] convertEdges(int[][] lengths){
Edge[] edges=new Edge[lengths.length];
for(int i=0;i<lengths.length;i++){
edges[i]=new Edge(lengths[i][0], lengths[i][1], lengths[i][2]);
}
return edges;
}
//Converts Graphs into JUNG compatible form Graph<Integer, Integer> for visualization
public static Graph<Integer, Integer> convertGraph(Graphs g){
Graph<Integer,Integer> graph=new SparseMultigraph<Integer,Integer>();
for(Vertex v:g.getVertices()){
graph.addVertex(v.getValue());
}
for(Edge e:g.getEdges()){
if(e.getDirected()){
graph.addEdge(e.getWeight(), e.getVertex1().getValue(), e.getVertex2().getValue(), EdgeType.DIRECTED);
}
else{
graph.addEdge(e.getWeight(), e.getVertex1().getValue(), e.getVertex2().getValue());
}
}
return graph;
}
//Uses JUNG to display 2D graph
public static void display(Graphs graph, String color, String name){
Graph<Integer,Integer> g=convertGraph(graph);
//VisualizationImageServer vs = new VisualizationImageServer(new CircleLayout(g), new Dimension(650, 650));
//Initialize visualization
Layout<Integer, String> layout = new CircleLayout(g);
layout.setSize(new Dimension(620,620));
VisualizationViewer<Integer,String> vs = new VisualizationViewer<Integer,String>(layout);
vs.setPreferredSize(new Dimension(650,650));
//Creates GraphMouse and adds to visualization
DefaultModalGraphMouse gm = new DefaultModalGraphMouse();
gm.setMode(ModalGraphMouse.Mode.TRANSFORMING);
vs.setGraphMouse(gm);
//Initialize JFrames
JFrame frame = new JFrame(name);
frame.getContentPane().setBackground(Color.RED);
frame.getContentPane().add(vs);
frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
frame.pack();
frame.setVisible(true);
//Colors Vertices
Transformer<Integer,Paint> vertexPaint = new Transformer<Integer,Paint>() {
public Paint transform(Integer i) {
if(color=="green"){
return Color.GREEN;
}
else{
return Color.RED;
}
}
};
//Labels Edges
float dash[] = {10.0f};
final Stroke edgeStroke = new BasicStroke(1.0f, BasicStroke.CAP_BUTT, BasicStroke.JOIN_MITER, 10.0f, dash, 0.0f);
Transformer<String, Stroke> edgeStrokeTransformer =new Transformer<String, Stroke>(){
public Stroke transform(String s) {
return edgeStroke;
}
};
//Renders Vertex colors/labels
vs.getRenderContext().setVertexFillPaintTransformer(vertexPaint);
vs.getRenderContext().setVertexLabelTransformer(new ToStringLabeller());
vs.getRenderer().getVertexLabelRenderer().setPosition(Position.CNTR);
//Renders Edge labels
vs.getRenderContext().setEdgeLabelTransformer(new ToStringLabeller());
}
}
================================================
FILE: Graph/README.md
================================================
# Graph Algorithms
## Graph Implementation
* [Graph](https://github.com/jpa99/Algorithms/blob/master/Graph/Graphs.java)
* [Vertex](https://github.com/jpa99/Algorithms/blob/master/Graph/Vertex.java)
* [Edge](https://github.com/jpa99/Algorithms/blob/master/Graph/Edge.java)
## Graph Traversal
* [Breadth-First Search](https://github.com/jpa99/Algorithms/blob/master/Graph/BFS.java)
* [Depth First Search](https://github.com/jpa99/Algorithms/blob/master/Graph/DFS.java)
* [Combined Traversal](https://github.com/jpa99/Algorithms/blob/master/Graph/Graph_Traversal.java)
## Shortest Path
* [Dijkstra's Algorithm](https://github.com/jpa99/Algorithms/blob/master/Graph/Dijkstra.java)
* [Bellman-Ford](https://github.com/jpa99/Algorithms/blob/master/Graph/Bellman_Ford.java)
* [Floyd-Warshall](https://github.com/jpa99/Algorithms/blob/master/Graph/Floyd_Warshall.java)
* [Johnson's Algorithm](https://github.com/jpa99/Algorithms/blob/master/Graph/Johnson.java)
## Minimum Spanning Tree
* Kruskal's Algorithm
* [Prim's Algorithm](https://github.com/jpa99/Algorithms/blob/master/Graph/Prim.java)
## Network Flow
* [Karger's Min-Cut Algorithm](https://github.com/jpa99/Algorithms/blob/master/Graph/Karger.java)
* [Ford-Fulkerson](https://github.com/jpa99/Algorithms/blob/master/Graph/Ford_Fulkerson.java)
* Push-Relabel
* Edmonds-Karp
## Others
* Tarjan's Algorithm
* Topological Sort
* Strongly Connected Components
* A*
================================================
FILE: Graph/Vertex.java
================================================
public class Vertex {
//Vertex class
//probably unnecessary, but already built into Prim's Algorith implementation
int value;
public Vertex(int val){
value=val;
}
public int getValue(){
return value;
}
public String toString(){
return String.valueOf(value);
}
}
================================================
FILE: LICENSE
================================================
MIT License
Copyright (c) 2017 Joel Abraham
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.
================================================
FILE: Math/README.md
================================================
# Math/Number Theoretic Algorithms
================================================
FILE: Miscellaneous/Fisher_Yates.java
================================================
import java.util.Arrays;
import java.util.Random;
public class Fisher_Yates {
/*Fisher-Yates Algorithm
Problem (informal): Given input array, return permuted array such that elements are uniformly distributed (pseudorandomly)
Algorithm: For each index i, swap element at i with element at random index 0 <= j <= i
Complexity:
* Time - O(n) since only one iteration
* Space - O(n) to choose random integer at each position
Notes:
* shuffle() - randomly permutes input array
* swap() - swaps elements at indices i and j
Notes:
* Simple but effective shuffling algorithm
*/
public static void main(String[] args) {
Integer[] arr = {1, 4, 3, 2, 64, 3, 2, 4, 5, 5, 2, 12, 14, 5, 3, 0, -1};
arr = shuffle(arr);
System.out.println(Arrays.toString(arr));
}
public static <E extends Comparable<E>> E[] shuffle(E[] arr){
Random rng = new Random();
for(int i = arr.length - 1 ; i > 0 ; i--){
int j = rng.nextInt(i+1); //random element in range [0, i]
swap(arr, i, j);
}
return arr;
}
public static <E> void swap(E[] arr, int i, int j){
E temp = arr[i];
arr[i] = arr[j];
arr[j] = temp;
}
}
================================================
FILE: Miscellaneous/Matrix_Exponentiation.java
================================================
import java.util.Arrays;
public class Matrix_Exponentiation {
/*Matrix Exponentiation Algorithm
Problem (informal): Given a matrix M, find the product: M^n = M x M x ... x M
Algorithm: Brute force algorithm for repeated multiplication
Complexity:
* Time - O(n*i*j*k) where a has dimensions i x j and b has dimensions j x k to compute M^n
* Space - O(i*j) where M has i rows and j columns
Functions Defined:
* matrix_multiply() - returns matrix product of matrices a and b
* matrix_exponentation() - returns M^n via repeated multiplication of M for square matrix M
*/
public static void main(String[] args){
int[][] a = {{1, 2, 3, 2}, {2, 3, 4, 8}, {4, 5, 3, 6}}; //3 x 4
int[][] b = {{6, 1, 4}, {9, 0, 6}, {6, 4, 5}, {3, 1, 1}}; // 4 x 3
int[][] m = matrix_multiply(a, b);
System.out.println(Arrays.deepToString(m));
//testing staticness with multiplication with identity
int[][] identity = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
int[][] m2 = matrix_multiply(m, identity);
System.out.println(Arrays.deepToString(m2));
//matrix exponentiation
m2 = matrix_exponentiation(m2, 2);
System.out.println(Arrays.deepToString(m2));
}
//assumes that matrix b has j rows and a has j columns
//O(ijk) where a has dimensions i x j and b has dimensions j x k
public static int[][] matrix_multiply(int[][] a, int[][] b){
int[][] m = new int[a.length][b[0].length];
for(int i=0;i<a.length;i++){
for(int j = 0; j < b[0].length;j++){
//m[i][j] is product of ith row of A and jth column of B
int sum = 0;
for(int k = 0; k < b.length; k++){
sum+= a[i][k]*b[k][j];
}
m[i][j] = sum;
}
}
return m;
}
//O(n*ijk) where a has dimensions i x j and b has dimensions j x k to compute M^n
public static int[][] matrix_exponentiation(int[][] m, int n){
while(n-- > 1){
m = matrix_multiply(m, m);
}
return m;
}
}
================================================
FILE: Miscellaneous/README.md
================================================
# Miscellaneous Algorithms
* [Fisher-Yates Algorithm](https://github.com/jpa99/Algorithms/blob/master/Miscellaneous/Fisher_Yates.java)
* [Subarray Inversions](https://github.com/jpa99/Algorithms/blob/master/Miscellaneous/Subarray_Inversions.java)
* [Matrix Exponentiation](https://github.com/jpa99/Algorithms/blob/master/Miscellaneous/Matrix_Exponentiation.java)
================================================
FILE: Miscellaneous/Subarray_Inversions.java
================================================
import java.util.*;
public class Subarray_Inversions {
/* Subarray Inversions
Problem: Given an array A of n integers, find the sum of the number of inversions in all subarrays of length k. To clarify, one must determine the number of inversions in each of the n – k + 1 subarrays of length k and add them together.
Explanation: Many times, algorithms that perform the same or similar operation(s) repeatedly can be improved by the use of a more robust data structure. In our case, we’re looking for a dynamic data structure that can efficiently answer queries about an element’s relative position when sorted. We can use a self-balancing binary tree to actually maintain a sorted list, but insertion/removal takes logarithmic time. We can do this in constant time using a Binary Indexed Tree, or Fenwick Tree.
A binary indexed tree is a tree represented in the form of an array. It uses clever bit manipulation to compute the cumulative sum of elements very efficiently. We can call the function update(index, val) function to add val to BIT[index] and all of the ancestors of index. The function read(index) returns the sum of the values stored at BIT[index] and all of the ancestors of index in the tree. Thus, calling read(index) returns the cumulative sum of all elements in BIT less than or equal to index. Instead of storing values, if we simply store 1, we can use read(index + 1) to determine the number of elements less than index. Now, we can construct a binary indexed tree by inserting the elements (updating) of the first window. For subsequent windows, we can remove the trailing element by calling update(tail_element, -1) and add the new element with update(head_element, 1). Since this is a tree, the longest possible root-node path is O(logk), Thus, we achieve an optimal runtime of O(nlogk + klogk) = O(nlogk)!
Or do we…? Remember, binary indexed trees allocate memory for every possible value in the range [0, max_element], so this requires O(max_element) time and space. For very sparse arrays, this can be quite costly. Instead, we can define a hash function to . We can do this because we’re only concerned about inversions — as long as we keep the relative magnitude the same (i.e. A[i] <= A ==> A[hash(i)] <= A[hash(j)]), our solution will still be correct. Thus, we can map all the elements in A to the set {0, 1, 2, …, n}, yielding a guaranteed runtime of O(nlogk).
Complexity:
* Time - O(nlogk)
* Space - O(n)
Functions Defined:
* inversionCountBIT1() - First pass, instantiates binary indexed tree
* inversionCountBIT2() - Subsequent passes, remove trailing element, add leading element, computes changes
* inversionCount() - main algorithm that maps array to [1...n] and slides window
* class BIT() - Instantiates binary indexed tree
+ update() - updates ancestors and index with specified value, runs in O(log n)
+ read() - computes and determines sum of index pointer and ancestors, runs in O(log n)
*/
//Declare binary indexed tree with global scope
static BIT bit;
//first window, counts first k elements and creates BIT
static long inversionCountBIT1(int[] arr, int start, int end) {
bit = new BIT(arr.length);
long count = 0;
for(int index = start; index >=end; index--){
count+=bit.read(arr[index]);
bit.update(arr[index], 1);
}
return count;
}
//subsequent windows, removes previous element, adds new element, and increments change in inversions
static long inversionCountBIT2(int[] arr, int start, int end, long val) {
bit.update(arr[start+1], -1); //remove trailing element
//find number of elements in range [start, end-1] greater than first
int numGreaterThanFirst = start-end - bit.read(arr[start+1]+1);
long count = val + bit.read(arr[end]) - numGreaterThanFirst;
bit.update(arr[end], 1); //adds leading element
return count;
}
//Main method to count inversions in size k subarrays
public static long inversionCount(int n, int k, int[] arr){
bit = new BIT(n);
HashMap<Integer, Integer> freq = new HashMap<Integer, Integer>();
int[] asort = arr.clone();
//Map elements from [A[0]...A[n-1]] to [1...n]
Arrays.sort(asort);
int index = 0;
int current = 1;
for(int i=0;i<n;i++){
if(!freq.containsKey(asort[i])){
freq.put(asort[i], current);
current++;
}
}
for(int i=0;i<n;i++){
arr[i] = freq.get(arr[i]);
}
long count = 0;
long val = 0;
//[start - end] ==> start - end = k+1
for(int start = n-1; start >=k-1; start--){
int end = start - k+1;
if(start == n-1){ //First pass
val = inversionCountBIT1(arr, n-1, n-k);
}
else{ //subsequent passes
val = inversionCountBIT2(arr, start, end, val);
}
count+=val;
}
return count;
}
public static void main(String[] args)throws Exception {
int n = 10;
int[] arr = {15, 51, 44, 44, 76, 50, 29, 88, 48, 50};
int k = 5;
long result = inversionCount(n, k, arr);
System.out.println(result);
}
//Implementation of Binary Indexed Tree
static class BIT
{
int[] tree;
int maxVal;
public BIT(int N){
tree = new int[N+1];
maxVal = N;
}
//Updates BIT, starting with element at index and all ancestors
void update(int index, int val){
while (index <= maxVal){
tree[index] += val;
index += (index & -index);
}
}
//Returns the cumulative frequency of index starting with element at index and all ancestors
int read(int index)
{
--index;
int cumulative_sum=0;
while (index >0){
cumulative_sum += tree[index];
index -= (index & -index);
}
return cumulative_sum;
}
};
}
================================================
FILE: Optimization/LightConfigurationOptimization.java
================================================
import java.util.*;
import java.math.*;
import org.apache.commons.math3.util.Combinations;
public class LightConfigurationOptimization {
static final int M = 5, N = 5; //Source/Target arrays are M*N grids
static final int k = 5; //Number of LEDs
static final double Z = 5; //Distance between source and target planes
static final int len = M*N; //Number of candidate locations
static final double halfwidth = 12; //Manufacturer provided angular half-width
static final double m = Math.log(0.5)/Math.log(Math.cos(halfwidth*Math.PI/180));
static final double intensity = 1; //arbitrary units, can change later
public static void main(String[] rip){
long start = System.nanoTime();
//Given two parallel M*N arrays (source and target), Z units apart, and 5 light fixtures, find optimal configuration
//Objective function is sigma/E
int[] optLEDarr = new int[k];
double min = Double.MAX_VALUE; //current mimimum of objective function
String[][] sourceArray = new String[M][N];
for (Iterator<int[]> iter = new Combinations(M*N, k).iterator(); iter.hasNext();) {
LEDConfiguration config = cost(iter.next());
if(config.CVRMSE < min){
min = config.CVRMSE;
optLEDarr = config.LEDarr;
}
}
System.out.println(Arrays.toString(optLEDarr));
for(String[] row:sourceArray) Arrays.fill(row, "⚫");
for(int LED:optLEDarr){
int[] LEDcoord = indexToPoints(LED);
sourceArray[LEDcoord[0]][LEDcoord[1]] = "⚪";
}
System.out.println(min+"\n\n");
for(String[] row:sourceArray) System.out.println(Arrays.toString(row));
System.out.println("\nRuntime: "+((System.nanoTime()-start)/1000000)+" ms");
}
//Outputs cost function evaluated at specified LED configuration
public static LEDConfiguration cost(int[] LEDarr){
double netIrradiance = 0; //Sum of irradiance at all points
double avgIrradiance = 0; //Average irradiance across grid
double netErrorSquared = 0, sigma = 0;
double CVRMSE = 0; //objective function, CVRMSE = sigma/avgIrradiance
int len = M*N;
//unique combination of LEDs exists
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
for(int LED:LEDarr){
netIrradiance += irradiance(LED, pointcoord);
}
}
avgIrradiance = netIrradiance/len;
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
double pointIrradiance = 0; //irradiance at point from all LEDs
for(int LED:LEDarr){
pointIrradiance+=irradiance(LED, pointcoord);
}
netErrorSquared+=Math.pow(pointIrradiance - avgIrradiance, 2);
}
sigma = Math.sqrt(netErrorSquared/len);
CVRMSE = sigma/avgIrradiance; //objective function
LEDConfiguration config = new LEDConfiguration(CVRMSE, LEDarr);
return config;
}
//Returns irradiance contributed by specific LED at a specific point
public static double irradiance(int LED, int[] pointcoord){
int[] LEDcoord = indexToPoints(LED);
return (Math.pow(Z, m+1)*intensity)/
Math.pow((Math.pow(pointcoord[0] - LEDcoord[0], 2) + Math.pow(pointcoord[1] - LEDcoord[1], 2) + Math.pow(Z, 2)), ((m+3)/2));
}
//Mapping from [0, M*N] --> [0,M]x[0,N]
public static int[] indexToPoints(int index){
int[] points = {index%M, index/M};
return points;
}
static class LEDConfiguration{
public double CVRMSE;
public int[] LEDarr;
public LEDConfiguration(double CVRMSE, int[] LEDarray){
this.CVRMSE = CVRMSE;
LEDarr = LEDarray;
}
}
}
================================================
FILE: Optimization/LightConfigurationOptimizationSA.java
================================================
import java.util.Arrays;
import java.util.HashMap;
import java.util.Random;
public class LightConfigurationOptimizationSA {
static final int M = 5, N = 5; //Source/Target arrays are M*N grids
static final int k = 5; //Number of LEDs
static final double Z = 5; //Distance between source and target planes
static final int len = M*N;
static final double halfwidth = 12; //Manufacturer provided angular half-width
static final double m = Math.log(0.5)/Math.log(Math.cos(halfwidth*Math.PI/180));
static final double intensity = 1; //arbitrary units, can change later
//Simulated Annealing parameters
static final double Tmin = .0001; //Temperature at which iteration terminates
static final double alpha = 0.9; //Decrease in temperature
public static void main(String[] args) {
double T = 1; //Initial temperature
String[][] sourceArray = new String[M][N];
Solution min = new Solution(Double.MAX_VALUE, null);
Solution currentSol = genRandSol();
while(T > Tmin){
for(int i=0;i<100;i++){
if(currentSol.CVRMSE < min.CVRMSE){
min = currentSol;
}
Solution newSol = neighbor(currentSol);
double ap = Math.pow(Math.E, (currentSol.CVRMSE - newSol.CVRMSE)/T);
if(ap > Math.random()){
currentSol = newSol;
}
}
T*=alpha;
}
System.out.println(min.CVRMSE+"\n\n");
for(String[] row:sourceArray) Arrays.fill(row, "⚫");
for(int LED:min.config){
int[] LEDcoord = indexToPoints(LED);
sourceArray[LEDcoord[0]][LEDcoord[1]] = "⚪";
}
for(String[] row:sourceArray) System.out.println(Arrays.toString(row));
}
//Given current configuration, returns "neighboring" configuration (i.e. very similar)
//integer of k points each in range [0, n)
/*Different neighbor selection strategies?
* Move all points 0 or 1 units in a random direction
*
*/
public static Solution neighbor(Solution currentSol){
int[] config = currentSol.config; //+- 1 for left/right, +-M for up/down
int[] directions = {-1, 1, M, -M};
for(int i=0;i<config.length;i++){
int newIndex = config[i]+directions[(int) (Math.random()*4)];
if(newIndex >= 0 && newIndex < len) config[i] = newIndex;
}
return new Solution(cost(config), config);
}
//Generates random solution via modified Fisher-Yates shuffle for first k elements
//Pseudorandomly selects k integers from the interval [0, n-1]
public static Solution genRandSol(){
Random rng = new Random();
HashMap<Integer, Integer> hash = new HashMap<Integer, Integer>(2*k);
int[] configuration = new int[k];
for (int i = 0; i < k; i++) {
int j = i + rng.nextInt(len - i);
configuration[i] = (hash.containsKey(j) ? hash.remove(j) : j);
if (j > i) hash.put(j, (hash.containsKey(i) ? hash.remove(i) : i));
}
double cost = cost(configuration);
return new Solution(cost, configuration);
}
//Returns irradiance contributed by specific LED at a specific point
public static double irradiance(int LED, int[] pointcoord){
int[] LEDcoord = indexToPoints(LED);
return (Math.pow(Z, m+1)*intensity)/
Math.pow((Math.pow(pointcoord[0] - LEDcoord[0], 2) + Math.pow(pointcoord[1] - LEDcoord[1], 2) + Math.pow(Z, 2)), ((m+3)/2));
}
//Mapping from [0, M*N] --> [0,M]x[0,N]
public static int[] indexToPoints(int index){
int[] points = {index%M, index/M};
return points;
}
//Cost function, evaluates CVRMSE of input LED configuration
//Complexity is O(M*N*k), asymptotically tight
public static double cost(int[] LEDarr){
double netIrradiance = 0; //Sum of irradiance at all points
double avgIrradiance = 0; //Average irradiance across grid
double netErrorSquared = 0, sigma = 0;
//unique combination of LEDs exists
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
for(int LED:LEDarr){
netIrradiance+=irradiance(LED, pointcoord);
}
}
avgIrradiance = netIrradiance/len;
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
double pointIrradiance = 0; //irradiance at point from all LEDs
for(int LED:LEDarr){
pointIrradiance+=irradiance(LED, pointcoord);
}
netErrorSquared+=Math.pow(pointIrradiance - avgIrradiance, 2);
}
sigma = Math.sqrt(netErrorSquared/len);
return sigma/avgIrradiance; //objective function
}
static class Solution{
public double CVRMSE;
public int[] config;
public Solution(double CVRMSE, int[] configuration){
this.CVRMSE = CVRMSE;
config = configuration;
}
}
}
================================================
FILE: Optimization/LocationalOptimizationIterative.java
================================================
import java.util.*;
import java.math.*;
import org.apache.commons.math3.util.Combinations;
public class LocationalOptimizationIterative {
static final int M = 7, N = 7; //Source/Target arrays are M*N grids
static final int k = 5; //Number of LEDs
static final double Z = 5; //Distance between source and target planes
static final double halfwidth = 12; //Manufacturer provided angular half-width
static final double m = Math.log(0.5)/Math.log(Math.cos(halfwidth*Math.PI/180));
static final double intensity = 1; //arbitrary units, can change later
public static void main(String[] rip){
long start = System.nanoTime();
//Given two parallel M*N arrays (source and target), Z units apart, and 5 light fixtures, find optimal configuration
//Objective function is sigma/E
int len = M*N; //Number of points
int[] optLEDarr = new int[k];
double min = Double.MAX_VALUE; //current mimimum of objective function
String[][] sourceArray = new String[M][N];
for (Iterator<int[]> iter = new Combinations(M*N, k).iterator(); iter.hasNext();) {
double netIrradiance = 0; //Sum of irradiance at all points
double avgIrradiance = 0; //Average irradiance across grid
double netErrorSquared = 0, sigma = 0;
double CVRMSE = 0; //objective function, CVRMSE = sigma/avgIrradiance
//unique combination of LEDs exists
int[] LEDarr = iter.next();
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
for(int LED:LEDarr){
netIrradiance+=irradiance(LED, pointcoord);
}
}
avgIrradiance = netIrradiance/len;
for(int targetPoint = 0; targetPoint < len; targetPoint++){
//given some point on target plane and set of LED positions, find irradiance
int[] pointcoord = indexToPoints(targetPoint);
double pointIrradiance = 0; //irradiance at point from all LEDs
for(int LED:LEDarr){
pointIrradiance+=irradiance(LED, pointcoord);
}
netErrorSquared+=Math.pow(pointIrradiance - avgIrradiance, 2);
}
sigma = Math.sqrt(netErrorSquared/len);
CVRMSE = sigma/avgIrradiance; //objective function
if(CVRMSE < min){
min = CVRMSE;
optLEDarr = LEDarr;
}
}
for(String[] row:sourceArray) Arrays.fill(row, "⚫");
for(int LED:optLEDarr){
int[] LEDcoord = indexToPoints(LED);
sourceArray[LEDcoord[0]][LEDcoord[1]] = "⚪";
}
System.out.println(min+"\n\n");
for(String[] row:sourceArray) System.out.println(Arrays.toString(row));
System.out.println("\nRuntime: "+((System.nanoTime()-start)/1000000)+" ms");
}
//Returns irradiance contributed by specific LED at a specific point
public static double irradiance(int LED, int[] pointcoord){
int[] LEDcoord = indexToPoints(LED);
return (Math.pow(Z, m+1)*intensity)/
Math.pow((Math.pow(pointcoord[0] - LEDcoord[0], 2) + Math.pow(pointcoord[1] - LEDcoord[1], 2) + Math.pow(Z, 2)), ((m+3)/2));
}
//Mapping from [0, M*N] --> [0,M]x[0,N]
public static int[] indexToPoints(int index){
int[] points = {index%M, index/M};
return points;
}
}
================================================
FILE: Optimization/README.md
================================================
# Optimization Algorithms
This folder contains optimization implementations for locational optimization problems. The general problem statement solveable by this flavor of optimization is as follows: Given a set S of n candidate 2-tuples (ordered pairs) and a function cost(P): R^2 --> R where P = {(x_1, y_1), (x_2, y_2), ..., (x_k, y_k)}, find a subset Q of k 2-tuples (ordered pairs) such that cost(Q) is minimized. This can be reformulated as selecting k optimal points from a set of n candidate points.
* [Naive Optimization](https://github.com/jpa99/Algorithms/blob/master/Optimization/LightConfigurationOptimization.java)
* Simplex (LP)
* [Simulated Annealing](https://github.com/jpa99/Algorithms/blob/master/Optimization/LightConfigurationOptimizationSA.java)
* Genetic Algorithms
* Combinatoric Algorithms
================================================
FILE: ProjectEuler/Amicable_numbers.java
================================================
public class Amicable_numbers {
public static void main(String[] args) {
int sum=0;
for(int i=0;i<10000;i++){
if(amicable(i, sum_divisors(i)) && i!=sum_divisors(i)){
sum+=i;
}
}
System.out.println(sum);
}
public static boolean amicable(int a, int b){
return sum_divisors(a)==b && sum_divisors(b)==a ? true:false;
}
public static int sum_divisors(int n){
int sum=0;
for(int i=2;i<(int)(n/2)+1;i++){
if(n%i==0){
sum+=i;
}
}
return sum+1;
}
}
================================================
FILE: ProjectEuler/Coded_triangle_numbers.java
================================================
import java.io.*;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.HashMap;
import java.util.Scanner;
public class Coded_triangle_numbers {
public static void main(String[] args) throws IOException{
//Initialize array containing words from text file
String fileName="words.txt";
String[] words = null;
try{
FileReader inputFile = new FileReader(fileName);
BufferedReader bufferReader = new BufferedReader(inputFile);
String line=bufferReader.readLine();
words=line.split(",");
bufferReader.close();
}
catch(Exception e){
}
//Initialize list containing triangles numbers
ArrayList<Integer> triangles=new ArrayList<Integer>();
int num=0;
for(int index=1;index<500;index++){
num+=index;
triangles.add(num);
}
//Iterate through array of words and test for triangle numbers
int num_triangles=0;
for(String n:words){
int sum=0;
for(char i:n.toCharArray()){
sum+="ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(i)+1;
}
if(triangles.contains(sum)){
num_triangles++;
}
System.out.println(n +" "+sum+" ");
}
System.out.println(num_triangles);
}
}
================================================
FILE: ProjectEuler/Collatz_sequence.java
================================================
public class Collatz_sequence {
public static void main(String[] args){
double starting=0;
double max=0;
for(double i=2;i<1000000;i++){
if(collatz(i)>max){
max=collatz(i);
starting=i;
System.out.println(starting);
}
}
}
public static double collatz(double n){
double sum=0;
while(n!=1){
if(n%2==0){
n/=2;
}
else{
n=3*n+1;
}
sum++;
}
return sum;
}
}
================================================
FILE: ProjectEuler/Combinatoric_selections.java
================================================
import java.math.BigInteger;
public class Combinatoric_selections {
public static void main(String[] args) {
int sum=0;
for(int n=23; n<=100;n++){
for(int r=4;r<n-3;r++){
int choose = (factorial(n))/(factorial(r)*(factorial(n-r)));
if(choose>1000000){
sum++;
}
}
}
}
public static int factorial(int num){
int prod=1;
for(int i=num;i>1;i--){
prod*=i;
}
return prod;
}
}
================================================
FILE: ProjectEuler/Concealed_square.java
================================================
import java.math.BigInteger;
public class Concealed_square {
public static void main(String[] args) {
for(long i=1010101010;i<1389026624;i+=10){
BigInteger num=BigInteger.valueOf(i);
String n=String.valueOf(num.pow(2));
if(n.length()=="1929394959697989990".length()){
int index=0;
char[] nums=n.toCharArray();
for(int j=0;j<nums.length;j+=2){
if(nums[j]=="1929394959697989990".toCharArray()[j]){
index++;
}
if(index==10){
System.out.println(i);
}
}
}
}
}
}
================================================
FILE: ProjectEuler/Consecutive_distinct_prime_factors.java
================================================
import java.util.ArrayList;
import java.lang.Math;
public class Consecutive_distinct_prime_factors {
public static void main(String[] args) {
for(double i=0;i<100000000;i++){
if(!isPrime(i) && factor(i).size()==4 &&
factor(i+1).size()==4 &&
factor(i+2).size()==4 &&
factor(i+3).size()==4
){
System.out.println(i);
}
}
}
public static ArrayList<Double> factor(double n){
ArrayList<Double> factors=new ArrayList<Double>();
for(double i= n-1;i>=2;i--){
if(n%i==0 && isPrime(i) && !inlist(i, factors)) {
n/=i;
factors.add(i);
i++;
}
}
return factors;
}
public static boolean inlist(double n, ArrayList<Double> arr){
for(double i: arr){
if(n==i){
return true;
}
}
return false;
}
public static double return_max(ArrayList<Double> factors){
double max=factors.get(0);
for(double i:factors){
if(i>max){
max=i;
}
}
return max;
}
public static boolean isPrime(double n){
for(double i=2;i<n;i++){
if(n%i==0){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/Counting_sundays.java
================================================
public class Counting_sundays {
public static void main(String[] args) {
}
}
================================================
FILE: ProjectEuler/Digit_factorials.java
================================================
public class Digit_factorials {
public static void main(String[] args) {
int sum=0;
for(int i=10; i>0;i++){
if(sumDigits(i)){
sum+=i;
System.out.println(sum);
}
}
}
public static int factorial(int num){
int prod=1;
for(int i=num;i>1;i--){
prod*=i;
}
return prod;
}
public static boolean sumDigits(int n){
String num=String.valueOf(n);
int fsum=0;
for(int i=0;i<num.length();i++){
fsum+=factorial(Integer.parseInt(num.substring(i, i+1)));
}
if(fsum==n){
return true;
}
else{
return false;
}
}
}
================================================
FILE: ProjectEuler/Digit_fifth_power.java
================================================
public class Digit_fifth_power {
public static void main(String[] args) {
int sum=0;
for(int i=0;i<1000000000;i++){
if(fifth_power(i)){
sum+=i;
System.out.println(i);
}
}
}
public static int[] digits(int n){
char[] num=String.valueOf(n).toCharArray();
int[] nums=new int[num.length];
for(int i=0;i<nums.length;i++){
nums[i]=Character.getNumericValue(num[i]);
}
return nums;
}
public static boolean fifth_power(int n){
int sum=0;
for(int i:digits(n)){
sum+=(int)Math.pow(i, 2);
}
return sum==n && String.valueOf(n).length()>1 ? true:false;
}
}
================================================
FILE: ProjectEuler/Distinct_powers.java
================================================
import java.math.BigInteger;
import java.util.ArrayList;
public class Distinct_powers {
public static void main(String[] args) {
ArrayList<BigInteger> power=new ArrayList<BigInteger>();
for(int i=2;i<=100;i++){
for(int j=2;j<=100;j++){
BigInteger num=BigInteger.valueOf(i).pow(j);
if(!power.contains(num)){
power.add(num);
System.out.println(i+" "+j+" "+num);
}
}
}
System.out.println(power.size());
}
}
================================================
FILE: ProjectEuler/Even_fibonacci_sum.java
================================================
import java.util.ArrayList;
public class Even_fibonacci_sum {
public static void main(String[] args) {
ArrayList<Integer> fib=new ArrayList<Integer>();
fib.add(1);
fib.add(2);
int sum=2;
while(fib.get(fib.size()-1) <= 4000000){
int i=2;
fib.add(fib.get(i-1)+fib.get(i-2));
if(fib.get(i)%2==0){
sum+=fib.get(i);
}
i++;
}
System.out.println(Math.pow(2, 1000));
System.out.println(sum);
}
}
================================================
FILE: ProjectEuler/Factorial_digit_sum.java
================================================
import java.math.BigInteger;
public class Factorial_digit_sum {
public static void main(String[] args) {
System.out.println(sum_digits(factorial(100)));
}
public static BigInteger factorial(int num){
BigInteger prod=BigInteger.valueOf(1);
for(int i=num;i>1;i--){
prod=prod.multiply(BigInteger.valueOf(i));
}
return prod;
}
public static double sum_digits(BigInteger n){
String num=String.valueOf(n);
int sum=0;
for(int i=0;i<num.length();i++){
sum+=Integer.parseInt(num.substring(i,i+1));
}
return sum;
}
}
================================================
FILE: ProjectEuler/Grid_product_maximum.java
================================================
import java.util.Arrays;
public class Grid_product_maximum {
public static void main(String[] args) {
String g= "08 02 22 97 38 15 00 40 00 75 04 05 07 78 52 12 50 77 91 08 ";
String g2= "49 49 99 40 17 81 18 57 60 87 17 40 98 43 69 48 04 56 62 00 ";
String g3= "81 49 31 73 55 79 14 29 93 71 40 67 53 88 30 03 49 13 36 65 ";
String g4= "52 70 95 23 04 60 11 42 69 24 68 56 01 32 56 71 37 02 36 91 ";
String g5= "22 31 16 71 51 67 63 89 41 92 36 54 22 40 40 28 66 33 13 80 ";
String g6= "24 47 32 60 99 03 45 02 44 75 33 53 78 36 84 20 35 17 12 50 ";
String g7= "32 98 81 28 64 23 67 10 26 38 40 67 59 54 70 66 18 38 64 70 ";
String g8= "67 26 20 68 02 62 12 20 95 63 94 39 63 08 40 91 66 49 94 21 ";
String g9= "24 55 58 05 66 73 99 26 97 17 78 78 96 83 14 88 34 89 63 72 ";
String g10= "21 36 23 09 75 00 76 44 20 45 35 14 00 61 33 97 34 31 33 95 ";
String g11= "78 17 53 28 22 75 31 67 15 94 03 80 04 62 16 14 09 53 56 92 ";
String g12="16 39 05 42 96 35 31 47 55 58 88 24 00 17 54 24 36 29 85 57 ";
String g13= "86 56 00 48 35 71 89 07 05 44 44 37 44 60 21 58 51 54 17 58 ";
String g14= "19 80 81 68 05 94 47 69 28 73 92 13 86 52 17 77 04 89 55 40 ";
String g15= "04 52 08 83 97 35 99 16 07 97 57 32 16 26 26 79 33 27 98 66 ";
String g16= "88 36 68 87 57 62 20 72 03 46 33 67 46 55 12 32 63 93 53 69 ";
String g17= "04 42 16 73 38 25 39 11 24 94 72 18 08 46 29 32 40 62 76 36 ";
String g18= "20 69 36 41 72 30 23 88 34 62 99 69 82 67 59 85 74 04 36 16 ";
String g19= "20 73 35 29 78 31 90 01 74 31 49 71 48 86 81 16 23 57 05 54 ";
String g20= "01 70 54 71 83 51 54 69 16 92 33 48 61 43 52 01 89 19 67 48 ";
StringBuilder grid_string=new StringBuilder();
grid_string.append(g+g2+g3+g4+g5+g6+g7+g8+g9+g10+g11+g12+g13+g14+g15+g16+g17+g18+g19+g20);
int[][] grid=new int[20][20];
String[] arr=grid_string.toString().split(" ");
for(int i=0;i<grid.length; i++){
for(int j=0;j<grid[i].length;j++){
grid[i][j]=Integer.parseInt(arr[20*i+j]);
}
}
System.out.println(Math.max(Math.max(max_prod_horizontal(grid), max_prod_vertical(grid)), Math.max(max_prod_diagonal_right(grid), max_prod_diagonal_left(grid))));
}
public static int max_prod_horizontal(int[][] grid){
int max=0;
for(int[] arr:grid){
for(int i=0;i<arr.length-3;i++){
max=Math.max(max, arr[i]*arr[i+1]*arr[i+2]*arr[i+3]);
}
}
return max;
}
public static int max_prod_vertical(int[][] grid){
int max=0;
for(int i=0;i<grid.length;i++){
for(int j=0;j<grid.length-3;j++){
max=Math.max(max, grid[j][i]*grid[j+1][i]*grid[j+2][i]*grid[j+3][i]);
}
}
return max;
}
public static int max_prod_diagonal_right(int[][] grid){
int max=0;
for(int i=0;i<grid.length-3;i++){
for(int j=0;j<grid.length-3;j++){
max=Math.max(max, grid[i][j]*grid[i+1][j+1]*grid[i+2][j+2]*grid[i+3][j+3]);
}
}
return max;
}
public static int max_prod_diagonal_left(int[][] grid){
int max=0;
for(int i=grid.length-1;i>=3;i--){
for(int j=grid.length-1;j>=3;j--){
max=Math.max(max, grid[i][j]*grid[i-1][j-1]*grid[i-2][j-2]*grid[i-3][j-3]);
}
}
return max;
}
}
================================================
FILE: ProjectEuler/Highly_divisible_triangular.java
================================================
import java.util.ArrayList;
public class Highly_divisible_triangular {
public static void main(String[] args) {
int index=1;
int max_divisors=0;
int i=1;
while(max_divisors<=500){
max_divisors=Math.max(max_divisors, num_divisors(i));
index++;
i+=index;
}
System.out.println("The "+index+"th triangle number, "+i+", has "+max_divisors+" divisors");
}
public static int num_divisors(int n){
int num=0;
for(int i=2;i<(int)(n/2)+1;i++){
if(n%i==0){
num++;
}
}
return num+2;
}
}
================================================
FILE: ProjectEuler/Large_sum.java
================================================
public class Large_sum {
public static void main(String[] args) {
String num="37107287533902102798797998220837590246510135740250463769376774900097126481248969700780504170182605387432498619952474105947423330951305812372661730962991942213363574161572522430563301811072406154908250230675882075393461711719803104210475137780632466768926167069662363382013637841838368417873436172675728112879812849979408065481931592621691275889832738442742289174325203219235894228767964876702721893184745144573600130643909116721685684458871160315327670386486105843025439939619828917593665686757934951621764571418565606295021572231965867550793241933316490635246274190492910143244581382266334794475817892575867718337217661963751590579239728245598838407582035653253593990084026335689488301894586282278288018119938482628201427819413994056758715117009439035398664372827112653829987240784473053190104293586865155060062958648615320752733719591914205172558297169388870771546649911559348760353292171497005693854370070576826684624621495650076471787294438377604532826541087568284431911906346940378552177792951453612327252500029607107508256381565671088525835072145876576172410976447339110607218265236877223636045174237069058518606604482076212098132878607339694128114266041808683061932846081119106155694051268969251934325451728388641918047049293215058642563049483624672216484350762017279180399446930047329563406911573244438690812579451408905770622942919710792820955037687525678773091862540744969844508330393682126183363848253301546861961243487676812975343759465158038628759287849020152168555482871720121925776695478182833757993103614740356856449095527097864797581167263201004368978425535399209318374414978068609844840309812907779179908821879532736447567559084803087086987551392711854517078544161852424320693150332599594068957565367821070749269665376763262354472106979395067965269474259770973916669376304263398708541052684708299085211399427365734116182760315001271653786073615010808570091499395125570281987460043753582903531743471732693212357815498262974255273730794953759765105305946966067683156574377167401875275889028025717332296191766687138199318110487701902712526768027607800301367868099252546340106163286652636270218540497705585629946580636237993140746255962240744869082311749777923654662572469233228109171419143028819710328859780666976089293863828502533340334413065578016127815921815005561868836468420090470230530811728164304876237919698424872550366387845831148769693215490281042402013833512446218144177347063783299490636259666498587618221225225512486764533677201869716985443124195724099139590089523100588229554825530026352078153229679624948164195386821877476085327132285723110424803456124867697064507995236377742425354112916842768655389262050249103265729672370191327572567528565324825826546309220705859652229798860272258331913126375147341994889534765745501184957014548792889848568277260777137214037988797153829820378303147352772158034814451349137322665138134829543829199918180278916522431027392251122869539409579530664052326325380441000596549391598795936352974615218550237130764225512118369380358038858490341698116222072977186158236678424689157993532961922624679571944012690438771072750481023908955235974572318970677254791506150550495392297953090112996751986188088225875314529584099251203829009407770775672113067397083047244838165338735023408456470580773088295917476714036319800818712901187549131054712658197623331044818386269515456334926366572897563400500428462801835170705278318394258821455212272512503275512160354698120058176216521282765275169129689778932238195734329339946437501907836945765883352399886755061649651847751807381688378610915273579297013376217784275219262340194239963916804498399317331273132924185707147349566916674687634660915035914677504995186714302352196288948901024233251169136196266227326746080059154747183079839286853520694694454072476841822524674417161514036427982273348055556214818971426179103425986472045168939894221798260880768528778364618279934631376775430780936333301898264209010848802521674670883215120185883543223812876952786713296124747824645386369930090493103636197638780396218407357239979422340623539380833965132740801111666627891981488087797941876876144230030984490851411606618262936828367647447792391803351109890697907148578694408955299065364044742557608365997664579509666024396409905389607120198219976047599490197230297649139826800329731560371200413779037855660850892521673093931987275027546890690370753941304265231501194809377245048795150954100921645863754710598436791786391670211874924319957006419179697775990283006991536871371193661495281130587638027841075444973307840789923115535562561142322423255033685442488917353448899115014406480203690680639606723221932041495354150312888033953605329934036800697771065056663195481234880673210146739058568557934581403627822703280826165707739483275922328459417065250945123252306082291880205877731971983945018088807242966198081119777158542502016545090413245809786882778948721859617721078384350691861554356628840622574736922845095162084960398013400172393067166682355524525280460972253503534226472524250874054075591789781264330331690";
System.out.println(num.length());
double sum=0;
for(int i=0; i<=4950;i+=50){
sum+=Double.parseDouble(num.substring(i, i+50));
}
System.out.println(sum);
String n=String.valueOf(sum);
System.out.println(n.substring(0, 10));
}
}
================================================
FILE: ProjectEuler/Largest_consecutive_product.java
================================================
public class Largest_consecutive_product {
public static void main(String[] args) {
String num="7316717653133062491922511967442657474235534919493496983520312774506326239578318016984801869478851843858615607891129494954595017379583319528532088055111254069874715852386305071569329096329522744304355766896648950445244523161731856403098711121722383113622298934233803081353362766142828064444866452387493035890729629049156044077239071381051585930796086670172427121883998797908792274921901699720888093776657273330010533678812202354218097512545405947522435258490771167055601360483958644670632441572215539753697817977846174064955149290862569321978468622482839722413756570560574902614079729686524145351004748216637048440319989000889524345065854122758866688116427171479924442928230863465674813919123162824586178664583591245665294765456828489128831426076900422421902267105562632111110937054421750694165896040807198403850962455444362981230987879927244284909188845801561660979191338754992005240636899125607176060588611646710940507754100225698315520005593572972571636269561882670428252483600823257530420752963450";
int max=prod(num.substring(0,13));
for(int i=1;i<=num.length()-13;i++){
if(prod(num.substring(i,i+13)) > max || (-1*prod(num.substring(i,i+13))) > max){
max=prod(num.substring(i,i+13));
}
}
System.out.println(max);
}
public static int prod(String n){
String[] nums=n.split("");
int prod=1;
for(String i:nums){
prod*=Integer.parseInt(i);
}
return prod;
}
}
================================================
FILE: ProjectEuler/Lexicogrphic_permutations.java
================================================
import java.util.ArrayList;
import java.lang.*;
public class Lexicogrphic_permutations {
public static void main(String[] args) {
}
public static void sort(ArrayList<Integer> perms){
int index=0;
while(index!=perms.size()){
int min=find_min(perms, index);
swap(perms, index, min);
}
}
public static void swap(ArrayList<Integer> arr, int index_a, int index_b){
int temp=arr.get(index_a);
arr.set(index_a, arr.get(index_b));
arr.set(index_b, temp);
}
public static int find_min(ArrayList<Integer> arr, int start_index){
int min=start_index;
for(int i=start_index;i<arr.size();i++){
if(arr.get(i)<arr.get(min)){
min=i;
}
}
return min;
}
}
================================================
FILE: ProjectEuler/MATH_TOOLBOX.java
================================================
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
public interface MATH_TOOLBOX {
public int run(int a, int b);
}
class factorial implements MATH_TOOLBOX{
public int run(int n, int x){
int prod=1;
for(int i=n;i>1;i--){
prod*=i;
}
return prod;
}
}
class sum_digits_square implements MATH_TOOLBOX{
public int run(int i, int x){
char[] digits=String.valueOf(i).toCharArray();
int sum=0;
for(char c:digits){
sum+=Math.pow((double)(Character.getNumericValue(c)), 2);
}
return sum;
}
}
class main{
public static void main(String[] args){
List<HashMap<MATH_TOOLBOX, String>> functions=new ArrayList<HashMap<MATH_TOOLBOX, String>>();
new HashMap<MATH_TOOLBOX, String>();
functions.add(new HashMap<MATH_TOOLBOX, String>());
}
}
================================================
FILE: ProjectEuler/Names_scores.java
================================================
import java.io.BufferedReader;
import java.io.FileReader;
import java.util.Arrays;
public class Names_scores {
public static void main(String[] args) {
//Initialize array containing names from text file
String fileName="names.txt";
String[] names = null;
try{
FileReader inputFile = new FileReader(fileName);
BufferedReader bufferReader = new BufferedReader(inputFile);
String line=bufferReader.readLine();
names=line.split(",");
bufferReader.close();
}
catch(Exception e){
}
//Sort array of names alphabetically
Arrays.sort(names);
//Iterate through array and calculate score, adding to total sum
int total_score=0;
for(int i=0;i<names.length;i++){
int score=0;
for(char letter:names[i].toCharArray()){
score+="ABCDEFGHIJKLMNOPQRSTUVWXYZ".indexOf(letter)+1;
}
total_score+=(score*(i+1));
}
System.out.println(total_score);
}
}
================================================
FILE: ProjectEuler/Nontrivial_digit_cancelling_fractions.java
================================================
public class Nontrivial_digit_cancelling_fractions {
public static void main(String[] args) {
}
public static boolean cancelling(int n, int d){
String num=String.valueOf(n);
String den=String.valueOf(d);
if(num.substring(0,1)== den.substring(0,1) ||
num.substring(1)== den.substring(0,1) ||
num.substring(0,1)== den.substring(1) ||
num.substring(1)== den.substring(1)){
}
return true;
}
}
================================================
FILE: ProjectEuler/Nth_digit_powers.java
================================================
import java.lang.Math;
import java.util.*;
public class Nth_digit_powers {
public static void main(String[] args) {
Date start=new Date();
int num=0;
for(int i=1;i<1000000000;i++){
double pow= Math.pow(i, 1.0/(String.valueOf(i).length()));
if(pow==(int)(pow)){
num++;
}
}
System.out.println(num);
Date end=new Date();
System.out.println("Run time = "+ (start.getTime() - end.getTime())/1000.0+" seconds");
}
}
================================================
FILE: ProjectEuler/Number_letter_counts.java
================================================
public class Number_letter_counts {
public static void main(String[] args) {
int digits=36;
int teens=70;
int tens=46;
int ninety_nine=digits*9+teens+tens*10;
int hundreds=(digits+(7*9))*100;
int ands=99*9*3;
int thousand=11;
System.out.println(ninety_nine*10+hundreds+ands+thousand);
}
}
/*
one two three four five six seven eight nine ten eleven twelve thirteen fourteen fifteen sixteen seventeen eighteen nineteen
twenty thirty forty fifty sixty seventy eighty ninety
hundred
*/
================================================
FILE: ProjectEuler/PLAYGROUND.java
================================================
import java.io.*;
import java.math.*;
import java.text.*;
import java.util.*;
@SuppressWarnings("unused")
class PLAYGROUND{
static int[] order_initial;
static int[] order_final;
@SuppressWarnings("resource")
public static void main (String[] args) throws IOException
{
System.out.println("\n1. Add a task\n"+"2. Display the next task to be completed\n"+"3. Mark task as completed\n"+"4. Display last task completed\n"+"5. Return last task completed to the task to do list\n"+"6. Display the employee information\n"+"7. Exit");
}
public static ArrayList<String> removeDuplicates(ArrayList<String> list) {
ArrayList<String> result = new ArrayList<>();
HashSet<String> set = new HashSet<>();
for (String item : list) {
if (!set.contains(item)){
result.add(item);
set.add(item);
}
}
return result;
}
//Neccessariliy array of distinct integers
public static int indexOf(int element, int[] arr){
for(int i=0;i<arr.length;i++){
if(arr[i]==element){
return i;
}
}
return -1;
}
public static int cycle(int i, int[] temp){
int index = indexOf(i, order_final);
int n=order_final[index];
temp[index]=i;
return n;
}
public static BigInteger factorial2(int num){
BigInteger one=BigInteger.valueOf(1);
BigInteger prod=one;
for(BigInteger i=BigInteger.valueOf(num);i.min(one)==one;i.subtract(one)){
prod=prod.multiply(i);
}
return prod;
}
public static int factorial(int num){
int prod=1;
for(int i=num;i>1;i--){
prod*=i;
}
return prod;
}
public static int sum_digits_square(int i){
if(i==1 || i==89){
return i;
}
char[] digits=String.valueOf(i).toCharArray();
int sum=0;
for(char c:digits){
sum+=Math.pow((double)(Character.getNumericValue(c)), 2);
}
return sum_digits_square(sum);
}
public static boolean triangle_word(String n){
ArrayList<Integer> triangles=new ArrayList<Integer>();
int num=0;
for(int index=1;index<500;index++){
num+=index;
triangles.add(num);
}
int sum=0;
for(char i:n.toCharArray()){
sum+=i-'A'+1;
}
return triangles.contains(sum) ? true:false;
}
public static int num_divisors(int n){
int num=0;
for(int i=2;i<(int)(n/2)+1;i++){
if(n%i==0){
num++;
}
}
return num+2;
}
public static ArrayList<Integer> primes(int a, int b){
ArrayList<Integer> list=new ArrayList<Integer>();
for(int i=a;i<=b;i++){
if(isPrime(i)){
list.add(i);
}
}
return list;
}
public static boolean isPrime(int n){
for(int i=2;i<n;i++){
if(n%i==0){
return false;
}
}
return true;
}
public static boolean amicable(int a, int b){
return sum_divisors(a)==b && sum_divisors(b)==a ? true:false;
}
public static int sum_divisors(int n){
int sum=0;
for(int i=2;i<(int)(n/2)+1;i++){
if(n%i==0){
sum+=i;
}
}
return sum+1;
}
}
================================================
FILE: ProjectEuler/Pandigital_prime.java
================================================
import java.util.ArrayList;
import java.util.Date;
public class Pandigital_prime {
public static void main(String[] args) {
Date start = new Date();
ArrayList<Integer> pans=new ArrayList<Integer>();
for(int i=7654321;i>2143;i-=2){
if(pandigital(i) && isPrime(i)){
pans.add(i);
}
}
System.out.println(pans.get(0));
Date end = new Date();
System.out.println("Run time = "+ (start.getTime() - end.getTime())/1000.0+" seconds");
}
public static boolean pandigital(int n){
String num=String.valueOf(n);
for(int i=num.length(); i>=1; i--){
if(!num.contains(Integer.toString(i))){
return false;
}
}
return true;
}
public static boolean isPrime(int n){
for(int i= (int)(Math.sqrt(n)+1);i>1;i--){
if(n%i==0){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/Permuted_multiples.java
================================================
import java.util.Date;
public class Permuted_multiples {
public static void main(String[] args) {
Date start = new Date();
for(int i=0; i< 1000000;i++){
if(same_digits(i,2*i) &&
same_digits(2*i, 3*i) &&
same_digits(3*i, 4*i) &&
same_digits(4*i, 5*i) &&
same_digits(5*i, 6*i)){
System.out.println(i);
}
}
Date end = new Date();
System.out.println("Run time = "+ (start.getTime() - end.getTime())/1000.0+" seconds");
}
public static boolean same_digits(int a, int b){
String num_a=String.valueOf(a);
String num_b=String.valueOf(b);
if(num_a.length()!=num_b.length()){
return false;
}
for(int i=0;i<num_a.length();i++){
if(!num_b.contains(num_a.substring(i, i+1))){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/Prime_Summation.java
================================================
import javax.swing.plaf.synth.SynthSeparatorUI;
public class Prime_Summation {
public static void main(String[] args) {
double sum=0;
double n=2000000;
for(double i=n-1;i>=2;i--){
if(isPrime(i)){
sum+=i;
}
}
System.out.println(sum+ "end");
}
public static boolean isPrime(double n){
for(double i=2;i<=(int)(Math.sqrt(n));i++){
if(n%i==0){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/Prime_factorization.java
================================================
import java.util.*;
public class Prime_factorization {
public static void main(String[] args) {
System.out.println(factor(646));
}
public static ArrayList<Double> factor(double n){
ArrayList<Double> factors=new ArrayList<Double>();
for(double i=n-1;i>=2;i--){
if(n%i==0 && isPrime(i)) {
n/=i;
factors.add(i);
i++;
}
}
return factors;
}
public static double return_max(ArrayList<Double> factors){
double max=factors.get(0);
for(double i:factors){
if(i>max){
max=i;
}
}
return max;
}
public static boolean isPrime(double n){
for(double i=2;i<n;i++){
if(n%i==0){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/Pythagorean_triplet.java
================================================
public class Pythagorean_triplet {
public static void main(String[] args) {
for(double a=1;a<1000;a++){
for(double b=1;b<1000;b++){
double c= Math.sqrt((Math.pow(a, 2))+(Math.pow(b, 2)));
if(a+b+c==1000){
System.out.println(a*b*c);
}
}
}
System.out.println("end");
}
}
================================================
FILE: ProjectEuler/README.md
================================================
# projecteuler
Math toolbox containing algorithms for Project Euler problems
================================================
FILE: ProjectEuler/Reverse_message.java
================================================
import java.util.*;
public class Reverse_message{
public static void main(String[] args){
System.out.println(reverse_words("find you will pain only go you recordings security the into if"));
}
public static String reverse_words(String message){
String[] words=message.split(" ");
String[] rev_words=new String[words.length];
for(int i=0;i<words.length;i++){
rev_words[i]=words[words.length-1-i];
}
StringBuilder builder=new StringBuilder();
for(String string: rev_words){
if(builder.length()>0){
builder.append(" ");
}
builder.append(string);
}
String rev_message=builder.toString();
return rev_message;
}
}
================================================
FILE: ProjectEuler/Smallest_multiple.java
================================================
public class Smallest_multiple {
public static void main(String[] args) {
for(int i=2520; i< (2.5*Math.pow(10,18)); i++){
int sum=0;
for(int k=20;k>1;k--){
if(i%k==0){
sum++;
}
}
if(sum==19){
System.out.println(i);
break;
}
}
}
}
================================================
FILE: ProjectEuler/Square_digit_chains.java
================================================
import java.util.ArrayList;
public class Square_digit_chains {
public static void main(String[] args) {
ArrayList<Integer> one=new ArrayList<Integer>();
one.add(1);
ArrayList<Integer> eightynine =new ArrayList<Integer>();
eightynine.add(89);
for(int i=2;i<1000;i++){
int n=i;
while(!(one.contains(n) || eightynine.contains(n))){
n=sum_digits_square(n);
}
if(one.contains(n)){
one.add(i);
}
if(eightynine.contains(n)){
eightynine.add(i);
}
}
System.out.println(eightynine.size());
}
public static int sum_digits_square(int n){
char[] digits=String.valueOf(n).toCharArray();
int sum=0;
for(char c:digits){
sum+=Math.pow((double)(Character.getNumericValue(c)), 2);
}
return sum;
}
}
================================================
FILE: ProjectEuler/Thousand_digit_fibonacci.java
================================================
import java.math.BigInteger;
import java.util.ArrayList;
public class Thousand_digit_fibonacci {
public static void main(String[] args) {
ArrayList<BigInteger> fib=new ArrayList<BigInteger>();
fib.add(BigInteger.valueOf(1));
fib.add(BigInteger.valueOf(1));
int i=0;
for(i=2;String.valueOf(fib.get(fib.size()-1)).length()<1000;i++)
fib.add(fib.get(i-1).add(fib.get(i-2)));
System.out.println(i);
}
}
================================================
FILE: ProjectEuler/Totient_maximum.java
================================================
import java.lang.Math;
public class Totient_maximum {
public static void main(String[] args) {
double max=0;
double max_index=1;;
for(double i=100000;i>1;i--){
double t=i/totient(i);
if(t>max){
max=t;
max_index=i;
}
}
System.out.println(max_index);
}
public static double gcd(double a, double b){
return (b==0) ? a:gcd(b, a%b);
}
public static double totient(double n){
double num=0;
for(double i=n;i>0;i--){
if(gcd(n, i)==1){
num++;
}
}
return num;
}
}
================================================
FILE: ProjectEuler/Totient_permutations.java
================================================
public class Totient_permutations {
public static void main(String[] args) {
double min=2;
double index=0;
for(double i=2;i<1000000;i++){
if(same_digits(i, totient(i)) && ((i/totient(i)) < min)){
min=i/totient(i);
index=i;
}
}
System.out.println(index);
}
public static double gcd(double a, double b){
return (b==0) ? a:gcd(b, a%b);
}
public static double totient(double n){
double num=0;
for(double i=n;i>0;i--){
if(gcd(n, i)==1){
num++;
}
}
return num;
}
public static boolean same_digits(double a, double b){
String num_a=String.valueOf(a);
String num_b=String.valueOf(b);
if(num_a.length()!=num_b.length()){
return false;
}
for(int i=0;i<num_a.length();i++){
if(!num_b.contains(num_a.substring(i, i+1))){
return false;
}
}
return true;
}
}
================================================
FILE: ProjectEuler/primes.java
================================================
import java.util.*;
public class primes{
public static void main(String[] args){
Scanner scan=new Scanner(System.in);
System.out.println("Enter an integer");
int num=scan.nextInt();
if(isPrime(num)){
System.out.println(num);
}
else{
System.out.println(factor(num));
}
}
public static List<Integer> factor(int n){
List<Integer> factors=new ArrayList<Integer>();
for(int i=n-1;i>=2;i--){
if(n%i==0 && isPrime(i)) {
n/=i;
factors.add(i);
i++;
}
}
return factors;
}
public static boolean isPrime(int n){
for(int i=2;i<n;i++){
if(n%i==0){
return false;
}
}
return true;
}
}
================================================
FILE: README.md
================================================
# Algorithms
[](https://opensource.org/licenses/MIT)
This respository is a collection of various useful algorithms and data structures along with their Java implementations, intended for educational use. This is a work in progress, so some algorithms may not be included. All files that have been added have been tested extensively and should be accurate, readable, and efficient. Feel free to suggest any algorithms that you'd like to see implemented in the future. Don't hesitate to contact me with any questions, concerns, or feedback (my contact information is at the bottom of this file). If you found this repository helpful, I'd love to know :)
## Table of Contents
* Algorithms
+ [Graph](https://github.com/jpa99/Algorithms#graph)
+ [Dynamic Programming](https://github.com/jpa99/Algorithms#dynamic-programming)
+ [Sorting](https://github.com/jpa99/Algorithms#sorting)
+ [Searching](https://github.com/jpa99/Algorithms#searching)
+ [Strings](https://github.com/jpa99/Algorithms#strings)
+ [Math](https://github.com/jpa99/Algorithms#math)
+ [Computational Geometry](https://github.com/jpa99/Algorithms#computational-geometry)
+ [Optimization](https://github.com/jpa99/Algorithms#optimization)
+ [Miscellaneous](https://github.com/jpa99/Algorithms#miscellaneous)
+ [Data Structures](https://github.com/jpa99/Algorithms#data-structures)
+ [Project Euler](https://github.com/jpa99/Algorithms#project-euler)
+ [Google Code Jam](https://github.com/jpa99/Algorithms#google-code-jam)
+ [USACO](https://github.com/jpa99/Algorithms#usaco)
* Resources
+ [Books](https://github.com/jpa99/Algorithms#books)
+ [Websites](https://github.com/jpa99/Algorithms#websites)
+ [Courses](https://github.com/jpa99/Algorithms#courses)
+ [Online Judges](https://github.com/jpa99/Algorithms#online-judges)
+ [Github Libraries](https://github.com/jpa99/Algorithms#github-libraries)
## Graph
* Graph Traversal
+ Breadth-First Search
+ Depth First Search
* Shortest Path
+ Dijkstra's Algorithm
+ Bellman-Ford
+ Floyd-Warshall
+ Johnson's Algorithm
* Minimum Spanning Tree
+ Kruskal's Algorithm
+ Prim's Algorithm
* Network Flow
+ Karger's Algorithm
+ Push-Relabel
+ Edmonds-Karp
+ Ford-Fulkerson
* Tarjan's Algorithm
* Topological Sort
* Strongly Connected Components
## Dynamic Programming
* 0-1 Knapsack
* Edit (Levenshtein) Distance
* Longest Increasing Subsequence
* Longest Common Subsequence
* Maximum Subset Sum
## Sorting
* Timsort
* Radix Sort
* Counting Sort
* Quicksort
* Heapsort
* Mergesort
* Insertion Sort
* Bubble Sort
* Selection Sort
* Bogosort
## Searching
* Linear
* Binary
* ith Order Statistic
+ Sort Select
+ Randomized Select
+ Heapselect
+ Quickselect
## Strings
* String Searching
+ Aho-Corasick
+ Z Algorithm
+ Knuth-Morris-Pratt
+ Boyer-Moore
+ Rabin-Karp
+ Brute Force
## Math/Number Theory
* Fibonacci
+ Binet's Formula
+ Iterative
+ Recursive (DP)
+ Matrix Exponentiation
+ Fast Doubling
* Euclid's Algorithm
* Fast Fourier Transform
* Primality Testing
+ Naive
+ Sieve of Erastothenes
+ Miller-Rabin
* Karatsuba's Algorithm
* Fast Exponentiation
* Strassen's Algorithm
## Computational Geometry
* Convex Hull
+ Graham Scan
+ Jarvis March
## Optimization
* Naive Optimization
* Simplex (LP)
* Simulated Annealing
* Genetic Algorithms
* Combinatoric Algorithms
## Miscellaneous
* Fisher-Yates Shuffle
* Kadane's Algorithm
* Subarray Inversions
## Data Structures
* Graph
* Tree
* Binary Tree
* Fenwick Tree (Binary Indexed Tree)
* Red-Black Tree
* AVL Tree
* B-Tree
* Suffix Tree
* Trie
* Hash Table
* Hash Map
* Stack
* Queue
* List
* LinkedList
## [Project Euler](https://github.com/jpa99/Algorithms/tree/master/ProjectEuler)
Interesting math problems that can be solved computationally; full problem set available [here](https://projecteuler.net/archives). The Project Euler folder contains the full inventory of problems I've implemented with it's own table of contents [here](https://github.com/jpa99/Algorithms/tree/master/ProjectEuler).
## [Google Code Jam](https://github.com/jpa99/Algorithms/tree/master/GoogleCodeJam)
Competitive programming style problems from [previous competitions](https://code.google.com/codejam/past-contests). The Google Code Jam folder contains the full inventory of problems I've implemented with it's own table of contents [here](https://github.com/jpa99/Algorithms/tree/master/GoogleCodeJam).
## [USACO](https://github.com/jpa99/Algorithms/tree/master/USACO)
Algorithmic problems from past USA Computing Olympiad contests, check out the full [problem database](http://www.usaco.org/index.php?page=contests). The USACO folder contains the full inventory of problems I've implemented with it's own table of contents [here](https://github.com/jpa99/Algorithms/tree/master/USACO).
Developed By
------------
* Joel P. Abraham - <joelpabraham@gmail.com>
<a href="https://www.linkedin.com/in/joelpabraham/">
<img alt="Add me to Linkedin" src="https://image.freepik.com/iconos-gratis/boton-del-logotipo-linkedin_318-84979.png" height="60" width="60"/>
</a>
================================================
FILE: Se
gitextract_4er3oeyk/
├── .gitignore
├── Computational Geometry/
│ ├── GrahamScan.java
│ ├── JarvisMarch.java
│ └── README.md
├── DP/
│ ├── Edit_Distance.java
│ ├── Knapsack.java
│ ├── LCS.java
│ ├── README.md
│ └── maxDonations.java
├── Data Structures/
│ ├── BinaryTree.java
│ ├── Binary_Indexed_Tree.java
│ ├── Edge.java
│ ├── Graphs.java
│ ├── README.md
│ ├── Tree.java
│ └── Vertex.java
├── GoogleCodeJam/
│ ├── ABBA.java
│ ├── Alphabet_Cake.java
│ ├── BFCalculator.java
│ ├── Bathroom_Stalls.java
│ ├── Close_Match.java
│ ├── Coin_Jam.java
│ ├── Counting_Sheep.java
│ ├── CrossOver.java
│ ├── Digits.java
│ ├── Oversized_Pancake_Flipper.java
│ ├── Pancakes.java
│ ├── Prison_Break.java
│ ├── README.md
│ ├── Solution.java
│ ├── Super_Substrings.java
│ └── Tidy_Numbers.java
├── Graph/
│ ├── BFS.java
│ ├── Bellman_Ford.java
│ ├── DFS.java
│ ├── Dijkstra.java
│ ├── Edge.java
│ ├── Floyd_Warshall.java
│ ├── Ford_Fulkerson.java
│ ├── Graph_Traversal.java
│ ├── Graphs.java
│ ├── Johnson
│ ├── Karger.java
│ ├── Prim.java
│ ├── README.md
│ └── Vertex.java
├── LICENSE
├── Math/
│ └── README.md
├── Miscellaneous/
│ ├── Fisher_Yates.java
│ ├── Matrix_Exponentiation.java
│ ├── README.md
│ └── Subarray_Inversions.java
├── Optimization/
│ ├── LightConfigurationOptimization.java
│ ├── LightConfigurationOptimizationSA.java
│ ├── LocationalOptimizationIterative.java
│ └── README.md
├── ProjectEuler/
│ ├── Amicable_numbers.java
│ ├── Coded_triangle_numbers.java
│ ├── Collatz_sequence.java
│ ├── Combinatoric_selections.java
│ ├── Concealed_square.java
│ ├── Consecutive_distinct_prime_factors.java
│ ├── Counting_sundays.java
│ ├── Digit_factorials.java
│ ├── Digit_fifth_power.java
│ ├── Distinct_powers.java
│ ├── Even_fibonacci_sum.java
│ ├── Factorial_digit_sum.java
│ ├── Grid_product_maximum.java
│ ├── Highly_divisible_triangular.java
│ ├── Large_sum.java
│ ├── Largest_consecutive_product.java
│ ├── Lexicogrphic_permutations.java
│ ├── MATH_TOOLBOX.java
│ ├── Names_scores.java
│ ├── Nontrivial_digit_cancelling_fractions.java
│ ├── Nth_digit_powers.java
│ ├── Number_letter_counts.java
│ ├── PLAYGROUND.java
│ ├── Pandigital_prime.java
│ ├── Permuted_multiples.java
│ ├── Prime_Summation.java
│ ├── Prime_factorization.java
│ ├── Pythagorean_triplet.java
│ ├── README.md
│ ├── Reverse_message.java
│ ├── Smallest_multiple.java
│ ├── Square_digit_chains.java
│ ├── Thousand_digit_fibonacci.java
│ ├── Totient_maximum.java
│ ├── Totient_permutations.java
│ └── primes.java
├── README.md
├── Searching/
│ └── README.md
├── Sorting/
│ ├── Bogosort.java
│ ├── Bubble_Sort.java
│ ├── Counting_Sort.java
│ ├── Heapsort.java
│ ├── Insertion_Sort.java
│ ├── Mergesort.java
│ ├── Quicksort.java
│ ├── README.md
│ ├── Radix_Sort.java
│ ├── Selection_Sort.java
│ ├── Sorting.java
│ └── Timsort.java
├── Strings/
│ ├── Boyer_Moore.java
│ ├── KMP.java
│ ├── Naive_String_Searching.java
│ ├── README.md
│ ├── Rabin_Karp.java
│ ├── String_Algorithms.java
│ ├── Strings_d.in
│ └── Strings_random.in
└── USACO/
├── AngryCows.java
├── AngryCows2.java
├── BovineGenomics.java
├── BovineGenomics_bruteforce.java
├── BuildGates.java
├── CircularBarn.java
├── CowCode.java
├── CowDanceShow.java
├── CowTip.java
├── FencePainting.java
├── HPS.java
├── Haybales.java
├── HoofPaperScissors.java
├── LoadBalancing.java
├── MilkPails.java
├── ModernArt.java
├── ModernArt2.java
├── ModernArt2_bruteforce.java
├── MowingField.java
├── NotLast.java
├── PromotionCounting.java
├── README.md
├── SeqSum7.java
├── asdf.java
├── friday.java
├── gift1.java
├── marathon.java
├── reorder.java
├── ride.java
├── sample.java
└── test.java
SYMBOL INDEX (590 symbols across 126 files)
FILE: Computational Geometry/GrahamScan.java
class GrahamScan (line 4) | public class GrahamScan {
method main (line 27) | public static void main(String[] args) {
method graham (line 40) | public static Stack<int[]> graham(int[][] points){
method polarbubblesort (line 76) | public static int[][] polarbubblesort(int[][] arr, int[] min, int[] pa...
method angle (line 94) | public static double angle(int[] a, int[] b, int[] c){
method dot (line 107) | public static double dot(int[] v1, int[] v2){
method norm (line 111) | public static double norm(int[] v){
method cross (line 115) | public static int cross(int[] v1, int[] v2){
method d (line 119) | public static double d(int[] a, int[] b){
FILE: Computational Geometry/JarvisMarch.java
class JarvisMarch (line 4) | public class JarvisMarch {
method main (line 26) | public static void main(String[] args) {
method jarvis (line 39) | public static Stack<int[]> jarvis(int[][] points){
method angle (line 79) | public static double angle(int[] a, int[] b, int[] c){
method dot (line 92) | public static double dot(int[] v1, int[] v2){
method norm (line 96) | public static double norm(int[] v){
method cross (line 100) | public static int cross(int[] v1, int[] v2){
method d (line 104) | public static double d(int[] a, int[] b){
FILE: DP/Edit_Distance.java
class Edit_Distance (line 3) | public class Edit_Distance {
method main (line 22) | public static void main(String[] args) {
method editDistanceIterative (line 37) | public static int editDistanceIterative(String a, String b){
method editDistanceTD (line 53) | public static int editDistanceTD(String a, String b){
FILE: DP/Knapsack.java
class Knapsack (line 4) | public class Knapsack {
method main (line 23) | public static void main(String[] args){
method knapsackTD (line 33) | public static int knapsackTD(int maxweight, boolean[] insert){
method fractionalknapsack (line 45) | public static void fractionalknapsack(){
FILE: DP/LCS.java
class LCS (line 4) | public class LCS {
method main (line 27) | public static void main(String[] args) {
method iterativeLCS (line 38) | public static int[] iterativeLCS(int[] a, int[] b){
method recursiveLCS (line 69) | public static int recursiveLCS(int a, int b){
FILE: DP/maxDonations.java
class maxDonations (line 2) | public class maxDonations {
method main (line 22) | public static void main(String[] args) {
method maxDonations (line 34) | public static int maxDonations(int start, int end){
FILE: Data Structures/BinaryTree.java
class BinaryTree (line 4) | public class BinaryTree {
method main (line 6) | public static void main(String[] args) {
method createBinaryTree (line 23) | public static BinaryTreeNode createBinaryTree(int[] binaryTreeArray){
method balance (line 34) | public static BinaryTreeNode balance(BinaryTreeNode tree){
class BinaryTreeNode (line 40) | static class BinaryTreeNode{
method BinaryTreeNode (line 45) | public BinaryTreeNode(int val){
method toString (line 51) | public String toString(){
method toArrayList (line 57) | public ArrayList<Integer> toArrayList(){
method toArray (line 67) | public int[] toArray(){
FILE: Data Structures/Binary_Indexed_Tree.java
class Binary_Indexed_Tree (line 1) | public class Binary_Indexed_Tree {
method main (line 3) | public static void main(String[] args) throws IOException {
class BIT (line 17) | static class BIT{
method BIT (line 21) | public BIT(int n){
method update (line 26) | public void update(int index, int val){
method read (line 34) | public int read(int index){
FILE: Data Structures/Edge.java
class Edge (line 2) | public class Edge {
method Edge (line 11) | public Edge(int weight, int value1, int value2){
method Edge (line 17) | public Edge(int weight, int value1, int value2, boolean directed){
method incident (line 25) | public boolean incident(int vertex){
method getVertex1 (line 29) | public Vertex getVertex1(){
method getVertex2 (line 33) | public Vertex getVertex2(){
method getWeight (line 37) | public int getWeight(){
method getDirected (line 41) | public boolean getDirected(){
method makeDirected (line 45) | public void makeDirected(){
method swap (line 49) | public void swap(){
method toString (line 55) | public String toString(){
FILE: Data Structures/Graphs.java
class Graphs (line 2) | public class Graphs {
method Graphs (line 9) | public Graphs(Vertex[] vertices, Edge[] edges){
method hasVertex (line 15) | public boolean hasVertex(Vertex v){
method getCost (line 25) | public int getCost(){
method getEdges (line 33) | public Edge[] getEdges(){
method vertex (line 37) | public String[] vertex(){
method getVertices (line 45) | public Vertex[] getVertices(){
method toString (line 49) | public String toString(){
FILE: Data Structures/Tree.java
class Tree (line 3) | public class Tree {
method main (line 5) | public static void main(String[] args) {
class Node (line 12) | public static class Node<T> {
method Node (line 17) | public Node(T data) {
method Node (line 21) | public Node(T data, Node<T> parent) {
method getChildren (line 26) | public List<Node<T>> getChildren() {
method setParent (line 30) | public void setParent(Node<T> parent) {
method add (line 35) | public void add(T data) {
method add (line 41) | public void add(Node<T> child) {
method data (line 46) | public T data() {
method setData (line 50) | public void setData(T data) {
method isRoot (line 54) | public boolean isRoot() {
method isLeaf (line 58) | public boolean isLeaf() {
method removeParent (line 62) | public void removeParent() {
class Graph (line 68) | public class Graph {
method Graph (line 73) | public Graph(Vertex[] vertices, Edge[] edges){
method hasVertex (line 79) | public boolean hasVertex(Vertex v){
method getCost (line 89) | public int getCost(){
method getEdges (line 97) | public Edge[] getEdges(){
method vertex (line 101) | public String[] vertex(){
method getVertices (line 109) | public Vertex[] getVertices(){
method toString (line 113) | public String toString(){
class Edge (line 131) | public class Edge {
method Edge (line 138) | public Edge(int weight, int value1, int value2){
method Edge (line 144) | public Edge(int weight, int value1, int value2, boolean directed){
method incident (line 152) | public boolean incident(int vertex){
method getVertex1 (line 156) | public Vertex getVertex1(){
method getVertex2 (line 160) | public Vertex getVertex2(){
method getWeight (line 164) | public int getWeight(){
method getDirected (line 168) | public boolean getDirected(){
method makeDirected (line 172) | public void makeDirected(){
method swap (line 176) | public void swap(){
method toString (line 182) | public String toString(){
class Vertex (line 189) | public class Vertex {
method Vertex (line 192) | public Vertex(int val){
method getValue (line 196) | public int getValue(){
method toString (line 200) | public String toString(){
FILE: Data Structures/Vertex.java
class Vertex (line 1) | static class Vertex{
method Vertex (line 5) | public Vertex(int name, int distance){
method toString (line 10) | public String toString(){
FILE: GoogleCodeJam/ABBA.java
class ABBA (line 2) | public class ABBA {
method main (line 3) | public static void main(String[] args) throws Exception{
method canObtain (line 11) | public static String canObtain(String initial, String target){
FILE: GoogleCodeJam/Alphabet_Cake.java
class Alphabet_Cake (line 8) | public class Alphabet_Cake {
method main (line 14) | public static void main(String[] args) throws Exception{
method print (line 79) | public static <T> void print(T t){
class Scan (line 84) | static class Scan{
method Scan (line 88) | public Scan(String file) throws IOException{
method next (line 93) | String next(){
method nextInt (line 105) | int nextInt(){
method nextLong (line 109) | long nextLong(){
method nextDouble (line 113) | double nextDouble(){
method nextLine (line 117) | String nextLine(){
FILE: GoogleCodeJam/BFCalculator.java
class BFCalculator (line 2) | public class BFCalculator {
method main (line 4) | public static void main(String[] args) {
FILE: GoogleCodeJam/Bathroom_Stalls.java
class Bathroom_Stalls (line 6) | public class Bathroom_Stalls {
method main (line 8) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Close_Match.java
class Close_Match (line 7) | public class Close_Match {
method main (line 9) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Coin_Jam.java
class Coin_Jam (line 5) | public class Coin_Jam {
method main (line 7) | public static void main(String[] args) throws Exception{
method convert (line 45) | public static int convert(String s, int base){
method out (line 58) | public static int[] out(String s){
method isDiv (line 74) | public static boolean isDiv(String n){
method divisors (line 90) | public static String divisors(String n){
method binary_convert (line 105) | public static String binary_convert(int n, int len){
method convertss (line 121) | public static int convertss(String s, int base){
method gen_bin_array (line 132) | public static String[] gen_bin_array(int len){
FILE: GoogleCodeJam/Counting_Sheep.java
class Counting_Sheep (line 4) | public class Counting_Sheep {
method main (line 6) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/CrossOver.java
class CrossOver (line 3) | public class CrossOver {
method main (line 5) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Digits.java
class Digits (line 9) | public class Digits {
method main (line 11) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Oversized_Pancake_Flipper.java
class Oversized_Pancake_Flipper (line 4) | public class Oversized_Pancake_Flipper {
method main (line 6) | public static void main(String[] args) throws Exception{
method flip (line 77) | public static boolean[] flip(int start, int size, boolean[] pancakes){
method indexOf (line 83) | public static int indexOf(boolean[] pancake, boolean element){
FILE: GoogleCodeJam/Pancakes.java
class Pancakes (line 4) | public class Pancakes {
method main (line 6) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Prison_Break.java
class Prison_Break (line 4) | public class Prison_Break {
method main (line 6) | public static void main(String[] args) throws Exception{
FILE: GoogleCodeJam/Solution.java
class Solution (line 7) | public class Solution {
method prison (line 9) | static long prison(int n, int m, int[] h, int[] v) {
method main (line 64) | public static void main(String[] args) throws IOException{
FILE: GoogleCodeJam/Super_Substrings.java
class Super_Substrings (line 4) | public class Super_Substrings {
method main (line 6) | public static void main(String[] args) throws Exception{
method sum (line 26) | public static int sum(int num){
FILE: GoogleCodeJam/Tidy_Numbers.java
class Tidy_Numbers (line 4) | public class Tidy_Numbers {
method main (line 6) | public static void main(String[] args) throws Exception {
method isTidy (line 49) | public static int isTidy(long n){
method nines (line 60) | public static String nines(String n){
FILE: Graph/BFS.java
class BFS (line 27) | public class BFS {
method main (line 52) | public static void main(String[] args) {
method QueueBFSList (line 80) | public static ArrayList<Integer> QueueBFSList(ArrayList<ArrayList<Inte...
method IterativeBFSList (line 102) | public static ArrayList<Integer> IterativeBFSList(ArrayList<ArrayList<...
method QueueBFSMatrix (line 124) | public static ArrayList<Integer> QueueBFSMatrix(boolean[][] adjmat, in...
method IterativeBFSMatrix (line 146) | public static ArrayList<Integer> IterativeBFSMatrix(boolean[][] adjmat...
method mat2list (line 169) | public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
method list2mat (line 183) | public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjli...
method display (line 195) | public static void display(boolean[][] adj, String name){
FILE: Graph/Bellman_Ford.java
class Bellman_Ford (line 22) | public class Bellman_Ford {
method main (line 41) | public static void main(String[] args) {
method bellman_ford (line 68) | public static int bellman_ford(ArrayList<Vertex>[] adjlist, int source...
method display (line 96) | public static void display(boolean[][] adj, String name){
class Vertex (line 156) | static class Vertex{
method Vertex (line 160) | public Vertex(int val){
method Vertex (line 164) | public Vertex(int val, int weight){
method toString (line 170) | public String toString(){
method list2arr (line 175) | public static int[] list2arr(ArrayList<Integer> list){
method list2arr (line 179) | public static ArrayList<Integer> list2arr(int[] arr){
FILE: Graph/DFS.java
class DFS (line 27) | public class DFS {
method main (line 48) | public static void main(String[] args) {
method iterativeDFS (line 76) | public static ArrayList<Integer> iterativeDFS(ArrayList<ArrayList<Inte...
method recursiveDFS (line 98) | public static void recursiveDFS(ArrayList<ArrayList<Integer>> adjlist,...
method mat2list (line 109) | public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
method list2mat (line 123) | public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjli...
method display (line 134) | public static void display(boolean[][] adj, String name){
FILE: Graph/Dijkstra.java
class Dijkstra (line 22) | public class Dijkstra {
method main (line 45) | public static void main(String[] args) {
method dijkstra (line 90) | public static ArrayList<Integer> dijkstra(ArrayList<Vertex>[] adjlist,...
method display (line 126) | public static void display(boolean[][] adj, String name){
class Vertex (line 186) | static class Vertex implements Comparable<Vertex>{
method Vertex (line 190) | public Vertex(int name){
method Vertex (line 194) | public Vertex(int name, int val){
method toString (line 200) | public String toString(){
method compareTo (line 204) | public int compareTo(Vertex v){
method list2arr (line 209) | public static int[] list2arr(ArrayList<Integer> list){
method list2arr (line 213) | public static ArrayList<Integer> list2arr(int[] arr){
FILE: Graph/Edge.java
class Edge (line 2) | public class Edge {
method Edge (line 11) | public Edge(int weight, int value1, int value2){
method Edge (line 17) | public Edge(int weight, int value1, int value2, boolean directed){
method incident (line 25) | public boolean incident(int vertex){
method getVertex1 (line 29) | public Vertex getVertex1(){
method getVertex2 (line 33) | public Vertex getVertex2(){
method getWeight (line 37) | public int getWeight(){
method getDirected (line 41) | public boolean getDirected(){
method makeDirected (line 45) | public void makeDirected(){
method swap (line 49) | public void swap(){
method toString (line 55) | public String toString(){
FILE: Graph/Floyd_Warshall.java
class Floyd_Warshall (line 22) | public class Floyd_Warshall {
method main (line 45) | public static void main(String[] args) {
method floyd_warshall (line 72) | public static ArrayList<Integer> floyd_warshall(ArrayList<Vertex>[] ad...
method display (line 107) | public static void display(boolean[][] adj, String name){
class Vertex (line 167) | static class Vertex{
method Vertex (line 171) | public Vertex(int name){
method Vertex (line 175) | public Vertex(int name, int val){
method toString (line 181) | public String toString(){
method list2arr (line 186) | public static int[] list2arr(ArrayList<Integer> list){
method list2arr (line 190) | public static ArrayList<Integer> list2arr(int[] arr){
FILE: Graph/Ford_Fulkerson.java
class Ford_Fulkerson (line 23) | public class Ford_Fulkerson {
method main (line 43) | public static void main(String[] args){
method bfs (line 93) | public static int[] bfs(int[][] residual)
method dfs (line 123) | public static ArrayList<Integer> dfs(int[][] residual){
method residual (line 154) | public static int[][] residual(int[][] network, int[][] flow){
method display (line 172) | public static void display(int[][] adj, String name){
FILE: Graph/Graph_Traversal.java
class Graph_Traversal (line 23) | public class Graph_Traversal {
method main (line 27) | public static void main(String[] args) {
method iterativeDFS (line 106) | public static ArrayList<Integer> iterativeDFS(ArrayList<ArrayList<Inte...
method recursiveDFS (line 128) | public static void recursiveDFS(ArrayList<ArrayList<Integer>> adjlist,...
method bfs (line 139) | public static ArrayList<Integer> bfs(ArrayList<ArrayList<Integer>> adj...
method BFS (line 161) | public static ArrayList<Integer> BFS(ArrayList<ArrayList<Integer>> adj...
method bfsmatrix (line 183) | public static ArrayList<Integer> bfsmatrix(boolean[][] adjmat, int sou...
method BFSmatrix (line 205) | public static ArrayList<Integer> BFSmatrix(boolean[][] adjmat, int sou...
method mat2list (line 230) | public static ArrayList<ArrayList<Integer>> mat2list(boolean[][] adj){
method list2mat (line 244) | public static boolean[][] list2mat(ArrayList<ArrayList<Integer>> adjli...
method display (line 256) | public static void display(boolean[][] adj, String name){
method execute (line 316) | public static <T> void execute(T t, long start){
FILE: Graph/Graphs.java
class Graphs (line 2) | public class Graphs {
method Graphs (line 9) | public Graphs(Vertex[] vertices, Edge[] edges){
method hasVertex (line 15) | public boolean hasVertex(Vertex v){
method getCost (line 25) | public int getCost(){
method getEdges (line 33) | public Edge[] getEdges(){
method vertex (line 37) | public String[] vertex(){
method getVertices (line 45) | public Vertex[] getVertices(){
method toString (line 49) | public String toString(){
FILE: Graph/Karger.java
class Karger (line 15) | public class Karger {
method main (line 38) | public static void main(String[] args) {
method edgeContraction (line 64) | public static int[][] edgeContraction(int[][] edges){
method newVertices (line 95) | public static int[] newVertices(int[] vertices, int[][] edges){
method convertGraph (line 115) | public static Graph<Integer, Integer> convertGraph(int[] vertices, int...
method display (line 128) | public static void display(int[] vertices, int[][] edges, String color...
FILE: Graph/Prim.java
class Prim (line 19) | public class Prim extends JPanel{
method main (line 47) | public static void main(String[] args) {
method adjacentEdges (line 96) | public static Edge[] adjacentEdges(Graphs mst, Graphs g){
method contains (line 110) | public static boolean contains(Vertex[] vertices, Vertex v){
method minEdge (line 120) | public static Edge minEdge(Edge[] edges){
method addVertex (line 131) | public static Graphs addVertex(Graphs g, Vertex vertex){
method addEdge (line 142) | public static Graphs addEdge(Graphs g, Edge edge){
method convertVertices (line 153) | public static Vertex[] convertVertices(int[] values){
method convertEdges (line 162) | public static Edge[] convertEdges(int[][] lengths){
method convertGraph (line 172) | public static Graph<Integer, Integer> convertGraph(Graphs g){
method display (line 190) | public static void display(Graphs graph, String color, String name){
FILE: Graph/Vertex.java
class Vertex (line 2) | public class Vertex {
method Vertex (line 9) | public Vertex(int val){
method getValue (line 13) | public int getValue(){
method toString (line 17) | public String toString(){
FILE: Miscellaneous/Fisher_Yates.java
class Fisher_Yates (line 4) | public class Fisher_Yates {
method main (line 25) | public static void main(String[] args) {
method shuffle (line 32) | public static <E extends Comparable<E>> E[] shuffle(E[] arr){
method swap (line 41) | public static <E> void swap(E[] arr, int i, int j){
FILE: Miscellaneous/Matrix_Exponentiation.java
class Matrix_Exponentiation (line 3) | public class Matrix_Exponentiation {
method main (line 23) | public static void main(String[] args){
method matrix_multiply (line 42) | public static int[][] matrix_multiply(int[][] a, int[][] b){
method matrix_exponentiation (line 58) | public static int[][] matrix_exponentiation(int[][] m, int n){
FILE: Miscellaneous/Subarray_Inversions.java
class Subarray_Inversions (line 3) | public class Subarray_Inversions {
method inversionCountBIT1 (line 32) | static long inversionCountBIT1(int[] arr, int start, int end) {
method inversionCountBIT2 (line 43) | static long inversionCountBIT2(int[] arr, int start, int end, long val) {
method inversionCount (line 54) | public static long inversionCount(int n, int k, int[] arr){
method main (line 91) | public static void main(String[] args)throws Exception {
class BIT (line 101) | static class BIT
method BIT (line 105) | public BIT(int N){
method update (line 111) | void update(int index, int val){
method read (line 119) | int read(int index)
FILE: Optimization/LightConfigurationOptimization.java
class LightConfigurationOptimization (line 5) | public class LightConfigurationOptimization {
method main (line 14) | public static void main(String[] rip){
method cost (line 46) | public static LEDConfiguration cost(int[] LEDarr){
method irradiance (line 82) | public static double irradiance(int LED, int[] pointcoord){
method indexToPoints (line 89) | public static int[] indexToPoints(int index){
class LEDConfiguration (line 94) | static class LEDConfiguration{
method LEDConfiguration (line 97) | public LEDConfiguration(double CVRMSE, int[] LEDarray){
FILE: Optimization/LightConfigurationOptimizationSA.java
class LightConfigurationOptimizationSA (line 5) | public class LightConfigurationOptimizationSA {
method main (line 19) | public static void main(String[] args) {
method neighbor (line 57) | public static Solution neighbor(Solution currentSol){
method genRandSol (line 69) | public static Solution genRandSol(){
method irradiance (line 85) | public static double irradiance(int LED, int[] pointcoord){
method indexToPoints (line 92) | public static int[] indexToPoints(int index){
method cost (line 99) | public static double cost(int[] LEDarr){
class Solution (line 129) | static class Solution{
method Solution (line 132) | public Solution(double CVRMSE, int[] configuration){
FILE: Optimization/LocationalOptimizationIterative.java
class LocationalOptimizationIterative (line 5) | public class LocationalOptimizationIterative {
method main (line 13) | public static void main(String[] rip){
method irradiance (line 75) | public static double irradiance(int LED, int[] pointcoord){
method indexToPoints (line 82) | public static int[] indexToPoints(int index){
FILE: ProjectEuler/Amicable_numbers.java
class Amicable_numbers (line 2) | public class Amicable_numbers {
method main (line 4) | public static void main(String[] args) {
method amicable (line 15) | public static boolean amicable(int a, int b){
method sum_divisors (line 19) | public static int sum_divisors(int n){
FILE: ProjectEuler/Coded_triangle_numbers.java
class Coded_triangle_numbers (line 7) | public class Coded_triangle_numbers {
method main (line 9) | public static void main(String[] args) throws IOException{
FILE: ProjectEuler/Collatz_sequence.java
class Collatz_sequence (line 2) | public class Collatz_sequence {
method main (line 3) | public static void main(String[] args){
method collatz (line 17) | public static double collatz(double n){
FILE: ProjectEuler/Combinatoric_selections.java
class Combinatoric_selections (line 3) | public class Combinatoric_selections {
method main (line 5) | public static void main(String[] args) {
method factorial (line 19) | public static int factorial(int num){
FILE: ProjectEuler/Concealed_square.java
class Concealed_square (line 3) | public class Concealed_square {
method main (line 5) | public static void main(String[] args) {
FILE: ProjectEuler/Consecutive_distinct_prime_factors.java
class Consecutive_distinct_prime_factors (line 4) | public class Consecutive_distinct_prime_factors {
method main (line 6) | public static void main(String[] args) {
method factor (line 19) | public static ArrayList<Double> factor(double n){
method inlist (line 31) | public static boolean inlist(double n, ArrayList<Double> arr){
method return_max (line 40) | public static double return_max(ArrayList<Double> factors){
method isPrime (line 50) | public static boolean isPrime(double n){
FILE: ProjectEuler/Counting_sundays.java
class Counting_sundays (line 2) | public class Counting_sundays {
method main (line 4) | public static void main(String[] args) {
FILE: ProjectEuler/Digit_factorials.java
class Digit_factorials (line 2) | public class Digit_factorials {
method main (line 4) | public static void main(String[] args) {
method factorial (line 14) | public static int factorial(int num){
method sumDigits (line 22) | public static boolean sumDigits(int n){
FILE: ProjectEuler/Digit_fifth_power.java
class Digit_fifth_power (line 2) | public class Digit_fifth_power {
method main (line 4) | public static void main(String[] args) {
method digits (line 15) | public static int[] digits(int n){
method fifth_power (line 24) | public static boolean fifth_power(int n){
FILE: ProjectEuler/Distinct_powers.java
class Distinct_powers (line 4) | public class Distinct_powers {
method main (line 6) | public static void main(String[] args) {
FILE: ProjectEuler/Even_fibonacci_sum.java
class Even_fibonacci_sum (line 3) | public class Even_fibonacci_sum {
method main (line 5) | public static void main(String[] args) {
FILE: ProjectEuler/Factorial_digit_sum.java
class Factorial_digit_sum (line 3) | public class Factorial_digit_sum {
method main (line 5) | public static void main(String[] args) {
method factorial (line 9) | public static BigInteger factorial(int num){
method sum_digits (line 16) | public static double sum_digits(BigInteger n){
FILE: ProjectEuler/Grid_product_maximum.java
class Grid_product_maximum (line 3) | public class Grid_product_maximum {
method main (line 5) | public static void main(String[] args) {
method max_prod_horizontal (line 39) | public static int max_prod_horizontal(int[][] grid){
method max_prod_vertical (line 49) | public static int max_prod_vertical(int[][] grid){
method max_prod_diagonal_right (line 59) | public static int max_prod_diagonal_right(int[][] grid){
method max_prod_diagonal_left (line 69) | public static int max_prod_diagonal_left(int[][] grid){
FILE: ProjectEuler/Highly_divisible_triangular.java
class Highly_divisible_triangular (line 3) | public class Highly_divisible_triangular {
method main (line 5) | public static void main(String[] args) {
method num_divisors (line 18) | public static int num_divisors(int n){
FILE: ProjectEuler/Large_sum.java
class Large_sum (line 2) | public class Large_sum {
method main (line 4) | public static void main(String[] args) {
FILE: ProjectEuler/Largest_consecutive_product.java
class Largest_consecutive_product (line 2) | public class Largest_consecutive_product {
method main (line 4) | public static void main(String[] args) {
method prod (line 15) | public static int prod(String n){
FILE: ProjectEuler/Lexicogrphic_permutations.java
class Lexicogrphic_permutations (line 4) | public class Lexicogrphic_permutations {
method main (line 6) | public static void main(String[] args) {
method sort (line 12) | public static void sort(ArrayList<Integer> perms){
method swap (line 20) | public static void swap(ArrayList<Integer> arr, int index_a, int index...
method find_min (line 26) | public static int find_min(ArrayList<Integer> arr, int start_index){
FILE: ProjectEuler/MATH_TOOLBOX.java
type MATH_TOOLBOX (line 5) | public interface MATH_TOOLBOX {
method run (line 6) | public int run(int a, int b);
class factorial (line 10) | class factorial implements MATH_TOOLBOX{
method run (line 11) | public int run(int n, int x){
class sum_digits_square (line 20) | class sum_digits_square implements MATH_TOOLBOX{
method run (line 21) | public int run(int i, int x){
class main (line 31) | class main{
method main (line 32) | public static void main(String[] args){
FILE: ProjectEuler/Names_scores.java
class Names_scores (line 5) | public class Names_scores {
method main (line 7) | public static void main(String[] args) {
FILE: ProjectEuler/Nontrivial_digit_cancelling_fractions.java
class Nontrivial_digit_cancelling_fractions (line 2) | public class Nontrivial_digit_cancelling_fractions {
method main (line 4) | public static void main(String[] args) {
method cancelling (line 9) | public static boolean cancelling(int n, int d){
FILE: ProjectEuler/Nth_digit_powers.java
class Nth_digit_powers (line 5) | public class Nth_digit_powers {
method main (line 7) | public static void main(String[] args) {
FILE: ProjectEuler/Number_letter_counts.java
class Number_letter_counts (line 2) | public class Number_letter_counts {
method main (line 4) | public static void main(String[] args) {
FILE: ProjectEuler/PLAYGROUND.java
class PLAYGROUND (line 6) | @SuppressWarnings("unused")
method main (line 12) | @SuppressWarnings("resource")
method removeDuplicates (line 19) | public static ArrayList<String> removeDuplicates(ArrayList<String> lis...
method indexOf (line 31) | public static int indexOf(int element, int[] arr){
method cycle (line 40) | public static int cycle(int i, int[] temp){
method factorial2 (line 47) | public static BigInteger factorial2(int num){
method factorial (line 56) | public static int factorial(int num){
method sum_digits_square (line 66) | public static int sum_digits_square(int i){
method triangle_word (line 78) | public static boolean triangle_word(String n){
method num_divisors (line 92) | public static int num_divisors(int n){
method primes (line 102) | public static ArrayList<Integer> primes(int a, int b){
method isPrime (line 112) | public static boolean isPrime(int n){
method amicable (line 122) | public static boolean amicable(int a, int b){
method sum_divisors (line 126) | public static int sum_divisors(int n){
FILE: ProjectEuler/Pandigital_prime.java
class Pandigital_prime (line 4) | public class Pandigital_prime {
method main (line 6) | public static void main(String[] args) {
method pandigital (line 19) | public static boolean pandigital(int n){
method isPrime (line 29) | public static boolean isPrime(int n){
FILE: ProjectEuler/Permuted_multiples.java
class Permuted_multiples (line 3) | public class Permuted_multiples {
method main (line 5) | public static void main(String[] args) {
method same_digits (line 20) | public static boolean same_digits(int a, int b){
FILE: ProjectEuler/Prime_Summation.java
class Prime_Summation (line 3) | public class Prime_Summation {
method main (line 5) | public static void main(String[] args) {
method isPrime (line 17) | public static boolean isPrime(double n){
FILE: ProjectEuler/Prime_factorization.java
class Prime_factorization (line 3) | public class Prime_factorization {
method main (line 5) | public static void main(String[] args) {
method factor (line 11) | public static ArrayList<Double> factor(double n){
method return_max (line 24) | public static double return_max(ArrayList<Double> factors){
method isPrime (line 34) | public static boolean isPrime(double n){
FILE: ProjectEuler/Pythagorean_triplet.java
class Pythagorean_triplet (line 2) | public class Pythagorean_triplet {
method main (line 4) | public static void main(String[] args) {
FILE: ProjectEuler/Reverse_message.java
class Reverse_message (line 3) | public class Reverse_message{
method main (line 4) | public static void main(String[] args){
method reverse_words (line 7) | public static String reverse_words(String message){
FILE: ProjectEuler/Smallest_multiple.java
class Smallest_multiple (line 2) | public class Smallest_multiple {
method main (line 4) | public static void main(String[] args) {
FILE: ProjectEuler/Square_digit_chains.java
class Square_digit_chains (line 3) | public class Square_digit_chains {
method main (line 5) | public static void main(String[] args) {
method sum_digits_square (line 25) | public static int sum_digits_square(int n){
FILE: ProjectEuler/Thousand_digit_fibonacci.java
class Thousand_digit_fibonacci (line 4) | public class Thousand_digit_fibonacci {
method main (line 6) | public static void main(String[] args) {
FILE: ProjectEuler/Totient_maximum.java
class Totient_maximum (line 2) | public class Totient_maximum {
method main (line 4) | public static void main(String[] args) {
method gcd (line 18) | public static double gcd(double a, double b){
method totient (line 22) | public static double totient(double n){
FILE: ProjectEuler/Totient_permutations.java
class Totient_permutations (line 2) | public class Totient_permutations {
method main (line 4) | public static void main(String[] args) {
method gcd (line 18) | public static double gcd(double a, double b){
method totient (line 22) | public static double totient(double n){
method same_digits (line 32) | public static boolean same_digits(double a, double b){
FILE: ProjectEuler/primes.java
class primes (line 2) | public class primes{
method main (line 3) | public static void main(String[] args){
method factor (line 15) | public static List<Integer> factor(int n){
method isPrime (line 26) | public static boolean isPrime(int n){
FILE: Sorting/Bogosort.java
class Bogosort (line 4) | public class Bogosort {
method main (line 27) | public static void main(String[] args) {
method sorted (line 35) | public static <E extends Comparable<E>> boolean sorted(E[] arr){
method bogosort (line 43) | public static <E extends Comparable<E>> E[] bogosort(E[] arr){
method shuffle (line 51) | public static <E extends Comparable<E>> E[] shuffle(E[] arr){
method swap (line 60) | public static <E> void swap(E[] arr, int i, int j){
FILE: Sorting/Bubble_Sort.java
class Bubble_Sort (line 3) | public class Bubble_Sort {
method main (line 20) | public static void main(String[] args) {
method bubblesort (line 32) | public static <E extends Comparable<E>> E[] bubblesort(E[] arr){
FILE: Sorting/Counting_Sort.java
class Counting_Sort (line 3) | public class Counting_Sort {
method main (line 20) | public static void main(String[] args) {
method countingsort (line 29) | public static int[] countingsort(int[] arr, int...max){
FILE: Sorting/Heapsort.java
class Heapsort (line 3) | public class Heapsort {
method main (line 24) | public static void main(String[] args) {
method heapsort (line 35) | public static <E extends Comparable<E>> E[] heapsort(E[] arr){
method maxheapify (line 53) | public static <E extends Comparable<E>> E[] maxheapify(E[] arr, Intege...
FILE: Sorting/Insertion_Sort.java
class Insertion_Sort (line 3) | public class Insertion_Sort {
method main (line 20) | public static void main(String[] args) {
method insertionsort (line 32) | public static <E extends Comparable<E>> E[] insertionsort(E[] arr){
FILE: Sorting/Mergesort.java
class Mergesort (line 3) | public class Mergesort {
method main (line 23) | public static void main(String[] args) {
method mergesort (line 32) | public static int[] mergesort(int[] arr){
FILE: Sorting/Quicksort.java
class Quicksort (line 3) | public class Quicksort {
method main (line 24) | public static void main(String[] args) {
method quicksort (line 35) | public static <E extends Comparable<E>> E[] quicksort(E[] arr, int...r...
FILE: Sorting/Radix_Sort.java
class Radix_Sort (line 3) | public class Radix_Sort {
method main (line 25) | public static void main(String[] args) {
method radixsort (line 34) | public static int[] radixsort(int[] arr, int...maximum){
FILE: Sorting/Selection_Sort.java
class Selection_Sort (line 3) | public class Selection_Sort {
method main (line 20) | public static void main(String[] args) {
method selectionsort (line 32) | public static <E extends Comparable<E>> E[] selectionsort(E[] arr){
FILE: Sorting/Sorting.java
class Sorting (line 4) | public class Sorting {
method main (line 13) | public static void main(String[] args) {
method getMax (line 77) | public static int getMax(int[] arr){
method bucketsort (line 84) | public static int[] bucketsort(int[] arr){
method radixsort (line 90) | public static int[] radixsort(int[] arr, int...maximum){
method countingsort (line 122) | public static int[] countingsort(int[] arr, int...max){
method quicksort (line 167) | public static int[] quicksort(int[] arr, int...range){
method heapsort (line 197) | public static int[] heapsort(int[] arr){
method maxheapify (line 214) | public static int[] maxheapify(int[] arr, int node, int heaplength){
method mergesort (line 237) | public static int[] mergesort(int[] arr){
method insertionsort (line 273) | public static int[] insertionsort(int[] arr){
method bubblesort (line 295) | public static int[] bubblesort(int[] arr){
method selectionsort (line 310) | public static int[] selectionsort(int[] arr){
FILE: Sorting/Timsort.java
class Timsort (line 3) | public class Timsort {
method main (line 19) | public static void main(String[] args){
FILE: Strings/Boyer_Moore.java
class Boyer_Moore (line 4) | public class Boyer_Moore {
method main (line 24) | public static void main(String[] args) { long start=System.nanoTime();
method boyer_moore (line 37) | public static int boyer_moore(String pat, String txt) {
FILE: Strings/KMP.java
class KMP (line 5) | public class KMP {
method main (line 28) | public static void main(String[] args) throws FileNotFoundException { ...
method kmpIterative (line 43) | public static boolean kmpIterative(String pattern, String text){
method kmpDFA (line 76) | public static int kmpDFA(String pat, String txt) {
method longest_prefix_suffix (line 99) | public static int longest_prefix_suffix(String str){
FILE: Strings/Naive_String_Searching.java
class Naive_String_Searching (line 6) | public class Naive_String_Searching {
method main (line 25) | public static void main(String[] args) throws Exception{
method naive (line 37) | public static boolean naive(String pat, String txt){
FILE: Strings/Rabin_Karp.java
class Rabin_Karp (line 5) | public class Rabin_Karp {
method main (line 25) | public static void main(String[] args) { long start=System.nanoTime();
method hash (line 33) | private static long hash(String key, int m, long q) {
method check (line 40) | private static boolean check(String pat, String txt, int i, int m) {
method rabin_karp (line 47) | public static int rabin_karp(String pat, String txt) {
FILE: Strings/String_Algorithms.java
class String_Algorithms (line 8) | public class String_Algorithms {
method main (line 18) | public static void main(String[] args) throws FileNotFoundException {
method boyer_moore (line 49) | public static int boyer_moore(String pat, String txt) {
method kmp (line 73) | public static int kmp(String pat, String txt) {
method hash (line 94) | private static long hash(String key, int m, long q) {
method check (line 101) | private static boolean check(String pat, String txt, int i, int m) {
method rabin_karp (line 108) | public static int rabin_karp(String pat, String txt) {
FILE: USACO/AngryCows.java
class AngryCows (line 4) | public class AngryCows {
method main (line 6) | public static void main(String[] args) throws Exception {
method exists (line 48) | public static int exists(int a, int b, ArrayList<Integer> arr){
method first (line 58) | public static int first(int a, int b, ArrayList<Integer> arr){
method last (line 68) | public static int last(int a, int b, ArrayList<Integer> arr){
method explode (line 78) | public static void explode(int a, int b, ArrayList<Integer> arr){
FILE: USACO/AngryCows2.java
class AngryCows2 (line 4) | public class AngryCows2 {
method main (line 6) | public static void main(String[] args) throws Exception{
method explode (line 35) | public static void explode(int a, int b, ArrayList<Integer> arr){
FILE: USACO/BovineGenomics.java
class BovineGenomics (line 7) | public class BovineGenomics {
method main (line 9) | public static void main(String[] args) throws Exception{
method disjoint (line 53) | public static boolean disjoint(String[] spotarr, String[] plainarr, in...
FILE: USACO/BovineGenomics_bruteforce.java
class BovineGenomics_bruteforce (line 6) | public class BovineGenomics_bruteforce {
method main (line 8) | public static void main(String[] args) throws Exception{
method disjoint (line 49) | public static boolean disjoint(String[] spotarr, String[] plainarr, in...
FILE: USACO/BuildGates.java
class BuildGates (line 8) | public class BuildGates {
method main (line 9) | public static void main(String[] args) throws Exception{
FILE: USACO/CircularBarn.java
class CircularBarn (line 2) | public class CircularBarn {
method main (line 4) | public static void main(String[] args) {
FILE: USACO/CowCode.java
class CowCode (line 4) | public class CowCode {
method main (line 6) | public static void main(String[] args) throws Exception {
method f (line 21) | public static String f(long n, String word){
FILE: USACO/CowDanceShow.java
class CowDanceShow (line 4) | public class CowDanceShow {
method main (line 13) | public static void main(String[] args) throws Exception {
method time (line 56) | public static int time(int k){
method maxval (line 81) | public static int maxval(int[] stage){
method min (line 93) | public static int min(int[] stage){
FILE: USACO/CowTip.java
class CowTip (line 4) | public class CowTip {
method main (line 6) | public static void main(String[] args) throws Exception {
method tipped (line 40) | public static int tipped(int[][] farm){
method invert (line 52) | public static int[][] invert(int[][] farm, int row, int col){
method maxTipped (line 61) | public static int[] maxTipped(int[][] farm){
FILE: USACO/FencePainting.java
class FencePainting (line 4) | public class FencePainting {
method main (line 6) | public static void main(String[] args) throws Exception {
FILE: USACO/HPS.java
class HPS (line 4) | public class HPS {
method main (line 6) | public static void main(String[] args) throws Exception {
method greater (line 74) | public static boolean greater(int a, int b, int rock, int paper, int s...
FILE: USACO/Haybales.java
class Haybales (line 9) | public class Haybales {
method main (line 11) | public static void main(String[] args) throws Exception{
method floorIndex (line 54) | public static int floorIndex(List<Integer> haybales, int query){
method ceilIndex (line 63) | public static int ceilIndex(List<Integer> haybales, int query){
FILE: USACO/HoofPaperScissors.java
class HoofPaperScissors (line 4) | public class HoofPaperScissors {
method main (line 6) | public static void main(String[] args) throws Exception {
method numRepeats (line 39) | public static int[] numRepeats(int[] arr){
FILE: USACO/LoadBalancing.java
class LoadBalancing (line 5) | public class LoadBalancing {
method main (line 7) | public static void main(String[] args) throws Exception{
method max_points (line 43) | public static int max_points(int x, int y, ArrayList<int[]> points){
FILE: USACO/MilkPails.java
class MilkPails (line 4) | public class MilkPails {
method main (line 6) | public static void main(String[] args) throws Exception {
method min (line 38) | public static int min(ArrayList<Integer> n){
FILE: USACO/ModernArt.java
class ModernArt (line 6) | public class ModernArt {
method main (line 8) | public static void main(String[] args) throws Exception{
method removeTopLayer (line 41) | public static int[][] removeTopLayer(int[][] paint){
FILE: USACO/ModernArt2.java
class ModernArt2 (line 8) | public class ModernArt2 {
method main (line 10) | public static void main(String[] args) throws Exception{
method layers (line 29) | public static int layers(int[] paint){
FILE: USACO/ModernArt2_bruteforce.java
class ModernArt2_bruteforce (line 7) | public class ModernArt2_bruteforce {
method main (line 9) | public static void main(String[] args) throws Exception{
method consecutive (line 102) | public static boolean consecutive(ArrayList<Integer> list2, ArrayList<...
method timeout (line 125) | public static void timeout(){
FILE: USACO/MowingField.java
class MowingField (line 4) | public class MowingField {
method main (line 6) | public static void main(String[] args) throws Exception {
FILE: USACO/NotLast.java
class NotLast (line 4) | public class NotLast {
method main (line 6) | public static void main(String[] args) throws Exception {
FILE: USACO/PromotionCounting.java
class PromotionCounting (line 4) | public class PromotionCounting {
method main (line 6) | public static void main(String[] args) throws Exception {
method change (line 31) | public static int change(String[] arr){
FILE: USACO/SeqSum7.java
class SeqSum7 (line 4) | public class SeqSum7 {
method main (line 6) | public static void main(String[] args) throws Exception{
method sum (line 35) | public static int sum(int start, int end){
FILE: USACO/asdf.java
class asdf (line 4) | public class asdf {
method main (line 13) | public static void main(String[] args) throws Exception {
method time (line 37) | public static int time(int k){
method maxval (line 62) | public static int maxval(int[] stage){
method min (line 74) | public static int min(int[] stage){
FILE: USACO/friday.java
class friday (line 4) | public class friday {
method main (line 6) | public static void main(String[] args) throws IOException {
FILE: USACO/gift1.java
class gift1 (line 10) | public class gift1 {
method main (line 12) | public static void main(String[] args) throws IOException {
FILE: USACO/marathon.java
class marathon (line 4) | public class marathon {
method main (line 6) | public static void main(String[] args) throws IOException {
method distance_between (line 35) | public static int distance_between(ArrayList<Integer> p1, ArrayList<In...
FILE: USACO/reorder.java
class reorder (line 3) | public class reorder {
method main (line 8) | public static void main(String[] args) throws IOException{
method indexOf (line 33) | public static int indexOf(int element, int[] arr){
method cycle (line 42) | public static int cycle(int i, int[] temp){
FILE: USACO/ride.java
class ride (line 11) | public class ride {
method main (line 13) | public static void main(String[] args) throws IOException {
FILE: USACO/sample.java
class sample (line 5) | public class sample {
method main (line 7) | public static void main(String[] args) throws Exception {
method timeout (line 20) | public static void timeout(){
FILE: USACO/test.java
class test (line 6) | public class test {
method main (line 7) | public static void main(String[] args) throws Exception {
Copy disabled (too large)
Download .json
Condensed preview — 145 files, each showing path, character count, and a content snippet. Download the .json file for the full structured content (10,499K chars).
[
{
"path": ".gitignore",
"chars": 272,
"preview": "# Compiled class file\n*.class\n\n# Log file\n*.log\n\n# BlueJ files\n*.ctxt\n\n# Mobile Tools for Java (J2ME)\n.mtj.tmp/\n\n# Packa"
},
{
"path": "Computational Geometry/GrahamScan.java",
"chars": 3340,
"preview": "import java.util.Arrays;\nimport java.util.Stack;\n\npublic class GrahamScan {\n\t\n\t/*Graham's Scan\n\n\t Problem (informal): Fi"
},
{
"path": "Computational Geometry/JarvisMarch.java",
"chars": 2788,
"preview": "import java.util.Arrays;\nimport java.util.Stack;\n\npublic class JarvisMarch {\n\t\n\t/*Jarvis March\n\n\t Problem (informal): Fi"
},
{
"path": "Computational Geometry/README.md",
"chars": 272,
"preview": "# Computational Geometric Algorithms\n## Convex Hull\n * [Graham's Scan](https://github.com/jpa99/Algorithms/blob/master/"
},
{
"path": "DP/Edit_Distance.java",
"chars": 2153,
"preview": "import java.util.Arrays;\n\npublic class Edit_Distance {\n\t\n\t/*Edit (Levenshtein Distance) Algorithm\n\n\t Problem (informal):"
},
{
"path": "DP/Knapsack.java",
"chars": 1701,
"preview": "import cern.colt.Arrays;\nimport java.util.*;\n\npublic class Knapsack {\n\t\n\t/*0-1 Knapsack Probelm\n\n\t Problem (informal): G"
},
{
"path": "DP/LCS.java",
"chars": 1961,
"preview": "import java.util.*;\nimport cern.colt.Arrays;\n\npublic class LCS {\n\t\n\t/*Longest Common Subsequence (LCS)\n\n\t Problem (infor"
},
{
"path": "DP/README.md",
"chars": 471,
"preview": "# Dynamic Programming Algorithms\n\n* [0-1 Knapsack](https://github.com/jpa99/Algorithms/blob/master/DP/Knapsack.java)\n* ["
},
{
"path": "DP/maxDonations.java",
"chars": 1158,
"preview": "\npublic class maxDonations {\n\t\n\t/*Maximum Donations (Topcoder)\n\n\t Problem (informal): Given set S of values, find subset"
},
{
"path": "Data Structures/BinaryTree.java",
"chars": 2191,
"preview": "import java.util.*;\nimport java.util.Arrays;\n\npublic class BinaryTree {\n\n\tpublic static void main(String[] args) {\n\t\t\n\t\t"
},
{
"path": "Data Structures/Binary_Indexed_Tree.java",
"chars": 953,
"preview": "public class Binary_Indexed_Tree {\n\n\tpublic static void main(String[] args) throws IOException {\n \t\t//testting BIT\n\t\tBI"
},
{
"path": "Data Structures/Edge.java",
"chars": 1015,
"preview": "\npublic class Edge {\n\t\n\t//Edge class with built in functions; used for Graph class\n\t\n\tprivate int weight;\n\tprivate Verte"
},
{
"path": "Data Structures/Graphs.java",
"chars": 1073,
"preview": "\npublic class Graphs {\n\t\n\t//Graph class with certain built in algorithms\n\n\tprivate Edge[] edges;\n\tprivate Vertex[] verti"
},
{
"path": "Data Structures/README.md",
"chars": 604,
"preview": "# Data Structures\n* [Binary Indexed Tree (Fenwick Tree)](https://github.com/jpa99/Algorithms/edit/master/Data%20Structur"
},
{
"path": "Data Structures/Tree.java",
"chars": 3529,
"preview": "import java.util.*;\n\npublic class Tree {\n\n\tpublic static void main(String[] args) {\n\t\tNode<String> tree = new Node<Strin"
},
{
"path": "Data Structures/Vertex.java",
"chars": 232,
"preview": "static class Vertex{\n\tpublic int name;\n\tpublic int distance;\n\n\tpublic Vertex(int name, int distance){\n\t\tthis.name = name"
},
{
"path": "GoogleCodeJam/ABBA.java",
"chars": 1241,
"preview": "\npublic class ABBA {\n\tpublic static void main(String[] args) throws Exception{\n\t\tSystem.out.println(canObtain(\"B\",\"ABBA\""
},
{
"path": "GoogleCodeJam/Alphabet_Cake.java",
"chars": 3501,
"preview": "import java.util.*;\nimport java.util.Map.Entry;\nimport java.io.*;\nimport java.time.*;\nimport java.math.*;\nimport java.aw"
},
{
"path": "GoogleCodeJam/BFCalculator.java",
"chars": 116,
"preview": "\npublic class BFCalculator {\n\n\tpublic static void main(String[] args) {\n\t\t// TODO Auto-generated method stub\n\n\t}\n\n}\n"
},
{
"path": "GoogleCodeJam/Bathroom_Stalls.java",
"chars": 2106,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class Bathro"
},
{
"path": "GoogleCodeJam/Close_Match.java",
"chars": 822,
"preview": "import java.util.Scanner;\nimport java.io.*;\nimport java.time.*;\nimport java.math.*;\nimport java.awt.*;\n\npublic class Clo"
},
{
"path": "GoogleCodeJam/Coin_Jam.java",
"chars": 3221,
"preview": "import java.io.*;\nimport java.util.*;\nimport java.util.stream.IntStream;\n\npublic class Coin_Jam {\n\n\tpublic static void m"
},
{
"path": "GoogleCodeJam/Counting_Sheep.java",
"chars": 875,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class Counting_Sheep {\n\n\tpublic static void main(String[] args) throws Exc"
},
{
"path": "GoogleCodeJam/CrossOver.java",
"chars": 1110,
"preview": "import java.util.*;\nimport java.io.*;\npublic class CrossOver {\n\n\tpublic static void main(String[] args) throws Exception"
},
{
"path": "GoogleCodeJam/Digits.java",
"chars": 2753,
"preview": "import java.util.*;\nimport java.util.List;\nimport java.util.stream.Collectors;\nimport java.io.*;\nimport java.time.*;\nimp"
},
{
"path": "GoogleCodeJam/Oversized_Pancake_Flipper.java",
"chars": 2574,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class Oversized_Pancake_Flipper {\n\n\tpublic static void main(String[] args)"
},
{
"path": "GoogleCodeJam/Pancakes.java",
"chars": 338,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class Pancakes {\n\n\tpublic static void main(String[] args) throws Exception"
},
{
"path": "GoogleCodeJam/Prison_Break.java",
"chars": 1816,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class Prison_Break {\n\n\tpublic static void main(String[] args) throws Excep"
},
{
"path": "GoogleCodeJam/README.md",
"chars": 27,
"preview": "# Google Code Jam Problems\n"
},
{
"path": "GoogleCodeJam/Solution.java",
"chars": 2652,
"preview": "import java.io.*;\nimport java.util.*;\nimport java.text.*;\nimport java.math.*;\nimport java.util.regex.*;\n\npublic class So"
},
{
"path": "GoogleCodeJam/Super_Substrings.java",
"chars": 704,
"preview": "import java.io.File;\nimport java.util.*;\n\npublic class Super_Substrings {\n\n\tpublic static void main(String[] args) throw"
},
{
"path": "GoogleCodeJam/Tidy_Numbers.java",
"chars": 1555,
"preview": "import java.util.*;\nimport java.io.*;\n\npublic class Tidy_Numbers {\n\n\tpublic static void main(String[] args) throws Excep"
},
{
"path": "Graph/BFS.java",
"chars": 8579,
"preview": "import java.awt.BasicStroke;\nimport java.awt.Color;\nimport java.awt.Dimension;\nimport java.awt.Paint;\nimport java.awt.St"
},
{
"path": "Graph/Bellman_Ford.java",
"chars": 6122,
"preview": "import java.awt.*;\nimport java.util.*;\nimport java.util.Queue;\nimport java.util.stream.Collectors;\n\nimport javax.swing.J"
},
{
"path": "Graph/DFS.java",
"chars": 6759,
"preview": "import java.awt.BasicStroke;\nimport java.awt.Color;\nimport java.awt.Dimension;\nimport java.awt.Paint;\nimport java.awt.St"
},
{
"path": "Graph/Dijkstra.java",
"chars": 6916,
"preview": "import java.awt.*;\nimport java.util.*;\nimport java.util.Queue;\nimport java.util.stream.Collectors;\n\nimport javax.swing.J"
},
{
"path": "Graph/Edge.java",
"chars": 1015,
"preview": "\npublic class Edge {\n\t\n\t//Edge class with built in functions; used for Graph class\n\t\n\tprivate int weight;\n\tprivate Verte"
},
{
"path": "Graph/Floyd_Warshall.java",
"chars": 6316,
"preview": "import java.awt.*;\nimport java.util.*;\nimport java.util.Queue;\nimport java.util.stream.Collectors;\n\nimport javax.swing.J"
},
{
"path": "Graph/Ford_Fulkerson.java",
"chars": 6603,
"preview": "import java.awt.BasicStroke;\nimport java.awt.Color;\nimport java.awt.Dimension;\nimport java.awt.Paint;\nimport java.awt.St"
},
{
"path": "Graph/Graph_Traversal.java",
"chars": 9572,
"preview": "import java.awt.BasicStroke;\nimport java.awt.Color;\nimport java.awt.Dimension;\nimport java.awt.Paint;\nimport java.awt.St"
},
{
"path": "Graph/Graphs.java",
"chars": 1073,
"preview": "\npublic class Graphs {\n\t\n\t//Graph class with certain built in algorithms\n\n\tprivate Edge[] edges;\n\tprivate Vertex[] verti"
},
{
"path": "Graph/Johnson",
"chars": 8770,
"preview": "import java.awt.*;\nimport java.util.*;\nimport java.util.Queue;\nimport java.util.stream.Collectors;\n\nimport javax.swing.J"
},
{
"path": "Graph/Karger.java",
"chars": 5789,
"preview": "import java.awt.*;\nimport java.util.*;\nimport javax.swing.*;\n\nimport org.apache.commons.collections15.Transformer;\n\n//Us"
},
{
"path": "Graph/Prim.java",
"chars": 8719,
"preview": "import java.awt.*;\nimport java.util.*;\nimport javax.swing.*;\n\nimport org.apache.commons.collections15.Transformer;\n\n//Us"
},
{
"path": "Graph/README.md",
"chars": 1442,
"preview": "# Graph Algorithms\n## Graph Implementation\n * [Graph](https://github.com/jpa99/Algorithms/blob/master/Graph/Graphs.java)"
},
{
"path": "Graph/Vertex.java",
"chars": 290,
"preview": "\npublic class Vertex {\n\t\n\t//Vertex class\n\t//probably unnecessary, but already built into Prim's Algorith implementation\n"
},
{
"path": "LICENSE",
"chars": 1069,
"preview": "MIT License\n\nCopyright (c) 2017 Joel Abraham\n\nPermission is hereby granted, free of charge, to any person obtaining a co"
},
{
"path": "Math/README.md",
"chars": 35,
"preview": "# Math/Number Theoretic Algorithms\n"
},
{
"path": "Miscellaneous/Fisher_Yates.java",
"chars": 1167,
"preview": "import java.util.Arrays;\nimport java.util.Random;\n\npublic class Fisher_Yates {\n\t\n\t/*Fisher-Yates Algorithm\n\n\t Problem (i"
},
{
"path": "Miscellaneous/Matrix_Exponentiation.java",
"chars": 1916,
"preview": "import java.util.Arrays;\n\npublic class Matrix_Exponentiation {\n\t\n\t/*Matrix Exponentiation Algorithm\n\n\t Problem (informal"
},
{
"path": "Miscellaneous/README.md",
"chars": 364,
"preview": "# Miscellaneous Algorithms\n\n* [Fisher-Yates Algorithm](https://github.com/jpa99/Algorithms/blob/master/Miscellaneous/Fis"
},
{
"path": "Miscellaneous/Subarray_Inversions.java",
"chars": 6398,
"preview": "import java.util.*;\n\npublic class Subarray_Inversions {\n\n /* Subarray Inversions\n\n Problem: Given an array A o"
},
{
"path": "Optimization/LightConfigurationOptimization.java",
"chars": 3676,
"preview": "import java.util.*;\nimport java.math.*;\nimport org.apache.commons.math3.util.Combinations;\n\npublic class LightConfigurat"
},
{
"path": "Optimization/LightConfigurationOptimizationSA.java",
"chars": 4729,
"preview": "import java.util.Arrays;\nimport java.util.HashMap;\nimport java.util.Random;\n\npublic class LightConfigurationOptimization"
},
{
"path": "Optimization/LocationalOptimizationIterative.java",
"chars": 3181,
"preview": "import java.util.*;\nimport java.math.*;\nimport org.apache.commons.math3.util.Combinations;\n\npublic class LocationalOptim"
},
{
"path": "Optimization/README.md",
"chars": 817,
"preview": "# Optimization Algorithms\nThis folder contains optimization implementations for locational optimization problems. The ge"
},
{
"path": "ProjectEuler/Amicable_numbers.java",
"chars": 493,
"preview": "\npublic class Amicable_numbers {\n\n\tpublic static void main(String[] args) {\n\t\tint sum=0;\n\t\tfor(int i=0;i<10000;i++){\n\t\t\t"
},
{
"path": "ProjectEuler/Coded_triangle_numbers.java",
"chars": 1248,
"preview": "import java.io.*;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.HashMap;\nimport java.util.Scanne"
},
{
"path": "ProjectEuler/Collatz_sequence.java",
"chars": 419,
"preview": "\npublic class Collatz_sequence {\n\tpublic static void main(String[] args){\n\t\tdouble starting=0;\n\t\tdouble max=0;\n\t\tfor(dou"
},
{
"path": "ProjectEuler/Combinatoric_selections.java",
"chars": 428,
"preview": "import java.math.BigInteger;\n\npublic class Combinatoric_selections {\n\n\tpublic static void main(String[] args) {\n\t\t\n\t\tint"
},
{
"path": "ProjectEuler/Concealed_square.java",
"chars": 526,
"preview": "import java.math.BigInteger;\n\npublic class Concealed_square {\n\n\tpublic static void main(String[] args) {\n\t\tfor(long i=10"
},
{
"path": "ProjectEuler/Consecutive_distinct_prime_factors.java",
"chars": 1065,
"preview": "import java.util.ArrayList;\nimport java.lang.Math;\n\npublic class Consecutive_distinct_prime_factors {\n\n\tpublic static vo"
},
{
"path": "ProjectEuler/Counting_sundays.java",
"chars": 85,
"preview": "\npublic class Counting_sundays {\n\n\tpublic static void main(String[] args) {\n\t\t\n\t}\n\n}\n"
},
{
"path": "ProjectEuler/Digit_factorials.java",
"chars": 563,
"preview": "\npublic class Digit_factorials {\n\n\tpublic static void main(String[] args) {\n\t\tint sum=0;\n\t\tfor(int i=10; i>0;i++){\n\t\t\tif"
},
{
"path": "ProjectEuler/Digit_fifth_power.java",
"chars": 604,
"preview": "\npublic class Digit_fifth_power {\n\n\tpublic static void main(String[] args) {\n\t\tint sum=0;\n\t\tfor(int i=0;i<1000000000;i++"
},
{
"path": "ProjectEuler/Distinct_powers.java",
"chars": 446,
"preview": "import java.math.BigInteger;\nimport java.util.ArrayList;\n\npublic class Distinct_powers {\n\n\tpublic static void main(Strin"
},
{
"path": "ProjectEuler/Even_fibonacci_sum.java",
"chars": 428,
"preview": "import java.util.ArrayList;\n\npublic class Even_fibonacci_sum {\n\n\tpublic static void main(String[] args) {\n\t\tArrayList<In"
},
{
"path": "ProjectEuler/Factorial_digit_sum.java",
"chars": 544,
"preview": "import java.math.BigInteger;\n\npublic class Factorial_digit_sum {\n\n\tpublic static void main(String[] args) {\n\t\tSystem.out"
},
{
"path": "ProjectEuler/Grid_product_maximum.java",
"chars": 3135,
"preview": "import java.util.Arrays;\n\npublic class Grid_product_maximum {\n\n\tpublic static void main(String[] args) {\n\t\tString g= \"08"
},
{
"path": "ProjectEuler/Highly_divisible_triangular.java",
"chars": 525,
"preview": "import java.util.ArrayList;\n\npublic class Highly_divisible_triangular {\n\n\tpublic static void main(String[] args) {\n\t\tint"
},
{
"path": "ProjectEuler/Large_sum.java",
"chars": 5332,
"preview": "\npublic class Large_sum {\n\n\tpublic static void main(String[] args) {\n\t\tString num=\"3710728753390210279879799822083759024"
},
{
"path": "ProjectEuler/Largest_consecutive_product.java",
"chars": 1495,
"preview": "\npublic class Largest_consecutive_product {\n\n\tpublic static void main(String[] args) {\n\t\tString num=\"7316717653133062491"
},
{
"path": "ProjectEuler/Lexicogrphic_permutations.java",
"chars": 697,
"preview": "import java.util.ArrayList;\nimport java.lang.*;\n\npublic class Lexicogrphic_permutations {\n\n\tpublic static void main(Stri"
},
{
"path": "ProjectEuler/MATH_TOOLBOX.java",
"chars": 799,
"preview": "import java.util.ArrayList;\nimport java.util.HashMap;\nimport java.util.List;\n\npublic interface MATH_TOOLBOX {\n\tpublic in"
},
{
"path": "ProjectEuler/Names_scores.java",
"chars": 1059,
"preview": "import java.io.BufferedReader;\nimport java.io.FileReader;\nimport java.util.Arrays;\n\npublic class Names_scores {\n\n\tpublic"
},
{
"path": "ProjectEuler/Nontrivial_digit_cancelling_fractions.java",
"chars": 421,
"preview": "\npublic class Nontrivial_digit_cancelling_fractions {\n\n\tpublic static void main(String[] args) {\n\t\t\n\n\t}\n\t\n\tpublic static"
},
{
"path": "ProjectEuler/Nth_digit_powers.java",
"chars": 443,
"preview": "import java.lang.Math;\n\nimport java.util.*;\n\npublic class Nth_digit_powers {\n\n\tpublic static void main(String[] args) {\n"
},
{
"path": "ProjectEuler/Number_letter_counts.java",
"chars": 512,
"preview": "\npublic class Number_letter_counts {\n\n\tpublic static void main(String[] args) {\n\t\tint digits=36;\n\t\tint teens=70;\n\t\tint t"
},
{
"path": "ProjectEuler/PLAYGROUND.java",
"chars": 2874,
"preview": "import java.io.*;\nimport java.math.*;\nimport java.text.*;\nimport java.util.*;\n\n@SuppressWarnings(\"unused\")\nclass PLAYGRO"
},
{
"path": "ProjectEuler/Pandigital_prime.java",
"chars": 807,
"preview": "import java.util.ArrayList;\nimport java.util.Date;\n\npublic class Pandigital_prime {\n\n\tpublic static void main(String[] a"
},
{
"path": "ProjectEuler/Permuted_multiples.java",
"chars": 771,
"preview": "import java.util.Date;\n\npublic class Permuted_multiples {\n\n\tpublic static void main(String[] args) {\n\t\tDate start = new "
},
{
"path": "ProjectEuler/Prime_Summation.java",
"chars": 418,
"preview": "import javax.swing.plaf.synth.SynthSeparatorUI;\n\npublic class Prime_Summation {\n\n\tpublic static void main(String[] args)"
},
{
"path": "ProjectEuler/Prime_factorization.java",
"chars": 679,
"preview": "import java.util.*;\n\npublic class Prime_factorization {\n\n\tpublic static void main(String[] args) {\n\t\tSystem.out.println("
},
{
"path": "ProjectEuler/Pythagorean_triplet.java",
"chars": 305,
"preview": "\npublic class Pythagorean_triplet {\n\n\tpublic static void main(String[] args) {\n\t\t\n\t\tfor(double a=1;a<1000;a++){\n\t\t\tfor(d"
},
{
"path": "ProjectEuler/README.md",
"chars": 77,
"preview": "# projecteuler\nMath toolbox containing algorithms for Project Euler problems\n"
},
{
"path": "ProjectEuler/Reverse_message.java",
"chars": 762,
"preview": "import java.util.*;\n\npublic class Reverse_message{\n public static void main(String[] args){\n \tSystem.out.println(r"
},
{
"path": "ProjectEuler/Smallest_multiple.java",
"chars": 276,
"preview": "\npublic class Smallest_multiple {\n\n\tpublic static void main(String[] args) {\n\t\tfor(int i=2520; i< (2.5*Math.pow(10,18));"
},
{
"path": "ProjectEuler/Square_digit_chains.java",
"chars": 753,
"preview": "import java.util.ArrayList;\n\npublic class Square_digit_chains {\n\n\tpublic static void main(String[] args) {\n\t\tArrayList<I"
},
{
"path": "ProjectEuler/Thousand_digit_fibonacci.java",
"chars": 419,
"preview": "import java.math.BigInteger;\nimport java.util.ArrayList;\n\npublic class Thousand_digit_fibonacci {\n\n\tpublic static void m"
},
{
"path": "ProjectEuler/Totient_maximum.java",
"chars": 515,
"preview": "import java.lang.Math;\npublic class Totient_maximum {\n\n\tpublic static void main(String[] args) {\n\t\tdouble max=0;\n\t\tdoubl"
},
{
"path": "ProjectEuler/Totient_permutations.java",
"chars": 835,
"preview": "\npublic class Totient_permutations {\n\n\tpublic static void main(String[] args) {\n\t\tdouble min=2;\n\t\tdouble index=0;\n\t\tfor("
},
{
"path": "ProjectEuler/primes.java",
"chars": 639,
"preview": "import java.util.*;\npublic class primes{\n\tpublic static void main(String[] args){\n\t\tScanner scan=new Scanner(System.in);"
},
{
"path": "README.md",
"chars": 5390,
"preview": "# Algorithms\n\n![Java](https://img.shields.io/badge/Java-8-ye"
},
{
"path": "Searching/README.md",
"chars": 23,
"preview": "# Searching Algorithms\n"
},
{
"path": "Sorting/Bogosort.java",
"chars": 1611,
"preview": "import java.util.Arrays;\nimport java.util.Random;\n\npublic class Bogosort {\n\t\n\t/*Bogosort\n\n\t Problem (informal): Given in"
},
{
"path": "Sorting/Bubble_Sort.java",
"chars": 1159,
"preview": "import java.util.Arrays;\n\npublic class Bubble_Sort {\n\t\n\t/*Selection Sort\n\n\t Problem (informal): Given collection of obje"
},
{
"path": "Sorting/Counting_Sort.java",
"chars": 1515,
"preview": "import java.util.Arrays;\n\npublic class Counting_Sort {\n\t\n\t/*Counting Sort\n\n\t Problem (informal): Given collection of int"
},
{
"path": "Sorting/Heapsort.java",
"chars": 2014,
"preview": "import java.util.Arrays;\n\npublic class Heapsort {\n\t\n\t/*Quicksort\n\n\t Problem (informal): Given collection of objects, ret"
},
{
"path": "Sorting/Insertion_Sort.java",
"chars": 1321,
"preview": "import java.util.Arrays;\n\npublic class Insertion_Sort {\n\t\n\t/*Insertion Sort\n\n\t Problem (informal): Given collection of o"
},
{
"path": "Sorting/Mergesort.java",
"chars": 1610,
"preview": "import java.util.Arrays;\n\npublic class Mergesort {\n\t\n\t/*Mergesort\n\n\t Problem (informal): Given collection of objects, re"
},
{
"path": "Sorting/Quicksort.java",
"chars": 1812,
"preview": "import java.util.Arrays;\n\npublic class Quicksort {\n\t\n\t/*Quicksort\n\n\t Problem (informal): Given collection of objects, re"
},
{
"path": "Sorting/README.md",
"chars": 1010,
"preview": "# Sorting Algorithms\n* [Sorting Algorithm Comparison](https://github.com/jpa99/Algorithms/edit/master/Sorting/Sorting.ja"
},
{
"path": "Sorting/Radix_Sort.java",
"chars": 1549,
"preview": "import java.util.Arrays;\n\npublic class Radix_Sort {\n\t\n\t/* (LSD) Radix Sort\n\n\t Problem (informal): Given collection of in"
},
{
"path": "Sorting/Selection_Sort.java",
"chars": 1311,
"preview": "import java.util.Arrays;\n\npublic class Selection_Sort {\n\t\n\t/*Selection Sort\n\n\t Problem (informal): Given collection of o"
},
{
"path": "Sorting/Sorting.java",
"chars": 7199,
"preview": "import java.util.Arrays;\nimport java.util.Random;\n\npublic class Sorting {\n\t/*\n\t \n\t Generally, based on runtime benchmark"
},
{
"path": "Sorting/Timsort.java",
"chars": 715,
"preview": "import java.util.Arrays;\n\npublic class Timsort {\n\t\n\t/*Timsort\n\n\t Problem (informal): Given collection of objects, return"
},
{
"path": "Strings/Boyer_Moore.java",
"chars": 1987,
"preview": "import java.math.BigInteger;\nimport java.util.Random;\n\npublic class Boyer_Moore {\n\n\t/*Boyer-Moore\n\n\t Problem (informal):"
},
{
"path": "Strings/KMP.java",
"chars": 3424,
"preview": "import java.io.File;\nimport java.io.FileNotFoundException;\nimport java.util.Scanner;\n\npublic class KMP {\n\t\n\t/*Knuth-Morr"
},
{
"path": "Strings/Naive_String_Searching.java",
"chars": 1303,
"preview": "import java.io.File;\nimport java.io.FileNotFoundException;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic cl"
},
{
"path": "Strings/README.md",
"chars": 785,
"preview": "# String Algorithms\n## String Searching\n* [Comparative Analysis of all string searching algorithms on both empirical and"
},
{
"path": "Strings/Rabin_Karp.java",
"chars": 2592,
"preview": "import java.math.BigInteger;\nimport java.util.Random;\n\n\npublic class Rabin_Karp {\n\t\n\t/*Rabin-Karp\n\n\t Problem (informal):"
},
{
"path": "Strings/String_Algorithms.java",
"chars": 4493,
"preview": "import java.io.File;\nimport java.io.FileNotFoundException;\nimport java.math.BigInteger;\nimport java.util.Arrays;\nimport "
},
{
"path": "Strings/Strings_random.in",
"chars": 10099998,
"preview": "7cokfrIV2T8cJOK9uuDMJgsIIagVWUeeKcBO3CeljJVWfvtSRV3I1aCGvTesPu6BZARh1gIv9tyRaA71eYaFhg3XrTWCVXqri9iI\nmqrfezSazu1olyTq9M1"
},
{
"path": "USACO/AngryCows.java",
"chars": 1935,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class AngryCows {\n\n\tpublic static void main(String[] args) throws Exceptio"
},
{
"path": "USACO/AngryCows2.java",
"chars": 1000,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class AngryCows2 {\n\n\tpublic static void main(String[] args) throws Excepti"
},
{
"path": "USACO/BovineGenomics.java",
"chars": 1482,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.S"
},
{
"path": "USACO/BovineGenomics_bruteforce.java",
"chars": 1436,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class Bovine"
},
{
"path": "USACO/BuildGates.java",
"chars": 1200,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.S"
},
{
"path": "USACO/CircularBarn.java",
"chars": 85,
"preview": "\npublic class CircularBarn {\n\n\tpublic static void main(String[] args) {\n\t\t\n\t\t\n\n\t}\n\n}\n"
},
{
"path": "USACO/CowCode.java",
"chars": 948,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class CowCode {\n\tstatic int counter=0;\n\tpublic static void main(String[] a"
},
{
"path": "USACO/CowDanceShow.java",
"chars": 2043,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class CowDanceShow {\n\tstatic int minindex;\n\tstatic int min;\n\tstatic int ti"
},
{
"path": "USACO/CowTip.java",
"chars": 1572,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class CowTip {\n\tstatic int counter=0;\n\tpublic static void main(String[] ar"
},
{
"path": "USACO/FencePainting.java",
"chars": 785,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class FencePainting {\n\n\tpublic static void main(String[] args) throws Exce"
},
{
"path": "USACO/HPS.java",
"chars": 1496,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class HPS {\n\tstatic int counter=0;\n\tpublic static void main(String[] args)"
},
{
"path": "USACO/Haybales.java",
"chars": 1617,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.L"
},
{
"path": "USACO/HoofPaperScissors.java",
"chars": 1219,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class HoofPaperScissors {\n\n\tpublic static void main(String[] args) throws "
},
{
"path": "USACO/LoadBalancing.java",
"chars": 1921,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.*;\n\npublic class LoadBalancing {\n\n\tpublic static void "
},
{
"path": "USACO/MilkPails.java",
"chars": 1006,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class MilkPails {\n\tstatic int x, y, k, m, min, pail_x=0, pail_y=0;\n\tpublic"
},
{
"path": "USACO/ModernArt.java",
"chars": 744,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.Arrays;\nimport java.util.Scanner;\n\npublic class Modern"
},
{
"path": "USACO/ModernArt2.java",
"chars": 916,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.S"
},
{
"path": "USACO/ModernArt2_bruteforce.java",
"chars": 3125,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.ArrayList;\nimport java.util.Arrays;\nimport java.util.S"
},
{
"path": "USACO/MowingField.java",
"chars": 1854,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class MowingField {\n\n\tpublic static void main(String[] args) throws Except"
},
{
"path": "USACO/NotLast.java",
"chars": 2275,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class NotLast {\n\tstatic int counter=0;\n\tpublic static void main(String[] a"
},
{
"path": "USACO/PromotionCounting.java",
"chars": 786,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class PromotionCounting {\n\n\tpublic static void main(String[] args) throws "
},
{
"path": "USACO/README.md",
"chars": 17,
"preview": "# USACO Problems\n"
},
{
"path": "USACO/SeqSum7.java",
"chars": 908,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class SeqSum7 {\n\tstatic int[] cows;\n\tpublic static void main(String[] args"
},
{
"path": "USACO/asdf.java",
"chars": 1803,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class asdf {\n\tstatic int minindex;\n\tstatic int min;\n\tstatic int time;\n\tsta"
},
{
"path": "USACO/friday.java",
"chars": 947,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class friday {\n\n\tpublic static void main(String[] args) throws IOException"
},
{
"path": "USACO/gift1.java",
"chars": 1363,
"preview": "/*\nID: joelpabraham\nLANG: JAVA\nTASK: gift1\n*/\nimport java.io.*;\nimport java.util.HashMap;\nimport java.util.StringTokeniz"
},
{
"path": "USACO/marathon.java",
"chars": 1477,
"preview": "import java.io.*;\nimport java.util.*;\n\npublic class marathon {\n\n\tpublic static void main(String[] args) throws IOExcepti"
},
{
"path": "USACO/reorder.java",
"chars": 1115,
"preview": "import java.io.*;\nimport java.util.*;\npublic class reorder {\n\t\n\tstatic int[] order_final;\n\tstatic int[] order_intial;\n\n\t"
},
{
"path": "USACO/ride.java",
"chars": 774,
"preview": "/*\nID: joelpabraham\nLANG: JAVA\nTASK: ride\n*/\n\nimport java.io.*;\nimport java.util.*;\n\n\npublic class ride {\n\n\tpublic stati"
},
{
"path": "USACO/sample.java",
"chars": 439,
"preview": "import java.io.File;\nimport java.io.PrintWriter;\nimport java.util.Scanner;\n\npublic class sample {\n\n\tpublic static void m"
},
{
"path": "USACO/test.java",
"chars": 567,
"preview": "import java.io.*;\nimport java.util.*;\nimport java.util.regex.*;\nimport java.util.stream.*;\n\npublic class test {\n\tpublic "
}
]
// ... and 1 more files (download for full content)
About this extraction
This page contains the full source code of the jpa99/Algorithms GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 145 files (23.4 MB), approximately 2.6M tokens, and a symbol index with 590 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.
Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.