CCF 201909-4 推荐系统

试题编号：	201909-4
试题名称：	推荐系统
时间限制：	5.0s
内存限制：	512.0MB
问题描述：

算法设计

　　由于我们需要选出得分最大的K件商品，得出相同的先按类号从小到大排序，再按编号从小到大排序。那么我们可以将所有商品放入到一个set变量bbt中进行自动排序。另外，同类商品编号必然不同，不同类商品编号可能相同，所以我们可以用类号+编号来唯一标识一件商品。由于商品的编号在10^9 以内，而类号在以内，我们可以用类号∗109+编号类号*10^9+编号类号∗10 ^9+编号来作为一件商品唯一的id，显然每件商品和其id是一一对应的。这样的id可以用long long类型存储，且按id从小到大排序就相当于题目要求的“先按类号从小到大排序，再按编号从小到大排序”的排序原则。如果我们得到一件商品的id，那么这件商品的类号=id/10^9,编号=id%10^9 。

　　于是我们可以定义一个商品类dat，其中定义两个成员变量：id和score。为了方便set排序，需要在类内重载<运算符，保证商品先按得分从大到小排序，再按id从小到大排序。但是这又需要考虑另一个问题，题目中需要对商品进行添加和删除，添加和删除操作都是通过商品的id来操作的，我们显然无法在set中我们需要给出id和score两个变量才能查找到一件商品，而无法只通过商品的id查找到相应的商品。怎么办呢？我们可以另外定义一个unordered_map变量um，键存储商品的id，值存储指向这件商品在set中的位置的迭代器。还记得set中进行插入的insert函数吗？其实这个函数是有返回值的，只不过我们不常用。它的返回值是一个pair，first成员就是指向新插入的元素在set中位置的迭代器，second成员是一个bool表示这次插入操作是否成功。于是我们在向set中插入商品时可以直接通过代码um[a] = bbt.insert(dat(a, score)).first;完成um和bbt的同步更新。进行删除时，我们先通过um找到商品在set中的迭代器，然后利用set的erase函数进行删除，另外别忘了同步对um中的对应元素也进行删除就可以了。

　　然后是打印操作，我们可以定义一个变量k存储要选出的最多商品总数，定义一个数组变量K存储每类商品被选中的最多件数，定义一个二位数组变量ans存储每类商品要输出的编号。遍历整个set，假设当前遍历到的商品所属类别为t，而ans[t][0]< K[t]，表示当前类别还没有选满，则将当前商品的编号加入到ans[t][]中，另外令变量k递减1，判断k是否变为了0，如果k变为了0，表示商品总数已选够，即可直接结束遍历。

最后，题目中要求，同类商品的编号从小到大输出，需要对ans中每类商品编号排序再输出即可。

　　然而60分之后的数据有问题，如要获得满分，请注释掉第55行用来对要输出的商品进行排序的代码

#pragma GCC optimize(3,"Ofast","inline")
#include<set>
#include<vector>
#include<stdio.h>
#include<tr1/unordered_map>
using namespace std;
using namespace tr1;
typedef long long ll;
const ll mul=1e9;
const int M=;
const int Kn=;
struct dat{
    ll id;int s;
    dat(ll id=,int s=):id(id),s(s){}
    bool operator <(const dat &c) const{
        return s!=c.s?s>c.s:id<c.id;
    }
};
set<dat>bbt; unordered_map<ll,set<dat>::iterator>um;
int K[M],ans[M][Kn];
int main(){
    int n,m,cas,opt,t,id,s,k;
    scanf("%d%d",&m,&n);
    for(int i=;i<n;i++){
        scanf("%d%d",&id,&s);
        for(int j=;j<m;j++){
            ll a=j*mul+id;
            um[a]=bbt.insert(dat(a,s)).first;
        }
    }
    for(scanf("%d",&cas);cas--;){
        scanf("%d",&opt);
        if(opt==){
            scanf("%d%d%d",&t,&id,&s);
            ll a=t*mul+id;
            um[a]=bbt.insert(dat(a,s)).first;
        }
        else if(opt==){
            scanf("%d%d",&t,&id);
            ll a=t*mul+id;
            bbt.erase(um[a]);um.erase(a);
        }
        else{
            scanf("%d",&k);
            for(int i=;i<m;i++) scanf("%d",&K[i]),ans[i][]=;
            for(auto &i:bbt){
                t=i.id/mul;
                if(ans[t][]<K[t]){
                    ans[t][++ans[t][]]=i.id%mul;
                    if(!--k) break;
                }
            }
            for(int i=;i<m;i++){
                if(!ans[i][]){puts("-1");continue;}
//                sort(ans[i]+1,ans[i]+ans[0]+1)''
                for(int j=;j<=ans[i][];j++) printf("%d ",ans[i][j]);
                puts("");
            }
        }
    }
    return ;
}

----------------------------------------------------------------------------------------------------------------------------

以上是来自网路的做法，以下是来自本人的（原创）做法

