2018届实习-阿里巴巴内推编程题

对于一个由一位十进制整数构成的二叉树，如果深度不超过4，可以用一个三位十进制整数构成的数组表示，具体规则如下：

1、百位数表示树的层次L，1<=L<=4;十位数表示在该层次中的位置P，1<=P<=8;个位数表示数值V。

2、数组里，L一定是单增的，也就是说后一个数的L大于等于前一个数的L；

3、对于同一个L，P也是单增的，就是说在L不变的情况下，后一个数的P大于等于前一个数的P。

例如：[ 113, 215, 221 ]

      3

    /    \

 5       1

现在要求这个树所有到叶子节点的路径和，对于例子中，路径和为 （3+5）+（3+1）=12

题目的意思就是给出了几个三位数，比如 113 ，代表的是深度为1 ，左边第1个的数值 为 3 ； 215表示深度为2，左边第1个的数值为5 。。。。。。

不过多啰嗦了，解题思路就是将这个三位数数组转变为满二叉树数组，根据百位和十位推断出其数值 在满二叉树数组 的位置，然后递归求所有路径和。

百位（a）    十位（b）     数组中位置（index）

1            1           1

2            1           2

2            2           3

3            1           4

...........

可以推出公式： index  = pow（2，a-1）+b-1

二叉树的递归遍历会的话，跟在二叉树数组中递归遍历差不多。

附上代码：

import java.util.ArrayList;
import java.util.Scanner;
public class Solution {
	public static void main(String[] args){
		ArrayList<Integer> inputs = new ArrayList<Integer>();
		Scanner in = new Scanner(System.in);
		String line = in.nextLine();
		while(line!=null && !line.isEmpty()){
			int value = Integer.parseInt(line);
			if(value==0)
				break;
			inputs.add(value);
			line = in.nextLine();
		}
		
		int[] A = new int[inputs.size()];
		for(int i=0;i<inputs.size();i++){
			A[i]=inputs.get(i).intValue();
		}
		int res = resolve(A);
		System.out.println(res);
	}
	
	public static int resolve(int[] A){	
		ArrayList<Integer> tmp= new ArrayList<Integer>();
		ArrayList<ArrayList<Integer>> t = new ArrayList<ArrayList<Integer>>();
		int nlen = A.length;
		int[] bai = new int[nlen];
		int[] shi = new int[nlen];
		int[] ge = new int[nlen];
		for(int i=0;i<nlen;i++){
			bai[i]=A[i]/100;
			shi[i]=A[i]/10%10;
			ge[i]=A[i]%10;
		}		
		int[] treeArray = new int[16];
		for(int i=0;i<16;i++){
			treeArray[i]=Integer.MIN_VALUE;
		}
		for(int i=0;i<nlen;i++){
			int loc = (int) Math.pow(2, bai[i]-1)+shi[i]-1;
			treeArray[loc]= ge[i];
		}
		
		helper(treeArray,1,t,tmp);
		
		int r = 0;
		for(int i=0;i<t.size();i++){
			for(int j=0;j<t.get(i).size();j++)
				r += t.get(i).get(j);
		}
				
		return r;
	}
	
	public static void helper(int[] treeArray,int index,ArrayList<ArrayList<Integer>> ret,ArrayList<Integer> tmp){
		if(treeArray[index]!=Integer.MIN_VALUE)
			tmp.add(treeArray[index]);
		
		if(treeArray[2*index]==Integer.MIN_VALUE && treeArray[2*index+1]==Integer.MIN_VALUE)
		{
			ret.add(new ArrayList<Integer>(tmp));			
			return ;
		}		
		if(treeArray[2*index]!=Integer.MIN_VALUE){
			helper(treeArray,2*index,ret,tmp);
			tmp.remove(tmp.size()-1);
		}
		if(treeArray[2*index+1]!=Integer.MIN_VALUE){
			helper(treeArray,2*index+1,ret,tmp);
			tmp.remove(tmp.size()-1);
		}
	}
}