7.19华为OD机试真题新系统 - 物流仓储多维度成本利润综合查询系统 (Java/Py/C/C++/Js/Go)

原创于 2026-07-21 15:43:33 发布 · 39 阅读

1 ·

本内容遵循CC 4.0 BY-SA版权协议

GEO检测

物流仓储多维度成本利润综合查询系统

2026 华为OD机试真题 7月19日华为OD上机新系统考试真题 100 分题型

点击查看华为 OD 机试真题完整目录：2026最新华为OD机试新系统卷 + 双机位C卷真题题库目录｜全覆盖题库 + 逐点算法考点详解

题目描述

某物流企业在全国多个仓库开展仓储业务，需要对不同仓库、不同时间段的入库成本、出库收入和库存损耗进行综合统计分析，用于生成日报、周报和月报。

字段说明及取值范围如下：

字段	类型	取值范围	说明
warehouseId	int	[0, 99]	仓库编号
numOfWarehouse	int	-	仓库数量
startDay	int	-	统计开始天
endDay	int	-	统计结束天，startDay <= endDay
inCost	int	[0, 1000]	入库成本（千元）
outRevenue	int	[0, 2000]	出库收入（千元）
loss	int	[0, 100]	库存损耗（千元），0 表示无损耗

输入描述

warehouses: int[] 扁平化数组 [w0d0in, w0d0out, w0d0loss, w0d1in, w0d1out, w0d1loss, ...]，先存储仓库 0 的数据，再存储仓库 1 的数据，所有仓库数据个数均相同
queries: int[][]，形如 [[warehouseId, startDay, endDay], ...]
numOfWarehouse: int，仓库个数

输入保证最多 100 个仓库，每个仓库最多 100 天数据，每天数据连续，中间无空缺。

输出描述

返回 int[][]，每个查询结果为 [累计净利润, 累计损耗, 风控标记]。

业务计算规则：

净利润 = 累计出库收入 - 累计入库成本
累计损耗 = Σ每日损耗
损耗率 = 累计损耗 / (累计入库成本 + 累计出库收入) × 100%

风控规则：

当损耗率 > 5% 时，触发风控标记（返回 1）
当损耗率 <= 5% 时，不触发风控（返回 0）

示例1

输入

[3, 8, 1, 5, 12, 0, 2, 6, 0, 4, 10, 1][[0, 0, 2]]1

输出

[[16,1,0]]

说明

共有 1 个仓库，3 天数据。累计入库成本为 10，累计出库收入为 26，累计损耗为 1，净利润为 16，损耗率为 2.78%，不触发风控。

示例2

输入

[10, 20, 5, 10, 20, 5, 10, 20, 5, 5, 15, 2, 5, 15, 2, 5, 15, 2][[0, 0, 2], [1, 0, 1]]2

输出

[[30,15,1],[20,4,1]]

说明

仓库 0 查询 0-2 天，净利润 30，损耗 15，损耗率大于 5%，触发风控。仓库 1 查询 0-1 天，净利润 20，损耗 4，损耗率大于 5%，触发风控。

解题思路

核心思想

每个查询都要求某个仓库在一段连续日期内的入库成本、出库收入和损耗总和。若每次查询都遍历日期区间，查询次数多时会重复计算。可以为每个仓库分别构建三类前缀和：入库成本前缀和、出库收入前缀和、损耗前缀和。

这样任意区间 [startDay, endDay] 的累计值都可以通过 prefix[endDay + 1] - prefix[startDay] 在 O(1) 时间得到。

算法步骤

根据 warehouses.length / (numOfWarehouse * 3) 计算每个仓库的数据天数。
为每个仓库建立入库、出库、损耗三类前缀和。
遍历每个查询 [warehouseId, startDay, endDay]。
用前缀和计算累计入库成本、累计出库收入和累计损耗。
计算净利润 totalOut - totalIn。
用整数比较 totalLoss * 100 > 5 * (totalIn + totalOut) 判断损耗率是否大于 5%，避免浮点误差。
按查询顺序输出所有结果。

正确性说明

前缀和数组中，第 i 项表示从第 0 天到第 i-1 天的累计值。因此区间 [startDay, endDay] 的总和等于 prefix[endDay + 1] - prefix[startDay]，这正好覆盖查询区间内的所有天数且不包含区间外数据。算法分别对入库、出库、损耗建立前缀和，所以每个查询都能得到准确的三项累计值。净利润和风控标记均直接由题目公式计算，因此每个查询输出正确。

