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<List<Integer>> combinationSum2(int[] candidates, int target) {
+         List<List<Integer>> res = new ArrayList<>();
+        if (candidates == null || candidates.length == 0 || target <= 0) {
+            return res;
+        }
+        Arrays.sort(candidates);//
+        combination(res,candidates,new ArrayList<Integer>(),target,0);
+        return res;
+    }
+    private static void combination(List<List<Integer>> res, int[] candidates, ArrayList<Integer> list,
+                                    int target, int index) {
+        if (target == 0) {
+            if (!res.contains(list))
+            res.add(new ArrayList<Integer>(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.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<List<Integer>> combinationSum3(int k, int n) {
+         List<List<Integer>> res = new ArrayList<>();
+        if (k <= 0 || n <= 0) {
+            return res;
+        }
+        find(res, new ArrayList<Integer>(), k, n,1);
+        return res;
+    }
+    private static void find(List<List<Integer>> res, ArrayList<Integer> list, int k, int n,int num) {
+        if (list.size() == k && n == 0) {
+            res.add(new ArrayList<Integer>(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.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<List<Integer>> subsets(int[] nums) {
+         List<List<Integer>> res = new ArrayList<>();
+        if (nums == null || nums.length == 0) {
+            return res;
+        }
+        find(res,new ArrayList<Integer>(), nums,0);
+        res.add(new ArrayList<Integer>());//add empty set
+        return res;
+    }
+     private  void find(List<List<Integer>> res, ArrayList<Integer> 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<Integer>(list));
+            find(res,list,nums,i+1);
+            list.remove(list.size() - 1);
+        }
+    }
+}
diff --git a/2019.01.23-leetcode131/sourcema.md b/2019.01.23-leetcode131/sourcema.md
new file mode 100644
index 000000000..4585b210a
--- /dev/null
+++ b/2019.01.23-leetcode131/sourcema.md
@@ -0,0 +1,38 @@
+# LeetCode 131
+    class Solution {
+    public List<List<String>> partition(String s) {
+        List<List<String>> res = new ArrayList<>();
+        if (s == null || s.length() == 0) {
+            return res;
+        }
+        find(res, new ArrayList<String>(), s);
+        return res;
+    }
+    private  void find(List<List<String>> res, ArrayList<String> list, String s) {
+        if (s.length() == 0) {
+            res.add(new ArrayList<String>(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.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<List<String>> result = new ArrayList<>();
+    StringBuilder point = new StringBuilder();
+    HashSet<Integer> col = new HashSet<>();
+    HashSet<Integer> pie = new HashSet<>();
+    HashSet<Integer> na = new HashSet<>();
+
+    public List<List<String>> solveNQueens(int n) {
+        for (int i = 0; i < n; i++) point.append('.');
+        dfs(n, new ArrayList<Integer>());
+        return result;
+    }
+
+     void dfs(int n, List<Integer> list) {
+        if (list.size() == n) {
+            List<String> 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.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.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;i<nums.length;i++){
+            dp[i]=Math.max(dp[i-1],dp[i-2]+nums[i]);
+        }
+        return dp[nums.length-1];
+    }
+}
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<nums.length;i++){//不包含第一个
+           dp1[i]=Math.max(dp1[i-1],dp1[i-2]+nums[i]); 
+        }
+        for(int i=2;i<nums.length-1;i++){
+            dp2[i]=Math.max(dp2[i-1],dp2[i-2]+nums[i]);
+        }
+        return Math.max(dp1[dp1.length-1],dp2[dp2.length-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<grid[0].length;i++){
+            dp[0][i]=dp[0][i-1]+grid[0][i];
+        }
+        for(int i=1;i<grid.length;i++){
+            dp[i][0]=dp[i-1][0]+grid[i][0];
+        }
+        for(int i=1;i<grid.length;i++){
+            for(int j=1;j<grid[0].length;j++){
+                dp[i][j]=Math.min(dp[i][j-1],dp[i-1][j])+grid[i][j];
+            }
+        }
+        return dp[grid.length-1][grid[0].length-1];
+    }
+}
diff --git a/2019.01.30-leetcode62/sourcema.md b/2019.01.30-leetcode62/sourcema.md
new file mode 100644
index 000000000..79d3e668d
--- /dev/null
+++ b/2019.01.30-leetcode62/sourcema.md
@@ -0,0 +1,21 @@
+# LeetCode 62
+    class Solution {
+    public int uniquePaths(int m, int n) {
+        if (m == 1 || n == 1) {
+            return 1;
+        }
+        int[][] dp = new int[m][n];
+        for (int i = 1; i < n; i++) {
+            dp[0][i]=1;
+        }
+        for (int i = 1; i < m; i++) {
+            dp[i][0]=1;
+        }
+        for (int i = 1; i < m; i++) {
+            for (int j = 1; j < n; j++) {
+                dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+            }
+        }
+        return dp[m - 1][n - 1];
+    }
+}
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<nums.length;i++){
+            dp[i]=dp[i-1]+nums[i];
+        }
+    }
+    
+    public int sumRange(int i, int j) {
+        if(i==0){
+            return dp[j];
+        }else{
+            return dp[j]-dp[i-1];
+        }
+    }
+}
+
+/**
+ * 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.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<A.length;i++){
+            for(int j=i+1;j<A.length;j++){
+                if(j-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<j;k++){
+            if(arr[k+1]-arr[k]!=d){
+                return false;
+            }
+        }
+        return true;
+    }
+}