华为OD机考双机位C卷 - 补种未成活胡杨 (Java & Python & JS & GO & C++ & C)

2026华为OD机考新系统真题 + 双机位C卷 + 往年真题 - 题库目录分值说明 + 考点说明+在线OJ 2026年4月1日起,华为OD机试正式切换至新系统模式!采用力扣模式,无需自己写输入! 难度大幅度降低。正在备考华为OD机试的同学,优先刷新系统机试真题,可大幅提升通过率。 新系统考题考点与旧版一致,无需重新适应。本专栏所有算法题均配有详细思路解析,并提供C语言、JS、C++、Python、Go、Java多语言源码实现。订阅后私信即可开通专属OJ刷题权限,高效备考一次上岸! 阅读详情

补种未成活胡杨

2026华为OD机试双机位C卷 - 华为OD上机考试双机位C卷 100分题型

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

题目描述

近些年来,我国防沙治沙取得显著成果。某沙漠新种植N棵胡杨(编号1-N),排成一排。

一个月后,有M棵胡杨未能成活。

现可补种胡杨K棵,请问如何补种(只能补种,不能新种),可以得到最多的连续胡杨树?

输入描述

N 总种植数量,1 <= N <= 100000

M 未成活胡杨数量,M 个空格分隔的数,按编号从小到大排列,1 <= M <= N

K 最多可以补种的数量,0 <= K <= M

输出描述

最多的连续胡杨棵树

示例1

输入

5
2
2 4
1

输出

3

说明

补种到2或4结果一样,最多的连续胡杨棵树都是3。

示例2

输入

10
3
2 4 7
1

输出

6

说明

种第7棵树,最多连续胡杨树棵数位6(5,6,7,8,9,10)

解题思路

这道题目主要是考察如何通过补种胡杨树,使得胡杨树形成【最长的连续序列】。

示例解释

示例1

输入:

5
2
2 4
1

解释:

  • 胡杨树总共有 5 棵,编号分别是 1, 2, 3, 4, 5。
  • 未成活的胡杨树编号是 2 和 4。
  • 只能补种 1 棵树。

选择补种位置:

  • 可以补种编号为2的树,得到序列 1, 2, 3,最多连续 3 棵树。
  • 或者补种编号为4的树,得到序列 3, 4, 5,同样可以得到最多连续 3 棵树。

因此,输出结果为 3。

示例2

输入:

10
3
2 4 7
1

解释:

  • 胡杨树总共有 10 棵,编号分别是 1 到 10。
  • 未成活的胡杨树编号是 2, 4, 7。
  • 只能补种 1 棵树。

选择补种位置:

  • 如果补种编号为7的树,可以形成最长连续序列 5, 6, 7, 8, 9, 10,连续的胡杨树棵数为 6。
  • 其他补种选择(如2或4)得到的最长连续胡杨树棵数较少。

因此,输出结果为 6。

代码思路

基本与下题一致:

1004. 最大连续1的个数 III

参考题解:https://leetcode.cn/problems/max-consecutive-ones-iii/solutions/608931/zui-da-lian-xu-1de-ge-shu-iii-by-leetcod-hw12/

双指针解法,容易理解

Java

import java.util.*;

