SJTU_liangge的博客

KMP算法：前缀函数：对于长度为m的字符串s，前缀函数为π(i)(0<=i<m)表示s的子串s[0:i]的最长的相等的真前缀和真后缀的长度。特别地，如果不存在符合条件的前后缀，那么π(i)=0.真前缀，真后缀：不等于自身的前后缀。aabaaab: 0,1,0,1,2,2,3a ∅ ∅ 0aa a a 1aab a,aa ab,b 0aaba a,aa,aab a,ba,aba 1aabaa a,aa

class Solution {public: int myclumsy(int n,char op,long long int now1,long long int now2){ if(n==0) return now1-now2; if(op=='*'){ return myclumsy(n-1,'/',now1,now2*n); } else if(op=='/'){ return

/** * Definition for a binary tree node. * struct TreeNode { * int val; * TreeNode *left; * TreeNode *right; * TreeNode() : val(0), left(nullptr), right(nullptr) {} * TreeNode(int x) : val(x), left(nullptr), right(nullptr) {} *

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next)

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next)

class Solution {public: bool find132(vector<int>& nums,int start,int end){ if(end-start+1<3) return false; int max = nums[start]; int maxn = start; for(int i=start+1;i<=end;i++){ maxn = nums[

/** * // This is the interface that allows for creating nested lists. * // You should not implement it, or speculate about its implementation * class NestedInteger { * public: * // Return true if this NestedInteger holds a single integer, rather

class Solution {public: int hammingWeight(uint32_t n) { int res = 0; while(n!=0){ if(n&1==1) res+=1; n>>=1; } return res; }};

class Solution {public: int evalRPN(vector<string>& tokens) { stack<int> num; for(int i=0;i<tokens.size();i++){ if(tokens[i]!="+"&&tokens[i]!="-"&&tokens[i]!="*"&&tokens[i]!="/"){

class ParkingSystem {public: int big_park; int med_park; int sma_park; ParkingSystem(int big, int medium, int small):big_park(big),med_park(medium),sma_park(small) { } bool addCar(int carType) { switch(carType){

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next)

class Solution {public: int numDistinct(string s, string t) { int answer = 0; map<char,int> m; for(int i=0;i<t.length();i++) m[t[i]] += 1; string s1; for(int i=0;i<s.length();i++){ if(m[s

class Solution {public: string minWindow(string s, string t) { map<char,int> m; string s1 = s; for(int i=0;i<t.length();i++){ m[t[i]] += 1; } for(int i=0;i<s.length();i++){ if

class Solution {public: void sortColors(vector<int>& nums) { sort(nums.begin(),nums.end()); }};

class MyHashMap {public: /** Initialize your data structure here. */ int *k[1000001]={nullptr}; stack<int> s; MyHashMap() { } /** value will always be non-negative. */ void put(int key, int value) { s.push(va

class Solution {public: bool isValidSerialization(string preorder) { if(preorder == "#") return true; stack<int> s; map<int,int> m; for(int i=0;i<preorder.length();i++){ if(preorder[i]==' ') c

class Solution {public: bool searchMatrix(vector<vector<int>>& matrix, int target) { int left = 0, right = matrix.size()-1; while(left<right){ int mid = (left+right)/2; if(matrix[mid][0]>ta

class Solution {public: int calculate(string s) { stack<int> num; stack<char> op; stack<int> n_num; queue<char> n_op; for(int i=0;i<s.length();i++){ if(s[i]==' ') continue;

class Solution {public: int calculate(string s) { stack<char> op; stack<int> num; for(int i=0;i<s.length();i++){ if(s[i]=='(') op.push(s[i]); else if(s[i]==' ') continue; else

class Solution {public: void setZeroes(vector<vector<int>>& matrix) { map<pair<int,int>,int> m; for(int i=0;i<matrix.size();i++){ for(int j=0;j<matrix[0].size();j++){ if(mat

class Solution {public: int minDistance(string word1, string word2) { int dp[500][500]; int m = word1.length(); int n = word2.length(); if(m==0||n==0) return max(m,n); if(word1[0]==word2[0]) dp[0][0] = 0;

class Solution {public: string simplifyPath(string path) { string res="/"; for(int i=0;i<path.length();i++){ if(path[i]=='/'&&res[res.length()-1]=='/') continue; else if((i-1<0||(i-1>=0&&amp

class Solution {public: int mySqrt(int x) { if(x == 0) return 0; if(x == 1) return 1; int left = 0,right = x/2+1; while(left<right){ int mid = (left+right)/2; if(mid > x/mid) right = mid-1;

class Solution {public: vector<string> fullJustify(vector<string>& words, int maxWidth) { vector<vector<string> > answer; vector<string> now; int nowwidth=0; for(int i=0;i<words.size

class Solution {public: string addBinary(string a, string b) { int n_a = a.length(); int n_b = b.length(); int num_a = max(n_a,n_b); int num_b = min(n_a,n_b); string res; reverse(a.begin(),a.end());

class Solution {public: string removeDuplicates(string S) { for(int i=1;i<S.length();i++){ if(i-1>=0&&S[i]==S[i-1]) { S.erase(i-1,2); i-=2; } } return S;

class Solution {public: vector<int> plusOne(vector<int>& digits) { int res=0; for(int i = digits.size()-1;i>=0;i--){ if(i==digits.size()-1)digits[i] +=1; else digits[i]+=res; res = 0; if(digi

class Solution {public: bool isNumber(string s) { bool flage=false; int pose=-1; bool flagd=false; for(int i=0;i<s.length();i++){ if((i==0&&(s[i]=='+'||s[i]=='-'))|| (i==pose+1&&am

class Solution {public: bool huiwen(string s){ for(int i=0;i<s.length();i++){ if(s[i]!=s[s.length()-1-i]) return false; } return true; } int minCut(string s) { int n = s.length(); int dp[

class Solution {public: bool huiwen(string s){ for(int i=0;i<s.length();i++){ if(s[i]!=s[s.length()-1-i]) return false; } return true; } vector<vector<string> > answer; void func(string s

class Solution {public: vector<int> nextGreaterElements(vector<int>& nums) { stack<pair<int,int> > s1; vector<int> answer; map<int,int> m; bool flag = true; for(int i=0;m.

class Solution {public: int climbStairs(int n) { if(n==0) return 0; if(n==1) return 1; int dp[n]; dp[0] = 1; dp[1] = 2; for(int i=2;i<n;i++){ dp[i] = dp[i-1]+dp[i-2]; } ret

class MyQueue {public: stack<int> s1,s2; /** Initialize your data structure here. */ MyQueue() { } /** Push element x to the back of queue. */ void push(int x) { s1.push(x); } /** Removes the el

class Solution {public: static bool compare(vector<int> a,vector<int> b){ if(a[0]<b[0]) return true; else if(a[0]>b[0]) return false; else{ if(a[1]<b[1]) return true; else return fal

class Solution {public: vector<int> countBits(int num) { vector<int> res; res.push_back(0); if(num >= 1){ res.push_back(1); } int n = num; while(num!=0){ num>&g

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode() : val(0), next(nullptr) {} * ListNode(int x) : val(x), next(nullptr) {} * ListNode(int x, ListNode *next) : val(x), next(next)

class NumMatrix {public: int** num; NumMatrix(vector<vector<int>>& matrix) { if(!matrix.empty()&&!matrix[0].empty()){ int m = matrix.size(); int n = matrix[0].size(); num = new in

class NumArray {public: vector<int> num; NumArray(vector<int>& nums) :num(nums){ } int sumRange(int i, int j) { int res=0; for(;i<=j;i++){ res+=num[i]; } return res;

class Solution {public: bool isMonotonic(vector<int>& A) { int flag=0; if(A.size()<=1) return true; for(int i=1;i<A.size();i++){ if(A[i]>A[i-1]){ if(flag==0) flag = 1;

class Solution {public: int uniquePathsWithObstacles(vector<vector<int>>& obstacleGrid) { if(obstacleGrid.empty()) return 0; if(obstacleGrid[0].empty()) return 0; if(obstacleGrid[0][0]==1) return 0; int