From 5beeb7c6521faa61da74ef9a852e3e0ff8f330c0 Mon Sep 17 00:00:00 2001
From: Wander_Lust <hvmanoj2@gmail.com>
Date: Tue, 19 May 2026 07:04:53 +0530
Subject: [PATCH] miku

---
 Nqueens.java          |  57 ++++++++++++++++++++++++++++
 bellmanFord.java      |  85 ++++++++++++++++++++++++++++++++++++++++++
 dijkstra.java         |  74 ++++++++++++++++++++++++++++++++++++
 kruskalMST$Edge.class | Bin 691 -> 0 bytes
 subsetSum.java        |  38 +++++++++++++++++++
 5 files changed, 254 insertions(+)
 create mode 100644 Nqueens.java
 create mode 100644 bellmanFord.java
 create mode 100644 dijkstra.java
 delete mode 100644 kruskalMST$Edge.class
 create mode 100644 subsetSum.java

diff --git a/Nqueens.java b/Nqueens.java
new file mode 100644
index 0000000..d70570c
--- /dev/null
+++ b/Nqueens.java
@@ -0,0 +1,57 @@
+import java.util.*;
+public class Nqueens{
+    static int n;
+    static int[][] board;
+
+    static boolean isSafe(int r, int c){
+        for(int i=0;i<r;i++){
+            if(board[i][c]==1)
+                return false;
+        }
+        for(int i=r,j=c;i>=0 && j>=0;i--,j--){
+            if(board[i][j]==1)
+                return false;
+        }
+        for(int i=r,j=c;i>=0 && j<n;i--,j++){
+            if(board[i][j]==1)
+                return false;
+        }
+        return true;
+
+    }
+
+    static void solve(int r){
+        if(r==n){
+            for(int i=0;i<n;i++){
+                for(int j=0;j<n;j++){
+                    if(board[i][j]==1){
+                        System.out.print(" Q ");
+                    }else
+                        System.out.print(" . ");
+                }
+                System.out.println();
+            }
+            System.out.println();
+            return;
+            
+        }
+        for(int i=0;i<n;i++){
+            if(isSafe(r,i)){
+                board[r][i] =1;
+                solve(r+1);
+                board[r][i]=0;
+            }
+
+            
+        }
+    }
+    public static void main(String[] args){
+        Scanner sc= new Scanner(System.in);
+        System.out.print("\nEnter n: ");
+        n =sc.nextInt();
+        board = new int[n][n];
+        solve(0);
+        sc.close();
+
+    }
+}
diff --git a/bellmanFord.java b/bellmanFord.java
new file mode 100644
index 0000000..91f6c53
--- /dev/null
+++ b/bellmanFord.java
@@ -0,0 +1,85 @@
+import java.util.*;
+public class bellmanFord{
+    static class Edge{
+        int src, dest, weigh;
+        Edge(int s, int d, int w){
+            src = s;
+            dest = d;
+            weigh = w;
+        }
+    }
+    static void printPath(int vertex, int[] parent){
+        if(vertex==-1) return;
+        printPath(parent[vertex], parent);
+        System.out.print(vertex+" ");
+
+    }
+    public static void main(String[] args){
+        Scanner sc = new Scanner(System.in);
+        System.out.print("Enter no. of vertices and edges: ");
+        int n = sc.nextInt();
+        int e = sc.nextInt();
+        int[] parent = new int[n];
+        Edge[] edges = new Edge[e];
+        int[] dist = new int[n];
+
+        System.out.print("Enter the edges(src dest weight): ");
+        for(int i=0;i<e;i++){
+            int s = sc.nextInt();
+            int d = sc.nextInt();
+            int w = sc.nextInt();
+            edges[i] = new Edge(s,d,w);
+            
+        }
+
+        System.out.println("\nEnter source vertex: ");
+        int s = sc.nextInt();
+
+        for(int i=0;i<n;i++){
+            dist[i] = 999;
+            parent[i] = -1;
+        }
+        dist[s] = 0;
+
+        for(int i=1;i<=n-1;i++){
+            for(int j=0;j<e;j++){
+                int sr = edges[j].src;
+                int d = edges[j].dest;
+                int w = edges[j].weigh;
+                if(dist[sr]!=999 && dist[sr] + w < dist[d]){
+                    dist[d] = dist[sr]+w;
+                    parent[d] = sr;
+                }
+
+
+            }
+        }
+        boolean negcycle = false;
+
+        for(int j=0;j<e;j++){
+                int sr = edges[j].src;
+                int d = edges[j].dest;
+                int w = edges[j].weigh;
+                if(dist[sr]!=999 && dist[sr] + w < dist[d]){
+                    dist[d] = dist[sr]+w;
+                    negcycle = true;
+                    break;
+                    
+                }
+        }
+        if(negcycle){
+            System.out.println("\nNegative cycle exists.");
+
+        }else{
+            System.out.println("\nShortest paths from source vertex " + s + ":\n");
+            for(int i=0;i<n;i++){
+                System.out.println("vertex: "+i);
+                System.out.println("Cost: "+ dist[i]);
+                System.out.println("Path: ");
+                printPath(i, parent);
+                System.out.println();
+            }
+        }
+        sc.close();
+    }
+}
diff --git a/dijkstra.java b/dijkstra.java
new file mode 100644
index 0000000..17851b4
--- /dev/null
+++ b/dijkstra.java
@@ -0,0 +1,74 @@
+import java.util.*;
+public class dijkstra{
+    static int V;
+    static int minDistance(int[] dist, boolean[] visited){
+        int min = Integer.MAX_VALUE;
+        int minIndex = -1;
+        for(int v=0;v<V;v++){
+            if(!visited[v] && dist[v]<min){
+                min = dist[v];
+                minIndex = v;;
+            }
+        }
+        return minIndex;
+    }
+
+    static void printPath(int vertex, int[] parent){
+        if(vertex==-1) return;
+        printPath(parent[vertex], parent);
+        System.out.print(vertex+" ");
+    }
+
+    static void dijkstra(int[][] graph, int source){
+        int[] dist = new int[V];
+        boolean[] visited = new boolean[V];
+        int[] parent = new int[V];
+
+        Arrays.fill(dist, Integer.MAX_VALUE);
+        for(int i=0;i<V;i++)
+            parent[i] = -1;
+        dist[source] = 0;
+        long start = System.nanoTime();
+        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];
+                    parent[v] = u;
+                }
+            }
+        }
+        long end = System.nanoTime();
+
+        System.out.println("\nSHortest distances from source "+source+":");
+        for(int i =0;i<V;i++){
+            System.out.println("Vetex: "+i);
+            System.out.println("Cost: "+dist[i]);
+            System.out.println("Path: ");
+            printPath(i, parent);
+            System.out.println("\n");
+        }
+          long executionTime = end - start;
+
+        System.out.println("Execution Time: " + executionTime + " nanoseconds");
+    }
+
+        public static void main(String[] args){
+            Scanner sc = new Scanner(System.in);
+            System.out.println("\nENter number of vertices: ");
+            V = sc.nextInt();
+            int[][] graph = new int[V][V];
+            System.out.println("ENter adjacency matrix: ");
+            for(int i=0;i<V;i++){
+                for(int j =0;j<V;j++){
+                    graph[i][j] =sc.nextInt();
+                }
+            }
+            int source = 0;
+            dijkstra(graph, source);
+            sc.close();
+
+        }
+    }
+
diff --git a/kruskalMST$Edge.class b/kruskalMST$Edge.class
deleted file mode 100644
index 1c6429d67a0f1a49d1d934f8f8fde0cb2e73fba1..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001

