【PAT】A1076 Forwards on Weibo【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个用户和他们关注的用户，以及一个L次的转发限制。假设所有用户都转发关注用户的信息，对于K个查询，求源用户发出一条消息后，最多有几名用户可以看到该条消息。

思路

BFS搜索即可。首先要搞清楚路径的方向，假设B用户关注A用户，边的方向应该是A->B。在BFS搜索中，我们每一轮都将一层结点取出，对于每一个结点进行如下步骤：

• 如果该结点未被访问，则将其标记为已访问，计数器累加，将其未被访问的相邻结点加入到队列中。
• 将该结点从队列中移除。

这样循环L次后，再减去1（因为在上述遍历中我们将源用户也算进去了）即得到结果。

代码1

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#define MAX_N 1000
using namespace std;

int main() {
    int N, L;
    vector<int> G[MAX_N + 1];
    bool marked[MAX_N];
    scanf("%d %d", &N, &L);
    for(int i = 1, m, follow; i <= N; i++){
        scanf("%d", &m);
        for(int j = 0; j < m; j++){
            scanf("%d", &follow);
            G[follow].push_back(i);
        }
    }
    
    int K;
    scanf("%d", &K);
    for(int i = 0, query, level, cnt; i < K; i++){
        level = 0;
        cnt = 0;
        fill(marked + 1, marked + N + 1, false);
        queue<int> q;
        
        scanf("%d", &query);
        
        q.push(query);
        marked[query] = true;
        //广度优先搜索L+1次遍历L层以内的点
        while (!q.empty() && level++ <= L) {
            for(int i = 0, u, l = (int)q.size(); i < l; i++){
                u = q.front();
                cnt++;
                 for(int v : G[u]){
                        if(!marked[v]){
                            q.push(v);
                            marked[v] = true;
                        }
                    }
                q.pop();
            }
        }
        
        
        // 减去1（自身）即得到结果
        printf("%d\n", cnt - 1);
    }
    return 0;
}

代码2

使用更一般的写法，使用结构体记录层次。速度比上面的快一点点。

#include <cstdio>
#include <vector>
#include <queue>
#include <algorithm>
#define MAX_N 1000
using namespace std;
struct Node{
    int id, L;
    Node(int id, int L) : id(id), L(L){};
};
int main() {
    int N, L;
    vector<int> G[MAX_N + 1];
    bool marked[MAX_N];
    scanf("%d %d", &N, &L);
    for(int i = 1, m, follow; i <= N; i++){
        scanf("%d", &m);
        for(int j = 0; j < m; j++){
            scanf("%d", &follow);
            G[follow].push_back(i);
        }
    }
    
    int K;
    scanf("%d", &K);
    for(int i = 0, query, level, cnt; i < K; i++){
        level = 0;
        cnt = 0;
        fill(marked + 1, marked + N + 1, false);
        
        scanf("%d", &query);
        
        queue<Node> q;
        q.push(Node(query, 0));
        marked[query] = true;
        while (!q.empty()) {
            int l = q.front().L, id = q.front().id;
            q.pop();
            cnt++;
            if(l == L) continue;
            for(int to : G[id]){
                if(!marked[to]){
                    q.push(Node(to, l + 1));
                    marked[to] = true;
                }
            }
        }
        
        
        // 减去1（自身）即得到结果
        printf("%d\n", cnt - 1);
    }
    return 0;
}