├── t.cpp ├── t.sql ├── README.md ├── .gitignore ├── util_py ├── __init__.py └── __pycache__ │ ├── list.cpython-38.pyc │ ├── tree.cpython-38.pyc │ └── __init__.cpython-38.pyc ├── 0100_Same_Tree └── slt.md ├── 0112_Path_Sum └── slt.md ├── 0039_Combination_Sum └── slt.md ├── 0046_Permutations └── slt.md ├── 0077_Combinations └── slt.md ├── 0101_Symmetric_Tree └── slt.md ├── 0113_Path_Sum_II └── slt.md ├── 0126_Word_Ladder_II └── slt.md ├── 0137_Single_Number_II └── slt.md ├── 0147_Insertion_Sort_List └── slt.md ├── 0260_Single_Number_III └── slt.md ├── 0509_Fibonacci_Number └── slt.md ├── 0054_Spiral_Matrix └── slt.md ├── 0079_Word_Search └── slt.md ├── 0128_Longest_Consecutive_Sequence ├── Solution1.cpp └── slt.md ├── 0191_Number_of_1_Bits └── slt.md ├── 0389_Find_the_Difference └── slt.md ├── 0441_Arranging_Coins ├── slt.md └── Solution1.py ├── 0456_132_Pattern └── slt.md ├── 0882_Reachable_Nodes_In_Subdivided_Graph └── slt.md ├── mst02.05_Sum_Lists_LCCI └── slt.md ├── 0086_Partition_List └── slt.md ├── 0092_Reverse_Linked_List_II └── slt.md ├── 0104_Maximum_Depth_of_Binary_Tree └── slt.md ├── 0127_Word_Ladder └── slt.md ├── 0129_Sum_Root_to_Leaf_Numbers └── slt.md ├── 0132_Palindrome_Partitioning_II └── slt.md ├── 0168_Excel_Sheet_Column_Title └── slt.md ├── 0226_Invert_Binary_Tree └── slt.md ├── 0257_Binary_Tree_Paths └── slt.md ├── 0322_Coin_Change └── slt.md ├── 0328_Odd_Even_Linked_List └── slt.md ├── 0344_Reverse_String └── slt.md ├── 0347_Top_K_Frequent_Elements └── slt.md ├── 0437_Path_Sum_III └── slt.md ├── 0547_Number_of_Provinces └── slt.md ├── 0563_Binary_Tree_Tilt └── slt.md ├── 1030_Matrix_Cells_in_Distance_Order └── slt.md ├── mst01.07_Rotate_Matrix_LCCI └── slt.md ├── mst16.15_Master_Mind_LCCI └── slt.md ├── 0013_Roman_to_Integer └── slt.md ├── 0019_Remove_Nth_Node_From_End_of_List └── slt.md ├── 0023_Merge_k_Sorted_Lists └── slt.md ├── 0061_Rotate_List └── slt.md ├── 0111_Minimum_Depth_of_Binary_Tree └── slt.md ├── 0150_Evaluate_Reverse_Polish_Notation └── slt.md ├── 0155_Min_Stack └── slt.md ├── 0173_Binary_Search_Tree_Iterator └── slt.md ├── 0218_The_Skyline_Problem └── slt.md ├── 0252_Meeting_Rooms └── slt.md ├── 0504_Base_7 └── slt.md ├── 0830_Positions_of_Large_Groups └── slt.md ├── 0876_Middle_of_the_Linked_List └── slt.md ├── 0051_N-Queens └── slt.md ├── 0190_Reverse_Bits └── slt.md ├── 0222_Count_Complete_Tree_Nodes └── slt.md ├── 0232_Implement_Queue_using_Stacks └── slt.md ├── 0251_Flatten_2D_Vector └── slt.md ├── 0566_Reshape_the_Matrix └── slt.md ├── 0832_Flipping_an_Image └── slt.md ├── 1603_Design_Parking_System └── slt.md ├── mst16.22_Langtons_Ant_LCCI └── slt.md ├── 0014_Longest_Common_Prefix └── slt.md ├── 0032 Longest Valid Parentheses └── slt.md ├── 0048_Rotate_Image └── slt.md ├── 0052_N-Queens_II └── slt.md ├── 0067_Add_Binary └── slt.md ├── 0144_Binary_Tree_Preorder_Traversal └── slt.md ├── 0179_Largest_Number └── slt.md ├── 0274_H-Index └── slt.md ├── 0341_Flatten_Nested_List_Iterator └── slt.md ├── 0415_Add_Strings └── slt.md ├── 0637_Average_of_Levels_in_Binary_Tree └── slt.md ├── 0783_Minimum_Distance_Between_BST_Nodes └── slt.md ├── 0842_Split_Array_into_Fibonacci_Sequence └── slt.md ├── 0912_Sort_an_Array └── slt.md ├── 0938_Range_Sum_of_BST └── slt.md ├── 0027_Remove_Element └── slt.md ├── 0074_Search_a_2D_Matrix └── slt.md ├── 0082_Remove_Duplicates_from_Sorted_List_II └── slt.md ├── 0116_Populating_Next_Right_Pointers_in_Each_Node └── slt.md ├── 0157_Read_N_Characters_Given_Read4 └── slt.md ├── 0293_Flip_Game └── slt.md ├── 0303_Range_Sum_Query_-_Immutable └── slt.md ├── 0373_Find_K_Pairs_with_Smallest_Sums └── slt.md ├── 0403_Frog_Jump └── slt.md ├── 0572_Subtree_of_Another_Tree └── slt.md ├── 0617_Merge_Two_Binary_Trees └── slt.md ├── 0669_Trim_a_Binary_Search_Tree └── slt.md ├── 0815_Bus_Routes └── slt.md ├── 0999_Available_Captures_for_Rook └── slt.md ├── mst16.20_T9_LCCI └── slt.md ├── package.json ├── .elp.js ├── 0207_Course_Schedule └── slt.md ├── 0258_Add_Digits └── slt.md ├── 0323_Number_of_Connected_Components_in_an_Undirected_Graph └── slt.md ├── 0404_Sum_of_Left_Leaves └── slt.md ├── 0530_Minimum_Absolute_Difference_in_BST └── slt.md ├── 1046_Last_Stone_Weight └── slt.md ├── 1110_Delete_Nodes_And_Return_Forest └── slt.md ├── mst17.16_The_Masseuse_LCCI └── slt.md ├── 0018_4Sum └── slt.md ├── 0050_Pow(x, n) └── slt.md ├── 0094_Binary_Tree_Inorder_Traversal └── slt.md ├── 0114_Flatten_Binary_Tree_to_Linked_List └── slt.md ├── 0189_Rotate_Array └── slt.md ├── 0199_Binary_Tree_Right_Side_View └── slt.md ├── 0445_Add_Two_Numbers_II └── slt.md ├── 0501_Find_Mode_in_Binary_Search_Tree └── slt.md ├── 0513_Find_Bottom_Left_Tree_Value └── slt.md ├── 0559_Maximum_Depth_of_N-ary_Tree └── slt.md ├── 0643_Maximum_Average_Subarray_I └── slt.md ├── 1006_Clumsy_Factorial └── slt.md ├── 1059_All_Paths_from_Source_Lead_to_Destination └── slt.md ├── 1122_Relative_Sort_Array └── slt.md ├── 1486_XOR_Operation_in_an_Array └── slt.md ├── 1721_Swapping_Nodes_in_a_Linked_List └── slt.md ├── mst10.01_Sorted_Merge_LCCI └── slt.md ├── 0017_Letter_Combinations_of_a_Phone_Number └── slt.md ├── 0102_Binary_Tree_Level_Order_Traversal └── slt.md ├── 0108_Convert_Sorted_Array_to_Binary_Search_Tree └── slt.md ├── 0153_Find_Minimum_in_Rotated_Sorted_Array └── slt.md ├── 0217_Contains_Duplicate └── slt.md ├── 0225_Implement_Stack_using_Queues └── slt.md ├── 0228_Summary_Ranges └── slt.md ├── 0485_Max_Consecutive_Ones └── slt.md ├── 0872_Leaf-Similar_Trees └── slt.md ├── 1723_Find_Minimum_Time_to_Finish_All_Jobs └── slt.md ├── 0045_Jump_Game_II └── slt.md ├── 0059_Spiral_Matrix_II └── slt.md ├── 0071_Simplify_Path └── slt.md ├── 0095_Unique_Binary_Search_Trees_II └── slt.md ├── 0106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal └── slt.md ├── 0107_Binary_Tree_Level_Order_Traversal_II └── slt.md ├── 0125_Valid_Palindrome └── slt.md ├── 0210_Course_Schedule_II └── slt.md ├── 0227_Basic_Calculator_II └── slt.md ├── 0270_Closest_Binary_Search_Tree_Value └── slt.md ├── 0359_Logger_Rate_Limiter └── slt.md ├── 0383_Ransom_Note └── slt.md ├── 0451_Sort_Characters_By_Frequency └── slt.md ├── 0474_Ones_and_Zeroes └── slt.md ├── 0860_Lemonade_Change └── slt.md ├── 0941_Valid_Mountain_Array └── slt.md ├── 0973_K_Closest_Points_to_Origin └── slt.md ├── 1418_Display_Table_of_Food_Orders_in_a_Restaurant └── slt.md ├── Solution.class ├── 0049_Group_Anagrams └── slt.md ├── 0103_Binary_Tree_Zigzag_Level_Order_Traversal └── slt.md ├── 0154_Find_Minimum_in_Rotated_Sorted_Array_II └── slt.md ├── 0206_Reverse_Linked_List └── slt.md ├── 0243_Shortest_Word_Distance └── slt.md ├── 0342_Power_of_Four ├── slt.md └── Solution1.py ├── 0392_Is_Subsequence └── slt.md ├── 0684_Redundant_Connection └── slt.md ├── 0012_Integer_to_Roman └── slt.md ├── 0055_Jump_Game └── slt.md ├── 0110_Balanced_Binary_Tree └── slt.md ├── 0203_Remove_Linked_List_Elements └── slt.md ├── 0852_Peak_Index_in_a_Mountain_Array └── slt.md ├── 0995_Minimum_Number_of_K_Consecutive_Bit_Flips └── slt.md ├── mst17.14_Smallest_K_LCCI ├── mst.md └── Solution1.py ├── 0016_3Sum_Closest └── slt.md ├── 0069_Sqrt(x) ├── sqrt1.jpg ├── sqrt2.jpg └── slt.md ├── 0163_Missing_Ranges └── slt.md ├── 0395_Longest_Substring_with_At_Least_K_Repeating_Characters └── slt.md ├── 0434_Number_of_Segments_in_a_String └── slt.md ├── 0463_Island_Perimeter └── slt.md ├── 0551_Student_Attendance_Record_I └── slt.md ├── 0649_Dota2_Senate └── slt.md ├── 0867_Transpose_Matrix └── slt.md ├── 1646_Get_Maximum_in_Generated_Array └── slt.md ├── 1833_Maximum_Ice_Cream_Bars └── slt.md ├── 1893_Check_if_All_the_Integers_in_a_Range_Are_Covered └── slt.md ├── 0047_Permutations_II └── slt.md ├── 0065_Valid_Number ├── DFA.jpg └── slt.md ├── 0122_Best_Time_to_Buy_and_Sell_Stock_II ├── slt.md └── Solution1.js ├── 0141_Linked_List_Cycle └── slt.md ├── 0204_Count_Primes └── slt.md ├── 0239_Sliding_Window_Maximum └── slt.md ├── 0246_Strobogrammatic_Number └── slt.md ├── 0412_Fizz_Buzz └── slt.md ├── 0455_Assign_Cookies └── slt.md ├── 0460_LFU_Cache └── slt.md ├── 0543_Diameter_of_Binary_Tree └── slt.md ├── 0627_Swap_Salary └── slt.md ├── 0914_X_of_a_Kind_in_a_Deck_of_Cards └── slt.md ├── 0993_Cousins_in_Binary_Tree └── slt.md ├── 1207_Unique_Number_of_Occurrences └── slt.md ├── 0066_Plus_One └── slt.md ├── 0117_Populating_Next_Right_Pointers_in_Each_Node_II └── slt.md ├── 0165_Compare_Version_Numbers └── slt.md ├── 0349_Intersection_of_Two_Arrays └── slt.md ├── 0454_4Sum_II └── slt.md ├── 0704_Binary_Search └── slt.md ├── 0738_Monotone_Increasing_Digits └── slt.md ├── 1877_Minimize_Maximum_Pair_Sum_in_Array └── slt.md ├── 0044_Wildcard_Matching └── slt.md ├── 0090_Subsets_II └── slt.md ├── 0099_Recover_Binary_Search_Tree └── slt.md ├── 0109_Convert_Sorted_List_to_Binary_Search_Tree └── slt.md ├── 0171_Excel_Sheet_Column_Number └── slt.md ├── 0235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree └── slt.md ├── 0345_Reverse_Vowels_of_a_String └── slt.md ├── 0766_Toeplitz_Matrix └── slt.md ├── mst17.21_Volume_of_Histogram_LCCI └── slt.md ├── util_java └── tree │ ├── TreeNode.class │ └── TreeNode.java ├── 0024_Swap_Nodes_in_Pairs └── slt.md ├── 0058_Length_of_Last_Word └── slt.md ├── 0083_Remove_Duplicates_from_Sorted_List └── slt.md ├── 0198_House_Robber └── slt.md ├── 0219_Contains_Duplicate_II └── slt.md ├── 0240_Search_a_2D_Matrix_II └── slt.md ├── 0244_Shortest_Word_Distance_II └── slt.md ├── 0266_Palindrome_Permutation └── slt.md ├── 0461_Hamming_Distance └── slt.md ├── 0671_Second_Minimum_Node_In_a_Binary_Tree └── slt.md ├── 0692_Top_K_Frequent_Words └── slt.md ├── 0889_Construct_Binary_Tree_from_Preorder_and_Postorder_Traversal └── slt.md ├── 0057_Insert_Interval └── slt.md ├── 0080_Remove_Duplicates_from_Sorted_Array_II └── slt.md ├── 0170_Two_Sum_III_-_Data_structure_design └── slt.md ├── 0261_Graph_Valid_Tree └── slt.md ├── 0331_Verify_Preorder_Serialization_of_a_Binary_Tree └── slt.md ├── 0387_First_Unique_Character_in_a_String └── slt.md ├── 0399_Evaluate_Division └── slt.md ├── 0408_Valid_Word_Abbreviation └── slt.md ├── 0495_Teemo_Attacking └── slt.md ├── 0506_Relative_Ranks └── slt.md ├── 0897_Increasing_Order_Search_Tree └── slt.md ├── 1720_Decode_XORed_Array └── slt.md ├── 0145_Binary_Tree_Postorder_Traversal └── slt.md ├── 0224_Basic_Calculator └── slt.md ├── 0290_Word_Pattern └── slt.md ├── 0299_Bulls_and_Cows └── slt.md ├── 0350_Intersection_of_Two_Arrays_II └── slt.md ├── 0401_Binary_Watch └── slt.md ├── 0653_Two_Sum_IV_-_Input_is_a_BST └── slt.md ├── 0703_Kth_Largest_Element_in_a_Stream └── slt.md ├── 0930_Binary_Subarrays_With_Sum └── slt.md ├── 1052_Grumpy_Bookstore_Owner └── slt.md ├── 1711_Count_Good_Meals └── slt.md ├── 1846_Maximum_Element_After_Decreasing_and_Rearranging └── slt.md ├── t.py ├── 0022_Generate_Parentheses └── slt.md ├── 0041_First_Missing_Positive └── slt.md ├── 0169_Majority_Element └── slt.md ├── 0326_Power_of_Three ├── slt.md └── Solution1.js ├── 0526_Beautiful_Arrangement └── slt.md ├── 0538_Convert_BST_to_Greater_Tree └── slt.md ├── 0541_Reverse_String_II └── slt.md ├── 0863_All_Nodes_Distance_K_in_Binary_Tree └── slt.md ├── 1074_Number_of_Submatrices_That_Sum_to_Target └── slt.md ├── 1894_Find_the_Student_that_Will_Replace_the_Chalk └── slt.md ├── 0133_Clone_Graph └── slt.md ├── 0215_Kth_Largest_Element_in_an_Array └── slt.md ├── 0237_Delete_Node_in_a_Linked_List └── slt.md ├── 0354_Russian_Doll_Envelopes └── slt.md ├── 0492_Construct_the_Rectangle └── slt.md ├── 0922_Sort_Array_By_Parity_II └── slt.md ├── 0945_Minimum_Increment_to_Make_Array_Unique └── slt.md ├── 0093_Restore_IP_Addresses └── slt.md ├── 0151_Reverse_Words_in_a_String └── slt.md ├── 0182_Duplicate_Emails └── slt.md ├── 0304_Range_Sum_Query_2D_-_Immutable └── slt.md ├── 0494_Target_Sum └── slt.md ├── 0528_Random_Pick_with_Weight └── slt.md ├── 0084_Largest_Rectangle_in_Histogram └── slt.md ├── 0205_Isomorphic_Strings └── slt.md ├── 0452_Minimum_Number_of_Arrows_to_Burst_Balloons └── slt.md ├── 0605_Can_Place_Flowers └── slt.md ├── 1232_Check_If_It_Is_a_Straight_Line └── slt.md ├── 0187_Repeated_DNA_Sequences └── slt.md ├── 0242_Valid_Anagram └── slt.md ├── 0378_Kth_Smallest_Element_in_a_Sorted_Matrix └── slt.md ├── 0476_Number_Complement └── slt.md ├── 0542_01_Matrix └── slt.md ├── 0575_Distribute_Candies └── slt.md ├── 0595_Big_Countries └── slt.md ├── 1208_Get_Equal_Substrings_Within_Budget └── slt.md ├── mst16.24_Pairs_With_Sum_LCCI └── slt.md ├── 0043_Multiply_Strings ├── slt.md └── Solution1.py ├── 0139_Word_Break └── slt.md ├── 0268_Missing_Number └── slt.md ├── 0518_Coin_Change_2 └── slt.md ├── 0620_Not_Boring_Movies └── slt.md ├── 1004_Max_Consecutive_Ones_III └── slt.md ├── 1148_Article_Views_I └── slt.md ├── 1190_Reverse_Substrings_Between_Each_Pair_of_Parentheses └── slt.md ├── 1202_Smallest_String_With_Swaps └── slt.md ├── 0068_Text_Justification └── slt.md ├── 0105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal └── slt.md ├── 0118_Pascal's_Triangle └── slt.md ├── 0493_Reverse_Pairs └── slt.md ├── 0820_Short_Encoding_of_Words └── slt.md ├── 0030_Substring_with_Concatenation_of_All_Words └── slt.md ├── 0075_Sort_Colors └── slt.md ├── 0213_House_Robber_II └── slt.md ├── 0263_Ugly_Number └── slt.md ├── 0520_Detect_Capital └── slt.md ├── 0785_Is_Graph_Bipartite? └── slt.md ├── 1203_Sort_Items_by_Groups_Respecting_Dependencies └── slt.md ├── 0040_Combination_Sum_II └── slt.md ├── 0503_Next_Greater_Element_II └── slt.md ├── 0976_Largest_Perimeter_Triangle └── slt.md ├── 1068_Product_Sales_Analysis_I └── slt.md ├── 1143_Longest_Common_Subsequence └── slt.md ├── 1221_Split_a_String_in_Balanced_Strings └── slt.md ├── 1370_Increasing_Decreasing_String └── slt.md ├── 0042_Trapping_Rain_Water └── slt.md ├── 0149_Max_Points_on_a_Line └── slt.md ├── 0584_Find_Customer_Referee └── slt.md ├── 0633_Sum_of_Square_Numbers └── slt.md ├── 1104_Path_In_Zigzag_Labelled_Binary_Tree └── slt.md ├── 1600_Throne_Inheritance └── slt.md ├── 0208_Implement_Trie_(Prefix_Tree) └── slt.md ├── 0613_Shortest_Distance_in_a_Line └── slt.md ├── 0724_Find_Pivot_Index └── slt.md ├── 1011_Capacity_To_Ship_Packages_Within_D_Days └── slt.md ├── 1378_Replace Employee_ID_With_The_Unique_Identifier └── slt.md ├── 0088_Merge_Sorted_Array ├── slt.md └── Solution1.cpp ├── 0124_Binary_Tree_Maximum_Path_Sum └── slt.md ├── 0200_Number_of_Islands └── slt.md ├── 0610_Triangle_Judgement └── slt.md ├── 1350_Students_With_Invalid_Departments └── slt.md ├── 0130_Surrounded_Regions └── slt.md ├── 0511_Game_Play_Analysis_I └── slt.md ├── 1579_Remove_Max_Number_of_Edges_to_Keep_Graph_Fully_Traversable └── slt.md ├── 0011_Container_With_Most_Water └── slt.md ├── 0078_Subsets └── slt.md ├── 0175_Combine_Two_Tables └── slt.md ├── 0318_Maximum_Product_of_Word_Lengths └── slt.md ├── 0424_Longest_Repeating_Character_Replacement └── slt.md ├── 0483_Smallest_Good_Base └── slt.md ├── 0664_Strange_Printer └── slt.md ├── 0680_Valid_Palindrome_II └── slt.md ├── 0725_Split_Linked_List_in_Parts └── slt.md ├── 0726_Number_of_Atoms └── slt.md ├── 1303_Find_the_Team_Size └── slt.md ├── 0064_Minimum_Path_Sum └── slt.md ├── 0283_Move_Zeroes └── slt.md ├── 0301_Remove_Invalid_Parentheses └── slt.md ├── 0525_Contiguous_Array └── slt.md ├── 0567_Permutation_in_String └── slt.md ├── 0026_Remove_Duplicates_from_Sorted_Array └── slt.md ├── 0056_Merge_Intervals └── slt.md ├── 0087_Scramble_String └── slt.md ├── 0367_Valid_Perfect_Square ├── slt.md └── Solution1.py ├── 0458_Poor_Pigs └── slt.md ├── 1050_Actors_and_Directors_Who_Cooperated_At_Least_Three_Times └── slt.md ├── 0035_Search_Insert_Position └── slt.md ├── 0136_Single_Number └── slt.md ├── 0166_Fraction_to_Recurring_Decimal └── slt.md ├── 0477_Total_Hamming_Distance └── slt.md ├── 0521_Longest_Uncommon_Subsequence_I └── slt.md ├── 0797_All_Paths_From_Source_to_Target └── slt.md ├── 0888_Fair_Candy_Swap └── slt.md ├── 1069_Product_Sales_Analysis_II └── slt.md ├── 0382_Linked_List_Random_Node ├── slt.md └── Solution1.py ├── 1631_Path_With_Minimum_Effort └── slt.md ├── mst17.04_Missing_Number_LCCI └── slt.md ├── 0135_Candy └── slt.md ├── 0138_Copy_List_with_Random_Pointer └── slt.md ├── 0176_Second_Highest_Salary └── slt.md ├── 0181_Employees_Earning_More_Than_Their_Managers └── slt1.md ├── 0407_Trapping_Rain_Water_II └── slt.md ├── 0596_Classes_More_Than_5_Students └── slt.md ├── 0650_2_Keys_Keyboard └── slt.md ├── 1310_XOR_Queries_of_a_Subarray └── slt.md ├── 0211_Add_and_Search_Word_-_Data_structure_design └── slt.md ├── 0234_Palindrome_Linked_List └── slt.md ├── 0276_Paint_Fence └── slt.md ├── 0321_Create_Maximum_Number └── slt.md ├── 0556_Next_Greater_Element_III └── slt.md ├── mst16.16_Sub_Sort_LCCI └── slt.md ├── 0310_Minimum_Height_Trees └── slt.md ├── 0661_Image_Smoother └── slt.md ├── 1178_Number_of_Valid_Words_for_Each_Puzzle └── slt.md ├── 0008_String_to_Integer_(atoi) └── slt.md ├── 0413_Arithmetic_Slices └── slt.md ├── 0578_Get_Highest_Answer_Rate_Question └── slt.md ├── 0611_Valid_Triangle_Number └── slt.md ├── .vscode └── settings.json ├── 0098_Validate_Binary_Search_Tree └── slt.md ├── 1025_Divisor_Game └── slt.md ├── mst16.17_Contiguous_Sequence_LCCI └── slt.md ├── 0020_Valid_Parentheses └── slt.md ├── 0063_Unique_Paths_II └── slt.md ├── 0603_Consecutive_Available_Seats └── slt.md ├── 0646_Maximum_Length_of_Pair_Chain └── slt.md ├── 1173_Immediate_Food_Delivery_I └── slt.md ├── 1770_Maximum_Score_from_Performing_Multiplication_Operations └── slt.md ├── 0121_Best_Time_to_Buy_and_Sell_Stock └── slt.md ├── 0148_Sort_List └── slt.md ├── 0223_Rectangle_Area └── slt.md ├── 0570_Managers_with_at_Least_5_Direct_Reports └── slt.md ├── 0459_Repeated_Substring_Pattern ├── slt.md └── Solution1.py ├── 0524_Longest_Word_in_Dictionary_through_Deleting └── slt.md ├── 0561_Array_Partition_I └── slt.md ├── 1005_Maximize_Sum_Of_Array_After_K_Negations └── slt.md ├── 1075_Project_Employees_I └── slt.md ├── 0053_Maximum_Subarray └── slt.md ├── 0180_Consecutive_Numbers └── slt.md ├── 0421_Maximum_XOR_of_Two_Numbers_in_an_Array └── slt.md ├── 0659_Split_Array_into_Consecutive_Subsequences └── slt.md ├── 0892_Surface_Area_of_3D_Shapes └── slt.md ├── 1045_Customers_Who_Bought_All_Products └── slt.md ├── 1128_Number_of_Equivalent_Domino_Pairs └── slt.md ├── 1211_Queries_Quality_and_Percentage └── slt.md ├── 0743_Network_Delay_Time └── slt.md ├── 1141_User_Activity_for_the_Past_30_Days_I └── slt.md ├── 0162_Find_Peak_Element └── slt.md ├── 0340_Longest_Substring_with_At_Most_K_Distinct_Characters └── slt.md ├── 0073_Set_Matrix_Zeroes └── slt.md ├── 0740_Delete_and_Earn └── slt.md ├── 1082_Sales_Analysis_I └── slt.md ├── 1327_List_the_Products_Ordered_in_a_Period └── slt.md ├── 0015_3Sum └── slt.md ├── 0202_Happy_Number └── slt.md ├── 0313_Super_Ugly_Number └── slt.md ├── 0376_Wiggle_Subsequence └── slt.md ├── 0502_IPO └── slt.md ├── 0512_Game_Play_Analysis_II └── slt.md ├── 0619_Biggest_Single_Number └── slt.md ├── 1113_Reported_Posts └── slt.md ├── 1135_Connecting_Cities_With_Minimum_Cost └── slt.md ├── 0188_Best_Time_to_Buy_and_Sell_Stock_IV └── slt.md ├── 0391_Perfect_Rectangle └── slt.md ├── 0608_Tree_Node └── slt.md ├── 0586_Customer_Placing_the_Largest_Number_of_Orders └── slt.md ├── 0607_Sales_Person └── slt.md ├── 0714_Best_Time_to_Buy_and_Sell_Stock_with_Transaction_Fee └── slt.md ├── 0253_Meeting_Rooms_II └── slt.md ├── 0577_Employee_Bonus └── slt.md ├── 0746_Min_Cost_Climbing_Stairs └── slt.md ├── 0861_Score_After_Flipping_Matrix └── slt.md ├── 0036_Valid_Sudoku └── slt.md ├── 0802_Find_Eventual_Safe_States └── slt.md ├── mst16.21_Sum_Swap_LCCI └── slt.md ├── 0256_Paint_House └── slt.md ├── 0560_Subarray_Sum_Equals_K └── slt.md ├── 0767_Reorganize_String └── slt.md ├── 0001_Two_Sum └── slt.md ├── 0540_Single_Element_in_a_Sorted_Array └── slt.md ├── 0597_Friend_Requests_I:_Overall_Acceptance_Rate └── slt.md ├── 0612_Shortest_Distance_in_a_Plane └── slt.md ├── 1084_Sales_Analysis_III └── slt.md ├── 1722_Minimize_Hamming_Distance_After_Swap_Operations └── slt.md ├── 0859_Buddy_Strings └── slt.md ├── 1322_Ads_Performance └── slt.md ├── 0338_Counting_Bits └── slt.md ├── 0402_Remove_K_Digits └── slt.md ├── 0697_Degree_of_an_Array └── slt.md ├── 1070_Product_Sales_Analysis_III └── slt.md ├── 1142_User_Activity_for_the_Past_30_Days_II └── slt.md ├── 1251_Average_Selling_Price └── slt.md ├── 1438_Longest_Continuous_Subarray_With_Absolute_Diff_Less_Than_or_Equal_to_Limit └── slt.md ├── 1738_Find_Kth_Largest_XOR_Coordinate_Value └── slt.md ├── 0119_Pascal's_Triangle_II └── slt.md ├── 0480_Sliding_Window_Median └── slt.md ├── 1076_Project_Employees_II └── slt.md ├── 1162_As_Far_from_Land_as_Possible └── slt.md ├── 0160_Intersection_of_Two_Linked_Lists └── slt.md ├── 0070_Climbing_Stairs └── slt.md ├── 0264_Ugly_Number_II └── slt.md ├── 0583_Delete_Operation_for_Two_Strings └── slt.md ├── 0448_Find_All_Numbers_Disappeared_in_an_Array └── slt.md ├── 0384_Shuffle_an_Array ├── slt.md └── Solution1.py ├── 1035_Uncrossed_Lines └── slt.md ├── 0134_Gas_Station └── slt.md ├── 0197_Rising_Temperature └── slt.md ├── 0453_Minimum_Moves_to_Equal_Array_Elements ├── slt.md └── Solution1.py ├── 0300_Longest_Increasing_Subsequence └── slt.md ├── 0978_Longest_Turbulent_Subarray └── slt.md ├── 0120_Triangle └── slt.md ├── 0081_Search_in_Rotated_Sorted_Array_II └── slt.md ├── 0435_Non-overlapping_Intervals └── slt.md ├── 0881_Boats_to_Save_People └── slt.md ├── 1049_Last_Stone_Weight_II └── slt.md ├── 1269_Number_of_Ways_to_Stay_in_the_Same_Place_After_Some_Steps └── slt.md ├── 0279_Perfect_Squares └── slt.md ├── 0375_Guess_Number_Higher_or_Lower_II └── slt.md ├── 0443_String_Compression └── slt.md ├── 0033_Search_in_Rotated_Sorted_Array └── slt.md ├── 0355_Design_Twitter └── slt.md ├── 0184_Department_Highest_Salary └── slt.md ├── 0201_Bitwise_AND_of_Numbers_Range └── slt.md ├── 0335_Self_Crossing └── slt.md ├── 0602_Friend_Requests_II:_Who_Has_the_Most_Friends └── slt.md ├── 1442_Count_Triplets_That_Can_Form_Two_Arrays_of_Equal_XOR └── slt.md ├── 0177_Nth_Highest_Salary └── slt.md ├── 0450_Delete_Node_in_a_BST └── slt.md ├── 0183_Customers_Who_Never_Order └── slt.md ├── 0167_Two_Sum_II_-_Input_array_is_sorted ├── Solution2.js ├── Solution2.cpp └── slt.md ├── 0626_Exchange_Seats └── slt.md ├── 1280_Students_and_Examinations └── slt.md ├── 1294_Weather_Type_in_Each_Country └── slt.md ├── 0123_Best_Time_to_Buy_and_Sell_Stock_III └── slt.md ├── 0416_Partition_Equal_Subset_Sum └── slt.md ├── 0580_Count_Student_Number_in_Departments └── slt.md ├── util_go └── tree │ └── tree.go ├── 0091_Decode_Ways └── slt.md ├── 0447_Number_of_Boomerangs └── slt.md ├── 1083_Sales_Analysis_II └── slt.md ├── 0096_Unique_Binary_Search_Trees ├── slt.md └── Solution1.py ├── 0146_LRU_Cache └── slt.md ├── 0262_Trips_and_Users └── slt.md ├── 1218_Longest_Arithmetic_Subsequence_of_Given_Difference └── slt.md ├── test.sh ├── 0164_Maximum_Gap └── slt.md ├── 0614_Second_Degree_Follower └── slt.md ├── 0236_Lowest_Common_Ancestor_of_a_Binary_Tree └── slt.md ├── 0981_Time_Based_Key-Value_Store └── slt.md ├── 0231_Power_of_Two └── slt.md ├── 0581_Shortest_Unsorted_Continuous_Subarray └── slt.md ├── 0789_Escape_The_Ghosts └── slt.md ├── 0877_Stone_Game └── slt.md ├── 1111_Maximum_Nesting_Depth_of_Two_Valid_Parentheses_Strings └── slt.md ├── 0085_Maximal_Rectangle └── slt.md ├── 0381_Insert_Delete_GetRandom_O(1)_-_Duplicates_allowed └── slt.md ├── 0159_Longest_Substring_with_At_Most_Two_Distinct_Characters └── slt.md ├── 0185_Department_Top_Three_Salaries └── slt.md ├── 0295_Find_Median_from_Data_Stream └── slt.md ├── 0787_Cheapest_Flights_Within_K_Stops └── slt.md ├── 0178_Rank_Scores └── slt.md ├── 0397_Integer_Replacement └── slt.md ├── 0765_Couples_Holding_Hands └── slt.md ├── 0786_K-th_Smallest_Prime_Fraction └── slt.md ├── 0444_Sequence_Reconstruction └── slt.md ├── 1126_Active_Businesses └── slt.md ├── 0273_Integer_to_English_Words └── slt.md ├── 0869_Reordered_Power_of_2 └── slt.md ├── util_cpp ├── list.h └── tree.h ├── 0003_Longest_Substring_Without_Repeating_Characters └── stl.md ├── 0879_Profitable_Schemes └── slt.md ├── .elp ├── 0010_Regular_Expression_Matching └── slt.md ├── 0309_Best_Time_to_Buy_and_Sell_Stock_with_Cooldown └── slt.md ├── 0005_Longest_Palindromic_Substring └── slt.md ├── 0172_Factorial_Trailing_Zeroes ├── slt.md └── Solution1.js ├── 1107_New_Users_Daily_Count └── slt.md ├── 1112_Highest_Grade_For_Each_Student └── slt.md ├── 0028_Implement_strStr() └── slt.md ├── 0552_Student_Attendance_Record_II └── slt.md ├── 0072_Edit_Distance └── slt.md ├── 0523_Continuous_Subarray_Sum └── slt.md ├── 0959_Regions_Cut_By_Slashes └── slt.md ├── 0847_Shortest_Path_Visiting_All_Nodes └── slt.md ├── 1744_Can_You_Eat_Your_Favorite_Candy_on_Your_Favorite_Day? └── slt.md ├── 0142_Linked_List_Cycle_II └── slt.md ├── 0289_Game_of_Life └── slt.md ├── 1098_Unpopular_Books └── slt.md ├── 0496_Next_Greater_Element_I └── slt.md ├── 0534_Game_Play_Analysis_III └── slt.md ├── 1109_Corporate_Flight_Bookings └── slt.md ├── 0220_Contains_Duplicate_III └── slt.md ├── 1746_Maximum_Subarray_Sum_After_One_Operation └── slt.md ├── 0221_Maximal_Square └── slt.md ├── 0229_Majority_Element_II └── slt.md ├── 0488_Zuma_Game └── slt.md ├── 0514_Freedom_Trail └── slt.md ├── utils_js ├── array.js └── tree.js ├── 0319_Bulb_Switcher └── slt.md ├── 0007_Reverse_Integer ├── slt.md └── Solution2.py ├── 0152_Maximum_Product_Subarray └── slt.md ├── 0371_Sum_of_Two_Integers └── slt.md ├── 1734_Decode_XORed_Permutation └── slt.md ├── 0343_Integer_Break └── slt.md ├── 0574_Winning_Candidate └── slt.md ├── 0034_Find_First_and_Last_Position_of_Element_in_Sorted_Array └── slt.md ├── 1838_Frequency_of_the_Most_Frequent_Element └── slt.md ├── 0332_Reconstruct_Itinerary └── slt.md └── 0446_Arithmetic_Slices_II_-_Subsequence └── slt.md /t.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /t.sql: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | hi -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | *.out -------------------------------------------------------------------------------- /util_py/__init__.py: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0100_Same_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归检查 2 | -------------------------------------------------------------------------------- /0112_Path_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | -------------------------------------------------------------------------------- /0039_Combination_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 DFS 2 | -------------------------------------------------------------------------------- /0046_Permutations/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | -------------------------------------------------------------------------------- /0077_Combinations/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | -------------------------------------------------------------------------------- /0101_Symmetric_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | -------------------------------------------------------------------------------- /0113_Path_Sum_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | -------------------------------------------------------------------------------- /0126_Word_Ladder_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 BFS 2 | -------------------------------------------------------------------------------- /0137_Single_Number_II/slt.md: -------------------------------------------------------------------------------- 1 | 题解同 of 56-2 -------------------------------------------------------------------------------- /0147_Insertion_Sort_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 插入排序 -------------------------------------------------------------------------------- /0260_Single_Number_III/slt.md: -------------------------------------------------------------------------------- 1 | 题解同 mst56-1 -------------------------------------------------------------------------------- /0509_Fibonacci_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | -------------------------------------------------------------------------------- /0054_Spiral_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 直接四个方向扫描 2 | -------------------------------------------------------------------------------- /0079_Word_Search/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | DFS 4 | -------------------------------------------------------------------------------- /0128_Longest_Consecutive_Sequence/Solution1.cpp: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /0191_Number_of_1_Bits/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历数1 2 | -------------------------------------------------------------------------------- /0389_Find_the_Difference/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | -------------------------------------------------------------------------------- /0441_Arranging_Coins/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 模拟 2 | -------------------------------------------------------------------------------- /0456_132_Pattern/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 單調棧 2 | -------------------------------------------------------------------------------- /0882_Reachable_Nodes_In_Subdivided_Graph/slt.md: -------------------------------------------------------------------------------- 1 | -------------------------------------------------------------------------------- /mst02.05_Sum_Lists_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 直接遍历计算 -------------------------------------------------------------------------------- /0086_Partition_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历分开，尾接法建两个链表，再连起来 -------------------------------------------------------------------------------- /0092_Reverse_Linked_List_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 反转链表，再拼接 -------------------------------------------------------------------------------- /0104_Maximum_Depth_of_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs -------------------------------------------------------------------------------- /0127_Word_Ladder/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 直接BFS，很慢 -------------------------------------------------------------------------------- /0129_Sum_Root_to_Leaf_Numbers/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | -------------------------------------------------------------------------------- /0132_Palindrome_Partitioning_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | -------------------------------------------------------------------------------- /0168_Excel_Sheet_Column_Title/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 不断取余 2 | -------------------------------------------------------------------------------- /0226_Invert_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 后序遍历 -------------------------------------------------------------------------------- /0257_Binary_Tree_Paths/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 2 | -------------------------------------------------------------------------------- /0322_Coin_Change/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dp 2 | 3 | -------------------------------------------------------------------------------- /0328_Odd_Even_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双指针 2 | 3 | -------------------------------------------------------------------------------- /0344_Reverse_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 直接左右对换反转 2 | 3 | -------------------------------------------------------------------------------- /0347_Top_K_Frequent_Elements/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用堆 2 | -------------------------------------------------------------------------------- /0437_Path_Sum_III/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DFS 2 | 3 | -------------------------------------------------------------------------------- /0547_Number_of_Provinces/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 2 | 3 | -------------------------------------------------------------------------------- /0563_Binary_Tree_Tilt/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 2 | -------------------------------------------------------------------------------- /1030_Matrix_Cells_in_Distance_Order/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 bfs -------------------------------------------------------------------------------- /mst01.07_Rotate_Matrix_LCCI /slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 先上下翻转，再转置 -------------------------------------------------------------------------------- /mst16.15_Master_Mind_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双hash 2 | -------------------------------------------------------------------------------- /0013_Roman_to_Integer/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 比后面小减当前，比后面大加当前 2 | -------------------------------------------------------------------------------- /0019_Remove_Nth_Node_From_End_of_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 快慢指针 -------------------------------------------------------------------------------- /0023_Merge_k_Sorted_Lists/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 不断的两两merge 2 | -------------------------------------------------------------------------------- /0061_Rotate_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 尾部连接头部，再从中间断开 4 | -------------------------------------------------------------------------------- /0111_Minimum_Depth_of_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | -------------------------------------------------------------------------------- /0150_Evaluate_Reverse_Polish_Notation/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 栈 2 | -------------------------------------------------------------------------------- /0155_Min_Stack/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 双栈，一个存数据，一个存最小值 4 | -------------------------------------------------------------------------------- /0173_Binary_Search_Tree_Iterator/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 迭代中序遍历 2 | -------------------------------------------------------------------------------- /0218_The_Skyline_Problem/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 扫描线法 2 | -------------------------------------------------------------------------------- /0252_Meeting_Rooms/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 按第一个元素排序，并判断有没有重叠 2 | -------------------------------------------------------------------------------- /0504_Base_7/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 divide and mod 2 | 3 | -------------------------------------------------------------------------------- /0830_Positions_of_Large_Groups/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 一次遍历，双指针 2 | -------------------------------------------------------------------------------- /0876_Middle_of_the_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 快慢指针 2 | -------------------------------------------------------------------------------- /0051_N-Queens/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 回溯法 2 | 3 | 注意与解数独那道题的相似之处 4 | -------------------------------------------------------------------------------- /0190_Reverse_Bits/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 直接把每位取出来放到一个list里，再反转构建结果 2 | -------------------------------------------------------------------------------- /0222_Count_Complete_Tree_Nodes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历，直接数每个结点 2 | -------------------------------------------------------------------------------- /0232_Implement_Queue_using_Stacks/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 两个栈来倒顺序 2 | -------------------------------------------------------------------------------- /0251_Flatten_2D_Vector/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 在初始化的时候把2D merge成1D 2 | -------------------------------------------------------------------------------- /0566_Reshape_the_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Traverse 2 | 3 | -------------------------------------------------------------------------------- /0832_Flipping_an_Image/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Simulation 2 | 3 | -------------------------------------------------------------------------------- /1603_Design_Parking_System/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | -------------------------------------------------------------------------------- /mst16.22_Langtons_Ant_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Simulation 2 | -------------------------------------------------------------------------------- /0014_Longest_Common_Prefix/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 对每一列，遍历所有字符串，比较那一列的字符 2 | -------------------------------------------------------------------------------- /0032 Longest Valid Parentheses/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用一个栈来存放左括号的下标 2 | -------------------------------------------------------------------------------- /0048_Rotate_Image/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 先上下翻转，在转置 2 | 3 | 其实先转置，再左右翻转也行 -------------------------------------------------------------------------------- /0052_N-Queens_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 回溯法 2 | 3 | 同51，不过不返回棋盘，改成计数 4 | -------------------------------------------------------------------------------- /0067_Add_Binary/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 从右往左加就行了，注意cpp insert的方法。 -------------------------------------------------------------------------------- /0144_Binary_Tree_Preorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用栈，非递归 2 | 3 | -------------------------------------------------------------------------------- /0179_Largest_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 自定义排序 2 | 3 | 和mst45正好相反 4 | -------------------------------------------------------------------------------- /0274_H-Index/slt.md: -------------------------------------------------------------------------------- 1 | h-index：至少h篇被引用了h次 2 | 3 | ### 思路1 排序后遍历 4 | -------------------------------------------------------------------------------- /0341_Flatten_Nested_List_Iterator/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS + 遞歸 2 | -------------------------------------------------------------------------------- /0415_Add_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 simulation 10-based add 2 | -------------------------------------------------------------------------------- /0637_Average_of_Levels_in_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 bfs 2 | -------------------------------------------------------------------------------- /0783_Minimum_Distance_Between_BST_Nodes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 中序遍历 -------------------------------------------------------------------------------- /0842_Split_Array_into_Fibonacci_Sequence/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 回溯 2 | 3 | -------------------------------------------------------------------------------- /0912_Sort_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 快排 2 | 3 | 这里选取随机位置的元素作为pivot 4 | -------------------------------------------------------------------------------- /0938_Range_Sum_of_BST/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 pre-order traverse 2 | -------------------------------------------------------------------------------- /0027_Remove_Element/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 类似第26题，只是判断的对象是给定的一个val 2 | 3 | 4 | -------------------------------------------------------------------------------- /0074_Search_a_2D_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 利用矩阵的特性从右上角或者左下角开始检查 4 | -------------------------------------------------------------------------------- /0082_Remove_Duplicates_from_Sorted_List_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历一遍 2 | 3 | -------------------------------------------------------------------------------- /0116_Populating_Next_Right_Pointers_in_Each_Node/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 前序遍历 2 | -------------------------------------------------------------------------------- /0157_Read_N_Characters_Given_Read4/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 直接循环调用 2 | 3 | -------------------------------------------------------------------------------- /0293_Flip_Game/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | 出现两个连续的 `+` 则加入结果 4 | -------------------------------------------------------------------------------- /0303_Range_Sum_Query_-_Immutable/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Pre sum 2 | 3 | -------------------------------------------------------------------------------- /0373_Find_K_Pairs_with_Smallest_Sums/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 暴力枚举所有pair，排序后，返回前k个 -------------------------------------------------------------------------------- /0403_Frog_Jump/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs + cache 2 | 3 | 不加cache会超时 4 | -------------------------------------------------------------------------------- /0572_Subtree_of_Another_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 preorder dfs 2 | 3 | -------------------------------------------------------------------------------- /0617_Merge_Two_Binary_Trees/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 pre order dfs 2 | 3 | -------------------------------------------------------------------------------- /0669_Trim_a_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dfs + BST 性质 2 | -------------------------------------------------------------------------------- /0815_Bus_Routes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 BFS 2 | 3 | - 时间复杂度 4 | - 空间复杂度 5 | -------------------------------------------------------------------------------- /0999_Available_Captures_for_Rook/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 找到R，再往四个方向遍历 4 | -------------------------------------------------------------------------------- /mst16.20_T9_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 从字符映射到数组，而不是从数字映射到字符 4 | -------------------------------------------------------------------------------- /package.json: -------------------------------------------------------------------------------- 1 | { 2 | "type": "module", 3 | "dependencies": {} 4 | } 5 | -------------------------------------------------------------------------------- /.elp.js: -------------------------------------------------------------------------------- 1 | // chapter 3 two pointers 2 | 20230122={ 3 | [455] 4 | }, 5 | 6 | -------------------------------------------------------------------------------- /0207_Course_Schedule/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 拓扑排序，队列实现 2 | 3 | 这道题每个节点的序号正好是0-n，n为结点的个数 -------------------------------------------------------------------------------- /0258_Add_Digits/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 模拟 2 | 3 | - 时间复杂度 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0323_Number_of_Connected_Components_in_an_Undirected_Graph/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 -------------------------------------------------------------------------------- /0404_Sum_of_Left_Leaves/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 2 | 3 | dfs，加所有左子节点的 val 4 | -------------------------------------------------------------------------------- /0530_Minimum_Absolute_Difference_in_BST/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 中序遍历 2 | 3 | -------------------------------------------------------------------------------- /1046_Last_Stone_Weight/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 最大堆 2 | 3 | 时间复杂度O(n*logn) 4 | 空间复杂度O(n) -------------------------------------------------------------------------------- /1110_Delete_Nodes_And_Return_Forest/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DFS + hash 2 | 3 | -------------------------------------------------------------------------------- /mst17.16_The_Masseuse_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 这道题和198 rober是一样的 4 | -------------------------------------------------------------------------------- /0018_4Sum/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 思路同3sum，只是多了一重循环 2 | 3 | ## 思路2 利用递归化解为2sum，泛华为N sum 4 | -------------------------------------------------------------------------------- /0050_Pow(x, n)/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分递归 2 | 3 | 注意n=-2^31的特殊情况。直接n = -n会溢出 4 | 5 | -------------------------------------------------------------------------------- /0094_Binary_Tree_Inorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | 3 | ### 思路2 非递归，用栈 4 | -------------------------------------------------------------------------------- /0114_Flatten_Binary_Tree_to_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 右左根遍历，用一个指针指向上次的节点 -------------------------------------------------------------------------------- /0189_Rotate_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 三次旋转。 4 | 5 | python切片会copy一份，就不要用了 6 | -------------------------------------------------------------------------------- /0199_Binary_Tree_Right_Side_View/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 使用层序遍历，每层只保存最后一个结点 4 | -------------------------------------------------------------------------------- /0445_Add_Two_Numbers_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用stack 2 | 3 | 利用栈把list中的顺序反过来相加即可 4 | -------------------------------------------------------------------------------- /0501_Find_Mode_in_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash + dfs统计 + 遍历 2 | -------------------------------------------------------------------------------- /0513_Find_Bottom_Left_Tree_Value/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 level order (dfs) 2 | 3 | -------------------------------------------------------------------------------- /0559_Maximum_Depth_of_N-ary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 2 | 3 | 同二叉树求高度的思路一致 4 | -------------------------------------------------------------------------------- /0643_Maximum_Average_Subarray_I/slt.md: -------------------------------------------------------------------------------- 1 | 直接暴力计算会超时 2 | 3 | ### 思路1 pre sum 4 | 5 | -------------------------------------------------------------------------------- /1006_Clumsy_Factorial/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 stack 2 | 3 | 遇到乘除直接算，遇到加减把数放到栈中。减法存负数 -------------------------------------------------------------------------------- /1059_All_Paths_from_Source_Lead_to_Destination/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS 2 | 3 | -------------------------------------------------------------------------------- /1122_Relative_Sort_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双重循环 2 | 3 | 注意题目要求，arr1中arr2没有的元素需要升序排序 -------------------------------------------------------------------------------- /1486_XOR_Operation_in_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历一遍 2 | 3 | 时间复杂度 O(n) 4 | -------------------------------------------------------------------------------- /1721_Swapping_Nodes_in_a_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双指针 2 | 3 | 注意这道题只要求换值，不用换节点 -------------------------------------------------------------------------------- /mst10.01_Sorted_Merge_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 为防止覆盖A原有的内容，从尾部从大到小merge 4 | -------------------------------------------------------------------------------- /0017_Letter_Combinations_of_a_Phone_Number/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 利用三重循环 2 | 3 | ## 思路2 dfs 4 | -------------------------------------------------------------------------------- /0102_Binary_Tree_Level_Order_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用栈 2 | 3 | 并用count记录一行结点的个数 4 | -------------------------------------------------------------------------------- /0108_Convert_Sorted_Array_to_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 分区间构建BST 4 | -------------------------------------------------------------------------------- /0153_Find_Minimum_in_Rotated_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分 2 | 3 | 找最小的数只能用右边来判断 4 | -------------------------------------------------------------------------------- /0217_Contains_Duplicate/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 时间复杂度 O(n) 4 | 空间复杂度 O(n) 5 | 6 | -------------------------------------------------------------------------------- /0225_Implement_Stack_using_Queues/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 单队列实现 2 | 3 | 在push的时候把新的元素放到队列的头部 4 | -------------------------------------------------------------------------------- /0228_Summary_Ranges/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 数学模拟 2 | 3 | 时间复杂度 O(n) 4 | 空间复杂度 O(n) 5 | -------------------------------------------------------------------------------- /0485_Max_Consecutive_Ones/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Use `start` to remember start of ones 2 | -------------------------------------------------------------------------------- /0872_Leaf-Similar_Trees/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Traverse 2 | 3 | 遍历一遍，记录叶子节点的值然后比较 4 | -------------------------------------------------------------------------------- /1723_Find_Minimum_Time_to_Finish_All_Jobs/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs暴力破解 + 剪枝 2 | 3 | 不剪会超时 4 | -------------------------------------------------------------------------------- /0045_Jump_Game_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心算法 2 | 3 | 思路其实和55. Jump Game 是一样的。只不过那道题只判断能不能到达最后。 4 | -------------------------------------------------------------------------------- /0059_Spiral_Matrix_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 同Spiral Matrix1 2 | 3 | 只是把读变成写。另外这道题一定是方阵。不用考虑长方形的情况 -------------------------------------------------------------------------------- /0071_Simplify_Path/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 先split，再根据.. 或.或dir_name来向数组中添加或删除dir_name 4 | -------------------------------------------------------------------------------- /0095_Unique_Binary_Search_Trees_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归建树 2 | 3 | 注意最后返回的是一个树的根节点的vector 4 | -------------------------------------------------------------------------------- /0106_Construct_Binary_Tree_from_Inorder_and_Postorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 思路同105 -------------------------------------------------------------------------------- /0107_Binary_Tree_Level_Order_Traversal_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 把层序遍历的结果reverse一次就行了 4 | -------------------------------------------------------------------------------- /0125_Valid_Palindrome/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 左右检查 2 | 3 | 直接遍历字符串，保留数字字母，同时tolower。最后再左右检查即可。 4 | -------------------------------------------------------------------------------- /0210_Course_Schedule_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 topolotical sort 2 | 3 | 同207 一样，再记录path即可 4 | 5 | -------------------------------------------------------------------------------- /0227_Basic_Calculator_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 stack 2 | 3 | 用栈保存之前的结果，先算乘除，再算加减 4 | 5 | -------------------------------------------------------------------------------- /0270_Closest_Binary_Search_Tree_Value/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 二分查找 2 | 3 | 是 BST，直接二分查找 4 | -------------------------------------------------------------------------------- /0359_Logger_Rate_Limiter/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | -------------------------------------------------------------------------------- /0383_Ransom_Note/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 表统计字符个数 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | -------------------------------------------------------------------------------- /0451_Sort_Characters_By_Frequency/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 大顶堆 2 | 3 | Python heapq默认是小顶堆，存负数，就变成大顶堆了 -------------------------------------------------------------------------------- /0474_Ones_and_Zeroes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | dp[i][j] 表示 i 个0，j个1，最大的子集数 4 | 5 | -------------------------------------------------------------------------------- /0860_Lemonade_Change/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 一次遍历，记录5和10的个数 2 | 3 | 只需要判断一个loop之后里面five有没有小于0 4 | -------------------------------------------------------------------------------- /0941_Valid_Mountain_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历一遍 2 | 3 | 用一个flag来标识是上坡还是下坡，注意处理一些特殊cases 4 | -------------------------------------------------------------------------------- /0973_K_Closest_Points_to_Origin/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 暴力计算 2 | 3 | 直接重写内置排序函数的key，然后返回前K个即可 4 | -------------------------------------------------------------------------------- /1418_Display_Table_of_Food_Orders_in_a_Restaurant/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | 4 | -------------------------------------------------------------------------------- /Solution.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/Solution.class -------------------------------------------------------------------------------- /0049_Group_Anagrams/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用map来存，键是排好序的分组中的一个元素，值是vector of 那个分组中的string 4 | -------------------------------------------------------------------------------- /0103_Binary_Tree_Zigzag_Level_Order_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 类似层序变量，最后在判断一下每行的顺序即可 4 | -------------------------------------------------------------------------------- /0154_Find_Minimum_in_Rotated_Sorted_Array_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分 2 | 3 | 153和154的区别在于154需要去重。 4 | -------------------------------------------------------------------------------- /0206_Reverse_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 recursive 2 | 3 | ### Solution 2 iterate 4 | 5 | -------------------------------------------------------------------------------- /0243_Shortest_Word_Distance/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历一次，记录索引 2 | 3 | 时间复杂度 O(n) 4 | 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0342_Power_of_Four/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | - 时间复杂度 O(logn) 4 | - 空间复杂度 O(1) 5 | 6 | ### -------------------------------------------------------------------------------- /0392_Is_Subsequence/slt.md: -------------------------------------------------------------------------------- 1 | 2 | ### 思路1 3 | 4 | 用两个指针分别指向s和t，字符相等，则都进一步，否则只进t指针。最后判断s有没有走完。 5 | -------------------------------------------------------------------------------- /0684_Redundant_Connection/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用并查集 2 | 3 | 用并查集就很好做了，判断是否两个节点已经联通，如果联通，返回该条边就好了 4 | -------------------------------------------------------------------------------- /0012_Integer_to_Roman/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 直接无脑转换 2 | 3 | 本质上还是hash的思想 4 | 5 | ## 思路2 也是hash，但是只用1,4,5,9,10 -------------------------------------------------------------------------------- /0055_Jump_Game/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心算法 2 | 3 | reach表示在当前i索引上，还能向前走的最远距离。如果这个最远距离大于len，则win。否则lose。 4 | -------------------------------------------------------------------------------- /0110_Balanced_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | 3 | 从下往上返回层数 4 | 5 | 返回-1 表示不平衡 6 | 返回>=0 则表示层数 7 | -------------------------------------------------------------------------------- /0203_Remove_Linked_List_Elements/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0852_Peak_Index_in_a_Mountain_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0995_Minimum_Number_of_K_Consecutive_Bit_Flips/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Sliding Window 2 | 3 | 4 | 5 | -------------------------------------------------------------------------------- /mst17.14_Smallest_K_LCCI/mst.md: -------------------------------------------------------------------------------- 1 | ### Solution1 排序 2 | 3 | - 时间复杂度 $O(n * logn)$ 4 | - 空间复杂度 $O(1)$ 5 | -------------------------------------------------------------------------------- /0016_3Sum_Closest/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 类似3sum的思路1 2 | 3 | 不过有两点不同。一是只用返回一个确切的数。二是题目明确告诉只有一个答案，所以重复判断也不需要了。 4 | -------------------------------------------------------------------------------- /0069_Sqrt(x)/sqrt1.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/0069_Sqrt(x)/sqrt1.jpg -------------------------------------------------------------------------------- /0069_Sqrt(x)/sqrt2.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/0069_Sqrt(x)/sqrt2.jpg -------------------------------------------------------------------------------- /0163_Missing_Ranges/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | 1. 遍历一遍 nums，用 n 不断划分区间 4 | 2. 遍历分化好的区间，取其中合法的，并拼接成最后结果 -------------------------------------------------------------------------------- /0395_Longest_Substring_with_At_Least_K_Repeating_Characters/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Split and conquer 2 | 3 | -------------------------------------------------------------------------------- /0434_Number_of_Segments_in_a_String/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 直接统计 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0463_Island_Perimeter/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | 3 | 岛屿的周长就是岛屿方格和非岛屿方格相邻的边的数量。注意，这里的非岛屿方格，既包括水域方格，也包括网格的边界。 4 | -------------------------------------------------------------------------------- /0551_Student_Attendance_Record_I/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历模拟 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(1)$ 5 | -------------------------------------------------------------------------------- /0649_Dota2_Senate/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心，用队列来模拟投票 2 | 3 | 队列中的元素就是在senate中的索引。每下一轮时，就把索引加上长度push进队列，保证了相对位置的不变。 -------------------------------------------------------------------------------- /0867_Transpose_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Traverse 2 | 3 | Assign `matrix[i][j]` to `res[j][i]` 4 | 5 | -------------------------------------------------------------------------------- /1646_Get_Maximum_in_Generated_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 模拟遍历 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(n)$ 5 | -------------------------------------------------------------------------------- /1833_Maximum_Ice_Cream_Bars/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 greedy 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /1893_Check_if_All_the_Integers_in_a_Range_Are_Covered/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 贪心 2 | 3 | 数据量很小，直接排序再遍历 4 | -------------------------------------------------------------------------------- /0047_Permutations_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | 3 | 这道题有重复的元素，但又要求结果不能有重复的tuple。因此需要两个处理 4 | 5 | - 排序 6 | - 去重 7 | -------------------------------------------------------------------------------- /0065_Valid_Number/DFA.jpg: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/0065_Valid_Number/DFA.jpg -------------------------------------------------------------------------------- /0122_Best_Time_to_Buy_and_Sell_Stock_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 当天卖出后，当前还可以买入。所以只要当前价格高于前一天就卖出，总能保证profit最大。 4 | -------------------------------------------------------------------------------- /0141_Linked_List_Cycle/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 快慢指针 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 参考 floyd 算法 7 | -------------------------------------------------------------------------------- /0204_Count_Primes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 暴力枚举 2 | 3 | 注意1不是素数，最小的质数是2 4 | 5 | python 会超时 6 | 7 | ### 思路2 素数筛 8 | 9 | -------------------------------------------------------------------------------- /0239_Sliding_Window_Maximum/slt.md: -------------------------------------------------------------------------------- 1 | 2 | ### 思路1 3 | 4 | 用deque维持一个递减队列。 5 | 6 | 注意deq的元素是索引，这样才能判断是否在窗口内 7 | -------------------------------------------------------------------------------- /0246_Strobogrammatic_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 倒过来还能是 阿拉伯数字 的数只有 01689 4 | 5 | 注意 69 和 018 反转的性质不同 6 | -------------------------------------------------------------------------------- /0412_Fizz_Buzz/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 traverse 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(n)$ 5 | 6 | -------------------------------------------------------------------------------- /0455_Assign_Cookies/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 greedy 2 | 3 | - 时间复杂度 O(n * logn) 4 | 排序的复杂度 5 | - 空间复杂度 O(1) 6 | -------------------------------------------------------------------------------- /0460_LFU_Cache/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash table + 二叉平衡搜索树 2 | 3 | 哈希表用来进行key-value映射。二叉平衡搜索树用来的各个结点按照freq和time排序。 4 | -------------------------------------------------------------------------------- /0543_Diameter_of_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 获取高度 2 | 3 | 直径可能是不过根节点的。所以对于每个节点，都要判断 左右子树高度之和 4 | 5 | -------------------------------------------------------------------------------- /0627_Swap_Salary/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | UPDATE salary 5 | SET sex=IF(sex="f", "m", "f"); 6 | ``` 7 | -------------------------------------------------------------------------------- /0914_X_of_a_Kind_in_a_Deck_of_Cards/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 统计各个数出现的次数，然后求次数之间是否存在公约数 2 | 3 | 如果a == b，则gcd(a,b)就是a 4 | -------------------------------------------------------------------------------- /0993_Cousins_in_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS 2 | 3 | - 时间复杂度O(n) 4 | - 空间复杂度O(n) 5 | 6 | 注意对空的判断 7 | -------------------------------------------------------------------------------- /1207_Unique_Number_of_Occurrences/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 map + set 2 | 3 | map统计每个数的出现次数，set记录次数集合。两个大小一样，说明没有重复 4 | -------------------------------------------------------------------------------- /0066_Plus_One/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 simulation 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0117_Populating_Next_Right_Pointers_in_Each_Node_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 层序遍历 2 | 3 | 用一个新的节点充当每一行的前一个结点，再用一个指针p遍历每一行，串起来。 -------------------------------------------------------------------------------- /0165_Compare_Version_Numbers/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 + 模拟 2 | 3 | - 时间复杂度 $O(max(n,m))$ 4 | - 空间复杂度 $O(n + m)$ 5 | -------------------------------------------------------------------------------- /0349_Intersection_of_Two_Arrays/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 用两个 set 7 | -------------------------------------------------------------------------------- /0454_4Sum_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 直接4重循环会超时 4 | 5 | 我们把4个分成两组，用hash来保存第一组的结果，方便第二组快速查找。时间复杂度O(n*2) 6 | 7 | -------------------------------------------------------------------------------- /0704_Binary_Search/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 binary search 2 | 3 | - time complexity $O(logn)$ 4 | - space complexity $O(1)$ 5 | -------------------------------------------------------------------------------- /0738_Monotone_Increasing_Digits/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心 2 | 3 | 从右向左扫描数字，若发现当前数字比其左边一位（较高位）小，则把其左边一位数字减1，并将该位及其右边的所有位改成9 -------------------------------------------------------------------------------- /1877_Minimize_Maximum_Pair_Sum_in_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 排序 + 模拟 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /0044_Wildcard_Matching/slt.md: -------------------------------------------------------------------------------- 1 | 注意通配符和正则的区别， 2 | 3 | 正则的*前面必有一个preceding char，而通配符的星可以没有，且是匹配任意内容。 4 | 5 | ### 思路1 回溯法 6 | -------------------------------------------------------------------------------- /0090_Subsets_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 回溯 dfs 2 | 3 | 思路同subsets1，有两个不同之处 4 | 5 | 1. nums未必有序，所以先排下序 6 | 2. nums可能包含重复，需要检查 7 | -------------------------------------------------------------------------------- /0099_Recover_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 中序遍历记录错误节点 2 | 3 | 思路1 用递归形式的中序遍历。空间复杂度是O(H)，H是树的高度。最坏情况退化为O(N) 4 | 5 | -------------------------------------------------------------------------------- /0109_Convert_Sorted_List_to_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 用快慢指针法找到中点，再递归建树 2 | 3 | 给定的数组是递增的，中点的数是中位数，是根结点 4 | 5 | -------------------------------------------------------------------------------- /0171_Excel_Sheet_Column_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 其实可以看做26进制转10进制 7 | -------------------------------------------------------------------------------- /0235_Lowest_Common_Ancestor_of_a_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 递归检查 2 | 3 | lca 一定是会让 p 和 q 分别在其两侧的 4 | 5 | -------------------------------------------------------------------------------- /0345_Reverse_Vowels_of_a_String/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | python 为 O(n) 6 | -------------------------------------------------------------------------------- /0766_Toeplitz_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Traverse 2 | 3 | - Time complexity: O(m*n) 4 | - Space complexity: O(1) 5 | 6 | -------------------------------------------------------------------------------- /mst17.21_Volume_of_Histogram_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | 总体积 - 柱体体积 4 | 5 | 总体积一层一层的算。 6 | 7 | 注意这道题与11题的区别 8 | -------------------------------------------------------------------------------- /util_java/tree/TreeNode.class: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/util_java/tree/TreeNode.class -------------------------------------------------------------------------------- /0024_Swap_Nodes_in_Pairs/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 direct swap 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0058_Length_of_Last_Word/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 从右向左遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 从右往左遍历，先跳过所有的空格。再一次遇到空格时，结束。 7 | -------------------------------------------------------------------------------- /0083_Remove_Duplicates_from_Sorted_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0198_House_Robber/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | dp[i]表示到i为止，能打劫的最大数。 4 | 5 | dp[i] = max(dp[i-2] + nums[i], dp[i-1]); 6 | 7 | -------------------------------------------------------------------------------- /0219_Contains_Duplicate_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 思路同217，不过value存的是索引 7 | -------------------------------------------------------------------------------- /0240_Search_a_2D_Matrix_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Z-search 2 | 3 | - t-complexity: $O(m+n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0244_Shortest_Word_Distance_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用hash，键是word，值是word的索引的数组。 4 | 5 | 然后我们双重循环word1和word2两个数组，找出最小值即可。 6 | -------------------------------------------------------------------------------- /0266_Palindrome_Permutation/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 出现单词的 char 数不能 > 1 7 | -------------------------------------------------------------------------------- /0461_Hamming_Distance/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 异或 2 | 3 | - 时间复杂度 O(1) 4 | - 空间复杂度 O(1) 5 | 6 | 异或后统计1个个数，即是 x 和 y 之间不同比特位的个数 7 | -------------------------------------------------------------------------------- /0671_Second_Minimum_Node_In_a_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dfs 2 | 3 | 每层调用的 cur 是根节点的值。 4 | 5 | 利用 dfs 找到比 cur 大的第一个数 6 | -------------------------------------------------------------------------------- /0692_Top_K_Frequent_Words/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash table + priority queue 2 | 3 | - 时间复杂度 O(n * logk) 4 | - 空间复杂度 O(n) 5 | -------------------------------------------------------------------------------- /0889_Construct_Binary_Tree_from_Preorder_and_Postorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 from root to leaf build tree 2 | 3 | -------------------------------------------------------------------------------- /0057_Insert_Interval /slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心算法 2 | 3 | 遍历一遍intervals。当前指向的区间结尾 < 新区间开头的，直接放到结果中。 4 | 5 | 注意这里更新的是newInterval本身 6 | 7 | -------------------------------------------------------------------------------- /0080_Remove_Duplicates_from_Sorted_Array_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 类似remove duplicates1，不过检查前两个。 4 | 5 | 因为是有序的，所以只用比较大小就行了 6 | -------------------------------------------------------------------------------- /0170_Two_Sum_III_-_Data_structure_design/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 和 two sum 1 类似 2 | 3 | 用set来记录数据。 4 | 5 | 在find的时候，类似第一题two sum的解法 6 | -------------------------------------------------------------------------------- /0261_Graph_Valid_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | 3 | 判断图是不是树，满足两点 4 | 5 | - 是连通图 6 | - 不存在环，即要求边数小于顶点数 7 | 8 | 如果边 >= 顶点数，则必存在环 9 | -------------------------------------------------------------------------------- /0331_Verify_Preorder_Serialization_of_a_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 计算出度和入度 2 | 3 | 在有向图中，出度和入度是相等的。 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /0387_First_Unique_Character_in_a_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | - 时间复杂度 O(2n) 4 | - 空间复杂度 O(n) 5 | 6 | 遍历两遍，第一遍计数，第二遍判断 7 | -------------------------------------------------------------------------------- /0399_Evaluate_Division/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | 3 | 用图来解决，边是有向的。边的权就是两个节点相除 4 | 5 | start / end = (start / tmp) * (tmp / end) 6 | -------------------------------------------------------------------------------- /0408_Valid_Word_Abbreviation/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 扩展 abbr，最后判断长度是否和 word 相等 7 | -------------------------------------------------------------------------------- /0495_Teemo_Attacking/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 traverse + simulate 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0506_Relative_Ranks/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash and sort 2 | 3 | - t-complexity: $O(n * logn)$ 4 | - s-complexity: $O(n)$ 5 | 6 | -------------------------------------------------------------------------------- /0897_Increasing_Order_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 in-order dfs 2 | 3 | - t-complexity: O(N) 4 | - s-complexity: O(N) 5 | 6 | -------------------------------------------------------------------------------- /1720_Decode_XORed_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 反向异或 2 | 3 | a ^ b = c --> a = b ^ c 4 | 5 | 且异或有交换律 6 | 7 | a ^ b = c --> b ^ a = c -------------------------------------------------------------------------------- /0145_Binary_Tree_Postorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 迭代 2 | 3 | 前序是 中左右， 4 | 5 | 首先调整代码 左右顺序，变成 中右左， 6 | 7 | 再反转，就成了 左右中 8 | 9 | -------------------------------------------------------------------------------- /0224_Basic_Calculator/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 stack 2 | 3 | 用栈来模拟递归 4 | 5 | - 进入括号的时候把之前的状态入栈，然后计算括号内的内容。 6 | - 退出括号的时候还原之前的状态。 7 | 8 | -------------------------------------------------------------------------------- /0290_Word_Pattern/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 利用一个map和set 4 | 5 | map保存pattern字符到单词的映射， 6 | set保存已经加入到map中的单词，防止不用pattern对应的word重复 7 | -------------------------------------------------------------------------------- /0299_Bulls_and_Cows/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 emulate + hash 2 | 3 | - t-complexity $O(n)$ 4 | - s-complexity $O(C)$ 5 | C = 10 6 | 7 | -------------------------------------------------------------------------------- /0350_Intersection_of_Two_Arrays_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 用两个字典统计两边数组中每个数出现的次数，最后在添加到res里 7 | -------------------------------------------------------------------------------- /0401_Binary_Watch/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历时间 2 | 3 | - 时间复杂度 O(1) 4 | - 空间复杂度 O(1) 5 | 6 | 遍历所有时间，统计其中 1 个个数的和，如果等于 turnOn，则加入结果数组 7 | -------------------------------------------------------------------------------- /0653_Two_Sum_IV_-_Input_is_a_BST/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 in-order dfs + hash 2 | 3 | - t-complexity: O(n) 4 | - s-complexity: O(n) 5 | 6 | -------------------------------------------------------------------------------- /0703_Kth_Largest_Element_in_a_Stream/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 优先队列 2 | 3 | 用最小堆维护数据。 4 | 5 | 返回第k大的时候，把k之前的数都pop掉。最后que里还剩k个元素，que[0]就是第k大的数。 6 | -------------------------------------------------------------------------------- /0930_Binary_Subarrays_With_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 pre sum + hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 可以看做是 two sum 的升级版 7 | -------------------------------------------------------------------------------- /1052_Grumpy_Bookstore_Owner/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Sliding window 2 | 3 | final-satisfied = origin-satisfied + grumpy-but-X-turned 4 | 5 | -------------------------------------------------------------------------------- /1711_Count_Good_Meals/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 可以看成是 two sum 的升级版，只是 sum 是 power of 2 7 | -------------------------------------------------------------------------------- /1846_Maximum_Element_After_Decreasing_and_Rearranging/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 排序 + 遍历模拟 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | -------------------------------------------------------------------------------- /t.py: -------------------------------------------------------------------------------- 1 | from PIL import Image, ImageDraw, ImageFont 2 | 3 | 4 | img = Image.open('gfg_logo.png') 5 | d1 = ImageDraw.Draw(img) 6 | 7 | 8 | -------------------------------------------------------------------------------- /0022_Generate_Parentheses/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 DFS 2 | 3 | 我们用l和r分别表示还需要加到字符串中的数目。为了保证字符串合法，剩下的右括号必须大于等于左括号，如果剩下的右括号小于左括号，说明有左括号没有与之匹配的右括号。 4 | 5 | -------------------------------------------------------------------------------- /0041_First_Missing_Positive/slt.md: -------------------------------------------------------------------------------- 1 | # 思路1 把数组中的正数按数值重新放在数组中 2 | 3 | 比如，当前遍历到的元素是5，则把它放在nums[4]这个位置。最后再遍历数组，找到第一个没有被正确放置的位置的索引idx，返回idx+1。 4 | -------------------------------------------------------------------------------- /0169_Majority_Element/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 摩尔投票法 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 也可以理解成混战极限一换一，不同的两者一旦遇见就同归于尽，最后活下来的值都是相同的，即要求的结果 7 | -------------------------------------------------------------------------------- /0326_Power_of_Three/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 数学方法 2 | 3 | - 时间复杂度 $O(logn)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 如果能整数3则不断整除3，最后判断留下来的数是不是1。$3^{0} = 1$ 7 | -------------------------------------------------------------------------------- /0526_Beautiful_Arrangement/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 回溯 2 | 3 | - 时间复杂度 $O(n!)$ 4 | - 空间复杂度 $O(n^2)$ 5 | 6 | 用一个 match 二维数组先把匹配的对都加好，再 dfs 7 | -------------------------------------------------------------------------------- /0538_Convert_BST_to_Greater_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 right-mid-left traverse 2 | 3 | - t-complexity: O(n) 4 | - s-complexity: O(n) 5 | 6 | -------------------------------------------------------------------------------- /0541_Reverse_String_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 遍历 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(1)$ 5 | python 是$O(n)$ 6 | 7 | 注意对最后不满 k 的处理即可 8 | -------------------------------------------------------------------------------- /0863_All_Nodes_Distance_K_in_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 建图 + BFS 2 | 3 | 二叉树中每个节点最多3个相邻的节点，是稀疏图。用「邻接表」的形式进行存储 4 | 5 | 6 | 7 | 8 | -------------------------------------------------------------------------------- /1074_Number_of_Submatrices_That_Sum_to_Target/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + hash 表优化 2 | 3 | - 时间复杂度 O(n^3), 设矩形长宽同阶为n 4 | - 空间复杂度 O(n^2) 5 | -------------------------------------------------------------------------------- /1894_Find_the_Student_that_Will_Replace_the_Chalk/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 求模 + 模拟 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | -------------------------------------------------------------------------------- /util_py/__pycache__/list.cpython-38.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/util_py/__pycache__/list.cpython-38.pyc -------------------------------------------------------------------------------- /util_py/__pycache__/tree.cpython-38.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/util_py/__pycache__/tree.cpython-38.pyc -------------------------------------------------------------------------------- /0133_Clone_Graph/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归dfs 2 | 3 | 用一个数组visited来存放新创建的结点 4 | 5 | 这个数组同时实现了两个功能： 6 | 7 | - 判断val对应的新的结点有没有被创建 8 | - 通过val值get新建的结点 9 | -------------------------------------------------------------------------------- /0215_Kth_Largest_Element_in_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用快排的partition 2 | 3 | 首先假设一共n个数，第k大，就是正数n-k+1个数，目标索引就是n-k 4 | 5 | 利用快排的partition返回目标索引的原理 6 | -------------------------------------------------------------------------------- /0237_Delete_Node_in_a_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 copy value of next node 2 | 3 | - t-complexity: $O(1)$ 4 | - s-complexity: $O(1)$ 5 | 6 | -------------------------------------------------------------------------------- /0354_Russian_Doll_Envelopes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP + Sort 2 | 3 | > Time complexity: O(n^2) 4 | 5 | 先按照 w 排序，把问题转化成找 h 的最长上升子序列的问题。 6 | 7 | 8 | -------------------------------------------------------------------------------- /0492_Construct_the_Rectangle/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 枚举 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | l 从 sqrt(area) 开始递增枚举，w 为 area / l 整除的数 7 | -------------------------------------------------------------------------------- /0922_Sort_Array_By_Parity_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 两次遍历 2 | 3 | 一次把A中的偶数放到res[0], res[2], res[4]... 中 4 | 5 | 一次把A中的奇数放到res[1], res[3], res[5]... 中 6 | -------------------------------------------------------------------------------- /0945_Minimum_Increment_to_Make_Array_Unique/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash的思想 用一个数字来记录重复出现的数字的个数 2 | 3 | 如果数3，一共出现了5次，则我们把其中四个3都加1，res += 4，然后，数4出现的次数也要加4 4 | -------------------------------------------------------------------------------- /util_py/__pycache__/__init__.cpython-38.pyc: -------------------------------------------------------------------------------- https://raw.githubusercontent.com/siria55/leetcode_solutions/HEAD/util_py/__pycache__/__init__.cpython-38.pyc -------------------------------------------------------------------------------- /0093_Restore_IP_Addresses/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 暴力枚举 2 | 3 | len(new_str) == len(s) + 3 4 | 最后加这个长度判断是过滤掉leading zeros的情况 5 | 如010010 6 | 变成 7 | 0.1.1.0是不符合要求的 -------------------------------------------------------------------------------- /0151_Reverse_Words_in_a_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 如果这道题用语言库或语言特性，就失去了考察的意义 4 | 5 | 1 reverse whole str 6 | 2 reverse each word 7 | 3 clean spaces -------------------------------------------------------------------------------- /0182_Duplicate_Emails/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用GROUP BY 2 | 3 | ```sql 4 | SELECT email 5 | FROM Person 6 | GROUP BY email 7 | HAVING COUNT(*)>1; 8 | ``` 9 | -------------------------------------------------------------------------------- /0304_Range_Sum_Query_2D_-_Immutable/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Presum 2 | 3 | Multiple one dimensional presum. 4 | 5 | Each row treat as an array. 6 | 7 | -------------------------------------------------------------------------------- /0494_Target_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS + cache 2 | 3 | 考虑不加缓存的情况 4 | 5 | - 时间复杂度 (2^n) 6 | 每个 n 都有 -+ 两种情况，类似于求 n 个元素集合的幂集 7 | - 空间复杂度 (n) 8 | -------------------------------------------------------------------------------- /0528_Random_Pick_with_Weight/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + 二分查找 2 | 3 | - 时间复杂度 4 | - 构造函数 $O(n)$ 5 | - pickIndex $O(logn)$ 6 | - 空间复杂度 $O(1)$ 7 | -------------------------------------------------------------------------------- /0084_Largest_Rectangle_in_Histogram/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 暴力枚举 2 | 3 | 中心扩散法，n^2时间复杂度 4 | 5 | 注意在外面的循环中如果height[i] == height[i-1]可以直接跳过，两个的面积是一样的。如果不做这个优化会超时 6 | -------------------------------------------------------------------------------- /0205_Isomorphic_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | - 时间复杂度 O(n ^ 2) 4 | - 空间复杂度 O(1) 5 | 6 | 遍历判断每个字符在 s 和 t 中各自出现的首位置 7 | 8 | 同构词相应字母出现的首位置必然是相同的。 9 | -------------------------------------------------------------------------------- /0452_Minimum_Number_of_Arrows_to_Burst_Balloons/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | 6 | 贪心法, 每个气球只少需要一支箭, 先按照右端点排序, 7 | 8 | -------------------------------------------------------------------------------- /0605_Can_Place_Flowers/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 greedy 2 | 3 | 注意 flowerbed 中已经满足了相邻不种的规则。 4 | 5 | 遇到 1 跳两步。 6 | 与到 0 时。由于前面 1 都是跳的 2。则前面必然是 0，只需要判断后面一个 7 | -------------------------------------------------------------------------------- /1232_Check_If_It_Is_a_Straight_Line/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 检查斜率 2 | 3 | 如果直接用y/x，需要检查x为0的特例。可以改用乘法 4 | 5 | y1 / x1 = y0 / x0 6 | 7 | -> 8 | 9 | x1 * y0 = y1 * x0 -------------------------------------------------------------------------------- /0187_Repeated_DNA_Sequences/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash map 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(n)$ 5 | 6 | 用hash存放出现的字符串。最后扫描一遍hash表 7 | 8 | -------------------------------------------------------------------------------- /0242_Valid_Anagram/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash map 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | anagram就是字符出现出现词数一样的单词。 7 | 8 | 利用hash map记录两个字符串中每个字符出现的词数 9 | -------------------------------------------------------------------------------- /0378_Kth_Smallest_Element_in_a_Sorted_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 矩阵二分查找 2 | 3 | 判断mid在排序中的位置是否 >= k 4 | 如果 >= k说明k在mid前面（包括），right=mid 5 | 如果 3000000 OR population > 25000000; 7 | ``` 8 | -------------------------------------------------------------------------------- /1208_Get_Equal_Substrings_Within_Budget/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 滑动窗口 2 | 3 | 用一个数组记录两个字符串每个字符的 ascii 差值，问题边转换为 4 | 5 | 在一个数组中，在连续子数组的和 <= `maxCost` 的情况下，找到这个连续子数组的最大长度 -------------------------------------------------------------------------------- /mst16.24_Pairs_With_Sum_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Hash 2 | 3 | Similar to the classical `Two Sum` problem but use hash value to record the nubmer counts. 4 | 5 | -------------------------------------------------------------------------------- /0043_Multiply_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用双重循环模拟标准的乘法 2 | 3 | 99 * 99 = 9801 4 | 99 * 999 = 98901 5 | 6 | a位数 * b位数 的结果最多有a+b位 7 | 8 | 注意这题python的写法不能写到其他语言中，会溢出 9 | -------------------------------------------------------------------------------- /0139_Word_Break/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dp 2 | 3 | dp[i]表示字符串s的前i个字符能否拆分成wordDict。 4 | 注意dp中i和j是从1开始，而s中是索引 5 | dp[i] = dp[j] && s.substr(j, i-j) in wordDic 6 | 7 | -------------------------------------------------------------------------------- /0268_Missing_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 数学方法 2 | 3 | 时间复杂度 O(n) 4 | 空间复杂度 O(1) 5 | 6 | 高斯求和法求得 _sum = (n * (n+1)) / 2 7 | 8 | 再遍历 nums，用 _sum 依次减去每一个数，留下来的就是结果 9 | -------------------------------------------------------------------------------- /0518_Coin_Change_2/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | https://leetcode-cn.com/problems/coin-change-2/solution/ling-qian-dui-huan-iihe-pa-lou-ti-wen-ti-dao-di-yo/ 4 | -------------------------------------------------------------------------------- /0620_Not_Boring_Movies/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT * 5 | FROM cinema 6 | WHERE description!="boring" AND MOD(id,2)=1 7 | ORDER BY rating DESC; 8 | ``` 9 | -------------------------------------------------------------------------------- /1004_Max_Consecutive_Ones_III/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Sliding window 2 | 3 | convert problem from "max K 0 to 1" to "find a subarray which contains at most K 0". 4 | 5 | -------------------------------------------------------------------------------- /1148_Article_Views_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT DISTINCT author_id AS id 5 | FROM Views 6 | WHERE author_id=viewer_id 7 | ORDER BY author_id; 8 | ``` 9 | -------------------------------------------------------------------------------- /1190_Reverse_Substrings_Between_Each_Pair_of_Parentheses/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 模拟 + 栈 2 | 3 | - 时间复杂度 O(n^2) 4 | 最坏情况，每个字符右边都有一个`)` 5 | - 空间复杂度 O(n) 6 | 7 | 8 | -------------------------------------------------------------------------------- /1202_Smallest_String_With_Swaps/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 2 | 3 | 交换关系具有传递性。 4 | 5 | 我们先用并查集，把所有能互换的索引放到一个连通分量里。 6 | 7 | 再维护一个字典：key是连通分量的根，value是连通分量里字符的list。然后把这个list排序 -------------------------------------------------------------------------------- /0068_Text_Justification/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心 遍历words 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(n)$ 5 | 6 | 第一次遍历，把 words 按 line 分好 7 | 第二次遍历，加空格组成字符串， 8 | 注意最后一行 left justify 9 | -------------------------------------------------------------------------------- /0105_Construct_Binary_Tree_from_Preorder_and_Inorder_Traversal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用个 hash 加速查找 pre 中第一个节点在 in 中的位置 4 | 5 | 注意新建的node一定要用new，不然局部变量不会存在在其作用域之外。 6 | 7 | -------------------------------------------------------------------------------- /0118_Pascal's_Triangle/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 按数学方法添加 2 | 3 | 按数学方法，找出规律循环即可 4 | 5 | [1], 6 | [1,1], 7 | [1,2,1], 8 | [1,3,3,1], 9 | [1,4,6,4,1] 10 | 11 | 这样更容易看出规律 12 | -------------------------------------------------------------------------------- /0493_Reverse_Pairs/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 分治。利用归并排序的思路 2 | 3 | 直接双重循环会超时 4 | 5 | 我们把原数按顺序组分成前后A和B两个子集 6 | 7 | 原数组的结果就等于 = A中的res + B中的res + A中大于两倍B中的元素个数 8 | 9 | 10 | -------------------------------------------------------------------------------- /0820_Short_Encoding_of_Words/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 用一个set存储后缀 2 | 3 | 我们把所有words存在一个集合中，再遍历每个单词的所有后缀。如果和这个后缀相同的单词也在集合中，则从集合中剔除这个单词。 4 | 5 | 即集合最后只保留无法作为其他单词的后缀的单词。最后再加上#的长度即可 6 | -------------------------------------------------------------------------------- /0030_Substring_with_Concatenation_of_All_Words/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 双重循环遍历s和words，用两个hash，一个记录words中的word count，另一记录s中出现了的word count。 4 | 5 | 时间复杂度`O(s.size() * words.size())` -------------------------------------------------------------------------------- /0075_Sort_Colors/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历一次，遇到0放到前面，遇到2放到后面 2 | 3 | 用left和right分别标志左边已经是0和右边已经是2的位置。 4 | 5 | 注意 6 | 7 | 1. 只有没有swap的时候，i才能继续移动。 8 | 2. 如果要swap i必须大于left且小于right。 9 | -------------------------------------------------------------------------------- /0213_House_Robber_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 类似198，只不过用两个状态方程，一个从第一个房子开始，一个从第二个房子开始 4 | 5 | 从第一个房子开始的不算最后一个。且第一个状态方程的i=0和i=1都是nums[0]。因为要求了从第一个房子开始，第二个房子就不应该被算进去 6 | 7 | -------------------------------------------------------------------------------- /0263_Ugly_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 数学方法 2 | 3 | - 时间复杂度 O(logn) 4 | 2 * x 次方，不断除以2，就会除 x 次。x = log2(2 ^ x) 5 | - 空间复杂度 O(1) 6 | 7 | 若能被235整数，则一直除235。再判断最后留下来的数是不是1 8 | -------------------------------------------------------------------------------- /0520_Detect_Capital/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 遍历统计 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 分别统计大小写字符的个数，再判断，一共就三种正确情况 7 | 8 | - 大全写 9 | - 全小写 10 | - 首字母大写，其他全小写 11 | -------------------------------------------------------------------------------- /0785_Is_Graph_Bipartite?/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 BFS + 染色法 2 | 3 | 0 represents unvisited nodes, 1 and 2 represent two colors 4 | 5 | 把相邻的节点染成不同颜色，如果相邻节点颜色相同，则返回 false 6 | 7 | -------------------------------------------------------------------------------- /1203_Sort_Items_by_Groups_Respecting_Dependencies/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 拓扑排序 2 | 3 | 1. 构造小组的依赖关系和组内项目的依赖关系。 4 | 2. 判断小组间是否有冲突，没冲突计算出小组的拓扑排序。 5 | 3. 判断每个小组内项目是否有冲突，没冲突计算出小组内项目的拓扑排序。 -------------------------------------------------------------------------------- /0040_Combination_Sum_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 DFS 2 | 3 | 和上一道题非常类似。两个不同之处：一是对重复元素的检查，二是一个元素只用一次 4 | 5 | 上一题candidates里面没有重复的元素，所以所有的组合必然是不同的。这题里面candidates里面有重复的元素，为了保证没有重复的组合，需要检查 6 | -------------------------------------------------------------------------------- /0503_Next_Greater_Element_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 单调栈 2 | 3 | 单调栈递减。如果遇到一个大于栈顶的元素，说明这个元素就是当前栈顶元素的next greater element 4 | 5 | But we store index stead of number directly. 6 | 7 | -------------------------------------------------------------------------------- /0976_Largest_Perimeter_Triangle/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 不失一般性，我们假设三角形的边长满足 a≤b≤c，那么这三条边组成面积不为零的三角形的充分必要条件为 a+b>c。 4 | 5 | 把A按增序排序，然后从后往前找相邻的三个元素满足abc的条件即可。 6 | 7 | 时间复杂度O(nlogn) 8 | -------------------------------------------------------------------------------- /1068_Product_Sales_Analysis_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT p.product_name, s.year, s.price 5 | FROM Sales s JOIN Product p 6 | ON s.product_id=p.product_id; 7 | ``` 8 | -------------------------------------------------------------------------------- /1143_Longest_Common_Subsequence/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | - t-complexity: $O(m*n)$ 4 | - s-complexity: $O(m*n)$ 5 | 6 | dp[i][j] 是 text1 以 i 结尾，text2 以 j 结尾，的LCS 7 | 8 | -------------------------------------------------------------------------------- /1221_Split_a_String_in_Balanced_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 贪心 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | 用 diff 记录 L 和 R 出现的次数之差，等于 0 时说明平衡，则结果 + 1 7 | -------------------------------------------------------------------------------- /1370_Increasing_Decreasing_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 桶技术 2 | 3 | 用一个大小为26的桶统计每个字符出现的次数。然后在从a到z再从z到a把桶里的字符加到res里 4 | 5 | |M|是字符集，这里是26 6 | 7 | 时间复杂度O(len(s) * |M|) 8 | 空间复杂度O(|M|) 9 | -------------------------------------------------------------------------------- /0042_Trapping_Rain_Water/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 从左右按矮的一方往中间逼近 2 | 3 | 在收缩的时候，左边最高的边也比右边低，右边最高的边也比左边低。因为我们就是按照矮的一边来收缩的， 4 | 5 | 在左右内部，我们再分别记录遇到的最高的边。然后用这个最高的边来计算后面的水量。 6 | 7 | 注意这道题与11题的区别 8 | -------------------------------------------------------------------------------- /0149_Max_Points_on_a_Line/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 暴力枚举 2 | 3 | - 时间复杂度 O(n^3) 4 | - 空间复杂度 O(1) 5 | 6 | 两点可以形成一条直线，在这个基础上再判断其他点在不在直线内 7 | 8 | 在计算斜率的时候用乘法，可以 skip 掉很多 corner cases... 9 | -------------------------------------------------------------------------------- /0584_Find_Customer_Referee/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 注意好对NULL的处理即可。 4 | 5 | ```sql 6 | SELECT name 7 | FROM customer 8 | WHERE referee_id != 2 OR referee_id IS NULL; 9 | ``` 10 | -------------------------------------------------------------------------------- /0633_Sum_of_Square_Numbers/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 two-pointers 2 | 3 | https://leetcode-cn.com/problems/sum-of-square-numbers/solution/shuang-zhi-zhen-de-ben-zhi-er-wei-ju-zhe-ebn3/ 4 | -------------------------------------------------------------------------------- /1104_Path_In_Zigzag_Labelled_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 二叉树性质 2 | 3 | 1. h 层满二叉树总共节点数为 2 ^ h - 1 4 | 2. 那么满二叉树第k层的结点标记为[2^(k-1), 2^k-1] 5 | 3. label 节点在正常的完全二叉树的父节点为 label / 2 6 | -------------------------------------------------------------------------------- /1600_Throne_Inheritance/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 字典 + 链表 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 字典存放所有人名，value 是那个人的孩子名字链表 7 | 8 | 另外用一个集合存放有没有死 9 | 10 | 最后用 前序遍历 获得结果 11 | -------------------------------------------------------------------------------- /0208_Implement_Trie_(Prefix_Tree)/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 参考： 4 | https://leetcode-cn.com/problems/implement-trie-prefix-tree/solution/trie-tree-de-shi-xian-gua-he-chu-xue-zhe-by-huwt/ 5 | 6 | -------------------------------------------------------------------------------- /0613_Shortest_Distance_in_a_Line/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | min + abs + 自联结 4 | 5 | ```sql 6 | SELECT MIN(ABS(p1.x - p2.x)) AS shortest 7 | FROM point p1 JOIN point p2 8 | ON p1.x != p2.x; 9 | ``` -------------------------------------------------------------------------------- /0724_Find_Pivot_Index/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 前缀和 2 | 3 | 设index左边的和为left_sum，满足条件的idx会有下面的等式成立 4 | 5 | 6 | left_sum == total - nums[idx] - left_sum 7 | 8 | total - nums[idx] - left_sum 就是 right_sum 9 | -------------------------------------------------------------------------------- /1011_Capacity_To_Ship_Packages_Within_D_Days/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | 在不考虑天数的情况下，最低运力是 max(weights)，最高运力是 sum(weights) 4 | 5 | 然后在 [max(weights), sum(weights)] 之间用二分 + 试探的方法找到满足D天的最小运力 6 | -------------------------------------------------------------------------------- /1378_Replace Employee_ID_With_The_Unique_Identifier/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 left join 2 | 3 | ```sql 4 | SELECT u.unique_id, e.name 5 | FROM Employees e LEFT JOIN EmployeeUNI u 6 | ON e.id=u.id; 7 | ``` 8 | -------------------------------------------------------------------------------- /0088_Merge_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 归并排序 2 | 3 | - 时间复杂度 $O(m + n)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 这道题需要在nums1里就地归并，为了避免覆盖nums1的元素，我们从后往前进行归并。 7 | 8 | 另外结果本来就要存在nums1中，所以最后只用检查nums2有没有走完，nums1不用检查。 9 | -------------------------------------------------------------------------------- /0124_Binary_Tree_Maximum_Path_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | 3 | - 一个节点要么往上走（父节点），要么往下走（右子节点）。每条路径有一个最高点。 4 | - max_down(node)递归 5 | 1. 计算了以node为最高点的路径的sum。（用来更新res） 6 | 2. 为node节点的父节点返回了 左或右（再加上自己）的最大值 -------------------------------------------------------------------------------- /0200_Number_of_Islands/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs标记岛屿 2 | 3 | 思路：遍历岛这个二维数组，如果当前数为1，则进入感染函数并将岛个数+1 4 | 5 | 感染函数：其实就是一个递归标注的过程，它会将所有相连的1都标注成2。为什么要标注？这样就避免了遍历过程中的重复计数的情况，一个岛所有的1都变成了2后，遍历的时候就不会重复遍历了。建议没想明白的同学画个图看看。 -------------------------------------------------------------------------------- /0610_Triangle_Judgement/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用CASE...WHEN... 4 | 5 | ```sql 6 | SELECT x, y, z, 7 | IF((x+y>z AND x+z>y AND y+z>x), 'Yes', 'No') AS triangle 8 | FROM triangle; 9 | ``` 10 | -------------------------------------------------------------------------------- /1350_Students_With_Invalid_Departments/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT s.id, s.name 5 | FROM Students s LEFT JOIN Departments d 6 | ON s.department_id=d.id 7 | WHERE d.id IS NULL; 8 | ``` 9 | -------------------------------------------------------------------------------- /0130_Surrounded_Regions/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用排除法：先找到所有连接起来与边界连通的O，将这些O标记一下，然后遍历数组，所有没有被标记的O就是我们要找的O。 4 | 5 | 首先对边界上每一个'O'做深度优先搜索，将与其相连的所有'O'改为'-'。 6 | 7 | 然后遍历矩阵，将矩阵中所有'O'改为'X',将矩阵中所有'-'变为'O' 8 | 9 | -------------------------------------------------------------------------------- /0511_Game_Play_Analysis_I/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | GROUP BY + MIN 4 | 5 | ```sql 6 | SELECT player_id, MIN(event_date) AS first_login 7 | FROM Activity 8 | GROUP BY player_id; 9 | ``` 10 | -------------------------------------------------------------------------------- /1579_Remove_Max_Number_of_Edges_to_Keep_Graph_Fully_Traversable/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 2 | 3 | 用两个并查集分别代表两个人。 4 | 5 | 先遍历第三类边，把这个边的连通的部分分别merge到两个人里面。 6 | 7 | 用一个res计数，如果遍历到已经连通的边，则说明这个边的多余的，可以去掉，这时res+=1 8 | -------------------------------------------------------------------------------- /0011_Container_With_Most_Water/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 从两边到中间宽度递减算water 2 | 3 | `crystal clear`的solution [link](https://leetcode.com/problems/container-with-most-water/discuss/6100/Simple-and-clear-proofexplanation) 4 | -------------------------------------------------------------------------------- /0078_Subsets/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 Traceback 2 | 3 | Can be done with both iteration and recursion methods. 4 | 5 | 使用回溯法（递归） 6 | 7 | 子集，即每个元素都可能存在或不存在。 8 | 9 | n个元素的集合有2^n个子集。 10 | 11 | 注意不要和全排列和组合搞混淆 12 | -------------------------------------------------------------------------------- /0175_Combine_Two_Tables/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 直接用left join 2 | 3 | ```sql 4 | SELECT P.firstName, P.lastName, A.city, A.state 5 | FROM Person AS P LEFT JOIN Address AS A 6 | ON P.personId=A.personId; 7 | ``` 8 | 9 | -------------------------------------------------------------------------------- /0318_Maximum_Product_of_Word_Lengths/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 brute force simulation 2 | 3 | - t-complexity: $O(N^2i * L)$ 4 | N is length of words, L is length of words[i] 5 | - s-complexity: $O(1)$ 6 | 7 | -------------------------------------------------------------------------------- /0424_Longest_Repeating_Character_Replacement/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 sliding window 2 | 3 | 每次for loop都r++，如果 4 | 5 | 用history_char_max记录当前窗口内出现的最多的相同的字符的个数。 6 | 如果 history_char_max + k > 窗口长度，则窗口是满足要求的。否则 l += 1 7 | -------------------------------------------------------------------------------- /0483_Smallest_Good_Base/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 二分 + 模拟 2 | 3 | - 时间复杂度 4 | - 空间复杂度 5 | 6 | 数据范围1e18。以最小的二进制，最大的数1e18计算，1的个数也不会超过60。 7 | 8 | `2^64 = 10^(64*lg2) = 10^(64*0.3) = 10^19.2` 9 | 10 | 11 | -------------------------------------------------------------------------------- /0664_Strange_Printer/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | - 时间复杂度 O(n^3) 4 | - 空间复杂度 O(n^2) 5 | 6 | https://leetcode-cn.com/problems/strange-printer/solution/xin-shou-pian-cong-xiao-wen-ti-zai-dao-q-qifh/ 7 | 8 | -------------------------------------------------------------------------------- /0680_Valid_Palindrome_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 双指针 2 | 3 | - 时间复杂度 $O(n)$ 4 | 虽然在 while 里验证回文，但实际最多验证两次 5 | - 空间复杂度 $O(1)$ 6 | 7 | 如果一次 s[l] != s[r] 都没遇到，则返回 true 8 | 如果遇到 s[l] != s[r]，则分别删除左右两边，只要有一个满足就行 9 | -------------------------------------------------------------------------------- /0725_Split_Linked_List_in_Parts/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 simulation 2 | 3 | - t-complexity $O(n)$ 4 | - s-complexity $O(1)$ 5 | 6 | divide to get lenth of each pair, add and first [0, remainder-1] one more node 7 | -------------------------------------------------------------------------------- /0726_Number_of_Atoms/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 stk + 从后往前，一次遍历 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | stk的含义： 7 | 8 | 假设 formula 是 `K4(ON(SO3)2)2`，那么stk的变化是 9 | 10 | [1] -> [1,2] -> [1,2,4] 11 | -------------------------------------------------------------------------------- /1303_Find_the_Team_Size/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT e1.employee_id, COUNT(*) AS team_size 5 | FROM Employee e1 JOIN Employee e2 6 | ON e1.team_id=e2.team_id 7 | GROUP BY e1.employee_id; 8 | ``` 9 | -------------------------------------------------------------------------------- /0064_Minimum_Path_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 还是dp 2 | 3 | 注意处理边界情况 4 | 5 | dp[i][j]表示到点[i][j]时的最短路，那么我们可以写出公式 6 | 7 | `dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]` 8 | 9 | 同62题的情况，这道题也可以压缩空间 10 | 11 | -------------------------------------------------------------------------------- /0283_Move_Zeroes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 交换法 2 | 3 | 时间复杂度 O(n*n) 4 | 空间复杂度 O(1) 5 | 6 | 一次遍历，遇到0就和后面第一个不是0的交换。 7 | 8 | ### 思路2 尾插法 9 | 10 | 时间复杂度 O(n) 11 | 空间复杂度 O(1) 12 | 13 | 一次遍历，把不是0的数依次放到原数组中。最后再补上0 14 | -------------------------------------------------------------------------------- /0301_Remove_Invalid_Parentheses/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS 2 | 3 | 1. traverse s, get matched left and right parentheses count 4 | 2. dfs, delete corresponding left and right parenthese, and see if is valid 5 | 6 | -------------------------------------------------------------------------------- /0525_Contiguous_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 当0与1数量一致时(连续数组), 其连续数组的和为零。 7 | 8 | cur 遇到 1 +1， 遇到 0 -1。 9 | 10 | 于是只要我们遇到了两个相同的 cur 中间的 1 和 0 的数量一定是相同的 11 | -------------------------------------------------------------------------------- /0567_Permutation_in_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 滑动窗口 + hash 2 | 3 | 一个hash表记录窗口个每个字符应该出现的个数 4 | 5 | 用s1中的各个字符来初始化hash表 6 | 7 | - > 0, 表示s2窗口中还应该出现多少次 8 | - == 0，说明s1中的字符用完了刚好 9 | - < 0, 说明s2中窗口的已经出现了过多的那个字符 10 | -------------------------------------------------------------------------------- /0026_Remove_Duplicates_from_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 就地算法 2 | 3 | 注意，这道题的返回结果使用引用传出去。 4 | 5 | 我们用new_tail来作为已经整理好的没有重复元素的数组的最后一个索引。然后用i去找后面的元素，如果重复就跳过，如果i和new_tail的元素不同，则把i上的元素放到new_tail后面。时间复杂度为O(n),空间复杂度为O(1)。 6 | -------------------------------------------------------------------------------- /0056_Merge_Intervals/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 按照start排序，再合并 2 | 3 | 有点像machine test guide中看最多节目的那道题。 4 | 5 | 复杂度：Sorting takes O(n log(n)) and merging the intervals takes O(n). So, the resulting algorithm takes O(n log(n)). 6 | -------------------------------------------------------------------------------- /0087_Scramble_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 递归 2 | 3 | 首先，这两个字符串长度要想等， 4 | 其次，这两个字符串组成要一样 5 | 然后，S和T中，至少存在一个i，使得S的前半段和T的前半段扰动，S后半段和T后半段扰动；或者S前半段和T后半段扰动，S后半段和T前半段扰动（镜像对称）； 6 | 7 | python 直接回超时，需要加一个缓存才能过。python的 str slice 很耗时。 8 | -------------------------------------------------------------------------------- /0367_Valid_Perfect_Square/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 traverse 2 | 3 | - t-complexity O(n) 4 | - t-complexity O(1) 5 | 6 | ### Solution 2 bi-search 7 | 8 | - t-complexity $O(logn)$ 9 | - s-complexity $O(1)$ 10 | 11 | -------------------------------------------------------------------------------- /0458_Poor_Pigs/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 转化为 k 进制问题 2 | 3 | - t-complexity: $O(1)$ 4 | - s-complexity: $O(1)$ 5 | 6 | https://leetcode-cn.com/problems/poor-pigs/solution/tong-ge-lai-shua-ti-la-k-jin-zhi-wen-ti-ha2ze/ 7 | 8 | -------------------------------------------------------------------------------- /1050_Actors_and_Directors_Who_Cooperated_At_Least_Three_Times/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT actor_id, director_id 5 | FROM ActorDirector 6 | GROUP BY actor_id, director_id 7 | HAVING COUNT(*) >= 3; 8 | ``` 9 | -------------------------------------------------------------------------------- /util_java/tree/TreeNode.java: -------------------------------------------------------------------------------- 1 | package util_java.tree; 2 | 3 | public class TreeNode { 4 | public int val; 5 | public TreeNode left; 6 | public TreeNode right; 7 | public TreeNode(int x) { val = x; } 8 | } -------------------------------------------------------------------------------- /0035_Search_Insert_Position/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分查找 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | 6 | 如果target不在数组中的话，最后跳出循环时，low = high + 1，这时的low就是应该插入的位置。时间复杂度O(logn) 7 | 8 | 注意这道题实际跑出来的时间，顺序查找比二分查找要快。面试中一定要搞清楚面试官的意图。 9 | -------------------------------------------------------------------------------- /0136_Single_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 XOR 2 | 3 | - 交换律：a ^ b ^ c <=> a ^ c ^ b 4 | - 任何数与0异或为任何数 0 ^ n => n 5 | - 相同的数异或为0: n ^ n => 0 6 | 7 | var a = [2,3,2,4,4] 8 | 2 ^ 3 ^ 2 ^ 4 ^ 4等价于 2 ^ 2 ^ 4 ^ 4 ^ 3 => 0 ^ 0 ^3 => 3 9 | -------------------------------------------------------------------------------- /0166_Fraction_to_Recurring_Decimal/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用hash map来存放余数。如果同样的数字已经在map中，说明循环。 4 | 5 | 注意括号要括住整个循环的部分，如4/333 = "0.(012)"。因此，map的值是余数对应的小数在字符串中的索引。这样在插入左括号时，就能知道左括号插在说明地方。 6 | 7 | 另外为了避免溢出，我们先转成longlong类型 8 | -------------------------------------------------------------------------------- /0477_Total_Hamming_Distance/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 乘法原理 2 | 3 | - 时间复杂度 O(n * C) C 为常数 30 4 | - 空间复杂度 O(1) 5 | 6 | 7 | 设第 i 列比特位有 s1 个 1, s2 个 0 8 | 9 | 则 s1 中的每个 1 都有 s2 个 0 与之不同，所以对于第 i 位，汉明距离就是 s1 * s2 10 | 11 | -------------------------------------------------------------------------------- /0521_Longest_Uncommon_Subsequence_I/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 规律法 2 | 3 | - 时间复杂度 O(n) 4 | 主要是比较字符串是否相等 5 | - 空间复杂度 O(1) 6 | 7 | - case1: 相等，则必然 -1 8 | - case2: 不相等，长度不同，则不然是最长的 9 | - case3: 不相等，长度相同，则就是这个长度 10 | 11 | -------------------------------------------------------------------------------- /0797_All_Paths_From_Source_to_Target/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFS 2 | 3 | - 时间复杂度 $O(n * 2^n)$ 4 | 共有 n 个节点，每个节点有选和不选两种决策，共 $2^n$。对于每个方案最坏情况需要 O(n) 的复杂度进行拷贝并添加到结果集。 5 | - 空间复杂度 $O(n * 2^n)$ 6 | 最多有 2^n 种方案，每个方案最多有 n 个元素 7 | -------------------------------------------------------------------------------- /0888_Fair_Candy_Swap/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 假设alice交换x，bob交换y，则有公式： 4 | 5 | sumA - x + y = sumB + x - y 6 | 7 | 化简得： 8 | 9 | x = y + (sumA - sumB) / 2 10 | 11 | 因此只需要遍历每个Bob中的y，判断对应的x是否在alice中即可。 12 | 13 | -------------------------------------------------------------------------------- /1069_Product_Sales_Analysis_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT s.product_id, SUM(s.quantity) AS total_quantity 5 | FROM Sales s JOIN Product p 6 | ON s.product_id=p.product_id 7 | GROUP BY s.product_id; 8 | ``` 9 | -------------------------------------------------------------------------------- /0382_Linked_List_Random_Node/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Reservoir Sampling 2 | 3 | https://leetcode.cn/problems/linked-list-random-node/solution/lian-biao-sui-ji-jie-dian-by-leetcode-so-x6it/ 4 | https://zhuanlan.zhihu.com/p/29178293 5 | -------------------------------------------------------------------------------- /1631_Path_With_Minimum_Effort/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dijkstra算法变种 2 | 3 | 转换成图，边的权值就是两个点之间的effort 4 | 5 | dijkstra算法忘了可以参考 https://blog.csdn.net/yalishadaa/article/details/55827681 6 | 7 | dijkstra算法是用的所有边的权值的和，这道题改成经过的所有边的权值的最大值就可以了 8 | -------------------------------------------------------------------------------- /mst17.04_Missing_Number_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 xor 2 | 3 | - A ^ 0 = A 4 | - A ^ x ^ x = A 5 | 6 | Let res xor every number and index, the only one left is the number without index, which is the number we want. 7 | 8 | 9 | -------------------------------------------------------------------------------- /0135_Candy/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 greedy 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 贪心不一定都要排序，这道题只需要从左往右一次，确保右边比较左边满足要求。 7 | 8 | 再右往左一次，确保左边比较右边满足要求。 9 | 10 | 从右往左是 alloc[i] = max(alloc[i], alloc[i+1] + 1) 这样不破坏从左往右的性质 11 | -------------------------------------------------------------------------------- /0138_Copy_List_with_Random_Pointer/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 有丝分裂法，原地复制再分裂 2 | 3 | - 时间复杂度 O(3n) 4 | - 复杂度空间 O(1) 5 | 6 | 7 | 第一次遍历：copy node without random。用next连接p和copy出来的新节点。新节点的next连接原来的next 8 | 第二次遍历：连接random 9 | 第三次遍历：有丝分裂 10 | -------------------------------------------------------------------------------- /0176_Second_Highest_Salary/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 use max 2 | 3 | ```sql 4 | SELECT MAX(Salary) AS SecondHighestSalary 5 | FROM Employee 6 | WHERE Salary < 7 | (SELECT MAX(Salary) AS max_salary 8 | FROM Employee); 9 | ``` 10 | -------------------------------------------------------------------------------- /0181_Employees_Earning_More_Than_Their_Managers/slt1.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用 JOIN 2 | 3 | ```sql 4 | SELECT E1.name AS Employee 5 | FROM Employee E1 JOIN Employee E2 ON 6 | E1.salary > E2.salary AND 7 | E1.managerId = E2.id; 8 | ``` 9 | -------------------------------------------------------------------------------- /0407_Trapping_Rain_Water_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 min heap 2 | 3 | 在接水 1 中，是用的两边的墙。这里则换成一圈墙 4 | 5 | 1. 首先判断面积是否大于等于 3 * 3，否则接不到水 6 | 2. 定义最小堆，把四周的方块放入最小堆中，标记访问过的 7 | 3. 取出最矮的方块，遍历方块四周，获取能获得水的体积，标记访问过再放入堆中 8 | 4. 重复3 9 | 10 | -------------------------------------------------------------------------------- /0596_Classes_More_Than_5_Students/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 实际测试的数据中是有同一个学生选择同一个课程，的重复数据，所以需要用distinct。 4 | 5 | ```sql 6 | SELECT class 7 | FROM courses 8 | GROUP BY class 9 | HAVING COUNT( DISTINCT student) >= 5; 10 | ``` 11 | -------------------------------------------------------------------------------- /0650_2_Keys_Keyboard/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dp 2 | 3 | dp[i] represents length is i, min moves 4 | 5 | if i % j == 0: 6 | dp[i] = dp[j] + dp[i/j] 7 | 8 | 如果n为一个质数，那么结果就是n,因为只能一个个粘贴 9 | 如果n为一个合数，那么他的结果就是分解因式的结果之和 10 | 11 | -------------------------------------------------------------------------------- /1310_XOR_Queries_of_a_Subarray/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 2 | 3 | 时间复杂度 O(n + m) 4 | 空间复杂度 O(n) 5 | 6 | 复习异或的运算性质 7 | 8 | - a ^ 0 = a 9 | - a ^ b ^ b = a 10 | - a ^ b = b ^ a 11 | 12 | 因此异或也和加法一样，[i, j] = pre[j] ^ pre[i] 13 | -------------------------------------------------------------------------------- /0211_Add_and_Search_Word_-_Data_structure_design/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Trie 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(C * n)$ 5 | C is size of charset, there is 26 6 | 7 | 该题与208. 实现 Trie (前缀树)大同小异，只需要对.单独处理就可以了。 8 | 9 | -------------------------------------------------------------------------------- /0234_Palindrome_Linked_List/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | 1. use fast-slow pointers find median node 7 | 2. then reverse second-half list 8 | 3. compare two halves 9 | 10 | -------------------------------------------------------------------------------- /0276_Paint_Fence/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 第一个栏杆有k种办法： 第二个栏杆有k*k种办法 4 | 5 | 超过3根栏杆动态规划才有意义： 6 | 如果超过3根栏杆,才有可能出现, 7 | 1.第三根栏杆刷第二根栏杆颜色(这时候就需要考虑第二根栏杆是不是和第一根栏杆一样颜色, 所以也是k-1) : dp[i] = dp[i-2]*(k-1) 8 | 2.第三根栏杆不刷第二根栏杆颜色 ：dp[i] = dp[i-1]*(k-1) 9 | -------------------------------------------------------------------------------- /0321_Create_Maximum_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 利用分治的思想。 4 | 5 | - 求单个数组中给定个数能取得的最大数 6 | - 把多个单个数组的结果merge起来 7 | 8 | 时间复杂度 9 | 10 | merge是O(k) 11 | pick是O(m+n) 12 | 加上外层的遍历 13 | 从时间是O(k^2 * (m+n)) 14 | 15 | 空间复杂度O(max(m,n,k)) 16 | -------------------------------------------------------------------------------- /0556_Next_Greater_Element_III/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用单调栈 2 | 3 | - 首先，从低到高位依次递增的，返回-1， 如44332211 4 | - 从低位到高位遍历，找到低位比高位大的最小值。如12443111，则走到2的时候，低位就有比高位大的了（4和3），然后选取最小的，也就是3，和2交换，变成1344211 5 | - 最后再把3后面的反转一下，1311244 6 | 7 | 为了找到3，我们维护一个单调递增的栈 8 | 9 | -------------------------------------------------------------------------------- /mst16.16_Sub_Sort_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双指针 2 | 3 | - 如果l大于区间里的最小值，则l需要被包括 4 | - 如果r小于区间里的最大值，则r需要被包括 5 | 6 | 一次遍历，同时从前后两个方向扫描数组 7 | 8 | - 从前往后，如果arr[i]比max小，则把r更新为i，否则更新max 9 | - 从后往前，如果arr[len-1-i]比min大，则把l更新为len-1-i，否则更新min 10 | 11 | -------------------------------------------------------------------------------- /0310_Minimum_Height_Trees/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 剥洋葱 2 | 3 | 这个图是一个多叉树 4 | 5 | 为了使生成的树的高度最小,root 节点必须是尽可能接近中心的 6 | 7 | 如何找出中心节点? 8 | 9 | - 如果将最外层叶子节点砍掉,就会有新的一层叶子节点出现,这样一直砍下去直到最后一层就是中心节点. 10 | 11 | 当前最外层叶子结点的度为1 12 | 13 | 最后的结果必然是一个或两个节点 14 | -------------------------------------------------------------------------------- /0661_Image_Smoother/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 traverse + simulation 2 | 3 | - t-complexity: $O(N)$ 4 | - s-complexity: $O(1)$ 5 | 6 | ints in cell has range of [0, 255], hence only 8-bit is used, we can use the middle 8-bit to store the new state 7 | 8 | -------------------------------------------------------------------------------- /1178_Number_of_Valid_Words_for_Each_Puzzle/slt.md: -------------------------------------------------------------------------------- 1 | Brutal-force will exceed timeout. 2 | 3 | ### Solution1 Hash + Subsets 4 | 5 | see https://leetcode.com/problems/number-of-valid-words-for-each-puzzle/discuss/371864/Python-Find-all-Sub-Puzzles 6 | -------------------------------------------------------------------------------- /0008_String_to_Integer_(atoi)/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 遍历字符串 2 | 3 | 2 ^ 31 - 1 = 2,147,483,647 4 | 5 | 按照题意，遇到第一个（非正负号 && 非空格 && 非数字）的字符就停止。 6 | 检查溢出的思路类似第七题，不过这道题在计算中不带符号，都是正的，所以只用检查正溢出。如果结果是INT_MIN的话，正溢出的判断也能检查到。 7 | 8 | python对溢出的判断可以放在最后来做（Python没有溢出这一说） 9 | -------------------------------------------------------------------------------- /0413_Arithmetic_Slices/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 双指针 2 | 3 | - 时间复杂度 $O(n^2)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 对暴力破解的优化 7 | 8 | ### Solution2 DP 9 | 10 | dp[i] represents number of satisfied sub-arrays ends with i, so answer will be sum of dp 11 | 12 | -------------------------------------------------------------------------------- /0578_Get_Highest_Answer_Rate_Question/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT question_id AS survey_log 5 | FROM survey_log 6 | GROUP BY question_id 7 | ORDER BY COUNT(answer_id) / COUNT(IF(action="show", 1, 0)) DESC 8 | LIMIT 1; 9 | ``` 10 | -------------------------------------------------------------------------------- /0611_Valid_Triangle_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 双指针 2 | 3 | - 时间复杂度 O(n^2) 4 | - 空间复杂度 O(1) 5 | 6 | 先排序。用 i 遍历最长边, l = 0, r = i - 1 7 | 8 | - nums[l] + nums[r] > nums[i]，则[l, r-1] 和 r 和 i 都成组成三角形，r-- 9 | - nums[l] + nums[r] <= nums[i]，则 l++ 10 | -------------------------------------------------------------------------------- /.vscode/settings.json: -------------------------------------------------------------------------------- 1 | { 2 | "files.associations": { 3 | "*.cjson": "jsonc", 4 | "*.wxss": "css", 5 | "*.wxs": "javascript", 6 | "numeric": "cpp", 7 | "vector": "cpp", 8 | "cstdio": "cpp" 9 | } 10 | } -------------------------------------------------------------------------------- /0098_Validate_Binary_Search_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 BST中序遍历结果递增 2 | 3 | 注意要严格递增 4 | 5 | 注意最后比较的时候用`i < in_order.size()`，而不用`i < in_order.size()-1`，因为`in_order.size() - 1 = 18446744073709551615` 6 | 7 | - 这里的中序遍历可以用递归，则可以不用递归。 8 | - 另外不用开辟n空间来存遍历结果。可以在线检查是否严格递增 9 | -------------------------------------------------------------------------------- /1025_Divisor_Game/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 数学方法 2 | 3 | - 时间复杂度 O(1) 4 | - 空间复杂度 O(1) 5 | 6 | 首先： 7 | 8 | - 奇数 - 奇数 = 偶数 9 | 10 | 1. 最后一步，占 2 的赢，占 1 的输 11 | 2. 若当前是奇数，奇数的约数只能是奇数或者1，因此下一步是偶数 12 | 3. 若当前是偶数，偶数的约数可以是偶数，也可以是奇数，可以是1，直接减1 13 | 4. 最后 偶数必赢 14 | -------------------------------------------------------------------------------- /mst16.17_Contiguous_Sequence_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 当前nums[i]就两种情况，要么加入之前的数，要么自己门派开启一个新的subarray 4 | 5 | 所有已状态转移方程 6 | 7 | dp[i] = max(dp[i-1] + nums[i], nums[i]) 8 | 9 | dp[i]就表示已i这个数结尾的最大subarray的最大sum。 10 | 11 | 最后要返回的是max(dp[i]) 12 | -------------------------------------------------------------------------------- /0020_Valid_Parentheses/slt.md: -------------------------------------------------------------------------------- 1 | 不管哪种方法，如果 长度是奇数，直接返回false 2 | 3 | ## 思路1 stack 直接把当前左括号对应的右括号入栈 4 | 5 | 注意括号交错要返回False 6 | 7 | 一种映射方法是只把右括号push入栈 8 | 9 | ## 思路2 stack 把左括号入栈，遇到对应的右括号则弹出 10 | 11 | - 时间复杂度 O(n) 12 | - 空间复杂度 O(n) 13 | 14 | 这是最容易想到的方法 15 | -------------------------------------------------------------------------------- /0063_Unique_Paths_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 同上一题，如果i,j是障碍，则dp[i][j]为0。 4 | 5 | 这道题有一种很好的处理边角特殊情况的方法，即我们申请一个m+1,n+1的二位数字，[1][1]作为起始点[m+1][n+1]最为终点。这样很好的处理了边上有障碍的情况。 6 | 7 | dp[1][1]作为起始点一定是1。所以开始设置`dp[0][1]=1`或`dp[1][0]=1`都可以。 8 | 9 | 另外dp用int还会溢出，所以用long long -------------------------------------------------------------------------------- /0603_Consecutive_Available_Seats/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 自联结 + abs 4 | 5 | ```sql 6 | SELECT DISTINCT c1.seat_id 7 | FROM cinema c1 JOIN cinema c2 8 | ON ABS(c1.seat_id-c2.seat_id)=1 9 | WHERE c1.free=1 AND c2.free=1 10 | ORDER BY c1.seat_id; 11 | ``` 12 | -------------------------------------------------------------------------------- /0646_Maximum_Length_of_Pair_Chain/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | - t-complexity: $ O(n^2) $ 4 | - s-complexity: $ O(n) $ 5 | 6 | 根据数对的第一个数排序所有的数对，dp[i] 存储以 pairs[i] 结尾的最长链的长度。当 i < j 且 pairs[i][1] < pairs[j][0] 时，扩展数对链，更新 dp[j] = max(dp[j], dp[i] + 1)。 7 | 8 | -------------------------------------------------------------------------------- /1173_Immediate_Food_Delivery_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT 5 | ROUND( 6 | (SELECT COUNT(*) FROM Delivery WHERE order_date=customer_pref_delivery_date) / 7 | (SELECT COUNT(*) FROM Delivery) * 100 8 | , 2) AS immediate_percentage; 9 | ``` 10 | -------------------------------------------------------------------------------- /1770_Maximum_Score_from_Performing_Multiplication_Operations/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | See https://leetcode.com/problems/maximum-score-from-performing-multiplication-operations/discuss/1075469/JavaC%2B%2BPython-3-Top-Down-DP-O(m2)-Clean-and-Concise 4 | 5 | -------------------------------------------------------------------------------- /0121_Best_Time_to_Buy_and_Sell_Stock/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 类似`Kadane's Algorithm`求最大子数列问题的方法。 4 | 5 | ### 思路2 dp 压缩空间 6 | 7 | 时间复杂度 O(n) 8 | 空间复杂度 O(1) 9 | 10 | 一次遍历：记录当前最小的价格，和 当前能获取的最大收益 11 | 12 | 前i天的最大收益 = max{前i-1天的最大收益，第i天的价格-前i-1天中的最小价格} 13 | 14 | -------------------------------------------------------------------------------- /0148_Sort_List/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 快排 2 | 3 | 不同于数组中的快排，链表快排不是交换元素，而是直接把链表分成三段 4 | 5 | go会超时 6 | 7 | ### 思路2 归并排序 8 | 9 | - t-complexity: $O(n * logn)$ 10 | - s-complexity: $O(1)$ 11 | 12 | - 将链表以中点拆分为两个。用快慢指针法 13 | - 两个链表内部分别排好序 14 | - 再merge两个有序链表 15 | 16 | -------------------------------------------------------------------------------- /0223_Rectangle_Area/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 先把交叉部分的左右上下四个边的值算出来。在用两个矩形面积和和减去交叉部分的和。注意为了避免溢出，我们先减后加。 4 | 5 | 有一组数据是(0, 0, 50000, 40000, 0, 0, 50000, 40000) 6 | 7 | 50000 * 40000 = 2,000,000,000 8 | 9 | 而32位int上限是2,147,483,647 10 | 11 | 如果两个矩形面积直接相加的话就溢出了 12 | -------------------------------------------------------------------------------- /0570_Managers_with_at_Least_5_Direct_Reports/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 先找出有5个下属的经理的Id 4 | 5 | ```sql 6 | SELECT name 7 | FROM Employee 8 | WHERE id IN ( 9 | SELECT managerId 10 | FROM Employee 11 | GROUP BY managerId 12 | HAVING COUNT(*)>=5); 13 | ``` 14 | 15 | -------------------------------------------------------------------------------- /0459_Repeated_Substring_Pattern/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 7 | 假设母串S是由子串s重复N次而成， 则 S+S则有子串s重复2N次， 8 | 那么现在有： S=Ns， S+S=2Ns， 其中N>=2。 如果条件成立， S+S=2Ns, 9 | 掐头去尾破坏2个s，S+S中还包含2*（N-1）s, 又因为N>=2, 10 | 因此S在(S+S)[1:-1]中必出现一次以上 11 | -------------------------------------------------------------------------------- /0524_Longest_Word_in_Dictionary_through_Deleting/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 双指针检查 subsequence 2 | 3 | - 时间复杂度 $O(n \cdot x)$ 4 | n 是 dictionary 的长度。x 是字符串的平均长度 5 | - 空间复杂度 $O(x)$ 6 | 7 | for t in dictionary: 8 | if t is sub-sequence of s: 9 | 再判断长度和字典序 10 | -------------------------------------------------------------------------------- /0561_Array_Partition_I/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Sort 2 | 3 | `min(a, b)` will get min of a and b. So if a and b diff is large, e.g. b >> a, then b is wasted. 4 | 5 | So what we do is make sure a and b is as close as possible. The right way to do it is sort `nums` first. 6 | 7 | -------------------------------------------------------------------------------- /1005_Maximize_Sum_Of_Array_After_K_Negations/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 贪心模拟 2 | 3 | steps: 4 | 5 | 1. if k > 0, go to 2, else 4 6 | 2. find min of nums, negate it 7 | 3. k--, goto 1 8 | 4. get sum of nums 9 | 10 | 关键是如何取得 nums 的最小值， nums 元素值不大，可以用 hash 数组实现 11 | 12 | -------------------------------------------------------------------------------- /1075_Project_Employees_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT p.project_id, ROUND(AVG(e.experience_years), 2) AS average_years 5 | FROM Project p JOIN Employee e 6 | ON p.employee_id=e.employee_id 7 | GROUP BY p.project_id 8 | ORDER BY p.project_id; 9 | ``` 10 | -------------------------------------------------------------------------------- /0053_Maximum_Subarray/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 只有n小于0，数组才会变小，所以小于0的时候，dp设为0，其实已经有重置start的意思了 4 | 5 | `dp[i]`表示包含了nums[i]这个元素的最大子列和，不是`nums[0, i]`中的最大子列和。 6 | 7 | `dp[i] = max(0, dp[i-1]) + nums[i]` 8 | 9 | 所以我们还要对dp中的每个元素检查，找到最大的元素。那个最大的元素才是整个nums的最大子列和。 10 | 11 | -------------------------------------------------------------------------------- /0180_Consecutive_Numbers/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 三表联结 2 | 3 | ```sql 4 | SELECT DISTINCT L1.num AS ConsecutiveNums 5 | FROM Logs L1, Logs L2, Logs L3 6 | WHERE 7 | L1.num=L2.num AND 8 | L2.num=L3.num AND 9 | L2.id-L1.id=1 AND 10 | L3.id-L2.id=1; 11 | ``` 12 | -------------------------------------------------------------------------------- /0421_Maximum_XOR_of_Two_Numbers_in_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 位运算 + Trie 2 | 3 | - 时间复杂度 O(n * logc) 4 | n 是 nums 的长度，c 是字典树集合的大小，这里是 2 5 | - 空间复杂度 O(n * logc) 6 | n 中的每一个数在字典树中都要用 logc 的空间 7 | 8 | 遍历一遍 nums，利用字典树的特性找到 当前 nums[i] 与前面所有 [nums[0], nums[i-1]] 异或的最大值 9 | -------------------------------------------------------------------------------- /0659_Split_Array_into_Consecutive_Subsequences/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 哈希表 + 最小堆 2 | 3 | dict = { 4 | key: nums中的数, 5 | value: 最小堆，里面的元素是以key结尾的子数组的长度。 6 | 7 | } 8 | 9 | 字典的键为序列结尾数值，值为结尾为该数值的所有序列长度（以堆存储）。 10 | 11 | 更新方式：每遍历一个数，将该数加入能加入的长度最短的序列中，不能加入序列则新建一个序列；然后更新字典。 12 | -------------------------------------------------------------------------------- /0892_Surface_Area_of_3D_Shapes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | For each tower, its surface area is 4 * v + 2 4 | However, 2 adjacent tower will hide the area of connected part. 5 | The hidden part is min(v1, v2) and we need just minus this area * 2 6 | 7 | Time Complexity: 8 | O(N^2) 9 | -------------------------------------------------------------------------------- /1045_Customers_Who_Bought_All_Products/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | group by 然后 4 | 5 | 每组的产品种类数量 = 总产品种类数量 6 | 7 | ```sql 8 | SELECT customer_id 9 | FROM Customer 10 | GROUP BY customer_id 11 | HAVING COUNT(DISTINCT product_key)=(SELECT COUNT(*) FROM Product); 12 | ``` 13 | -------------------------------------------------------------------------------- /1128_Number_of_Equivalent_Domino_Pairs/slt.md: -------------------------------------------------------------------------------- 1 | 直接double for loop会超时 2 | 3 | ### 思路1 排序 + hash 4 | 5 | 两个多米诺骨牌是equal => 两个骨牌相同，或其中一个反转后相同。 6 | 7 | 我们只需要把每个骨牌都按增序反转，然后用hash来计数即可 8 | 9 | 最后用的是组合数的公式 10 | 11 | 假设某一类等价对象的总数是N，从N个中任取两个的组合数，就是满足d[i]和d[j]等价的骨牌对的数量。 12 | 13 | -------------------------------------------------------------------------------- /1211_Queries_Quality_and_Percentage/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT query_name, 5 | ROUND(AVG(rating/position), 2) AS quality, 6 | ROUND((SUM(if(rating<3, 1, 0)) / count(*)) * 100, 2) AS poor_query_percentage 7 | FROM Queries 8 | GROUP BY query_name; 9 | ``` 10 | -------------------------------------------------------------------------------- /0743_Network_Delay_Time/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Dijkstra + 邻接矩阵 2 | 3 | - 时间复杂度 O(n^3) 4 | 朴素 Dijkstra O(n^2) * 枚举其他的点 O(n) 5 | - 空间复杂度 O(n^2) 6 | 7 | 求的是「从 k 点出发，所有点都被访问到的最短时间」，将问题转换一下其实就是求「从 k 点出发，到其他点 x 的最短距离的最大值」。 8 | 9 | 以 k 作为原点，枚举其他所有点作为汇点，求最短路。取其中的 max，即是最后的结果。 10 | -------------------------------------------------------------------------------- /1141_User_Activity_for_the_Past_30_Days_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 注意count要去重 4 | 5 | ```sql 6 | SELECT activity_date AS day, COUNT(DISTINCT user_id) AS active_users 7 | FROM Activity 8 | WHERE DATEDIFF('2019-07-27', activity_date) < 30 9 | GROUP BY activity_date; 10 | ``` 11 | -------------------------------------------------------------------------------- /0162_Find_Peak_Element/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 bisearch 2 | 3 | - t-complexity $O(logn)$ 4 | - s-complexity $O(1)$ 5 | 6 | O(logN)一般考虑二分搜索。有如下规律： 7 | 8 | 规律一：如果nums[i+1] < nums[i]，则在i之前一定存在峰值元素（包括i） 9 | 10 | 规律二：如果nums[i] < nums[i+1]，则在i+1之后一定存在峰值元素（包括i+1）如果i+1是最后一个元素，则i+1就是峰值 11 | -------------------------------------------------------------------------------- /0340_Longest_Substring_with_At_Most_K_Distinct_Characters/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 sliding window + hash table 2 | 3 | - 时间复杂度 $O(n)$ 4 | n 是字符串长度 5 | - 空间复杂度 $O(k)$ 6 | k 是不同字符的个数 7 | 8 | 基本思想是：在字符串上移动滑动窗口，保证窗口内有不超过 k 个不同字符，同时在每一步更新最大子串长度。 9 | 10 | 用哈希表来保证窗口中不超过 k 个不同的字符 11 | -------------------------------------------------------------------------------- /0073_Set_Matrix_Zeroes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 这道题要求我们尽量少使用空间。这种方法空间复杂度是O(1) 4 | 5 | 利用第一行和第一列保存，是否是0。 6 | 7 | 1. 首先检索第一行和第一列中是否有0，用两个flag保存。 8 | 2. 检索除了第一行和第一列之外的所有元素，如果i,j是0，则把[i][0]和[0][j]值为0 9 | 3. 然后再处理除第一行和第一列的元素，如果[i][0]或[0][j]，则把[i][j]置为0。 10 | 4. 最后用那两个flag是否把第一行和第一列全置为0 11 | -------------------------------------------------------------------------------- /0740_Delete_and_Earn/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dp 2 | 3 | _max = max(nums) 4 | 5 | 然后对 [1, _max] 进行 dp 6 | 7 | - 对当前数字 n，如果不删除，则就是 n - 1 的最优结果 8 | - 对当前数组 n，如果删除，则就是 n - 2 的最优结果 + (当前数组的个数 * 当前数字) 9 | 10 | 用一个数组 idx2cnt 存放每个数字出现的个数 11 | 12 | dp[i] = max(dp[i-1], dp[i-2] + i * idx2cnt) 13 | -------------------------------------------------------------------------------- /1082_Sales_Analysis_I/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 这道题同1076，也有个多个答案的问题 4 | 5 | 用ALL 6 | 用子查询求出最大的价格是多少，再用>= 7 | 8 | ```sql 9 | SELECT seller_id 10 | FROM Sales 11 | GROUP BY seller_id 12 | HAVING SUM(price) >= ALL( 13 | SELECT SUM(price) FROM Sales GROUP BY seller_id 14 | ); 15 | ``` 16 | -------------------------------------------------------------------------------- /1327_List_the_Products_Ordered_in_a_Period/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT p.product_name, SUM(o.unit) AS unit 5 | FROM Products p JOIN Orders o 6 | ON p.product_id=o.product_id 7 | WHERE MONTH(o.order_date)=2 8 | GROUP BY p.product_id 9 | HAVING SUM(o.unit) >= 100; 10 | ``` 11 | -------------------------------------------------------------------------------- /0015_3Sum/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 排序后遍历所有组合 2 | 3 | > Time complexity: O(n^2) 4 | 5 | 注意题目要求是unique triplets，所以有重复的还得跳过。ilr三个指针都有是否重复的判断。 6 | 7 | 如果用下面的方法，其实也是O(n^2)。因为twoSum本身是O(n)。这里排序后遍历也是O(n^2)，因为是排过序的。 8 | 9 | ``` 10 | for a in nums: 11 | target = 2 12 | twoSum(target) 13 | ``` 14 | 15 | -------------------------------------------------------------------------------- /0202_Happy_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 快慢 2 | 3 | 首先digitSquareSum只有两种可能，要么最后循环重复，要么最后等于1. 4 | 5 | 快乐数必定会收敛到1,1必须是收敛的，因为1的平方还是1，若生成的一组数中有两个重合（非1）的，那么就会构成一种循环 6 | 7 | 参考英文网站热评第一。这题可以用快慢指针的思想去做，有点类似于检测是否为环形链表那道题 8 | 如果给定的数字最后会一直循环重复，那么快的指针（值）一定会追上慢的指针（值），也就是 9 | 两者一定会相等。如果没有循环重复，那么最后快慢指针也会相等，且都等于1 10 | -------------------------------------------------------------------------------- /0313_Super_Ugly_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 DP 2 | 3 | 同264，只是235换成了一个未定的list 4 | 5 | dp[i] 表示第 i 个超级丑数。最小的超级丑数是1，有 dp[1] = 1 6 | 7 | 创建与数组 primes 长度相同的数组 pointers, 每个元素初始化为 1 8 | 9 | 当 2 <= i <= n 时，dp[i] = min(dp[pointers[j]] * primes[j]) (for j in range(len(primes))) 10 | 11 | 然后再把用到的那个指针 += 1 -------------------------------------------------------------------------------- /0376_Wiggle_Subsequence/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 思路很简单 就是 wiggle 就是一升一降。 4 | 5 | 那么 一个up 就要配一个 down 就 构成一组 6 | 7 | 所以 6 其实就是 有 up.. down ... up... down.... up ... down 至于 过程中 有几个连续的 up 或连续的down 不用管. 8 | 9 | 故 每变化一次 down就等于 up 的值+1 10 | 11 | 最后看看以谁结尾就是 wiggle 的次数 12 | 13 | （反过来一降一升也是一样的） 14 | -------------------------------------------------------------------------------- /0502_IPO/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 贪心，排序 + 大顶堆 2 | 3 | - 时间复杂度 $O(max(n * logn, k * logn))$ 4 | 构建 projects 并排序：n * logn 5 | 执行 k 步项目：k * logn 6 | - 空间复杂度 $O(n)$ 7 | 8 | 贪心：`在需要的本金小于等于我们当前资本的项目中，利益最大的是哪个` 9 | 10 | 将 profit 和 capital 关联起来，并按照 capital 排序 11 | 12 | 所有小于等于当前本金的都可以加入到大顶堆中 13 | -------------------------------------------------------------------------------- /0512_Game_Play_Analysis_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | 利用上一题（511）的结果作为子查询 4 | 5 | ```sql 6 | SELECT player_id, device_id 7 | FROM Activity 8 | WHERE (player_id, event_date) IN ( 9 | SELECT player_id, MIN(event_date) 10 | FROM Activity 11 | GROUP BY player_id 12 | ); 13 | ``` 14 | -------------------------------------------------------------------------------- /0619_Biggest_Single_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用子查询你找出所有单个元素，再在其中用max找出最大的。不能再GROUP的select语句中直接用max，因为这个max同count一样，则是组内的。 4 | 5 | ```sql 6 | SELECT MAX(num) as num 7 | FROM ( 8 | SELECT num 9 | FROM my_numbers 10 | GROUP BY num 11 | HAVING COUNT(num)=1 12 | ) AS t; 13 | ``` -------------------------------------------------------------------------------- /1113_Reported_Posts/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 主要注意post_id存在duplicate, COUNT的时候注意去重 4 | 5 | ```sql 6 | SELECT extra AS report_reason, COUNT(DISTINCT post_id) AS report_count 7 | FROM Actions 8 | WHERE action='report' AND extra IS NOT NULL AND action_date='2019-07-04' 9 | GROUP BY extra; 10 | ``` 11 | -------------------------------------------------------------------------------- /1135_Connecting_Cities_With_Minimum_Cost/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Kruskal 算法 2 | 3 | 使用并查集 4 | 5 | 即求最小是生成树 6 | 7 | 1. 将所有的边按照权重从小到大排序。 8 | 2. 取一条权重最小的边。 9 | 3. 使用并查集（union-find）数据结构来判断加入这条边后是否会形成环。若不会构成环，则将这条边加入最小生成树中。 10 | 4. 检查所有的结点是否已经全部联通，这一点可以通过目前已经加入的边的数量来判断。若全部联通，则结束算法；否则返回步骤 2. 11 | 12 | -------------------------------------------------------------------------------- /0188_Best_Time_to_Buy_and_Sell_Stock_IV/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | 当 k 大于等于总天数的一半时，退化为贪心问题. 和 Best_Time_to_Buy_and_Sell_Stock_II 一样 4 | 5 | 当 k 小于总天数一半时，和 Best_Time_to_Buy_and_Sell_Stock_III 一样 6 | 7 | 建立两个数组： buy, sell 8 | 9 | buy[j] 表示在第 j 次买入时的最大收益 10 | sell[j] 表示在第 j 次卖出是的最大收益 11 | 12 | -------------------------------------------------------------------------------- /0391_Perfect_Rectangle/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 geometry + hash 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(n)$ 5 | 6 | 1. the large rectangle area should be equal to the sum of small rectangles 7 | 2. count of all the points should be even, and that of all the four corner points should be one 8 | 9 | -------------------------------------------------------------------------------- /0608_Tree_Node/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 left join + case when 2 | 3 | ```sql 4 | SELECT t1.id, 5 | CASE 6 | WHEN t1.p_id IS NULL THEN "Root" 7 | WHEN t2.p_id IS NULL THEN "Leaf" 8 | ELSE "Inner" 9 | END AS Type 10 | FROM tree t1 LEFT JOIN tree t2 11 | ON t1.id=t2.p_id 12 | GROUP BY t1.id; 13 | ``` 14 | -------------------------------------------------------------------------------- /0586_Customer_Placing_the_Largest_Number_of_Orders/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | GROUP BY + COUNT + LIMIT 4 | 5 | 用了group by之后的count，count的是分组内的数据的个数。不管count是出现在group by前还是后。 6 | 7 | ```sql 8 | SELECT customer_number 9 | FROM orders 10 | GROUP BY customer_number 11 | ORDER BY COUNT(*) DESC 12 | LIMIT 1; 13 | ``` -------------------------------------------------------------------------------- /0607_Sales_Person/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 先用内联结筛选出销售给RED的所有orders中包含的sales_id，再用NOT IN 4 | 5 | ```sql 6 | SELECT s.name 7 | FROM salesperson s 8 | WHERE s.sales_id NOT IN ( 9 | SELECT o.sales_id 10 | FROM orders o INNER JOIN company c 11 | ON o.com_id=c.com_id WHERE c.name="RED"); 12 | ``` 13 | -------------------------------------------------------------------------------- /0714_Best_Time_to_Buy_and_Sell_Stock_with_Transaction_Fee/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | has[i]表示第i天手上有股票，not[i]表示第i天手上没有股票，递归方程： 4 | 5 | - has[i] = max(has[i-1], not[i-1] - prices[i]) （第二项表示在第i天买入股票） 6 | - not[i] = max(not[i-1], has[i-1] + prices[i] - fee) （第二项表示在第i天将股票卖出，需扣除手续费） 7 | 8 | 9 | 10 | -------------------------------------------------------------------------------- /0069_Sqrt(x)/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分法 2 | 3 | 4 | 5 | ### 思路2 牛顿迭代法 6 | 7 | 见 https://www.zhihu.com/question/20690553/answer/146104283 8 | p 9 | `X(n+1)=[X(n)+p/Xn]/2` 10 | 11 | 具体到开平方，可以参考下面两张图 12 | 13 | 注意返回int类型，python需要处理一下 14 | 15 | ### Solution3 遍历尝试 16 | 17 | - 时间复杂度 O(n^(1/2)) 18 | - 空间复杂度 O(1) 19 | -------------------------------------------------------------------------------- /0253_Meeting_Rooms_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 min heap 2 | 3 | 1 按照 开始时间 对会议进行排序。 4 | 5 | 2 初始化一个新的 最小堆，将第一个会议的结束时间加入到堆中。我们只需要记录会议的结束时间，告诉我们什么时候房间会空。堆中的值是会议的结束时间 6 | 7 | 3 对每个会议，检查堆的最小元素（即堆顶部的房间）是否空闲。 8 | 如果空闲，则将其弹出。不再占用heap。 9 | 然后将新的会议的结束时间放入heap 10 | 11 | 4 处理完所有会议后，堆的大小即为开的房间数量。这就是容纳这些会议需要的最小房间数。 12 | 13 | -------------------------------------------------------------------------------- /0577_Employee_Bonus/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用左联结。注意处理NULL不能用=，NULL=NULL是false。NULL 和任何值比较都是false 4 | 5 | 判断是不是NULL必须用 `is null` or `is not null` 6 | 7 | ```sql 8 | SELECT e.name, b.bonus 9 | FROM Employee e LEFT JOIN Bonus b 10 | ON e.empId=b.empId 11 | WHERE b.bonus < 1000 OR b.bonus IS NULL; 12 | ``` 13 | -------------------------------------------------------------------------------- /0746_Min_Cost_Climbing_Stairs/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | dp[i]表示到第i花费最小 4 | 5 | 可能一次走一步，也可能是两步，所以有： 6 | 7 | - dp[i] = min(dp[i-1], dp[i-2]) + cost[i] 8 | 9 | 另外有初识条件： 10 | 11 | dp[0] = cost[0] 12 | dp[1] = cost[1] 13 | 14 | 最后返回 15 | 16 | min(dp[-1], dp[-2])，跳到最后一层也有两种方式。 17 | 18 | 最后可以直接利用原数组做dp，空间复杂度O(1) 19 | -------------------------------------------------------------------------------- /0861_Score_After_Flipping_Matrix/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心 2 | 3 | 1. （行反转）左边第一列全变成1 4 | 2. （列反转，行不变）让每一列中的1尽可能的多，即数0和1的个数，判断用不用反转 5 | 6 | 计算结果的时候，不用真的把矩阵反转再统计结果，而是按列统计分数。假设矩阵是m*n 7 | 8 | - 对于最左边一列，结果就是1的个数 * (2 ^ n-1) 9 | - 对于其他列，统计1个个数，也是1的个数 * (2 ^ n-1) 10 | 11 | 注意在判断非左边第一列1的时候，需要判断这一行是不是反转过，即第一个列的数是不是0 12 | 13 | -------------------------------------------------------------------------------- /0036_Valid_Sudoku/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash_table, 利用3个二维数组一起检查 2 | 3 | 关键是理解如何把0-8 * 0-8的91个方块放到0-8中 4 | 5 | 我们先看i = 6,7,8的情况，这时i/3*3=6，j/3=0,1,2 加上就是（678）最后一行的三个大方块的编号。同理i = 3,4,5时，i/3*3=3，加上j就是（345）第二行三个大方块的编号。同理i = 0,1,2时，i/3*3=0，加上j/3就是（012）第一行三个大方块的编号。 6 | 7 | i / 3 * 3 后值为0,3,6 8 | j / 3后值为0,1,2 9 | 10 | 11 | -------------------------------------------------------------------------------- /0802_Find_Eventual_Safe_States/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 拓扑排序 + 反向图 2 | 3 | - 时间复杂度 O(m + n) 4 | - 空间复杂度 O(m + n) 5 | 6 | 一个节点如果在环里面，则是不安全的。反之则是安全的。 7 | 8 | 我们要找的即为出度为 0 的点（即安全节点），以及所指向的节点仅包含安全节点的节点。 9 | 10 | 而拓扑排序找的是入度为 0 的节点，以及由入度为 0 的节点组成的节点。 11 | 12 | 我们首先构建反向图，然后再用拓扑排序加入入度为 0 的节点即可。在环中的节点不可能加到 topsort 的 que 里去。 13 | -------------------------------------------------------------------------------- /mst16.21_Sum_Swap_LCCI/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 hash 2 | 3 | 例 4 | 5 | s1 - 5 + 10 -> s1 + 5 6 | s2 - 10 + 5 -> s2 - 5 7 | 8 | 最后s1和s2相差了 2 * abs(n1-n2) 9 | 10 | 也就是说最开始如果abs(s1-s2) == 2 * abs(n1-n2) 11 | 12 | 那么，n1和n2就是最后需要的结果 13 | 14 | 于是首先如果diff是奇数，则直接返回[] 15 | 16 | 对于每个array1中的数n，如果n-diff/2在array2中，那这两个数就是结果 17 | -------------------------------------------------------------------------------- /0256_Paint_House/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 二维dp，代表第n个房子刷第1、2、3种颜色时，最小的花费。最后只需要返回三种颜色中的最小值即可。递推关系为 4 | 5 | 当前房子刷0，则i-1房子必须刷1或2。其他同理 6 | 7 | dp[i][0] = Math.min(dp[i-1][1],dp[i-1][2])+costs[i][0]; 8 | dp[i][1] = Math.min(dp[i-1][0],dp[i-1][2])+costs[i][1]; 9 | dp[i][2] = Math.min(dp[i-1][1],dp[i-1][0])+costs[i][2]; 10 | 11 | -------------------------------------------------------------------------------- /0560_Subarray_Sum_Equals_K/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 前缀和 + hash 2 | 3 | 一次遍历搞定 4 | 5 | preSum[i]定义为 nums[0] + nums[1] + ... + nums[i] 6 | 7 | 那么preSum[i] - preSum[j-1]就是 nums[j] + nums[j+1] + ... + nums[i-1] + nums[i] 8 | 9 | 如果[j, i]区间的和是k，那么就有preSum[i] - preSum[j-1] == k 10 | 11 | -> preSum[i] - k == preSum[j-1] 12 | 13 | 14 | -------------------------------------------------------------------------------- /0767_Reorganize_String/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心法+最大堆 2 | 3 | 首先确定一个边界条件。如果一个字母的出现频率大于1/2，则必然是不能重构的。 4 | 5 | 我们构建一个最大堆，堆的元素是（times，ch），即字符出现的次数和字符。 6 | 7 | 然后按照出现次数从大到小把字符一次加到res里。times-1后再把ch放到堆里。 8 | 9 | 用prev记录上次pop出的字母和其个数 10 | 11 | python的堆默认是最小堆，把key加个符号，就可以当最大堆用。同时heap的元素可以是tuple，会优先以tuple最前面的元素作为比较的key。 12 | 13 | 14 | -------------------------------------------------------------------------------- /0001_Two_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用hash的思想 2 | 3 | > Time complexity: O(N) 4 | > Space complexity: O(N) 5 | 6 | 由于最后要返回的是索引的数组。用hash的key来存放数组中一个元素的值，而用hash的value来存放那个值得索引。这样就建立了数组元素值对数组元素索引的映射。 7 | 8 | 这个算法的性能取决于hash find的时间复杂度。本身外层循环是O(N) 9 | cpp unordered_map find()的时间复杂是常量。所以最终的时间复杂度还是O(N) 10 | 11 | 返回vector的顺序不重要。 12 | 13 | -------------------------------------------------------------------------------- /0128_Longest_Consecutive_Sequence/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 题目要求 O(n) 复杂度。 4 | 5 | 这是一个很有意思的算法，可以手动模拟一下 6 | 7 | - 用哈希表存储每个端点值对应连续区间的长度 8 | - 若数已在哈希表中：跳过不做处理 9 | - 若是新数加入： 10 | - 取出其左右相邻数已有的连续区间长度 left 和 right 11 | - 计算当前数的区间长度为：cur_length = left + right + 1 12 | - 根据 cur_length 更新最大长度 max_length 的值 13 | - 更新区间两端点的长度值 14 | -------------------------------------------------------------------------------- /0540_Single_Element_in_a_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 二分 2 | 3 | - t-complexity $O(log n)$ 4 | - s-complexity $O(1)$ 5 | 6 | 总元素个数是奇数个 7 | 8 | 当我们从中心移除一对元素时 9 | 10 | 11445566899 11 | 12 | 左：1144；右：66899 13 | 14 | 与原数组一样，包含单个元素的子数组元素个数必为奇数，不包含单个元素的子数组必为偶数。 因此，当原数组移除一对元素后，然后计算出哪一侧的子数组元素个数是奇数，这样我们就能够知道下一步应该在哪一侧进行搜索。 15 | -------------------------------------------------------------------------------- /0597_Friend_Requests_I:_Overall_Acceptance_Rate/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT ROUND( 5 | IFNULL( 6 | (SELECT COUNT(DISTINCT requester_id, accepter_id) FROM request_accepted) / 7 | (SELECT COUNT(DISTINCT sender_id, send_to_id) FROM friend_request) 8 | , 0), 2) 9 | AS accept_rate; 10 | ``` 11 | -------------------------------------------------------------------------------- /0612_Shortest_Distance_in_a_Plane/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 JOIN计算每两点之间的距离 2 | 3 | 注意这里的不等联结，一定要把多列括起来，不然判断的就是单列的不等 4 | 5 | ```sql 6 | SELECT ROUND( 7 | MIN(SQRT(ABS(p2.y-p1.y)*ABS(p2.y-p1.y) + ABS(p2.x-p1.x)*ABS(p2.x-p1.x))) 8 | , 2) 9 | AS shortest 10 | FROM point_2d p1 JOIN point_2d p2 11 | ON (p1.x, p1.y)!=(p2.x, p2.y); 12 | ``` 13 | -------------------------------------------------------------------------------- /1084_Sales_Analysis_III/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 用子查询 2 | 3 | 注意这道题的含义，仅在春天出售的商品。如果一个商品还在其他时间内出售，则不在这道题的结果里。 4 | 5 | ```sql 6 | SELECT product_id, product_name 7 | FROM Product 8 | WHERE product_id NOT IN ( 9 | SELECT product_id 10 | FROM Sales 11 | WHERE sale_date < "2019-01-01" OR sale_date > "2019-03-31" 12 | ); 13 | ``` 14 | -------------------------------------------------------------------------------- /1722_Minimize_Hamming_Distance_After_Swap_Operations/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 2 | 3 | 首先明确说明是汉明距离： 4 | 5 | - 相同长度的两个数组 source 和 target 间的 汉明距离 是元素不同的下标数量 6 | 7 | 如果allowedSwaps有[1,2]和[2,3]，那么[1,3]也是可以交换的。 8 | 9 | 这道题变可以转换成用并查集找连通分量。一个连通分量内所有下表都是可以交换的。 10 | 11 | 最后每个连通分量内，source和target不同元素的个数，就是当前连通分量的汉明距离。最后把所有的连通分量的汉明距离加起来就行了 12 | -------------------------------------------------------------------------------- /0859_Buddy_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 simulation 2 | 3 | - t-complexity: $O(n + C)$ 4 | C is size of charset 5 | - s-complexity: $O(C)$ 6 | 7 | 直接暴力会超时 8 | 9 | - s 和 goal 长度或者词频不同，则不为 buddy string 10 | - s 与 goal 不同的字符数量为 2 （能相互交换） 11 | - s and goal diff char number is 0, and s has char which appear more than twice 12 | 13 | -------------------------------------------------------------------------------- /1322_Ads_Performance/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 注意最后除了ctr降序，还需要ad_id升序。 4 | 5 | ```sql 6 | SELECT ad_id, 7 | IFNULL( 8 | ROUND( 9 | SUM(action="Clicked") / (SUM(action="Clicked") + SUM(action="Viewed")) * 100, 10 | 2) 11 | , 0) 12 | AS ctr 13 | FROM Ads 14 | GROUP BY ad_id 15 | ORDER BY ctr DESC, ad_id; 16 | ``` 17 | -------------------------------------------------------------------------------- /0338_Counting_Bits/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 2 | 3 | - odd number ends with 1 4 | - even number ends with 0 5 | 6 | if n is odd: 7 | bits of n is one more then bits of n-1 8 | e.g. 3-011 2-010 9 | elif n is even: 10 | bits of n is same as bits of n // 2, just emagine left shift out that 0, 1's count remain same. 11 | 12 | 13 | -------------------------------------------------------------------------------- /0402_Remove_K_Digits/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 对于两个数 123a456 和 123b456，如果 a > b， 那么数字 123a456 大于 数字 123b456，否则数字 123a456 小于等于数字 123b456。也就说，两个相同位数的数字大小关系取决于第一个不同的数的大小。 4 | 5 | 6 | - 从左到右遍历 7 | - 对于每一个遍历到的元素，我们决定是丢弃还是保留。 8 | 9 | 如果stk尾部元素大于当前元素，则抛弃stk尾部元素 10 | 11 | 12 | 利用栈或双端队列，本质上是以空间换时间的方法。 13 | 14 | 时间复杂度O(N) 15 | 空间复杂度O(N) 16 | 17 | -------------------------------------------------------------------------------- /0697_Degree_of_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Hash 2 | 3 | Use a hash table `counter` to count original nums' frequency, and find degree. 4 | 5 | Then find the max degree's correspoding number, then find's left-most and right-most index. 6 | 7 | To do that, use two dict `left` and `right` to store every number left and right-most index. 8 | 9 | -------------------------------------------------------------------------------- /1070_Product_Sales_Analysis_III/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用子查询 2 | 3 | 注意相同product_id和year的record可能有多个。如果直接用GROUP BY + MIN 则只会选出一个。 4 | 5 | ```sql 6 | SELECT product_id, year AS first_year, quantity, price 7 | FROM Sales 8 | WHERE (product_id, year) IN ( 9 | SELECT product_id, MIN(year) AS year FROM Sales GROUP BY product_id 10 | ); 11 | ``` 12 | -------------------------------------------------------------------------------- /1142_User_Activity_for_the_Past_30_Days_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用distinct直接计算 2 | 3 | `总session数 / 总用户数` 4 | 5 | ```sql 6 | SELECT 7 | IFNULL( 8 | ROUND(COUNT(DISTINCT session_id) / COUNT(DISTINCT user_id), 2), 9 | 0) 10 | AS average_sessions_per_user 11 | FROM Activity 12 | WHERE DATEDIFF('2019-07-27', activity_date) < 30; 13 | ``` 14 | -------------------------------------------------------------------------------- /1251_Average_Selling_Price/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 注意两点，一是求加权平均值，二是日期范围 4 | 5 | ```sql 6 | SELECT p.product_id, ROUND(SUM(p.price * u.units) / SUM(u.units), 2) AS average_price 7 | FROM Prices p JOIN UnitsSold u 8 | ON p.product_id=u.product_id AND u.purchase_date BETWEEN p.start_date AND p.end_date 9 | GROUP BY p.product_id; 10 | ``` 11 | -------------------------------------------------------------------------------- /1438_Longest_Continuous_Subarray_With_Absolute_Diff_Less_Than_or_Equal_to_Limit/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Sliding window + Ordered Sequence 2 | 3 | In cpp, just use multiset is ok. In python, there's not equivalent data structure, situation become tricky. 4 | 5 | Use a Counter to store items in window, and recored max and min value in widnow. 6 | 7 | -------------------------------------------------------------------------------- /1738_Find_Kth_Largest_XOR_Coordinate_Value/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + 最小堆 2 | 3 | - 时间复杂度 O(m * n * logk) 4 | - 空间复杂度 O(m * n) 5 | 6 | 我们可以建立一个大小为 k 的小根堆，在计算二维前缀异或时，判断当前「子矩阵异或和」是否大于堆顶元素： 7 | 8 | 大于堆顶元素：当前子矩阵异或和可能是第 k 大的值，堆顶元素不可能为第 k 大的值。将堆顶元素弹出，并将当前子矩阵和加入堆中 9 | 小于堆顶元素：不会是第 k 大的值，直接丢弃。 10 | 等于堆顶元素：有相同元素在堆中，直接丢弃。 11 | 12 | 最终的堆顶元素即为答案。 13 | -------------------------------------------------------------------------------- /0119_Pascal's_Triangle_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | The result we need is only one line. So there is no need to store all lines of triangle, just one line will satisfy. 4 | 5 | We iterate from back to front to avoid res[j-1] be overridden. 6 | 7 | SpaceCompexity: O(rowIndex) 8 | 9 | ### Solution 1.1 10 | 11 | 类似1，但不用从后往前，也可以只用一行 tmp array 12 | -------------------------------------------------------------------------------- /0480_Sliding_Window_Median/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双堆 - 双堆对顶 2 | 3 | https://leetcode-cn.com/problems/sliding-window-median/solution/python-shuang-dui-shuang-ha-xi-dui-liang-jb34/ 4 | 5 | - 设中位数为X 6 | - 小于X的数放在最大堆中，大于X的数放在最小堆中 7 | 8 | 9 | 由于一开始是把所有元素都放在最小堆中，然后k//2下取整把另一半元素放在最大堆中的 10 | 11 | - 如果k是奇数，则每次取最小堆的元素为答案 12 | - 如果k是偶数，则取两个堆的对顶，把平均值放入答案 13 | 14 | -------------------------------------------------------------------------------- /1076_Project_Employees_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 关键是要处理多个COUNT相等的情况。我们可以先把COUNT的max值取出来作为子查询 4 | 5 | ```sql 6 | SELECT project_id 7 | FROM Project 8 | GROUP BY project_id 9 | HAVING COUNT(employee_id)=( 10 | SELECT COUNT(employee_id) FROM Project 11 | GROUP BY project_id 12 | ORDER BY COUNT(employee_id) DESC LIMIT 1 13 | ); 14 | ``` 15 | -------------------------------------------------------------------------------- /1162_As_Far_from_Land_as_Possible/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 BFS 2 | 3 | 先遍历一遍grid，把所有陆地置为-1 4 | 5 | 1,0,1 6 | 0,0,0 7 | 1,0,1 8 | 9 | -> 10 | 11 | -1, 0, -1 12 | 0, 0, 0, 13 | -1, 0, -1 14 | 15 | 然后我们从每个海洋结点出发，进行广度优先遍历。并直接把距离写在grid里，每绕完一圈，dist加1 16 | 17 | -1, 1, -1 18 | 1, 0, 1, 19 | -1, 1, -1 20 | 21 | -1, 1, -1, 22 | 1, 2, 1, 23 | -1, 1, -1 24 | 25 | -------------------------------------------------------------------------------- /0160_Intersection_of_Two_Linked_Lists/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 双指针循环相遇 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 太6了，我的理解： 7 | 8 | 两个链表长度分别为L1+C、L2+C， C为公共部分的长度， 9 | 10 | 按照楼主的做法： 第一个人走了L1+C步后，回到第二个人起点走L2步；第2个人走了L2+C步后，回到第一个人起点走L1步。 当两个人走的步数都为L1+L2+C时就两个家伙就相爱了 11 | 12 | 即最后两个人都会走L1 + L2 + C步 13 | 14 | 如果C = 0，两个人都走了L1 + L2步后，p1 == p2 == None也会跳出循环 15 | -------------------------------------------------------------------------------- /0070_Climbing_Stairs/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 时间复杂度 O(n) 4 | 空间复杂度 O(n) 5 | 6 | 为方便，我们把楼梯按索引的方式也从0开始。 7 | dp[i]表示到i层有多少中方法，显然dp[0]=1, dp[1]=2。当i>=2时，到达i可以从i-1,i-2两种方法。因此有`dp[i] = dp[i-1] + dp[i-2];` 8 | 9 | ### 思路2 dp 压缩存储空间 10 | 11 | 时间复杂度 O(n) 12 | 空间复杂度 O(1) 13 | 14 | 应注意到这道题和斐波那契数列的关系。类似`Unique path 62`和`min path sum 64`中那样，这道题也可以压缩存储空间。 15 | 16 | -------------------------------------------------------------------------------- /0264_Ugly_Number_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 三指针法 2 | 3 | 所有的ugly number： 4 | 5 | (1) 1×2, 2×2, 3×2, 4×2, 5×2, … 所有正整数 * 2 6 | (2) 1×3, 2×3, 3×3, 4×3, 5×3, … 所有正整数 * 3 7 | (3) 1×5, 2×5, 3×5, 4×5, 5×5, … 所有正整数 * 5 8 | We can find that every subsequence is the 9 | ugly-sequence itself (1, 2, 3, 4, 5, …) multiply 2, 3, 5. 10 | 11 | 我们只要用三个指针，把这些数按照大小顺序排列起来就行了。 12 | -------------------------------------------------------------------------------- /0583_Delete_Operation_for_Two_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | dp[i][j] 表示以 i-1 结尾的 word1 和以 j-1 结尾的 word2 想要相等，所需要删除的最少字数 4 | 5 | 状态转移方程： 6 | 7 | ``` 8 | if word1[i-1] == word2[j-1]: 9 | dp[i][j] = dp[i-1][j-1] 10 | else: 11 | dp[i][j] = min(dp[i-1][j-1] + 2, dp[i-1][j] + 1, dp[i][j-1] + 1) // 表示两个串都删 | 删 word1 | 删 word2 12 | ``` 13 | 14 | -------------------------------------------------------------------------------- /0448_Find_All_Numbers_Disappeared_in_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 hash - operate on original array, mapping number to index 2 | 3 | 1. Add size to every element of nums[nums[i]] for i in range(size) 4 | This will make every number(appeared in array)'s corresponding index > size 5 | 6 | 2. Traverse array, find value <= size. Then the index is the answer element. 7 | 8 | -------------------------------------------------------------------------------- /0384_Shuffle_an_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Shuffle Simulation 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(n)$ 5 | 6 | 共有 n 个不同的数，根据每个位置能够选择什么数，共有 n! 种组合。 7 | 8 | 题目要求每次调用 shuffle 时等概率返回某个方案，或者说每个元素都够等概率出现在每个位置中。 9 | 10 | 我们可以使用 Knuth 洗牌算法（Fisher-Yates 洗牌算法），在 O(n) 复杂度内等概率返回某个方案。 11 | 12 | 具体的，我们从前往后尝试填充 `[0, n - 1]` 该填入什么数时，通过随机当前下标与（剩余的）哪个下标进行值交换来实现。 13 | -------------------------------------------------------------------------------- /1035_Uncrossed_Lines/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dp 2 | 3 | - 时间复杂度 O(m * n) 4 | - 空间复杂度 O(m * n) 5 | 6 | dp[i][j] 表示 nums1 中前 i 个数字和 nums2 中前 j 个数组可以组成最多直线数量 7 | 8 | 转移方程： 9 | 10 | - dp[i][j] = dp[i-1][j-1] + 1, if nums[i] == nums[j] 11 | - dp[i][j] = max(dp[i-1][j], dp[i][j-1]), if nums[i] != nums[j] 12 | 13 | 若 nums[i] != nums[j]，说明他们中至少一个不能对结果做出贡献，取其中最大值 14 | -------------------------------------------------------------------------------- /0134_Gas_Station/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 一次遍历法 2 | 3 | total_remain表示总加油和总耗油之差，如果这个数小于0，则必然完不成绕圈。 4 | 5 | 为什么如果k+1->end全部可以正常通行，且total_remain>=0就可以说明车子从k+1站点出发可以开完全程？ 6 | 7 | 因为，起始点将当前路径分为A、B两部分。其中，必然有 8 | (1)A部分剩余油量<0。 9 | (2)B部分剩余油量>0。 10 | 所以，无论多少个站，都可以抽象为两个站点（A、B）。(1)从B站加满油出发，(2)开往A站，车加油，(3)再开回B站的过程。 11 | 12 | B剩余的油>=A缺少的总油（因为total_remain>=0）。必然可以推出，B剩余的油>=A站点的每个子站点缺少的油。 13 | -------------------------------------------------------------------------------- /0197_Rising_Temperature/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 JOIN 2 | 3 | 使用内联结，然后用DATEDIFF或TO_DAYS比较日期。 4 | 5 | DATEDIFF(A, B)的结果是A-B。如A="2019-10-11", B="2019-10-10",则DATEDIFF(A, B)=1, DATEDIFF(B, A)=-1 6 | 7 | ```sql 8 | SELECT W2.Id 9 | FROM Weather W1 JOIN Weather W2 10 | ON 11 | DATEDIFF(W2.recordDate, W1.recordDate)=1 AND 12 | W2.temperature>W1.temperature; 13 | ``` 14 | -------------------------------------------------------------------------------- /0453_Minimum_Moves_to_Equal_Array_Elements/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 math 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(1)$ 5 | 6 | 假设最少操作次数是 k，k 次操作后所有数都相等。设相等的数为 target 7 | 对 n - 1 个元素操作 k 次，则一共增加了 k * (n-1) 8 | 9 | 则有 10 | 11 | target * n = sum(nums) + k * (n-1) 12 | 13 | 而 target = min(nums) + k 14 | 15 | 这样便可以解出 k 16 | 17 | k = sum - min(nums) * n 18 | 19 | -------------------------------------------------------------------------------- /0300_Longest_Increasing_Subsequence/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | - t-comlpexity: O(n^2) 4 | - s-comlpexity: O(n) 5 | 6 | dp[i] represents LIS ending with i. 7 | 8 | ``` 9 | max_len = 1 10 | for i in range(n): 11 | for j in range(i): 12 | if nums[j] < nums[i]: 13 | dp[i] = max(dp[i], dp[j]+1) 14 | max_len = max(max_len, dp[i]) 15 | ``` 16 | 17 | -------------------------------------------------------------------------------- /0978_Longest_Turbulent_Subarray/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | dp[i]表示以i结尾的最长连续子数组的长度 4 | 5 | 本题需要两个状态方程 6 | 7 | - up[i]表示以i结尾，并且`arr[i-1] < arr[i]`的最长湍流子数组的长度 8 | - down[i]表示以i结尾，并且`arr[i-1] > arr[i]`的最长湍流子数组的长度 9 | 10 | 状态转移方程： 11 | 12 | - up[i] = down[i-1] + 1, if arr[i-1] < arr[i] 13 | - down[i] = up[i+1] + 1, if arr[i-1] > arr[i] 14 | 15 | 如果`arr[i-1] == arr[i]`则两个状态都回归1 16 | -------------------------------------------------------------------------------- /0120_Triangle/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 bottom-up dp 2 | 3 | 树状结构很容易让人想到DFS，但是这道题兄弟节点向下都会有一个share branch，如果用DFS，会有很多overlapping subproblems。 4 | 5 | 换个思路，假设x和y是k的子节点，如果x和y的path值都确定了，那么k的path值就是path(k) += min(path(x), path(y))。所以这道题用DP才是最佳方案。 6 | 7 | DP也有两个思路，一是top-down，而是bottom-up 8 | 9 | top-down的方案我们还需要n^2的空间来存储中间数据，而bottom-up的方案我们用原有数组来存放。 10 | 11 | 总结一下，这道题bottom-up的dp是时间和空间都相对较优的方法。 12 | -------------------------------------------------------------------------------- /0081_Search_in_Rotated_Sorted_Array_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 只对有序的那一半进行二分查找 2 | 3 | 与33 Search in Rotated Sorted Array I不同，这道题可能包含重复的元素 4 | 5 | 必须跳过重复的元素。不然像{1,3,1,1,1}这种过不了 6 | 7 | 8 | 9 | C++最简洁的二分法分类讨论 10 | 每次二分，左半部分和右半部分至少有一边是有序的，以此为条件可以分成两种情况： 11 | 1、左半边是有序的 12 | (1) target落在左半边 13 | (2) otherwise 14 | 2、右半边是有序的 15 | (1) target落在右半边 16 | (2) otherwise 17 | 综上所述，一共两种可能性，这两种情况各自又有两种可能性 18 | -------------------------------------------------------------------------------- /0435_Non-overlapping_Intervals/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 贪心 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 O(1) 5 | 6 | 要移去最少，即是要保留最多。所以按右边界从小到大排序，来保留最多的不重叠区间 7 | 8 | 记录一下大佬的思想： 贪心算法，按照起点排序：选择结尾最短的，后面才可能连接更多的区间（如果两个区间有重叠，应该保留结尾小的） 把问题转化为最多能保留多少个区间，使他们互不重复，则按照终点排序，每个区间的结尾很重要，结尾越小，则后面越有可能容纳更多的区间。 9 | 10 | 把问题转换为： 11 | 计算最多能组成的不重叠区间个数，然后用区间总个数减去不重叠区间的个数。 12 | 13 | 按区间的结尾进行升序排序，每次选择结尾最小，并且和前一个区间不重叠的区间。 14 | -------------------------------------------------------------------------------- /0881_Boats_to_Save_People/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 双指针 + 贪心 2 | 3 | - 时间复杂度 $O(n * logn)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 要使需要的船数尽可能地少，应当使载两人的船尽可能地多。 7 | 考虑体重最轻的人 8 | 9 | - 若他不能与体重最重的人同乘一艘船，那么体重最重的人无法与任何人同乘一艘船，此时应单独分配一艘船给体重最重的人 10 | - 若他能与体重最重的人同乘一艘船，那么他能与其余任何人同乘一艘船，为了尽可能地利用船的承载重量，选择与体重最重的人同乘一艘船是最优的 11 | 12 | 所以，我们要尽可能的把最重和最轻的人放在一起。 13 | 14 | 先小到大排序。 15 | 16 | 从右往左遍历重的人，如果同时带上左边轻的人，则 l++ 17 | -------------------------------------------------------------------------------- /1049_Last_Stone_Weight_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | 4 | 参考 https://leetcode-cn.com/problems/last-stone-weight-ii/solution/java-gao-kao-bei-bei-bao-zhi-jing-gao-zh-ybd8/ 5 | 6 | 7 | 设总重量为 sum，要减去的石头总重量为 neg 8 | 则加法运算求得的石头总重量为 sum - neg 9 | 最后结果的重量为 sum - neg - neg = sum - 2 * neg 10 | 要最后的结果最小，即要求 neg 最接近 sum / 2 11 | 12 | 13 | dp[i] 表示：是否有子集数组，重量和为i，值为 True or False 14 | 15 | -------------------------------------------------------------------------------- /1269_Number_of_Ways_to_Stay_in_the_Same_Place_After_Some_Steps/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | `dp[i][j]` 表示当前在用了 i 步，在 j 位置的方案数。 4 | 5 | 我们需要求的是 `dp[steps][0]` 6 | 7 | 有 8 | 9 | dp[0][0] = 1 初始条件 10 | 11 | 对于每个 i 步，我们考虑它是怎么从前一步转换来的 12 | 13 | - 原地不动, i + 1, 由 dp[i-1][j] 而来 14 | - 由左而来, i + 1, 由 dp[i-1][j-1] 而来 15 | - 由右而来, i + 1, 由 dp[i-1][j+1] 而来 16 | 17 | dp[i][j] 就是上面三种情况的总和 18 | -------------------------------------------------------------------------------- /0279_Perfect_Squares/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | - 时间复杂度 O(n * sqrt(n)) 4 | - 空间复杂度 O(n) 5 | 6 | For each i, it must be the sum of some number `(i - j*j)` and a perfect square number (j*j). 即 i = (i - j * j) + (j * j) 7 | 8 | dp[n]表示最少使用的个数，则有(k为满足k^2<=n的最大的k) 9 | 10 | 转移方程 11 | 12 | dp[i] = min(dp[i], dp[i-j*j]+1) 13 | 14 | dp[i] 可以取的最小值即为 1 + min(dp[i-1], dp[i-4], dp[i-9] · · · ) 15 | 16 | -------------------------------------------------------------------------------- /0375_Guess_Number_Higher_or_Lower_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | - t-complexity: $O(N^3)$ 4 | - s-complexity: $O(N^2)$ 5 | 6 | problem explained: https://leetcode.com/problems/guess-number-higher-or-lower-ii/discuss/84766/Clarification-on-the-problem-description.-Problem-description-need-to-be-updated-!!! 7 | 8 | `dp[i][j]` denotes guess number from [i, j], min cost of win game 9 | 10 | -------------------------------------------------------------------------------- /0443_String_Compression/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 双指针模拟 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 注意处理好特情况： 7 | 8 | - size == 1: 直接返回 1 9 | - size > 1 10 | 遍历 (1, N) 11 | - 对中间的元素： 12 | - i != i-1，则要加，注意区分 cnt == 1 13 | - i == i-1，直接 cnt++ 14 | - 对最后一个元素，要判断倒数第二和最后一个字符 15 | - 最后两个字符相同：直接按 cnt + 1 算 16 | - 最后两个字符不同：分别算 倒数第二个字符的 cnt，和最后一个字符 17 | -------------------------------------------------------------------------------- /0033_Search_in_Rotated_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 只对有序的那一半进行二分查找 2 | 3 | C++最简洁的二分法分类讨论 4 | 每次二分，左半部分和右半部分至少有一边是有序的，以此为条件可以分成两种情况： 5 | 1、左半边是有序的 6 | (1) target落在左半边 7 | (2) otherwise 8 | 2、右半边是有序的 9 | (1) target落在右半边 10 | (2) otherwise 11 | 综上所述，一共两种可能性，这两种情况各自又有两种可能性 12 | 13 | 注意分的时候，`nums[l] <= nums[m]`相等必须放在左边，不然只有两个元素的情况过不了。 14 | 15 | 另外 while (l <= r) 这里必须有等号，不然一个元素时l == r，连while都进不去 16 | -------------------------------------------------------------------------------- /0355_Design_Twitter/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 记录每个tweid的时间。get的时候按时间归并 2 | 3 | struct Node 4 | { 5 | unordered_set followee; 6 | list tweet; 7 | }; 8 | int recent_max, time; 9 | unordered_map tweet_time; 10 | unordered_map user; 11 | 12 | 关键是设计好数据结构。最后在getNewsFeed时，根据tweet_time找到时间进行线性归并 13 | 14 | userId -> Node { 15 | followee set 16 | tweet list 17 | } 18 | -------------------------------------------------------------------------------- /0184_Department_Highest_Salary/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 利用子查询先找出每个部门的最高工资，再联结两个表查询 4 | 5 | ```sql 6 | SELECT 7 | D.Name AS Department, 8 | E.Name AS Employee, 9 | E.Salary 10 | FROM Department AS D JOIN Employee AS E 11 | ON D.Id=E.DepartmentId 12 | WHERE (E.Salary, D.Id) IN ( 13 | SELECT MAX(Salary), DepartmentId 14 | FROM Employee 15 | GROUP BY DepartmentId); 16 | ``` 17 | 18 | -------------------------------------------------------------------------------- /0201_Bitwise_AND_of_Numbers_Range/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 直接遍历会超时 4 | 5 | 6 | 【笔记】当一个数+1时，总会有这么一个规律“某一位后的数字，全部被置为相反数”。举个例子： 7 | 8 | 010111 + 1 = 011000，则010111 & 011000 = 010000。那么，x & (x+1) 后几位相反数的“与操作”，结果总为0。 9 | 所以，当(m,m+1,...n-1,n)进行连续“与操作”时，会按照上述规律被抵消很大一部分，而只剩下n的前缀部分，最后只需将n归位。举个例子： 10 | 11 | m = 5(0101), n = 7 (0111)。不停右移，得到n前缀部分为01，最后归位前缀得res=0100=4 12 | 13 | 010111 14 | 011000 15 | 16 | 010000 -------------------------------------------------------------------------------- /0335_Self_Crossing/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 by cases 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: %O(1)% 5 | 6 | three cases that will not self crossing: 7 | 8 | - always out: dist[i] > dist[i-2] 9 | - always in: dist[i] < dist[i-2] 10 | - first out then in: 11 | 12 | see graph at: 13 | https://leetcode-cn.com/problems/self-crossing/solution/tong-ge-lai-shua-ti-la-san-chong-bu-xian-w80r/ 14 | 15 | -------------------------------------------------------------------------------- /0602_Friend_Requests_II:_Who_Has_the_Most_Friends/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用UNION ALL 2 | 3 | ```sql 4 | SELECT t.id, COUNT(t.id) AS num 5 | FROM ( 6 | SELECT requester_id AS id 7 | FROM request_accepted 8 | UNION ALL 9 | SELECT accepter_id AS id 10 | FROM request_accepted 11 | ) t 12 | GROUP BY t.id 13 | ORDER BY COUNT(t.id) DESC LIMIT 1; 14 | ``` 15 | 16 | 注意UNION会去掉重复的值，UNION ALL会保留重复的值 17 | -------------------------------------------------------------------------------- /1442_Count_Triplets_That_Can_Form_Two_Arrays_of_Equal_XOR/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + 暴力 2 | 3 | - 时间复杂度 O(n^2) 4 | - 空间复杂度 O(n) 5 | 6 | 若 a == b, 则有 a ^ b == 0, 7 | 8 | a = prexor[i-1] ^ prexor[j-1] 9 | b = prexor[j-1] ^ prexor[k] 10 | 11 | 即 prexor[i-1] ^ prexor[j-1] ^ prexor[j-1] ^ prexor[k] == 0 12 | 即 prexor[i-1] ^ prexor[k] == 0 13 | 即 prexor[i-1] == prexor[k] 14 | 15 | 即这个等式成立时，中间所有j的取值都满足 16 | -------------------------------------------------------------------------------- /0177_Nth_Highest_Salary/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Directly Single Table Query 2 | 3 | ```sql 4 | CREATE FUNCTION getNthHighestSalary(N INT) RETURNS INT 5 | BEGIN 6 | SET N = N-1; 7 | RETURN ( 8 | # Write your MySQL query statement below. 9 | SELECT Salary 10 | FROM Employee 11 | GROUP BY Salary 12 | ORDER BY Salary DESC 13 | LIMIT N, 1 14 | ); 15 | END 16 | ``` 17 | 18 | -------------------------------------------------------------------------------- /0450_Delete_Node_in_a_BST/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dfs delete 2 | 3 | - t-complexity: O(h) 4 | h is the height of the tree 5 | - s-complexity: O(h) 6 | 7 | if node is target node: 8 | 9 | - if do not have left child, replace it with right child 10 | - if do not have right child, replace it with left child 11 | - if have both children, put left child to right child's left most leaf, and delete it 12 | 13 | -------------------------------------------------------------------------------- /0183_Customers_Who_Never_Order/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 left join 并用 is null过滤 2 | 3 | ```sql 4 | SELECT C.name AS Customers 5 | FROM Customers C LEFT JOIN Orders O 6 | ON C.id=O.customerId 7 | WHERE O.id IS NULL; 8 | ``` 9 | 10 | ### Solution 2 Use sub-query 11 | 12 | ```sql 13 | SELECT Name AS Customers 14 | FROM Customers WHERE Id NOT IN( 15 | SELECT DISTINCT CustomerId FROM Orders 16 | ); 17 | ``` 18 | 19 | -------------------------------------------------------------------------------- /0167_Two_Sum_II_-_Input_array_is_sorted/Solution2.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} numbers 3 | * @param {number} target 4 | * @return {number[]} 5 | */ 6 | var twoSum = function(numbers, target) { 7 | let l = 0, r = numbers.length-1; 8 | while (l < r) { 9 | let s = numbers[l] + numbers[r]; 10 | if (s < target) ++l; 11 | else if (s > target) --r; 12 | else return [l+1, r+1]; 13 | } 14 | }; 15 | -------------------------------------------------------------------------------- /0626_Exchange_Seats/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 这道题改id就行了，最后再排序 4 | 5 | ```sql 6 | SELECT 7 | CASE 8 | WHEN MOD(id, 2) != 0 AND id!=cnt THEN id + 1 -- id是奇数，且不是最后一个 9 | WHEN MOD(id, 2) != 0 AND id=cnt THEN id -- id是奇数，是最后一个 10 | ELSE id -1 -- id是偶数 11 | END AS id 12 | , 13 | student 14 | FROM seat JOIN ( 15 | SELECT COUNT(*) AS cnt 16 | FROM seat) AS t 17 | ORDER BY id; 18 | ``` 19 | -------------------------------------------------------------------------------- /1280_Students_and_Examinations/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 注意这里的group by用到了两个字段 4 | 5 | s1和s2是笛卡尔积。第二个连接用left join，因为有0的情况 6 | 7 | ```sql 8 | SELECT s1.student_id, s1.student_name, s2.subject_name, COUNT(e.subject_name) AS attended_exams 9 | FROM Students s1 JOIN Subjects s2 LEFT JOIN Examinations e 10 | ON s1.student_id=e.student_id AND s2.subject_name=e.subject_name 11 | GROUP BY s1.student_id, s2.subject_name; 12 | ``` 13 | -------------------------------------------------------------------------------- /1294_Weather_Type_in_Each_Country/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 使用case when和month 4 | 5 | ```sql 6 | SELECT c.country_name, 7 | CASE 8 | WHEN AVG(weather_state) <= 15 THEN "Cold" 9 | WHEN AVG(weather_state) >= 25 THEN "Hot" 10 | ELSE "Warm" 11 | END weather_type 12 | FROM Countries c JOIN Weather w 13 | ON c.country_id=w.country_id 14 | WHERE MONTH(w.day)=11 15 | GROUP BY c.country_id; 16 | ``` 17 | -------------------------------------------------------------------------------- /0088_Merge_Sorted_Array/Solution1.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | void merge(vector& nums1, int m, vector& nums2, int n) { 4 | int p1 = m - 1, p2 = n - 1; 5 | int k = m + n - 1; 6 | while (p1 >= 0 && p2 >= 0) { 7 | nums1[k--] = nums1[p1] > nums2[p2] ? nums1[p1--] : nums2[p2--]; 8 | } 9 | while (p2 >= 0) 10 | nums1[k--] = nums2[p2--]; 11 | } 12 | }; -------------------------------------------------------------------------------- /0123_Best_Time_to_Buy_and_Sell_Stock_III/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 泛化到k次交易，秒杀所有股票交易问题 4 | 5 | dp[k, i] = max(dp[k, i-1], prices[i] - prices[j] + dp[k-1, j-1]), j=[0..i-1] 6 | 7 | dp[k, i] 表示k次交易，第i天卖（或不交易）时的最大收益 8 | 9 | 两种情况： 10 | 11 | - i天不交易，则dp[k,i] = dp[k, i-1] 12 | - i天交易(卖)，假设我们在j天买了，则dp[k,i] = prices[i] - prices[j] + dp[k-1, j-1] 13 | 14 | 15 | 16 | j是可以等于i的，j=i，则 17 | dp[k,i] = max(dp[k,i-1], dp[k-1][i-1]) 18 | 19 | -------------------------------------------------------------------------------- /0416_Partition_Equal_Subset_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dp 2 | 3 | if sum is odd, then return false 4 | 5 | state definition: 6 | 7 | dp[i][j] means select numbers from index of [0, i], and very numbers can only bu used once, let sum of these numbers to be j. 8 | 9 | if j < nums[i], 则要和为 j 的情况下，不能选 nums[i]，则 dp[i][j] = dp[i-1][j] 10 | 11 | if j >= nums[j], 则可以选也可以不选 12 | 13 | dp[i][j] = dp[i-1][j] || dp[i-1][j-nums[i]] 14 | 15 | -------------------------------------------------------------------------------- /0580_Count_Student_Number_in_Departments/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | left join + group by 4 | 5 | 注意 6 | 7 | - 是department left join student。我们要找出dep的信息，无论有没有对应的stu。 8 | - COUNT()中要是stu的信息，这样才是stu的数量。 9 | 10 | ```sql 11 | SELECT d.dept_name, COUNT(s.student_id) AS student_number 12 | FROM department d LEFT JOIN student s 13 | ON d.dept_id=s.dept_id 14 | GROUP BY d.dept_id 15 | ORDER BY student_number DESC, d.dept_name; 16 | ``` 17 | -------------------------------------------------------------------------------- /util_go/tree/tree.go: -------------------------------------------------------------------------------- 1 | package tree 2 | 3 | type TreeNode struct { 4 | Val int 5 | Left *TreeNode 6 | Right *TreeNode 7 | } 8 | 9 | func IsEqualTree(t1, t2 *TreeNode) bool { 10 | if t1 == nil && t2 == nil { 11 | return true 12 | } 13 | if t1 == nil || t2 == nil { 14 | return false 15 | } 16 | if t1.Val != t2.Val { 17 | return false 18 | } 19 | return IsEqualTree(t1.Left, t2.Left) && IsEqualTree(t1.Right, t2.Right) 20 | } -------------------------------------------------------------------------------- /0091_Decode_Ways/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 dp 2 | 3 | dp[i]表示长度为i的str的可能解码方式。这里我们dp的总长度是`str.size()+1`。dp[0]存放1。不表示0长度的解码种数，只是为了后面的计算 4 | 5 | 以12345为例，第二行是dp对应的元素。可见当前s[i]在1到9之间时，解码的数量和dp[i-1]持平。但是substr(i-2,2)在10到26之间时，dp[i]还要加dp[i-2]; 6 | 7 | 8 | 注意i是长度 9 | dp[i] += dp[i-1] s[i-1]是1-9的数 10 | dp[i] += dp[i-2] s[i-2:i]是10到26的数 11 | 12 | ```txt 13 | 12345 14 | 112333 15 | ``` 16 | 17 | 注意处理0开头的特殊情况 18 | 19 | -------------------------------------------------------------------------------- /0447_Number_of_Boomerangs/slt.md: -------------------------------------------------------------------------------- 1 | 直接暴力会超时 2 | 3 | ### Solution 1 enumerate + hash table 4 | 5 | - t-complexity $O(n^2)$ 6 | - s-complexity $O(n)$ 7 | 8 | 题目所描述的回旋镖可以视作一个 V 型的折线。我们可以枚举每个 points[i]，将其当作 V 型的拐点 9 | 10 | 设 points 中有 m 个点到 points[i] 的距离均相等，我们需要从这 m 点中选出 2 个点当作回旋镖的 2 个端点，由于题目要求考虑元组的顺序，因此方案数即为在 m 个元素中选出 2 个不同元素的排列数 11 | 12 | $A_{m}^{2} = m \cdot (m-1)$ 13 | 14 | 所以我们只需要遍历两次，内层循环统计每个距离上，有多少个 m，用 hash table 记录从 距离到 m 的映射 15 | -------------------------------------------------------------------------------- /1083_Sales_Analysis_II/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 利用子查询，找出买了iphone的buyer，再用not in即可。 4 | 5 | 注意WHERE和GROUP BY的先后顺序 6 | 7 | ```sql 8 | SELECT s.buyer_id 9 | FROM Sales s JOIN Product p 10 | ON s.product_id=p.product_id 11 | WHERE p.product_name="S8" AND s.buyer_id NOT IN 12 | ( 13 | SELECT s.buyer_id 14 | FROM Sales s JOIN Product p 15 | ON s.product_id=p.product_id 16 | WHERE p.product_name="iPhone") 17 | GROUP BY s.buyer_id; 18 | ``` 19 | -------------------------------------------------------------------------------- /0096_Unique_Binary_Search_Trees/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | `G(n)`表示输入n时，能构建多少棵不同的BST。两个特殊情况是n=0和n=1时，空树和一个节点的树都只有一种情况，所以`G(0)=1, G(1)=1` 4 | 5 | `F(i, n)`表示以i为根结点，n的序列能构建多少棵不同的BST。我们可以得到 6 | 7 | `G(n) = F(1, n) + F(2, n) + ... + F(n, n)` 8 | 9 | 而`F(i, n)`又可以分成左右子树情况种类的乘积，即 10 | 11 | `F(i, n) = G(i-1) * G(n-i), 1 <= i <= n` 12 | 13 | 最后可以得到 14 | 15 | `G(n) = G(0) * G(n-1) + G(1) * G(n-2) + … + G(n-1) * G(0)` 16 | 17 | 最后计算的时候，要从小开始算 18 | -------------------------------------------------------------------------------- /0146_LRU_Cache/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 利用链表 2 | 3 | 把最近一次用过的放到链表头部 4 | 5 | 保持把新鲜数据往链表头移动。新鲜的定义：刚被修改(put)，或者访问过(get)，就算新鲜，就需要 splice 到链表头。 6 | 过期键直接 pop_back()，链表节点越往后，越陈旧。 7 | 8 | 代码要领： 9 | map 中保存的是 ，这样查找的时候就不用需要去遍历链表了，使用 unordered_map 就能很快找到链表节点指针。 10 | 判断容量的时候，最好不使用 std::list::size() 方法，在 c++ 里，这个方法可能不是 O(1) 的。 11 | 12 | 13 | python中手动实现一个链表 14 | 15 | python中list 的pop(0) and insert(0, v)都是O(n)时间复杂度 16 | deque则是双向链表，首尾删插都是O(1)时间复杂度 -------------------------------------------------------------------------------- /0167_Two_Sum_II_-_Input_array_is_sorted/Solution2.cpp: -------------------------------------------------------------------------------- 1 | class Solution { 2 | public: 3 | vector twoSum(vector& numbers, int target) { 4 | int l = 0, r = numbers.size() - 1; 5 | while (l < r) { 6 | int s = numbers[l] + numbers[r]; 7 | if (s < target) ++l; 8 | else if (s > target) --r; 9 | else return {l+1, r+1}; 10 | } 11 | return {}; 12 | } 13 | }; -------------------------------------------------------------------------------- /0262_Trips_and_Users/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | ```sql 4 | SELECT 5 | t.Request_at AS Day, 6 | ROUND(SUM(IF(T.STATUS = "completed",0,1))/COUNT(*), 2) AS `Cancellation Rate` 7 | FROM Trips T JOIN 8 | Users AS U1 ON (T.client_id = U1.users_id AND U1.banned ='No') JOIN 9 | Users AS U2 ON (T.driver_id = U2.users_id AND U2.banned ='No') 10 | WHERE T.request_at BETWEEN '2013-10-01' AND '2013-10-03' 11 | GROUP BY t.Request_at; 12 | ``` 13 | -------------------------------------------------------------------------------- /1218_Longest_Arithmetic_Subsequence_of_Given_Difference/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP 2 | 3 | - t-complexity: $O(n)$ 4 | - s-complexity: $O(C)$ 5 | C = 40001 6 | 7 | n is in range [-10000, 10000], n-diff is in range [-20000, 20000]. and move to positive as index 8 | 9 | - state definition: dp[n] is longest subsequence ended with n 10 | - state transfer: dp[n] = dp[n-diff] + 1 11 | - init value: None 12 | - return value: max(dp[arr[i]]) 13 | 14 | -------------------------------------------------------------------------------- /test.sh: -------------------------------------------------------------------------------- 1 | 2011-01-01 16:30:11|xxx|xxx 2 | 3 | awk 'END{print NR}' weblog.log 4 | awk '{split($1,array," ");split(array[2],array2,"|");{print($0)}}' 5 | 6 | awk '{2011-01-01 } END{print NR}' 7 | 8 | if(array2[1] >= "22/Feb/2017-18:52:59") 9 | 10 | sed -n '/2011-01-01 14:00:00/,/2011-01-01 15:00:00/p' test.log 11 | 12 | grep -o '2011-01-01 15:30:11' weblog.log | awk 'END{print NR}' 13 | 14 | grep "2011-01-01 14:*" weblog.log | awk 'END{print NR}' -------------------------------------------------------------------------------- /0164_Maximum_Gap/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 桶 2 | 3 | - 把所有数按一定区间大小放到桶中 4 | - max(当前桶中的最小值 - 前一个桶中的最大值)就是最后的结果 5 | 6 | 时间复杂度O(N) 7 | for len(桶s)： 8 | min(current 桶) 9 | 10 | len(桶s) * len(current 桶) = N 11 | 12 | 空间复杂度O(N) 13 | 14 | 关键是如何确定每个桶的长度，可以参考 15 | 16 | https://leetcode-cn.com/problems/maximum-gap/solution/python3-tong-pai-xu-by-yanghk/ 17 | 18 | https://leetcode-cn.com/problems/maximum-gap/solution/zui-da-jian-ju-by-leetcode-solution/ 19 | 20 | -------------------------------------------------------------------------------- /0614_Second_Degree_Follower/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 这道题要找出follower的follower数量 4 | 5 | 先联结两表，这样f2的followee是f1中的follower， 6 | 7 | ```sql 8 | SELECT * 9 | FROM follow f1 JOIN follow f2 10 | ON f1.follower=f2.followee; 11 | ``` 12 | 13 | 然后再找出f2的followee有多少follower就可以了。 14 | 15 | ```sql 16 | SELECT f1.follower, COUNT(DISTINCT f2.follower) AS num 17 | FROM follow f1 JOIN follow f2 18 | ON f1.follower=f2.followee 19 | GROUP BY f2.followee; 20 | ``` 21 | -------------------------------------------------------------------------------- /0236_Lowest_Common_Ancestor_of_a_Binary_Tree/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DFS 2 | 3 | - t-complexity: O(N) 4 | N is number of nodes 5 | - s-complexity: O(N) 6 | in worst case, recursion depth is N 7 | 8 | three cases for root is p and q's lowest common ancester: 9 | 10 | 1. p and q are in root's sub-trees, and is not in same side 11 | 2. p == root, q is in root's left or right sub-tree 12 | 3. q == root, p is in root's left or right sub-tree 13 | 14 | -------------------------------------------------------------------------------- /0981_Time_Based_Key-Value_Store/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash map + map 2 | 3 | Assuming n is the number of set operations, and m is the number os get operations 4 | 5 | - Time Comlpexity: 6 | - Set: O(1) single operation, and total O(n) 7 | Note: assuming timestamps are only increasing, If not, it's O(n log n) 8 | - Get: O(log n) for a single operation, and total O(m log n) 9 | - Space Comlpexity: O(n) 10 | 11 | 由于添加的 timestamp 是递增的，内层也可以用数组 + 二分查找 12 | 13 | -------------------------------------------------------------------------------- /0231_Power_of_Two/slt.md: -------------------------------------------------------------------------------- 1 | 首先明确1点，负数和零不可能是 power of two 2 | 3 | ### Solution1 不断 * 2 比较 4 | 5 | - 时间复杂度 O(logn) 6 | - 空间复杂度 O(1) 7 | 8 | ### Solution2 bit 9 | 10 | - 时间复杂度 O(1) 11 | - 空间复杂度 O(1) 12 | 13 | n为2的幂次方，则恒有： 14 | 15 | - n 二进制最高位为 1，其余所有位为 0 16 | - n−1 二进制最高位为 0，其余所有位为 1 17 | 18 | -> `n & (n-1) == 0` 19 | 20 | |2^x|n|n-1|n&(n-1)| 21 | |-|-|-|-|-| 22 | |2^0|1|0|0| 23 | |2^1|10|01|0| 24 | |2^2|100|011|0| 25 | |2^3|1000|0111|0| 26 | 27 | 但是注意思路2跑的时间实际上大于思路1哦 28 | -------------------------------------------------------------------------------- /0581_Shortest_Unsorted_Continuous_Subarray/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 贪心 + 双指针 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(1) 5 | 6 | 把 nums 分成 3 部分：ABC 7 | 8 | 设我们要找的就是 B，则 A 和 C 都是升序，且 9 | 10 | - A 中任意元素小于 B 中最小元素 11 | - C 中任意元素大于 B 中最大元素 12 | 13 | 寻找 B 右边界的方法： 14 | 15 | 从左往右遍历 nums，用 maxn 来记录当前（遇到 i 之前）的最大值。 16 | 17 | - nums[i] > maxn，说明当前元素可以作为升序序列新的末尾元素。更新 maxn 18 | - nums[i] <= maxn，说明 `[0, i]` 区间内的数组不满足升序条件。更新 r 到 i 19 | 20 | 即让 r 右边的 都大于 maxn 21 | 22 | 找左边界的方法正好相反，从右往左遍历。 23 | -------------------------------------------------------------------------------- /0789_Escape_The_Ghosts/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 贪心 + 曼哈顿距离 2 | 3 | - 时间复杂度 $O(n)$ 4 | n 为 ghosts 的数量 5 | - 空间复杂度 $O(1)$ 6 | 7 | 结论：「如果一个阻碍者能够抓到玩家，必然不会比玩家更晚到达终点」 8 | 9 | 证明： 10 | 11 | 设玩家起点、阻碍着起点、终点分别为 s, e, t。 12 | 13 | 设玩家从 s 到 t 会经过点 k。当且仅当 dist(e, k) <= dist(s, k)，时，阻碍者会在 k 点抓到玩家。 14 | 15 | 由于 k 到 t 为公共部分，所有能抓到玩家时，有 16 | 17 | dist(e, k) + dist(k, t) <= dist(s, k) + dist(k, t) 18 | 19 | -> 20 | 21 | dist(e, t) <= dist(s, t) 22 | 23 | 由于都是方格，且不能斜着移动，所以转化为曼哈顿距离 24 | -------------------------------------------------------------------------------- /0877_Stone_Game/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | - 时间复杂度 O(n^2) 4 | - 空间复杂度 O(n^2) 5 | 6 | `dp[l][r]` 表示在区间[l, r] 内，双方都做最优选择的情况下，先手与后手的得分差值 7 | 8 | 则 dp[1][n] 是 n 个堆的所有石子的双方的差值 9 | 10 | - dp[1][n] > 0，则先手赢 11 | - dp[1][n] < 0，则后手赢 12 | 13 | 不可能相等，应为总石子是奇数 14 | 15 | 状态转移方程： 16 | 17 | 这次先手从左边取（减去[l+1, r]中的最佳决策） 18 | 19 | 最大差值a = piles[l-1] - dp[l+1][r] 20 | 21 | 这次先手从右边取（减去[l, r-1]中的最佳决策） 22 | 23 | 最大差值b = piles[r-1] - dp[l][r-1] 24 | 25 | dp[l][r] = max(a, b) 26 | 27 | 28 | -------------------------------------------------------------------------------- /1111_Maximum_Nesting_Depth_of_Two_Valid_Parentheses_Strings/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 把左括号按深度分别分给A和B，这样让A和B相差的高度尽可能小。总高度也就会越小。 4 | 5 | // 让A字符串和B字符串的depth尽可能的接近。 6 | // 为什么呢？因为seq对应的栈上，每个左括号都对应一个深度，而这个左括号，要么是A的，要么是B的。 7 | // 所以，栈上的左括号只要按奇偶分配给A和B就可以啦！ 8 | 9 | 10 | 输入：seq = "()(())()" 11 | 输出：[0,0,0,1,1,0,1,1] 12 | 解释：本示例答案不唯一。 13 | 按此输出 A = "()()", B = "()()", max(depth(A), depth(B)) = 1，它们的深度最小。 14 | 像 [1,1,1,0,0,1,1,1]，也是正确结果，其中 A = "()()()", B = "()", max(depth(A), depth(B)) = 1 。 -------------------------------------------------------------------------------- /0085_Maximal_Rectangle/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | dp的状态方程是最左边、最右边和高 4 | 从最左边、最右边和高来找面积 5 | 6 | If you think this algorithm is not easy to understand, you can try this example: 7 | 8 | 0 0 0 1 0 0 0 9 | 0 0 1 1 1 0 0 10 | 0 1 1 1 1 1 0 11 | The vector "left" and "right" from row 0 to row 2 are as follows 12 | 13 | row 0: 14 | 15 | l: 0 0 0 3 0 0 0 16 | r: 7 7 7 4 7 7 7 17 | row 1: 18 | 19 | l: 0 0 2 3 2 0 0 20 | r: 7 7 5 4 5 7 7 21 | row 2: 22 | 23 | l: 0 1 2 3 2 1 0 24 | r: 7 6 5 4 5 6 7 -------------------------------------------------------------------------------- /0381_Insert_Delete_GetRandom_O(1)_-_Duplicates_allowed/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 用一个数组nums来保存所有insert的元素 4 | 5 | - insert时把元素加到nums尾部，时间复杂度O(1) 6 | - getRandom时，按nums的长度取一个随机索引返回，时间复杂度O(1) 7 | 8 | 另外用一个hash表维护数在nums的索引 9 | 10 | - key：nums中的数 11 | - val：是一个集合，由key数在nums中的索引组成 12 | 13 | 删除时，设删除x， 14 | 15 | 1. 从hash表的集合中取一个x的索引i。并从集合中remove i 16 | 2. 把nums[i]和nums[nums.length-1]（设nums[nums.length-1] 是 y）交换 17 | 3. 最后再更新原来y的索引集合 18 | 4. 最后再把换到nums最后的x pop掉 19 | 20 | 以上所有操作的时间复杂度都是O(1)，加起来也是O(1) 21 | -------------------------------------------------------------------------------- /0159_Longest_Substring_with_At_Most_Two_Distinct_Characters/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 滑动窗口 + 哈希表 2 | 3 | - 时间复杂度 $O(n)$ 4 | n 是字符串长度 5 | - 空间复杂度 $O(k)$ 6 | k 是不同字符的个数 7 | 8 | 用hashmap来保存字符和其出现的次数。 9 | 10 | 11 | "eceba" 12 | 13 | 然后如果 HashMap 中的映射数量超过两个的时候，我们需要删掉一个映射，比如此时 HashMap 中e有2个，c有1个，此时把b也存入了 HashMap，那么就有三对映射了，这时我们的 left 是0，先从e开始，映射值减1，此时e还有1个，不删除，left 自增1。这时 HashMap 里还有三对映射，此时 left 是1，那么到c了，映射值减1，此时c映射为0，将c从 HashMap 中删除，left 自增1，然后我们更新结果为 i - left + 1，以此类推直至遍历完整个字符串 14 | 15 | e 2 16 | c 1 17 | -------------------------------------------------------------------------------- /0185_Department_Top_Three_Salaries/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | 先用 join 构建一个(机构名, 员工名, 工资)的表。再利用子查询，同部门工资大于的数量小于3，自然就是这个部门的前三。卧槽。 4 | 5 | ```sql 6 | SELECT 7 | D.name AS Department, 8 | E.name AS Employee, 9 | E.Salary AS Salary 10 | FROM Employee AS E JOIN Department AS D 11 | ON E.DepartmentId=D.Id 12 | WHERE ( 13 | SELECT COUNT(DISTINCT Ein.Salary) 14 | FROM Employee AS Ein 15 | WHERE Ein.Salary > E.Salary AND Ein.DepartmentId=E.DepartmentId 16 | )<3; 17 | ``` 18 | 19 | -------------------------------------------------------------------------------- /0295_Find_Median_from_Data_Stream/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 优先队列 2 | 3 | - 时间复杂度 4 | - addNum: $O(logn)$ 5 | - findMedian: $O(1)$ 6 | - 空间复杂度 $O(n)$ 7 | 8 | 用两个优先队列 que_max, que_min, 分别存放大于中位数和小于中位数的数。 9 | 10 | - 当数量为奇数数时，让 que_min 中的数比 que_max 中多一个。此时中位数就是 que_min 的队头。 11 | - 当数量为偶数时，中位数就是他们两个队头的平均值 12 | 13 | 当添加数的时候 14 | 15 | - num <= max(que_min) 则把 num 添加到 que_min 中。并把可能多的元素移动到 que_max 中 16 | - num > max(que_min) 则把 num 添加到 que_max 中。并把可能多的元素移动到 que_min 中 17 | - 当数量为 0 时，直接加到 que_min 中 18 | -------------------------------------------------------------------------------- /0787_Cheapest_Flights_Within_K_Stops/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | - 时间复杂度 $O((m+n)k)$ 4 | m 是 flights 长度 5 | - 空间复杂度 $O(n * k)$ 6 | 即 dp 占用的空间 7 | 8 | f[t][i] 表示恰好 t 次航班，从 src 到 i 的最下花费。 9 | 10 | 状态转移方程 11 | 12 | f[t][i] = min(f[t-1][j] + cost(j,i)) for every flights 中从 j 到 i 的航班 13 | 14 | 最多能达的航班数是 k + 1，最后答案为 min(f[1][dst], f[2][dst], ..., f[k+1][dst]) 15 | 16 | 当 t=0 时，f[0][i] 表示不搭航班到 i 的最小花费，有： 17 | 18 | - f[0][i] = 0, i == src 19 | - f[0][i] = inf, i != src 20 | 21 | 22 | 23 | -------------------------------------------------------------------------------- /0178_Rank_Scores/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 使用WHERE子句 2 | 3 | ```sql 4 | SELECT 5 | score, 6 | (SELECT COUNT(DISTINCT score) FROM Scores WHERE score >= s.score) AS `rank` 7 | FROM Scores AS s 8 | ORDER BY score DESC; 9 | ``` 10 | 11 | 对于外部SELECT的每一条score，我们再用内部的SELECT，统计scores表中有多少个比外部记录大的记录的个数。 12 | 13 | ### 思路2 JOIN 14 | 15 | ```sql 16 | SELECT s1.Score, COUNT(DISTINCT(s2.Score)) AS Rank 17 | FROM Scores s1 JOIN Scores s2 18 | WHERE s1.score<=s2.score 19 | GROUP BY s1.Id 20 | ORDER BY Rank; 21 | ``` 22 | 23 | -------------------------------------------------------------------------------- /0397_Integer_Replacement/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 bit + greedy 2 | 3 | if last bit is 0, then right shift, one step down 4 | if not, count bit of n-1 and n+1, we want remove as much ones as possible 5 | 6 | for -1, only left-most bit of 1 can be removed 7 | for +1, all left-most consecutive ones will be removed 8 | 9 | then n + 1 == n - 1, do ++n is better, except 3 10 | 11 | special cases: 12 | - a special case is when n = 3, n + 1 == n - 1, use n-1 will fast 13 | - n = `INT_MAX`, n + 1 will overflow 14 | 15 | -------------------------------------------------------------------------------- /0765_Couples_Holding_Hands/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 Greedy 2 | 3 | ``` 4 | Time complexity: O(N^2) 5 | Space cpmplexity: O(1) 6 | ``` 7 | 8 | https://leetcode-cn.com/problems/couples-holding-hands/solution/tan-xin-suan-fa-shi-qing-lu-qian-shou-bi-eeel/ 9 | 10 | Traverse every even index, find the value's couple, then swap. 11 | 12 | Find x's couple skill: 13 | 14 | - x is even, x ends with 0 in bianry, x ^ 1 turns 0 to 1, get x + 1 15 | - x is odd, x ends with 1 in binary, x ^ 1 turns 1 to 0, get x - 1 16 | 17 | -------------------------------------------------------------------------------- /0786_K-th_Smallest_Prime_Fraction/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 priority queue 2 | 3 | - t-complexity: $O(klogn)$ 4 | n is length of arr 5 | - s-complexity: $O(n)$ 6 | 7 | for every j as denominator, numerator arr[0] - arr[i] is increasing 8 | 9 | initialize priority queue with value $arr[0] / arr[1], ..., arr[0] / arr[n-1]$ 10 | 11 | then proceed k steps, in every step, pop out smallest element, denoted as $arr[i] / arr[j]$, if i+1 < j, we push $arr[i+1] / arr[j]$ in queue. 12 | 13 | after k pops, we get result 14 | 15 | -------------------------------------------------------------------------------- /0065_Valid_Number/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DFA 2 | 3 | - 时间复杂度 4 | - 空间复杂度 5 | 6 | 首先我们把开头和结尾的空格去掉。注意中间是不能有空格的，如果中间出现空格，返回false 7 | 8 | 状态图片见图。我们一共有八种状态，其中635是终止状态，63是没有e的三种形式，5是有e的形式 9 | 10 | - 6 (数字，或正负号加数字，无小数点) 11 | - 3（浮点数） 12 | - 6->3 13 | - 1->2->3：正负号+点+数字 14 | - 2->3：点+数字 15 | 16 | ### Solution2 模拟 17 | 18 | - 时间复杂度 O(n) 19 | - 空间复杂度 O(1) 20 | 21 | 按 `e/E` 进行分割 22 | 23 | 如果有 `e/E` 则左边可以是浮点数或者整数，右边必须是整数 24 | 没有，则可以是浮点数或者整数 25 | 26 | 判断是不是浮点数或整数： 27 | 28 | - `+/-`只能出现在开头 29 | - `.` 最多出现一次 30 | - 至少有一个数字 31 | -------------------------------------------------------------------------------- /0444_Sequence_Reconstruction/slt.md: -------------------------------------------------------------------------------- 1 | 能唯一重建的意思就是任意两个数字的顺序必须是一致的，不能说在一个子序列中1在4的后面， 2 | 但是在另一个子序列中1在4的前面，这样就不是唯一的了。 3 | 还有一点就是，子序列seqs中不能出现其他的数字，就是说必须都是原序列中的数字。 4 | 5 | ### 思路1 拓扑排序 6 | 7 | 拓扑排序本身的结果不一定是唯一的，这道题要求是唯一的一个org，即要求拓扑排序的结果是唯一的，即每次入度为0的结点只有一个。 8 | 9 | 将seqs中的各序列seq按照其中元素出现的先后顺序建立有向图g。 10 | 例如seqs中的某序列seq = [1, 2, 3]，对应有向图，顶点为1, 2, 3；边为(1, 2), (2, 3)。 11 | 12 | 然后对图g执行拓扑排序，将得到的排序结果与原始序列org作比对即可。 13 | 14 | 其实也不用把拓扑排序的结果求出来： 15 | 16 | 对于一个有向图，当无环时存在拓扑排序；而唯一确定则表示拓扑排序每一层只有一个结点，且整个图是连通的，这意味这在拓扑排序的过程中，每次入度为0的结点只有一个。 17 | -------------------------------------------------------------------------------- /1126_Active_Businesses/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 找到每个event_type的平均 4 | 5 | ```sql 6 | SELECT event_type, AVG(occurences) AS avg_occurences 7 | FROM Events 8 | GROUP BY event_type; 9 | ``` 10 | 11 | ```sql 12 | SELECT e.business_id 13 | FROM Events e JOIN ( 14 | SELECT event_type, AVG(occurences) AS avg_occurences 15 | FROM Events 16 | GROUP BY event_type 17 | ) t 18 | ON e.event_type=t.event_type 19 | WHERE e.occurences>t.avg_occurences 20 | GROUP BY e.business_id 21 | HAVING COUNT(e.business_id)>1; 22 | ``` 23 | -------------------------------------------------------------------------------- /0273_Integer_to_English_Words/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 simulation 2 | 3 | - t-complexity: $O(logn)$ 4 | n is num's value, i /= 1000, so it's log 5 | - s-complexity: $O(logn)$ 6 | 7 | In English three words a group, for num <= 2^ 31 - 1, possible range is 8 | 9 | - Billion 10 | - Million 11 | - Thousand 12 | 13 | And leading these words with [0, 999] 14 | 15 | Use a function `num2str` to convert nubmer bellow 999 16 | 17 | - x >= 100: Need `??? Hundred` 18 | - x >= 20: Need `??? XXX-ty` 19 | - x < 20: Show simple words 20 | 21 | -------------------------------------------------------------------------------- /0869_Reordered_Power_of_2/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 hash 2 | 3 | - t-complexity: $O(C * log n)$ 4 | count every digit in n use log n, C is contant approximate to 30 5 | - s-complexity: $O(C)$ 6 | 7 | we can rearrange n in any order, so what only matter is count of every digits in n. 8 | 9 | 2^29 < 10^9 < 2^39, so there are 30 2's power in range of [1,10^9], as 2^0, 2^1, ..., 2^29 10 | 11 | we pre-compute every possible digits count of these 2's powers, and rearrange n to see if its in these pre-computed possible digits. 12 | 13 | -------------------------------------------------------------------------------- /util_cpp/list.h: -------------------------------------------------------------------------------- 1 | #ifndef LIST_H 2 | #define LIST_H 3 | 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | struct ListNode { 9 | int val; 10 | ListNode *next; 11 | ListNode(): val(0), next(nullptr) {} 12 | ListNode(int x): val(x), next(nullptr) {} 13 | }; 14 | 15 | bool is_equal_list(ListNode* l1, ListNode* l2); 16 | 17 | void print_list(ListNode *list); 18 | 19 | ListNode* build_from_vector(std::vector vec); 20 | vector build_vector(ListNode* list); 21 | 22 | #endif 23 | 24 | -------------------------------------------------------------------------------- /0003_Longest_Substring_Without_Repeating_Characters/stl.md: -------------------------------------------------------------------------------- 1 | ## 思路1 HashMap存放字符到索引的映射 2 | 3 | 如果用传统的双重循环遍历每个子串的话，时间复杂度是O(n^2)。我们这里使用map的时间复杂度只有O(n^logn)。（假定map search的时间复杂度为O(n^logn)，比如c++中） 4 | 5 | map的key为s中的字符，value为字符的索引 6 | 7 | start标记最近一个没有重复的字符的索引。如果当前字符已经在map中，则和start进行比较，start取最靠后的，这样保持start记录的是最近一个没有重复字符的开始索引。 8 | 另外，map和set两种容器的底层结构都是红黑树，所以容器中不会出现相同的元素，因此count()的结果只能为0和1。 9 | 10 | 注意start只能向前移动`start = max(start, char_map[s[i]] + 1);`。 11 | 12 | 13 | 如 axxxxbxxbxxxxa 14 | 15 | 如果start没有去max的话，遇到最后一个a时，start又跳回去了。把两个b都包括进去了 16 | -------------------------------------------------------------------------------- /0879_Profitable_Schemes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | 参考 4 | 5 | - 时间复杂度 O(len * n * minProfit) len 为 group 长度 6 | - 空间复杂度 O(len * n * minProfit) 7 | 8 | `dp[i][j][k]` 表示在前 i 个工作中选择了 j 个员工，并且满足工作利润至少为 k 的计划数目。 9 | 10 | 设 group 数组长度为 n，则最后的结果为 11 | 12 | sum(dp[len][j][minProfit] for j in range(n)) 13 | 14 | 对于每个工作 i，在员工为 j 的情况下，有「当前可以开展工作」和「当前无法开展工作」两种情况。 15 | 16 | 如果当前工作 i 无法开展，则 17 | 18 | dp[i][j][k] = dp[i-1][j][k] 19 | 20 | 如果当前工作 i 可以开展，则（`j-group[i]`是） 21 | 22 | dp[i][j][k] = dp[i-1][j][k] + dp[i-1][j-group[i]][max(0, k-profit[i])] -------------------------------------------------------------------------------- /.elp: -------------------------------------------------------------------------------- 1 | // chapter 3 two pointers 2 | 20230122={ 3 | [455] 4 | }, 5 | 20230123={ 6 | [135] 7 | }, 8 | 20230124={ 9 | [435] 10 | }, 11 | 20230126={ 12 | [605] 13 | }, 14 | 20230127={ 15 | [452] 16 | }, 17 | 20230128={ 18 | [763] 19 | }, 20 | 20230129={ 21 | [122] 22 | }, 23 | 202330130={ 24 | [406] 25 | }, 26 | 20230131={ 27 | [665] 28 | }, 29 | 20230202={ 30 | [167] 31 | }, 32 | 20230203={ 33 | [88] 34 | }, 35 | 20230207={ 36 | [142] 37 | }, 38 | 20230208={ 39 | [76] 40 | }, 41 | 20230209={ 42 | [633] 43 | } 44 | 45 | 46 | -------------------------------------------------------------------------------- /0010_Regular_Expression_Matching/slt.md: -------------------------------------------------------------------------------- 1 | ### Solutuion 1 递归 2 | 3 | 注意`*`一定是match preceding char，`*`不会出现在第一个位置 4 | 5 | ### Solutuion 2 DP 6 | 7 | 8 | ``` 9 | dp[i][j]: if s[0..i-1] matches p[0..j-1] 10 | 11 | if p[j-1] != '*': 12 | dp[i][j] = dp[i-1][j-1] && s[i-1] == p[j-1] 13 | 14 | if p[j-1] == '*': (denote p[j-2] with x) 15 | dp[i][j] is true iff any of the following is true 16 | 1) "x*" repeats 0 time and matches empty: dp[i][j-2] 17 | 2) "x*" repeats >= 1 times and matches "x*x": s[i-1] == x && dp[i-1][j] 18 | ``` 19 | 20 | -------------------------------------------------------------------------------- /0309_Best_Time_to_Buy_and_Sell_Stock_with_Cooldown/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DP + state machine 2 | 3 | 由题目可知，股票买卖有3个状态， 4 | 定义 dp[i][0],表示第i天持有股票 5 | 定义 dp[i][1],表示第i天处于冷冻期，且不持有股票 (刚卖) 6 | 定义 dp[i][2]，表示第i天不处于冷冻期，且不持有股票 7 | 8 | 状态机见： 9 | 10 | https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-with-cooldown/solution/czhuang-tai-ji-dong-tai-gui-hua-by-zhang-fcid/ 11 | 12 | 13 | ``` 14 | dp[i][0] = max(dp[i-1][0], dp[i-1][2] - prices[i]) 15 | dp[i][1] = dp[i-1][0] + prices[i] 16 | dp[i][2] = max(dp[i-1][1], dp[i-1][2]) 17 | ``` 18 | 19 | -------------------------------------------------------------------------------- /0005_Longest_Palindromic_Substring/slt.md: -------------------------------------------------------------------------------- 1 | ## 思路1 dp 2 | 3 | dp(i, j) represents whether s(i ... j) can form a palindromic substring, dp(i, j) is true when s(i) equals to s(j) and s(i+1 ... j-1) is a palindromic substring. When we found a palindrome, check if it's the longest one. Time complexity O(n^2). 4 | 5 | `dp[l][r]`代表`s[l,r]`是否是回文。 6 | 如果`s[l] == s[r]`且`s[l+1, r-1]`是回文，则`s[l,r]`是回文。 7 | 8 | 如果`s[l] == s[r]`且`r-l<=2`，则`s[l,r]`是回文。如aba或aa。 9 | 10 | ## 思路2 中心散开法 11 | 12 | 时间复杂度O(n^2)。下面的python实现的方法如果改成c++的话，会比cpp现在用的方法慢。因为spread_out被调用了两次。 13 | 14 | -------------------------------------------------------------------------------- /0172_Factorial_Trailing_Zeroes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 数学方法 2 | 3 | 首先题目的意思是末尾有几个0 4 | 比如`6! = 【1* 2* 3* 4* 5* 6】` 5 | 其中只有2*5末尾才有0，所以就可以抛去其他数据 专门看2 5 以及其倍数 毕竟 4 * 25末尾也是0 6 | 比如`10！ = 【2*4*5*6*8*10】` 7 | 其中 4能拆成`2*2` 10能拆成2*5 8 | 所以`10！ = 【2*（2*2）*5*（2*3）*（2*2*2）*（2*5）】` 9 | 一个2和一个5配对（即10） 就产生一个0 所以10！末尾2个0 10 | 11 | 转头一想 2肯定比5多 所以只数5的个数就行了 12 | 13 | 假若N=31 31!里能凑10的5为`[5, 2*5, 3*5, 4*5, 25, 6*5]` 其中 25还能拆为`5**2` 14 | 所以 里面的5的个数为 `int(31/(5**1)) + int(31/(5**2))` 15 | 所以 只要先找个一个`5**x < n`的x的最大数 然后按上面循环加起来 16 | 17 | 最后即是求乘法因子里有多少个5的倍数（2比5多，2 * 5 即凑成一个10） 18 | -------------------------------------------------------------------------------- /1107_New_Users_Daily_Count/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 1 选出每个user_id第一次登陆的时间 4 | 5 | ```sql 6 | SELECT user_id, MIN(activity_date) AS login_date 7 | FROM Traffic 8 | WHERE activity='login' 9 | GROUP BY user_id; 10 | ``` 11 | 12 | 2 再用90天筛选，并用你group by求数量 13 | 14 | ```sql 15 | SELECT login_date, COUNT(*) AS user_count 16 | FROM ( 17 | SELECT user_id, MIN(activity_date) AS login_date 18 | FROM Traffic 19 | WHERE activity='login' 20 | GROUP BY user_id 21 | ) AS t 22 | WHERE DATEDIFF("2019-06-30", login_date)<=90 23 | GROUP BY login_date; 24 | ``` 25 | -------------------------------------------------------------------------------- /1112_Highest_Grade_For_Each_Student/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 选出每个学生的最大分数 4 | 5 | ```sql 6 | SELECT student_id, course_id, MAX(grade) 7 | FROM Enrollments 8 | GROUP BY student_id; 9 | ``` 10 | 11 | 再JOIN两表 12 | 13 | ```sql 14 | SELECT e.student_id, MIN(e.course_id) as course_id, e.grade 15 | FROM Enrollments e JOIN ( 16 | SELECT student_id, course_id, MAX(grade) AS max_grade 17 | FROM Enrollments 18 | GROUP BY student_id 19 | ) AS t 20 | ON e.student_id=t.student_id AND e.grade=t.max_grade 21 | GROUP BY e.student_id 22 | ORDER BY e.student_id; 23 | ``` 24 | -------------------------------------------------------------------------------- /0028_Implement_strStr()/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 brute-force 2 | 3 | - 时间复杂度 O(m * n) 4 | - 空间复杂度 O(1) 5 | 6 | 题目是叫我们实现这个函数，而不是调用这个函数。 7 | 直接以每个haystack字符作为起点，依次匹配needle中的字符。 8 | 9 | python利用切片可以写得很简洁 10 | 11 | ```python 12 | class Solution: 13 | def strStr(self, haystack: str, needle: str) -> int: 14 | for i in range(len(haystack)-len(needle)+1): 15 | if haystack[i:i+len(needle)] == needle: 16 | return i 17 | return -1 18 | ``` 19 | 20 | ### 思路2 暴力破解 -- 双指针 21 | 22 | 用一次遍历 + 回溯 23 | 24 | 直接用双重循环的话会超时 25 | 26 | ### 思路3 KMP 27 | -------------------------------------------------------------------------------- /0552_Student_Attendance_Record_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(n)$ 5 | 6 | `dp[i][j][k]` 表示前 i 天、在 A 为 j 次、末尾连续的 L 为 k 次的方案数 7 | 8 | 状态转移方程： 9 | 10 | - 当前为 P：此时连续 L 为 0 11 | dp[i][j][0] += dp[i-1][j][k] for j in range(2) for k in range(3) 12 | - 当前为 L：连续的 L + 1 13 | dp[i][j][k] += dp[i-1][j][k-1] for j in range(2) for k in range(1, 3) 14 | - 当前为 A：则缺席天数加 1 15 | dp[i][1][k] += dp[i-1][0][k] for k in range(3) 16 | 17 | 初始状态： 18 | 19 | 天数为 0，A 和 L 的次数为 0，则只有一种情况，即 "P" 20 | 21 | dp[0][0][0] = 1 22 | 23 | 最后再把最后一天的所有情况加起来即可 24 | -------------------------------------------------------------------------------- /0072_Edit_Distance/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | D[i][j] 表示 word1 的前 i 个字母和 word2 的前 j 个字母之间的编辑距离。 4 | 5 | 当word[i] == word[j]时， 6 | d[i][j] = d[i-1][j-1]，因为新加上的字符相等，无需编辑 7 | 8 | 当word[i] != word[j]时，有三种情况 9 | 10 | dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1 11 | 12 | - dp[i-1][j-1]到dp[i][j]需要进行一次替换。因为在i-1和j-1的时候，两个字符串已经完成编辑相等了。两个words各加一个新字符，再进行一次转换就行了 13 | - dp[i-1][j]到dp[i][j]，需要删除一个字符。i-1和j已经是相等的了，word1再新加一个字符。把这个新加的字符删掉还是相等 14 | - dp[i][j-1]到dp[i][j]，需要插入一个字符。因为word2新加了一个字符，word1也需要插入新加的字符。 15 | 16 | 另外有编辑情况dp[0][j] = j, dp[i][0] = i。表示空字符串和非空字符串之间的转换 17 | 18 | -------------------------------------------------------------------------------- /0523_Continuous_Subarray_Sum/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + hash + 同余 2 | 3 | - 时间复杂度 O(n) 4 | - 空间复杂度 O(n) 5 | 6 | 直接暴力双重循环的话会超时 7 | 8 | 假设我们的目标区间是 `[i, j]` 9 | 10 | 有 11 | 12 | `presum[j] - presum[i-1] = n * k` 其中 n 为整数 13 | 14 | 变形 15 | 16 | `(presum[j] / k) - (presum[i-1] / k) = n` 17 | 18 | 要使两者除 k 相减为整数，则需要 presum[j] 和 presum[i-1] 对 k 的余数相同 19 | 20 | 解释： 21 | 22 | 假设: 23 | sum[i] = k * a + b 24 | sum[j] = k * c + d 25 | 那么：sum[i] - sum[j] = (k * a + b) - (k * c + d) = k * (a - c) + (b - d) 26 | 要使 (sum[i] - sum[j]) 是 k 的整数倍，就要使 b - d = 0, 即 sum[i] 与 sum[j] 除 k 余数相同 27 | -------------------------------------------------------------------------------- /0959_Regions_Cut_By_Slashes/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 并查集 2 | 3 | 把一个square看成四个三角形。 4 | 5 | 如果将每个三角形看作为一张图上的节点，则网格中的一个共边区域，就相当于图中的一个连通分量。因此，不难想到利用并查集求解连通分量的数目。 6 | 7 | 设网格为 n * n 大小，则图中有 4 * n^2 个节点，每个格子对应其中的 4 个节点。对于每个格子而言，考虑当前位置的字符 8 | 9 | - 为空格，则四个节点都连通 10 | - 为`/`，则左上角两个节点连通，右下角两个节点连通 11 | - 为`\`，则右上角两个节点连通，左下角两个节点连通 12 | 13 | 上面是一个square内部的情，如果看square之间的话，有： 14 | 15 | - 一个格子中最下方的三角形，必然和下面的格子（如果存在）中最上方的三角形连通 16 | - 一个格子中最右方的三角形，必然和右边的格子（如果存在）中最左方的三角形连通。 17 | 18 | 构造好图之后，利用并查集统计连通分量的个数即可 19 | 20 | 具体实现方面，每个格子的 4 个节点按照上、右、下、左的顺序依次编号 0123，每个节点可以根据格子所在的行和列以及节点在格子中的编号唯一地确定。 21 | 22 | -------------------------------------------------------------------------------- /0167_Two_Sum_II_-_Input_array_is_sorted/slt.md: -------------------------------------------------------------------------------- 1 | 注意这题结果 index 从 1 开始 2 | 3 | ### Solution1 遍历 + 二分查找 4 | 5 | - 时间复杂度 $O(n * logn)$ 6 | - 空间复杂度 $O(1)$ 7 | 8 | 需要索引是有序的。（其实按照 two sum 的做法，再排下序也可以....） 9 | 10 | ### Solution2 双指针 11 | 12 | - 时间复杂度 $O(n)$ 13 | l 和 r 最多总共移动 n 次 14 | - 空间复杂度 $O(1)$ 15 | 16 | 可以证明，对于排好序且有解的数组，双指针一定能遍历到最优解。证明方法如下：假设最 17 | 优解的两个数的位置分别是 l 和 r。我们假设在左指针在 l 左边的时候，右指针已经移动到了 r； 18 | 此时两个指针指向值的和小于给定值，因此左指针会一直右移直到到达 l。同理，如果我们假设 19 | 在右指针在 r 右边的时候，左指针已经移动到了 l；此时两个指针指向值的和大于给定值，因此 20 | 右指针会一直左移直到到达 r。所以双指针在任何时候都不可能处于 (l,r) 之间，又因为不满足条件时指针必须移动一个，所以最终一定会收敛在 l 和 r。 21 | -------------------------------------------------------------------------------- /0847_Shortest_Path_Visiting_All_Nodes/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 BFS 2 | 3 | - 时间复杂度 O((n ^ 2) * (2 ^ n)) 4 | 常规的 BFS 时间复杂度是 O(n + m) n 是节点数，m 是边数。 5 | 本题引入 mask 其最大值是 2 ^ n。可以看做是进行了 2 ^ n 次常规 BFS 6 | 本题 m 没有显示给出，考虑最坏情况下的完全图 有 n^2 条边。 7 | - 空间复杂度 O(n * (2 ^ n)) 8 | 即 que 占得空间 9 | 10 | 由于点可以重复访问，我们使用三元组 (u,mask,dist) 表示队列中的每一个元素 11 | 12 | - u 当前节点编号 13 | - mask 一个长度为 n 的二进制数，表示每一个节点是否经过。第 i 位为 1，表示 i 经过过 14 | - dist 表示到当前节点为止所经过的路径长度 15 | 16 | visited 数组中也不同于常规的 BFS 只保存访问过的节点，还要保存节点对应的 mask 状态 17 | 18 | 在搜索的过程中，如果当前三元组中的 mask 包含 n 个 1（即 mask=2^n-1 那么我们就可以返回 dist 作为答案 19 | -------------------------------------------------------------------------------- /1744_Can_You_Eat_Your_Favorite_Candy_on_Your_Favorite_Day?/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 模拟 + 前缀和 2 | 3 | 对于每个 query 三元组，计算能最早和最晚吃到 query[0] 类糖的时间，再判断 query[1] 是否在这个时间内 4 | 5 | 问题转换为求吃 query[0] 类糖果的最早和最晚时间 6 | 7 | - fav类型：t = query[0] 8 | - fav天数：d = query[1] + 1 题目的天从 0 算，我们从 1 算 9 | - 每天吃糖上限：c = query[2] 10 | 11 | 另外预先求得 candiesCount 的前缀和数组 presum，以便快速求得 t 类糖果之前有多少糖果。 12 | 13 | 我们的 presume 数组从 1 开始 14 | 15 | 求最早时间（第一颗 t 糖的最小时间）（以最大速率 c 吃糖）： 16 | 17 | `(presum[t] / c) + 1` 18 | 19 | 最晚时间（最后一个 t 糖的最晚时间）（以最小速率 1 吃糖）： 20 | 21 | `persum[t+1]` 22 | 23 | 24 | 25 | 26 | 27 | 28 | -------------------------------------------------------------------------------- /mst17.14_Smallest_K_LCCI/Solution1.py: -------------------------------------------------------------------------------- 1 | from typing import * 2 | 3 | 4 | class Solution: 5 | def smallestK(self, arr: List[int], k: int) -> List[int]: 6 | arr.sort() 7 | return arr[:k] 8 | 9 | 10 | def test(test_name, arr, k, expected): 11 | res = Solution().smallestK(arr, k) 12 | if res == expected: 13 | print(test_name + ' succeed') 14 | else: 15 | print(test_name + ' fail') 16 | 17 | 18 | if __name__ == '__main__': 19 | arr1 = [1,3,5,7,2,4,6,8] 20 | k1 = 4 21 | expected1 = [1,2,3,4] 22 | test('tset1', arr1, k1, expected1) 23 | -------------------------------------------------------------------------------- /0142_Linked_List_Cycle_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 快慢双指针 2 | 3 | - 时间复杂度 $O(n)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | fast 指针每次走两步，slow 指针每次走一步 7 | 8 | 把链表分成两部分，设环前的长度为 a，环中的长度为 b。 9 | 10 | - 第一次相遇： 11 | - case1 fast 遇到 NULL，说明是无环链表，直接返回 nullptr 12 | - case2 fast == slow，设 fast 走了 f 步，slow 走了 s 步。有 13 | - f = 2s 14 | - f = s + nb 快指针比慢指针多走 n 圈 15 | 可以解得：s = nb, f = 2nb。即慢指针走了 n 圈，快指针走了 2n 圈 16 | - 第二次相遇： 17 | 如果一个指针走 a + nb 步的话，则必然会走到还的入口。这时慢指针走了 nb，我们希望慢指针再走 a 步。 18 | 这时 slow 不变，将 fast 指向 head。slow 和 fast 每次都走一步。 19 | 当 fast == slow 时，f = a, s = a + nb。这时就找到入口了 20 | -------------------------------------------------------------------------------- /0289_Game_of_Life/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 用第二位存储下一阶段的状态 2 | 3 | 如果复制一个board来计算新状态，空间复杂度是O(mn)。而这种思路是常数空间复杂度。时间复杂度都是O(mn) 4 | 5 | 细胞的两种状态01只用到了第一位。注意count的数量不但包括周围八个，也包括了board[i][j]本身 6 | 7 | 首先明确可以或的情况，简化一下就是： 8 | 9 | - 周围有三个，则不论ij生死，新阶段都可以活 10 | - 周围有两个，则ij生，新阶段也可以活 11 | 12 | `` 13 | 14 | 上面的判断里， 15 | 16 | (board[i][j] == 0 && count == 3) || (board[i][j] == 1 && count == 3 || count == 4) 17 | 18 | 上面的判断可以优化为 19 | 20 | (count == 3 || (count == 4 && board[i][j] == 1)) 21 | 22 | - 如果ij当前是0，则必有count=3，周围有三个，所以新阶段可以活 23 | - 如果ij当前是1 24 | - count=3，周围有两个，新阶段活 25 | - count=4，周围有三个，新阶段活 26 | 27 | 28 | -------------------------------------------------------------------------------- /1098_Unpopular_Books/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 1 LEFT JOIN 两表，并过滤掉一月以内的书，可能存在书没有order的情况 4 | 5 | ```sql 6 | SELECT * 7 | FROM Books b LEFT JOIN Orders o 8 | ON b.book_id=o.book_id 9 | WHERE 30= nums2[i], add nums2[i] to stack 15 | 16 | -------------------------------------------------------------------------------- /0534_Game_Play_Analysis_III/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 2 | 3 | ```sql 4 | FROM Activity a1 JOIN Activity a2 5 | ON a1.player_id=a2.player_id AND a1.event_date >= a2.event_date 6 | ``` 7 | 8 | 这样得到的结果是a1表的时间是大于等于a2表的 9 | 10 | 如2016-03-01>=2016-03-01，结果是1个2016-05-02 >= 2016-05-02和2016-03-01，结果是两个，以此类推。这样正好实现了累加。 11 | 12 | ```sql 13 | SELECT 14 | a1.player_id, 15 | a1.event_date, 16 | SUM(a2.games_played) AS games_played_so_far 17 | FROM Activity AS a1 JOIN Activity AS a2 18 | ON a1.player_id=a2.player_id AND a1.event_date>=a2.event_date 19 | GROUP BY a1.player_id, a1.event_date; 20 | ``` 21 | 22 | -------------------------------------------------------------------------------- /1109_Corporate_Flight_Bookings/slt.md: -------------------------------------------------------------------------------- 1 | 直接 double-for loop 遍历累加会超时 2 | 3 | ### Solution1 记录中途变化量 4 | 5 | - 时间复杂度 $O(n + m)$ 6 | m 为 bookings 的长度 7 | - 空间复杂度 $O(n)$ 8 | 9 | 1. 换一种思路理解题意，将问题转换为：某公交车共有 n 站，第 i 条记录 bookings[i] = [i, j, k] 表示在 i 站上车 k 人，乘坐到 j 站，在 j+1 站下车，需要按照车站顺序返回每一站车上的人数 10 | 11 | 2. 根据 1 的思路，定义 counter[] 数组记录每站的人数变化，counter[i] 表示第 i+1 站。遍历 bookings[]：bookings[i] = [i, j, k] 表示在 i 站增加 k 人即 counters[i-1] += k，在 j+1 站减少 k 人即 counters[j] -= k 12 | 13 | counter[i] 表示 i 站 新增/减少 的人数，即变化的人数 14 | 15 | 3. 遍历（整理）counter[] 数组，得到每站总人数： 每站的人数为前一站人数加上当前人数变化 counters[i] += counters[i - 1] 16 | 17 | -------------------------------------------------------------------------------- /0220_Contains_Duplicate_III/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | 我们换种思路。 由于本题对索引有要求，因此直接排序破坏了原来的索引的做法是不行的。 我们考虑使用桶排序。 4 | 5 | 我们将数据分到 M 个桶 中。 6 | 7 | 每个数字nums[i] 都被我们分配到一个桶中 8 | 分配的依据就是 nth = nums[i] // (t + 1) 9 | nth分别是(t+1)的0倍，1倍，2倍... 10 | 11 | 这样相邻桶内的数字最多相差2 * t + 1 12 | 如t = 3, t+1 = 4 13 | 第一个桶：0,1,2,3, 14 | 第二个桶：4,5,6,7 15 | 16 | 最多相差7，就是2t + 1 17 | 18 | 不相邻的桶一定不满足相差小于等于t 19 | 20 | 同一个桶内的数字最多相差t 21 | 22 | 因此如果命中同一个桶内，那么直接返回True，即一个桶中有多个 23 | 24 | 如果命中相邻桶，我们再判断一下是否满足 相差 <= t 25 | 否则返回False 26 | 27 | 需要注意的是，由于题目有索引相差k的要求，因此要维护一个大小为k的窗口，定期清除桶中过期的数字。 28 | 29 | 代码 30 | 我们使用哈希表来模拟桶，key就是桶号，value就是数字本身。 31 | -------------------------------------------------------------------------------- /1746_Maximum_Subarray_Sum_After_One_Operation/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 DP 2 | 3 | - replace: ends with n and must replaced one 4 | - nonreplace: ends with n and must not replaced 5 | 6 | for replace, there are three cases: 7 | 8 | - `n * n`: replace current n, and start this as new subarray. 9 | - `n * n + nonreplace`: replace current n and plus former nonreplace subarray. 10 | - `n + replace`: already replaced before and add current n to subarray. 11 | 12 | for nonreplace, there are only two cases: 13 | 14 | - `n`: n start as a new subarray. 15 | - `n + nonreplace`: n plus former nonreplace subarray. 16 | 17 | -------------------------------------------------------------------------------- /0221_Maximal_Square/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | 注意，状态方程dp[i][j]表示的是边长，不是面积。 4 | 5 | 对于最左边一列和最上面一行，dp都是0。 6 | 7 | When i > 0 and j > 0, if matrix[i][j] = '0', then dp[i][j] = 0 since no square will be able to contain the '0' at that cell. If matrix[i][j] = '1', we will have dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1, which means that the square will be limited by its left, upper and upper-left neighbors. 8 | 9 | if matrix[i][j] == '0': 10 | dp[i][j] = 0 11 | else: 12 | dp[i][j] = min(dp[i-1][j-1], dp[i-1][j], dp[i][j-1]) + 1 13 | 14 | 15 | 是min因为只有左、上、左上三个方向都能组成square，[i][j]才能组成square 16 | 17 | -------------------------------------------------------------------------------- /0229_Majority_Element_II/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 Boyer-Moore Algorithm 2 | 3 | - t-complexity: $O(N)$ 4 | - s-complexity: $O(1)$ 5 | 6 | If you aren't familiar with Boyer-Moore Algorithm, please read [this article](https://gregable.com/2013/10/majority-vote-algorithm-find-majority.html) first. 7 | 8 | since the requirement is finding the majority for more than floor of [n/3], the answer would be less than or equal to two numbers. So we can modify the algorithm to maintain two counters for two majorities. 9 | 10 | majorities count in 1/2 could at most be 1. 11 | majorities count in 1/3 could at most be 2. 12 | ... 13 | 14 | -------------------------------------------------------------------------------- /0384_Shuffle_an_Array/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | 3 | def __init__(self, nums: List[int]): 4 | self.origin = nums 5 | self.l = len(nums) 6 | 7 | def reset(self) -> List[int]: 8 | return self.origin 9 | 10 | def shuffle(self) -> List[int]: 11 | res = self.origin[:] 12 | for i in range(self.l): 13 | j = randint(i, self.l-1) 14 | res[i], res[j] = res[j], res[i] 15 | return res 16 | 17 | # Your Solution object will be instantiated and called as such: 18 | # obj = Solution(nums) 19 | # param_1 = obj.reset() 20 | # param_2 = obj.shuffle() -------------------------------------------------------------------------------- /0488_Zuma_Game/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 DFS with memoization for optimization 2 | 3 | 1. Use `unordered_map` to count frequencies of balls in `hand`. Use another `unordered_map` to memoization of `steps` needed to empty `board`. 4 | 2. Use recursive DFS to try inserting every ball in hand at every position on the board. 5 | 3. Decrease freq of ball when inserting it on the board and increase it before trying a new combination. 6 | 4. Update the board after inserting a ball on the board and recursively call DFS on the new board with the new hand. 7 | 5. Return the minimum steps after trying all combination. 8 | 9 | -------------------------------------------------------------------------------- /0514_Freedom_Trail/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | dp[i][j]表示 从前往后拼，key的第i个字符，ring的第j个字符往12点对齐最少的步数 4 | 5 | 显然，ring的第j个字符和key的第i个字符必须相等才行， 6 | 7 | 对key的第i个字符，假设是x，需要考虑x在ring中下标的集合。 8 | 9 | 因此对每一次字符，维护一个数组pos[i]，表示x在ring中的位置的集合 10 | 11 | 12 | 对与dp[i][j]，需要枚举上次的字符pos[i-1]，在ring中的所有位置k。 13 | 14 | for k in pos[i-1] 15 | min { 16 | dp[i-1][k] + min( abs(j-k), n - abs(j-k) ) + 1 17 | } 18 | 19 | min中的三部分： 20 | 21 | - dp[i-1][k]：上次的值 22 | - min( abs(j-k), n - abs(j-k) )，k转到上次j的位置的步数。因为是环，所以有后面的`n - abs(j-k)` 23 | - 1：按下 24 | 25 | 26 | 空间复杂度O(mn) 27 | 时间复杂度O(mn^2) 28 | 29 | m是key的长度，n是ring的长度。由于用了pos，所以O(mn^2)是一个宽泛的上界。 -------------------------------------------------------------------------------- /utils_js/array.js: -------------------------------------------------------------------------------- 1 | let isEqualArray = function(arr1, arr2) { 2 | if (!Array.isArray(arr1) || !Array.isArray(arr2)) 3 | return false; 4 | 5 | if (arr1.length != arr2.length) 6 | return false; 7 | 8 | for (let i = 0; i < arr1.length; i++) { 9 | if (Array.isArray(arr1[i]) && Array.isArray(arr2[i])) { 10 | if (!isEqualArray(arr1[i], arr2[i])) 11 | return false; 12 | } else { 13 | if (arr1[i] != arr2[i]) 14 | return false; 15 | } 16 | } 17 | return true; 18 | } 19 | 20 | const ArrayUtil = { 21 | isEqualArray: isEqualArray, 22 | }; 23 | 24 | export default ArrayUtil; 25 | -------------------------------------------------------------------------------- /0319_Bulb_Switcher/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution 1 math 2 | 3 | - t-complexity: $O(1)$ 4 | - s-complexity: $O(1)$ 5 | 6 | A bulb ends up on iff it is switched an odd number of times. 7 | 8 | Call them bulb 1 to bulb n. Bulb i is switched in round d if and only if d divides i. So bulb i ends up on if and only if it has an odd number of divisors. 9 | 10 | Divisors come in pairs, like i=12 has divisors 1 and 12, 2 and 6, and 3 and 4. Except when i is a square, like 36 has divisors 1 and 36, 2 and 18, 3 and 12, 4 and 9, and double divisor 6. So bulb i ends up on if and only if i is a square. 11 | 12 | So just count the square numbers. 13 | 14 | -------------------------------------------------------------------------------- /0007_Reverse_Integer/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 常规数学转换 + 溢出检查 2 | 3 | 2^31-1 = 2147483647 4 | -2^31 = -2147483648 5 | 6 | 在每次循环中，res都会乘以10，我们提前检查res和`INT_MIN/10, INT_MAX/10`的关系 7 | 8 | 如果res恰好等于`INT_MIN/10, INT_MAX/10`，则判断pop与7和-8的关系 9 | 10 | 注意 python 负数的整除和求模都和 c++ 不同 11 | 12 | ### 思路2 直接用切片反转（python是不会溢出的）（only python） 13 | 14 | 先记录正负号，直接用切片反转，然后用`int(str())`的方法去掉0。最后返回时判断一下有没有越界。 15 | 16 | 17 | ```python 18 | class Solution: 19 | def reverse(self, x: int) -> int: 20 | sign = 1 if x >= 0 else -1 21 | res = sign * int(str(sign * x)[::-1]) 22 | return 0 if res > 2 ** 31 -1 or res < -(2 ** 31) else res 23 | ``` 24 | -------------------------------------------------------------------------------- /0152_Maximum_Product_Subarray/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 遍历一遍，同时记录最大和最小值 2 | 3 | 如果遇到负号，则最大的就会变成最小的，所以我们要同时记录max和min两个值。 4 | 5 | “ 6 | C++，数组，我觉得不算动态规划。 7 | 8 | 这个题目感觉不像动态规划，更像“最大子列和”的那种“在线处理”的解法。 9 | 10 | 如果之前有理解过“在线处理”算法的话，就能比较容易地解出这道题了。 11 | 12 | 首先假设存在某个最大乘积，然后对数组遍历，在经过每个元素的时候，有以下四种情况： 13 | 14 | 如果该元素为正数： 15 | 如果到上一个元素为止的最大乘积也是正数，那么直接乘上就好了，同样的最大乘积也会变得更大 16 | 如果到上一个元素为止的最大乘积是负数，那么最大乘积就会变成该元素本身，且连续性被断掉 17 | 如果该元素为负数： 18 | 如果到上一个元素为止的最大乘积也是负数，那么直接乘上就好了，同样的最大乘积也会变得更大 19 | 如果到上一个元素为止的最大乘积是正数，那么最大乘积就会不变，且连续性被断掉 20 | 以上四种情况中说到的最大乘积都是临时最大乘积，每遍历新的元素都需要进行比较来确定真正的最大乘积。 21 | 22 | 如果细心的话就可以发现，如果要得到乘以当前元素以后的最大乘积，需要记录最大乘积，也要记录最小乘积，因为最小值可能翻身变最大值。 23 | ” 24 | -------------------------------------------------------------------------------- /0172_Factorial_Trailing_Zeroes/Solution1.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number} n 3 | * @return {number} 4 | */ 5 | var trailingZeroes = function(n) { 6 | let res = 0, base = 5; 7 | while (Math.floor(n/base)) { 8 | res += Math.floor(n/base); 9 | n = Math.floor(n/base); 10 | 11 | } 12 | return res; 13 | }; 14 | 15 | var test = function(test_name, n, expected) { 16 | let res = trailingZeroes(n); 17 | if (res == expected) 18 | console.log(test_name + ' succeed'); 19 | else 20 | console.log(test_name + ' fail'); 21 | } 22 | 23 | test('test1', 3, 0); 24 | test('test2', 5, 1); 25 | test('test3', 10, 2); 26 | test('test4', 30, 7); 27 | -------------------------------------------------------------------------------- /0122_Best_Time_to_Buy_and_Sell_Stock_II/Solution1.js: -------------------------------------------------------------------------------- 1 | /** 2 | * @param {number[]} prices 3 | * @return {number} 4 | */ 5 | var maxProfit = function(prices) { 6 | let res = 0; 7 | for (let i = 1; i < prices.length; ++i) { 8 | res += Math.max(0, prices[i] -prices[i-1]); 9 | } 10 | return res; 11 | }; 12 | 13 | function test(test_name, prices, expected) { 14 | const res = maxProfit(prices); 15 | if (res === expected) 16 | console.log(test_name + ' succeed'); 17 | else 18 | console.log(test_name + ' fail'); 19 | } 20 | 21 | test('test1', [7,1,5,3,6,4], 7); 22 | test('test2', [1,2,3,4,5], 4); 23 | test('test3', [7,6,4,3,1], 0); 24 | -------------------------------------------------------------------------------- /0371_Sum_of_Two_Integers/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 bit operation 2 | 3 | - t-complexity $O(C)$ 4 | C is const with value 32 5 | - s-complexity $O(1)$ 6 | 7 | iterate from low to high decimal 8 | 9 | three cases of current bits: 10 | 11 | - both bits are 1, current value depends on carry, and next carry = 1 12 | - only one of the bits is 1 13 | - if carry is 1, then current value is 0, and next carry keeps 1 14 | - if carry is 0, then current value is 1, and next carry keeps 0 15 | these two cases can be summarized as res |= ((carry ^ 1) << i), and carry remain 16 | - none of these bits are 0, current value is carry, next carry is 0 17 | 18 | -------------------------------------------------------------------------------- /utils_js/tree.js: -------------------------------------------------------------------------------- 1 | function TreeNode(val, left, right) { 2 | this.val = (val===undefined ? 0 : val) 3 | this.left = (left===undefined ? null : left) 4 | this.right = (right===undefined ? null : right) 5 | } 6 | 7 | function getInOrderArray(tree) { 8 | let resArr = []; 9 | let stk = []; 10 | let p = tree; 11 | while (p || stk.length) { 12 | while (p) { 13 | stk.push(p); 14 | p = p.left; 15 | } 16 | p = stk.pop(); 17 | resArr.push(p.val); 18 | p = p.right; 19 | } 20 | return resArr; 21 | } 22 | 23 | const TreeUtils = { 24 | getInOrderArray: getInOrderArray, 25 | }; 26 | 27 | export { TreeUtils, TreeNode }; -------------------------------------------------------------------------------- /0096_Unique_Binary_Search_Trees/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def numTrees(self, n: int) -> int: 3 | dp = [0 for i in range(n + 1)] 4 | dp[0] = dp[1] = 1 5 | 6 | for i in range(2, n + 1): 7 | for j in range(1, i + 1): 8 | dp[i] += dp[j-1] * dp[i-j] 9 | return dp[n] 10 | 11 | def test(test_name, n, expected): 12 | res = Solution().numTrees(n) 13 | if res == expected: 14 | print(test_name + ' success.') 15 | else: 16 | print(test_name + ' failed.') 17 | 18 | 19 | if __name__ == "__main__": 20 | n1 = 3 21 | expected1 = 5 22 | test('test1', n1, expected1) 23 | -------------------------------------------------------------------------------- /1734_Decode_XORed_Permutation/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 数学模拟 2 | 3 | 首先复习异或运算运算法则 4 | 5 | - a ^ a = 0 6 | - a ^ 0 = a 7 | - a ^ b = b ^ a 8 | - a ^ b = c <-> c ^ b = a 9 | 10 | 如果这道题有「首位元素」或者「结尾元素」，则便和 1720 一样了 11 | 12 | 首先 encoded 中的每一项如下 13 | 14 | [perm[0] ^ perm[1], perm[1] ^ perm[2], ..., perm[n-2] ^ perm[n-1] 15 | 16 | 例如： 17 | 18 | 01 12 23 34 （n = 5，encoded 偶数个） 19 | 20 | 得 21 | 22 | 0123 23 | 24 | 则把 encoded 中每隔一项进行异或，得： 25 | 26 | res1 = perm[0] ^ perm[1] ^ perm[2] ^ perm[3] ^ ... ^ perm[n-2] 27 | 28 | 第二部 利用交换律 29 | 30 | res2 = perm[0] ^ perm[1] ^ ... ^ perm[n-1] 31 | 32 | 则 res2 = res1 ^ perm[n-1] 33 | 推出：perm[n-1] = res1 ^ res2 这样便转化成了 1720 -------------------------------------------------------------------------------- /0043_Multiply_Strings/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def multiply(self, num1: str, num2: str) -> str: 3 | res = 0 4 | for i in range(1, len(num1) + 1): 5 | for j in range(1, len(num2) + 1): 6 | res += int(num1[-i]) * int(num2[-j]) * 10 ** (i+j-2) 7 | return str(res) 8 | 9 | def test(test_name, num1, num2, expected): 10 | res = Solution().multiply(num1, num2) 11 | if res == expected: 12 | print(test_name + ' success.') 13 | else: 14 | print(test_name + ' failed.') 15 | 16 | if __name__ == "__main__": 17 | test("test1", '2', '3', '6') 18 | test('test2', '123', '456', '56088') 19 | -------------------------------------------------------------------------------- /0343_Integer_Break/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dp 2 | 3 | for i = 2; i <= n; i++ 4 | for j = 1; j < i; j++ 5 | dp[i] = max(dp[i], max(j * (i-j), j * dp[i-j])) 6 | 7 | i表示剪成多少段。如n=5，则最少是2段，最多是5段。（mn都是整数） 8 | 9 | j遍历i剪完的每一段。比如i=2，则j=1，2.表示在第一段和第二段中再剪下去。 10 | 11 | max 第一个参数 dp[i] 表示不剪， 12 | j * (i-j) 表示 从j处剪一下，剩下i-j不剪了 13 | j * dp[i-j] 表示 从j处剪一下，剩下i-j继续剪 14 | 15 | ### 思路2 贪心 16 | 17 | 贪心算法，取3，具体见。 18 | 19 | https://leetcode-cn.com/problems/jian-sheng-zi-ii-lcof/solution/mian-shi-ti-14-ii-jian-sheng-zi-iitan-xin-er-fen-f/ 20 | 21 | 贪心法则：尽可能分解出多的 3, 3的个数为a，余数为b，b可能的值是0,1,2 22 | 23 | b = 0, return 3^a 24 | b = 1, 将末尾的3+1看成4，返回3^(a-1) + 2 * 2 25 | b = 2, 返回3^a * 2 26 | 27 | -------------------------------------------------------------------------------- /0574_Winning_Candidate/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 2 | 3 | ```sql 4 | SELECT c.Name 5 | FROM Candidate c JOIN Vote v 6 | ON c.id=v.CandidateId 7 | GROUP BY v.CandidateId 8 | ORDER BY COUNT(v.CandidateId) DESC 9 | LIMIT 1; 10 | ``` 11 | 12 | ### 思路2 13 | 14 | 首先在Vote表中用GROUP BY选出最多的人的ID 15 | 16 | ```sql 17 | SELECT CandidateId 18 | FROM Vote 19 | GROUP BY CandidateId 20 | ORDER BY COUNT(*) DESC LIMIT 1 21 | ``` 22 | 23 | 再用Cadidate表和这个表联结 24 | 25 | ```sql 26 | SELECT c.Name 27 | FROM Candidate c JOIN 28 | ( 29 | SELECT CandidateId 30 | FROM Vote 31 | GROUP BY CandidateId 32 | ORDER BY COUNT(*) DESC LIMIT 1 33 | ) AS t ON c.id=t.CandidateId; 34 | ``` 35 | -------------------------------------------------------------------------------- /0034_Find_First_and_Last_Position_of_Element_in_Sorted_Array/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 二分查找 2 | 3 | - 时间复杂度 $O(2 * logn)$ 4 | - 空间复杂度 $O(1)$ 5 | 6 | 首先我们说明一下二分查找，记住二分查找如果有重复的，找最左边和最右边的数的方法即可。 7 | 即找 lower bound 和 upper bound 的方法 8 | 9 | 10 | 先找左边界，再找右边界。找左边界从右边逼近，找右边界从左边逼的方法： 11 | 12 | 1. target < A[mid]，左边界索引一定小于mid，right = mid - 1 13 | 2. target = A[mid]，左边界就是mid或小于mid，right = mid 14 | 3. A[mid] < target，左边界大于mid，left = mid + 1 15 | 16 | 很多解答都把1和2写在了一起，即（综合1和2，当`target <= A[mid]`时，right = mid;）其实这样不好理解， 17 | 18 | 注意找右边的时候mid要加1，因为默认是向左对齐的。(向下取整) 19 | 20 | 21 | 22 | 2和3可以合并写成 2*. If A[mid] >= target, j = mid; 23 | 24 | 25 | 利用二分思想先找其左边界，再找其右边界即可，注意找左边界的时候，由右侧逼近；找右边界的时候，由左侧逼近，即可。 26 | -------------------------------------------------------------------------------- /0367_Valid_Perfect_Square/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPerfectSquare(self, num: int) -> bool: 3 | i = 1 4 | while i * i < num: 5 | i += 1 6 | return i * i == num 7 | 8 | 9 | def test(test_name, num, expected): 10 | res = Solution().isPerfectSquare(num) 11 | if type(res) == type(expected) and res == expected: 12 | print(test_name + ' succeed') 13 | else: 14 | print(test_name + ' fail') 15 | 16 | 17 | if __name__ == '__main__': 18 | num1 = 16 19 | expected1 = True 20 | test('test1', num1, expected1) 21 | 22 | num2 = 14 23 | expected2 = False 24 | test('test2', num2, expected2) 25 | -------------------------------------------------------------------------------- /0453_Minimum_Moves_to_Equal_Array_Elements/Solution1.py: -------------------------------------------------------------------------------- 1 | from typing import * 2 | 3 | 4 | class Solution: 5 | def minMoves(self, nums: List[int]) -> int: 6 | return sum(nums) - min(nums) * len(nums) 7 | 8 | 9 | def test(test_name, nums, expected): 10 | res = Solution().minMoves(nums) 11 | if type(res) == type(expected) and res == expected: 12 | print(test_name + ' succeed') 13 | else: 14 | print(test_name + ' fail') 15 | 16 | 17 | if __name__ == '__main__': 18 | nums1 = [1,2,3] 19 | expected1 = 3 20 | test('test1', nums1, expected1) 21 | 22 | nums2 = [1,1,1] 23 | expected2 = 0 24 | test('test2', nums2, expected2) 25 | -------------------------------------------------------------------------------- /0007_Reverse_Integer/Solution2.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def reverse(self, x: int) -> int: 3 | sign = 1 if x >= 0 else -1 4 | 5 | # int() 会自动去掉字符串开头的0 int('001') = 1 6 | res = sign * int(str(sign * x)[::-1]) 7 | 8 | if res > 2 ** 31 - 1 or res < -(2 ** 31): 9 | return 0 10 | return res 11 | 12 | 13 | def test(test_name, x, expected): 14 | res = Solution().reverse(x) 15 | if res == expected: 16 | print(test_name + ' success.') 17 | else: 18 | print(test_name + ' failed.') 19 | 20 | 21 | if __name__ == "__main__": 22 | test('test1', 123, 321) 23 | test('test2', -123, -321) 24 | test('test3', 120, 21) 25 | -------------------------------------------------------------------------------- /0342_Power_of_Four/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def isPowerOfFour(self, n: int) -> bool: 3 | x = 1 4 | while x < n: 5 | x *= 4 6 | return x == n 7 | 8 | 9 | def test(test_name, n, expected): 10 | res = Solution().isPowerOfFour(n) 11 | if res == expected: 12 | print(test_name + ' success.') 13 | else: 14 | print(test_name + ' failed.') 15 | 16 | 17 | if __name__ == '__main__': 18 | n1 = 16 19 | expected1 = True 20 | test('test1', n1, expected1) 21 | 22 | n2 = 5 23 | expected2 = False 24 | test('test2', n2, expected2) 25 | 26 | n3 = 1 27 | expected3 = True 28 | test('test3', n3, expected3) 29 | -------------------------------------------------------------------------------- /util_cpp/tree.h: -------------------------------------------------------------------------------- 1 | #ifndef TREE_H 2 | #define TREE_H 3 | 4 | #include 5 | #include 6 | using namespace std; 7 | 8 | struct TreeNode { 9 | int val; 10 | TreeNode *left; 11 | TreeNode *right; 12 | TreeNode(): val(0), left(nullptr), right(NULL) {} 13 | TreeNode(int x) : val(x), left(nullptr), right(NULL) {} 14 | TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {} 15 | }; 16 | 17 | enum class orderType 18 | { 19 | pre, in, post 20 | }; 21 | 22 | bool is_equal_tree(TreeNode* t1, TreeNode* t2); 23 | bool is_balanced_tree(TreeNode* root); 24 | vector get_order(TreeNode* root, orderType order_type); 25 | 26 | #endif 27 | -------------------------------------------------------------------------------- /0441_Arranging_Coins/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def arrangeCoins(self, n: int) -> int: 3 | row = 1 4 | remains = n 5 | while remains >= row: 6 | remains -= row 7 | row += 1 8 | return row-1 9 | 10 | 11 | def test(test_name, n, expected): 12 | res = Solution().arrangeCoins(n) 13 | if type(res) == type(expected) and res == expected: 14 | print(test_name + ' succeed') 15 | else: 16 | print(test_name + ' fail') 17 | 18 | 19 | if __name__ == '__main__': 20 | n1 = 5 21 | expected1 = 2 22 | test('test1', n1, expected1) 23 | 24 | n2 = 8 25 | expected2 = 3 26 | test('test2', n2, expected2) 27 | -------------------------------------------------------------------------------- /0459_Repeated_Substring_Pattern/Solution1.py: -------------------------------------------------------------------------------- 1 | class Solution: 2 | def repeatedSubstringPattern(self, s: str) -> bool: 3 | return s in (s+s)[1:-1] 4 | 5 | 6 | def test(test_name, s, expected): 7 | res = Solution().repeatedSubstringPattern(s) 8 | if res == expected: 9 | print(test_name + ' success.') 10 | else: 11 | print(test_name + ' failed.') 12 | 13 | 14 | if __name__ == '__main__': 15 | s1 = 'abab' 16 | expected1 = True 17 | test('test1', s1, expected1) 18 | 19 | s2 = 'aba' 20 | expected2 = False 21 | test('test2', s2, expected2) 22 | 23 | s3 = 'abcabcabcabc' 24 | expected3 = True 25 | test('test3', s3, expected3) 26 | 27 | -------------------------------------------------------------------------------- /1838_Frequency_of_the_Most_Frequent_Element/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 前缀和 + 二分 2 | 3 | - 时间复杂度 O(n * logn) 4 | - 空间复杂度 (n + 排序用的空间) 5 | n 是 pre_sum 用的空间 6 | 7 | 参考：https://leetcode-cn.com/problems/frequency-of-the-most-frequent-element/solution/1838-zui-gao-pin-yuan-su-de-pin-shu-shua-ub57/ 8 | 9 | 先把 nums 排序 10 | 11 | 然后遍历 i for i in range(len(nums)) 12 | 13 | 对于每个 i，取 l = 0, r = i 14 | 15 | 然后统计 mid 到 i 右边的顶上的面积 16 | 17 | // 长方形面积 - sum(nums[mid], nums[mid+1], ..., nums[i-1], nums[i]) 18 | // 后面一个用前缀和实现 19 | area = nums[i] * (i - mid + 1) - (sum[i] - sum[mid-1]) 20 | 21 | 如果: 22 | 23 | - area > k，说明这个面积太大，k不满足，l = mid + 1 24 | - area <= k，说明这个面积偏小，但可以满足，r = mid - 1 25 | 26 | 用这个二分法，找到 r 中最大的 mid 27 | -------------------------------------------------------------------------------- /0332_Reconstruct_Itinerary/slt.md: -------------------------------------------------------------------------------- 1 | ### 思路1 dfs 2 | 3 | 注意这道题和前面几道题不同，是单向图 4 | 5 | '''1.比较容易理解的方式：''' 6 | 类似大部分基本深搜，每次对当前出发点的“剩余可用目的地”循环，优先去名字值小的 7 | 但无论以递归入参还是全局变量的方式，每次进递归需层数+1，选择的ticket要暂时标为已用，即当前form-to的剩余可用次数-1 8 | 结束条件是层数达到完全遍历，若未达到又无可用目的地，说明这条路走不通了，回溯时需还原层数、可用次数 9 | 10 | 11 | 12 | '''2.更烧脑但更简洁的方式：''' 13 | 因题目强调了“假定所有机票至少存在一种合理的行程”，所以可利用深搜一定会有结果这一点，无需任何标记、判定，仅单纯对每层进行循环及扣除 14 | 15 | 也就是每次进递归，还是对当前“剩余可用目的地”循环，但选择名字值小的进入下层时直接扣除这张机票 16 | 17 | 这样任意循环若还能进行，说明还有机票没用；反之一定是“基于已经出现的终点，自身成为更早部分的终点” 18 | 19 | 这里有点绕，举例来说第一个结束循环的一定是唯一一个这样的机场：他作为机票的终点的总次数，比作为起点的总次数多1 20 | 21 | 也就是说JFK恰好是唯一相反的机场，而其它机场作为起点和终点的总次数一定相同 22 | 23 | 所以最早结束循环的递归，一定是入参为终点时，将其加入行程数组；第二个出现的，则是之前行程中，唯一可作为终点的 24 | 以此类推……最后行程数组反向，即为答案 25 | 26 | 27 | -------------------------------------------------------------------------------- /0382_Linked_List_Random_Node/Solution1.py: -------------------------------------------------------------------------------- 1 | # Definition for singly-linked list. 2 | # class ListNode: 3 | # def __init__(self, val=0, next=None): 4 | # self.val = val 5 | # self.next = next 6 | class Solution: 7 | 8 | def __init__(self, head: Optional[ListNode]): 9 | self.head = head 10 | 11 | def getRandom(self) -> int: 12 | node = self.head 13 | res, i = 0, 1 14 | while node: 15 | if randrange(i) == 0: 16 | res = node.val 17 | i += 1 18 | node = node.next 19 | return res 20 | 21 | # Your Solution object will be instantiated and called as such: 22 | # obj = Solution(head) 23 | # param_1 = obj.getRandom() -------------------------------------------------------------------------------- /0446_Arithmetic_Slices_II_-_Subsequence/slt.md: -------------------------------------------------------------------------------- 1 | ### Solution1 dp 2 | 3 | - 时间复杂度 $O(n^2)$ 4 | - 空间复杂度 $O(n)$ 5 | 6 | https://leetcode-cn.com/problems/arithmetic-slices-ii-subsequence/solution/deng-chai-shu-lie-hua-fen-ii-zi-xu-lie-b-77pl/ 7 | 8 | 我们首先考虑至少有两个元素的等差子序列，下文将其称作「弱等差子序列」 9 | 10 | 尾项和公差可以确定一个等差数列。定义状态 f[i][d] 表示尾项为 nums[i]，公差为 d 的弱等差子序列的个数。 11 | 12 | 用双重循环遍历 nums， j < i，将 nums[i] 和 nums[j] 分别当做的尾项和倒数第二项，则有 d = nums[i] - nums[j]。我们可以将 nums[i] 加到以 nums[j] 为尾项，且公差为 d 的弱等差子序列的末尾。 13 | 14 | 于是有转义方程 f[i][d] += f[j][d] + 1， +1 因为 (nums[j], nums[i]) 本身也算一个弱等差子序列。（f[i][d](弱等差的数目) = f[j][d](真等差的数目) + 1(假等差的数目)） 15 | 16 | 由于题目中要求至少三个元素，当状态转义发生时，f[j][d] 已经是弱等差子序列，再加上 nums[i] 便有了三个元素。 17 | 18 | 于是将循环中的 f[j][d] 累加，就是结果 19 | --------------------------------------------------------------------------------