|邻接表bfs遍历图|1076 Forwards on Weibo (30分)

link

struct Node{
    int id;
    int h;
}node;

vector<Node> G[N];

 cin>>n>>l;
    for(int i=1;i<=n;i++){
        int k;
        cin>>k;
        node.id=i;
        for(int j=0;j<k;j++){
            int tmp;
            cin>>tmp;
            G[tmp].push_back(node);// node.id=tmp;
        }
    }
    
 int q;
    cin>>q;
    for(int i=0;i<q;i++){
        memset(vis,false,sizeof(vis));
        int tmp;
        cin>>tmp;
        int numF=bfs(tmp);
        cout<<numF<<endl;
    }
    
bool vis[N]={false};    
int bfs(int v){
    int num_F=0;
    
    queue<Node> q;
    Node s;
    s.id=v;
    s.h=0;
    q.push(s);
    vis[v]=true;
    
	while(!q.empty()){
        Node now=q.front();
        q.pop();
        for(int i=0;i<G[now.id].size();i++){//G[0]---Node型结构体顶点
             Node next=G[now.id][i];//node.id=i;//G[2][0]G[2][1]..
             next.h=now.h+1;
             if(vis[next.id]==false&&next.h<=l){
                 q.push(next);
                 vis[next.id]=true;
                 num_F++;
             }
        }
    }

#include <iostream>
#include <cstdio>
#include <queue>
#include <cstring>
using namespace std;
const int N=1010;

struct Node{
    int id;
    int layer;
}user;

int n,l;
vector<Node>G[N];
int inq[N]={false};
//int G[N][N]={0};

int bfs(int s){
    int numF=0;
    
    queue<Node>q;
    Node start;
    start.id=s;
    start.layer=0;
    q.push(start);
    inq[start.id]=true;
    
    while(!q.empty()){
        Node now=q.front();
        q.pop();
        int now_id=now.id;
        for(int i=0;i<G[now_id].size();i++){
            Node next = G[now_id][i];//vector<Node>G[N];
            next.layer=now.layer+1;
            if(inq[next.id]==false&&next.layer<=l){
                q.push(next);
                inq[next.id]=true;
                numF++;
            }
        }
    }
    return numF;
}


int main()
{
    cin>>n>>l;
    for(int i=1;i<=n;i++){
        user.id=i;
        int k;
        cin>>k;
        for(int j=0;j<k;j++){
            int isFollowed;
            cin>>isFollowed;
            G[isFollowed].push_back(user);
        }
    }
    int q;
    cin>>q;
    for(int i=0;i<q;i++){
        memset(inq,false,sizeof(inq));
        int tmp;
        cin>>tmp;
        int numF=bfs(tmp);//以给出的顶点来初始节点来遍历图---注意啊
        cout<<numF<<endl;
    }
    return 0;
}

//在微博，当用户发布一条信息时
//他的关注者可以看到这条信息并且选择是否转发它
//且转发的信息可以被被转发者的关注者再次转发
//但是同一用户最多只能转发该信息一次(信息的最初发布者不能转发该信息)

//现在给出N个用户的关注情况(即他们各自关注了哪些用户)
//以及一个转发层数的上限L-----------高度
//并给出最初发布消息的用户编号，球在转发层数上限内最多会被多少用户转发

//咋觉得是求节点数目呢？

//7 3 n用户个数 l转发层数上限
//接下来n行（顶点编号1~n）
//M[i] user_list[i]
//关注者人数，名单----注意啊，给的是关注者，就是说，我在看着你，不是你sj我啊
//3 2 3 4
//0
//2 5 6
//2 3 1
//2 3 4
//1 4
//1 5
//2 2 6


#include <cstdio>
#include <iostream>
#include <vector>
#include <queue>
using namespace std;
const int N = 1010;

struct Node {
	int id;
	int layer;
}user;
vector<Node> Adj[N];

bool inq[N] = {false};
int bfs(int s,int l) {
	int num_f = 0;
	queue<Node>q;
	Node start;
	start.id = s;
	start.layer = 0;
	q.push(start);
	inq[start.id] = true;
	while (!q.empty()) {
		Node now = q.front();
		q.pop();
		int now_id = now.id;
		for (int i = 0; i < Adj[now_id].size(); i++) {
			Node n = Adj[now_id][i];
			n.layer = now.id + 1;
			if (inq[n.id] == false && n.layer <= l) {
				cout << n.id << endl;
				q.push(n);
				inq[n.id] = true;
				num_f++;
			}
		}
	}
	return num_f;
}

int main() {
	int n,l;
	cin >> n >> l;
	for (int i = 1; i <= n; i++) {
		user.id = i;
		int k;
		cin >> k;
		for (int j = 0; j < k;j++) {
			int chase;
			cin >> chase;
			Adj[chase].push_back(user);//我在看着你，你在被我看着
		}
	}
	//查询个数
	int q;
	cin >> q;
	for (int i = 0; i < q; i++) {
		memset(inq, false, sizeof(inq));
		int tmp;
		cin >> tmp;//要查询的点编号--把这个点当作起始顶点
		//cout << tmp << endl;
		int num_forward=bfs(tmp,l);//返回转发数
		cout << num_forward<<endl;
	}
	return 0;
}


/*
1)如何建立图
如果用户X关注了用户Y
则建立Y指向X的有向边
来表示Y发布的消息可以传递到X并被X转发

2）
建立图完毕后，使用dfs和bfs来遍历



//遍历时只能访问一次----每个用户只能转发一次


*/