Codeforces Round #620 (Div. 2) A-F代码 （暂无记录题解）

A. Two Rabbits （手速题）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int main(){
     int t;
     cin>>t;
     while(t--){
         ll x,y,a,b;
         cin>>x>>y>>a>>b;
         ll sum = a+b;
         if((y-x)%sum == ){
             cout<<(y-x)/sum<<endl;
         }
         else{
             cout<<-<<endl;
         }
     }
     return ;
 }

B. Longest Palindrome （模拟 枚举）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 int main(){
     int n,m;
     cin>>n>>m;
     vector<string> v;
     bool vis[n];
     memset(vis,,sizeof(vis));
     for(int i = ;i<n;i++){
         string s;
         cin>>s;
         v.push_back(s);
     }
     bool flag = false;
     string mid = "",ans = "";
     for(int i = ;i<n;i++){
         string t = v[i];
         reverse(t.begin(),t.end());
         if(!flag && t == v[i]) {
             flag = true;
             mid = v[i];
             continue;
         }
         if(flag && t == v[i]) continue;
         for(int j = ;j<n;j++){
             if(v[j] == t && vis[j] == ){
                 ans+=v[i];
                 vis[i] = vis[j] = ;
                 break;
             }
         }
     }
     string t = ans;
     reverse(t.begin(),t.end());
     ans+=mid,ans+=t;
     if(ans.length() == ){
         cout<<;return ;
     }
     cout<<ans.length()<<endl;
     cout<<ans;
     return ;
 }

C. Air Conditioner （模拟 区间覆盖）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxn = ;
 struct node{
     ll t,l,h;
     ll l1,r;
     bool operator < (node &x)const {
         return t<x.t;
     }
 }c[maxn];
 int main(){
     int q;
     cin>>q;
     while(q--){
         ll n,m;
         cin>>n>>m;
         for(int i = ;i<=n;i++){
             cin>>c[i].t>>c[i].l>>c[i].h ;
         }
         sort(c+,c++n);
         c[].r = c[].l1 = m;
         bool flag = true;
         for(int i = ;i<=n;i++){
             ll d = c[i].t - c[i-].t;
             ll R = c[i-].r + d;
             ll L = c[i-].l1 - d;
             if(L>c[i].h || R< c[i].l){
                 flag = false;
     //            cout<<"De"<<i<<endl;
                 break;
             }
             c[i].r = min(R,c[i].h);
             c[i].l1 = max(L,c[i].l);
         }
         if(flag) cout<<"YES"<<endl;
         else cout<<"NO"<<endl;
     }
     return ;
 }

D. Shortest and Longest LIS（贪心 构造）

 #include<bits/stdc++.h>
 using namespace std;
 void solve(){
     int n;
     string s;
     cin>>n;
     cin>>s;
     int Min[n];
     int t = n;
     for(int i = ;i<s.length();i++){
         int len = ,indx = i;
         if(s[i] == '<'){
             while(s[i]=='<'){
                 len++;
                 i++;
             }
         }
         for(int j = i;j>=i-len;j--){
             Min[j] = t,t--;
         }
     }
     if(t) Min[n-] = t;
     t = ;
     int Max[n];
     for(int i = ;i<s.length();i++){
         int len = ,indx = i;
         if(s[i] == '>'){
             while(s[i]=='>'){
                 len++;
                 i++;
             }
         }
         for(int j = i;j>=i-len;j--){
             Max[j] = t,t++;
         }
     }
     if(t == n) Max[n-] = t;
     for(int i = ;i<n;i++) cout<<Min[i]<<" ";
     cout<<endl;
     for(int i = ;i<n;i++) cout<<Max[i]<<" ";
     cout<<endl;
 }
 int main(){
     int t;
     cin>>t;
     while(t--){
         solve();
     }
     return ;
 }

