Added few java codes

JAVA/DisjointSet.java

@@ -0,0 +1,54 @@
+
+
+import java.util.HashMap;
+
+public class DisjointSet {
+ public class Node{
+	  int val;
+	  int rank;
+	  Node parent;
+ }
+ HashMap<Integer,Node> map=new HashMap<>();
+ //STEP 1: CREATE SET
+ public void create(int v) {
+	 Node nn=new Node();
+	 nn.val=v;
+	 nn.rank=0;
+	 nn.parent=nn;
+	 map.put(v, nn);
+
+ }
+ //STEP 2: FIND THE REPRESENATATIVE ELEMENT
+ public int find(int v)
+ {
+	 Node n=map.get(v);
+	 return findNode(n).val;
+}
+ public Node findNode(Node n)
+ {
+	 if(n.parent==n)
+		 return n;
+	 else
+		return findNode(n.parent);
+ }
+ //STEP 3: UNION THE NODES
+ public void union(int v1, int v2)
+ {
+	Node n1=map.get(v1);
+	Node n2=map.get(v2);
+	Node rn1=findNode(n1); //address
+	Node rn2=findNode(n2);
+	if(rn1.rank==rn2.rank)
+	{
+		rn1.parent=rn2;
+		rn2.rank=rn2.rank+1;
+	}
+	else if(rn1.rank>rn2.rank) 
+	{
+		rn2.parent=rn1;  //bcz isme kisi ki height nhi change hoigi
+	}
+	else {
+		rn1.parent=rn2;
+	}
+ }
+}

JAVA/GenerateParentheses.java

@@ -0,0 +1,25 @@
+
+import java.util.*;
+public class GenerateParentheses {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		int n=3;
+		List<String> list=new ArrayList<>();
+     generateParentheses(n,0,0,"",list);
+     System.out.println(list);
+	}
+public static void generateParentheses(int n, int open, int close, String ans, List<String> list )
+{
+	if(open==n&&close==n)
+	{
+//		System.out.println(ans);
+		list.add(ans);
+		return;
+	}
+	if(open<n)
+		generateParentheses(n,open+1,close,ans+"(",list);
+	if(close<open)
+		generateParentheses(n,open,close+1,ans+")",list);
+}
+}

JAVA/HouseRobber.java

@@ -0,0 +1,70 @@
+
+import java.util.Arrays;
+
+public class HouseRobber {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+     int[] arr= {2,7,9,3,1};
+//      int[] dp=new int[arr.length];
+//
+//      Arrays.fill(dp, -1);
+     // System.out.println(house(0,arr,dp));
+    //  System.out.println(houseTD(arr.length-1,arr,dp));
+       System.out.println(houseBU(arr));
+       System.out.println(space(arr));
+	}
+     public static int house(int ind,int[] arr,int[] dp)
+	    {
+    	 if(ind>=arr.length)
+	        {
+          return 0;
+	        }
+
+	    	if(dp[ind]!=-1)
+	    		return dp[ind];
+	       	        int rob=arr[ind]+house(ind+2,arr,dp);
+	        int dntrob=house(ind+1,arr,dp);
+	        dp[ind]= Math.max(rob,dntrob);
+	        return dp[ind];
+	    }
+     public static int houseTD(int ind, int[] arr, int[] dp)
+     {
+    	     if(ind<0)
+    		 return 0;
+    	 if(dp[ind]!=-1)
+    		 return dp[ind];
+    	     int rob=arr[ind]+house(ind-2,arr,dp);
+	        int dntrob=house(ind-1,arr,dp);
+	        dp[ind]= Math.max(rob,dntrob);
+	        return dp[ind];
+     }
+     public static int houseBU(int[] arr)
+     {
+    	 int[] dp=new int[arr.length];
+    	 dp[0]=arr[0];
+    	 dp[1]=Math.max(arr[0], arr[1]);
+    	 for(int i=2;i<arr.length;i++)
+    	 {
+    	    int rob=arr[i]+dp[i-2];
+	        int dntrob=dp[i-1];
+	        dp[i]= Math.max(rob,dntrob);
+     }
+    	 return dp[arr.length-1];
+ }
+     public static int space(int[] arr)
+     {
+    	 int prev2=arr[0];
+    	 int prev=Math.max(arr[0],arr[1]);
+    	 for(int i=2;i<arr.length;i++)
+    	 {
+    		 int rob=arr[i]+prev2;
+    		 int dntrob=prev;
+    		 int curr=Math.max(rob, dntrob);
+    		 prev2=prev;
+    		 prev=curr;
+    	 }
+    	 return prev;
+     }
+}
+

JAVA/NQueens.java

@@ -0,0 +1,70 @@
+
+
+public class NQueens {
+
+	public static void main(String[] args) {
+		// TODO Auto-generated method stub
+		int n=4;
+     boolean[][] board=new boolean[n][n];
+     System.out.println(queens(board,0,0));
+	}
+ public static int queens(boolean[][] board, int row, int col)
+ {
+	 if(row==board.length)
+	 {
+//		 display(board);
+//		 System.out.println();
+		 return 1;
+	 }
+	 int count=0;
+	 //placing the queen and checking for every row and column
+	 for(col=0;col<board[0].length;col++)
+	 {
+		if(isSafe(board,row,col)) 
+		{
+			board[row][col]=true;
+			count+=queens(board,row+1,col);
+			board[row][col]=false; //backtracking when the function is over
+		}	
+	 }
+	 return count;
+ }
+ public static boolean isSafe(boolean[][] board, int row, int col)
+ {
+	 //for vertical column
+	 for(int i=0;i<row;i++)
+	 {
+		 if(board[i][col])
+			 return false;
+	 }
+	 //for left diagonal
+	 int maxLeft=Math.min(row, col);
+	 for(int i=1;i<=maxLeft;i++)
+	 {
+		 if(board[row-i][col-i])
+			 return false;
+	 }
+	 //for right diagonal
+	 int maxRight=Math.min(row,board.length-col-1);
+	 for(int i=1;i<=maxRight;i++)
+	 {
+		 if(board[row-i][col+i])
+			 return false;
+	 }
+	 return true;
+ }
+ public static void display(boolean[][] board)
+ {
+	 for(boolean[] row: board)
+	 {
+		 for(boolean element: row)
+		 {
+			 if(element)
+				 System.out.print("Q"+" ");
+			 else
+				 System.out.print("X"+" ");
+		 }
+		 System.out.println();
+	 }
+ }
+}