xiji333的博客

https://leetcode-cn.com/problems/longest-arithmetic-subsequence-of-given-difference/思路：其实和最长上升子序列是很像的，考虑dpidp_idpi​表示以aia_iai​结尾的最长等差子序列的长度，那么当j<ij<ij<i且aj=ai+da_j=a_i+daj​=ai​+d时有dpi=max(dpi,dpj+1)dp_i=max(dp_i,dp_j+1)dpi​=max(dpi​,dpj​+1)，但是这样

https://leetcode-cn.com/problems/repeated-dna-sequences/思路一：非常直观的方法，逐一取长度为10的子串，通过哈希计数即可。复杂度O(NL)O(NL)O(NL)。class Solution {public: vector<string> findRepeatedDnaSequences(string s) { vector<string> ans; const int LEN=10

https://leetcode-cn.com/problems/maximum-number-of-ways-to-partition-an-array/思路：第一次在比赛中间干掉hardhardhard题，纪念一下。先计算出前缀和数组sumsumsum，并设整个数组的总和为tottottot，那么问题中的条件就等效于在前缀和数组中寻找sumi=tot−sumisum_i=tot-sum_{i}sumi​=tot−sumi​的iii的个数，也即sumi=tot/2sum_i=tot/2sumi​=to

https://leetcode-cn.com/problems/fraction-to-recurring-decimal/思路：模拟竖式除法即可，关键点在于如何区分有限小数和无限循环小数。其实就是看小数部分会不会出现循环节，在模拟的过程中，如果某个余数出现了多次，那么肯定就是无限循环小数喽。搞个哈希表记录一下位置即可。class Solution {public: using ll=long long; string fractionToDecimal(ll numerator,

https://leetcode-cn.com/problems/number-of-boomerangs/思路：考虑枚举点iii，如果我们知道其他所有点到点iii的距离，那么可以计算出每个距离对应的点对数量xxx，显然它对答案的贡献为x∗(x−1)x*(x-1)x∗(x−1)——从xxx个元素中有顺序的选出2个元素。通过哈希表可以把时间复杂度降低到O(n2)O(n^2)O(n2)。不过计数方式有很多种，也可以考虑在统计点对数量的时候计算。class Solution {public: in

https://leetcode-cn.com/problems/group-anagrams-lcci/思路：统计每个字符串每个字符出现的次数，可以得到一个长度为26的整型数组，只要这个数组相等，两个字符串就是变为词组。为了加快效率，可以自定义一种对数组的hash方法。class Solution {public: vector<vector<string>> groupAnagrams(vector<string>& strs) {

https://leetcode-cn.com/problems/time-based-key-value-store/思路：模拟题……class TimeMap {public: /** Initialize your data structure here. */ TimeMap() { } void set(string key, string value, int timestamp) { mp[key][timestamp]=va

https://leetcode-cn.com/problems/count-good-meals/思路：哈希计数，cnticnt_icnti​表示数字iii的出现次数，那么对于所有可能凑出来的美味程度jjj(2的幂次)，可以计算出：ans=ans+cnt[j−ele]ans=ans+cnt[j-ele]ans=ans+cnt[j−ele]。class Solution {public: int countPairs(vector<int>& deliciousness)

https://leetcode-cn.com/problems/find-majority-element-lcci/思路：哈希可以直接做，但是空间复杂度是O(n)O(n)O(n)的。为了降低空间复杂度至O(1)O(1)O(1)，我们可以使用Boyer-Moore投票算法（力扣官方题解），其核心思想是：在每一轮投票过程中，从数组中删除两个不同的元素，直到投票过程无法继续，此时数组为空或者数组中剩下的元素都相等。如果数组为空，则数组中不存在主要元素；如果数组中剩下的元素都相等，则数组中剩下的元素可

https://leetcode-cn.com/problems/max-points-on-a-line/思路一：直接暴力枚举，显然答案的那条直线至少涵盖nnn个点中的某222个点，因此直接O(n2)O(n^2)O(n2)枚举直线上的两个点，再遍历一遍进行判断。复杂度O(n3)O(n^3)O(n3)。为了避免斜率不存在等特殊情况，我们可以对判断公式进行移项。class Solution {public: vector<int> p1,p2; int maxPoints(

