华为OD机试真题新系统 2026-06-03 Java&Go&C 实现【返回所有加载的AGENTS.md文件ID列表】

MISAYAONE

189人浏览 · 2026-06-18 16:00:00

MISAYAONE · 2026-06-18 16:00:00 发布

题目

思路

Code

题目

编码Agent 工具会在当前项目下生成AGENTS.md文件用于记录相关上下文和规范信息;每个md文件都有一个唯一ID，其中根文件ID为0，其他文件除自身ID外，还有一个父文件ID;
Agent在加载某个md文件时需同时加载该md文件的所有子文件，当前给定3个输入值:
1.输入1:md文件自身ID列表(用例保证列表中的ID不出现 0)
2.输入2:md文件对应的父文件ID列表
3.输入3:此次需要加载的某个md文件ID
请输出:需要加载的文件ID及所有子文件ID列表，并按从小到大的数值顺序返回。
补充说明
1.被加载的文件ID一定在第一个列表中。
2.两个列表数量相等，且长度n满足:1<=n<=1000。
输入
第一行输入md自身ID
第二行输入md父文件ID，与第一行一一对应
第三行输入需要加载的md文件ID
输出
需要加载的文件ID列表，并按从小到大的数值顺序返回。

样例1

输入

1,2,3,4,5
0,1,1,2,3
1

输出

1,2,3,4,5
说明

1的子节点为2、3;2子节点4;3子节点5，全部纳入结果，升序排列。
样例2

输入

2,5,7,9
1,2,2,0
2

输出

2,5,7

思路

DFS / BFS
预处理：
- 将自身 ID 列表和父 ID 列表一一对应，建立子→父关系。
- 遍历关系，构建邻接表 children[parent] = [child1, child2, ...]。
状态定义：
- children：哈希映射（或数组映射），key 为父节点 ID，value 为其直接子节点列表。
- visited 或直接递归收集即可（树无环，无需判重）。
核心逻辑：
1. 读取三行输入，解析自身 ID 列表 selfIds 和父 ID 列表 parentIds。
2. 遍历 i=0..n-1，将 selfIds[i] 加入 children[parentIds[i]] 列表。
3. 从目标节点 target 开始 DFS（或 BFS）：
- 将 target 加入结果集。
- 对 children[target] 中的每个子节点，递归访问其子树。
4. 结果集升序排序后以逗号连接输出。
复杂度：
- 时间 O(n log n)：建图 O(n)，DFS O(n)，排序 O(n log n)。n ≤ 1000。
- 空间 O(n)：邻接表存储。

Code

import java.util.*;

/**
 * MD 文件加载依赖 — 树形子孙节点查找
 */
public class Main {

    public static void main(String[] args) {
        try (Scanner sc = new Scanner(System.in)) {
            String line1 = sc.nextLine().trim();
            String line2 = sc.nextLine().trim();
            String line3 = sc.nextLine().trim();

            String[] selfParts = line1.split(",");
            String[] parentParts = line2.split(",");
            int target = Integer.parseInt(line3);

            int n = selfParts.length;
            int[] selfIds = new int[n];
            int[] parentIds = new int[n];
            for (int i = 0; i < n; i++) {
                selfIds[i] = Integer.parseInt(selfParts[i]);
                parentIds[i] = Integer.parseInt(parentParts[i]);
            }

            List<Integer> result = solve(selfIds, parentIds, target);
            StringBuilder sb = new StringBuilder();
            for (int i = 0; i < result.size(); i++) {
                if (i > 0) sb.append(",");
                sb.append(result.get(i));
            }
            System.out.println(sb);
        } catch (Exception e) {
            System.out.println();
        }
    }

    static List<Integer> solve(int[] selfIds, int[] parentIds, int target) {
        // 构建邻接表 children[parent] -> list of children
        Map<Integer, List<Integer>> children = new HashMap<>();
        for (int i = 0; i < selfIds.length; i++) {
            int pid = parentIds[i];
            children.computeIfAbsent(pid, k -> new ArrayList<>()).add(selfIds[i]);
        }

        // DFS 收集所有后代
        List<Integer> result = new ArrayList<>();
        Deque<Integer> stack = new ArrayDeque<>();
        stack.push(target);

        while (!stack.isEmpty()) {
            int node = stack.pop();
            result.add(node);
            List<Integer> childList = children.get(node);
            if (childList != null) {
                for (int child : childList) {
                    stack.push(child);
                }
            }
        }

        Collections.sort(result);
        return result;
    }
}

Go

package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
	"strconv"
	"strings"
)

/**
 * 使用邻接表 + DFS 找出 target 及其所有子孙节点
 */
func solve(selfIds, parentIds []int, target int) []int {
	// 构建邻接表
	children := make(map[int][]int)
	for i, pid := range parentIds {
		children[pid] = append(children[pid], selfIds[i])
	}

	// DFS 收集
	result := make([]int, 0)
	stack := []int{target}

	for len(stack) > 0 {
		node := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		result = append(result, node)

		for _, child := range children[node] {
			stack = append(stack, child)
		}
	}

	sort.Ints(result)
	return result
}

