Add files via upload

Author: shatakshigarg

DP-1/COIN TOWER.txt

@@ -0,0 +1,44 @@
+public class Solution {
+
+	public static String findWinner(int n, int x, int y) {
+		//Your code goes here
+        int[] dp = new int[n+1];
+        // 0 - Whis wins ; 1 - Beerus wins
+        dp[0]=0;
+        dp[1]=1;
+    
+        for (int i=2;i<=n;i++)
+        {
+            //Beerus wins if dp[i-1] or dp[i-x] or dp[i-y] is 0, i.e, Whis wins when the number of coins is (i-1), (i-x) or (i-y)
+            //If none of them are 0, then Beerus cannot win => This means Whis wins for i number of coins
+            if (dp[i-1]==0)
+            {
+                dp[i]=1;
+            }
+            else if ((i-x)>=0 && dp[i-x]==0)
+            {
+                dp[i]=1;
+            }
+            else if ((i-y)>=0 && dp[i-y]==0)
+            {
+                dp[i]=1;
+            }
+            else
+            {
+                dp[i]=0;
+            }
+            /*
+            if (dp[i]==1)
+            	System.out.println("For n="+i+" coins, Winner is: Beerus");
+        	else
+            	System.out.println("For n="+i+" coins, Winner is: Whis");
+            */
+        }
+        
+        if (dp[n]==1)
+            return "Beerus";
+        else
+            return "Whis";
+	}
+
+}

DP-1/LOOT HOUSES.txt

@@ -0,0 +1,38 @@
+public class Solution {
+
+	public static int maxMoneyLooted(int[] houses) {
+		//Your code goes here
+        //Handling the base cases where number of houses = 0,1,2
+        if (houses.length==0)
+            return 0;
+        
+        if (houses.length==1)
+            return houses[0];
+        
+        if (houses.length==2)
+            return Math.max(houses[0],houses[1]);
+        
+        int n = houses.length;
+        int[] dp = new int[n];
+        dp[0]=houses[0];
+        dp[1]=Math.max(houses[0],houses[1]);
+        
+        for (int i=2;i<n;i++)
+        {
+            //For every house, we consider two cases
+            //Case 1 - Current house is counted as part of the max value => This means the previous house cannot be counted
+            int maxVal1=dp[i-2]+houses[i];
+            
+            //Case 2 - Current house is not counted as part of the max value => This means previous house can be counted
+            int maxVal2=dp[i-1];
+            
+            //Max value till current house is maximum of the two possible max values till now
+            dp[i]=Math.max(maxVal1,maxVal2);
+        }
+        
+        //Final element of dp stores max possible value for given number of houses and their respective amounts of loot
+        return dp[n-1];
+        
+	}
+
+}

DP-1/MIN STEPS TO 1 USING DP.txt

@@ -0,0 +1,42 @@
+public class Solution {
+
+	public static int countMinStepsToOne(int n) {
+		
+        if(n<=1)
+        {
+            return 0;
+        }
+        if(n==2)
+        {
+            return 1;
+        }
+        if(n==3)
+        {
+            return 1;
+        }
+        
+        int dp[] = new int[n+1];
+        dp[0]=0;
+        dp[1]=0;
+        
+        for(int i =2;i<=n;i++)
+        {
+            int ans1=Integer.MAX_VALUE,ans2=Integer.MAX_VALUE,ans3=Integer.MAX_VALUE;
+            ans1=dp[i-1];
+            
+            if(i%2==0)
+            {
+                ans2=dp[i/2];
+            }
+            if(i%3==0)
+            {
+                ans3=dp[i/3];
+            }
+            
+            dp[i]=1+ Math.min(ans1,Math.min(ans2,ans3));
+        }
+        
+        return dp[n];
+	}
+
+}

DP-1/MIN STEPS TO ONE.txt

@@ -0,0 +1,38 @@
+public class Solution {
+
+	public static int countMinStepsToOne(int n) {
+		//Your code goes here
+         if(n<=1)
+	        {
+	            return 0;
+	        }
+
+	        if(n==2)
+	        {
+	            return 1;
+	        }
+	        if(n==3)
+	        {
+	            return 1;
+	        }
+			int a;
+	        int b= Integer.MAX_VALUE;
+	        int c=Integer.MAX_VALUE;
+	        a = countMinStepsToOne(n-1);
+	        if(n%2==0)
+	        {
+	            b = countMinStepsToOne(n/2);   
+	        }
+	        if(n%3==0)
+	        {
+	            c=countMinStepsToOne(n/3);
+	        }
+
+	        return 1+ Math.min(a,Math.min(b,c));
+	    }
+
+	public static void main(String[] args) {
+		System.out.println(countMinStepsToOne(10));
+	}
+
+}

DP-1/MINIMUM NUMBER OF SQUARES.txt

@@ -0,0 +1,42 @@
+public class Solution {
+
+	public static int minCount(int n) {
+		int dp[]=new int[n+1];
+        for(int i =0;i<dp.length;i++)
+        {
+            dp[i]=-1;
+        }
+        
+        return count(n,dp);
+	}
+    
+    public static int count(int n,int dp[])
+    {
+        if(n==0)
+        {
+            return 0;
+        }
+        
+        int minans=Integer.MAX_VALUE;
+        int ans;
+        for(int i =1;i*i<=n;i++)
+        {
+            if(dp[n-(i*i)]==-1)
+            {
+                ans = count((n-(i*i)),dp);
+                dp[n-(i*i)]=ans;
+            }
+            else
+            {
+                ans = dp[n-(i*i)];
+            }
+            
+            if(ans<minans)
+            {
+                minans=ans;
+            }
+        }
+        return 1 + minans;
+    }
+
+}

DP-1/STAIR CASE.txt

@@ -0,0 +1,25 @@
+public class Solution {
+
+	public static long staircase(int n) {
+		if(n<=1)
+        {
+            return 1;
+        }
+        if(n==2)
+        {
+            return 2;
+        }
+        
+        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];
+        }
+        
+        return dp[n];
+	}
+
+}