[华为机试]朋友圈信息转发

最新推荐文章于 2021-03-10 14:43:37 发布

BoilerHouseKing

最新推荐文章于 2021-03-10 14:43:37 发布

阅读量1.6k

点赞数

CC 4.0 BY-SA版权

文章标签： Java

本文链接：https://blog.youkuaiyun.com/guorudi/article/details/44683463

华为机试专栏收录该内容

0 篇文章

订阅专栏

本文探讨了一个社交应用中信息如何高效传播的问题。具体地，分析了如何通过最少次数的信息转发，使得所有用户能在最短时间内接收到信息。文章提供了一种算法实现思路，包括构建用户关系图、使用广度优先搜索进行预处理以及通过二分图匹配来确定最优转发策略。

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

朋友圈转发信息

描述:

在一个社交应用中，两个用户设定朋友关系后，则可以互相收到对方发布或转发的信息。当一个用户发布或转发一条信息时，他的所有朋友都能收到该信息。

现给定一组用户，及用户之间的朋友关系。

问：当某用户发布一条信息之后，为了让每个人都能在最早时间收到这条信息，这条信息最少需要被转发几次？

假设：对所有用户而言：

1）朋友发出信息到自己收到该信息的时延为T（T>0）；

2）如需转发，从收到信息到转发出信息的时延为0。

用例保证：在给定的朋友圈关系中，任何人发布的信息总是能通过N（N>=0）次转发让其他所有用户收到。

例如：

下图表示某个朋友圈关系（节点间连线表示朋友关系）中，用户1在时刻0发布信息之后，两种不同的转发策略。

黄色节点表示转发用户，蓝色数字为用户收到信息的时间。

运行时间限制:

无限制

内存限制:

无限制

输入:

Sender

[消息创建者编号]

Relationship

[朋友关系列表，1,2 表示1和2是朋友关系]

End

如下：

Sender
1
Relationship
1,2
1,3
1,4
2,5
2,6
3,6
4,6
4,7
5,6
5,8
5,9
6,7
6,8
6,9
7,9
10,7
End

输出:

当某用户发布一条信息之后，为了让每个人都能在最早时间收到这条信息，这条信息最少需要被转发的次数

样例输入:

Sender
1
Relationship
1,2
1,3
1,4
2,5
2,6
3,6
4,6
4,7
5,6
5,8
5,9
6,7
6,8
6,9
7,9
10,7
End

样例输出:

答案提示:

可以发现，每个用户接受到信息的时间，是他到起点（消息创建者编号）消息创建着的最短路，故先用最短路预处理。

然后可以发现，收到消息时间为 T 的用户是否选择发布消息，只会影响到 2T的用户，（因为，时间T的用户的儿子一定是时间为2T的用户，因为每个人都要最早收到消息），而影响不到3T、4T......的用户。类似的，2T用户的决策影响3T用户。

那么，问题就简化成选最少的上层用户，让下层每个用户都收到最早消息，也就是一个二分图问题。

从u到v，要求能到达v的每一点，u中需要的最小点数

（以上分析摘自我的牛逼师弟http://www.cnblogs.com/njczy2010/p/4370062.html）

然后利用二分答案求解即可

package 朋友圈转发消息;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedHashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Queue;
import java.util.Scanner;
import java.util.Set;
class Node {

	@Override
	public int hashCode() {
		final int prime = 31;
		int result = 1;
		result = prime * result + val;
		return result;
	}
	@Override
	public boolean equals(Object obj) {
		if (this == obj)
			return true;
		if (obj == null)
			return false;
		if (getClass() != obj.getClass())
			return false;
		Node other = (Node) obj;
		if (val != other.val)
			return false;
		return true;
	}
	int val;
	Node(int val) {
		this.val = val;
	}
	List<Node> next = new ArrayList<>();
}

public class Main {
	static Map<Integer, Node> map = new HashMap<>();
	static Set<Node> used = new HashSet<>();
	static int res = 0;
	public static void bfs(int sender){
		Queue<Node> que = new LinkedList<>();
		Queue<Node> next = new LinkedList<>();
		Node seed = map.get(sender);
		que.add(seed);
		used.add(seed);
		while (!que.isEmpty()) {
			List<Node> father = new ArrayList<>();
			List<Node> son = new ArrayList<>();
			Map<Integer,Node> mapSon = new HashMap<>();
			List<Node> listUse = new ArrayList<>();
			while (!que.isEmpty()) {
				Node n = que.poll();
				Node fa = new Node(n.val);
				father.add(fa);
				List<Node> list = n.next;
				for (Node node : list) {
					if (used.contains(node))
						continue;
					listUse.add(node);
					Node so;
					if(mapSon.containsKey(node.val)){
						so= mapSon.get(node.val);
					}else{
						next.add(node);
						so = new Node(node.val);
						son.add(so);
						mapSon.put(node.val, so);
					}
					fa.next.add(so);
					so.next.add(fa);
				}
			}
			for(Node node:listUse){
				used.add(node);
			}
			// /////
			bGraph(father, son);
			Queue<Node> lin = que;
			que = next;
			next = lin;
		}
	}

	private static void bGraph(List<Node> father, List<Node> son) {
		if(father.size()==1||son.size()==1) {
			res +=1;
			return;
		}
		if(son.size()==0) return;
		int left =1,right = father.size();
		int mid = (left+right)/2;
		while(mid<right){
			can = false;
			sonUsed.clear();
			bGraph(father, son, 0, 0, mid);
			if (can) {
				right = mid;
			} else {
				left = mid+1;
			}
		} 
		res +=mid;
		return;
	}
	
	static Set<Node> sonUsed = new LinkedHashSet<>();
	static boolean can = false;
	private static void bGraph(List<Node> father,List<Node> son,int x,int start,int searchTimes){
		if(can) return;
		if(x==searchTimes){
			if(sonUsed.size()==son.size()){
				can=true;
			}
			return;
		}
		
		for(int i=start;i<father.size();i++){
			Node n = father.get(i);
			List<Node> sonAdd = new ArrayList<>();
			for(int j=0;j<n.next.size();j++){
				Node node = n.next.get(j);
				if(!sonUsed.contains(node)){
					sonUsed.add(n.next.get(j));
					sonAdd.add(node);
				}
				
			}
			bGraph(father,son,x+1,i+1,searchTimes);
			for(int j=0;j<sonAdd.size();j++){
				sonUsed.remove(sonAdd.get(j));
			}
		}
	}

	public static void main(String args[]) {
/*		Scanner sc=null;
		try {
			sc = new Scanner(new FileInputStream("D://desktop//test.txt"));
		} catch (FileNotFoundException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}*/
		Scanner sc = new Scanner(System.in);
		String dummy = sc.next();
		int sender = sc.nextInt();
		String dummy2 = sc.next();
		String friend = sc.next();
		while (!friend.endsWith("End")) {
			String[] str = friend.split(",");
			int a = Integer.parseInt(str[0]);
			int b = Integer.parseInt(str[1]);
			if (a == b) {
				friend = sc.next();
				continue;
			}
			Node na;
			Node nb;
			if (map.containsKey(a)) {
				na = map.get(a);
			} else {
				na = new Node(a);
				map.put(a, na);
			}
			if (map.containsKey(b)) {
				nb = map.get(b);
			} else {
				nb = new Node(b);
				map.put(b, nb);
			}
			na.next.add(nb);
			nb.next.add(na);
			friend = sc.next();
		}
		bfs(sender);
		System.out.println(res-1);
		sc.close();
	}
}