text stringlengths 49 983k |
|---|
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+5;
const int M=1e5+5;
struct each{
int l,r;
}a[N];
vector<int>d[M];
int n,m,b[M],ans[M];
bool com(each x,each y){
return x.l<y.l;
}
void add(int x,int y){
while(x<=m){
b[x]+=y;
x+=x&-x;
}
}
int query(int x){
int ans=0;
while(x){
ans+=b[x];
x-=x&-x;
}
return ans;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d%d",&a[i].l,&a[i].r);
int top=1;
sort(a+1,a+n+1,com);
for(int i=1;i<=m;i++){
while(top<=n&&a[top].l==i)
add(i,1),add(a[top++].r+1,-1);
for(int j=i;j<=m;j+=i) d[j].push_back(i);
int si=d[i].size();
for(int j=0;j<si;j++){
if(i+d[i][j]<=m) ans[d[i][j]]+=query(i)-query(i+d[i][j]);
ans[d[i][j]]+=query(i)-query(i-d[i][j]);
}
}
for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <math.h>
using namespace std;
const int MAXN = 3e5 + 10;
int N, M;
struct Node {
int l, r, d;
} A[MAXN];
int tr[MAXN];
inline int lowbit(int x) {
return x & (-x);
}
inline void update(int x, int d) {
for(; x <= M; x += lowbit(x))
tr[x] += d;
}
inline int query(int x) {
int res = 0;
for(; x; x -= lowbit(x))
res += tr[x];
return res;
}
int main() {
register int i, d;
scanf("%d%d", &N, &M);
for(i = 1; i <= N; ++i)
scanf("%d%d", &A[i].l, &A[i].r), A[i].d = A[i].r - A[i].l + 1;
sort(A + 1, A + N + 1, [&](Node x, Node y) {return x.d < y.d;});
int k = 1;
for(d = 1; d <= M; ++d) {
while(k <= N && A[k].d < d) {
update(A[k].l, 1); update(A[k].r + 1, -1);
++k;
}
int ans = N - k + 1;
for(i = d; i <= M; i += d)
ans += query(i);
printf("%d\n", ans);
}
return 0;
} |
#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;
int n,m,l[310000],r[310000],tree[110000];
vector<int> vec[110000];
void add(int x,int y){
for (;x<=m;x+=x&-x) tree[x]+=y;
}
int getsum(int x){
int sum=0;
for (;x;x-=x&(-x)) sum+=tree[x];
return sum;
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++){
scanf("%d%d",&l[i],&r[i]);
vec[r[i]-l[i]+1].push_back(i);
}
for (int i=1;i<=m;i++){
int ans=0;
for (int j=0;j<(int)vec[i].size();j++)
add(l[vec[i][j]],1),add(r[vec[i][j]]+1,-1);
for (int j=i;j<=m;j+=i) ans+=getsum(j);
n-=vec[i].size();
printf("%d\n",ans+n);
}
return 0;
}
// |
#include <iostream>
#include <vector>
using namespace std;
class Fenwick {
public:
Fenwick(int _N) : N(_N), v(N+1, 0) {}
private:
int N;
vector<int> v;
public:
void add(int val, int p){
for(int i=p;i<=N;i+=i&-i) v[i] += val;
}
int sum(int p){
int res = 0;
for(int i=p;i>0;i-=i&-i) res += v[i];
return res;
}
};
int main(){
int N, M;
while(cin >> N >> M){
Fenwick f(M+1);
vector< vector<pair<int,int>> > range(M+1);
for(int i=0;i<N;i++){
int l, r; cin >> l >> r;
range[r-l+1].push_back(make_pair(l, r));
}
cout << N << endl;
int all = N;
for(int i=2;i<=M;i++){
all -= range[i-1].size();
for(const pair<int,int>& p : range[i-1]){
f.add(1, p.first);
f.add(-1, p.second+1);
}
int res = all;
for(int j=i;j<=M;j+=i) res += f.sum(j);
cout << res << endl;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 300000;
int n, m, c[maxn + 5];
struct node {
int l, r;
bool operator < (const node &x) const {
return r - l + 1 < x.r - x.l + 1;
}
} a[maxn + 5];
int lb (int x) { return x & (-x); }
void add(int x, int d) {
for (int i = x; i <= n; i += lb(i))
c[i] += d;
}
int sum(int x) {
int ret = 0;
for (int i = x; i; i -= lb(i))
ret += c[i];
return ret;
}
int main() {
scanf("%d %d", &m, &n);
for (int i = 1; i <= m; i++) {
scanf("%d %d", &a[i].l, &a[i].r);
}
int pos = 1;
sort(a + 1, a + m + 1);
for (int i = 1; i <= n; i++) {
while (pos <= m && a[pos].r - a[pos].l + 1 <= i) {
add(a[pos].l, 1); add(a[pos].r + 1, -1);
pos++;
}
int ans = m - pos;
for (int j = i; j <= n; j += i) {
ans += sum(j);
}
printf("%d\n", ans + 1);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int d[100005];
int main()
{
int n, m; scanf("%d%d", &n, &m);
for (int i = 0;i < n;i++)
{
int l, r; scanf("%d%d", &l, &r);
d[1]++; d[r-l+2]--;
d[l]++; d[r+1]--;
if (l <= r-l+1) { d[l]--; d[r-l+2]++; }
int at = r-l+2;
while (at < l)
{
int fact = (l+at-1)/at;
int hi = r/fact;
if (hi >= at)
{
d[at]++;
if (hi+1 < 100005) d[hi+1]--;
}
fact = r/(max(at, hi)+1);
if (fact == 0) break;
at = (l+fact-1)/fact;
}
}
for (int i = 1;i <= m;i++)
{
d[i] += d[i-1];
printf("%d\n", d[i]);
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
class Fenwick {
public:
Fenwick(int _N) : N(_N), v(N+1, 0) {}
private:
int N;
vector<int> v;
public:
void add(int val, int p){
for(int i=p;i<=N;i+=i&-i) v[i] += val;
}
int sum(int p){
int res = 0;
for(int i=p;i>0;i-=i&-i) res += v[i];
return res;
}
};
int main(){
int N, M; cin >> N >> M;
Fenwick f(M+1);
vector< vector<pair<int,int>> > range(M+1);
for(int i=0;i<N;i++){
int l, r; cin >> l >> r;
range[r-l+1].push_back(make_pair(l, r));
}
cout << N << endl;
int all = N;
for(int i=2;i<=M;i++){
all -= range[i-1].size();
for(const pair<int,int>& p : range[i-1]){
f.add(1, p.first);
f.add(-1, p.second+1);
}
int res = all;
for(int j=i;j<=M;j+=i) res += f.sum(j);
cout << res << endl;
}
}
|
# include "iostream"
# include "cstdio"
# include "vector"
# define lowbit(x) (x&-x)
using namespace std;
const int maxm=3e5+10;
int N,M,Tree[maxm<<1],Ans[maxm];
vector<int> L[maxm],H[maxm];
inline void Update(int x,int Value){
while(x<=M){
Tree[x]+=Value;
x+=lowbit(x);
}
return;
}
inline int Ask(int x){
if(x>M) return 0;
register int Result=0;
while(x){
Result+=Tree[x];
x-=lowbit(x);
}
return Result;
}
int main(){
register int i,j;
int x,y;
scanf("%d%d",&N,&M);
for(i=1;i<=N;i++){
scanf("%d%d",&x,&y);
L[x].push_back(y);
}
for(i=1;i<=M;i++){
for(j=i;j<=M;j+=i){
H[j].push_back(i);
}
}
for(i=1;i<=M;i++){
for(j=0;j<L[i].size();j++){
Update(i,1);
Update(L[i][j]+1,-1);
}
for(j=0;j<H[i].size();j++){
Ans[H[i][j]]+=Ask(i)-Ask(i+H[i][j]);
}
}
for(i=1;i<=M;i++){
printf("%d\n",Ans[i]);
}
return 0;
} |
#include<bits/stdc++.h>
#define N 600005
using namespace std;
int n,m,l,r,c[N];
struct node{int l,r,len;}a[N];
inline bool cmp(node aa,node bb){return aa.len<bb.len;}
inline int lowbit(int x){return x&-x;}
inline void add(int x,int y){for(int i=x;i<=m;i+=lowbit(i))c[i]+=y;}
inline int sum(int x){int ans=0;for(int i=x;i;i-=lowbit(i))ans+=c[i];return ans;}
int main(){
scanf("%d%d",&n,&m);int tot=0;
for (int i=1;i<=n;i++){
scanf("%d%d",&l,&r);
a[i].l=l;a[i].r=r;
a[i].len=r-l+1;
}
sort(a+1,a+n+1,cmp);int j=1;
for (int i=1;i<=m;i++){
for (;j<=n;j++){
if (a[j].len>i) break;
add(a[j].l,1);
if (a[j].r+1<=m) add(a[j].r+1,-1);
}
int ans=n-j+1;
for (int j=i;j<=m;j+=i) ans=ans+sum(j);
printf("%d\n",ans);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
int n, m, rm, ans[100010];
int main(){
scanf("%d%d", &n, &m);
for(int x, y; n--; ){
scanf("%d%d", &x, &y);
int b = y + 1;
for(int j = 1; j * j <= m; j++){
int tx = (x + j - 1) / j, ty = y / j;
ans[tx]++;
ans[min(b, ty + 1)]--;
b = tx;
}
for(int i = 1; i < b; i++){
if((x - 1) / i < y / i){
ans[i]++; ans[i + 1]--;
}
}
}
for(int i = 1; i <= m; i++){
ans[i] += ans[i - 1];
printf("%d\n", ans[i]);
}
} |
#include<bits/stdc++.h>
#define MAXN 300005
#define LL long long
#define len(p) (n[p].r - n[p].l + 1)
using namespace std;
int N,M;
struct Node{
int l,r;
Node(int l=0, int r=0):l(l), r(r){}
bool operator < (const Node& n1) const{
return r-l < n1.r-n1.l;
}
} n[MAXN];
//
int fw[MAXN];
int lbt(int x){
return x & (-x);
}
int getsum(int x){
int ans = 0;
for(;x;x -= lbt(x)){
ans += fw[x];
}
return ans;
}
void change(int x, int dv){
for(;x<=M;x += lbt(x)){
fw[x] += dv;
}
}
//
int main(){
ios::sync_with_stdio(0);
cin>>N>>M;
for(int i=1;i<=N;i++){
cin>>n[i].l>>n[i].r;
}
sort(n+1, n+1+N);
int p = 0;
for(int d=1;d<=M;d++){
while(p+1<=N && len(p+1)<d){
p++;
change(n[p].l, +1);
change(n[p].r+1, -1);
}
int ans = 0;
for(int j=d;j<=M;j+=d){
ans += getsum(j);
}
cout<<ans + (N-p)<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
#define LL long long
#define uLL unsigned long long
#define db long double
using namespace std;
const int N=3e5+10;
int rd()
{
int x=0,w=1;char ch=0;
while(ch<'0'||ch>'9'){if(ch=='-') w=-1;ch=getchar();}
while(ch>='0'&&ch<='9'){x=(x<<3)+(x<<1)+(ch^48);ch=getchar();}
return x*w;
}
struct line
{
int l,r;
bool operator < (const line &bb) const {return r-l+1<bb.r-bb.l+1;}
}a[N];
int n,m,bt[N];
void add(int x,int y){while(x<=n) bt[x]+=y,x+=x&(-x);}
int gsm(int x){int an=0;while(x) an+=bt[x],x-=x&(-x);return an;}
int main()
{
m=rd(),n=rd();
for(int i=1;i<=m;++i) a[i].l=rd(),a[i].r=rd();
sort(a+1,a+m+1);
for(int i=1,j=1;i<=n;++i)
{
while(j<=m&&a[j].r-a[j].l+1<=i)
add(a[j].l,1),add(a[j].r+1,-1),++j;
int ans=m-j+1;
for(int d=i;d<=n;d+=i) ans+=gsm(d);
printf("%d\n",ans);
}
return 0;
}
|
#include <iostream>
#include <vector>
#include <iomanip>
using namespace std;
class Fenwick {
public:
Fenwick(int _N) : N(_N), v(N+1, 0) {}
private:
int N;
vector<int> v;
public:
void add(int val, int p){
for(int i=p;i<=N;i+=i&-i) v[i] += val;
}
int sum(int p){
int res = 0;
for(int i=p;i>0;i-=i&-i) res += v[i];
return res;
}
};
int main(){
std::ios_base::sync_with_stdio(false);
int N, M;
while(cin >> N >> M){
Fenwick f(M+1);
vector< vector<pair<int,int>> > range(M+1);
for(int i=0;i<N;i++){
int l, r; cin >> l >> r;
range[r-l+1].push_back(make_pair(l, r));
}
cout << N << endl;
int all = N;
for(int i=2;i<=M;i++){
all -= range[i-1].size();
for(const pair<int,int>& p : range[i-1]){
f.add(1, p.first);
f.add(-1, p.second+1);
}
int res = all;
for(int j=i;j<=M;j+=i) res += f.sum(j);
cout << res << endl;
}
}
}
|
#include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)
#define lb(x) (x&-x)
const int N=500005;
struct data {
int l,r;
} p[N];
int s[N],n,m;
int read() {
int x=0,v=1; char ch=getchar();
for (;ch<'0'||ch>'9';v=(ch=='-')?(-1):v,ch=getchar());
for (;ch<='9'&&ch>='0';x=x*10+ch-'0',ch=getchar());
return x*v;
}
void add(int x,int v) {
for (;x<=m;x+=lb(x)) s[x]+=v;
}
int get(int x) {
int res=0;
for (;x;x-=lb(x)) res+=s[x];
return res;
}
bool cmp(data a,data b) {
return (a.r-a.l<b.r-b.l);
}
int main(void) {
n=read(),m=read();
rep(i,1,n) p[i].l=read(),p[i].r=read();
std:: sort(p+1,p+n+1,cmp);
int rec=n;
for (int d=1,j=1;d<=m;++d) {
while (j<=n&&p[j].r-p[j].l+1<d) {
add(p[j].l,1),add(p[j].r+1,-1);
j++,rec--;
}
int ans=rec;
for (int i=0;i<=m;i+=d) {
ans+=get(i);
}
printf("%d\n", ans);
}
return 0;
} |
#include <iostream>
#include <vector>
#include <cmath>
using namespace std;
int main(){
int N, M;
while(cin >> N >> M){
int thr = (int)sqrt(M);
vector<int> l(N), r(N);
for(int i=0;i<N;i++) cin >> l[i] >> r[i];
for(int d=1;d<=thr;d++){
int res = 0;
for(int i=0;i<N;i++){
if((l[i]+d-1)/d <= r[i]/d) ++res;
}
cout << res << endl;
}
vector<int> m(200001, 0);
for(int i=0;i<N;i++){
int checked = 200000;
for(int c=1;c<=thr;c++){
int left = (l[i]+c-1)/c;
int right = min(r[i]/c, checked-1);
m[left]++;
m[right+1]--;
checked = left;
}
}
for(int i=0;i<200000;i++) m[i+1] += m[i];
for(int d=thr+1;d<=M;d++){
cout << m[d] << endl;
}
}
}
|
#include<bits/stdc++.h>
#define lowbit(x) ((x) & (-(x)))
const int N = 300010;
int n, m, c[N], ans[N];
void add(int l, int r){
++ r;
while (r < N){
-- c[r];
r += lowbit(r);
}
while (l < N){
++ c[l];
l += lowbit(l);
}
}
int query(int sit){
int ret = 0;
while (sit){
ret += c[sit];
sit -= lowbit(sit);
}
return ret;
}
std::vector <std::pair <int, std::pair <int, int>>> vec;
int main(){
scanf("%d%d", &n, &m);
for (int i = 0, l, r; i < n; ++ i){
scanf("%d%d", &l, &r);
vec.push_back({r - l + 1, {l, r}});
}
sort(vec.begin(), vec.end());
for (int i = 1, sit = 0; i <= m; ++ i){
while (vec[sit].first <= i && sit < n){
add(vec[sit].second.first, vec[sit].second.second);
++ sit;
}
for (int j = 1; i * j <= m; ++ j){
ans[i] += query(i * j);
}
ans[i] += n - sit;
}
for (int i = 1; i <= m; ++ i){
printf("%d\n", ans[i]);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define lowbit(x) (x&-x)
const int M=3e5+5;
struct d{int l,r;}a[M];
bool cmp(d a,d b){return a.r-a.l<b.r-b.l;}
int sum[M];
void upd(int pos,int x){for(int i=pos;i<M;i+=lowbit(i))sum[i]+=x;return ;}
int que(int pos){int res=0;for(int i=pos;i>0;i-=lowbit(i))res+=sum[i];return res;}
int main()
{
int n,m;scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)scanf("%d%d",&a[i].l,&a[i].r);
sort(a+1,a+1+n,cmp);
for(int d=1,j=1;d<=m;d++)
{
while(j<=n&&a[j].r-a[j].l<d-1)
{
upd(a[j].l,1);
upd(a[j].r+1,-1);
j++;
}
int ans=n-j+1;
for(int i=d;i<=m;i+=d)ans+=que(i);
printf("%d\n",ans);
}
}
|
#include<cstdio>
int N,M;
struct range{int l,r;range*next;}a[300010],*fir[300010];
int b[100010];
void add(int i,int x){for(;i<=M;i+=i&-i)b[i]+=x;}
int query(int i){int s=0;for(;i;i-=i&-i)s+=b[i];return s;}
int main(){
scanf("%d%d",&N,&M);
for(int i=0,l,r;i<N;i++){
scanf("%d%d",&l,&r);++r;
a[i]=(range){l,r,fir[r-l]};fir[r-l]=a+i;
}
for(int i=1;i<=M;i++){
for(range*j=fir[i];j;j=j->next,N--)add(j->l,1),add(j->r,-1);
int ans=N;
for(int j=i;j<=M;j+=i)ans+=query(j);
printf("%d\n",ans);
}
} |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int mod = 1000000007;
int n, t[200005];
void inc(int l, int r) {
for (l += n, r += n; l < r; l >>= 1, r >>= 1) {
if (l & 1) t[l++]++;
if (r & 1) t[--r]++;
}
}
int que(int x) {
int z = 0;
for (x += n; x; x >>= 1) z += t[x];
return z;
}
int main() {
ios::sync_with_stdio(false);
int m, u, v, c = 0;
vector<pii> a[100005] = {};
cin >> m >> n; c = m; n++;
while (m--) cin >> u >> v, a[v - u + 1].push_back({u, v + 1});
for (int i = 1; i < n; i++) {
int z = 0;
for (int j = i; j <= n; j += i) z += que(j);
cout << z + c << '\n';
for (pii j : a[i]) inc(j.first, j.second), c--;
}
}
|
#include <iostream>
#include <algorithm>
#include <cstring>
constexpr int MAX=(int)1e5;
using P=std::pair<int,int>;
int n,m;
int bit[MAX+2];
P sec[MAX*3];
bool used[MAX*3];
void add(int k,int x) {
for(int i=k;i<=m;i+=(i&-i))
bit[i]+=x;
}
int sum(int k) {
int res=0;
for(int i=k;i>0;i-=(i&-i))
res+=bit[i];
return res;
}
int main() {
std::cin>>n>>m;
int l,r;
for(int i=0;i<n;++i){
std::cin>>l>>r;
sec[i].first=r-l+1;
sec[i].second=l;
}
std::sort(sec,sec+n);
int c=0;
for(int i=1;i<=m;++i) {
while(c<n&&sec[c].first<i) {
add(sec[c].second,1);
add(sec[c].second+sec[c].first,-1);
++c;
}
int ans=n-c;
for(int j=0;j<=m;j+=i)
ans+=sum(j);
std::cout<<ans<<std::endl;
}
return 0;
} |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int _=3e5+10;
int n,m,c[_];
inline void add(int x,int y){
for(;x<=m;x+=x&(-x))c[x]+=y;
}
inline int sum(int x){
int res=0;
for(;x;x-=x&(-x))res+=c[x];
return res;
}
struct node{
int l,r,len;
}e[_];
inline bool cmp(node t1,node t2){
return t1.len<t2.len;
}
signed main(){
cin>>n>>m;
for(int i=1;i<=n;i++){
scanf("%d%d",&e[i].l,&e[i].r);
e[i].len=e[i].r-e[i].l+1;
}
sort(e+1,e+1+n,cmp);
int num=1;
for(int d=1;d<=m;d++){
while(e[num].len<d&&num<=n)
{ add(e[num].l,1); add(e[num].r+1,-1); num++; }
int ans=n-num+1;
for(int j=1;j*d<=m && d;j++)ans+=sum(j*d);
printf("%d\n",ans);
}
} |
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=3e5+5;
struct node{
int l,r;
bool operator < (const node &b)const{
return r-l<b.r-b.l;
}
}a[N];
int n,m,bit[N];
void modify(int x,int v){
while(x<=m)
bit[x]+=v,x+=x&-x;
}
int query(int x){
int res=0;
while(x)
res+=bit[x],x^=x&-x;
return res;
}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i)
scanf("%d%d",&a[i].l,&a[i].r);
sort(a+1,a+n+1);
for(int i=1,j=1;i<=m;++i){
while(j<=n&&a[j].r-a[j].l<i)
modify(a[j].l,1),modify(a[j].r+1,-1),++j;
int res=n+1-j;
for(int k=i;k<=m;k+=i)
res+=query(k);
printf("%d\n",res);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define N 500007
#define ll long long
int sum[N],n,m;
struct str
{
int l,r,d;
}p[N];
bool operator <(str a,str b)
{
return a.d<b.d;
}
void add(int x,int d)
{
if(!x)return;
for(;x<=m;x+=x&-x)
sum[x]+=d;
}
void mody(int l,int r,int d)
{
add(l,d),add(r+1,-d);
}
int query(int x)
{
int ans=0;
for(;x;x-=x&-x)
ans+=sum[x];
return ans;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d%d",&p[i].l,&p[i].r),p[i].d=p[i].r-p[i].l;
sort(p+1,p+n+1);
int j=1;
for(int d=1;d<=m;d++)
{
while(j<=n&&p[j].d<d)mody(p[j].l,p[j].r,1),j++;
int ans=n-j+1;
for(int i=d;i<=m;i+=d)
ans+=query(i);
printf("%d\n",ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, M;
cin >> N >> M;
vector<int> L(N), R(N);
for (int i = 0; i < N; ++ i) cin >> L[i] >> R[i];
vector<int> a(M+3);
for (int i = 0; i < N; ++ i) {
int n = 1;
for (;;) {
int x = (L[i]+n-1)/n;
int y = R[i]/n;
if (y < 2) break;
if (x > y) {
n = max(n+1, L[i]/y);
continue;
}
int m = n;
while (x > 2) {
int m2 = R[i] / (x-1);
if (m2 <= m) break;
m = m2;
x = (L[i] + m - 1) / m;
}
x = max(2, x);
//cout << "n = " << n << endl;
//cout << "m = " << m << endl;
//cout << "[" << x << ", " << y << "]" << endl;
a[x]++;
a[y+1]--;
if (x == 2) break;
n = R[i]/x + 1;
}
//cout << endl;
}
cout << N << endl;
int x = 0;
for (int d = 2; d <= M; ++ d) {
x += a[d];
cout << x << endl;
}
}
|
#include<bits/stdc++.h>
using namespace std;
int q,w,e,r,t,c[100010];
struct qqq{
int l,r;
}a[300010];
int read(){
int sum=0;
char st=getchar();
while(st<'0'||'9'<st)st=getchar();
while('0'<=st&&st<='9'){
sum=(sum<<3)+(sum<<1)+st-'0';
st=getchar();
}
return sum;
}
void add(int x,int y){
while(x<=w){
c[x]+=y;
x+=x&(-x);
}
}
int get(int x){
int sum=0;
while(x>0){
sum+=c[x];
x-=x&(-x);
}
return sum;
}
bool paix(qqq s1,qqq s2){
return s1.r-s1.l<s2.r-s2.l;
}
int main(){
cin>>q>>w;
for(int i=1;i<=q;i++){
a[i].l=read(),a[i].r=read();
}
sort(a+1,a+1+q,paix);
int ans,st=0;
for(int i=1;i<=w;i++){
ans=0;
for(;st<q&&a[st+1].r-a[st+1].l+1<i;st++){
add(a[st+1].l,1),add(a[st+1].r+1,-1);
}
for(int j=i;j<=w;j+=i){
ans+=get(j);
}
printf("%d\n",ans+q-st);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 7;
int bit[N], f[N], ans[N];
vector <pair <int, int> > Q[N];
void update(int idx, int value) {
for(int i = idx; i < N; i += i & -i) {
bit[i] += value;
}
}
int query(int idx) {
int res = 0;
for(int i = idx; i > 0; i -= i & -i) {
res += bit[i];
}
return res;
}
int main() {
ios_base :: sync_with_stdio(0); cin.tie(0); cout.tie(0);
int n, m; cin >> n >> m;
for(int i = 1; i <= n; i++) {
int l, r; cin >> l >> r;
f[r - l]++;
Q[r - l].push_back(make_pair(l, r));
}
for(int i = N - 2; i >= 0; i--) {
f[i] += f[i + 1];
}
for(int i = 1; i <= m; i++) {
if(i - 2 >= 0) {
for(auto z: Q[i - 2]) {
int l, r; tie(l, r) = z;
update(l, +1);
update(r + 1, -1);
}
}
ans[i] += f[i - 1];
for(int j = i; j <= m; j += i) {
ans[i] += query(j);
}
cout << ans[i] << "\n";
}
} |
#include<bits/stdc++.h>
using namespace std;
struct Section{
int l,r;
bool operator<(const Section& rhs) const{
return r-l+1<rhs.r-rhs.l+1;
}
} sec[300005];
int N,M,bit[100005];
inline void modify(int pos,int add){
for(;pos<=M+1;pos+=pos&-pos)
bit[pos]+=add;
}
inline int query(int pos){
int res=0;
for(;pos;pos-=pos&-pos)
res+=bit[pos];
return res;
}
int main(){
scanf("%d%d",&N,&M);
for(int i=0;i<N;i++)
scanf("%d%d",&sec[i].l,&sec[i].r);
sort(sec,sec+N);
int cur=0;
for(int i=1;i<=M;i++){
while(cur<N && sec[cur].r-sec[cur].l+1<i){
modify(sec[cur].l,1);
modify(sec[cur].r+1,-1);
cur++;
}
int ans=N-cur;
for(int j=i;j<=M;j+=i)
ans+=query(j);
printf("%d\n",ans);
}
return 0;
} |
#include <algorithm>
#include <cstdio>
const int N=100005;
int f[N],cnt[N],n,m;
struct info{
int l,r;
}a[N*3];
bool cmp(info a,info b){
return a.r-a.l<b.r-b.l;
}
void add(int x,int y){
for (;x<=m;x+=x&-x) f[x]+=y;
}
int sum(int x){
int y=0;
for (;x;x-=x&-x) y+=f[x];
return y;
}
int main(){
scanf("%d%d\n",&n,&m);
for (int i=1;i<=n;i++){
scanf("%d%d\n",&a[i].l,&a[i].r);
cnt[a[i].r-a[i].l]++;
}
for (int i=m;i;i--) cnt[i]+=cnt[i+1];
std::sort(a+1,a+n+1,cmp);
for (int i=1,j=1;i<=m;i++){
for (;j<=n && a[j].r-a[j].l<i;j++){
add(a[j].l,1);add(a[j].r+1,-1);
}
int ans=cnt[i];
for (int k=i;k<=m;k+=i) ans+=sum(k);
printf("%d\n",ans);
}
} |
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 300010;
int n, m, d[N];
struct Point {int l, r;} a[N];
bool operator < (Point a, Point b) {
return a.r - a.l < b.r - b.l;
}
namespace BIT {
#define lowbit(i) (i & -i)
int c[N];
void add(int x, int v) {
for(int i = x; i <= m; i += lowbit(i)) c[i] += v;
}
int query(int x) {
int ans = 0;
for(int i = x; i; i -= lowbit(i)) ans += c[i];
return ans;
}
}
int main() {
scanf("%d%d", &n, &m);
for(int i = 1; i <= n; ++i) scanf("%d%d", &a[i].l, &a[i].r);
sort(a + 1, a + n + 1);
int cur = 1;
for(int i = 1; i <= m; ++i) {
while(cur <= n && a[cur].r - a[cur].l + 1 <= i) {
BIT::add(a[cur].l, 1); BIT::add(a[cur].r + 1, -1);
++cur;
}
for(int j = i; j <= m; j += i) d[i] += BIT::query(j);
d[i] += n - cur + 1;
}
for(int i = 1; i <= m; ++i) printf("%d\n", d[i]);
return 0;
} |
#include <bits/stdc++.h>
std::vector<int> A[' '];
int n, m, S[' '], a, l, r, i, d, x;
void U(int z, int u) {
while (z <= n)
S[z] += u, z += z & -z;
}
int main() {
scanf("%d%d", &m, &n);
for (i = 1; i <= m; i++)
scanf("%d%d", &l, &r), A[r - l + 1].push_back(l);
for (d = 1; d <= n; d++) {
a = m;
for (i = d; i <= n; i += d) {
r = 0, x = i;
while (x)
r += S[x], x -= x & -x;
a += r;
}
for (int u : A[d])
U(u, 1), U(u + d, -1), m--;
printf("%d\n", a);
}
return 0;
} |
#include <cstdio>
#include <algorithm>
const int MAXN=3E5+10;
const int mod=1E9+7;
int N,M;
struct pair {
int l,r;
bool operator < (const pair&a) const {
return r-l < a.r-a.l;
}
int len() {return r-l+1;}
}rc[MAXN];
struct FWT {
int f[MAXN];
void change(int i,int x) {
for(;i<=M;i+=i&(-i))
f[i]+=x;
}
int query(int i) {
int ans=0;
for(;i;i-=i&(-i))
ans+=f[i];
return ans;
}
}fw;
int main() {
scanf("%d%d",&N,&M);
for(int i=1;i<=N;++i) {
scanf("%d%d",&rc[i].l,&rc[i].r);
}std::sort(rc+1,rc+N+1);
/*for(int i=1;i<=N;++i) {
fw.change(rc[i].l,1);
fw.change(rc[i].r+1,-1);
}*/
int tail=1;
for(int i=1;i<=M;++i) {
while(tail<=N&&rc[tail].len()<i){
fw.change(rc[tail].l,1);
fw.change(rc[tail].r+1,-1);
++tail;
}
int ans=N-tail+1;
for(int j=0;j<=M;j+=i) {
ans+=fw.query(j);
}printf("%d\n",ans);
}
return 0;
} |
#include<iostream>
#include<algorithm>
using namespace std;
const int MAX=300005;
int tree[MAX],n,m;
pair<int,int> query[MAX];
int cmp(pair<int,int> a,pair<int,int> b)
{
return a.second-a.first<b.second-b.first;
}
void update(int r,int key)
{
for(;r<=m;r+=(r&(-r))){
tree[r]+=key;
}
}
int getBIT(int r)
{
int result=0;
while(r>0){
result+=tree[r];
r-=(r&(-r));
}
return result;
}
int main()
{
int a,b;
cin>>n>>m;
for(int i=1;i<=n;++i){
cin>>query[i].first>>query[i].second;
}
sort(query+1,query+n+1,cmp);
int idx=1;
for(int d=1;d<=m;++d){
for(;idx<=n&&d>query[idx].second-query[idx].first+1;++idx){
update(query[idx].first,1);
update(query[idx].second+1,-1);
}
int ans=n-idx+1;
for(int i=d;i<=m;i+=d){
ans+=getBIT(i);
}
cout<<ans<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=310000;
int n,m,tr[N],Ans[N];
struct suv
{
int l,r;
bool operator < (const suv& tp) const
{
return r-l<tp.r-tp.l;
}
}p[N];
void Add(int x,int s)
{
while(x<=m+1) tr[x]+=s, x+=(x&(-x));
}
int Query(int x)
{
int ret=0;
while(x) ret+=tr[x], x-=(x&(-x));
return ret;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i) scanf("%d%d",&p[i].l,&p[i].r), ++p[i].l, ++p[i].r;
sort(p+1,p+n+1);
for(int i=1;i<=n;++i) Add(p[i].l,1), Add(p[i].r+1,-1);
for(int d=m,cur=n;d>=1;--d)
{
while(p[cur].r-p[cur].l+1>=d && cur) Add(p[cur].l,-1), Add(p[cur--].r+1,1);
Ans[d]=n-cur;// cout<<Ans[d]<<endl;
for(int i=0;i*d<=m;++i)
Ans[d] += Query(i*d+1);
}
for(int i=1;i<=m;++i) printf("%d\n",Ans[i]);
return 0;
} |
#include <cstdio>
#include <vector>
#include <algorithm>
int n,m,c[100005];
std::vector<std::pair<int,int> > s[100005];
inline void Modify(int x,int v){for(;x<=m;x+=x&-x)c[x]+=v;}
inline int Query(int x,int s=0){for(;x;x^=x&-x)s+=c[x];return s;}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1,l,r;i<=n;++i)
{
scanf("%d%d",&l,&r);
s[r-l+1].push_back(std::make_pair(l,r));
}
for(int d=1;d<=m;++d)
{
for(auto i:s[d])Modify(i.first,1),Modify(i.second+1,-1),--n;
int Ans=n;
for(int i=d;i<=m;i+=d)Ans+=Query(i);
printf("%d\n",Ans);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
const int N=300005;
int n,m;
struct BIT{
int c[N];
inline int lowbit(int x){return x&(-x);};
inline void update(int x,int y){
for (;x<=m+2;x+=lowbit(x)) c[x]+=y;
}
inline int query(int x){
int ans=0;for (;x;x-=lowbit(x)) ans+=c[x];return ans;
}
}T;
struct Node{
int l,r;
}a[N];
inline bool cmp(Node a,Node b){
return a.r-a.l<b.r-b.l;
}
int main (){
scanf ("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf ("%d%d",&a[i].l,&a[i].r),a[i].l+=2,a[i].r+=2;
sort(a+1,a+n+1,cmp);
for (int d=1,now=1;d<=m;d++){
for (;now<=n;now++)
if (a[now].r-a[now].l+1<d)
T.update(a[now].l,1),T.update(a[now].r+1,-1);
else break;
int ans=n-now+1;
for (int i=0;i<=m;i+=d)
ans+=T.query(i+2);
printf ("%d\n",ans);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=3e5+10;
int n,m;
pair<int,int> p[N];
struct bit{
int a[N];
void add(int p,int d){
for (;p<=n;p+=p&-p) a[p]+=d;
}
int query(int p){
int ans=0;
for (;p;p-=p&-p) ans+=a[p];
return ans;
}
}T;
int main()
{
scanf("%d%d",&m,&n);
for (int i=1;i<=m;i++){
scanf("%d%d",&p[i].first,&p[i].second);
p[i].first=p[i].second-p[i].first;
}
sort(p+1,p+m+1);
for (int i=1,j=1;i<=n;i++){
for (;j<=m&&p[j].first<i;T.add(p[j].second+1,-1),T.add(p[j].second-p[j].first,1),j++);
int ans=m-j+1;
for (int k=i;k<=n;k+=i) ans+=T.query(k);
printf("%d\n",ans);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int N=100100;
int n,m,sm[N];
vector<pair<int,int> >vec[N];
void add(int x,int y){for(;x<=m;x+=x&-x)sm[x]+=y;}
int qry(int x){int ans=0;for(;x;x-=x&-x)ans+=sm[x];return ans;}
int main(){
ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
cin>>n>>m;
for(int i=1;i<=n;++i){
int x,y;cin>>x>>y;
vec[y-x+1].emplace_back(x,y);
}
for(int i=1;i<=m;++i){
for(auto j:vec[i]){--n;add(j.first,1);add(j.second+1,-1);}
int res=n;
for(int j=i;j<=m;j+=i)res+=qry(j);
cout<<res<<'\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn=1e5+5;
int sum[maxn];
int main()
{
int n,m;
scanf("%d%d",&n,&m);
memset(sum,0,sizeof(sum));
for(int i=1;i<=n;i++)
{
int l,r;
scanf("%d%d",&l,&r);l--;
for(int j=1,k;j<=l;j=k+1)
{
k=min(l/(l/j),r/(r/j));
if(l/j!=r/j)
{
sum[j]++;
sum[k+1]--;
}
}
sum[l+1]++;
sum[r+1]--;
}
for(int i=1;i<=m;i++)
{
sum[i]+=sum[i-1];
printf("%d\n",sum[i]);
}
return 0;
}
|
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <utility>
#define FR first
#define SE second
#define lowbit(x) (x&-x)
using namespace std;
int sumv[100005];
void add(int x,int num) {
for(;x;x-=lowbit(x)) sumv[x]+=num;
}
int sum(int x,int n) {
int s=0;
for(;x<=n;x+=lowbit(x)) s+=sumv[x];
return s;
}
typedef pair<int,int> pr;
pr a[300005];
bool cmp(pr x,pr y) {
return x.SE-x.FR>y.SE-y.FR;
}
int ans[100005];
int main() {
int n,m;
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) {
int x,y;
scanf("%d%d",&x,&y);
a[i]=pr(x,y);
add(y,1);
add(x-1,-1);
}
sort(a+1,a+n+1,cmp);
int l=1;
for(int i=m;i>0;i--) {
while (l<=n&&a[l].SE-a[l].FR>=i) {
add(a[l].SE,-1);
add(a[l].FR-1,1);
l++;
}
ans[i]=l-1;
for(int j=i;j<=m;j+=i) ans[i]+=sum(j,m);
}
for(int i=1;i<=m;i++) printf("%d\n",ans[i]);
return 0;
} |
#include <cstdio>
#include <algorithm>
using namespace std;
int n,m,f[100005],g[100005];
void zzk(int L,int R){
for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){
// k<=kk<=(l-1)/a
a=(L-1)/k;
if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;
kk=R/(a+1);
kk=min(kk,Max); kk=max(kk,Min);
f[k]++; f[kk+1]--;
k=Max+1;
}
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1,l,r; i<=n; i++){
scanf("%d%d",&l,&r);
zzk(l,r);
}
for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);
}
/*
3 3
1 2
2 3
3 3
*/ |
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
const int MAXN = 100005;
const int mod = 1e9 + 7;
int n, m, a[MAXN];
int b[MAXN];
int main(){
scanf("%d %d",&n,&m);
while(n--){
int l, r; scanf("%d %d",&l,&r);
l--;
for(int i=1; i<=505; i++){
if(r / i != l / i) a[i]++;
}
if(506 <= r){
b[506]++;
b[r+1]--;
for(int i=1; i<=200; i++){
// xi <= l < x(i+1)
// xi <= r < x(i+1)
int ed = l / i;
int st = (r + i + 1) / (i + 1);
st = max(st, 506);
if(st <= ed){
b[st]--;
b[ed+1]++;
}
}
}
}
for(int i=1; i<=m; i++) b[i] += b[i-1];
for(int i=1; i<=m; i++) printf("%d\n", a[i] + b[i]);
}
|
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
inline int rd(){
char c=getchar();int x=0,flag=1;
for(;c<'0'||c>'9';c=getchar())if(c=='-')flag=-1;
for(;c>='0'&&c<='9';c=getchar())x=x*10+c-'0';
return x*flag;
}
struct shop{
int l,r,len;
friend bool operator < (shop a,shop b){
return a.len>b.len;
}
}a[300010];
int n,m,st[100010]={0};
inline void add(int x,int v){
for(;x<=m;x+=x&-x)
st[x]+=v;
return;
}
inline int ask(int x){
int res=0;
for(;x;x-=x&-x)
res+=st[x];
return res;
}
int main(){
n=rd();m=rd();
for(int i=1;i<=n;i++){
int l=rd(),r=rd();
a[i]=(shop){l,r,r-l+1};
}
sort(a+1,a+n+1);
for(int i=1,j=n;i<=m;i++){
for(;j&&a[j].len<i;j--)
add(a[j].l,1),add(a[j].r+1,-1);
int ans=j;
for(int k=i;k<=m;k+=i)
ans+=ask(k);
printf("%d\n",ans);
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<algorithm>
using namespace std;
int n,m,c[101010];
struct evol{int l,r,len;}a[303030];
bool cmp(evol u,evol v){ return u.len<v.len;}
void add(int x,int d)
{
for(int i=x;i<=m;i+=(i&-i))
c[i]+=d;
}
int query(int x)
{
int res=0;
for(int i=x;i;i-=(i&-i))
res+=c[i];
return res;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d%d",&a[i].l,&a[i].r),a[i].len=a[i].r-a[i].l+1;
sort(a+1,a+n+1,cmp);
int p=1;
for(int i=1;i<=m;i++)
{
while(p<=n&&a[p].len<i)
{
add(a[p].l,1);
add(a[p].r+1,-1);
p++;
}
int sum=0;
for(int j=0;j<=m;j+=i)
sum+=query(j);
printf("%d\n",n-p+1+sum);
}
return 0;
} |
#include <bits/stdc++.h>
#define X first
#define Y second
#define mp make_pair
using namespace std;
typedef pair<int,int> PII;
const int N = 300010;
int n,m,c[N];
PII p[N];
bool cmp(PII a,PII b){
return a.Y-a.X<b.Y-b.X;
}
inline int sum(int x){
int ret = 0;
while(x){
ret+=c[x];
x-=x&-x;
}
return ret;
}
inline void add(int x,int t){
while(x<=m+1){
c[x]+=t;
x+=x&-x;
}
}
int main(){
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++){
scanf("%d%d",&p[i].X,&p[i].Y);
}
sort(p,p+n,cmp);
int j = 0;
//cout<<"----"; for(int i=0;i<n;i++) cout<<p[i].X<<' '<<p[i].Y<<endl;
for(int i=1;i<=m;i++){
while(j<n && p[j].Y-p[j].X+1<i){
add(p[j].X,1);
add(p[j].Y+1,-1);
j++;
}
int ans = n-j;
for(int k = i;k<=m;k+=i) ans += sum(k);
printf("%d\n",ans);
}
return 0;
} |
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
#define lowbit(x) (x&-x)
struct node { int l,r,len; }a[300010];
int c[100010],n,m;
inline int rd()
{
int x=0;char ch=getchar();
for (;ch<'0'||ch>'9';ch=getchar());
for (;ch>='0'&&ch<='9';ch=getchar()) x=x*10+ch-'0';
return x;
}
inline bool cmp(node x,node y) { return x.len<y.len; }
inline void add(int x,int y) { for (;x<=m;x+=lowbit(x)) c[x]+=y; }
inline int query(int x)
{
int res=0;
for (;x;x-=lowbit(x)) res+=c[x];
return res;
}
int main()
{
n=rd();m=rd();
for (int i=1;i<=n;i++)
{
a[i].l=rd();a[i].r=rd();
a[i].len=a[i].r-a[i].l+1;
}
sort(a+1,a+n+1,cmp);
int hh=1;
for (int i=1;i<=m;i++)
{
for (;a[hh].len<i&&hh<=n;hh++) add(a[hh].l,1),add(a[hh].r+1,-1);
int ans=n-hh+1;
for (int j=0;j<=m;j+=i) ans+=query(j);
printf("%d\n",ans);
}
return 0;
} |
#include<cstdio>
const int N=1e5+5,M=3e5+5;
int n,m,i,ans,he[N],f[N];
struct edge{int l,to;}e[M];
int read(){
char c=getchar();int k=0;for (;c<48||c>57;c=getchar());
for (;c>47&&c<58;c=getchar()) k=(k<<3)+(k<<1)+c-48;return k;
}
void write(int x){if (x>9) write(x/10);putchar(x%10+48);}
void add(int x,int k){for (;x<=n;x+=x&-x) f[x]+=k;}
int ask(int x){int k=0;for (;x;x-=x&-x) k+=f[x];return k;}
int main(){
for (m=read(),n=read(),i=1;i<=m;i++){
int l=read(),r=read();
e[i].l=he[r-l+1];he[r-l+1]=i;e[i].to=l;
}
for (int x=1;x<=n;x++){
for (ans=m,i=x;i<=n;i+=x) ans+=ask(i);
write(ans);putchar('\n');
for (i=he[x];i;i=e[i].l)
m--,add(e[i].to,1),add(e[i].to+x,-1);
}
} |
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
using namespace std;
int n,m,c[100050];
int main() {
scanf("%d%d",&n,&m);
int i,l,r;
while(n--) {
scanf("%d%d",&l,&r);l--;
int lim=l,lst=0;
for(i=1;i<=lim;i=lst+1) {
lst=min(l/(l/i),r/(r/i));
if(r/i-1>=l/i)c[i]++,c[lst+1]--;
}
c[lst+1]++,c[r+1]--;
}for(i=1;i<=m;i++)c[i]+=c[i-1],printf("%d\n",c[i]);
}
|
#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N=3e5+10;
struct point{int l,r;}a[N];
int n,m,tot,ans,c[N];
vector<int>vec[N];
int sum(int x){int ret=0;while(x)ret+=c[x],x-=x&-x;return ret;}
void add(int x,int y){while(x<=n)c[x]+=y,x+=x&-x;}
int main()
{
scanf("%d%d",&m,&n);
for(int i=1;i<=m;i++)
{
scanf("%d%d",&a[i].l,&a[i].r);
if(a[i].l)vec[a[i].r-a[i].l+1].push_back(i);
}
tot=m;
for(int i=1;i<=n;i++)
{
ans=0;
for(int j=1;j<=n/i;j++)ans+=sum(i*j);
printf("%d\n",tot+ans);
for(auto j:vec[i])add(a[j].l,1),add(a[j].r+1,-1),tot--;
}
} |
#include <cstdio>
#include <algorithm>
using namespace std;
int n,m,f[100005],g[100005];
void zzk(int L,int R){
for (int k=1,kk,kkk,a,Max,Min; k<=m && k<=R;){
// k<=kk<=(l-1)/a
a=(L-1)/k;
if (a==0) Max=99999999; else Max=(L-1)/a; Min=k-1;
kk=R/(a+1);
kk=min(kk,Max); kk=max(kk,Min);
f[k]++; f[kk+1]--;
k=Max+1;
}
}
int main(){
scanf("%d%d",&n,&m);
for (int i=1,l,r; i<=n; i++){
scanf("%d%d",&l,&r);
zzk(l,r);
}
for (int i=1; i<=m; i++) g[i]=g[i-1]+f[i],printf("%d\n",g[i]);
} |
#include<bits/stdc++.h>
using namespace std;
vector<pair<int,int> > v[100010];
int bit[100010],n,m;
void add(int x,int k){
while(x<=m+1){
bit[x]+=k;
x+=x&-x;
}
}
int sum(int x){
int s=0;
while(x){
s+=bit[x];
x-=x&-x;
}
return s;
}
int main(){
cin>>n>>m;
memset(bit,0,m+1);
for(int i=0;i<n;i++){
int a,b;cin>>a>>b;
v[b-a+1].push_back(make_pair(a,b));
}
for(int k=1;k<=m;k++){
for(int i=0;i<v[k-1].size();i++){
add(v[k-1][i].first,1);
add(v[k-1][i].second+1,-1);
n--;
}
int cnt=n;
for(int i=k;i<=m;i+=k){
cnt+=sum(i);
}
cout<<cnt<<endl;
}
return 0;
}
|
//#include<bits/stdc++.h>
#include<cstdio>
#include<algorithm>
#define rep(i,a,b) for(int i=(a),i##ed=(b);i<=i##ed;i++)
#define per(i,a,b) for(int i=(a),i##ed=(b);i>=i##ed;i--)
using namespace std;
const int N=300010;
int n,m,sum,pos,res;
int t[N];
struct P {
int x,y;
inline bool operator<(const P &yy)const { return y-x<yy.y-yy.x; }
};P a[N];
inline void add(int x,int w) { for(;x<=m;x+=x&-x) t[x]+=w; }
inline int ask(int x) { int s=0;for(;x;x-=x&-x) s+=t[x];return s; }
int main() {
scanf("%d%d",&n,&m),sum=n,pos=1;
rep(i,1,n) scanf("%d%d",&a[i].x,&a[i].y);
sort(a+1,a+n+1);
rep(i,1,m) {
for(;a[pos].y-a[pos].x+1<i&&pos<=n;)
add(a[pos].x,1),add(a[pos].y+1,-1),++pos,--sum;
res=0; rep(j,1,m/i) res+=ask(j*i);
printf("%d\n",res+sum);
}
return 0;
} |
#include <iostream>
#include <utility>
#include <algorithm>
#define MAX_N 100010
using namespace std;
int bit[MAX_N],m,l[3*MAX_N],r[3*MAX_N];
pair<int,int> p[3*MAX_N];
int sum(int i){
int s = 0;
while(i>0){
s += bit[i];
i -= i& -i;
}
return s;
}
void add(int i, int x){
while(i<=m){
bit[i] += x;
i += i&-i;
}
}
int main(){
int i,n,k,j = 0;
cin >> n >> m;
for(i=0;i<n;i++){
cin >> l[i] >> r[i];
p[i] = make_pair(r[i]-l[i]+1,i);
}
sort(p,p+n);
for(i=0;i<=m;i++){
bit[i] = 0;
}
for(i=1;i<=m;i++){
int ans = 0;
while(p[j].first<i && j<n){
add(l[p[j].second],1);
add(r[p[j].second]+1,-1);
j++;
}
ans += n-j;
for(k=0;k<=m;k += i){
ans += sum(k);
}
cout << ans << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int k = 300;
int n, m;
int cnt[100002];
void sub(int l, int r) {
int prev_pl = 1e9;
for (int i = 1; i <= k; ++i) {
int pl = (l + i - 1) / i;
int pr = (r + i - 1) / i;
pr = min(pr, prev_pl);
++cnt[pl];
--cnt[pr];
prev_pl = pl;
}
for (int j = 1; j < prev_pl; ++j) {
if ((l + j - 1) / j * j < r) {
++cnt[j];
--cnt[j + 1];
}
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i) {
int l, r;
cin >> l >> r;
++r;
sub(l, r);
}
partial_sum(cnt, cnt + m + 2, cnt);
for (int j = 1; j <= m; ++j) {
cout << cnt[j] << endl;
}
} |
#include <bits/stdc++.h>
#define ll long long
#define INF 999999999
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<int,int>P;
const int MAX_N = 125252;
vector<P> lens[125252];
int bit[MAX_N+1],n,m;
//i番目までの和を計算する
int sum(int i)
{
int s = 0;
while(i>0){
s += bit[i];
i -= i & -i;
}
return s;
}
//i番目の値にxを加える
void add(int i,int x)
{
while(i <= MAX_N){
bit[i] += x;
i += i & -i;
}
}
int main()
{
scanf("%d%d",&n,&m);
rep(i,n){
int l,r;
scanf("%d%d",&l,&r);
r++;
lens[r-l].push_back(P(l,r)); //rはr+1を指すようにする
}
printf("%d\n",n);
int rest = n;
for(int i=2;i<m+1;i++){ //iは間隔dのこと
rep(j,lens[i-1].size()){
add(lens[i-1][j].first,1);
add(lens[i-1][j].second,-1);
rest--;
}
int ans = rest; //間隔がm以上の区間
int it = i;
while(it<=m){
ans += sum(it);
it += i;
}
printf("%d\n",ans);
}
} |
#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstdlib>
#include<cstring>
#include<string>
#include<climits>
#include<vector>
#include<cmath>
#include<map>
#define LL long long
using namespace std;
LL n,m;
int main()
{
cin>>n>>m;
LL x,y,z;
vector<LL> a(m+10);
for(int i=0;i<n;i++)
{
cin>>x>>y;
z=y-x+1;a[0]+=1;a[z]-=1;
LL t=z+1,s;
while(t<=m)
{
LL v=((x+t-1)/t);
if(v <= 0) break;
s=y/v;
if(s >= t)
{
a[t-1] += 1;
a[s] -= 1;
}
if(v <= 1) break;
t = max(s+1, (x + (v-1)-1) / (v-1));
}
}
LL ans=0;
for (int i=0;i<m;i++)
ans+=a[i],cout<<ans<<endl;
return 0;
} |
#include<cctype>
#include<cstdio>
#include<cstring>
#include<algorithm>
#define LL long long
using namespace std;int n,m,li,ri,l,r;
LL s[100010];
inline LL read()
{
char c;LL d=1,f=0;
while(c=getchar(),!isdigit(c)) if(c=='-') d=-1;f=(f<<3)+(f<<1)+c-48;
while(c=getchar(),isdigit(c)) f=(f<<3)+(f<<1)+c-48;
return d*f;
}
signed main()
{
n=read();m=read();
for(register int i=1;i<=n;i++)
{
li=read();ri=read();
s[li]++;s[ri+1]--;
li--;
for(l=1;l<=li;l=r+1)
{
r=min(li/(li/l),ri/(ri/l));
if(li/l!=ri/l) s[l]++,s[r+1]--;
}
}
for(register int i=1;i<=m;i++)
{
s[i]+=s[i-1];
printf("%lld\n",s[i]);
}
} |
#include <bits/stdc++.h>
using namespace std;
const int N=300010;
int n,m,i,ql,qr,ans[N];
int read()
{
int d=0; char ch=getchar();
while (!isdigit(ch)) ch=getchar();
while (isdigit(ch)) d=(d<<3)+(d<<1)+ch-48,ch=getchar();
return d;
}
int main()
{
m=read(); n=read();
while (m--)
{
ql=read()-1; qr=read();
for (i=1;i<=ql;)
{
int d=qr/i,j=qr/d,k=ql/d;
ans[max(k+1,i)]++; ans[j+1]--;
i=j+1;
}
ans[i]++; ans[qr+1]--;
}
for (int i=1;i<=n;i++)
{
ans[i]+=ans[i-1];
printf("%d\n",ans[i]);
}
return 0;
} |
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int i,j,k,n,m,b[200001],l,r,lim,t,p1,p2;
int main(){
while (scanf("%d%d",&n,&m)!=EOF){
memset(b,0,sizeof(b));lim=trunc(sqrt(m));t=m/(lim+1);
for (i=1;i<=n;i++){
scanf("%d%d",&l,&r);
k=r-l+1;b[1]++;b[k+1]--;
for (j=k+1;j<=lim;j++)
if ((l/j!=r/j||l%j==0||r%j==0)&&r/j>t) b[j]++,b[j+1]--;
for (j=1;j<=t;j++){
p1=l/j;p2=r/j;
if (l%j) p1++;
p1=max(p1,k+1);
if (p1<=p2) b[p1]++,b[p2+1]--;
}
}
for (k=0,i=1;i<=m;i++) k+=b[i],printf("%d\n",k);
}
return 0;
} |
#include<bits/stdc++.h>
#define N (300009)
using namespace std;
int n,m,l,r,c[N];
vector<int>L[N];
void U(int x,int k) {for (;x<=m; c[x]+=k,x+=(x&-x));}
int Q(int x) {int s=0; for (;x; s+=c[x],x-=(x&-x)); return s;}
int main()
{
cin>>n>>m;
for (int i=1; i<=n; ++i)
cin>>l>>r, L[r-l+1].push_back(l);
for (int d=1; d<=m; ++d)
{
int ans=n;
for (int i=d; i<=m; i+=d) ans+=Q(i);
for (int i=0,sz=L[d].size(); i<sz; ++i)
U(L[d][i],1), U(L[d][i]+d,-1), --n;
printf("%d\n",ans);
}
}
|
#include <cstdio>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <vector>
using namespace std;
const int maxn = 3e5 + 5;
int n, m;
int l[maxn], r[maxn];
int c[maxn];
void add(int x, int d){
for(int i = x;i < maxn;i += i & -i){
c[i] += d;
}
}
int Sum(int x){
int res = 0;
for(int i = x;i > 0;i -= i & -i){
res += c[i];
}
return res;
}
vector<int> G[maxn];
int main(){
cin >> n >> m;
for(int i = 1;i <= n;i++){
scanf("%d%d", &l[i], &r[i]);
r[i]++;
G[r[i] - l[i]].push_back(i);
}
int sum = n;
for(int i = 1;i <= m;i++){
for(auto it : G[i]){
add(l[it], 1);
add(r[it], -1);
}
sum -= G[i].size();
int ans = sum;
for(int j = i;j <= m;j += i){
ans += Sum(j);
}
printf("%d\n", ans);
}
return 0;
}
|
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int n,m;
struct node{int l,r;}a[300010];
bool cmp(node x,node y){return x.r-x.l<y.r-y.l;}
int tree[100010];
void add(int id,int x){for(;id<=m;id+=id&-id) tree[id]+=x;}
int query(int id){int re=0;for(;id;id-=id&-id) re+=tree[id];return re;}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%d%d",&a[i].l,&a[i].r);
sort(a+1,a+n+1,cmp);
for (int i=1,j=1;i<=m;i++)
{
int cnt=0;
for (int t=i;t<=m;t+=i) cnt+=query(t);
printf("%d\n",cnt+n-j+1);
while (j<=n&&a[j].r-a[j].l<=i)
{
add(a[j].l,1);
add(a[j].r+1,-1);
j++;
}
}
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
inline int read()
{
int x;char c;
while((c=getchar())<'0'||c>'9');
for(x=c-'0';(c=getchar())>='0'&&c<='9';)x=x*10+c-'0';
return x;
}
#define MM 100000
#define MX 1600000
#define N 131072
struct work{int t,l,r;}w[MX+5];
bool cmp(const work&a,const work&b){return a.r!=b.r?a.r<b.r:a.t>b.t;}
int ans[MM+5],wn,t[N*2+5];
void inc(int k){for(k+=N;k;k>>=1)++t[k];}
int query(int l,int r)
{
int res=0;
for(l+=N-1,r+=N+1;l^r^1;l>>=1,r>>=1)
{
if(~l&1)res+=t[l+1];
if( r&1)res+=t[r-1];
}
return res;
}
int main()
{
int n,m,i,j;
n=read();m=read();
for(i=1;i<=n;++i)w[++wn].l=read(),w[wn].r=read();
for(i=1;i<=m;++i)for(j=0;j<m;j+=i)w[++wn]=(work){1,i,j+i};
sort(w+1,w+wn+1,cmp);
for(i=1;i<=wn;++i)
if(w[i].t)ans[w[i].l]+=query(w[i].r-w[i].l+1,MM);
else inc(w[i].l);
for(i=1;i<=m;++i)printf("%d\n",n-ans[i]);
} |
#include <bits/stdc++.h>
using namespace std;
int n,m,s[500005],l[500005],r[500005],ans;vector<int>v[500005];
void add(int x,int v){for(;x<=m;x+=x&-x) s[x]+=v;}
int que(int x){int r=0;for(;x;x-=x&-x) r+=s[x];return r;}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) scanf("%d%d",&l[i],&r[i]),v[r[i]-l[i]+1].push_back(i);
for(int i=1;i<=m;i++,ans=0)
{
for(int j=0;j<v[i].size();j++) add(l[v[i][j]],1),add(r[v[i][j]]+1,-1);
for(int j=i;j<=m;j+=i) ans+=que(j);
n-=v[i].size();printf("%d\n",ans+n);
}
} |
#include <vector>
#include <algorithm>
#include <iostream>
using namespace std;
struct query {
int l, r, t;
};
int main() {
int n, m; cin >> n >> m;
vector<query> v;
for (int i = 0; i < n; i++) {
int l, r; cin >> l >> r;
v.push_back({l, r, 0});
}
for (int d = 2; d <= m; d++)
for (int k = 0; k * d < m; k++)
v.push_back({k * d + 1, (k + 1) * d - 1, d});
sort(v.begin(), v.end(), [](query lhs, query rhs) {
return (lhs.r < rhs.r) || (lhs.r == rhs.r && lhs.t < rhs.t);
});
int ans[m+1], bit[m+1];
fill(bit, bit+m+1, 0);
fill(ans, ans+m+1, n);
for (query q : v) {
if (q.t == 0)
for (int x = q.l; x > 0; x -= x&-x) bit[x]++;
else {
for (int x = q.l; x <= m; x += x&-x) ans[q.t] -= bit[x];
}
}
for (int i = 1; i <= m; i++) cout << ans[i] << endl;
}
|
#include <bits/stdc++.h>
#define st first
#define nd second
#define mp make_pair
#define pb push_back
#define mod 1000000007
#define N 1000005
using namespace std;
typedef long long ll;
int n, m, kac, bas[N], son[N], fen[N];
vector < int > g[N];
void up(int x, int y){
for(; x < N; x += x&-x)
fen[x] += y;
}
int qu(int x){
int ans = 0;
for(; x > 0; x -= x&-x)
ans += fen[x];
return ans;
}
int main() {
// freopen("in.txt", "r", stdin);
// freopen("out.txt", "w", stdout);
scanf("%d %d",&n ,&m);
for(int i = 1; i <= n; i++){
scanf("%d %d",bas + i, son + i);
g[son[i] - bas[i] + 1].pb(i);
}
kac = n;
for(int i = 1; i <= m; i++){
int ans = kac;
for(int j = i; j <= m; j += i)
ans += qu(j);
printf("%d\n", ans);
for(int j = 0; j < g[i].size(); j++){
int k = g[i][j];
up(bas[k], 1);
up(son[k] + 1, -1);
kac--;
}
}
return 0;
} |
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<cmath>
using namespace std;
int n,m;
struct node{int l,r;
}a[300010];
bool cmp(node x,node y){return x.r-x.l<y.r-y.l;}
int tree[100010];
void add(int id,int x){for(;id<=m;id+=id&-id) tree[id]+=x;}
int query(int id){int re=0;for(;id;id-=id&-id) re+=tree[id];return re;}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++) scanf("%d%d",&a[i].l,&a[i].r);
sort(a+1,a+n+1,cmp);
for (int i=1,j=0;i<=m;i++)
{
int cnt=0;
for (int t=i;t<=m;t+=i) cnt+=query(t);
printf("%d\n",cnt+n-j);
while (j<n&&a[j+1].r-a[j+1].l<=i)
{
add(a[j+1].l,1);
add(a[j+1].r+1,-1);
j++;
}
}
} |
#include <stdio.h>
#include <string.h>
#include <iostream>
#include<string>
#include<algorithm>
#include<vector>
#include<unordered_map>
#include<unordered_set>
#define P pair<int,int>
using namespace std;
int BIT[100005];
void add(int a) {
while (a < 100005) {
BIT[a]++;
a += a&-a;
}
}
void take(int a) {
while (a < 100005) {
BIT[a]--;
a += a&-a;
}
}
int sum(int a) {
int b = 0;
while (a > 0) {
b += BIT[a];
a -= a&-a;
}
return b;
}
P c[300000];
signed main() {
int a, b; cin >> a >> b;
for (int d = 0; d < a; d++) {
int e, f; scanf("%d%d", &e, &f);
c[d] = { f - e,e };
}
sort(c, c + a);
int ans = a;
int K = 0;
for (int i = 1; i <= b; i++) {
while (K<a&&c[K].first + 1 < i) {
ans--;
add(c[K].second); take(c[K].second + c[K].first + 1);
K++;
}
int N = 0;
for (int j = i; j <= b; j += i) {
N += sum(j);
}
printf("%d\n", ans + N);
}
} |
#include <bits/stdc++.h>
const int N=400005;
using namespace std;
typedef pair<int,int> pii;
int n,m,dp[N],cur;
vector<pii>g[N];
void add(int pos,int val){
while(pos<N){
dp[pos]+=val;
pos+=pos&(-pos);
}
}
int get(int pos){
int ans=0;
while(pos){
ans+=dp[pos];
pos-=pos&(-pos);
}
return ans;
}
int main()
{ios_base::sync_with_stdio(0);cout.tie(0);cin.tie(0);
cin>>n>>m;
cur=n;
for(int i=1;i<=n;i++){
int l,r;cin>>l>>r;
g[r-l+1].push_back({l,r});
}
for(int i=1;i<=m;i++){
int v=cur;
for(int j=0;j<N;j+=i)v+=get(j);
cout<<v<<'\n';
for(auto el:g[i]){
cur--;
add(el.first,1);
add(el.second+1,-1);
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define INF 999999999
#define MOD 1000000007
#define rep(i,n) for(int i=0;i<n;i++)
using namespace std;
typedef pair<int,int>P;
const int MAX_N = 100005;
const int N = 1<<17;
int bit[MAX_N+1];
vector<P> len[MAX_N];
//i番目までの和を計算する
int sum(int i)
{
int s = 0;
while(i>0){
s += bit[i];
i -= i & -i;
}
return s;
}
//i番目の値にxを加える
void add(int i,int x)
{
while(i <= MAX_N){
bit[i] += x;
i += i & -i;
}
}
int main()
{
int n,m,l,r,ans;
cin >> n >> m;
rep(i,n){
scanf("%d%d",&l,&r);
len[r-l].push_back(P(l-1,r-1));
}
cout << n << "\n";
int res = n;
for(int i=1;i<m;i++){
ans=0;
rep(j,len[i-1].size()){
add(len[i-1][j].first+1,1);
add(len[i-1][j].second+2,-1);
res--;
}
ans += res;
for(int in=i+1;in<=m;in+=(i+1)){
ans += sum(in);
}
cout << ans << "\n";
}
} |
#include <bits/stdc++.h>
#define mod 1000000007
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define nyan "(=^･ω･^=)"
#define mkp make_pair
typedef long long ll;
using namespace std;
int N, M, l, r, res[100002];
int main() {
cin >> N >> M;
for (int i = 0; i != N; ++i) {
cin >> l >> r;
int p;
for (p = 1; p <= 400; ++p) {
if ((l - 1) / p != r / p) {
++res[p];
--res[p + 1];
}
}
--p;
for (int j = 300; j; --j) {
++res[max((l - 1) / j, p) + 1];
p = max(r / j, p);
--res[p + 1];
}
}
for (int i = 1; i <= M; ++i) {
res[i] += res[i - 1];
cout << res[i] << endl;
}
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int c[200010],n,m;
vector<int> vec[200010];
void add(int s,int w){while (s<=m) {c[s]+=w;s+=s&(-s);}}
int sum(int s){int ans=0;while (s) {ans+=c[s];s-=s&(-s);}return ans;}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
{
int l,r;scanf("%d%d",&l,&r);
vec[r-l+1].push_back(l);
}
int now=n;
for (int i=1;i<=m;i++)
{
now-=vec[i-1].size();int ans=now;
for (int k=0;k<vec[i-1].size();k++)
{
add(vec[i-1][k],1);
add(vec[i-1][k]+i-1,-1);
}
for (int j=i;j<=m;j+=i) ans+=sum(j);
printf("%d\n",ans);
}
} |
#include<stdio.h>
int d[100010];
inline int up(int x,int y){return x%y==0?x/y:x/y+1;}
inline int max(int a,int b){return a>b?a:b;}
int main(){
int n,m,l,r,i,nex;
scanf("%d%d",&n,&m);
while(n--){
scanf("%d%d",&l,&r);
d[1]++;
d[r-l+2]--;
for(i=r-l+2;i<=r;i=nex+1){
nex=r/(r/i);
d[max(up(l,r/i),r-l+2)]++;
d[nex+1]--;
}
}
for(i=1;i<=m;i++)d[i]+=d[i-1];
for(i=1;i<=m;i++)printf("%d\n",d[i]);
} |
#include <bits/stdc++.h>
#define L(x) ((x) & -(x))
const int N = 100005;
std::vector<int> e[100005];
int n, m, s[N], a;
void U(int x, int u) {
while (x <= n)
s[x] += u, x += L(x);
}
int Q(int x) {
int r = 0;
while (x)
r += s[x], x -= L(x);
return r;
}
int main() {
scanf("%d%d", &m, &n);
for (int i = 1, l, r; i <= m; i++)
scanf("%d%d", &l, &r), e[r - l + 1].push_back(l);
for (int d = 1; d <= n; d++) {
a = m;
for (int i = d; i <= n; i += d)
a += Q(i);
for (int u : e[d])
U(u, 1), U(u + d, -1), m--;
printf("%d\n", a);
}
return 0;
} |
#include<iostream>
using namespace std;
int l[1000001],r[1000001],sum[1000001];
int main()
{
int n,m,last;
cin>>n>>m;
for (int i=1;i<=n;++i)
{
cin>>l[i]>>r[i];
l[i]--;
for (int j=1;j<=l[i];j=last+1)
{
last=min(l[i]/(l[i]/j),r[i]/(r[i]/j));
if (l[i]/j<r[i]/j)
{
sum[j]++;
sum[last+1]--;
}
}
sum[l[i]+1]++;
sum[r[i]+1]--;
}
for (int i=1;i<=m;++i)
{
sum[i]+=sum[i-1];
cout<<sum[i]<<endl;
}
return 0;
} |
#include <bits/stdc++.h>
typedef long long LL;
using namespace std;
int N,M;
struct Event
{
int len,L,R;
};
vector<Event>E;
Event Make(int len,int L,int R)
{
return (Event){len,L,R};
}
int Tr[300010];
int lowbit(int x){return x&-x;}
int getsum(int x){int S=0;while(x){S+=Tr[x];x-=lowbit(x);}return S;}
void add(int x,int y){while(x<=M){Tr[x]+=y;x+=lowbit(x);}}
bool cmp(Event A,Event B)
{
return A.len<B.len;
}
int main()
{
scanf("%d%d",&N,&M);
for (int i=1;i<=N;i++)
{
int LL,RR;
scanf("%d%d",&LL,&RR);
E.push_back(Make(RR-LL+1,LL,RR));
}
sort(E.begin(),E.end(),cmp);
int now = 0;
int cnt = N;
for (int i=1;i<=M;i++)
{
while(now<E.size() && E[now].len<i)
{
Event tmp = E[now];
add(tmp.L,1);
add(tmp.R+1,-1);
now++;
cnt--;
}
int ans = cnt;
for (int j=i;j<=M;j+=i) ans+=getsum(j);
printf("%d\n",ans);
}
} |
#include <cstdio>
#include <algorithm>
#define lowbit(x) (x&(-x))
using std::sort;
const int maxn = 300010;
int n, m, c[maxn];
struct node {
int l, r, len;
bool operator < (const node &a) const {
return len < a.len;
}
}a[maxn];
void add(int i, int x) {
while(i <= m) c[i] += x, i += lowbit(i);
}
int ask(int i) {
int ret = 0;
while(i > 0) ret += c[i], i -= lowbit(i);
return ret;
}
int main() {
scanf("%d %d", &n, &m);
for(int i = 1;i <= n;i ++) {
scanf("%d %d", &a[i].l, &a[i].r);
a[i].r ++, a[i].len = a[i].r - a[i].l;
}
sort(a + 1, a + n + 1);
for(int i = 1, j = 1, ans;i <= m;i ++) {
while(j <= n && a[j].len < i) {
add(a[j].l, 1);
add(a[j].r, -1);
j ++;
}
ans = n - j + 1;
for(int k = i;k <= m;k += i)
ans += ask(k);
printf("%d\n", ans);
}
} |
#include <cstdio>
#include <vector>
using namespace std;
#define iter(i, n) for (int i = 1; i <= n; ++i)
#define NR 201000
int t[NR], n, m, ans[NR];
vector<int> fac[NR], s[NR];
void inc(int x) { for (++x; x; x -= x & -x) ++t[x]; }
int sum(int x) { int s = 0; for (++x; x <= n + 10; x += x & -x) s += t[x]; return s; }
int main() {
scanf("%d%d", &m, &n);
iter(i, m) {
int l, r;
scanf("%d%d", &l, &r);
s[r + 1].push_back(l - 1);
//if (0<=l-1&&r+1<=9) printf("[%d %d]\n", l-1, r+1);
}
iter(i, 2 * n) for (int j = i; j <= 2 * n; j += i) fac[j].push_back(i);
iter(i, 2 * n) {
for (int l : s[i]) inc(l);
for (int d : fac[i]) {
ans[d] -= sum(i - d);
//if (d == n - 1) printf("[%d %d %d]\n", i-d, i, sum(i-d));
}
}
iter(i, n) printf("%d\n", ans[i] + m);
return 0;
}
|
#include<cstdio>
#include<vector>
const int N=3e5+5;
int n,m,L[N],R[N],B[N],c[N],s;
std::vector<int>X[N],Y[N];
inline void add(int i,int x){for(;i<=m;i+=i&-i)B[i]+=x;}
inline int ask(int i){int x=0;for(;i;i&=i-1)x+=B[i];return x;}
int main(){
scanf("%d%d",&n,&m);
for(int i=1;i<=n;++i){
scanf("%d%d",L+i,R+i);
int l=R[i]-L[i]+1;
++c[l],X[l].push_back(L[i]),Y[l].push_back(R[i]+1);
}
for(int i=m;i;--i)c[i]+=c[i+1];
for(int i=1;i<=m;++i){
s=c[i];
for(int j=i;j<=m;j+=i)s+=ask(j);
printf("%d\n",s);
for(int x:X[i])add(x,1);
for(int x:Y[i])add(x,-1);
}
return 0;
} |
#include <iostream>
using namespace std;
int ans[500005],cf[500005],l[500005],r[500005];
const int bl=550;
int main(int argc, char** argv) {
int n,m,t;
ios::sync_with_stdio(false);
cin >> n >> m;
t=m/bl;
for(int i=1;i<=n;i++)
cin >> l[i] >> r[i];
for(int i=1;i<=n;i++)
{
int lst=t;
for(int j=bl;j>=1;j--)
{
int L=(l[i]-1)/j+1,R=r[i]/j;
L=max(L,lst+1);
if(R<L) continue;
++cf[L],--cf[R+1];
lst=max(lst,R);
}
}
for(int i=1;i<=t;i++)
{
int ans=0;
for(int j=1;j<=n;j++)
ans+=(l[j]-1)/i!=r[j]/i;
cout << ans << "\n";
}
for(int i=t+1;i<=m;i++)
{
cf[i]+=cf[i-1];
cout << cf[i] << "\n";
}
return 0;
}
//dlstxdy |
#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
#include<cmath>
using namespace std;
int n,m,tree[300005];
struct node{int l,r,len;}q[300005];
bool cmp(node t1,node t2){return t1.len<t2.len;}
int lowbit(int x){return x&-x;}
void add(int x,int y){for (int i=x;i<=m;i+=lowbit(i))tree[i]+=y;}
int query(int x){int s=0;for (int i=x;i>0;i-=lowbit(i))s+=tree[i];return s;}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
scanf("%d%d",&q[i].l,&q[i].r),q[i].len=q[i].r-q[i].l+1;
sort(q+1,q+n+1,cmp);
for (int i=1,k=1;i<=m;i++)
{
for (;(k<=n && q[k].len<i);k++)
add(q[k].l,1),add(q[k].r+1,-1);
int ans=n-k+1;
for (int j=i;j<=m;j+=i) ans+=query(j);
printf("%d\n",ans);
}
return 0;
} |
#include<bits/stdc++.h>
#define N 600005
using namespace std;
int n,m,b[N];
struct T
{
int x,y,l;
}a[N];
bool cmp(T x,T y)
{
return x.l<y.l;
}
void mdy(int k,int l,int r,int x,int y)
{
if (x<=l&&r<=y)
{
b[k]++;
return;
}
int mid=l+r>>1;
if (x<=mid) mdy(k<<1,l,mid,x,y);
if (y>mid) mdy(k<<1|1,mid+1,r,x,y);
}
int qry(int k,int l,int r,int x)
{
if (l==r) return b[k];
int mid=l+r>>1;
if (x<=mid) return b[k]+qry(k<<1,l,mid,x);
return b[k]+qry(k<<1|1,mid+1,r,x);
}
int main()
{
scanf("%d%d",&n,&m);
for (int i=1;i<=n;i++)
{
scanf("%d%d",&a[i].x,&a[i].y);
a[i].l=a[i].y-a[i].x+1;
}
sort(a+1,a+n+1,cmp);
for (int i=1,j=1;i<=m;i++)
{
while(j<=n&&a[j].l<i)
{
mdy(1,1,m,a[j].x,a[j].y);
j++;
}
int Ans=n-j+1;
for (int j=1;i*j<=m;j++)
Ans+=qry(1,1,m,j*i);
printf("%d\n",Ans);
}
} |
#include<bits/stdc++.h>
#define N 300005
using namespace std;
int n,m,x,y,pre;
int fen[N];
vector<int> v[N];
void up(int node,int val) {
node++;
while(node-1<=m) {
fen[node]+=val;
node+=node&-node;
}
}
int get(int node) {
int ret=0;
node++;
while(node>=1) {
ret+=fen[node];
node-=node&-node;
}
return ret;
}
int main() {
scanf("%d %d",&n,&m);
for(int i=1;i<=n;i++) {
scanf("%d %d",&x,&y);
v[y-x+1].push_back(x);
}
for(int i=1;i<=m;i++) {
int ans=0;
for(int j=0;j<=m;j+=i) {
ans+=get(j);
}
printf("%d\n",n-pre+ans);
for(int j=0;j<v[i].size();j++) {
up(v[i][j],1);
up(v[i][j]+i,-1);
}
pre+=v[i].size();
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N=300005;
int n,m;
struct Seg{
int l,r,len;
void readin(){
scanf("%d%d",&l,&r);
len=r-l+1;
}
}a[N];
bool cmp(Seg x,Seg y){return x.len<y.len;}
struct Tree{
int c[N];
void updata(int x,int v){
for(;x<=m;x+=x&(-x)) c[x]+=v;
}
int query(int x){
int ret=0;
for(;x>0;x-=x&(-x)) ret+=c[x];
return ret;
}
}T;
void work()
{
int k=1;
for(int i=1,k=1;i<=m;i++)
{
for(;k<=n&&a[k].len<i;k++) T.updata(a[k].l,1),T.updata(a[k].r+1,-1);
int ans=n-k+1;
for(int j=i;j<=m;j+=i) ans+=T.query(j);
printf("%d\n",ans);
}
}
void init()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++) a[i].readin();
sort(a+1,a+1+n,cmp);
}
int main()
{
init();
work();
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
const int maxn=3e5+10;
int n,m,Ans[maxn],vis[maxn];
int main()
{
#ifdef h10
freopen("E.in","r",stdin);
freopen("E.out","w",stdout);
#endif
int i,j,l,r,x;
scanf("%d%d",&n,&m);
for (i=1;i<=n;i++)
{
scanf("%d%d",&l,&r);
if (!l) {Ans[1]++; continue;}
int last=m+1;
for (x=1;x*x<=r;x++)
{
int u=(l+x-1)/x,v=r/x;
if (u<=v)
{
if (v<last) Ans[u]++,Ans[v+1]--;
else Ans[u]++,Ans[last]--;
last=u;
for (j=u;j<=v&&j*j<=r&&vis[j]!=i;j++) vis[j]=i;
}
}
for (x=1;x*x<=r;x++)
{
int u=(l+x-1)/x,v=r/x;
if (u<=v&&vis[x]!=i)
vis[x]=i,Ans[x]++,Ans[x+1]--;
}
}
for (i=1;i<=m;i++)
Ans[i]+=Ans[i-1],printf("%d\n",Ans[i]);
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=300005,M=100005;
int n,m,cnt[M*4];
struct node
{
int l,r;
}a[N];
bool operator<(const node&a,const node&b){return a.r-a.l<b.r-b.l;}
void insert(int u,int l,int r,int ql,int qr)
{
if(l>=ql&&r<=qr){cnt[u]++;return;}
int mid=l+r>>1;
if(ql<=mid)insert(u<<1,l,mid,ql,qr);
if(qr>mid)insert(u<<1|1,mid+1,r,ql,qr);
}
int query(int p)
{
int ans=0,u=1,l=1,r=m;
for(;;)
{
ans+=cnt[u];
if(l==r)break;
int mid=l+r>>1;
if(p<=mid)u=u<<1,r=mid;
else u=u<<1|1,l=mid+1;
}
return ans;
}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)scanf("%d%d",&a[i].l,&a[i].r);
sort(a+1,a+1+n);
for(int i=1,j=1;i<=m;i++)
{
while(j<=n&&a[j].r-a[j].l<i)insert(1,1,m,a[j].l,a[j].r),j++;
int ans=0;
for(int k=i;k<=m;k+=i)ans+=query(k);
printf("%d\n",ans+n-j+1);
}
return 0;
}
|
#include<bits/stdc++.h>
#define LL long long
#define PLL pair<LL,LL>
using namespace std;
int N,M;
int bit[100010] = {0}, ans[100010] = {0};
vector<pair<LL, PLL>> r;
void update(int hi, int add){
while(hi <= M) bit[hi] += add, hi += hi & -hi;
}
int query(int x){
int ret = 0;
while(x) ret += bit[x], x -= x & -x;
return ret;
}
int main(){
cin >> N >> M;
for(int i=0,li,ri; i<N;i++) cin >> li >> ri, r.push_back({ri-li+1, {li,ri}});
sort(r.begin(), r.end());
for(int d=1,i=0; d<=M; d++){
for(i; r[i].first < d && i<N; i++){
update(r[i].second.first, 1);
update(r[i].second.second+1, -1);
}
ans[d-1] += N-i;
for(int j=d; j<=M; j+=d){
ans[d-1] += query(j);
}
}
for(int i=0; i<M; i++) cout << ans[i] << endl;
return 0;
}
|
#include<bits/stdc++.h>
#define rep(i,j,k) for(int i=(int)j;i<=(int)k;i++)
#define per(i,j,k) for(int i=(int)j;i>=(int)k;i--)
#define pii pair<int,int>
#define fi first
#define se second
#define pb push_back
using namespace std;
typedef long long LL;
const int N=310000;
vector<int>dj[N];
int ans[N];
int l[N],r[N],n,m;
vector<int>lk[N];
int cnt[N];
inline void add(int x){
for(;x<=m;x+=(x&(-x)))cnt[x]++;
}
inline int ask(int x){
int ans=0;
for(;x;x-=(x&(-x)))ans+=cnt[x];
return ans;
}
int main(){
scanf("%d%d",&n,&m);
rep(i,1,n)scanf("%d%d",&l[i],&r[i]);
rep(d,1,m){
for(int i=d;i<=m;i+=d)dj[i].push_back(d);
}
rep(i,1,n)lk[r[i]].push_back(l[i]);
per(i,m,1){
rep(j,0,lk[i].size()-1){
add(lk[i][j]);
}
rep(j,0,dj[i].size()-1){
ans[dj[i][j]]+=ask(i);
ans[dj[i][j]]-=ask(max(i-dj[i][j],0));
}
}
rep(i,1,m)printf("%d\n",ans[i]);
return 0;
}
|
#include<bits/stdc++.h>
using namespace std;
int n,m,cc,bit[100005];
vector<int>g[100005];
void add(int p,int x){while(p<=m)bit[p]+=x,p+=(p&(-p));}
int sum(int p){int res=0;while(p)res+=bit[p],p-=(p&(-p));return res;}
int main()
{
scanf("%d%d",&n,&m);
for(int i=0;i<n;i++)
{
int l,r;
scanf("%d%d",&l,&r);
g[r-l+1].push_back(l);
}
int ans=n;
for(int i=1;i<=m;i++)
{
int res=0;
for(int j=0;j<g[i].size();j++)
{
add(g[i][j],1);
add(g[i][j]+i,-1);
ans--;
}
for(int j=i;j<=m;j+=i)res+=sum(j);
printf("%d\n",ans+res);
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
#define mx 100005
int n, m, l, r, a[mx], b[mx];
int main(){
scanf("%d%d", &n, &m);
for(int i = 0; i < n; i++){
scanf("%d%d", &l, &r); l--;
int rr = m+1;
for(int j = 1; j*j <= r && j < rr; j++){
if(l/j < r/j){
a[j]++;
a[j+1]--;
}
a[min(r/j+1, rr)]--;
a[rr = max(j+1, l/j+1)]++;
}
}
for(int i = 1; i <= m; i++) printf("%d\n", a[i] += a[i-1]);
} |
#include <bits/stdc++.h>
#define rep(i,n) for(int i=0;i<(n);i++)
using namespace std;
template<class G>
class Fenwick_tree_dual{
vector<G> a;
public:
Fenwick_tree_dual(int n):a(n){}
void add(int l,int r,G val){
if(l==0){
for(r--;r>=0;r=(r&(r+1))-1) a[r]+=val;
return;
}
add(0,r,val);
add(0,l,-val);
}
G sum(int i){
G res{};
for(;i<a.size();i|=i+1) res+=a[i];
return res;
}
};
struct interval{
int l,r;
bool operator<(const interval& I)const{ return r-l<I.r-I.l; }
};
int main(){
int n,m; scanf("%d%d",&n,&m);
vector<interval> I(n);
rep(i,n) scanf("%d%d",&I[i].l,&I[i].r), I[i].r++;
sort(I.begin(),I.end());
int idx=0;
Fenwick_tree_dual<int> F(m+1);
for(int d=1;d<=m;d++){
while(idx<n && I[idx].r-I[idx].l<=d){
F.add(I[idx].l,I[idx].r,1);
idx++;
}
int ans=n-idx;
for(int x=d;x<=m;x+=d) ans+=F.sum(x);
printf("%d\n",ans);
}
return 0;
}
|
#include<cstdio>
#include<algorithm>
using namespace std;
const int N=300300,M=100100;
int i,j,k,n,m,ch;
int T[M];
struct cc {
int l,r;
bool operator < (const cc &n) const {
return r-l<n.r-n.l;
}
} A[N];
void R(int &x) {
x=0;ch=getchar();
while (ch<'0' || '9'<ch) ch=getchar();
while ('0'<=ch && ch<='9') x=x*10+ch-'0',ch=getchar();
}
void W(int x) {
if (x>=10) W(x/10);
putchar(x%10+'0');
}
void T_add(int x,int y) {
for (;x<=m;x+=x&-x) T[x]+=y;
}
int T_query(int x) {
int y=0;
for (;x;x-=x&-x) y+=T[x];
return y;
}
int main() {
R(n);R(m);
for (i=1;i<=n;i++) R(A[i].l),R(A[i].r);
sort(A+1,A+n+1);
j=1;
for (i=1;i<=m;i++) {
while (j<=n && A[j].r-A[j].l+1<i) T_add(A[j].l,1),T_add(A[j].r+1,-1),j++;
int ans=n-j+1;
for (k=i;k<=m;k+=i) ans+=T_query(k);
W(ans);puts("");
}
} |
#include<cstdio>
#include<algorithm>
#define rep(i,a,b) for(int i=(a),i##ed=(b);i<=i##ed;i++)
#define per(i,a,b) for(int i=(a),i##ed=(b);i>=i##ed;i--)
using namespace std;
const int N=300010;
int n,m,sum,pos,res;
int t[N];
struct P {
int x,y;
inline bool operator<(const P &yy)const { return y-x<yy.y-yy.x; }
};P a[N];
inline void add(int x,int w) { for(;x<=m;x+=x&-x) t[x]+=w; }
inline int ask(int x) { int s=0;for(;x;x-=x&-x) s+=t[x];return s; }
int main() {
scanf("%d%d",&n,&m),sum=n,pos=1;
rep(i,1,n) scanf("%d%d",&a[i].x,&a[i].y);
sort(a+1,a+n+1);
rep(i,1,m) {
for(;a[pos].y-a[pos].x+1<i&&pos<=n;)
add(a[pos].x,1),add(a[pos].y+1,-1),++pos,--sum;
res=0; rep(j,1,m/i) res+=ask(j*i);
printf("%d\n",res+sum);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
#define ll int64_t
const int N=3e5+5;
const int M=1e5+5;
int n,m,bit[M];
void upd(int x,int val){
for(;x<M;x=x|(x+1))
bit[x]+=val;
}
int get(int x){
int cnt=0;
for(;x>=0;x=(x&(x+1))-1)
cnt+=bit[x];
return cnt;
}
int main() {
ios_base::sync_with_stdio(0);cin.tie(0);
cin>>n>>m;
vector<tuple<int,int,int>> seg;
for(int i=0;i<n;++i){
int l,r;
cin>>l>>r;
seg.emplace_back(r-l+1,l,r);
}
sort(seg.begin(),seg.end());
reverse(seg.begin(),seg.end());
for(int i=1;i<=m;++i){
while(!seg.empty()&&get<0>(seg.back())<i){
int len,l,r;
tie(len,l,r)=seg.back();
seg.pop_back();
upd(l,1);
upd(r+1,-1);
}
int res=int(seg.size());
for(int j=0;j<=m;j+=i)
res+=get(j);
cout<<res<<'\n';
}
}
|
#include<iostream>
#include<cstdio>
using namespace std;
int n,m;
int s[1<<17],a;
int main()
{
scanf("%d%d",&n,&m);
for(;n--;)
{
int A,B;scanf("%d%d",&A,&B);
int M=1;
for(;M*M<=B;M++)
{
if((A+M-1)/M<=B/M)
{
s[M]++;
s[M+1]--;
}
}
int B1=M;
int k=B/M;
for(;k>=1;k--)
{
int B2=B/k;
int L=(A+k-1)/k;
if(L<B1)L=B1;
s[L]++;
s[B2+1]--;
B1=B2+1;
}
}
for(int i=1;i<=m;i++)printf("%d\n",a+=s[i]);
} |
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
typedef pair<int, int> P;
int N, M;
vector<P> R[100001];
struct BIT {
int n; vector<int> xs;
BIT(int n) : n(n) {
xs.resize(n+1);
}
void add(int x, int k) {
for (int i=x+1; i<=n; i+=i&-i) xs[i] += k;
}
int sum(int x) {
int s = 0;
for (int i=x+1; i>0; i-=i&-i) s += xs[i];
return s;
}
};
int main() {
ios::sync_with_stdio(false); cin.tie(0);
cin >> N >> M;
BIT bit(M+1);
for (int i=0; i<N; i++) {
int l, r;
cin >> l >> r;
R[r-l+1].push_back(P(l, r));
}
int s = N;
for (int d=1; d<=M; d++) {
s -= R[d-1].size();
for (auto &p : R[d-1]) {
bit.add(p.first, 1);
bit.add(p.second+1, -1);
}
int c = 0;
for (int i=d; i<=M; i+=d) c += bit.sum(i);
cout << s + c << "\n";
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Range
{
int l,r,sz;
Range(){}
}R[300001];
bool operator < (const Range &a, const Range &b)
{
return a.sz < b.sz;
}
int n,m;
int ans[100011];
int Tree[100011];
void update(int x,int val)
{
for(;x<=100010;x+=x&(-x))
Tree[x] += val;
}
int query(int x)
{
int ans = 0;
for(;x>0;x-=x&(-x))
ans += Tree[x];
return ans;
}
int main()
{
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> m;
for (int i=1;i<=n;i++)
{
cin >> R[i].l >> R[i].r;
R[i].sz = (R[i].r - R[i].l + 1);
}
sort(R+1,R+1+n);
int pos = 1;
for (int i=1;i<=m;i++)
{
while(pos <= n && R[pos].sz < i)
{
update(R[pos].l,1);
update(R[pos].r+1,-1);
pos++;
}
ans[i] = (n - pos + 1);
for (int j=i;j<=m;j+=i)
ans[i] += query(j);
}
for (int i=1;i<=m;i++)
cout << ans[i] << '\n';
} |
#include <bits/stdc++.h>
using namespace std;
#define X first
#define Y second
#define pb push_back
typedef double db;
typedef long long ll;
typedef pair<int,int> P;
const int MAXN=3e5+10;
struct Interval{int l,r,len;}itv[MAXN];
int n,m,res,bit[MAXN];
bool cmp(Interval a,Interval b)
{return a.len<b.len;}
void Update(int k,int x)
{while(k<=m) bit[k]+=x,k+=k&(-k);}
int Query(int k)
{int ret=0;while(k) ret+=bit[k],k-=k&(-k);return ret;}
int main()
{
scanf("%d%d",&n,&m);
for(int i=1;i<=n;i++)
scanf("%d%d",&itv[i].l,&itv[i].r),itv[i].len=itv[i].r-itv[i].l+1;
sort(itv+1,itv+n+1,cmp);
int k=1;
for(int i=1;i<=m;i++)
{
while(itv[k].len<=i&&k<=n)
Update(itv[k].l,1),Update(itv[k].r+1,-1),k++;
res=n-k+1;
for(int j=i;j<=m;j+=i)
res+=Query(j);
printf("%d\n",res);
}
return 0;
} |
#include <bits/stdc++.h>
#define lowbit(x) (x & -x)
using namespace std;
const int _ = 3e5 + 10;
int N, M, d;
struct node {
int l, r, len;
} a[_];
struct BIT {
int c[_];
void insert(int x, int y) {
for ( ; x <= M + 1; x += lowbit(x)) c[x] += y;
}
int query(int x) {
int y = 0;
for ( ; x; x -= lowbit(x)) y += c[x];
return y;
}
} tr;
int main() {
scanf("%d%d", &N, &M);
for (int i = 1; i <= N; ++i) {
scanf("%d%d", &a[i].l, &a[i].r);
a[i].len = (a[i].r - a[i].l + 1);
}
sort(a + 1, a + N + 1,
[](node a, node b) -> bool { return a.len < b.len; });
for (int d = 1, p = 1; d <= M; ++d) {
while (p <= N && a[p].len < d) {
tr.insert(a[p].l, 1);
tr.insert(a[p].r + 1, -1);
++p;
}
int ans = N - p + 1;
for (int i = d; i <= M; i += d)
ans += tr.query(i);
printf("%d\n", ans);
}
return 0;
} |
#include <bits/stdc++.h>
using namespace std;
using ii = pair<int, int>;
const int N = 3e5 + 5;
int n, m, fen[N];
ii seg[N];
void add(int p, int val) {
for (; p <= m; p += p & -p) fen[p] += val;
}
int sum(int p) {
int res = 0;
for (; p; p -= p & -p) res += fen[p];
return res;
}
#define L first
#define R second
int main() {
ios::sync_with_stdio(false); cin.tie(0); cout.tie(0);
cin >> n >> m;
for (int i = 1; i <= n; ++i) cin >> seg[i].L >> seg[i].R;
sort(seg + 1, seg + 1 + n, [](const ii &x, const ii &y){ return x.R - x.L < y.R - y.L; });
int x = n, j = 1;
for (int d = 1; d <= m; ++d) {
while (j <= n && seg[j].R - seg[j].L + 1 < d) {
add(seg[j].L, +1);
add(seg[j].R + 1, -1);
--x; ++j;
}
int ans = x;
for (int i = d; i <= m; i += d)
ans += sum(i);
cout << ans << "\n";
}
return 0;
} |
#include <algorithm>
#include <cstdio>
struct data
{
int l, r, len;
inline void input()
{
scanf("%d%d", &l, &r);
len = r - l + 1;
}
inline bool operator <(const data &a) const
{
return len < a.len;
}
} arr[300005];
int sum[100005], n, m;
inline void modify(int pos, int x)
{
for (; pos <= m; pos += pos & -pos)
sum[pos] += x;
}
inline int query(int pos)
{
int res = 0;
for (; pos; pos -= pos & -pos)
res += sum[pos];
return res;
}
int main()
{
// freopen("ARC068-E.in", "r", stdin);
scanf("%d%d", &n, &m);
for (int i = 0; i < n; i++)
arr[i].input();
std::sort(arr, arr + n);
for (int i = 1, idx = 0; i <= m; i++)
{
while (idx < n && arr[idx].len <= i)
{
modify(arr[idx].l, 1);
modify(arr[idx++].r + 1, -1);
}
int ans = n - idx;
for (int j = i; j <= m; j += i)
ans += query(j);
printf("%d\n", ans);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.