355. Design Twitter

355. Design Twitter

Design a simplified version of Twitter where users can post tweets, follow/unfollow another user and is able to see the 10 most recent tweets in the user's news feed. Your design should support the following methods:

1. postTweet(userId, tweetId): Compose a new tweet.
2. 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.
3. follow(followerId, followeeId): Follower follows a followee.
4. unfollow(followerId, followeeId): Follower unfollows a followee.

Example:

Twitter twitter = new Twitter();

// User 1 posts a new tweet (id = 5).
twitter.postTweet(1, 5);

// User 1's news feed should return a list with 1 tweet id -> [5].
twitter.getNewsFeed(1);

// User 1 follows user 2.
twitter.follow(1, 2);

// User 2 posts a new tweet (id = 6).
twitter.postTweet(2, 6);

// 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.getNewsFeed(1);

// User 1 unfollows user 2.
twitter.unfollow(1, 2);

// User 1's news feed should return a list with 1 tweet id -> [5],
// since user 1 is no longer following user 2.
twitter.getNewsFeed(1);

 Hash Table Heap Design

 

The good design about this implementation is that we keep the previous Tweet for the same user in the "next" field (at line 8), rather than keep all tweets in a queue inside the user. The benefit of doing this is that, when we get the top 10 feeds (at line 59), we only need to keep the head post of each follower into a pq, rather than all posts. We just compare the head, and get the next one after head (line 69). Similar problems are here.

 

class Twitter {
  private static int timeStamp = 0;
  private Map<Integer, User> userMap = new HashMap<>();

  private class Tweet {
    int tweetId;
    int timeStamp;
    Tweet next;

    Tweet(int tweetId) {
      this.tweetId = tweetId;
      timeStamp = Twitter.timeStamp++;
    }
  }

  private class User {
    int userId;
    Set<Integer> myFollows = new HashSet<>(); //Show the other users whom current user is following
    Tweet myPosts; //Keep user's own posts in a timed order.

    User(int userId) {
      this.userId = userId;
      follow(userId); // first follow itself
    }

    void follow(int id) {
      myFollows.add(id);
    }

    void unfollow(int id) {
      myFollows.remove(id);
    }

    void post(int id) {
      Tweet t = new Tweet(id);
      t.next = myPosts;
      myPosts = t; // The head keeps the latest post.
    }
  }

  /**
   * Compose a new tweet.
   */
  public void postTweet(int userId, int tweetId) {
    getOrCreateUser(userId).post(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 myFollows or by the user herself. Tweets must be ordered from most recent to least recent.
   */
  public List<Integer> getNewsFeed(int userId) {
    List<Integer> feeds = new LinkedList<>();
    User user = userMap.get(userId);
    if (user == null)
      return feeds;

    PriorityQueue<Tweet> q = new PriorityQueue<>(user.myFollows.size(), (a, b) -> (b.timeStamp - a.timeStamp));
    for (int f : user.myFollows) {
      Tweet t = userMap.get(f).myPosts;
      if (t != null)
        q.add(t); //add all followed tweets to one PQ.
    }

    int n = 0;
    while (!q.isEmpty() && n++ < 10) {
      Tweet t = q.poll();
      feeds.add(t.tweetId);
      if (t.next != null)
        q.add(t.next);
    }
    return feeds;
  }

  /**
   * Follower myFollows a followee. If the operation is invalid, it should be a no-op.
   */
  public void follow(int followerId, int followeeId) {
    getOrCreateUser(followerId).follow(getOrCreateUser(followeeId).userId);
  }

  /**
   * Follower unfollows a followee. If the operation is invalid, it should be a no-op.
   */
  public void unfollow(int followerId, int followeeId) {
    if (!userMap.containsKey(followerId) || followerId == followeeId)
      return;
    userMap.get(followerId).unfollow(followeeId);
  }

  private User getOrCreateUser(int userId) {
    User user = userMap.get(userId);
    if (user == null) {
      user = new User(userId);
      userMap.put(userId, user);
    }
    return user;
  }
}

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