E. 1-Trees and Queries （最近公共祖先）

 #include<bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int maxbit = ;
 const int maxn = 1e5+;
 vector<int> G[maxn];
 int depth[maxn];
 int fa[maxn][maxbit];
 int Log[maxn];
 int N;
 void pre(){
     Log[] = -;
     Log[] = ,Log[] = ;
     for(int i = ;i<maxn;i++) Log[i] = Log[i/] + ;
 }
 void dfs(int cur,int father){//dfs预处理
     depth[cur] = depth[father] + ;//当前结点的深度为父亲结点+1
     fa[cur][] = father;//更新当前结点的父亲结点
     for(int j = ;(<<j)<=N;j++){//倍增更新当前结点的祖先
         fa[cur][j] = fa[fa[cur][j-]][j-];
     }
     for(int i = ;i<G[cur].size() ;i++){
         if(G[cur][i] != father) {//dfs遍历
             dfs(G[cur][i],cur);
         }
     }
 }
 int LCA(int u,int v){
     if(depth[u]<depth[v]) swap(u,v);
     int dist = depth[u] - depth[v];//深度差
     while(depth[u]!=depth[v]){//把较深的结点u倍增到与v高度相等
         u = fa[u][Log[depth[u]-depth[v]]];
     }
     if(u == v) return u;//如果u倍增到v，说明v是u的LCA
     for(int i = Log[depth[u]];i>=;i--){//否则两者同时向上倍增
         if(fa[u][i]!=fa[v][i]){//如果向上倍增的祖先不同，说明是可以继续倍增
             u = fa[u][i];//替换两个结点
             v = fa[v][i];
         }
     }
     return fa[u][];//最终结果为u v向上一层就是LCA
 }
 int main()
 {
     pre();
     cin>>N;
     for(int i = ;i<N;i++){
         int u,v;
         cin>>u>>v;
         G[u].push_back(v),G[v].push_back(u);
     }
     dfs(,);
     int q;cin>>q;
     while(q--){
         int x,y,a,b,k;
         cin>>x>>y>>a>>b>>k;
         int t1 = LCA(a,b),t2 = LCA(a,x),t3 = LCA(a,y),t4 = LCA(b,x),t5  = LCA(b,y);
         int dis = abs(depth[t1]-depth[a])+abs(depth[t1]-depth[b]);
         if(dis% == k% && dis <=k ){
 //            cout<<"De1"<<endl;
             cout<<"YES"<<endl;
             continue;
         }
         int dis1 = abs(depth[t2]-depth[a])+abs(depth[t2]-depth[x]);
         int dis2 = abs(depth[t5]-depth[b])+abs(depth[t5]-depth[y]);
         if( (dis1+dis2+)% == k%  && dis1+dis2+ <= k){
 //            cout<<"de2"<<endl;
             cout<<"YES"<<endl;
             continue;
         }
         dis1 = abs(depth[t3]-depth[a])+abs(depth[t3]-depth[y]);
         dis2 = abs(depth[t4]-depth[b])+abs(depth[t4]-depth[x]);
         if((dis1+dis2+)% == k% && dis1+dis2+ <= k){
 //            cout<<"de3"<<endl;
             cout<<"YES"<<endl;
             continue;
         }
         cout<<"NO"<<endl;
     }
     return ;
 }

F2. Animal Observation (hard version) （dp 滑动窗口 线段树区间更新最大值查询）

 #include<bits/stdc++.h>
 using namespace std;
 const int maxn = 4e4+;
 int dp[][maxn];
 int val[][maxn];
 int sum[][maxn];
 int n,m,k;
 struct node{
     int l,r;
     int Max,lz;
 }seg_t[maxn*];
 void build(int l,int r,int p){
     seg_t[p].l = l,seg_t[p].r = r;
     if(l == r) {
         seg_t[p].Max = ;return ;
     }
     int mid = (l+r)>>;
     build(l,mid,p*);
     build(mid+,r,p*+);
     seg_t[p].Max = max(seg_t[p*].Max ,seg_t[p*+].Max );
 }
 void pushdown(int k){
     seg_t[k*].lz +=seg_t[k].lz ;
     seg_t[k*+].lz +=seg_t[k].lz ;
     seg_t[k*].Max +=seg_t[k].lz ;
     seg_t[k*+].Max +=seg_t[k].lz ;
     seg_t[k].lz = ;
 }
 void upd(int L,int R,int p,int v){
     if(seg_t[p].l == L && seg_t[p].r == R){
         seg_t[p].lz +=v;
         seg_t[p].Max +=v;
         return;
     }
     if(seg_t[p].lz ) pushdown(p);
     int mid = (seg_t[p].l + seg_t[p].r )>>;
     if(R<=mid) upd(L,R,p*,v);
     else if(L>mid) upd(L,R,p*+,v);
     else{
         upd(L,mid,p*,v);
         upd(mid+,R,p*+,v);
     }
     seg_t[p].Max = max(seg_t[p*].Max ,seg_t[p*+].Max );
 }
 int query(int p,int L,int R){
     if(seg_t[p].l == L && seg_t[p].r == R) return seg_t[p].Max ;
     if(seg_t[p].lz ) pushdown(p);
     int mid = (seg_t[p].l +seg_t[p].r)>>;
     if(R<=mid) return query(p*,L,R);
     else if(L>mid) return query(p*+,L,R);
     else return max(query(p*,L,mid),query(p*+,mid+,R));
 }
 int main(){
     cin>>n>>m>>k;
     for(int i = ;i<=n;i++){
         for(int j = ;j<=m;j++) {
             cin>>val[i][j];
             sum[i][j] = sum[i][j-] + val[i][j];
         }
     }
     for(int i = ;i<=m-k+;i++){
         dp[][i] = sum[][i+k-] - sum[][i-]+sum[][i+k-]-sum[][i-];
     }
     for(int i = ;i<=n;i++){
         memset(seg_t,,sizeof(seg_t));
         build(,*m,);
         for(int j = ;j<=m;j++) upd(j,j,,dp[i-][j]);
         for(int j = ;j<=k;j++) upd(,j,,-val[i][j]);
         for(int j = ;j<=m-k+;j++){
             dp[i][j] = max(dp[i][j],query(,,m)+sum[i][j+k-]-sum[i][j-]+sum[i+][j+k-]-sum[i+][j-]);
             upd(max(,j-k+),j,,val[i][j]);
             upd(j+,j+k,,-val[i][j+k]);
         }
     }
     int ans = ;
     for(int i = ;i<=m;i++) ans = max(ans,dp[n][i]);
     cout<<ans;
     return ;
 }