note

Author: guangxush

guangxu/202103/20210301.md

@@ -1,11 +1,81 @@
 ## Algorithm
 
+[119. Pascal's Triangle II](https://leetcode.com/problems/pascals-triangle-ii/)
+
 ### Description
 
-### Solution
+Given an integer rowIndex, return the rowIndexth (0-indexed) row of the Pascal's triangle.
+
+In Pascal's triangle, each number is the sum of the two numbers directly above it as shown:
+
+![](assets/20210301-937f15cd.png)
+
+Example 1:
+
+```
+Input: rowIndex = 3
+Output: [1,3,3,1]
+```
+
+
+Example 2:
+
+```
+Input: rowIndex = 0
+Output: [1]
+```
+
 
-```java 
+Example 3:
+
+```
+Input: rowIndex = 1
+Output: [1,1]
+```
+
+Constraints:
+
+- 0 <= rowIndex <= 33
+
+- Follow up: Could you optimize your algorithm to use only O(rowIndex) extra space?
+
+### Solution
 
+```java
+class Solution {
+    public List<Integer> getRow(int rowIndex) {
+        rowIndex++;
+        List<List<Integer>> lists =  new ArrayList<>();
+        if(rowIndex==0){
+            List<Integer> list = new ArrayList<>();
+            return list;
+        }
+        if(rowIndex>=1){
+            List<Integer> list = new ArrayList<>();
+            list.add(1);
+            lists.add(list);
+        }
+        if(rowIndex>=2){
+            List<Integer> list = new ArrayList<>();
+            list.add(1);
+            list.add(1);
+            lists.add(list);
+        }
+        if(rowIndex>=3){
+            for(int i=3;i<=rowIndex;i++){
+                List<Integer> list = new ArrayList<>();
+                List<Integer> pre = lists.get(i-1-1);
+                list.add(1);
+                for(int j=1;j<i-1;j++){
+                    list.add(pre.get(j-1)+pre.get(j));
+                }
+                list.add(1);
+                lists.add(list);
+            }
+        }
+        return lists.get(rowIndex-1);
+    }
+}
 ```
 
 ### Discuss

guangxu/202103/20210302.md

@@ -1,11 +1,63 @@
 ## Algorithm
 
+[1. Two Sum](https://leetcode.com/problems/two-sum/)
+
 ### Description
 
-### Solution
+Given an array of integers nums and an integer target, return indices of the two numbers such that they add up to target.
+
+You may assume that each input would have exactly one solution, and you may not use the same element twice.
+
+You can return the answer in any order.
+
+
+Example 1:
+
+```
+Input: nums = [2,7,11,15], target = 9
+Output: [0,1]
+Output: Because nums[0] + nums[1] == 9, we return [0, 1].
+```
+
+
+Example 2:
 
-```java 
+```
+Input: nums = [3,2,4], target = 6
+Output: [1,2]
+```
+
+
+Example 3:
+
+```
+Input: nums = [3,3], target = 6
+Output: [0,1]
+```
+
+Constraints:
+
+- 2 <= nums.length <= 103
+- -109 <= nums[i] <= 109
+- -109 <= target <= 109
+- Only one valid answer exists.
+
+### Solution
 
+```java
+class Solution {
+    public int[] twoSum(int[] nums, int target) {
+        Map<Integer, Integer> map = new HashMap<>();
+        for(int i=0;i<nums.length;i++){
+            int num = target - nums[i];
+            if(map.containsKey(num)&&map.get(num)!=i){
+                return new int[]{map.get(num),i};
+            }
+            map.put(nums[i], i);
+        }
+        throw new IllegalArgumentException("no solution!");
+    }
+}
 ```
 
 ### Discuss

guangxu/202103/assets/20210301-937f15cd.png

@@ -1,5 +1,7 @@
 | 标题 | Algorithm | Review | Tip | Share|
 | :-----| :---- | :---- |  :---- |  :---- |
+| [20210302](./202103/20210302.md) |[1. Two Sum(两数之和)](https://leetcode.com/problems/two-sum/)||||
+| [20210301](./202103/20210301.md) |[119. Pascal's Triangle II(杨辉三角2)](https://leetcode.com/problems/pascals-triangle-ii/)||||
 | [20210228](./202102/20210228.md) |[118. Pascal's Triangle(杨辉三角)](https://leetcode.com/problems/pascals-triangle/)||||
 | [20210227](./202102/20210227.md) |[300. Longest Increasing Subsequence(最长递增序列)](https://leetcode.com/problems/longest-increasing-subsequence/)||||
 | [20210226](./202102/20210226.md) |[103. Binary Tree Zigzag Level Order Traversal(之字形打印二叉树)](https://leetcode.com/problems/binary-tree-zigzag-level-order-traversal/)||||