change js to md

Author: BaffinLee

001-100/61. Rotate List.md

@@ -0,0 +1,87 @@
+# 61. Rotate List
+
+- Difficulty: Medium.
+- Related Topics: Linked List, Two Pointers.
+- Similar Questions: Rotate Array, Split Linked List in Parts.
+
+## Problem
+
+Given a linked list, rotate the list to the right by **k** places, where **k** is non-negative.
+
+**Example 1:**
+
+```
+Input: 1->2->3->4->5->NULL, k = 2
+Output: 4->5->1->2->3->NULL
+Explanation:
+rotate 1 steps to the right: 5->1->2->3->4->NULL
+rotate 2 steps to the right: 4->5->1->2->3->NULL
+```
+
+**Example 2:**
+
+```
+Input: 0->1->2->NULL, k = 4
+Output: 2->0->1->NULL
+Explanation:
+rotate 1 steps to the right: 2->0->1->NULL
+rotate 2 steps to the right: 1->2->0->NULL
+rotate 3 steps to the right: 0->1->2->NULL
+rotate 4 steps to the right: 2->0->1->NULL
+```
+
+## Solution
+
+```javascript
+/**
+ * Definition for singly-linked list.
+ * function ListNode(val) {
+ *     this.val = val;
+ *     this.next = null;
+ * }
+ */
+/**
+ * @param {ListNode} head
+ * @param {number} k
+ * @return {ListNode}
+ */
+var rotateRight = function(head, k) {
+	var count = 1;
+	var last = head;
+	var now = head;
+	
+	if (!head || !head.next) return head;
+
+	while (last.next) {
+		last = last.next;
+		count++;
+	}
+
+	k %= count;
+	
+	if (k === 0) return head;
+
+	while (k < count - 1) {
+		now = now.next;
+		k++;
+	}
+
+	last.next = head;
+	head = now.next;
+	now.next = null;
+
+	return head;
+};
+```
+
+**Explain:**
+
+1. 拿到长度 count 和最后一个 last
+2. k %= count
+3. 找到新的最后一个 newLast，last.next = head，head = newLast.next，newLast.next = null
+4. return head
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).

001-100/62. Unique Paths.md

