weixin_41811657的博客

class Solution {public: ListNode* reverseList(ListNode* head) { ListNode* pre=nullptr; ListNode* cur=head; while(cur){ ListNode* next=cur->next; cur->next=pre; pre=cur; cur.

思路本题为动态规划，动态规划所求目标dp[i]为以元素nums[i]结尾的最大连续子序和;当dp[i-1]>0时，dp[i]=dp[i-1]+nums[i];当dp[i-1]$\leq$0时，dp[i]=nums[i];所以，状态转移方程为：dp[i]=max(0,dp[i−1])+nums[i]dp[i]=max(0,dp[i-1])+nums[i]dp[i]=max(0,dp[i−1])+nums[i]C++class Solution {public: int ma.

class Solution {public: int minSubArrayLen(int s, vector<int>& nums) { int j = 0, sum = 0, len = INT_MAX; for(int i = 0; i<nums.size(); i++) { sum += nums[i]; while(sum >= s) { len = min(len, i - j .

#include<iostream>#include<vector>using namespace std;class Solution {public: bool checkSubarraySum(vector<int>& nums, int k) { vector<int> presum(nums.size()); presum[0]=nums[0]; for(int i=1; .

#include<iostream>#include<vector>#include<unordered_map>using namespace std;class Solution {public: int subarraySum(vector<int>& nums, int k) { unordered_map<int, int> mymap; mymap[0]=1; .

# Definition for singly-linked list.# class ListNode:# def __init__(self, val=0, next=None):# self.val = val# self.next = nextclass Solution: def removeElements(self, head: ListNode, val: int) -> ListNode: temp=List.

C++代码：class Solution {public: int removeDuplicates(vector<int>& nums) { int i=0, count=0, val=nums[0]; for (int j=0; j<nums.size(); j++){ if(nums[j]==val){ count++; } ..

#include<iostream>#include<vector>#include<algorithm>using namespace std;class Solution {private: vector<vector<int>> ans; vector<int> path;public: void backtracking(vector<int>& candidates,.

回溯算法三步法1. 确定递归函数参数  本题需要一维数组path来存放符合条件的结果，二维数组result来存放结果集。定义path 和 result为全局变量。接下来还需要如下参数：targetSum（int）目标和，也就是题目中的n。k（int）就是题目中要求k个数的集合。sum（int）为已经收集的元素的总和，也就是path里元素的总和。startIndex（int）为下一层for循环搜索的起始位置。代码:vector<vector<int>> re.

#include<iostream>#include<vector>#include<cstdlib>using namespace std;class Solution {public: int dx[4]={0, 1, 0, -1}; int dy[4]={1, 0, -1, 0}; int islandPerimeter(vector<vector<int>>& grid) { .

#include<iostream>#include<vector>#include<cstdlib>#include<time.h>using namespace std;class Solution {public: int dfs(vector<vector<int>>& grid, int i, int j){ if (i<0 || j<0 || i == grid..

class Solution {public: void dfs(vector<vector<char>>& grid, int i, int j){ //dfs出现1时保证把以该起点出发的所有发现的上下左右为1的值改为0； if(i<grid.size()&&j<grid[i].size()&&grid[i][j]=='1') grid[i][j] = '0'; //是1修改为0，再找其上下左右周围为1.

.对于每一个边界上的 O，我们以它为起点，标记所有与它直接或间接相连的字母 O；.最后我们遍历这个矩阵，对于每一个字母：.如果该字母被标记过，则该字母为没有被字母 X 包围的字母 O，我们将其还原为字母 O；.如果该字母没有被标记过，则该字母为被字母 X 包围的字母 O，我们将其修改为字母 X。#include<iostream>#include<vector>#include<cstdlib>#include<time.h>usi..

class Solution {public: int rob(vector<int>& nums) { if(nums.size()==1) return nums[0]; int n=nums.size(); vector<int>a(n+1),b(n+1); for (int i=2; i<n+1; i++){ a[i]=max(a[i-1].

当前位置的最优解未必是由前一个位置的最优解转移得到的。当前位置如果是一个负数的话，那么我们希望以它前一个位置结尾的某个段的积也是个负数，这样就可以负负得正，并且我们希望这个积尽可能「负得更多」，即尽可能小。如果当前位置是一个正数的话，我们更希望以它前一个位置结尾的某个段的积也是个正数，并且希望它尽可能地大。于是这里我们可以再维护一个 fmin⁡(i)f_{\min}(i)fmin​(i)，它表示以第 i 个元素结尾的乘积最小子数组的乘积，那么我们可以得到这样的动态规划转移方程：fmax(i)=maxi=.

当row=0且column>0时，dp[0][column]=dp[0][column−1]+grid[0][column]dp[0][column]=dp[0][column-1]+grid[0][column]dp[0][column]=dp[0][column−1]+grid[0][column]当column=0且row>0时，dp[row][0]=dp[row−1][0]+grid[row][0]dp[row][0]=dp[row-1][0]+grid[row][0]dp[row..

贪心算法局部最优解：每次取最大跳跃步数（取最大覆盖范围），整体最优解：最后得到整体最大覆盖范围，看是否能到终点。局部最优推出全局最优，找不出反例，试试贪心！class Solution {public: bool canJump(vector<int>& nums) { int cover=0; if (nums.size()==1) return true; for (int i=0; i<=cover;i++){.

递归class Solution {public: vector<string> paths; void construct_paths(TreeNode* root, string path, vector<string>& paths) { if (root != nullptr) { path += to_string(root->val); if (root->left .

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode(int x) : val(x), left(NULL), right(NULL) {} * }; */class Solution {public: vector<vector<int>&gt.

#include<iostream>#include<vector>using namespace std;class Solution {private: vector<vector<int>> result; vector<int> path; void backtracking(vector<int>& nums, int startIndex) { result.pu.

是分割字符串，不是随机组合#include<iostream>#include<vector>#include<string>using namespace std;//分割字符串，不是组合class Solution {private: vector<vector<string>> result; vector<string> path; // 放已经回文的子串 void backtrac..

#include<iostream>#include<vector>#include<string>#include <algorithm> using namespace std;class Solution {public: vector<string> ans; string temp; void backtrack(string& s, vector<bool>& use.

#include<iostream>#include<vector>#include <algorithm> using namespace std;class Solution {public: vector<vector<int>> ans; vector<int> temp; void backtrack(vector<int>& nums, vector<bool.

#include<iostream>#include<vector>using namespace std;class Solution {public: vector<vector<int>> ans; vector<int> temp; void backtrack(vector<int>& nums, vector<bool>& used){ if .

回溯模板void backtracking(参数) { if (终止条件) { 存放结果; return; } for (选择：本层集合中元素（树中节点孩子的数量就是集合的大小）) { 处理节点; backtracking(路径，选择列表); // 递归 回溯，撤销处理结果 }}#include<iostream>#include<vector>using .

class Solution {public: bool isValid(string s) { int n = s.size(); if (n%2==1){ return false; } unordered_map<char, char> mymap={{')', '('}, {'}', '{'}, {']', '['}}; stack<char> st; .

#include<iostream>#include<vector>#include<string>#include <unordered_map>using namespace std;class Solution {public: vector<string> letterCombinations(string digits) { vector<string> combinations; .

class Solution {public: bool isAnagram(string s, string t) { sort(s.begin(), s.end()); sort(t.begin(), t.end()); string a=s; string b=t; return a==b; }};

由于互为字母异位词的两个字符串包含的字母相同，因此对两个字符串分别进行排序之后得到的字符串一定是相同的，故可以将排序之后的字符串作为哈希表的键。\class Solution {public: vector<vector<string>> groupAnagrams(vector<string>& strs) { unordered_map<string, vector<string>> mp; .

思路：按照与逐行读取 Z 字形图案相同的顺序访问字符串。首先访问 行 0 中的所有字符，接着访问 行 1，然后 行 2，依此类推…对于所有整数 k，行 0 中的字符位于索引k(2⋅numRows−2)k(2 \cdot \text{numRows} - 2)k(2⋅numRows−2) 处;行 numRows−1numRows−1numRows−1 中的字符位于索引 k(2⋅numRows−2)+numRows−1k(2⋅numRows−2)+numRows−1k(2⋅numRows−2)+.

class Solution {public: int nthUglyNumber(int n) { if (n < 1) {return INT_MIN;} int two = 0, three = 0, five = 0; vector<int> dp(n); dp[0] = 1; for (int i = 1; i < n; ++i) { int t1 = d.

class Solution {public: bool exist(vector<vector<char>>& board, string word) { rows = board.size(); cols = board[0].size(); for(int i = 0; i < rows; i++) { for(int j = 0; j < cols; j++) { .

思路：遍历过程中将字符为1的位坐标点处的值置为0class Solution {private: void dfs(vector<vector<char>>& grid, int r, int c) { int row=grid.size(); int col=grid[0].size(); grid[r][c]='0'; if (r - 1 >= 0 && grid[.

class Solution {public: vector<vector<int>> threeSum(vector<int>& nums) { vector<vector<int>> result; sort(nums.begin(),nums.end()); for(int i=0;i<nums.size() && nums[i]<.

暴力法：class Solution {public: vector<int> twoSum(vector<int>& nums, int target) { int i,j; for(i=0;i<nums.size()-1;i++) { for(j=i+1;j<nums.size();j++) { if(nums[i]+n.

最多的水实为垂线段与坐标轴围成的面积class Solution {public: int maxArea(vector<int>& height) { int l=0, r=height.size()-1; int ans=0; while (l<r) { int temp=min(height[r], height[l])*(r-l); ans=max(.

class Solution {public: double myPow(double x, int n) { if(n==0) return 1; //考虑到负数右移永远是负数， if(n==-1) return 1/x; if(n&1) return myPow(x*x, n>>1)*x; else return myPow(x*x, n>>1); }};...

class Solution {public: bool searchMatrix(vector<vector<int>>& matrix, int target) { if(matrix.size()==0) return false; for (int i=0; i<matrix.size();i++) { for (int j=0; j<matrix[0].size(); j.

思路：#include<iostream>#include<vector>#include<string>#include<algorithm>using namespace std;bool cmp(string a, string b){ return a+b > b+a;}class Solution {public:string largestNumber(vector<int>& nums) .

class Solution {public: vector<int> smallestK(vector<int>& arr, int k) { if (arr.size()==0 || k==0) return {}; vector<int> ans; sort(arr.begin(), arr.end()); for (int i=0; i<k;i++) { .