NOIP模拟 shopping【线段树 or Splay】

题目大意：

有n中物品，其价值和价格分别为$w_i,p_i$，现有以下两种操作m个：
1 k w p：把第k个物品的价值和价格分别改为w和p；
2 k：每次买价值最大的物品中价格最低的（每种物品可无限购买），问k元最多能买到价值为多少的物品。（1<=n,m<=100000，1<=k,w,p<=1000000000）

解题思路：

我们可以将物品（一个修改也算一种物品）以w为第一关键字，p为第二关键字排序后建线段树，同时记录排序后每个原序列物品（修改）所对应的新位置。而后把属于修改的物品的价格设为INF；

对于询问操作，注意到k元最多买logk种物品（买一种物品相当于k%$p_i$,而一个数最多模log次），所以我们可以在线段树上找到当前剩余钱能买到的价值最大中价格最小的物品，不断取模即可。

对于修改操作，我们只需把需要修改的原序列物品所对应的节点的价格变为INF，把修改所对应的节点价格变为p，同时将原序列物品所对应的节点编号转移过来即可。

其实也可以用Splay在线做，排序还是一样的，只不过不用放修改进去。

时间复杂度O($mlog^2n+nlogn$)。

线段树版：

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=100005,INF=0x3f3f3f3f;
int n,m,cnt,mx;
int b[N<<1],tr[N<<3];
struct node
{
    int k,w,p,id;
    inline friend bool operator <(const node &a,const node &b)
    {
        if(a.w==b.w)return a.p<b.p;
        return a.w>b.w;
    }
}a[N],t[N<<1],q[N];

void Init()
{
    for(int i=1;i<=n;i++)
        t[++cnt]=a[i],t[cnt].id=i;
    for(int i=1;i<=m;i++)
        if(q[i].w!=-1)t[++cnt]=q[i],t[cnt].id=i;
}

void build(int k,int l,int r)
{
    if(l==r)
    {
        tr[k]=t[l].p;
        return;
    }
    int mid=l+r>>1;
    build(k<<1,l,mid),build(k<<1|1,mid+1,r);
    tr[k]=min(tr[k<<1],tr[k<<1|1]);
}

void modify(int k,int l,int r,int p,int v)
{
    if(l==r)
    {
        t[l].p=tr[k]=v;
        return;
    }
    int mid=l+r>>1;
    if(p<=mid)modify(k<<1,l,mid,p,v);
    else modify(k<<1|1,mid+1,r,p,v);
    tr[k]=min(tr[k<<1],tr[k<<1|1]);
}

node query(int k,int l,int r,int v)
{
    if(l==r)return t[l];
    int mid=l+r>>1;
    if(tr[k<<1]<=v)return query(k<<1,l,mid,v);
    else return query(k<<1|1,mid+1,r,v);
}

int main()
{
    //freopen("shopping.in","r",stdin);
    //freopen("shopping.out","w",stdout);
    n=getint(),m=getint();
    for(int i=1;i<=n;i++)
        a[i].w=getint(),a[i].p=getint();
    for(int i=1;i<=m;i++)
    {
        int op=getint();
        if(op==1)q[i].k=getint(),q[i].w=getint(),q[i].p=getint();
        else q[i].k=getint(),q[i].w=-1;
    }
    Init();
    sort(t+1,t+cnt+1);
    for(int i=1;i<=cnt;i++)
        if(!t[i].k)a[t[i].id].id=i;
        else q[t[i].id].id=i,t[i].p=INF;
    build(1,1,cnt);
    for(int i=1;i<=m;i++)
    {
        if(q[i].w!=-1)
        {
            modify(1,1,cnt,a[q[i].k].id,INF),modify(1,1,cnt,q[i].id,q[i].p);
            a[q[i].k].id=q[i].id;
        }
        else 
        {
            ll ans=0;
            while(q[i].k>=tr[1])
            {
                node tmp=query(1,1,cnt,q[i].k);
                ans+=1ll*q[i].k/tmp.p*tmp.w,q[i].k%=tmp.p;
            }
            cout<<ans<<'\n';
        }
    }
    return 0;
}

Splay版

#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#define ll long long
using namespace std;

int getint()
{
    int i=0,f=1;char c;
    for(c=getchar();(c<'0'||c>'9')&&c!='-';c=getchar());
    if(c=='-')f=-1,c=getchar();
    for(;c>='0'&&c<='9';c=getchar())i=(i<<3)+(i<<1)+c-'0';
    return i*f;
}

const int N=100005,INF=0x3f3f3f3f;
int n,m;
struct node
{
    int w,p,id;
}a[N];
int tot,root,w[N<<1],p[N<<1],mi[N<<1],fa[N<<1],son[N<<1][2];

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

void Rotate(int x)
{
    int y=fa[x],z=fa[y],t=which(x);
    if(y!=root)son[z][which(y)]=x;
    else root=x;
    fa[y]=x,fa[x]=z;
    son[y][t]=son[x][t^1],son[x][t^1]=y;
    if(son[y][t])fa[son[y][t]]=y;
    mi[y]=min(p[y],min(mi[son[y][0]],mi[son[y][1]]));
    mi[x]=min(p[x],min(mi[son[x][0]],mi[son[x][1]]));
}

void Splay(int x,int f)
{
    while(fa[x]!=f)
    {
        if(fa[fa[x]]!=f)
            if(which(x)==which(fa[x]))Rotate(fa[x]);
            else Rotate(x);
        Rotate(x);
    }
}

void Insert(int &u,node &t,int f)
{
    if(!u)
    {
        t.id=u=++tot,fa[u]=f;
        w[u]=t.w,mi[u]=p[u]=t.p;
        return;
    }
    if(t.w==w[u])
    {
        if(t.p<p[u])Insert(son[u][0],t,u);
        else Insert(son[u][1],t,u);
    }
    else if(t.w>w[u])Insert(son[u][0],t,u);
    else Insert(son[u][1],t,u);
    mi[u]=min(p[u],min(mi[son[u][0]],mi[son[u][1]]));
}

int getsuf(int x)
{
    if(!son[x][0])return x;
    return getsuf(son[x][0]);
}

void Delete(int x)
{
    Splay(x,0);
    if(!son[x][1])
    {
        root=son[x][0],fa[son[x][0]]=0;
        return;
    }
    int y=getsuf(son[x][1]);
    Splay(y,x);
    son[y][0]=son[x][0],fa[son[x][0]]=y;
    fa[y]=0,root=y,mi[y]=min(p[y],min(mi[son[y][0]],mi[son[y][1]]));
}

int find(int u,int v)
{
    if(mi[son[u][0]]<=v)return find(son[u][0],v);
    else if(p[u]<=v)return u;
    else return find(son[u][1],v);
}

int main()
{
    //freopen("lx.in","r",stdin);
    int op,k,w0,p0;
    n=getint(),m=getint();
    memset(mi,INF,sizeof(mi));
    for(int i=1;i<=n;i++)
    {
        a[i].w=getint(),a[i].p=getint();
        Insert(root,a[i],0);
        Splay(tot,0);
    }
    while(m--)
    {
        op=getint(),k=getint();
        if(op==1)
        {
            w0=getint(),p0=getint();
            Delete(a[k].id);
            a[k].w=w0,a[k].p=p0;
            Insert(root,a[k],0);
        }
        else
        {
            ll ans=0;
            while(mi[root]<=k)
            {
                int x=find(root,k);
                ans+=1ll*k/p[x]*w[x],k%=p[x];
            }
            cout<<ans<<'\n';
        }
    }
    return 0;
}