From 04d1899da7cdded97486f818576f9c1ff82b7361 Mon Sep 17 00:00:00 2001
From: Celia_Wu <530081999@qq.com>
Date: Sun, 8 Sep 2019 10:47:25 -0400
Subject: [PATCH] 2019-09-08

---
 ...44\346\225\260\344\271\213\345\222\214.py" |  15 +++
 ...44\346\225\260\347\233\270\345\212\240.py" |  39 ++++++
 ...00\351\225\277\345\255\220\344\270\262.py" |  16 +++
 ...04\344\270\255\344\275\215\346\225\260.py" |  64 ++++------
 ...36\346\226\207\345\255\220\344\270\262.py" |  36 +++---
 ...27\345\275\242\345\217\230\346\215\242.py" |  51 ++++----
 ...64\346\225\260\345\217\215\350\275\254.py" |  19 ++-
 ...\215\242\346\225\264\346\225\260(atoi).py" |  32 ++---
 ...9-\345\233\236\346\226\207\346\225\260.py" |  22 ++--
 ...64\347\232\204\345\256\271\345\231\250.py" |  20 ++--
 ...54\345\205\261\345\211\215\347\274\200.py" |  10 +-
 ...11\346\225\260\344\271\213\345\222\214.py" |  29 ++---
 ...11\346\225\260\344\271\213\345\222\214.py" |  19 +--
 ...27\346\257\215\347\273\204\345\220\210.py" |  27 ++---
 ...33\346\225\260\344\271\213\345\222\214.py" |  53 ++++----
 ...4N\344\270\252\350\212\202\347\202\271.py" |  34 +++---
 ...10\347\232\204\346\213\254\345\217\267.py" |  19 +--
 ...11\345\272\217\351\223\276\350\241\250.py" |  31 +++++
 ...54\345\217\267\347\224\237\346\210\220.py" |  29 +++--
 ...22\345\272\217\351\223\276\350\241\250.py" |  30 +++++
 ...55\347\232\204\350\212\202\347\202\271.py" |  26 ++++
 ...04\351\207\215\345\244\215\351\241\271.py" |  11 +-
 ...73\351\231\244\345\205\203\347\264\240.py" |  26 ++--
 .../0028-\345\256\236\347\216\260strStr().py" |  17 +++
 ...44\346\225\260\347\233\270\351\231\244.py" |  27 ++---
 ...00\344\270\252\346\216\222\345\210\227.py" |  34 +++---
 ...11\346\225\210\346\213\254\345\217\267.py" |  19 +++
 ...22\345\272\217\346\225\260\347\273\204.py" |  47 ++++----
 ...00\344\270\252\344\275\215\347\275\256.py" |  70 ++++++-----
 ...22\345\205\245\344\275\215\347\275\256.py" |  19 +--
 ...10\347\232\204\346\225\260\347\213\254.py" |  14 +--
 ...7-\350\247\243\346\225\260\347\213\254.py" |  65 +++++-----
 .../0038-\346\212\245\346\225\260.py"         |  20 ++++
 ...04\345\220\210\346\200\273\345\222\214.py" |  29 +++--
 ...\345\220\210\346\200\273\345\222\214II.py" |  39 +++---
 ...00\344\270\252\346\255\243\346\225\260.py" |  24 ++--
 ...2-\346\216\245\351\233\250\346\260\264.py" |  35 +++---
 ...46\344\270\262\347\233\270\344\271\230.py" | 113 +++++++++---------
 ...15\347\254\246\345\214\271\351\205\215.py" |  35 ++++++
 ...6-\345\205\250\346\216\222\345\210\227.py" |  22 ++--
 ...\345\205\250\346\216\222\345\210\227II.py" |  27 ++---
 ...13\350\275\254\345\233\276\345\203\217.py" |  20 ++++
 ...15\350\257\215\345\210\206\347\273\204.py" |  18 +--
 0050.Pow(x,n)/0050-Pow(x,n).py                |  27 +++--
 .../0051-N\347\232\207\345\220\216.py"        |  77 +++++-------
 .../0052-N\347\232\207\345\220\216II.py"      |  78 +++++-------
 ...47\345\255\220\345\272\217\345\222\214.py" |  18 +--
 ...72\346\227\213\347\237\251\351\230\265.py" |  58 +++++----
 ...63\350\267\203\346\270\270\346\210\217.py" |  13 +-
 ...10\345\271\266\345\214\272\351\227\264.py" |  34 ++----
 ...22\345\205\245\345\214\272\351\227\264.py" |  46 +++----
 ...15\347\232\204\351\225\277\345\272\246.py" |  14 ++-
 ...\346\227\213\347\237\251\351\230\265II.py" |  45 +++++--
 ...4k\344\270\252\346\216\222\345\210\227.py" |  32 +++--
 ...13\350\275\254\351\223\276\350\241\250.py" |  40 +++----
 ...15\345\220\214\350\267\257\345\276\204.py" |  23 ++--
 ...\345\220\214\350\267\257\345\276\204II.py" |  28 +++++
 ...17\350\267\257\345\276\204\345\222\214.py" |  32 ++---
 .../0066-\345\212\240\344\270\200.py"         |  29 ++---
 ...33\345\210\266\346\261\202\345\222\214.py" |  24 +++-
 ...04\345\271\263\346\226\271\346\240\271.py" |  21 ++++
 ...0-\347\210\254\346\245\274\346\242\257.py" |  29 ++---
 ...00\345\214\226\350\267\257\345\276\204.py" |  18 ++-
 ...26\350\276\221\350\267\235\347\246\273.py" |  24 ++--
 ...51\351\230\265\347\275\256\351\233\266.py" |  28 ++---
 ...14\347\273\264\347\237\251\351\230\265.py" |  32 +++--
 ...34\350\211\262\345\210\206\347\261\273.py" |  42 +++----
 .../0077-\347\273\204\345\220\210.py"         |  19 ++-
 .../0078-\345\255\220\351\233\206.py"         |  26 ++--
 ...25\350\257\215\346\220\234\347\264\242.py" |  51 ++++----
 ...\351\207\215\345\244\215\351\241\271II.py" |   1 +
 ...\345\272\217\346\225\260\347\273\204II.py" | 106 +---------------
 ...\345\244\215\345\205\203\347\264\240II.py" |  30 ++---
 ...15\345\244\215\345\205\203\347\264\240.py" |  20 ++++
 ...47\347\232\204\347\237\251\345\275\242.py" |  15 +--
 ...11\345\272\217\346\225\260\347\273\204.py" |  28 +----
 ...74\351\233\267\347\274\226\347\240\201.py" |   9 +-
 .../0090-\345\255\220\351\233\206II.py"       |  18 +--
 ...\350\275\254\351\223\276\350\241\250II.py" |  74 +++++-------
 ...11\346\220\234\347\264\242\346\240\221.py" |  24 +---
 ...11\346\220\234\347\264\242\346\240\221.py" |  33 +++++
 ...70\345\220\214\347\232\204\346\240\221.py" |  24 +---
 ...60\344\272\214\345\217\211\346\240\221.py" |  26 ++--
 ...02\346\254\241\351\201\215\345\216\206.py" |  29 ++---
 ...02\346\254\241\351\201\215\345\216\206.py" |  37 +++---
 ...00\345\244\247\346\267\261\345\272\246.py" |  16 +++
 ...40\344\272\214\345\217\211\346\240\221.py" |  18 +--
 ...40\344\272\214\345\217\211\346\240\221.py" |  24 ++--
 ...\346\254\241\351\201\215\345\216\206II.py" |  40 ++-----
 ...11\346\220\234\347\264\242\346\240\221.py" |  19 +--
 ...11\346\220\234\347\264\242\346\240\221.py" |  43 +++----
 ...41\344\272\214\345\217\211\346\240\221.py" |  31 +++--
 ...00\345\260\217\346\267\261\345\272\246.py" |  21 ++--
 ...57\345\276\204\346\200\273\345\222\214.py" |  26 +---
 ...\345\276\204\346\200\273\345\222\214II.py" |  22 ++--
 ...00\344\270\272\351\223\276\350\241\250.py" |  22 ++--
 ...02\347\202\271\346\214\207\351\222\210.py" |  38 +++---
 ...\347\202\271\346\214\207\351\222\210II.py" |  55 +++++----
 ...50\350\276\211\344\270\211\350\247\222.py" |  16 +++
 ...\350\276\211\344\270\211\350\247\222II.py" |  30 ++---
 ...17\350\267\257\345\276\204\345\222\214.py" |  19 +--
 ...00\344\275\263\346\227\266\346\234\272.py" |  29 +++--
 ...\344\275\263\346\227\266\346\234\272II.py" |  16 ++-
 ...344\275\263\346\227\266\346\234\272III.py" |  21 ++++
 ...01\345\233\236\346\226\207\344\270\262.py" |  23 +---
 ...\350\257\215\346\216\245\351\276\231II.py" | 113 ++++++++++++++++++
 ...25\350\257\215\346\216\245\351\276\231.py" |  47 ++++----
 ...36\347\273\255\345\272\217\345\210\227.py" |  21 ++++
 ...60\345\255\227\344\271\213\345\222\214.py" |   9 +-
 ...25\347\232\204\345\214\272\345\237\237.py" | 103 ++++------------
 ...\345\233\236\346\226\207\344\270\262II.py" |  29 +++++
 ...3-\345\205\213\351\232\206\345\233\276.py" |  41 ++-----
 ...4-\345\212\240\346\262\271\347\253\231.py" |  32 +++--
 ...41\347\232\204\346\225\260\345\255\227.py" |  11 +-
 ...\347\232\204\346\225\260\345\255\227II.py" |   4 +-
 ...10\347\232\204\351\223\276\350\241\250.py" |  31 +++++
 ...25\350\257\215\346\213\206\345\210\206.py" |  14 +--
 ...57\345\275\242\351\223\276\350\241\250.py" |  24 ++++
 ...\345\275\242\351\223\276\350\241\250II.py" |  34 ++++++
 ...15\346\216\222\351\223\276\350\241\250.py" |  43 ++++---
 ...15\345\272\217\351\201\215\345\216\206.py" |  15 ++-
 ...16\345\272\217\351\201\215\345\216\206.py" |  15 ++-
 ...23\345\255\230\346\234\272\345\210\266.py" |  44 +++++++
 ...22\345\205\245\346\216\222\345\272\217.py" |  41 ++++---
 ...22\345\272\217\351\223\276\350\241\250.py" |  39 +++---
 ...76\345\274\217\346\261\202\345\200\274.py" |  35 +++---
 ...14\347\232\204\345\215\225\350\257\215.py" |  15 +--
 ...47\345\255\220\345\272\217\345\210\227.py" |  22 ++--
 ...04\346\234\200\345\260\217\345\200\274.py" |  34 ++++--
 ...\346\234\200\345\260\217\345\200\274II.py" |  25 +++-
 ...5-\346\234\200\345\260\217\346\240\210.py" |  23 ++--
 ...54\344\272\214\345\217\211\346\240\221.py" |  26 ++--
 ...6N\344\270\252\345\255\227\347\254\246.py" |  26 ++--
 ...00\351\225\277\345\255\220\344\270\262.py" |  46 +++----
 ...70\344\272\244\351\223\276\350\241\250.py" |  49 +++-----
 ...26\350\276\221\350\267\235\347\246\273.py" |  22 ++--
 ...73\346\211\276\345\263\260\345\200\274.py" |   6 +-
 ...61\347\232\204\345\214\272\351\227\264.py" |  42 +++----
 ...00\345\244\247\351\227\264\350\267\235.py" |   3 +-
 ...03\347\211\210\346\234\254\345\217\267.py" |   1 -
 ...11\345\272\217\346\225\260\347\273\204.py" |   9 +-
 ...50\345\210\227\345\220\215\347\247\260.py" |  13 +-
 ...9-\346\261\202\344\274\227\346\225\260.py" |   5 +-
 ...23\346\236\204\350\256\276\350\256\241.py" |  38 ++++++
 ...50\345\210\227\345\272\217\345\217\267.py" |   9 +-
 ...30\345\220\216\347\232\204\351\233\266.py" |   5 +-
 ...21\350\277\255\344\273\243\345\231\250.py" |  23 ++--
 ...\344\275\263\346\227\266\346\234\272IV.py" |  41 +++++++
 ...13\350\275\254\346\225\260\347\273\204.py" |  11 +-
 ...14\350\277\233\345\210\266\344\275\215.py" |  12 +-
 ...51\347\232\204\344\270\252\346\225\260.py" |   7 +-
 ...23\345\256\266\345\212\253\350\210\215.py" |  20 ++--
 ...04\345\217\263\350\247\206\345\233\276.py" |  33 ++---
 ...33\345\261\277\346\225\260\351\207\217.py" |  36 +++---
 ...64\346\214\211\344\275\215\344\270\216.py" |  13 ++
 ...2-\345\277\253\344\271\220\346\225\260.py" |  26 ++--
 ...76\350\241\250\345\205\203\347\264\240.py" |  25 ++--
 ...41\346\225\260\350\264\250\346\225\260.py" |  19 +--
 ...04\345\255\227\347\254\246\344\270\262.py" |  17 +++
 ...15\350\275\254\351\223\276\350\241\250.py" |  25 ++--
 ...23\346\236\204\350\256\276\350\256\241.py" |   8 +-
 ...\350\257\215\346\220\234\347\264\242II.py" |   6 +-
 ...55\345\233\236\346\226\207\344\270\262.py" |   2 +
 ...00\345\244\247\345\205\203\347\264\240.py" |  24 +++-
 ...345\220\210\346\200\273\345\222\214III.py" |  31 +++--
 ...15\345\244\215\345\205\203\347\264\240.py" |   8 +-
 ...\345\244\215\345\205\203\347\264\240II.py" |  12 +-
 ...02\347\202\271\344\270\252\346\225\260.py" |   9 +-
 ...\344\274\232\350\256\256\345\256\244II.py" |  22 ++--
 ...53\345\206\267\345\206\273\346\234\237.py" |  15 +++
 ...54\345\255\227\347\254\246\344\270\262.py" |  13 +-
 ...46\344\270\262\347\233\270\345\212\240.py" |  59 +++++----
 ...53\346\211\213\347\273\255\350\264\271.py" |  18 +++
 ...02\345\205\211\347\273\204\345\220\210.py" |   9 +-
 ...67\346\234\254\347\273\237\350\256\241.py" |  55 +++++++++
 .../1094-\346\213\274\350\275\246.py"         |  20 ++++
 ...76\347\233\256\346\240\207\345\200\274.py" |  52 ++++++++
 README.md                                     |   7 +-
 178 files changed, 2893 insertions(+), 2212 deletions(-)
 create mode 100644 "0001.\344\270\244\346\225\260\344\271\213\345\222\214/0001-\344\270\244\346\225\260\344\271\213\345\222\214.py"
 create mode 100644 "0002.\344\270\244\346\225\260\347\233\270\345\212\240/0002-\344\270\244\346\225\260\347\233\270\345\212\240.py"
 create mode 100644 "0003.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0003-\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
 create mode 100644 "0021.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/0021-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250.py"
 create mode 100644 "0023.\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250/0023-\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.py"
 create mode 100644 "0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/0024-\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.py"
 create mode 100644 "0028.\345\256\236\347\216\260strStr()/0028-\345\256\236\347\216\260strStr().py"
 create mode 100644 "0032.\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/0032-\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267.py"
 create mode 100644 "0038.\346\212\245\346\225\260/0038-\346\212\245\346\225\260.py"
 create mode 100644 "0044.\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/0044-\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215.py"
 create mode 100644 "0048.\346\227\213\350\275\254\345\233\276\345\203\217/0048-\346\227\213\350\275\254\345\233\276\345\203\217.py"
 create mode 100644 "0063.\344\270\215\345\220\214\350\267\257\345\276\204II/0063-\344\270\215\345\220\214\350\267\257\345\276\204II.py"
 create mode 100644 "0083.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240/0083-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240.py"
 create mode 100644 "0099.\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0099-\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
 create mode 100644 "0104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/0104-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.py"
 create mode 100644 "0118.\346\235\250\350\276\211\344\270\211\350\247\222/0118-\346\235\250\350\276\211\344\270\211\350\247\222.py"
 create mode 100644 "0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III/0123-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.py"
 create mode 100644 "0126.\345\215\225\350\257\215\346\216\245\351\276\231II/0126-\345\215\225\350\257\215\346\216\245\351\276\231II.py"
 create mode 100644 "0128.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/0128-\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.py"
 create mode 100644 "0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II/0132-\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.py"
 create mode 100644 "0138.\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/0138-\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.py"
 create mode 100644 "0141.\347\216\257\345\275\242\351\223\276\350\241\250/0141-\347\216\257\345\275\242\351\223\276\350\241\250.py"
 create mode 100644 "0142.\347\216\257\345\275\242\351\223\276\350\241\250II/0142-\347\216\257\345\275\242\351\223\276\350\241\250II.py"
 create mode 100644 "0146.LRU\347\274\223\345\255\230\346\234\272\345\210\266/0146-LRU\347\274\223\345\255\230\346\234\272\345\210\266.py"
 create mode 100644 "0170.\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0170-\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
 create mode 100644 "0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV/0188-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.py"
 create mode 100644 "0201.\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216/0201-\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216.py"
 create mode 100644 "0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262/0205-\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.py"
 create mode 100644 "0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237/0309-\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.py"
 create mode 100644 "0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271/0714-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.py"
 create mode 100644 "1093.\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241/1093-\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241.py"
 create mode 100644 "1094.\346\213\274\350\275\246/1094-\346\213\274\350\275\246.py"
 create mode 100644 "1095.\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274/1095-\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274.py"

