Codeforces1234F. Yet Another Substring Reverse（状压dp）

题目链接：传送门

思路：

由于只能翻转一次子串，就相当于找出两个不连续的子串，把在后面的一个子串翻转过来，和第一个子串拼接。

因为题目仅要求子串中的字符不重复，所以字符的先后顺序无关，翻转的操作就相当于：

选出两个不连续的子串，且他们没有相同的字符，两个子串的长度之和就是答案的一种可能。

题目中反复强调，给出的字符串只有前20个字母[a, t]，考虑到$2^{20} = 10^{6}, 2^{26} = 6*10^{7}$，显然在疯狂暗示：要用状压来做这题。

所以考虑二进制状压字符集合。

---

一个朴素的想法：

令集合X = {'a', 'b',..., 't'}，用|X|表示集合X的大小。

预处理出集合X的所有有效子集（在原字符串中能找得到）。时间复杂度为O(n*|X|) = 2*$10^{6}$。

然后再枚举X的子集A，和集合A在X中的补集B的子集C，若C是有效的（在原字符串中能找到），则|A|+|C|就是答案的一种可能。

这样做的总时间复杂度是O($2^{|X|}* 2^{|X|}$ + n*|X|) = 1e12，显然会TLE。

---

题解：

实际上，我们在枚举集合B的子集C的时候，如果我们能知道集合B的有效子集的大小的最大值max{|C|}，就可以用|A|+max{|C|}以O(1)的时间来更新答案了。时间复杂度可以下降到O($2^{|X|}$)

接下来考虑如何预处理出max{|C|}。

如果用f[mask]表示，以mask二进制表示的集合S的最大有效子集的大小，那么：

如果S是有效的：f[mask] = |S|

否则：f[mask] = max{f[mask^(1<<i)] | 0 < i < |X| && mask&(1<<i) > 0}

这里的处理是$O(|X|*2^{|X|}) = 2*10^{7}$，是可行的。

---

代码：$O(|X|*2^{|X|} + |X|*n)$

 #include <bits/stdc++.h>
 #define fast ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
 #define N 100005
 #define M 100005
 #define INF 0x3f3f3f3f
 #define mk(x) (1<<x)
 #define sz(x) ((int)x.size())
 #define lson(x) (x<<1)
 #define rson(x) (x<<1|1)
 #define mp(a,b) make_pair(a, b)
 #define endl '\n'
 #define lowbit(x) (x&-x)

 using namespace std;
 typedef long long ll;
 typedef double db;

 /** fast read **/
 template <typename T>
 inline void read(T &x) {
     x = ; T fg = ; char ch = getchar();
     while (!isdigit(ch)) {
         if (ch == '-') fg = -;
         ch = getchar();
     }
     while (isdigit(ch)) x = x*+ch-'', ch = getchar();
     x = fg * x;
 }
 template <typename T, typename... Args>
 inline void read(T &x, Args &... args) { read(x), read(args...); }
 #define MAXMASK 20

 int f[mk(MAXMASK)]; // f[mask] = mask's max number of different characters
 int main()
 {
     string s;
     cin >> s; int n = s.size();
     for (int i = ; i < n; i++) {
         int mask = ;
         for (int j = ; j < MAXMASK && i+j < n; j++) {
             int b = s[i+j] - 'a';
             if (mask & mk(b))
                 break;
             mask |= mk(b);
             f[mask] = j+;
         }
     }
     for (int mask = ; mask < mk(MAXMASK); mask++) {
         for (int i = ; i < MAXMASK; i++) if (mask & mk(i)){
             f[mask] = max(f[mask], f[mask ^ mk(i)]);
         }
     }
     int ans = ;
     for (int mask = ; mask < mk(MAXMASK); mask++) {
         int mask1 = (mk(MAXMASK)-) ^ mask;
         ans = max(ans, f[mask] + f[mask1]);
     }
     cout << ans << endl;

     return ;
 }