1076. Forwards on Weibo (30) - 记录层的BFS改进

题目如下：

Weibo is known as the Chinese version of Twitter. One user on Weibo may have many followers, and may follow many other users as well. Hence a social network is formed with followers relations. When a user makes a post on Weibo, all his/her followers can view
and forward his/her post, which can then be forwarded again by their followers. Now given a social network, you are supposed to calculate the maximum potential amount of forwards for any specific user, assuming that only L levels of indirect followers are
counted.

Input Specification:

Each input file contains one test case. For each case, the first line contains 2 positive integers: N (<=1000), the number of users; and L (<=6), the number of levels of indirect followers that are counted. Hence it is assumed that all the users are numbered
from 1 to N. Then N lines follow, each in the format:

M[i] user_list[i]

where M[i] (<=100) is the total number of people that user[i] follows; and user_list[i] is a list of the M[i] users that are followed by user[i]. It is guaranteed that no one can follow oneself. All the numbers are separated
by a space.

Then finally a positive K is given, followed by K UserID's for query.

Output Specification:

For each UserID, you are supposed to print in one line the maximum potential amount of forwards this user can triger, assuming that everyone who can view the initial post will forward it once, and that only L levels of indirect followers are
counted.

Sample Input:

7 3
3 2 3 4
0
2 5 6
2 3 1
2 3 4
1 4
1 5
2 2 6

Sample Output:

4
5

题目要求根据微博的关注链条计算一条微博可能被转发的最大次数，此题目考察的就是BFS的改进，最关键的是粉丝会看到关注人的微博，题目给出的是一个人的关注列表，因此这个图应该反向去存，例如1的关注有2、3、4，那么2、3、4应该有邻接点1，这是因为1关注了2、3、4，后三者的微博可以被1看到。

为了在BFS时知道当前的层，我们要定义level、tail、last三个变量，tail记录每次邻接点遍历时的结点号，last代表当前层的最后一个元素，如果出队元素v恰好为last，就说明应该进入下一层，并且tail最后存储的是v的最后一个邻接点，也就是下一层的最后一个元素，这时候更新last为tail，进入下一层。很显然last的初值应该为源点，这样才能在源点访问结束后顺利进入第二层。

最后，因为源点算一层，因此应该根据层数，对1≤level≤maxLevel的所有结点v进行记录，最后输出。

代码如下：

#include <iostream>
#include <stdio.h>
#include <vector>
#include <queue>

using namespace std;

vector<vector<int> > graph;
vector<int> visited;
int N,M;
int maxLevel;
int K,num;

int BFS(int source){
    for(int i = 0; i <= N; i++)
        visited[i] = false;
    queue<int> q;
    q.push(source);
    int level = 0, last = source, tail = source;
    visited[source] = true;
    int cnt = 0;
    while(!q.empty()){
        int v = q.front();
        q.pop();
        for(int i = 0; i < graph[v].size(); i++){
            int w = graph[v][i];
            if(visited[w]) continue;
            q.push(w);
            tail = w;
            visited[w] = true;
        }
        if(level >= 1 && level <= maxLevel){
            cnt++;
        }
        if(v == last){
            level ++;
            last = tail;
        }

        if(level > maxLevel) break;
    }

    return cnt;

}

int main()
{
    cin >> N >> maxLevel;
    graph.resize(N + 1);
    visited.resize(N + 1);
    for(int i = 1; i <= N; i++){
        scanf("%d",&M);
        for(int j = 0; j < M; j++){
            scanf("%d",&num);
            graph[num].push_back(i);
        }
    }
    cin >> K;
    for(int i = 0; i < K; i++){
        scanf("%d",&num);
        cout << BFS(num) << endl;
    }

    return 0;
}