codeforces round #797 (div.3)

RE自动机

已于 2022-06-09 11:17:18 修改

阅读量359

点赞数

分类专栏： cf round 文章标签：贪心算法算法 c++ 数据结构

于 2022-06-08 23:48:40 首次发布

本文链接：https://blog.csdn.net/weixin_51640076/article/details/125194107

版权

cf round 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

codeforces round #797(div.3)

E.Price Maximization
给定 $n$ 和 $k$ ，将 $n$ (偶数)个数分成 $n / 2$ 组，每组两个数，令 $S_i$ 为第i组的数的和，求 $\sum_{i=1}^{n/2}$ $\lfloor$ $S_i$ / $k$ $\rfloor$ 的最大值。
做法：贪心， $k$ 的范围只有 $1000$ ，将每个 $a_i$ 对k求余，对每种余数贪心去凑k，复杂度 $O(k^2)$ .

#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#define int long long
#define endl "\n"
#define pi acos(-1)
#define db double
#define ldb long double
#define pii pair<int,int>
#define hash 786433.393241
#define inf 0x3f3f3f3f
using namespace std;

int a[200010],b[200010];
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0);
    int t;
    cin>>t;
    while(t--)
    {
        int n,k;
        cin>>n>>k;
        int ans=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            b[a[i]%k]++;
            ans+=a[i]/k;
        }
        for(int i=1;i<k;i++)
        {
            for(int j=k-i;j<k;j++)
            {
                if(b[i]==0)break;
                if(i==j)
                {
                    ans+=b[i]/2;
                    b[i]=b[i]%2;
                    continue;
                }
                if(b[i]<=b[j])
                {
                    ans+=b[i];
                    b[j]-=b[i];
                    b[i]=0;
                    break;
                }
                else
                {
                    ans+=b[j];
                    b[i]-=b[j];
                    b[j]=0;
                }
            }
        }
        for(int i=0;i<=k;i++)
        {
            b[i]=0;
        }
        cout<<ans<<endl;
    }
    return 0;
}

F.Shifting String
给一个排列 $p$ 和字符串 $s$ ，每次操作使 $s_i$ 变成 $s_{p_i}$ ，求最小使 $s$ 变为原字符串的操作数。
做法：排列可以分成多个环，每个环对应一个序列，每次操作会使序列循环变化，比如原来对应的序列是 $a b c d$ ，一次操作后就变成 $b c d a$ ，对每个环计算最少的使序列变为原序列的操作次数，这些操作次数的最小公倍数即为所求。

由于算错复杂度多打了个哈希，复杂度 $O (n)$ 。

#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#define int long long
#define endl "\n"
#define pi acos(-1)
#define db double
#define ldb long double
#define pii pair<int,int>
#define hash 786433.393241
#define inf 0x3f3f3f3f
using namespace std;

int p[200010];
unsigned int h[210];
int b=2333;
unsigned int f[210];
int c(int l,int n)
{
    int len=n-l+1;
    return h[n]==(h[n]-h[l-1]*f[len])*f[n-len]+h[l-1];
}
int v[210];
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0);
    int t;
    f[1]=b;
    for(int i=2;i<=200;i++)
    {
        f[i]=f[i-1]*b;
    }
    cin>>t;
    while(t--)
    {
        int n;
        cin>>n;
        string s;
        cin>>s;
        for(int i=1;i<=n;i++)
        {
            v[i]=0;
            cin>>p[i];
        }
        unsigned int ans=1;
        for(int i=1;i<=n;i++)
        {
            if(v[i])continue;
            int j=i,k=1;
            v[i]=1;
            h[1]=s[j-1];
            while(!v[p[j]])
            {
                j=p[j];
                v[j]=1;
                k++;
                h[k]=h[k-1]*b+s[j-1];
            }
            unsigned int now=k;
            for(int i=2;i<=k;i++)
            {
                if(c(i,k))
                {
                    now=i-1;
                    break;
                }
            }
            ans=ans/__gcd(now,ans)*now;
        }
        cout<<ans<<endl;
    }
    return 0;
}

