孙佰贵的专栏

#define INF 0x6FFFFFFFclass Solution {public: int maxProfit(vector &prices) { // Start typing your C/C++ solution below // DO NOT write int main() function int maxDiff = 0; int curMinPrice

class Solution {public: int maxProfit(vector &prices) { // Start typing your C/C++ solution below // DO NOT write int main() function //sum all the consecutive positive diff int sum = 0; f

class Solution {//Let f[i][j] to be the maximum sum of j segments from the first i numbers, where the last element we choose is a[i]. //We have two strategies to achieve it:////1.Choosing the opti

class Solution {//refer to http://discuss.leetcode.com/questions/194/integer-to-roman @Ark//roman number//I II III IV V VI VII VIII IX//I 1//V 5//X 10//L 50//C 100//D 500//M 1000public: st

class Solution {//static declare and definition with local scopepublic: void letterCombinations_aux(int step, string& path, vector& ans, const string& digits) { //pay attention to this kind of s

class Solution {public: vector getRow(int rowIndex) { // Start typing your C/C++ solution below // DO NOT write int main() function vector ans(rowIndex+2, 0); vector tmp(ro

class Solution {public: vector > generate(int numRows) { // Start typing your C/C++ solution below // DO NOT write int main() function vector > ans; ans.resize(numRows);

class Solution {public: int reverse(int x) { // Start typing your C/C++ solution below // DO NOT write int main() function int sign = 1; if(x < 0) sign = -1; unsigned int num = x < 0 ? -x

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {}};class Solution {public: ListNode *removeNthFromEnd(ListNode *head, int n) { // Start typing your

class Solution {//I V X L C D M//find out the regular patternpublic: int romanToInt(string s) { // Start typing your C/C++ solution below // DO NOT write int main() function if (s.size() ==

class Solution {//recursive solution is straight forward, just think about a binary tree, we should check//if those sub trees are same(1. left==right, right==left or 2. left==left, right==right)//

class Solution {public: int searchInsert(int A[], int n, int target) { // Start typing your C/C++ solution below // DO NOT write int main() function int l = 0; int r = n-1; while (l <= r)

class Solution {public: bool isValidSudoku(vector > &board) { // Start typing your C/C++ solution below // DO NOT write int main() function return CheckBlock(board) && CheckStrip(board); } b

class Solution { //Split the problem in three steps: // //1.build the adjacency list //2.do a BFS to get a vector> prev array. For example, prev[1] = [2, 3, 0] means we can go from (2 to 1) or (3

class Solution {public: struct Node { int num, idx; Node(int _num = 0, int _idx = 0):num(_num),idx(_idx){} bool operator < (const Node& orh) const { if(num == orh.num) return idx

class Solution {//more detail refer to: http://fisherlei.blogspot.com/2012/12/leetcode-median-of-two-sorted-arrays.html//using the method of getting the kth number in the two sorted array to solve t

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {}};class Solution {//dummy node in the head of the result, avoid judging NULL of headpublic: ListNode *addTwoN

class Solution {//put last char in the end of the string //to avoid extra judge, when go to the end without repeating charpublic: int lengthOfLongestSubstring(string s) { // Start typing your C/

class Solution {//note://1. NULL//2. sign//3. prefix ' '//4. out of range, to avoid this we use long longpublic: int atoi(const char *str) { // Start typing your C/C++ solution below // DO

class Solution {//insert special character, then enumerate every character in workStr and record the max substring O(n^2)public: string longestPalindrome(string s) { // Start typing your C/C++ so

class Solution {//be careful with the special case//when done with coding, figure out some cases (including illegal, normal, edge cases)//to run with this solution, this will help to get a bug-free

class Solution {//compare both the left most and the right most digit, //if not equal return falsepublic: bool isPalindrome(int x) { // Start typing your C/C++ solution below // DO NOT write i

class Solution {//1. If the next character of p is NOT '*', then it must match the current character of s. //Continue pattern matching with the next character of both s and p.//2. If the next chara

class Solution {//O(n)//find the highest bar as one end of the wall//then check left side from left to right, //record the left most high height "h" along the way, //if A[i] < h && A[i] < A[mid],

class Solution {//Find two lines, which together with x-axis forms a container, such that the container contains the most water.//if do not together with x-axis forms a container, //and together wi

class Solution {//1. sort the sequence//2. fix i, then increase j and decrease j accordinglypublic: int threeSumClosest(vector &num, int target) { // Start typing your C/C++ solution below //

class Solution {//1. find out the minimum size string as the pivot string//2. check every other string and update the minSizepublic: string longestCommonPrefix(vector &strs) { // Start

class Solution {public: void threeSum(int step, int sum, vector& path, vector>& ans, const vector& num, vector& used) { if(path.size() == 3) { ans.push_back(path); return;

class Solution {//fix i, j, then let p q walk to find out the fourSum target O(n^3)//there exists O(n^2logn) solutionpublic: vector > fourSum(vector &num, int target) { // Start typing your C/C+

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {}};class Solution {//when finished the code, find come cases to test it firstpublic: ListNode *swapPairs(ListN

struct ListNode { int val; ListNode *next; ListNode(int x) : val(x), next(NULL) {}};class Solution {//once the link order of the list is changed, //we must keep the previous pointer(p in the c

class Solution {public: int removeDuplicates(int A[], int n) { // Start typing your C/C++ solution below // DO NOT write int main() function if(0 == n) return 0; int len = 1; for (int i =

class Solution {public: int removeElement(int A[], int n, int elem) { // Start typing your C/C++ solution below // DO NOT write int main() function int len = 0; for (int i = 0; i < n; ++i)

class Solution {//note: //1. min negative int number->unsigned int//2. construct divisor tablepublic: int divide(int dividend, int divisor) { // Start typing your C/C++ solution below // DO N

class Solution {//from right to left find the minimum larger number to replace the current number//once find, swap(current, minimum larger number), then sort(current+1, end)//find out the regular p

class Solution {//because all the word have same length, if they do not have the same length then they can not be solve by //the solution below//so it can be solve by iterating finding the substrin

class Solution {//once meet Parentheses, we should think of stack//then it is some thing trivialpublic: int longestValidParentheses(string s) { // Start typing your C/C++ solution below // DO

class Solution {//observation is the key, try to solve it by modifying binary searchpublic: int search(int A[], int n, int target) { // Start typing your C/C++ solution below // DO NOT write in

class Solution {//stackpublic: bool isValid(string s) { // Start typing your C/C++ solution below // DO NOT write int main() function stack charStack; for (int i = 0; i < s.size(); ++i) {

class Solution {public: void generateParenthesis_aux(vector& remainNum, stack& stackPath, string& path, vector& ans) { if(remainNum[0] == 0 && remainNum[1] == 0) { ans.push_back(path);