Z_shsf-CSDN博客

原创【C++】77组合

综合来看，给定的组合算法的时间复杂度是指数级别的，取决于要选择的数的个数和范围的大小。而空间复杂度则主要受递归调用和结果集合的影响。对于每个位置，有两种选择：选或者不选，因此总共有 2^k 种可能的组合，其中 k 为要选择的数的个数。因此，总的空间复杂度为 O(k + C)，其中 k 为要选择的数的个数，C 为所有可能的组合数量。在递归调用过程中，需要 O(k) 的栈空间来存储当前的组合情况，其中 k 为要选择的数的个数。因此，总的时间复杂度为 O(2^k * k)，其中 k 为要选择的数的个数。

2024-05-30 21:15:00 353

原创【C++】每日一题 46 全排列

在回溯算法中，我们仍然尝试了每个数字作为当前位置的可能性，但通过交换元素的方式可以避免生成重复的排列。递归调用过程中，需要额外的空间来存储当前的排列以及记录数字是否被使用的情况。综合来看，修改后的全排列算法的时间复杂度仍然是阶乘级别的，但相比使用额外的标志数组，空间复杂度得到了一定的优化。递归调用过程中，不需要额外的空间来存储记录数字是否被使用的情况，因为我们通过交换元素的方式来避免重复排列。综合来看，全排列算法的时间复杂度是阶乘级别的，空间复杂度也与排列的数量成正比。) 的空间来存储所有可能的排列。

2024-05-30 07:20:47 700

原创【C++】每日一题 50 Pow(x,n)

在这个函数中，我们首先处理n为0和n为负数的情况，然后使用递归的方式计算x的n次幂。如果n为奇数，则将问题分解为计算x的(n-1)/2次幂，然后将结果相乘，并额外乘以x。当 n 为 -2147483648 时，原始的代码中的 myPow(x, -n) 将会调用 myPow(x, 2147483648)，这个值超出了 int 类型的范围，导致了溢出错误。递归调用会使用栈空间，因此考虑递归的深度。当 n 为正数时，我们可以通过递归将指数减半，因此时间复杂度为 O(logn)，因为每次递归我们将指数减半。

2024-05-27 22:56:34 408

原创【CV】视频图像背景分割MOG2,KNN,GMG

给定数据后，可以使用期望最大化（Expectation-Maximization，EM）算法来估计GMM的参数，包括每个高斯分布的均值、方差和混合系数。在使用 GaussianMixture 模型时，random_state 参数用于控制初始化高斯混合模型的随机性，包括初始化聚类中心、对数似然函数等，从而控制着模型中的随机数生成过程。当设置了 random_state 参数时，模型将会使用指定的随机种子来初始化，确保每次运行模型时都得到相同的随机初始化结果。P.S.简单补充下高斯混合模型的知识。

2024-05-27 22:25:22 1010

原创【C++】单词距离

findShortestDistance 函数的时间复杂度取决于两个单词在文本中出现的次数，设为 M 和 K，其中 M 是第一个单词出现的次数，K 是第二个单词出现的次数。需要注意的是，由于哈希表的使用，该优化方案可以显著减少寻找过程中的计算量，但需要额外的空间来存储哈希表和位置列表。遍历数组：在代码中使用了一个 for 循环来遍历输入的单词数组，所以遍历的时间复杂度是 O(n)，其中 n 是单词数组的长度。因此，经过分析，可以得出该算法的时间复杂度为 O(n)，空间复杂度为 O(1)。

2024-05-18 18:18:37 648

原创【C++】每日一题 LCR 027. 回文链表

上述代码中用到了一个辅助函数 reverseList 用于反转链表的后半部分。该函数的时间复杂度为 O(n)，空间复杂度为 O(1)。整体的时间复杂度为 O(n)，空间复杂度为 O(1)。可以使用快慢指针和链表反转的方法来判断链表是否为回文链表。如果一个链表是回文，那么链表节点序列从前往后看和从后往前看是相同的。给定一个链表的头节点 head ，请判断其是否为回文链表。用 O(n) 时间复杂度和 O(1) 空间复杂度解决此题。