public class Main {
    public static void main(String[] args) {
        // 创建一个扫描器对象,用于读取输入
        Scanner scanner = new Scanner(System.in);
        
        // 读取总共的胡杨树数量
        int total = scanner.nextInt();
        
        // 读取未成活的胡杨树数量
        int deadCount = scanner.nextInt();
        
        // 创建一个数组来表示每棵树是否成活,0表示成活,1表示未成活
        int[] nums = new int[total];
        
        // 初始化数组,所有元素设为0,表示所有树最初都是成活的
        Arrays.fill(nums, 0);
 
        // 根据输入,将未成活的树的位置标记为1
        for (int i = 0; i < deadCount; i++) {
            int num = scanner.nextInt();
            nums[num - 1] = 1; // 树的编号从1开始,因此需要减1
        }
        
        // 读取可以补种的树的数量
        int supplementCount = scanner.nextInt();
        
        // 初始化滑动窗口的左右边界
        int left = 0;
        int maxLen = 0; // 用于存储最大连续成活区域的长度
        int sumLeft = 0; // 滑动窗口左边界的未成活树数量
        int sumRight = 0; // 滑动窗口右边界的未成活树数量
        
        // 遍历所有的树,right代表滑动窗口的右边界
        for (int right = 0; right < total; right++) {
            sumRight += nums[right]; // 更新右边界的未成活树数量
            
            // 如果窗口内的未成活树数量大于可以补种的数量
            while (sumRight - sumLeft > supplementCount) {
                sumLeft += nums[left]; // 缩小窗口,左边界右移
                left++;
            }
            
            // 更新最大成活区域的长度
            maxLen = Math.max(maxLen, right - left + 1);
        }
        
        // 输出最大连续成活区域的长度
        System.out.println(maxLen);
    }
}

Python

# 读取胡杨树的总数N
total = int(input())

# 读取未成活胡杨树的数量M
dead_count = int(input())

# 读取未成活胡杨树的编号列表
dead_list = list(map(int, input().split()))

# 读取可以补种的胡杨树数量K
supplement_count = int(input())

# 初始化数组,所有树最初都是成活的,0表示成活,1表示未成活
nums = [0] * total

# 根据输入,将未成活的树的位置标记为1
for num in dead_list:
    nums[num - 1] = 1  # 树的编号从1开始,因此需要减1

# 初始化滑动窗口的左右边界
left = 0
max_len = 0  # 用于存储最大连续成活区域的长度
sum_left = 0  # 滑动窗口左边界的未成活树数量
sum_right = 0  # 滑动窗口右边界的未成活树数量

# 遍历所有的树,right代表滑动窗口的右边界
for right in range(total):
    sum_right += nums[right]  # 更新右边界的未成活树数量
    
    # 如果窗口内的未成活树数量大于可以补种的数量
    while sum_right - sum_left > supplement_count:
        sum_left += nums[left]  # 缩小窗口,左边界右移
        left += 1
    
    # 更新最大成活区域的长度
    max_len = max(max_len, right - left + 1)

# 输出最大连续成活区域的长度
print(max_len)

JavaScript

const readline = require('readline');


const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout
});

const inputLines = [];
rl.on('line', (input) => {
    inputLines.push(input);
});

rl.on('close', () => {
    // 读取胡杨树的总数N
    const total = parseInt(inputLines[0]);

    // 读取未成活胡杨树的数量M
    const deadCount = parseInt(inputLines[1]);

    // 读取未成活胡杨树的编号列表
    const deadList = inputLines[2].split(' ').map(Number);

    // 读取可以补种的胡杨树数量K
    const supplementCount = parseInt(inputLines[3]);

    // 初始化数组,所有树最初都是成活的,0表示成活,1表示未成活
    const nums = new Array(total).fill(0);

    // 根据输入,将未成活的树的位置标记为1
    deadList.forEach(num => {
        nums[num - 1] = 1; // 树的编号从1开始,因此需要减1
    });

    // 初始化滑动窗口的左右边界
    let left = 0;
    let maxLen = 0; // 用于存储最大连续成活区域的长度
    let sumLeft = 0; // 滑动窗口左边界的未成活树数量
    let sumRight = 0; // 滑动窗口右边界的未成活树数量

    // 遍历所有的树,right代表滑动窗口的右边界
    for (let right = 0; right < total; right++) {
        sumRight += nums[right]; // 更新右边界的未成活树数量
        
        // 如果窗口内的未成活树数量大于可以补种的数量
        while (sumRight - sumLeft > supplementCount) {
            sumLeft += nums[left]; // 缩小窗口,左边界右移
            left++;
        }
        
        // 更新最大成活区域的长度
        maxLen = Math.max(maxLen, right - left + 1);
    }

    // 输出最大连续成活区域的长度
    console.log(maxLen);
});

C++

#include <iostream>
#include <vector>
#include <algorithm> 

using namespace std;

