pull request to merge code and resolve conflict in Readme

Author: Xianfeng Zhao

Binary_Search/483.Smallest-Good-Base/483.Smallest Good Base.cpp

@@ -2,45 +2,29 @@ class Solution {
 public:
     string smallestGoodBase(string n) 
     {
-        long long N=0;
-        for (int i=0; i<n.size(); i++)
-            N=N*10+n[i]-'0';
-        
-        if (N==1) return "2";
-        
-        long long m_max = log(N+1)/log(2)+1;
-        
-        for (long long m=m_max; m>=2; m--)
+        long long N = stoll(n);
+        for (int m = log(N+1)/log(2); m>=2; m--)
         {
             long long left = 2;
-            long long right = pow(N,1.0/(m-1));
-            long long mid;
-            
-            // cout<<"m="<<m<<" "<<left<<" "<<right<<" "<<endl;
-                
-            while (left<=right)  // 两个边界都需要探查
+            long long right = pow(N, 1.0/(m-1));
+            while (left<=right)
             {
+                long long mid = left+(right-left)/2;
+                long long k = mid;
 
-                mid = left+(right-left)/2;
-                long long k=mid;
-                long long sum=1;
+                long long sum = 1;
                 for (int i=1; i<m; i++)
-                {
-                    sum=sum*k+1;
-                }
-                if (sum==N)
-                    return to_string(k);
-                else if (sum<N)
-                    left = mid+1;
-                else
-                    right = mid-1;  // 注意，因为mid已经排除，所以right的更新值不应该包括mid本身，否则死循环。
-                    
-                //cout<<sum<<" "<<k<<" "<<m<<" "<<endl;
-                    
+                    sum = sum*k + 1;
+                
+                //cout<<m<<" "<<" "<<k<<" "<<sum<<endl;
+                
+                if (sum==N) return to_string(k);
+                else if (sum>N) right = mid-1;
+                else left = mid+1;
             }
+            
         }
 
         return to_string(N-1);
-        
     }
 };

Bit_Manipulation/2002.Maximum-Product-of-the-Length-of-Two-Palindromic-Subsequences/2002.Maximum-Product-of-the-Length-of-Two-Palindromic-Subsequences.cpp

@@ -0,0 +1,39 @@
+class Solution {    
+public:
+    int lp(string&s, int state)
+    {           
+        string t;
+        for (int i=0; i<s.size(); i++)
+        {
+            if ((state>>i)&1)
+                t.push_back(s[s.size()-1-i]);
+        }
+                
+        int n = t.size();          
+        vector<vector<int>>dp(n, vector<int>(n));
+        for (int i=0; i<n; i++)
+            dp[i][i] = 1;
+        for (int len=2; len<=n; len++)
+            for (int i=0; i+len-1<n; i++)
+            {
+                int j = i+len-1;
+                if (t[i]==t[j])
+                    dp[i][j] = dp[i+1][j-1]+2;
+                else
+                    dp[i][j] = max(dp[i][j-1], dp[i+1][j]);
+            }        
+       
+        return dp[0][n-1];
+    }
+    
+    
+    int maxProduct(string s) 
+    {
+        int n = s.size();
+        int all = (1<<n)-1;
+        int ret = 0;
+        for (int subset=1; subset<(1<<n)-1; subset++)
+            ret = max(ret, lp(s, all-subset)*lp(s, subset));
+        return ret;
+    }
+};

Bit_Manipulation/2002.Maximum-Product-of-the-Length-of-Two-Palindromic-Subsequences/Readme.md

@@ -0,0 +1,5 @@
+### 2002.Maximum-Product-of-the-Length-of-Two-Palindromic-Subsequences
+
+因为只有12个字符，我们可以暴力枚举拆解的方案，也就是2^12=4096种方法，将原字符串拆为两个subsequence。然后查看每个subsequence里面最长的回文子序列。
+
+对于一个subsequence里面的最长回文子序列问题，我们可以将这个子序列收拢转化为一个常规的字符串。求字符串里的最长回文子序列，这是一个经典问题。可以用o(N^2)的DP。

DFS/2014.Longest-Subsequence-Repeated-k-Times/2014.Longest-Subsequence-Repeated-k-Times.cpp

