题意：
一共有n(<=1e5)个元素，每一个元素都有三个关键字，a，b，c现在将这些元素分给A，B，C，这些元素价值在A手中的体现为，所有元素中最大的a值，在B中则是最大b值，C也是一样的，现在要有一种分法，求A+B+C的最小值。
题解：
首先想到的是n^2的算法，首先将所有元素按照a关键字从小到大，然后在开一个数组按照b关键字排序，然后从小到大枚举a，然后标记，然后从大到小枚举b，记录c的最大值，就可以一直更新答案。
既然知道了n^2的算法，现在想是否可以优化呢？枚举a是必然的，如果从小到大枚举a，无异是在b中删除元素，那么从大到小枚举a的话，就是在b中增加元素，删除是不好处理的，那么现在从大到小枚举a，那么现在的问题是在b中优化了。
b是从小到大排了序的，那么如果要选第i个，那么就需要知道(i + 1) ~ n中c的最大值，那么现在就会发现一个单调性便是在b中，随着b的增大，c的最大值一定是不上升的。
现在考虑新增加一个元素，那么这个元素会对它前面的比他的c小的b的c的最大值造成影响，那么现在就需要知道第一个小于等于这个元素的c值的位置，然后一并更新。
怎么知道那个位置呢？二分啊QAQ。怎么区间更新呢？线段树啊QAQ。
然后现在考虑求得答案，答案的组成是A+B+C，A是通过枚举的，现在的问题是求B+C的最小值，线段树也可以一并维护B+C了，线段树也要维护一个C的最大值。
代码：
#include <cstdio>
#include <iostream>
#include <algorithm>
using namespace std;
const int N = 1e5 + 7;
int disc[N], dcnt, n, ans = 1e9 + 7;
int mi[N << 2], vc[N << 2], lz[N << 2];
struct node {int a, b, c;} ai[N];
#define mid (l + r >> 1)
#define lson o << 1, l, mid
#define rson o << 1 | 1, mid + 1, r
bool cmp (node a, node b) {return a.a < b.a;}
void pushdown (int o, int l, int r)
{
if (!lz[o]) return;
mi[o << 1] = disc[l] + lz[o], vc[o << 1] = lz[o], lz[o << 1] = lz[o];
mi[o << 1 | 1] = disc[mid + 1] + lz[o], vc[o << 1 | 1] = lz[o], lz[o << 1 | 1] = lz[o];
lz[o] = 0;
}
void update (int o, int l, int r, int L, int R, int x)
{
if (l == L && r == R)
{
mi[o] = disc[L] + x;
vc[o] = x;
lz[o] = x;
return;
}
pushdown(o, l, r);
if (R <= mid) update (lson, L, R, x);
else if (L > mid) update (rson, L, R, x);
else update (lson, L, mid, x), update (rson, mid + 1, R, x);
mi[o] = min (mi[o << 1], mi[o << 1 | 1]);
}
int query (int o, int l, int r, int x)
{
if (l == r) return vc[o];
pushdown(o, l, r);
if (x <= mid) return query (lson, x);
else if (x > mid) return query (rson, x);
}
int getpos (int l , int r, int d)
{
while (l < r)
{
if (query(1, 1, dcnt, mid) < d) r = mid;
else l = mid + 1;
}
return l;
}
void build (int o, int l, int r)
{
if (l == r)
{
mi[o] = disc[l];
return;
}
build (lson);
build (rson);
mi[o] = min (mi[o << 1], mi[o << 1 | 1]);
}
int main ()
{
scanf ("%d", &n);
for (int i = 1; i <= n; ++ i)
{
scanf ("%d%d%d", &ai[i].a, &ai[i].b, &ai[i].c);
disc[++dcnt] = ai[i].b;
}
disc[++dcnt] = 0;
sort (ai + 1, ai + 1 + n, cmp);
sort (disc + 1, disc + 1 + dcnt);
dcnt = unique (disc + 1, disc + 1 + dcnt) - disc - 1;
build (1, 1, dcnt);
ans = ai[n].a;
for (int i = n; i >= 1; -- i)
{
int p = lower_bound (disc + 1, disc + 1 + dcnt, ai[i].b) - disc;
int pos = getpos(1, p, ai[i].c);
if (pos <= p - 1) update (1, 1, dcnt, pos, p - 1, ai[i].c);
ans = min (ans, ai[i - 1].a + mi[1]);
}
cout << ans << endl;
return 0;
}
总结：
首先需要想到暴力，然后再优化就理所当然了，还有的就是要发现序列的单调性。