Gym101911 题解

最新推荐文章于 2020-03-12 10:42:36 发布

mxYlulu

最新推荐文章于 2020-03-12 10:42:36 发布

阅读量504

点赞数

分类专栏： coderforce 文章标签： gym

本文链接：https://blog.csdn.net/mxYlulu/article/details/93419088

版权

coderforce 专栏收录该内容

57 篇文章 1 订阅

订阅专栏

酿酿跄跄终于补完了题，这次其实不是很难。
但是一部分是时间因素，一部分是被卡了一些特例。
总之自己还是太菜了呀 $Q A Q$
比赛链接
$A$
题意：每天有 $m$ 小时，你喝咖啡需要花一小时，你想在 $n$ 个时刻都喝过一次咖啡，老板规定连续喝咖啡的间隔必须是 $d$ 以上，求最少多少天，并输出每个时刻第几天喝。

题解:对于每个时刻，贪心的选刚好大于 $d$ 的最开始的一个，每次都这样选择。
但是还需要支持删除已经选择过的。
所以采用 $m a p$ +二分，把 $m a p$ 当一个链表用，支持删除操作，同时二分查找大于 $d$ 的数。
时间复杂度为 $O (N l o g N)$

代码:

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)

#define inf 0x3f3f3f3f

using namespace std;

int n,m,d;
map<int,vector<int> >M;
int mark[200050];

int main(){
    int x;
    cin>>n>>m>>d;
    FOR(i,1,n)scanf("%d",&x),M[x].push_back(i);
    int now;
    int k;
    for(k=1;;k++){
        now=-d-1;
        auto it=M.lower_bound(now+d+1);
        if(it==M.end())break;
        while(it!=M.end()){
            now=(*it).first;
            mark[M[now].back()]=k;
            M[now].pop_back();
            if(M[now].size()==0)M.erase(it);
            it=M.lower_bound(now+d+1);
        }
    }
    cout<<k-1<<endl;
    FOR(i,1,n)printf("%d ",mark[i]);
}

$B$
题意：有 $n$ 个上升气流带，在这里飞行不会下降，否则会下降 $1 /$ 每格。求出从某个起点能飞的尽可能远的距离。