复杂度分析

设仓库数为 W，每个仓库天数为 D，查询数为 Q。

时间复杂度：O(WD + Q)，构建前缀和需要遍历全部仓库数据，每个查询 O(1)。

空间复杂度：O(WD)，用于保存三类前缀和。

Java

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class Main {
    static List<List<Integer>> solve(int[] warehouses, int[][] queries, int numOfWarehouse) {
        // 每个仓库每天有 3 个指标，因此可反推出每个仓库共有多少天数据
        int days = warehouses.length / (numOfWarehouse * 3);
        int[][] prefixIn = new int[numOfWarehouse][days + 1];
        int[][] prefixOut = new int[numOfWarehouse][days + 1];
        int[][] prefixLoss = new int[numOfWarehouse][days + 1];

        // 为每个仓库分别建立入库、出库、损耗三类前缀和
        for (int warehouse = 0; warehouse < numOfWarehouse; warehouse++) {
            int base = warehouse * days * 3;
            for (int day = 0; day < days; day++) {
                int index = base + day * 3;
                prefixIn[warehouse][day + 1] = prefixIn[warehouse][day] + warehouses[index];
                prefixOut[warehouse][day + 1] = prefixOut[warehouse][day] + warehouses[index + 1];
                prefixLoss[warehouse][day + 1] = prefixLoss[warehouse][day] + warehouses[index + 2];
            }
        }

        // 每个查询用前缀和 O(1) 得到区间累计值
        List<List<Integer>> report = new ArrayList<>();
        for (int[] query : queries) {
            int warehouse = query[0], startDay = query[1], endDay = query[2];
            int totalIn = prefixIn[warehouse][endDay + 1] - prefixIn[warehouse][startDay];
            int totalOut = prefixOut[warehouse][endDay + 1] - prefixOut[warehouse][startDay];
            int totalLoss = prefixLoss[warehouse][endDay + 1] - prefixLoss[warehouse][startDay];
            int netProfit = totalOut - totalIn;
            int denominator = totalIn + totalOut;
            int risk = denominator > 0 && totalLoss * 100 > 5 * denominator ? 1 : 0;

            List<Integer> row = new ArrayList<>();
            row.add(netProfit);
            row.add(totalLoss);
            row.add(risk);
            report.add(row);
        }
        return report;
    }

    static int[] extractInts(String text) {
        Matcher matcher = Pattern.compile("-?\\d+").matcher(text);
        List<Integer> values = new ArrayList<>();
        while (matcher.find()) values.add(Integer.parseInt(matcher.group()));
        int[] nums = new int[values.size()];
        for (int i = 0; i < values.size(); i++) nums[i] = values.get(i);
        return nums;
    }

    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        StringBuilder input = new StringBuilder();
        while (scanner.hasNextLine()) input.append(scanner.nextLine());
        scanner.close();

        String data = input.toString();
        int firstEnd = data.indexOf(']');
        int queryEnd = data.lastIndexOf("]]");
        int[] warehouses = extractInts(data.substring(0, firstEnd + 1));
        int[] queryNums = extractInts(data.substring(firstEnd + 1, queryEnd + 2));
        int numOfWarehouse = Integer.parseInt(data.substring(queryEnd + 2).trim());

        int[][] queries = new int[queryNums.length / 3][3];
        for (int i = 0, j = 0; i < queries.length; i++) {
            queries[i][0] = queryNums[j++];
            queries[i][1] = queryNums[j++];
            queries[i][2] = queryNums[j++];
        }

        List<List<Integer>> ans = solve(warehouses, queries, numOfWarehouse);
        StringBuilder output = new StringBuilder("[");
        for (int i = 0; i < ans.size(); i++) {
            if (i > 0) output.append(",");
            output.append("[").append(ans.get(i).get(0)).append(",").append(ans.get(i).get(1)).append(",").append(ans.get(i).get(2)).append("]");
        }
        output.append("]");
        System.out.println(output.toString());
    }
}

Python

import re


