vivo笔试题（含答案）

总结不易，如果对你有帮助，请点赞关注支持一下
微信搜索程序dunk，关注公众号，定期分享Java笔试、面试题

编译依赖问题(90% -> AC)

一个完整的软件项目往往会包含很多由代码和文档组成的源文件。编译器在编译整个项目的时候，可能需要按照依赖关系来依次编译每个源文件。比如，A.cpp 依赖 B.cpp，那么在编译的时候，编译器需要先编译 B.cpp，才能再编译 A.cpp。 假设现有 0，1，2，3 四个文件，0号文件依赖1号文件，1号文件依赖2号文件，3号文件依赖1号文件，则源文件的编译顺序为 2,1,0,3 或 2,1,3,0。现给出文件依赖关系，如 1,2,-1,1，表示0号文件依赖1号文件，1号文件依赖2号文件，2号文件没有依赖，3号文件依赖1号文件。请补充完整程序，返回正确的编译顺序。注意如有同时可以编译多个文件的情况，按数字升序返回一种情况即可，比如前述案例输出为：2,1,0,3

输入例子1:

"1,2,-1,1"

输出例子1:

"2,1,0,3"

自己的做法

比较迷，看到这道题第一反应，这不是并查集吗，奥不对，并查集是只能找到最顶级的依赖，这个题明显不是这个意思，然后自己做了一个多叉树吧，应该叫字典树吧，每个节点保存当前信息和所有依赖它的节点信息，用一个list集合存放所有的顶级节点，最终dfs输出就行，只通过了90%

import java.util.*;


public class Solution {
   
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 编译顺序
     * @param input string字符串 
     * @return string字符串    
     */
    StringBuilder builder = new StringBuilder();
    public String compileSeq (String input) {
   
        // write code here
        Map<Integer, DependTree> map = new HashMap();
        List<Integer> res = new ArrayList<>();
        String[] depends = input.split(",");
        for (int i = 0; i < depends.length; i++) {
   
            int child = i;
            int parent = Integer.parseInt(depends[i]);
            if (parent == -1) {
   
                res.add(child);
                if (!map.containsKey(child))
                    map.put(child, new DependTree(child));
                continue;
            }
            if (map.containsKey(parent)) {
   
                DependTree PT = map.get(parent);
                DependTree CP = null;
                if (map.containsKey(child)) {
   
                     CP = map.get(child);
                } else {
   
                    CP = new DependTree(child);
                    map.put(child, CP);
                }
                PT.child.add(CP);
            } else {
   
                DependTree PT = new DependTree(parent);
                map.put(parent, PT);
                DependTree CP = null;
                if (map.containsKey(child)) {
   
                    CP = map.get(child);
                } else {
   
                    CP = new DependTree(child);
                    map.put(child, CP);
                }
                PT.child.add(CP);
            }
        }
        for (int i = 0; i < res.size(); i++) {
   
            dfs(map.get(res.get(i)));
        }
        return builder.toString().substring(0, builder.length() - 1);
    }
    
    private void dfs(DependTree dependTree) {
   
        builder.append(dependTree.val + ",");
        for(DependTree sub : dependTree.child) {
   
            dfs(sub);
        }
    }
}
    class DependTree {
   
    public int val;
    public List<DependTree> child = new ArrayList<>();
    public DependTree(int val) {
   
        this.val = val;
    }
}

分析一下错误

您的代码已保存
答案错误:您提交的程序没有通过所有的测试用例
case通过率为90.00%

用例:
“8,2,7,4,6,-1,5,5,6”

对应输出应该为:

“5,6,4,3,7,2,1,8,0”

你的输出为:

“5,6,4,3,8,0,7,2,1”

画一下依赖树

发现问题，没有满足按数字升序返回一种情况即可

改进（AC）

使用优先队列

import java.util.*;
public class Solution {
   
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 编译顺序
     * @param input string字符串
     * @return string字符串
     */
    StringBuilder builder = new StringBuilder();
    public String compileSeq (String input) {
   
        // write code here
        Map<Integer, DependTree> map = new HashMap();
        List<Integer> res = new ArrayList<>();
        String[<