└── leetcode
    ├── Array Partition
        └── solution.java
    ├── Binary Search
        └── solution.java
    ├── Coin Change
        └── solution.java
    ├── Counting Bits
        └── solution.java
    ├── Course Schedule
        └── solution.java
    ├── Design Add and Search Words Data Structure
        └── solution.java
    ├── Fibonacci Number
        └── solution.java
    ├── Find Center of Star Graph
        └── solution.java
    ├── Find the Town Judge
        └── solution.java
    ├── Flood Fill
        └── solution.java
    ├── Generate Parentheses
        └── solution.java
    ├── House Robber II
        └── solution.java
    ├── Implement Trie (Prefix Tree)
        └── solution.java
    ├── Jump Game
        └── solution.java
    ├── Lexicographically Smallest Palindrome
        └── solution.java
    ├── Longest Common Subsequence
        └── solution.java
    ├── Longest Palindrome
        └── solution.java
    ├── Longest Palindromic Subsequence
        └── solution.java
    ├── Lowest common ancestor
        └── solution.java
    ├── Maximum Number of Coins You Can Get
        └── solution.java
    ├── Maximum Subarray
        └── solution.java
    ├── Minimum Path Sum
        └── solution.java
    ├── Move Zeroes
        └── solution.java
    ├── Number of 1 Bits
        └── solution.java
    ├── Number of Enclaves
        └── solution.java
    ├── Number of Islands
        └── solution.java
    ├── Number of Operations to Make Network Connected
        └── solution.java
    ├── Numbers With Same Consecutive Differences
        └── solution.java
    ├── Power of Two
        └── solution.java
    ├── Rotting Oranges
        └── solution.java
    ├── Same Tree
        └── solution.java
    ├── Search Insert Position
        └── solution.java
    ├── Search in Rotated Sorted Array
        └── solution.java
    ├── Single Number
        └── solution.java
    ├── Sqrt(x)
        └── solution.java
    ├── Subsets
        └── solution.java
    ├── Unique Paths II
        └── solution.java
    └── Validate Binary Search Tree
        └── solution.java


/leetcode/Array Partition/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int arrayPairSum(int[] nums) {
 3 |         Arrays.sort(nums);
 4 |         int n=0;
 5 |         for(int i=0;i<nums.length;i+=2)
 6 |         {
 7 |             n+=nums[i];
 8 |         }
 9 |         return n;
10 |         
11 |     }
12 | }


--------------------------------------------------------------------------------
/leetcode/Binary Search/solution.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Solution {
 3 |     public int search(int[] nums, int target) {
 4 |        int a=Arrays.binarySearch(nums,target);
 5 |        if(a<0)
 6 |        {
 7 |         return -1;
 8 | 
 9 |        }
10 |        else
11 |        {
12 |         return a;
13 |        }
14 |     }
15 | }


--------------------------------------------------------------------------------
/leetcode/Coin Change/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | 		public static int solve(int [] coins , int n , int amount,int [][] dp){
 3 |     		if(n==0){
 4 |         		if(amount%coins[n]==0) return amount/coins[n];
 5 |             else return Integer.MAX_VALUE-1;
 6 |         }
 7 |         if(dp[n][amount]!=-1) return dp[n][amount];
 8 |         int notpick = solve(coins,n-1,amount,dp);
 9 |         int pick = Integer.MAX_VALUE-1;
10 |         if(	amount >= coins[n]){
11 |     				pick = 1+ solve(coins,n,amount-coins[n],dp);
12 |         }
13 |  				return dp[n][amount] =  Math.min(pick,notpick);
14 |         
15 |     }
16 |     public int coinChange(int[] coins, int amount) {
17 | 				int n= coins.length;
18 |         int dp [][] = new int[n][amount+1];
19 |         for(int [] row : dp){
20 |         		Arrays.fill(row,-1);
21 |         }
22 |        	int ans = solve(coins,n-1,amount,dp); 
23 |         if(ans==Integer.MAX_VALUE-1) return -1;
24 |         return ans;
25 |     }
26 | }
27 | 


--------------------------------------------------------------------------------
/leetcode/Counting Bits/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] countBits(int n) {
 3 |        int[] dp=new int[n+1];
 4 |        int offset=1;
 5 |        for(int i=1;i<=n;i++){
 6 |         if(offset*2==i){
 7 |             offset=i;
 8 |         }
 9 |         dp[i]=1+dp[i-offset];
10 |        }
11 |         return dp;
12 |     }
13 | }


