Few More DP problems implemented.

src/longestPalindromeSubstring.java

@@ -0,0 +1,42 @@
+import java.util.*;
+import java.io.*;
+public class longestPalindromeSubstring {
+	public static void main(String[] args) throws IOException {
+        BufferedReader br =
+            new BufferedReader(new InputStreamReader(System.in));
+        int tc = Integer.parseInt(br.readLine().trim());
+        while (tc-- > 0) {
+            String str = br.readLine().trim();
+            Solution sln = new Solution();
+            System.out.println(sln.longestPalindrome(str));
+        }
+    }
+}
+class Solution {
+    // complete this function
+    public String longestPalindrome(String s) {
+        if(s==null||s.length()==0)
+        return "";
+        int start=-1;
+        int max_len =0;
+        int n=s.length();
+        boolean dp[][]=new boolean[n][n];
+        for(int i=0;i<n;i++)
+        dp[i][i]=true;
+        for(int i=1;i<n;i++){
+            for(int j=i-1;j>=0;j--){
+                dp[j][i]=s.charAt(i)==s.charAt(j)&&(i-j<3||dp[j+1][i-1]);
+                if(dp[j][i]){
+                    int len=i-j+1;
+                    if(len>max_len){
+                        max_len=len;
+                        start=j;
+                    }
+                }
+            }
+        }
+        if(start!=-1)
+        return s.substring(start,start+max_len);
+        return String.valueOf(s.charAt(0));
+    }
+}

src/problems/dynamicprogramming/countNumberOfHops.java

@@ -0,0 +1,34 @@
+package problems.dynamicprogramming;
+import java.util.*;
+public class countNumberOfHops {
+	public static void main(String args[])
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+
+        while(t-- > 0)
+        {
+            int n = sc.nextInt();
+            System.out.println(new Hops().countWays(n));
+
+        }
+    }
+}
+class Hops
+{
+    static long countWays(int n)
+    {
+        if(n==0||n==1)
+        return 1;
+        long dp[]=new long[n+1];
+        dp[0]=1;
+        dp[1]=1;
+        dp[2]=2;
+        for(int i=3;i<=n;i++)
+            dp[i]=(dp[i-1]+dp[i-2]+dp[i-3])%1000000007;
+         return dp[n];
+    }
+
+}
+
+

src/problems/dynamicprogramming/distinctOccurrences.java

@@ -0,0 +1,35 @@
+package problems.dynamicprogramming;
+import java.util.*;
+public class distinctOccurrences {
+	public static void main(String args[])
+	{
+		Scanner sc = new Scanner(System.in);
+		int t = sc.nextInt();
+		while(t-->0)
+		{
+			String S = sc.next();
+			String T = sc.next();
+
+			GfG g = new GfG();
+			System.out.println(g.subsequenceCount(S,T));
+		}
+	}
+}
+class GfG
+{
+    int  subsequenceCount(String s, String t)
+    {
+	int dp[][]=new int[t.length()+1][s.length()+1];
+	for(int j=0;j<=s.length();j++)
+	dp[0][j]=1;
+	for(int i=0;i<t.length();i++){
+	    for(int j=0;j<s.length();j++){
+	        if(t.charAt(i)==s.charAt(j))
+	        dp[i+1][j+1]=(dp[i][j]+dp[i+1][j])%1000000007;
+	        else
+	        dp[i+1][j+1]=(dp[i+1][j])%1000000007;
+	    }
+	}
+	return dp[t.length()][s.length()];
+    }
+}

src/problems/dynamicprogramming/longestIncresingSubsequence.java

@@ -0,0 +1,35 @@
+package problems.dynamicprogramming;
+import java.util.*;
+public class longestIncresingSubsequence {
+	 public static void main(String args[]) { 
+	        Scanner sc = new Scanner(System.in);
+	        int t = sc.nextInt();
+	        while(t > 0){
+	            int n = sc.nextInt();
+	            int array[] = new int[n];
+	            for (int i = 0; i < n; ++i)
+	            {
+	                array[i] = sc.nextInt();
+	            }
+	            Solution ob = new Solution();
+	            System.out.println(ob.longestSubsequence(n,array));
+	            t--;
+	        }
+	    } 
+}
+class Solution { 
+    // return length of longest strictly increasing subsequence
+    static int longestSubsequence(int n, int a[]){
+        int dp[]=new int[n];
+        int len=0;
+        for(int num:a){
+            int i=Arrays.binarySearch(dp,0,len,num);
+            if(i<0)
+            i=-(i+1);
+            dp[i]=num;
+            if(i==len)
+            len++;
+        }
+        return len;
+    }
+} 

src/problems/dynamicprogramming/maximumSubarraySum.java

@@ -0,0 +1,38 @@
+package problems.dynamicprogramming;
+import java.util.*;
+public class maximumSubarraySum {
+	public static void main(String args[])
+    {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while(t-->0)
+            {
+                int n;
+                n = sc.nextInt();
+                ArrayList<Integer> arr = new ArrayList<Integer>();
+                for(int i = 0;i<n;i++)
+                    {
+                        int p = sc.nextInt();
+                        arr.add(p);
+                    }
+
+                Sol obj = new Sol();  
+                System.out.println(obj.maxSubArray(arr));  
+
+            }
+    }
+}
+class Sol
+{
+
+    public static int maxSubArray(ArrayList<Integer> a)
+    {
+       int maxsum=a.get(0);
+       int currmax=a.get(0);
+       for(int i=1;i<a.size();i++){
+           currmax=Math.max(a.get(i),currmax+a.get(i));
+           maxsum=Math.max(maxsum,currmax);
+       }
+       return maxsum;
+    }
+}