Merge pull request #38 from Arnavthakare19/main

Created Graph algorithms folder

Author: Ritikraja07

Graph algorithms/BellmanFordAlgorithm.java

@@ -0,0 +1,92 @@
+import java.util.*;
+
+public class BellmanFordAlgorithm {
+
+    static class Edge {
+        int src, dest, weight;
+
+        Edge(int src, int dest, int weight) {
+            this.src = src;
+            this.dest = dest;
+            this.weight = weight;
+        }
+    }
+
+    public static void bellmanFord(List<Edge> edges, int V, int start) {
+        int[] dist = new int[V];
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        dist[start] = 0;
+
+        for (int i = 0; i < V - 1; i++) {
+            for (Edge edge : edges) {
+                int u = edge.src;
+                int v = edge.dest;
+                int w = edge.weight;
+
+                if (dist[u] != Integer.MAX_VALUE && dist[u] + w < dist[v]) {
+                    dist[v] = dist[u] + w;
+                }
+            }
+        }
+
+        // Check for negative-weight cycles
+        for (Edge edge : edges) {
+            int u = edge.src;
+            int v = edge.dest;
+            int w = edge.weight;
+
+            if (dist[u] != Integer.MAX_VALUE && dist[u] + w < dist[v]) {
+                System.out.println("Graph contains a negative-weight cycle.");
+                return;
+            }
+        }
+
+        System.out.println("Shortest Distances from Node " + start + ":");
+        for (int i = 0; i < V; i++) {
+            System.out.println("Node " + i + ": " + dist[i]);
+        }
+    }
+
+    public static void main(String[] args) {
+        int V = 5;
+        List<Edge> edges = new ArrayList<>();
+        edges.add(new Edge(0, 1, 4));
+        edges.add(new Edge(0, 2, 3));
+        edges.add(new Edge(1, 2, -2));
+        edges.add(new Edge(1, 3, 2));
+        edges.add(new Edge(1, 4, 3));
+        edges.add(new Edge(3, 2, 5));
+        edges.add(new Edge(3, 1, 1));
+        edges.add(new Edge(4, 3, -4));
+
+        int startNode = 0;
+
+        bellmanFord(edges, V, startNode);
+    }
+}
+
+/*
+The provided Java program implements the Bellman-Ford algorithm to find the shortest distances from a given starting node to all other nodes in a directed graph. Here's a description of the program:
+
+BellmanFordAlgorithm Class:
+
+This is the main class that contains the bellmanFord method for performing the Bellman-Ford algorithm and the main method to demonstrate its usage.
+Edge Class:
+
+The Edge class is a nested class used to represent edges in the graph. Each edge has a source node (src), a destination node (dest), and a weight (weight) associated with it.
+bellmanFord Method:
+
+The bellmanFord method takes three parameters: a list of Edge objects representing the graph's edges (edges), the number of vertices (V), and the starting node (start) from which the shortest distances are to be calculated.
+It initializes an array dist to store the shortest distances from the starting node to all other nodes. Initially, all distances are set to Integer.MAX_VALUE except for the starting node, which is set to 0.
+The method then performs the Bellman-Ford algorithm by iterating over the vertices V - 1 times (where V is the number of vertices). In each iteration, it relaxes the edges by checking if there is a shorter path to a vertex through the current vertex. If a shorter path is found, it updates the distance.
+After the main loop, the method checks for the presence of negative-weight cycles by iterating over the edges again. If a shorter path is found, it indicates the existence of a negative-weight cycle in the graph.
+Finally, it prints the shortest distances from the starting node to all other nodes.
+main Method:
+
+The main method is the entry point of the program.
+It creates a graph with 5 vertices and initializes a list of Edge objects (edges) to represent the graph's edges.
+Each Edge object in the edges list represents a directed edge with its source, destination, and weight.
+It specifies the starting node (startNode) from which to find the shortest distances.
+It calls the bellmanFord method with the graph's edges, the number of vertices, and the starting node as arguments to calculate and display the shortest distances.
+Overall, this program demonstrates the Bellman-Ford algorithm for finding the shortest distances in a weighted directed graph. It also checks for the presence of negative-weight cycles, which can affect the correctness of the shortest path calculations.
+    */

Graph algorithms/DijkstrasAlgorithmMST.java