def solve(warehouses, queries, num_of_warehouse):
    # 每个仓库每天有 in/out/loss 三个数，据此计算每个仓库的天数
    days = len(warehouses) // (num_of_warehouse * 3)
    inbound_prefix = [[0] * (days + 1) for _ in range(num_of_warehouse)]
    revenue_prefix = [[0] * (days + 1) for _ in range(num_of_warehouse)]
    loss_prefix = [[0] * (days + 1) for _ in range(num_of_warehouse)]

    # 分仓库构建三类前缀和，后续查询即可 O(1) 求区间和
    for warehouse in range(num_of_warehouse):
        base = warehouse * days * 3
        for day in range(days):
            index = base + day * 3
            inbound_prefix[warehouse][day + 1] = inbound_prefix[warehouse][day] + warehouses[index]
            revenue_prefix[warehouse][day + 1] = revenue_prefix[warehouse][day] + warehouses[index + 1]
            loss_prefix[warehouse][day + 1] = loss_prefix[warehouse][day] + warehouses[index + 2]

    # 按查询顺序计算净利润、累计损耗和风控标记
    report = []
    for warehouse, start_day, end_day in queries:
        total_in = inbound_prefix[warehouse][end_day + 1] - inbound_prefix[warehouse][start_day]
        total_out = revenue_prefix[warehouse][end_day + 1] - revenue_prefix[warehouse][start_day]
        total_loss = loss_prefix[warehouse][end_day + 1] - loss_prefix[warehouse][start_day]
        net_profit = total_out - total_in
        denominator = total_in + total_out
        risk = 1 if denominator > 0 and total_loss * 100 > 5 * denominator else 0
        report.append([net_profit, total_loss, risk])
    return report


def main():
    lines = []
    while True:
        try:
            lines.append(input())
        except EOFError:
            break
    data = "".join(lines)
    first_end = data.find("]")
    query_end = data.rfind("]]")
    warehouses = list(map(int, re.findall(r"-?\d+", data[:first_end + 1])))
    query_nums = list(map(int, re.findall(r"-?\d+", data[first_end + 1:query_end + 2])))
    num_of_warehouse = int(data[query_end + 2:].strip())
    queries = [query_nums[i:i + 3] for i in range(0, len(query_nums), 3)]
    ans = solve(warehouses, queries, num_of_warehouse)
    print("[" + ",".join("[" + ",".join(map(str, row)) + "]" for row in ans) + "]")


if __name__ == "__main__":
    main()

JavaScript

const readline = require("readline");

function getInts(text) {
  return (text.match(/-?\d+/g) || []).map(Number);
}

function solve(warehouses, queries, numOfWarehouse) {
  // 每个仓库每天占 3 个数，因此先计算每个仓库的数据天数
  const days = Math.floor(warehouses.length / (numOfWarehouse * 3));
  const prefixIn = Array.from({ length: numOfWarehouse }, () => Array(days + 1).fill(0));
  const prefixOut = Array.from({ length: numOfWarehouse }, () => Array(days + 1).fill(0));
  const prefixLoss = Array.from({ length: numOfWarehouse }, () => Array(days + 1).fill(0));

  // 建立三类前缀和，避免每次查询重复遍历日期区间
  for (let warehouse = 0; warehouse < numOfWarehouse; warehouse++) {
    const base = warehouse * days * 3;
    for (let day = 0; day < days; day++) {
      const index = base + day * 3;
      prefixIn[warehouse][day + 1] = prefixIn[warehouse][day] + warehouses[index];
      prefixOut[warehouse][day + 1] = prefixOut[warehouse][day] + warehouses[index + 1];
      prefixLoss[warehouse][day + 1] = prefixLoss[warehouse][day] + warehouses[index + 2];
    }
  }

  // 逐个查询生成 [净利润, 累计损耗, 风控标记]
  const report = [];
  for (const [warehouse, startDay, endDay] of queries) {
    const totalIn = prefixIn[warehouse][endDay + 1] - prefixIn[warehouse][startDay];
    const totalOut = prefixOut[warehouse][endDay + 1] - prefixOut[warehouse][startDay];
    const totalLoss = prefixLoss[warehouse][endDay + 1] - prefixLoss[warehouse][startDay];
    const netProfit = totalOut - totalIn;
    const denominator = totalIn + totalOut;
    const risk = denominator > 0 && totalLoss * 100 > 5 * denominator ? 1 : 0;
    report.push([netProfit, totalLoss, risk]);
  }
  return report;
}

