mikefan1991的博客

class Solution {public: vector> combinationSum(vector& candidates, int target) { vector > res; vector set; sort(candidates.begin(),candidates.end()); helper(candid

class Solution {public: vector> combinationSum2(vector& candidates, int target) { vector > res; vector set; sort(candidates.begin(),candidates.end()); helper(candi

class Solution {public: int removeElement(vector& nums, int val) { if(nums.empty()) return 0; if(nums.size()==1) { if(nums[0]==val)

class Solution {public: string longestCommonPrefix(vector& strs) { string res; if(strs.size()==0) return res; int minlen=strs[0].length(); int minidx;

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* me

class Solution {public: vector> fourSum(vector& nums, int target) { sort(nums.begin(),nums.end()); vector set; vector > res; if(nums.size()<4) return r

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* re

class Solution {public: int divide(int dividend, int divisor) { if(divisor==0||dividend==INT_MIN&&divisor==-1) return INT_MAX; long long a=labs(dividend); long

DP method:bool isMatch(char* s, char* p) {    const int m=strlen(s), n=strlen(p);    bool dp[m+1][n+1];    for(int i=0;i        for(int j=0;j            dp[i][j]=0;    dp[0][0]=true;

class Solution {public: vector> threeSum(vector& nums) { vector set; vector > res; if(nums.size()<3) return res; sort(nums.begin(),nums.end());

DP algorithmThe time is too long which can still be optimizedclass Solution {public:bool isMatch(string s, string p) { if(p=="*") return true; if(p.empty()&&!s.empty())

class Solution {public: bool isValid(string s) { stack st; for(int i=0;i<s.length();i++) { if(s[i]=='('||s[i]=='['||s[i]=='{') st.push(s[i]);

class Solution {public: vector generateParenthesis(int n) { string s; vector res; helper(n,n,s,res); return res; } void helper(int left,int right,string s,

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* sw

class Solution {public: int threeSumClosest(vector& nums, int target) { int res=target<0?INT_MAX+target:INT_MAX-target; sort(nums.begin(),nums.end()); for(int i=0;i<nums.s

class Solution {public: int removeDuplicates(vector& nums) { if(nums.empty()) return 0; int res=1; int old=0; for(int i=1;i<nums.size();i++)

DFS method:class Solution {public: void solveSudoku(vector>& board) { solve(board); } bool solve(vector>& board){ int i,j; for(i=0;i<9;i++) {

class Solution {public: int searchInsert(vector& nums, int target) { int left=0,right=nums.size()-1,mid=(left+right)/2; while(left!=right) { if(nums[mid]==targ

class Solution {public: int strStr(string haystack, string needle) { int hlen=haystack.length(); int nlen=needle.length(); if(hlen<nlen) return -1; if(

class Solution {public: bool isValidSudoku(vector>& board) { bool row[9]; bool col[9]; bool block[9]; int num; for(int i=0;i<9;i++) { m

class Solution {public: vector letterCombinations(string digits) { map mp; mp['2']="abc"; mp['3']="def"; mp['4']="ghi"; mp['5']="jkl"; mp['6']="mno

class Solution {public: void nextPermutation(vector& nums) { for(int i=nums.size()-2;i>=0;i--) { if(nums[i]<nums[i+1])//find the place that the first ascending happens

The O(n) method:class Solution {public: int longestValidParentheses(string s) { vector len(s.length(),false); stack st; int res=0; for(int i=0;i<s.length();i++)

class Solution {public: string intToRoman(int num) { map mp; mp.insert(make_pair(1,"I")); mp.insert(make_pair(2,"II")); mp.insert(make_pair(3,"III")); mp.i

class Solution {public: vector anagrams(vector& strs) { vector res; map mp; for(int i=0;i<strs.size();i++) { string temp=strs[i]; if(temp.s

binary search:class Solution {public: vector searchRange(vector& nums, int target) { int left=0,right=nums.size()-1,mid=(left+right)/2; vector res; res.push_back(-1);

class Solution {public: void rotate(vector>& matrix) { int size=matrix.size(); for(int i=0;i<size/2;i++) { for(int j=i;j<size-i-1;j++) {

class Solution {public: string countAndSay(int n) { string s="1"; if(n==1) return s; string res; n--; while(n--) { res.clea

Loop through each bit of n instead of n times. Be careful with the case that when n is INT_MIN.class Solution {public: double myPow(double x, int n) { if(n==0) return 1;

Use stackclass Solution {public: int largestRectangleArea(vector& height) { stack s; int res=0; height.push_back(0); for(int i=0;i<height.size();i++) {

class Solution {public: bool canJump(vector& nums) { if(nums.size()==1) return true; if(nums[0]==0) return false; int max=-1; for(int i=0;i

Learned the 3D dp algorithm from http://blog.sina.com.cn/leetcode.dp[i][j][l] means starting from i in s1 and j in s2, if they can be scambled with the length l. When l goes from 1 to len-max(i,j),

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* de

class Solution {public: int firstMissingPositive(vector& nums) { int i=0; while(i<nums.size()) { if(nums[i]!=i+1&&nums[i]>0&&nums[i]<nums.size()&&nums[i]!=nums

class Solution {public: int maxSubArray(vector& nums) { int max=nums[0]; int pre=nums[0]; for(int i=1;i<nums.size();i++) { if(nums[i]+pre>nums[i])

class Solution {public: int trap(vector& height) { int begin; int res=0; for(begin=0;begin<height.size();begin++)//find the first non-zero position if(height[b

Use the stack algorithm in the previous problem to find maximum area in every line of the matrix.class Solution {public: int maximalRectangle(vector>& matrix) { if(matrix.empty())

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* pa

/** * Definition for singly-linked list. * struct ListNode { * int val; * ListNode *next; * ListNode(int x) : val(x), next(NULL) {} * }; */class Solution {public: ListNode* de

Use another stack to save all minimum numbers. Then while popping, the corresponding minimum number can be popped, and the minimum number is always the top of that stack.class MinStack {public: