tema Enlace
El comienzo muy convirtió en una, buscando fuera de línea codiciosos y el prefijo de dos dimensiones, y luego mantener una matriz bidimensional de orden parcial árbol, por lo que la idea es la existencia de ERROR, porque soy ya que cada punto de la esquina inferior izquierda, inferior derecha, en la esquina superior izquierda la esquina superior derecha, respectivamente, para calcular la contribución máxima, pero este método no es el más codicioso, porque en ese momento puede que no haya un rectángulo de cuatro esquinas, sino como un punto interno de tiempo es suficiente un codicioso codicioso.
, Que este es el caso, no se ajusta a la estrategia codiciosa
Pues bien, para encontrar dónde se encuentra el problema mucho más conveniente, en lugar de una depuración sostenida.
cambio de tipo de pensamiento Vamos a pensar que el rango de impacto de cada punto a la derecha es limitado, es decir, el punto de [pos, pos + W - 1 ] Esta gama, que es el nivel de tiempo, por supuesto, es al mismo tiempo vertical, porque el punto no está en la frontera.
Por lo tanto, podemos suponer que han recibido durante este intervalo de su impacto, y el impacto de cada punto a ir a la derecha, entonces el problema sería que no se convierta en un alcance máximo de una cosa!
Nos ascendiendo una coordenada del eje Y, y luego guardar el número vector punto, y seleccionar el valor máximo puede ser por lo tanto actualiza.
#include <iostream>
#include <cstdio>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <limits>
#include <vector>
#include <stack>
#include <queue>
#include <set>
#include <map>
#include <bitset>
//#include <unordered_map>
//#include <unordered_set>
#define lowbit(x) ( x&(-x) )
#define pi 3.141592653589793
#define e 2.718281828459045
#define INF 0x3f3f3f3f3f3f3f3f
#define eps 1e-8
#define HalF (l + r)>>1
#define lsn rt<<1
#define rsn rt<<1|1
#define Lson lsn, l, mid
#define Rson rsn, mid+1, r
#define QL Lson, ql, qr
#define QR Rson, ql, qr
#define myself rt, l, r
#define MP(a, b) make_pair(a, b)
#define MAX_3(a, b, c) max(a, max(b, c))
#define Rabc(x) x > 0 ? x : -x
using namespace std;
typedef unsigned long long ull;
typedef unsigned int uit;
typedef long long ll;
const int maxN = 1e4 + 7;
int N, _UX, _UY;
ll W, H, Lsan_X[maxN], Lsan_Y[maxN];
vector<int> vt[maxN];
struct node
{
ll x, y; int c;
node(ll a=0, ll b=0, int _c=0):x(a), y(b), c(_c) {}
inline void In() { scanf("%lld%lld%d", &x, &y, &c); }
} a[maxN];
inline bool cmp(int e1, int e2) { return a[e1].x < a[e2].x; }
int tree[maxN << 2], lazy[maxN << 2];
inline void pushdown(int rt)
{
if(lazy[rt])
{
tree[lsn] += lazy[rt]; tree[rsn] += lazy[rt];
lazy[lsn] += lazy[rt]; lazy[rsn] += lazy[rt];
lazy[rt] = 0;
}
}
void update(int rt, int l, int r, int ql, int qr, int val)
{
if(ql <= l && qr >= r)
{
tree[rt] += val;
lazy[rt] += val;
return;
}
pushdown(rt);
int mid = HalF;
if(qr <= mid) update(QL, val);
else if(ql > mid) update(QR, val);
else { update(QL, val); update(QR, val); }
tree[rt] = max(tree[lsn], tree[rsn]);
}
inline void solve()
{
int id = 1, ans = 0;
for(int i=1, len, L, R; i<=_UY; i++)
{
while(id < i && Lsan_Y[i] - Lsan_Y[id] >= H)
{
len = (int)vt[id].size();
for(int j=0; j<len; j++)
{
L = (int)a[vt[id][j]].x;
R = (int)(upper_bound(Lsan_X + 1, Lsan_X + _UX + 1, Lsan_X[L] + W - 1) - Lsan_X - 1);
if(L <= R) update(1, 1, _UX, L, R, -a[vt[id][j]].c);
}
id++;
}
len = (int)vt[i].size();
for(int j=0; j<len; j++)
{
L = (int)a[vt[i][j]].x;
R = (int)(upper_bound(Lsan_X + 1, Lsan_X + _UX + 1, Lsan_X[L] + W - 1) - Lsan_X - 1);
if(L <= R) update(1, 1, _UX, L, R, a[vt[i][j]].c);
ans = max(ans, tree[1]);
}
}
if(!W || !H) ans = 0;
printf("%d\n", ans);
}
inline void init()
{
for(int i=1; i<=N; i++) vt[i].clear();
for(int i=1; i<=(N << 2); i++) tree[i] = lazy[i] = 0;
}
int main()
{
while(scanf("%d%lld%lld", &N, &W, &H) != EOF)
{
init();
for(int i=1; i<=N; i++)
{
a[i].In();
Lsan_X[i] = a[i].x; Lsan_Y[i] = a[i].y;
}
sort(Lsan_X + 1, Lsan_X + N + 1);
sort(Lsan_Y + 1, Lsan_Y + N + 1);
_UX = (int)(unique(Lsan_X + 1, Lsan_X + N + 1) - Lsan_X - 1);
_UY = (int)(unique(Lsan_Y + 1, Lsan_Y + N + 1) - Lsan_Y - 1);
for(int i=1; i<=N; i++)
{
a[i].x = (int)(lower_bound(Lsan_X + 1, Lsan_X + _UX + 1, a[i].x) - Lsan_X);
a[i].y = (int)(lower_bound(Lsan_Y + 1, Lsan_Y + _UY + 1, a[i].y) - Lsan_Y);
vt[a[i].y].push_back(i);
}
for(int i=1; i<=_UY; i++) sort(vt[i].begin(), vt[i].end(), cmp);
solve();
}
return 0;
}
Habla realmente quieren enfoque codiciosos comienza por la falta de codicia, me gusta mucho tiempo, sí siempre pensó (niebla
