Add files via upload

Author: shatakshigarg

DP-2/EDIT DISTANCE.txt

@@ -0,0 +1,38 @@
+public class Solution {
+
+	public static int editDistance(String s, String t) {
+		//Your code goes here
+        //Find the lengths of both strings
+        int m=s.length();
+        int n=t.length();
+        
+        int[][] dp = new int[m+1][n+1];
+        //Initializing dp for iterative approach
+        for (int i=n;i>=0;i--)
+            dp[m][i]=n-i;
+        
+        for (int i=m;i>=0;i--)
+            dp[i][n]=m-i;
+        
+        for (int i=m-1;i>=0;i--)
+        {
+            for (int j=n-1;j>=0;j--)
+            {
+                if (s.charAt(i)==t.charAt(j))
+                {
+                    dp[i][j]=dp[i+1][j+1];
+                }
+                else
+                {
+                    int ans1=1+dp[i+1][j+1];
+                    int ans2=1+dp[i][j+1];
+                    int ans3=1+dp[i+1][j];
+                    
+                    dp[i][j]=Math.min(ans1,Math.min(ans2,ans3));
+                }
+            }
+        }
+        return dp[0][0];
+    }
+
+}

DP-2/LCS.txt

@@ -0,0 +1,50 @@
+public class Solution {
+
+	public static int lcs(String s, String t) {
+		//Your code goes here
+        int[][] dp = new int[s.length()+1][t.length()+1];
+        for (int i=0;i<dp.length;i++)
+        {
+            for (int j=0;j<dp[0].length;j++)
+            {
+                dp[i][j]=-1;
+            }
+        }
+        return lcsHelper(s,0,t,0,dp);
+    }
+    
+    private static int lcsHelper(String s, int i, String t, int j, int[][] dp)
+    {
+        if (i==s.length() || j== t.length())
+        {
+            return 0;
+        }
+        
+        if (s.charAt(i)==t.charAt(j))
+        {
+            if (dp[i+1][j+1]==-1)
+            {
+                dp[i+1][j+1]=lcsHelper(s,i+1,t,j+1,dp);
+            }
+            dp[i][j]=1+dp[i+1][j+1];
+        }
+        else
+        {
+            if(dp[i+1][j]==-1)
+            {
+                dp[i+1][j]=lcsHelper(s,i+1,t,j,dp);
+            }
+            int ans1=dp[i+1][j];
+            
+            if(dp[i][j+1]==-1)
+            {
+                dp[i][j+1]=lcsHelper(s,i,t,j+1,dp);
+            }
+            int ans2=dp[i][j+1];
+            
+            dp[i][j]=Math.max(ans1,ans2);
+        }
+        return dp[i][j];
+    }
+
+}

DP-2/MAGIC GRID.txt

@@ -0,0 +1,48 @@
+public class Solution{
+
+
+    public static int getMinimumStrength(int[][] grid) {
+        
+        /* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+        */
+        int row=grid.length;
+        if (row==0)
+            return row;
+        
+        int col=grid[0].length;
+        if (col==0)
+            return col;
+        
+        int[][] dp=new int[row][col];
+        dp[row-1][col-1]=1;
+        
+        for (int i=col-2;i>=0;i--)
+        {
+        	dp[row-1][i]=dp[row-1][i+1]-grid[row-1][i];
+            
+        }
+        for (int i=row-2;i>=0;i--)
+        {
+            dp[i][col-1]=dp[i+1][col-1]-grid[i][col-1];
+        }
+        
+        
+        for(int i=row-2;i>=0;i--)
+        {
+            for (int j=col-2;j>=0;j--)
+            {                
+                int ans1=dp[i+1][j];
+                int ans2=dp[i][j+1];
+                
+                dp[i][j]=Math.max(1,Math.min(ans1,ans2)-grid[i][j]);
+            }
+        }
+        
+        return dp[0][0];
+
+    }
+}

DP-2/MAXIMUM SQUARE MATRIX WITH ALL ZEROS.txt

