Gym 101147F Bishops Alliance （树状数组+DP）

题目链接：http://codeforces.com/gym/101147/problem/F

#include<bits/stdc++.h>
using namespace std;
#define debug puts("YES");
#define rep(x,y,z) for(int (x)=(y);(x)<(z);(x)++)
#define ll long long
#define lrt int l,int r,int rt
#define lson l,mid,rt<<1
#define rson mid+1,r,rt<<1|1
#define root l,r,rt
#define mst(a,b) memset((a),(b),sizeof(a))
#define pii pair<ll,ll>
#define mk(x,y) make_pair(x,y)
const int  maxn =2*111111;
const int mod=998244353;
const int ub=1e6;
ll powmod(ll x,ll y){ll t; for(t=1;y;y>>=1,x=x*x%mod) if(y&1) t=t*x%mod; return t;}
ll gcd(ll x,ll y){return y?gcd(y,x%y):x;}
/*
题目大意：在二维平面上，给定二维平面维度和
若干个点的横纵坐标，每个点都有一个权值p,
定义一个子集：子集中任何一对点对都满足这样的条件：
两个点在同一对角线上，并且两点间对角线长度（包括两端）
等于两点权值的平方和加上C,C为常数事先给定，
问这样的子集存在的最大大小是多少？

题目解析：题目比较绕，凡是格点统计的树状数组是常用操作，
先分析下性质，不难发现二维坐标(x,y)可以唯一的确定两个对角线，
分别用x+y,x-y标记，这样思路就有点了，先用容器，把同一对角线的点存入容器中，
存入的结构是横坐标和权值的平方。
再分析，不难发现这样的子集其状态有传递性，比如：
我们如果有xi<xj<xk,
xj-xi+1>=pi*pi+pj*pj+C，
xk-xj+1>=pk*pk+pj*pj+C，
这样的性质可以传递到i和k上，
就是说我们按横坐标排序后只要考虑当前点和上一个点的状态即可。
那么状态转移的条件是什么呢？dp[j]=max{dp[i]+1},i和j的关系：
满足xj-xi+1>=pi*pi+pj*pj+C，等式变换一下，
把变量归类，就形成了树状数组应用的本质关系，
但是因为数值大小有点越界所以需要离散化。
详情操作见代码，分析到这里代码也就大致出来了！

时间复杂度：O(nlogn)(大致。。。)
*/

ll n,m,c,x,y,p,ans,ret;
ll ls[maxn],cnt;
vector<pair<int,ll> >a[2][maxn];
///bit
ll tree[maxn];
int lowbit(int x){return x&-x;}
void add(int x,ll d){for(;x<maxn;tree[x]=max(tree[x],d),x+=lowbit(x));}
ll sum(int x){ll ret=0;for(;x>0;ret=max(ret,tree[x]),x-=lowbit(x));return ret;}

int main(){
    freopen("bishops.in","r",stdin);///套路
    int t;scanf("%d",&t);
    while(t--){
        cnt=ret=0;
        rep(i,0,2) rep(j,0,maxn) a[i][j].clear();///初始化
        scanf("%lld%lld%lld",&n,&m,&c);
        for(int i=0;i<m;i++){
            scanf("%lld%lld%lld",&x,&y,&p);
            a[0][x+y+1].push_back(make_pair(x,1LL*p*p));
            a[1][x-y+n].push_back(make_pair(x,1LL*p*p));
        }
        rep(i,0,2) rep(j,1,maxn){
            int len=a[i][j].size();
            if(len==0) continue;
            ans=cnt=0;///初始化
            sort(a[i][j].begin(),a[i][j].end());
            rep(q,0,len){
                int tx=a[i][j][q].first;
                ll tp=a[i][j][q].second;
                ls[cnt++]=tp+1LL*tx+c-1;
                ls[cnt++]=1LL*tx-tp;
            }
            sort(ls,ls+cnt),cnt=unique(ls,ls+cnt)-ls;
            rep(q,0,cnt+5) tree[q]=0;
            rep(q,0,len){
                int tx=a[i][j][q].first;
                ll tp=a[i][j][q].second;
                ll tmp=tp+1LL*tx+c-1;
                tp=1LL*tx-tp;
                tp=lower_bound(ls,ls+cnt,tp)-ls+1;
                ///if(j==9) cout<<tp<<" ";
                tp=sum(tp)+1;
                ans=max(ans,tp);
                tmp=lower_bound(ls,ls+cnt,tmp)-ls+1;
                ///if(j==9) cout<<tmp<<endl;
                add(tmp,tp);
            }
            ret=max(ret,ans);
            ///cout<<ans<<" "<<i<<" "<<j<<endl;
        }
        printf("%lld\n",ret);
    }
    return 0;
}