----------------------------------------------------------------------------------------------------------------------------

其实大同小异。当然，我的做法在常数上效率更高，不然，我也没有必要讲他了。

/*
建立一个set群：bst[M]。bst[i]的表示维护第i类商品的set
题目保证：任意时刻，同类的任意两个商品的编号各不相同
所以可以这样哈希映射 ha[当前类][该商品id]-->该商品得分，
插入：在当前类的set中插入dat(该商品得分,该商品id)
删除：在当前类的set中删除dat(ha[当前类][该商品id]即该商品得分，该商品id)
    因为set删除要么使用迭代器，要么使用无重(包含各项信息的)键值
查询： 1、if(sum<=K) 只需将所有bst[i]的信息排序输出
       2、否则,将所有bst[i]的前K大输出。具体操作如下：
           <1>首先将所有bst[i]的最大扔到堆q中，同时在所有set[i]中删除该值.
           <2>将堆顶元素x弹出,并将元素x所属的bst[j]的当前最大y扔到堆q中，同时在set[j]中删除y.
           <3>重复<2>K次
*/
#include<set>
#include<queue>
#include<cstdio>
#include<algorithm>
#include<tr1/unordered_map>
#include<iostream>
#include<algorithm>
#define debug(x) cerr<<#x<<" "<<x<<endl;
using namespace std;
using namespace std::tr1;
const int N=1e5+;
const int M=+;
const int Kn=+;
int n,m,as,sum,k[M];pair<int,int>vp[N];
unordered_map<int,int>ha[M];
int ans[M][Kn];
inline int read(){
    int x=,f=;char ch=getchar();
    while(ch<''||ch>''){if(ch=='-')f=-;ch=getchar();}
    while(ch>=''&&ch<=''){x=x*+ch-'';ch=getchar();}
    return x*f;
}
struct dat{
    int v,id;
    dat(int _v=,int _id=):v(_v),id(_id){}
    bool operator <(const dat &a)const{
        return v!=a.v?v>a.v:id<a.id;
    }
};
struct add{
    dat mes;int typ;
    add(dat _mes=,int _typ=):mes(_mes),typ(_typ){}
    bool operator <(const add &a)const{
        return mes.v==a.mes.v?typ>a.typ:mes.v<a.mes.v;
    }
};
typedef set<dat> bbt;
bbt bst[M];
bbt::iterator it[M],ed[M];
int cnt;
int main(){
    m=read();n=read();
    for(int i=,x,y;i<=n;i++) x=read(),y=read(),vp[i]=make_pair(y,x);
    #define x first
    #define y second
    for(int i=;i<m;i++){
        for(int j=;j<=n;j++){
            bst[i].insert(dat(vp[j].x,vp[j].y));
            ha[i][vp[j].y]=vp[j].x;
        }
    }
    #undef x
    #undef y
    int op,tpy,com,sco,K,t;
    for(as=read();as--;){
        op=read();
        if(op==){
            tpy=read();com=read();sco=read();
            bst[tpy].insert(dat(sco,com));
            ha[tpy][com]=sco;
        }
        if(op==){
            tpy=read();com=read();
            if(t=ha[tpy][com]) bst[tpy].erase(dat(t,com)),ha[tpy][com]=;
        }
        if(op==){
            K=read();sum=;
            for(int i=;i<m;i++) k[i]=read(),sum+=k[i];
            for(int i=;i<m;i++) it[i]=bst[i].begin(),ed[i]=bst[i].end();
            if(sum<=K){
                for(int i=;i<m;i++) ans[i][]=;
                for(int i=;i<m;i++){
                    for(;k[i];k[i]--){
                        if(it[i]==ed[i]) break;
                        ans[i][++ans[i][]]=it[i]++->id;
                    }
                    if(!ans[i][]){puts("-1");continue;}
//                    sort(ans[i]+1,ans[i]+ans[i][0]+1);
                    for(int j=;j<=ans[i][];j++) printf("%d ",ans[i][j]);
                    puts("");
                }
            }
            else{
                priority_queue<add> q;int cat=;
                for(int i=;i<m;i++) if(it[i]!=ed[i]) q.push(add(*it[i]++,i));
                for(int i=;i<m;i++) ans[i][]=;
                while(!q.empty()){
                    add now=q.top();q.pop();
                    #define typ now.typ
                    #define com now.mes.id
                     if(k[typ]>){
                        ans[typ][++ans[typ][]]=com;
                        ++cat;
                        if(cat==K) break;
                        k[typ]--;
                        if(k[typ]>&&it[tpy]!=ed[tpy]) q.push(add(*it[typ]++,typ));
                    }
                    #undef typ
                    #undef com
                }
                for(int i=;i<m;i++){
                    if(!ans[i][]){puts("-1");continue;}
//                    sort(ans[i]+1,ans[i]+ans[i][0]+1);
                    for(int j=;j<=ans[i][];j++) printf("%d ",ans[i][j]);
                    puts("");
                }
            }
        }
    }
    return ;
}