https://leetcode-cn.com/problems/number-of-submatrices-that-sum-to-target/思路：考虑枚举左右边界l、rl、rl、r，计算该区间内每一行元素的和，可以得到一个数组sumsumsum，如果可以找到两个位置i、ji、ji、j满足∑k=ijsumk=target\sum_{k=i}^{j}sum_k=target∑k=ij​sumk​=target，那么就找到了一组可行解，其左上角坐标为(l,i)(l,i)(l,i)，右下角坐标为(r,j

https://leetcode-cn.com/problems/contiguous-array/思路：其实和昨天那道题是差不多的……把数组中的0变为-1，那么问题转换为找总和为0的最长连续子数组。搞一个哈希表记录和到位置的映射：如果[0,i][0,i][0,i]的总和为jjj，那么可以令hash[j]=ihash[j]=ihash[j]=i。那么如果记录过jjj了，说明我们找到了一个合法区间，其长度为i−hash[j]i-hash[j]i−hash[j]。依据贪心思想，记录过的位置越靠前越好，因此只

https://leetcode-cn.com/problems/top-k-frequent-words/思路：先用哈希统计每个单词的出现次数，然后就是经典问题：求前kkk个最大/小元素。堆或者快排分割都行。class Solution {public: vector<string> topKFrequent(vector<string>& words, int k) { unordered_map<string,int> cnt

思路：设S0=0,Si=a0⨁a1⨁……⨁ai−1S_0=0,S_i=a_0\bigoplus a_1\bigoplus……\bigoplus a_{i-1}S0​=0,Si​=a0​⨁a1​⨁……⨁ai−1​，由异或性质可知，数组arrarrarr的[i,j−1][i,j-1][i,j−1]的异或和等于Sj⨁SiS_j \bigoplus S_iSj​⨁Si​，那么由题目的a=ba=ba=b可以化简得到Si=Sk+1S_i=S_{k+1}Si​=Sk+1​，此时jjj有k+1−ik+1-ik+1−i种选.

https://leetcode-cn.com/problems/brick-wall/思路：很容易证明，最优解的那条线至少穿过了一对砖块之间的缝隙。也就是说，最优解一定在缝隙处产生。那么我们可以计算每个缝隙处的砖块数量，并记录最大值，答案就等于墙的个数减去该最大值。class Solution {public: int leastBricks(vector<vector<int>>& wall) { unordered_map<unsi

https://leetcode-cn.com/problems/design-hashmap/思路：vector+forward_listvector+forward\_listvector+forward_list，链地址法即可。class node{public: int key,value; node(int k=0,int v=0):key(k),value(v){}};class MyHashMap {public: /** Initialize you

https://leetcode-cn.com/problems/design-hashset/思路一：朴实无华且枯燥的链地址法，通过vector、forward_listvector、forward\_listvector、forward_list实现(后者是一个单向链表)。class MyHashSet {public: /** Initialize your data structure here. */ const int num=2333; vector<fo

http://www.pipioj.online/problem.php?id=1476思路：通过字符串哈希，可以在O(n)O(n)O(n)复杂度内计算出长度为lenlenlen的所有s1s_1s1​的子串的哈希值，将其用哈希表存起来，那么就可以在O(n)O(n)O(n)复杂度内判断s1、s2s_1、s_2s1​、s2​是否有公共子串。二分公共子串的长度，复杂度O(nlgn)O(nlgn)O(nlgn)。#include<bits/stdc++.h>#define INF 0x3f3f3

https://leetcode-cn.com/problems/degree-of-an-array/思路：首先遍历一遍统计数组的度，之后维护滑动窗口，保证窗口内的度等于最大值即可。class Solution {public: int findShortestSubArray(vector<int>& nums) { vector<int> cnt(50000); int n=nums.size(),MAX=0;

https://leetcode-cn.com/problems/find-all-numbers-disappeared-in-an-array/思路：使用额外空间的话很简单，用一个数组记录是否出现过即可。现在考虑优化，如何直接在给定的数组上做哈希。我们可以把numsinums_inumsi​映射到一个新的下标：idx=(numsi−1)%nidx=(nums_i-1)\%nidx=(numsi​−1)%n，然后把nums[idx]nums[idx]nums[idx]加上nnn，最后遍历numsnum

https://leetcode-cn.com/problems/fair-candy-swap/思路：看数据范围知道暴力枚举是不行滴，先转化问题，不妨设sumA=∑i=0nAisumA=\sum_{i=0}^nA_isumA=∑i=0n​Ai​，sum=sumA+∑i=0mBisum=sumA+\sum_{i=0}^mB_isum=sumA+∑i=0m​Bi​，那么此时我们枚举iii，假设爱丽丝需要交换的糖果数是A[i]A[i]A[i]，那么显然要存在一个jjj，使得下式成立：sumA−A[i]+B

