阿里巴巴2018校招笔试题

前几天做了阿里的2018的校招笔试题，我投的岗位是Java研发，在这里跟大家分享下笔试题及我的解法。

1、 题目

由于当时时间比较紧，只有四十分钟，但是题目也只有一道，可能我比较渣，所以时间很赶，没来得及截图，下面是我对题目的大致记忆。

大致意思是给定一组树节点，形式为（id, pId, cost），其中id是节点的序号，pId是父节点的序号，cost是花费，即完成这件事情所需的花费。给定的节点可以构成一棵树或者一个森林，需要求出树或森林中最大的花费是多少。举例如下：
给定节点：
1, 0, 2
2, 1, 3
3, 1, 2
4, 0, 3
构成如下森林：

(1, 0, 2)               (4, 0, 3)
_____|_____
|           |
(2, 1, 3)     (3, 1, 2)

耗费最大的肯定在叶节点，id=2的节点总花费为父节点2+本身花费3=5，以此类推，id=3的节点花费为4，id=4的节点花费为3，所以给定这组节点花费的最大花费是5。

（我描述的可能不是很准确，大致意思吧）

2、 思路

我刚看到题目的第一个想法就是定义一个节点类Node，然后将给定节点实例化成一个一个的节点放入List中，然后找出叶子节点，最后对对叶子节点的花费进行统计。发现这种思路需要很多List遍历，太耗费时间，于是尝试思考其他解法。

经过几分钟思考，我觉得可以优化第一种思路，同样定义一个节点类Node，然后将给定节点实例化成一个一个的节点放入Map中，Map的key取节点id，value是Node对象。Node对象中包含节点中给定的id、pId和cost，另外加入一个标志字段isLeaf来标识这个节点是否为叶子节点。首先将给定节点放入Map中，然后遍历Map中所有元素，找到叶子节点，同时统计叶子节点的花费。由于通过Map找到父节点可以直接Map.get(pId)，所以可以节省很多时间。

由于时间有限，没有时间再去思考太多，于是开始动手。

3、 实现

下面是我的具体实现：

注： main方法已经被实现好，就是获取输入和调用resolve方法，resolve也已经被定义好了，这里main方法是的简化写法。

public class AliTest {

public static void main(String[] args) {
// 待输入list
ArrayList<Integer> idList = new ArrayList<>();
ArrayList<Integer> pIdList = new ArrayList<>();
ArrayList<Integer> costList = new ArrayList<>();

// 手动构造测试数据
idList.add(1);
idList.add(2);
idList.add(3);
idList.add(4);

pIdList.add(0);
pIdList.add(1);
pIdList.add(1);
pIdList.add(0);

costList.add(2);
costList.add(3);
costList.add(2);
costList.add(3);

int get = resolve(idList, pIdList, costList);
System.out.println(get);
}

public static int resolve(ArrayList<Integer> ids, ArrayList<Integer> parents, ArrayList<Integer> costs) {
Map<Integer, Node> nodeMap = new HashMap<>();
for(int i = 0; i < ids.size(); i++) {
Node node = new Node();
node.setId(ids.get(i));
node.setParentId(parents.get(i));
node.setCost(costs.get(i));
node.setIsleaf(1);
if(nodeMap.containsKey(parents.get(i))) {
Node pNode = nodeMap.get(parents.get(i));
pNode.setIsleaf(0);
nodeMap.put(parents.get(i), pNode);
}
nodeMap.put(ids.get(i), node);
}

List<Integer> costList = nodeMap.values()
.stream()
.filter(node -> node.getIsleaf() == 1)
.map(node -> {
int myCost = node.getCost();

int pId = node.getParentId();
while(pId != 0) {
Node pNode = nodeMap.get(pId);
myCost += pNode.getCost();
pId = pNode.getParentId();
}
return myCost;
}).collect(Collectors.toList());

return costList.stream().max((h1, h2) -> h1.compareTo(h2)).get();

}

// 树节点
static class Node {
private int id; //id
private int parentId; // 父id
private int cost; // 花费
private int isleaf; // 是否为叶节点，1表示是叶节点，0表示不是叶节点

public int getId() {
return id;
}

public void setId(int id) {
this.id = id;
}

public int getParentId() {
return parentId;
}

public void setParentId(int parentId) {
this.parentId = parentId;
}

public int getCost() {
return cost;
}

public void setCost(int cost) {
this.cost = cost;
}

public int getIsleaf() {
return isleaf;
}

public void setIsleaf(int isleaf) {
this.isleaf = isleaf;
}
}

}

4、 总结

当时写完已经没时间测试了，直接贴上去交了。晚上我回来测试了一下，居然错了，我检查了一下，原来将 resolve()方法中的

node.setIsleaf(1);

错写成

node.setId(1);

了，心累。

这个题目总体来说难度不是很大，主要是平时思考得比较少，最后取最大的时候max()方法不熟悉，花了好几分钟，总体来说就是自己能力还亟待提高。

以上思路和实现只是我个人的一点想法，如有不对之处，还望大神指教。当然如果哪位大神有更好的思路和解法，也望不吝赐教，不胜感激！