spider33的博客

参考该blog1、Bloom filter适用范围：可以用来实现数据字典，进行数据的判重，或者集合求交集对于原理来说很简单，位数组+k个独立hash函数。将hash函数对应的值的位数组置1，查找时如果发现所有hash函数对应位都是1说明存在，很明显这个过程并不保证查找的结果是100%正确的。同时也不支持删除一个已经插入的关键字，因为该关键字对应的位会牵动到其他的关键字。所以一个简单的改进就是 counting Bloom filter，用一个counter数组代替位数组，就可以支持删除了。2、Has

Backtracking（回溯）属于 DFS。普通 DFS 主要用在 可达性问题 ，这种问题只需要执行到特点的位置然后返回即可。而 Backtracking 主要用于求解 排列组合 问题，例如有 { ‘a’,‘b’,‘c’ } 三个字符，求解所有由这三个字符排列得到的字符串，这种问题在执行到特定的位置返回之后还会继续执行求解过程。因为 Backtracking 不是立即返回，而要继续求解，因此在程序实现时，需要注意对元素的标记问题：在访问一个新元素进入新的递归调用时，需要将新元素标记为已经访问，这样

深度优先搜索在得到一个新节点时立即对新节点进行遍历1、岛屿的最大面积深度优先搜索时间复杂度：O(R∗C)。其中 R是给定网格中的行数，C 是列数。我们访问每个网格最多一次。空间复杂度：O(R∗C)，递归的深度最大可能是整个网格的大小，因此最大可能使用 O(R∗C) 的栈空间。class Solution { int dfs(vector<vector<int>>& grid, int cur_i, int cur_j) { //异常处理，直接返回

广度优先搜索一层一层地进行遍历，每层遍历都是以上一层遍历的结果作为起点，遍历一个距离能访问到的所有节点。需要注意的是，遍历过的节点不能再次被遍历。1、二进制矩阵中的最短路径class Solution {public: //保存当前节点的八个方向，进行遍历 vector<vector<int>>dir={{0,1},{0,-1},{1,0},{-1,0},{1,1},{1,-1},{-1,1},{-1,-1}}; int shortestPathBi

1、矩阵的最小路径和class Solution {public: int minPathSum(vector<vector<int>>& grid) { int m=grid.size(); if(m==0) return 0; int n=grid[0].size(); vector<vector<int>> dp(m,vector<int>(n,0));

1、删除两个字符串的字符使他们相等转换为求两个字符串的最长公共子序列问题class Solution{public: int minDistance(string word1,string word2){ int n1 = word1.size(),n2 = word2.size(); vector<vector<int>> dp(n1+1,vector<int>(n2+1,0)); for(int i=1;i<=n1;i++){ f

当 S1i==S2j 时，那么就能在 S1 的前 i-1 个字符与 S2 的前 j-1 个字符最长公共子序列的基础上再加上 S1i 这个值，最长公共子序列长度加 1，即 dp[i][j] = dp[i-1][j-1] + 1。当 S1i != S2j 时，此时最长公共子序列为 S1 的前 i-1 个字符和 S2 的前 j 个字符最长公共子序列，或者 S1 的前 i 个字符和 S2 的前 j-1 个字符最长公共子序列，取它们的最大者，即 dp[i][j] = max{ dp[i-1][j], dp[i][j

1、最长上升子序列状态转移dp[i]=max(dp[j])+1 其中 0≤j<i 且 num[j]<num[i]dp[i]代表0-i之间的序列中最长上升子序列的长度程序分析class Solution {public: int lengthOfLIS(vector<int>& nums) { int n=nums.size(); if(n==0) return 0; if(n==

动态规划 + 二分搜索状态转移方程：//当前状态位K个鸡蛋，面对N层楼//返回当前状态下的最优结果def dp(K,N): for 1<=i<=N: //最坏情况下的最少扔鸡蛋次数 res = min(res, max( dp(K-1,i-1), //碎了 dp(K,N-i) //没碎 )+1; //在i楼扔了一次 return res;函数单调性程序class Solution { un

打家劫舍1class Solution {public: int rob(vector<int>& nums) { int n = nums.size(); if(n==0) return 0; if(n==1) return nums[0]; vector<int> dp(n,0); dp[0] = nums[0]; dp[1] = max(nums[0]

背包问题 (Knapsack problem x ) 有很多种版本，常见的是以下三种：**0-1 背包问题 (0-1 knapsack problem)：**每种物品只有一个**完全背包问题 (UKP, unbounded knapsack problem)：**每种物品都有无限个可用**多重背包问题 (BKP, bounded knapsack problem)：**第 i 种物品有 n[i] 个可用0-1背包有一个容量为 N 的背包，要用这个背包装下物品的价值最大，这些物品有两个属性：体积 w

基本框架明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义。**#参考labuladong算法教程**# 初始化 base casedp[0][0][...] = base# 进行状态转移for 状态1 in 状态1的所有取值： for 状态2 in 状态2的所有取值： for ... dp[状态1][状态2][...] = 求最值(选择1，选择2...)三种动态规划方案1.

归并排序时间复杂度：O(nlog(n))空间复杂度：由于使用了递归，O(log(n))class Solution {public: ListNode* sortList(ListNode* head) { if(head==nullptr){ return nullptr; }else if(head->next==nullptr){ return head; } List

全排列1给定一个 没有重复 数字的序列，返回其所有可能的全排列。class Solution {public: vector<vector<int>> permute(vector<int>& nums) { n = nums.size(); vector<bool> visit(n,false); dfs(nums,visit); return res;

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* merge(ListNode* head1,ListNode* head2) //将两个有序链表合并成为一个

二叉树前序中序后序遍历二叉树从上到下打印二叉树垂序遍历二叉树

完全反转链表三种反转列表方式/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; *//*迭代法//O(n),O(1)*/class Solution{public: ListNode* reverseList(ListNod