--------------------------------------------------------------------------------
/leetcode/Course Schedule/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean canFinish(int numCourses, int[][] prerequisites) {
 3 |         ArrayList<ArrayList<Integer>> adj=new ArrayList<>();
 4 |         for(int i=0;i<numCourses;i++)
 5 |         {
 6 |             adj.add(new ArrayList<>());
 7 |         }
 8 |         for(int i=0;i<prerequisites.length;i++)
 9 |         {
10 |             adj.get(prerequisites[i][1]).add(prerequisites[i][0]);
11 |         }
12 |         int[] inDegree = new int[numCourses];
13 |         for(int i=0;i<numCourses;i++)
14 |         {
15 |             for(int it : adj.get(i)){
16 |                 inDegree[it]++;
17 |             }
18 |         }
19 |         Queue<Integer> q=new LinkedList<>();
20 |         for(int i=0;i<numCourses;i++)
21 |         {
22 |             if(inDegree[i]==0){
23 |                 q.add(i);
24 |             }
25 |         }
26 |         int count=0;
27 |         while(!q.isEmpty()){
28 |             int node=q.poll();
29 |             count++;
30 |             for(int a:adj.get(node)){
31 |                 inDegree[a]--;
32 |                 if(inDegree[a]==0) q.add(a);
33 |             }
34 |         }
35 |         if(count==numCourses) return true;
36 |         return false;
37 |     }
38 | }
39 | 


--------------------------------------------------------------------------------
/leetcode/Design Add and Search Words Data Structure/solution.java:
--------------------------------------------------------------------------------
 1 | class TrieNode {
 2 |     TrieNode[] child = new TrieNode[26];
 3 |     boolean end = false;
 4 | }
 5 | class WordDictionary {
 6 |     TrieNode root;
 7 |     public WordDictionary() {
 8 |         root = new TrieNode();
 9 |     }
10 |     public void addWord(String word) {
11 |         TrieNode current = root;
12 |         for (int i = 0; i < word.length(); i++) {
13 |             int index = word.charAt(i) - 'a';
14 |             if (current.child[index] == null) {
15 |                 current.child[index] = new TrieNode();
16 |             }
17 |             current = current.child[index];
18 |         }
19 |         current.end = true;
20 |     }
21 |     public boolean search(String word) {
22 |         return searchInNode(word, root, 0);
23 |     }
24 |     private boolean searchInNode(String word, TrieNode current, int pos) {
25 |         if (current == null) {
26 |             return false;
27 |         }
28 |         if (pos == word.length()) {
29 |             return current.end;
30 |         }
31 |         char ch = word.charAt(pos);
32 |         if (ch == '.') {
33 |             for (int i=0;i<26;i++) { 
34 |                 if (current.child[i] != null && searchInNode(word, current.child[i], pos + 1)) {
35 |                     return true;
36 |                 }
37 |             }
38 |             return false; 
39 |         } else {
40 |             int index = ch - 'a';
41 |             return searchInNode(word, current.child[index], pos + 1); 
42 |         }
43 |     }
44 | }


--------------------------------------------------------------------------------
/leetcode/Fibonacci Number/solution.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public int fib(int n) {
3 |       if(n==0 || n==1) return n;
4 |       return fib(n-1)+fib(n-2);  
5 |     }
6 | }


--------------------------------------------------------------------------------
/leetcode/Find Center of Star Graph/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int findCenter(int[][] edges) {
 3 |         int k=0;
 4 |                 if(edges[0][0] == edges[1][0] || edges[0][0] == edges[1][1] )
 5 |                     k = edges[0][0];
 6 |                 else if(edges[0][1] == edges[1][0] || edges[0][1] == edges[1][1] )
 7 |                     k = edges[0][1];
 8 |         return k;
 9 |     }
10 | }


--------------------------------------------------------------------------------
/leetcode/Find the Town Judge/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int findJudge(int n, int[][] trust) {
 3 |         int indegree [] = new int[n+1];
 4 |         int outdegree [] = new int[n+1];
 5 |         for(int i=0;i<trust.length;i++){
 6 |         		int ai=trust[i][0];
 7 |                 int bi=trust[i][1];
 8 |         		outdegree[ai]+=1;
 9 |             indegree[bi]+=1;
10 |         }
11 |         for(int i=1;i<n+1;i++){
12 |         		if(outdegree[i]==0 && indegree[i]==n-1) return i;
13 |         }
14 |         return -1;
15 |     }
16 | }


