E - Snowy Smile HDU - 6638 （线段树维护最大连续子段和）

题意:

链接：https://vjudge.net/contest/319475#problem/E

给你n个点，每个点告诉你坐标还有权值（有正有负），让你画一个矩形把一些点括起来，问你矩形括起来的权值最大是多少，可以让矩阵面积为 0 ，也就是不括。

解题思路：

首先对 x 和 y 轴离散化，枚举一个上边界，然后从上边界开始一行一行的加入线段树中，每加一行就取一个最大，每次更新上边界就需要从新建立一棵线段树，然后用线段树的叶子节点保存每一列的值的加和，然后整体线段树维护最大连续子段和。线段树维护最大连续子段和似乎是一个模板。详细细节可以参考代码。

AC代码：

#include<bits/stdc++.h>
#define up(i, x, y) for(ll i = x; i <= y; i++)
#define down(i, x, y) for(ll i = x; i >= y; i--)
#define bug prllf("*********\n")
#define debug(x) cout<<#x"=["<<x<<"]" <<endl
#define IO ios::sync_with_stdio(false);cin.tie(0);cout.tie(0)
#define lk k<<1
#define rk k<<1|1
typedef long long ll;
typedef unsigned long long ull;
const double eps = 1e-8;
const ll mod = 1e9 + 7;
const ll maxn = 2e3 + 3;
const double pi = acos(-1);
const ll inf = 0x3f3f3f3f;
const ll INF = 0x3f3f3f3f3f3f3f3fLL;
using namespace std;

typedef pair<ll, ll> P;
ll n, ans;
struct node{ll x, y, w;}a[maxn];
ll lix[maxn], liy[maxn];
ll len_x, len_y;
vector<P> vec[maxn];
struct node2
{
    ll m, lm, rm, sum;
}t[maxn << 2];

void push_up(ll k)
{
    t[k].sum = t[lk].sum + t[rk].sum;
    t[k].lm = max( t[lk].sum + t[rk].lm, t[lk].lm );
    t[k].rm = max( t[rk].sum + t[lk].rm, t[rk].rm );
    t[k].m = max({ t[lk].m, t[rk].m, t[lk].rm + t[rk].lm });
}

void update(ll k, ll l, ll r, ll pos, ll val)
{
    if(l == r && l == pos)
    {
        t[k].sum += val;
        t[k].m += val;
        t[k].lm += val;
        t[k].rm += val;
        return ;
    }
    ll mid = (l + r) >> 1;
    if(pos <= mid) update(lk, l, mid, pos, val);
    if(mid + 1 <= pos) update(rk, mid + 1, r, pos, val);
    push_up(k);
}

int main()
{
    ll T; scanf("%lld", &T); while(T--)
    {
        scanf("%lld", &n);
        len_x = 0, len_y = 0;
        for(ll i = 1; i <= n; i++)
        {
            vec[i].clear();
            scanf("%lld %lld %lld", &a[i].x, &a[i].y, &a[i].w);
            lix[++len_x] = a[i].x;
            liy[++len_y] = a[i].y;
        }
        sort(lix + 1, lix + 1 + len_x);
        sort(liy + 1, liy + 1 + len_y);
        len_x = unique(lix + 1, lix + 1 + len_x) - (lix + 1);
        len_y = unique(liy + 1, liy + 1 + len_y) - (liy + 1);
        for(ll i = 1; i <= n; i++)
        {
            a[i].x = lower_bound(lix + 1, lix + 1 + len_x, a[i].x) - lix;
            a[i].y = lower_bound(liy + 1, liy + 1 + len_y, a[i].y) - liy;
            vec[ a[i].y ].push_back( P{ a[i].x, a[i].w } );
        }
        ans = 0;
        for(int i = 1; i <= len_y; i++) // 枚举矩形的上边界
        {
            memset(t, 0, sizeof(t));
            for(ll j = i; j >= 1; j--) // 从上边界开始往下扩展矩形大小
            {
                for(auto tmp : vec[j])
                {
                    update(1, 1, len_x, tmp.first, tmp.second);
                }
                ans = max(ans, t[1].m);
            }
        }
        printf("%lld\n", ans);
    }
}