G.Count the Trains
有 $n$ 个车厢，第 $i$ 个车厢可以达到的速度为 $a_i$ ，同时第 $i$ 个车厢的实际速度必须小于第 $i$ -1个车厢的实际速度。相同实际速度的车厢称为一个块。每次操作可以使第 $k$ 个车厢的可达速度减 $d$ ，求每次操作后的块数。
做法 $1$ ：线段树维护区间块数和区间左右端点实际速度，用tag记录区间最后一次修改的速度。记可达速度为 $a_i$ ,实际速度为 $b_i$ ,每次操作先单点查询 $k$ 点的实际速度 $a_k$ ，如果修改后的 $b_k^{'}$ 小于 $a_k$ ，则在线段树上二分求实际速度大于等于 $b_k^{'}$ 的最右一个点，即要修改区间的右端点（左端点是k),然后区间修改，最后查询总区间块数。
做法 $2$ ：由于每次操作至多增加一个块，所以在整个过程中最多出现 $2 n$ 个块，即最多合并2 $n$ 个块，于是将块缩点后直接用 $s e t$ 模拟这个过程即可。

只写了线段树，做法2会简单许多。

#include <iostream>
#include <bits/stdc++.h>
#include <cstdio>
#define int long long
#define endl "\n"
#define pi acos(-1)
#define db double
#define ldb long double
#define pii pair<int,int>
#define hash 786433.393241
#define inf 0x3f3f3f3f
using namespace std;

struct dd
{
    int l,r,blo,lx,rx,tag;
    dd operator +(const dd&t)const
    {
        dd res;
        res.tag=-1;
        res.l=l;
        res.r=t.r;
        res.lx=lx;
        res.rx=t.rx;
        res.blo=blo+t.blo;
        if(rx==t.lx)res.blo--;
        return res;
    }
};
dd tree[400010];
int a[200010],b[200010];
void build(int p,int l,int r)
{
    tree[p].l=l;
    tree[p].r=r;
    tree[p].tag=-1;
    if(l==r)
    {
        tree[p].lx=a[l];
        tree[p].rx=a[r];
        tree[p].blo=1;
        return;
    }
    int mid = (l+r)>>1;
    build(p<<1,l,mid);
    build(p<<1|1,mid+1,r);
    tree[p]=tree[p<<1]+tree[p<<1|1];
}
void f(int p,int d)
{
    tree[p].lx=tree[p].rx=d;
    tree[p].blo=1;
    tree[p].tag=d;
}
void pd(int p)
{
    f(p<<1,tree[p].tag);
    f(p<<1|1,tree[p].tag);
    tree[p].tag=-1;
}
void up(int p,int l,int r,int d)
{
    if(tree[p].l>r||tree[p].r<l)return;
    if(tree[p].l>=l&&tree[p].r<=r)
    {
        tree[p].lx=tree[p].rx=d;
        tree[p].blo=1;
        tree[p].tag=d;
        return;
    }
    if(tree[p].tag!=-1)pd(p);
    up(p<<1,l,r,d);
    up(p<<1|1,l,r,d);
    tree[p]=tree[p<<1]+tree[p<<1|1];
}
int fr(int p,int d)
{
    if(tree[p].l==tree[p].r)return tree[p].l;
    if(tree[p].tag!=-1)pd(p);
    if(tree[p<<1|1].lx>=d)return fr(p<<1|1,d);
    return fr(p<<1,d);
}
dd gb(int p,int l,int r)
{
    if(tree[p].l>r||tree[p].r<l)return {0,0,0,-5,-10,0};
    if(tree[p].l>=l&&tree[p].r<=r)return tree[p];
    if(tree[p].tag!=-1)pd(p);
    return gb(p<<1,l,r)+gb(p<<1|1,l,r);
}
int ga(int p,int k)
{
    if(tree[p].l==k&&tree[p].r==k)
    {return tree[p].lx;}
    if(tree[p].l<=k&&k<=tree[p].r)
    {
        if(tree[p].tag!=-1)pd(p);
        return max(ga(p<<1,k),ga(p<<1|1,k));
    }
    return -1;
}
int ans[200010];
signed main()
{
    ios::sync_with_stdio(false),cin.tie(0);
    int t;
    cin>>t;
    while(t--)
    {
        int n,m;
        cin>>n>>m;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            b[i]=a[i];
        }
        for(int i=2;i<=n;i++)
        {
            if(a[i]>=a[i-1])a[i]=a[i-1];
        }
        build(1,1,n);
        int k,d;
        for(int i=1;i<=m;i++)
        {
            cin>>k>>d;
            int aa=ga(1,k);
            b[k]-=d;
            if(b[k]<aa)
            {
                int r=fr(1,b[k]);
                up(1,k,r,b[k]);
            }
            ans[i]=gb(1,1,n).blo;
        }
        for(int i=1;i<=m;i++)cout<<ans[i]<<" \n"[i==m];
    }
    return 0;
}