C - Make a Rectangle

从大到小贪心即可。

# include <bits/stdc++.h>

using namespace std;

map<int,int>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 <bits/stdc++.h>

using namespace std;

#define P 1000000007

int 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<n; ++i){

		if(s1[i-1]==s2[i-1]) ans=ans*2%P;

		if(s1[i]!=s2[i]&&s1[i-1]!=s2[i-1]&&s1[i]!=s1[i-1]&&s2[i]!=s2[i-1]) ans=ans*3%P;

	}

	printf("%lld",ans);

}

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 <bits/stdc++.h>

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 <bits/stdc++.h>

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<n;i++) scanf("%s",s[i]);

	for(int i=0;i<n;i++) {

		for(int j=0;j<m-1;j++) {

            if(i&&!(s[i-1][j+1]^s[i][j]^s[i-1][j]^s[i][j+1])) a[j]++;

            else a[j]=1;

		}

		int t=0;

		for(int j=0;j<=m-1;j++) {

			while(t&&a[b[t-1]]>=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;

}