--------------------------------------------------------------------------------
/leetcode/Flood Fill/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[][] floodFill(int[][] image, int sr, int sc, int color) {
 3 |         int rowlength=image.length;
 4 |         int collength=image[0].length;
 5 |         int startcolor=image[sr][sc];
 6 |         if(startcolor==color) return image;
 7 |          recursiveColor(image,sr,sc,color,startcolor,rowlength-1,collength-1);
 8 |          return image;
 9 | 
10 |         
11 |     }
12 |     private static void recursiveColor(int[][] image,int row,int col,int color,int startcolor,int n,int m){
13 |         if(row>n || row<0 || col>m || col<0 || image[row][col]!=startcolor) return;
14 |         image[row][col]=color;
15 |         recursiveColor(image,row+1,col,color,startcolor,n,m);
16 |         recursiveColor(image,row-1,col,color,startcolor,n,m);
17 |         recursiveColor(image,row,col+1,color,startcolor,n,m);
18 |         recursiveColor(image,row,col-1,color,startcolor,n,m);
19 | 
20 |     }
21 | }


--------------------------------------------------------------------------------
/leetcode/Generate Parentheses/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | 		private List<String> ans = new ArrayList<>();
 3 | 		public void generate(int open , int close , StringBuilder s){
 4 |     		if(open ==0 && close == 0){
 5 |         		ans.add(s.toString());
 6 |             return ;
 7 |         }
 8 |         if(open > 0 ){
 9 |         		s.append('(');
10 |             generate(open -1 ,close , s);
11 |             s.deleteCharAt(s.length() -1);  //backtracking
12 |         }
13 |         if(close >0 && close> open){
14 |         		s.append(')');
15 |             generate(open , close -1 , s);
16 |             s.deleteCharAt(s.length() - 1); //backtracking
17 |         }
18 |     }
19 |     public List<String> generateParenthesis(int n) {
20 |         StringBuilder s = new StringBuilder();
21 |         generate(n,n,s);
22 |         return ans;
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/leetcode/House Robber II/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int rob(int[] nums) {
 3 |        if (nums.length < 2)
 4 |       return nums[0];
 5 | 
 6 |    
 7 |     int[] skipLastHouse = new int[nums.length - 1];
 8 |     int[] skipFirstHouse = new int[nums.length - 1];
 9 | 
10 |     for (int i = 0; i < nums.length - 1; i++) {
11 |       skipLastHouse[i] = nums[i];
12 |       skipFirstHouse[i] = nums[i + 1];
13 |     }
14 | 
15 |   
16 |     int lootSkippingLast = robHelper(skipLastHouse);
17 |     int lootSkippingFirst = robHelper(skipFirstHouse);
18 | 
19 |     
20 |     return Math.max(lootSkippingLast, lootSkippingFirst);
21 |   }
22 |    private int robHelper(int[] nums) {
23 |     if (nums.length < 2)
24 |       return nums[0];
25 | 
26 |     int[] dp = new int[nums.length];
27 | 
28 |     dp[0] = nums[0];
29 |     dp[1] = Math.max(nums[0], nums[1]);
30 | 
31 |     for (int i = 2; i < nums.length; i++) {
32 |       dp[i] = Math.max(dp[i - 2] + nums[i], dp[i - 1]);
33 |     }
34 | 
35 |     return dp[nums.length - 1];
36 |   }
37 | }


--------------------------------------------------------------------------------
/leetcode/Implement Trie (Prefix Tree)/solution.java:
--------------------------------------------------------------------------------
 1 | class TrieNode{
 2 |     TrieNode[] child=new TrieNode[26];
 3 |     boolean end;
 4 |     public TrieNode(){
 5 |         end=false;
 6 |         for(int i=0;i<26;i++){
 7 |             child[i]=null;
 8 |         }
 9 |     }
10 | }
11 | 
12 | class Trie {
13 |     static TrieNode root;
14 |     public Trie(){
15 |         root=new TrieNode();
16 |     }
17 |     public void insert(String word){
18 |         TrieNode current=root;
19 |         for (int i = 0; i < word.length(); i++) {
20 |             int index=word.charAt(i)-'a';
21 |             if(current.child[index]==null){
22 |                 current.child[index]=new TrieNode();
23 |             }
24 |             current=current.child[index];
25 |         }
26 |         current.end=true;
27 |     }
28 | 
29 |     public boolean search(String word){
30 |         TrieNode current=root;
31 |         for (int i = 0; i < word.length(); i++) {
32 |             int index=word.charAt(i)-'a';
33 |             if(current.child[index]==null){
34 |                 return false;
35 |             }
36 |             current=current.child[index];
37 |         }
38 |         return current.end;
39 |     }
40 |     public boolean startsWith(String prefix) {
41 |         TrieNode current=root;
42 |         for (int i = 0; i < prefix.length(); i++) {
43 |             int index=prefix.charAt(i)-'a';
44 |             if(current.child[index]==null){
45 |                 return false;
46 |             }
47 |             current=current.child[index];
48 |         }
49 |         return true;
50 |     }
51 | }


