正文
AtCoder Regular Contest 081
提示：扫一扫查出行【扫一扫了解最新限行尾号】
复制提示
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;
}
