day04.双指针+位运算+离散化+区间合并

原创 已于 2025-05-19 11:40:20 修改 · 1k 阅读 · 17 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
Acwing算法基础

当前文章被收录于：

Acwing算法基础
12 篇文章 0 人学习
订阅专栏 查看详情
于 2025-02-06 23:34:57 首次发布

一、双指针（两类）

双指针算法的核心是将O(n^2)的算法优化到O(n)。
在这里插入图片描述

  • 类别一：两个指针维护两个序列（如 归并）
    在这里插入图片描述
  • 类别二：两个指针维护一个序列–首尾（如 快排）
    在这里插入图片描述

1.思想

① 遍历
② 更新

2.模板

for (int i = 0, j = 0; i < n; i ++ )  //i从0开始，j从某一点开始
{
    while (j < i && check(i, j))   //每次i更新完，就要更新j
    	j ++ ;                   //前提是 j在合法范围内，且满足某种性质

    // 具体问题的逻辑
}
常见问题分类：
    (1) 对于一个序列，用两个指针维护一段区间
    (2) 对于两个序列，维护某种次序，比如归并排序中合并两个有序序列的操作

3.题目

（1）将一串英文字符按单词分隔开，单词间以空格分割。
如：
输出： abc dfg
输出：abc
dfg

在这里插入图片描述

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

int main() {
	char str[100];
	gets(str);      //读取一行文本并存储在str中
	int n = strlen(str); //计算以 null 字符 '\0' 结束的字符串的长度
	for (int i = 0; i < n; i++) {
		int j = i;
		while (j < n && str[j] != ' ') {
			cout << str[j];
			j++;
		}
		cout << endl;

		i = j;
	}
	retur 0;
}

（2）799.最长连续不重复子序列
在这里插入图片描述
在这里插入图片描述

const int N=10010;
int n;
int a[N],s[N];

int main() {
	cin>>n;
	for(int i=0;i<n;i++)
		cin>>a[i];
		
	int res=0;
	for(int i=0,j=0;i<n;i++){    // j表示滑动窗口的左边界
		s[a[i]]++;     // 存储每个数 出现次数 的数组
		
		// 如果当前数字出现次数大于 1，说明有重复，调整左边界
		while(s[a[i]]>1){  
			s[a[j]]--;  //减少左边界指向的数字出现的次数
			j++;        // 左边界右移
		}
		res=max(res,i-j+1);
	}
	cout << res <<endl;
	return 0;
}

二、位运算

1.思想&&模板

  • 求n的第k位数字: n >> k & 1
    在这里插入图片描述
int main() {
	int n = 10;      // 10的二进制表示
	for (int k = 3; k >= 0; k--)
		cout << (n >> k & 1);     // 1010
}
  • 返回n的最后一位1：lowbit(n) = n & -n
    在这里插入图片描述
int lowbit(int x){
	return x&-x;
}

2.题目（801.二进制中1d个数）

在这里插入图片描述

int lowbit(int x){
	return x&-x;
}

int main() {
	int n;
	cin>>n;
	while(n--){
		int x;
		cin>>x;
		
		int res=0;    //存储结果
		//只要x不为0，就减去lowbit，减多少次就有多少个1；
		while(x){
			x=x-lobit(x);
			res++;
		}
		cout<<res<<endl;		
	}
	return 0;
}

三、离散化

若有一个数组范围很大，但元素很少，在保证相对位置不变的前提下，则可以将其下标映射到一个新数组中，减少空间的浪费。
在这里插入图片描述

1.思想&&模板

① 数组去重—利用库函数可以实现 排序+去重

vector<int> alls; // 存储所有待离散化的值
sort(alls.begin(), alls.end()); // 将所有值排序
alls.erase(unique(alls.begin(), alls.end()), alls.end());   // 去掉重复元素
// unique会将重复元素置于数组末尾，并返回独一无二元素中最后一个元素的下标。
//erase 再将unique的返回值作为起点，删除末尾的元素 即完成去重。
  • 关于unique方法的实现（利用双指针）
    在这里插入图片描述
vector<int>::iterator unique(vector<int> &a){
	int j=0;      // 用于追踪新数组中的元素，即独一无二的元素
	for(int i=0;i<a.size();i++)
		if(!i||a[i]!=a[i-1])   //不是第一个元素 且 不与前一个元素相同（不重复）
			a[j++]=a[i];       //可以理解为加入新数组
	// a[0]~a[j-1] 所有a中不重复的数
	
	return a.begin()+j;	
}

