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+;
 const int maxn=1e5+;
 
 int n,x,y;
 int res;
 struct Node
 {
     int l,r;
     Node(int _a=,int _b=):l(_a),r(_b){}
 }show[maxn];
 multiset<int >_set;
 
 bool cmp(Node _a,Node _b)
 {
     return _a.l < _b.l;
 }
 int Solve()
 {
     sort(show+,show+n+,cmp);
     for(int i=;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=;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\n",Solve());
 }

---

分割线：2019.7.2

•Code

 #include<bits/stdc++.h>
 using namespace std;
 #define ll long long
 const int MOD=1e9+;
 const int maxn=1e5+;
 
 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+,tv+n+);
 
     ll ans=;
     for(int i=;i <= n;++i)///求出每个节目都需要一台电视的总花费
         ans=(ans+x+(tv[i].r-tv[i].l)*y)%MOD;
 
     _set.clear();
     for(int i=;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=;i <= n;++i)
     {
         int l,r;
         scanf("%d%d",&l,&r);
         tv[i]=Data{l,r};
     }
     printf("%lld\n",Solve());
 
     return ;
 }