leetcode-高频题题解
1. Two Sum
hashmap的2-sum模板
class Solution {
public:
vector twoSum(vector& nums, int target) {
vector res;
if(nums.size()==0){
return res;
}
unordered_map m;
for(int i=0;i 8. String to Integer (atoi)
返回值是int型：
class Solution {
public:
int myAtoi(string str) {
int num = 0;
int sign = 1;
const int n = str.size();
int i = 0;
while (str[i] == ' ' && i < n) i++; //忽略空格
if (str[i] == '+') i++; //判断正负号
else if (str[i] == '-') {
sign = -1;
i++;
}
for (; i < n; i++) {
if (str[i] == '-' || !isdigit(str[i])) //当出现非数字字符，忽略之后的数字
break;
if (num > INT_MAX / 10 ||(num == INT_MAX / 10 && (str[i] - '0') > INT_MAX % 10)) {
return sign == -1 ? INT_MIN : INT_MAX;
}
num = num * 10 + str[i] - '0';
}
return num * sign;
}
};
返回值是long：
int myAtoi(string str) {
long result = 0;
int indicator = 1;
for(int i = 0; i= INT_MAX) return INT_MAX;
if(result*indicator <= INT_MIN) return INT_MIN;
}
return result*indicator;
}
}
15. 3Sum
需要去重的2-sum模板
class Solution {
public:
vector> threeSum(vector& nums) {
vector> res;
if(nums.size()<3){
return res;
}
sort(nums.begin(),nums.end());
for(int i=0;i pair;
pair.push_back(nums[i]);
pair.push_back(nums[l]);
pair.push_back(nums[r]);
res.push_back(pair);
++l;
--r;
while(ltarget){
r--;
}
else{
l++;
}
}
}
return res;
}
};
- public class Solution {
- public List> threeSum(int[] num) {
- List> ans = new ArrayList<>();
- if(num != null && num.length >= 3){
- Arrays.sort(num);
- HashMap map = new HashMap<>();
- HashMap pointer = new HashMap<>();
- for(int i = 0; i < num.length; ++i){
- Integer count = map.get(num[i]);
- if(count == null){
- count = 0;
- pointer.put(num[i], i);
- }
- map.put(num[i], count + 1);
- }
- // List l = new ArrayList<>(4);
- int zero = 0;
- for(int i = 0, j = i + 1; i < num.length; ){
- j = i + 1;
- while(j < num.length){
- int remain = zero - num[i] - num[j];
- Integer count = map.get(remain);
- boolean flag = false;
- if(count != null){
- int site = pointer.get(remain);
- if(site > j){
- flag = true;
- }
- else if(site == j && count >= 2){
- flag = true;
- }
- if(flag){
- List l = new ArrayList<>();
- l.add(num[i]);l.add(num[j]);l.add(remain);
- ans.add(l);
- }
- }
- while( ++j < num.length && num[j] == num[j - 1]);
- }
- while( ++i < num.length && num[i] == num[i - 1]);
- }
- if(map.get(0) != null && map.get(0) >= 3){
- List l = new ArrayList<>();
- l.add(0);l.add(0);l.add(0);
- ans.add(l);
- }
-
- }
- return ans;
- }
- }
20. Valid Parentheses
class Solution {
public:
bool isValid(string s) {
stack st;
for(int i=0;i 21. Merge Two Sorted Lists
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* mergeTwoLists(ListNode* l1, ListNode* l2) {
ListNode dummy(0);
ListNode* tail = &dummy;
while(l1 && l2){
if(l1->val < l2->val){
tail->next = l1;
l1 = l1->next;
}
else{
tail->next = l2;
l2 = l2->next;
}
tail = tail->next;
}
if(l1){
tail->next = l1;
}
if(l2){
tail->next = l2;
}
return dummy.next;
}
};
28. Implement strStr()
class Solution {
public:
int strStr(string haystack, string needle) {
if(!needle.size()) return 0;
else if(haystack.size()50. Pow(x, n)
class Solution {
public:
double myPow(double x, int n) {
if(n==0){
return 1.0;
}
if(n==INT_MIN){
return myPow(x,-n/2) * myPow(x,-n/2);
}
if(n<0){
return 1.0/myPow(x,-n);
}
double half = myPow(x,n/2);
if((n & 1) == 0){
return half*half;
}
return x*half*half;
}
};
56. Merge Intervals
/**
* Definition for an interval.
* struct Interval {
* int start;
* int end;
* Interval() : start(0), end(0) {}
* Interval(int s, int e) : start(s), end(e) {}
* };
*/
class Solution {
public:
vector merge(vector& intervals) {
vector res;
if(!intervals.size() || intervals.size()==1) return intervals;
sort(intervals.begin(),intervals.end(),SortByM1);
Interval t(intervals[0].start,intervals[0].end);
for(int i=1;it.end){
res.push_back(t);
t.start=intervals[i].start;
t.end=intervals[i].end;
}
else{
t.end=max(intervals[i].end,t.end);
}
}
res.push_back(t);
return res;
}
static bool SortByM1(Interval v1, Interval v2)//注意：本函数的参数的类型一定要与vector中元素的类型一致
{
if(v1.start != v2.start)
return v1.start < v2.start;//升序排列
else
return v1.end < v2.end;
}
};
57. Insert Interval
/**
* Definition for an interval.
* struct Interval {
* int start;
* int end;
* Interval() : start(0), end(0) {}
* Interval(int s, int e) : start(s), end(e) {}
* };
*/
class Solution {
public:
vector insert(vector& intervals, Interval newInterval) {
vector res;
if(!intervals.size()){
res.push_back(newInterval);
return res;
}
int index=0;
while(index < intervals.size() && intervals[index].end < newInterval.start){
res.push_back(intervals[index++]);
}
while(index < intervals.size() && intervals[index].start <= newInterval.end){
newInterval.start = min(newInterval.start, intervals[index].start);
newInterval.end = max(newInterval.end, intervals[index].end);
index++;
}
res.push_back(newInterval);
while(index < intervals.size()){
res.push_back(intervals[index++]);
}
return res;
}
};
65. Valid Number
有限状态自动机：
class Solution {
public:
bool isNumber(string str) {
int state=0, flag=0; // flag to judge the special case "."
while(str[0]==' ') str.erase(0,1);//delete the prefix whitespace
while(str[str.length()-1]==' ') str.erase(str.length()-1, 1);//delete the suffix whitespace
for(int i=0; i分情况讨论：
bool isNumber(string s) {
int i = 0;
// skip the whilespaces
for(; s[i] == ' '; i++) {}
// check the significand
if(s[i] == '+' || s[i] == '-') i++; // skip the sign if exist
int n_nm, n_pt;
for(n_nm=0, n_pt=0; (s[i]<='9' && s[i]>='0') || s[i]=='.'; i++)
s[i] == '.' ? n_pt++:n_nm++;
if(n_pt>1 || n_nm<1) // no more than one point, at least one digit
return false;
// check the exponent if exist
if(s[i] == 'e') {
i++;
if(s[i] == '+' || s[i] == '-') i++; // skip the sign
int n_nm = 0;
for(; s[i]>='0' && s[i]<='9'; i++, n_nm++) {}
if(n_nm<1)
return false;
}
// skip the trailing whitespaces
for(; s[i] == ' '; i++) {}
return s[i]==0; // must reach the ending 0 of the string
}
70. Climbing Stairs
class Solution {
public:
int climbStairs(int n) {
if(n==1)
return 1;
if(n==2)
return 2;
else
{
int dp[n+1];
dp[1]=1;dp[2]=2;
for(int i=3;i73. Set Matrix Zeroes
void setZeroes(vector>& matrix) {
bool row = false, col = false;
for(int i = 0; i < matrix.size(); i++){
for(int j = 0; j < matrix[0].size(); j++){
if(matrix[i][j] == 0) {
if(i == 0) row = true;
if(j == 0) col = true;
matrix[0][j] = matrix[i][0] = 0;
}
}
}
for(int i = 1; i < matrix.size(); i++){
for(int j = 1; j < matrix[0].size(); j++){
if(matrix[i][0] == 0 || matrix[0][j] == 0) matrix[i][j] = 0;
}
}
if(col){
for(int i = 0; i < matrix.size(); i++) matrix[i][0] = 0;
}
if(row){
for(int j = 0; j < matrix[0].size(); j++) matrix[0][j] = 0;
}
}
88.Merge Sorted Array
void merge(vector& nums1, int m, vector& nums2, int n) {
int i=m-1,j=n-1,k=m+n-1;
while(i>=0&&j>=0){
if(nums1[i]>nums2[j]) nums1[k--]=nums1[i--];
else nums1[k--]=nums2[j--];
}
while(j>=0) nums1[k--]=nums2[j--];
}
98.Validate Binary Search Tree
/**
* 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 list;
bool isValidBST(TreeNode* root) {
if(!root){
return true;
}
inorder(root);
for(int i=1;ileft);
list.push_back(root->val);
inorder(root->right);
}
};
TreeNode* pre = NULL;
bool isValidBST(TreeNode* root) {
if(root){
if(!isValidBST(root->left)){
return false;
}
if(pre && pre->val >= root->val){
return false;
}
pre = root;
return isValidBST(root->right);
}
return true;
}
125.Valid Palindrome
class Solution {
public:
bool isPalindrome(string s) {
transform(s.begin(),s.end(),s.begin(),::tolower);
int l=0,r=s.size()-1;
while(l// Leet Code, Valid Palindrome
// 时间复杂度 O(n)，空间复杂度 O(1)
class Solution {
public:
bool isPalindrome(string s) {
transform(s.begin(), s.end(), s.begin(), ::tolower);
auto left = s.begin(), right = prev(s.end());
while (left < right) {
if (!::isalnum(*left)) ++left;
else if (!::isalnum(*right)) --right;
else if (*left++ != *right--) return false;
}
return true;
}
};
127.Word Ladder
class Solution {
public:
int ladderLength(string beginWord, string endWord, vector& wordList) {
if(beginWord.size()==0 || endWord.size()==0 || beginWord.size()!=endWord.size()){
return 0;
}
int L = beginWord.size();
int step = 1;
unordered_set s(wordList.begin(),wordList.end());
queue q;
q.push(beginWord);
while(!q.empty()){
int size = q.size();
for(int i=0;i 2.Add Two Numbers
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) {
ListNode prehead(0),* p=&prehead;
int extra = 0;
while(l1 || l2 || extra){
int sum = (l1?l1->val:0) + (l2?l2->val:0) + extra;
extra = sum/10;
p->next = new ListNode(sum%10);
p = p->next;
l1=l1?l1->next:l1;
l2=l2?l2->next:l2;
}
return prehead.next;
}
};
12.Integer to Roman
class Solution {
public:
string intToRoman(int num) {
string str="";
string s[]={"M","CM","D","CD","C","XC","L","XL","X","IX","V","IV","I"};
int nums[]={1000,900,500,400,100,90,50,40,10,9,5,4,1};
for(int i=0;i<13 && num;++i){
int c = num/nums[i];
num %= nums[i];
for(int j=0;j13.Roman to Integer
class Solution {
public:
int romanToInt(string s) {
if(s.empty()) return 0;
int ret=charToInt(s[0]);
int pre=ret;
for(int i=1;i22.Generate Parentheses
class Solution {
public:
vector generateParenthesis(int n) {
vector res;
dfs(res, 0, 0, n, "");
return res;
}
void dfs(vector &res, int left, int right, int n, string str){
if(!n) return;
if(left == n && right == n){
res.push_back(str);
}
if(left > n || right > left)
return;
dfs(res, left+1, right, n, str + "(");
dfs(res, left, right+1, n, str + ")");
}
};
23. k Sorted Lists
见 “九章算法” 笔记本下的笔记 “ch8 - Heap堆”
24.Swap Nodes in Pairs
ListNode* swapPairs(ListNode* head) {
ListNode dummy(0);
dummy.next=head;
ListNode* prev=&dummy;
while(head &&head->next)
{
ListNode* nn=head->next->next;
prev->next=head->next;
head->next->next=head;
head->next=nn;
prev=head;
head=nn;
}
return dummy.next;
}
27.Remove Element
class Solution {
public:
int removeElement(vector& nums, int val) {
if(nums.size()==0){
return 0;
}
int i=0, j=0;
while(j 46.Permutations
class Solution {
public:
vector > permute(vector& num) {
sort(num.begin(), num.end());
vector> result;
vector path; // 中间结果
dfs(num, path, result);
return result;
}
private:
void dfs(const vector& num, vector &path,
vector > &result) {
if (path.size() == num.size()) { // 收敛条件
result.push_back(path);
return;
}
// 扩展状态
for (auto i : num) {
// 查找 i 是否在 path 中出现过
auto pos = find(path.begin(), path.end(), i);
if (pos == path.end()) {
path.push_back(i);
dfs(num, path, result);
path.pop_back();
}
}
}
};
49. Group Anagrams
class Solution {
public:
vector> groupAnagrams(vector& strs) {
vector> ret;
if(strs.empty()) return ret;
map> m;
for(int i=0;i>::iterator it=m.begin();it!=m.end();++it){
ret.push_back(it->second);
}
return ret;
}
};
67. Add Binary
class Solution {
public:
string addBinary(string a, string b) {
string res="";
int c=0,s=0;
for(int i=a.size()-1,j=b.size()-1;i>=0 || j>=0 || c==1;){
int a1=i>=0? a[i--]-'0':0;
int b1=j>=0? b[j--]-'0':0;
int t=a1 + b1 + c;
s = t%2;
c = t/2;
res.insert(res.begin(),s+'0');
}
return res;
}
};
69.Sqrt(x)
class Solution {
public:
int mySqrt(int x) {
if(x<0){
return -1;
}
long long start=0, end = x/2+1;
while(start+1 < end){
long long mid = start + (end-start)/2;
long long t = mid * mid;
if(t == x){
return (int)mid;
}
else if(t > x){
end = mid;
}
else{
start = mid;
}
}
if(start * start <= x && end * end >x){
return (int)start;
}
return (int)end;
}
};
77. Combinations
class Solution {
public:
vector> combine(int n, int k) {
vector> ret;
vector elem;
dfs(ret, elem, 1, n, k);
return ret;
}
void dfs(vector> &ret, vector &elem, int begin, int end,int k1){
int s = elem.size();
if(s==k1){
ret.push_back(elem);
}
else{
for(int i=begin;i<=end;++i){
auto pos=find(elem.begin(),elem.end(),i);
if(pos==elem.end()){
elem.push_back(i);
dfs(ret,elem,i+1,end, k1);
elem.pop_back();
}
}
}
}
};
78. Subsets
class Solution {
private:
void helper(vector > &results,
vector &subset,
vector &nums,
int start) {
results.push_back(subset);
for (int i = start; i < nums.size(); i++) {
subset.push_back(nums[i]);
helper(results, subset, nums, i + 1);
subset.pop_back();
}
}
public:
vector> subsets(vector &nums) {
vector > results;
vector subset;
sort(nums.begin(), nums.end());
helper(results, subset, nums, 0);
return results;
}
};
79. Word Search
class Solution {
public:
bool exist(vector>& board, string word) {
if(!word.size()) return false;
int m=board.size(),n=0;
if(m){
n=board[0].size();
}
int len=word.size();
vector > visit(m,vector(n,false));
for(int i=0;i > &visit, int start, string word, vector> board, int i, int j){
if(word[start]!=board[i][j]) return false;
else{
visit[i][j]=true;
if(start==word.size()-1) return true;
else{
if(i-1>=0 && !visit[i-1][j] && check(visit,start+1,word,board,i-1,j)) return true;
if(i+1=0 && !visit[i][j-1] && check(visit,start+1,word,board,i,j-1)) return true;
if(j+1 91. Decode Ways
class Solution {
public:
int numDecodings(string s) {
int n = s.size();
vector dp(n+1,0); //表示前i位的编码数目，即对应坐标0~i-1
if(n==0){
return 0;
}
if(s[0] == '0'){ //注意！！！
return 0;
}
dp[0] = 1;
dp[1] = 1;
for(int i=2;i<=n;++i){
if(s[i-1] >= '1'){
dp[i] = dp[i-1];
}
string s2 = s.substr(i-2,2);
int t = 0;
stringstream ss;
ss<>t;
if(t>=10 && t<=26){
dp[i] += dp[i-2];
}
}
return dp[n];
}
};
102. Binary Tree Level Order Traversal
/**
* 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> levelOrder(TreeNode* root) {
vector> res;
if(!root){
return res;
}
queue q;
q.push(root);
while(!q.empty()){
int size = q.size();
vector level;
for(int i=0;ival);
if(node->left){
q.push(node->left);
}
if(node->right){
q.push(node->right);
}
}
res.push_back(level);
}
return res;
}
};
129. Sum Root to Leaf Numbers
/**
* 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:
int sumNumbers(TreeNode *root) {
return dfs(root, 0);
}
private:
int dfs(TreeNode *root, int sum) {
if (root == nullptr) return 0;
if (root->left == nullptr && root->right == nullptr)
return sum * 10 + root->val;
return dfs(root->left, sum * 10 + root->val) +
dfs(root->right, sum * 10 + root->val);
}
};
131. Palindrome Partitioning
class Solution {
public:
/*
* @param s: A string
* @return: A list of lists of string
*/
vector> partition(string &s) {
// write your code here
vector> res;
vector str;
if(!s.size()){
return res;
}
dfs(s, res, str, 0);
return res;
}
//找到所有以str开头的是回文串的组合，放入res中
void dfs(string &s, vector> &res, vector &str, int startIndex){
if(startIndex == s.size()){
res.push_back(str);
return;
}
for(int i=startIndex; i 4. Median of Two Sorted Arrays
class Solution {
public:
double findMedianSortedArrays(vector& nums1, vector& nums2) {
int n1=nums1.size(),n2=nums2.size();
int n=n1+n2;
if(n&1){
return findMadian(nums1,0,nums2,0,n/2+1);
}
else{
return (findMadian(nums1,0,nums2,0,n/2)+findMadian(nums1,0,nums2,0,n/2+1))/2.0;
}
}
double findMadian(vector& nums1, int start1, vector& nums2, int start2, int k){
int n1=nums1.size(),n2=nums2.size();
if(n1-start1>n2-start2) return findMadian(nums2,start2,nums1,start1,k);
if(n1-start1<=0) return nums2[start2+k-1];
if(k==1) return min(nums1[start1],nums2[start2]);
int k1=min(k/2,n1-start1),k2=k-k1;
if(nums1[start1+k1-1]==nums2[start2+k2-1])
return nums1[start1+k1-1];
else if(nums1[start1+k1-1]>nums2[start2+k2-1])
return findMadian(nums1,start1,nums2,start2+k2,k1);
else
return findMadian(nums1,start1+k1,nums2,start2,k2);
}
};
7. Reverse Integer
class Solution {
public:
int reverse(int x) {
if (x == INT_MIN)
return 0;
if (x < 0)
return -reverse(-x);
int rx = 0; // store reversed integer
while (x != 0) {
// check overflow
if (rx > INT_MAX / 10 || 10 * rx > INT_MAX - x % 10) return 0;
rx = rx * 10 + x % 10;
x = x / 10;
}
return rx;
}
};
10.Regular Expression Matching
class Solution {
public:
bool isMatch(string s, string p) {
if(p.empty()) return s.empty();
if(p.size()>1 && p[1]=='*'){
return isMatch(s,p.substr(2)) || (!s.empty() && (s[0]==p[0] || p[0]=='.') && isMatch(s.substr(1),p));
}
else{
return !s.empty() && (s[0]==p[0] || p[0]=='.') && isMatch(s.substr(1), p.substr(1));
}
}
};
https://www.jianshu.com/p/85f3e5a9fcda
对于第4个条件：当p的第二个字符不是星号时，如果S不空且(p.charAt(0) == s.charAt(0) 或者 p.charAt(0)‘ . ’)，则进入下一层递归继续比较分别截取首元素的s和p；否则，返回false。
对于第5个条件：当p的第二个字符是星号时，如果S不空且(p.charAt(0) == s.charAt(0) 或者 p.charAt(0)‘ . ’)，有两种分支需要分别判断：
1、某字符+星号不要匹配s的首字符：（因为星号之前的字符可出现可不出现，该情况不配是考虑到后面有必须匹配的。假设当前匹配并截去s的首字符，会导致后续匹配错误。） 截去p的前两个元素（某字符+星号）并进入下一层递归，假如返回true，则当前递归返回true；假如返回false，进入分支2。
2、某字符+星号要匹配s的首字符：截去s首字符并继续条件5的判断。
对于第6个条件：当p的第二个字符是星号时，非【S不空且(p.charAt(0) == s.charAt(0) 或者 p.charAt(0)==‘ . ’)】，截去p的前两个元素（某字符+星号）并进入下一层递归。
17.Letter Combinations of a Phone Number
class Solution {
public:
vector letterCombinations(string digits) {
vector ret;
//特殊情况处理，当输入为空或者输入中包含处2-9以外的数字时。
bool flg=0;
for(int i=0;i'9'){
flg=1;
break;
}
}
if(digits.empty() || flg)
return ret;
vector nums = {"","","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
string str="";
dfs(ret, str, 0, digits, nums);
return ret;
}
void dfs(vector &ret, string &str, int startIndex, string digits, vector nums){
if(startIndex == digits.size()){
ret.push_back(str);
return;
}
for(int i=0;i 19.Remove Nth Node From End of List
class Solution {
public:
ListNode* removeNthFromEnd(ListNode* head, int n) {
ListNode dummy(0);
dummy.next = head;
ListNode* p1 = &dummy, *p2 = &dummy;
for(int i=0;inext;
}
while(p1->next){
p1 = p1->next;
p2 = p2->next;
}
p2->next = p2->next->next;
return dummy.next;
}
};
26.Remove Duplicates from Sorted Array
class Solution {
public:
int removeDuplicates(vector& nums) {
if(nums.size()==0){
return 0;
}
int i=0,j=0;
while(j 80.Remove Duplicates from Sorted List II
class Solution {
public:
int removeDuplicates(vector& nums) {
if(nums.size()==0){
return 0;
}
int idx = 0;
int cnt = 0;
for(int i=0;i0 && nums[i] == nums[i-1]){
cnt++;
if(cnt>=3){
continue;
}
}
else{
cnt=1;
}
nums[idx++] = nums[i];
}
return idx;
}
};
29.Divide Two Integers
class Solution {
public:
int divide(int dividend, int divisor) {
if(!divisor || (dividend == INT_MIN && divisor == -1)) // overflow
return INT_MAX;
int sign = ((dividend<0)^(divisor<0))?-1:1;
long long dvd = labs(dividend); //陷阱1
long long dvs = labs(divisor);
int res = 0;
while(dvd >= dvs){
long long tmp = dvs, mul = 1;
while(dvd >= (tmp<<1)){ //陷阱2
tmp <<= 1;
mul <<= 1;
}
dvd -= tmp;
res += mul;
}
return sign == 1 ? res:-res;;
}
};
33.Search in Rotated Sorted Array
class Solution {
public:
int search(vector& nums, int target) {
if(nums.size()==0){
return -1;
}
int start=0,end=nums.size()-1;
while(start+1 nums[start]){ // mid在上升区间
if(target >= nums[start] && target <= nums[mid]){
end = mid;
}
else{
start = mid;
}
}
else{ //mid在下降区间
if(target >= nums[mid] && target <= nums[end]){
start = mid;
}
else{
end = mid;
}
}
}
if(nums[start] == target){
return start;
}
if(nums[end] == target){
return end;
}
return -1;
}
};
81.Search in Rotated Sorted Array II
class Solution {
public:
bool search(vector& nums, int target) {
if(nums.size()==0){
return false;
}
int start=0,end=nums.size()-1;
while(start+1 nums[start]){ // mid在上升区间
if(target >= nums[start] && target <= nums[mid]){
end = mid;
}
else{
start = mid;
}
}
else if(nums[mid] < nums[start]){ //mid在下降区间
if(target >= nums[mid] && target <= nums[end]){
start = mid;
}
else{
end = mid;
}
}
else{
start++;
}
}
if(nums[start] == target){
return true;
}
if(nums[end] == target){
return true;
}
return false;
}
};
34.Search for a Range
class Solution {
public:
vector searchRange(vector& A, int target) {
vector res(2,-1);
int n = A.size();
if(!n)
return res;
int l = 0, r=0;
int start=0, end = n-1;
while(start+1 < end){
int mid = start + (end -start)/2;
if(target <= A[mid]){
end = mid;
}
else{
start = mid;
}
}
if(A[start] == target)
l = start;
else if(A[end] == target)
l = end;
else
return res;
start = 0;
end = n-1;
while(start+1 < end){
int mid = start + (end -start)/2;
if(target >= A[mid]){
start = mid;
}
else {
end = mid;
}
}
if(A[end] == target) // 注意此处先比较end
r = end;
else if(A[start] == target)
r = start;
else
return res;
res[0] = l;
res[1] = r;
return res;
}
};
39.Combination Sum
class Solution {
public:
vector> combinationSum(vector& candidates, int target) {
vector> res;
if(candidates.size()==0){
return res;
}
sort(candidates.begin(),candidates.end());
vector one;
dfs(candidates, res, one, target, 0);
return res;
}
void dfs(vector candidates, vector> &res, vector &one, int remain, int startIndex){
if(remain == 0){
res.push_back(one);
return;
}
for(int i=startIndex;istartIndex && candidates[i] == candidates[i-1]){
continue;
}*/
if(candidates[i] <= remain){
one.push_back(candidates[i]);
dfs(candidates,res,one,remain - candidates[i], i);//可重复取多次体现在此处的startIndex没有+1
one.pop_back();
}
else{
break;
}
}
}
};
40.Combination Sum Ⅱ
class Solution {
public:
vector> combinationSum2(vector& candidates, int target) {
vector> res;
if(candidates.size()==0){
return res;
}
sort(candidates.begin(),candidates.end());
vector one;
dfs(candidates, res, one, target, 0);
return res;
}
void dfs(vector candidates, vector> &res, vector &one, int remain, int startIndex){
if(remain == 0){
res.push_back(one);
return;
}
for(int i=startIndex;istartIndex && candidates[i] == candidates[i-1]){ //跳过重复元素
continue;
}
if(candidates[i] <= remain){
one.push_back(candidates[i]);
dfs(candidates,res,one,remain - candidates[i], i+1);//每个元素只能选1次，所以此处是i+1
one.pop_back();
}
else{
break;
}
}
}
};
216.Combination Sum Ⅲ
class Solution {
public:
vector> combinationSum3(int k, int n) {
vector> res;
if(n==0 && k>0 || k>n || k==0){
return res;
}
vector one;
dfs(res,one,1,k,n);
return res;
}
void dfs(vector> &res, vector &one, int startIdx, int k, int n){
if(n==0 && k==0){
res.push_back(one);
return;
}
for(int i=startIdx;i<=9;++i){ // 无重复元素
if(n < i){
break;
}
one.push_back(i);
dfs(res,one,i+1,k-1,n-i); //每个元素选一次
one.pop_back();
}
}
};
43.Multiply Strings
class Solution {
public:
string multiply(string num1, string num2) {
string res(num1.size()+num2.size(), '0');
for(int i=num1.size()-1;i>=0;--i){
int carry = 0;
for(int j=num2.size()-1;j>=0;--j){
int tmp = res[i+j+1]-'0' + (num1[i]-'0') * (num2[j]-'0') +carry;
res[i+j+1] = tmp%10 + '0';
carry = tmp/10;
}
res[i] += carry;
}
size_t startpos=res.find_first_not_of("0");
if(startpos != string::npos){
return res.substr(startpos);
}
return "0";
}
};
44.Wildcard Matching
http://blog.csdn.net/makuiyu/article/details/43698963
-
迭代回溯【可用】
-
递归回溯 【时间会超】
-
动态规划 【空间会超】
0 1 2 3 4 5 6 7 8
s: a b c d a c c c
| | \ \ \
p: a b * c d * a c c
|
失配class Solution {
public:
bool isMatch(string s, string p) {
int sl = s.size(), pl = p.size();int ss = 0, pp = -1; int i=0, j=0; while(i};
51.N-Queens
class Solution {
public:
vector> solveNQueens(int n) {
vector> res;
if(n<=0){
return res;
}
vector one;
dfs(res, one, n);
return res;
}
void dfs(vector> &res, vector &one, int n){
if(one.size()==n){
res.push_back(drawChessBoard(one));
return;
}
for(int i=0;i drawChessBoard(vector &one){
vector res;
for(int i=0;i one, int idx){
for(int i=0;i 52.N-Queens II
class Solution {
public:
int totalNQueens(int n) {
if(n<=0){
return 0;
}
int res = 0;
vector one;
dfs(res, one, n);
return res;
}
void dfs(int &res, vector &one, int n){
if(one.size()==n){
res++;
return;
}
for(int i=0;i one, int idx){
for(int i=0;i 53.Maximum Subarray
class Solution {
public:
int maxSubArray(vector& nums) {
int maxglobal = nums[0];
int curmax = nums[0];
for(int i=1;i nums[i]){
curmax += nums[i];
}
else{
curmax = nums[i];
}
maxglobal = max(curmax,maxglobal);
}
return maxglobal;
}
};
62.Unique Paths
class Solution {
public:
int uniquePaths(int m, int n) {
vector f(n,0);
for(int i=0;i 63.Unique Paths II
class Solution {
public:
int uniquePathsWithObstacles(vector>& obstacleGrid) {
int m = obstacleGrid.size(); //m行n列
if(!m){
return 0;
}
int n = obstacleGrid[0].size();
vector f(n,0);
for(int i=0;i 64.Minimum Path Sum
class Solution {
public:
int minPathSum(vector>& grid) {
int m=grid.size(),n=0;
if(m) n=grid[0].size();
else return 0;
vector dp(n,grid[0][0]);
for(int i=1;i 72.Edit Distance
class Solution {
public:
int minDistance(string word1, string word2) {
int n1 = word1.size(), n2 = word2.size();
if(!n1 && !n2){
return 0;
}
int f[n1+1][n2+1];
for(int i=0;i<=n1;++i){
f[i][0] = i;
}
for(int j=0;j<=n2;++j){
f[0][j] = j;
}
for(int i=1;i<=n1;++i){
for(int j=1;j<=n2;++j){
if(word1[i-1] == word2[j-1]){
f[i][j] = min(f[i-1][j-1], f[i-1][j]+1); //匹配、删除
f[i][j] = min(f[i][j], f[i][j-1]+1); //插入
}
else{
f[i][j] = min(f[i-1][j-1]+1, f[i-1][j]+1); //替换，删除
f[i][j] = min(f[i][j], f[i][j-1]+1); //插入
}
}
}
return f[n1][n2];
}
};
74.Search a 2D Matrix
class Solution {
public:
bool searchMatrix(vector>& matrix, int target) {
int m=matrix.size(),n=0;
if(m) n=matrix[0].size();
if(!m || !n){
return false;
}
int l = 0, r = m*n-1;
while(l+1 < r){
int mid = l+(r-l)/2;
int t = matrix[mid/n][mid%n];
if(target == t){
return true;
}
else if(target > t){
l = mid;
}
else{
r = mid;
}
}
if(target == matrix[l/n][l%n]){
return true;
}
if(target == matrix[r/n][r%n]){
return true;
}
return false;
}
};
240. Search a 2D Matrix II
class Solution {
public:
bool searchMatrix(vector>& matrix, int target) {
int m = matrix.size();
if(m==0)
return false;
int n = matrix[0].size();
int i = 0, j = n-1;
while(i=0){
if(target == matrix[i][j])
return true;
else if(target < matrix[i][j]){
j--;
}
else{
i++;
}
}
return false;
}
};
83.Remove Duplicates from Sorted List
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
if(!head || !head->next)
return head;
ListNode *pre=head, *cur=head->next;
while(cur){
if(cur->val == pre->val){
cur = cur->next;
pre->next = cur;
}
else{
pre = cur;
cur = cur->next;
}
}
return head;
}
};
82.Remove Duplicates from Sorted List Ⅱ
/**
* Definition for singly-linked list.
* struct ListNode {
* int val;
* ListNode *next;
* ListNode(int x) : val(x), next(NULL) {}
* };
*/
class Solution {
public:
ListNode* deleteDuplicates(ListNode* head) {
ListNode dummy(0);
dummy.next = head;
ListNode *pre = &dummy, *cur = head;
bool isDel = false;
while(cur){
isDel = false;
while(cur->next && cur->val==cur->next->val){
isDel = true;
cur->next = cur->next->next;
}
if(isDel){
cur = cur->next;
pre->next = cur;
isDel = false;
}
else{
pre = cur;
cur=cur->next;
}
}
return dummy.next;
}
};
86.Partition List
ListNode* partition(ListNode* head, int x) {
ListNode left(0), right(0);
ListNode *l = &left, *r = &right;
while(head){
ListNode* & ref = head->val < x ? l : r;
ref->next = head;
ref = ref->next;
head = head->next;
}
l->next = right.next;
r->next = NULL;
return left.next;
}
93.Restore IP Addresses
class Solution {
public:
vector restoreIpAddresses(string s) {
vector res;
if(s.size()<4 || s.size() > 12){
return res;
}
vector ip;
dfs(res, ip, s, 0);
return res;
}
void dfs(vector &res, vector &ip, string s, int startIndex){
if(ip.size()==4){
if(startIndex != s.size()){
return;
}
string str = "";
for(int i=0;i<4;++i){
str += ip[i];
str += ".";
}
str = str.substr(0,str.size()-1);
res.push_back(str);
return;
}
for(int i=startIndex;i>digit;
return digit>=0 && digit<=255;
}
};
94.Binary Tree Inorder Traversal
递归：
class Solution {
public:
vector inorderTraversal(TreeNode* root) {
vector ret;
if(!root){
return ret;
}
vector ret1 = inorderTraversal(root->left);
vector ret2 = inorderTraversal(root->right);
ret.insert(ret.end(), ret1.begin(), ret1.end());
ret.push_back(root->val);
ret.insert(ret.end(), ret2.begin(), ret2.end());
return ret;
}
};
非递归：
class Solution {
public:
vector inorderTraversal(TreeNode* root) {
vector ret;
if(!root){
return ret;
}
stack s;
TreeNode* cur = root;
while(cur || !s.empty()){
while(cur){
s.push(cur);
cur=cur->left;
}
cur = s.top();
ret.push_back(cur->val);
s.pop();
cur = cur->right;
}
return ret;
}
};
103.Binary Tree Zigzag Level Order Traversal
class Solution {
public:
vector> zigzagLevelOrder(TreeNode* root) {
vector> ret;
if(!root){
return ret;
}
stack curlevel;
stack nextlevel;
stack tmp;
curlevel.push(root);
bool normalOrder = true;
while(!curlevel.empty()){
vector cur;
while(!curlevel.empty()){
TreeNode* node = curlevel.top();
curlevel.pop();
cur.push_back(node->val);
if(normalOrder){
if(node->left){
nextlevel.push(node->left);
}
if(node->right){
nextlevel.push(node->right);
}
}
else{
if(node->right){
nextlevel.push(node->right);
}
if(node->left){
nextlevel.push(node->left);
}
}
}
ret.push_back(cur);
tmp = curlevel;
curlevel = nextlevel;
nextlevel = tmp;
normalOrder = !normalOrder;
}
return ret;
}
};
105.Construct Binary Tree from Preorder and Inorder Tree
/**
* 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:
TreeNode* buildTree(vector& preorder, vector& inorder) {
if(!preorder.size() || !inorder.size() || preorder.size()!=inorder.size()){
return NULL;
}
return mybuildTree(preorder,0, preorder.size()-1, inorder, 0, inorder.size()-1);
}
TreeNode* mybuildTree(vector& preorder, int prestart, int preend, vector& inorder, int instart, int inend){
if (instart > inend) {
return NULL;
}
TreeNode* root = new TreeNode(preorder[prestart]);
int pos = findPosition(inorder, instart, inend, preorder[prestart]);
root->left = mybuildTree(preorder, prestart+1, prestart+pos-instart, inorder, instart, pos-1);
root->right = mybuildTree(preorder, prestart+pos-instart+1, preend, inorder, pos+1, inend);
return root;
}
int findPosition(vector A, int start, int end,int key){
int pos = 0;
for(int i=start;i<=end;++i){
if(A[i] == key){
pos = i;
break;
}
}
return pos;
}
};
106.Construct Binary Tree from Inorder and Postorder Tree
/**
* 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:
TreeNode* buildTree(vector& inorder, vector& postorder) {
if(!inorder.size() || !postorder.size() || inorder.size()!=postorder.size()){
return NULL;
}
return mybuildTree(postorder,0, postorder.size()-1, inorder, 0, inorder.size()-1);
}
TreeNode* mybuildTree(vector& postorder, int poststart, int postend, vector& inorder, int instart, int inend){
if (instart > inend) {
return NULL;
}
TreeNode* root = new TreeNode(postorder[postend]);
int pos = findPosition(inorder, instart, inend, postorder[postend]);
root->left = mybuildTree(postorder, poststart, poststart+pos-instart-1, inorder, instart, pos-1);
root->right = mybuildTree(postorder, poststart+pos-instart, postend-1, inorder, pos+1, inend);
return root;
}
int findPosition(vector A, int start, int end, int key){
int pos = 0;
for(int i=start;i<=end;++i){
if(A[i] == key){
pos = i;
break;
}
}
return pos;
}
};
108.Convert Sorted Array to Binary Search Tree
class Solution {
public:
TreeNode* sortedArrayToBST(vector& nums) {
if(nums.size()==0)
return NULL;
return helper(nums, 0, nums.size()-1);
}
TreeNode* helper(vector nums, int start, int end){
if(start>end){
return NULL;
}
TreeNode* root = new TreeNode(nums[start+(end-start)/2]);
root->left = helper(nums, start, start+(end-start)/2-1);
root->right = helper(nums, start+(end-start)/2+1, end);
return root;
}
};
109.Convert Sorted List to Binary Search Tree
class Solution {
public:
ListNode* cur;
TreeNode* sortedListToBST(ListNode* head) {
int size = getLen(head);
cur = head;
return helper(size);
}
TreeNode* helper(int size){
if(size<=0){
return NULL;
}
TreeNode* left = helper(size/2);
TreeNode* root = new TreeNode(cur->val);
cur = cur->next;
TreeNode* right = helper(size - 1 - size/2);
root->left = left;
root->right = right;
return root;
}
int getLen(ListNode* head){
int size = 0;
while(head){
size++;
head = head->next;
}
return size;
}
};
path sumⅠⅡⅢ 求解：
https://segmentfault.com/a/1190000003554851
112.Path SumⅠ
bool hasPathSum(TreeNode* root, int sum) {
if(!root)
return false;
if(!root->left && !root->right)
return root->val == sum;
return hasPathSum(root->left, sum-root->val) || hasPathSum(root->right, sum-root->val);
}
113.Path SumⅡ
vector> pathSum(TreeNode* root, int sum) {
vector> ret;
if(!root)
return ret;
vector one;
dfs(root, ret, one, sum);
return ret;
}
void dfs(TreeNode* root, vector> &ret, vector &one, int sum){
one.push_back(root->val);
if(root->val == sum && !root->left && !root->right){
ret.push_back(one);
}
else{
if(root->left){
dfs(root->left, ret, one, sum-root->val);
}
if(root->right){
dfs(root->right, ret, one, sum-root->val);
}
}
one.pop_back();
}
class Solution {
public:
vector> pathSum(TreeNode* root, int sum) {
vector> ret;
if(!root)
return ret;
if(!root->left && !root->right){
if(sum == root->val){
vector v(1, root->val);
ret.push_back(v);
return ret;
}
else{
return ret;
}
}
vector> l = pathSum(root->left, sum-root->val);
vector> r = pathSum(root->right, sum-root->val);
for(int i=0;ival);
ret.push_back(l[i]);
}
for(int i=0;ival);
ret.push_back(r[i]);
}
return ret;
}
};
437.Path SumⅢ
https://www.cnblogs.com/grandyang/p/6007336.html
int pathSum(TreeNode* root, int sum) {
int res = 0;
vector out;
helper(root, sum, 0, out, res);
return res;
}
void helper(TreeNode* node, int sum, int curSum, vector& out, int& res) {
if (!node) return;
curSum += node->val;
out.push_back(node);
if (curSum == sum) ++res;
int t = curSum;
for (int i = 0; i < out.size() - 1; ++i) {
t -= out[i]->val;
if (t == sum) ++res;
}
helper(node->left, sum, curSum, out, res);
helper(node->right, sum, curSum, out, res);
out.pop_back();
}
666.Path Sum Ⅳ
114.Flatten Binary Tree to Linked List
void flatten(TreeNode* root) {
while(root){
if(root->left){
TreeNode* cur = root->left;
while(cur->right){
cur = cur->right;
}
cur->right = root->right;
root->right = root->left;
root->left = NULL;
}
root = root->right;
}
}
116.Populating Next Right Pointers in Each Node
void connect(TreeLinkNode *root) {
TreeLinkNode * node = NULL;//root表示当前层，node表示当前层的节点，从当前层最左边的节点开始
while(root && root->left){
node = root; // 处理当前层
while(node){
node->left->next = node->right;
if(node->next){
node->right->next = node->next->left;
}
node = node->next;
}
root = root->left;
}
}
116.Populating Next Right Pointers in Each Node Ⅱ
void connect(TreeLinkNode *root) {
if(!root){
return;
}
queue q;
q.push(root);
while(!q.empty()){
int size = q.size();
TreeLinkNode * pre = q.front();
q.pop();
if(pre->left){
q.push(pre->left);
}
if(pre->right){
q.push(pre->right);
}
for(int i=1;inext = node;
pre = node;
if(node->left){
q.push(node->left);
}
if(node->right){
q.push(node->right);
}
}
}
}
128.Longest Consecutive Sequence
class Solution {
public:
vector parent;
vector size;
int longestConsecutive(vector& nums) {
if(!nums.size()) return 0;
for(int i=0;i m;
for(int i=0;i size[pb]){
parent[pb] = pa;
size[pa] += size[pb];
}
else{
parent[pa] = pb;
size[pb] += size[pa];
}
}
}
};
130.Surrounded Regions
class Solution {
public:
class UF{
public:
int* pa;
int* rank;
int count;
UF(int n){
count = n;
pa = new int[n];
rank = new int[n];
for(int i=0;i rank[v]){
pa[v] = u;
}
else if(rank[u] < rank[v]){
pa[u] = v;
}
else{
pa[u] = v;
rank[v]++;
}
count--;
}
int getcount(){
return count;
}
};
void solve(vector>& board) {
int m=board.size();
if(m==0) return;
int n=board[0].size();
UF uf(m*n+1);
for(int i=0;i 3.Longest Substring Without Repeating Characters
int lengthOfLongestSubstring(string s) {
vector loc(256,-1);
int maxlen=0,start=-1;
for(int i=0;i start){
start = loc[s[i]];
}
loc[s[i]] = i;
maxlen = max(maxlen, i-start);
}
return maxlen;
}