Codeforce Round 955（A - F）

最新推荐文章于 2025-12-05 10:55:08 发布

原创最新推荐文章于 2025-12-05 10:55:08 发布 · 704 阅读

4 ·

CC 4.0 BY-SA版权

文章标签：

#算法 #c++ #数学建模 #笔记 #经验分享

A. Preparing for the Olympiad

思路：比对所有A的i 跟 B的i+1的大小如果A[i] > B[i+1] 那么=将他们的差值累加到res 最后输出res

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 110;
int a[N],b[N];


void solve()
{
    int n;
    cin >> n;
    memset(a,0,sizeof a);
    memset(b,0,sizeof b);
    for(int i = 0;i < n;i++) cin >> a[i];
    for(int i = 0;i < n;i++) cin >> b[i];
    int res = 0;
    for(int i = 0;i < n;i++)
    {
        if(a[i] > b[i+1]) res += (a[i] - b[i+1]);
    }

    cout << res << endl;
}

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        solve();
    }
    return 0;
}

B. Journey

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 110;
int a[N],b[N];

void solve()
{
    int n,a,b,c;
    cin >> n >> a >> b >> c;
    int k = a + b + c;
    int day = (n / k) * 3;
    n = n % k;
    if(n)
    {
        int d[3] = {a,b,c};
        while(n > 0)
        {
            for(int i = 0;i < 3 && n > 0;i++)
            {
                n -= d[i];
                day++;
            }
        }
    }
    cout << day << endl;
}

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        solve();
    }
}

C. Preparing for the Exam

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;

const int N = 300010;
int q[N];
bool st[N];

void solve()
{
    memset(st,0,sizeof st);
    int n,m,k;
    cin >> n >> m >> k;
    for(int i = 0;i < m;i++) cin >> q[i];
    for(int i = 0;i < k;i++) 
    {
        int a;
        cin >> a;
        st[a] = true;
    }
    // 分三种情况
    // n 是总题数 k 是会做的题目
    if(n > k + 1) //第一种是每一套题目都做不出来 
    {
        for(int i = 0;i < m;i++) cout << "0";
        cout << endl;
    }
    else if(n == k)//第二种是都会做 全输出1就ok
    {
        for(int i = 0;i < m;i++) cout << "1";
        cout << endl;
    }
    else//第三种是只有一题不会做
    {
        for(int i = 0;i < m;i++)
        {
            if(st[q[i]]) cout << "0";//如果当前这一套题目少的那道 不是我不会做的题 那么输出0
            else cout << "1";
        }
        cout << endl;
    }
}

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        solve();
    }
    return 0;
}

D. Counting Pairs

#include<iostream>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long LL;
const LL N = 200010;