@@ -0,0 +1,63 @@
+class Solution {
+    int k;
+    string s;
+    string ret;
+public:
+    string longestSubsequenceRepeatedK(string s, int k) 
+    {
+        this->k = k;
+        this->s = s;
+        vector<int>count(26);
+        for (auto ch:s)
+            count[ch-'a']++;
+        string t;
+        for (int i=0; i<26; i++)
+        {
+            if (count[i]>=k)
+                t.push_back('a'+i);
+        }
+
+        string temp;
+        dfs(t, temp);
+        
+        return ret;
+    }
+
+    void dfs(string&t, string& temp)
+    {       
+        if (temp!="" && !checkOK(temp))
+            return;
+
+        if (temp.size()>ret.size() || (temp.size()==ret.size() && temp>ret))
+            ret = temp;
+
+        if (temp.size()==7)
+            return;
+
+        for (auto ch: t)
+        {
+            temp.push_back(ch);
+            dfs(t, temp);
+            temp.pop_back();
+        }
+    }
+
+    bool checkOK(string& temp)
+    {
+        int j = 0;
+        int count = 0;
+        for (int i=0; i<s.size(); i++)
+        {
+            if (s[i]!=temp[j]) continue;
+            j++;
+            if (j==temp.size())
+            {
+                j = 0;
+                count++;
+                if (count == k)
+                    return true;
+            }            
+        }
+        return false;        
+    }
+};

DFS/2014.Longest-Subsequence-Repeated-k-Times/Readme.md

@@ -0,0 +1,7 @@
+### 2014.Longest-Subsequence-Repeated-k-Times
+
+本题其实并没有特别高明的算法，就是“暴力”枚举可能的repeated subsequence，然后检验该子序列能否在s中重复k次。显然对于“检验”的操作，复杂度就是o(n)=16000，那么枚举repeated subsequence的复杂度是多少呢？
+
+注意到本题的约束条件```n < k*8```. 这说明了两点：首先，repeated subsequence的长度不超过7，否则重复k次之后会有```n>=len(subsequenc)*k>=8*k```推出矛盾。其次，s里面频次大于等于k的字符种类不会超过7，否则也会有```n>=k*8```推出矛盾。这两个推论告诉我们，repeated subsequence的构造并没有那么复杂，它最长只有7位，并且字符的种类不会超过7种。所以repeated subsequence的可能性最多就是7^7+7^6+7^5...= 7^8 = 5e6。
+
+按照上面的分析，共有5e6种可能的subsequence，每次检验需要1.6e4，总的时间复杂度依然达到了1e10数量级。我们只能寄希望于剪枝，降低subsequence的种类数目。其中一种方法就是，如果我们发现一个较短的subsequence不符合条件（即无法重复k次依然是s的子序列），那么任何在此基础上append任何字符也都不会符合条件。所以这就提醒我们“暴力”枚举repeated subsequence可以采用从短的序列逐渐生成更长序列的方法，一旦检验发现不合条件，就可以终止这个支路。

Dynamic_Programming/115.Distinct-Subsequences/115.Distinct-Subsequences.cpp

@@ -4,20 +4,27 @@ class Solution {
     {
         int m = s.size();
         int n = t.size();
-        auto dp = vector<vector<long>>(m+1,vector<long>(n+1,0));
+        auto dp = vector<vector<long long>>(m+1,vector<long long>(n+1,0));
         s = "#"+s;
         t = "#"+t;
+                
+        if (m<n) 
+            return 0;
+        if (m==n)
+            return (s==t);
 
-        for (int i=0; i<=m; i++) dp[i][0] = 1;
+        for (int i=0; i<=m; i++)
+            dp[i][0] = 1;
 
         for (int i=1; i<=m; i++)
             for (int j=1; j<=n; j++)
             {
                 if (s[i]==t[j])
-                    dp[i][j] += dp[i-1][j-1];
-                dp[i][j] += dp[i-1][j];
+                    dp[i][j] = dp[i-1][j] + dp[i-1][j-1];
+                else
+                    dp[i][j] = dp[i-1][j];
+                //cout<<i<<" "<<j<<" "<<dp[i][j]<<endl;
             }
-        
         return dp[m][n];
     }
 };

Dynamic_Programming/1494.Parallel-Courses-II/1494.Parallel-Courses-II_v2.cpp

