Educational Codeforces Round 95 (Rated for Div. 2)

最新推荐文章于 2020-09-19 22:58:04 发布

Fighting_Peter

最新推荐文章于 2020-09-19 22:58:04 发布

阅读量202

点赞数

分类专栏： Codeforces 文章标签： set dp 数学期望

本文链接：https://blog.csdn.net/Fighting_Peter/article/details/108597153

版权

Codeforces 专栏收录该内容

64 篇文章 0 订阅

订阅专栏

昨天本来想打一下，但是今天早上课很早，就没有打，只是看了看前三个题写了个代码，今天中午课结束交了一下都AC了。y1s1 A题第一次写就出来了，但是答案一直不对，最后结果是样例错了-。-

A - Buying Torches

数学题，最终需要stick的数量是 $k y + k$ ，然后直接求答案就行了。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=100010;
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        ll x,y,k;
        cin>>x>>y>>k;
        ll res=k+(1ll*k*y+k-1+x-2)/(x-1);
        cout<<res<<endl;
    }
    return 0;
}

B - Negative Prefixes

对于不固定位置的数，前面越大越好。把不固定位置的数逆序排列，然后插入原数组即可。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<vector>
#include<iostream>
#include<algorithm>
using namespace std;
const int N=100010;
int a[N],n;
bool st[N];
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=1;i<=n;i++) cin>>a[i];
        vector<int> b;
        for(int i=1;i<=n;i++)
        {
            st[i]=0;
            cin>>st[i];
            if(!st[i]) b.push_back(a[i]);
        }
        sort(b.begin(),b.end());
        reverse(b.begin(),b.end());
        for(int i=1,j=0;i<=n;i++)
        {
            if(st[i]) cout<<a[i]<<' ';
            else cout<<b[j++]<<' ';
        }
        cout<<'\n';
    }
    return 0;
}

C - Mortal Kombat Tower

写个dp考虑转移即可。
$f [i] [1 / 2] [0 / 1]$ 表示为考虑前 $i$ 个boss，最后一次kill杀了1/2个boss，现在是轮到谁了（0表示朋友，1表示自己）。
转移就很容易，边界是 $f [0] [1 / 2] [1] = 0$ 由于朋友先手，最开始只能从前面的边界进行转移。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
const int N=200010;
int a[N],n;
int f[N][3][2];
int main()
{
    IO;
    int T=1;
    cin>>T;
    while(T--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            for(int j=1;j<=2;j++)
                for(int k=0;k<=1;k++)   
                    f[i][j][k]=0x3f3f3f3f;
        }
        // f[0][1][1]=f[0][2][1]=0; 全局变量 省略这一步
        f[0][2][0]=f[0][1][0]=0x3f3f3f3f;
        for(int i=1;i<=n;i++)
        {
            f[i][1][0]=min(f[i-1][1][1],f[i-1][2][1])+a[i];
            if(i>=2) f[i][2][0]=min(f[i-2][1][1],f[i-2][2][1])+a[i]+a[i-1];
            f[i][1][1]=min(f[i-1][1][0],f[i-1][2][0]);
            if(i>=2) f[i][2][1]=min(f[i-2][1][0],f[i-2][2][0]);
        }
        int res=0x3f3f3f3f;
        for(int i=1;i<=2;i++)
            for(int j=0;j<=1;j++)
                res=min(res,f[n][i][j]);
        cout<<res<<'\n';
    }
    return 0;
}

D - Trash Problem

贪心：我们只要把所有坐标先排序，然后只找出两个相距最远的两堆垃圾，然后分别向左和向右知道最左端和最右端所移动的步数就是答案。
比如排序后最左端的垃圾左边是 $l$ ，最右端是 $r$ ，这些垃圾中 $u, v$ 相距最远距离是 $d$ ，那么答案就是 $r - l - d$
考虑需要维护的哪些东西?
首先维护垃圾位置并且每次支持排序只需要用set维护即可
齐次需要维护每对垃圾之间的距离，由于可能出现重复序列我们用multiset维护即可。
每次某位置加入一个垃圾或者删除某位置的垃圾就维护一下set和multiset即可。

关于multiset的ms.erase(x)
如果 $x$ 是值，那么它将删除所有 $v a l = x$ ，如果 $x$ 是地址，将删除该地址的数，因此如果想要只删除一个 $v a l = x$ 的数，需要先找到地址，然后按照地址删除。

