From 8b92c3fdbeedb7ae0d3b5b6d79871af91cf7c2ea Mon Sep 17 00:00:00 2001 From: yanglbme Date: Wed, 6 Feb 2019 10:13:55 +0800 Subject: [PATCH] fix: remove unnecesary throw to fix #704 - Fix #704 - Thanks @lprone --- DataStructures/Heaps/EmptyHeapException.java | 7 +- DataStructures/Heaps/Heap.java | 25 +- DataStructures/Heaps/HeapElement.java | 58 ++-- DataStructures/Heaps/MaxHeap.java | 94 +++--- DataStructures/Heaps/MinHeap.java | 86 ++--- DataStructures/Heaps/MinPriorityQueue.java | 42 +-- .../LongestIncreasingSubsequence.java | 29 +- Others/Dijkshtra.java | 71 ++-- Others/Dijkstra.java | 319 +++++++++--------- 9 files changed, 368 insertions(+), 363 deletions(-) diff --git a/DataStructures/Heaps/EmptyHeapException.java b/DataStructures/Heaps/EmptyHeapException.java index b7d853c56..01668e2c8 100644 --- a/DataStructures/Heaps/EmptyHeapException.java +++ b/DataStructures/Heaps/EmptyHeapException.java @@ -1,16 +1,15 @@ /** - * + * */ -package heaps; +package Heaps; /** * @author Nicolas Renard * Exception to be thrown if the getElement method is used on an empty heap. - * */ @SuppressWarnings("serial") public class EmptyHeapException extends Exception { - + public EmptyHeapException(String message) { super(message); } diff --git a/DataStructures/Heaps/Heap.java b/DataStructures/Heaps/Heap.java index 02b2ba270..fe87d72a1 100644 --- a/DataStructures/Heaps/Heap.java +++ b/DataStructures/Heaps/Heap.java @@ -1,4 +1,4 @@ -package heaps; +package Heaps; /** * Interface common to heap data structures.
@@ -10,32 +10,31 @@ package heaps; * max-heap).

*

All heap-related operations (inserting or deleting an element, extracting the min or max) are performed in * O(log n) time.

+ * * @author Nicolas Renard - * - * */ public interface Heap { - + /** - * * @return the top element in the heap, the one with lowest key for min-heap or with * the highest key for max-heap - * @throws Exception if heap is empty + * @throws EmptyHeapException if heap is empty */ - public abstract HeapElement getElement() throws EmptyHeapException; + HeapElement getElement() throws EmptyHeapException; + /** * Inserts an element in the heap. Adds it to then end and toggle it until it finds its * right position. - * + * * @param element an instance of the HeapElement class. */ - public abstract void insertElement(HeapElement element); - + void insertElement(HeapElement element); + /** * Delete an element in the heap. - * + * * @param elementIndex int containing the position in the heap of the element to be deleted. */ - public abstract void deleteElement(int elementIndex); + void deleteElement(int elementIndex); -} +} \ No newline at end of file diff --git a/DataStructures/Heaps/HeapElement.java b/DataStructures/Heaps/HeapElement.java index e0cc93ccb..60640346b 100644 --- a/DataStructures/Heaps/HeapElement.java +++ b/DataStructures/Heaps/HeapElement.java @@ -1,7 +1,7 @@ /** - * + * */ -package heaps; +package Heaps; import java.lang.Double; import java.lang.Object; @@ -12,116 +12,110 @@ import java.lang.Object; * or double, either primitive type or object) and any kind of IMMUTABLE object the user sees fit * to carry any information he/she likes. Be aware that the use of a mutable object might * jeopardize the integrity of this information.