2024-05-18 17:32:25 338

原创【CV】opencv调用DIS/LK等计算光流，前一帧和当前帧写反了有什么影响？

多尺度图像金字塔包含了同一图像的不同分辨率版本，通过在不同尺度上计算光流，可以更好地捕捉到不同尺度下的运动信息，提高光流估计的准确性和鲁棒性。错误的运动估计：Lucas-Kanade光流算法假设相邻帧之间的像素运动是基本相似的，因此它通过比较两帧之间的像素差异来估计运动。在计算光流时，常用的方法之一是利用Lucas-Kanade光流算法，该算法假设在一个局部区域内，像素的运动是基本相似的。因为光流是描述相邻帧之间像素移动的一种方法，它通过比较两帧之间的像素强度或特征点的移动来计算物体的运动情况。

2024-05-15 23:06:32 712

原创【C++】每日一题 198 打家劫舍

每间房内都藏有一定的现金，影响你偷窃的唯一制约因素就是相邻的房屋装有相互连通的防盗系统，如果两间相邻的房屋在同一晚上被小偷闯入，系统会自动报警。给定一个代表每个房屋存放金额的非负整数数组，计算你不触动警报装置的情况下，一夜之内能够偷窃到的最高金额。最终，( f(n) ) 就是我们要求的结果，即在不触动警报装置的情况下能够偷窃到的最高金额。然后根据状态转移方程依次求解 ( f(2), f(3), …其中，( nums[i] ) 表示第 ( i ) 个房屋内的现金数量。这是一个典型的动态规划问题。

2024-05-15 22:51:08 218

原创【C++】每日一题 17 电话号码的字母组合

总的来说，这个算法的时间和空间复杂度都是指数级别的，随着输入规模 ( n ) 和每个数字对应的字母集合的大小 ( m ) 的增加，其运行时间和所需空间将急剧增加。最坏情况下，结果数量为 ( O(m^n) )，因此需要 ( O(m^n) ) 的空间。生成结果集合的过程中，需要将所有可能的组合添加到结果集中，这也需要 ( O(m^n) ) 的时间。递归调用栈的深度最多为输入数字串的长度 ( n )，因此需要额外的 ( O(n) ) 的空间。综合起来，整个算法的空间复杂度为 ( O(m^n) )。

2024-05-14 22:48:52 670

原创【C】每日一题 53 最大子数组和

在扫描的过程中，对于每个位置，只需要比较前一个位置的最大子数组和与当前位置的元素的和，因此时间复杂度是线性的。给你一个整数数组 nums ，请你找出一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。动态规划方法只需要使用常数级别的额外空间来存储一些临时变量，如当前位置的最大子数组和以及全局最大子数组和。动态规划方法使用一次线性扫描来计算每个位置的最大子数组和，因此时间复杂度为 O(n)。综上所述，动态规划方法的时间复杂度为 O(n)，空间复杂度为 O(1)。因此，空间复杂度为 O(1)。

2024-05-13 22:27:21 338

原创【CV】计算机视觉是什么？

人脸检测：利用预训练的人脸检测器，如Haar级联检测器或基于深度学习的检测器，检测图像或视频中的人脸。选择合适的立体匹配算法，如基于特征点的匹配（SIFT、SURF）或基于区域的匹配（立体匹配算法）。视差计算：根据匹配到的特征点或区域的偏移量，计算视差值，即左右图像中对应点的水平偏移量。表情分类：利用预训练的模型或算法，对人脸区域进行表情分类，识别出人脸的表情和情绪。目标检测与识别：利用预训练的目标检测模型，检测图像或视频中的物体，并进行识别。动作识别：分析图像或视频中的人或物体的动作，了解场景中的行为。

2024-05-12 23:00:58 1106

原创【C++】148 排序链表

对链表进行升序排序，常见的做法是使用归并排序（Merge Sort）算法。这种算法适用于链表的排序，并且具有稳定性和时间复杂度为 O(n log n) 的优点。使用两个辅助函数 merge 和 sortList。merge 函数用于合并两个有序链表，sortList 函数用于对链表进行归并排序。给你链表的头结点 head ，请将其按升序排列并返回排序后的链表。

2024-05-12 14:01:20 296

原创【CV】计算机视觉中的特征追踪与背景处理

计算机视觉领域中的重要任务之一是视频特征追踪，它可以用于目标跟踪、运动分析、行为识别等应用。然而，在实际应用中，经常会遇到需要仅处理视频中特定特征物体而忽略背景的情况，这就需要进行背景处理。本文将介绍如何使用Python和OpenCV库进行视频特征追踪，并提供针对特定特征物体的背景处理解决方案和示例。

2024-05-10 22:25:20 1113 1

原创【C++】每日一题 103 二叉树的锯齿形层序遍历

在最坏情况下，队列中会存储二叉树的所有叶子节点，而二叉树的叶子节点数量最多为 ( n/2 )，因此队列的空间复杂度为 ( O(n) )。此外，结果数组所需的空间与二叉树的高度成正比，最坏情况下为 ( O(log n) )。因此，总的空间复杂度为 ( O(n) )。这个算法的时间复杂度取决于二叉树的节点数量，假设节点总数为 ( n )。在算法中，我们通过 BFS 遍历了整棵二叉树，每个节点只会被访问一次，因此时间复杂度为 ( O(n) )。给你二叉树的根节点 root ，返回其节点值的锯齿形层序遍历。

2024-05-10 21:10:03 360

原创【C++】每日一题 199. 二叉树的右视图

在最坏情况下，队列中可能会存储二叉树中的所有叶子节点，即二叉树的最后一层。对于完全二叉树，最后一层的节点数量为 n/2，其中 n 是节点总数。可以使用广度优先搜索（BFS）来遍历二叉树，但是在遍历过程中只记录每一层最右侧的节点值。这样最后记录的节点值就是从右侧看到的节点值。给定一个二叉树的根节点 root，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。BFS遍历二叉树需要访问每个节点恰好一次，因此时间复杂度为 O(n)，其中 n 是二叉树中的节点数。

2024-05-09 23:02:55 488 1

原创【C++】236. 二叉树的最近公共祖先

然后，检查当前节点是否等于p或q，如果是，则当前节点就是它们的最近公共祖先。接着递归地在左子树和右子树中查找p和q的最近公共祖先。如果左右子树分别找到了p和q，则当前节点就是它们的最近公共祖先。如果只在左子树或右子树中找到了p或q，则返回左子树或右子树中找到的节点。百度百科中最近公共祖先的定义为：“对于有根树 T 的两个节点 p、q，最近公共祖先表示为一个节点 x，满足 x 是 p、q 的祖先且 x 的深度尽可能大（一个节点也可以是它自己的祖先）。给定一个二叉树, 找到该树中两个指定节点的最近公共祖先。

2024-05-09 21:15:00 226

原创【CV】视频图像滤波技术

视频图像滤波是机器视觉领域中的重要技术之一，它可以有效地去除图像中的噪声、平滑图像、增强图像特征等。本文简要探讨视频图像滤波的原理、常用算法和应用场景。

2024-05-08 22:32:33 1088

原创【C++】每日一题 114 二叉树展开为链表

如果不为空，则找到左子树的最右节点（即左子树中最右边的节点），然后将根节点的右子树接到左子树的最右节点上，接着将整个左子树移到根节点的右子树位置。最后，处理下一个节点，直到遍历完整个二叉树。Morris 遍历算法是一种遍历二叉树的方法，其核心思想是通过线索化二叉树的空闲指针，使得可以在不使用额外空间的情况下遍历整个二叉树。展开后的单链表应该同样使用 TreeNode ，其中 right 子指针指向链表中下一个结点，而左子指针始终为 null。展开后的单链表应该与二叉树先序遍历顺序相同。

2024-05-08 21:15:00 287

原创【CV】双边滤波

双边滤波是一种在图像处理中常用的滤波技术，特别适用于保持图像边缘和纹理细节的情况下进行降噪。在视频图像处理中，双边滤波同样发挥着重要作用，能够有效地提高图像质量和增强视觉效果。

2024-05-07 23:05:53 1401 3

原创【C】每日一题 20 有效的括号

给定一个只包括 ‘(’，‘)’，‘{’，‘}’，‘[’，‘]’ 的字符串 s ，判断字符串是否有效。每个右括号都有一个对应的相同类型的左括号。左括号必须用相同类型的右括号闭合。左括号必须以正确的顺序闭合。

2024-05-07 21:55:32 220

原创【C】137 只出现一次的数字

通常，如果不带后缀的整数常量在程序中出现，并且与无符号整数类型进行运算，那么这个整数常量会被默认为有符号整数类型。因此，当我们需要确保一个整数常量被视为无符号整数时，可以在其后面添加 u 后缀来明确指定。这里，我们使用 (1u << i) 来表示将无符号整数 1 左移 i 位，确保不会出现符号位的影响。通过使用无符号整数，我们可以避免在进行位运算时出现意外的结果，尤其是涉及到位移操作时更需要注意这一点。给你一个整数数组 nums ，除某个元素仅出现一次外，其余每个元素都恰出现三次。

2024-05-05 09:56:18 260

原创【C】190 颠倒二进制位

在这种情况下，输入和输出都将被指定为有符号整数类型，并且不应影响您的实现，因为无论整数是有符号的还是无符号的，其内部的二进制表示形式都是相同的。从给定的 32 位无符号整数 n 的最低位开始，逐位取出并存放到结果 res 的最高位，然后 n 向右移动一位，res 向左移动一位，直到 n 的所有位都取完。原始算法中，我们需要遍历给定的 32 位无符号整数的所有位，进行逐位的颠倒操作。由于只有固定的 32 位，因此遍历的时间复杂度为 O(32)，即 O(1)。颠倒给定的 32 位无符号整数的二进制位。

2024-05-02 22:51:59 456 1

原创【C】67 二进制求和

遍历输入的两个二进制字符串，需要线性时间，即 O(max(m, n))，其中 m 和 n 分别是字符串 a 和 b 的长度。最终返回结果需要反转结果字符串，其时间复杂度也是线性的，为 O(max(m, n))。综上所述，addBinary 函数的时间复杂度为 O(max(m, n))。因此，addBinary 函数的空间复杂度为 O(max(m, n))。给你两个二进制字符串 a 和 b ，以二进制字符串的形式返回它们的和。结果字符串的长度最多为 max(m, n) + 1，因为可能存在进位。

2024-05-01 22:36:08 318

原创【C】153 寻找旋转排序数组中的最小值

这表示当前中间元素 nums[mid] 大于最右侧元素 nums[right]，说明最小元素位于 mid 的右侧（包括 mid 自身）。注意，数组 [a[0], a[1], a[2], …, a[n-1]] 旋转一次的结果为数组 [a[n-1], a[0], a[1], a[2], …, a[n-2]]。总体思路，通过判断当前中间元素 nums[mid] 和最右侧元素 nums[right] 的大小关系，以确定最小元素的位置所在。若旋转 4 次，则可以得到 [4,5,6,7,0,1,2]

2024-04-30 21:59:30 349

原创【C++】每日一题在排序数组中查找元素的第一个和最后一个位置

二分查找结束位置：binarySearchRight函数的时间复杂度也为 O(log n)，同样是通过二分查找来定位目标值的结束位置的。二分查找起始位置：binarySearchLeft函数的时间复杂度为 O(log n)，因为它是通过二分查找来定位目标值的起始位置的。总体时间复杂度：由于我们分别调用了两次 O(log n) 的二分查找函数，因此整体的时间复杂度为 O(log n)。综上所述，该算法的时间复杂度为 O(log n)，空间复杂度为 O(1)。因此，空间复杂度为 O(1)。

2024-04-28 22:42:28 276

原创【CV】特征匹配FAST和MSER

特征匹配是计算机视觉领域的重要概念，涉及在图像中寻找关键点和描述符。FAST和MSER是两种常用的关键点检测算法。

2024-04-26 22:37:13 630

原创【C++】1 两数之和

在这种情况下，{numMap[complement], i} 创建了一个包含两个整数的向量，分别是 numMap[complement] 和 i，它们分别代表了哈希表中目标值的索引和当前元素的索引。给定一个整数数组 nums 和一个整数目标值 target，请你在该数组中找出和为目标值 target 的那两个整数，并返回它们的数组下标。因此，这种方法的时间复杂度是 O(n)，空间复杂度是 O(n)。对于包含 n 个元素的数组，最坏情况下需要存储 n 个元素的索引，因此空间复杂度是 O(n)。

2024-04-26 22:26:25 289

原创【C++】316 去除重复字母

使用了两个辅助的哈希表 last_occurrence 和 visited，它们最多存储字符串中出现的不同字符，因此空间复杂度也为 O(n)。使用了一个栈 st 来存储结果字符串中的字符，最坏情况下栈的大小会达到字符串的长度，因此空间复杂度为 O(n)。遍历字符串以构建最终的结果字符串：O(n)，其中 n 是字符串的长度。给你一个字符串 s ，请你去除字符串中重复的字母，使得每个字母只出现一次。遍历字符串以构建 last_occurrence 字典：O(n)，其中 n 是字符串的长度。

2024-04-25 23:31:03 388

原创【C++】33 搜索旋转排序数组

在传递给函数之前，nums 在预先未知的某个下标 k（0 <= k < nums.length）上进行了旋转，使数组变为 [nums[k], nums[k+1], …, nums[n-1], nums[0], nums[1], …例如， [0,1,2,4,5,6,7] 在下标 3 处经旋转后可能变为 [4,5,6,7,0,1,2]。给你旋转后的数组 nums 和一个整数 target ，如果 nums 中存在这个目标值 target ，则返回它的下标，否则返回 -1。

2024-04-24 23:07:31 413

原创【CV】opencv特征匹配算法

特征匹配是计算机视觉领域中的一项关键任务，它用于在不同图像中寻找相似的特征点，并将它们进行匹配。这些特征点可以是图像中的角点、边缘、斑点等，在不同的图像中可能因为旋转、缩放、光照变化等因素发生变化。在OpenCV中，提供了多种特征匹配算法，其中包括ORB、SIFT、SURF、KAZE、AKAZE等。接下来，简要介绍这些算法，主要给出OpenCV示例。这里挖个坑，每个算法原理后续再填。

2024-04-23 23:10:04 2104 2

原创【C++】162 寻找峰值

时间复杂度：该算法使用二分查找来确定峰值元素的位置。在每次迭代中，我们将搜索范围缩小一半，因此时间复杂度为 O(log n)，其中 n 是输入数组的长度。空间复杂度：这个算法的空间复杂度为 O(1)，因为它只使用了固定数量的额外空间来存储迭代过程中的指针和变量，与输入数组的大小无关。数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。因此，该算法满足了题目要求的时间复杂度为 O(log n) 的要求，并且具有较低的空间复杂度。你必须实现时间复杂度为 O(log n) 的算法来解决此问题。

2024-04-23 22:40:17 209

原创【C++】129 求根节点到叶节点数字之和

对于一个平衡的二叉树，递归深度为 O(log n)，而对于最坏情况下的非平衡二叉树，递归深度为 O(n)。此外，由于没有使用额外的数据结构，除了递归调用栈外，空间复杂度为 O(1)。时间复杂度：对于每个节点，我们只需访问它一次，因此时间复杂度为 O(n)，其中 n 是二叉树中的节点数。给你一个二叉树的根节点 root ，树中每个节点都存放有一个 0 到 9 之间的数字。例如，从根节点到叶节点的路径 1 -> 2 -> 3 表示数字 123。叶节点是指没有子节点的节点。使用深度优先搜索（DFS）解决。

2024-04-22 22:44:03 233

原创【C++】117 填充每个节点的下一个右侧结点指针

填充它的每个 next 指针，让这个指针指向其下一个右侧节点。如果找不到下一个右侧节点，则将 next 指针设置为 NULL。在遍历过程中，通过 next 指针可以找到每个节点的右侧节点，然后进行连接。在每一层中，遍历该层的所有节点，并将它们的 next 指针连接起来。初始状态下，所有 next 指针都被设置为 NULL。从根节点开始层次遍历二叉树。

2024-04-21 22:46:15 191

原创【C++】530 二叉搜索树的最小绝对差

我们可以利用二叉搜索树的性质：中序遍历二叉搜索树可以得到一个升序的节点值序列。因此，我们只需要在中序遍历的过程中计算相邻节点值之间的差值，然后找到最小的差值即可。给你一个二叉搜索树的根节点 root ，返回树中任意两不同节点值之间的最小差值。差值是一个正数，其数值等于两值之差的绝对值。

2024-04-20 23:49:30 459

原创【C++】637二叉树的层平均值

在最坏情况下，队列可能包含二叉树中的所有叶子节点，即二叉树的最后一层节点。在最坏情况下，这个数组将包含二叉树的所有层级的平均值。因此，结果数组的空间复杂度也是 O(N)。遍历每个节点：在最坏情况下，我们需要访问二叉树中的每个节点一次。因此，遍历所有节点的时间复杂度为 O(N)，其中 N 是二叉树中的节点数。每个节点访问的操作：在每个节点处，我们需要执行一些常数时间的操作，例如将节点值相加和将其左右子节点入队。给定一个非空二叉树的根节点 root , 以数组的形式返回每一层节点的平均值。

2024-04-19 23:13:19 305

原创【C++】222 完全二叉树的节点个数

完全二叉树的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~ 2^h 个节点。给你一棵完全二叉树的根节点 root ，求出该树的节点个数。

2024-04-18 23:17:26 222

原创【C++】每日一题 106 从中序与后续遍历序列构造二叉树

给定两个整数数组 inorder 和 postorder ，其中 inorder 是二叉树的中序遍历， postorder 是同一棵树的后序遍历，请你构造并返回这颗二叉树。

2024-04-17 23:23:15 844

原创【C++】每日一题 290 单词规律

在遍历过程中，建立字符到单词的映射和单词到字符的映射，并检查映射是否正确。这里的遵循指完全匹配，例如， pattern 里的每个字母和字符串 s 中的每个非空单词之间存在着双向连接的对应规律。哈希表 charToWord 存储了 pattern 中的每个字符到对应的单词，空间复杂度为 O(字符集大小)。哈希表 wordToChar 存储了 s 中的每个单词到对应的字符，空间复杂度也为 O(单词数量)。遍历 pattern 的过程中，需要将每个字符映射到对应的单词，这需要 O(m) 的时间复杂度。

2024-04-16 23:06:06 698

原创【C++】每日一题 48 旋转图像

通过一次循环遍历每一圈，每次处理四个边界上的元素，实现了原地旋转图像的功能，时间复杂度为 O(n^2)。你必须在原地旋转图像，这意味着你需要直接修改输入的二维矩阵。请不要使用另一个矩阵来旋转图像。给定一个 n × n 的二维矩阵 matrix 表示一个图像。请你将图像顺时针旋转 90 度。观察规律容易发现 matrix[i][j] = matrix[n - 1 - j][i];也可以考虑用其他一次循环解决这个问题，采用分圈处理的方法。

2024-04-15 22:32:10 469

原创【C++】每日一题 54 螺旋矩阵

通过维护四个边界来确定当前遍历的范围，然后依次按照顺时针的方向遍历矩阵，将元素添加到结果数组中。遍历整个矩阵需要访问每个元素一次，因此时间复杂度为 O(m * n)，其中 m 是矩阵的行数，n 是矩阵的列数。除了存储结果的数组外，算法的空间复杂度主要取决于额外的变量和常数大小的空间。给你一个 m 行 n 列的矩阵 matrix ，请按照顺时针螺旋顺序，返回矩阵中的所有元素。输入：matrix = [[1,2,3],[4,5,6],[7,8,9]]输出：[1,2,3,6,9,8,7,4,5]

2024-04-14 12:39:07 339