diff --git a/2018.11.19-leetcode15/Ostrichcrab.md b/2018.11.19-leetcode15/Ostrichcrab.md new file mode 100644 index 000000000..fe57aea3f --- /dev/null +++ b/2018.11.19-leetcode15/Ostrichcrab.md @@ -0,0 +1,32 @@ +``` + +class Solution { +public: + vector> threeSum(vector& nums) { + vector> ans; + int n = nums.size(); + sort(nums.begin(), nums.end()); //排序，从小到大 + for(int i = 0 ; i < n - 2; i ++){ + int j = i + 1; + int k = n - 1; + while(j < k){ + if(nums[i] + nums[j] + nums[k] > 0){ + k --; + } + else if(nums[i] + nums[j] + nums[k] < 0){ + j ++; + } + else{ + ans.push_back({nums[i], nums[j], nums[k]}); + while(nums[j+1] == nums[j]) j++; + j ++; + } + } + while(nums[i+1] == nums[i]) i++; + } + + return ans; + } +}; + +``` diff --git "a/2018.11.19-leetcode15/\346\243\225\346\246\210\346\240\221.md" "b/2018.11.19-leetcode15/\346\243\225\346\246\210\346\240\221.md" new file mode 100644 index 000000000..04d48cf9c --- /dev/null +++ "b/2018.11.19-leetcode15/\346\243\225\346\246\210\346\240\221.md" @@ -0,0 +1,30 @@ +``` +class Solution { + public List> threeSum(int[] nums) { + List> res = new ArrayList<>(); + Arrays.sort(nums); + for(int i=0;i0&&nums[i]!=nums[i-1])){ + while(low> levelOrderBottom(TreeNode* root) { + vector> v; + if (!root) + { + return v; + } + + queue q; + q.push(root); + int len=1; + TreeNode *node = root; + + while (!q.empty()) + { + vector vi; + int size = 0; + for (int i=0; ileft) + { + size++; + q.push(tmp->left); + } + + if (tmp->right) + { + size++; + q.push(tmp->right); + } + vi.push_back(tmp->val); + q.pop(); + } + + v.insert(v.begin(),vi); + len = size; + } + + return v; + } +}; +``` diff --git "a/2018.12.12-leetcode109/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.12-leetcode109/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..ea213919c --- /dev/null +++ "b/2018.12.12-leetcode109/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,44 @@ +``` +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +/** + * Definition for a binary tree node. + * struct TreeNode { + * int val; + * TreeNode *left; + * TreeNode *right; + * TreeNode(int x) : val(x), left(NULL), right(NULL) {} + * }; + */ +class Solution { +public: + TreeNode *sortedListToBST(ListNode *head) + { + return sortedListToBST( head, NULL ); + } + +private: + TreeNode *sortedListToBST(ListNode *head, ListNode *tail) + { + if( head == tail ) + return NULL; + + ListNode *mid = head, *temp = head; + while( temp != tail && temp->next != tail ) // 寻找中间节点 + { + mid = mid->next; + temp = temp->next->next; + } + TreeNode *root = new TreeNode( mid->val ); + root->left = sortedListToBST( head, mid ); + root->right = sortedListToBST( mid->next, tail ); + return root; + } +}; +``` diff --git "a/2018.12.13-leetcode215/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.13-leetcode215/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..ba6f21d74 --- /dev/null +++ "b/2018.12.13-leetcode215/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,26 @@ +``` +class Solution { +public: + int findKthLargest(vector& nums, int k) { + int left = 0, right = nums.size() - 1; + while (true) { + int pos = partition(nums, left, right); + if (pos == k - 1) return nums[pos]; + else if (pos > k - 1) right = pos - 1; + else left = pos + 1; + } + } + int partition(vector& nums, int left, int right) { + int pivot = nums[left], l = left + 1, r = right; + while (l <= r) { + if (nums[l] < pivot && nums[r] > pivot) { + swap(nums[l++], nums[r--]); + } + if (nums[l] >= pivot) ++l; + if (nums[r] <= pivot) --r; + } + swap(nums[left], nums[r]); + return r; + } +}; +``` diff --git a/2018.12.14-leetcode347/Avalon.md b/2018.12.14-leetcode347/Avalon.md new file mode 100644 index 000000000..62226162b --- /dev/null +++ b/2018.12.14-leetcode347/Avalon.md @@ -0,0 +1,30 @@ +class Solution { + public List topKFrequent(int[] nums, int k) { + HashMap map =new HashMap<>(); + int len = nums.length; + Integer tempInt; + Integer current; + for (int i=0;i> list_Data=new ArrayList<>(map.entrySet()); + Collections.sort(list_Data,new Comparator>(){ + + @Override + public int compare(Map.Entry o1, Map.Entry o2) { + return o2.getValue().compareTo(o1.getValue()); + } + }); + List result = new ArrayList<>(); + for (int i=0;i topKFrequent(vector& nums, int k) { + unordered_map m; + priority_queue> q; + vector res; + for (auto a : nums) ++m[a]; + for (auto it : m) q.push(make_pair(it.second, it.first)); + for (int i = 0; i < k; ++i) { + res.push_back(q.top().second); q.pop(); + } + return res; + } +}; +``` diff --git a/2018.12.15-leetcode451/TheRocket.md b/2018.12.15-leetcode451/TheRocket.md new file mode 100644 index 000000000..ca3c2f84e --- /dev/null +++ b/2018.12.15-leetcode451/TheRocket.md @@ -0,0 +1,30 @@ +```java +class Solution { + public String frequencySort(String s) { + Map map = new HashMap<>(); + for (char c : s.toCharArray()) { + map.put(c, map.getOrDefault(c, 0) + 1); + } + List[] buckets = new ArrayList[s.length() + 1]; + for (Map.Entry entry : map.entrySet()) { + char c = entry.getKey(); + int count = entry.getValue(); + if (buckets[count] == null) { + buckets[count] = new ArrayList<>(); + } + buckets[count].add(c); + } + StringBuilder sb = new StringBuilder(); + for (int i = buckets.length - 1; i >= 0; --i) { + if (buckets[i] != null) { + for (char c : buckets[i]) { + for (int j = 0; j < i; ++j) { + sb.append(c); + } + } + } + } + return sb.toString(); + } +} +``` diff --git a/2018.12.15-leetcode451/Tony the Cyclist.md b/2018.12.15-leetcode451/Tony the Cyclist.md new file mode 100644 index 000000000..99a4f0adf --- /dev/null +++ b/2018.12.15-leetcode451/Tony the Cyclist.md @@ -0,0 +1,12 @@ +```python +from collections import Counter +class Solution(object): + def topKFrequent(self, nums, k): + """ + :type nums: List[int] + :type k: int + :rtype: List[int] + """ + c = Counter(nums) + return [item[0] for item in c.most_common(k)] +``` diff --git "a/2018.12.15-leetcode451/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.15-leetcode451/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..02077d4db --- /dev/null +++ "b/2018.12.15-leetcode451/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,25 @@ +``` +class Solution { +public: + string frequencySort(string s) { + unordered_map m; + for(auto ch:s) m[ch]++; + + priority_queue> p; + for(auto var:m) + p.push(make_pair(var.second, var.first)); + + string ret; + int len = p.size(); + for(int i=0; i list0 = new ArrayList<>();//红色 + List list1 = new ArrayList<>();//白色 + List list2 = new ArrayList<>();//蓝色 + for (int i=nums.length-1;i>=0;i--){ + if (nums[i]==0)list0.add(0); + else if(nums[i]==1)list1.add(1); + else if (nums[i]==2)list2.add(2); + } + + for (int i=0;i 1) swap(nums, i, --r); + else ++i; + } + } + + private static void swap(int[] nums, int i, int j) { + int tmp = nums[i]; + nums[i] = nums[j]; + nums[j] = tmp; + } +} +``` diff --git a/2018.12.16-leetcode75/Tony the Cyclist.md b/2018.12.16-leetcode75/Tony the Cyclist.md new file mode 100644 index 000000000..3b89d6592 --- /dev/null +++ b/2018.12.16-leetcode75/Tony the Cyclist.md @@ -0,0 +1,25 @@ +```python +class Solution(object): + def sortColors(self, nums): + """ + :type nums: List[int] + :rtype: void Do not return anything, modify nums in-place instead. + """ + if len(nums) < 2: + pass + else: + index_0 = 0 + index_2 = len(nums) - 1 + i = 0 + # j = len(nums)-1 + while i < index_2 + 1 and i <= len(nums)-1: + if nums[i] == 0: + nums[index_0], nums[i] = nums[i], nums[index_0] + index_0 += 1 + i += 1 + elif nums[i] == 2: + nums[index_2], nums[i] = nums[i], nums[index_2] + index_2 -= 1 + else: + i += 1 +``` diff --git "a/2018.12.16-leetcode75/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.16-leetcode75/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..655e253ba --- /dev/null +++ "b/2018.12.16-leetcode75/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,28 @@ +``` +class Solution { +public: + void sortColors(vector& nums) { + int i=0; + int j=nums.size()-1; + + int index = 0; + while(index <= j) + { + if(nums[index]==0 && index!=i) + { + swap(nums[index], nums[i]); + i++; + + } + else if(nums[index]==2) + { + swap(nums[index], nums[j]); + j--; + } + else + index++; + } + + } +}; +``` diff --git a/2018.12.17-leetcode445/Avalon.md b/2018.12.17-leetcode445/Avalon.md new file mode 100644 index 000000000..8ec4dc4a1 --- /dev/null +++ b/2018.12.17-leetcode445/Avalon.md @@ -0,0 +1,34 @@ +/** + * Definition for singly-linked list. + * public class ListNode { + * int val; + * ListNode next; + * ListNode(int x) { val = x; } + * } + */ +class Solution { + public ListNode addTwoNumbers(ListNode l1, ListNode l2) { + String i1 = String.valueOf(l1.val); + while (l1.next != null) { + i1 = i1.concat(String.valueOf(l1.next.val)); + l1 = l1.next; + } + String i2 = String.valueOf(l2.val); + while (l2.next != null) { + i2 = i2.concat(String.valueOf(l2.next.val)); + l2.next = l2.next.next; + } + + long l = Long.parseLong(i1)+Long.parseLong(i2); + char[] charArr = String.valueOf(l).toCharArray(); + + ListNode current; + ListNode temp = new ListNode(charArr[charArr.length-1] -'0'); + for (int i =charArr.length-2;i>=0;i--){ + current=new ListNode(charArr[i]-'0'); + current.next = temp; + temp = current; + } + return temp; + } +} diff --git a/2018.12.17-leetcode445/sourcema.md b/2018.12.17-leetcode445/sourcema.md new file mode 100644 index 000000000..4d2f11539 --- /dev/null +++ b/2018.12.17-leetcode445/sourcema.md @@ -0,0 +1,34 @@ +# LeetCode 445 + class Solution { + public ListNode addTwoNumbers(ListNode l1, ListNode l2) { + if (l1 == null || l2 == null) { + return l1==null?l2:l1; + } + Stack stack1 = new Stack<>(); + Stack stack2 = new Stack<>(); + int ca=0; + ListNode node=null; + while (l1 != null) { + stack1.push(l1.val); + l1=l1.next; + } + while (l2 != null) { + stack2.push(l2.val); + l2=l2.next; + } + while (!stack1.isEmpty() || !stack2.isEmpty()) { + int s1=stack1.isEmpty()?0:stack1.pop(); + int s2=stack2.isEmpty()?0:stack2.pop(); + ListNode cur = new ListNode((s1 + s2 + ca) % 10); + cur.next=node; + node=cur; + ca=(s1+s2+ca)/10; + } + if (ca == 1) { + ListNode cur = new ListNode(1); + cur.next=node; + node=cur; + } + return node; + } +} diff --git "a/2018.12.17-leetcode445/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.17-leetcode445/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..372cfda07 --- /dev/null +++ "b/2018.12.17-leetcode445/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,75 @@ +``` +/** + * Definition for singly-linked list. + * struct ListNode { + * int val; + * ListNode *next; + * ListNode(int x) : val(x), next(NULL) {} + * }; + */ +class Solution { +public: + ListNode* addTwoNumbers(ListNode* l1, ListNode* l2) { + stack s1; + stack s2; + + ListNode *L1 = l1; + while(L1) + { + s1.push(L1->val); + L1 = L1->next; + } + + L1 = l2; + while(L1) + { + s2.push(L1->val); + L1 = L1->next; + } + + stack s3; + int carry = 0; + while(!s1.empty() && !s2.empty()) + { + int sum = s1.top() + s2.top() + carry; + carry = sum/10; + s3.push(sum%10); + + s1.pop(); + s2.pop(); + } + + while(!s1.empty()) + { + int sum = s1.top() + carry; + carry = sum/10; + s3.push(sum%10); + + s1.pop(); + } + + while(!s2.empty()) + { + int sum = s2.top() + carry; + carry = sum/10; + s3.push(sum%10); + + s2.pop(); + } + + if(carry) s3.push(carry); + + ListNode* ret = new ListNode(-1); + ListNode* p = ret; + while(!s3.empty()) + { + ListNode *node = new ListNode(s3.top()); + p->next = node; + p = p->next; + s3.pop(); + } + + return ret->next; + } +}; +``` diff --git a/2018.12.17-leetcode455/Avalon.md b/2018.12.17-leetcode455/Avalon.md new file mode 100644 index 000000000..13b1a880e --- /dev/null +++ b/2018.12.17-leetcode455/Avalon.md @@ -0,0 +1,20 @@ +class Solution { + public int findContentChildren(int[] g, int[] s) { + /** + * 第一步：排序 + */ + Arrays.sort(g); + Arrays.sort(s);//按照从小到大进行排序 + int gIndex =0,count = 0; + for (int i=0;i=g[gIndex]){ + count++; + gIndex++; + break; + } + } + } + return count; + } +} diff --git a/2018.12.17-leetcode455/TheRocket.md b/2018.12.17-leetcode455/TheRocket.md new file mode 100644 index 000000000..971fb06a2 --- /dev/null +++ b/2018.12.17-leetcode455/TheRocket.md @@ -0,0 +1,17 @@ +```java +class Solution { + public int findContentChildren(int[] g, int[] s) { + Arrays.sort(g); + Arrays.sort(s); + int i = 0; + int j = 0; + while (i < g.length && j < s.length) { + if (s[j] >= g[i]) { + ++i; + } + ++j; + } + return i; + } +} +``` diff --git "a/2018.12.17-leetcode455/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.17-leetcode455/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..a6346451a --- /dev/null +++ "b/2018.12.17-leetcode455/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,26 @@ +``` +class Solution { +public: + int findContentChildren(vector& g, vector& s) { + sort(g.begin(), g.end()); + sort(s.begin(), s.end()); + + int i = 0; + int j = 0; + int count = 0; + while(i < g.size() && j < s.size()) + { + if(g[i] <= s[j]) + { + i++; + j++; + count++; + } + else + j++; + } + + return count; + } +}; +``` diff --git a/2018.12.18-leetcode435/Avalon.md b/2018.12.18-leetcode435/Avalon.md new file mode 100644 index 000000000..5ee1493db --- /dev/null +++ b/2018.12.18-leetcode435/Avalon.md @@ -0,0 +1,24 @@ +/** + * Definition for an interval. + * public class Interval { + * int start; + * int end; + * Interval() { start = 0; end = 0; } + * Interval(int s, int e) { start = s; end = e; } + * } + */ +class Solution { + public int eraseOverlapIntervals(Interval[] intervals) { + //按照停止位置进行排序 + Arrays.sort(intervals, (x, y) -> x.end - y.end); + + // + int count = 0, j = 1;//j-下一个 + for (int i = 0; j < intervals.length; j++) { + if (intervals[i].end > intervals[j].start) {//当后一个产生重叠区域时 + count++; + }else i=j;//当不重叠的时候，需要把j的位置作为比较方 + } + return count; + } +} diff --git a/2018.12.18-leetcode435/TheRocket.md b/2018.12.18-leetcode435/TheRocket.md new file mode 100644 index 000000000..796d1a0a1 --- /dev/null +++ b/2018.12.18-leetcode435/TheRocket.md @@ -0,0 +1,29 @@ +```java +/** + * Definition for an interval. + * public class Interval { + * int start; + * int end; + * Interval() { start = 0; end = 0; } + * Interval(int s, int e) { start = s; end = e; } + * } + */ +class Solution { + public int eraseOverlapIntervals(Interval[] intervals) { + if (intervals == null || intervals.length <= 1) { + return 0; + } + Arrays.sort(intervals, Comparator.comparingInt(o -> o.end)); + int res = 0; + int pre = intervals[0].end; + for (int i = 1; i < intervals.length; ++i) { + if (intervals[i].start < pre) { + ++res; + } else { + pre = intervals[i].end; + } + } + return res; + } +} +``` diff --git "a/2018.12.18-leetcode435/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.18-leetcode435/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..657d760c9 --- /dev/null +++ "b/2018.12.18-leetcode435/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,28 @@ +``` +class Solution { +public: + int eraseOverlapIntervals(vector& intervals) { + if(intervals.size() <= 1) return 0; + + int ret = 0; + sort(intervals.begin(), intervals.end(), [](Interval& a, Interval& b){return a.start < b.start;}); + + auto tmp = intervals.begin(); + auto it=intervals.begin(); + it++; + for(; it!=intervals.end(); it++) + { + if(tmp->end > it->start) + { + ret++; + tmp = (tmp->end>it->end)?it:tmp; + } + else + tmp = it; + } + + return ret; + + } +}; +``` diff --git a/2018.12.19-leetcode452/Avalon.md b/2018.12.19-leetcode452/Avalon.md new file mode 100644 index 000000000..f0233eb8d --- /dev/null +++ b/2018.12.19-leetcode452/Avalon.md @@ -0,0 +1,21 @@ +class Solution { + public int findMinArrowShots(int[][] points) { + if (points == null || points.length == 0) return 0; + //对二位数组进行排序 + Arrays.sort(points, (x, y) -> x[1] - y[1]); + + //开始落实比较方案 + //1-无重叠区域 + int count = 0, j = 1; + for (int i = 0; j < points.length; j++) { + if (points[i][1] >= points[j][0]) {//被比较方的结束大于比较方的开始--重叠了-》 + + } else { + count++;//因为这个是后结算的，所以需要在最后return 的时候自加 + i = j; + } + } + + return ++count;//当最后一个出现的时候是木有进行判断 + } +} diff --git a/2018.12.19-leetcode452/TheRocket.md b/2018.12.19-leetcode452/TheRocket.md new file mode 100644 index 000000000..49ca369e7 --- /dev/null +++ b/2018.12.19-leetcode452/TheRocket.md @@ -0,0 +1,19 @@ +```java +class Solution { + public int findMinArrowShots(int[][] points) { + if (points == null || points.length == 0) { + return 0; + } + Arrays.sort(points, Comparator.comparingInt(o -> o[1])); + int res = 1; + int pre = points[0][1]; + for (int i = 1; i < points.length; ++i) { + if (points[i][0] > pre) { + ++res; + pre = points[i][1]; + } + } + return res; + } +} +``` diff --git "a/2018.12.19-leetcode452/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.19-leetcode452/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..300b8c15e --- /dev/null +++ "b/2018.12.19-leetcode452/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,36 @@ +``` +bool cmp(const std::pair &a, const std::pair &b) +{ + return a.first>& points) { + if(points.size() <= 1) return points.size(); + + int ret = 1; + sort(points.begin(), points.end(), cmp); + + auto tmp = points.begin(); + auto it = points.begin(); + it++; + for(; itsecond >= it->first) + { + tmp->first = it->first; + tmp->second = min(tmp->second, it->second); + } + else + { + tmp = it; + ret++; + } + } + + return ret; + } +}; + +``` diff --git a/2018.12.20-leetcode406/Avalon.md b/2018.12.20-leetcode406/Avalon.md new file mode 100644 index 000000000..2d4a2ff7a --- /dev/null +++ b/2018.12.20-leetcode406/Avalon.md @@ -0,0 +1,13 @@ +class Solution { + public int[][] reconstructQueue(int[][] people) { + //按照身高降序，位置升序进行排序 + Arrays.sort(people,(x,y)->x[0]==y[0]?x[1]-y[1]:y[0]-x[0]); + + List templist = new LinkedList<>(); + for (int[] p : + people) { + templist.add(p[1], p); + } + return templist.toArray(new int[templist.size()][]); + } +} diff --git a/2018.12.20-leetcode406/TheRocket.md b/2018.12.20-leetcode406/TheRocket.md new file mode 100644 index 000000000..fd3e64e74 --- /dev/null +++ b/2018.12.20-leetcode406/TheRocket.md @@ -0,0 +1,15 @@ +```java +class Solution { + public int[][] reconstructQueue(int[][] people) { + Arrays.sort(people, (o1, o2) -> o1[0] != o2[0] ? Integer.compare(o2[0], o1[0]) : Integer.compare(o1[1], o2[1])); + for (int i = 0; i < people.length; ++i) { + int[] p = people[i]; + for (int j = i; j > p[1]; --j) { + people[j] = people[j - 1]; + } + people[p[1]] = p; + } + return people; + } +} +``` diff --git "a/2018.12.20-leetcode406/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2018.12.20-leetcode406/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..ad62127e8 --- /dev/null +++ "b/2018.12.20-leetcode406/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,22 @@ +``` +bool cmp(pair &p1, pair &p2) +{ + return (p1.first>p2.first)||(p1.first==p2.first && p1.second> reconstructQueue(vector>& people) { + + sort(people.begin(), people.end(), cmp); + + vector> ret; + for(auto it:people) + { + ret.insert(ret.begin() + it.second, it); + } + + return ret; + } +}; +``` diff --git a/2018.12.21-leetcode763/Avalon.md b/2018.12.21-leetcode763/Avalon.md new file mode 100644 index 000000000..bab975bc3 --- /dev/null +++ b/2018.12.21-leetcode763/Avalon.md @@ -0,0 +1,39 @@ +class Solution { + public List partitionLabels(String S) { + if (S == null || S.length() == 0) return null; + + List list = new ArrayList<>(); + + //region 开始解题 + //System.out.println('b'-'a');//1-->创建一个二维数组 + ///1.创建一个二维数组,存储起止位置 + int[][] stored = new int[26][];//26个英文字母 + int start, end; + for (int i = 0; i < 26; i++) {//没有时为-1 + start = S.indexOf((char) ('a' + i)); + end = S.lastIndexOf((char) ('a' + i)); + stored[i] = new int[]{start, end}; + } + Stream stream = Arrays.stream(stored);//转换为stream 进行操作 + //stream.forEach(p-> System.out.println(Arrays.toString((int[])p))); + //2.筛选不需要的部分 + 按照 start 位置进行排序 + int[][] tempResult = (int[][]) stream.filter(p -> ((int[]) p)[0] > -1).sorted((e1, e2) -> ((int[]) e1)[0] - ((int[]) e2)[0]).toArray(int[][]::new);//通过流转化为数组 + //3.通过贪婪算法得出结果 + + int j = 1, i = 0;//count=0, + for (; j < tempResult.length; j++) { + if (tempResult[i][1] > tempResult[j][0]) {//结束位置覆盖开始位置-》 + if (tempResult[i][1] < tempResult[j][1]) + tempResult[i][1] = tempResult[j][1]; + } else { + list.add(tempResult[i][1] - tempResult[i][0] + 1); + i = j; + } + } + list.add(tempResult[i][1] - tempResult[i][0] + 1); + //endregion + + + return list; + } +} diff --git a/2018.12.21-leetcode763/Be a fresh man.md b/2018.12.21-leetcode763/Be a fresh man.md new file mode 100644 index 000000000..aa07578a4 --- /dev/null +++ b/2018.12.21-leetcode763/Be a fresh man.md @@ -0,0 +1,120 @@ +## 763_(划分字母区间)Partition Labels +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +字符串 S 由小写字母组成。我们要把这个字符串划分为尽可能多的片段，同一个字母只会出现在其中的一个片段。
+返回一个表示每个字符串片段的长度的列表。
+__注意__:
+1. S的长度在[1, 500]之间。 +2. S只包含小写字母'a'到'z'。 +### 1.2 输入与输出 +输入： +* string S:带划分的字符串 S + +输出： +* vector< int>:划分为尽可能多的片段， 每个字符串片段的长度的列表 +### 1.3 样例 +#### 1.3.1 样例1 +输入: S = "ababcbacadefegdehijhklij"
+输出: [9,7,8]
+解释:划分结果为 "ababcbaca", "defegde", "hijhklij"。
+每个字母最多出现在一个片段中。像 "ababcbacadefegde", "hijhklij" 的划分是错误的，因为划分的片段数较少。 + +## 2 思路描述与代码 +### 2.1 思路描述（一遍扫描+切割法） +说明: +* `vector` data; 是个长度可变的 int 数组，c++里面称为容器 +* data.empty() 判断 data 是否为空 +* `vector` data(26, -1); 初始化一个长度为26的长度可变 int 数组，且所有元素初始化为 -1 + +使用`vector< int>` ans记录最终的划分方案;
+使用`vector` border 记录每个划分字母区间的右边界所处的下标；
+使用`vector` dict(26, -1) 记录每个字符第一次出现的位置;
+```cpp +for( int i = 0; i < S.size(); i++ ){ + if(该字母在之前出现过) + * 合并包括该字母第一次出现位置的区间到当前位置的所有区间; + else 如果未出现则记录其第一次出现位置; + 当前位置作为最后一个字母区间的右边界; +} +找出最多分段的区间右边界后，对其进行切割即可; +``` + +比如输出S = "ababc";
+S[0] = 'a', border = [], dict['a'] = -1, 'a'未出现过, dict['a'] = 0, border = [0];
+S[1] = 'b', border = [0], dict['b'] = -1, 'b'未出现过, dict['a'] = 1, border = [0, 1];
+S[2] = 'a', border = [0, 1], dict['a'] = 0, 'a'出现过, 合并区间, border = [2];
+S[3] = 'b', border = [2], dict['b'] = 1, 'b'出现过, 合并区间, border = [3];
+S[4] = 'c', border = [3], dict['c'] = -1, 'c'出现过, dict['c'] = 4, border = [3, 4];
+然后进行切割，将S = "ababc" 从位置3、4分别切割一刀，划分成 "abab" 与 "c"。 + +### 2.2 代码 +```cpp +//一遍扫描+切割法 +vector partitionLabels(string S) { + vector ans; + int len = S.size(); + //记录每个划分字母区间的右边界所处的下标 + vector border; + //记录字母第一次出现的位置 + vector dict(26, -1); + for( int i = 0; i < len; i++ ){ + //如果该字母在之前出现过 + if(dict[S[i] - 'a'] != -1){ + //合并该字母第一次出现位置到当前位置的所有区间 + while(!border.empty() && dict[S[i] - 'a'] <= border.back()) border.pop_back(); + } + //如果未出现记录位置 + else dict[S[i] - 'a'] = i; + //当前位置作为最后一个字母区间的右边界 + border.push_back(i); + } + //找出最多分段的区间右边界后，对其进行划分即可 + int len_border = border.size(); + ans.push_back(border[0] + 1); + for( int i = 1; i < len_border; i++ ){ + ans.push_back(border[i] - border[i - 1]); + } + return ans; +} +``` +## 3 思考与拓展 +### 3.1 思考 +一遍扫描+切割法利用的是字符第一次出现的位置，也可以利用字符最后一次出现的位置的做为突破点。 +#### 3.1.1 其他方法 +##### 3.1.1.1 两遍扫描法 +首先遍历一遍记录 S 中出现字母的最后一个下标;
+再一遍扫描确认最佳分割方案。 +```cpp +vector partitionLabels(string S) { + vector ans; + int len = S.size(); + vector dict(26, -1); + for( int i = 0; i < len; i++ ){ + dict[S[i] - 'a'] = i; + } + //记录当前分割区间的开始与结束下标 + int interval_start = 0; + int interval_end = -1; + for( int i = 0; i < len; i++ ){ + //扩张右边界 + interval_end = max(interval_end, dict[S[i] - 'a']); + //到达右边界的结束位置了 + if(i == interval_end){ + ans.push_back(interval_end - interval_start + 1); + interval_start = interval_end + 1; + } + } + return ans; +} +``` +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +一遍扫描+切割法|O(n)|O(n)，最坏情况与两遍扫描法时间复杂度一致 +两遍扫描法|O(1)|O(n) +#### 3.1.3 难点分析 +1. 选取字母第一次还是最后一次出现的位置作为入手点; +2. 根据什么规则判断到了右边界。 + +### 3.2 拓展 +如果给你的是链表数据呢？ diff --git a/2018.12.21-leetcode763/TheRocket.md b/2018.12.21-leetcode763/TheRocket.md new file mode 100644 index 000000000..c8d40c805 --- /dev/null +++ b/2018.12.21-leetcode763/TheRocket.md @@ -0,0 +1,23 @@ +```java +class Solution { + public List partitionLabels(String S) { + char[] cs = S.toCharArray(); + // 字符最后一次出现的位置 + int[] last = new int[26]; + for (int i = 0; i < cs.length; ++i) { + last[cs[i] - 'a'] = i; + } + List res = new ArrayList<>(); + int start = 0; // 区间起始位置 + int end = 0; // 区间结束位置 + for (int i = 0; i < cs.length; ++i) { + end = Math.max(end, last[cs[i] - 'a']); + if (i == end) { + res.add(end - start + 1); + start = i + 1; + } + } + return res; + } +} +``` diff --git a/2018.12.22-leetcode605/TheRocket.md b/2018.12.22-leetcode605/TheRocket.md new file mode 100644 index 000000000..dc218ea07 --- /dev/null +++ b/2018.12.22-leetcode605/TheRocket.md @@ -0,0 +1,21 @@ +```java +class Solution { + public boolean canPlaceFlowers(int[] flowerbed, int n) { + int len = flowerbed.length; + if (len < 2 * n - 1) { + return false; + } + for (int i = 0; i < len && n > 0; ) { + int next = i + 1 < len ? flowerbed[i + 1] : 0; + if (flowerbed[i] == 0 && next == 0) { + --n; + i += 2; + } else { + while (++i < len && flowerbed[i] == 1) {} + ++i; + } + } + return n == 0; + } +} +``` diff --git a/2018.12.23-leetcode392/FFFro.md b/2018.12.23-leetcode392/FFFro.md new file mode 100644 index 000000000..d33f0a9d4 --- /dev/null +++ b/2018.12.23-leetcode392/FFFro.md @@ -0,0 +1,25 @@ +class Solution { + public boolean isSubsequence(String s, String t) { + char[] tempS = s.toCharArray(); + char[] tempT = t.toCharArray(); + int s_l = tempS.length; + int t_l = tempT.length; + + if (s_l > t_l) { + return false; + } else if (s_l == 0) { + return true; + } + int i = 0; + for (int j = 0; j < t_l; j++) { + if (tempS[i] == tempT[j]) { + if (i == s_l - 1) { + return true; + } else { + i++; + } + } + } + return false; + } +} diff --git a/2018.12.23-leetcode392/TheRocket.md b/2018.12.23-leetcode392/TheRocket.md new file mode 100644 index 000000000..d214cbf21 --- /dev/null +++ b/2018.12.23-leetcode392/TheRocket.md @@ -0,0 +1,16 @@ +```java +class Solution { + public boolean isSubsequence(String s, String t) { + int index = -1; + for (char c : s.toCharArray()) { + // 每次从下一个位置开始找 + index = t.indexOf(c, index + 1); + // 没找到 + if (index == -1) { + return false; + } + } + return true; + } +} +``` diff --git a/2018.12.23-leetcode392/Tony the Cyclist.md b/2018.12.23-leetcode392/Tony the Cyclist.md new file mode 100644 index 000000000..c5ebc9045 --- /dev/null +++ b/2018.12.23-leetcode392/Tony the Cyclist.md @@ -0,0 +1,20 @@ +```python +class Solution(object): + def isSubsequence(self, s, t): + """ + :type s: str + :type t: str + :rtype: bool + """ + if len(s) == 0: + return True + if len(s) > len(t): + return False + index = 0 + for i in range(len(t)): + if t[i] == s[index]: + index += 1 + if index == len(s): + return True + return False +``` diff --git a/2018.12.23-leetcode392/lyan_dut.md b/2018.12.23-leetcode392/lyan_dut.md new file mode 100644 index 000000000..cbd34cf80 --- /dev/null +++ b/2018.12.23-leetcode392/lyan_dut.md @@ -0,0 +1,21 @@ +```c++ +/* + * 392. 判断子序列 + * https://leetcode-cn.com/problems/is-subsequence/ + */ +/* + * 方法一: 双指针 + */ +bool MyLeetCode::isSubsequence(string s, string t) { + if(s.length()==0 && t.length()==0) + return true; + for(int i=0, j=0; j < t.length(); j++){ + if(s[i] == t[j]) + i++; + if(i==s.length()) + return true; + } + return false; +} + +``` diff --git a/2018.12.24-leetcode665/TheRocket.md b/2018.12.24-leetcode665/TheRocket.md new file mode 100644 index 000000000..30f9d7d01 --- /dev/null +++ b/2018.12.24-leetcode665/TheRocket.md @@ -0,0 +1,24 @@ +```java +class Solution { + public boolean checkPossibility(int[] nums) { + if (nums == null || nums.length <= 1) { + return true; + } + boolean changed = false; + for (int i = 1; i < nums.length; ++i) { + if (nums[i - 1] > nums[i]) { + if (changed) { + return false; + } + changed = true; + if (i - 2 >= 0 && nums[i - 2] > nums[i]) { + nums[i] = nums[i - 1]; + } else { + nums[i - 1] = nums[i]; + } + } + } + return true; + } +} +``` diff --git "a/2018.12.24-leetcode665/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.24-leetcode665/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..42bba4068 --- /dev/null +++ "b/2018.12.24-leetcode665/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,17 @@ +class Solution { + public boolean checkPossibility(int[] nums) { + int cnt = 0; + for(int i = 1; i <= nums.length - 1 ; i++) { + if(nums[i-1] > nums[i]) { + if(i-2 < 0 || nums[i-2] < nums[i]) { + nums[i-1] = nums[i]; + } else { + nums[i] = nums[i-1]; + } + cnt++; + } + } + if(cnt <= 1) return true; + return false; + } +} diff --git "a/2018.12.24-leetcode665/\345\246\256\345\217\257.md" "b/2018.12.24-leetcode665/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..21756d46d --- /dev/null +++ "b/2018.12.24-leetcode665/\345\246\256\345\217\257.md" @@ -0,0 +1,86 @@ +``` +package sy181229; + +/** + * @author suyuan + *给定一个长度为 n 的整数数组，你的任务是判断在最多改变 1 个元素的情况下， + *该数组能否变成一个非递减数列。 + +我们是这样定义一个非递减数列的： 对于数组中所有的 i (1 <= i < n)， +满足 array[i] <= array[i + 1]。 + +**示例 1:** + +输入: [4,2,3] +输出: True +解释: 你可以通过把第一个4变成1来使得它成为一个非递减数列。 + + +**示例 2:** + +输入: [4,2,1] +输出: False +解释: 你不能在只改变一个元素的情况下将其变为非递减数列。 + +说明: n 的范围为 [1, 10,000]。 + */ +public class leetcode_665非递减数列 +{ + + public static void main(String[] args) + { + //int[] nums =new int[]{1 ,2 ,-1 ,3}; + int[] nums =new int[]{4, 2, 3}; + checkPossibility(nums); + + } + + public static boolean checkPossibility2(int[] nums) + { + int len=nums.length; + int c=0; + for(int i=1;inums[i]) + { + c++; + if((c==1 && i>=2 && i=2) + return false; + } + } + return true; + } + + public static boolean checkPossibility(int[] nums) + { + boolean flag=false; + int len=nums.length; + for(int i=0;i nums[i+1]) + { + if(flag) + return false; + else + { + //找到是前一个数大还是后一个数大 + //[-1 4 2 3] + //后一个大于前一个 复合递增规则,前后不用调整,调整i + //第一个数 -1 会越界 + if(i-1 < 0 || nums[i+1] >= nums[i-1]) + nums[i]=nums[i+1]; + //[1 2 -1 3] + //前一个大于后一个 , 后一个不符合递增规则, 调整后一个 + else + nums[i+1]=nums[i]; + flag=true; + + } + } + } + return true; + } + +} +``` diff --git a/2018.12.25-leetcode122/Be a fresh man.md b/2018.12.25-leetcode122/Be a fresh man.md new file mode 100644 index 000000000..02a29a649 --- /dev/null +++ b/2018.12.25-leetcode122/Be a fresh man.md @@ -0,0 +1,66 @@ +## 122_(买卖股票的最佳时机 II)Best Time to Buy and Sell Stock II +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。
+注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 +### 1.2 输入与输出 +输入： +* vector& prices:长度可变的价格数组prices + +输出： +* int:所能获取的最大利润 + +### 1.3 样例 +#### 1.3.1 样例1 +输入: [7,1,5,3,6,4]
+输出: 7
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 +#### 1.3.2 样例2 +输入: [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 + 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 +#### 1.3.3 样例3 +输入: [7,6,4,3,1]
+输出: 0
+解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 + + +## 2 思路描述与代码 +### 2.1 思路描述（贪心法） +把所有可能获利的交易都吃掉，局部最优可以获得全局最优。
+算差分数组，把差分数组中所有为正的元素都加起来就是最大收益。 + +比如输入: [7,1,5,3,6,4]
+差分数组为:[0,-6,4,-2,3,-2]
+最大收益为 4 + 3 = 7 +### 2.2 代码 +```cpp +//函数中涉及到的c++知识 +//vector 是个长度可变的 int 数组，c++里面称为容器 +int maxProfit(vector& prices) { + int len = prices.size(); + int max_profit = 0; + for( int i = 1; i < len; i++ ){ + if(prices[i] - prices[i - 1] > 0) max_profit += prices[i] - prices[i - 1]; + } + return max_profit; +} +``` +## 3 思考与拓展 +### 3.1 思考 +典型的贪心法。本题贪心法和开天眼道理很像，比如差分数组为正，则回到前一天买入，下一天突然跌了，我可以回到前一天卖出去。 +#### 3.1.1 其他方法 +无。 +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +贪心法|O(1)|O(n) +#### 3.1.3 难点分析 +1. 差分数组首元素记为0。 + +### 3.2 拓展 +1. [买卖股票的最佳时机 III](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-iii/)。 diff --git a/2018.12.25-leetcode122/Ostrichcrab.md b/2018.12.25-leetcode122/Ostrichcrab.md new file mode 100644 index 000000000..f12504d50 --- /dev/null +++ b/2018.12.25-leetcode122/Ostrichcrab.md @@ -0,0 +1,14 @@ +``` +class Solution { +public: + int maxProfit(vector& prices) { + int size = prices.size(); + if(size == 0) return 0; + int profit = 0; + for(int i = 1; i < size; i++){ + profit += prices[i]>prices[i-1]?prices[i]-prices[i-1]:0; + } + return profit; + } +}; +``` diff --git a/2018.12.25-leetcode122/TheRocket.md b/2018.12.25-leetcode122/TheRocket.md new file mode 100644 index 000000000..8b048567b --- /dev/null +++ b/2018.12.25-leetcode122/TheRocket.md @@ -0,0 +1,13 @@ +```java +class Solution { + public int maxProfit(int[] prices) { + int res = 0; + for (int i = 1; i < prices.length; ++i) { + if (prices[i] > prices[i - 1]) { + res += prices[i] - prices[i - 1]; + } + } + return res; + } +} +``` diff --git a/2018.12.25-leetcode122/Tony the Cyclist.md b/2018.12.25-leetcode122/Tony the Cyclist.md new file mode 100644 index 000000000..36c812849 --- /dev/null +++ b/2018.12.25-leetcode122/Tony the Cyclist.md @@ -0,0 +1,13 @@ +```python +class Solution(object): + def maxProfit(self, prices): + """ + :type prices: List[int] + :rtype: int + """ + profile = 0 + for i in range(1, len(prices)): + if prices[i] > prices[i-1]: + profile += prices[i] - prices[i-1] + return profile +``` diff --git a/2018.12.25-leetcode122/sourcema.md b/2018.12.25-leetcode122/sourcema.md new file mode 100644 index 000000000..1b84f30a9 --- /dev/null +++ b/2018.12.25-leetcode122/sourcema.md @@ -0,0 +1,15 @@ +# LeetCode 122 + class Solution { + public int maxProfit(int[] prices) {//只要有差价就进行交易 + if (prices==null||prices.length==0||prices.length==1) { + return 0; + } + int res=0; + for (int i = 0; i < prices.length-1; i++) { + if (prices[i+1]-prices[i]>0) { + res+=prices[i+1]-prices[i]; + } + } + return res; + } +} diff --git "a/2018.12.25-leetcode122/\345\210\230\346\266\246\346\263\275(capture).md" "b/2018.12.25-leetcode122/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..7d5322cc6 --- /dev/null +++ "b/2018.12.25-leetcode122/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,34 @@ +```java + public static int maxProfit(int[] prices) { + + int profit=0; + int buyPosition=0; + boolean isbuy = false; //还没有买入 + + for (int i=0;i=prices[i+1]){ + + isbuy=false; + profit=profit+(prices[i]-prices[buyPosition]); + continue; + } + if (i==prices.length-2&&isbuy){ + return profit+(prices[prices.length-1]-prices[buyPosition]); + } + + continue; + + } + + return profit; + } +``` diff --git "a/2018.12.25-leetcode122/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.25-leetcode122/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..61d3a7cac --- /dev/null +++ "b/2018.12.25-leetcode122/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,11 @@ +class Solution { + public int maxProfit(int[] prices) { + int res = 0; + for(int i = 1; i < prices.length; i++){ + if(prices[i] > prices[i-1]){ + res += prices[i] - prices[i-1]; + } + } + return res; + } +} diff --git "a/2018.12.25-leetcode122/\345\246\256\345\217\257.md" "b/2018.12.25-leetcode122/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..7fcf8f5d8 --- /dev/null +++ "b/2018.12.25-leetcode122/\345\246\256\345\217\257.md" @@ -0,0 +1,56 @@ +``` +package sy181230; + +/** + * @author suyuan + *给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 + +设计一个算法来计算你所能获取的最大利润。你可以尽可能地完成更多的交易（多次买卖一支股票）。 + +注意：你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。 + +示例 1: + +输入: [7,1,5,3,6,4] +输出: 7 +解释: 在第 2 天（股票价格 = 1）的时候买入，在第 3 天（股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 随后，在第 4 天（股票价格 = 3）的时候买入，在第 5 天（股票价格 = 6）的时候卖出, 这笔交易所能获得利润 = 6-3 = 3 。 +示例 2: + +输入: [1,2,3,4,5] +输出: 4 +解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。 + 注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。 + 因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。 +示例 3: + +输入: [7,6,4,3,1] +输出: 0 +解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 + */ +public class leetcode_122买卖股票的最佳时机II +{ + + public static void main(String[] args) + { + int[] prices=new int[]{7,1,5,3,6,4}; + System.out.println(maxProfit(prices)); + + } + + //一直贪呀 + public static int maxProfit(int[] prices) + { + if(prices == null || prices.length<2) + return 0; + int max=0; + for(int i=1;iprices[i-1]) + max+=prices[i]-prices[i-1]; + } + return max; + } + +} +``` diff --git a/2018.12.26-leetcode53/Be a fresh man.md b/2018.12.26-leetcode53/Be a fresh man.md new file mode 100644 index 000000000..c7980049e --- /dev/null +++ b/2018.12.26-leetcode53/Be a fresh man.md @@ -0,0 +1,105 @@ +## 053_(最大子序和)Maximum Subarray +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。
+__进阶__: +如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。 + +### 1.2 输入与输出 +输入： +* vector< int>& nums：给定的整数数组 nums + +输出： +* int：最大子序和 + +### 1.3 样例 +#### 1.3.1 样例1 +输入: [-2,1,-3,4,-1,2,1,-5,4],
+输出: 6
+解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 + +## 2 思路描述与代码 +### 2.1 思路描述（在线处理法） +其思想是如果当前累加的和 this_sum < 0，那么其肯定不会使得后续的子序和更大，所以累加值 this_sum 置 0 重新累加。 +```cpp +len_nums 为输入数组的长度 +max_sum 为记录的最大和 +this_sum 记录当前累加的结果 +for( i = 0; i < len_nums; i++ ){ + this_sum += nums[i]; + max_sum = max(max_sum, this_sum); + if(this_sum < 0) this_sum = 0; +} +``` +### 2.2 代码 +```cpp +class Solution { +public: + const int MIN = -2147483648; + int maxSubArray(vector& nums) { + return maxSubArray_online_processing(nums); + } + //在线处理 + int maxSubArray_online_processing(const vector& nums){ + int len_nums = nums.size(); + int max_sum = MIN; + int this_sum = 0; + for( int i = 0; i < len_nums; i++ ){ + this_sum += nums[i]; + max_sum = max(max_sum, this_sum); + if(this_sum < 0) this_sum = 0; + } + return max_sum; + } +}; +``` +## 3 思考与拓展 +### 3.1 思考 +在线处理的时间复杂度为O(n)，此外还有一种方法叫做分治，其空间复杂度为O(nlogn)，二者的思想都值得细细回味。 +#### 3.1.1 其他方法 +##### 3.1.1.1 分治法 +分治主要有两个步骤，分和治。
+把输入的 nums 数组一分为2，递归求左半部分最大子序和 left_max，递归求右半部分的最大子序和right_max，一遍扫描求跨越中间节点的最大子序和 across_mid_max，三者的最大值即为最大子序和。 +```cpp +class Solution { +public: + const int MIN = -2147483648; + int maxSubArray(vector& nums) { + return maxSubArray_divideAndConquer(nums, 0, nums.size() - 1); + } + int maxSubArray_divideAndConquer(const vector& nums, const int start, const int end){ + if(start == end) return nums[start]; + int mid = (start + end) / 2; + //获取左、右部分最大值 + int left_max = maxSubArray_divideAndConquer(nums, start, mid); + int right_max = maxSubArray_divideAndConquer(nums, mid + 1, end); + //获取中间最大值 + int left_across_mid_max = MIN; + int left_across_mid_sum = 0; + for( int i = mid; i >= start; i-- ){ + left_across_mid_sum += nums[i]; + left_across_mid_max = max(left_across_mid_max, left_across_mid_sum); + } + int right_across_mid_max = MIN; + int right_across_mid_sum = 0; + for( int i = mid + 1; i <= end; i++ ){ + right_across_mid_sum += nums[i]; + right_across_mid_max = max(right_across_mid_max, right_across_mid_sum); + } + int across_mid_max = left_across_mid_max + right_across_mid_max; + return max(left_max, max(right_max, across_mid_max)); + } +}; +``` + +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +在线处理法|O(1)|O(n) +分治法|O(n)|O(nlogn) +#### 3.1.3 难点分析 +1. 在线处理法需要理解如果当前累加的和 this_sum < 0，那么其肯定不会使得后续的子序和更大； +2. 分治法需要考虑三种可能的最大子列和情况 + +### 3.2 拓展 +本题可以有很多变形，可以尝试[最小子序列和](https://blog.csdn.net/u011493189/article/details/52409375)。 diff --git a/2018.12.26-leetcode53/Ostrichcrab.md b/2018.12.26-leetcode53/Ostrichcrab.md new file mode 100644 index 000000000..83aa24bf9 --- /dev/null +++ b/2018.12.26-leetcode53/Ostrichcrab.md @@ -0,0 +1,17 @@ +``` +class Solution { +public: + int maxSubArray(vector& nums) { + int size = nums.size(); + vector dp(size+1); + dp[0] = nums[0]; + int ans = nums[0]; + for(int i = 1; i0) dp[i]=nums[i]+dp[i-1]; + else dp[i] = nums[i]; + ans = max(ans,dp[i]); + } + return ans; + } +}; +``` diff --git a/2018.12.26-leetcode53/TheRocket.md b/2018.12.26-leetcode53/TheRocket.md new file mode 100644 index 000000000..975922d1b --- /dev/null +++ b/2018.12.26-leetcode53/TheRocket.md @@ -0,0 +1,13 @@ +```java +class Solution { + public int maxSubArray(int[] nums) { + int maxSum = nums[0]; + int curSum = nums[0]; + for (int i = 1; i < nums.length; ++i) { + curSum = curSum > 0 ? curSum + nums[i] : nums[i]; + maxSum = Math.max(maxSum, curSum); + } + return maxSum; + } +} +``` diff --git a/2018.12.26-leetcode53/Tony the Cyclist.md b/2018.12.26-leetcode53/Tony the Cyclist.md new file mode 100644 index 000000000..e020f0ff5 --- /dev/null +++ b/2018.12.26-leetcode53/Tony the Cyclist.md @@ -0,0 +1,16 @@ +```java +class Solution { + public int maxSubArray(int[] nums) { + int [] n = new int[nums.length]; + n[0] = nums[0]; + for (int i = 1; i < nums.length; i++){ + nums[i] = (nums[i] + nums[i-1]) < nums[i]? nums[i]: (nums[i] + nums[i-1]); + } + int max = nums[0]; + for (int i = 1; i < nums.length; i++){ + max = nums[i] > max? nums[i]: max; + } + return max; + } +} +``` diff --git a/2018.12.26-leetcode53/WYJ.md b/2018.12.26-leetcode53/WYJ.md new file mode 100644 index 000000000..041915ea7 --- /dev/null +++ b/2018.12.26-leetcode53/WYJ.md @@ -0,0 +1,38 @@ +```java +class Solution { + public int maxSubArray(int[] nums) { + return findMaxSub(nums, 0, nums.length - 1); + } + public int findMaxSub(int[] nums, int begin, int end){ + if(begin == end){ + return nums[begin]; + } + else{ + int mid = (begin + end) / 2; + int leftSum = findMaxSub(nums, begin, mid); + int rightSum = findMaxSub(nums, mid + 1, end); + int crossSum = findMaxCrossing(nums, begin, mid, end); + return Math.max(Math.max(leftSum, rightSum), crossSum); + } + } + public int findMaxCrossing(int[] nums, int begin, int mid, int end){ + int leftSum = Integer.MIN_VALUE; + int sum = 0; + for(int i = mid; i >= begin; i--){ + sum += nums[i]; + if(sum > leftSum){ + leftSum = sum; + } + } + int rightSum = Integer.MIN_VALUE; + sum = 0; + for(int i = mid + 1; i <= end; i++){ + sum += nums[i]; + if(sum > rightSum){ + rightSum = sum; + } + } + return leftSum + rightSum; + } +} +``` diff --git a/2018.12.26-leetcode53/sourcema.md b/2018.12.26-leetcode53/sourcema.md new file mode 100644 index 000000000..c98ad1f38 --- /dev/null +++ b/2018.12.26-leetcode53/sourcema.md @@ -0,0 +1,15 @@ +# LeetCode 53 + class Solution { + public int maxSubArray(int[] nums) {//简单的dp思想，如果累加和<0，保存最大值，重新进行累加 + if (nums == null || nums.length == 0) { + return 0; + } + int sum=0,max=Integer.MIN_VALUE; + for (int i = 0; i < nums.length; i++) { + sum += nums[i]; + max = Math.max(sum, max); + sum=sum<0?0:sum; + } + return max; + } +} diff --git "a/2018.12.26-leetcode53/\345\210\230\346\266\246\346\263\275(capture).md" "b/2018.12.26-leetcode53/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..56d16a39a --- /dev/null +++ "b/2018.12.26-leetcode53/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,24 @@ +```java + /** + * 时间复杂度为O(n) + **/ + public static int maxSubArray(int[] nums) { + + int maxSubArray=nums[0]; + int tempSubArray=nums[0]; + + for (int i=1;imaxSubArray)maxSubArray=tempSubArray; + if (i==nums.length-1) return maxSubArray; + + } + + return maxSubArray; + } +``` diff --git "a/2018.12.26-leetcode53/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.26-leetcode53/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..6c36abac1 --- /dev/null +++ "b/2018.12.26-leetcode53/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,15 @@ +class Solution { + public int maxSubArray(int[] nums) { + int res = Integer.MIN_VALUE; + int max = 0; + for(int i = 0; i < nums.length; i++){ + if(max > 0) { + max += nums[i]; + }else{ + max = nums[i]; + } + if(res < max) res = max; + } + return res; + } +} diff --git "a/2018.12.26-leetcode53/\345\246\256\345\217\257.md" "b/2018.12.26-leetcode53/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..4f06e386d --- /dev/null +++ "b/2018.12.26-leetcode53/\345\246\256\345\217\257.md" @@ -0,0 +1,42 @@ +``` +package sy181230; + +/** + * @author suyuan + 给定一个整数数组 nums ，找到一个具有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 + +示例: + +输入: [-2,1,-3,4,-1,2,1,-5,4], +输出: 6 +解释: 连续子数组 [4,-1,2,1] 的和最大，为 6。 +进阶: + +如果你已经实现复杂度为 O(n) 的解法，尝试使用更为精妙的分治法求解。 + */ +public class leetcode_53最大子序和 +{ + + public static void main(String[] args) + { + int[] nums=new int[]{-2,1,-3,4,-1,2,1,-5,4}; + System.out.println(maxSubArray(nums)); + + } + + public static int maxSubArray(int[] nums) + { + if(nums==null ) + return 0; + int sum=nums[0]; + int max=nums[0]; + for(int i=1;i 给定整数数组 nums ，找到一个有最大和的连续子数组（子数组最少包含一个元素），返回其最大和。 + +**例子** +> Input: [-2,1,-3,4,-1,2,1,-5,4], +Output: 6 +Explanation: [4,-1,2,1] has the largest sum = 6. + +**思想** +贪心。记录到当前位置的和，只要和大于0，则继续和后面相加；否则summ置0。 + +**解法** +```python +class Solution(object): + def maxSubArray(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + res = summ = nums[0] + for num in nums[1:]: + if summ < 0: + summ = 0 + summ += num + res = max(res, summ) + return res +``` \ No newline at end of file diff --git a/2018.12.27-leetcode121/Be a fresh man.md b/2018.12.27-leetcode121/Be a fresh man.md new file mode 100644 index 000000000..ea775d8dc --- /dev/null +++ b/2018.12.27-leetcode121/Be a fresh man.md @@ -0,0 +1,76 @@ +## 121_(买卖股票的最佳时机)Best Time to Buy and Sell Stock +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。
+如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。
+注意你不能在买入股票前卖出股票。 +### 1.2 输入与输出 +输入： +* vector& prices:长度可变的价格数组prices + +输出： +* int:所能获取的最大利润 +### 1.3 样例 +#### 1.3.1 样例1 +输入: [7,1,5,3,6,4]
+输出: 5
+解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 + 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 +#### 1.3.2 样例2 +输入: [7,6,4,3,1] +输出: 0 +解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 +## 2 思路描述与代码 +### 2.1 思路描述（动态规划法） +dp[i] 表示为第 i + 1 天可获得的最大利润; +此时最大利润可能是下述两种情况： +1. 当前卖出的的情况是prices[i]-最低价 +2. 不是当天卖出的情况是dp[i-1] +于是dp[i] = max(prices[i]-最低价, dp[i-1]);
+dp中只与前一个元素有关，可以写成简化空间复杂度的写法:max_profit = max(prices[i]-最低价, max_profit)。 + +比如输入: [7,1,5,3,6,4];
+i = 0, min_price = 7, dp[0] = 0;
+i = 1, min_price = 1, dp[1] = min(0, 0) = 0;
+i = 2, min_price = 1, dp[2] = min(5 - 1, 0) = 4;
+i = 3, min_price = 1, dp[3] = min(3 - 1, 4) = 4;
+i = 4, min_price = 1, dp[4] = min(6 - 1, 4) = 5;
+i = 5, min_price = 1, dp[5] = min(4 - 1, 5) = 5;
+### 2.2 代码 +```cpp +//函数中涉及到的c++知识 +//vector 是个长度可变的 int 数组，c++里面称为容器 +int maxProfit(vector& prices) { + int len = prices.size(); + //边界情况 + if(len == 0) return 0; + + //当前最大的利益 = max(前一天可能的最大利益, 今天的价钱-最低价) + int max_profit = -2147483648; + int min_price = 2147483647; + for( int i = 0; i < prices.size(); i++ ){ + min_price = min(min_price, prices[i]); + max_profit = max(max_profit, prices[i] - min_price); + } + return max_profit; +} +``` +## 3 思考与拓展 +### 3.1 思考 +本题通过分析在第 x 天可能卖出的最大收益的情况可以很快推出动态规划的递推表达式，然后再做空间的简化即可。 +#### 3.1.1 其他方法 +#### 3.1.1.1 差分+最大连续子列和 +1. 先求差分数组 +2. 求差分数组中的最大连续子列和 + +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +动态规划法|O(1)|O(n) +差分+最大连续子列和|O(n)|O(n) +#### 3.1.3 难点分析 +1. 求递归表达式 +2. 简化空间复杂度 + +### 3.2 拓展 +1. [买卖股票的最佳时机 II](https://leetcode-cn.com/problems/best-time-to-buy-and-sell-stock-ii/)。 diff --git a/2018.12.27-leetcode121/Ostrichcrab.md b/2018.12.27-leetcode121/Ostrichcrab.md new file mode 100644 index 000000000..9f3d933a8 --- /dev/null +++ b/2018.12.27-leetcode121/Ostrichcrab.md @@ -0,0 +1,16 @@ +``` +class Solution { +public: + int maxProfit(vector& prices) { + int ans = 0; + int size = prices.size(); + if(size==0) return 0; + int minn = prices[0]; + for(int i = 1; i < size; i++){ + ans = ans > prices[i]-minn ? ans : prices[i]-minn; + minn = minn > prices[i] ? prices[i] : minn; + } + return ans; + } +}; +``` diff --git a/2018.12.27-leetcode121/TheRocket.md b/2018.12.27-leetcode121/TheRocket.md new file mode 100644 index 000000000..e9c2fdcfe --- /dev/null +++ b/2018.12.27-leetcode121/TheRocket.md @@ -0,0 +1,16 @@ +```java +class Solution { + public int maxProfit(int[] prices) { + if (prices == null || prices.length <= 1) { + return 0; + } + int res = 0; + int minPrice = prices[0]; + for (int price : prices) { + minPrice = Math.min(minPrice, price); + res = Math.max(res, price - minPrice); + } + return res; + } +} +``` diff --git a/2018.12.27-leetcode121/Tony the Cyclist.md b/2018.12.27-leetcode121/Tony the Cyclist.md new file mode 100644 index 000000000..5889e45d6 --- /dev/null +++ b/2018.12.27-leetcode121/Tony the Cyclist.md @@ -0,0 +1,15 @@ +```java +class Solution { + public int maxProfit(int[] prices) { + int maxn = 0; + int minn = 100000; + int dest = 0; + for(int i = 0; i < prices.length; i++){ + minn = minn < prices[i]? minn: prices[i]; + maxn = prices[i]; + dest = maxn-minn > dest? maxn-minn: dest; + } + return dest; + } +} +``` diff --git a/2018.12.27-leetcode121/WYJ.md b/2018.12.27-leetcode121/WYJ.md new file mode 100644 index 000000000..e82da9e27 --- /dev/null +++ b/2018.12.27-leetcode121/WYJ.md @@ -0,0 +1,45 @@ +```java +class Solution { + public int maxProfit(int[] prices) { + if(prices.length <= 1){ + return 0; + } + for(int i = prices.length - 1; i > 0; i--){ + prices[i] = prices[i] - prices[i - 1]; + } + prices[0] = 0; + return maxSubProfit(prices, 0, prices.length - 1); + } + public int maxSubProfit(int[] prices, int begin, int end){ + if(begin == end){ + return prices[begin]; + } + else{ + int mid = (begin + end) / 2; + int leftSum = maxSubProfit(prices, begin, mid); + int rightSum = maxSubProfit(prices, mid + 1, end); + int crossSum = maxCrossProfit(prices, begin, mid, end); + return Math.max(Math.max(leftSum, rightSum), crossSum); + } + } + public int maxCrossProfit(int[] prices, int begin, int mid, int end){ + int leftSum = Integer.MIN_VALUE; + int sum = 0; + for(int i = mid; i >= begin; i--){ + sum += prices[i]; + if(sum > leftSum){ + leftSum = sum; + } + } + int rightSum = Integer.MIN_VALUE; + sum = 0; + for(int i = mid + 1; i <= end; i++){ + sum += prices[i]; + if(sum > rightSum){ + rightSum = sum; + } + } + return leftSum + rightSum; + } +} +``` diff --git a/2018.12.27-leetcode121/sourcema.md b/2018.12.27-leetcode121/sourcema.md new file mode 100644 index 000000000..de418a3cf --- /dev/null +++ b/2018.12.27-leetcode121/sourcema.md @@ -0,0 +1,23 @@ +# LeetCode 121 + class Solution { + public int maxProfit(int[] stocks) {//找数组中前后差值最大的结果 + if (stocks.length == 0 || stocks == null) { + return 0; + } + int[] mins = new int[stocks.length]; + int[] maxs = new int[stocks.length]; + mins[0] = stocks[0]; + maxs[stocks.length-1] = stocks[stocks.length-1]; + int res=Integer.MIN_VALUE; + for (int i = 1; i < stocks.length; i++) { + mins[i] = Math.min(mins[i - 1], stocks[i]); + } + for (int i =stocks.length-2 ; i >=0; i--) { + maxs[i] = Math.max(maxs[i + 1], stocks[i]); + } + for (int i = 0; i < stocks.length; i++) { + res = Math.max(res, maxs[i] - mins[i]); + } + return res; + } +} diff --git "a/2018.12.27-leetcode121/\345\210\230\346\266\246\346\263\275(capture).md" "b/2018.12.27-leetcode121/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..b5cdc07c7 --- /dev/null +++ "b/2018.12.27-leetcode121/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,18 @@ +```java + public int maxProfit(int[] prices) { + + int maxProfit=0; + int tempProfit=0; + + for (int i=1;i0){ + tempProfit=tempProfit+(prices[i]-prices[i-1]); + if(tempProfit>maxProfit) maxProfit=tempProfit; + }else{ + tempProfit=0;} + } + + return maxProfit; + } + +``` diff --git "a/2018.12.27-leetcode121/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.27-leetcode121/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..e3f7b984c --- /dev/null +++ "b/2018.12.27-leetcode121/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,15 @@ +class Solution { + public int maxProfit(int[] prices) { + int res = 0; + int max = 0; + for(int i = 1; i < prices.length; i++){ + if(max > 0){ + max += prices[i] - prices[i-1]; + } else { + max = prices[i] - prices[i-1]; + } + if(res < max) res = max; + } + return res; + } +} diff --git "a/2018.12.27-leetcode121/\345\246\256\345\217\257.md" "b/2018.12.27-leetcode121/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..3d81de683 --- /dev/null +++ "b/2018.12.27-leetcode121/\345\246\256\345\217\257.md" @@ -0,0 +1,78 @@ +``` +package sy181230; + +/** + * @author suyuan + 给定一个数组，它的第 i 个元素是一支给定股票第 i 天的价格。 + +如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 + +注意你不能在买入股票前卖出股票。 + +示例 1: + +输入: [7,1,5,3,6,4] +输出: 5 +解释: 在第 2 天（股票价格 = 1）的时候买入，在第 5 天（股票价格 = 6）的时候卖出，最大利润 = 6-1 = 5 。 + 注意利润不能是 7-1 = 6, 因为卖出价格需要大于买入价格。 +示例 2: + +输入: [7,6,4,3,1] +输出: 0 +解释: 在这种情况下, 没有交易完成, 所以最大利润为 0。 + */ +public class leetcode_121买卖股票的最佳时机 +{ + + public static void main(String[] args) + { + int[] prices=new int[]{7,1,5,3,6,4}; + System.out.println(maxProfit2(prices)); + + + } + + //贪心 + public static int maxProfit(int[] prices) + { + //根据题意，我们只需要找出数组中最大的差值即可，即 max(prices[j] – prices[i]) ，i < j。 + if(prices == null || prices.length<2) + return 0; + int min=prices[0]; + int profit=0; + + for(int i=1;i 给定一个数组，第 i 个元素是给定股票第 i 天的价格。 +如果你最多只允许完成一笔交易（即买入和卖出一支股票），设计一个算法来计算你所能获取的最大利润。 +注意你不能在买入股票前卖出股票。 + +**例子** +> **Example 1:** +Input: [7,1,5,3,6,4] +Output: 5 +Explanation: Buy on day 2 (price = 1) and sell on day 5 (price = 6), profit = 6-1 = 5. + Not 7-1 = 6, as selling price needs to be larger than buying price. + +> **Example 2:** +Input: [7,6,4,3,1] +Output: 0 +Explanation: In this case, no transaction is done, i.e. max profit = 0. + +**思想** +记录到当前位置为止的最小购买价格buy。 +遍历数组，若price > buy，则记录当前卖出的利润；否则，buy = price。 + +**解法** +```python +class Solution(object): + def maxProfit(self, prices): + """ + :type prices: List[int] + :rtype: int + """ + if not prices: + return 0 + + res = 0 + buy = prices[0] # Record the min-buy up to this time + for price in prices[1:]: + if price > buy: + res = max(res, price - buy) + else: + buy = price + return res +``` \ No newline at end of file diff --git a/2018.12.28-leetcode69/Be a fresh man.md b/2018.12.28-leetcode69/Be a fresh man.md new file mode 100644 index 000000000..41abe369d --- /dev/null +++ b/2018.12.28-leetcode69/Be a fresh man.md @@ -0,0 +1,67 @@ +## 069_(x的平方根)Sqrt(x) +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +实现 int sqrt(int x) 函数。
+计算并返回 x 的平方根，其中 x 是非负整数。
+由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。
+### 1.2 输入与输出 +输入： +* int x:求 x 的平方根 + +输出： +* int: x 的平方根 +### 1.3 样例 +#### 1.3.1 样例1 +输入: 4
+输出: 2
+#### 1.3.2 样例2 +输入: 8
+输出: 2
+解释: 8 的平方根是 2.82842...,
+ 由于返回类型是整数，小数部分将被舍去。
+## 2 思路描述与代码 +### 2.1 思路描述（牛顿迭代方法） +令f(t) = x - t^2
+相当于求 f(t) = 0 时的 t(t >= 0)
+利用牛顿迭代公式可以求得 t_new = (t + x/t) / 2
+迭代直到 abs(t_new * t_new - x) 小于指定的精度，然后返回 (int)t_new
+### 2.2 代码 +```cpp +double pricision = 0.00001; +int mySqrt(int x) { + double y = 1.0 * x; + double sqrt_y = 1; + while( abs(y - sqrt_y * sqrt_y) > pricision ){ + sqrt_y = (sqrt_y + y / sqrt_y) / 2; + } + return (int)sqrt_y; +} +``` +## 3 思考与拓展 +### 3.1 思考 +#### 3.1.1 其他方法 +##### 3.1.1.1 二分法 +取左边界 left 为 0， 右边界 right 为 x / 2
+然后算 mid = (left + right) / 2
+如果 mid * mid < x 则扩大左边界 left 为 mid
+否则 扩大右边界 right 为 mid
+重复上述过程直到 abs(mid * mid - x) 小于指定的精度，然后返回 (int)mid
+ +##### 3.1.1.2 平方数判定法 +1 = 1
+1 + 3 = 2^2
+1 + 3 + 5 = 3^2
+1 + 3 + 5 + 7 = 4^2
+... ...
+1 + 3 + 5 + 7 + ... + 2*n-1 = n^2
+可以看出如果求其平方根就是不断减去递增的奇数直到为0，此时减去奇数的次数就是他的平方根。 +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +二分法|O(1)|O(logx) +平方数判定法|O(1)|O(x^(1/2)) +牛顿迭代方法|O(1)|一般比上述两种方法好，收敛速度快 +#### 3.1.3 难点分析 +1. 推理牛顿迭代的公式。 +### 3.2 拓展 +如果让你求 x 的立方根呢？ diff --git a/2018.12.28-leetcode69/Ostrichcrab.md b/2018.12.28-leetcode69/Ostrichcrab.md new file mode 100644 index 000000000..40fc393b0 --- /dev/null +++ b/2018.12.28-leetcode69/Ostrichcrab.md @@ -0,0 +1,59 @@ +``` +class Solution { +public: + int mySqrt(int x) { + return sqrt(x); + } +}; +-------------------------------------- +class Solution { +public: + int mySqrt(int x) { + double pre = 0; + double cur = x; + while(abs(cur-pre)>0.000001){ + pre = cur; + cur = (pre/2+x/(2*pre)); + } + return int(cur); + } +}; +----------------------------------------- + +class Solution +{ +public: + int mySqrt(int x) + { + //数学大神根据牛顿迭代法来求推导出的神奇方法 + assert(x >= 0); + if (x == 0 || x == 1) + { + return x; + } + float tmp = x; + float xhalf = 0.5f*tmp; + int i = *(int*)&tmp; + + i = 0x5f375a86 - (i >> 1); // 这一步是关键 + + tmp = *(float*)&i; + tmp = tmp*(1.5f - xhalf*tmp*tmp); + tmp = tmp*(1.5f - xhalf*tmp*tmp); + tmp = tmp*(1.5f - xhalf*tmp*tmp); + + int ret = 1 / tmp; + if (ret*ret > x) + { + return ret - 1; + } + return ret; + } +}; +---------------------------------------------------- +int x = []() { + std::ios::sync_with_stdio(false); + std::cin.tie(nullptr); + return 0; +}(); +``` diff --git a/2018.12.28-leetcode69/TheRocket.md b/2018.12.28-leetcode69/TheRocket.md new file mode 100644 index 000000000..041788aed --- /dev/null +++ b/2018.12.28-leetcode69/TheRocket.md @@ -0,0 +1,11 @@ +```java +class Solution { + public int mySqrt(int x) { + long r = x; + while (r * r > x) { + r = (r + x / r) / 2; + } + return (int) r; + } +} +``` diff --git a/2018.12.28-leetcode69/Tony the Cyclist.md b/2018.12.28-leetcode69/Tony the Cyclist.md new file mode 100644 index 000000000..a021014ca --- /dev/null +++ b/2018.12.28-leetcode69/Tony the Cyclist.md @@ -0,0 +1,27 @@ +```java +class Solution { + public int mySqrt(int x) { + if (x == 0) { + return 0; + } + if (x == 1) { + return 1; + } + int low = 0; + int high = x/2 + 1; + while (low <= high){ + int mid = (low + high) / 2; + if (mid < x/mid){ + low = mid + 1; + } + else if (mid> x/mid){ + high=mid-1; + } + else{ + return mid; + } + } + return low-1; + } +} +``` diff --git a/2018.12.28-leetcode69/sourcema.md b/2018.12.28-leetcode69/sourcema.md new file mode 100644 index 000000000..c5dfb909d --- /dev/null +++ b/2018.12.28-leetcode69/sourcema.md @@ -0,0 +1,24 @@ +# LeetCode 69 + class Solution { + public int mySqrt(int n) { + if (n == 0) { + return 0; + } + if (n == 1) { + return 1; + } + int left=0; + int right=n; + while (left<=right) { + int mid=(left+right)/2; + if (mid < n/mid) { + left=mid+1; + } else if (mid> n/mid) { + right=mid-1; + } else { + return mid; + } + } + return left-1; + } +} diff --git "a/2018.12.28-leetcode69/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.28-leetcode69/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..73ea4070f --- /dev/null +++ "b/2018.12.28-leetcode69/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,21 @@ +class Solution { + public int mySqrt(int x) { + if(x == 0) return 0; + int low=1; + int hi=x/2+1; + while(low+1x/mid){ + hi=mid; + } + else if(mid= i) && (x/(i+1))<(i+1)) + { + res=i; + break; + } + } + return res; + } + + public static int mySqrt(int x) + { + int mid; + int left=1; + int right=x; + int res=0; + while(left<=right) + { + mid=(left+right)>>1; + if(mid<=x/mid) + { + left=mid+1; + res=mid; + } + else + { + right=mid-1; + } + } + return res; + } + +} +``` diff --git "a/2018.12.28-leetcode69/\346\235\216\347\242\247\346\266\265.md" "b/2018.12.28-leetcode69/\346\235\216\347\242\247\346\266\265.md" new file mode 100644 index 000000000..49c4b2d96 --- /dev/null +++ "b/2018.12.28-leetcode69/\346\235\216\347\242\247\346\266\265.md" @@ -0,0 +1,42 @@ +#### [69. Sqrt(x)](https://leetcode.com/problems/sqrtx/) +**题目描述** +> 实现 int sqrt(int x) 函数。 +计算并返回 x 的平方根，其中 x 是非负整数。 +由于返回类型是整数，结果只保留整数的部分，小数部分将被舍去。 + +**例子** +> **Example 1:** +Input: 4 +Output: 2 + +> **Example 2:** +Input: 8 +Output: 2 +Explanation: The square root of 8 is 2.82842..., and since the decimal part is truncated, 2 is returned. + +**思想** +int(x**0.5) +二分，注意循环的条件以及最后return的值。如果只让left = mid的话，会造成死循环。 + +**解法** +```python +class Solution: + def mySqrt(self, x): + """ + :type x: int + :rtype: int + """ + if x < 2: + return x + + left, right = 0, x//2 + while left <= right: + mid = (left + right) >> 1 + if mid * mid == x: + return mid + if mid * mid > x: + right = mid - 1 + else: + left = mid + 1 + return left - 1 +``` \ No newline at end of file diff --git a/2018.12.29-leetcode744/Be a fresh man.md b/2018.12.29-leetcode744/Be a fresh man.md new file mode 100644 index 000000000..fa11f9c13 --- /dev/null +++ b/2018.12.29-leetcode744/Be a fresh man.md @@ -0,0 +1,99 @@ +## 744_(寻找比目标字母大的最小字母)Find Smallet Letter Greater Than Target +## 1 问题描述、输入输出与样例 +### 1.1 问题描述 +给定一个只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。 +数组里字母的顺序是循环的。
+举个例子，如果目标字母target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。 + +__注__: +1. letters长度范围在[2, 10000]区间内。 +2. letters 仅由小写字母组成，最少包含两个不同的字母。 +3. 目标字母target 是一个小写字母。 +### 1.2 输入与输出 +输入： +* vector<_char_>& letters:只包含小写字母的有序数组letters +* char target:目标字母 + +输出： +* char:有序数组里面比目标字母大的最小字母 +### 1.3 样例 +#### 1.3.1 样例1 +输入:
+letters = ["c", "f", "j"]
+target = "a"
+输出: "c" +#### 1.3.2 样例2 +输入: +letters = ["c", "f", "j"]
+target = "c"
+输出: "f"
+#### 1.3.3 样例3 +输入:
+letters = ["c", "f", "j"]
+target = "d"
+输出: "f" +#### 1.3.4 样例4 +输入:
+letters = ["c", "f", "j"]
+target = "g"
+输出: "j" +#### 1.3.5 样例5 +输入:
+letters = ["c", "f", "j"]
+target = "j"
+输出: "c" +#### 1.3.6 样例6 +输入:
+letters = ["c", "f", "j"]
+target = "k"
+输出: "c" + +## 2 思路描述与代码 +### 2.1 思路描述（两遍扫描法） +1. 第一遍扫描记录出现的字符 +2. 第二遍从目标字符的下一个字符开始环形扫描出现的第一个字母 + +比如输入：letters = ["c", "f", "j"]，target = "j"
+第一遍扫描后有:dict["c"]=1, dict["f"]=1, dict["j"]=1, 其余字符的dict都是0; +第二遍扫描从 "h" 开始环形扫描，扫到 "c" 时发现其出现过，于是返回 "c" 。 +### 2.2 代码 +```cpp +//函数中涉及到的c++知识 +//vector 是个长度可变的 char 数组，c++里面称为容器 +//vector 是个长度可变的 int 数组，c++里面称为容器 +//vector dict(26, 0) 初始化包含26个元素的可变数组为0 +char nextGreatestLetter(vector& letters, char target) { + //字符初始化为未出现 + vector dict(26, 0); + //一遍扫描记录出现的字符 + int cnt_valid_letter = 0; + int len = letters.size(); + for( int i = 0; i < len; i++ ){ + if(cnt_valid_letter == 26) continue; + if(dict[letters[i] - 'a'] == 0){ + dict[letters[i] - 'a'] = 1; + cnt_valid_letter++; + } + } + //环形扫描比目标字母大的最小字母 + int start = (target - 'a' + 1) % 26; + for( int i = 0; i < 26; i++ ){ + if(dict[(i+start)%26]) return ((i+start)%26+'a'); + } + return -1; +} +``` +## 3 思考与拓展 +### 3.1 思考 +本题利用求模操作实现环形扫描，再配合常见的两遍扫描法即可解决该问题。 +#### 3.1.1 其他方法 +无。 +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +两遍扫描法|O(1)|O(n) +#### 3.1.3 难点分析 +1. 实现环形扫描 + +### 3.2 拓展 +如果给你的数据是链表或者数组数据呢？ diff --git a/2018.12.29-leetcode744/Ostrichcrab.md b/2018.12.29-leetcode744/Ostrichcrab.md new file mode 100644 index 000000000..38f4f1ad6 --- /dev/null +++ b/2018.12.29-leetcode744/Ostrichcrab.md @@ -0,0 +1,15 @@ +``` +int x = []() { + std::ios::sync_with_stdio(false); + std::cin.tie(nullptr); + return 0; +}(); +class Solution { +public: + char nextGreatestLetter(vector& letters, char target) { + int index = upper_bound(letters.begin(),letters.end(),target)-letters.begin(); + if(index == letters.size()) index = 0; + return letters[index]; + } +}; +``` diff --git a/2018.12.29-leetcode744/TheRocket.md b/2018.12.29-leetcode744/TheRocket.md new file mode 100644 index 000000000..365f3d8a2 --- /dev/null +++ b/2018.12.29-leetcode744/TheRocket.md @@ -0,0 +1,17 @@ +```java +class Solution { + public char nextGreatestLetter(char[] letters, char target) { + int lo = 0; + int hi = letters.length; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if (target >= letters[mid]) { + lo = mid + 1; + } else { + hi = mid; + } + } + return lo == letters.length ? letters[0] : letters[lo]; + } +} +``` diff --git a/2018.12.29-leetcode744/Tony the Cyclist.md b/2018.12.29-leetcode744/Tony the Cyclist.md new file mode 100644 index 000000000..6cc343526 --- /dev/null +++ b/2018.12.29-leetcode744/Tony the Cyclist.md @@ -0,0 +1,13 @@ +```python +class Solution(object): + def nextGreatestLetter(self, letters, target): + """ + :type letters: List[str] + :type target: str + :rtype: str + """ + for x in letters: + if x >target: + return x + return letters[0] +``` diff --git a/2018.12.29-leetcode744/WYJ.md b/2018.12.29-leetcode744/WYJ.md new file mode 100644 index 000000000..1f070e235 --- /dev/null +++ b/2018.12.29-leetcode744/WYJ.md @@ -0,0 +1,20 @@ +```java +class Solution { + public char nextGreatestLetter(char[] letters, char target) { + + int distance = Integer.MAX_VALUE; + int index = -1; + for(int i = 0; i < letters.length; i++){ + int tempDis = (int)(letters[i] - target); + if(tempDis < 0){ + tempDis += 26; + } + if(tempDis > 0&&tempDis < distance){ + distance = tempDis; + index = i; + } + } + return letters[index]; + } +} +``` diff --git a/2018.12.29-leetcode744/YYT.md b/2018.12.29-leetcode744/YYT.md new file mode 100644 index 000000000..42d9bcac2 --- /dev/null +++ b/2018.12.29-leetcode744/YYT.md @@ -0,0 +1,40 @@ + /** + * 二分法 + * 因为比较太多运行时间也没有更短 + */ + public char nextGreatestLetter1(char[] letters, char target) { + int length = letters.length; + if (letters[0] - target < 0 && letters[length - 1] - target < 0){ + return letters[0]; + } + int start = 0; + int end = length - 1; + int binary = 0; + int distance = Integer.MAX_VALUE; + char res = ' '; + while (start <= end) { + binary = (start + end) / 2; + if (letters[binary] - target > 0){ + if (letters[binary] - target < distance){ + res = letters[binary]; + distance = letters[binary] - target; + } + if(end - start == 0){ + return res; + } + end = binary - 1; + }else { + start = binary + 1; + } + } + return res; + } + + public char nextGreatestLetter(char[] letters, char target) { + for (int i = 0; i < letters.length; i++) { + if (letters[i] - target > 0){ + return letters[i]; + } + } + return letters[0]; + } diff --git a/2018.12.29-leetcode744/sourcema.md b/2018.12.29-leetcode744/sourcema.md new file mode 100644 index 000000000..5cd553602 --- /dev/null +++ b/2018.12.29-leetcode744/sourcema.md @@ -0,0 +1,17 @@ +# LeetCode 744 + class Solution { + public char nextGreatestLetter(char[] letters, char target) {//简单的二分思路 + //test + int left=0; + int right=letters.length-1; + while(left<=right){ + int mid=(left+right)>>1; + if(letters[mid]>target){ + right=mid-1; + }else { + left=mid+1; + } + } + return letters[left%letters.length]; + } +} diff --git "a/2018.12.29-leetcode744/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" "b/2018.12.29-leetcode744/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" new file mode 100644 index 000000000..90ae2a5fb --- /dev/null +++ "b/2018.12.29-leetcode744/\345\210\251\347\210\252\345\276\267\351\262\201\344\274\212.md" @@ -0,0 +1,8 @@ +class Solution { + public char nextGreatestLetter(char[] letters, char target) { + int i = 0; + while(i < letters.length && letters[i++] <= target); + if(i == letters.length && letters[i-1] <= target) return letters[0]; + return letters[i-1]; + } +} diff --git "a/2018.12.29-leetcode744/\345\246\256\345\217\257.md" "b/2018.12.29-leetcode744/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..804e38bd0 --- /dev/null +++ "b/2018.12.29-leetcode744/\345\246\256\345\217\257.md" @@ -0,0 +1,83 @@ +``` +package sy190101; + +/** + * @author suyuan + * + 给定一个只包含小写字母的有序数组letters 和一个目标字母 target， + 寻找有序数组里面比目标字母大的最小字母。 + +数组里字母的顺序是循环的。举个例子，如果目标字母target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。 + +示例: + +输入: +letters = ["c", "f", "j"] +target = "a" +输出: "c" + +输入: +letters = ["c", "f", "j"] +target = "c" +输出: "f" + +输入: +letters = ["c", "f", "j"] +target = "d" +输出: "f" + +输入: +letters = ["c", "f", "j"] +target = "g" +输出: "j" + +输入: +letters = ["c", "f", "j"] +target = "j" +输出: "c" + +输入: +letters = ["c", "f", "j"] +target = "k" +输出: "c" +注: + +letters长度范围在[2, 10000]区间内。 +letters 仅由小写字母组成，最少包含两个不同的字母。 +目标字母target 是一个小写字母。 + */ +public class leetcode_744寻找比目标字母大的最小字母 +{ + + public static void main(String[] args) + { + char[] letters=new char[] {'c', 'f', 'j'}; + System.out.println(nextGreatestLetter(letters, 'c')); + + + } + // 给定一个只包含小写字母的有序数组letters 和一个目标字母 target， + // 寻找有序数组里面比目标字母大的最小字母。 + // 数组里字母的顺序是循环的。 + + //读题:有序数组 比目标字母大的最小字母 字母的顺序是循环的 + //二分 + public static char nextGreatestLetter(char[] letters, char target) + { + int mid; + int left=0; + int right=letters.length-1; + while(left<=right) + { + mid=(left+right)>>1; + if(letters[mid]<=target) + left=mid+1; + else + right=mid-1; + + } + return left 给定一只包含小写字母的有序数组letters 和一个目标字母 target，寻找有序数组里面比目标字母大的最小字母。 + +> 数组里字母的顺序是循环的。举个例子，如果目标字母target = 'z' 并且有序数组为 letters = ['a', 'b']，则答案返回 'a'。 + +**例子** +> Input:letters = ["c", "f", "j"] target = "a" +Output: "c" + +> Input:letters = ["c", "f", "j"] target = "c" +Output: "f" + +**思想** +给定的是有序列表，所以考虑二分：找到第一个比target大的元素。 +若未找到，说明列表元素都比target小。此时考虑wrap around，返回第一个元素即可。 + +**解法** +```python +class Solution(object): + def nextGreatestLetter(self, letters, target): + """ + :type letters: List[str] + :type target: str + :rtype: str + """ + left, right = 0, len(letters)-1 + while left <= right: + mid = (left + right) >> 1 + if letters[mid] <= target: + left = mid + 1 + else: + if mid == 0 or letters[mid-1] <= target: + return letters[mid] + right = mid - 1 + return letters[0] +``` \ No newline at end of file diff --git "a/2018.12.29-leetcode744/\346\243\225\346\246\210\346\240\221.md" "b/2018.12.29-leetcode744/\346\243\225\346\246\210\346\240\221.md" new file mode 100644 index 000000000..55244d555 --- /dev/null +++ "b/2018.12.29-leetcode744/\346\243\225\346\246\210\346\240\221.md" @@ -0,0 +1,29 @@ +``` +class Solution { + public char nextGreatestLetter(char[] letters, char target) { + if(letters.length==0||null==letters) return '\0'; + int left = 0; + int right = letters.length-1; + + while(lefttarget){ + right = mid; + } + } + return left==letters.length-1&&letters[left]<=target? letters[0]:letters[left]; + + /* + for(int i = 0;i& nums) { + int size = nums.size(); + int left = 0, right = size-1; + while(left> 1; + if(mid & 1){ + if(nums[mid] == nums[mid-1]) left = mid + 1; + else if(nums[mid] == nums[mid+1]) right = mid - 1; + else return nums[mid]; + }else{ + if(nums[mid] == nums[mid-1]) right = mid - 2; + else if(nums[mid] == nums[mid+1]) left = mid + 2; + else return nums[mid]; + } + } + return nums[left]; + } +}; +``` diff --git a/2018.12.30-leetcode540/TheRocket.md b/2018.12.30-leetcode540/TheRocket.md new file mode 100644 index 000000000..19bacb607 --- /dev/null +++ b/2018.12.30-leetcode540/TheRocket.md @@ -0,0 +1,20 @@ +```java +class Solution { + public int singleNonDuplicate(int[] nums) { + int lo = 0; + int hi = nums.length - 1; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if ((mid & 1) == 1) { + --mid; + } + if (nums[mid] == nums[mid + 1]) { + lo = mid + 2; + } else { + hi = mid; + } + } + return nums[lo]; + } +} +``` diff --git a/2018.12.30-leetcode540/Tony the Cyclist.md b/2018.12.30-leetcode540/Tony the Cyclist.md new file mode 100644 index 000000000..3c3343d78 --- /dev/null +++ b/2018.12.30-leetcode540/Tony the Cyclist.md @@ -0,0 +1,20 @@ +```python +class Solution(object): + def singleNonDuplicate(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + cot = 1 + pre = nums[0] + for i in range(1, len(nums), 1): + if nums[i] == pre: + cot += 1 + else: + if cot == 1: + return pre + else: + pre = nums[i] + cot = 1 + return nums[-1] +``` diff --git a/2018.12.30-leetcode540/WYJ.md b/2018.12.30-leetcode540/WYJ.md new file mode 100644 index 000000000..086bc8aa1 --- /dev/null +++ b/2018.12.30-leetcode540/WYJ.md @@ -0,0 +1,27 @@ +```java +class Solution { + public int singleNonDuplicate(int[] nums) { + int l = 0, r = nums.length - 1; + while(l < r){ + int mid = l + (r - l) / 2; + if(mid % 2 == 0){ + if(nums[mid] != nums[mid + 1]){ + r = mid; + } + else{ + l = mid + 2; + } + } + else{ + if(nums[mid] == nums[mid - 1]){ + l = mid + 1; + } + else{ + r = mid; + } + } + } + return nums[l]; + } +} +``` diff --git a/2018.12.30-leetcode540/lyan_dut.md b/2018.12.30-leetcode540/lyan_dut.md new file mode 100644 index 000000000..72e580554 --- /dev/null +++ b/2018.12.30-leetcode540/lyan_dut.md @@ -0,0 +1,48 @@ +```c++ +/* + * 540. 有序数组中的单一元素 + * https://leetcode-cn.com/problems/single-element-in-a-sorted-array/ + */ +/* + * 方法一: 二分查找 + */ +int MyLeetCode::singleNonDuplicate(vector &nums) { + int left = 0; + int right = nums.size()-1; + while (left < right){ + int mid = (left+right)/2; + int lremain; + int rremain; + if(nums[mid] == nums[mid-1]){ + lremain = (mid-1) - left; + rremain = right - mid; + if(lremain%2 == 0) + left = mid + 1; + else + right = mid - 2; + } + else if(nums[mid] == nums[mid+1]){ + lremain = mid - left; + rremain = right - (mid+1); + if(rremain%2 == 0) + right = mid - 1; + else + left = mid + 2; + } + else + left = mid; + } + return nums[left]; +} + +/* + * 方法二: 异或 + */ +int MyLeetCode::singleNonDuplicate(vector &nums) { + int res = 0; + for(int i=0; i>1; + if ((mid&1)==1) mid--; + if ( nums[mid] == nums[mid + 1]) { + start = mid + 2;//如果mid是--之后的值，mid+1 mid可能又回到原来的值可能造成死循环 + } else if ( mid-1>=0&&nums[mid] == nums[mid - 1]) { + end=mid-1; + } else { + return nums[mid]; + } + } + return nums[start]; + } +} diff --git "a/2018.12.30-leetcode540/\345\210\230\346\266\246\346\263\275(capture).md" "b/2018.12.30-leetcode540/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..2e05f1846 --- /dev/null +++ "b/2018.12.30-leetcode540/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,29 @@ +```java + public int singleNonDuplicate(int[] nums) { + if (nums.length==1) return nums[0]; + if (nums.length%2==0) return 0; + int mid; + int start=0; + int end=nums.length-1; + while(true){ + mid=(start+end)/2; + if (nums[mid]==nums[mid-1]&&(mid-start)%2==1) { + //该数一定在后面 + if ((end-start)==2) return nums[mid+1]; + start=mid+1; + }else if (nums[mid]==nums[mid+1]&&(mid-start)%2==1) { + //该数一定在前面 + if ((end-start)==2) return nums[mid-1]; + end=mid-1; + }else if (nums[mid]==nums[mid-1]&&(mid-start)%2!=1) { + //该数一定在前面 + end=mid; + }else if (nums[mid]==nums[mid+1]&&(mid-start)%2!=1) { + //该数一定在后面 + start=mid; + }else { + return nums[mid]; + } + } + } +``` diff --git "a/2018.12.30-leetcode540/\345\246\256\345\217\257.md" "b/2018.12.30-leetcode540/\345\246\256\345\217\257.md" new file mode 100644 index 000000000..5234b3655 --- /dev/null +++ "b/2018.12.30-leetcode540/\345\246\256\345\217\257.md" @@ -0,0 +1,58 @@ +``` +package sy190101; + +/** + * @author suyuan + 给定一个只包含整数的有序数组，每个元素都会出现两次，唯有一个数只会出现一次，找出这个数。 + +示例 1: + +输入: [1,1,2,3,3,4,4,8,8] +输出: 2 +示例 2: + +输入: [3,3,7,7,10,11,11] +输出: 10 +注意: 您的方案应该在 O(log n)时间复杂度和 O(1)空间复杂度中运行。 + */ +public class leetcode_540有序数组中的单一元素 +{ + + public static void main(String[] args) + { + int[] nums =new int[] {1,1,2,2,3,3,4,4,8}; + System.out.println(singleNonDuplicate(nums)); + + + } + + public static int singleNonDuplicate2(int[] nums) + { + int left=0; + int right=nums.length-1; + while(left>1; + //奇数 + if((mid&1) !=0) + mid--; + //找到,跳两格 + if(nums[mid]==nums[mid+1]) + left=mid+2; + else + right=mid; + } + return nums[left]; + } + + //无序还可以用异或,有序用有点浪费 + public static int singleNonDuplicate(int[] nums) + { + int res=0; + for(int i=0;i 给定一个只包含整数的有序数组。每个元素都会出现两次，只有一个数只会出现一次，找出这个数。 + +**例子** +> **Example 1:** +Input: [1,1,2,3,3,4,4,8,8] +Output: 2 + +> **Example 2:** +Input: [3,3,7,7,10,11,11] +Output: 10 + +**思想** +法1：异或操作，相同为0，相异为1。但是时间复杂度O(n) +法2：有序数组，考虑二分。 +> 将奇数的mid变为mid-1，而不是偶数的mid+1 → 防止数组越界 + +**解法1** +异或操作 - 时间复杂度O(n)，空间复杂度O(1)。 +```python +class Solution(object): + def singleNonDuplicate(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + res = 0 + for num in nums: + res ^= num + return res +``` +**解法2** +二分 - 时间复杂度O(nlogn)，空间复杂度O(1)。 +```python +class Solution(object): + def singleNonDuplicate(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + left, right = 0, len(nums) - 1 + while left < right: + mid = (left + right) >> 1 + if mid % 2 == 1: + mid -= 1 # Set the index of mid is 0,2,4... + if nums[mid] != nums[mid+1]: + right = mid + else: + left = mid + 2 + return nums[left] +``` \ No newline at end of file diff --git "a/2018.12.30-leetcode540/\346\243\225\346\246\210\346\240\221.md" "b/2018.12.30-leetcode540/\346\243\225\346\246\210\346\240\221.md" new file mode 100644 index 000000000..07dea677b --- /dev/null +++ "b/2018.12.30-leetcode540/\346\243\225\346\246\210\346\240\221.md" @@ -0,0 +1,20 @@ +``` +class Solution { + public int singleNonDuplicate(int[] nums) { + int start = 0; + int end = nums.length - 1; + while(start false +调用 isBadVersion(5) -> true +调用 isBadVersion(4) -> true + +所以，4 是第一个错误的版本。 +``` diff --git a/2018.12.31-leetcode278/Ostrichcrab.md b/2018.12.31-leetcode278/Ostrichcrab.md new file mode 100644 index 000000000..55cf4174f --- /dev/null +++ b/2018.12.31-leetcode278/Ostrichcrab.md @@ -0,0 +1,18 @@ +``` +// Forward declaration of isBadVersion API. +bool isBadVersion(int version); + +class Solution { +public: + int firstBadVersion(int n) { + int l = 1, r = n; + int mid; + while(l<=r){ + mid = l + (r-l)/2; + if(isBadVersion(mid)) r = mid - 1; + else l = mid + 1; + } + return l; + } +}; +``` diff --git a/2018.12.31-leetcode278/TheRocket.md b/2018.12.31-leetcode278/TheRocket.md new file mode 100644 index 000000000..5738fdd7e --- /dev/null +++ b/2018.12.31-leetcode278/TheRocket.md @@ -0,0 +1,20 @@ +```java +/* The isBadVersion API is defined in the parent class VersionControl. + boolean isBadVersion(int version); */ + +public class Solution extends VersionControl { + public int firstBadVersion(int n) { + int lo = 1; + int hi = n; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if (isBadVersion(mid)) { + hi = mid; + } else { + lo = mid + 1; + } + } + return lo; + } +} +``` diff --git a/2018.12.31-leetcode278/WYJ.md b/2018.12.31-leetcode278/WYJ.md new file mode 100644 index 000000000..46038633c --- /dev/null +++ b/2018.12.31-leetcode278/WYJ.md @@ -0,0 +1,17 @@ +```java +public class Solution extends VersionControl { + public int firstBadVersion(int n) { + int l = 1, r = n; + while(l < r){ + int mid = l + (r - l) / 2; + if(isBadVersion(mid)){ + r = mid; + } + else{ + l = mid + 1; + } + } + return l; + } +} +``` diff --git a/2018.12.31-leetcode278/sourcema.md b/2018.12.31-leetcode278/sourcema.md new file mode 100644 index 000000000..7478df027 --- /dev/null +++ b/2018.12.31-leetcode278/sourcema.md @@ -0,0 +1,15 @@ +# LeetCode 278 + public class Solution extends VersionControl { + public int firstBadVersion(int n) { + int left=1; + int right=n; + while(left 你是PM且现在领导团队开发一个新产品。不幸的是，最新版的产品有质量问题。因为每个版本都是基于上个版本产品开发的，所以质量差的产品会延续给下一代产品。 +假设你有n代产品[1, 2, ..., n]，想找到第一个坏的版本。 + +> 给定一个API名为 isBadVersion(version)，返回version是否是坏的。编写函数找到第一个坏的版本。（最小化调用API的次数） + +**例子** +> Given n = 5, and version = 4 is the first bad version. +call isBadVersion(3) -> false +call isBadVersion(5) -> true +call isBadVersion(4) -> true +Then 4 is the first bad version. + +**思想** +二分，找到第一个为 isBadVersion(version)返回为true的版本。 + +**解法** +```python +# The isBadVersion API is already defined for you. +# @param version, an integer +# @return a bool +# def isBadVersion(version): + +class Solution(object): + def firstBadVersion(self, n): + """ + :type n: int + :rtype: int + """ + l, r = 1, n + while l <= r: + mid = (l + r) >> 1 + if isBadVersion(mid): + if mid == 1 or not isBadVersion(mid-1): + return mid + r = mid - 1 + else: + l = mid + 1 +``` \ No newline at end of file diff --git "a/2019.01.01-leetcode153/153.\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md" "b/2019.01.01-leetcode153/153.\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md" new file mode 100644 index 000000000..2d084ac84 --- /dev/null +++ "b/2019.01.01-leetcode153/153.\346\227\213\350\275\254\346\225\260\347\273\204\347\232\204\346\234\200\345\260\217\346\225\260\345\255\227.md" @@ -0,0 +1,18 @@ +``` +假设按照升序排序的数组在预先未知的某个点上进行了旋转。 + +( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 + +请找出其中最小的元素。 + +你可以假设数组中不存在重复元素。 + +示例 1: + +输入: [3,4,5,1,2] +输出: 1 +示例 2: + +输入: [4,5,6,7,0,1,2] +输出: 0 +``` diff --git a/2019.01.01-leetcode153/Ostrichcrab.md b/2019.01.01-leetcode153/Ostrichcrab.md new file mode 100644 index 000000000..8c07e6eff --- /dev/null +++ b/2019.01.01-leetcode153/Ostrichcrab.md @@ -0,0 +1,17 @@ +``` +class Solution { +public: + int findMin(vector& nums) { + int l = 0; + int r = nums.size()-1; + int mid = 0; + while(l>1; + if(nums[mid]>nums[r]) l = mid+1; + else r = mid; + } + return nums[r]; + } +}; +``` diff --git a/2019.01.01-leetcode153/TheRocket.md b/2019.01.01-leetcode153/TheRocket.md new file mode 100644 index 000000000..0c47ba604 --- /dev/null +++ b/2019.01.01-leetcode153/TheRocket.md @@ -0,0 +1,17 @@ +```java +class Solution { + public int findMin(int[] nums) { + int lo = 0; + int hi = nums.length - 1; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if (nums[mid] > nums[hi]) { + lo = mid + 1; + } else { + hi = mid; + } + } + return nums[lo]; + } +} +``` diff --git a/2019.01.01-leetcode153/Tony the Cyclist.md b/2019.01.01-leetcode153/Tony the Cyclist.md new file mode 100644 index 000000000..8e31acb93 --- /dev/null +++ b/2019.01.01-leetcode153/Tony the Cyclist.md @@ -0,0 +1,9 @@ +```python +class Solution(object): + def findMin(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + return min(nums) +``` diff --git a/2019.01.01-leetcode153/WYJ.md b/2019.01.01-leetcode153/WYJ.md new file mode 100644 index 000000000..9e464d055 --- /dev/null +++ b/2019.01.01-leetcode153/WYJ.md @@ -0,0 +1,17 @@ +```java +class Solution { + public int findMin(int[] nums) { + int l = 0, r = nums.length - 1; + while(l < r){ + int mid = l + (r - l) / 2; + if(nums[mid] > nums[r]){ + l = mid + 1; + } + else{ + r = mid; + } + } + return nums[l]; + } +} +``` diff --git a/2019.01.01-leetcode153/marguerite.md b/2019.01.01-leetcode153/marguerite.md new file mode 100644 index 000000000..33b754fdf --- /dev/null +++ b/2019.01.01-leetcode153/marguerite.md @@ -0,0 +1,22 @@ + +``` +class Solution { +public: + int findMin(vector &num) { + int start = 0; + int end = num.size() - 1; + int mid = 0; + while (start < end) { //注意这里和普通的二分查找不同，这里是start < end不是 start <= end. + mid = start + (end - start)/2; + if (num[mid] > num[end]) + start = mid + 1; //此时可以扔掉mid的值 + else + end = mid;//此时不能扔掉mid的值 + } + return num[end]; //退出循环说明start与end相等，所以只剩一个元素可能，所以return [start]或者return [end]都可以了。 + //注意不能return mid，可以从{2,1}这个输入看出来。 + + } + + ``` + diff --git a/2019.01.01-leetcode153/sourcema.md b/2019.01.01-leetcode153/sourcema.md new file mode 100644 index 000000000..a760fb24a --- /dev/null +++ b/2019.01.01-leetcode153/sourcema.md @@ -0,0 +1,18 @@ +# LeetCode 153 + class Solution { + public int findMin(int[] nums) {//典型的二分，数组进行了旋转，我们现在把数组分为两部分， + // 前面部分是数组中元素较大的元素，后面部分呢是数组中元素较小的元素，如果中间部分的元素值大于首元素和 + //末尾元素说明当前位置在数组的前半部分，left应该等于mid+1，否则说明在数组后半部分right==mid; + int left=0; + int right=nums.length-1; + while (left < right && nums[left] > nums[right]) { + int mid=(left+right)>>1; + if (nums[mid] >= nums[left] && nums[right] < nums[mid]) { + left = mid + 1; + } else { + right=mid; + } + } + return nums[left]; + } +} diff --git "a/2019.01.01-leetcode153/\346\235\216\347\242\247\346\266\265.md" "b/2019.01.01-leetcode153/\346\235\216\347\242\247\346\266\265.md" new file mode 100644 index 000000000..b428ecd11 --- /dev/null +++ "b/2019.01.01-leetcode153/\346\235\216\347\242\247\346\266\265.md" @@ -0,0 +1,38 @@ +#### [153. Find Minimum in Rotated Sorted Array](https://leetcode.com/problems/find-minimum-in-rotated-sorted-array/) +**题目描述** +> 假设按照升序排序的数组，在预先未知的某个点上进行了旋转。 +( 例如，数组 [0,1,2,4,5,6,7] 可能变为 [4,5,6,7,0,1,2] )。 + +> 请找出其中最小的元素。（假设数组中不存在重复元素） + +**例子** +> **Example 1:** +Input: [3,4,5,1,2] +Output: 1 + +> **Example 2:** +Input: [4,5,6,7,0,1,2] +Output: 0 + +**思想** +若旋转了，则num[l] > num[r]；否则未旋转，直接返回num[l]。 +>当nums[mid] > nums[r]时，mid在未旋转部分，取l = mid + 1； +否则，mid在旋转部分，取r = mid； + +**解法** +```python +class Solution(object): + def findMin(self, nums): + """ + :type nums: List[int] + :rtype: int + """ + l, r = 0, len(nums)-1 + while l < r and nums[l] > nums[r]: + mid = (l + r) >> 1 + if nums[mid] > nums[r]: # 肯定未旋转，取左侧 + l = mid + 1 + else: # 肯定旋转了，取右侧 + r = mid + return nums[l] +``` \ No newline at end of file diff --git "a/2019.01.01-leetcode153/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2019.01.01-leetcode153/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..94e0cdd37 --- /dev/null +++ "b/2019.01.01-leetcode153/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,20 @@ +``` +class Solution { +public: + int findMin(vector& nums) { + if(nums.size() <= 1) return nums[0]; + + int i = 0; + int j = 1; + while(j < nums.size()) + { + if(nums[i] > nums[j]) + return nums[j]; + i++; + j++; + } + + return nums[0]; + } +}; +``` diff --git a/2019.01.02-leetcode34/Ostrichcrab.md b/2019.01.02-leetcode34/Ostrichcrab.md new file mode 100644 index 000000000..43478ea2b --- /dev/null +++ b/2019.01.02-leetcode34/Ostrichcrab.md @@ -0,0 +1,28 @@ +``` +class Solution { +public: + vector searchRange(vector& nums, int target) { + vector ans(2,-1); + int size = nums.size(); + if(!size) return ans; + int l = 0, r = size-1; + int mid = -1; + if(targetnums[r]) return ans; + while(l<=r) + { + mid = (l+r)>>1; + if(nums[mid]==target){ + int pos = mid; + while(nums[pos]==target && pos-1) mid--; + ans[0] = mid+1; + return ans; + } + else if(nums[mid] < target) l = mid+1; + else r = mid-1; + } + return ans; + } +}; +``` diff --git a/2019.01.02-leetcode34/TheRocket.md b/2019.01.02-leetcode34/TheRocket.md new file mode 100644 index 000000000..b86f3139a --- /dev/null +++ b/2019.01.02-leetcode34/TheRocket.md @@ -0,0 +1,40 @@ +```java +class Solution { + public int[] searchRange(int[] nums, int target) { + int left = lowerBound(nums, target); + if (left < nums.length && nums[left] == target) { + int right = upperBound(nums, target); + return new int[] { left, right - 1 }; + } + return new int[] { -1, -1 }; + } + + private int lowerBound(int[] nums, int target) { + int lo = 0; + int hi = nums.length; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if (nums[mid] < target) { + lo = mid + 1; + } else { + hi = mid; + } + } + return lo; + } + + private int upperBound(int[] nums, int target) { + int lo = 0; + int hi = nums.length; + while (lo < hi) { + int mid = lo + (hi - lo) / 2; + if (nums[mid] <= target) { + lo = mid + 1; + } else { + hi = mid; + } + } + return lo; + } +} +``` diff --git a/2019.01.02-leetcode34/Tony the Cyclist.md b/2019.01.02-leetcode34/Tony the Cyclist.md new file mode 100644 index 000000000..a313fb67b --- /dev/null +++ b/2019.01.02-leetcode34/Tony the Cyclist.md @@ -0,0 +1,15 @@ +```python +class Solution(object): + def searchRange(self, nums, target): + """ + :type nums: List[int] + :type target: int + :rtype: List[int] + """ + if target not in nums: + return [-1, -1] + begin = nums.index(target) + nums.reverse() + end = len(nums) - 1 - nums.index(target) + return [begin, end] +``` diff --git a/2019.01.02-leetcode34/WYJ.md b/2019.01.02-leetcode34/WYJ.md new file mode 100644 index 000000000..0000bed58 --- /dev/null +++ b/2019.01.02-leetcode34/WYJ.md @@ -0,0 +1,38 @@ +```java +class Solution { + public int[] searchRange(int[] nums, int target) { + if(nums.length == 0){ + return new int[] {-1, -1}; + } + int l = 0, r = nums.length - 1; + while(l < r){ + int mid = l + (r - l) / 2; + if(nums[mid] < target){ + l = mid + 1; + } + else{ + r = mid; + } + } + int start = l; + if(nums[l] == target){ + r = nums.length - 1; + while(l < r){ + int mid = l + (r - l) / 2; + if(mid == l){ + mid += 1; + } + if(nums[mid] > target){ + r = mid - 1; + } + else{ + l = mid; + } + } + int end = r; + return new int[] {start, end}; + } + return new int[] {-1, -1}; + } +} +``` diff --git a/2019.01.02-leetcode34/marguerite.md b/2019.01.02-leetcode34/marguerite.md new file mode 100644 index 000000000..8ad7353fe --- /dev/null +++ b/2019.01.02-leetcode34/marguerite.md @@ -0,0 +1,43 @@ +``` +class Solution { + public int[] searchRange(int[] nums, int target) { + int l=0; + int h=nums.length-1; + int answer[]=new int[2]; + int s=-1; + int e=-1; + int t=-1; + while(l<=h){ + int m=(l+h)/2; + if(nums[m]>target) + h=m-1; + else if(nums[m]=0&&nums[s]==target){ + s--; + } + while(e<=nums.length-1&&nums[e]==target){ + e++; + } + s=s+1; + e=e-1; + answer[0]=s; + answer[1]=e; + + } + return answer; + } +} + +``` diff --git a/2019.01.02-leetcode34/sourcema.md b/2019.01.02-leetcode34/sourcema.md new file mode 100644 index 000000000..d579a4cba --- /dev/null +++ b/2019.01.02-leetcode34/sourcema.md @@ -0,0 +1,52 @@ +# LeetCode 34 + class Solution { + public int[] searchRange(int[] nums, int target) { + int[] res = {-1, -1}; + if (nums == null || nums.length == 0) { + return res; + } + int start=findStartPosition(nums, target); + int end=findEndPosition(nums, target); + res[0]=start; + res[1]=end; + return res; + } + private static int findEndPosition(int[] nums, int target) { + int left=0; + int right=nums.length-1; + while (left < right) { + int mid=left+(right-left)/2; + if (nums[mid] < target) { + left=mid+1; + } else if (nums[mid] > target) { + right=mid-1; + } else { + if (nums[mid + 1] != nums[mid]) { + return mid; + } else { + left=mid+1; + } + } + } + return nums[left]!=target?-1:left; + } + private static int findStartPosition(int[] nums, int target) { + int left=0; + int right=nums.length-1; + while (left < right) { + int mid=left+(right-left)/2; + if (nums[mid] < target) { + left=mid+1; + } else if (nums[mid] > target) { + right=mid-1; + } else { + if (mid==0||nums[mid - 1] != nums[mid]) { + return mid; + } else { + right=mid-1; + } + } + } + return nums[left]!=target?-1:left; + } +} diff --git "a/2019.01.02-leetcode34/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.02-leetcode34/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..2d5e54abe --- /dev/null +++ "b/2019.01.02-leetcode34/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,40 @@ +```java + public static int[] searchRange(int[] nums, int target) { + + if (nums.length==0) return new int[]{-1,-1}; + int start=0; + int end=nums.length-1; + int mid; + while (start<=end){ + mid=start+(end-start)/2; + if (nums[mid]>target){ + end=mid-1; + continue; + } + if (nums[mid]0&&nums[left]==nums[left-1]){ + left=left-1; + continue; + } + break; + } + while (true){ + + if (right 给定一个按照升序排列的整数数组 nums和一个目标值 target。找出给定目标值在数组中的开始位置和结束位置。 + +> 你的算法时间复杂度必须是 O(log n) 级别。 +如果数组中不存在目标值，返回 [-1, -1]。 + +**例子** +> **Example 1:** +Input: nums = [5,7,7,8,8,10], target = 8 +Output: [3,4] + +> **Example 2:** +Input: nums = [5,7,7,8,8,10], target = 6 +Output: [-1,-1] + +**思想** +二分。方法多样化：getFirst用的非递归，getLast用的递归。 + +**解法** +```python +class Solution(object): + def searchRange(self, nums, target): + """ + :type nums: List[int] + :type target: int + :rtype: List[int] + """ + return [self.getFirst(nums, target), self.getLast(nums, target, 0, len(nums)-1)] + + def getFirst(self, nums, target): + l, r = 0, len(nums) - 1 + while l <= r: + mid = (l + r) >> 1 + if nums[mid] < target: + l = mid + 1 + elif nums[mid] > target: + r = mid - 1 + else: + if mid == 0 or nums[mid-1] < target: + return mid + r = mid - 1 + return -1 + + def getLast(self, nums, target, l, r): + if l > r: + return -1 + + mid = (l + r) >> 1 + if nums[mid] < target: + return self.getLast(nums, target, mid+1, r) + if nums[mid] > target: + return self.getLast(nums, target, l, mid-1) + if mid == len(nums)-1 or nums[mid+1] > target: + return mid + return self.getLast(nums, target, mid+1, r) +``` \ No newline at end of file diff --git "a/2019.01.02-leetcode34/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2019.01.02-leetcode34/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..814ed43fa --- /dev/null +++ "b/2019.01.02-leetcode34/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,33 @@ +``` +class Solution { +public: + vector searchRange(vector& nums, int target) { + + int l = 0; + int r = nums.size()-1; + while(l <= r) + { + int mid = l + (r-l)/2; + if(nums[mid] == target) + { + int i=mid; + int j=mid; + while(i>0 && nums[i-1]==target) + i--; + while(j{i, j}; + } + else if(nums[mid] > target) + { + r = mid-1; + } + else + l = mid + 1; + } + + return vector{-1, -1}; + } +}; +``` diff --git a/2019.01.03-leetcode241/Ostrichcrab.md b/2019.01.03-leetcode241/Ostrichcrab.md new file mode 100644 index 000000000..7c6da7d24 --- /dev/null +++ b/2019.01.03-leetcode241/Ostrichcrab.md @@ -0,0 +1,25 @@ +``` +class Solution { +public: + vector diffWaysToCompute(string input) { + vector result; + for(int i = 0; i < input.size(); i++){ + char c = input[i]; + if(c=='+' || c=='-' || c=='*'){ + auto result1 = diffWaysToCompute(input.substr(0,i)); + auto result2 = diffWaysToCompute(input.substr(i+1)); + for(int r1 : result1){ + for(int r2 : result2){ + if(c=='+') result.push_back(r1+r2); + else if(c=='-') result.push_back(r1-r2); + else result.push_back(r1*r2); + } + } + } + } + if(result.empty()) + result.push_back(atoi(input.c_str())); + return result; + } +}; +``` diff --git a/2019.01.03-leetcode241/TheRocket.md b/2019.01.03-leetcode241/TheRocket.md new file mode 100644 index 000000000..848ab54c4 --- /dev/null +++ b/2019.01.03-leetcode241/TheRocket.md @@ -0,0 +1,29 @@ +```java +class Solution { + public List diffWaysToCompute(String input) { + List res = new ArrayList<>(); + for (int i = 0; i < input.length(); ++i) { + char c = input.charAt(i); + if (c == '+' || c == '-' || c == '*') { + List left = diffWaysToCompute(input.substring(0, i)); + List right = diffWaysToCompute(input.substring(i + 1)); + for (int l : left) { + for (int r : right) { + if (c == '+') { + res.add(l + r); + } else if (c == '-') { + res.add(l - r); + } else { + res.add(l * r); + } + } + } + } + } + if (res.size() == 0) { + res.add(Integer.valueOf(input)); + } + return res; + } +} +``` diff --git a/2019.01.03-leetcode241/marguerite.md b/2019.01.03-leetcode241/marguerite.md new file mode 100644 index 000000000..4020d3855 --- /dev/null +++ b/2019.01.03-leetcode241/marguerite.md @@ -0,0 +1,32 @@ +``` +class Solution { +public: + vector diffWaysToCompute(string input) { + vector ret; + for(int i = 0; i < input.size(); i ++) + { + if(input[i] == '+' || input[i] == '-' || input[i] == '*') + { + vector left = diffWaysToCompute(input.substr(0, i)); + vector right = diffWaysToCompute(input.substr(i+1)); + for(int j = 0; j < left.size(); j ++) + { + for(int k = 0; k < right.size(); k ++) + { + if(input[i] == '+') + ret.push_back(left[j] + right[k]); + else if(input[i] == '-') + ret.push_back(left[j] - right[k]); + else + ret.push_back(left[j] * right[k]); + } + } + } + } + if(ret.empty()) + ret.push_back(atoi(input.c_str())); + return ret; + } +}; + +``` diff --git a/2019.01.03-leetcode241/sourcema.md b/2019.01.03-leetcode241/sourcema.md new file mode 100644 index 000000000..ecdffcd7e --- /dev/null +++ b/2019.01.03-leetcode241/sourcema.md @@ -0,0 +1,26 @@ +# leetcode 241 + public List diffWaysToCompute(String input) { + List res=new ArrayList(); + for(int i=0;i left=diffWaysToCompute(input.substring(0,i)); + List right=diffWaysToCompute(input.substring(i+1,input.length())); + for(Integer l:left){ + for(Integer r:right){ + switch (ch) + { + case '*':res.add(l*r); break; + case '-':res.add(l-r); break; + case '+':res.add(l+r); break; + } + } + } + } + } + if(res.size()==0){ + res.add(Integer.valueOf(input)); + return res; + } + return res; + } diff --git "a/2019.01.03-leetcode241/\344\270\272\350\277\220\347\256\227\350\241\250\350\276\276\345\274\217\350\256\276\350\256\241\344\274\230\345\205\210\347\272\247" "b/2019.01.03-leetcode241/\344\270\272\350\277\220\347\256\227\350\241\250\350\276\276\345\274\217\350\256\276\350\256\241\344\274\230\345\205\210\347\272\247" new file mode 100644 index 000000000..24f632383 --- /dev/null +++ "b/2019.01.03-leetcode241/\344\270\272\350\277\220\347\256\227\350\241\250\350\276\276\345\274\217\350\256\276\350\256\241\344\274\230\345\205\210\347\272\247" @@ -0,0 +1,19 @@ +给定一个含有数字和运算符的字符串，为表达式添加括号，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。 + +示例 1: + +输入: "2-1-1" +输出: [0, 2] +解释: +((2-1)-1) = 0 +(2-(1-1)) = 2 +示例 2: + +输入: "2*3-4*5" +输出: [-34, -14, -10, -10, 10] +解释: +(2*(3-(4*5))) = -34 +((2*3)-(4*5)) = -14 +((2*(3-4))*5) = -10 +(2*((3-4)*5)) = -10 +(((2*3)-4)*5) = 10 diff --git "a/2019.01.03-leetcode241/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.03-leetcode241/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..a642fd012 --- /dev/null +++ "b/2019.01.03-leetcode241/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,32 @@ +```java + public List diffWaysToCompute1(String input) { + List res = new ArrayList<>(); + for (int i=0;i left = diffWaysToCompute1(input.substring(0,i)); + List right = diffWaysToCompute1(input.substring(i+1)); + + for (int j=0;j 给定一个含有数字和运算符的字符串，为表达式**添加括号**，改变其运算优先级以求出不同的结果。你需要给出所有可能的组合的结果。有效的运算符号包含 +, - 以及 * 。 + +**例子** +> **示例 1**: +输入: "2-1-1" +输出: [0, 2] +解释: +((2-1)-1) = 0 +(2-(1-1)) = 2 + +> **示例 2:** +输入: "2*3-4*5" +输出: [-34, -14, -10, -10, 10] +解释: +(2*(3-(4*5))) = -34 +((2*3)-(4*5)) = -14 +((2*(3-4))*5) = -10 +(2*((3-4)*5)) = -10 +(((2*3)-4)*5) = 10 + +**思想** +分治法 +1）递归地将表达式**按照运算符拆分**为左右两半； +2）分解成子问题，用操作符继续分成左右两部分； +3）截止条件：isdigit() +可采用dic存储优化 + +**解法** +```python +class Solution(object): + def diffWaysToCompute(self, input): + """ + :type input: str + :rtype: List[int] + """ + self.dic = {} + return self.helper(input) + + def helper(self, input): + if input in self.dic: + return self.dic[input] + if input.isdigit(): + return [int(input)] + + res = [] + for i in range(len(input)): + if input[i] in '+-*': + l = self.diffWaysToCompute(input[:i]) + r = self.diffWaysToCompute(input[i+1:]) + + for x in l: + for y in r: + if input[i] == '+': + res.append(x + y) + elif input[i] == '-': + res.append(x - y) + else: + res.append(x * y) + self.dic[input] = res + return res +``` \ No newline at end of file diff --git a/2019.01.04-leetcode279/Ostrichcrab.md b/2019.01.04-leetcode279/Ostrichcrab.md new file mode 100644 index 000000000..16563e006 --- /dev/null +++ b/2019.01.04-leetcode279/Ostrichcrab.md @@ -0,0 +1,17 @@ +``` +class Solution { +public: + int numSquares(int n) { + vector dp; + dp.push_back(0); + for(int i = 1; i <= n; i++) dp.push_back(i); + // for(int i = 0; i <= n; i++) cout< 给定正整数 n，找到若干个完全平方数（比如 1, 4, 9, 16, ...）使得它们的和等于 n。你需要让组成和的完全平方数的个数最少。 + +**例子** +> **示例 1:** +输入: n = 12 +输出: 3 +解释: 12 = 4 + 4 + 4. + +> **示例 2:** +输入: n = 13 +输出: 2 +解释: 13 = 4 + 9. + +**思想** +**法1**：DP +> 看到 "最小" 之类的词，考虑DP。 + +dp[i] 表示组成和为 i 的完全平方数的最小个数。 +dp[i] = min(dp[i], dp[i-j*j]) + +**法2**：BFS +结点表示剩余的和，边表示完全平方数 + +**解法1** +复杂度 - 时间O(n^2)，空间O(n) +```python +class Solution(object): + def numSquares(self, n): + """ + :type n: int + :rtype: int + """ + dp = [i for i in range(n+1)] + for i in range(1, n+1): + for j in range(1, int(i**0.5)+1): + dp[i] = min(dp[i], dp[i-j*j]+1) + return dp[-1] +``` + +**解法2** +BFS +```python +class Solution(object): + def numSquares(self, n): + """ + :type n: int + :rtype: int + """ + depth = 0 + nodes = set([n]) + edges = [i * i for i in range(1, int(n**0.5)+1)] + while edges: + depth += 1 + nextLevel = set() + for node in nodes: + for edge in edges: + if edge == node: + return depth + elif edge < node: + nextLevel.add(node - edge) + else: + break + nodes = nextLevel + return depth +``` + +##### Ref +[Summary of 4 different solutions (BFS, DP, static DP and mathematics)](https://leetcode.com/problems/perfect-squares/discuss/71488/Summary-of-4-different-solutions-(BFS-DP-static-DP-and-mathematics)) \ No newline at end of file diff --git "a/2019.01.04-leetcode279/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2019.01.04-leetcode279/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..1f1360dc0 --- /dev/null +++ "b/2019.01.04-leetcode279/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,16 @@ +``` +class Solution { +public: + int numSquares(int n) { + while (n % 4 == 0) n /= 4; + if (n % 8 == 7) return 4; + for (int a = 0; a * a <= n; ++a) { + int b = sqrt(n - a * a); + if (a * a + b * b == n) { + return !!a + !!b; + } + } + return 3; + } +}; +``` diff --git a/2019.01.05-leetcode127/Ostrichcrab.md b/2019.01.05-leetcode127/Ostrichcrab.md new file mode 100644 index 000000000..5c861956b --- /dev/null +++ b/2019.01.05-leetcode127/Ostrichcrab.md @@ -0,0 +1,36 @@ +``` +public class Solution { + public int ladderLength(String beginWord, String endWord, List wordList) { + + Set wordSet = new HashSet<>(wordList); + Set visited = new HashSet<>(); + visited.add(beginWord); + int dist = 1; + + while (!visited.contains(endWord)) { + Set temp = new HashSet<>(); + for (String word: visited) { + for (int i = 0; i < word.length(); i++) { + char[] chars = word.toCharArray(); + for (int j = (int)'a'; j < (int)'z' + 1; j++) { + chars[i] = (char)j; + String newWord = new String(chars); + if (wordSet.contains(newWord)) { + temp.add(newWord); + wordSet.remove(newWord); + } + } + } + } + dist += 1; + if (temp.size() == 0) { // it nevert get to the endWord + return 0; + } + + visited = temp; + } + + return dist; + } +} +``` diff --git a/2019.01.05-leetcode127/TheRocket.md b/2019.01.05-leetcode127/TheRocket.md new file mode 100644 index 000000000..8665c8aa0 --- /dev/null +++ b/2019.01.05-leetcode127/TheRocket.md @@ -0,0 +1,44 @@ +```java +class Solution { + public int ladderLength(String beginWord, String endWord, List wordList) { + Set dict = new HashSet<>(wordList); + if (!dict.contains(endWord)) { + return 0; + } + Set head = new HashSet<>(); + Set tail = new HashSet<>(); + head.add(beginWord); + tail.add(endWord); + int level = 1; + while (!head.isEmpty() && !tail.isEmpty()) { + ++level; + if (head.size() > tail.size()) { + Set tmp = head; + head = tail; + tail = tmp; + } + Set newHead = new HashSet<>(); + for (String word : head) { + char[] cs = word.toCharArray(); + for (int i = 0; i < cs.length; ++i) { + char ch = cs[i]; + for (char j = 'a'; j <= 'z'; ++j) { + cs[i] = j; + String s = new String(cs); + if (tail.contains(s)) { + return level; + } + if (dict.contains(s)) { + dict.remove(s); + newHead.add(s); + } + } + cs[i] = ch; + } + } + head = newHead; + } + return 0; + } +} +``` diff --git a/2019.01.05-leetcode127/sourcema.md b/2019.01.05-leetcode127/sourcema.md new file mode 100644 index 000000000..fc8cad22c --- /dev/null +++ b/2019.01.05-leetcode127/sourcema.md @@ -0,0 +1,35 @@ +# LeetCode 127 + class Solution { + public int ladderLength(String beginWord, String endWord, List wordList) { + Set set = new HashSet<>(wordList); + if(!set.contains(endWord)){ + return 0; + } + Queue queue=new LinkedList(); + queue.add(beginWord); + int step=1; + while(!queue.isEmpty()){ + int size=queue.size(); + for (int i = 0; i < size; i++) { + String s = queue.poll(); + for (int k = 0; k < s.length(); k++) { + char[] chars = s.toCharArray(); + for (char j = 'a'; j <= 'z'; j++) { + chars[k] = j; + String temp = String.valueOf(chars); + if (set.contains(temp)) { + if (temp.equals(endWord)) { + return step + 1; + } + queue.add(temp); + set.remove(temp); + } + } + } + } + step++; + } + return 0; + + } +} diff --git "a/2019.01.05-leetcode127/\345\215\225\350\257\215\346\216\245\351\276\231" "b/2019.01.05-leetcode127/\345\215\225\350\257\215\346\216\245\351\276\231" new file mode 100644 index 000000000..c9807d2f1 --- /dev/null +++ "b/2019.01.05-leetcode127/\345\215\225\350\257\215\346\216\245\351\276\231" @@ -0,0 +1,32 @@ +给定两个单词（beginWord 和 endWord）和一个字典，找到从 beginWord 到 endWord 的最短转换序列的长度。转换需遵循如下规则： + +每次转换只能改变一个字母。 +转换过程中的中间单词必须是字典中的单词。 +说明: + +如果不存在这样的转换序列，返回 0。 +所有单词具有相同的长度。 +所有单词只由小写字母组成。 +字典中不存在重复的单词。 +你可以假设 beginWord 和 endWord 是非空的，且二者不相同。 +示例 1: + +输入: +beginWord = "hit", +endWord = "cog", +wordList = ["hot","dot","dog","lot","log","cog"] + +输出: 5 + +解释: 一个最短转换序列是 "hit" -> "hot" -> "dot" -> "dog" -> "cog", + 返回它的长度 5。 +示例 2: + +输入: +beginWord = "hit" +endWord = "cog" +wordList = ["hot","dot","dog","lot","log"] + +输出: 0 + +解释: endWord "cog" 不在字典中，所以无法进行转换。 diff --git "a/2019.01.05-leetcode127/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2019.01.05-leetcode127/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..955681db6 --- /dev/null +++ "b/2019.01.05-leetcode127/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,44 @@ +``` +class Solution { +public: + int ladderLength(string beginWord, string endWord, vector& wordList) { + int ret = 0; + + set s(wordList.begin(), wordList.end()); + if(s.find(endWord) == s.end()) + return 0; + + queue q; + q.push(beginWord); + while(!q.empty()) + { + for(int j=q.size(); j>0; j--) + { + string str = q.front(); + q.pop(); + + if(str == endWord) return ret+1; + + for(int i=0; i>& grid, int x0, int y0){ + int n, m, sum=1; + n = grid.size(); + m = grid[0].size(); + + grid[x0][y0] = 0; //当前元素设置为0，避免再次搜索到 + int dir[4][2] = {{0,1},{0,-1},{1,0},{-1,0}}; + + for(int i=0; i<4; i++){ + int x = x0 + dir[i][0]; + int y = y0 + dir[i][1]; + if(x>=0&&x=0&&y>& grid) + { + int mx = 0, n, m; + n = grid.size(); + m = grid[0].size(); + for(int i=0; i= 0 && grid[i - 1][j] == 1) + sum += dfs(grid, i - 1, j); + if (i + 1 < grid.length && grid[i + 1][j] == 1) + sum += dfs(grid, i + 1, j); + if (j - 1 >= 0 && grid[i][j - 1] == 1) + sum += dfs(grid, i, j - 1); + if (j + 1 < grid[0].length && grid[i][j + 1] == 1) + sum += dfs(grid, i, j + 1); + return sum; + } +} +``` diff --git a/2019.01.06-leetcode695/WYJ.md b/2019.01.06-leetcode695/WYJ.md new file mode 100644 index 000000000..db53f12cd --- /dev/null +++ b/2019.01.06-leetcode695/WYJ.md @@ -0,0 +1,50 @@ +```java +class Solution { + public int maxAreaOfIsland(int[][] grid) { + if(grid.length == 0){ + return 0; + } + boolean[][] judge = new boolean[grid.length][grid[0].length]; + for(int i = 0; i < grid.length; i++){ + for(int j = 0; j < grid[0].length; j++){ + judge[i][j] = false; + } + } + int area = 0; + for(int i = 0; i < grid.length; i++){ + for(int j = 0; j < grid[i].length; j++){ + if(!judge[i][j]&&grid[i][j] == 1){ + area = Math.max(area, findArea(grid, i, j, judge)); + } + } + } + return area; + } + public int findArea(int[][] grid, int x, int y, boolean[][] judge){ + if(grid[x][y] == 0){ + return 0; + } + if(judge[x][y]){ + return 0; + } + else{ + judge[x][y] = true; + int up = 0, down = 0, left = 0, right = 0; + if(x - 1 >= 0){ + up = findArea(grid, x - 1, y, judge); + } + if(x + 1 < grid.length){ + down = findArea(grid, x + 1, y, judge); + } + if(y - 1 >= 0){ + left = findArea(grid, x, y - 1, judge); + } + if(y + 1 < grid[x].length){ + right = findArea(grid, x, y + 1, judge); + } + return 1 + up + down + left + right; + + } + } +} +``` diff --git a/2019.01.06-leetcode695/sourcema.md b/2019.01.06-leetcode695/sourcema.md new file mode 100644 index 000000000..548f1fc10 --- /dev/null +++ b/2019.01.06-leetcode695/sourcema.md @@ -0,0 +1,27 @@ +# LeetCode 695 + class Solution { + public int maxAreaOfIsland(int[][] grid) { + if (grid[0].length == 0 || grid.length == 0) { + return 0; + } + int row=grid.length,col=grid[0].length; + int max=0; + for (int i = 0; i < row; i++) { + for (int j = 0; j < col; j++) { + if (grid[i][j] == 1) { + int count=dfs(grid, i, j); + max = Math.max(max, count); + } + } + } + return max; + } + private int dfs(int[][] grid, int i, int j) { + if (i < 0 || i >= grid.length || j < 0 || j >= grid[0].length || grid[i][j] == 0) { + return 0; + } + grid[i][j]=0; + return 1 + dfs(grid, i - 1, j) + dfs(grid, i + 1, j) + + dfs(grid, i, j - 1) + dfs(grid, i, j + 1); + } +} diff --git "a/2019.01.06-leetcode695/\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257" "b/2019.01.06-leetcode695/\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257" new file mode 100644 index 000000000..9af299f60 --- /dev/null +++ "b/2019.01.06-leetcode695/\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257" @@ -0,0 +1,22 @@ +给定一个包含了一些 0 和 1的非空二维数组 grid , 一个 岛屿 是由四个方向 (水平或垂直) 的 1 (代表土地) 构成的组合。你可以假设二维矩阵的四个边缘都被水包围着。 + +找到给定的二维数组中最大的岛屿面积。(如果没有岛屿，则返回面积为0。) + +示例 1: + +[[0,0,1,0,0,0,0,1,0,0,0,0,0], + [0,0,0,0,0,0,0,1,1,1,0,0,0], + [0,1,1,0,1,0,0,0,0,0,0,0,0], + [0,1,0,0,1,1,0,0,1,0,1,0,0], + [0,1,0,0,1,1,0,0,1,1,1,0,0], + [0,0,0,0,0,0,0,0,0,0,1,0,0], + [0,0,0,0,0,0,0,1,1,1,0,0,0], + [0,0,0,0,0,0,0,1,1,0,0,0,0]] +对于上面这个给定矩阵应返回 6。注意答案不应该是11，因为岛屿只能包含水平或垂直的四个方向的‘1’。 + +示例 2: + +[[0,0,0,0,0,0,0,0]] +对于上面这个给定的矩阵, 返回 0。 + +注意: 给定的矩阵grid 的长度和宽度都不超过 50。 diff --git "a/2019.01.06-leetcode695/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" "b/2019.01.06-leetcode695/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" new file mode 100644 index 000000000..248c5105a --- /dev/null +++ "b/2019.01.06-leetcode695/\347\245\236\347\247\230\347\232\204\347\201\253\346\237\264\344\272\272.md" @@ -0,0 +1,26 @@ +``` +class Solution { +public: + vector> dirs{{0,-1},{-1,0},{0,1},{1,0}}; + int maxAreaOfIsland(vector>& grid) { + int m = grid.size(), n = grid[0].size(), res = 0; + for (int i = 0; i < m; ++i) { + for (int j = 0; j < n; ++j) { + if (grid[i][j] != 1) continue; + int cnt = 0; + helper(grid, i, j, cnt, res); + } + } + return res; + } + void helper(vector>& grid, int i, int j, int& cnt, int& res) { + int m = grid.size(), n = grid[0].size(); + if (i < 0 || i >= m || j < 0 || j >= n || grid[i][j] <= 0) return; + res = max(res, ++cnt); + grid[i][j] *= -1; + for (auto dir : dirs) { + helper(grid, i + dir[0], j + dir[1], cnt, res); + } + } +}; +``` diff --git a/2019.01.07-leetcode200/TheRocket.md b/2019.01.07-leetcode200/TheRocket.md new file mode 100644 index 000000000..70b08f22b --- /dev/null +++ b/2019.01.07-leetcode200/TheRocket.md @@ -0,0 +1,28 @@ +```java +class Solution { + public int numIslands(char[][] grid) { + int res = 0; + for (int i = 0; i < grid.length; ++i) { + for (int j = 0; j < grid[0].length; ++j) { + if (grid[i][j] == '1') { + ++res; + dfs(grid, i, j); + } + } + } + return res; + } + + private void dfs(char[][] grid, int i, int j) { + grid[i][j] = '0'; + if (i - 1 >= 0 && grid[i - 1][j] == '1') + dfs(grid, i - 1, j); + if (i + 1 = 0 && grid[i][j - 1] == '1') + dfs(grid, i, j - 1); + if (j + 1 < grid[0].length && grid[i][j + 1] == '1') + dfs(grid, i, j + 1); + } +} +``` diff --git a/2019.01.07-leetcode200/marguerite.md b/2019.01.07-leetcode200/marguerite.md new file mode 100644 index 000000000..c9e908cf8 --- /dev/null +++ b/2019.01.07-leetcode200/marguerite.md @@ -0,0 +1,43 @@ +给定的一个二维网格的地图（’1’（陆地）和0（水）），计数岛的数量。岛屿是四面环水，是由相邻的陆地水平或垂直连接而形成的。 + +可以假设该网格的所有四个边都被水包围。采用深度优先遍历，把访问过的改为‘0’，继续遍历 + +``` +public class 岛屿的数量 { + public int numIslands(char[][] grid) { + if (grid == null || grid.length == 0 + || grid[0].length == 0) + return 0; + int rows = grid.length; + int cols = grid[0].length; + int count = 0; + for (int i = 0; i < rows; i++) + for (int j = 0; j < cols; j++) + // 注意char + if (grid[i][j] == '1') { + count++; + dfsSearch(grid, i, j, rows, cols); + } + return count++; + } + + // 每遇到'1'后, 开始向四个方向 递归搜索. 搜到后变为'0', + // 因为相邻的属于一个island. 然后开始继续找下一个'1'. + private void dfsSearch(char[][] grid, + int i, int j, int rows, int cols) { + if (i < 0 || i >= rows || j < 0 || j >= cols) + return; + if (grid[i][j] != '1') + return; + // 也可以才用一个visited数组，标记遍历过的岛屿 + grid[i][j] = '0'; + dfsSearch(grid, i + 1, j, rows, cols); + dfsSearch(grid, i - 1, j, rows, cols); + dfsSearch(grid, i, j + 1, rows, cols); + dfsSearch(grid, i, j - 1, rows, cols); + + } +} + + +``` diff --git a/2019.01.07-leetcode200/sourcema.md b/2019.01.07-leetcode200/sourcema.md new file mode 100644 index 000000000..01bf867af --- /dev/null +++ b/2019.01.07-leetcode200/sourcema.md @@ -0,0 +1,53 @@ +# leetcode 200 + class Solution { + static int count=0; + static int[] parent; + public static int numIslands(char[][] arr) {//并查集解法 + if (arr.length == 0||arr[0].length == 0 ) { + return 0; + } + int length=arr.length * arr[0].length; + int width=arr[0].length; + parent = new int[length]; + for (int i = 0; i < length; i++) { + int x=i/width; + int y=i%width; + if (arr[x][y] - '0' == 1) { + count++; + } + parent[i]=i; + } + for (int i = 0; i < length; i++) {//为什么考查右边和下方 1 0 + int x=i/width; //1 1如果不考察下方，右下角的1就无法抵消啦 + int y=i%width; + int down=x+1; + int right=y+1; + if (right < width && arr[x][y] - '0' == 1 && arr[x][right] - '0' == 1) { + union(i, i+1); + } + if (down < arr.length && arr[x][y] - '0' == 1 && arr[down][y] - '0' == 1) { + union(i, i+width); + } + } + return count; + + } + + public static void union(int p,int q) { + int rootP = find(p); + int rootQ = find(q); + if (rootP == rootQ) { + return; + } + parent[rootQ]=rootP; + count--; + } + + public static int find(int e) { + while (parent[e] != e) { + parent[e] = parent[parent[e]];//让子节点直接连接父节点 + e = parent[e]; + } + return e; + } +} diff --git "a/2019.01.07-leetcode200/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.07-leetcode200/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..ef98406aa --- /dev/null +++ "b/2019.01.07-leetcode200/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,27 @@ +```java + public int numIslands(char[][] grid) { + + int count=0; + for (int i=0;i=0&&y>=0&&y 0) + count++; + return count; + } + + private int dfs(int[][] mat, int i, boolean[] visited) { + if (visited[i]) + return 0; + visited[i] = true; + int count = 1; + for (int j = 0; j < visited.length; j++) + if (i != j && mat[i][j] == 1) + count += dfs(mat, j, visited); + return count; + } + +几次深度优先遍历能遍历所有值为1 的结点，图的连通性。（for 是所有结点，M[i][j]==1这个判断相当于i的邻接点，深度优先遍历） + +public class Solution { + public void dfs(int[][] M, int[] visited, int i) { + for (int j = 0; j < M.length; j++) { + if (M[i][j] == 1 && visited[j] == 0) { + visited[j] = 1; + dfs(M, visited, j); + } + } + } + public int findCircleNum(int[][] M) { + int[] visited = new int[M.length]; + int count = 0; + for (int i = 0; i < M.length; i++) { + if (visited[i] == 0) { + dfs(M, visited, i); + count++; + } + } + return count; + } + +广度优先遍历： +Queue q = new LinkedList<>(); + public void bfs(int[][] M, int[] visited, int i) { + // visit[i]; + q.offer(i); + visited[i] = 1; + while (!q.isEmpty()) { + int node = q.poll(); + for (int j = 0; j < M.length; j++) { + // 未被访问过且是邻接点,注意是node的邻接点 + if (visited[j] == 0 && M[node][j] == 1) { + // visit[j]; + q.offer(j); + visited[j] = 1; + } + } + } + + } + + public int findCircleNum(int[][] M) { + int[] visited = new int[M.length]; + int count = 0; + for (int i = 0; i < M.length; i++) { + if (visited[i] == 0) { + bfs(M, visited, i); + count++; + } + } + return count; + } +``` diff --git a/2019.01.08-leetcode547/sourcema.md b/2019.01.08-leetcode547/sourcema.md new file mode 100644 index 000000000..51f6a5f20 --- /dev/null +++ b/2019.01.08-leetcode547/sourcema.md @@ -0,0 +1,42 @@ +# leetcode 547 + class Solution { + static int[] parent; + static int count; + + public static int findCircleNum(int[][] friends) { + if (friends == null || friends.length == 0 || friends[0].length == 0) { + return 0; + } + parent = new int[friends.length]; + count = friends.length; + for (int i = 0; i < friends.length; i++) { + parent[i] = i; + } + for (int i = 0; i < friends.length; i++) { + for (int j = i+1; j < friends.length; j++) { + if (friends[i][j] == 1) { + union(i, j); + } + } + } + return count; + } + + public static void union(int p, int q) { + int rootP = find(p); + int rootQ = find(q); + if (rootP == rootQ) { + return; + } + parent[rootQ] = rootP; + count--; + } + + public static int find(int e) { + while (parent[e] != e) { + parent[e] = parent[parent[e]];//让子节点直接连接父节点 + e = parent[e]; + } + return e; + } +} diff --git "a/2019.01.08-leetcode547/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.08-leetcode547/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..6d4bddce9 --- /dev/null +++ "b/2019.01.08-leetcode547/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,29 @@ +```java + public int findCircleNum(int[][] M) { + + int circleNum=0; + int[] temp = new int[M.length]; + for (int i : temp){ + temp[i]=0; + } + for (int i=0;i +找到所有被 'X' 围绕的区域，并将这些区域里所有的 'O' 用 'X' 填充。 +### 1.2 输入与输出 +输入： +* vector< vector< char>>& board:给定二维区域的指针 + +输出： +* void:原地修改 +### 1.3 样例 +#### 1.3.1 样例1 +输入:
+X X X X
+X O O X
+X X O X
+X O X X
+输出:
+X X X X
+X X X X
+X X X X
+X O X X
+解释：
+被围绕的区间不会存在于边界上，换句话说，任何边界上的 'O' 都不会被填充为 'X'。 任何不在边界上，或不与边界上的 'O' 相连的 'O'
最终都会被填充为 'X'。如果两个元素在水平或垂直方向相邻，则称它们是“相连”的。 + +## 2 思路描述与代码 +### 2.1 思路描述（DFS） +1. DFS编辑边界中的 'O'，将边界以及与边界的 'O' 相连的 'O' 标记为 '*'； +2. 然后遍历区域，若区域的值为 '*' ，则更新为 'O'，若区域的值为 O' 则更新为 'X'。 + +比如输入:
+X X X X
+X O O X
+X X O X
+X O X X
+ +经过步骤1处理后为
+X X X X
+X O O X
+X X O X
+X * X X
+ +经过步骤2处理后为
+X X X X
+X X X X
+X X X X
+X O X X
+ +### 2.2 代码 +```cpp +//函数中涉及到的c++知识 +//vector> board 是个长度、宽度可变的二维 char 数组，c++里面称为容器 +//board.size() 可以获取行数， board[0].size() 可以获取列数 +void solve(vector>& board) { + int row = board.size(); + if(row == 0) return ; + int col = board[0].size(); + if(col == 0) return ; + //上下边界DFS + for( int j = 0; j < col; j++ ){ + DFS(board, 0, j); + DFS(board, row-1, j); + } + //左右边界DFS + for( int i = 1; i < row - 1; i++ ){ + DFS(board, i, 0); + DFS(board, i, col-1); + } + //根据遍历结果重新更新结果 + //如果是 '*' 则说明该点与边界的 'O' 相连，于是需要更新为 'O' + //如果是 'O' 则说明该点不与边界的 'O' 相连，于是需要更新为 'X' + for( int i = 0; i < row; i++ ){ + for( int j = 0; j < col; j++ ){ + if(board[i][j] == 'O') board[i][j] = 'X'; + else if(board[i][j] == '*') board[i][j] = 'O'; + } + } + +} +void DFS(vector>& board, int i, int j){ + //越界或者不是与边界0相连的0则返回 + if(i < 0 || i >= board.size() || j < 0 || j >= board[0].size() || board[i][j] != 'O') return ; + //其他情况就是与边界0相连的0，然后标记为'*' + board[i][j] = '*'; + DFS(board, i - 1, j); + DFS(board, i + 1, j); + DFS(board, i , j - 1); + DFS(board, i , j + 1); +} +``` +## 3 思考与拓展 +### 3.1 思考 +本题有两个思路，一个是求内部与边界0的连通区域，另外一个是上述描述。一个从内而外，一个从外到内，值得注意的是从外而内思路更清晰，代码也更容易书写。 +#### 3.1.1 其他方法 +无。 +#### 3.1.2 复杂度分析 +方法|空间复杂度|时间复杂度 +--- | --- | --- +DFS|O(mn)|O(mn) +#### 3.1.3 难点分析 +1. 选定由内而外还是由外而内的思路； +2. 选用DFS还是BFS + +### 3.2 拓展 +可以尝试使用BFS解决该题。 diff --git a/2019.01.09-leetcode130/Ostrichcrab.md b/2019.01.09-leetcode130/Ostrichcrab.md new file mode 100644 index 000000000..8fbadcabe --- /dev/null +++ b/2019.01.09-leetcode130/Ostrichcrab.md @@ -0,0 +1,67 @@ +``` +class Solution { +public: + int n,m; + int dx[4]={0,0,1,-1}; + int dy[4]={1,-1,0,0}; + vector >flag; + + void bfs(vector >& board,int x,int y){ + queue >q; + q.push(make_pair(x,y)); + flag[x][y]=1; + + while(!q.empty()){ + int qx=q.front().first; + int qy=q.front().second; + q.pop(); + for(int i=0;i<4;i++){ + int tx=qx+dx[i]; + int ty=qy+dy[i]; + if(tx>=0&&tx=0&&ty >& board) { + if(board.empty()){ + return ; + } + n=board.size(); + m=board[0].size(); + flag.resize(n); + for(int i=0;i= board.length || j < 0 || j >= board[0].length || board[i][j] != 'O') { + return; + } + board[i][j] = '1'; + dfs(board, i - 1, j); + dfs(board, i + 1, j); + dfs(board, i, j - 1); + dfs(board, i, j + 1); + } +} +``` diff --git "a/2019.01.09-leetcode130/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.09-leetcode130/\345\210\230\346\266\246\346\263\275(capture).md" new file mode 100644 index 000000000..d6a52d766 --- /dev/null +++ "b/2019.01.09-leetcode130/\345\210\230\346\266\246\346\263\275(capture).md" @@ -0,0 +1,47 @@ +```java + public void solve(char[][] board) { + + if (board.length==0) return; + + for (int i=0;i=0&&x=0&&y1){ + check(board, i-1, j, row, col); + } + if(j>1){ + check(board, i, j-1, row, col); + } + if(i+1> res; + vector> visited; + void dfs(vector>& matrix, int x, int y, int pre, int preval){ + if(x<0 || x>=matrix.size() || y<0 || y>=matrix[0].size() || + matrix[x][y]
> pacificAtlantic(vector>& matrix) {
+        if(matrix.empty()) return res;
+        int m = matrix.size(), n = matrix[0].size();
+        visited.resize(m,vector(n,0));
+        for(int i = 0; i < m; i++){
+            dfs(matrix,i,0,INT_MIN,1);
+            dfs(matrix,i,n-1,INT_MIN,2);
+        }
+        for(int i = 0; i < n; i++){
+            dfs(matrix,0,i,INT_MIN,1);
+            dfs(matrix,m-1,i,INT_MIN,2);
+        }
+        return res;
+    }
+};
+```
diff --git a/2019.01.10-leetcode417/TheRocket.md b/2019.01.10-leetcode417/TheRocket.md
new file mode 100644
index 000000000..0edad38ba
--- /dev/null
+++ b/2019.01.10-leetcode417/TheRocket.md
@@ -0,0 +1,49 @@
+```java
+class Solution {
+    public List pacificAtlantic(int[][] matrix) {
+        List res = new ArrayList<>();
+        if (matrix == null || matrix.length == 0) {
+            return res;
+        }
+        int m = matrix.length;
+        int n = matrix[0].length;
+        boolean[][] fromPacific = new boolean[m][n];
+        boolean[][] fromAtlantic  = new boolean[m][n];
+        for (int i = 0; i < m; ++i) {
+            dfs(matrix, fromPacific, i, 0);
+            dfs(matrix, fromAtlantic, i, n - 1);
+        }
+        for (int i = 0; i < n; ++i) {
+            dfs(matrix, fromPacific, 0, i);
+            dfs(matrix, fromAtlantic, m - 1, i);
+        }
+        for (int i = 0; i < m; ++i) {
+            for (int j = 0; j < n; ++j) {
+                if (fromPacific[i][j] && fromAtlantic[i][j]) {
+                    res.add(new int[] {i, j});
+                }
+            }
+        }
+        return res;
+    }
+
+    private void dfs(int[][] matrix, boolean[][] fromOcean, int i, int j) {
+        if (fromOcean[i][j]) {
+            return;
+        }
+        fromOcean[i][j] = true;
+        if (i - 1 >= 0 && matrix[i - 1][j] >= matrix[i][j]) {
+            dfs(matrix, fromOcean, i - 1, j);
+        }
+        if (i + 1 < matrix.length && matrix[i + 1][j] >= matrix[i][j]) {
+            dfs(matrix, fromOcean, i + 1, j);
+        }
+        if (j - 1 >= 0 && matrix[i][j - 1] >= matrix[i][j]) {
+            dfs(matrix, fromOcean, i, j - 1);
+        }
+        if (j + 1 < matrix[0].length && matrix[i][j + 1] >= matrix[i][j]) {
+            dfs(matrix, fromOcean, i, j + 1);
+        }
+    }
+}
+```
diff --git a/2019.01.10-leetcode417/marguerite.md b/2019.01.10-leetcode417/marguerite.md
new file mode 100644
index 000000000..49129b347
--- /dev/null
+++ b/2019.01.10-leetcode417/marguerite.md
@@ -0,0 +1,68 @@
+给定一个 m x n 的非负整数矩阵来表示一片大陆上各个单元格的高度。“太平洋”处于大陆的左边界和上边界，而“大西洋”处于大陆的右边界和下边界。
+
+规定水流只能按照上、下、左、右四个方向流动，且只能从高到低或者在同等高度上流动。
+
+请找出那些水流既可以流动到“太平洋”，又能流动到“大西洋”的陆地单元的坐标。
+提示：
+输出坐标的顺序不重要
+m 和 n 都小于150
+ 
+示例：
+给定下面的 5x5 矩阵:
+
+  太平洋 ~   ~   ~   ~   ~ 
+       ~  1   2   2   3  (5) *
+       ~  3   2   3  (4) (4) *
+       ~  2   4  (5)  3   1  *
+       ~ (6) (7)  1   4   5  *
+       ~ (5)  1   1   2   4  *
+          *   *   *   *   * 大西洋
+
+返回:
+
+[[0, 4], [1, 3], [1, 4], [2, 2], [3, 0], [3, 1], [4, 0]] (上图中带括号的单元).
+
+##题目思路很明确，用两个数组来记录哪些点可以去大西洋，
+##哪些可以去太平洋，然后将又能去大西洋，又能去太平洋的点输出。判断哪些点能去的思路用启发式的方式递归做。
+
+```
+public class Solution {
+    public List pacificAtlantic(int[][] matrix) {
+ 
+        List results = new ArrayList();
+        int m = matrix.length;
+        if(m == 0) return results;
+        int n = matrix[0].length;
+        int[][] toAtlantic = new int[m][n];
+        int[][] toPacific = new int[m][n];
+ 
+        for(int i = 0; i< m; i ++){
+            toAtlantic[i][n-1] = 1;
+            toPacific[i][0] = 1;
+            reactiveCell(matrix,toAtlantic,i,n-1,m,n);
+            reactiveCell(matrix,toPacific,i,0,m,n);
+        }
+        for(int i = 0; i < n; i ++){
+            toAtlantic[m-1][i] = 1;
+            toPacific[0][i] = 1;
+            reactiveCell(matrix,toAtlantic,m-1,i,m,n);
+            reactiveCell(matrix,toPacific,0,i,m,n);
+        }
+ 
+        for(int i = 0; i < m; i ++)
+            for(int j = 0 ; j < n ; j ++){
+                if(toAtlantic[i][j] == 1 && toPacific[i][j] == 1){ int[]result = new int[]{i,j}; results.add(result);}
+            }
+        return  results;
+    }
+ 
+    public void reactiveCell(int[][] matrix,int[][] markMatrix,int i,int j,int m,int n){
+ 
+        if( i > 0 && matrix[i-1][j] >= matrix[i][j] && markMatrix[i-1][j] == 0) {markMatrix[i-1][j] = 1;reactiveCell(matrix,markMatrix,i-1,j,m,n);}
+        if( i < m-1 && matrix[i+1][j] >= matrix[i][j] && markMatrix[i+1][j] == 0) {markMatrix[i+1][j] = 1;reactiveCell(matrix,markMatrix,i+1,j,m,n);}
+        if( j > 0 && matrix[i][j-1] >= matrix[i][j] && markMatrix[i][j-1] == 0) {markMatrix[i][j-1] = 1; reactiveCell(matrix,markMatrix,i,j-1,m,n);}
+        if( j < n-1 && matrix[i][j+1] >= matrix[i][j] && markMatrix[i][j+1] == 0) {markMatrix[i][j+1] = 1;reactiveCell(matrix,markMatrix,i,j+1,m,n);}
+    }
+}
+
+```
diff --git a/2019.01.10-leetcode417/sourcema.md b/2019.01.10-leetcode417/sourcema.md
new file mode 100644
index 000000000..d30c27a59
--- /dev/null
+++ b/2019.01.10-leetcode417/sourcema.md
@@ -0,0 +1,44 @@
+# leetcode 417
+    class Solution {
+    private static int[][] d = {{0,1}, {1,0}, {0,-1}, {-1,0}};
+    private static int row;
+    private static int col;
+    public static List pacificAtlantic(int[][] matrix) {
+        List res = new ArrayList<>();
+        if (matrix == null || matrix.length == 0) {
+            return res;
+        }
+        row=matrix.length;
+        col=matrix[0].length;
+        boolean[][] pacific = new boolean[row][col];
+        boolean[][] atlantic = new boolean[row][col];
+        for (int i = 0; i = 0 && nextX < row && nextY >= 0 && nextY < col && !arr[nextX][nextY]
+                    && matrix[nextX][nextY] >= matrix[x][y]) {
+                dfs(matrix,arr,nextX,nextY);
+            }
+        }
+    }
+}
diff --git "a/2019.01.10-leetcode417/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.10-leetcode417/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..8444a8b67
--- /dev/null
+++ "b/2019.01.10-leetcode417/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,48 @@
+```java
+  public List pacificAtlantic(int[][] matrix) {
+        
+        List res = new ArrayList<>();
+        boolean[] booleans = new boolean[]{false,false};
+        if (matrix.length==0)return res;
+        int[][] matrixDemo = new int[matrix.length][matrix[0].length];
+        for (int i=0;i 0 && matrix[y][x] >= matrix[y][x - 1]) findArea(x - 1, y, matrix, booleans, matrixDemo);
+            if (x < matrix[0].length - 1 && matrix[y][x] >= matrix[y][x + 1]) findArea(x + 1, y, matrix, booleans, matrixDemo);
+            if (y > 0 && matrix[y][x] >= matrix[y - 1][x]) findArea(x, y - 1, matrix, booleans, matrixDemo);
+            if (y < matrix.length - 1 && matrix[y][x] >= matrix[y + 1][x]) findArea(x, y + 1, matrix, booleans, matrixDemo);
+        }
+    }
+
+    public void clear(int[][] matrixDemo){
+        for (int i=0;i pacificAtlantic(int[][] matrix) {
+        List res = new LinkedList<>();
+		
+		if(null==matrix||matrix.length==0||matrix[0].length==0){
+			return res;
+		}
+		
+		int row = matrix.length;
+		int col = matrix[0].length;
+		boolean[][] pacific = new boolean[row][col];
+		boolean[][] atlantic = new boolean[row][col];
+		
+		//遍历竖着的左右两列
+		for(int i=0;i=n||y<0||y>=m||visited[x][y]==true||matrix[x][y] letterCombinations(string digits) {
+        
+        vector res;
+        if(digits.size()==0)return res;
+        string list[]={"","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
+        res.push_back("");
+        for(int i=0;i letterCombinations(String digits) {
+        List res = new ArrayList<>();
+        if (digits == null || digits.length() == 0) {
+            return res;
+        }
+        res.add("");
+        String[] dict = {"abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        for (char c : digits.toCharArray()) {
+            List tmp = new ArrayList<>();
+            String s = dict[c - '2'];
+            for (String prefix : res) {
+                for (char cur : s.toCharArray()) {
+                    tmp.add(prefix + cur);
+                }
+            }
+            res = tmp;
+        }
+        return res;
+    }
+}
+```
diff --git a/2019.01.11-leetcode17/WYJ.md b/2019.01.11-leetcode17/WYJ.md
new file mode 100644
index 000000000..6b50fc7d2
--- /dev/null
+++ b/2019.01.11-leetcode17/WYJ.md
@@ -0,0 +1,25 @@
+```java
+class Solution {
+    private List res = new ArrayList<>();
+    public List letterCombinations(String digits) {
+        if(digits.length() == 0){
+            return res;
+        }
+        String[] dic = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+        dfs(digits, 0, "", dic);
+        return res;
+        
+    }
+    private void dfs(String digits, int index, String s, String[] dic){
+        if(index == digits.length()){
+            res.add(s);
+            return;
+        }
+        int num = digits.charAt(index) - '0';
+        for(int i = 0; i < dic[num].length(); i++){
+            dfs(digits, index + 1, s + String.valueOf(dic[num].charAt(i)), dic);
+        }
+        return;
+    }
+}
+```
diff --git a/2019.01.11-leetcode17/sourcema.md b/2019.01.11-leetcode17/sourcema.md
new file mode 100644
index 000000000..7bad697a6
--- /dev/null
+++ b/2019.01.11-leetcode17/sourcema.md
@@ -0,0 +1,26 @@
+# leetcode 17
+    class Solution {
+    
+    static String[] letters = {"", "", "abc", "def", "ghi", "jkl", "mno", "pqrs", "tuv", "wxyz"};
+    public static List letterCombinations(String digits) {
+        List res = new ArrayList<>();
+        if (digits == null || digits.length() == 0) {
+            return res;
+        }
+        dfs(digits, res, 0, digits.length(), "");
+        return res;
+    }
+
+    private static void dfs(String digits, List res, int index, int length, String ret) {
+        if (index >= length) {
+            res.add(ret);
+            return;
+        }
+        int digit = digits.charAt(index) - '0';
+        for (int i = 0; i  letterCombinations(String digits) {
+        List res =  new ArrayList();
+        if (digits.length()==0) return res;
+        Map map = new HashMap<>();
+        map.put("2",new String[]{"a","b","c"});
+        map.put("3",new String[]{"d","e","f"});
+        map.put("4",new String[]{"g","h","i"});
+        map.put("5",new String[]{"j","k","l"});
+        map.put("6",new String[]{"m","n","o"});
+        map.put("7",new String[]{"p","q","r","s"});
+        map.put("8",new String[]{"t","u","v"});
+        map.put("9",new String[]{"w","x","y","z"});
+
+        List list = new ArrayList<>();
+        for (int i=0;i list, int depth, int width, List res, String tempStr){
+        for (int i=0;i letterCombinations(String digits) {
+		LinkedList res = new LinkedList<>();
+        if(digits.isEmpty()){
+        	return res;
+        }
+        String[]  mapping = {"0","1","abc","def","ghi","jkl","mno","pqrs","tuv","wxyz"};
+        res.add("");
+        
+        for(int i=0;i restoreIpAddresses(string s) {
+        vector res;
+        findIp(s, 0, 0, "", res);
+        return res;
+    }
+    void findIp(string s, int f, int idx, string ip, vector &res){
+        if(idx == 3){
+            if(s.size() - 1 - f < 3){
+                if(s[f] == '0' && f != s.size() - 1) return;
+                int num = stoi(s.substr(f, s.size() - f)); 
+                if(num < 256){
+                    ip += to_string(num);
+                    res.push_back(ip);
+                }
+            }
+        }
+        else{
+            for(int i = 1; i <= 3; i++){
+                if(f + i >= s.size()) break;
+                int num = stoi(s.substr(f, i));
+                if(num < 256)
+                    findIp(s, f + i, idx + 1, ip + to_string(num) + ".", res);
+                if(s[f] == '0' && i == 1) break;
+            }
+        }
+    }
+};
+```
diff --git a/2019.01.12-leetcode93/TheRocket.md b/2019.01.12-leetcode93/TheRocket.md
new file mode 100644
index 000000000..cd3d5260d
--- /dev/null
+++ b/2019.01.12-leetcode93/TheRocket.md
@@ -0,0 +1,38 @@
+```java
+class Solution {
+    public List restoreIpAddresses(String s) {
+        List res = new ArrayList<>();
+        if (s == null || s.length() < 4) {
+            return res;
+        }
+        dfs(s, res, new StringBuilder(), 0, 0);
+        return res;
+    }
+
+    private void dfs(String s, List res, StringBuilder ip, int index, int cnt) {
+        if (cnt > 4) {
+            return;
+        }
+        if (cnt == 4 && index == s.length()) {
+            res.add(ip.toString());
+            return;
+        }
+        for (int i = 1; i < 4; ++i) {
+            int end = index + i;
+            if (end > s.length()) {
+                break;
+            }
+            String sub = s.substring(index, end);
+            if ((sub.startsWith("0") && sub.length() > 1) || Integer.parseInt(sub) > 255) {
+                break;
+            }
+            if (cnt < 3) {
+                sub += ".";
+            }
+            ip.append(sub);
+            dfs(s, res, ip, end, cnt + 1);
+            ip.delete(ip.length() - sub.length(), ip.length());
+        }
+    }
+}
+```
diff --git a/2019.01.12-leetcode93/WYJ.md b/2019.01.12-leetcode93/WYJ.md
new file mode 100644
index 000000000..639ea6e15
--- /dev/null
+++ b/2019.01.12-leetcode93/WYJ.md
@@ -0,0 +1,29 @@
+```java
+class Solution {
+    private List res = new ArrayList<>();
+    public List restoreIpAddresses(String s) {
+        dfs(s, 0, "", 0);
+        return res;
+    }
+    private void dfs(String s, int index, String ip, int splitNum){
+        if(splitNum == 4){
+            if(index >= s.length()){
+                res.add(ip.substring(0, ip.length() - 1)); 
+            }
+            return;
+        }
+        for(int i = 1; i < 4&&index + i <= s.length(); i++){
+            String temp = s.substring(index, index + i);
+            if(temp.length() >1&&temp.charAt(0) == '0'){
+                return;
+            }
+            int num = Integer.valueOf(temp);
+            if(num > 255|| num < 0){
+                return;
+            }
+            dfs(s, index + i, ip + temp + ".", splitNum + 1);
+        }
+        return;
+    }
+}
+```
diff --git a/2019.01.12-leetcode93/marguerite.md b/2019.01.12-leetcode93/marguerite.md
new file mode 100644
index 000000000..1f617455c
--- /dev/null
+++ b/2019.01.12-leetcode93/marguerite.md
@@ -0,0 +1,90 @@
+给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
+
+示例:
+
+输入: "25525511135"
+输出: ["255.255.11.135", "255.255.111.35"]
+
+##这道题的主要思路是分治，将问题的规模不断缩小。回溯中好多的题目都是使用这个思想来解题的。
+
+IP地址被三个”.”分割成了4个部分，这里我把每一个部分叫做一个段，依次为第0段，第1段，第2段，第3段。
+
+那么给定一个只包含数字的字符串，如果求出有效的ip地址呢？ 
+以25525511135为例来分析。考虑第0段可能的取值，由于每一个段可以包含1位，2位或3位，那么第0段可能的取值是： 
+2 
+25 
+255
+
+##第0段取值以后后面的字符串需要被分割成3段，那么后面的字符能否被分割成3段呢？ 
+
+##第0段取上面的值后，剩余的部分依次为： 
+
+##5525511135 ，字符串的长度为10，而3段最长也只能为9，所以第0段取2时没有对应的有效ip地址。 
+
+##525511135 ，这里字符串的长度为9，即这个字符串还可能被分割成有效的3段。 
+
+##25511135 ，这里字符串的长度为8，即这个字符串还可能被分割成有效的3段。 
+
+##然后再对525511135和25511135求分割成3段的方法。这里问题规模就缩小了。需要被分割的段由4段变成了3了，字符串的长度也变短了。
+
+##递归退出的条件是遍历到字符串尾端并且字符串被分割成了4段。
+
+还需要注意的是:
+
+##如果一个段包含3个字符，那么这三个字符不能大于”255”,这是ip地址的基本知识；
+
+##如果一个字符包括2个或3个字符，它的第一个字符不能为0。
+
+```
+class Solution {
+public:
+    vector restoreIpAddresses(string s) {
+        vector result;
+        string path;
+        helper(s,0,0,path,result);
+        return result;
+    }
+
+    void helper(string &s,int num,int pos,string &path,vector& result)
+    {
+        //遍历完给定字符串，并且生成了个段时
+        if(pos==s.size()&&num==4)
+        {
+            //这里需要去除掉path最后的.
+            result.push_back(path.substr(0,path.size()-1));
+            return;
+        }
+
+        //如果该段包含的字符数大于规定的最大数目，那么直接退出，可以把这个判断放在下面的if中，
+        //但是三个if都需要加，所以放在这儿更简洁一些。
+        if(s.size()-pos>3*(4-num))
+            return;
+
+        //该段只含有一个字符
+        if(pos restoreIpAddresses(String s) {
+        List res = new ArrayList<>();
+        if (s == null || s.length() == 0||s.length()<4||s.length()>12) {
+            return res;
+        }
+        dfs(s, res, 0, "");
+        return res;
+    }
+
+    private static void dfs(String ip, List res, int index, String ret) {
+        if (index == 3) {
+           if ((ip.length()==1||(ip.length()>1&&ip.length()<4&&ip.charAt(0)!='0'))
+                    &&Integer.valueOf(ip) <= 255) {//Integer.valueOf(ip)防止ip的位数超出int范围 首位不能以0开头
+                res.add(ret+ip);
+            }
+            return;
+        }
+        for (int i = 1; i < 4; i++) {
+            String split = ip.substring(0, i>ip.length()?ip.length():i);//可能出现ip的长度小于i的情况，不够长度去切分
+            if ((split.length()==1||(split.length()>1&&split.charAt(0)!='0'))
+                    &&Integer.valueOf(split) <= 255) {
+                ret = ret + split + ".";
+                dfs(ip.substring(i>ip.length()?ip.length():i),res,index+1,ret);
+                ret = ret.substring(0,ret.length() - split.length() - 1);
+            }
+        }
+    }
+}
diff --git "a/2019.01.12-leetcode93/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.12-leetcode93/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..06aa4541b
--- /dev/null
+++ "b/2019.01.12-leetcode93/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,31 @@
+```java
+    public List restoreIpAddresses(String s) {
+
+        List res = new ArrayList<>();
+        if (s.length()<4||s.length()>12) return res;
+        getRes(s,4,"",res);
+        return res;
+    }
+
+    public void getRes(String currStr, int rdeep, String currResStr, List res){
+        if (currStr.length()rdeep*3) return;
+        if (rdeep==1){
+            if (currStr.length()>1&&currStr.startsWith("0")) return;//排除长度大于1且开头为0的情况
+            if (currStr.length()==3&&Integer.valueOf(currStr)>255) return;//排除长度为3且大于255的情况
+            res.add(currResStr+"."+currStr);
+            return;
+        }
+        for (int i=1;i<4;i++){
+            if (i>=currStr.length()) break;
+            if (i>1&&currStr.startsWith("0")) break; //排除长度大于1且开头为0的情况
+            if (i!=3||Integer.valueOf(currStr.substring(0,i))<=255) {  //排除长度为3且大于255的情况
+                if (currResStr.equals("")) {
+                    getRes(currStr.substring(i),rdeep-1,currStr.substring(0,i),res);
+                }else{
+                    getRes(currStr.substring(i),rdeep-1,currResStr+"."+currStr.substring(0,i),res);
+                }
+
+            }
+        }
+    }
+```
diff --git "a/2019.01.12-leetcode93/\345\244\215\345\216\237IP\345\234\260\345\235\200" "b/2019.01.12-leetcode93/\345\244\215\345\216\237IP\345\234\260\345\235\200"
new file mode 100644
index 000000000..0d9fb59d5
--- /dev/null
+++ "b/2019.01.12-leetcode93/\345\244\215\345\216\237IP\345\234\260\345\235\200"
@@ -0,0 +1,6 @@
+给定一个只包含数字的字符串，复原它并返回所有可能的 IP 地址格式。
+
+示例:
+
+输入: "25525511135"
+输出: ["255.255.11.135", "255.255.111.35"]
diff --git "a/2019.01.12-leetcode93/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.12-leetcode93/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..8fb22b4ce
--- /dev/null
+++ "b/2019.01.12-leetcode93/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,30 @@
+```
+class Solution {
+    public List restoreIpAddresses(String s) {
+         List res = new LinkedList();
+        if(s.length()==0||null==s){
+        	return res;
+        }
+        dfs(s, res, "", 0, 0);
+        return res;
+    }
+    
+     public void dfs(String s,List res,String ip,int idx,int count){
+    	if(count>4) return;
+    	if(count==4&&s.length()==idx){
+    		res.add(ip);
+    		return;
+    	}
+    	
+    	for(int i=1;i<4;i++){
+    		//s.length()-idx > (4-count)*3
+    		if(idx+i>s.length()) break;
+    		String sub = s.substring(idx, idx+i);
+    		if(sub.startsWith("0")&&sub.length()>1||Integer.parseInt(sub)>=256) break;
+    		dfs(s, res, ip+sub+(count==3?"":"."), idx+i, count+1);
+    	}
+    	
+    }
+}
+
+```
diff --git a/2019.01.13-leetcode79/Ostrichcrab.md b/2019.01.13-leetcode79/Ostrichcrab.md
new file mode 100644
index 000000000..503b5d84f
--- /dev/null
+++ b/2019.01.13-leetcode79/Ostrichcrab.md
@@ -0,0 +1,30 @@
+```
+class Solution {
+public:
+    bool dfs(vector>& board, string word,int x, int y, int len)
+    {
+        if(len == word.length()) return true;
+        if(x<0||y<0||x>=board.size()||y>=board[0].size()||board[x][y]!=word[len]) 
+            return false;
+        board[x][y]^=128;
+        bool res = dfs(board,word,x-1,y,len+1)||
+                   dfs(board,word,x+1,y,len+1)||
+                   dfs(board,word,x,y+1,len+1)||
+                   dfs(board,word,x,y-1,len+1) ;
+        board[x][y]^=128;
+        return res;
+    }
+    bool exist(vector>& board, string word) {
+        int n = board.size();
+        int m = board[0].size();
+        for(int i = 0; i < n; i++)
+        {
+            for(int j = 0; j < m; j++)
+            {
+                if(dfs(board,word,i,j,0)) return true;
+            }
+        }
+        return false;
+    }
+};
+```
diff --git a/2019.01.13-leetcode79/TheRocket.md b/2019.01.13-leetcode79/TheRocket.md
new file mode 100644
index 000000000..73b66409b
--- /dev/null
+++ b/2019.01.13-leetcode79/TheRocket.md
@@ -0,0 +1,30 @@
+```java
+class Solution {
+    public boolean exist(char[][] board, String word) {
+        for (int i = 0; i < board.length; ++i) {
+            for (int j = 0; j < board[0].length; ++j) {
+                if (dfs(board, i, j, word, 0)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    private boolean dfs(char[][] board, int i, int j, String word, int index) {
+        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || board[i][j] != word.charAt(index)) {
+            return false;
+        }
+        if (index == word.length() - 1) {
+            return true;
+        }
+        board[i][j] ^= 128;
+        boolean flag = dfs(board, i - 1, j, word, index + 1) ||
+                dfs(board, i + 1, j, word, index + 1) ||
+                dfs(board, i, j - 1, word, index + 1) ||
+                dfs(board, i, j + 1, word, index + 1);
+        board[i][j] ^= 128;
+        return flag;
+    }
+}
+```
diff --git a/2019.01.13-leetcode79/WYJ.md b/2019.01.13-leetcode79/WYJ.md
new file mode 100644
index 000000000..5d996ac5b
--- /dev/null
+++ b/2019.01.13-leetcode79/WYJ.md
@@ -0,0 +1,38 @@
+```java
+class Solution {
+    private boolean[][] used;
+    public boolean exist(char[][] board, String word) {
+        if(word.length() == 0 || board.length == 0 ||board[0].length == 0){
+            return false;
+        }
+        used = new boolean[board.length][board[0].length];
+        for(int i = 0; i < board.length; i++){
+            for(int j = 0; j < board[0].length; j++){
+                dfs(board, word, 0, i, j);
+            }
+        }
+        return res.size() != 0;
+    }
+    private boolean dfs(char[][] board, String word, int index, int i, int j){
+        if(index == word.length()){
+            return true;
+        }
+        if(i < 0||i >= board.length||j < 0||j >= board[0].length||used[i][j]){
+            return false;
+        }
+        if(index < word.length()&&board[i][j]!=word.charAt(index)){
+            return false;
+        }
+
+        used[i][j] = true;
+        if(dfs(board, word, index + 1, i - 1, j)
+            ||dfs(board, word, index + 1, i + 1, j)
+            ||dfs(board, word, index + 1, i, j - 1)
+            ||dfs(board, word, index + 1, i, j + 1)){
+            return true;
+        }
+        used[i][j] = false;
+        return false;
+    } 
+}
+```
diff --git a/2019.01.13-leetcode79/sourcema.md b/2019.01.13-leetcode79/sourcema.md
new file mode 100644
index 000000000..8996c93c5
--- /dev/null
+++ b/2019.01.13-leetcode79/sourcema.md
@@ -0,0 +1,33 @@
+# leetcode 79
+    class Solution {
+    public boolean exist(char[][] board, String word) {
+        if (board[0].length == 0 || board.length == 0) {
+            return false;
+        }
+        int row=board.length,col=board[0].length,count=0;
+        boolean flag=false;
+        go:
+        for (int i = 0; i < row; i++) {
+            for (int j = 0; j < col; j++) {
+                flag=dfs(board,word,i,j,count);
+                if (flag) {
+                    break go;
+                }
+            }
+        }
+        return flag;
+    }
+    private  boolean dfs(char[][] board, String word,int i, int j, int count) {
+        if (count == word.length()) {
+            return true;
+        }
+        if (i < 0 || i >= board.length || j < 0 || j >= board[0].length || word.charAt(count) != board[i][j]) {
+            return false;
+        }
+        board[i][j]^=256;
+        boolean flag=dfs(board,word,i+1,j,count+1)||dfs(board,word,i-1,j,count+1)
+                ||dfs(board,word,i,j+1,count+1)||dfs(board,word,i,j-1,count+1);
+        board[i][j]^=256;
+        return flag;
+    }
+}
diff --git "a/2019.01.13-leetcode79/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.13-leetcode79/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..6705fb5e2
--- /dev/null
+++ "b/2019.01.13-leetcode79/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,39 @@
+```java
+  public boolean exist(char[][] board, String word) {
+
+        if (board.length==0) return false;
+        int[][] boardBak = new int[board.length][board[0].length];
+
+        char[] chars = word.toCharArray();
+        for (int i=0;i=board.length||j<0||j>=board[0].length) return false;
+        if (boardBak[i][j]==1) return false;
+        boolean up=false,down=false,left=false,right=false;
+
+        if (board[i][j]==chars[deep]){
+            boardBak[i][j]=1;
+            if (chars.length==deep+1) {
+                return true;
+            }
+            up=(deepsearch(i-1,j,board,boardBak,chars,deep+1));
+            if (!up) down=deepsearch(i+1,j,board,boardBak,chars,deep+1);
+            if (!(up||down))left=deepsearch(i,j-1,board,boardBak,chars,deep+1);
+            if (!(up||down||left))right=deepsearch(i,j+1,board,boardBak,chars,deep+1);
+        }
+        if (up||down||left||right) {
+            return true;
+        }else {
+            boardBak[i][j]=0;
+            return false;
+        }
+    }
+```
diff --git "a/2019.01.13-leetcode79/\345\215\225\350\257\215\346\220\234\347\264\242" "b/2019.01.13-leetcode79/\345\215\225\350\257\215\346\220\234\347\264\242"
new file mode 100644
index 000000000..6f66c0f1e
--- /dev/null
+++ "b/2019.01.13-leetcode79/\345\215\225\350\257\215\346\220\234\347\264\242"
@@ -0,0 +1,16 @@
+给定一个二维网格和一个单词，找出该单词是否存在于网格中。
+
+单词必须按照字母顺序，通过相邻的单元格内的字母构成，其中“相邻”单元格是那些水平相邻或垂直相邻的单元格。同一个单元格内的字母不允许被重复使用。
+
+示例:
+
+board =
+[
+  ['A','B','C','E'],
+  ['S','F','C','S'],
+  ['A','D','E','E']
+]
+
+给定 word = "ABCCED", 返回 true.
+给定 word = "SEE", 返回 true.
+给定 word = "ABCB", 返回 false.
diff --git "a/2019.01.13-leetcode79/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.13-leetcode79/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..fcd92bad9
--- /dev/null
+++ "b/2019.01.13-leetcode79/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,35 @@
+```
+class Solution {
+    public boolean exist(char[][] board, String word) {
+		if (word.length()==0||word.isEmpty()) {
+			return true;
+		}
+
+		for (int i = 0; i < board.length; i++) {
+			for (int j = 0; j < board[0].length; j++) {
+				if(dfs(board, word, 0, i, j)){
+					return true;
+				}
+			}
+		}
+		return false;
+    }
+    
+	public static boolean dfs(char[][] board, String words, int idx, int i, int j) {
+		if(idx==words.length()){
+			return true;
+		}
+		if(i<0||i==board.length||j<0||j==board[0].length){
+			return false;
+		}
+		if(board[i][j]!=words.charAt(idx)){
+			return false;
+		}
+		board[i][j] ^= 256;
+		boolean exist = dfs(board, words, idx+1, i, j+1)||dfs(board, words, idx+1, i, j-1)||
+				dfs(board, words, idx+1, i+1, j)||dfs(board, words, idx+1, i-1, j);
+		board[i][j] ^= 256;
+		return exist;
+	}
+}
+```
diff --git a/2019.01.14-leetcode257/Ostrichcrab.md b/2019.01.14-leetcode257/Ostrichcrab.md
new file mode 100644
index 000000000..04453ed9a
--- /dev/null
+++ b/2019.01.14-leetcode257/Ostrichcrab.md
@@ -0,0 +1,33 @@
+```
+/**
+ * Definition for a binary tree node.
+ * struct TreeNode {
+ *     int val;
+ *     TreeNode *left;
+ *     TreeNode *right;
+ *     TreeNode(int x) : val(x), left(NULL), right(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    void dfs(TreeNode* root, vector &str, string strpath)
+    {
+        if(root->left==nullptr&&root->right==nullptr){
+            str.push_back(strpath);
+            return;
+        }
+        if(root->left){
+            dfs(root->left,str,strpath+"->"+to_string(root->left->val));
+        }
+        if(root->right){
+            dfs(root->right,str,strpath+"->"+to_string(root->right->val));
+        }
+    }
+    vector binaryTreePaths(TreeNode* root) {
+        vector res;
+        if(root==nullptr) return res;
+        dfs(root,res,to_string(root->val));
+        return res;
+    }
+};
+```
diff --git a/2019.01.14-leetcode257/TheRocket.md b/2019.01.14-leetcode257/TheRocket.md
new file mode 100644
index 000000000..00d912e20
--- /dev/null
+++ b/2019.01.14-leetcode257/TheRocket.md
@@ -0,0 +1,33 @@
+```java
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List binaryTreePaths(TreeNode root) {
+        List res = new ArrayList<>();
+        if (root != null) {
+            dfs(root, String.valueOf(root.val), res);
+        }
+        return res;
+    }
+
+    private void dfs(TreeNode root, String path, List res) {
+        if (root.left == null && root.right == null) {
+            res.add(path);
+            return;
+        }
+        if (root.left != null) {
+            dfs(root.left, path + "->" + root.left.val, res);
+        }
+        if (root.right != null) {
+            dfs(root.right, path + "->" + root.right.val, res);
+        }
+    }
+}
+```
diff --git a/2019.01.14-leetcode257/marguerite.md b/2019.01.14-leetcode257/marguerite.md
new file mode 100644
index 000000000..3a1264571
--- /dev/null
+++ b/2019.01.14-leetcode257/marguerite.md
@@ -0,0 +1,39 @@
+```
+ /**
+     * 递归方式
+     * @param root
+     * @return
+     */
+     
+ ```
+    public List binaryTreePaths(TreeNode root) {
+        if (root == null) {
+            return resultList;
+        }
+        List singleResult = new ArrayList<>();
+
+        getTreePath(root, singleResult);
+        return resultList;
+    }
+    
+```
+ /**
+     * DFS深度优先遍历
+     * @param resultList
+     * @param node
+     * @param singleResult
+     */
+```     
+    private void getTreePath(TreeNode node, List singleResult) {
+        singleResult.add(node.val + "");
+        if (node.left == null && node.right == null) {
+            resultList.add(getPath(singleResult));
+        }
+        if (node.left != null) {
+            getTreePath(node.left, new ArrayList<>(singleResult));
+        }
+        if (node.right != null) {
+            getTreePath(node.right, new ArrayList<>(singleResult));
+        }
+    }
+```
diff --git a/2019.01.14-leetcode257/sourcema.md b/2019.01.14-leetcode257/sourcema.md
new file mode 100644
index 000000000..d48b53171
--- /dev/null
+++ b/2019.01.14-leetcode257/sourcema.md
@@ -0,0 +1,25 @@
+# leetcode 257
+    class Solution {
+        public List binaryTreePaths(TreeNode root) {
+            List list = new ArrayList<>();
+            if (root == null) {
+                return list;
+            }
+            dfs(root, list,new String());
+            return list;
+        }
+        private void dfs(TreeNode root, List list,String ret) {
+            if (root.left==null&&root.right==null) {
+                ret+=root.val;
+                list.add(ret);
+                return;
+            }
+            ret += root.val + "->";
+            if(root.left!=null){
+            dfs(root.left,list,ret);
+            }
+            if(root.right!=null){
+            dfs(root.right,list,ret);
+            }
+        }
+    }
diff --git "a/2019.01.14-leetcode257/\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204" "b/2019.01.14-leetcode257/\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204"
new file mode 100644
index 000000000..2e9d87f64
--- /dev/null
+++ "b/2019.01.14-leetcode257/\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204"
@@ -0,0 +1,17 @@
+给定一个二叉树，返回所有从根节点到叶子节点的路径。
+
+说明: 叶子节点是指没有子节点的节点。
+
+示例:
+
+输入:
+
+   1
+ /   \
+2     3
+ \
+  5
+
+输出: ["1->2->5", "1->3"]
+
+解释: 所有根节点到叶子节点的路径为: 1->2->5, 1->3
diff --git "a/2019.01.14-leetcode257/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.14-leetcode257/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..d6d4b1776
--- /dev/null
+++ "b/2019.01.14-leetcode257/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,23 @@
+```java
+    public List binaryTreePaths(TreeNode root) {
+
+        List res = new ArrayList<>();
+        if (root==null) return res;
+        deepsearch(root, "", res);
+        return res;
+    }
+
+    public void deepsearch(TreeNode node, String currStr, List res){
+
+        if (node.left==null&&node.right==null) {
+            currStr = currStr + node.val;
+            res.add(currStr);
+            return;
+        }
+
+        currStr = currStr + node.val + "->";
+
+        if (node.left!=null) deepsearch(node.left,currStr,res);
+        if (node.right!=null) deepsearch(node.right,currStr,res);
+    }
+```
diff --git "a/2019.01.14-leetcode257/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.14-leetcode257/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..57e954076
--- /dev/null
+++ "b/2019.01.14-leetcode257/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,32 @@
+```
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     int val;
+ *     TreeNode left;
+ *     TreeNode right;
+ *     TreeNode(int x) { val = x; }
+ * }
+ */
+class Solution {
+    public List binaryTreePaths(TreeNode root) {
+        List res = new ArrayList<>();
+		if(null!=root){
+			DFS(root,"",res);
+		}
+		return res;
+    }
+    
+    public void DFS(TreeNode node,String path,List res){
+		if(node.left==null&&node.right==null){
+			res.add(path+node.val);
+		}
+		if(node.left!=null){
+			DFS(node.left,path+node.val+"->",res);
+		}
+		if(node.right!=null){
+			DFS(node.right,path+node.val+"->",res);
+		}
+	}
+}
+```
diff --git a/2019.01.15-leetcode46/Ostrichctab.md b/2019.01.15-leetcode46/Ostrichctab.md
new file mode 100644
index 000000000..843cd21c7
--- /dev/null
+++ b/2019.01.15-leetcode46/Ostrichctab.md
@@ -0,0 +1,29 @@
+```
+class Solution {
+public:
+    void dfs(vector& nums, vector> &res, vector t, vector &flag)
+    {
+        if(t.size()==nums.size()) {
+            res.push_back(t);
+            return ;
+        }
+        for(int i = 0; i> permute(vector& nums) {
+        vector> res;
+        vector t;
+        vector flag(nums.size(),0);
+        if(nums.size()==0) return res;
+        dfs(nums,res,t,flag);
+        return res;
+    }
+};
+```
diff --git a/2019.01.15-leetcode46/TheRocket.md b/2019.01.15-leetcode46/TheRocket.md
new file mode 100644
index 000000000..ee1ed8a9f
--- /dev/null
+++ b/2019.01.15-leetcode46/TheRocket.md
@@ -0,0 +1,31 @@
+```java
+class Solution {
+    public List> permute(int[] nums) {
+        List> res = new ArrayList<>();
+        dfs(nums, res, 0);
+        return res;
+    }
+
+    private void dfs(int[] nums, List> res, int s) {
+        if (s == nums.length) {
+            List list = new ArrayList<>(nums.length);
+            for (int num : nums) {
+                list.add(num);
+            }
+            res.add(list);
+            return;
+        }
+        for (int i = s; i < nums.length; ++i) {
+            swap(nums, i, s);
+            dfs(nums, res, s + 1);
+            swap(nums, i, s);
+        }
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}
+```
diff --git a/2019.01.15-leetcode46/marguerite.md b/2019.01.15-leetcode46/marguerite.md
new file mode 100644
index 000000000..ec8050bf1
--- /dev/null
+++ b/2019.01.15-leetcode46/marguerite.md
@@ -0,0 +1,27 @@
+```
+public class Solution {
+    public List> permute(int[] nums) {
+        List> res = new ArrayList>();
+        ArrayList temp = new ArrayList();
+        dfs(res, nums, 0);
+        return res;
+    }
+    private void dfs(List> res, int[] nums, int j) {
+        if (j == nums.length) {
+            List temp = new ArrayList();
+            for (int num : nums) temp.add(num);
+            res.add(temp);
+        }
+        for (int i = j; i < nums.length; i++) {
+            swap(nums, i, j);
+            dfs(res, nums, j+1);
+            swap(nums, i, j);
+        }
+    }
+    private void swap(int[] nums, int m, int n) {
+        int temp = nums[m];
+        nums[m] = nums[n];
+        nums[n] = temp;
+    }
+}
+```
diff --git "a/2019.01.15-leetcode46/\345\205\250\346\216\222\345\210\227" "b/2019.01.15-leetcode46/\345\205\250\346\216\222\345\210\227"
new file mode 100644
index 000000000..0806df0a2
--- /dev/null
+++ "b/2019.01.15-leetcode46/\345\205\250\346\216\222\345\210\227"
@@ -0,0 +1,14 @@
+给定一个没有重复数字的序列，返回其所有可能的全排列。
+
+示例:
+
+输入: [1,2,3]
+输出:
+[
+  [1,2,3],
+  [1,3,2],
+  [2,1,3],
+  [2,3,1],
+  [3,1,2],
+  [3,2,1]
+]
diff --git "a/2019.01.15-leetcode46/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.15-leetcode46/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..f76ad5e90
--- /dev/null
+++ "b/2019.01.15-leetcode46/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,36 @@
+```java
+    public List> permute(int[] nums) {
+        List> res = new ArrayList<>();
+        List currRes = new ArrayList<>();
+        fenzhi(nums,0,currRes,res);
+        return res;
+    }
+
+    public void fenzhi(int[] nums, int deep, List currRes, List> res){
+        if (nums.length==1){
+            currRes.add(nums[0]);
+            List tempRes = new ArrayList<>();
+            for (int i=0;ideep){
+                currRes.remove(currRes.size()-1);
+            }
+            int[] nextNums = new int[nums.length-1];
+            for (int j=0,k=0;j> permute(int[] nums) {
+        List> res = new ArrayList<>();
+        if(null==nums||nums.length==0){
+        	return res;
+        }
+        List l0 = new ArrayList<>();
+        l0.add(nums[0]);
+        res.add(l0);
+        for(int i=1;i> new_ans = new ArrayList>();
+        	for(int j=0;j<=i;++j){
+        		for(List l:res){
+        			List new_l = new ArrayList(l);
+        			new_l.add(j, nums[i]);
+        			new_ans.add(new_l);
+        		}
+        	}
+        	res = new_ans;
+        }
+        return res;
+    }
+    
+    public static void main(String[] args) {
+    	int[] nums = {1,2,3};
+		System.out.println(permute(nums));
+	}
+}
+```
diff --git a/2019.01.16-leetcode47/Ostrichcrab.md b/2019.01.16-leetcode47/Ostrichcrab.md
new file mode 100644
index 000000000..9bbe68a96
--- /dev/null
+++ b/2019.01.16-leetcode47/Ostrichcrab.md
@@ -0,0 +1,14 @@
+```
+class Solution {
+public:
+    vector> permuteUnique(vector& nums) {
+        vector> res;
+        sort(nums.begin(),nums.end());
+        do
+        {
+            res.push_back(nums);
+        }while(next_permutation(nums.begin(),nums.end()));
+        return res;
+    }
+};
+```
diff --git a/2019.01.16-leetcode47/TheRocket.md b/2019.01.16-leetcode47/TheRocket.md
new file mode 100644
index 000000000..9e249df28
--- /dev/null
+++ b/2019.01.16-leetcode47/TheRocket.md
@@ -0,0 +1,43 @@
+```java
+class Solution {
+    public List> permuteUnique(int[] nums) {
+        List> res = new ArrayList<>();
+        dfs(nums, res, 0);
+        return res;
+    }
+
+    private void dfs(int[] nums, List> res, int s) {
+        if (s == nums.length) {
+            List list = new ArrayList<>(nums.length);
+            for (int num : nums) {
+                list.add(num);
+            }
+            res.add(list);
+            return;
+        }
+        for (int i = s; i < nums.length; ++i) {
+            if (isDuplicate(nums, s, i)) {
+                continue;
+            }
+            swap(nums, i, s);
+            dfs(nums, res, s + 1);
+            swap(nums, i, s);
+        }
+    }
+
+    private boolean isDuplicate(int[] nums, int s, int e) {
+        for (int i = s; i < e; ++i) {
+            if (nums[i] == nums[e]) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private void swap(int[] nums, int i, int j) {
+        int tmp = nums[i];
+        nums[i] = nums[j];
+        nums[j] = tmp;
+    }
+}
+```
diff --git a/2019.01.16-leetcode47/marguerite.md b/2019.01.16-leetcode47/marguerite.md
new file mode 100644
index 000000000..2ec7cdc0a
--- /dev/null
+++ b/2019.01.16-leetcode47/marguerite.md
@@ -0,0 +1,34 @@
+#使用递归
+
+```
+public class Solution {
+    public List> permuteUnique(int[] nums) {
+        List> result = new ArrayList>();
+        if (nums.length == 0)
+            return null;
+        Arrays.sort(nums);
+        getResult(result,nums,new ArrayList(),0,new int[nums.length]);
+        return result;
+    }
+ 
+    public static void getResult(List> result,int[] nums,List ans,int num,int[] pos){
+        if( num == nums.length){
+            result.add(new ArrayList(ans));
+            return ;
+        }
+        for( int i = 0 ; i> res = new ArrayList>();
+
+    public List> permuteUnique(int[] nums) {
+
+        int len = nums.length;
+        if (len==0) return res;
+        huisu(0,len,nums);
+        return res;
+    }
+
+    public void huisu(int deep, int len, int[] nums){
+
+        if (deep==len-1){
+            List tempList = new ArrayList<>();
+            for (int i=0;i> combine(int n, int k) {
+        vector> res;
+        vector out;
+        helper(n, k, 1, out, res);
+        return res;
+    }
+    void helper(int n, int k, int level, vector& out, vector>& res) {
+        if (out.size() == k) res.push_back(out);
+        for (int i = level; i <= n; ++i) {
+            out.push_back(i);
+            helper(n, k, i + 1, out, res);
+            out.pop_back();
+        }
+    }
+};
+```
diff --git a/2019.01.17-leetcode77/TheRocket.md b/2019.01.17-leetcode77/TheRocket.md
new file mode 100644
index 000000000..fce0e875b
--- /dev/null
+++ b/2019.01.17-leetcode77/TheRocket.md
@@ -0,0 +1,22 @@
+```java
+class Solution {
+    public List> combine(int n, int k) {
+        List> res = new ArrayList<>();
+        List list = new ArrayList<>(k);
+        dfs(n, k, 1, res, list);
+        return res;
+    }
+
+    private void dfs(int n, int k, int s, List> res, List list) {
+        if (list.size() == k) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+        for (int i = s; i <= n; ++i) {
+            list.add(i);
+            dfs(n, k, i + 1, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.17-leetcode77/sourcema.md b/2019.01.17-leetcode77/sourcema.md
new file mode 100644
index 000000000..6e640b64c
--- /dev/null
+++ b/2019.01.17-leetcode77/sourcema.md
@@ -0,0 +1,20 @@
+# leetcode 77
+    class Solution {
+    public List> combine(int n, int k) {
+        List> res = new ArrayList<>();
+        List list = new ArrayList<>();
+        dfs(n, k, res, list, 1);
+        return res;
+    }
+    public void dfs(int n, int k, List> res, List list, int start){
+        if(list.size() == k){
+            res.add(new ArrayList(list));
+            return;
+        }
+        for(int i = start; i <= n; i++){
+            list.add(i);
+            dfs(n, k, res, list, i + 1);
+            list.remove(list.size() - 1);
+        }
+    }
+}
diff --git "a/2019.01.17-leetcode77/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.17-leetcode77/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..8b00263d7
--- /dev/null
+++ "b/2019.01.17-leetcode77/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,28 @@
+```java
+    public List> combine(int n, int k) {
+
+        List> res = new ArrayList<>();
+        int[] box = new int[k];
+        fenzhi(0,0,n,k,box,res);
+
+        return res;
+    }
+
+    public void fenzhi(int deep, int index, int n, int k, int[] box, List> res){
+
+        if (deep==k){
+            List tempList = new ArrayList<>();
+            for (int i=0;i> combine(int n, int k) {
+        List> res = new ArrayList<>();
+        combine(res, new ArrayList(), 1, n, k);
+        return res;
+    }
+    
+    public static void combine(List> res,List comb,int start,int n,int k){
+    	if(k==0){
+    		res.add(new ArrayList(comb));
+    		return;
+    	}
+    	
+    	for(int i=start;i<=n;i++){
+    		comb.add(i);
+    		combine(res, comb, i+1, n, k-1);
+    		comb.remove(comb.size()-1);
+    	}
+    }
+    
+    public static void main(String[] args) {
+		List> res = combine(5, 2);
+		System.out.println(res);
+	}
+}
+```
diff --git "a/2019.01.17-leetcode77/\347\273\204\345\220\210" "b/2019.01.17-leetcode77/\347\273\204\345\220\210"
new file mode 100644
index 000000000..f69606127
--- /dev/null
+++ "b/2019.01.17-leetcode77/\347\273\204\345\220\210"
@@ -0,0 +1,14 @@
+给定两个整数 n 和 k，返回 1 ... n 中所有可能的 k 个数的组合。
+
+示例:
+
+输入: n = 4, k = 2
+输出:
+[
+  [2,4],
+  [3,4],
+  [2,3],
+  [1,2],
+  [1,3],
+  [1,4],
+]
diff --git a/2019.01.18-leetcode39/Ostrichcrab.md b/2019.01.18-leetcode39/Ostrichcrab.md
new file mode 100644
index 000000000..25b5fd92d
--- /dev/null
+++ b/2019.01.18-leetcode39/Ostrichcrab.md
@@ -0,0 +1,24 @@
+```
+class Solution {
+public:
+    void dfs(vector candidates, int start, int target, vector item, vector>& res)
+    {
+        if(target<0) return;
+        if(target==0) {
+            res.push_back(item);
+            return ;
+        }
+        for(int i = start; i < candidates.size(); i++){
+            item.push_back(candidates[i]);
+            dfs(candidates,i,target-candidates[i],item,res);
+            item.pop_back();
+        }
+    }
+    vector> combinationSum(vector& candidates, int target) {
+        vector> res;
+        vector item;
+        dfs(candidates,0,target,item,res);
+        return res;
+    }
+};
+```
diff --git a/2019.01.18-leetcode39/TheRocket.md b/2019.01.18-leetcode39/TheRocket.md
new file mode 100644
index 000000000..69c7d7f80
--- /dev/null
+++ b/2019.01.18-leetcode39/TheRocket.md
@@ -0,0 +1,24 @@
+```java
+class Solution {
+    public List> combinationSum(int[] candidates, int target) {
+        List> res = new ArrayList<>();
+        dfs(candidates, target, 0, res, new ArrayList());
+        return res;
+    }
+
+    private void dfs(int[] candidates, int target, int s, List> res, ArrayList list) {
+        if (target < 0) {
+            return;
+        }
+        if (target == 0) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+        for (int i = s; i < candidates.length; ++i) {
+            list.add(candidates[i]);
+            dfs(candidates, target - candidates[i], i, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.18-leetcode39/sourcema.md b/2019.01.18-leetcode39/sourcema.md
new file mode 100644
index 000000000..a7c22326e
--- /dev/null
+++ b/2019.01.18-leetcode39/sourcema.md
@@ -0,0 +1,32 @@
+# leetcode 39
+    class Solution {
+    public List> combinationSum(int[] candidates, int target) {
+         List> res = new ArrayList<>();
+        if (candidates == null || candidates.length == 0 || target <= 0) {
+            return res;
+        }
+        Arrays.sort(candidates);
+        combination(res,candidates,new ArrayList(),target,0,candidates.length);
+        return res;
+    }
+    private static void combination(List> res,int [] arr, ArrayList list,
+                                    int target, int index, int length) {
+        if (target == 0) {
+            ArrayList temp=new ArrayList<>(list);
+            Collections.sort(temp);
+            if (!res.contains(temp)) {
+                res.add(new ArrayList(temp));
+            }
+            return;
+        }
+        if (index >= length) {
+            return;
+        }
+        for (int i = index; i> combinationSum(int[] candidates, int target) {
+
+        List> res = new ArrayList<>();
+        List box = new ArrayList<>();
+        Arrays.sort(candidates);
+
+        for (int i=0;i(),res);
+        }
+
+        return res;
+    }
+
+    public void huisu(int currSum, int target, int index, int[] candidates, List box, List> res){
+
+        if (index==candidates.length)return;
+        int count = 0;
+        while (currSumtarget) break;
+            box.add(candidates[index]);
+            count++;
+            if (currSum==target){
+                res.add(new ArrayList(box));
+                break;
+            }
+            for (int i=index+1;i> combinationSum(int[] candidates, int target) {
+        List> res = new ArrayList<>();
+    	if(candidates.length==0||null==candidates){
+    		return res;
+    	}
+        comb(res, candidates, new ArrayList(), target, 0,0);
+        return res; 
+    }
+    
+    public void comb(List> res,int[] candidates,List com,int target,int start,int sum){
+    	if(sum==target){
+    		res.add(new ArrayList<>(com));
+    		return;
+    	}else if(sum>target){
+    		return;
+    	}
+    	
+    	for(int i=start;i> result;
+	vector> combinationSum2(vector& candidates, int target) {
+		sort(candidates.begin(), candidates.end());
+		combinate(candidates, candidates.size() - 1, {}, target);
+		return result;
+	}
+	void combinate(vector& candidates, int pos, vectorcontain, int target)
+	{
+		if (target == 0)
+			result.push_back(contain);
+		if (target < 0)
+			return;
+		for (int i = pos; i >= 0; i--)
+		{
+			if (i != pos && candidates[i] == candidates[i + 1]) //important!
+				continue;
+			contain.push_back(candidates[i]);
+			combinate(candidates, i - 1, contain, target - candidates[i]);
+			contain.pop_back();
+		}
+	}
+};
+```
diff --git a/2019.01.19-leetcode40/TheRocket.md b/2019.01.19-leetcode40/TheRocket.md
new file mode 100644
index 000000000..1a610de3b
--- /dev/null
+++ b/2019.01.19-leetcode40/TheRocket.md
@@ -0,0 +1,30 @@
+```java
+class Solution {
+    public List> combinationSum2(int[] candidates, int target) {
+        Arrays.sort(candidates);
+        List> res = new ArrayList<>();
+        dfs(candidates, target, 0, res, new ArrayList<>());
+        return res;
+    }
+
+    private void dfs(int[] candidates, int target, int s, List> res, ArrayList list) {
+        if (target < 0) {
+            return;
+        }
+        if (target == 0) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+        for (int i = s; i < candidates.length; ++i) {
+            // 不允许重复使用
+            if (i > s && candidates[i] == candidates[i - 1]) {
+                continue;
+            }
+            list.add(candidates[i]);
+            // 传入下一层的起始参数为 i + 1
+            dfs(candidates, target - candidates[i], i + 1, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.19-leetcode40/sourcema.md b/2019.01.19-leetcode40/sourcema.md
new file mode 100644
index 000000000..80d205e69
--- /dev/null
+++ b/2019.01.19-leetcode40/sourcema.md
@@ -0,0 +1,27 @@
+# leetcode 40
+    class Solution {
+    public List> combinationSum2(int[] candidates, int target) {
+         List> res = new ArrayList<>();
+        if (candidates == null || candidates.length == 0 || target <= 0) {
+            return res;
+        }
+        Arrays.sort(candidates);//
+        combination(res,candidates,new ArrayList(),target,0);
+        return res;
+    }
+    private static void combination(List> res, int[] candidates, ArrayList list,
+                                    int target, int index) {
+        if (target == 0) {
+            if (!res.contains(list))
+            res.add(new ArrayList(list));
+            return;
+        }
+        if (index>=candidates.length||target < candidates[index]) {
+            return;
+        }
+            list.add(candidates[index]);
+            combination(res,candidates,list,target-candidates[index],index+1);
+            list.remove(list.size() - 1);
+            combination(res,candidates,list,target,index+1);
+    }
+}
diff --git "a/2019.01.19-leetcode40/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.19-leetcode40/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..bf61dd823
--- /dev/null
+++ "b/2019.01.19-leetcode40/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,33 @@
+```java
+   public void search(int[] candidates, int target, List box, List> res, int n, boolean flag) {
+
+        if (target==0){
+            res.add(new ArrayList(box));
+        }
+
+        if(n == candidates.length || target < candidates[n])
+            return;
+
+        if (flag&&n>0&&n> combinationSum(int[] candidates, int target) {
+        List> res = new ArrayList<>();
+        if(candidates == null || candidates.length == 0) {
+            return res;
+        }
+        Arrays.sort(candidates);
+        List box = new ArrayList<>();
+        search(candidates, target, box, res, 0, true);
+        return res;
+    }
+```
diff --git "a/2019.01.19-leetcode40/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.19-leetcode40/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..f1bc1bea9
--- /dev/null
+++ "b/2019.01.19-leetcode40/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,26 @@
+```
+class Solution {
+    public List> combinationSum2(int[] candidates, int target) {
+        List> res = new ArrayList<>();
+        Arrays.sort(candidates);
+        comb(res, new ArrayList(), candidates, target, 0);
+        return res;
+    }
+    
+    public static void comb(List> res,List com,int[] candidates,int target,int start){
+    	if(target==0){
+    		res.add(new ArrayList<>(com));
+    		return;
+    	}
+    	if(target<0)	return;
+    	
+    	for(int i=start;istart&&candidates[i]==candidates[i-1])
+    			continue;
+    		com.add(candidates[i]);
+    		comb(res, com, candidates, target-candidates[i], i+1);
+    		com.remove(com.size()-1);
+    	}
+    }
+}
+```
diff --git "a/2019.01.19-leetcode40/\347\273\204\345\220\210\346\200\273\345\222\214II" "b/2019.01.19-leetcode40/\347\273\204\345\220\210\346\200\273\345\222\214II"
new file mode 100644
index 000000000..2c0250fdb
--- /dev/null
+++ "b/2019.01.19-leetcode40/\347\273\204\345\220\210\346\200\273\345\222\214II"
@@ -0,0 +1,26 @@
+给定一个数组 candidates 和一个目标数 target ，找出 candidates 中所有可以使数字和为 target 的组合。
+
+candidates 中的每个数字在每个组合中只能使用一次。
+
+说明：
+
+所有数字（包括目标数）都是正整数。
+解集不能包含重复的组合。 
+示例 1:
+
+输入: candidates = [10,1,2,7,6,1,5], target = 8,
+所求解集为:
+[
+  [1, 7],
+  [1, 2, 5],
+  [2, 6],
+  [1, 1, 6]
+]
+示例 2:
+
+输入: candidates = [2,5,2,1,2], target = 5,
+所求解集为:
+[
+  [1,2,2],
+  [5]
+]
diff --git a/2019.01.20-leetcode216/Ostrichcrab.md b/2019.01.20-leetcode216/Ostrichcrab.md
new file mode 100644
index 000000000..53263656b
--- /dev/null
+++ b/2019.01.20-leetcode216/Ostrichcrab.md
@@ -0,0 +1,25 @@
+```
+class Solution {
+public:
+    void dfs(vector> &res, vector sol, int k, int n){
+        if(sol.size()==k&&n==0){
+            res.push_back(sol);
+            return ;
+        }
+        if(sol.size()> combinationSum3(int k, int n) {
+        vector> res;
+        vector sol;
+        dfs(res,sol,k,n);
+        return res;
+    }
+};
+```
diff --git a/2019.01.20-leetcode216/TheRocket.md b/2019.01.20-leetcode216/TheRocket.md
new file mode 100644
index 000000000..fe80e06cf
--- /dev/null
+++ b/2019.01.20-leetcode216/TheRocket.md
@@ -0,0 +1,23 @@
+```java
+class Solution {
+    public List> combinationSum3(int k, int n) {
+        List> res = new ArrayList<>();
+        dfs(k, n, 1, res, new ArrayList<>(k));
+        return res;
+    }
+
+    private void dfs(int k, int n, int s, List> res, ArrayList list) {
+        if (list.size() == k) {
+            if (n == 0) {
+                res.add(new ArrayList<>(list));
+            }
+            return;
+        }
+        for (int i = s; i <= 9; ++i) {
+            list.add(i);
+            dfs(k, n - i, i + 1, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.20-leetcode216/sourcema.md b/2019.01.20-leetcode216/sourcema.md
new file mode 100644
index 000000000..6ff7bc7c8
--- /dev/null
+++ b/2019.01.20-leetcode216/sourcema.md
@@ -0,0 +1,25 @@
+# leetcode 216
+    class Solution {
+    public List> combinationSum3(int k, int n) {
+         List> res = new ArrayList<>();
+        if (k <= 0 || n <= 0) {
+            return res;
+        }
+        find(res, new ArrayList(), k, n,1);
+        return res;
+    }
+    private static void find(List> res, ArrayList list, int k, int n,int num) {
+        if (list.size() == k && n == 0) {
+            res.add(new ArrayList(list));
+            return;
+        }
+        if (list.size() >= k) {
+            return;
+        }
+        for (int i = num; i <=9&&i<=n ; i++) {
+            list.add(i);
+            find(res,list,k,n-i,i+1);
+            list.remove(list.size() - 1);
+        }
+    }
+}
diff --git "a/2019.01.20-leetcode216/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.20-leetcode216/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..ff2923a36
--- /dev/null
+++ "b/2019.01.20-leetcode216/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,26 @@
+```java
+    public List> combinationSum3(int k, int n) {
+
+        List> res = new ArrayList<>();
+        List box = new ArrayList<>();
+        search(k,0,n,box,res);
+        return res;
+    }
+
+    public void search(int k, int lastCount, int n, List box, List> res){
+
+
+        if (k<0||n<0) return;
+
+        if (n==0&&k==0){
+            res.add(new ArrayList(box));
+        }
+
+        for (int i=lastCount+1;i<=n&&i<10;i++){
+            box.add(i);
+            search(k-1,i,n-i,box,res);
+            box.remove(box.size()-1);
+        }
+
+    }
+```
diff --git "a/2019.01.20-leetcode216/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.20-leetcode216/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..7b2cd18b5
--- /dev/null
+++ "b/2019.01.20-leetcode216/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,24 @@
+```
+class Solution {
+    public List> combinationSum3(int k, int n) {
+    	List> res = new ArrayList<>();
+    	if(k<=0||n<=0){
+    		return res;
+    	}
+        comb(res, new ArrayList(),k, 1, n);
+        return res;
+    }
+    
+     public static void comb(List> res,List com,int k,int start,int n){
+    	if(k==com.size()&&0==n){
+    		res.add(new ArrayList<>(com));
+    		return;
+    	}
+    	for(int i=start;i<=9;i++){
+    		com.add(i);
+    		comb(res, com, k,i+1,n-i);
+    		com.remove(com.size()-1);
+    	}
+    }
+}
+```
diff --git "a/2019.01.20-leetcode216/\347\273\204\345\220\210\346\200\273\345\222\214III" "b/2019.01.20-leetcode216/\347\273\204\345\220\210\346\200\273\345\222\214III"
new file mode 100644
index 000000000..91a4c55b9
--- /dev/null
+++ "b/2019.01.20-leetcode216/\347\273\204\345\220\210\346\200\273\345\222\214III"
@@ -0,0 +1,14 @@
+找出所有相加之和为 n 的 k 个数的组合。组合中只允许含有 1 - 9 的正整数，并且每种组合中不存在重复的数字。
+
+说明：
+
+所有数字都是正整数。
+解集不能包含重复的组合。 
+示例 1:
+
+输入: k = 3, n = 7
+输出: [[1,2,4]]
+示例 2:
+
+输入: k = 3, n = 9
+输出: [[1,2,6], [1,3,5], [2,3,4]]
diff --git a/2019.01.21-leetcode78/Ostrichcrab.md b/2019.01.21-leetcode78/Ostrichcrab.md
new file mode 100644
index 000000000..754be0888
--- /dev/null
+++ b/2019.01.21-leetcode78/Ostrichcrab.md
@@ -0,0 +1,34 @@
+```
+class Solution {
+public:
+    vector> subsets(vector& nums) {
+        int n = nums.size();
+        int m = 1<> res(m,vector());
+        for(int i = 0; i < n; i++)
+            for(int j =  0; j < m; j++)
+                if((j>>i)&1)
+                    res[j].push_back(nums[i]);
+        return res;
+    }
+};
+```
+```
+class Solution {
+public:
+    vector> subsets(vector& nums) {
+        int n = nums.size();
+        int m = 1<> res(m,vector());
+        // for(int i = 0; i < n; i++)
+        //     for(int j =  0; j < m; j++)
+        //         if((j>>i)&1)
+        //             res[j].push_back(nums[i]);
+        for(int i = 0; i < m; i++)
+            for(int j = 0; j < n; j++)
+                if((i>>j)&1)
+                    res[i].push_back(nums[j]);
+        return res;
+    }
+};
+```
diff --git a/2019.01.21-leetcode78/TheRocket.md b/2019.01.21-leetcode78/TheRocket.md
new file mode 100644
index 000000000..02749ee93
--- /dev/null
+++ b/2019.01.21-leetcode78/TheRocket.md
@@ -0,0 +1,18 @@
+```java
+class Solution {
+    public List> subsets(int[] nums) {
+        List> res = new ArrayList<>();
+        dfs(0, nums, res, new ArrayList<>());
+        return res;
+    }
+
+    private void dfs(int s, int[] nums, List> res, List list) {
+        res.add(new ArrayList<>(list));
+        for (int i = s; i < nums.length; ++i) {
+            list.add(nums[i]);
+            dfs(i + 1, nums, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.21-leetcode78/marguerite.md b/2019.01.21-leetcode78/marguerite.md
new file mode 100644
index 000000000..f8cd55255
--- /dev/null
+++ b/2019.01.21-leetcode78/marguerite.md
@@ -0,0 +1,19 @@
+```
+
+public class Solution {
+    public List> subsets(int[] nums) {
+        List> res = new ArrayList>();
+        res.add(new ArrayList());
+        for (int num : nums) {  // ①从数组中取出每个元素
+            int size = res.size();
+            for (int i = 0; i < size; i++) {
+                List temp = new ArrayList<>(res.get(i));  // ②逐一取出中间结果集
+                temp.add(num);  // ③将 num 放入中间结果集
+                res.add(temp);  // ④加入到结果集中
+            }
+        }
+        return res;
+    }
+
+
+```
diff --git a/2019.01.21-leetcode78/sourcema.md b/2019.01.21-leetcode78/sourcema.md
new file mode 100644
index 000000000..9391cde27
--- /dev/null
+++ b/2019.01.21-leetcode78/sourcema.md
@@ -0,0 +1,23 @@
+# leetcode 78
+    class Solution {
+    public List> subsets(int[] nums) {
+         List> res = new ArrayList<>();
+        if (nums == null || nums.length == 0) {
+            return res;
+        }
+        find(res,new ArrayList(), nums,0);
+        res.add(new ArrayList());//add empty set
+        return res;
+    }
+     private  void find(List> res, ArrayList list, int[] nums,int index) {
+        if (index >= nums.length) {
+            return;
+        }
+        for (int i = index; i < nums.length; i++) {
+            list.add(nums[i]);
+            res.add(new ArrayList(list));
+            find(res,list,nums,i+1);
+            list.remove(list.size() - 1);
+        }
+    }
+}
diff --git "a/2019.01.21-leetcode78/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.21-leetcode78/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..1113679fb
--- /dev/null
+++ "b/2019.01.21-leetcode78/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,58 @@
+```java
+    public List> subsets(int[] nums) {
+
+        List> res = new ArrayList<>();
+        if (nums==null||nums.length==0) return res;
+        List box = new ArrayList<>();
+        List allList = new ArrayList<>();
+
+        search(0,nums.length,nums,box,allList,res);
+
+        return res;
+    }
+
+    public void search(int startNum, int endNum, int[] nums, List box, List allList, List> res){
+
+        if (startNum==0) {
+            res.add(new ArrayList<>());
+            startNum++;
+        }
+        if (endNum==nums.length) {
+            for (int i : nums){
+                allList.add(i);
+            }
+            res.add(allList);
+            endNum--;
+        }
+        if (startNum==endNum){
+            digui(startNum, 0, nums, box, allList, res, true);
+            return;
+        }
+        if (startNum>endNum){
+            return;
+        }
+
+        digui(startNum, 0, nums, box, allList, res, false);
+
+        search(startNum+1,endNum-1,nums,box,allList,res);
+
+    }
+
+    public void digui(int k, int index, int[] nums, List box, List allList, List> res, boolean isEqual){
+        if (k==0) {
+            res.add(new ArrayList<>(box));
+            if (isEqual) return;
+            ArrayList tempList = new ArrayList<>(allList);
+            if(tempList.removeAll(box)) {
+                res.add(tempList);
+            }
+            return;
+        }
+
+        for (int i=index;i> subsets(int[] nums) {
+        List> res = new ArrayList<>();
+        for(int i=0;i<=nums.length;i++){
+        	comb(res, new ArrayList(), nums, 0, i);        	
+        }
+        return res;
+    }
+    
+    public void comb(List> res,List com,int[] nums,int start,int size){
+    	if(com.size()==size){
+    		res.add(new ArrayList<>(com));
+    		return;
+    	}
+    	
+    	for(int i=start;i<=nums.length-1;i++){
+    		com.add(nums[i]);
+    		comb(res, com, nums, i+1,size);
+    		com.remove(com.size()-1);
+    	}
+    }
+}
+```
diff --git a/2019.01.22-leetcode90/Ostrichcrab.md b/2019.01.22-leetcode90/Ostrichcrab.md
new file mode 100644
index 000000000..3fa83f08b
--- /dev/null
+++ b/2019.01.22-leetcode90/Ostrichcrab.md
@@ -0,0 +1,23 @@
+```
+class Solution {
+public:
+    void dfs(vector& nums, int pos, vector& path, vector>& result){
+        if(pos==nums.size()) return ;
+        for(int i = pos; i < nums.size(); i++){
+            path.push_back(nums[i]);
+            result.push_back(path);
+            dfs(nums,i+1,path,result);
+            path.pop_back();
+            while(nums[i]==nums[i+1]) i++;
+        }
+    }
+    vector> subsetsWithDup(vector& nums) {
+        vector path;
+        vector> result;
+        result.push_back(path);
+        sort(nums.begin(),nums.end());
+        dfs(nums,0,path,result);
+        return result;
+    }
+};
+```
diff --git a/2019.01.22-leetcode90/TheRocket.md b/2019.01.22-leetcode90/TheRocket.md
new file mode 100644
index 000000000..953e7f52c
--- /dev/null
+++ b/2019.01.22-leetcode90/TheRocket.md
@@ -0,0 +1,22 @@
+```java
+class Solution {
+    public List> subsetsWithDup(int[] nums) {
+        Arrays.sort(nums);
+        List> res = new ArrayList<>();
+        dfs(0, nums, res, new ArrayList<>());
+        return res;
+    }
+
+    private void dfs(int s, int[] nums, List> res, ArrayList list) {
+        res.add(new ArrayList<>(list));
+        for (int i = s; i < nums.length; ++i) {
+            if (i > s && nums[i] == nums[i - 1]) {
+                continue;
+            }
+            list.add(nums[i]);
+            dfs(i + 1, nums, res, list);
+            list.remove(list.size() - 1);
+        }
+    }
+}
+```
diff --git a/2019.01.22-leetcode90/marguerite.md b/2019.01.22-leetcode90/marguerite.md
new file mode 100644
index 000000000..320f114e0
--- /dev/null
+++ b/2019.01.22-leetcode90/marguerite.md
@@ -0,0 +1,23 @@
+```
+public class Solution {
+    public List> subsetsWithDup(int[] nums) {
+        List> result=new ArrayList<>();
+        List list=new ArrayList<>();
+        Arrays.sort(nums);
+        backtracking(result, nums, list, 0);
+        return result;
+    }
+     
+    public void backtracking(List> result,int nums[],List list,int start) {
+        result.add(new ArrayList<>(list));
+        for(int i=start;istart&&nums[i]==nums[i-1]) continue;　　　　//跳过重复的
+            list.add(nums[i]);
+            backtracking(result, nums, list, i+1);
+            list.remove(list.size()-1);
+             
+        }
+    }
+}
+
+```
diff --git "a/2019.01.22-leetcode90/\345\255\220\351\233\206II" "b/2019.01.22-leetcode90/\345\255\220\351\233\206II"
new file mode 100644
index 000000000..c9b558328
--- /dev/null
+++ "b/2019.01.22-leetcode90/\345\255\220\351\233\206II"
@@ -0,0 +1,16 @@
+给定一个可能包含重复元素的整数数组 nums，返回该数组所有可能的子集（幂集）。
+
+说明：解集不能包含重复的子集。
+
+示例:
+
+输入: [1,2,2]
+输出:
+[
+  [2],
+  [1],
+  [1,2,2],
+  [2,2],
+  [1,2],
+  []
+]
diff --git "a/2019.01.22-leetcode90/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.22-leetcode90/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..4a6af6e53
--- /dev/null
+++ "b/2019.01.22-leetcode90/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,27 @@
+```
+class Solution {
+    public List> subsetsWithDup(int[] nums) {
+        Arrays.sort(nums);
+        List> res = new ArrayList<>();
+        comb(res, new ArrayList(), nums, 0);
+        return res;  
+    }
+    
+        public void comb(List> res,List com,int[] nums,int start){
+    	if(nums.length>=com.size()){
+    		res.add(new ArrayList<>(com));
+    	}
+    	int i = start;
+    	while(i> partition(string s) {
+        vector > ret;
+        if(s.empty()) return ret;
+        
+        vector path;
+        dfs(0, s, path, ret);
+        
+        return ret;
+    }
+    
+    void dfs(int index, string& s, vector& path, vector >& ret) {
+        if(index == s.size()) {
+            ret.push_back(path);
+            return;
+        }
+        for(int i = index; i < s.size(); ++i) {
+            if(isPalindrome(s, index, i)) {
+                path.push_back(s.substr(index, i - index + 1));
+                dfs(i+1, s, path, ret);
+                path.pop_back();
+            }
+        }
+    }
+    
+    bool isPalindrome(const string& s, int start, int end) {
+        while(start <= end) {
+            if(s[start++] != s[end--])
+                return false;
+        }
+        return true;
+    }
+};
+```
diff --git a/2019.01.23-leetcode131/TheRocket.md b/2019.01.23-leetcode131/TheRocket.md
new file mode 100644
index 000000000..c8fb6ac67
--- /dev/null
+++ b/2019.01.23-leetcode131/TheRocket.md
@@ -0,0 +1,36 @@
+```java
+class Solution {
+    public List> partition(String s) {
+        List> res = new ArrayList<>();
+        List list = new ArrayList<>();
+        dfs(s, res, list);
+        return res;
+    }
+
+    private void dfs(String s, List> res, List list) {
+        if (s.length() == 0) {
+            res.add(new ArrayList<>(list));
+            return;
+        }
+        for (int i = 1; i <= s.length(); ++i) {
+            String sub = s.substring(0, i);
+            if (isPalindrome(sub)) {
+                list.add(sub);
+                dfs(s.substring(i), res, list);
+                list.remove(list.size() - 1);
+            }
+        }
+    }
+
+    private boolean isPalindrome(String s) {
+        int i = 0;
+        int j = s.length() - 1;
+        while (i < j) {
+            if (s.charAt(i++) != s.charAt(j--)) {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
diff --git a/2019.01.23-leetcode131/marguerite.md b/2019.01.23-leetcode131/marguerite.md
new file mode 100644
index 000000000..3b5bf3be9
--- /dev/null
+++ b/2019.01.23-leetcode131/marguerite.md
@@ -0,0 +1,37 @@
+```
+public class Solution {
+    List> res=new ArrayList<>();
+    public List> partition(String s) {
+        DFS(s,new ArrayList());
+        return res;
+    }
+    private void DFS(String s,List list){
+		if(s.length()<1){
+			res.add(new ArrayList<>(list));
+			return;
+		}
+		for(int i=1;i<=s.length();i++){
+			String str=s.substring(0, i);
+			if(this.isPalindrom(str)){
+				list.add(str);
+				DFS(s.substring(i),list);
+				list.remove(list.size()-1);
+			}else{
+				continue;
+			}
+		}
+	}
+	private  boolean isPalindrom(String s){
+		
+		int p1=0;
+		int p2=s.length()-1;
+		int len=(s.length()+1)/2;
+		for(int i=0;i> partition(String s) {
+        List> res = new ArrayList<>();
+        if (s == null || s.length() == 0) {
+            return res;
+        }
+        find(res, new ArrayList(), s);
+        return res;
+    }
+    private  void find(List> res, ArrayList list, String s) {
+        if (s.length() == 0) {
+            res.add(new ArrayList(list));
+            return;
+        }
+        for (int i = 1; i <=s.length() ; i++) {
+            String temp = s.substring(0, i);
+            if (IsPalindrome(temp)) {
+                list.add(temp);
+                find(res,list,s.substring(i));
+                list.remove(list.size() - 1);
+            }
+        }
+
+    }
+    private  boolean IsPalindrome(String temp) {
+        int left=0;int right=temp.length()-1;
+        while (left < right) {
+            if (temp.charAt(left) != temp.charAt(right)) {
+                return false;
+            }else{
+                left++;
+                right--;
+            }
+        }
+        return true;
+    }
+}
diff --git "a/2019.01.23-leetcode131/\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262" "b/2019.01.23-leetcode131/\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262"
new file mode 100644
index 000000000..942590ce1
--- /dev/null
+++ "b/2019.01.23-leetcode131/\345\210\206\345\211\262\345\233\236\346\226\207\344\270\262"
@@ -0,0 +1,12 @@
+给定一个字符串 s，将 s 分割成一些子串，使每个子串都是回文串。
+
+返回 s 所有可能的分割方案。
+
+示例:
+
+输入: "aab"
+输出:
+[
+  ["aa","b"],
+  ["a","a","b"]
+]
diff --git a/2019.01.24-leetcode37/Ostrichcrab.md b/2019.01.24-leetcode37/Ostrichcrab.md
new file mode 100644
index 000000000..e141b76c2
--- /dev/null
+++ b/2019.01.24-leetcode37/Ostrichcrab.md
@@ -0,0 +1,87 @@
+```
+class Solution {
+public:
+    void solveSudoku(vector > &board) {
+        solve(board, 0);
+    }
+    bool solve(vector > &board, int position)
+    {
+        if(position == 81)
+            return true;
+
+        int row = position / 9;
+        int col = position % 9;
+        if(board[row][col] == '.')
+        {
+            for(int i = 1; i <= 9; i ++)
+            {//try each digit
+                board[row][col] = i + '0';
+                if(check(board, position))
+                    if(solve(board, position + 1))
+                    //only return valid filling
+                        return true;
+                board[row][col] = '.';
+            }
+        }
+        else
+        {
+            if(solve(board, position + 1))
+            //only return valid filling
+                return true;
+        }
+        return false;
+    }
+    bool check(vector > &board, int position)
+    {
+        int row = position / 9;
+        int col = position % 9;
+        int gid;
+        if(row >= 0 && row <= 2)
+        {
+            if(col >= 0 && col <= 2)
+                gid = 0;
+            else if(col >= 3 && col <= 5)
+                gid = 1;
+            else
+                gid = 2;
+        }
+        else if(row >= 3 && row <= 5)
+        {
+            if(col >= 0 && col <= 2)
+                gid = 3;
+            else if(col >= 3 && col <= 5)
+                gid = 4;
+            else
+                gid = 5;
+        }
+        else
+        {
+            if(col >= 0 && col <= 2)
+                gid = 6;
+            else if(col >= 3 && col <= 5)
+                gid = 7;
+            else
+                gid = 8;
+        }
+
+        //check row, col, subgrid
+        for(int i = 0; i < 9; i ++)
+        {
+            //check row
+            if(i != col && board[row][i] == board[row][col])
+                return false;
+            
+            //check col
+            if(i != row && board[i][col] == board[row][col])
+                return false;
+            
+            //check subgrid
+            int r = gid/3*3+i/3;
+            int c = gid%3*3+i%3;
+            if((r != row || c != col) && board[r][c] == board[row][col])
+                return false;
+        }
+        return true;
+    }
+};
+```
diff --git a/2019.01.24-leetcode37/TheRocket.md b/2019.01.24-leetcode37/TheRocket.md
new file mode 100644
index 000000000..498154275
--- /dev/null
+++ b/2019.01.24-leetcode37/TheRocket.md
@@ -0,0 +1,59 @@
+```java
+class Solution {
+    public void solveSudoku(char[][] board) {
+        // 记录某行的某位数字是否已经被摆放
+        boolean[][] row = new boolean[9][9];
+        // 记录某列的某位数字是否已经被摆放
+        boolean[][] col = new boolean[9][9];
+        // 记录 3x3 宫格内的某位数字是否已经被摆放
+        boolean[][] block = new boolean[9][9];
+        for (int i = 0; i < 9; ++i) {
+            for (int j = 0; j < 9; ++j) {
+                if (board[i][j] != '.') {
+                    int num = board[i][j] - '1';
+                    row[i][num] = true;
+                    col[j][num] = true;
+                    // 化二维的 3x3 为一维的 0~8
+                    block[i / 3 * 3 + j / 3][num] = true;
+                }
+            }
+        }
+        dfs(board, 0, 0, row, col, block);
+    }
+
+    private boolean dfs(char[][] board, int i, int j, boolean[][] row, boolean[][] col, boolean[][] block) {
+        while (board[i][j] != '.') {
+            if (++j == 9) {
+                ++i;
+                j = 0;
+            }
+            if (i == 9) {
+                return true;
+            }
+
+        }
+        // 化二维的 3x3 为一维的 0~8
+        int blockIndex = i / 3 * 3 + j / 3;
+        for (int k = 0; k < 9; ++k) {
+            if (!row[i][k] && !col[j][k] && !block[blockIndex][k]) {
+                // 设置访问标志
+                row[i][k] = true;
+                col[j][k] = true;
+                block[blockIndex][k] = true;
+                // 改变当前值
+                board[i][j] = (char) ('1' + k);
+                // 进入下一层，成功则直接返回
+                if (dfs(board, i, j, row, col, block)) {
+                    return true;
+                }
+                // 恢复
+                row[i][k] = false;
+                col[j][k] = false;
+                block[blockIndex][k] = false;
+                board[i][j] = '.';
+            }
+        }
+        return false;
+    }
+}
+```
diff --git "a/2019.01.24-leetcode37/\345\210\230\346\266\246\346\263\275(capture).md" "b/2019.01.24-leetcode37/\345\210\230\346\266\246\346\263\275(capture).md"
new file mode 100644
index 000000000..6a439f5c8
--- /dev/null
+++ "b/2019.01.24-leetcode37/\345\210\230\346\266\246\346\263\275(capture).md"
@@ -0,0 +1,87 @@
+```java
+    public void solveSudoku(char[][] board) {
+
+        int[] next = findNext(0, 0, board);
+        huisu(next[0],next[1],board);
+
+    }
+
+    public boolean huisu(int i, int j, char[][] board){
+
+        System.out.println(i+" "+j);
+
+        int[] other = findOther(i, j, board);
+
+        for (int m=1;m> solveNQueens(int n) {
+        vector> res;
+        vector nQueens(n,string(n,'.'));
+        solveNQueens(res,nQueens,0,n);
+        return res;
+    }
+    void solveNQueens(vector>&res,vector& nQueens, int row, int &n){
+        if(row==n){
+            res.push_back(nQueens);
+            return ;
+        }
+        for(int col = 0; col != n; col++)
+            if(isValid(nQueens, row, col, n)){
+                nQueens[row][col]='Q';
+                solveNQueens(res,nQueens,row+1,n);
+                nQueens[row][col]='.';
+            }
+    }
+    bool isValid(vector& nQueens, int row, int col, int &n){
+    for(int i = 0; i != row; i++)
+        if(nQueens[i][col]=='Q') return false;
+        for(int i = row -1,j=col-1; i>=0&&j>=0; i--,j--)
+            if(nQueens[i][j]=='Q') return false;
+        for(int i = row-1,j=col+1;i>=0&&j> solveNQueens(int n) {
+        List> res = new ArrayList<>();
+        char[][] cs = new char[n][n];
+        for (int i = 0; i < cs.length; ++i) {
+            Arrays.fill(cs[i], '.');
+        }
+        dfs(cs, 0, res);
+        return res;
+    }
+
+    private void dfs(char[][] cs, int r, List> res) {
+        int n = cs.length;
+        if (r == n) {
+            List list = new ArrayList<>(n);
+            for (int i = 0; i < n; ++i) {
+                list.add(new String(cs[i]));
+            }
+            res.add(list);
+            return;
+        }
+        for (int i = 0; i < n; ++i) {
+            if (isValid(cs, r, i)) {
+                cs[r][i] = 'Q';
+                dfs(cs, r + 1, res);
+                cs[r][i] = '.';
+            }
+        }
+    }
+
+    private boolean isValid(char[][] cs, int r, int c) {
+        int j = c;
+        for (int i = r - 1; i >= 0; --i) {
+            if (cs[i][j] == 'Q') {
+                return false;
+            }
+        }
+        j = c - 1;
+        for (int i = r - 1; i >= 0 && j >= 0; --i) {
+            if (cs[i][j--] == 'Q') {
+                return false;
+            }
+        }
+        j = c + 1;
+        for (int i = r - 1; i >= 0 && j < cs.length; --i) {
+            if (cs[i][j++] == 'Q') {
+                return false;
+            }
+        }
+        return true;
+    }
+}
+```
diff --git a/2019.01.25-leetcode51/sourcema.md b/2019.01.25-leetcode51/sourcema.md
new file mode 100644
index 000000000..b9c23c97b
--- /dev/null
+++ b/2019.01.25-leetcode51/sourcema.md
@@ -0,0 +1,41 @@
+# LeetCode 51
+    class Solution {
+    List> result = new ArrayList<>();
+    StringBuilder point = new StringBuilder();
+    HashSet col = new HashSet<>();
+    HashSet pie = new HashSet<>();
+    HashSet na = new HashSet<>();
+
+    public List> solveNQueens(int n) {
+        for (int i = 0; i < n; i++) point.append('.');
+        dfs(n, new ArrayList());
+        return result;
+    }
+
+     void dfs(int n, List list) {
+        if (list.size() == n) {
+            List line = new ArrayList<>();
+            for (int i = 0; i < n; i++) {
+                point.replace(list.get(i), list.get(i) + 1, "Q");
+                line.add(point.toString());
+                point.replace(list.get(i), list.get(i) + 1, ".");
+            }
+            result.add(line);
+            return;
+        }
+        for (int i = 0; i < n; i++) {
+            if (col.contains(i)|| pie.contains(list.size()-i) || na.contains(list.size()+i)) {
+                continue;
+            }
+            col.add(i);
+            pie.add(list.size() - i);
+            na.add(list.size() + i);
+            list.add(i);
+            dfs(n, list);
+            list.remove(list.size()-1);
+            col.remove(i);
+            pie.remove(list.size() - i);
+            na.remove(list.size() + i);
+        }
+     }
+}
diff --git "a/2019.01.25-leetcode51/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.25-leetcode51/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..d50d2aa5f
--- /dev/null
+++ "b/2019.01.25-leetcode51/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,51 @@
+```
+class Solution {
+    public List> solveNQueens(int n) {
+        List> res = new ArrayList<>();
+        char[][] board = new char[n][n];
+        for(int i=0;i> res){
+    	if(colIndex==board.length){
+    		res.add(construct(board));
+    		return;
+    	}
+    	
+    	for(int i=0;i construct(char[][] board){
+    	List res = new LinkedList<>();
+    	for(int i=0;i dp(n+3);
+        dp[0]=0;
+        dp[1]=1;
+        dp[2]=2;
+        for(int i = 3; i <= n; i++)
+        {
+            dp[i]=dp[i-1]+dp[i-2];
+        }
+        return dp[n];
+    }
+};
+```
diff --git a/2019.01.26-leetcode70/TheRocket.md b/2019.01.26-leetcode70/TheRocket.md
new file mode 100644
index 000000000..3b0e5e6a4
--- /dev/null
+++ b/2019.01.26-leetcode70/TheRocket.md
@@ -0,0 +1,17 @@
+```java
+class Solution {
+    public int climbStairs(int n) {
+        if (n <= 2) {
+            return n;
+        }
+        int a = 1, b = 2;
+        int res = 0;
+        for (int i = 3; i <= n; ++i) {
+            res = a + b;
+            a = b;
+            b = res;
+        }
+        return res;
+    }
+}
+```
diff --git a/2019.01.26-leetcode70/sourcema.md b/2019.01.26-leetcode70/sourcema.md
new file mode 100644
index 000000000..32fa77388
--- /dev/null
+++ b/2019.01.26-leetcode70/sourcema.md
@@ -0,0 +1,20 @@
+# LeetCode 70
+    class Solution {
+    public int climbStairs(int n) {
+         if (n == 1) {
+            return 1;
+        }
+        if (n == 2) {
+            return 2;
+        }
+        int one=1;
+        int two=2;
+        int res=0;
+        for (int i = 3; i <=n ; i++) {
+            res=one+two;
+            one=two;
+            two=res;
+        }
+        return res;
+    }
+}
diff --git "a/2019.01.26-leetcode70/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.26-leetcode70/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..307465304
--- /dev/null
+++ "b/2019.01.26-leetcode70/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,19 @@
+```
+class Solution {
+    
+    Map dp = new HashMap<>();
+    
+    public int climbStairs(int n) {
+       if(n<0)
+			return 0;
+		if(n==0)
+			return 1;
+		if(dp.containsKey(n))
+			return dp.get(n);
+		int steps = climbStairs(n-1)+climbStairs(n-2);
+		dp.put(n, steps);
+		return steps;
+    }
+    
+}
+```
diff --git "a/2019.01.26-leetcode70/\347\210\254\346\245\274\346\242\257" "b/2019.01.26-leetcode70/\347\210\254\346\245\274\346\242\257"
new file mode 100644
index 000000000..e0ec4ddbe
--- /dev/null
+++ "b/2019.01.26-leetcode70/\347\210\254\346\245\274\346\242\257"
@@ -0,0 +1,21 @@
+假设你正在爬楼梯。需要 n 阶你才能到达楼顶。
+
+每次你可以爬 1 或 2 个台阶。你有多少种不同的方法可以爬到楼顶呢？
+
+注意：给定 n 是一个正整数。
+
+示例 1：
+
+输入： 2
+输出： 2
+解释： 有两种方法可以爬到楼顶。
+1.  1 阶 + 1 阶
+2.  2 阶
+示例 2：
+
+输入： 3
+输出： 3
+解释： 有三种方法可以爬到楼顶。
+1.  1 阶 + 1 阶 + 1 阶
+2.  1 阶 + 2 阶
+3.  2 阶 + 1 阶
diff --git a/2019.01.27-leetcode198/Ostrichcrab.md b/2019.01.27-leetcode198/Ostrichcrab.md
new file mode 100644
index 000000000..cbd8f80a0
--- /dev/null
+++ b/2019.01.27-leetcode198/Ostrichcrab.md
@@ -0,0 +1,19 @@
+```
+//dp[i]:=走到第i家，获得的最大收入
+class Solution {
+public:
+    int rob(vector& a) {
+        int n = a.size();
+        if(n==0) return 0;
+        int dp[n+2];
+        dp[0]=a[0];
+        if(n==1) return a[0];
+        dp[1]=max(a[0],a[1]);
+        for(int i = 2; i < n; i++)
+        {
+            dp[i]=max(dp[i-2]+a[i],dp[i-1]);
+        }
+        return dp[n-1];
+    }
+};
+```
diff --git a/2019.01.27-leetcode198/TheRocket.md b/2019.01.27-leetcode198/TheRocket.md
new file mode 100644
index 000000000..9afde4fb2
--- /dev/null
+++ b/2019.01.27-leetcode198/TheRocket.md
@@ -0,0 +1,15 @@
+```java
+class Solution {
+    public int rob(int[] nums) {
+        int pre2 = 0;
+        int pre1 = 0;
+        int cur = 0;
+        for (int num : nums) {
+            cur = Math.max(pre2 + num, pre1);
+            pre2 = pre1;
+            pre1 = cur;
+        }
+        return cur;
+    }
+}
+```
diff --git a/2019.01.27-leetcode198/sourcema.md b/2019.01.27-leetcode198/sourcema.md
new file mode 100644
index 000000000..af86b82d1
--- /dev/null
+++ b/2019.01.27-leetcode198/sourcema.md
@@ -0,0 +1,18 @@
+# leetcode 198
+    class Solution {
+    public int rob(int[] nums) {
+        if(nums==null||nums.length==0){
+            return 0;
+        }
+        if(nums.length==1){
+            return nums[0];
+        }
+        int[] dp=new int[nums.length];
+        dp[0]=nums[0];
+        dp[1]=Math.max(dp[0],nums[1]);
+        for(int i=2;inums[1]?nums[0]:nums[1];
+    	}
+    	int[] dp = new int[nums.length];
+    	dp[0] = nums[0];
+    	dp[1] = nums[0]>nums[1]?nums[0]:nums[1];
+    	for(int i=2;i& nums) {
+        int ans = -1;
+        vector a;
+        if(nums.size()==0) return 0;
+        if(nums.size()==1) return nums[0];
+        for(int i = 1; i < nums.size(); i++)
+        {
+            a.push_back(nums[i]);
+        }
+        nums.pop_back();
+        ans = robber(a)>robber(nums)?robber(a):robber(nums);
+        return ans;
+    }
+    int robber(vector& a) {
+        int n = a.size();
+        if(n==0) return 0;
+        int dp[n+2];
+        dp[0]=a[0];
+        if(n==1) return a[0];
+        dp[1]=max(a[0],a[1]);
+        for(int i = 2; i < n; i++)
+        {
+            dp[i]=max(dp[i-2]+a[i],dp[i-1]);
+        }
+        return dp[n-1];
+    }
+};
+```
diff --git a/2019.01.28-leetcode213/TheRocket.md b/2019.01.28-leetcode213/TheRocket.md
new file mode 100644
index 000000000..1420896b5
--- /dev/null
+++ b/2019.01.28-leetcode213/TheRocket.md
@@ -0,0 +1,25 @@
+```java
+class Solution {
+    public int rob(int[] nums) {
+        if (nums == null || nums.length == 0) {
+            return 0;
+        }
+        if (nums.length == 1) {
+            return nums[0];
+        }
+        return Math.max(rob(nums, 0, nums.length - 2), rob(nums, 1, nums.length - 1));
+    }
+
+    public int rob(int[] nums, int begin, int end) {
+        int pre2 = 0;
+        int pre1 = 0;
+        int cur = 0;
+        for (int i = begin; i <= end; ++i) {
+            cur = Math.max(pre2 + nums[i], pre1);
+            pre2 = pre1;
+            pre1 = cur;
+        }
+        return cur;
+    }
+}
+```
diff --git a/2019.01.28-leetcode213/sourcema.md b/2019.01.28-leetcode213/sourcema.md
new file mode 100644
index 000000000..0a53fdf8e
--- /dev/null
+++ b/2019.01.28-leetcode213/sourcema.md
@@ -0,0 +1,25 @@
+# leetcode 213
+    class Solution {
+    public int rob(int[] nums) {
+         if(nums==null||nums.length==0){
+            return 0;
+        }
+        if(nums.length==1){
+            return nums[0];
+        }
+        if(nums.length==2){
+            return Math.max(nums[0],nums[1]);
+        }
+        int[] dp1=new int[nums.length];
+        int[] dp2=new int[nums.length-1];
+        dp1[1]=nums[1];
+        dp2[0]=nums[0];dp2[1]=Math.max(dp2[0],nums[1]);
+        for(int i=2;i>& grid) {
+        int n = grid.size();
+        int m = grid[0].size();
+        int dp[n+1][m+1];
+        dp[0][0]=grid[0][0];
+        for(int i = 1; i < n; i++) dp[i][0]=grid[i][0]+dp[i-1][0];
+        for(int i = 1; i < m; i++) dp[0][i]=grid[0][i]+dp[0][i-1];
+        for(int i = 1; i < n; i++){
+            for(int j = 1; j < m; j++){
+                dp[i][j] = min(dp[i-1][j]+grid[i][j],dp[i][j-1]+grid[i][j]);
+            }
+        }
+        return dp[n-1][m-1];
+    }
+};
+```
diff --git a/2019.01.29-leetcode64/TheRocket.md b/2019.01.29-leetcode64/TheRocket.md
new file mode 100644
index 000000000..fd315da7b
--- /dev/null
+++ b/2019.01.29-leetcode64/TheRocket.md
@@ -0,0 +1,22 @@
+```java
+class Solution {
+    public int minPathSum(int[][] grid) {
+        int m = grid.length;
+        int n = grid[0].length;
+        int[][] dp = new int[m][n];
+        dp[0][0] = grid[0][0];
+        for (int i = 1; i < m; ++i) {
+            dp[i][0] = dp[i - 1][0] + grid[i][0];
+        }
+        for (int i = 1; i < n; ++i) {
+            dp[0][i] = dp[0][i - 1] + grid[0][i];
+        }
+        for (int i = 1; i < m; ++i) {
+            for (int j = 1; j < n; ++j) {
+                dp[i][j] = Math.min(dp[i - 1][j], dp[i][j - 1]) + grid[i][j];
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}
+```
diff --git a/2019.01.29-leetcode64/sourcema.md b/2019.01.29-leetcode64/sourcema.md
new file mode 100644
index 000000000..7be7fe039
--- /dev/null
+++ b/2019.01.29-leetcode64/sourcema.md
@@ -0,0 +1,22 @@
+# leetcode 64
+    class Solution {
+    public int minPathSum(int[][] grid) {//动态规划模板题，直接手撸
+        if(grid==null||grid.length==0||grid[0].length==0){
+            return 0;
+        }
+        int[][] dp=new int[grid.length][grid[0].length];
+        dp[0][0]=grid[0][0];
+        for(int i=1;i 向右 -> 向下
+2. 向右 -> 向下 -> 向右
+3. 向下 -> 向右 -> 向右
+示例 2:
+
+输入: m = 7, n = 3
+输出: 28
diff --git "a/2019.01.30-leetcode62/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.30-leetcode62/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..634d2c420
--- /dev/null
+++ "b/2019.01.30-leetcode62/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,23 @@
+```
+class Solution {
+    public int uniquePaths(int m, int n) {
+        int[][] map = new int[m][n];
+        for(int i=0;i sum;
+    NumArray(vector nums) {
+        sum.push_back(0);
+        for(int i = 0; i < nums.size(); i++)
+            sum.push_back(nums[i]+sum.back());
+    }
+    
+    int sumRange(int i, int j) {
+        return sum[j+1]-sum[i];
+    }
+};
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
+ ```
diff --git a/2019.01.31-leetcode303/TheRocket.md b/2019.01.31-leetcode303/TheRocket.md
new file mode 100644
index 000000000..684bc79f4
--- /dev/null
+++ b/2019.01.31-leetcode303/TheRocket.md
@@ -0,0 +1,22 @@
+```java
+class NumArray {
+    private int[] sums;
+
+    public NumArray(int[] nums) {
+        sums = new int[nums.length + 1];
+        for (int i = 0; i < nums.length; ++i) {
+            sums[i + 1] = sums[i] + nums[i];
+        }
+    }
+
+    public int sumRange(int i, int j) {
+        return sums[j + 1] - sums[i];
+    }
+}
+
+/**
+ * Your NumArray object will be instantiated and called as such:
+ * NumArray obj = new NumArray(nums);
+ * int param_1 = obj.sumRange(i,j);
+ */
+ ```
diff --git a/2019.01.31-leetcode303/sourcema.md b/2019.01.31-leetcode303/sourcema.md
new file mode 100644
index 000000000..85b17ca22
--- /dev/null
+++ b/2019.01.31-leetcode303/sourcema.md
@@ -0,0 +1,28 @@
+# leetcode 303
+    class NumArray {
+    int[] dp;
+    public NumArray(int[] nums) {
+        if(nums==null||nums.length==0){//test
+            return;
+        }
+        dp=new int[nums.length];
+        dp[0]=nums[0];
+        for(int i=1;i 1
+sumRange(2, 5) -> -1
+sumRange(0, 5) -> -3
+说明:
+
+你可以假设数组不可变。
+会多次调用 sumRange 方法。
diff --git "a/2019.01.31-leetcode303/\346\243\225\346\246\210\346\240\221.md" "b/2019.01.31-leetcode303/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..2ef03d955
--- /dev/null
+++ "b/2019.01.31-leetcode303/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,33 @@
+```
+package day;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class NumArray {
+	int[] nums;
+	
+    public NumArray(int[] nums) {
+    	for(int i=1;i& A) {
+        if(A.size()<3) return 0;
+        int now = 0;
+        int ans = 0;
+        for(int i = 2; i < A.size(); i++){
+            if(A[i]-A[i-1] == A[i-1]-A[i-2]) now++;
+            else now = 0;
+            ans+=now;
+        }
+        
+       return ans; 
+    }
+};
+```
diff --git a/2019.02.01-leetcode413/TheRocket.md b/2019.02.01-leetcode413/TheRocket.md
new file mode 100644
index 000000000..240627a95
--- /dev/null
+++ b/2019.02.01-leetcode413/TheRocket.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int numberOfArithmeticSlices(int[] A) {
+        if (A == null || A.length < 3) {
+            return 0;
+        }
+        int res = 0;
+        int cur = 0;
+        for (int i = 2; i < A.length; ++i) {
+            if (A[i] - A[i - 1] == A[i - 1] - A[i - 2]) {
+                res += ++cur;
+            } else {
+                cur = 0;
+            }
+        }
+        return res;
+    }
+}
+```
diff --git a/2019.02.01-leetcode413/sourcema.md b/2019.02.01-leetcode413/sourcema.md
new file mode 100644
index 000000000..df0c2f983
--- /dev/null
+++ b/2019.02.01-leetcode413/sourcema.md
@@ -0,0 +1,26 @@
+# leetcode 413
+    class Solution {
+    public int numberOfArithmeticSlices(int[] A) {
+        if(A==null||A.length==0){
+            return 0;
+        }
+        int res=0;
+        for(int i=0;i=2&&isArithmetic(A,i,j)){
+                    res+=1;
+                }
+            }
+        }
+        return res;
+    }
+    public boolean isArithmetic(int[] arr,int i,int j){
+        int d=arr[i+1]-arr[i];
+        for(int k=i+1;k> 1;
+        for (int i = 1; i <= half; ++i) {
+            for (int j = i; i + j <= n; ++j) {
+                dp[i + j] = Math.max(dp[i + j], Math.max(i, dp[i]) * Math.max(j, dp[j]));
+            }
+        }
+        return dp[n];
+    }
+}
+```
diff --git "a/2019.02.02-leetcode343/\346\225\264\346\225\260\346\213\206\345\210\206" "b/2019.02.02-leetcode343/\346\225\264\346\225\260\346\213\206\345\210\206"
new file mode 100644
index 000000000..00f187992
--- /dev/null
+++ "b/2019.02.02-leetcode343/\346\225\264\346\225\260\346\213\206\345\210\206"
@@ -0,0 +1,13 @@
+给定一个正整数 n，将其拆分为至少两个正整数的和，并使这些整数的乘积最大化。 返回你可以获得的最大乘积。
+
+示例 1:
+
+输入: 2
+输出: 1
+解释: 2 = 1 + 1, 1 × 1 = 1。
+示例 2:
+
+输入: 10
+输出: 36
+解释: 10 = 3 + 3 + 4, 3 × 3 × 4 = 36。
+说明: 你可以假设 n 不小于 2 且不大于 58。
diff --git "a/2019.02.02-leetcode343/\346\243\225\346\246\210\346\240\221.md" "b/2019.02.02-leetcode343/\346\243\225\346\246\210\346\240\221.md"
new file mode 100644
index 000000000..6be93f1ff
--- /dev/null
+++ "b/2019.02.02-leetcode343/\346\243\225\346\246\210\346\240\221.md"
@@ -0,0 +1,32 @@
+```
+public class Integer_Break {
+	/*
+    public static int integerBreak(int n) {
+        if(n==2)	return 1;
+        if(n==3)	return 2;
+        int product = 1;
+        while(n>4){
+        	System.out.println(product);
+        	product *=3;
+        	n -= 3;
+        }
+        product *= n;
+    	return product;
+    }
+    */
+	
+	public static int integerBreak(int n){
+		int[] dp = new int[n+1];
+		dp[1] = 1;
+		for(int i=2;i<=n;i++){
+			for(int j=1;j<=i/2;j++){
+				dp[i] = Math.max(dp[i], (Math.max(j, dp[j])*(Math.max(i-j, dp[i-j]))));
+			}
+		}
+		return dp[n];
+	}
+    public static void main(String[] args) {
+		System.out.println(integerBreak(10));
+	}
+}
+```
diff --git a/2019.02.03-leetocde279/Ostrichcrab.md b/2019.02.03-leetocde279/Ostrichcrab.md
new file mode 100644
index 000000000..16563e006
--- /dev/null
+++ b/2019.02.03-leetocde279/Ostrichcrab.md
@@ -0,0 +1,17 @@
+```
+class Solution {
+public:
+    int numSquares(int n) {
+        vector dp;
+        dp.push_back(0);
+        for(int i = 1; i <= n; i++) dp.push_back(i);
+        // for(int i = 0; i <= n; i++) cout<=0){
+    			min = Math.min(min, dp[i-j*j]+1);
+    			++j;
+    		}
+    		dp[i] = min;
+    	}
+    	return dp[n];
+    }
+}
+```
diff --git a/2019.02.09-leetcode91/TheRocket.md b/2019.02.09-leetcode91/TheRocket.md
new file mode 100644
index 000000000..c66979187
--- /dev/null
+++ b/2019.02.09-leetcode91/TheRocket.md
@@ -0,0 +1,32 @@
+```java
+class Solution {
+    public int numDecodings(String s) {
+        if (s == null || s.length() == 0 || s.charAt(0) == '0') {
+            return 0;
+        }
+        int pre2 = 1;
+        int pre1 = 1;
+        int res = 1;
+        char prec = s.charAt(0);
+        for (int i = 1; i < s.length(); ++i) {
+            char c = s.charAt(i);
+            if (c == '0') {
+                if ((prec == '1' || prec == '2')) {
+                    res = pre2;
+                } else {
+                    return 0;
+                }
+            } else {
+                res = pre1;
+                if (prec == '1' || (prec == '2' && c <= '6')) {
+                    res += pre2;
+                }
+            }
+            pre2 = pre1;
+            pre1 = res;
+            prec = c;
+        }
+        return res;
+    }
+}
+```
diff --git "a/2019.02.09-leetcode91/\350\247\243\347\240\201\346\226\271\346\263\225" "b/2019.02.09-leetcode91/\350\247\243\347\240\201\346\226\271\346\263\225"
new file mode 100644
index 000000000..c7a285987
--- /dev/null
+++ "b/2019.02.09-leetcode91/\350\247\243\347\240\201\346\226\271\346\263\225"
@@ -0,0 +1,18 @@
+一条包含字母 A-Z 的消息通过以下方式进行了编码：
+
+'A' -> 1
+'B' -> 2
+...
+'Z' -> 26
+给定一个只包含数字的非空字符串，请计算解码方法的总数。
+
+示例 1:
+
+输入: "12"
+输出: 2
+解释: 它可以解码为 "AB"（1 2）或者 "L"（12）。
+示例 2:
+
+输入: "226"
+输出: 3
+解释: 它可以解码为 "BZ" (2 26), "VF" (22 6), 或者 "BBF" (2 2 6) 。
diff --git a/2019.02.10-leetcode300/TheRocket.md b/2019.02.10-leetcode300/TheRocket.md
new file mode 100644
index 000000000..5c98e2871
--- /dev/null
+++ b/2019.02.10-leetcode300/TheRocket.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int lengthOfLIS(int[] nums) {
+        int[] dp = new int[nums.length];
+        int len = 0;
+        for (int num : nums) {
+            int i = Arrays.binarySearch(dp, 0, len, num);
+            if (i < 0) {
+                i = -(i + 1);
+            }
+            dp[i] = num;
+            if (i == len) {
+                ++len;
+            }
+        }
+        return len;
+    }
+}
+```
diff --git "a/2019.02.10-leetcode300/\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227" "b/2019.02.10-leetcode300/\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227"
new file mode 100644
index 000000000..c258ed444
--- /dev/null
+++ "b/2019.02.10-leetcode300/\346\234\200\351\225\277\344\270\212\345\215\207\345\255\220\345\272\217\345\210\227"
@@ -0,0 +1,12 @@
+给定一个无序的整数数组，找到其中最长上升子序列的长度。
+
+示例:
+
+输入: [10,9,2,5,3,7,101,18]
+输出: 4 
+解释: 最长的上升子序列是 [2,3,7,101]，它的长度是 4。
+说明:
+
+可能会有多种最长上升子序列的组合，你只需要输出对应的长度即可。
+你算法的时间复杂度应该为 O(n2) 。
+进阶: 你能将算法的时间复杂度降低到 O(n log n) 吗?
diff --git a/2019.02.11-leetcode646/TheRocket.md b/2019.02.11-leetcode646/TheRocket.md
new file mode 100644
index 000000000..03e81c239
--- /dev/null
+++ b/2019.02.11-leetcode646/TheRocket.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int findLongestChain(int[][] pairs) {
+        if (pairs == null || pairs.length == 0) {
+            return 0;
+        }
+        Arrays.sort(pairs, Comparator.comparingInt(o -> o[1]));
+        int res = 1;
+        int pre = pairs[0][1];
+        for (int[] pair : pairs) {
+            if (pair[0] > pre) {
+                ++res;
+                pre = pair[1];
+            }
+        }
+        return res;
+    }
+}
+```
diff --git a/2019.02.11-leetcode646/jackykun2012.md b/2019.02.11-leetcode646/jackykun2012.md
new file mode 100644
index 000000000..03e81c239
--- /dev/null
+++ b/2019.02.11-leetcode646/jackykun2012.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int findLongestChain(int[][] pairs) {
+        if (pairs == null || pairs.length == 0) {
+            return 0;
+        }
+        Arrays.sort(pairs, Comparator.comparingInt(o -> o[1]));
+        int res = 1;
+        int pre = pairs[0][1];
+        for (int[] pair : pairs) {
+            if (pair[0] > pre) {
+                ++res;
+                pre = pair[1];
+            }
+        }
+        return res;
+    }
+}
+```
diff --git "a/2019.02.11-leetcode646/\346\234\200\351\225\277\346\225\260\345\257\271\351\223\276" "b/2019.02.11-leetcode646/\346\234\200\351\225\277\346\225\260\345\257\271\351\223\276"
new file mode 100644
index 000000000..9e894d454
--- /dev/null
+++ "b/2019.02.11-leetcode646/\346\234\200\351\225\277\346\225\260\345\257\271\351\223\276"
@@ -0,0 +1,14 @@
+给出 n 个数对。 在每一个数对中，第一个数字总是比第二个数字小。
+
+现在，我们定义一种跟随关系，当且仅当 b < c 时，数对(c, d) 才可以跟在 (a, b) 后面。我们用这种形式来构造一个数对链。
+
+给定一个对数集合，找出能够形成的最长数对链的长度。你不需要用到所有的数对，你可以以任何顺序选择其中的一些数对来构造。
+
+示例 :
+
+输入: [[1,2], [2,3], [3,4]]
+输出: 2
+解释: 最长的数对链是 [1,2] -> [3,4]
+注意：
+
+给出数对的个数在 [1, 1000] 范围内。
diff --git a/2019.02.12-leetcode376/TheRocket.md b/2019.02.12-leetcode376/TheRocket.md
new file mode 100644
index 000000000..d4e4b3186
--- /dev/null
+++ b/2019.02.12-leetcode376/TheRocket.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int wiggleMaxLength(int[] nums) {
+        if (nums.length < 2) {
+            return nums.length;
+        }
+        int up = 1;
+        int down = 1;
+        for (int i = 1; i < nums.length; ++i) {
+            if (nums[i] > nums[i - 1]) {
+                up = down + 1;
+            } else if (nums[i] < nums[i - 1]) {
+                down = up + 1;
+            }
+        }
+        return Math.max(up, down);
+    }
+}
+```
diff --git "a/2019.02.12-leetcode376/\346\221\206\345\212\250\345\272\217\345\210\227" "b/2019.02.12-leetcode376/\346\221\206\345\212\250\345\272\217\345\210\227"
new file mode 100644
index 000000000..ad916a81f
--- /dev/null
+++ "b/2019.02.12-leetcode376/\346\221\206\345\212\250\345\272\217\345\210\227"
@@ -0,0 +1,22 @@
+如果连续数字之间的差严格地在正数和负数之间交替，则数字序列称为摆动序列。第一个差（如果存在的话）可能是正数或负数。少于两个元素的序列也是摆动序列。
+
+例如， [1,7,4,9,2,5] 是一个摆动序列，因为差值 (6,-3,5,-7,3) 是正负交替出现的。相反, [1,4,7,2,5] 和 [1,7,4,5,5] 不是摆动序列，第一个序列是因为它的前两个差值都是正数，第二个序列是因为它的最后一个差值为零。
+
+给定一个整数序列，返回作为摆动序列的最长子序列的长度。 通过从原始序列中删除一些（也可以不删除）元素来获得子序列，剩下的元素保持其原始顺序。
+
+示例 1:
+
+输入: [1,7,4,9,2,5]
+输出: 6 
+解释: 整个序列均为摆动序列。
+示例 2:
+
+输入: [1,17,5,10,13,15,10,5,16,8]
+输出: 7
+解释: 这个序列包含几个长度为 7 摆动序列，其中一个可为[1,17,10,13,10,16,8]。
+示例 3:
+
+输入: [1,2,3,4,5,6,7,8,9]
+输出: 2
+进阶:
+你能否用 O(n) 时间复杂度完成此题?
diff --git a/2019.02.13-leetcode416/TheRocket.md b/2019.02.13-leetcode416/TheRocket.md
new file mode 100644
index 000000000..1b84d5128
--- /dev/null
+++ b/2019.02.13-leetcode416/TheRocket.md
@@ -0,0 +1,23 @@
+```java
+public boolean canPartition(int[] nums) {
+    int sum = 0;
+    for (int num : nums) {
+        sum += num;
+    }
+    if ((sum & 1) == 1) {
+        return false;
+    }
+    sum /= 2;
+    boolean[] dp = new boolean[sum + 1];
+    dp[0] = true;
+    for (int num : nums) {
+        for (int i = sum; i >= num; --i) {
+            dp[i] = dp[i] || dp[i - num];
+            if (dp[sum]) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+```
diff --git "a/2019.02.13-leetcode416/\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206" "b/2019.02.13-leetcode416/\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206"
new file mode 100644
index 000000000..bc8af3ce0
--- /dev/null
+++ "b/2019.02.13-leetcode416/\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206"
@@ -0,0 +1,22 @@
+给定一个只包含正整数的非空数组。是否可以将这个数组分割成两个子集，使得两个子集的元素和相等。
+
+注意:
+
+每个数组中的元素不会超过 100
+数组的大小不会超过 200
+示例 1:
+
+输入: [1, 5, 11, 5]
+
+输出: true
+
+解释: 数组可以分割成 [1, 5, 5] 和 [11].
+ 
+
+示例 2:
+
+输入: [1, 2, 3, 5]
+
+输出: false
+
+解释: 数组不能分割成两个元素和相等的子集.
diff --git a/2019.02.14-leetcode494/TheRocket.md b/2019.02.14-leetcode494/TheRocket.md
new file mode 100644
index 000000000..518289c25
--- /dev/null
+++ b/2019.02.14-leetcode494/TheRocket.md
@@ -0,0 +1,25 @@
+```java
+class Solution {
+    public int findTargetSumWays(int[] nums, int S) {
+        int sum = 0;
+        for (int num : nums) {
+            sum += num;
+        }
+        if (sum < S || ((S + sum) & 1) == 1) {
+            return 0;
+        }
+        return subsetSum(nums, (S + sum) >> 1);
+    }
+
+    private int subsetSum(int[] nums, int sum) {
+        int[] dp = new int[sum + 1];
+        dp[0] = 1;
+        for (int num : nums) {
+            for (int i = sum; i >= num; --i) {
+                dp[i] += dp[i - num];
+            }
+        }
+        return dp[sum];
+    }
+}
+```
diff --git "a/2019.02.14-leetcode494/\347\233\256\346\240\207\345\222\214" "b/2019.02.14-leetcode494/\347\233\256\346\240\207\345\222\214"
new file mode 100644
index 000000000..595a4d1ce
--- /dev/null
+++ "b/2019.02.14-leetcode494/\347\233\256\346\240\207\345\222\214"
@@ -0,0 +1,22 @@
+给定一个非负整数数组，a1, a2, ..., an, 和一个目标数，S。现在你有两个符号 + 和 -。对于数组中的任意一个整数，你都可以从 + 或 -中选择一个符号添加在前面。
+
+返回可以使最终数组和为目标数 S 的所有添加符号的方法数。
+
+示例 1:
+
+输入: nums: [1, 1, 1, 1, 1], S: 3
+输出: 5
+解释: 
+
+-1+1+1+1+1 = 3
++1-1+1+1+1 = 3
++1+1-1+1+1 = 3
++1+1+1-1+1 = 3
++1+1+1+1-1 = 3
+
+一共有5种方法让最终目标和为3。
+注意:
+
+数组的长度不会超过20，并且数组中的值全为正数。
+初始的数组的和不会超过1000。
+保证返回的最终结果为32位整数。
diff --git a/2019.02.15-leetcode139/TheRocket.md b/2019.02.15-leetcode139/TheRocket.md
new file mode 100644
index 000000000..488c9ebf0
--- /dev/null
+++ b/2019.02.15-leetcode139/TheRocket.md
@@ -0,0 +1,18 @@
+```java
+class Solution {
+    public boolean wordBreak(String s, List wordDict) {
+        Set set = new HashSet<>(wordDict);
+        int n = s.length();
+        boolean[] dp = new boolean[n + 1];
+        dp[0] = true;
+        for (int i = 1; i <= n; ++i) {
+            for (int j = i; j >= 0; --j) {
+                if (dp[j] && set.contains(s.substring(j, i))) {
+                    dp[i] = true;
+                }
+            }
+        }
+        return dp[n];
+    }
+}
+```
diff --git "a/2019.02.15-leetcode139/\345\215\225\350\257\215\346\213\206\345\210\206" "b/2019.02.15-leetcode139/\345\215\225\350\257\215\346\213\206\345\210\206"
new file mode 100644
index 000000000..56946710c
--- /dev/null
+++ "b/2019.02.15-leetcode139/\345\215\225\350\257\215\346\213\206\345\210\206"
@@ -0,0 +1,21 @@
+给定一个非空字符串 s 和一个包含非空单词列表的字典 wordDict，判定 s 是否可以被空格拆分为一个或多个在字典中出现的单词。
+
+说明：
+
+拆分时可以重复使用字典中的单词。
+你可以假设字典中没有重复的单词。
+示例 1：
+
+输入: s = "leetcode", wordDict = ["leet", "code"]
+输出: true
+解释: 返回 true 因为 "leetcode" 可以被拆分成 "leet code"。
+示例 2：
+
+输入: s = "applepenapple", wordDict = ["apple", "pen"]
+输出: true
+解释: 返回 true 因为 "applepenapple" 可以被拆分成 "apple pen apple"。
+     注意你可以重复使用字典中的单词。
+示例 3：
+
+输入: s = "catsandog", wordDict = ["cats", "dog", "sand", "and", "cat"]
+输出: false
diff --git a/2019.02.16-leetcode474/TheRocket.md b/2019.02.16-leetcode474/TheRocket.md
new file mode 100644
index 000000000..dd05be56b
--- /dev/null
+++ b/2019.02.16-leetcode474/TheRocket.md
@@ -0,0 +1,31 @@
+```java
+class Solution {
+    public int findMaxForm(String[] strs, int m, int n) {
+        if (strs == null || strs.length == 0) {
+            return 0;
+        }
+        int[][] dp = new int[m + 1][n + 1];
+        for (String str : strs) {
+            int[] nums = count(str);
+            for (int i = m; i >= nums[0]; --i) {
+                for (int j = n; j >= nums[1]; --j) {
+                    dp[i][j] = Math.max(dp[i][j], dp[i - nums[0]][j - nums[1]] + 1);
+                }
+            }
+        }
+        return dp[m][n];
+    }
+
+    private int[] count(String str) {
+        int[] nums = new int[2];
+        for (char c : str.toCharArray()) {
+            if (c == '0') {
+                ++nums[0];
+            } else {
+                ++nums[1];
+            }
+        }
+        return nums;
+    }
+}
+```
diff --git "a/2019.02.16-leetcode474/\344\270\200\345\222\214\351\233\266" "b/2019.02.16-leetcode474/\344\270\200\345\222\214\351\233\266"
new file mode 100644
index 000000000..d96b5a85e
--- /dev/null
+++ "b/2019.02.16-leetcode474/\344\270\200\345\222\214\351\233\266"
@@ -0,0 +1,22 @@
+在计算机界中，我们总是追求用有限的资源获取最大的收益。
+
+现在，假设你分别支配着 m 个 0 和 n 个 1。另外，还有一个仅包含 0 和 1 字符串的数组。
+
+你的任务是使用给定的 m 个 0 和 n 个 1 ，找到能拼出存在于数组中的字符串的最大数量。每个 0 和 1 至多被使用一次。
+
+注意:
+
+给定 0 和 1 的数量都不会超过 100。
+给定字符串数组的长度不会超过 600。
+示例 1:
+
+输入: Array = {"10", "0001", "111001", "1", "0"}, m = 5, n = 3
+输出: 4
+
+解释: 总共 4 个字符串可以通过 5 个 0 和 3 个 1 拼出，即 "10","0001","1","0" 。
+示例 2:
+
+输入: Array = {"10", "0", "1"}, m = 1, n = 1
+输出: 2
+
+解释: 你可以拼出 "10"，但之后就没有剩余数字了。更好的选择是拼出 "0" 和 "1" 。
diff --git a/2019.02.17-leetcode322/Sagittarius.md b/2019.02.17-leetcode322/Sagittarius.md
new file mode 100644
index 000000000..33357b4c6
--- /dev/null
+++ b/2019.02.17-leetcode322/Sagittarius.md
@@ -0,0 +1,25 @@
+```
+class Solution {
+    public int coinChange(int[] coins, int amount) {
+        if(amount <= 0)
+            return 0;
+        
+        int[] minNum = new int[amount+1];
+        
+        for(int i=1;i<=amount;i++){
+            minNum[i]=Integer.MAX_VALUE;
+            
+            for(int j=0;j= coin) {
+                    dp[i] = Math.min(dp[i], dp[i - coin] + 1);
+                }
+            }
+        }
+        return dp[amount] != amount + 1 ? dp[amount] : -1;
+    }
+}
+```
diff --git "a/2019.02.17-leetcode322/\351\233\266\351\222\261\345\205\221\346\215\242" "b/2019.02.17-leetcode322/\351\233\266\351\222\261\345\205\221\346\215\242"
new file mode 100644
index 000000000..2af6c2ea2
--- /dev/null
+++ "b/2019.02.17-leetcode322/\351\233\266\351\222\261\345\205\221\346\215\242"
@@ -0,0 +1,13 @@
+给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。
+
+示例 1:
+
+输入: coins = [1, 2, 5], amount = 11
+输出: 3 
+解释: 11 = 5 + 5 + 1
+示例 2:
+
+输入: coins = [2], amount = 3
+输出: -1
+说明:
+你可以认为每种硬币的数量是无限的。
diff --git a/2019.02.18-leetcode377/TheRocket.md b/2019.02.18-leetcode377/TheRocket.md
new file mode 100644
index 000000000..578c3c364
--- /dev/null
+++ b/2019.02.18-leetcode377/TheRocket.md
@@ -0,0 +1,16 @@
+```java
+class Solution {
+    public int combinationSum4(int[] nums, int target) {
+        int[] dp = new int[target + 1];
+        dp[0] = 1;
+        for (int i = 1; i <= target; ++i) {
+            for (int num : nums) {
+                if (i >= num) {
+                    dp[i] += dp[i - num];
+                }
+            }
+        }
+        return dp[target];
+    }
+}
+```
diff --git "a/2019.02.18-leetcode377/\347\273\204\345\220\210\346\200\273\345\222\214IV" "b/2019.02.18-leetcode377/\347\273\204\345\220\210\346\200\273\345\222\214IV"
new file mode 100644
index 000000000..f8d5caba2
--- /dev/null
+++ "b/2019.02.18-leetcode377/\347\273\204\345\220\210\346\200\273\345\222\214IV"
@@ -0,0 +1,23 @@
+给定一个由正整数组成且不存在重复数字的数组，找出和为给定目标正整数的组合的个数。
+
+示例:
+
+nums = [1, 2, 3]
+target = 4
+
+所有可能的组合为：
+(1, 1, 1, 1)
+(1, 1, 2)
+(1, 2, 1)
+(1, 3)
+(2, 1, 1)
+(2, 2)
+(3, 1)
+
+请注意，顺序不同的序列被视作不同的组合。
+
+因此输出为 7。
+进阶：
+如果给定的数组中含有负数会怎么样？
+问题会产生什么变化？
+我们需要在题目中添加什么限制来允许负数的出现？
diff --git a/2019.02.19-leetcode309/TheRocket.md b/2019.02.19-leetcode309/TheRocket.md
new file mode 100644
index 000000000..ef3db5f26
--- /dev/null
+++ b/2019.02.19-leetcode309/TheRocket.md
@@ -0,0 +1,19 @@
+```java
+class Solution {
+    public int maxProfit(int[] prices) {
+        if (prices == null || prices.length <= 1) {
+            return 0;
+        }
+        int curSell = 0;
+        int preSell = 0;
+        int buy = -prices[0];
+        for (int i = 1; i < prices.length; ++i) {
+            int tmp = curSell;
+            curSell = Math.max(curSell, buy + prices[i]);
+            buy = Math.max(buy, preSell - prices[i]);
+            preSell = tmp;
+        }
+        return curSell;
+    }
+}
+```
diff --git "a/2019.02.19-leetcode309/\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" "b/2019.02.19-leetcode309/\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"
new file mode 100644
index 000000000..975221373
--- /dev/null
+++ "b/2019.02.19-leetcode309/\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"
@@ -0,0 +1,11 @@
+给定一个整数数组，其中第 i 个元素代表了第 i 天的股票价格 。​
+
+设计一个算法计算出最大利润。在满足以下约束条件下，你可以尽可能地完成更多的交易（多次买卖一支股票）:
+
+你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+卖出股票后，你无法在第二天买入股票 (即冷冻期为 1 天)。
+示例:
+
+输入: [1,2,3,0,2]
+输出: 3 
+解释: 对应的交易状态为: [买入, 卖出, 冷冻期, 买入, 卖出]
diff --git a/2019.02.20-leetcode714/TheRocket.md b/2019.02.20-leetcode714/TheRocket.md
new file mode 100644
index 000000000..39553ad58
--- /dev/null
+++ b/2019.02.20-leetcode714/TheRocket.md
@@ -0,0 +1,16 @@
+```java
+class Solution {
+    public int maxProfit(int[] prices, int fee) {
+        if (prices == null || prices.length <= 1) {
+            return 0;
+        }
+        int sell = 0;
+        int buy = -prices[0];
+        for (int i = 1; i < prices.length; ++i) {
+            sell = Math.max(sell, buy + prices[i] - fee);
+            buy = Math.max(buy, sell - prices[i]);
+        }
+        return sell;
+    }
+}
+```
diff --git "a/2019.02.20-leetcode714/\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" "b/2019.02.20-leetcode714/\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"
new file mode 100644
index 000000000..310c59cc6
--- /dev/null
+++ "b/2019.02.20-leetcode714/\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"
@@ -0,0 +1,21 @@
+给定一个整数数组 prices，其中第 i 个元素代表了第 i 天的股票价格 ；非负整数 fee 代表了交易股票的手续费用。
+
+你可以无限次地完成交易，但是你每次交易都需要付手续费。如果你已经购买了一个股票，在卖出它之前你就不能再继续购买股票了。
+
+返回获得利润的最大值。
+
+示例 1:
+
+输入: prices = [1, 3, 2, 8, 4, 9], fee = 2
+输出: 8
+解释: 能够达到的最大利润:  
+在此处买入 prices[0] = 1
+在此处卖出 prices[3] = 8
+在此处买入 prices[4] = 4
+在此处卖出 prices[5] = 9
+总利润: ((8 - 1) - 2) + ((9 - 4) - 2) = 8.
+注意:
+
+0 < prices.length <= 50000.
+0 < prices[i] < 50000.
+0 <= fee < 50000.
diff --git "a/2019.02.21-leetcode123/\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" "b/2019.02.21-leetcode123/\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"
new file mode 100644
index 000000000..95cc9d0ad
--- /dev/null
+++ "b/2019.02.21-leetcode123/\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"
@@ -0,0 +1,24 @@
+给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你最多可以完成 两笔 交易。
+
+注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+示例 1:
+
+输入: [3,3,5,0,0,3,1,4]
+输出: 6
+解释: 在第 4 天（股票价格 = 0）的时候买入，在第 6 天（股票价格 = 3）的时候卖出，这笔交易所能获得利润 = 3-0 = 3 。
+     随后，在第 7 天（股票价格 = 1）的时候买入，在第 8 天 （股票价格 = 4）的时候卖出，这笔交易所能获得利润 = 4-1 = 3 。
+示例 2:
+
+输入: [1,2,3,4,5]
+输出: 4
+解释: 在第 1 天（股票价格 = 1）的时候买入，在第 5 天 （股票价格 = 5）的时候卖出, 这笔交易所能获得利润 = 5-1 = 4 。   
+     注意你不能在第 1 天和第 2 天接连购买股票，之后再将它们卖出。   
+     因为这样属于同时参与了多笔交易，你必须在再次购买前出售掉之前的股票。
+示例 3:
+
+输入: [7,6,4,3,1] 
+输出: 0 
+解释: 在这个情况下, 没有交易完成, 所以最大利润为 0。
diff --git "a/2019.02.22-leetcode188/\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" "b/2019.02.22-leetcode188/\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"
new file mode 100644
index 000000000..b0f7d85bb
--- /dev/null
+++ "b/2019.02.22-leetcode188/\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"
@@ -0,0 +1,17 @@
+给定一个数组，它的第 i 个元素是一支给定的股票在第 i 天的价格。
+
+设计一个算法来计算你所能获取的最大利润。你最多可以完成 k 笔交易。
+
+注意: 你不能同时参与多笔交易（你必须在再次购买前出售掉之前的股票）。
+
+示例 1:
+
+输入: [2,4,1], k = 2
+输出: 2
+解释: 在第 1 天 (股票价格 = 2) 的时候买入，在第 2 天 (股票价格 = 4) 的时候卖出，这笔交易所能获得利润 = 4-2 = 2 。
+示例 2:
+
+输入: [3,2,6,5,0,3], k = 2
+输出: 7
+解释: 在第 2 天 (股票价格 = 2) 的时候买入，在第 3 天 (股票价格 = 6) 的时候卖出, 这笔交易所能获得利润 = 6-2 = 4 。
+     随后，在第 5 天 (股票价格 = 0) 的时候买入，在第 6 天 (股票价格 = 3) 的时候卖出, 这笔交易所能获得利润 = 3-0 = 3 。
diff --git "a/2019.02.23-leetcode583/\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234" "b/2019.02.23-leetcode583/\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234"
new file mode 100644
index 000000000..2d95ce635
--- /dev/null
+++ "b/2019.02.23-leetcode583/\344\270\244\344\270\252\345\255\227\347\254\246\344\270\262\347\232\204\345\210\240\351\231\244\346\223\215\344\275\234"
@@ -0,0 +1,11 @@
+给定两个单词 word1 和 word2，找到使得 word1 和 word2 相同所需的最小步数，每步可以删除任意一个字符串中的一个字符。
+
+示例 1:
+
+输入: "sea", "eat"
+输出: 2
+解释: 第一步将"sea"变为"ea"，第二步将"eat"变为"ea"
+说明:
+
+给定单词的长度不超过500。
+给定单词中的字符只含有小写字母。
diff --git "a/2019.02.24-leetcode72/\347\274\226\350\276\221\350\267\235\347\246\273" "b/2019.02.24-leetcode72/\347\274\226\350\276\221\350\267\235\347\246\273"
new file mode 100644
index 000000000..d64cde7ef
--- /dev/null
+++ "b/2019.02.24-leetcode72/\347\274\226\350\276\221\350\267\235\347\246\273"
@@ -0,0 +1,25 @@
+给定两个单词 word1 和 word2，计算出将 word1 转换成 word2 所使用的最少操作数 。
+
+你可以对一个单词进行如下三种操作：
+
+插入一个字符
+删除一个字符
+替换一个字符
+示例 1:
+
+输入: word1 = "horse", word2 = "ros"
+输出: 3
+解释: 
+horse -> rorse (将 'h' 替换为 'r')
+rorse -> rose (删除 'r')
+rose -> ros (删除 'e')
+示例 2:
+
+输入: word1 = "intention", word2 = "execution"
+输出: 5
+解释: 
+intention -> inention (删除 't')
+inention -> enention (将 'i' 替换为 'e')
+enention -> exention (将 'n' 替换为 'x')
+exention -> exection (将 'n' 替换为 'c')
+exection -> execution (插入 'u')
diff --git a/leetcode203/Ostrichcrab.md b/leetcode203/Ostrichcrab.md
new file mode 100644
index 000000000..5c4c593a0
--- /dev/null
+++ b/leetcode203/Ostrichcrab.md
@@ -0,0 +1,28 @@
+```
+/**
+ * Definition for singly-linked list.
+ * struct ListNode {
+ *     int val;
+ *     ListNode *next;
+ *     ListNode(int x) : val(x), next(NULL) {}
+ * };
+ */
+class Solution {
+public:
+    ListNode* removeElements(ListNode* head, int val) {
+        if(head==NULL) return NULL;
+        while(head != NULL && head->val == val){
+            head = head->next;
+        }
+        if(head==NULL) return NULL;
+        ListNode* node = head;
+        while(node->next != NULL){
+            if(node->next->val==val)
+                node->next = node->next->next;
+            else
+                node = node->next;
+        }
+        return head;
+    }
+};
+```