├── .gitignore
├── 1-100
    ├── 1.md
    ├── 10.md
    ├── 11.md
    ├── 12.md
    ├── 13.md
    ├── 14.md
    ├── 15.md
    ├── 16.md
    ├── 17.md
    ├── 18.md
    ├── 19.md
    ├── 2.md
    ├── 20.md
    ├── 21.md
    ├── 22.md
    ├── 23.md
    ├── 24.md
    ├── 25.md
    ├── 26.md
    ├── 27.md
    ├── 28.md
    ├── 29.md
    ├── 3.md
    ├── 30.md
    ├── 31.md
    ├── 32.md
    ├── 33.md
    ├── 34.md
    ├── 35.md
    ├── 36.md
    ├── 37.md
    ├── 38.md
    ├── 39.md
    ├── 4.md
    ├── 40.md
    ├── 41.md
    ├── 42.md
    ├── 43.md
    ├── 44.md
    ├── 45.md
    ├── 46.md
    ├── 47.md
    ├── 48.md
    ├── 49.md
    ├── 5.md
    ├── 50.md
    ├── 51.md
    ├── 52.md
    ├── 53.md
    ├── 54.md
    ├── 55.md
    ├── 56.md
    ├── 57.md
    ├── 58.md
    ├── 59.md
    ├── 6.md
    ├── 60.md
    ├── 61.md
    ├── 62.md
    ├── 63.md
    ├── 64.md
    ├── 65.md
    ├── 66.md
    ├── 67.md
    ├── 68.md
    ├── 69.md
    ├── 7.md
    ├── 70.md
    ├── 71.md
    ├── 72.md
    ├── 73.md
    ├── 74.md
    ├── 75.md
    ├── 76.md
    ├── 77.md
    ├── 78.md
    ├── 79.md
    ├── 8.md
    ├── 80.md
    ├── 81.md
    ├── 82.md
    ├── 83.md
    ├── 84.md
    ├── 85.md
    ├── 86.md
    ├── 87.md
    ├── 88.md
    ├── 89.md
    ├── 9.md
    ├── 90.md
    ├── 91.md
    ├── 92.md
    ├── 93.md
    ├── 94.md
    ├── 95.md
    ├── 96.md
    ├── 97.md
    ├── 98.md
    └── 99.md
├── 1001-1100
    ├── 1000.md
    ├── 1001.md
    ├── 1002.md
    ├── 1003.md
    ├── 1004.md
    ├── 1005.md
    ├── 1006.md
    ├── 1007.md
    ├── 1008.md
    ├── 1009.md
    ├── 1010.md
    ├── 1011.md
    ├── 1012.md
    ├── 1013.md
    ├── 1014.md
    ├── 1015.md
    ├── 1016.md
    ├── 1017.md
    ├── 1018.md
    ├── 1019.md
    ├── 1020.md
    ├── 1021.md
    ├── 1022.md
    ├── 1023.md
    ├── 1024.md
    ├── 1025.md
    ├── 1026.md
    ├── 1027.md
    ├── 1028.md
    ├── 1029.md
    ├── 1030.md
    ├── 1031.md
    ├── 1032.md
    ├── 1033.md
    ├── 1034.md
    ├── 1035.md
    ├── 1036.md
    ├── 1037.md
    ├── 1038.md
    ├── 1039.md
    ├── 1040.md
    ├── 1041.md
    ├── 1042.md
    ├── 1043.md
    ├── 1044.md
    ├── 1046.md
    ├── 1047.md
    ├── 1048.md
    └── 1049.md
├── 101-200
    ├── 100.md
    ├── 101.md
    ├── 102.md
    ├── 103.md
    ├── 104.md
    ├── 105.md
    ├── 106.md
    ├── 107.md
    ├── 108.md
    ├── 109.md
    ├── 110.md
    ├── 111.md
    ├── 112.md
    ├── 113.md
    ├── 114.md
    ├── 115.md
    ├── 116.md
    ├── 117.md
    ├── 118.md
    ├── 119.md
    ├── 120.md
    ├── 121.md
    ├── 122.md
    ├── 123.md
    ├── 124.md
    ├── 125.md
    ├── 126.md
    ├── 127.md
    ├── 128.md
    ├── 129.md
    ├── 130.md
    ├── 131.md
    ├── 132.md
    ├── 133.md
    ├── 134.md
    ├── 135.md
    ├── 136.md
    ├── 137.md
    ├── 138.md
    ├── 139.md
    ├── 140.md
    ├── 141.md
    ├── 142.md
    ├── 143.md
    ├── 144.md
    ├── 145.md
    ├── 146.md
    ├── 147.md
    ├── 148.md
    ├── 149.md
    ├── 150.md
    ├── 151.md
    ├── 152.md
    ├── 153.md
    ├── 154.md
    ├── 155.md
    ├── 160.md
    ├── 162.md
    ├── 164.md
    ├── 165.md
    ├── 166.md
    ├── 167.md
    ├── 168.md
    ├── 169.md
    ├── 171.md
    ├── 172.md
    ├── 173.md
    ├── 174.md
    ├── 179.md
    ├── 187.md
    ├── 188.md
    ├── 189.md
    ├── 190.md
    ├── 191.md
    ├── 198.md
    └── 199.md
├── 201-300
    ├── 200.md
    ├── 201.md
    ├── 202.md
    ├── 203.md
    ├── 204.md
    ├── 205.md
    ├── 206.md
    ├── 207.md
    ├── 208.md
    ├── 209.md
    ├── 210.md
    ├── 211.md
    ├── 212.md
    ├── 213.md
    ├── 214.md
    ├── 215.md
    ├── 216.md
    ├── 217.md
    ├── 218.md
    ├── 219.md
    ├── 220.md
    ├── 221.md
    ├── 222.md
    ├── 223.md
    ├── 224.md
    ├── 225.md
    ├── 226.md
    ├── 227.md
    ├── 228.md
    ├── 229.md
    ├── 230.md
    ├── 231.md
    ├── 232.md
    ├── 233.md
    ├── 234.md
    ├── 235.md
    ├── 236.md
    ├── 237.md
    ├── 238.md
    ├── 239.md
    ├── 240.md
    ├── 241.md
    ├── 242.md
    ├── 257.md
    ├── 258.md
    ├── 260.md
    ├── 263.md
    ├── 264.md
    ├── 268.md
    ├── 273.md
    ├── 274.md
    ├── 275.md
    ├── 278.md
    ├── 279.md
    ├── 282.md
    ├── 283.md
    ├── 287.md
    ├── 289.md
    ├── 290.md
    ├── 292.md
    ├── 295.md
    ├── 297.md
    └── 299.md
├── 301-400
    ├── 300.md
    ├── 301.md
    ├── 303.md
    ├── 304.md
    ├── 306.md
    ├── 307.md
    ├── 309.md
    ├── 310.md
    ├── 312.md
    ├── 313.md
    ├── 315.md
    ├── 316.md
    ├── 318.md
    ├── 319.md
    ├── 321.md
    ├── 322.md
    ├── 324.md
    ├── 326.md
    ├── 327.md
    ├── 328.md
    ├── 329.md
    ├── 330.md
    ├── 331.md
    ├── 332.md
    ├── 334.md
    ├── 335.md
    ├── 336.md
    ├── 337.md
    ├── 338.md
    ├── 341.md
    ├── 342.md
    ├── 343.md
    ├── 344.md
    ├── 345.md
    ├── 347.md
    ├── 349.md
    ├── 350.md
    ├── 352.md
    ├── 354.md
    ├── 355.md
    ├── 357.md
    ├── 363.md
    ├── 365.md
    ├── 367.md
    ├── 368.md
    ├── 371.md
    ├── 372.md
    ├── 373.md
    ├── 375.md
    ├── 376.md
    ├── 377.md
    ├── 378.md
    ├── 380.md
    ├── 381.md
    ├── 382.md
    ├── 383.md
    ├── 384.md
    ├── 385.md
    ├── 386.md
    ├── 387.md
    ├── 388.md
    ├── 389.md
    ├── 390.md
    ├── 391.md
    ├── 392.md
    ├── 393.md
    ├── 394.md
    ├── 395.md
    ├── 396.md
    ├── 397.md
    ├── 398.md
    └── 399.md
├── 401-500
    ├── 400.md
    ├── 401.md
    ├── 402.md
    ├── 403.md
    ├── 404.md
    ├── 405.md
    ├── 406.md
    ├── 407.md
    ├── 409.md
    ├── 410.md
    ├── 412.md
    ├── 413.md
    ├── 414.md
    ├── 415.md
    ├── 416.md
    ├── 417.md
    ├── 419.md
    ├── 420.md
    ├── 421.md
    ├── 423.md
    ├── 424.md
    ├── 427.md
    ├── 429.md
    ├── 430.md
    ├── 432.md
    ├── 433.md
    ├── 434.md
    ├── 435.md
    ├── 436.md
    ├── 437.md
    ├── 438.md
    ├── 440.md
    ├── 441.md
    ├── 442.md
    ├── 443.md
    ├── 445.md
    ├── 446.md
    ├── 447.md
    ├── 448.md
    ├── 449.md
    ├── 450.md
    ├── 451.md
    ├── 452.md
    ├── 453.md
    ├── 454.md
    ├── 455.md
    ├── 456.md
    ├── 457.md
    ├── 458.md
    ├── 459.md
    ├── 460.md
    ├── 461.md
    ├── 462.md
    ├── 463.md
    ├── 464.md
    ├── 466.md
    ├── 467.md
    ├── 468.md
    ├── 470.md
    ├── 472.md
    ├── 473.md
    ├── 474.md
    ├── 475.md
    ├── 476.md
    ├── 477.md
    ├── 478.md
    ├── 479.md
    ├── 480.md
    ├── 481.md
    ├── 482.md
    ├── 483.md
    ├── 485.md
    ├── 486.md
    ├── 488.md
    ├── 491.md
    ├── 492.md
    ├── 493.md
    ├── 494.md
    ├── 495.md
    ├── 496.md
    ├── 497.md
    └── 498.md
├── 501-600
    ├── 500.md
    ├── 501.md
    ├── 502.md
    ├── 503.md
    ├── 504.md
    ├── 506.md
    ├── 507.md
    ├── 508.md
    ├── 509.md
    ├── 513.md
    ├── 514.md
    ├── 515.md
    ├── 516.md
    ├── 517.md
    ├── 518.md
    ├── 519.md
    ├── 520.md
    ├── 521.md
    ├── 522.md
    ├── 523.md
    ├── 524.md
    ├── 525.md
    ├── 526.md
    ├── 528.md
    ├── 529.md
    ├── 530.md
    ├── 532.md
    ├── 535.md
    ├── 537.md
    ├── 538.md
    ├── 539.md
    ├── 540.md
    ├── 541.md
    ├── 542.md
    ├── 543.md
    ├── 546.md
    ├── 547.md
    ├── 551.md
    ├── 552.md
    ├── 553.md
    ├── 554.md
    ├── 556.md
    ├── 557.md
    ├── 558.md
    ├── 559.md
    ├── 560.md
    ├── 561.md
    ├── 563.md
    ├── 564.md
    ├── 565.md
    ├── 566.md
    ├── 567.md
    ├── 572.md
    ├── 575.md
    ├── 576.md
    ├── 581.md
    ├── 583.md
    ├── 587.md
    ├── 589.md
    ├── 590.md
    ├── 591.md
    ├── 592.md
    ├── 593.md
    ├── 594.md
    ├── 598.md
    └── 599.md
├── 601-700
    ├── 600.md
    ├── 605.md
    ├── 606.md
    ├── 609.md
    ├── 611.md
    ├── 617.md
    ├── 621.md
    ├── 622.md
    ├── 623.md
    ├── 628.md
    ├── 629.md
    ├── 630.md
    ├── 632.md
    ├── 633.md
    ├── 636.md
    ├── 637.md
    ├── 638.md
    ├── 639.md
    ├── 640.md
    ├── 641.md
    ├── 643.md
    ├── 645.md
    ├── 646.md
    ├── 647.md
    ├── 648.md
    ├── 649.md
    ├── 650.md
    ├── 652.md
    ├── 653.md
    ├── 654.md
    ├── 655.md
    ├── 657.md
    ├── 658.md
    ├── 659.md
    ├── 661.md
    ├── 662.md
    ├── 664.md
    ├── 665.md
    ├── 667.md
    ├── 668.md
    ├── 669.md
    ├── 670.md
    ├── 671.md
    ├── 672.md
    ├── 673.md
    ├── 674.md
    ├── 675.md
    ├── 676.md
    ├── 677.md
    ├── 678.md
    ├── 679.md
    ├── 680.md
    ├── 682.md
    ├── 684.md
    ├── 685.md
    ├── 686.md
    ├── 687.md
    ├── 688.md
    ├── 689.md
    ├── 691.md
    ├── 692.md
    ├── 693.md
    ├── 695.md
    ├── 696.md
    ├── 697.md
    ├── 698.md
    └── 699.md
├── 701-800
    ├── 700.md
    ├── 701.md
    ├── 703.md
    ├── 704.md
    ├── 705.md
    ├── 706.md
    ├── 707.md
    ├── 709.md
    ├── 710.md
    ├── 712.md
    ├── 713.md
    ├── 714.md
    ├── 715.md
    ├── 717.md
    ├── 718.md
    ├── 719.md
    ├── 720.md
    ├── 721.md
    ├── 722.md
    ├── 724.md
    ├── 725.md
    ├── 726.md
    ├── 728.md
    ├── 729.md
    ├── 730.md
    ├── 731.md
    ├── 732.md
    ├── 733.md
    ├── 735.md
    ├── 736.md
    ├── 738.md
    ├── 739.md
    ├── 740.md
    ├── 741.md
    ├── 743.md
    ├── 744.md
    ├── 745.md
    ├── 746.md
    ├── 747.md
    ├── 748.md
    ├── 749.md
    ├── 752.md
    ├── 753.md
    ├── 754.md
    ├── 756.md
    ├── 757.md
    ├── 761.md
    ├── 762.md
    ├── 763.md
    ├── 764.md
    ├── 765.md
    ├── 766.md
    ├── 767.md
    ├── 768.md
    ├── 769.md
    ├── 770.md
    ├── 771.md
    ├── 773.md
    ├── 775.md
    ├── 777.md
    ├── 778.md
    ├── 779.md
    ├── 780.md
    ├── 781.md
    ├── 782.md
    ├── 783.md
    ├── 784.md
    ├── 785.md
    ├── 786.md
    ├── 787.md
    ├── 788.md
    ├── 789.md
    ├── 790.md
    ├── 791.md
    ├── 792.md
    ├── 793.md
    ├── 794.md
    ├── 795.md
    ├── 796.md
    ├── 797.md
    ├── 798.md
    └── 799.md
├── 801-900
    ├── 801.md
    ├── 802.md
    ├── 803.md
    ├── 804.md
    ├── 805.md
    ├── 806.md
    ├── 807.md
    ├── 808.md
    ├── 809.md
    ├── 810.md
    ├── 811.md
    ├── 812.md
    ├── 813.md
    ├── 814.md
    ├── 815.md
    ├── 816.md
    ├── 817.md
    ├── 818.md
    ├── 819.md
    ├── 820.md
    ├── 821.md
    ├── 822.md
    ├── 823.md
    ├── 824.md
    ├── 825.md
    ├── 826.md
    ├── 827.md
    ├── 828.md
    ├── 829.md
    ├── 830.md
    ├── 831.md
    ├── 832.md
    ├── 833.md
    ├── 834.md
    ├── 835.md
    ├── 836.md
    ├── 837.md
    ├── 838.md
    ├── 839.md
    ├── 840.md
    ├── 841.md
    ├── 842.md
    ├── 843.md
    ├── 844.md
    ├── 845.md
    ├── 846.md
    ├── 847.md
    ├── 848.md
    ├── 849.md
    ├── 850.md
    ├── 851.md
    ├── 852.md
    ├── 853.md
    ├── 854.md
    ├── 855.md
    ├── 856.md
    ├── 857.md
    ├── 858.md
    ├── 859.md
    ├── 860.md
    ├── 861.md
    ├── 862.md
    ├── 863.md
    ├── 864.md
    ├── 865.md
    ├── 866.md
    ├── 867.md
    ├── 868.md
    ├── 869.md
    ├── 870.md
    ├── 871.md
    ├── 872.md
    ├── 873.md
    ├── 874.md
    ├── 875.md
    ├── 876.md
    ├── 877.md
    ├── 878.md
    ├── 879.md
    ├── 880.md
    ├── 881.md
    ├── 882.md
    ├── 883.md
    ├── 884.md
    ├── 885.md
    ├── 886.md
    ├── 887.md
    ├── 888.md
    ├── 889.md
    ├── 890.md
    ├── 891.md
    ├── 892.md
    ├── 893.md
    ├── 894.md
    ├── 895.md
    ├── 896.md
    ├── 897.md
    ├── 898.md
    └── 899.md
├── 901-1000
    ├── 900.md
    ├── 901.md
    ├── 902.md
    ├── 903.md
    ├── 904.md
    ├── 905.md
    ├── 906.md
    ├── 907.md
    ├── 908.md
    ├── 909.md
    ├── 910.md
    ├── 911.md
    ├── 912.md
    ├── 913.md
    ├── 914.md
    ├── 915.md
    ├── 916.md
    ├── 917.md
    ├── 918.md
    ├── 919.md
    ├── 920.md
    ├── 921.md
    ├── 922.md
    ├── 923.md
    ├── 924.md
    ├── 925.md
    ├── 926.md
    ├── 927.md
    ├── 928.md
    ├── 929.md
    ├── 930.md
    ├── 931.md
    ├── 932.md
    ├── 933.md
    ├── 934.md
    ├── 935.md
    ├── 936.md
    ├── 937.md
    ├── 938.md
    ├── 939.md
    ├── 940.md
    ├── 941.md
    ├── 942.md
    ├── 943.md
    ├── 944.md
    ├── 945.md
    ├── 946.md
    ├── 947.md
    ├── 948.md
    ├── 949.md
    ├── 950.md
    ├── 951.md
    ├── 952.md
    ├── 953.md
    ├── 954.md
    ├── 955.md
    ├── 956.md
    ├── 957.md
    ├── 958.md
    ├── 959.md
    ├── 960.md
    ├── 961.md
    ├── 962.md
    ├── 963.md
    ├── 964.md
    ├── 965.md
    ├── 966.md
    ├── 967.md
    ├── 968.md
    ├── 969.md
    ├── 970.md
    ├── 971.md
    ├── 972.md
    ├── 973.md
    ├── 974.md
    ├── 975.md
    ├── 976.md
    ├── 977.md
    ├── 978.md
    ├── 979.md
    ├── 980.md
    ├── 981.md
    ├── 982.md
    ├── 983.md
    ├── 984.md
    ├── 985.md
    ├── 986.md
    ├── 987.md
    ├── 988.md
    ├── 989.md
    ├── 990.md
    ├── 991.md
    ├── 992.md
    ├── 993.md
    ├── 994.md
    ├── 995.md
    ├── 996.md
    ├── 997.md
    ├── 998.md
    └── 999.md
└── README.md


/.gitignore:
--------------------------------------------------------------------------------
1 | .idea/
2 | 


--------------------------------------------------------------------------------
/1-100/1.md:
--------------------------------------------------------------------------------
 1 | ### 1. 两数之和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`哈希表`
 6 | 
 7 | 给定一个整数数组  `nums` 和一个目标值  `target` ，请你在该数组中找出和为目标值的那**两个** 整数，并返回他们的数组下标。
 8 | 
 9 | 
10 | 
11 | 你可以假设每种输入只会对应一个答案。但是，你不能重复利用这个数组中同样的元素。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 给定 nums = [2, 7, 11, 15], target = 9
21 | 
22 | 因为 nums[0] + nums[1] = 2 + 7 = 9
23 | 所以返回 [0, 1]
24 | ```
25 | 
26 | ```
27 | /**
28 |  * @param {number[]} nums
29 |  * @param {number} target
30 |  * @return {number[]}
31 |  */
32 | var twoSum = function(nums, target) {
33 |   let hash={}
34 |   for(let i=0;i<nums.length;i++){
35 |     if(hash[nums[i]]!=null){
36 |       return [hash[nums[i]],i]
37 |     }
38 |     hash[target-nums[i]]=i
39 |   }
40 | };
41 | ```
42 | 
43 | 


--------------------------------------------------------------------------------
/1-100/11.md:
--------------------------------------------------------------------------------
 1 | ### 11. 盛最多水的容器
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`双指针`
 6 | 
 7 | 给定 *n*  个非负整数 *a* 1，*a* 2，...，*a* n，每个数代表坐标中的一个点(*i* ,*ai* ) 。在坐标内画 *n*  条垂直线，垂直线 *i* 的两个端点分别为(*i* ,*ai* ) 和 (*i* , 0)。找出其中的两条线，使得它们与*x* 轴共同构成的容器可以容纳最多的水。
 8 | 
 9 | 
10 | 
11 | **说明：** 你不能倾斜容器，且*n* 的值至少为 2。
12 | 
13 | 
14 | 
15 | ![](https://aliyun-lc-upload.oss-cn-hangzhou.aliyuncs.com/aliyun-lc-upload/uploads/2018/07/25/question_11.jpg)
16 | 
17 | 
18 | 
19 | 
20 | 图中垂直线代表输入数组 [1,8,6,2,5,4,8,3,7]。在此情况下，容器能够容纳水（表示为蓝色部分）的最大值为49。
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | 
28 | **示例:** 
29 | 
30 | 
31 | 
32 | ```
33 | 输入: [1,8,6,2,5,4,8,3,7]
34 | 输出: 49
35 | ```
36 | 
37 | 
38 | 
39 | -----
40 | 
41 | 思路：
42 | 
43 | 双指针，`i`和`j`分别从头和尾开始，面积和最短的边界相关；
44 | 
45 | 如果`height[i]<height[j]`，`i`可以继续右移，因为这时候的短板是`i`，因此`i`对应的数如果增大，面积也会增大；
46 | 
47 | 如果`height[i]<=height[j]`，短板变为`j`，那么`i`移动对面积就没有任何变化了，因此要左移`j`，直到下一次`heigth[i]<height[j]`的时候，短板又交换。
48 | 
49 | ```
50 | /**
51 |  * @param {number[]} height
52 |  * @return {number}
53 |  */
54 | var maxArea = function(height) { 
55 |   let res=0
56 |   let i=0,j=height.length-1
57 |   while(i<j){
58 |     res=Math.max(res,Math.min(height[i],height[j])*(j-i))
59 |     if(height[i]<height[j])i++
60 |     else j--
61 |   }
62 |   return res
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/1-100/14.md:
--------------------------------------------------------------------------------
 1 | ### 14. 最长公共前缀
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 编写一个函数来查找字符串数组中的最长公共前缀。
 8 | 
 9 | 
10 | 
11 | 如果不存在公共前缀，返回空字符串 `""` 。
12 | 
13 | 
14 | 
15 | **示例1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:["flower","flow","flight"]
21 | 输出: "fl"
22 | ```
23 | 
24 | 
25 | **示例2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入:["dog","racecar","car"]
31 | 输出: ""
32 | 解释: 输入不存在公共前缀。
33 | ```
34 | 
35 | 
36 | **说明:** 
37 | 
38 | 
39 | 
40 | 所有输入只包含小写字母 `a-z` 。
41 | 
42 | 
43 | ```
44 | /**
45 |  * @param {string[]} strs
46 |  * @return {string}
47 |  */
48 | var longestCommonPrefix = function(strs) {
49 |   if(strs.length===0)return ''
50 |   let comPre=strs[0]
51 |   for(let i=1;i<strs.length;i++){
52 |     let j=0
53 |     for(;j<strs[i].length;j++){
54 |       if(strs[i][j]!==comPre[j])break
55 |     }
56 |     if(j===0)return ''
57 |     comPre=comPre.substring(0,j)
58 |   }
59 |   return comPre
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/1-100/16.md:
--------------------------------------------------------------------------------
 1 | ### 16. 最接近的三数之和
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`双指针`
 6 | 
 7 | 给定一个包括*n*  个整数的数组 `nums` ** 和 一个目标值 `target` 。找出 `nums` ** 中的三个整数，使得它们的和与 `target` 最接近。返回这三个数的和。假定每组输入只存在唯一答案。
 8 | 
 9 | 
10 | 
11 | ```
12 | 例如，给定数组 nums = [-1，2，1，-4], 和 target = 1.
13 | 
14 | 与 target 最接近的三个数的和为 2. (-1 + 2 + 1 = 2).
15 | ```
16 | 
17 | 
18 | 
19 | -----
20 | 
21 | 思路：
22 | 
23 | 和`NO.15`基本一样的方式，相差在于：
24 | 
25 | 1. 不需要去重。
26 | 2. 不需要完全相等，而是比较当前`sum`和`target`的绝对值的差。
27 | 
28 | ```
29 | /**
30 |  * @param {number[]} nums
31 |  * @param {number} target
32 |  * @return {number}
33 |  */
34 | var threeSumClosest = function(nums, target) {
35 |   nums.sort((a,b)=>a-b)
36 |   let result=null
37 |   let min=Infinity
38 |   for(let fix=0;fix<nums.length-2;fix++){
39 |     let left=fix+1,right=nums.length-1
40 |     let sum
41 |     while(left<right){
42 |       sum=nums[fix]+nums[left]+nums[right]
43 |       if(Math.abs(sum-target)<min){
44 |         min=Math.abs(sum-target)
45 |         if(min===0)return target
46 |         result=sum
47 |       }
48 |       if(sum>target)right--
49 |       else left++
50 |     }
51 |   }
52 |   return result
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/1-100/21.md:
--------------------------------------------------------------------------------
 1 | ### 21. 合并两个有序链表
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`链表`
 6 | 
 7 | 将两个有序链表合并为一个新的有序链表并返回。新链表是通过拼接给定的两个链表的所有节点组成的。
 8 | 
 9 | 
10 | 
11 | **示例：** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入：1->2->4, 1->3->4
17 | 输出：1->1->2->3->4->4
18 | ```
19 | 
20 | ```
21 | /**
22 |  * Definition for singly-linked list.
23 |  * function ListNode(val) {
24 |  *     this.val = val;
25 |  *     this.next = null;
26 |  * }
27 |  */
28 | /**
29 |  * @param {ListNode} l1
30 |  * @param {ListNode} l2
31 |  * @return {ListNode}
32 |  */
33 | var mergeTwoLists = function(l1, l2) {
34 |   if(l1==null)return l2
35 |   if(l2==null)return l1
36 |   if(l1.val<l2.val){
37 |     l1.next=mergeTwoLists(l1.next,l2);
38 |     return l1;
39 |   }else{
40 |     l2.next=mergeTwoLists(l1,l2.next);
41 |     return l2;
42 |   }
43 | };
44 | ```
45 | 
46 | 


--------------------------------------------------------------------------------
/1-100/22.md:
--------------------------------------------------------------------------------
 1 | ### 22. 括号生成
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`、`回溯算法`
 6 | 
 7 | 给出*n* 代表生成括号的对数，请你写出一个函数，使其能够生成所有可能的并且**有效的** 括号组合。
 8 | 
 9 | 
10 | 
11 | 例如，给出*n* =** 3，生成结果为：
12 | 
13 | 
14 | 
15 | ```
16 | [
17 |   "((()))",
18 |   "(()())",
19 |   "(())()",
20 |   "()(())",
21 |   "()()()"
22 | ]
23 | ```
24 | 
25 | 
26 | 
27 | -----
28 | 
29 | 思路：
30 | 
31 | 每一个位置都有2个选择，放置`(`或者`)`。
32 | 
33 | 如果`(`的数量超过了`n`说明一定不成立；
34 | 
35 | 如果`)`的数量超过了`(`的数量，也一定不成立；
36 | 
37 | 如果两个的数量都为`n`，那么就是一个有效的完整组合。
38 | 
39 | ```
40 | /**
41 |  * @param {number} n
42 |  * @return {string[]}
43 |  */
44 | var generateParenthesis = function(n) {
45 |   let s=''
46 |   let l="(",r=")"
47 |   let res=[]
48 |   function dfs(s,n,lN,rN){
49 |     if(lN>n || lN<rN)return
50 |     if(lN===n && rN===n)res.push(s)
51 |     dfs(s+l,n,lN+1,rN)
52 |     dfs(s+r,n,lN,rN+1)
53 |   }
54 |   dfs(s,n,0,0)
55 |   return res
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/1-100/35.md:
--------------------------------------------------------------------------------
 1 | ### 35. 搜索插入位置
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`二分查找`
 6 | 
 7 | 给定一个排序数组和一个目标值，在数组中找到目标值，并返回其索引。如果目标值不存在于数组中，返回它将会被按顺序插入的位置。
 8 | 
 9 | 
10 | 
11 | 你可以假设数组中无重复元素。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: [1,3,5,6], 5
21 | 输出: 2
22 | ```
23 | 
24 | 
25 | **示例2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: [1,3,5,6], 2
31 | 输出: 1
32 | ```
33 | 
34 | 
35 | **示例 3:** 
36 | 
37 | 
38 | 
39 | ```
40 | 输入: [1,3,5,6], 7
41 | 输出: 4
42 | ```
43 | 
44 | 
45 | **示例 4:** 
46 | 
47 | 
48 | 
49 | ```
50 | 输入: [1,3,5,6], 0
51 | 输出: 0
52 | ```
53 | 
54 | ```
55 | /**
56 |  * @param {number[]} nums
57 |  * @param {number} target
58 |  * @return {number}
59 |  */
60 | var searchInsert = function(nums, target) {
61 |   if(nums[nums.length-1]<target)return nums.length
62 |   function bs(arr,n){
63 |     let lo=0,hi=arr.length-1
64 | 	  while(lo<hi){
65 |       let mid=Math.floor((lo+hi)/2)
66 |       if(arr[mid]<n)lo=mid+1
67 |       else hi=mid
68 | 	  }
69 | 	  return hi
70 | 	}
71 |   return bs(nums,target)
72 | };
73 | ```
74 | 
75 | 


--------------------------------------------------------------------------------
/1-100/41.md:
--------------------------------------------------------------------------------
 1 | ### 41. 缺失的第一个正数
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个未排序的整数数组，找出其中没有出现的最小的正整数。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,2,0]
17 | 输出: 3
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: [3,4,-1,1]
27 | 输出: 2
28 | ```
29 | 
30 | 
31 | **示例3:** 
32 | 
33 | 
34 | 
35 | ```
36 | 输入: [7,8,9,11,12]
37 | 输出: 1
38 | ```
39 | 
40 | 
41 | **说明:** 
42 | 
43 | 
44 | 
45 | 你的算法的时间复杂度应为O(*n* )，并且只能使用常数级别的空间。
46 | 
47 | 
48 | 
49 | 
50 | -----
51 | 
52 | 思路：
53 | 
54 | 将每一个数字放到它应该存在的位置，如果`nums[i]<=0`或者`nums[i]>n`(`n`为当前数组的长度)，不处理，因此如果存在以上的数字，那么最最终结果一定在`[1,n]`之间。
55 | 
56 | 因此，只需要对`[1,n]`内部的数字放到对应的`num-1`索引上，例如`1`就应该放到索引`0`上。
57 | 
58 | 通过交换将数字都放好后，对数字遍历查询，如果找到中间某个数字不连续`A[i]!==i+1`，那么就是结果，如果不能存在不连续的数字，返回`n`。
59 | 
60 | ```
61 | /**
62 |  * @param {number[]} nums
63 |  * @return {number}
64 |  */
65 | var firstMissingPositive = function(A) {
66 |   let n=A.length
67 |   for(let i=0;i<n;i++){
68 |     while(A[i]>0 && A[i]<=n && A[A[i] - 1]!==A[i]){
69 |       swap(i, A[i]-1)
70 |     }
71 |   }
72 |   for(let i=0;i<n;i++){
73 |     if(A[i]!==i+1)return i+1
74 |   }
75 |   return n+1
76 |   
77 |   function swap(i,j){
78 |     let t=A[i]
79 |     A[i]=A[j]
80 |     A[j]=t
81 |   }
82 | };
83 | ```
84 | 
85 | 


--------------------------------------------------------------------------------
/1-100/45.md:
--------------------------------------------------------------------------------
 1 | ### 45. 跳跃游戏 II
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`贪心算法`、`数组`
 6 | 
 7 | 给定一个非负整数数组，你最初位于数组的第一个位置。
 8 | 
 9 | 
10 | 
11 | 数组中的每个元素代表你在该位置可以跳跃的最大长度。
12 | 
13 | 
14 | 
15 | 你的目标是使用最少的跳跃次数到达数组的最后一个位置。
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [2,3,1,1,4]
25 | 输出: 2
26 | 解释: 跳到最后一个位置的最小跳跃数是 2。
27 |     从下标为 0 跳到下标为 1 的位置，跳1步，然后跳3步到达数组的最后一个位置。
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 
33 | 
34 | 
35 | 假设你总是可以到达数组的最后一个位置。
36 | 
37 | 
38 | 
39 | 
40 | -----
41 | 
42 | 思路：
43 | 
44 | 贪心算法，定义一个变量`maxRange`表示每一个位置能跳到的最大位置，定义变量`rangeEnd`表示当前能跳到最大的位置，遍历`nums`不断更新`maxRange`，
45 | 当`i===rangeEnd`，更新`rangeEnd`为最新的`maxRange`，表示当前这一段能跳的最远距离。
46 | 
47 | ```
48 | /**
49 |  * @param {number[]} nums
50 |  * @return {number}
51 |  */
52 | var jump = function (nums) {
53 |   if(nums.length<=1)return 0
54 |   let maxRange=nums[0]
55 |   let rangeEnd=nums[0]
56 |   let step=1
57 |   for(let i=0;i<nums.length-1;i++){
58 |     maxRange=Math.max(maxRange,nums[i]+i)
59 |     if(i===rangeEnd){
60 |       rangeEnd=maxRange
61 |       step++
62 |     }
63 |   }
64 |   return step
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/1-100/46.md:
--------------------------------------------------------------------------------
 1 | ### 46. 全排列
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`回溯算法`
 6 | 
 7 | 给定一个**没有重复** 数字的序列，返回其所有可能的全排列。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,2,3]
17 | 输出:
18 | [
19 |   [1,2,3],
20 |   [1,3,2],
21 |   [2,1,3],
22 |   [2,3,1],
23 |   [3,1,2],
24 |   [3,2,1]
25 | ]
26 | ```
27 | 
28 | 
29 | 
30 | -----
31 | 
32 | 思路：
33 | 
34 | 无重复，最基础的回溯，用一个数组`used`保存已经使用过的数字，再用一个数组`arr`跟踪当前的排列状态，如果`arr.length===nums.length`，说明已经完成，
35 | 添加到结果`res`中，注意每次递归返回需要回复`used`和`arr`，以便下次继续使用。
36 | 
37 | 
38 | 
39 | ```
40 | /**
41 |  * @param {number[]} nums
42 |  * @return {number[][]}
43 |  */
44 | var permute = function(nums) {
45 |   let res=[]
46 |   let N=nums.length
47 |   let used=Array(N).fill(false)
48 |   function backtrack(arr){
49 |     if(arr.length===N){
50 |       return res.push(arr.slice())
51 |     }
52 |     for(let i=0;i<N;i++){
53 |       if(used[i])continue
54 |       used[i]=true
55 |       arr.push(nums[i])
56 |       backtrack(arr)
57 |       arr.pop()
58 |       used[i]=false
59 |     }
60 |   }
61 |   backtrack([])
62 |   return res
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/1-100/49.md:
--------------------------------------------------------------------------------
 1 | ### 49. 字母异位词分组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`哈希表`、`字符串`
 6 | 
 7 | 给定一个字符串数组，将字母异位词组合在一起。字母异位词指字母相同，但排列不同的字符串。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: ["eat", "tea", "tan", "ate", "nat", "bat"],
17 | 输出:
18 | [
19 |   ["ate","eat","tea"],
20 |   ["nat","tan"],
21 |   ["bat"]
22 | ]
23 | ```
24 | 
25 | 
26 | **说明：** 
27 | 
28 | 
29 | 
30 | 
31 | * 所有输入均为小写字母。
32 | 
33 | * 不考虑答案输出的顺序。
34 | 
35 | 
36 | 
37 | 
38 | 
39 | 
40 | -----
41 | 
42 | 思路：
43 | 
44 | 查看2个异位词最直接的办法就是排序，这里对每一个单词进行排序，再用`hash`保存，发现相同的说明是异位词，
45 | 时间复杂度是`O(NKlogK)`，其中`N`是单词列表长度，`K`是每个单词的长度。
46 | 
47 | 另一种办法对每一个单词构建一个`26`位数组，里面存放每一个字母在当前单词中出现的次数，
48 | 
49 | 例如：`aabcab`，对应的数组就是`[3,2,1,0,0,0,...]`
50 | 
51 | 序列化该数组后，保存到`hash`，发现相同的说明就是异位词。
52 | 
53 | 第二种方法时间复杂度是`O(NK)`。
54 | 
55 | ```
56 | /**
57 |  * @param {string[]} strs
58 |  * @return {string[][]}
59 |  */
60 | var groupAnagrams = function(strs) {
61 |   let collect={},result=[]
62 |   for(let i=0;i<strs.length;i++){
63 |     let sorted=strs[i].split('').sort().join('')
64 |     if(!collect[sorted])collect[sorted]=[strs[i]]
65 |     else collect[sorted].push(strs[i])
66 |   }
67 |   for(let k in collect){
68 |     result.push(collect[k])
69 |   }
70 |   return result
71 | };
72 | ```
73 | 
74 | 


--------------------------------------------------------------------------------
/1-100/50.md:
--------------------------------------------------------------------------------
 1 | ### 50. Pow(x, n)
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`、`二分查找`
 6 | 
 7 | 实现[pow(*x* , *n* )](https://www.cplusplus.com/reference/valarray/pow/)
 8 | ，即计算 x 的 n 次幂函数。
 9 | 
10 | 
11 | 
12 | **示例 1:** 
13 | 
14 | 
15 | 
16 | ```
17 | 输入: 2.00000, 10
18 | 输出: 1024.00000
19 | ```
20 | 
21 | 
22 | **示例2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: 2.10000, 3
28 | 输出: 9.26100
29 | ```
30 | 
31 | 
32 | **示例3:** 
33 | 
34 | 
35 | 
36 | ```
37 | 输入: 2.00000, -2
38 | 输出: 0.25000
39 | 解释: 2-2 = 1/22 = 1/4 = 0.25
40 | ```
41 | 
42 | 
43 | **说明:** 
44 | 
45 | 
46 | 
47 | 
48 | * -100.0 <*x* < 100.0
49 | 
50 | * *n* 是 32 位有符号整数，其数值范围是[&minus;231,231&minus; 1] 。
51 | 
52 | 
53 | 
54 | 
55 | 
56 | 
57 | -----
58 | 
59 | 思路：
60 | 
61 | 先处理特殊情况`n===0`，`n===1`，`n===-1`；
62 | 
63 | 然后对`n`分别是偶数和奇数进行处理，最终目标就是让`n`为偶数，然后`pow(x,n)===pow(x*x,n/2)`。
64 | 
65 | ```
66 | /**
67 |  * @param {number} x
68 |  * @param {number} n
69 |  * @return {number}
70 |  */
71 | var myPow = function(x, n) {
72 |   // console.log(x,n)
73 |   if(n===0)return 1
74 |   if(n===1)return x
75 |   if(n===-1)return 1/x
76 |   if(n % 2===0){
77 |     return myPow(x*x,n/2)
78 |   }else{
79 |     return x*myPow(x*x,(n-1)/2)
80 |   }
81 | };
82 | ```
83 | 
84 | 


--------------------------------------------------------------------------------
/1-100/55.md:
--------------------------------------------------------------------------------
 1 | ### 55. 跳跃游戏
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`贪心算法`、`数组`
 6 | 
 7 | 给定一个非负整数数组，你最初位于数组的第一个位置。
 8 | 
 9 | 
10 | 
11 | 数组中的每个元素代表你在该位置可以跳跃的最大长度。
12 | 
13 | 
14 | 
15 | 判断你是否能够到达最后一个位置。
16 | 
17 | 
18 | 
19 | **示例1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [2,3,1,1,4]
25 | 输出: true
26 | 解释: 从位置 0 到 1 跳 1 步, 然后跳 3 步到达最后一个位置。
27 | ```
28 | 
29 | 
30 | **示例2:** 
31 | 
32 | 
33 | 
34 | ```
35 | 输入: [3,2,1,0,4]
36 | 输出: false
37 | 解释: 无论怎样，你总会到达索引为 3 的位置。但该位置的最大跳跃长度是 0 ， 所以你永远不可能到达最后一个位置。
38 | ```
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | 贪心，对于每一个点，找到它能跳跃的最大位置，直到最后一个点，最后检查最大位置是否超过最后的点。
47 | 
48 | ```
49 | /**
50 |  * @param {number[]} nums
51 |  * @return {boolean}
52 |  */
53 | var canJump = function(nums) {
54 |   let reach = 0;
55 |   for (let i=0; i<nums.length-1 && i<=reach;++i){
56 |     reach=Math.max(i+nums[i], reach);
57 |   }
58 |   return reach >= nums.length-1
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/1-100/56.md:
--------------------------------------------------------------------------------
 1 | ### 56. 合并区间
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`排序`、`数组`
 6 | 
 7 | 给出一个区间的集合，请合并所有重叠的区间。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [[1,3],[2,6],[8,10],[15,18]]
17 | 输出: [[1,6],[8,10],[15,18]]
18 | 解释: 区间 [1,3] 和 [2,6] 重叠, 将它们合并为 [1,6].
19 | ```
20 | 
21 | 
22 | **示例2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: [[1,4],[4,5]]
28 | 输出: [[1,5]]
29 | 解释: 区间 [1,4] 和 [4,5] 可被视为重叠区间。
30 | ```
31 | 
32 | 
33 | 
34 | -----
35 | 
36 | 思路：
37 | 
38 | 定义一个新数组`result`，用于存放更新后的所有区间。
39 | 
40 | 先按照起点排序，如果当前区间的起点和上一个区间的终点存在交集，则更新上一个区间终点的位置为当前区间终点的位置；
41 | 
42 | 否则，直接`push`当前区间。
43 | 
44 | ```
45 | /**
46 |  * @param {number[][]} intervals
47 |  * @return {number[][]}
48 |  */
49 | var merge = function(intervals) {
50 |   intervals.sort((a,b)=>a[0]===b[0]?a[1]-b[1]:a[0]-b[0])
51 |   let result=[]
52 |   for(let [x,y] of intervals){
53 |     if(result.length===0){
54 |       result.push([x,y])
55 |     }else{
56 |       let last=result[result.length-1]
57 |       if(x>last[1]){
58 |         result.push([x,y])
59 |       }else{
60 |         last[1]=Math.max(last[1],y)
61 |       }
62 |     }
63 |   }
64 |   return result
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/1-100/58.md:
--------------------------------------------------------------------------------
 1 | ### 58. 最后一个单词的长度
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个仅包含大小写字母和空格 `' '` 的字符串，返回其最后一个单词的长度。
 8 | 
 9 | 
10 | 
11 | 如果不存在最后一个单词，请返回 0。
12 | 
13 | 
14 | 
15 | **说明：** 一个单词是指由字母组成，但不包含任何空格的字符串。
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: "Hello World"
25 | 输出: 5
26 | ```
27 | 
28 | 
29 | 
30 | -----
31 | 
32 | 思路：
33 | 
34 | 倒序遍历，当还未碰到任何字母时，跳过空格，如果已经存在字母，遇到空格则`break`。
35 | 
36 | ```
37 | /**
38 |  * @param {string} s
39 |  * @return {number}
40 |  */
41 | var lengthOfLastWord = function(s) {
42 |   let len=0
43 |   for(let i=s.length-1;i>=0;i--){
44 |     if(len===0 && s[i]===' ')continue
45 |     if(s[i]===' ')break
46 |     len++
47 |   }
48 |   return len
49 | };
50 | ```
51 | 
52 | 


--------------------------------------------------------------------------------
/1-100/59.md:
--------------------------------------------------------------------------------
 1 | ### 59. 螺旋矩阵 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个正整数*n* ，生成一个包含 1 到*n* 2所有元素，且元素按顺时针顺序螺旋排列的正方形矩阵。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 3
17 | 输出:
18 | [
19 |  [ 1, 2, 3 ],
20 |  [ 8, 9, 4 ],
21 |  [ 7, 6, 5 ]
22 | ]
23 | ```
24 | 
25 | 
26 | 
27 | -----
28 | 
29 | 思路：
30 | 
31 | 与`NO.54`差不多，一层一层地处理添加到`result`中。
32 | 
33 | ```
34 | /**
35 |  * @param {number} n
36 |  * @return {number[][]}
37 |  */
38 | var generateMatrix = function(n) {
39 |   let start=0,end=n-1,num=1
40 |   let result=[]
41 |   for(let i=0;i<n;i++){
42 |     result[i]=[]
43 |   }
44 |   while(end>=start){
45 |     let i=start  
46 |     while(i<=end)result[start][i++]=num++
47 |     i=start+1
48 |     while(i<=end)result[i++][end]=num++
49 |     i=end-1
50 |     while(i>=start)result[end][i--]=num++
51 |     i=end-1
52 |     while(i>=start+1)result[i--][start]=num++
53 |     start++;end--        
54 |   }
55 |   return result
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/1-100/64.md:
--------------------------------------------------------------------------------
 1 | ### 64. 最小路径和
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`动态规划`
 6 | 
 7 | 给定一个包含非负整数的 *m* x*n* 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。
 8 | 
 9 | 
10 | 
11 | **说明：** 每次只能向下或者向右移动一步。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:
21 | [
22 |  [1,3,1],
23 |   [1,5,1],
24 |   [4,2,1]
25 | ]
26 | 输出: 7
27 | 解释: 因为路径 1&rarr;3&rarr;1&rarr;1&rarr;1 的总和最小。
28 | ```
29 | 
30 | 
31 | 
32 | -----
33 | 
34 | 思路：
35 | 
36 | 与`NO.62`和`NO.63`一个模式。
37 | 
38 | `dp[i][j]`代表当前位置的最小路径和，状态转移方程：
39 | 
40 | 右侧：`dp[i+1][j]=Math.min(dp[i+1][j],dp[i][j]+grid[i+1][j])`
41 | 
42 | 下侧：`dp[i][j+1]=Math.min(dp[i][j+1],dp[i][j]+grid[i][j+1])`
43 | 
44 | ```
45 | /**
46 |  * @param {number[][]} grid
47 |  * @return {number}
48 |  */
49 | var minPathSum = function(grid) {
50 |   if(grid.length===0)return 0  
51 |   let m=grid.length,n=grid[0].length
52 |   let dp=Array(m).fill().map(()=>Array(n).fill(Infinity))
53 |   dp[0][0]=grid[0][0]
54 |   for(let i=0;i<m;i++){
55 |     for(let j=0;j<n;j++){
56 |       if(i<m-1){
57 |         dp[i+1][j]=Math.min(dp[i+1][j],dp[i][j]+grid[i+1][j])
58 |       }
59 |       if(j<n-1){
60 |         dp[i][j+1]=Math.min(dp[i][j+1],dp[i][j]+grid[i][j+1])
61 |       }
62 |     }
63 |   }
64 |   return dp[m-1][n-1]
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/1-100/66.md:
--------------------------------------------------------------------------------
 1 | ### 66. 加一
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个由**整数** 组成的**非空** 数组所表示的非负整数，在该数的基础上加一。
 8 | 
 9 | 
10 | 
11 | 最高位数字存放在数组的首位， 数组中每个元素只存储一个数字。
12 | 
13 | 
14 | 
15 | 你可以假设除了整数 0 之外，这个整数不会以零开头。
16 | 
17 | 
18 | 
19 | **示例1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [1,2,3]
25 | 输出: [1,2,4]
26 | 解释: 输入数组表示数字 123。
27 | ```
28 | 
29 | 
30 | **示例2:** 
31 | 
32 | 
33 | 
34 | ```
35 | 输入: [4,3,2,1]
36 | 输出: [4,3,2,2]
37 | 解释: 输入数组表示数字 4321。
38 | ```
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | 字符串加法的简单版，处理好进位。
47 | 
48 | ```
49 | /**
50 |  * @param {number[]} digits
51 |  * @return {number[]}
52 |  */
53 | var plusOne = function(digits) {
54 |   let carry=1,id=digits.length-1
55 |   while(carry>0 && id>=0){
56 |     digits[id]+=carry
57 |     carry=Math.floor(digits[id]/10)
58 |     digits[id] %= 10
59 |     id--
60 |   }
61 |   if(carry>0)digits.unshift(carry)
62 |   return digits
63 |   
64 |   // let i=digits.length-1
65 |   // digits[i]+=1
66 |   // while(digits[i]===10){
67 |   //   digits[i]=0
68 |   //   if(i===0)digits.unshift(0)
69 |   //   else i--
70 |   //   digits[i]+=1
71 |   // }
72 |   // return digits
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/1-100/67.md:
--------------------------------------------------------------------------------
 1 | ### 67. 二进制求和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`、`字符串`
 6 | 
 7 | 给定两个二进制字符串，返回他们的和（用二进制表示）。
 8 | 
 9 | 
10 | 
11 | 输入为**非空** 字符串且只包含数字 `1` 和 `0` 。
12 | 
13 | 
14 | 
15 | **示例1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: a = "11", b = "1"
21 | 输出: "100"
22 | ```
23 | 
24 | 
25 | **示例2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: a = "1010", b = "1011"
31 | 输出: "10101"
32 | ```
33 | 
34 | 
35 | 
36 | -----
37 | 
38 | 思路：
39 | 
40 | 字符串加法的原理，只是`10`进制转为`2`进制。
41 | 
42 | ```
43 | /**
44 |  * @param {string} a
45 |  * @param {string} b
46 |  * @return {string}
47 |  */
48 | var addBinary = function(a, b) {
49 |   let res='',carry=0
50 |   let i=a.length-1,j=b.length-1
51 |   while(i>=0 || j>=0){
52 |     let sum
53 |     if(i===-1){
54 |       sum=+b[j--]+carry
55 |     }else if(j===-1){
56 |       sum=+a[i--]+carry
57 |     }else{
58 |       sum=+a[i--] + +b[j--] +carry
59 |     }
60 |     carry=Math.floor(sum/2)
61 |     sum %=2
62 |     res=sum+''+res
63 |   }
64 |   if(carry>0)return carry+''+res
65 |   return res
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/1-100/69.md:
--------------------------------------------------------------------------------
 1 | ### 69. x 的平方根
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`、`二分查找`
 6 | 
 7 | 实现 `int sqrt(int x)` 函数。
 8 | 
 9 | 
10 | 
11 | 计算并返回*x* 的平方根，其中*x* 是非负整数。
12 | 
13 | 
14 | 
15 | 由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: 4
25 | 输出: 2
26 | ```
27 | 
28 | 
29 | **示例 2:** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入: 8
35 | 输出: 2
36 | 说明: 8 的平方根是 2.82842..., 
37 |     由于返回类型是整数，小数部分将被舍去。
38 | ```
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | `二分法`，初始最小值`l`为`0`，初始最大值`h`为`Math.floor(x/2)`。
47 | 
48 | ```
49 | /**
50 |  * @param {number} x
51 |  * @return {number}
52 |  */
53 | var mySqrt = function(x) {
54 |   if(x===1)return 1
55 |   let l=0,h=Math.floor(x/2)
56 |   while(l<h){
57 |     let mid=Math.ceil((l+h)/2)
58 |     if(mid*mid>x)h=mid-1
59 |     else l=mid
60 |   }
61 |   return l
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/1-100/7.md:
--------------------------------------------------------------------------------
 1 | ### 7. 整数反转
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给出一个 32 位的有符号整数，你需要将这个整数中每位上的数字进行反转。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 123
17 | 输出: 321
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: -123
27 | 输出: -321
28 | ```
29 | 
30 | 
31 | **示例 3:** 
32 | 
33 | 
34 | 
35 | ```
36 | 输入: 120
37 | 输出: 21
38 | ```
39 | 
40 | 
41 | **注意:** 
42 | 
43 | 
44 | 
45 | 假设我们的环境只能存储得下 32 位的有符号整数，则其数值范围为[&minus;231, 231&minus; 1]。请根据这个假设，如果反转后整数溢出那么就返回 0。
46 | 
47 | 
48 | 
49 | 
50 | -----
51 | 
52 | 思路：
53 | 
54 | 使用字符串在反转并不是最好的选择，因为还需要处理负号和`0`的情况，用数字运算方式反转比较适合。
55 | 
56 | 每次找到当前数的最后一位，然后作为反转数字的第一位，例如`123`：
57 | 
58 | ```
59 | 123 --> 0*10  + 3
60 | 12  --> 3*10  + 2
61 | 1   --> 32*10 + 1
62 | ```
63 | 
64 | 再注意保存开始的正负状态和结果的限制`[−2^31,  2^31 − 1]`。
65 | 
66 | ```
67 | /**
68 |  * @param {number} x
69 |  * @return {number}
70 |  */
71 | var reverse = function(x) {
72 |   let symbol=x<0 ? -1 : 1
73 |   x=Math.abs(x)
74 |   let res=0
75 |   while(x>0){
76 |     let t=x%10
77 |     res=res*10+t
78 |     x=Math.floor(x/10)
79 |   }
80 |   res*=symbol
81 |   if(res<-Math.pow(2,31) || res>Math.pow(2,31)-1)return 0
82 |   return res
83 | };
84 | ```
85 | 
86 | 


--------------------------------------------------------------------------------
/1-100/70.md:
--------------------------------------------------------------------------------
 1 | ### 70. 爬楼梯
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 假设你正在爬楼梯。需要 *n* 阶你才能到达楼顶。
 8 | 
 9 | 
10 | 
11 | 每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
12 | 
13 | 
14 | 
15 | **注意：** 给定 *n*  是一个正整数。
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入： 2
25 | 输出： 2
26 | 解释： 有两种方法可以爬到楼顶。
27 | 1.  1 阶 + 1 阶
28 | 2.  2 阶
29 | ```
30 | 
31 | 
32 | **示例 2：** 
33 | 
34 | 
35 | 
36 | ```
37 | 输入： 3
38 | 输出： 3
39 | 解释： 有三种方法可以爬到楼顶。
40 | 1.  1 阶 + 1 阶 + 1 阶
41 | 2.  1 阶 + 2 阶
42 | 3.  2 阶 + 1 阶
43 | ```
44 | 
45 | 
46 | 
47 | -----
48 | 
49 | 思路：
50 | 
51 | `DP`，`dp[i]`表示当前楼梯有几种走法，`dp[i]=dp[i-1]+dp[i-2]`。
52 | 
53 | ```
54 | /**
55 |  * @param {number} n
56 |  * @return {number}
57 |  */
58 | var climbStairs = function(n) {
59 |   // let mem=[]
60 |   // function getSteps(n){
61 |   //     if(mem[n])return mem[n]
62 |   //     if(n===1)return 1
63 |   //     if(n===2)return 2
64 |   //     let steps=getSteps(n-1)+getSteps(n-2)
65 |   //     mem[n]=steps
66 |   //     return steps
67 |   // }
68 |   // return getSteps(n)
69 |   let dp=Array(n).fill(0)
70 |   dp[0]=1
71 |   dp[1]=2
72 |   for(let i=2;i<n;i++){
73 |     dp[i]=dp[i-1]+dp[i-2]
74 |   }
75 |   return dp[n-1]
76 | };
77 | ```
78 | 
79 | 


--------------------------------------------------------------------------------
/1-100/77.md:
--------------------------------------------------------------------------------
 1 | ### 77. 组合
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`回溯算法`
 6 | 
 7 | 给定两个整数 *n*  和 *k* ，返回 1 ... *n* 中所有可能的 *k*  个数的组合。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:n = 4, k = 2
17 | 输出:
18 | [
19 |   [2,4],
20 |   [3,4],
21 |   [2,3],
22 |   [1,2],
23 |   [1,3],
24 |   [1,4],
25 | ]
26 | ```
27 | 
28 | 
29 | 
30 | -----
31 | 
32 | 思路：
33 | 
34 | 这道题有一个特点就是每个数之和它后面的数组合，例如`[1,2,3,4]`，组合成4个数的，只存在`[1,2,3,4]`,不会出现`[3,2,1,4]`之类的。
35 | 
36 | 因此可以跟踪一个变量`start`，维护每次开始的索引位置，当长度打到`k`后，停止并且保存到结果。
37 | 
38 | ```
39 | /**
40 |  * @param {number} n
41 |  * @param {number} k
42 |  * @return {number[][]}
43 |  */
44 | var combine = function(n, k) {
45 |   let res=[]
46 |   function backtrack(start,arr){
47 |     if(arr.length===k){
48 |       return res.push(arr.slice())
49 |     }
50 |     for(let i=start;i<=n;i++){
51 |       arr.push(i)
52 |       backtrack(i+1,arr)
53 |       arr.pop()
54 |     }
55 |   }
56 |   backtrack(1,[])
57 |   return res
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/1-100/78.md:
--------------------------------------------------------------------------------
 1 | ### 78. 子集
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`、`数组`、`回溯算法`
 6 | 
 7 | 给定一组**不含重复元素** 的整数数组*nums* ，返回该数组所有可能的子集（幂集）。
 8 | 
 9 | 
10 | 
11 | **说明：** 解集不能包含重复的子集。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: nums = [1,2,3]
21 | 输出:
22 | [
23 |   [3],
24 |  [1],
25 |  [2],
26 |  [1,2,3],
27 |  [1,3],
28 |  [2,3],
29 |  [1,2],
30 |  []
31 | ]
32 | ```
33 | 
34 | 
35 | 
36 | -----
37 | 
38 | 思路：
39 | 
40 | `回溯`，由于都是独立的数字，因此只需要每次递归时索引`+1`。
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @return {number[][]}
46 |  */
47 | var subsets = function(nums) {
48 |   let result=[]
49 |   backtrack(0,[])
50 |   return result
51 | 
52 |   function backtrack(start,temp){
53 |     result.push(temp.slice())
54 |     for(let i=start;i<nums.length;i++){
55 |       temp.push(nums[i])
56 |       backtrack(i+1,temp)
57 |       temp.pop()
58 |     }
59 |   }
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/1-100/83.md:
--------------------------------------------------------------------------------
 1 | ### 83. 删除排序链表中的重复元素
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`链表`
 6 | 
 7 | 给定一个排序链表，删除所有重复的元素，使得每个元素只出现一次。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 1->1->2
17 | 输出: 1->2
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: 1->1->2->3->3
27 | 输出: 1->2->3
28 | ```
29 | 
30 | 
31 | 
32 | -----
33 | 
34 | 思路：
35 | 
36 | 只要每次遍历节点时检查下一个节点的`val`和当前节点的`val`是否相等，相等则将`node.next`连接到下一个节点的`next`上(架空下一个节点)。
37 | 
38 | ```
39 | /**
40 |  * Definition for singly-linked list.
41 |  * function ListNode(val) {
42 |  *     this.val = val;
43 |  *     this.next = null;
44 |  * }
45 |  */
46 | /**
47 |  * @param {ListNode} head
48 |  * @return {ListNode}
49 |  */
50 | var deleteDuplicates = function(head) {
51 |   if(!head)return head
52 |   let node=head
53 |   while(node && node.next){
54 |     if(node.next.val===node.val){
55 |       node.next=node.next.next
56 |     }else{
57 |       node=node.next
58 |     }
59 |   }
60 |   return head
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/1-100/86.md:
--------------------------------------------------------------------------------
 1 | ### 86. 分隔链表
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`链表`、`双指针`
 6 | 
 7 | 给定一个链表和一个特定值*x* ，对链表进行分隔，使得所有小于 *x*  的节点都在大于或等于 *x*  的节点之前。
 8 | 
 9 | 
10 | 
11 | 你应当保留两个分区中每个节点的初始相对位置。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: head = 1->4->3->2->5->2, x = 3
21 | 输出: 1->2->2->4->3->5
22 | ```
23 | 
24 | 
25 | 
26 | -----
27 | 
28 | 思路：
29 | 
30 | 建立一个链表头`less`和链表头`greater`，遍历链表`head`，如果`head.val<x`，放入`less`中，如果`head.val>=x`放入`greater`中。
31 | 
32 | 最后合并`less`和`greater`。
33 | 
34 | ```
35 | /**
36 |  * Definition for singly-linked list.
37 |  * function ListNode(val) {
38 |  *     this.val = val;
39 |  *     this.next = null;
40 |  * }
41 |  */
42 | /**
43 |  * @param {ListNode} head
44 |  * @param {number} x
45 |  * @return {ListNode}
46 |  */
47 | var partition = function(head, x) {
48 |   let node=new ListNode(0),less=node,
49 |       node2=new ListNode(0),greater=node2
50 |   while(head){
51 |     if(head.val<x){
52 |       less.next=head
53 |       less=less.next
54 |     }else{
55 |       greater.next=head
56 |       greater=greater.next
57 |     }
58 |     head=head.next
59 |   }
60 |   less.next=node2.next
61 |   greater.next=null
62 |   return node.next
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/1-100/9.md:
--------------------------------------------------------------------------------
 1 | ### 9. 回文数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 判断一个整数是否是回文数。回文数是指正序（从左向右）和倒序（从右向左）读都是一样的整数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 121
17 | 输出: true
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: -121
27 | 输出: false
28 | 解释: 从左向右读, 为 -121 。 从右向左读, 为 121- 。因此它不是一个回文数。
29 | ```
30 | 
31 | 
32 | **示例 3:** 
33 | 
34 | 
35 | 
36 | ```
37 | 输入: 10
38 | 输出: false
39 | 解释: 从右向左读, 为 01 。因此它不是一个回文数。
40 | ```
41 | 
42 | 
43 | **进阶:** 
44 | 
45 | 
46 | 
47 | 你能不将整数转为字符串来解决这个问题吗？
48 | 
49 | 
50 | 
51 | 
52 | -----
53 | 
54 | 思路：
55 | 
56 | 使用字符串就是判断回文字符串，很简单。
57 | 
58 | 而不是用字符串就是`NO.7`，反转一个数字，然后比较它们是否相等；
59 | 
60 | 注意：如果遇到负数直接返回`false`。
61 | 
62 | ```
63 | /**
64 |  * @param {number} x
65 |  * @return {boolean}
66 |  */
67 | var isPalindrome = function(x) {
68 |   if(x<0)return false
69 |   let n=x
70 |   let rev=0
71 |   while(n>0){
72 |     let t=n%10
73 |     rev=rev*10+t
74 |     n=~~(n/10)
75 |   }
76 |   return rev===x
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/1-100/90.md:
--------------------------------------------------------------------------------
 1 | ### 90. 子集 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`回溯算法`
 6 | 
 7 | 给定一个可能包含重复元素的整数数组 ***nums*** ，返回该数组所有可能的子集（幂集）。
 8 | 
 9 | 
10 | 
11 | **说明：** 解集不能包含重复的子集。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: [1,2,2]
21 | 输出:
22 | [
23 |   [2],
24 |   [1],
25 |   [1,2,2],
26 |   [2,2],
27 |   [1,2],
28 |   []
29 | ]
30 | ```
31 | 
32 | 
33 | 
34 | -----
35 | 
36 | 思路：
37 | 
38 | 由于输入含有重复值，因此需要排序并且通过`if(i>start && nums[i]===nums[i-1])continue)`去重。
39 | 
40 | ```
41 | /**
42 |  * @param {number[]} nums
43 |  * @return {number[][]}
44 |  */
45 | var subsetsWithDup = function(nums) {
46 |   let result=[],temp=[]
47 |   nums.sort()
48 |   backtrack(result,0,temp,nums)
49 |   return result
50 |   function backtrack(result,start,temp,nums){
51 |     result.push(temp.slice())
52 |     for(let i=start;i<nums.length;i++){
53 |       if(i>start && nums[i]===nums[i-1])continue
54 |       temp.push(nums[i])
55 |       backtrack(result,i+1,temp,nums)
56 |       temp.pop()
57 |     }
58 |   }
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/1-100/93.md:
--------------------------------------------------------------------------------
 1 | ### 93. 复原IP地址
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`、`回溯算法`
 6 | 
 7 | 给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: "25525511135"
17 | 输出: ["255.255.11.135", "255.255.111.35"]
18 | ```
19 | 
20 | 
21 | 
22 | -----
23 | 
24 | 思路：
25 | 
26 | `回溯`，注意几个规则：
27 | 
28 | 1. 变量`cur`表示当前值，如果这个值`>255`，不成立，同时，如果这个值存在`前导0`，同样不成立。
29 | 
30 | 2. 变量`remain`表示还剩下的`IP`值(初始为`4`)。
31 | 
32 | 3. 变量`str`表示还剩下的字符串，如果`str.length>remain*3`，不成立，因为每一个`IP`数值不可能超过`3`位。
33 | 
34 | ```
35 | /**
36 |  * @param {string} s
37 |  * @return {string[]}
38 |  */
39 | var restoreIpAddresses = function(s) {
40 |   let result=[]
41 |   function backtrack(str,remain,cur,res){
42 |     if(str.length>remain*3)return
43 |     if(+cur>255 || (cur.length>1 && cur[0]==="0"))return
44 |     if(remain===0)return result.push(res.substring(1))
45 |     for(let i=1;i<=3;i++){
46 |       if(str.length<i)continue
47 |       let cur=str.substring(0,i)
48 |       backtrack(str.substring(i),remain-1,cur,res+'.'+cur)
49 |     }
50 |   }
51 |   backtrack(s,4,'','')
52 |   return result
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/1-100/96.md:
--------------------------------------------------------------------------------
 1 | ### 96. 不同的二叉搜索树
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`树`、`动态规划`
 6 | 
 7 | 给定一个整数 *n* ，求以1 ...*n* 为节点组成的二叉搜索树有多少种？
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 3
17 | 输出: 5
18 | 解释:给定 n = 3, 一共有 5 种不同结构的二叉搜索树:
19 | 
20 |    1         3     3      2      1
21 |     \       /     /      / \      \
22 |      3     2     1      1   3      2
23 |     /     /       \                 \
24 |    2     1         2                 3
25 | ```
26 | 
27 | 
28 | 
29 | -----
30 | 
31 | 思路：
32 | 
33 | 与`NO.95`不同在于，这题不需要找出划分后具体的树，只需要保留结果，因此使用`DP`。
34 | 
35 | `dp[i]`表示从数量为`i`有多少种划分，初始`dp[0]=1`，即`root`为`null`就是1种划分。
36 | 
37 | `dp[i]=dp[j]*dp[i-j-1]`，`j`的范围为`0<=j<i`，其中`j`表示左子树的数量，`i-j-1`表示右子树的数量。
38 | 
39 | ```
40 | /**
41 |  * @param {number} n
42 |  * @return {number}
43 |  */
44 | var numTrees = function(n) {
45 |   let dp=Array(n+1).fill(0)
46 |   dp[0]=1
47 |   for(let i=1;i<=n;i++){
48 |     for(let j=0;j<i;j++){
49 |       dp[i]+=dp[j]*dp[i-j-1]
50 |     }
51 |   }
52 |   return dp[n]
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/1001-1100/1009.md:
--------------------------------------------------------------------------------
 1 | ### 1009. 十进制整数的反码
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 每个非负整数 `N` 都有其二进制表示。例如， `5` 可以被表示为二进制 `"101"` ， `11`  可以用二进制 `"1011"` 表示，依此类推。注意，除 `N = 0` 外，任何二进制表示中都不含前导零。
 8 | 
 9 | 
10 | 
11 | 二进制的反码表示是将每个 `1` 改为 `0` 且每个 `0` 变为 `1` 。例如，二进制数 `"101"` 的二进制反码为 `"010"` 。
12 | 
13 | 
14 | 
15 | 给定十进制数 `N` ，返回其二进制表示的反码所对应的十进制整数。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | 
28 | **示例 1：** 
29 | 
30 | 
31 | 
32 | ```
33 | 输入：5
34 | 输出：2
35 | 解释：5 的二进制表示为 "101"，其二进制反码为 "010"，也就是十进制中的 2 。
36 | ```
37 | 
38 | 
39 | **示例 2：** 
40 | 
41 | 
42 | 
43 | ```
44 | 输入：7
45 | 输出：0
46 | 解释：7 的二进制表示为 "111"，其二进制反码为 "000"，也就是十进制中的 0 。
47 | ```
48 | 
49 | 
50 | **示例 3：** 
51 | 
52 | 
53 | 
54 | ```
55 | 输入：10
56 | 输出：5
57 | 解释：10 的二进制表示为 "1010"，其二进制反码为 "0101"，也就是十进制中的 5 。
58 | ```
59 | 
60 | 
61 | 
62 | 
63 | 
64 | 
65 | **提示：** 
66 | 
67 | 
68 | 
69 | 
70 | 1.  `0 <= N < 10^9` 
71 | 
72 | 
73 | 
74 | 
75 | ```
76 | /**
77 |  * @param {number} N
78 |  * @return {number}
79 |  */
80 | var bitwiseComplement = function(N) {
81 |   let str=N.toString(2)
82 |   let len=str.length
83 |   let candi=Math.pow(2,len)-1
84 |   return N^candi
85 | };
86 | ```
87 | 
88 | 


--------------------------------------------------------------------------------
/1001-1100/1014.md:
--------------------------------------------------------------------------------
 1 | ### 1014. 最佳观光组合
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定正整数数组 `A` ， `A[i]` 表示第  `i`  个观光景点的评分，并且两个景点 `i`  和 `j` 之间的距离为 `j - i` 。
 8 | 
 9 | 
10 | 
11 | 一对景点（ `i < j` ）组成的观光组合的得分为（ `A[i] + A[j] + i- j` ）：景点的评分之和**减去** 它们两者之间的距离。
12 | 
13 | 
14 | 
15 | 返回一对观光景点能取得的最高分。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | **示例：** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入：[8,1,5,2,6]
29 | 输出：11
30 | 解释：i = 0, j = 2, A[i] + A[j] + i - j = 8 + 5 + 0 - 2 = 11
31 | ```
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | **提示：** 
39 | 
40 | 
41 | 
42 | 
43 | 1.  `2 <= A.length <= 50000` 
44 | 
45 | 2.  `1 <= A[i] <= 1000` 
46 | 
47 | 
48 | 
49 | 
50 | ```
51 | /**
52 |  * @param {number[]} A
53 |  * @return {number}
54 |  */
55 | var maxScoreSightseeingPair = function(A) {
56 |   let cur = 0;
57 |   let dp=Array(A.length).fill(0)
58 |   for(let i = 1; i < A.length; ++i)
59 |     dp[i] = Math.max(dp[i-1]-1, A[i-1]-1);
60 |   for(let i = 1; i < A.length; ++i)
61 |     cur = Math.max(cur, dp[i]+A[i]);
62 |   return cur;
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/1001-1100/1015.md:
--------------------------------------------------------------------------------
 1 | ### 1015. 可被 K 整除的最小整数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定正整数 `K` ，你需要找出可以被 K 整除的、仅包含数字 **1**  的最小正整数 N。
 8 | 
 9 | 
10 | 
11 | 返回 `N` 的长度。如果不存在这样的 `N` ，就返回  `-1` 。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：1
25 | 输出：1
26 | 解释：最小的答案是 N = 1，其长度为 1。
27 | ```
28 | 
29 | 
30 | **示例 2：** 
31 | 
32 | 
33 | 
34 | ```
35 | 输入：2
36 | 输出：-1
37 | 解释：不存在可被 2 整除的正整数 N 。
38 | ```
39 | 
40 | 
41 | **示例 3：** 
42 | 
43 | 
44 | 
45 | ```
46 | 输入：3
47 | 输出：3
48 | 解释：最小的答案是 N = 111，其长度为 3。
49 | ```
50 | 
51 | 
52 | 
53 | 
54 | 
55 | 
56 | **提示：** 
57 | 
58 | 
59 | 
60 | 
61 | * `1 <= K <= 10^5`
62 | 
63 | 
64 | 
65 | 
66 | ```
67 | /**
68 |  * @param {number} K
69 |  * @return {number}
70 |  */
71 | var smallestRepunitDivByK = function(K) {
72 |   if(K % 5===0 || K % 2===0)return -1
73 |   let count=1,used={}
74 |   let mod=1 % K
75 |   while(mod!==0){
76 |     if(used[mod])return -1
77 |     used[mod]=true
78 |     mod=(mod*10+1)% K
79 |     count++
80 |   }
81 |   return count
82 | };
83 | ```
84 | 
85 | 


--------------------------------------------------------------------------------
/1001-1100/1016.md:
--------------------------------------------------------------------------------
 1 | ### 1016. 子串能表示从 1 到 N 数字的二进制串
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个二进制字符串 `S` （一个仅由若干'0' 和 '1' 构成的字符串）和一个正整数 `N` ，如果对于从  `1`  到  `N`  的每个整数  `X` ，其二进制表示都是 `S`  的子串，就返回  `true` ，否则返回  `false` 。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | **示例 1：** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入：S = "0110", N = 3
21 | 输出：true
22 | ```
23 | 
24 | 
25 | **示例 2：** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入：S = "0110", N = 4
31 | 输出：false
32 | ```
33 | 
34 | 
35 | 
36 | 
37 | 
38 | 
39 | **提示：** 
40 | 
41 | 
42 | 
43 | 
44 | 1.  `1 <= S.length <= 1000` 
45 | 
46 | 2.  `1 <= N <= 10^9` 
47 | 
48 | 
49 | 
50 | 
51 | ```
52 | /**
53 |  * @param {string} S
54 |  * @param {number} N
55 |  * @return {boolean}
56 |  */
57 | var queryString = function(S, N) {
58 |   for(let i=1;i<=N;i++){
59 |       let x=i.toString(2)
60 |       if(!S.includes(x)){
61 |           return false;
62 |       }
63 |   }
64 |   return true;
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/1001-1100/1037.md:
--------------------------------------------------------------------------------
 1 | ### 1037. 有效的回旋镖
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 回旋镖定义为一组三个点，这些点各不相同且**不** 在一条直线上。
 8 | 
 9 | 
10 | 
11 | 给出平面上三个点组成的列表，判断这些点是否可以构成回旋镖。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：[[1,1],[2,3],[3,2]]
25 | 输出：true
26 | ```
27 | 
28 | 
29 | **示例 2：** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入：[[1,1],[2,2],[3,3]]
35 | 输出：false
36 | ```
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | **提示：** 
44 | 
45 | 
46 | 
47 | 
48 | 1.  `points.length == 3` 
49 | 
50 | 2.  `points[i].length == 2` 
51 | 
52 | 3.  `0 <= points[i][j] <= 100` 
53 | 
54 | 
55 | 
56 | 
57 | ```
58 | /**
59 |  * @param {number[][]} points
60 |  * @return {boolean}
61 |  */
62 | var isBoomerang = function(points) {
63 |   function isSameLine(p1,p2,p3){
64 |     if(p1[1]-p2[1]===0 && p2[1]-p3[1]===0)return true
65 |     let s1=(p1[0]-p2[0])/(p1[1]-p2[1]),
66 |         s2=(p2[0]-p3[0])/(p2[1]-p3[1])
67 |     if(s1===s2)return true
68 |     return false
69 |   }
70 |   function isSame(p1,p2){
71 |     return (p1[0]===p2[0] && p1[1]===p2[1])
72 |   }
73 |   return !isSame(points[0],points[1]) && 
74 |          !isSame(points[1],points[2]) && 
75 |          !isSameLine(points[0],points[1],points[2])
76 | };
77 | ```
78 | 
79 | 


--------------------------------------------------------------------------------
/1001-1100/1047.md:
--------------------------------------------------------------------------------
 1 | ### 1047. 删除字符串中的所有相邻重复项
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给出由小写字母组成的字符串 `S` ，**重复项删除操作** 会选择两个相邻且相同的字母，并删除它们。
 8 | 
 9 | 
10 | 
11 | 在 S 上反复执行重复项删除操作，直到无法继续删除。
12 | 
13 | 
14 | 
15 | 在完成所有重复项删除操作后返回最终的字符串。答案保证唯一。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | **示例：** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入："abbaca"
29 | 输出："ca"
30 | 解释：
31 | 例如，在 "abbaca" 中，我们可以删除 "bb" 由于两字母相邻且相同，这是此时唯一可以执行删除操作的重复项。之后我们得到字符串 "aaca"，其中又只有 "aa" 可以执行重复项删除操作，所以最后的字符串为 "ca"。
32 | ```
33 | 
34 | 
35 | 
36 | 
37 | 
38 | 
39 | **提示：** 
40 | 
41 | 
42 | 
43 | 
44 | 1.  `1 <= S.length <= 20000` 
45 | 
46 | 2.  `S`  仅由小写英文字母组成。
47 | 
48 | 
49 | 
50 | 
51 | ```
52 | /**
53 |  * @param {string} S
54 |  * @return {string}
55 |  */
56 | var removeDuplicates = function(S) {
57 |   let stack=[S[0]],i=1
58 |   while(i<S.length){
59 |     while(i<S.length && stack.length>0 && S[i]===stack[stack.length-1]){
60 |       stack.pop()
61 |       i++
62 |     }
63 |     stack.push(S[i++])
64 |   }
65 |   return stack.join('')
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/101-200/103.md:
--------------------------------------------------------------------------------
 1 | ### 103. 二叉树的锯齿形层次遍历
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`栈`、`树`、`广度优先搜索`
 6 | 
 7 | 给定一个二叉树，返回其节点值的锯齿形层次遍历。（即先从左往右，再从右往左进行下一层遍历，以此类推，层与层之间交替进行）。
 8 | 
 9 | 
10 | 
11 | 例如：
12 | 给定二叉树 `[3,9,20,null,null,15,7]` ,
13 | 
14 | 
15 | 
16 | ```
17 |     3
18 |    / \
19 |   9  20
20 |     /  \
21 |    15   7
22 | ```
23 | 
24 | 
25 | 返回锯齿形层次遍历如下：
26 | 
27 | 
28 | 
29 | ```
30 | [
31 |   [3],
32 |   [20,9],
33 |   [15,7]
34 | ]
35 | ```
36 | 
37 | ```
38 | /**
39 |  * Definition for a binary tree node.
40 |  * function TreeNode(val) {
41 |  *     this.val = val;
42 |  *     this.left = this.right = null;
43 |  * }
44 |  */
45 | /**
46 |  * @param {TreeNode} root
47 |  * @return {number[][]}
48 |  */
49 | var zigzagLevelOrder = function(root) {
50 |   if(!root)return []
51 |   let res=[]
52 |   let aux=[root]
53 |   let h=0
54 |   while(aux.length>0){
55 |     h++
56 |     let len=aux.length
57 |     let vals=[]
58 |     for(let i=0;i<len;i++){
59 |       let node=aux.shift()
60 |       if(h%2===1)vals.push(node.val)
61 |       else vals.unshift(node.val)
62 |       if(node.left)aux.push(node.left)
63 |       if(node.right)aux.push(node.right)
64 |     }
65 |     res.push(vals)
66 |   }
67 |   return res    
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/101-200/104.md:
--------------------------------------------------------------------------------
 1 | ### 104. 二叉树的最大深度
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`
 6 | 
 7 | 给定一个二叉树，找出其最大深度。
 8 | 
 9 | 
10 | 
11 | 二叉树的深度为根节点到最远叶子节点的最长路径上的节点数。
12 | 
13 | 
14 | 
15 | **说明:** 叶子节点是指没有子节点的节点。
16 | 
17 | 
18 | 
19 | **示例：** 
20 | 给定二叉树  `[3,9,20,null,null,15,7]` ，
21 | 
22 | 
23 | 
24 | ```
25 |     3
26 |    / \
27 |   9  20
28 |     /  \
29 |    15   7
30 | ```
31 | 
32 | 
33 | 返回它的最大深度3 。
34 | 
35 | 
36 | ```
37 | /**
38 |  * Definition for a binary tree node.
39 |  * function TreeNode(val) {
40 |  *     this.val = val;
41 |  *     this.left = this.right = null;
42 |  * }
43 |  */
44 | /**
45 |  * @param {TreeNode} root
46 |  * @return {number}
47 |  */
48 | var maxDepth = function(root) {
49 |   if(!root)return 0
50 |   return Math.max(maxDepth(root.left),maxDepth(root.right))+1
51 | };
52 | ```
53 | 
54 | 


--------------------------------------------------------------------------------
/101-200/107.md:
--------------------------------------------------------------------------------
 1 | ### 107. 二叉树的层次遍历 II
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`广度优先搜索`
 6 | 
 7 | 给定一个二叉树，返回其节点值自底向上的层次遍历。 （即按从叶子节点所在层到根节点所在的层，逐层从左向右遍历）
 8 | 
 9 | 
10 | 
11 | 例如：
12 | 给定二叉树  `[3,9,20,null,null,15,7]` ,
13 | 
14 | 
15 | 
16 | ```
17 |     3
18 |    / \
19 |   9  20
20 |     /  \
21 |    15   7
22 | ```
23 | 
24 | 
25 | 返回其自底向上的层次遍历为：
26 | 
27 | 
28 | 
29 | ```
30 | [
31 |   [15,7],
32 |   [9,20],
33 |   [3]
34 | ]
35 | ```
36 | 
37 | 
38 | 
39 | -----
40 | 
41 | 思路：
42 | 
43 | 除了最后结果倒序，与`NO.102`完全一致。
44 | 
45 | ```
46 | /**
47 |  * Definition for a binary tree node.
48 |  * function TreeNode(val) {
49 |  *     this.val = val;
50 |  *     this.left = this.right = null;
51 |  * }
52 |  */
53 | /**
54 |  * @param {TreeNode} root
55 |  * @return {number[][]}
56 |  */
57 | var levelOrderBottom = function(root) { 
58 |   let res=[]
59 |   function dfs(root,level){
60 |     if(!root)return
61 |     if(level===res.length){
62 |       res.push([])
63 |     }
64 |     res[level].push(root.val)
65 |     if(root.left)dfs(root.left,level+1)
66 |     if(root.right)dfs(root.right,level+1)
67 |   }
68 |   dfs(root,0)
69 |   return res.reverse()
70 | };
71 | ```
72 | 
73 | 


--------------------------------------------------------------------------------
/101-200/108.md:
--------------------------------------------------------------------------------
 1 | ### 108. 将有序数组转换为二叉搜索树
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`
 6 | 
 7 | 将一个按照升序排列的有序数组，转换为一棵高度平衡二叉搜索树。
 8 | 
 9 | 
10 | 
11 | 本题中，一个高度平衡二叉树是指一个二叉树*每个节点* 的左右两个子树的高度差的绝对值不超过 1。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 给定有序数组: [-10,-3,0,5,9],
21 | 
22 | 一个可能的答案是：[0,-3,9,-10,null,5]，它可以表示下面这个高度平衡二叉搜索树：
23 | 
24 |       0
25 |      / \
26 |    -3   9
27 |    /   /
28 |  -10  5
29 | ```
30 | 
31 | ```
32 | /**
33 |  * Definition for a binary tree node.
34 |  * function TreeNode(val) {
35 |  *     this.val = val;
36 |  *     this.left = this.right = null;
37 |  * }
38 |  */
39 | /**
40 |  * @param {number[]} nums
41 |  * @return {TreeNode}
42 |  */
43 | var sortedArrayToBST = function(nums) {
44 |   function createBalance(start,end){
45 |     if(start>end)return null
46 |     let mid=Math.floor((start+end)/2) 
47 |     let root=new TreeNode(nums[mid])
48 |     root.left=createBalance(start,mid-1)
49 |     root.right=createBalance(mid+1,end)
50 |     return root
51 |   }
52 |   return createBalance(0,nums.length-1)
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/101-200/111.md:
--------------------------------------------------------------------------------
 1 | ### 111. 二叉树的最小深度
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`、`广度优先搜索`
 6 | 
 7 | 给定一个二叉树，找出其最小深度。
 8 | 
 9 | 
10 | 
11 | 最小深度是从根节点到最近叶子节点的最短路径上的节点数量。
12 | 
13 | 
14 | 
15 | **说明:** 叶子节点是指没有子节点的节点。
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | 给定二叉树 `[3,9,20,null,null,15,7]` ,
24 | 
25 | 
26 | 
27 | ```
28 |     3
29 |    / \
30 |   9  20
31 |     /  \
32 |    15   7
33 | ```
34 | 
35 | 
36 | 返回它的最小深度 2.
37 | 
38 | 
39 | 
40 | 
41 | -----
42 | 
43 | 思路：
44 | 
45 | 必须是`root`到`leaf`的最小高度，如果当前节点是`leaf`，返回`1`；否则：
46 | 
47 | 当前节点存在2个子节点，那么返回`min(leftH,rightH)+1`；
48 | 
49 | 当前节点只有1个子节点，那么只能返回`存在的子节点的高度+1`。
50 | 
51 | ```
52 | /**
53 |  * Definition for a binary tree node.
54 |  * function TreeNode(val) {
55 |  *     this.val = val;
56 |  *     this.left = this.right = null;
57 |  * }
58 |  */
59 | /**
60 |  * @param {TreeNode} root
61 |  * @return {number}
62 |  */
63 | var minDepth = function(root) {
64 |   if(!root)return 0
65 |   let leftH=minDepth(root.left),
66 |       rightH=minDepth(root.right)
67 |   if(root.left && root.right){
68 |     return Math.min(leftH,rightH)+1
69 |   }else if(!root.left){
70 |     return rightH+1
71 |   }else if(!root.right){
72 |     return leftH+1
73 |   }
74 | };
75 | ```
76 | 
77 | 


--------------------------------------------------------------------------------
/101-200/112.md:
--------------------------------------------------------------------------------
 1 | ### 112. 路径总和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`
 6 | 
 7 | 给定一个二叉树和一个目标和，判断该树中是否存在根节点到叶子节点的路径，这条路径上所有节点值相加等于目标和。
 8 | 
 9 | 
10 | 
11 | **说明:** 叶子节点是指没有子节点的节点。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 给定如下二叉树，以及目标和  `sum = 22` ，
17 | 
18 | 
19 | 
20 | ```
21 |               5
22 |              / \
23 |             4  8
24 |            /   / \
25 |           11 13  4
26 |          /  \      \
27 |         7    2      1
28 | ```
29 | 
30 | 
31 | 返回  `true` , 因为存在目标和为 22 的根节点到叶子节点的路径  `5->4->11->2` 。
32 | 
33 | 
34 | ```
35 | /**
36 |  * Definition for a binary tree node.
37 |  * function TreeNode(val) {
38 |  *     this.val = val;
39 |  *     this.left = this.right = null;
40 |  * }
41 |  */
42 | /**
43 |  * @param {TreeNode} root
44 |  * @param {number} sum
45 |  * @return {boolean}
46 |  */
47 | var hasPathSum = function(root, sum) {
48 |   if(!root)return false
49 |   let s=sum-root.val
50 |   if(s===0 && !root.left && !root.right)return true
51 |   return hasPathSum(root.left,s) || hasPathSum(root.right,s)
52 | };
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------
/101-200/118.md:
--------------------------------------------------------------------------------
 1 | ### 118. 杨辉三角
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个非负整数*numRows，* 生成杨辉三角的前*numRows* 行。
 8 | 
 9 | 
10 | 
11 | ![](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
12 | 
13 | 
14 | 
15 | 
16 | 在杨辉三角中，每个数是它左上方和右上方的数的和。
17 | 
18 | 
19 | 
20 | **示例:** 
21 | 
22 | 
23 | 
24 | ```
25 | 输入: 5
26 | 输出:
27 | [
28 |      [1],
29 |     [1,1],
30 |    [1,2,1],
31 |   [1,3,3,1],
32 |  [1,4,6,4,1]
33 | ]
34 | ```
35 | 
36 | 
37 | 
38 | -----
39 | 
40 | 思路：
41 | 
42 | 要求输出整个三角形，使用`temp`保留上一层的数组，通过`temp`计算当前层。
43 | 
44 | ```
45 | /**
46 |  * @param {number} numRows
47 |  * @return {number[][]}
48 |  */
49 | var generate = function(numRows) {
50 |   let temp=[]
51 |   let result=[]
52 |   for(let i=0;i<numRows;i++){
53 |     result[i]=Array(temp.length+1).fill(1)
54 |     for(let j=1;j<result[i].length-1;j++){
55 |       result[i][j]=temp[j-1]+temp[j]
56 |     }
57 |     temp=result[i]
58 |   }
59 |   return result
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/101-200/119.md:
--------------------------------------------------------------------------------
 1 | ### 119. 杨辉三角 II
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个非负索引*k* ，其中 *k* &le;33，返回杨辉三角的第 *k* 行。
 8 | 
 9 | 
10 | 
11 | ![](https://upload.wikimedia.org/wikipedia/commons/0/0d/PascalTriangleAnimated2.gif)
12 | 
13 | 
14 | 
15 | 
16 | 在杨辉三角中，每个数是它左上方和右上方的数的和。
17 | 
18 | 
19 | 
20 | **示例:** 
21 | 
22 | 
23 | 
24 | ```
25 | 输入: 3
26 | 输出: [1,3,3,1]
27 | ```
28 | 
29 | 
30 | **进阶：** 
31 | 
32 | 
33 | 
34 | 你可以优化你的算法到 *O* (*k* ) 空间复杂度吗？
35 | 
36 | 
37 | 
38 | 
39 | -----
40 | 
41 | 思路：
42 | 
43 | 空间`O(N)`，对于上一层`A`，倒序计算出当前层的值。
44 | 
45 | ```
46 | /**
47 |  * @param {number} rowIndex
48 |  * @return {number[]}
49 |  */
50 | var getRow = function(rowIndex) {
51 |   let A=[]
52 |   A[0] = 1;
53 |   for(let i=1; i<rowIndex+1; i++)
54 |     for(let j=i; j>=1; j--)
55 |       A[j] =(A[j]||0)+ (A[j-1] || 0);
56 |   return A;
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/101-200/121.md:
--------------------------------------------------------------------------------
 1 | ### 121. 买卖股票的最佳时机
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`动态规划`
 6 | 
 7 | 给定一个数组，它的第*i*  个元素是一支给定股票第 *i*  天的价格。
 8 | 
 9 | 
10 | 
11 | 如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
12 | 
13 | 
14 | 
15 | 注意你不能在买入股票前卖出股票。
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [7,1,5,3,6,4]
25 | 输出: 5
26 | 解释:在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。
27 |      注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。
28 | ```
29 | 
30 | 
31 | **示例 2:** 
32 | 
33 | 
34 | 
35 | ```
36 | 输入: [7,6,4,3,1]
37 | 输出: 0
38 | 解释:在这种情况下, 没有交易完成, 所以最大利润为 0。
39 | ```
40 | 
41 | 
42 | 
43 | -----
44 | 
45 | 思路：
46 | 
47 | 对于每一天，
48 | 
49 | 最大卖出收益为：
50 | 
51 | * 上一次买入的+当前卖出的
52 | * 当前不卖(即上一次卖出的)
53 | 
54 | 最大买入收益为：
55 | 
56 | * 上一次买入的
57 | * 购买今天的(`-prices[i]`)
58 | 
59 | 最后返回`sell`。
60 | 
61 | ```
62 | /**
63 |  * @param {number[]} prices
64 |  * @return {number}
65 |  */
66 | var maxProfit = function(prices) {
67 |   let sell=0,buy=-prices[0],rest=0
68 |   for(let i=0;i<prices.length;i++){
69 |     sell=Math.max(buy+prices[i],sell)
70 |     buy=Math.max(-prices[i],buy)
71 |   }
72 |   return sell
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/101-200/125.md:
--------------------------------------------------------------------------------
 1 | ### 125. 验证回文串
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`双指针`、`字符串`
 6 | 
 7 | 给定一个字符串，验证它是否是回文串，只考虑字母和数字字符，可以忽略字母的大小写。
 8 | 
 9 | 
10 | 
11 | **说明：** 本题中，我们将空字符串定义为有效的回文串。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: "A man, a plan, a canal: Panama"
21 | 输出: true
22 | ```
23 | 
24 | 
25 | **示例 2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: "race a car"
31 | 输出: false
32 | ```
33 | 
34 | ```
35 | /**
36 |  * @param {string} s
37 |  * @return {boolean}
38 |  */
39 | var isPalindrome = function(s) {
40 |   if(s==="")return true
41 |   s = s.toLowerCase().replace(/[^a-z0-9]/g, "");
42 | 
43 |   let l=0,r=s.length-1
44 |   while(l<r){
45 |     if(s[l]!==s[r])return false
46 |     l++;r--
47 |   }
48 |   return true
49 | };
50 | ```
51 | 
52 | 


--------------------------------------------------------------------------------
/101-200/128.md:
--------------------------------------------------------------------------------
 1 | ### 128. 最长连续序列
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`并查集`、`数组`
 6 | 
 7 | 给定一个未排序的整数数组，找出最长连续序列的长度。
 8 | 
 9 | 
10 | 
11 | 要求算法的时间复杂度为*O(n)* 。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:[100, 4, 200, 1, 3, 2]
21 | 输出: 4
22 | 解释: 最长连续序列是 [1, 2, 3, 4]。它的长度为 4。
23 | ```
24 | 
25 | 
26 | 
27 | -----
28 | 
29 | 思路：
30 | 
31 | 使用`hash`来保存每一个数字的连续长度，对于一个未访问过的数字`n`，它的连续长度就是`它左侧数字(n-1)的长度 + 它右侧数字(n+1)的长度 + 1`。
32 | 
33 | 并且保存当前长度，最后要更新它左侧和右侧的最新连续长度。
34 | 
35 | ```
36 | /**
37 |  * @param {number[]} nums
38 |  * @return {number}
39 |  */
40 | var longestConsecutive = function(nums) {
41 |   let hash={},max=0
42 |   for(let i=0;i<nums.length;i++){
43 |     let cur=nums[i]
44 |     if(hash[cur]!=null)continue
45 |     let left=hash[cur-1]?hash[cur-1]:0
46 |     let right=hash[cur+1]?hash[cur+1]:0
47 |     let sum=left+right+1
48 |     hash[cur]=sum
49 |     max=Math.max(max,sum)
50 |     hash[cur-left]=sum
51 |     hash[cur+right]=sum
52 |   }
53 |   return max
54 | };
55 | ```
56 | 
57 | 


--------------------------------------------------------------------------------
/101-200/131.md:
--------------------------------------------------------------------------------
 1 | ### 131. 分割回文串
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`回溯算法`
 6 | 
 7 | 给定一个字符串 *s* ，将*s* 分割成一些子串，使每个子串都是回文串。
 8 | 
 9 | 
10 | 
11 | 返回 *s*  所有可能的分割方案。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:"aab"
21 | 输出:
22 | [
23 |   ["aa","b"],
24 |   ["a","a","b"]
25 | ]
26 | ```
27 | 
28 | 
29 | 
30 | -----
31 | 
32 | 思路：
33 | 
34 | 回溯，`start`为从当前哪个索引开始，检测以`start`为开头的每一个子字符串，如果存在回文字符串，就添加到`arr`中，直到`start===s.length`，
35 | 说明当前`arr`为其中一个解，添加到结果`result`中。
36 | 
37 | ```
38 | /**
39 |  * @param {string} s
40 |  * @return {string[][]}
41 |  */
42 | var partition = function(s) {
43 |   let result=[]
44 |   backtrack([],0)
45 |   return result
46 |   
47 |   function isP(str){
48 |     for(let i=0;i<str.length/2;i++){
49 |       if(str[i]!==str[str.length-1-i])return false
50 |     }
51 |     return true
52 |   }
53 |   function backtrack(arr,start){
54 |     if(start===s.length) result.push(arr.slice())
55 |     for(let i=start;i<s.length;i++){
56 |       let str=s.substring(start,i+1)
57 |       if(isP(str)){
58 |         arr.push(str)
59 |         backtrack(arr,i+1)
60 |         arr.pop()
61 |       }
62 |     }
63 |   }
64 | };
65 | ```
66 | 
67 | 


--------------------------------------------------------------------------------
/101-200/132.md:
--------------------------------------------------------------------------------
 1 | ### 132. 分割回文串 II
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定一个字符串 *s* ，将 *s*  分割成一些子串，使每个子串都是回文串。
 8 | 
 9 | 
10 | 
11 | 返回符合要求的最少分割次数。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:"aab"
21 | 输出: 1
22 | 解释:进行一次分割就可将s分割成 ["aa","b"] 这样两个回文子串。
23 | ```
24 | 
25 | ```
26 | /**
27 |  * @param {string} s
28 |  * @return {number}
29 |  */
30 | var minCut = function(s) {
31 |   let N=s.length
32 |   let dp=Array(N+1).fill(0)
33 |   let palin=Array(N).fill().map(n=>Array(N).fill(false))
34 |   for(let i=0;i<N;i++) palin[i][i]=true
35 | 
36 |   dp[0]=-1
37 |   for(let i=2;i<dp.length;i++){
38 |     dp[i]=dp[i-1]+1
39 |     for(let j=1;j<i;j++){
40 |       if(s[i-1]===s[j-1]){
41 |         if(i-j<=1 || palin[j][i-2]){
42 |           dp[i]=Math.min(dp[i],dp[j-1]+1)
43 |           palin[j-1][i-1]=true
44 |         }
45 |       }
46 |     }
47 |   }
48 |   return dp[N]
49 | };
50 | ```
51 | 
52 | 


--------------------------------------------------------------------------------
/101-200/136.md:
--------------------------------------------------------------------------------
 1 | ### 136. 只出现一次的数字
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`哈希表`
 6 | 
 7 | 给定一个**非空** 整数数组，除了某个元素只出现一次以外，其余每个元素均出现两次。找出那个只出现了一次的元素。
 8 | 
 9 | 
10 | 
11 | **说明：** 
12 | 
13 | 
14 | 
15 | 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [2,2,1]
25 | 输出: 1
26 | ```
27 | 
28 | 
29 | **示例2:** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入: [4,1,2,1,2]
35 | 输出: 4
36 | ```
37 | 
38 | 
39 | 
40 | -----
41 | 
42 | 思路：
43 | 
44 | 一种名叫`消消乐`的符号`^`。
45 | 
46 | ```
47 | /**
48 |  * @param {number[]} nums
49 |  * @return {number}
50 |  */
51 | var singleNumber = function(nums) {
52 |   return nums.reduce((a,b)=>a^b)
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/101-200/137.md:
--------------------------------------------------------------------------------
 1 | ### 137. 只出现一次的数字 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定一个**非空** 整数数组，除了某个元素只出现一次以外，其余每个元素均出现了三次。找出那个只出现了一次的元素。
 8 | 
 9 | 
10 | 
11 | **说明：** 
12 | 
13 | 
14 | 
15 | 你的算法应该具有线性时间复杂度。 你可以不使用额外空间来实现吗？
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: [2,2,3,2]
25 | 输出: 3
26 | ```
27 | 
28 | 
29 | **示例2:** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入: [0,1,0,1,0,1,99]
35 | 输出: 99
36 | ```
37 | 
38 | 
39 | 
40 | -----
41 | 
42 | 思路：
43 | 
44 | 对于时间`O(n)`，空间`O(1)`的算法，需要编写一个状态机，当一个数出现`3`次，会抵消。
45 | 
46 | 如果单变量使用`^`，只能抵消偶数次数，如果要`3`次抵消，必须要有2个变量同时`^`。
47 | 
48 | `a=a^nums[i]`
49 | 
50 | `b=b^nums[i]`
51 | 
52 | 但仅仅这样两个变量完全一致，无法`3`次抵消。
53 | 
54 | 因此还需要使用`~`，`~`的作用是将`0`变为`1`，`1`变为`0`，同时也可以将当前状态逆转。
55 | 
56 | `a=(a^nums[i]) ~ b`
57 | 
58 | `b=(b^nums[i]) ~ a`
59 | 
60 | 例如一个数组`[2,2,2,2,2,2]`，它每次的`a`和`b`输出值为`2,0`，`0,2`，`0,0`，`2,0`，`0,2`，`0,0`，每`3`次置零。
61 | 
62 | ```
63 | /**
64 |  * @param {number[]} nums
65 |  * @return {number}
66 |  */
67 | var singleNumber = function(nums) {
68 |   let a=0,b=0
69 |   for(let n of nums){
70 |     a=(a^n) & ~b
71 |     b=(b^n) & ~a
72 |   }
73 |   return a
74 | };
75 | ```
76 | 
77 | 


--------------------------------------------------------------------------------
/101-200/144.md:
--------------------------------------------------------------------------------
 1 | ### 144. 二叉树的前序遍历
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`栈`、`树`
 6 | 
 7 | 给定一个二叉树，返回它的*前序* 遍历。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,null,2,3]  
17 |    1
18 |     \
19 |      2
20 |     /
21 |    3 
22 | 
23 | 输出: [1,2,3]
24 | ```
25 | 
26 | 
27 | **进阶:** 递归算法很简单，你可以通过迭代算法完成吗？
28 | 
29 | 
30 | ```
31 | /**
32 |  * Definition for a binary tree node.
33 |  * function TreeNode(val) {
34 |  *     this.val = val;
35 |  *     this.left = this.right = null;
36 |  * }
37 |  */
38 | /**
39 |  * @param {TreeNode} root
40 |  * @return {number[]}
41 |  */
42 | var preorderTraversal = function(root) {
43 |   let stack=[],res=[]
44 |   let node=root
45 |   while(stack.length>0 || node){
46 |     while(node){
47 |       res.push(node.val)
48 |       stack.push(node)
49 |       node=node.left
50 |     }
51 |     node=stack.pop()
52 |     node=node.right
53 |   }
54 |   return res
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/101-200/145.md:
--------------------------------------------------------------------------------
 1 | ### 145. 二叉树的后序遍历
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`栈`、`树`
 6 | 
 7 | 给定一个二叉树，返回它的 *后序* 遍历。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,null,2,3]  
17 |    1
18 |     \
19 |      2
20 |     /
21 |    3 
22 | 
23 | 输出: [3,2,1]
24 | ```
25 | 
26 | 
27 | **进阶:** 递归算法很简单，你可以通过迭代算法完成吗？
28 | 
29 | 
30 | ```
31 | /**
32 |  * Definition for a binary tree node.
33 |  * function TreeNode(val) {
34 |  *     this.val = val;
35 |  *     this.left = this.right = null;
36 |  * }
37 |  */
38 | /**
39 |  * @param {TreeNode} root
40 |  * @return {number[]}
41 |  */
42 | var postorderTraversal = function(root) {
43 |   let res=[],stack=[],node=root
44 |   while(stack.length>0 || node){
45 |     while(node){
46 |       res.push(node.val)
47 |       stack.push(node)
48 |       node=node.right
49 |     }
50 |     node=stack.pop()   
51 |     node=node.left
52 |   }
53 |   return res.reverse()
54 | };
55 | ```
56 | 
57 | 


--------------------------------------------------------------------------------
/101-200/151.md:
--------------------------------------------------------------------------------
 1 | ### 151. 翻转字符串里的单词
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个字符串，逐个翻转字符串中的每个单词。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | **示例 1：** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: "the sky is blue"
21 | 输出:"blue is sky the"
22 | ```
23 | 
24 | 
25 | **示例 2：** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: " hello world! "
31 | 输出:"world! hello"
32 | 解释:输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
33 | ```
34 | 
35 | 
36 | **示例 3：** 
37 | 
38 | 
39 | 
40 | ```
41 | 输入: "a good  example"
42 | 输出:"example good a"
43 | 解释:如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
44 | ```
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | **说明：** 
52 | 
53 | 
54 | 
55 | 
56 | * 无空格字符构成一个单词。
57 | 
58 | * 输入字符串可以在前面或者后面包含多余的空格，但是反转后的字符不能包括。
59 | 
60 | * 如果两个单词间有多余的空格，将反转后单词间的空格减少到只含一个。
61 | 
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 
69 | 
70 | **进阶：** 
71 | 
72 | 
73 | 
74 | 请选用 C 语言的用户尝试使用*O* (1) 额外空间复杂度的原地解法。
75 | 
76 | 
77 | ```
78 | /**
79 |  * @param {string} str
80 |  * @returns {string}
81 |  */
82 | var reverseWords = function(str) {
83 |   let newS=str.trim()
84 |   let sArr=newS.split(/\s+/)
85 |   sArr.reverse()
86 |   return sArr.join(' ')
87 | };
88 | ```
89 | 
90 | 


--------------------------------------------------------------------------------
/101-200/152.md:
--------------------------------------------------------------------------------
 1 | ### 152. 乘积最大子序列
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`动态规划`
 6 | 
 7 | 给定一个整数数组  `nums` ，找出一个序列中乘积最大的连续子序列（该序列至少包含一个数）。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [2,3,-2,4]
17 | 输出: 6
18 | 解释:子数组 [2,3] 有最大乘积 6。
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: [-2,0,-1]
28 | 输出: 0
29 | 解释:结果不能为 2, 因为 [-2,-1] 不是子数组。
30 | ```
31 | 
32 | ```
33 | /**
34 |  * @param {number[]} nums
35 |  * @return {number}
36 |  */
37 | var maxProduct = function(nums) {
38 |     let maxProd = nums[0];
39 |     let currentMax = maxProd;
40 |     let currentMin = maxProd;
41 |     
42 |     for (let i = 1; i < nums.length; i++) {
43 |         // if we hit a negative number, our max is now min and min is now max
44 |         if (nums[i] < 0) {
45 |             const temp1 = currentMax;
46 |             currentMax = currentMin;
47 |             currentMin = temp1;
48 |         }
49 |         currentMax = Math.max(nums[i], nums[i] * currentMax);
50 |         currentMin = Math.min(nums[i], nums[i] * currentMin);
51 |         maxProd = Math.max(currentMax, maxProd);
52 |     }
53 |     
54 |     return maxProd;
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/101-200/153.md:
--------------------------------------------------------------------------------
 1 | ### 153. 寻找旋转排序数组中的最小值
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`二分查找`
 6 | 
 7 | 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
 8 | 
 9 | 
10 | 
11 | ( 例如，数组 `[0,1,2,4,5,6,7]`  **** 可能变为 `[4,5,6,7,0,1,2]` )。
12 | 
13 | 
14 | 
15 | 请找出其中最小的元素。
16 | 
17 | 
18 | 
19 | 你可以假设数组中不存在重复元素。
20 | 
21 | 
22 | 
23 | **示例 1:** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入: [3,4,5,1,2]
29 | 输出: 1
30 | ```
31 | 
32 | 
33 | **示例 2:** 
34 | 
35 | 
36 | 
37 | ```
38 | 输入: [4,5,6,7,0,1,2]
39 | 输出: 0
40 | ```
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @return {number}
46 |  */
47 | var findMin = function(nums) {
48 |   for(let i=0;i<nums.length-1;i++){
49 |     if(nums[i+1]-nums[i]<0)return nums[i+1]
50 |   }
51 |   return nums[0]
52 | };
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------
/101-200/154.md:
--------------------------------------------------------------------------------
 1 | ### 154. 寻找旋转排序数组中的最小值 II
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`数组`、`二分查找`
 6 | 
 7 | 假设按照升序排序的数组在预先未知的某个点上进行了旋转。
 8 | 
 9 | 
10 | 
11 | ( 例如，数组 `[0,1,2,4,5,6,7]`  **** 可能变为 `[4,5,6,7,0,1,2]` )。
12 | 
13 | 
14 | 
15 | 请找出其中最小的元素。
16 | 
17 | 
18 | 
19 | 注意数组中可能存在重复的元素。
20 | 
21 | 
22 | 
23 | **示例 1：** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入: [1,3,5]
29 | 输出: 1
30 | ```
31 | 
32 | 
33 | **示例2：** 
34 | 
35 | 
36 | 
37 | ```
38 | 输入: [2,2,2,0,1]
39 | 输出: 0
40 | ```
41 | 
42 | 
43 | **说明：** 
44 | 
45 | 
46 | 
47 | 
48 | * 这道题是[寻找旋转排序数组中的最小值](https://leetcode-cn.com/problems/find-minimum-in-rotated-sorted-array/description/)
49 | 的延伸题目。
50 | 
51 | * 允许重复会影响算法的时间复杂度吗？会如何影响，为什么？
52 | 
53 | 
54 | 
55 | 
56 | ```
57 | /**
58 |  * @param {number[]} nums
59 |  * @return {number}
60 |  */
61 | var findMin = function(nums) {
62 |   let lo = 0;
63 |   let hi = nums.length - 1;
64 |   let mid = 0;
65 | 
66 |   while(lo < hi) {
67 |       mid = lo + Math.floor((hi - lo) / 2);
68 |       if (nums[mid] > nums[hi]) {
69 |           lo = mid + 1;
70 |       }else if (nums[mid] < nums[hi]) {
71 |           hi = mid;
72 |       }else { 
73 |           hi--;
74 |       }
75 |   }
76 |   return nums[lo];
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/101-200/162.md:
--------------------------------------------------------------------------------
 1 | ### 162. 寻找峰值
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`二分查找`
 6 | 
 7 | 峰值元素是指其值大于左右相邻值的元素。
 8 | 
 9 | 
10 | 
11 | 给定一个输入数组 `nums` ，其中  `nums[i] &ne; nums[i+1]` ，找到峰值元素并返回其索引。
12 | 
13 | 
14 | 
15 | 数组可能包含多个峰值，在这种情况下，返回任何一个峰值所在位置即可。
16 | 
17 | 
18 | 
19 | 你可以假设 `nums[-1] = nums[n] = -&infin;` 。
20 | 
21 | 
22 | 
23 | **示例 1:** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入: nums = [1,2,3,1]
29 | 输出: 2
30 | 解释:3 是峰值元素，你的函数应该返回其索引 2。
31 | ```
32 | 
33 | 
34 | **示例2:** 
35 | 
36 | 
37 | 
38 | ```
39 | 输入: nums = [1,2,1,3,5,6,4]
40 | 输出: 1 或 5 
41 | 解释: 你的函数可以返回索引 1，其峰值元素为 2；
42 |     或者返回索引 5， 其峰值元素为 6。
43 | ```
44 | 
45 | 
46 | **说明:** 
47 | 
48 | 
49 | 
50 | 你的解法应该是*O* (*logN* )** 时间复杂度的。
51 | 
52 | 
53 | ```
54 | /**
55 |  * @param {number[]} nums
56 |  * @return {number}
57 |  */
58 | var findPeakElement = function(nums) {
59 | 
60 |     // for(let i=1;i<nums.length;i++){
61 |     //   if(nums[i]<nums[i-1])return i-1
62 |     // }
63 |     // return nums.length-1
64 |   
65 |       var n=nums.length;
66 |     var l=0, r=n-1;
67 |     while(l<r) {
68 |         var mid = Math.floor((l+r)/2);
69 |         if(nums[mid]<nums[mid+1]) {
70 |             l=mid+1;
71 |         } else {
72 |             r=mid;
73 |         }
74 |     }
75 |     return l;
76 | };
77 | ```
78 | 
79 | 


--------------------------------------------------------------------------------
/101-200/167.md:
--------------------------------------------------------------------------------
 1 | ### 167. 两数之和 II - 输入有序数组
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`双指针`、`二分查找`
 6 | 
 7 | 给定一个已按照***升序排列* ** 的有序数组，找到两个数使得它们相加之和等于目标数。
 8 | 
 9 | 
10 | 
11 | 函数应该返回这两个下标值** index1 和 index2，其中 index1必须小于index2*。* 
12 | 
13 | 
14 | 
15 | **说明:** 
16 | 
17 | 
18 | 
19 | 
20 | * 返回的下标值（index1 和 index2）不是从零开始的。
21 | 
22 | * 你可以假设每个输入只对应唯一的答案，而且你不可以重复使用相同的元素。
23 | 
24 | 
25 | 
26 | 
27 | 
28 | **示例:** 
29 | 
30 | 
31 | 
32 | ```
33 | 输入: numbers = [2, 7, 11, 15], target = 9
34 | 输出: [1,2]
35 | 解释: 2 与 7 之和等于目标数 9 。因此 index1 = 1, index2 = 2 。
36 | ```
37 | 
38 | ```
39 | /**
40 |  * @param {number[]} numbers
41 |  * @param {number} target
42 |  * @return {number[]}
43 |  */
44 | var twoSum = function(numbers, target) {
45 |     let helper=[],index,index2
46 |     for(let i=0;i<numbers.length;i++){
47 |         let cur=numbers[i]
48 |         if(helper[cur]!==undefined){
49 |             if(target-cur>cur){
50 |                 index=i
51 |                 index2=helper[cur]
52 |             }else{
53 |                 index2=i
54 |                 index=helper[cur]                
55 |             }
56 |             break
57 |         }
58 |         else helper[target-cur]=i
59 |     }
60 |    return [index+1,index2+1]
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/101-200/168.md:
--------------------------------------------------------------------------------
 1 | ### 168. Excel表列名称
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个正整数，返回它在 Excel 表中相对应的列名称。
 8 | 
 9 | 
10 | 
11 | 例如，
12 | 
13 | 
14 | 
15 | ```
16 |     1 -> A
17 |     2 -> B
18 |     3 -> C
19 |     ...
20 |     26 -> Z
21 |     27 -> AA
22 |     28 -> AB 
23 |     ...
24 | ```
25 | 
26 | 
27 | **示例 1:** 
28 | 
29 | 
30 | 
31 | ```
32 | 输入: 1
33 | 输出: "A"
34 | ```
35 | 
36 | 
37 | **示例2:** 
38 | 
39 | 
40 | 
41 | ```
42 | 输入: 28
43 | 输出: "AB"
44 | ```
45 | 
46 | 
47 | **示例3:** 
48 | 
49 | 
50 | 
51 | ```
52 | 输入: 701
53 | 输出: "ZY"
54 | ```
55 | 
56 | ```
57 | /**
58 |  * @param {number} n
59 |  * @return {string}
60 |  */
61 | var convertToTitle = function(n) {
62 |   let S='ABCDEFGHIJKLMNOPQRSTUVWXYZ'
63 |   let res=''
64 |   while(n>0){
65 |     let mod=(n-1)%26
66 |     n=Math.floor((n-1)/26)
67 |     res=S[mod]+res
68 |   }
69 |   return res
70 | };
71 | ```
72 | 
73 | 


--------------------------------------------------------------------------------
/101-200/169.md:
--------------------------------------------------------------------------------
 1 | ### 169. 求众数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`数组`、`分治算法`
 6 | 
 7 | 给定一个大小为 *n* 的数组，找到其中的众数。众数是指在数组中出现次数**大于**  `&lfloor; n/2 &rfloor;` 的元素。
 8 | 
 9 | 
10 | 
11 | 你可以假设数组是非空的，并且给定的数组总是存在众数。
12 | 
13 | 
14 | 
15 | **示例1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: [3,2,3]
21 | 输出: 3
22 | ```
23 | 
24 | 
25 | **示例2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: [2,2,1,1,1,2,2]
31 | 输出: 2
32 | ```
33 | 
34 | ```
35 | /**
36 |  * @param {number[]} nums
37 |  * @return {number}
38 |  */
39 | var majorityElement = function(nums) {
40 |     let count=0,res=null
41 |     for(let i=0;i<nums.length;i++){
42 |         if(count===0){
43 |             res=nums[i]
44 |         }
45 |         if(res===nums[i]) count++
46 |         else count--
47 |     }
48 |     return res
49 | };
50 | ```
51 | 
52 | 


--------------------------------------------------------------------------------
/101-200/171.md:
--------------------------------------------------------------------------------
 1 | ### 171. Excel表列序号
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个Excel表格中的列名称，返回其相应的列序号。
 8 | 
 9 | 
10 | 
11 | 例如，
12 | 
13 | 
14 | 
15 | ```
16 |     A -> 1
17 |     B -> 2
18 |     C -> 3
19 |     ...
20 |     Z -> 26
21 |     AA -> 27
22 |     AB -> 28 
23 |     ...
24 | ```
25 | 
26 | 
27 | **示例 1:** 
28 | 
29 | 
30 | 
31 | ```
32 | 输入: "A"
33 | 输出: 1
34 | ```
35 | 
36 | 
37 | **示例2:** 
38 | 
39 | 
40 | 
41 | ```
42 | 输入:"AB"
43 | 输出: 28
44 | ```
45 | 
46 | 
47 | **示例3:** 
48 | 
49 | 
50 | 
51 | ```
52 | 输入:"ZY"
53 | 输出: 701
54 | ```
55 | 
56 | 
57 | **致谢：** 
58 | 特别感谢[@ts](http://leetcode.com/discuss/user/ts)
59 | 添加此问题并创建所有测试用例。
60 | 
61 | 
62 | ```
63 | /**
64 |  * @param {string} s
65 |  * @return {number}
66 |  */
67 | var titleToNumber = function(s) {
68 |   if(s==='')return 0
69 |   return (s.charCodeAt(0)-65+1)*Math.pow(26,s.length-1) + titleToNumber(s.slice(1))
70 | };
71 | ```
72 | 
73 | 


--------------------------------------------------------------------------------
/101-200/172.md:
--------------------------------------------------------------------------------
 1 | ### 172. 阶乘后的零
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个整数 *n* ，返回 *n* ! 结果尾数中零的数量。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 3
17 | 输出: 0
18 | 解释:3! = 6, 尾数中没有零。
19 | ```
20 | 
21 | 
22 | **示例2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: 5
28 | 输出: 1
29 | 解释:5! = 120, 尾数中有 1 个零.
30 | ```
31 | 
32 | 
33 | **说明:** 你算法的时间复杂度应为*O* (log*n* )** 。
34 | 
35 | 
36 | ```
37 | /**
38 |  * @param {number} n
39 |  * @return {number}
40 |  */
41 | var trailingZeroes = function(n) {
42 |   let x=5,res=0
43 |   while(x<=n){
44 |     res+=Math.floor(n/x)
45 |     x*=5
46 |   }
47 |   return res
48 | };
49 | ```
50 | 
51 | 


--------------------------------------------------------------------------------
/101-200/179.md:
--------------------------------------------------------------------------------
 1 | ### 179. 最大数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`排序`
 6 | 
 7 | 给定一组非负整数，重新排列它们的顺序使之组成一个最大的整数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [10,2]
17 | 输出: 210
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: [3,30,34,5,9]
27 | 输出: 9534330
28 | ```
29 | 
30 | 
31 | **说明:** 输出结果可能非常大，所以你需要返回一个字符串而不是整数。
32 | 
33 | 
34 | 
35 | 
36 | -----
37 | 
38 | 思路：
39 | 
40 | 对于两个数字`a`，`b`，只需要比较它们的字符串相加`a+''+b`，`b+''+a`'，并且只能找它们从大到小排序。
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @return {string}
46 |  */
47 | var largestNumber = function(nums) {
48 |   nums.sort((a,b)=>(b+''+a)-(a+''+b))
49 |   let res=''
50 |   for(let n of nums) res+=n
51 |   if(res==='' || res[0]==="0")return "0"
52 |   return res
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/101-200/187.md:
--------------------------------------------------------------------------------
 1 | ### 187. 重复的DNA序列
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`、`哈希表`
 6 | 
 7 | 所有 DNA 由一系列缩写为 A，C，G 和 T 的核苷酸组成，例如：&ldquo;ACGAATTCCG&rdquo;。在研究 DNA 时，识别 DNA 中的重复序列有时会对研究非常有帮助。
 8 | 
 9 | 
10 | 
11 | 编写一个函数来查找 DNA 分子中所有出现超多一次的10个字母长的序列（子串）。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: s = "AAAAACCCCCAAAAACCCCCCAAAAAGGGTTT"
21 | 
22 | 输出: ["AAAAACCCCC", "CCCCCAAAAA"]
23 | ```
24 | 
25 | 
26 | 
27 | -----
28 | 
29 | 思路：
30 | 
31 | 每`10`个字符就存入`hash`，如果有重复，`hash`对应的`val`就`+1`，最终只返回`hash`中`val`为2的字符串，既重复出现了，也避免重复返回。
32 | 
33 | ```
34 | /**
35 |  * @param {string} s
36 |  * @return {string[]}
37 |  */
38 | var findRepeatedDnaSequences = function(s) {
39 |   let hash={}
40 |   let res=[]
41 |   for(let i=0;i<=s.length-10;i++){
42 |     let str=s.substring(i,i+10)
43 |     if(hash[str]==null){
44 |       hash[str]=1
45 |     }else{
46 |       hash[str]++
47 |     }
48 |     if(hash[str]===2)res.push(str)
49 |   }
50 |   return res
51 | };
52 | ```
53 | 
54 | 


--------------------------------------------------------------------------------
/101-200/199.md:
--------------------------------------------------------------------------------
 1 | ### 199. 二叉树的右视图
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`、`广度优先搜索`
 6 | 
 7 | 给定一棵二叉树，想象自己站在它的右侧，按照从顶部到底部的顺序，返回从右侧所能看到的节点值。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:[1,2,3,null,5,null,4]
17 | 输出:[1, 3, 4]
18 | 解释:
19 |    1            <---
20 |  /   \
21 | 2     3         <---
22 |  \     \
23 |   5     4       <---
24 | ```
25 | 
26 | ```
27 | /**
28 |  * Definition for a binary tree node.
29 |  * function TreeNode(val) {
30 |  *     this.val = val;
31 |  *     this.left = this.right = null;
32 |  * }
33 |  */
34 | /**
35 |  * @param {TreeNode} root
36 |  * @return {number[]}
37 |  */
38 | var rightSideView = function(root) {
39 |   if(!root)return []
40 |   let arr=[root]
41 |   let res=[]
42 |   while(arr.length>0){
43 |     let len=arr.length
44 |     res.push(arr[len-1].val)
45 |     for(let i=0;i<len;i++){
46 |       let node=arr.shift()
47 |       if(node.left)arr.push(node.left)
48 |       if(node.right)arr.push(node.right)
49 |     }
50 |   }
51 |   return res
52 | };
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------
/201-300/201.md:
--------------------------------------------------------------------------------
 1 | ### 201. 数字范围按位与
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定范围 [m, n]，其中 0 <= m <= n <= 2147483647，返回此范围内所有数字的按位与（包含 m, n 两端点）。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [5,7]
17 | 输出: 4
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: [0,1]
27 | 输出: 0
28 | ```
29 | 
30 | 
31 | 
32 | -----
33 | 
34 | 思路：
35 | 
36 | 因为`n`和`m`最多`31`位，因此从左到右遍历它们每一个位置(31次)，按位与的规则是从m到n的每一个数的当前位置必须都是`1`，这个位置最后结果才能是`1`。
37 | 
38 | 如果当前位置`m`和`n`相等并且为`1`，最终结果此位置一定为`1`；
39 | 
40 | 如果当前位置`m`和`n`相等并且为`0`，最红结果此位置一定为`0`；
41 | 
42 | 如果当前位置`m`和`n`不相等，那么不需要再遍历了，后面的位置都是`0`。
43 | 
44 | 因为大的数`n`此位置一定为`1`，`m`这个位置一定是`0`(n>=m)，从`m`到`n`的过程中，这个位置进位了，一旦发生进位，前面的每一位都要经过一次`0`，因此前面全部为`0`。
45 | 
46 | 最后将结果解析为数字。
47 | 
48 | ```
49 | /**
50 |  * @param {number} m
51 |  * @param {number} n
52 |  * @return {number}
53 |  */
54 | var rangeBitwiseAnd = function(m, n) {
55 |   let k=Math.pow(2,30)
56 |   let str=''
57 |   for(let i=0;i<31;i++){
58 |     let c1=(m<<i) & k,
59 |         c2=(n<<i) & k
60 |     if(c1!==c2){
61 |       return parseInt(str.padEnd(31,0),2)
62 |     }else{
63 |       if(c1===0)str+='0'
64 |       else str+="1"
65 |     }
66 |   }
67 |   return parseInt(str,2)
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/201-300/202.md:
--------------------------------------------------------------------------------
 1 | ### 202. 快乐数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`、`数学`
 6 | 
 7 | 编写一个算法来判断一个数是不是&ldquo;快乐数&rdquo;。
 8 | 
 9 | 
10 | 
11 | 一个&ldquo;快乐数&rdquo;定义为：对于一个正整数，每一次将该数替换为它每个位置上的数字的平方和，然后重复这个过程直到这个数变为 1，也可能是无限循环但始终变不到 1。如果可以变为 1，那么这个数就是快乐数。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: 19
21 | 输出: true
22 | 解释:12 + 92 = 82
23 | 82 + 22 = 68
24 | 62 + 82 = 100
25 | 12 + 02 + 02 = 1
26 | ```
27 | 
28 | ```
29 | /**
30 |  * @param {number} n
31 |  * @return {boolean}
32 |  */
33 | var isHappy = function(n) {
34 |   let mem={}
35 |   let s=n+''
36 |   while(s!=='1'){
37 |     if(mem[s])return false
38 |     mem[s]=true
39 |     let sum=0
40 |     for(let i=0;i<s.length;i++){
41 |       sum+=s[i]*s[i]
42 |     }
43 |     s=sum+''
44 |   }
45 |   return true
46 | };
47 | ```
48 | 
49 | 


--------------------------------------------------------------------------------
/201-300/203.md:
--------------------------------------------------------------------------------
 1 | ### 203. 移除链表元素
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`链表`
 6 | 
 7 | 删除链表中等于给定值***val*** 的所有节点。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 1->2->6->3->4->5->6, **val** = 6
17 | 输出: 1->2->3->4->5
18 | ```
19 | 
20 | 
21 | 
22 | -----
23 | 
24 | 思路：
25 | 
26 | 只需要时刻跟踪当前`node`和当前`node`的上一个节点`lastNode`。
27 | 
28 | 遇到`node.val===val`，那么就改变`lastNode.next`为`node.next`。
29 | 
30 | ```
31 | /**
32 |  * Definition for singly-linked list.
33 |  * function ListNode(val) {
34 |  *     this.val = val;
35 |  *     this.next = null;
36 |  * }
37 |  */
38 | /**
39 |  * @param {ListNode} head
40 |  * @param {number} val
41 |  * @return {ListNode}
42 |  */
43 | var removeElements = function(head, val) {
44 |   let root=new ListNode(null)
45 |   root.next=head
46 |   let lastNode=root,node=head
47 |   while(lastNode){
48 |     if(node && node.val===val){
49 |       let nxt=node.next
50 |       lastNode.next=nxt
51 |       node=nxt
52 |     }else{
53 |       if(node)node=node.next
54 |       lastNode=lastNode.next
55 |     }
56 |   }
57 |   return root.next
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/201-300/204.md:
--------------------------------------------------------------------------------
 1 | ### 204. 计数质数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`、`数学`
 6 | 
 7 | 统计所有小于非负整数*n* 的质数的数量。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 10
17 | 输出: 4
18 | 解释: 小于 10 的质数一共有 4 个, 它们是 2, 3, 5, 7 。
19 | ```
20 | 
21 | 
22 | 
23 | -----
24 | 
25 | 思路：
26 | 
27 | 厄拉多塞筛法，比`Math.sqrt`+`for in primes`加起来还快。
28 | 
29 | 它是定义一个数组`notPrime`，表示非质数的数，`0`和`1`不是质数。
30 | 
31 | 接着`2`是第一个质数，然后把范围内所有2的倍数在`notPrime[2的倍数]=true`，
32 | 
33 | 接着`3`不在`notPrime`范围内，因此是下一个质数，然后把3所有的倍数设置为`true`
34 | 
35 | 以此类推...
36 | 
37 | ```
38 | /**
39 |  * @param {number} n
40 |  * @return {number}
41 |  */
42 | var countPrimes = function(n) {
43 |   let notPrime = new Array(n);
44 |   let count = 0;
45 |   notPrime[0] = true;
46 |   notPrime[1] = true;
47 |   for (let i = 1; i < n; i=i+2){
48 |     if (!notPrime[i]){
49 |       count++;
50 |       // 对当前质数的所有倍数都定义为非质数，这里从 i*i开始，因为之前的已经计算过了
51 |       for (let j = i*i; j < n; j += i){
52 |         notPrime[j] = true;
53 |       }
54 |     }
55 |   }
56 |   return n>2?count+1:count;
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/201-300/206.md:
--------------------------------------------------------------------------------
 1 | ### 206. 反转链表
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`链表`
 6 | 
 7 | 反转一个单链表。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 1->2->3->4->5->NULL
17 | 输出: 5->4->3->2->1->NULL
18 | ```
19 | 
20 | 
21 | **进阶:** 
22 | 你可以迭代或递归地反转链表。你能否用两种方法解决这道题？
23 | 
24 | 
25 | ```
26 | /**
27 |  * Definition for singly-linked list.
28 |  * function ListNode(val) {
29 |  *     this.val = val;
30 |  *     this.next = null;
31 |  * }
32 |  */
33 | /**
34 |  * @param {ListNode} head
35 |  * @return {ListNode}
36 |  */
37 | var reverseList = function(head) {
38 |   function iteratively (node){
39 |     let prev=null
40 |     while(node){
41 |       let next=node.next
42 |       node.next=prev
43 |       prev=node
44 |       node=next
45 |     }
46 |     return prev
47 |   }
48 | 
49 | 
50 |   function recursively (node){
51 |     if(!node || !node.next)return node
52 |     let r=recursively(node.next)
53 |     node.next.next=node
54 |     node.next=null
55 |     return r
56 |   }
57 | 
58 |   return recursively(head)
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/201-300/216.md:
--------------------------------------------------------------------------------
 1 | ### 216. 组合总和 III
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`回溯算法`
 6 | 
 7 | 找出所有相加之和为***n*** 的***k*** 个数的组合***。*** 组合中只允许含有 1 -9 的正整数，并且每种组合中不存在重复的数字。
 8 | 
 9 | 
10 | 
11 | **说明：** 
12 | 
13 | 
14 | 
15 | 
16 | * 所有数字都是正整数。
17 | 
18 | * 解集不能包含重复的组合。
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例 1:** 
25 | 
26 | 
27 | 
28 | ```
29 | 输入: **k** = 3, **n** = 7
30 | 输出: [[1,2,4]]
31 | ```
32 | 
33 | 
34 | **示例 2:** 
35 | 
36 | 
37 | 
38 | ```
39 | 输入: **k** = 3, **n** = 9
40 | 输出: [[1,2,6], [1,3,5], [2,3,4]]
41 | ```
42 | 
43 | ```
44 | /**
45 |  * @param {number} k
46 |  * @param {number} n
47 |  * @return {number[][]}
48 |  */
49 | var combinationSum3 = function(k, n) {
50 |     let validNum=[]
51 |     let res=[]
52 |     let cache={}
53 |     function getSumComb(sum,validNum,times,start){
54 |         if(times===0){
55 |             if(sum===0)res.push(validNum.slice())
56 |             return
57 |         }
58 |         for(let i=start;i<=9;i++){
59 |             validNum.push(i)
60 |             getSumComb(sum-i,validNum,times-1,i+1)
61 |             validNum.pop()       
62 |         }
63 |     }
64 |     getSumComb(n,validNum,k,1)
65 |     return res
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/201-300/217.md:
--------------------------------------------------------------------------------
 1 | ### 217. 存在重复元素
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`哈希表`
 6 | 
 7 | 给定一个整数数组，判断是否存在重复元素。
 8 | 
 9 | 
10 | 
11 | 如果任何值在数组中出现至少两次，函数返回 true。如果数组中每个元素都不相同，则返回 false。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: [1,2,3,1]
21 | 输出: true
22 | ```
23 | 
24 | 
25 | **示例 2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入:[1,2,3,4]
31 | 输出: false
32 | ```
33 | 
34 | 
35 | **示例3:** 
36 | 
37 | 
38 | 
39 | ```
40 | 输入:[1,1,1,3,3,4,3,2,4,2]
41 | 输出: true
42 | ```
43 | 
44 | ```
45 | /**
46 |  * @param {number[]} nums
47 |  * @return {boolean}
48 |  */
49 | var containsDuplicate = function(nums) {
50 |     let res=[]
51 |     for(let i=0;i<nums.length;i++){
52 |         let cur=nums[i]
53 |         if(res[cur])return true
54 |         else res[cur]=1
55 |     }
56 |     return false
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/201-300/219.md:
--------------------------------------------------------------------------------
 1 | ### 219. 存在重复元素 II
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`哈希表`
 6 | 
 7 | 给定一个整数数组和一个整数*k* ，判断数组中是否存在两个不同的索引*i* 和*j* ，使得**nums [i] = nums [j]** ，并且 *i*  和 *j* 的差的绝对值最大为 *k* 。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: nums = [1,2,3,1], k= 3
17 | 输出: true
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:nums = [1,0,1,1], k=1
27 | 输出: true
28 | ```
29 | 
30 | 
31 | **示例 3:** 
32 | 
33 | 
34 | 
35 | ```
36 | 输入:nums = [1,2,3,1,2,3], k=2
37 | 输出: false
38 | ```
39 | 
40 | ```
41 | /**
42 |  * @param {number[]} nums
43 |  * @param {number} k
44 |  * @return {boolean}
45 |  */
46 | var containsNearbyDuplicate = function(nums, k) {
47 |   let hash={}
48 |   for(let i=0;i<nums.length;i++){
49 |     if(hash[nums[i]]==null)hash[nums[i]]=i
50 |     else{
51 |       let step=i-hash[nums[i]]
52 |       if(step<=k)return true
53 |       else hash[nums[i]]=i
54 |     }
55 |   }
56 |   return false
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/201-300/221.md:
--------------------------------------------------------------------------------
 1 | ### 221. 最大正方形
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 在一个由 0 和 1 组成的二维矩阵内，找到只包含 1 的最大正方形，并返回其面积。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:
17 | 1 0 1 0 0
18 | 1 0 1 1 1
19 | 1 1 1 11
20 | 1 0 0 1 0
21 | 
22 | 输出:4
23 | ```
24 | 
25 | ```
26 | /**
27 |  * @param {character[][]} matrix
28 |  * @return {number}
29 |  */
30 | var maximalSquare = function(matrix) {
31 |   let dp=[]
32 |   let n=matrix.length
33 |   if(n===0)return 0
34 |   let max=0
35 |   for(let i=0;i<n;i++){
36 |     dp[i]=[]
37 |     for(let j=0;j<matrix[i].length;j++){
38 |       if(matrix[i][j]==="0")dp[i][j]=0
39 |       else{
40 |         let lt=0,l=0,t=0
41 |         if(i>0 && j>0)lt=dp[i-1][j-1]
42 |         if(i>0)t=dp[i-1][j]
43 |         if(j>0)l=dp[i][j-1]
44 |         dp[i][j]=Math.min(lt,l,t)+1
45 |         max=Math.max(max,dp[i][j])
46 |       }
47 |     }
48 |   }
49 |   return max*max
50 | };
51 | ```
52 | 
53 | 


--------------------------------------------------------------------------------
/201-300/222.md:
--------------------------------------------------------------------------------
 1 | ### 222. 完全二叉树的节点个数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`树`、`二分查找`
 6 | 
 7 | 给出一个**完全二叉树** ，求出该树的节点个数。
 8 | 
 9 | 
10 | 
11 | **说明：** 
12 | 
13 | 
14 | 
15 | [完全二叉树](https://baike.baidu.com/item/%E5%AE%8C%E5%85%A8%E4%BA%8C%E5%8F%89%E6%A0%91/7773232?fr=aladdin)
16 | 的定义如下：在完全二叉树中，除了最底层节点可能没填满外，其余每层节点数都达到最大值，并且最下面一层的节点都集中在该层最左边的若干位置。若最底层为第 h 层，则该层包含 1~2h个节点。
17 | 
18 | 
19 | 
20 | **示例:** 
21 | 
22 | 
23 | 
24 | ```
25 | 输入: 
26 |     1
27 |    / \
28 |   2   3
29 |  / \  /
30 | 4  5 6
31 | 
32 | 输出: 6
33 | ```
34 | 
35 | ```
36 | /**
37 |  * Definition for a binary tree node.
38 |  * function TreeNode(val) {
39 |  *     this.val = val;
40 |  *     this.left = this.right = null;
41 |  * }
42 |  */
43 | /**
44 |  * @param {TreeNode} root
45 |  * @return {number}
46 |  */
47 | var countNodes = function(root) {
48 |   if(!root)return 0
49 |   let count=1
50 |   count+=countNodes(root.left)
51 |   count+=countNodes(root.right)
52 |   return count
53 | 
54 | };
55 | ```
56 | 
57 | 


--------------------------------------------------------------------------------
/201-300/223.md:
--------------------------------------------------------------------------------
 1 | ### 223. 矩形面积
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 在**二维** 平面上计算出两个**由直线构成的** 矩形重叠后形成的总面积。
 8 | 
 9 | 
10 | 
11 | 每个矩形由其左下顶点和右上顶点坐标表示，如图所示。
12 | 
13 | 
14 | 
15 | ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/22/rectangle_area.png)
16 | 
17 | 
18 | 
19 | 
20 | **示例:** 
21 | 
22 | 
23 | 
24 | ```
25 | 输入: -3, 0, 3, 4, 0, -1, 9, 2
26 | 输出: 45
27 | ```
28 | 
29 | 
30 | **说明:**  假设矩形面积不会超出**int** 的范围。
31 | 
32 | 
33 | ```
34 | /**
35 |  * @param {number} A
36 |  * @param {number} B
37 |  * @param {number} C
38 |  * @param {number} D
39 |  * @param {number} E
40 |  * @param {number} F
41 |  * @param {number} G
42 |  * @param {number} H
43 |  * @return {number}
44 |  */
45 | var computeArea = function(A, B, C, D, E, F, G, H) {
46 |   let gapX1=[A,C],gapX2=[E,G],
47 |       gapY1=[B,D],gapY2=[F,H]
48 |   let ox1=Math.max(A,E),ox2=Math.min(C,G)
49 |   let oy1=Math.max(B,F),oy2=Math.min(D,H)
50 |   let gap_x=0,gap_y=0
51 |   if(ox2>ox1)gap_x=ox2-ox1
52 |   if(oy2>oy1)gap_y=oy2-oy1
53 |   let allArea=(C-A)*(D-B)+(G-E)*(H-F)
54 |   return allArea-gap_x*gap_y
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/201-300/228.md:
--------------------------------------------------------------------------------
 1 | ### 228. 汇总区间
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个无重复元素的有序整数数组，返回数组区间范围的汇总。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [0,1,2,4,5,7]
17 | 输出: ["0->2","4->5","7"]
18 | 解释:0,1,2 可组成一个连续的区间;4,5 可组成一个连续的区间。
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: [0,2,3,4,6,8,9]
28 | 输出: ["0","2->4","6","8->9"]
29 | 解释:2,3,4 可组成一个连续的区间;8,9 可组成一个连续的区间。
30 | ```
31 | 
32 | ```
33 | /**
34 |  * @param {number[]} nums
35 |  * @return {string[]}
36 |  */
37 | var summaryRanges = function(nums) {
38 |   let result=[]
39 |   if(nums.length===0)return result
40 |   let head=nums[0],
41 |       tail=null
42 |   for(let i=1;i<nums.length;i++){
43 |     if(nums[i]-nums[i-1]===1)tail=nums[i]
44 |     else{
45 |       if(tail){
46 |         result.push(head+'->'+tail)
47 |         tail=null
48 |       }else{
49 |         result.push(''+head)
50 |       }
51 |       head=nums[i]
52 |     }
53 |   }
54 |   if(tail)result.push(head+'->'+tail)
55 |   else result.push(''+head)
56 |   return result
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/201-300/231.md:
--------------------------------------------------------------------------------
 1 | ### 231. 2的幂
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`数学`
 6 | 
 7 | 给定一个整数，编写一个函数来判断它是否是 2 的幂次方。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 1
17 | 输出: true
18 | 解释:20= 1
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: 16
28 | 输出: true
29 | 解释:24= 16
30 | ```
31 | 
32 | 
33 | **示例 3:** 
34 | 
35 | 
36 | 
37 | ```
38 | 输入: 218
39 | 输出: false
40 | ```
41 | 
42 | ```
43 | /**
44 |  * @param {number} n
45 |  * @return {boolean}
46 |  */
47 | var isPowerOfTwo = function(n) {
48 |   if(n<=0) return false;
49 |   return !(n&(n-1));
50 | };
51 | ```
52 | 
53 | 


--------------------------------------------------------------------------------
/201-300/233.md:
--------------------------------------------------------------------------------
 1 | ### 233. 数字 1 的个数
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个整数 n，计算所有小于等于 n 的非负整数中数字 1 出现的个数。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 13
17 | 输出: 6 
18 | 解释:数字 1 出现在以下数字中: 1, 10, 11, 12, 13 。
19 | ```
20 | 
21 | ```
22 | /**
23 |  * @param {number} n
24 |  * @return {number}
25 |  */
26 | var countDigitOne = function(n) {
27 |   if(n<0)return 0
28 |   let s=n+''
29 |   function count(s){
30 |     if(s==='' || +s===0)return 0
31 |     let head=+s[0]
32 |     // 例如782，rest为count('99')
33 |     // 因为对语0XX~6XX，每一个都存在 99 个尾巴
34 |     let rest=count('9'.repeat(s.length-1))
35 |     let res=0
36 |     for(let i=0;i<head;i++){
37 |       // 如果当前头为 1，说明需要额外加上10^(len-1)
38 |       // 例如 1XX ，以1为头的任何数都至少存在1个1，需要额外加上100
39 |       if(i===1)res+=Math.pow(10,s.length-1)
40 |       res+=rest
41 |     }
42 |     let restStr=s.slice(1)
43 |     if(head===1)res+=+restStr+1
44 |     res+=count(restStr)
45 |     return res
46 |   }
47 |   return count(s)
48 | };
49 | ```
50 | 
51 | 


--------------------------------------------------------------------------------
/201-300/240.md:
--------------------------------------------------------------------------------
 1 | ### 240. 搜索二维矩阵 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`二分查找`、`分治算法`
 6 | 
 7 | 编写一个高效的算法来搜索*m* x*n* 矩阵 matrix 中的一个目标值 target。该矩阵具有以下特性：
 8 | 
 9 | 
10 | 
11 | 
12 | * 每行的元素从左到右升序排列。
13 | 
14 | * 每列的元素从上到下升序排列。
15 | 
16 | 
17 | 
18 | 
19 | 
20 | **示例:** 
21 | 
22 | 
23 | 
24 | 现有矩阵 matrix 如下：
25 | 
26 | 
27 | 
28 | ```
29 | [
30 |   [1,   4,  7, 11, 15],
31 |   [2,   5,  8, 12, 19],
32 |   [3,   6,  9, 16, 22],
33 |   [10, 13, 14, 17, 24],
34 |   [18, 21, 23, 26, 30]
35 | ]
36 | ```
37 | 
38 | 
39 | 给定 target= `5` ，返回 `true` 。
40 | 
41 | 
42 | 
43 | 给定target= `20` ，返回 `false` 。
44 | 
45 | 
46 | ```
47 | /**
48 |  * @param {number[][]} matrix
49 |  * @param {number} target
50 |  * @return {boolean}
51 |  */
52 | var searchMatrix = function(matrix, target) {
53 |   if(matrix.length===0)return false
54 |   let maxR=matrix[0].length,
55 |       maxC=matrix.length
56 |   let curR=maxR-1,curC=0
57 |   
58 |   while(curR>=0 && curC<maxC){
59 |     let cur=matrix[curC][curR]
60 |     if(cur<target)curC++
61 |     else if(cur>target)curR--
62 |     else return true
63 |   }
64 |   return false
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/201-300/242.md:
--------------------------------------------------------------------------------
 1 | ### 242. 有效的字母异位词
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`排序`、`哈希表`
 6 | 
 7 | 给定两个字符串 *s*  和 *t*  ，编写一个函数来判断 *t*  是否是 *s*  的一个字母异位词。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: s = "anagram", t = "nagaram"
17 | 输出: true
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: s = "rat", t = "car"
27 | 输出:false
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 你可以假设字符串只包含小写字母。
33 | 
34 | 
35 | 
36 | **进阶:** 
37 | 如果输入字符串包含 unicode 字符怎么办？你能否调整你的解法来应对这种情况？
38 | 
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | 对`s`每一个字母对应的索引`+1`，对`t`每一个字母对应的索引`-1`，如果存在负值，返回`false`。
47 | 
48 | ```
49 | /**
50 |  * @param {string} s
51 |  * @param {string} t
52 |  * @return {boolean}
53 |  */
54 | var isAnagram = function(s, t) {
55 |   if(s.length!==t.length)return false
56 |   let codes=Array(26).fill(0)
57 |   for(let i=0;i<s.length;i++){
58 |     codes[s.charCodeAt(i)-97]++
59 |   }
60 |   for(let i=0;i<t.length;i++){
61 |     let c=t.charCodeAt(i)-97
62 |     codes[c]--
63 |     if(codes[c]<0)return false
64 |   }
65 |   return true
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/201-300/257.md:
--------------------------------------------------------------------------------
 1 | ### 257. 二叉树的所有路径
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`
 6 | 
 7 | 给定一个二叉树，返回所有从根节点到叶子节点的路径。
 8 | 
 9 | 
10 | 
11 | **说明:** 叶子节点是指没有子节点的节点。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入:
21 | 
22 |    1
23 |  /   \
24 | 2     3
25 |  \
26 |   5
27 | 
28 | 输出: ["1->2->5", "1->3"]
29 | 
30 | 解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
31 | ```
32 | 
33 | ```
34 | /**
35 |  * Definition for a binary tree node.
36 |  * function TreeNode(val) {
37 |  *     this.val = val;
38 |  *     this.left = this.right = null;
39 |  * }
40 |  */
41 | /**
42 |  * @param {TreeNode} root
43 |  * @return {string[]}
44 |  */
45 | var binaryTreePaths = function(root) {
46 |     if(!root)return []
47 |     let str=root.val+''
48 |     let result=[]
49 |     pre(str,root)
50 |     function pre(str,node){
51 |         if(node.left)pre(str+'->'+node.left.val,node.left)
52 |         if(node.right)pre(str+'->'+node.right.val,node.right)
53 |         if(!node.left && !node.right)result.push(str)
54 |     }
55 |     return result
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/201-300/258.md:
--------------------------------------------------------------------------------
 1 | ### 258. 各位相加
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个非负整数  `num` ，反复将各个位上的数字相加，直到结果为一位数。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 38
17 | 输出: 2 
18 | 解释:各位相加的过程为：3 + 8 = 11, 1 + 1 = 2。 由于2 是一位数，所以返回 2。
19 | ```
20 | 
21 | 
22 | **进阶:** 
23 | 你可以不使用循环或者递归，且在 O(1) 时间复杂度内解决这个问题吗？
24 | 
25 | 
26 | ```
27 | /**
28 |  * @param {number} num
29 |  * @return {number}
30 |  */
31 | var addDigits = function(num) {
32 |     while(num>=10){
33 |         let x=parseInt(num/10,10)+num%10
34 |         num=x
35 |     }
36 |     return num
37 |     
38 |     // O(1)
39 |     // return (num % 9 === 0) ? (num === 0 ? 0 : 9) : num % 9
40 | };
41 | ```
42 | 
43 | 


--------------------------------------------------------------------------------
/201-300/260.md:
--------------------------------------------------------------------------------
 1 | ### 260. 只出现一次的数字 III
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定一个整数数组 `nums` ，其中恰好有两个元素只出现一次，其余所有元素均出现两次。 找出只出现一次的那两个元素。
 8 | 
 9 | 
10 | 
11 | **示例 :** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,2,1,3,2,5]
17 | 输出: [3,5]
18 | ```
19 | 
20 | 
21 | **注意：** 
22 | 
23 | 
24 | 
25 | 
26 | 1. 结果输出的顺序并不重要，对于上面的例子， `[5, 3]` 也是正确答案。
27 | 
28 | 2. 你的算法应该具有线性时间复杂度。你能否仅使用常数空间复杂度来实现？
29 | 
30 | 
31 | 
32 | 
33 | 
34 | 
35 | -----
36 | 
37 | 思路：
38 | 
39 | 2次遍历，第一次遍历计算所有数的`xor`，计算`xor`的原因是因为只要找到`xor`二进制中最后一位`1`的位置，
40 | 那么说明那`2`个独立的数这个位置上的数字是不同的(这样它们才有可能异或`1`)。
41 | 
42 | 第二次遍历，如果当前数的那个位置是`1`，单独计算异或值；如果是`0`，也单独计算异或值，最终得到2个不同的独立值。
43 | 
44 | ```
45 | /**
46 |  * @param {number[]} nums
47 |  * @return {number[]}
48 |  */
49 | var singleNumber = function(nums) {
50 |   let xor=0
51 |   for(let num of nums)xor ^= num
52 |   // 找出xor的二进制中最后一个1及后面的0代表的数字
53 |   // 这个最后一个1的位置 说明这两个出现1次的数在这个位置的数是1和0
54 |   let lastOneBit=1
55 |   while(xor % 2===0){
56 |     xor /= 2
57 |     lastOneBit*=2
58 |   }
59 |   let res=[0,0]
60 |   for(let num of nums){
61 |     // 这个位置是0的所有数
62 |     if((lastOneBit & num)===0){
63 |       res[0] ^= num
64 |     }else{
65 |       // 这个位置是1的所有数
66 |       res[1] ^= num
67 |     }
68 |   }
69 |   return res
70 | };
71 | ```
72 | 
73 | 


--------------------------------------------------------------------------------
/201-300/263.md:
--------------------------------------------------------------------------------
 1 | ### 263. 丑数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 编写一个程序判断给定的数是否为丑数。
 8 | 
 9 | 
10 | 
11 | 丑数就是只包含质因数 `2, 3, 5` 的**正整数** 。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: 6
21 | 输出: true
22 | 解释:6 = 2 &times;3
23 | ```
24 | 
25 | 
26 | **示例 2:** 
27 | 
28 | 
29 | 
30 | ```
31 | 输入: 8
32 | 输出: true
33 | 解释:8 = 2 &times; 2 &times;2
34 | ```
35 | 
36 | 
37 | **示例3:** 
38 | 
39 | 
40 | 
41 | ```
42 | 输入: 14
43 | 输出: false 
44 | 解释:14 不是丑数，因为它包含了另外一个质因数7。
45 | ```
46 | 
47 | 
48 | **说明：** 
49 | 
50 | 
51 | 
52 | 
53 | 1.  `1` 是丑数。
54 | 
55 | 2. 输入不会超过 32 位有符号整数的范围:[&minus;231, 231&minus; 1]。
56 | 
57 | 
58 | 
59 | 
60 | ```
61 | /**
62 |  * @param {number} num
63 |  * @return {boolean}
64 |  */
65 | var isUgly = function(num) {
66 |   if(num===0)return false
67 |   while(num%2===0){
68 |     num=num/2
69 |   }
70 |   while(num%3===0){
71 |     num=num/3
72 |   }
73 |   while(num%5===0){
74 |     num=num/5
75 |   }
76 |   return num===1?true:false
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/201-300/268.md:
--------------------------------------------------------------------------------
 1 | ### 268. 缺失数字
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`数组`、`数学`
 6 | 
 7 | 给定一个包含  `0, 1, 2, ..., n` 中*n* 个数的序列，找出 0 .. *n* 中没有出现在序列中的那个数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [3,0,1]
17 | 输出: 2
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: [9,6,4,2,3,5,7,0,1]
27 | 输出: 8
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 你的算法应具有线性时间复杂度。你能否仅使用额外常数空间来实现?
33 | 
34 | 
35 | ```
36 | /**
37 |  * @param {number[]} nums
38 |  * @return {number}
39 |  */
40 | var missingNumber = function(nums) {
41 |     let sum=0,len=nums.length
42 |     for(let i=0;i<nums.length;i++){
43 |         sum+=nums[i]
44 |     }
45 |     return (1+len)*len/2-sum
46 | };
47 | ```
48 | 
49 | 


--------------------------------------------------------------------------------
/201-300/283.md:
--------------------------------------------------------------------------------
 1 | ### 283. 移动零
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`双指针`
 6 | 
 7 | 给定一个数组  `nums` ，编写一个函数将所有  `0`  移动到数组的末尾，同时保持非零元素的相对顺序。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [0,1,0,3,12]
17 | 输出: [1,3,12,0,0]
18 | ```
19 | 
20 | 
21 | **说明** :
22 | 
23 | 
24 | 
25 | 
26 | 1. 必须在原数组上操作，不能拷贝额外的数组。
27 | 
28 | 2. 尽量减少操作次数。
29 | 
30 | 
31 | 
32 | 
33 | ```
34 | /**
35 |  * @param {number[]} nums
36 |  * @return {void} Do not return anything, modify nums in-place instead.
37 |  */
38 | 
39 | //  O(n^2)
40 | 
41 | // var moveZeroes = function(nums) {
42 | //     let len=nums.length
43 | //     for(let i=0;i<len;){
44 | //         if(nums[i]===0){
45 | //             nums.splice(i,1);
46 | //             nums.push(0);
47 | //             len--
48 | //         }else{
49 | //             i++
50 | //         }
51 | //     }
52 | // };
53 | 
54 | // O(n)
55 | 
56 | var moveZeroes = function(nums) {
57 |     let len=nums.length
58 |     let j=0
59 |     for(let i=0;i<len;i++){
60 |         if(nums[i]!==0){
61 |             nums[j]=nums[i]
62 |             j++;
63 |         }
64 |     }
65 |     for(;j<len;j++){
66 |         nums[j]=0
67 |     }
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/201-300/292.md:
--------------------------------------------------------------------------------
 1 | ### 292. Nim 游戏
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`脑筋急转弯`、`极小化极大`
 6 | 
 7 | 你和你的朋友，两个人一起玩[Nim 游戏](https://baike.baidu.com/item/Nim游戏/6737105)
 8 | ：桌子上有一堆石头，每次你们轮流拿掉1 - 3 块石头。 拿掉最后一块石头的人就是获胜者。你作为先手。
 9 | 
10 | 
11 | 
12 | 你们是聪明人，每一步都是最优解。 编写一个函数，来判断你是否可以在给定石头数量的情况下赢得游戏。
13 | 
14 | 
15 | 
16 | **示例:** 
17 | 
18 | 
19 | 
20 | ```
21 | 输入: 4
22 | 输出: false 
23 | 解释:如果堆中有 4 块石头，那么你永远不会赢得比赛；
24 |     因为无论你拿走 1 块、2 块 还是 3 块石头，最后一块石头总是会被你的朋友拿走。
25 | ```
26 | 
27 | 
28 | 
29 | -----
30 | 
31 | 思路：
32 | 
33 | 首先，到某一个人时`n==4`就一定输；
34 | 
35 | 因此如果一开始有`5,6,7`都能赢，因为可以拿走`1,2,3`个，让剩下的`n`为`4`。
36 | 
37 | 但是，一开始有`8`个，无论你拿几个，对方都能拿走几个，给你留下`4`个，因此到某一个人时`n===8`就一定输....
38 | 
39 | 继续推导下去，到某一个时`n===12`一定输，`n===16`一定输....
40 | 
41 | 也就是`n % 4===0`，一定输。
42 | 
43 | ```
44 | /**
45 |  * @param {number} n
46 |  * @return {boolean}
47 |  */
48 | var canWinNim = function(n) {
49 |     // first turn && 4 -->false
50 |     if(n===0)return false
51 |     return !!(n%4)
52 | };
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------
/301-400/303.md:
--------------------------------------------------------------------------------
 1 | ### 303. 区域和检索 - 数组不可变
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定一个整数数组 *nums* ，求出数组从索引*i* 到*j* (*i* &le;*j* ) 范围内元素的总和，包含*i, j* 两点。
 8 | 
 9 | 
10 | 
11 | **示例：** 
12 | 
13 | 
14 | 
15 | ```
16 | 给定 nums = [-2, 0, 3, -5, 2, -1]，求和函数为 sumRange()
17 | 
18 | sumRange(0, 2) -> 1
19 | sumRange(2, 5) -> -1
20 | sumRange(0, 5) -> -3
21 | ```
22 | 
23 | 
24 | **说明:** 
25 | 
26 | 
27 | 
28 | 
29 | 1. 你可以假设数组不可变。
30 | 
31 | 2. 会多次调用*sumRange* 方法。
32 | 
33 | 
34 | 
35 | 
36 | ```
37 | /**
38 |  * @param {number[]} nums
39 |  */
40 | var NumArray = function(nums) {
41 |     this.sums = [];
42 |     let sum = 0;
43 |     for(let i=0; i<nums.length; i++) {
44 |         sum = sum + nums[i];
45 |         this.sums.push(sum);
46 |     }
47 | };
48 | 
49 | /** 
50 |  * @param {number} i 
51 |  * @param {number} j
52 |  * @return {number}
53 |  */
54 | NumArray.prototype.sumRange = function(i, j) {
55 |     if(i==0)  return this.sums[j];
56 |     return this.sums[j]-this.sums[i-1];
57 | };
58 | 
59 | /** 
60 |  * Your NumArray object will be instantiated and called as such:
61 |  * var obj = Object.create(NumArray).createNew(nums)
62 |  * var param_1 = obj.sumRange(i,j)
63 |  */
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/301-400/309.md:
--------------------------------------------------------------------------------
 1 | ### 309. 最佳买卖股票时机含冷冻期
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定一个整数数组，其中第*i* 个元素代表了第*i* 天的股票价格 。​
 8 | 
 9 | 
10 | 
11 | 设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
12 | 
13 | 
14 | 
15 | 
16 | * 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
17 | 
18 | * 卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例:** 
25 | 
26 | 
27 | 
28 | ```
29 | 输入: [1,2,3,0,2]
30 | 输出:3 
31 | 解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
32 | ```
33 | 
34 | ```
35 | /**
36 |  * @param {number[]} prices
37 |  * @return {number}
38 |  */
39 | function maxProfit(prices){
40 |   let prev_sell,prev_buy,prev_rest,
41 |       sell=0,buy=-prices[0],rest=0
42 |   for(let i=0;i<prices.length;i++){
43 |       prev_buy=buy;prev_rest=rest;prev_sell=sell
44 |       sell=prev_buy+prices[i]
45 |       // 此处不能是卖出后立刻买
46 |       buy=Math.max(prev_rest-prices[i],prev_buy)
47 |       rest=Math.max(prev_rest,prev_sell)
48 |   }
49 |   return Math.max(sell,rest)
50 | }
51 | ```
52 | 
53 | 


--------------------------------------------------------------------------------
/301-400/319.md:
--------------------------------------------------------------------------------
 1 | ### 319. 灯泡开关
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`脑筋急转弯`、`数学`
 6 | 
 7 | 初始时有*n* 个灯泡关闭。 第 1 轮，你打开所有的灯泡。 第 2 轮，每两个灯泡你关闭一次。 第 3 轮，每三个灯泡切换一次开关（如果关闭则开启，如果开启则关闭）。第*i*  轮，每*i* 个灯泡切换一次开关。 对于第*n* 轮，你只切换最后一个灯泡的开关。 找出*n* 轮后有多少个亮着的灯泡。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:3
17 | 输出: 1 
18 | 解释: 
19 | 初始时, 灯泡状态 [关闭, 关闭, 关闭].
20 | 第一轮后, 灯泡状态 [开启, 开启, 开启].
21 | 第二轮后, 灯泡状态 [开启, 关闭, 开启].
22 | 第三轮后, 灯泡状态 [开启, 关闭, 关闭]. 
23 | 
24 | 你应该返回 1，因为只有一个灯泡还亮着。
25 | ```
26 | 
27 | 
28 | 
29 | -----
30 | 
31 | 思路：
32 | 
33 | 需要求满足`i*i<=n`的个数。
34 | 
35 | 因为当一个数内部被按了双数次，相当于还是开，而被按了单数次，就是关。
36 | 
37 | 例如`6`，当`i==2`的时候，它被按1次，当`i==3`，它被按1次，当`i==6`，它被按1次，总共3次，最后就是关。
38 | 
39 | 只有`i^2`这种数 ，它才会被按双数次。
40 | 
41 | * 例如 `20`，它能被它本身整除，按的次数`+1`；
42 | 
43 |   接着它能被`2`整除，那么同样它也能被`10`整除，按的次数`+2`；
44 |   
45 |   接着它能被`4`整除，那么同样它也能被`5`整除，按的次数`+2`；
46 |   
47 |   因此最后是单数。
48 | 
49 | * 例如`25`，它能被它本身整除，按的次数`+1`；
50 | 
51 |   接着能被`5`整除，因为两个`5`重复，因此按的次数`+1`；
52 |   
53 |   最终还是双数。
54 | 
55 | ```
56 | /**
57 |  * @param {number} n
58 |  * @return {number}
59 |  */
60 | var bulbSwitch = function(n) {
61 |   return Math.floor(Math.sqrt(n))
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/301-400/322.md:
--------------------------------------------------------------------------------
 1 | ### 322. 零钱兑换
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 `-1` 。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:coins = [1, 2, 5], amount = 11
17 | 输出:3 
18 | 解释: 11 = 5 + 5 + 1
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入:coins = [2], amount = 3
28 | 输出:-1
29 | ```
30 | 
31 | 
32 | **说明** :
33 | 你可以认为每种硬币的数量是无限的。
34 | 
35 | 
36 | ```
37 | /**
38 |  * @param {number[]} coins
39 |  * @param {number} amount
40 |  * @return {number}
41 |  */
42 | var coinChange = function(coins, amount) {
43 |   if(amount===0)return 0
44 |   let dp=Array(amount+1).fill(Infinity)
45 |   dp[0]=0
46 |   for(let i=0;i<dp.length;i++){
47 |     for(let j=0;j<coins.length;j++){
48 |       if(i<coins[j])continue
49 |       dp[i]=Math.min(dp[i-coins[j]]+1,dp[i])
50 |     }
51 |   }
52 |   return dp[amount]===Infinity ? -1 : dp[amount]
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/301-400/324.md:
--------------------------------------------------------------------------------
 1 | ### 324. 摆动排序 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`排序`
 6 | 
 7 | 给定一个无序的数组 `nums` ，将它重新排列成 `nums[0] < nums[1] > nums[2] < nums[3]...` 的顺序。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:nums = [1, 5, 1, 1, 6, 4]
17 | 输出:一个可能的答案是 [1, 4, 1, 5, 1, 6]
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:nums = [1, 3, 2, 2, 3, 1]
27 | 输出: 一个可能的答案是 [2, 3, 1, 3, 1, 2]
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 你可以假设所有输入都会得到有效的结果。
33 | 
34 | 
35 | 
36 | **进阶:** 
37 | 你能用O(n) 时间复杂度和 / 或原地 O(1) 额外空间来实现吗？
38 | 
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | 对`nums`从小到大排序，之后2个指针，指针1`left`初始在中间，指针2`right`初始在末尾，向左移动并且逐个配对。
47 | 
48 | ```
49 | /**
50 |  * @param {number[]} nums
51 |  * @return {void} Do not return anything, modify nums in-place instead.
52 |  */
53 | var wiggleSort = function(nums) {
54 |   let arr=nums.slice()
55 |   arr.sort((a,b)=>a-b)
56 |   var len = nums.length
57 |   var left = Math.ceil(len/2)-1
58 |   var right = len-1
59 |   for(var i = 0; i<nums.length; i++) {
60 |     if(i%2==1) {
61 |       nums[i] = arr[right--]
62 |     }else {
63 |       nums[i] = arr[left--]
64 |     }
65 |   }
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/301-400/326.md:
--------------------------------------------------------------------------------
 1 | ### 326. 3的幂
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个整数，写一个函数来判断它是否是 3的幂次方。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: 27
17 | 输出: true
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入: 0
27 | 输出: false
28 | ```
29 | 
30 | 
31 | **示例 3:** 
32 | 
33 | 
34 | 
35 | ```
36 | 输入: 9
37 | 输出: true
38 | ```
39 | 
40 | 
41 | **示例 4:** 
42 | 
43 | 
44 | 
45 | ```
46 | 输入: 45
47 | 输出: false
48 | ```
49 | 
50 | 
51 | **进阶：** 
52 | 你能不使用循环或者递归来完成本题吗？
53 | 
54 | 
55 | ```
56 | /**
57 |  * @param {number} n
58 |  * @return {boolean}
59 |  */
60 | var isPowerOfThree = function(n) {
61 |   // if(n<=0)return false
62 |   // if(n===1)return true
63 |   // if(n%3!==0)return false
64 |   // return isPowerOfThree(n/3)
65 |   
66 |   // without loop / recursion
67 |   return (n>0 && Math.pow(3,19) % n===0)
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/301-400/338.md:
--------------------------------------------------------------------------------
 1 | ### 338. 比特位计数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`、`动态规划`
 6 | 
 7 | 给定一个非负整数**num** 。对于**0 &le; i &le; num** 范围中的每个数字**i** ，计算其二进制数中的 1 的数目并将它们作为数组返回。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:2
17 | 输出:[0,1,1]
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:5
27 | 输出:[0,1,1,2,1,2]
28 | ```
29 | 
30 | 
31 | **进阶:** 
32 | 
33 | 
34 | 
35 | 
36 | * 给出时间复杂度为**O(n*sizeof(integer))** 的解答非常容易。但你可以在线性时间**O(n)** 内用一趟扫描做到吗？
37 | 
38 | * 要求算法的空间复杂度为**O(n)** 。
39 | 
40 | * 你能进一步完善解法吗？要求在C++或任何其他语言中不使用任何内置函数（如 C++ 中的**__builtin_popcount** ）来执行此操作。
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number} num
48 |  * @return {number[]}
49 |  */
50 | var countBits = function(num) {
51 |   let dp=[0,1]
52 |   let p=Math.floor(Math.log2(num))
53 |   for(let i=1;i<=p;i++){
54 |     fillpow(i)
55 |   }
56 |   function fillpow(p){
57 |     let prev=Math.pow(2,p-1)
58 |     let cur=Math.pow(2,p)
59 |     let next=Math.pow(2,p+1)
60 |     for(let i=prev;i<cur;i++){
61 |       dp[i+prev]=dp[i]
62 |     }
63 |     for(let i=cur+prev;i<next;i++){
64 |       dp[i]=dp[i-cur]+1
65 |     }
66 |   }
67 |   return dp.slice(0,num+1)
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/301-400/342.md:
--------------------------------------------------------------------------------
 1 | ### 342. 4的幂
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定一个整数 (32 位有符号整数)，请编写一个函数来判断它是否是 4的幂次方。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:16
17 | 输出:true
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:5
27 | 输出:false
28 | ```
29 | 
30 | 
31 | **进阶：** 
32 | 你能不使用循环或者递归来完成本题吗？
33 | 
34 | 
35 | ```
36 | /**
37 |  * @param {number} num
38 |  * @return {boolean}
39 |  */
40 | var isPowerOfFour = function(num) {
41 |   return num > 0 && (num & (num - 1)) == 0 && (num - 1) % 3 == 0;
42 | };
43 | ```
44 | 
45 | 


--------------------------------------------------------------------------------
/301-400/343.md:
--------------------------------------------------------------------------------
 1 | ### 343. 整数拆分
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`、`动态规划`
 6 | 
 7 | 给定一个正整数*n* ，将其拆分为**至少** 两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:2
17 | 输出:1
18 | 解释:2 = 1 + 1, 1 &times; 1 = 1。
19 | ```
20 | 
21 | 
22 | **示例2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入:10
28 | 输出:36
29 | 解释:10 = 3 + 3 + 4, 3 &times;3 &times;4 = 36。
30 | ```
31 | 
32 | 
33 | **说明:** 你可以假设*n* 不小于 2 且不大于 58。
34 | 
35 | 
36 | ```
37 | /**
38 |  * @param {number} n
39 |  * @return {number}
40 |  */
41 | var integerBreak = function(n) {
42 |     if(n===2)return 1
43 |     if(n===3)return 2
44 |     if(n===4)return 4
45 |     let res=1
46 |     while(n>4){
47 |         res*=3
48 |         n=n-3
49 |     }
50 |     return res*n
51 | //     let c={
52 | //         2:1,
53 | //         3:2,
54 | //         4:4,
55 | //         5:6,
56 | //         6:9,
57 | //     }
58 | //     if(n<7) return c[n]
59 |     
60 | //     function getMax(n){
61 | //         if(n<=4)return n
62 | //         return getMax(n-3)*3
63 | //     }
64 | //     return getMax(n)
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/301-400/344.md:
--------------------------------------------------------------------------------
 1 | ### 344. 反转字符串
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`双指针`、`字符串`
 6 | 
 7 | 编写一个函数，其作用是将输入的字符串反转过来。输入字符串以字符数组  `char[]`  的形式给出。
 8 | 
 9 | 
10 | 
11 | 不要给另外的数组分配额外的空间，你必须**[原地](https://baike.baidu.com/item/原地算法)
12 | 修改输入数组** 、使用 O(1) 的额外空间解决这一问题。
13 | 
14 | 
15 | 
16 | 你可以假设数组中的所有字符都是 [ASCII](https://baike.baidu.com/item/ASCII)
17 |  码表中的可打印字符。
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 | **示例 1：** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入：["h","e","l","l","o"]
31 | 输出：["o","l","l","e","h"]
32 | ```
33 | 
34 | 
35 | **示例 2：** 
36 | 
37 | 
38 | 
39 | ```
40 | 输入：["H","a","n","n","a","h"]
41 | 输出：["h","a","n","n","a","H"]
42 | ```
43 | 
44 | ```
45 | /**
46 |  * @param {character[]} s
47 |  * @return {void} Do not return anything, modify s in-place instead.
48 |  */
49 | var reverseString = function(s) {
50 |   for(let i=0;i<s.length/2;i++){
51 |     let t=s[i]
52 |     s[i]=s[s.length-1-i]
53 |     s[s.length-1-i]=t
54 |   }
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/301-400/345.md:
--------------------------------------------------------------------------------
 1 | ### 345. 反转字符串中的元音字母
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`双指针`、`字符串`
 6 | 
 7 | 编写一个函数，以字符串作为输入，反转该字符串中的元音字母。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:"hello"
17 | 输出:"holle"
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:"leetcode"
27 | 输出:"leotcede"
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 元音字母不包含字母"y"。
33 | 
34 | 
35 | ```
36 | /**
37 |  * @param {string} s
38 |  * @return {string}
39 |  */
40 | var reverseVowels = function(s) {
41 |   let vowels=''
42 |   for(let i=0;i<s.length;i++){
43 |     if(/[aeiouAEIOU]/.test(s[i])){
44 |       vowels+=s[i]
45 |     }
46 |   }
47 |   let j=vowels.length-1
48 |   let res=''
49 |   for(let i=0;i<s.length;i++){
50 |     if(/[aeiouAEIOU]/.test(s[i])){
51 |       res+=vowels[j--]
52 |     }else{
53 |       res+=s[i]
54 |     }
55 |   }
56 |   return res
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/301-400/349.md:
--------------------------------------------------------------------------------
 1 | ### 349. 两个数组的交集
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`排序`、`哈希表`、`双指针`、`二分查找`
 6 | 
 7 | 给定两个数组，编写一个函数来计算它们的交集。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:nums1 = [1,2,2,1], nums2 = [2,2]
17 | 输出:[2]
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:nums1 = [4,9,5], nums2 = [9,4,9,8,4]
27 | 输出:[9,4]
28 | ```
29 | 
30 | 
31 | **说明:** 
32 | 
33 | 
34 | 
35 | 
36 | * 输出结果中的每个元素一定是唯一的。
37 | 
38 | * 我们可以不考虑输出结果的顺序。
39 | 
40 | 
41 | 
42 | 
43 | ```
44 | /**
45 |  * @param {number[]} nums1
46 |  * @param {number[]} nums2
47 |  * @return {number[]}
48 |  */
49 | var intersection = function(nums1, nums2) {
50 |     let arr1=[],res=[]
51 |     for(let i=0;i<nums1.length;i++){
52 |         arr1[nums1[i]]=1
53 |     }
54 |     for(let i=0;i<nums2.length;i++){
55 |         if(arr1[nums2[i]])arr1[nums2[i]]=true
56 |     }
57 |     for(let i=0;i<arr1.length;i++){
58 |         if(arr1[i]===true)res.push(i)
59 |     }
60 |     return res
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/301-400/357.md:
--------------------------------------------------------------------------------
 1 | ### 357. 计算各个位数不同的数字个数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`、`动态规划`、`回溯算法`
 6 | 
 7 | 给定一个**非负** 整数 n，计算各位数字都不同的数字 x 的个数，其中 0 &le; x < 10n。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:2
17 | 输出:91 
18 | 解释:答案应为除去 11,22,33,44,55,66,77,88,99 外，在 [0,100) 区间内的所有数字。
19 | ```
20 | 
21 | ```
22 | /**
23 |  * @param {number} n
24 |  * @return {number}
25 |  */
26 | var countNumbersWithUniqueDigits = function(n) {
27 | 
28 |     if (n === 0) return 1;
29 |     let res = 10;
30 |     let uniqueDigits = 9;
31 |     let availableNumber = 9;
32 |     while (n-- > 1 && availableNumber > 0) {
33 |         uniqueDigits = uniqueDigits * availableNumber;
34 |         res += uniqueDigits;
35 |         availableNumber--;
36 |     }
37 |     return res;
38 | };
39 | ```
40 | 
41 | 


--------------------------------------------------------------------------------
/301-400/367.md:
--------------------------------------------------------------------------------
 1 | ### 367. 有效的完全平方数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`、`二分查找`
 6 | 
 7 | 给定一个正整数 *num* ，编写一个函数，如果 *num*  是一个完全平方数，则返回 True，否则返回 False。
 8 | 
 9 | 
10 | 
11 | **说明：** 不要使用任何内置的库函数，如  `sqrt` 。
12 | 
13 | 
14 | 
15 | **示例 1：** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入：16
21 | 输出：True
22 | ```
23 | 
24 | 
25 | **示例 2：** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入：14
31 | 输出：False
32 | ```
33 | 
34 | ```
35 | /**
36 |  * @param {number} num
37 |  * @return {boolean}
38 |  */
39 | var isPerfectSquare = function(num) {
40 |     let lo=1,
41 |         hi=Number.MAX_SAFE_INTEGER
42 |     while(lo<hi){
43 |       let mid=Math.floor((lo+hi)/2)
44 |       let cur=mid*mid
45 |       if(cur<num)lo=mid+1
46 |       else if(cur>num)hi=mid
47 |       else return true     
48 |     }
49 |     return false
50 | };
51 | ```
52 | 
53 | 


--------------------------------------------------------------------------------
/301-400/371.md:
--------------------------------------------------------------------------------
 1 | ### 371. 两整数之和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | **不使用** 运算符 `+`  和 `-` ​​​​​​​，计算两整数​​​​​​​ `a` 、 `b` ​​​​​​​之和。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:a = 1, b = 2
17 | 输出:3
18 | ```
19 | 
20 | 
21 | **示例 2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:a = -2, b = 3
27 | 输出:1
28 | ```
29 | 
30 | ```
31 | /**
32 |  * @param {number} a
33 |  * @param {number} b
34 |  * @return {number}
35 |  */
36 | var getSum = function(a, b) {
37 |     let aS=Math.abs(a),bS=Math.abs(b)
38 |     let i=Math.min(aS,bS),
39 |         j=Math.max(aS,bS);
40 |     let sum
41 |     if(a*b>0){
42 |         let t=i/j
43 |         let s=String(t)
44 |         s='1'.concat(s.substr(1))
45 |         sum=parseFloat(s)*j*((a<0 && b<0)?-1:1)
46 |     }else if(a*b<0){
47 |         let t=j/i
48 |         let s=String(t)
49 |         s='0'.concat(s.substr(1))
50 |         sum=parseFloat(s)*i*(j*-1===a||j*-1===b?-1:1)
51 |     }else if(a===0)return b
52 |     else return a
53 |     return sum
54 | };
55 | ```
56 | 
57 | 


--------------------------------------------------------------------------------
/301-400/372.md:
--------------------------------------------------------------------------------
 1 | ### 372. 超级次方
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 你的任务是计算*a* *b* 对1337 取模，*a*  是一个正整数，*b*  是一个非常大的正整数且会以数组形式给出。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:a = 2, b = [3]
17 | 输出:8
18 | ```
19 | 
20 | 
21 | **示例2:** 
22 | 
23 | 
24 | 
25 | ```
26 | 输入:a = 2, b = [1,0]
27 | 输出:1024
28 | ```
29 | 
30 | 
31 | 
32 | -----
33 | 
34 | 思路：
35 | 
36 | 一个次方的转换`a^12345 === a^5 * a^10^4 * a^100^3 * a^1000^2 * a^10000^1`
37 | 
38 | 反向遍历`b`，每次遍历`a=pow(a,10)`，然后再求`pow(a,b[i])`
39 | 
40 | 这里`pow`函数很好写，就是普通的次方再`%MOD`
41 | 
42 | ```
43 | /**
44 |  * @param {number} a
45 |  * @param {number[]} b
46 |  * @return {number}
47 |  */
48 | var superPow = function(a, b) {
49 |   let MOD=1337
50 |   let sum=1
51 |   for(let i=b.length-1;i>=0;i--){
52 |     sum = sum * getPow(a % MOD, b[i]) % MOD
53 |     a = getPow(a,10) 
54 |   }
55 |   return sum
56 |   function getPow(n,p){
57 |     let sum=1
58 |     for(let i=0;i<p;i++){
59 |       sum = sum * n % MOD
60 |     }
61 |     return sum
62 |   }  
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/301-400/383.md:
--------------------------------------------------------------------------------
 1 | ### 383. 赎金信
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个赎金信 (ransom) 字符串和一个杂志(magazine)字符串，判断第一个字符串ransom能不能由第二个字符串magazines里面的字符构成。如果可以构成，返回 true ；否则返回 false。
 8 | 
 9 | 
10 | 
11 | (题目说明：为了不暴露赎金信字迹，要从杂志上搜索各个需要的字母，组成单词来表达意思。)
12 | 
13 | 
14 | 
15 | **注意：** 
16 | 
17 | 
18 | 
19 | 你可以假设两个字符串均只含有小写字母。
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | canConstruct("a", "b") -> false
26 | canConstruct("aa", "ab") -> false
27 | canConstruct("aa", "aab") -> true
28 | ```
29 | 
30 | ```
31 | /**
32 |  * @param {string} ransomNote
33 |  * @param {string} magazine
34 |  * @return {boolean}
35 |  */
36 | var canConstruct = function(ransomNote, magazine) {
37 |   let map={},ran=ransomNote,mag=magazine
38 |   for(let i=0;i<ran.length;i++){
39 |     if(!map[ran[i]])map[ran[i]]=1
40 |     else map[ran[i]]++
41 |   }
42 |   for(let i=0;i<mag.length;i++){
43 |     if(map[mag[i]])map[mag[i]]--
44 |   }
45 | 
46 |   for(let k in map){
47 |     if(map[k]>0)return false
48 |   }
49 |   return true
50 | };
51 | ```
52 | 
53 | 


--------------------------------------------------------------------------------
/301-400/386.md:
--------------------------------------------------------------------------------
 1 | ### 386. 字典序排数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给定一个整数*n* , 返回从*1* 到*n* 的字典顺序。
 8 | 
 9 | 
10 | 
11 | 例如，
12 | 
13 | 
14 | 
15 | 给定 *n*  =1 3，返回 [1,10,11,12,13,2,3,4,5,6,7,8,9] 。
16 | 
17 | 
18 | 
19 | 请尽可能的优化算法的时间复杂度和空间复杂度。 输入的数据*n* 小于等于5,000,000。
20 | 
21 | 
22 | 
23 | 
24 | -----
25 | 
26 | 思路：
27 | 
28 | 最直观就是排序。
29 | 
30 | 时间复杂度`O(N)`的解决方案，对于以`1`开头的，存在`10,11,12...19`，对于`10`开头的，存在`100,101,102...109`；
31 | 
32 | 因此对于从`1`到`9`每一个数，递归以它们开头的每一个数字，添加到结果。
33 | 
34 | ```
35 | /**
36 |  * @param {number} n
37 |  * @return {number[]}
38 |  */
39 | var lexicalOrder = function(n) {
40 |   let result=[]
41 |   for(let i=1;i<10;i++){
42 |     dfs(result,i)
43 |   }
44 |   function dfs(result,cur){
45 |     if(cur>n)return 
46 |     result.push(cur)
47 |     for(let i=0;i<10;i++){
48 |       if((10*cur+i)>n)return
49 |       dfs(result,10*cur+i)
50 |     }        
51 |   }
52 |   return result
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/301-400/387.md:
--------------------------------------------------------------------------------
 1 | ### 387. 字符串中的第一个唯一字符
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`、`字符串`
 6 | 
 7 | 给定一个字符串，找到它的第一个不重复的字符，并返回它的索引。如果不存在，则返回 -1。
 8 | 
 9 | 
10 | 
11 | **案例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | s = "leetcode"
18 | 返回 0.
19 | 
20 | s = "loveleetcode",
21 | 返回 2.
22 | ```
23 | 
24 | 
25 | 
26 | 
27 | 
28 | 
29 | **注意事项：** 您可以假定该字符串只包含小写字母。
30 | 
31 | 
32 | ```
33 | /**
34 |  * @param {string} s
35 |  * @return {number}
36 |  */
37 | var firstUniqChar = function(s) {
38 |   let mem=Array(26).fill(0)
39 |   for(let i=0;i<s.length;i++)mem[s.charCodeAt(i)-97]++
40 |   for(let i=0;i<s.length;i++){
41 |     if(mem[s.charCodeAt(i)-97]===1)return i
42 |   }
43 |   return -1
44 | };
45 | ```
46 | 
47 | 


--------------------------------------------------------------------------------
/301-400/389.md:
--------------------------------------------------------------------------------
 1 | ### 389. 找不同
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`哈希表`
 6 | 
 7 | 给定两个字符串 ***s***  和 ***t*** ，它们只包含小写字母。
 8 | 
 9 | 
10 | 
11 | 字符串***t*** 由字符串***s*** 随机重排，然后在随机位置添加一个字母。
12 | 
13 | 
14 | 
15 | 请找出在 ***t***  中被添加的字母。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | **示例:** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入：
29 | s = "abcd"
30 | t = "abcde"
31 | 
32 | 输出：
33 | e
34 | 
35 | 解释：
36 | 'e' 是那个被添加的字母。
37 | ```
38 | 
39 | 
40 | 
41 | -----
42 | 
43 | 思路：
44 | 
45 | 一个空间复杂度`O(1)`的方法。
46 | 
47 | 对`s`遍历，将它所有字母的`ascii`值相加为`sSum`；
48 | 
49 | 对`t`遍历，将它所有字母的`ascii`值相加为`tSum`；
50 | 
51 | 最后返回`String.fromCharCode(tSum-sSum)`。
52 | 
53 | ```
54 | /**
55 |  * @param {string} s
56 |  * @param {string} t
57 |  * @return {character}
58 |  */
59 | var findTheDifference = function(s, t) {
60 |   let sSum=0,tSum=0
61 |   for(let i=0;i<t.length;i++){
62 |     tSum+=t.charCodeAt(i)
63 |   }
64 |   for(let i=0;i<s.length;i++){
65 |     sSum+=s.charCodeAt(i)
66 |   }
67 |   return String.fromCharCode(tSum-sSum)
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/401-500/400.md:
--------------------------------------------------------------------------------
 1 | ### 400. 第N个数字
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 在无限的整数序列1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ...中找到第*n* 个数字。
 8 | 
 9 | 
10 | 
11 | **注意:** 
12 | *n* 是正数且在32为整形范围内(*n*  < 231)。
13 | 
14 | 
15 | 
16 | **示例 1:** 
17 | 
18 | 
19 | 
20 | ```
21 | 
22 | 输入:
23 | 3
24 | 
25 | 输出:
26 | 3
27 | ```
28 | 
29 | 
30 | **示例 2:** 
31 | 
32 | 
33 | 
34 | ```
35 | 
36 | 输入:
37 | 11
38 | 
39 | 输出:
40 | 0
41 | 
42 | 说明:
43 | 第11个数字在序列 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, ... 里是0，它是10的一部分。
44 | ```
45 | 
46 | ```
47 | /**
48 |  * @param {number} n
49 |  * @return {number}
50 |  */
51 | var findNthDigit = function(n) {
52 |   let i=1
53 |   for(;;i++){
54 |     let m=Math.pow(10,i-1)*9*i
55 |     if(n-m<0)break
56 |     n-=m
57 |   }
58 |   let num=Math.floor(n/i)+Math.pow(10,i-1)-1, mod=n % i
59 |   let numStr=num+'',nextNumStr=num+1+''
60 |   if(mod===0)return numStr[numStr.length-1]
61 |   return nextNumStr[mod-1]
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/401-500/404.md:
--------------------------------------------------------------------------------
 1 | ### 404. 左叶子之和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 计算给定二叉树的所有左叶子之和。
 8 | 
 9 | 
10 | 
11 | **示例：** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 |     3
18 |    / \
19 |   9  20
20 |     /  \
21 |    15   7
22 | 
23 | 在这个二叉树中，有两个左叶子，分别是 9 和 15，所以返回 24
24 | ```
25 | 
26 | 
27 | 
28 | 
29 | 
30 | ```
31 | /**
32 |  * Definition for a binary tree node.
33 |  * function TreeNode(val) {
34 |  *     this.val = val;
35 |  *     this.left = this.right = null;
36 |  * }
37 |  */
38 | /**
39 |  * @param {TreeNode} root
40 |  * @return {number}
41 |  */
42 | var sumOfLeftLeaves = function(root) {
43 |   function calcLeftSum(root,left){
44 |     if(!root)return 0
45 |     let sum=0
46 |     if(root.left)sum+=calcLeftSum(root.left,true)
47 |     if(root.right)sum+=calcLeftSum(root.right,false)
48 |     if(!root.left && !root.right){
49 |       if(left)return root.val
50 |       return 0
51 |     }
52 |     return sum
53 |   }
54 |   return calcLeftSum(root,false)
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/401-500/409.md:
--------------------------------------------------------------------------------
 1 | ### 409. 最长回文串
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 给定一个包含大写字母和小写字母的字符串，找到通过这些字母构造成的最长的回文串。
 8 | 
 9 | 
10 | 
11 | 在构造过程中，请注意区分大小写。比如 `"Aa"` 不能当做一个回文字符串。
12 | 
13 | 
14 | 
15 | **注意:** 
16 | 假设字符串的长度不会超过 1010。
17 | 
18 | 
19 | 
20 | **示例 1:** 
21 | 
22 | 
23 | 
24 | ```
25 | 
26 | 输入:
27 | "abccccdd"
28 | 
29 | 输出:
30 | 7
31 | 
32 | 解释:
33 | 我们可以构造的最长的回文串是"dccaccd", 它的长度是 7。
34 | ```
35 | 
36 | 
37 | 
38 | -----
39 | 
40 | 思路：
41 | 
42 | 回文串的特点，出现频率为奇数的最多出现1次。
43 | 
44 | 使用`hash`计算出每一个字母的频率，再算出存在多少个`奇数频率`的数。
45 | 
46 | 最后返回`Math.min(s.length,s.length-odd+1)`。
47 | 
48 | 例如一个`s`有12个字母，其中频率分布为`1,3,3,5`，4个奇数，结果就是`12-4+1`，如果不存在奇数，则返回`s.length`。
49 | 
50 | ```
51 | /**
52 |  * @param {string} s
53 |  * @return {number}
54 |  */
55 | var longestPalindrome = function(s) {
56 |   let hash={}
57 |   for(let l of s){
58 |     if(hash[l]==null)hash[l]=1
59 |     else hash[l]++
60 |   }
61 |   let odd=0
62 |   for(let k in hash){
63 |     if(hash[k] % 2===1)odd++
64 |   }
65 |   return Math.min(s.length,s.length-odd+1)
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/401-500/412.md:
--------------------------------------------------------------------------------
 1 | ### 412. Fizz Buzz
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 写一个程序，输出从 1 到 *n*  数字的字符串表示。
 8 | 
 9 | 
10 | 
11 | 1. 如果*n* 是3的倍数，输出&ldquo;Fizz&rdquo;；
12 | 
13 | 
14 | 
15 | 2. 如果*n* 是5的倍数，输出&ldquo;Buzz&rdquo;；
16 | 
17 | 
18 | 
19 | 3.如果*n* 同时是3和5的倍数，输出 &ldquo;FizzBuzz&rdquo;。
20 | 
21 | 
22 | 
23 | **示例：** 
24 | 
25 | 
26 | 
27 | ```
28 | n = 15,
29 | 
30 | 返回:
31 | [
32 |     "1",
33 |     "2",
34 |     "Fizz",
35 |     "4",
36 |     "Buzz",
37 |     "Fizz",
38 |     "7",
39 |     "8",
40 |     "Fizz",
41 |     "Buzz",
42 |     "11",
43 |     "Fizz",
44 |     "13",
45 |     "14",
46 |     "FizzBuzz"
47 | ]
48 | ```
49 | 
50 | ```
51 | /**
52 |  * @param {number} n
53 |  * @return {string[]}
54 |  */
55 | var fizzBuzz = function(n) {
56 |     let res=[]
57 |     for(let i=0;i<n;i++){
58 |         if((i+1)%15===0){
59 |             res[i]="FizzBuzz"
60 |         }else if((i+1)%5===0){
61 |             res[i]="Buzz"
62 |         }else if((i+1)%3===0){
63 |             res[i]="Fizz"
64 |         }else{
65 |             res[i]=''+(i+1)
66 |         }
67 |     }
68 |     return res
69 | };
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/401-500/415.md:
--------------------------------------------------------------------------------
 1 | ### 415. 字符串相加
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定两个字符串形式的非负整数 `num1`  和 `num2` ，计算它们的和。
 8 | 
 9 | 
10 | 
11 | **注意：** 
12 | 
13 | 
14 | 
15 | 
16 | 1.  `num1`  和 `num2` 的长度都小于 5100.
17 | 
18 | 2.  `num1`  和 `num2`  都只包含数字 `0-9` .
19 | 
20 | 3.  `num1`  和 `num2`  都不包含任何前导零。
21 | 
22 | 4. **你不能使用任何內建 BigInteger 库，也不能直接将输入的字符串转换为整数形式。** 
23 | 
24 | 
25 | 
26 | 
27 | ```
28 | /**
29 |  * @param {string} num1
30 |  * @param {string} num2
31 |  * @return {string}
32 |  */
33 | var addStrings = function(num1, num2) {
34 |     let ret = '', carry = 0, i = num1.length - 1, j = num2.length - 1;
35 |     while (i >= 0 || j >= 0 || carry === 1) {
36 |         let n1 = i >= 0 ? num1[i--] : 0;
37 |         let n2 = j >= 0 ? num2[j--] : 0;
38 |         let sum = carry + n1 % 10 + n2 % 10;
39 |         carry = Math.trunc(sum / 10);
40 |         ret = (sum % 10) + ret;
41 |     }
42 |     return ret;
43 |     
44 | };
45 | ```
46 | 
47 | 


--------------------------------------------------------------------------------
/401-500/416.md:
--------------------------------------------------------------------------------
 1 | ### 416. 分割等和子集
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定一个**只包含正整数** 的**非空** 数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
 8 | 
 9 | 
10 | 
11 | **注意:** 
12 | 
13 | 
14 | 
15 | 
16 | 1. 每个数组中的元素不会超过 100
17 | 
18 | 2. 数组的大小不会超过 200
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例 1:** 
25 | 
26 | 
27 | 
28 | ```
29 | 输入: [1, 5, 11, 5]
30 | 
31 | 输出: true
32 | 
33 | 解释: 数组可以分割成 [1, 5, 5] 和 [11].
34 | ```
35 | 
36 | 
37 | 
38 | 
39 | 
40 | 
41 | **示例2:** 
42 | 
43 | 
44 | 
45 | ```
46 | 输入: [1, 2, 3, 5]
47 | 
48 | 输出: false
49 | 
50 | 解释: 数组不能分割成两个元素和相等的子集.
51 | ```
52 | 
53 | 
54 | 
55 | 
56 | 
57 | ```
58 | /**
59 |  * @param {number[]} nums
60 |  * @return {boolean}
61 |  */
62 | var canPartition = function(nums) {
63 |     let allSum=nums.reduce((sum,cur)=>sum+cur,0)
64 |     if(allSum % 2!==0)return false
65 |     let sum=allSum/2
66 |     let aux=Array(sum+1).fill(0)
67 |     aux[0]=1
68 |     for(let n of nums){
69 |         for(let i=sum;i>=n;i--){
70 |             aux[i]+=aux[i-n]
71 |         }
72 |         if(aux[sum]>0)return true
73 |     }
74 |     return false
75 | };
76 | ```
77 | 
78 | 


--------------------------------------------------------------------------------
/401-500/421.md:
--------------------------------------------------------------------------------
 1 | ### 421. 数组中两个数的最大异或值
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`位运算`、`字典树`
 6 | 
 7 | 给定一个非空数组，数组中元素为 a0, a1, a2, &hellip; , an-1，其中 0 &le; ai < 231。
 8 | 
 9 | 
10 | 
11 | 找到 ai 和aj最大的异或 (XOR) 运算结果，其中0 &le; *i* ,*j*  < *n* 。
12 | 
13 | 
14 | 
15 | 你能在O(*n* )的时间解决这个问题吗？
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: [3, 10, 5, 25, 2, 8]
26 | 
27 | 输出: 28
28 | 
29 | 解释: 最大的结果是 5 ^ 25 = 28.
30 | ```
31 | 
32 | ```
33 | /**
34 |  * @param {number[]} nums
35 |  * @return {number}
36 |  */
37 | var findMaximumXOR = function(nums) {
38 |   let max=Math.max.apply(Math,nums)
39 |   let boundry=Math.pow(2,Math.floor(Math.log2(max)))
40 |   let maxLenArr=[]
41 |   for(let i=0;i<nums.length;i++){
42 |     let cur=nums[i]
43 |     if(cur>=boundry)maxLenArr.push(cur)
44 |   }
45 |   let maxXOR=0
46 |   for(let i=0;i<maxLenArr.length;i++){
47 |     for(let j=0;j<nums.length;j++){
48 |       maxXOR=Math.max(maxXOR,maxLenArr[i]^nums[j])
49 |     }
50 |   }
51 |   return maxXOR
52 | };
53 | ```
54 | 
55 | 


--------------------------------------------------------------------------------
/401-500/429.md:
--------------------------------------------------------------------------------
 1 | ### 429. N叉树的层序遍历
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`广度优先搜索`
 6 | 
 7 | 给定一个 N 叉树，返回其节点值的*层序遍历* 。 (即从左到右，逐层遍历)。
 8 | 
 9 | 例如，给定一个 `3叉树` :
10 | 
11 | 
12 | 
13 | ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/12/narytreeexample.png)
14 | 
15 | 
16 | 
17 | 
18 | 返回其层序遍历:
19 | 
20 | ```
21 | [     [1],     [3,2,4],     [5,6]]
22 | ```
23 | 
24 | 
25 | **说明:** 
26 | 
27 | 1. 树的深度不会超过 `1000` 。
28 | 2. 树的节点总数不会超过 `5000` 。
29 | 
30 | 
31 | ```
32 | /**
33 |  * // Definition for a Node.
34 |  * function Node(val,children) {
35 |  *    this.val = val;
36 |  *    this.children = children;
37 |  * };
38 |  */
39 | /**
40 |  * @param {Node} root
41 |  * @return {number[][]}
42 |  */
43 | var levelOrder = function(root) {
44 |   if(!root)return []
45 |   let arr=[root]
46 |   let res=[]
47 |   while(arr.length>0){
48 |     let len=arr.length
49 |     let temp=[]
50 |     for(let i=0;i<len;i++){
51 |       let cur=arr.shift()
52 |       temp.push(cur.val)
53 |       for(let j=0;j<cur.children.length;j++){
54 |         arr.push(cur.children[j])
55 |       }
56 |     }
57 |     res.push(temp)
58 |   }
59 |   return res
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/401-500/434.md:
--------------------------------------------------------------------------------
 1 | ### 434. 字符串中的单词数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 统计字符串中的单词个数，这里的单词指的是连续的不是空格的字符。
 8 | 
 9 | 
10 | 
11 | 请注意，你可以假定字符串里不包括任何不可打印的字符。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: "Hello, my name is John"
21 | 输出: 5
22 | ```
23 | 
24 | ```
25 | /**
26 |  * @param {string} s
27 |  * @return {number}
28 |  */
29 | var countSegments = function(s) {
30 |   let newSeg=true
31 |   let count=0
32 |   for(let i=0;i<s.length;i++){
33 |     if(newSeg && s[i]!==' '){
34 |       count++
35 |       newSeg=false
36 |     }else if(!newSeg && s[i]===' '){
37 |       newSeg=true
38 |     }
39 |   }
40 |   return count
41 | };
42 | ```
43 | 
44 | 


--------------------------------------------------------------------------------
/401-500/441.md:
--------------------------------------------------------------------------------
 1 | ### 441. 排列硬币
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`、`二分查找`
 6 | 
 7 | 你总共有*n* 枚硬币，你需要将它们摆成一个阶梯形状，第*k* 行就必须正好有*k* 枚硬币。
 8 | 
 9 | 
10 | 
11 | 给定一个数字*n* ，找出可形成完整阶梯行的总行数。
12 | 
13 | 
14 | 
15 | *n* 是一个非负整数，并且在32位有符号整型的范围内。
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | n = 5
26 | 
27 | 硬币可排列成以下几行:
28 | &curren;
29 | &curren; &curren;
30 | &curren; &curren;
31 | 
32 | 因为第三行不完整，所以返回2.
33 | ```
34 | 
35 | 
36 | **示例 2:** 
37 | 
38 | 
39 | 
40 | ```
41 | 
42 | n = 8
43 | 
44 | 硬币可排列成以下几行:
45 | &curren;
46 | &curren; &curren;
47 | &curren; &curren; &curren;
48 | &curren; &curren;
49 | 
50 | 因为第四行不完整，所以返回3.
51 | ```
52 | 
53 | ```
54 | /**
55 |  * @param {number} n
56 |  * @return {number}
57 |  */
58 | var arrangeCoins = function(n) {
59 |   let lo=0,hi=Math.pow(2,32)+1
60 |   while(lo<hi){
61 |     let mid=Math.ceil((lo+hi)/2)
62 |     let c=(mid+1)*mid/2
63 |     if(c>n) hi=mid-1
64 |     else lo=mid
65 |   }
66 |   return lo
67 | }
68 | ```
69 | 
70 | 


--------------------------------------------------------------------------------
/401-500/442.md:
--------------------------------------------------------------------------------
 1 | ### 442. 数组中重复的数据
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个整数数组 a，其中1 &le; a[i] &le; *n*  （*n* 为数组长度）, 其中有些元素出现**两次** 而其他元素出现**一次** 。
 8 | 
 9 | 
10 | 
11 | 找到所有出现**两次** 的元素。
12 | 
13 | 
14 | 
15 | 你可以不用到任何额外空间并在O(*n* )时间复杂度内解决这个问题吗？
16 | 
17 | 
18 | 
19 | **示例：** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入:
26 | [4,3,2,7,8,2,3,1]
27 | 
28 | 输出:
29 | [2,3]
30 | ```
31 | 
32 | ```
33 | /**
34 |  * @param {number[]} nums
35 |  * @return {number[]}
36 |  */
37 | var findDuplicates = function(nums) {
38 |     let res=[];
39 |     for(let i=0;i<nums.length;i++){
40 |         let abs=Math.abs(nums[i]);
41 |         if(nums[abs-1]>0){
42 |             nums[abs-1]*=-1
43 |         }else{
44 |             res.push(abs)
45 |         }
46 |     }
47 |     return res
48 | };
49 | ```
50 | 
51 | 


--------------------------------------------------------------------------------
/401-500/448.md:
--------------------------------------------------------------------------------
 1 | ### 448. 找到所有数组中消失的数字
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个范围在 1 &le; a[i] &le; *n*  (*n*  = 数组大小 ) 的 整型数组，数组中的元素一些出现了两次，另一些只出现一次。
 8 | 
 9 | 
10 | 
11 | 找到所有在 [1, *n* ] 范围之间没有出现在数组中的数字。
12 | 
13 | 
14 | 
15 | 您能在不使用额外空间且时间复杂度为*O(n)* 的情况下完成这个任务吗? 你可以假定返回的数组不算在额外空间内。
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入:
26 | [4,3,2,7,8,2,3,1]
27 | 
28 | 输出:
29 | [5,6]
30 | ```
31 | 
32 | ```
33 | /**
34 |  * @param {number[]} nums
35 |  * @return {number[]}
36 |  */
37 | var findDisappearedNumbers = function(nums) {
38 | //     let arr=[]
39 | //     for(let i=0;i<nums.length;i++){
40 | //         let curAbs=Math.abs(nums[i])
41 | //         if(nums[curAbs-1]<0)continue;
42 | //         else nums[curAbs-1]=-nums[curAbs-1]
43 | //     }
44 |     
45 | //     for(let i=0;i<nums.length;i++){
46 | //         if(nums[i]>0)arr.push(i+1)
47 | //     }
48 | //     return arr
49 |     
50 |     let arr=[];
51 |     let len=nums.length;
52 |     for(let i=0;i<len;i++){
53 |         nums[(nums[i]-1) % len]+=len
54 |     }
55 |     for(let i=0;i<len;i++){
56 |         if(nums[i]<=len)arr.push(i+1)
57 |     }
58 |     return arr
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/401-500/453.md:
--------------------------------------------------------------------------------
 1 | ### 453. 最小移动次数使数组元素相等
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个长度为 *n*  的**非空** 整数数组，找到让数组所有元素相等的最小移动次数。每次移动可以使 *n*  - 1 个元素增加 1。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入:
18 | [1,2,3]
19 | 
20 | 输出:
21 | 3
22 | 
23 | 解释:
24 | 只需要3次移动（注意每次移动会增加两个元素的值）：
25 | 
26 | [1,2,3]  =>  [2,3,3]  =>  [3,4,3]  =>  [4,4,4]
27 | ```
28 | 
29 | ```
30 | /**
31 |  * @param {number[]} nums
32 |  * @return {number}
33 |  */
34 | var minMoves = function(nums) {
35 |   let sum=0
36 |   for(let n of nums)sum+=n
37 |   let min=Math.min.apply(Math,nums)
38 |   return sum-min*nums.length
39 | };
40 | ```
41 | 
42 | 


--------------------------------------------------------------------------------
/401-500/459.md:
--------------------------------------------------------------------------------
 1 | ### 459. 重复的子字符串
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个非空的字符串，判断它是否可以由它的一个子串重复多次构成。给定的字符串只含有小写英文字母，并且长度不超过10000。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: "abab"
18 | 
19 | 输出: True
20 | 
21 | 解释: 可由子字符串 "ab" 重复两次构成。
22 | ```
23 | 
24 | 
25 | **示例 2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 
31 | 输入: "aba"
32 | 
33 | 输出: False
34 | ```
35 | 
36 | 
37 | **示例 3:** 
38 | 
39 | 
40 | 
41 | ```
42 | 
43 | 输入: "abcabcabcabc"
44 | 
45 | 输出: True
46 | 
47 | 解释: 可由子字符串 "abc" 重复四次构成。 (或者子字符串 "abcabc" 重复两次构成。)
48 | ```
49 | 
50 | ```
51 | /**
52 |  * @param {string} s
53 |  * @return {boolean}
54 |  */
55 | var repeatedSubstringPattern = function(s) {
56 |   let ss=(s+s).substring(1,s.length*2-1)
57 |   return ss.includes(s)
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/401-500/461.md:
--------------------------------------------------------------------------------
 1 | ### 461. 汉明距离
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 两个整数之间的[汉明距离](https://baike.baidu.com/item/%E6%B1%89%E6%98%8E%E8%B7%9D%E7%A6%BB)
 8 | 指的是这两个数字对应二进制位不同的位置的数目。
 9 | 
10 | 
11 | 
12 | 给出两个整数  `x`  和  `y` ，计算它们之间的汉明距离。
13 | 
14 | 
15 | 
16 | **注意：** 
17 | 0 &le;  `x` ,  `y`  < 231.
18 | 
19 | 
20 | 
21 | **示例:** 
22 | 
23 | 
24 | 
25 | ```
26 | 
27 | 输入: x = 1, y = 4
28 | 
29 | 输出: 2
30 | 
31 | 解释:
32 | 1   (0 0 0 1)
33 | 4   (0 1 0 0)
34 |        &uarr;   &uarr;
35 | 
36 | 上面的箭头指出了对应二进制位不同的位置。
37 | ```
38 | 
39 | 
40 | 
41 | -----
42 | 
43 | 思路：
44 | 
45 | 两个数(a,b)的海明距离就是`a^b`后存在`1`的数量。
46 | 
47 | ```
48 | /**
49 |  * @param {number} x
50 |  * @param {number} y
51 |  * @return {number}
52 |  */
53 | var hammingDistance = function(x, y) {
54 |   let xor=x^y
55 |   let res=0
56 |   while(xor>0){
57 |     if(xor % 2===1)res++
58 |     xor=xor>>1
59 |   }
60 |   return res
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/401-500/462.md:
--------------------------------------------------------------------------------
 1 | ### 462. 最少移动次数使数组元素相等 II
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个非空整数数组，找到使所有数组元素相等所需的最小移动数，其中每次移动可将选定的一个元素加1或减1。 您可以假设数组的长度最多为10000。
 8 | 
 9 | 
10 | 
11 | **例如:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入:
18 | [1,2,3]
19 | 
20 | 输出:
21 | 2
22 | 
23 | 说明：只有两个动作是必要的（记得每一步仅可使其中一个元素加1或减1）： 
24 | 
25 | [1,2,3]  =>  [2,2,3]  =>  [2,2,2]
26 | ```
27 | 
28 | ```
29 | /**
30 |  * @param {number[]} nums
31 |  * @return {number}
32 |  */
33 | var minMoves2 = function(nums) {
34 |   nums.sort((a,b)=>a-b)
35 |   let allSteps=0
36 |   let mid=nums[Math.floor(nums.length/2)]
37 |   for(let i=0;i<nums.length;i++){
38 |       allSteps+=Math.abs(mid-nums[i])
39 |   }
40 |   return allSteps
41 | };
42 | ```
43 | 
44 | 


--------------------------------------------------------------------------------
/401-500/476.md:
--------------------------------------------------------------------------------
 1 | ### 476. 数字的补数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定一个正整数，输出它的补数。补数是对该数的二进制表示取反。
 8 | 
 9 | 
10 | 
11 | **注意:** 
12 | 
13 | 
14 | 
15 | 
16 | 1. 给定的整数保证在32位带符号整数的范围内。
17 | 
18 | 2. 你可以假定二进制数不包含前导零位。
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例 1:** 
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 输入: 5
31 | 输出: 2
32 | 解释: 5的二进制表示为101（没有前导零位），其补数为010。所以你需要输出2。
33 | ```
34 | 
35 | 
36 | **示例 2:** 
37 | 
38 | 
39 | 
40 | ```
41 | 
42 | 输入: 1
43 | 输出: 0
44 | 解释: 1的二进制表示为1（没有前导零位），其补数为0。所以你需要输出0。
45 | ```
46 | 
47 | 
48 | 
49 | -----
50 | 
51 | 思路：
52 | 
53 | 1. 转换成二进制，然后反转`0`和`1`。
54 | 
55 | 2. 对一个数`num`，只要求出当前它的位数的最大值`n`，它的补数就是`num ^ n`。
56 | 
57 | 例如：`num:5`，它的位数是`3(101)`，那么3位的最大值就是`7(111)`，它的补数就是`5^7`。
58 | 
59 | ```
60 | /**
61 |  * @param {number} num
62 |  * @return {number}
63 |  */
64 | var findComplement = function(num) {
65 |   return num ^ (Math.pow(2,Math.floor(Math.log2(num))+1)-1)
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/401-500/485.md:
--------------------------------------------------------------------------------
 1 | ### 485. 最大连续1的个数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个二进制数组， 计算其中最大连续1的个数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: [1,1,0,1,1,1]
18 | 输出: 3
19 | 解释: 开头的两位和最后的三位都是连续1，所以最大连续1的个数是 3.
20 | ```
21 | 
22 | 
23 | **注意：** 
24 | 
25 | 
26 | 
27 | 
28 | * 输入的数组只包含 `0`  和 `1` 。
29 | 
30 | * 输入数组的长度是正整数，且不超过 10,000。
31 | 
32 | 
33 | 
34 | 
35 | ```
36 | /**
37 |  * @param {number[]} nums
38 |  * @return {number}
39 |  */
40 | var findMaxConsecutiveOnes = function(nums) {
41 |     let curCount=0,maxCount=0;
42 |     for(let i=0;i<nums.length;i++){
43 |         if(nums[i]!==1){
44 |             if(curCount>maxCount){
45 |                 maxCount=curCount
46 |             }
47 |             curCount=0;
48 |             continue;
49 |         }
50 |         curCount++;
51 |     }
52 |     return Math.max(maxCount,curCount)
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/401-500/492.md:
--------------------------------------------------------------------------------
 1 | ### 492. 构造矩形
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 作为一位web开发者， 懂得怎样去规划一个页面的尺寸是很重要的。 现给定一个具体的矩形页面面积，你的任务是设计一个长度为 L 和宽度为 W 且满足以下要求的矩形的页面。要求：
 8 | 
 9 | 
10 | 
11 | ```
12 | 
13 | 1. 你设计的矩形页面必须等于给定的目标面积。
14 | 
15 | 2. 宽度 W 不应大于长度 L，换言之，要求 L >= W 。
16 | 
17 | 3. 长度 L 和宽度 W 之间的差距应当尽可能小。
18 | ```
19 | 
20 | 
21 | 你需要按顺序输出你设计的页面的长度 L 和宽度 W。
22 | 
23 | 
24 | 
25 | **示例：** 
26 | 
27 | 
28 | 
29 | ```
30 | 
31 | 输入: 4
32 | 输出: [2, 2]
33 | 解释: 目标面积是 4， 所有可能的构造方案有 [1,4], [2,2], [4,1]。
34 | 但是根据要求2，[1,4] 不符合要求; 根据要求3，[2,2] 比 [4,1] 更能符合要求. 所以输出长度 L 为 2， 宽度 W 为 2。
35 | ```
36 | 
37 | 
38 | **说明:** 
39 | 
40 | 
41 | 
42 | 
43 | 1. 给定的面积不大于 10,000,000 且为正整数。
44 | 
45 | 2. 你设计的页面的长度和宽度必须都是正整数。
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | -----
53 | 
54 | 思路：
55 | 
56 | 因为`width`一定不大于`height`，因此`width`的最大值就是`Math.sqrt(area)`，遍历`width`递减到`1`，如果存在`area % i===0`，当前`i`就是结果`width`。
57 | 
58 | ```
59 | /**
60 |  * @param {number} area
61 |  * @return {number[]}
62 |  */
63 | var constructRectangle = function(area) {
64 |   let maxWidth=Math.floor(Math.sqrt(area))
65 |   for(let i=maxWidth;i>=1;i--){
66 |     if(area % i===0)return [area/i,i]
67 |   }
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/501-600/504.md:
--------------------------------------------------------------------------------
 1 | ### 504. 七进制数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给定一个整数，将其转化为7进制，并以字符串形式输出。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 100
18 | 输出: "202"
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 
28 | 输入: -7
29 | 输出: "-10"
30 | ```
31 | 
32 | 
33 | **注意:**  输入范围是[-1e7, 1e7] 。
34 | 
35 | 
36 | 
37 | 
38 | -----
39 | 
40 | 思路：
41 | 
42 | 先判断正负，然后对`num`的绝对值进行转换。
43 | 
44 | ```
45 | /**
46 |  * @param {number} num
47 |  * @return {string}
48 |  */
49 | var convertToBase7 = function(num) {
50 |   let syb=num<0?'-':''
51 |   num=Math.abs(num)
52 |   let str=''
53 |   while(num>0){
54 |     str=(num % 7)+str
55 |     num=Math.floor(num/7)
56 |   }
57 |   if(str==='')return '0'
58 |   return syb+str
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/501-600/507.md:
--------------------------------------------------------------------------------
 1 | ### 507. 完美数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 对于一个**正整数** ，如果它和除了它自身以外的所有正因子之和相等，我们称它为&ldquo;完美数&rdquo;。
 8 | 
 9 | 
10 | 
11 | 给定一个**正整数**  `n` ，如果他是完美数，返回 `True` ，否则返回 `False` 
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例：** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: 28
26 | 输出: True
27 | 解释: 28 = 1 + 2 + 4 + 7 + 14
28 | ```
29 | 
30 | 
31 | 
32 | 
33 | 
34 | 
35 | **注意:** 
36 | 
37 | 
38 | 
39 | 输入的数字**`n`**  不会超过 100,000,000. (1e8)
40 | 
41 | 
42 | ```
43 | /**
44 |  * @param {number} num
45 |  * @return {boolean}
46 |  */
47 | var checkPerfectNumber = function(num) {
48 |   if(num===1)return false
49 |   let sqrt=Math.floor(Math.sqrt(num))
50 |   let sum=1
51 |   for(let i=2;i<=sqrt;i++){
52 |     if(num % i===0){
53 |       sum+=i
54 |       sum+=num/i
55 |     }
56 |   }
57 |   // console.log(sum)
58 |   return sum===num
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/501-600/509.md:
--------------------------------------------------------------------------------
 1 | ### 509. 斐波那契数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | **斐波那契数** ，通常用 `F(n)`  表示，形成的序列称为**斐波那契数列** 。该数列由 `0`  和  `1`  开始，后面的每一项数字都是前面两项数字的和。也就是：
 8 | 
 9 | 
10 | 
11 | ```
12 | F(0) = 0, F(1)= 1
13 | F(N) = F(N - 1) + F(N - 2), 其中 N > 1.
14 | ```
15 | 
16 | 
17 | 给定 `N` ，计算 `F(N)` 。
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 | **示例 1：** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入：2
31 | 输出：1
32 | 解释：F(2) = F(1) + F(0) = 1 + 0 = 1.
33 | ```
34 | 
35 | 
36 | **示例 2：** 
37 | 
38 | 
39 | 
40 | ```
41 | 输入：3
42 | 输出：2
43 | 解释：F(3) = F(2) + F(1) = 1 + 1 = 2.
44 | ```
45 | 
46 | 
47 | **示例 3：** 
48 | 
49 | 
50 | 
51 | ```
52 | 输入：4
53 | 输出：3
54 | 解释：F(4) = F(3) + F(2) = 2 + 1 = 3.
55 | ```
56 | 
57 | 
58 | 
59 | 
60 | 
61 | 
62 | **提示：** 
63 | 
64 | 
65 | 
66 | 
67 | * 0 &le;  `N`  &le; 30
68 | 
69 | 
70 | 
71 | 
72 | ```
73 | /**
74 |  * @param {number} N
75 |  * @return {number}
76 |  */
77 | var fib = function(N) {
78 |   let dp=[0,1]  
79 |   for(let i=2;i<=N;i++){
80 |     dp[i]=dp[i-1]+dp[i-2]
81 |   }
82 |   return dp[N]
83 | };
84 | ```
85 | 
86 | 


--------------------------------------------------------------------------------
/501-600/515.md:
--------------------------------------------------------------------------------
 1 | ### 515. 在每个树行中找最大值
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`、`广度优先搜索`
 6 | 
 7 | 您需要在二叉树的每一行中找到最大的值。
 8 | 
 9 | 
10 | 
11 | **示例：** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 
18 | 
19 |           1
20 |          / \
21 |         3   2
22 |        / \   \  
23 |       5   3   9 
24 | 
25 | 输出: [1, 3, 9]
26 | ```
27 | 
28 | ```
29 | /**
30 |  * Definition for a binary tree node.
31 |  * function TreeNode(val) {
32 |  *     this.val = val;
33 |  *     this.left = this.right = null;
34 |  * }
35 |  */
36 | /**
37 |  * @param {TreeNode} root
38 |  * @return {number[]}
39 |  */
40 | var largestValues = function(root) {
41 |   if(!root)return []
42 |   let ans=[]
43 |   let arr=[root]
44 |   while(arr.length>0){
45 |     let len=arr.length
46 |     let maxV=-Infinity
47 |     for(let i=0;i<len;i++){
48 |       let node=arr.shift()
49 |       maxV=Math.max(maxV,node.val)
50 |       if(node.left)arr.push(node.left)
51 |       if(node.right)arr.push(node.right)
52 |     }
53 |     ans.push(maxV)
54 |   }
55 |   return ans
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/501-600/516.md:
--------------------------------------------------------------------------------
 1 | ### 516. 最长回文子序列
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 给定一个字符串 `s` ，找到其中最长的回文子序列。可以假设 `s` 的最大长度为 `1000` 。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 输入:
13 | 
14 | 
15 | 
16 | ```
17 | 
18 | "bbbab"
19 | ```
20 | 
21 | 
22 | 输出:
23 | 
24 | 
25 | 
26 | ```
27 | 
28 | 4
29 | ```
30 | 
31 | 
32 | 一个可能的最长回文子序列为 "bbbb"。
33 | 
34 | 
35 | 
36 | **示例 2:** 
37 | 输入:
38 | 
39 | 
40 | 
41 | ```
42 | 
43 | "cbbd"
44 | ```
45 | 
46 | 
47 | 输出:
48 | 
49 | 
50 | 
51 | ```
52 | 
53 | 2
54 | ```
55 | 
56 | 
57 | 一个可能的最长回文子序列为 "bb"。
58 | 
59 | 
60 | ```
61 | /**
62 |  * @param {string} s
63 |  * @return {number}
64 |  */
65 | var longestPalindromeSubseq = function(s) {
66 |    let mem=[]
67 |    for(let i=0;i<s.length;i++) mem[i]=[]
68 |    return lps(s,0,s.length-1)
69 |    function lps(str,start,end){
70 |        if(start>end)return 0
71 |        if(start===end)return 1
72 |        if(mem[start][end])return mem[start][end]
73 |        let res
74 |        if(str[start]===str[end]) res= lps(str,start+1,end-1)+2
75 |        else res=Math.max(lps(str,start+1,end),lps(str,start,end-1))
76 |        mem[start][end]=res
77 |        return res
78 |    }
79 | };
80 | ```
81 | 
82 | 


--------------------------------------------------------------------------------
/501-600/520.md:
--------------------------------------------------------------------------------
 1 | ### 520. 检测大写字母
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个单词，你需要判断单词的大写使用是否正确。
 8 | 
 9 | 
10 | 
11 | 我们定义，在以下情况时，单词的大写用法是正确的：
12 | 
13 | 
14 | 
15 | 
16 | 1. 全部字母都是大写，比如"USA"。
17 | 
18 | 2. 单词中所有字母都不是大写，比如"leetcode"。
19 | 
20 | 3. 如果单词不只含有一个字母，只有首字母大写，比如"Google"。
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 否则，我们定义这个单词没有正确使用大写字母。
27 | 
28 | 
29 | 
30 | **示例 1:** 
31 | 
32 | 
33 | 
34 | ```
35 | 
36 | 输入: "USA"
37 | 输出: True
38 | ```
39 | 
40 | 
41 | **示例 2:** 
42 | 
43 | 
44 | 
45 | ```
46 | 
47 | 输入: "FlaG"
48 | 输出: False
49 | ```
50 | 
51 | 
52 | **注意:**  输入是由大写和小写拉丁字母组成的非空单词。
53 | 
54 | 
55 | ```
56 | /**
57 |  * @param {string} word
58 |  * @return {boolean}
59 |  */
60 | var detectCapitalUse = function(word) {
61 |   if(word.length===1)return true
62 |   let allUpp=word.charCodeAt(0)<97 && word.charCodeAt(1)<97 ? true : false
63 |   return assert(word,allUpp)
64 |   
65 |   function assert(word,allUpp){
66 |     for(let i=1;i<word.length;i++){
67 |       if(allUpp && word.charCodeAt(i)>=97)return false
68 |       else if(!allUpp && word.charCodeAt(i)<97)return false
69 |     }      
70 |     return true
71 |   }
72 | };
73 | ```
74 | 
75 | 


--------------------------------------------------------------------------------
/501-600/521.md:
--------------------------------------------------------------------------------
 1 | ### 521. 最长特殊序列 Ⅰ
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定两个字符串，你需要从这两个字符串中找出最长的特殊序列。最长特殊序列定义如下：该序列为某字符串独有的最长子序列（即不能是其他字符串的子序列）。
 8 | 
 9 | 
10 | 
11 | **子序列** 可以通过删去字符串中的某些字符实现，但不能改变剩余字符的相对顺序。空序列为所有字符串的子序列，任何字符串为其自身的子序列。
12 | 
13 | 
14 | 
15 | 输入为两个字符串，输出最长特殊序列的长度。如果不存在，则返回 -1。
16 | 
17 | 
18 | 
19 | **示例 :** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入: "aba", "cdc"
25 | 输出: 3
26 | 解析: 最长特殊序列可为 "aba" (或 "cdc")
27 | ```
28 | 
29 | 
30 | **说明:** 
31 | 
32 | 
33 | 
34 | 
35 | 1. 两个字符串长度均小于100。
36 | 
37 | 2. 字符串中的字符仅含有'a'~'z'。
38 | 
39 | 
40 | 
41 | 
42 | ```
43 | /**
44 |  * @param {string} a
45 |  * @param {string} b
46 |  * @return {number}
47 |  */
48 | var findLUSlength = function(a, b) {
49 |   let aLen=a.length;
50 |   let bLen=b.length;
51 |   if(aLen===0 && bLen===0 || a===b){
52 |       return -1
53 |   }else if(aLen>bLen){
54 |       return aLen
55 |   }else{
56 |       return bLen
57 |   }
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/501-600/523.md:
--------------------------------------------------------------------------------
 1 | ### 523. 连续的子数组和
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`、`动态规划`
 6 | 
 7 | 给定一个包含**非负数** 的数组和一个目标**整数** k，编写一个函数来判断该数组是否含有连续的子数组，其大小至少为 2，总和为 **k**  的倍数，即总和为 n*k，其中 n 也是一个**整数** 。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [23,2,4,6,7], k = 6
17 | 输出: True
18 | 解释: [2,4] 是一个大小为 2 的子数组，并且和为 6。
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 输入: [23,2,6,4,7], k = 6
28 | 输出: True
29 | 解释: [23,2,6,4,7]是大小为 5 的子数组，并且和为 42。
30 | ```
31 | 
32 | 
33 | **说明:** 
34 | 
35 | 
36 | 
37 | 
38 | 1. 数组的长度不会超过10,000。
39 | 
40 | 2. 你可以认为所有数字总和在 32 位有符号整数范围内。
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number[]} nums
48 |  * @param {number} k
49 |  * @return {boolean}
50 |  */
51 | var checkSubarraySum = function(nums, k) {
52 |   let sums=[]
53 |   for(let i=0;i<nums.length;i++){
54 |     sums[i]=nums[i]+(i>0?sums[i-1]:0)
55 |     if(i>0 && ((sums[i] % k===0) || (sums[i]===k)))return true
56 |   }
57 | 
58 |   if(k===0)return false
59 |   let dp=[]
60 |   for(let i=0;i<sums.length;i++){
61 |     let m=sums[i] % k
62 |     if(dp[m]!=null){
63 |       if(i-dp[m]>1)return true
64 |     }else{
65 |       dp[m]=i
66 |     }
67 |   }    
68 |   return false
69 | 
70 | };
71 | ```
72 | 
73 | 


--------------------------------------------------------------------------------
/501-600/525.md:
--------------------------------------------------------------------------------
 1 | ### 525. 连续数组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 给定一个二进制数组, 找到含有相同数量的 0 和 1 的最长连续子数组（的长度）。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: [0,1]
21 | 输出: 2
22 | 说明: [0, 1] 是具有相同数量0和1的最长连续子数组。
23 | ```
24 | 
25 | 
26 | **示例 2:** 
27 | 
28 | 
29 | 
30 | ```
31 | 输入: [0,1,0]
32 | 输出: 2
33 | 说明: [0, 1] (或 [1, 0]) 是具有相同数量0和1的最长连续子数组。
34 | ```
35 | 
36 | 
37 | 
38 | 
39 | 
40 | 
41 | **注意:** 给定的二进制数组的长度不会超过50000。
42 | 
43 | 
44 | 
45 | 
46 | -----
47 | 
48 | 思路：
49 | 
50 | 假设给定一个数组`[0,1,0,0,0,1]`，他们的前缀和是`[0,1,1,1,1,2]`
51 | 
52 | 这并不能看出什么有效的信息，但如果将`0`替换成`1`后，变为`[-1,1,-1,-1,-1,1]`，他们的前缀和是`[-1,0,-1,-2,-3,-2]`
53 | 
54 | 可以看出，当存在相同的前缀和时，说明这是一个`0`和`1`都相等的子数组。
55 | 
56 | ```
57 | /**
58 |  * @param {number[]} nums
59 |  * @return {number}
60 |  */
61 | var findMaxLength = function(nums) {
62 |   let aux=nums.map(n=>n===0?-1:1)
63 |   let hash={0:-1},maxLen=0
64 |   let sum=0
65 |   for(let i=0;i<aux.length;i++){
66 |     sum+=aux[i]
67 |     if(hash[sum]==null)hash[sum]=i
68 |     else{
69 |       maxLen=Math.max(maxLen,i-hash[sum])
70 |     }
71 |   }
72 |   return maxLen
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/501-600/530.md:
--------------------------------------------------------------------------------
 1 | ### 530. 二叉搜索树的最小绝对差
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个所有节点为非负值的二叉搜索树，求树中任意两节点的差的绝对值的最小值。
 8 | 
 9 | 
10 | 
11 | **示例 :** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入:
18 | 
19 |    1
20 |     \
21 |      3
22 |     /
23 |    2
24 | 
25 | 输出:
26 | 1
27 | 
28 | 解释:最小绝对差为1，其中 2 和 1 的差的绝对值为 1（或者 2 和 3）。
29 | ```
30 | 
31 | 
32 | **注意:** 树中至少有2个节点。
33 | 
34 | 
35 | 
36 | 
37 | -----
38 | 
39 | 思路：
40 | 
41 | 与`NO.783`一致，根据`BST`的性质，使用中序排列(从小到大)，依次检查每一个节点值的差距。
42 | 
43 | ```
44 | /**
45 |  * Definition for a binary tree node.
46 |  * function TreeNode(val) {
47 |  *     this.val = val;
48 |  *     this.left = this.right = null;
49 |  * }
50 |  */
51 | /**
52 |  * @param {TreeNode} root
53 |  * @return {number}
54 |  */
55 | var getMinimumDifference = function(root) {
56 |   let last
57 |   let min=Infinity
58 |   function dfs(node){
59 |     if(!node)return
60 |     if(node.left)dfs(node.left)
61 |     if(last==null){
62 |       last=node.val
63 |     }else{
64 |       let cur=node.val-last
65 |       if(cur<min)min=cur
66 |       last=node.val
67 |     }
68 |     if(node.right)dfs(node.right)
69 |   }
70 |   dfs(root)
71 |   return min     
72 | };
73 | ```
74 | 
75 | 


--------------------------------------------------------------------------------
/501-600/538.md:
--------------------------------------------------------------------------------
 1 | ### 538. 把二叉搜索树转换为累加树
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个二叉搜索树（Binary Search Tree），把它转换成为累加树（Greater Tree)，使得每个节点的值是原来的节点值加上所有大于它的节点值之和。
 8 | 
 9 | 
10 | 
11 | **例如：** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 二叉搜索树:
18 |               5
19 |             /   \
20 |            2     13
21 | 
22 | 输出: 转换为累加树:
23 |              18
24 |             /   \
25 |           20     13
26 | ```
27 | 
28 | ```
29 | /**
30 |  * Definition for a binary tree node.
31 |  * function TreeNode(val) {
32 |  *     this.val = val;
33 |  *     this.left = this.right = null;
34 |  * }
35 |  */
36 | /**
37 |  * @param {TreeNode} root
38 |  * @return {TreeNode}
39 |  */
40 | var convertBST = function(root) {
41 |   if(!root)return root
42 |   function dfs(root,sum){
43 |     if(root.right) sum=dfs(root.right,sum)
44 |     root.val+=sum
45 |     sum=root.val
46 |     if(root.left) sum=dfs(root.left,sum)
47 |     return sum
48 |   }
49 |   dfs(root,0)
50 |   return root
51 | };
52 | ```
53 | 
54 | 


--------------------------------------------------------------------------------
/501-600/541.md:
--------------------------------------------------------------------------------
 1 | ### 541. 反转字符串 II
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个字符串和一个整数 k，你需要对从字符串开头算起的每个 2k 个字符的前k个字符进行反转。如果剩余少于 k 个字符，则将剩余的所有全部反转。如果有小于 2k 但大于或等于 k 个字符，则反转前 k 个字符，并将剩余的字符保持原样。
 8 | 
 9 | 
10 | 
11 | **示例:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: s = "abcdefg", k = 2
18 | 输出: "bacdfeg"
19 | ```
20 | 
21 | 
22 | **要求:** 
23 | 
24 | 
25 | 
26 | 
27 | 1. 该字符串只包含小写的英文字母。
28 | 
29 | 2. 给定字符串的长度和 k 在[1, 10000]范围内。
30 | 
31 | 
32 | 
33 | 
34 | ```
35 | /**
36 |  * @param {string} s
37 |  * @param {number} k
38 |  * @return {string}
39 |  */
40 | var reverseStr = function(s, k) {
41 |   let arr=s.split('')
42 |   let rest=arr.length % (2*k)
43 |   // console.log(rest)
44 |   for(let i=0;i<arr.length-rest;i+=2*k){
45 |     reverse(arr,i,k)
46 |   }
47 |   
48 |   if(rest<k){
49 |     reverse(arr,arr.length-rest,rest)
50 |   }else{
51 |     reverse(arr,arr.length-rest,k)
52 |   }
53 |   return arr.join('')
54 |   function swap(arr,i,j){
55 |     let t=arr[i]
56 |     arr[i]=arr[j]
57 |     arr[j]=t
58 |   }
59 |   function reverse(arr,start,len){
60 |     // console.log(start,len)
61 |     for(let i=0;i<len/2;i++){
62 |       swap(arr,start+i,start+len-i-1)
63 |     }
64 |   }
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/501-600/543.md:
--------------------------------------------------------------------------------
 1 | ### 543. 二叉树的直径
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一棵二叉树，你需要计算它的直径长度。一棵二叉树的直径长度是任意两个结点路径长度中的最大值。这条路径可能穿过根结点。
 8 | 
 9 | 
10 | 
11 | **示例 :** 
12 | 给定二叉树
13 | 
14 | 
15 | 
16 | ```
17 | 
18 |           1
19 |          / \
20 |         2   3
21 |        / \     
22 |       4   5    
23 | ```
24 | 
25 | 
26 | 返回**3** , 它的长度是路径 [4,2,1,3] 或者[5,2,1,3]。
27 | 
28 | 
29 | 
30 | **注意：** 两结点之间的路径长度是以它们之间边的数目表示。
31 | 
32 | 
33 | ```
34 | /**
35 |  * Definition for a binary tree node.
36 |  * function TreeNode(val) {
37 |  *     this.val = val;
38 |  *     this.left = this.right = null;
39 |  * }
40 |  */
41 | /**
42 |  * @param {TreeNode} root
43 |  * @return {number}
44 |  */
45 | var diameterOfBinaryTree = function(root) {
46 |   let max=0
47 |   function dfs(root){
48 |     if(!root)return 0
49 |     let left=dfs(root.left),
50 |         right=dfs(root.right)
51 |     max=Math.max(max,left+right)
52 |     return Math.max(left,right)+1
53 |   }
54 |   dfs(root)
55 |   return max
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/501-600/551.md:
--------------------------------------------------------------------------------
 1 | ### 551. 学生出勤记录 I
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个字符串来代表一个学生的出勤记录，这个记录仅包含以下三个字符：
 8 | 
 9 | 
10 | 
11 | 
12 | 1. **'A'**  : Absent，缺勤
13 | 
14 | 2. **'L'**  : Late，迟到
15 | 
16 | 3. **'P'**  : Present，到场
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 如果一个学生的出勤记录中不**超过一个'A'(缺勤)** 并且**不超过两个连续的'L'(迟到)** ,那么这个学生会被奖赏。
23 | 
24 | 
25 | 
26 | 你需要根据这个学生的出勤记录判断他是否会被奖赏。
27 | 
28 | 
29 | 
30 | **示例 1:** 
31 | 
32 | 
33 | 
34 | ```
35 | 输入: "PPALLP"
36 | 输出: True
37 | ```
38 | 
39 | 
40 | **示例 2:** 
41 | 
42 | 
43 | 
44 | ```
45 | 输入: "PPALLL"
46 | 输出: False
47 | ```
48 | 
49 | ```
50 | /**
51 |  * @param {string} s
52 |  * @return {boolean}
53 |  */
54 | var checkRecord = function(s) {
55 |   if(s.includes("LLL"))return false
56 |   let A=0
57 |   for(let r of s)if(r==="A")A++
58 |   return A<2
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/501-600/557.md:
--------------------------------------------------------------------------------
 1 | ### 557. 反转字符串中的单词 III
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个字符串，你需要反转字符串中每个单词的字符顺序，同时仍保留空格和单词的初始顺序。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: "Let's take LeetCode contest"
18 | 输出: "s'teL ekat edoCteeL tsetnoc"********
19 | ```
20 | 
21 | 
22 | ********注意：******** 在字符串中，每个单词由单个空格分隔，并且字符串中不会有任何额外的空格。
23 | 
24 | 
25 | ```
26 | /**
27 |  * @param {string} s
28 |  * @return {string}
29 |  */
30 | var reverseWords = function(s) {
31 |   let arr=s.split(' ')
32 |   for(let i=0;i<arr.length;i++){
33 |     arr[i]=arr[i].split('').reverse().join('')
34 |   }
35 |   return arr.join(' ')
36 | };
37 | ```
38 | 
39 | 


--------------------------------------------------------------------------------
/501-600/559.md:
--------------------------------------------------------------------------------
 1 | ### 559. N叉树的最大深度
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`、`深度优先搜索`、`广度优先搜索`
 6 | 
 7 | 给定一个 N 叉树，找到其最大深度。
 8 | 
 9 | 最大深度是指从根节点到最远叶子节点的最长路径上的节点总数。
10 | 
11 | 例如，给定一个 `3叉树` :
12 | 
13 | 
14 | 
15 | ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/12/narytreeexample.png)
16 | 
17 | 
18 | 
19 | 
20 | 我们应返回其最大深度，3。
21 | 
22 | **说明:** 
23 | 
24 | 1. 树的深度不会超过 `1000` 。
25 | 2. 树的节点总不会超过 `5000` 。
26 | 
27 | 
28 | ```
29 | /**
30 |  * // Definition for a Node.
31 |  * function Node(val,children) {
32 |  *    this.val = val;
33 |  *    this.children = children;
34 |  * };
35 |  */
36 | /**
37 |  * @param {Node} root
38 |  * @return {number}
39 |  */
40 | var maxDepth = function(root) {
41 |   if(!root)return 0
42 |   let subh=0
43 |   for(let i=0;i<root.children.length;i++){
44 |     subh=Math.max(subh,maxDepth(root.children[i]))
45 |   }
46 |   return subh+1
47 | };
48 | ```
49 | 
50 | 


--------------------------------------------------------------------------------
/501-600/560.md:
--------------------------------------------------------------------------------
 1 | ### 560. 和为K的子数组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`哈希表`
 6 | 
 7 | 给定一个整数数组和一个整数**k，** 你需要找到该数组中和为**k** 的连续的子数组的个数。
 8 | 
 9 | 
10 | 
11 | **示例 1 :** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入:nums = [1,1,1], k = 2
18 | 输出: 2 , [1,1] 与 [1,1] 为两种不同的情况。
19 | ```
20 | 
21 | 
22 | **说明 :** 
23 | 
24 | 
25 | 
26 | 
27 | 1. 数组的长度为 [1, 20,000]。
28 | 
29 | 2. 数组中元素的范围是 [-1000, 1000] ，且整数**k** 的范围是[-1e7, 1e7]。
30 | 
31 | 
32 | 
33 | 
34 | 
35 | 
36 | -----
37 | 
38 | 思路：
39 | 
40 | 在`nums`数组中，`SUM(0,i)`表示从索引`0`到索引`i`之间的和。
41 |     
42 | 1. 如果`SUM(0,i)-k==0`，那么说明`[0,i]`这个子数组符合要求。
43 | 2. 如果`SUM(0,i)-k==SUM(0,j)`，那么说明`[j,i]`这个子数组符合要求。
44 | 
45 | 根据以上两点，只需要定义个`hash`，用来保存之前的`SUM`出现的**次数**，遍历时再检查`SUM(0,i)-k`是否存在于`hash`中。
46 | 
47 | ```
48 | /**
49 |  * @param {number[]} nums
50 |  * @param {number} k
51 |  * @return {number}
52 |  */
53 | var subarraySum = function(nums, k) {
54 |   let map={},result=0,sum=0
55 |   map[0]=1
56 |   for(let i=0;i<nums.length;i++){
57 |     sum+=nums[i]
58 |     result+=map[sum-k]||0
59 |     if(!map[sum])map[sum]=1
60 |     else map[sum]++
61 |   }
62 |   return result
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/501-600/561.md:
--------------------------------------------------------------------------------
 1 | ### 561. 数组拆分 I
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定长度为**2n** 的数组, 你的任务是将这些数分成**n** 对, 例如 (a1, b1), (a2, b2), ..., (an, bn) ，使得从1 到n 的 min(ai, bi) 总和最大。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: [1,4,3,2]
18 | 
19 | 输出: 4
20 | 解释: n 等于 2, 最大总和为 4 = min(1, 2) + min(3, 4).
21 | ```
22 | 
23 | 
24 | **提示:** 
25 | 
26 | 
27 | 
28 | 
29 | 1. **n** 是正整数,范围在 [1, 10000].
30 | 
31 | 2. 数组中的元素范围在 [-10000, 10000].
32 | 
33 | 
34 | 
35 | 
36 | ```
37 | /**
38 |  * @param {number[]} nums
39 |  * @return {number}
40 |  */
41 | var arrayPairSum = function(nums) {
42 |     let sum=0;
43 | function shell(arr){
44 |   function swap(arr,i,j){
45 |     let tem=arr[i];
46 |     arr[i]=arr[j];
47 |     arr[j]=tem;
48 |   }
49 |   let len=arr.length;
50 |   let n=len;
51 |   let h=1;
52 |   while(h<Math.floor(n/3))h=3*h+1
53 |   while(h>=1){
54 |     for(let i=h;i<n;i++){
55 |       for(let j=i;j>=h && arr[j]<arr[j-h];j-=h){
56 |         swap(arr,j,j-h)
57 |       }
58 | 
59 |     }
60 |     h=Math.floor(h/3)
61 |   }
62 | }
63 |   
64 |     shell(nums);
65 |     for(let i=0;i<nums.length;i=i+2){
66 |         sum+=nums[i]
67 |     }
68 |     return sum;
69 | };
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/501-600/563.md:
--------------------------------------------------------------------------------
 1 | ### 563. 二叉树的坡度
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个二叉树，计算**整个树** 的坡度。
 8 | 
 9 | 
10 | 
11 | 一个树的**节点的坡度** 定义即为，该节点左子树的结点之和和右子树结点之和的**差的绝对值** 。空结点的的坡度是0。
12 | 
13 | 
14 | 
15 | **整个树** 的坡度就是其所有节点的坡度之和。
16 | 
17 | 
18 | 
19 | **示例:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: 
26 |          1
27 |        /   \
28 |       2     3
29 | 输出: 1
30 | 解释: 
31 | 结点的坡度 2 : 0
32 | 结点的坡度 3 : 0
33 | 结点的坡度 1 : |2-3| = 1
34 | 树的坡度 : 0 + 0 + 1 = 1
35 | ```
36 | 
37 | 
38 | **注意:** 
39 | 
40 | 
41 | 
42 | 
43 | 1. 任何子树的结点的和不会超过32位整数的范围。
44 | 
45 | 2. 坡度的值不会超过32位整数的范围。
46 | 
47 | 
48 | 
49 | 
50 | ```
51 | /**
52 |  * Definition for a binary tree node.
53 |  * function TreeNode(val) {
54 |  *     this.val = val;
55 |  *     this.left = this.right = null;
56 |  * }
57 |  */
58 | /**
59 |  * @param {TreeNode} root
60 |  * @return {number}
61 |  */
62 | var findTilt = function(root) {
63 |   let sum=0
64 |   function dfs(root){
65 |     if(!root)return 0
66 |     let leftSum=dfs(root.left),
67 |         rightSum=dfs(root.right)
68 |     sum+=Math.abs(leftSum-rightSum)
69 |     return leftSum+rightSum+root.val
70 |   }
71 |   dfs(root)
72 |   return sum
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/501-600/565.md:
--------------------------------------------------------------------------------
 1 | ### 565. 数组嵌套
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 索引从 `0` 开始长度为 `N` 的数组 `A` ，包含 `0` 到 `N - 1` 的所有整数。找到并返回最大的集合 `S` ， `S[i] = {A[i], A[A[i]], A[A[A[i]]], ... }` 且遵守以下的规则。
 8 | 
 9 | 
10 | 
11 | 假设选择索引为 `i` 的元素 `A[i]` 为 `S` 的第一个元素， `S` 的下一个元素应该是 `A[A[i]]` ，之后是 `A[A[A[i]]]...`  以此类推，不断添加直到 `S` 出现重复的元素。
12 | 
13 | 
14 | 
15 | **示例1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: A = [5,4,0,3,1,6,2]
22 | 输出: 4
23 | 解释: 
24 | A[0] = 5, A[1] = 4, A[2] = 0, A[3] = 3, A[4] = 1, A[5] = 6, A[6] = 2.
25 | 
26 | 其中一种最长的 S[K]:
27 | S[0] = {A[0], A[5], A[6], A[2]} = {5, 6, 2, 0}
28 | ```
29 | 
30 | 
31 | **注意:** 
32 | 
33 | 
34 | 
35 | 
36 | 1.  `N` 是 `[1, 20,000]` 之间的整数。
37 | 
38 | 2.  `A` 中不含有重复的元素。
39 | 
40 | 3.  `A` 中的元素大小在 `[0, N-1]` 之间。
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number[]} nums
48 |  * @return {number}
49 |  */
50 | var arrayNesting = function(nums) {
51 |     let cache={}
52 |     let max=0
53 |     for(let i=0;i<nums.length;i++){
54 |         let cur=nums[i]
55 |         let count=0
56 |         while(cache[cur]===undefined){
57 |             cache[cur]=1
58 |             count++
59 |             cur=nums[cur]
60 |         }
61 |         if(count>max)max=count
62 |     }
63 |     return max
64 | };
65 | ```
66 | 
67 | 


--------------------------------------------------------------------------------
/501-600/575.md:
--------------------------------------------------------------------------------
 1 | ### 575. 分糖果
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 给定一个**偶数** 长度的数组，其中不同的数字代表着不同种类的糖果，每一个数字代表一个糖果。你需要把这些糖果**平均** 分给一个弟弟和一个妹妹。返回妹妹可以获得的最大糖果的种类数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: candies = [1,1,2,2,3,3]
18 | 输出: 3
19 | 解析:一共有三种种类的糖果，每一种都有两个。
20 |      最优分配方案：妹妹获得[1,2,3],弟弟也获得[1,2,3]。这样使妹妹获得糖果的种类数最多。
21 | ```
22 | 
23 | 
24 | **示例 2 :** 
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 输入: candies = [1,1,2,3]
31 | 输出: 2
32 | 解析: 妹妹获得糖果[2,3],弟弟获得糖果[1,1]，妹妹有两种不同的糖果，弟弟只有一种。这样使得妹妹可以获得的糖果种类数最多。
33 | ```
34 | 
35 | 
36 | **注意:** 
37 | 
38 | 
39 | 
40 | 
41 | 1. 数组的长度为[2, 10,000]，并且确定为偶数。
42 | 
43 | 1. 数组中数字的大小在范围[-100,000, 100,000]内。
44 | 
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | 
55 | -----
56 | 
57 | 思路：
58 | 
59 | 先计算出所有糖果的种类`K`，两人平均分糖果，如果能分到的`len/2`小于`K`，那么只能选`len/2`
60 | 
61 | 如果`len/2`大于`K`，那么就可以优先将所有种类糖果拿走，再补上缺少的，因此最终返回`Math.min(len/2,K)`。
62 | 
63 | ```
64 | /**
65 |  * @param {number[]} candies
66 |  * @return {number}
67 |  */
68 | var distributeCandies = function(candies) {
69 |   let kinds=new Set(candies).size;
70 |   return Math.min(candies.length/2,kinds)
71 | };
72 | ```
73 | 
74 | 


--------------------------------------------------------------------------------
/501-600/581.md:
--------------------------------------------------------------------------------
 1 | ### 581. 最短无序连续子数组
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个整数数组，你需要寻找一个**连续的子数组** ，如果对这个子数组进行升序排序，那么整个数组都会变为升序排序。
 8 | 
 9 | 
10 | 
11 | 你找到的子数组应是**最短** 的，请输出它的长度。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: [2, 6, 4, 8, 10, 9, 15]
22 | 输出: 5
23 | 解释: 你只需要对 [6, 4, 8, 10, 9] 进行升序排序，那么整个表都会变为升序排序。
24 | ```
25 | 
26 | 
27 | **说明 :** 
28 | 
29 | 
30 | 
31 | 
32 | 1. 输入的数组长度范围在[1, 10,000]。
33 | 
34 | 2. 输入的数组可能包含**重复** 元素，所以**升序** 的意思是**<=。** 
35 | 
36 | 
37 | 
38 | 
39 | ```
40 | /**
41 |  * @param {number[]} nums
42 |  * @return {number}
43 |  */
44 | var findUnsortedSubarray = function(nums) {
45 |   let n = nums.length;
46 |   let mx = nums[0];
47 |   let mn = nums[n-1];
48 |   let start = -1, end = -2;
49 |   for(let i = 1; i < nums.length; i++){
50 |       mx = Math.max(mx, nums[i]);
51 |       mn = Math.min(mn, nums[n-i-1]);
52 |       if( mx > nums[i]) end = i;
53 |       if(mn < nums[n-1-i]) start = n - 1 - i;
54 |   }
55 |   return end - start +1;
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/501-600/583.md:
--------------------------------------------------------------------------------
 1 | ### 583. 两个字符串的删除操作
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定两个单词*word1* 和*word2* ，找到使得*word1* 和*word2* 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: "sea", "eat"
18 | 输出: 2
19 | 解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"
20 | ```
21 | 
22 | 
23 | **说明:** 
24 | 
25 | 
26 | 
27 | 
28 | 1. 给定单词的长度不超过500。
29 | 
30 | 2. 给定单词中的字符只含有小写字母。
31 | 
32 | 
33 | 
34 | 
35 | ```
36 | /**
37 |  * @param {string} word1
38 |  * @param {string} word2
39 |  * @return {number}
40 |  */
41 | var minDistance = function(a, b) {
42 |   let aL=a.length,bL=b.length;
43 |   let arr=[]
44 |   for(let i=0;i<=aL;i++){
45 |     arr[i]=[]
46 |     for(let j=0;j<=bL;j++){
47 |       arr[i][j]=0
48 |     }
49 |   }
50 |   for(let i=1;i<=aL;i++){
51 |     for(let j=1;j<=bL;j++){
52 |       if(a[i-1]===b[j-1]){
53 |         arr[i][j]=arr[i-1][j-1]+1
54 |       }else{
55 |         arr[i][j]=Math.max(arr[i-1][j],arr[i][j-1])
56 |       }
57 |     }
58 |   }
59 |  
60 |   return aL+bL-2*arr[aL][bL]
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/501-600/589.md:
--------------------------------------------------------------------------------
 1 | ### 589. N叉树的前序遍历
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个 N 叉树，返回其节点值的*前序遍历* 。
 8 | 
 9 | 例如，给定一个 `3叉树` :
10 | 
11 | 
12 | 
13 | ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/12/narytreeexample.png)
14 | 
15 | 
16 | 
17 | 
18 | 返回其前序遍历:  `[1,3,5,6,2,4]` 。
19 | 
20 | 
21 | 
22 | **说明:** 递归法很简单，你可以使用迭代法完成此题吗?
23 | 
24 | ```
25 | /**
26 |  * // Definition for a Node.
27 |  * function Node(val,children) {
28 |  *    this.val = val;
29 |  *    this.children = children;
30 |  * };
31 |  */
32 | /**
33 |  * @param {Node} root
34 |  * @return {number[]}
35 |  */
36 | var preorder = function(root) {
37 |   if(!root)return []
38 |   let stack=[root],res=[]
39 |   while(stack.length>0 ){
40 |     let node=stack.pop()
41 |     res.push(node.val)
42 |     for(let i=node.children.length-1;i>=0;i--){
43 |       stack.push(node.children[i])
44 |     }
45 |   }
46 |   return res
47 | };
48 | ```
49 | 
50 | 


--------------------------------------------------------------------------------
/501-600/590.md:
--------------------------------------------------------------------------------
 1 | ### 590. N叉树的后序遍历
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个 N 叉树，返回其节点值的*后序遍历* 。
 8 | 
 9 | 例如，给定一个 `3叉树` :
10 | 
11 | 
12 | 
13 | ![](https://assets.leetcode-cn.com/aliyun-lc-upload/uploads/2018/10/12/narytreeexample.png)
14 | 
15 | 
16 | 
17 | 
18 | 返回其后序遍历:  `[5,6,3,2,4,1]` .
19 | 
20 | 
21 | 
22 | **说明:** 递归法很简单，你可以使用迭代法完成此题吗?
23 | 
24 | ```
25 | /**
26 |  * // Definition for a Node.
27 |  * function Node(val,children) {
28 |  *    this.val = val;
29 |  *    this.children = children;
30 |  * };
31 |  */
32 | /**
33 |  * @param {Node} root
34 |  * @return {number[]}
35 |  */
36 | var postorder = function(root) {
37 |   if(!root)return []
38 |   let stack=[root],res=[]
39 |   while(stack.length>0 ){
40 |     let node=stack.pop()
41 |     res.push(node.val)
42 |     for(let i=0;i<node.children.length;i++){
43 |       stack.push(node.children[i])
44 |     }
45 |   }
46 |   return res.reverse()
47 | };
48 | ```
49 | 
50 | 


--------------------------------------------------------------------------------
/501-600/593.md:
--------------------------------------------------------------------------------
 1 | ### 593. 有效的正方形
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定二维空间中四点的坐标，返回四点是否可以构造一个正方形。
 8 | 
 9 | 
10 | 
11 | 一个点的坐标（x，y）由一个有两个整数的整数数组表示。
12 | 
13 | 
14 | 
15 | **示例:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: p1 = [0,0], p2 = [1,1], p3 = [1,0], p4 = [0,1]
22 | 输出: True
23 | ```
24 | 
25 | 
26 | 
27 | 
28 | 
29 | 
30 | **注意:** 
31 | 
32 | 
33 | 
34 | 
35 | 1. 所有输入整数都在 [-10000，10000] 范围内。
36 | 
37 | 2. 一个有效的正方形有四个等长的正长和四个等角（90度角）。
38 | 
39 | 3. 输入点没有顺序。
40 | 
41 | 
42 | 
43 | 
44 | ```
45 | /**
46 |  * @param {number[]} p1
47 |  * @param {number[]} p2
48 |  * @param {number[]} p3
49 |  * @param {number[]} p4
50 |  * @return {boolean}
51 |  */
52 | var validSquare = function(p1, p2, p3, p4) {
53 |   function getDis(p1,p2){
54 |     let mins=[p1[0]-p2[0],p1[1]-p2[1]]
55 |     let dis=Math.sqrt(Math.pow(mins[0],2)+Math.pow(mins[1],2))
56 |     return dis
57 |   }
58 |   let d1=getDis(p1,p2)
59 |   if(!d1||d1!==getDis(p3,p4))return false
60 |   let d2=getDis(p1,p3)
61 |   if(!d2||d2!==getDis(p2,p4))return false 
62 |   let d3=getDis(p1,p4)
63 |   if(!d3||d3!==getDis(p2,p3))return false
64 |   if(d1!==d2 && d2!==d3 && d3!==d1)return false
65 |   return true
66 | };
67 | ```
68 | 
69 | 


--------------------------------------------------------------------------------
/501-600/594.md:
--------------------------------------------------------------------------------
 1 | ### 594. 最长和谐子序列
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 和谐数组是指一个数组里元素的最大值和最小值之间的差别正好是1。
 8 | 
 9 | 
10 | 
11 | 现在，给定一个整数数组，你需要在所有可能的子序列中找到最长的和谐子序列的长度。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: [1,3,2,2,5,2,3,7]
22 | 输出: 5
23 | 原因: 最长的和谐数组是：[3,2,2,2,3].
24 | ```
25 | 
26 | 
27 | **说明:**  输入的数组长度最大不超过20,000.
28 | 
29 | 
30 | 
31 | 
32 | -----
33 | 
34 | 思路：
35 | 
36 | 首先通过`hash`将每一个数字的频率保存。
37 | 
38 | 然后对每一个`hash[k]`，找出是否存在`hash[k+1]`，如果存在`hash[k+1]`，那么就和最大长度`maxLen`比较。
39 | 
40 | 最后返回`maxLen`，注意，只需要比较`hash[k+1]`，不需要比较`hash[k-1]`，因为每一个数字都是连锁的。
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @return {number}
46 |  */
47 | var findLHS = function(nums) {
48 |   let hash={}
49 |   for(let n of nums){
50 |     if(hash[n]==null)hash[n]=1
51 |     else hash[n]++
52 |   }
53 |   let maxLen=0
54 |   for(let k in hash){
55 |     let nxt=+k+1
56 |     if(hash[nxt]>0)maxLen=Math.max(maxLen,hash[k]+hash[nxt])
57 |   }
58 |   return maxLen
59 | };
60 | ```
61 | 
62 | 


--------------------------------------------------------------------------------
/601-700/605.md:
--------------------------------------------------------------------------------
 1 | ### 605. 种花问题
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 假设你有一个很长的花坛，一部分地块种植了花，另一部分却没有。可是，花卉不能种植在相邻的地块上，它们会争夺水源，两者都会死去。
 8 | 
 9 | 
10 | 
11 | 给定一个花坛（表示为一个数组包含0和1，其中0表示没种植花，1表示种植了花），和一个数**n** 。能否在不打破种植规则的情况下种入**n** 朵花？能则返回True，不能则返回False。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: flowerbed = [1,0,0,0,1], n = 1
22 | 输出: True
23 | ```
24 | 
25 | 
26 | **示例 2:** 
27 | 
28 | 
29 | 
30 | ```
31 | 
32 | 输入: flowerbed = [1,0,0,0,1], n = 2
33 | 输出: False
34 | ```
35 | 
36 | 
37 | **注意:** 
38 | 
39 | 
40 | 
41 | 
42 | 1. 数组内已种好的花不会违反种植规则。
43 | 
44 | 2. 输入的数组长度范围为 [1, 20000]。
45 | 
46 | 3. **n**  是非负整数，且不会超过输入数组的大小。
47 | 
48 | 
49 | 
50 | 
51 | ```
52 | /**
53 |  * @param {number[]} flowerbed
54 |  * @param {number} n
55 |  * @return {boolean}
56 |  */
57 | var canPlaceFlowers = function(flowerbed, n) {
58 |   if(n===0)return true
59 | 
60 |   for(let i=0;i<flowerbed.length;i++){
61 |     if(flowerbed[i]===0){
62 |       if((flowerbed[i-1]===0 || i===0) &&
63 |          (flowerbed[i+1]===0 || i===flowerbed.length-1)){
64 |         n--
65 |         flowerbed[i]=1
66 |       }
67 |     }
68 |     if(n===0)return true
69 |   }
70 |   return false
71 | };
72 | ```
73 | 
74 | 


--------------------------------------------------------------------------------
/601-700/611.md:
--------------------------------------------------------------------------------
 1 | ### 611. 有效三角形的个数
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个包含非负整数的数组，你的任务是统计其中可以组成三角形三条边的三元组个数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: [2,2,3,4]
18 | 输出: 3
19 | 解释:
20 | 有效的组合是: 
21 | 2,3,4 (使用第一个 2)
22 | 2,3,4 (使用第二个 2)
23 | 2,2,3
24 | ```
25 | 
26 | 
27 | **注意:** 
28 | 
29 | 
30 | 
31 | 
32 | 1. 数组长度不超过1000。
33 | 
34 | 2. 数组里整数的范围为 [0, 1000]。
35 | 
36 | 
37 | 
38 | 
39 | ```
40 | /**
41 |  * @param {number[]} nums
42 |  * @return {number}
43 |  */
44 | var triangleNumber = function(nums) {
45 |     let sum=0
46 |     nums.sort((a,b)=>a-b)
47 |     for(let i=nums.length-1;i>=2;i--){
48 |         let l=0,r=i-1
49 |         while(l<r){
50 |             if(nums[l]+nums[r]>nums[i]){
51 |                 sum+=r-l
52 |                 r--
53 |             }else
54 |                 l++
55 |         }
56 |     }
57 |     return sum
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/601-700/621.md:
--------------------------------------------------------------------------------
 1 | ### 621. 任务调度器
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`贪心算法`、`队列`、`数组`
 6 | 
 7 | 给定一个用字符数组表示的 CPU 需要执行的任务列表。其中包含使用大写的 A - Z 字母表示的26 种不同种类的任务。任务可以以任意顺序执行，并且每个任务都可以在 1 个单位时间内执行完。CPU 在任何一个单位时间内都可以执行一个任务，或者在待命状态。
 8 | 
 9 | 
10 | 
11 | 然而，两个**相同种类** 的任务之间必须有长度为**n** 的冷却时间，因此至少有连续 n 个单位时间内 CPU 在执行不同的任务，或者在待命状态。
12 | 
13 | 
14 | 
15 | 你需要计算完成所有任务所需要的**最短时间** 。
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: tasks = ["A","A","A","B","B","B"], n = 2
26 | 输出: 8
27 | 执行顺序: A -> B -> (待命) -> A -> B -> (待命) -> A -> B.
28 | ```
29 | 
30 | 
31 | **注：** 
32 | 
33 | 
34 | 
35 | 
36 | 1. 任务的总个数为[1, 10000]。
37 | 
38 | 2. n 的取值范围为 [0, 100]。
39 | 
40 | 
41 | 
42 | 
43 | ```
44 | /**
45 |  * @param {character[]} tasks
46 |  * @param {number} n
47 |  * @return {number}
48 |  */
49 | var leastInterval = function(tasks, n) {
50 |   let c = Array(26).fill(0)
51 |   let acode='A'.charCodeAt(0)
52 |   for(let t of tasks){
53 |       c[t.charCodeAt(0)-acode]++;
54 |   }
55 |   c.sort((a,b)=>a-b)
56 |   let i = 25;
57 |   while(i >= 0 && c[i] == c[25]) i--;
58 | 
59 |   return Math.max(tasks.length, (c[25] - 1) * (n + 1) + 25 - i);
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/601-700/628.md:
--------------------------------------------------------------------------------
 1 | ### 628. 三个数的最大乘积
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`、`数学`
 6 | 
 7 | 给定一个整型数组，在数组中找出由三个数组成的最大乘积，并输出这个乘积。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: [1,2,3]
18 | 输出: 6
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 
28 | 输入: [1,2,3,4]
29 | 输出: 24
30 | ```
31 | 
32 | 
33 | **注意:** 
34 | 
35 | 
36 | 
37 | 
38 | 1. 给定的整型数组长度范围是[3,104]，数组中所有的元素范围是[-1000, 1000]。
39 | 
40 | 2. 输入的数组中任意三个数的乘积不会超出32位有符号整数的范围。
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number[]} nums
48 |  * @return {number}
49 |  */
50 | var maximumProduct = function(nums) {
51 |   nums.sort((a,b)=>b-a)
52 |   let f=nums[0]
53 |   
54 |   if(f<0){
55 |     return f*nums[1]*nums[2]
56 |   }else{
57 |     return f*Math.max(nums[1]*nums[2],nums[nums.length-1]*nums[nums.length-2])
58 |   }
59 |   
60 | };
61 | ```
62 | 
63 | 


--------------------------------------------------------------------------------
/601-700/633.md:
--------------------------------------------------------------------------------
 1 | ### 633. 平方数之和
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定一个非负整数 `c` ，你要判断是否存在两个整数  `a`  和  `b` ，使得a2 + b2 = c。
 8 | 
 9 | 
10 | 
11 | **示例1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 5
18 | 输出: True
19 | 解释: 1 * 1 + 2 * 2 = 5
20 | ```
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | **示例2:** 
28 | 
29 | 
30 | 
31 | ```
32 | 
33 | 输入: 3
34 | 输出: False
35 | ```
36 | 
37 | ```
38 | /**
39 |  * @param {number} c
40 |  * @return {boolean}
41 |  */
42 | var judgeSquareSum = function(c) {
43 |   let limit=Math.floor(Math.sqrt(c))
44 |   for(let i=0;i<=limit;i++){
45 |     let r=Math.sqrt(c-i*i)
46 |     if(r===Math.floor(r))return true
47 |   }
48 |   return false
49 | };
50 | ```
51 | 
52 | 


--------------------------------------------------------------------------------
/601-700/637.md:
--------------------------------------------------------------------------------
 1 | ### 637. 二叉树的层平均值
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个非空二叉树, 返回一个由每层节点平均值组成的数组.
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入:
17 |     3
18 |    / \
19 |   9  20
20 |     /  \
21 |    15   7
22 | 输出: [3, 14.5, 11]
23 | 解释:
24 | 第0层的平均值是 3,  第1层是 14.5, 第2层是 11. 因此返回 [3, 14.5, 11].
25 | ```
26 | 
27 | 
28 | **注意：** 
29 | 
30 | 
31 | 
32 | 
33 | 1. 节点值的范围在32位有符号整数范围内。
34 | 
35 | 
36 | 
37 | 
38 | ```
39 | /**
40 |  * Definition for a binary tree node.
41 |  * function TreeNode(val) {
42 |  *     this.val = val;
43 |  *     this.left = this.right = null;
44 |  * }
45 |  */
46 | /**
47 |  * @param {TreeNode} root
48 |  * @return {number[]}
49 |  */
50 | var averageOfLevels = function(root) {
51 |   if(!root)return []
52 |   let res=[],arr=[root]
53 |   while(arr.length>0){
54 |     let len=arr.length,sum=0
55 |     for(let i=0;i<len;i++){
56 |       let node=arr.shift()
57 |       sum+=node.val
58 |       if(node.left)arr.push(node.left)
59 |       if(node.right)arr.push(node.right)
60 |     }
61 |     res.push(sum/len)
62 |   }
63 |   return res
64 | };
65 | ```
66 | 
67 | 


--------------------------------------------------------------------------------
/601-700/643.md:
--------------------------------------------------------------------------------
 1 | ### 643. 子数组最大平均数 I
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定  `n`  个整数，找出平均数最大且长度为  `k`  的连续子数组，并输出该最大平均数。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: [1,12,-5,-6,50,3], k = 4
17 | 输出: 12.75
18 | 解释: 最大平均数 (12-5-6+50)/4 = 51/4 = 12.75
19 | ```
20 | 
21 | 
22 | 
23 | 
24 | 
25 | 
26 | **注意:** 
27 | 
28 | 
29 | 
30 | 
31 | 1. 1 <=  `k`  <=  `n`  <= 30,000。
32 | 
33 | 2. 所给数据范围 [-10,000，10,000]。
34 | 
35 | 
36 | 
37 | 
38 | ```
39 | /**
40 |  * @param {number[]} nums
41 |  * @param {number} k
42 |  * @return {number}
43 |  */
44 | var findMaxAverage = function(nums, k) {
45 |   let sum=0
46 |   let len=Math.min(k,nums.length)
47 |   for(let i=0;i<len;i++) sum+=nums[i]
48 |   let maxAvg=sum/k
49 |   for(let i=1;i<nums.length-k+1;i++){
50 |     sum=sum-nums[i-1]+nums[i+k-1]
51 |     let curAvg=(sum)/k
52 |     if(curAvg>maxAvg)maxAvg=curAvg
53 |   }
54 |   return maxAvg
55 | };
56 | ```
57 | 
58 | 


--------------------------------------------------------------------------------
/601-700/645.md:
--------------------------------------------------------------------------------
 1 | ### 645. 错误的集合
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`、`数学`
 6 | 
 7 | 集合  `S`  包含从1到 `n` 的整数。不幸的是，因为数据错误，导致集合里面某一个元素复制了成了集合里面的另外一个元素的值，导致集合丢失了一个整数并且有一个元素重复。
 8 | 
 9 | 
10 | 
11 | 给定一个数组  `nums`  代表了集合  `S`  发生错误后的结果。你的任务是首先寻找到重复出现的整数，再找到丢失的整数，将它们以数组的形式返回。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: nums = [1,2,2,4]
22 | 输出: [2,3]
23 | ```
24 | 
25 | 
26 | **注意:** 
27 | 
28 | 
29 | 
30 | 
31 | 1. 给定数组的长度范围是[2, 10000]。
32 | 
33 | 2. 给定的数组是无序的。
34 | 
35 | 
36 | 
37 | 
38 | ```
39 | /**
40 |  * @param {number[]} nums
41 |  * @return {number[]}
42 |  */
43 | var findErrorNums = function(nums) {
44 |   let mem=Array(nums.length).fill(false),
45 |       err=null
46 |   for(let i=0;i<nums.length;i++){
47 |     if(mem[nums[i]-1])err=nums[i]
48 |     mem[nums[i]-1]=true
49 |   }
50 |   for(let i=0;i<mem.length;i++){
51 |     if(!mem[i])return [err,i+1]
52 |   }
53 | };
54 | ```
55 | 
56 | 


--------------------------------------------------------------------------------
/601-700/650.md:
--------------------------------------------------------------------------------
 1 | ### 650. 只有两个键的键盘
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 最初在一个记事本上只有一个字符 'A'。你每次可以对这个记事本进行两种操作：
 8 | 
 9 | 
10 | 
11 | 
12 | 1.  `Copy All`  (复制全部) : 你可以复制这个记事本中的所有字符(部分的复制是不允许的)。
13 | 
14 | 2.  `Paste`  (粘贴) : 你可以粘贴你**上一次** 复制的字符。
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 给定一个数字 `n` 。你需要使用最少的操作次数，在记事本中打印出**恰好**  `n` 个 'A'。输出能够打印出 `n` 个 'A' 的最少操作次数。
21 | 
22 | 
23 | 
24 | **示例 1:** 
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 输入: 3
31 | 输出: 3
32 | 解释:
33 | 最初, 我们只有一个字符 'A'。
34 | 第 1 步, 我们使用 Copy All 操作。
35 | 第 2 步, 我们使用 Paste操作来获得 'AA'。
36 | 第 3 步, 我们使用 Paste 操作来获得 'AAA'。
37 | ```
38 | 
39 | 
40 | **说明:** 
41 | 
42 | 
43 | 
44 | 
45 | 1.  `n` 的取值范围是 [1, 1000] 。
46 | 
47 | 
48 | 
49 | 
50 | ```
51 | /**
52 |  * @param {number} n
53 |  * @return {number}
54 |  */
55 | var minSteps = function(n) {
56 |     // let steps={
57 |     //     1:0,
58 |     // }
59 |     let sum=0
60 |     function iter(n){
61 |         if(n===1)return
62 |         let i=2
63 |         while(n%i!==0){
64 |             i++
65 |         }
66 |         sum+=i
67 |         iter(n/i)
68 |     }
69 | 
70 |     iter(n)
71 |     return sum
72 | };
73 | ```
74 | 
75 | 


--------------------------------------------------------------------------------
/601-700/657.md:
--------------------------------------------------------------------------------
 1 | ### 657. 机器人能否返回原点
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 在二维平面上，有一个机器人从原点 (0, 0) 开始。给出它的移动顺序，判断这个机器人在完成移动后是否在**(0, 0) 处结束** 。
 8 | 
 9 | 
10 | 
11 | 移动顺序由字符串表示。字符 move[i] 表示其第 i 次移动。机器人的有效动作有 `R` （右）， `L` （左）， `U` （上）和  `D` （下）。如果机器人在完成所有动作后返回原点，则返回 true。否则，返回 false。
12 | 
13 | 
14 | 
15 | **注意：** 机器人&ldquo;面朝&rdquo;的方向无关紧要。 &ldquo;R&rdquo; 将始终使机器人向右移动一次，&ldquo;L&rdquo; 将始终向左移动等。此外，假设每次移动机器人的移动幅度相同。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | **示例 1:** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入: "UD"
29 | 输出: true
30 | 解释：机器人向上移动一次，然后向下移动一次。所有动作都具有相同的幅度，因此它最终回到它开始的原点。因此，我们返回 true。
31 | ```
32 | 
33 | 
34 | **示例 2:** 
35 | 
36 | 
37 | 
38 | ```
39 | 输入: "LL"
40 | 输出: false
41 | 解释：机器人向左移动两次。它最终位于原点的左侧，距原点有两次 &ldquo;移动&rdquo; 的距离。我们返回 false，因为它在移动结束时没有返回原点。
42 | ```
43 | 
44 | ```
45 | /**
46 |  * @param {string} moves
47 |  * @return {boolean}
48 |  */
49 | var judgeCircle = function(moves) {
50 |   let obj={U:1,D:-1,L:10,R:-10}
51 |   let sum=0;
52 |   for(let i=0;i<moves.length;i++){
53 |       sum+=obj[moves[i]]
54 |   }
55 |   return sum===0
56 | };
57 | ```
58 | 
59 | 


--------------------------------------------------------------------------------
/601-700/665.md:
--------------------------------------------------------------------------------
 1 | ### 665. 非递减数列
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个长度为 `n` 的整数数组，你的任务是判断在**最多** 改变 `1`  个元素的情况下，该数组能否变成一个非递减数列。
 8 | 
 9 | 
10 | 
11 | 我们是这样定义一个非递减数列的：对于数组中所有的 `i`  (1 <= i < n)，满足 `array[i] <= array[i + 1]` 。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: [4,2,3]
22 | 输出: True
23 | 解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。
24 | ```
25 | 
26 | 
27 | **示例 2:** 
28 | 
29 | 
30 | 
31 | ```
32 | 
33 | 输入: [4,2,1]
34 | 输出: False
35 | 解释: 你不能在只改变一个元素的情况下将其变为非递减数列。
36 | ```
37 | 
38 | 
39 | **说明:**  `n`  的范围为 [1, 10,000]。
40 | 
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @return {boolean}
46 |  */
47 | var checkPossibility = function(nums) {
48 |   let correct=0
49 |   for(let i=0;i<nums.length-1;i++){
50 |     if(nums[i]>nums[i+1]){
51 |       if(nums[i+1]<(nums[i-1] || 0) && nums[i]>nums[i+2])return false
52 |       correct++
53 |     }
54 |     if(correct>1)return false
55 |   }
56 |   return true
57 | };
58 | ```
59 | 
60 | 


--------------------------------------------------------------------------------
/601-700/670.md:
--------------------------------------------------------------------------------
 1 | ### 670. 最大交换
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`数学`
 6 | 
 7 | 给定一个非负整数，你**至多** 可以交换一次数字中的任意两位。返回你能得到的最大值。
 8 | 
 9 | 
10 | 
11 | **示例 1 :** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 2736
18 | 输出: 7236
19 | 解释: 交换数字2和数字7。
20 | ```
21 | 
22 | 
23 | **示例 2 :** 
24 | 
25 | 
26 | 
27 | ```
28 | 
29 | 输入: 9973
30 | 输出: 9973
31 | 解释: 不需要交换。
32 | ```
33 | 
34 | 
35 | **注意:** 
36 | 
37 | 
38 | 
39 | 
40 | 1. 给定数字的范围是[0, 108]
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number} num
48 |  * @return {number}
49 |  */
50 | var maximumSwap = function(num) {
51 |   let str=num+''
52 |   let max=num
53 |   let maxNum='',maxID=str.length-1
54 |   for(let i=str.length-1;i>=0;i--){
55 |     if(str[i]>maxNum){
56 |       maxNum=str[i]
57 |       maxID=i
58 |     }else if(str[i]<maxNum){
59 |       let nstr=str.substring(0,i)+str[maxID]+str.substring(i+1,maxID)+str[i]+str.substring(maxID+1)
60 |       let nstrint=+nstr
61 |       max=Math.max(max,nstrint)
62 |     }
63 |   }
64 |   return max
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/601-700/671.md:
--------------------------------------------------------------------------------
 1 | ### 671. 二叉树中第二小的节点
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定一个非空特殊的二叉树，每个节点都是正数，并且每个节点的子节点数量只能为 `2` 或 `0` 。如果一个节点有两个子节点的话，那么这个节点的值不大于它的子节点的值。
 8 | 
 9 | 
10 | 
11 | 给出这样的一个二叉树，你需要输出所有节点中的**第二小的值。** 如果第二小的值不存在的话，输出 -1 **。** 
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: 
22 |     2
23 |    / \
24 |   2   5
25 |      / \
26 |     5   7
27 | 
28 | 输出: 5
29 | 说明: 最小的值是 2 ，第二小的值是 5 。
30 | ```
31 | 
32 | 
33 | **示例 2:** 
34 | 
35 | 
36 | 
37 | ```
38 | 
39 | 输入: 
40 |     2
41 |    / \
42 |   2   2
43 | 
44 | 输出: -1
45 | 说明: 最小的值是 2, 但是不存在第二小的值。
46 | ```
47 | 
48 | ```
49 | /**
50 |  * Definition for a binary tree node.
51 |  * function TreeNode(val) {
52 |  *     this.val = val;
53 |  *     this.left = this.right = null;
54 |  * }
55 |  */
56 | /**
57 |  * @param {TreeNode} root
58 |  * @return {number}
59 |  */
60 | var findSecondMinimumValue = function(root) {
61 |   if(!root)return -1
62 |   let min=root.val,ans=Infinity
63 |   function dfs(root){
64 |     if(root.val>min){
65 |       ans=Math.min(ans,root.val)
66 |     }else{
67 |       if(root.left)dfs(root.left)
68 |       if(root.right)dfs(root.right)      
69 |     }
70 |   }
71 |   dfs(root)
72 |   return ans==Infinity?-1:ans
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/601-700/674.md:
--------------------------------------------------------------------------------
 1 | ### 674. 最长连续递增序列
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个未经排序的整数数组，找到最长且**连续** 的的递增序列。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: [1,3,5,4,7]
18 | 输出: 3
19 | 解释: 最长连续递增序列是 [1,3,5], 长度为3。
20 | 尽管 [1,3,5,7] 也是升序的子序列, 但它不是连续的，因为5和7在原数组里被4隔开。 
21 | ```
22 | 
23 | 
24 | **示例 2:** 
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 输入: [2,2,2,2,2]
31 | 输出: 1
32 | 解释: 最长连续递增序列是 [2], 长度为1。
33 | ```
34 | 
35 | 
36 | **注意：** 数组长度不会超过10000。
37 | 
38 | 
39 | ```
40 | /**
41 |  * @param {number[]} nums
42 |  * @return {number}
43 |  */
44 | var findLengthOfLCIS = function(nums) {
45 |     if(nums.length===0)return 0
46 |     let start=0,maxLen=0
47 |     let i=1
48 |     for(;i<nums.length;i++){
49 |         if(nums[i]<=nums[i-1]){
50 |             let temp=i-start
51 |             if(temp>maxLen)maxLen=temp
52 |             start=i
53 |         }
54 |     }
55 |     let temp=i-start
56 |     if(temp>maxLen)maxLen=temp
57 |     return maxLen
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/601-700/680.md:
--------------------------------------------------------------------------------
 1 | ### 680. 验证回文字符串 Ⅱ
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个非空字符串 `s` ，**最多** 删除一个字符。判断是否能成为回文字符串。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: "aba"
18 | 输出: True
19 | ```
20 | 
21 | 
22 | **示例 2:** 
23 | 
24 | 
25 | 
26 | ```
27 | 
28 | 输入: "abca"
29 | 输出: True
30 | 解释: 你可以删除c字符。
31 | ```
32 | 
33 | 
34 | **注意:** 
35 | 
36 | 
37 | 
38 | 
39 | 1. 字符串只包含从 a-z 的小写字母。字符串的最大长度是50000。
40 | 
41 | 
42 | 
43 | 
44 | ```
45 | /**
46 |  * @param {string} s
47 |  * @return {boolean}
48 |  */
49 | var validPalindrome = function(s) {
50 |   let left=0,right=s.length-1
51 |   while(left<=right){
52 |     if(s[left]!==s[right]){
53 |       return check(left+1,right) || check(left,right-1)
54 |     }
55 |     left++
56 |     right--
57 |   }
58 |   return true
59 |   function check(left,right){
60 |     while(left<=right){
61 |       if(s[left]!==s[right])return false
62 |       left++
63 |       right--
64 |     } 
65 |     return true
66 |   }
67 | 
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/601-700/686.md:
--------------------------------------------------------------------------------
 1 | ### 686. 重复叠加字符串匹配
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定两个字符串 A 和 B, 寻找重复叠加字符串A的最小次数，使得字符串B成为叠加后的字符串A的子串，如果不存在则返回 -1。
 8 | 
 9 | 
10 | 
11 | 举个例子，A = "abcd"，B = "cdabcdab"。
12 | 
13 | 
14 | 
15 | 答案为 3，因为 A 重复叠加三遍后为&ldquo;abcdabcdabcd&rdquo;，此时 B 是其子串；A 重复叠加两遍后为"abcdabcd"，B 并不是其子串。
16 | 
17 | 
18 | 
19 | **注意:** 
20 | 
21 | 
22 | 
23 |  `A` 与 `B` 字符串的长度在1和10000区间范围内。
24 | 
25 | 
26 | ```
27 | /**
28 |  * @param {string} A
29 |  * @param {string} B
30 |  * @return {number}
31 |  */
32 | var repeatedStringMatch = function(A, B) {
33 |   let s=''
34 |   for(let i=1;s.length<=A.length+B.length;i++){
35 |     s+=A
36 |     if(s.includes(B))return i
37 |   }
38 |   return -1
39 | };
40 | ```
41 | 
42 | 


--------------------------------------------------------------------------------
/601-700/693.md:
--------------------------------------------------------------------------------
 1 | ### 693. 交替位二进制数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`
 6 | 
 7 | 给定一个正整数，检查他是否为交替位二进制数：换句话说，就是他的二进制数相邻的两个位数永不相等。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: 5
18 | 输出: True
19 | 解释:
20 | 5的二进制数是: 101
21 | ```
22 | 
23 | 
24 | **示例 2:** 
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 输入: 7
31 | 输出: False
32 | 解释:
33 | 7的二进制数是: 111
34 | ```
35 | 
36 | 
37 | **示例3:** 
38 | 
39 | 
40 | 
41 | ```
42 | 
43 | 输入: 11
44 | 输出: False
45 | 解释:
46 | 11的二进制数是: 1011
47 | ```
48 | 
49 | 
50 | **示例 4:** 
51 | 
52 | 
53 | 
54 | ```
55 | 
56 | 输入: 10
57 | 输出: True
58 | 解释:
59 | 10的二进制数是: 1010
60 | ```
61 | 
62 | 
63 | 
64 | -----
65 | 
66 | 思路：
67 | 
68 | 将数字转换为二进制的过程中，不断检查当前位的数字是否和上一位相反。
69 | 
70 | ```
71 | /**
72 |  * @param {number} n
73 |  * @return {boolean}
74 |  */
75 | var hasAlternatingBits = function(n) {
76 |   let last;
77 |   while(n>0){
78 |     let cur=n%2
79 |     if(last!==cur){
80 |       last=cur
81 |     }else{
82 |       return false
83 |     }
84 |     n=n>>1
85 |   }
86 |   return true
87 | };
88 | ```
89 | 
90 | 


--------------------------------------------------------------------------------
/701-800/700.md:
--------------------------------------------------------------------------------
 1 | ### 700. 二叉搜索树中的搜索
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`树`
 6 | 
 7 | 给定二叉搜索树（BST）的根节点和一个值。 你需要在BST中找到节点值等于给定值的节点。 返回以该节点为根的子树。 如果节点不存在，则返回 NULL。
 8 | 
 9 | 
10 | 
11 | 例如，
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 给定二叉搜索树:
18 | 
19 |         4
20 |        / \
21 |       2   7
22 |      / \
23 |     1   3
24 | 
25 | 和值: 2
26 | ```
27 | 
28 | 
29 | 你应该返回如下子树:
30 | 
31 | 
32 | 
33 | ```
34 | 
35 |       2     
36 |      / \   
37 |     1   3
38 | ```
39 | 
40 | 
41 | 在上述示例中，如果要找的值是  `5` ，但因为没有节点值为  `5` ，我们应该返回  `NULL` 。
42 | 
43 | 
44 | ```
45 | /**
46 |  * Definition for a binary tree node.
47 |  * function TreeNode(val) {
48 |  *     this.val = val;
49 |  *     this.left = this.right = null;
50 |  * }
51 |  */
52 | /**
53 |  * @param {TreeNode} root
54 |  * @param {number} val
55 |  * @return {TreeNode}
56 |  */
57 | var searchBST = function(root, val) {
58 |   if(!root) return null
59 |   if(root.val===val) return root
60 |   if(root.val<val) return searchBST(root.right,val)
61 |   if(root.val > val ) return searchBST(root.left,val)
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/701-800/704.md:
--------------------------------------------------------------------------------
 1 | ### 704. 二分查找
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`二分查找`
 6 | 
 7 | 给定一个 `n` 个元素有序的（升序）整型数组 `nums`  和一个目标值 `target`  ，写一个函数搜索 `nums` 中的  `target` ，如果目标值存在返回下标，否则返回  `-1` 。
 8 | 
 9 | 
10 | 
11 | 
12 | **示例 1:** 
13 | 
14 | 
15 | 
16 | ```
17 | 输入: nums = [-1,0,3,5,9,12], target = 9
18 | 输出: 4
19 | 解释: 9 出现在 nums 中并且下标为 4
20 | ```
21 | 
22 | 
23 | **示例2:** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入: nums = [-1,0,3,5,9,12], target = 2
29 | 输出: -1
30 | 解释: 2 不存在 nums 中因此返回 -1
31 | ```
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | **提示：** 
39 | 
40 | 
41 | 
42 | 
43 | 1. 你可以假设  `nums` 中的所有元素是不重复的。
44 | 
45 | 2.  `n` 将在 `[1, 10000]` 之间。
46 | 
47 | 3.  `nums` 的每个元素都将在 `[-9999, 9999]` 之间。
48 | 
49 | 
50 | 
51 | 
52 | ```
53 | /**
54 |  * @param {number[]} nums
55 |  * @param {number} target
56 |  * @return {number}
57 |  */
58 | var search = function(nums, target) {
59 |     let lo=0,hi=nums.length
60 |     while(lo<hi){
61 |       let mid=Math.floor((lo+hi)/2)
62 |       if(nums[mid]<target) lo=mid+1
63 |       else if(nums[mid]>target) hi=mid
64 |       else return mid
65 |     }
66 |     return -1
67 | };
68 | ```
69 | 
70 | 


--------------------------------------------------------------------------------
/701-800/709.md:
--------------------------------------------------------------------------------
 1 | ### 709. 转换成小写字母
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 实现函数 ToLowerCase()，该函数接收一个字符串参数 str，并将该字符串中的大写字母转换成小写字母，之后返回新的字符串。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | **示例 1：** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入:"Hello"
22 | 输出:"hello"
23 | ```
24 | 
25 | 
26 | **示例 2：** 
27 | 
28 | 
29 | 
30 | ```
31 | 
32 | 输入:"here"
33 | 输出:"here"
34 | ```
35 | 
36 | 
37 | **示例** **3：** 
38 | 
39 | 
40 | 
41 | ```
42 | 
43 | 输入:"LOVELY"
44 | 输出:"lovely"
45 | ```
46 | 
47 | ```
48 | /**
49 |  * @param {string} str
50 |  * @return {string}
51 |  */
52 | var toLowerCase = function(str) {
53 |   let news=''
54 |   for(let i=0;i<str.length;i++){
55 |     let c=str.charCodeAt(i)
56 |     if(c>=65 && c<=90){
57 |       news+=String.fromCharCode(c-65+97)
58 |     }else{
59 |       news+=str[i]
60 |     }
61 |   }
62 |   return news
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/701-800/713.md:
--------------------------------------------------------------------------------
 1 | ### 713. 乘积小于K的子数组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`数组`、`双指针`
 6 | 
 7 | 给定一个正整数数组 `nums` 。
 8 | 
 9 | 
10 | 
11 | 找出该数组内乘积小于 `k` 的连续的子数组的个数。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: nums = [10,5,2,6], k = 100
22 | 输出: 8
23 | 解释: 8个乘积小于100的子数组分别为: [10], [5], [2], [6], [10,5], [5,2], [2,6], [5,2,6]。
24 | 需要注意的是 [10,5,2] 并不是乘积小于100的子数组。
25 | ```
26 | 
27 | 
28 | **说明:** 
29 | 
30 | 
31 | 
32 | 
33 | * `0 < nums.length <= 50000`
34 | 
35 | * `0 < nums[i] < 1000`
36 | 
37 | * `0 <= k < 10^6`
38 | 
39 | 
40 | 
41 | 
42 | ```
43 | /**
44 |  * @param {number[]} nums
45 |  * @param {number} k
46 |  * @return {number}
47 |  */
48 | var numSubarrayProductLessThanK = function(nums, k) {
49 |   let sum=1,res=0
50 |   let left=0,right=0
51 |   while(right<nums.length){
52 |     let cur=nums[right]
53 |     sum=sum*cur
54 |     while(left<=right && sum>=k){
55 |       sum=sum/nums[left++]
56 |     }
57 |     right++
58 |     res+=right-left
59 |   }
60 |   return res
61 | };
62 | ```
63 | 
64 | 


--------------------------------------------------------------------------------
/701-800/717.md:
--------------------------------------------------------------------------------
 1 | ### 717. 1比特与2比特字符
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 有两种特殊字符。第一种字符可以用一比特 `0` 来表示。第二种字符可以用两比特( `10` 或 `11` )来表示。
 8 | 
 9 | 
10 | 
11 | 现给一个由若干比特组成的字符串。问最后一个字符是否必定为一个一比特字符。给定的字符串总是由0结束。
12 | 
13 | 
14 | 
15 | **示例1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 输入: 
22 | bits = [1, 0, 0]
23 | 输出: True
24 | 解释: 
25 | 唯一的编码方式是一个两比特字符和一个一比特字符。所以最后一个字符是一比特字符。
26 | ```
27 | 
28 | 
29 | **示例2:** 
30 | 
31 | 
32 | 
33 | ```
34 | 
35 | 输入: 
36 | bits = [1, 1, 1, 0]
37 | 输出: False
38 | 解释: 
39 | 唯一的编码方式是两比特字符和两比特字符。所以最后一个字符不是一比特字符。
40 | ```
41 | 
42 | 
43 | **注意:** 
44 | 
45 | 
46 | 
47 | 
48 | * `1 <= len(bits) <= 1000` .
49 | 
50 | * `bits[i]`  总是 `0`  或 `1` .
51 | 
52 | 
53 | 
54 | 
55 | ```
56 | /**
57 |  * @param {number[]} bits
58 |  * @return {boolean}
59 |  */
60 | var isOneBitCharacter = function(bits) {
61 |     let len=bits.length
62 |     for(let i=0;i<len;i++){
63 |         if(i===len-1)return true
64 |         if(bits[i]===1)i++
65 |     }
66 |     return false
67 | };
68 | ```
69 | 
70 | 


--------------------------------------------------------------------------------
/701-800/724.md:
--------------------------------------------------------------------------------
 1 | ### 724. 寻找数组的中心索引
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个整数类型的数组 `nums` ，请编写一个能够返回数组**&ldquo;中心索引&rdquo;** 的方法。
 8 | 
 9 | 
10 | 
11 | 我们是这样定义数组**中心索引** 的：数组中心索引的左侧所有元素相加的和等于右侧所有元素相加的和。
12 | 
13 | 
14 | 
15 | 如果数组不存在中心索引，那么我们应该返回 -1。如果数组有多个中心索引，那么我们应该返回最靠近左边的那一个。
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: 
26 | nums = [1, 7, 3, 6, 5, 6]
27 | 输出: 3
28 | 解释: 
29 | 索引3 (nums[3] = 6) 的左侧数之和(1 + 7 + 3 = 11)，与右侧数之和(5 + 6 = 11)相等。
30 | 同时, 3 也是第一个符合要求的中心索引。
31 | ```
32 | 
33 | 
34 | **示例 2:** 
35 | 
36 | 
37 | 
38 | ```
39 | 
40 | 输入: 
41 | nums = [1, 2, 3]
42 | 输出: -1
43 | 解释: 
44 | 数组中不存在满足此条件的中心索引。
45 | ```
46 | 
47 | 
48 | **说明:** 
49 | 
50 | 
51 | 
52 | 
53 | * `nums`  的长度范围为 `[0, 10000]` 。
54 | 
55 | * 任何一个 `nums[i]`  将会是一个范围在 `[-1000, 1000]` 的整数。
56 | 
57 | 
58 | 
59 | 
60 | ```
61 | /**
62 |  * @param {number[]} nums
63 |  * @return {number}
64 |  */
65 | var pivotIndex = function(nums) {
66 |   let sum=0
67 |   for(let i=0;i<nums.length;i++){
68 |     sum+=nums[i]
69 |   }
70 |   let leftSum=0
71 |   for(let i=0;i<nums.length;i++){
72 |     let p=nums[i]
73 |     if(leftSum===sum-leftSum-p)return i
74 |     leftSum+=p
75 |   }
76 |   return -1
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/701-800/728.md:
--------------------------------------------------------------------------------
 1 | ### 728. 自除数
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | *自除数* 是指可以被它包含的每一位数除尽的数。
 8 | 
 9 | 
10 | 
11 | 例如，128 是一个自除数，因为 `128 % 1 == 0` ， `128 % 2 == 0` ， `128 % 8 == 0` 。
12 | 
13 | 
14 | 
15 | 还有，自除数不允许包含 0 。
16 | 
17 | 
18 | 
19 | 给定上边界和下边界数字，输出一个列表，列表的元素是边界（含边界）内所有的自除数。
20 | 
21 | 
22 | 
23 | **示例 1：** 
24 | 
25 | 
26 | 
27 | ```
28 | 
29 | 输入： 
30 | 上边界left = 1, 下边界right = 22
31 | 输出： [1, 2, 3, 4, 5, 6, 7, 8, 9, 11, 12, 15, 22]
32 | ```
33 | 
34 | 
35 | **注意：** 
36 | 
37 | 
38 | 
39 | 
40 | * 每个输入参数的边界满足 `1 <= left <= right <= 10000` 。
41 | 
42 | 
43 | 
44 | 
45 | ```
46 | /**
47 |  * @param {number} left
48 |  * @param {number} right
49 |  * @return {number[]}
50 |  */
51 | var selfDividingNumbers = function(left, right) {
52 |   let res=[],isDi=true
53 |   for(let i=left ;i<=right;i++){
54 |       isDi=true;
55 |       let den=String(i)
56 |       for(let j=0;j<den.length;j++){
57 |           if(i % den[j] !==0){
58 |               isDi=false;
59 |           }
60 |       }
61 |       if(isDi)
62 |       res.push(i)
63 |   }
64 |   return res
65 | };
66 | ```
67 | 
68 | 


--------------------------------------------------------------------------------
/701-800/738.md:
--------------------------------------------------------------------------------
 1 | ### 738. 单调递增的数字
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`贪心算法`
 6 | 
 7 | 给定一个非负整数 `N` ，找出小于或等于 `N` 的最大的整数，同时这个整数需要满足其各个位数上的数字是单调递增。
 8 | 
 9 | 
10 | 
11 | （当且仅当每个相邻位数上的数字 `x` 和 `y` 满足 `x <= y` 时，我们称这个整数是单调递增的。）
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: N = 10
21 | 输出: 9
22 | ```
23 | 
24 | 
25 | **示例 2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: N = 1234
31 | 输出: 1234
32 | ```
33 | 
34 | 
35 | **示例 3:** 
36 | 
37 | 
38 | 
39 | ```
40 | 输入: N = 332
41 | 输出: 299
42 | ```
43 | 
44 | 
45 | **说明:**   `N` 是在 `[0, 10^9]` 范围内的一个整数。
46 | 
47 | 
48 | 
49 | 
50 | -----
51 | 
52 | 思路：
53 | 
54 | 要找出`单调递增`的最大数，将数字转换成字符串后，从前往后找，找到不符合`单调递增`的立刻修改，并且后面添加`999...`即是最大值。
55 | 
56 | 因此这里一旦发现当前数字比上一个数字更小，递归处理上一个数字和之前的字符串。
57 | 
58 | ```
59 | /**
60 |  * @param {number} N
61 |  * @return {number}
62 |  */
63 | var monotoneIncreasingDigits = function(N) {
64 |   let S=N+''
65 |   let prevStr=''
66 |   for(let i=0;i<S.length;i++){
67 |     if(prevStr.length>0 && prevStr[prevStr.length-1]>S[i]){
68 |       prevStr=monotoneIncreasingDigits(+prevStr-1)+"9".repeat(S.length-i)
69 |       break
70 |     }
71 |     prevStr+=S[i]
72 |   }
73 |   return +prevStr
74 | };
75 | ```
76 | 
77 | 


--------------------------------------------------------------------------------
/701-800/739.md:
--------------------------------------------------------------------------------
 1 | ### 739. 每日温度
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`栈`、`哈希表`
 6 | 
 7 | 根据每日  `气温`  列表，请重新生成一个列表，对应位置的输入是你需要再等待多久温度才会升高的天数。如果之后都不会升高，请输入 `0`  来代替。
 8 | 
 9 | 
10 | 
11 | 例如，给定一个列表 `temperatures = [73, 74, 75, 71, 69, 72, 76, 73]` ，你的输出应该是 `[1, 1, 4, 2, 1, 1, 0, 0]` 。
12 | 
13 | 
14 | 
15 | **提示：**  `气温`  列表长度的范围是 `[1, 30000]` 。每个气温的值的都是 `[30, 100]` 范围内的整数。
16 | 
17 | 
18 | 
19 | 
20 | -----
21 | 
22 | 思路：
23 | 
24 | 建立单调递增`stack`。
25 | 
26 | 对`T`进行反向遍历(正向也可以)，对内部每一个`T[i]`建立一个单调递增的`stack`，`stack`内部存放`T`的索引。
27 | 
28 | 如果发现不是递增状态，通过`stack.pop()`调整，将离当前`T[i]`和离它最近的`stack[stack.length-1]`的差值添加进`res`。
29 | 
30 | 
31 | ```
32 | /**
33 |  * @param {number[]} T
34 |  * @return {number[]}
35 |  */
36 | var dailyTemperatures = function(T) {
37 |   let stack=[]
38 |   let res=[]
39 |   for(let i=T.length-1;i>=0;i--){
40 |     while(stack.length>0 && T[i]>=T[stack[stack.length-1]]){
41 |       stack.pop()
42 |     }
43 |     if(stack.length===0)res.push(0)
44 |     else res.push(stack[stack.length-1]-i)
45 |     stack.push(i)
46 |   }
47 |   return res.reverse()
48 | };
49 | ```
50 | 
51 | 


--------------------------------------------------------------------------------
/701-800/754.md:
--------------------------------------------------------------------------------
 1 | ### 754. 到达终点数字
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 在一根无限长的数轴上，你站在 `0` 的位置。终点在 `target` 的位置。
 8 | 
 9 | 
10 | 
11 | 每次你可以选择向左或向右移动。第 n 次移动（从 1 开始），可以走 n 步。
12 | 
13 | 
14 | 
15 | 返回到达终点需要的最小移动次数。
16 | 
17 | 
18 | 
19 | **示例 1:** 
20 | 
21 | 
22 | 
23 | ```
24 | 
25 | 输入: target = 3
26 | 输出: 2
27 | 解释:
28 | 第一次移动，从 0 到 1 。
29 | 第二次移动，从 1 到 3 。
30 | ```
31 | 
32 | 
33 | **示例 2:** 
34 | 
35 | 
36 | 
37 | ```
38 | 
39 | 输入: target = 2
40 | 输出: 3
41 | 解释:
42 | 第一次移动，从 0 到 1 。
43 | 第二次移动，从 1 到 -1 。
44 | 第三次移动，从 -1 到 2 。
45 | ```
46 | 
47 | 
48 | **注意:** 
49 | 
50 | 
51 | 
52 | 
53 | * `target` 是在 `[-10^9, 10^9]` 范围中的非零整数。
54 | 
55 | 
56 | 
57 | 
58 | ```
59 | /**
60 |  * @param {number} target
61 |  * @return {number}
62 |  */
63 | var reachNumber = function(target) {
64 |   target=Math.abs(target)
65 |   let i=0,s=0
66 |   for(;i/2*(i+1)<target;i++){s+=i}
67 |   s+=i
68 |   let delta=s-target
69 |   while(delta % 2===1){
70 |     delta+= ++i
71 |   }
72 |   return i
73 | };
74 | ```
75 | 
76 | 


--------------------------------------------------------------------------------
/701-800/763.md:
--------------------------------------------------------------------------------
 1 | ### 763. 划分字母区间
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`贪心算法`、`双指针`
 6 | 
 7 | 字符串  `S`  由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。返回一个表示每个字符串片段的长度的列表。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 输入: S = "ababcbacadefegdehijhklij"
17 | 输出: [9,7,8]
18 | 解释:
19 | 划分结果为 "ababcbaca", "defegde", "hijhklij"。
20 | 每个字母最多出现在一个片段中。
21 | 像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。
22 | ```
23 | 
24 | 
25 | **注意:** 
26 | 
27 | 
28 | 
29 | 
30 | 1.  `S` 的长度在 `[1, 500]` 之间。
31 | 
32 | 2.  `S` 只包含小写字母 `'a'` 到 `'z'` 。
33 | 
34 | 
35 | 
36 | 
37 | 
38 | 
39 | -----
40 | 
41 | 思路：
42 | 
43 | 首先找到每一个`S[i]`的最后的位置，存放到一个`hash`中。
44 | 
45 | 再次遍历`S`，维护一个变量`curLen`记录当前最少要到达哪一个索引(每种字母只能出现在一段内)，
46 | 如果`i===curLen`，说明当前`i`之前的所有字母，后面都不会存在了，达到了要求，记录当前的长度。
47 | 
48 | ```
49 | /**
50 |  * @param {string} S
51 |  * @return {number[]}
52 |  */
53 | var partitionLabels = function(S) {
54 |   let lastIdx={}
55 |   for(let i=0;i<S.length;i++){
56 |     lastIdx[S[i]]=i
57 |   }
58 |   let res=[],curLen=0,lastR=0
59 |   for(let i=0;i<S.length;i++){
60 |     curLen=Math.max(lastIdx[S[i]],curLen)
61 |     if(i===curLen){
62 |       res.push(curLen-lastR+1)
63 |       lastR=curLen+1
64 |     }
65 |   }
66 |   return res
67 | };
68 | ```
69 | 
70 | 


--------------------------------------------------------------------------------
/701-800/771.md:
--------------------------------------------------------------------------------
 1 | ### 771. 宝石与石头
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 给定字符串 `J` 代表石头中宝石的类型，和字符串 `S` 代表你拥有的石头。 `S` 中每个字符代表了一种你拥有的石头的类型，你想知道你拥有的石头中有多少是宝石。
 8 | 
 9 | 
10 | 
11 |  `J` 中的字母不重复， `J` 和 `S` 中的所有字符都是字母。字母区分大小写，因此 `"a"` 和 `"A"` 是不同类型的石头。
12 | 
13 | 
14 | 
15 | **示例 1:** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入: J = "aA", S = "aAAbbbb"
21 | 输出: 3
22 | ```
23 | 
24 | 
25 | **示例 2:** 
26 | 
27 | 
28 | 
29 | ```
30 | 输入: J = "z", S = "ZZ"
31 | 输出: 0
32 | ```
33 | 
34 | 
35 | **注意:** 
36 | 
37 | 
38 | 
39 | 
40 | * `S` 和 `J` 最多含有50个字母。
41 | 
42 | *  `J` 中的字符不重复。
43 | 
44 | 
45 | 
46 | 
47 | ```
48 | /**
49 |  * @param {string} J
50 |  * @param {string} S
51 |  * @return {number}
52 |  */
53 | var numJewelsInStones = function(J, S) {
54 |   let hash={},res=0
55 |   for(let j of J)hash[j]=true
56 |   for(let s of S)if(hash[s])res++
57 |   return res
58 | };
59 | ```
60 | 
61 | 


--------------------------------------------------------------------------------
/701-800/784.md:
--------------------------------------------------------------------------------
 1 | ### 784. 字母大小写全排列
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`位运算`、`回溯算法`
 6 | 
 7 | 给定一个字符串 `S` ，通过将字符串 `S` 中的每个字母转变大小写，我们可以获得一个新的字符串。返回所有可能得到的字符串集合。
 8 | 
 9 | 
10 | 
11 | ```
12 | 
13 | 示例:
14 | 输入: S = "a1b2"
15 | 输出: ["a1b2", "a1B2", "A1b2", "A1B2"]
16 | 
17 | 输入: S = "3z4"
18 | 输出: ["3z4", "3Z4"]
19 | 
20 | 输入: S = "12345"
21 | 输出: ["12345"]
22 | ```
23 | 
24 | 
25 | **注意：** 
26 | 
27 | 
28 | 
29 | 
30 | * `S` 的长度不超过 `12` 。
31 | 
32 | * `S` 仅由数字和字母组成。
33 | 
34 | 
35 | 
36 | 
37 | 
38 | 
39 | -----
40 | 
41 | 思路：
42 | 
43 | 检查每一个`S`的索引，如果是字母，则需要加上字母的小写和大写，数字则直接加上即可。
44 | 
45 | ```
46 | /**
47 |  * @param {string} S
48 |  * @return {string[]}
49 |  */
50 | var letterCasePermutation = function(S) {
51 |   let res=[]
52 |   function backtrack(idx,str){
53 |     if(idx===S.length){
54 |       return res.push(str)
55 |     }
56 |     if(/[a-zA-Z]/.test(S[idx])){
57 |       backtrack(idx+1,str+(S[idx].toLowerCase()))
58 |     }
59 |     backtrack(idx+1,str+(S[idx].toUpperCase()))
60 |   }
61 |   backtrack(0,'')
62 |   return res
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/701-800/790.md:
--------------------------------------------------------------------------------
 1 | ### 790. 多米诺和托米诺平铺
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`动态规划`
 6 | 
 7 | 有两种形状的瓷砖：一种是2x1 的多米诺形，另一种是形如"L" 的托米诺形。两种形状都可以旋转。
 8 | 
 9 | 
10 | 
11 | ```
12 | 
13 | XX  <- 多米诺
14 | 
15 | XX  <- "L" 托米诺
16 | X
17 | ```
18 | 
19 | 
20 | 给定N 的值，有多少种方法可以平铺2 x N 的面板？**返回值 mod 10^9 + 7** 。
21 | 
22 | 
23 | 
24 | （平铺指的是每个正方形都必须有瓷砖覆盖。两个平铺不同，当且仅当面板上有四个方向上的相邻单元中的两个，使得恰好有一个平铺有一个瓷砖占据两个正方形。）
25 | 
26 | 
27 | 
28 | ```
29 | 
30 | 示例:
31 | 输入: 3
32 | 输出: 5
33 | 解释: 
34 | 下面列出了五种不同的方法，不同字母代表不同瓷砖：
35 | XYZ XXZ XYY XXY XYY
36 | XYZ YYZ XZZ XYY XXY
37 | ```
38 | 
39 | 
40 | **提示：** 
41 | 
42 | 
43 | 
44 | 
45 | * N 的范围是 `[1, 1000]`
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | ```
55 | /**
56 |  * @param {number} N
57 |  * @return {number}
58 |  */
59 | var numTilings = function(N) {
60 |   let MOD=1000000007
61 |   let mem=[1,1,2]
62 |   let start=3
63 |   while(start<=N){
64 |     mem[start]=(mem[start-1]*2 +mem[start-3] ) % MOD
65 |     start++
66 |   }
67 |   return mem[N]
68 | };
69 | ```
70 | 
71 | 


--------------------------------------------------------------------------------
/701-800/791.md:
--------------------------------------------------------------------------------
 1 | ### 791. 自定义字符串排序
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 字符串 `S` 和  `T`  只包含小写字符。在 `S` 中，所有字符只会出现一次。
 8 | 
 9 | 
10 | 
11 |  `S`  已经根据某种规则进行了排序。我们要根据 `S` 中的字符顺序对 `T` 进行排序。更具体地说，如果 `S` 中 `x` 在 `y` 之前出现，那么返回的字符串中 `x` 也应出现在 `y` 之前。
12 | 
13 | 
14 | 
15 | 返回任意一种符合条件的字符串 `T` 。
16 | 
17 | 
18 | 
19 | ```
20 | 
21 | 示例:
22 | 输入:
23 | S = "cba"
24 | T = "abcd"
25 | 输出: "cbad"
26 | 解释: 
27 | S中出现了字符 "a", "b", "c", 所以 "a", "b", "c" 的顺序应该是 "c", "b", "a". 
28 | 由于 "d" 没有在S中出现, 它可以放在T的任意位置. "dcba", "cdba", "cbda" 都是合法的输出。
29 | ```
30 | 
31 | 
32 | **注意:** 
33 | 
34 | 
35 | 
36 | 
37 | * `S` 的最大长度为 `26` ，其中没有重复的字符。
38 | 
39 | * `T` 的最大长度为 `200` 。
40 | 
41 | * `S` 和 `T` 只包含小写字符。
42 | 
43 | 
44 | 
45 | 
46 | ```
47 | /**
48 |  * @param {string} S
49 |  * @param {string} T
50 |  * @return {string}
51 |  */
52 | var customSortString = function(S, T) {
53 |   let newS=''
54 |   for(let i=0;i<S.length;i++){
55 |     let count=(T.match(new RegExp(S[i],"g")) || []).length
56 |     T=T.replace(new RegExp(S[i],'g'),'')
57 |     for(let j=0;j<count;j++){
58 |       newS+=S[i]
59 |     }
60 |   }
61 |   return newS+T
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/701-800/793.md:
--------------------------------------------------------------------------------
 1 | ### 793. 阶乘函数后K个零
 2 | 
 3 | 难度：Hard
 4 | 
 5 | 相关话题：`二分查找`
 6 | 
 7 |  `f(x)` 是 `x!` 末尾是0的数量。（回想一下 `x! = 1 * 2 * 3 * ... * x` ，且 `0! = 1` ）
 8 | 
 9 | 
10 | 
11 | 例如， `f(3) = 0` ，因为3! = 6的末尾没有0；而 `f(11) = 2` ，因为11!= 39916800末端有2个0。给定 `K` ，找出多少个非负整数 `x` ，有 `f(x) = K` 的性质。
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 示例 1:
18 | 输入:K = 0输出:5解释:0!, 1!, 2!, 3!, and 4!均符合 K = 0 的条件。示例 2:
19 | 输入:K = 5输出:0解释:没有匹配到这样的 x!，符合K = 5 的条件。
20 | ```
21 | 
22 | 
23 | **注意：** 
24 | 
25 | 
26 | 
27 | 
28 | * `K` 是范围在 `[0, 10^9]` 的整数**。**
29 | 
30 | 
31 | 
32 | 
33 | ```
34 | /**
35 |  * @param {number} K
36 |  * @return {number}
37 |  */
38 | var preimageSizeFZF = function(K) {
39 |   let lo=0,hi=K*5
40 |   while(lo<=hi){
41 |     let mid=Math.floor((lo+hi)/2)
42 |     let count=calc(mid)
43 |     if(count<K)lo=mid+1
44 |     else hi=mid-1
45 |   }
46 |   let ans=0
47 |   // console.log(lo)
48 |   for(let i=lo;;i++){
49 |     let n=calc(i)
50 |     if(n!==K)break
51 |     ans++
52 |   }
53 |   return ans
54 |   function calc(n){
55 |     if(n===0)return 0
56 |     let res=0, x=5
57 |     while(x<=n){
58 |       res+=Math.floor(n/x)
59 |       x*=5
60 |     }
61 |     return res
62 |   }
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/701-800/796.md:
--------------------------------------------------------------------------------
 1 | ### 796. 旋转字符串
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给定两个字符串,  `A` 和 `B` 。
 8 | 
 9 | 
10 | 
11 |  `A` 的旋转操作就是将 `A`  最左边的字符移动到最右边。例如, 若 `A = 'abcde'` ，在移动一次之后结果就是 `'bcdea'` 。如果在若干次旋转操作之后， `A` 能变成 `B` ，那么返回 `True` 。
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 示例 1:
18 | 输入: A = 'abcde', B = 'cdeab'
19 | 输出: true
20 | 
21 | 示例 2:
22 | 输入: A = 'abcde', B = 'abced'
23 | 输出: false
24 | ```
25 | 
26 | 
27 | **注意：** 
28 | 
29 | 
30 | 
31 | 
32 | * `A`  和 `B` 长度不超过 `100` 。
33 | 
34 | 
35 | 
36 | 
37 | ```
38 | /**
39 |  * @param {string} A
40 |  * @param {string} B
41 |  * @return {boolean}
42 |  */
43 | var rotateString = function(A, B) {
44 |   if(A.length!==B.length)return false
45 |   let S=A+A
46 |   return S.includes(B)
47 | };
48 | ```
49 | 
50 | 


--------------------------------------------------------------------------------
/701-800/797.md:
--------------------------------------------------------------------------------
 1 | ### 797. 所有可能的路径
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给一个有 `n` 个结点的有向无环图，找到所有从 `0` 到 `n-1` 的路径并输出（不要求按顺序）
 8 | 
 9 | 
10 | 
11 | 二维数组的第 i 个数组中的单元都表示有向图中 i 号结点所能到达的下一些结点（译者注：有向图是有方向的，即规定了a&rarr;b你就不能从b&rarr;a）空就是没有下一个结点了。
12 | 
13 | 
14 | 
15 | ```
16 | 示例:
17 | 输入: [[1,2], [3], [3], []] 
18 | 输出: [[0,1,3],[0,2,3]] 
19 | 解释: 图是这样的:
20 | 0--->1
21 | |    |
22 | v    v
23 | 2--->3
24 | 这有两条路: 0 -> 1 -> 3 和 0 -> 2 -> 3.
25 | ```
26 | 
27 | 
28 | **提示:** 
29 | 
30 | 
31 | 
32 | 
33 | * 结点的数量会在范围 `[2, 15]` 内。
34 | 
35 | * 你可以把路径以任意顺序输出，但在路径内的结点的顺序必须保证。
36 | 
37 | 
38 | 
39 | 
40 | 
41 | 
42 | -----
43 | 
44 | 思路：
45 | 
46 | `dfs`遍历，使用一个数组`stack`保存当前`dfs`的路径。
47 | 
48 | ```
49 | /**
50 |  * @param {number[][]} graph
51 |  * @return {number[][]}
52 |  */
53 | var allPathsSourceTarget = function(graph) {
54 |   let n=graph.length
55 |   let res=[]
56 |   function dfs(v,stack){
57 |     if(v===n-1){
58 |       return res.push(stack.slice())
59 |     }
60 |     let adj=graph[v]
61 |     for(let i=0;i<adj.length;i++){
62 |       stack.push(adj[i])
63 |       dfs(adj[i],stack)
64 |       stack.pop()
65 |     }
66 |   }
67 |   dfs(0,[0])
68 |   return res
69 | };
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/801-900/821.md:
--------------------------------------------------------------------------------
 1 | ### 821. 字符的最短距离
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给定一个字符串 `S` 和一个字符 `C` 。返回一个代表字符串 `S` 中每个字符到字符串 `S` 中的字符 `C` 的最短距离的数组。
 8 | 
 9 | 
10 | 
11 | **示例 1:** 
12 | 
13 | 
14 | 
15 | ```
16 | 
17 | 输入: S = "loveleetcode", C = 'e'
18 | 输出: [3, 2, 1, 0, 1, 0, 0, 1, 2, 2, 1, 0]
19 | ```
20 | 
21 | 
22 | **说明:** 
23 | 
24 | 
25 | 
26 | 
27 | 1. 字符串 `S` 的长度范围为 `[1, 10000]` 。
28 | 
29 | 2.  `C` 是一个单字符，且保证是字符串 `S` 里的字符。
30 | 
31 | 3.  `S` 和 `C` 中的所有字母均为小写字母。
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | -----
39 | 
40 | 思路：
41 | 
42 | 正向遍历一次，将每一个`C`所在位置后面的数处理，再反向遍历一次，将每一个`C`所在位置前面的数处理。
43 | 
44 | ```
45 | /**
46 |  * @param {string} S
47 |  * @param {character} C
48 |  * @return {number[]}
49 |  */
50 | var shortestToChar = function(S, C) {
51 |   let prev=-Infinity
52 |   let res=Array(S.length).fill(Infinity)
53 |   for(let i=0;i<S.length;i++){
54 |     if(S[i]===C)prev=i
55 |     res[i]=i-prev
56 |   }
57 |   prev=Infinity
58 |   for(let i=S.length-1;i>=0;i--){
59 |     if(S[i]===C)prev=i
60 |     res[i]=Math.min(res[i],prev-i)
61 |   }
62 |   return res
63 | };
64 | ```
65 | 
66 | 


--------------------------------------------------------------------------------
/801-900/830.md:
--------------------------------------------------------------------------------
 1 | ### 830. 较大分组的位置
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 在一个由小写字母构成的字符串 `S` 中，包含由一些连续的相同字符所构成的分组。
 8 | 
 9 | 
10 | 
11 | 例如，在字符串  `S = "abbxxxxzyy"` 中，就含有  `"a"` ,  `"bb"` ,  `"xxxx"` ,  `"z"`  和  `"yy"`  这样的一些分组。
12 | 
13 | 
14 | 
15 | 我们称所有包含大于或等于三个连续字符的分组为较大分组。找到每一个较大分组的起始和终止位置。
16 | 
17 | 
18 | 
19 | 最终结果按照字典顺序输出。
20 | 
21 | 
22 | 
23 | **示例1:** 
24 | 
25 | 
26 | 
27 | ```
28 | 
29 | 输入:"abbxxxxzzy"
30 | 输出:[[3,6]]
31 | 解释: "xxxx" 是一个起始于 3 且终止于 6 的较大分组。
32 | ```
33 | 
34 | 
35 | **示例 2:** 
36 | 
37 | 
38 | 
39 | ```
40 | 
41 | 输入:"abc"
42 | 输出:[]
43 | 解释: "a","b" 和 "c" 均不是符合要求的较大分组。
44 | ```
45 | 
46 | 
47 | **示例 3:** 
48 | 
49 | 
50 | 
51 | ```
52 | 
53 | 输入:"abcdddeeeeaabbbcd"
54 | 输出:[[3,5],[6,9],[12,14]]
55 | ```
56 | 
57 | 
58 | **说明:**  `1 <= S.length <= 1000` 
59 | 
60 | 
61 | ```
62 | /**
63 |  * @param {string} S
64 |  * @return {number[][]}
65 |  */
66 | var largeGroupPositions = function(S) {
67 |     let start=0,res=[]
68 |     for(let i=0;i<S.length;i++){
69 |         if(S[i]===S[start])continue
70 |         else{
71 |             if(i-start>2)res.push([start,i-1])
72 |             start=i
73 |         }
74 |     }
75 |     if(S.length-start>2)res.push([start,S.length-1])
76 |     return res
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/801-900/836.md:
--------------------------------------------------------------------------------
 1 | ### 836. 矩形重叠
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 矩形以列表  `[x1, y1, x2, y2]`  的形式表示，其中  `(x1, y1)`  为左下角的坐标， `(x2, y2)`  是右上角的坐标。
 8 | 
 9 | 
10 | 
11 | 如果相交的面积为正，则称两矩形重叠。需要明确的是，只在角或边接触的两个矩形不构成重叠。
12 | 
13 | 
14 | 
15 | 给出两个矩形，判断它们是否重叠并返回结果。
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：rec1 = [0,0,2,2], rec2 = [1,1,3,3]
25 | 输出：true
26 | ```
27 | 
28 | 
29 | **示例 2：** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入：rec1 = [0,0,1,1], rec2 = [1,0,2,1]
35 | 输出：false
36 | ```
37 | 
38 | 
39 | **说明：** 
40 | 
41 | 
42 | 
43 | 
44 | 1. 两个矩形  `rec1`  和  `rec2`  都以含有四个整数的列表的形式给出。
45 | 
46 | 2. 矩形中的所有坐标都处于  `-10^9`  和  `10^9`  之间。
47 | 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | -----
54 | 
55 | 思路：
56 | 
57 | 先算出这两个矩形有可能存在的交叉点，然后再判断这个交叉点是否有效的交叉点。
58 | 
59 | ```
60 | /**
61 |  * @param {number[]} rec1
62 |  * @param {number[]} rec2
63 |  * @return {boolean}
64 |  */
65 | var isRectangleOverlap = function(rec1, rec2) {
66 |   let x1 = rec1[0], y1 = rec1[1], x2 = rec1[2], y2 = rec1[3];
67 |   let x3 = rec2[0], y3 = rec2[1], x4 = rec2[2], y4 = rec2[3];
68 | 	return (x1 < x4 && x3 < x2 && y1 < y4 && y3 < y2);
69 | };
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/801-900/852.md:
--------------------------------------------------------------------------------
 1 | ### 852. 山脉数组的峰顶索引
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`二分查找`
 6 | 
 7 | 我们把符合下列属性的数组 `A` 称作山脉：
 8 | 
 9 | 
10 | 
11 | 
12 | * `A.length >= 3`
13 | 
14 | * 存在  `0 < i< A.length - 1`  使得 `A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1]`
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 给定一个确定为山脉的数组，返回任何满足 `A[0] < A[1] < ... A[i-1] < A[i] > A[i+1] > ... > A[A.length - 1]` 的  `i` 的值。
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | 
28 | **示例 1：** 
29 | 
30 | 
31 | 
32 | ```
33 | 输入：[0,1,0]
34 | 输出：1
35 | ```
36 | 
37 | 
38 | **示例 2：** 
39 | 
40 | 
41 | 
42 | ```
43 | 输入：[0,2,1,0]
44 | 输出：1
45 | ```
46 | 
47 | 
48 | 
49 | 
50 | 
51 | 
52 | **提示：** 
53 | 
54 | 
55 | 
56 | 
57 | 1.  `3 <= A.length <= 10000` 
58 | 
59 | 2. 0 <= A[i] <= 10^6
60 | 
61 | 3. A 是如上定义的山脉
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | 
69 | 
70 | ```
71 | /**
72 |  * @param {number[]} A
73 |  * @return {number}
74 |  */
75 | var peakIndexInMountainArray = function(A) {
76 |     return A.findIndex(n=>n===Math.max.apply(this,A))
77 | };
78 | ```
79 | 
80 | 


--------------------------------------------------------------------------------
/801-900/867.md:
--------------------------------------------------------------------------------
 1 | ### 867. 转置矩阵
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个矩阵 `A` ，返回 `A` 的转置矩阵。
 8 | 
 9 | 
10 | 
11 | 矩阵的转置是指将矩阵的主对角线翻转，交换矩阵的行索引与列索引。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：[[1,2,3],[4,5,6],[7,8,9]]
25 | 输出：[[1,4,7],[2,5,8],[3,6,9]]
26 | ```
27 | 
28 | 
29 | **示例 2：** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入：[[1,2,3],[4,5,6]]
35 | 输出：[[1,4],[2,5],[3,6]]
36 | ```
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | **提示：** 
44 | 
45 | 
46 | 
47 | 
48 | 1.  `1 <= A.length<= 1000` 
49 | 
50 | 2.  `1 <= A[0].length<= 1000` 
51 | 
52 | 
53 | 
54 | 
55 | ```
56 | /**
57 |  * @param {number[][]} A
58 |  * @return {number[][]}
59 |  */
60 | var transpose = function(A) {
61 |   let m=A.length,n=A[0].length
62 |   let res=Array(n).fill().map(()=>Array(m).fill(0))
63 |   for(let i=0;i<m;i++){
64 |     for(let j=0;j<n;j++){
65 |       res[j][i]=A[i][j]
66 |     }
67 |   }
68 |   return res
69 | };
70 | ```
71 | 
72 | 


--------------------------------------------------------------------------------
/801-900/870.md:
--------------------------------------------------------------------------------
 1 | ### 870. 优势洗牌
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`贪心算法`、`数组`
 6 | 
 7 | 给定两个大小相等的数组 `A` 和 `B` ，A 相对于 B 的*优势* 可以用满足 `A[i] > B[i]` 的索引  `i` 的数目来描述。
 8 | 
 9 | 
10 | 
11 | 返回 `A` 的**任意** 排列，使其相对于  `B` 的优势最大化。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例 1：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：A = [2,7,11,15], B = [1,10,4,11]
25 | 输出：[2,11,7,15]
26 | ```
27 | 
28 | 
29 | **示例 2：** 
30 | 
31 | 
32 | 
33 | ```
34 | 输入：A = [12,24,8,32], B = [13,25,32,11]
35 | 输出：[24,32,8,12]
36 | ```
37 | 
38 | 
39 | 
40 | 
41 | 
42 | 
43 | **提示：** 
44 | 
45 | 
46 | 
47 | 
48 | 1.  `1 <= A.length = B.length <= 10000` 
49 | 
50 | 2.  `0 <= A[i] <= 10^9` 
51 | 
52 | 3.  `0 <= B[i] <= 10^9` 
53 | 
54 | 
55 | 
56 | 
57 | ```
58 | /**
59 |  * @param {number[]} A
60 |  * @param {number[]} B
61 |  * @return {number[]}
62 |  */
63 | var advantageCount = function(A, B) {
64 |   A.sort((a,b)=>a-b)
65 |   let sortedB=B.map((n,i)=>i).sort((a,b)=>B[b]-B[a])
66 |   let res=[]
67 |   let minID=0,maxID=A.length-1
68 |   for(let i=0;i<sortedB.length;i++){
69 |     let id=sortedB[i],
70 |         val=B[id]
71 |     if(A[maxID]>val){
72 |       res[id]=A[maxID--]
73 |     }else{
74 |       res[id]=A[minID++]
75 |     }
76 |   }
77 |   return res
78 | };
79 | ```
80 | 
81 | 


--------------------------------------------------------------------------------
/901-1000/905.md:
--------------------------------------------------------------------------------
 1 | ### 905. 按奇偶排序数组
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数组`
 6 | 
 7 | 给定一个非负整数数组  `A` ，返回一个数组，在该数组中， `A`  的所有偶数元素之后跟着所有奇数元素。
 8 | 
 9 | 
10 | 
11 | 你可以返回满足此条件的任何数组作为答案。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | **示例：** 
20 | 
21 | 
22 | 
23 | ```
24 | 输入：[3,1,2,4]
25 | 输出：[2,4,3,1]
26 | 输出 [4,2,3,1]，[2,4,1,3] 和 [4,2,1,3] 也会被接受。
27 | ```
28 | 
29 | 
30 | 
31 | 
32 | 
33 | 
34 | **提示：** 
35 | 
36 | 
37 | 
38 | 
39 | 1.  `1 <= A.length <= 5000` 
40 | 
41 | 2.  `0 <= A[i] <= 5000` 
42 | 
43 | 
44 | 
45 | 
46 | ```
47 | /**
48 |  * @param {number[]} A
49 |  * @return {number[]}
50 |  */
51 | var sortArrayByParity = function(A) {
52 |     let res=[]
53 |     for(let i=0;i<A.length;i++){
54 |         let cur=A[i]
55 |         if(cur % 2 ===0){
56 |             res.unshift(cur)
57 |         }else{
58 |             res.push(cur)
59 |         }
60 |     }
61 |     return res
62 | };
63 | ```
64 | 
65 | 


--------------------------------------------------------------------------------
/901-1000/912.md:
--------------------------------------------------------------------------------
 1 | ### 912. 排序数组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：
 6 | 
 7 | 给定一个整数数组 `nums` ，将该数组升序排列。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 | **示例 1：** 
21 | 
22 | 
23 | 
24 | ```
25 | 
26 | 输入：[5,2,3,1]
27 | 输出：[1,2,3,5]
28 | ```
29 | 
30 | 
31 | **示例 2：** 
32 | 
33 | 
34 | 
35 | ```
36 | 
37 | 输入：[5,1,1,2,0,0]
38 | 输出：[0,0,1,1,2,5]
39 | ```
40 | 
41 | 
42 | 
43 | 
44 | 
45 | 
46 | **提示：** 
47 | 
48 | 
49 | 
50 | 
51 | 1.  `1 <= A.length <= 10000` 
52 | 
53 | 2.  `-50000 <= A[i] <= 50000` 
54 | 
55 | 
56 | 
57 | 
58 | ```
59 | /**
60 |  * @param {number[]} nums
61 |  * @return {number[]}
62 |  */
63 | var sortArray = function(nums) {
64 |   partition(0,nums.length-1)
65 |   return nums
66 |   function partition(i,j){
67 |     if(i>=j)return
68 |     let p=nums[j],l=i,r=j-1
69 |     while(l<=r){
70 |       while(l<=r && nums[l]<p)l++
71 |       while(l<=r && nums[r]>p)r--
72 |       if(l>r)break
73 |       swap(nums,l++,r--)
74 |     }
75 |     swap(nums,l,j)
76 |     partition(i,l-1)
77 |     partition(l+1,j)
78 |   }
79 |   function swap(arr,i,j){
80 |     let t=arr[i]
81 |     arr[i]=arr[j]
82 |     arr[j]=t
83 |   }
84 | };
85 | ```
86 | 
87 | 


--------------------------------------------------------------------------------
/901-1000/917.md:
--------------------------------------------------------------------------------
 1 | ### 917. 仅仅反转字母
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`字符串`
 6 | 
 7 | 给定一个字符串 `S` ，返回&ldquo;反转后的&rdquo;字符串，其中不是字母的字符都保留在原地，而所有字母的位置发生反转。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 | **示例 1：** 
21 | 
22 | 
23 | 
24 | ```
25 | 输入："ab-cd"
26 | 输出："dc-ba"
27 | ```
28 | 
29 | 
30 | **示例 2：** 
31 | 
32 | 
33 | 
34 | ```
35 | 输入："a-bC-dEf-ghIj"
36 | 输出："j-Ih-gfE-dCba"
37 | ```
38 | 
39 | 
40 | **示例 3：** 
41 | 
42 | 
43 | 
44 | ```
45 | 输入："Test1ng-Leet=code-Q!"
46 | 输出："Qedo1ct-eeLg=ntse-T!"
47 | ```
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | **提示：** 
55 | 
56 | 
57 | 
58 | 
59 | 1.  `S.length <= 100` 
60 | 
61 | 2.  `33 <= S[i].ASCIIcode <= 122` 
62 | 
63 | 3.  `S`  中不包含 `\`  or  `"` 
64 | 
65 | 
66 | 
67 | 
68 | ```
69 | /**
70 |  * @param {string} S
71 |  * @return {string}
72 |  */
73 | var reverseOnlyLetters = function(S) {
74 |   let rs=''
75 |   for(let i=S.length-1;i>=0;i--){
76 |     if(/[a-zA-Z]/.test(S[i]))rs+=S[i]
77 |   }
78 |   let result='',j=0
79 |   for(let i=0;i<S.length;i++){
80 |     if(/[a-zA-Z]/.test(S[i]))result+=rs[j++]
81 |     else result+=S[i]
82 |   }
83 |   return result
84 | };
85 | ```
86 | 
87 | 


--------------------------------------------------------------------------------
/901-1000/922.md:
--------------------------------------------------------------------------------
 1 | ### 922. 按奇偶排序数组 II
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`排序`、`数组`
 6 | 
 7 | 给定一个非负整数数组 `A` ， A 中一半整数是奇数，一半整数是偶数。
 8 | 
 9 | 
10 | 
11 | 对数组进行排序，以便当 `A[i]`  为奇数时， `i` 也是奇数；当 `A[i]` 为偶数时，  `i`  也是偶数。
12 | 
13 | 
14 | 
15 | 你可以返回任何满足上述条件的数组作为答案。
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | **示例：** 
24 | 
25 | 
26 | 
27 | ```
28 | 输入：[4,2,5,7]
29 | 输出：[4,5,2,7]
30 | 解释：[4,7,2,5]，[2,5,4,7]，[2,7,4,5] 也会被接受。
31 | ```
32 | 
33 | 
34 | 
35 | 
36 | 
37 | 
38 | **提示：** 
39 | 
40 | 
41 | 
42 | 
43 | 1.  `2 <= A.length <= 20000` 
44 | 
45 | 2.  `A.length % 2 == 0` 
46 | 
47 | 3.  `0 <= A[i] <= 1000` 
48 | 
49 | 
50 | 
51 | 
52 | 
53 | 
54 | 
55 | 
56 | ```
57 | /**
58 |  * @param {number[]} A
59 |  * @return {number[]}
60 |  */
61 | var sortArrayByParityII = function(A) {
62 |   let res=[]
63 |   let oddIdx=1,
64 |       evenIdx=0
65 |   for(let i=0;i<A.length;i++){
66 |     if(A[i]%2===0){
67 |       res[evenIdx]=A[i]
68 |       evenIdx+=2
69 |     }else{
70 |       res[oddIdx]=A[i]
71 |       oddIdx+=2
72 |     }
73 |   }
74 |   return res
75 | };
76 | ```
77 | 
78 | 


--------------------------------------------------------------------------------
/901-1000/930.md:
--------------------------------------------------------------------------------
 1 | ### 930. 和相同的二元子数组
 2 | 
 3 | 难度：Middle
 4 | 
 5 | 相关话题：`哈希表`、`双指针`
 6 | 
 7 | 在由若干 `0` 和 `1`  组成的数组 `A` 中，有多少个和为  `S` 的**非空** 子数组。
 8 | 
 9 | 
10 | 
11 | 
12 | 
13 | 
14 | 
15 | **示例：** 
16 | 
17 | 
18 | 
19 | ```
20 | 输入：A = [1,0,1,0,1], S = 2
21 | 输出：4
22 | 解释：
23 | 如下面黑体所示，有 4 个满足题目要求的子数组：
24 | [1,0,1,0,1]
25 | [1,0,1,0,1]
26 | [1,0,1,0,1]
27 | [1,0,1,0,1]
28 | ```
29 | 
30 | 
31 | 
32 | 
33 | 
34 | 
35 | **提示：** 
36 | 
37 | 
38 | 
39 | 
40 | 1.  `A.length <= 30000` 
41 | 
42 | 2.  `0 <= S <= A.length` 
43 | 
44 | 3.  `A[i]` 为 `0` 或 `1` 
45 | 
46 | 
47 | 
48 | 
49 | 
50 | 
51 | -----
52 | 
53 | 思路：
54 | 
55 | 遍历数组`A`，不断求出当前位置之前的和`preSum`，并且保存进`hash`，如果发现`preSum>=S`，
56 | 说明有可能存在一组连续的子数组的和为`S`，这时检查`hash[preSum-S]`，如果发现存在，
57 | 说明之前存在`hash[preSum-S]`个位置，与当前位置的差值为`S`。
58 | 
59 | ```
60 | /**
61 |  * @param {number[]} A
62 |  * @param {number} S
63 |  * @return {number}
64 |  */
65 | var numSubarraysWithSum = function(A, S) {
66 |   let hash=[1],preSum=0,result=0
67 |   for(let i=0;i<A.length;i++){
68 |     preSum+=A[i]
69 |     if(preSum>=S)result+=hash[preSum-S] || 0
70 |     if(!hash[preSum])hash[preSum]=1
71 |     else hash[preSum]++
72 |   }
73 |   return result
74 | };
75 | ```
76 | 
77 | 


--------------------------------------------------------------------------------
/901-1000/942.md:
--------------------------------------------------------------------------------
 1 | ### 942. 增减字符串匹配
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`数学`
 6 | 
 7 | 给定只含 `"I"` （增大）或  `"D"` （减小）的字符串 `S` ，令 `N = S.length` 。
 8 | 
 9 | 
10 | 
11 | 返回 `[0, 1, ..., N]` 的任意排列 `A` 使得对于所有 `i = 0,..., N-1` ，都有：
12 | 
13 | 
14 | 
15 | 
16 | * 如果 `S[i] == "I"` ，那么 `A[i] < A[i+1]`
17 | 
18 | * 如果 `S[i] == "D"` ，那么 `A[i] > A[i+1]`
19 | 
20 | 
21 | 
22 | 
23 | 
24 | 
25 | 
26 | 
27 | 
28 | **示例 1：** 
29 | 
30 | 
31 | 
32 | ```
33 | 输出："IDID"
34 | 输出：[0,4,1,3,2]
35 | ```
36 | 
37 | 
38 | **示例 2：** 
39 | 
40 | 
41 | 
42 | ```
43 | 输出："III"
44 | 输出：[0,1,2,3]
45 | ```
46 | 
47 | 
48 | **示例 3：** 
49 | 
50 | 
51 | 
52 | ```
53 | 输出："DDI"
54 | 输出：[3,2,0,1]
55 | ```
56 | 
57 | 
58 | 
59 | 
60 | 
61 | 
62 | **提示：** 
63 | 
64 | 
65 | 
66 | 
67 | 1.  `1 <= S.length <= 1000` 
68 | 
69 | 2.  `S`  只包含字符 `"I"` 或 `"D"` 。
70 | 
71 | 
72 | 
73 | 
74 | ```
75 | /**
76 |  * @param {string} S
77 |  * @return {number[]}
78 |  */
79 | var diStringMatch = function(S) {
80 |   let l=0,r=S.length,res=[]
81 |   let id=0
82 |   while(l<r){
83 |     if(S[id]==="D")res.push(r--)
84 |     else res.push(l++)
85 |     id++
86 |   }
87 |   res.push(l)
88 |   return res
89 | };
90 | ```
91 | 
92 | 


--------------------------------------------------------------------------------
/901-1000/961.md:
--------------------------------------------------------------------------------
 1 | ### 961. 重复 N 次的元素
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`哈希表`
 6 | 
 7 | 在大小为  `2N` 的数组  `A` 中有  `N+1`  个不同的元素，其中有一个元素重复了  `N`  次。
 8 | 
 9 | 
10 | 
11 | 返回重复了  `N` 次的那个元素。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例 1：** 
25 | 
26 | 
27 | 
28 | ```
29 | 输入：[1,2,3,3]
30 | 输出：3
31 | ```
32 | 
33 | 
34 | **示例 2：** 
35 | 
36 | 
37 | 
38 | ```
39 | 输入：[2,1,2,5,3,2]
40 | 输出：2
41 | ```
42 | 
43 | 
44 | **示例3：** 
45 | 
46 | 
47 | 
48 | ```
49 | 输入：[5,1,5,2,5,3,5,4]
50 | 输出：5
51 | ```
52 | 
53 | 
54 | 
55 | 
56 | 
57 | 
58 | **提示：** 
59 | 
60 | 
61 | 
62 | 
63 | 1.  `4 <= A.length <= 10000` 
64 | 
65 | 2.  `0 <= A[i] < 10000` 
66 | 
67 | 3.  `A.length` 为偶数
68 | 
69 | 
70 | 
71 | 
72 | ```
73 | /**
74 |  * @param {number[]} A
75 |  * @return {number}
76 |  */
77 | var repeatedNTimes = function(A) {
78 |     let hash={}
79 |     for(let i=0;i<A.length;i++){
80 |       let cur=A[i]
81 |       if(hash[cur]==null)hash[cur]=true
82 |       else return cur
83 |     }
84 | };
85 | ```
86 | 
87 | 


--------------------------------------------------------------------------------
/901-1000/976.md:
--------------------------------------------------------------------------------
 1 | ### 976. 三角形的最大周长
 2 | 
 3 | 难度：Easy
 4 | 
 5 | 相关话题：`排序`、`数学`
 6 | 
 7 | 给定由一些正数（代表长度）组成的数组  `A` ，返回由其中三个长度组成的、**面积不为零** 的三角形的最大周长。
 8 | 
 9 | 
10 | 
11 | 如果不能形成任何面积不为零的三角形，返回 `0` 。
12 | 
13 | 
14 | 
15 | 
16 | 
17 | 
18 | 
19 | 
20 | 
21 | 
22 | 
23 | 
24 | **示例 1：** 
25 | 
26 | 
27 | 
28 | ```
29 | 输入：[2,1,2]
30 | 输出：5
31 | ```
32 | 
33 | 
34 | **示例 2：** 
35 | 
36 | 
37 | 
38 | ```
39 | 输入：[1,2,1]
40 | 输出：0
41 | ```
42 | 
43 | 
44 | **示例 3：** 
45 | 
46 | 
47 | 
48 | ```
49 | 输入：[3,2,3,4]
50 | 输出：10
51 | ```
52 | 
53 | 
54 | **示例 4：** 
55 | 
56 | 
57 | 
58 | ```
59 | 输入：[3,6,2,3]
60 | 输出：8
61 | ```
62 | 
63 | 
64 | 
65 | 
66 | 
67 | 
68 | **提示：** 
69 | 
70 | 
71 | 
72 | 
73 | 1.  `3 <= A.length <= 10000` 
74 | 
75 | 2.  `1 <= A[i] <= 10^6` 
76 | 
77 | 
78 | 
79 | 
80 | ```
81 | /**
82 |  * @param {number[]} A
83 |  * @return {number}
84 |  */
85 | var largestPerimeter = function(A) {
86 |   A.sort((a,b)=>b-a)
87 |   let max=0
88 |     for(let i=0;i<A.length-2;i++){
89 |           let eI=A[i],eJ=A[i+1],eK=A[i+2]
90 |           if(eI<eJ+eK)
91 |           return eI+eJ+eK
92 |     }
93 |   return 0
94 | };
95 | ```
96 | 
97 | 


--------------------------------------------------------------------------------
/README.md:
--------------------------------------------------------------------------------
 1 | Leetcode题解(Javascript)
 2 | 
 3 | 全部使用`js`解决，对于一名小前端来说，`js`是用的最顺手的一门语言，但是用它做算法题有部分缺陷：
 4 | 
 5 | 1. 没有内置数据结构，例如`TreeSet`，`PriorityQueue`等等，这些数据结构要么就手撕一个，然后保存，以后方便使用；要么就模拟一个，性能没那么好，但也能接受的。
 6 | 
 7 | 2. 数字精度问题，`js`数字超过`15`还是`16`位后就不精确了，这使得处理部分问题不得不另寻办法处理这种高位数字。
 8 | 
 9 | 3. 性能问题，虽然是动态语言，但其实这个并不是特别大的问题，在`leetcode`下使用`es6`性能并不差，特别是`map`和`{}`，往往相差巨大。
10 | 
11 | 当然，算法思想是不受语言限制的，部分题目有解题思路说明(之后不断补充)，希望能帮到想学算法的`JSER`。
12 | 


--------------------------------------------------------------------------------