Merge pull request #2955 from Abe0770/main

Create 2657-find-the-prefix-common-array-of-two-arrays.cpp

Author: MHamiid

cpp/2657-find-the-prefix-common-array-of-two-arrays.cpp

@@ -0,0 +1,38 @@
+/*
+  You are given two 0-indexed integer permutations A and B of length n.
+  A prefix common array of A and B is an array C such that C[i] is equal to the count of numbers that are present at or before the index i in both A and B.
+  Return the prefix common array of A and B.
+  A sequence of n integers is called a permutation if it contains all integers from 1 to n exactly once.
+
+  Ex. Input: A = [1,3,2,4], B = [3,1,2,4]
+      Output: [0,2,3,4]
+      Explanation: At i = 0: no number is common, so C[0] = 0.
+      At i = 1: 1 and 3 are common in A and B, so C[1] = 2.
+      At i = 2: 1, 2, and 3 are common in A and B, so C[2] = 3.
+      At i = 3: 1, 2, 3, and 4 are common in A and B, so C[3] = 4.
+
+    Time  : O(n)
+    Space : O(n)
+*/
+
+class Solution {
+public:
+    vector<int> findThePrefixCommonArray(vector<int>& A, vector<int>& B) {
+        vector<int> C;
+        vector<int> v(A.size()+1,0);
+        int count = 0;
+
+        for(int i = 0; i < A.size(); ++i){
+            if(v[A[i]] < 0)
+                count++;
+            ++v[A[i]];
+
+            if(v[B[i]]>0)
+                count++;
+            --v[B[i]];
+            
+            C.push_back(count);
+        }
+        return C;
+    }
+};

cpp/2707-extra-characters-in-a-string.cpp

@@ -0,0 +1,36 @@
+/*
+  You are given a 0-indexed string s and a dictionary of words dictionary. 
+  You have to break s into one or more non-overlapping substrings such that each substring is present in dictionary. 
+  There may be some extra characters in s which are not present in any of the substrings.
+
+  Return the minimum number of extra characters left over if you break up s optimally.
+
+  Ex. Input: s = "leetscode", dictionary = ["leet","code","leetcode"]
+      Output: 1
+      Explanation: We can break s in two substrings: "leet" from index 0 to 3 and "code" from index 5 to 8. There is only 1 unused character (at index 4), so we return 1.
+
+  Time  : O(N^M)    M = dictionary.size(), N = s.size()
+  Space : O(N)
+*/
+
+class Solution {
+public:
+    int minExtraChar(string s, vector<string>& dictionary) {
+        int n = s.size();
+        vector<int> dp(n + 1, n);
+
+        dp[0] = 0; 
+
+        for (int i = 1; i <= n; ++i) {
+            for(int j = 0 ; j < dictionary.size() ; ++j) {
+                int len = dictionary[j].size();
+                if (i >= len && s.substr(i - len, len) == dictionary[j]) {
+                    dp[i] = min(dp[i], dp[i - len]);
+                }
+            }
+            dp[i] = min(dp[i], dp[i - 1] + 1);
+        }
+
+        return dp[n];
+    }
+};