const rl = readline.createInterface({ input: process.stdin, output: process.stdout, terminal: false });
const lines = [];
rl.on("line", (line) => lines.push(line));
rl.on("close", () => {
  const data = lines.join("");
  const firstEnd = data.indexOf("]");
  const queryEnd = data.lastIndexOf("]]");
  const warehouses = getInts(data.slice(0, firstEnd + 1));
  const queryNums = getInts(data.slice(firstEnd + 1, queryEnd + 2));
  const numOfWarehouse = Number(data.slice(queryEnd + 2).trim());
  const queries = [];
  for (let i = 0; i < queryNums.length; i += 3) queries.push([queryNums[i], queryNums[i + 1], queryNums[i + 2]]);
  const ans = solve(warehouses, queries, numOfWarehouse);
  console.log(`[${ans.map((row) => `[${row.join(",")}]`).join(",")}]`);
});

C++

#include <bits/stdc++.h>
using namespace std;

vector<vector<int>> solve(const vector<int>& warehouses, const vector<array<int, 3>>& queries, int numOfWarehouse) {
    // 每天 3 个指标，按仓库数量反推出每个仓库的数据天数
    int days = warehouses.size() / (numOfWarehouse * 3);
    vector<vector<int>> prefixIn(numOfWarehouse, vector<int>(days + 1));
    vector<vector<int>> prefixOut(numOfWarehouse, vector<int>(days + 1));
    vector<vector<int>> prefixLoss(numOfWarehouse, vector<int>(days + 1));

    // 对每个仓库分别建立入库、出库、损耗前缀和
    for (int warehouse = 0; warehouse < numOfWarehouse; warehouse++) {
        int base = warehouse * days * 3;
        for (int day = 0; day < days; day++) {
            int index = base + day * 3;
            prefixIn[warehouse][day + 1] = prefixIn[warehouse][day] + warehouses[index];
            prefixOut[warehouse][day + 1] = prefixOut[warehouse][day] + warehouses[index + 1];
            prefixLoss[warehouse][day + 1] = prefixLoss[warehouse][day] + warehouses[index + 2];
        }
    }

    // 使用区间差计算每个查询结果，并用整数比较判断是否超过 5%
    vector<vector<int>> report;
    for (auto query : queries) {
        int warehouse = query[0], startDay = query[1], endDay = query[2];
        int totalIn = prefixIn[warehouse][endDay + 1] - prefixIn[warehouse][startDay];
        int totalOut = prefixOut[warehouse][endDay + 1] - prefixOut[warehouse][startDay];
        int totalLoss = prefixLoss[warehouse][endDay + 1] - prefixLoss[warehouse][startDay];
        int netProfit = totalOut - totalIn;
        int denominator = totalIn + totalOut;
        int risk = denominator > 0 && totalLoss * 100 > 5 * denominator ? 1 : 0;
        report.push_back({netProfit, totalLoss, risk});
    }
    return report;
}

vector<int> extractInts(const string& text) {
    vector<int> nums;
    int sign = 1, value = 0;
    bool reading = false;
    for (char ch : text) {
        if (ch == '-') {
            sign = -1;
        } else if (isdigit((unsigned char)ch)) {
            value = value * 10 + (ch - '0');
            reading = true;
        } else if (reading) {
            nums.push_back(sign * value);
            sign = 1; value = 0; reading = false;
        } else {
            sign = 1;
        }
    }
    if (reading) nums.push_back(sign * value);
    return nums;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    string data((istreambuf_iterator<char>(cin)), istreambuf_iterator<char>());
    int firstEnd = data.find(']');
    int queryEnd = data.rfind("]]");
    vector<int> warehouses = extractInts(data.substr(0, firstEnd + 1));
    vector<int> queryNums = extractInts(data.substr(firstEnd + 1, queryEnd - firstEnd + 1));
    int numOfWarehouse = stoi(data.substr(queryEnd + 2));
    vector<array<int, 3>> queries;
    for (int i = 0; i < (int)queryNums.size(); i += 3) queries.push_back({queryNums[i], queryNums[i + 1], queryNums[i + 2]});
    vector<vector<int>> ans = solve(warehouses, queries, numOfWarehouse);
    cout << "[";
    for (int i = 0; i < (int)ans.size(); i++) {
        if (i > 0) cout << ",";
        cout << "[" << ans[i][0] << "," << ans[i][1] << "," << ans[i][2] << "]";
    }
    cout << "]\n";
    return 0;
}

Go

package main

import (
	"bufio"
	"fmt"
	"io"
	"os"
	"regexp"
	"strconv"
	"strings"
)

