Codeforces Global Round 13 C. Pekora and Trampoline（贪心+数据结构）

最新推荐文章于 2024-05-19 10:14:31 发布

madaidao

最新推荐文章于 2024-05-19 10:14:31 发布

阅读量2k

点赞数

分类专栏：贪心并查集数据结构

本文链接：https://blog.csdn.net/madaidao/article/details/114265630

版权

数据结构同时被 3 个专栏收录

28 篇文章 0 订阅

订阅专栏

贪心

20 篇文章 0 订阅

订阅专栏

并查集

1 篇文章 0 订阅

订阅专栏

题目链接：https://codeforces.com/contest/1491/problem/C

题目大意：有 n(1<=n<=5000) 张蹦床从左到右排成一排，每张蹦床有个初始弹性 $s_{_{i}}(1<=s_{_{i}}<=10^{9})$ ，n张蹦床则有 $s_{1},s_{2},.....s_{i}...,s_{n}$ 。

小明可以从任意一张蹦床开始跳，若小明跳上第张蹦床，则跳往下一个蹦床的位置为 i+s[i] ，若 i+s[i]>n 则跳到外面去了。当小明跳过这张蹦床后，蹦床弹性减少1，蹦床弹性最少为1不能低于1。也就是说跳过蹦床后弹性变为 $s_{i}=max(s_{i}-1,1)$ 。

小明每次跳上蹦床后，就会一直跳直到跳出去。求，小明最少多少趟跳上蹦床，可把所有蹦床的弹性变为1。

题解：

个人解法：

由于小明可以任意选择每次跳的起点，首先我们考虑下，该如何选择每次跳的起点，才能让小明跳入蹦床的趟数最少？

答案很显然，由于我们只关心跳的趟数，而每次只能往右跳，所以我们可以每次都贪心的选择最左边的蹦床为起点，这样可以使每趟能经过的蹦床尽量的多。

接下来我们分析下复杂度，每趟遍历的复杂度为 O(n) ，最多有 $10^{9}*n$ 趟，总复杂度为 O(10^9*n^2) ，显然不满足本题的要求。

我们可以观察到，假设蹦床i为第一张非1的蹦床，并且 $i+s_{i}>n$ ，那么我们可以 O(1) 计算出要跳多少次才能不跳出去，我们可以把 O(10^9) 优化到 O(n) ，这样复杂度为 O(n^3) ，依然不满足要求，我们继续优化。

我们可以观察到，每趟跳遍历蹦床的时候，若 $s_{i}==1$ ，这时 $s_{_{i}}$ 不会再变化，我们不需要再遍历这个位置，我们可以直接跳到下一个弹性非1的蹦床上。若每次遍历都是有效的遍历非1的位置，那么总复杂度可以优化为有效遍历次数 O(n^2) 。

当 $s_{i}==1$ 时，如何 O(1) 的求出下一个弹性非1的位置呢？

我们可以借鉴并查集算法的思想（也可以抽象为并查集问题），维护 next[i] 为当 $s_{i}==1$ 时下一个弹性非1蹦床的位置，每次递归查询并且更新 next[i] 的值，查询的均摊复杂度为 O(1) ，查询代码如下。

int getNext(int i)
{
    if(i>n)
        return i;
    if(a[i]!=1)
        return i;
    return nt[i]=getNext(nt[i]);
}

官方解法可做到，请继续往下看！

代码如下：

#include<bits/stdc++.h>