func splitInts(s string) []int {
	parts := strings.Split(s, ",")
	res := make([]int, len(parts))
	for i, p := range parts {
		res[i], _ = strconv.Atoi(strings.TrimSpace(p))
	}
	return res
}

func main() {
	defer func() {
		if r := recover(); r != nil {
			fmt.Println()
		}
	}()

	scanner := bufio.NewScanner(os.Stdin)
	lines := make([]string, 0)
	for scanner.Scan() {
		line := strings.TrimSpace(scanner.Text())
		if line != "" {
			lines = append(lines, line)
		}
		if len(lines) == 3 {
			break
		}
	}

	if len(lines) < 3 {
		fmt.Println()
		return
	}

	selfIds := splitInts(lines[0])
	parentIds := splitInts(lines[1])
	target, _ := strconv.Atoi(lines[2])

	result := solve(selfIds, parentIds, target)
	fmt.Println(strings.Join(intsToStrings(result), ","))
}

func intsToStrings(nums []int) []string {
	s := make([]string, len(nums))
	for i, v := range nums {
		s[i] = strconv.Itoa(v)
	}
	return s
}

C

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#define MAX_N 1000

/**
 * 简易邻接表（静态数组实现）
 */
int adj[MAX_N + 1][MAX_N];  // adj[parent][*] = children
int adjCnt[MAX_N + 1];       // 每个 parent 的孩子数

int result[MAX_N];
int resCnt;

/**
 * 使用 DFS 收集 target 及其所有子孙节点
 */
void dfs(int target) {
    // 显式栈模拟 DFS
    int stack[MAX_N];
    int top = 0;
    stack[top++] = target;

    while (top > 0) {
        int node = stack[--top];
        result[resCnt++] = node;
        for (int i = adjCnt[node] - 1; i >= 0; i--) {
            stack[top++] = adj[node][i];
        }
    }
}

int cmp(const void* a, const void* b) {
    return *(int*)a - *(int*)b;
}

void solve(int* selfIds, int* parentIds, int n, int target) {
    // 构建邻接表
    memset(adjCnt, 0, sizeof(adjCnt));
    for (int i = 0; i < n; i++) {
        int pid = parentIds[i];
        adj[pid][adjCnt[pid]++] = selfIds[i];
    }

    // DFS 收集
    resCnt = 0;
    dfs(target);

    // 排序
    qsort(result, resCnt, sizeof(int), cmp);
}

int main() {
    char line[8000];
    int selfIds[MAX_N], parentIds[MAX_N], n = 0, target;

    // 读取第一行
    if (fgets(line, sizeof(line), stdin) == NULL) { printf("\n"); return 0; }
    char* token = strtok(line, ",\n\r");
    while (token != NULL && n < MAX_N) {
        selfIds[n++] = atoi(token);
        token = strtok(NULL, ",\n\r");
    }

    // 读取第二行
    if (fgets(line, sizeof(line), stdin) == NULL) { printf("\n"); return 0; }
    n = 0;
    token = strtok(line, ",\n\r");
    while (token != NULL && n < MAX_N) {
        parentIds[n++] = atoi(token);
        token = strtok(NULL, ",\n\r");
    }

    // 读取第三行
    if (fgets(line, sizeof(line), stdin) == NULL) { printf("\n"); return 0; }
    target = atoi(line);

    solve(selfIds, parentIds, n, target);

    for (int i = 0; i < resCnt; i++) {
        if (i > 0) printf(",");
        printf("%d", result[i]);
    }
    printf("\n");
    return 0;
}

【华为od机试真题Python+JS+Java+Go合集】【超值优惠】：Py/JS/Java/Go合集

【华为od机试真题Python】：Python真题题库

【华为od机试真题JavaScript】：JavaScript真题题库

【华为od机试真题Java&Go】：Java&Go真题题库

【华为od机试真题C++】：C++真题题库

【华为od机试真题C语言】：C语言真题题库

【华为od面试手撕代码题库】：面试手撕代码题库

【华为od机试面试交流群】【文章底部有二维码链接，可扫码加交流群】

华为OD机试:二本院校有机会吗?
有机会,但不大,大神除外!机考分数越高越好,所以需要提前刷题。机考通过后,如果没有收到面试邀请,也不要着急,非目标院校面试邀请发的时间比较晚。非目标院校今年有点难,机试至少要考到350分,所以需要疯狂刷题,华为OD机考是有题库的,最好在考前完所有题库题目。华为OD机试:跨专业可以参加华为OD可以,但是如果你的本科院校比较差,上岸概率不大。华为OD机试:华为OD简历被锁定机试通过,性格测试也通过,但是没人联系面试,发现简历被锁定。此时需要主动去联系HR。让他帮助你查询原因。