int main() {
    int total, deadCount;
    cin >> total >> deadCount;

    // 初始化数组,所有树最初都是成活的,0表示成活,1表示未成活
    vector<int> nums(total, 0);

    // 根据输入,将未成活的树的位置标记为1
    for (int i = 0; i < deadCount; i++) {
        int num;
        cin >> num;
        nums[num - 1] = 1; // 树的编号从1开始,因此需要减1
    }

    // 读取可以补种的树的数量
    int supplementCount;
    cin >> supplementCount;

    // 初始化滑动窗口的左右边界
    int left = 0, maxLen = 0, sumLeft = 0, sumRight = 0;

    // 遍历所有的树,right代表滑动窗口的右边界
    for (int right = 0; right < total; right++) {
        sumRight += nums[right]; // 更新右边界的未成活树数量

        // 如果窗口内的未成活树数量大于可以补种的数量
        while (sumRight - sumLeft > supplementCount) {
            sumLeft += nums[left]; // 缩小窗口,左边界右移
            left++;
        }

        // 更新最大成活区域的长度
        maxLen = max(maxLen, right - left + 1);
    }

    // 输出最大连续成活区域的长度
    cout << maxLen << endl;

    return 0;
}

Go

package main

import "fmt"

func main() {
    // 1. 读取总数和未成活数
    var total, deadCount int
    fmt.Scan(&total, &deadCount)

    // 创建切片,默认值为0(代表成活)
    nums := make([]int, total)

    // 标记未成活的树(设为1)
    for i := 0; i < deadCount; i++ {
        var idx int
        fmt.Scan(&idx)
        // 题目编号从1开始,所以下标要-1
        if idx > 0 && idx <= total {
            nums[idx-1] = 1
        }
    }

    // 读取补种卡数量
    var supplementCount int
    fmt.Scan(&supplementCount)

    // 2. 滑动窗口逻辑
    left := 0
    maxLen := 0
    deadInWindow := 0 // 窗口内死树的数量

    // range 遍历,right 自动增加
    for right, val := range nums {
        deadInWindow += val

        // 如果死树超过了补种能力,左边界收缩
        for deadInWindow > supplementCount {
            deadInWindow -= nums[left]
            left++
        }

        // 更新最大长度
        currentLen := right - left + 1
        if currentLen > maxLen {
            maxLen = currentLen
        }
    }

    fmt.Println(maxLen)
}

C语言

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

// 定义一个max函数,用于求两个数中的最大值
int max(int a, int b) {
    return (a > b) ? a : b;
}

int main() {
    int total, deadCount;

    scanf("%d %d", &total, &deadCount);

    // 初始化数组,所有树最初都是成活的,0表示成活,1表示未成活
    int *nums = (int *)calloc(total, sizeof(int));

    // 根据输入,将未成活的树的位置标记为1
    for (int i = 0; i < deadCount; i++) {
        int num;
        scanf("%d", &num);
        nums[num - 1] = 1; // 树的编号从1开始,因此需要减1
    }

    // 读取可以补种的树的数量
    int supplementCount;
    scanf("%d", &supplementCount);

    // 初始化滑动窗口的左右边界
    int left = 0, maxLen = 0, sumLeft = 0, sumRight = 0;

    // 遍历所有的树,right代表滑动窗口的右边界
    for (int right = 0; right < total; right++) {
        sumRight += nums[right]; // 更新右边界的未成活树数量

        // 如果窗口内的未成活树数量大于可以补种的数量
        while (sumRight - sumLeft > supplementCount) {
            sumLeft += nums[left]; // 缩小窗口,左边界右移
            left++;
        }

        // 更新最大成活区域的长度
        maxLen = max(maxLen, right - left + 1);
    }

    // 输出最大连续成活区域的长度
    printf("%d\n", maxLen);

    // 释放动态分配的内存
    free(nums);

    return 0;
}

单指针解法,比较难理解

Java

