1076 Forwards on Weibo（BFS）

二脸

已于 2022-02-26 21:12:34 修改

阅读量266

点赞数

分类专栏： PAT 算法笔记文章标签：宽度优先

于 2022-02-26 20:38:51 首次发布

本文链接：https://blog.youkuaiyun.com/adoge_/article/details/123155504

版权

PAT 同时被 2 个专栏收录

41 篇文章

订阅专栏

算法笔记

21 篇文章

订阅专栏

1076 Forwards on Weibo (30 分)

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:

Sample Output:

4
5

思路：先记录每个博主有哪些粉丝，然后广度优先，遍历每个粉丝，直到已被访问过或者超过了最大层数。

注意：每次查询开始前要对vis（是否访问过）这个数组初始化。

数组初始化：memset，fill函数都可以，memset主要用于0 、-1、inf

(18条消息) 【C++】fill函数，fill与memset函数的区别_柳婼の blog-优快云博客_fill和memset

#include <iostream>
#include <cstring>
#include "queue"
#include "vector"
using namespace std;
const int maxx=1100;
int N,L;
struct node{
    int id;
    int  level;
};
vector<node> follow[maxx];
bool vis[maxx]={false};
int BFS(int s){
    int numforwards=0;
    queue<node> m;
    node start={s,0};
    m.push(start);
    vis[start.id] = true;
    while (!m.empty()){
        node top = m.front();
        m.pop();
        for (int i = 0; i < follow[top.id].size();++i) {
            node next = follow[top.id][i];
            next.level = top.level+1;
            if (vis[next.id]== false && next.level<=L){
                m.push(next);
                vis[next.id] = true;
                numforwards++;
            }
        }
    }
    return numforwards;
}
int main() {
    cin>>N>>L;
    int temp,follower;
    for (int i = 1; i <= N; ++i) {
        cin>>temp;
        for (int j = 0; j < temp; ++j) {
            node user;
            user.id = i;
            cin>>follower;
            follow[follower].push_back(user);
        }
    }
    int K,query;
    cin>>K;
    for (int i = 0; i < K; ++i) {
        memset(vis, false,sizeof(vis));
        cin>>query;
        int ans = BFS(query);
        cout<<ans<<endl;
    }
}