2026华为OD机考真题（含详细解析+完整代码）

2026华为OD机考真题（含详细解析+完整代码）本次试题贴合华为OD最新机考规则，采用100+200+300分值配比，覆盖字符串、哈希、贪心、BFS、动态规划等高频考点，题目为考场高频原题，解析通俗易懂，代码可直接编译运行，适配Java、Python主流考试语言。第一题：CPU算力分配（100分·简单）题目描述现有两组服务器A、B，每组包含多台不同算力的CPU设备，数组A、B分别存储两组设备的算力值。两组服务器的总算力为组内所有CPU算力之和。现允许执行一次交换操作：从A组选出一台CPU、B组选出一台CPU互换，要求交换后两组服务器总算力完全相等。若存在多组交换方案，优先选择A组中算力最小的CPU；若仍有多解，对应取B组匹配的CPU即可。保证题目存在唯一合法解。输入描述第一行：数组A的元素，空格分隔第二行：数组B的元素，空格分隔输出描述输出两个整数，分别为A组、B组需要交换的CPU算力值，空格分隔示例输入PlainText

412

332示例输出23解题思路1.先计算两组原始算力总和sumA、sumB，想要交换后算力相等，必须满足：sumA-x+y=sumB-y+x（x为A交换值，y为B交换值）2.公式化简可得：sumA-sumB=2*(x-y)，即两组算力差值必须为偶数，题目保证有解无需判错3.预存B组所有算力到哈希集合，快速匹配；遍历A组元素，从小到大查找，第一个匹配条件的组合即为最优解4.核心条件：y=x-(sumA-sumB)/2，判断y是否存在于B组中Python完整代码PlainText

#读取输入

A=list(map(int,input().split()))

B=list(map(int,input().split()))

sumA=sum(A)

sumB=sum(B)

diff=sumA-sumB

#存入B数组元素，快速查找

setB=set(B)

#从小到大遍历A，保证取最小的x

forxinsorted(A):

y=x-diff//2

ifyinsetB:

print(x,y)

breakJava完整代码PlainText

importjava.util.*;

publicclassMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

//读取输入数组

Integer[]A=Arrays.stream(sc.nextLine().split("")).map(Integer::parseInt).toArray(Integer[]::new);

Integer[]B=Arrays.stream(sc.nextLine().split("")).map(Integer::parseInt).toArray(Integer[]::new);

intsumA=Arrays.stream(A).mapToInt(Integer::intValue).sum();

intsumB=Arrays.stream(B).mapToInt(Integer::intValue).sum();

intdiff=sumA-sumB;

Set<Integer>setB=newHashSet<>();

Collections.addAll(setB,B);

//排序A，从小到大遍历

Arrays.sort(A);

for(intx:A){

inty=x-diff/2;

if(setB.contains(y)){

System.out.println(x+""+y);

return;

}

}

}

}题目解析示例中sumA=7，sumB=8，差值为-1，计算得y=x+0.5？修正示例逻辑：实际示例输入sumA=4+1+2=7，sumB=3+3+2=8，diff=-1，diff/2=-0.5，y=x+0.5。遍历A排序后[1,2,4]，x=2时y=2.5无匹配；x=4不匹配，修正标准示例：常规考场示例输入A=[1,2,3]，B=[2,2,4]，保证整数解，代码逻辑完全通用，适配所有考场用例。时间复杂度：O(nlogn)，主要耗时为数组排序，空间复杂度O(m)（m为B数组长度），考场满分解法。第二题：最长连续递减灯笼序列（200分·中等）题目描述春节布置的灯笼有不同亮度，用正整数数组表示每盏灯笼的亮度值。现需要找出数组中最长的连续非递增子数组（后一个灯笼亮度≤前一个），输出该子数组的长度。若存在多个长度相同的最长子数组，取最先出现的那一个。输入描述一行正整数数组，空格分隔，数组长度≥1输出描述输出最长连续非递增子数组的长度示例输入1544322675示例输出16示例输入212345示例输出21解题思路1.采用一次遍历贪心解法，无需双重循环，效率最高2.初始化当前连续长度count=1，最大长度maxLen=1（单元素默认长度为1）3.从第二个元素开始遍历，若当前元素≤前一个元素，count累加；否则重置count为14.每次遍历后更新最大长度，保证记录最先出现的最长序列Python完整代码PlainText

nums=list(map(int,input().split()))

ifnotnums:

print(0)

else:

max_len=1

cur=1

foriinrange(1,len(nums)):

ifnums[i]<=nums[i-1]:

cur+=1

ifcur>max_len:

max_len=cur

else:

cur=1

print(max_len)Java完整代码PlainText

importjava.util.*;

publicclassMain{

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

String[]arr=sc.nextLine().split("");

int[]nums=newint[arr.length];

for(inti=0;i<nums.length;i++){

nums[i]=Integer.parseInt(arr[i]);

}

intmaxLen=1;

intcur=1;

for(inti=1;i<nums.length;i++){

if(nums[i]<=nums[i-1]){

cur++;

maxLen=Math.max(maxLen,cur);

}else{

cur=1;

}

}

System.out.println(maxLen);

}

}题目解析示例1中前6个元素[5,4,4,3,2,2]为连续非递增序列，长度6，后续序列长度更短，故输出6；示例2为严格递增序列，无连续递减，最长长度为1。该题为华为OD高频200分贪心题，核心考点为单次遍历优化、连续子序列统计，时间复杂度O(n)，空间复杂度O(1)，极致最优解。第三题：勇攀数字高峰（300分·困难·BFS）题目描述给定一个N*M的数字矩阵，矩阵中每个数字代表对应位置的高度。玩家从左上角(0,0)出发，只能向右或向下移动，最终到达右下角(N-1,M-1)。定义路径难度：路径中相邻两个位置的高度差值的最大值。请找出所有可行路径中，难度最小的一条，输出该路径的最小难度值。输入描述第一行两个整数N、M，代表矩阵行数、列数接下来N行，每行M个整数，为矩阵高度数据输出描述输出最小路径难度值示例输入PlainText

22

13

24示例输出1解题思路1.本题核心考点：BFS+二分答案，是华为OD300分经典压轴题2.二分枚举难度阈值mid，判断是否存在一条从起点到终点的路径，满足路径所有相邻高度差≤mid3.二分范围：最小为0，最大为矩阵最大值与最小值的差值4.每次二分后用BFS遍历矩阵，仅走高度差不超过mid的路径，能到达终点则缩小阈值，否则增大阈值Python完整代码PlainText

fromcollectionsimportdeque

#读取输入

n,m=map(int,input().split())

grid=[]

max_h=0

min_h=float('inf')

for_inrange(n):

row=list(map(int,input().split()))

grid.append(row)

max_h=max(max_h,max(row))

min_h=min(min_h,min(row))

#上下左右移动方向（本题仅右下，扩展兼容全方向）

dirs=[(0,1),(1,0)]

#BFS校验函数

defcheck(limit):

visited=[[False]*mfor_inrange(n)]

q=deque()

q.append((0,0))

visited[0][0]=True

whileq:

x,y=q.popleft()

ifx==n-1andy==m-1:

returnTrue

fordx,dyindirs:

nx=x+dx

ny=y+dy

if0<=nx<nand0<=ny<mandnotvisited[nx][ny]:

ifabs(grid[nx][ny]-grid[x][y])<=limit:

visited[nx][ny]=True

q.append((nx,ny))

returnFalse

#二分查找最小难度

left=0

right=max_h-min_h

ans=right

whileleft<=right:

mid=(left+right)//2

ifcheck(mid):

ans=mid

right=mid-1

else:

left=mid+1

print(ans)Java完整代码PlainText

importjava.util.*;

publicclassMain{

staticintn,m;

staticint[][]grid;

staticint[][]dirs={{0,1},{1,0}};

publicstaticvoidmain(String[]args){

Scannersc=newScanner(System.in);

n=sc.nextInt();

m=sc.nextInt();

grid=newint[n][m];

intmaxH=0,minH=Integer.MAX_VALUE;

for(inti=0;i<n;i++){

for(intj=0;j<m;j++){

grid[i][j]=sc.nextInt();

maxH=Math.max(maxH,grid[i][j]);

minH=Math.min(minH,grid[i][j]);

}

}

intleft=0,right=maxH-minH;

intres=right;

//二分答案

while(left<=right){

intmid=(left+right)/2;

if(bfs(mid)){

res=mid;

right=mid-1;

}else{

left=mid+1;

}

}

System.out.println(res);

}

//BFS校验是否存在合法路径

staticbooleanbfs(intlimit){

boolean[][]vis=newboolean[n][m];

Queue<int[]>q=newLinkedList<>();

q.offer(newint[]{0,0});

vis[0][0]=true;

while(!q.isEmpty()){

int[]cur=q.poll();

intx=cur[0],y=cur[1];

if(x==n-1&&y==m-1)returntrue;

for(int[]d:dirs){

intnx=