--------------------------------------------------------------------------------
/leetcode/Jump Game/solution.java:
--------------------------------------------------------------------------------
 1 | import java.util.*;
 2 | class Solution {
 3 |     public boolean canJump(int[] nums) {
 4 |     int gas=0;
 5 |     for(int i=0;i<nums.length;i++)
 6 |     {
 7 |         if(gas<i){
 8 |             return false;
 9 |         }
10 |         gas=Math.max(gas,i+nums[i]);
11 |     }
12 |         return true;
13 |     }
14 | }
15 | 


--------------------------------------------------------------------------------
/leetcode/Lexicographically Smallest Palindrome/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public String makeSmallestPalindrome(String s) {
 3 |         char[] ch=s.toCharArray();
 4 |         int i=0;
 5 |         int j=s.length()-1;
 6 |         while(i<= j) {
 7 |             if(ch[i] != ch[j]) {
 8 |                 if(ch[j] > ch[i]) {
 9 |                     ch[j] = ch[i];
10 |                 } else {
11 |                     ch[i] = ch[j];
12 |                 }
13 |             }
14 |             i++;
15 |             j--;
16 |         }  
17 |         return String.valueOf(ch);
18 |     }
19 | }
20 | 


--------------------------------------------------------------------------------
/leetcode/Longest Common Subsequence/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | 		public static int solve(String text1 , String text2 , int i , int j,int [][] dp){
 3 |     		if(i<0 || j<0) return 0;
 4 |         if(dp[i][j]!=-1) return dp[i][j];
 5 |         if(text1.charAt(i)==text2.charAt(j)){
 6 |         		return dp[i][j]= 1+solve(text1,text2,i-1,j-1,dp);
 7 |         }
 8 |         else{
 9 |         		return dp[i][j] = Math.max(solve(text1,text2,i-1,j,dp),solve(text1,text2,i,j-1,dp));
10 |         }
11 |     }
12 |     public int longestCommonSubsequence(String text1, String text2) {
13 |         int n1 = text1.length();
14 |         int n2 = text2.length();
15 |         int dp [][] = new int[n1][n2];
16 |         for(int [] row : dp){
17 |         		Arrays.fill(row,-1);
18 |         }
19 |         return solve(text1,text2,n1-1,n2-1,dp);
20 |         
21 |     }
22 | }


--------------------------------------------------------------------------------
/leetcode/Longest Palindrome/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int longestPalindrome(String s) {
 3 |         int[] freq = new int[58];
 4 |         int len = 0;
 5 |         for(char ch: s.toCharArray()) freq[ch-'A']++;
 6 | 
 7 |         for(int num: freq) {
 8 |             if(num%2 == 0) {
 9 |                 len+=num;
10 |             } else {
11 |                 len += (num-1);
12 |             }
13 |         }
14 | 
15 |         return len==s.length()?len:len+1;
16 |     }
17 | }


--------------------------------------------------------------------------------
/leetcode/Longest Palindromic Subsequence/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int longestPalindromeSubseq(String s) {
 3 |         String p = new StringBuilder(s).reverse().toString();
 4 |         int m = s.length();
 5 |         int dp[] = new int[m+1];
 6 |         int de[] = new int[m+1];
 7 |         for(int i=1;i<=m;i++)
 8 |         {
 9 |             for(int j=1;j<=m;j++)
10 |             {
11 |                 if(s.charAt(i-1) == p.charAt(j-1))
12 |                 {
13 |                     dp[j] = 1 + de[j-1];
14 |                 }
15 |                 else
16 |                 {
17 |                     dp[j] = Math.max(dp[j-1] , de[j]);
18 |                 }
19 |             }
20 |             for(int j=1;j<=m;j++)
21 |             {
22 |                 de[j] = dp[j];
23 |             }
24 |         }
25 |         return de[m];
26 |     }
27 | }
28 | 


--------------------------------------------------------------------------------
/leetcode/Lowest common ancestor/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public TreeNode lowestCommonAncestor(TreeNode root, TreeNode p, TreeNode q) {
 3 |         while(root !=null)
 4 |         if(p.val < root.val && q.val <root.val)
 5 |            { root = root.left;
 6 |     }
 7 |     else if(p.val > root.val && q.val > root.val)
 8 |     {
 9 |         root = root.right;
10 |     }
11 |     else
12 |     {
13 |         return root;
14 |     }
15 | return null;}
16 | }


