[Function add]: 1. Add leetcode solutions with tag amazon.

Botao Xiao · Botao Xiao · commit 6c9c78596c39 · 2019-04-17T00:06:52.000-04:00
diff --git a/leetcode/387. First Unique Character in a String.md b/leetcode/387. First Unique Character in a String.md
@@ -0,0 +1,34 @@
+## 387. First Unique Character in a String
+
+### Question
+Given a string, find the first non-repeating character in it and return it's index. If it doesn't exist, return -1.
+
+```
+Examples:
+
+s = "leetcode"
+return 0.
+
+s = "loveleetcode",
+return 2.
+```
+
+Note: You may assume the string contain only lowercase letters.
+
+### Solution
+* Method 1: array(or hashMap)
+  ```Java
+  class Solution {
+      public int firstUniqChar(String s) {
+          int[] dic = new int[26];
+          char[] arr = s.toCharArray();
+          for(char c : arr){
+              dic[c - 'a']++;
+          }
+          for(int i = 0; i < arr.length; i++){
+              if(dic[arr[i] - 'a'] == 1) return i;
+          }
+          return -1;
+      }
+  }
+  ```
diff --git a/leetcode/973. K Closest Points to Origin.md b/leetcode/973. K Closest Points to Origin.md
@@ -0,0 +1,52 @@
+## 973. K Closest Points to Origin
+
+### Question
+We have a list of points on the plane.  Find the K closest points to the origin (0, 0).
+
+(Here, the distance between two points on a plane is the Euclidean distance.)
+
+You may return the answer in any order.  The answer is guaranteed to be unique (except for the order that it is in.)
+
+```
+Example 1:
+
+Input: points = [[1,3],[-2,2]], K = 1
+Output: [[-2,2]]
+Explanation:
+The distance between (1, 3) and the origin is sqrt(10).
+The distance between (-2, 2) and the origin is sqrt(8).
+Since sqrt(8) < sqrt(10), (-2, 2) is closer to the origin.
+We only want the closest K = 1 points from the origin, so the answer is just [[-2,2]].
+Example 2:
+
+Input: points = [[3,3],[5,-1],[-2,4]], K = 2
+Output: [[3,3],[-2,4]]
+(The answer [[-2,4],[3,3]] would also be accepted.)
+```
+
+Note:
+1. 1 <= K <= points.length <= 10000
+2. -10000 < points[i][0] < 10000
+3. -10000 < points[i][1] < 10000
+
+### Solutions:
+* Method 1: PriorityQueue
+  ```Java
+  class Solution {
+      public int[][] kClosest(int[][] points, int K) {
+          PriorityQueue<int[]> pq = new PriorityQueue<>(new Comparator<int[]>(){
+              @Override
+              public int compare(int[] a, int[] b){
+                  return a[0] * a[0] + a[1] * a[1] - b[0] * b[0] - b[1] * b[1];
+              }
+          });
+          for(int[] point : points)   pq.offer(point);
+          int[][] res = new int[K][2];
+          int count = 0;
+          for(int i = 0; i < K; i++){
+              res[i] = pq.poll();
+          }
+          return res;
+      }
+  }
+  ```
