Codeforces Div2 #549

最新推荐文章于 2024-05-31 11:17:58 发布

SigmaQuadrant

最新推荐文章于 2024-05-31 11:17:58 发布

阅读量197

点赞数

分类专栏：比赛题解

本文链接：https://blog.csdn.net/qq_40859782/article/details/88970425

版权

比赛题解专栏收录该内容

218 篇文章 0 订阅

订阅专栏

B-Nirvana

给定一个数n，让你求出1-n当中所有的数里面那个每个数位乘积都最大的那个值。题解给出的做法是贪心：既然是数位乘积最大，就要有尽量多的9，贪心没一位向后面借位，然后后面的数字全部变成9。特判两种情况，就是没有借位或者是第一位是1。然后这里还有一种dp的做法，dp[i][0|1]表示我当前这一位有没有向前面借位。转移就是dp[i][0]=max(dp[i-1][0]* v[i],dp[i-1][1]* (v[i]-1))，dp[i][1]=9*max(dp[i-1][0],dp[i-1][1])，最终的答案就是max(dp[len][0],dp[len-1][1]。
解法一：

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=15;
vector<int> v;
int main() {
    int n,ans=1;
    scanf("%d",&n);
    while(n) {
        v.push_back(n%10);
        n/=10;
    }
    reverse(v.begin(),v.end());
    for(int i=0;i<v.size();i++) ans*=v[i];
    if(v[0]==1) {
        int mul=1;
        for(int i=1;i<v.size();i++) mul*=9;
        ans=max(ans,mul);
    }
    for(int i=0;i<v.size();i++) {
        int mul=1;
        if(v[i]>0) {
            for(int j=0;j<i;j++) mul*=v[j];
            mul*=(v[i]-1);
            for(int j=i+1;j<v.size();j++)
            mul*=9;
        }
        ans=max(ans,mul);
    }
    printf("%d\n",ans);
    return 0;
}

解法二：

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
vector<int> v;
const int N=15;
int dp[N][2];
int main() {
    int n;
    scanf("%d",&n);
    while(n) {
        v.push_back(n%10);
        n/=10;
    }
    dp[0][0]=dp[0][1]=1;
    for(int i=0;i<v.size();i++) {
        dp[i+1][0]=max(dp[i][0]*v[i],dp[i][1]*(v[i]-1));
        dp[i+1][1]=max(dp[i][0]*9,dp[i][1]*9);
    }
    int m=v.size();
    printf("%d\n",max(dp[m][0],dp[m-1][1]));
    return 0;
}

C-Queen

给出一颗树，然后这个树里面有两种颜色的点，有一种颜色不妨称为黑色结点，这样的结点只要满足本身是黑色结点并且同时所有的儿子都是黑色结点的话，就必须要从这个树里面删除掉，删除之后它的所有的子树都会被连接到它的父亲上面。优先选择删除编号小的结点，求这样的一个序列。注意到这样的删除方式其实是唯一的，并且先后顺序并不会产生实际的影响。如果某个点被删除，那么下面结点也一定都是黑色结点。删除了之后并不会影响到它的父亲结点。所以只要dfs一遍，有哪些点是本身是黑色并且儿子结点全部是黑色的就可以了。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=1e5+50;
vector<int> G[N];
vector<int> ans;
int w[N];
int dfs(int u,int fa) {
    bool flag=false;
    for(auto &v:G[u]) {
        if(v==fa) continue;
        flag|=dfs(v,u);
    }
    if(flag==false&&w[u]==1) ans.push_back(u);
    if(w[u]==0) return true;
    else return false;
}
int main() {
    int n,rt;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
        int fa,resp;
        scanf("%d%d",&fa,&resp);
        if(fa==-1) rt=i;
        else {
            G[i].push_back(fa);
            G[fa].push_back(i);
            w[i]=resp;
        }
    }
    dfs(rt,-1);
    sort(ans.begin(),ans.end());
    if(!ans.size()) puts("-1");
    else {
        for(int i=0;i<ans.size();i++)
            printf("%d ",ans[i]);
    }
    return 0;
}

D- The Beatles