--------------------------------------------------------------------------------
/leetcode/Maximum Number of Coins You Can Get/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int maxCoins(int[] piles) {
 3 |         Arrays.sort(piles);
 4 |         int a=piles.length/3;
 5 |         int b=0;
 6 |         for(int i=piles.length-2;i>=a;i-=2)
 7 |         {
 8 |             b+=piles[i];
 9 |         }
10 |         return b;
11 |     }
12 | }


--------------------------------------------------------------------------------
/leetcode/Maximum Subarray/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int maxSubArray(int[] nums) {
 3 |       int sum=0;
 4 |       int ans =Integer.MIN_VALUE;
 5 |       for(int i=0;i<nums.length;i++)
 6 |       {
 7 |         sum+=nums[i];
 8 |         if(sum>ans) ans=sum;
 9 |         if(sum<0) sum=0;
10 |       }
11 |       return ans; 
12 |     }
13 | }
14 | 


--------------------------------------------------------------------------------
/leetcode/Minimum Path Sum/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int minPathSum(int[][] grid) {
 3 |         int m=grid.length;
 4 |         int n=grid[0].length;
 5 |         int[][] a=new int[m][n];
 6 |         for(int[] row: a)
 7 |         Arrays.fill(row,-1);
 8 |         a[0][0]=grid[0][0];
 9 |         for(int i=1;i<m;i++)
10 |         a[i][0]=grid[i][0]+a[i-1][0];
11 |         for(int i=1;i<n;i++)
12 |         a[0][i]=grid[0][i]+a[0][i-1];
13 |         for(int i=1;i<m;i++){
14 |             for(int j=1;j<n;j++){
15 |                 int c=Math.min(a[i-1][j],a[i][j-1]);
16 |                 a[i][j]=c+grid[i][j];
17 |             }
18 |         }
19 |         return a[m-1][n-1];
20 |         
21 |     }
22 | }
23 | 


--------------------------------------------------------------------------------
/leetcode/Move Zeroes/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public void moveZeroes(int[] nums) {
 3 |         int j = 0;
 4 |         int n = nums.length;
 5 |         int[] arr = new int[n];
 6 |         for(int i=0;i<n;i++){
 7 |             if(nums[i] != 0){
 8 |                 arr[j] = nums[i];
 9 |                 j++;
10 |             }
11 |         }
12 |         for(int i=0;i<n;i++){
13 |             nums[i] = arr[i];
14 |         }
15 |         
16 |     }
17 | } 
18 | 


--------------------------------------------------------------------------------
/leetcode/Number of 1 Bits/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int hammingWeight(int n) {
 3 |         int c=0;
 4 |         while(n>0){
 5 |             if((n&1)==1)
 6 |                 c++;
 7 |                 n=n>>1;
 8 |         }
 9 |         return c;
10 |     }
11 | }
12 | 
13 | 


--------------------------------------------------------------------------------
/leetcode/Number of Enclaves/solution.java:
--------------------------------------------------------------------------------
 1 | class Pair{
 2 | 		int row;
 3 |     int col;
 4 |     Pair(int _row , int _col){
 5 |     		this.row=_row;
 6 |         this.col=_col;
 7 |     }
 8 | }
 9 | class Solution {
10 |     public int numEnclaves(int[][] grid) {
11 |         int m = grid.length;
12 |         int n = grid[0].length;
13 |         int [][] vis = new int[m][n];
14 |         Queue<Pair> q = new LinkedList<>();
15 |         for(int i=0; i<m;i++){
16 |         		if(grid[i][0]==1){
17 |             		vis[i][0]=1;
18 |                 q.offer(new Pair(i,0));
19 |             }
20 |             if(grid[i][n-1]==1){
21 |             		vis[i][n-1]=1; 
22 |                 q.offer(new Pair(i,n-1));
23 |             }
24 |         }
25 |         for(int i=0;i<n;i++){
26 |         		if(grid[0][i]==1){
27 |             		vis[0][i]=1;
28 |                 q.offer(new Pair(0,i));
29 |             }
30 |             if(grid[m-1][i]==1){
31 |             		vis[m-1][i]=1;
32 |                 q.offer(new Pair(m-1,i));
33 |             }
34 |         }
35 |         int [] drow = {-1,0,1,0};
36 |         int [] dcol = {0,1,0,-1};
37 |         while(!q.isEmpty()){
38 |         		int r=q.peek().row;
39 |             int c=q.peek().col;
40 |             q.poll();
41 |             for(int i=0;i<4;i++){
42 |             		int nrow = r+drow[i];
43 |                 int ncol =  c+dcol[i];
44 |                 if(nrow>=0 && nrow<m && ncol >=0 && ncol <n && vis[nrow][ncol]==0 && grid[nrow][ncol]==1 ){
45 |                 			vis[nrow][ncol] =1;
46 |                       q.offer(new Pair(nrow,ncol));
47 |                 }
48 |             }
49 |         }
50 | 				int count=0;
51 |         for(int i=0;i<m;i++){
52 |         		for(int j=0;j<n;j++){
53 |             		if(grid[i][j]==1 && vis[i][j]==0){
54 |                 		count+=1;
55 |                 }
56 |             }
57 |         }
58 |         return count;
59 |     }
60 | }


