欲买桂花同载酒

无

题目：题目链接就合并链表？这是hard嘛？就挺离谱的。我都不敢相信。。。有k个链表，每次将一个链表和新链表合并就可以了。例如样例：[[1,4,5],[1,3,4],[2,6]]，设新链表为l，初始为空链表首先l与[1,4,5]合并，l = 1,4,5然后l与[1,3,4]合并，l = 1，1，3，4，4，5以此类推。基本上和归并排序一样的，只不过归并排序合并的是数组，这是链表。合并两个链表都会吧，不会最好自己动手模拟一下，就是双指针的用法。看代码吧：class Solution {pub

题目：题目链接这题是hard诶，题目本身难度其实还好，但我debug是真的hard…思路：把这题拆开，首先解决如何反转k个结点的链表？首先创建一个头结点root，root->next=nullptr。然后依次插入结点。然后我们再输出root->next，这样是不是就反转了链表呀。知道了逻辑，我们开始敲代码：class Solution {public: ListNode* reverseList(ListNode* head) { ListNode* root

题目：题目链接题目大意是说每两个结点互换。简单来说就说，先弄个头结点，然后把每次交换的两个结点加入这个头结点，只需要改变他们的next指针就可以了。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x),

题目：题目链接思路：最近几天的题目都好难啊，都不会做看的题解。没看的可以先移步中文官方题解首先，大致思路肯定是找划分点，然后在判断划分的子串是不是回文串。找划分点。怎么找，直接dfs嘛判断子串，如果直接暴力，每次都判断，那挺麻烦的。时间复杂度是O(1)，怎么办，预处理呗，先对字符串处理一遍。令dp[i][j]为s[i…j]是否为回文串。这个状态转移方程是参照官方题解的，应该是不难理解的。为什么i>=j是true呢？因为我们认为这种情况其实是不存在的，但对于dp[0][1]，它下一步会

题目：题目链接思路：深度拷贝。有递归和迭代两种方式方法一 递归参考：官方题解class Solution {public: unordered_map<Node*, Node*> cachedNode; Node* copyRandomList(Node* head) { if (head == nullptr) { return nullptr; } if (!cachedNode.count(head)) {//不重复创建结点 Node* headNe

题目：题目链接Trie又称字典树，前缀树。具体性质可以参照英文官方题解，里面还有Trie的用法，可以去看看还是挺有意思的。其实坦白来说就是建树，每棵树都有最多26个结点也就是26个英文字母，我的代码是按照中文官方题解写的，顺便加了点自己的理解。看代码吧：class Trie {private: vector<Trie*> children;//这是他的儿子，也是一棵Trie树 bool isEnd;//该结点是否是叶子结点 Trie* searchPrefix(string pr

题目：题目链接这题，官方题解我觉得写得特别通俗易懂了。那么为什么要双向链表呢？因为你删除一个结点时，需要把前驱结点和后继结点连起来，那么要知道前驱结点就需要双向链表了。看代码吧：/*leetcode146. LRU Cache*/struct DLinkedNode {//双向链表结点的结构 int key, value; DLinkedNode* prev; DLinkedNode* next; DLinkedNode() : key(0),value(0),prev(null

题目：题目链接思路：就是找中心点。然后设置双指针l,r从两边开始找回文串。这篇题解讲的挺好的。注意中心点可以是一个，也可以是两个哦。看代码吧：class Solution {public: int countSubstrings(string s) { int n = s.size(); int ans = 0; for (int i = 0; i < n; ++i) {//遍历每个字符，因为每个字符都可以单中心点或双中心点 for (int j = 0; j < 2

题目：题目链接思路： 求前k个出现频率高的数。先用map把各个数出现的频率记录，然后丢到优先队列里面，让优先队列按照频率进行排序。之后再输出就可以了。上代码吧：class Solution {public: vector<int> topKFrequent(vector<int>& nums, int k) { unordered_map<int, int>un_mp; priority_queue<pair

题目：题目链接兄弟们，我又回来了！！思路：划分子集S为s1和s2，这两个集合的和相同。首先先考虑一下Sum(s1) = Sum(s2) ，那么Sum(S)=Sum(s1+s2)=Sum(s1)+Sum(s2)=2∗Sum(s1)Sum(S) = Sum(s1+s2)=Sum(s1) + Sum(s2)=2*Sum(s1)Sum(S)=Sum(s1+s2)=Sum(s1)+Sum(s2)=2∗Sum(s1)所以Sum(S)一定为偶数。方法一 DP把它看成背包问题，每个元素有选和不选两种情况，就是0

题目：题目链接思路：滑动窗口嘛。为啥？Related topic里面有。简单来说就是利用一个大小为p.size()的窗口，从s的第0个位置开始比对，然后比完了就右移一个位置。比对的话直接用map就可以，因为只要它们二者的组成字符一样就可以。先用一个map存放p的各个字符的出现次数。再用一个map放当前滑动窗口内s的字符串。可如果每移动到新的位置都从窗口岂是位置开始匹配，那时间复杂度太高了，过不了。怎么改呢？我们窗口每次向左移动一个位置啊！那么当前窗口和前一个窗口不一样的地方就是少了字符，多了字符

题目：题目链接思路：题目就是说选了root，就不能选root->left和root->right。那么很像dp是吧，那就来吧。方法一 自己想的dp来来来兄弟们，我有个非常好懂的方法，这里空白很多可以写下。令dp[root]为以root为根节点的树的最大权值和。那么状态转移方程是啥？首先如果不选择root的话，dp[root]=dp[root−>left]+dp[root−>right]dp[root] = dp[root->left]+dp[root->rig

题目：题目链接思路：其实我也不会，我想着最暴力的方法是根据每一个结点找路径，但是实现起来还是有些复杂，不知道怎么递归。看了官方解答才知道我和大佬的差距有多么的大啊！方法一 dfs双重递归，先递归找所有结点，然后对于所有结点，以它们为路径起点，dfs找路径和为targetSum的个数。先看对于单个结点找路径的代码：int dfs(TreeNode* root, int targetSum) {//找到以root为起点的路径和为targetSum的路径个数 if (!root) return 0;

题目：题目链接思路：让你找全是一的最大的全为’1’的正方形面积。方法一 暴力最先想到的，那必然是暴力。我们先找一个点，然后把这个点当作正方形的左上角，在遍历正方形的最大边长。注意：我们只需要遍历新加的一行和一列就可以了哦！看代码吧：class Solution {public: int n, m; void findSquare(int i, int j, int& max_len, vector<vector<char>>& matri

题目：题目链接思路：好家伙，第一反应是递归。其实我们可以把他看成：s=s1k[s2]s3s=s1k[s2]s3s=s1k[s2]s3其中k是数字，s,s1,s2,s3是字符串。另外，s2也可以是s。**方法一 递归**那么我们知道了我们处理s时，只需要在s2进行递归调用就可以了。那么你可能肯定会做了吧。不会做也没关系，我也不会。哈哈哈哈。实际递归编写还是有难度的啊，我参考了大神的代码，我写不出来。。。。看代码吧：class Solution {public: bool isDigi

题目：题目链接这题说实在的，我没做出来，太难了。我也是看中文官网题解才做出来的。我说下我的理解吧:首先dp嘛，我们令dp[i]为前i个字符是否可以用单词本表示。那么状态转移方程是啥啊？其状态转移方程如下：dp[i]=dp[j]  if(s[j −>i−1]在字典中)dp[i] = dp[j] \ \ if(s[j\ ->i-1]在字典中)dp[i]=dp[j]  if(s[j −>i−1]在字典中)边界条件：dp

兄弟们，我黄某人又回来了！！！！题目：题目链接思路：题目大意就是让你判断是否是一个合法的BST。树的话一般就是递归，只有亿点点难吧。方法一 递归对于一个结点A，其左子树所有结点都要小于A的值，其右子树所有结点都要大于A的值。所以对于左子树而言其上界是A的值，右子树而言其下界是A的值。晕了晕了。别急！这是不是就是说我递归做的话参数最起码要有两个，结点，上界和下界。那么当前结点只要在上界和下界之间就是合法的。那么可以搞出代码：/** * Definition for a binary tree n

题目：题目链接只能往下和往右走，问你从左上角走到右下角的最小和。直接dp。设dp[i][j]为到(i,j)的最小和。其状态转移方程为：dp[i][j]=min(dp[i−1][j],dp[i][j−1])+grid[i][j]dp[i][j]=min(dp[i-1][j],dp[i][j-1])+grid[i][j]dp[i][j]=min(dp[i−1][j],dp[i][j−1])+grid[i][j]特殊地，dp[0][0]=grid[0][0]。如果dp[i][j]不存在就直接忽略。直接贴迭

题目：题目链接思路：区间合并。我之前一直以为要线段树做，一直放着。今天实在不会做其他的了，就尝试用最朴素的方法做一下。没想到还过了，真是惊喜。具体做法：先排序，然后遍历所有区间，一个一个合并。因为你从小大排序了，就表明后面的区间一定饥接在前面区间，要么和前面区间合并，要么无法合并。看代码吧：class Solution {public: static bool cmp(vector<int>& a, vector<int>& b) {//如果第一个不

题目：题目链接题目大意：判断链表是否有环，如果有环就找出环的入口思路：快慢指针。举个例子假设A和B都想从宿舍去操场跑步，A跑的速度是B的两倍，那么当A在操场跑步时，B可能还没到操场。但B到了操场A肯定还在操场。此时就变成了小学操场追人的问题，因为你们速度不一样，你们总会相遇的。需要解决两个问题：1.如何判断有无环。2.如何找到环的入口。开始解题：快慢指针可以判断 有无环，如果没环快指针肯定会指向null。那么问题变成了怎么找环的入口？如下：利用快慢指针，快指针比慢指针多走一步。假设从起点到环的

题目：题目链接思路：直接bfs就好。每一分钟都拓展当前所有的腐烂橙子，然后直到不能拓展，再看是否还有新鲜橙子。看代码吧：class Solution {public: int m, n; bool isInBoard(int x, int y) {//判断是否在网格内 return (x < m&& x >= 0) && (y < n&& y >= 0); } int orangesRotting(vector<

题目：题目链接题目大意就是看哪些单词出现的字母一样，如果是就把他们放一起，不管其字母出现的顺序是否一样。思路：用map记录下单词的字符串(是排序后的)。也就是说我们对于两个单词 acb和bac，把acb，bac排序，它们就都是abc，使用我们只需要记录abc出现就可以了。注意我们需要输出原单词，所以先用个中间变量保存单词再排序，这样原单词就不变了。看代码吧：class Solution {public: vector<vector<string>> groupAnag

题目：题目链接思路：有一个含有重复元素的数组，该重复元素只有一个，但可能重复多次。例如 1 2 2 2。让你求该重复元素。想不出空间复杂度O(1)的算法，只能看大神的。看到了快慢指针。满脸黑人问号？what，这也行？再一看，确实很有道理啊。建议移步官方解答三，我觉得讲的还是可以的。简单来说就是把数组的下标当成地址，然后数组的元素也是地址，这样就相当于一个链表了。可以根据数组的元素去跳转到相应的数组下标。例如 [1,3,4,2,2] 其下标为[0,1,2,3,4] 首先从0跳到nums[0](也就是1

题目：题目链接思路：题目大意就是求树的前序遍历。这点观察是可以发现的。所以只要把前序遍历的结果放入数组，然后把他们串起来就可以了。方法一 前序遍历有两种，递归和非递归。看代码吧：/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(null

题目：题目链接思路：题目大意是二叉树的右视图。翻译一下就是记录二叉树每层最右边的结点，所以答案数组的长度肯定是二叉树的高度，因为每层挑一个嘛。肯定要遍历树嘛，那两种方法dfs，bfs。方法一 dfs根据我们翻译的内容，对于一个父结点肯定是要先访问左子树，再访问右子树的。然后判断一下当前结点是否加入答案，判断方式就是我们前面提到的，每层只加入一个，所以只要和目前答案数组的长度与高度相比较就可以了。看代码吧：/** * Definition for a binary tree node. * str

题目：题目链接题意：从一个数组中找到连续的子数组，其所有元素的积最大用MPS表示。思路：dp。先看数据量，2*10^4 所以O(n^2)肯定不行。那就是一维dp了。开始我想着设dp[i]为从0到i的MPS，但状态转移方程一直写不出来。看了看提示，设dp[i]为以i结尾的MPS。那么就很好根据前面推出后一个了。要注意因为是积，所以哪怕前面是负数也有可能再与一个负数相乘为正。所以要保存最大和最小值。具体如下：设max_product[i]为以i结尾的最大连续子数组积，min_product[i]为以

题目：题目链接方法一 暴力直接找，上代码：class Solution {public: bool searchMatrix(vector<vector<int>>& matrix, int target) { for(const auto& row:matrix){ for(const auto& ele:row) if(ele == target) return tru

题目：题目链接思路：最长连续序列，不会。下面介绍一种大神的解法和官方解答。方法一 大神解法利用map的有序性，把元素都丢到map里面，然后直接遍历一遍map就可以了。看代码：class Solution {public: int longestConsecutive(vector<int>& nums) { if (nums.size() < 2) return nums.size(); map<int, int>mp;

题目：题目链接思路：题意就是从m*n的矩阵中找到一串连续的字符串与目标字符串相同。直接dfs。看代码：class Solution {public: int dis[4][2] = { {0,1},{1,0},{-1,0},{0,-1} };//上下左右四个方向 bool vis[10][10];//标记数组，记录该位置是否访问过 int n, m;//分别表示长和宽 bool f = 0;//用于记录是否找到答案 bool isInBorder(int x, int y) {//判断是

题目：题目链接思路：二分查找。直接看代码：class Solution {public: int searchInsert(vector<int>& nums, int target) { int low = 0, high = nums.size() - 1; while (low <= high) { int mid = low + (high - low) / 2; if (nums[mid] == target) return mid;

题目：题目链接题意：子数组的和等于k，求子数组有多少个思路：前缀和肯定要，因为pre[i]-pre[j]就是[j+1,i]这个子数组的和。接着枚举起点，终点，求得符合k的答案。时间复杂度是O(n^2)，过不了啊一直TLE。没办法，只好给标答跪了。它的思想是利用map维护前缀和出现的次数，然后枚举终点i，直接查找以i结尾的数组中的子数组有没有等于k的情况，因为查找是O(1)的，所以时间复杂度为O(n)，就可以过了。具体查找步骤就是对于终点i，此时map中已经保存了[0,i-1]的前缀和，那么我们只要在

题目：题目链接数学真是让人又爱又恨啊！方法一 动态规划令dp[i]为n=i时需要的最少个数，那么可以列出状态转移方程：边界条件：dp[1]=1然后直接两个for循环就可以了，看代码吧：class Solution {public: int numSquares(int n) { vector<int>dp(n + 5, 1e4); dp[0] = 0; for (int i = 1; i <= n; ++i) for (int j = 1; j * j

题目：题目链接思路：第一反应是dfs，然后感觉太麻烦了，想到dp，感觉dp简单点。首先令dp[i]为amount=i时最少的硬币数，那么可以得到其状态转移方程：dp[i]=for coin in coins:if(i>=coin)max(dp[i−coin]+1,dp[i])dp[i] = for\ coin\ in\ coins : if(i>=coin) max(dp[i-coin]+1,dp[i])dp[i]=for coin in&n

题目：题目链接思路：和Course Schedule I一样，拓补排序。多一个记录拓补排序答案的数组就可以了。上代码：/*leetcode210. Course Schedule II*/class Solution {public: vector<int> findOrder(int numCourses, vector<vector<int>>& prerequisites) { vector<int>ad

题目：题目链接思路：这题就是把他看成有向图，然后进行拓补排序就行了。对于[0,1]则可表示为从1顶点出发到0顶点的一条有向边，然后1若完成就相当于0的入度减少，当0入度为0时则表示可以直接上该课程。所以就是一个拓补排序。由于常规的拓补排序对于图顶点的存储在本题是不可行的，因为顶点数是10^5，二维的数组开不了这么大。然后可以采用邻接矩阵的存储方法，一维表示顶点数，二维表示该点可到的顶点。然后就是基本的拓补排序了，最后比较可拓补排序的顶点数是否和总顶点数相等就可以了。上代码吧：class Solutio

题目：题目链接思路：题目说了不能用除法，那就只能用乘法了。对于一个数字i而言，他的答案应该是他前面的数乘上他后面的数。换句话说就是前缀和*后缀和(和在这里就是乘积的意思)。知道了怎么做，就直接求前缀和，后缀和就可以了。上代码吧：class Solution {public: vector<int> productExceptSelf(vector<int>& nums) { vector<int> res(nums.size(),1)

题目：题目链接思路：看他的related topics。然后动态规划做。这一看就是一维的，为什么因为二维的我不会，你也就看不到这篇题解了。嘿嘿咱们令dp[i]表示前i个房子能偷的最大值。那么此时有两种情况：要么选第i个房子，那i-1就不能选，只能加上dp[i-2]。要么不选第i个房子，那么就可以是dp[i-1]。因为数组都大于0，所以肯定不存在选择dp[i-3]的情况，然后跳过第i-1个房子的情况。所以就是这两种情况，取最大值就可以了。可以得到状态转移方程：dp[i]=max(dp[i−2]+nu

题目：题目链接思路：我记得严蔚敏奶奶的数据结构中有，就是先整体反转，然后分别翻转前k个，和后面的n-k个。令S= P1P2, 首先P1是前n-k个数字序列，P2是后面k个。整体旋转：S’=P2’P1’ 。之后对两部分分别旋转：S1=P2P1。得到答案。注意：k可能会大于数组长度，对数组长度取余就好了直接看代码吧:class Solution {public: void rotate(vector<int>& nums, int k) { k %= nu

题目：题目链接方法一：转置矩阵然后翻转每一行class Solution {public: void rotate(vector<vector<int>>& matrix) { int len = matrix.size(); for(int row = 0;row<len;++row){//矩阵转置 for(int col = row;col<len;++col){