@@ -0,0 +1,63 @@
+import java.util.*;
+
+public class DijkstrasAlgorithmMST {
+
+    public static void dijkstra(int[][] graph, int start) {
+        int V = graph.length;
+        int[] dist = new int[V];
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        dist[start] = 0;
+
+        boolean[] visited = new boolean[V];
+
+        for (int count = 0; count < V - 1; count++) {
+            int u = minDistance(dist, visited);
+            visited[u] = true;
+
+            for (int v = 0; v < V; v++) {
+                if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE
+                        && dist[u] + graph[u][v] < dist[v]) {
+                    dist[v] = dist[u] + graph[u][v];
+                }
+            }
+        }
+
+        System.out.println("Shortest Distances from Node " + start + ":");
+        for (int i = 0; i < V; i++) {
+            System.out.println("Node " + i + ": " + dist[i]);
+        }
+    }
+
+    public static int minDistance(int[] dist, boolean[] visited) {
+        int V = dist.length;
+        int minDist = Integer.MAX_VALUE;
+        int minIndex = -1;
+
+        for (int v = 0; v < V; v++) {
+            if (!visited[v] && dist[v] < minDist) {
+                minDist = dist[v];
+                minIndex = v;
+            }
+        }
+
+        return minIndex;
+    }
+
+    public static void main(String[] args) {
+        int[][] graph = {
+            {0, 4, 0, 0, 0, 0, 0, 8, 0},
+            {4, 0, 8, 0, 0, 0, 0, 11, 0},
+            {0, 8, 0, 7, 0, 4, 0, 0, 2},
+            {0, 0, 7, 0, 9, 14, 0, 0, 0},
+            {0, 0, 0, 9, 0, 10, 0, 0, 0},
+            {0, 0, 4, 14, 10, 0, 2, 0, 0},
+            {0, 0, 0, 0, 0, 2, 0, 1, 6},
+            {8, 11, 0, 0, 0, 0, 1, 0, 7},
+            {0, 0, 2, 0, 0, 0, 6, 7, 0}
+        };
+
+        int startNode = 0;
+
+        dijkstra(graph, startNode);
+    }
+}

Graph algorithms/DijkstrasAlgorithmSP.java

@@ -0,0 +1,63 @@
+import java.util.*;
+
+public class DijkstrasAlgorithmSP {
+
+    public static void dijkstra(int[][] graph, int start) {
+        int V = graph.length;
+        int[] dist = new int[V];
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        dist[start] = 0;
+
+        boolean[] visited = new boolean[V];
+
+        for (int count = 0; count < V - 1; count++) {
+            int u = minDistance(dist, visited);
+            visited[u] = true;
+
+            for (int v = 0; v < V; v++) {
+                if (!visited[v] && graph[u][v] != 0 && dist[u] != Integer.MAX_VALUE
+                        && dist[u] + graph[u][v] < dist[v]) {
+                    dist[v] = dist[u] + graph[u][v];
+                }
+            }
+        }
+
+        System.out.println("Shortest Distances from Node " + start + ":");
+        for (int i = 0; i < V; i++) {
+            System.out.println("Node " + i + ": " + dist[i]);
+        }
+    }
+
+    public static int minDistance(int[] dist, boolean[] visited) {
+        int V = dist.length;
+        int minDist = Integer.MAX_VALUE;
+        int minIndex = -1;
+
+        for (int v = 0; v < V; v++) {
+            if (!visited[v] && dist[v] < minDist) {
+                minDist = dist[v];
+                minIndex = v;
+            }
+        }
+
+        return minIndex;
+    }
+
+    public static void main(String[] args) {
+        int[][] graph = {
+            {0, 4, 0, 0, 0, 0, 0, 8, 0},
+            {4, 0, 8, 0, 0, 0, 0, 11, 0},
+            {0, 8, 0, 7, 0, 4, 0, 0, 2},
+            {0, 0, 7, 0, 9, 14, 0, 0, 0},
+            {0, 0, 0, 9, 0, 10, 0, 0, 0},
+            {0, 0, 4, 14, 10, 0, 2, 0, 0},
+            {0, 0, 0, 0, 0, 2, 0, 1, 6},
+            {8, 11, 0, 0, 0, 0, 1, 0, 7},
+            {0, 0, 2, 0, 0, 0, 6, 7, 0}
+        };
+
+        int startNode = 0;
+
+        dijkstra(graph, startNode);
+    }
+}

Graph algorithms/FloodFill.java

