Added codes for 26 May

GeeksForGeeks/May/26-5-24/GFG.java

@@ -0,0 +1,50 @@
+//{ Driver Code Starts
+// Initial Template for Java
+
+import java.io.*;
+import java.util.*;
+
+class GfG {
+    public static void main(String args[]) {
+        Scanner sc = new Scanner(System.in);
+        int t = sc.nextInt();
+        while (t-- > 0) {
+            String X = sc.next();
+            String Y = sc.next();
+            int costX = sc.nextInt();
+            int costY = sc.nextInt();
+
+            Solution ob = new Solution();
+            System.out.println(ob.findMinCost(X, Y, costX, costY));
+        }
+    }
+}
+// } Driver Code Ends
+
+
+class Solution 
+{
+    public int findMinCost(String x, String y, int costX, int costY) 
+    {
+        int n = x.length(), m = y.length();
+	    int dp[][] = new int[n+1][m+1];
+
+	    for (int i=0; i<=n; i++)
+	        dp[i][0] = 0;
+
+	    for (int i=0; i<=m; i++)
+	        dp[0][i] = 0;
+
+	    for (int i=1; i<=n; i++)
+	    {
+	        for (int j=1; j<=m; j++)
+	        {
+	            if (x.charAt(i-1) == y.charAt(j-1))
+	                dp[i][j] = 1 + dp[i-1][j-1];
+	            else
+	                dp[i][j] = Math.max(dp[i-1][j], dp[i][j-1]);
+	        }
+	    }
+	    return (n-dp[n][m])*costX + (m-dp[n][m])*costY;
+    }
+}

GeeksForGeeks/May/26-5-24/README.md

@@ -0,0 +1,2 @@
+Time complexity - O(n*m)
+Space complexity - O(n*m)

LeetCode/May/26-5-24/README.md

@@ -0,0 +1,2 @@
+Time complexity - O(n)
+Space complexity - O(1)

LeetCode/May/26-5-24/Solution.java

@@ -0,0 +1,36 @@
+class Solution 
+{
+    public int checkRecord(int n)
+    {
+        int kMod = 1_000_000_007;
+        // dp[i][j] := the length so far with i A's and the last letters are j L's
+        long[][] dp = new long[2][3];
+        dp[0][0] = 1;
+
+        while (n-- > 0) 
+        {
+            long[][] prev = Arrays.stream(dp).map((long[] A) -> A.clone())
+                                .toArray((int length) -> new long[length][]);
+
+            // Append a P.
+            dp[0][0] = (prev[0][0] + prev[0][1] + prev[0][2]) % kMod;
+
+            // Append an L.
+            dp[0][1] = prev[0][0];
+
+            // Append an L.
+            dp[0][2] = prev[0][1];
+
+            // Append an A or append a P.
+            dp[1][0] = (prev[0][0] + prev[0][1] + prev[0][2] + prev[1][0] + prev[1][1] + prev[1][2]) % kMod;
+
+            // Append an L.
+            dp[1][1] = prev[1][0];
+
+            // Append an L.
+            dp[1][2] = prev[1][1];
+        }
+
+        return (int) ((dp[0][0] + dp[0][1] + dp[0][2] + dp[1][0] + dp[1][1] + dp[1][2]) % kMod);
+    }
+}