vivo2021界秋招

1.一个完整的软件项目往往会包含很多由代码和文档组成的源文件。编译器在编译整个项目的时候，可能需要按照依赖关系来依次编译每个源文件。比如，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

import java.util.*;


public class Solution {
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     * 编译顺序
     * @param input string字符串
     * @return string字符串
     */
    public String compileSeq (String input) {
        //定义一个优先队列，存放所有没有依赖的元素（从小到大排序）
        //Queue存储出度为0的节点
        PriorityQueue<Integer> queue=new PriorityQueue<>(((o1, o2) -> o1-o2));

        String[] split = input.split(",");
        int n=split.length;
        int[] nums=new int[n];
        
        for(int i=0;i<n;i++){
            nums[i]=Integer.parseInt(split[i]);
        }
        StringBuilder sb=new StringBuilder();
        for (int i = 0; i < n; i++) {
            //将没有依赖的元素放入队列中
            if(nums[i]==-1)queue.offer(i);
        }
        
        while(!queue.isEmpty()){
            int x = queue.poll();
            sb.append(x+",");
            
            //当完成编译完成后，依赖该文件的文件此时也不存在依赖了
            //例如:加入A依赖B，当B完成编译后，A也不存在依赖了
            //将其加入到队列中
            for (int i = 0; i < n; i++) {
                if(nums[i]==x) queue.offer(i);
            }
        }
        sb.deleteCharAt(sb.length()-1);
        return sb.toString();
    }
}

2.回文字符串就是正读和反读都一样的字符串，如“viv”、“nexen”、“12321”、“qqq”、“翻身把身翻” 等。

给定一个非空字符串 str，在最多可以删除一个字符的情况下请编程判定其能否成为回文字符串；如果可以则输出首次删除一个字符所能得到的回文字符串，如果不行则输出字符串 "false" 。

public class Main {
    public static void main(String[] args) {
        Scanner in = new Scanner(new BufferedInputStream(System.in));
        PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
 
        while (in.hasNext()) {
            String s = in.nextLine();
            char[] sc = s.toCharArray();
            int n = sc.length;
 
            int left = 0, right = n - 1, k = 0, index = -1;
            boolean isFound = true;
            while (k <= 1 && left <= right) {
                if (sc[left] == sc[right]) {
                    ++left;
                    --right;
                } else {
                    if (left + 1 <= right && sc[left + 1] == sc[right]) {
                        index = left;
                        left += 2;
                        --right;
                        ++k;
                    } else if (left <= right - 1 && sc[right - 1] == sc[left]) {
                        index = right;
                        ++left;
                        right -= 2;
                        ++k;
                    } else {
                        isFound = false;
                        break;
                    }
                }
            }
            if (isFound && k <= 1) {
                if(index == -1){
                    index = n - 1;
                }
                for (int i = 0; i < n; ++i) {
                    if(i != index){
                        out.print(sc[i]);
                    }
                }
                out.println();
            } else {
                out.println("false");
            }
        }
 
        in.close();
        out.close();
    }
}

3.vivo游戏中心的运营小伙伴最近接到一款新游戏的上架申请，为了保障用户体验，运营同学将按运营流程和规范对其做出分析评估。经过初步了解后分析得知，该游戏的地图可以用一个大小为 n*n 的矩阵表示，每个元素可以视为一个格子，根据游戏剧情设定其中某些格子是不可达的(比如建筑、高山、河流或者其它障碍物等)，现在请你设计一种算法寻找从起点出发到达终点的最优抵达路径，以协助运营小伙伴评估该游戏的可玩性和上手难度。

import java.util.*;
public class Main{
    private static int[][] posi=new int[][]{{0,-1},{0,1},{1,0},{-1,0}};
    static int n;
    static int x1;
    static int y1;
    static int x2;
    static int y2;
    static int[][] map;
    public static void main(String[] args){
        Scanner sc=new Scanner(System.in);
        n=sc.nextInt();
        int[][] arr=new int[n][n];
        y1=sc.nextInt();
        x1=sc.nextInt();
        y2=sc.nextInt();
        x2=sc.nextInt();
        for(int i=0;i<n;i++){
            String row=sc.next();
            for(int j=0;j<n;j++){
                if(row.charAt(j)=='#'||row.charAt(j)=='@')
                    arr[i][j]=-1;
            }
        }
        map=new int[n][n];
        for(int i=0;i<map.length;i++){
            Arrays.fill(map[i],Integer.MAX_VALUE);
        }
        calcWayDistance(arr,x1,y1,0);
        if(map[x2][y2]==Integer.MAX_VALUE) System.out.print(-1);
        else System.out.print(map[x2][y2]);
    }
    private static void calcWayDistance(int[][] arr,int x,int y,int dis){
        if(x<0||x>=n||y<0||y>=n||arr[x][y]==-1||dis>=map[x][y]) return;
        map[x][y]=dis;
        for(int[] dir:posi){
            int a=x+dir[0];
            int b=y+dir[1];
            calcWayDistance(arr,a,b,dis+1);
        }
    }
}