- * @author Nicolas Renard * + * @author Nicolas Renard */ public class HeapElement { private final double key; private final Object additionalInfo; - + // Constructors /** - * - * @param key : a number of primitive type 'double' + * @param key : a number of primitive type 'double' * @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry - * additional information of use for the user + * additional information of use for the user */ public HeapElement(double key, Object info) { this.key = key; this.additionalInfo = info; } - + /** - * - * @param key : a number of primitive type 'int' + * @param key : a number of primitive type 'int' * @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry - * additional information of use for the user + * additional information of use for the user */ public HeapElement(int key, Object info) { this.key = key; this.additionalInfo = info; } - + /** - * - * @param key : a number of object type 'Integer' + * @param key : a number of object type 'Integer' * @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry - * additional information of use for the user + * additional information of use for the user */ public HeapElement(Integer key, Object info) { this.key = key; this.additionalInfo = info; } - + /** - * - * @param key : a number of object type 'Double' + * @param key : a number of object type 'Double' * @param info : any kind of IMMUTABLE object. May be null, since the purpose is only to carry - * additional information of use for the user + * additional information of use for the user */ public HeapElement(Double key, Object info) { this.key = key; this.additionalInfo = info; } - + /** - * * @param key : a number of primitive type 'double' */ public HeapElement(double key) { this.key = key; this.additionalInfo = null; } - + /** - * * @param key : a number of primitive type 'int' */ public HeapElement(int key) { this.key = key; this.additionalInfo = null; } - + /** - * * @param key : a number of object type 'Integer' */ public HeapElement(Integer key) { this.key = key; this.additionalInfo = null; } - + /** - * * @param key : a number of object type 'Double' */ public HeapElement(Double key) { this.key = key; this.additionalInfo = null; } - + // Getters + /** * @return the object containing the additional info provided by the user. */ public Object getInfo() { return additionalInfo; } + /** * @return the key value of the element */ public double getKey() { return key; } - + // Overridden object methods - + public String toString() { - return "Key: " + key + " - " +additionalInfo.toString(); + return "Key: " + key + " - " + additionalInfo.toString(); } + /** - * * @param otherHeapElement * @return true if the keys on both elements are identical and the additional info objects * are identical. diff --git a/DataStructures/Heaps/MaxHeap.java b/DataStructures/Heaps/MaxHeap.java index 5f774e353..302840c14 100644 --- a/DataStructures/Heaps/MaxHeap.java +++ b/DataStructures/Heaps/MaxHeap.java @@ -1,4 +1,4 @@ -package heaps; +package Heaps; import java.util.ArrayList; import java.util.List; @@ -6,66 +6,71 @@ import java.util.List; /** * Heap tree where a node's key is higher than or equal to its parent's and lower than or equal * to its children's. - * @author Nicolas Renard * + * @author Nicolas Renard */ public class MaxHeap implements Heap { - + private final List maxHeap; - - public MaxHeap(List listElements) throws Exception { - maxHeap = new ArrayList(); + + public MaxHeap(List listElements) { + maxHeap = new ArrayList<>(); for (HeapElement heapElement : listElements) { if (heapElement != null) insertElement(heapElement); else System.out.println("Null element. Not added to heap"); } if (maxHeap.size() == 0) System.out.println("No element has been added, empty heap."); - } - - // Get the element at a given index. The key for the list is equal to index value - 1 + } + + /** + * Get the element at a given index. The key for the list is equal to index value - 1 + * + * @param elementIndex index + * @return heapElement + */ public HeapElement getElement(int elementIndex) { - if ((elementIndex <= 0) && (elementIndex > maxHeap.size())) throw new IndexOutOfBoundsException("Index out of heap range"); + if ((elementIndex <= 0) || (elementIndex > maxHeap.size())) + throw new IndexOutOfBoundsException("Index out of heap range"); return maxHeap.get(elementIndex - 1); } - + // Get the key of the element at a given index private double getElementKey(int elementIndex) { return maxHeap.get(elementIndex - 1).getKey(); } - + // Swaps two elements in the heap private void swap(int index1, int index2) { HeapElement temporaryElement = maxHeap.get(index1 - 1); maxHeap.set(index1 - 1, maxHeap.get(index2 - 1)); maxHeap.set(index2 - 1, temporaryElement); } - - // Toggle an element up to its right place as long as its key is lower than its parent's + + // Toggle an element up to its right place as long as its key is lower than its parent's private void toggleUp(int elementIndex) { double key = maxHeap.get(elementIndex - 1).getKey(); - while (getElementKey((int) Math.floor(elementIndex/2)) < key) { - swap(elementIndex, (int) Math.floor(elementIndex/2)); - elementIndex = (int) Math.floor(elementIndex/2); + while (getElementKey((int) Math.floor(elementIndex / 2)) < key) { + swap(elementIndex, (int) Math.floor(elementIndex / 2)); + elementIndex = (int) Math.floor(elementIndex / 2); } } - + // Toggle an element down to its right place as long as its key is higher - // than any of its children's + // than any of its children's private void toggleDown(int elementIndex) { double key = maxHeap.get(elementIndex - 1).getKey(); - boolean wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size()))); - while ((2*elementIndex <= maxHeap.size()) && wrongOrder) { + boolean wrongOrder = (key < getElementKey(elementIndex * 2)) || (key < getElementKey(Math.min(elementIndex * 2, maxHeap.size()))); + while ((2 * elementIndex <= maxHeap.size()) && wrongOrder) { // Check whether it shall swap the element with its left child or its right one if any. - if ((2*elementIndex < maxHeap.size()) && (getElementKey(elementIndex*2 + 1) > getElementKey(elementIndex*2))) { - swap(elementIndex, 2*elementIndex + 1); - elementIndex = 2*elementIndex + 1; + if ((2 * elementIndex < maxHeap.size()) && (getElementKey(elementIndex * 2 + 1) > getElementKey(elementIndex * 2))) { + swap(elementIndex, 2 * elementIndex + 1); + elementIndex = 2 * elementIndex + 1; + } else { + swap(elementIndex, 2 * elementIndex); + elementIndex = 2 * elementIndex; } - else { - swap(elementIndex, 2*elementIndex); - elementIndex = 2*elementIndex; - } - wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size()))); - + wrongOrder = (key < getElementKey(elementIndex * 2)) || (key < getElementKey(Math.min(elementIndex * 2, maxHeap.size()))); + } } @@ -84,21 +89,23 @@ public class MaxHeap implements Heap { @Override public void deleteElement(int elementIndex) { - if (maxHeap.isEmpty()) - try { - throw new EmptyHeapException("Attempt to delete an element from an empty heap"); - } catch (EmptyHeapException e) { - e.printStackTrace(); - } - if ((elementIndex > maxHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range"); + if (maxHeap.isEmpty()) + try { + throw new EmptyHeapException("Attempt to delete an element from an empty heap"); + } catch (EmptyHeapException e) { + e.printStackTrace(); + } + if ((elementIndex > maxHeap.size()) || (elementIndex <= 0)) + throw new IndexOutOfBoundsException("Index out of heap range"); // The last element in heap replaces the one to be deleted maxHeap.set(elementIndex - 1, getElement(maxHeap.size())); maxHeap.remove(maxHeap.size()); // Shall the new element be moved up... - if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex); - // ... or down ? - else if (((2*elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2))) || - ((2*elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2)))) toggleDown(elementIndex); + if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex); + // ... or down ? + else if (((2 * elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2))) || + ((2 * elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2)))) + toggleDown(elementIndex); } @Override @@ -109,7 +116,4 @@ public class MaxHeap implements Heap { throw new EmptyHeapException("Heap is empty. Error retrieving element"); } } - -} - - +} \ No newline at end of file diff --git a/DataStructures/Heaps/MinHeap.java b/DataStructures/Heaps/MinHeap.java index fbf2b86ff..5fca978f6 100644 --- a/DataStructures/Heaps/MinHeap.java +++ b/DataStructures/Heaps/MinHeap.java @@ -1,7 +1,7 @@ /** - * + * */ -package heaps; +package Heaps; import java.util.ArrayList; import java.util.List; @@ -9,66 +9,66 @@ import java.util.List; /** * Heap tree where a node's key is higher than or equal to its parent's and lower than or equal * to its children's. - * @author Nicolas Renard * + * @author Nicolas Renard */ public class MinHeap implements Heap { - + private final List minHeap; - - public MinHeap(List listElements) throws Exception { - minHeap = new ArrayList(); + + public MinHeap(List listElements) { + minHeap = new ArrayList<>(); for (HeapElement heapElement : listElements) { if (heapElement != null) insertElement(heapElement); else System.out.println("Null element. Not added to heap"); } if (minHeap.size() == 0) System.out.println("No element has been added, empty heap."); } - + // Get the element at a given index. The key for the list is equal to index value - 1 public HeapElement getElement(int elementIndex) { - if ((elementIndex <= 0) && (elementIndex > minHeap.size())) throw new IndexOutOfBoundsException("Index out of heap range"); + if ((elementIndex <= 0) || (elementIndex > minHeap.size())) + throw new IndexOutOfBoundsException("Index out of heap range"); return minHeap.get(elementIndex - 1); } - + // Get the key of the element at a given index private double getElementKey(int elementIndex) { return minHeap.get(elementIndex - 1).getKey(); } - + // Swaps two elements in the heap private void swap(int index1, int index2) { HeapElement temporaryElement = minHeap.get(index1 - 1); minHeap.set(index1 - 1, minHeap.get(index2 - 1)); minHeap.set(index2 - 1, temporaryElement); } - - // Toggle an element up to its right place as long as its key is lower than its parent's + + // Toggle an element up to its right place as long as its key is lower than its parent's private void toggleUp(int elementIndex) { double key = minHeap.get(elementIndex - 1).getKey(); - while (getElementKey((int) Math.floor(elementIndex/2)) > key) { - swap(elementIndex, (int) Math.floor(elementIndex/2)); - elementIndex = (int) Math.floor(elementIndex/2); + while (getElementKey((int) Math.floor(elementIndex / 2)) > key) { + swap(elementIndex, (int) Math.floor(elementIndex / 2)); + elementIndex = (int) Math.floor(elementIndex / 2); } } - + // Toggle an element down to its right place as long as its key is higher - // than any of its children's + // than any of its children's private void toggleDown(int elementIndex) { double key = minHeap.get(elementIndex - 1).getKey(); - boolean wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size()))); - while ((2*elementIndex <= minHeap.size()) && wrongOrder) { + boolean wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size()))); + while ((2 * elementIndex <= minHeap.size()) && wrongOrder) { // Check whether it shall swap the element with its left child or its right one if any. - if ((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex*2 + 1) < getElementKey(elementIndex*2))) { - swap(elementIndex, 2*elementIndex + 1); - elementIndex = 2*elementIndex + 1; + if ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex * 2 + 1) < getElementKey(elementIndex * 2))) { + swap(elementIndex, 2 * elementIndex + 1); + elementIndex = 2 * elementIndex + 1; + } else { + swap(elementIndex, 2 * elementIndex); + elementIndex = 2 * elementIndex; } - else { - swap(elementIndex, 2*elementIndex); - elementIndex = 2*elementIndex; - } - wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size()))); - + wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size()))); + } } @@ -87,23 +87,25 @@ public class MinHeap implements Heap { @Override public void deleteElement(int elementIndex) { - if (minHeap.isEmpty()) - try { - throw new EmptyHeapException("Attempt to delete an element from an empty heap"); - } catch (EmptyHeapException e) { - e.printStackTrace(); - } - if ((elementIndex > minHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range"); + if (minHeap.isEmpty()) + try { + throw new EmptyHeapException("Attempt to delete an element from an empty heap"); + } catch (EmptyHeapException e) { + e.printStackTrace(); + } + if ((elementIndex > minHeap.size()) || (elementIndex <= 0)) + throw new IndexOutOfBoundsException("Index out of heap range"); // The last element in heap replaces the one to be deleted minHeap.set(elementIndex - 1, getElement(minHeap.size())); minHeap.remove(minHeap.size()); // Shall the new element be moved up... - if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex); - // ... or down ? - else if (((2*elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2))) || - ((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2)))) toggleDown(elementIndex); + if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex); + // ... or down ? + else if (((2 * elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))) || + ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2)))) + toggleDown(elementIndex); } - + @Override public HeapElement getElement() throws EmptyHeapException { try { @@ -112,4 +114,4 @@ public class MinHeap implements Heap { throw new EmptyHeapException("Heap is empty. Error retrieving element"); } } -} +} \ No newline at end of file diff --git a/DataStructures/Heaps/MinPriorityQueue.java b/DataStructures/Heaps/MinPriorityQueue.java index 3dc2bd280..f117b9328 100644 --- a/DataStructures/Heaps/MinPriorityQueue.java +++ b/DataStructures/Heaps/MinPriorityQueue.java @@ -1,13 +1,13 @@ - +package Heaps; /* Minimum Priority Queue -* It is a part of heap data structure -* A heap is a specific tree based data structure -* in which all the nodes of tree are in a specific order. -* that is the children are arranged in some -* respect of their parents, can either be greater -* or less than the parent. This makes it a min priority queue -* or max priority queue. -*/ + * It is a part of heap data structure + * A heap is a specific tree based data structure + * in which all the nodes of tree are in a specific order. + * that is the children are arranged in some + * respect of their parents, can either be greater + * or less than the parent. This makes it a min priority queue + * or max priority queue. + */ // Functions: insert, delete, peek, isEmpty, print, heapSort, sink @@ -16,15 +16,15 @@ public class MinPriorityQueue { private int capacity; private int size; - // calss the constructor and initializes the capacity + // calss the constructor and initializes the capacity MinPriorityQueue(int c) { this.capacity = c; this.size = 0; this.heap = new int[c + 1]; } - // inserts the key at the end and rearranges it - // so that the binary heap is in appropriate order + // inserts the key at the end and rearranges it + // so that the binary heap is in appropriate order public void insert(int key) { if (this.isFull()) return; @@ -41,41 +41,41 @@ public class MinPriorityQueue { this.size++; } - // returns the highest priority value + // returns the highest priority value public int peek() { return this.heap[1]; } - // returns boolean value whether the heap is empty or not + // returns boolean value whether the heap is empty or not public boolean isEmpty() { if (0 == this.size) return true; return false; } - // returns boolean value whether the heap is full or not + // returns boolean value whether the heap is full or not public boolean isFull() { if (this.size == this.capacity) return true; return false; } - // prints the heap + // prints the heap public void print() { for (int i = 1; i <= this.capacity; i++) System.out.print(this.heap[i] + " "); System.out.println(); } - // heap sorting can be done by performing - // delete function to the number of times of the size of the heap - // it returns reverse sort because it is a min priority queue + // heap sorting can be done by performing + // delete function to the number of times of the size of the heap + // it returns reverse sort because it is a min priority queue public void heapSort() { for (int i = 1; i < this.capacity; i++) this.delete(); } - // this function reorders the heap after every delete function + // this function reorders the heap after every delete function private void sink() { int k = 1; while (2 * k <= this.size || 2 * k + 1 <= this.size) { @@ -103,7 +103,7 @@ public class MinPriorityQueue { } } - // deletes the highest priority value from the heap + // deletes the highest priority value from the heap public int delete() { int min = this.heap[1]; this.heap[1] = this.heap[this.size]; diff --git a/Dynamic Programming/LongestIncreasingSubsequence.java b/Dynamic Programming/LongestIncreasingSubsequence.java index eaa574a40..ccbb88468 100644 --- a/Dynamic Programming/LongestIncreasingSubsequence.java +++ b/Dynamic Programming/LongestIncreasingSubsequence.java @@ -1,12 +1,11 @@ import java.util.Scanner; /** - * * @author Afrizal Fikri (https://github.com/icalF) - * + * @author Libin Yang (https://github.com/yanglbme) */ public class LongestIncreasingSubsequence { - public static void main(String[] args) throws Exception { + public static void main(String[] args) { Scanner sc = new Scanner(System.in); int n = sc.nextInt(); @@ -20,7 +19,7 @@ public class LongestIncreasingSubsequence { } private static int upperBound(int[] ar, int l, int r, int key) { - while (l < r-1) { + while (l < r - 1) { int m = (l + r) / 2; if (ar[m] >= key) r = m; @@ -35,10 +34,12 @@ public class LongestIncreasingSubsequence { int N = array.length; if (N == 0) return 0; - + int[] tail = new int[N]; - int length = 1; // always points empty slot in tail - + + // always points empty slot in tail + int length = 1; + tail[0] = array[0]; for (int i = 1; i < N; i++) { @@ -46,17 +47,17 @@ public class LongestIncreasingSubsequence { if (array[i] < tail[0]) tail[0] = array[i]; - // array[i] extends largest subsequence - else if (array[i] > tail[length-1]) + // array[i] extends largest subsequence + else if (array[i] > tail[length - 1]) tail[length++] = array[i]; - // array[i] will become end candidate of an existing subsequence or - // Throw away larger elements in all LIS, to make room for upcoming grater elements than array[i] - // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it) + // array[i] will become end candidate of an existing subsequence or + // Throw away larger elements in all LIS, to make room for upcoming grater elements than array[i] + // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it) else - tail[upperBound(tail, -1, length-1, array[i])] = array[i]; + tail[upperBound(tail, -1, length - 1, array[i])] = array[i]; } - + return length; } } \ No newline at end of file diff --git a/Others/Dijkshtra.java b/Others/Dijkshtra.java index e0bd6737a..17f839177 100644 --- a/Others/Dijkshtra.java +++ b/Others/Dijkshtra.java @@ -1,83 +1,82 @@ -/* -@author : Mayank K Jha +/** + * @author Mayank K Jha + */ -*/ - -import java.io.IOException; import java.util.Arrays; import java.util.Scanner; import java.util.Stack; public class Dijkshtra { - public static void main(String[] args) throws IOException { + public static void main(String[] args) { Scanner in = new Scanner(System.in); // n = Number of nodes or vertices - int n = in.nextInt(); + int n = in.nextInt(); // m = Number of Edges - int m = in.nextInt(); + int m = in.nextInt(); // Adjacency Matrix - long w[][] = new long [n+1][n+1]; + long[][] w = new long[n + 1][n + 1]; - //Initializing Matrix with Certain Maximum Value for path b/w any two vertices + // Initializing Matrix with Certain Maximum Value for path b/w any two vertices for (long[] row : w) { - Arrays.fill(row, 1000000l); + Arrays.fill(row, 1000000L); } /* From above,we Have assumed that,initially path b/w any two Pair of vertices is Infinite such that Infinite = 1000000l For simplicity , We can also take path Value = Long.MAX_VALUE , but i have taken Max Value = 1000000l */ // Taking Input as Edge Location b/w a pair of vertices - for(int i = 0; i < m; i++) { - int x = in.nextInt(),y=in.nextInt(); - long cmp = in.nextLong(); + for (int i = 0; i < m; i++) { + int x = in.nextInt(), y = in.nextInt(); + long cmp = in.nextLong(); - //Comparing previous edge value with current value - Cycle Case - if(w[x][y] > cmp) { - w[x][y] = cmp; w[y][x] = cmp; - } + // Comparing previous edge value with current value - Cycle Case + if (w[x][y] > cmp) { + w[x][y] = cmp; + w[y][x] = cmp; + } } - // Implementing Dijkshtra's Algorithm - Stack t = new Stack(); + // Implementing Dijkshtra's Algorithm + Stack t = new Stack<>(); int src = in.nextInt(); - for(int i = 1; i <= n; i++) { - if(i != src) { + for (int i = 1; i <= n; i++) { + if (i != src) { t.push(i); } } - Stack p = new Stack(); + Stack p = new Stack<>(); p.push(src); w[src][src] = 0; - while(!t.isEmpty()) { + while (!t.isEmpty()) { int min = 989997979; int loc = -1; - for(int i = 0; i < t.size(); i++) { + for (int i = 0; i < t.size(); i++) { w[src][t.elementAt(i)] = Math.min(w[src][t.elementAt(i)], w[src][p.peek()] + w[p.peek()][t.elementAt(i)]); - if(w[src][t.elementAt(i)] <= min) { + if (w[src][t.elementAt(i)] <= min) { min = (int) w[src][t.elementAt(i)]; loc = i; } } p.push(t.elementAt(loc)); t.removeElementAt(loc); - } + } // Printing shortest path from the given source src - for(int i = 1; i <= n; i++) { - if(i != src && w[src][i] != 1000000l) { - System.out.print(w[src][i] + " "); + for (int i = 1; i <= n; i++) { + if (i != src && w[src][i] != 1000000L) { + System.out.print(w[src][i] + " "); + } + // Printing -1 if there is no path b/w given pair of edges + else if (i != src) { + System.out.print("-1" + " "); + } } - // Printing -1 if there is no path b/w given pair of edges - else if(i != src) { - System.out.print("-1" + " "); - } - } } -} +} \ No newline at end of file diff --git a/Others/Dijkstra.java b/Others/Dijkstra.java index b3df65bfd..e8ad2680f 100644 --- a/Others/Dijkstra.java +++ b/Others/Dijkstra.java @@ -5,167 +5,174 @@ package Others; * Dijkstra's algorithm,is a graph search algorithm that solves the single-source * shortest path problem for a graph with nonnegative edge path costs, producing * a shortest path tree. - * + *

* NOTE: The inputs to Dijkstra's algorithm are a directed and weighted graph consisting * of 2 or more nodes, generally represented by an adjacency matrix or list, and a start node. - * + *

* Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java * Also most of the comments are from RosettaCode. - * */ -//import java.io.*; -import java.util.*; -public class Dijkstra { - private static final Graph.Edge[] GRAPH = { - new Graph.Edge("a", "b", 7), //Distance from node "a" to node "b" is 7. In the current Graph there is no way to move the other way (e,g, from "b" to "a"), a new edge would be needed for that - new Graph.Edge("a", "c", 9), - new Graph.Edge("a", "f", 14), - new Graph.Edge("b", "c", 10), - new Graph.Edge("b", "d", 15), - new Graph.Edge("c", "d", 11), - new Graph.Edge("c", "f", 2), - new Graph.Edge("d", "e", 6), - new Graph.Edge("e", "f", 9), - }; - private static final String START = "a"; - private static final String END = "e"; - /** - * main function - * Will run the code with "GRAPH" that was defined above. - */ - public static void main(String[] args) { - Graph g = new Graph(GRAPH); - g.dijkstra(START); - g.printPath(END); - //g.printAllPaths(); - } +import java.util.*; + +public class Dijkstra { + private static final Graph.Edge[] GRAPH = { + // Distance from node "a" to node "b" is 7. + // In the current Graph there is no way to move the other way (e,g, from "b" to "a"), + // a new edge would be needed for that + new Graph.Edge("a", "b", 7), + new Graph.Edge("a", "c", 9), + new Graph.Edge("a", "f", 14), + new Graph.Edge("b", "c", 10), + new Graph.Edge("b", "d", 15), + new Graph.Edge("c", "d", 11), + new Graph.Edge("c", "f", 2), + new Graph.Edge("d", "e", 6), + new Graph.Edge("e", "f", 9), + }; + private static final String START = "a"; + private static final String END = "e"; + + /** + * main function + * Will run the code with "GRAPH" that was defined above. + */ + public static void main(String[] args) { + Graph g = new Graph(GRAPH); + g.dijkstra(START); + g.printPath(END); + //g.printAllPaths(); + } } - + class Graph { - private final Map graph; // mapping of vertex names to Vertex objects, built from a set of Edges - - /** One edge of the graph (only used by Graph constructor) */ - public static class Edge { - public final String v1, v2; - public final int dist; - public Edge(String v1, String v2, int dist) { - this.v1 = v1; - this.v2 = v2; - this.dist = dist; - } - } - - /** One vertex of the graph, complete with mappings to neighbouring vertices */ - public static class Vertex implements Comparable { - public final String name; - public int dist = Integer.MAX_VALUE; // MAX_VALUE assumed to be infinity - public Vertex previous = null; - public final Map neighbours = new HashMap<>(); - - public Vertex(String name) { - this.name = name; - } - - private void printPath() { - if (this == this.previous) { - System.out.printf("%s", this.name); - } - else if (this.previous == null) { - System.out.printf("%s(unreached)", this.name); - } - else { - this.previous.printPath(); - System.out.printf(" -> %s(%d)", this.name, this.dist); - } - } - - public int compareTo(Vertex other) { - if (dist == other.dist) - return name.compareTo(other.name); - - return Integer.compare(dist, other.dist); - } - - @Override public String toString() { - return "(" + name + ", " + dist + ")"; - } -} - - /** Builds a graph from a set of edges */ - public Graph(Edge[] edges) { - graph = new HashMap<>(edges.length); - - //one pass to find all vertices - for (Edge e : edges) { - if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); - if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2)); - } - - //another pass to set neighbouring vertices - for (Edge e : edges) { - graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist); - //graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph - } - } - - /** Runs dijkstra using a specified source vertex */ - public void dijkstra(String startName) { - if (!graph.containsKey(startName)) { - System.err.printf("Graph doesn't contain start vertex \"%s\"\n", startName); - return; - } - final Vertex source = graph.get(startName); - NavigableSet q = new TreeSet<>(); - - // set-up vertices - for (Vertex v : graph.values()) { - v.previous = v == source ? source : null; - v.dist = v == source ? 0 : Integer.MAX_VALUE; - q.add(v); - } - - dijkstra(q); - } - - /** Implementation of dijkstra's algorithm using a binary heap. */ - private void dijkstra(final NavigableSet q) { - Vertex u, v; - while (!q.isEmpty()) { - - u = q.pollFirst(); // vertex with shortest distance (first iteration will return source) - if (u.dist == Integer.MAX_VALUE) break; // we can ignore u (and any other remaining vertices) since they are unreachable - - //look at distances to each neighbour - for (Map.Entry a : u.neighbours.entrySet()) { - v = a.getKey(); //the neighbour in this iteration - - final int alternateDist = u.dist + a.getValue(); - if (alternateDist < v.dist) { // shorter path to neighbour found - q.remove(v); - v.dist = alternateDist; - v.previous = u; - q.add(v); - } - } - } - } - - /** Prints a path from the source to the specified vertex */ - public void printPath(String endName) { - if (!graph.containsKey(endName)) { - System.err.printf("Graph doesn't contain end vertex \"%s\"\n", endName); - return; - } - - graph.get(endName).printPath(); - System.out.println(); - } - /** Prints the path from the source to every vertex (output order is not guaranteed) */ - public void printAllPaths() { - for (Vertex v : graph.values()) { - v.printPath(); - System.out.println(); - } - } -} + // mapping of vertex names to Vertex objects, built from a set of Edges + private final Map graph; + + /** One edge of the graph (only used by Graph constructor) */ + public static class Edge { + public final String v1, v2; + public final int dist; + + public Edge(String v1, String v2, int dist) { + this.v1 = v1; + this.v2 = v2; + this.dist = dist; + } + } + + /** One vertex of the graph, complete with mappings to neighbouring vertices */ + public static class Vertex implements Comparable { + public final String name; + // MAX_VALUE assumed to be infinity + public int dist = Integer.MAX_VALUE; + public Vertex previous = null; + public final Map neighbours = new HashMap<>(); + + public Vertex(String name) { + this.name = name; + } + + private void printPath() { + if (this == this.previous) { + System.out.printf("%s", this.name); + } else if (this.previous == null) { + System.out.printf("%s(unreached)", this.name); + } else { + this.previous.printPath(); + System.out.printf(" -> %s(%d)", this.name, this.dist); + } + } + + public int compareTo(Vertex other) { + if (dist == other.dist) + return name.compareTo(other.name); + + return Integer.compare(dist, other.dist); + } + + @Override + public String toString() { + return "(" + name + ", " + dist + ")"; + } + } + + /** Builds a graph from a set of edges */ + public Graph(Edge[] edges) { + graph = new HashMap<>(edges.length); + + // one pass to find all vertices + for (Edge e : edges) { + if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); + if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2)); + } + + // another pass to set neighbouring vertices + for (Edge e : edges) { + graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist); + // graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph + } + } + + /** Runs dijkstra using a specified source vertex */ + public void dijkstra(String startName) { + if (!graph.containsKey(startName)) { + System.err.printf("Graph doesn't contain start vertex \"%s\"\n", startName); + return; + } + final Vertex source = graph.get(startName); + NavigableSet q = new TreeSet<>(); + + // set-up vertices + for (Vertex v : graph.values()) { + v.previous = v == source ? source : null; + v.dist = v == source ? 0 : Integer.MAX_VALUE; + q.add(v); + } + + dijkstra(q); + } + + /** Implementation of dijkstra's algorithm using a binary heap. */ + private void dijkstra(final NavigableSet q) { + Vertex u, v; + while (!q.isEmpty()) { + // vertex with shortest distance (first iteration will return source) + u = q.pollFirst(); + if (u.dist == Integer.MAX_VALUE) + break; // we can ignore u (and any other remaining vertices) since they are unreachable + + // look at distances to each neighbour + for (Map.Entry a : u.neighbours.entrySet()) { + v = a.getKey(); // the neighbour in this iteration + + final int alternateDist = u.dist + a.getValue(); + if (alternateDist < v.dist) { // shorter path to neighbour found + q.remove(v); + v.dist = alternateDist; + v.previous = u; + q.add(v); + } + } + } + } + + /** Prints a path from the source to the specified vertex */ + public void printPath(String endName) { + if (!graph.containsKey(endName)) { + System.err.printf("Graph doesn't contain end vertex \"%s\"\n", endName); + return; + } + + graph.get(endName).printPath(); + System.out.println(); + } + + /** Prints the path from the source to every vertex (output order is not guaranteed) */ + public void printAllPaths() { + for (Vertex v : graph.values()) { + v.printPath(); + System.out.println(); + } + } +} \ No newline at end of file