--------------------------------------------------------------------------------
/leetcode/Number of Islands/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     boolean[][] flag;
 3 |     public int numIslands(char[][] grid) {
 4 |         int height = grid.length;
 5 |         int width = grid[0].length;
 6 |         int n=0;
 7 |         flag = new boolean[height][width];
 8 |         for(int i=0; i<height; i++){
 9 |             for(int j=0; j<width;j++){
10 |                 if(grid[i][j] == '1' && !flag[i][j]){
11 |                     flag[i][j] = true;
12 |                     ++n;
13 |                     inrowchecker(grid,i,j);
14 |                     incolumnchecker(grid,i,j);
15 |                 }
16 |             }
17 |         }
18 |         return n;
19 |     }
20 |     private void inrowchecker(char[][] grid, int row, int cols){
21 |         for(int i=cols-1; i>-1; i--){
22 |             if(grid[row][i] == '1' && !flag[row][i]){
23 |                 flag[row][i] = true;
24 |                 incolumnchecker(grid,row,i);
25 |             }
26 |             else break;
27 |         }
28 | 
29 |         for(int i=cols+1; i<grid[0].length; i++){
30 |             if(grid[row][i] == '1' && !flag[row][i]){
31 |                 flag[row][i] = true;
32 |                 incolumnchecker(grid,row,i);
33 |             }
34 |             else break;
35 |         }
36 |         return;
37 |     }
38 | 
39 |       private void incolumnchecker(char[][] grid, int row, int cols){
40 |         for(int i=row-1; i>-1; i--){
41 |             if(grid[i][cols] == '1' && !flag[i][cols]){
42 |                 flag[i][cols] = true;
43 |                 inrowchecker(grid,i,cols);
44 |             }
45 |             else break;
46 |         }
47 | 
48 |         for(int i=row+1; i<grid.length; i++){
49 |             if(grid[i][cols] == '1' && !flag[i][cols]){
50 |                 flag[i][cols] = true;
51 |                 inrowchecker(grid,i,cols);
52 |             }
53 |             else break;
54 |         }
55 |         return;
56 |     }
57 | }
58 | 


--------------------------------------------------------------------------------
/leetcode/Number of Operations to Make Network Connected/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int makeConnected(int n, int[][] connections) {
 3 |         int[] parent = new int[n];
 4 |         int[] rank = new int[n];
 5 |         for(int i=0;i<n;i++){
 6 |             parent[i]=i;
 7 |         }
 8 | 
 9 |         int extraEdges=0;
10 |         int req=0;
11 |         for(int i=0;i<connections.length;i++){
12 |             int ulpsrc=findParent(connections[i][0],parent);
13 |             int ulpdst = findParent(connections[i][1],parent);
14 |             if(ulpsrc == ulpdst) extraEdges++;
15 |             else
16 |             {
17 |                 union(ulpsrc,ulpdst,parent,rank);
18 |             }
19 |         }
20 |         
21 |         for(int i=0;i<n;i++){
22 |             if(parent[i]==i) req++;
23 |         }
24 |         int ans = req-1;
25 |         if(ans<=extraEdges) return ans;
26 |         return -1;
27 |     }
28 |     public int findParent(int node,int[] parent)
29 |     {
30 |         if(parent[node]==node) return node;
31 |         return parent[node]=findParent(parent[node],parent);
32 |     }
33 | 
34 |     public void union(int u,int v,int[] parent,int[] rank)
35 |     {
36 |         int pu = findParent(u,parent);
37 |         int pv = findParent(v,parent);
38 |         if(rank[pu]<rank[pv]){
39 |             parent[pu]=pv;
40 |         }
41 |         else if(rank[pv]<rank[pu]){
42 |             parent[pv] = pu;
43 |         }
44 |         else{
45 |             parent[pv]=pu;
46 |             rank[pu]++;
47 |             }
48 |     }
49 | }


