#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int INF=0x3f3f3f3f;
const int N=1e3+5;
struct node
{
int l,r;
}a[N];
vector<int>t;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n,m,p;
cin>>n>>m>>p;
p++;
ll mn=min(m,p);
for(int i=0;i<n;i++)
{
cin>>a[i].l>>a[i].r;
t.pb(a[i].l);
t.pb(a[i].r);
}

sort(t.begin(),t.end());
t.erase(unique(t.begin(),t.end()),t.end());

ll ans=0;
int N=t.size();
for(int i=0;i<N;i++)
{
if(i==0)
{
ll cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i]&&t[i]<=a[j].r)cnt++;
ans+=min(mn,cnt);
}
else
{
ll cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i]&&t[i]<=a[j].r)cnt++;
ans+=min(mn,cnt);
cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i-1]+1&&t[i]-1<=a[j].r)cnt++;
ans+=(ll)min(mn,cnt)*(t[i]-t[i-1]-1);
}
}

cout<<ans<<endl;
return 0;
}

离散化做了一下，一直卡在第8组，最后发现第八组的p可能是2147483647，加1就越界了，卡的我无话可说。最后改成long long 就过了
#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
#define mem(a,b) memset(a,b,sizeof(a))

const int INF=0x3f3f3f3f;
const int N=1e3+5;
struct node
{
int l,r;
}a[N];
vector<int>t;
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
ll n,m,p;
cin>>n>>m>>p;
p++;
ll mn=min(m,p);
for(int i=0;i<n;i++)
{
cin>>a[i].l>>a[i].r;
t.pb(a[i].l);
t.pb(a[i].r);
}

sort(t.begin(),t.end());
t.erase(unique(t.begin(),t.end()),t.end());

ll ans=0;
int N=t.size();
for(int i=0;i<N;i++)
{
if(i==0)
{
ll cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i]&&t[i]<=a[j].r)cnt++;
ans+=min(mn,cnt);
}
else
{
ll cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i]&&t[i]<=a[j].r)cnt++;
ans+=min(mn,cnt);
cnt=0;
for(int j=0;j<n;j++)
if(a[j].l<=t[i-1]+1&&t[i]-1<=a[j].r)cnt++;
ans+=(ll)min(mn,cnt)*(t[i]-t[i-1]-1);
}
}

cout<<ans<<endl;
return 0;
}

水题，直接扫描，完全无需离散化

#include <stdio.h>
#define MIN(a,b) ((a)<(b)?(a):(b))
long long timeline[5000002];
int main(){
long long numPlayer,numComputer,numGame,count=0;
int i,begin,end,delta=0;
scanf("%I64d %I64d %I64d",&numGame,&numComputer,&numPlayer);
numPlayer++;
for(i=0;i<=5000001;i++)
timeline[i]=0;
for(i=0;i<numGame;i++){
scanf("%d %d",&begin,&end);
timeline[begin]++;
timeline[end+1]--;
}
for(i=0;i<=5000001;i++){
delta+=timeline[i];
count+=MIN(delta,numPlayer);
}
printf("%I64d\n",count);
return 0;
}

我以为只有答案会爆int，结果P+1也会。。。

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

唉，刚开始 p 没加上 1，后来

主程序虽然用了 int64 ，可是写函数的时候用longint，第8个点就过不了,

纠结了好久....终于发现了

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 9ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 9ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：18ms

扫描法果然强

不小心把p加了两次导致我WA 3# Wa到无语......

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

好简单的离散化

全大写代码。。

ans 要用 INT64...

简单的离散 还交了那么多遍！唉

这题不离散也能秒杀。。 BS

好题！！

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 9ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：9ms

无语

编译通过...

├ 测试数据 01：答案正确... 0ms

├ 测试数据 02：答案正确... 0ms

├ 测试数据 03：答案正确... 0ms

├ 测试数据 04：答案正确... 0ms

├ 测试数据 05：答案正确... 0ms

├ 测试数据 06：答案正确... 0ms

├ 测试数据 07：答案正确... 0ms

├ 测试数据 08：答案正确... 0ms

├ 测试数据 09：答案正确... 0ms

├ 测试数据 10：答案正确... 0ms

---|---|---|---|---|---|---|---|-

Accepted 有效得分：100 有效耗时：0ms

为什么第三组会。。。。程序输出比正确答案长

用得到INT64吗？

不是最多1000台电脑吗？

那么最多只有1000人玩..

阴人的好题！！！

。。。

答案竟然超过Maxlongint！

害我浪费我40多分钟反复读题。。。

用离散化轻松AC，（只要你用了int64）

不过我觉得这题真的是好题。。。

可以让你对Longint产生怀疑。。。

感谢FDhyc大牛

message from FDhyc

是这样，你肯定想到了读入p以后要inc(p) 因为佳佳自己也算

因为p

vijos太仁慈了，我近似纯枚举都过了……

z:=0;t:=min(m,p+1);

for i:=0 to max do

begin

inc(z,l[i]);dec(z,r[i]);

inc(ans,min(z,t));

end;

ＭＡＸ表示时间最大可达处，Ｌ［Ｉ］表示Ｉ时刻区间左端点数，Ｒ［Ｉ］．．．．右端点数，Ｚ为当前Ｉ时刻有多少游戏正在进行（即可以玩）

一字记之曰：阴。。。。。

在交了16次以后终于过了。。。。。

总结：1、数据要排序。。。否则第3个点过不了

2、请了p个人。。。实际是p+1个人。。。由于p最大是maxlongint。所以p+1用maxlongint存不下。。。。

3、答案超过maxlongint。。。

我是用贪心的~~~~过了8组

不知道你们看不看出我的思路~~~我想我的算法是正确的~~~可还是有问题

——

先把X从小到大排序。。。。

program york;

var n,m,i,j,s,k,t:longint;

x,y,b,a:array[0..1000]of longint;

{a:array[0..1000,0..1000]of longint;}

p:array[0..1000]of boolean;

procedure sort(l,r:longint);

var i,j,x0,y0,t:longint;

begin

i:=l; j:=r;

x0:=x[(i+j)div 2]; y0:=y[(i+j) div 2];

repeat

while (x[i]y0)) do dec(j);

if ij;

if i

很简单的离散化...才几十行

我找错误却花了3个多小时不止 狂汗

其实用马甲交了N次 自己的号还浪费4次...

天呐~~