func solve(warehouses []int, queries [][3]int, numOfWarehouse int) [][]int {
	// 每个仓库每天有 3 个指标，由数组长度反推出天数
	days := len(warehouses) / (numOfWarehouse * 3)
	prefixIn := make([][]int, numOfWarehouse)
	prefixOut := make([][]int, numOfWarehouse)
	prefixLoss := make([][]int, numOfWarehouse)
	for i := 0; i < numOfWarehouse; i++ {
		prefixIn[i] = make([]int, days+1)
		prefixOut[i] = make([]int, days+1)
		prefixLoss[i] = make([]int, days+1)
	}

	// 分别累计入库、出库和损耗，查询区间时只需做前缀差
	for warehouse := 0; warehouse < numOfWarehouse; warehouse++ {
		base := warehouse * days * 3
		for day := 0; day < days; day++ {
			index := base + day*3
			prefixIn[warehouse][day+1] = prefixIn[warehouse][day] + warehouses[index]
			prefixOut[warehouse][day+1] = prefixOut[warehouse][day] + warehouses[index+1]
			prefixLoss[warehouse][day+1] = prefixLoss[warehouse][day] + warehouses[index+2]
		}
	}

	// 按查询顺序输出净利润、损耗和风控标记
	report := [][]int{}
	for _, query := range queries {
		warehouse, startDay, endDay := query[0], query[1], query[2]
		totalIn := prefixIn[warehouse][endDay+1] - prefixIn[warehouse][startDay]
		totalOut := prefixOut[warehouse][endDay+1] - prefixOut[warehouse][startDay]
		totalLoss := prefixLoss[warehouse][endDay+1] - prefixLoss[warehouse][startDay]
		netProfit := totalOut - totalIn
		denominator := totalIn + totalOut
		risk := 0
		if denominator > 0 && totalLoss*100 > 5*denominator {
			risk = 1
		}
		report = append(report, []int{netProfit, totalLoss, risk})
	}
	return report
}

func extractInts(text string) []int {
	re := regexp.MustCompile(`-?\d+`)
	matches := re.FindAllString(text, -1)
	nums := []int{}
	for _, item := range matches {
		value, _ := strconv.Atoi(item)
		nums = append(nums, value)
	}
	return nums
}

func main() {
	reader := bufio.NewReader(os.Stdin)
	raw, _ := io.ReadAll(reader)
	data := string(raw)
	firstEnd := strings.Index(data, "]")
	queryEnd := strings.LastIndex(data, "]]")
	warehouses := extractInts(data[:firstEnd+1])
	queryNums := extractInts(data[firstEnd+1 : queryEnd+2])
	numOfWarehouse, _ := strconv.Atoi(strings.TrimSpace(data[queryEnd+2:]))
	queries := [][3]int{}
	for i := 0; i < len(queryNums); i += 3 {
		queries = append(queries, [3]int{queryNums[i], queryNums[i+1], queryNums[i+2]})
	}
	ans := solve(warehouses, queries, numOfWarehouse)
	parts := []string{}
	for _, row := range ans {
		parts = append(parts, fmt.Sprintf("[%d,%d,%d]", row[0], row[1], row[2]))
	}
	fmt.Printf("[%s]\n", strings.Join(parts, ","))
}

C语言

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

typedef struct {
    int warehouse;
    int startDay;
    int endDay;
} Query;

void solve(int warehouses[], int warehouseCount, Query queries[], int queryCount, int numOfWarehouse, int result[][3]) {
    // 每个仓库每天包含 3 个指标，所以可计算出每个仓库的天数
    int days = warehouseCount / (numOfWarehouse * 3);
    int prefixIn[105][105] = {0};
    int prefixOut[105][105] = {0};
    int prefixLoss[105][105] = {0};

    // 为所有仓库构建三类前缀和，便于快速查询连续日期区间
    for (int warehouse = 0; warehouse < numOfWarehouse; warehouse++) {
        int base = warehouse * days * 3;
        for (int day = 0; day < days; day++) {
            int index = base + day * 3;
            prefixIn[warehouse][day + 1] = prefixIn[warehouse][day] + warehouses[index];
            prefixOut[warehouse][day + 1] = prefixOut[warehouse][day] + warehouses[index + 1];
            prefixLoss[warehouse][day + 1] = prefixLoss[warehouse][day] + warehouses[index + 2];
        }
    }

    // 对每条查询使用前缀和差值计算结果，并判断损耗率是否大于 5%
    for (int i = 0; i < queryCount; i++) {
        int warehouse = queries[i].warehouse;
        int startDay = queries[i].startDay;
        int endDay = queries[i].endDay;
        int totalIn = prefixIn[warehouse][endDay + 1] - prefixIn[warehouse][startDay];
        int totalOut = prefixOut[warehouse][endDay + 1] - prefixOut[warehouse][startDay];
        int totalLoss = prefixLoss[warehouse][endDay + 1] - prefixLoss[warehouse][startDay];
        int denominator = totalIn + totalOut;
        result[i][0] = totalOut - totalIn;
        result[i][1] = totalLoss;
        result[i][2] = denominator > 0 && totalLoss * 100 > 5 * denominator ? 1 : 0;
    }
}

