第一题60分
    第二题时间不够，第二题如下：

    1. import java.util.*;
    2. public class Main{
    3.     public static int count2;
    4.     public static void main(String[] args){
    5.         Scanner scanner=new Scanner(System.in);
    6.         int n=Integer.parseInt(scanner.nextLine());
    7.         Set<Node> set2=new HashSet<>();
    8.         String tar=scanner.nextLine();
    9.         for(int i=0;i<n;i++){
    10.             String[] s=scanner.nextLine().split(" ");
    11.             Node temp0=null;
    12.             for(Node node:set2){
    13.                 if(node.val.equals(s[0])){
    14.                     temp0=node;
    15.                 }
    16.             }
    17.             if(temp0==null){
    18.                 temp0=new Node(s[0]);
    19.                 set2.add(temp0);
    20.             }
    21.             if("null".equals(s[1])){//1.字符串的"null"，不是null 2.字符串判断相等一定要用equals，不要用==
    23.             }else{
    24.                 Node temp1=null;
    25.                 for(Node node:set2){
    26.                     if(node.val.equals(s[1])){
    27.                         temp1=node;
    28.                         break;
    29.                     }
    30.                 }
    31.                 if(temp1==null){
    32.                     Node temp=new Node(s[1]);
    33.                     set2.add(temp);//不要忘记把new出来的对象加入set
    34.                     temp.next.add(temp0);
    35.                     temp0.pre=temp;
    36.                 }else{
    37.                     temp1.next.add(temp0);
    38.                     temp0.pre=temp1;
    39.                 }
    40.             }
    41.             if("null".equals(s[2])){
    43.             }else{
    44.                 Node temp2=null;
    45.                 for(Node node:set2){
    46.                     if(node.val.equals(s[2])){
    47.                         temp2=node;
    48.                         break;
    49.                     }
    50.                 }
    51.                 if(temp2==null){
    52.                     Node temp=new Node(s[2]);
    53.                     set2.add(temp);
    54.                     temp0.next.add(temp);
    55.                     temp.pre=temp0;
    56.                 }else{
    57.                     temp0.next.add(temp2);
    58.                     temp2.pre=temp0;
    59.                 }
    60.             }
    62.         }
    63.         Node target=null;
    64.         for(Node node:set2){
    65.             if(tar.equals(node.val)){
    66.                 target=node;
    67.                 break;
    68.             }
    69.         }
    70.         dfs(target,0);
    71.         int count1=0;
    72.         while(target!=null){
    73.             count1++;
    74.             target=target.pre;
    75.         }
    76.         System.out.println(count1+count2);
    79.     }
    80.     public static void dfs(Node node,int idx){
    81.         //千万不要写成node.next==null,首先当上一个dfs的node.next容量为0时根本不会进入for循环内部
    82.         //从而进入不到当前的dfs的判断条件
    83.         //其次由于我默认给next属性赋了初始值，所以它不会为null，最原始的状态的容量为0
    84.         if(node.next.size()==0){
    85.             count2=Math.max(count2,idx);
    86.             return;
    87.         }
    88.         for(Node nod:node.next){
    89.                 dfs(nod,idx+1);
    90.         }
    91.     }
    92. }
    93. class Node{
    94.     public Set<Node> next=new HashSet<>();
    95.     public Node pre;
    96.     public String val;
    97.     public Node(String val){
    98.         this.val=val;
    99.     }
    100. }
    1. 8
    2. d2
    3. d1 null d2
    4. d2 d1 d3
    5. d2 d1 d4
    6. d2 d1 d5
    7. d3 d2 null
    8. d4 d2 null
    9. d5 d2 d6
    10. d6 d5 null
    11. 第一个参数8指的是关系的项数
    12. 第二个参数d2是要查找的设备
    13. 之后的8行是关系
    14. 比如d2 d1 d3表示d2的流入设备是d1，d2的流出设备是d3
    15. 比如d1 null d2 表示d1没有流入设备，d1的流出设备是d2
    16. 一个设备只能有一个流入设备，但是可以有多个流出设备
    18. 求d2的链路最长有多长？
    20. 我的思路是构造双向链表，其中next是一个set<node>集合
    21. pre是一个node节点,
    22. 主要就是把这个双向链表先构建出来
    23. 然后就是根据d2的pre一直找到根设备，即该设备的pre为null，然后再根据d2的next找到最远的设备，
    24. 然后两个流程中计算的值相加就是d2所在的链路的最长值。