题意是说总有有nk个城市，然后每隔k个位置都会有一个饭店，某个人每次都会走l步，但是这个l我们是不知道的，但是会告诉你他在初始位置的时候与最近的城市的距离是a，走过一步以后和最近的城市的距离是b，然后求问他最终经过若干步数之后回到原点。求问他需要的最少步数和最多步数是多少。这个答案显然就是 $\frac{n*k}{gcd(n*k,l)}$ 的最大值和最小值，然后这里l满足的条件其实就是l%k一定是a-b,a+b,-a-b,-a+b这四种情况当中的一种，显然这里超过nk的部分已经没有意义，所以分别枚举上述的四种情况就可以求出最后的答案。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
ll n,k,a,b;
ll gcd(ll x,ll y) { return y==0?x:gcd(y,x%y); }
ll cal(ll x) { while(x<0) x+=k; return x;}
int main() {
    scanf("%lld%lld%lld%lld",&n,&k,&a,&b);
    ll mul=1LL*n*k;
    ll mi=1e12,ma=0;
    for(ll i=0;i<n;i++) {
        ll ans=n*k/gcd(n*k,cal(i*k+a+b));
        mi=min(mi,ans);
        ma=max(ma,ans);
    }
    for(ll i=0;i<n;i++) {
        ll ans=n*k/gcd(n*k,cal(i*k+b-a));
        mi=min(mi,ans);
        ma=max(ma,ans);
    }
    for(ll i=0;i<n;i++) {
        ll ans=n*k/gcd(n*k,cal(i*k+a-b));
        mi=min(mi,ans);
        ma=max(ma,ans);
    }
    for(ll i=1;i<n;i++) {
        ll ans=n*k/gcd(n*k,cal(i*k-a-b));
        mi=min(mi,ans);
        ma=max(ma,ans);
    }
    printf("%lld %lld\n",mi,ma);
    return 0;
}

E- Lynyrd Skynyrd

有两个数组，第一个数组里面有一个1到n的全排列，第二个数组是一个长度为m包含了1到n所有的数字的数组，每次都有一个查询，这个查询需要你判断这个区间是否存在一个给定的全排列的一个循环。首先先预处理每个数字的前面一个数字的位置，问题就转化为对于询问的区间，这个区间里面的是否存在的一个数字经过n-1次左移仍然没有小于左边界，进而也就是求出这个区间里面所有的最大值，最大值是方便用线段树维护的。但是这里左移动n-1次还是会很浪费效率，所以考虑倍增查找第n-1个，这样就能够在O(nlogn）的复杂度里面完成了。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=2e5+50;
int a[N],b[N],last[N],LOG[N];
int f[N][22],g[N][22];
unordered_map<int,int> mp;
int main() {
    int n,m,q;
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=n;i++) {
        scanf("%d",&a[i]);
        mp[a[i]]=i;
    }
    for(int i=1;i<=m;i++) {
        scanf("%d",&b[i]);
        int T=mp[b[i]]-1;
        if(T==0) T=n;
        f[i][0]=last[a[T]];
        last[b[i]]=i;
    }
    for(int i=1;(1<<i)<=n;i++)
        for(int j=1;j<=m;j++)
            f[j][i]=max(f[j][i],f[f[j][i-1]][i-1]);
    for(int i=1;i<=m;i++) {
        int L=n-1,cur=i;
        for(int j=20;j>=0;j--)
            if(L-(1<<j)>=0) L-=(1<<j),cur=f[cur][j];
        g[i][0]=cur;
    }

    for(int i=1;(1<<i)<=m;i++)
        for(int j=1;j+(1<<i)-1<=m;j++)
            g[j][i]=max(g[j][i-1],g[j+(1<<(i-1))][i-1]);

    LOG[0]=-1;
    for(int i=1;i<=m;i++) LOG[i]=LOG[i>>1]+1;
    string ans;
    while(q--) {
        int l,r;
        scanf("%d%d",&l,&r);
        int t=LOG[r-l+1];
        if(max(g[l][t],g[r-(1<<t)+1][t])>=l) ans+='1';
        else ans+='0';
    }
    cout<<ans<<endl;
    return 0;
}

