Leetcode : subset 2 and min insertion to make string palindrome

C++/Subsets ||.cpp

@@ -0,0 +1,40 @@
+/*Problem url : https://leetcode.com/problems/subsets-ii/ */
+
+// Given an integer array nums that may contain duplicates, return all possible subsets (the power set).
+// The solution set must not contain duplicate subsets. Return the solution in any order.
+
+
+
+class Solution {
+public:
+    set<vector<int>> stt;
+    void print(int index, vector<int> &v, vector<vector<int>> &ans, vector<int> &nums,int n)
+    {
+        if(index == n)
+        {
+            if(stt.find(v)==stt.end())
+            {
+                ans.push_back(v);
+                stt.insert(v);
+            }
+
+            return;
+        }
+
+        print(index+1,v,ans,nums,n);
+
+        v.push_back(nums[index]);
+        print(index+1,v,ans,nums,n);
+        v.pop_back();           
+    }
+
+    vector<vector<int>> subsetsWithDup(vector<int>& nums) {
+        sort(nums.begin(),nums.end());
+        vector<vector<int>> ans;
+        vector<int> v;
+        int n = nums.size();
+        print(0,v,ans,nums,n);
+
+        return ans;
+    }
+};

C++/min_insertion_to_make_string_palindrome.cpp

@@ -0,0 +1,62 @@
+// <!-- Leetcode 
+
+// 1312. Minimum Insertion Steps to Make a String Palindrome
+
+// Given a string s. In one step you can insert any character at any index of the string.
+
+// Return the minimum number of steps to make s palindrome.
+
+// A Palindrome String is one that reads the same backward as well as forward. -->
+
+
+
+class Solution {
+public:
+    int longestCommonSubsequence(string text1, string text2) {
+        int n1 = text1.size();
+        int n2 = text2.size();
+        // vector<vector<int>> dp(n1+1,vector<int>(n2+1,0));
+        vector<int> prev(n2+1,0), cur(n2+1,0);
+
+        for(int i=1;i<=n1;i++)
+        {
+            for(int j=1;j<=n2;j++)
+            {
+                if(text1[i-1] == text2[j-1])
+                {
+                    cur[j] = 1 + prev[j-1];
+                }
+
+                else
+                {
+                    cur[j] = max(prev[j] , cur[j-1]);
+                }
+            }
+            prev = cur;
+        }
+
+        return prev[n2];
+    }
+
+    string reverseStr(string str)
+    {
+        int n = str.length();
+
+        // Swap character starting from two
+        // corners
+        for (int i = 0; i < n / 2; i++)
+            swap(str[i], str[n - i - 1]);
+
+        return str;
+    }
+
+    int longestPalindromeSubseq(string s) {
+        string t = reverseStr(s);
+        return longestCommonSubsequence(s,t);
+    }
+
+    int minInsertions(string s) {
+        int n = s.size();
+        return n - longestPalindromeSubseq(s);
+    }
+};