literal 691
zcmZXRT~8B16o%hvxBJCPS1F);sC=mHlE@EeLqZx1n-nx@!~L|Kl!bQJ><9iSZ%nKv
zUJ$PRQHFO4u>>w=&YYR&ob#SDfB*ft25^WEE=nj{Fg#RX3iucDO74$kJlg-<zfgl*
zz-&cvlphF`>y0x9HXIAChXr^7)yuTVF6H>7+uJ=Fj+B5XxI&FBdZ=nfTxsvQhZov2
zzo}?+p1ZuNd057ZfHO!YUuCL#i9oI1d6cr*2razi%UoG|#>@Vg^~`!0hK(};qn!-t
zS36OxPK!xjrM)|1x!#$F-ZjOXZ1qIt=gIJkOyxx7D$S^*8;xR_7bz1ppGG~nnM-Ir
z5q!`TaJxy74%DYeYkV-Jk6Ma=eX6qjILUGgyM*U03wU81tF%3qS*9q-&|}40j;jQL
zRh0Q{96fjF@y;v<ORHZhctvWBrxtmGwif(`2-c^tf{iJj1)Ed&KX@;&&V7XuI?8|v
z2No7tX9+G}`7`&Kwwb9!$_;+P-{Ts7{~vFX0X+YZ{01pqdF!5cg1sBqzp(TeFJqHf
eg^@m3`8Ayq-mph)x3E34J9tN{mDt$9d)T+zl7H*~

diff --git a/subsetSum.java b/subsetSum.java
new file mode 100644
index 0000000..f65dcd6
--- /dev/null
+++ b/subsetSum.java
@@ -0,0 +1,38 @@
+import java.util.*;
+public class subsetSum{
+    static boolean found = false;
+    static int[] arr;
+    static int target;
+    static ArrayList<Integer> current= new ArrayList<>();
+
+    static void subset(int index, int sum, ArrayList<Integer> current){
+        if(sum==target){
+            found = true;
+            System.out.println("\nSubset found: "+current);
+            return;
+        }
+        if(arr.length == index || sum>target){
+            return;
+        }
+        current.add(arr[index]);
+        subset(index+1, sum+arr[index], current);
+        current.remove(current.size()-1);
+        subset(index+1, sum, current);
+    }
+    public static void main(String[] args){
+        Scanner sc= new Scanner(System.in);
+        System.out.println("\nEnter size of array: ");
+        int n = sc.nextInt();
+        arr = new int[n];
+        System.out.println("\nENter array elements: ");
+        for(int i=0;i<n;i++)
+            arr[i] = sc.nextInt();
+        System.out.print("Enter target: ");
+        target = sc.nextInt();
+        subset(0,0,new ArrayList<Integer>());
+        if(!found){
+            System.out.println("\nNo subset found");
+        }
+        sc.close();
+    }
+}