Codeforces Round #635 (Div. 1)
A. Linova and Kingdom (CF 1336 A)
题目大意
给定一棵\(n\)个节点（从\(1\)开始）的树，\(1\)号节点为根。每个节点要么是工厂要么是旅游景点（包括根）。给定一个数\(k\)，表示将\(k\)个节点变为工厂，最大化每个工厂到根节点的路径上的旅游景点数量的和。
解题思路
很显然可以贪心，但是我们对于工厂位置的选择很显然从叶子节点开始，但稍加思索下可以发现难以抉择，在状态转移的时候比较复杂。
我们可以反过来，考虑旅游景点的选择。很显然我们从根节点开始考虑。当我们选择一个节点设为旅游景点的时候，最优情况下，这个节点到根节点中的所有点一定不是工厂。
基于这个事实，我们可以很容易算出，一个节点\(a\)设为旅游景点的话，它对答案的贡献即为\(son[a]-deep[a]\)，其中\(son[a]\)表示以\(a\)为根节点的子树的孩子数量（不包括它本身），\(deep[a]\)表示节点\(a\)的深度（从\(0\)开始）。
这两个数组一遍\(DFS\)即可求出，然后排序，前\(n-k\)大的数的和即为答案。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
int s = 0, c = getchar();
x = 0;
while (isspace(c)) c = getchar();
if (c == 45) s = 1, c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (s) x = -x;
}
template <typename T>
void write(T x, char c = ' ') {
int b[40], l = 0;
if (x < 0) putchar(45), x = -x;
while (x > 0) b[l++] = x % 10, x /= 10;
if (!l) putchar(48);
while (l) putchar(b[--l] | 48);
putchar(c);
}
void DFS(int u,int fa,int deep[],int son[],vector<int> edge[]){
for(auto v:edge[u]){
if (v==fa) continue;
deep[v]=deep[u]+1;
++son[u];
DFS(v,u,deep,son,edge);
son[u]+=son[v];
}
}
int main(void) {
int n,k;
read(n);
read(k);
vector<int> edge[n+1];
for(int u,v,i=1;i<n;++i){
read(u);
read(v);
edge[u].push_back(v);
edge[v].push_back(u);
}
int deep[n+1]={0};
int son[n+1]={0};
DFS(1,1,deep,son,edge);
vector<int> val;
for(int i=1;i<=n;++i){
val.push_back(son[i]-deep[i]);
}
sort(val.begin(),val.end(),greater<int>());
LL ans=0;
for(int i=0;i<n-k;++i) ans+=(LL)val[i];
write(ans,'\n');
return 0;
}
B. Xenia and Colorful Gems (CF 1336 B)
题目大意
给定三组数，要求从每组数中选择一个数\(x,y,z\)，使得这三个数的俩俩差的平方和最小。即求\(\min{(x-y)^2+(y-z)^2+(z-x)^2}\)。
解题思路
三个数从小到大排序有左中右三种情况。
那么我们枚举\(a\)组取出来的数是中间的，\(b\)组是最小的，\(c\)组是最大的。
然后枚举\(a\)组里的数\(x\)，找出\(b\)组里第一个小于等于\(x\)的数\(y\)，找出\(c\)组里第一个大于等于\(x\)的数\(z\),计算它们俩俩差的平方和取最小值即可。
其实找\(x\)和\(y\)可以不用\(lower\_bound\)用俩指针扫也行。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
template <typename T>
void read(T &x) {
int s = 0, c = getchar();
x = 0;
while (isspace(c)) c = getchar();
if (c == 45) s = 1, c = getchar();
while (isdigit(c)) x = (x << 3) + (x << 1) + (c ^ 48), c = getchar();
if (s) x = -x;
}
template <typename T>
void write(T x, char c = ' ') {
int b[40], l = 0;
if (x < 0) putchar(45), x = -x;
while (x > 0) b[l++] = x % 10, x /= 10;
if (!l) putchar(48);
while (l) putchar(b[--l] | 48);
putchar(c);
}
LL cal(LL a,LL b,LL c){
return (a-b)*(a-b)+(a-c)*(a-c)+(b-c)*(b-c);
}
void work(vector<LL> num[],int a,int b,int c,LL &ans){
for(auto i:num[a]){
auto l=upper_bound(num[b].begin(),num[b].end(),i);
if (l==num[b].begin()) continue;
--l;
auto r=lower_bound(num[c].begin(),num[c].end(),i);
if (r==num[c].end()) continue;
ans=ans==-1?cal(i,*l,*r):min(ans,cal(i,*l,*r));
}
}
int main(void) {
int t;
read(t);
while(t--){
LL ans=-1;
int cnt[3]={0};
for(int i=0;i<3;++i) read(cnt[i]);
vector<LL> num[3];
for(int i=0;i<3;++i){
for(int u,j=0;j<cnt[i];++j){
read(u);
num[i].push_back((LL)u);
}
sort(num[i].begin(),num[i].end());
}
work(num,0,1,2,ans);
work(num,0,2,1,ans);
work(num,1,0,2,ans);
work(num,1,2,0,ans);
work(num,2,0,1,ans);
work(num,2,1,0,ans);
write(ans,'\n');
}
return 0;
}
C. Kaavi and Magic Spell (CF 1336 C)
题目大意
给定两个字符串\(S、T\)，要求通过以下两个操作来构造一个字符串\(A\)
- 取\(S\)的首字符放到\(A\)的首部
- 取\(S\)的首字符放到\(A\)的尾部
可以进行的操作数小于等于\(n\)，\(n\)为串\(S\)的长度。
如果串\(T\)是串\(A\)的前缀，我们说串\(A\)是具有膜法的。问你有多少种方法去构造一个具有膜法的串\(A\)。答案模\(998244353\)。
解题思路
如果我们从首字母开始考虑构造，当字母放到首部的时候，会对我们判断串\(T\)是否为串\(A\)的前缀有很大影响，还会发现转移具有后效性，我们得换个方向取考虑。
从最后一个字母来考虑的话，由于构造的串\(A\)的长度是已知的，这个字母只能放在当前考虑区间的首部或尾部，然后我们就可以缩小考虑范围继续考虑下一个字母，是同样的子问题。
设\(dp[l][r]\)表示构造串\(A\)的\([l...r)\)(从\(0\)开始)的所有方法中，满足串\(A\)是膜法的方法的数量。
转移就很简单了。
对于当前考虑的字母\(S[pos]\)，如果\(l>m-1\)或者\(S[pos]==T[l]\)(即当前位不会影响判断串\(T\)是否为\(A\)的前缀或者填了是保持串\(T\)是串\(A\)的前缀的必要条件)，则字母\(S[pos]\)可以放在第\(l\)位，此时\(dp[l][r]+=dp[l+1][r]\)。
如果\(r>m\)或者\(S[pos]==T[r-1]\)(即当前位不会影响判断串\(T\)是否为\(A\)的前缀或者填了是保持串\(T\)是串\(A\)的前缀的必要条件)，则字母\(S[pos]\)可以放在第\(r-1\)位，此时\(dp[l][r]+=dp[l][r-1]\)
我们枚举操作数量\(i=m\)～\(n\)（\(m\)为串\(T\)的长度），求得对应的\(dp[0][i]\)求和即是答案。
然而时间复杂度为\(O(n^{3})\)会炸。
因为求一次\(DP\)的时间复杂度为\(O(n^2)\)是已经是它的下限了，我们只能从枚举操作数量去优化。
我们发现，如果当操作数量为\(i\)时，求到了一些能使串\(A\)具有膜法的方法数量，当操作数变为\(i+1\)时，我们把额外的那个字母放到串\(A\)的最后面，以前求到的方法仍然能够使得串\(A\)具有膜法。当然放到前面我们就得重新算了。
那么我们可以直接算\(dp[0][n]\)，在算的时候，我们记录一个数\(cnt\)，表示我们把前\(cnt\)个字母都放到了后面，第\(cnt+1\)个字母放到了前面，这样，由于我们是从最后考虑的字母，这前\(cnt\)个字母显得“可有可无”，它们存不存在不会对我们的判断造成影响，而是会使得答案翻倍（当然\(cnt<n-m\)）。
当我们知道有\(cnt\)个字母放到了后面，而目前考虑的区间的答案已经知道为\(dp[l][r]\)，那么这\(cnt\)个字母的有无（也就是说操作数的减少）就会产生额外的答案为\(dp[l][r]*min(cnt,n-m)\)。（有没有它们，能够产生膜法串\(A\)的方法数都是\(dp[l][r]\)）。
时间复杂度就变为\(O(n^{2})\)。
我傻了，求出\(dp[0][n]\)后\(\sum\limits_{i=m}^{n}dp[0][i]\)就是答案。
代码里的ans就是划线处的体现。
神奇的代码
#include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const LL mo=998244353;
char s[3006],t[3006];
int ls,lt;
LL dp[3006][3006];
LL ans;
LL DP(int pos,int l,int r,int id,int cntt){
if (l==r) {
ans=(ans+min(id,ls-lt))%mo;;
return 1;
}
if (dp[l][r]!=-1) {
ans=(ans+dp[l][r]*min(id,ls-lt))%mo;
return dp[l][r];
}
LL qwq=0;
if (l>lt-1||s[pos]==t[l]) qwq=(qwq+DP(pos-1,l+1,r,id==12345?cntt:id,cntt+1))%mo;
if (r>lt||s[pos]==t[r-1]) qwq=(qwq+DP(pos-1,l,r-1,id,cntt+1))%mo;
return dp[l][r]=qwq;
}
int main(void) {
scanf("%s%s",s,t);
memset(dp,-1,sizeof(dp));
ls=strlen(s);
lt=strlen(t);
ans=(ans+DP(ls-1,0,ls,12345,0))%mo;
LL qwq=0;
for(int i=lt;i<=ls;++i)
qwq=(qwq+dp[0][i])%mo;
printf("%lld\n",qwq);
return 0;
}
\(tourist翻了(\)
