首页 > > 程序设计 > Java技术 >

可达用户投资额的计算（Java）

2018-09-18 06:33:40来源：博客园阅读 ()

有话要说：

前阵子遇到了一个计算可达用户投资额的问题，觉得非常有趣，故把它记录下来。

问题描述：

某产品可被投资，注册后才可以投资，其注册可以被邀请（并不是每个人都是被邀请的）。邀请人可以邀请多个人注册投资，而被邀请人只能有一位邀请人。也就是说邀请人与被邀请人是一对多的关系。

现给定两组数据：邀请与被邀请的关系；所有用户的投资额。

如下：

1,2
1,4
2,11
2,10
4,5
5,6
6,8
6,9
6,7
13,14
13,15
13,17
14,20
20,21
15,18
15,19

以上数据是处理过后的邀请关系，前者邀请了后者。

以上数据是处理过后的所有用户投资额。

现在根据这两组数据需要计算每位用户的“用户投资金额”，“可达用户投资金额”，“邀请用户阶数”，“成功邀请用户数”，“一阶推荐用户投资金额”。

用户投资金额：即该用户的投资额，以以上数据举个例子来说：2的投资金额为2300

可达用户投资金额：即该用户的投资额加上该用户邀请的所有人的投资额（包括该用户邀请人所邀请的人），假设A邀请了B和C，B邀请了D和E，C、D、E没有邀请别人，那么A的可达用户投资金额就是A、B、C、D、E投资额的总数

邀请用户阶数：即该用户所邀请人的总数（不包括该用户邀请人所邀请的人），假设A邀请了B和C，B邀请了D和E，C、D、E没有邀请别人，那么A的邀请用户阶数为2

成功邀请用户数：在邀请用户阶数的基础上除去投资额为零的用户

一阶推荐用户投资金额：即该用户所邀请人的总投资额（不包括该用户邀请人所邀请的人），假设A邀请了B和C，B邀请了D和E，C、D、E没有邀请别人，那么A的一阶推荐用户投资金额为B、C投资额的总数

大家可以先想想如何处理该数据

思路分析：

首先根据邀请的关系可以分析出邀请人的关系图可以分解为多棵不相关的树（反证法可证）。

邀请关系如下图所示：

因此可以先将数据生成若干棵树，然后针对于树进行遍历。

对于每棵树来说，父节点的可达用户投资金额就是子节点的可达用户投资金额之和再加上父节点的投资额，根据这一特性，可以对每棵树从叶子节点网上遍历。

代码实现：

获取所有用户的投资额：

直接读取文件，并把用户id与用户投资额放在Map集合中

 1 // 获取每个人的投资额
 2 public static Map<String, Double> getAmount() {
 3     Map<String, Double> amounts = new HashMap<String, Double>();
 4 
 5     File file = new File("D:/amount.txt");
 6 
 7     try {
 8         // 创建输入流，读取txt
 9         InputStream is = new FileInputStream(file.getAbsolutePath());
10         InputStreamReader isr = new InputStreamReader(is, "UTF-8");
11 
12         BufferedReader br = new BufferedReader(isr);
13         String line = "";
14         while ((line = br.readLine()) != null) {
15             String[] amount = line.trim().split(",");
16             amount[0] = amount[0].trim();
17             amounts.put(amount[0], Double.parseDouble(amount[1]));
18         }
19 
20         br.close();
21         isr.close();
22         is.close();
23 
24     } catch (FileNotFoundException e) {
25         e.printStackTrace();
26     } catch (IOException e) {
27         e.printStackTrace();
28     }
29     return amounts;
30 }

获取用户的邀请关系：

直接读取文件，并把用户的邀请关系放在List集合中

 1 // 获取关系数据集合
 2 public static List<String[]> getRelationship() {
 3     List<String[]> list = new ArrayList<String[]>();
 4 
 5     File file = new File("D:/relationship.txt");
 6 
 7     try {
 8         // 创建输入流，读取txt
 9         InputStream is = new FileInputStream(file.getAbsolutePath());
10         InputStreamReader isr = new InputStreamReader(is, "UTF-8");
11 
12         BufferedReader br = new BufferedReader(isr);
13         String line = "";
14         while ((line = br.readLine()) != null) {
15             String[] relation = line.trim().split(",");
16             relation[0] = relation[0].trim();
17             relation[1] = relation[1].trim();
18             list.add(relation);
19         }
20 
21         br.close();
22         isr.close();
23         is.close();
24 
25     } catch (FileNotFoundException e) {
26         e.printStackTrace();
27     } catch (IOException e) {
28         e.printStackTrace();
29     }
30     return list;
31 }

构造Person对象：

 1 // 用户邀请关系(前者邀请了后者)
 2 List<String[]> relationships = new ArrayList<>();
 3 relationships = getRelationship();
 4 
 5 // 每个用户投资额
 6 Map<String, Double> amounts = new HashMap<String, Double>();
 7 amounts = getAmount();
 8 
 9 // 构造用户信息