diff --git "a/0001.\344\270\244\346\225\260\344\271\213\345\222\214/0001-\344\270\244\346\225\260\344\271\213\345\222\214.py" "b/0001.\344\270\244\346\225\260\344\271\213\345\222\214/0001-\344\270\244\346\225\260\344\271\213\345\222\214.py"
new file mode 100644
index 0000000..9442d88
--- /dev/null
+++ "b/0001.\344\270\244\346\225\260\344\271\213\345\222\214/0001-\344\270\244\346\225\260\344\271\213\345\222\214.py"
@@ -0,0 +1,15 @@
+class Solution(object):
+    def twoSum(self, nums, target):
+        """
+        :type nums: List[int]
+        :type target: int
+        :rtype: List[int]
+        """
+        hashmap = {}
+        for i, x in enumerate(nums):
+            if hashmap.has_key(target - x):
+                return [hashmap[target - x], i]
+            else:
+                hashmap[x] = i
+                
+        return []
\ No newline at end of file
diff --git "a/0002.\344\270\244\346\225\260\347\233\270\345\212\240/0002-\344\270\244\346\225\260\347\233\270\345\212\240.py" "b/0002.\344\270\244\346\225\260\347\233\270\345\212\240/0002-\344\270\244\346\225\260\347\233\270\345\212\240.py"
new file mode 100644
index 0000000..92afc5c
--- /dev/null
+++ "b/0002.\344\270\244\346\225\260\347\233\270\345\212\240/0002-\344\270\244\346\225\260\347\233\270\345\212\240.py"
@@ -0,0 +1,39 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def addTwoNumbers(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        if self.getLength(l1) < self.getLength(l2):
+            l1, l2 = l2, l1
+        head = l1
+        while(l2):
+            l1.val += l2.val
+            l1 = l1.next
+            l2 = l2.next
+        
+        p = head
+        while(p):
+            if p.val > 9:
+                p.val -= 10
+                if p.next:
+                    p.next.val += 1
+                else:
+                    p.next = ListNode(1)
+            p = p.next   
+        return head
+        
+        
+    def getLength(self, l):
+        tmp = 0
+        while(l):
+            tmp += 1
+            l = l.next
+        return tmp
\ No newline at end of file
diff --git "a/0003.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0003-\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py" "b/0003.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0003-\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
new file mode 100644
index 0000000..7fcc3ef
--- /dev/null
+++ "b/0003.\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0003-\346\227\240\351\207\215\345\244\215\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
@@ -0,0 +1,16 @@
+class Solution(object):
+    def lengthOfLongestSubstring(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        record = {}
+        start, res = 0, 0
+        for end in range(len(s)):
+            if s[end] in record:
+                start = max(start, record[s[end]] + 1)
+                
+            record[s[end]] = end
+            res = max(res, end - start + 1)
+            
+        return res
\ No newline at end of file
diff --git "a/0004.\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/0004-\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.py" "b/0004.\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/0004-\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.py"
index 5dbbd99..a36ac3f 100644
--- "a/0004.\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/0004-\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.py"
+++ "b/0004.\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260/0004-\345\257\273\346\211\276\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204\347\232\204\344\270\255\344\275\215\346\225\260.py"
@@ -1,46 +1,22 @@
 from heapq import *
-class MedianFinder(object):
-# 维护两个堆，一个大顶堆，一个小顶堆，小顶堆里的数比大顶堆里的数都要大， 
-# 如果有两个潜在的中位数（两个堆size相同），数据流的中位数就是两个堆顶之和除以2
-# 如果只有一个中位数，就看size更小的那个堆的堆顶
-# 如果新进来的数比小顶堆的数要小，就把它插入大顶堆
-# 如果新进来的数比小顶堆的数要大，就把它插入小顶堆
-# 调整两个堆，使得size 差最大为1
+class DoubleHeap(object):
     def __init__(self):
-        """
-        initialize your data structure here.
-        """
-        self.max_h = list()
-        self.min_h = list()
-        heapify(self.max_h)
-        heapify(self.min_h)
+        self.maxh = []
+        self.minh = []
+        heapify(self.maxh)
+        heapify(self.minh)
         
-
-    def addNum(self, num):
-        """
-        :type num: int
-        :rtype: None
-        """
-        heappush(self.min_h, num)
-        heappush(self.max_h, -heappop(self.min_h))
-        if len(self.max_h) > len(self.min_h):
-            heappush(self.min_h, -heappop(self.max_h))
-
-    def findMedian(self):
-        """
-        :rtype: float
-        """
-        max_len = len(self.max_h)
-        min_len = len(self.min_h)
-        if max_len == min_len: #有两个候选中位数
-            return (self.min_h[0] + -self.max_h[0]) / 2.
-        else:#小顶堆的size 一定 >= 大顶堆的size，所以答案就是小顶堆的堆顶
-            return self.min_h[0] / 1.
+    def insert(self, val):
+        heappush(self.minh, val)
+        heappush(self.maxh, -heappop(self.minh))
+        if len(self.maxh) > len(self.minh):
+            heappush(self.minh, -heappop(self.maxh))
             
-# Your MedianFinder object will be instantiated and called as such:
-# obj = MedianFinder()
-# obj.addNum(num)
-# param_2 = obj.findMedian()
+    def findMedian(self):
+        if len(self.maxh) == len(self.minh):
+            return (self.minh[0] - self.maxh[0]) / 2.0
+        return self.minh[0]/1.0
+
 
 class Solution(object):
     def findMedianSortedArrays(self, nums1, nums2):
@@ -49,9 +25,11 @@ def findMedianSortedArrays(self, nums1, nums2):
         :type nums2: List[int]
         :rtype: float
         """
-        mf = MedianFinder()
+        dh = DoubleHeap()
         for num in nums1:
-            mf.addNum(num)
+            dh.insert(num)
+            
         for num in nums2:
-            mf.addNum(num)
-        return mf.findMedian()
\ No newline at end of file
+            dh.insert(num)
+            
+        return dh.findMedian()
\ No newline at end of file
diff --git "a/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/0005-\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py" "b/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/0005-\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py"
index 22d6540..d1f7847 100644
--- "a/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/0005-\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py"
+++ "b/0005.\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262/0005-\346\234\200\351\225\277\345\233\236\346\226\207\345\255\220\344\270\262.py"
@@ -4,24 +4,30 @@ def longestPalindrome(self, s):
         :type s: str
         :rtype: str
         """
-        max_l = 0
-        res = ""
-        for i in range(0, len(s)):
-            #以s[i] 为中心向左右扩散
+        left, right = 0, 0
+        res, string = 0, ""
+        for i in range(len(s)):
             left, right = i, i
             while(left >= 0 and right < len(s) and s[left] == s[right]):
-                if max_l < right - left + 1:
-                    max_l = right - left + 1
-                    res = s[left:right + 1]
                 left -= 1
                 right += 1
-                        
-            #以s[i],s[i+1]为中心向左右扩散
-            left, right = i, i + 1
+            left += 1
+            right -= 1
+            
+            if right - left + 1 > res:
+                res = right - left + 1
+                string = s[left:right + 1]
+                
+        for i in range(1, len(s)):
+            left, right = i - 1, i
             while(left >= 0 and right < len(s) and s[left] == s[right]):
-                if max_l < right - left + 1:
-                    max_l = right - left + 1
-                    res = s[left:right + 1]
                 left -= 1
-                right += 1            
-        return res
\ No newline at end of file
+                right += 1
+            left += 1
+            right -= 1
+            
+            if right - left + 1 > res:
+                res = right - left + 1
+                string = s[left:right + 1]      
+        return string
+        
\ No newline at end of file
diff --git "a/0006.Z\345\255\227\345\275\242\345\217\230\346\215\242/0006-Z\345\255\227\345\275\242\345\217\230\346\215\242.py" "b/0006.Z\345\255\227\345\275\242\345\217\230\346\215\242/0006-Z\345\255\227\345\275\242\345\217\230\346\215\242.py"
index 345c29c..ddac202 100644
--- "a/0006.Z\345\255\227\345\275\242\345\217\230\346\215\242/0006-Z\345\255\227\345\275\242\345\217\230\346\215\242.py"
+++ "b/0006.Z\345\255\227\345\275\242\345\217\230\346\215\242/0006-Z\345\255\227\345\275\242\345\217\230\346\215\242.py"
@@ -1,35 +1,40 @@
 class Solution(object):
-    def convert(self, s, n):
+    def convert(self, s, numRows):
         """
         :type s: str
         :type numRows: int
         :rtype: str
         """
-        #找规律
-        if n <= 1:
+        #第一行和最后一行都是相差 2 * (n - 1)
+        #对于直角在上面的直角三角形， 相差 2 * (n - 1 - i)
+        #对于直角在下面的直角三角形， 相差 2 * i
+        if not s or numRows == 1:
             return s
-        l = len(s)
         res = ""
-        for i in range(n):
-            tmp, index = "", i
-            if i in [0, n - 1]:
-                while(index < l):
-                    
-                    tmp += s[index]
-                    index += 2 * (n - 1)
+        for idx in range(numRows):
+            if idx < len(s):
+                res += s[idx]
+            
+            if idx in [0, numRows - 1]:
+                tmp = idx + 2 *(numRows - 1)
+                while tmp < len(s):
+                    res += s[tmp]
+                    tmp += 2 *(numRows - 1)
             else:
-                state = "down"
-                while(index < l):
-                    tmp += s[index]
-                    if state == "down":
-                        state = "up"
-                        index += 2 * (n - 1 - i)
-                    else:
-                        state = "down"
-                        index += 2 * i
-            res += tmp
-
+                tmp = idx + 2 * (numRows - 1 - idx)
+                tri = "down"
+                while tmp < len(s):
+                    res += s[tmp]
+                    if tri == "up":
+                        tmp += 2 * (numRows - 1 - idx)
+                        tri = "down"
+                    else:       
+                        tmp += 2 * idx
+                        tri = "up"
+                    
         return res
                     
-                        
+            
+                    
+            
             
\ No newline at end of file
diff --git "a/0007.\346\225\264\346\225\260\345\217\215\350\275\254/0007-\346\225\264\346\225\260\345\217\215\350\275\254.py" "b/0007.\346\225\264\346\225\260\345\217\215\350\275\254/0007-\346\225\264\346\225\260\345\217\215\350\275\254.py"
index ff7dd8e..82df21d 100644
--- "a/0007.\346\225\264\346\225\260\345\217\215\350\275\254/0007-\346\225\264\346\225\260\345\217\215\350\275\254.py"
+++ "b/0007.\346\225\264\346\225\260\345\217\215\350\275\254/0007-\346\225\264\346\225\260\345\217\215\350\275\254.py"
@@ -4,19 +4,16 @@ def reverse(self, x):
         :type x: int
         :rtype: int
         """
-
-        flag = 0
+        INT_MIN = -2 **31
+        INT_MAX = 2 ** 31 - 1
+        op = 1
         if x < 0:
-            flag = 1
-        if flag:
+            op = -1
             s = str(x)[1:]
-            s = s[::-1]
-            x = -1 *int(s)            
         else:
             s = str(x)
-            s = s[::-1]
-            x = int(s)
             
-        if x < -1 * 2 **31 or x > 2** 31 -1:
-            return 0    
-        return x
\ No newline at end of file
+        res = op * int(s[::-1])
+        return res if INT_MIN <= res <= INT_MAX else 0
+            
+        
\ No newline at end of file
diff --git "a/0008.\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi)/0008-\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi).py" "b/0008.\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi)/0008-\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi).py"
index 422830d..f817929 100644
--- "a/0008.\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi)/0008-\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi).py"
+++ "b/0008.\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi)/0008-\345\255\227\347\254\246\344\270\262\350\275\254\346\215\242\346\225\264\346\225\260(atoi).py"
@@ -5,32 +5,34 @@ def myAtoi(self, s):
         :rtype: int
         """
         s = s.strip(" ")
-        if not len(s): #排除空
-            return 0
-        if s[0] not in ["+", "-"] and not s[0].isdigit(): #排除第一个非空字符不是数字
+        # print s
+        if not s or (s[0] not in ["+", "-"] and not s[0].isdigit()):
             return 0
+        
         op = 1
-        res = ""
+        tmp = ""
         for i, char in enumerate(s):
-            if i == 0 :
+            if i == 0:
                 if char == "-":
                     op = -1
                     continue
                 elif char == "+":
-                    continue
-            if char == " " or not char.isdigit():
+                    pass
+                    continue       
+            if char.isdigit():
+                tmp += char
+            else:
                 break
-            res += char
-        # print res, op
-        if len(res) > 0:
-            res = op * int(res)
+        # print tmp
+        if tmp:
+            res = op * int(tmp)
         else:
-            return 0
-        INT_MIN = -2 **31
+            res = 0
         INT_MAX = 2 **31 - 1
+        INT_MIN = -2 **31
         if res > INT_MAX:
             return INT_MAX
         elif res < INT_MIN:
             return INT_MIN
-        return res
-        
\ No newline at end of file
+        else:
+            return res
\ No newline at end of file
diff --git "a/0009.\345\233\236\346\226\207\346\225\260/0009-\345\233\236\346\226\207\346\225\260.py" "b/0009.\345\233\236\346\226\207\346\225\260/0009-\345\233\236\346\226\207\346\225\260.py"
index e40b713..fc986ad 100644
--- "a/0009.\345\233\236\346\226\207\346\225\260/0009-\345\233\236\346\226\207\346\225\260.py"
+++ "b/0009.\345\233\236\346\226\207\346\225\260/0009-\345\233\236\346\226\207\346\225\260.py"
@@ -1,11 +1,17 @@
 class Solution(object):
     def isPalindrome(self, x):
+        """
+        :type x: int
+        :rtype: bool
+        """
+        #2019.6.1
+        xx = x
+        if x < 0:
+            return False
 
-        s = str(x)
-        if len(s) <= 1:
-            return True
-        print len(s) / 2
-        for count in range(0, len(s)/2):
-            if s[count] != s[len(s)-1  - count]:
-                return False
-        return True
\ No newline at end of file
+        reverse = 0
+        while x > 0:
+            x, tmp = divmod(x, 10)
+            reverse = reverse * 10 + tmp
+
+        return reverse == xx
\ No newline at end of file
diff --git "a/0011.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/0011-\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.py" "b/0011.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/0011-\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.py"
index aef803f..15c142d 100644
--- "a/0011.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/0011-\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.py"
+++ "b/0011.\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250/0011-\347\233\233\346\234\200\345\244\232\346\260\264\347\232\204\345\256\271\345\231\250.py"
@@ -4,17 +4,13 @@ def maxArea(self, height):
         :type height: List[int]
         :rtype: int
         """
-        lo, hi = 0, len(height) - 1
+        left, right = 0, len(height) - 1
         res = 0
-        while(lo < hi):
-            if height[lo] > height[hi]:
-                area = height[hi] * (hi - lo)
-                hi -= 1
+        while(left < right):
+            # print left, right, 
+            res = max(res, (right - left) * min(height[left], height[right]))
+            if height[left] < height[right]:
+                left += 1
             else:
-                area = height[lo] * (hi - lo)
-                lo += 1
-            # print area
-            res = max(area, res)
-            
-        return res
-                
\ No newline at end of file
+                right -= 1
+        return res
\ No newline at end of file
diff --git "a/0014.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/0014-\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.py" "b/0014.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/0014-\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.py"
index 8737a0d..058eeef 100644
--- "a/0014.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/0014-\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.py"
+++ "b/0014.\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200/0014-\346\234\200\351\225\277\345\205\254\345\205\261\345\211\215\347\274\200.py"
@@ -6,15 +6,13 @@ def longestCommonPrefix(self, strs):
         """
         if not strs:
             return ""
-        
         strs.sort()
-        res = ""
         
-        for x, y in zip(strs[0], strs[-1]):
+        res = ""
+        pair = zip(strs[0], strs[-1])
+        for x, y in pair:
             if x == y:
                 res += x
             else:
                 break
-        
-        return res
-                
\ No newline at end of file
+        return res
\ No newline at end of file
diff --git "a/0015.\344\270\211\346\225\260\344\271\213\345\222\214/0015-\344\270\211\346\225\260\344\271\213\345\222\214.py" "b/0015.\344\270\211\346\225\260\344\271\213\345\222\214/0015-\344\270\211\346\225\260\344\271\213\345\222\214.py"
index 5ed85e1..ffe7ff2 100644
--- "a/0015.\344\270\211\346\225\260\344\271\213\345\222\214/0015-\344\270\211\346\225\260\344\271\213\345\222\214.py"
+++ "b/0015.\344\270\211\346\225\260\344\271\213\345\222\214/0015-\344\270\211\346\225\260\344\271\213\345\222\214.py"
@@ -4,29 +4,30 @@ def threeSum(self, nums):
         :type nums: List[int]
         :rtype: List[List[int]]
         """
-        #固定a,用双指针在排序数组里找两数之和为-a
         nums.sort()
-        l = len(nums)
         res = []
-        for i, a in enumerate(nums):
+        for i, num in enumerate(nums):
             if i == 0 or nums[i] > nums[i - 1]:
-            #开始双指针
-                left, right = i + 1, len(nums) - 1
+                # num  + b + c == 0
+                left = i + 1
+                right = len(nums) - 1
+                
                 while(left < right):
-                    s = a +  nums[left] + nums[right]
+                    s = num + nums[left] + nums[right]
                     if s == 0:
-                        tmp = [a, nums[left], nums[right]]
-                        res.append(tmp)
+                        res.append([num, nums[left], nums[right]])
                         left += 1
                         right -= 1
-                        while left < right and nums[left] == nums[left - 1]:
+                        while(left < right and nums[left] == nums[left - 1]):
                             left += 1
-                        while right > left and nums[right] == nums[right + 1]:
+                        while(left < right and nums[right + 1] == nums[right]):
                             right -= 1
-                    elif s < 0:
-                        left += 1
+                        # break
                     elif s > 0:
                         right -= 1
-        return res
+                    else:
+                        left += 1
                 
-            
\ No newline at end of file
+                    
+        return res
+                    
\ No newline at end of file
diff --git "a/0016.\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/0016-\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.py" "b/0016.\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/0016-\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.py"
index 4b5aaa9..e947337 100644
--- "a/0016.\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/0016-\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.py"
+++ "b/0016.\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214/0016-\346\234\200\346\216\245\350\277\221\347\232\204\344\270\211\346\225\260\344\271\213\345\222\214.py"
@@ -6,19 +6,22 @@ def threeSumClosest(self, nums, target):
         :rtype: int
         """
         nums.sort()
-        res = 99999999
+        res = nums[0] + nums[1] + nums[2]
         for i, num in enumerate(nums):
             left, right = i + 1, len(nums) - 1
-            while(left < right):
+            
+            while left < right:
                 s = num + nums[left] + nums[right]
-                
+                # print s, res, abs(s - target), abs(res - target)
                 if abs(s - target) < abs(res - target):
                     res = s
-                
                 if s == target:
                     return s
-                elif s > target:
-                    right -= 1
-                else:
+                elif s < target:
                     left += 1
-        return res
\ No newline at end of file
+                else:
+                    right -= 1
+        return res
+                
+            
+        
\ No newline at end of file
diff --git "a/0017.\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/0017-\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.py" "b/0017.\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/0017-\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.py"
index 7b58b1c..935f397 100644
--- "a/0017.\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/0017-\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.py"
+++ "b/0017.\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210/0017-\347\224\265\350\257\235\345\217\267\347\240\201\347\232\204\345\255\227\346\257\215\347\273\204\345\220\210.py"
@@ -4,20 +4,19 @@ def letterCombinations(self, digits):
         :type digits: str
         :rtype: List[str]
         """
+        if not digits:
+            return []
         mapping = {2:"abc", 3:"def", 4:"ghi", 5:"jkl", 6:"mno", 7:"pqrs", 8:"tuv", 9:"wxyz"}
-        
+               
         res = []
-        for digit in digits:
-            temp = []
-            n = int(digit)
-            for char in mapping[n]:
-                # print char
-                if not res:
-                    temp.append(char)
-                else:
-                    for item in res:
-                        temp.append(item + char)
-            res = temp
-            # print res
-        
+        # for i, digit in enumerate(digits)
+        def dfs(nums, tmp):
+            if not nums:
+                res.append(tmp)
+                return
+                   
+            for char in mapping[int(nums[0])]:
+                dfs(nums[1:], tmp + char)
+                          
+        dfs(digits, "")
         return res
\ No newline at end of file
diff --git "a/0018.\345\233\233\346\225\260\344\271\213\345\222\214/0018-\345\233\233\346\225\260\344\271\213\345\222\214.py" "b/0018.\345\233\233\346\225\260\344\271\213\345\222\214/0018-\345\233\233\346\225\260\344\271\213\345\222\214.py"
index 1fb6f76..16b0c4a 100644
--- "a/0018.\345\233\233\346\225\260\344\271\213\345\222\214/0018-\345\233\233\346\225\260\344\271\213\345\222\214.py"
+++ "b/0018.\345\233\233\346\225\260\344\271\213\345\222\214/0018-\345\233\233\346\225\260\344\271\213\345\222\214.py"
@@ -1,46 +1,37 @@
 class Solution(object):
-    def fourSum(self, n, target):
+    def fourSum(self, nums, target):
         """
         :type nums: List[int]
         :type target: int
         :rtype: List[List[int]]
         """
-        self.res = []
-        n.sort()
-        # print n
-        def threeSum(nums,t, d):
-            """
-            :type nums: List[int]
-            :rtype: List[List[int]]
-            """
-            #固定a,用双指针在排序数组里找两数之和为-a
-            l = len(nums)
-            res = []
-            for i, a in enumerate(nums):
-                if i == 0 or nums[i] > nums[i - 1]:
-                #开始双指针
-                    left, right = i + 1, len(nums) - 1
+        if len(nums) < 4:
+            return []
+        nums.sort()
+        res = []
+        def findThreeSum(num, l, t):
+            for i, n in enumerate(l):
+                if i == 0 or l[i] > l[i - 1]:
+                    left, right = i + 1, len(l) - 1
                     while(left < right):
-                        s = a +  nums[left] + nums[right]
-                        # print d, a, nums[left], nums[right]
+                        s = n + l[left] + l[right]
+
                         if s == t:
-                            tmp = [d,a, nums[left], nums[right]]
-                            self.res.append(tmp)
+                            res.append([num, n, l[left], l[right]])
                             left += 1
                             right -= 1
-                            while left < right and nums[left] == nums[left - 1]:
+                            while(left < right and l[left] == l[left - 1]):
                                 left += 1
-                            while right > left and nums[right] == nums[right + 1]:
+                            while(right > left and l[right] == l[right + 1]):
                                 right -= 1
-                        elif s < t:
-                            left += 1
                         elif s > t:
                             right -= 1
-        
-        for i in range(len(n) - 3):
-            if i == 0 or n[i] > n[i - 1]:
-                # print n[i]
-                threeSum(n[i + 1:], target - n[i], n[i])
-                
+                        else:
+                            left += 1
+                      
+        for i, num in enumerate(nums):
+            if i == 0 or nums[i] > nums[i - 1]:
+                findThreeSum(num, nums[i + 1:], target - num)
                 
-        return self.res
\ No newline at end of file
+        return res
+        
\ No newline at end of file
diff --git "a/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271/0019-\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.py" "b/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271/0019-\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.py"
index 45d8dba..eb41749 100644
--- "a/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271/0019-\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.py"
+++ "b/0019.\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271/0019-\345\210\240\351\231\244\351\223\276\350\241\250\347\232\204\345\200\222\346\225\260\347\254\254N\344\270\252\350\212\202\347\202\271.py"
@@ -11,23 +11,19 @@ def removeNthFromEnd(self, head, n):
         :type n: int
         :rtype: ListNode
         """
-        if not head.next:
-            return []
         p = head
-        if n == 1:
-            while(p.next.next):
-                p = p.next
-            p.next = None
-        else:
-            fast = head
-            slow = head
-            for i in range(n-1):
-                fast = fast.next
-            print fast.val,slow.val
-            while(fast.next):
-                fast = fast.next
-                slow = slow.next
-            print fast.val,slow.val 
-            slow.val = slow.next.val
-            slow.next = slow.next.next
-        return head
\ No newline at end of file
+        slow, fast = p, p
+        while(n):
+            n -= 1
+            fast = fast.next
+        if fast is None:
+            return p.next    
+        while(fast and fast.next):
+            fast = fast.next
+            slow = slow.next
+        
+        slow.next = slow.next.next
+        
+        return p
+        
+        
\ No newline at end of file
diff --git "a/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/0020-\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.py" "b/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/0020-\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.py"
index 5044c13..4a34f9b 100644
--- "a/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/0020-\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.py"
+++ "b/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267/0020-\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.py"
@@ -4,13 +4,14 @@ def isValid(self, s):
         :type s: str
         :rtype: bool
         """
-        if len(s)%2:
-            return False
-        dic = {")":"(","]":"[","}":"{"}
-        stack = [None]
-        for item in s:
-            if item in dic and stack[-1] == dic[item]:
-                stack.pop()
+        mapping = {")":"(", "]":"[", "}":"{"}
+        stack = []
+        for i, char in enumerate(s):
+            if char not in mapping:#left
+                stack.append(char)
             else:
-                stack.append(item)
-        return len(stack) == 1
+                if not stack or stack[-1] != mapping[char]:
+                    return False
+                stack.pop()
+                
+        return len(stack) == 0
\ No newline at end of file
diff --git "a/0021.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/0021-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250.py" "b/0021.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/0021-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250.py"
new file mode 100644
index 0000000..9efb265
--- /dev/null
+++ "b/0021.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250/0021-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\351\223\276\350\241\250.py"
@@ -0,0 +1,31 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def mergeTwoLists(self, l1, l2):
+        """
+        :type l1: ListNode
+        :type l2: ListNode
+        :rtype: ListNode
+        """
+        newhead = ListNode(0)
+        p = newhead
+        while(l1 and l2):
+            if l1.val < l2.val:
+                p.next = ListNode(l1.val)
+                l1 = l1.next
+            else:
+                p.next = ListNode(l2.val)
+                l2 = l2.next
+            p = p.next
+        
+        if l1:
+            p.next = l1
+        else:
+            p.next = l2
+        return newhead.next
+            
+            
\ No newline at end of file
diff --git "a/0022.\346\213\254\345\217\267\347\224\237\346\210\220/0022-\346\213\254\345\217\267\347\224\237\346\210\220.py" "b/0022.\346\213\254\345\217\267\347\224\237\346\210\220/0022-\346\213\254\345\217\267\347\224\237\346\210\220.py"
index 3801859..326c241 100644
--- "a/0022.\346\213\254\345\217\267\347\224\237\346\210\220/0022-\346\213\254\345\217\267\347\224\237\346\210\220.py"
+++ "b/0022.\346\213\254\345\217\267\347\224\237\346\210\220/0022-\346\213\254\345\217\267\347\224\237\346\210\220.py"
@@ -1,23 +1,22 @@
 class Solution(object):
-    def generate(self, temp, left, right, result):
-        if (left == 0 and right == 0):
-            result.append(temp)
-            return
-        if (left > 0):
-            self.generate(temp + "(", left-1, right, result)
-        if (left < right):
-            self.generate(temp + ")", left, right - 1, result)
-            
     def generateParenthesis(self, n):
         """
         :type n: int
         :rtype: List[str]
         """
-        result = []
-        self.generate("", n, n, result)
-        return result
-    
-
-            
         
+        res = []
+        
+        def dfs(tmp, left, right):
+            if len(tmp) == 2 * n:
+                res.append(tmp)
+                
+            if left:
+                dfs(tmp + "(", left - 1, right)
+            if right > left:
+                dfs(tmp + ")", left, right - 1)
+                    
+            
+        dfs("", n, n)
+        return res
         
\ No newline at end of file
diff --git "a/0023.\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250/0023-\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.py" "b/0023.\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250/0023-\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.py"
new file mode 100644
index 0000000..8581c27
--- /dev/null
+++ "b/0023.\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250/0023-\345\220\210\345\271\266K\344\270\252\346\216\222\345\272\217\351\223\276\350\241\250.py"
@@ -0,0 +1,30 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def mergeKLists(self, lists):
+        """
+        :type lists: List[ListNode]
+        :rtype: ListNode
+        """
+        from heapq import *
+        pq = []
+        for i in range(len(lists)):
+            if lists[i]:
+                heappush(pq, (lists[i].val, i))
+                lists[i] = lists[i].next
+            
+        dummy = ListNode(1)
+        p = dummy
+        while pq:
+            val, idx = heappop(pq)
+            p.next = ListNode(val)
+            p = p.next
+            if lists[idx]:
+                heappush(pq, (lists[idx].val, idx))
+                lists[idx] = lists[idx].next
+        return dummy.next
+            
\ No newline at end of file
diff --git "a/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/0024-\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.py" "b/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/0024-\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.py"
new file mode 100644
index 0000000..85dc922
--- /dev/null
+++ "b/0024.\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271/0024-\344\270\244\344\270\244\344\272\244\346\215\242\351\223\276\350\241\250\344\270\255\347\232\204\350\212\202\347\202\271.py"
@@ -0,0 +1,26 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def swapPairs(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+            return head
+        dummy = ListNode(1)
+        dummy.next = head
+
+        first = head
+        second = head.next
+        
+        tail = second.next
+        first.next = self.swapPairs(tail)
+        second.next = first
+        dummy.next = second
+        
+        return dummy.next
\ No newline at end of file
diff --git "a/0026.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/0026-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.py" "b/0026.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/0026-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.py"
index e23482f..be1b92b 100644
--- "a/0026.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/0026-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.py"
+++ "b/0026.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271/0026-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271.py"
@@ -4,13 +4,14 @@ def removeDuplicates(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        
         i = 0
         for j in range(len(nums)):
-            if i < 1 or nums[j] != nums[j - 1]:
+            if j == 0 or nums[j] != nums[j - 1]:
                 nums[i] = nums[j]
                 i += 1
         return i
-            
-    
-                     
\ No newline at end of file
+                    
+                
+                
+                
+                    
\ No newline at end of file
diff --git "a/0027.\347\247\273\351\231\244\345\205\203\347\264\240/0027-\347\247\273\351\231\244\345\205\203\347\264\240.py" "b/0027.\347\247\273\351\231\244\345\205\203\347\264\240/0027-\347\247\273\351\231\244\345\205\203\347\264\240.py"
index 439086f..7f0c216 100644
--- "a/0027.\347\247\273\351\231\244\345\205\203\347\264\240/0027-\347\247\273\351\231\244\345\205\203\347\264\240.py"
+++ "b/0027.\347\247\273\351\231\244\345\205\203\347\264\240/0027-\347\247\273\351\231\244\345\205\203\347\264\240.py"
@@ -5,15 +5,17 @@ def removeElement(self, nums, val):
         :type val: int
         :rtype: int
         """
-        i = 0
-        while( i <len(nums)):
-            print i
-            if nums[i] == val:
-                nums.pop(i)
-            else:
-                i += 1
-
-              
-        return len(nums)
-                    
-        
\ No newline at end of file
+        nums.sort()
+        for i, num in enumerate(nums):
+            if num == val:
+                j = i + 1
+                while(j < len(nums) and nums[j] == num):
+                    j += 1
+                t = j
+                while(j < len(nums)):
+                    nums[i] = nums[j]
+                    i += 1
+                    j += 1
+                return i
+                
+                    
\ No newline at end of file
diff --git "a/0028.\345\256\236\347\216\260strStr()/0028-\345\256\236\347\216\260strStr().py" "b/0028.\345\256\236\347\216\260strStr()/0028-\345\256\236\347\216\260strStr().py"
new file mode 100644
index 0000000..1866c7d
--- /dev/null
+++ "b/0028.\345\256\236\347\216\260strStr()/0028-\345\256\236\347\216\260strStr().py"
@@ -0,0 +1,17 @@
+class Solution(object):
+    def strStr(self, haystack, needle):
+        """
+        :type haystack: str
+        :type needle: str
+        :rtype: int
+        """
+        if not needle:
+            return 0
+        # if needle in haystack:
+        #     return haystack.index(needle)
+        for i, char in enumerate(haystack):
+            if char == needle[0]:
+                if haystack[i:i + len(needle)] == needle:
+                    return i
+                
+        return -1
\ No newline at end of file
diff --git "a/0029.\344\270\244\346\225\260\347\233\270\351\231\244/0029-\344\270\244\346\225\260\347\233\270\351\231\244.py" "b/0029.\344\270\244\346\225\260\347\233\270\351\231\244/0029-\344\270\244\346\225\260\347\233\270\351\231\244.py"
index 00c56c2..c4d873d 100644
--- "a/0029.\344\270\244\346\225\260\347\233\270\351\231\244/0029-\344\270\244\346\225\260\347\233\270\351\231\244.py"
+++ "b/0029.\344\270\244\346\225\260\347\233\270\351\231\244/0029-\344\270\244\346\225\260\347\233\270\351\231\244.py"
@@ -5,24 +5,23 @@ def divide(self, dividend, divisor):
         :type divisor: int
         :rtype: int
         """
-        # 计算被除数可以减去多少个除数：
+        multi = dividend * divisor
         op = 1
-        if (dividend > 0 and divisor < 0) or (dividend < 0 and divisor > 0):
+        if multi == 0:
+            return 0
+        elif multi <0:
             op = -1
-        
         dividend, divisor = abs(dividend), abs(divisor)
+        multi = 1
         res = 0
         while(dividend >= divisor):
-            multidivisor, multi = divisor, 1
-            while(dividend >= multidivisor):
+            tmp = multi * divisor
+            if dividend >= tmp:
+                dividend -= tmp
                 res += multi
-                dividend -= multidivisor
-                multi = multi << 1
-                multidivisor = multidivisor <<1
+                multi += 1
+            else:
+                multi = 1
                 
-            
-        INT_MIN = -(2 **31)
-        INT_MAX = 2 **31 - 1
-        res *= op
-        
-        return res if INT_MIN <= res <= INT_MAX else INT_MAX 
\ No newline at end of file
+        res = res * op
+        return res if -2 ** 31 <= res <= 2 ** 31 - 1 else 2 ** 31 - 1
\ No newline at end of file
diff --git "a/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/0031-\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.py" "b/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/0031-\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.py"
index d44dc9d..5538d3c 100644
--- "a/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/0031-\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.py"
+++ "b/0031.\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227/0031-\344\270\213\344\270\200\344\270\252\346\216\222\345\210\227.py"
@@ -4,21 +4,27 @@ def nextPermutation(self, nums):
         :type nums: List[int]
         :rtype: None Do not return anything, modify nums in-place instead.
         """
-        #i 代表从nums结尾往前递增序列的头， j代表递增序列里比nums[i - 1]大的最小的元素
-        
-        l = len(nums)
-        for i in range(l - 1, -1, -1):
-            if nums[i - 1] < nums[i]:# 找到了需要的i
-                break
-        
-        if i == 0: # 代表当前不存在下一个更大的序列，整体翻转即可
-            nums[:] = nums[::-1]
+        if not nums or len(nums) == 1:
             return nums
+        # print nums, sorted(nums)[::-1]
+        if nums == sorted(nums)[::-1]:
+            nums[:] = nums[::-1]
+            return
         
-        for j in range(l - 1, i - 1, -1):
-            if nums[j] > nums[i - 1]: #找到了需要的j
+        i = len(nums) - 1
+        while(i - 1 >= 0 and nums[i - 1] >= nums[i]):
+            i -= 1
+        i -= 1    
+        tmp = nums[i]
+        j = len(nums) - 1
+        while(j >= i and nums[j] <= tmp):
+            j -= 1
+            if nums[j] > tmp:
                 break
 
-        nums[i - 1], nums[j] = nums[j], nums[i - 1]
-        nums[i:] = nums[i:][::-1]
-        return nums
\ No newline at end of file
+        # print tmp, nums[j], nums[i]
+        nums[i], nums[j] = nums[j], nums[i]
+        # print nums
+        nums[i+ 1:] = nums[i + 1:][::-1]
+        return 
+        
\ No newline at end of file
diff --git "a/0032.\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/0032-\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267.py" "b/0032.\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/0032-\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267.py"
new file mode 100644
index 0000000..38e69fd
--- /dev/null
+++ "b/0032.\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267/0032-\346\234\200\351\225\277\346\234\211\346\225\210\346\213\254\345\217\267.py"
@@ -0,0 +1,19 @@
+class Solution(object):
+    def longestValidParentheses(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        stack = [-1]
+        res = 0
+        for i, x in enumerate(s):
+            if x == "(":
+                stack.append(i)
+            else:
+                stack.pop()
+                if stack:
+                    res = max(res, i - stack[-1])
+                else:
+                    stack.append(i)
+                    
+        return res
\ No newline at end of file
diff --git "a/0033.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/0033-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204.py" "b/0033.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/0033-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204.py"
index 4d944f0..e6c5746 100644
--- "a/0033.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/0033-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204.py"
+++ "b/0033.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204/0033-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204.py"
@@ -5,39 +5,38 @@ def search(self, nums, target):
         :type target: int
         :rtype: int
         """
+        #1. 二分找旋转点
+        #2. 确认target落在哪一侧然后二分找
         if not nums:
             return -1
         if len(nums) == 1:
             return 0 if nums[0] == target else -1
-        
-        lo, hi = 0, len(nums) - 1
-        while(lo <= hi):
-            mid = (lo + hi) // 2
-            # print mid, nums[mid]
-            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]:
+        midposition = -1
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            # print mid
+            if mid + 1 < len(nums) and nums[mid] > nums[mid + 1]:
+                midposition = mid
                 break
-            if nums[mid] < nums[-1]:
-                hi = mid - 1
             elif nums[mid] >= nums[0]:
-                lo = mid + 1
-                
-        if lo > hi:#没有旋转
-            lo, hi = 0, len(nums) - 1
-        else:
+                left = mid + 1
+            elif nums[mid] <= nums[-1]:
+                right = mid - 1
+        # print midposition       
+        if midposition != -1:
             if target >= nums[0]:
-                lo, hi = 0, mid
+                left, right = 0, midposition
             else:
-                lo, hi = mid + 1, len(nums) - 1
-
-        while(lo <= hi):
-            # print lo, hi
-            mid = (lo + hi) // 2
+                left, right = midposition + 1, len(nums) - 1
+        else:
+            left, right = 0, len(nums) - 1
+        while(left <= right):
+            mid = (left + right) // 2
             if nums[mid] == target:
                 return mid
             elif nums[mid] > target:
-                hi = mid - 1
+                right = mid - 1
             else:
-                lo = mid + 1
-        
-        return -1
-                
\ No newline at end of file
+                left = mid + 1
+        return -1
\ No newline at end of file
diff --git "a/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/0034-\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.py" "b/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/0034-\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.py"
index 1df165c..6916af6 100644
--- "a/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/0034-\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.py"
+++ "b/0034.\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256/0034-\345\234\250\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\345\205\203\347\264\240\347\232\204\347\254\254\344\270\200\344\270\252\345\222\214\346\234\200\345\220\216\344\270\200\344\270\252\344\275\215\347\275\256.py"
@@ -6,43 +6,51 @@ def searchRange(self, nums, target):
         :rtype: List[int]
         """
         lo, hi = 0, len(nums) - 1
-        #找第一个target
-        while(lo <= hi):
+        
+        while lo <= hi:
+            
             mid = (lo + hi) // 2
+            # print lo, hi, mid, nums
             if nums[mid] == target:
                 break
-            elif nums[mid] > target:
-                hi = mid - 1
-            else:
+            elif nums[mid] < target:
                 lo = mid + 1
-        if lo > hi: #不存在
+            else:
+                hi = mid - 1
+        
+        if lo > hi:
             return [-1, -1]
-
-        midtarget = mid
-        lo, hi = 0, mid
-        leftpos = 0
-        while(lo <= hi):
-            # print lo, hi
-            if (hi >= 1 and nums[hi - 1] != target) or hi == 0: #找到左边界或者找到头了
-                leftpos = hi
-                break
+        midposition = mid
+        leftside, rightside = midposition, midposition
+        #找左边界
+        # print 1
+        lo, hi = 0, midposition
+        while lo <= hi:
+            # print lo, hi, mid
             mid = (lo + hi) // 2
-            if nums[mid] == target:
-                hi = mid
-            elif nums[mid] < target:
+            if nums[mid] < target:
                 lo = mid + 1
-
-        rightpos = 0
-        lo, hi = midtarget, len(nums) - 1
-        while(lo <= hi):
-            if (lo <= len(nums) - 2 and nums[lo + 1] != target) or lo == len(nums) - 1: #找到右边界或者找到头了
-                rightpos = lo
-                break
-            mid = (lo + hi + 1) // 2
-            if nums[mid] == target:
-                lo = mid 
-            elif nums[mid] > target:
+            elif nums[mid] == target:
+                if mid == 0 or (mid - 1 >= 0 and nums[mid - 1] < target):
+                    leftside = mid
+                    break
+                else:
+                    hi = mid - 1
+        # print 1      
+        #找右边界
+        lo, hi = midposition, len(nums) - 1
+        while lo <= hi:
+            mid = (lo + hi) // 2
+            if nums[mid] > target:
                 hi = mid - 1
+            elif nums[mid] == target:
+                if mid == len(nums) - 1 or (mid + 1 < len(nums) and nums[mid + 1] > target):
+                    rightside = mid
+                    break
+                else:
+                    lo = mid + 1
+        
+        return [leftside, rightside]
+                    
                 
-        return [leftpos, rightpos]
-                
\ No newline at end of file
+            
\ No newline at end of file
diff --git "a/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/0035-\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.py" "b/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/0035-\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.py"
index ad0dcc8..521a7c3 100644
--- "a/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/0035-\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.py"
+++ "b/0035.\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256/0035-\346\220\234\347\264\242\346\217\222\345\205\245\344\275\215\347\275\256.py"
@@ -5,12 +5,13 @@ def searchInsert(self, nums, target):
         :type target: int
         :rtype: int
         """
-        if not nums:
-            return 0
-        l = len(nums)
-        for index in range(l):
-            if nums[index] >= target:
-                return index
-        return index + 1
-            
-        
\ No newline at end of file
+        lo,hi = 0, len(nums) - 1
+        while (lo <= hi):
+            mid = lo + (hi - lo) / 2
+            if nums[mid] == target:
+                return mid
+            elif nums[mid] > target:
+                hi = mid - 1
+            else:
+                lo = mid + 1
+        return lo
\ No newline at end of file
diff --git "a/0036.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/0036-\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.py" "b/0036.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/0036-\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.py"
index 19f59d5..ed34e1b 100644
--- "a/0036.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/0036-\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.py"
+++ "b/0036.\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254/0036-\346\234\211\346\225\210\347\232\204\346\225\260\347\213\254.py"
@@ -5,19 +5,15 @@ def isValidSudoku(self, board):
         :rtype: bool
         """
         from collections import defaultdict
-        row = defaultdict(set)
-        column = defaultdict(set)
-        squre = defaultdict(set)
-        
+        row, column, squre  = defaultdict(set), defaultdict(set), defaultdict(set)
         for i in range(9):
             for j in range(9):
                 if board[i][j].isdigit():
-                    if board[i][j] in row[i] or board[i][j] in column[j] or (board[i][j]) in squre[(i // 3, j // 3)]:
-                        # print board[i][j], row[i], column[j], squre[(i // 3, j // 3)]
+                    if board[i][j] in row[i] or board[i][j] in column[j] or board[i][j] in squre[(i//3, j//3)]:
                         return False
                     else:
                         row[i].add(board[i][j])
                         column[j].add(board[i][j])
-                        squre[(i // 3, j // 3)].add(board[i][j])
-                    
-        return True
\ No newline at end of file
+                        squre[(i//3, j //3)].add(board[i][j])
+        return True
+                
\ No newline at end of file
diff --git "a/0037.\350\247\243\346\225\260\347\213\254/0037-\350\247\243\346\225\260\347\213\254.py" "b/0037.\350\247\243\346\225\260\347\213\254/0037-\350\247\243\346\225\260\347\213\254.py"
index f598eae..cfbd885 100644
--- "a/0037.\350\247\243\346\225\260\347\213\254/0037-\350\247\243\346\225\260\347\213\254.py"
+++ "b/0037.\350\247\243\346\225\260\347\213\254/0037-\350\247\243\346\225\260\347\213\254.py"
@@ -6,40 +6,43 @@ def solveSudoku(self, board):
         """
         from collections import defaultdict
         row, column, squre  = defaultdict(set), defaultdict(set), defaultdict(set)
-        fill_list = []
+        
+        self.res = []
+        def dfs(x, y):
+            
+            if x == 8 and y == 9:
+                # print board
+                for roww in board:
+                    self.res.append(roww[:])
+                # print self.res
+                return
+            if y == 9:
+                dfs(x + 1, 0)
+                return
+            if board[x][y].isdigit():
+                dfs(x, y + 1)
+                return
+                
+            for k in range(1,10):
+                if str(k) not in row[x] and str(k) not in column[y] and str(k) not in squre[(x // 3, y // 3)]:
+                    board[x][y] = str(k)
+                    row[x].add(str(k))
+                    column[y].add(str(k))
+                    squre[(x // 3, y // 3)].add(str(k))
+                    
+                    dfs(x, y + 1)
+                    
+                    board[x][y] = "."
+                    row[x].remove(str(k))
+                    column[y].remove(str(k))
+                    squre[(x // 3, y // 3)].remove(str(k))
+            
         for i in range(9):
             for j in range(9):
-                if board[i][j].isdigit(): #排除掉空的情况
+                if board[i][j].isdigit():
                     row[i].add(board[i][j].encode("utf-8"))
                     column[j].add(board[i][j].encode("utf-8"))
                     squre[(i // 3, j // 3)].add(board[i][j].encode("utf-8"))
-                else:
-                    fill_list.append([i, j])
-                    
-        self.result = []           
-        def backtrack(idx):
-            if idx == len(fill_list):
-                for row1 in board:
-                    self.result.append(row1[:])
-                return
-            if not self.result:
-                i, j = fill_list[idx][0], fill_list[idx][1]
-                for digit in range(1, 10):
-                    if str(digit) in row[i] or str(digit) in column[j] or str(digit) in squre[(i // 3, j // 3)]:
-                        continue
-
-                    board[i][j] = str(digit)
-                    row[i].add(board[i][j])
-                    column[j].add(board[i][j])
-                    squre[(i // 3, j // 3)].add(board[i][j])
-
-                    backtrack(idx + 1)
 
-                    row[i].remove(board[i][j])
-                    column[j].remove(board[i][j])
-                    squre[(i // 3, j // 3)].remove(board[i][j])
-
-        backtrack(0)  
-        for i in range(9):
-            for j in range(9):
-                board[i][j] = self.result[i][j]
+        dfs(0, 0)
+        board[:] = self.res
\ No newline at end of file
diff --git "a/0038.\346\212\245\346\225\260/0038-\346\212\245\346\225\260.py" "b/0038.\346\212\245\346\225\260/0038-\346\212\245\346\225\260.py"
new file mode 100644
index 0000000..529e56d
--- /dev/null
+++ "b/0038.\346\212\245\346\225\260/0038-\346\212\245\346\225\260.py"
@@ -0,0 +1,20 @@
+class Solution(object):
+    def countAndSay(self, n):
+        """
+        :type n: int
+        :rtype: str
+        """
+        record = ["1"]
+        for i in range(1, n):
+            pre = record[i - 1]
+            idx = 0
+            tmp = ""
+            while idx < len(pre):
+                cnt = 1
+                while(idx + 1 < len(pre) and pre[idx] == pre[idx + 1]):
+                    idx += 1
+                    cnt += 1
+                tmp += str(cnt) + pre[idx]
+                idx += 1
+            record.append(tmp)
+        return record[-1]
\ No newline at end of file
diff --git "a/0039.\347\273\204\345\220\210\346\200\273\345\222\214/0039-\347\273\204\345\220\210\346\200\273\345\222\214.py" "b/0039.\347\273\204\345\220\210\346\200\273\345\222\214/0039-\347\273\204\345\220\210\346\200\273\345\222\214.py"
index 71662df..20f1d1f 100644
--- "a/0039.\347\273\204\345\220\210\346\200\273\345\222\214/0039-\347\273\204\345\220\210\346\200\273\345\222\214.py"
+++ "b/0039.\347\273\204\345\220\210\346\200\273\345\222\214/0039-\347\273\204\345\220\210\346\200\273\345\222\214.py"
@@ -1,15 +1,26 @@
 class Solution(object):
     def combinationSum(self, candidates, target):
+        """
+        :type candidates: List[int]
+        :type target: int
+        :rtype: List[List[int]]
+        """
         res = []
         candidates.sort()
+        def dfs(t, tmp):
+            if t < 0:
+                return
+            if t == 0:
+                tmp.sort()
+                if tmp not in res:
+                    res.append(tmp)
+                return
+            
+            for i, x in enumerate(candidates):
+                if t - x < 0:
+                    break
+                dfs(t - x, tmp + [x])
         
-        def backtrack(remain, temp, start):
-            if not remain: #remain为0
-                res.append(temp[:])
-            else:
-                for i, n in enumerate(candidates[start:]):
-                    if n > remain:
-                        break
-                    backtrack(remain-n, temp+[n], start+i)
-        backtrack(target, [], 0)
+        
+        dfs(target, [])
         return res
\ No newline at end of file
diff --git "a/0040.\347\273\204\345\220\210\346\200\273\345\222\214II/0040-\347\273\204\345\220\210\346\200\273\345\222\214II.py" "b/0040.\347\273\204\345\220\210\346\200\273\345\222\214II/0040-\347\273\204\345\220\210\346\200\273\345\222\214II.py"
index 294916c..c70ce0a 100644
--- "a/0040.\347\273\204\345\220\210\346\200\273\345\222\214II/0040-\347\273\204\345\220\210\346\200\273\345\222\214II.py"
+++ "b/0040.\347\273\204\345\220\210\346\200\273\345\222\214II/0040-\347\273\204\345\220\210\346\200\273\345\222\214II.py"
@@ -1,32 +1,25 @@
 class Solution(object):
-    def combinationSum2(self, c, t):
+    def combinationSum2(self, candidates, target):
         """
         :type candidates: List[int]
         :type target: int
         :rtype: List[List[int]]
         """
-        res = list()
-        l = len(c)
-        def dfs(start, tmp):
-            s = sum(tmp)
-            if s == t:
-                tt = sorted(tmp)
-                if tt not in res:
-                    res.append(tt[:])
+        res = []
+        candidates.sort()
+        def dfs(start, t, tmp):
+            if t == 0:
+                tmp.sort()
+                if tmp not in res:
+                    res.append(tmp)
                 return
-            if start >= l:
-                return
-
-            for i in range(start, l):
-                
-                if c[i] > t or s + c[i] > t:
-                    continue
-                
-                tmp.append(c[i])
-                dfs(i + 1, tmp)
-                tmp.pop()
-                    
-        for i,x in enumerate(c):
-            dfs(i, list())
             
+            for i in range(start, len(candidates)):
+                x = candidates[i]
+                if t - x < 0:
+                    break
+                dfs(i + 1, t - x, tmp + [x])
+        
+        
+        dfs(0, target, [])
         return res
\ No newline at end of file
diff --git "a/0041.\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/0041-\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260.py" "b/0041.\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/0041-\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260.py"
index abcda2e..5e1ac10 100644
--- "a/0041.\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/0041-\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260.py"
+++ "b/0041.\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260/0041-\347\274\272\345\244\261\347\232\204\347\254\254\344\270\200\344\270\252\346\255\243\346\225\260.py"
@@ -4,15 +4,15 @@ def firstMissingPositive(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        # 对于处于1~n之间的数，把它们放到nums[i - 1]的位置上
-        
-        for i in range(len(nums)):
-            while 1 <= nums[i] <= len(nums) and nums[i] != nums[nums[i] - 1]:
-                # nums[i], nums[nums[i] - 1] = nums[nums[i] - 1], nums[i]
-                nums[nums[i] - 1], nums[i] = nums[i], nums[nums[i] - 1]
-                
-        for i, x in enumerate(nums):
-            if x != i + 1:
-                return i + 1
-        
-        return len(nums) + 1
\ No newline at end of file
+        if not nums:
+            return 1
+        max_element = max(nums)
+        if max_element < 0:
+            return 1
+        i = 1
+        while i < max_element:
+        # for i in range(1, max_element):
+            if i not in nums:
+                return i
+            i += 1
+        return max_element + 1
\ No newline at end of file
diff --git "a/0042.\346\216\245\351\233\250\346\260\264/0042-\346\216\245\351\233\250\346\260\264.py" "b/0042.\346\216\245\351\233\250\346\260\264/0042-\346\216\245\351\233\250\346\260\264.py"
index a5926c1..2d3dc43 100644
--- "a/0042.\346\216\245\351\233\250\346\260\264/0042-\346\216\245\351\233\250\346\260\264.py"
+++ "b/0042.\346\216\245\351\233\250\346\260\264/0042-\346\216\245\351\233\250\346\260\264.py"
@@ -4,28 +4,21 @@ def trap(self, height):
         :type height: List[int]
         :rtype: int
         """
+        height = [0] + height + [0]
         left_max = [0 for _ in height]
         right_max = [0 for _ in height]
-        water = [0 for _ in height]
         
-        for i in range(len(height)):
-            if i - 1 >= 0:
-                left_max[i] = max(left_max[i - 1], height[i])
-            else:
-                left_max[i] = height[i]
+        
+        for i in range(1, len(height)):
+            left_max[i] = max(height[i], left_max[i - 1])
+            
+        for i in range(len(height) - 2, -1, -1):
+            # print i
+            right_max[i] = max(height[i], right_max[i + 1])
+        # print left_max, right_max     
+        # res = [0 for _ in height]
+        res = 0
+        for i in range(1, len(height) - 2):
+            res += min(left_max[i], right_max[i]) - height[i]
             
-        for i in range(len(height) - 1, -1, -1):
-            if i  < len(height) - 1:
-                right_max[i] = max(right_max[i + 1], height[i])
-            else:
-                right_max[i] = height[i]
-                
-        for i in range(len(height)):
-            tmp = min(left_max[i], right_max[i]) - height[i]
-            if tmp > 0:
-                water[i] = tmp
-        # print height     
-        # print water
-        # print left_max
-        # print right_max
-        return sum(water)
\ No newline at end of file
+        return res
\ No newline at end of file
diff --git "a/0043.\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/0043-\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.py" "b/0043.\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/0043-\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.py"
index 7b07eb5..d1ddced 100644
--- "a/0043.\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/0043-\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.py"
+++ "b/0043.\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230/0043-\345\255\227\347\254\246\344\270\262\347\233\270\344\271\230.py"
@@ -5,65 +5,68 @@ def multiply(self, num1, num2):
         :type num2: str
         :rtype: str
         """
-        if len(num1) < len(num2):
-            num1, num2 = num2, num1
-        if num1 == "0" or num2 == "0":
+        if num1 == "0" or num2 == "0": #处理特殊情况
             return "0"
         
-        num2 = num2[::-1]
-        tmp, res = [],[]
-        for i, char in enumerate(num2):
-            tmp = self.stringMultiDigit(num1, int(char)) + "0" * i #计算当前位乘法的结果，注意末尾添0
-            res = self.stringPlusString(res, tmp) #加上当前位结果
+        l1, l2 = len(num1), len(num2) 
+        if l1 < l2: 
+            num1, num2 = num2, num1 #保障num1始终比num2大
+            l1, l2 = l2, l1
             
-        return "".join(res)
+        num2 = num2[::-1]
+        res = "0"
+        for i, digit in enumerate(num2):
+            tmp = self.StringMultiplyDigit(num1, int(digit)) + "0" * i #计算num1和num2的当前位的乘积
+            res = self.StringPlusString(res, tmp) #计算res和tmp的和
+
+        return res
     
-    def stringMultiDigit(self,s, n): #计算一个字符串和一个数字的乘积， 返回字符串
-        s = s[::-1]
-        l = []
-        for char in s:
-            l.append(int(char))
-            
-        for i, char in enumerate(l):
-            l[i] *= n
+    def StringMultiplyDigit(self,string, n):
+        #这个函数的功能是：计算一个字符串和一个整数的乘积，返回字符串
+        #举例：输入为 "123", 3， 返回"369"
+        s = string[::-1]
+        res = []
+        for i, char in enumerate(s):
+            num = int(char)
+            res.append(num * n)
+        res = self.CarrySolver(res)
+        res = res[::-1]
+        return "".join(str(x) for x in res)
+        
+    def CarrySolver(self, nums):  
+        #这个函数的功能是：将输入的数组中的每一位处理好进位
+        #举例：输入[15, 27, 12], 返回[5, 8, 4, 1]
+        i = 0
+        while i < len(nums):
+            if nums[i] >= 10:
+                carrier = nums[i] // 10
+                if i == len(nums) - 1:
+                    nums.append(carrier)
+                else:
+                    nums[i + 1] += carrier
+                nums[i] %= 10
+            i += 1
+                    
+        return nums
+    
+    def StringPlusString(self, s1, s2):
+        #这个函数的功能是：计算两个字符串的和
+        #举例：输入为“123”， “456”, 返回为"579"
+        l1, l2 = len(s1), len(s2)
+        if l1 < l2:
+            s1, s2 = s2, s1
+            l1, l2 = l2, l1
+        s1 = [int(x) for x in s1]
+        s2 = [int(x) for x in s2]
+        s1, s2 = s1[::-1], s2[::-1]
+        for i, digit in enumerate(s2):
+            s1[i] += s2[i]
             
-        for i, char in enumerate(l):
-            while(l[i] > 9):
-                tmp = l[i] // 10
-                l[i] -= tmp * 10
-                if i == len(l) - 1:
-                    l.append(0)
-                l[i + 1] +=  tmp
-                
-        return "".join(str(char) for char in l[::-1])
+        s1 = self.CarrySolver(s1)
+        s1 = s1[::-1]
+        return "".join(str(x) for x in s1)
             
         
-    def stringPlusString(self,s1, s2): #字符串加法，返回字符串
-        # print s1, s2
-        s1, s2 = s1[::-1], s2[::-1]
-        l1, l2 = [], []
-        for char in s1:
-            l1.append(int(char))
-        for char in s2:
-            l2.append(int(char))
-        # tmp = []
-        if len(l1) < len(l2):
-            l1, l2 = l2, l1
-        i = 0
-        for i in range(len(l2)):
-            l1[i] += l2[i]
-            if l1[i] > 9:
-                l1[i] -= 10
-                if i == len(l1) - 1:
-                    l1.append(0)
-                l1[i + 1] += 1
-        i += 1
-        if i < len(l1) - 1: #处理最后一位可能的进位
-            if l1[i] > 9:
-                l1[i] -= 10
-                if i == len(l1) - 1:
-                    l1.append(0)
-                l1[i + 1] += 1
-
-        return "".join(str(char) for char in l1[::-1])
-    
\ No newline at end of file
+        
+            
+            
\ No newline at end of file
diff --git "a/0044.\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/0044-\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215.py" "b/0044.\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/0044-\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215.py"
new file mode 100644
index 0000000..6e5f9dd
--- /dev/null
+++ "b/0044.\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215/0044-\351\200\232\351\205\215\347\254\246\345\214\271\351\205\215.py"
@@ -0,0 +1,35 @@
+class Solution(object):
+    def isMatch(self, s, p):
+        """
+        :type s: str
+        :type p: str
+        :rtype: bool
+        """
+        tmpp = ""
+        for i, char in enumerate(p):
+            if p[i] != "*":
+                tmpp += p[i]
+            else:
+                if i == 0 or p[i] != tmpp[-1]:
+                    tmpp += "*"
+        p = tmpp[:]
+        
+        memo = {}
+        def find(i, j):
+            if (i, j) not in memo:
+                ans = False
+                if j == len(p):
+                    ans = i == len(s)
+                elif i < len(s):
+                    if p[j] in [s[i], "?"]:
+                        ans = find(i + 1, j + 1)
+                    elif p[j] == "*":
+                        ans = find(i, j + 1) or find(i + 1, j)
+                elif p[j] == "*":
+                    ans = find(i, j + 1)
+                memo[i, j] = ans
+            return memo[i, j]
+        
+        return find(0, 0)
+                
+                    
\ No newline at end of file
diff --git "a/0046.\345\205\250\346\216\222\345\210\227/0046-\345\205\250\346\216\222\345\210\227.py" "b/0046.\345\205\250\346\216\222\345\210\227/0046-\345\205\250\346\216\222\345\210\227.py"
index 457bb71..f2a991c 100644
--- "a/0046.\345\205\250\346\216\222\345\210\227/0046-\345\205\250\346\216\222\345\210\227.py"
+++ "b/0046.\345\205\250\346\216\222\345\210\227/0046-\345\205\250\346\216\222\345\210\227.py"
@@ -1,22 +1,16 @@
-
 class Solution(object):
     def permute(self, nums):
         """
         :type nums: List[int]
         :rtype: List[List[int]]
         """
-        res, l = list(), len(nums)
-        def dfs(n, tmp):
-            if len(tmp) == l:
-                res.append(tmp[:])
-                return
-            for i, x in enumerate(n):
-                tmp.append(x)
-                dfs(n[:i] + n[i + 1:], tmp)
-                tmp.pop()
-            
-            
-        for i, x in enumerate(nums):
-            dfs(nums[:i] + nums[i + 1:], [x])
+        res = []
+        def dfs(tmp, nums):
+            if not nums:
+                res.append(tmp)
             
+            for i, x in enumerate(nums):
+                dfs(tmp + [x], nums[:i] + nums[i + 1:])
+                
+        dfs([], nums)
         return res
\ No newline at end of file
diff --git "a/0047.\345\205\250\346\216\222\345\210\227II/0047-\345\205\250\346\216\222\345\210\227II.py" "b/0047.\345\205\250\346\216\222\345\210\227II/0047-\345\205\250\346\216\222\345\210\227II.py"
index fcb677f..08a58bd 100644
--- "a/0047.\345\205\250\346\216\222\345\210\227II/0047-\345\205\250\346\216\222\345\210\227II.py"
+++ "b/0047.\345\205\250\346\216\222\345\210\227II/0047-\345\205\250\346\216\222\345\210\227II.py"
@@ -4,19 +4,16 @@ def permuteUnique(self, nums):
         :type nums: List[int]
         :rtype: List[List[int]]
         """
-        res, l = list(), len(nums)
-        def dfs(n, tmp):
-            if len(tmp) == l:
-                if tmp not in res:
-                    res.append(tmp[:])
-                return
-            for i, x in enumerate(n):
-                tmp.append(x)
-                dfs(n[:i] + n[i + 1:], tmp)
-                tmp.pop()
-            
-            
-        for i, x in enumerate(nums):
-            dfs(nums[:i] + nums[i + 1:], [x])
-            
+        nums.sort()
+        res = []
+        record = dict()
+        def dfs(tmp, nums):
+            if not nums:
+                res.append(tmp)
+                    
+            for i, x in enumerate(nums):
+                if i == 0 or nums[i] != nums[i - 1]:
+                    dfs(tmp + [x], nums[:i] + nums[i + 1:])
+                
+        dfs([], nums)
         return res
\ No newline at end of file
diff --git "a/0048.\346\227\213\350\275\254\345\233\276\345\203\217/0048-\346\227\213\350\275\254\345\233\276\345\203\217.py" "b/0048.\346\227\213\350\275\254\345\233\276\345\203\217/0048-\346\227\213\350\275\254\345\233\276\345\203\217.py"
new file mode 100644
index 0000000..e97f740
--- /dev/null
+++ "b/0048.\346\227\213\350\275\254\345\233\276\345\203\217/0048-\346\227\213\350\275\254\345\233\276\345\203\217.py"
@@ -0,0 +1,20 @@
+class Solution(object):
+    def rotate(self, matrix):
+        """
+        :type matrix: List[List[int]]
+        :rtype: None Do not return anything, modify matrix in-place instead.
+        """
+        #先转置再左右对称翻转
+        if not matrix or not matrix[0]:
+            return matrix
+        n = len(matrix)
+        
+        for i in range(n):
+            for j in range(i + 1, n):
+                matrix[i][j], matrix[j][i] = matrix[j][i], matrix[i][j]
+                
+        for row in matrix:
+            for i in range(n // 2):
+                row[i], row[n - 1 - i] = row[n - 1 - i], row[i]
+                
+        return matrix
\ No newline at end of file
diff --git "a/0049.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/0049-\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.py" "b/0049.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/0049-\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.py"
index e9abe00..6998b4a 100644
--- "a/0049.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/0049-\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.py"
+++ "b/0049.\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204/0049-\345\255\227\346\257\215\345\274\202\344\275\215\350\257\215\345\210\206\347\273\204.py"
@@ -4,13 +4,15 @@ def groupAnagrams(self, strs):
         :type strs: List[str]
         :rtype: List[List[str]]
         """
-        hashmap = dict()
-        for s in strs:
-            t = "".join(sorted(s))
-
-            if t in hashmap:
-                hashmap[t].append(s)
+        record = dict()
+        
+        for word in strs:
+            tmp = tuple(sorted(word))
+            # print tmp
+            if tmp in record:
+                record[tmp].append(word)
             else:
-                hashmap[t] = [s]
+                record[tmp] = [word]
+        return [val for key, val in record.items()]
             
-        return hashmap.values()
\ No newline at end of file
+                
\ No newline at end of file
diff --git a/0050.Pow(x,n)/0050-Pow(x,n).py b/0050.Pow(x,n)/0050-Pow(x,n).py
index ef94423..4d7478f 100644
--- a/0050.Pow(x,n)/0050-Pow(x,n).py
+++ b/0050.Pow(x,n)/0050-Pow(x,n).py
@@ -1,17 +1,22 @@
 class Solution(object):
-    def myPow(self, x, n):
+    def myPow(self, x0, n):
         """
         :type x: float
         :type n: int
         :rtype: float
         """
-        i = abs(n)
-        res = 1.0
-        while(i != 0):
-            if i % 2:
-                res *= x
-            x *= x
-            # print i, res
-            i /= 2
-        return res if n > 0 else 1/res
-        
\ No newline at end of file
+        if not n:
+            return 1
+        def helper(x, n, tmp):
+            print n, x
+            if n <= 1:
+                return x * tmp
+            if n % 2:
+                tmp *= x
+                n -= 1
+            return helper(x * x, n // 2, tmp)
+        op = 1
+        if n < 0:
+            op = -1 
+        res = helper(x0, abs(n), 1)
+        return res if op > 0 else 1.0/res
\ No newline at end of file
diff --git "a/0051.N\347\232\207\345\220\216/0051-N\347\232\207\345\220\216.py" "b/0051.N\347\232\207\345\220\216/0051-N\347\232\207\345\220\216.py"
index 76f3f05..c718df3 100644
--- "a/0051.N\347\232\207\345\220\216/0051-N\347\232\207\345\220\216.py"
+++ "b/0051.N\347\232\207\345\220\216/0051-N\347\232\207\345\220\216.py"
@@ -4,51 +4,40 @@ def solveNQueens(self, n):
         :type n: int
         :rtype: List[List[str]]
         """
-        board = ["." * n for _ in range(n)]
-
+        if n <= 0:
+            return []
         res = []
-        def checkRowAndCol(row, col):
+        def dfs(start, tmp):  
+            if start == n:
+                res.append(tmp[:])
+                return
             for i in range(n):
-                if (board[row][i] == "Q" and i != col) or (board[i][col] == "Q" and i != row): #发生了横向或者纵向冲突
-                    return False
-            return True
-        
-        def checkDoubleDio(row, col):
-            add = row + col
-            sub = col - row
-            
-            for x in range(n):
-                if x == row: #跳过自身这个点
-                    continue
-                y = add - x
-                # print add,sub, x, y
-                if y >= 0 and y < n and x >= 0 and x < n and board[x][y] == "Q": #发生/冲突
-                    return False
-            
-                y = sub + x
-                if y >= 0 and y < n and x >= 0 and x < n and board[x][y] == "Q": #发生\冲突
-                    return False
-                
-            return True
-        
+                tmp.append("." * i + "Q" + "." * (n - i - 1))
+                if self.isValid(tmp, start, i,  n):
+                    dfs(start + 1, tmp)
+                tmp.pop()
+        dfs(0, [])
+        return res
+    
+    def isValid(self, tmp, x0, y0, n):
+        self.add = x0 + y0
+        self.sub = y0 - x0
         
-        def dfs(row, col):
-            if col >= n: #本行所有位置都找完了
-                return
-            board[row] = "." * col + "Q" + (n - col - 1) * "." #把皇后放在(row, col)的位置上
-            if checkRowAndCol(row, col) and checkDoubleDio(row, col): #如果没有发生冲突
-                if row == n - 1: #如果放下的是最后一个皇后
-                    # print board
-                    res.append(board[:]) #找到一个可行解啦！！！
-                else:
-                    for i in range(n): #还要放更多的皇后，往下一行放吧
-                        dfs(row + 1, i)
-                        
-            board[row] = "." * n #回溯，把本行放下的皇后拿回来
-            # dfs(row, col + 1)
-            return
-
-        for i in range(n):
-            dfs(0, i)
+        for i in range(len(tmp)): #判断列
+            if i == x0:
+                continue
+            if tmp[i][y0] == "Q":
+                return False
             
-        return res
\ No newline at end of file
+        for i in range(min(n, len(tmp))): #判断\
+            if i == x0:
+                continue
+            # print i, j
+            j = self.add - i
+            # print i, j, self.add, tmp
+            if 0 <= j < n and tmp[i][j] == "Q":
+                return False
+            j = i + self.sub
+            if 0 <= j < n and tmp[i][j] == "Q":
+                return False
+        return True
\ No newline at end of file
diff --git "a/0052.N\347\232\207\345\220\216II/0052-N\347\232\207\345\220\216II.py" "b/0052.N\347\232\207\345\220\216II/0052-N\347\232\207\345\220\216II.py"
index 2e04536..68308b8 100644
--- "a/0052.N\347\232\207\345\220\216II/0052-N\347\232\207\345\220\216II.py"
+++ "b/0052.N\347\232\207\345\220\216II/0052-N\347\232\207\345\220\216II.py"
@@ -4,52 +4,40 @@ def totalNQueens(self, n):
         :type n: int
         :rtype: int
         """
-
-        board = ["." * n for _ in range(n)]
-        # print board
+        if n <= 0:
+            return []
         self.res = 0
-        def checkRowAndCol(row, col):
+        def dfs(start, tmp):  
+            if start == n:
+                self.res += 1
+                return
             for i in range(n):
-                if (board[row][i] == "Q" and i != col) or (board[i][col] == "Q" and i != row):
-                    return False
-            return True
-        
-        def checkDoubleDio(row, col):
-            add = row + col
-            sub = col - row
-            
-            for x in range(n):
-                if x == row:
-                    continue
-                y = add - x
-                # print add,sub, x, y
-                if y >= 0 and y < n and x >= 0 and x < n and board[x][y] == "Q":
-                    return False
-            
-                y = sub + x
-                if y >= 0 and y < n and x >= 0 and x < n and board[x][y] == "Q":
-                    return False
-                
-            return True
-        
+                tmp.append("." * i + "Q" + "." * (n - i - 1))
+                if self.isValid(tmp, start, i,  n):
+                    dfs(start + 1, tmp)
+                tmp.pop()
+        dfs(0, [])
+        return self.res
+    
+    def isValid(self, tmp, x0, y0, n):
+        self.add = x0 + y0
+        self.sub = y0 - x0
         
-        def dfs(row, col):
-            if col >= n:
-                return
-            board[row] = "." * col + "Q" + (n - col - 1) * "."
-            if checkRowAndCol(row, col) and checkDoubleDio(row, col):
-                if row == n - 1:
-                    # print board
-                    self.res += 1
-                else:
-                    for i in range(n):
-                        dfs(row + 1, i)
-                        
-            board[row] = "." * n
-            # dfs(row, col + 1)
-            return
-
-        for i in range(n):
-            dfs(0, i)
+        for i in range(len(tmp)): #判断列
+            if i == x0:
+                continue
+            if tmp[i][y0] == "Q":
+                return False
             
-        return self.res
\ No newline at end of file
+        for i in range(min(n, len(tmp))): #判断\
+            if i == x0:
+                continue
+            # print i, j
+            j = self.add - i
+            # print i, j, self.add, tmp
+            if 0 <= j < n and tmp[i][j] == "Q":
+                return False
+            j = i + self.sub
+            if 0 <= j < n and tmp[i][j] == "Q":
+                return False
+        return True
\ No newline at end of file
diff --git "a/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214/0053-\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.py" "b/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214/0053-\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.py"
index c890aaf..10a5d37 100644
--- "a/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214/0053-\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.py"
+++ "b/0053.\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214/0053-\346\234\200\345\244\247\345\255\220\345\272\217\345\222\214.py"
@@ -6,10 +6,14 @@ def maxSubArray(self, nums):
         """
         if not nums:
             return 0
-        dp = [nums[0]]
-        res = dp[0]
-        for i in range(1, len(nums)):
-            dp.append(max(dp[i-1] + nums[i], nums[i]))
-            if dp[-1] > res:
-                res = dp[-1]
-        return res
\ No newline at end of file
+        dp = [] # dp[i]表示以i结尾的连续子数组的最大和
+        for i, x in enumerate(nums):
+            if i == 0:
+                dp.append(x)
+            else:
+                if dp[-1] < 0:
+                    dp.append(x)
+                else:
+                    dp.append(dp[-1] + x)
+                    
+        return max(dp)
\ No newline at end of file
diff --git "a/0054.\350\236\272\346\227\213\347\237\251\351\230\265/0054-\350\236\272\346\227\213\347\237\251\351\230\265.py" "b/0054.\350\236\272\346\227\213\347\237\251\351\230\265/0054-\350\236\272\346\227\213\347\237\251\351\230\265.py"
index 4b07771..33e693b 100644
--- "a/0054.\350\236\272\346\227\213\347\237\251\351\230\265/0054-\350\236\272\346\227\213\347\237\251\351\230\265.py"
+++ "b/0054.\350\236\272\346\227\213\347\237\251\351\230\265/0054-\350\236\272\346\227\213\347\237\251\351\230\265.py"
@@ -4,27 +4,39 @@ def spiralOrder(self, matrix):
         :type matrix: List[List[int]]
         :rtype: List[int]
         """
-        m = len(matrix)
-        if m == 0:
+        if not matrix or not matrix[0]:
             return []
-        n = len(matrix[0])
-        if n == 0:
-            return []
-        r, i, j, di, dj = list(), 0, 0, 0, 1
-        
-        for _ in range(m * n):
-            r.append(matrix[i][j])
-            matrix[i][j] = None
-            if matrix[(i + di) % m][(j + dj) % n] == None: #来过了改转向了
-                di, dj = dj, -di #0 1 变 1 0, 1 0 变 0 -1, 0 -1 变 -1, 0, -1 0 变 0 1                
-            i += di
-            j += dj
-
-        return r
-                    
-                    
-                
-                        
-                
-                    
-        
\ No newline at end of file
+        m, n = len(matrix), len(matrix[0])
+        i, j = 0, 0
+        state = "right"
+        cnt = 0
+        res = []
+        while(cnt < m * n):
+            cnt += 1
+            res.append(matrix[i][j])
+            matrix[i][j] = "X"
+            if state == "right":
+                j += 1
+                if j == n or matrix[i][j] == "X":
+                    i += 1
+                    j -= 1
+                    state = "down"
+            elif state == "down":
+                i += 1
+                if i == m or matrix[i][j] == "X":
+                    i -= 1
+                    j -= 1
+                    state = "left"
+            elif state == "left":
+                j -= 1
+                if j == -1 or matrix[i][j] == "X":
+                    j += 1
+                    i -= 1
+                    state = "up"
+            elif state == "up":
+                i -= 1
+                if i == -1 or matrix[i][j] == "X":
+                    i += 1
+                    j += 1
+                    state = "right"
+        return res
\ No newline at end of file
diff --git "a/0055.\350\267\263\350\267\203\346\270\270\346\210\217/0055-\350\267\263\350\267\203\346\270\270\346\210\217.py" "b/0055.\350\267\263\350\267\203\346\270\270\346\210\217/0055-\350\267\263\350\267\203\346\270\270\346\210\217.py"
index 8198fc2..b6283c9 100644
--- "a/0055.\350\267\263\350\267\203\346\270\270\346\210\217/0055-\350\267\263\350\267\203\346\270\270\346\210\217.py"
+++ "b/0055.\350\267\263\350\267\203\346\270\270\346\210\217/0055-\350\267\263\350\267\203\346\270\270\346\210\217.py"
@@ -4,10 +4,9 @@ def canJump(self, nums):
         :type nums: List[int]
         :rtype: bool
         """
-
-        max_jump = 0
-        for index, num in enumerate(nums):
-            if index > max_jump:
-                return False
-            max_jump = max(max_jump, index + num)
-        return True
\ No newline at end of file
+        start, end = 0, 0
+        
+        while start <= end and end < len(nums):
+            end = max(end, start + nums[start])
+            start += 1
+        return end >= len(nums) - 1
\ No newline at end of file
diff --git "a/0056.\345\220\210\345\271\266\345\214\272\351\227\264/0056-\345\220\210\345\271\266\345\214\272\351\227\264.py" "b/0056.\345\220\210\345\271\266\345\214\272\351\227\264/0056-\345\220\210\345\271\266\345\214\272\351\227\264.py"
index ea26cc6..04c87a0 100644
--- "a/0056.\345\220\210\345\271\266\345\214\272\351\227\264/0056-\345\220\210\345\271\266\345\214\272\351\227\264.py"
+++ "b/0056.\345\220\210\345\271\266\345\214\272\351\227\264/0056-\345\220\210\345\271\266\345\214\272\351\227\264.py"
@@ -1,29 +1,21 @@
-# Definition for an interval.
-# class Interval(object):
-#     def __init__(self, s=0, e=0):
-#         self.start = s
-#         self.end = e
-
 class Solution(object):
     def merge(self, intervals):
         """
-        :type intervals: List[Interval]
-        :rtype: List[Interval]
+        :type intervals: List[List[int]]
+        :rtype: List[List[int]]
         """
         if not intervals:
-            return []
-        intervals = sorted(intervals,key=lambda x:x.start)
+            return intervals
+        intervals = sorted(intervals, key = lambda x: x[0])
+        start, end = intervals[0][0], intervals[0][1]
+        
         res = []
-        left = intervals[0].start
-        right = intervals[0].end
-        for item in intervals:
-            if item.start <= right:
-                right = max(right, item.end)
+        for i, interval in enumerate(intervals):
+            if interval[0] > end:
+                res.append([start, end])
+                start, end = interval[0], interval[1]
             else:
-                res.append([left, right])
-                left = item.start
-                right = item.end
-        res.append([left, right])
-                
+                end = max(end, interval[1])
+        res.append([start, end])
         return res
-            
\ No newline at end of file
+        
\ No newline at end of file
diff --git "a/0057.\346\217\222\345\205\245\345\214\272\351\227\264/0057-\346\217\222\345\205\245\345\214\272\351\227\264.py" "b/0057.\346\217\222\345\205\245\345\214\272\351\227\264/0057-\346\217\222\345\205\245\345\214\272\351\227\264.py"
index 508ed54..0c3824e 100644
--- "a/0057.\346\217\222\345\205\245\345\214\272\351\227\264/0057-\346\217\222\345\205\245\345\214\272\351\227\264.py"
+++ "b/0057.\346\217\222\345\205\245\345\214\272\351\227\264/0057-\346\217\222\345\205\245\345\214\272\351\227\264.py"
@@ -1,42 +1,28 @@
-# Definition for an interval.
-# class Interval(object):
-#     def __init__(self, s=0, e=0):
-#         self.start = s
-#         self.end = e
-
 class Solution(object):
     def insert(self, intervals, newInterval):
         """
-        :type intervals: List[Interval]
-        :type newInterval: Interval
-        :rtype: List[Interval]
+        :type intervals: List[List[int]]
+        :type newInterval: List[int]
+        :rtype: List[List[int]]
         """
-        # tmp = Interval(newInterval[0], newInterval[1])
         intervals.append(newInterval)
-        # intervals[-1] = newInterval
-        # print type(intervals[0]), type(tmp)
         return self.merge(intervals)
-    
     def merge(self, intervals):
         """
-        :type intervals: List[Interval]
-        :rtype: List[Interval]
+        :type intervals: List[List[int]]
+        :rtype: List[List[int]]
         """
-        
         if not intervals:
-            return []
-        intervals = sorted(intervals,key=lambda x:x[0])
+            return intervals
+        intervals = sorted(intervals, key = lambda x: x[0])
+        start, end = intervals[0][0], intervals[0][1]
+        
         res = []
-        left = intervals[0][0]
-        right = intervals[0][1]
-        for item in intervals:
-            if item[0] <= right:
-                right = max(right, item[1])
+        for i, interval in enumerate(intervals):
+            if interval[0] > end:
+                res.append([start, end])
+                start, end = interval[0], interval[1]
             else:
-                res.append([left, right])
-                left = item[0]
-                right = item[1]
-        res.append([left, right])
-                
-        return res
-            
\ No newline at end of file
+                end = max(end, interval[1])
+        res.append([start, end])
+        return res
\ No newline at end of file
diff --git "a/0058.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246/0058-\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py" "b/0058.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246/0058-\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py"
index 7e36392..2ef7de1 100644
--- "a/0058.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246/0058-\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py"
+++ "b/0058.\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246/0058-\346\234\200\345\220\216\344\270\200\344\270\252\345\215\225\350\257\215\347\232\204\351\225\277\345\272\246.py"
@@ -4,9 +4,11 @@ def lengthOfLastWord(self, s):
         :type s: str
         :rtype: int
         """
-        if len(s) <= 0 :
-            return 0
-        s = s.rstrip(" ")
-        print s,s.split(" ")
-        return len(s.split(" ")[-1])
-        
\ No newline at end of file
+        cnt = 0
+        for i in range(len(s) - 1, -1, -1):
+            if s[i] != " ":
+                while i >= 0 and s[i] != " ":
+                    cnt += 1
+                    i -= 1
+                break
+        return cnt
\ No newline at end of file
diff --git "a/0059.\350\236\272\346\227\213\347\237\251\351\230\265II/0059-\350\236\272\346\227\213\347\237\251\351\230\265II.py" "b/0059.\350\236\272\346\227\213\347\237\251\351\230\265II/0059-\350\236\272\346\227\213\347\237\251\351\230\265II.py"
index c4b4cc0..7789cb1 100644
--- "a/0059.\350\236\272\346\227\213\347\237\251\351\230\265II/0059-\350\236\272\346\227\213\347\237\251\351\230\265II.py"
+++ "b/0059.\350\236\272\346\227\213\347\237\251\351\230\265II/0059-\350\236\272\346\227\213\347\237\251\351\230\265II.py"
@@ -4,16 +4,35 @@ def generateMatrix(self, n):
         :type n: int
         :rtype: List[List[int]]
         """
-        
-        res = [[0 for i in range(n)] for j in range(n)]
-        
-        i, j, di, dj = 0, 0, 0, 1
-        for number in range(1, n ** 2 + 1):
-            res[i][j] = number            
-            if res[(i + di) % n][(j + dj) % n] != 0: #需要转向
-                di, dj = dj, - di                
-            i += di
-            j += dj
-            
-        return res
-            
\ No newline at end of file
+        i, j = 0, 0
+        state = "right"
+        cnt = 0
+        res = [[0 for _ in range(n)] for _ in range(n)]
+        while(cnt < n * n):
+            cnt += 1
+            res[i][j] = cnt
+            if state == "right":
+                j += 1
+                if j == n or res[i][j] != 0:
+                    i += 1
+                    j -= 1
+                    state = "down"
+            elif state == "down":
+                i += 1
+                if i == n or res[i][j] != 0:
+                    i -= 1
+                    j -= 1
+                    state = "left"
+            elif state == "left":
+                j -= 1
+                if j == -1 or res[i][j] != 0:
+                    j += 1
+                    i -= 1
+                    state = "up"
+            elif state == "up":
+                i -= 1
+                if i == -1 or res[i][j] != 0:
+                    i += 1
+                    j += 1
+                    state = "right"
+        return res
\ No newline at end of file
diff --git "a/0060.\347\254\254k\344\270\252\346\216\222\345\210\227/0060-\347\254\254k\344\270\252\346\216\222\345\210\227.py" "b/0060.\347\254\254k\344\270\252\346\216\222\345\210\227/0060-\347\254\254k\344\270\252\346\216\222\345\210\227.py"
index 306e3dc..ac61812 100644
--- "a/0060.\347\254\254k\344\270\252\346\216\222\345\210\227/0060-\347\254\254k\344\270\252\346\216\222\345\210\227.py"
+++ "b/0060.\347\254\254k\344\270\252\346\216\222\345\210\227/0060-\347\254\254k\344\270\252\346\216\222\345\210\227.py"
@@ -1,4 +1,3 @@
-import math
 class Solution(object):
     def getPermutation(self, n, k):
         """
@@ -6,13 +5,24 @@ def getPermutation(self, n, k):
         :type k: int
         :rtype: str
         """
-        digit = [i for i in range(1, n + 1)] #生成1 ~ n的列表
-        res = ""
-        while n > 0:
-            tmp = math.factorial(n - 1) #计算一共有多少种组合
-            idx =  (k - 1) / tmp #由K在tmp中占的比例来确定第一位的数字
-            k -= idx * tmp #第一位确定之后，刷新k
-            res += str(digit[idx])
-            digit.pop(idx)
-            n -= 1
-        return res
\ No newline at end of file
+        fac = [1]      
+        for i in range(2, n + 1):
+            fac.append(fac[-1] * i)
+        digits = [i for i in range(1, n + 1)]
+        
+        self.res = ""
+        def dfs(left_digit, tmp, kk):
+            if left_digit == 0:
+                self.res = tmp[:]
+                return
+            for digit in digits:
+                kk -= fac[left_digit - 2]
+                if kk <= 0:
+                    kk += fac[left_digit - 2]
+                    fac.pop()
+                    digits.remove(digit)
+                    dfs(left_digit - 1, tmp + str(digit), kk)
+                    break
+
+        dfs(n, "", k)
+        return self.res
\ No newline at end of file
diff --git "a/0061.\346\227\213\350\275\254\351\223\276\350\241\250/0061-\346\227\213\350\275\254\351\223\276\350\241\250.py" "b/0061.\346\227\213\350\275\254\351\223\276\350\241\250/0061-\346\227\213\350\275\254\351\223\276\350\241\250.py"
index 0ebda46..d44f254 100644
--- "a/0061.\346\227\213\350\275\254\351\223\276\350\241\250/0061-\346\227\213\350\275\254\351\223\276\350\241\250.py"
+++ "b/0061.\346\227\213\350\275\254\351\223\276\350\241\250/0061-\346\227\213\350\275\254\351\223\276\350\241\250.py"
@@ -11,30 +11,22 @@ def rotateRight(self, head, k):
         :type k: int
         :rtype: ListNode
         """
-        if k <= 0:
+        p = head
+        l = []
+        while p:
+            l.append(p.val)
+            p = p.next
+        if len(l) <= 1:
             return head
-        l = 0
-        ptr = head
-        while(ptr != None):
-            ptr = ptr.next
-            l += 1
-        # print l
-        if l <= 1:
-            return head
-        k = k % l
-        if k == 0:
+        k = k % len(l)
+        if not k:
             return head
         
-        fast = head
-        slow = head
-        while(k != 0):
-            fast  = fast.next
-            k-= 1
-        while(fast.next != None):
-            fast = fast.next
-            slow = slow.next
-        # print fast.val, slow.val
-        ptr = slow.next
-        fast.next = head
-        slow.next = None
-        return ptr
\ No newline at end of file
+        l = l[-k:] + l[:-k]
+        print l
+        newhead = ListNode(-1)
+        p = newhead
+        for item in l:
+            p.next = ListNode(item)
+            p = p.next
+        return newhead.next
\ No newline at end of file
diff --git "a/0062.\344\270\215\345\220\214\350\267\257\345\276\204/0062-\344\270\215\345\220\214\350\267\257\345\276\204.py" "b/0062.\344\270\215\345\220\214\350\267\257\345\276\204/0062-\344\270\215\345\220\214\350\267\257\345\276\204.py"
index 75c7dd1..8c89221 100644
--- "a/0062.\344\270\215\345\220\214\350\267\257\345\276\204/0062-\344\270\215\345\220\214\350\267\257\345\276\204.py"
+++ "b/0062.\344\270\215\345\220\214\350\267\257\345\276\204/0062-\344\270\215\345\220\214\350\267\257\345\276\204.py"
@@ -5,17 +5,14 @@ def uniquePaths(self, m, n):
         :type n: int
         :rtype: int
         """
-        # C(m + n - 2) (m - 1)
-        k = m + n - 2
-        t = m - 1
+        dp = [[0 for _ in range(m)]for _ in range(n)]
         
-        up = 1
-        for i in range(0, t):
-            up *= k - i
-        
-        down = 1
-        for i in range(1, m):
-            down *= i
-        
-        # print up, down
-        return up // down
\ No newline at end of file
+        for i in range(m):
+            dp[0][i] = 1
+        for j in range(n):
+            dp[j][0] = 1
+            
+        for i in range(1, n):
+            for j in range(1, m):
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]
\ No newline at end of file
diff --git "a/0063.\344\270\215\345\220\214\350\267\257\345\276\204II/0063-\344\270\215\345\220\214\350\267\257\345\276\204II.py" "b/0063.\344\270\215\345\220\214\350\267\257\345\276\204II/0063-\344\270\215\345\220\214\350\267\257\345\276\204II.py"
new file mode 100644
index 0000000..53bf790
--- /dev/null
+++ "b/0063.\344\270\215\345\220\214\350\267\257\345\276\204II/0063-\344\270\215\345\220\214\350\267\257\345\276\204II.py"
@@ -0,0 +1,28 @@
+class Solution(object):
+    def uniquePathsWithObstacles(self, obstacleGrid):
+        """
+        :type obstacleGrid: List[List[int]]
+        :rtype: int
+        """
+        if not obstacleGrid or not obstacleGrid[0] or obstacleGrid[0][0] == 1 or obstacleGrid[-1][-1] == 1:
+            return 0
+        m, n = len(obstacleGrid[0]), len(obstacleGrid)
+        dp = [[0 for _ in range(m)]for _ in range(n)]
+        
+        for i in range(m):
+            if obstacleGrid[0][i] != 1:
+                dp[0][i] = 1
+            else:
+                break
+        for j in range(n):
+            if obstacleGrid[j][0] != 1:
+                
+                dp[j][0] = 1
+            else:
+                break
+            
+        for i in range(1, n):
+            for j in range(1, m):
+                if obstacleGrid[i][j] != 1:
+                    dp[i][j] = dp[i - 1][j] + dp[i][j - 1]
+        return dp[-1][-1]
\ No newline at end of file
diff --git "a/0064.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0064-\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py" "b/0064.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0064-\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
index df7bfe7..d6a6897 100644
--- "a/0064.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0064-\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
+++ "b/0064.\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0064-\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
@@ -4,21 +4,23 @@ def minPathSum(self, grid):
         :type grid: List[List[int]]
         :rtype: int
         """
-        #dp[m][n] = min(dp[m - 1][n], dp[m][n - 1]) + grid[m][n]
-        if not grid:
+        if not grid or not grid[0]:
             return 0
-        m = len(grid)
-        n = len(grid[0])
-        dp = [[0] * (n)] * (m) 
+        m, n = len(grid), len(grid[0])
+        dp = [[0 for _ in range(n)] for _ in range(m)]
         for i in range(m):
             for j in range(n):
-                # print dp, i, j
-                if not i and not j:
-                    dp[i][j] = grid[i][j]
-                elif i and not j:
-                    dp[i][j] = dp[i-1][j] + grid[i][j]
-                elif not i and j:
-                    dp[i][j] = dp[i][j-1] + grid[i][j]
-                else:
-                    dp[i][j] = min(dp[i-1][j], dp[i][j-1]) + grid[i][j]
-        return dp[m-1][n-1]
\ No newline at end of file
+                # print i, j
+                dp[i][j] = grid[i][j]
+        
+        
+        dp[0][0] = grid[0][0]
+        for i in range(m):
+            for j in range(n):
+                if i - 1 >= 0 and j - 1 >= 0:
+                    dp[i][j] += min(dp[i - 1][j], dp[i][j - 1])
+                elif i - 1 >= 0:
+                    dp[i][j] += dp[i - 1][j]
+                elif j - 1 >= 0:
+                    dp[i][j] += dp[i][j - 1]
+        return dp[-1][-1]
\ No newline at end of file
diff --git "a/0066.\345\212\240\344\270\200/0066-\345\212\240\344\270\200.py" "b/0066.\345\212\240\344\270\200/0066-\345\212\240\344\270\200.py"
index 0e3ec96..2811cf8 100644
--- "a/0066.\345\212\240\344\270\200/0066-\345\212\240\344\270\200.py"
+++ "b/0066.\345\212\240\344\270\200/0066-\345\212\240\344\270\200.py"
@@ -4,21 +4,14 @@ def plusOne(self, digits):
         :type digits: List[int]
         :rtype: List[int]
         """
-        index = 0
-        if digits[-1] != 9:
-            digits[-1] += 1
-            return digits
-        else:
-            for index in range(len(digits)-1, -1,-1):
-                if digits[index] != 9:
-                    break
-            if digits[index] != 9:
-                digits[index] += 1
-                for i in range(index+ 1, len(digits)):
-                    digits[i] = 0
-                return digits
-            else:
-                res = [1]
-                for i in range(0,len(digits)):
-                    res.append(0)
-                return res
\ No newline at end of file
+        l = digits[::-1]
+        
+        l[0] += 1
+        for i in range(len(l)):
+            if l[i] > 9:
+                l[i] -= 10
+                if i != len(l) - 1:
+                    l[i + 1] += 1
+                else:
+                    l.append(1)
+        return l[::-1]
\ No newline at end of file
diff --git "a/0067.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214/0067-\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.py" "b/0067.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214/0067-\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.py"
index 4078a02..9daca05 100644
--- "a/0067.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214/0067-\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.py"
+++ "b/0067.\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214/0067-\344\272\214\350\277\233\345\210\266\346\261\202\345\222\214.py"
@@ -5,4 +5,26 @@ def addBinary(self, a, b):
         :type b: str
         :rtype: str
         """
-        return bin(int(a,2) + int(b,2))[2:]
\ No newline at end of file
+        l1, l2 = len(a), len(b)
+        if l1 < l2:
+            l1, l2 = l2, l1
+            a, b = b, a
+        la, lb = [], []
+        for char in a:
+            la.append(int(char))
+        for char in b:
+            lb.append(int(char))
+        la, lb = la[::-1], lb[::-1]
+        
+        for i in range(l1):
+            if i < l2:
+                la[i] += lb[i]
+            if la[i] > 1:
+                la[i] -= 2
+                if i != l1 - 1:
+                    la[i + 1] += 1
+                else:
+                    la.append(1)
+                    
+        return "".join(str(x) for x in la[::-1])
+            
\ No newline at end of file
diff --git "a/0069.x\347\232\204\345\271\263\346\226\271\346\240\271/0069-x\347\232\204\345\271\263\346\226\271\346\240\271.py" "b/0069.x\347\232\204\345\271\263\346\226\271\346\240\271/0069-x\347\232\204\345\271\263\346\226\271\346\240\271.py"
index e69de29..ed61097 100644
--- "a/0069.x\347\232\204\345\271\263\346\226\271\346\240\271/0069-x\347\232\204\345\271\263\346\226\271\346\240\271.py"
+++ "b/0069.x\347\232\204\345\271\263\346\226\271\346\240\271/0069-x\347\232\204\345\271\263\346\226\271\346\240\271.py"
@@ -0,0 +1,21 @@
+class Solution(object):
+    def mySqrt(self, x):
+        """
+        :type x: int
+        :rtype: int
+        """
+        if not x :
+            return 0
+        if x < 4:
+            return 1
+        start, end = 2, x // 2
+        while 1:
+            i = (start + end) // 2
+            if i ** 2 <= x and (i + 1) ** 2 >x:
+                return i
+            elif i ** 2 < x:
+                start = i + 1
+            elif i ** 2 > x:
+                end = i - 1
+                
+                
\ No newline at end of file
diff --git "a/0070.\347\210\254\346\245\274\346\242\257/0070-\347\210\254\346\245\274\346\242\257.py" "b/0070.\347\210\254\346\245\274\346\242\257/0070-\347\210\254\346\245\274\346\242\257.py"
index 46b3b2e..88ab0fc 100644
--- "a/0070.\347\210\254\346\245\274\346\242\257/0070-\347\210\254\346\245\274\346\242\257.py"
+++ "b/0070.\347\210\254\346\245\274\346\242\257/0070-\347\210\254\346\245\274\346\242\257.py"
@@ -1,22 +1,19 @@
 class Solution(object):
-
     def climbStairs(self, n):
         """
         :type n: int
         :rtype: int
         """
-        if n <= 1:
-            return 1
-        if n == 2:
-            return 2
-        a = 1
-        b = 2
-        count = 3
-        while count<=n:
-          c = a + b
-          a = b
-          b = c
-          count += 1
-        return c
-          
-    
+        if n <= 2:
+            return [1, 2][n - 1]
+        first = 1
+        second = 2
+        cnt = 2
+        while cnt < n:
+            cnt += 1
+            cur = first + second
+            if cnt == n:
+                return cur
+            first = second
+            second = cur
+        
\ No newline at end of file
diff --git "a/0071.\347\256\200\345\214\226\350\267\257\345\276\204/0071-\347\256\200\345\214\226\350\267\257\345\276\204.py" "b/0071.\347\256\200\345\214\226\350\267\257\345\276\204/0071-\347\256\200\345\214\226\350\267\257\345\276\204.py"
index 658d06a..d008010 100644
--- "a/0071.\347\256\200\345\214\226\350\267\257\345\276\204/0071-\347\256\200\345\214\226\350\267\257\345\276\204.py"
+++ "b/0071.\347\256\200\345\214\226\350\267\257\345\276\204/0071-\347\256\200\345\214\226\350\267\257\345\276\204.py"
@@ -4,16 +4,12 @@ def simplifyPath(self, path):
         :type path: str
         :rtype: str
         """
-        if not path:
-            return ""
-        pathList = path.split("/")
+        l = path.split("/")
         stack = []
-        for path in pathList:
-            if path == "." or path == "":
-                continue
-            if path == "..":
-                if stack:
-                    stack.pop()
-            else:
-                stack.append(path)
+        for item in l:
+            if item != "." and item != ".." and item:
+                stack.append(item)
+            elif item == ".." and stack:
+                stack.pop()
+
         return "/" + "/".join(stack)
\ No newline at end of file
diff --git "a/0072.\347\274\226\350\276\221\350\267\235\347\246\273/0072-\347\274\226\350\276\221\350\267\235\347\246\273.py" "b/0072.\347\274\226\350\276\221\350\267\235\347\246\273/0072-\347\274\226\350\276\221\350\267\235\347\246\273.py"
index 5fb05aa..84662af 100644
--- "a/0072.\347\274\226\350\276\221\350\267\235\347\246\273/0072-\347\274\226\350\276\221\350\267\235\347\246\273.py"
+++ "b/0072.\347\274\226\350\276\221\350\267\235\347\246\273/0072-\347\274\226\350\276\221\350\267\235\347\246\273.py"
@@ -5,21 +5,21 @@ def minDistance(self, word1, word2):
         :type word2: str
         :rtype: int
         """
-        #用dp[i][j]表示word1[:i + 1], word2[:j + 1]这个问题的解
-        m, n = len(word1), len(word2)
-        dp = [[0 for _ in range(n + 1)] for _ in range(m + 1)]
+        #dp[i][j]表示word1[:i + 1]和word2[:j + 1]的解
+        l1, l2 = len(word1), len(word2)
+        dp = [[0 for _ in range(l2 + 1)] for _ in range(l1 + 1)]
         
-        for i in range(m + 1): 
+        for i in range(l1 + 1):
             dp[i][0] = i
+        for j in range(l2 + 1):
+            dp[0][j] = j
             
-        for i in range(n + 1):
-            dp[0][i] = i
-            
-        for i in range(1, m + 1):
-            for j in range(1, n + 1):
+        for i in range(1, l1 + 1):
+            for j in range(1, l2 + 1):
                 if word1[i - 1] == word2[j - 1]:
                     dp[i][j] = dp[i - 1][j - 1]
                 else:
-                    dp[i][j] = 1 + min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1]) #分别对应插入，替换，删除
-                    
-        return dp[m][n]
\ No newline at end of file
+                    dp[i][j] = 1 + min(dp[i - 1][j], dp[i - 1][j - 1], dp[i][j - 1])
+        return dp[l1][l2]
+        
+    
\ No newline at end of file
diff --git "a/0073.\347\237\251\351\230\265\347\275\256\351\233\266/0073-\347\237\251\351\230\265\347\275\256\351\233\266.py" "b/0073.\347\237\251\351\230\265\347\275\256\351\233\266/0073-\347\237\251\351\230\265\347\275\256\351\233\266.py"
index fd3f47b..f33d6de 100644
--- "a/0073.\347\237\251\351\230\265\347\275\256\351\233\266/0073-\347\237\251\351\230\265\347\275\256\351\233\266.py"
+++ "b/0073.\347\237\251\351\230\265\347\275\256\351\233\266/0073-\347\237\251\351\230\265\347\275\256\351\233\266.py"
@@ -2,23 +2,23 @@ class Solution(object):
     def setZeroes(self, matrix):
         """
         :type matrix: List[List[int]]
-        :rtype: void Do not return anything, modify matrix in-place instead.
+        :rtype: None Do not return anything, modify matrix in-place instead.
         """
-        self.matrix = matrix
-        m = len(matrix)
-        n = len(matrix[0])
-        l_m = [1] * m
-        l_n = [1] * n
+        if not matrix or not matrix[0]:
+            return matrix
+        m, n = len(matrix), len(matrix[0])
+        
         for i in range(m):
             for j in range(n):
-                # print matrix[i][j], i, j
                 if matrix[i][j] == 0:
-                    l_m[i] = 0
-                    l_n[j] = 0
-        # print l_m, l_n
+                    for t in range(m):#同一列
+                        if matrix[t][j] != 0:
+                            matrix[t][j] = "0"
+                    for t in range(n):#同一行
+                        if matrix[i][t] != 0:
+                            matrix[i][t] = "0"            
         for i in range(m):
             for j in range(n):
-                # print i,j
-                if l_m[i] == 0 or l_n[j] == 0:
-                        matrix[i][j] = 0
-                # print matrix
+                if matrix[i][j] == "0":
+                    matrix[i][j] = 0
+        
\ No newline at end of file
diff --git "a/0074.\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265/0074-\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265.py" "b/0074.\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265/0074-\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265.py"
index e36dfbb..a298ed2 100644
--- "a/0074.\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265/0074-\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265.py"
+++ "b/0074.\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265/0074-\346\220\234\347\264\242\344\272\214\347\273\264\347\237\251\351\230\265.py"
@@ -5,23 +5,19 @@ def searchMatrix(self, matrix, target):
         :type target: int
         :rtype: bool
         """
-        m = len(matrix)
-        if m == 0:
-            return False
-        n = len(matrix[0])
-        if n == 0:
+        if not matrix or not matrix[0]:
             return False
+        m, n = len(matrix), len(matrix[0])
         
-        x, y = m - 1, 0
-        while(1):
-            if x < 0 or x >= m or y <0 or y >= n:
-                break
-            val = matrix[x][y]
-            if val == target:
-                return True
-            elif val > target:
-                x -= 1
-            elif val <target:
-                y += 1
-                
-        return False
+        i, j = m - 1, 0
+        while 1:
+            if 0 <= i < m and 0 <= j < n:
+                cur = matrix[i][j]
+                if cur == target:
+                    return True
+                elif cur < target:
+                    j += 1
+                elif cur > target:
+                    i -= 1
+            else:
+                return False
\ No newline at end of file
diff --git "a/0075.\351\242\234\350\211\262\345\210\206\347\261\273/0075-\351\242\234\350\211\262\345\210\206\347\261\273.py" "b/0075.\351\242\234\350\211\262\345\210\206\347\261\273/0075-\351\242\234\350\211\262\345\210\206\347\261\273.py"
index f91676d..45ee9b3 100644
--- "a/0075.\351\242\234\350\211\262\345\210\206\347\261\273/0075-\351\242\234\350\211\262\345\210\206\347\261\273.py"
+++ "b/0075.\351\242\234\350\211\262\345\210\206\347\261\273/0075-\351\242\234\350\211\262\345\210\206\347\261\273.py"
@@ -2,31 +2,19 @@ class Solution(object):
     def sortColors(self, nums):
         """
         :type nums: List[int]
-        :rtype: void Do not return anything, modify nums in-place instead.
+        :rtype: None Do not return anything, modify nums in-place instead.
         """
-        b = 0
-        r = 0
-        w = 0
-        for item in nums:
-            if item == 0:
-                r+= 1
-            if item == 1:
-                w += 1
-            if item == 2:
-                b += 1
-        for index,item in enumerate(nums):
-            if r!= 0:
-                nums[index] = 0
-                r -= 1
-                continue
-            if w!= 0:
-                nums[index] = 1
-                w -= 1
-                continue
-            if b!= 0:
-                nums[index] = 2
-                b -= 1
-                continue
-        # return nums
-            
-        
\ No newline at end of file
+        lo, hi = 0, len(nums) - 1
+        i = 0
+        while i <= hi:
+            x = nums[i]
+            if x == 0:
+                nums[lo], nums[i] = nums[i], nums[lo]
+                lo += 1
+                i += 1
+            elif x == 2:
+                nums[hi], nums[i] = nums[i], nums[hi]
+                hi -= 1
+            else:
+                i += 1
+                
\ No newline at end of file
diff --git "a/0077.\347\273\204\345\220\210/0077-\347\273\204\345\220\210.py" "b/0077.\347\273\204\345\220\210/0077-\347\273\204\345\220\210.py"
index fba47df..c3cdc1b 100644
--- "a/0077.\347\273\204\345\220\210/0077-\347\273\204\345\220\210.py"
+++ "b/0077.\347\273\204\345\220\210/0077-\347\273\204\345\220\210.py"
@@ -6,18 +6,13 @@ def combine(self, n, k):
         :rtype: List[List[int]]
         """
         res = []
-        def generate(k, i, tmp):
-            
-            if k == 0:
+        def dfs(t, cnt, tmp):
+            if cnt == 0:
                 res.append(tmp[:])
-                return
-            
-            for j in range(i , n + 1):
-                tmp.append(j)
-                generate(k - 1, j + 1, tmp)
-                tmp.pop()
+
+            for i in range(t + 1, n + 1):
+                dfs(i, cnt - 1, tmp + [i])
             
-        
-        generate(k, 1, [])
+        dfs(0, k, [])
         return res
-        
\ No newline at end of file
+            
\ No newline at end of file
diff --git "a/0078.\345\255\220\351\233\206/0078-\345\255\220\351\233\206.py" "b/0078.\345\255\220\351\233\206/0078-\345\255\220\351\233\206.py"
index e2fcb4e..6012ad0 100644
--- "a/0078.\345\255\220\351\233\206/0078-\345\255\220\351\233\206.py"
+++ "b/0078.\345\255\220\351\233\206/0078-\345\255\220\351\233\206.py"
@@ -1,24 +1,14 @@
-import copy
 class Solution(object):
     def subsets(self, nums):
         """
         :type nums: List[int]
         :rtype: List[List[int]]
-        """     
-        res, tmp = [], []
-        
-        def generate(nums, n):
-            res.append(tmp[:])
+        """
+        res = [[]]
+        for num in nums:
+            tmp = res[:]
+            for item in res:
+                tmp.append(item + [num])     
+            res = tmp[:]
             
-            if n == len(nums):
-                return 
-            for i in range(n, len(nums)):
-                tmp.append(nums[i])
-                n += 1
-                generate(nums, n)
-                tmp.pop()
-                
-        generate(nums, 0)
-        return res
-
-        
\ No newline at end of file
+        return res
\ No newline at end of file
diff --git "a/0079.\345\215\225\350\257\215\346\220\234\347\264\242/0079-\345\215\225\350\257\215\346\220\234\347\264\242.py" "b/0079.\345\215\225\350\257\215\346\220\234\347\264\242/0079-\345\215\225\350\257\215\346\220\234\347\264\242.py"
index 5af9e24..77cc5f1 100644
--- "a/0079.\345\215\225\350\257\215\346\220\234\347\264\242/0079-\345\215\225\350\257\215\346\220\234\347\264\242.py"
+++ "b/0079.\345\215\225\350\257\215\346\220\234\347\264\242/0079-\345\215\225\350\257\215\346\220\234\347\264\242.py"
@@ -5,45 +5,36 @@ def exist(self, board, word):
         :type word: str
         :rtype: bool
         """
-        if not board or not board[0] or not len(word):
-            return False
-        
-        m, n = len(board), len(board[0])
-        if len(word) > m *n:
+        if not board or not board[0]:
             return False
+        if not word:
+            return True
         
         self.res = False
         dx = [1, -1, 0, 0]
         dy = [0, 0, 1, -1]
-        visited = [[0 for _ in range(n + 1)] for j in range(m + 1)]
-        
         def dfs(start, x0, y0):
-            if start >= len(word) or board[x0][y0] != word[start]: #找不到解
+            if start == len(word) - 1:
+                self.res = True
                 return
+            visited.add((x0, y0))
             
-            visited[x0][y0] = 1
-            if board[x0][y0] == word[start]:
-                if start == len(word) - 1: #找到一个可行解啦！！！
-                    self.res = True
-                    return
-                else:
-                    for k in range(4):
-                        x = x0 + dx[k]
-                        y = y0 + dy[k]
-                        
-                        if 0<= x < m and 0<= y < n and visited[x][y] == 0  and not self.res: #not self.res很关键，剪枝非常重要
-                            dfs(start + 1, x, y) #找下一个字母
-            visited[x0][y0] = 0 #回溯
-                            
+            for k in range(4):
+                x = x0 + dx[k]
+                y = y0 + dy[k]
+                # print x, y
+                if 0 <= x < m and 0 <= y < n and (x, y) not in visited and board[x][y] == word[start + 1] and not self.res:
+                    visited.add((x, y))
+                    dfs(start + 1, x, y)
+                    visited.remove((x, y))
             
+        m, n = len(board), len(board[0])
+        # print m * n, len(word)
         for i in range(m):
             for j in range(n):
                 if board[i][j] == word[0]:
-                    dfs(0, i, j) #开始搜索
-                if self.res:
-                    return self.res
-        return self.res
-        
-        
-        
-        
\ No newline at end of file
+                    visited = set()
+                    dfs(0, i, j)
+                    if self.res:
+                        return True
+        return False
\ No newline at end of file
diff --git "a/0080.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II/0080-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.py" "b/0080.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II/0080-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.py"
index e489bb1..9bac95c 100644
--- "a/0080.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II/0080-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.py"
+++ "b/0080.\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II/0080-\345\210\240\351\231\244\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\351\207\215\345\244\215\351\241\271II.py"
@@ -9,4 +9,5 @@ def removeDuplicates(self, nums):
             if i < 2 or num != nums[i - 2]:
                 nums[i] = num
                 i += 1
+                
         return i
\ No newline at end of file
diff --git "a/0081.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II/0081-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II.py" "b/0081.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II/0081-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II.py"
index c30f94d..e5f1122 100644
--- "a/0081.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II/0081-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II.py"
+++ "b/0081.\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II/0081-\346\220\234\347\264\242\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204II.py"
@@ -5,110 +5,8 @@ def search(self, nums, target):
         :type target: int
         :rtype: bool
         """
-        #如果第一个数和最后一个数不相等，那么跟上一题没有区别
-        #如果第一个数和最后一个数相等，而且等于target，return true
-        #如果第一个数和最后一个数相等，但是不等于target，在最坏的情况下就需要遍历两个升序数组的某一个，已确定target有可能落在哪一段，极端情况时间复杂度会降低到0(N)
-        if not nums:
-            return False
-        if nums[0] != nums[-1]:
-            return self.search1(nums, target)
-        if nums[0] == nums[-1]:
-            if nums[0] == target:
+        for num in nums:
+            if target == num:
                 return True
-            else:
-                # for num in nums: #偷懒就可以这么写……直接上O(N)的算法
-                #     if num == target:
-                #         return True
-                # return False
-                return self.search2(nums, target)
-        
-    def search1(self, nums, target): #上一题的解答，两次二分查找分别找旋转点和结果
-        """
-        :type nums: List[int]
-        :type target: int
-        :rtype: int
-        """
-        if not nums:
-            return -1
-        if len(nums) == 1:
-            return True if nums[0] == target else False
-        
-        lo, hi = 0, len(nums) - 1
-        while(lo <= hi):
-            mid = (lo + hi) // 2
-            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]: #旋转点为mid
-                break
-            if nums[mid] <= nums[-1]:
-                hi = mid - 1
-            elif nums[mid] >= nums[0]:
-                lo = mid + 1
-                
-        if lo > hi:#没有旋转
-            lo, hi = 0, len(nums) - 1
-        else:
-            if target >= nums[0]:
-                lo, hi = 0, mid
-            else:
-                lo, hi = mid + 1, len(nums) - 1
-
-        while(lo <= hi):
-            mid = (lo + hi) // 2
-            if nums[mid] == target:
-                return True
-            elif nums[mid] > target:
-                hi = mid - 1
-            else:
-                lo = mid + 1
-        
-        return False
-    
-    def search2(self, nums, target):#这种情况下nums[0] == nums[-1]
-        """
-        :type nums: List[int]
-        :type target: int
-        :rtype: int
-        """
-        if not nums:
-            return -1
-        if len(nums) == 1:
-            return True if nums[0] == target else False
-        
-        lo, hi = 0, len(nums) - 1
-        while(lo <= hi):
-            mid = (lo + hi) // 2
-            if mid + 1 < len(nums) and nums[mid] > nums[mid +1]:
-                break
-            if nums[mid] == nums[0]: #无法确定mid落在哪一段
-                i = mid
-                while(i < len(nums) - 1 and nums[i] == nums[i + 1]):
-                    i += 1
-                if i == len(nums) - 1:#整个右段都找完了，全部跟nums[0]一样，所以target肯定落在左侧，也就是0 ~ mid这一段
-                    hi = mid - 1
-                else:
-                    lo = mid + 1
-                
-            if nums[mid] < nums[-1]:
-                hi = mid - 1
-            elif nums[mid] > nums[0]:
-                lo = mid + 1    
-
-        if target > nums[mid]:
-            return False #因为mid一定是最大的那个数
-        elif target == nums[mid]: #找到了就直接返回
-            return True
-        elif target < nums[mid]: #还需要二分查找，现在要确认找左侧还是找右侧
-            if target > nums[0]: #在左侧找
-                lo, hi = 0, mid - 1
-            else: #在右侧找
-                lo, hi = mid + 1, len(nums) - 1
             
-        while(lo <= hi):
-            mid = (lo + hi) // 2
-            if nums[mid] == target:
-                return True
-            elif nums[mid] > target:
-                hi = mid - 1
-            else:
-                lo = mid + 1
-        
         return False
\ No newline at end of file
diff --git "a/0082.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II/0082-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II.py" "b/0082.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II/0082-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II.py"
index c5c52fa..2f4b37b 100644
--- "a/0082.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II/0082-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II.py"
+++ "b/0082.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II/0082-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240II.py"
@@ -10,17 +10,19 @@ def deleteDuplicates(self, head):
         :type head: ListNode
         :rtype: ListNode
         """
-        new_head = ListNode(1)
-        new_head.next = head
-        pre = new_head
-        cur = head
-        while cur:
-            while cur.next != None and cur.val == cur.next.val:
-                cur = cur.next;
-            if cur == pre.next:
-                pre = pre.next
-            else:
-                pre.next = cur.next
-            cur = cur.next
-                
-        return new_head.next
\ No newline at end of file
+        if not head or not head.next:
+            return head            
+        newhead = ListNode(-1)
+        newhead.next = head
+        if head.val != head.next.val:
+            head.next = self.deleteDuplicates(head.next)
+        else:
+            p = head
+            while p and p.val == head.val:
+                p = p.next
+            newhead.next = self.deleteDuplicates(p)
+            
+        return newhead.next
+        
+            
+        
\ No newline at end of file
diff --git "a/0083.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240/0083-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240.py" "b/0083.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240/0083-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240.py"
new file mode 100644
index 0000000..a601135
--- /dev/null
+++ "b/0083.\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240/0083-\345\210\240\351\231\244\346\216\222\345\272\217\351\223\276\350\241\250\344\270\255\347\232\204\351\207\215\345\244\215\345\205\203\347\264\240.py"
@@ -0,0 +1,20 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def deleteDuplicates(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+            return head
+        p = head
+        while p and p.val == head.val:
+            p = p.next
+        head.next = self.deleteDuplicates(p)
+            
+        return head
\ No newline at end of file
diff --git "a/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/0084-\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.py" "b/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/0084-\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.py"
index ac9a2dc..465d8f7 100644
--- "a/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/0084-\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.py"
+++ "b/0084.\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242/0084-\346\237\261\347\212\266\345\233\276\344\270\255\346\234\200\345\244\247\347\232\204\347\237\251\345\275\242.py"
@@ -4,15 +4,12 @@ def largestRectangleArea(self, heights):
         :type heights: List[int]
         :rtype: int
         """
-        res = 0
-        stack = list()
         heights = [0] + heights + [0]
-        for i in range(len(heights)):
-            while stack and heights[stack[-1]] > heights[i]:
-                top = stack.pop()
-                res = max(res, (i - stack[-1] - 1) * heights[top])
-                # print (i - stack[-1] - 1) * heights[top], heights[top]
-
+        stack = []
+        res = 0
+        for i, num in enumerate(heights):
+            while stack and heights[stack[-1]] > num:
+                    top = stack.pop()
+                    res = max(res, (i - stack[-1] - 1) * heights[top])
             stack.append(i)
-            # print stack
         return res
\ No newline at end of file
diff --git "a/0088.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/0088-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.py" "b/0088.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/0088-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.py"
index a3d895f..2f0a252 100644
--- "a/0088.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/0088-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.py"
+++ "b/0088.\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204/0088-\345\220\210\345\271\266\344\270\244\344\270\252\346\234\211\345\272\217\346\225\260\347\273\204.py"
@@ -5,28 +5,8 @@ def merge(self, nums1, m, nums2, n):
         :type m: int
         :type nums2: List[int]
         :type n: int
-        :rtype: void Do not return anything, modify nums1 in-place instead.
+        :rtype: None Do not return anything, modify nums1 in-place instead.
         """
-        temp = []
-        p1 = 0
-        p2 = 0
-        while(p1 < m and p2 < n):
-            if (nums1[p1] <= nums2[p2]):
-                temp.append(nums1[p1])
-                p1 += 1
-            else:
-                temp.append(nums2[p2])
-                p2 += 1
-        
-        while(p1 < m):
-            temp.append(nums1[p1])
-            p1 += 1
-        while(p2 < n):
-            temp.append(nums2[p2])
-            p2 += 1
-        
-        for i in range(0, m + n ):
-            nums1[i] = temp[i]
-        
-        # return nums1
-        
\ No newline at end of file
+        nums1[:] = (nums1[:m] + nums2)
+        nums1.sort()
+        # return sorted(nums)
\ No newline at end of file
diff --git "a/0089.\346\240\274\351\233\267\347\274\226\347\240\201/0089-\346\240\274\351\233\267\347\274\226\347\240\201.py" "b/0089.\346\240\274\351\233\267\347\274\226\347\240\201/0089-\346\240\274\351\233\267\347\274\226\347\240\201.py"
index 67ffe43..4bf87ea 100644
--- "a/0089.\346\240\274\351\233\267\347\274\226\347\240\201/0089-\346\240\274\351\233\267\347\274\226\347\240\201.py"
+++ "b/0089.\346\240\274\351\233\267\347\274\226\347\240\201/0089-\346\240\274\351\233\267\347\274\226\347\240\201.py"
@@ -4,8 +4,7 @@ def grayCode(self, n):
         :type n: int
         :rtype: List[int]
         """
-        # G(i) = i ^ (i /2)
-        dp = [0 for _  in range(2 ** n)]
-        for i in range(1, 2 ** n):
-            dp[i] = i ^ (i /2)
-        return dp
\ No newline at end of file
+        res = []
+        for i in range(2 ** n):
+            res.append(i ^ (i // 2))
+        return res 
\ No newline at end of file
diff --git "a/0090.\345\255\220\351\233\206II/0090-\345\255\220\351\233\206II.py" "b/0090.\345\255\220\351\233\206II/0090-\345\255\220\351\233\206II.py"
index 2ffe5bb..f8ebd70 100644
--- "a/0090.\345\255\220\351\233\206II/0090-\345\255\220\351\233\206II.py"
+++ "b/0090.\345\255\220\351\233\206II/0090-\345\255\220\351\233\206II.py"
@@ -4,13 +4,13 @@ def subsetsWithDup(self, nums):
         :type nums: List[int]
         :rtype: List[List[int]]
         """
-        nums.sort()
-        result = [[]]
+        res = [[]]
         for num in nums:
-            for i in result[:]:
-                item = i[:]
-                item.append(num)
-                if item not in result:
-                    result.append(item[:])
-        return result
-    
+            tmp = res[:]
+            for item in res:
+                newitem = sorted(item + [num])
+                if newitem not in tmp:
+                    tmp.append(newitem)
+            res = tmp[:]
+            
+        return res
\ No newline at end of file
diff --git "a/0092.\345\217\215\350\275\254\351\223\276\350\241\250II/0092-\345\217\215\350\275\254\351\223\276\350\241\250II.py" "b/0092.\345\217\215\350\275\254\351\223\276\350\241\250II/0092-\345\217\215\350\275\254\351\223\276\350\241\250II.py"
index a2e191b..4edf755 100644
--- "a/0092.\345\217\215\350\275\254\351\223\276\350\241\250II/0092-\345\217\215\350\275\254\351\223\276\350\241\250II.py"
+++ "b/0092.\345\217\215\350\275\254\351\223\276\350\241\250II/0092-\345\217\215\350\275\254\351\223\276\350\241\250II.py"
@@ -12,52 +12,40 @@ def reverseBetween(self, head, m, n):
         :type n: int
         :rtype: ListNode
         """
-        # 先找到m ~ n这一段，翻转，再塞回去
-        if m == n:
-            return head
+        newhead = ListNode(-1)
+        newhead.next = head
+        #找到第m - 1和第n个节点
         cnt = 1
-        pre_m, pn = None, None
-        node = head
-        while(cnt < n):
-            # print node.val, cnt
-            if cnt == m - 1:
-                pre_m = node
-            node, cnt = node.next, cnt + 1
-        pn = node
-        if pn:
-            nextn = pn.next
-            pn.next = None
-        else:
-            nextn = None
-        # print pre_m.val, nextn.val
-         
-        if pre_m is None: #从1开始
-            head = self.reverseList(head)
-            newhead = head
-            while(head.next):
-                head = head.next
-            head.next = nextn
-            return newhead
+        slow = head
+        while cnt < m - 1:
+            print slow.val
+            slow = slow.next
+            cnt += 1
+        cnt = 1
+        fast = head
+        while cnt < n:
+            # print fast.val, n
+            fast = fast.next        
+            cnt += 1
+            # print fast.val, cnt
+        print slow.val, fast.val  
+        tail = fast.next
+        fast.next = None
+        if m != 1:          
+            slow.next = self.reverseLL(slow.next)
         else:
-            pre_m.next = self.reverseList(pre_m.next)
-            newhead = head
-            while(head.next):
-                head = head.next
-            head.next = nextn
-            return newhead
-        
-            
-            
-
+            newhead.next = self.reverseLL(slow)
+        p = slow
+        while p and p.next:
+            p = p.next
+        p.next = tail
+        return newhead.next
         
-    def reverseList(self, head):
-        """
-        :type head: ListNode
-        :rtype: ListNode
-        """
-        if head is None or head.next is None:
+    def reverseLL(self, head):
+        if not head or not head.next:
             return head
-        tmp = self.reverseList(head.next)
+        
+        p = self.reverseLL(head.next)
         head.next.next = head
         head.next = None
-        return tmp
\ No newline at end of file
+        return p
\ No newline at end of file
diff --git "a/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0098-\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py" "b/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0098-\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
index 20a8927..bc284dc 100644
--- "a/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0098-\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
+++ "b/0098.\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0098-\351\252\214\350\257\201\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
@@ -11,22 +11,10 @@ def isValidBST(self, root):
         :type root: TreeNode
         :rtype: bool
         """
-        inorder = list() 
-        self.inorderTra(root, inorder)
-        # print inorder
-        for i in range(len(inorder)-1):
-            if inorder[i] >= inorder[i+1]:
-                return False
-        return True
-    
-    def inorderTra(self, root, inorder):
-        if not root:
-            return None
-    
+        def inOrder(node):
+            if not node:
+                return []
+            return inOrder(node.left) + [node.val] + inOrder(node.right)
         
-        self.inorderTra(root.left, inorder)
-        inorder.append(root.val)
-        self.inorderTra(root.right, inorder)
-        
-        return 
-        
\ No newline at end of file
+        inorder = inOrder(root)
+        return len(inorder) == len(set(inorder)) and inorder == sorted(inorder)
\ No newline at end of file
diff --git "a/0099.\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0099-\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py" "b/0099.\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0099-\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
new file mode 100644
index 0000000..9a783e1
--- /dev/null
+++ "b/0099.\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0099-\346\201\242\345\244\215\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
@@ -0,0 +1,33 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def recoverTree(self, root):
+        """
+        :type root: TreeNode
+        :rtype: None Do not return anything, modify root in-place instead.
+        """
+        def inOrder(node):
+            if not node:
+                return []
+            return inOrder(node.left) + [node.val] + inOrder(node.right)
+        
+        inorder = inOrder(root)
+        inorder.sort()
+        
+        self.idx = 0
+        def change(node):
+            if not node:
+                return
+            change(node.left)
+            node.val = inorder[self.idx]
+            self.idx += 1
+            change(node.right)
+            
+        change(root)
+        return root
+            
\ No newline at end of file
diff --git "a/0100.\347\233\270\345\220\214\347\232\204\346\240\221/0100-\347\233\270\345\220\214\347\232\204\346\240\221.py" "b/0100.\347\233\270\345\220\214\347\232\204\346\240\221/0100-\347\233\270\345\220\214\347\232\204\346\240\221.py"
index 4abafa3..981c048 100644
--- "a/0100.\347\233\270\345\220\214\347\232\204\346\240\221/0100-\347\233\270\345\220\214\347\232\204\346\240\221.py"
+++ "b/0100.\347\233\270\345\220\214\347\232\204\346\240\221/0100-\347\233\270\345\220\214\347\232\204\346\240\221.py"
@@ -12,22 +12,8 @@ def isSameTree(self, p, q):
         :type q: TreeNode
         :rtype: bool
         """
-        if not p and not q:
-            return True
-        
-        self.result = True
-        self.check(p,q)
-        return self.result
-    
-    def check(self, p, q):
-        # if :
-        if (not p or not q)  or (p.val != q.val)  :
-            self.result = False
-            return 
-
-        if p.left or q.left:
-            self.check(p.left, q.left)
-        if p.right or q.right:
-            self.check(p.right, q.right)
-        
-        return
\ No newline at end of file
+        if not p:
+            return not q
+        if not q:
+            return not p
+        return p.val == q.val and self.isSameTree(p.left, q.left) and self.isSameTree(p.right, q.right)
\ No newline at end of file
diff --git "a/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/0101-\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.py" "b/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/0101-\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.py"
index 7170990..1ae0835 100644
--- "a/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/0101-\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.py"
+++ "b/0101.\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221/0101-\345\257\271\347\247\260\344\272\214\345\217\211\346\240\221.py"
@@ -11,23 +11,11 @@ def isSymmetric(self, root):
         :type root: TreeNode
         :rtype: bool
         """
+        def helper(node1, node2):
+            if not node1:
+                return not node2
+            if not node2:
+                return not node1
+            return node1.val == node2.val and helper(node1.left, node2.right) and helper(node1.right, node2.left)
         
-        queue = [root]
-        
-        while(queue):
-            next_queue = list()
-            layer = list()
-            for node in queue:
-                if not node:
-                    layer.append(None)
-                    continue
-                next_queue.append(node.left)
-                next_queue.append(node.right)
-                
-                layer.append(node.val)
-                
-            if layer != layer[::-1]:
-                return False
-            queue = next_queue
-            
-        return True
\ No newline at end of file
+        return helper(root, root)
\ No newline at end of file
diff --git "a/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206/0102-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.py" "b/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206/0102-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.py"
index bee34dd..30d1829 100644
--- "a/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206/0102-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.py"
+++ "b/0102.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206/0102-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206.py"
@@ -11,25 +11,18 @@ def levelOrder(self, root):
         :type root: TreeNode
         :rtype: List[List[int]]
         """
-        if not root:
-            return []
         queue = [root]
-        res = list()
+        res = []
         while queue:
-            nextqueue = list()
-            layer = list()
+            next_queue = []
+            layer = []
             for node in queue:
-                if node.left:
-                    nextqueue.append(node.left)
-                if node.right:
-                    nextqueue.append(node.right)
-                layer.append(node.val)
-                
-            queue = nextqueue[:]
-            res.append(layer)
+                if node:
+                    layer.append(node.val)
+                    next_queue += [node.left, node.right]
+            queue = next_queue[:]
+            if layer:
+                res.append(layer[:])
         return res
-        
-        
-        
-        
-    
\ No newline at end of file
+                              
+        
\ No newline at end of file
diff --git "a/0103.\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206/0103-\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206.py" "b/0103.\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206/0103-\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206.py"
index 7062c15..68cd10f 100644
--- "a/0103.\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206/0103-\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206.py"
+++ "b/0103.\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206/0103-\344\272\214\345\217\211\346\240\221\347\232\204\351\224\257\351\275\277\345\275\242\345\261\202\346\254\241\351\201\215\345\216\206.py"
@@ -11,28 +11,21 @@ def zigzagLevelOrder(self, root):
         :type root: TreeNode
         :rtype: List[List[int]]
         """
+        reverse = 0
         queue = [root]
-        lor = 0 # 0 for left and 1 for right
-        res = list()
-        if not root:
-            return []
-        while(queue):
-            next_queue = list()
-            layer = list()
-            
+        res = []
+        while queue:
+            next_queue = []
+            layer = []
             for node in queue:
-                if node.left:
-                    next_queue.append(node.left)
-                if node.right:
-                    next_queue.append(node.right)
-                
-                layer.append(node.val)
-
-            if not lor: # left
-                res.append(layer)
-            else:
-                res.append(layer[::-1])
-            
-            lor = 1 - lor
-            queue = next_queue
+                if node:
+                    layer.append(node.val)
+                    next_queue += [node.left, node.right]
+            queue = next_queue[:]
+            if layer:
+                if not reverse:
+                    res.append(layer[:])
+                else:
+                    res.append(layer[::-1])
+                reverse = 1 - reverse
         return res
\ No newline at end of file
diff --git "a/0104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/0104-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.py" "b/0104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/0104-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.py"
new file mode 100644
index 0000000..e3b62e7
--- /dev/null
+++ "b/0104.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246/0104-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\244\247\346\267\261\345\272\246.py"
@@ -0,0 +1,16 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
+class Solution(object):
+    def maxDepth(self, root):
+        """
+        :type root: TreeNode
+        :rtype: int
+        """
+        if not root:
+            return 0
+        return 1 + max(self.maxDepth(root.left), self.maxDepth(root.right))
\ No newline at end of file
diff --git "a/0105.\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0105-\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py" "b/0105.\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0105-\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
index f372ec4..c386175 100644
--- "a/0105.\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0105-\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
+++ "b/0105.\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0105-\344\273\216\345\211\215\345\272\217\344\270\216\344\270\255\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
@@ -14,16 +14,18 @@ def buildTree(self, preorder, inorder):
         """
         if not preorder:
             return None
+        root_val = preorder[0]
+        root_idx = inorder.index(root_val)
         
-        root = TreeNode(preorder[0])        
-        left_inorder = inorder[: inorder.index(root.val)]
-        right_inorder = inorder[inorder.index(root.val) + 1 :]
+        preorder_left = preorder[1:1 + root_idx]
+        preorder_right = preorder[root_idx + 1:]
         
-        l_left = len(left_inorder)
-        left_preorder = preorder[1:l_left + 1]
-        right_preorder = preorder[l_left + 1 :]
+        inorder_left = inorder[:root_idx]
+        inorder_right = inorder[root_idx + 1:]
         
-        root.left = self.buildTree(left_preorder, left_inorder)
-        root.right = self.buildTree(right_preorder, right_inorder)
+        # print preorder_left, preorder_right, inorder_left, inorder_right
+        root = TreeNode(root_val)
+        root.left = self.buildTree(preorder_left, inorder_left)
+        root.right = self.buildTree(preorder_right, inorder_right)
         
         return root
\ No newline at end of file
diff --git "a/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0106-\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py" "b/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0106-\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
index e638c0f..d20caa6 100644
--- "a/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0106-\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
+++ "b/0106.\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221/0106-\344\273\216\344\270\255\345\272\217\344\270\216\345\220\216\345\272\217\351\201\215\345\216\206\345\272\217\345\210\227\346\236\204\351\200\240\344\272\214\345\217\211\346\240\221.py"
@@ -12,22 +12,20 @@ def buildTree(self, inorder, postorder):
         :type postorder: List[int]
         :rtype: TreeNode
         """
-        if not postorder:
+        if not inorder:
             return None
+        root_val = postorder[-1]
+        root_idx = inorder.index(root_val)
         
-        root = TreeNode(postorder[-1])
+        postorder_left = postorder[:root_idx]
+        postorder_right = postorder[root_idx:-1]
         
-        root_index = inorder.index(postorder[-1])
+        inorder_left = inorder[:root_idx]
+        inorder_right = inorder[root_idx + 1:]
         
-        left_inorder = inorder[:root_index]
-        right_inorder = inorder[root_index + 1:]
-        
-        l_left = len(left_inorder)
-        
-        left_postorder = postorder[:l_left]
-        right_postorder = postorder[l_left : -1]
-        
-        root.left = self.buildTree(left_inorder, left_postorder)
-        root.right = self.buildTree(right_inorder, right_postorder)
+        # print preorder_left, preorder_right, inorder_left, inorder_right
+        root = TreeNode(root_val)
+        root.left = self.buildTree(inorder_left, postorder_left)
+        root.right = self.buildTree(inorder_right, postorder_right)
         
         return root
\ No newline at end of file
diff --git "a/0107.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II/0107-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II.py" "b/0107.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II/0107-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II.py"
index dac2a0e..35c90e7 100644
--- "a/0107.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II/0107-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II.py"
+++ "b/0107.\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II/0107-\344\272\214\345\217\211\346\240\221\347\232\204\345\261\202\346\254\241\351\201\215\345\216\206II.py"
@@ -11,30 +11,16 @@ def levelOrderBottom(self, root):
         :type root: TreeNode
         :rtype: List[List[int]]
         """
-        # Definition for a binary tree node.
-
-        if not root:
-            return []
-        node = [root]
-        node_val = list(list())
-        self.generate(node, node_val)
-        return node_val[::-1]
-    
-    def generate(self, node, node_val):
-        new_node = []
-        new_node_val = []
-        for node in node:
-            if node.left:
-                new_node.append(node.left)
-            if node.right:
-                new_node.append(node.right)
-            new_node_val.append(node.val)
-        node_val.append(new_node_val)
-        if len(new_node) == 0:
-            return
-        self.generate(new_node, node_val)
-        
-        
-        
-        
-    
\ No newline at end of file
+        queue = [root]
+        res = []
+        while queue:
+            next_queue = []
+            layer = []
+            for node in queue:
+                if node:
+                    layer.append(node.val)
+                    next_queue += [node.left, node.right]
+            queue = next_queue[:]
+            if layer:
+                res.append(layer[:])
+        return res[::-1]
\ No newline at end of file
diff --git "a/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0108-\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py" "b/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0108-\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
index 3c4a0e8..0a3ba57 100644
--- "a/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0108-\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
+++ "b/0108.\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0108-\345\260\206\346\234\211\345\272\217\346\225\260\347\273\204\350\275\254\346\215\242\344\270\272\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
@@ -13,17 +13,8 @@ def sortedArrayToBST(self, nums):
         """
         if not nums:
             return None
-             
-        def dfs(start, end):
-            if end < start:
-                return 
-            
-            mid = (end + start) // 2
-            root = TreeNode(nums[mid])
-            
-            root.left = dfs(start, mid - 1)
-            root.right = dfs(mid + 1, end)
-            
-            return root
-
-        return dfs(0, len(nums) - 1)
\ No newline at end of file
+        l = len(nums)
+        root = TreeNode(nums[l // 2])
+        root.left = self.sortedArrayToBST(nums[:l//2])
+        root.right = self.sortedArrayToBST(nums[l//2 + 1:])
+        return root
\ No newline at end of file
diff --git "a/0109.\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0109-\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py" "b/0109.\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0109-\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
index 1053d00..2d2a03a 100644
--- "a/0109.\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0109-\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
+++ "b/0109.\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221/0109-\346\234\211\345\272\217\351\223\276\350\241\250\350\275\254\346\215\242\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221.py"
@@ -18,31 +18,22 @@ def sortedListToBST(self, head):
         :rtype: TreeNode
         """
         if not head:
-            return head
-        l = list()
-        while(head):
-            l.append(head.val)
-            head = head.next
-        
-        def sortedArrayToBST(nums):
-            if not nums:
-                return None
-
-            def dfs(start, end):
-                if end < start:
-                    return 
-
-                mid = (end + start) // 2
-                root = TreeNode(nums[mid])
-
-                root.left = dfs(start, mid - 1)
-                root.right = dfs(mid + 1, end)
-
-                return root
-
-            return dfs(0, len(nums) - 1)
-        
-        return sortedArrayToBST(l)
-            
+            return None
+        if not head.next:
+            return TreeNode(head.val)
+        slow, fast = head, head
+        pre = head
+        while fast and fast.next:        
+            pre = slow
+            slow = slow.next
+            fast = fast.next.next
+            # print slow.val, fast.val, pre.val
+        pre.next = None
+        part1 = head
+        part2 = slow.next
         
+        root = TreeNode(slow.val)
+        root.left = self.sortedListToBST(part1)
+        root.right = self.sortedListToBST(part2)
+        return root
         
\ No newline at end of file
diff --git "a/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/0110-\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py" "b/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/0110-\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py"
index 466e681..e2996bf 100644
--- "a/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/0110-\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py"
+++ "b/0110.\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221/0110-\345\271\263\350\241\241\344\272\214\345\217\211\346\240\221.py"
@@ -1,18 +1,23 @@
+# Definition for a binary tree node.
+# class TreeNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.left = None
+#         self.right = None
+
 class Solution(object):
     def isBalanced(self, root):
+        """
+        :type root: TreeNode
+        :rtype: bool
+        """
         if not root:
             return True
+        if not root.left and not root.right:
+            return True
         
-        def check(root,height):
-            if not root:
-                return True,height
-            
-            tag1,height1=check(root.left,height+1)
-            tag2,height2=check(root.right,height+1)
-            if tag1 and tag2 and abs(height1-height2)<2:
-                return True,max(height1,height2)
-            else:
-                return False,height1
-            
-        tag,height=check(root,0)
-        return tag  
\ No newline at end of file
+        def getHeight(node, h):
+            if not node:
+                return h
+            return max(getHeight(node.left, h + 1), getHeight(node.right, h + 1))
+        return self.isBalanced(root.left) and self.isBalanced(root.right) and abs(getHeight(root.left, 0) - getHeight(root.right, 0)) <= 1
\ No newline at end of file
diff --git "a/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/0111-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.py" "b/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/0111-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.py"
index 633069e..15bab42 100644
--- "a/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/0111-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.py"
+++ "b/0111.\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246/0111-\344\272\214\345\217\211\346\240\221\347\232\204\346\234\200\345\260\217\346\267\261\345\272\246.py"
@@ -11,16 +11,13 @@ def minDepth(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        if root:
-            if root.left and root.right:
-                return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
-            if root.left:
-                return 1 + self.minDepth(root.left)
-            if root.right:
-                return 1 + self.minDepth(root.right)
-            else:
-                return 1
-        else:
+        if not root:
             return 0
-        
-        
\ No newline at end of file
+        if not root.left and not root.right:
+            return 1
+        elif not root.left:
+            return 1 + self.minDepth(root.right)
+        elif not root.right:
+            return 1 + self.minDepth(root.left)
+        else:
+            return 1 + min(self.minDepth(root.left), self.minDepth(root.right))
\ No newline at end of file
diff --git "a/0112.\350\267\257\345\276\204\346\200\273\345\222\214/0112-\350\267\257\345\276\204\346\200\273\345\222\214.py" "b/0112.\350\267\257\345\276\204\346\200\273\345\222\214/0112-\350\267\257\345\276\204\346\200\273\345\222\214.py"
index 88c3cff..ce9a472 100644
--- "a/0112.\350\267\257\345\276\204\346\200\273\345\222\214/0112-\350\267\257\345\276\204\346\200\273\345\222\214.py"
+++ "b/0112.\350\267\257\345\276\204\346\200\273\345\222\214/0112-\350\267\257\345\276\204\346\200\273\345\222\214.py"
@@ -6,28 +6,14 @@
 #         self.right = None
 
 class Solution(object):
-    def hasPathSum(self, root, s):
+    def hasPathSum(self, root, sum):
         """
         :type root: TreeNode
         :type sum: int
         :rtype: bool
         """
-        self.res = False
-        
-        def dfs(node, tmp):
-            if not node:
-                return 
-            
-            tmp.append(node.val)
-            if not node.left and not node.right and sum(tmp) == s:
-                self.res = True
-            
-            dfs(node.left, tmp)
-            dfs(node.right, tmp)
-            tmp.pop()
-        
-        
-        dfs(root, list())
-        return self.res
-            
-        
\ No newline at end of file
+        if not root:
+            return False
+        if not root.left and not root.right:
+            return root.val == sum
+        return self.hasPathSum(root.left, sum - root.val) or self.hasPathSum(root.right, sum - root.val)
\ No newline at end of file
diff --git "a/0113.\350\267\257\345\276\204\346\200\273\345\222\214II/0113-\350\267\257\345\276\204\346\200\273\345\222\214II.py" "b/0113.\350\267\257\345\276\204\346\200\273\345\222\214II/0113-\350\267\257\345\276\204\346\200\273\345\222\214II.py"
index fa7f356..b03107d 100644
--- "a/0113.\350\267\257\345\276\204\346\200\273\345\222\214II/0113-\350\267\257\345\276\204\346\200\273\345\222\214II.py"
+++ "b/0113.\350\267\257\345\276\204\346\200\273\345\222\214II/0113-\350\267\257\345\276\204\346\200\273\345\222\214II.py"
@@ -12,19 +12,19 @@ def pathSum(self, root, s):
         :type sum: int
         :rtype: List[List[int]]
         """
-        res = list()
-        
-        def dfs(node, tmp):
+        res = []
+        def dfs(node, path):
             if not node:
-                return 
+                return
             
-            tmp.append(node.val) 
-            if not node.left and not node.right and sum(tmp) == s:
-                res.append(tmp[:])
+            path += [node.val]
+            if not node.left and not node.right and sum(path) == s:
+                res.append(path[:])
+                
+            dfs(node.left, path)
+            dfs(node.right, path)
             
-            dfs(node.left, tmp)
-            dfs(node.right, tmp)
-            tmp.pop()
+            path.pop()
             
-        dfs(root, list())        
+        dfs(root, [])
         return res
\ No newline at end of file
diff --git "a/0114.\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/0114-\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.py" "b/0114.\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/0114-\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.py"
index 4f6227f..ffd37d4 100644
--- "a/0114.\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/0114-\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.py"
+++ "b/0114.\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250/0114-\344\272\214\345\217\211\346\240\221\345\261\225\345\274\200\344\270\272\351\223\276\350\241\250.py"
@@ -11,19 +11,17 @@ def flatten(self, root):
         :type root: TreeNode
         :rtype: None Do not return anything, modify root in-place instead.
         """
-        
-        if not root or (not root.left and not root.right):
+        if not root:
+            return None
+        if not root.left and not root.right:
             return root
         
-        #先把左右子树捋直
         self.flatten(root.left)
         self.flatten(root.right)
-        
-        tmp = root.right #把捋直的右子树备份一下
-        
-        root.right = root.left #把捋直的左子树放到右边
-        root.left = None #记得把左子树置空
-        while(root.right): #找到现在右子树的最后一个node
-            root = root.right
-        root.right = tmp #把捋直的原来的右子树接上去
-        
\ No newline at end of file
+        ltree, rtree = root.left, root.right
+        root.right = ltree
+        root.left = None
+        p = root
+        while p.right:
+            p = p.right
+        p.right = rtree
\ No newline at end of file
diff --git "a/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/0116-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.py" "b/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/0116-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.py"
index 2c89464..2ec9db4 100644
--- "a/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/0116-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.py"
+++ "b/0116.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210/0116-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210.py"
@@ -13,20 +13,28 @@ def connect(self, root):
         :type root: Node
         :rtype: Node
         """
-        #先排除掉不需要处理的情况
-        if not root or (not root.left and not root.right):
-            return root
-        
-        #某一个节点的左孩子的next一定是指向这个节点的右孩子
-        root.left.next = root.right
-        
-        #当某一个节点的next不为空的时候，这个节点的右孩子的next一定是指向该节点next的left
-        if root.next:
-            root.right.next = root.next.left
-        
-        #递归处理下一层
+        if not root:
+            return
+        wait = None
+        if root.left and root.right:
+            root.left.next = root.right
+            wait = root.right
+        elif root.left:
+            wait = root.left
+        elif root.right:
+            wait = root.right
+            
+        p = root.next
+        while p:
+            if p.left:
+                wait.next = p.left
+                break
+            elif p.right:
+                wait.next = p.right
+                break
+            else:
+                p = p.next
+
         self.connect(root.left)
         self.connect(root.right)
-  
-        return root
-                
\ No newline at end of file
+        return root   
\ No newline at end of file
diff --git "a/0117.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II/0117-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II.py" "b/0117.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II/0117-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II.py"
index caa2621..3cf5013 100644
--- "a/0117.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II/0117-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II.py"
+++ "b/0117.\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II/0117-\345\241\253\345\205\205\346\257\217\344\270\252\350\212\202\347\202\271\347\232\204\344\270\213\344\270\200\344\270\252\345\217\263\344\276\247\350\212\202\347\202\271\346\214\207\351\222\210II.py"
@@ -1,37 +1,42 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val, left, right, next):
+        self.val = val
+        self.left = left
+        self.right = right
+        self.next = next
+"""
 class Solution(object):
     def connect(self, root):
         """
         :type root: Node
         :rtype: Node
         """
-        if not root or (not root.left and not root.right):
-            return root
-        
-        def findCousin(node, parent):
-            tmp = parent.next
-            while(tmp):
-                if tmp.left:
-                    node.next = tmp.left
-                    break
-                    
-                elif tmp.right:
-                    node.next = tmp.right
-                    break
-                tmp = tmp.next
-                
+        if not root:
+            return
+        wait = None
         if root.left and root.right:
             root.left.next = root.right
-            findCousin(root.right, root)
-            
+            wait = root.right
         elif root.left:
-            findCousin(root.left, root)
-            
+            wait = root.left
         elif root.right:
-            findCousin(root.right, root)
-        
-        # print root.val, root.right.next
+            wait = root.right
+        else:
+            return root
+        p = root.next
+        while p:
+            if p.left:
+                wait.next = p.left
+                break
+            elif p.right:
+                wait.next = p.right
+                break
+            else:
+                p = p.next
+
+       
         self.connect(root.right)
         self.connect(root.left)
-        
-                
-        return root
\ No newline at end of file
+        return root 
\ No newline at end of file
diff --git "a/0118.\346\235\250\350\276\211\344\270\211\350\247\222/0118-\346\235\250\350\276\211\344\270\211\350\247\222.py" "b/0118.\346\235\250\350\276\211\344\270\211\350\247\222/0118-\346\235\250\350\276\211\344\270\211\350\247\222.py"
new file mode 100644
index 0000000..c451287
--- /dev/null
+++ "b/0118.\346\235\250\350\276\211\344\270\211\350\247\222/0118-\346\235\250\350\276\211\344\270\211\350\247\222.py"
@@ -0,0 +1,16 @@
+class Solution(object):
+    def generate(self, numRows):
+        """
+        :type numRows: int
+        :rtype: List[List[int]]
+        """
+        if not numRows:
+            return []
+        res = [[1]]
+        for i in range(1, numRows):
+            tmp = [1]
+            for j in range(1, i):
+                tmp.append(res[i-1][j - 1] + res[i - 1][j])
+            tmp.append(1)
+            res.append(tmp[:])
+        return res
\ No newline at end of file
diff --git "a/0119.\346\235\250\350\276\211\344\270\211\350\247\222II/0119-\346\235\250\350\276\211\344\270\211\350\247\222II.py" "b/0119.\346\235\250\350\276\211\344\270\211\350\247\222II/0119-\346\235\250\350\276\211\344\270\211\350\247\222II.py"
index c6f0f9e..fcf14ac 100644
--- "a/0119.\346\235\250\350\276\211\344\270\211\350\247\222II/0119-\346\235\250\350\276\211\344\270\211\350\247\222II.py"
+++ "b/0119.\346\235\250\350\276\211\344\270\211\350\247\222II/0119-\346\235\250\350\276\211\344\270\211\350\247\222II.py"
@@ -4,23 +4,13 @@ def getRow(self, rowIndex):
         :type rowIndex: int
         :rtype: List[int]
         """
-        # C(n - 1，m - 1)
-        n = rowIndex
-        m = n + 1
-        def Calculate(n, m):
-            down = 1
-            up = 1
-            for i in range(1, m):
-                down *= i
-                
-            for i in range(1, m):
-                up *= (n + 1 -i)
-                
-            return up // down
-            
-        res = list()
-        for i in range(1, m + 1):
-            res.append(Calculate(n, i))
-        
-        
-        return res
\ No newline at end of file
+        if not rowIndex:
+            return [1]
+        res = [[1]]
+        for i in range(1, rowIndex + 1):
+            tmp = [1]
+            for j in range(1, i):
+                tmp.append(res[j - 1] + res[j])
+            tmp.append(1)
+            res = tmp[:]
+        return res     
\ No newline at end of file
diff --git "a/0120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0120-\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py" "b/0120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0120-\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
index 712bce6..7086ac2 100644
--- "a/0120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0120-\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
+++ "b/0120.\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214/0120-\344\270\211\350\247\222\345\275\242\346\234\200\345\260\217\350\267\257\345\276\204\345\222\214.py"
@@ -4,12 +4,13 @@ def minimumTotal(self, triangle):
         :type triangle: List[List[int]]
         :rtype: int
         """
-        dp= triangle[-1]
-        
-        for i in range(len(triangle) - 2, -1, -1):
-            for j in range(i + 1):
-                dp[j] = triangle[i][j] + min(dp[j], dp[j + 1])
-                
-        return dp[0]
-        
-        
\ No newline at end of file
+        if not triangle or not triangle[0]:
+            return 0
+        dp = triangle[:]
+        for i in range(1, len(dp)):
+            dp[i][0] += dp[i - 1][0]
+            for j in range(1, len(dp[i]) - 1):
+                dp[i][j] += min(dp[i - 1][j - 1], dp[i - 1][j])
+            dp[i][-1] += dp[i - 1][-1]
+            
+        return min(dp[-1]) 
\ No newline at end of file
diff --git "a/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/0121-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.py" "b/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/0121-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.py"
index 9134a56..8b19676 100644
--- "a/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/0121-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.py"
+++ "b/0121.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272/0121-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272.py"
@@ -4,11 +4,24 @@ def maxProfit(self, prices):
         :type prices: List[int]
         :rtype: int
         """
-        # if not prices:
-        #     return 0
-        minelement = 2 << 31
-        profit = 0
-        for i in range(len(prices)):
-            minelement = min(minelement, prices[i])
-            profit = max(profit, prices[i] - minelement)
-        return profit
\ No newline at end of file
+#         dp[i][k][0] = max(dp[i – 1][k][0], dp[I – 1][k][1] + prices[i])
+#         dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k][0] - prices[i])
+#         第一题 k = 1
+
+#         dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+#         dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
+
+#         当i = 0时，
+#         dp[0][0] = 0
+#         dp[0][1] = -prices[0]
+        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
+        for i, price in enumerate(prices):
+            if i == 0:
+                dp[0][0] = 0
+                dp[0][1] = -price
+            else:
+                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+                dp[i][1] = max(dp[i - 1][1],  - prices[i])
+                
+        return dp[len(prices) - 1][0] if prices else 0
+            
\ No newline at end of file
diff --git "a/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II/0122-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.py" "b/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II/0122-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.py"
index e0eafaf..c52418d 100644
--- "a/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II/0122-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.py"
+++ "b/0122.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II/0122-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272II.py"
@@ -4,9 +4,13 @@ def maxProfit(self, prices):
         :type prices: List[int]
         :rtype: int
         """
-        sum = 0
-        for i in range(1,len(prices)):
-            if prices[i] > prices[i-1]:
-                profit = prices[i] - prices[i-1]
-                sum += profit
-        return sum
\ No newline at end of file
+        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
+        for i, price in enumerate(prices):
+            if i == 0:
+                dp[0][0] = 0
+                dp[0][1] = -price
+            else:
+                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+                dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
+                
+        return dp[len(prices) - 1][0] if prices else 0
\ No newline at end of file
diff --git "a/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III/0123-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.py" "b/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III/0123-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.py"
new file mode 100644
index 0000000..1761b27
--- /dev/null
+++ "b/0123.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III/0123-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272III.py"
@@ -0,0 +1,21 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+
+        max_k = 2
+        n = len(prices)
+        dp = [[[0 for _ in range(2)] for _ in range(max_k + 1)] for _ in range(n)]
+        
+        for i, price in enumerate(prices):
+            for k in range(max_k, 0, -1):
+                if i == 0:
+                    dp[0][k][0] = 0
+                    dp[0][k][1] = -price
+                else:
+                    dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i])
+                    dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i])
+                
+        return dp[n - 1][max_k][0] if prices else 0
\ No newline at end of file
diff --git "a/0125.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/0125-\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.py" "b/0125.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/0125-\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.py"
index d9f3a41..ff3a1f2 100644
--- "a/0125.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/0125-\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.py"
+++ "b/0125.\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262/0125-\351\252\214\350\257\201\345\233\236\346\226\207\344\270\262.py"
@@ -4,20 +4,9 @@ def isPalindrome(self, s):
         :type s: str
         :rtype: bool
         """
-        s = s.lower()
-        ss = ""
-        for i in s:
-            if i.isalpha() != True and i.isdigit() != True:
-                print i
-                continue
-            ss += i
-        # print ss
-        if len(ss) <= 1:
-            return True
-        for i in range(0,len(ss)):
-            # print ss[i]
-            if ss[i] != ss[-i-1]:
-                return False
-        return True
-                
-        
\ No newline at end of file
+        tmp = ""
+        for char in s.lower():
+            if char.isalpha() or char.isdigit():
+                tmp += char
+        print tmp
+        return tmp == tmp[::-1]
\ No newline at end of file
diff --git "a/0126.\345\215\225\350\257\215\346\216\245\351\276\231II/0126-\345\215\225\350\257\215\346\216\245\351\276\231II.py" "b/0126.\345\215\225\350\257\215\346\216\245\351\276\231II/0126-\345\215\225\350\257\215\346\216\245\351\276\231II.py"
new file mode 100644
index 0000000..1697649
--- /dev/null
+++ "b/0126.\345\215\225\350\257\215\346\216\245\351\276\231II/0126-\345\215\225\350\257\215\346\216\245\351\276\231II.py"
@@ -0,0 +1,113 @@
+class Solution(object):
+    def findLadders(self, beginWord, endWord, wordList):
+        """
+        :type beginWord: str
+        :type endWord: str
+        :type wordList: List[str]
+        :rtype: List[List[str]]
+        """
+        from collections import defaultdict, deque
+        if endWord not in wordList:
+            return []
+        wordList = set(wordList)
+        wordList.add(beginWord)
+        
+        record = defaultdict(set)
+        flag, forward, backward = True, {beginWord}, {endWord}
+        while forward:
+            if len(forward) > len(backward):
+                flag, forward, backward = not flag, backward, forward
+            
+            wordList -= forward
+            next_level = set()
+            for word in forward:
+                for i in range(len(word)):
+                    for k in range(26):
+                        tmp = word[:i] + chr(ord("a") + k) + word[i + 1:]
+                        
+                        if tmp in wordList:
+                            next_level.add(tmp)
+                            if flag:
+                                record[tmp].add(word)
+                            else:
+                                record[word].add(tmp)
+                                
+            if next_level & backward:#有交集说明找到了
+                res = [[endWord]]
+                while res[0][0] != beginWord:
+                    res = [[x] + y for y in res for x in record[y[0]]]
+                return res
+            # res += 1
+            forward = next_level
+        return []      
+                        
+        return 0
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        
+        for word in wordList:
+            wl.add(word)
+            
+        record = defaultdict(list)
+        queue = deque()
+        queue.append(endWord)
+        # wl.remove(endWord)
+        def bfs(queue):
+            if not queue:
+                return 
+            next_queue = deque()
+            while queue:
+                cur = queue.popleft()
+                print wl, cur
+                
+                for i in range(len(cur)):
+                    for k in range(26):
+                        tmp = cur[:i] + chr(ord("a") + k) + cur[i + 1:]
+
+                        if tmp != cur and tmp in wl and tmp not in record[cur]:
+                            
+                            next_queue.append(tmp)
+                            record[cur].append(tmp)
+                wl.remove(cur)
+        
+            bfs(next_queue)
+
+        bfs(queue)
+        print record
+        self.min_length = 2 ** 32 - 1
+        self.res = []
+        
+        def dfs(bW, eW, path):
+            if len(path) > self.min_length:
+                return
+            print path, eW, record[eW]
+            if bW == eW:
+                # if len(path) + 1 < self.min_length:
+                #     self.res = [[eW] + path ]
+                #     self.min_length = len(path) + 1
+                # elif len(path) + 1 == self.min_length:
+                self.res.append([eW] + path )
+                return
+
+            for pre_node in record[eW]:
+                if pre_node not in visited:
+                    visited.add(pre_node)
+                    dfs(bW, pre_node, [eW] + path )
+                    visited.remove(pre_node)
+                
+        visited = set()
+        visited.add(endWord)
+        dfs(beginWord, endWord, [])
+        return self.res
+                            
\ No newline at end of file
diff --git "a/0127.\345\215\225\350\257\215\346\216\245\351\276\231/0127-\345\215\225\350\257\215\346\216\245\351\276\231.py" "b/0127.\345\215\225\350\257\215\346\216\245\351\276\231/0127-\345\215\225\350\257\215\346\216\245\351\276\231.py"
index fb2fa0b..42405ae 100644
--- "a/0127.\345\215\225\350\257\215\346\216\245\351\276\231/0127-\345\215\225\350\257\215\346\216\245\351\276\231.py"
+++ "b/0127.\345\215\225\350\257\215\346\216\245\351\276\231/0127-\345\215\225\350\257\215\346\216\245\351\276\231.py"
@@ -1,4 +1,3 @@
-from collections import deque
 class Solution(object):
     def ladderLength(self, beginWord, endWord, wordList):
         """
@@ -7,27 +6,29 @@ def ladderLength(self, beginWord, endWord, wordList):
         :type wordList: List[str]
         :rtype: int
         """
-        if endWord not in wordList or beginWord == endWord:
+        from collections import deque
+        if endWord not in wordList:
             return 0
-        visited = set()
-        wordList = set(wordList)
+        wordList = set(wordList) #必备优化，不然超时
         
-        q = deque()
-        q.append([beginWord, 0])
-        
-        char = "abcdefghijklmnopqrstuvwxyz"
-        while q:
-            cur, cnt = q.popleft() #从队列里取一个出来
-            if cur == endWord: #如果刚好找到了
-                return cnt + 1
-               
-            for i in range(len(cur)):
-                for j in range(26):
-                    word = cur[:i] + char[j] + cur[i + 1:] #把26种变换可能都生成
-                    if word in wordList and word not in visited: #判断变换有没有效
-                        visited.add(word)
-                        q.append([word, cnt + 1])
-                    
-        return 0
-                    
-            
\ No newline at end of file
+        res, forward, backward = 2, {beginWord}, {endWord}
+        while forward:
+            if len(forward) > len(backward):
+                forward, backward = backward, forward
+                
+            next_level = set()
+            for word in forward:
+                for i in range(len(word)):
+                    for k in range(26):
+                        tmp = word[:i] + chr(ord("a") + k) + word[i + 1:]
+                        
+                        if tmp in backward: #找到了
+                            return res
+                        if tmp in wordList:
+                            next_level.add(tmp)
+                            wordList.remove(tmp)
+            res += 1
+            forward = next_level
+                            
+                        
+        return 0
\ No newline at end of file
diff --git "a/0128.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/0128-\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.py" "b/0128.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/0128-\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.py"
new file mode 100644
index 0000000..fe318e8
--- /dev/null
+++ "b/0128.\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227/0128-\346\234\200\351\225\277\350\277\236\347\273\255\345\272\217\345\210\227.py"
@@ -0,0 +1,21 @@
+class Solution(object):
+    def longestConsecutive(self, nums):
+        """
+        :type nums: List[int]
+        :rtype: int
+        """
+        record = dict()
+        res = 0
+        for num in nums:
+            if num not in record:
+                left = record.get(num - 1, 0)
+                right = record.get(num + 1, 0)
+                
+                length = right + left + 1
+                
+                res = max(res, length)
+                
+                for i in [num - left, num, num + right]:
+                    record[i] = length
+                    
+        return res
\ No newline at end of file
diff --git "a/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/0129-\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.py" "b/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/0129-\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.py"
index 79084aa..57e33c4 100644
--- "a/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/0129-\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.py"
+++ "b/0129.\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214/0129-\346\261\202\346\240\271\345\210\260\345\217\266\345\255\220\350\212\202\347\202\271\346\225\260\345\255\227\344\271\213\345\222\214.py"
@@ -15,15 +15,16 @@ def sumNumbers(self, root):
         
         def dfs(node, tmp):
             if not node:
-                return 
+                return
             
             tmp = tmp * 10 + node.val
             if not node.left and not node.right:
                 self.res += tmp
+                return
             
             dfs(node.left, tmp)
             dfs(node.right, tmp)
-            # tmp /= 10
-                        
-        dfs(root, 0)
+            # tmp -= node.val
+            
+        dfs(root, 0)   
         return self.res
\ No newline at end of file
diff --git "a/0130.\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/0130-\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237.py" "b/0130.\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/0130-\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237.py"
index 1e29183..ee15145 100644
--- "a/0130.\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/0130-\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237.py"
+++ "b/0130.\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237/0130-\350\242\253\345\233\264\347\273\225\347\232\204\345\214\272\345\237\237.py"
@@ -1,95 +1,44 @@
-class UnionFindSet(object):
-    def __init__(self, grid):
-
-        m, n = len(grid), len(grid[0])
-        self.roots = [i for i in range(m * n)]
-        self.rank = [0 for i in range(m * n)]
-        self.count = n
-        
-        for i in range(m):
-            for j in range(n):
-                self.roots[i *n + j] = i * n +j
-
-    def find(self, member):
-        tmp = []
-        while member != self.roots[member]:
-            tmp.append(member)
-            member = self.roots[member]
-        for root in tmp:
-            self.roots[root] = member
-        return member
-        
-    def union(self, p, q):
-        parentP = self.find(p)
-        parentQ = self.find(q)
-        if parentP != parentQ:
-            if self.rank[parentP] > self.rank[parentQ]:
-                self.roots[parentQ] = parentP
-            elif self.rank[parentP] < self.rank[parentQ]:
-                self.roots[parentP] = parentQ
-            else:
-                self.roots[parentQ] = parentP
-                self.rank[parentP] -= 1
-            self.count -= 1
-
 class Solution(object):
     def solve(self, board):
         """
         :type board: List[List[str]]
         :rtype: None Do not return anything, modify board in-place instead.
         """
+        #从四条边的O往里找相邻的O染色成P，到不了的O变成X， P染色回O
         
         if not board or not board[0]:
             return board
         
         m, n = len(board), len(board[0])
-
         dx = [1, -1, 0, 0]
         dy = [0, 0, 1, -1]
         
-        def dfs(x, y):
+        def dfs(x0, y0):
             for k in range(4):
-                xx = x + dx[k]
-                yy = y + dy[k]
- 
-                if xx >= 0 and xx < m and yy >= 0 and yy < n: #当前坐标有效
-                    if board[xx][yy] == "O":
-                        board[xx][yy] = "P" #给走过的点染色
-                        dfs(xx, yy)
-        #--------以下在从四周往里找相邻的所有点
-        i = 0
-        for j in range(n): #上边
-            if board[i][j] == "O":
-                board[i][j] = "P"
-                dfs(i, j)
- 
-        i = m - 1
-        for j in range(n): #下边
-            if board[i][j] == "O":
-                board[i][j] = "P"
-                dfs(i, j)    
-        j = 0        
-        for i in range(m): #左边
-            if board[i][j] == "O":
-                board[i][j] = "P"
-                dfs(i, j) 
- 
-        j = n - 1     
-        for i in range(m): #右边
-            if board[i][j] == "O":
-                board[i][j] = "P"
-                dfs(i, j) 
-        #--------以上在从四周往里找相邻的所有点
-        # print board
-        res = 0
-        for i in range(m):
+                x = x0 + dx[k]
+                y = y0 + dy[k]
+                
+                if 0 <= x < m and 0 <= y < n and board[x][y] == "O":
+                    board[x][y] = "P"
+                    dfs(x, y)
+        
+        
+        for i in [0, m - 1]:
             for j in range(n):
-                if board[i][j] == "P": #统计一下还有多少个没有去过的点
+                if board[i][j] == "O":
+                    board[i][j] = "P"
+                    dfs(i, j)
                     
-                    board[i][j] = "O"
-                elif board[i][j] == "O":
+        for j in [0, n - 1]:
+            for i in range(m):
+                 if board[i][j] == "O":
+                    board[i][j] = "P"
+                    dfs(i, j)
+                    
+        for i in range(m):
+            for j in range(n):
+                if board[i][j] == "O":
                     board[i][j] = "X"
-                        
-        return board
-                        
-                     
\ No newline at end of file
+                elif board[i][j] == "P":
+                    board[i][j] = "O"
+                    
\ No newline at end of file
diff --git "a/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II/0132-\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.py" "b/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II/0132-\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.py"
new file mode 100644
index 0000000..9faf5e5
--- /dev/null
+++ "b/0132.\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II/0132-\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262II.py"
@@ -0,0 +1,29 @@
+class Solution(object):
+    def minCut(self, s):
+        """
+        :type s: str
+        :rtype: int
+        """
+        if s == s[::-1]:
+            return 0
+        
+        for i in range(1, len(s) + 1):
+            if s[:i] == s[:i][::-1] and s[i:] == s[i:][::-1]:
+                return 1
+        
+        dp = [len(s) for i in range(len(s))]
+        for i in range(0, len(s)):
+            self.centeralExtend(s, i, i, dp)
+            self.centeralExtend(s, i, i+1, dp)
+        print dp
+        return dp[-1]
+    
+    def centeralExtend(self, string, left, right, dp):
+        while left >= 0 and right < len(string) and string[left] == string[right]:
+            if left > 0:
+                dp[right] = min(dp[right], dp[left - 1] + 1)
+            else:
+                dp[right] = 0
+            left -= 1
+            right += 1
+                
\ No newline at end of file
diff --git "a/0133.\345\205\213\351\232\206\345\233\276/0133-\345\205\213\351\232\206\345\233\276.py" "b/0133.\345\205\213\351\232\206\345\233\276/0133-\345\205\213\351\232\206\345\233\276.py"
index 5a8f4ee..ebffc5b 100644
--- "a/0133.\345\205\213\351\232\206\345\233\276/0133-\345\205\213\351\232\206\345\233\276.py"
+++ "b/0133.\345\205\213\351\232\206\345\233\276/0133-\345\205\213\351\232\206\345\233\276.py"
@@ -1,10 +1,3 @@
-"""
-# Definition for a Node.
-class Node(object):
-    def __init__(self, val, neighbors):
-        self.val = val
-        self.neighbors = neighbors
-"""
 class Solution(object):
     def cloneGraph(self, node):
         """
@@ -12,8 +5,9 @@ def cloneGraph(self, node):
         :rtype: Node
         """
         from collections import defaultdict, deque
-        record = defaultdict(list)
-        mapping = dict()
+        neighborList = defaultdict(list) #这个哈希表用于记录老结点和其邻居的关系, key是每个老结点，val是它的neighbors
+        mapping = dict() #这个哈希表用于记录老结点和它对应的新节点
+        
         def bfs(queue):
             if not queue:
                 return
@@ -21,44 +15,35 @@ def bfs(queue):
             
             while queue:
                 cur = queue.popleft()
-                mapping[cur] = Node(cur.val, [])
+                mapping[cur] = Node(cur.val, []) #为每个老结点创建一个对应的新节点
                 for nei in cur.neighbors:
-                    record[cur].append(nei)
+                    neighborList[cur].append(nei) #记录下当前老结点的所有邻居
                     if nei not in visited:
                         visited.add(nei)
                         newqueue.append(nei)
-            bfs(newqueue)
+            bfs(newqueue) #BFS找下一层
          
         visited = {node}           
         q = deque()
         q.append(node)
         bfs(q)
-        
-        # for key, val in record.items():
-        #     print key.val
-        #     for item in val:
-        #         print item.val
-        # print mapping
         visited = {node}
         
         def generate(queue):
             while queue:
                 newqueue = []
                 for node in queue:
-                    if node:
-                        # print node.val                    
-                        if not record[node]: #如果没有邻居
+                    if node:                
+                        if not neighborList[node]: #如果没有邻居
                             return
 
-                        for nei in record[node]: #处理每个邻居
-                            mapping[node].neighbors.append(mapping[nei])
+                        for nei in neighborList[node]: #处理每个邻居
+                            mapping[node].neighbors.append(mapping[nei]) #在新的结点标记【老结点的邻居对应的】新结点
                             if nei not in visited:
                                 visited.add(nei)
                                 newqueue.append(nei)
                 queue = newqueue[:]
-        q = deque()
-        q.append(node)
-        generate(q)
 
-        return mapping[node]
-                
\ No newline at end of file
+        generate([node])
+
+        return mapping[node] #返回输入结点对应的新节点
\ No newline at end of file
diff --git "a/0134.\345\212\240\346\262\271\347\253\231/0134-\345\212\240\346\262\271\347\253\231.py" "b/0134.\345\212\240\346\262\271\347\253\231/0134-\345\212\240\346\262\271\347\253\231.py"
index 8c202c5..471a152 100644
--- "a/0134.\345\212\240\346\262\271\347\253\231/0134-\345\212\240\346\262\271\347\253\231.py"
+++ "b/0134.\345\212\240\346\262\271\347\253\231/0134-\345\212\240\346\262\271\347\253\231.py"
@@ -5,17 +5,23 @@ def canCompleteCircuit(self, gas, cost):
         :type cost: List[int]
         :rtype: int
         """
-        if sum(gas) < sum(cost) or not len(gas):
-            return -1
-        l = len(gas)
-        sub = [gas[i] - cost[i] for i in range(l)]
-        
-        g = 0
-        index = 0
-        for i in range(l): #i是出发加油站的编号
-            g = g + sub[i]
-            if g < 0:
-                g = 0
-                index = i + 1
+        idx = 0
+        for i in range(len(gas)):
+            if i < idx:
+                continue
+            j = i
+            left_gas = gas[i]
+            while left_gas > 0:
+                # print j
+                if left_gas < cost[j]: #去不了下一站
+                    idx = max(idx, j)
+                    break
+                left_gas -= cost[j]
+                if (j + 1) % len(gas) == i:
+                    return i
                 
-        return index
+                j = (j + 1) % len(gas)
+                left_gas += gas[j]
+        return -1
+                
+            
\ No newline at end of file
diff --git "a/0136.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/0136-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227.py" "b/0136.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/0136-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227.py"
index 4e142b2..8c6a931 100644
--- "a/0136.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/0136-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227.py"
+++ "b/0136.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227/0136-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227.py"
@@ -4,10 +4,7 @@ def singleNumber(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        r = 0
-        for i in nums:
-            r ^= i
-        return r
-           
-        
-       
\ No newline at end of file
+        res = nums[0]
+        for i in range(1, len(nums)):
+            res ^= nums[i]
+        return res
\ No newline at end of file
diff --git "a/0137.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II/0137-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II.py" "b/0137.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II/0137-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II.py"
index bb3fbc2..3fdfbda 100644
--- "a/0137.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II/0137-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II.py"
+++ "b/0137.\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II/0137-\345\217\252\345\207\272\347\216\260\344\270\200\346\254\241\347\232\204\346\225\260\345\255\227II.py"
@@ -4,6 +4,4 @@ def singleNumber(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        for num in nums:
-            if nums.count(num) == 1:
-                return num
\ No newline at end of file
+        return (3 * sum(set(nums)) - sum(nums)) // 2
\ No newline at end of file
diff --git "a/0138.\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/0138-\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.py" "b/0138.\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/0138-\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.py"
new file mode 100644
index 0000000..7e115f1
--- /dev/null
+++ "b/0138.\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250/0138-\345\244\215\345\210\266\345\270\246\351\232\217\346\234\272\346\214\207\351\222\210\347\232\204\351\223\276\350\241\250.py"
@@ -0,0 +1,31 @@
+"""
+# Definition for a Node.
+class Node(object):
+    def __init__(self, val, next, random):
+        self.val = val
+        self.next = next
+        self.random = random
+"""
+class Solution(object):
+    def copyRandomList(self, head):
+        """
+        :type head: Node
+        :rtype: Node
+        """
+        #133变种题， 图换成链表
+        mapping = dict()
+        
+        p = head
+        while p:
+            mapping[p] = Node(p.val, None, None)
+            p = p.next
+            
+        for key, val in mapping.items(): #key是老结点， val是新节点
+            if key.next:
+                val.next = mapping[key.next]
+            if key.random and key.random in mapping:
+                val.random = mapping[key.random]
+            
+        return mapping[head] if head else head
+        
+        
\ No newline at end of file
diff --git "a/0139.\345\215\225\350\257\215\346\213\206\345\210\206/0139-\345\215\225\350\257\215\346\213\206\345\210\206.py" "b/0139.\345\215\225\350\257\215\346\213\206\345\210\206/0139-\345\215\225\350\257\215\346\213\206\345\210\206.py"
index 7bbfd14..3adaf59 100644
--- "a/0139.\345\215\225\350\257\215\346\213\206\345\210\206/0139-\345\215\225\350\257\215\346\213\206\345\210\206.py"
+++ "b/0139.\345\215\225\350\257\215\346\213\206\345\210\206/0139-\345\215\225\350\257\215\346\213\206\345\210\206.py"
@@ -5,13 +5,13 @@ def wordBreak(self, s, wordDict):
         :type wordDict: List[str]
         :rtype: bool
         """
-        record = [0]#一开始从开头开始找
+        dp = [0]
         
         for j in range(len(s) + 1):
-            for i in record:#在之前每一种找法的基础上找
-                if s[i : j] in wordDict: #找到一种可行的分法，说明最远可以拆分到j
-                    record.append(j)
+            for i in dp:
+                if s[i:j] in wordDict:
+                    dp.append(j)
                     break
-        # print record
-        return record[-1] == len(s)
-                
\ No newline at end of file
+        # print dp
+        return dp[-1] == len(s)
+                    
\ No newline at end of file
diff --git "a/0141.\347\216\257\345\275\242\351\223\276\350\241\250/0141-\347\216\257\345\275\242\351\223\276\350\241\250.py" "b/0141.\347\216\257\345\275\242\351\223\276\350\241\250/0141-\347\216\257\345\275\242\351\223\276\350\241\250.py"
new file mode 100644
index 0000000..568e4df
--- /dev/null
+++ "b/0141.\347\216\257\345\275\242\351\223\276\350\241\250/0141-\347\216\257\345\275\242\351\223\276\350\241\250.py"
@@ -0,0 +1,24 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def hasCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: bool
+        """
+        if not head or not head.next:
+            return False
+        slow, fast = head, head
+        
+        while fast:
+            slow = slow.next
+            fast = fast.next
+            if fast:
+                fast = fast.next
+            if slow == fast:
+                return True
+        return False
\ No newline at end of file
diff --git "a/0142.\347\216\257\345\275\242\351\223\276\350\241\250II/0142-\347\216\257\345\275\242\351\223\276\350\241\250II.py" "b/0142.\347\216\257\345\275\242\351\223\276\350\241\250II/0142-\347\216\257\345\275\242\351\223\276\350\241\250II.py"
new file mode 100644
index 0000000..3fbb11e
--- /dev/null
+++ "b/0142.\347\216\257\345\275\242\351\223\276\350\241\250II/0142-\347\216\257\345\275\242\351\223\276\350\241\250II.py"
@@ -0,0 +1,34 @@
+# Definition for singly-linked list.
+# class ListNode(object):
+#     def __init__(self, x):
+#         self.val = x
+#         self.next = None
+
+class Solution(object):
+    def detectCycle(self, head):
+        """
+        :type head: ListNode
+        :rtype: ListNode
+        """
+        if not head or not head.next:
+            return None
+        
+        slow, fast = head, head
+        while fast:
+            slow = slow.next
+            fast = fast.next
+            if fast:
+                fast = fast.next
+                
+            if slow == fast:
+                break
+        if slow != fast:
+            return None
+        
+        fast = head
+        while slow:
+            if slow == fast:
+                return slow
+            slow = slow.next
+            fast = fast.next
+            
\ No newline at end of file
diff --git "a/0143.\351\207\215\346\216\222\351\223\276\350\241\250/0143-\351\207\215\346\216\222\351\223\276\350\241\250.py" "b/0143.\351\207\215\346\216\222\351\223\276\350\241\250/0143-\351\207\215\346\216\222\351\223\276\350\241\250.py"
index 03cd491..d726f6f 100644
--- "a/0143.\351\207\215\346\216\222\351\223\276\350\241\250/0143-\351\207\215\346\216\222\351\223\276\350\241\250.py"
+++ "b/0143.\351\207\215\346\216\222\351\223\276\350\241\250/0143-\351\207\215\346\216\222\351\223\276\350\241\250.py"
@@ -15,35 +15,34 @@ def reorderList(self, head):
         
         slow, fast = head, head
         while fast and fast.next:
+            # print slow.val, fast.val
             slow = slow.next
-            fast = fast.next.next
+            fast = fast.next
+            if fast and fast.next:
+                fast = fast.next
         
-        l1, l2 = head, self.reverseList(slow.next)
+        # print slow.val, fast.val
+        
+        tail = slow.next
         slow.next = None
-        # self.printList(l1)
-        # self.printList(l2)
-        while l1 and l2:
-            cur = l2
-            l2 = l2.next
-
-            cur.next = l1.next
-            l1.next = cur
-            l1 = l1.next.next
-
+        first = head
+        last = self.reverseList(tail)
+        
+        while last:
+            tmp = first.next
+            first.next = last
+            tmp2 = last.next
+            last.next = tmp
+            first = first.next.next
+            
+            last = tmp2
         return head
-    
+        
+        
     def reverseList(self, head):
         if not head or not head.next:
             return head
         p = self.reverseList(head.next)
         head.next.next = head
         head.next = None
-        return p
-    
-    def printList(self, head):
-        l = []
-        p = head
-        while p:
-            l.append(p.val)
-            p = p.next
-        print l
\ No newline at end of file
+        return p
\ No newline at end of file
diff --git "a/0144.\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/0144-\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.py" "b/0144.\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/0144-\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.py"
index 3075ff1..faad066 100644
--- "a/0144.\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/0144-\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.py"
+++ "b/0144.\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206/0144-\344\272\214\345\217\211\346\240\221\347\232\204\345\211\215\345\272\217\351\201\215\345\216\206.py"
@@ -13,6 +13,15 @@ def preorderTraversal(self, root):
         """
         if not root:
             return []
-        result = [root.val] + self.preorderTraversal(root.left)
-        result += self.preorderTraversal(root.right)
-        return result 
\ No newline at end of file
+        stack = [root]
+        res = []
+        while stack:
+            cur = stack.pop()
+            res.append(cur.val)
+            
+            if cur.right:
+                stack.append(cur.right)
+            if cur.left:
+                stack.append(cur.left)
+        return res
+        
\ No newline at end of file
diff --git "a/0145.\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/0145-\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.py" "b/0145.\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/0145-\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.py"
index d224375..5b5c4eb 100644
--- "a/0145.\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/0145-\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.py"
+++ "b/0145.\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206/0145-\344\272\214\345\217\211\346\240\221\347\232\204\345\220\216\345\272\217\351\201\215\345\216\206.py"
@@ -13,6 +13,15 @@ def postorderTraversal(self, root):
         """
         if not root:
             return []
-        result = self.postorderTraversal(root.left)
-        result += self.postorderTraversal(root.right)
-        return result + [root.val]
\ No newline at end of file
+        
+        stack = [root]
+        res = []
+        while stack:
+            cur = stack.pop()
+            res.append(cur.val) 
+            if cur.left:
+                stack.append(cur.left)
+            if cur.right:
+                stack.append(cur.right)
+            
+        return res[::-1]
\ No newline at end of file
diff --git "a/0146.LRU\347\274\223\345\255\230\346\234\272\345\210\266/0146-LRU\347\274\223\345\255\230\346\234\272\345\210\266.py" "b/0146.LRU\347\274\223\345\255\230\346\234\272\345\210\266/0146-LRU\347\274\223\345\255\230\346\234\272\345\210\266.py"
new file mode 100644
index 0000000..265117e
--- /dev/null
+++ "b/0146.LRU\347\274\223\345\255\230\346\234\272\345\210\266/0146-LRU\347\274\223\345\255\230\346\234\272\345\210\266.py"
@@ -0,0 +1,44 @@
+class LRUCache(object):
+
+    def __init__(self, capacity):
+        """
+        :type capacity: int
+        """
+        from collections import OrderedDict
+        self.capacity = capacity
+        self.record = OrderedDict()
+
+    def get(self, key):
+        """
+        :type key: int
+        :rtype: int
+        """
+        if key in self.record:
+            tmp = self.record.pop(key)
+            self.record[key] = tmp
+            return tmp
+        else:
+            return -1
+        
+
+    def put(self, key, value):
+        """
+        :type key: int
+        :type value: int
+        :rtype: None
+        """
+        if key in self.record:
+            self.record.pop(key)         
+        else:
+            if self.capacity > 0:
+                self.capacity -= 1
+            else:
+                self.record.popitem(last = False)
+        self.record[key] = value
+        
+
+
+# Your LRUCache object will be instantiated and called as such:
+# obj = LRUCache(capacity)
+# param_1 = obj.get(key)
+# obj.put(key,value)
\ No newline at end of file
diff --git "a/0147.\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/0147-\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217.py" "b/0147.\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/0147-\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217.py"
index f2d2c8e..77b202d 100644
--- "a/0147.\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/0147-\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217.py"
+++ "b/0147.\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217/0147-\345\257\271\351\223\276\350\241\250\350\277\233\350\241\214\346\217\222\345\205\245\346\216\222\345\272\217.py"
@@ -13,22 +13,35 @@ def insertionSortList(self, head):
         if not head or not head.next:
             return head
         
-        dummy = ListNode(-1)
+        dummy = ListNode(-9999999999)
         dummy.next = head
-        pre = head #pre始终指着排序好链表的最后一个节点
-        cur = head.next #cur始终指着未排序链表的第一个节点
-        while cur:
+        p = head
+        while p:
+            while p and p.next and p.val < p.next.val:
+                p = p.next
+            
+            if not p.next:
+                break
+            cur = p.next
             tail = cur.next
-            pre.next = tail  #把cur这个节点拿出来
+            p.next = tail
+            cur.next = None
             
-            p = dummy
-            while p.next and p.next.val < cur.val: #找到插入的位置
-                p = p.next
+            tmp = dummy
+            while tmp and tmp.next and tmp.next.val < cur.val:
+                tmp = tmp.next
                 
-            cur.next = p.next #把cur插入到p和p.next之间
-            p.next = cur
-            cur = tail
+            tmp2 = tmp.next
+            tmp.next = cur
+            cur.next = tmp2
             
-            if p == pre:#如果刚插入到了已排序链表的末尾
-                pre = pre.next #那么就更新pre
-        return dummy.next
\ No newline at end of file
+            # self.printList(dummy.next)
+            
+        return dummy.next
+        
+    def printList(self, head):
+        res = []
+        while head:
+            res.append(head.val)
+            head = head.next
+        print res
\ No newline at end of file
diff --git "a/0148.\346\216\222\345\272\217\351\223\276\350\241\250/0148-\346\216\222\345\272\217\351\223\276\350\241\250.py" "b/0148.\346\216\222\345\272\217\351\223\276\350\241\250/0148-\346\216\222\345\272\217\351\223\276\350\241\250.py"
index 70ab025..8d99052 100644
--- "a/0148.\346\216\222\345\272\217\351\223\276\350\241\250/0148-\346\216\222\345\272\217\351\223\276\350\241\250.py"
+++ "b/0148.\346\216\222\345\272\217\351\223\276\350\241\250/0148-\346\216\222\345\272\217\351\223\276\350\241\250.py"
@@ -10,33 +10,42 @@ def sortList(self, head):
         :type head: ListNode
         :rtype: ListNode
         """
-
+        #1. 一分为二
+        #2. 各自排序
+        #3. 合二为一
+        
         if not head or not head.next:
             return head
+        
+        dummy = ListNode(-1)
+        dummy.next = head
+        
         pre, slow, fast = head, head, head
         while fast and fast.next:
             pre = slow
             slow = slow.next
             fast = fast.next.next
-
+            
+        first = head
+        second = pre.next
         pre.next = None
-        left, right = self.sortList(head), self.sortList(slow)
-        return self.merge(left, right)
-    
+        # print first.val, second.val
+        sortedfirst = self.sortList(first)
+        sortedsecond = self.sortList(second)
+        
+        return self.merge(sortedfirst, sortedsecond)
+        
     def merge(self, l1, l2):
         if not l1:
             return l2
         if not l2:
             return l1
-        
-        if l1.val < l2.val:
-            head = ListNode(l1.val)
-            head.next = self.merge(l1.next, l2)
+
+        if l1.val <= l2.val:
+            tmp = ListNode(l1.val)
+            tmp.next = self.merge(l1.next, l2)
         else:
-            head = ListNode(l2.val)
-            head.next = self.merge(l1, l2.next)
-        return head
-            
-                
+            tmp = ListNode(l2.val)
+            tmp.next = self.merge(l1, l2.next)
             
-        
\ No newline at end of file
+        return tmp
\ No newline at end of file
diff --git "a/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/0150-\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py" "b/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/0150-\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py"
index 9a6acbe..d0ff710 100644
--- "a/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/0150-\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py"
+++ "b/0150.\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274/0150-\351\200\206\346\263\242\345\205\260\350\241\250\350\276\276\345\274\217\346\261\202\345\200\274.py"
@@ -5,22 +5,23 @@ def evalRPN(self, tokens):
         :rtype: int
         """
         stack = []
-        for item in tokens:
-            if item in ["+", "-", "*", "/"]:
-                if item == "+":
-                    temp = int(stack[-2]) + int(stack[-1])
-                elif item == "-":
-                    temp = int(stack[-2]) - int(stack[-1])
-                    # print temp                
-                elif item == "*":
-                    temp = int(stack[-2]) * int(stack[-1])             
-                elif item == "/":
-                    temp = int(float(stack[-2])/ float(stack[-1]))                    
-                stack.pop()
-                stack.pop()
-                stack.append(temp)
-                
+        for i, x in enumerate(tokens):
+            # print stack
+            if x not in ["+", "-", "*", "/"]:
+                stack.append(int(x))
             else:
-                stack.append(item)
+                if x == "+":
+                    tmp = stack[-1] + stack[-2]
+                    stack = stack[:-2]       
+                elif x == "-":
+                    tmp = stack[-2] - stack[-1]
+                    stack = stack[:-2]                    
+                elif x == "*":
+                    tmp = stack[-1] * stack[-2]
+                    stack = stack[:-2]
+                elif x == "/":
+                    tmp = int( stack[-2] * 1.0 / stack[-1])
+                    stack = stack[:-2]
+                stack.append(tmp)
                 
-        return int(stack[0])
\ No newline at end of file
+        return stack[0]
\ No newline at end of file
diff --git "a/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/0151-\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.py" "b/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/0151-\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.py"
index ee268fd..fdc0ce2 100644
--- "a/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/0151-\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.py"
+++ "b/0151.\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215/0151-\347\277\273\350\275\254\345\255\227\347\254\246\344\270\262\351\207\214\347\232\204\345\215\225\350\257\215.py"
@@ -3,14 +3,9 @@ def reverseWords(self, s):
         """
         :type s: str
         :rtype: str
-            """
-        res = []
+        """
+        s = s.strip()
         s = s.rstrip()
-        s = s.lstrip()
-        l = s.split(" ")
-        l = l[::-1]
-        print l
-        # print " ".join(item for item in l)    
-        # for item in l:
-        #     if item == ""
-        return " ".join(item for item in l if item != "")
\ No newline at end of file
+        s = s[::-1].split(" ")
+        
+        return " ".join(item[::-1] for item in s if item)
\ No newline at end of file
diff --git "a/0152.\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227/0152-\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227.py" "b/0152.\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227/0152-\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227.py"
index 3fb4a22..8c92d31 100644
--- "a/0152.\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227/0152-\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227.py"
+++ "b/0152.\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227/0152-\344\271\230\347\247\257\346\234\200\345\244\247\345\255\220\345\272\217\345\210\227.py"
@@ -4,14 +4,16 @@ def maxProduct(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        l = len(nums)
-        dpmax = [0 for _ in range(l)]
-        dpmin = [0 for _ in range(l)]
+        #dp[i] = max(nums[i], nums[i] * dp[i - 1])
         
-        dpmax[0] = nums[0]
-        dpmin[0] = nums[0]
-        for i in range(1, l):
-            dpmax[i] = max(nums[i], max(nums[i] * dpmax[i - 1], nums[i] * dpmin[i - 1]))
-            dpmin[i] = min(nums[i], min(nums[i] * dpmax[i - 1], nums[i] * dpmin[i - 1]))
-
-        return max(dpmax)
\ No newline at end of file
+        dp = [0 for i in nums]
+        dpmin = [0 for i in nums]
+        
+        dp[0], dpmin[0] = nums[0], nums[0]
+        for i, num in enumerate(nums):
+            if i > 0:
+                dp[i] = max(num, max(dp[i - 1] * num, dpmin[i - 1] * num))
+                dpmin[i] = min(num, min(dp[i - 1] * num, dpmin[i - 1] * num))
+        
+        # print dp
+        return max(dp)
\ No newline at end of file
diff --git "a/0153.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/0153-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.py" "b/0153.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/0153-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.py"
index ece52c0..4394d72 100644
--- "a/0153.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/0153-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.py"
+++ "b/0153.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274/0153-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274.py"
@@ -4,15 +4,29 @@ def findMin(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        # m = len(nums) / 2
-        b = 0
-        e = len(nums)-1
-        while(b < e):
-            m = b + (e-b) / 2
-            if nums[m] < nums[e]: 
-                e = m
+        if not nums:
+            return 0
+        if len(nums) == 1:
+            return nums[0]
+        
+        if nums[0] < nums[-1]: #没发生旋转
+            return nums[0]
+        
+        left, right = 0, len(nums) - 1
+        while left <= right:
+            mid = (left + right) // 2
+            
+            if mid + 1< len(nums): #mid 不是最后一位
+                if nums[mid - 1] > nums[mid] and nums[mid] < nums[mid + 1]: #找到了
+                    return nums[mid]
             else:
-                b = m+1
-        return nums[b]
+                if nums[mid - 1] > nums[mid]: # mid 是最后一位
+                    return nums[mid]
+            if nums[mid] < nums[-1]: 
+                right = mid - 1
+            else:
+                left = mid + 1
                 
-            
\ No newline at end of file
+        
+                    
+        
\ No newline at end of file
diff --git "a/0154.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II/0154-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II.py" "b/0154.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II/0154-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II.py"
index 7adf69c..fcc547c 100644
--- "a/0154.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II/0154-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II.py"
+++ "b/0154.\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II/0154-\345\257\273\346\211\276\346\227\213\350\275\254\346\216\222\345\272\217\346\225\260\347\273\204\344\270\255\347\232\204\346\234\200\345\260\217\345\200\274II.py"
@@ -4,4 +4,27 @@ def findMin(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-        return min(nums)
\ No newline at end of file
+        left, right = 0, len(nums) - 1
+        while left < right:
+            mid = (left + right) // 2
+            
+            if nums[mid] > nums[right]: #最小值肯定在【mid + 1, right】
+                left = mid + 1
+            elif nums[mid] < nums[right]: #最小值肯定在【left, mid】
+                right = mid
+            elif nums[mid] == nums[right]: #无法确定最小值的区间
+                
+                flag = False
+                for j in range(right - 1, mid, -1):#逐个在右侧找，看是不是有比nums[mid]更小的数
+                    if nums[mid] > nums[j]:
+                        flag = True #确实存在更小的数，是nums[j]
+                        break
+                        
+                if flag: #可以确定最小值肯定在【mid + 1, j】
+                    left = mid + 1
+                    right = j
+                else: #mid 到right所有的数都相等, 最小值肯定在【left, mid】
+                    right = mid
+                    
+        return nums[left]
+                    
\ No newline at end of file
diff --git "a/0155.\346\234\200\345\260\217\346\240\210/0155-\346\234\200\345\260\217\346\240\210.py" "b/0155.\346\234\200\345\260\217\346\240\210/0155-\346\234\200\345\260\217\346\240\210.py"
index 616a4e3..50dca76 100644
--- "a/0155.\346\234\200\345\260\217\346\240\210/0155-\346\234\200\345\260\217\346\240\210.py"
+++ "b/0155.\346\234\200\345\260\217\346\240\210/0155-\346\234\200\345\260\217\346\240\210.py"
@@ -5,28 +5,29 @@ def __init__(self):
         initialize your data structure here.
         """
         self.stack = []
-        self.min_stack = []
-        
+        self.minstack = []
 
     def push(self, x):
         """
         :type x: int
-        :rtype: void
+        :rtype: None
         """
         self.stack.append(x)
-        if self.min_stack and self.min_stack[-1] <= x:
-            self.min_stack.append(self.min_stack[-1])
+        if self.minstack:
+            if x < self.minstack[-1]:
+                self.minstack.append(x)
+            else:
+                self.minstack.append(self.minstack[-1])
         else:
-            self.min_stack.append(x)
+            self.minstack.append(x)
         
 
     def pop(self):
         """
-        :rtype: void
+        :rtype: None
         """
-        self.stack = self.stack[:-1]
-        self.min_stack = self.min_stack[:-1]
-        
+        self.minstack.pop()
+        self.stack.pop()
 
     def top(self):
         """
@@ -38,7 +39,7 @@ def getMin(self):
         """
         :rtype: int
         """
-        return self.min_stack[-1]
+        return self.minstack[-1]
 
 
 # Your MinStack object will be instantiated and called as such:
diff --git "a/0156.\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/0156-\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.py" "b/0156.\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/0156-\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.py"
index 0eaab42..adb4184 100644
--- "a/0156.\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/0156-\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.py"
+++ "b/0156.\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221/0156-\344\270\212\344\270\213\347\277\273\350\275\254\344\272\214\345\217\211\346\240\221.py"
@@ -11,21 +11,15 @@ def upsideDownBinaryTree(self, root):
         :type root: TreeNode
         :rtype: TreeNode
         """
-        #每一个节点变成其左孩子的右节点        
         if not root or (not root.left and not root.right):
             return root
-
-        parent, sibling = None, None
-        while root:
-            tmp = root.left
-            root.left = sibling
-            
-            sibling = root.right
-            root.right = parent
-            
-            parent = root
-            root = tmp
-            
-        return parent
-            
-            
+        newroot = self.upsideDownBinaryTree(root.left)
+        right = root.right
+        root.left.left = right
+        root.left.right = root
+        
+        root.left = None
+        root.right = None
+        
+        return newroot
+        
\ No newline at end of file
diff --git "a/0157.\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246/0157-\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246.py" "b/0157.\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246/0157-\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246.py"
index 70bf37f..7acd02a 100644
--- "a/0157.\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246/0157-\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246.py"
+++ "b/0157.\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246/0157-\347\224\250Read4\350\257\273\345\217\226N\344\270\252\345\255\227\347\254\246.py"
@@ -19,18 +19,14 @@ def read(self, buf, n):
         :type n: Number of characters to read (int)
         :rtype: The number of actual characters read (int)
         """
-        tmp = ["","","",""]
-        cnt = 0
-        read4(tmp)
-        while tmp != ["","","",""]:            
-            for i in range(4):
-                if tmp[i]:                    
-                    buf[cnt] = tmp[i]
-                    cnt += 1
-                    if cnt == n + 1:
-                        return n
-            tmp = ["","","",""]
-            read4(tmp)
-        return cnt
-            
-        
\ No newline at end of file
+        res = 0
+        tmp = read4(buf)
+        s = ""
+        while tmp:
+            res += tmp
+            # print buf
+            s += "".join(buf[:tmp])
+            tmp = read4(buf)
+        for i in range(len(s)):
+            buf[i] = s[i]
+        return len(s) if len(s) < n else n
\ No newline at end of file
diff --git "a/0159.\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0159-\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py" "b/0159.\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0159-\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
index a36eb0a..da514b9 100644
--- "a/0159.\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0159-\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
+++ "b/0159.\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262/0159-\350\207\263\345\244\232\345\214\205\345\220\253\344\270\244\344\270\252\344\270\215\345\220\214\345\255\227\347\254\246\347\232\204\346\234\200\351\225\277\345\255\220\344\270\262.py"
@@ -4,29 +4,29 @@ def lengthOfLongestSubstringTwoDistinct(self, s):
         :type s: str
         :rtype: int
         """
-        left, right = 0, 0
-        queue = []
-        last_pos = {}
+        if len(s) <= 2:
+            return len(s)
+        start, end = 0, 0
+        q = []
         res = 0
-        for right in range(len(s)):
-            if s[right] in queue:
-                last_pos[s[right]] = right
-            elif s[right] not in queue:
-                if len(queue) >= 2:
-
-                    if last_pos[queue[0]] < last_pos[queue[1]]: #把0号元素踢掉
-                        left = last_pos[queue[0]] + 1
-                        last_pos.pop(queue[0])
-                        queue.pop(0)
+        dic = {} #记录q中字母最近一次出现的下标
+        for i, char in enumerate(s):
+            dic[char] = i
+            if len(q) < 2:
+                if char not in q:
+                    q.append(char)
+            else:
+                if char not in q: #要以旧换新了
+                    if dic[q[0]] < dic[q[1]]:
+                        tmp = q[0]
+                        q.pop(0)
                     else:
-                        left = last_pos[queue[1]] + 1
-                        last_pos.pop(queue[1])
-                        queue.pop(1)
-                        
-                queue.append(s[right])
-                last_pos[s[right]] = right
-            # print s[left:right + 1]
-            res = max(res, right - left + 1)
+                        tmp = q[1]
+                        q.pop(1)
+                    start = dic[tmp] + 1
+                    
+                    q.append(char)
+            end = i   
+            res = max(end - start + 1, res)
         return res
-                        
-        return res 
\ No newline at end of file
+                    
\ No newline at end of file
diff --git "a/0160.\347\233\270\344\272\244\351\223\276\350\241\250/0160-\347\233\270\344\272\244\351\223\276\350\241\250.py" "b/0160.\347\233\270\344\272\244\351\223\276\350\241\250/0160-\347\233\270\344\272\244\351\223\276\350\241\250.py"
index 396a67b..c3b380b 100644
--- "a/0160.\347\233\270\344\272\244\351\223\276\350\241\250/0160-\347\233\270\344\272\244\351\223\276\350\241\250.py"
+++ "b/0160.\347\233\270\344\272\244\351\223\276\350\241\250/0160-\347\233\270\344\272\244\351\223\276\350\241\250.py"
@@ -10,39 +10,28 @@ def getIntersectionNode(self, headA, headB):
         :type head1, head1: ListNode
         :rtype: ListNode
         """
-        la = 0
-        lb = 0
-        pa = headA
-        pb = headB
-        while(pa!= None):
+        pa, pb = headA, headB
+        la, lb = 0, 0
+        while pa:
             la += 1
             pa = pa.next
-        while(pb!= None):
+        
+        while pb:
             lb += 1
             pb = pb.next
-        
-        # print la,lb
-        pb = headB
-        pa = headA
-        if lb > la:
-            k = lb-la 
-            while(k > 0):
-                k -= 1
-                pb = pb.next
-        else:
-            k = la - lb
-            while(k > 0):
-                k -= 1
-                pa = pa.next
-        # print pb.val
-        # print pa.val
-        
-        while(pb != None):
-            # print pa.val, pb.val
-            if pb == pa:
-                return pa
-            else:
-                pa = pa.next
-                pb = pb.next
             
+        if la < lb:
+            la, lb, headA, headB = lb, la, headB, headA
+            
+        n = la - lb
+        pa, pb = headA, headB
+        while n:
+            pa = pa.next
+            n -= 1
+            
+        while pa:
+            if pa == pb:
+                return pa
+            pa = pa.next
+            pb = pb.next
         return None
\ No newline at end of file
diff --git "a/0161.\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273/0161-\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273.py" "b/0161.\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273/0161-\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273.py"
index a613a15..4635420 100644
--- "a/0161.\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273/0161-\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273.py"
+++ "b/0161.\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273/0161-\347\233\270\351\232\224\344\270\2721\347\232\204\347\274\226\350\276\221\350\267\235\347\246\273.py"
@@ -1,12 +1,16 @@
 class Solution(object):
-    def isOneEditDistance(self, s, t):      
+    def isOneEditDistance(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        edit = 0 #代表编辑次数
         distance = len(s) - len(t)
         if abs(distance) > 1: #长度都差了不止一位，肯定不对
             return False
-        if not s or not t: #两者有一个为空返回真，两个都为空返回假
+        if not s or not t:
             return s != t
-        
-        edit = 0 #代表编辑次数
         i, j = 0, 0
         while i < len(s) and j < len(t):
             if s[i] == t[j]: #无需编辑
@@ -23,10 +27,10 @@ def isOneEditDistance(self, s, t):
                     i += 1
                     j += 1
                 edit += 1
-
-        if i < len(s): #如果t没了，s还多了一位，取决于edit还是不是0
+        # print i, j, edit
+        if i < len(s):
             return edit == 0
-        if j < len(t): #如果s没了，t还多了一位，取决于edit还是不是0
+        if j < len(t):
             return edit == 0
-        
-        return i == len(s) and j == len(t) and edit == 1 
\ No newline at end of file
+        return i == len(s) and j == len(t) and edit == 1
+    
\ No newline at end of file
diff --git "a/0162.\345\257\273\346\211\276\345\263\260\345\200\274/0162-\345\257\273\346\211\276\345\263\260\345\200\274.py" "b/0162.\345\257\273\346\211\276\345\263\260\345\200\274/0162-\345\257\273\346\211\276\345\263\260\345\200\274.py"
index 04b7c85..0630c38 100644
--- "a/0162.\345\257\273\346\211\276\345\263\260\345\200\274/0162-\345\257\273\346\211\276\345\263\260\345\200\274.py"
+++ "b/0162.\345\257\273\346\211\276\345\263\260\345\200\274/0162-\345\257\273\346\211\276\345\263\260\345\200\274.py"
@@ -9,8 +9,7 @@ def findPeakElement(self, nums):
             return 0
         lo, hi = 0, len(nums) - 1
         while(lo < hi):
-            # print lo,hi
-            mid = lo + (hi - lo) / 2
+            mid = (lo + hi) // 2
             if nums[mid - 1] < nums[mid] and nums[mid] > nums[mid + 1]:
                 return mid
             elif nums[mid] < nums[mid + 1]:
@@ -18,4 +17,5 @@ def findPeakElement(self, nums):
             else:
                 hi = mid - 1
                 
-        return lo
\ No newline at end of file
+        return lo
+             
\ No newline at end of file
diff --git "a/0163.\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264/0163-\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264.py" "b/0163.\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264/0163-\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264.py"
index f3f7100..6e621ba 100644
--- "a/0163.\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264/0163-\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264.py"
+++ "b/0163.\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264/0163-\347\274\272\345\244\261\347\232\204\345\214\272\351\227\264.py"
@@ -6,31 +6,23 @@ def findMissingRanges(self, nums, lower, upper):
         :type upper: int
         :rtype: List[str]
         """
-        # if not nums:
-        #     if lower == upper:
-        #         return [str(lower)]
-        #     else:
-        #         return [str(lower) + "->" + str(upper)]
-        start = lower
-        end = lower
+        start, end = lower, lower #左闭右开
         res = []
-        for i in range(len(nums)):
-            if nums[i] == end:
-                start, end = nums[i] + 1, nums[i] + 1
-                
-            elif nums[i] > end:
-                end = max(end, nums[i] - 1)
-                
-                if end != start:
-                    res.append(str(start) + "->" + str(end))
-                else:
+        for i, num in enumerate(nums):
+            if num == end: #连上了
+                start, end = num + 1, num + 1
+            elif num > end: #没连上
+                end = max(end, num - 1)
+                if end - start == 0: #只有一个数
                     res.append(str(start))
+                else:
+                    res.append(str(start) + "->" + str(end))
+                start, end = num + 1, num + 1
+        end = upper
+        if start < end:
+            res.append(str(start) + "->" + str(end))
+        elif end == start: #只有一个数
+                res.append(str(start))
+        return res
                     
-                start, end = nums[i] + 1, nums[i] + 1
-                
-        if start < upper:       
-            res.append(str(start) + "->" + str(upper))
-        elif start == upper:
-            res.append(str(start))
-            
-        return res         
\ No newline at end of file
+                
\ No newline at end of file
diff --git "a/0164.\346\234\200\345\244\247\351\227\264\350\267\235/0164-\346\234\200\345\244\247\351\227\264\350\267\235.py" "b/0164.\346\234\200\345\244\247\351\227\264\350\267\235/0164-\346\234\200\345\244\247\351\227\264\350\267\235.py"
index a6e277d..0a2ef6d 100644
--- "a/0164.\346\234\200\345\244\247\351\227\264\350\267\235/0164-\346\234\200\345\244\247\351\227\264\350\267\235.py"
+++ "b/0164.\346\234\200\345\244\247\351\227\264\350\267\235/0164-\346\234\200\345\244\247\351\227\264\350\267\235.py"
@@ -27,4 +27,5 @@ def maximumGap(self, nums):
         return res
                         
     def findBucketIndex(self, num, min_val, max_val, n):
-        return int((num - min_val) * n / (max_val - min_val))
\ No newline at end of file
+        return int((num - min_val) * n / (max_val - min_val))
+                
\ No newline at end of file
diff --git "a/0165.\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267/0165-\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267.py" "b/0165.\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267/0165-\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267.py"
index 82b0ada..d33c456 100644
--- "a/0165.\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267/0165-\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267.py"
+++ "b/0165.\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267/0165-\346\257\224\350\276\203\347\211\210\346\234\254\345\217\267.py"
@@ -7,7 +7,6 @@ def compareVersion(self, version1, version2):
         """
         l1 = version1.split(".")
         l2 = version2.split(".")
-        
         i, j = 0, 0
         while i < len(l1) and j < len(l2): # 逐位比大小
             num1, num2 = int(l1[i]), int(l2[j])
diff --git "a/0167.\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204/0167-\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.py" "b/0167.\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204/0167-\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.py"
index 3b1db81..0355fad 100644
--- "a/0167.\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204/0167-\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.py"
+++ "b/0167.\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204/0167-\344\270\244\346\225\260\344\271\213\345\222\214II-\350\276\223\345\205\245\346\234\211\345\272\217\346\225\260\347\273\204.py"
@@ -6,10 +6,11 @@ def twoSum(self, numbers, target):
         :rtype: List[int]
         """
         left, right = 0, len(numbers) - 1
-        while(left < right):
-            if numbers[left] + numbers[right] == target:
+        while 1:
+            tmp = numbers[left] + numbers[right]
+            if tmp == target:
                 return [left + 1, right + 1]
-            if numbers[left] + numbers[right] < target:
+            elif tmp < target:
                 left += 1
-            elif numbers[left] + numbers[right] > target:
+            elif tmp > target:
                 right -= 1
\ No newline at end of file
diff --git "a/0168.Excel\350\241\250\345\210\227\345\220\215\347\247\260/0168-Excel\350\241\250\345\210\227\345\220\215\347\247\260.py" "b/0168.Excel\350\241\250\345\210\227\345\220\215\347\247\260/0168-Excel\350\241\250\345\210\227\345\220\215\347\247\260.py"
index 618eac7..f09a200 100644
--- "a/0168.Excel\350\241\250\345\210\227\345\220\215\347\247\260/0168-Excel\350\241\250\345\210\227\345\220\215\347\247\260.py"
+++ "b/0168.Excel\350\241\250\345\210\227\345\220\215\347\247\260/0168-Excel\350\241\250\345\210\227\345\220\215\347\247\260.py"
@@ -4,11 +4,10 @@ def convertToTitle(self, n):
         :type n: int
         :rtype: str
         """
-        #十进制转26进制
         res = ""
-        while(n):
-            n-=1
-            n, tmp = divmod(n, 26)
-            res = chr(ord("A") + tmp) + res
-            
-        return res
\ No newline at end of file
+        while n:
+            n -= 1
+            char = chr(ord('A') + n % 26)
+            n /= 26
+            res += char
+        return res[::-1]
\ No newline at end of file
diff --git "a/0169.\346\261\202\344\274\227\346\225\260/0169-\346\261\202\344\274\227\346\225\260.py" "b/0169.\346\261\202\344\274\227\346\225\260/0169-\346\261\202\344\274\227\346\225\260.py"
index 799481b..c16cf77 100644
--- "a/0169.\346\261\202\344\274\227\346\225\260/0169-\346\261\202\344\274\227\346\225\260.py"
+++ "b/0169.\346\261\202\344\274\227\346\225\260/0169-\346\261\202\344\274\227\346\225\260.py"
@@ -4,7 +4,4 @@ def majorityElement(self, nums):
         :type nums: List[int]
         :rtype: int
         """
-
-        nums.sort()
-        return nums[len(nums)/2]
-        
\ No newline at end of file
+        return sorted(nums)[len(nums) / 2]
\ No newline at end of file
diff --git "a/0170.\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0170-\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py" "b/0170.\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0170-\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
new file mode 100644
index 0000000..f61501f
--- /dev/null
+++ "b/0170.\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0170-\344\270\244\346\225\260\344\271\213\345\222\214III-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
@@ -0,0 +1,38 @@
+class TwoSum(object):
+
+    def __init__(self):
+        """
+        Initialize your data structure here.
+        """
+        from collections import defaultdict
+        self.dic = defaultdict(int)
+
+    def add(self, number):
+        """
+        Add the number to an internal data structure..
+        :type number: int
+        :rtype: None
+        """
+        self.dic[number] += 1
+
+    def find(self, value):
+        """
+        Find if there exists any pair of numbers which sum is equal to the value.
+        :type value: int
+        :rtype: bool
+        """
+        for key, val in self.dic.items():
+            if key * 2 == value:
+                if val > 1:
+                    return True
+            else:
+                if value - key in self.dic:
+                    return True
+        return False
+        
+
+
+# Your TwoSum object will be instantiated and called as such:
+# obj = TwoSum()
+# obj.add(number)
+# param_2 = obj.find(value)
\ No newline at end of file
diff --git "a/0171.Excel\350\241\250\345\210\227\345\272\217\345\217\267/0171-Excel\350\241\250\345\210\227\345\272\217\345\217\267.py" "b/0171.Excel\350\241\250\345\210\227\345\272\217\345\217\267/0171-Excel\350\241\250\345\210\227\345\272\217\345\217\267.py"
index 35fb274..6f4b36c 100644
--- "a/0171.Excel\350\241\250\345\210\227\345\272\217\345\217\267/0171-Excel\350\241\250\345\210\227\345\272\217\345\217\267.py"
+++ "b/0171.Excel\350\241\250\345\210\227\345\272\217\345\217\267/0171-Excel\350\241\250\345\210\227\345\272\217\345\217\267.py"
@@ -4,9 +4,8 @@ def titleToNumber(self, s):
         :type s: str
         :rtype: int
         """
-        l = len(s) - 1
         res = 0
-        for index, item in enumerate(s):
-            res += (ord(item) - ord("A") + 1) * (26 ** (l - index))
-        return res
-            
\ No newline at end of file
+        for i, char in enumerate(s):
+            res *= 26
+            res += 1 + ord(char) - ord("A")           
+        return res
\ No newline at end of file
diff --git "a/0172.\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266/0172-\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266.py" "b/0172.\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266/0172-\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266.py"
index 5f4c466..d80bb7a 100644
--- "a/0172.\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266/0172-\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266.py"
+++ "b/0172.\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266/0172-\351\230\266\344\271\230\345\220\216\347\232\204\351\233\266.py"
@@ -6,7 +6,6 @@ def trailingZeroes(self, n):
         """
         res = 0
         while n > 4:
+            res += n //5
             n //= 5
-            res += n
-        return res
-        
\ No newline at end of file
+        return res
\ No newline at end of file
diff --git "a/0173.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250/0173-\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py" "b/0173.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250/0173-\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py"
index eb457d5..b38a445 100644
--- "a/0173.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250/0173-\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py"
+++ "b/0173.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250/0173-\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\350\277\255\344\273\243\345\231\250.py"
@@ -11,30 +11,27 @@ def __init__(self, root):
         """
         :type root: TreeNode
         """
-        self.stack = []
-        self.pushLeft(root)
-
+        
+        def inorder(node):
+            if not node:
+                return []
+            return inorder(node.left) + [node.val] + inorder(node.right)
+        self.l = inorder(root)
+        self.idx = 0
     def next(self):
         """
         @return the next smallest number
         :rtype: int
         """
-        popedNode = self.stack.pop()
-        self.pushLeft(popedNode.right)
-        return popedNode.val
+        self.idx += 1
+        return self.l[self.idx - 1]
 
     def hasNext(self):
         """
         @return whether we have a next smallest number
         :rtype: bool
         """
-        return len(self.stack) != 0
-    
-    def pushLeft(self, node):
-        while(node):
-            self.stack.append(node)
-            node = node.left
-    
+        return self.idx < len(self.l)
 
 
 # Your BSTIterator object will be instantiated and called as such:
diff --git "a/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV/0188-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.py" "b/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV/0188-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.py"
new file mode 100644
index 0000000..84d748c
--- /dev/null
+++ "b/0188.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV/0188-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272IV.py"
@@ -0,0 +1,41 @@
+class Solution(object):
+    def maxProfit(self, k, prices):
+        """
+        :type k: int
+        :type prices: List[int]
+        :rtype: int
+        """
+        max_k = k
+        if k > len(prices):
+            return self.maxProfit2(prices)
+        
+        n = len(prices)
+        dp = [[[0 for _ in range(2)] for _ in range(max_k + 1)] for _ in range(n)]
+        
+        for i, price in enumerate(prices):
+            for k in range(max_k, 0, -1):
+                if i == 0:
+                    dp[0][k][0] = 0
+                    dp[0][k][1] = -price
+                else:
+                    dp[i][k][0] = max(dp[i - 1][k][0], dp[i - 1][k][1] + prices[i])
+                    dp[i][k][1] = max(dp[i - 1][k][1], dp[i - 1][k - 1][0] - prices[i])
+                
+        return dp[n - 1][max_k][0] if prices else 0
+    
+    
+    def maxProfit2(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
+        for i, price in enumerate(prices):
+            if i == 0:
+                dp[0][0] = 0
+                dp[0][1] = -price
+            else:
+                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i])
+                dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
+                
+        return dp[len(prices) - 1][0] if prices else 0
\ No newline at end of file
diff --git "a/0189.\346\227\213\350\275\254\346\225\260\347\273\204/0189-\346\227\213\350\275\254\346\225\260\347\273\204.py" "b/0189.\346\227\213\350\275\254\346\225\260\347\273\204/0189-\346\227\213\350\275\254\346\225\260\347\273\204.py"
index 0f9436d..c7c127f 100644
--- "a/0189.\346\227\213\350\275\254\346\225\260\347\273\204/0189-\346\227\213\350\275\254\346\225\260\347\273\204.py"
+++ "b/0189.\346\227\213\350\275\254\346\225\260\347\273\204/0189-\346\227\213\350\275\254\346\225\260\347\273\204.py"
@@ -3,8 +3,11 @@ def rotate(self, nums, k):
         """
         :type nums: List[int]
         :type k: int
-        :rtype: void Do not return anything, modify nums in-place instead.
+        :rtype: None Do not return anything, modify nums in-place instead.
         """
-        l = len(nums)
-        k = k % l
-        nums[:]  = nums[l-k:] + nums[:l-k]
+        #每次把最后一个数放到最前面，放k次
+        for i in range(k):
+            # tmp = nums[0]
+            tmp = nums.pop()
+            nums.insert(0, tmp)
+        
\ No newline at end of file
diff --git "a/0190.\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215/0190-\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215.py" "b/0190.\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215/0190-\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215.py"
index e58bbb8..a2bf6fc 100644
--- "a/0190.\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215/0190-\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215.py"
+++ "b/0190.\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215/0190-\351\242\240\345\200\222\344\272\214\350\277\233\345\210\266\344\275\215.py"
@@ -2,9 +2,9 @@ class Solution:
     # @param n, an integer
     # @return an integer
     def reverseBits(self, n):
-        b = bin(n)[2:]
-        b = "0" * (32 - len(b)) + b
-        # print b
-        # print b[::-1]
-        return int(b[::-1], 2)
-        
\ No newline at end of file
+        res = 0
+        for i in range(32):
+            res <<= 1
+            res += n & 1
+            n >>= 1
+        return res
\ No newline at end of file
diff --git "a/0191.\344\275\2151\347\232\204\344\270\252\346\225\260/0191-\344\275\2151\347\232\204\344\270\252\346\225\260.py" "b/0191.\344\275\2151\347\232\204\344\270\252\346\225\260/0191-\344\275\2151\347\232\204\344\270\252\346\225\260.py"
index 944a2e5..1e7ce05 100644
--- "a/0191.\344\275\2151\347\232\204\344\270\252\346\225\260/0191-\344\275\2151\347\232\204\344\270\252\346\225\260.py"
+++ "b/0191.\344\275\2151\347\232\204\344\270\252\346\225\260/0191-\344\275\2151\347\232\204\344\270\252\346\225\260.py"
@@ -4,9 +4,4 @@ def hammingWeight(self, n):
         :type n: int
         :rtype: int
         """
-        sum = 0
-        while(n > 0):
-            if (n & 1):
-              sum += 1
-            n >>= 1
-        return sum
\ No newline at end of file
+        return bin(n).count("1")
\ No newline at end of file
diff --git "a/0198.\346\211\223\345\256\266\345\212\253\350\210\215/0198-\346\211\223\345\256\266\345\212\253\350\210\215.py" "b/0198.\346\211\223\345\256\266\345\212\253\350\210\215/0198-\346\211\223\345\256\266\345\212\253\350\210\215.py"
index 4dee799..515cd58 100644
--- "a/0198.\346\211\223\345\256\266\345\212\253\350\210\215/0198-\346\211\223\345\256\266\345\212\253\350\210\215.py"
+++ "b/0198.\346\211\223\345\256\266\345\212\253\350\210\215/0198-\346\211\223\345\256\266\345\212\253\350\210\215.py"
@@ -4,15 +4,15 @@ def rob(self, nums):
         :type nums: List[int]
         :rtype: int
         """
+        # return 0
         if not nums:
             return 0
-        dp = [nums[0]]
-        if len(nums) == 1:
-            return dp[0]
-        dp.append(max(nums[0], nums[1]))
-        # if len(nums) == 2:
-        #     return dp[1]
-        for i in range(2, len(nums)):
-            dp.append(max(dp[i-2] + nums[i], dp[i-1]))
-        # print dp
-        return dp[-1]
\ No newline at end of file
+        dp = [0 for _ in nums]
+        dp[0] = nums[0] 
+        for i in range(1, len(nums)):
+            if i == 1:
+                dp[i] = max(dp[0], nums[i])
+            else:
+                dp[i] = max(dp[i - 2] + nums[i], dp[i - 1])
+        return dp[-1]
+            
\ No newline at end of file
diff --git "a/0199.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276/0199-\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.py" "b/0199.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276/0199-\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.py"
index 2e25954..6a266c3 100644
--- "a/0199.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276/0199-\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.py"
+++ "b/0199.\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276/0199-\344\272\214\345\217\211\346\240\221\347\232\204\345\217\263\350\247\206\345\233\276.py"
@@ -11,26 +11,15 @@ def rightSideView(self, root):
         :type root: TreeNode
         :rtype: List[int]
         """
-        if not root:
-            return []
-        next_layer = [root]
-        result = [root.val]
-        while(next_layer):
-            temp_next_layer = []
-            for node in next_layer:
-                if not node:
-                    continue
-                if node.left:
-                    temp_next_layer.append(node.left)
-                if node.right:
-                    temp_next_layer.append(node.right)
-            # print temp_next_layer[0].val
-            if temp_next_layer:
-                next_layer = temp_next_layer
-                result.append(temp_next_layer[-1].val)
-                # print result
-            else:
-                break
+        res = []
+        def dfs(node, depth):
+            if not node:
+                return
+            if depth > len(res):
+                res.append(node.val)
+            dfs(node.right, depth + 1)
+            dfs(node.left, depth +1)
             
-        return result
-                
\ No newline at end of file
+            
+        dfs(root, 1)
+        return res
\ No newline at end of file
diff --git "a/0200.\345\262\233\345\261\277\346\225\260\351\207\217/0200-\345\262\233\345\261\277\346\225\260\351\207\217.py" "b/0200.\345\262\233\345\261\277\346\225\260\351\207\217/0200-\345\262\233\345\261\277\346\225\260\351\207\217.py"
index 5e1ec45..0da7d96 100644
--- "a/0200.\345\262\233\345\261\277\346\225\260\351\207\217/0200-\345\262\233\345\261\277\346\225\260\351\207\217.py"
+++ "b/0200.\345\262\233\345\261\277\346\225\260\351\207\217/0200-\345\262\233\345\261\277\346\225\260\351\207\217.py"
@@ -1,33 +1,29 @@
 class Solution(object):
-    def numIslands(self, M):
+    def numIslands(self, grid):
         """
         :type grid: List[List[str]]
         :rtype: int
         """
-        if not M or not M[0]:
+        if not grid or not grid[0]:
             return 0
-        m, n = len(M), len(M[0])
-        visited = [[0 for j in range(n)] for i in range(m)]
-        # print visited
+        m, n = len(grid), len(grid[0])
         dx = [1, -1, 0, 0]
         dy = [0, 0, 1, -1]
-        res = 0
-        
-        def dfs(x0, y0):
+        def dfs(x, y):
             for k in range(4):
-                x = x0 + dx[k]
-                y = y0 + dy[k]
-                # print x, y
-                if 0<= x < m and 0 <= y < n and M[x][y] == '1' and visited[x][y] ==0:
-                    visited[x][y] = 1
-                    dfs(x, y)
-
+                xx = x + dx[k]
+                yy = y + dy[k]
+                
+                if 0 <= xx < m and 0 <= yy < n and grid[xx][yy] == "1":
+                    grid[xx][yy] = "0"
+                    dfs(xx, yy)
+        
+        
+        res = 0
         for i in range(m):
             for j in range(n):
-                if M[i][j] == '1' and visited[i][j] == 0:
-                    res += 1
-                    visited[i][j] = 1
+                if grid[i][j] == "1":
+                    grid[i][j] = "0"
                     dfs(i, j)
-                    # print visited
-                    
+                    res += 1
         return res
\ No newline at end of file
diff --git "a/0201.\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216/0201-\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216.py" "b/0201.\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216/0201-\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216.py"
new file mode 100644
index 0000000..fba5811
--- /dev/null
+++ "b/0201.\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216/0201-\346\225\260\345\255\227\350\214\203\345\233\264\346\214\211\344\275\215\344\270\216.py"
@@ -0,0 +1,13 @@
+class Solution(object):
+    def rangeBitwiseAnd(self, m, n):
+        """
+        :type m: int
+        :type n: int
+        :rtype: int
+        """
+        if m == 0 or m == n:
+            return m
+        else: #当n > m的时候，因为相邻两个数 &的结果的最后一位必定为1，因此可以递归处理
+            return self.rangeBitwiseAnd(m >> 1, n >> 1) << 1
+        
+            
\ No newline at end of file
diff --git "a/0202.\345\277\253\344\271\220\346\225\260/0202-\345\277\253\344\271\220\346\225\260.py" "b/0202.\345\277\253\344\271\220\346\225\260/0202-\345\277\253\344\271\220\346\225\260.py"
index 0ec75fb..b376561 100644
--- "a/0202.\345\277\253\344\271\220\346\225\260/0202-\345\277\253\344\271\220\346\225\260.py"
+++ "b/0202.\345\277\253\344\271\220\346\225\260/0202-\345\277\253\344\271\220\346\225\260.py"
@@ -4,15 +4,17 @@ def isHappy(self, n):
         :type n: int
         :rtype: bool
         """
-        l = set()
-        while(n!= 1):
-            l.add(n)
-            temp = 0
-            while(n > 0):
-                temp += (n % 10) ** 2
-                n /= 10
-            n = temp
-            if n in l:
-                return False
-                    
-        return n == 1
\ No newline at end of file
+        def happy(num):
+            res = 0
+            while num:
+                num, tmp = divmod(num, 10)
+                res += tmp ** 2
+            return res
+        visited = set()
+        while n and n not in visited:
+            visited.add(n)
+            tmp = happy(n)
+            if tmp == 1:
+                return True
+            n = tmp
+        return False
\ No newline at end of file
diff --git "a/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240/0203-\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.py" "b/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240/0203-\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.py"
index b1d673f..8edf91a 100644
--- "a/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240/0203-\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.py"
+++ "b/0203.\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240/0203-\347\247\273\351\231\244\351\223\276\350\241\250\345\205\203\347\264\240.py"
@@ -11,17 +11,18 @@ def removeElements(self, head, val):
         :type val: int
         :rtype: ListNode
         """
-        dummy = ListNode(0)
+        if not head:
+            return head
+        dummy = ListNode(-1)
         dummy.next = head
-        pre = dummy
-        ptr = head
-        while(ptr != None):
-            if ptr.val != val:
-                pre = pre.next
-                ptr = ptr.next
+        
+        pre, cur = dummy, head
+        while cur:
+            if cur.val == val: #需要被删除
+                pre.next = cur.next
+                cur.next = None
+                cur = pre.next
             else:
-                # print pre.val, ptr.val
-                pre.next = ptr.next
-                ptr = pre.next
-        return dummy.next
-        
\ No newline at end of file
+                pre = pre.next
+                cur = cur.next
+        return dummy.next
\ No newline at end of file
diff --git "a/0204.\350\256\241\346\225\260\350\264\250\346\225\260/0204-\350\256\241\346\225\260\350\264\250\346\225\260.py" "b/0204.\350\256\241\346\225\260\350\264\250\346\225\260/0204-\350\256\241\346\225\260\350\264\250\346\225\260.py"
index afa9f29..c9852a5 100644
--- "a/0204.\350\256\241\346\225\260\350\264\250\346\225\260/0204-\350\256\241\346\225\260\350\264\250\346\225\260.py"
+++ "b/0204.\350\256\241\346\225\260\350\264\250\346\225\260/0204-\350\256\241\346\225\260\350\264\250\346\225\260.py"
@@ -4,16 +4,9 @@ def countPrimes(self, n):
         :type n: int
         :rtype: int
         """
-        # print int(n**0.5 +1)
-        if n <= 2:
-            return 0
-        temp =[1 for i in range(1,n+1)]
-        temp[0], temp[1]  = 0,0
-        for i in range(2, int(n**0.5 +1)):
-            if temp[i] == 1:
-                for j in range(i*i, n, i):
-                    temp[j] = 0
-            # print temp
-        return sum(temp)
-            
-        
\ No newline at end of file
+        record = [1] * n
+        for i in range(2, n):
+            if record[i] == 1:
+                for j in range(i * 2, n, i):
+                    record[j] = 0
+        return sum(record) - 2 if n > 1 else 0
\ No newline at end of file
diff --git "a/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262/0205-\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.py" "b/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262/0205-\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.py"
new file mode 100644
index 0000000..101e467
--- /dev/null
+++ "b/0205.\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262/0205-\345\220\214\346\236\204\345\255\227\347\254\246\344\270\262.py"
@@ -0,0 +1,17 @@
+class Solution(object):
+    def isIsomorphic(self, s, t):
+        """
+        :type s: str
+        :type t: str
+        :rtype: bool
+        """
+        mapping = dict()
+        for i, char in enumerate(s):
+            if char in mapping:
+                if mapping[char] != t[i]: #一对多
+                    return False
+            else:
+                if t[i] in mapping.values(): #多对一
+                    return False
+                mapping[char] = t[i]
+        return True
\ No newline at end of file
diff --git "a/0206.\345\217\215\350\275\254\351\223\276\350\241\250/0206-\345\217\215\350\275\254\351\223\276\350\241\250.py" "b/0206.\345\217\215\350\275\254\351\223\276\350\241\250/0206-\345\217\215\350\275\254\351\223\276\350\241\250.py"
index 96678b3..ace8b9e 100644
--- "a/0206.\345\217\215\350\275\254\351\223\276\350\241\250/0206-\345\217\215\350\275\254\351\223\276\350\241\250.py"
+++ "b/0206.\345\217\215\350\275\254\351\223\276\350\241\250/0206-\345\217\215\350\275\254\351\223\276\350\241\250.py"
@@ -10,21 +10,14 @@ def reverseList(self, head):
         :type head: ListNode
         :rtype: ListNode
         """
-        if  head is None or head.next is None :
+        if not head or not head.next:
             return head
-        
-        dummyhead = ListNode(0)
-        dummyhead.next = pre = head
-        cur = pre.next
-        while(cur):
-            # print cur.val, cur.next.val, pre.val
-            pre.next = cur.next 
-            cur.next = dummyhead.next
-            dummyhead.next = cur
-            cur = pre.next
-            
-        return dummyhead.next
-        
-        
-        
+        pre, cur = None, head
+        while cur: 
+            tmp = cur.next #保存尾部
+            cur.next = pre #逆转局部
+            pre = cur #pre后移
+            cur = tmp #cur后移
+        return pre
+
         
\ No newline at end of file
diff --git "a/0211.\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0211-\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py" "b/0211.\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0211-\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
index 60ea337..db66ffb 100644
--- "a/0211.\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0211-\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
+++ "b/0211.\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241/0211-\346\267\273\345\212\240\344\270\216\346\220\234\347\264\242\345\215\225\350\257\215-\346\225\260\346\215\256\347\273\223\346\236\204\350\256\276\350\256\241.py"
@@ -1,11 +1,11 @@
 class WordDictionary(object):
- 
+
     def __init__(self):
         """
         Initialize your data structure here.
         """
         self.roots = {}
- 
+
     def addWord(self, word):
         """
         Adds a word into the data structure.
@@ -17,7 +17,7 @@ def addWord(self, word):
         for char in word:
             node = node.setdefault(char, {})
         node["end"] = True
- 
+
     def search(self, word):
         """
         Returns if the word is in the data structure. A word could contain the dot character '.' to represent any one letter.
@@ -27,7 +27,7 @@ def search(self, word):
         self.res = False
         self.searchHelper(self.roots, word)
         return self.res
- 
+
     def searchHelper(self, dic, word):
         if not word:
             self.res |= "end" in dic
diff --git "a/0212.\345\215\225\350\257\215\346\220\234\347\264\242II/0212-\345\215\225\350\257\215\346\220\234\347\264\242II.py" "b/0212.\345\215\225\350\257\215\346\220\234\347\264\242II/0212-\345\215\225\350\257\215\346\220\234\347\264\242II.py"
index c7b72a7..7ddeda8 100644
--- "a/0212.\345\215\225\350\257\215\346\220\234\347\264\242II/0212-\345\215\225\350\257\215\346\220\234\347\264\242II.py"
+++ "b/0212.\345\215\225\350\257\215\346\220\234\347\264\242II/0212-\345\215\225\350\257\215\346\220\234\347\264\242II.py"
@@ -59,10 +59,10 @@ def findWords(self, board, words):
         for word in words:
             tree.insert(word)
         words = set(words)
-        
         res = set()
         def dfs(x0, y0, node, tmpword):
             visited.add((x0, y0))
+            # print tmpword, x0, y0
             for k in range(4):
                 x = x0 + dx[k]
                 y = y0 + dy[k]
@@ -72,8 +72,8 @@ def dfs(x0, y0, node, tmpword):
                     dfs(x, y, node[board[x][y]], tmpword + board[x][y])
                     visited.remove((x,y))
                     
-            if tmpword in words: #找到一个单词了
-                res.add(tmpword) #用集合避免重复
+            if tmpword in words:
+                res.add(tmpword)
                     
         for i in range(m):
             for j in range(n):
diff --git "a/0214.\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262/0214-\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262.py" "b/0214.\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262/0214-\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262.py"
index 5f42c1c..86e9798 100644
--- "a/0214.\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262/0214-\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262.py"
+++ "b/0214.\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262/0214-\346\234\200\347\237\255\345\233\236\346\226\207\344\270\262.py"
@@ -5,8 +5,10 @@ def shortestPalindrome(self, s):
         :rtype: str
         """
         reversedS = s[::-1]
+        # print reversedS
         i = 0
         for i in range(len(s)):
+            # print reversedS[i:], s[:len(s) - i]
             if reversedS[i:] == s[:len(s) - i]:
                 return reversedS[:i] + s
         return ""
\ No newline at end of file
diff --git "a/0215.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240/0215-\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.py" "b/0215.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240/0215-\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.py"
index 54fb400..6c62036 100644
--- "a/0215.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240/0215-\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.py"
+++ "b/0215.\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240/0215-\346\225\260\347\273\204\344\270\255\347\232\204\347\254\254K\344\270\252\346\234\200\345\244\247\345\205\203\347\264\240.py"
@@ -5,4 +5,26 @@ def findKthLargest(self, nums, k):
         :type k: int
         :rtype: int
         """
-        return sorted(nums, reverse = True)[k-1]
\ No newline at end of file
+        left, right, target = 0, len(nums) - 1, k - 1
+        while True:
+            pos = self.partition(nums, left, right)
+            if pos == target:
+                return nums[pos]
+            elif pos > k: #要往左找
+                right = pos - 1
+            elif pos < k: #要往右找
+                left = pos + 1
+                
+    def partition(self, nums, left, right):
+        import random
+        k = random.randint(left, right)
+        pivot = nums[k]
+        nums[left], nums[k] = nums[k], nums[left]
+        index = left
+        
+        for i in range(left + 1, right + 1):
+            if nums[i] > pivot:
+                index += 1
+                nums[i], nums[index] = nums[index], nums[i]
+        nums[left], nums[index] = nums[index], nums[left]
+        return index #此时所有index左侧的值都比nums[index]大， 所有右侧的值都比nums[index]小
\ No newline at end of file
diff --git "a/0216.\347\273\204\345\220\210\346\200\273\345\222\214III/0216-\347\273\204\345\220\210\346\200\273\345\222\214III.py" "b/0216.\347\273\204\345\220\210\346\200\273\345\222\214III/0216-\347\273\204\345\220\210\346\200\273\345\222\214III.py"
index 6db4e39..c710340 100644
--- "a/0216.\347\273\204\345\220\210\346\200\273\345\222\214III/0216-\347\273\204\345\220\210\346\200\273\345\222\214III.py"
+++ "b/0216.\347\273\204\345\220\210\346\200\273\345\222\214III/0216-\347\273\204\345\220\210\346\200\273\345\222\214III.py"
@@ -5,21 +5,20 @@ def combinationSum3(self, k, n):
         :type n: int
         :rtype: List[List[int]]
         """
-        if not k or not n:
-            return []
-        
-        res = []         
-        def dfs(k, n, tmp, start):
-            if n == 0 and k == 0:
-                res.append(tmp[:])
+        res = []
+        def dfs(start, cnt, target, tmp):
+            if target < 0:
                 return
-            if k <= 0 or n <= 0:
-                return
-            
-            for i in range(start, 10):
-                tmp.append(i)
-                dfs(k - 1, n - i, tmp, i + 1)
-                tmp.pop()
-                    
-        dfs(k, n, [], 1)       
+            if target == 0:
+                if cnt == 0:
+                    res.append(tmp)
+                else:
+                    return
+                
+            for num in range(start, 10):
+                visited.add(num)
+                dfs(num + 1, cnt - 1, target - num, tmp + [num])
+                visited.remove(num)
+        visited = set()        
+        dfs(1, k, n, [])
         return res
\ No newline at end of file
diff --git "a/0217.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240/0217-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240.py" "b/0217.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240/0217-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240.py"
index 159c7f0..6570342 100644
--- "a/0217.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240/0217-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240.py"
+++ "b/0217.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240/0217-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240.py"
@@ -4,10 +4,4 @@ def containsDuplicate(self, nums):
         :type nums: List[int]
         :rtype: bool
         """
-        if len(nums) <= 1:
-            return False
-        nums.sort()
-        for index in range(0,len(nums)-1):
-            if nums[index] == nums[index +1]:#or nums[index] == nums[index-1]:
-                return True
-        return False
\ No newline at end of file
+        return len(nums) != len(set(nums))
\ No newline at end of file
diff --git "a/0219.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II/0219-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II.py" "b/0219.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II/0219-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II.py"
index 47b4e95..5d2aa7a 100644
--- "a/0219.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II/0219-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II.py"
+++ "b/0219.\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II/0219-\345\255\230\345\234\250\351\207\215\345\244\215\345\205\203\347\264\240II.py"
@@ -5,12 +5,10 @@ def containsNearbyDuplicate(self, nums, k):
         :type k: int
         :rtype: bool
         """
-        record = dict()
+        dic = dict()
         for i, num in enumerate(nums):
-            # print record
-            if record.get(num, -1) != -1:
-                if i - record[num] <= k:
+            if num in dic:
+                if i - dic[num] <= k:
                     return True
-            record[num] = i
-        return False
-                
\ No newline at end of file
+            dic[num] = i
+        return False
\ No newline at end of file
diff --git "a/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260/0222-\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.py" "b/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260/0222-\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.py"
index 449e4ed..a04b18b 100644
--- "a/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260/0222-\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.py"
+++ "b/0222.\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260/0222-\345\256\214\345\205\250\344\272\214\345\217\211\346\240\221\347\232\204\350\212\202\347\202\271\344\270\252\346\225\260.py"
@@ -11,6 +11,9 @@ def countNodes(self, root):
         :type root: TreeNode
         :rtype: int
         """
-        if not root:
-            return 0
-        return 1 + self.countNodes(root.left) + self.countNodes(root.right)
\ No newline at end of file
+        def inorder(node):
+            if not node:
+                return []
+            return inorder(node.left) + [node.val] + inorder(node.right)
+        return len(inorder(root))
+        
\ No newline at end of file
diff --git "a/0253.\344\274\232\350\256\256\345\256\244II/0253-\344\274\232\350\256\256\345\256\244II.py" "b/0253.\344\274\232\350\256\256\345\256\244II/0253-\344\274\232\350\256\256\345\256\244II.py"
index 35d0b7b..b66bc55 100644
--- "a/0253.\344\274\232\350\256\256\345\256\244II/0253-\344\274\232\350\256\256\345\256\244II.py"
+++ "b/0253.\344\274\232\350\256\256\345\256\244II/0253-\344\274\232\350\256\256\345\256\244II.py"
@@ -6,16 +6,18 @@ def minMeetingRooms(self, intervals):
         """
         if not intervals:
             return 0
-        intervals = sorted(intervals, key = lambda x :x[1])
-        record = [0 for _ in range(intervals[-1][1] + 2)]
+        if not intervals[0]:
+            return 1
+        intervals = sorted(intervals, key = lambda x: x[1])
+        record = [0 for _ in range(intervals[-1][1] + 1)]
         
-        for i, interval in enumerate(intervals):
-            start, end = interval[0], interval[1]
-            record[start] += 1
+        for interval in intervals:
+            # print record
+            begin, end = interval[0], interval[1]
+            record[begin] += 1
             record[end] -= 1
-        
-        # print record
-        for i in range(1, len(record)):
-            record[i] += record[i - 1]
-        
+            
+        for i, x in enumerate(record):
+            if i > 0:
+                record[i] += record[i - 1]
         return max(record)
\ No newline at end of file
diff --git "a/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237/0309-\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.py" "b/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237/0309-\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.py"
new file mode 100644
index 0000000..b8f03fc
--- /dev/null
+++ "b/0309.\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237/0309-\346\234\200\344\275\263\344\271\260\345\215\226\350\202\241\347\245\250\346\227\266\346\234\272\345\220\253\345\206\267\345\206\273\346\234\237.py"
@@ -0,0 +1,15 @@
+class Solution(object):
+    def maxProfit(self, prices):
+        """
+        :type prices: List[int]
+        :rtype: int
+        """
+        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
+        for i, price in enumerate(prices):
+            if i == 0:
+                dp[0][0] = 0
+                dp[0][1] = -price
+            else:
+                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i]) 
+                dp[i][1] = max(dp[i - 1][1], dp[i - 2][0] - prices[i]) #前天买的今天才能卖
+        return dp[i][0] if prices else 0
\ No newline at end of file
diff --git "a/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262/0344-\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.py" "b/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262/0344-\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.py"
index 6a23614..ceb97e9 100644
--- "a/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262/0344-\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.py"
+++ "b/0344.\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262/0344-\345\217\215\350\275\254\345\255\227\347\254\246\344\270\262.py"
@@ -1,8 +1,15 @@
 class Solution(object):
     def reverseString(self, s):
         """
-        :type s: str
-        :rtype: str
+        :type s: List[str]
+        :rtype: None Do not return anything, modify s in-place instead.
         """
-        return s[::-1]
+        if not s or len(s) == 0:
+            return s
+        left, right = 0, len(s) - 1
+        while(left < right):
+            s[left], s[right] = s[right], s[left]
+            left += 1
+            right -= 1
+        return s
         
\ No newline at end of file
diff --git "a/0415.\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240/0415-\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240.py" "b/0415.\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240/0415-\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240.py"
index 4c2a9a0..86f7c94 100644
--- "a/0415.\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240/0415-\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240.py"
+++ "b/0415.\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240/0415-\345\255\227\347\254\246\344\270\262\347\233\270\345\212\240.py"
@@ -1,41 +1,36 @@
 class Solution(object):
-    def addStrings(self, nums1, nums2):
+    def addStrings(self, s1, s2):
         """
         :type num1: str
         :type num2: str
         :rtype: str
         """
-        if not nums1:
-            return nums2
-        elif not nums2:
-            return nums1
-        elif not nums1 and not nums2:
-            return ""
-        
-        l1, l2 = len(nums1), len(nums2)
-        if l1 > l2: #保证 l1 较短
+        l1, l2 = len(s1), len(s2)
+        if l1 < l2:
+            s1, s2 = s2, s1
             l1, l2 = l2, l1
-            nums1, nums2 = nums2, nums1
-        n1 = list(nums1)[::-1]
-        n2 = list(nums2)[::-1]
-        
-        res = list()
-        for i in range(0, l2):
-            if i < l1:
-                res.append(int(n1[i]) + int(n2[i]))
-            else:
-                res.append(int(n2[i]))
-        
-        # print res
-        for i in range(0, l2):
-            while(res[i] > 9):
-                res[i] -= 10
-                if i != l2 - 1:
-                    res[i + 1] += 1
+        s1 = [int(x) for x in s1]
+        s2 = [int(x) for x in s2]
+        s1, s2 = s1[::-1], s2[::-1]
+        for i, digit in enumerate(s2):
+            s1[i] += s2[i]
+            
+        s1 = self.CarrySolver(s1)
+        s1 = s1[::-1]
+        return "".join(str(x) for x in s1)
+    
+    def CarrySolver(self, nums):  
+        #这个函数的功能是：将输入的数组中的每一位处理好进位
+        #举例：输入[15, 27, 12], 返回[5, 8, 4, 1]
+        i = 0
+        while i < len(nums):
+            if nums[i] >= 10:
+                carrier = nums[i] // 10
+                if i == len(nums) - 1:
+                    nums.append(carrier)
                 else:
-                    res.append(1)
-                    l2 += 1
+                    nums[i + 1] += carrier
+                nums[i] %= 10
+            i += 1
                     
-        return "".join(str(res[i]) for i in range(l2 - 1, -1, -1))
-        
-        
\ No newline at end of file
+        return nums
\ No newline at end of file
diff --git "a/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271/0714-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.py" "b/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271/0714-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.py"
new file mode 100644
index 0000000..f55fa80
--- /dev/null
+++ "b/0714.\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271/0714-\344\271\260\345\215\226\350\202\241\347\245\250\347\232\204\346\234\200\344\275\263\346\227\266\346\234\272\345\220\253\346\211\213\347\273\255\350\264\271.py"
@@ -0,0 +1,18 @@
+class Solution(object):
+    def maxProfit(self, prices, fee):
+        """
+        :type prices: List[int]
+        :type fee: int
+        :rtype: int
+        """
+        dp = [[0 for _ in range(2)] for _ in range(len(prices))]
+        for i, price in enumerate(prices):
+            if i == 0:
+                dp[0][0] = 0
+                dp[0][1] = -price
+            else:
+                # tmp = dp[i][0]
+                dp[i][0] = max(dp[i - 1][0], dp[i - 1][1] + prices[i] - fee)
+                dp[i][1] = max(dp[i - 1][1], dp[i - 1][0] - prices[i])
+            # print dp        
+        return dp[i][0] if prices else 0
\ No newline at end of file
diff --git "a/1014.\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210/1014-\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210.py" "b/1014.\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210/1014-\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210.py"
index 98c66fa..7c69fc9 100644
--- "a/1014.\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210/1014-\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210.py"
+++ "b/1014.\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210/1014-\346\234\200\344\275\263\350\247\202\345\205\211\347\273\204\345\220\210.py"
@@ -5,12 +5,9 @@ def maxScoreSightseeingPair(self, A):
         :rtype: int
         """
         res = 0
-        mmax = A[0]
-        mmax_index = 0
+        pre_max = A[0] + 0 #初始值
         for j in range(1, len(A)):
-            res = max(res, mmax + A[j] + mmax_index - j)
-            if A[j] + j > mmax + mmax_index:
-                mmax = A[j]
-                mmax_index = j
+            res = max(res, pre_max + A[j] - j) #判断能否刷新res
+            pre_max = max(pre_max, A[j] + j) #判断能否刷新pre_max， 得到更大的A[i] + i
                 
         return res
\ No newline at end of file
diff --git "a/1093.\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241/1093-\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241.py" "b/1093.\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241/1093-\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241.py"
new file mode 100644
index 0000000..153b96b
--- /dev/null
+++ "b/1093.\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241/1093-\345\244\247\346\240\267\346\234\254\347\273\237\350\256\241.py"
@@ -0,0 +1,55 @@
+class Solution(object):
+    def sampleStats(self, count):
+        """
+        :type count: List[int]
+        :rtype: List[float]
+        """
+        s = 0
+        total_cnt = sum(count)
+        cnt  = 0
+        avg, median, mean, mean_cnt = 0, 0, 0, 0
+        min_element, max_element = 0, 0
+        #找最小值
+        for i in range(len(count)):
+            if count[i] != 0:
+                min_element = i
+                break
+        #找最大值
+        for i in range(len(count) - 1, -1, -1):
+            if count[i] != 0:
+                max_element = i
+                break
+                
+        #找一共统计了多少个数字        
+        geshu = 0
+        for i in count:
+            if i > 0:
+                geshu += i
+                
+        find = False
+        for i, num in enumerate(count):
+            s += num * i #计算总和
+            if mean_cnt < num: #找count数组最大值的下标
+                mean = i
+                mean_cnt = num
+                
+            cnt += num #找目前出现了多少个数字
+            if cnt > total_cnt // 2 and find == False: 
+                if total_cnt % 2: #中位数肯定是一个数
+                    median = i
+                    find = True
+                else:
+                    if cnt - num == total_cnt // 2: #中位数有两个不同的数
+                        for j in range(i - 1, -1, -1): #往前找上一个数
+                            if count[j] > 0:
+                                median = (i + j) /2.0
+                                find = True
+                                break
+                    else:#中位数有两个相同的数
+                        median = i
+                        find = True
+                                
+        return [min_element, max_element, 1.0 * s /geshu, median, mean ]
+                                
+                                
+            
\ No newline at end of file
diff --git "a/1094.\346\213\274\350\275\246/1094-\346\213\274\350\275\246.py" "b/1094.\346\213\274\350\275\246/1094-\346\213\274\350\275\246.py"
new file mode 100644
index 0000000..83d63f5
--- /dev/null
+++ "b/1094.\346\213\274\350\275\246/1094-\346\213\274\350\275\246.py"
@@ -0,0 +1,20 @@
+class Solution(object):
+    def carPooling(self, trips, capacity):
+        """
+        :type trips: List[List[int]]
+        :type capacity: int
+        :rtype: bool
+        """
+        time = [0 for _ in range(1005)]
+        
+        for num, start, end in trips:
+            time[start] += num
+            time[end] -= num
+            
+        for i, x in enumerate(time):
+            time[i] += time[i - 1]
+            if time[i] > capacity:
+                return False
+            
+        return True
+        
\ No newline at end of file
diff --git "a/1095.\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274/1095-\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274.py" "b/1095.\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274/1095-\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274.py"
new file mode 100644
index 0000000..9968a55
--- /dev/null
+++ "b/1095.\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274/1095-\345\261\261\350\204\211\346\225\260\347\273\204\344\270\255\346\237\245\346\211\276\347\233\256\346\240\207\345\200\274.py"
@@ -0,0 +1,52 @@
+class Solution(object):
+    def findInMountainArray(self, target, mountain_arr):
+        """
+        :type target: integer
+        :type mountain_arr: MountainArray
+        :rtype: integer
+        """
+        # 得到数组长度
+        n = mountain_arr.length()  
+        #找山顶
+        left, right = 0, n - 1
+        while 1:
+            mid = (left + right) // 2
+            val = mountain_arr.get(mid)
+            lval, rval = mountain_arr.get(mid - 1), mountain_arr.get(mid + 1)
+
+            if val > lval and val > rval:
+                peak = val
+                peak_idx = mid
+                break
+            if val < rval:
+                left = mid + 1
+            else:
+                right = mid
+        if target == peak:
+            return mid
+
+        #找左侧
+        left, right = 0, peak_idx - 1
+        while left <= right:
+            mid = (left + right) // 2
+            val = mountain_arr.get(mid)
+            if val == target:
+                return mid
+            elif val > target:
+                right = mid - 1
+            else:
+                left = mid + 1
+                
+        #找右侧
+        left, right = peak_idx + 1, n - 1
+        while left <= right:
+            mid = (left + right) // 2
+            val = mountain_arr.get(mid)
+            if val == target:
+                return mid
+            elif val > target:
+                left = mid + 1
+            else:     
+                right = mid - 1
+                
+        return -1    
diff --git a/README.md b/README.md
index 2a42799..4d70f6c 100644
--- a/README.md
+++ b/README.md
@@ -1,6 +1 @@
-# LeetCode-Python
-杩欎釜鏂囦欢澶归噷瀛樻斁鐨勬槸鎴戝湪Leetcode-cn涓婄殑绗竴杞埛棰樼殑AC浠ｇ爜銆�
-
-棰樼洰鍒嗘瀽瑙ｇ瓟鍙互鍙傝�冩垜鐨勪釜浜哄崥瀹細https://blog.csdn.net/qq_32424059
-
-鏈枃浠跺す鐢県ttps://github.com/JiayangWu/LeetCodeCN-Submissions-Crawler 鑷姩鐢熸垚銆�
+# LeetCode-Solutions