算法：给一个二叉树，每个节点都有权值，你可以从这个树的节点往下走，到任意节点停止，你得到的分数是走过路径上的权值的异或和

给一个二叉树，每个节点都有权值，你可以从这个树的节点往下走，到任意节点停止，你得到的分数是走过路径上的权值的异或和，求可以获得的最大分数。

---

输入：第一行包含一个整数N,表示节点的数量，接下来N行每一行都有四个值，节点id，节点的权重，左节点id，右节点id。如果左右节点id=-1，表示没有子节点。

输出，可以获得的最大分数。

例子：

5
1 1  2  3
2 4 -1 -1
3 2 -1  4
4 5 -1  5
5 3 -1 -1

输出：7

---

思路：这题和在二叉树里面选取一段路径，求路径和等于给定值的所有路径的题目差不多，相似之处在于，可以从任意节点出发，可以在任意节点结束。这种题目也是使用递归，只不过需要两个递归函数，一个递归函数process（root）用来计算以root为头结点的子树的所有结果，一个递归函数count(root)计算，从root出发的所有可能结果。注意，以root为头结点，不一定从root出发。

看代码把：

public static class Node{
	 public Node left;
	 public	Node right;
	 public	int val;
	 public	int id;
		public Node(int val,int id){
			this.val=val;
			this.id=id;
			this.left=null;
			this.right=null;
		}
	}
	public static HashMap<Integer,Node> map;//key为id，value为node
	public static int res=0;//保存结果
	public static void process(Node head,int xor){//表示以head为头结点的
		if(head==null)
			return ;
		count(head,xor);
		process(head.left,xor);
		process(head.right,xor);
	}
	public static void count(Node node,int xor){//从这个节点出发的异或
		if(node==null) return ;
		int tmp=xor^node.val;
		res=Math.max(res, xor);
		count(node.left,tmp);
		count(node.right,tmp);
		
	}
	public static void main(String[] args) {
		// TODO Auto-generated method stub
		Scanner sc=new Scanner(System.in);
		map=new HashMap<>();
		while(sc.hasNext()){
			int N=sc.nextInt();
			sc.nextLine();
			int[][] info=new int[N][4];
			
			for(int i=0;i<N;i++){
				for(int j=0;j<4;j++){
					info[i][j]=sc.nextInt();
				}
				Node node=new Node(info[i][1],info[i][0]);
				map.put(info[i][0], node);
				
				sc.nextLine();
			}
			Node head=null;
			for(int i=0;i<info.length;i++){
				int left=info[i][2];
				int right=info[i][3];
				int id=info[i][0];
				Node node=map.get(id);
				node.left=left==-1?null:map.get(left);
				node.right=right==-1?null:map.get(right);
				if(i==0){
					head=node;
				}
			}
			process(head,0);
			System.out.println(res);
	
		}
	}