@@ -0,0 +1,72 @@
+# 62. Unique Paths
+
+- Difficulty: Medium.
+- Related Topics: Array, Dynamic Programming.
+- Similar Questions: Unique Paths II, Minimum Path Sum, Dungeon Game.
+
+## Problem
+
+A robot is located at the top-left corner of a **m** x **n** grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+How many possible unique paths are there?
+
+![](https://leetcode.com/static/images/problemset/robot_maze.png)
+
+Above is a 7 x 3 grid. How many possible unique paths are there?
+
+**Note:** **m** and **n** will be at most 100.
+
+**Example 1:**
+
+```
+Input: m = 3, n = 2
+Output: 3
+Explanation:
+From the top-left corner, there are a total of 3 ways to reach the bottom-right corner:
+1. Right -> Right -> Down
+2. Right -> Down -> Right
+3. Down -> Right -> Right
+```
+
+**Example 2:**
+
+```
+Input: m = 7, n = 3
+Output: 28
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number} m
+ * @param {number} n
+ * @return {number}
+ */
+var uniquePaths = function(m, n) {
+  var dp = Array(m);
+  if (!m || !n) return 0;
+  for (var i = 0; i < m; i++) {
+    dp[i] = Array(n);
+    for (var j = 0; j < n; j++) {
+      if (j > 0 && i > 0) dp[i][j] = dp[i - 1][j] + dp[i][j - 1];
+      else if (j > 0 && i === 0) dp[i][j] = dp[i][j - 1];
+      else if (j === 0 && i > 0) dp[i][j] = dp[i - 1][j];
+      else dp[i][j] = 1;
+    }
+  }
+  return dp[m - 1][n - 1];
+};
+```
+
+**Explain:**
+
+`dp[i][j]` 代表到达该点的路径数量。该点可以从左边点或上边点到达
+也就是 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]` 。
+
+**Complexity:**
+
+* Time complexity : O(m*n).
+* Space complexity : O(m*n).

001-100/63. Unique Paths II.md

@@ -0,0 +1,82 @@
+# 63. Unique Paths II
+
+- Difficulty: Medium.
+- Related Topics: Array, Dynamic Programming.
+- Similar Questions: Unique Paths.
+
+## Problem
+
+A robot is located at the top-left corner of a **m** x **n** grid (marked 'Start' in the diagram below).
+
+The robot can only move either down or right at any point in time. The robot is trying to reach the bottom-right corner of the grid (marked 'Finish' in the diagram below).
+
+Now consider if some obstacles are added to the grids. How many unique paths would there be?
+
+![](https://leetcode.com/static/images/problemset/robot_maze.png)
+
+An obstacle and empty space is marked as ```1``` and ```0``` respectively in the grid.
+
+**Note:** **m** and **n** will be at most 100.
+
+**Example 1:**
+
+```
+Input:
+[
+  [0,0,0],
+  [0,1,0],
+  [0,0,0]
+]
+Output: 2
+Explanation:
+There is one obstacle in the middle of the 3x3 grid above.
+There are two ways to reach the bottom-right corner:
+1. Right -> Right -> Down -> Down
+2. Down -> Down -> Right -> Right
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} obstacleGrid
+ * @return {number}
+ */
+var uniquePathsWithObstacles = function(obstacleGrid) {
+  var m = obstacleGrid.length;
+  var n = (obstacleGrid[0] || []).length;
+  var dp = Array(m);
+  var left = 0;
+  var top = 0;
+
+  if (!m || !n) return 0;
+  
+  for (var i = 0; i < m; i++) {
+    dp[i] = Array(n);
+    for (var j = 0; j < n; j++) {
+      left = (j === 0 || obstacleGrid[i][j - 1] === 1) ? 0 : dp[i][j - 1];
+      top = (i === 0 || obstacleGrid[i - 1][j] === 1) ? 0 : dp[i - 1][j];
+      dp[i][j] = obstacleGrid[i][j] === 1 ? 0 : ((i === 0 && j === 0) ? 1 : (left + top));
+    }
+  }
+  
+  return dp[m - 1][n - 1];
+};
+```
+
+**Explain:**
+
+`dp[i][j]` 代表到达该点的路径数量。该点可以从左边点或上边点到达
+也就是 `dp[i][j] = dp[i - 1][j] + dp[i][j - 1]`。
+
+考虑特殊情况：
+
+1. 该点为障碍，`dp[i][j] = 0`;
+2. 左边点为障碍或不存在，`left = 0`;
+3. 上边点点为障碍或不存在，`top = 0`;
+4. 左边点与上边点均不存在，即起点，`dp[i][j] = 1`;
+
+**Complexity:**
+
+* Time complexity : O(m*n).
+* Space complexity : O(m*n).

001-100/64. Minimum Path Sum.md

@@ -0,0 +1,64 @@
+# 64. Minimum Path Sum
+
+- Difficulty: Medium.
+- Related Topics: Array, Dynamic Programming.
+- Similar Questions: Unique Paths, Dungeon Game, Cherry Pickup.
+
+## Problem
+
+Given a **m** x **n** grid filled with non-negative numbers, find a path from top left to bottom right which **minimizes** the sum of all numbers along its path.
+
+**Note:** You can only move either down or right at any point in time.
+
+**Example:**
+
+```
+Input:
+[
+  [1,3,1],
+  [1,5,1],
+  [4,2,1]
+]
+Output: 7
+Explanation: Because the path 1→3→1→1→1 minimizes the sum.
+```
+
+## Solution
+
+```javascript
+/**
+ * @param {number[][]} grid
+ * @return {number}
+ */
+var minPathSum = function(grid) {
+  var m = grid.length;
+  var n = (grid[0] || []).length;
+  var dp = Array(m);
+  var left = 0;
+  var top = 0;
+  
+  if (!m || !n) return 0;
+    
+  for (var i = 0; i < m; i++) {
+    dp[i] = Array(n);
+    for (var j = 0; j < n; j++) {
+      top = i === 0 ? Number.MAX_SAFE_INTEGER : dp[i - 1][j];
+      left = j === 0 ? Number.MAX_SAFE_INTEGER : dp[i][j - 1];
+      dp[i][j] = grid[i][j] + (i === 0 && j === 0 ? 0 : Math.min(left, top));
+    }
+  }
+  
+  return dp[m - 1][n - 1];
+};
+```
+
+**Explain:**
+
+`dp[i][j]` 代表到达此位置的最小 `sum`。
+
+`dp[i][j] = min(dp[i - 1][j] + dp[i][j - 1]) + grid[i][j]`;
+
+**Complexity:**
+
+* Time complexity : O(m*n).
+* Space complexity : O(m*n).

001-100/65. Valid Number.md

@@ -0,0 +1,80 @@
+# 65. Valid Number
+
+- Difficulty: Hard.
+- Related Topics: Math, String.
+- Similar Questions: String to Integer (atoi).
+
+## Problem
+
+Validate if a given string is numeric.
+
+Some examples:
+```"0"``` => ```true```
+```" 0.1 "``` => ```true```
+```"abc"``` => ```false```
+```"1 a"``` => ```false```
+```"2e10"``` => ```true```
+
+**Note:** It is intended for the problem statement to be ambiguous. You should gather all requirements up front before implementing one.
+
+**Update (2015-02-10):**
+The signature of the ```C++``` function had been updated. If you still see your function signature accepts a ```const char *``` argument, please click the reload button to reset your code definition.
+
+## Solution
+
+```javascript
+/**
+ * @param {string} s
+ * @return {boolean}
+ */
+var isNumber = function(s) {
+  var state = [
+    {}, 
+    {'blank': 1, 'sign': 2, 'digit':3, '.':4}, 
+    {'digit':3, '.':4},
+    {'digit':3, '.':5, 'e':6, 'blank':9},
+    {'digit':5},
+    {'digit':5, 'e':6, 'blank':9},
+    {'sign':7, 'digit':8},
+    {'digit':8},
+    {'digit':8, 'blank':9},
+    {'blank':9}
+  ];
+  var validState = [3, 5, 8, 9];
+  var currentState = 1;
+  var len = s.length;
+  var str = '';
+  var type = '';
+  for (var i = 0; i < len; i++) {
+    str = s[i];
+    if (str >= '0' && str <= '9') {
+      type = 'digit';
+    } else if (str === '+' || str === '-') {
+      type = 'sign';
+    } else if (str === ' ') {
+      type = 'blank';
+    } else {
+      type = str;
+    }
+    if (state[currentState][type] === undefined) {
+      return false;
+    } else {
+      currentState = state[currentState][type];
+    }
+  }
+	if (validState.indexOf(currentState) === -1) {
+    return false;
+	} else {
+    return true;
+	}
+};
+```
+
+**Explain:**
+
+[DFA 确定有限状态自动机](https://leetcode.com/problems/valid-number/discuss/23728/A-simple-solution-in-Python-based-on-DFA)
+
+**Complexity:**
+
+* Time complexity : O(n).
+* Space complexity : O(1).