Codeforces Round #620 (Div. 2)

A. Two Rabbits

题意：两只兔子分别在xy，相向而跳，一个一次跳a，另一个一次跳b，问能不能相遇，多久相遇。

思路：直接看(y-x)能否被(a+b)整除即可。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
using namespace std;
int T;
int x,y,a,b; 
int main(){
// freopen("in.txt","r",stdin);
 rd(T);
 while(T--){
  rd(x);rd(y);rd(a);rd(b);
  if((y-x) % (a+b))printf("-1\n");
  else printf("%d\n",(y-x)/(a+b));
 }
 return 0;
}
/**/

B. Longest Palindrome

题意：给n(100)个长度为m(50)的字符串，选择一些组合成一个回文串，输出最长的那个。

思路：因为长度都一样，尽可能多选即可，每次从中选出两个互为回文的串加到最终串的开始和最后，直到选不出来为止，然后再看看能不能选出一个自身为回文串的放到最终串的中间即可。在寻找互为回文串的过程中可以暴力也可以用set优化。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
const int N=105;
const int M=55;
using namespace std;
int n,m;
char s[N][M];
bool tag[N];
int sta[N],top;
int main(){
// freopen("in.txt","r",stdin);
 rd(n);rd(m);
 for(int i=1;i<=n;i++)scanf("%s",s[i]);
 for(int i=1;i<n;i++){
  for(int j=i+1;j<=n;j++){
   bool flg=0;
   for(int k=0;k<m;k++)flg =flg | (s[i][k] != s[j][m-k-1]);
   if(!tag[i] && !tag[j] && !flg)tag[i]=tag[j]=1,sta[++top]=i;
  }
 }
 bool ghb=0;
 for(int i=1;i<=n;i++)
  if(!tag[i]){
   bool flg=0;
   for(int j=0;j<m;j++)flg=flg | (s[i][j] != s[i][m-j-1]);
   if(!tag[i] && !flg){sta[++top]=i;ghb=1;break;}
  }
 printf("%d\n",m*(2*top-ghb));
 for(int i=1;i<=top;i++)printf("%s",s[sta[i]]);
 for(int i=top-ghb;i>=1;i--)
  for(int j=m-1;j>=0;j--)
   printf("%c",s[sta[i]][j]);
 puts("");
 return 0;
}
/**/

C. Air Conditioner

题意：500组数据，初始温度m，初始时间0，每个时间点可以选择温度上调1或者下调1，问能不能保证n(100)个人满意，即使得在t时温度在l和h之间。

思路：维护当前可能的温度区间即可，如果全过程都非空则可以。维护时从上一个人的区间转移到下一个人的区间，只需要通过二者时间差维护出可达到的最高和最低温度(一直升温或者降温)，然后再对当前人所需要的区间取交集即可。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
const int N=105;
using namespace std;
int T,n,m;
int t[N],l[N],h[N];
int main(){
// freopen("in.txt","r",stdin);
 rd(T);
 while(T--){
  rd(n);rd(m);
  for(int i=1;i<=n;i++)rd(t[i]),rd(l[i]),rd(h[i]);
  int now_t=0,now_l=m,now_h=m;
  bool flg=0;
  for(int i=1;i<=n;i++){
   now_l=now_l-(t[i]-now_t);
   now_h=now_h+(t[i]-now_t);
   now_t=t[i];
   if(now_h < l[i]){flg=1;break;}
   if(now_l > h[i]){flg=1;break;}
   now_h=min(now_h,h[i]);
   now_l=max(now_l,l[i]);
  }
  if(!flg)printf("YES\n");
  else printf("NO\n");
 }
 return 0;
}
/**/

D. Shortest and Longest LIS

题意：给n-1(2e5)个'>'和'<'，构造出一个n的排列使得两项之间满足上述关系，并且使得其最长上升子序列最大和最小，输出两个序列。

思路：首先可以看到有一个上界和下界，上界是所有的小于号都能连起来，下界是最长的小于号组。考虑一一构造，对于它的上界，其实应该是小于号数目+1，因为对于l~r这一段小于号，它对应的应该是排列中l~r+1的位置，而r+1这个位置是大于号，我们的最长上升子序列一定不会取r+1这个位置，因为取了它后面的小于号将无法连接上，除非它后面没有小于号了，而这种情况下我么可以让l~r和n这个位置连接起来而不是和r+1这个位置，所以上界就是所有<的位置和n这个位置组成上升子序列，只需要从左到右对这些位置依次填入1,2,3...即可，然后为了满足'>'，我们可以倒着把没填的位置继续接着填入4,5,6...再考虑它的下界，应该是最长的'<'段+1，从后往前枚举'<'段，依次对l~r填入1,2,3...然后的操作和构造上界时相同。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
const int N=2e5+10;
using namespace std;
int T;
int n;
char s[N];
int mx[N],mn[N];
int main(){
// freopen("in.txt","r",stdin);
 rd(T);
 while(T--){
  rd(n);scanf("%s",s);
  memset(mx,0,sizeof(mx));
  memset(mn,0,sizeof(mn));
  int now=0;
  for(int i=0;i<n-1;i++)if(s[i] == '<')mx[i+1]=++now;
  mx[n]=++now;for(int i=n-1;i>=1;i--)if(!mx[i])mx[i]=++now;
  int l=-1,r=-1;now=0;
  for(int i=n-2;i>=0;i--){
   if(s[i] == '<' && r == -1)r=i+1;
   if(s[i] == '<')l=i+1;
   if((s[i] == '>' || i == 0) && l != -1){
    for(int j=l;j<=r;j++)mn[j]=++now;
    l=-1;r=-1;
   }
  }now=n;
  for(int i=1;i<=n;i++)if(!mn[i])mn[i]=now--;
  for(int i=1;i<=n;i++)printf("%d ",mn[i]);puts("");
  for(int i=1;i<=n;i++)printf("%d ",mx[i]);puts("");
 }
 return 0;
}
/**/

