最大矩阵覆盖权值--(静态连续最大子段 (线段树) )-HDU(6638)Snowy Smile

这题是杭电多校2019第六场的题目

题目链接：http://acm.hdu.edu.cn/showproblem.php?pid=6638

题意：给你平面上n个点，每个点都有权值（有负权），让你计算一个矩阵可能的最大覆盖权值和；

思路：用  连续最大子段-线段树  枚举上界，按行一行行更新线段树中的点，每插完一行就更新答案（类似枚举上下界），时间复杂度：O( n^2*log(n) ) ；

#define IOS ios_base::sync_with_stdio(0); cin.tie(0);
#include <cstdio>//sprintf islower isupper
#include <cstdlib>//malloc  exit strcat itoa system("cls")
#include <iostream>//pair
#include <fstream>
#include <bitset>
#include <map>
//#include<unordered_map>    http://acm.hdu.edu.cn/showproblem.php?pid=6638
#include <vector>
#include <stack>
#include <set>
#include <string.h>//strstr substr
#include <string>
#include <time.h>//srand(((unsigned)time(NULL))); Seed n=rand()%10 - 0~9;
#include <cmath>
#include <deque>
#include <queue>//priority_queue<int, vector<int>, greater<int> > q;//less
#include <vector>//emplace_back
//#include <math.h>
//#include <windows.h>//reverse(arr,arr+len);// ~ ! ~ ! floor
#include <algorithm>//sort + unique : sz=unique(b+1,b+n+1)-(b+1);+nth_element(first, nth, last, compare)
using namespace std;//next_permutation(arr+1,arr+1+n);//prev_permutation
#define fo(arr,b,c) for(register int arr=b;arr<=c;++arr)
#define fr(arr,b,c) for(register int arr=b;arr>=c;--arr)
#define mem(arr,b) memset(arr,b,sizeof(arr))
#define pr printf
#define sc scanf
#define ls rt<<1
#define rs rt<<1|1
void swapp(int &arr,int &b);
double fabss(double arr);
int maxx(int arr,int b);
int minn(int arr,int b);
int Del_bit_1(int n);
int lowbit(int n);
int abss(int arr);
//const long long INF=(1LL<<60);
const double E=2.718281828;
const double PI=acos(-1.0);
const int inf=(1<<29);
const double ESP=1e-9;
const int mod=(int)1e9+7;
const int N=(int)2003;

int b[N];
struct node_
{
    int x,y;
    long long v;
    friend bool operator<(node_ a,node_ b)
    {
        if(a.y==b.y)
            return a.x<b.x;
        return a.y>b.y;
    }
}arr[N];
struct vnode
{
    int x;
    long long v;
};
//=================================================离散化;
int LSx(int n)
{
    int m=0;
    for(int i=1;i<=n;++i)
        b[++m]=arr[i].x;
    sort(b+1,b+1+m);
    m=unique(b+1,b+1+m)-b-1;
    for(int i=1;i<=n;++i)
        arr[i].x=lower_bound(b+1,b+1+m,arr[i].x)-b;
    return m;
}
int LSy(int n)
{
    int m=0;
    for(int i=1;i<=n;++i)
        b[++m]=arr[i].y;
    sort(b+1,b+1+m);
    m=unique(b+1,b+1+m)-b-1;
    for(int i=1;i<=n;++i)
        arr[i].y=lower_bound(b+1,b+1+m,arr[i].y)-b;
    return m;
}
//===========================================连续子段线段树;
struct node
{
    long long Sum,Lsum,Rsum,ans;
}tr[N<<2];

void up(int rt)
{
    tr[rt].Sum=tr[ls].Sum+tr[rs].Sum;
    tr[rt].ans=max(max(tr[ls].ans,tr[rs].ans),tr[ls].Rsum+tr[rs].Lsum);
    tr[rt].Lsum=max(tr[ls].Lsum,tr[ls].Sum+tr[rs].Lsum);
    tr[rt].Rsum=max(tr[rs].Rsum,tr[rs].Sum+tr[ls].Rsum);
}
void Build(int l,int r,int rt)
{
    if(l==r)
    {
        tr[rt].Sum=tr[rt].Lsum=tr[rt].Rsum=tr[rt].ans=0;
        return;
    }
    int mid=(l+r)>>1;
    Build(l,mid,ls);
    Build(mid+1,r,rs);
    up(rt);
}
void update_dot(int pos,long long v,int l,int r,int rt)
{
    if(l==r)
    {
        tr[rt].Sum+=v;
        tr[rt].Lsum=tr[rt].Rsum=tr[rt].ans=tr[rt].Sum;
        return;
    }
    int mid=(l+r)>>1;
    if(pos<=mid)
        update_dot(pos,v,l,mid,ls);
    else
        update_dot(pos,v,mid+1,r,rs);
    up(rt);
}
vector<vector<vnode> >v(N);

int main()
{
    int T;
    sc("%d",&T);
    while(T--)
    {
        int n;
        sc("%d",&n);
        for(int i=1;i<=n;++i)
            sc("%d%d%lld",&arr[i].x,&arr[i].y,&arr[i].v);
        int L=LSx(n);
        int H=LSy(n);
        fo(i,1,H)v[i].clear();
        for(int i=1;i<=n;++i)
            v[arr[i].y].push_back({arr[i].x,arr[i].v});
        long long ans=0;
        for(int i=H;i>=1;--i)
        {
            Build(1,L,1);
            for(int j=i;j>=1;--j)
            {
                int sz=v[j].size();
                for(int k=0;k<sz;++k)
                {
                    vnode t=v[j][k];
                    update_dot(t.x,t.v,1,L,1);
                }
                ans=max(ans,tr[1].ans);//每增加一层就更新答案;
            }
        }
        pr("%lld
",ans);
    }
    return 0;
}

/**************************************************************************************/

int maxx(int arr,int b)
{
    return arr>b?arr:b;
}

void swapp(int &arr,int &b)
{
    arr^=b^=arr^=b;
}

int lowbit(int n)
{
    return n&(-n);
}

int Del_bit_1(int n)
{
    return n&(n-1);
}

int abss(int arr)
{
    return arr>0?arr:-arr;
}

double fabss(double arr)
{
    return arr>0?arr:-arr;
}

int minn(int arr,int b)
{
    return arr<b?arr:b;
}