C - Make a Rectangle

从大到小贪心即可。

# include 
    
     using namespace std;map
     
      m;int main(){    int n, a;    scanf("%d",&n);    while(n--) scanf("%d",&a), m[a]++;    int r=0, c=0;    for(auto i:m)        if(i.second>3) r=c=i.first;        else if(i.second>1) c=r,r=i.first;    printf("%lld\n",(long long)r*c);}
     
    

D - Coloring Dominoes

就是个乘法原理。

# include 
    
     using namespace std;#define P 1000000007int n;char s1[100], s2[100];int main(){    scanf("%d%s%s",&n,s1,s2);    long long ans=s1[0]==s2[0]?3:6;    for(int i=1; i
    

E - Don't Be a Subsequence

首先考虑如何求答案串的最小长度。

显然是可以dp的。

首先考虑长度为1的答案，显然标记一下哪些字母没出现过即可。

否则令\(dp[i]\)表示\(suffix(i)\)的以\(s[i]\)为开头的答案串的最小长度，容易得到\(dp[i]=min(dp[j]+1)\)，其中\(j>i\)并且\(s[j]\)是\(suffix(i)\)里所有同样字符的最左端。

对于每个\(i\)，这样的j最多只有26个，可以通过一次\(O(26\times len)\)预处理出来。

如果求出了答案串的最小长度，如何确定答案串的最小字典序呢？

考虑dp转移的过程，每次用字典序靠前的字符来进行转移就行了。

记录一下路径，倒序输出即可。

时间复杂度\(O(26\times len)\)。

# include 
    
     using namespace std;const int N=200005;int vis[26];char s[N];struct Node{int len, id, c;}dp[N], ans;int main (){    scanf("%s",s+1);    int len=strlen(s+1);    for (int i=len; i>=1; --i) {        dp[i].len=dp[vis[0]].len+1; dp[i].id=vis[0]; dp[i].c=0;        for (int j=1; j<=25; ++j) if (dp[i].len>dp[vis[j]].len+1) dp[i].len=dp[vis[j]].len+1, dp[i].id=vis[j], dp[i].c=j;        vis[s[i]-'a']=i;    }    for (int i=0; i<=25; ++i) if (!vis[i]) {printf("%c\n",i+'a'); return 0;}    ans.len=dp[vis[0]].len; ans.id=vis[0]; ans.c=0;    for (int i=1; i<=25; ++i) if (ans.len>dp[vis[i]].len) ans.len=dp[vis[i]].len, ans.id=vis[i], ans.c=i;    while (ans.id) putchar(ans.c+'a'), ans.c=dp[ans.id].c, ans.id=dp[ans.id].id;    putchar(ans.c+'a');    putchar('\n');    return 0;}
    

F - Flip and Rectangles

我们首先考虑一个\(2\times 2\)的方格，如果包含奇数个黑格子的话，我们把它称为\(Bad-Part\)。

显然，对于每一个最后可能出现的黑矩形，其中必然不包含\(Bad-Part\)。

因为对于\(Bad-Part\)，无论怎么操作都无法全部变黑。

假设\(S\)不包含任意\(Bad-Part\)，那么我们可以进行一些操作使得S全部变黑。

如何证明？

考虑S的最上面一行和最左边一行，由于我们必然要把他们变成黑色，所以操作是一定的，而这些操作也一定可以将

整个S变黑。

现在的问题是，找到一个面积最大的\(S\)，使得S不包含任何\(Bad-Part\)。

我们可以把每个\(Bad-Part\)缩到\(2\times 2\)方格中心的那个位置，我们把这样的点称为\(Bad-Point\)。

那么问题就变成了经典的最大全0子矩阵了。

而这个问题有经典的悬线法可以\(O(nm)\)解决。

# include 
    
     using namespace std;const int N=2005;char s[N][N];int n, m, a[N], b[N];int main(){    scanf("%d%d",&n,&m);    int ans=max(n,m);    for(int i=0;i
     
      =a[j]) {                int x=b[--t];                if(t==0) ans=max(ans,(j+1)*a[x]);                else ans=max(ans,(j-b[t-1])*a[x]);            }            b[t++]=j;        }    }    printf("%d\n",ans);    return 0;}