@@ -0,0 +1,60 @@
+public class Solution {
+	
+
+	public static int findMaxSquareWithAllZeros(int[][] input){
+        
+	/* Your class should be named Solution.
+	 * Don't write main() function.
+	 * Don't read input, it is passed as function argument.
+	 * Return output and don't print it.
+	 * Taking input and printing output is handled automatically.
+	 */
+     int m=input.length;
+     if (m==0)
+         return 0;
+        
+     int n=input[0].length;
+     if (n==0)
+         return 0;
+    
+     int[][] dp = new int[m][n];
+     int maxVal=0;
+     
+     for (int i=0;i<n;i++)
+     {
+         if (input[0][i]==0)
+         {
+             dp[0][i]=1;
+         }
+     }
+     
+     for (int i=0;i<m;i++)
+     {
+         if (input[i][0]==0)
+         {
+             dp[i][0]=1;
+         }
+     }
+        
+     for (int i=1;i<m;i++)
+     {
+         for (int j=1;j<n;j++)
+         {
+             if(input[i][j]==0)
+             {
+                 int ans1=dp[i-1][j];
+                 int ans2=dp[i][j-1];
+                 int ans3=dp[i-1][j-1];
+                 
+                 dp[i][j]=Math.min(ans1,Math.min(ans2,ans3))+1;
+             }
+             if (dp[i][j]>maxVal)
+             	maxVal=dp[i][j];
+         }
+         
+     }
+     
+     return maxVal;
+	
+	}
+}

DP-2/MIN COST PATH PROBLEM.txt

@@ -0,0 +1,39 @@
+public class Solution {
+
+	public static int minCostPath(int[][] cost) {
+		//Find number of rows m  and number of cols n
+		int m=cost.length;
+		int n=cost[0].length;
+				
+		//Create (m+1) * (n+1) dp matrix with all values = infinity
+		int[][] dp = new int[m+1][n+1];
+		for (int i=0;i<dp.length;i++)
+		{
+			for (int j=0;j<dp[0].length;j++)
+			{
+				//We initialize each element as -infinity as the cost can be any positive or negative value (including +infinity)
+				dp[i][j]=Integer.MAX_VALUE;
+			}
+		}
+		
+		//We start filling the minimum cost values for elements from (m-1,n-1) to (0,0)
+		for (int i=m-1;i>=0;i--)
+		{
+			for (int j=n-1;j>=0;j--)
+			{
+				//Handle special case for i=m-1, j=n-1
+				if (i==m-1 && j==n-1)
+				{
+					dp[i][j]=cost[i][j];
+					continue;
+				}
+				int ans1=dp[i+1][j];
+				int ans2=dp[i][j+1];
+				int ans3=dp[i+1][j+1];
+				
+				dp[i][j]=cost[i][j]+Math.min(ans1, Math.min(ans2, ans3));
+			}
+		}
+		return dp[0][0];	
+	}
+}

DP-2/SMALLEST SUPER-SEQUENCE.txt

@@ -0,0 +1,46 @@
+public class Solution {
+
+	public static int smallestSuperSequence(String str1, String str2) {
+
+        /* Your class should be named Solution
+		 * Don't write main().
+		 * Don't read input, it is passed as function argument.
+		 * Return output and don't print it.
+	 	 * Taking input and printing output is handled automatically.
+        */
+        int n1=str1.length();
+        int n2=str2.length();
+        
+        int[][] dp = new int[n1+1][n2+1];
+        for (int i=n1;i>=0;i--)
+        {
+            dp[i][n2]=n1-i;
+        }
+        for (int i=n2;i>=0;i--)
+        {
+            dp[n1][i]=n2-i;
+        }
+        
+        for (int i=n1-1;i>=0;i--)
+        {
+            for (int j=n2-1;j>=0;j--)
+            {
+                if(str1.charAt(i)==str2.charAt(j))
+                {
+					dp[i][j]=dp[i+1][j+1]+1;
+                }
+                else
+                {
+                    
+                    int ans1=dp[i+1][j];
+                    int ans2=dp[i][j+1];
+                    
+                    dp[i][j]=Math.min(ans1,ans2)+1;
+                }
+            }
+        }
+        
+        return dp[0][0];
+        
+}
+}

DP-2/WAYS TO MAKE COIN CHANGE.txt

@@ -0,0 +1,34 @@
+public class Solution {
+
+	
+	public static int countWaysToMakeChange(int denominations[], int value){
+        // Write your code here
+        /*
+        if (value==0)
+            return 1;
+        
+        if (value<0)
+            return 0;
+        
+        int finalAns=0;
+        for (int i=0;i<denominations.length;i++)
+        {
+            finalAns=finalAns+countWaysToMakeChange(denominations,value-denominations[i]);
+        }
+        return finalAns;
+        */
+        int[] dp = new int[value+1];
+        dp[0]=1;
+        for (int i=0;i<denominations.length;i++)
+        {
+            for (int j=0;j<=value;j++)
+            {
+                if (j>=denominations[i])
+                {
+                    dp[j]=dp[j]+dp[j-denominations[i]];
+                }
+            }
+        }
+        return dp[value];
+	}	
+}