int extractInts(const char text[], int nums[]) {
    int count = 0, value = 0, sign = 1, reading = 0;
    for (int i = 0; text[i] != '\0'; i++) {
        if (text[i] == '-') {
            sign = -1;
        } else if (isdigit((unsigned char)text[i])) {
            value = value * 10 + (text[i] - '0');
            reading = 1;
        } else if (reading) {
            nums[count++] = sign * value;
            value = 0; sign = 1; reading = 0;
        } else {
            sign = 1;
        }
    }
    if (reading) nums[count++] = sign * value;
    return count;
}

int main(void) {
    char data[50000];
    int len = 0, ch;
    while ((ch = getchar()) != EOF && len < (int)sizeof(data) - 1) data[len++] = (char)ch;
    data[len] = '\0';
    char *firstEnd = strchr(data, ']');
    char *queryEnd = strstr(data, "]]");
    char *last = NULL;
    while (queryEnd != NULL) {
        last = queryEnd;
        queryEnd = strstr(queryEnd + 1, "]]");
    }
    queryEnd = last;
    char warehouseText[30000], queryText[20000], numText[100];
    strncpy(warehouseText, data, firstEnd - data + 1);
    warehouseText[firstEnd - data + 1] = '\0';
    strncpy(queryText, firstEnd + 1, queryEnd - firstEnd + 1);
    queryText[queryEnd - firstEnd + 1] = '\0';
    strcpy(numText, queryEnd + 2);

    int warehouses[30000], queryNums[30000];
    int warehouseCount = extractInts(warehouseText, warehouses);
    int queryNumCount = extractInts(queryText, queryNums);
    int numOfWarehouse = 0;
    sscanf(numText, "%d", &numOfWarehouse);
    int queryCount = queryNumCount / 3;
    Query queries[10005];
    for (int i = 0, j = 0; i < queryCount; i++) {
        queries[i].warehouse = queryNums[j++];
        queries[i].startDay = queryNums[j++];
        queries[i].endDay = queryNums[j++];
    }
    int result[10005][3];
    solve(warehouses, warehouseCount, queries, queryCount, numOfWarehouse, result);
    printf("[");
    for (int i = 0; i < queryCount; i++) {
        if (i > 0) printf(",");
        printf("[%d,%d,%d]", result[i][0], result[i][1], result[i][2]);
    }
    printf("]\n");
    return 0;
}

完整用例

用例1

[3, 8, 1, 5, 12, 0, 2, 6, 0, 4, 10, 1][[0, 0, 2]]1

用例2

[10, 20, 5, 10, 20, 5, 10, 20, 5, 5, 15, 2, 5, 15, 2, 5, 15, 2][[0, 0, 2], [1, 0, 1]]2

用例3

[0,0,0,10,0,0][[0,0,0],[0,0,1]]1

用例4

[50,50,5][[0,0,0]]1

用例5

[50,50,6][[0,0,0]]1

用例6

[100,150,10,200,300,0,20,100,1,30,90,9][[0,1,1],[1,0,1],[0,0,1]]2

用例7

[5,10,1,10,5,2,0,100,6][[0,0,0],[1,0,0],[2,0,0]]3

用例8

[1,2,0,2,2,1,3,3,1,4,4,1][[0,0,3],[0,0,0],[0,1,2]]1

用例9

[0,0,0,0,0,0,1000,2000,100,1000,0,0,500,500,50,500,500,0][[0,0,1],[1,0,1],[2,0,0]]3

用例10

[10,30,1,20,20,2,30,10,3,40,60,4,50,70,5,100,50,10,80,120,20,60,90,0,40,100,5,20,80,1][[0,0,4],[1,1,3],[1,0,4]]2

在这里插入图片描述

标签

#华为od #java #c语言 #华为od新系统 #华为od机考