② 二分求出 x 对应的离散化值（快速查找某个值在排序后的数据中的位置）

int find(int x)       // 找到第一个大于等于x的位置
{
    int l = 0, r = alls.size() - 1;
    while (l < r)
    {
        int mid = l + r >> 1;
        if (alls[mid] >= x) r = mid;
        else l = mid + 1;
    }
    return r + 1; // 映射到1, 2, ...n
    // +1 表示从1开始映射
}

2.题目（802.区间和）

在这里插入图片描述
分析：
（1）n次操作，m次问询，由于每次问询设计两个位置，故该题共涉及n+2 * m个数。
核心：在保证这n+2 * m个数字在相对位置不变的情况下，将他们存入数组，去重排序作为基准，便于进行离散化。
tips：由于1<=n，m<=10000,即最多进行10000次操作和10000次问询，n+2 * m<=30000。故存储这n+2 *m个位置的数组的容量应设置为30000个，同时避免re，令N=30010。

（2）将n次操作中的位置 x 进行离散化，更新数轴。
（3）m次询问中的位置l，r进行离散化，求前缀和。

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

typedef pair<int,int> PII;    // 定义双元数组
const int N=300010;    //n+2m

int n,m;              // n次操作，m次问询
int a[n],s[n];        // a数组模拟数轴，全为0; s数组 存储前缀和

vector<int> alls;       // 存储 x,l,r 的数值
vector<PII> add,query;  // 数组存储 ①操作参数，②问询参数

int find(x){    // 找大于x的最小值
	int l=0,r=a.size()-1;
	while(l<r){
		int mid = l+(r-l)/2;
		if(alls[mid]>=x)
			r=mid;
	}
	return r+1;     //	
}

int main() {
	cin >> n >> m;            // 1.1
	for(int i=0;i<n;i++){     // 1.2 读入操作参数
		int x,c;
		cin >> x >> c;
		add.push_back({x,c})
		
		alls.push_back(x);     // 单独存储 操作 中的 位置参数 x
	}
	for(int i=0;i<m;i++){     // 1.3 读入问询参数
		int l.r;
		cin >> l >> r;
		query.push_back({l,r});
		
		alls.push_back(l);
		alls.push_back(r);		
	}
//----------------------------------------------
	// 2.去重
	sort(alls.begin(),alls.end());
	alls.erase(unique(alls.begin(),alls.end()),alls.end());
	
	// 3.处理 操作步骤
	// 3.1 更新
	for(auto item:add){
		int x = find(item.first);     // 对 x 离散化
		a[x] = a[x] + item.second;    // 某一位置x上的数+c
	}
	// 3.2 处理前缀和,为 询问 做准备
	for (int i=0;i<alls.size();i++){
		s[i]=s[i-1]+a[i];
	}
	
	// 4.处理询问
	for (auto item:query){
		int l=find(item.first);
		int r=find(item.second);
		cout << s[r]-s[l-1] << endl;
	}

	return 0;
}

四、区间合并

把有交集的区间合并。

1.思想

（1）按照区间的左端点排序。
（2）区间与区间的关系有三种：包含，相交，不相交。
① 包含则不用管；
② 相交则合并；
③ 不相交则不用合并。

  • 综合来说，包含 和 相交 的处理原则可以合并：左端点不变，将右端点更新为 两个区间右端点的最大值。
  • ③ 不相交时，则将当前区间加入结果区间，将下一个不相交区间作为当前区间。
    在这里插入图片描述

2.模板

// 将所有存在交集的区间合并
void merge(vector<PII> &segs)
{
    vector<PII> res;

    sort(segs.begin(), segs.end());

    int st = -2e9, ed = -2e9;
    for (auto seg : segs)
        if (ed < seg.first)
        {
            if (st != -2e9) res.push_back({st, ed});
            st = seg.first, ed = seg.second;
        }
        else ed = max(ed, seg.second);

    if (st != -2e9) res.push_back({st, ed});

    segs = res;
}

3.题目（803.区间合并）

在这里插入图片描述

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

const int N = 100010;

