feat: solve No.210,950

201-300/210. Course Schedule II.md

@@ -74,22 +74,20 @@ var findOrder = function(numCourses, prerequisites) {
         requiringMap[prerequisites[i][0]]++;
         requiredByMap[prerequisites[i][1]].push(prerequisites[i][0]);
     }
-    var queue = new MinPriorityQueue();
+    var queue = [];
     for (var j = 0; j < numCourses; j++) {
-        queue.enqueue(j, requiringMap[j]);
+        requiringMap[j] === 0 && queue.push(j);
     }
     var res = [];
-    while (queue.size()) {
-        var item = queue.dequeue();
-        if (requiringMap[item.element] !== item.priority) continue;
-        if (item.priority !== 0) return [];
-        res.push(item.element);
-        for (var k = 0; k < requiredByMap[item.element].length; k++) {
-            requiringMap[requiredByMap[item.element][k]]--;
-            queue.enqueue(requiredByMap[item.element][k], requiringMap[requiredByMap[item.element][k]]);
+    while (queue.length) {
+        var course = queue.pop();
+        res.push(course);
+        for (var k = 0; k < requiredByMap[course].length; k++) {
+            requiringMap[requiredByMap[course][k]]--;
+            requiringMap[requiredByMap[course][k]] === 0 && queue.push(requiredByMap[course][k]);
         }
     }
-    return res;
+    return res.length === numCourses ? res : [];
 };
 ```
 
@@ -99,5 +97,5 @@ nope.
 
 **Complexity:**
 
-* Time complexity : O(n * log(n)).
+* Time complexity : O(n).
 * Space complexity : O(n).

901-1000/950. Reveal Cards In Increasing Order.md

@@ -0,0 +1,105 @@
+# 950. Reveal Cards In Increasing Order
+
+- Difficulty: Medium.
+- Related Topics: Array, Queue, Sorting, Simulation.
+- Similar Questions: .
+
+## Problem
+
+You are given an integer array `deck`. There is a deck of cards where every card has a unique integer. The integer on the `ith` card is `deck[i]`.
+
+You can order the deck in any order you want. Initially, all the cards start face down (unrevealed) in one deck.
+
+You will do the following steps repeatedly until all cards are revealed:
+
+
+
+- Take the top card of the deck, reveal it, and take it out of the deck.
+
+- If there are still cards in the deck then put the next top card of the deck at the bottom of the deck.
+
+- If there are still unrevealed cards, go back to step 1. Otherwise, stop.
+
+
+Return **an ordering of the deck that would reveal the cards in increasing order**.
+
+**Note** that the first entry in the answer is considered to be the top of the deck.
+
+
+Example 1:
+
+```
+Input: deck = [17,13,11,2,3,5,7]
+Output: [2,13,3,11,5,17,7]
+Explanation: 
+We get the deck in the order [17,13,11,2,3,5,7] (this order does not matter), and reorder it.
+After reordering, the deck starts as [2,13,3,11,5,17,7], where 2 is the top of the deck.
+We reveal 2, and move 13 to the bottom.  The deck is now [3,11,5,17,7,13].
+We reveal 3, and move 11 to the bottom.  The deck is now [5,17,7,13,11].
+We reveal 5, and move 17 to the bottom.  The deck is now [7,13,11,17].
+We reveal 7, and move 13 to the bottom.  The deck is now [11,17,13].
+We reveal 11, and move 17 to the bottom.  The deck is now [13,17].
+We reveal 13, and move 17 to the bottom.  The deck is now [17].
+We reveal 17.
+Since all the cards revealed are in increasing order, the answer is correct.
+```
+
+Example 2:
+
+```
+Input: deck = [1,1000]
+Output: [1,1000]
+```
+
+
+**Constraints:**
+
+
+
+- `1 <= deck.length <= 1000`
+
+- `1 <= deck[i] <= 106`
+
+- All the values of `deck` are **unique**.
+
+
+
+## Solution
+
+```javascript
+/**
+ * @param {number[]} deck
+ * @return {number[]}
+ */
+var deckRevealedIncreasing = function(deck) {
+    deck.sort((a, b) => a - b);
+    var res = Array(deck.length);
+    var i = 0;
+    var j = 0;
+    var skip = false;
+    while (i < deck.length) {
+        // find space for card
+        if (res[j] === undefined) {
+            // place card if it's not skip round
+            if (!skip) {
+                res[j] = deck[i];
+                i++;
+            }
+            // revert skip flag
+            skip = !skip;
+        }
+        // try next place
+        j = (j + 1) % deck.length;
+    }
+    return res;
+};
+```
+
+**Explain:**
+
+nope.
+
+**Complexity:**
+
+* Time complexity : O(n * log(n)).
+* Space complexity : O(n).