[Solution] OpenAI高频题 Social Network / Follow Graph — Parts 1-4 详解

This is my writeup of the Social Network / Follow Graph problem, one of the current high-frequency OpenAI coding questions. It comes in 4 progressive parts plus a design follow-up. Each part builds on the previous one, and each has exactly one key insight — get that right and the code writes itself.

Part 1: immutable snapshots

SocialNetwork holds user -> set(followees). create_snapshot() must return a view that never changes afterward. The trap: a shallow dict copy still shares the inner sets, so later follow() calls would leak into old snapshots. Deep-copy the inner sets (and freeze them as frozensets — cheap insurance against accidental mutation).

2. import bisect
3. import heapq
4. from collections import defaultdict
6. class Snapshot:
7.     def __init__(self, following):
8.         self._following = {u: frozenset(s) for u, s in following.items()}
9.         followers = {u: [] for u in self._following}
10.         for u, followees in self._following.items():
11.             for v in followees:
12.                 followers[v].append(u)
13.         self._following_sorted = {u: tuple(sorted(s)) for u, s in self._following.items()}
14.         self._followers_sorted = {u: tuple(sorted(l)) for u, l in followers.items()}
16.     def is_following(self, follower, followee):
17.         return followee in self._following.get(follower, ())
19.     def get_following(self, user_id):
20.         return list(self._following_sorted.get(user_id, ()))
22.     def get_followers(self, user_id):
23.         return list(self._followers_sorted.get(user_id, ()))
25.     def recommend(self, user_id, k):
26.         if k <= 0:
27.             return []
28.         direct = self._following.get(user_id, frozenset())
29.         score = defaultdict(int)
30.         for f in direct:
31.             for g in self._following.get(f, ()):
32.                 if g != user_id and g not in direct:
33.                     score[g] += 1
34.         return heapq.nsmallest(k, score, key=lambda g: (-score[g], g))
36. class SocialNetwork:
37.     def __init__(self):
38.         self._following = {}
40.     def add_user(self, user_id):
41.         self._following.setdefault(user_id, set())
43.     def follow(self, follower, followee):
44.         if follower not in self._following or followee not in self._following:
45.             raise KeyError("unknown user")
46.         if follower == followee:
47.             return                          # self-follow is a no-op
48.         self._following[follower].add(followee)   # duplicate follow is a no-op (set)
50.     def create_snapshot(self):
51.         return Snapshot(self._following)

复制代码

Part 2: followers

get_followers needs the reverse direction. Don't scan every user per call — build the reverse index once at snapshot construction, plus sorted tuples for both directions (already in the code above). This is safe precisely because the snapshot is immutable; on a mutable graph it would be a staleness bug. Queries become O(answer); construction is O(n + m).

Part 3: two-hop recommendations

Candidate g is reached through a followee f of the user (user -> f -> g), excluding the user and anyone already followed. Score = number of distinct followees reaching g. Since each followee's followee-set has no duplicates, incrementing once per (f, g) pair counts distinct followees correctly. Top-k by (score desc, id asc) with a heap — no need to sort all candidates. Cost: O(sum of followees' out-degrees + C log k).

Part 4: historical queries

New class, FollowTimeline: follow/unfollow(follower, followee, t) arrive in non-decreasing t, and is_following(follower, followee, t) asks about any t. Snapshots copy the whole graph; here we store, per pair, only the timestamps where the state actually flipped. A pair starts "not following", so the state at time t is following iff an odd number of flips happened at or before t: bisect_right(flips, t) odd. Calls only ever append (thanks to the non-decreasing guarantee), so queries are O(log e).

Two subtleties: same-t follow-then-unfollow records both flips, and bisect_right counts both, so the later call wins. Redundant calls (follow while already following) record nothing.

2. class FollowTimeline:
3.     def __init__(self):
4.         self._flips = defaultdict(list)
5.         self._last_t = None
7.     def _check_time(self, t):
8.         if self._last_t is not None and t < self._last_t:
9.             raise ValueError("timestamps must be non-decreasing")
10.         self._last_t = t
12.     def _currently_following(self, key):
13.         return len(self._flips[key]) % 2 == 1
15.     def follow(self, follower, followee, t):
16.         self._check_time(t)
17.         key = (follower, followee)
18.         if follower != followee and not self._currently_following(key):
19.             self._flips[key].append(t)
21.     def unfollow(self, follower, followee, t):
22.         self._check_time(t)
23.         key = (follower, followee)
24.         if self._currently_following(key):
25.             self._flips[key].append(t)
27.     def is_following(self, follower, followee, t):
28.         flips = self._flips.get((follower, followee))
29.         return bool(flips) and bisect.bisect_right(flips, t) % 2 == 1

复制代码

Follow-up (discussion): copy-on-write snapshots

If snapshots are frequent and edits are few, a snapshot can be an O(1) reference to the current dict of frozensets; follow() replaces only the touched user's frozenset (plus the top-level dict — or use a persistent hash map to make that O(log n) too). Old snapshots keep pointing at old versions. The reverse index and sorted views become lazy, cached per snapshot.

Pitfalls that actually decide this question

1. Shallow-copying the snapshot (shared inner sets).
2. Rebuilding the reverse index per query instead of once at construction.
3. Counting non-distinct followees in recommendations.
4. bisect_left instead of bisect_right in Part 4 — same-timestamp ordering breaks.
5. Recording flips for redundant calls — corrupts the parity.

Happy to discuss alternatives.