Issue 945 (#948)

Author: GurleenKaur09

Java/Algorithm/DynamicProgramming/Kadane/Kadane.java

@@ -0,0 +1,31 @@
+import java.util.*;
+
+class KadanesAlgo
+{
+	public static void main (String[] args) throws java.lang.Exception
+	{
+	   
+	    Scanner sc=new Scanner(System.in);  
+        System.out.print("Enter the number of elements you want to store: ");  
+        int n=sc.nextInt();  
+        int[] a = new int[100];  
+        System.out.println("Enter the elements of the array: ");  
+        for(int i=0; i<n; i++)  {  
+            a[i]=sc.nextInt();  
+        }  
+        int local_max = 0;
+        int global_max = Integer.MIN_VALUE;
+        
+        for(int i=0;i<n;i++)
+    	{
+    	    local_max = Math.max(a[i], a[i] + local_max);
+    	    
+    	    if(local_max > global_max)
+    	    {
+    	        global_max = local_max;
+    	    }
+    	    
+    	}
+        System.out.println("Maximum Subarray sum: " +global_max);
+	}
+}

Java/Algorithm/DynamicProgramming/LCS/LCS.java

@@ -0,0 +1,59 @@
+import java.util.Scanner;  
+  
+class LCSExample1 {  
+    public static String findLengthOfLCS(String str1, String str2, int p, int q) {  
+        int[][] tableForLCS = new int[p + 1][q + 1];  
+        for (int i = 0; i <= p; i++) {  
+            for (int j = 0; j <= q; j++) {  
+                if (i == 0 || j == 0)  
+                    tableForLCS[i][j] = 0; 
+                else if (str1.charAt(i - 1) == str2.charAt(j - 1))  
+                    tableForLCS[i][j] = tableForLCS[i - 1][j - 1] + 1;  
+                else  
+                    tableForLCS[i][j] = Math.max(tableForLCS[i - 1][j], tableForLCS[i][j - 1]);     
+            }  
+        }
+        int index = tableForLCS[p][q];  
+        int temp = index;  
+        char[] longestCommonSubsequence = new char[index + 1];  
+        longestCommonSubsequence[index] = '\0';  
+        int i = p, j = q;  
+        String lcs ="";  
+        while (i > 0 && j > 0) {  
+            if (str1.charAt(i - 1) == str2.charAt(j - 1)) {  
+                  
+                longestCommonSubsequence[index - 1] = str1.charAt(i - 1);  
+                i--;  
+                j--;  
+                index--;  
+            }  
+            else if (tableForLCS[i - 1][j] > tableForLCS[i][j - 1])  
+                i--;  
+            else  
+                j--;  
+        }  
+        for (int k = 0; k <= temp; k++)  
+            lcs = lcs + longestCommonSubsequence[k];  
+              
+        return lcs;  
+    }  
+    public static void main(String[] args) {  
+          
+        String str1, str2, LCS;  
+          
+        Scanner sc= new Scanner(System.in); 
+        System.out.print("Enter first sequence: ");  
+        str1 = sc.nextLine(); 
+          
+        System.out.print("Enter second sequence: ");  
+        str2 = sc.nextLine(); 
+          
+        int p = str1.length();  
+        int q = str2.length();  
+          
+        LCS = findLengthOfLCS(str1, str2, p, q);  
+          
+        System.out.println("LCS: "+LCS);  
+          
+    }  
+}  

Java/Algorithm/DynamicProgramming/LIS/LIS.java

@@ -0,0 +1,41 @@
+import java.util.*;
+
+public class LIS {
+    public static void main(String[] args){
+
+        Scanner sc=new Scanner(System.in);  
+        System.out.print("Enter the number of elements you want to store: ");  
+        int n=sc.nextInt();  
+        int[] nums= new int[100];  
+        System.out.println("Enter the elements of the array: ");  
+        for(int i=0; i<n; i++)  {  
+            nums[i]=sc.nextInt();  
+        }  
+        printLIS(nums);
+    }
+        public static void printLIS(int[] nums){
+        String[] paths = new String[nums.length];
+        int[] sizes = new int[nums.length];
+
+        for(int i=0; i<nums.length; i++){
+            sizes[i] = 1;
+            paths[i] = nums[i] + " " ;
+        }
+    int maxLength = 1; 
+
+    for(int i=1; i<nums.length; i++){ 
+        for(int j=0; j<nums.length; j++){
+    if(nums[i]>nums[j] && sizes[i] < sizes[j] + 1){;
+        sizes[i] = sizes[j] + 1;
+        paths[i] = paths[j] + nums[i] + " "; 	
+        if(maxLength < sizes[i])
+            maxLength = sizes[i];
+        }
+    }
+    }
+    for(int i=1; i<nums.length; i++){
+        if(sizes[i] == maxLength)
+        System.out.println("LIS: " + paths[i]);
+    }
+    }
+}

Java/Algorithm/DynamicProgramming/NoOfSubsequences/Subsequences.java

@@ -0,0 +1,43 @@
+import java.util.*;
+
+public class Subsequences {
+public static void main(String[] args) {
+	Scanner sc=new Scanner(System.in);  
+	System.out.print("Enter the number of elements you want to store: ");  
+	int n=sc.nextInt();  
+	int[] arr= new int[100];  
+	System.out.println("Enter the elements of the array: ");  
+	for(int i=0; i<n; i++)  {  
+		arr[i]=sc.nextInt();  
+	}
+	System.out.print("Enter Sum: ");
+	int X = sc.nextInt();
+	System.out.println(countSubsequence(arr, n, X));
+}
+
+public static int countSubsequence(int[] A, int N, int X) {
+	int[][] dp = new int[N+1][X+1];
+	for (int[] row : dp) {
+	Arrays.fill(row, 0);
+	}
+	for (int i = 0; i <= N; i++) {
+	for (int j = 0; j <= X; j++) {
+		if (i == N) {
+		dp[i][j] = 1;
+		}
+	}
+	}
+
+	for (int i = N-1; i >= 0; i--) {
+	for (int j = 1; j <= X; j++) {
+		if (A[i] <= j) {
+		dp[i][j] = dp[i+1][j] + dp[i+1][j-A[i]];
+		} else {
+		dp[i][j] = dp[i+1][j];
+		}
+	}
+	}
+	System.out.print("Number of Subsequences with sum less than or equal to given sum: ");
+	return dp[0][X] - 1;
+}
+}