import java.util.Scanner;
import java.util.ArrayList;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // 读取胡杨树的总数N
        int total = scanner.nextInt();
        
        // 读取未成活胡杨树的数量M
        int deadCount = scanner.nextInt();

        // 存储未成活胡杨树编号的列表
        ArrayList<Integer> deadList = new ArrayList<>();
        
        // 读取未成活胡杨树的编号
        for (int i = 0; i < deadCount; i++) {
            int num = scanner.nextInt();
            deadList.add(num);
        }

        // 读取可以补种的胡杨树数量K
        int supplementCount = scanner.nextInt();
        
        // 初始化最大连续胡杨树的长度
        int maxLen = 0;
        
        // 遍历可能的补种位置,寻找最长连续胡杨树的长度
        for (int i = supplementCount - 1; i < deadCount; i++) {
            if (i == supplementCount - 1) {
                // 考虑补种后,从开头到第一个无法成活的区域
                maxLen = Math.max(maxLen, supplementCount == deadCount ? total : deadList.get(supplementCount) - 1);
            } else if (i == deadCount - 1) {
                // 考虑补种后,从最后一个无法成活的区域到结尾
                maxLen = Math.max(maxLen, total - deadList.get(i - supplementCount));
            } else {
                // 计算补种后的最大连续胡杨树
                maxLen = Math.max(maxLen, deadList.get(i + 1) - deadList.get(i - supplementCount) - 1);
            }
        }

        // 输出结果
        System.out.println(maxLen);
    }
}

Python

# 读取胡杨树的总数N
total = int(input())

# 读取未成活胡杨树的数量M
deadCount = int(input())

# 读取未成活胡杨树的编号列表
deadList = list(map(int, input().split()))

# 读取可以补种的胡杨树数量K
supplementCount = int(input())

# 初始化最大连续胡杨树的长度
maxLen = 0

# 遍历可能的补种位置,寻找最长连续胡杨树的长度
for i in range(supplementCount-1, deadCount):
    if i == supplementCount-1:
        # 考虑补种后,从开头到第一个无法成活的区域
        maxLen = max(maxLen, total if supplementCount == deadCount else deadList[supplementCount]-1)
    elif i == deadCount-1:
        # 考虑补种后,从最后一个无法成活的区域到结尾
        maxLen = max(maxLen, total - deadList[i-supplementCount])
    else:
        # 计算补种后的最大连续胡杨树
        maxLen = max(maxLen, deadList[i+1]-deadList[i-supplementCount]-1)

# 输出结果
print(maxLen)

JavaScript

const readline = require('readline');

const rl = readline.createInterface({
  input: process.stdin,
  output: process.stdout
});

let totalNum, deadNum, deadIdx, maxReplantNum;

rl.on('line', (input) => {
  if (!totalNum) {
    // 读取胡杨树的总数N
    totalNum = parseInt(input);
  } else if (!deadNum) {
    // 读取未成活胡杨树的数量M
    deadNum = parseInt(input);
  } else if (!deadIdx) {
    // 读取未成活胡杨树的编号列表
    deadIdx = input.split(' ').map(Number);
  } else {
    // 读取可以补种的胡杨树数量K
    maxReplantNum = parseInt(input);
    
    let max = 0;
    
    // 遍历可能的补种位置,寻找最长连续胡杨树的长度
    for (let i = maxReplantNum - 1; i < deadNum; i++) {
      if (i === maxReplantNum - 1) {
        // 考虑补种后,从开头到第一个无法成活的区域
        max = Math.max(max, maxReplantNum === deadNum ? totalNum : deadIdx[maxReplantNum] - 1);
      } else if (i === deadNum - 1) {
        // 考虑补种后,从最后一个无法成活的区域到结尾
        max = Math.max(max, totalNum - deadIdx[i - maxReplantNum]);
      } else {
        // 计算补种后的最大连续胡杨树
        max = Math.max(max, deadIdx[i + 1] - deadIdx[i - maxReplantNum] - 1);
      }
    }
    
    // 输出结果
    console.log(max);
    rl.close();
  }
});

