Java-PAT-1076.Forwards on Weibo 【Java实现】

网上都是c++版本的，所以我用Java写的不一定是最好的。如果大家有其他解法欢迎留言讨论

共勉！

题目：

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

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

1，邻接表存储图；

2，应用深度优先搜索，但是有深度的限定。

要注意：题目所给的形式不能直接建表，要反过来建；

代码如下：

import java.util.ArrayList;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class ForwardsOnWeibo {

	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc = new Scanner(System.in);
		int VER_NUM = sc.nextInt();
		int MAX_LEVEL = sc.nextInt();
		// 数组下标从1到N，下标即为vertex的值
		Vertex[] vertex = new Vertex[VER_NUM + 1];

		// 为数组new节点
		for (int i = 1; i <= VER_NUM; i++) {
			vertex[i] = new Vertex();
		}

		// 建图
		int count = 0;
		for (int i = 1; i <= VER_NUM; i++) {
			count = sc.nextInt();
			for (int j = 1; j <= count; j++) {
				vertex[sc.nextInt()].add_adjacent(vertex[i]);
			}
		}
		
		// 进行bfs，返回结果
		int outputNum = sc.nextInt();
		for (int i = 0; i < outputNum; i++) {
			System.out.println(bfs(vertex, MAX_LEVEL, sc.nextInt()));
		}
		sc.close();

	}

	/**
	 * 修改的广度优先搜索
	 * 
	 * @param vertex
	 * @param MAX_LEVEL
	 * @param root
	 * @return
	 */
	public static int bfs(Vertex[] vertex, int MAX_LEVEL, int root) {
		Queue<Vertex> queue = new LinkedList<Vertex>();
		queue.add(vertex[root]);
		vertex[root].isVisited = true;
		int count = 0;
		int level = 0;
		Vertex last = vertex[root];
		Vertex tail = null;
		Vertex tmpVertex1 = null;
		Vertex tmpVertex2 = null;

		while (!queue.isEmpty() && level < MAX_LEVEL) {
			tmpVertex1 = queue.poll();
			Iterator<Vertex> it = tmpVertex1.adjacent.iterator();
			while (it.hasNext()) {
				tmpVertex2 = it.next();
				if (!tmpVertex2.isVisited) {
					tmpVertex2.isVisited = true;
					queue.add(tmpVertex2);
					tail=tmpVertex2;
					count++;
				}
			}
			if(tmpVertex1==last){
				level++;
				last=tail;
			}
		}
		reset(vertex);
		return count;
	}

	/**
	 * 将vertex.isVisited重置为false
	 * 
	 * @param vertex
	 */
	public static void reset(Vertex[] vertex) {
		for (int i = 1; i < vertex.length; i++)
			vertex[i].isVisited = false;
	}
}

/**
 * 节点类 包括节点值，存储邻节点的矩阵以及访问标志
 * 
 * @author Jacob
 */
class Vertex {
	public boolean isVisited;
	public ArrayList<Vertex> adjacent = null;

	public void add_adjacent(Vertex data) {
		if (adjacent == null)
			adjacent = new ArrayList<Vertex>();
		adjacent.add(data);
	}
}