[leetcode]355. Design Twitter

• 题目链接：https://leetcode.com/problems/design-twitter/

• 题意：这是一个设计类题目，本题要求设计一个Twitter，主要支持以下几种操作：

  • 发表一条状态 postTweet(userId, tweetId)
  • 关注某个用户 follow(followerId, followeeId): Follower follows a followee
  • 对某个用户取消关注 unfollow(followerId, followeeId): Follower unfollows a followee
  • 获取朋友圈最近的10条状态，按照发表时间从新到旧排列 getNewsFeed(userId): Retrieve the 10 most recent tweet ids in the user’s news feed. Each item in the news feed must be posted by users who the user followed or by the user herself. Tweets must be ordered from most recent to least recent.

• 可以想象一下qq空间或微博，我们每次打开空间，都能看到自己和朋友最新的状态。这里就是要实现一个简化版的微博，用户和状态都用一个ID来标示。最初想的是为每个用户维护一个“关注者”(followee)列表，然后维护一个整体的“推文”(tweets)列表，这样每次要获取某个用户的朋友圈状态时，就对tweets列表从后往前遍历，如果某条tweet是该用户或者ta的朋友发的就放入显示列表中。这里用一个无序set来保存用户的followees，就能够在O(1)时间里判断一条tweet的发表者是不是该用户的followee。具体代码如下：

class Twitter {
private:
    unordered_map<int,unordered_set<int>> user;
    vector<pair<int,int>> tweet;    
public:
    /** Initialize your data structure here. */
    Twitter() {

    }

    /** Compose a new tweet. */
    void postTweet(int userId, int tweetId) {
        tweet.push_back(make_pair(userId,tweetId));
    }

    /** Retrieve the 10 most recent tweet ids in the user's news feed.  */
    vector<int> getNewsFeed(int userId) {
        vector<int> ret;
        for(int i=tweet.size()-1; i>=0; --i){
            if(userId == tweet[i].first || user[userId].find(tweet[i].first) != user[userId].end()){
                ret.push_back(tweet[i].second);
            }
            if((int)ret.size() == 10)  break;
        }
        return ret;
    }

    /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
    void follow(int followerId, int followeeId) {
        user[followerId].insert(followeeId);
    }

    /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
    void unfollow(int followerId, int followeeId) {
        user[followerId].erase(followeeId);
    }
};

      这样写当然没问题，但是效率也是低的可怜，因为查看每个用户的朋友圈信息时都需要去遍历整个tweets列表，然而里面很多都不是该用户的朋友发表的。当用户很多时，这样的遍历就显得特别低效。有没有一种设计使得我们只需要遍历该用户的朋友的tweets列表就能获得完整的显示列表呢？
      当然有，我们不妨为每个用户维护一个tweets列表来保存ta自己发表的状态，这样每次需要查询用户的朋友圈状态时就可以从ta本人以及ta朋友的tweets列表中获取。为了方便管理，我们把ta自己也加入ta的followee列表中，这样我们的显示列表就是followee列表中对应的用户的tweets列表的合并。因为我们只需获取10条最新的朋友圈状态，所以我们的问题转化为了从n (n为followee的数量)个列表中获取最大的k (k=10)个数，此时你一定已经想到了堆，是的，我们可以用 堆/优先队列 来获得最新的10条朋友圈状态。不多说了，看代码：

struct User{
    unordered_set<int> followee;
    vector<pair<int,int>> tweet;
    User(){}
    User(int _userid){
        tweet.push_back(make_pair(-1,-1));
        followee.insert(_userid);
    }
};
struct cmp{
  bool operator()(const vector<pair<int,int>>::iterator& a, const vector<pair<int,int>>::iterator& b){
      return a->second < b->second;
  }
};
class Twitter {
private:
    unordered_map<int,User> user;
    int count;

public:
    /** Initialize your data structure here. */
    Twitter():count(0) {

    }

    /** Compose a new tweet. */
    void postTweet(int userId, int tweetId) {
        if(user.find(userId) == user.end()){
            User u(userId);
            user.insert(make_pair(userId,u));
        }
        user[userId].tweet.push_back(make_pair(tweetId,++count));
    }


    /** Retrieve the 10 most recent tweet ids in the user's news feed. */
    vector<int> getNewsFeed(int userId) {
        vector<int> ret;
        if(user.find(userId) == user.end())  return ret;
        priority_queue<vector<pair<int,int>>::iterator, vector<vector<pair<int,int>>::iterator>, cmp> que;
        unordered_set<int>::iterator it;
        for(it = user[userId].followee.begin(); it != user[userId].followee.end(); ++ it){
            if(user[*it].tweet.size()>1){
                que.push(user[*it].tweet.end()-1);
            }
        }
        while(ret.size() < 10 && !que.empty()){
            vector<pair<int,int>>::iterator tit = que.top();
            que.pop();
            ret.push_back(tit->first);
            -- tit;
            if(tit->first != -1){
                que.push(tit);
            }
        }
        return ret;
    }

    /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
    void follow(int followerId, int followeeId) {
        if(user.find(followerId) == user.end()){
            User u(followerId);
            user.insert(make_pair(followerId,u));
        }
        user[followerId].followee.insert(followeeId);
    }

    /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
    void unfollow(int followerId, int followeeId) {
        if(followerId == followeeId || user.find(followerId) == user.end()){
            return;
        }
        user[followerId].followee.erase(followeeId);
    }
};