C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int main() {
    // 读取胡杨树的总数N
    int total;
    int deadCount;
    cin >> total >> deadCount;

    // 存储未成活胡杨树编号的列表
    vector<int> deadList;
    for (int i = 0; i < deadCount; i++) {
        int num;
        cin >> num;
        deadList.push_back(num);
    }

    // 读取可以补种的胡杨树数量K
    int supplementCount;
    cin >> supplementCount;

    // 初始化最大连续胡杨树的长度
    int maxLen = 0;

    // 遍历可能的补种位置,寻找最长连续胡杨树的长度
    for (int i = supplementCount - 1; i < deadCount; i++) {
        if (i == supplementCount - 1) {
            // 考虑补种后,从开头到第一个无法成活的区域
            maxLen = max(maxLen, supplementCount == deadCount ? total : deadList[supplementCount-1] - 1);
        } else if (i == deadCount - 1) {
            // 考虑补种后,从最后一个无法成活的区域到结尾
            maxLen = max(maxLen, total - deadList[i - supplementCount]);
        } else {
            // 计算补种后的最大连续胡杨树
            maxLen = max(maxLen, deadList[i + 1] - deadList[i - supplementCount] - 1);
        }
    }

    // 输出结果
    cout << maxLen << endl;

    return 0;
}

Go

package main

import "fmt"

func main() {
	// 读取胡杨树的总数和死亡数
	var total, deadCount int
	fmt.Scan(&total, &deadCount)

	// 创建切片存储未成活胡杨树的编号
	deadList := make([]int, deadCount)
	for i := 0; i < deadCount; i++ {
		fmt.Scan(&deadList[i])
	}

	// 读取可以补种的胡杨树数量
	var supplementCount int
	fmt.Scan(&supplementCount)

	// 初始化最大连续胡杨树的长度
	maxLen := 0

	// 遍历可能的补种位置,寻找最长连续胡杨树的长度
	for i := supplementCount - 1; i < deadCount; i++ {
		var currentLen int
		
		if i == supplementCount-1 {
			// 考虑补种后,从开头到第一个无法成活的区域
			if supplementCount == deadCount {
				currentLen = total
			} else {
				currentLen = deadList[supplementCount] - 1
			}
		} else if i == deadCount-1 {
			// 考虑补种后,从最后一个无法成活的区域到结尾
			currentLen = total - deadList[i-supplementCount]
		} else {
			// 计算补种后的最大连续胡杨树
			currentLen = deadList[i+1] - deadList[i-supplementCount] - 1
		}
		
		if currentLen > maxLen {
			maxLen = currentLen
		}
	}

	// 输出结果
	fmt.Println(maxLen)
}

C语言

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

int main() {
    // 读取胡杨树的总数N
    int total, deadCount;
    scanf("%d %d", &total, &deadCount);

    // 分配内存用于存储未成活胡杨树的编号
    int* deadList = (int*)malloc(deadCount * sizeof(int));
    for (int i = 0; i < deadCount; i++) {
        scanf("%d", &deadList[i]);
    }

    // 读取可以补种的胡杨树数量K
    int supplementCount;
    scanf("%d", &supplementCount);

    // 初始化最大连续胡杨树的长度
    int maxLen = 0;

    // 遍历可能的补种位置,寻找最长连续胡杨树的长度
    for (int i = supplementCount - 1; i < deadCount; i++) {
        if (i == supplementCount - 1) {
            // 考虑补种后,从开头到第一个无法成活的区域
            maxLen = maxLen > (supplementCount == deadCount ? total : deadList[supplementCount] - 1) 
                     ? maxLen : (supplementCount == deadCount ? total : deadList[supplementCount] - 1);
        } else if (i == deadCount - 1) {
            // 考虑补种后,从最后一个无法成活的区域到结尾
            maxLen = maxLen > (total - deadList[i - supplementCount]) 
                     ? maxLen : (total - deadList[i - supplementCount]);
        } else {
            // 计算补种后的最大连续胡杨树
            maxLen = maxLen > (deadList[i + 1] - deadList[i - supplementCount] - 1) 
                     ? maxLen : (deadList[i + 1] - deadList[i - supplementCount] - 1);
        }
    }

    // 输出结果
    printf("%d\n", maxLen);

    // 释放分配的内存
    free(deadList);

    return 0;
}