using namespace std;
const int nn =5100;
const int inff = 0x3fffffff;
const double eps = 1e-8;
typedef long long LL;
const double pi = acos(-1.0);
const LL mod = (479 << 21) + 1;
LL n;
LL a[nn];
int nt[nn];
LL ans;
int getNext(int i)
{
    if(i>n)
        return i;
    if(a[i]!=1)
        return i;
    return nt[i]=getNext(nt[i]);
}
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        ans=0;
        for(int i=1;i<=n;i++)
        {
            cin>>a[i];
            if(a[i]==1)
                nt[i]=i+1;
        }
        a[n+1]=2;
        while(true)
        {
            int i=1;
            if(a[1]==1)
            {
                i=getNext(1);
                if(i>n)
                    break;
            }
            if(i+a[i]>n)
            {
                if(i==n)
                {
                    ans+=a[i]-1;
                    a[i]=1;
                    nt[i]=i+1;
                } else {
                    ans+=i+a[i]-n;
                    a[i]=n-i;
                    if(a[i]==1)
                        nt[i]=i+1;
                }
                continue;
            }
            for(;i<=n;)
            {
                if(a[i]==1)
                {
                    i=getNext(i);
                } else {
                    int v=a[i];
                    a[i]--;
                    if(a[i]==1)
                    {
                        nt[i]=i+1;
                    }
                    i+=v;
                }
            }
            ans++;
        }
        cout<<ans<<endl;
    }
    return 0;
}

官服解法：复杂度 O(n)

若我们把第i次起跳的位置记为 $p_{i}$ ，那么数列的所有排列都可以得到相同的结果。

简单证明：我们只考虑两次起跳，我们交换两次起跳的位置可以得到相同的结果，因此相邻的两次起跳位置可以交换，可以推导出上面的结论。

因此，我们可以只考虑数列非递减的情况。由于每次只能往右跳，那么每次起跳的起点，一定是从左边起第一个非1的蹦床。

暴力模拟复杂度为 O(n^3) 。其实，我们可以不暴力模拟跳跃的过程，我们可以把当前这个点跳来了多少次先记录下来，记为。

当起跳位置来到时，若 s[i]-1>c[i] ，则这个点还需要起跳 s[i]-1-c[i] 次。反之则不用起跳。

然后我们用当前点，更新后面位置的 c[i] 值。比如 s[i]=4,c[i]=6 时， i+2,i+3,i+4 会经过1次， i+1 会经过3次。

到这里我们可以 O(n^2) 解决这个问题。

但是我们还可以用数据结构优化，把复杂度优化到 O(n) 。

我们继续观察， i+1 可能会增加多次，我们可以 O(1) 更新，对于区间 i+2 到 i+s[i] ，一定只增加1次。区间累加操作，我们可以用线段树优化到 O(logn) ，但本题我们还有更好的做法。

我们把一个位置通过区间累加获得的部分抽离出来单独计算，我们可以把问题抽象为，有多个区间 $[l_{i},r_{i}]$ ，我们要依次求出点 1,2,3...n 被多少个区间覆盖。

我们可以点1开始，维护一个值，表示当前有多少个区间覆盖。那么当我们进入区间起点 $l_{i}$ 时+1，当我们离开区间终点 $r_{i}$ 时-1。

我们可以维护位置i有多少个区间起点为 L[i] ，那么当我们进入位置时 t+L[i] .

我们可以维护位置i有多少个区间终点为 R[i] ，那么当我们离开位置时 t-R[i] .

这样对于每个位置，我们可以 O(1) 求出这个位置被多少个区间覆盖。

回到本题，我们可以用这个方法 O(1) 求出每个位置通过区间累加获得的结果。

这样复杂度就优化到 O(n) 。

代码如下：

#include<bits/stdc++.h>

using namespace std;
const int nn =5100;
const int inff = 0x3fffffff;
const double eps = 1e-8;
typedef long long LL;
const double pi = acos(-1.0);
const LL mod = (479 << 21) + 1;
int n;
int s[nn];
LL c[nn];
int L[nn];
int R[nn];
int main()
{
    int t;
    cin>>t;
    while(t--)
    {
        cin>>n;
        for(int i=1;i<=n;i++)
        {
            cin>>s[i];
            L[i]=R[i]=0;
            c[i]=0;
        }
        int tem=0;
        LL ans=0;
        for(int i=1;i<=n;i++)
        {
            tem+=L[i];
            c[i]+=tem;
            if(s[i]-1>c[i])
            {
                ans+=s[i]-1-c[i];
                c[i]=s[i]-1;
            }
            int l=i+2;
            int r=min(i+s[i],n);
            if(l<=r)
            {
                L[l]++;
                R[r]++;
            }
            c[i+1]+=c[i]-s[i]+1;
            tem-=R[i];
        }
        cout<<ans<<endl;
    }
    return 0;
}