1000题了惹

Author: MangoDowner

indexes/力扣千题.md

@@ -394,6 +394,7 @@
 * [949. 给定数字能组成的最大时间](../problems/949.给定数字能组成的最大时间.md)
 * [953. 验证外星语词典](../problems/953.验证外星语词典.md)
 * [954. 二倍数对数组](../problems/954.二倍数对数组.md)
+* [958. 二叉树的完全性检验](../problems/958.二叉树的完全性检验.md)
 * [963. 最小面积矩形 II](../problems/963.最小面积矩形II.md)
 * [965. 单值二叉树](../problems/965.单值二叉树.md)
 * [968. 监控二叉树](../problems/968.监控二叉树.md)
@@ -596,5 +597,6 @@
 * [1929. 数组串联](../problems/1929.数组串联.md)
 * [1933. 判断字符串是否可分解为值均等的子串](../problems/1933.判断字符串是否可分解为值均等的子串.md)
 * [1941. 检查是否所有字符出现次数相同](../problems/1941.检查是否所有字符出现次数相同.md)
+* [1942. 最小未被占据椅子的编号](../problems/1942.最小未被占据椅子的编号.md)
 * [1952. 三除数](../problems/1952.三除数.md)
 

problems/1942.最小未被占据椅子的编号.md

@@ -0,0 +1,171 @@
+#  1942. 最小未被占据椅子的编号
+有 n个朋友在举办一个派对，这些朋友从 0到 n - 1编号。
+派对里有 无数张椅子，编号为 0到 infinity。当一个朋友到达派对时，他会占据编号最小且未被占据的椅子。
+
+比方说，当一个朋友到达时，如果椅子0，1和5被占据了，那么他会占据2号椅子。
+当一个朋友离开派对时，他的椅子会立刻变成未占据状态。如果同一时刻有另一个朋友到达，可以立即占据这张椅子。
+
+给你一个下标从 0开始的二维整数数组times，其中``times[i] = [arrivali, leavingi]``表示第 i个朋友到达和离开的时刻，
+同时给你一个整数``targetFriend``。所有到达时间 互不相同。
+
+请你返回编号为``targetFriend``的朋友占据的 椅子编号。
+
+
+
+示例 1：
+```
+输入：times = [[1,4],[2,3],[4,6]], targetFriend = 1
+输出：1
+解释：
+- 朋友 0 时刻 1 到达，占据椅子 0 。
+- 朋友 1 时刻 2 到达，占据椅子 1 。
+- 朋友 1 时刻 3 离开，椅子 1 变成未占据。
+- 朋友 0 时刻 4 离开，椅子 0 变成未占据。
+- 朋友 2 时刻 4 到达，占据椅子 0 。
+朋友 1 占据椅子 1 ，所以返回 1 。
+```
+示例 2：
+```
+输入：times = [[3,10],[1,5],[2,6]], targetFriend = 0
+输出：2
+解释：
+- 朋友 1 时刻 1 到达，占据椅子 0 。
+- 朋友 2 时刻 2 到达，占据椅子 1 。
+- 朋友 0 时刻 3 到达，占据椅子 2 。
+- 朋友 1 时刻 5 离开，椅子 0 变成未占据。
+- 朋友 2 时刻 6 离开，椅子 1 变成未占据。
+- 朋友 0 时刻 10 离开，椅子 2 变成未占据。
+朋友 0 占据椅子 2 ，所以返回 2 。
+```
+
+提示：
+```
+n == times.length
+2 <= n <= 104
+times[i].length == 2
+1 <= arrivali < leavingi <= 105
+0 <= targetFriend <= n - 1
+每个arrivali时刻互不相同。
+```
+
+## [C#]优先队列
+### 解题思路
+参考的官方解法：
+
++ 对于每一个人，它会在两个时刻影响椅子占据与否的状态：
+    + 在他到达时，他会选择占据编号最小的未被占据的椅子；
+    + 在他离开时，他会释放之前占据的椅子。
++ 这两种情况分别对应以下操作：
+    + 查询当前未被占据的编号最小的椅子，并将该椅子移出未被占据椅子的集合；
+    + 查询某个人当前占据的椅子编号，并将该椅子加入未被占据的椅子中。
+
+
+C#没有优先队列，需要自己实现
+
+
+### 代码
+
+```csharp
+public class Solution
+{
+    public int SmallestChair(int[][] times, int targetFriend)
+    {
+        var n = times.Length;
+        var arrive = new int[n][];
+        var leave = new int[n][];
+        for (var i = 0; i < n; i++)
+        {
+            arrive[i] = new int[2];
+            arrive[i][0] = times[i][0];
+            arrive[i][1] = i;
+            leave[i] = new int[2];
+            leave[i][0] = times[i][1];
+            leave[i][1] = i;
+        }
+
+        // 升序排列
+        Array.Sort(arrive, (a, b) => a[0].CompareTo(b[0]));
+        Array.Sort(leave, (a, b) => a[0].CompareTo(b[0]));
+
+        var pq = new PriorityQueue<int>(); //存储可用座位
+        for (var i = 0; i < n; i++)
+        {
+            pq.Add(i); // n个人最多用到n个座位 起初都可用
+        }
+
+        var map = new Dictionary<int, int>(); //存储人与座位
+        var j = 0; //记录离开到哪个人
+        foreach (var arr in arrive)
+        {
+            // 释放座位
+            while (j < n && leave[j][0] <= arr[0])
+            {
+                pq.Add(map[leave[j][1]]);
+                j++;
+            }
+
+            int seat = pq.PopFirst(); //最小座位
+            map.Add(arr[1], seat);
+            if (arr[1] == targetFriend) return seat;
+        }
+
+        return -1;
+    }
+}
+
+public class PriorityQueue<T> where T : IComparable<T>
+{
+    private SortedList<T, int> list = new SortedList<T, int>();
+    private int count = 0;
+
+    public void Add(T item)
+    {
+        if (list.ContainsKey(item)) list[item]++;
+        else list.Add(item, 1);
+
+        count++;
+    }
+
+    public T PopFirst()
+    {
+        if (Size() == 0) return default(T);
+        T result = list.Keys[0];
+        if (--list[result] == 0)
+            list.RemoveAt(0);
+
+        count--;
+        return result;
+    }
+
+    public T PopLast()
+    {
+        if (Size() == 0) return default(T);
+        int index = list.Count - 1;
+        T result = list.Keys[index];
+        if (--list[result] == 0)
+            list.RemoveAt(index);
+
+        count--;
+        return result;
+    }
+
+    public int Size()
+    {
+        return count;
+    }
+
+    public T PeekFirst()
+    {
+        if (Size() == 0) return default(T);
+        return list.Keys[0];
+    }
+
+    public T PeekLast()
+    {
+        if (Size() == 0) return default(T);
+        int index = list.Count - 1;
+        return list.Keys[index];
+    }
+}
+
+```

