text stringlengths 49 983k |
|---|
#include <vector>
#include <list>
#include <map>
#include <set>
#include <stack>
#include <queue>
#include <deque>
#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 <cassert>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(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 EXIST(s,e) ((s).find(e)!=(s).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define EACH(t,i,c) for(t::iterator i=(c).begin(); i!=(c).end(); ++i)
const double EPS = 1e-10;
const double PI = acos(-1.0);
typedef vector<pii> vp;
int main(){
int n,m;
cin>>n>>m;
vp yx(n);
vi y(n),x(n);
REP(i,n){
cin>>yx[i].second>>yx[i].first;
y[i]=yx[i].first;
x[i]=yx[i].second;
}
sort(ALL(y));
sort(ALL(x));
vvi sum(n+1,vi(n+1));
vp y_index,x_index;
REP(i,n){
y_index.push_back(make_pair(yx[i].first,i));
x_index.push_back(make_pair(yx[i].second,i));
}
sort(ALL(y_index));
sort(ALL(x_index));
vi oldindex_to_newindex(n);
REP(i,n){
REP(j,n){
if(x_index[j].second==y_index[i].second){
oldindex_to_newindex[x_index[j].second]=j;
}
}
}
REP(i,n){
int newindex=oldindex_to_newindex[y_index[i].second];
sum[i+1][newindex+1]=1;
}
FOR(i,1,n+1){
FOR(j,1,n+1){
sum[i][j]+=sum[i-1][j];
}
}
FOR(j,1,n+1){
FOR(i,1,n+1){
sum[i][j]+=sum[i][j-1];
}
}
REP(i,m){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
int xt=upper_bound(ALL(x),x2)-x.begin();
int yt=upper_bound(ALL(y),y2)-y.begin();
int xb=lower_bound(ALL(x),x1)-x.begin();
int yb=lower_bound(ALL(y),y1)-y.begin();
cout<<sum[yt][xt]-sum[yt][xb]-sum[yb][xt]+sum[yb][xb]<<endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) REP(i,0,n)
#define REP(i,s,e) for(int i=(s); i<(int)(e); i++)
#define pb push_back
#define all(r) (r).begin(),(r).end()
#define rall(r) (r).rbegin(),(r).rend()
#define fi first
#define se second
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
const ll MOD = 1e9 + 7;
double EPS = 1e-8;
map<int, int> mx, my;
int s[5010][5010];
int get(int x1, int y1, int x2, int y2) {
return s[y2][x2] - s[y1][x2] - s[y2][x1] + s[y1][x1];
}
int main(){
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
rep(i, n) {
cin >> x[i] >> y[i];
mx[x[i]]++;
my[y[i]]++;
}
int cnt_x = 0, cnt_y = 0;
for(auto& p : mx) p.se = ++cnt_x;
for(auto& p : my) p.se = ++cnt_y;
for(int i = 0; i < n; i++) s[my[y[i]]][mx[x[i]]]++;
for(int i = 0; i < 5010; i++) for(int j = 1; j < 5010; j++) s[i][j] += s[i][j-1];
for(int i = 1; i < 5010; i++) for(int j = 0; j < 5010; j++) s[i][j] += s[i-1][j];
rep(i, m) {
int qx1, qy1, qx2, qy2;
cin >> qx1 >> qy1 >> qx2 >> qy2;
int x1, x2, y1, y2;
if(mx.lower_bound(qx1) == mx.end() || my.lower_bound(qy1) == my.end()) {
cout << 0 <<endl;
continue;
}
x1 = (mx.lower_bound(qx1))->se-1;
y1 = (my.lower_bound(qy1))->se-1;
x2 = (--mx.upper_bound(qx2))->se;
y2 = (--my.upper_bound(qy2))->se;
cout << get(x1, y1, x2, y2) << endl;
}
} |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5002;
int n, m;
int x[MAXN], y[MAXN];
int G[MAXN][MAXN];
int main() {
while(cin >> n >> m) {
vector<int> xs, ys;
for(int i = 0; i < n; ++i) {
cin >> x[i] >> y[i];
xs.push_back(x[i]);
ys.push_back(y[i]);
}
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());
memset(G, 0, sizeof(G));
for(int i = 0; i < n; ++i) {
int nx = lower_bound(xs.begin(), xs.end(), x[i]) - xs.begin();
int ny = lower_bound(ys.begin(), ys.end(), y[i]) - ys.begin();
G[1+ny][1+nx] += 1;
}
for(int i = 0; i < MAXN; ++i) {
for(int j = 0; j+1 < MAXN; ++j) {
G[i][j+1] += G[i][j];
}
}
for(int j = 0; j < MAXN; ++j) {
for(int i = 0; i+1 < MAXN; ++i) {
G[i+1][j] += G[i][j];
}
}
while(m--) {
int a, b, c, d;
cin >> a >> b >> c >> d;
a = lower_bound(xs.begin(), xs.end(), a) - xs.begin();
b = lower_bound(ys.begin(), ys.end(), b) - ys.begin();
c = upper_bound(xs.begin(), xs.end(), c) - xs.begin();
d = upper_bound(ys.begin(), ys.end(), d) - ys.begin();
cout << G[d][c] - G[d][a] - G[b][c] + G[b][a] << endl;
}
}
return 0;
} |
#include<iostream>
#include<vector>
#include<algorithm>
#include<cstdio>
#define F first
#define S second
const int LIM = 1e9+5;
using namespace std;
typedef pair<int,int> P;
int n,m;
vector<P> V;
void input(){
cin >> n >> m;
V.resize(n);
for(int i = 0; i < n; i++) cin >> V[i].F >> V[i].S;
}
void solve(){
sort(V.begin(),V.end());
for(int i = 0; i < m; i++){
int l,r,d,u;
scanf("%d %d %d %d",&l,&d,&r,&u);
int ans = 0;
vector<P>::iterator ite = lower_bound(V.begin(),V.end(),P(l,-LIM));
while(ite < V.end()){
if(ite->F > r) break;
if(d <= ite->S && ite->S <= u) ans++;
ite++;
}
printf("%d\n",ans);
}
}
int main(){
input();
solve();
return 0;
} |
#include<iostream>
#include<vector>
#include<map>
#include<algorithm>
using namespace std;
#define fs first
#define sc second
#define MAX 1000000001
int n,m;
int sum[5100][5100];
pair<int,int> p[5100];
vector<int> x,y;
int x1,y1,x2,y2;
int main(){
cin >> n >> m;
for(int i=0;i<n;i++){
cin >> p[i].fs >> p[i].sc;
x.push_back(p[i].fs); y.push_back(p[i].sc);
}
x.push_back(MAX); x.push_back(-MAX);
y.push_back(MAX); y.push_back(-MAX);
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++){
p[i].fs = lower_bound(x.begin(),x.end(),p[i].fs) - x.begin();
p[i].sc = lower_bound(y.begin(),y.end(),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++){
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(x.begin(),x.end(),x1)-x.begin()-1;
y1 = lower_bound(y.begin(),y.end(),y1)-y.begin()-1;
x2 = upper_bound(x.begin(),x.end(),x2)-x.begin()-1;
y2 = upper_bound(y.begin(),y.end(),y2)-y.begin()-1;
cout << sum[x2][y2] - sum[x2][y1] - sum[x1][y2] + sum[x1][y1] << endl;
}
} |
#include<stdio.h>
#include<iostream>
#include<algorithm>
using namespace std;
struct Point{
int x,y;
bool operator<(const Point & p) const{
return x < p.x;
}
};
int main(){
int n,m;cin>>n>>m;
int i,j,k;
Point p[n];
for(i=0;i<n;i++) scanf("%d %d",&p[i].x,&p[i].y);
sort(p,p+n);
int sx,sy,tx,ty;
for(i=0;i<m;i++){
scanf("%d %d %d %d",&sx,&sy,&tx,&ty);
int ans = 0;
for(j=0;j<n;j++) {
if(sx<=p[j].x&&p[j].x<=tx&&sy<=p[j].y&&p[j].y<=ty){
ans++;
}
if(tx<p[j].x) break;
}
printf("%d\n",ans);
}
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++;
}
}
cout << sum << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i,n) for(int i=0;i<(int)n;i++)
int tr_2d[5002][5002];
map<int,int> zip_x,zip_y;
int unzip_x[5000],unzip_y[5000];
pair<int,int> compress(vector<int> &x, vector<int> &y){
// zipで座標->index
// unzipでindex->座標
// x,yは書き換えられるので注意
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,x.size()){
zip_x[x[i]] = i;
unzip_x[i] = x[i];
}
rep(i,y.size()){
zip_y[y[i]] = i;
unzip_y[i] = y[i];
}
return make_pair(x.size(),y.size());
}
void Imos2D(int n){
rep(i,n+1)rep(j,n)tr_2d[i][j+1]+=tr_2d[i][j];
rep(i,n)rep(j,n+1)tr_2d[i+1][j]+=tr_2d[i][j];
}
int sum(int xl,int xr,int yd,int yu){
return tr_2d[xr][yu]-tr_2d[xl][yu]+tr_2d[xl][yd]-tr_2d[xr][yd];
}
signed main(){
int n,m;
cin>>n>>m;
vector<int> tr_x(n),tr_x2(n),tr_y(n),tr_y2(n);
rep(i,n+2){
rep(j,n+2){
tr_2d[i][j]=0;
}
}
rep(i,n){
int x,y;
cin>>x>>y;
tr_x[i] = x;
tr_x2[i] = x;
tr_y[i] = y;
tr_y2[i] = y;
}
//座圧
pair<int,int> size=compress(tr_x2,tr_y2);
// cout<<size.first<<size.second<<endl;
rep(i,n){
int id_x = zip_x[tr_x[i]];
int id_y = zip_y[tr_y[i]];
tr_2d[id_x+1][id_y+1]++;
}
// rep(i,n){
// rep(j,n-1){
// cout<<tr_2d[i][j]<<" ";
// }
// cout<<tr_2d[i][n-1]<<endl;
// }
//2次元累積和
Imos2D(n);
// rep(i,n+1){
// rep(j,n){
// cout<<s[i][j]<<" ";
// }
// cout<<s[i][n]<<endl;
// }
rep(i,m){
int xl,xr,yd,yu;
cin>>xl>>yd>>xr>>yu;
auto ixl = lower_bound(unzip_x,unzip_x+size.first,xl)-unzip_x;
auto ixr = upper_bound(unzip_x,unzip_x+size.first,xr)-unzip_x-1;
auto iyd = lower_bound(unzip_y,unzip_y+size.second,yd)-unzip_y;
auto iyu = upper_bound(unzip_y,unzip_y+size.second,yu)-unzip_y-1;
// cout << xl<<" "<<xr<<" : "<<ixl<< " " <<ixr<<endl;
// cout << yd<<" "<<yu<<" : "<<iyd<< " " <<iyu<<endl;
cout << sum(ixl,ixr+1,iyd,iyu+1)<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#define REP(i, a, n) for(int i = ((int) a); i < ((int) n); i++)
using namespace std;
int N, M, X[5010], Y[5010];
int compress(int *p, vector<int> &s) {
REP(i, 0, N) s.push_back(p[i]);
sort(s.begin(), s.end());
s.erase(unique(s.begin(), s.end()), s.end());
REP(i, 0, N) p[i] = find(s.begin(), s.end(), p[i]) - s.begin();
return s.size();
}
int main(void) {
cin >> N >> M;
REP(i, 0, N) cin >> X[i] >> Y[i];
vector<int> sx, sy;
int w = compress(X, sx);
int h = compress(Y, sy);
int **sum = (int**) malloc((h + 1) * sizeof(int*));
REP(i, 0, h + 1) sum[i] = (int*) malloc((w + 1) * sizeof(int));
REP(i, 0, h + 1) REP(j, 0, w + 1) sum[i][j] = 0;
REP(i, 0, N) sum[Y[i] + 1][X[i] + 1]++;
REP(i, 0, h) REP(j, 0, w + 1) sum[i + 1][j] += sum[i][j];
REP(i, 0, h + 1) REP(j, 0, w) sum[i][j + 1] += sum[i][j];
REP(i, 0, M) {
int lx, rx, ly, ry;
cin >> lx >> ly >> rx >> ry;
int vlx = lower_bound(sx.begin(), sx.end(), lx) - sx.begin();
int vly = lower_bound(sy.begin(), sy.end(), ly) - sy.begin();
int vrx = upper_bound(sx.begin(), sx.end(), rx) - sx.begin();
int vry = upper_bound(sy.begin(), sy.end(), ry) - sy.begin();
cout << (sum[vry][vrx] - sum[vry][vlx] - sum[vly][vrx] + sum[vly][vlx]) << endl;;
}
return 0;
} |
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#include <numeric>
#include <functional>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <climits>
using namespace std;
typedef istringstream ISS;
typedef ostringstream OSS;
typedef vector<string> VS;
typedef int INT;
typedef vector<INT> VI;
typedef vector<VI> VVI;
typedef pair <INT, INT> II;
typedef vector <II> VII;
const int PADDING = 1000000001;
const int SIZE = 5002;
int n, m;
II P[SIZE];
int SX[SIZE], SY[SIZE];
int SXC, SYC;
short CNT[SIZE][SIZE], DP[SIZE][SIZE];
void init() {
memset( DP, 0, sizeof(DP) );
memset( CNT, 0, sizeof(CNT) );
SXC = SYC = 0;
for ( int i = 0; i < n; ++ i ) {
SX[SXC++] = P[i].first;
SY[SYC++] = P[i].second;
}
sort( SX, SX+n );
sort( SY, SY+n );
SXC = unique( SX, SX+n ) - SX;
SYC = unique( SY, SY+n ) - SY;
for ( int i = 0; i < n; ++ i ) {
int a = lower_bound( SX, SX+SXC, P[i].first ) - SX;
int b = lower_bound( SY, SY+SYC, P[i].second ) - SY;
CNT[a][b] ++;
}
}
bool input() {
if ( ! ( cin >> n >> m ) ) return false;
for ( int i = 0; i < n; ++ i ) {
scanf( "%d%d", &P[i].first, &P[i].second );
}
return true;
}
int calc( II p ) {
int *sxp = upper_bound( SX, SX+SXC, p.first );
int *syp = upper_bound( SY, SY+SYC, p.second );
int a = sxp - SX;
int b = syp - SY;
return DP[a][b];
}
int solve( II p1, II p2 ) {
II A( p1.first-1, p2.second ), B = p2, C( p1.first-1, p1.second-1 ), D( p2.first, p1.second-1 );
return calc(B) - calc(A) - calc(D) + calc(C);
}
void solve_host() {
for ( int i = 1; i <= SXC; ++ i ) {
for ( int j = 1; j <= SYC; ++ j ) {
DP[i][j] = DP[i-1][j] + DP[i][j-1] - DP[i-1][j-1] + CNT[i-1][j-1];
}
}
II p1, p2;
for ( int i = 0; i < m; ++ i ) {
scanf( "%d%d%d%d", &p1.first, &p1.second, &p2.first, &p2.second );
printf( "%d\n", solve( p1, p2 ) );
}
}
int main() {
while ( input() ) {
init();
solve_host();
}
return 0;
} |
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
const int inf = 1e9+7;
int main(){
int n,m;
cin >> n >> m;
vector<int> x(n+1), y(n+1);
vector<pair<int,int> > xy(n+1);
for(int i=0; i<n; i++){
cin >> x[i] >> y[i];
xy[i] = make_pair(x[i],y[i]);
}
x[n]=inf; y[n]=inf;
xy[n]=make_pair(inf,inf);
sort(x.begin(), x.end());
sort(y.begin(), y.end());
sort(xy.begin(), xy.end());
vector<pair<int, int> > nx, ny;
for(int i=0; i<n+1; i++){
nx.push_back(make_pair(x[i], 1));
for(int j=i+1; j<n+1; j++){
if(x[i]==x[j]){
nx.back().second++;
}else{
i=j-1;
break;
}
}
}
for(int i=0; i<n+1; i++){
ny.push_back(make_pair(y[i], 1));
for(int j=i+1; j<n+1; j++){
if(y[i]==y[j]){
ny.back().second++;
}else{
i=j-1;
break;
}
}
}
vector<vector<int> > lsum(nx.size(), vector<int>(ny.size()));
int pidx = 0;
int remain = n+1;
for(int i=0; i<(int)nx.size(); i++){
lsum[i][0] = remain;
for(int j=1; j<(int)ny.size(); j++){
lsum[i][j] = lsum[i][j-1] -ny[j-1].second;
}
while(xy[pidx].first == nx[i].first){
remain--;
vector<pair<int,int> >::iterator it;
it = lower_bound(ny.begin(), ny.end(), make_pair(xy[pidx].second, 0));
it->second--;
pidx++;
}
}
for(int i=0; i<m; i++){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
vector<pair<int, int> >:: iterator it;
it = lower_bound(nx.begin(), nx.end(), make_pair(x1, 0));
x1 = it-nx.begin();
it = lower_bound(nx.begin(), nx.end(), make_pair(x2+1, 0));
x2 = it-nx.begin();
it = lower_bound(ny.begin(), ny.end(), make_pair(y1, 0));
y1 = it-ny.begin();
it = lower_bound(ny.begin(), ny.end(), make_pair(y2+1, 0));
y2 = it-ny.begin();
cout << lsum[x1][y1] -lsum[x2][y1] -lsum[x1][y2] +lsum[x2][y2] << endl;
}
return 0;
} |
#include <iostream>
#include <vector>
#include <map>
#include <set>
#include <algorithm>
using namespace std;
int dp[5001][5001];
int get(const vector<int> &xs, const vector<int> &ys, int x, int y) {
if (*xs.begin() > x || *ys.begin() > y) return 0;
int px = lower_bound(xs.begin(), xs.end(), x) - xs.begin();
int py = lower_bound(ys.begin(), ys.end(), y) - ys.begin();
if (lower_bound(xs.begin(), xs.end(), x) == xs.end()
|| *lower_bound(xs.begin(), xs.end(), x) != x) px--;
if (lower_bound(ys.begin(), ys.end(), y) == ys.end()
|| *lower_bound(ys.begin(), ys.end(), y) != y) py--;
//cout<<x<<" "<<y<<" "<<px<<" "<<py<<endl;
return dp[py][px];
}
int main() {
int n,m;
cin>>n>>m;
set<int> xs, ys;
vector<int> inx(n), iny(n);
for (int i=0; i<n; ++i) {
cin>>inx[i]>>iny[i];
xs.insert(inx[i]);
ys.insert(iny[i]);
}
map<int,int> xmap, ymap;
int cnt = 0;
vector<int> vx, vy;
for (set<int>::iterator x = xs.begin(); x != xs.end(); ++x) {
xmap[*x] = cnt++;
vx.push_back(*x);
}
cnt = 0;
for (set<int>::iterator y = ys.begin(); y != ys.end(); ++y) {
ymap[*y] = cnt++;
vy.push_back(*y);
}
for (int i=0; i<n; ++i)
dp[ymap[iny[i]]][xmap[inx[i]]] += 1;
const int ny = ys.size();
const int nx = xs.size();
for (int i=0; i<ny; ++i)
for (int j=0; j<nx; ++j) {
int r = i?dp[i-1][j]:0;
r += j?dp[i][j-1]:0;
r -= (i>0&&j>0)?dp[i-1][j-1]:0;
dp[i][j] += r;
}
for (int i=0; i<m; ++i) {
int x1,y1,x2,y2;
cin>>x2>>y2>>x1>>y1; x2--, y2--;
int ans = get(vx,vy,x1,y1) - get(vx,vy,x2,y1) - get(vx,vy,x1,y2) + get(vx,vy,x2,y2);
cout<<ans<<endl;
}
} |
#include<iostream>
#include<algorithm>
#include<vector>
#include<map>
using namespace std;
#define REP(i, a, n) for(int i=a; i<n; i++)
struct St {
int x1;
int y1;
int x2;
int y2;
};
St r[500001];
int imos[5001][5001];
int main()
{
int n, m;
vector<int> x, y;
vector<int> vx, vy;
cin >> n >> m;
REP(i, 0, n) {
int xx, yy;
cin >> xx >> yy;
x.push_back(xx);
y.push_back(yy);
vx.push_back(xx);
vy.push_back(yy);
}
REP(i, 0, m) {
cin >> r[i].x1 >> r[i].y1 >> r[i].x2 >> r[i].y2;
}
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, 0, n + 1) imos[i][0] = imos[0][i] = 0;
REP(i, 0, n) {
int tx = lower_bound(x.begin(), x.end(), vx[i]) - x.begin();
int ty = lower_bound(y.begin(), y.end(), vy[i]) - y.begin();
++imos[ty + 1][tx + 1];
}
REP(i, 0, y.size()) {
REP(j, 0, x.size()) {
imos[i + 1][j + 1] += imos[i + 1][j] + imos[i][j + 1] - imos[i][j];
}
}
REP(i, 0, m) {
int xx1, yy1, xx2, yy2;
xx1 = lower_bound(x.begin(), x.end(), r[i].x1) - x.begin();
yy1 = lower_bound(y.begin(), y.end(), r[i].y1) - y.begin();
xx2 = lower_bound(x.begin(), x.end(), r[i].x2 + 1) - x.begin();
yy2 = lower_bound(y.begin(), y.end(), r[i].y2 + 1) - y.begin();
cout << imos[yy2][xx2] - imos[yy2][xx1] - imos[yy1][xx2] + imos[yy1][xx1] << endl;
}
return 0;
} |
#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] = 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 <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int T[5005][5005];
int main() {
int n,m;
cin >> n >> m;
vector<int> x(n),y(n),vx(n),vy(n);
rep(i,n) {
cin >> x[i] >> y[i];
vx[i] = x[i];
vy[i] = y[i];
}
sort(vx.begin(),vx.end());
sort(vy.begin(),vy.end());
vx.erase(unique(vx.begin(),vx.end()),vx.end());
vy.erase(unique(vy.begin(),vy.end()),vy.end());
rep(i,n) {
x[i] = lower_bound(vx.begin(),vx.end(),x[i]) - vx.begin();
y[i] = lower_bound(vy.begin(),vy.end(),y[i]) - vy.begin();
}
memset(T,0,sizeof(T));
rep(i,n) {
T[x[i]+1][y[i]+1]++;
}
int h = vx.size();
int w = vy.size();
rep(i,h+1) {
REP(j,1,w+1) {
T[i][j] += T[i][j-1];
}
}
REP(i,1,h+1) {
rep(j,w+1) {
T[i][j] += T[i-1][j];
}
}
rep(i,m) {
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
int nx1 = lower_bound(vx.begin(),vx.end(),x1) - vx.begin();
int ny1 = lower_bound(vy.begin(),vy.end(),y1) - vy.begin();
int nx2 = upper_bound(vx.begin(),vx.end(),x2) - vx.begin();
int ny2 = upper_bound(vy.begin(),vy.end(),y2) - vy.begin();
// cout << T[nx2][ny2] << endl;
// cout << T[nx1][ny2] << endl;
// cout << T[nx2][ny1] << endl;
// cout << T[nx1][ny1] << endl;
cout << T[nx2][ny2] - T[nx1][ny2] - T[nx2][ny1] + T[nx1][ny1] << endl;
}
return 0;
} |
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using P = pair<ll, ll>;
constexpr ld EPS = 1e-12;
constexpr int INF = numeric_limits<int>::max() / 2;
constexpr int MOD = 1e9 + 7;
vector<vector<int>> sum(6000, vector<int>(6000, 0));
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
vector<P> v(n);
set<ll> xst, yst;
for (int i = 0; i < n; i++)
{
ll x, y;
cin >> x >> y;
x += 1e10;
y += 1e10;
v[i] = P(x, y);
xst.insert(x);
yst.insert(y);
}
map<int, int> xmp, ymp;
int idx = 1;
xmp[0] = 0;
for (auto x : xst)
{
xmp[x] = idx;
idx++;
}
idx = 1;
ymp[0] = 0;
for (auto y : yst)
{
ymp[y] = idx;
idx++;
}
int xsz = xst.size(), ysz = yst.size();
for (int i = 0; i < n; i++)
{
ll x = v[i].first, y = v[i].second;
x = xmp[x];
y = ymp[y];
sum[x][y]++;
}
for (int i = 1; i <= xsz; i++)
{
for (int j = 1; j <= ysz; j++)
{
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
}
}
for (int i = 0; i < m; i++)
{
ll sx, sy, gx, gy;
cin >> sx >> sy >> gx >> gy;
sx += 1e10;
sy += 1e10;
gx += 1e10;
gy += 1e10;
auto x1 = xst.lower_bound(sx);
auto y1 = yst.lower_bound(sy);
auto x2 = xst.upper_bound(gx);
auto y2 = yst.upper_bound(gy);
if (x1 == xst.end() || y1 == yst.end())
{
cout << 0 << endl;
continue;
}
x2--;
y2--;
sx = xmp[*x1];
sy = ymp[*y1];
gx = xmp[*x2];
gy = ymp[*y2];
//cout<<sx<<" "<<sy<<" "<<gx<<" "<<gy<<endl;
cout << sum[gx][gy] - sum[sx - 1][gy] - sum[gx][sy - 1] + sum[sx - 1][sy - 1] << endl;
}
}
|
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
#pragma warning(disable:4996)
int n, m;
pair<int, int> x[10000];
int a, b, c, d, e, f, g, h, sum, l, r, mi;
int main() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
scanf("%d %d", &x[i].first, &x[i].second);
}
sort(x, x + n);
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &a, &b, &c, &d);
sum = 0;
l = 0; r = n; mi = n / 2;
for (int j = 0; j < 30; j++) {
mi = (l + r) / 2;
if (x[mi].first < a) {
l = mi;
}
if (x[mi].first > a) {
r = mi;
}
}
e = mi;
l = 0; r = n;
for (int j = 0; j < 30; j++) {
mi = (l + r) / 2;
if (x[mi].first < c) {
l = mi;
}
if (x[mi].first > c) {
r = mi;
}
}
f = mi;
g = max(0, e - 5);
h = min(n - 1, f + 5);
for (int j = g; j <= h; j++) {
if (a <= x[j].first) {
if (x[j].first <= c) {
if (b <= x[j].second) {
if (x[j].second <= d) {
sum++;
}
}
}
}
}
printf("%d\n", sum);
}
} |
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
#define all(c) (c).begin(), (c).end()
#define loop(i,a,b) for(int i=a; i<int(b); i++)
#define rep(i,b) loop(i,0,b)
template<typename T>
inline void compless(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 n,m;
int xs[5000], ys[5000];
int sum[5100][5100]={};
int main(){
scanf("%d%d",&n,&m);
vector<int> x(n),y(n);
rep(i,n){
scanf("%d%d",xs+i,ys+i);
x[i]=xs[i];
y[i]=ys[i];
}
compless(x);
compless(y);
rep(i,n){
int fx=idx(xs[i],x);
int fy=idx(ys[i],y);
sum[fy+1][fx+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 lx,ly,rx,ry;
scanf("%d%d%d%d",&lx,&ly,&rx,&ry);
lx = idx(lx,x);
rx = idx(rx+1,x);
ly = idx(ly,y);
ry = idx(ry+1,y);
printf("%d\n",sum[ry][rx]-sum[ry][lx]-sum[ly][rx]+sum[ly][lx]);
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
#include <stack>
#include <cstring>
#include <string>
#include <queue>
#include <cmath>
#define rep(i,n) for(int i = 0; i < (n); i++)
#define all(v) (v).begin(), (v).end()
#define rev(v) (v).rbegin(), (v).rend()
#define MP make_pair
#define X first
#define Y second
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> P;
typedef long long ll;
int main(){
//freopen("test.txt", "r", stdin);
int n, m;
cin >> n >> m;
vector<P> t(n);
rep(i, n) cin >> t[i].X >> t[i].Y;
sort(all(t));
rep(i, m){
int lx, by, rx, ty;
cin >> lx >> by >> rx >> ty;
vector<P>::iterator left, right;
left = lower_bound(all(t), MP(lx, -1<<30));
right = lower_bound(all(t), MP(rx, 1<<30));
int cnt = 0;
for(; left != right; left++){
if(left->Y >= by && left->Y <= ty) cnt++;
}
cout << cnt << endl;
}
return 0;
} |
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define INF (1<<29)
#define EPS (1e-10)
#define mp make_pair
#define pb push_back
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef pair<int,int> pii;
int dx[] = {0,1,0,-1}, dy[] = {1,0,-1,0};
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 <iostream>
#include <map>
#include <algorithm>
#include <vector>
using namespace std;
#define REP(i,n) for(integer i=0;i<(integer)(n);i++)
typedef long long int integer;
typedef pair<integer,integer> P;
const int MAX = 5004;
int acc[MAX + 8][MAX + 8];
int trecd[MAX + 8][MAX + 8];
int main() {
integer n, m;
cin >> n >> m;
vector<integer> xs, ys;
vector<P> treasures(n);
for (P &p : treasures) {
cin >> p.first >> p.second;
xs.push_back(p.first);
ys.push_back(p.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());
vector<integer> rxs = xs, rys = ys;
reverse(rxs.begin(), rxs.end());
for (integer &rx : rxs) rx = -rx;
reverse(rys.begin(), rys.end());
for (integer &ry : rys) ry = -ry;
for (P p : treasures) {
integer x = find(xs.begin(), xs.end(), p.first) - xs.begin() + 1;
integer y = find(ys.begin(), ys.end(), p.second) - ys.begin() + 1;
trecd[x][y]++;
}
for (integer y = 1; y < MAX; y++) for (integer x = 1; x < MAX; x++) {
acc[x][y] = acc[x][y-1] + acc[x-1][y] - acc[x-1][y-1] + trecd[x][y];
}
REP (i, m) {
integer xb, yb, xe, ye;
cin >> xb >> yb >> xe >> ye;
xb = lower_bound(xs.begin(), xs.end(), xb) - xs.begin() + 1;
yb = lower_bound(ys.begin(), ys.end(), yb) - ys.begin() + 1;
xe = rxs.end() - lower_bound(rxs.begin(), rxs.end(), -xe);
ye = rys.end() - lower_bound(rys.begin(), rys.end(), -ye);
integer ans = acc[xe][ye] - acc[xb-1][ye] - acc[xe][yb-1]
+ acc[xb-1][yb-1];
cout << ans << endl;
}
} |
#include <iostream>
#include <vector>
#include <string>
#include <cstring>
#include <algorithm>
#define REP(i,k,n) for(int i=k;i<n;i++)
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef long long ll;
int main() {
int n,m;
cin >> n >> m;
vector<pair<int,int> > v;
rep(i,n) {
int x,y;
cin >> x >> y;
v.push_back(make_pair(x,y));
}
sort(v.begin(),v.end());
rep(i,m) {
int ans = 0;
int x1,y1,x2,y2;
cin >> x1 >> y1 >> x2 >> y2;
rep(j,n) {
int X = v[j].first;
int Y = v[j].second;
if(X < x1) continue;
REP(k,j,n) {
int X2 = v[k].first;
int Y2 = v[k].second;
if(X2 > x2) break;
if(y1 <= Y2 && Y2 <= y2) ans++;
}
break;
}
cout << ans << endl;
}
return 0;
} |
#include <algorithm>
#include <functional>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <vector>
#include <list>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <bitset>
#include <climits>
#define all(c) (c).begin(), (c).end()
#define rep(i,n) for(int i=0;i<(n);i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF=100000000;
int dx[4]={1,0,-1,0};
int dy[4]={0,1,0,-1};
using namespace std;
typedef pair<int ,int > P;
typedef long long ll;
int n,m;
int sum[5003][5003];
int x[5003],y[5003];
vector<int> comp(int *a) {
vector<int> vec;
rep(i,n) vec.pb(a[i]);
sort(all(vec));
vec.erase(unique(all(vec)),vec.end());
return vec;
}
int conv(vector<int> &vec,int x) {
return lower_bound(all(vec),x)-vec.begin();
}
int main() {
cin>>n>>m;
rep(i,n) {
cin>>x[i]>>y[i];
}
vector<int> comp_x=comp(x);
vector<int> comp_y=comp(y);
rep(i,n) {
//printf("%d %d -> ",y[i],x[i]);
int nx=conv(comp_x,x[i]);
int ny=conv(comp_y,y[i]);
//printf("%d %d\n",ny,nx);
sum[ny+1][nx+1]++;
}
rep(i,comp_y.size()+1) rep(j,comp_x.size()+1) if(i&&j) {
sum[i][j]+=sum[i-1][j]+sum[i][j-1]-sum[i-1][j-1];
}
rep(i,m) {
int x1,x2;
int y1,y2;
cin>>x1>>y1>>x2>>y2;
x1=conv(comp_x,x1);
x2=conv(comp_x,x2+1);
y1=conv(comp_y,y1);
y2=conv(comp_y,y2+1);
printf("%d\n",sum[y2][x2]-sum[y2][x1]-sum[y1][x2]+sum[y1][x1]);
}
return 0;
} |
#include<iostream>
#include<algorithm>
#include<vector>
using namespace std;
int compress( vector< int >& x){
sort(x.begin(),x.end());
x.erase(unique(x.begin(),x.end()),x.end());
return x.size();
}
int calc(vector<vector<int> >& mas,int y, int x, int ny, int nx){
return mas[ny][nx] + mas[y - 1][x - 1] - mas[y - 1][nx] - mas[ny][x - 1];
}
int main(){
int n, m;
vector< int > x, y, cx, cy; //ああ
const int INF = 1e9 + 1;
cin >> n >> m;
x.resize(n + 2), y.resize(n + 2), cx.resize(n), cy.resize(n);
x[n] = INF, y[n] = INF, x[n + 1] = -INF, y[n + 1] = -INF;
for(int i = 0; i < n; i++){
cin >> x[i] >> y[i];
cx[i] = x[i], cy[i] = y[i];
}
static vector< vector< int > > mas( compress(y) + 1, vector< int >( compress(x) + 1, 0));
for(int i = 0; i < n; i++){
int yy = lower_bound(y.begin(),y.end(),cy[i])-y.begin();
int xx = lower_bound(x.begin(),x.end(),cx[i])-x.begin();
mas[yy][xx]++;
}
for(int i = 0; i < mas.size() - 1; i++){
for(int j = 0; j < mas[i].size() - 1; j++){
mas[i + 1][j + 1] += mas[i + 1][j] + mas[i][j + 1] - mas[i][j];
}
}
int x1, y1, x2, y2;
while(m--){
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound( x.begin(), x.end(), x1) - x.begin();
x2 = upper_bound( x.begin(), x.end(), x2) - x.begin() - 1;
y1 = lower_bound( y.begin(), y.end(), y1) - y.begin();
y2 = upper_bound( y.begin(), y.end(), y2) - y.begin() - 1;
cout << calc(mas,y1,x1,y2,x2) << endl;
}
} |
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int main()
{
int N, M;
cin >> N >> M;
vector<int> xs, ys;
vector<pair<int,int> > v(N);
for (int i = 0; i < N; i++) {
cin >> v[i].first >> v[i].second;
xs.push_back(v[i].first);
ys.push_back(v[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());
static const int MAXN = 5000;
static int grid[MAXN][MAXN];
for (vector<pair<int,int> >::const_iterator it = v.begin(); it != v.end(); ++it) {
const int xi = distance(xs.begin(), lower_bound(xs.begin(), xs.end(), it->first));
const int yi = distance(ys.begin(), lower_bound(ys.begin(), ys.end(), it->second));
++grid[xi][yi];
}
static int sums[MAXN+1][MAXN+1];
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
sums[i+1][j+1] = sums[i][j+1] + sums[i+1][j] - sums[i][j] + grid[i][j];
}
}
for (int i = 0; i < M; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
const int xi1 = distance(xs.begin(), lower_bound(xs.begin(), xs.end(), x1));
const int yi1 = distance(ys.begin(), lower_bound(ys.begin(), ys.end(), y1));
const int xi2 = distance(xs.begin(), lower_bound(xs.begin(), xs.end(), x2+1));
const int yi2 = distance(ys.begin(), lower_bound(ys.begin(), ys.end(), y2+1));
cout << sums[xi2][yi2] - sums[xi2][yi1] - sums[xi1][yi2] + sums[xi1][yi1] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define repr(i,n) for(int i=(int)(n-1);i>=0;i--)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout << #x" = " << x << endl
#define print(x) cout << x << endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<int, P> PIP;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
typedef set<int> S;
#define INF INT_MAX
#define MAX_N 1000000001
int n, m;
P treasure[5000];
int main(){
cin.sync_with_stdio(false);
cin >> n >> m;
rep(i, n) {
int x, y;
cin >> x >> y;
treasure[i] = P(x, y);
}
sort(treasure, treasure + n);
rep(i, m) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int up = upper_bound(treasure, treasure + n, P(x2, INF)) - treasure;
int low = lower_bound(treasure, treasure + n, P(x1, -INF)) - treasure;
int cnt = 0;
repl(j, low, up) {
if (y1 <= treasure[j].se && treasure[j].se <= y2) cnt++;
}
cout << cnt << endl;
}
return 0;
} |
#define _CRT_SECURE_NO_WARNINGS
#pragma comment (linker, "/STACK:526000000")
#include "bits/stdc++.h"
using namespace std;
typedef string::const_iterator State;
#define eps 1e-11L
#define MAX_MOD 1000000007LL
#define GYAKU 500000004LL
#define MOD 998244353LL
#define seg_size 262144 * 4LL
#define pb push_back
#define mp make_pair
typedef long long ll;
#define REP(a,b) for(long long (a) = 0;(a) < (b);++(a))
#define ALL(x) (x).begin(),(x).end()
unsigned long xor128() {
static unsigned long x = 123456789, y = 362436069, z = 521288629, w = time(NULL);
unsigned long t = (x ^ (x << 11));
x = y; y = z; z = w;
return (w = (w ^ (w >> 19)) ^ (t ^ (t >> 8)));
}
void init() {
iostream::sync_with_stdio(false);
cout << fixed << setprecision(20);
}
#define int ll
int grid[5003][5003];
void solve() {
int n, m;
cin >> n >> m;
map<int, int> x, y;
vector<pair<int, int>> inputs;
REP(i, n) {
int a, b;
cin >> a >> b;
inputs.push_back(mp(a, b));
x[a] = 1;
y[b] = 1;
}
x[2e9] = 1;
y[2e9] = 1;
int cnt = 1;
for (auto i = x.begin(); i != x.end();++i) {
i->second = cnt;
cnt++;
}
cnt = 1;
for (auto i = y.begin(); i != y.end(); ++i) {
i->second = cnt;
cnt++;
}
REP(i, inputs.size()) {
grid[x[inputs[i].first]][y[inputs[i].second]]++;
}
REP(i, 5002) {
REP(q, 5002) {
grid[i][q + 1] += grid[i][q];
}
}
REP(i, 5002) {
REP(q, 5002) {
grid[q + 1][i] += grid[q][i];
}
}
REP(i, m) {
pair<int, int> go[2];
REP(q, 2) {
cin >> go[q].first >> go[q].second;
go[q].first += q;
go[q].second += q;
go[q].first = (*(x.lower_bound(go[q].first))).second;
go[q].second = (*(y.lower_bound(go[q].second))).second;
go[q].first -= q;
go[q].second -= q;
}
int ans = grid[go[1].first][go[1].second];
ans -= grid[go[0].first - 1][go[1].second];
ans -= grid[go[1].first][go[0].second - 1];
ans += grid[go[0].first - 1][go[0].second - 1];
cout << ans << endl;
}
}
#undef int
int main() {
solve();
}
|
// 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 == treasure.end() || *it > mp(x2,y2) ) break;
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 <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int map[5003][5003] = {0};
int main() {
long long int n, m, input_x, input_y;
cin >> n >> m;
vector< long long int > x, y, x_s, y_s;
x_s.push_back( -10000000000 );
x_s.push_back( 10000000000 );
y_s.push_back( -10000000000 );
y_s.push_back( 10000000000 );
for ( long long int i = 0; i < n; i++ ) {
cin >> input_x >> input_y;
x.push_back( input_x );
y.push_back( input_y );
x_s.push_back( input_x );
y_s.push_back( input_y );
}
sort( x_s.begin(), x_s.end() );
x_s.erase( unique( x_s.begin(), x_s.end() ), x_s.end() );
sort( y_s.begin(), y_s.end() );
y_s.erase( unique( y_s.begin(), y_s.end() ), y_s.end() );
vector< long long int >:: iterator it;
for ( long long int i = 0; i < n; i++ ) {
it = lower_bound( x_s.begin(), x_s.end(), x[i] );
x[i] = distance( x_s.begin(), it );
it = lower_bound( y_s.begin(), y_s.end(), y[i] );
y[i] = distance( y_s.begin(), it );
map[ x[i] ][ y[i] ]++;
}
for ( long long int i = 0; i < n+2; i++ ) {
long long int k = 0;
for ( long long int j = 0; j < n+2; j++ ) {
map[j][i] += k;
k = map[j][i];
if ( i > 0 ) {
map[j][i] += map[j][i-1];
}
}
}
/*
for ( long long int i = 0; i < n+2; i++ ) {
for ( long long int j = 0; j < n+2; j++ ) {
cout << map[j][i] << " ";
}
cout << endl;
}
*/
long long int x1, x2, y1, y2;
for ( long long int i = 0; i < m; i++ ) {
cin >> x1 >> y1 >> x2 >> y2;
it = lower_bound( x_s.begin(), x_s.end(), x1 );
x1 = distance( x_s.begin(), it ) - 1;
it = lower_bound( y_s.begin(), y_s.end(), y1 );
y1 = distance( y_s.begin(), it ) - 1;
it = upper_bound( x_s.begin(), x_s.end(), x2 );
x2 = distance( x_s.begin(), it ) - 1;
it = upper_bound( y_s.begin(), y_s.end(), y2 );
y2 = distance( y_s.begin(), it ) - 1;
long long int ans = map[x2][y2];
if ( x1 >= 0 ) ans -= map[x1][y2];
if ( y1 >= 0 ) ans -= map[x2][y1];
if ( x1 >= 0 && y1 >= 0 ) ans += map[x1][y1];
// cout << x1 << " " << y1 << " " << x2 << " " << y2 << endl;
cout << ans << endl;
}
return 0;
} |
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <iostream>
#include <complex>
#include <string>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <cassert>
typedef long long ll;
using namespace std;
#ifndef LOCAL
#define debug(x) ;
#else
#define debug(x) cerr << __LINE__ << " : " << #x << " = " << (x) << endl;
template <typename T1, typename T2>
ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << "{" << p.first << ", " << p.second << "}";
return out;
}
template <typename T>
ostream &operator<<(ostream &out, const vector<T> &v) {
out << '{';
for (const T &item : v) out << item << ", ";
out << "\b\b}";
return out;
}
#endif
#define mod 1000000007 //1e9+7(prime number)
#define INF 1000000000 //1e9
#define LLINF 2000000000000000000LL //2e18
#define SIZE 5010
int sum[SIZE][SIZE];
int main(){
int N, M, x[SIZE], y[SIZE];
vector<int> vecX, vecY;
map<int,int> dicX, dicY;
scanf("%d%d", &N, &M);
for (int i=0; i<N; i++) {
scanf("%d%d", x+i, y+i);
vecX.push_back(x[i]);
vecY.push_back(y[i]);
}
vecX.push_back(-INF-10);
vecY.push_back(-INF-10);
sort(vecX.begin(), vecX.end());
vecX.erase(unique(vecX.begin(), vecX.end()), vecX.end());
sort(vecY.begin(), vecY.end());
vecY.erase(unique(vecY.begin(), vecY.end()), vecY.end());
for (int i=0; i<vecX.size(); i++) dicX[vecX[i]] = i;
for (int i=0; i<vecY.size(); i++) dicY[vecY[i]] = i;
for (int i=0; i<N; i++) {
sum[dicX[x[i]]][dicY[y[i]]]++;
}
for (int i=0; i<=N; i++)
for (int j=0; j<=N; j++)
sum[i+1][j] += sum[i][j];
for (int i=0; i<=N; i++)
for (int j=0; j<=N; j++)
sum[i][j+1] += sum[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(vecX.begin(), vecX.end(), x1) - vecX.begin();
y1 = lower_bound(vecY.begin(), vecY.end(), y1) - vecY.begin();
x2 = lower_bound(vecX.begin(), vecX.end(), x2+1) - vecX.begin() - 1;
y2 = lower_bound(vecY.begin(), vecY.end(), y2+1) - vecY.begin() - 1;
int ans = sum[x1-1][y1-1] + sum[x2][y2] - sum[x1-1][y2] - sum[x2][y1-1];
printf("%d\n", ans);
}
return 0;
}
|
// Author :
// Date :
// Problem:
// Solution:
// Comment:
#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <cmath>
#include <cstring>
#define pp push
#define pb push_back
#define mp make_pair
#define xx first
#define yy second
using namespace std;
vector < pair <int,int> > pts;
int main(){
int n , m;
int x , y;
scanf("%d%d",&n,&m);
for(int i = 0 ; i < n ; i++){
scanf("%d %d",&x,&y);
pts.pb(mp(x,y));
}
int xx,yy;
sort( pts.begin() , pts.end() );
for(int i = 0 ; i < m ; i++){
int cnt = 0;
scanf("%d %d %d %d",&x,&y,&xx,&yy);
for(int j = 0 ; j < n ; j++){
if(x <= pts[j].xx && xx >= pts[j].xx && y <= pts[j].yy && yy >= pts[j].yy){
cnt++;
}
if(x > pts[j].xx && xx < pts[j].xx) break;
}
printf("%d\n",cnt);
}
#ifdef GEREL
for(;;);
#endif
return 0;
} |
#include <stdio.h>
#include <vector>
#include <algorithm>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int n, x[5000], y[5000], m;
vector<int> xs, ys;
int sum[5010][5010];
int of(const vector<int>& xs, int x) {
return lower_bound(xs.begin(), xs.end(), x) - xs.begin();
}
int solve(int x1, int y1, int x2, int y2) {
if (x1 > xs.back() || x2 < xs[0]) return 0;
if (y1 > ys.back() || y2 < ys[0]) return 0;
const int ix1 = of(xs, x1), ix2 = of(xs, x2+1);
const int iy1 = of(ys, y1), iy2 = of(ys, y2+1);
return sum[ix2][iy2] - sum[ix2][iy1] - sum[ix1][iy2] + sum[ix1][iy1];
}
int main() {
scanf("%d%d", &n, &m);
rep (i, n) scanf("%d%d", x+i, y+i);
rep (i, n) xs.push_back(x[i]), ys.push_back(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());
rep (i, n) sum[of(xs, x[i])+1][of(ys, y[i])+1]++;
rep (i, xs.size()+1) rep (j, ys.size()+1) {
if (i) sum[i][j] += sum[i-1][j];
if (j) sum[i][j] += sum[i][j-1];
if (i && j) sum[i][j] -= sum[i-1][j-1];
}
rep (_, m) {
int x1, y1, x2, y2;
scanf("%d%d%d%d", &x1, &y1, &x2, &y2);
printf("%d\n", solve(x1, y1, x2, y2));
}
return 0;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
#define rep(i, n) for(int i = 0; i < (n); ++i)
using namespace std;
int n, m;
int x[5000];
int y[5000];
vector<int> vx;
vector<int> vy;
int f[5000][5000];
void compress(){
rep(i, n){
vx.push_back(x[i]);
vy.push_back(y[i]);
}
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
vx.erase(unique(vx.begin(), vx.end()), vx.end());
vy.erase(unique(vy.begin(), vy.end()), vy.end());
rep(i, n){
x[i] = lower_bound(vx.begin(), vx.end(), x[i]) - vx.begin();
y[i] = lower_bound(vy.begin(), vy.end(), y[i]) - vy.begin();
}
}
void accumulate(){
rep(i, n){
++f[x[i]][y[i]];
}
rep(i, vx.size()){
rep(j, vy.size() - 1){
f[i][j + 1] += f[i][j];
}
}
rep(i, vx.size() - 1){
rep(j, vy.size()){
f[i + 1][j] += f[i][j];
}
}
}
void transform(int&a, int& b, int& c, int& d){
a = lower_bound(vx.begin(), vx.end(), a) - vx.begin();
b = lower_bound(vy.begin(), vy.end(), b) - vy.begin();
c = upper_bound(vx.begin(), vx.end(), c) - vx.begin() - 1;
d = upper_bound(vy.begin(), vy.end(), d) - vy.begin() - 1;
}
int access(int i, int j){
return i >= 0 && j >= 0 ? f[i][j] : 0;
}
int main(){
scanf("%d%d", &n, &m);
rep(i, n){
scanf("%d%d", &x[i], &y[i]);
}
compress();
accumulate();
rep(i, m){
int a, b, c, d;
scanf("%d%d%d%d", &a, &b, &c, &d);
transform(a, b ,c, d);
if(a <= c && b <= d){
printf("%d\n", access(c, d) + access(a - 1, b - 1) - access(c, b - 1) - access(a - 1, d));
}
else{
puts("0");
}
}
return 0;
} |
#include<iostream>
#include<utility>
#include<cstdio>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n,m;cin>>n>>m;
vector<pair<int,int> > pii(n);
for(int i=0;i<n;i++)
cin>>pii[i].first>>pii[i].second;
sort(pii.begin(),pii.end());
for(int i=0;i<m;i++){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
int cnt=0;
for(int j=0;j<n;j++){
if(x1<=pii[j].first&&pii[j].first<=x2&&y1<=pii[j].second&&pii[j].second<=y2)
cnt++;
}
printf("%d\n",cnt);
}
// cout<<ans<<endl;
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll segN=(1LL<<32);
vector<ll> G;
struct data{
vector<ll> *v;
bool flg;
data* ch[2];
void init(){
v=new vector<ll>;
flg=false;
ch[0]=(data*)malloc(sizeof(data));
ch[1]=(data*)malloc(sizeof(data));
ch[0]->ch[0]=NULL;
ch[1]->ch[0]=NULL;
}
void add(ll i,ll x,ll l,ll r){
// cout<<i<<' '<<x<<' '<<l<<' '<<r<<endl;
ll m=(l+r)/2;
if(ch[0]==NULL)init();
if(i<l || r<=i)return;
v->push_back(x);
if(r-l==1)return;
ch[0]->add(i,x,l,m);
ch[1]->add(i,x,m,r);
}
void add(ll i,ll x){
add(i,x,0,segN);
}
ll sum(ll a,ll b,ll c,ll d,ll l,ll r){
ll m=(l+r)/2;
if(ch[0]==NULL)return 0;
if(b<=l || r<=a)return 0;
if(a<=l && r<=b){
if(!flg)sort(v->begin(),v->end());
flg=true;
vector<ll> :: iterator A,B;
A=lower_bound(v->begin(),v->end(),c);
B=upper_bound(v->begin(),v->end(),d);
return B-A;
}
ll res=0;
res+=ch[0]->sum(a,b,c,d,l,m);
res+=ch[1]->sum(a,b,c,d,m,r);
return res;
}
ll sum(ll a,ll b,ll c,ll d){
return sum(a,b,c,d,0,segN);
}
};
data T;
int main(){
ll d=1e9;
int n,m;
int ax,ay,bx,by;
T.init();
scanf("%d %d",&n,&m);
for(int i=0;i<n;i++){
scanf("%d %d",&ax,&ay);
T.add(ax+d,ay);
}
for(int i=0;i<m;i++){
scanf("%d %d %d %d",&ax,&ay,&bx,&by);
cout<<T.sum(ax+d,bx+d+1,ay,by)<<endl;
}
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()
typedef pair< int, int > pii;
int n, m, X[5050], Y[5050], X1[500050], X2[500050], Y1[500050], Y2[500050];
int compress(int *x) {
vector< int > xs;
for_(i,0,n) xs.push_back(x[i]);
sort(allof(xs));
xs.erase(unique(allof(xs)), xs.end());
for_(i,0,n) x[i] = find(allof(xs), x[i]) - xs.begin();
return xs.size();
}
int main() {
cin >> n >> m;
vector< pii > vpx, vpy;
for_(i,0,n) {
scanf("%d %d", &X[i], &Y[i]);
vpx.push_back(pii(X[i], i));
vpy.push_back(pii(Y[i], i));
}
sort(allof(vpx)); sort(allof(vpy));
vector< int > vx, vy;
for_(i,0,n) {
vx.push_back(vpx[i].first);
vy.push_back(vpy[i].first);
}
for_(i,0,m) {
int x1, x2, y1, y2; scanf("%d %d %d %d", &x1, &y1, &x2, &y2);
int ind = lower_bound(allof(vx), x1) - vx.begin();
X1[i] = ind < n ? vpx[ind].second : n;
ind = upper_bound(allof(vx), x2) - vx.begin() - 1;
X2[i] = ind >= 0 ? vpx[ind].second : -1;
ind = lower_bound(allof(vy), y1) - vy.begin();
Y1[i] = ind < n ? vpy[ind].second : n;
ind = upper_bound(allof(vy), y2) - vy.begin() - 1;
Y2[i] = ind >= 0 ? vpy[ind].second : -1;
}
int W = compress(X), H = compress(Y);
vector< vector< int > > grid(H+1, vector< int >(W+1, 0));
for_(i,0,n) ++grid[Y[i]][X[i]];
for_(y,0,H+1) for_(x,0,W+1) {
if (y > 0) grid[y][x] += grid[y-1][x];
if (x > 0) grid[y][x] += grid[y][x-1];
if (y > 0 && x > 0) grid[y][x] -= grid[y-1][x-1];
}
for_(i,0,m) {
int ans = 0;
if (X1[i] < n && X2[i] >= 0 && Y1[i] < n && Y2[i] >= 0) {
int x1 = X[X1[i]], x2 = X[X2[i]], y1 = Y[Y1[i]], y2 = Y[Y2[i]];
ans += grid[y2][x2];
if (x1-1 >= 0) ans -= grid[y2][x1-1];
if (y1-1 >= 0) ans -= grid[y1-1][x2];
if (x1-1 >= 0 && y1-1 >= 0) ans += grid[y1-1][x1-1];
}
printf("%d\n", ans);
}
return 0;
} |
#include<iostream>
#include<sstream>
#include<algorithm>
#include<set>
#include<map>
#include<queue>
#include<complex>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<cassert>
#define rep(i,n) for(int i=0;i<(int)n;i++)
#define all(c) (c).begin(),(c).end()
#define mp make_pair
#define pb push_back
#define each(i,c) for(__typeof((c).begin()) i=(c).begin();i!=(c).end();i++)
#define dbg(x) cerr<<__LINE__<<": "<<#x<<" = "<<(x)<<endl
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int,int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int n, m, s[5010][5010];
vi x, y;
vi vy, vx;
int main(){
scanf("%d%d", &n, &m);
rep(i, n){
int a, b;
scanf("%d%d", &a, &b);
x.pb(a); y.pb(b);
vx.pb(a); vy.pb(b);
}
vx.pb(-inf - 1); vy.pb(-inf - 1);
vx.pb(inf + 1); vy.pb(inf + 1);
sort(all(vx)); sort(all(vy));
rep(i, n){
int a = lower_bound(all(vx), x[i]) - vx.begin();
int b = lower_bound(all(vy), y[i]) - vy.begin();
s[a][b]++;
}
rep(i, vx.size()) rep(j, vy.size()){
s[i + 1][j + 1] += s[i + 1][j] + s[i][j + 1] - s[i][j];
}
rep(i, m){
int x, X, y, Y;
scanf("%d%d%d%d", &x, &y, &X, &Y);
x = lower_bound(all(vx), x) - vx.begin() - 1;
y = lower_bound(all(vy), y) - vy.begin() - 1;
X = lower_bound(all(vx), X + 1) - vx.begin() - 1;
Y = lower_bound(all(vy), Y + 1) - vy.begin() - 1;
printf("%d\n", s[X][Y] - s[x][Y] - s[X][y] + s[x][y]);
}
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;
int mp[5005][5005],n,m;
vector<int> x,y;
// O(n * log n ) n=v.size()
vector<int> compress(vector<int> v){
// v = {4,6,7,1,1,6}
// -> res={1,2,3,0,0,2}
vector<int> copy=v;
sort(v.begin(), v.end());
v.erase( unique( v.begin(), v.end()) , v.end() );
vector<int> res;
for(int i=0;i<(int)copy.size();i++){
int num=lower_bound( v.begin(),v.end(), copy[i] ) - v.begin();
res.push_back( num );
}
return res;
}
int sum(int sx,int sy,int gx,int gy){
sx--,sy--;
if(gx<0||gy<0)return 0;
int res=mp[gx][gy];
if(sx>=0) res-=mp[sx][gy];
if(sy>=0) res-=mp[gx][sy];
if(sx>=0&&sy>=0) res+=mp[sx][sy];
return res;
}
int main(){
cin>>n>>m;
x.resize(n),y.resize(n);
for(int i=0;i<n;i++)cin>>x[i]>>y[i];
vector<int> X,Y;
X=compress(x),Y=compress(y);
for(int i=0;i<n;i++)mp[X[i]][Y[i]]++;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)mp[i][j+1]+=mp[i][j];
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)mp[j+1][i]+=mp[j][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() );
while(m--){
int a,b,c,d;
cin>>a>>b>>c>>d;
int sx=lower_bound(x.begin(),x.end(),a)-x.begin();
int sy=lower_bound(y.begin(),y.end(),b)-y.begin();
int gx=upper_bound(x.begin(),x.end(),c)-x.begin()-1;
int gy=upper_bound(y.begin(),y.end(),d)-y.begin()-1;
cout<<sum(sx,sy,gx,gy)<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX;
const int MAXN = 5000;
const int B = 500;
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;
typedef pair<int, int> pii;
int main(){
int i,n,m;
while(cin >> n >> m){
vector<pii> d(n);
for(i=0;i<n;i++) cin >> d[i].first >> d[i].second;
sort(d.begin(), d.end());
for(i=0;i<m;i++){
int x1,y1,x2,y2,ans=0;
cin >> x1 >> y1 >> x2 >> y2;
vector<pii>::iterator itr1 = lower_bound(d.begin(), d.end(), pii(x1, y1));
vector<pii>::iterator itr2 = upper_bound(d.begin(), d.end(), pii(x2, y2));
for(;itr1!=itr2;++itr1) if(y1 <= (*itr1).second && (*itr1).second <= y2) ans ++;
cout << ans << 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]);
}
random_shuffle(all(X)), random_shuffle(all(Y));
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>
using namespace std;
#define FOR(i,k,n) for(int i = (k); i < (n); i++)
#define REP(i,n) FOR(i,0,n)
#define ALL(a) a.begin(), a.end()
#define MS(m,v) memset(m,v,sizeof(m))
#define D10 fixed<<setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-10;
template<class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template<class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
void compress(vi& v)
{
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
}
int main()
{
int n, m;
cin >> n >> m;
vector<pii> v;
vi vx, vy;
REP(i, n)
{
ld x, y; cin >> x >> y;
vx.push_back(x); vy.push_back(y);
v.emplace_back(x, y);
}
compress(vx);
compress(vy);
vector<vi> sum(n+1, vi(n+1));
REP(i, n)
{
int x = v[i].first, y = v[i].second;
int cx = find(ALL(vx), x) - vx.begin();
int cy = find(ALL(vy), y) - vy.begin();
sum[cx+1][cy+1]++;
}
FOR(i, 1, n + 1)FOR(j, 1, n + 1)
{
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i-1][j-1];
}
REP(i, m)
{
ld lx, ly, rx, ry;
cin >> lx >> ly >> rx >> ry;
rx++; ry++;
int clx = lower_bound(ALL(vx), lx) - vx.begin();
int cly = lower_bound(ALL(vy), ly) - vy.begin();
int crx = lower_bound(ALL(vx), rx) - vx.begin();
int cry = lower_bound(ALL(vy), ry) - vy.begin();
cout << sum[crx][cry] - sum[crx][cly] - sum[clx][cry] + sum[clx][cly] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(nullptr);
ios::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];
}
auto vx = x, vy = y;
sort(begin(vx), end(vx));
vx.erase(unique(begin(vx), end(vx)), end(vx));
sort(begin(vy), end(vy));
vy.erase(unique(begin(vy), end(vy)), end(vy));
auto zip_x = [&](int e) {
return lower_bound(begin(vx), end(vx), e) - begin(vx);
};
auto zip_y = [&](int e) {
return lower_bound(begin(vy), end(vy), e) - begin(vy);
};
int h = vx.size(), w = vy.size();
vector<vector<int>> cum(h + 1, vector<int>(w + 1));
for (int i = 0; i < n; ++i) {
++cum[zip_x(x[i])][zip_y(y[i])];
}
for (int i = 0; i < h; ++i) {
for (int j = w; j--; ) {
cum[i][j] += cum[i][j + 1];
}
}
for (int j = 0; j < w; ++j) {
for (int i = h; i--; ) {
cum[i][j] += cum[i + 1][j];
}
}
while (m--) {
int lx, ly, rx, ry;
cin >> lx >> ly >> rx >> ry;
++rx, ++ry;
lx = zip_x(lx), ly = zip_y(ly);
rx = zip_x(rx), ry = zip_y(ry);
int res = cum[lx][ly] - cum[lx][ry] - cum[rx][ly] + cum[rx][ry];
cout << res << '\n';
}
}
|
#include<iostream>
#include<vector>
#include<algorithm>
#define F first
#define S second
const int LIM = 1e9+5;
using namespace std;
typedef pair<int,int> P;
int n,m;
vector<P> V;
void input(){
cin >> n >> m;
V.resize(n);
for(int i = 0; i < n; i++) cin >> V[i].F >> V[i].S;
}
void solve(){
sort(V.begin(),V.end());
P p1,p2;
for(int i = 0; i < m; i++){
cin >> p1.F >> p1.S >> p2.F >> p2.S;
int ans = 0;
int l = p1.F,r = p2.F,d = p1.S,u = p2.S;
vector<P>::iterator ite = lower_bound(V.begin(),V.end(),P(l,-LIM));
while(ite < V.end()){
if(ite->F > r) break;
// cout << ite->F << " " << ite->S << endl;
if(d <= ite->S && ite->S <= u){
ans++;
}//else ite = lower_bound(V.begin(),V.end(),P(ite->F+1,-LIM));
ite++;
}
cout << ans << endl;
}
}
int main(){
input();
solve();
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define repl(i,a,b) for(int i=(int)(a);i<(int)(b);i++)
#define rep(i,n) repl(i,0,n)
#define each(itr,v) for(auto itr:v)
#define pb(s) push_back(s)
#define mp(a,b) make_pair(a,b)
#define all(x) (x).begin(),(x).end()
#define dbg(x) cout<<#x"="<<x<<endl
#define maxch(x,y) x=max(x,y)
#define minch(x,y) x=min(x,y)
#define uni(x) x.erase(unique(all(x)),x.end())
#define exist(x,y) (find(all(x),y)!=x.end())
#define bcnt(x) bitset<32>(x).count()
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
typedef pair<P, int> PPI;
typedef pair<ll, ll> PL;
typedef pair<P, ll> PPL;
#define INF 1000000010
#define MAX_N 1000
int n,m;
vector<int> xs,ys,xss,yss;
int ks[5555][5555];
int res=0;
int main(){
cin.sync_with_stdio(false);
cin>>n>>m;
xs.pb(-INF); ys.pb(-INF);
rep(i,n){
int x,y;
cin>>x>>y;
xs.pb(x); ys.pb(y);
xss.pb(x); yss.pb(y);
}
xs.pb(INF); ys.pb(INF);
sort(all(xs)); sort(all(ys));
uni(xs); uni(ys);
rep(i,n){
int ix=lower_bound(all(xs),xss[i])-xs.begin(),iy=lower_bound(all(ys),yss[i])-ys.begin();
ks[ix][iy]++;
}
rep(i,5005)rep(j,5005){
ks[i][j+1]+=ks[i][j];
}
rep(i,5005)rep(j,5005){
ks[i+1][j]+=ks[i][j];
}
rep(i,m){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
int ix1=lower_bound(all(xs),x1)-xs.begin()-1,iy1=lower_bound(all(ys),y1)-ys.begin()-1;
int ix2=upper_bound(all(xs),x2)-xs.begin()-1,iy2=upper_bound(all(ys),y2)-ys.begin()-1;
//dbg(ix1); dbg(iy1);dbg(ix2); dbg(iy2);
cout<<ks[ix2][iy2]-ks[ix1][iy2]-ks[ix2][iy1]+ks[ix1][iy1]<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int dp[5002][5002];
map<int,int> make_zip(vector<int> v) {
map<int,int> ret;
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
for (int i=0; i<(int)v.size(); ++i) {
ret[v[i]] = i+1;
}
return ret;
}
int compress(map<int,int> &zip, int x, bool upper=true) {
auto it = zip.lower_bound(x);
if (it != zip.end() && it->first == x) return it->second;
if (upper) {
if (it == zip.end()) return -1;
return it->second;
} else {
if (it == zip.end()) return zip.rbegin()->second;
else if (it == zip.begin()) return -1;
return (--it)->second;
}
}
int main() {
cin.tie(0);
ios::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];
}
auto xzip = make_zip(x);
auto yzip = make_zip(y);
for (int i=0; i<n; ++i) {
int ty = compress(yzip, y[i]);
int tx = compress(xzip, x[i]);
dp[ty][tx] ++;
}
for (int i=0; i<5001; ++i) {
for (int j=0; j<5001; ++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 x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = compress(xzip, x1, true);
y1 = compress(yzip, y1, true);
x2 = compress(xzip, x2, false);
y2 = compress(yzip, y2, false);
if (x1 < 0 || y1 < 0 || x2 < 0 || y2 < 0) {
cout << 0 << endl;
} else {
int cnt = dp[y2][x2] - dp[y1-1][x2] - dp[y2][x1-1] + dp[y1-1][x1-1];
cout << cnt << endl;
}
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <map>
#include <cstdio>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
set<int> X_, Y_;
vector< pair<int,int> > x_y(n);
int x, y;
for(int i = 0; i < n; ++i){
cin >> x >> y;
X_.insert(x);
Y_.insert(y);
x_y[i] = make_pair(x,y);
}
vector<int> X, Y;
for(set<int>::iterator itr = X_.begin(); itr != X_.end(); ++itr)
X.push_back(*itr);
for(set<int>::iterator itr = Y_.begin(); itr != Y_.end(); ++itr)
Y.push_back(*itr);
map<int,int> M_x, M_y;
for(int i = 0; i < X.size(); ++i) M_x[X[i]] = i;
for(int i = 0; i < Y.size(); ++i) M_y[Y[i]] = i;
int h = X.size(), w = Y.size();
vector< vector<int> > acum(h+2,vector<int>(w+2,0));
for(int i = 0; i < n; ++i){
int x = x_y[i].first, y = x_y[i].second;
++acum[M_x[x]+1][M_y[y]+1];
}
for(int i = 1; i <= h+1; ++i){
//cout << acum[i][0] << " | ";
/*
for(int j = 1; j <= n; ++j){
acum[i][j] += acum[i][j-1] + acum[i-1][j] - acum[i-1][j-1];
cout << acum[i][j] << " | ";
}
*/
for(int j = 1; j <= w+1; ++j){
acum[i][j] += acum[i][j-1];
}
for(int j = 1; j <= w+1; ++j){
acum[i][j] += acum[i-1][j];
//cout << acum[i][j] << " | ";
}
//cout << endl;
}
int x_1, x_2, y_1, y_2;
for(int i = 0; i < m; ++i){
cin >> x_1 >> y_1 >> x_2 >> y_2;
//--x_2;--y_2;
int x_1_ = lower_bound(X.begin(),X.end(),x_1)-X.begin(),
y_1_ = lower_bound(Y.begin(),Y.end(),y_1)-Y.begin(),
x_2_ = upper_bound(X.begin(),X.end(),x_2)-X.begin(),
y_2_ = upper_bound(Y.begin(),Y.end(),y_2)-Y.begin();
//++x_2_;++y_2_;
cout << acum[x_2_][y_2_] - acum[x_2_][y_1_] - acum[x_1_][y_2_] + acum[x_1_][y_1_] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
// 0-indexed
template <class T>
struct SegmentTree {
// a,b,c: T, e:T(unit)
// abc = (ab)c = a(bc)
// ae = ea = a
int n;
T unit;
vector<vector<int>> dat;
SegmentTree(){};
void init(int newn) {
n = 1;
while(n < newn) n <<= 1;
dat.assign(n << 1, vector<int>());
}
void build(const vector<T> &v) {
int newn = v.size();
init(newn);
for(int i = 0; i < newn; ++i) dat[n + i] = {v[i].y};
for(int i = n - 1; i; --i) {
int lid = 0, rid = 0, lsize = dat[i << 1].size(),
rsize = dat[(i << 1) | 1].size();
for(int j = 0; j < lsize + rsize; ++j) {
if(lid < lsize && rid < rsize) {
if(dat[i << 1][lid] <= dat[(i << 1) | 1][rid])
dat[i].push_back(dat[i << 1][lid++]);
else
dat[i].push_back(dat[(i << 1) | 1][rid++]);
}
else if(lid < lsize)
dat[i].push_back(dat[i << 1][lid++]);
else
dat[i].push_back(dat[(i << 1) | 1][rid++]);
}
}
}
// [a,b)
int query(int a, int b, int d, int u) {
int ans = 0;
for(int l = a + n, r = b + n; l < r; l >>= 1, r >>= 1) {
if(l & 1) {
ans +=
upper_bound(dat[l].begin(), dat[l].end(), u) -
lower_bound(dat[l].begin(), dat[l].end(), d);
++l;
}
if(r & 1) {
--r;
ans +=
upper_bound(dat[r].begin(), dat[r].end(), u) -
lower_bound(dat[r].begin(), dat[r].end(), d);
}
}
return ans;
}
};
struct cod {
int x, y;
};
bool operator<(const cod &l, const cod &r) {
if(l.x != r.x) return l.x < r.x;
return l.y < r.y;
}
int n, m;
vector<cod> v;
SegmentTree<cod> seg;
void solve();
int main() {
cin >> n >> m;
v.resize(n);
for(int i = 0; i < n; ++i) cin >> v[i].x >> v[i].y;
sort(v.begin(), v.end());
seg.build(v);
for(int i = 0; i < m; ++i) {
int d, u, lid, rid;
cod l, r;
l.y = -1e9 - 1;
r.y = 1e9 + 1;
cin >> l.x >> d >> r.x >> u;
lid = lower_bound(v.begin(), v.end(), l) - v.begin();
rid = upper_bound(v.begin(), v.end(), r) - v.begin();
cout << seg.query(lid, rid, d, u) << endl;
}
return 0;
}
|
#include <iostream>
#include <set>
#include <vector>
#include <climits>
#include <algorithm>
#include <cstring>
using namespace std;
int n, m;
int x[5002], y[5002];
int sum[5002][5002];
set<int> setx, sety;
vector<int> vx, vy;
int main(){
while(cin >> n >> m){
setx.clear();
sety.clear();
setx.insert(INT_MIN);
sety.insert(INT_MIN);
for(int i = 0; i < n; i++){
cin >> x[i] >> y[i];
setx.insert(x[i]);
sety.insert(y[i]);
}
vx.clear();
vy.clear();
for(set<int>::iterator iter = setx.begin(); iter != setx.end(); iter++){
vx.push_back(*iter);
}
for(set<int>::iterator iter = sety.begin(); iter != sety.end(); iter++){
vy.push_back(*iter);
}
memset(sum, 0, sizeof(sum));
for(int i = 0; i < n; i++){
int idxx = find(vx.begin(), vx.end(), x[i]) - vx.begin();
int idxy = find(vy.begin(), vy.end(), y[i]) - vy.begin();
sum[idxx][idxy]++;
}
for(int i = 1; i < vx.size(); i++){
for(int j = 1; j < vy.size(); j++){
sum[i][j] += sum[i - 1][j] + sum[i][j - 1] - sum[i - 1][j - 1];
}
}
/*
for(int i = 0; i < vx.size(); i++){
for(int j = 0; j < vy.size(); j++){
printf("%3d", sum[i][j]);
}
cout << endl;
}
*/
for(int i = 0; i < m; i++){
int lx, ly, hx, hy;
cin >> lx >> ly >> hx >> hy;
int idx_lx = lower_bound(vx.begin(), vx.end(), lx) - vx.begin();
int idx_ly = lower_bound(vy.begin(), vy.end(), ly) - vy.begin();
int idx_hx = upper_bound(vx.begin(), vx.end(), hx) - vx.begin() - 1;
int idx_hy = upper_bound(vy.begin(), vy.end(), hy) - vy.begin() - 1;
if(idx_lx > idx_hx || idx_ly > idx_hy){
cout << 0 << endl;
continue;
}
//cout<<idx_lx<<", "<<idx_ly<<", "<<idx_hx<<", "<<idx_hy<<endl;
int calc =
sum[idx_hx ][idx_hy ] -
sum[idx_lx - 1][idx_hy ] -
sum[idx_hx ][idx_ly - 1] +
sum[idx_lx - 1][idx_ly - 1];
cout << calc << endl;
}
}
} |
#include <bits/stdc++.h>
using namespace std;
int sum[5050][5050];
void compress(vector<int> &v)
{
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int main()
{
int n, m;
cin >> n >> m;
int x[5050], y[5050];
vector<int> xx, yy;
for(int i = 0; i < n; i++) {
cin >> x[i] >> y[i];
xx.push_back(x[i]);
yy.push_back(y[i]);
}
compress(xx);
compress(yy);
for(int i = 0; i < n; i++) {
x[i] = find(xx.begin(), xx.end(), x[i]) - xx.begin();
y[i] = find(yy.begin(), yy.end(), y[i]) - yy.begin();
sum[y[i]+1][x[i]+1]++;
}
for(int i = 0; i < yy.size(); i++) {
for(int j = 0; j < xx.size(); j++) {
sum[i+1][j+1] += sum[i+1][j] + sum[i][j+1] - sum[i][j];
}
}
for(int i = 0; i < m; i++) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(xx.begin(), xx.end(), x1) - xx.begin();
y1 = lower_bound(yy.begin(), yy.end(), y1) - yy.begin();
x2 = upper_bound(xx.begin(), xx.end(), x2) - xx.begin();
y2 = upper_bound(yy.begin(), yy.end(), y2) - yy.begin();
cout << sum[y2][x2] - sum[y2][x1] - sum[y1][x2] + sum[y1][x1] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int (i)=0;(i)<(int)(n);++(i))
#define each(itr,c) for(__typeof(c.begin()) itr=c.begin(); itr!=c.end(); ++itr)
#define all(x) (x).begin(),(x).end()
#define mp make_pair
#define pb push_back
#define fi first
#define se second
typedef pair<int,int> pi;
int dp[5001][5001]={0};
int main()
{
int n,m;
cin >>n >>m;
vector<int> x(n),y(n);
vector<pi> p(n);
//the number of points
map<pi,int> s;
rep(i,n)
{
scanf(" %d %d", &x[i], &y[i]);
p[i]=pi(x[i],y[i]);
if(s.find(p[i])==s.end()) s[p[i]]=1;
else ++s[p[i]];
}
//eliminate same value
sort(all(x));
sort(all(y));
x.erase( unique(all(x)), x.end());
y.erase( unique(all(y)), y.end());
int X=x.size();
int Y=y.size();
//make DPtable
rep(i,n)
{
int idx=lower_bound(all(x),p[i].fi)-x.begin()+1;
int idy=lower_bound(all(y),p[i].se)-y.begin()+1;
++dp[idy][idx];
}
/*
for(int i=Y; i>=0; --i)
{
rep(j,X+1) printf(" %d", dp[i][j]);
printf("\n");
}
*/
for(int i=1; i<=Y; ++i)for(int j=1; j<=X; ++j)
{
dp[i][j]+=dp[i-1][j]+dp[i][j-1]-dp[i-1][j-1];
}
/*
for(int i=Y; i>=0; --i)
{
rep(j,X+1) printf(" %d", dp[i][j]);
printf("\n");
}
*/
rep(Q,m)
{
int x1,y1,x2,y2;
scanf(" %d %d %d %d",&x1,&y1,&x2,&y2);
int rx=upper_bound(all(x),x2)-x.begin();
int ry=upper_bound(all(y),y2)-y.begin();
int lx=lower_bound(all(x),x1)-x.begin();
int ly=lower_bound(all(y),y1)-y.begin();
//printf("%d,%d, %d,%d\n", lx,ly,rx,ry);
//printf("%d - %d - %d + %d\n", dp[ry][rx],dp[ry][lx],dp[ly][rx],dp[ly][lx]);
printf("%d\n", dp[ry][rx]-dp[ry][lx]-dp[ly][rx]+dp[ly][lx]);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
inline int toInt(string s) {int v; istringstream sin(s);sin>>v;return v;}
template<class T> inline string toString(T x) {ostringstream sout;sout<<x;return sout.str();}
template<class T> inline T sqr(T x) {return x*x;}
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 pb push_back
#define mp make_pair
#define each(i,c) for(typeof((c).begin()) i=(c).begin(); i!=(c).end(); ++i)
#define exist(s,e) ((s).find(e)!=(s).end())
#define range(i,a,b) for(int i=(a);i<(b);++i)
#define rep(i,n) range(i,0,n)
#define clr(a,b) memset((a), (b) ,sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF =1LL << 62;
const int inf =1 << 29;
const int nmax=5002;
int sum[nmax][nmax];
int x[nmax],y[nmax];
vi xx,yy;
int main(void){
int n,m;
scanf("%d %d",&n,&m);
rep(i,n){
scanf("%d %d",&x[i],&y[i]);
xx.pb(x[i]);
yy.pb(y[i]);
}
sort(xx.begin(),xx.end());
xx.erase(unique(xx.begin(),xx.end()),xx.end());
sort(yy.begin(),yy.end());
yy.erase(unique(yy.begin(),yy.end()),yy.end());
rep(i,n){
int fx=lower_bound(all((xx)),x[i])-xx.begin();
int fy=lower_bound(all((yy)),y[i])-yy.begin();
sum[fx+1][fy+1]++;
}
rep(i,xx.size())rep(j,yy.size()) sum[i+1][j+1]=(sum[i+1][j+1]+sum[i+1][j]+sum[i][j+1]-sum[i][j]);
rep(i,m){
int x1,x2,y1,y2;
scanf("%d %d %d %d",&x1,&y1,&x2,&y2);
int lx=lower_bound(all((xx)),x1)-xx.begin();
int rx=lower_bound(all((xx)),x2+1)-xx.begin();
int ly=lower_bound(all((yy)),y1)-yy.begin();
int ry=lower_bound(all((yy)),y2+1)-yy.begin();
printf("%d\n",sum[rx][ry]-sum[lx][ry]-sum[rx][ly]+sum[lx][ly]);
}
return 0;
} |
#include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(),(c).end())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
using namespace std;
int main(void)
{
int n,m;
cin >> n >> m;
vector<pair<int,int> > tre(n);
REP(i,n) cin >> tre[i].first >> tre[i].second;
set<int> sx,sy;
REP(i,n){
sx.insert(tre[i].first);
sy.insert(tre[i].second);
}
sx.insert(-1023456789);
sy.insert(-1023456789);
sx.insert(1023456789);
sy.insert(1023456789);
vector<int> vx(sx.begin(),sx.end()),vy(sy.begin(),sy.end());
vector<vector<int> > fi(vx.size(),vector<int>(vy.size(),0));
REP(i,n){
int x=lower_bound(vx.begin(),vx.end(),tre[i].first)-vx.begin();
int y=lower_bound(vy.begin(),vy.end(),tre[i].second)-vy.begin();
++fi[x][y];
}
REP(i,vx.size()) REP(j,vy.size()-1) fi[i][j+1]+=fi[i][j];
REP(i,vx.size()-1) REP(j,vy.size()) fi[i+1][j]+=fi[i][j];
REP(i,m){
int tmp;
cin >> tmp;
int x0=upper_bound(vx.begin(),vx.end(),tmp-1)-vx.begin()-1;
cin >> tmp;
int y0=upper_bound(vy.begin(),vy.end(),tmp-1)-vy.begin()-1;
cin >> tmp;
int x1=upper_bound(vx.begin(),vx.end(),tmp)-vx.begin()-1;
cin >> tmp;
int y1=upper_bound(vy.begin(),vy.end(),tmp)-vy.begin()-1;
cout << fi[x1][y1]-fi[x0][y1]-fi[x1][y0]+fi[x0][y0] << endl;
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <vector>
#include <cmath>
#include <cstring>
#include <numeric>
#include <algorithm>
#include <functional>
#include <array>
#include <map>
#include <queue>
#include <limits.h>
#include <set>
#include <stack>
#include <random>
#include <complex>
#define rep(i,s,n) for(int i = (s); (n) > i; i++)
#define REP(i,n) rep(i,0,n)
#define RANGE(x,a,b) ((a) <= (x) && (x) <= (b))
#define DUPLE(a,b,c,d) (RANGE(a,c,d) || RANGE(b,c,d) || RANGE(c,a,b) || RANGE(d,a,b))
#define INCLU(a,b,c,d) (RANGE(a,c,d) && (b,c,d))
#define PW(x) ((x)*(x))
#define ALL(x) (x).begin(), (x).end()
#define MODU 1000000007
#define bitcheck(a,b) ((a >> b) & 1)
#define bitset(a,b) ( a |= (1 << b))
#define bitunset(a,b) (a &= ~(1 << b))
using namespace std;
typedef pair<int, int> pii;
typedef long long ll;
const pii Dir[8] = { //?????????
{ 0,1 },{ 0,-1 },{ 1,0 },{ -1,0 },
{ 1,1 },{ 1,-1 },{ -1,-1 },{ -1,1 }
};
template<typename A, size_t N, typename T>
void Fill(A(&array)[N], const T &val) {
std::fill((T*) array, (T*) (array + N), val);
}
signed main() {
int n, m;
scanf("%d %d", &n, &m);
vector<pii> px(n);
vector<pii> py(n);
vector<int> pxynum(n);
REP(i, n) {
scanf("%d %d", &px[i].first, &px[i].second);
py[i] = { px[i].second,px[i].first };
}
sort(ALL(px));
sort(ALL(py));
int cou = 0;
for (auto cur : px) {
auto itr = lower_bound(ALL(py), make_pair( cur.second,cur.first ));
pxynum[cou] = itr - py.begin();
cou++;
}
REP(i, m) {
int a, b, c, d;
scanf("%d %d %d %d", &a, &b, &c, &d);
auto s = lower_bound(ALL(px), make_pair( a,-INT_MAX ));
auto f = upper_bound(s,px.end(), make_pair(c, INT_MAX));
int ys = lower_bound(ALL(py), make_pair(b, -INT_MAX))-py.begin();
int yf = upper_bound(py.begin()+ys,py.end(), make_pair(d, INT_MAX))-py.begin();
int ans = 0;
for (int i = s-px.begin(); i < f-px.begin(); i++) {
if (RANGE(pxynum[i], ys, yf - 1)) {
ans++;
}
}
printf("%d\n",ans);
}
return 0;
} |
#include <iostream>
#include <algorithm>
using namespace std;
int n, q, xa, ya, xb, yb, xc[5555], yc[5555], xd[5555], yd[5555]; pair<int, int> p1[5555], p2[5555];
int main() {
scanf("%d%d", &n, &q);
for(int i = 0; i < n; i++) scanf("%d%d", &p1[i].first, &p1[i].second), p2[i] = make_pair(p1[i].second, p1[i].first);
sort(p1, p1 + n); sort(p2, p2 + n);
for(int i = 0; i < n; i++) xc[i] = p1[i].first, yc[i] = p1[i].second, xd[i] = p2[i].second, yd[i] = p2[i].first;
for(int i = 0; i < q; i++) {
scanf("%d%d%d%d", &xa, &ya, &xb, &yb);
int l1 = lower_bound(xc, xc + n, xa) - xc;
int r1 = lower_bound(xc, xc + n, xb + 1) - xc;
int l2 = lower_bound(yd, yd + n, ya) - yd;
int r2 = lower_bound(yd, yd + n, yb + 1) - yd;
int c = 0;
if(r1 - l1 <= r2 - l2) {
for(int j = l1; j < r1; j++) {
if(ya <= yc[j] && yc[j] <= yb) c++;
}
}
else {
for(int j = l2; j < r2; j++) {
if(xa <= xd[j] && xd[j] <= xb) c++;
}
}
printf("%d\n", c);
}
} |
//27
//19
#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
int x[5000],y[5000];
vector<int> xp(n),yp(n);
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
xp[i]=x[i];
yp[i]=y[i];
}
sort(xp.begin(),xp.end());
sort(yp.begin(),yp.end());
xp.erase(unique(xp.begin(),xp.end()),xp.end());
yp.erase(unique(yp.begin(),yp.end()),yp.end());
vector<vector<int> > g(yp.size(),vector<int>(xp.size()));
for(int i=0;i<n;i++){
g[lower_bound(yp.begin(),yp.end(),y[i])-yp.begin()]
[lower_bound(xp.begin(),xp.end(),x[i])-xp.begin()]++;
}
vector<vector<int> > ag(yp.size()+1,vector<int>(xp.size()+1));
for(int i=0;i<yp.size();i++){
for(int j=0;j<xp.size();j++){
ag[i+1][j+1]=ag[i][j+1]+ag[i+1][j]-ag[i][j]+g[i][j];
}
}
while(m--){
int xl,yl,xh,yh;
cin>>xl>>yl>>xh>>yh;
int xxl,yyl,xxh,yyh;
xxl=lower_bound(xp.begin(),xp.end(),xl)-xp.begin();
yyl=lower_bound(yp.begin(),yp.end(),yl)-yp.begin();
xxh=upper_bound(xp.begin(),xp.end(),xh)-xp.begin();
yyh=upper_bound(yp.begin(),yp.end(),yh)-yp.begin();
cout<<ag[yyh][xxh]-ag[yyh][xxl]-ag[yyl][xxh]+ag[yyl][xxl]<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define rep(i,n) for(int i = 0; i < n; i++)
#define INF 1000000001
using namespace std;
typedef pair<int,int> P;
int n, m;
vector<P> v;
int main(){
scanf("%d%d",&n,&m);
rep(i,n){
int x, y;
scanf("%d%d",&x,&y);
v.push_back(P(x,y));
}
sort(v.begin(),v.end());
rep(i,m){
int x1, y1, x2, y2;
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
int sx = 0, ex = n-1, smid;
int s, e;
int cnt = 0;
while(ex-sx > 1){
smid = (sx+ex)/2;
if(v[smid].first >= x1) ex = smid;
else sx = smid;
}
//cout << sx << " " << ex << endl;
s = sx;
sx = 0; ex = n-1;
while(ex-sx > 1){
smid = (sx+ex)/2;
if(v[smid].first <= x2) sx = smid;
else ex = smid;
}
//cout << sx << " " << ex << endl;
e = ex;
e = ex;
if(x1 <= v[s].first && v[s].first <= x2 && y1 <= v[s].second && v[s].second <= y2) cnt++;
if(x1 <= v[e].first && v[e].first <= x2 && y1 <= v[e].second && v[e].second <= y2) cnt++;
for(int j = s+1; j <= e-1; j++) if(y1 <= v[j].second && v[j].second <= y2) cnt++;
cout << cnt << endl;
}
} |
#include <iostream>
#include <sstream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <ctime>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <functional>
#include <algorithm>
using namespace std;
#define rep(i,j) REP((i), 0, (j))
#define REP(i,j,k) for(int i=(j);(i)<(k);++i)
#define BW(a,x,b) ((a)<=(x)&&(x)<=(b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int*)a, (int*)(a + LENGTHOF(a)), b)
#define SQ(x) ((x)*(x))
#define Mod(x, mod) (((x)+(mod)%(mod))
#define MP make_pair
#define PB push_back
#define Fi first
#define Se second
#define INF (1<<30)
#define EPS 1e-10
#define MOD 1000000007
typedef pair<int, int> P;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
map<int,int>zipX,zipY;
int unzipX[5005], unzipY[5005];
int cum[5005][5005];
int N,M;
vector<int> X, Y;
int compressX(vector<int>&x){
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
rep(i,x.size()){
zipX[x[i]] = i;
unzipX[i] = x[i];
}
return x.size();
}
int compressY(vector<int>&y){
sort(y.begin(), y.end());
y.erase(unique(y.begin(), y.end()), y.end());
rep(i,y.size()){
zipY[y[i]] = i;
unzipY[i] = y[i];
}
return y.size();
}
int main(){
scanf("%d%d", &N,&M);
X.resize(N); Y.resize(N);
rep(i,N) scanf("%d%d", &X[i], &Y[i]);
vector<int>x,y; x = X; y = Y;
int W = compressX(x);
int H = compressY(y);
memset(cum, 0,sizeof(cum));
rep(i,N) cum[zipX[X[i]]+1][zipY[Y[i]]+1]++;
zipX[-INF] = 0; zipY[INF] = 0;
zipX[INF] = W; zipY[INF] = H;
rep(i,W+1) rep(j,H) cum[i][j+1] += cum[i][j];
rep(j,H+1) rep(i,W) cum[i+1][j] += cum[i][j];
/* rep(i,W+1){
rep(j,H+1) cout << cum[i][j] << " " ; cout << endl;
}*/
rep(i,M){
int x1, x2, y1, y2;
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
P a = *zipX.lower_bound(x1);
P b = *zipY.lower_bound(y1);
P c = *zipX.upper_bound(x2);
P d = *zipY.upper_bound(y2);
// cout << a.second << " " << b.second << " " << c.second << " " <<d.second << " " << cum[a.second][d.second] << endl;
printf("%d\n", cum[a.second][b.second]-cum[c.second][b.second]-cum[a.second][d.second]+cum[c.second][d.second]);
}
return 0;
} |
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
template<typename T>
struct CumulativeSum2D {
vector<vector<T>> acc;
CumulativeSum2D(int h = 0, int w = 0) : acc(h + 1, vector<T>(w + 1)) { }
void add(int i, int j, T x) { acc[i + 1][j + 1] += x; }
void build() {
int H = acc.size(), W = acc[0].size();
for (int i = 1; i < H; i++) for (int j = 1; j < W; j++) {
acc[i][j] += acc[i][j - 1] + acc[i - 1][j] - acc[i - 1][j - 1];
}
}
T sum(int si, int sj, int ti, int tj) { // [si, ti) x [sj, tj)
return acc[ti][tj] - acc[si][tj] - acc[ti][sj] + acc[si][sj];
}
};
template <typename T>
vector<T> uni(vector<T> v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
return v;
}
template<typename T>
int compressed(vector<T> &a) {
vector<T> b = a;
sort(begin(b), end(b)); b.erase(unique(begin(b), end(b)), end(b));
for (T &ai: a) ai = lower_bound(begin(b), end(b), ai) - begin(b);
return b.size();
}
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 numX = uni(x), numY = uni(y);
int sx = compressed(x), sy = compressed(y);
CumulativeSum2D<int> acc(sx, sy);
for (int i = 0; i < n; i++) acc.add(x[i], y[i], 1);
acc.build();
for (int i = 0; i < m; i++) {
int x1, y1, x2, y2; cin >> x1 >> y1 >> x2 >> y2;
x1 = lower_bound(begin(numX), end(numX), x1) - begin(numX);
y1 = lower_bound(begin(numY), end(numY), y1) - begin(numY);
x2 = upper_bound(begin(numX), end(numX), x2) - begin(numX);
y2 = upper_bound(begin(numY), end(numY), y2) - begin(numY);
cout << acc.sum(x1, y1, x2, y2) << 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));
vector<pii>::iterator ite = upper_bound(treasure.begin(),treasure.end(),mp(x2,y2));
while( 1 ){
//if( it == treasure.end() || *it > mp(x2,y2) ) break;
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 <iostream>
#include <map>
#include <cmath>
#include <algorithm>
#include <vector>
#include <cstdio>
using namespace std;
typedef pair<int, int> P;
int main(){
int n, m;
P data[5000];
P data2[5000];
bool ans[5000];
while(cin >> n >> m){
for(int i=0;i<n;i++){
int a, b;
scanf("%d%d", &a, &b);
data[i] = P(a, i);
data2[i] = P(b, i);
}
sort(data, data+n);
sort(data2, data2+n);
for(int i=0;i<m;i++){
P a, b;
scanf("%d%d%d%d", &a.first, &a.second, &b.first, &b.second);
fill(ans,ans+5000,false);
int l = lower_bound(data, data+n, P(a.first,-1)) - data;
int r = lower_bound(data, data+n, P(b.first+1,-1)) - data;
for(int j=l;j<r;j++){
ans[data[j].second] = true;
}
int l2 = lower_bound(data2, data2+n, P(a.second,-1)) - data2;
int r2 = lower_bound(data2, data2+n, P(b.second+1,-1)) - data2;
int cnt = 0;
for(int j=l2;j<r2;j++){
if(ans[data2[j].second]) cnt++;
}
printf("%d\n", cnt);
}
}
} |
#include<iostream>
#include<bits/stdc++.h>
using namespace std;
int main(){
int n,m;
cin>>n>>m;
vector<int> x(n),y(n);
set<int> xs,ys;
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
xs.insert(x[i]);
ys.insert(y[i]);
}
xs.insert(-1e9-1),ys.insert(-1e9-1);
xs.insert(1e9+1),ys.insert(1e9+1);
map<int,int> dicx;
map<int,int> dicy;
int index=0;
for(auto it=xs.begin();it!=xs.end();it++){
dicx[*it]=index;
index++;
}
index=0;
for(auto it=ys.begin();it!=ys.end();it++){
dicy[*it]=index;
index++;
}
vector<vector<int>> field(xs.size(),vector<int>(ys.size(),0));
for(int i=0;i<n;i++){
field[dicx[x[i]]][dicy[y[i]]]++;
}
vector<vector<int>> sum(xs.size(),vector<int>(ys.size(),0));
for(int i=1;i<xs.size();i++){
for(int j=1;j<ys.size();j++){
sum[i][j]=field[i][j]+sum[i][j-1]+sum[i-1][j]-sum[i-1][j-1];
}
}
for(int i=0;i<m;i++){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
swap(x1,x2);
swap(y1,y2);
auto it=xs.upper_bound(x1);
it--;
x1=*it;
it=ys.upper_bound(y1);
it--;
y1=*it;
it=xs.lower_bound(x2);
it--;
x2=*it;
it=ys.lower_bound(y2);
it--;
y2=*it;
cout<<sum[dicx[x1]][dicy[y1]]-sum[dicx[x1]][dicy[y2]]-sum[dicx[x2]][dicy[y1]]+sum[dicx[x2]][dicy[y2]]<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define INF 1000000001
using namespace std;
map<int, int> Dic(const vector<int>& v, vector<int>& sorted) {
sorted = v;
sort(sorted.begin(), sorted.end());
sorted.erase(unique(sorted.begin(), sorted.end()), sorted.end());
map<int, int> res;
for (int i = 1; i <= sorted.size(); i++) {
res[sorted[i - 1]] = i;
}
return res;
}
int main()
{
int n, m;
cin >> n >> m;
vector<int> x(n), sx, y(n), sy;
x.push_back(-INF); y.push_back(-INF);
for (int i = 1; i <= n; i++) cin >> x[i] >> y[i];
x.push_back(INF); y.push_back(INF);
map<int, int> xdic = Dic(x, sx), ydic = Dic(y, sy);
vector<vector<int>> sum(sx.size() + 1, vector<int>(sy.size() + 1, 0));
for (int i = 1; i <= n; i++) {
sum[xdic[x[i]]][ydic[y[i]]]++;
}
for (int i = 1; i <= sx.size(); i++) {
for (int j = 1; j <= sy.size(); j++) {
sum[i][j] += sum[i - 1][j];
}
}
for (int i = 1; i <= sx.size(); i++) {
for (int j = 1; j <= sy.size(); j++) {
sum[i][j] += sum[i][j - 1];
}
}
for (int i = 0, x1, y1, x2, y2; i < m; i++) {
cin >> x1 >> y1 >> x2 >> y2;
x1 = xdic[*lower_bound(sx.begin(), sx.end(), x1)];
x2 = xdic[*(upper_bound(sx.begin(), sx.end(), x2) == sx.begin() ? sx.begin() : upper_bound(sx.begin(), sx.end(), x2) - 1)];
y1 = ydic[*lower_bound(sy.begin(), sy.end(), y1)];
y2 = ydic[*(upper_bound(sy.begin(), sy.end(), y2) == sy.begin() ? sy.begin() : upper_bound(sy.begin(), sy.end(), y2) - 1)];
cout << sum[x2][y2] - sum[x1 - 1][y2] - sum[x2][y1 - 1] + sum[x1 - 1][y1 - 1] << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef pair<ll,ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<string> vs;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef vector<pll> vpll;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<29;
const ll INF=1ll<<60;
const double pi=acos(-1);
const double eps=1e-11;
const ll mod=1e9+7;
const int dx[4]={-1,0,1,0},dy[4]={0,-1,0,1};
int main(){
ios::sync_with_stdio(0);
cin.tie(0);
int n,m;
cin>>n>>m;
vi x(n),y(n);
vi c(n),d(n);
for(int i=0;i<n;i++){
cin>>x[i]>>y[i];
c[i]=x[i],d[i]=y[i];
}
sort(c.begin(),c.end());
c.erase(unique(c.begin(),c.end()),c.end());
sort(d.begin(),d.end());
d.erase(unique(d.begin(),d.end()),d.end());
map<int,int> mp1,mp2;
for(int i=0;i<c.size();i++) mp1[c[i]]=i;
for(int i=0;i<d.size();i++) mp2[d[i]]=i;
int h=c.size(),w=d.size();
vvi a(h+1,vi(w+1));
for(int i=0;i<n;i++) a[mp1[x[i]]+1][mp2[y[i]]+1]++;
for(int i=1;i<=h;i++) for(int j=1;j<=w;j++){
a[i][j]+=a[i-1][j]+a[i][j-1]-a[i-1][j-1];
}
for(int i=0;i<m;i++){
int l,r,L,R;
cin>>l>>r>>L>>R;
l=lower_bound(c.begin(),c.end(),l)-c.begin();
r=lower_bound(d.begin(),d.end(),r)-d.begin();
L=upper_bound(c.begin(),c.end(),L)-c.begin();
R=upper_bound(d.begin(),d.end(),R)-d.begin();
cout<<a[L][R]-a[L][r]-a[l][R]+a[l][r]<<endl;
}
}
|
#include<iostream>
#include<cstdio>
#include<string>
#include<cstring>
#include<vector>
#include<algorithm>
#define INF (1<<29)
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
vector<int> x,y;
int num[5001][5001];
int index(vector<int> &v,int x){
int l,r;
l=-1;r=v.size();
while(1<r-l){
int m=(r+l)/2;
if(v[m]<=x)l=m;
else r=m;
}
return l;
}
int main(){
vector<pair<int,int> > treasure;
int n,m;
int a,b,c,d;
cin>>n>>m;
//x.push_back(-1000000000);
//y.push_back(-1000000000);
rep(i,n){
cin>>a>>b;
x.push_back(a);
y.push_back(b);
treasure.push_back(make_pair(a,b));
}
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());
rep(i,n){
a = index(x,treasure[i].first);
b = index(y,treasure[i].second);
++num[a][b];
}
rep(i,x.size()){
rep(j,y.size()){
a=b=c=d=0;
if(0<i&&0<j)a = num[i-1][j-1];
if(0<i)b = num[i-1][j];
if(0<j)c = num[i][j-1];
d = num[i][j];
num[i][j] = d+c+b-a;
}
}
rep(i,m){
int x1,y1,x2,y2;
cin>>x1>>y1>>x2>>y2;
x1 = index(x,x1-1);
y1 = index(y,y1-1);
x2 = index(x,x2);
y2 = index(y,y2);
a=b=c=d=0;
if(x1!=-1&&y1!=-1)a = num[x1][y1];
if(x1!=-1&&y2!=-1)b = num[x1][y2];
if(x2!=-1&&y1!=-1)c = num[x2][y1];
if(x2!=-1&&y2!=-1)d = num[x2][y2];
cout<< d-c-b+a <<endl;
}
return 0;
} |
#include <algorithm>
#include <iostream>
#include <set>
#define INF 1000000001
#define N 5003
using namespace std;
typedef pair<int,int> P;
int Bynary_Search(int,int,int,int);
int n,m,xsz,ysz,d[N][N],ans;
int pxy[2][N],x[N],y[N],x1,y1,x2,y2;
set<int> sx,sy;
P in[N];
int main(){
cin>>n>>m;
for(int i=0;i<n;i++) cin>>x[i]>>y[i],sx.insert(x[i]),sy.insert(y[i]);
int k=1;
for(set<int>::iterator it=sx.begin();it!=sx.end();it++,k++) pxy[0][k]=*it;
k=1;
for(set<int>::iterator it=sy.begin();it!=sy.end();it++,k++) pxy[1][k]=*it;
xsz=sx.size();
ysz=sy.size();
pxy[0][0]=pxy[1][0]=-INF;
pxy[0][xsz+1]=pxy[1][ysz+1]=INF;
for(int i=0;i<n;i++){
int rx=Bynary_Search(x[i],0,xsz,0);
int ry=Bynary_Search(y[i],1,ysz,0);
d[ry][rx]++;
}
for(int i=0;i<ysz+1;i++)
for(int j=1;j<xsz+1;j++) d[i][j]=d[i][j]+d[i][j-1];
for(int i=0;i<xsz+1;i++)
for(int j=1;j<ysz+1;j++) d[j][i]=d[j][i]+d[j-1][i];
for(int i=0;i<m;i++){
cin>>x1>>y1>>x2>>y2;
int xb=Bynary_Search(x1,0,xsz,0),yb=Bynary_Search(y1,1,ysz,0);
int xe=Bynary_Search(x2,0,xsz,1),ye=Bynary_Search(y2,1,ysz,1);
ans=d[ye][xe];
if(yb) ans-=d[yb-1][xe];
if(xb) ans-=d[ye][xb-1];
if(xb&&yb) ans+=d[yb-1][xb-1];
if(xb>xe||yb>ye) ans=0;
cout<<ans<<endl;
}
return 0;
}
int Bynary_Search(int s,int index,int sz,int c){
int l=0,r=sz+2,m;
while(l+1<r){
m=(l+r)/2;
if(s>=pxy[index][m]) l=m;
else r=m;
}
if(c) return l;
if(s==pxy[index][l]) return l;
else return l+1;
} |
#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) - upper_bound(all(t),y2);
}
if(right==posx.begin())add=0;
else{
right--;
vector<int> &t = r[zip[*right]];
add = lower_bound(all(t),y1) - upper_bound(all(t),y2);
}
cout<<sub-add<<endl;
}
} |
#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, ys;
for(int i = 0; i < N; i++) {
scanf("%d %d", &X[i], &Y[i]);
xs.push_back(X[i]);
ys.push_back(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<iostream>
#include<stack>
#include<queue>
#include<math.h>
#include<algorithm>
using namespace std;
#define FOR(k,m,n) for(int (k)=(m);(k)<(n);(k)++)
#define rep(i,n) FOR((i),0,(n))
#define N_MAX 5000
#define M_MAX 500000
#define ll long long
//??????????????¨??????
int n,m;
int xy[N_MAX][2];
int square[4];
//??????
int ans;
bool ok;
int main() {
//??\???
cin>>n>>m;
rep(i,n)rep(j,2)cin>>xy[i][j];
//xy??????x???????????????????????????????????????
bool flag=true;
for (int i = 0; flag; i++) {
flag = 0;
for (int j = n-1 ; j >= i + 1; j--) {
if (xy[j][0] < xy[j - 1][0]) {
//??£??\????´??????????
swap(xy[j],xy[j-1]);
flag=1;
/*
temp0 = xy[j][0];
xy[j][0] = xy[j - 1][0];
xy[j - 1][0] = temp0;
temp1 = xy[j][1];
xy[j][1] = xy[j - 1][1];
xy[j - 1][1] = temp1;
rep(k, 2) {
temp[k]=xy[j][k];
xy[j][k]=xy[j-1][k];
xy[j-1][k]=temp[k];
}
*/
}
}
}
//?¨????
rep(roop, m) {
//???????¨????
ans=0;
//??\???
rep(i,4)cin>>square[i];
//??????????§??????????x?????´????????¢???(?????????????????????)
int left=0,right=n,mid;
while (left < right) {
mid=(left+right)/2;
if(left==mid )break;
if(xy[mid][0]==square[0])break;
else if(square[0]<xy[mid][0])right=mid;
else left=mid;
}
//cout<<"left: "<<left<<endl;
//cout << "ss" << square[1]<<endl;
//cout<<xy[left][1] << endl;
while(xy[left][0]<=square[2]){
if(square[0] <= xy[left][0])
if(xy[left][0] <= square[2])
if(square[1] <= xy[left][1])
if(xy[left][1] <= square[3])
ans++;
left++;
if(left>=n)break;
}
cout<<ans<<endl;
}
/*
//???????????°
rep(i, n) {
rep(j,2)cout<<xy[i][j]<<" ";
cout<<endl;
}
*/
//cin>>m;
return 0;
} |
#include <iostream>
#include <algorithm>
#include <vector>
#include <cstdio>
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();
}
void print(int n){
for(int i=n+1;i>=0;i--){
for(int j=0;j<n+2;j++){
cout << p_cnt[i][j];
}
cout << endl;
}
cout << endl;
}
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]++;
//printf("X[i] = %d, Y[i] = %d, x = %d, y = %d\n", X[i], Y[i], x, y);
}
//print(n);
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];
}
}
//print(n);
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);
//printf("%d %d %d %d\n", x1, y1, x2, y2);
cout << p_cnt[y2][x2] - p_cnt[y2][x1] - p_cnt[y1][x2] + p_cnt[y1][x1] << endl;
}
} |
#include <iostream>
#include <cstdio>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <string>
#include <vector>
#include <set>
#include <map>
#include <stack>
#include <queue>
#include <algorithm>
#define CH(N,A,B) (A<=N&&N<B)
#define REP(i,a,b) for(int i=a;i<b;i++)
#define RREP(i,a,b) for(int i=(b-1);a<=i;i--)
#define F first
#define S second
#define X first
#define Y second
using namespace std;
int n, m;
vector<int> vx, vy;
int tx[5005], ty[5005], unzipx[5005], unzipy[5005], imos[5005][5005];
map<int, int> zipx, zipy;
pair< pair<int,int>, pair<int,int> > p[500005];
int main() {
cin>>n>>m;
REP(i,0,n){
cin>>tx[i]>>ty[i];
vx.push_back(tx[i]);
vy.push_back(ty[i]);
}
REP(i,0,m){
cin>>p[i].F.X>>p[i].F.Y>>p[i].S.X>>p[i].S.Y;
}
//compression
sort(vx.begin(), vx.end());
sort(vy.begin(), vy.end());
vx.erase(unique(vx.begin(), vx.end()), vx.end());
vy.erase(unique(vy.begin(), vy.end()), vy.end());
REP(i,0,vx.size()){
zipx[vx[i]] = i;
unzipx[i] = vx[i];
}
REP(i,0,vy.size()){
zipy[vy[i]] = i;
unzipy[i] = vy[i];
}
//Initializing imos array
REP(i,0,5005)REP(j,0,5005) imos[i][j] = 0;
REP(i,0,n){
imos[zipy[ty[i]]][zipx[tx[i]]]++;
}
//creating imos array
REP(i,0,vy.size()){
REP(j,1,vx.size()){
imos[i][j] += imos[i][j-1];
}
}
REP(j,0,vx.size()){
REP(i,1,vy.size()){
imos[i][j] += imos[i-1][j];
}
}
REP(i,0,m){
vector<int>::iterator a1x = lower_bound(vx.begin(),vx.end(),p[i].F.X),
a1y = lower_bound(vy.begin(),vy.end(),p[i].F.Y),
a2x = upper_bound(vx.begin(),vx.end(),p[i].S.X)-1,
a2y = upper_bound(vy.begin(),vy.end(),p[i].S.Y)-1;
int z1x = zipx[*a1x], z1y = zipy[*a1y], z2x = zipx[*a2x], z2y = zipy[*a2y];
int ans = imos[z2y][z2x];
if(z1y > 0) ans -= imos[z1y-1][z2x];
if(z1x > 0) ans -= imos[z2y][z1x-1];
if(z1y > 0 && z1x > 0) ans += imos[z1y-1][z1x-1];
//fo exception
if(p[i].F.Y > unzipy[vy.size()-1] || p[i].F.X > unzipx[vx.size()-1]) cout<<0<<endl;
else if(p[i].S.Y < unzipy[0] || p[i].S.X < unzipx[0]) cout<<0<<endl;
else cout<<ans<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define MAX 5010
typedef pair<int,int> pii;
int s[MAX][MAX];
int main(){
int n,m;
cin >> n >> m;
vector<int> x(n),y(n);
vector<int> X,Y;
for(int i = 0 ; i < n ; i++){
cin >> x[i] >> y[i];
X.push_back(x[i]);
Y.push_back(y[i]);
}
X.push_back(INT_MIN);
Y.push_back(INT_MIN);
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 px = lower_bound(X.begin(),X.end(),x[i]) - X.begin();
int py = lower_bound(Y.begin(),Y.end(),y[i]) - Y.begin();
s[px][py]++;
}
for(int i = 1 ; i < MAX ; i++){
for(int j = 1 ; j < MAX ; j++){
s[i][j] += s[i-1][j]+s[i][j-1]-s[i-1][j-1];
}
}
while(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 << s[x2][y2]-s[x1-1][y2]-s[x2][y1-1]+s[x1-1][y1-1] << endl;
}
return 0;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int n, m, x1_, y1_, x2_, y2_;
vector<int> x, y;
int main()
{
scanf("%d", &n);
scanf("%d", &m);
x = vector<int>(n);
y = vector<int>(n);
for (int i = 0; i < n; i++)
{
scanf("%d", &x[i]);
scanf("%d", &y[i]);
}
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
if (x[i] > x[j])
{
swap(x[i], x[j]);
swap(y[i], y[j]);
}
}
}
for (int i = 0; i < m; i++)
{
scanf("%d", &x1_);
scanf("%d", &y1_);
scanf("%d", &x2_);
scanf("%d", &y2_);
int s = distance(x.begin(), upper_bound(x.begin(), x.end(), x1_ - 1));
int t = distance(x.begin(), lower_bound(x.begin(), x.end(), x2_ + 1));
int ret = 0;
for (int j = s; j < t; j++)
{
if (y1_ <= y[j] && y[j] <= y2_)
{
ret++;
}
}
printf("%d\n", ret);
}
return 0;
} |
#include "bits/stdc++.h"
#define REP(i,n) for(ll i=0;i<ll(n);++i)
#define RREP(i,n) for(ll i=ll(n)-1;i>=0;--i)
#define FOR(i,m,n) for(ll i=m;i<ll(n);++i)
#define RFOR(i,m,n) for(ll i=ll(n)-1;i>=ll(m);--i)
#define ALL(v) (v).begin(),(v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)),v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
constexpr int dx[8] = { 1,1,0,-1,-1,-1,0,1 };
constexpr int dy[8] = { 0,1,1,1,0,-1,-1,-1 };
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> bool chmin(T &a, T b) { if (a > b) { a = b; return true; } return false; }
template <class T> bool chmax(T &a, T b) { if (a < b) { a = b; return true; } return false; }
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n; cin >> n;
int m; cin >> m;
vector<pii> v(n);
REP(i, n)cin >> v[i].first >> v[i].second;
vi x(n), y(n);
REP(i, n) {
tie(x[i], y[i]) = v[i];
}
sort(ALL(x));
UNIQUE(x);
sort(ALL(y));
UNIQUE(y);
int h = x.size(), w = y.size();
vvi cnt(h + 1, vi(w + 1, 0));
REP(i, n) {
int c = lower_bound(ALL(x), v[i].first) - x.begin(), d = lower_bound(ALL(y), v[i].second) - y.begin();
cnt[c + 1][d + 1]++;
}
REP(i, h)REP(j, w + 1)cnt[i + 1][j] += cnt[i][j];
REP(i, h + 1)REP(j, w)cnt[i][j + 1] += cnt[i][j];
auto query = [&](int i1, int j1, int i2, int j2) {
return cnt[i2][j2] - cnt[i1][j2] - cnt[i2][j1] + cnt[i1][j1];
};
REP(i, m) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int i1 = lower_bound(ALL(x), x1) - x.begin(),
j1 = lower_bound(ALL(y), y1) - y.begin(),
i2 = upper_bound(ALL(x), x2) - x.begin(),
j2 = upper_bound(ALL(y), y2) - y.begin();
cout << query(i1,j1,i2,j2) << endl;
}
}
|
#include <iostream>
#include <vector>
#include <map>
#include <algorithm>
using namespace std;
using P = pair<int, int>;
int idx(vector<int> const& v, int i) {
return lower_bound(v.begin(), v.end(), i) - v.begin();
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> sum(n+2, vector<int>(n+2));
vector<int> xs(n), ys(n);
vector<int> x(n), y(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());
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 tx = idx(x, xs[i]);
int ty = idx(y, ys[i]);
++sum[ty+1][tx+1];
}
for(int i=0; i<y.size(); ++i) {
for(int j=0; j<x.size(); ++j) {
sum[i+1][j+1] += sum[i+1][j] + sum[i][j+1] - sum[i][j];
}
}
for(int i=0; i<m; ++i) {
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
x1 = idx(x, x1);
y1 = idx(y, y1);
x2 = idx(x, x2+1);
y2 = idx(y, y2+1);
cout << sum[y2][x2] - sum[y2][x1] - sum[y1][x2] + sum[y1][x1] << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int mp[5005][5005],n,m;
int t[5005][5005];
vector<int> x,y;
vector<int> compress(vector<int> v){
vector<int> copy=v;
sort(v.begin(), v.end());
v.erase( unique( v.begin(), v.end()) , v.end() );
vector<int> res;
for(int i=0;i<(int)copy.size();i++){
int num=lower_bound( v.begin(),v.end(), copy[i] ) - v.begin();
res.push_back( num );
}
return res;
}
int sum(int sx,int sy,int gx,int gy){
return t[gx][gy]-t[sx][gy]-t[gx][sy]+t[sx][sy];
}
int main(){
cin>>n>>m;
x.resize(n),y.resize(n);
for(int i=0;i<n;i++)cin>>x[i]>>y[i];
vector<int> X,Y;
X=compress(x),Y=compress(y);
for(int i=0;i<n;i++)mp[X[i]][Y[i]]++;
for(int i=0;i<n;i++)
for(int j=0;j<n;j++)
t[i+1][j+1]=mp[i][j] + t[i+1][j] + t[i][j+1] - t[i][j];
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() );
while(m--){
int a,b,c,d;
cin>>a>>b>>c>>d;
int sx=lower_bound(x.begin(),x.end(),a)-x.begin();
int sy=lower_bound(y.begin(),y.end(),b)-y.begin();
int gx=upper_bound(x.begin(),x.end(),c)-x.begin();
int gy=upper_bound(y.begin(),y.end(),d)-y.begin();
cout<<sum(sx,sy,gx,gy)<<endl;
}
return 0;
} |
#define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <iostream>
#include <cstdio>
#include <sstream>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <queue>
#include <stack>
#include <limits>
#include <map>
#include <string>
#include <cstring>
#include <set>
#include <deque>
#include <bitset>
#include <list>
#include <cctype>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair <int,int> P;
typedef pair <int,P> PP;
static const double EPS = 1e-8;
static const int tx[] = {0,1,0,-1};
static const int ty[] = {-1,0,1,0};
struct Point {
int x;
int y;
Point(int _x,int _y) : x(_x),y(_y) {}
bool operator<(const Point& p) const{
return x < p.x;
}
};
int main(){
int total_treasure,total_region;
while(~scanf("%d %d",&total_treasure,&total_region)){
vector<Point> treasures;
vector<int> treasures_x;
for(int i=0;i<total_treasure;i++){
int x,y;
scanf("%d %d",&x,&y);
treasures.push_back(Point(x,y));
treasures_x.push_back(x);
}
sort(treasures.begin(),treasures.end());
sort(treasures_x.begin(),treasures_x.end());
for(int i=0;i<total_region;i++){
int x[2],y[2];
scanf("%d %d %d %d",x,y,x+1,y+1);
int left_idx = lower_bound(treasures_x.begin(),treasures_x.end(),x[0]) - treasures_x.begin();
int right_idx = upper_bound(treasures_x.begin(),treasures_x.end(),x[1]) - treasures_x.begin() - 1;
int count = 0;
for(int j=left_idx;j<=right_idx;j++){
if(treasures[j].y < y[0] || y[1] < treasures[j].y) continue;
count++;
}
printf("%d\n",count);
}
}
} |
#include<bits/stdc++.h>
#define range(i,a,b) for(int i = (a); i < (b); i++)
#define rep(i,b) for(int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
#define debug(x) cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << endl;
const int INF = 2000000000;
using namespace std;
const int MAX_N = 5100;
const int MAX_P = MAX_N * MAX_N;
int grid[MAX_N][MAX_N] = {0};
void compress(vector<int> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(),v.end()),v.end());
}
int lb(vector<int> v, int num){
return lower_bound(all(v), num) - v.begin();
}
//s[MAX_N + 1][MAX_N + 1]
void cumulativeSum(int h, int w){
//?????????????´????(1,1)
rep(i,h) rep(j,w) grid[i + 1][j + 1] += grid[i + 1][j] + grid[i][j + 1] - grid[i][j];
}
//(i,j)????????????(k,l)???????????¨??????????????¢
int sum(int i, int j, int k, int l){
return grid[k][l] - grid[i][l] - grid[k][j] + grid[i][j];
}
int main(){
int n, m;
cin >> n >> m;
vector<int> x(n), y(n);
pair<int, int> inp[MAX_N];
rep(i,n){
cin >> x[i] >> y[i];
inp[i] = make_pair(x[i],y[i]);
}
compress(x);
compress(y);
rep(i,n){
int fy = lb(y, inp[i].second);
int fx = lb(x, inp[i].first);
grid[fy + 1][fx + 1]++; //?´???????????????????+1??????
}
cumulativeSum(y.size(), x.size());
//rep(i,y.size() + 1){ rep(j,x.size() + 1){ cout << grid[i][j] <<' '; } cout << endl; }
//rep(i,x.size()){ show(x[i]) }
rep(i,m){
int lx, ly, rx, ry;
cin >> lx >> ly >> rx >> ry;
lx = lb(x, lx);
ly = lb(y, ly);
rx = lb(x, rx + 1);//?¢???????????????????
ry = lb(y, ry + 1);
cout << sum(ly, lx, ry, rx) << endl;
}
} |
#include <iostream>
#include <vector>
#include <utility>
#include <algorithm>
using namespace std;
int main(){
int n,m;
cin >> n >> m;
vector<pair<int,int> > xy(n);
for(int i=0; i<n; i++){
int x,y;
cin >> x >> y;
xy[i] = make_pair(x,y);
}
sort(xy.begin(), xy.end());
for(int q=0; q<m; q++){
int x1, y1, x2, y2;
cin >> x1 >> y1 >> x2 >> y2;
int count=0;
vector<pair<int,int> >::iterator it;
it = lower_bound(xy.begin(), xy.end(), make_pair(x1, (int)-1e9-1));
for(int i=it-xy.begin(); i<n; i++){
if(xy[i].first > x2) break;
if(y1<=xy[i].second && xy[i].second<=y2){
count++;
}
}
cout << count << endl;
}
return 0;
} |
#include <iostream>
#include <cstdio>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <algorithm>
#include <cstring>
#include <functional>
#include <cmath>
#include <complex>
using namespace std;
#define rep(i,n) for(int i=0;i<(n);++i)
#define rep1(i,n) for(int i=1;i<=(n);++i)
#define all(c) (c).begin(),(c).end()
#define fs first
#define sc second
#define pb push_back
#define show(x) cout << #x << " " << x << endl
short int imos[5001][5001];
int n,m,x[5000],y[5000];
vector<int> ashx,ashy;
int main(){
cin>>n>>m;
rep(i,n){
cin>>x[i]>>y[i];
ashx.pb(x[i]);
ashy.pb(y[i]);
}
sort(all(ashx));
sort(all(ashy));
ashx.erase(unique(all(ashx)),ashx.end());
ashy.erase(unique(all(ashy)),ashy.end());
rep(i,n) x[i]=lower_bound(all(ashx),x[i])-ashx.begin();
rep(i,n) y[i]=lower_bound(all(ashy),y[i])-ashy.begin();
int h=ashx.size(),w=ashy.size();
rep(i,n) imos[x[i]+1][y[i]+1]++;
rep(i,h+1) rep(j,w) imos[i][j+1]+=imos[i][j];
rep(i,h) rep(j,w+1) imos[i+1][j]+=imos[i][j];
rep(i,m){
int sx,sy,tx,ty,isx,isy,itx,ity;
cin>>sx>>sy>>tx>>ty;
isx=lower_bound(all(ashx),sx)-ashx.begin();
isy=lower_bound(all(ashy),sy)-ashy.begin();
itx=upper_bound(all(ashx),tx)-ashx.begin();
ity=upper_bound(all(ashy),ty)-ashy.begin();
cout<<imos[itx][ity]-imos[itx][isy]-imos[isx][ity]+imos[isx][isy]<<endl;
}
} |
#include <algorithm>
#include <iostream>
#include <cstdio>
#include <set>
#define INF 1000000001
#define N 5003
using namespace std;
typedef pair<int,int> P;
int Bynary_Search(int,int,int,int);
int n,m,xsz,ysz,d[N][N],ans;
int pxy[2][N],x[N],y[N],x1,y1,x2,y2;
set<int> sx,sy;
P in[N];
int main(){
cin>>n>>m;
for(int i=0;i<n;i++) cin>>x[i]>>y[i],sx.insert(x[i]),sy.insert(y[i]);
int k=1;
for(set<int>::iterator it=sx.begin();it!=sx.end();it++,k++) pxy[0][k]=*it;
k=1;
for(set<int>::iterator it=sy.begin();it!=sy.end();it++,k++) pxy[1][k]=*it;
xsz=sx.size();
ysz=sy.size();
pxy[0][0]=pxy[1][0]=-INF;
pxy[0][xsz+1]=pxy[1][ysz+1]=INF;
for(int i=0;i<n;i++){
int rx=Bynary_Search(x[i],0,xsz,0);
int ry=Bynary_Search(y[i],1,ysz,0);
d[ry][rx]++;
}
for(int i=0;i<ysz+1;i++)
for(int j=1;j<xsz+1;j++) d[i][j]=d[i][j]+d[i][j-1];
for(int i=0;i<xsz+1;i++)
for(int j=1;j<ysz+1;j++) d[j][i]=d[j][i]+d[j-1][i];
for(int i=0;i<m;i++){
scanf("%d%d%d%d",&x1,&y1,&x2,&y2);
int xb=Bynary_Search(x1,0,xsz,0),yb=Bynary_Search(y1,1,ysz,0);
int xe=Bynary_Search(x2,0,xsz,1),ye=Bynary_Search(y2,1,ysz,1);
ans=d[ye][xe];
if(yb) ans-=d[yb-1][xe];
if(xb) ans-=d[ye][xb-1];
if(xb&&yb) ans+=d[yb-1][xb-1];
if(xb>xe||yb>ye) ans=0;
printf("%d\n",ans);
}
return 0;
}
int Bynary_Search(int s,int index,int sz,int c){
int l=0,r=sz+2,m;
while(l+1<r){
m=(l+r)/2;
if(s>=pxy[index][m]) l=m;
else r=m;
}
if(c) return l;
if(s==pxy[index][l]) return l;
else return l+1;
} |
#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());
auto it = unique(v.begin(), v.end());
rep(i, m) {
X1[i] = lower_bound(v.begin(), it, X1[i]) - v.begin();
X2[i] = upper_bound(v.begin(), it, X2[i]) - v.begin() - 1;
}
rep(i, n) {
x[i] = lower_bound(v.begin(), it, x[i]) - v.begin();
}
return (int)v.size();
}
int 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 <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(in[i].x>c) break;
if((a<=in[i].x&&b<=in[i].y&&in[i].y<=d))cnt++;
}
cout <<cnt<<endl;
}
return 0;
} |
#include <cstdio>
#include <iostream>
#include <vector>
#include <list>
#include <cmath>
#include <fstream>
#include <algorithm>
#include <string>
#include <queue>
#include <set>
#include <map>
#include <complex>
#include <iterator>
#include <cstdlib>
#include <cstring>
#include <sstream>
#include <stack>
#include <climits>
#include <deque>
using namespace std;
typedef long long ll;
typedef pair<int,int> pii;
double EPS=1e-10;
double EQ(double a,double b){
return abs(a-b)<EPS;
}
void fast_stream(){
std::ios_base::sync_with_stdio(0);
}
template<class T>
string IntToString(T num){
string res;stringstream ss;ss<<num;
return ss.str();
}
ll StringToInt(string &str){
ll res=0;
for(int i=0;i<(int)str.size();i++)
res=(res*10+str[i]-'0');
return res;
}
int n,m;
int xs[10001];
int ys[10001];
int minx;
int miny;
int maxx;
int maxy;
int sums[5010][5010];
pii ps[10001];
int main(){
cin>>n>>m;
set<int> sx,sy;
map<pii,int> sp;
for(int i=0;i<n;i++){
cin>>xs[i]>>ys[i];
ps[i].first=ys[i];
ps[i].second=xs[i];
sx.insert(xs[i]);
sy.insert(ys[i]);
sp[ps[i]]++;
}
vector<int> sortedx,sortedy;
for(set<int>::iterator it=sx.begin();it!=sx.end();it++)
sortedx.push_back(*it);
for(set<int>::iterator it=sy.begin();it!=sy.end();it++)
sortedy.push_back(*it);
for(int i=0;i<(int)sortedy.size();i++)
for(int j=0;j<(int)sortedx.size();j++){
sums[i+1][j+1]=sums[i+1][j]+sums[i][j+1]-sums[i][j];
if(sp.count(pii(sortedy[i],sortedx[j]))>0){
sums[i+1][j+1]+=sp[pii(sortedy[i],sortedx[j])];
}
}
for(int i=0;i<m;i++){
cin>>minx>>miny>>maxx>>maxy;
int minxPos=lower_bound(sortedx.begin(),sortedx.end(),minx)-sortedx.begin();
int maxxPos=upper_bound(sortedx.begin(),sortedx.end(),maxx)-sortedx.begin()-1;
int minyPos=lower_bound(sortedy.begin(),sortedy.end(),miny)-sortedy.begin();
int maxyPos=upper_bound(sortedy.begin(),sortedy.end(),maxy)-sortedy.begin()-1;
int cnt=sums[maxyPos+1][maxxPos+1]-sums[minyPos][maxxPos+1]
-sums[maxyPos+1][minxPos]+sums[minyPos][minxPos];
cout<<cnt<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using vi=vector<int>;
using vvi=vector<vi>;
using vs=vector<string>;
using msi=map<string,int>;
using mii=map<int,int>;
using pii=pair<int,int>;
using vlai=valarray<int>;
using ll=long long;
#define rep(i,n) for(int i=0;i<n;i++)
#define range(i,s,n) for(int i=s;i<n;i++)
#define all(a) a.begin(),a.end()
#define rall(a) a.rbegin(),a.rend()
#define fs first
#define sc second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define INF 1e9
#define EPS 1e-9
string solve(string s){
int d=0,dep=0;
string ans=s;
stack<int> p;
for(int i=0;i<s.size();i++){
char c=s[i];
if(c=='[') p.push(i);
else if(c==']'){
int f=p.top(),l; p.pop();
string inner=s.substr(f+1,i-f-1);
l=inner.length()+2;
inner=solve(s.substr(f+1,i-f-1));
reverse(all(inner));
auto tmp=s.substr(0,f)+inner+s.substr(i+1);
s=tmp;
i-=l-inner.length();
}
else if(c=='+') d++,dep++;
else if(c=='-') d--,dep++;
else{
char tt;
if(c=='?')tt='A';
else tt=(char)((c-'A'+d+2600)%26+'A');
auto tmp=s.substr(0,i-dep)+tt+s.substr(i+1);
i-=dep;
s=tmp;
d=dep=0;
}
}
return s;
}
string bur(string s){
// string ans(100,'Z');
// if(count(all(s),'?')==0) return solve(s);
// rep(i,26){
// string os=s;
// os[s.find('?')]='A'+i;
// ans=min(ans,bur(os));
// }
return solve(s);
}
int main(){
string o;
while(cin>>o,o!="."){
cout<<bur(o)<<endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
class range {
private:
struct Iterator {
int val, inc;
int operator*() {return val;}
bool operator!=(Iterator& itr) {return val != itr.val;}
void operator++() {val += inc;}
};
Iterator i, n;
public:
range(int n) : i({0, 1}), n({n, 1}) {}
range(int i, int n) : i({i, 1}), n({n, 1}) {}
range(int i, int inc, int n) : i({i, inc}), n({n, inc}) {}
Iterator& begin() {return i;}
Iterator& end() {return n;}
};
template<class T> inline T at(const vector<T> &v, int i) {return v[(i % (int)v.size() + v.size()) % v.size()];}
template<class T> inline bool is_max(T &a, const T &b) {return a < b ? a = b, true : false;}
template<class T> inline bool is_min(T &a, const T &b) {return a > b ? a = b, true : false;}
class Parser {
private:
string s;
long long p;
string factor() {
string res;
if (s[p] == '[') {
++p;
res = expr();
++p;
reverse(res.begin(), res.end());
return res;
}
while (isalpha(s[p])) res += s[p++];
return res;
}
string expr() {
string res;
while (true) {
if (s[p] == '+') {
++p;
string f = expr();
if (f[0] == 'Z') f[0] = 'A';
else ++f[0];
res += f;
} else if (s[p] == '-') {
++p;
string f = expr();
if (f[0] == 'A') f[0] = 'Z';
else --f[0];
res += f;
} else if (isalpha(s[p]) || s[p] == '[') {
res += factor();
} else {
break;
}
}
return res;
}
public:
Parser(string s) : s(s + '@'), p(0) {}
string eval() {return expr();}
};
string solve(string str) {
int index = str.find("?");
if (index == (int)string::npos) {
Parser parser(str);
return parser.eval();
}
string res;
for (int i : range(100)) res += "Z";
for (int i : range('A', 'Z' + 1)) {
str[index] = i;
is_min(res, solve(str));
}
return res;
}
int main() {
while (true) {
string str;
cin >> str;
if (str == ".") break;
cout << solve(str) << endl;
}
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<queue>
#include<stack>
#include<map>
#include<set>
#include<functional>
using namespace std;
#define REP(i, a, n) for(int i=a; i<n; i++)
#define RREP(i, a, n) for(int i=n-1; i>=a; i--)
#define INF 1000000000
#define ll long long
int main()
{
string S;
while (cin >> S, S != ".") {
int cnt = 0, idx = 0;
char ans[101];
stack<int> stk;
REP(i, 0, S.size()) {
if (S[i] == '+') cnt++;
else if (S[i] == '-') cnt--;
else if (S[i] == '?') {
ans[idx] = 'A';
idx++;
cnt = 0;
}
else if (S[i] == '[') {
stk.push(idx);
}
else if (S[i] == ']') {
int begin = stk.top(), end = idx - 1;
stk.pop();
while(end - begin > 0) {
swap(ans[begin], ans[end]);
begin++;
end--;
}
}
else {
cnt %= 26;
char tmp = S[i] + cnt;
if (tmp > 'Z') {
tmp = tmp - 26;
}
if (tmp < 'A') {
tmp = tmp + 26;
}
ans[idx] = tmp;
idx++;
cnt = 0;
}
}
ans[idx] = '\0';
cout << ans << endl;
}
return 0;
} |
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#include <cfloat>
using std::cerr;
using std::cin;
using std::cout;
using std::endl;
struct Status{
std::string s;
int pos_back;
};
Status Cipher(const std::string&,int);
Status String(const std::string&,int);
Status Letter(const std::string&,int);
Status Cipher(const std::string& s,int pos_front){
Status result;
for(int i=pos_front;i<s.size();i++){
Status str_result=String(s,i);
result.s+=str_result.s;
result.pos_back=str_result.pos_back;
i=result.pos_back;
if(i+1<s.size()&&s[i+1]==']'){
return result;
}
}
return result;
}
Status String(const std::string& s,int pos_front){
if(s[pos_front]=='['){
Status cip_result=Cipher(s,pos_front+1);
std::reverse(cip_result.s.begin(), cip_result.s.end());
cip_result.pos_back++;
return cip_result;
}else{
Status let_result=Letter(s,pos_front);
return let_result;
}
}
char IncrementChar(char c, int increment){
increment%='Z'-'A'+1;
c+=increment;
if(c>'Z'){
c-='Z'-'A'+1;
}else if(c<'A'){
c+='Z'-'A'+1;
}
return c;
}
Status Letter(const std::string& s,int pos_front){
int increment=0;
for(int i=pos_front;i<s.size();i++){
if(s[i]=='+'){
increment++;
}else if(s[i]=='-'){
increment--;
}else{
Status result;
result.s=std::string{IncrementChar(s[i],increment)};
result.pos_back=i;
return result;
}
}
}
std::string Solve(std::string s){
std::vector<std::string> result;
bool found_hatena=false;
for(int i=0;i<s.size();i++){
if(s[i]=='?'){
found_hatena=true;
for(char c='A';c<='Z';c++){
std::string replaced=s;
replaced[i]=c;
result.push_back(Solve(replaced));
}
break;
}
}
if(!found_hatena){ result.push_back(Cipher(s,0).s);}
std::sort(result.begin(), result.end());
// cerr<<result.front()<<endl;
return result.front();
}
int main(){
cout << std::fixed << std::setprecision(16);
cin.tie(nullptr);
std::ios::sync_with_stdio(false);
while(1){
std::string s;
cin>>s;
if(s=="."){
break;
}
cout<<Solve(s)<<endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char calc (string s) {
char c = s[s.size()-1];
int sum = 0;
for (int i = 0; i < s.size() - 1; i++) {
sum += s[i] == '-' ? -1 : 1;
}
if (c == '?') {
c = 'A';
} else {
c = 'A' + (((c - 'A') + 26 + (sum % 26)) % 26);
}
return c;
}
string dfs (string str) {
int i = 0;
string res = "";
string tmp = "";
for (int i = 0; i < str.size(); i++) {
if (str[i] == '+' || str[i] == '-') {
tmp += str[i];
} else if ('A' <= str[i] && str[i] <= 'Z' || str[i] == '?') {
tmp += str[i];
res += calc(tmp);
tmp = "";
} else if (str[i] == '[') {
int count = 1;
i++;
string str_ = "";
while (count) {
if (str[i] == '[') count++;
if (str[i] == ']') count--;
if (count) {
str_ += str[i];
}
i++;
}
i--;
str_ = dfs (str_);
for (int j = str_.size()-1; j >= 0; j--) {
res += str_[j];
}
}
}
return res;
}
int main () {
string str;
while (cin >> str, str != ".") {
cout << dfs(str) << endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
string s;
int p,len;
string bnf(bool rev){
string res;
int cnt=0;
while(p!=len){
if(s[p]=='+')p++,cnt++;
if(s[p]=='-')p++,cnt--;
if('A'<=s[p]&&s[p]<='Z')res+=((s[p++]+cnt+26*100)-'A')%26+'A',cnt=0;
if(s[p]=='?')res+=s[p++],cnt=0;
if(s[p]=='[')p++,res+=bnf(true);
if(s[p]==']'){
p++;
break;
}
}
if(rev)reverse(res.begin(),res.end());
return res;
}
int main(){
while(1){
cin>>s;
if(s==".")break;
len=s.size();
p=0;
string ans=bnf(false);
for(int i=0;i<(int)ans.size();i++)
if(ans[i]=='?')ans[i]='A';
cout<<ans<<endl;
}
return 0;
} |
#include<iostream>
#include<algorithm>
using namespace std;
char change(char a,string str,int i){
int t=0;
for(int j=i-1;j>=0;j--){
if(str[j]=='+') t++;
else if(str[j]=='-')t--;
else break;
}
a=(a+26*10-'A'+t)%26+'A';
return a;
}
void ja(string str){
string anstr;
for(int i=0;i<(int)str.size();i++){
if(str[i]>='A' && str[i]<='Z')anstr+=change(str[i],str,i);
else if(str[i]=='?') anstr+='A';
else if(str[i]=='[')anstr+='[';
else if(str[i]==']') anstr+=']';
}
for(int i=0;i<(int)anstr.size();i++){
if(anstr[i]=='['){
int cnt=1;
int j;
for(j=i+1;cnt>0;j++){
if(anstr[j]=='[')cnt++,anstr[j]=']';
else if(anstr[j]==']')cnt--,anstr[j]='[';
}
anstr[j-1]=']';
reverse(anstr.begin()+i+1,anstr.begin()+j-1);
}
}
for(int i=0;i<(int)anstr.size();i++)if(anstr[i]>='A' && anstr[i]<='Z')cout<<anstr[i];
cout<<endl;
}
int main(){
while(1){
string str;
cin>>str;
if(str==".")break;
ja(str);
}
return 0;
} |
/*
* 2584.cc: Broken Cipher Generator
*/
#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 = 100;
typedef long long ll;
const int INF = 1 << 30;
const ll LINF = 1LL << 60;
/* typedef */
typedef vector<int> vi;
typedef queue<int> qi;
typedef pair<int,int> pii;
/* global variables */
/* subroutines */
string cipher(string &s, int &pos);
char letter(string &s, int &pos) {
if (s[pos] == '+') {
pos++; // '+'
char l = letter(s, pos);
if (l == '?') return l;
return (l == 'Z') ? 'A' : l + 1;
}
if (s[pos] == '-') {
pos++; // '-'
char l = letter(s, pos);
if (l == '?') return l;
return (l == 'A') ? 'Z' : l - 1;
}
return s[pos++];
}
string str(string &s, int &pos) {
if (s[pos] != '[') return string(1, letter(s, pos));
pos++; // '['
string ci = cipher(s, pos);
pos++; // ']'
for (int i = 0, j = ci.size() - 1; i < j; i++, j--) swap(ci[i], ci[j]);
return ci;
}
string cipher(string &s, int &pos) {
string ci;
while (pos < s.size() && s[pos] != ']') ci += str(s, pos);
return ci;
}
/* main */
int main() {
for (;;) {
string s;
cin >> s;
if (s == ".") break;
int pos = 0;
string ans = cipher(s, pos);
for (int i = 0; i < ans.size(); i++)
if (ans[i] == '?') ans[i] = 'A';
cout << ans << endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define mod 26
using namespace std;
string str;
string solve(){
string res;
stack <int> st;
for(int i=0;i<str.size();i++){
int cnt=0;
while(str[i]=='+'||str[i]=='-')cnt+=(str[i]=='+')-(str[i]=='-'),i++;
if(cnt) res+=((str[i]-'A')+cnt%mod+mod)%mod+'A';
else if(str[i]!='['&&str[i]!=']')res += str[i];
if(str[i]=='?')res[res.size()-1]='A';
if(str[i]=='[')st.push(res.size());
if(str[i]==']'){
reverse(res.begin()+st.top(),res.end());
st.pop();
}
}
return res;
}
int main(){
while(1){
cin>>str;
if(str==".")break;
cout <<solve()<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
#define mod 26
#define S str[i]
using namespace std;
string str;
string solve(){
string res;
stack <int> st;
for(int i=0;i<str.size();i++){
int cnt=0;
while(S=='+'||S=='-')cnt+=(S=='+')-(S=='-'),i++;
if(cnt) res+=((S-'A')+cnt%mod+mod)%mod+'A';
else if(S!='['&&S!=']')res += S;
if(S=='?')res.back()='A';
if(S=='[')st.push(res.size());
if(S==']')reverse(res.begin()+st.top(),res.end()),st.pop();
}
return res;
}
int main(){
while(cin>>str&&str!=".")cout <<solve()<<endl;
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long int LL;
typedef long long int ll;
typedef pair<long long int, long long int> pii;
typedef pair<double, double> pdd;
#define SORT(c) sort((c).begin(),(c).end())
#define BACKSORT(c) sort((c).begin(),(c).end(),std::greater<LL>())
#define FOR(i,a,b) for(LL i=(a);i<(b);++i)
#define REP(i,n) FOR(i,0,n)
#define SP << " " <<
string parse(string& s,int& idx){
if(s[idx]=='#'){
return "";
}
if(s[idx]=='['){
idx++;
string str = parse(s, idx);
string ans = "";
REP(i,str.size()){
ans += str[str.size() - i - 1];
}
return ans + parse(s,idx);
}
else if (s[idx] == ']')
{
idx++;
return "";
}
else
{
LL cnt = 0;
while(s[idx]=='+'||s[idx]=='-'){
if(s[idx]=='+'){
cnt++;
}
else
{
cnt--;
}
cnt = (cnt + 26) % 26;
idx++;
}
if(s[idx]=='?'){
idx++;
return 'A' + parse(s, idx);
}else{
char c = (s[idx] - 'A' + cnt)%26 + 'A';
idx++;
return c + parse(s, idx);
}
}
}
LL mod = 1000000007;
int main()
{
cin.tie(0);
ios::sync_with_stdio(false);
while (true)
{
string s;
cin >> s;
if(s[0]=='.'){
break;
}
s += "#";
int idx = 0;
string str = parse(s, idx);
cout << str << endl;
}
}
|
#include <iostream>
#include <string>
#include <stack>
#include <algorithm>
#define rep(i,n) for(int i=0; i<(n); i++)
using namespace std;
string S;
void solve(){
char ans[100]={};
stack<int> st;
int now = 0, sf = 0;
rep(i,S.length()){
if( S[i] == '[' ){
st.push( now );
}else if( S[i] == ']' ){
int b = st.top();
st.pop();
for(int l=b, r=now-1; r-l>0; l++, r--){
swap(ans[l], ans[r]);
}
}else if( S[i] == '+' ){
sf++;
}else if( S[i] == '-' ){
sf--;
}else if( S[i] == '?' ){
ans[now++] = 'A';
sf = 0;
}else{
sf %= 26;
char tmp = S[i] + sf;
if( S[i] + sf > 'Z' ) tmp = 'A' + sf - ('Z' - S[i] + 1);
if( S[i] + sf < 'A' ) tmp = 'Z' + sf + (S[i] - 'A' + 1);
ans[now++] = tmp;
sf = 0;
}
}
ans[now] = '\0';
cout << ans << endl;
}
int main(){
while(cin>>S, S != "."){
solve();
}
return 0;
} |
#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
#define mp make_pair
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 = 1000000000;
static const ll MOD = 1000000007LL;
static const double EPS = 1E-10;
string s;
typedef string::const_iterator State;
class ParseError{};
class Parsing
{
typedef string::const_iterator State;
public:
static inline string solve(string s)
{
State begin = s.begin();
return Cipher(begin);
}
private:
static void consume(State& begin, char expected)
{
if (*begin == expected) {
begin++;
} else {
cerr << "Expected '" << expected << "' but got '" << *begin << "'"
<< endl;
cerr << "Rest string is '";
while (*begin) {
cerr << *begin++;
}
cerr << "'" << endl;
throw ParseError();
}
}
static string Cipher(State& begin)
{
string ret = "";
while(*begin != '$' && *begin != ']') ret += String(begin);
return ret;
}
static string String(State& begin)
{
string ret = "";
if(*begin != '['){
ret += Letter(begin);
}
else{
begin++;
ret += Cipher(begin);
reverse(ALL(ret));
begin++;
}
return ret;
}
static char Letter(State& begin)
{
int cnt = 0;
while(*begin == '+' || *begin == '-'){
if(*begin == '+') cnt += 1;
if(*begin == '-') cnt -= 1;
begin++;
}
if(*begin == '?'){
begin++;
return 'A';
}
int ret = *begin - 'A' + cnt;
while(ret < 0) ret += 26;
begin++;
return ret % 26 + 'A';
}
};
int main()
{
while(cin >> s, s != ".") cout << Parsing::solve(s + '$') << endl;
return 0;
} |
#include<iostream>
#include<string>
#include<algorithm>
#include<map>
#include<set>
#include<utility>
#include<vector>
#include<cmath>
#include<cstdio>
#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 it ::iterator
#define all(in) in.begin(),in.end()
const double PI=acos(-1);
const double ESP=1e-10;
using namespace std;
void kansu(vector<char>& in,int x){
in[x]='!';
//cout<<"!"<<endl;
vector<char>t;
loop(i,x+1,in.size()){
if(in[i]=='['){kansu(in,i);i--;}
else if(in[i]==']'){
reverse(all(t));
rep(j,t.size())
in[j+x+1]=t[j];
in[i]='!';
//rep(i,t.size())cout<<t[i]<<" ";
//cout<<endl;
break;
}else{
t.pb(in[i]);
}
}
}
int main(){
string s;
while(cin>>s,s.size()!=1||s[0]!='.'){
vector<char>in;
for(int i=s.size()-1;i>=0;i--){
if(s[i]=='+'||s[i]=='-'||s[i]=='?'){
int tm=i;
char tmp;
if(s[i]=='?'){tmp=s[i];i--;}
else tmp=s[i+1];
while(s[i]=='+'||s[i]=='-'){
if(s[i]=='+')tmp++;
else tmp--;
if(tmp>'Z')tmp='A';
if(tmp<'A')tmp='Z';
i--;
}
i++;
if(s[tm]=='?')tmp='A';
in.pb(tmp);
}else if(i==0||!isalpha(s[i])||(isalpha(s[i])&&(s[i-1]!='+'&&s[i-1]!='-')))in.pb(s[i]);
}
//rep(i,in.size())cout<<in[i]<<" ";
//
reverse(all(in));
rep(i,in.size()){
if(in[i]=='['){
kansu(in,i);
}else if(in[i]!='!'&&in[i]!=']')cout<<in[i];
}
cout<<endl;
}
} |
#include <iostream>
#include <cctype>
#include <algorithm>
using namespace std;
char Letter(string &S, int &i);
string String(string &S, int &i);
string Cipher(string &S, int &i);
char Letter(string &S, int &i){
if(isupper(S[i])||S[i]=='?'){
i++;
return S[i-1];
}else{
char c;
if(S[i]=='+'){
i++;
c = Letter(S,i);
if(c!='?'){
if(c!='Z')c++;
else c='A';
}
}else{
i++;
c = Letter(S,i);
if(c!='?'){
if(c!='A')c--;
else c='Z';
}
}
return c;
}
}
string String(string &S, int &i){
string ret;
if(S[i]=='['){
i++;
ret=Cipher(S,i);
reverse(ret.begin(), ret.end());
i++;
return ret;
}else{
return string(1,Letter(S,i));
}
}
string Cipher(string &S, int &i){
string ret;
while(i<S.size()&&S[i]!=']'){
ret+=String(S,i);
}
return ret;
}
int main(){
while(true){
string S;
cin>>S;
if(S[0]=='.') return 0;
int i=0;
string C = Cipher(S,i);
for(auto &c:C) if(c=='?') c='A';
cout<<C<<endl;
}
} |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.