完整用例

用例1

5
2
2 4
1

用例2

10
3
2 4 7
1

用例3

6
1
3
0

用例4

7
3
1 2 5
2

用例5

8
4
2 4 6 8
2

用例6

6
1
3
0

用例7

10
3
2 4 7
1

用例8

7
4
1 2 5 6
3

用例9

7
2
4 6
1

用例10

8
4
2 4 6 8
4

fengmian

2026华为OD机考双机位C卷++ 双机位B卷 + 双机位A卷 + 2025C/B/A卷+ 往年真题 - 题库目录分值说明 + 考点说明+在线OJ 2025华为OD机考双机位C卷++ 双机位B卷 + 双机位A卷 + 2025C/B/A卷+ 往年真题 - 题库目录分值说明 + 考点说明+在线OJ 阅读详情

相关推荐

华为OD机考双机位C卷 - 补种未成活胡杨 (Java & Python& JS & C/C++ & GO )

华为OD机考双机位C卷 - 补种未成活胡杨(OD上机考试双机位C卷)。提供在线OJ刷题。Java、C++、Python、GO语言、C语言、JavaScript题解,并提供完整思路讲解。

算法大师! 2419

【持续更新】华为OD机考双机位C卷 真题解析|备考攻略+高分刷题技巧+高频考点分类+在线OJ刷题

本专栏包含华为 OD 机试最新的 双机位C卷+双机位B卷+ 双机位A卷题库,并持续更新。专栏所有算法题全部包含题目描述、输入输出和详细的思路讲解以及JS、C++、Python、Go、java 源码实现。同时免费提供最新的在线OJ 刷题系统,订阅专栏之后可以私信我开通OJ权限。

qq_45776114的博客 1208

2026华为OD机试(JAVA&Go)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,Java实现。

MISAYAONE的博客 34万+

Scrum 敏捷框架完全指南

形式化的质量检查清单,只有满足 DoD 的增量才能交付。

Cat_fish_snow的博客 458

2026华为OD机试(Python)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,Python实现。

MISAYAONE的博客 29万+

2026华为OD机试(JavaScript)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,JavaScript实现。

MISAYAONE的博客 8万+

miniPC Type‑C 一线连屏设计:LDR6021Q 标准 TCPC 与 TCPC + 方案解析

无需主机 MCU 参与。主控策略层(TCPM,参考 PY32F003F18P6‑E):全权处理连接去抖、PDO/RDO 解析、电源合同管理、PR‑Swap/DR‑Swap 角色交换、VDM 处理、DP Alt Mode 协商、MUX 与 HPD 控制全部上层业务逻辑。乐得瑞 LDR6021Q QFN16 单口 USB‑PD 控制器,同一硬件支持标准 TCPC、TCPC + 两套固件方案,针对性解决 miniPC Type‑C 供电、DP 一线连屏、扩展坞兼容难题,兼顾深度定制与快速量产,无需改版 PCB。

Huns668的博客 223

2026华为OD机试(C语言)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,C语言实现。

MISAYAONE的博客 11万+

InnoDB 内存结构总览:Change Buffer、AHI 与 Log Buffer

本文系统梳理InnoDB内存结构中的ChangeBuffer、Adaptive Hash Index(AHI)与LogBuffer。ChangeBuffer缓存二级索引页不在内存时的变更,减少随机IO,仅在页加载时合并;聚簇索引修改立即执行,因数据本身不可延后。AHI基于高频等值查询自动构建哈希索引,加速定位,仅支持等值操作。LogBuffer为redo log内存缓冲,配合磁盘日志实现崩溃恢复。三者均服务于性能优化,其中ChangeBuffer与AHI共享BufferPool空间,而LogBuffer独立

bksczm的博客 312

2026华为OD机试(C++)真题【E卷+A卷+B卷+C卷+D卷】目录+在线OJ

华为OD机试真题题库【E卷+A卷+B卷+C卷+D卷】目录,C++实现。

MISAYAONE的博客 20万+

AMD显卡跑MiniMax H3提速30%:SageAttention ROCm适配全记录

