A1076 Forwards on Weibo （30 分）（L层之内的转发数）（图的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 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 trigger, 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

题意：

 微博中，一位用户可以被其他用户关注。当该用户发布一条消息，它的关注者可以看到该信息，并选择是否转发它，转发的信息也可以被转发者的关注者选择是否再次转发，每位用户最多只转发一次该信息。

输入：第一行：N为用户（编号1~N）、转发层数上限L

接下来N行：第二行：1号用户关注了3位用户，分别为2，3, 4

最后一行：查询给定的2位用户2,6

求在转发上限之内消息最多会被多少用户转发

思路：

1. 如何建图？以第二行为例，用户1关注了2,3,4用户，说明用户2,3,4发送的信息可以被1转发，这就需要建立2到1的有向边
2. 遍历DFS、BFS？采用BFS更佳。本题主要是求从节点i出发，在L层内可以访问到多少节点，这样定义结构体（节点编号、层号），控制遍历层数不超过L即可

#include <cstdio>
#include <cstring>
#include <vector>
#include <queue>
using namespace std;
const int maxn = 1010;
struct Node{
    int id;
    int layer;
};
vector<Node> Adj[maxn];         //邻接表存储
bool inq[maxn] = {false};       //顶点是否已被加入过队列，仅存储顶点id即可

int BFS(int s, int L){
    int numForward = 0;         //转发数
    queue<Node> q;
    Node start;
    start.id = s;
    start.layer = 0;
    q.push(start);
    inq[start.id] = true;
    while(!q.empty()){
        Node topNode = q.front();
        q.pop();
        int u = topNode.id;
        for(int i = 0; i < Adj[u].size(); i++){
            Node next = Adj[u][i];
            next.layer = topNode.layer + 1;
            //如果next的编号从未加入过队列，且next的层次不超过L
            if(inq[next.id] == false && next.layer <= L){
                q.push(next);
                inq[next.id] = true;
                numForward++;
            }
        }
    }
    return numForward;
}

int main(){
    Node user;
    int n, L, numFollow, idFollow;
    scanf("%d%d", &n, &L);
    for(int i = 1; i <= n; i++){
        user.id = i;
        scanf("%d", &numFollow);
        for(int j = 0; j < numFollow; j++){
            scanf("%d", &idFollow);
            Adj[idFollow].push_back(user);
        }
    }
    int numQuery, s;
    scanf("%d", &numQuery);
    for(int i = 0; i < numQuery; i++){
        memset(inq, false, sizeof(inq));        //每一次查询之前都要初始化
        scanf("%d", &s);                        //起始结点编号
        int numForward = BFS(s, L);
        printf("%d\n", numForward);
    }
    return 0;
}