10 Map<String, Person> persons = new HashMap<String, Person>();
11 Iterator<String> it = amounts.keySet().iterator();
12 while (it.hasNext()) {
13     String key = it.next();
14 
15     Person temp = new Person();
16     temp.setId(key);
17     temp.setAmount(amounts.get(key));
18 
19     persons.put(key, temp);
20 }

其中Person类为：

 1 class Person {
 2 
 3     /**
 4      * 用户id
 5      */
 6     private String id;
 7 
 8     /**
 9      * 邀请人列表
10      */
11     private List<Person> invitedPersons = new ArrayList<Person>();
12 
13     /**
14      * 投资额
15      */
16     private double amount;
17 
18     /**
19      * 所有下线投资额总额（包括自身）
20      */
21     private double allAmount;
22 
23     public String getId() {
24         return id;
25     }
26 
27     public void setId(String id) {
28         this.id = id;
29     }
30 
31     public double getAmount() {
32         return amount;
33     }
34 
35     public void setAmount(double amount) {
36         this.amount = amount;
37     }
38 
39     public List<Person> getInvitedPersons() {
40         return invitedPersons;
41     }
42 
43     public void setInvitedPersons(List<Person> invitedPersons) {
44         this.invitedPersons = invitedPersons;
45     }
46 
47     public double getAllAmount() {
48         return allAmount;
49     }
50 
51     public void setAllAmount(double allAmount) {
52         this.allAmount = allAmount;
53     }
54 
55 }

构建邀请关系：

 1 for (int i = 0; i < relationships.size(); i++) {
 2     String[] relationship = relationships.get(i);
 3 
 4     // 获取邀请人
 5     Person person1 = persons.get(relationship[0]);
 6     // 获取被邀请人
 7     Person person2 = persons.get(relationship[1]);
 8     // 加上关联关系
 9     person1.getInvitedPersons().add(person2);
10 }

根据以上的构造，已经针对于每个用户都生成了一棵树。

但事实上这些树有大量的重合，如果逐一遍历的话会导致不必要的浪费。

于是准备找出所有的根树，遍历根数即可。

找到所有的根树：

 1 // 所有person集合
 2 List<Person> allPerson = new ArrayList<>();
 3 allPerson.addAll(persons.values());
 4 
 5 // 找到根节点，去除非根节点
 6 for (int i = 0; i < relationships.size(); i++) {
 7     String[] relationship = relationships.get(i);
 8 
 9     // 如果是被邀请人，则去除
10     persons.remove(relationship[1]);
11 }

根据以上精简，persons集合里只有根节点。

遍历根数，找出所有人的可达用户投资金额：

Iterator<Person> it4 = persons.values().iterator();
while (it4.hasNext()) {
    Person person = it4.next();
    addAllChildren(person);
}

其中addAllChildren为

 1 // 可达用户投资金额
 2 public static double addAllChildren(Person person) {
 3     double childrenAmount = 0;
 4 
 5     // 先加自己的
 6     childrenAmount += person.getAmount();
 7 
 8     // 再加孩子的
 9     for (int i = 0; i < person.getInvitedPersons().size(); i++) {
10         Person child = person.getInvitedPersons().get(i);
11 
12         if (child.getInvitedPersons().size() > 0) {
13             childrenAmount += addAllChildren(child);
14         } else {
15             childrenAmount += child.getAmount();
16         }
17     }
18 
19     person.setAllAmount(childrenAmount);
20 
21     return childrenAmount;
22 }

通过此遍历，每个person对象的可达用户投资金额均已被算出，又因为java是值传递的，所以allPerson内的person对象的值都已经被计算出来了。

接下来就可以遍历所有的person对象了。

遍历person集合，算出需要的所有数据：

 1 try {
 2     String path = "D:/result.txt";
 3     File file = new File(path);
 4     if (!file.exists()) {
 5         file.getParentFile().mkdirs();
 6     }
 7     file.createNewFile();
 8 
 9     // write
10     FileWriter fw = new FileWriter(file, true);
11     BufferedWriter bw = new BufferedWriter(fw);
12 
13     Iterator<Person> it3 = allPerson.iterator();
14 
15     while (it3.hasNext()) {
16         Person person = it3.next();
17 
18         if (person.getAllAmount() == 0) {
19             bw.write("可达用户投资总额：" + person.getAmount() + "；");
20         } else {
21             bw.write("可达用户投资总额：" + person.getAllAmount() + "；");
22         }
23 
24         bw.write("邀请用户阶数：" + person.getInvitedPersons().size() + "；");
25 
26         int count = 0;
27         double sum = 0;
28         for (Person temp : person.getInvitedPersons()) {
29             if (temp.getAmount() != 0) {
30                 sum += temp.getAmount();
31                 count++;
32             }
33         }
34 
35         bw.write("成功邀请用户数：" + count + "；");
36         bw.write("一阶推荐用户投资金额：" + sum + "；\n");
37     }
38 
39     bw.flush();
40     bw.close();
41     fw.close();
42 } catch (Exception e) {
43     e.printStackTrace();
44 }