在Transformer架构的视频生成模型中,注意力计算往往是性能瓶颈,尤其当显存资源受限时,低精度量化与内核优化成为关键突破口。SageAttention通过将QK^T矩阵乘法量化为INT8,并以FP16/INT4表达注意力概率矩阵,在保证画质的前提下显著降低访存与计算开销,相比传统FlashAttention具备更高速度上限。这一技术价值在本地部署场景尤为突出——当用户使用非NVIDIA显卡运行大型视频模型时,通用优化库常因依赖CUDA而失效。本文聚焦AMD ROCm平台下的MiniMax H3视频生成

weixin_32238157的博客 293

第三篇 第 6 课

前置:第三篇第 1 课(stdx 引入),第二篇第 1 课(std.regex)。环境:仓颉 SDK 1.2.0。本文所有代码与输出均逐行实测。

weixin_41618057的博客 561

通达信浮筹多空波段抓牛擒龙指标公式源码

VAR33:=VA3>=REF(VA4,1) AND C<REF(C,1) AND VAR19=60 AND VAR18=0 AND 活跃线>=REF(活跃线,1) AND VA12<REF(VA13,1);DRAWTEXT(VAR28 AND COUNT(VAR28,30)=1,65,' ★超涨注意风险'),COLOR0000FF;DRAWTEXT(VAR26 AND COUNT(VAR26,30)=1,90,' ←继续等'),COLOR00FFFF;浮筹线:VA3,COLORFF00FF;

2401_86043146的博客 5284

信创环境下PageOffice文档控件适配与实践

信创适配做到文档控件这一层,拼的已经不是"有没有国产版本",而是同一个功能在两类终端上是否真的等价。等价的标准很具体:同一次点击能得到同样的结果,同一份公文能得到同样的版式,同一个项目不需要维护两套代码。这背后是三件并不轻松的工作:服务端用一套接口同时支撑两类终端,客户端把两种系统与四种芯片的安装包分发清楚,文档内核层由产品侧跟着 WPS 的版本走。浏览器这一层的压力,则被收进了产品自己的窗口里——升级节奏由产品掌握,不再交给运气。

zi_wu_xian的专栏 340

硬件原理图:从软件思维到硬件接口的嵌入式开发破局指南

本文为软件开发者提供了读懂硬件原理图的嵌入式开发破局指南。文章将硬件原理图类比为“硬件系统的架构图”,引导读者将软件API调用思维迁移到硬件接口理解上,详细解析了电阻、电容、二极管等常见元器件的“硬件API”功能与选型逻辑,并通过实战电路拆解,阐述了从原理图分析到驱动代码编写的完整思维链条,帮助开发者建立软硬件协同的系统级视角。

lg888的博客 498

【人工智能】OpenClaw网关API速率限制报错全解析 API rate limit reached. Please try again later.

对应HTTP标准状态码为429(请求过多)。该报错集中出现在OpenClaw GATEWAY DASHBOARD的聊天会话界面,核心特征为:用户最初以为是单一模型服务商的问题,先后更换OpenAI、Gemini、Ollama、Moonshot、Mercury-2等多个主流大模型API后,该报错仍稳定触发,尤其在执行复杂任务时高频出现。

奶爸的编程之路,也就一周冷个三天 6461

【从零理解 Spring AI · 12】MCP 的两种角色:做客户端还是做服务端

上一篇讲了 MCP 的概念:标准协议、三大角色、M+N 替代 M×N。

nice_lcj520的博客 630

【机器学习与数据挖掘实战 | 商务】案例03:基于k近邻算法的非侵入式电力负荷监测与分解的电力分析

本案例结合非侵入式电力负荷监测与分解的案例,重点介绍了在数据可视化的辅助下k近邻算法的应用。首先利用数据可视化寻找数据的特征,构建特征集合。然后构建k近邻模型,利用构建的特征集合训练模型,接着利用该模型对单一设备所属类别进行判定,最后计算实时用电量。

Morse_Chen的博客 2306

spring boot 4集成SQLLite,及其SQLLite的建库

