qq_24447809的博客

class dijkstra{ public: using pi=pair<int,int>; vector<vector<pi>> map; int n; dijkstra(vector<vector<int>>& edges,int size) { n=size; map.resize(n+1); for(auto& v:edges)

#include <iostream>#include <string>#include<vector>#include<algorithm>#include <functional>using namespace std;class Less{public: template<typename T1, typename T2> bool operator()(const T1& a, const T2.

需求分析1.保存插入的先后顺序2.快速查找指定数据解决方案：双向链表 + hash表1.链表采用头插法，那么尾部数据自然就是最早插入的数据2.为了方便删除，采用双向链表3.每插入一个数据，就在hash表中记录位置，方便查找代码实现#include <iostream>#include<unordered_map>#include<set>#include<unordered_set>using namespace std;clas

leetcode题目描述解题思路1.每个频率对应一个双向链表，记录对应的key值，如果key对应频率有变化就从此链表中删除2.链表采用头插法，那么尾部数据自然就是最早插入的数据，优先删除3.为了方便删除，采用双向链表4.每插入一个数据，就在hash表中记录key对应链表节点位置，方便查找代码class Node {public: int key; int value; Node* next; Node* pre; Node(int mkey = 0, int mvalue = 0)

LeetCode146题思路1.双向链表方便删除操作2.最近使用的资源更新到表头，表尾自然就是长时间未被使用的资源3.资源不够的时候删除表尾代码#include <iostream>#include<unordered_map>using namespace std;class Node {public: int key; int value; Node* next; Node* pre; Node(int mkey = 0, int mvalue =

题目给你 k 枚相同的鸡蛋，并可以使用一栋从第 1 层到第 n 层共有 n 层楼的建筑。已知存在楼层 f ，满足 0 <= f <= n ，任何从 高于 f 的楼层落下的鸡蛋都会碎，从 f 楼层或比它低的楼层落下的鸡蛋都不会破。每次操作，你可以取一枚没有碎的鸡蛋并把它从任一楼层 x 扔下（满足 1 <= x <= n）。如果鸡蛋碎了，你就不能再次使用它。如果某枚鸡蛋扔下后没有摔碎，则可以在之后的操作中 重复使用 这枚鸡蛋。请你计算并返回要确定 f 确切的值 的 最小操作次数

给你两个单词 word1 和 word2，请你计算出将 word1 转换成 word2 所使用的最少操作数 。你可以对一个单词进行如下三种操作：插入一个字符删除一个字符替换一个字符示例 1：输入：word1 = “horse”, word2 = “ros”输出：3解释：horse -> rorse (将 ‘h’ 替换为 ‘r’)rorse -> rose (删除 ‘r’)rose -> ros (删除 ‘e’)示例 2：输入：word1 = “intention

LeetCode 438 找到字符串中所有异位词给定一个字符串 s 和一个非空字符串 p，找到 s 中所有是 p 的字母异位词的子串，返回这些子串的起始索引。字符串只包含小写英文字母，并且字符串 s 和 p 的长度都不超过 20100。说明：字母异位词指字母相同，但排列不同的字符串。不考虑答案输出的顺序。示例 1:输入: s: “cbaebabacd” p: “abc”输出: [0, 6]解释: 起始索引等于 0 的子串是 “cba”, 它是 “abc” 的字母异位词。 起始索引等于

#include<iostream>#include <bitset>using namespace std;int main(){ int a = 12; //测试值，12往上对齐到16 int b = 7; //字节对齐值，7->8字节对齐；3->4字节对齐 int d = ~b; //取反0x11111000; cout << "a=" << bitset<sizeof(a) * 2&gt

给定一个二叉搜索树和一个目标结果，如果 BST 中存在两个元素且它们的和等于给定的目标结果，则返回 true。思路1.二叉搜索树的中序遍历是递增序列，反中序遍历（先找右节点）是递减数组2.在有序数组中找两数之和为k时，可以同时比较最大最小值大于k，从右端找更小值；小于k，从左端找更大值；代码结合以上两点：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode

给定 n 个整数，找出平均数最大且长度为 k 的连续子数组，并输出该最大平均数。示例 1:输入: [1,12,-5,-6,50,3], k = 4输出: 12.75解释: 最大平均数 (12-5-6+50)/4 = 51/4= 12.75思路利用一个滑动窗口，每次滑动时把窗口左端减去，把窗口右端加上，新总和再比较class Solution {public: double findMaxAverage(vector<int>& nums, int k) {

前序遍历利用栈的后进先出性质class Solution {public: vector<int> preorderTraversal(TreeNode* root) { stack<TreeNode*> st; vector<int> result; if (root == NULL) return result; st.push(root); while (!st.empty

给定一个 N 叉树，返回其节点值的前序遍历。例如，给定一个 3叉树 :返回其前序遍历: [1,3,5,6,2,4]。说明: 递归法很简单，你可以使用迭代法完成此题吗?栈实现迭代/*// Definition for a Node.class Node {public: int val; vector<Node*> children; Node() {} Node(int _val) { val = _val; }

给定一个 N 叉树，找到其最大深度。最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。例如，给定一个我们应返回其最大深度，3。说明:树的深度不会超过 1000。树的节点总不会超过 5000。递归（深搜）class Solution {public: int maxDepth(Node* root) { if(!root) return 0; int n=root->children.size();

给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过也可能不穿过根结点。示例 :给定二叉树返回 3, 它的长度是路径 [4,2,1,3] 或者 [5,2,1,3]。注意：两结点之间的路径长度是以它们之间边的数目表示。递归/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * Tr

给定一个有相同值的二叉搜索树（BST），找出 BST 中的所有众数（出现频率最高的元素）。假定 BST 有如下定义：结点左子树中所含结点的值小于等于当前结点的值结点右子树中所含结点的值大于等于当前结点的值左子树和右子树都是二叉搜索树例如：给定 BST [1,null,2,2],提示：如果众数超过1个，不需考虑输出顺序进阶：你可以不使用额外的空间吗？（假设由递归产生的隐式调用栈的开销不被计算在内）思路二叉搜索树的中序遍历是递增序列。普通中序遍历/** * Definition fo

给定一个范围在 1 ≤ a[i] ≤ n ( n = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。找到所有在 [1, n] 范围之间没有出现在数组中的数字。您能在不使用额外空间且时间复杂度为O(n)的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。示例:输入:[4,3,2,7,8,2,3,1]输出:[5,6]class Solution {public: vector<int> findDisappearedNumbers(

举个栗子给定两个字符串 s 和 t，它们只包含小写字母。字符串 t 由字符串 s 随机重排，然后在随机位置添加一个字母。请找出在 t 中被添加的字母。示例 1：输入：s = “abcd”, t = “abcde” 输出：“e”解释：‘e’ 是那个被添加的字母。示例 2：输入：s = “”, t = “y”输出：“y”示例 3：输入：s = “a”, t = “aa”输出：“a”示例 4：输入：s = “ae”, t = “aea”输出：“a”异或运算的特性：1.异或自己

你是产品经理，目前正在带领一个团队开发新的产品。不幸的是，你的产品的最新版本没有通过质量检测。由于每个版本都是基于之前的版本开发的，所以错误的版本之后的所有版本都是错的。假设你有 n 个版本 [1, 2, …, n]，你想找出导致之后所有版本出错的第一个错误的版本。你可以通过调用 bool isBadVersion(version) 接口来判断版本号 version是否在单元测试中出错。实现一个函数来查找第一个错误的版本。你应该尽量减少对调用 API 的次数。示例:给定 n = 5，并且 ver.

给定一个整数，编写一个函数来判断它是否是 2 的幂次方。示例 1:输入: 1 输出: true 解释: 20 = 1示例 2:输入: 16 输出: true 解释: 24 = 16示例 3:输入: 218 输出: false版本1class Solution {public: bool isPowerOfTwo(int n) { if(n<=0) return false; if(n==1)

给定一个整数数组，判断是否存在重复元素。如果任意一值在数组中出现至少两次，函数返回 true 。如果数组中每个元素都不相同，则返回 false 。示例 1:输入: [1,2,3,1] 输出: true示例 2:输入: [1,2,3,4] 输出: false示例 3:输入: [1,1,1,3,3,4,3,2,4,2] 输出: trueset映射class Solution {public: bool containsDuplicate(vector<int>&amp

反转一个单链表。示例:输入: 1->2->3->4->5->NULL 输出: 5->4->3->2->1->NULLstack栈利用栈的后进先出特性。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL

统计所有小于非负整数 n 的质数的数量。示例:输入: 10 输出: 4 解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。暴力法class Solution {public: bool prime(int n) { for(int i=2;i*i<=n;i++) { if(n%i==0) return false; } retu

删除链表中等于给定值 val 的所有节点。示例:输入: 1->2->6->3->4->5->6, val = 6 输出: 1->2->3->4->5简单删除注意头结点的处理和节点回收。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) :

编写一个函数，输入是一个无符号整数，返回其二进制表达式中数字位数为 ‘1’ 的个数（也被称为汉明重量）。简单版本class Solution {public: int hammingWeight(uint32_t n) { int ans=0; while(n!=0) { if(n & 1) ans++; n=n>>1;

给定一个整数 n，返回 n! 结果尾数中零的数量。示例 1:输入: 3输出: 0解释: 3! = 6, 尾数中没有零。示例 2:输入: 5输出: 1解释: 5! = 120, 尾数中有 1 个零.说明: 你算法的时间复杂度应为 O(log n) 。数学思想因为0都是5和偶数相乘产生的，所以要找出因子中有多少个5，因为25,125,625…含有多个5，要加上这些额外的5，即res=n/5+n/25+n/125+n/625…举个栗子：计算130,（1）130/5=26,说明有26个包

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) {

思路dp[i]表示以第i位为序列尾部的时候，序列和最大值。#include<iostream>#include<string>#include<vector>#include<algorithm>using namespace std;class Solution {public: int maxSubArray(vector<int>& nums) { if (nums.empty())

#include<iostream>#include<string>#include<vector>#include<algorithm>using namespace std;class Solution {public: int searchInsert(vector<int>& nums, int target) { int left = 0, right = nums.size() - 1;

kmp算法理解核心逻辑是避免字符串匹配时的重复运算，比如{“ABABABCABAB”}中查找{“ABABC”},当字符段ABABA和ABABC不匹配时，移动要查找字符串到A处（加粗）处进行下一次匹配，即ABABABCABAB     ABABC而不用在下一个字母B处进行匹配，其实就是利用了字符串ABAB中重复的AB项。前缀和可以用前缀和来表示这个头和尾重复的字符串长度，字符串必须包含首部和尾部：A:0AB:0ABA:1ABAB:2ABA