//O((n+q)logn)
#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<set>
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
typedef pair<ll,ll> pll;
typedef pair<int,int> pii;
const int N=100010;
set<int> s;
multiset<int,greater<int>> ms; 
int n,q;
int a[N];
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n>>q;
        for(int i=1;i<=n;i++) 
        {
            cin>>a[i];
            s.insert(a[i]);
        }
        sort(a+1,a+1+n);
        ms.insert(0);
        for(int i=2;i<=n;i++) ms.insert(a[i]-a[i-1]);
        
        for(int i=0;i<=q;i++)
        {
            if(s.size()<=2) cout<<"0\n";
            else
            {
                auto ed=s.end();
                ed--;
                int l=*s.begin(),r=*ed;
                cout<<r-l-*ms.begin()<<'\n';
            }
            if(i!=q)
            {
                int op,x;
                cin>>op>>x;
                if(op==1)
                {
                    s.insert(x);
                    if(s.size()==1) continue;
                    auto ed=s.end();
                    ed--;
                    auto t=s.find(x);
                    if(t==ed)
                    {
                        t--;
                        ms.insert(x-*t);
                    }
                    else if(t==s.begin())
                    {
                        t++;
                        ms.insert(*t-x);
                    }
                    else
                    {
                        auto t1=t,t2=t;
                        t1--;t2++;
                        ms.insert(*t2-x);
                        ms.insert(x-*t1);
                        auto p=ms.find(*t2-*t1);
                        ms.erase(p);
                    }
                }
                else
                {
                    if(s.size()==1)
                    {
                        s.erase(x);
                        continue;
                    }
                    auto t=s.find(x);
                    auto ed=s.end();
                    ed--;
                    if(t==ed)
                    {
                        t--;
                        auto p=ms.find(x-*t);
                        ms.erase(p);
                    }
                    else if(t==s.begin())
                    {
                        t++;
                        auto p=ms.find(*t-x);
                        ms.erase(p);
                    }
                    else
                    {
                        auto t1=t,t2=t;
                        t1--;t2++;
                        ms.insert(*t2-*t1);
                        auto p1=ms.find(x-*t1);
                        ms.erase(p1);
                        auto p2=ms.find(*t2-x);
                        ms.erase(p2);
                    }
                    s.erase(x);
                }
            }
        }
    }
    return 0;
}

由于自己对STL不是太熟悉，踩了非常多的坑www
一位网友的set总结

剩下的题以后再看吧？可能?

E - Expected Damage

首先我们让 $\ge b$ 的怪物称为大怪物，否则称为小怪物。
不难发现：如果大怪物的个数 $b i g < a$ ，那么所有怪物都不会造成伤害，否则才能造成伤害。
小怪物的位置并不会影响大怪物是否造成伤害，不过大怪物的位置会影响小怪物是否造成伤害，因此我们先考虑大怪物的位置。如果一个大怪物想要造成伤害那么它的前面一定有 $a$ 个大怪物，也就是说他只要不是前面 $a$ 个大怪物（炮灰）他就能造成伤害，共有 $b i g$ 个大怪物那么他不是前 $a$ 个怪物的概率是 $1-\frac{a}{big}$ ，现在把所有大怪物排列好，那么一共有 $b i g + 1$ 个空位可以放置小怪物（由于小怪物直接互不影响，每个位置可以放置随意多个小怪物），小怪物想要造成伤害它的位置一定在前 $a$ 的大怪物后面，易求概率为 $1-\frac{a}{big+1}$ ，由此预处理前缀和，然后快速幂逆元即可得到答案。

#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)
#pragma GCC optimize(2)
#include<iostream>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N=200010,mod=998244353;
int d[N],s[N];
int n,m;
int qmi(int a,int b,int p)
{
    int res=1;
    while(b)
    {
        if(b&1) res=1ll*res*a%p;
        a=1ll*a*a%p;
        b>>=1;
    }
    return res;
}
int main()
{
    IO;
    int T=1;
    //cin>>T;
    while(T--)
    {
        cin>>n>>m;
        for(int i=1;i<=n;i++) cin>>d[i];
        sort(d+1,d+1+n);
        for(int i=1;i<=n;i++) s[i]=(s[i-1]+d[i]%mod)%mod;
        while(m--)
        {
            int a,b;
            cin>>a>>b;
            int pos=lower_bound(d+1,d+1+n,b)-d;
            int small=pos-1,big=n-pos+1;
            int res;
            if(big<a) res=0;
            else
                res=(1ll*(big+1-a)*qmi(big+1,mod-2,mod)%mod*s[small]%mod+1ll*(big-a)*qmi(big,mod-2,mod)%mod*(s[n]-s[small]+mod)%mod)%mod;
            cout<<res<<'\n';
        }
    }
    return 0;
}

要加油哦~

Fighting_Peter

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Educational Codeforces Round 95 (Rated for Div. 2)

昨天本来想打一下，但是今天早上课很早，就没有打，只是看了看前三个题写了个代码，今天中午课结束交了一下都AC了。y1s1 A题第一次写就出来了，但是答案一直不对，最后结果是样例错了-。-A - Buying Torches数学题，最终需要stick的数量是ky+kky+kky+k，然后直接求答案就行了。#define IO ios::sync_with_stdio(false);cin.tie();cout.tie(0)#pragma GCC optimize(2)#include<iostr
复制链接

扫一扫