线段树维护最大值：

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=2e5+50;
int a[N],b[N],last[N],LOG[N];
int f[N][22],pos[N],tree[N<<2];
unordered_map<int,int> mp;
void update(int rt) {
    tree[rt]=max(tree[rt<<1],tree[rt<<1|1]);
}
void build(int rt,int l,int r) {
    if(l==r) {
        tree[rt]=pos[l];
        return;
    }
    int mid=(l+r)>>1;
    build(rt<<1,l,mid);
    build(rt<<1|1,mid+1,r);
    update(rt);
}
int query(int rt,int l,int r,int L,int R) {
    if(R<l||L>r) return -1;
    if(L<=l&&r<=R) return tree[rt];
    int mid=(l+r)>>1;
    return max(query(rt<<1,l,mid,L,R),query(rt<<1|1,mid+1,r,L,R));
}
int main() {
    int n,m,q;
    scanf("%d%d%d",&n,&m,&q);
    for(int i=1;i<=n;i++) {
        scanf("%d",&a[i]);
        mp[a[i]]=i;
    }
    for(int i=1;i<=m;i++) {
        scanf("%d",&b[i]);
        int T=mp[b[i]]-1;
        if(T==0) T=n;
        f[i][0]=last[a[T]];
        last[b[i]]=i;
    }
    for(int i=1;(1<<i)<=n;i++)
        for(int j=1;j<=m;j++)
            f[j][i]=max(f[j][i],f[f[j][i-1]][i-1]);
    for(int i=1;i<=m;i++) {
        int L=n-1,cur=i;
        for(int j=20;j>=0;j--)
            if(L-(1<<j)>=0) L-=(1<<j),cur=f[cur][j];
        pos[i]=cur;
    }
    build(1,1,m);
    string ans;
    while(q--) {
        int l,r;
        scanf("%d%d",&l,&r);
        int res=query(1,1,m,l,r);
        if(res>=l) ans+='1';
        else ans+='0';
    }
    cout<<ans<<endl;
    return 0;
}

H-U2

给出平面上一些形式为 $y=x^{2}+bx+c$ 的抛物线，求问有多少个抛物线的内部是不会包含任何点的。这道题一眼看过来很难做，但是如果考虑变换 $y-x^{2}=bx+c$ ，就可以把点 $x,y)置换为(x,y-x^{2})$ ，这样抛物线就全部转化为了直线。然后要求这个直线在所有点的上方，维护一个凸包的上半部分就可以了。最后还要去掉那些平行于y轴的直线。

#include<bits/stdc++.h>
#define first F
#define second S
#define make_pair MP
typedef long long ll;
using namespace std;
const int N=1e5+50;
struct point{ ll x,y; }p[N];
bool cmp(point a,point b) {
    if(a.x<b.x) return true;
    if(a.x==b.x&&a.y<b.y) return true;
    return false;
}
int st[N],top=0;
ll det(point a,point b,point c) { //ab det ac
    return (b.x-a.x)*(c.y-a.y)-(c.x-a.x)*(b.y-a.y);
}
int main() {
    int n;
    scanf("%d",&n);
    for(int i=1;i<=n;i++) {
         scanf("%lld%lld",&p[i].x,&p[i].y);
         p[i].y-=p[i].x*p[i].x;
    }
    sort(p+1,p+n+1,cmp);
    st[++top]=n;
    for(int i=n-1;i>=1;i--) {
        while( top>1&& det(p[st[top-1]],p[st[top]],p[i])<=0 ) top--;
        st[++top]=i;
    }
    int ans=1;
    for(int i=2;i<=top;i++) {
        if(p[st[i]].x!=p[st[i-1]].x) ++ans;
    }
    printf("%d\n",ans-1);
    return 0;
}

SigmaQuadrant

关注

0
点赞
踩
1

收藏

觉得还不错? 一键收藏
0
评论
Codeforces Div2 #549

B-Nirvana给定一个数n，让你求出1-n当中所有的数里面那个每个数位乘积都最大的那个值。题解给出的做法是贪心：既然是数位乘积最大，就要有尽量多的9，贪心没一位向后面借位，然后后面的数字全部变成9。特判两种情况，就是没有借位或者是第一位是1。然后这里还有一种dp的做法，dp[i][0|1]表示我当前这一位有没有向前面借位。转移就是dp[i][0]=max(dp[i-1][0]v[i],dp[...
复制链接

扫一扫

专栏目录