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,'
');
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,'
');
}
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])后(sumlimits_{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
",qwq);
return 0;
}
(tourist翻了()