text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll INF = 1e9+7;
int main() {
int n,m;
cin >> n >> m;
vector<ll> x(n), y(n), xs(n), ys(n);
for(int i=0;i<n;i++) {
cin >> x[i] >> y[i];
xs[i] = x[i];
ys[i] = y[i];
}
// 座標圧縮
xs.push_back(-2*INF);
ys.push_back(-2*INF);
sort(xs.begin(),xs.end());
sort(ys.begin(),ys.end());
xs.erase(unique(xs.begin(),xs.end()),xs.end());
ys.erase(unique(ys.begin(),ys.end()),ys.end());
for(int i=0;i<n;i++) {
x[i] = lower_bound(xs.begin(),xs.end(),x[i]) - xs.begin();
y[i] = lower_bound(ys.begin(),ys.end(),y[i]) - ys.begin();
//cout << x[i] << " " << y[i] << endl;
}
vector<vector<ll>> sum(ys.size()+5,vector<ll>(xs.size()+5,0));
for(int i=0;i<n;i++) {
sum[y[i]][x[i]]++;
}
for(int i=1;i<=ys.size();i++) {
for(int j=1;j<=xs.size();j++) {
sum[i][j] = sum[i][j] + sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1];
}
}
/*
for(int i=0;i<=ys.size();i++) {
for(int j=0;j<=xs.size();j++) {
cout << sum[i][j] << " ";
}
cout << endl;
}
*/
for(int i=0;i<m;i++) {
ll x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(xs.begin(),xs.end(),x1) - xs.begin();
y1 = lower_bound(ys.begin(),ys.end(),y1) - ys.begin();
x2 = upper_bound(xs.begin(),xs.end(),x2) - xs.begin() - 1;
y2 = upper_bound(ys.begin(),ys.end(),y2) - ys.begin() - 1;
ll ans = sum[y2][x2] - sum[y2][x1-1] - sum[y1-1][x2] + sum[y1-1][x1-1];
cout << ans << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define rep(i,n) for(int i=0; i<n; i++)
int n, m;
int nx, ny;
int x[5001], y[5001];
int index_x[5001], index_y[5001];
int sum[5001][5001];
int main(){
cin >> n >> m;
rep(i,n) cin >> x[i] >> y[i];
memset(sum, 0, sizeof(sum));
rep(i,n) index_x[i] = x[i];
rep(i,n) index_y[i] = y[i];
sort(index_x, index_x+n);
sort(index_y, index_y+n);
nx = unique(index_x, index_x+n) - index_x;
ny = unique(index_y, index_y+n) - index_y;
rep(i,n){
int px = (lower_bound(index_x, index_x+nx, x[i]) - index_x) + 1;
int py = (lower_bound(index_y, index_y+ny, y[i]) - index_y) + 1;
sum[px][py] += 1;
}
rep(i,nx) rep(j,ny)
sum[i+1][j+1] += (sum[i+1][j] + sum[i][j+1] - sum[i][j]);
rep(i,m){
int lx, ly, rx, ry;
cin >> lx >> ly >> rx >> ry;
lx = lower_bound(index_x, index_x+nx, lx) - index_x;
ly = lower_bound(index_y, index_y+ny, ly) - index_y;
rx = lower_bound(index_x, index_x+nx, rx+1) - index_x;
ry = lower_bound(index_y, index_y+ny, ry+1) - index_y;
cout << (sum[rx][ry] - sum[lx][ry] - sum[rx][ly] + sum[lx][ly]) << endl;
}
return 0;
} |
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
const int INF = 1000000001;
inline int query(const vector<vector<int> >& mat, int a, int b, int c, int d) {
return mat[d][c] - mat[d][a] - mat[b][c] + mat[b][a];
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector<int> x_pos, y_pos;
x_pos.reserve(n + 1);
y_pos.reserve(n + 1);
x_pos.push_back(-INF);
y_pos.push_back(-INF);
vector<int> x(n), y(n);
for(int i = 0; i < n; ++i) {
scanf("%d %d", &x[i], &y[i]);
x_pos.push_back(x[i]);
y_pos.push_back(y[i]);
}
sort(x_pos.begin(), x_pos.end());
sort(y_pos.begin(), y_pos.end());
x_pos.erase(unique(x_pos.begin(), x_pos.end()), x_pos.end());
y_pos.erase(unique(y_pos.begin(), y_pos.end()), y_pos.end());
const int w = (int)x_pos.size(), h = (int)y_pos.size();
vector<vector<int> > treasure(h, vector<int>(w, 0));
for(int i = 0; i < n; ++i) {
const int x1 = lower_bound(x_pos.begin(), x_pos.end(), x[i]) - x_pos.begin();
const int y1 = lower_bound(y_pos.begin(), y_pos.end(), y[i]) - y_pos.begin();
++treasure[y1][x1];
}
for(int i = 0; i < h; ++i)
for(int j = 0; j < w - 1; ++j)
treasure[i][j + 1] += treasure[i][j];
for(int j = 0; j < w; ++j)
for(int i = 0; i < h - 1; ++i)
treasure[i + 1][j] += treasure[i][j];
for(int i = 0; i < m; ++i) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
x1 = lower_bound(x_pos.begin(), x_pos.end(), x1) - x_pos.begin();
y1 = lower_bound(y_pos.begin(), y_pos.end(), y1) - y_pos.begin();
x2 = upper_bound(x_pos.begin(), x_pos.end(), x2) - x_pos.begin();
y2 = upper_bound(y_pos.begin(), y_pos.end(), y2) - y_pos.begin();
printf("%d\n", query(treasure, x1 - 1, y1 - 1, x2 - 1, y2 - 1));
}
return EXIT_SUCCESS;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int,int> P;
const int INF = 1 << 28;
int main() {
int N, M;
cin >> N >> M;
vector<P> v(N);
for (int i = 0; i < N; i++) {
cin >> v[i].first >> v[i].second;
}
sort(v.begin(), v.end());
int len = sqrt(N);
vector<vector<P> > m((N + len - 1) / len), n((N + len - 1) / len);
for (int i = 0; i < N; i++) {
m[i / len].push_back(P(v[i].second, v[i].first));
n[i / len].push_back(v[i]);
}
for (auto& i : m) {
sort(i.begin(), i.end());
}
while (M--) {
int sx, sy, gx, gy;
cin >> sx >> sy >> gx >> gy;
int ans = 0;
for (int i = 0; i < m.size(); i++) {
int n_first = n[i][0].first;
int n_last = n[i][n[i].size()-1].first;
if ((sx <= n_first && n_first <= gx) && (sx <= n_last && n_last <= gx)) {
int low = lower_bound(m[i].begin(), m[i].end(), P(sy, sx)) - m[i].begin();
int up = upper_bound(m[i].begin(), m[i].end(), P(gy, gx)) - m[i].begin();
ans += up - low;
} else {
if ((n_first <= sx && sx <= n_last) || (n_first <= gx && gx <= n_last)) {
int low = lower_bound(n[i].begin(), n[i].end(), P(sx,sy)) - n[i].begin();
int up = upper_bound(n[i].begin(), n[i].end(), P(gx,gy)) - n[i].begin();
for (low; low <= up && low < n[i].size(); low++) {
if (
sx <= n[i][low].first && n[i][low].first <= gx
&& sy <= n[i][low].second && n[i][low].second <= gy
) ans++;
}
}
}
}
cout << ans << endl;
}
return 0;
} |
#include<bits/stdc++.h>
typedef long long ll;
#define REP(i,n) for(int i = 0;i < (n);i++)
#define rep(i,m,n) for(int i = (m);i < (n);i++)
#define P pair<int,int>
#define pb push_back
#define mk make_pair
using namespace std;
#define Vec(a) vector <int> a
const int INF = 1 << 20;
const int MOD = 1e9+7;
int main(){
int n,m;
cin >> n >> m;
vector <P> p(n);
REP(i,n){
cin >> p[i].first >> p[i].second;
}
sort(p.begin(),p.end());
REP(i,m){
int x1,x2,y1,y2;
int sum = 0;
cin >> x1 >> y1 >> x2 >> y2;
REP(j,n){
if(p[j].first >= x1 && p[j].first <= x2 && p[j].second >= y1 && p[j].second <= y2){
sum++;
}
if(x2 < p[j].first){
break;
}
}
printf("%d\n", sum);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i,n) for (int i=0;i<(n);i++)
#define rep2(i,a,b) for (int i=(a);i<(b);i++)
#define rrep(i,n) for (int i=(n)-1;i>=0;i--)
#define rrep2(i,a,b) for (int i=(b)-1;i>=(a);i--)
#define all(a) (a).begin(),(a).end()
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
const int MAX_N = 5010;
int a[MAX_N][MAX_N];
int getSum(int r1, int c1, int r2, int c2) {
return a[r1][c1] - a[r1][c2] - a[r2][c1] + a[r2][c2];
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int n, m;
cin >> n >> m;
vector<Pii> p(n);
map<int, int> mpx;
map<int, int> mpy;
rep(i, n) {
cin >> p[i].first >> p[i].second;
mpx[p[i].first] = 0;
mpy[p[i].second] = 0;
}
V vx;
V vy;
int idx = 0;
for (auto&& q : mpx) {
vx.emplace_back(q.first);
q.second = idx++;
}
int idy = 0;
for (auto&& q : mpy) {
vy.emplace_back(q.first);
q.second = idy++;
}
rep(i, n) {
a[mpx[p[i].first]][mpy[p[i].second]]++;
}
rrep(i, n) {
rrep(j, n) {
a[i][j] += a[i][j + 1];
}
}
rrep(j, n) {
rrep(i, n) {
a[i][j] += a[i + 1][j];
}
}
rep(i, m) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int r1, c1, r2, c2;
r1 = lower_bound(all(vx), x1) - vx.begin();
c1 = lower_bound(all(vy), y1) - vy.begin();
r2 = upper_bound(all(vx), x2) - vx.begin();
c2 = upper_bound(all(vy), y2) - vy.begin();
cout << getSum(r1, c1, r2, c2) << endl;
}
} |
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
typedef pair<int,int> pii;
int main(){
int n,m,x,y,sx,sy,lx,ly;
vector<pii> map;
cin>>n>>m;
for(int i=0;i<n;i++){
cin>>x>>y;
map.push_back(make_pair(x,y));
}
sort(map.begin(),map.end());
for(int i=0;i<m;i++){
cin>>sx>>sy>>lx>>ly;
int left,right;
for(left=0;map[left].first<sx&&left<map.size();left++);
int ans=0;
for(right=left;map[right].first<=lx&&right<map.size();right++)
if(sy<=map[right].second&&map[right].second<=ly) ans++;
cout<<ans<<endl;
}
}
|
#include<stdio.h>
#include<algorithm>
using namespace std;
int sum[5002][5002];
int x[5002];
int y[5002];
int X[5002];
int Y[5002];
int main(){
int a,b;
scanf("%d%d",&a,&b);
for(int i=0;i<a;i++){
scanf("%d%d",x+i,y+i);
X[i]=x[i];
Y[i]=y[i];
}
X[a]=-1999999999;
X[a+1]=1999999999;
Y[a]=-1999999999;
Y[a+1]=1999999999;
std::sort(X,X+a+2);
std::sort(Y,Y+a+2);
for(int i=0;i<a;i++){
x[i]=lower_bound(X,X+a+2,x[i])-X;
y[i]=lower_bound(Y,Y+a+2,y[i])-Y;
sum[x[i]][y[i]]++;
}
for(int i=0;i<a+2;i++){
for(int j=1;j<a+2;j++){
sum[i][j]+=sum[i][j-1];
}
}
for(int i=0;i<a+2;i++){
for(int j=1;j<a+2;j++){
sum[j][i]+=sum[j-1][i];
}
}
for(int i=0;i<b;i++){
int p,q,r,s;
scanf("%d%d%d%d",&p,&q,&r,&s);
int P=lower_bound(X,X+a+2,p)-X-1;
int Q=lower_bound(Y,Y+a+2,q)-Y-1;
int R=upper_bound(X,X+a+2,r)-X-1;
int S=upper_bound(Y,Y+a+2,s)-Y-1;
printf("%d\n",sum[R][S]-sum[R][Q]-sum[P][S]+sum[P][Q]);
}
} |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
int main()
{
for(int n,m;cin>>n>>m;){
vector<pair<int,int> > ps(n);
for(int i=0;i<n;i++) cin>>ps[i].first>>ps[i].second;
vector<int> xs,ys;
for(int i=0;i<n;i++){
xs.push_back(ps[i].first);
ys.push_back(ps[i].second);
}
sort(xs.begin(),xs.end()); xs.erase(unique(xs.begin(),xs.end()),xs.end());
sort(ys.begin(),ys.end()); ys.erase(unique(ys.begin(),ys.end()),ys.end());
for(int i=0;i<n;i++)
ps[i]=make_pair(lower_bound(xs.begin(),xs.end(),ps[i].first)-xs.begin(),
lower_bound(ys.begin(),ys.end(),ps[i].second)-ys.begin());
vector<vector<int> > grid(ys.size(),vector<int>(xs.size()));
for(int i=0;i<n;i++)
grid[ps[i].second][ps[i].first]++;
vector<vector<int> > sum(ys.size()+1,vector<int>(xs.size()+1));
for(int i=0;i<ys.size();i++) for(int j=0;j<xs.size();j++)
sum[i+1][j+1]=sum[i][j+1]+sum[i+1][j]-sum[i][j]+grid[i][j];
for(int i=0;i<m;i++){
int x1,y1,x2,y2; cin>>x1>>y1>>x2>>y2;
x1=lower_bound(xs.begin(),xs.end(),x1)-xs.begin();
y1=lower_bound(ys.begin(),ys.end(),y1)-ys.begin();
x2=upper_bound(xs.begin(),xs.end(),x2)-xs.begin();
y2=upper_bound(ys.begin(),ys.end(),y2)-ys.begin();
cout<<sum[y2][x2]-sum[y1][x2]-sum[y2][x1]+sum[y1][x1]<<endl;
}
}
} |
// iostream のscanf, printf では間に合わなかった
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
#define INF (1<<29)
#define mp make_pair
#define pb push_back
typedef pair<int,int> pii;
int main(){
int n, m;
cin >> n >> m;
vector<pii> treasure;
for( int i = 0; i < n; i++ ){
int x, y;
//cin >> x >> y;
scanf("%d %d", &x, &y);
treasure.pb( mp(x,y) );
}
sort(treasure.begin(), treasure.end());
for( int i = 0; i < m; i++ ){
int x1, y1, x2, y2;
//cin >> x1 >> y1 >> x2 >> y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
// search
int ans = 0;
vector<pii>::iterator it = lower_bound(treasure.begin(),treasure.end(),mp(x1,y1));
while( 1 ){
if( it == treasure.end() || *it > mp(x2,y2) ) break;
if( x1 <= (*it).first && (*it).first <= x2 && y1 <= (*it).second && (*it).second <= y2 ) ans++;
it++;
}
//cout << ans << endl;
printf("%d\n", ans);
}
} |
#include <iostream>
#include <iomanip>
#include <sstream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <complex>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <cassert>
#include <climits>
#include <queue>
#include <set>
#include <map>
#include <valarray>
#include <bitset>
#include <stack>
using namespace std;
#define REP(i,n) for(int i=0;i<(int)(n);++i)
#define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
typedef pair<int,int> pii;
const int INF = 1<<29;
const double PI = acos(-1);
const double EPS = 1e-8;
void hoge(vector<int> &v) {
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
}
int x[5000], y[5000], num[5000];
int a[5001][5001];
int sum[5001][5001];
int main() {
int n, m;
cin >> n >> m;
vector<int> xs, ys;
REP(i,n) {
cin >> x[i] >> y[i];
xs.push_back(x[i]);
ys.push_back(y[i]);
}
hoge(xs);
hoge(ys);
REP(i,n) {
int yy = lower_bound(ALL(ys),y[i]) - ys.begin();
int xx = lower_bound(ALL(xs),x[i]) - xs.begin();
a[yy][xx]++;
//cout << yy << " " << xx << endl;
}
REP(i,ys.size()) {
REP(j,xs.size()) {
sum[i+1][j+1] = sum[i][j+1] + sum[i+1][j] - sum[i][j] + a[i][j];
}
}
REP(i,m) {
int xx1, yy1,xx2, yy2;
cin >> xx1 >> yy1 >> xx2 >> yy2;
int x2 = lower_bound(ALL(xs),xx1) - xs.begin();
int y2 = lower_bound(ALL(ys),yy1) - ys.begin();
int x1 = upper_bound(ALL(xs),xx2) - xs.begin();
int y1 = upper_bound(ALL(ys),yy2) - ys.begin();
//cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
int res = sum[y1][x1]+sum[y2][x2]-sum[y1][x2]-sum[y2][x1];
cout << res << endl;
}
} |
#include<algorithm>
#include<vector>
#include<stack>
#include<deque>
#include<iostream>
#include<cstdio>
#define F first
#define S second
#define LIM 1000000010
#define pb push_back
#define all(n) n.begin(),n.end()
using namespace std;
typedef pair<int,int> P;
int dp[5002][5002];
int main(){
int n,m;
vector<int> X,Y;
while(cin >> n >> m){
for(int i=0;i<5000;i++)for(int j=0;j<5000;j++)dp[j][i] = 0;
for(int i=0;i<n;i++){
int x,y;
cin >> x >> y;
X.pb(x); Y.pb(y);
}
vector<int> x,y;
x = X;
y = Y;
X.pb(-LIM); X.pb(LIM); Y.pb(-LIM); Y.pb(LIM);
sort(all(X)); sort(all(Y));
X.erase(unique(all(X)),X.end());
Y.erase(unique(all(Y)),Y.end());
for(int i=0;i<n;i++){
x[i] = lower_bound(all(X),x[i])-X.begin();
y[i] = lower_bound(all(Y),y[i])-Y.begin();
dp[y[i]][x[i]]++;
}
for(int i=0;i<=n;i++){
for(int j=0;j<=n;j++){
dp[i+1][j+1] += dp[i+1][j]+dp[i][j+1]-dp[i][j];
}
}
for(int i=0;i<m;i++){
int sx,sy,gx,gy;
cin >> sx >> sy >> gx >> gy;
sx = lower_bound(all(X),sx)-X.begin();
sy = lower_bound(all(Y),sy)-Y.begin();
gx = upper_bound(all(X),gx)-X.begin()-1;
gy = upper_bound(all(Y),gy)-Y.begin()-1;
cout << dp[gy][gx]-dp[gy][sx-1]-dp[sy-1][gx]+dp[sy-1][sx-1] << endl;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
#define rep(i, n) REP(i, 0, n)
#define REP(i, a, n) for(int i=(a); i<(n); i++)
int n, m;
vector<pii> xy;
int main() {
cin >> n >> m;
rep(i, n) { int x, y; cin >> x >> y; xy.push_back({x, y}); }
sort(xy.begin(), xy.end());
rep(_, m) {
int ans = 0;
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
rep(i, n) {
if(xy[i].first < x1) continue;
REP(j, i, n) {
if(xy[j].first > x2) break;
if(y1 <= xy[j].second && xy[j].second <= y2) ans++;
}
break;
}
cout << ans << endl;
}
}
|
#include<iostream>
using namespace std;
int x[5000],y[5000];
int main(){
int n,m,tmp;
cin>>n>>m;
for(int i=0;i<n;i++)cin>>x[i]>>y[i];
for(int i=0;i<n-1;i++){for(int j=n-1;j>i;j--){if(x[j]<x[j-1]){tmp=x[j],x[j]=x[j-1],x[j-1]=tmp;tmp=y[j],y[j]=y[j-1],y[j-1]=tmp;}}}
int leftx,rightx,lefty,righty;
for(int u=0;u<m;u++){
cin>>leftx>>lefty>>rightx>>righty;
int bef,aft;
int left=0,right=n,mid;
while(true){
if(right<=left+1)
break;
mid=(right+left)/2;
if(x[mid]>=leftx)
right=mid;
else
left=mid;
}
bef=max(0,mid-1);
left=0,right=n;
while(true){
if(right<=left+1)
break;
mid=(right+left)/2;
if(x[mid]<=rightx)
left=mid;
else
right=mid;
}
aft=min(n-1,mid+1);
int ans=0;
for(int i=bef;i<=aft;i++){if(x[i]>=leftx&&x[i]<=rightx&&y[i]>=lefty&&y[i]<=righty)ans++;}
cout<<ans<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef vector<int> VI;
#define pb push_back
#define all(vec) (vec).begin(),(vec).end()
const int INF = 2000000000;
int x[5000], y[5000];
int sx[500000], sy[500000], ex[500000], ey[500000];
short num[5050][5050];
int find(VI &zip, int key, int type = 0)
{
int l = 0, r = zip.size() - 1;
while (true){
if (l > r) return type ? l : r;
int m = (l + r) / 2;
if (zip[m] == key) return m;
if (zip[m] < key) l = m + 1;
else r = m - 1;
}
}
int main()
{
VI zip_x; zip_x.pb(-INF); zip_x.pb(INF);
VI zip_y; zip_y.pb(-INF); zip_y.pb(INF);
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++){
scanf("%d %d", &x[i], &y[i]);
zip_x.pb(x[i]);
zip_y.pb(y[i]);
}
for (int i = 0; i < m; i++){
scanf("%d %d %d %d", &sx[i], &sy[i], &ex[i], &ey[i]);
//zip_x.pb(sx[i]);
//zip_y.pb(sy[i]);
//zip_x.pb(ex[i]);
//zip_y.pb(ey[i]);
}
// 座標圧縮
sort(all(zip_x));
zip_x.erase(unique(all(zip_x)), zip_x.end());
sort(all(zip_y));
zip_y.erase(unique(all(zip_y)), zip_y.end());
// 圧縮後の座標を受け取る
for (int i = 0; i < n; i++){
x[i] = find(zip_x, x[i]);
y[i] = find(zip_y, y[i]);
}
for (int i = 0; i < m; i++){
sx[i] = find(zip_x, sx[i], 1);
sy[i] = find(zip_y, sy[i], 1);
ex[i] = find(zip_x, ex[i]);
ey[i] = find(zip_y, ey[i]);
}
//累積和
for (int i = 0; i < n; i++){
num[x[i]][y[i]]++;
}
for (int i = 1; i < zip_x.size(); i++){
for (int j = 1; j < zip_y.size(); j++){
num[i][j] += num[i - 1][j];
num[i][j] += num[i][j - 1];
num[i][j] -= num[i - 1][j - 1];
}
}
/*
puts("");
for (int i = 0; i < zip_x.size(); i++){
for (int j = 0; j < zip_y.size(); j++){
printf("%d ", num[i][j]);
}
puts("");
}
puts("");
*/
for (int i = 0; i < m; i++){
int res = num[ex[i]][ey[i]];
res -= num[sx[i] - 1][ey[i]];
res -= num[ex[i]][sy[i] - 1];
res += num[sx[i] - 1][sy[i] - 1];
printf("%d\n", res);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
#define allof(a) (a).begin(),(a).end()
void uniqueVector(vector< int >& vec) {
sort(allof(vec));
vec.erase(unique(allof(vec)), vec.end());
}
void solve(
int n, int m,
const vector< int >& tx, const vector< int >& ty,
const vector< int >& lft, const vector< int >& bot,
const vector< int >& rgt, const vector< int >& top
) {
vector< int > x_sort = tx, y_sort = ty;
uniqueVector(x_sort);
uniqueVector(y_sort);
vector< vector< int > > imos(n + 1, vector< int >(n + 1, 0));
for_(i,0,n) {
int x = lower_bound(allof(x_sort), tx[i]) - x_sort.begin() + 1;
int y = lower_bound(allof(y_sort), ty[i]) - y_sort.begin() + 1;
++imos[y][x];
}
for_(y,0,n+1) for_(x,0,n) imos[y][x + 1] += imos[y][x];
for_(x,0,n+1) for_(y,0,n) imos[y + 1][x] += imos[y][x];
for_(i,0,m) {
int lx = lower_bound(allof(x_sort), lft[i]) - x_sort.begin() + 1;
int by = lower_bound(allof(y_sort), bot[i]) - y_sort.begin() + 1;
int rx = upper_bound(allof(x_sort), rgt[i]) - x_sort.begin();
int ty = upper_bound(allof(y_sort), top[i]) - y_sort.begin();
printf("%d\n", imos[ty][rx] - imos[ty][lx - 1] - imos[by - 1][rx] + imos[by - 1][lx - 1]);
}
}
int main() {
int n, m;
scanf("%d %d", &n, &m);
vector< int > tx(n), ty(n);
for_(i,0,n) scanf("%d %d", &tx[i], &ty[i]);
vector< int > lft(m), bot(m), rgt(m), top(m);
for_(i,0,m) scanf("%d %d %d %d", &lft[i], &bot[i], &rgt[i], &top[i]);
solve(n, m, tx, ty, lft, bot, rgt, top);
} |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<n;i++)
using namespace std;
int sum[6000][6000];
int X[6000], Y[6000];
int X1[600000], X2[600000], Y1[600000], Y2[600000];
int n, m;
int compress(int*x, int*X1, int*X2) {
vector<int>v;
rep(i, n)v.push_back(x[i]);
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
rep(i, m) {
X1[i] = lower_bound(v.begin(), v.end(), X1[i]) - v.begin();
X2[i] = upper_bound(v.begin(), v.end(), X2[i]) - v.begin() - 1;
}
rep(i, n) {
x[i] = lower_bound(v.begin(), v.end(), x[i]) - v.begin();
}
return (int)v.size();
}
signed main() {
scanf("%d%d", &n, &m);
rep(i, n)scanf("%d%d", &X[i], &Y[i]);
rep(i, m)scanf("%d%d%d%d", &X1[i], &Y1[i], &X2[i], &Y2[i]);
int h = compress(X, X1, X2), w = compress(Y, Y1, Y2);
rep(i, n)sum[X[i]][Y[i]]++;
rep(i, h + 1)for (int j = 1; j <= w; j++) {
sum[i][j] += sum[i][j - 1];
}
for (int i = 1; i <= h; i++)rep(j, w + 1) {
sum[i][j] += sum[i - 1][j];
}
rep(i, m) {
if (X2[i] < 0 || Y2[i] < 0) {
puts("0"); continue;
}
int ans = sum[X2[i]][Y2[i]];
if (X1[i] > 0)ans -= sum[X1[i] - 1][Y2[i]];
if (Y1[i] > 0)ans -= sum[X2[i]][Y1[i] - 1];
if (X1[i] > 0 && Y1[i] > 0)ans += sum[X1[i] - 1][Y1[i] - 1];
printf("%d\n", ans);
}
} |
#include<algorithm>
#include<vector>
#include<stack>
#include<deque>
#include<iostream>
#include<cstdio>
#define F first
#define S second
#define LIM 1000000010
#define pb push_back
#define all(n) n.begin(),n.end()
using namespace std;
typedef pair<int,int> P;
short dp[5002][5002];
int main(){
int n,m;
vector<int> X,Y;
while(scanf("%d%d",&n,&m) != EOF){
for(int i=0;i<n;i++)for(int j=0;j<n;j++)dp[j][i] = 0;
for(int i=0;i<n;i++){
int x,y;
scanf("%d %d",&x,&y);
X.pb(x); Y.pb(y);
}
vector<int> x,y;
x = X;
y = Y;
X.pb(-LIM); X.pb(LIM); Y.pb(-LIM); Y.pb(LIM);
sort(all(X)); sort(all(Y));
X.erase(unique(all(X)),X.end());
Y.erase(unique(all(Y)),Y.end());
for(int i=0;i<n;i++){
x[i] = find(all(X),x[i])-X.begin();
y[i] = find(all(Y),y[i])-Y.begin();
dp[y[i]][x[i]]++;
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
dp[i+1][j+1] += dp[i+1][j]+dp[i][j+1]-dp[i][j];
}
}
for(int i=0;i<m;i++){
int sx,sy,gx,gy;
scanf("%d %d %d %d",&sx,&sy,&gx,&gy);
sx = lower_bound(all(X),sx)-X.begin();
sy = lower_bound(all(Y),sy)-Y.begin();
gx = upper_bound(all(X),gx)-X.begin()-1;
gy = upper_bound(all(Y),gy)-Y.begin()-1;
cout << dp[gy][gx]-dp[gy][sx-1]-dp[sy-1][gx]+dp[sy-1][sx-1] << endl;
}
}
return 0;
} |
//#define LOCAL
#include <fstream>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <climits>
#include <vector>
#define rep(i,n) for(int i=0; i<n; i++)
using namespace std;
void printv(vector<int> vi)
{
rep(i,vi.size()) {
cout << vi[i] << " ";
}
cout << endl;
}
short data[5002][5002];
int main()
{
#ifdef LOCAL
ifstream in("input.txt");
cin.rdbuf(in.rdbuf());
#endif
vector<int> x, y;
vector<int> ux, uy;
int n, m;
cin >> n >> m;
rep(i,n) {
int a, b;
cin >> a >> b;
x.push_back(a);
y.push_back(b);
}
ux = x;
uy = y;
ux.push_back(INT_MAX);
ux.push_back(INT_MIN);
uy.push_back(INT_MAX);
uy.push_back(INT_MIN);
//printv(ux);
//printv(uy);
sort(ux.begin(), ux.end());
sort(uy.begin(), uy.end());
//printv(ux);
//printv(uy);
ux.erase(unique(ux.begin(), ux.end()), ux.end());
uy.erase(unique(uy.begin(), uy.end()), uy.end());
//printv(ux);
//printv(uy);
rep(i,n) {
x[i] = lower_bound(ux.begin(), ux.end(), x[i]) - ux.begin();
y[i] = lower_bound(uy.begin(), uy.end(), y[i]) - uy.begin();
data[y[i]][x[i]]++;
}
//printv(x);
//printv(y);
for (int i=0; i<5002; i++) {
for (int j=1; j<5002; j++) {
data[i][j] += data[i][j-1];
}
}
for (int i=1; i<5002; i++) {
for (int j=0; j<5002; j++) {
data[i][j] += data[i-1][j];
}
}
rep(i,m) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a = lower_bound(ux.begin(), ux.end(), a) - ux.begin();
b = lower_bound(uy.begin(), uy.end(), b) - uy.begin();
c = upper_bound(ux.begin(), ux.end(), c) - ux.begin() - 1;
d = upper_bound(uy.begin(), uy.end(), d) - uy.begin() - 1;
int ans = data[d][c] - data[d][a-1] - data[b-1][c] + data[b-1][a-1];
cout << ans << endl;
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
#define all(vec) vec.begin(),vec.end()
int main(){
int n,m;cin >> n >> m;
vector<int> index_of_x(n),index_of_y(n);
for(int i=0;i<n;i++){
cin >> index_of_x[i] >> index_of_y[i];
}
vector<int> value_of_x = index_of_x,
value_of_y = index_of_y;
sort(all(value_of_x));
sort(all(value_of_y));
value_of_x.erase(unique(all(value_of_x)),value_of_x.end());
value_of_y.erase(unique(all(value_of_y)),value_of_y.end());
for(int i=0;i<n;i++){
index_of_x[i] = lower_bound(all(value_of_x),index_of_x[i]) - value_of_x.begin();
index_of_y[i] = lower_bound(all(value_of_y),index_of_y[i]) - value_of_y.begin();
}
vector<vector<int>> v(value_of_y.size()+1,vector<int>(value_of_x.size()+1));
{
vector<vector<int>> p(value_of_y.size(),vector<int>(value_of_x.size()));
for(int i=0;i<n;i++){
p[index_of_y[i]][index_of_x[i]] += 1;
}
for(int y=1;y<=value_of_y.size();y++){
for(int x=1;x<=value_of_x.size();x++){
v[y][x] = v[y][x-1] + p[y-1][x-1];
}
}
for(int x=0;x<=value_of_x.size();x++){
for(int y=1;y<=value_of_y.size();y++){
v[y][x] = v[y-1][x] + v[y][x];
}
}
}
for(int i=0;i<m;i++){
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
int sx = lower_bound(all(value_of_x),x1) - value_of_x.begin();
int gx = upper_bound(all(value_of_x),x2) - value_of_x.begin();
int sy = lower_bound(all(value_of_y),y1) - value_of_y.begin();
int gy = upper_bound(all(value_of_y),y2) - value_of_y.begin();
int ans = v[gy][gx] - v[sy][gx] - v[gy][sx] + v[sy][sx];
cout << ans << endl;
}
return 0;
} |
//#define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define IN(a, b, x) (a<=x&&x<b)
#define MP make_pair
#define PB push_back
#ifdef int
const ll INF = (1LL<<60);
#else
const int INF = (1LL<<30);
#endif
const double PI = 3.14159265359;
const double EPS = 1e-12;
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
template<typename T>
inline void compress(vector<T> & c){
sort(ALL(c));
c.erase(unique(ALL(c)),c.end());
}
template<typename T>
inline size_t idx(T i, vector<T> const& c){
return lower_bound(ALL(c),i) - c.begin();
}
int xx[5010], yy[5010], sum[5010][5010];
signed main(void)
{
int n, m;
cin >> n >> m;
VI x(n), y(n);
REP(i, n) {
cin >> xx[i] >> yy[i];
x[i] = xx[i], y[i] = yy[i];
}
compress(x);
compress(y);
REP(i, n) {
int tx = idx(xx[i], x), ty = idx(yy[i], y);
sum[ty+1][tx+1]++;
}
REP(i, y.size()) REP(j, x.size()) {
sum[i+1][j+1] += sum[i+1][j] + sum[i][j+1] - sum[i][j];
}
REP(i, m) {
int sx, sy, gx, gy;
cin >> sx >> sy >> gx >> gy;
sx = idx(sx, x), sy = idx(sy, y);
gx = idx(gx+1, x), gy = idx(gy+1, y);
cout << sum[gy][gx] - sum[gy][sx] - sum[sy][gx] + sum[sy][sx] << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <map>
using namespace std;
using lint = long long;
using ldouble = long double;
const int INF = 1 << 30;
map<int, int> compress(vector<int>& v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
map<int, int> ret;
for (int i = 0; i < v.size(); ++i) ret[v[i]] = i;
return ret;
}
int main() {
int N, M;
cin >> N >> M;
vector<int> x(N), y(N);
for (int i = 0; i < N; ++i) {
cin >> x[i] >> y[i];
}
auto xs = x, ys = y;
xs.push_back(-INF);
ys.push_back(-INF);
auto revx = compress(xs);
auto revy = compress(ys);
int X = xs.size(), Y = ys.size();
vector<vector<int>> imos(X, vector<int>(Y, 0));
for (int i = 0; i < N; ++i) {
++imos[revx[x[i]]][revy[y[i]]];
}
for (int i = 1; i < X; ++i) {
for (int j = 0; j < Y; ++j) {
imos[i][j] += imos[i - 1][j];
}
}
for (int i = 0; i < X; ++i) {
for (int j = 1; j < Y; ++j) {
imos[i][j] += imos[i][j - 1];
}
}
for (int i = 0; i < M; ++i) {
int lx, ly, rx, ry;
cin >> lx >> ly >> rx >> ry;
lx = *(--lower_bound(xs.begin(), xs.end(), lx));
ly = *(--lower_bound(ys.begin(), ys.end(), ly));
rx = *(--upper_bound(xs.begin(), xs.end(), rx));
ry = *(--upper_bound(ys.begin(), ys.end(), ry));
cout << imos[revx[rx]][revy[ry]] - imos[revx[rx]][revy[ly]] -
imos[revx[lx]][revy[ry]] + imos[revx[lx]][revy[ly]]
<< endl;
}
return 0;
}
|
#include<bits/stdc++.h>
typedef long long ll;
#define REP(i,n) for(int i = 0;i < (n);i++)
#define rep(i,m,n) for(int i = (m);i < (n);i++)
#define P pair<int,int>
#define pb push_back
#define mk make_pair
using namespace std;
#define Vec(a) vector <int> a
const int INF = 1 << 20;
const int MOD = 1e9+7;
int main(){
int n,m;
cin >> n >> m;
vector <P> p(n);
REP(i,n){
cin >> p[i].first >> p[i].second;
}
sort(p.begin(),p.end());
REP(i,m){
int x1,x2,y1,y2;
int sum = 0;
cin >> x1 >> y1 >> x2 >> y2;
REP(j,n){
if(p[j].first >= x1 && p[j].first <= x2 && p[j].second >= y1 && p[j].second <= y2){
sum++;
}
if(x2 < p[j].first){
break;
}
}
cout << sum << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<ll,ll> mp;
ll inf = 1e12;
bool lessY(const mp &a, const mp &b){
return a.second != b.second ? a.second < b.second : a.first < b.first;
}
int main(){
ll n,m;
cin>>n>>m;
vector<ll> x(n),y(n);
vector<mp> z(n);
for(ll i=0;i<n;i++) cin>>x[i]>>y[i];
for(ll i=0;i<n;i++) z[i] = mp(x[i],y[i]);
set<ll> ux,uy;// unique x,y;
for(auto i:x) ux.insert(i);
for(auto i:y) uy.insert(i);
ll h = ux.size(),w = uy.size();
vector<ll> rx,ry;
for(auto i:ux) rx.push_back(i);
for(auto i:uy) ry.push_back(i);
vector<vector<ll> > dp(h+1,vector<ll>(w+1,0) );
for(int i=0;i<n;i++){
auto ix = lower_bound(rx.begin(),rx.end() , x[i] );
auto iy = lower_bound(ry.begin(),ry.end() , y[i] );
int xi = ix-rx.begin();
int yi = iy-ry.begin();
// cout<<xi<<' '<<yi<<endl;
dp[xi+1][yi+1]++;
}
for(int i=0;i<h;i++)
for(int j=0;j<w;j++) dp[i+1][j+1] += dp[i+1][j]+dp[i][j+1]-dp[i][j];
for(ll i=0;i<m;i++){
ll sx,sy,tx,ty;
cin>>sx>>sy>>tx>>ty;
auto xs = lower_bound(rx.begin(),rx.end(), sx );
auto ys = lower_bound(ry.begin(),ry.end(), sy );
auto xt = upper_bound(rx.begin(),rx.end(), tx );
auto yt = upper_bound(ry.begin(),ry.end(), ty );
//xt--,yt--;
int ssx = xs-rx.begin();
int ssy = ys-ry.begin();
int ttx = xt-rx.begin();
int tty = yt-ry.begin();
//cout<<ssx<<' '<<ssy<<' '<<ttx<<' '<<tty<<endl;
cout<<dp[ttx][tty]-dp[ttx][ssy]-dp[ssx][tty]+dp[ssx][ssy]<<endl;
}
}
|
#include <iostream>
#include <complex>
#include <sstream>
#include <string>
#include <algorithm>
#include <deque>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <vector>
#include <set>
#include <limits>
#include <cstdio>
#include <cctype>
#include <cmath>
#include <cstring>
#include <cstdlib>
#include <ctime>
using namespace std;
#define REP(i, j) for(int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for(int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef pair<int, int> P;
const int MAX_N = 5010;
const int MAX_M = 5 * 100010;
const int MAX_Y = MAX_N + MAX_M * 2;
const int MAX_W = MAX_N + MAX_M * 2;
int H, W, N, M, tsx[MAX_N], tsy[MAX_N];
vector<int> X, Y;
void init_number(){
set<int> Ys, Xs;
REP(i, N){ Xs.insert(tsx[i]); Ys.insert(tsy[i]); }
Ys.insert((1e9 + 10) * -1);
Ys.insert(1e9 + 10);
Xs.insert((1e9 + 10) * -1);
Xs.insert(1e9 + 10);
X = vector<int>(Xs.begin(), Xs.end());
Y = vector<int>(Ys.begin(), Ys.end());
W = X.size();
H = Y.size();
}
void init(vector< vector<int> > &v, vector< vector<int> > &E){
E[0][0] = v[0][0];
FOR(i, 1, H) E[i][0] = E[i - 1][0] + v[i][0];
FOR(i, 1, W) E[0][i] = E[0][i - 1] + v[0][i];
FOR(y, 1, H)
FOR(x, 1, W)
E[y][x] = v[y][x] + E[y - 1][x] + E[y][x - 1] - E[y - 1][x - 1];
}
int calc(int Y1, int X1, int Y2, int X2, vector< vector<int> > &E){
int ret = E[Y2][X2];
if(X1 - 1 >= 0) ret -= E[Y2][X1 - 1];
if(Y1 - 1 >= 0) ret -= E[Y1 - 1][X2];
if(X1 - 1 >= 0 && Y1 - 1 >= 0) ret += E[Y1 - 1][X1 - 1];
return ret;
}
int main() {
cin >>N >>M;
REP(i, N) cin >>tsx[i] >>tsy[i];
init_number();
vector< vector<int> > v(H, vector<int>(W, 0)), E(H, vector<int>(W, 0));
REP(i, N){
int y = lower_bound(Y.begin(), Y.end(), tsy[i]) - Y.begin();
int x = lower_bound(X.begin(), X.end(), tsx[i]) - X.begin();
v[y][x] += 1;
}
init(v, E);
REP(i, M){
int x1, y1, x2, y2; cin >>x1 >>y1 >>x2 >>y2;
x1 = lower_bound(X.begin(), X.end(), x1) - X.begin();
y1 = lower_bound(Y.begin(), Y.end(), y1) - Y.begin();
x2 = upper_bound(X.begin(), X.end(), x2) - X.begin() - 1;
y2 = upper_bound(Y.begin(), Y.end(), y2) - Y.begin() - 1;
cout <<calc(y1, x1, y2, x2, E) <<endl;
}
return 0;
} |
// iostream のscanf, printf では間に合わなかった
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
#define INF (1<<29)
#define mp make_pair
#define pb push_back
typedef pair<int,int> pii;
int main(){
int n, m;
cin >> n >> m;
vector<pii> treasure;
for( int i = 0; i < n; i++ ){
int x, y;
//cin >> x >> y;
scanf("%d %d", &x, &y);
treasure.pb( mp(x,y) );
}
sort(treasure.begin(), treasure.end());
for( int i = 0; i < m; i++ ){
int x1, y1, x2, y2;
//cin >> x1 >> y1 >> x2 >> y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
// search
int ans = 0;
vector<pii>::iterator it = lower_bound(treasure.begin(),treasure.end(),mp(x1,y1));
while( 1 ){
if( it == treasure.end() || *it > mp(x2,y2) ) break;
//if( (*it).first > x2 ) it = upper_bound(treasure.begin(), treasure.end(),mp(-INF,(*it).second+1));
if( x1 <= (*it).first && (*it).first <= x2 && y1 <= (*it).second && (*it).second <= y2 ) ans++;
it++;
}
//cout << ans << endl;
printf("%d\n", ans);
}
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pii = pair<int, int>;
int n, m;
vector<int> x, y;
vector<int> uzx, uzy;
map<int, int> zx, zy;
int cum[5010][5010];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(10);
cin >> n >> m;
x.resize(n);
y.resize(n);
uzx.resize(n);
uzy.resize(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
uzx[i] = x[i];
uzy[i] = y[i];
}
sort(uzx.begin(), uzx.end());
sort(uzy.begin(), uzy.end());
uzx.erase(unique(uzx.begin(), uzx.end()), uzx.end());
uzy.erase(unique(uzy.begin(), uzy.end()), uzy.end());
for (int i = 0; i < (int)uzx.size(); i++) {
zx[uzx[i]] = i;
}
for (int i = 0; i < (int)uzy.size(); i++) {
zy[uzy[i]] = i;
}
for (int i = 0; i < n; i++) {
int px = zx[x[i]] + 1;
int py = zy[y[i]] + 1;
cum[px][py]++;
}
for (int i = 0; i < 5010; i++) {
for (int j = 0; j < 5010; j++) {
if (j + 1 < 5010) cum[i][j + 1] += cum[i][j];
if (i) cum[i][j] += cum[i - 1][j];
}
}
for (int i = 0; i < m; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int ax = (lower_bound(uzx.begin(), uzx.end(), x1) - uzx.begin());
int ay = (lower_bound(uzy.begin(), uzy.end(), y1) - uzy.begin());
int bx = (upper_bound(uzx.begin(), uzx.end(), x2) - uzx.begin());
int by = (upper_bound(uzy.begin(), uzy.end(), y2) - uzy.begin());
cout << cum[bx][by] - cum[ax][by] - cum[bx][ay] + cum[ax][ay] << endl;
}
return 0;
}
|
#include<cstdio>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
#define fs first
#define sc second
#define MAX 1000000001
#define a(x) (x).begin(),(x).end()
#define pb push_back
int n,m;
int sum[5100][5100];
pair<int,int> p[5100];
vector<int> x,y;
int x1,y1,x2,y2;
int main(){
scanf("%d%d",&n,&m);
x.resize(n+2); y.resize(n+2);
for(int i=0;i<n;i++){
scanf("%d%d",&x[i],&y[i]);
p[i].fs = x[i]; p[i].sc = y[i];
}
x[n] = MAX; x[n+1] = -MAX;
y[n] = MAX; y[n+1] = -MAX;
sort(a(x)); sort(a(y));
x.erase(unique(a(x)),x.end()); y.erase(unique(a(y)),y.end());
for(int i=0;i<n;i++){
p[i].fs = lower_bound(a(x),p[i].fs) - x.begin();
p[i].sc = lower_bound(a(y),p[i].sc) - y.begin();
}
sort(p,p+n);
int cnt = 0;
for(int i=0;i<x.size();i++)
for(int j=0;j<y.size();j++){
if(!i || !j)sum[i][j] = 0;
else sum[i][j] = sum[i][j-1] + sum[i-1][j] - sum[i-1][j-1];
while(cnt<n && p[cnt].fs == i && p[cnt].sc == j){
sum[i][j]++; cnt++;
}
}
for(int i=0;i<m;i++){
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
x1 = lower_bound(a(x),x1)-x.begin()-1;
y1 = lower_bound(a(y),y1)-y.begin()-1;
x2 = upper_bound(a(x),x2)-x.begin()-1;
y2 = upper_bound(a(y),y2)-y.begin()-1;
printf("%d\n",sum[x2][y2] - sum[x2][y1] - sum[x1][y2] + sum[x1][y1]);
}
} |
#include<cstdio>
#include<set>
#include<map>
#include<vector>
#include<algorithm>
#define fst first
#define snd second
using namespace std;
typedef pair<int,int> pp;
typedef long long int lli;
multiset<pp> tr;
set<lli> xa, ya;
vector<lli> xv, yv;
int field[6000][6000];
int main(void) {
int n,m;
scanf("%d%d",&n,&m);
int ix=0, iy=0;
xa.insert(-2000000000);
xa.insert(+2000000000);
ya.insert(-2000000000);
ya.insert(+2000000000);
for(int i=0; i<n; i++) {
lli x,y;
scanf("%lld%lld",&x,&y);
xa.insert(x);
ya.insert(y);
tr.insert(pp(x,y));
}
for(lli x : xa)
xv.push_back(x);
for(lli y : ya)
yv.push_back(y);
field[0][0] = tr.count(pp(xv[0],yv[0]));
auto itx = ++xv.begin(), ity = ++yv.begin();
for(int i=1; i<xv.size(); i++,itx++)
field[i][0] = field[i-1][0] + tr.count(pp(*itx,yv[0]));
for(int i=1; i<yv.size(); i++,ity++)
field[0][i] = field[0][i-1] + tr.count(pp(xv[0],*ity));
itx = ++xv.begin();
for(int i=1; i<xv.size(); i++,itx++) {
ity = ++yv.begin();
for(int j=1; j<yv.size(); j++,ity++)
field[i][j] = -field[i-1][j-1] + field[i-1][j] + field[i][j-1] + tr.count(pp(*itx,*ity));
}
for(int i=0; i<m; i++) {
lli x1,y1,x2,y2;
scanf("%lld%lld%lld%lld",&x1,&y1,&x2,&y2);
int sx,sy,tx,ty;
sx = lower_bound(begin(xv), end(xv), x1)-begin(xv);
sy = lower_bound(begin(yv), end(yv), y1)-begin(yv);
tx = upper_bound(begin(xv), end(xv), x2)-begin(xv)-1;
ty = upper_bound(begin(yv), end(yv), y2)-begin(yv)-1;
//printf("%d - %d - %d + %d\n",field[tx][ty] , field[sx-1][ty] , field[tx][sy-1] , field[sx-1][sy-1]);
printf("%d\n",field[tx][ty] - field[sx-1][ty] - field[tx][sy-1] + field[sx-1][sy-1]);
}
return 0;
} |
#include<bits/stdc++.h>
#define s second
#define f first
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
int x,y,q,n,ty,tx;
pair<int,int> a[5000];
cin>>n>>q;
r(i,n)cin>>x>>y,a[i].f=x,a[i].s=y;
sort(a,a+n);
r(i,q){
cin>>x>>y>>tx>>ty;
int c=0;
r(i,n){
if(x<=a[i].f&&a[i].f<=tx&&y<=a[i].s&&a[i].s<=ty)c++;
if(tx<a[i].f)break;
}
cout<<c<<endl;
}
} |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
const int INF = 1e9+1;
int v[5002][5002] = {};
int main(){
int n, m;
scanf("%d %d", &n, &m);
vector<int> x(n), y(n);
for(int i = 0; i < n; i++){
scanf("%d %d", x.begin()+i, y.begin()+i);
}
vector<int> ax = x, ay = y;
ax.push_back(-INF); ax.push_back(INF);
ay.push_back(-INF); ay.push_back(INF);
sort(ax.begin(), ax.end());
ax.erase(unique(ax.begin(),ax.end()),ax.end());
sort(ay.begin(), ay.end());
ay.erase(unique(ay.begin(),ay.end()),ay.end());
int nx = ax.size(), ny = ay.size();
auto fx = [&](int val)->int{
return lower_bound(ax.begin(),ax.end(),val)-ax.begin();
};
auto fy = [&](int val)->int{
return lower_bound(ay.begin(), ay.end(), val)-ay.begin();
};
for(int i = 0; i < n; i++){
v[fx(x[i])][fy(y[i])]++;
}
for(int i = 0; i < nx; i++){
for(int j = 1; j < ny; j++){
v[i][j] += v[i][j-1];
}
}
for(int j = 0; j < ny; j++){
for(int i = 1; i < nx; i++){
v[i][j] += v[i-1][j];
}
}
auto get = [&](int lx, int rx, int ly, int ry)->int{
return v[rx][ry]-v[rx][ly-1]-v[lx-1][ry]+v[lx-1][ly-1];
};
for(int i = 0; i < m; i++){
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
cout << get(fx(a),fx(c+1)-1,fy(b),fy(d+1)-1) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
using P = pair<int, int>;
map<int, int> compress(vector<int> v) {
map<int, int> zip;
REP(i, v.size()) zip[v[i]] = -1;
int idx = 0;
for (auto& p : zip) p.second = idx++;
return zip;
}
int main() {
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
vector<P> ps(n);
REP(i, n) {
cin >> x[i] >> y[i];
ps[i] = {x[i], y[i]};
}
x.push_back(-1e9 - 1);
y.push_back(-1e9 - 1);
x.push_back(1e9 + 1);
y.push_back(1e9 + 1);
auto zx = compress(x);
auto zy = compress(y);
vector<int> xs, ys;
for (auto p : zx) xs.push_back(p.first);
for (auto p : zy) ys.push_back(p.first);
vector<vector<int>> imos(xs.size() + 1, vector<int>(ys.size() + 1, 0));
for (auto p : ps) imos[zx[p.first] + 1][zy[p.second] + 1]++;
REP(i, xs.size() + 1) REP(j, ys.size()) imos[i][j + 1] += imos[i][j];
REP(i, xs.size()) REP(j, ys.size() + 1) imos[i + 1][j] += imos[i][j];
REP(i, m) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int sx = distance(begin(xs), lower_bound(begin(xs), end(xs), x1));
int sy = distance(begin(ys), lower_bound(begin(ys), end(ys), y1));
int tx = distance(begin(xs), upper_bound(begin(xs), end(xs), x2));
int ty = distance(begin(ys), upper_bound(begin(ys), end(ys), y2));
int ans = 0;
ans += imos[sx][sy];
ans -= imos[tx][sy];
ans -= imos[sx][ty];
ans += imos[tx][ty];
cout << ans << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
#define rep(i,n) for(ll i=0;i<(ll)(n);i++)
#define all(a) (a).begin(),(a).end()
#define pb push_back
#define INF (1e9+1)
//#define INF (1LL<<59)
int main(){
int n,m;
cin>>n>>m;
set<int> posx;
vector<pii> v(n);
rep(i,n){
int x,y;
cin>>x>>y;
v[i] = pii(x,y);
posx.insert(x);
}
map<int,int> zip,unzip;
int c=0;
for(auto &e:posx){
zip[e] = c;
unzip[c] = e;
c++;
}
vector<vector<int>> r(posx.size());
rep(i,v.size()){
r[zip[v[i].first]].pb(v[i].second);
}
rep(i,r.size()-1){
rep(j,r[i].size()){
r[i+1].pb(r[i][j]);
}
}
rep(i,r.size())sort(all(r[i]));
rep(i,m){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
auto left = posx.lower_bound(x1);
auto right = posx.upper_bound(x2);
int sub=0,add=0;
if(left==posx.begin())sub=0;
else{
left--;
vector<int> &t = r[zip[*left]];
sub = (lower_bound(all(t),y1)-t.begin()) - (upper_bound(all(t),y2)-t.begin());
}
if(right==posx.begin())add=0;
else{
right--;
vector<int> &t = r[zip[*right]];
add = (lower_bound(all(t),y1)-t.begin()) - (upper_bound(all(t),y2)-t.begin());
}
cout<<sub-add<<endl;
}
} |
#include <iostream>
#include <algorithm>
#include <numeric>
#include <vector>
#include <cassert>
#include <string>
#include <memory.h>
#include <queue>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <map>
#include <cctype>
#include <iomanip>
#include <sstream>
#include <cctype>
#include <fstream>
#include <cmath>
using namespace std;
#define REP2(i, m, n) for(int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for(ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n) & 1)
typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;
const int sz = 5050;
int S[sz][sz];
inline int get_idx(const vector<int> &ix, int x){
return lower_bound(ALL(ix), x) - ix.begin();
}
int main(){
int n, m;
int x1, y1, x2, y2;
cin >> n >> m;
vector<int> x(n), y(n);
REP(i, n) cin >> x[i] >> y[i];
vector<int> ix = x;
vector<int> iy = y;
sort(ALL(ix));
sort(ALL(iy));
REP(i, n){
int X = get_idx(ix, x[i]);
int Y = get_idx(iy, y[i]);
S[X+1][Y+1]++;
}
REP(i, n)REP(j,n){
S[i+1][j+1] += S[i+1][j] + S[i][j+1] - S[i][j];
}
REP(i, m){
cin >> x1 >> y1 >> x2 >> y2;
x1 = get_idx(ix, x1);
x2 = get_idx(ix, x2 + 1);
y1 = get_idx(iy, y1);
y2 = get_idx(iy, y2 + 1);
cout << S[x2][y2] - S[x2][y1] - S[x1][y2] + S[x1][y1] << endl;
}
return 0;
} |
/*
* 2426.cc: Treasure Hunt
*/
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cmath>
#include<iostream>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<stack>
#include<list>
#include<queue>
#include<deque>
#include<algorithm>
#include<numeric>
#include<utility>
#include<complex>
#include<functional>
using namespace std;
/* constant */
const int MAX_N = 5000;
/* typedef */
typedef pair<int,int> pii;
typedef map<int,int> mii;
/* global variables */
int xs[MAX_N], ys[MAX_N], sums[MAX_N + 1][MAX_N + 1];
pii pts[MAX_N];
mii xmap, ymap;
/* subroutines */
/* main */
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> xs[i] >> ys[i];
pts[i] = pii(xs[i], ys[i]);
}
sort(xs, xs + n);
sort(ys, ys + n);
int xn = unique(xs, xs + n) - xs;
int yn = unique(ys, ys + n) - ys;
//printf("%d,%d\n", xn, yn);
for (int i = 0; i < xn; i++) xmap[xs[i]] = i;
for (int i = 0; i < yn; i++) ymap[ys[i]] = i;
for (int i = 0; i < n; i++)
sums[xmap[pts[i].first] + 1][ymap[pts[i].second] + 1]++;
for (int x = 1; x <= xn; x++)
for (int y = 1; y <= yn; y++) sums[x][y] += sums[x][y - 1];
for (int y = 1; y <= yn; y++)
for (int x = 1; x <= xn; x++) sums[x][y] += sums[x - 1][y];
//printf("%d\n", sums[xn][yn]);
while (m--) {
int x0, y0, x1, y1;
cin >> x0 >> y0 >> x1 >> y1;
int xi0 = lower_bound(xs, xs + xn, x0) - xs;
int yi0 = lower_bound(ys, ys + yn, y0) - ys;
int xi1 = upper_bound(xs, xs + xn, x1) - xs;
int yi1 = upper_bound(ys, ys + yn, y1) - ys;
int sum =
sums[xi1][yi1] - sums[xi1][yi0] - sums[xi0][yi1] + sums[xi0][yi0];
printf("%d\n", sum);
}
return 0;
} |
#ifndef ___Class_RangeTree
#define ___Class_RangeTree
// ------ Includes ------ //
#include <limits>
#include <vector>
#include <algorithm>
template<typename Type> class RangeTree {
private:
int size_; std::vector<std::vector<Type> > dat;
inline int query_(int a, int b, Type x, int k, int l, int r) {
// Find range [a, b) : value < x : Now k-th node and the range is [l, r)
if (r <= a || b <= l) return 0;
if (a <= l && r <= b) return lower_bound(dat[k].begin(), dat[k].end(), x) - dat[k].begin();
int lc = query_(a, b, x, k << 1, l, (l + r) >> 1);
int rc = query_(a, b, x, k << 1 | 1, (l + r) >> 1, r);
return lc + rc;
}
public:
RangeTree() : size_(0), dat(std::vector<Type>()) {};
template<class T>
RangeTree(T begin_, T end_) {
int n = (end_ - begin_);
for (size_ = 1; size_ < n; size_ <<= 1); dat.resize(size_ << 1, std::vector<Type>());
for (int i = 0; i < n; i++) dat[i + size_] = std::vector<Type>({ *(begin_ + i) });
for (int i = size_ - 1; i > 0; i--) {
dat[i].resize(dat[i << 1].size() + dat[i << 1 | 1].size());
int cl = 0;
for (int j = 0; j < dat[i].size(); j++) {
if (j - cl == dat[i << 1 | 1].size() || (cl != dat[i << 1].size() && dat[i << 1][cl] < dat[i << 1 | 1][j - cl])) {
dat[i][j] = dat[i << 1][cl++];
}
else {
dat[i][j] = dat[i << 1 | 1][j - cl];
}
}
}
}
inline int size() { return size_; }
inline int query(int l, int r, Type x) {
// Find range [a, b) : value < x
return query_(l, r, x, 1, 0, size_);
}
};
#endif
#include <cstdio>
#include <vector>
#pragma warning(disable : 4996)
using namespace std;
int N, Q, xl, yl, xr, yr;
int main() {
scanf("%d%d", &N, &Q);
vector<pair<int, int> > p(N);
for (int i = 0; i < N; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p.begin(), p.end());
vector<int> z1(N), z2(N);
for (int i = 0; i < N; i++) {
z1[i] = p[i].first;
z2[i] = p[i].second;
}
RangeTree<int> seg(z2.begin(), z2.end());
while (Q--) {
scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
int ptr1 = lower_bound(z1.begin(), z1.end(), xl) - z1.begin();
int ptr2 = lower_bound(z1.begin(), z1.end(), xr + 1) - z1.begin();
int res1 = seg.query(ptr1, ptr2, yl);
int res2 = seg.query(ptr1, ptr2, yr + 1);
printf("%d\n", res2 - res1);
}
return 0;
} |
#include<iostream>
#include<algorithm>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
int map[5002][5002];
int main() {
int n, m;
cin >> n >> m;
int x[n], y[n], xx[n + 2], yy[n + 2];
rep (i, n) cin >> x[i] >> y[i];
rep (i, n) xx[i] = x[i];
rep (i, n) yy[i] = y[i];
xx[n] = 2e9;
yy[n] = 2e9;
xx[n + 1] = -2e9;
yy[n + 1] = -2e9;
sort(xx, xx + n + 2);
sort(yy, yy + n + 2);
rep (i, n + 2) rep (j, n + 2) map[i][j] = 0;
rep (i, n) {
int nx, ny;
rep (j, n + 2) if (x[i] == xx[j]) nx = j;
rep (j, n + 2) if (y[i] == yy[j]) ny = j;
++map[ny][nx];
--map[n + 1][nx];
--map[ny][n + 1];
++map[n + 1][n + 1];
}
rep (i, n + 2) rep (j, n + 1) map[i][j + 1] += map[i][j];
rep (i, n + 1) rep (j, n + 2) map[i + 1][j] += map[i][j];
rep (i, m) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int xx1 = lower_bound(xx, xx + n + 2, x1) - xx - 1;
int yy1 = lower_bound(yy, yy + n + 2, y1) - yy - 1;
int xx2 = upper_bound(xx, xx + n + 2, x2) - xx - 1;
int yy2 = upper_bound(yy, yy + n + 2, y2) - yy - 1;
cout << map[yy2][xx2] - map[yy2][xx1] - map[yy1][xx2] + map[yy1][xx1] << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
struct CumulativeSum2D
{
vector< vector< int > > data;
CumulativeSum2D(int W, int H) : data(W + 1, vector< int >(H + 1, 0))
{
};
inline void add(int x, int y, int z)
{
++x, ++y;
if(x >= data.size() || y >= data[0].size()) return;
data[x][y] += z;
}
void build()
{
for(int i = 1; i < data.size(); i++) {
for(int j = 1; j < data[i].size(); j++) {
data[i][j] += data[i][j - 1] + data[i - 1][j] - data[i - 1][j - 1];
}
}
}
inline int query(int sx, int sy, int gx, int gy)
{
return (data[gx][gy] - data[sx][gy] - data[gx][sy] + data[sx][sy]);
}
};
int main()
{
int N, M, X[5000], Y[5000];
scanf("%d %d", &N, &M);
vector< int > xs(N), ys(N);
for(int i = 0; i < N; i++) {
scanf("%d %d", &X[i], &Y[i]);
xs[i] = X[i];
ys[i] = Y[i];
}
sort(begin(xs), end(xs));
xs.erase(unique(begin(xs), end(xs)), end(xs));
sort(begin(ys), end(ys));
ys.erase(unique(begin(ys), end(ys)), end(ys));
CumulativeSum2D sum(xs.size(), ys.size());
for(int i = 0; i < N; i++) {
sum.add(lower_bound(begin(xs), end(xs), X[i]) - begin(xs),
lower_bound(begin(ys), end(ys), Y[i]) - begin(ys), 1);
}
sum.build();
for(int i = 0; i < M; i++) {
int x1, y1, x2, y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
x1 = lower_bound(begin(xs), end(xs), x1) - begin(xs);
y1 = lower_bound(begin(ys), end(ys), y1) - begin(ys);
x2 = upper_bound(begin(xs), end(xs), x2) - begin(xs);
y2 = upper_bound(begin(ys), end(ys), y2) - begin(ys);
printf("%d\n", sum.query(x1, y1, x2, y2));
}
} |
#include <bits/stdc++.h>
#define REP(i,n) for(int i=0;i<(int)(n);i++)
using namespace std;
typedef int Data;
pair<vector<int>,vector<int>> compressor(vector<Data> c) {
int n = c.size();
vector<Data> v(c), w;
vector<int> res(n);
sort(v.begin(), v.end());
auto itr = unique(begin(v),end(v));
v.erase(itr,end(v));
REP(i,v.size()) w.push_back(v[i]);
REP(i,n) res[i] = lower_bound(w.begin(), w.end(), c[i]) - w.begin();
return make_pair(v,res);
}
int main() {
int n,m;
cin>>n>>m;
vector<int> x(n),y(n),x1(m),x2(m),y1(m),y2(m);
REP(i,n)
cin>>x[i]>>y[i];
REP(i,m)
cin>>x1[i]>>y1[i]>>x2[i]>>y2[i];
vector<int> xl;
vector<int> yl;
REP(i,n){
xl.push_back(x[i]);
yl.push_back(y[i]);
}
vector<int> cmpx,cmpy,sxl,syl;
tie(sxl, cmpx) = compressor(xl);
tie(syl, cmpy) = compressor(yl);
sxl.insert(begin(sxl),-1000000001);
syl.insert(begin(syl),-1000000001);
int w=sxl.size();
int h=syl.size();
vector<vector<int16_t>> t(h,vector<int16_t>(w));
REP(i,n)
++t[cmpy[i]][cmpx[i]];
vector<vector<int16_t>> t2(h+1,vector<int16_t>(w+1));
REP(i,h) {
vector<int16_t> t1(w+1);
partial_sum(begin(t[i]),end(t[i]),begin(t1)+1);
REP(j,w+1){
t2[i+1][j] = t2[i][j] + t1[j];
}
}
REP(i,m){
int xi1,yi1,xi2,yi2;
xi1=prev(lower_bound(begin(sxl),end(sxl),x1[i]))-begin(sxl);
yi1=prev(lower_bound(begin(syl),end(syl),y1[i]))-begin(syl);
xi2=prev(upper_bound(begin(sxl),end(sxl),x2[i]))-begin(sxl);
yi2=prev(upper_bound(begin(syl),end(syl),y2[i]))-begin(syl);
cout<<(t2[yi2][xi2]-t2[yi2][xi1]-t2[yi1][xi2]+t2[yi1][xi1])<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using VI = vector<ll>;
using VVI = vector<VI>;
using P = pair<ll, ll>;
int idx(VI v, ll k) { return lower_bound(v.begin(), v.end(), k) - v.begin(); }
int main(int argc, char const* argv[]) {
ll n, m;
cin >> n >> m;
vector<P> ts(n, make_pair(0, 0));
VI x(n), xs(n);
VI y(n), ys(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
xs[i] = x[i];
ys[i] = y[i];
}
sort(xs.begin(), xs.end());
xs.erase(unique(xs.begin(), xs.end()), xs.end());
sort(ys.begin(), ys.end());
ys.erase(unique(ys.begin(), ys.end()), ys.end());
VVI tbl = VVI(xs.size() + 2, VI(ys.size() + 2, 0));
for (int i = 0; i < n; i++) {
ll tx = idx(xs, x[i]);
ll ty = idx(ys, y[i]);
tbl[tx + 1][ty + 1]++;
}
for (int i = 0; i < xs.size(); i++) {
for (int j = 0; j < ys.size(); j++) {
tbl[i + 1][j + 1] += tbl[i + 1][j] + tbl[i][j + 1] - tbl[i][j];
}
}
for (int i = 0; i < m; i++) {
ll x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = idx(xs, x1); // ret === x1 の時k、小さい値が返る, x1 < retの時も実質そう
y1 = idx(ys, y1);
x2 = idx(xs, x2+1); // x2 == val の時 ret = idx(x2)+1 ,
y2 = idx(ys, y2+1);
cout << tbl[x2][y2] - tbl[x2][y1] - tbl[x1][y2] + tbl[x1][y1] << endl;
}
return 0;
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#include<climits>
using namespace std;
int main()
{
int n,m;
int x1,y1,x2,y2;
vector<int> x,y;
vector<int> ix,iy;
vector< vector<int> > dp;
cin>>n>>m;
x.resize(n);
y.resize(n);
for(int i=0; i<n; i++){
cin>>x[i]>>y[i];
ix.push_back(x[i]);
iy.push_back(y[i]);
}
ix.push_back(INT_MIN);
iy.push_back(INT_MIN);
sort(ix.begin(), ix.end());
sort(iy.begin(), iy.end());
ix.erase(unique(ix.begin(), ix.end()), ix.end());
iy.erase(unique(iy.begin(), iy.end()), iy.end());
dp.resize(iy.size(), vector<int>(ix.size(), 0));
for(int i=0; i<n; i++){
int ty = lower_bound(iy.begin(), iy.end(), y[i]) - iy.begin();
int tx = lower_bound(ix.begin(), ix.end(), x[i]) - ix.begin();
dp[ty][tx]++;
}
for(int i=1; i<iy.size(); i++){
for(int j=1; j<ix.size(); j++){
dp[i][j] += dp[i-1][j] + dp[i][j-1] - dp[i-1][j-1];
}
}
for(int i=0; i<m; i++){
cin>>x1>>y1>>x2>>y2;
int ix1,iy1,ix2,iy2;
iy1 = lower_bound(iy.begin(), iy.end(), y1) - iy.begin();
ix1 = lower_bound(ix.begin(), ix.end(), x1) - ix.begin();
iy2 = upper_bound(iy.begin(), iy.end(), y2) - iy.begin()-1;
ix2 = upper_bound(ix.begin(), ix.end(), x2) - ix.begin()-1;
cout<<dp[iy2][ix2]+dp[iy1-1][ix1-1]-dp[iy1-1][ix2]-dp[iy2][ix1-1]<<endl;
}
} |
#include <bits/stdc++.h>
// #define int long long
using namespace std;
using pii=pair<int,int>;
#define REPF(i,a,n) for(int i=(a);i<(int)(n);++i)
#define REP(i,n) REPF(i,0,n)
#define ALL(c) begin(c),end(c)
int sum[5100][5100];
signed main() {
int n,m;
cin>>n>>m;
vector<int> x(n),y(n);
vector<pii> p(n);
REP(i,n) {
cin>>p[i].first>>p[i].second;
x[i]=p[i].first;
y[i]=p[i].second;
}
sort(ALL(x));
x.erase(unique(ALL(x)),end(x));
sort(ALL(y));
y.erase(unique(ALL(y)),end(y));
auto get_x=[&](int i) {
return distance(begin(x),lower_bound(ALL(x),i));
};
auto get_y=[&](int i) {
return distance(begin(y),lower_bound(ALL(y),i));
};
REP(i,n) {
int xx=get_x(p[i].first);
int yy=get_y(p[i].second);
sum[xx][yy]++;
}
REP(i,5100) REPF(j,1,5100) sum[i][j]+=sum[i][j-1];
REP(j,5100) REPF(i,1,5100) sum[i][j]+=sum[i-1][j];
REP(i,m) {
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
int xx1=get_x(x1);
int yy1=get_y(y1);
int xx2=get_x(x2);
int yy2=get_y(y2);
if(find(ALL(x),x2)==end(x)) xx2--;
if(find(ALL(y),y2)==end(y)) yy2--;
if(xx2<xx1 || yy2<yy1) {
cout<<0<<endl;
continue;
}
int ans=sum[xx2][yy2];
if(xx1>0) {
ans-=sum[xx1-1][yy2];
}
if(yy1>0) {
ans-=sum[xx2][yy1-1];
}
if(xx1>0 && yy1>0) {
ans+=sum[xx1-1][yy1-1];
}
cout<<ans<<endl;
}
return 0;
} |
#include <vector>
#include <iostream>
#include <utility>
#include <algorithm>
#include <string>
#include <deque>
#include <tuple>
#include <queue>
#include <functional>
#include <cmath>
#include <iomanip>
#include <map>
#include <numeric>
#include <unordered_map>
//cin.sync_with_stdio(false);
//streambuf
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
using vi = vector<int>;
using vpii = vector<pii>;
#define ALL(a) a.begin(),a.end()
#define rep(i,a) for(int i=0;i<a;i++)
int sum[5002][5002];
int main() {
int n, m;
cin >> n >> m;
vpii pos(n);
vi x(n+1), y(n+1);
for (int i = 0; i < n; i++) {
int x1, y1;
cin >> x1 >> y1;
x[i] = x1;
y[i] = y1;
pos[i] = pii(x1, y1);
}
x.back() = -1e9 - 1;
y.back() = -1e9 - 1;
sort(ALL(x));
sort(ALL(y));
x.erase(unique(ALL(x)), x.end());
y.erase(unique(ALL(y)), y.end());
for (pii a : pos)sum[lower_bound(ALL(x), a.first) - x.begin()][lower_bound(ALL(y), a.second) - y.begin()]++;
rep(i, x.size()) {
rep(j, y.size()) {
sum[i][j] += -(i&&j ? sum[i - 1][j - 1] : 0) + (i ? sum[i - 1][j] : 0) + (j ? sum[i][j - 1] : 0);
}
}
for (int i = 0; i < m; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(ALL(x), x1) - x.begin() - 1;
y1 = lower_bound(ALL(y), y1) - y.begin() - 1;
x2 = upper_bound(ALL(x), x2) - x.begin() - 1;
y2 = upper_bound(ALL(y), y2) - y.begin() - 1;
cout << sum[x2][y2] - sum[x1][y2] - sum[x2][y1] + sum[x1][y1] << endl;
}
} |
#include <bits/stdc++.h>
#define ll long long
#define p pair<int, int>
using namespace std;
template <typename A, size_t N, typename T>
void Fill(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
int imos[5100][5100];
const int INF = 1e9 + 7;
int main() {
int n, m;
cin >> n >> m;
vector<int> x(n + 2), y(n + 2);
x[n] = INF, y[n] = INF;
x[n + 1] = -INF, y[n + 1] = -INF;
vector<int> xs(n), ys(n);
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
xs[i] = x[i];
ys[i] = y[i];
}
// 始点と終点を入れとく
sort(x.begin(), x.end());
sort(y.begin(), y.end());
x.erase(unique(x.begin(), x.end()), x.end());
y.erase(unique(y.begin(), y.end()), y.end());
for (int i = 0; i < n; i++) {
int nx = lower_bound(x.begin(), x.end(), xs[i]) - x.begin();
int ny = lower_bound(y.begin(), y.end(), ys[i]) - y.begin();
imos[ny + 1][nx + 1]++;
}
for (int i = 0; i < y.size(); i++) {
for (int j = 0; j < x.size(); j++) {
imos[i + 1][j + 1] += imos[i + 1][j] + imos[i][j + 1] - imos[i][j];
}
}
for (int i = 0; i < m; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(x.begin(), x.end(), x1) - x.begin();
y1 = lower_bound(y.begin(), y.end(), y1) - y.begin();
x2 = lower_bound(x.begin(), x.end(), x2 + 1) - x.begin();
y2 = lower_bound(y.begin(), y.end(), y2 + 1) - y.begin();
cout << imos[y2][x2] - imos[y2][x1] - imos[y1][x2] + imos[y1][x1] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
// macro
#define rep(i,n) for(i=0;i<n;i++)
#define ll long long
#define all(v) v.begin(), v.end()
// code starts
int main()
{
int n,m;cin>>n>>m;
vector<int> x(n);
vector<int> y(n);
int i,j;
rep(i,n)cin>>x[i]>>y[i];
vector<int> xl(m);
vector<int> yu(m);
vector<int> xr(m);
vector<int> yd(m);
rep(i,m)cin>>xl[i]>>yu[i]>>xr[i]>>yd[i];
vector<int> xpress;
vector<int> ypress;
xpress=x;
ypress=y;
sort(all(xpress));
sort(all(ypress));
auto itx=unique(all(xpress));
xpress.erase(itx,xpress.end());
auto ity=unique(all(ypress));
ypress.erase(ity,ypress.end());
int nx=xpress.size();
int ny=ypress.size();
vector<vector<int>> fld(ny,vector<int>(nx,0));
rep(i,n)
{
auto xind=lower_bound(all(xpress),x[i])-xpress.begin();
auto yind=lower_bound(all(ypress),y[i])-ypress.begin();
fld[yind][xind]++;
}
rep(i,ny)
{
rep(j,nx)
{
if(i-1>=0&&j-1>=0)
{
fld[i][j]+=fld[i-1][j]+fld[i][j-1]-fld[i-1][j-1];
}
else if(i-1>=0)
{
fld[i][j]+=fld[i-1][j];
}
else if(j-1>=0)
{
fld[i][j]+=fld[i][j-1];
}
}
}
rep(i,m)
{
int xlind=lower_bound(all(xpress),xl[i]-1)-xpress.begin();
int xrind=lower_bound(all(xpress),xr[i])-xpress.begin();
int yuind=lower_bound(all(ypress),yu[i]-1)-ypress.begin();
int ydind=lower_bound(all(ypress),yd[i])-ypress.begin();
if(!binary_search(all(xpress),xl[i]-1))xlind--;
if(!binary_search(all(xpress),xr[i]))xrind--;
if(!binary_search(all(ypress),yu[i]-1))yuind--;
if(!binary_search(all(ypress),yd[i]))ydind--;
int ans=0;
if(ydind>=0&&xrind>=0)ans+=fld[ydind][xrind];
if(yuind>=0&&xrind>=0)ans-=fld[yuind][xrind];
if(ydind>=0&&xlind>=0)ans-=fld[ydind][xlind];
if(yuind>=0&&xlind>=0)ans+=fld[yuind][xlind];
cout<<ans<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define fs first
#define sc second
#define mp make_pair
#define pb push_back
#define eb emplace_back
#define ALL(A) A.begin(),A.end()
#define RALL(A) A.rbegin(),A.rend()
typedef long long LL;
typedef pair<int,int> P;
const LL mod=998244353;
const LL LINF=1LL<<62;
const LL INF=1<<30;
int s[7000][7000];
int main(){
int n,m;cin >> n >> m;
vector<int> x(n),y(n);
vector<P> p;
int ss=1000;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
p.pb({x[i],y[i]});
}
sort(ALL(x));
sort(ALL(y));
for (int i = 0; i < n; i++) {
s[ss+lower_bound(ALL(x),p[i].fs)-x.begin()][ss+lower_bound(ALL(y),p[i].sc)-y.begin()]++;
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
s[ss+j+1][ss+i]+=s[ss+j][ss+i];
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
s[ss+i][ss+j+1]+=s[ss+i][ss+j];
}
}
for (int i = 0; i < m; i++) {
int a,b,c,d;cin >> a >> b >> c >> d;
a=lower_bound(ALL(x),a)-x.begin();
b=lower_bound(ALL(y),b)-y.begin();
c=upper_bound(ALL(x),c)-x.begin()-1;
d=upper_bound(ALL(y),d)-y.begin()-1;
cout << s[ss+c][ss+d]-s[ss+a-1][ss+d]-s[ss+c][ss+b-1]+s[ss+a-1][ss+b-1] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 1000;
const int BNUM = MAXN / B;
int n, m;
pair<int, int> ps[MAXN];
int x[MAXN], y[MAXN];
vector<int> bucket[BNUM];
int main() {
while(cin >> n >> m) {
for(int i = 0; i < n; ++i) {
cin >> ps[i].first >> ps[i].second;
}
sort(ps, ps+n);
fill(bucket, bucket + BNUM, vector<int>());
for(int i = 0; i < n; ++i) {
x[i] = ps[i].first;
y[i] = ps[i].second;
bucket[i/B].push_back(y[i]);
}
for(int b = 0; b < BNUM; ++b) {
sort(bucket[b].begin(), bucket[b].end());
}
while(m--) {
int s, t, u, v; cin >> s >> t >> u >> v;
int l = lower_bound(x, x+n, s) - x;
int r = upper_bound(x, x+n, u) - x;
int res = 0;
while(l < r && l % B != 0) {
res += (t <= y[l] && y[l] <= v);
++l;
}
while(l < r && r % B != 0) {
--r;
res += (t <= y[r] && y[r] <= v);
}
while(l < r) {
int b = l / B;
res += upper_bound(bucket[b].begin(), bucket[b].end(), v)
- lower_bound(bucket[b].begin(), bucket[b].end(), t);
l += B;
}
cout << res << endl;
}
}
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
vector<int> A(n*n, 0);
vector<int> x(n);
vector<int> y(n);
vector<int> xb(m);
vector<int> yb(m);
vector<int> xe(m);
vector<int> ye(m);
vector<int> xs;
vector<int> ys;
for(int j = 0; j < n; j++)
cin >> x[j] >> y[j];
for(int i = 0; i < m; i++)
cin >> xb[i] >> yb[i] >> xe[i] >> ye[i];
xs = x;
ys = y;
sort( xs.begin(), xs.end() );
sort( ys.begin(), ys.end() );
xs.erase( unique( xs.begin(), xs.end() ), xs.end() );
ys.erase( unique( ys.begin(), ys.end() ), ys.end() );
for(int j = 0; j < n; j++){
x[j] = find( xs.begin(), xs.end(), x[j] ) - xs.begin();
y[j] = find( ys.begin(), ys.end(), y[j] ) - ys.begin();
}
for(int i = 0; i < m; i++){
xb[i] = lower_bound( xs.begin(), xs.end(), xb[i] ) - xs.begin();
yb[i] = lower_bound( ys.begin(), ys.end(), yb[i] ) - ys.begin();
xe[i] = upper_bound( xs.begin(), xs.end(), xe[i] ) - xs.begin() - 1;
ye[i] = upper_bound( ys.begin(), ys.end(), ye[i] ) - ys.begin() - 1;
}
for(int j = 0; j < n; j++){
A[ n*y[j] + x[j] ] += 1;
}
for(int j = 0; j < n; j++){
for(int k = 1; k < n; k++){
A[n*j+k] += A[n*j+k-1];
}
}
for(int k = 0; k < n; k++){
for(int j = 1; j < n; j++){
A[n*j+k] += A[n*(j-1)+k];
}
}
for(int i = 0; i < m; i++){
if(xe[i] < 0 || ye[i] < 0 || xb[i] == (int)xs.size() || yb[i] == (int)ys.size()){
cout << 0 <<endl;
continue;
}
int a, b, c;
if(xb[i] > 0 && yb[i] > 0)
c = A[ n*(yb[i]-1) + (xb[i]-1) ];
else
c = 0;
if(xb[i] > 0)
a = A[ n*ye[i] + (xb[i]-1) ];
else
a = 0;
if(yb[i] > 0)
b = A[ n*(yb[i]-1) + xe[i] ];
else
b = 0;
cout << A[ n*ye[i] + xe[i] ] - a - b + c <<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 250;
const int BNUM = MAXN / B;
int n, m;
pair<int, int> ps[MAXN];
int x[MAXN], y[MAXN];
vector<int> bucket[BNUM];
int main() {
while(cin >> n >> m) {
for(int i = 0; i < n; ++i) {
cin >> ps[i].first >> ps[i].second;
}
sort(ps, ps+n);
fill(bucket, bucket + BNUM, vector<int>());
for(int i = 0; i < n; ++i) {
x[i] = ps[i].first;
y[i] = ps[i].second;
bucket[i/B].push_back(y[i]);
}
for(int b = 0; b < BNUM; ++b) {
sort(bucket[b].begin(), bucket[b].end());
}
while(m--) {
int s, t, u, v; cin >> s >> t >> u >> v;
int l = lower_bound(x, x+n, s) - x;
int r = upper_bound(x, x+n, u) - x;
int res = 0;
while(l < r && l % B != 0) {
res += (t <= y[l] && y[l] <= v);
++l;
}
while(l < r && r % B != 0) {
--r;
res += (t <= y[r] && y[r] <= v);
}
while(l < r) {
int b = l / B;
res += upper_bound(bucket[b].begin(), bucket[b].end(), v)
- lower_bound(bucket[b].begin(), bucket[b].end(), t);
l += B;
}
cout << res << endl;
}
}
return 0;
} |
#include<cstdio>
#include<vector>
#include<algorithm>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
const int INF=1000000001;
int main(){
int n,q; scanf("%d%d",&n,&q);
int x[5000],y[5000];
rep(i,n) scanf("%d%d",x+i,y+i);
vector<int> X(x,x+n),Y(y,y+n);
X.push_back(-INF); sort(X.begin(),X.end()); X.erase(unique(X.begin(),X.end()),X.end());
Y.push_back(-INF); sort(Y.begin(),Y.end()); Y.erase(unique(Y.begin(),Y.end()),Y.end());
static int dp[5001][5001];
rep(i,n){
dp[lower_bound(Y.begin(),Y.end(),y[i])-Y.begin()][lower_bound(X.begin(),X.end(),x[i])-X.begin()]++;
}
rep(i,5000) rep(j,5000) dp[i+1][j+1]+=dp[i+1][j]+dp[i][j+1]-dp[i][j];
while(q--){
int x1,y1,x2,y2; scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
x1=lower_bound(X.begin(),X.end(),x1)-X.begin();
y1=lower_bound(Y.begin(),Y.end(),y1)-Y.begin();
x2=upper_bound(X.begin(),X.end(),x2)-X.begin()-1;
y2=upper_bound(Y.begin(),Y.end(),y2)-Y.begin()-1;
printf("%d\n",dp[y2][x2]-dp[y2][x1-1]-dp[y1-1][x2]+dp[y1-1][x1-1]);
}
return 0;
} |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using int64 = int64_t;
int N, M;
int tx[5000], ty[5000];
int acc[5002][5002] = {};
int cx[5000], cy[5000];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (int j = 0; j < N; ++j) {
cin >> tx[j] >> ty[j];
}
// initialize
for (int j = 0; j <= N; ++j) fill(acc[j], acc[j]+N+1, 0);
copy(tx, tx+N, cx); sort(cx, cx+N);
copy(ty, ty+N, cy); sort(cy, cy+N);
for (int j = 0; j < N; ++j) {
int xx = lower_bound(cx, cx+N, tx[j]) - cx;
int yy = lower_bound(cy, cy+N, ty[j]) - cy;
++ acc[xx+1][yy+1];
}
for (int j = 1; j <= N; ++j) {
for (int k = 1; k <= N; ++k) {
acc[j][k] += acc[j-1][k] + acc[j][k-1] - acc[j-1][k-1];
}
}
for (int j = 0; j < M; ++j) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int ix1 = lower_bound(cx, cx+N, x1) - cx + 1;
int ix2 = upper_bound(cx, cx+N, x2) - cx;
int iy1 = lower_bound(cy, cy+N, y1) - cy + 1;
int iy2 = upper_bound(cy, cy+N, y2) - cy;
cout << acc[ix2][iy2] - acc[ix1-1][iy2] - acc[ix2][iy1-1] + acc[ix1-1][iy1-1] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> P3;
const ll MOD = 1000000007;
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(1e4 + 5);
const double EPS = 1e-11;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define ALL(v) (v).begin(), (v).end()
void compress(vector<int> &x, map<int, int> &zip) {
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
for (int i = 0; i < x.size(); i++) {
zip[x[i]] = i;
}
}
int n, m, a[5005][5005];
int main() {
cin >> n >> m;
vector<int> x(n), y(n);
vector<P> pos(n);
map<int,int> xzip, yzip;
REP(i,n){
cin >> x[i] >> y[i];
pos[i] = {x[i],y[i]};
}
x.push_back(-IINF);
x.push_back(IINF);
y.push_back(-IINF);
y.push_back(IINF);
compress(x,xzip);
compress(y,yzip);
REP(i,n){
int px = xzip[pos[i].first], py = yzip[pos[i].second];
a[py][px]++;
}
REP(i,yzip.size()){
REP(j,xzip.size()){
a[i+1][j+1] += a[i+1][j] + a[i][j+1] - a[i][j];
}
}
REP(i,m){
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(ALL(x),x1)-x.begin()-1;
x2 = upper_bound(ALL(x),x2)-x.begin()-1;
y1 = lower_bound(ALL(y),y1)-y.begin()-1;
y2 = upper_bound(ALL(y),y2)-y.begin()-1;
cout << a[y2][x2] - a[y2][x1] - a[y1][x2] + a[y1][x1] << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
using namespace std;
int n, q, xa, ya, xb, yb, x[5555], y[5555]; pair<int, int> p[5555];
int main() {
scanf("%d%d", &n, &q);
for(int i = 0; i < n; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p, p + n);
for(int i = 0; i < n; i++) x[i] = p[i].first, y[i] = p[i].second;
for(int i = 0; i < q; i++) {
scanf("%d%d%d%d", &xa, &ya, &xb, &yb);
int l = lower_bound(x, x + n, xa) - x;
int r = lower_bound(x, x + n, xb + 1) - x;
int c = 0;
for(int j = l; j < r; j++) {
if(ya <= y[j] && y[j] <= yb) c++;
}
printf("%d\n", c);
}
} |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
const int N = 5002;
int n, m, p_cnt[N][N], X[N], Y[N];
vector<int> vx, vy;
int conv(vector<int>& vec, int x){
return lower_bound(vec.begin(), vec.end(), x) - vec.begin();
}
int main(){
cin >> n >> m;
for(int i=0;i<n;i++){
cin >> X[i] >> Y[i];
vx.push_back(X[i]);
vy.push_back(Y[i]);
}
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
fill(p_cnt[0], p_cnt[N], 0);
for(int i=0;i<n;i++){
int x = conv(vx, X[i]);
int y = conv(vy, Y[i]);
p_cnt[y+1][x+1]++;
}
for(int i=0;i<vy.size()+2;i++){
for(int j=0;j<vx.size()+2;j++){
if(i == 0 && j == 0) continue;
else if(i == 0) p_cnt[i][j] += p_cnt[i][j-1];
else if(j == 0) p_cnt[i][j] += p_cnt[i-1][j];
else p_cnt[i][j] += p_cnt[i][j-1] + p_cnt[i-1][j] - p_cnt[i-1][j-1];
}
}
for(int i=0;i<m;i++){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = conv(vx, x1);
y1 = conv(vy, y1);
x2 = conv(vx, x2+1);
y2 = conv(vy, y2+1);
cout << p_cnt[y2][x2] - p_cnt[y2][x1] - p_cnt[y1][x2] + p_cnt[y1][x1] << endl;
}
} |
#include "iostream"
#include "climits"
#include "list"
#include "queue"
#include "stack"
#include "set"
#include "functional"
#include "algorithm"
#include "string"
#include "map"
#include "unordered_map"
#include "unordered_set"
#include "iomanip"
#include "cmath"
#include "random"
#include "bitset"
#include "cstdio"
#include "numeric"
#include "cassert"
#include "ctime"
using namespace std;
constexpr long long int MOD = 1000000007;
//constexpr int MOD = 1000000007;
//constexpr int MOD = 998244353;
//constexpr long long int MOD = 998244353;
constexpr double EPS = 1e-12;
//int N, M, K, T, H, W, L, R;
long long int N, M, K, T, H, W, L, R;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> M;
map<int, int>xp;
map<int, int>yp;
vector<int>x(N);
vector<int>y(N);
for (int i = 0; i < N; i++) {
cin >> x[i] >> y[i];
xp[x[i]] = 0;
yp[y[i]] = 0;
}
int cnt = 0;
xp[MOD] = yp[MOD] = xp[-MOD] = yp[-MOD] = 0;
for (auto &i : xp) {
i.second = cnt++;
}
cnt = 0;
for (auto &i : yp) {
i.second = cnt++;
}
H = yp.size(), W = xp.size();
vector<vector<int>>sum(H, vector<int>(W));
for (int i = 0; i < N; i++) {
sum[yp[y[i]]][xp[x[i]]]++;
}
for (int i = 0; i < H; i++) {
for (int j = 1; j < W; j++) {
sum[i][j] += sum[i][j - 1];
}
}
for (int i = 1; i < H; i++) {
for (int j = 0; j < W; j++) {
sum[i][j] += sum[i - 1][j];
}
}
//cout << H << " " << W << endl;
while (M--) {
cin >> L >> R;
int sx = xp.lower_bound(L)->second;
int sy = yp.lower_bound(R)->second;
cin >> L >> R;
int gx = xp.upper_bound(L)->second - 1;
int gy = yp.upper_bound(R)->second - 1;
// cout << sy << " " << sx << " " << gy << " " << gx << endl;
sy--, sx--;
cout << sum[gy][gx] - sum[gy][sx] - sum[sy][gx] + sum[sy][sx] << endl;
}
}
|
#include <iostream>
#include <sstream>
#include <cstdlib>
#include <cmath>
#include <map>
#include <set>
#include <queue>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <cstdio>
#include <numeric>
#include <bitset>
#include <stack>
#include <cstring>
using namespace std;
const int INF = 1 << 30;
const double EPS = 1e-10;
int main()
{
int n, m;
while (cin >> n >> m) {
vector<int> x(n), y(n);
set<int> sx, sy;
for (int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
sx.insert(x[i]);
sy.insert(y[i]);
}
vector<int> ix(1, -INF), iy(1, -INF);
for (set<int>::iterator it = sx.begin(); it != sx.end(); ++it)
ix.push_back(*it);
for (set<int>::iterator it = sy.begin(); it != sy.end(); ++it)
iy.push_back(*it);
vector<vector<int> > dp(iy.size(), vector<int>(ix.size(), 0));
for (int i = 0; i < n; ++i)
++dp[lower_bound(iy.begin(), iy.end(), y[i])-iy.begin()][lower_bound(ix.begin(), ix.end(), x[i])-ix.begin()];
for (unsigned int i = 0; i < dp.size(); ++i) {
for (unsigned int j = 1; j < dp[i].size(); ++j)
dp[i][j] += dp[i][j-1];
}
for (unsigned int i = 0; i < dp[0].size(); ++i) {
for (unsigned int j = 1; j < dp.size(); ++j)
dp[j][i] += dp[j-1][i];
}
while (m--) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int ix1 = upper_bound(ix.begin(), ix.end(), x2)-1-ix.begin();
int iy1 = upper_bound(iy.begin(), iy.end(), y2)-1-iy.begin();
int ix2 = upper_bound(ix.begin(), ix.end(), x1-1)-1-ix.begin();
int iy2 = upper_bound(iy.begin(), iy.end(), y1-1)-1-iy.begin();
int ix3 = upper_bound(ix.begin(), ix.end(), x1-1)-1-ix.begin();
int iy3 = upper_bound(iy.begin(), iy.end(), y2)-1-iy.begin();
int ix4 = upper_bound(ix.begin(), ix.end(), x2)-1-ix.begin();
int iy4 = upper_bound(iy.begin(), iy.end(), y1-1)-1-iy.begin();
cout << dp[max(0, iy1)][max(0, ix1)] + dp[max(0, iy2)][max(0, ix2)] - dp[max(0, iy3)][max(0, ix3)] - dp[max(0, iy4)][max(0, ix4)] << endl;
}
}
return 0;
} |
#include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <cmath>
#include <string>
#include <vector>
#include <list>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <bitset>
#include <numeric>
#include <climits>
#include <cfloat>
using namespace std;
template <class T>
class cumulativeSum
{
int ny, nx;
vector<vector<T> > sum;
public:
cumulativeSum(const vector<vector<T> >& a)
{
ny = a.size();
nx = a[0].size();
sum.assign(ny+1, vector<T>(nx+1, 0));
for(int i=0; i<ny; ++i){
for(int j=0; j<nx; ++j){
sum[i+1][j+1] = a[i][j] + sum[i][j+1] + sum[i+1][j] - sum[i][j];
}
}
}
T getSum(int y1, int x1, int y2, int x2)
{
if(y1 > y2 || x1 > x2)
return 0;
y1 = max(y1, 0);
x1 = max(x1, 0);
y2 = min(y2, ny-1);
x2 = min(x2, nx-1);
return sum[y2+1][x2+1] - sum[y1][x2+1] - sum[y2+1][x1] + sum[y1][x1];
}
};
int main()
{
int n, m;
cin >> n >> m;
vector<int> y(n), x(n);
map<int, int> yIndex, xIndex;
yIndex[-1];
xIndex[-1];
yIndex[INT_MAX/2];
xIndex[INT_MAX/2];
for(int i=0; i<n; ++i){
cin >> x[i] >> y[i];
yIndex[y[i]];
xIndex[x[i]];
}
int h = 0;
for(map<int, int>::iterator it=yIndex.begin(); it!=yIndex.end(); ++it){
it->second = h;
++ h;
}
int w = 0;
for(map<int, int>::iterator it=xIndex.begin(); it!=xIndex.end(); ++it){
it->second = w;
++ w;
}
vector<vector<int> > treasure(h, vector<int>(w, 0));
for(int i=0; i<n; ++i){
int y2 = yIndex[y[i]];
int x2 = xIndex[x[i]];
++ treasure[y2][x2];
}
cumulativeSum<int> cs(treasure);
for(int i=0; i<m; ++i){
int y1, x1, y2, x2;
cin >> x1 >> y1 >> x2 >> y2;
y1 = yIndex.lower_bound(y1)->second;
x1 = xIndex.lower_bound(x1)->second;
y2 = (--yIndex.upper_bound(y2))->second;
x2 = (--xIndex.upper_bound(x2))->second;
cout << cs.getSum(y1, x1, y2, x2) << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
int main(){
int n, m, x, y, xx, yy, ans;
std::cin >> n >> m;
vector<pii> t(n + 1);
t[n].first = t[n].second = 1e9 + 7;
for (int i = 0; i < n; i++) {
scanf("%d %d", &t[i].first, &t[i].second);
}
sort(t.begin(), t.end());
for (int i = 0; i < m; i++) {
ans = 0;
scanf("%d %d %d %d", &x, &y, &xx, &yy);
for (int j = 0; j < n; j++) {
if(x <= t[j].first and t[j].first <= xx){
if(y <= t[j].second and t[j].second <= yy)ans++;
}else if(x < t[j].first){
break;
}
}
printf("%d\n", ans);
}
return 0;
} |
#include <stdio.h>
#include <stdlib.h>
typedef struct pair{
int x;
int y;
}pair;
int cmpx(const void *a,const void *b){
pair *c1 = (pair *)a;
pair *c2 = (pair *)b;
return c1->x - c2->x;
}
int main(void){
int sx,sy,gx,gy, n, m, count, i, j;
pair t[5000];
scanf("%d%d",&n,&m);
for(i = 0;i < n;i++)
scanf("%d%d",&t[i].x,&t[i].y);
qsort(t,n,sizeof(t[0]),cmpx);
for(i = 0;i < m;i++){
scanf("%d%d%d%d",&sx,&sy,&gx,&gy);
count = 0;
for(j = 0;j < n && t[j].x <= gx;j++)
if(sx <= t[j].x && sy <= t[j].y && gx >= t[j].x && gy >= t[j].y) count++;
printf("%d\n",count);
}
return 0;
} |
#include<bits/stdc++.h>
#define rep(i,n)for(int i=0;i<(n);i++)
using namespace std;
typedef pair<int, int>P;
P p[5000];
vector<int>dat[50000];
void init(int k, int l, int r) {
if (r - l == 1) {
dat[k].push_back(p[l].second); return;
}
int lb = k * 2 + 1, rb = k * 2 + 2;
init(lb, l, (l + r) / 2);
init(rb, (l + r) / 2, r);
dat[k].resize(r - l);
merge(dat[lb].begin(), dat[lb].end(), dat[rb].begin(), dat[rb].end(), dat[k].begin());
}
int query(int a, int b, int c, int d, int k, int l, int r) {
if (b <= l || r <= a)return 0;
if (a <= l&&r <= b) {
int u = upper_bound(dat[k].begin(), dat[k].end(), d) - dat[k].begin();
int v = upper_bound(dat[k].begin(), dat[k].end(), c - 1) - dat[k].begin();
return u - v;
}
int lb = query(a, b, c, d, k * 2 + 1, l, (l + r) / 2);
int rb = query(a, b, c, d, k * 2 + 2, (l + r) / 2, r);
return lb + rb;
}
int main() {
int n, q; scanf("%d%d", &n, &q);
rep(i, n)scanf("%d%d", &p[i].first, &p[i].second);
sort(p, p + n); init(0, 0, n);
rep(i, q) {
int sx, tx, sy, ty; scanf("%d%d%d%d", &sx, &sy, &tx, &ty);
int a = lower_bound(p, p + n, P(sx, INT_MIN)) - p;
int b = lower_bound(p, p + n, P(tx, INT_MAX)) - p;
printf("%d\n", query(a, b, sy, ty, 0, 0, n));
}
} |
// iostream のscanf, printf では間に合わなかった
#include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
#define INF (1<<29)
#define mp make_pair
#define pb push_back
typedef pair<int,int> pii;
int main(){
int n, m;
cin >> n >> m;
vector<pii> treasure;
for( int i = 0; i < n; i++ ){
int x, y;
//cin >> x >> y;
scanf("%d %d", &x, &y);
treasure.pb( mp(x,y) );
}
sort(treasure.begin(), treasure.end());
for( int i = 0; i < m; i++ ){
int x1, y1, x2, y2;
//cin >> x1 >> y1 >> x2 >> y2;
scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
// search
int ans = 0;
vector<pii>::iterator it = lower_bound(treasure.begin(),treasure.end(),mp(x1,y1));
vector<pii>::iterator ite = upper_bound(treasure.begin(),treasure.end(),mp(x2,y2));
while( 1 ){
if( it == ite ) break;
if( x1 <= (*it).first && (*it).first <= x2 && y1 <= (*it).second && (*it).second <= y2 ) ans++;
it++;
}
//cout << ans << endl;
printf("%d\n", ans);
}
} |
#include "bits/stdc++.h"
#include<unordered_map>
#pragma warning(disable:4996)
using namespace std;
const int My_Inf=2147483647;
const long long int My_LInf=9223372036854775807;
int num[5001][5001];
int sum[5001][5001];
int main() {
memset(num, 0, sizeof(num));
memset(sum, 0, sizeof(num));
int N, M; cin >> N >> M;
vector<pair<int, int>>tres;
vector<int>xs, ys;
for (int i = 0; i < N; ++i) {
int x, y; cin >> x >> y;
tres.push_back(make_pair(x, y));
xs.push_back(x);
ys.push_back(y);
}
sort(xs.begin(), xs.end());
xs.resize(unique(xs.begin(), xs.end()) - xs.begin());
sort(ys.begin(), ys.end());
ys.resize(unique(ys.begin(), ys.end()) - ys.begin());
for (int i = 0; i < N; ++i) {
tres[i].first = lower_bound(xs.begin(), xs.end(), tres[i].first) - xs.begin();
tres[i].second = lower_bound(ys.begin(), ys.end(), tres[i].second) - ys.begin();
}
for (int i = 0; i < N; ++i) {
num[tres[i].first][tres[i].second]++;
}
for (int i = 0; i < 5000; ++i) {
for (int j = 0; j < 5000; ++j) {
sum[i + 1][j + 1] = sum[i + 1][j] + sum[i][j + 1] - sum[i][j] + num[i][j];
}
}
for (int i = 0; i < M; ++i) {
int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(xs.begin(), xs.end(), x1) - xs.begin();
x2 = upper_bound(xs.begin(), xs.end(), x2) - xs.begin();
y1 = lower_bound(ys.begin(), ys.end(), y1) - ys.begin();
y2 = upper_bound(ys.begin(), ys.end(), y2) - ys.begin();
int ans = sum[x2][y2] - sum[x2][y1] - sum[x1][y2] + sum[x1][y1];
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG_MODE
#define DBG(n) n;
#else
#define DBG(n) ;
#endif
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define rep(i,s,g) for(ll (i) = (s);(i) < (g);++i)
#define rrep(i,s,g) for(ll (i) = (s);i >= (g);--(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
int main(){
int n,m;cin >> n >> m;
vector<pair<int,int>> v;
REP(i,n){
int a,b;
scanf("%d %d",&a,&b);
v.PB(MP(a,b));
}
sort(ALL(v));
int a,b,c,d;
int ans;
REP(i,m){
scanf("%d %d %d %d",&a,&b,&c,&d);
int st = (lower_bound(ALL(v),MP(a,-1000000000)) - v.begin());
ans = 0;
for(int i = st;i < n;i++){
if(v[i].FI > c)break;
if(v[i].SE >= b && v[i].SE <= d)ans++;
}
printf("%d\n",ans);
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <numeric>
#include <bitset>
#include <cmath>
static const int MOD = 1000000007;
using ll = long long;
using u32 = uint32_t;
using namespace std;
template<class T> constexpr T INF = ::numeric_limits<T>::max() / 32 * 15 + 208;
int main() {
int n, m;
cin >> n >> m;
vector<int> xs(n), ys(n);
for (int i = 0; i < n; ++i) {
cin >> xs[i] >> ys[i];
}
auto zx = xs, zy = ys;
sort(zx.begin(), zx.end());
zx.erase(unique(zx.begin(), zx.end()), zx.end());
sort(zy.begin(), zy.end());
zy.erase(unique(zy.begin(), zy.end()), zy.end());
int h = zy.size(), w = zx.size();
vector<vector<int>> v(h+1, vector<int> (w+1));
auto fy = [&zy](int y){ return lower_bound(zy.begin(),zy.end(), y) - zy.begin(); };
auto fx = [&zx](int x){ return lower_bound(zx.begin(),zx.end(), x) - zx.begin(); };
for (int i = 0; i < n; ++i) {
v[fy(ys[i])+1][fx(xs[i])+1]++;
}
for (int i = 0; i <= h; ++i) {
for (int j = 0; j <= w; ++j) {
if(i) v[i][j] += v[i-1][j];
if(j) v[i][j] += v[i][j-1];
if(i && j) v[i][j] -= v[i-1][j-1];
}
}
for (int i = 0; i < m; ++i) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
x1 = fx(x1), x2 = fx(x2+1), y1 = fy(y1), y2 = fy(y2+1);
printf("%d\n", v[y2][x2]-v[y2][x1]-v[y1][x2]+v[y1][x1]);
}
return 0;
}
|
// Enjoy your stay.
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it,X) for(auto it=(X).begin();it!=(X).end();it++)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i,n) rep2(i,0,n)
#define rep2(i,m,n) for(int i=m;i<(n);i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<ll,ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
int n,m,y[5555],x[5555];
int sum[5555][5555];
vi zy,zx;
int f(int Y,int X){
return sum[upper_bound(zy.begin(),zy.end(),Y)-zy.begin()]
[upper_bound(zx.begin(),zx.end(),X)-zx.begin()];
}
int main(){
cin.tie(0);
ios_base::sync_with_stdio(0);
cin>>n>>m;
rep(i,n){
cin>>y[i]>>x[i];
zy.pb(y[i]);
zx.pb(x[i]);
}
zy.pb(INF);zx.pb(INF);
sort(zy.begin(),zy.end());
sort(zx.begin(),zx.end());
rep(i,n){
sum[upper_bound(zy.begin(),zy.end(),y[i])-zy.begin()]
[upper_bound(zx.begin(),zx.end(),x[i])-zx.begin()]++;
}
rep2(i,1,sz(zy)+1)rep2(j,1,sz(zx)+1){
sum[i][j] += sum[i-1][j] + sum[i][j-1] - sum[i-1][j-1];
}
rep(i,m){
int y1,x1,y2,x2;
cin>>y1>>x1>>y2>>x2;
cout<<f(y2,x2) - f(y1-1,x2) - f(y2,x1-1) + f(y1-1,x1-1)<<endl;
}
} |
#include<stdio.h>
#include<limits.h>
#include<vector>
#include<algorithm>
using namespace std;
struct P{int x,y;P(int x,int y):x(x),y(y){}P(){}};
vector<int>pressX,pressY;
const int C=5120;
short treasure[C][C]={};
P Compress(int x,int y)
{
return P( upper_bound(pressX.begin(),pressX.end(),x)-pressX.begin()-1,
upper_bound(pressY.begin(),pressY.end(),y)-pressY.begin()-1);
}
int CountPoint(int x,int y)
{
P p=Compress(x,y);
return treasure[p.y][p.x];
}
int CountArea(int x1,int x2, int y1, int y2)
{
int lu=CountPoint(x1-1,y1-1);
int ru=CountPoint(x2,y1-1);
int ld=CountPoint(x1-1,y2);
int rd=CountPoint(x2,y2);
//printf("x1:%d y1:%d x2:%d y2:%d 左上;%d 右上:%d 左下:%d 右下:%d\n",x1,y1,x2,y2,lu,ru,ld,rd);
return rd+lu-ru-ld;
}
int main()
{
int n,m,i,j,x[5000],y[5000];
scanf("%d%d",&n,&m);
pressX.reserve(n+2);
pressY.reserve(n+2);
for(i=0;i<n;++i)
{
scanf("%d%d",x+i,y+i);
pressX.push_back(x[i]);
pressY.push_back(y[i]);
}
pressX.push_back(INT_MAX);
pressX.push_back(INT_MIN);
pressY.push_back(INT_MAX);
pressY.push_back(INT_MIN);
sort(pressX.begin(),pressX.end());
sort(pressY.begin(),pressY.end());
for(i=0; i<n; ++i)
{
P p=Compress(x[i],y[i]);
++treasure[p.y][p.x];
}
for(i=1; i<C; ++i)
{
treasure[i][0]+=treasure[i-1][0];
treasure[0][i]+=treasure[0][i-1];
}
for(i=1; i<C; ++i)
for(j=1; j<C; ++j)
treasure[i][j] += treasure[i][j-1]+treasure[i-1][j]-treasure[i-1][j-1];
int x1,x2,y1,y2;
while(m--)
{
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
printf("%d\n",CountArea(x1,x2,y1,y2));
}
return 0;
} |
#include "bits/stdc++.h"
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2426&lang=jp
using namespace std;
typedef pair<int, int> pii;
int main() {
cin.tie(0); ios::sync_with_stdio(false);
int n, m; cin >> n >> m;
vector<int> treasure_x(n), x(n);
vector<int> treasure_y(n), y(n);
for (int i = 0; i < n;i++) {
cin >> treasure_x[i] >> treasure_y[i];
x[i] = treasure_x[i]; y[i] = treasure_y[i];
}
sort(x.begin(), x.end()); sort(y.begin(), y.end());
x.erase(unique(x.begin(), x.end()), x.end());
y.erase(unique(y.begin(), y.end()), y.end());
vector<vector<int>> dp(n + 2, vector<int>(n + 2, 0));
for (int i = 0; i < n;i++) {
int xind = lower_bound(x.begin(), x.end(), treasure_x[i]) - x.begin();
int yind = lower_bound(y.begin(), y.end(), treasure_y[i]) - y.begin();
dp[xind+1][yind+1]++;
}
for (int i = 0; i < n;i++) {
for (int j = 0; j < n;j++) {
dp[i + 1][j + 1] += dp[i][j + 1] + dp[i + 1][j] - dp[i][j];
}
}
for (int i = 0; i < m;i++) {
int ans = 0;
int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
int x1ind = lower_bound(x.begin(), x.end(), x1) - x.begin();
int y1ind = lower_bound(y.begin(), y.end(), y1) - y.begin();
int x2ind = lower_bound(x.begin(), x.end(), x2+1) - x.begin();
int y2ind = lower_bound(y.begin(), y.end(), y2+1) - y.begin();
cout << dp[x2ind][y2ind] - dp[x2ind][y1ind] - dp[x1ind][y2ind] + dp[x1ind][y1ind] << endl;
}
} |
#include<bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pair<int, int> > vii;
#define rrep(i, m, n) for(int (i)=(m); (i)<(n); (i)++)
#define erep(i, m, n) for(int (i)=(m); (i)<=(n); (i)++)
#define rep(i, n) for(int (i)=0; (i)<(n); (i)++)
#define rrev(i, m, n) for(int (i)=(n)-1; (i)>=(m); (i)--)
#define erev(i, m, n) for(int (i)=(n); (i)>=(m); (i)--)
#define rev(i, n) for(int (i)=(n)-1; (i)>=0; (i)--)
#define vrep(i, c) for(__typeof((c).begin())i=(c).begin(); i!=(c).end(); i++)
#define ALL(v) (v).begin(), (v).end()
#define pb push_back
template<class T, class S> inline pair<T, S> mp(const T x, const S y){ return make_pair(x, y); }
template<class T, class S> inline bool minup(T& m, const S x){ return m>(T)x ? (m=(T)x, true) : false; }
template<class T, class S> inline bool maxup(T& m, const S x){ return m<(T)x ? (m=(T)x, true) : false; }
static const int INF = 2000000000;
static const ll MOD = 1000000007LL;
static const double EPS = 1E-10;
int n, m;
int sx, sy;
int tx, ty;
int vx[5555];
int vy[5555];
int maze[5555][5555];
int main()
{
cin >> n >> m;
rep(i, n) cin >> vx[i] >> vy[i];
vi x, y;
rep(i, n){
x.pb(vx[i]);
y.pb(vy[i]);
}
sort(ALL(x)); x.erase(unique(ALL(x)), x.end());
sort(ALL(y)); y.erase(unique(ALL(y)), y.end());
rep(i, n){
vx[i] = lower_bound(ALL(x), vx[i]) - x.begin();
vy[i] = lower_bound(ALL(y), vy[i]) - y.begin();
}
rep(i, n) maze[vx[i] + 1][vy[i] + 1] += 1;
rep(i, n + 1) rep(j, n) maze[i][j + 1] += maze[i][j];
rep(i, n) rep(j, n + 1) maze[i + 1][j] += maze[i][j];
rep(i, m){
cin >> sx >> sy >> tx >> ty;
tx += 1;
ty += 1;
ll ret = 0;
int lx = lower_bound(ALL(x), tx) - x.begin();
int ly = lower_bound(ALL(y), ty) - y.begin();
int rx = lower_bound(ALL(x), sx) - x.begin();
int ry = lower_bound(ALL(y), sy) - y.begin();
ret += maze[lx][ly];
ret += maze[rx][ry];
ret -= maze[rx][ly];
ret -= maze[lx][ry];
cout << ret << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 700;
const int BNUM = MAXN / B;
int n, m;
pair<int, int> ps[MAXN];
int x[MAXN], y[MAXN];
vector<int> bucket[BNUM];
int main() {
while(scanf("%d%d", &n, &m) != EOF) {
for(int i = 0; i < n; ++i) {
scanf("%d%d", &ps[i].first, &ps[i].second);
}
sort(ps, ps+n);
fill(bucket, bucket + BNUM, vector<int>());
for(int i = 0; i < n; ++i) {
x[i] = ps[i].first;
y[i] = ps[i].second;
bucket[i/B].push_back(y[i]);
}
for(int b = 0; b < BNUM; ++b) {
sort(bucket[b].begin(), bucket[b].end());
}
while(m--) {
int s, t, u, v;
scanf("%d%d%d%d", &s, &t, &u, &v);
int l = lower_bound(x, x+n, s) - x;
int r = upper_bound(x, x+n, u) - x;
int res = 0;
while(l < r && l % B != 0) {
res += (t <= y[l] && y[l] <= v);
++l;
}
while(l < r && r % B != 0) {
--r;
res += (t <= y[r] && y[r] <= v);
}
while(l < r) {
int b = l / B;
res += upper_bound(bucket[b].begin(), bucket[b].end(), v)
- lower_bound(bucket[b].begin(), bucket[b].end(), t);
l += B;
}
printf("%d\n", res);
}
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int n,m;
int ix[5000],iy[5000];
int sum[5005][5005];
int main()
{
cin>>n>>m;
vector<int>x,y;
for(int i=0;i<n;i++)
{
cin>>ix[i]>>iy[i];
x.push_back(ix[i]);
y.push_back(iy[i]);
}
sort(x.begin(),x.end());x.erase(unique(x.begin(),x.end()),x.end());
sort(y.begin(),y.end());y.erase(unique(y.begin(),y.end()),y.end());
for(int i=0;i<n;i++)
{
int X=lower_bound(x.begin(),x.end(),ix[i])-x.begin();
int Y=lower_bound(y.begin(),y.end(),iy[i])-y.begin();
sum[X+1][Y+1]++;
}
for(int i=0;i<=x.size();i++)
{
for(int j=0;j<y.size();j++)sum[i][j+1]+=sum[i][j];
}
for(int j=0;j<=y.size();j++)
{
for(int i=0;i<x.size();i++)sum[i+1][j]+=sum[i][j];
}
for(int i=0;i<m;i++)
{
int xl,yl,xr,yr;
cin>>xl>>yl>>xr>>yr;
xl=lower_bound(x.begin(),x.end(),xl)-x.begin();
yl=lower_bound(y.begin(),y.end(),yl)-y.begin();
xr=upper_bound(x.begin(),x.end(),xr)-x.begin();
yr=upper_bound(y.begin(),y.end(),yr)-y.begin();
cout<<sum[xr][yr]-sum[xr][yl]-sum[xl][yr]+sum[xl][yl]<<endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
#define REP(i,m,n) for(int i=(m);i<(n);i++)
#define rep(i,n) REP(i,0,n)
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(),(c).end()
#define rall(c) (c).rbegin(),(c).rend()
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const ll inf=1e9+7;
const ll mod=998244353;
int main(){
ll n,m;cin>>n>>m;
vector<ll>x(n);
vector<ll>y(n);
set<ll>xx;
set<ll>yy;
rep(i,n){
cin>>x[i]>>y[i];
xx.insert(x[i]);
yy.insert(y[i]);
}
xx.insert(inf);
yy.insert(inf);
xx.insert(-inf);
yy.insert(-inf);
ll h=xx.size();
ll w=yy.size();
vector<vector<ll> >g(h+2,vector<ll>(w+2));
ll i=0;
map<ll,ll>mpx;
map<ll,ll>mpy;
for(auto e:xx){
mpx[e]=i;
i++;
}
i=0;
for(auto e:yy){
mpy[e]=i;
i++;
}
rep(i,n){
g[mpx[x[i]]][mpy[y[i]]]++;
}
REP(i,1,h+1){
REP(j,1,w+1){
g[i][j]+=g[i][j-1];
}
}
REP(i,1,h+1){
REP(j,1,w+1){
g[i][j]+=g[i-1][j];
}
}
//cout<<endl;
REP(i,1,h+1){
REP(j,1,w+1){
//cout<<g[i][j]<<' ';
}
//cout<<endl;
}
rep(i,m){
ll a,b,c,d;
cin>>a>>b>>c>>d;
ll A=mpx[*xx.lower_bound(a)];
ll B=mpy[*yy.lower_bound(b)];
ll C=mpx[*xx.upper_bound(c)];
ll D=mpy[*yy.upper_bound(d)];
C--;
D--;
//cout<<A<<' '<<B<<' '<<C<<' '<<D<<endl;
cout<<g[C][D]+g[A-1][B-1]-g[A-1][D]-g[C][B-1]<<endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#ifdef DEBUG_MODE
#define DBG(n) n;
#else
#define DBG(n) ;
#endif
#define REP(i,n) for(ll (i) = (0);(i) < (n);++i)
#define rep(i,s,g) for(ll (i) = (s);(i) < (g);++i)
#define rrep(i,s,g) for(ll (i) = (s);i >= (g);--(i))
#define PB push_back
#define MP make_pair
#define FI first
#define SE second
#define SHOW1d(v,n) {for(int W = 0;W < (n);W++)cerr << v[W] << ' ';cerr << endl << endl;}
#define SHOW2d(v,i,j) {for(int aaa = 0;aaa < i;aaa++){for(int bbb = 0;bbb < j;bbb++)cerr << v[aaa][bbb] << ' ';cerr << endl;}cerr << endl;}
#define ALL(v) v.begin(),v.end()
#define Decimal fixed<<setprecision(20)
#define INF 1000000000
#define MOD 1000000007
typedef long long ll;
typedef pair<ll,ll> P;
int main(){
int n,m;cin >> n >> m;
vector<pair<int,int>> v;
REP(i,n){
int a,b;
scanf("%d %d",&a,&b);
v.PB(MP(a,b));
}
sort(ALL(v));
int a,b,c,d;
int ans;
REP(i,m){
scanf("%d %d %d %d",&a,&b,&c,&d);
int st = 0;
ans = 0;
for(int i = st;i < n;i++){
if(v[i].FI > c)break;
if(v[i].FI >= a && v[i].SE >= b && v[i].SE <= d)ans++;
}
printf("%d\n",ans);
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
typedef pair<ll,ll> pll;
const int INT = 1e9;
const ll LINF = 1e18;
void solve(){
int n,m; cin >> n >> m;
vector<pll> p(n);
for(int i = 0; i < n;i++){
ll x,y; cin >> x >> y;
p[i] = {x,y};
}
sort(p.begin(),p.end());
for(int i = 0; i < m;i++){
int x1,y1,x2,y2; cin >> x1 >> y1 >> x2 >> y2;
ll xl = lower_bound(p.begin(), p.end(), pll(x1,-LINF)) - p.begin();
ll xr = upper_bound(p.begin(),p.end(),pll(x2,LINF)) - p.begin();
ll ans = 0;
for(ll j = xl; j < xr;j++){
if(y1 <= p[j].second && p[j].second <= y2) ans++;
}
cout << ans << endl;
}
}
int main(void){
cin.tie(0); ios_base::sync_with_stdio(false);
solve();
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1e9 + 10;
int xs[5001], ys[5001];
int sum[5100][5100];
int main() {
int N, M; cin >> N >> M;
vector<int> X = {-inf, inf}, Y = {-inf, inf};
rep(i, N) {
scanf("%d%d", &xs[i], &ys[i]);
X.push_back(xs[i]); Y.push_back(ys[i]);
}
sort(X.begin(), X.end()); X.erase(unique(all(X)), X.end());
sort(Y.begin(), Y.end()); Y.erase(unique(all(Y)), Y.end());
rep(i, N) {
sum[upper_bound(all(Y), ys[i]) - Y.begin()][upper_bound(all(X), xs[i]) - X.begin()] ++;
}
rep(i, Y.size() + 10) rep(j, X.size() + 10) {
if(i && j) sum[i][j] -= sum[i-1][j-1];
if(i) sum[i][j] += sum[i-1][j];
if(j) sum[i][j] += sum[i][j-1];
}
rep(i, M) {
int rx1, ry1, rx2, ry2; scanf("%d%d%d%d", &rx1, &ry1, &rx2, &ry2);
int x1 = lower_bound(all(X), rx1) - X.begin();
int y1 = lower_bound(all(Y), ry1) - Y.begin();
int x2 = upper_bound(all(X), rx2) - X.begin();
int y2 = upper_bound(all(Y), ry2) - Y.begin();
printf("%d\n", sum[y2][x2] - sum[y2][x1] - sum[y1][x2] + sum[y1][x1]);
}
return 0;
} |
#ifndef ___Class_RangeTree
#define ___Class_RangeTree
// ------ Includes ------ //
#include <limits>
#include <vector>
#include <algorithm>
template<typename Type> class RangeTree {
private:
int size_; std::vector<std::vector<Type> > dat;
inline int query_(int a, int b, Type x, int k, int l, int r) {
// Find range [a, b) : value < x : Now k-th node and the range is [l, r)
if (r <= a || b <= l) return 0;
if (a <= l && r <= b) return lower_bound(dat[k].begin(), dat[k].end(), x) - dat[k].begin();
int lc = query_(a, b, x, (k << 1), l, (l + r) >> 1);
int rc = query_(a, b, x, (k << 1) + 1, (l + r) >> 1, r);
return lc + rc;
}
public:
RangeTree() : size_(0), dat(std::vector<Type>()) {};
template<class T>
RangeTree(T begin_, T end_) {
int n = (end_ - begin_);
for (size_ = 1; size_ < n; size_ <<= 1); dat.resize(size_ << 1, std::vector<Type>());
for (int i = 0; i < n; i++) dat[i + size_] = std::vector<Type>({ *(begin_ + i) });
for (int i = size_ - 1; i > 0; i--) {
dat[i].resize(dat[i << 1].size() + dat[(i << 1) + 1].size());
std::merge(dat[i << 1].begin(), dat[i << 1].end(), dat[(i << 1) + 1].begin(), dat[(i << 1) + 1].end(), dat[i].begin());
}
}
inline int size() { return size_; }
inline int query(int l, int r, Type x) {
// Find range [a, b) : value < x
return query_(l, r, x, 1, 0, size_);
}
};
#endif
#include <cstdio>
#include <vector>
#pragma warning(disable : 4996)
using namespace std;
int N, Q, xl, yl, xr, yr;
int main() {
scanf("%d%d", &N, &Q);
vector<pair<int, int> > p(N);
for (int i = 0; i < N; i++) scanf("%d%d", &p[i].first, &p[i].second);
sort(p.begin(), p.end());
vector<int> z1(N), z2(N);
for (int i = 0; i < N; i++) {
z1[i] = p[i].first;
z2[i] = p[i].second;
}
RangeTree<int> seg(z2.begin(), z2.end());
while (Q--) {
scanf("%d%d%d%d", &xl, &yl, &xr, &yr);
int ptr1 = lower_bound(z1.begin(), z1.end(), xl) - z1.begin();
int ptr2 = lower_bound(z1.begin(), z1.end(), xr + 1) - z1.begin();
int res1 = seg.query(ptr1, ptr2, yl);
int res2 = seg.query(ptr1, ptr2, yr + 1);
printf("%d\n", res2 - res1);
}
return 0;
} |
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
using int64 = int64_t;
constexpr int64 MOD = 1000000007;
struct dat {
int id;
int z;
dat () {}
~dat () {}
dat (int a, int b): id(a), z(b) {}
bool operator < (const dat& o) const {
return z < o.z;
}
};
int N, M;
int tx[5000], ty[5000];
dat arr_x[5000];
dat arr_y[5000];
int check[5000];
int solve(int x1, int y1, int x2, int y2) {
fill(check, check + N, 0);
for (dat* itx = lower_bound(arr_x, arr_x+N, dat(-1, x1));
itx < arr_x+N && itx->z <= x2; ++itx) {
++ check[ itx->id ];
}
int ans = 0;
for (dat* ity = lower_bound(arr_y, arr_y+N, dat(-1, y1));
ity < arr_y+N && ity->z <= y2; ++ity) {
ans += check[ ity->id ];
}
return ans;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> N >> M;
for (int j = 0; j < N; ++j) {
cin >> tx[j] >> ty[j];
}
// initialize
for (int j = 0; j < N; ++j) {
arr_x[j] = dat(j, tx[j]);
arr_y[j] = dat(j, ty[j]);
}
sort(arr_x, arr_x + N);
sort(arr_y, arr_y + N);
for (int j = 0; j < M; ++j) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
cout << solve(x1, y1, x2, y2) << endl;
}
return 0;
} |
#include <iostream>
#include <algorithm>
#include <string>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <set>
#include <vector>
#include <map>
#define rep2(i, b, n) for(int i=b; i < n; ++i)
#define repm(i, b, n) for(int i=b; i > n; --i)
#define rep(i, n) rep2(i, 0, n)
#define sz(v) v.size()
#define mp(x, y) make_pair(x, y)
#define fst first
#define scd second
#define X fst
#define Y scd
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
int main( void )
{
int n, m;
pii p[5010];
while (cin >> n >> m)
{
rep (i, n)
{
cin >> p[i].X >> p[i].Y;
}
sort(p, (p + n));
const int rp = (int)1e9, rm = -(int)1e9;
rep (i, m)
{
int l, t, r, b;
cin >> l >> t >> r >> b;
pii *ll, *hh;
ll = lower_bound(p, (p + n), mp(l, rm));
hh = upper_bound(p, (p + n), mp(r, rp));
int ans = 0;
for (pii *itr=ll; itr != hh; ++itr)
{
if (t <= (itr->Y) && (itr->Y) <= b)
++ans;
}
cout << ans << endl;
}
}
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main(){
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
for(int i = 0; i < n; ++i){ cin >> x[i] >> y[i]; }
vector<int> xc(x), yc(y);
sort(xc.begin(), xc.end());
sort(yc.begin(), yc.end());
xc.erase(unique(xc.begin(), xc.end()), xc.end());
yc.erase(unique(yc.begin(), yc.end()), yc.end());
for(int i = 0; i < n; ++i){
x[i] = lower_bound(xc.begin(), xc.end(), x[i]) - xc.begin();
y[i] = lower_bound(yc.begin(), yc.end(), y[i]) - yc.begin();
}
vector< vector<int> > image(yc.size(), vector<int>(xc.size()));
for(int i = 0; i < n; ++i){ ++image[y[i]][x[i]]; }
vector< vector<int> > integral(yc.size() + 1, vector<int>(xc.size() + 1));
for(int i = 1; i <= yc.size(); ++i){
int sum = 0;
for(int j = 1; j <= xc.size(); ++j){
sum += image[i - 1][j - 1];
integral[i][j] = integral[i - 1][j] + sum;
}
}
while(m--){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int xc1 = lower_bound(xc.begin(), xc.end(), x1) - xc.begin();
int yc1 = lower_bound(yc.begin(), yc.end(), y1) - yc.begin();
int xc2 = upper_bound(xc.begin(), xc.end(), x2) - xc.begin();
int yc2 = upper_bound(yc.begin(), yc.end(), y2) - yc.begin();
int answer = integral[yc2][xc2] - integral[yc2][xc1] - integral[yc1][xc2] + integral[yc1][xc1];
cout << answer << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 200;
const int BNUM = MAXN / B;
int n, m;
pair<int, int> ps[MAXN];
int x[MAXN], y[MAXN];
vector<int> bucket[BNUM];
int main() {
while(scanf("%d%d", &n, &m) != EOF) {
for(int i = 0; i < n; ++i) {
scanf("%d%d", &ps[i].first, &ps[i].second);
}
sort(ps, ps+n);
fill(bucket, bucket + BNUM, vector<int>());
for(int i = 0; i < n; ++i) {
x[i] = ps[i].first;
y[i] = ps[i].second;
bucket[i/B].push_back(y[i]);
}
for(int b = 0; b < BNUM; ++b) {
sort(bucket[b].begin(), bucket[b].end());
}
while(m--) {
int s, t, u, v;
scanf("%d%d%d%d", &s, &t, &u, &v);
int l = lower_bound(x, x+n, s) - x;
int r = upper_bound(x, x+n, u) - x;
int res = 0;
while(l < r && l % B != 0) {
res += (t <= y[l] && y[l] <= v);
++l;
}
while(l < r && r % B != 0) {
--r;
res += (t <= y[r] && y[r] <= v);
}
while(l < r) {
int b = l / B;
res += upper_bound(bucket[b].begin(), bucket[b].end(), v)
- lower_bound(bucket[b].begin(), bucket[b].end(), t);
l += B;
}
printf("%d\n", res);
}
}
return 0;
} |
#include<iostream>
#include<vector>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<cmath>
#include<cstring>
#include<queue>
#include<stack>
#include<cstdio>
#include<sstream>
#include<iomanip>
#define loop(i,a,b) for(int i=a;i<b;i++)
#define rep(i,a) loop(i,0,a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
using namespace std;
//kaewasuretyuui
typedef long long ll;
typedef pair<int,int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int,pii> pip;
typedef vector<pip>vip;
const double PI=acos(-1);
const double EPS=1e-8;
const int inf=1e8;
int main(){
int n,m;
cin>>n>>m;
vp in(n);
vi x,y;
rep(i,n){
int a,b;
cin>>a>>b;
x.pb(a);
y.pb(b);
in[i]=pii(a,b);
}
sort(all(x));
sort(all(y));
x.erase(unique(all(x)),x.end());
y.erase(unique(all(y)),y.end());
rep(i,n)in[i]=pii(lower_bound(all(x),in[i].first)-x.begin(),lower_bound(all(y),in[i].second)-y.begin());
vvi fi(x.size()+1,vi(y.size()+1));
rep(i,n)fi[in[i].first+1][in[i].second+1]++;
rep(i,x.size())rep(j,y.size())fi[i+1][j+1]+=fi[i][j+1]+fi[i+1][j]-fi[i][j];
while(m--){
int a,b,c,d;
cin>>a>>b>>c>>d;
a=lower_bound(all(x),a)-x.begin();
b=lower_bound(all(y),b)-y.begin();
c=upper_bound(all(x),c)-x.begin();
d=upper_bound(all(y),d)-y.begin();
cout<<fi[c][d]-fi[a][d]-fi[c][b]+fi[a][b]<<endl;
}
} |
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <iterator>
#include <map>
#include <utility>
#include <vector>
using namespace std;
#define FOR(it,c) for(__typeof((c).begin())it=(c).begin(); it!=(c).end();++it)
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
map<int, vector<int> > treasure;
for(int i = 0; i < n; ++i) {
int x, y;
cin >> x >> y;
treasure[x].push_back(y);
}
vector<int> prev = treasure.rbegin()->second;
map<int, vector<int> >::reverse_iterator rit = treasure.rbegin();
++rit;
while(rit != treasure.rend()) {
vector<int>& cur = rit->second;
for(int i = 0; i < prev.size(); ++i)
cur.push_back(prev[i]);
prev = rit->second;
++rit;
}
FOR(it, treasure)
sort(it->second.begin(), it->second.end());
treasure.insert(make_pair(1000000001, vector<int>()));
for(int i = 0; i < m; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
const vector<int>& v1 = treasure.lower_bound(x1)->second;
const vector<int>& v2 = treasure.upper_bound(x2)->second;
int num1 = upper_bound(v1.begin(), v1.end(), y2) - lower_bound(v1.begin(), v1.end(), y1);
int num2 = upper_bound(v2.begin(), v2.end(), y2) - lower_bound(v2.begin(), v2.end(), y1);
cout << num1 - num2 << endl;
}
return EXIT_SUCCESS;
} |
#include<iostream>
#include<algorithm>
#include<cstdio>
#include<cmath>
#include<math.h>
#include<string>
#include<string.h>
#include<stack>
#include<queue>
#include<vector>
#include<utility>
#include<set>
#include<map>
#include<stdlib.h>
#include<iomanip>
using namespace std;
#define ll long long
#define ld long double
#define EPS 0.0000000001
#define INF 1e9
#define MOD 1000000007
#define rep(i,n) for(i=0;i<n;i++)
#define loop(i,a,n) for(i=a;i<n;i++)
#define all(in) in.begin(),in.end()
#define shosu(x) fixed<<setprecision(x)
typedef vector<int> vi;
typedef pair<int,int> pii;
int grid[5005][5005];
void compress(vi &v){
sort(all(v));
v.erase(unique(all(v)),v.end());
}
void cumulativesum(int h,int w){
int i,j;
rep(i,h)rep(j,w) grid[i+1][j+1]+=grid[i+1][j]+grid[i][j+1]-grid[i][j];
}
int sum(int i,int j,int k,int l){//y,x??§??????????°???§
return grid[k][l]-grid[i][l]-grid[k][j]+grid[i][j];
}
int main(void) {
int i,j;
int n,m;
cin>>n>>m;
vi x(n),y(n);
pii p[5000];
rep(i,n){
cin>>x[i]>>y[i];
p[i].first=x[i];
p[i].second=y[i];
}
compress(x);
compress(y);
rep(i,n){
int fy=lower_bound(all(y),p[i].second)-y.begin();
int fx=lower_bound(all(x),p[i].first)-x.begin();
grid[fy+1][fx+1]++;
}
cumulativesum(n,n);//?´???????
rep(i,m){
int lx,ly,rx,ry;
cin>>lx>>ly>>rx>>ry;
lx=lower_bound(all(x),lx)-x.begin();
ly=lower_bound(all(y),ly)-y.begin();
rx=lower_bound(all(x),rx+1)-x.begin();
ry=lower_bound(all(y),ry+1)-y.begin();
cout<<sum(ly,lx,ry,rx)<<endl;
}
} |
#include<iostream>
#include<vector>
#include<algorithm>
#include<iomanip>
using namespace std;
const int INF = 1e9+100;
signed main(){
cin.tie(0);
ios::sync_with_stdio(false);
vector<vector<int> > field;
vector<pair<int,int> > in;
vector<int> x, y;
int n, m, a, b;
int x1, x2, y1, y2;
cin>>n>>m;
for(int i = 0; i < n; i++){
cin>>a>>b;
x.push_back(a);
y.push_back(b);
in.push_back(make_pair(b,a));
}
x.push_back(INF);
x.push_back(-INF);
y.push_back(INF);
y.push_back(-INF);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(in.begin(), in.end());
x.erase(unique(x.begin(), x.end()), x.end());
y.erase(unique(y.begin(), y.end()), y.end());
field.resize(y.size()+4, vector<int>(x.size()+4, 0));
for(int i = 0; i < in.size(); i++){
int xkey = in[i].second, ykey = in[i].first;
int tx = lower_bound(x.begin(), x.end(), xkey) - x.begin();
int ty = lower_bound(y.begin(), y.end(), ykey) - y.begin();
field[ty][tx]++;
}
for(int i = 0; i < y.size(); i++){
for(int j = 0; j < x.size(); j++){
field[i+1][j] += field[i][j];
}
}
for(int j = 0; j < x.size(); j++){
for(int i = 0; i < y.size(); i++){
field[i][j+1] += field[i][j];
}
}
for(int i = 0; i < m; i++){
cin>>x1>>y1>>x2>>y2;
int tx1l = lower_bound(x.begin(), x.end(), x1) - x.begin();
int ty1l = lower_bound(y.begin(), y.end(), y1) - y.begin();
int tx2u = upper_bound(x.begin(), x.end(), x2) - x.begin();
int ty2u = upper_bound(y.begin(), y.end(), y2) - y.begin();
int ans = field[ty2u-1][tx2u-1] + field[ty1l-1][tx1l-1] - field[ty2u-1][tx1l-1] - field[ty1l-1][tx2u-1];
cout<<ans<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 100;
const int BNUM = MAXN / B;
int n, m;
pair<int, int> ps[MAXN];
int x[MAXN], y[MAXN];
vector<int> bucket[BNUM];
int main() {
while(scanf("%d%d", &n, &m) != EOF) {
for(int i = 0; i < n; ++i) {
scanf("%d%d", &ps[i].first, &ps[i].second);
}
sort(ps, ps+n);
fill(bucket, bucket + BNUM, vector<int>());
for(int i = 0; i < n; ++i) {
x[i] = ps[i].first;
y[i] = ps[i].second;
bucket[i/B].push_back(y[i]);
}
for(int b = 0; b < BNUM; ++b) {
sort(bucket[b].begin(), bucket[b].end());
}
while(m--) {
int s, t, u, v;
scanf("%d%d%d%d", &s, &t, &u, &v);
int l = lower_bound(x, x+n, s) - x;
int r = upper_bound(x, x+n, u) - x;
int res = 0;
while(l < r && l % B != 0) {
res += (t <= y[l] && y[l] <= v);
++l;
}
while(l < r && r % B != 0) {
--r;
res += (t <= y[r] && y[r] <= v);
}
while(l < r) {
int b = l / B;
res += upper_bound(bucket[b].begin(), bucket[b].end(), v)
- lower_bound(bucket[b].begin(), bucket[b].end(), t);
l += B;
}
printf("%d\n", res);
}
}
return 0;
} |
#include<string>
#include<vector>
#include<iostream>
#include<sstream>
#include<cstdio>
#include<cstdlib>
#include<functional>
#include<algorithm>
#include<stack>
#include<queue>
#include<deque>
#include<set>
#include<map>
#include<utility>
#include<cmath>
#include<ctime>
#include<complex>
using namespace std;
#define REP(i,s,e) for(int i=int(s);i<=int(e);i++)
#define rep(i,n) for(int i=0;i<int(n);i++)
#define INF 1000000001
int s[5010][5010];
int main(){
int n,m,x1,y1,x2,y2,x3,y3;
vector<int>x,y,X,Y;
cin >> n >> m;
rep(i,n){
cin >> x1 >> y1;
x.push_back(x1);
y.push_back(y1);
}
X=x; Y=y;
x.push_back(-INF); x.push_back(INF);
y.push_back(-INF); y.push_back(INF);
sort(x.begin(),x.end());
sort(y.begin(),y.end());
x.erase(unique(x.begin(),x.end()),x.end());
y.erase(unique(y.begin(),y.end()),y.end());
rep(i,n){
int dx=lower_bound(x.begin(),x.end(),X[i])-x.begin();
int dy=lower_bound(y.begin(),y.end(),Y[i])-y.begin();
s[dy][dx]++;
}
REP(i,1,n) REP(j,1,n) s[i][j]+=s[i][j-1]+s[i-1][j]-s[i-1][j-1];
rep(i,m){
cin >> x2 >> y2 >> x3 >> y3;
int dx2=lower_bound(x.begin(),x.end(),x2)-x.begin();
int dy2=lower_bound(y.begin(),y.end(),y2)-y.begin();
int dx3=upper_bound(x.begin(),x.end(),x3)-x.begin()-1;
int dy3=upper_bound(y.begin(),y.end(),y3)-y.begin()-1;
cout << s[dy3][dx3]-s[dy2-1][dx3]-s[dy3][dx2-1]+s[dy2-1][dx2-1] << endl;
}
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
int treasure[5002][5002];
int x[5000];int y[5000];
int cpx[5000]; int cpy[5000];
map<int,int> xind;
map<int,int> yind;
int main()
{
fill(treasure[0],treasure[5000],0);
int n,m;
cin>>n>>m;
for(int i=0;i<n;i++)
{
cin>>x[i]>>y[i];
cpx[i]=x[i];
cpy[i]=y[i];
}
sort(cpx,cpx+n);
sort(cpy,cpy+n);
for(int i=0;i<n;i++)
{
xind[cpx[i]]=i;
yind[cpy[i]]=i;
}
//座圧した座標で累積和
for(int i=0;i<n;i++)
treasure[xind[x[i]]+1][yind[y[i]]+1]++;
//累積和
//横
for(int i=1;i<5002;i++)
{
for(int j=1;j<5002;j++)
treasure[i][j]+=treasure[i][j-1];
}
//縦
for(int i=1;i<5002;i++)
{
for(int j=1;j<5002;j++)
treasure[i][j]+=treasure[i-1][j];
}
// for(int i=0;i<n+1;i++)
// {
// for(int j=0;j<n+1;j++)
// cerr<<treasure[i][j]<<" ";
// cerr<<endl;
// }
//クエリ
for(int i=0;i<m;i++)
{
int a,b,c,d;
cin>>a>>b>>c>>d;
a--;b--;
int aind,bind,cind,dind;
aind=upper_bound(cpx,cpx+n,a)-cpx;
if(a<*(cpx+aind))
aind--;
bind=upper_bound(cpy,cpy+n,b)-cpy;
if(b<*(cpy+bind))
bind--;
cind=upper_bound(cpx,cpx+n,c)-cpx;
dind=upper_bound(cpy,cpy+n,d)-cpy;
aind++;bind++;
//cerr<<aind<<" "<<bind<<" "<<cind<<" "<<dind<<endl;
int ans=treasure[cind][dind]-treasure[cind][bind]-treasure[aind][dind]+treasure[aind][bind];
cout<<ans<<endl;
}
return 0;
}
|
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
#include<string>
#include<iostream>
#include<map>
#include<set>
#include<queue>
using namespace std;
typedef long long ll;
int N,M;
int fie[5005][5005];
int rui[5005][5005];
ll xy[2][5001];
ll X[5001],Y[5001];
int W,H;
int compress(int id,ll *x){
vector<ll> xs;
for(int i=0;i<N;i++){
xs.push_back(xy[id][i]);
}
sort(xs.begin(),xs.end());
xs.erase(unique(xs.begin(),xs.end()),xs.end());
for(int i=0;i<N;i++){
ll a = find(xs.begin(),xs.end(),xy[id][i]) - xs.begin();
a++;
x[a] = xy[id][i];
xy[id][i] = a;
}
x[0] = -10000000000;
return (int)xs.size();
}
int nibun(ll a,ll *b,int wh,bool f){
/*
cout << a << " :: wh = " << wh << endl;
for(int i=0;i<=W;i++)
cout << b[i] << " ";
cout << endl;
*/
int res = lower_bound(b,b+wh+1,a) - b;
// cout << res << endl;
if(b[res] > a && !f) res--;
return res;
}
void view(){
for(int y=0;y<=H+1;y++){
for(int x=0;x<=W+1;x++){
cout << rui[x][y] << " ";
}
cout << endl;
}
}
int main(){
cin >> N >> M;
for(int i=0;i<N;i++){
cin >> xy[0][i] >> xy[1][i];
}
W = compress(0,X);
H = compress(1,Y);
/*
cout << "W = " << W << endl;
for(int i=1;i<=W;i++)
cout << X[i] << " ";
cout << endl;
cout << "H = " << H << endl;
for(int i=1;i<=H;i++)
cout << Y[i] << " ";
cout << endl;
*/
for(int i=0;i<N;i++){
fie[xy[0][i]][xy[1][i]]++;
}
for(int y=1;y<=H+1;y++){
for(int x=1;x<=W+1;x++){
rui[x][y] = rui[x-1][y] + fie[x][y];
}
}
for(int y=1;y<=H+1;y++){
for(int x=1;x<=W+1;x++){
rui[x][y] += rui[x][y-1];
}
}
for(int i=0;i<M;i++){
ll x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = nibun(x1,X,W,true);
y1 = nibun(y1,Y,H,true);
x2 = nibun(x2,X,W,false);
y2 = nibun(y2,Y,H,false);
/*
cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
cout << rui[x2][y2] << " - " << rui[x2][y1-1] << " - " << rui[x1-1][y2] << " + " << rui[x1][y1] << endl;
*/
int res = rui[x2][y2] - rui[x2][y1-1] - rui[x1-1][y2] + rui[x1-1][y1-1];
cout << res << endl;
}
} |
#define _USE_MATH_DEFINES
#include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <cfloat>
#include <climits>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge { int u, v; ll w; };
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
int lb(vector<int>& Z, int z) {
return lower_bound(Z.begin(), Z.end(), z) - Z.begin();
}
int ub(vector<int>& Z, int z) {
return upper_bound(Z.begin(), Z.end(), z) - Z.begin();
}
int compress(vector<int>& z, vector<int>& z1, vector<int>& z2) {
int n = z.size(), m = z1.size();
vector<int> Z;
for (int i = 0; i < n; i++)
Z.push_back(z[i]);
sort(Z.begin(), Z.end());
Z.erase(unique(Z.begin(), Z.end()), Z.end());
for (int i = 0; i < n; i++)
z[i] = lb(Z, z[i]);
for (int j = 0; j < m; j++) {
z1[j] = lb(Z, z1[j]);
z2[j] = ub(Z, z2[j]) - 1;
}
return Z.size();
}
int main() {
int n, m; cin >> n >> m;
vector<int> x(n), y(n);
for (int i = 0; i < n; i++)
scanf("%d%d", &x[i], &y[i]);
vector<int> x1(m), y1(m), x2(m), y2(m);
for (int j = 0; j < m; j++)
scanf("%d%d%d%d", &x1[j], &y1[j], &x2[j], &y2[j]);
int w = compress(x, x1, x2), h = compress(y, y1, y2);
vector< vector<int> > sum(h + 1, vector<int>(w + 1));
for (int i = 0; i < n; i++)
sum[y[i] + 1][x[i] + 1]++;
for (int y = 1; y <= h; y++)
for (int x = 1; x <= w; x++)
sum[y][x] += sum[y][x - 1] + sum[y - 1][x] - sum[y - 1][x - 1];
for (int j = 0; j < m; j++) {
int l = x1[j], u = y1[j], r = x2[j] + 1, d = y2[j] + 1;
printf("%d\n", sum[d][r] - sum[d][l] - sum[u][r] + sum[u][l]);
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
// ret[i][j] = sum of all field in [0,i) x [0,j).
template<typename T>
vector<vector<T>> calc_sum(const vector<vector<T>>& field){
int h = field.size();
int w = field[0].size();
vector<vector<T>> ret(h+1,vector<T>(w+1));
for(int y=1;y<=h;y++){
for(int x=1;x<=w;x++){
ret[y][x] = ret[y][x-1] + field[y-1][x-1];
}
}
for(int x=0;x<=w;x++){
for(int y=1;y<=h;y++){
ret[y][x] = ret[y][x] + ret[y-1][x];
}
}
return ret;
}
#define all(vec) vec.begin(),vec.end()
int main(){
int n,m;cin >> n >> m;
vector<int> index_of_x(n),index_of_y(n);
for(int i=0;i<n;i++){
cin >> index_of_x[i] >> index_of_y[i];
}
vector<int> value_of_x = index_of_x,
value_of_y = index_of_y;
sort(all(value_of_x));
sort(all(value_of_y));
value_of_x.erase(unique(all(value_of_x)),value_of_x.end());
value_of_y.erase(unique(all(value_of_y)),value_of_y.end());
for(int i=0;i<n;i++){
index_of_x[i] = lower_bound(all(value_of_x),index_of_x[i]) - value_of_x.begin();
index_of_y[i] = lower_bound(all(value_of_y),index_of_y[i]) - value_of_y.begin();
}
vector<vector<int>> p(value_of_y.size(),vector<int>(value_of_x.size()));
for(int i=0;i<n;i++){
p[index_of_y[i]][index_of_x[i]] += 1;
}
auto v = calc_sum(p);
for(int i=0;i<m;i++){
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
int sx = lower_bound(all(value_of_x),x1) - value_of_x.begin();
int gx = upper_bound(all(value_of_x),x2) - value_of_x.begin();
int sy = lower_bound(all(value_of_y),y1) - value_of_y.begin();
int gy = upper_bound(all(value_of_y),y2) - value_of_y.begin();
int ans = v[gy][gx] - v[sy][gx] - v[gy][sx] + v[sy][sx];
cout << ans << endl;
}
return 0;
} |
#include <vector>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <algorithm>
#include <utility>
#include <functional>
#include <sstream>
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <climits>
#include <fstream>
using namespace std;
inline int toInt(string s) { int v; istringstream sin(s); sin >> v; return v; }
template<class T> inline string toStr(T x) { ostringstream sout; sout << x; return sout.str(); }
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(),(a).rend()
#define FOR(i,a,b) for(int i=(a);i<=(b);++i)
#define REP(i,n) FOR(i,0,(n)-1)
const double EPS = 1e-12;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int pos1(vi v, int p) {
return lower_bound(ALL(v), p) - v.begin() - 1;
}
int pos2(vi v, int p) {
return upper_bound(ALL(v), p) - v.begin() - 1;
}
int main() {
int n, m;
cin >> n >> m;
vi x(n), y(n);
vector<pii> xy(n);
REP(i, n) {
cin >> x[i] >> y[i];
xy[i] = pii(x[i], y[i]);
}
x.push_back(INT_MIN);
y.push_back(INT_MIN);
sort(ALL(x));
sort(ALL(y));
x.erase(unique(ALL(x)), x.end());
y.erase(unique(ALL(y)), y.end());
int xsize = x.size(), ysize = y.size();
vi xpos(n), ypos(n);
REP(i, n) {
REP(j, xsize) {
if (xy[i].first == x[j]) {
xpos[i] = j;
break;
}
}
}
REP(i, n) {
REP(j, ysize) {
if (xy[i].second == y[j]) {
ypos[i] = j;
break;
}
}
}
vvi field(ysize, vi(xsize));
REP(i, n) {
field[ypos[i]][xpos[i]]++;
}
FOR(i, 1, ysize - 1) {
FOR(j, 1, xsize - 1) {
field[i][j] += field[i][j - 1];
}
}
FOR(i, 1, ysize - 1) {
FOR(j, 1, xsize - 1) {
field[i][j] += field[i - 1][j];
}
}
REP(i, m) {
int xm1, ym1, xm2, ym2;
cin >> xm1 >> ym1 >> xm2 >> ym2;
int xp1 = pos1(x, xm1), yp1 = pos1(y, ym1), xp2 = pos2(x, xm2), yp2 = pos2(y, ym2);
cout << field[yp2][xp2] - field[yp1][xp2] - field[yp2][xp1] + field[yp1][xp1] << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define FOR(i,a,b) for(int i=(a);i<(b);i++)
#define rep(i,N) for(int i=0;i<(N);i++)
#define ALL(s) (s).begin(),(s).end()
#define EQ(a,b) (abs((a)-(b))<EPS)
#define EQV(a,b) ( EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()) )
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
ll n,m;
ll x[2],y[2];
bool in(ll cx,ll cy){
return x[0] <= cx && cx <= x[1] && y[0] <= cy && cy <= y[1];
}
int main(){
cin >> n >> m;
vector<P> vp;
rep(i,n){
ll xx,yy;
cin >> xx >> yy;
vp.push_back(P(xx,yy));
}
sort(ALL(vp));
rep(i,m){
ll ans = 0;
cin >> x[0] >> y[0] >> x[1] >> y[1];
rep(j,n){
ans += in(vp[j].first,vp[j].second);
}
cout << ans << endl;
}
}
|
#include <cstdio>
#include <cstring>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
int n,m;
vector<int> xindex;
vector<int> yindex;
int fie[5001][5001];
int x[5001],y[5001];
int main(void){
scanf("%d %d",&n,&m);
xindex.push_back(-2e9);
yindex.push_back(-2e9);
for(int i=0;i<n;i++){
scanf("%d %d",&x[i],&y[i]);
xindex.push_back(x[i]);
yindex.push_back(y[i]);
}
sort(xindex.begin(),xindex.end());
xindex.erase(unique(xindex.begin(),xindex.end()),xindex.end());
sort(yindex.begin(),yindex.end());
yindex.erase(unique(yindex.begin(),yindex.end()),yindex.end());
for(int i=0;i<n;i++){
x[i]=lower_bound(xindex.begin(),xindex.end(),x[i])-xindex.begin();
y[i]=lower_bound(yindex.begin(),yindex.end(),y[i])-yindex.begin();
fie[x[i]][y[i]]++;
}
for(int i=0;i<yindex.size();i++){
for(int j=1;j<xindex.size();j++){
fie[j][i]+=fie[j-1][i];
}
}
for(int i=0;i<xindex.size();i++){
for(int j=1;j<yindex.size();j++){
fie[i][j]+=fie[i][j-1];
}
}
for(int i=0;i<m;i++){
int lx,rx,ly,ry;
scanf("%d %d %d %d",&lx,&ly,&rx,&ry);
lx=upper_bound(xindex.begin(),xindex.end(),lx-1)-xindex.begin();
rx=upper_bound(xindex.begin(),xindex.end(),rx)-xindex.begin();
ly=upper_bound(yindex.begin(),yindex.end(),ly-1)-yindex.begin();
ry=upper_bound(yindex.begin(),yindex.end(),ry)-yindex.begin();
lx--;
rx--;
ly--;
ry--;
printf("%d\n",fie[rx][ry]-fie[lx][ry]-fie[rx][ly]+fie[lx][ly]);
}
return 0;
} |
#include <iostream>
#include <vector>
#include <algorithm>
#define inf (1e9+9)
using namespace std;
int n, m;
int x[5005], y[5005];
vector<int> compX, compY;
int dif[5005][5005], sum[5005][5005];
int main(void)
{
cin >> n >> m;
for(int i = 1; i <= n; i++) cin >> x[i] >> y[i];
compX.push_back(-inf);
for(int i = 1; i <= n; i++) compX.push_back(x[i]);
sort(compX.begin(), compX.end());
compX.erase(unique(compX.begin(), compX.end()), compX.end());
for(int i = 1; i <= n; i++) x[i] = lower_bound(compX.begin(), compX.end(), x[i]) - compX.begin();
compY.push_back(-inf);
for(int i = 1; i <= n; i++) compY.push_back(y[i]);
sort(compY.begin(), compY.end());
compY.erase(unique(compY.begin(), compY.end()), compY.end());
for(int i = 1; i <= n; i++) y[i] = lower_bound(compY.begin(), compY.end(), y[i]) - compY.begin();
for(int i = 1; i <= n; i++) dif[x[i]][y[i]]++;
for(int x = 1; x < 5005; x++){
for(int y = 1; y < 5005; y++){
sum[x][y] = sum[x-1][y] + sum[x][y-1] - sum[x-1][y-1] + dif[x][y];
}
}
//for(int i = 0; i < compY.size(); i++) cout << compY[i] << " "; cout << endl;
int sx, sy, tx, ty;
for(int q = 0; q < m; q++){
cin >> sx >> sy >> tx >> ty;
sx = lower_bound(compX.begin(), compX.end(), sx) - compX.begin();
sy = lower_bound(compY.begin(), compY.end(), sy) - compY.begin();
tx = upper_bound(compX.begin(), compX.end(), tx) - compX.begin() - 1;
ty = upper_bound(compY.begin(), compY.end(), ty) - compY.begin() - 1;
//cout << sx << " " << sy << " " << tx << " " << ty << endl;
cout << sum[tx][ty] - sum[sx-1][ty] - sum[tx][sy-1] + sum[sx-1][sy-1] << endl;
}
return 0;
}
|
#include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <complex>
#include <queue>
#include <deque>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <iomanip>
#include <assert.h>
#include <array>
#include <cstdio>
#include <cstring>
#include <random>
#include <functional>
#include <numeric>
#include <bitset>
#include <fstream>
using namespace std;
#define REP(i,a,b) for(int i=a;i<(int)b;i++)
#define rep(i,n) REP(i,0,n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) { cout << #a << " = " << a << endl; }
template<class T1, class T2> inline bool minimize(T1 &a, T2 b) { return b < a && (a = b, 1); }
template<class T1, class T2> inline bool maximize(T1 &a, T2 b) { return a < b && (a = b, 1); }
typedef long long ll;
int const inf = 1e9 + 10;
int xs[5001], ys[5001];
int sum[5100][5100];
int main() {
int N, M; cin >> N >> M;
vector<int> X, Y;
rep(i, N) {
scanf("%d%d", &xs[i], &ys[i]);
X.push_back(xs[i]); Y.push_back(ys[i]);
}
sort(X.begin(), X.end()); X.erase(unique(all(X)), X.end());
sort(Y.begin(), Y.end()); Y.erase(unique(all(Y)), Y.end());
rep(i, N) {
sum[upper_bound(all(Y), ys[i]) - Y.begin()][upper_bound(all(X), xs[i]) - X.begin()] ++;
}
rep(i, Y.size() + 10) rep(j, X.size() + 10) {
if(i && j) sum[i][j] -= sum[i-1][j-1];
if(i) sum[i][j] += sum[i-1][j];
if(j) sum[i][j] += sum[i][j-1];
}
rep(i, M) {
int rx1, ry1, rx2, ry2; scanf("%d%d%d%d", &rx1, &ry1, &rx2, &ry2);
int x1 = lower_bound(all(X), rx1) - X.begin();
int y1 = lower_bound(all(Y), ry1) - Y.begin();
int x2 = upper_bound(all(X), rx2) - X.begin();
int y2 = upper_bound(all(Y), ry2) - Y.begin();
printf("%d\n", sum[y2][x2] - sum[y2][x1] - sum[y1][x2] + sum[y1][x1]);
}
return 0;
} |
#include <bits/stdc++.h>
#define For(i, a, b) for(int (i)=(int)(a); (i)<(int)(b); ++(i))
#define rFor(i, a, b) for(int (i)=(int)(a)-1; (i)>=(int)(b); --(i))
#define rep(i, n) For((i), 0, (n))
#define rrep(i, n) rFor((i), (n), 0)
#define fi first
#define se second
using namespace std;
typedef long long lint;
typedef unsigned long long ulint;
typedef pair<int, int> pii;
typedef pair<lint, lint> pll;
template<class T> bool chmax(T &a, const T &b){if(a<b){a=b; return true;} return false;}
template<class T> bool chmin(T &a, const T &b){if(a>b){a=b; return true;} return false;}
template<class T> T div_floor(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>=0 ? a/b : (a+1)/b-1;
}
template<class T> T div_ceil(T a, T b){
if(b < 0) a *= -1, b *= -1;
return a>0 ? (a-1)/b+1 : a/b;
}
constexpr lint mod = 1000000007;
constexpr lint INF = mod * mod;
constexpr int MAX = 100010;
int sum[5010][5010];
int main(){
int n, m;
scanf("%d%d", &n, &m);
vector<int> vx, vy;
int x[n], y[n];
rep(i, n){
scanf("%d%d", &x[i], &y[i]);
vx.push_back(x[i]);
vy.push_back(y[i]);
}
sort(vx.begin(), vx.end());
vx.erase(unique(vx.begin(), vx.end()), vx.end());
sort(vy.begin(), vy.end());
vy.erase(unique(vy.begin(), vy.end()), vy.end());
rep(i, n){
int ix = lower_bound(vx.begin(), vx.end(), x[i]) - vx.begin();
int iy = lower_bound(vy.begin(), vy.end(), y[i]) - vy.begin();
++sum[ix+1][iy+1];
}
rep(i, vx.size()+5)rep(j, vy.size()+5) sum[i][j+1] += sum[i][j];
rep(j, vy.size()+5)rep(i, vx.size()+5) sum[i+1][j] += sum[i][j];
rep(_, m){
int p, q, r, s;
scanf("%d%d%d%d", &p, &q, &r, &s);
int l = lower_bound(vx.begin(), vx.end(), p) - vx.begin();
int u = lower_bound(vy.begin(), vy.end(), q) - vy.begin();
int rr = upper_bound(vx.begin(), vx.end(), r) - vx.begin();
int d = upper_bound(vy.begin(), vy.end(), s) - vy.begin();
printf("%d\n", sum[rr][d] - sum[rr][u] - sum[l][d] + sum[l][u]);
}
}
|
#include<algorithm>
#include<vector>
#include<stack>
#include<deque>
#include<iostream>
#include<cstdio>
#define F first
#define S second
#define LIM 1000000010
#define pb push_back
#define all(n) n.begin(),n.end()
using namespace std;
typedef pair<int,int> P;
int dp[5002][5002];
int main(){
int n,m;
vector<int> X,Y;
while(cin >> n >> m){
for(int i=0;i<n;i++)for(int j=0;j<n;j++)dp[j][i] = 0;
for(int i=0;i<n;i++){
int x,y;
cin >> x >> y;
X.pb(x); Y.pb(y);
}
vector<int> x,y;
x = X;
y = Y;
X.pb(-LIM); X.pb(LIM); Y.pb(-LIM); Y.pb(LIM);
sort(all(X)); sort(all(Y));
X.erase(unique(all(X)),X.end());
Y.erase(unique(all(Y)),Y.end());
for(int i=0;i<n;i++){
x[i] = find(all(X),x[i])-X.begin();
y[i] = find(all(Y),y[i])-Y.begin();
dp[y[i]][x[i]]++;
}
for(int i=0;i<n;i++){
for(int j=0;j<n;j++){
dp[i+1][j+1] += dp[i+1][j]+dp[i][j+1]-dp[i][j];
}
}
for(int i=0;i<m;i++){
int sx,sy,gx,gy;
cin >> sx >> sy >> gx >> gy;
sx = lower_bound(all(X),sx)-X.begin();
sy = lower_bound(all(Y),sy)-Y.begin();
gx = upper_bound(all(X),gx)-X.begin()-1;
gy = upper_bound(all(Y),gy)-Y.begin()-1;
cout << dp[gy][gx]-dp[gy][sx-1]-dp[sy-1][gx]+dp[sy-1][sx-1] << endl;
}
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main(){
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
for (int i = 0; i < n; i++){
cin >> x[i] >> y[i];
}
vector<int> xpos;
for (int i = 0; i < n; i++){
xpos.push_back(x[i]);
}
sort(xpos.begin(), xpos.end());
xpos.erase(unique(xpos.begin(), xpos.end()), xpos.end());
int xcnt = xpos.size();
map<int, int> mpx;
for (int i = 0; i < xcnt; i++){
mpx[xpos[i]] = i;
}
for (int i = 0; i < n; i++){
x[i] = mpx[x[i]];
}
vector<int> ypos;
for (int i = 0; i < n; i++){
ypos.push_back(y[i]);
}
sort(ypos.begin(), ypos.end());
ypos.erase(unique(ypos.begin(), ypos.end()), ypos.end());
int ycnt = ypos.size();
map<int, int> mpy;
for (int i = 0; i < ycnt; i++){
mpy[ypos[i]] = i;
}
for (int i = 0; i < n; i++){
y[i] = mpy[y[i]];
}
vector<vector<int>> S(ycnt + 1, vector<int>(xcnt + 1, 0));
for (int i = 0; i < n; i++){
S[y[i] + 1][x[i] + 1]++;
}
for (int i = 1; i <= ycnt; i++){
for (int j = 1; j <= xcnt; j++){
S[i][j] += S[i][j - 1];
}
}
for (int j = 1; j <= xcnt; j++){
for (int i = 1; i <= ycnt; i++){
S[i][j] += S[i - 1][j];
}
}
for (int i = 0; i < m; i++){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(xpos.begin(), xpos.end(), x1) - xpos.begin();
y1 = lower_bound(ypos.begin(), ypos.end(), y1) - ypos.begin();
x2 = upper_bound(xpos.begin(), xpos.end(), x2) - xpos.begin();
y2 = upper_bound(ypos.begin(), ypos.end(), y2) - ypos.begin();
cout << S[y2][x2] - S[y2][x1] - S[y1][x2] + S[y1][x1] << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define for_(i,a,b) for(int i=(a);i<(b);++i)
#define allof(a) (a).begin(),(a).end()
void uniqueVector(vector< int >& vec) {
sort(allof(vec));
vec.erase(unique(allof(vec)), vec.end());
}
void solve(
int n, int m,
const vector< int >& tx, const vector< int >& ty,
const vector< int >& lft, const vector< int >& bot,
const vector< int >& rgt, const vector< int >& top
) {
vector< int > x_sort = tx, y_sort = ty;
uniqueVector(x_sort);
uniqueVector(y_sort);
vector< vector< int > > imos(n + 1, vector< int >(n + 1, 0));
for_(i,0,n) {
int x = lower_bound(allof(x_sort), tx[i]) - x_sort.begin() + 1;
int y = lower_bound(allof(y_sort), ty[i]) - y_sort.begin() + 1;
++imos[y][x];
}
for_(y,0,n+1) for_(x,0,n) imos[y][x + 1] += imos[y][x];
for_(x,0,n+1) for_(y,0,n) imos[y + 1][x] += imos[y][x];
for_(i,0,m) {
int lx = lower_bound(allof(x_sort), lft[i]) - x_sort.begin() + 1;
int by = lower_bound(allof(y_sort), bot[i]) - y_sort.begin() + 1;
int rx = upper_bound(allof(x_sort), rgt[i]) - x_sort.begin();
int ty = upper_bound(allof(y_sort), top[i]) - y_sort.begin();
printf("%d\n", imos[ty][rx] - imos[ty][lx - 1] - imos[by - 1][rx] + imos[by - 1][lx - 1]);
}
}
int main() {
int n, m;
assert(scanf("%d %d", &n, &m) == 2);
vector< int > tx(n), ty(n);
for_(i,0,n) assert(scanf("%d %d", &tx[i], &ty[i]) == 2);
vector< int > lft(m), bot(m), rgt(m), top(m);
for_(i,0,m) assert(scanf("%d %d %d %d", &lft[i], &bot[i], &rgt[i], &top[i]) == 4);
solve(n, m, tx, ty, lft, bot, rgt, top);
} |
#include <bits/stdc++.h>
#define INF 2e9
#define x first
#define y second
using namespace std;
typedef pair<int,int> P;
P in[5002];
int n,m;
int main(){
cin>>n>>m;
for(int i=0;i<n;i++) cin>>in[i].x>>in[i].y;
sort(in,in+n);
int a,b,c,d;
while(m--){
scanf("%d%d%d%d",&a,&b,&c,&d);
int cnt=0;
for(int i=0;i<n;i++){
if((a<=in[i].x&&in[i].x<=c)&&(b<=in[i].y&&in[i].y<=d))cnt++;
}
cout <<cnt<<endl;
}
return 0;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
inline int index(const vector<int> &xs, int x){
return lower_bound(xs.begin(), xs.end(), x) - xs.begin();
}
int main(){
int n, m;
scanf("%d%d", &n, &m);
vector<int> tx(n + 1), ty(n + 1);
for(int i = 0; i < n; ++i){
scanf("%d%d", &tx[i], &ty[i]);
}
tx[n] = ty[n] = (int)-2e9;
vector<int> xs = tx, ys = ty;
sort(xs.begin(), xs.end());
xs.erase( unique(xs.begin(), xs.end()), xs.end() );
sort(ys.begin(), ys.end());
ys.erase( unique(ys.begin(), ys.end()), ys.end() );
vector<vector<int> > s(xs.size() + 1, vector<int>(ys.size() + 1) );
for(int i = 0; i < n; ++i){
int ix = index(xs, tx[i]);
int iy = index(ys, ty[i]);
++s[ix][iy];
}
for(int i = 0; i <= xs.size(); ++i){
for(int j = 1; j <= ys.size(); ++j){
s[i][j] += s[i][j - 1];
}
}
for(int j = 0; j <= ys.size(); ++j){
for(int i = 1; i <= xs.size(); ++i){
s[i][j] += s[i - 1][j];
}
}
int x1, x2, y1, y2;
for(int i = 0; i < m; ++i){
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
int ix1 = index(xs, x1);
int iy1 = index(ys, y1);
int ix2 = upper_bound(xs.begin(), xs.end(), x2) - xs.begin() - 1;
int iy2 = upper_bound(ys.begin(), ys.end(), y2) - ys.begin() - 1;
int c = s[ix2][iy2] - s[ix1-1][iy2] - s[ix2][iy1-1] + s[ix1-1][iy1-1];
printf("%d\n", c);
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.