# 思路

//////////////////////////////////////////////////////////////////////////////////////////

# 代码（树套树）

#include <cstdio>
#include <algorithm>

const int maxn=100000;
const int maxk=200000;
const int maxs=10000000;

struct splay_tree
{
int fa[maxs],son[2][maxs],val[maxs],size[maxs],tot;

inline int t(int x)
{
return son[1][fa[x]]==x;
}

inline int updata(int x)
{
return size[x]=size[son[0][x]]+size[son[1][x]]+1;
}

inline int rotate(int x)
{
int k=t(x),f=fa[x];
if(fa[f])
{
son[t(f)][fa[f]]=x;
}
fa[x]=fa[f];
if(son[!k][x])
{
fa[son[!k][x]]=f;
}
son[k][f]=son[!k][x];
fa[f]=x;
son[!k][x]=f;
updata(f);
updata(x);
return 0;
}

inline int splay(int &root,int x,int c)
{
while(fa[x]!=c)
{
int f=fa[x];
if(fa[f]==c)
{
rotate(x);
}
else if(t(x)==t(f))
{
rotate(f);
rotate(x);
}
else
{
rotate(x);
rotate(x);
}
}
if(!c)
{
root=x;
}
return 0;
}

inline int ins(int &root,int x)
{
++tot;
size[tot]=1;
fa[tot]=son[0][tot]=son[1][tot]=0;
val[tot]=x;
if(!root)
{
root=tot;
return 0;
}
int now=root;
while(now)
{
int k=val[now]<x;
if(!son[k][now])
{
son[k][now]=tot;
fa[tot]=now;
break;
}
now=son[k][now];
}
splay(root,now,0);
return 0;
}

int getrank(int now,int x)
{
if(!now)
{
return 0;
}
else if(val[now]<=x)
{
return size[son[0][now]]+1+getrank(son[1][now],x);
}
else
{
return getrank(son[0][now],x);
}
}
};
struct segment_tree
{
splay_tree st;
int root[maxk<<4];

int ins(int now,int left,int right,int pos,int v)
{
st.ins(root[now],v);
if(left==right)
{
return 0;
}
int mid=(left+right)>>1;
if(pos<=mid)
{
ins(now<<1,left,mid,pos,v);
}
else
{
ins(now<<1|1,mid+1,right,pos,v);
}
return 0;
}

{
{
return st.getrank(root[now],v);
}
int mid=(left+right)>>1,res=0;
{
}
{
}
return res;
}
};
struct data
{
int s,c,m;

bool operator <(const data &other) const
{
if(s==other.s)
{
if(c==other.c)
{
return m<other.m;
}
return c<other.c;
}
return s<other.s;
}
};

data d[maxn+10];
int n,k,ans[maxn+10],sum[maxn+10];
segment_tree st;

int main()
{
scanf("%d%d",&n,&k);
for(register int i=1; i<=n; ++i)
{
scanf("%d%d%d",&d[i].s,&d[i].c,&d[i].m);
sum[i]=1;
}
std::sort(d+1,d+n+1);
for(register int i=1; i<=n; ++i)
{
if((i!=n)&&(d[i].s==d[i+1].s)&&(d[i].c==d[i+1].c)&&(d[i].m==d[i+1].m))
{
sum[i+1]+=sum[i];
}
else
{
ans[st.getrank(1,1,k,1,d[i].c,d[i].m)]+=sum[i];
}
st.ins(1,1,k,d[i].c,d[i].m);
}
for(register int i=0; i<n; ++i)
{
printf("%d\n",ans[i]);
}
return 0;
}

# 代码（cdq分治）

#include <cstdio>
#include <utility>
#include <algorithm>

const int maxn=100000;
const int maxk=200000;

typedef std::pair<int,std::pair<std::pair<int,int>,std::pair<int,int> > > data;
//first                 第一维
//second.first.first    第二维
//second.first.second   第三维
//second.second.first   数量
//second.second.second  等级

int k;

struct tree_array
{
int c[maxk+10];

inline int lowbit(int x)
{
return x&(-x);
}

{
while(pos<=k)
{
c[pos]+=x;
pos+=lowbit(pos);
}
return 0;
}

inline int sum(int pos)
{
int res=0;
while(pos)
{
res+=c[pos];
pos-=lowbit(pos);
}
return res;
}
};

data d[maxn+10];
tree_array t;

bool cmp(data a,data b)
{
if(a.second.first==b.second.first)
{
return a.first<b.first;
}
return a.second.first<b.second.first;
}

int solve(int l,int r)
{
if(l==r)
{
d[l].second.second.second+=d[l].second.second.first-1;
return 0;
}
int mid=(l+r)>>1;
solve(l,mid);
solve(mid+1,r);
std::sort(d+l,d+mid+1,cmp);
std::sort(d+mid+1,d+r+1,cmp);
int j=l;
for(register int i=mid+1; i<=r; ++i)
{
while((j<=mid)&&(d[j].second.first.first<=d[i].second.first.first))
{
++j;
}
d[i].second.second.second+=t.sum(d[i].second.first.second);
}
for(register int i=l; i<j; ++i)
{
}
return 0;
}

int n,tot=1,ans[maxn+10];

int main()
{
scanf("%d%d",&n,&k);
for(register int i=1; i<=n; ++i)
{
scanf("%d%d%d",&d[i].first,&d[i].second.first.first,&d[i].second.first.second);
d[i].second.second.first=1;
d[i].second.second.second=0;
}
std::sort(d+1,d+n+1);
for(register int i=2; i<=n; ++i)
{
if((d[i].first==d[i-1].first)&&(d[i].second.first==d[i-1].second.first))
{
++d[tot].second.second.first;
}
else
{
++tot;
d[tot]=d[i];
}
}
solve(1,tot);
for(register int i=1; i<=tot; ++i)
{
ans[d[i].second.second.second]+=d[i].second.second.first;
}
for(register int i=0; i<n; ++i)
{
printf("%d\n",ans[i]);
}
return 0;
}