--------------------------------------------------------------------------------
/leetcode/Numbers With Same Consecutive Differences/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int[] numsSameConsecDiff(int n, int k) {
 3 |         Queue<Integer> q = new LinkedList<>();
 4 |         for (int i=1;i<=9;i++)
 5 |         {
 6 |             q.add(i);
 7 |         } 
 8 |         for(int j=1;j<n;j++)
 9 |         {
10 |             int size = q.size();
11 |             for(int e=0;e<size;e++)
12 |             {
13 |                 Integer x = q.poll();
14 |                 int f= x%10;
15 |                 if(f+k <=9)
16 |                 {
17 |                     Integer g=(x*10)+(f+k);
18 |                     q.add(g);
19 |                 }
20 |                 if(f-k >= 0 && k != 0)
21 |                 {
22 |                     Integer g=(x*10)+(f-k);
23 |                     q.add(g);
24 |                 }
25 |             }
26 |         }
27 |         int[] arr=new int[q.size()];
28 |         int index=0;
29 |         while(!q.isEmpty())
30 |         {
31 |             arr[index++]=q.poll();
32 |         }
33 |         return arr;
34 |     }
35 | }
36 | 


--------------------------------------------------------------------------------
/leetcode/Power of Two/solution.java:
--------------------------------------------------------------------------------
1 | class Solution {
2 |     public boolean isPowerOfTwo(int n) {
3 |      if(n<=0)
4 |      {
5 |         return false;
6 |      }   
7 |      return((n)&(n-1))==0?true:false;
8 |     }
9 | }


--------------------------------------------------------------------------------
/leetcode/Rotting Oranges/solution.java:
--------------------------------------------------------------------------------
 1 | class Pair{
 2 | 		int row;
 3 |         int col;
 4 |     int time;
 5 |     Pair(int _row, int _col , int _time){
 6 |     		this.row=_row;
 7 |         this.col=_col;
 8 |         this.time=_time;
 9 |     }
10 | }
11 | class Solution {
12 |     public int orangesRotting(int[][] grid) {
13 |         int m = grid.length;
14 |         int n = grid[0].length;
15 |         int [][] vis = new int[m][n];
16 |         Queue<Pair> q = new LinkedList<>();
17 |         int fresh=0;
18 |         for(int i=0;i<m;i++){
19 |         	for(int j=0;j<n;j++){
20 |           		if(grid[i][j]==2){
21 |               		q.offer(new Pair(i,j,0));
22 |                   vis[i][j]=1;
23 |               }
24 |               if(grid[i][j]==1) fresh++;
25 |               
26 |           }
27 |         }
28 |         int t=0;
29 |         int [] drow = {-1,0,1,0};
30 |         int [] dcol = {0,-1,0,1};
31 |         while(!q.isEmpty()){
32 |         		int r = q.peek().row;
33 |             int c = q.peek().col;
34 |             int tm = q.peek().time;
35 |             q.poll();
36 |             t=Math.max(t,tm);
37 |             for(int i=0;i<4;i++){
38 |             		int nrow= r+ drow[i];
39 |                 int ncol= c+ dcol[i];
40 |                 if(nrow>=0 && nrow<m && ncol >= 0 && ncol <n && vis[nrow][ncol]==0 && grid[nrow][ncol]==1){
41 |                 		q.offer(new Pair(nrow,ncol,t+1));
42 |                     vis[nrow][ncol]=1;
43 |                     fresh--;
44 |                 }
45 |             }
46 |         }
47 |         if(fresh==0) return t;
48 |         else return -1;
49 |     }
50 | }


--------------------------------------------------------------------------------
/leetcode/Same Tree/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isSameTree(TreeNode p, TreeNode q) {
 3 |         if(p==null && q==null)
 4 |         return true;
 5 |         if(p==null || q==null)
 6 |         return false;
 7 |         if(p.val!=q.val)
 8 |         return false;
 9 |         return isSameTree(p.left,q.left) && isSameTree(p.right,q.right);
10 |         
11 |     }
12 | }


--------------------------------------------------------------------------------
/leetcode/Search Insert Position/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | public int searchInsert(int[] nums, int target) {
 3 | int l = 0;
 4 | int r = nums.length;
 5 | while (l < r) {
 6 | final int m = (l + r) / 2;
 7 | if (nums[m] == target)
 8 | eturn m;
 9 | if (nums[m] < target)
10 | l = m + 1;
11 | else
12 | r = m;
13 | }
14 | return l;
15 | }
16 | }
17 | 


