2022校招:华为笔试

面试真题 专栏收录该内容
17 篇文章 2 订阅

三题120分钟,分值=100+200+300。需要自己处理输入。
华为是谁?
华为是全球领先的信息与通信技术( ICT)解决方案供应商,专注于 ICT 领域,坚持稳
健经营、持续创新、开放合作,在电信运营商、企业、终端和云计算等领域构筑了端到端
的解决方案优势,为运营商客户、企业客户和消费者提供有竞争力的 ICT 解决方案、产品
和服务,并致力于使能未来信息社会、 构建更美好的全联接世界。目前,华为有 17 万多
名员工,业务遍及全球 170 多个国家和地区,服务全世界三分之一以上的人口。
我们为世界带来了什么?
为客户创造价值。华为和运营商一起,在全球建设了 1,500 多张网络,帮助世界超过
三分之一的人口实现联接。华为和企业客户一起,以开放的云计算和敏捷的企业网络,助
力平安城市、金融、交通、能源等领域实现高效运营和敏捷创新。华为智能终端和智能手
机,正在帮助人们享受高品质的数字工作、生活和娱乐体验。
推动行业良性发展。华为主张开放、合作、共赢,与上下游合作伙伴及友商合作创新、
扩大产业价值,形成健康良性的产业生态系统。华为加入 300 多个标准组织、产业联盟和
开源社区,累计提案 4.3 万篇。我们面向云计算、NFV/SDN、5G 等新兴热点领域,与产业
伙伴分工协作,推动行业持续良性发展。
促进经济增长。华为为所在国家不仅带来直接的纳税、就业促进、产业链带动效应,
更重要的是通过创新的 ICT 解决方案打造数字化引擎,推动各行各业数字化转型,促进经
济增长,提升人们的生活质量与福祉。
促进社会可持续发展。作为负责任的企业公民,华为致力于消除全球数字鸿沟;在西
非埃博拉疫区、日本海啸核泄漏、中国汶川大地震等重大灾难现场,我们深知灾难面前通
信的重要性,我们选择了坚守;我们在全球开展 “未来种子”项目,为各国青年学生提
供来中国培训实习的机会。

  1. 最大绝对值之差
    树。找出一个节点,把这个节点与parent隔断,成为新的树的root。目标是最大化两颗树的差值。返回应该割裂开的节点,如果出现平局,返回索引较小的。
    第一行输入是n,表示一共多少节点。第二行是所有节点的值。之后是节点的关系,【parent,child】。

input:
4
4 9 -7 -8
0 1
0 3
1 2

output: 3
注意,在关系中左child一定会比右child先出现。

public class Main {
    static int largestGap = 0;
    static int res = 100000;

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        Node[] nodes = new Node[n];
        boolean[] notRoot = new boolean[n];
        for (int i = 0; i < n; i++) {
            int v = sc.nextInt();
            nodes[i] = new Node(i, v);
        }
        while (sc.hasNextInt()) {
            int p = sc.nextInt();
            int c = sc.nextInt();
            Node par = nodes[p];
            Node child = nodes[c];
            notRoot[c] = true;
            if (par.left == null)
                par.left = child;
            else
                par.right = child;
        }
        Node root = null;
        for (int i = 0; i < n; i++) {
            if (!notRoot[i]) {
                root = nodes[i];
                break;
            }
        }
        subtreeSum(root);
        findGap(root, 0);
        System.out.println(res);
    }

    private static void findGap(Node root, int parVal) {
        if (root == null)
            return;
        int left = 0;
        int right = 0;
//        System.out.printf("findgap(), root.id=%d, largestGap=%d, res=%d\n", root.idx, largestGap,
//                        res);
        if (root.left != null) {
            left = root.left.sum;
            int leftgap = Math.abs(root.sum + parVal - 2 * left);
//            System.out.printf("left=%d, leftgap=%d\n", left, leftgap);
            if (leftgap > largestGap) {
                largestGap = leftgap;
                res = root.left.idx;
            } else if (leftgap == largestGap && root.left.idx < res) {
                res = root.left.idx;
            }
        }
        if (root.right != null) {
            right = root.right.sum;
            int rightgap = Math.abs(root.sum + parVal - 2 * right);
//            System.out.printf("right=%d, rightgap=%d\n", right, rightgap);
            if (rightgap > largestGap) {
                largestGap = rightgap;
                res = root.right.idx;
            } else if (rightgap == largestGap && root.right.idx < res) {
                res = root.right.idx;
            }
        }
//        System.out.printf("largestGap=%d, res=%d\n", largestGap, res);
        findGap(root.left, parVal + root.val + right);
        findGap(root.right, parVal + root.val + left);
    }

    private static int subtreeSum(Node root) {
        if (root == null)
            return 0;
        int left = subtreeSum(root.left);
        int right = subtreeSum(root.right);
        int s = left + right + root.val;
        root.sum = s;
        return s;
    }
}