typedef pair<int, int> PII;   // 定义双元数组，便于存储区间。
vector<PII> segs;

void merge(vector<PII> &sges) {
	vector<PII> res;    // 结果数组

	sort(segs.begin(), segs.end()); //会先按照第一关键字排序，相同时再按照第二关键字排序。

	int st = -2e9, ed = -2e9;   // 当前区间的左端点，右端点
	for (auto seg : segs) {
		if (seg.first > ed) {  // 情况3：不相交
			if (st != -2e9)     // 若当前区间非空区间，则加入结果集
				res.push_back({st, ed});
			st = seg.first;     // 将 下一个不相交的区间 作为 当前区间
			ed = seg.second;
		} else
			ed = max(ed, seg.second);
	}
	
	if (st != -2e9)   // 原始集合中最后一个 区间。
		res.push_back({st, ed});

	segs = res;
}

int main() {
	int n;
	cin >> n;

	for (int i = 0; i < n; i++) {
		int l, r;
		cin >> l >> r;
		segs.push_back({l, r});
	}

	merge(segs);

	cout << segs.size() << endl;
	return 0;
}

五、贪心区间问题

5.1 （AcWing 905.区间选点）

题意：从N个闭区间中选出最少的点覆盖所有区间。
思想：

  1. 将所有区间的右端点 从小到大 排序
  2. 枚举每一个区间：
    ① 若当前区间中已经包含点，则跳过该区间。
    ② 否则，选点并更新右端点为当前区间的右端点。

在这里插入图片描述

#include <iostream>
#include <algorithm>
using namespace std;
const int N=100010;

// 定义区间结构体
struct Range
{
    int l,r;
    bool operator< (const Range &W)const
    {
        return r<W.r;
    }
}range[N];
int n;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int l,r;
        cin>>l>>r;
        range[i]={l,r};
    }
    
    // 1.排序
    sort(range,range+n);

	// 2.遍历
    int res=0,ed=-2e9;   //res表示选点的数量,ed为右端点
    for(int i=0;i<n;i++)
        if(range[i].l > ed)    // 该区间与上一区间 未重合
        {
            res++;          // 选点
            ed = range[i].r;  // 更新右端点
        }

    cout<<res;
    return 0;
}

5.2 （AcWing 908.最大不相交区间数量）

同上一题一样，选出来点的数量==最大不相交区间的数量。
在这里插入图片描述

#include <iostream>
#include <algorithm>
using namespace std;
const int N=100010;
struct Range
{
    int l,r;
    bool operator< (const Range &W)const
    {
        return r<W.r;
    }
}range[N];
int n;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int l,r;
        cin>>l>>r;
        range[i]={l,r};
    }
    sort(range,range+n);
    int res=0,st=-2e9;
    for(int i=0;i<n;i++)
        if(range[i].l>st)
        {
            res++;
            st=range[i].r;
        }
    cout<<res;
    return 0;
}

5.3 （AcWing 906.区间分组）

1.将所有区间按照 左端点从小到大 排序
2. 遍历所有的区间：使用 小根堆 存储每个组最后一个区间的右端点值。
① 如果当前区间的 左端点 <= 堆中最小右端点 （相交），说明该区间不能放进任何一个分组，则将这个区间加入堆**（新开一组）。
② 如果当前区间左端点 > 堆中最小右端点（不相交），说明该区间能够放进任意一个组中，则将其放入右端点最小的组。将右端点最小的组的右端点更新**

在这里插入图片描述

