algorithm/Java
1
0
Fork 0
mirror of https://github.com/TheAlgorithms/Java.git synced 2025-07-14 01:16:07 +08:00
Code Issues Packages Projects Releases Wiki Activity

fix: remove unnecesary throw to fix #704

Browse Source 
- Fix #704
- Thanks @lprone
This commit is contained in:
yanglbme
2019-02-06 10:13:55 +08:00
parent bb670a2ceb
commit 8b92c3fdbe
9 changed files with 368 additions and 363 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
DataStructures/Heaps/EmptyHeapException.java
View File

@ -1,12 +1,11 @@
/** /**
* *
*/ */
package heaps; package Heaps;
/** /**
* @author Nicolas Renard * @author Nicolas Renard
* Exception to be thrown if the getElement method is used on an empty heap. * Exception to be thrown if the getElement method is used on an empty heap.
*
*/ */
@SuppressWarnings("serial") @SuppressWarnings("serial")
public class EmptyHeapException extends Exception { public class EmptyHeapException extends Exception {

15
DataStructures/Heaps/Heap.java
View File

@ -1,4 +1,4 @@
package heaps; package Heaps;
/** /**
* Interface common to heap data structures.<br> * Interface common to heap data structures.<br>
@ -10,32 +10,31 @@ package heaps;
* max-heap).</p> * max-heap).</p>
* <p>All heap-related operations (inserting or deleting an element, extracting the min or max) are performed in * <p>All heap-related operations (inserting or deleting an element, extracting the min or max) are performed in
* O(log n) time.</p> * O(log n) time.</p>
*
* @author Nicolas Renard * @author Nicolas Renard
*
*
*/ */
public interface Heap { public interface Heap {
/** /**
*
* @return the top element in the heap, the one with lowest key for min-heap or with * @return the top element in the heap, the one with lowest key for min-heap or with
* the highest key for max-heap * 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 * Inserts an element in the heap. Adds it to then end and toggle it until it finds its
* right position. * right position.
* *
* @param element an instance of the HeapElement class. * @param element an instance of the HeapElement class.
*/ */
public abstract void insertElement(HeapElement element); void insertElement(HeapElement element);
/** /**
* Delete an element in the heap. * Delete an element in the heap.
* *
* @param elementIndex int containing the position in the heap of the element to be deleted. * @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);
} }

18
DataStructures/Heaps/HeapElement.java
View File

@ -1,7 +1,7 @@
/** /**
* *
*/ */
package heaps; package Heaps;
import java.lang.Double; import java.lang.Double;
import java.lang.Object; import java.lang.Object;
@ -12,8 +12,8 @@ import java.lang.Object;
* or double, either primitive type or object) and any kind of IMMUTABLE object the user sees fit * 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 * to carry any information he/she likes. Be aware that the use of a mutable object might
* jeopardize the integrity of this information. </p> * jeopardize the integrity of this information. </p>
* @author Nicolas Renard
* *
* @author Nicolas Renard
*/ */
public class HeapElement { public class HeapElement {
private final double key; private final double key;
@ -22,7 +22,6 @@ public class HeapElement {
// Constructors // 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 * @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
@ -33,7 +32,6 @@ public class HeapElement {
} }
/** /**
*
* @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 * @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
@ -44,7 +42,6 @@ public class HeapElement {
} }
/** /**
*
* @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 * @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
@ -55,7 +52,6 @@ public class HeapElement {
} }
/** /**
*
* @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 * @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
@ -66,7 +62,6 @@ public class HeapElement {
} }
/** /**
*
* @param key : a number of primitive type 'double' * @param key : a number of primitive type 'double'
*/ */
public HeapElement(double key) { public HeapElement(double key) {
@ -75,7 +70,6 @@ public class HeapElement {
} }
/** /**
*
* @param key : a number of primitive type 'int' * @param key : a number of primitive type 'int'
*/ */
public HeapElement(int key) { public HeapElement(int key) {
@ -84,7 +78,6 @@ public class HeapElement {
} }
/** /**
*
* @param key : a number of object type 'Integer' * @param key : a number of object type 'Integer'
*/ */
public HeapElement(Integer key) { public HeapElement(Integer key) {
@ -93,7 +86,6 @@ public class HeapElement {
} }
/** /**
*
* @param key : a number of object type 'Double' * @param key : a number of object type 'Double'
*/ */
public HeapElement(Double key) { public HeapElement(Double key) {
@ -102,12 +94,14 @@ public class HeapElement {
} }
// Getters // Getters
/** /**
* @return the object containing the additional info provided by the user. * @return the object containing the additional info provided by the user.
*/ */
public Object getInfo() { public Object getInfo() {
return additionalInfo; return additionalInfo;
} }
/** /**
* @return the key value of the element * @return the key value of the element
*/ */
@ -118,10 +112,10 @@ public class HeapElement {
// Overridden object methods // Overridden object methods
public String toString() { public String toString() {
return "Key: " + key + " - " +additionalInfo.toString(); return "Key: " + key + " - " + additionalInfo.toString();
} }
/** /**
*
* @param otherHeapElement * @param otherHeapElement
* @return true if the keys on both elements are identical and the additional info objects * @return true if the keys on both elements are identical and the additional info objects
* are identical. * are identical.

56
DataStructures/Heaps/MaxHeap.java
View File

@ -1,4 +1,4 @@
package heaps; package Heaps;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -6,15 +6,15 @@ 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 * 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. * to its children's.
* @author Nicolas Renard
* *
* @author Nicolas Renard
*/ */
public class MaxHeap implements Heap { public class MaxHeap implements Heap {
private final List<HeapElement> maxHeap; private final List<HeapElement> maxHeap;
public MaxHeap(List<HeapElement> listElements) throws Exception { public MaxHeap(List<HeapElement> listElements) {
maxHeap = new ArrayList<HeapElement>(); maxHeap = new ArrayList<>();
for (HeapElement heapElement : listElements) { for (HeapElement heapElement : listElements) {
if (heapElement != null) insertElement(heapElement); if (heapElement != null) insertElement(heapElement);
else System.out.println("Null element. Not added to heap"); else System.out.println("Null element. Not added to heap");
@ -22,9 +22,15 @@ public class MaxHeap implements Heap {
if (maxHeap.size() == 0) System.out.println("No element has been added, empty 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) { 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); return maxHeap.get(elementIndex - 1);
} }
@ -43,9 +49,9 @@ public class MaxHeap implements Heap {
// 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) { private void toggleUp(int elementIndex) {
double key = maxHeap.get(elementIndex - 1).getKey(); double key = maxHeap.get(elementIndex - 1).getKey();
while (getElementKey((int) Math.floor(elementIndex/2)) < key) { while (getElementKey((int) Math.floor(elementIndex / 2)) < key) {
swap(elementIndex, (int) Math.floor(elementIndex/2)); swap(elementIndex, (int) Math.floor(elementIndex / 2));
elementIndex = (int) Math.floor(elementIndex/2); elementIndex = (int) Math.floor(elementIndex / 2);
} }
} }
@ -53,18 +59,17 @@ public class MaxHeap implements Heap {
// than any of its children's // than any of its children's
private void toggleDown(int elementIndex) { private void toggleDown(int elementIndex) {
double key = maxHeap.get(elementIndex - 1).getKey(); double key = maxHeap.get(elementIndex - 1).getKey();
boolean wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size()))); boolean wrongOrder = (key < getElementKey(elementIndex * 2)) || (key < getElementKey(Math.min(elementIndex * 2, maxHeap.size())));
while ((2*elementIndex <= maxHeap.size()) && wrongOrder) { while ((2 * elementIndex <= maxHeap.size()) && wrongOrder) {
// Check whether it shall swap the element with its left child or its right one if any. // 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))) { if ((2 * elementIndex < maxHeap.size()) && (getElementKey(elementIndex * 2 + 1) > getElementKey(elementIndex * 2))) {
swap(elementIndex, 2*elementIndex + 1); swap(elementIndex, 2 * elementIndex + 1);
elementIndex = 2*elementIndex + 1; elementIndex = 2 * elementIndex + 1;
} else {
swap(elementIndex, 2 * elementIndex);
elementIndex = 2 * elementIndex;
} }
else { wrongOrder = (key < getElementKey(elementIndex * 2)) || (key < getElementKey(Math.min(elementIndex * 2, maxHeap.size())));
swap(elementIndex, 2*elementIndex);
elementIndex = 2*elementIndex;
}
wrongOrder = (key < getElementKey(elementIndex*2)) || (key < getElementKey(Math.min(elementIndex*2, maxHeap.size())));
} }
} }
@ -90,15 +95,17 @@ public class MaxHeap implements Heap {
} catch (EmptyHeapException e) { } catch (EmptyHeapException e) {
e.printStackTrace(); e.printStackTrace();
} }
if ((elementIndex > maxHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range"); 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 // The last element in heap replaces the one to be deleted
maxHeap.set(elementIndex - 1, getElement(maxHeap.size())); maxHeap.set(elementIndex - 1, getElement(maxHeap.size()));
maxHeap.remove(maxHeap.size()); maxHeap.remove(maxHeap.size());
// Shall the new element be moved up... // Shall the new element be moved up...
if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex); if (getElementKey(elementIndex) > getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex);
// ... or down ? // ... or down ?
else if (((2*elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2))) || else if (((2 * elementIndex <= maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2))) ||
((2*elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex*2)))) toggleDown(elementIndex); ((2 * elementIndex < maxHeap.size()) && (getElementKey(elementIndex) < getElementKey(elementIndex * 2))))
toggleDown(elementIndex);
} }
@Override @Override
@ -109,7 +116,4 @@ public class MaxHeap implements Heap {
throw new EmptyHeapException("Heap is empty. Error retrieving element"); throw new EmptyHeapException("Heap is empty. Error retrieving element");
} }
} }
} }

46
DataStructures/Heaps/MinHeap.java
View File

@ -1,7 +1,7 @@
/** /**
* *
*/ */
package heaps; package Heaps;
import java.util.ArrayList; import java.util.ArrayList;
import java.util.List; import java.util.List;
@ -9,15 +9,15 @@ 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 * 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. * to its children's.
* @author Nicolas Renard
* *
* @author Nicolas Renard
*/ */
public class MinHeap implements Heap { public class MinHeap implements Heap {
private final List<HeapElement> minHeap; private final List<HeapElement> minHeap;
public MinHeap(List<HeapElement> listElements) throws Exception { public MinHeap(List<HeapElement> listElements) {
minHeap = new ArrayList<HeapElement>(); minHeap = new ArrayList<>();
for (HeapElement heapElement : listElements) { for (HeapElement heapElement : listElements) {
if (heapElement != null) insertElement(heapElement); if (heapElement != null) insertElement(heapElement);
else System.out.println("Null element. Not added to heap"); else System.out.println("Null element. Not added to heap");
@ -27,7 +27,8 @@ public class MinHeap implements 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
public HeapElement getElement(int elementIndex) { 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); return minHeap.get(elementIndex - 1);
} }
@ -46,9 +47,9 @@ public class MinHeap implements Heap {
// 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) { private void toggleUp(int elementIndex) {
double key = minHeap.get(elementIndex - 1).getKey(); double key = minHeap.get(elementIndex - 1).getKey();
while (getElementKey((int) Math.floor(elementIndex/2)) > key) { while (getElementKey((int) Math.floor(elementIndex / 2)) > key) {
swap(elementIndex, (int) Math.floor(elementIndex/2)); swap(elementIndex, (int) Math.floor(elementIndex / 2));
elementIndex = (int) Math.floor(elementIndex/2); elementIndex = (int) Math.floor(elementIndex / 2);
} }
} }
@ -56,18 +57,17 @@ public class MinHeap implements Heap {
// than any of its children's // than any of its children's
private void toggleDown(int elementIndex) { private void toggleDown(int elementIndex) {
double key = minHeap.get(elementIndex - 1).getKey(); double key = minHeap.get(elementIndex - 1).getKey();
boolean wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size()))); boolean wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size())));
while ((2*elementIndex <= minHeap.size()) && wrongOrder) { while ((2 * elementIndex <= minHeap.size()) && wrongOrder) {
// Check whether it shall swap the element with its left child or its right one if any. // 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))) { if ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex * 2 + 1) < getElementKey(elementIndex * 2))) {
swap(elementIndex, 2*elementIndex + 1); swap(elementIndex, 2 * elementIndex + 1);
elementIndex = 2*elementIndex + 1; elementIndex = 2 * elementIndex + 1;
} else {
swap(elementIndex, 2 * elementIndex);
elementIndex = 2 * elementIndex;
} }
else { wrongOrder = (key > getElementKey(elementIndex * 2)) || (key > getElementKey(Math.min(elementIndex * 2, minHeap.size())));
swap(elementIndex, 2*elementIndex);
elementIndex = 2*elementIndex;
}
wrongOrder = (key > getElementKey(elementIndex*2)) || (key > getElementKey(Math.min(elementIndex*2, minHeap.size())));
} }
} }
@ -93,15 +93,17 @@ public class MinHeap implements Heap {
} catch (EmptyHeapException e) { } catch (EmptyHeapException e) {
e.printStackTrace(); e.printStackTrace();
} }
if ((elementIndex > minHeap.size()) && (elementIndex <= 0)) throw new IndexOutOfBoundsException("Index out of heap range"); 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 // The last element in heap replaces the one to be deleted
minHeap.set(elementIndex - 1, getElement(minHeap.size())); minHeap.set(elementIndex - 1, getElement(minHeap.size()));
minHeap.remove(minHeap.size()); minHeap.remove(minHeap.size());
// Shall the new element be moved up... // Shall the new element be moved up...
if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex/2))) toggleUp(elementIndex); if (getElementKey(elementIndex) < getElementKey((int) Math.floor(elementIndex / 2))) toggleUp(elementIndex);
// ... or down ? // ... or down ?
else if (((2*elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2))) || else if (((2 * elementIndex <= minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))) ||
((2*elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex*2)))) toggleDown(elementIndex); ((2 * elementIndex < minHeap.size()) && (getElementKey(elementIndex) > getElementKey(elementIndex * 2))))
toggleDown(elementIndex);
} }
@Override @Override

