wangkai6666的博客

差量算子是边缘检测的基础工具，通过计算像素间的灰度差来识别图像中的边缘（灰度变化剧烈的区域）核心定义：差量算子是一个 “模板”（如 Roberts、Sobel 算子），通过对图像像素进行局部差分运算，输出像素的灰度变化强度。

这说明：假设f(x,y)是一幅图像，在原点的傅里叶变换等于图像的平均灰度级（M*N是总的像素点，f(x,y)是(x,y)点的灰度值，将所有的像素点的灰度值求和然后除以总的个数即为平均灰度值）对图像而言，图像的边缘部分是突变部分，变化较快，因此反应在频域上是高频分量；高频成分：对应图像中快速变化的区域（如物体边缘、纹理细节、噪声），表现为频谱图中远离中心的部分。因此，频率的大小反应了信号的变化快慢。低频成分：对应图像中缓慢变化的区域（如大片的天空、光滑的墙面），表现为频谱图中靠近中心的部分。

单极脉冲噪声和双极脉冲噪声是图像中两种最常见的脉冲噪声差异在于噪声像素的灰度值偏离方向，前者只向 “极亮” 或 “极暗” 一方向偏移，后者同时向 “极亮” 和 “极暗” 两方向偏移。

腐蚀使目标区域范围“变小”，其实质造成图像的边界收缩，可以用来消除小且无意义的目标物膨胀使目标区域范围“变大”，将目标区域接触的背景点合并到该目标物中，使目标边界向外部扩张。可以用来填补目标区域中某些空洞以及消除包含在目标区域中的小颗粒噪声理解腐蚀的公式和腐蚀的实现理解膨胀的公式和膨胀的实现。

腐蚀是常见的形态学操作之一，它通过从图像边界中去除像素来精细地缩小图像中的对象。它通过考虑每个像素的邻域并将其值设置为该邻域中所有像素中的最小值来实现这一点。在二进制图像中，如果任何相邻像素的值为0，则输出像素也设置为0灰度图像腐蚀运算的核心原理：灰度腐蚀是对图像中每个像素，用结构元素（类似 “模板”）覆盖该像素邻域后计算 “图像邻域值 减去 结构元素对应值” 的最小值将这个最小值作为该像素的腐蚀后结果。

Retinex是一个合成词，它的构成是retina（视网膜）+ cortex（皮层）→ Retinexμ 读作 “缪”（miù，音同 “谬”），是希腊字母 “mu” 的音译，常用于表示均值（如高斯分布的均值）σ 读作 “西格玛”（xī gé mǎ），是希腊字母 “sigma” 的音译，常用于表示标准差（如高斯分布的标准差）

直方图均衡化（Histogram Equalization） ：通过将原始图像的直方图变换为均匀分布的直方图，从而增加图像的全局对比度直方图均衡化去雾是基于图像灰度分布优化和大气散射模型简化假设的去雾方法，核心逻辑是通过调整雾天图像的灰度直方图，增强对比度以削弱雾的 “灰度压缩” 效应。局部直方图均衡化（Local Histogram Equalization） ：在图像的不同区域应用不同的均衡化处理，用于增强局部对比度，适用于图像局部过暗或过亮的情况。

它通过向量的模长和点积来表示两个向量之间的欧式距离，核心是利用向量运算的余弦定理展开：这种推导方式把欧式距离和向量的几何属性（模长、夹角）关联起来，更清晰地体现了它的几何意义 ——两个向量在空间中的直线距离，是欧式距离定义在向量运算场景下的严谨表达。

损失函数（Loss Function） 是机器学习和优化领域的核心工具，用于量化模型预测结果与真实结果的 “差异程度”，是指导模型迭代优化的 “指南针”。定义：损失函数是一个数学函数，输入为 “模型预测值” 和 “真实标签（或目标值）”，输出为一个标量数值，该数值越大表示 “预测与真实的差异越大”，模型性能越差。核心作用：为模型优化提供方向—— 通过最小化损失函数，让模型的预测尽可能接近真实结果，从而提升泛化能力。关键特性总结单调性：预测与真实的差异越大，损失函数值越大。