题解：我们并不知道什么时候会到 $0$ ，同时考虑一下，起点一定是在上升带左侧开始的，也就是每个上升带左侧，经过越多飞得越远。(其实不在左侧也行，只不过可以转换成在左侧）
预处理对于每个左侧，到达第几个下降带会为 $0$ ，方便处理，每个上升带后面我们规定有一个下降带，所以最后一个下降带是 $1 e 9$ 。前缀和即可以完成。
查询在第几个直接二分即可，然后暴力查到底第几个点。

代码：

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n;ll h;
ll start[200050],len[200050],diff[200050];
ll df[200050];

int main(){
    cin>>n>>h;
    FOR(i,1,n){
        ll l,r;
        scanf("%lld%lld",&l,&r);
        start[i]=l,len[i]=r-l;
    }
    FOR(i,1,n-1)diff[i]=start[i+1]-(start[i]+len[i]);
    diff[n]=2e9;
    FOR(i,1,n)df[i]=df[i-1]+diff[i];
    //FOR(i,1,n)cout<<df[i]<<endl;
    ll ans=-1;
    for(int i=1;i<=n;i++){
        int l=i,r=n,tmp;
        while(l<=r){
            int mid=(l+r)>>1;
            if(df[mid]-df[i-1]>=h){
                tmp=mid;
                r=mid-1;
            }
            else l=mid+1;
        }
        ll res=h-(df[tmp-1]-df[i-1]);
        //cout<<i<<" "<<tmp<<" "<<res<<endl;
        res=start[tmp]+len[tmp]+res-start[i];
        ans=max(ans,res);
    }
    cout<<ans<<endl;
}

$C$
题意：每两个 $x$ 可以合成一个 $2 x$ ，给你一个序列，同时你可以每次加一个操作，给序列加上一个 $x$ ，问多少个操作能够让序列最后只有一个数。

题解：暴力 $m a p$ 记录，从最小的加，如果不够，就加上一个操作，然后 $2 x$ 数量增加，一直到最大数乘 $2$ (最后序列的数)
同时记录，如果比最后数小的数还有存在的，则不能实现。
否则输出操作。(需要特判 $n = 1$ ，被卡了好久)

代码：

#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ll long long
#define ull unsigned long long
using namespace std;

int n;
ll a[200050];
map<ll,ll>M;
ll mi=0x3f3f3f3f,mx=-1;

ll slove(ll x){
    ll cnt=0;
    while(true){
        if(M[x]%2==0){
            M[x*2]+=M[x]/2;
            M[x]=0;
        }
        else{
            cnt++;M[x]++;
            M[x*2]+=M[x]/2;
            M[x]=0;
        }
        x*=2;
        if(M[x]==1&&x>=mx*2)return cnt;
    }
}

int main(){
    cin>>n;
    FOR(i,1,n){
        scanf("%lld",&a[i]);
        mi=min(a[i],mi);
        mx=max(a[i],mx);
    }
    for(int i=1;i<=n;i++)M[a[i]]++;
    int ans=slove(mi);
    FOR(i,1,n)if(M[a[i]])ans=0x3f3f3f3f;
    if(n==1)ans=0;
    if(ans==0x3f3f3f3f)puts("-1");
    else cout<<ans<<endl;
}

$D$
题意：给你 $n$ 个数，你要给出不同的组合 $(a, b)$ 使得 $a * b = A [i]$ ，不能重复，但是 $(a, b)$ 和 $(b, a)$ 不同。

题解：首先求这个直接暴力求惹，其实我们可以预处理完所有的乘积，选前几个即可。
或者在线，增加一个标记，标记自己暴力到第几个元素了，同时每次设置一个反向标记，处理到 $(a, b)$ 的时候，可以使用一次反向标记 $(b, a)$ 。
复杂度 $n\sqrt{n}$

代码：

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n;
int cur[10000010],num[10000010];
int A[200050];
pair<int,int>B[200050];

bool slove(){
    FOR(i,1,n){
        if(num[A[i]]){
            num[A[i]]^=1;
            B[i].first=A[i]/cur[A[i]],B[i].second=cur[A[i]];
            continue;
        }
        bool ok=false;
        for(int j=cur[A[i]]+1;j<=(int)sqrt(A[i]);j++){
            if(A[i]%j==0){
                ok=true;
                cur[A[i]]=j;
                if(A[i]/j!=j)num[A[i]]=1;
                B[i].first=j,B[i].second=A[i]/j;
                break;
            }
        }
        if(!ok)return false;
    }
    return true;
}

int main(){
    cin>>n;
    FOR(i,1,n)scanf("%d",&A[i]),cur[A[i]]=0;
    if(slove()){
        puts("YES");
        FOR(i,1,n)printf("%d %d\n",B[i].first,B[i].second);
    }
    else puts("NO");
}

$E$
题意：类似于涂色问题，对区间涂色，但区间的长度取决于该颜色目前的最左和最右，每次只告诉你要涂的颜色，求最后结果。

题解：我们考虑一个特点，当你已经涂完一个颜色了，最后这部分的结果，要么就是还是这个颜色，要么就是被完全覆盖。所以涂完这个颜色之后，需要考虑的只是这个端点两端的颜色。
所以相当于，处理一个颜色，删除这个颜色区间里的数。我们考虑到链表操作，这样删除的操作能保证是 $O (n)$
怎么快速找到最左最右端点呢，用 $s e t$ 存储，每次删除的时候，也将其他颜色的结点删除。相当于最后只留下每个颜色的左右端点。

代码：

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n,m;
int A[300050];
set<int>st[300050];
int lst[300050],rst[300050];
int B[300050],ans[300050];
int vis[300050];

void del(int x){
    rst[lst[x]]=rst[x];
    lst[rst[x]]=lst[x];
}

int main(){
    cin>>n;
    for(int i=1;i<=n;i++){
        scanf("%d",&A[i]);
        st[A[i]].insert(i);
        ans[i]=A[i];
    }
    for(int i=1;i<=n;i++){
        lst[i]=i-1;
        rst[i]=i+1;
    }
    cin>>m;
    for(int i=1;i<=m;i++){
        int x;scanf("%d",&x);B[i]=x;
        if(st[x].size()<2||vis[x])continue;
        int l=*(st[x].begin()),r=*(--st[x].end());
        for(int i=l+1,tmp;i<=r-1;i=tmp){
            tmp=rst[i];
            st[A[i]].erase(i);
            del(i);
        }
        vis[x]=1;
    }
    for(int i=1;i<=m;i++){
        if(st[B[i]].size()==0)continue;
        else if(st[B[i]].size()==1){
            ans[*(st[B[i]].begin())]=B[i];
        }
        else{
            int l=*(st[B[i]].begin()),r=*(--st[B[i]].end());
            for(int j=l;j<=r;j++)ans[j]=B[i];
        }
    }
    for(int i=1;i<=n;i++)printf("%d ",ans[i]);
}

$F$
题意：求出每个在自己之前比自己不幸运值低的人。

题解：容易想到逆序对？类似操作，用树状数组存储对应不幸运值的人数，显然是求树状数组前缀和。不断在线更新即可。

#include<bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;i++)
#define ll long long
#define ull unsigned long long
using namespace std;

int n;
int sum[1000050];
ll C[500005];

int lowbit(int x){//求出二进制数的倒数第一个0
	return (x&(-x));
}

void change(int x,int d){//单点查询往上走
	for(int i=x;i<=100;i+=lowbit(i)){
		C[i]+=(ll)d;
	}
}

ll query(int x){//区间查询前缀和，往左走完所有
	if(x==0)return 0;
	ll ret=0;
	for(int i=x;i;i-=lowbit(i)){
		ret+=C[i];
	}
	return ret;
}

int cal(int x){
    int pre=0,last=0;
    int y=x/1000,z=x%1000;
    while(y){
        pre+=y%10;
        y/=10;
    }
    while(z){
        last+=z%10;
        z/=10;
    }
    //cout<<y<<" "<<z<<endl;
    return abs(pre-last);
}

void init(){
    memset(sum,0,sizeof(sum));
    change(1,1);
    for(int i=1;i<1000000;i++){
        sum[i]=query(cal(i));
        change(cal(i)+1,1);
    }
}

int main(){
    init();
    cin>>n;
    FOR(i,1,n){
        int x;scanf("%d",&x);
        printf("%d\n",sum[x]);
    }
}

$G$
题意：给定 $n$ 个关系，要求构造一棵树使得切掉一条边能够让这个关系的两个点在不同树上，而且都是分别的最大坐标，并且这些边不能够重复。

题解：显然 $n$ 一定是在某个树上的，所以每个关系中一定有 $n$ 。那我们考虑一个多叉树，只有两层，第一层为 $n$ ，第二层为其他节点，那么显然答案是正确的的，但是如何考虑不能重复呢，对应多个相同关系，我们需要加边使得条件仍然成立，加入的点显然是小于这两个节点的，实质上只用考虑小于第二层的即可，所以这样构造即可。
这里还有个小贪心，就是尽可能地取到比自己小的最后一个。用 $s e t$ 自带的二分 $lower\_bound$ 减一位即可实现。

代码：

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n;
int vis[2010];

struct node{
    int u,v;
    friend bool operator < (node a,node b){
        return a.u>b.v;
    }
}A[1010];

vector<int>vec[1010];
set<int>st;

int main(){
    cin>>n;
    bool ok=true;
    FOR(i,1,n-1){
        scanf("%d%d",&A[i].u,&A[i].v);
        if(A[i].u>A[i].v)swap(A[i].u,A[i].v);
        if(A[i].v!=n)ok=false;
        vis[A[i].u]=vis[A[i].v]=1;
    }
    FOR(i,1,n)if(!vis[i])st.insert(i);
    FOR(i,1,n-1){
        if(vec[A[i].u].size()>0){
            auto it=st.lower_bound(A[i].u);
            if(it==st.begin()||st.empty()){
                ok=false;
                break;
            }
            else{
                --it;
                vec[A[i].u].push_back(*it);
                st.erase(it);
            }
        }
        else{
            vec[A[i].u].push_back(A[i].v);
        }
    }
    FOR(i,1,n)vis[i]=0;
    FOR(i,1,n-1)if(!vis[A[i].u]){
        vis[A[i].u]=1;
        vec[A[i].u].push_back(A[i].u);
    }
    if(ok){
        puts("YES");
        FOR(i,1,n-1){
            printf("%d %d\n",vec[A[i].u][vec[A[i].u].size()-2],vec[A[i].u][vec[A[i].u].size()-1]);
            vec[A[i].u].pop_back();
        }
    }
    else puts("NO");
}

$H$
题意：水题。

$I$
题意：水题。

$J$
题意：多少种组合 $\frac{w}{h}=\frac{x}{y}$ , $w≤a\&\&h≤b$

题解：
$w y = h x$
$w=\frac{hx}{y},h=\frac{wy}{x}$
首先 $h$ 取整数，我们只考虑 $\frac{hx}{y}$ 能取到多少个整数，直接取 $g c d$ ，答案就是 $\frac{hgcd(x,y)}{y}$ 。
对于 $w$ 也有答案，反之也有答案 $\frac{wgcd(x,y)}{x}$ 。
这里计算答案的时候没有考虑另一个取值的范围，所以两个答案取最小即可。(总有一个计算会更小。

$K$
题意：分成尽可能多的序列，每个序列中可以重新排序，使得最中间的数 $\geq m$ ，则其实 $m - g o o d$ 序列。偶数情况，取较大的那个。

题解：容易发现，对于每个序列，大于等于 $m$ 的总是比小于的多一个。所以我们可以将其计数。不能贪心的一满足就计数，可能这个位置满足，但后面要满足需要借用前面 $1$ 个多余的。最后答案是多余的个数。
可不可能大于的较少呢，那么答案必定是 $0$ 。
当大于的较多的时候，在哪一部分有多得多的，都可以单独以自己做一个。(所以是正确的。

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n,m;
int l=0,r=0,x;

int main(){
    cin>>n>>m;
    int cnt=0;
    for(int i=1;i<=n;i++){
        scanf("%d",&x);
        if(x>=m)l++;else r++;
    }
    cout<<max(l-r,0)<<endl;
}

$L$
题意：从任意一个点反复折射，到达两条直线上的已有的点尽可能多的。

题解：我们考虑横向，单个步数为奇数，到达上面的点都是奇数，下面的都是偶数，显然步数为 $1$ 的时候只多不少。
如果为偶数，对于步数 $l=2^p*m$ ，奇数个 $2^p$ 到达上面，反之下面，我从下面往上射，显然 $2^p$ 为更佳答案，但是前提是 $m$ 为奇数，也就是 $2^p$ 是对于 $l$ 的最大位。
一旦 $m$ 为偶数，到达上面下面都是偶数倍步长，显然是不符合的(因为不能包括 $l$ 射到的所有点)
所以我们 $l o g$ 考虑。
对于每个步长，从上从下射是不一样的，所以我们要考虑奇数倍和偶数倍对于两种情况的总和。
取最大。
当然这样子我们没有考虑步长为 $0$ 的时候，此时答案为 $2$ 。如果你计算的答案比 $2$ 小了，说明出现了这种情况取最大即可。
我直接枚举的是 $2$ 倍步长。

#include<bits/stdc++.h>
#define FOR(i,l,r) for(int i=l;i<=r;i++)
#define ll long long
#define inf 0x3f3f3f3f

using namespace std;

int n,m;
ll y1,y2;
map<ll,int>mp1,mp2;
ll A[100050],B[100050];

int main(){
    cin>>n>>y1;
    FOR(i,1,n)scanf("%lld",&A[i]);
    cin>>m>>y2;
    FOR(i,1,m)scanf("%lld",&B[i]);
    int ans=-1;
    FOR(i,1,34){
        ll tmp=1ll<<i;
        mp1.clear(),mp2.clear();
        FOR(j,1,n)mp1[A[j]%tmp]++;
        FOR(j,1,m)mp2[B[j]%tmp]++;
        FOR(j,1,n){
            ans=max(ans,mp1[A[j]%tmp]+mp2[(A[j]+tmp/2)%tmp]);
        }
        FOR(j,1,m){
            ans=max(ans,mp2[A[j]%tmp]+mp1[(A[j]+tmp/2)%tmp]);
        }
    }
    cout<<max(ans,2)<<endl;
}

mxYlulu

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Gym101911 题解

酿酿跄跄终于补完了题，这次其实不是很难。但是一部分是时间因素，一部分是被卡了一些特例。总之自己还是太菜了呀QAQQAQQAQ比赛链接AAA题意：每天有mmm小时，你喝咖啡需要花一小时，你想在nnn个时刻都喝过一次咖啡，老板规定连续喝咖啡的间隔必须是ddd以上，求最少多少天，并输出每个时刻第几天喝。题解:对于每个时刻，贪心的选刚好大于ddd的最开始的一个，每次都这样选择。但是还需要支持...
复制链接

扫一扫