https://leetcode-cn.com/problems/shortest-palindrome/思路：思路其实很简单，因为只能在字符串的头部添加字符，所以我们只要找到下标从0开始的最长回文串s1s_1s1​，假设后面部分为s2s_2s2​，那么答案就等于reverse(s2)+sreverse(s_2)+sreverse(s2​)+s。怎么在线性复杂度内找到s1s_1s1​呢？我们有两种方法，第一种方法是利用hashhashhash，通过定义进制数和模数，我们可以将一个字符串表示成数字，比如进

https://leetcode-cn.com/problems/lru-cache/思路：使用双向链表模拟队列，当执行获取或者写入操作时，将对应的节点放到头节点之后(队头)。为了做到O(1)O(1)O(1)获取数据、O(1)O(1)O(1)写入数据，我们还需要一个哈希表，建立从keykeykey到双向链表节点的映射。class LRUCache {public: LRUCache(int capacity):c(capacity) { } int get(int

https://leetcode-cn.com/problems/next-greater-element-i/思路：题目说的花里胡哨……其实就是对于nums2nums2nums2的每一个元素，求出位于其右侧且大于它的一个元素的值就可以了，搞一个单调栈就行了，维护一个单调递减栈即可在线性复杂度内求出。但是考虑到nums1nums1nums1是乱序的，所以需要再搞一个哈希表。class Solution {public: vector<int> nextGreaterElement

https://leetcode-cn.com/problems/remove-zero-sum-consecutive-nodes-from-linked-list/comments/思路一：暴力。枚举起始点lll，找到一个终结点rrr，使得[l,r)[l,r)[l,r)元素之和等于000，然后修改节点之间的关系即可。最差情况下时间复杂度为O(n2)O(n^2)O(n2)。注意此题不能使用deletedeletedelete回收空间。/** * Definition for singly-link

https://leetcode-cn.com/problems/copy-list-with-random-pointer/思路一：首先忽略randomrandomrandom指针，遍历给定链表h1h_1h1​，同时建立出它的深拷贝h2h_2h2​，并建立从h1h_1h1​到h2h_2h2​的映射。然后我们再次遍历链表h1h_1h1​，有了映射关系，就可以修改randomrandomrandom指针了。/*// Definition for a Node.class Node {public:

https://leetcode-cn.com/problems/linked-list-components/思路：哈希一下GGG中出现的值，然后遍历链表判断就行了。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solu

https://leetcode-cn.com/problems/intersection-of-two-linked-lists-lcci/思路一：哈希表。记录链表AAA的所有节点，然后遍历BBB看是否存在被记录过的节点即可。/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next

https://leetcode-cn.com/problems/remove-duplicate-node-lcci/思路：因为元素范围在[0,20000][0,20000][0,20000]内，所以搞一个数组哈希存一下出现过的值即可。剩下的操作就是简单的删除单向链表的某个节点辣(当然可以暴力O(n2)O(n^2)O(n2)搞，这样空间复杂度是O(1)O(1)O(1)的)。/** * Definition for singly-linked list. * struct ListNode {

https://leetcode-cn.com/problems/continuous-subarray-sum/思路：hash+dphash+dphash+dp。搞一个hashhashhash表，dp[sum]=idp[sum]=idp[sum]=i，表示[0…i][0…i][0…i]的前缀和si%k=sums_i\%k=sumsi​%k=sum，初始可以令dp[0]=−1dp[0]=-1dp[0]=−1，然后遍历整个数组，记录前缀和sis_isi​，如果dp[si%k]dp[s_i\%k]dp[si

https://leetcode-cn.com/problems/fu-za-lian-biao-de-fu-zhi-lcof/思路一：借助哈希表，建立新旧节点之间的映射即可。/*// Definition for a Node.class Node {public: int val; Node* next; Node* random; Nod...

https://ac.nowcoder.com/acm/contest/5026/E思路：其实就是找一个长度为xxx的字串，使得它在字符串sss中至少出现了kkk次，且这kkk个sss均不相交。很显然，长度xxx满足单调性，所以我们可以二分长度。那么如何快速判断两个字串是否相等呢？哈希。我们设进制为basebasebase，h[i]h[i]h[i]表示s[1…i]s[1…i]s[1…i]的哈希值...