LL a[N];
LL n;
LL findl(LL x)//找到大于等于x的最左边的数的下标
{
    LL l = 0,r = n-1;
    while(l < r)
    {
        LL mid = l + r >> 1;
        if(a[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r;
}

LL findr(LL x)//找到小于等于x的最右边的数的下标
{
    LL l = 0,r = n - 1;
    while(l < r)
    {
        LL mid = l + r + 1>> 1;
        if(a[mid] <= x) l = mid;
        else r = mid - 1;
    }
    return l;
}

void solve()
{
    memset(a,0,sizeof a);//每次初始化一下a数组
    LL x,y;
    cin >> n >> x >> y;
    LL sum = 0;
    for(LL i = 0;i < n;i++)
    {
        cin >> a[i];
        sum += a[i];//求一下总和
    }
    /*
        要求的是 x <= sum - a[i] - a[j] <= y
        那么我们可以枚举每一个a[i] 那么对应的a[j] 就有范围
        sum - a[i] - y <= a[j] <= sum - a[i] - x
        因为我们对元素组排序 所以可以二分数俩个端点
    */


    sort(a,a+n);//可以发现选的数其实跟位置没关系 因为俩个数 总是前后关系
    LL ans = 0;
    for(LL i = 0;i < n;i++)
    {
        LL res = 0;
        LL left = sum - (LL)a[i] - y;//求出左端点大小
        LL right = sum - (LL)a[i] - x;//求出右端点大小
        LL l = findl(left);//找一下大于等于左端点的最右端的位置
        if(a[l] < left) continue;//如果左端点（也就是a[l] 已经为 数组当中最大值）找不到 跳过
        LL r = findr(right);

        if(r <= i) break;//如果右端点下标是小于i的 那么不用再找了 因为右端点值只会越来越小
                        //后面的条件越苛刻 当前条件都满足不了 就不用再继续了

        if(l <= i) l = i + 1;//我们只计算在i右边的区间 这样避免了重复计算
        res = r - l + 1;
        ans += res;//累加一下答案
    }
    
    cout << ans << endl;
}

int main()
{
    LL T;
    cin >> T;
    while(T--)
    {
        solve();
    }
    return 0;
}

E. Best Price

思路:一开始以为二分性质以为在满足差评数小于等于k的时候钱越多越好后面发现对于

样例3：4的时候也是满足差评数小于等于3 但是 1号不买了导致没用3的时候获得的利润多

3 3

1 5 2

3 6 4

换一种思路：差评的价钱是一个个区间我们利用差分维护这些区间记录下满足当前价钱差评数下的人数那么答案就是当前价钱*人数然后取max就是答案（注意会爆int）

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
#define x first
#define y second
using namespace std;
const int N = 200010;
typedef pair<int,int> PII;
typedef long long LL;
PII a[N];
//观察数据范围 有2e9 但实际操作的数也就2e5个
//因此需要进行离散化
vector<int> alls;//离散化数组
//s用来统计差评数
//cnt用来统计满足差评数对应的人数
int s[N * 2],cnt[N * 2];//注意这里要开2倍

int find(int x)//找到离散化之后的下标
{
    //注意这里返回的下标加1 方便做前缀和
    return lower_bound(alls.begin(),alls.end(),x) - alls.begin() + 1;
}

void solve()
{
    alls.clear();
    memset(s,0,sizeof s);
    memset(cnt,0,sizeof cnt);
    int n,k;
    cin >> n >> k;
    for(int i = 1;i <= n;i++) cin >> a[i].x , alls.push_back(a[i].x);
    for(int i = 1;i <= n;i++) cin >> a[i].y , alls.push_back(a[i].y);

    sort(alls.begin(),alls.end());
    alls.erase(unique(alls.begin(),alls.end()),alls.end());

    for(int i = 1;i <= n;i++)
    {
        int l = find(a[i].x + 1) , r = find(a[i].y);//维护一下差评区间从a[i].x + 1 ~ a[i].y
        s[l] += 1,s[r+1] -=1;//用差分维护到时候做一遍前缀和
        cnt[1] += 1,cnt[r+1] -= 1;
    }

    for(int i = 1;i <= alls.size();i++) s[i] += s[i-1],cnt[i] += cnt[i-1];
    LL ans = 0;
    for(int i = 1;i <= alls.size();i++)
    {
        if(s[i] <= k) ans = max(ans,(LL)alls[i-1] * cnt[i]);//如果当前差评数小于等于k 那么可能是最大解
    }

    cout << ans << endl;

}

int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        solve();
    }
}

F. Joker

思路：将joker位置看作一段区间[l,r] 取的位置为x

1.x < l 那么往开头放是不影响区间的往后放相当于左端点往前移动变成[l + 1,r]

2.x > r 那么往结尾放是不影响区间的往前放相当于右端点往后移动变成[l,r + 1]

3.l < x < r 那么对于子区间 1[l,x-1] 和 2[x+1,r] 就跟上面情况一样了

区间1变成[l,x] 区间2变成[x,r]相当于没有变化然后再左右端点加上区间[1,1] [n,n]

#include<iostream>
#include<algorithm>
#include<cstring>
#include<vector>
using namespace std;

const int N = 200010;
typedef pair<int,int> PII;


void solve()
{
    int n,m,q;
    cin >> n >> m >> q;
    //最多也就三个区间 初始化三个区间
    vector<PII> segs ({{1,-q},{m,m},{n + q + 1,n}});

    while(q--)
    {
        int x;
        cin >> x;
        bool ins = false;//标记一下移动位置是否在区间当中
        for(auto &[l,r] : segs)//没用&的话修改不了值
        {
            //如果在区间左侧 那么区间左端点扩展1
            if(x < l) l = max(l - 1,1);
            //如果在区间右侧 那么区间右端点扩展1
            else if(x > r) r = min(r + 1,n);
            //如果在区间当中
            else
            {
                ins = true;
                if(l == r) l = n + q,r = -q;//如果就一个点 那么 该区间消失 变成俩个端点
            }
        }

        if(ins)
        {
            segs[0] = {1,max(segs[0].second,1)};
            segs[2] = {min(n,segs[2].first),n};
        }
        //进行区间合并 
        int sl = 0,sr = -1,ans = 0;
        for(auto t : segs)
        {
            int l = t.first, r = t.second;
            if(l > r) continue;//如果区间左端点大于右端点表示没用区间
            if(l > sr) //区间左端点大于上一个的右端点 答案直接累加
            {
                ans += max(0,sr - sl + 1);
                sl = l,sr = r;//更新一下上一个的左右端点
            }
            sr = max(sr,r);//如果区间左端点 小于 上一个的右端点 那么 取靠后的右端点计算
        }
        ans += max(0,sr - sl + 1);
        cout << ans << " ";
    }
    cout << endl;

}



int main()
{
    int T;
    cin >> T;
    while(T--)
    {
        solve();
    }
    return 0;
}