355. Design Twitter

问题：

设计数据结构，使得完成以下功能：

• 关注用户：
  • void follow(int followerId, int followeeId)
• 取关用户：
  • void unfollow(int followerId, int followeeId)
• 某用户发状态：
  • void postTweet(int userId, int tweetId)
• 取得某用户能查看到的最新10条状态（包含自己+被关注者们）：
  • vector<int> getNewsFeed(int userId)

Example 1:

Input
["Twitter", "postTweet", "getNewsFeed", "follow", "postTweet", "getNewsFeed", "unfollow", "getNewsFeed"]
[[], [1, 5], [1], [1, 2], [2, 6], [1], [1, 2], [1]]
Output
[null, null, [5], null, null, [6, 5], null, [5]]

Explanation
Twitter twitter = new Twitter();
twitter.postTweet(1, 5); // User 1 posts a new tweet (id = 5).
twitter.getNewsFeed(1);  // User 1's news feed should return a list with 1 tweet id -> [5]. return [5]
twitter.follow(1, 2);    // User 1 follows user 2.
twitter.postTweet(2, 6); // User 2 posts a new tweet (id = 6).
twitter.getNewsFeed(1);  // User 1's news feed should return a list with 2 tweet ids -> [6, 5]. Tweet id 6 should precede tweet id 5 because it is posted after tweet id 5.
twitter.unfollow(1, 2);  // User 1 unfollows user 2.
twitter.getNewsFeed(1);  // User 1's news feed should return a list with 1 tweet id -> [5], since user 1 is no longer following user 2.
 

Constraints:

1 <= userId, followerId, followeeId <= 500
0 <= tweetId <= 10^4
All the tweets have unique IDs.
At most 3 * 10^4 calls will be made to postTweet, getNewsFeed, follow, and unfollow.

　　

解法：System Design

使用两个数据结构保存数据：

• 关注关系：user1->{user2,user3....} : user1关注了user2，user3...
  • unordered_map<int, set<int>> fol;
• 某用户发的状态list：user1->{tweet1, tweet2...}   tweet->{timestamp, tweetId}
  • unordered_map<int, vector<pair<int, int>>> tw;

由于取得最新10条状态，需要按照时间戳排序，优先展示时间较大的。

我们使用priority_queue的最大堆来实现，时间戳作为权值。

 

代码参考：

class Twitter {
public:
    unordered_map<int, set<int>> fol;// user: followers list
    unordered_map<int, vector<pair<int, int>>> tw;// user: list{time, tweet}
    long long timestamp;
    /** Initialize your data structure here. */
    Twitter() {
        timestamp=0;
    }
    
    /** Compose a new tweet. */
    void postTweet(int userId, int tweetId) {
        tw[userId].push_back({timestamp++, tweetId});
    }
    
    /** 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. */
    vector<int> getNewsFeed(int userId) {
        priority_queue<pair<int,int>> q;//timestamp, tweetId
        for(auto tweet:tw[userId]) {//add oneself's tweets
            q.push(tweet);
        }
        for(auto followee:fol[userId]) {
            for(auto tweet:tw[followee]) {//add followees' tweets
                q.push(tweet);
            }
        }
        vector<int> res;
        while(!q.empty() && res.size()<10) {
            res.push_back(q.top().second);
            q.pop();
        }
        return res;
    }
    
    /** Follower follows a followee. If the operation is invalid, it should be a no-op. */
    void follow(int followerId, int followeeId) {
        if(followerId != followeeId)//Ensure: oneself is not in his followers.
            fol[followerId].insert(followeeId);
    }
    
    /** Follower unfollows a followee. If the operation is invalid, it should be a no-op. */
    void unfollow(int followerId, int followeeId) {
        fol[followerId].erase(followeeId);
    }
};

/**
 * Your Twitter object will be instantiated and called as such:
 * Twitter* obj = new Twitter();
 * obj->postTweet(userId,tweetId);
 * vector<int> param_2 = obj->getNewsFeed(userId);
 * obj->follow(followerId,followeeId);
 * obj->unfollow(followerId,followeeId);
 */