我就不说我很sb的用线段树来维护值。。。。。。
本机自测的时候想了老半天没想出怎么维护点在所有区间被多少区间包含的方法。最后一小时才想出来线段树（果然太弱）
。。
首先想到贪心，答案一定是某个区间的右端点。。。（这个很容易想也容易证，我就不说了。。。。。）
然后按右端点排序
然后我维护了个左端点前缀和，将来枚举每一个右端点的时候所得到的答案就是sum[n]-sum[i]-he+ge*a[i].r
he表示包含右端点的所有区间的左端点之和，ge表示包含这个点的区间个数。（均不包括自己）
。。
然后离散一下端点用线段树就可以维护he和ge了。。。。
。。
噗，为嘛我没想到直接差分就行了。。。。。。。。
我们直接枚举每个端点，然后维护一个左端点的（后缀和，应该这么说对吧。。。。），每遇到一个左端点就剪掉，就是he，ge数就++同理。。。。。
遇到右端点ge就--且更新答案。QAQ
然后就行了。。
#include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
using namespace std;
typedef long long ll;
const int max(const int &a, const int &b) { return a>b?a:b; }
const int min(const int &a, const int &b) { return a<b?a:b; }
#define read(x) scanf("%d", &x)
#define error(x) if(x) { puts("error"); }
#define dbg(x) cout << (#x) << " = " << x << endl
#define rep(i, n) for(int i=0; i<n; ++i)
#define for1(i,a,n) for(int i=(a); i<=(n); ++i)
#define for2(i,a,n) for(int i=(a); i<(n); ++i)
#define for3(i,a,n) for(int i=(a); i>=(n); ++i)
#define for4(i,a,n) for(int i=(a); i>(n); ++i)
#define lc x<<1
#define rc x<<1|1
#define lson l, m, lc
#define rson m+1, r, rc
#define MID (l+r)>>1
const int N=1e5+10;
struct dat { ll l, r; int pl, pr; }a[N];
struct Tre { int s; ll sum; }t[N<<4];
void pushup(int x) { t[x].s=t[lc].s+t[rc].s; t[x].sum=t[lc].sum+t[rc].sum; }
void update(int l, int r, int x, int pos, ll sum, int k) {
if(l==r) {
t[x].s+=k;
t[x].sum+=sum;
return;
}
int m=MID;
if(pos<=m) update(lson, pos, sum, k); else update(rson, pos, sum, k);
pushup(x);
}
int ask1(int l, int r, int x, int L, int R) {
if(L<=l && r<=R) return t[x].s;
int m=MID, ret=0;
if(L<=m) ret+=ask1(lson, L, R); if(m<R) ret+=ask1(rson, L, R);
return ret;
}
ll ask2(int l, int r, int x, int L, int R) {
if(L<=l && r<=R) return t[x].sum;
int m=MID; ll ret=0;
if(L<=m) ret+=ask2(lson, L, R); if(m<R) ret+=ask2(rson, L, R);
return ret;
}
bool cmp(const dat &a, const dat &b) { return a.r<b.r; }
int n, num;
ll sum[N], he, ans, E, ge, b[N<<1];
int main() {
read(n);
for1(i, 1, n) read(a[i].l), read(a[i].r), b[++num]=a[i].l, b[++num]=a[i].r;
sort(a+1, a+1+n, cmp);
sort(b+1, b+1+num);
num=unique(b+1, b+1+num)-b-1;
for1(i, 1, n) a[i].pl=lower_bound(b+1, b+1+num, a[i].l)-b;
for1(i, 1, n) a[i].pr=lower_bound(b+1, b+1+num, a[i].r)-b;
for1(i, 1, n) update(1, num, 1, a[i].pl, a[i].l, 1);
for1(i, 1, n) sum[i]=sum[i-1]+a[i].l;
for1(i, 1, n) {
update(1, num, 1, a[i].pl, -a[i].l, -1);
while(a[i].r==a[i+1].r) {
++i;
update(1, num, 1, a[i].pl, -a[i].l, -1);
}
ge=ask1(1, num, 1, 1, a[i].pr);
he=ask2(1, num, 1, 1, a[i].pr);
ll tp=sum[n]-sum[i]-he+ge*a[i].r+a[i].r;
if(tp>ans) {
ans=tp;
E=a[i].r;
}
}
printf("%lld %lld\n", E, ans);
return 0;
}
背景
“圣主applepi于公元2011年9月创造了Nescafe，它在散发了16次光辉之后与公元2011年11月12日被封印为一颗魂珠，贮藏于Nescafe神塔之中。公元2012年9月，圣主带领四大护法重启了Nescafe，如今已经是Nescafe之魂的第30次传播了。不久，它就要被第二次封印，而变成一座神杯……”applepi思索着Nescafe的历史，准备着第二次封印。
描述
Nescafe由n种元素组成（编号为1~n），第i种元素有一个封印区间[ai,bi]。当封印力度E小于ai时，该元素将获得ai的封印能量；当封印力度E在ai到bi之间时，该元素将获得E的封印能量；而当封印力度E大于bi时，该元素将被破坏从而不能获得任何封印能量。现在圣主applepi想选择恰当的E，使得封印获得的总能量尽可能高。为了封印的最后一击尽量完美，就请你写个程序帮他计算一下吧！
输入格式
第一行一个整数N。
接下来N行每行两个整数ai、bi，第i+1行表示第i种元素的封印区间。
输出格式
两个用空格隔开的整数，第一个数是能够获得最多总能量的封印力度E，第二个数是获得的总能量大小。当存在多个E能够获得最多总能量时，输出最小的E。
测试样例1
输入
2
5 10
20 25
输出
10 30
备注
对于 50% 的数据，1<=N<=1000，1<=ai<=bi<=10000。
对于 100% 的数据，1<=N<=10^5，1<=ai<=bi<=10^9。