codeforces round #797 (div.3)

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 
#include 
#include 
#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$变为原字符串的操作数。
做法：排列可以分成多个环，每个环对应一个序列，每次操作会使序列循环变化，比如原来对应的序列是$abcd$，一次操作后就变成$bcda$，对每个环计算最少的使序列变为原序列的操作次数，这些操作次数的最小公倍数即为所求。

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

#include 
#include 
#include 
#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^{{}^{\prime }}$小于$a_k$，则在线段树上二分求实际速度大于等于$b_k^{{}^{\prime }}$的最右一个点，即要修改区间的右端点（左端点是k),然后区间修改，最后查询总区间块数。
做法$2$：由于每次操作至多增加一个块，所以在整个过程中最多出现$2n$个块，即最多合并2$n$个块，于是将块缩点后直接用$set$模拟这个过程即可。

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

#include 
#include 
#include 
#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;
}