Solution
此题可以十分简单粗暴地套用树状数组套主席树的模板。
或者：cdq分治。
此题中，原先给出一个数列，之后会删除一些数。但是，呃，删除操作好像有点儿麻烦。反正允许离线，那就当作是初始给出一些数，先把这些数加入序列，之后会再添加一些数。也就是全部反过来算。
可以把每次的答案分成两个部分：原先存在的逆序对+加入这个数新产生的逆序对，那么每次只要算出当前新产生的逆序对，最后算一遍前缀和即可。
加入这个数新产生的逆序对也可以分成两个部分：位置靠前且值比它大的，位置靠后且比它小的。那么总共有三种操作，(1)往序列的某个位置加入一个数，(2)查询比某个数位置靠前且值比它大的数量，(3)查询比某个数位置靠后且值比它小的数量。显然，根据给出的删除顺序，可以得出每个操作的先后顺序，即每个操作的时间。要在cdq分治之前，要先按操作的时间从小到大排序。
在cdq分治中，每次会合并左右两个序列。在合并的时候，如果要查询位置靠前且比它大的，就要先执行位置靠前的操作，位置相同的操作，先执行加入操作，树状数组维护的是值，也就是说cdq分治结束以后，所有操作将按位置从小到大顺序排好。这样不方便查询位置靠后且比它小的。
那么，考虑把所有的操作分成互不影响的两组操作，第一组：所有的操作(1)和操作(2)。第二组：所有的操作(1)和操作(3)。两组操作分别先按时间从小到大排序，第二组操作在cdq分治的时候，先执行值小的操作，树状数组维护的是位置。
最后把两组操作所得结果累计，就得到了每次答案的加入这个数新产生的逆序对这一部分。
代码建议自己完成，实在不行的话，下面那个代码凑合着看吧QAQ
Code
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
#define lowbit(x) (x&(-x))
inline int getint()//读入优化
{
char ch;
int res=0;
while(ch=getchar(),ch<'0'||ch>'9');
res=ch-48;
while(ch=getchar(),ch>='0'&&ch<='9')
res=res*10+ch-48;
return res;
}
const int e=3e5+5;
struct point
{
int id,v,t,opt,k;
}a[e],t[e],b[e];//id是位置，v是数值。k其实没什么用，然而不知道为什么写进去了。a，b为两组操作
int n,m,real[e],c[e],cnt,num;
bool vis[e];
long long ans[e];//逆序对总数可能超过int范围
inline bool cmp(const point &a,const point &b)//排序
{
return a.t<b.t||(a.t==b.t&&a.opt<b.opt);//t是时间，opt=1为加入操作，opt=2为询问操作
}
inline void init(int x)//树状数组清零
{
while(x<=n)
{
c[x]=0;
x+=lowbit(x);
}
}
inline void add(int x,int d)//树状数组单点修改
{
while(x<=n)
{
c[x]+=d;
x+=lowbit(x);
}
}
inline int query(int x)//树状数组前缀和查询
{
int res=0;
while(x)
{
res+=c[x];
x-=lowbit(x);
}
return res;
}
inline void solve(int l,int r)//第一组分治
{
if(l==r)return;
int mid=(l+r)/2,id1=l,id2,i;
id2=mid+1;
solve(l,mid);
solve(mid+1,r);
for(i=l;i<=r;i++)
if(id2>r||id1<=mid&&a[id1].id<=a[id2].id)//先执行位置靠前的
{
t[i]=a[id1++];
if(t[i].opt==1)
add(t[i].v,1);
}
else
{
t[i]=a[id2++];
if(t[i].opt==2)
ans[t[i].k]+=(long long)query(n)-(long long)query(t[i].v);
//查询值比它大的数量
}
for(i=l;i<=r;i++)
{
a[i]=t[i];
init(a[i].v);
}
}
inline void solve2(int l,int r)//第二组分治
{
if(l==r)return;
int mid=(l+r)/2,id1=l,id2,i;
id2=mid+1;
solve2(l,mid);
solve2(mid+1,r);
for(i=l;i<=r;i++)
if(id2>r||id1<=mid&&b[id1].v<=b[id2].v)//先执行值较小的
{
t[i]=b[id1++];
if(t[i].opt==1)
add(t[i].id,1);
}
else
{
t[i]=b[id2++];
if(t[i].opt==2)
ans[t[i].k]+=(long long)query(n)-(long long)query(t[i].id);
//查询位置比它靠后的数量
}
for(i=l;i<=r;i++)
{
b[i]=t[i];
init(b[i].id);
}
}
int main()
{
int i,x,y;
n=getint();
m=getint();
for(i=1;i<=n;i++)
{
x=getint();
real[x]=i;//x的位置为i
}
for(i=1;i<=m;i++)//创建操作
{
x=getint();
y=real[x];//y为x的位置
vis[x]=true;
a[++cnt]=(point){y,x,n-i+1,1,0};
a[++cnt]=(point){y,x,n-i+1,2,n-i+1};
b[++num]=(point){y,x,n-i+1,1,0};
b[++num]=(point){y,x,n-i+1,2,n-i+1};
}
int ti=0;
for(i=1;i<=n;i++)//创建操作
if(!vis[i])
{
a[++cnt]=(point){real[i],i,++ti,1,0};
a[++cnt]=(point){real[i],i,ti,2,ti};
b[++num]=(point){real[i],i,ti,1,0};
b[++num]=(point){real[i],i,ti,2,ti};
}
sort(a+1,a+cnt+1,cmp);//排序
sort(b+1,b+num+1,cmp);
solve(1,cnt);
solve2(1,num);
for(i=2;i<=n;i++)//做一遍前缀和
ans[i]+=ans[i-1];
for(i=n;i>=n-m+1;i--)
printf("%lld\n",ans[i]);
return 0;
}