#include <iostream>
#include <queue>
#include <algorithm>
using namespace std;
const int N=100010;
struct Range
{
    int l,r;
    bool operator <(const Range &W)const
    {
        return l<W.l;
    }
}range[N];
int n;
int main()
{
    cin>>n;
    for(int i=0;i<n;i++)
    {
        int l,r;
        cin>>l>>r;
        range[i]={l,r};
    }

	// 1.排序
    sort(range,range+n);
    priority_queue<int ,vector<int> ,greater<int> > heap;   //小顶堆

	// 2.遍历
    for(int i=0;i<n;i++)
    {
        if(heap.empty()||heap.top()>=range[i].l)   // ① 相交
        	heap.push(range[i].r);
        else
        {
            heap.pop();       // 起到更新 最小右端点的作用。
            heap.push(range[i].r);
        }
    }
    
    //堆中有多少个最小右端点，就有多少个组。
    cout<<heap.size();
}
标签
#算法 #数据结构 #c++
RFPDupeFilter 与请求指纹算法详解
Minner
08-22 308
Scrapy 2.17 去重源码详解：RFPDupeFilter 就是一个 set 加一个文件。拆解指纹算法，实测暴露默认端口与相对路径不归一化两个坑，给出规整中间件和自定义指纹方案。
LauterBach使用教程
热门推荐
wacebb的博客
03-10 1万+
（也就是服务器上编译时候的路径一模一样的路径，选中到工程目录就可以）4.选择自己板子对应的cpu（可以直接界面选择也可以命令行的方式）(cpu里的system setting)，我们板子需要sys复位，所以选择sys。注：一般情况下运行状态不可以修改外设寄存器的值，但是可以通过修改配置来修改为运行时可修改（cpu寄存器则不可以）（修改这个配置，运行时也可以查看代码）注意：lauterbach可以使用命令来操作，但是由于本人刚刚使用，目前基本上使用的都是界面的按钮，以后会陆续学习命令行指令和脚本的方式。
小红书 算法一面 十一
XLYcmy的博客
08-20 441
例如 **Soft MoE** 采用这种方式，大幅提升负载均衡性，但会增加计算开销。- **熵正则化**：直接最大化门控概率分布的熵，熵越大表示分布越均匀，公式为 $\mathcal{L}_{ent} = -\frac{1}{N}\sum_{i=1}^N\sum_{k=1}^K p_{ik}\log p_{ik}$。- **核心原理**：源自 **GShard** 和 **Switch Transformer**，通过最小化专家选择概率分布的熵，迫使门控网络给每个专家分配相近的 token 数量。
北斗导航 ｜ 从零开始学习基于奇偶矢量的接收机自主完好性监测（RAIM）算法及改进
尘世冰封的专栏
08-22 379
接收机自主完好性监测（Receiver Autonomous Integrity Monitoring, RAIM）是GNSS接收机内部的一种算法，它仅利用冗余的伪距观测量来判断定位结果是否可靠、是否存在故障卫星，并能识别和排除故障卫星。奇偶矢量法是RAIM最经典的实现方式之一，它将不可直接观测的测量误差映射到一个“奇偶空间”中，使故障检测变得简单且服从精确的概率分布。w\mathbf{w}w虽然能反映故障，但它的协方差矩阵不是单位阵，各分量相关，不利于统计检验。奇偶矢量通过一个正交变换P。
数据库连接算法详解：从基础概念到嵌套循环优化
jiangxiaohanya的博客
08-17 244
2.重复键在归并连接中的处理：排序归并连接遇到相同键时，需要保存或回溯同一键对应的记录组，然后输出笛卡尔积。（2）外连接：即使一方没有数据，也保留该侧数据，用NULL填充。对S中的键计算哈希值；（3）连接基数：连接结果的行数可能远大于任意一张输入表。设外表有R个页面，内表S个页面，比较次数O（R+R*S）5.哈希连接的限制：最适用于等值连接，不直接适用于比较。（1）build阶段：对较小的关系R建立哈希表。（1）内连接：只保留两张表之中能够匹配的内容。若R有M行，S有N行，则比较次数为O（MN）
【数据结构】排序算法：归并排序与基数排序
bianyuan172的博客
08-23 295
本文介绍了归并排序和基数排序两种非比较型排序算法。归并排序采用分治策略，通过递归分割与合并实现排序，时间复杂度稳定为O(nlogn)，空间复杂度O(n)，具有稳定性。基数排序则基于数字位数进行分配收集，时间复杂度O(d(n+r))，适用于固定位数的整数或字符串排序。文章通过示例详细说明了两者的执行过程，并对比了八大排序算法的关键特性，包括时间复杂度、空间复杂度和稳定性。最后通过典型例题展示了两种排序的应用场景和解题思路，强调归并排序的分治思想和基数排序的LSD实现是考试重点。（149字）
LeetCode 1. 两数之和 | 从暴力枚举到哈希表最优解 + 空间换时间思想全复盘
yc2284238579的博客
08-19 263
文章摘要 题目要求在数组中找到两数之和等于目标值的下标。核心思路是优化查找效率： 暴力法：双重循环枚举所有数对，时间复杂度O(n²)，效率低但易实现。 哈希表优化：利用哈希表O(1)查找特性，遍历时存储已访问元素，每次计算差值并查询，时间复杂度降至O(n)。关键细节是先查后存，避免自匹配。 代码实现：哈希表法通过一次遍历完成，空间换时间，边界处理需注意空数组和不足两元素的情况。 常见错误：内层循环起始点、哈希表键值设计、立即返回结果等易错点需警惕。 面试要点：优先选择哈希表解法，解释与暴力法的差异，强调时间
算法日常・每日刷题--＜BFS＞4
2503_92261635的博客
08-18 259
题目摘要： 给定一个由'X'和'O'组成的矩阵，要求捕获所有被'X'完全包围的'O'区域（即不与边界连通的区域），并将其替换为'X'。解法核心是逆向处理： 标记边界连通区域：遍历矩阵四边，对边界上的'O'进行BFS/DFS，标记所有与之连通的'O'为临时符号（如'.'），表示这些区域未被包围。 批量修改：遍历整个矩阵，将未被标记的'O'（被包围的）改为'X'，同时恢复标记的'.'为'O'。 示例： 输入： [['X','X','X','X'], ['X','O','O','X'], ['X','X','O'
10.LeetCode算法习题讲解--滑动窗口--最大连续为一的个数
Jammy_1的博客
08-19 225
利用滑动窗口解决最大连续1的个数
算法日常・每日刷题--＜BFS&&最短路径＞4
最新发布
2503_92261635的博客
08-23 216
675. 为高尔夫比赛砍树 - 力扣（LeetCode）675. 为高尔夫比赛砍树 - 你被请来给一个要举办高尔夫比赛的树林砍树。树林由一个 m x n 的矩阵表示， 在这个矩阵中： * 0 表示障碍，无法触碰 * 1 表示地面，可以行走 * 比 1 大的数 表示有树的单元格，可以行走，数值表示树的高度每一步，你都可以向上、下、左、右四个方向之一移动一个单位，如果你站的地方有一棵树，那么你可以决定是否要砍倒它。你需要按照树的高度从低向高砍掉所有的树，每砍过一颗树，该单元格的值变为 1（即变为地面）。
S 曲线加减速算法完整详解（C# 原生实现，无第三方库）
工业上位机开发工程师，专注C#底层算法与工控仪器开发。从零手写信号滤波、曲线拟合、机器视觉、排序与密码学哈希，纯原生实现零第三方库，附数学推导与可编译源码，可移植STM32/PLC。
08-17 989
S 曲线加减速是工业运动控制核心轨迹规划算法，相比梯形曲线，依靠约束加加速度 Jerk 实现加速度连续变化，有效消除机械冲击与振动。本文完整讲解七段式 S 曲线原理、阶段推演、时间预规划逻辑，剖析短行程自动裁剪等工程难点。提供无第三方依赖原生 C# 完整实现，内置运动状态机，支持正反方向运动，基于解析多项式实时求解位置、速度、加速度，无积分累积误差。代码可直接用于伺服上位机、模组轨迹发生器，亦可精简移植嵌入式平台。同时对比算法优劣与适用场景，适合工控开发、伺服调试、嵌入式运动算法学习者参考。
Tokenization（分词算法）：一切大语言模型的地基
2301_80194949的博客
08-18 205
本文深入解析了Tokenization（分词算法）这一大语言模型的基础技术。Tokenization将原始文本切分为模型可处理的子词单元并映射为数字ID，是模型理解文本的第一步。
LeetCode 28. 找出字符串中第一个匹配项的下标（暴力匹配 + KMP 算法详解）
2603_95532426的博客
08-20 231
本文介绍了LeetCode 28题"找出字符串中第一个匹配项的下标"的两种解法：暴力匹配和KMP算法。暴力匹配通过逐个字符比较实现，时间复杂度O(m×n)；KMP算法利用next数组跳过不必要匹配，时间复杂度O(m+n)。文章详细解释了KMP的核心思想，包括next数组的定义和构建过程，并提供了Python和Java的代码实现。两种方法各具特点：暴力匹配简单直观，KMP更高效但实现复杂，适合处理长字符串匹配问题。
一文读懂：字典序的第K小数字
2501_92927469的博客
08-22 216
可以按照层次遍历子树，firsti 指向第 i 层的最左侧的孩子节点， lasti 指向第 i 层的最右侧的孩子节点，根据推理可以知道: firsti = 10 × firsti − 1 ，lasti = 10 × lasti − 1 + 9 ，第 i 层共有 lasti − firsti + 1 个节点，由于所有的节点都需要满足小于等于 n ，所以第 i 层的最右侧节点应该为 min(n,lasti) ，不断迭代直到 firsti > n 则终止向下搜索。
算法效率的度量（上）：时间复杂度中的对数思维
Guangyu536的博客
08-23 211
本文系统讲解算法时间复杂度的分析方法，重点解析对数和对数线性复杂度。主要内容包括：1）大O表示法的核心规则（保留最高阶项、忽略系数）；2）对数复杂度O(logN)的三种典型场景（循环折半、二分查找、递归折半）；3）对数线性复杂度O(NlogN)的结构特征（线性遍历嵌套折半操作）；4）提供快速判断口诀和5道典型练习题（含递归分析）。通过代码示例和数学推导，揭示复杂度分析的本质是观察问题规模的缩减速度。
关于字符串【力扣151.反转字符串中的单词的思考】
wasb666的博客
08-17 496
【摘要】本文介绍了字符串反转问题的解决方案。通过三个关键步骤实现：首先去除多余空格，然后整体反转字符串，最后逐个反转单词。方法强调函数封装思想，将不同功能模块化处理。注意事项指出需特别关注函数封装在代码复用和维护中的重要性，这种分步处理方法能有效提高代码可读性和执行效率。
LeetCode 53 最大子数组和：一次遍历掌握 Kadane 算法
weixin_51228134的博客
08-23 497
本文围绕 LeetCode 53“最大子数组和”展开，详细介绍 Kadane 算法的核心思想。通过定义以当前位置结尾的最大子数组和，判断是延续原有子数组还是从当前元素重新开始，并在遍历过程中维护全局最大值。文章结合示例演算、Java 代码和状态转移公式，分析全负数数组等边界情况，总结常见错误。该算法时间复杂度为 O(n)，空间复杂度为 O(1)。
leetcode 104二叉树的最大深度
qq_63176310的博客
08-20 240
为根的树深度是 1。
分治题目：所有可能的真二叉树
stormsunshine的博客
08-18 162
当二叉树中只有一个结点时，唯一的结点是根结点，没有子结点，因此是真二叉树，此时真二叉树中的结点数是奇数。个结点的真二叉树满足左子树和右子树的结点数都是奇数且左子树和右子树的结点数之和是。个结点时，将其中一个叶结点增加两个子结点之后仍为真二叉树，新的真二叉树中有。是奇数时，遍历左子树和右子树的结点数，然后递归地构造左子树和右子树。根据真二叉树的定义，真二叉树中的每个结点的子结点数是。真二叉树中的结点数是奇数，可以使用数学归纳法证明。答案的每个元素都是一个真二叉树的根结点。时只有一个结点的二叉树是真二叉树。
算法札记：利用floyd判环算法优化SPFA判负环算法
Keven_11的博客
08-19 303
本文提出了一种优化SPFA算法检测负环的方法，使用Floyd判环算法替代传统的DFS判环。作者在SPFA中增加了计时器和Floyd判环（龟兔赛跑算法），当步数超过2n时启动判环检查。代码实现中，cycle()函数实现了Floyd判环逻辑，通过比较慢指针和快指针来检测环的存在。经测试，该优化在Acwing平台上比朴素SPFA快50倍，比基于栈的优化版本快1.2-1.4倍。这种方法显著提高了负环检测效率，尤其适用于大规模图论问题。
华为OD机试真题-查找单入口空闲区域(Py/Java/C/C++/Js/Go)
qq_45776114的博客
03-16 1226
华为OD机试(机考)双机位C卷 【查找单入口空闲区域】，提供Java、C++、Python、Go、JavaScript源码实现，并提供完整思路讲解，以及在线OJ模拟做题。华为OD机试 - 查找单入口空闲区域。
H5版仿制微信跳一跳小游戏，网页版仿微信跳一跳小游戏源码，实现了跳一跳的基本核心功能
H5版仿制微信跳一跳小游戏，网页版仿微信跳一跳小游戏源码，实现了跳一跳的基本核心功能
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值