problems/958.二叉树的完全性检验.md

@@ -0,0 +1,67 @@
+#   958. 二叉树的完全性检验
+给定一个二叉树，确定它是否是一个完全二叉树。
+
+百度百科中对完全二叉树的定义如下：
+
+若设二叉树的深度为 h，除第 h 层外，其它各层 (1～h-1) 的结点数都达到最大个数，
+第 h 层所有的结点都连续集中在最左边，这就是完全二叉树。（注：第 h 层可能包含 1~2h个节点。）
+
+
+示例 1：
+```
+输入：[1,2,3,4,5,6]
+输出：true
+解释：最后一层前的每一层都是满的（即，结点值为 {1} 和 {2,3} 的两层），且最后一层中的所有结点（{4,5,6}）都尽可能地向左。
+```
+示例 2：
+```
+输入：[1,2,3,4,5,null,7]
+输出：false
+解释：值为 7 的结点没有尽可能靠向左侧。
+```
+
+提示：
+```
+树中将会有 1 到 100 个结点。
+```
+
+### 解题思路
++ 对于根节点，我们定义其编号为 1。然后，对于每个节点 v，我们将其左节点编号为 ``2 * v``，将其右节点编号为 ``2 * v + 1``。
++ 我们可以发现，树中所有节点的编号按照广度优先搜索顺序正好是升序。（也可以使用深度优先搜索，之后对序列排序）。
++ 然后，我们检测编号序列是否为无间隔的 1, 2, 3, …，事实上，我们只需要检查最后一个编号是否正确，因为最后一个编号的值最大。
+
+### 代码
+
+```csharp
+/**
+ * Definition for a binary tree node.
+ * public class TreeNode {
+ *     public int val;
+ *     public TreeNode left;
+ *     public TreeNode right;
+ *     public TreeNode(int val=0, TreeNode left=null, TreeNode right=null) {
+ *         this.val = val;
+ *         this.left = left;
+ *         this.right = right;
+ *     }
+ * }
+ */
+public class Solution
+{
+    public bool IsCompleteTree(TreeNode root)
+    {
+        var nodes = new List<(TreeNode node, int value)> {(root, 1)};
+        var i = 0;
+        while (i < nodes.Count)
+        {
+            var curNode = nodes[i];
+            i++;
+            if (curNode.node == null) continue;
+            nodes.Add((curNode.node.left, curNode.value * 2));
+            nodes.Add((curNode.node.right, curNode.value * 2 + 1));
+        }
+
+        return nodes[i - 1].value == nodes.Count;
+    }
+}
+```