Codeforces Round #523 (Div. 2) D. TV Shows

传送门

https://www.cnblogs.com/violet-acmer/p/10005351.html

•题意

　　有n个节目，每个节目都有个开始时间和结束时间。

　　定义 x,y 分别为租电视需要的花费和看电视需要的花费（应该是花的电费，哈哈）。

　　假如某电视节目的播放区间是[a,b]，那么看完这个节目需要的总花费为x+(b-a)*y。

　　如果有其他节目的播放区间是[b,c]，那么便不能和[a,b]的节目用同一个电视看。

　　求看完所有电视节目所需要的最少花费。

•题解

　　对于每个节目的播放区间[a,b]，都会有个(b-a)*y 的花费；

　　能省钱的地方在“节目 i 是选择和之前的某个节目 j 共用一个电视，还是选择新租一个电视”；

　　这个只需要寻找一下有没有某个节目 j ，使得节目 i 和 j 共用一个电视要比 i 新租一个电视省钱。

 

　　(1):按节目开始时间从小到大排序，对于相同的开始时间，谁在前谁在后都可以。

　　(2):排序后，从第一个节目开始开始遍历。

　　     假设来到第 i 个节目，查找节目 j，满足节目 j 的结束时间早于节目 i 的开始时间，并且节目 j 的结束时间尽可能晚；

　　　  判断节目 i 是否可以和节目 j 共用一个电视；

•贪心策略的证明（个人理解）

　　假设有①②③④节目，排好序后如下所示：

　　对于排序策略“相同的开始时间，谁在前谁在后都可以”的理解：

　　②③节目开始时间相同，假设 x > y，那么①②③节目的总花费有两种不同的策略，1.(①,②)+③ 和 2.(①,③)+②

　　方案1的总花费为 (x+(9-1)*y) + (x+(11-5)*y) = 2*x+14*y.

　　方案2的总花费为 (x+(11-1)*y) + (x+(9-5)*y) = 2*x+14*y.

　　显然，这两种方案所花费的价钱是相同的。

　　此题的难点在于“如何高效查找节目 j"；

　　一开始本来打算开两个数组，一个数组存储节目的开始时间，一个数组存储节目的结束时间；

　　并用map存储结束时间相同的总节目数，然后，遍历的时候在结束时间的数组中二分查找；

　　实现了一下，又仔细想了想，感觉不行，还是太菜了。。。。。

　　没办法了，只好求助了，翻了翻大神博客，发现，差不多都用到了multiset这个容器，然后，补了补multiset；（tql）

•Code

#include<iostream>
#include<set>
#include<cstdio>
#include<algorithm>
using namespace std;
#define ll __int64
const int MOD=1e9+7;
const int maxn=1e5+10;

int n,x,y;
int res;
struct Node
{
    int l,r;
    Node(int _a=0,int _b=0):l(_a),r(_b){}
}show[maxn];
multiset<int >_set;

bool cmp(Node _a,Node _b)
{
    return _a.l < _b.l;
}
int Solve()
{
    sort(show+1,show+n+1,cmp);
    for(int i=1;i <= n;++i)
    {
        multiset<int >::iterator it;
        it=_set.lower_bound(show[i].l);//二分查找
        //it=lower_bound(_set.begin(),_set.end(),show[i].l);
        if(it == _set.begin())//如果it == _set.begin()，说明 i 之前没有结束时间比其小的电视节目
        {
            res += x;
            res %= MOD;
            _set.insert(show[i].r);
        }
        else
        {
            it--;//当前的it指向的时间是第一个 >= show[i].l，所以，要it--才是最靠近show[i].l的结束时间
            ll cost=1ll*(show[i].l-*it)*y;
            if(cost <= x)
            {
                res += cost;
                _set.erase(it);
            }
            else
                res += x;
            res %= MOD;
            _set.insert(show[i].r);
        }
    }
    return res%MOD;
}
int main()
{
    scanf("%d%d%d",&n,&x,&y);
    for(int i=1;i <= n;++i)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        show[i]=Node(l,r);
        res += 1ll*(r-l)*y%MOD;//记得加 1ll 防止爆int
        res %= MOD;
    }
    printf("%d
",Solve());
}

---

分割线：2019.7.2

•Code

#include<bits/stdc++.h>
using namespace std;
#define ll long long
const int MOD=1e9+7;
const int maxn=1e5+50;

int n;
ll x,y;
struct Data
{
    int l,r;
    bool operator < (const Data &obj) const
    {
        return l < obj.l;
    }
}tv[maxn];
multiset<int >_set;
multiset<int >::iterator it;

ll Solve()
{
    sort(tv+1,tv+n+1);

    ll ans=0;
    for(int i=1;i <= n;++i)///求出每个节目都需要一台电视的总花费
        ans=(ans+x+(tv[i].r-tv[i].l)*y)%MOD;

    _set.clear();
    for(int i=1;i <= n;++i)
    {
        it=_set.lower_bound(tv[i].l);
        if(it != _set.begin())
        {
            --it;
            ll cur=(tv[i].l-*it)*y;
            if(cur <= x)///如果可以共用一台电视
            {
                ans=(ans+cur-x+MOD)%MOD;
                _set.erase(it);
            }
        }
        _set.insert(tv[i].r);
    }
    return ans%MOD;
}
int main()
{
//    freopen("C:\Users\hyacinthLJP\Desktop\in&&out\contest","r",stdin);
    scanf("%d%lld%lld",&n,&x,&y);
    for(int i=1;i <= n;++i)
    {
        int l,r;
        scanf("%d%d",&l,&r);
        tv[i]=Data{l,r};
    }
    printf("%lld
",Solve());

    return 0;
}