1076 Forwards on Weibo （30 分）_vmprotect 多开-CSDN博客

本文链接：https://blog.csdn.net/SourDumplings/article/details/87561771

本文介绍了一个算法，用于计算微博平台上特定用户在限定间接关注者层级内的最大潜在转发量。通过广度优先搜索（BFS）策略，算法考虑了每个用户及其关注者的转发能力，避免了重复计算和超时问题。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

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 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:

Sample Output:

4
5

C++:

/*
 @Date    : 2018-08-31 22:41:48
 @Author  : 酸饺子 (changzheng300@foxmail.com)
 @Link    : https://github.com/SourDumplings
 @Version : $Id$
*/

/*
https://pintia.cn/problem-sets/994805342720868352/problems/994805392092020736
注意不能使用dfs，因为若是dfs的话，假设用户0发微博，要计算L = 3的情况：
      0
     / \
    1   3
   /   / \
  2   2   4
 /
3
在dfs的过程中，为避免重复则必须将计算过的进行标记，否则会在走右边路径时再通过一次2
沿着左路径走到3即为第三层，便将3计算在内，这将导致4不能被计算
如果不标记只按层数算的话就会超时，用Dijkstra也会超时
 */

#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <queue>
#include <map>

using namespace std;

const int MAXN = 1005;
int N, L;
vector<int> fans[MAXN];
int effectedNum;
bool effected[MAXN];

void bfs(int q)
{
    queue<pair<int, int>> Q;
    Q.push(pair<int, int>(q, 0));
    while (!Q.empty())
    {
        auto pv = Q.front(); Q.pop();
        if (!effected[pv.first])
        {
            effected[pv.first] = true;
            if (pv.second > 0)
                ++effectedNum;

            if (pv.second < L)
            {
                for (int f : fans[pv.first])
                {
                    if (!effected[f])
                        Q.push(pair<int, int>(f, pv.second + 1));
                }
            }
        }
    }
    return;
}


int main(int argc, char const *argv[])
{
    scanf("%d %d", &N, &L);
    for (int i = 0; i != N; ++i)
    {
        int m;
        scanf("%d", &m);
        for (int j = 0; j != m; ++j)
        {
            int v;
            scanf("%d", &v);
            fans[v].push_back(i+1);
        }
    }
    int k;
    scanf("%d", &k);

    for (int i = 0; i != k; ++i)
    {
        int q;
        scanf("%d", &q);
        fill(effected, effected + N + 1, false);
        effectedNum = 0;
        bfs(q);
        printf("%d\n", effectedNum);
    }
    return 0;
}