├── README.md ├── hackrank └── 101HackMarch15 │ ├── Devu_and_Minimizing_Runs_of_a_String.cpp │ └── Magical_Girl_Devu_and_Spirits.cpp ├── hdoj ├── hdoj1711.cpp ├── hdoj2222.cpp ├── hdoj2243.cpp ├── hdoj2896.cpp ├── hdoj3065.cpp └── hdoj4763.cpp ├── leetcode ├── 3Sum │ └── 3Sum_Sort.cpp ├── 3Sum_Closest │ └── 3SumClosest_Sort.cpp ├── 4Sum │ ├── 4Sum_Hash.cpp │ └── 4Sum_Sort.cpp ├── AddBinary.cpp ├── AddTwoNumbers.cpp ├── Anagrams │ └── Anagrams.cpp ├── Balanced_Binary_Tree │ └── BalancedBinaryTree.cpp ├── Best_Time_to_Buy_and_Sell_Stock │ └── Best Time to Buy and Sell Stock.cpp ├── Best_Time_to_Buy_and_Sell_Stock_II │ └── BestTimetoBuyandSellStockII.cpp ├── Best_Time_to_Buy_and_Sell_Stock_III │ └── Best Time to Buy and Sell Stock III.cpp ├── Binary_Search_Tree_Iterator │ └── BinarySearchTreeIterator.cpp ├── Binary_Tree_Inorder_Traversal │ ├── BinaryTreeInorderTraversal_recursion.cpp │ ├── BinaryTreeInorderTraversal_stack-1.cpp │ └── BinaryTreeInorderTraversal_stack-2.cpp ├── Binary_Tree_Level_Order_Traversal │ ├── BinaryTreeLevelOrderTraversal_one-queue.cpp │ ├── BinaryTreeLevelOrderTraversal_recursion.cpp │ └── BinaryTreeLevelOrderTraversal_two-vector.cpp ├── Binary_Tree_Level_Order_Traversal_II │ └── BinaryTreeLevelOrderTraversalII.cpp ├── Binary_Tree_Maximum_Path_Sum │ └── BinaryTreeMaximumPathSum.cpp ├── Binary_Tree_Postorder_Traversal │ ├── BinaryTreePostorderTraversal_recursion.cpp │ ├── BinaryTreePostorderTraversal_use-stack.cpp │ └── ReadMe.md ├── Binary_Tree_Preorder_Traversal │ ├── BinaryTreePreorderTraversal_recursion.cpp │ └── BinaryTreePreorderTraversal_use-stack.cpp ├── Binary_Tree_Right_Side_View │ ├── BinaryTreeRightSideView.cpp │ └── BinaryTreeRightSideView_2.cpp ├── Binary_Tree_Zigzag_Level_Order_Traversal │ └── BinaryTreeZigzagLevelOrderTraversal.cpp ├── Candy.cpp ├── ClimbingStairs.cpp ├── Clone_Graph │ ├── CloneGraph_BFS.cpp │ └── CloneGraph_DFS.cpp ├── Combination Sum II.cpp ├── Combination Sum.cpp ├── Combinations.cpp ├── Compare_Version_Numbers │ ├── Compare_Version_Numbers.cpp │ └── Compare_Version_Numbers.py ├── Construct_BinaryTree_from_Inorder_and_Postorder_Traversal │ └── ConstructBinaryTreefromInorderandPostorderTraversal.cpp ├── Construct_BinaryTree_from_Preorder_and_Inorder_Traversal │ └── ConstructBinaryTreefromPreorderandInorderTraversal.cpp ├── ContainerWithMostWater.cpp ├── ContainerWithMostWater_Linear.cpp ├── Convert Sorted Array to Binary Search Tree.cpp ├── Convert Sorted List to Binary Search Tree.cpp ├── CopyListwithRandomPointer.cpp ├── Count and Say.cpp ├── Count_Primes │ └── CountPrimes.cpp ├── Distinct Subsequences.cpp ├── Divide_Two_Integers │ └── DivideTwoIntegers.cpp ├── Edit_Distance │ └── EditDistance.cpp ├── Excel_Sheet_Column_Number │ └── ExcelSheetColumnNumber.cpp ├── Excel_Sheet_Column_Title │ └── ExcelSheetColumnTitle.cpp ├── Factorial_Trailing_Zeroes │ └── FactorialTrailingZeroes.cpp ├── Find_Minimum_in_Rotated_Sorted_Array │ └── FindMinimuminRotatedSortedArray.cpp ├── Find_Minimum_in_Rotated_Sorted_Array_II │ └── FindMinimuminRotatedSortedArrayII.cpp ├── Find_Peak_Element │ ├── FindPeakElement_BinarySearch.cpp │ └── FindPeakElement_Linear.cpp ├── First Missing Positive.cpp ├── Flatten_Binary_Tree_to_Linked_List │ ├── FlattenBinaryTreetoLinkedList.cpp │ ├── FlattenBinaryTreetoLinkedList_InPlace.cpp │ └── FlattenBinaryTreetoLinkedList_O-1-Space.cpp ├── GasStation.cpp ├── GenerateParentheses.cpp ├── Gray_Code │ └── GrayCode.cpp ├── Happy_Number │ └── HappyNumber.cpp ├── House_Robber │ └── House_Robber_DP.cpp ├── Implement-strStr.cpp ├── Insertion Sort List.cpp ├── Integer_to_Roman │ └── RomantoInteger.cpp ├── Interleaving_String │ ├── InterleavingString_DFS.cpp │ └── InterleavingString_DP.cpp ├── Intersection_of_Two_Linked_Lists │ ├── IntersectionofTwoLinkedLists.cpp │ └── IntersectionofTwoLinkedLists_tricky.cpp ├── Ismorphic_Strings │ └── IsmorphicStrings.cpp ├── JumpGame.cpp ├── JumpGameGreedy.cpp ├── JumpGameII_DP.cpp ├── JumpGameSearch.cpp ├── LRU_Cache │ └── LRUCache.cpp ├── Largest_Number │ └── LargestNumber.cpp ├── Length of Last Word.cpp ├── LetterCombinationsofaPhoneNumber.cpp ├── Linked_list_Cycle │ └── Linked List Cycle.cpp ├── Linked_list_Cycle_II │ ├── Linked List Cycle II.cpp │ └── readme.md ├── Longest Consecutive Sequence.cpp ├── Longest Valid Parentheses.cpp ├── LongestCommonPrefix.cpp ├── LongestPalindromicSubstring.cpp ├── LongestSubstringWithoutRepeatingCharacters.cpp ├── Majority_Element │ └── MajorityElement.cpp ├── Max_points_on_a_line.cpp ├── MaximumDepthofBinaryTree.cpp ├── Maximum_Gap │ └── MaximumGap.cpp ├── Maximum_Subarray │ ├── MaximumSubarray_DP.cpp │ └── MaximumSubarray_Divide-Conquer.cpp ├── MedianofTwoSortedArrays.cpp ├── MergeSortedArray.cpp ├── MergeTwoSortedLists.cpp ├── Merge_Intervals │ └── MergeIntervals.cpp ├── MergekSortedLists.cpp ├── MinimumPathSum.cpp ├── Minimum_Depth_of_Binary_Tree │ └── MinimumDepthofBinaryTree.cpp ├── Multiply Strings.cpp ├── NQueens.cpp ├── NQueensII.cpp ├── NextPermutation.cpp ├── Next_Permutation │ └── NextPermutation.cpp ├── Number_of_1_Bits │ └── NumberOf1Bits.cpp ├── PalindromeNumber.cpp ├── PalindromePartitioning.cpp ├── PalindromePartitioningII.cpp ├── Partition List.cpp ├── Pascalz_Triangle │ └── PascalsTriangle.cpp ├── Pascalz_Triangle_II │ └── PascalsTriangleII.cpp ├── Path_Sum │ └── PathSum.cpp ├── Path_Sum_II │ └── PathSumII.cpp ├── Permutation Sequence.cpp ├── Permutations II.cpp ├── Permutations.cpp ├── PlusOne.cpp ├── Populating Next Right Pointers in Each Node_I__II.cpp ├── Pow_x_n.cpp ├── README.md ├── Recover_Binary_Search_Tree │ ├── RecoverBinarySearchTree.cpp │ └── readme.md ├── RegularExpressionMatching.cpp ├── Remove Duplicates from Sorted List II.cpp ├── RemoveDuplicatesfromSortedArray.cpp ├── RemoveDuplicatesfromSortedList.cpp ├── RemoveNthNodeFromEndofList.cpp ├── Remove_Duplicates_from_Sorted_Array_II │ └── RemoveDuplicatesfromSortedArrayII.cpp ├── Remove_Element │ └── RemoveElement.cpp ├── Remove_Linked_List_Elements │ └── RemoveLinkedListElements.cpp ├── Reorder List.cpp ├── Restore_IP_Address │ └── RestoreIPAddress.cpp ├── ReverseInteger.cpp ├── ReverseNodesink-Group.cpp ├── Reverse_Bits │ ├── ReverseBits_Binary2Dec.cpp │ └── ReverseBits_BitOP.cpp ├── Reverse_Linked_list_II │ └── ReverseLinkedListII.cpp ├── Reverse_Words_in_a_String │ └── ReverseWordsInAString.cpp ├── Roman_to_Integer │ └── RomantoInteger.cpp ├── Rotate Image.cpp ├── RotateList.cpp ├── Rotate_Array │ └── RotateArray_dc.cpp ├── Same_Tree │ ├── SameTree.cpp │ └── SameTree_use-stack.cpp ├── Search a 2D Matrix.cpp ├── Search_For_A_Range │ └── SearchForARange.cpp ├── Search_Insert_Position │ └── SearchInsertPosition.cpp ├── Search_in_Rotated_Sorted_Array │ └── SearchinRotatedSortedArray.cpp ├── Search_in_Rotated_Sorted_Array_II │ └── SearchinRotatedSortedArrayII.cpp ├── Set_Matrix_Zeroes │ ├── SetMatrixZeroes_BruteForce.cpp │ ├── SetMatrixZeroes_ConstantSpace.cpp │ └── SetMatrixZeroes_LessSpace.cpp ├── Single_Number │ └── SingleNumber.cpp ├── Single_Number_II │ └── SingleNumberII.cpp ├── Sort_List │ └── SortList_MergeSort.cpp ├── Spiral Matrix II.cpp ├── Spiral Matrix.cpp ├── Sqrt_x.cpp ├── StringtoInteger.cpp ├── Subsets.cpp ├── SubsetsII.cpp ├── SubstringwithConcatenationofAllWords.cpp ├── Sudoku Solver.cpp ├── SumRoottoLeafNumbers.cpp ├── SurroundedRegions.cpp ├── SwapNodesinPairs.cpp ├── SymmetricTree.cpp ├── Trapping Rain Water.cpp ├── Triangle.cpp ├── Triangle_MoreSpaceCost.cpp ├── Two_Sum │ ├── TwoSum_BruteForce.cpp │ ├── TwoSum_Hash.cpp │ └── TwoSum_Sort.cpp ├── Unique Binary Search Trees II.cpp ├── UniqueBinarySearchTrees.cpp ├── UniquePaths.cpp ├── UniquePathsII.cpp ├── Valid Sudoku.cpp ├── Valid Sudoku_SolveWithBitManiputation.cpp ├── ValidNumber.cpp ├── ValidPalindrome.cpp ├── ValidParentheses.cpp ├── Valid_Number.cpp ├── Valid_Number_DFA.cpp ├── ValidateBinarySearchTree.cpp ├── Wildcard Matching.cpp ├── Wildcard_Matching.cpp ├── Word Break_1.cpp ├── WordLadder.cpp ├── WordLadderII.cpp ├── WordSearch.cpp └── ZigZagConversion.cpp ├── poj ├── poj1204.cpp ├── poj1363_stl.cpp ├── poj1363_without-stl.cpp ├── poj1625.cpp ├── poj1753.cpp ├── poj1852.cpp ├── poj2278.cpp ├── poj2386.cpp ├── poj2531.cpp ├── poj3461.cpp └── poj3691.cpp ├── spoj └── TRT.cpp ├── usaco └── chapter_1 │ ├── Broken_Necklace.cpp │ ├── Broken_Necklace_brute.cpp │ ├── Broken_Necklace_dp.cpp │ ├── Friday_the_Thirteenth.cpp │ ├── Greedy_Gift_Givers.cpp │ └── Your_Ride_Is_Here.cpp └── uva ├── uva10003_CuttingSticks.cpp ├── uva10154_WeightsandMeasures.cpp └── uva116_UnidirectionalTSP.cpp /README.md: -------------------------------------------------------------------------------- 1 | Learn Algorithm By Coding 2 | [![Total views](https://sourcegraph.com/api/repos/github.com/stackpush/LearnAlgorithmByCoding/counters/views.png)](https://sourcegraph.com/github.com/stackpush/LearnAlgorithmByCoding) 3 | ================= 4 | Solutions to Leetcode/POJ/UVA OJ/etc 5 | Some thought works in algorithm 6 | -------------------------------------------------------------------------------- /hackrank/101HackMarch15/Devu_and_Minimizing_Runs_of_a_String.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | 9 | int main() { 10 | /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 11 | int t; 12 | cin >> t; 13 | while(t--){ 14 | string str; 15 | cin >> str; 16 | int n = str.size(); 17 | vector runs; 18 | int i = 0; 19 | while(i < n){ 20 | int j = i + 1; 21 | while(j < n && str[j] == str[i]) ++j; 22 | runs.push_back(j-i); 23 | i = j; 24 | } 25 | int m = runs.size(); 26 | if(m < 3){ 27 | cout << m << endl; 28 | continue; 29 | } 30 | for(i = 1; i < m - 1; ++i){ 31 | if(runs[i] == 1) break; 32 | } 33 | if(i < m - 1){ 34 | cout << max(2 , m - 2) << endl;; 35 | continue; 36 | } 37 | if(runs[0] == 1 || runs[m-1] == 1){ 38 | cout << m - 1 << endl; 39 | continue; 40 | } 41 | cout << m << endl; 42 | } 43 | return 0; 44 | } 45 | 46 | -------------------------------------------------------------------------------- /hackrank/101HackMarch15/Magical_Girl_Devu_and_Spirits.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | 9 | int main() { 10 | /* Enter your code here. Read input from STDIN. Print output to STDOUT */ 11 | int t; 12 | cin >> t; 13 | while(t--){ 14 | int n; 15 | cin >> n; 16 | int magic = 1; 17 | long long power = 0; 18 | int ans = -1; 19 | long long min_spirit = 0; 20 | for(int i = 0; i < n; ++i){ 21 | long long spirit; 22 | cin >> spirit; 23 | if(spirit < min_spirit) min_spirit = spirit; 24 | 25 | if(spirit > 0) power += spirit; 26 | else{ 27 | if(power + spirit < 0){ 28 | if(min_spirit < spirit){ 29 | if(magic){ 30 | --magic; 31 | power = power + spirit - 2 * min_spirit; 32 | }else{ 33 | if(ans == -1) ans = i; 34 | } 35 | }else{ 36 | if(magic){ 37 | --magic; 38 | power -= spirit; 39 | }else{ 40 | if(ans == -1) ans = i; 41 | } 42 | } 43 | }else{ 44 | power += spirit; 45 | } 46 | } 47 | } 48 | if(ans != -1) cout << ans+1 << endl; 49 | else cout << "She did it!" << endl; 50 | } 51 | return 0; 52 | } 53 | 54 | 55 | -------------------------------------------------------------------------------- /hdoj/hdoj1711.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Problem: HDOJ 1711 3 | Author: 靖难 4 | Tag: KMP, string match, DFA 5 | Difficulty: 1 (from 1 to 5) 6 | */ 7 | 8 | # include 9 | # include 10 | 11 | const int NMAX = 1000000; 12 | const int MMAX = 10000; 13 | 14 | int Pattern[MMAX]; 15 | int Next[MMAX]; 16 | 17 | int Target[NMAX]; 18 | 19 | int kmp(int n, int m) 20 | { 21 | Next[0] = -1; 22 | int p = -1; 23 | for(int i = 1; i < m; ++i){ 24 | while(p != -1 && Pattern[p+1] != Pattern[i]){ 25 | p = Next[p]; 26 | } 27 | if(Pattern[p+1] == Pattern[i]){ 28 | p = p + 1; 29 | } 30 | Next[i] = p; 31 | } 32 | 33 | p = -1; 34 | for(int i = 0; i < n; ++i){ 35 | while(p != -1 && Pattern[p+1] != Target[i]){ 36 | p = Next[p]; 37 | } 38 | if(Pattern[p+1] == Target[i]){ 39 | p = p + 1; 40 | } 41 | if(p == m-1) return i - m + 2; 42 | } 43 | return -1; 44 | } 45 | 46 | int main() 47 | { 48 | int T = 0, N = 0, M = 0; 49 | scanf("%d", &T); 50 | 51 | while(T--){ 52 | scanf("%d%d", &N, &M); 53 | for(int i = 0; i < N; ++i){ 54 | scanf("%d", &Target[i]); 55 | } 56 | for(int i = 0; i < M; ++i){ 57 | scanf("%d", &Pattern[i]); 58 | } 59 | printf("%d\n", kmp(N, M)); 60 | } 61 | } 62 | -------------------------------------------------------------------------------- /hdoj/hdoj4763.cpp: -------------------------------------------------------------------------------- 1 | # include 2 | # include 3 | # include 4 | 5 | using std::vector; 6 | 7 | const int LMAX = 1000010; 8 | 9 | char song[LMAX]; 10 | int next[LMAX]; 11 | 12 | void build_next(int m) 13 | { 14 | next[0] = -1; 15 | int p = -1; 16 | for(int i = 1; i < m; ++i){ 17 | while(p != -1 && song[p+1] != song[i]){ 18 | p = next[p]; 19 | } 20 | if(song[p+1] == song[i]){ 21 | p = p + 1; 22 | } 23 | next[i] = p; 24 | printf("next[%d] = %d\n", i, next[i]); 25 | } 26 | } 27 | 28 | int solve(int m) 29 | { 30 | vector occur; 31 | vector tail; 32 | int i = 0; 33 | while(i < m){ 34 | if(next[i] == 0){ 35 | int num = 1; 36 | while(i + 1 < m && next[i + 1] == next[i]){ 37 | ++num; 38 | ++i; 39 | } 40 | occur.push_back(num); 41 | tail.push_back(i); 42 | } 43 | ++i; 44 | } 45 | if(occur.size() < 2 || tail[tail.size()-1] != m-1) return 0; 46 | int max = 0; 47 | for(int i = 0; i < occur.size()-1; ++i){ 48 | if(occur[i] > max) max = occur[i]; 49 | } 50 | if(max < occur[occur.size()-1]) return 0; 51 | return occur[occur.size()-1]; 52 | } 53 | 54 | int main() 55 | { 56 | int N; 57 | scanf("%d", &N); 58 | for(int i = 0; i < N; ++i){ 59 | scanf("%s", song); 60 | build_next(strlen(song)); 61 | printf("%d\n", solve(strlen(song))); 62 | } 63 | return 0; 64 | } -------------------------------------------------------------------------------- /leetcode/3Sum/3Sum_Sort.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > threeSum(vector &num) { 4 | vector > ans; 5 | if(num.size() < 3) return ans; 6 | sort(num.begin(), num.end()); 7 | int i = 0; 8 | while(i < num.size() - 2){ 9 | int j = i + 1; 10 | int k = num.size() - 1; 11 | while(j < k){ 12 | if(num[j] + num[k] == 0 - num[i]){ 13 | ans.push_back({num[i], num[j], num[k]}); 14 | ++j; 15 | --k; 16 | while(j < k && num[j] == num[j - 1]) ++j; 17 | while(k > j && num[k] == num[k + 1]) --k; 18 | }else if(num[j] + num[k] > 0 - num[i]){ 19 | --k; 20 | while(k > j && num[k] == num[k + 1]) --k; 21 | }else{ 22 | ++j; 23 | while(j < k && num[j] == num[j - 1]) ++j; 24 | } 25 | } 26 | ++i; 27 | while(i < num.size() - 2 && num[i] == num[i - 1]) ++i; 28 | } 29 | return ans; 30 | } 31 | }; -------------------------------------------------------------------------------- /leetcode/3Sum_Closest/3SumClosest_Sort.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int threeSumClosest(vector &num, int target) { 4 | sort(num.begin(), num.end()); 5 | int ans = num[0] + num[1] + num[2]; 6 | int diff = abs(target - ans); 7 | for(int i = 0; i < num.size() - 2; ++i){ 8 | int j = i + 1; 9 | int k = num.size() - 1; 10 | while(j < k){ 11 | int sum = num[i] + num[j] + num[k]; 12 | int cur = abs(sum - target); 13 | if(cur < diff){ 14 | ans = sum; 15 | diff = cur; 16 | } 17 | if(sum == target){ 18 | break; 19 | }else if(sum < target){ 20 | ++j; 21 | }else{ 22 | --k; 23 | } 24 | } 25 | } 26 | return ans; 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/4Sum/4Sum_Hash.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > fourSum(vector &num, int target) { 4 | vector > result; 5 | if(num.size() < 4) return result; 6 | sort(num.begin(), num.end()); 7 | unordered_map > > occur; 8 | int i = 0; 9 | while(i < num.size() - 1){ 10 | int j = i + 1; 11 | while(j < num.size()){ 12 | occur[num[i] + num[j]].push_back(pair(i, j)); 13 | ++j; 14 | } 15 | ++i; 16 | } 17 | i = 0; 18 | while(i < num.size() - 1){ 19 | int j = i + 1; 20 | while(j < num.size()){ 21 | int sum = target - num[i] - num[j]; 22 | if(occur.find(sum) != occur.end()){ 23 | for(int k = 0; k < occur[sum].size(); ++k){ 24 | int x = occur[sum][k].first; 25 | int y = occur[sum][k].second; 26 | if(x <= j) continue; 27 | result.push_back({num[i], num[j], num[x], num[y]}); 28 | } 29 | } 30 | ++j; 31 | } 32 | ++i; 33 | } 34 | sort(result.begin(), result.end()); 35 | result.erase(unique(result.begin(), result.end()), result.end()); 36 | return result; 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /leetcode/4Sum/4Sum_Sort.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > fourSum(vector &num, int target) { 4 | vector > ans; 5 | if(num.size() < 4) return ans; 6 | sort(num.begin(), num.end()); 7 | int i = 0; 8 | while(i < num.size() - 3){ 9 | int j = i + 1; 10 | while(j < num.size() - 2){ 11 | int p = j + 1; 12 | int q = num.size() - 1; 13 | while(p < q){ 14 | int sum = num[i] + num[j] + num[p] + num[q]; 15 | if(sum == target){ 16 | ans.push_back({num[i], num[j], num[p], num[q]}); 17 | ++p; 18 | --q; 19 | while(p < q && num[p] == num[p - 1]) ++p; 20 | while(p < q && num[q] == num[q + 1]) --q; 21 | }else if(sum < target){ 22 | ++p; 23 | while(p < q && num[p] == num[p - 1]) ++p; 24 | }else{ 25 | --q; 26 | while(p < q && num[q] == num[q + 1]) --q; 27 | } 28 | } 29 | ++j; 30 | while(j < num.size() - 2 && num[j] == num[j - 1]) ++j; 31 | } 32 | ++i; 33 | while(i < num.size() - 3 && num[i] == num[i - 1]) ++i; 34 | } 35 | return ans; 36 | } 37 | }; -------------------------------------------------------------------------------- /leetcode/AddBinary.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string addBinary(string a, string b) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int aLen = a.size(); 6 | int bLen = b.size(); 7 | int cLen = aLen>bLen?aLen:bLen; 8 | string result( cLen, '0' ); 9 | reverse( a.begin(), a.end() ); 10 | reverse( b.begin(), b.end() ); 11 | for( int i = aLen+1; i <= cLen; ++i ){ 12 | a += '0'; 13 | } 14 | for( int i = bLen+1; i <= cLen; ++i ){ 15 | b += '0'; 16 | } 17 | int v = 0; 18 | for( int i = 0; i != cLen; ++i ){ 19 | result[i] = '0' + a[i]-'0' + b[i] - '0' + v; 20 | v = (result[i]-'0')/2; 21 | result[i] = '0' + (result[i]-'0')%2; 22 | } 23 | if( v > 0 ){ 24 | result += ( '0'+v ); 25 | ++cLen; 26 | } 27 | reverse( result.begin(), result.end() ); 28 | return result; 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/Anagrams/Anagrams.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector anagrams(vector& strs) { 4 | unordered_map< string, vector > hash; 5 | for(int i = 0; i < strs.size(); ++i){ 6 | string tmp = strs[i]; 7 | sort(tmp.begin(), tmp.end()); 8 | hash[tmp].push_back(i); 9 | } 10 | vector ret; 11 | for(auto it = hash.begin(); it != hash.end(); ++it){ 12 | if(it->second.size() <= 1) continue; 13 | for(int i = 0; i < it->second.size(); ++i){ 14 | ret.push_back(strs[it->second[i]]); 15 | } 16 | } 17 | return ret; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /leetcode/Balanced_Binary_Tree/BalancedBinaryTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int dfs(TreeNode* root, bool& balanced){ 13 | if(root == NULL) return 0; 14 | if(!root->left && !root->right) return 1; 15 | bool lbalanced = true; 16 | bool rbalanced = true; 17 | int ldepth = dfs(root->left, lbalanced); 18 | int rdepth = dfs(root->right, rbalanced); 19 | balanced = lbalanced && rbalanced; 20 | if(abs(ldepth - rdepth) > 1) balanced = false; 21 | return max(ldepth, rdepth) + 1; 22 | } 23 | bool isBalanced(TreeNode *root) { 24 | bool ans = true; 25 | dfs(root, ans); 26 | return ans; 27 | } 28 | }; 29 | -------------------------------------------------------------------------------- /leetcode/Best_Time_to_Buy_and_Sell_Stock/Best Time to Buy and Sell Stock.cpp: -------------------------------------------------------------------------------- 1 | // dp 2 | class Solution { 3 | public: 4 | int maxProfit(vector &prices) { 5 | int n = prices.size(); 6 | if(n <= 1) return 0; 7 | 8 | int ans = 0; 9 | int min_price = prices[0]; 10 | for(int i = 0; i < n; ++i){ 11 | ans = max(ans, prices[i] - min_price); 12 | if(prices[i] < min_price) min_price = prices[i]; 13 | } 14 | return ans; 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /leetcode/Best_Time_to_Buy_and_Sell_Stock_II/BestTimetoBuyandSellStockII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector &prices) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int n = prices.size(); 7 | if( n <= 1 ) return 0; 8 | int profit = 0; 9 | for( int i = 1; i < n; ++i ){ 10 | if( prices[i]-prices[i-1] >0 ){ 11 | profit += (prices[i]-prices[i-1]); 12 | } 13 | } 14 | return profit; 15 | } 16 | 17 | }; -------------------------------------------------------------------------------- /leetcode/Best_Time_to_Buy_and_Sell_Stock_III/Best Time to Buy and Sell Stock III.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxProfit(vector &prices) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int n = prices.size(); 7 | if( n <= 1 ) return 0; 8 | vector profit( n, 0 ); 9 | int min = 0, maxProfit = 0; 10 | for( int i = 0; i < n; ++i ){ 11 | if( prices[i] < prices[min] ){ 12 | min = i; 13 | } 14 | if( prices[i]-prices[min] > maxProfit ){ 15 | maxProfit = prices[i]-prices[min]; 16 | } 17 | profit[i] = maxProfit; 18 | } 19 | int max = n-1; 20 | maxProfit = 0; 21 | int totalMax = 0; 22 | for( int i = n-1; i >= 0; --i ){ 23 | if( prices[i] > prices[max] ){ 24 | max = i; 25 | } 26 | if( prices[max]-prices[i] > maxProfit ){ 27 | maxProfit = prices[max]-prices[i]; 28 | } 29 | if( profit[i] + maxProfit > totalMax ){ 30 | totalMax = profit[i] + maxProfit; 31 | } 32 | } 33 | return totalMax; 34 | } 35 | }; -------------------------------------------------------------------------------- /leetcode/Binary_Search_Tree_Iterator/BinarySearchTreeIterator.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class BSTIterator { 11 | public: 12 | stack s; 13 | TreeNode* current; 14 | 15 | BSTIterator(TreeNode *root) { 16 | current = root; 17 | } 18 | 19 | void traverse(TreeNode* root){ 20 | } 21 | 22 | /** @return whether we have a next smallest number */ 23 | bool hasNext() { 24 | return !s.empty() || current; 25 | } 26 | 27 | /** @return the next smallest number */ 28 | int next() { 29 | while(!s.empty() || current){ 30 | if(current){ 31 | s.push(current); 32 | current = current->left; 33 | }else{ 34 | current = s.top()->right; 35 | break; 36 | } 37 | } 38 | TreeNode* ret = s.top(); 39 | s.pop(); 40 | return ret->val; 41 | } 42 | }; 43 | 44 | /** 45 | * Your BSTIterator will be called like this: 46 | * BSTIterator i = BSTIterator(root); 47 | * while (i.hasNext()) cout << i.next(); 48 | */ 49 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Inorder_Traversal/BinaryTreeInorderTraversal_recursion.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void inorderTraversal(TreeNode *root, vector &ans){ 13 | if(root == NULL) return; 14 | inorderTraversal(root->left, ans); 15 | ans.push_back(root->val); 16 | inorderTraversal(root->right, ans); 17 | } 18 | vector inorderTraversal(TreeNode *root) { 19 | vector ans; 20 | inorderTraversal(root, ans); 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Inorder_Traversal/BinaryTreeInorderTraversal_stack-1.cpp: -------------------------------------------------------------------------------- 1 | // The solution will change the binary tree 2 | /** 3 | * Definition for binary tree 4 | * struct TreeNode { 5 | * int val; 6 | * TreeNode *left; 7 | * TreeNode *right; 8 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | vector inorderTraversal(TreeNode *root) { 14 | vector ans; 15 | if(root == NULL) return ans; 16 | stack stk; 17 | stk.push(root); 18 | while(!stk.empty()){ 19 | TreeNode* cur = stk.top(); 20 | if(!cur->left){ 21 | ans.push_back(cur->val); 22 | stk.pop(); 23 | if(cur->right){ 24 | stk.push(cur->right); 25 | cur->right = NULL; 26 | } 27 | }else{ 28 | stk.push(cur->left); 29 | cur->left = NULL; 30 | } 31 | } 32 | return ans; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Inorder_Traversal/BinaryTreeInorderTraversal_stack-2.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector inorderTraversal(TreeNode *root) { 13 | vector ans; 14 | if(root == NULL) return ans; 15 | 16 | stack stk; 17 | 18 | TreeNode *cur = root; 19 | while(!stk.empty() || cur != NULL){ 20 | while(cur){ 21 | stk.push(cur); 22 | cur = cur->left; 23 | } 24 | TreeNode *p = stk.top(); stk.pop(); 25 | ans.push_back(p->val); 26 | cur = p->right; 27 | } 28 | return ans; 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Level_Order_Traversal/BinaryTreeLevelOrderTraversal_one-queue.cpp: -------------------------------------------------------------------------------- 1 | // Pay attention to the last NULL 2 | /** 3 | * Definition for binary tree 4 | * struct TreeNode { 5 | * int val; 6 | * TreeNode *left; 7 | * TreeNode *right; 8 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | vector > levelOrder(TreeNode *root) { 14 | vector< vector > ans; 15 | 16 | if(root == NULL) return ans; 17 | 18 | queue Q; 19 | vector data; 20 | 21 | Q.push(root); 22 | Q.push(NULL); 23 | while(!Q.empty()){ 24 | TreeNode* cur = Q.front(); 25 | Q.pop(); 26 | if(cur == NULL){ 27 | ans.push_back(data); 28 | data.clear(); 29 | if(Q.empty()) { 30 | break; 31 | }else{ 32 | Q.push(NULL); 33 | continue; 34 | } 35 | } 36 | data.push_back(cur->val); 37 | if(cur->left) Q.push(cur->left); 38 | if(cur->right) Q.push(cur->right); 39 | } 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Level_Order_Traversal/BinaryTreeLevelOrderTraversal_recursion.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void dfs(TreeNode *root, int level, vector< vector > &ans){ 13 | if(root == NULL) return; 14 | if(ans.size() <= level){ 15 | ans.push_back(vector()); 16 | } 17 | ans[level].push_back(root->val); 18 | dfs(root->left, level+1, ans); 19 | dfs(root->right, level+1, ans); 20 | } 21 | 22 | vector > levelOrderBottom(TreeNode *root) { 23 | vector< vector > ans; 24 | dfs(root, 0, ans); 25 | return ans; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Level_Order_Traversal/BinaryTreeLevelOrderTraversal_two-vector.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector > levelOrder(TreeNode *root) { 13 | vector< vector > ans; 14 | 15 | if(root == NULL) return ans; 16 | 17 | vector cur; 18 | vector data; 19 | 20 | cur.push_back(root); 21 | data.push_back(root->val); 22 | 23 | while(cur.size() != 0){ 24 | 25 | vector pre = cur; 26 | ans.push_back(data); 27 | cur.clear(); 28 | data.clear(); 29 | for(int i = 0; i < pre.size(); ++i){ 30 | if(pre[i]->left) { 31 | cur.push_back(pre[i]->left); 32 | data.push_back(pre[i]->left->val); 33 | } 34 | if(pre[i]->right) { 35 | cur.push_back(pre[i]->right); 36 | data.push_back(pre[i]->right->val); 37 | } 38 | } 39 | } 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Level_Order_Traversal_II/BinaryTreeLevelOrderTraversalII.cpp: -------------------------------------------------------------------------------- 1 | // Pay attention to the last NULL 2 | /** 3 | * Definition for binary tree 4 | * struct TreeNode { 5 | * int val; 6 | * TreeNode *left; 7 | * TreeNode *right; 8 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | vector > levelOrder(TreeNode *root) { 14 | vector< vector > ans; 15 | 16 | if(root == NULL) return ans; 17 | 18 | queue Q; 19 | vector data; 20 | 21 | Q.push(root); 22 | Q.push(NULL); 23 | while(!Q.empty()){ 24 | TreeNode* cur = Q.front(); 25 | Q.pop(); 26 | if(cur == NULL){ 27 | ans.push_back(data); 28 | data.clear(); 29 | if(Q.empty()) { 30 | break; 31 | }else{ 32 | Q.push(NULL); 33 | continue; 34 | } 35 | } 36 | data.push_back(cur->val); 37 | if(cur->left) Q.push(cur->left); 38 | if(cur->right) Q.push(cur->right); 39 | } 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Maximum_Path_Sum/BinaryTreeMaximumPathSum.cpp: -------------------------------------------------------------------------------- 1 | // Maximum Subarray + DFS 2 | // The solution is similar to solve Maximum Subarry with Divide and Conquer strategy 3 | /** 4 | * Definition for binary tree 5 | * struct TreeNode { 6 | * int val; 7 | * TreeNode *left; 8 | * TreeNode *right; 9 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 10 | * }; 11 | */ 12 | class Solution { 13 | public: 14 | int dfs(TreeNode *root, int& maxSum){ 15 | if(root == NULL){ 16 | return 0; 17 | } 18 | int lsum = dfs(root->left, maxSum); 19 | int rsum = dfs(root->right, maxSum); 20 | int ret = max(root->val, max(lsum, rsum) + root->val); 21 | if(maxSum < ret) maxSum = ret; 22 | if(maxSum < lsum + rsum + root->val) maxSum = lsum + rsum + root->val; 23 | return ret; 24 | } 25 | 26 | int maxPathSum(TreeNode *root) { 27 | int ans = INT_MIN; 28 | dfs(root, ans); 29 | return ans; 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Postorder_Traversal/BinaryTreePostorderTraversal_recursion.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void postorderTraversal(TreeNode* root, vector &ans){ 13 | if(root == NULL) return; 14 | postorderTraversal(root->left, ans); 15 | postorderTraversal(root->right, ans); 16 | ans.push_back(root->val); 17 | } 18 | vector postorderTraversal(TreeNode *root) { 19 | vector ans; 20 | postorderTraversal(root, ans); 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Postorder_Traversal/BinaryTreePostorderTraversal_use-stack.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector postorderTraversal(TreeNode *root) { 13 | vector ans; 14 | if(root == NULL) return ans; 15 | 16 | stack stk; 17 | stk.push(root); 18 | 19 | TreeNode* last = NULL; 20 | while(!stk.empty()){ 21 | TreeNode* cur = stk.top(); 22 | if((!cur->left && !cur->right) // 叶子节点 23 | || (!cur->right && cur->left && cur->left == last) // 无右子节点，刚访问过左子节点 24 | || (cur->right && cur->right == last) // 有右子节点，且刚访问过 25 | ){ 26 | last = cur; 27 | ans.push_back(cur->val); 28 | stk.pop(); 29 | }else if((cur->left && cur->left != last // 有左子结点且左子结点没有被刚访问过 30 | && (!cur->right || cur->right != last)) // 无右子节点或右子节点没有被刚访问过 31 | ){ 32 | stk.push(cur->left); 33 | }else if((cur->right && cur->right != last) // 有右子节点，且没有被刚访问过 34 | && (!cur->left || cur->left == last) // 无左子结点或左子结点刚被访问过 35 | ){ 36 | stk.push(cur->right); 37 | } 38 | } 39 | return ans; 40 | } 41 | }; 42 | 43 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Postorder_Traversal/ReadMe.md: -------------------------------------------------------------------------------- 1 | In postorder, the root node will be visited at the end. 2 | 3 | So, for a node Cur, if it is not a leaf node, the previously visited node should be its left child or right child. For such reason, we can determin next step by comparing the last visited node to current node's sons. 4 | 5 | When the current node is a leaf node, we just visit it and pop it from the stack. 6 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Preorder_Traversal/BinaryTreePreorderTraversal_recursion.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void preorderTraversal(TreeNode* root, vector &ans){ 13 | if(root == NULL) return; 14 | ans.push_back(root->val); 15 | preorderTraversal(root->left, ans); 16 | preorderTraversal(root->right, ans); 17 | } 18 | vector preorderTraversal(TreeNode *root) { 19 | vector ans; 20 | preorderTraversal(root, ans); 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Preorder_Traversal/BinaryTreePreorderTraversal_use-stack.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector preorderTraversal(TreeNode *root) { 13 | vector ans; 14 | if(root == NULL) return ans; 15 | stack stk; 16 | stk.push(root); 17 | while(!stk.empty()){ 18 | TreeNode *cur = stk.top(); 19 | stk.pop(); 20 | ans.push_back(cur->val); 21 | if(cur->right) stk.push(cur->right); 22 | if(cur->left) stk.push(cur->left); 23 | } 24 | return ans; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Right_Side_View/BinaryTreeRightSideView.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector rightSideView(TreeNode *root) { 13 | vector ans; 14 | if(root == NULL) return ans; 15 | 16 | vector pre, cur; 17 | cur.push_back(root); 18 | while(cur.size() != 0){ 19 | pre = cur; 20 | cur.clear(); 21 | for(int i = 0; i < pre.size(); ++i){ 22 | if(pre[i]->left) cur.push_back(pre[i]->left); 23 | if(pre[i]->right) cur.push_back(pre[i]->right); 24 | } 25 | ans.push_back(pre.back()->val); 26 | } 27 | return ans; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Right_Side_View/BinaryTreeRightSideView_2.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector rightSideView(TreeNode *root) { 13 | vector ans; 14 | if(root == NULL) return ans; 15 | 16 | queue q; 17 | q.push(root); 18 | q.push(NULL); 19 | TreeNode* pre = root; 20 | while(q.size() != 0){ 21 | TreeNode* cur = q.front(); 22 | q.pop(); 23 | if(cur == NULL){ 24 | ans.push_back(pre->val); 25 | if(!q.empty()) q.push(NULL); 26 | }else{ 27 | if(cur->left) q.push(cur->left); 28 | if(cur->right) q.push(cur->right); 29 | pre = cur; 30 | } 31 | } 32 | return ans; 33 | } 34 | }; 35 | -------------------------------------------------------------------------------- /leetcode/Binary_Tree_Zigzag_Level_Order_Traversal/BinaryTreeZigzagLevelOrderTraversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector > zigzagLevelOrder(TreeNode *root) { 13 | vector > ans; 14 | if(root == NULL) return ans; 15 | vector data; 16 | vector cur; 17 | cur.push_back(root); 18 | bool need_reverse = false; 19 | while(cur.size() != 0){ 20 | vector pre = cur; 21 | cur.clear(); 22 | for(int i = pre.size() - 1; i >= 0; --i){ 23 | data.push_back(pre[i]->val); 24 | if(need_reverse){ 25 | if(pre[i]->right) cur.push_back(pre[i]->right); 26 | if(pre[i]->left) cur.push_back(pre[i]->left); 27 | }else{ 28 | if(pre[i]->left) cur.push_back(pre[i]->left); 29 | if(pre[i]->right) cur.push_back(pre[i]->right); 30 | } 31 | 32 | } 33 | need_reverse = !need_reverse; 34 | ans.push_back(data); 35 | data.clear(); 36 | } 37 | return ans; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /leetcode/Candy.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int candy(vector &ratings) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = ratings.size(); 6 | vector candy( n, 1 ); 7 | for( int i = 1; i < n; ++i ){ 8 | if( ratings[i]>ratings[i-1] ){ 9 | candy[i] = max( candy[i-1]+1, candy[i] ); 10 | } 11 | } 12 | for( int i = n-2; i >=0; --i ){ 13 | if( ratings[i]>ratings[i+1] ){ 14 | candy[i] = max(candy[i], candy[i+1]+1); 15 | } 16 | } 17 | int total = 0; 18 | for( int i = 0; i < n; ++i ) total += candy[i]; 19 | return total; 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/ClimbingStairs.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int climbStairs(int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( n==0 || n==1 ) return 1; 6 | int a = 0, b = 1; 7 | for( int i = 0; i < n ; ++i ){ 8 | b = a + b; 9 | a = b - a; 10 | } 11 | return b; 12 | } 13 | }; -------------------------------------------------------------------------------- /leetcode/Clone_Graph/CloneGraph_BFS.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for undirected graph. 3 | * struct UndirectedGraphNode { 4 | * int label; 5 | * vector neighbors; 6 | * UndirectedGraphNode(int x) : label(x) {}; 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( node==NULL ) return NULL; 14 | UndirectedGraphNode *root = new UndirectedGraphNode( node->label ); 15 | unordered_map< UndirectedGraphNode *, UndirectedGraphNode * > occur; 16 | occur[node] = root; 17 | queue Q; 18 | Q.push(node); 19 | while( !Q.empty() ){ 20 | UndirectedGraphNode *cur = Q.front(); 21 | Q.pop(); 22 | for( int i = 0; i < cur->neighbors.size(); ++i ){ 23 | if( occur.find(cur->neighbors[i]) == occur.end() ){ 24 | UndirectedGraphNode *newNode = new UndirectedGraphNode( cur->neighbors[i]->label ); 25 | occur[ cur->neighbors[i] ] = newNode; 26 | occur[cur]->neighbors.push_back(newNode); 27 | Q.push( cur->neighbors[i] ); 28 | }else{ 29 | occur[cur]->neighbors.push_back( occur[cur->neighbors[i]] ); 30 | } 31 | } 32 | 33 | } 34 | return root; 35 | } 36 | }; -------------------------------------------------------------------------------- /leetcode/Clone_Graph/CloneGraph_DFS.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for undirected graph. 3 | * struct UndirectedGraphNode { 4 | * int label; 5 | * vector neighbors; 6 | * UndirectedGraphNode(int x) : label(x) {}; 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | unordered_map occur; 12 | UndirectedGraphNode *cloneGraph(UndirectedGraphNode *node) { 13 | if(node == NULL) return NULL; 14 | if(occur.find(node->label) != occur.end()){ 15 | return occur[node->label]; 16 | } 17 | UndirectedGraphNode* g = new UndirectedGraphNode(node->label); 18 | occur[node->label] = g; 19 | for(int i = 0; i < node->neighbors.size(); ++i){ 20 | UndirectedGraphNode* nb = cloneGraph(node->neighbors[i]); 21 | g->neighbors.push_back(nb); 22 | } 23 | return g; 24 | } 25 | }; -------------------------------------------------------------------------------- /leetcode/Combination Sum II.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combinationSum2(vector &num, int target) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector cur_ans; 6 | vector< vector > result; 7 | set< vector > visited; 8 | sort( num.begin(), num.end() ); 9 | dfs( target, 0, visited,cur_ans, result, num ); 10 | return result; 11 | } 12 | void dfs( int target, int choose, set< vector > &visited, vector& cur_ans, vector< vector >&result, vector &num ){ 13 | if( target==0 ){ 14 | if( visited.find(cur_ans)!=visited.end() ) return; 15 | visited.insert(cur_ans); 16 | result.push_back(cur_ans); 17 | return; 18 | } 19 | if( target < 0 ){ 20 | return; 21 | } 22 | for( int i = choose; i < num.size(); ++i ){ 23 | if( target-num[i] >= 0 ){ 24 | cur_ans.push_back(num[i]); 25 | dfs( target-num[i], i+1, visited, cur_ans, result, num ); 26 | cur_ans.pop_back(); 27 | } 28 | } 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/Combination Sum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combinationSum(vector &candidates, int target) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector cur_ans; 6 | vector< vector > result; 7 | sort( candidates.begin(), candidates.end() ); 8 | dfs( target, 0, cur_ans, result, candidates ); 9 | return result; 10 | } 11 | 12 | void dfs( int cur, int choose, vector&cur_ans, vector< vector >& result, vector &candidates){ 13 | if( cur==0 ) { 14 | result.push_back( cur_ans ); 15 | return; 16 | } 17 | if( cur < 0 ) return; 18 | if( cur - candidates[choose] >= 0 ) { 19 | cur_ans.push_back( candidates[choose] ); 20 | dfs( cur - candidates[choose], choose, cur_ans, result, candidates ); 21 | cur_ans.pop_back(); 22 | } 23 | for( int i = choose+1; i < candidates.size(); ++i ){ 24 | cur_ans.push_back( candidates[i] ); 25 | dfs( cur-candidates[i], i, cur_ans, result, candidates ); 26 | cur_ans.pop_back(); 27 | } 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/Combinations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > combine(int n, int k) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector< vector > result; 6 | vector ans; 7 | dfs( result, ans, n, k, 1); 8 | return result; 9 | } 10 | void dfs( vector< vector > &result, vector&ans ,int n, int k, int choose ){ 11 | if( ans.size() >= k ){ 12 | result.push_back(ans); 13 | return; 14 | } 15 | for( int i = choose; i <= n; ++i ){ 16 | if( ans.size()==0 || i > ans[ ans.size()-1 ] ){ 17 | ans.push_back(i); 18 | dfs( result, ans, n, k, choose+1 ); 19 | ans.pop_back(); 20 | } 21 | } 22 | } 23 | }; -------------------------------------------------------------------------------- /leetcode/Compare_Version_Numbers/Compare_Version_Numbers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static vector version2vec(string &version){ 4 | vector vec; 5 | int cur = 0; 6 | bool flag = false; 7 | for(int i = 0; i < version.size(); ++i){ 8 | if(version[i] != '.'){ 9 | flag = true; 10 | cur = cur * 10 + version[i] - '0'; 11 | }else{ 12 | if(flag) vec.push_back(cur); 13 | cur = 0; 14 | } 15 | } 16 | if(flag) vec.push_back(cur); 17 | return vec; 18 | } 19 | 20 | static int compareVersion(string version1, string version2) { 21 | vector v1 = version2vec(version1); 22 | vector v2 = version2vec(version2); 23 | int diff = v1.size() - v2.size(); 24 | vector* v = NULL; 25 | if(diff > 0) v = &v2; 26 | else v = &v1; 27 | for(int i = 0; i < abs(diff); ++i) v->push_back(0); 28 | for(int i = 0; i < v1.size(); ++i){ 29 | if(v1[i] > v2[i]){ 30 | return 1; 31 | }else if(v1[i] < v2[i]){ 32 | return -1; 33 | } 34 | } 35 | return 0; 36 | } 37 | }; -------------------------------------------------------------------------------- /leetcode/Compare_Version_Numbers/Compare_Version_Numbers.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | # @param version1, a string 3 | # @param version2, a string 4 | # @return an integer 5 | def compareVersion(self, version1, version2): 6 | version1 = [int(item) for item in version1.split('.')] 7 | version2 = [int(item) for item in version2.split('.')] 8 | diff = len(version1) - len(version2) 9 | if diff > 0: 10 | for i in range(diff): 11 | version2.append(0) 12 | else: 13 | for i in range(abs(diff)): 14 | version1.append(0) 15 | 16 | if version1 > version2: 17 | return 1 18 | elif version1 < version2: 19 | return -1 20 | else: 21 | return 0 -------------------------------------------------------------------------------- /leetcode/Construct_BinaryTree_from_Inorder_and_Postorder_Traversal/ConstructBinaryTreefromInorderandPostorderTraversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *buildTree(vector &inorder, vector &postorder, int l1, int r1, int l2, int r2){ 13 | if(l1 > r1 || l2 > r2 ) return NULL; 14 | int x = postorder[r2]; 15 | int i = l1; 16 | for(; i <= r1; ++i){ 17 | if(inorder[i] == x) break; 18 | } 19 | TreeNode *root = new TreeNode(x); 20 | root->left = buildTree(inorder, postorder, l1, i-1, l2, l2 + i - 1 - l1); 21 | root->right = buildTree(inorder, postorder, i + 1, r1, l2 + i - l1, r2 - 1); 22 | return root; 23 | } 24 | 25 | TreeNode *buildTree(vector &inorder, vector &postorder) { 26 | int n = inorder.size(); 27 | int m = postorder.size(); 28 | if(n == 0 || m == 0 || n != m) return NULL; 29 | return buildTree(inorder, postorder, 0, n - 1, 0, m-1); 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /leetcode/Construct_BinaryTree_from_Preorder_and_Inorder_Traversal/ConstructBinaryTreefromPreorderandInorderTraversal.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *buildTree(vector &preorder, vector &inorder, int l1, int r1, int l2, int r2){ 13 | if(l1 > r1 || l2 > r2) return NULL; 14 | int x = preorder[l1]; 15 | int i = l2; 16 | for(; i <= r2; ++i){ 17 | if(inorder[i] == x){ 18 | break; 19 | } 20 | } 21 | TreeNode *root = new TreeNode(x); 22 | root->left = buildTree(preorder, inorder, l1 + 1, l1 + i - l2, l2, i - 1); 23 | root->right = buildTree(preorder, inorder, l1 + i - l2 + 1, r1, i + 1, r2); 24 | return root; 25 | } 26 | 27 | TreeNode *buildTree(vector &preorder, vector &inorder) { 28 | int n = preorder.size(); 29 | int m = inorder.size(); 30 | if(n == 0 || m == 0 || n != m) return NULL; 31 | return buildTree(preorder, inorder, 0, n - 1, 0, m - 1); 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /leetcode/ContainerWithMostWater.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxArea(vector &height) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = height.size(); 6 | int result = 0; 7 | for( int i = 0; i < n; ++i ){ 8 | if( height[i]==0 ) continue; 9 | for( int j = n-1; j >= i+1; --j ){ 10 | if( j < i+result/height[i] ) break; 11 | int area = min( height[i], height[j] )*(j-i); 12 | if( area > result ){ 13 | result = area; 14 | } 15 | } 16 | } 17 | return result; 18 | } 19 | }; -------------------------------------------------------------------------------- /leetcode/ContainerWithMostWater_Linear.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maxArea(vector &height) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = height.size(); 6 | int result = 0; 7 | int i = 0, j = n-1; 8 | while( i result ) result = area; 18 | } 19 | return result; 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/Convert Sorted Array to Binary Search Tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | TreeNode *sortedArrayToBST(vector &num) { 13 | // Note: The Solution object is instantiated only once and is reused by each test case. 14 | int n = num.size(); 15 | if( n==0 ) return NULL; 16 | return buildTree( num, 0, n-1 ); 17 | } 18 | TreeNode *buildTree( vector &num, int left, int right ){ 19 | int mid = (left + right)/2; 20 | TreeNode* root = new TreeNode( num [mid] ); 21 | if( mid-1 >= left ){ 22 | root->left = buildTree( num, left, mid-1 ); 23 | } 24 | if( mid+1 <= right ){ 25 | root->right = buildTree( num, mid+1, right ); 26 | } 27 | return root; 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/Convert Sorted List to Binary Search Tree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | /** 10 | * Definition for binary tree 11 | * struct TreeNode { 12 | * int val; 13 | * TreeNode *left; 14 | * TreeNode *right; 15 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 16 | * }; 17 | */ 18 | class Solution { 19 | public: 20 | TreeNode *sortedListToBST(ListNode *head) { 21 | // IMPORTANT: Please reset any member data you declared, as 22 | // the same Solution instance will be reused for each test case. 23 | if( head==NULL ) return NULL; 24 | ListNode* slow = head; 25 | ListNode* fast = head; 26 | ListNode* tail = slow; 27 | while( fast->next ){ 28 | tail = slow; 29 | slow = slow->next; 30 | fast = fast->next; 31 | if( fast->next ) fast = fast->next; 32 | } 33 | tail->next = NULL; 34 | TreeNode* root = new TreeNode(slow->val); 35 | ListNode* cur = slow->next; 36 | if( head != slow ) 37 | root->left = sortedListToBST( head ); 38 | root->right = sortedListToBST( cur ); 39 | return root; 40 | } 41 | }; -------------------------------------------------------------------------------- /leetcode/CopyListwithRandomPointer.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list with a random pointer. 3 | * struct RandomListNode { 4 | * int label; 5 | * RandomListNode *next, *random; 6 | * RandomListNode(int x) : label(x), next(NULL), random(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | RandomListNode *copyRandomList(RandomListNode *head) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( head==NULL ) return NULL; 14 | RandomListNode* newHead = NULL; 15 | unordered_map< RandomListNode*, RandomListNode* > occur; 16 | dfs( newHead, head, occur ); 17 | return newHead; 18 | } 19 | void dfs( RandomListNode*&cur, RandomListNode* node, unordered_map& occur ){ 20 | if( node==NULL ) return; 21 | cur = new RandomListNode( node->label ); 22 | if( occur.find(node) == occur.end() ){ 23 | occur[node] = cur; 24 | } 25 | if( node->next ){ 26 | if( occur.find(node->next)==occur.end() ){ 27 | dfs( cur->next, node->next, occur ); 28 | }else{ 29 | cur->next = occur[node->next]; 30 | } 31 | } 32 | if( node->random ){ 33 | if( occur.find(node->random)==occur.end() ){ 34 | dfs( cur->random, node->random, occur ); 35 | }else{ 36 | cur->random = occur[node->random]; 37 | } 38 | } 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/Count and Say.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string countAndSay(int n) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | string pre("1"); 7 | string cur("1"); 8 | for( int i = 1; i < n; ++i ){ 9 | pre = cur; 10 | cur.clear(); 11 | int len = pre.size(); 12 | int num = 0; 13 | int j = 0; 14 | while( j < len ){ 15 | do{ 16 | ++num; 17 | ++j; 18 | }while( pre[j]==pre[j-1] ); 19 | cur += num + '0'; 20 | cur += pre[j-1]; 21 | num = 0; 22 | } 23 | } 24 | return cur; 25 | } 26 | }; -------------------------------------------------------------------------------- /leetcode/Count_Primes/CountPrimes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | 4 | int countPrimes(int n) { 5 | vector h(n, true); 6 | int ans = 0; 7 | int upper = sqrt(n); 8 | for(int i = 2; i < n; ++i){ 9 | if(!h[i]) continue; 10 | if(h[i]) ++ans; 11 | if(i > upper) continue; 12 | for(int j = i * i; j < n; j += i){ 13 | // (2 to i - 1) * i should be processed before 14 | h[j] = false; 15 | } 16 | } 17 | return ans; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /leetcode/Distinct Subsequences.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numDistinct(string S, string T) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int n = S.size(); 7 | int m = T.size(); 8 | if( n==0 ) return 0; 9 | if( m==0 ) return 1; 10 | vector< vector > dp( n+1, vector(m+1, 0) ); 11 | for( int i = 0; i <= n; ++i ){ 12 | dp[i][m] = 1; 13 | } 14 | for( int i = n-1; i >= 0; --i ){ 15 | for( int j = m-1; j >= 0; --j ){ 16 | if( S[i]==T[j] ){ 17 | dp[i][j] = dp[i+1][j] + dp[i+1][j+1]; 18 | }else{ 19 | dp[i][j] = dp[i+1][j]; 20 | } 21 | } 22 | } 23 | return dp[0][0]; 24 | } 25 | }; -------------------------------------------------------------------------------- /leetcode/Divide_Two_Integers/DivideTwoIntegers.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int divide(int dividend, int divisor) { 4 | if (divisor == 0 || (dividend == INT_MIN && divisor == -1)) return INT_MAX; 5 | if(dividend == 0) return 0; 6 | if(divisor == 1) return dividend; 7 | if(divisor == -1) return -dividend; 8 | if(divisor == dividend) return 1; 9 | if(divisor == INT_MIN) return 0; 10 | 11 | int sig = (dividend >= 0) ^ (divisor >= 0); 12 | 13 | long divisor_l = divisor; 14 | long dividend_l = dividend; 15 | if(divisor_l < 0) divisor_l = -divisor_l; 16 | if(dividend_l < 0) dividend_l = -dividend_l; 17 | 18 | int ans = 0; 19 | while(divisor_l <= dividend_l){ 20 | int p = 1; 21 | long t_divisor = divisor_l; 22 | while(dividend_l>>1 >= t_divisor){ 23 | p <<= 1; 24 | t_divisor <<= 1; 25 | } 26 | ans += p; 27 | dividend_l -= t_divisor; 28 | } 29 | return sig == 0 ? ans : -ans; 30 | } 31 | }; 32 | -------------------------------------------------------------------------------- /leetcode/Edit_Distance/EditDistance.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minDistance(string word1, string word2) { 4 | int n = word1.size(); 5 | int m = word2.size(); 6 | if(n == 0) return m; 7 | if(m == 0) return n; 8 | vector< vector > dp(n + 1, vector(m + 1, 0)); 9 | for(int i = 0; i <= n; ++i){ 10 | dp[i][0] = i; 11 | } 12 | for(int j = 0; j <= m; ++j){ 13 | dp[0][j] = j; 14 | } 15 | 16 | for(int i = 1; i <= n; ++i){ 17 | for(int j = 1; j <= m; ++j){ 18 | if(word1[i-1] == word2[j-1]){ 19 | dp[i][j] = min(min(dp[i-1][j-1], dp[i-1][j] + 1), dp[i][j-1] + 1); 20 | }else{ 21 | dp[i][j] = min(min(dp[i-1][j-1] + 1, dp[i-1][j] + 1), dp[i][j-1] + 1); 22 | } 23 | } 24 | } 25 | return dp[n][m]; 26 | } 27 | }; 28 | -------------------------------------------------------------------------------- /leetcode/Excel_Sheet_Column_Number/ExcelSheetColumnNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int titleToNumber(string s) { 4 | int n = s.size(); 5 | if(n == 0) return 0; 6 | int ans = 0; 7 | for(int i = 0; i < n; ++i){ 8 | ans = ans * 26 + s[i] - 'A' + 1; 9 | } 10 | return ans; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /leetcode/Excel_Sheet_Column_Title/ExcelSheetColumnTitle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string convertToTitle(int n) { 4 | string ans; 5 | if(n <= 0) return ans; 6 | bool v = false; 7 | while(n){ 8 | ans += 'A' + (n - 1) % 26; 9 | n = (n - 1) / 26; 10 | } 11 | int i = 0, j = ans.size() - 1; 12 | while(i < j){ 13 | ans[i] = ans[i] + ans[j]; 14 | ans[j] = ans[i] - ans[j]; 15 | ans[i] = ans[i] - ans[j]; 16 | ++i; 17 | --j; 18 | } 19 | return ans; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /leetcode/Factorial_Trailing_Zeroes/FactorialTrailingZeroes.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int trailingZeroes(int n) { 4 | if(n <= 1) return 0; 5 | int ans = 0; 6 | while(n){ 7 | ans += n / 5; 8 | n /= 5; 9 | } 10 | return ans; 11 | } 12 | }; 13 | -------------------------------------------------------------------------------- /leetcode/Find_Minimum_in_Rotated_Sorted_Array/FindMinimuminRotatedSortedArray.cpp: -------------------------------------------------------------------------------- 1 | // binary search, and analyse by drawing simple graph 2 | class Solution { 3 | public: 4 | int findMin(vector &num) { 5 | int n = num.size(); 6 | if(n == 1) return num[0]; 7 | 8 | int low = 0, high = n - 1; 9 | while(low < high){ 10 | int mid = low + (high - low) / 2; 11 | if(num[mid] < num[low]){ 12 | high = mid; 13 | }else if(num[mid] < num[high]){ 14 | high = mid - 1; 15 | }else{ 16 | low = mid + 1; 17 | } 18 | } 19 | return num[low]; 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /leetcode/Find_Minimum_in_Rotated_Sorted_Array_II/FindMinimuminRotatedSortedArrayII.cpp: -------------------------------------------------------------------------------- 1 | int findMin(int num[], int n) { 2 | int low = 0, high = n - 1; 3 | while(low < high){ 4 | int mid = (low + high) / 2; 5 | if(num[mid] > num[high]){ 6 | low = mid + 1; 7 | }else{ 8 | if(num[mid] < num[high]){ 9 | high = mid; 10 | }else{ 11 | --high; 12 | } 13 | } 14 | } 15 | return num[high]; 16 | } 17 | -------------------------------------------------------------------------------- /leetcode/Find_Peak_Element/FindPeakElement_BinarySearch.cpp: -------------------------------------------------------------------------------- 1 | int findPeakElement(int num[], int n) { 2 | if(n == 0) return -1; 3 | if(n == 1) return 0; 4 | 5 | int low = 0, high = n - 1; 6 | while(low < high){ 7 | int mid = ((low + high)>>1); 8 | if(num[mid] > num[mid+1]){ 9 | high = mid; 10 | }else{ 11 | low = mid + 1; 12 | } 13 | } 14 | return high; 15 | } 16 | -------------------------------------------------------------------------------- /leetcode/Find_Peak_Element/FindPeakElement_Linear.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int findPeakElement(const vector &num) { 4 | int n = num.size(); 5 | if(n == 0) return -1; 6 | if(n == 1) return 0; 7 | if(num[0] > num[1]) return 0; 8 | if(num[n-1] > num[n-2]) return n-1; 9 | 10 | for(int i = 1; i < n-1; ++i){ 11 | if(num[i] > num[i-1] && num[i] > num[i+1]){ 12 | return i; 13 | } 14 | } 15 | return -1; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /leetcode/First Missing Positive.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int firstMissingPositive(int A[], int n) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int i = 0; 7 | while( i < n ){ 8 | if( A[i] <= 0 || A[i] > n ) ++i; 9 | else if( A[i] == i+1 || A[ A[i]-1 ]== A[i] ) ++i; 10 | else{ 11 | int temp = A[i]; 12 | A[i] = A[ temp -1 ]; 13 | A[temp-1] = temp; 14 | } 15 | } 16 | for( int i = 0; i < n; ++i ) { 17 | if( A[i] != i+1 ) return i+1; 18 | } 19 | return n+1; 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/Flatten_Binary_Tree_to_Linked_List/FlattenBinaryTreetoLinkedList.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void flatten(TreeNode *root) { 13 | // Note: The Solution object is instantiated only once and is reused by each test case. 14 | if( root==NULL ) return; 15 | queue q; 16 | preOrder( root->left, q ); 17 | preOrder( root->right, q ); 18 | TreeNode* iter = root; 19 | while( !q.empty() ){ 20 | TreeNode* cur = q.front(); 21 | q.pop(); 22 | iter->left = NULL; 23 | iter->right = cur; 24 | iter = cur; 25 | } 26 | } 27 | void preOrder( TreeNode * root, queue& q ){ 28 | if( root==NULL ) return; 29 | q.push(root); 30 | preOrder( root->left, q ); 31 | preOrder( root->right, q ); 32 | } 33 | }; -------------------------------------------------------------------------------- /leetcode/Flatten_Binary_Tree_to_Linked_List/FlattenBinaryTreetoLinkedList_InPlace.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void flatten(TreeNode *root) { 13 | if(root == NULL) return; 14 | if(root->left) flatten(root->left); 15 | if(root->right) flatten(root->right); 16 | TreeNode *_rchild = root->right; 17 | TreeNode *_lchild = root->left; 18 | root->left = NULL; 19 | if(_lchild) root->right = _lchild; 20 | while(_lchild && _lchild->right){ 21 | _lchild = _lchild->right; 22 | } 23 | if(_lchild) _lchild->right = _rchild; 24 | else root->right = _rchild; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /leetcode/Flatten_Binary_Tree_to_Linked_List/FlattenBinaryTreetoLinkedList_O-1-Space.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void flatten(TreeNode *root) { 13 | if(root == NULL) return; 14 | TreeNode *cur = root; 15 | while(cur){ 16 | if(cur->left == NULL){ 17 | cur = cur->right; 18 | }else{ 19 | if(cur->right) { 20 | TreeNode *p = cur->left; 21 | while(p->right) p = p->right; 22 | p->right = cur->right; 23 | } 24 | cur-> right = cur->left; 25 | cur->left = NULL; 26 | } 27 | } 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /leetcode/GasStation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int canCompleteCircuit(vector &gas, vector &cost) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = gas.size(); 6 | int tank = 0; 7 | int total = 0; 8 | int ret = 0; 9 | for( int i = 0; i < n; ++i ){ 10 | total += (gas[i]-cost[i]); 11 | tank += (gas[i]-cost[i]); 12 | if( total < 0 ){ 13 | ret = (i+1)%n; 14 | total = 0; 15 | } 16 | } 17 | return tank < 0 ?-1:ret; 18 | } 19 | }; -------------------------------------------------------------------------------- /leetcode/GenerateParentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector generateParenthesis(int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector result; 6 | if( n==0 ) return result; 7 | stack stk; 8 | string cur(2*n, '.'); 9 | dfs( 0, n, cur, result, stk ); 10 | return result; 11 | } 12 | void dfs( int k, int n, string& cur, vector& result, stack& stk ) 13 | { 14 | if( k == 2*n ) 15 | { 16 | if( !stk.empty() ) 17 | { 18 | return; 19 | } 20 | result.push_back(cur); 21 | return; 22 | } 23 | cur[k] = '('; 24 | stk.push(cur[k]); 25 | dfs( k+1, n, cur, result, stk ); 26 | if( !stk.empty() ) stk.pop();//backtrace 27 | cur[k] = ')'; 28 | if( stk.empty() ) return; 29 | char c = stk.top(); 30 | stk.pop(); 31 | if( c != '(' ) return; 32 | dfs( k+1, n, cur, result, stk ); 33 | stk.push(c);//backtrace 34 | } 35 | }; -------------------------------------------------------------------------------- /leetcode/Gray_Code/GrayCode.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 0 0 0 3 | 0 0 1 4 | ------ n = 1 5 | 0 1 1 6 | 0 1 0 7 | ------ n = 2 8 | 1 1 0 9 | 1 1 1 10 | 1 0 1 11 | 1 0 0 12 | ------ n = 3 13 | */ 14 | class Solution { 15 | public: 16 | vector grayCode(int n) { 17 | vector ans; 18 | if(n == 0) { 19 | ans.push_back(0); //? fuck leetcode 20 | return ans; 21 | } 22 | ans.push_back(0); 23 | ans.push_back(1); 24 | int i = 2; 25 | while(i <= n){ 26 | int m = ans.size(); 27 | for(int j = m - 1; j >= 0; --j) { 28 | int flip = 1 << (i - 1); 29 | ans.push_back(ans[j]^flip); 30 | } 31 | ++i; 32 | } 33 | return ans; 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/Happy_Number/HappyNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isHappy(int n) { 4 | if(n == 1) return true; 5 | if(n == 0) return false; 6 | unordered_set history; 7 | history.insert(n); 8 | while(true){ 9 | int sum = 0; 10 | while(n){ 11 | int p = n % 10; 12 | sum += p * p; 13 | n /= 10; 14 | } 15 | if(sum == 1) return true; 16 | if(history.find(sum) != history.end()) return false; 17 | history.insert(sum); 18 | n = sum; 19 | } 20 | } 21 | }; 22 | -------------------------------------------------------------------------------- /leetcode/House_Robber/House_Robber_DP.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int rob(vector &num) { 4 | int n = num.size(); 5 | if(n == 0) return 0; 6 | if(n == 1) return num[0]; 7 | 8 | int prev_yes = 0, prev_no = 0; 9 | for(int i = 0; i < n; ++i){ 10 | int temp = prev_no; 11 | prev_no = max(prev_yes, prev_no); 12 | prev_yes = temp + num[i]; 13 | } 14 | return max(prev_yes, prev_no); 15 | } 16 | }; 17 | -------------------------------------------------------------------------------- /leetcode/Implement-strStr.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Problem: Leetcode - Implement strStr() 3 | Author: 靖难 4 | Tag: KMP, string match, DFA 5 | Difficulty: 1 (from 1 to 5) 6 | */ 7 | 8 | class Solution { 9 | public: 10 | char *strStr(char *haystack, char *needle) { 11 | // edge case 12 | if(needle == NULL || needle[0] == '\0') return haystack; 13 | if(haystack == NULL || haystack[0] == '\0') return NULL; 14 | // start kmp 15 | int n = strlen(haystack); 16 | int m = strlen(needle); 17 | // build next function 18 | int* next = new int[m+1]; 19 | next[0] = -1; 20 | int p = -1; 21 | for(int i = 1; i < m; ++i){ 22 | while(p != -1 && needle[p+1] != needle[i]){ 23 | p = next[p]; 24 | } 25 | if(needle[p+1] == needle[i]){ 26 | p = p + 1; 27 | } 28 | next[i] = p; 29 | } 30 | // query and match 31 | p = -1; 32 | int i = 0; 33 | for(; i < n; ++i){ 34 | while(p != -1 && needle[p+1] != haystack[i]){ 35 | p = next[p]; 36 | } 37 | if(needle[p+1] == haystack[i]){ 38 | p = p + 1; 39 | } 40 | if(p == m-1) break; 41 | } 42 | //recycle memory 43 | delete [] next; 44 | //return answer 45 | return p != m-1 ? NULL : haystack + i - m + 1; 46 | } 47 | }; 48 | -------------------------------------------------------------------------------- /leetcode/Insertion Sort List.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *insertionSortList(ListNode *head) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | if( !head || !head->next ) return head; 15 | ListNode* cur = head->next; 16 | head->next = NULL; 17 | while ( cur ){ 18 | ListNode* newCur = cur->next; 19 | if( head->val >= cur->val ){ 20 | cur->next = head; 21 | head = cur; 22 | cur = newCur; 23 | continue; 24 | } 25 | ListNode* ptr = head; 26 | while( ptr->next && ptr->next->val < cur->val ){ 27 | ptr = ptr->next; 28 | } 29 | cur->next = ptr->next; 30 | ptr->next = cur; 31 | cur = newCur; 32 | } 33 | return head; 34 | } 35 | }; -------------------------------------------------------------------------------- /leetcode/Integer_to_Roman/RomantoInteger.cpp: -------------------------------------------------------------------------------- 1 | // the Roman seven symbols: 2 | // I(1), V(5), X(10), L(50), C(100), D(500), M(1000) 3 | // the Roman rules: 4 | // the numeral I can be placed before V and X to make 4 units (IV) and 9 units (IX) respectively 5 | // X can be placed before L and C to make 40 (XL) and 90 (XC) respectively 6 | // C can be placed before D and M to make 400 (CD) and 900 (CM) according to the same pattern 7 | 8 | class Solution { 9 | public: 10 | string intToRoman(int num) { 11 | string ans; 12 | int base[13] = {1, 4, 5, 9, 10, 40, 50, 90, 100, 400, 500, 900, 1000}; 13 | string roma[13] = {"I", "IV", "V", "IX", "X", "XL", "L", "XC", "C", "CD", "D", "CM", "M"}; 14 | int i = 12; 15 | while(num){ 16 | if(num >= base[i]){ 17 | if(roma[i].size() == 1){ 18 | for(int j = 0; j < num / base[i]; ++j) ans += roma[i]; 19 | num %= base[i]; 20 | }else{ 21 | ans += roma[i]; 22 | num -= base[i]; 23 | } 24 | } 25 | --i; 26 | } 27 | return ans; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /leetcode/Interleaving_String/InterleavingString_DFS.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isInterleave(string s1, string s2, string s3) { 4 | int l1 = s1.size(); 5 | int l2 = s2.size(); 6 | int l3 = s3.size(); 7 | if(l1 == 0) return s2 == s3; 8 | if(l2 == 0) return s1 == s3; 9 | if(l1 + l2 != l3) return false; 10 | vector< vector > ans(l1+1, vector(l2+1, false)); 11 | ans[0][0] = true; 12 | for(int i = 1; i <= l1; ++i){ 13 | ans[i][0] = ans[i-1][0] && (s1[i-1] == s3[i-1]); 14 | } 15 | for(int i = 1; i <= l2; ++i){ 16 | ans[0][i] = ans[0][i-1] && (s2[i-1] == s3[i-1]); 17 | } 18 | for(int i = 1; i <= l1; ++i){ 19 | for(int j = 1; j <= l2; ++j){ 20 | ans[i][j] = ans[i-1][j] && (s1[i-1] == s3[i+j-1]); 21 | ans[i][j] = ans[i][j] || (ans[i][j-1] && (s2[j-1] == s3[i+j-1])); 22 | } 23 | } 24 | return ans[l1][l2]; 25 | } 26 | }; 27 | 28 | -------------------------------------------------------------------------------- /leetcode/Interleaving_String/InterleavingString_DP.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isInterleave(string s1, string s2, string s3) { 4 | int l1 = s1.size(); 5 | int l2 = s2.size(); 6 | int l3 = s3.size(); 7 | if(l1 == 0) return s2 == s3; 8 | if(l2 == 0) return s1 == s3; 9 | if(l1 + l2 != l3) return false; 10 | vector< vector > ans(l1+1, vector(l2+1, false)); 11 | ans[0][0] = true; 12 | for(int i = 1; i <= l1; ++i){ 13 | ans[i][0] = ans[i-1][0] && (s1[i-1] == s3[i-1]); 14 | } 15 | for(int i = 1; i <= l2; ++i){ 16 | ans[0][i] = ans[0][i-1] && (s2[i-1] == s3[i-1]); 17 | } 18 | for(int i = 1; i <= l1; ++i){ 19 | for(int j = 1; j <= l2; ++j){ 20 | ans[i][j] = ans[i-1][j] && (s1[i-1] == s3[i+j-1]); 21 | ans[i][j] = ans[i][j] || (ans[i][j-1] && (s2[j-1] == s3[i+j-1])); 22 | } 23 | } 24 | return ans[l1][l2]; 25 | } 26 | }; 27 | -------------------------------------------------------------------------------- /leetcode/Intersection_of_Two_Linked_Lists/IntersectionofTwoLinkedLists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { 12 | if(headA == NULL || headB == NULL) return NULL; 13 | ListNode *p1 = headA, *p2 = headB; 14 | int len1 = 0, len2 = 0; 15 | while(p1 != NULL){ 16 | len1++; 17 | p1 = p1->next; 18 | } 19 | while(p2 != NULL){ 20 | len2++; 21 | p2 = p2->next; 22 | } 23 | p1 = headA, p2 = headB; 24 | while(len1 > len2){ 25 | len1--; 26 | p1 = p1->next; 27 | } 28 | while(len2 > len1){ 29 | len2--; 30 | p2 = p2->next; 31 | } 32 | while(p1 != NULL && p2 != NULL){ 33 | if(p1 == p2) return p1; 34 | p1 = p1->next; 35 | p2 = p2->next; 36 | } 37 | return NULL; 38 | } 39 | }; 40 | -------------------------------------------------------------------------------- /leetcode/Intersection_of_Two_Linked_Lists/IntersectionofTwoLinkedLists_tricky.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *getIntersectionNode(ListNode *headA, ListNode *headB) { 12 | if(headA == NULL || headB == NULL) return NULL; 13 | ListNode *p1 = headA, *p2 = headB; 14 | while (p1 != NULL || p2 != NULL){ 15 | if(p1 == NULL) p1 = headB; 16 | if(p2 == NULL) p2 = headA; 17 | if(p1 == p2) return p1; 18 | p1 = p1->next; 19 | p2 = p2->next; 20 | } 21 | return NULL; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/Ismorphic_Strings/IsmorphicStrings.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isIsomorphic(string s, string t) { 4 | if(s.size() != t.size()) return false; 5 | int n = s.size(); 6 | int flag = 1; 7 | vector h1(256, 0), h2(256, 0); 8 | for(int i = 0; i < n; ++i){ 9 | char c1 = s[i], c2 = t[i]; 10 | if(h1[c1] != h2[c2]) return false; 11 | if(h1[c1] == 0){ 12 | h1[c1] = flag; 13 | h2[c2] = flag; 14 | ++flag; 15 | } 16 | } 17 | return true; 18 | } 19 | }; 20 | -------------------------------------------------------------------------------- /leetcode/JumpGame.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canJump(int A[], int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | if( n==1 ) 7 | { 8 | return true; 9 | } 10 | int maxDist = A[0]; 11 | for( int i = 1; i != n; ++i ) 12 | { 13 | if( maxDist < i ) 14 | { 15 | return false; 16 | } 17 | if( maxDist>=n-1 ) 18 | { 19 | return true; 20 | } 21 | if( maxDist >= i ) 22 | { 23 | if( i+A[i] > maxDist ) 24 | { 25 | maxDist = i+A[i]; 26 | } 27 | } 28 | } 29 | return false; 30 | } 31 | }; -------------------------------------------------------------------------------- /leetcode/JumpGameGreedy.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool canJump(int A[], int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | vector result( n, 0 ); 7 | result[0] = 1; 8 | for( int i = 0; i != n; ++i ) 9 | { 10 | if( result[i]==0 ) continue; 11 | for( int j = i+1; j <= i+A[i]; ++j ) 12 | { 13 | if( result[j]==1 )continue; 14 | if( j+A[j]>=n-1 ) 15 | { 16 | return true; 17 | } 18 | result[j] = 1; 19 | } 20 | if( result[n-1]==1 ) 21 | { 22 | return true; 23 | } 24 | } 25 | return false; 26 | } 27 | }; 28 | 29 | class Solution { 30 | public: 31 | bool canJump(int A[], int n) { 32 | // Start typing your C/C++ solution below 33 | // DO NOT write int main() function 34 | vector result( n, 0 ); 35 | for( int i = 0; i != n; ++i ) 36 | { 37 | result[i] = i+A[i]; 38 | for( int j = i-1; j >=0; --j ) 39 | { 40 | if( j+ A[j] >= i && result[j]=n-1 ) 46 | { 47 | return true; 48 | } 49 | } 50 | return false; 51 | } 52 | }; -------------------------------------------------------------------------------- /leetcode/JumpGameII_DP.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int jump(int A[], int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | if(n==0 || n==1 )return 0; 7 | int step = 1; 8 | int maxDist = A[0]; 9 | int i = 1; 10 | while( i < n ) 11 | { 12 | if( maxDist >= n-1 ) 13 | { 14 | break; 15 | } 16 | int maxIdx = i; 17 | for( int j = i; j < maxDist; ++j ) 18 | { 19 | if( j+A[j] > maxIdx+A[maxIdx]) 20 | { 21 | maxIdx = j; 22 | } 23 | } 24 | i = maxDist + 1; 25 | ++step; 26 | if( maxIdx+A[maxIdx]>maxDist+A[maxDist]) 27 | { 28 | maxDist = maxIdx + A[maxIdx]; 29 | }else{ 30 | maxDist = maxDist+A[maxDist]; 31 | } 32 | } 33 | 34 | return step; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /leetcode/JumpGameSearch.cpp: -------------------------------------------------------------------------------- 1 | //DFS 2 | class Solution { 3 | public: 4 | bool canJump(int A[], int n) { 5 | // Start typing your C/C++ solution below 6 | // DO NOT write int main() function 7 | int cur = 0; 8 | vector map(n,0); 9 | return dfs( A, n, cur,map); 10 | } 11 | bool dfs( int A[], int n, int cur, vector&map ) 12 | { 13 | if( cur=n-1 ) 14 | { 15 | return true; 16 | } 17 | for( int i = 1; i <= A[cur]; ++i ) 18 | { 19 | if( map[cur+i] != 1 ) 20 | { 21 | bool ret = dfs( A, n, cur+i,map); 22 | if( ret ) 23 | { 24 | return ret; 25 | } 26 | map[cur+i] = 1; 27 | } 28 | } 29 | return false; 30 | } 31 | }; 32 | 33 | //BFS 34 | class Solution { 35 | public: 36 | bool canJump(int A[], int n) { 37 | // Start typing your C/C++ solution below 38 | // DO NOT write int main() function 39 | int cur = 0; 40 | vector map(n,0); 41 | queue Q; 42 | Q.push(0); 43 | map[0] = 1; 44 | while(!Q.empty()) 45 | { 46 | int cur = Q.front(); 47 | if(cur+A[cur]>=n-1) 48 | { 49 | return true; 50 | } 51 | Q.pop(); 52 | for( int i = cur+A[cur]; i >cur ; --i ) 53 | { 54 | if( map[i]==0 ) 55 | { 56 | Q.push(i); 57 | map[i] = 1; 58 | } 59 | } 60 | } 61 | return false; 62 | } 63 | }; 64 | 65 | -------------------------------------------------------------------------------- /leetcode/LRU_Cache/LRUCache.cpp: -------------------------------------------------------------------------------- 1 | //data-structure application: hash-table, double linked list 2 | class LRUCache{ 3 | public: 4 | class Node { 5 | public: 6 | int key; 7 | int value; 8 | Node(int k, int v): key(k), value(v) {} 9 | }; 10 | 11 | int _capacity; 12 | list _list; 13 | map::iterator> _data; 14 | 15 | LRUCache(int capacity): _capacity(capacity) {} 16 | 17 | int get(int key) { 18 | if(_data.find(key) == _data.end()) return -1; 19 | list::iterator it = _data[key]; 20 | if(it != _list.begin()){ 21 | _list.erase(it); 22 | _list.push_front(*it); 23 | _data[key] = _list.begin(); 24 | } 25 | return it->value; 26 | } 27 | 28 | void set(int key, int value) { 29 | if(_data.find(key) != _data.end()) { 30 | list::iterator it = _data[key]; 31 | _list.erase(it); 32 | it->value = value; 33 | _list.push_front(*it); 34 | _data[key] = _list.begin(); 35 | }else{ 36 | if(_data.size() >= _capacity){ 37 | _data.erase(_list.back().key); 38 | _list.pop_back(); 39 | } 40 | _list.push_front(Node(key, value)); 41 | _data[key] = _list.begin(); 42 | } 43 | } 44 | }; 45 | 46 | -------------------------------------------------------------------------------- /leetcode/Largest_Number/LargestNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static bool cmp(const string& a, const string& b){ 4 | return a + b > b + a; 5 | } 6 | 7 | static string toString(int num){ 8 | string ret; 9 | while(num){ 10 | ret += num % 10 + '0'; 11 | num /= 10; 12 | } 13 | int i = 0, j = ret.size() - 1; 14 | while(i < j){ 15 | ret[i] = ret[i] + ret[j]; 16 | ret[j] = ret[i] - ret[j]; 17 | ret[i] = ret[i] - ret[j]; 18 | ++i; 19 | --j; 20 | } 21 | return ret.size() ? ret : "0"; 22 | } 23 | 24 | string largestNumber(vector &num) { 25 | string ans; 26 | vector snum; 27 | for(int i = 0; i < num.size(); ++i){ 28 | snum.push_back(toString(num[i])); 29 | } 30 | sort(snum.begin(), snum.end(), Solution::cmp); 31 | bool zero = true; 32 | for(int i = 0; i < snum.size(); ++i){ 33 | ans += snum[i]; 34 | if(snum[i] != "0") zero = false; 35 | } 36 | return zero ? "0" : ans; 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /leetcode/Length of Last Word.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int lengthOfLastWord(const char *s) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int len = 0; 7 | while( *s != '\0' ){ 8 | while( *s == ' ' ){ 9 | ++s; 10 | if( *s=='\0' ) return len; 11 | } 12 | len = 0; 13 | while( *s != ' ' ){ 14 | ++s; 15 | ++len; 16 | if( *s == '\0' )break; 17 | } 18 | } 19 | return len; 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/LetterCombinationsofaPhoneNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector letterCombinations(string digits) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector result; 6 | string cur( digits.size(), '.'); 7 | vector map(12,""); 8 | map[2] = "abc"; 9 | map[3] = "def"; 10 | map[4] = "ghi"; 11 | map[5] = "jkl"; 12 | map[6] = "mno"; 13 | map[7] = "pqrs"; 14 | map[8] = "tuv"; 15 | map[9] = "wxyz"; 16 | dfs(0, map, digits, cur, result ); 17 | return result; 18 | } 19 | void dfs( int k, vector&map, string&src, string&cur, vector&result ) 20 | { 21 | if( k>=src.size() ) 22 | { 23 | result.push_back(cur); 24 | return; 25 | } 26 | int digit = src[k]-'0'; 27 | for( int i = 0; i < map[digit].size(); ++i ) 28 | { 29 | cur[k] = map[digit][i]; 30 | dfs( k+1, map, src, cur, result ); 31 | } 32 | } 33 | }; -------------------------------------------------------------------------------- /leetcode/Linked_list_Cycle/Linked List Cycle.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | bool hasCycle(ListNode *head) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | ListNode* slow = head; 15 | ListNode* fast = head; 16 | do{ 17 | if( !slow || !fast ) return false; 18 | slow = slow->next; 19 | fast = fast->next; 20 | if( !fast ) return false; 21 | fast = fast->next; 22 | }while( slow != fast ); 23 | return true; 24 | } 25 | }; -------------------------------------------------------------------------------- /leetcode/Linked_list_Cycle_II/Linked List Cycle II.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *detectCycle(ListNode *head) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | ListNode* slow = head; 15 | ListNode* fast = head; 16 | do{ 17 | if( !slow || !fast ) return NULL; 18 | slow = slow->next; 19 | fast = fast->next; 20 | if( fast ) fast = fast->next; 21 | else return NULL; 22 | }while( slow != fast ); 23 | slow = head; 24 | while( slow != fast ){ 25 | slow = slow->next; 26 | fast = fast->next; 27 | } 28 | return slow; 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/Linked_list_Cycle_II/readme.md: -------------------------------------------------------------------------------- 1 | 2 | Proof: 3 | 1. Assume the length from head to the cycle is x 4 | 2. Assume the cycle itself's length is y. 5 | 3. Pointer slow run one step every time, and Pointer fast run two steps each time. 6 | 4. It is obvious that the faster will meet the slower at some node in the cycle. we define the length from the start node to such node is z. 7 | 5. the slower totally run x + ky + z steps, and the faster x + py + z, so x + py + z = 2(x + ky + z) 8 | 6. Thus, we have x = (p - 2k - 1)y + (y - z) 9 | 7. Then let the slower start from the head node again, and finally they will meet each other at the cycle start point. 10 | 11 | * Hint: The fast start from point z, and keep rolling in the cycle for p - 2k - 1 times, then run y - z more step to the start node of cycle. Meanwhile, the slower entered the cycle. 12 | 13 | -------------------------------------------------------------------------------- /leetcode/Longest Consecutive Sequence.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int longestConsecutive(vector &num) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = num.size(); 6 | if( n < 2) return n; 7 | unordered_set< int > keys; 8 | unordered_set< int > visited; 9 | for( int i = 0; i < n; ++i ) { 10 | keys.insert( num[i] ); 11 | } 12 | int maxLen = 1; 13 | for( int i = 0; i < n; ++i ){ 14 | if( visited.find(num[i])!=visited.end() ){ 15 | continue; 16 | } 17 | visited.insert( num[i] ); 18 | int low = num[i]; 19 | int high = num[i]; 20 | while(true){ 21 | if( keys.find(--low )==keys.end() ){ 22 | ++low; 23 | break; 24 | } 25 | visited.insert( low ); 26 | } 27 | //High bound 28 | while(true){ 29 | if( keys.find(++high )==keys.end() ){ 30 | --high; 31 | break; 32 | } 33 | visited.insert( high ); 34 | } 35 | int curLen = high - low + 1; 36 | if( curLen > maxLen ){ 37 | maxLen = curLen; 38 | } 39 | } 40 | return maxLen; 41 | } 42 | }; -------------------------------------------------------------------------------- /leetcode/Longest Valid Parentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int longestValidParentheses(string s) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int n = s.size(); 7 | stack stk; 8 | for( int i = 0; i < n; ++i ) { 9 | if( s[i] == '(' ){ 10 | stk.push(i); 11 | }else{ 12 | if( !stk.empty() ){ 13 | s[i] = '.'; 14 | s[ stk.top() ] = '.'; 15 | stk.pop(); 16 | } 17 | } 18 | } 19 | int maxLen = 0; 20 | int curLen = 0; 21 | for( int i = 0; i < n; ++i ){ 22 | if( s[i]=='.' ) ++curLen; 23 | else curLen = 0; 24 | if( curLen > maxLen ) maxLen = curLen; 25 | } 26 | return maxLen; 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/LongestCommonPrefix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string longestCommonPrefix(vector &strs) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | string result; 6 | int max = 0; 7 | int n = strs.size(); 8 | if( n==0 ) return result; 9 | int len = strs[0].size(); 10 | if( len==0 || n==1 ) return strs[0] ; 11 | for( int i = 1; i < n; ++i ){ 12 | int cnt = 0; 13 | for( int j = 0; j < len; ++j ){ 14 | if( j >= strs[i].size() || strs[i][j] != strs[0][j] ) break; 15 | ++cnt; 16 | } 17 | if( cnt < max || i==1 ) max = cnt; 18 | } 19 | return strs[0].substr( 0, max ); 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/LongestPalindromicSubstring.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string longestPalindrome(string s) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int n = s.size(); 7 | int maxLen = 1; 8 | int start = 0; 9 | vector< vector > flag( n, vector(n,false) ); 10 | for( int i = 0; i != n; ++i ){ 11 | flag[i][i] = true; 12 | if( i+1 hash( 256, -1 ); 7 | hash[ s[0] ] = 0; 8 | int curLen = 1; 9 | int maxLen = 1; 10 | for( int i = 1; i != s.size(); ++i ){ 11 | if( hash[ s[i] ]==-1 || hash[ s[i] ] < i-curLen ){ 12 | curLen = curLen + 1; 13 | }else{ 14 | curLen = i-hash[ s[i] ]; 15 | } 16 | if( curLen > maxLen ){ 17 | maxLen = curLen; 18 | } 19 | hash[ s[i] ] = i; 20 | } 21 | return maxLen; 22 | } 23 | }; -------------------------------------------------------------------------------- /leetcode/Majority_Element/MajorityElement.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int majorityElement(vector &num) { 4 | int n = num.size(); 5 | if(n <= 2) return num[0]; 6 | 7 | int ans, count = 0; 8 | for(int i = 0; i < n; ++i){ 9 | if(count == 0) ans = num[i]; 10 | if(num[i] == ans) ++count; 11 | else --count; 12 | } 13 | return ans; 14 | } 15 | }; 16 | -------------------------------------------------------------------------------- /leetcode/MaximumDepthofBinaryTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | int maxDepth(TreeNode *root) { 13 | // Start typing your C/C++ solution below 14 | // DO NOT write int main() function 15 | int max = 0; 16 | int step = 0; 17 | dfs(root,step,max); 18 | return max; 19 | } 20 | void dfs(TreeNode* root, int step, int&max) 21 | { 22 | if(root==NULL) 23 | { 24 | if(step>max) 25 | { 26 | max = step; 27 | } 28 | return; 29 | } 30 | dfs(root->left,step+1,max); 31 | dfs(root->right,step+1,max); 32 | } 33 | }; -------------------------------------------------------------------------------- /leetcode/Maximum_Gap/MaximumGap.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int maximumGap(vector& nums) { 4 | int n = nums.size(); 5 | if(n < 2) return 0; 6 | vector bucket[2]; 7 | for(int i = 0; i < 32; ++i){ 8 | int flag = 1 << i; 9 | for(int j = 0; j < n; ++j){ 10 | if(nums[j]&flag){ 11 | bucket[1].push_back(nums[j]); 12 | }else{ 13 | bucket[0].push_back(nums[j]); 14 | } 15 | } 16 | int j = 0; 17 | for(;j < bucket[0].size(); ++j){ 18 | nums[j] = bucket[0][j]; 19 | } 20 | for(int k = 0; k < bucket[1].size(); ++k, ++j){ 21 | nums[j] = bucket[1][k]; 22 | } 23 | bucket[0].clear(); 24 | bucket[1].clear(); 25 | } 26 | int ans = nums[1] - nums[0]; 27 | for(int i = 2; i < n; ++i){ 28 | ans = max(ans, nums[i] - nums[i-1]); 29 | } 30 | return ans; 31 | } 32 | }; 33 | -------------------------------------------------------------------------------- /leetcode/Maximum_Subarray/MaximumSubarray_DP.cpp: -------------------------------------------------------------------------------- 1 | // 最大字段和 2 | class Solution { 3 | public: 4 | int maxSubArray(int A[], int n) { 5 | int ans = INT_MIN; 6 | int cur = 0; 7 | for(int i = 0; i < n; ++i){ 8 | cur = max(A[i], A[i] + cur); 9 | if(cur > ans) ans = cur; 10 | } 11 | return ans; 12 | } 13 | }; 14 | -------------------------------------------------------------------------------- /leetcode/Maximum_Subarray/MaximumSubarray_Divide-Conquer.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int solve(int arr[], int low, int high){ 4 | if(low == high){ 5 | return arr[low]; 6 | } 7 | 8 | int mid = (high + low) / 2; 9 | 10 | int sum = 0; 11 | int left_sum = INT_MIN; 12 | for(int i = mid; i >= low; --i){ 13 | sum += arr[i]; 14 | if(sum > left_sum) left_sum = sum; 15 | } 16 | 17 | sum = 0; 18 | int right_sum = INT_MIN; 19 | for(int i = mid + 1; i <= high; ++i){ 20 | sum += arr[i]; 21 | if(sum > right_sum) right_sum = sum; 22 | } 23 | 24 | int ans = max(left_sum, right_sum); 25 | ans = max(ans, left_sum + right_sum); 26 | 27 | int left_ans = solve(arr, low, mid); 28 | int right_ans = solve(arr, mid+1, high); 29 | ans = max(ans, max(left_ans, right_ans)); 30 | return ans; 31 | } 32 | int maxSubArray(int A[], int n) { 33 | int ans = solve(A, 0, n - 1); 34 | return ans; 35 | } 36 | }; 37 | -------------------------------------------------------------------------------- /leetcode/MedianofTwoSortedArrays.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | double findMedianSortedArrays(int A[], int m, int B[], int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( m+n == 0 ) return 0.0; 6 | int i = 0, j = 0, k = 0; 7 | vector C( m+n+1, 0 ); 8 | while( i < m && j < n ){ 9 | if( A[i] < B[j] ){ 10 | C[k++] = A[i++]; 11 | }else if( A[i] > B[j] ){ 12 | C[k++] = B[j++]; 13 | }else{ 14 | C[k++] = A[i++]; 15 | C[k++] = B[j++]; 16 | } 17 | } 18 | while( i < m ){ 19 | C[k++] = A[i++]; 20 | } 21 | while( j < n ){ 22 | C[k++] = B[j++]; 23 | } 24 | if( (m+n)%2 ){ 25 | return C[ (m+n+1)/2-1]; 26 | } 27 | 28 | return double( C[(m+n)/2-1] + C[(m+n)/2])/2; 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/MergeSortedArray.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void merge(int A[], int m, int B[], int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( n==0 ) return; 6 | int* C = new int[m+n+1]; 7 | int i = 0, j = 0, k = 0; 8 | while( i < m && j < n ){ 9 | if( A[i] < B[j] ){ 10 | C[k++] = A[i++]; 11 | }else{ 12 | C[k++] = B[j++]; 13 | } 14 | } 15 | while( i < m ){ 16 | C[k++] = A[i++]; 17 | } 18 | while( j < n ){ 19 | C[k++] = B[j++]; 20 | } 21 | for( i = 0; i != k; ++i ){ 22 | A[i] = C[i]; 23 | } 24 | delete [] C; 25 | } 26 | }; -------------------------------------------------------------------------------- /leetcode/MergeTwoSortedLists.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *mergeTwoLists(ListNode *l1, ListNode *l2) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( l1==NULL ) return l2; 14 | if( l2==NULL ) return l1; 15 | 16 | ListNode *L0; 17 | ListNode *cur0, *cur1, *cur2; 18 | if( l1->val < l2->val ){ 19 | L0 = l1; 20 | cur1 = l1->next; 21 | cur2 = l2; 22 | }else{ 23 | L0 = l2; 24 | cur1 = l1; 25 | cur2 = l2->next; 26 | } 27 | cur0 = L0; 28 | while( cur1 != NULL && cur2 != NULL ){ 29 | if( cur1->val < cur2->val ){ 30 | cur0->next = cur1; 31 | cur1 = cur1->next; 32 | }else{ 33 | cur0->next = cur2; 34 | cur2 = cur2->next; 35 | } 36 | cur0 = cur0->next; 37 | } 38 | if( cur1 != NULL ){ 39 | cur0->next = cur1; 40 | } 41 | if( cur2 != NULL ){ 42 | cur0->next = cur2; 43 | } 44 | return L0; 45 | } 46 | }; -------------------------------------------------------------------------------- /leetcode/Merge_Intervals/MergeIntervals.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for an interval. 3 | * struct Interval { 4 | * int start; 5 | * int end; 6 | * Interval() : start(0), end(0) {} 7 | * Interval(int s, int e) : start(s), end(e) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool is_joint(const Interval& a, const Interval& b){ 13 | if(a.end < b.start) return false; 14 | if(a.start > b.end) return false; 15 | return true; 16 | } 17 | 18 | static bool cmp(const Interval& a, const Interval& b){ 19 | return a.start < b.start; 20 | } 21 | 22 | vector merge(vector& intervals) { 23 | int n = intervals.size(); 24 | if(n <= 1) return intervals; 25 | vector ans; 26 | sort(intervals.begin(), intervals.end(), Solution::cmp); 27 | ans.push_back(intervals[0]); 28 | for(int i = 1; i < n; ++i){ 29 | if(is_joint(intervals[i], ans.back())){ 30 | ans[ans.size()-1].start = min(intervals[i].start, ans.back().start); 31 | ans[ans.size()-1].end = max(intervals[i].end, ans.back().end); 32 | }else{ 33 | ans.push_back(intervals[i]); 34 | } 35 | } 36 | return ans; 37 | } 38 | }; 39 | -------------------------------------------------------------------------------- /leetcode/MergekSortedLists.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static ListNode *mergeKLists(vector &lists) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = lists.size(); 6 | if( n==0 ) return NULL; 7 | if( n==1 ) return lists[0]; 8 | vector< ListNode* > vec; 9 | for( int i = 0; i != n; ++i ) 10 | { 11 | ListNode* iter = lists[i]; 12 | while( iter != NULL ) 13 | { 14 | vec.push_back(iter); 15 | iter = iter->next; 16 | } 17 | } 18 | if( vec.size()==0 ) return NULL; 19 | sort( vec.begin(), vec.end(), Solution::myfunc ); 20 | for( int i = 0; i != vec.size()-1; ++i ){ 21 | vec[i]->next = vec[i+1]; 22 | } 23 | vec[vec.size()-1]->next = NULL; 24 | return vec[0]; 25 | } 26 | static bool myfunc( ListNode* u, ListNode* v ) 27 | { 28 | return u->val < v->val; 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/MinimumPathSum.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minPathSum(vector > &grid) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int m = grid.size(); 7 | int n = grid[0].size(); 8 | vector< vector > dp( m, vector(n,0) ); 9 | //初始化第一行，第一列 10 | dp[0][0] = grid[0][0]; 11 | for( int i = 1; i != n; ++i ){ 12 | dp[0][i] = dp[0][i-1] + grid[0][i]; 13 | } 14 | for( int i = 1; i != m; ++i ){ 15 | dp[i][0] = dp[i-1][0] + grid[i][0]; 16 | } 17 | //利用缓存值，滚动计算出所有值 18 | for( int i = 1; i != m; ++i ){ 19 | for( int j = 1; j != n; ++j ){ 20 | if( dp[i-1][j]+grid[i][j] < dp[i][j-1]+grid[i][j] ){ 21 | dp[i][j] = dp[i-1][j]+grid[i][j]; 22 | }else{ 23 | dp[i][j] = dp[i][j-1]+grid[i][j]; 24 | } 25 | } 26 | } 27 | return dp[m-1][n-1]; 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/Minimum_Depth_of_Binary_Tree/MinimumDepthofBinaryTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void dfs(TreeNode* root, int depth, int &ans){ 13 | if(root == NULL){ 14 | if(depth == 1) ans = 0; 15 | return; 16 | } 17 | if(!root->left && !root->right){ 18 | ans = min(ans, depth); 19 | return; 20 | } 21 | dfs(root->left, depth+1, ans); 22 | dfs(root->right, depth+1, ans); 23 | } 24 | int minDepth(TreeNode *root) { 25 | int ans = INT_MAX; 26 | dfs(root, 1, ans); 27 | return ans; 28 | } 29 | }; 30 | -------------------------------------------------------------------------------- /leetcode/NQueens.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > solveNQueens(int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | vector< vector > result; 7 | if(n==0) 8 | { 9 | return result; 10 | } 11 | vector queen(n); 12 | vector solution(n,string(n,'.')); 13 | dfs( queen, n, 0, result, solution ); 14 | return result; 15 | } 16 | void dfs( vector& queen, int n, int step, vector< vector >& result,vector& asolution ) 17 | { 18 | if(step==n) 19 | { 20 | result.push_back(asolution); 21 | return; 22 | } 23 | for(int i = 0; i != n; ++i ) 24 | { 25 | bool valid = true; 26 | for( int j = 0; j <= step-1; ++j ) 27 | { 28 | if( abs(step-j)==abs(i-queen[j]) || i==queen[j] ) 29 | { 30 | valid = false; 31 | break; 32 | } 33 | } 34 | if( valid ) 35 | { 36 | queen[step] = i; 37 | asolution[step][i] = 'Q'; 38 | dfs(queen, n, step+1, result, asolution); 39 | asolution[step][i] = '.'; 40 | } 41 | } 42 | } 43 | }; -------------------------------------------------------------------------------- /leetcode/NQueensII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int totalNQueens(int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | if(n==0) 7 | { 8 | return 0; 9 | } 10 | vector queen(n); 11 | int result = 0; 12 | dfs( queen, n, 0, result ); 13 | return result; 14 | } 15 | void dfs( vector& queen, int n, int step,int& result ) 16 | { 17 | if( step==n ) 18 | { 19 | ++result; 20 | return; 21 | } 22 | for( int i = 0; i != n; ++i ) 23 | { 24 | bool valid = true; 25 | for( int j = 0; j != step; ++j ) 26 | { 27 | if( abs(step-j)==abs(i-queen[j]) || i==queen[j]) 28 | { 29 | valid = false; 30 | break; 31 | } 32 | } 33 | if(valid) 34 | { 35 | queen[step] = i; 36 | dfs(queen, n, step+1, result ); 37 | } 38 | } 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/NextPermutation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void nextPermutation(vector &num) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = num.size(); 6 | if( n==0 || n==1 ) return; 7 | int cur = n-1; 8 | while( true ){ 9 | int next = cur--; 10 | if( num[cur] < num[next] ){ 11 | int pos = n-1; 12 | while( num[cur] >= num[pos] ) --pos; 13 | it_swap( num.begin()+cur, num.begin()+pos ); 14 | reverse( num.begin()+next, num.end() ); 15 | return; 16 | } 17 | if( cur==0 ){ 18 | reverse( num.begin(), num.end() ); 19 | return; 20 | } 21 | } 22 | } 23 | void it_swap( vector::iterator it1, vector::iterator it2 ){ 24 | *it1 = *it1^*it2; 25 | *it2 = *it1^*it2; 26 | *it1 = *it1^*it2; 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/Next_Permutation/NextPermutation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static void nextPermutation(vector &num) { 4 | //next_permutation(num.begin(), num.end()); 5 | if(num.size() < 2) return; 6 | int partion = -1; 7 | for(int i = num.size() - 1; i > 0; --i){ 8 | if(num[i-1] < num[i]){ 9 | partion = i - 1; 10 | break; 11 | } 12 | } 13 | int change = -1; 14 | if(partion != -1){ 15 | for(int i = num.size() - 1; i > 0; --i){ 16 | if(i != partion && num[i] > num[partion]){ 17 | change = i; 18 | break; 19 | } 20 | } 21 | } 22 | if(change != -1){ 23 | int c = num[partion]; 24 | num[partion] = num[change]; 25 | num[change] = c; 26 | } 27 | reverse(num.begin() + partion + 1, num.end()); 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/Number_of_1_Bits/NumberOf1Bits.cpp: -------------------------------------------------------------------------------- 1 | int hammingWeight(uint32_t n) { 2 | int count = 0; 3 | while(n){ 4 | n = n & (n - 1); 5 | ++count; 6 | } 7 | return count; 8 | } -------------------------------------------------------------------------------- /leetcode/PalindromeNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPalindrome(int x) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( x <0 ) return false; 6 | int exp = 1; 7 | while( x/exp >= 10 ){ 8 | exp *= 10; 9 | } 10 | while( x!=0 ){ 11 | int left = x/exp; 12 | int right = x%10; 13 | if( left != right ) return false; 14 | x = ( x % exp ) / 10; 15 | exp /= 100; 16 | } 17 | return true; 18 | } 19 | }; -------------------------------------------------------------------------------- /leetcode/PalindromePartitioning.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector> partition(string s) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int n = s.size(); 7 | vector< vector > ans; 8 | vector result; 9 | f( s, result, ans ); 10 | return ans; 11 | } 12 | 13 | void f( string s, vector& result, vector< vector >& ans ){ 14 | int n = s.size(); 15 | if( n==0 ){ 16 | ans.push_back(result); 17 | return; 18 | } 19 | for( int i = 1; i <= n; ++i ){ 20 | if( check(s, 0, i-1) ){ 21 | result.push_back( s.substr(0, i) ); 22 | f( s.substr( i, n-i), result, ans ); 23 | result.pop_back(); 24 | } 25 | } 26 | } 27 | bool check( string& s, int from, int to ){ 28 | int i = from; 29 | int j = to; 30 | while( i > map(n, vector(n, false) ); 7 | check( s, map ); 8 | vector dp(n, 0); 9 | dp[n-1] = 0; 10 | for( int i = n-2; i>=0; --i ){ 11 | dp[i] = n - i - 1; 12 | for( int j = i; j < n; ++j ){ 13 | if( map[i][j] ){ 14 | if( j + 1 < n && dp[j+1] + 1 < dp[i] ) 15 | dp[i] = dp[j+1] + 1; 16 | else if( j + 1 == n ){ 17 | dp[i] = 0; 18 | } 19 | } 20 | } 21 | } 22 | return dp[0]; 23 | } 24 | void check( string& s, vector< vector >& map ){ 25 | int n = s.size(); 26 | for( int i = 0; i != n; ++i ){ 27 | map[i][i] = true; 28 | if( i+1 < n && s[i]==s[i+1] ){ 29 | map[i][i+1] = true; 30 | } 31 | } 32 | for( int len = 3; len <= n; ++len ){ 33 | for( int i = 0; i < n-len+1; ++i ){ 34 | int j = i + len - 1; 35 | if( map[i+1][j-1] && s[i]==s[j] ){ 36 | map[i][j] = true; 37 | } 38 | } 39 | } 40 | } 41 | }; -------------------------------------------------------------------------------- /leetcode/Partition List.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *partition(ListNode *head, int x) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | if( head==NULL || head->next==NULL ) return head; 15 | ListNode* ptr = head; 16 | ListNode* pre = NULL, *cur = head; 17 | while( ptr != NULL ){ 18 | while( ptr->val < x ){ 19 | pre = ptr; 20 | cur = ptr->next; 21 | ptr = ptr->next; 22 | if( ptr==NULL ) break; 23 | } 24 | while( ptr != NULL && ptr->next != NULL ){ 25 | if( ptr->next->val >= x ){ 26 | ptr = ptr->next; 27 | }else{ 28 | ListNode* temp = ptr->next; 29 | ptr->next = ptr->next->next; 30 | temp->next = cur; 31 | if( pre != NULL ) pre->next = temp; 32 | else head = temp; 33 | pre = temp; 34 | } 35 | } 36 | if( ptr != NULL ) ptr = ptr->next; 37 | } 38 | return head; 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/Pascalz_Triangle/PascalsTriangle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > generate(int numRows) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector< vector > result; 6 | if( numRows<=0 ) return result; 7 | vector cur; 8 | cur.push_back(1); 9 | result.push_back(cur); 10 | for( int i = 2; i <= numRows; ++i ){ 11 | vector pre = cur; 12 | cur.clear(); 13 | cur.push_back(1); 14 | for( int j = 1; j < i-1; ++j ){ 15 | cur.push_back( pre[j-1]+pre[j] ); 16 | } 17 | cur.push_back(1); 18 | result.push_back(cur); 19 | } 20 | return result; 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /leetcode/Pascalz_Triangle_II/PascalsTriangleII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector getRow(int rowIndex) { 4 | vector ans(rowIndex + 1, 0); 5 | for(int i = 0; i <= rowIndex; ++i){ 6 | ans[0] = 1; 7 | int prev = 1; 8 | for(int j = 1; j <= i; ++j){ 9 | int cur = ans[j]; 10 | ans[j] = ans[j] + prev; 11 | prev = cur; 12 | } 13 | ans[i] = 1; 14 | } 15 | return ans; 16 | } 17 | }; 18 | -------------------------------------------------------------------------------- /leetcode/Path_Sum/PathSum.cpp: -------------------------------------------------------------------------------- 1 | //DFS 2 | /** 3 | * Definition for binary tree 4 | * struct TreeNode { 5 | * int val; 6 | * TreeNode *left; 7 | * TreeNode *right; 8 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | bool hasPathSum(TreeNode *root, int sum) { 14 | if(root == NULL) return false; 15 | if(root->left == NULL && root->right == NULL) return root->val == sum; 16 | if(root->left && hasPathSum(root->left, sum - root->val)) return true; 17 | if(root->right && hasPathSum(root->right, sum - root->val)) return true; 18 | return false; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /leetcode/Path_Sum_II/PathSumII.cpp: -------------------------------------------------------------------------------- 1 | //DFS 2 | /** 3 | * Definition for binary tree 4 | * struct TreeNode { 5 | * int val; 6 | * TreeNode *left; 7 | * TreeNode *right; 8 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 9 | * }; 10 | */ 11 | class Solution { 12 | public: 13 | void dfs(TreeNode *root, int cur, vector& arr, vector >& ans){ 14 | if(root == NULL) { 15 | return; 16 | } 17 | arr.push_back(root->val); 18 | cur = cur - root->val; 19 | 20 | if(!root->left && !root->right){ 21 | if(cur == 0){ 22 | ans.push_back(arr); 23 | } 24 | } 25 | if(root->left) dfs(root->left, cur, arr, ans); 26 | if(root->right) dfs(root->right, cur, arr, ans); 27 | arr.pop_back(); 28 | } 29 | vector > pathSum(TreeNode *root, int sum) { 30 | vector > ans; 31 | vector arr; 32 | dfs(root, sum, arr, ans); 33 | return ans; 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/Permutation Sequence.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string getPermutation(int n, int k) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int fact[10] = {1, 1, 2, 6,24,120,720,5040, 5040*8, 5040*8*9 }; 7 | vector hash(10, false); 8 | string result; 9 | --k; 10 | for(int i = n; i >= 1; --i){ 11 | int num = k/fact[i-1]; 12 | k = k%fact[i-1]; 13 | ++num; 14 | for( int j = 1; j <= n; ++j ){ 15 | if( !hash[j] ) --num; 16 | if( num==0 ){ 17 | result += j+'0'; 18 | hash[j] = true; 19 | break; 20 | } 21 | } 22 | } 23 | return result; 24 | } 25 | }; -------------------------------------------------------------------------------- /leetcode/Permutations II.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > permuteUnique(vector &num) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector > result; 6 | vector ans( num.size(), 0 ); 7 | vector visited( num.size(), 0 ); 8 | sort( num.begin(), num.end() ); 9 | dfs( result, ans, num, visited, 0 ); 10 | return result; 11 | } 12 | void dfs( vector > &result, vector&ans, vector&num, vector& visited, int k ){ 13 | if( k >= num.size() ){ 14 | result.push_back(ans); 15 | return; 16 | } 17 | for( int i = 0; i < num.size(); ++i ){ 18 | if( visited[i] ) continue; 19 | if( i >= 0 && num[i]==num[i-1] && visited[i-1] ) continue; 20 | ans[k] = num[i]; 21 | visited[i] = 1; 22 | dfs( result, ans, num, visited, k+1 ); 23 | visited[i] = 0; 24 | } 25 | } 26 | }; -------------------------------------------------------------------------------- /leetcode/Permutations.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > permute(vector &num) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | vector< vector > result; 7 | vector status( num.size(), 0 ); 8 | vector tmp( num.size(), 0 ); 9 | dfs( result, num, tmp, status, 0); 10 | return result; 11 | } 12 | void dfs( vector > & result, vector& num, vector& tmp, vector& status, int k ) 13 | { 14 | if( k==num.size() ) 15 | { 16 | result.push_back(tmp); 17 | } 18 | for( int i = 0; i != num.size();++i ) 19 | { 20 | if(status[i]==0) 21 | { 22 | tmp[k] = num[i]; 23 | status[i] = 1; 24 | dfs( result, num, tmp,status, k+1 ); 25 | status[i] = 0; 26 | } 27 | } 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/PlusOne.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector plusOne(vector &digits) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = digits.size(); 6 | if( n==0 ) return digits; 7 | digits[n-1] = digits[n-1]+1; 8 | int v = digits[n-1]/10; 9 | digits[n-1] %= 10; 10 | for( int i = n-2; i >= 0; --i ) 11 | { 12 | digits[i] += v; 13 | v = digits[i]/10; 14 | digits[i] %= 10; 15 | } 16 | if( v==0 ) return digits; 17 | digits.push_back(0); 18 | for( int i = 1; i < n+1; ++i ) 19 | { 20 | digits[i] = digits[i-1]; 21 | } 22 | digits[0] = v; 23 | return digits; 24 | } 25 | }; -------------------------------------------------------------------------------- /leetcode/Populating Next Right Pointers in Each Node_I__II.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree with next pointer. 3 | * struct TreeLinkNode { 4 | * int val; 5 | * TreeLinkNode *left, *right, *next; 6 | * TreeLinkNode(int x) : val(x), left(NULL), right(NULL), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | void connect(TreeLinkNode *root) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | if( !root ) return; 15 | vector cur, pre; 16 | cur.push_back( root ); 17 | while( !cur.empty() ){ 18 | pre = cur; 19 | cur.clear(); 20 | for( int i = 0; i < pre.size(); ++i ){ 21 | if( i+1 < pre.size() ) pre[i]->next = pre[i+1]; 22 | if( pre[i]->left ) cur.push_back( pre[i]->left ); 23 | if( pre[i]->right )cur.push_back( pre[i]->right ); 24 | } 25 | } 26 | } 27 | }; -------------------------------------------------------------------------------- /leetcode/Pow_x_n.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | double pow(double x, int n) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | if( n==1 ) return x; 7 | if( x <= 0.00000001 && x >= -0.00000001 ) return x; 8 | if( x <= 1.0+0.00000001 && x >= 1.0-0.00000001 ) return x; 9 | if( x <= -1.0+0.00000001 && x >= -1.0-0.00000001 ){ 10 | return n%2?x:1; 11 | } 12 | bool negtive = false; 13 | if( n < 0){ 14 | n = 0 - n; 15 | negtive = true; 16 | } 17 | double result = 1; 18 | double m = x; 19 | while( n ){ 20 | if( n&1 ){ 21 | result *= m; 22 | } 23 | m *= m; 24 | n >>= 1; 25 | } 26 | return !negtive?result:1/result; 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/README.md: -------------------------------------------------------------------------------- 1 | #wordladder2 2 | ##BFS,use two unordered_set to store current level and the previous level 3 | ##because the graph exists curcuit, use set to avoid dunplicating nodes 4 | # 5 | ##Marked Problems 6 | Gas Station 7 | #Tortoise and Hare Algorithm( Finding cycle in Linked list ) 8 | ##Prove: 9 | ###Length of head to cycle started node:x 10 | ###Length of the cycle: y 11 | ###Let hare run two steps while tortoise runs one step 12 | ###while both of them entered the cycle, the hare is definetly to overlap the tortoise at some node, we define it as m: 13 | The hare totally runs: x + k*y + m 14 | The tortoise totally runs: x + t*y + m 15 | Thus, k*y = 2t*y + x + m 16 | we have (x + m) mod y = 0 17 | We can conclude that if the hare run more x steps, it will reach the cycle's starting node. 18 | -------------------------------------------------------------------------------- /leetcode/Recover_Binary_Search_Tree/RecoverBinarySearchTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | void recoverTree(TreeNode *root) { 13 | if(root == NULL) return; 14 | 15 | stack q; 16 | TreeNode* n1 = NULL; 17 | TreeNode* n2 = NULL; 18 | TreeNode* pre = NULL; 19 | TreeNode* cur = root; 20 | 21 | while(!q.empty() || cur){ 22 | if(cur){ 23 | q.push(cur); 24 | cur = cur->left; 25 | }else{ 26 | cur = q.top(); 27 | q.pop(); 28 | if(pre && pre->val >= cur->val){ 29 | if(n1 == NULL) { 30 | n1 = pre; 31 | n2 = cur; 32 | }else{ 33 | n2 = cur; 34 | } 35 | } 36 | pre = cur; 37 | cur = cur->right; 38 | } 39 | } 40 | if(n1 && n2){ 41 | n1->val = n1->val + n2->val; 42 | n2->val = n1->val - n2->val; 43 | n1->val = n1->val - n2->val; 44 | } 45 | } 46 | }; 47 | -------------------------------------------------------------------------------- /leetcode/Recover_Binary_Search_Tree/readme.md: -------------------------------------------------------------------------------- 1 | When we have a sorted list of integers (assume it was in increasing order) with two elements were swapped by a error opration, we can scan it and detect where errors happend. 2 | 3 | Scan the list from left to right, and check every position if it is bigger than the former one. 4 | 5 | When we detect the first error, where D[i] <= D[i-1], we can determine that i-1 is the first error element's position.(Because the first error element is from a high place). If no further error detected, then i is the second error element's position. 6 | 7 | Because the second error element is from a lower position, so while D[i] <= D[i-1] then i is what we want. 8 | 9 | For example, [6, 3, 4, 5, 2] 10 | 11 | 3 <= 6, so 6 is the first error element 12 | 2 <= 5, so 2 is the second error element 13 | 14 | [2, 1] 15 | 16 | 1 <= 2 , so 2 is the first error element 17 | After traverse throughout the list, no more error detects, thus 1 is the second error element. 18 | 19 | The InOrder traverse of A BST is similar to scan a sorted list. 20 | 21 | 22 | -------------------------------------------------------------------------------- /leetcode/RegularExpressionMatching.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isMatch(const char *s, const char *p) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( !s || !p ) return false; 6 | if( p[0] == '\0' ) { 7 | return s[0]=='\0'; 8 | } 9 | if( p[1] == '*' ) { 10 | while( ( s[0] != '\0' && p[0] == '.' ) || s[0] == p[0] ) { 11 | if ( isMatch( s, p + 2 ) ) 12 | return true; 13 | s += 1; 14 | } 15 | return isMatch(s, p + 2); 16 | }else if( ( s[0] != '\0' && p[0] == '.' ) || s[0] == p[0] ) { 17 | return isMatch(s + 1, p + 1); 18 | } 19 | return false; 20 | } 21 | }; -------------------------------------------------------------------------------- /leetcode/Remove Duplicates from Sorted List II.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *deleteDuplicates(ListNode *head) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | if( !head || !head->next ) return head; 15 | bool unique = true; 16 | ListNode* ptr = head; 17 | ListNode* newHead = NULL; 18 | ListNode* curNode = NULL; 19 | while( ptr ){ 20 | ListNode* temp = ptr->next; 21 | if( ptr->next==NULL && unique ){ 22 | if( newHead==NULL ){ 23 | newHead = ptr; 24 | }else{ 25 | curNode->next = ptr; 26 | } 27 | break; 28 | } 29 | if( ptr->next != NULL ){ 30 | if( ptr->val == ptr->next->val ) unique = false; 31 | else{ 32 | if( unique ){ 33 | if( newHead==NULL ){ 34 | newHead = ptr; 35 | curNode = ptr; 36 | curNode->next = NULL; 37 | }else{ 38 | curNode->next = ptr; 39 | curNode = curNode->next; 40 | curNode->next = NULL; 41 | } 42 | }else unique = true; 43 | } 44 | } 45 | ptr = temp; 46 | } 47 | return newHead; 48 | } 49 | }; -------------------------------------------------------------------------------- /leetcode/RemoveDuplicatesfromSortedArray.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(int A[], int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( n==0 || n==1 ) return n; 6 | int i = 1,j = 1; 7 | while( j < n ){ 8 | if( A[j] != A[i-1] ){ 9 | A[i++] = A[j]; 10 | } 11 | ++j; 12 | } 13 | return i; 14 | } 15 | }; -------------------------------------------------------------------------------- /leetcode/RemoveDuplicatesfromSortedList.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *deleteDuplicates(ListNode *head) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( head==NULL || head->next==NULL ) return head; 14 | ListNode* pre = head; 15 | ListNode* cur = head->next; 16 | while( cur != NULL ){ 17 | if( pre->val == cur->val ){ 18 | ListNode* newCur = cur->next; 19 | pre->next = newCur; 20 | delete cur; 21 | cur = newCur; 22 | }else{ 23 | pre = cur; 24 | cur = cur->next; 25 | } 26 | } 27 | return head; 28 | } 29 | }; -------------------------------------------------------------------------------- /leetcode/RemoveNthNodeFromEndofList.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *removeNthFromEnd(ListNode *head, int n) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( n<=0 || head==NULL ) return head; 14 | 15 | ListNode* pre = head; 16 | ListNode* last = head; 17 | for( int i = 0; i < n; ++i ) 18 | { 19 | if( last->next==NULL ) 20 | { 21 | if( i==n-1 ) 22 | { 23 | ListNode* newHead = head->next; 24 | delete head; 25 | head = newHead; 26 | } 27 | return head; 28 | } 29 | last = last->next; 30 | } 31 | while( last->next != NULL ) 32 | { 33 | pre = pre->next; 34 | last = last->next; 35 | } 36 | ListNode* toDel = pre->next; 37 | pre->next = toDel->next; 38 | delete toDel; 39 | return head; 40 | } 41 | }; -------------------------------------------------------------------------------- /leetcode/Remove_Duplicates_from_Sorted_Array_II/RemoveDuplicatesfromSortedArrayII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeDuplicates(int A[], int n) { 4 | if(n <= 2) return n; 5 | int i = 0, j = 1; 6 | while(j < n){ 7 | int count = 0; 8 | while(j < n && A[j] == A[i]) { 9 | ++count; 10 | if(count == 1) A[++i] = A[j]; 11 | ++j; 12 | } 13 | if(j >= n) break; 14 | A[++i] = A[j++]; 15 | } 16 | return i + 1; 17 | } 18 | }; 19 | -------------------------------------------------------------------------------- /leetcode/Remove_Element/RemoveElement.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int removeElement(int A[], int n, int elem) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( n==0 ) return 0; 6 | if( n==1 && A[0]==elem ) return 0; 7 | int i = 0, j = 0; 8 | while( j < n ){ 9 | if( A[j] != elem ){ 10 | A[i++] = A[j]; 11 | } 12 | ++j; 13 | } 14 | return i; 15 | } 16 | }; -------------------------------------------------------------------------------- /leetcode/Remove_Linked_List_Elements/RemoveLinkedListElements.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode* removeElements(ListNode* head, int val) { 12 | ListNode* p = NULL; 13 | ListNode* q = head; 14 | while(q != NULL){ 15 | if(q->val == val){ 16 | ListNode *r = q->next; 17 | if(p == NULL){ 18 | head = q = r; 19 | }else{ 20 | p->next = r; 21 | q = r; 22 | } 23 | }else{ 24 | p = q; 25 | q = q->next; 26 | } 27 | } 28 | return head; 29 | } 30 | }; 31 | -------------------------------------------------------------------------------- /leetcode/Reorder List.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | void reorderList(ListNode *head) { 12 | // IMPORTANT: Please reset any member data you declared, as 13 | // the same Solution instance will be reused for each test case. 14 | if( !head || !head->next || !head->next->next ) return; 15 | ListNode* slow = head; 16 | ListNode* fast = head; 17 | while( fast->next != NULL ){ 18 | slow = slow->next; 19 | fast = fast->next; 20 | if( !fast->next ) break; 21 | fast = fast->next; 22 | } 23 | if( !slow || !fast ) return; 24 | 25 | ListNode* cur = slow->next; 26 | //cut down into two part from the middle 27 | slow->next = NULL; 28 | if( cur==NULL ) return; 29 | //reverse the second half 30 | ListNode* tmp = cur; 31 | ListNode* nxt = cur->next; 32 | while( nxt ){ 33 | ListNode* newCur = nxt->next; 34 | nxt->next = cur; 35 | cur = nxt; 36 | nxt = newCur; 37 | } 38 | tmp->next = NULL; 39 | //combine the two parts 40 | ListNode* preHalf = head; 41 | ListNode* nxtHalf = cur; 42 | while( preHalf && nxtHalf ){ 43 | ListNode* newPre = preHalf->next; 44 | ListNode* newNxt = nxtHalf->next; 45 | preHalf->next = nxtHalf; 46 | nxtHalf->next = newPre; 47 | preHalf = newPre; 48 | nxtHalf = newNxt; 49 | } 50 | } 51 | }; -------------------------------------------------------------------------------- /leetcode/Restore_IP_Address/RestoreIPAddress.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool detect(const string& s, int i, int j, string &val, int &num){ 4 | if(s[i] == '0' && j > i) return false; 5 | int ret = 0; 6 | int k = i; 7 | while(k <= j){ 8 | val += s[k]; 9 | ret = ret * 10 + s[k] - '0'; 10 | ++k; 11 | } 12 | num = ret; 13 | return ret >= 0 && ret <= 255; 14 | } 15 | 16 | void solve(const string& src, int i, int dot, vector& ans, string ip){ 17 | if(i >= src.size() || dot >= 4){ 18 | if(dot >= 4){ 19 | if(ip.size() - 3 == src.size()){ 20 | ans.push_back(ip); 21 | } 22 | } 23 | return; 24 | } 25 | 26 | for(int j = 0; j < 3; ++j){ 27 | if(i + j >= src.size()) break; 28 | string tip = ip; 29 | string val; 30 | int num; 31 | if(detect(src, i, i + j, val, num) ){ 32 | tip += val; 33 | if(dot < 3) tip += "."; 34 | } 35 | solve(src, i+j+1, dot+1, ans, tip); 36 | } 37 | } 38 | vector restoreIpAddresses(string s) { 39 | vector ans; 40 | if(s.size() < 4 || s.size() > 12) return ans; 41 | solve(s, 0, 0, ans, string()); 42 | return ans; 43 | } 44 | }; 45 | 46 | -------------------------------------------------------------------------------- /leetcode/ReverseInteger.cpp: -------------------------------------------------------------------------------- 1 | //integer ends with 0 2 | //may cause overflow 3 | class Solution { 4 | public: 5 | int reverse(int x) { 6 | // Note: The Solution object is instantiated only once and is reused by each test case. 7 | if( x==0 ) return x; 8 | int flag = x>0?1:-1; 9 | x *= flag; 10 | int result = 0; 11 | while( x>0 ){ 12 | result = result*10 + x%10; 13 | x = x/10; 14 | } 15 | return result*flag; 16 | } 17 | }; -------------------------------------------------------------------------------- /leetcode/ReverseNodesink-Group.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *reverseKGroup(ListNode *head, int k) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( head==NULL || head->next==NULL || k <= 1 ) return head; 14 | ListNode *curHead = head, *curLimit = head; 15 | for( int i = 0; i < k; ++i ){ 16 | if( curLimit==NULL ) return head; 17 | curLimit = curLimit->next; 18 | } 19 | ListNode *newLimit = curLimit?curLimit->next:NULL; 20 | ListNode *preTail = NULL; 21 | bool flag = false; 22 | while( curHead != NULL&& !flag ){ 23 | ListNode *curTail = curHead; 24 | ListNode *iter = curHead->next; 25 | curHead->next = NULL; 26 | while( iter != curLimit ){ 27 | ListNode *tmp = iter->next; 28 | iter->next = curHead; 29 | curHead = iter; 30 | iter = tmp; 31 | if( newLimit != NULL ) 32 | newLimit = newLimit->next; 33 | else flag = true; 34 | } 35 | if( preTail==NULL ) head = curHead; 36 | else{ 37 | preTail->next = curHead; 38 | } 39 | curHead = curLimit; 40 | curLimit = newLimit; 41 | preTail = curTail; 42 | preTail->next = curHead; 43 | if( curLimit != NULL ){ 44 | newLimit = curLimit->next; 45 | } 46 | } 47 | return head; 48 | } 49 | }; -------------------------------------------------------------------------------- /leetcode/Reverse_Bits/ReverseBits_Binary2Dec.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | uint32_t reverseBits(uint32_t n) { 4 | vector v; 5 | uint32_t ret = 0; 6 | while(n){ 7 | v.push_back(n % 2); 8 | n = n / 2; 9 | } 10 | for(int i = v.size(); i < 32; ++i) v.push_back(0); 11 | uint32_t e = 1; 12 | for(int i = v.size() - 1; i >= 0; --i){ 13 | ret += v[i] * e; 14 | e = e * 2; 15 | } 16 | return ret; 17 | } 18 | }; -------------------------------------------------------------------------------- /leetcode/Reverse_Bits/ReverseBits_BitOP.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | uint32_t reverseBits(uint32_t n) { 4 | uint32_t ret = 0; 5 | for(int i = 0; i < 32; ++i){ 6 | ret = ret << 1; 7 | ret |= (n >> i) & 1; 8 | } 9 | return ret; 10 | } 11 | }; -------------------------------------------------------------------------------- /leetcode/Reverse_Linked_list_II/ReverseLinkedListII.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *reverseBetween(ListNode *head, int m, int n) { 12 | if(head == NULL || head->next == NULL) return head; 13 | ListNode *cut = NULL, *prev = head, *cur = head->next; 14 | int count = 1; 15 | while(count < m && cur != NULL){ 16 | count++; 17 | if(cut == NULL) cut = head; 18 | else cut = cut->next; 19 | cur = cur->next; 20 | prev = prev->next; 21 | } 22 | ListNode *_head = prev; 23 | ListNode *_tail = prev; 24 | while(count < n && cur != NULL){ 25 | ListNode *_cur = cur->next; 26 | cur->next = prev; 27 | prev = cur; 28 | cur = _cur; 29 | _head = prev; 30 | count++; 31 | } 32 | if(cut == NULL){ 33 | _tail->next = cur; 34 | return _head; 35 | } 36 | cut->next = _head; 37 | _tail->next = cur; 38 | return head; 39 | 40 | } 41 | }; 42 | -------------------------------------------------------------------------------- /leetcode/Reverse_Words_in_a_String/ReverseWordsInAString.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | 1. remove extra spaces in-place using method similar to partion in quicksort 3 | 2. reverse a word (if exist) while find a space or eos 4 | 3. add a sigle space while walk into next word 5 | 6 | Actually, its a simple state machine 7 | 8 | */ 9 | void reverse(char* s, int i, int j){ 10 | while(i < j){ 11 | s[i] = s[i] + s[j]; 12 | s[j] = s[i] - s[j]; 13 | s[i] = s[i] - s[j]; 14 | ++i; 15 | --j; 16 | } 17 | } 18 | 19 | void reverseWords(char *s) { 20 | if(s == NULL || s[0] == '\0') return; 21 | int i = 0, j = -1, k = -1; 22 | 23 | bool first_space = true; 24 | bool first_word = true; 25 | 26 | while(true){ 27 | if(s[i] != ' ' && s[i] != '\0'){ 28 | if(!first_word && k == -1) s[++j] = ' '; 29 | s[++j] = s[i]; 30 | first_space = true; 31 | first_word = false; 32 | if(k == -1) k = j; 33 | }else if(first_space){ 34 | if(k != -1){ 35 | reverse(s, k, j); 36 | k = -1; 37 | } 38 | first_space = false; 39 | } 40 | if(s[i] == '\0') break; 41 | ++i; 42 | } 43 | s[++j] = '\0'; 44 | reverse(s, 0, j-1); 45 | } 46 | 47 | -------------------------------------------------------------------------------- /leetcode/Roman_to_Integer/RomantoInteger.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int romanToInt(string s) { 4 | int base[26]; 5 | base['I' - 'A'] = 1; 6 | base['V' - 'A'] = 5; 7 | base['X' - 'A'] = 10; 8 | base['L' - 'A'] = 50; 9 | base['C' - 'A'] = 100; 10 | base['D' - 'A'] = 500; 11 | base['M' - 'A'] = 1000; 12 | int n = s.size(); 13 | int ans = 0; 14 | for(int i = n-1; i >= 0; --i){ 15 | if(i+1 >= n || base[s[i] - 'A'] >= base[s[i+1] - 'A']){ 16 | ans += base[s[i] - 'A']; 17 | }else{ 18 | ans -= base[s[i] - 'A']; 19 | } 20 | } 21 | return ans; 22 | } 23 | }; 24 | -------------------------------------------------------------------------------- /leetcode/Rotate Image.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | (i,i)----------(i,n-i-1) 3 | | | 4 | | | 5 | | | 6 | (n-i-1, i)-----(n-i-1, n-i-1) 7 | 8 | ( i,j )----------( j, n-i-1 ) 9 | | | 10 | | | 11 | | | 12 | | | 13 | ( n-j-1, i )----------(n-i-1, n-j-1) 14 | 15 | 16 | */ 17 | 18 | class Solution { 19 | public: 20 | void rotate(vector > &matrix) { 21 | // IMPORTANT: Please reset any member data you declared, as 22 | // the same Solution instance will be reused for each test case. 23 | int n = matrix.size(); 24 | for( int i = 0; i < n/2; ++i ){ 25 | for( int j = i; j < n-1-i; ++j ){ 26 | int temp = matrix[i][j]; 27 | matrix[i][j] = matrix[n-1-j][i]; 28 | matrix[n-1-j][i] = matrix[n-1-i][n-1-j]; 29 | matrix[n-1-i][n-1-j] = matrix[j][n-1-i]; 30 | matrix[j][n-1-i] = temp; 31 | } 32 | } 33 | } 34 | }; -------------------------------------------------------------------------------- /leetcode/RotateList.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *rotateRight(ListNode *head, int k) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( head==NULL || k == 0 ) return head; 14 | ListNode* pre; 15 | ListNode* post; 16 | pre = post = head; 17 | for( int i = 0; i != k ; ++i ){ 18 | if( post == NULL ){ 19 | post = head; 20 | } 21 | post = post->next; 22 | } 23 | if( post==NULL ) return head; 24 | while( post->next != NULL ){ 25 | pre = pre->next; 26 | post = post->next; 27 | } 28 | ListNode *newHead = pre->next; 29 | pre->next = NULL; 30 | post->next = head; 31 | head = newHead; 32 | return newHead; 33 | } 34 | }; -------------------------------------------------------------------------------- /leetcode/Rotate_Array/RotateArray_dc.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void reverse(int nums[], int low, int high){ 4 | int i = low, j = high; 5 | while(i < j){ 6 | nums[i] = nums[i] + nums[j]; 7 | nums[j] = nums[i] - nums[j]; 8 | nums[i] = nums[i] - nums[j]; 9 | ++i; 10 | --j; 11 | } 12 | } 13 | 14 | void rotate(int nums[], int n, int k) { 15 | if(n == 1 || k == 0) return; 16 | k = k % n; 17 | if(k == 0) return; 18 | reverse(nums, 0, n - 1); 19 | reverse(nums, 0, k - 1); 20 | reverse(nums, k, n - 1); 21 | } 22 | }; 23 | -------------------------------------------------------------------------------- /leetcode/Same_Tree/SameTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isSameTree(TreeNode *p, TreeNode *q) { 13 | // Note: The Solution object is instantiated only once and is reused by each test case. 14 | if( p==q ) return true; 15 | if( p==NULL || q==NULL ) return false; 16 | if( p->val != q->val ) return false; 17 | return isSameTree( p->left, q->left )&&isSameTree( p->right, q->right ); 18 | } 19 | }; -------------------------------------------------------------------------------- /leetcode/Same_Tree/SameTree_use-stack.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isSameTree(TreeNode *p, TreeNode *q) { 13 | if( p == q ) return true; 14 | if( p == NULL || q == NULL ) return false; 15 | stack stk; 16 | stk.push(p); 17 | stk.push(q); 18 | while(!stk.empty()){ 19 | TreeNode *_p = stk.top(); stk.pop(); 20 | TreeNode *_q = stk.top(); stk.pop(); 21 | 22 | if( !_p && !_q) continue; 23 | if( !_p || !_q) return false; 24 | 25 | if(_p->val != _q->val){ 26 | return false; 27 | } 28 | stk.push(_p->left); stk.push(_q->left); 29 | stk.push(_p->right); stk.push(_q->right); 30 | } 31 | return true; 32 | } 33 | }; 34 | -------------------------------------------------------------------------------- /leetcode/Search a 2D Matrix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool searchMatrix(vector > &matrix, int target) { 4 | int n = matrix.size(); 5 | int m = matrix.front().size(); 6 | int low = 0; 7 | int high = m*n-1; 8 | while( low <= high ) 9 | { 10 | int mid = low + (high - low)/2; 11 | if( matrix[mid/m][mid%m] == target ) return true; 12 | if( matrix[mid/m][mid%m] > target){ 13 | high = mid - 1; 14 | }else{ 15 | low = mid + 1; 16 | } 17 | } 18 | return false; 19 | } 20 | }; -------------------------------------------------------------------------------- /leetcode/Search_For_A_Range/SearchForARange.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int low_bound(int A[], int n, int target){ 4 | int low = 0, high = n - 1; 5 | while(low <= high){ 6 | int mid = low + (high - low) / 2; 7 | if(A[mid] == target){ 8 | high = mid; 9 | if(low == high) break; 10 | }else if(A[mid] > target){ 11 | high = mid - 1; 12 | }else{ 13 | low = mid + 1; 14 | } 15 | } 16 | if(high != low) return -1; 17 | return low; 18 | } 19 | 20 | int high_bound(int A[], int n, int target){ 21 | int low = 0, high = n - 1; 22 | while(low <= high){ 23 | int mid = low + (high - low) / 2; 24 | if(A[mid] == target){ 25 | low = mid + 1; 26 | }else if(A[mid] > target){ 27 | high = mid - 1; 28 | }else{ 29 | low = mid + 1; 30 | } 31 | } 32 | if(low - 1 < 0 || A[low-1] != target) return -1; 33 | return low - 1; 34 | } 35 | 36 | vector searchRange(int A[], int n, int target) { 37 | vector ans; 38 | ans.push_back(low_bound(A, n, target)); 39 | ans.push_back(high_bound(A, n, target)); 40 | return ans; 41 | } 42 | }; 43 | -------------------------------------------------------------------------------- /leetcode/Search_Insert_Position/SearchInsertPosition.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int searchInsert(int A[], int n, int target) { 4 | int low = 0, high = n - 1; 5 | while(low <= high){ 6 | int mid = low + (high - low) / 2; 7 | if(A[mid] == target){ 8 | high = mid; 9 | if(high == low){ 10 | break; 11 | } 12 | }else if (A[mid] > target){ 13 | high = mid - 1; 14 | }else{ 15 | low = mid + 1; 16 | } 17 | } 18 | return low; 19 | } 20 | }; 21 | -------------------------------------------------------------------------------- /leetcode/Search_in_Rotated_Sorted_Array/SearchinRotatedSortedArray.cpp: -------------------------------------------------------------------------------- 1 | int search(int A[], int n, int target) { 2 | int low = 0, high = n - 1; 3 | while(low <= high){ 4 | int mid = (low + high) / 2; 5 | if(A[mid] == target) return mid; 6 | if(A[mid] > A[high]){ 7 | if(target > A[high] && target < A[mid]){ 8 | high = mid - 1; 9 | }else{ 10 | low = mid + 1; 11 | } 12 | }else{ 13 | if(target > A[mid] && target <= A[high]){ 14 | low = mid + 1; 15 | }else{ 16 | high = mid - 1; 17 | } 18 | } 19 | } 20 | return -1; 21 | } 22 | -------------------------------------------------------------------------------- /leetcode/Search_in_Rotated_Sorted_Array_II/SearchinRotatedSortedArrayII.cpp: -------------------------------------------------------------------------------- 1 | bool search(int A[], int n, int target) { 2 | int low = 0, high = n - 1; 3 | while(low <= high){ 4 | int mid = (low + high) / 2; 5 | if(A[mid] == target) return true; 6 | if(A[mid] > A[high]){ 7 | if(target >= A[low] && target < A[mid]){ 8 | high = mid - 1; 9 | }else{ 10 | low = mid + 1; 11 | } 12 | }else if(A[mid] == A[high]){ 13 | high--; 14 | }else{ 15 | if(target > A[mid] && target <= A[high]){ 16 | low = mid + 1; 17 | }else{ 18 | high = mid - 1; 19 | } 20 | } 21 | } 22 | return false; 23 | } 24 | -------------------------------------------------------------------------------- /leetcode/Set_Matrix_Zeroes/SetMatrixZeroes_BruteForce.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void setZeroes(vector > &matrix) { 4 | int n = matrix.size(); 5 | if(n < 1) return; 6 | int m = matrix[0].size(); 7 | vector > flag(n, vector(m, false)); 8 | for(int i = 0; i < n; ++i){ 9 | for (int j = 0; j < m; ++j){ 10 | if (matrix[i][j] == 0){ 11 | flag[i][j] = true; 12 | } 13 | } 14 | } 15 | for(int i = 0; i < n; ++i){ 16 | for(int j = 0; j < m; ++j){ 17 | if(matrix[i][j] == 0 && flag[i][j]){ 18 | for(int k = 0; k < m; ++k){ 19 | matrix[i][k] = 0; 20 | } 21 | for(int k = 0; k < n; ++k){ 22 | matrix[k][j] = 0; 23 | } 24 | } 25 | } 26 | } 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/Set_Matrix_Zeroes/SetMatrixZeroes_ConstantSpace.cpp: -------------------------------------------------------------------------------- 1 | // O(1) Space complexity, use the first zero as pivot to record if a col or row need to be set zero 2 | class Solution { 3 | public: 4 | void setZeroes(vector > &matrix) { 5 | int n = matrix.size(); 6 | if(n < 1) return; 7 | int m = matrix[0].size(); 8 | int x = -1, y = -1; 9 | for(int i = 0; i < n; ++i){ 10 | for(int j = 0; j < m; ++j){ 11 | if(matrix[i][j] == 0){ 12 | if(x == -1 && y == -1){ 13 | x = i; 14 | y = j; 15 | }else{ 16 | matrix[x][j] = 0; 17 | matrix[i][y] = 0; 18 | } 19 | } 20 | } 21 | } 22 | if(x == -1 && y == -1) return; 23 | for(int i = 0; i < n; ++i){ 24 | if(i == x) continue; 25 | for(int j = 0; j < m; ++j){ 26 | if(j == y) continue; 27 | if(matrix[x][j] == 0 || matrix[i][y] == 0){ 28 | matrix[i][j] = 0; 29 | } 30 | } 31 | } 32 | for(int i = 0; i < n; ++i) matrix[i][y] = 0; 33 | for(int j = 0; j < m; ++j) matrix[x][j] = 0; 34 | } 35 | }; -------------------------------------------------------------------------------- /leetcode/Set_Matrix_Zeroes/SetMatrixZeroes_LessSpace.cpp: -------------------------------------------------------------------------------- 1 | // use O(m + n) space to record the zero positions 2 | // if zero number is bigger than m+n, the matrix should be set to a pure zero matrix 3 | class Solution { 4 | public: 5 | void setZeroes(vector > &matrix) { 6 | int n = matrix.size(); 7 | if(n < 1) return; 8 | int m = matrix[0].size(); 9 | vector zeroes(m + n, -1); 10 | int count = 0; 11 | for(int i = 0; i < n; ++i){ 12 | for(int j = 0; j < m; ++j){ 13 | if(matrix[i][j] == 0){ 14 | if(count >= m + n) break; 15 | rec[count++] = i * m + j; 16 | } 17 | } 18 | } 19 | for(int i = 0; i < count; ++i){ 20 | int x = rec[i] / m; 21 | int y = rec[i] % m; 22 | for(int j = 0; j < m; ++j){ 23 | matrix[x][j] = 0; 24 | } 25 | for(int j = 0; j < n; ++j){ 26 | matrix[j][y] = 0; 27 | } 28 | } 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/Single_Number/SingleNumber.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int singleNumber(int A[], int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int result = A[0]; 6 | for( int i = 1; i < n; ++i ){ 7 | result ^= A[i]; 8 | } 9 | return result; 10 | } 11 | }; -------------------------------------------------------------------------------- /leetcode/Single_Number_II/SingleNumberII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int singleNumber(int A[], int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int one = 0, two = 0, three = 0; 6 | for( int i = 0; i < n; ++i ){ 7 | two |= ( one & A[i] ); 8 | one ^= A[i]; 9 | three = one&two; 10 | one &= ~three; 11 | two &= ~three; 12 | } 13 | return one; 14 | } 15 | }; -------------------------------------------------------------------------------- /leetcode/Spiral Matrix II.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > generateMatrix(int n) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | if( n==0 ) return vector< vector >(); 7 | vector< vector > matrix( n, vector(n, -1) ); 8 | int x = 0, y = 0; 9 | int cur = 1; 10 | matrix[0][0] = 1; 11 | while( cur < n*n ){ 12 | //right 13 | while( y+1 < n && matrix[x][y+1] == -1 ){ 14 | matrix[ x ][ ++y ] = ++cur; 15 | } 16 | //down 17 | while( x+1 < n && matrix[x+1][y] == -1 ){ 18 | matrix[++x][y] = ++cur; 19 | } 20 | //left 21 | while( y-1 >= 0 && matrix[x][y-1] == -1 ){ 22 | matrix[x][--y] = ++cur; 23 | } 24 | //up 25 | while(x-1 >= 0 && matrix[x-1][y] == -1 ){ 26 | matrix[--x][y] = ++cur; 27 | } 28 | } 29 | return matrix; 30 | } 31 | }; -------------------------------------------------------------------------------- /leetcode/Spiral Matrix.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector spiralOrder(vector > &matrix) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | int n = matrix.size(); 7 | if( n==1 ) return matrix[0]; 8 | vector result; 9 | if( n==0 ) return result; 10 | int m = matrix[0].size(); 11 | if( m==0 ) return result; 12 | if( m==1 ){ 13 | for( int i = 0; i < n; ++i ) 14 | result.push_back( matrix[i][0]); 15 | return result; 16 | } 17 | int circleNum = ( min(n, m)+1 )/2; 18 | for( int i = 0; i < circleNum; ++i ){ 19 | if( result.size()==n*m-1 ){ 20 | result.push_back( matrix[i][i] ); 21 | break; 22 | } 23 | //right 24 | for( int j = i; j < m-i-1; ++j ){ 25 | result.push_back( matrix[i][j] ); 26 | } 27 | //down 28 | for( int j = i; j < n-i-1; ++j ){ 29 | result.push_back( matrix[j][m-i-1] ); 30 | } 31 | //left 32 | for( int j = m-i-1; j > i; --j ){ 33 | result.push_back( matrix[n-i-1][j] ); 34 | } 35 | //up 36 | for( int j = n-i-1; j > i; --j ){ 37 | result.push_back( matrix[j][i] ); 38 | } 39 | } 40 | return result; 41 | } 42 | }; -------------------------------------------------------------------------------- /leetcode/Sqrt_x.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int sqrt(int x) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( x < 2 ) return x; 6 | int from = 1, to = x/2; 7 | int cur = 1; 8 | while( from <= to ){ 9 | cur = from + (to-from)/2; 10 | if( x/cur > cur ){ 11 | from = cur+1; 12 | }else if( x/cur < cur ){ 13 | to = cur-1; 14 | }else { return cur; } 15 | } 16 | return from-1; 17 | } 18 | }; -------------------------------------------------------------------------------- /leetcode/StringtoInteger.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int atoi(const char *str) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | if( str==NULL ) return 0; 6 | const char* cur = str; 7 | while( *cur==' ') ++cur; 8 | if( *cur=='\0' ) return 0; 9 | int flag = 1; 10 | if( *cur=='-' ) { 11 | flag = -1; 12 | ++cur; 13 | }else if( *cur=='+' ){ 14 | ++cur; 15 | } 16 | long long result = 0; 17 | while( *cur != '\0' ){ 18 | if( *cur < '0' || *cur > '9' ) break; 19 | result = result*10 + *cur - '0'; 20 | ++cur; 21 | } 22 | result *= flag; 23 | if( result >= INT_MAX ) return INT_MAX; 24 | if( result <= INT_MIN ) return INT_MIN; 25 | return result; 26 | } 27 | }; -------------------------------------------------------------------------------- /leetcode/Subsets.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > subsets(vector &S) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector< vector > result; 6 | vector cur; 7 | result.push_back(cur); 8 | if( S.empty() ) return result; 9 | unordered_set hash; 10 | dfs( S, hash, result, cur, 0 ); 11 | return result; 12 | } 13 | void dfs( vector& S, unordered_set&hash, vector< vector >&result, vector&cur, int k ){ 14 | if( k > S.size() ) return; 15 | if( k > 0 ) result.push_back(cur); 16 | int n = S.size(); 17 | for( int i = 0; i < n; ++i ){ 18 | if( (k==0||S[i] >= cur[k-1]) && hash.find(S[i]) == hash.end() ){ 19 | hash.insert( S[i] ); 20 | cur.push_back(S[i]); 21 | dfs(S, hash, result, cur, k+1); 22 | cur.pop_back(); 23 | hash.erase( S[i] ); 24 | } 25 | } 26 | } 27 | }; -------------------------------------------------------------------------------- /leetcode/SubsetsII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector > subsetsWithDup(vector &S) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector< vector >result; 6 | vector cur; 7 | result.push_back(cur); 8 | int n = S.size(); 9 | if( n==0 ) return result; 10 | unordered_set hash; 11 | set< vector > rec; 12 | dfs( S, hash, result, cur, 0 ,rec ); 13 | return result; 14 | } 15 | void dfs( vector& S, unordered_set& hash, 16 | vector< vector >&result, vector& cur, int k, set< vector >& rec ){ 17 | if( k > S.size() ) return; 18 | if( k > 0 ){ 19 | if( rec.find(cur)!=rec.end() ){ 20 | return; 21 | } 22 | rec.insert(cur); 23 | result.push_back(cur); 24 | } 25 | int n = S.size(); 26 | for( int i = 0; i < n; ++i ){ 27 | if( (k==0 || S[i]>=cur[k-1]) && hash.find(i)==hash.end() ){ 28 | hash.insert(i); 29 | cur.push_back(S[i]); 30 | dfs( S, hash, result, cur, k+1,rec); 31 | hash.erase(i); 32 | cur.pop_back(); 33 | } 34 | } 35 | } 36 | }; -------------------------------------------------------------------------------- /leetcode/SubstringwithConcatenationofAllWords.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector findSubstring(string S, vector &L) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = S.size(); 6 | int m = L.size(); 7 | int wordLen = L[0].size(); 8 | vector result; 9 | unordered_map< string, int > dict; 10 | unordered_map< string, int > curr; 11 | for( int i = 0; i < m; ++i ){ 12 | ++dict[ L[i] ]; 13 | } 14 | for( int i = 0; i <= n-m*wordLen; i++ ){ 15 | curr.clear(); 16 | bool found = true; 17 | for( int j = 0; j < m; ++j ){ 18 | string str = S.substr( i+j*wordLen, wordLen ); 19 | if( dict.find(str)==dict.end() ){ 20 | found = false; 21 | break; 22 | } 23 | ++curr[str]; 24 | if( curr[str] > dict[str] ){ 25 | found = false; 26 | break; 27 | } 28 | } 29 | if( found ){ 30 | result.push_back(i); 31 | } 32 | } 33 | return result; 34 | 35 | } 36 | }; -------------------------------------------------------------------------------- /leetcode/Sudoku Solver.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void solveSudoku(vector > &board) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector row(10, 0); 6 | vector col(10, 0); 7 | vector block(10, 0); 8 | vector needFill; 9 | for( int i = 0; i < 9; ++i ){ 10 | for( int j = 0; j < 9; ++j ){ 11 | if( board[i][j] != '.' ) { 12 | int c = board[i][j]-'0'; 13 | row[i] |= (1< > &board, vector&row, vector&col, vector&block,vector& needFill, int k ){ 24 | if( k >= needFill.size() ) return true; 25 | int x = needFill[k]/9, y = needFill[k]%9; 26 | for( int i = 1; i <= 9; ++i ){ 27 | if( row[x]&(1<val; 23 | if( root->left==NULL && root->right==NULL ){ 24 | sum += cur; 25 | return; 26 | } 27 | dfs( root->left, cur, sum ); 28 | dfs( root->right, cur, sum ); 29 | } 30 | }; -------------------------------------------------------------------------------- /leetcode/SwapNodesinPairs.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for singly-linked list. 3 | * struct ListNode { 4 | * int val; 5 | * ListNode *next; 6 | * ListNode(int x) : val(x), next(NULL) {} 7 | * }; 8 | */ 9 | class Solution { 10 | public: 11 | ListNode *swapPairs(ListNode *head) { 12 | // Note: The Solution object is instantiated only once and is reused by each test case. 13 | if( head==NULL || head->next ==NULL ) return head; 14 | ListNode* first = head, *second = head->next; 15 | ListNode* iter = second->next; 16 | ListNode* pre = NULL; 17 | while( first != NULL ) 18 | { 19 | if( second==NULL ) break; 20 | second->next = first; 21 | first->next = iter; 22 | if( pre==NULL ) { 23 | head = second; 24 | } else{ 25 | pre->next = second; 26 | } 27 | pre = first; 28 | first = iter; 29 | if( iter != NULL ){ 30 | second = iter->next; 31 | } 32 | if( second != NULL ){ 33 | iter = second->next; 34 | }else iter = NULL; 35 | } 36 | return head; 37 | } 38 | }; -------------------------------------------------------------------------------- /leetcode/SymmetricTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isSymmetric(TreeNode *root) { 13 | // Note: The Solution object is instantiated only once and is reused by each test case. 14 | if(root==NULL) return true; 15 | vector cur; 16 | vector pre; 17 | vector val; 18 | cur.push_back(root); 19 | val.push_back( root->val ); 20 | while( !cur.empty() ){ 21 | if( !check(val) ) return false; 22 | pre = cur; 23 | cur.clear(); 24 | val.clear(); 25 | for( int i = 0; i < pre.size(); ++i ){ 26 | if( pre[i]->left ){ 27 | cur.push_back(pre[i]->left); 28 | val.push_back(pre[i]->left->val); 29 | }else val.push_back(0); 30 | if( pre[i]->right ){ 31 | cur.push_back(pre[i]->right); 32 | val.push_back(pre[i]->right->val); 33 | }else val.push_back(0); 34 | } 35 | } 36 | return true; 37 | } 38 | bool check( vector & vec ){ 39 | int i = 0; 40 | int j = vec.size()-1; 41 | while( i < j ){ 42 | if( vec[i] != vec[j] ) return false; 43 | ++i; 44 | --j; 45 | } 46 | return true; 47 | } 48 | }; -------------------------------------------------------------------------------- /leetcode/Trapping Rain Water.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int trap(int A[], int n) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | if( n <= 2 ) return 0; 7 | int sum = 0; 8 | //from left to right 9 | int cur = 0; 10 | while( cur < n && A[cur]==0 ) ++cur; 11 | if( cur >= n ) return 0; 12 | while( cur < n ){ 13 | int curWater = 0; 14 | int curHeight = A[cur]; 15 | while( ++cur < n ){ 16 | if( A[cur] >= curHeight ) break; 17 | curWater += ( curHeight - A[cur] ); 18 | } 19 | if( cur < n && A[cur] >= curHeight ) sum += curWater; 20 | else ++cur; 21 | } 22 | //from right to left 23 | cur = n-1; 24 | while( cur >= 0 && A[cur]==0 ) --cur; 25 | while( cur >= 0 ){ 26 | int curWater = 0; 27 | int curHeight = A[cur]; 28 | while( --cur >= 0 ){ 29 | if( A[cur] > curHeight ) break; 30 | curWater += ( curHeight-A[cur] ); 31 | } 32 | if( cur >= 0 && A[cur] > curHeight ) sum += curWater; 33 | else --cur; 34 | } 35 | return sum; 36 | } 37 | }; -------------------------------------------------------------------------------- /leetcode/Triangle.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | static int minimumTotal(vector > &triangle) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int n = triangle.size(); 7 | if(n==1) return triangle[0][0]; 8 | vector< int > dp( n,0 ); 9 | dp[0] = triangle[0][0]; 10 | int pre = dp[0]; 11 | int min = 0; 12 | for( int i = 1; i != n; ++i ){ 13 | for( int j = 0; j != triangle[i].size(); ++j ){ 14 | if( j == 0 ){ 15 | pre = dp[j]; 16 | dp[j] = dp[j] + triangle[i][j]; 17 | }else if( j == triangle[i].size()-1 ){ 18 | int tmp = dp[j]; 19 | dp[j] = pre + triangle[i][j]; 20 | pre = tmp; 21 | }else if( pre+triangle[i][j] < dp[j]+triangle[i][j] ){ 22 | int tmp = dp[j]; 23 | dp[j] = pre+triangle[i][j]; 24 | pre = tmp; 25 | }else{ 26 | int tmp = dp[j]; 27 | dp[j] = dp[j]+triangle[i][j]; 28 | pre = tmp; 29 | } 30 | if( i==n-1 ){ 31 | if( j==0 ) min = dp[0]; 32 | if( dp[j] < min ){ 33 | min = dp[j]; 34 | } 35 | } 36 | } 37 | } 38 | return min; 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/Triangle_MoreSpaceCost.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int minimumTotal(vector > &triangle) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int n = triangle.size(); 7 | if(n==1) return triangle[0][0]; 8 | vector< vector > dp( n, vector(n,0) ); 9 | dp[0][0] = triangle[0][0]; 10 | int min = 0; 11 | for( int i = 1; i != n; ++i ){ 12 | for( int j = 0; j != triangle[i].size(); ++j ){ 13 | if( j == 0 ){ 14 | dp[i][j] = dp[i-1][j] + triangle[i][j]; 15 | }else if( j == triangle[i].size()-1 ){ 16 | dp[i][j] = dp[i-1][j-1] + triangle[i][j]; 17 | }else if( dp[i-1][j]+triangle[i][j] < dp[i-1][j-1]+triangle[i][j] ){ 18 | dp[i][j] = dp[i-1][j]+triangle[i][j]; 19 | }else{ 20 | dp[i][j] = dp[i-1][j-1]+triangle[i][j]; 21 | } 22 | if( i==n-1 ){ 23 | if( j==0 ) min = dp[i][j]; 24 | if( dp[i][j] < min ){ 25 | min = dp[i][j]; 26 | } 27 | } 28 | } 29 | } 30 | return min; 31 | } 32 | }; -------------------------------------------------------------------------------- /leetcode/Two_Sum/TwoSum_BruteForce.cpp: -------------------------------------------------------------------------------- 1 | # This solution will TLE 2 | 3 | class Solution { 4 | public: 5 | vector twoSum(vector &numbers, int target) { 6 | vector result; 7 | for(int i = 0; i < numbers.size(); ++i){ 8 | for(int j = i + 1; j < numbers.size(); ++j){ 9 | if(numbers[i] + numbers[j] == target){ 10 | result.push_back(i + 1); 11 | result.push_back(j + 1); 12 | break; 13 | } 14 | } 15 | } 16 | return result; 17 | } 18 | }; -------------------------------------------------------------------------------- /leetcode/Two_Sum/TwoSum_Hash.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector &numbers, int target) { 4 | unordered_map occur; 5 | vector result; 6 | for(int i = 0; i < numbers.size(); ++i){ 7 | if(occur.find(target - numbers[i]) != occur.end()){ 8 | result.push_back(occur[target - numbers[i]] + 1); 9 | result.push_back(i + 1); 10 | break; 11 | } 12 | occur[numbers[i]] = i; 13 | } 14 | return result; 15 | } 16 | }; -------------------------------------------------------------------------------- /leetcode/Two_Sum/TwoSum_Sort.cpp: -------------------------------------------------------------------------------- 1 | 2 | class Solution { 3 | public: 4 | static bool cmp(pair &a, pair& b){ 5 | return a.first < b.first; 6 | } 7 | vector twoSum(vector &numbers, int target) { 8 | vector result; 9 | vector< pair > data; 10 | for(int i = 0; i < numbers.size(); ++i){ 11 | data.push_back(pair(numbers[i], i+1)); 12 | } 13 | sort(data.begin(), data.end(), Solution::cmp); 14 | int i = 0, j = data.size() - 1; 15 | while(i < j){ 16 | if(data[i].first + data[j].first == target){ 17 | if(data[i].second > data[j].second){ 18 | result.push_back(data[j].second); 19 | result.push_back(data[i].second); 20 | }else{ 21 | result.push_back(data[i].second); 22 | result.push_back(data[j].second); 23 | } 24 | break; 25 | }else if(data[i].first + data[j].first > target){ 26 | --j; 27 | }else{ 28 | ++i; 29 | } 30 | } 31 | return result; 32 | } 33 | }; -------------------------------------------------------------------------------- /leetcode/Unique Binary Search Trees II.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | vector generateTrees(int n) { 13 | // IMPORTANT: Please reset any member data you declared, as 14 | // the same Solution instance will be reused for each test case. 15 | return CreateBST( 1, n ); 16 | 17 | } 18 | vector CreateBST( int _from, int _to ){ 19 | vector result; 20 | if( _from > _to ) { 21 | result.push_back(NULL); 22 | return result; 23 | }; 24 | if( _from == _to ){ 25 | result.push_back( new TreeNode(_from) ); 26 | return result; 27 | } 28 | for( int i = _from; i <= _to; ++i ){ 29 | vector leftTrees = CreateBST( _from, i-1 ); 30 | vector rightTrees = CreateBST( i+1, _to ); 31 | for( int j = 0; j < leftTrees.size(); ++j ){ 32 | for( int k = 0; k < rightTrees.size(); ++k ){ 33 | TreeNode* cur = new TreeNode(i); 34 | cur->left = leftTrees[j]; 35 | cur->right = rightTrees[k]; 36 | result.push_back(cur); 37 | } 38 | } 39 | } 40 | return result; 41 | } 42 | }; -------------------------------------------------------------------------------- /leetcode/UniqueBinarySearchTrees.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int numTrees(int n) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int ret = 1; 6 | for( int i = 1; i <= n; ++i ){ 7 | ret = ret*2*(2*(i-1)+1)/(i-1+2); 8 | } 9 | return ret; 10 | } 11 | }; -------------------------------------------------------------------------------- /leetcode/UniquePaths.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int uniquePaths(int m, int n) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | if( m==0 || n==0 ) return 0; 7 | vector< vector > dp( m, vector(n, 0) ); 8 | dp[0][0] = 1; 9 | for( int i = 1; i != n; ++i ){ 10 | dp[0][i] = 1; 11 | } 12 | for( int i = 1; i != m; ++i ){ 13 | dp[i][0] = 1; 14 | } 15 | for( int i = 1; i != m; ++i ){ 16 | for( int j = 1; j != n; ++j ){ 17 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 18 | } 19 | } 20 | return dp[m-1][n-1]; 21 | } 22 | }; -------------------------------------------------------------------------------- /leetcode/UniquePathsII.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int uniquePathsWithObstacles(vector > &obstacleGrid) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | int m = obstacleGrid.size(); 7 | int n = obstacleGrid[0].size(); 8 | if( m==0 || n==0 || obstacleGrid[0][0] ) return 0; 9 | vector< vector > dp( m, vector(n, 0) ); 10 | dp[0][0] = 1; 11 | for( int i = 1; i != n; ++i ){ 12 | dp[0][i] = (obstacleGrid[0][i]>0||!dp[0][i-1])?0:1; 13 | } 14 | for( int i = 1; i != m; ++i ){ 15 | dp[i][0] = (obstacleGrid[i][0]>0||!dp[i-1][0])?0:1; 16 | } 17 | for( int i = 1; i != m; ++i ){ 18 | for( int j = 1; j != n; ++j ){ 19 | if( obstacleGrid[i][j] || (obstacleGrid[i-1][j]&&obstacleGrid[i][j-1]) ){ 20 | dp[i][j] = 0; 21 | }else{ 22 | dp[i][j] = dp[i-1][j] + dp[i][j-1]; 23 | } 24 | } 25 | } 26 | return dp[m-1][n-1]; 27 | } 28 | }; -------------------------------------------------------------------------------- /leetcode/Valid Sudoku.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isValidSudoku(vector > &board) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | unordered_set visited; 6 | for( int i = 0; i < 9; ++i ){ 7 | visited.clear(); 8 | for( int j = 0; j < 9; ++j ){ 9 | if( board[i][j] <'0' || board[i][j] > '9') continue; 10 | if( visited.find(board[i][j]) != visited.end() ) return false; 11 | visited.insert( board[i][j] ); 12 | } 13 | visited.clear(); 14 | for( int j = 0; j < 9; ++j ){ 15 | if( board[j][i] <'0' || board[j][i] > '9') continue; 16 | if( visited.find(board[j][i]) != visited.end() ) return false; 17 | visited.insert( board[j][i] ); 18 | } 19 | } 20 | for( int i = 0; i < 3; ++i ){ 21 | for( int j = 0; j < 3; ++j ){ 22 | visited.clear(); 23 | for( int p = 0; p < 3; ++p ){ 24 | for( int q = 0; q < 3; ++q ){ 25 | int x = 3*i+p; 26 | int y = 3*j+q; 27 | if( board[x][y] <'0' || board[x][y] > '9') continue; 28 | if( visited.find(board[x][y]) != visited.end() ) return false; 29 | visited.insert( board[x][y] ); 30 | } 31 | } 32 | } 33 | } 34 | return true; 35 | } 36 | }; -------------------------------------------------------------------------------- /leetcode/Valid Sudoku_SolveWithBitManiputation.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isValidSudoku(vector > &board) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | vector row( 10, 0 ); 6 | vector col( 10, 0 ); 7 | vector block( 10, 0 ); 8 | for( int i = 0; i < 9; ++i ){ 9 | for( int j = 0; j < 9; ++j ){ 10 | if( board[i][j] <'0' || board[i][j] > '9') continue; 11 | int cur = board[i][j]-'0'; 12 | if( row[cur]&(1<= '0' && s[i] <= '9' ) 30 | ct = DIGIT; 31 | if( s[i] == '+' || s[i] == '-' ) 32 | ct = SIGNED; 33 | if( s[i] == '.' ) 34 | ct = DOT; 35 | if( s[i] == 'E' || s[i]=='e' ) 36 | ct = EXP; 37 | if( s[i]==' ' ) 38 | ct = SPACE; 39 | state = stateTable[state][ct]; 40 | if( state == -1 ) return false; 41 | } 42 | if( state==1 || state==4 || state==7 || state==8 ) return true; 43 | return false; 44 | } 45 | }; -------------------------------------------------------------------------------- /leetcode/ValidPalindrome.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isPalindrome(string s) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int from = 0; 6 | int to = s.size()-1; 7 | while( from < to ){ 8 | if( !isAlpha(s[from]) ){ 9 | ++from; 10 | continue; 11 | } 12 | if( !isAlpha( s[to] ) ){ 13 | --to; 14 | continue; 15 | } 16 | if( f(s[from]) != f(s[to]) ){ 17 | return false; 18 | } 19 | ++from; 20 | --to; 21 | } 22 | return true; 23 | } 24 | bool isAlpha( char c ){ 25 | if( c >= 'a' && c <= 'z'){ 26 | return true; 27 | }else if( c >= 'A' && c <= 'Z' ){ 28 | return true; 29 | }else if( c >= '0' && c <= '9' ){ 30 | return true; 31 | } 32 | return false; 33 | } 34 | char f( char c ){ 35 | if( c >= 'a' && c <= 'z'){ 36 | return 'A'+c-'a'; 37 | } 38 | return c; 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/ValidParentheses.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isValid(string s) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = s.size(); 6 | if( n==0 ) return true; 7 | if( n%2==1 ) return false; 8 | stack stk; 9 | int match[256]; 10 | match['('] = ')'; 11 | match['['] = ']'; 12 | match['{'] = '}'; 13 | for( int i = 0; i != n; ++i ) 14 | { 15 | if( s[i]=='(' || s[i]=='{' || s[i]=='[' ) 16 | { 17 | stk.push(s[i]); 18 | }else{ 19 | if( stk.empty() ) return false; 20 | char c = stk.top(); 21 | stk.pop(); 22 | if( match[c] != s[i] ) 23 | { 24 | return false; 25 | } 26 | } 27 | } 28 | if( !stk.empty() ) return false; 29 | return true; 30 | } 31 | }; -------------------------------------------------------------------------------- /leetcode/ValidateBinarySearchTree.cpp: -------------------------------------------------------------------------------- 1 | /** 2 | * Definition for binary tree 3 | * struct TreeNode { 4 | * int val; 5 | * TreeNode *left; 6 | * TreeNode *right; 7 | * TreeNode(int x) : val(x), left(NULL), right(NULL) {} 8 | * }; 9 | */ 10 | class Solution { 11 | public: 12 | bool isValidBST(TreeNode *root) { 13 | // Note: The Solution object is instantiated only once and is reused by each test case. 14 | return dfs( root, INT_MAX, INT_MIN ); 15 | } 16 | bool dfs( TreeNode* root, int max, int min ){ 17 | if( root==NULL ) return true; 18 | if( root->val <= min || root->val >= max ) return false; 19 | if( !dfs( root->left, root->val, min) ) return false; 20 | if( !dfs( root->right, max, root->val ) ) return false; 21 | return true; 22 | } 23 | }; -------------------------------------------------------------------------------- /leetcode/Wildcard Matching.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool isMatch(const char *s, const char *p) { 4 | // IMPORTANT: Please reset any member data you declared, as 5 | // the same Solution instance will be reused for each test case. 6 | 7 | if( !s && !p ) return true; 8 | if( !s && *p =='\0' ) return true; 9 | if( !s && *p != '*') return false; 10 | 11 | if( !s && *p =='*' ){ 12 | while( *p == '*' ) ++p; 13 | if( *p == '\0' ) return true; 14 | return false; 15 | } 16 | if( s && !p ) return false; 17 | 18 | int n = strlen(s); 19 | int m = strlen(p); 20 | int k = 0; 21 | while( p[k]=='*' ) ++k; 22 | int num = 0; 23 | for( ; k < m; ++k ){ 24 | if( p[k] == '*' ) break; 25 | ++num; 26 | } 27 | if( num > n ) return false; 28 | 29 | vector< bool > dp( n+2, false ); 30 | dp[ n ] = true; 31 | int i = m-1; 32 | for( ; i >= 0; --i ){ 33 | if( p[i] == '*' ){ 34 | while( i > 0 && p[i]==p[i-1] ) --i; 35 | int j = n; 36 | for( ; j >=0 && !dp[j]; --j ); 37 | for(; j >=0; --j ) dp[j] = true; 38 | }else{ 39 | for( int j = 0; j < n+1; ++j ) 40 | dp[j] = ( p[i]=='?' || p[i]==s[j] )?dp[j+1]:false; 41 | } 42 | } 43 | return dp[0]; 44 | } 45 | }; -------------------------------------------------------------------------------- /leetcode/Wildcard_Matching.cpp: -------------------------------------------------------------------------------- 1 | # include 2 | using namespace std; 3 | 4 | class Solution { 5 | public: 6 | const int CMAX = 28; 7 | class node{ 8 | int id; 9 | node* next[CMAX]; 10 | node(): id(-1){ 11 | for(int i = 0; i < CMAX; ++i){ 12 | next[i] = NULL; 13 | } 14 | } 15 | } 16 | int map_char(char c){ 17 | if(c >= 'a' && c <= 'z') return c - 'a'; 18 | if(c == '.') return 'z' - 'a' + 1; 19 | if(c == '*') return 'z' - 'a' + 2; 20 | return -1; 21 | } 22 | 23 | node* build_trie(const char* p){ 24 | if(p == NULL) return NULL; 25 | node* root = new node(); 26 | node* cur = root; 27 | for(int i = 0; p[i] != '\0'; ++i){ 28 | int k = map_char(p[i]); 29 | if(cur->next[k]) 30 | } 31 | } 32 | 33 | bool isMatch(const char *s, const char *p) { 34 | } 35 | }; 36 | -------------------------------------------------------------------------------- /leetcode/Word Break_1.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | class Solution { 7 | public: 8 | static bool wordBreak(string s, unordered_set &dict) { 9 | int n = s.size(); 10 | if (n == 0) return false; 11 | vector< bool > dp(n + 1, false); 12 | dp[0] = true; 13 | for (int i = 1; i <= n; ++i){ 14 | for (int j = 1; j <= i; ++j){ 15 | string substr = s.substr(j - 1, i - j + 1); 16 | if (dp[j - 1] && dict.find(substr) != dict.end()){ 17 | dp[i] = true; 18 | } 19 | } 20 | } 21 | return dp[n]; 22 | } 23 | }; 24 | 25 | int main(){ 26 | int n = 0; 27 | unordered_set dict; 28 | string str; 29 | cin >> n; 30 | for (int i = 0; i < n; ++i){ 31 | cin >> str; 32 | dict.insert(str); 33 | } 34 | cin >> str; 35 | cout << Solution::wordBreak(str, dict) << endl; 36 | return 0; 37 | } -------------------------------------------------------------------------------- /leetcode/WordLadder.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | int ladderLength(string start, string end, unordered_set &dict) { 4 | // Start typing your C/C++ solution below 5 | // DO NOT write int main() function 6 | queue Q; 7 | Q.push(start); 8 | map result; 9 | result[start] = 1; 10 | while(!Q.empty()) 11 | { 12 | string cur = Q.front(); 13 | Q.pop(); 14 | if( cur==end ) 15 | { 16 | break; 17 | } 18 | for( int i = 0; i != cur.size(); ++i ) 19 | { 20 | for( int j = 0; j != 26; ++j ) 21 | { 22 | string tmp = cur; 23 | tmp[i] = 'a'+ j; 24 | if( tmp[i]==cur[i] ) 25 | { 26 | continue; 27 | } 28 | unordered_set::const_iterator it = dict.find(tmp); 29 | if( it != dict.end() ) 30 | { 31 | Q.push(tmp); 32 | result[tmp] = result[cur]+1; 33 | dict.erase(tmp); 34 | } 35 | } 36 | } 37 | } 38 | return result[end]; 39 | } 40 | }; -------------------------------------------------------------------------------- /leetcode/WordSearch.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | bool exist(vector > &board, string word) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = board.size(); 6 | if( n==0 ) return false; 7 | int m = board[0].size(); 8 | if( m==0 ) return false; 9 | vector vis(n*m, 0); 10 | for( int i = 0; i < n; ++i ){ 11 | for( int j = 0; j < m; ++j ){ 12 | vis[i*m+j] = 1; 13 | bool flag = dfs( board, i, j, word, 0, vis ); 14 | vis[i*m+j] = 0; 15 | if( flag ) return true; 16 | } 17 | } 18 | return false; 19 | } 20 | bool dfs( vector< vector > &board, int i, int j, string& word, int pos, vector&vis ){ 21 | if( board[i][j] != word[pos] ) return false; 22 | if( pos==word.size()-1 ){ 23 | return true; 24 | } 25 | int step[4][2] = { {1, 0}, {-1, 0}, {0,1}, {0,-1} }; 26 | int n = board.size(); 27 | int m = board[0].size(); 28 | for( int k = 0; k < 4; ++k ){ 29 | int x = i+step[k][0]; 30 | int y = j+step[k][1]; 31 | if( x < 0 || x >= n ) continue; 32 | if( y < 0 || y >= m ) continue; 33 | if( vis[ x*m+y ]==1 ) continue; 34 | vis[x*m+y] = 1; 35 | bool flag = dfs( board, x, y, word, pos+1, vis ); 36 | vis[x*m+y] = 0; 37 | if( flag ) return true; 38 | } 39 | return false; 40 | } 41 | }; -------------------------------------------------------------------------------- /leetcode/ZigZagConversion.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | string convert(string s, int nRows) { 4 | // Note: The Solution object is instantiated only once and is reused by each test case. 5 | int n = s.size(); 6 | if( nRows <= 1 || n<=nRows ) return s; 7 | string result( s ); 8 | int k = 0; 9 | for( int i = 0; i != nRows; ++i ){ 10 | int j = i; 11 | int flag = 0; 12 | while( j < n ){ 13 | result[k++] = s[j]; 14 | if( i==0 || i==nRows-1 ) j += (2*nRows-2); 15 | else if( flag == 0 ){ 16 | flag = 1; 17 | j += ( 2*nRows-2-2*i ); 18 | }else if( flag==1 ){ 19 | flag = 0; 20 | j += 2*i; 21 | } 22 | } 23 | } 24 | return result; 25 | } 26 | }; -------------------------------------------------------------------------------- /poj/poj1363_stl.cpp: -------------------------------------------------------------------------------- 1 | # include 2 | # include 3 | using namespace std; 4 | 5 | int main(){ 6 | int n; 7 | while(cin >> n && n != 0){ 8 | stack rails; 9 | int i = 0, j = 1, train; 10 | while(i < n){ 11 | cin >> train; 12 | if(train == 0) break; 13 | if(!rails.empty() && rails.top() == train){ 14 | rails.pop(); 15 | }else{ 16 | while(j <= n && j != train){ 17 | rails.push(j++); 18 | } 19 | if(j <= n && j == train){ 20 | ++j; 21 | } 22 | } 23 | i = (i + 1) % n; 24 | if(i == 0){ 25 | if(rails.empty()){ 26 | cout << "Yes" << endl; 27 | } else { 28 | cout <<"No"<< endl; 29 | } 30 | j = 1; 31 | while(!rails.empty()) rails.pop(); 32 | } 33 | } 34 | cout << endl; 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /poj/poj1363_without-stl.cpp: -------------------------------------------------------------------------------- 1 | # include 2 | using namespace std; 3 | 4 | const int MAXN = 1001; 5 | 6 | int main(){ 7 | int rails[MAXN], top = -1; 8 | int n; 9 | while(cin >> n && n != 0){ 10 | int i = 0, j = 1, train; 11 | while(i < n){ 12 | cin >> train; 13 | if(train == 0) break; 14 | if(top >= 0 && rails[top] == train){ 15 | --top; 16 | }else{ 17 | while(j <= n && j != train){ 18 | rails[++top] = j++; 19 | } 20 | if(j <= n && j == train){ 21 | ++j; 22 | } 23 | } 24 | i = (i + 1) % n; 25 | if(i == 0){ 26 | if(top == -1){ 27 | cout << "Yes" << endl; 28 | } else { 29 | cout <<"No"<< endl; 30 | } 31 | j = 1; 32 | top = -1; 33 | } 34 | } 35 | cout << endl; 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /poj/poj1753.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #include 4 | using namespace std; 5 | 6 | int flip( int cur, int i, int j ){ 7 | cur = cur^( 1<<(i*4+j) ); 8 | if( i-1 >= 0 ) cur = cur^(1<<(4*(i-1)+j)); 9 | if( i+1 < 4 ) cur = cur^(1<<(4*(i+1)+j)); 10 | if( j-1 >= 0 ) cur = cur^(1<<(4*i+j-1)); 11 | if( j+1 <4 ) cur = cur = cur^(1<<(4*i+j+1)); 12 | return cur; 13 | } 14 | 15 | int bfs( int from ){ 16 | int result[65536]; 17 | int vis[65536]; 18 | queue Q; 19 | memset( result, 0x0, sizeof(int)*65536 ); 20 | memset( vis, 0x0, sizeof(int)*65536 ); 21 | Q.push( from ); 22 | vis[from] = 1; 23 | while( !Q.empty() ){ 24 | int cur = Q.front(); 25 | Q.pop(); 26 | if( cur==0 || cur==65535 ){ 27 | return result[cur]; 28 | } 29 | for( int i = 0; i != 4; ++i ){ 30 | for( int j = 0; j != 4; ++j ){ 31 | int state = flip( cur, i, j ); 32 | if( vis[state]==0 ){ 33 | Q.push( state ); 34 | vis[state] = 1; 35 | result[state] = result[cur] + 1; 36 | } 37 | } 38 | } 39 | } 40 | return -1; 41 | } 42 | 43 | int main() 44 | { 45 | int from = 0; 46 | for( int i = 0; i != 4; ++i ){ 47 | for( int j = 0; j != 4; ++j ){ 48 | char c; 49 | cin>>c; 50 | from = from + ((c=='w')?0:1)*( 1<<(i*4+j) ); 51 | } 52 | } 53 | int result = bfs( from ); 54 | if( result==-1 ){ 55 | cout<<"Impossible"< 2 | 3 | const int LMAX = 1000000; 4 | 5 | int t, n, len, dist[LMAX]; 6 | 7 | int max(int a, int b){ 8 | return a >= b ? a : b; 9 | } 10 | 11 | int min(int a, int b){ 12 | return a <= b ? a : b; 13 | } 14 | 15 | void solve(){ 16 | // 寻找最短时间 17 | int minT = 0; 18 | for(int i = 0; i < n; ++i){ 19 | int minL = min(dist[i], len - dist[i]); 20 | if(minL > minT){ 21 | minT = minL; 22 | } 23 | } 24 | // 寻找最长时间 25 | int maxT = 0; 26 | for(int i = 0; i < n; ++i){ 27 | int maxL = max(dist[i], len - dist[i]); 28 | if(maxL > maxT){ 29 | maxT = maxL; 30 | } 31 | } 32 | printf("%d %d\n", minT, maxT); 33 | } 34 | 35 | int main(){ 36 | scanf("%d", &t); 37 | while(t--){ 38 | scanf("%d%d", &len, &n); 39 | for(int i = 0; i < n; ++i){ 40 | scanf("%d", &dist[i]); 41 | } 42 | solve(); 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /poj/poj2386.cpp: -------------------------------------------------------------------------------- 1 | // DFS 2 | #include 3 | 4 | using namespace std; 5 | 6 | const int MAXN = 102; 7 | const int MAXM = 102; 8 | 9 | char land[MAXN][MAXM]; 10 | int N, M; 11 | 12 | void dfs(int x, int y){ 13 | land[x][y] = '.'; 14 | for(int i = -1; i <= 1; ++i){ 15 | for(int j = -1; j <= 1; ++j){ 16 | int _x = x + i; 17 | int _y = y + j; 18 | if(_x < 0 || _x >= N) continue; 19 | if(_y < 0 || _y >= M) continue; 20 | if(land[_x][_y] != 'W') continue; 21 | dfs(_x, _y); 22 | } 23 | } 24 | } 25 | 26 | int main(){ 27 | cin >> N >> M; 28 | for(int i = 0; i < N; ++i){ 29 | cin >> land[i]; 30 | } 31 | int ans = 0; 32 | for(int i = 0; i < N; i++){ 33 | for(int j = 0; j < M; ++j){ 34 | if(land[i][j] == 'W'){ 35 | dfs(i, j); 36 | ++ans; 37 | } 38 | } 39 | } 40 | cout << ans << endl; 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /poj/poj2531.cpp: -------------------------------------------------------------------------------- 1 | //DFS 2 | # include 3 | 4 | using namespace std; 5 | 6 | const int MAXN = 21; 7 | 8 | int n; 9 | int ans = 0; 10 | int vis[MAXN]; 11 | int network[MAXN][MAXN]; 12 | 13 | int cal(){ 14 | int total = 0; 15 | for(int i = 0; i < n; ++i){ 16 | if(!vis[i]) continue; 17 | for(int j = 0; j < n; ++j){ 18 | if(vis[j]) continue; 19 | total += network[i][j]; 20 | } 21 | } 22 | return total; 23 | } 24 | 25 | void dfs(int k){ 26 | if(k >= n){ 27 | int sum = cal(); 28 | if(sum > ans) ans = sum; 29 | return; 30 | } 31 | vis[k] = 1; 32 | dfs(k+1); 33 | vis[k] = 0; 34 | dfs(k+1); 35 | } 36 | 37 | int main(){ 38 | cin >> n; 39 | for(int i = 0; i < n; ++i){ 40 | vis[i] = 0; 41 | for(int j = 0; j < n; ++j){ 42 | cin >> network[i][j]; 43 | } 44 | } 45 | dfs(0); 46 | cout << ans << endl; 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /poj/poj3461.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | Problem: HDOJ 1711 3 | Author: 靖难 4 | Tag: KMP, string match, DFA 5 | Difficulty: 1 (from 1 to 5) 6 | */ 7 | 8 | # include 9 | # include 10 | 11 | const int NMAX = 1000000; 12 | const int MMAX = 10000; 13 | 14 | char Pattern[MMAX]; 15 | char Target[NMAX]; 16 | int Next[MMAX]; 17 | 18 | int kmp(int n, int m) 19 | { 20 | Next[0] = -1; 21 | int p = -1; 22 | for(int i = 1; i < m; ++i){ 23 | while(p != -1 && Pattern[p+1] != Pattern[i]){ 24 | p = Next[p]; 25 | } 26 | if(Pattern[p+1] == Pattern[i]){ 27 | p = p + 1; 28 | } 29 | Next[i] = p; 30 | } 31 | int num = 0; 32 | p = -1; 33 | for(int i = 0; i < n; ++i){ 34 | while(p != -1 && Pattern[p+1] != Target[i]){ 35 | p = Next[p]; 36 | } 37 | if(Pattern[p+1] == Target[i]){ 38 | p = p + 1; 39 | } 40 | if(p == m-1) ++num; 41 | } 42 | return num; 43 | } 44 | 45 | int main() 46 | { 47 | int T = 0, N = 0, M = 0; 48 | scanf("%d", &T); 49 | 50 | while(T--){ 51 | scanf("%s", Pattern); 52 | scanf("%s", Target); 53 | printf("%d\n", kmp(strlen(Target), strlen(Pattern))); 54 | } 55 | } 56 | -------------------------------------------------------------------------------- /spoj/TRT.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | using namespace std; 4 | 5 | int d[2001]; 6 | int r[2][2001]; 7 | 8 | int max(int a, int b){ 9 | return a > b ? a : b; 10 | } 11 | 12 | int main() { 13 | 14 | // your code here 15 | int n; 16 | scanf("%d", &n); 17 | for(int i = 0; i < n; ++i){ 18 | scanf("%d", &d[i]); 19 | } 20 | memset(r, 2*2001*sizeof(int), 0); 21 | for(int i = 0; i < n; ++i) r[0][i] = n * d[i]; 22 | int k = 1; 23 | for(int i = 1; i < n; ++i){ 24 | for(int j = 0; j < n; ++j){ 25 | if(j + i >= n) break; 26 | int y = n - (i + 1) + 1; 27 | int s1 = y * d[j] + r[!k][j+1]; 28 | int s2 = y * d[j+i] + r[!k][j]; 29 | r[k][j] = max(s1, s2); 30 | } 31 | k = !k; 32 | } 33 | printf("%d\n", r[!k][0]); 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /usaco/chapter_1/Broken_Necklace.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ID: binlong3 3 | PROG: beads 4 | LANG: C++ 5 | */ 6 | 7 | # include 8 | # include 9 | # include 10 | # include 11 | using namespace std; 12 | 13 | int solve(const string& beads){ 14 | int n = beads.size(); 15 | int ans = 0; 16 | int i = 0; 17 | while(i < n) { 18 | while(beads[i] == 'w' && i < n) ++i; 19 | if(i == n){ 20 | if(ans == 0) ans = n; 21 | break; 22 | } 23 | int n1 = 0; 24 | int j = (i - 1 + n) % n; 25 | while(j != i && beads[j] == 'w'){ 26 | ++n1; 27 | j = (j - 1 + n) % n; 28 | } 29 | int k = j; 30 | while(k != i){ 31 | if(beads[k] == beads[j] || beads[k] == 'w') ++n1; 32 | else break; 33 | k = (k - 1 + n) % n; 34 | } 35 | k = (k + 1) % n; 36 | 37 | int n2 = 0; 38 | j = i; 39 | while(j != k) { 40 | if(beads[j] == beads[i] || beads[j] == 'w') ++n2; 41 | else break; 42 | j = (j + 1) % n; 43 | } 44 | if(n1 + n2 > ans) ans = n1 + n2; 45 | ++i; 46 | } 47 | return ans; 48 | } 49 | 50 | 51 | int main(){ 52 | ofstream fout ("beads.out"); 53 | ifstream fin ("beads.in"); 54 | int N; 55 | string beads; 56 | fin >> N; 57 | fin >> beads; 58 | int ans = solve(beads); 59 | fout << ans << endl; 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /usaco/chapter_1/Friday_the_Thirteenth.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ID: binlong3 3 | PROG: friday 4 | LANG: C++ 5 | */ 6 | 7 | # include 8 | # include 9 | # include 10 | using namespace std; 11 | 12 | int is_leap_year(int year){ 13 | if((year % 4 == 0 && year % 100 != 0) || year % 400 == 0){ 14 | return 1; 15 | } 16 | return 0; 17 | } 18 | 19 | int main(){ 20 | ofstream fout ("friday.out"); 21 | ifstream fin ("friday.in"); 22 | int N; 23 | fin >> N; 24 | int days[2][12] = { 25 | {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}, 26 | {31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31} 27 | }; 28 | int ans[7] = {0, 0, 0, 0, 0, 0, 0}; 29 | int d = 0; 30 | for(int i = 0; i < N; ++i){ 31 | int year = 1900 + i; 32 | int leap = is_leap_year(year); 33 | for(int j = 0; j < 12; ++j){ 34 | int count = 13; 35 | for(int k = 0; k < j; ++k){ 36 | count += days[leap][k]; 37 | } 38 | ans[(d+count) % 7]++; 39 | } 40 | d += (leap ? 366 : 365); 41 | } 42 | int i = 6; 43 | for(i = 6; i < 12; ++i){ 44 | fout << ans[i%7] << " "; 45 | } 46 | fout << ans[i%7] << endl; 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /usaco/chapter_1/Greedy_Gift_Givers.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ID: binlong3 3 | PROG: gift1 4 | LANG: C++ 5 | */ 6 | 7 | # include 8 | # include 9 | # include 10 | # include 11 | # include 12 | using namespace std; 13 | 14 | int main(){ 15 | string comet; 16 | string group; 17 | ofstream fout ("gift1.out"); 18 | ifstream fin ("gift1.in"); 19 | int N; 20 | fin >> N; 21 | map users; 22 | vector names; 23 | string name; 24 | for(int i = 0; i < N; ++i){ 25 | fin >> name; 26 | users[name] = 0; 27 | names.push_back(name); 28 | } 29 | for(int i = 0; i < N; ++i){ 30 | fin >> name; 31 | int total, num; 32 | fin >> total >> num; 33 | if(num == 0) 34 | users[name] += total; 35 | else{ 36 | users[name] -= total; 37 | users[name] += total % num; 38 | for(int j = 0; j < num; ++j){ 39 | fin >> name; 40 | users[name] += total / num; 41 | } 42 | } 43 | } 44 | for(int i = 0; i < N; ++i){ 45 | fout << names[i] << " " << users[names[i]] << endl; 46 | } 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /usaco/chapter_1/Your_Ride_Is_Here.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | ID: binlong3 3 | PROG: ride 4 | LANG: C++ 5 | */ 6 | 7 | # include 8 | # include 9 | # include 10 | using namespace std; 11 | 12 | int main(){ 13 | string comet; 14 | string group; 15 | ofstream fout ("ride.out"); 16 | ifstream fin ("ride.in"); 17 | fin >> comet; 18 | fin >> group; 19 | int r1 = 1; 20 | for(int i = 0; i < comet.size(); ++i){ 21 | r1 *= (comet[i] - 'A' + 1) % 47; 22 | r1 %= 47; 23 | } 24 | int r2 = 1; 25 | for(int i = 0; i < group.size(); ++i){ 26 | r2 *= (group[i] - 'A' + 1) % 47; 27 | r2 %= 47; 28 | } 29 | if(r1 == r2) fout << "GO" << endl; 30 | else fout << "STAY" << endl; 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /uva/uva10003_CuttingSticks.cpp: -------------------------------------------------------------------------------- 1 | // DP, Typic Matrix Chain Problem 2 | # include 3 | # include 4 | 5 | using namespace std; 6 | 7 | int solve(vector& cut){ 8 | int n = cut.size(); 9 | vector< vector > ans(n, vector(n, 0x7FFFFFFF)); 10 | for (int i = 0; i < n; ++i){ 11 | ans[i][i] = 0; 12 | if(i+1 < n) ans[i][i+1] = 0; 13 | } 14 | for(int i = 2; i < n; ++i){ 15 | for(int j = 0; j < n; ++j){ 16 | for(int k = j + 1; k < j + i; ++k){ 17 | if(j + i >= n) continue; 18 | int cost = ans[j][k] + ans[k][j+i] + cut[j+i] - cut[j]; 19 | ans[j][j+i] = min(ans[j][j+i], cost); 20 | } 21 | } 22 | } 23 | return ans[0][n-1]; 24 | } 25 | 26 | int main(){ 27 | int len; 28 | while(cin >> len && len != 0){ 29 | int n; 30 | cin >> n; 31 | vector cut(n+2, 0); 32 | cut[0] = 0; 33 | cut[n+1] = len; 34 | for(int i = 1; i <= n; ++i){ 35 | cin >> cut[i]; 36 | } 37 | cout << "The minimum cutting is " << solve(cut) <<"."<< endl; 38 | } 39 | return 0; 40 | } 41 | --------------------------------------------------------------------------------