反思：先找出显然的上下界，然后证明这个上下界可以达到，然后进行构造。

E. 1-Trees and Queries

题意：n(1e5)个点的树，q(1e5)次询问，"假如xy连接，ab之间存不存在一条长度为k的路径"，需要注意这里的路径可以经过重复的边或是点。

思路：首先，我们可以在一条边上反复横跳，所以如果只要我们可以找出一条长度小于等于k并且奇偶性和k相同的路径便可以找出一条长为k的路径。如果经过xy，我们可以发现ab之间的路径可以分为四部分，xy，xy所形成环的剩下部分，xa，yb。因为可以证明xayb和xbya是奇偶性相同的，不妨认为xayb是比较短的那一个。其他部分只要走了就必须原路返回，奇偶性不变，所以没有意义。我们还可以发现前两部分个数之和必须为奇数，不然没办法走出来。在我们确定了各部分的个数之后，我们可以换一种方式走完这些路径，先走完第一部分再走完第二部分，那么我们还可以发现，每一部分的个数都不能大于1，一旦大于1可以两个一组删除掉而不改变奇偶性，所以其实就是xy，xa，yb三部分，对这条路判断一下是否小于k且奇偶性相同即可。如果不经过xy直接判断最短路即可，所有路径奇偶性也必然是相同的，也是原路返回的原因。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
const int N=1e5+10;
using namespace std;
int n,q;
int fi[N],nxt[N<<1],to[N<<1],tot;
void link(int x,int y){nxt[++tot]=fi[x];fi[x]=tot;to[tot]=y;}
int dep[N],siz[N],son[N],top[N],fa[N];
void dfs1(int x){
 siz[x]=1;
 for(int i=fi[x];i;i=nxt[i]){
  if(dep[to[i]])continue;
  dep[to[i]] = dep[x]+1;fa[to[i]]=x;
  dfs1(to[i]);siz[x]+=siz[to[i]];
  if(siz[to[i]] > siz[son[x]])son[x]=to[i];
 }
}
void dfs2(int x,int y){
 top[x]=y;if(son[x])dfs2(son[x],y);
 for(int i=fi[x];i;i=nxt[i])if(!top[to[i]])dfs2(to[i],to[i]);
}
int get_lc(int x,int y){
 while(top[x] != top[y]){
  if(dep[top[x]] < dep[top[y]])swap(x,y);
  x=fa[top[x]];
 }
 return dep[x] < dep[y] ? x : y;
}
int get_dis(int x,int y){
 return dep[x]+dep[y]-dep[get_lc(x,y)]*2;
}
int main(){
// freopen("in.txt","r",stdin);
 rd(n);
 for(int i=1;i<n;i++){
  int x,y;rd(x);rd(y);
  link(x,y);link(y,x);
 }
 dep[1]=1;dfs1(1);dfs2(1,1);rd(q);
 for(int i=1;i<=q;i++){
  int x,y,a,b,k;
  rd(x);rd(y);rd(a);rd(b);rd(k);
  int dis1=get_dis(a,b);bool flg=0;
  int dis2=min(get_dis(x,a)+get_dis(y,b)+1,get_dis(x,b)+get_dis(y,a)+1);
  if(dis1 <= k && ((dis1&1) == (k&1)))flg=1;
  if(dis2 <= k && ((dis2&1) == (k&1)))flg=1;
  if(flg)printf("YES\n");else printf("NO\n");
 }
 return 0;
}
/**/

反思：大胆猜结论。题解真的想了很久，总觉得官方的不严谨，也可能是我没理解好，但我这个应该是绝对正确得了。考场肯定不要证明，直接猜。需要记住的可能就是树上两点间距离奇偶性不会改变吧。还有一个好的思路是走的哪些边确定之后可以换一种绝对可行的遍历方式，进而通过环的形成而抵消一些操作进而简化问题。

F. Animal Observation

题意：n(50)行m(2e4)列的矩阵，每个点有一个非负数，每行可以选一个长度为k(2e4)的区间，该行和其下面一行(如果有的话)的这个区间被覆盖，多次覆盖不重复计算权值，问权值之和最大是多少。

思路：不妨补上n+1行，全为0，这样更一致，f[i][j]表示第i行覆盖区间左端点为j时的最大值，从f[i]转移到f[i+1]并不容易，但是从f[i-1]转移到f[i]很容易，我们只需要记录f[i-1]前缀最大值，后缀最大值，就可以得到i行和i-1行区间不相交的情况下的最大值，相交的情况可以暴力枚举，这是f1的小数据，f2大数据可以利用线段树优化，具体维护的是f[i-1]对应位置减去重叠部分，我们在枚举j的过程中只需要维护单点修改和区间修改即可，需要注意从前面相交和从后面相交要分开处理，但是只用一颗树就可以维护了。

#include<bits/stdc++.h>
#define LL long long
#define dl double
void rd(int &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
void lrd(LL &x){
 x=0;int f=1;char ch=getchar();
 while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
 while(ch<='9' && ch>='0')x=x*10+ch-'0',ch=getchar();x*=f;
}
const int INF=1e9;
const LL LINF=1e18;
const int N=55;
const int M=2e4+10;
using namespace std;
int n,m,k;
int a[N][M],s[N][M];
int f[N][M];
int mx_l[M],mx_r[M];
int t_mx[M<<2],tag[M<<2];
#define ls (o<<1)
#define rs (o<<1|1)
#define mid (l+r>>1)
void tagdown(int o){
 t_mx[ls]+=tag[o];tag[ls]+=tag[o];
 t_mx[rs]+=tag[o];tag[rs]+=tag[o];
 tag[o]=0;
}
void modify(int o,int l,int r,int x,int y){
 if(l == r)t_mx[o]=y;
 else {
  tagdown(o);
  if(x <= mid)modify(ls,l,mid,x,y);
  else modify(rs,mid+1,r,x,y);
  t_mx[o]=max(t_mx[ls],t_mx[rs]);
 }
}
void add(int o,int l,int r,int L,int R,int x){
 if(l >= L && r <= R)t_mx[o]+=x,tag[o]+=x;
 else {
  tagdown(o);
  if(mid >= L)add(ls,l,mid,L,R,x);
  if(mid <  R)add(rs,mid+1,r,L,R,x);
  t_mx[o]=max(t_mx[ls],t_mx[rs]);
 }
}
int query(int o,int l,int r,int L,int R){
 if(l >= L && r <= R)return t_mx[o];
 else {
  int ans=0;tagdown(o);
  if(mid >= L)ans=max(ans,query(ls,l,mid,L,R));
  if(mid <  R)ans=max(ans,query(rs,mid+1,r,L,R));
  return ans;
 }
}
int main(){
// freopen("in.txt","r",stdin);
 rd(n);rd(m);rd(k);
 for(int i=1;i<=n;i++)
  for(int j=1;j<=m;j++)
   rd(a[i][j]);
 for(int i=1;i<=n+1;i++)
  for(int j=1;j<=m;j++)
   s[i][j]=s[i-1][j]+s[i][j-1]-s[i-1][j-1]+a[i][j];
 for(int i=1;i+k-1<=m;i++)f[1][i]=s[2][i+k-1]-s[2][i-1];
 for(int i=2;i<=n;i++){
  for(int j=1;j<=m;j++)mx_l[j]=max(mx_l[j-1],f[i-1][j]);
  for(int j=m;j>=1;j--)mx_r[j]=max(mx_r[j+1],f[i-1][j]);//懒得卡出真正用得到的范围了 
  for(int j=1;j+k-1<=m;j++){
   int sum=s[i+1][j+k-1]-s[i-1][j+k-1]-s[i+1][j-1]+s[i-1][j-1];
   int sum2=s[i][j+k-1]-s[i-1][j+k-1]-s[i][j-1]+s[i-1][j-1];
   if(j > k)f[i][j]=max(f[i][j],mx_l[j-k]+sum);
   modify(1,1,m,j,f[i-1][j]-sum2);//此处并不是f[i-2][j] 
   if(j-1)add(1,1,m,max(1,j-k),j-1,a[i][j-1]);
   f[i][j]=max(f[i][j],query(1,1,m,max(1,j-k+1),j)+sum);
  }
  for(int j=m-k+1;j>=1;j--){
   int sum=s[i+1][j+k-1]-s[i-1][j+k-1]-s[i+1][j-1]+s[i-1][j-1];
   int sum2=s[i][j+k-1]-s[i-1][j+k-1]-s[i][j-1]+s[i-1][j-1];
   f[i][j]=max(f[i][j],mx_r[j+k]+sum);
   modify(1,1,m,j,f[i-1][j]-sum2);
   add(1,1,m,j+1,j+k-1,a[i][j+k]);
   f[i][j]=max(f[i][j],query(1,1,m,j,j+k-1)+sum);
  }
 }
 int ans=0;for(int i=1;i+k-1<=m;i++)ans=max(ans,f[n][i]);printf("%d\n",ans);
 return 0;
}
/**/

反思：需要注意dp的转移，很多时候都会在i-1转移到i和i转移到i+1之间做选择，其中一个往往比另一个更优，甚至可以用数据结构优化。