class Node {
    int idx;
    int val;
    int sum;
    Node left;
    Node right;

    public Node(int i, int v) {
        idx = i;
        val = v;
        sum = 0;
        left = null;
        right = null;
    }
}
  1. 梅花桩
    格子表示可跳跃的步数。第一行是m,n,表示棋盘的大小。求到达最右下角最少的步数。如果无法到达,返回-1。
public class Main {

    public static void main(String[] args) {
        final int INF = 100*100*10+1;
        Scanner sc = new Scanner(System.in);
        String[] input = sc.nextLine().split(",");
        int m = Integer.parseInt(input[0]);
        if (m <= 0) {
            System.out.println("-1");
            return;
        }
        int n = Integer.parseInt(input[1]);
        if (n <= 0) {
            System.out.println("-1");
            return;
        }
        int[][] grid = new int[m][n];
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                grid[i][j] = sc.nextInt();
                dp[i][j] = INF;
            }
        }
        dp[0][0] = 0;
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                if (grid[i][j] == 0) continue;
                // jump to right
                for (int k = 1; k <= grid[i][j]; k++) {
                    if (j+k >= n) break;
                    if (grid[i][j+k] == 0) continue;
                    dp[i][j+k] = Math.min(dp[i][j+k], dp[i][j]+1);
                }
                // jump to bottom
                for (int k = 1; k <= grid[i][j]; k++) {
                    if (i+k >= m) break;
                    if (grid[i+k][j] == 0) continue;
                    dp[i+k][j] = Math.min(dp[i+k][j], dp[i][j]+1);
                }
            }
        }
        if (dp[m-1][n-1] >= INF) {
            System.out.println("-1");
            return;
        }
        System.out.println(dp[m-1][n-1]);
    }
    
    private static void print2d(int[][] arr) {
        int m = arr.length;
        for (int i = 0; i < m; i++)
            System.out.println(Arrays.toString(arr[i]));
        System.out.println();
    }
}
  1. 最短编译时间
    只过5%的test case,时间来不及。
    不同项目需要不同的依赖。第一行是目标项目。之后每一行表示一个项目所依赖的项目和编译时间,格式为[项目名称,编译时间,*依赖项目]。依赖的项目必须要先做完。
    input:
    module3
    module1,10
    module2,5
    module3,10,module1,module2

output: 20

input:
module2
module2,10,module1

output: -1

input:
module2
module2,10,module1
module1,10,module2

output: -1

public class Main {
    static boolean valid = true;
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String goal = sc.nextLine().trim();
        Map<String, Integer> duration = new HashMap();
        Map<String, Set<String>> prereqs = new HashMap();
        while (sc.hasNextLine()) {
            String[] input = sc.nextLine().split(",");
            int d = Integer.parseInt(input[1]);
            duration.put(input[0], d);
            Set<String> pre = new HashSet();
            for (int i = 2; i < input.length; i++)
                pre.add(input[i]);
            prereqs.put(input[0], pre);
        }
        int res = getTime(goal, duration, prereqs, new HashSet());
        if (!valid)
            System.out.println("-1");
        else
            System.out.println(res);
    }

    private static int getTime(String cur, Map<String, Integer> duration, Map<String, Set<String>> prereqs, Set<String> seen) {
        if (!valid) return -1;
        if (!prereqs.containsKey(cur) || seen.contains(cur)) {
            valid = false;
            return -1;
        }
        seen.add(cur);
        Set<String> pres = prereqs.get(cur);
        int t = duration.get(cur);
        int front = 0;
        for (String pre: pres) {
            front = Math.max(front, getTime(pre, duration, prereqs, seen));
        }
        // 这行是考完之后才加的,忘记backtrack
        seen.remove(cur); 
        return t+front;
    }
}

如果不加上最后有一行代码(有注释那行),假设两个模块同时依赖一个模块,会出问题。可惜当时没有想到这种情况,测试平台所有测试用例是用户不可见的(只能自测)。
特别感谢Oscar哥帮忙debug。

  • 0
    点赞
  • 0
    评论
  • 2
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 博客之星2020 设计师:CY__ 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值