@@ -0,0 +1,101 @@
+public class FloodFill {
+
+    public static void floodFill(int[][] image, int sr, int sc, int newColor) {
+        int rows = image.length;
+        int cols = image[0].length;
+        int oldColor = image[sr][sc];
+
+        if (oldColor != newColor) {
+            dfs(image, sr, sc, oldColor, newColor, rows, cols);
+        }
+    }
+
+    public static void dfs(int[][] image, int row, int col, int oldColor, int newColor, int rows, int cols) {
+        if (row < 0 || row >= rows || col < 0 || col >= cols || image[row][col] != oldColor) {
+            return;
+        }
+
+        image[row][col] = newColor;
+
+        dfs(image, row - 1, col, oldColor, newColor, rows, cols);
+        dfs(image, row + 1, col, oldColor, newColor, rows, cols);
+        dfs(image, row, col - 1, oldColor, newColor, rows, cols);
+        dfs(image, row, col + 1, oldColor, newColor, rows, cols);
+    }
+
+    public static void main(String[] args) {
+        int[][] image = {
+            {1, 1, 1},
+            {1, 1, 0},
+            {1, 0, 1}
+        };
+
+        int sr = 1, sc = 1, newColor = 2;
+
+        floodFill(image, sr, sc, newColor);
+
+        System.out.println("Flood-Filled Image:");
+        for (int[] row : image) {
+            for (int pixel : row) {
+                System.out.print(pixel + " ");
+            }
+            System.out.println();
+        }
+    }
+}
+
+
+
+   
+// Description of the above code:
+
+// 1. The `FloodFill` class contains three methods: `floodFill`, `dfs`, and `main`.
+
+// 2. `floodFill` method:
+//    - This method serves as the entry point for the flood fill algorithm.
+//    - It takes four parameters:
+//      - `image`: A 2D integer array representing the image where the flood fill should be performed.
+//      - `sr` and `sc`: The starting row and column coordinates from where the flood fill should begin.
+//      - `newColor`: The new color that should replace the old color in the connected region.
+//    - It gets the dimensions of the `image` (number of rows and columns) and stores them in `rows` and `cols`.
+//    - It retrieves the old color from the `image` at the starting coordinates `(sr, sc)`.
+//    - If the old color is not equal to the new color, it calls the `dfs` method to perform the flood fill.
+
+// 3. `dfs` method:
+//    - This is a recursive depth-first search (DFS) function that performs the actual flood fill.
+//    - It takes six parameters:
+//      - `image`: The 2D integer array representing the image.
+//      - `row` and `col`: The current row and column coordinates being processed.
+//      - `oldColor`: The old color that needs to be replaced.
+//      - `newColor`: The new color to fill the region with.
+//      - `rows` and `cols`: The dimensions of the image.
+//    - It checks if the current coordinates are outside the image boundaries or if the pixel at `(row, col)` does not match the old color. In such cases, it returns, indicating that this branch of the recursion should stop.
+//    - If the conditions are met, it updates the color at `(row, col)` to the new color.
+//    - Then, it recursively calls `dfs` for the four neighboring pixels (up, down, left, and right), continuing the flood fill process.
+
+// 4. `main` method:
+//    - In the `main` method, an example image represented by a 2D array `image` is defined.
+//    - The starting row (`sr`), starting column (`sc`), and the new color (`newColor`) are specified.
+//    - The `floodFill` method is called with these parameters to perform the flood fill.
+//    - Finally, the modified image is printed to the console to display the result.
+
+// The code demonstrates how to use the flood fill algorithm to replace a connected region of pixels with a new color in a 2D image.
+
+/*The provided Java code implements the flood fill algorithm to change the color of a connected region in a 2D image. It starts from a given pixel and recursively fills adjacent pixels of the same original color with a new color. Here's a short description:
+
+The `floodFill` method:
+- Takes an image represented as a 2D array, a starting pixel (sr, sc), and a new color.
+- Checks if the old color at the starting pixel is different from the new color.
+- If they are different, it calls the `dfs` method to perform the flood fill.
+
+The `dfs` method:
+- Recursively explores neighboring pixels in four directions (up, down, left, right).
+- Changes the color of each visited pixel to the new color.
+- Stops when it encounters out-of-bounds pixels or pixels with colors different from the old color.
+
+In the `main` method:
+- An example image is provided as a 2D array.
+- A starting point (sr, sc) and a new color are specified.
+- The `floodFill` method is called to fill the connected region starting from the specified point with the new color.
+- The resulting image is printed to the console.*/
+