1129 Recommendation System（25 分）（C++）

Recommendation system predicts the preference that a user would give to an item. Now you are asked to program a very simple recommendation system that rates the user's preference by the number of times that an item has been accessed by this user.

Input Specification:

Each input file contains one test case. For each test case, the first line contains two positive integers: N (≤ 50,000), the total number of queries, and K (≤ 10), the maximum number of recommendations the system must show to the user. Then given in the second line are the indices of items that the user is accessing -- for the sake of simplicity, all the items are indexed from 1 to N. All the numbers in a line are separated by a space.

Output Specification:

For each case, process the queries one by one. Output the recommendations for each query in a line in the format:

query: rec[1] rec[2] ... rec[K]

where query is the item that the user is accessing, and rec[i] (i=1, ... K) is the i-th item that the system recommends to the user. The first K items that have been accessed most frequently are supposed to be recommended in non-increasing order of their frequencies. If there is a tie, the items will be ordered by their indices in increasing order.

Note: there is no output for the first item since it is impossible to give any recommendation at the time. It is guaranteed to have the output for at least one query.

Sample Input:

12 3
3 5 7 5 5 3 2 1 8 3 8 12

Sample Output:

5: 3
7: 3 5
5: 3 5 7
5: 5 3 7
3: 5 3 7
2: 5 3 7
1: 5 3 2
8: 5 3 1
3: 5 3 1
8: 3 5 1
12: 3 5 8

方法一：set重载：

思路：首先每个元素都是唯一的，首先先要有个容器存储出现了的元素，这里想到set，还要存储这些元素的出现次数，自然的想到结构体，要是可以set插入时候自动排序就最好了，重载set即可。

针对结构体重载（其实就是重载<hao）符号下的格式：

struct info{
    int id,rank;
    bool operator<(const info &a)const{
        return a.rank!=rank?a.rank<b.rank:a.id<b.id;
    }
}

本题代码则如下：

#include <iostream>
#include <set>
#include <vector>
using namespace std;
struct node
{
    int val,cnt;
    bool operator < (const node & a)const{
        return cnt != a.cnt ? cnt > a.cnt : val < a.val;
    }    
};
int main(){
    int n, k, temp, cnt = 0;
    cin>>n>>k;
    scanf("%d",&temp);
    set<node>s;
    std::vector<int> valuecnt(n + 1, 0);
    s.insert({temp,1});
    valuecnt[temp]++;
    for(int i = 1; i < n; ++ i){
        scanf("%d", &temp);
        printf("%d:",temp);
        cnt = 0;
        for(auto it = s.begin(); cnt < k && it != s.end(); ++it){
            printf(" %d",it->val);
            cnt++;
        }
        printf("\n");
        if(valuecnt[temp] > 0)
            s.erase({temp,valuecnt[temp]});
        valuecnt[temp]++;
        s.insert({temp,valuecnt[temp]});
    }
}

方法二：hash

思路：如果实在用不习惯重载，可以试试hash，本质是手动完成set重载后的排序功能。本题特别地规定了元素的上限值，以及每个元素只有一个，下意识也是在提醒hash

用ans存储最后要输出的推荐元素

用pos存储每个元素的位置

用num存储每个元素出现的次数

手动完成排序的功能：分两步，首先需要确定本次排序后可以输出的有哪些元素，其次这些元素的顺序。

确定元素：如果插入前，ans元素个数不足k个，本次这个元素一定能插入， 如果插入前，ans元素个数已经有k个，那么如果ans最后一个元素的出现次数小于本次插入元素的次数，可以将ans最后一个元素替换为本次的元素。或者ans最后一个元素的出现次数等于本次插入元素的次数，但是ans的最后一个元素值大于本次的元素，那么也可以将ans最后一个元素替换为本次的元素。

确定顺序：更新顺序时，其实如果本次插入或替换了元素，才需要更新顺序，而且仅需要更新ans的最后一个元素，找到最后一个元素应该在的位置即可。

#include <iostream>
#include <vector>
using namespace std;
vector<int>ans;
int n, k, temp, num[50005], pos[50005];
int main(){
	fill(pos, pos + 50005, -1);
	scanf("%d %d", &n, &k);
	for(int i = 0; i < n; ++ i){
		scanf("%d", &temp);
		++ num[temp];
		if(i == 0){
			ans.push_back(temp);
			pos[temp] = 0;
			continue;
		}
		printf("%d:", temp);
		for(int j = 0; j < ans.size(); ++ j)
			printf(" %d", ans[j]);
		printf("\n");
		if(pos[temp] == -1){
			if(ans.size() < k){
				ans.push_back(temp);
				pos[temp] = ans.size() - 1;
			}	
			else if(num[ans[k -1]] < num[temp] || (num[ans[k-1]] == num[temp] && ans[k -1] > temp)){
				swap(pos[ans[k -1]], pos[temp]);
				ans[k - 1] = temp;
			}
		}
		if(pos[temp] != -1){
			int p = pos[temp] - 1;
			while(p >= 0 && (num[ans[p]] < num[temp] || (num[ans[p]] == num[temp] && ans[p] > temp))){
				swap(pos[ans[p]], pos[temp]);
				swap(ans[p], ans[p+1]);
				-- p;
			}
		}
	}
}