spring boot 4集成SQLLite,及其SQLLite的建库

weixin_41463944的博客 267

18-XLINX的XC7A100T的BANK0引脚说明

DXP_0和 DXN_0是纯输入引脚,Xilinx Artix-7 FPGA 内部集成的一个片上监控模数转换器​ 的差分模拟输入对,模数转换器​的模拟信号输入端,将外部的模拟电压​ 采样并转换为内部的数字值,是一个单向的信号采集过程。它是与 VCCADC配对的关键引脚,共同为内部的精密模数转换器提供一个纯净、安静、独立的参考地平面。多FPGA同步配置: 在多FPGA系统中,主FPGA配置完成后,可以拉低从FPGA的 INIT_B使其等待,等所有FPGA都准备好后,再同时释放,实现同步启动。

weixin_44479192的博客 234

对称式目镜设计实例

对称式目镜设计实例

weixin_72050316的博客 1163

pcl2启动器下载(Minecraft PCL2 启动器 最新版 安装与使用说明)

摘要:PCL2(Plain Craft Launcher 2)是一款面向 Minecraft 的第三方启动器,支持正式版与快照版本管理、模组与整合包安装、Java 运行时自动匹配,绿色免安装、双击即可运行。适合在 Windows 上玩单机整合包、需要多版本共存或离线启动的用户使用

2611_96675819的博客 252

《电磁兼容设计》专栏说明

本专栏自2024年1月起开始更新,仅设此一个电磁兼容相关知识专栏,并将一直持续更新下去,无期限

linkking27的博客 795

Java 集合容器高频面试题全解:HashMap 树化阈值、1.7 死循环与 ConcurrentHashMap 演进(2026 招聘 JD 真题复盘)

HashMap 树化阈值 8 的泊松分布依据、退化阈值 6 的防抖设计、JDK 1.7 头插成环死循环的排查与修复、1.8 尾插后为何仍线程不安全、ConcurrentHashMap 放弃分段锁的原因与 ForwardingNode 协作扩容、computeIfAbsent 死锁陷阱、大集合找重复的场景题选型,附三层追问链自测。题目来源为 38 期公开招聘 JD 样本与字节、拼多多、建行、美团、快手公开面经。

蒙眼过河 438

文档:亲测可用解决vnc灰屏,黑屏,鼠标大黑叉情况

主要解决vnc-viewer灰屏,黑屏,鼠标大黑叉等现象,详细见文档。

SAP B1中文培訓教材_SDK

公司内部培训资料,对开发工具 ,DIAPI, UIAPI,Add-ON有详细解说

spdlog 同步日志库使用详解

spdlog是一个轻量级 C++ 日志库,支持同步日志、异步日志、多线程日志、日志文件轮转和自定义日志格式。对于嵌入式 Linux 应用开发,我建议先使用。它可以帮我们完成:日志级别过滤。时间戳和线程 ID 输出。日志格式化。终端和文件输出。多线程安全写入。日志文件按大小或时间轮转。我们不需要自己实现互斥锁、文件写入、日志格式化和轮转等底层功能。

zengjiajun2006的博客 1150

IMSL CNL 7.0.0 (x86-64)Crack

IMSL CNL 7.0.0 (x86-64)Crack intel的算法库破解文件,这是C++版本的破解文件

JavaSE通关手册:数据类型与变量

代码无需额外处理,编译时编译器自动完成转换。

xys_678的博客 237

复分析 阿尔福斯(Ahlfors) 第三版答案 英文

答案分为十章,有部分习题没有答案,全英文复分析阿尔福斯(Ahlfors) 第三版答案

上一篇: 6.3华为OD机试真题 新系统 - 资源二分类隔离判定 (Java/Py/C/C++/Js/Go)
下一篇: 6.3华为OD机试真题 新系统 - 返回所有加载的AGENTS.md文件ID列表 (Java/Py/C/C++/Js/Go)
算法大师
算法大师 新星创作者: 算法与数据结构技术领域 新星创作者: 算法与数据结构技术领域
博客等级 码龄5年 1万+粉丝 1686原创
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

算法大师

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值