Một bàn tiệc tròn:
     👤
  👤    👤    Mỗi người muốn ngồi cạnh 
👤        👤  "crush" của mình!
  👤    👤
     👤

1. Tình Yêu Đơn Phương:      2. Tình Yêu Đôi Bên:
   A → B → C                     A ↔ B
   (Một chiều)                  (Hai chiều)

3. Chuỗi Tình Cảm:           4. Hội Fan Club:
   A → B → C → D                A ← B
   (Chain)                      ↑   ↑
                               C   D

Input: [2,2,1,2]

Visualize mối quan hệ:
Employee 0: "Tôi chỉ muốn ngồi cạnh số 2!" 
           0 → 2
Employee 1: "Số 2 là idol của tôi!"
           1 → 2
Employee 2: "Tôi thích số 1!"
           2 → 1
Employee 3: "Số 2 là crush của tôi!"
           3 → 2

Vẽ graph:
   0 
   ↓
3→2←1
   ↓
   1

1. In-degree: Số lượng người thích một người
   [2,2,1,2] → inDegree[2] = 3 (được 3 người thích)

2. Cycle: Vòng tròn tình cảm
   A → B → C → A (Cycle length = 3)

3. Chain: Chuỗi tình cảm một chiều
   A → B → C → D (Chain length = 3)

Case 1: Cycle Length > 2
┌────────────┐
A → B → C → D│
└────────────┘
- Tất cả có thể ngồi cùng nhau!
- Count = cycle length

Case 2: Cycle Length = 2 + Chains
A ↔ B       Count = 2 + 
↑   ↑       (length of chains)
C   D         └── C: +1
↑             └── D: +1
E

class Solution {
public:
    int maximumInvitations(vector<int>& favorite) {
        int n = favorite.size();
        vector<int> inDegree(n, 0);    // Số người thích mỗi người
        vector<int> chainLengths(n, 0); // Độ dài chuỗi tới mỗi người
        vector<bool> visited(n, false); // Đánh dấu đã xét

        // Tính số người thích mỗi người
        for(int fav : favorite) {
            inDegree[fav]++;
        }

        // Visualize:
        // favorite = [2,2,1,2]
        // inDegree = [0,1,3,0]
        //            ↑ không ai thích

        queue<int> q;
        // Bắt đầu từ những người không được ai thích
        for(int i = 0; i < n; i++) {
            if(inDegree[i] == 0) q.push(i);
        }

        while(!q.empty()) {
            int person = q.front();
            q.pop();
            visited[person] = true;

            // Cập nhật độ dài chuỗi
            int nextPerson = favorite[person];
            chainLengths[nextPerson] = chainLengths[person] + 1;

            // Nếu đã xét hết người thích nextPerson
            if(--inDegree[nextPerson] == 0) {
                q.push(nextPerson);
            }
        }

        int maxCycle = 0;   // Cho cycles > 2
        int totalChains = 0; // Cho cycles = 2

        for(int i = 0; i < n; i++) {
            if(!visited[i]) {
                int cycleLength = 0;
                int curr = i;

                // Tìm độ dài cycle
                while(!visited[curr]) {
                    visited[curr] = true;
                    curr = favorite[curr];
                    cycleLength++;
                }

                if(cycleLength == 2) {
                    // Case đặc biệt: cycle 2 người
                    totalChains += 2 + 
                                 chainLengths[i] + 
                                 chainLengths[favorite[i]];
                } else {
                    // Cycles thông thường
                    maxCycle = max(maxCycle, cycleLength);
                }
            }
        }

        return max(maxCycle, totalChains);
    }
};

Vẽ graph:
2 → 1 ← 4
    ↓ ↑
    0 → 3

Initial arrays:
Index:     0  1  2  3  4
favorite: [3, 0, 1, 4, 1]
inDegree: [1, 2, 0, 1, 1]

1. Start từ node 2 (inDegree = 0):
   - Visit 2 → 1
   - chainLengths[1] = 1

2. Process neighbors:
   - inDegree[1]-- = 1 (vẫn > 0)

3. Final chainLengths:
   [1, 1, 0, 0, 0]

Find cycles:
1. Start từ node 0:
   0 → 3 → 4 → 1 → 0
   (Cycle length = 4)

2. Process cycle:
   maxCycle = max(maxCycle, 4) = 4

max(maxCycle, totalChains)
= max(4, 0)
= 4 employees!

Seating arrangement:
0 → 3 → 4 → 1
└───────────┘

   Vẽ graph trước khi code:
   - Dùng arrows cho directed edges
   - Circle các cycles
   - Mark các chain lengths

   Case 1: [1,0]
   - Simple 2-cycle

   Case 2: [1,2,3,1]
   - 3-person cycle

   Case 3: [1,2,0,0,3]
   - Multiple cycles

   - Sử dụng queue cho BFS
   - Tránh  tính toán lặp
   - Kết thúc code khi có thể