@@ -0,0 +1,37 @@
+class Solution {
+public:
+    int minNumberOfSemesters(int n, vector<vector<int>>& dependencies, int k) 
+    {
+        vector<int>dp(1<<n, INT_MAX/2);
+        vector<int>prevState(1<<n, 0);
+        vector<int>prevCourse(n,0);
+
+        for (auto x: dependencies)        
+            prevCourse[x[1]-1] |= 1<<(x[0]-1);        
+                    
+        for (int state = 0; state < (1<<n); state++)
+        {
+            prevState[state] = 0;
+            for (int i=0; i<n; i++)
+            {
+                if ((state>>i) & 1)
+                    prevState[state] |= prevCourse[i];
+            }
+            if (prevState[state]==0 && __builtin_popcount(state)<=k)
+                dp[state] = 1;
+        }
+
+        dp[0] = 0;
+        for (int state = 1; state < (1<<n); state++)        
+        {
+            for (int subset = state; subset > 0; subset = (subset-1)&state)
+            {
+                if (__builtin_popcount(state) - __builtin_popcount(subset) <= k && (prevState[state] & subset) == prevState[state])
+                {
+                    dp[state] = min(dp[state], dp[subset]+1);
+                }
+            }
+        }
+        return dp[(1<<n)-1];
+    }
+};

Dynamic_Programming/1986.Minimum-Number-of-Work-Sessions-to-Finish-the-Tasks/1986.Minimum-Number-of-Work-Sessions-to-Finish-the-Tasks.cpp

@@ -0,0 +1,29 @@
+class Solution {
+public:
+    int minSessions(vector<int>& tasks, int sessionTime) 
+    {        
+        int n = tasks.size();
+        vector<int>dp((1<<n), INT_MAX/2);
+        for (int state=0; state<(1<<n); state++)
+        {
+            int sum = 0;
+            for (int i=0; i<n; i++)
+            {
+                if ((state>>i)&1)
+                    sum+=tasks[i];
+            }
+            if (sum<=sessionTime)
+                dp[state]=1;
+        }
+        
+        for (int state=1; state<(1<<n); state++)
+        {
+            for (int subset=state; subset>0; subset=(subset-1)&state)
+            {
+                dp[state] = min(dp[state], dp[subset]+dp[state-subset]);                                    
+            }
+        }
+        return dp[(1<<n)-1];
+        
+    }
+};

Dynamic_Programming/1986.Minimum-Number-of-Work-Sessions-to-Finish-the-Tasks/Readme.md

@@ -0,0 +1,18 @@
+### 1986.Minimum-Number-of-Work-Sessions-to-Finish-the-Tasks
+
+因为数据规模n<=14，考虑到3^14是4e6数量级，可以判定这是非常套路的“枚举子集”的动态规划问题。
+
+我们用长度为14的二进制数state的每个bit位表示该任务是否被实施，那么dp[state]表示state所代表的任务集合需要最少多少个session。
+
+利用枚举子集的模板：
+```cpp
+  for (int state=1; state<(1<<n); state++)  
+      for (int subset=state; subset>0; subset=(subset-1)&state)
+      {
+          dp[state] = DoSomething(dp[subset]);
+      }  
+```
+dp[state]如果对应着多个session，那么它必然可以“拆分”成两个任务集subset与state-subset，然后对各自所需的session数目进行相加。所以我们需要遍历state的所有subset，找到最优的一种拆分。即```dp[state]=min{dp[subset]+dp[state-subset]}```。注意，上述的枚举子集的框架，所需要的时间复杂度是o(3^n)而不是o(2^n)
+
+初始值：对于一些特定的任务组合state，如果总时间小于sessionTime，那么他们的dp[state]就是1. 其余的dp[state]我们都设置为无穷大。这需要花费2^n的时间预处理遍历所有的组合。。
+

Dynamic_Programming/1987.Number-of-Unique-Good-Subsequences/1987.Number-of-Unique-Good-Subsequences_v1.cpp

@@ -0,0 +1,32 @@
+using LL = long long;
+class Solution {
+    LL M = 1e9+7;
+public:
+    int numberOfUniqueGoodSubsequences(string binary) 
+    {
+        int n = binary.size();
+        string s = "#" + binary;
+        vector<LL>dp(n+1,0);
+        
+        int start = 1;
+        while (start <=n && s[start]=='0')
+            start++;        
+        if (start==n+1) return 1;
+        dp[start] = 1;
+
+        int last0 = 0;
+        int last1 = 0;
+        
+        for (int i=start+1; i<=n; i++)
+        {            
+            int j = (s[i]=='0')? last0:last1;
+            dp[i] = dp[i-1] *2 - (j>=1 ? dp[j-1]:0);    
+            dp[i] = (dp[i] + M) % M;
+
+            if (s[i]=='0') last0 = i;
+            else last1 = i;
+        }    
+        
+        return dp[n] + (binary.find("0")!=-1);
+    }
+};