2017-2018 ACM-ICPC Latin American Regional Programming Contest GYM101889

挺有意思的一套题，题也没有啥毒瘤了，本来是队切的结果种种原因大家全挂机了。

只补了百人题，一共7个，其他的暂时先不补了，，也不会嘛qwq

H：签到

 #include <bits/stdc++.h>
 using namespace std;
 int a[],b[];
 int main(){
     cin>>a[]>>a[]>>a[]>>b[]>>b[]>>b[];
     int ans = ;
     for(int i=;i<=;i++)
         ans+=max(,b[i]-a[i]);
     cout<<ans<<endl;
 }

C：按情况模拟一下，签到。当时队友因为这个题写炸了心态受到了影响然后我又不在((

#include <bits/stdc++.h>
using namespace std;
int k,n;
int a[];
int num[];
vector<int> vis[];
int main(){
    ios::sync_with_stdio(false);
    cin>>k>>n;
    int cnt = ;
    int tmp = ;//那一个超出k的数
    for(int i=;i<=n;i++){
        cin>>a[i];
        if(a[i]>k){
            cnt++;
            tmp = a[i];
        } else{
            num[a[i]]++;
        }
    }
    for(int i=;i<=k;i++){
        vis[num[i]].push_back(i);
    }
    if(cnt>=){
        cout<<"*"<<endl;
    } else if(cnt==){
        if((n-)%k==&&vis[(n-)/k].size()==k){
            cout<<-tmp<<endl;
        } else if(n%k==&&vis[n/k-].size()==&&vis[n/k].size()==k-){//
            cout<<-tmp<<' '<<"+"<<vis[n/k-][]<<endl;
        } else{
            cout<<"*"<<endl;
        }
    } else if(cnt==){
        if((n+)%k==&&vis[(n+)/k].size()==k-&&vis[(n+)/k-].size()==){
            cout<<"+"<<vis[(n+)/k-][]<<endl;
        } else if((n-)%k==&&vis[(n-)/k].size()==k-&&vis[(n-)/k+].size()==){
            cout<<-vis[(n-)/k+][]<<endl;
        } else if(n%k==&&vis[n/k].size()==k-&&vis[n/k+].size()==&&vis[n/k-].size()==){
            cout<<-vis[n/k+][]<<' '<<"+"<<vis[n/k-][]<<endl;
        } else{
            cout<<"*"<<endl;
        }
    }
}

B:签到题

题意：给你目标字符串，你每次可以输入一个字符，输入字符为元音是会在当前串会在输入后反转，求方案数。

样例三很明显了，两边的顺序是固定的，只考虑 中间 那一部分就好。特殊情况判一下

 #include <bits/stdc++.h>
 using namespace std;
 string s;
 bool yuanyin(char a){
     return a=='a'||a=='e'||a=='i'||a=='o'||a=='u';
 }
 int main(){
     ios::sync_with_stdio(false);
     cin>>s;
     int n = s.length();
     int odd = ,even = ;//我不会别的英语了
     for(int i=;i<n;i++){
         if(yuanyin(s[i]))
             even++;
         else
             odd++;
     }
     if(even==n||odd==n){
         cout<<<<endl;
     } else{
         if(!yuanyin(s[])){
             cout<<<<endl;
         } else{
             int tmp = ;
             int i=;
             for(;i<n;i++) {
                 if (yuanyin(s[i]))
                     tmp++;
                 if (tmp == (even + ) / ) {
                     break;
                 }
             }
             int j=i+;
             for(;j<n;j++){
                 if(yuanyin(s[j]))
                     break;
             }
             cout<<j-i<<endl;
         }
     }
 }

E：搜索题，可以利用数位dp的思想，唔数位dp我之前写过一篇博客所以这道题有了思路之后还是挺简单的。

题意：给你一个串和整数n，包含数字和'?','?'可以用任意数替代但不能含前导0，求能被n整除的最小串。

 #include <bits/stdc++.h>
 //为什么取余的运算优先级会比加减法高啊喂。。。
 using namespace std;
 int dp[][];
 string s;int n,l;
 bool flag = false;
 void dfs(int len,int mod,string ans){
     if(flag) return;
     if(len==l){
         if(mod==){
             cout<<ans<<endl;
             flag = true;
         }
         return;
     }
     if(dp[len][mod]) return;
     if(s[len]=='?'){
         for(int i=;i<=;i++){
             if(flag) return;
             if(len==&&i==) continue;
             dfs(len+,(i+(mod*))%n,ans+char(i+''));
         }
     } else{
         if(flag) return;
         dfs(len+,(s[len]-''+mod*)%n,ans+s[len]);
     }
     dp[len][mod]=;
 }
 int main(){
     ios::sync_with_stdio(false);
     cin>>s>>n;
     l=s.length();
     dfs(,,"");
     if(!flag)
         cout<<"*"<<endl;
 }

J：简单数学题，一个字符串，R代表能跳，P代表不能，青蛙可以从任何地方跳，求能跳回原点的步数n的方案数，n需要小于字符串长度。

很明显的gcd，然后判断一下因数就可以。

 #include <bits/stdc++.h>
 using namespace std;
 int gcd(int x,int y){
     return y==?x:gcd(y,x%y);
 }
 string s;
 bool vis[];
 int main(){
     ios::sync_with_stdio(false);
     cin>>s;
     int n = s.length();
     for(int l=;l<n;l++){
         if(n%l==){
             for(int i=;i<l;i++){
                 //如果在>=l的位置有解那么<l的位置一定也有解
                 int pos = i;
                 while (pos<n&&s[pos]=='R'){
                     pos+=l;
                 }
                 if(pos>=n){
                     vis[l]=true;
                 }
             }
         }
     }
     int ans = ;
     for(int i=;i<n;i++){
         if(vis[gcd(i,n)])
             ans++;
     }
     cout<<ans<<endl;
 }

I：次小生成树板子题，题意不说了很简单。很久没写过LCA的题了今天算是复习了一下。

对于给定的那条边，如果本来就在MST里，直接输出，如果不在，减去两点间的最长路径即可，最长路径和LCA的数组一起处理就可以。

 #include <bits/stdc++.h>
 using namespace std;
 const int N = 1e5+;

 map<pair<int,int>,int>mt;

 int fa[N],ran[N];
 int find(int a){
     if(a==fa[a])return a;
     return fa[a]=find(fa[a]);
 }
 void unite(int x,int y){
     x = find(x);
     y = find(y);
     if(x==y) return;
     if(ran[x]<ran[y])fa[x]=y;
     else{
         fa[y]=x;
         if(ran[x]==ran[y])
             ran[x]++;
     }
 }
 bool same(int x,int y){
     return find(x)==find(y);
 }

 vector<int>g[N],val[N];
 int par[N][],maxx[N][],dep[N];
 void dfs(int v,int fa){
     for(int i=;i<g[v].size();i++){
         int u = g[v][i];
         if(u==fa)
             continue;
         dep[u]=dep[v]+;
         par[u][]=v;
         maxx[u][]=val[v][i];
         dfs(u,v);
     }
 }

 int lca_(int x,int y) {
     if (dep[x] > dep[y])
         swap(x, y);
     int tmp1 = mt[make_pair(x, y)];//
     int res = ;
     for (int i = ; i >= ; i--){
         if (dep[y] - dep[x] >= ( << i)) {
             res = max(res,maxx[y][i]);
             y = par[y][i];
         }
     }
     if(x==y)
         return tmp1-res;//多的长度
     //这两个一定在同一高度了
     for(int i=;i>=;i--) {
         if (par[x][i] == par[y][i])
             continue;
         else {
             res = max(res,maxx[x][i]);
             res = max(res,maxx[y][i]);
             x = par[x][i], y = par[y][i];
         }
     }
     res = max(res,maxx[x][]);
     res = max(res,maxx[y][]);
     return tmp1-res;
 }

 struct Edge{
     int from,to,cost;
     Edge(){}
     Edge(int from,int to,int cost):from(from),to(to),cost(cost){}
     bool operator <(const Edge &b)const {
         return cost<b.cost;
     }
 }edg[];

 int n,m,q,a,b,c;

 void init(){
     for(int j=;(<<j)<=n;j++){
         for(int i=;i<=n;i++){
             par[i][j]=par[par[i][j-]][j-];
             maxx[i][j]=max(maxx[i][j-],maxx[par[i][j-]][j-]);
         }
     }
 }

 int main(){
     ios::sync_with_stdio(false);
     for(int i=;i<=;i++){
         fa[i]=i,ran[i]=;
     }
     cin>>n>>m;
     for(int i=;i<=m;i++){
         cin>>a>>b>>c;
         edg[i]=Edge(a,b,c);
         mt[make_pair(a,b)]=c;
         mt[make_pair(b,a)]=c;
     }
     sort(edg+,edg++m);
     int ans = ;
     for(int i=;i<=m;i++){
         int u = edg[i].from,v = edg[i].to,cost = edg[i].cost;
         if(!same(u,v)){
             unite(u,v);
             ans+=cost;
             g[u].push_back(v);
             g[v].push_back(u);
             val[u].push_back(cost);
             val[v].push_back(cost);
         }
     }
     dep[]=;dfs(,);
     init();
     //cout<<ans<<endl;
     cin>>q;
     while (q--){
         cin>>a>>b;
         if(par[a][]==b||par[b][]==a)//本来就在MST里
             cout<<ans<<endl;
         else{
             cout<<ans+lca_(a,b)<<endl;
         }
     }
 }

F：离散化+树状数组。因为我是先学的线段树所以对树状数组不太熟。。。但还是能写下来的(((

思路：两个值都相同的先合并，然后按一维排序，另一维做最大上升子序列权值和。

 #include <bits/stdc++.h>
 using namespace std;
 typedef long long ll;
 const int N = ;
 struct node{
     int a,b;
     ll cost;
 }p[N];
 int n,s[N*];//离散化
 map<pair<int,int>, ll> m;
 vector<int> l[N*];
 ll c[N*];
 int lowbit(int k){ return k&-k;}
 void update(int pos,ll num){
     while (pos<=*N){
         c[pos]=max(c[pos],num);
         pos+=lowbit(pos);
     }
 }
 ll maxx(int pos){
     ll s = ;
     while (pos>){
         s=max(s,c[pos]);
         pos-=lowbit(pos);
     }
     return s;
 }
 int cmp(int a,int b){
     return a>b;
 }
 int main(){
     ios::sync_with_stdio(false);
     cin>>n;
     for(int i=;i<=n;i++){
         cin>>p[i].a>>p[i].b>>p[i].cost;
         s[*i]=p[i].a;
         s[*i-]=p[i].b;
     }
     sort(s+,s+*n+);
     int cnt = unique(s+,s+*n+)-s-;
     for(int i=;i<=n;i++){
         int a = lower_bound(s+,s++cnt,p[i].a)-s;
         int b = lower_bound(s+,s++cnt,p[i].b)-s;
         m[make_pair(a,b)]+=p[i].cost;
         l[a].push_back(b);
     }
     for(int i=;i<=cnt;i++){
         sort(l[i].begin(),l[i].end(),cmp);
         for(int j=;j<l[i].size();j++){
             int b = l[i][j];
             ll tmp = maxx(b-);
             ll all = tmp+m[make_pair(i,b)];
             update(b,all);
         }
     }
     cout<<maxx(cnt)<<endl;
 }