18
DataStructures/Heaps/MinPriorityQueue.java
View File

@ -1,13 +1,13 @@
package Heaps;
/* Minimum Priority Queue /* Minimum Priority Queue
* It is a part of heap data structure * It is a part of heap data structure
* A heap is a specific tree based data structure * A heap is a specific tree based data structure
* in which all the nodes of tree are in a specific order. * in which all the nodes of tree are in a specific order.
* that is the children are arranged in some * that is the children are arranged in some
* respect of their parents, can either be greater * respect of their parents, can either be greater
* or less than the parent. This makes it a min priority queue * or less than the parent. This makes it a min priority queue
* or max priority queue. * or max priority queue.
*/ */
// Functions: insert, delete, peek, isEmpty, print, heapSort, sink // Functions: insert, delete, peek, isEmpty, print, heapSort, sink

15
Dynamic Programming/LongestIncreasingSubsequence.java
View File

@ -1,12 +1,11 @@
import java.util.Scanner; import java.util.Scanner;
/** /**
*
* @author Afrizal Fikri (https://github.com/icalF) * @author Afrizal Fikri (https://github.com/icalF)
* * @author Libin Yang (https://github.com/yanglbme)
*/ */
public class LongestIncreasingSubsequence { public class LongestIncreasingSubsequence {
public static void main(String[] args) throws Exception { public static void main(String[] args) {
Scanner sc = new Scanner(System.in); Scanner sc = new Scanner(System.in);
int n = sc.nextInt(); int n = sc.nextInt();
@ -20,7 +19,7 @@ public class LongestIncreasingSubsequence {
} }
private static int upperBound(int[] ar, int l, int r, int key) { 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; int m = (l + r) / 2;
if (ar[m] >= key) if (ar[m] >= key)
r = m; r = m;
@ -37,7 +36,9 @@ public class LongestIncreasingSubsequence {
return 0; return 0;
int[] tail = new int[N]; 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]; tail[0] = array[0];
for (int i = 1; i < N; i++) { for (int i = 1; i < N; i++) {
@ -47,14 +48,14 @@ public class LongestIncreasingSubsequence {
tail[0] = array[i]; tail[0] = array[i];
// array[i] extends largest subsequence // array[i] extends largest subsequence
else if (array[i] > tail[length-1]) else if (array[i] > tail[length - 1])
tail[length++] = array[i]; tail[length++] = array[i];
// array[i] will become end candidate of an existing subsequence or // 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] // 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) // (and also, array[i] would have already appeared in one of LIS, identify the location and replace it)
else else
tail[upperBound(tail, -1, length-1, array[i])] = array[i]; tail[upperBound(tail, -1, length - 1, array[i])] = array[i];
} }
return length; return length;

47
Others/Dijkshtra.java
View File

@ -1,16 +1,14 @@
/* /**
@author : Mayank K Jha * @author Mayank K Jha
*/
*/
import java.io.IOException;
import java.util.Arrays; import java.util.Arrays;
import java.util.Scanner; import java.util.Scanner;
import java.util.Stack; import java.util.Stack;
public class Dijkshtra { public class Dijkshtra {
public static void main(String[] args) throws IOException { public static void main(String[] args) {
Scanner in = new Scanner(System.in); Scanner in = new Scanner(System.in);
// n = Number of nodes or vertices // n = Number of nodes or vertices
@ -19,48 +17,49 @@ public class Dijkshtra {
int m = in.nextInt(); int m = in.nextInt();
// Adjacency Matrix // 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) { 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 /* 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 */ 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 // Taking Input as Edge Location b/w a pair of vertices
for(int i = 0; i < m; i++) { for (int i = 0; i < m; i++) {
int x = in.nextInt(),y=in.nextInt(); int x = in.nextInt(), y = in.nextInt();
long cmp = in.nextLong(); long cmp = in.nextLong();
//Comparing previous edge value with current value - Cycle Case // Comparing previous edge value with current value - Cycle Case
if(w[x][y] > cmp) { if (w[x][y] > cmp) {
w[x][y] = cmp; w[y][x] = cmp; w[x][y] = cmp;
w[y][x] = cmp;
} }
} }
// Implementing Dijkshtra's Algorithm // Implementing Dijkshtra's Algorithm
Stack<Integer> t = new Stack<Integer>(); Stack<Integer> t = new Stack<>();
int src = in.nextInt(); int src = in.nextInt();
for(int i = 1; i <= n; i++) { for (int i = 1; i <= n; i++) {
if(i != src) { if (i != src) {
t.push(i); t.push(i);
} }
} }
Stack <Integer> p = new Stack<Integer>(); Stack<Integer> p = new Stack<>();
p.push(src); p.push(src);
w[src][src] = 0; w[src][src] = 0;
while(!t.isEmpty()) { while (!t.isEmpty()) {
int min = 989997979; int min = 989997979;
int loc = -1; 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)]); 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)]; min = (int) w[src][t.elementAt(i)];
loc = i; loc = i;
} }
@ -70,12 +69,12 @@ public class Dijkshtra {
} }
// Printing shortest path from the given source src // Printing shortest path from the given source src
for(int i = 1; i <= n; i++) { for (int i = 1; i <= n; i++) {
if(i != src && w[src][i] != 1000000l) { if (i != src && w[src][i] != 1000000L) {
System.out.print(w[src][i] + " "); System.out.print(w[src][i] + " ");
} }
// Printing -1 if there is no path b/w given pair of edges // Printing -1 if there is no path b/w given pair of edges
else if(i != src) { else if (i != src) {
System.out.print("-1" + " "); System.out.print("-1" + " ");
} }
} }

49
Others/Dijkstra.java
View File

@ -5,19 +5,22 @@ package Others;
* Dijkstra's algorithm,is a graph search algorithm that solves the single-source * 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 * shortest path problem for a graph with nonnegative edge path costs, producing
* a shortest path tree. * a shortest path tree.
* * <p>
* NOTE: The inputs to Dijkstra's algorithm are a directed and weighted graph consisting * 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. * of 2 or more nodes, generally represented by an adjacency matrix or list, and a start node.
* * <p>
* Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java * Original source of code: https://rosettacode.org/wiki/Dijkstra%27s_algorithm#Java
* Also most of the comments are from RosettaCode. * Also most of the comments are from RosettaCode.
*
*/ */
//import java.io.*;
import java.util.*; import java.util.*;
public class Dijkstra { public class Dijkstra {
private static final Graph.Edge[] GRAPH = { 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 // 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", "c", 9),
new Graph.Edge("a", "f", 14), new Graph.Edge("a", "f", 14),
new Graph.Edge("b", "c", 10), new Graph.Edge("b", "c", 10),
@ -43,12 +46,14 @@ public class Dijkstra {
} }
class Graph { class Graph {
private final Map<String, Vertex> graph; // mapping of vertex names to Vertex objects, built from a set of Edges // mapping of vertex names to Vertex objects, built from a set of Edges
private final Map<String, Vertex> graph;
/** One edge of the graph (only used by Graph constructor) */ /** One edge of the graph (only used by Graph constructor) */
public static class Edge { public static class Edge {
public final String v1, v2; public final String v1, v2;
public final int dist; public final int dist;
public Edge(String v1, String v2, int dist) { public Edge(String v1, String v2, int dist) {
this.v1 = v1; this.v1 = v1;
this.v2 = v2; this.v2 = v2;
@ -59,7 +64,8 @@ class Graph {
/** One vertex of the graph, complete with mappings to neighbouring vertices */ /** One vertex of the graph, complete with mappings to neighbouring vertices */
public static class Vertex implements Comparable<Vertex> { public static class Vertex implements Comparable<Vertex> {
public final String name; public final String name;
public int dist = Integer.MAX_VALUE; // MAX_VALUE assumed to be infinity // MAX_VALUE assumed to be infinity
public int dist = Integer.MAX_VALUE;
public Vertex previous = null; public Vertex previous = null;
public final Map<Vertex, Integer> neighbours = new HashMap<>(); public final Map<Vertex, Integer> neighbours = new HashMap<>();
@ -70,11 +76,9 @@ class Graph {
private void printPath() { private void printPath() {
if (this == this.previous) { if (this == this.previous) {
System.out.printf("%s", this.name); System.out.printf("%s", this.name);
} } else if (this.previous == null) {
else if (this.previous == null) {
System.out.printf("%s(unreached)", this.name); System.out.printf("%s(unreached)", this.name);
} } else {
else {
this.previous.printPath(); this.previous.printPath();
System.out.printf(" -> %s(%d)", this.name, this.dist); System.out.printf(" -> %s(%d)", this.name, this.dist);
} }
@ -87,25 +91,26 @@ class Graph {
return Integer.compare(dist, other.dist); return Integer.compare(dist, other.dist);
} }
@Override public String toString() { @Override
public String toString() {
return "(" + name + ", " + dist + ")"; return "(" + name + ", " + dist + ")";
} }
} }
/** Builds a graph from a set of edges */ /** Builds a graph from a set of edges */
public Graph(Edge[] edges) { public Graph(Edge[] edges) {
graph = new HashMap<>(edges.length); graph = new HashMap<>(edges.length);
//one pass to find all vertices // one pass to find all vertices
for (Edge e : edges) { for (Edge e : edges) {
if (!graph.containsKey(e.v1)) graph.put(e.v1, new Vertex(e.v1)); 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)); if (!graph.containsKey(e.v2)) graph.put(e.v2, new Vertex(e.v2));
} }
//another pass to set neighbouring vertices // another pass to set neighbouring vertices
for (Edge e : edges) { for (Edge e : edges) {
graph.get(e.v1).neighbours.put(graph.get(e.v2), e.dist); 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 // graph.get(e.v2).neighbours.put(graph.get(e.v1), e.dist); // also do this for an undirected graph
} }
} }
@ -132,13 +137,14 @@ class Graph {
private void dijkstra(final NavigableSet<Vertex> q) { private void dijkstra(final NavigableSet<Vertex> q) {
Vertex u, v; Vertex u, v;
while (!q.isEmpty()) { 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
u = q.pollFirst(); // vertex with shortest distance (first iteration will return source) // look at distances to each neighbour
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<Vertex, Integer> a : u.neighbours.entrySet()) { for (Map.Entry<Vertex, Integer> a : u.neighbours.entrySet()) {
v = a.getKey(); //the neighbour in this iteration v = a.getKey(); // the neighbour in this iteration
final int alternateDist = u.dist + a.getValue(); final int alternateDist = u.dist + a.getValue();
if (alternateDist < v.dist) { // shorter path to neighbour found if (alternateDist < v.dist) { // shorter path to neighbour found
@ -161,6 +167,7 @@ class Graph {
graph.get(endName).printPath(); graph.get(endName).printPath();
System.out.println(); System.out.println();
} }
/** Prints the path from the source to every vertex (output order is not guaranteed) */ /** Prints the path from the source to every vertex (output order is not guaranteed) */
public void printAllPaths() { public void printAllPaths() {
for (Vertex v : graph.values()) { for (Vertex v : graph.values()) {