--------------------------------------------------------------------------------
/leetcode/Search in Rotated Sorted Array/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int search(int[] nums, int target) {
 3 |         int left = 0;
 4 |         int right = nums.length - 1;
 5 | 
 6 |         while (left <= right) {
 7 |             int mid = (left + right) / 2;
 8 | 
 9 |             if (nums[mid] == target) {
10 |                 return mid;
11 |             } else if (nums[mid] >= nums[left]) {
12 |                 if (nums[left] <= target && target <= nums[mid]) {
13 |                     right = mid - 1;
14 |                 } else {
15 |                     left = mid + 1;
16 |                 }
17 |             } else {
18 |                 if (nums[mid] <= target && target <= nums[right]) {
19 |                     left = mid + 1;
20 |                 } else {
21 |                     right = mid - 1;
22 |                 }
23 |             }
24 |         }
25 | 
26 |         return -1;        
27 |     }
28 | }


--------------------------------------------------------------------------------
/leetcode/Single Number/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int singleNumber(int[] nums) {
 3 |         int r=0;
 4 |         for(int num:nums)
 5 |         {
 6 |             r^=num;
 7 |         }
 8 |         return r;
 9 |     }
10 | }
11 | 


--------------------------------------------------------------------------------
/leetcode/Sqrt(x)/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int mySqrt(int x) {
 3 |         if(x==0){
 4 |             return 0;
 5 |         }
 6 |         int low=1;int high=x;int result=0;
 7 |         while(low<=high){
 8 |             int mid=low+(high-low)/2;
 9 |             if(mid<=x/mid){
10 |                 result=mid;
11 |                 low=mid+1;
12 |             }else{
13 |                 high=mid-1;
14 |             }
15 |         }
16 |         return result;
17 |     }
18 | }
19 | 


--------------------------------------------------------------------------------
/leetcode/Subsets/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 | 		private List<List<Integer>> ans = new ArrayList<>();
 3 | 		public void generate( int i , int [] nums , List<Integer> a){
 4 |     		if(i==nums.length){
 5 |         		ans.add(new ArrayList<>(a));
 6 |             return ;
 7 |         }
 8 |         generate(i+1,nums,a);  //notpick
 9 |         a.add(nums[i]);   //pick
10 |         generate(i+1,nums,a);
11 |         a.remove(a.size()-1);  //backtracking
12 |     }
13 |     public List<List<Integer>> subsets(int[] nums) {
14 |         List<Integer> a = new ArrayList<>();
15 |         generate(0,nums,a);
16 |         return ans;
17 |     }
18 | }


--------------------------------------------------------------------------------
/leetcode/Unique Paths II/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public int uniquePathsWithObstacles(int[][] obstacleGrid) {
 3 |         if(obstacleGrid[0][0]==1) return 0;
 4 |         int m=obstacleGrid.length;
 5 |         int n=obstacleGrid[0].length;
 6 |         int [][] dp = new int[m][n];
 7 |         dp[0][0]=1;
 8 |         for(int i=1;i<m;i++){
 9 |             if(obstacleGrid[i][0]==1) dp[i][0]=0;
10 |             else dp[i][0]=dp[i-1][0];
11 |         }  
12 |         for(int i=1;i<n;i++){
13 |             if(obstacleGrid[0][i]==1) dp[0][i]=0;
14 |             else dp[0][i]=dp[0][i-1];
15 |         }  
16 |         for(int i=1;i<m;i++){
17 |             for(int j=1;j<n;j++){
18 |                 if(obstacleGrid[i][j]==1) dp[i][j]=0;
19 |                 else dp[i][j]=dp[i-1][j]+dp[i][j-1];
20 |             }
21 |         }
22 |         return dp[m-1][n-1];
23 |     }
24 | }
25 | 


--------------------------------------------------------------------------------
/leetcode/Validate Binary Search Tree/solution.java:
--------------------------------------------------------------------------------
 1 | class Solution {
 2 |     public boolean isValidBST(TreeNode root) {
 3 |         return isValidBST(root, Long.MIN_VALUE, Long.MAX_VALUE);
 4 |     }
 5 | 
 6 |     private boolean isValidBST(TreeNode root, long minValue, long maxValue) {
 7 |         if (root == null) {
 8 |             return true;
 9 |         }
10 |         if (root.val <= minValue || root.val >= maxValue) {
11 |             return false;
12 |         }
13 |         return isValidBST(root.left, minValue, root.val) && isValidBST(root.right, root.val, maxValue);
14 |     }
15 | }


--------------------------------------------------------------------------------