n个牧师去城市布道，随意选择n个布道点，并把这n个点公告诉所有村民每个村民选择到离自己家最近的布道点去听课，听课后，有的人会觉得距离太远于是每个牧师统计自己课上所有村民的地址，然后搬到这些地址的中心地带，并把新的步道点告诉所有村名每个村民选择到离自己家最近的布道点去听课（比如之前去牧师A处，现在发现去牧师B处更近）牧师每次课后都会更新位置，村民根据情况选择布道点，最终经历若干礼拜后，布道点终于稳定下来。

leetcode-17. 电话号码的字母组合给定一个仅包含数字 2-9 的字符串，返回所有它能表示的字母组合。答案可以按 任意顺序返回。给出数字到字母的映射如下（与电话按键相同）。注意 1 不对应任何字母。示例 1：输入：digits = “23”输出：[“ad”,“ae”,“af”,“bd”,“be”,“bf”,“cd”,“ce”,“cf”]思路：不断把前面的元素拿出来追加，然后再删除之前的元素class Solution {public: vector<vector<s

给一个整数数组 nums 和两个整数 k 和 t 。请判断是否存在 两个不同下标 i 和 j，使得 abs(nums[i] - nums[j]) <= t ，同时又满足 abs(i - j) <= k 。如果存在则返回 true，不存在返回 false。红黑树-set很容易实现范围查找1 set的lower_bound()的运用2 在set中取出符合左边条件的最小值，然后判断它是否满足右边条件的最大值范围3 对超出范围的元素要及时清理哈希桶class Solution

并查集学习博客：https://zhuanlan.zhihu.com/p/93647900/解决元素分组问题。并查集管理一系列不相交的集合，支持两种操作：合并（Union）：把两个不相交的集合合并为一个集合。查询（Find）：查询两个元素是否在同一个集合中。亲戚问题举例题目背景若某个家族人员过于庞大，要判断两个是否是亲戚，确实还很不容易，现在给出某个亲戚关系图，求任意给出的两个人是否具有亲戚关系。题目描述规定：x和y是亲戚，y和z是亲戚，那么x和z也是亲戚。如果x,y是亲戚，那么x的

leetcode-200. 岛屿数量给你一个由 ‘1’（陆地）和 ‘0’（水）组成的的二维网格，请你计算网格中岛屿的数量。岛屿总是被水包围，并且每座岛屿只能由水平方向和/或竖直方向上相邻的陆地连接形成。此外，你可以假设该网格的四条边均被水包围。并查集（Union-find Data Structure）是一种树型的数据结构。它的特点是由子结点找到父亲结点，用于处理一些不交集（Disjoint Sets）的合并及查询问题。Find：确定元素属于哪一个子集。它可以被用来确定两个元素是否属于同一子集。

给你一个 m x n 的矩阵 board ，由若干字符 ‘X’ 和 ‘O’ ，找到所有被 ‘X’ 围绕的区域，并将这些区域里所有的 ‘O’ 用 ‘X’ 填充。正面dfs遍历struct SimplePairHash { std::size_t operator()(const std::pair<int, int>& p) const { return ((p.first) << 16) | p.second; }};class S

给你一棵 二叉树 的根节点 root ，这棵二叉树总共有 n 个节点。每个节点的值为 1 到 n 中的一个整数，且互不相同。给你一个整数 startValue ，表示起点节点 s 的值，和另一个不同的整数 destValue ，表示终点节点 t 的值。请找到从节点 s 到节点 t 的 最短路径 ，并以字符串的形式返回每一步的方向。每一步用 大写 字母 ‘L’ ，‘R’ 和 ‘U’ 分别表示一种方向：‘L’ 表示从一个节点前往它的 左孩子 节点。‘R’ 表示从一个节点前往它的 右孩子 节点。‘U’ 表

leetcode-236. 二叉树的最近公共祖先deque法class Solution {public: deque<TreeNode*> dqp; deque<TreeNode*> dqq; bool findNode(TreeNode* root, deque<TreeNode*>& dq, TreeNode* target) { dq.push_back(root); if(root == target) { return

class Solution {public: ListNode* removeNthFromEnd(ListNode* head, int n) { if(!head || n<=0) return head; ListNode* fast = head; // fast 落在 NULL 上 ListNode* slow = head; // slow 落在被删除的前一个上面 // 倒 1 的话 fast

leetcode-654. 最大二叉树给定一个不重复的整数数组 nums 。最大二叉树 可以用下面的算法从 nums 递归地构建:创建一个根节点，其值为 nums 中的最大值。递归地在最大值 左边 的 子数组前缀上 构建左子树。递归地在最大值 右边 的 子数组后缀上 构建右子树。class Solution {public: TreeNode* constructMaximumBinaryTreeHelper(vector<int>& nums, int start, i

归并排序-分治思想递归做法#include <iostream>#include <vector>using namespace std;void mergeSortHelper(vector<int> &v, int start, int mid, int end, vector<int> &tmp) { int i = start; int j = mid + 1; int k = start; while(i &lt

以快排为模型，对数组递归划分，但递归后只处理包含所查第ｋ个元素的那边，如此递归下去直至查找成功#include <stdio.h>int Randomized_partition(int * a, int p, int r){ int x = a[r]; int i, j; i = p - 1; int temp; for(j = p; j < r; j++) { if(a[j] <= x) { i+=1; temp = a[i]; a[i

leetcode-215. 数组中的第K个最大元素给定整数数组 nums 和整数 k，请返回数组中第 k 个最大的元素。请注意，你需要找的是数组排序后的第 k 个最大的元素，而不是第 k 个不同的元素。示例 1:输入: [3,2,1,5,6,4] 和 k = 2输出: 5大顶堆class Solution {public: void heapSortHelper(vector<int>& nums, int start, int len) { int child =

leetcode-1461. 检查一个字符串是否包含所有长度为 K 的二进制子串给你一个二进制字符串 s 和一个整数 k 。如果所有长度为 k 的二进制字符串都是 s 的子串，请返回 true ，否则请返回 false 。示例 1：输入：s = “00110110”, k = 2输出：true解释：长度为 2 的二进制串包括 “00”，“01”，“10” 和 “11”。它们分别是 s 中下标为 0，1，3，2 开始的长度为 2 的子串。本人最笨的办法class Solution {pub

leetcode-718. 最长重复子数组给两个整数数组 A 和 B ，返回两个数组中公共的、长度最长的子数组的长度。示例：输入：A: [1,2,3,2,1]B: [3,2,1,4,7]输出：3解释：长度最长的公共子数组是 [3, 2, 1] 。动态规划class Solution {public: int findLength(vector<int>& A, vector<int>& B) { int lenA = A.

你这个学期必须选修 numCourses 门课程，记为 0 到 numCourses - 1 。在选修某些课程之前需要一些先修课程。 先修课程按数组 prerequisites 给出，其中 prerequisites[i] = [ai, bi] ，表示如果要学习课程 ai 则 必须 先学习课程 bi 。例如，先修课程对 [0, 1] 表示：想要学习课程 0 ，你需要先完成课程 1 。请你判断是否可能完成所有课程的学习？如果可以，返回 true ；否则，返回 false 。示例 1：输入：numC

如果一个由 ‘0’ 和 ‘1’ 组成的字符串，是以一些 ‘0’（可能没有 ‘0’）后面跟着一些 ‘1’（也可能没有 ‘1’）的形式组成的，那么该字符串是 单调递增 的。我们给出一个由字符 ‘0’ 和 ‘1’ 组成的字符串 s，我们可以将任何 ‘0’ 翻转为 ‘1’ 或者将 ‘1’ 翻转为 ‘0’。返回使 s 单调递增 的最小翻转次数。示例 1：输入：s = “00110”输出：1解释：我们翻转最后一位得到 00111.dpclass Solution {public: int

假如有一排房子，共 n 个，每个房子可以被粉刷成红色、蓝色或者绿色这三种颜色中的一种，你需要粉刷所有的房子并且使其相邻的两个房子颜色不能相同。当然，因为市场上不同颜色油漆的价格不同，所以房子粉刷成不同颜色的花费成本也是不同的。每个房子粉刷成不同颜色的花费是以一个 n x 3 的正整数矩阵 costs 来表示的。例如costs[0][0] 表示第 0 号房子粉刷成红色的成本花费；costs[1][2] 表示第 1 号房子粉刷成绿色的花费，以此类推。请计算出粉刷完所有房子最少的花费成本。示例 1

字符串有三种编辑操作:插入一个字符、删除一个字符或者替换一个字符。给定两个字符串，编写一个函数判定它们是否只需要一次(或者零次)编辑。示例 1:输入:first = “pale”second = “ple”输出: True// 编辑距离的方法class Solution {public: bool oneEditAway(string first, string second) { int len1 = first.length(); int len2 = second.l

编写一种算法，若M × N矩阵中某个元素为0，则将其所在的行与列清零class Solution {public: void setZeroes(vector<vector<int>>& matrix) { unordered_set<int> zero_row; unordered_set<int> zero_col; unordered_set<int>::iterator it_row; unordered

给定两个字符串 s1 和 s2，请编写一个程序，确定其中一个字符串的字符重新排列后，能否变成另一个字符串。示例 1：输入: s1 = “abc”, s2 = “bca”输出: true// 一个往字典中不断加// 一个往字典中不断减class Solution {public: bool CheckPermutation(string s1, string s2) { int len1 = s1.length(); int len2 = s2.length();

给定一个整数数组 nums ，数组中的元素 互不相同。返回该数组所有可能的子集（幂集）。解集 不能 包含重复的子集。你可以按 任意顺序 返回解集。示例 1：输入：nums = [1,2,3]输出：[[],[1],[2],[1,2],[3],[1,3],[2,3],[1,2,3]]这种应该不用去重// 回溯法class Solution {public: vector<vector<int>> res; void subsetsHelper(vector<i

一个整型数组 nums 里除两个数字之外，其他数字都出现了两次。请写程序找出这两个只出现一次的数字。要求时间复杂度是O(n)，空间复杂度是O(1)。示例 1：输入：nums = [4,1,4,6]输出：[1,6] 或 [6,1]方法一：分组异或如果我们可以把所有数字分成两组，使得：两个只出现一次的数字在不同的组中；相同的数字会被分到相同的组中。那么对两个组分别进行异或操作，即可得到答案的两个数字。先对所有数字进行一次异或，得到两个出现一次的数字的异或值。在异或结果中找到任意为 1 的位。

给定两个单链表的头节点 headA 和 headB ，请找出并返回两个单链表相交的起始节点。如果两个链表没有交点，返回 null 。题目数据 保证 整个链式结构中不存在环。注意，函数返回结果后，链表必须 保持其原始结构 。来源：力扣（LeetCode）链接：https://leetcode-cn.com/problems/3u1WK4著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。如果两个链表相交，则公共部分长度肯定相等，假设为c, 那么链表A在公共部分前的长度是a-c,

给定一个单链表 L 的头节点 head ，单链表 L 表示为：L0 → L1 → … → Ln-1 → Ln请将其重新排列后变为：L0 → Ln → L1 → Ln-1 → L2 → Ln-2 → …不能只是单纯的改变节点内部的值，而是需要实际的进行节点交换。// 递归做法class Solution {public: ListNode* left; int left_index = 0; int right_index = 0; // 输入 1->(2) 2->(3)

给定两个 非空链表 l1和 l2 来代表两个非负整数。数字最高位位于链表开始位置。它们的每个节点只存储一位数字。将这两数相加会返回一个新的链表。可以假设除了数字 0 之外，这两个数字都不会以零开头。不可以对原链表进行破坏class Solution {public: // 对齐的情况下递归计算两链表的和 int reverseCalculateSum(ListNode* l1, ListNode* l2, ListNode **new_head) { if(!l1) return 0;

#include <iostream>using namespace std;class LinkedList{public: int val; LinkedList *next; LinkedList(int _val): val(_val), next(NULL){}};// 递归逆序打印单链表void rtraverse(LinkedList *head) { if(!head) return; rtraverse(head->next); cout

#include <iostream>using namespace std;class LinkedList{public: int val; LinkedList *next; LinkedList(int _val): val(_val), next(NULL){}};// 递归逆序打印单链表void rtraverse(LinkedList *head) { if(!head) return; rtraverse(head->next); cout

参考：https://leetcode-cn.com/problems/FortPu/solution/cpython3java-wu-xu-zi-dian-dong-tai-shu-jkxnx/设计一个支持在平均 时间复杂度 O(1) 下，执行以下操作的数据结构：insert(val)：当元素 val 不存在时返回 true ，并向集合中插入该项，否则返回 false 。remove(val)：当元素 val 存在时返回 true ，并从集合中移除该项，否则返回 false 。getRandom：