give it a try

LeetCode

力扣

力扣

力扣

详细class Solution {public: static bool cmp(int a,int b){ string ab = to_string(a) + to_string(b); string ba = to_string(b) + to_string(a); return ab < ba; } string minNumber(vector<int>& nums) { so.

详细先求出这个数的位数有多少，再求出这个数是哪个，再求出这个位置是什么数class Solution {public: int check(int num,int a){ string res = ""; while(num){ res = res + (char)((num%10) + '0'); num /= 10; } reverse(res.begin(),res.end(.

详细直接记忆化排序即可class Solution {public: vector<int> getLeastNumbers(vector<int>& arr, int k) { int vis[10005] = {0}; vector<int> v; for(int i = 0;i < arr.size();i++){ vis[arr[i]]++; }

暴力即可，不匹配的时候，删左边也可以，删右边也可以，试一下就可以了class Solution {public: bool validPalindrome(string s) { int l = 0,r = s.size()-1; int flag = true,posl = -1,posr = -1; while(l <= r){ if(s[l] != s[r]){ posl = l.

详细直接模拟有没有这样一个弹出序列即可class Solution {public: bool validateStackSequences(vector<int>& pushed, vector<int>& popped) { stack<int> a; int posa = 0,posb = 0; while(posa < pushed.size()){ if

详细前序的意思就是，树在遍历的时候，子树的根节点优先输出，中序的意思就是，树在遍历的时候，子树的左节点优先输出，后序的意思就是，树在遍历的时候，子树的右节点优先输出，这样的话其实就有一个特性，前序的第一个节点一定为根节点，后序的最后一个节点一点为根节点。当找到中序中根节点的位置时，其左边为左子树，右边为右子树，这样进行划分递归，就可建树class Solution {private: unordered_map<int, int> mp;public: Tr

详细一样的思路，能分3越多越好，只是要注意中间可能会溢出的问题class Solution {public: int mod = 1e9+7; int cuttingRope(int n) { if(n == 2) return 1; if(n == 3) return 2; int num3 = n/3; int num2 = 0; if(n-num3*3 == 2) num2++; e

详细能分3就尽力分，因为他对答案的贡献是最大的，其次是2，最差是1，不能有1的时候存在，宁愿要俩个2，效果也比较好class Solution {public: int cuttingRope(int n) { if(n == 2) return 1; if(n == 3) return 2; int num3 = n/3; int num2 = 0; if(n-num3*3 == 2) num2++;

详细直接快速幂即可class Solution {public: double myPow(double x, int n) { double res = 1; if(n < 0){ n = (long long)abs(n); x = 1.0/x; } while(n > 0){ if(n&1) res

详细n&=(n-1) 每次必定会消去一个一，所以算法复杂度为log(n)，也就是该数中1的个数class Solution {public: int hammingWeight(uint32_t n) { int num = 0; while(n){ n &= (n-1); num++; } return num; }};...

详细快慢指针法，快指针是慢指针的俩倍，如果有环，一定会在环中相遇。而相遇的位置到环入口节点的距离和头结点到入口节点的位置一定相同。class Solution {public: ListNode *detectCycle(ListNode *head) { if(head == nullptr) return nullptr; ListNode* slow = head; ListNode* fast = head; ListN

详细直接暴力即可class Solution {public: vector<int> printNumbers(int n) { vector<int> v; int num = 1; int Max = 1; while(n--){ Max *= 10; } while(num < Max){ v.push_back

详细投票算法，因为众数一定会比一半多，那么最后记录的num一定会是正数，且now一定是众数的值class Solution {public: int majorityElement(vector<int>& nums) { int num = 0,now = nums[0]; for(int i = 0;i < nums.size();i++){ if(now == nums[i]){

题目传送一个前缀乘积，再来一个后缀乘积就可以了，后缀的空间可以省略class Solution {public: vector<int> constructArr(vector<int>& a) { vector<int> v; for(int i = 0;i < a.size();i++){ if(i == 0) v.push_back(a[i]); else{

题目传送一眼看过去很简单，排个序判断即可。关键是怎么好写这个代码AC代码class Solution {public: int findLHS(vector<int>& nums) { int Max = 0,first = 0; sort(nums.begin(),nums.end()); for(int i = 1;i < nums.size();i++){ while(nums[i]

题目传送其实可以dp的，只是数据太大了。dfs也可，偶数直接除2的代价肯定要比一个一个减或者加的代价小，所以是偶数直接除。如果是奇数，就dfs一下，取最小值。因为减一下或者加一下又必定是偶数。偶数又是除2，假设全程除下来，也就最多除32次。那么这个中间加上减的次数，时间复杂度绝对不会多。还可以直接贪心，要分很多情况了还有就是记忆化搜索这里就放个最简单的了class Solution {public: int integerReplacement(int n) { if

dfs遍历整颗树即可。时间复杂度为O(n)AC代码class Solution {public: int sum; int findTilt(TreeNode* root) { dfs(root); return sum; } int dfs(TreeNode* root){ if(root == nullptr){ return 0; } int sumleft.

题目传送暴力然后记忆化即可AC代码class Solution {public: int maxProduct(vector<string>& words) { int len = words.size(),Max = 0; int vis[len+5][30]; for(int i = 0;i < len;i++){ for(int j = 0;j < 30;j++){

题目传送其实相当于就是第i轮，每i个都开关换一下（最开始都是关着的）。那么一个数的约数轮都能把这个数给开或关一次（9能被 1 3 9各来一次）。可以看出当约数是奇数个的时候就可以把灯开着。因为约数都是对称的如8 的约数 1 2 4 81 * 82 * 4而91933所以有奇数个因子，当一个数是完全平方数的时候，就说明那个灯的位置是开着的。那么求一下n之内有多少个完全平方数就可以了。直接sqrt（n）就是答案，如：17 ：sqrt（17）= 4 , 17内有4 3 2 1 这几个数，比

题目传送最开始想二分了，但是实际上是不能分的。因为每一个分的点实际上没有什么规律（自我感觉）。dp：数据只有200，那说明可以跑三个for。先假设区间（i，j），那么是俩for，再枚举一个点x，在区间（i，j）内。那么要保证必胜的策略假设，必须考虑最坏的最好情况。那么当选中一个点的时候，分成俩个区间（i，x-1）和（x+1，j），因为考虑最坏情况，所以x点就不是最坏了，还得继续分区间。那么这个时候选错的代价就是x+max（dp【i】【x-1】），dp【x+1】【j】）。这个时候，只需要枚举每一个在（i

题目传送直接模拟即可class Solution {public: long long findPoisonedDuration(vector<int>& timeSeries, int duration) { int len = timeSeries.size(),last = timeSeries[0]; long long sum = 0; for(int i = 0;i < len;i++){

题目传送水题，直接记忆化即可AC代码class Solution {public: int missingNumber(vector<int>& nums) { int vis[10005] = {0},len = nums.size(); for(int i = 0;i < len;i++){ vis[nums[i]]++; } for(int i = 0;i < le

题目传送思路：dp，记录一下当前的数减去等差值在当前数的前面出现过没有，如果出现过，则直接在前面的基础上加一即可。然后记录最大值AC代码class Solution {public: int longestSubsequence(vector<int>& arr, int difference) { int len = arr.size(); int Max = 1,dp[100005] = {0}; map<in

题目传送暴力，二分，库函数都可class Solution {public: bool isPerfectSquare(int num) { for(long long i = 1;i * i <= num;i++){ if(i*i == num){ return true; } } return false; }};

题目传送水题，记忆化就okAC代码class Solution {public: int distributeCandies(vector<int>& candyType) { map<int,int> mp; int len = candyType.size(); int m = 0; for(int i = 0;i < len;i++){ if(mp[candyType[i]] ==

题目传送直接预处理一下，直接暴力跑就可以了，就是如何简化过程的问题了。先把26个字母预分类一下。后面直接好用。AC代码class Solution {public: vector<string> findWords(vector<string>& words) { vector<string> v; string rowIdx = "12210111011122000010020202"; //预处理 for(int i

题目传送map对应的数据结构是红黑树。红黑树是一种近似于平衡的二叉查找树，里面的数据是有序的。在红黑树上做查找操作的时间复杂度为 O(logN)。而unordered_map对应 哈希表，哈希表的特点就是查找效率高，时间复杂度为常数级别 O(1)， 而额外空间复杂度则要高出许多。所以对于需要高效率查询的情况，使用unordered_map容器。而如果对内存大小比较敏感或者数据存储要求有序的话，则可以用map容器。AC代码class Solution {public: vector&l

下定决心，好好过一天~题目传送思路：状态要找对，不然情况会很复杂俩种状态：1.一个数字独立成字母时。 当是s【i】!= ‘0’ 时，dp【i】 = dp【i-1】，否则该情况对答案无贡献2. 俩个数字成字母时。当s【i-1】和s【i】的和小于等于26，且s【i-1】不等于0时。dp【i】 += dp【i-2】AC代码class Solution {public: int numDecodings(string s) { int len = s.size(); s

题目传送思路：dp，状态为：维护到每一个点的最小步数class Solution {public: int jump(vector<int>& nums) { int dp[10005]; fill(dp,dp+10005,1e9+7); dp[0] = 0; for(int i = 0;i < nums.size();i++) { for(int j = 1;

题目传送思路：递推，dp每次选取一个最小臭数，dp【i】，但是最重要的如何维护，使得每次精准求出第i个丑数。1.那么第一个丑数必定是12.第二个丑数，则需要借助前面的丑数来进行计算。现在令pos数组全为0，我们可以想想，我们用每一个质数来乘以它当前能乘的最小丑数（重复的和已经计算过的除外）。那么pos数组则对应每一个质数能乘的最小丑数（肯定是先乘最小的才能维护到准确的第i个丑数呀）3.那么pos还要进行相应的处理。当选中了准确的第i个丑数后。那么对应的那个质数所能乘的最小丑数又要变化了，我们令

题目传送class Solution {public: int minPathSum(vector<vector<int>>& grid) { int n = grid.size(),m = grid[0].size(); int dp[205][205]; int arr[205][205]; for(int i = 1;i <= n;i++) { f

题目传送思路：很简单，直接设置左上角为1，dp[i][j] = dp[i-1][j] + dp[i][j-1]class Solution {public: int uniquePaths(int m, int n) { long long dp[105][105] = {0}; memset(dp,0,sizeof(dp)); dp[1][1] = 1; for(int i = 1;i <= n;i++)

下定决心，好好过一天 ~题目传送思路：首先数位dp是肯定可以的，只不过状态需要压缩。利用二进制形式进行压缩。但是这个题没有想象那么复杂。直接递推即可，dp[ i ] 代表 拥有 i 位数的合法的数。那么就是 9 * 9 * 8 * 7 … 第一位不能选零。其实更像组合数学。class Solution {public: int countNumbersWithUniqueDigits(int n) { int dp[20] = {0}; dp[0] =

下定决心，好好过一天 ~题目传送这是简单版本。思路：如果拿第 i 个物品，一定可以拿第 i-2 或者 i-3 个物品，那么动态方程就出来了，直接i从0往后遍历即可。dp[i] = max(nums[i] + dp[i-2] , nums[i] + dp[i-3]),输出dp数组中最大值即可class Solution {public: int rob(vector<int>& nums) { int dp[1005] = {0}; i

下定决心，好好过一天 ~题目传送思路：首先还是O（n2）的复杂度把，所有的回文子串都标记上，接下来就可以O（1）查询子序列i到j是否为回文串。接下来再来推另外一个动态方程。设pos[i]表示，以i位置结束的，子序列0到i最少可以分割为多少个符合条件的序列。那么从最开始递推,如果0到i本来就是回文，那么直接pos[i] = 0，否则。再来一个for，枚举位置j，判断j 到 i 是否为回文，如果为回文，那么维护最小值 pos[i] = min(pos[i] , pos[j-1] + 1)，这个1就为j到i这

下定决心，好好过一天 ~题目传送思路：在本子写写就知道。2只能拆成 1 * 1，3 为 1 * 2可以看到，这俩个数拆了过后，他的乘积形式都比自身还小。那么就没必要4 为 2 * 25 为 2 * 36 为 3 * 37 为 3 * 2 * 28 为 3 * 3 * 39 为 3 * 3 * 2 * 210 为 3 * 3 * 3 * 2那么规律就出来了，第n个数的前一个数，如果有2的存在，那么直接把这个2变成3（n比n-1多1）如果没有2，那么就得拆成俩个2出来，原因是，只有