content stringlengths 263 5.24M | pred_label stringclasses 1
value | pred_score_pos float64 0.6 1 |
|---|---|---|
# 题目
直方图是由在公共基线处对齐的一系列矩形组成的多边形。
矩形具有相等的宽度，但可以具有不同的高度。
例如，图例左侧显示了由高度为 2,1,4,5,1,3,3 的矩形组成的直方图，矩形的宽度都为 1：
通常，直方图用于表示离散分布，例如，文本中字符的频率。
现在，请你计算在公共基线处对齐的直方图中最大矩形的面积。
图例右图显示了所描绘直方图的最大对齐矩形。
输入格式<br>
输入包含几个测试用... | __label__POS | 0.999959 |
#include <u.h>
#include <libc.h>
#include <ip.h>
#include <bio.h>
#include <ndb.h>
static uchar noether[6];
Ndb *db;
static void
recursesubnet(Ndb *db, uchar *addr, uchar *mask, char *attr, char *name, char *name1)
{
Ndbs s;
Ndbtuple *t, *nt;
uchar submask[IPaddrlen], net[IPaddrlen];
char ip[Ndbvlen];
int found... | __label__POS | 0.605807 |
# 题目
输入两个整数序列，第一个序列表示栈的压入顺序，请判断第二个序列是否可能为该栈的弹出顺序。
假设压入栈的所有数字均不相等。
例如序列 1,2,3,4,5 是某栈的压入顺序，序列 4,5,3,2,1 是该压栈序列对应的一个弹出序列，但 4,3,5,1,2 就不可能是该压栈序列的弹出序列。
注意：若两个序列长度不等则视为并不是一个栈的压入、弹出序列。若两个序列都为空，则视为是一个栈的压入、弹出序列。
样例
```
输入：[1,2,3,4,5]
[4,5,3,2,1]
输出：true
```
# 参考答案
```c++
class Solution {
public:
bool isPopOrder(... | __label__POS | 1.00001 |
# 题目
达达现在碰到了一个棘手的问题，有 N 个整数需要排序。
达达手头能用的工具就是若干个双端队列。
她从 1 到 N 需要依次处理这 N 个数，对于每个数，达达能做以下两件事：
1．新建一个双端队列，并将当前数作为这个队列中的唯一的数；
2．将当前数放入已有的队列的头之前或者尾之后。
对所有的数处理完成之后，达达将这些队列按一定的顺序连接起来后就可以得到一个非降的序列。
请你求出最少需要多少个双端序列。
输入格式<br>
第一行输入整数 N，代表整数的个数。
接下来 N 行，每行包括一个整数 Di，代表所需处理的整数。
输出格式<br>
输出一个整数，代表最少需要的双端队列数。
数据范围<br>
1≤N≤2... | __label__POS | 0.999193 |
# 题目
请你写一个函数 StrToInt，实现把字符串转换成整数这个功能。
当然，不能使用 atoi 或者其他类似的库函数。
样例
```
输入："123"
输出：123
```
注意:
你的函数应满足下列条件：
* 忽略所有行首空格，找到第一个非空格字符，可以是 ‘+/−’ 表示是正数或者负数，紧随其后找到最长的一串连续数字，将其解析成一个整数；
* 整数后可能有任意非数字字符，请将其忽略；
* 如果整数长度为 0，则返回 0；
* 如果整数大于 INT_MAX(231−1)，请返回 INT_MAX；如果整数小于INT_MIN(−231) ，请返回 INT_MIN；
# 参考答案
```c++
class Solut... | __label__POS | 1.000007 |
# 题目
农夫约翰的农场由 N 块田地组成，每块地里都有一定数量的牛，其数量不会少于 1 头，也不会超过 2000 头。
约翰希望用围栏将一部分连续的田地围起来，并使得围起来的区域内每块地包含的牛的数量的平均值达到最大。
围起区域内至少需要包含 F 块地，其中 F 会在输入中给出。
在给定条件下，计算围起区域内每块地包含的牛的数量的平均值可能的最大值是多少。
输入格式<br>
第一行输入整数 N 和 F，数据间用空格隔开。
接下来 N 行，每行输入一个整数，第 i+1 行输入的整数代表第 i 片区域内包含的牛的数目。
输出格式<br>
输出一个整数，表示平均值的最大值乘以 1000 再 向下取整 之后得到的结果。
数据... | __label__POS | 0.999361 |
# 题目
城市的规划在城市建设中是个大问题。
不幸的是，很多城市在开始建设的时候并没有很好的规划，城市规模扩大之后规划不合理的问题就开始显现。
而这座名为 Fractal 的城市设想了这样的一个规划方案，如下图所示：
当城区规模扩大之后，Fractal 的解决方案是把和原来城区结构一样的区域按照图中的方式建设在城市周围，提升城市的等级。
对于任意等级的城市，我们把正方形街区从左上角开始按照道路标号。
... | __label__POS | 0.992367 |
# 题目
有 N 片雪花，每片雪花由六个角组成，每个角都有长度。
第 i 片雪花六个角的长度从某个角开始顺时针依次记为 a<sub>i</sub>,1,a<sub>i</sub>,2,…,a<sub>i</sub>,6。
因为雪花的形状是封闭的环形，所以从任何一个角开始顺时针或逆时针往后记录长度，得到的六元组都代表形状相同的雪花。
例如 a<sub>i</sub>,1,a<sub>i</sub>,2,…,a<sub>i</sub>,6 和 a<sub>i</sub>,2,a<sub>i</sub>,3,…,a<sub>i</sub>,6，a<sub>i</sub>,1 就是形状相同的雪花。
a<sub>i</sub>,1,a... | __label__POS | 0.997885 |
#include <iostream>
int main() {
int m = [](int x) { return [](int y) { return y * 2; }(x)+6; }(5);
std::cout << "m:" << m << std::endl; //输出m:16
std::cout << "n:" << [](int x, int y) { return x + y; }(5, 4) << std::endl; //输出n:9
auto gFunc = [](int x)... | __label__POS | 0.858543 |
#include "stdio.h"
#include <string>
#include <iostream>
using namespace std;
class MyString
{
public:
MyString() :m_pData(NULL), m_nLen(0)
{
cout << "MyString()" << endl;
}
MyString(const char *pStr) // 允许隐式转换
{
cout << "MyString(const char *pStr)" << endl;
m_nLen = strl... | __label__POS | 0.983504 |
# 题目
一定玩过八数码游戏，它实际上是在一个 3×3 的网格中进行的，1 个空格和 1∼8 这 8 个数字恰好不重不漏地分布在这 3×3 的网格中。
例如：
```
5 2 8
1 3 _
4 6 7
```
在游戏过程中，可以把空格与其上、下、左、右四个方向之一的数字交换（如果存在）。
例如在上例中，空格可与左、上、下面的数字交换，分别变成：
```
5 2 8 5 2 _ 5 2 8
1 _ 3 1 3 8 1 3 7
4 6 7 4 6 7 4 6 _
```
奇数码游戏是它的一个扩展，在一个 n×n 的网格中进行，其中 n 为奇数，1 个空格和 1∼n<... | __label__POS | 0.945744 |
# 题目
输入一个长度为 n 的整数序列，从中找出一段长度不超过 m 的连续子序列，使得子序列中所有数的和最大。
注意： 子序列的长度至少是 1。
输入格式<br>
第一行输入两个整数 n,m。
第二行输入 n 个数，代表长度为 n 的整数序列。
同一行数之间用空格隔开。
输出格式<br>
输出一个整数，代表该序列的最大子序和。
数据范围<br>
1≤n,m≤300000
输入样例：
```
6 4
1 -3 5 1 -2 3
```
输出样例：
```
7
```
# 参考答案
```c++
#include <bits/stdc++.h>
using namespace std;
#define fir(i,a,b... | __label__POS | 0.998741 |
# 题目
有 C 头奶牛进行日光浴，第 i 头奶牛需要 minSPF[i] 到 maxSPF[i] 单位强度之间的阳光。
每头奶牛在日光浴前必须涂防晒霜，防晒霜有 L 种，涂上第 i 种之后，身体接收到的阳光强度就会稳定为 SPF[i]，第 i 种防晒霜有 cover[i] 瓶。
求最多可以满足多少头奶牛进行日光浴。
输入格式<br>
第一行输入整数 C 和 L。
接下来的 C 行，按次序每行输入一头牛的 minSPF 和 maxSPF 值，即第 i 行输入 minSPF[i] 和 maxSPF[i]。
再接下来的 L 行，按次序每行输入一种防晒霜的 SPF 和 cover 值，即第 i 行输入 SPF[i] 和 cove... | __label__POS | 0.999744 |
# 题目
有 n 个小组要排成一个队列，每个小组中有若干人。
当一个人来到队列时，如果队列中已经有了自己小组的成员，他就直接插队排在自己小组成员的后面，否则就站在队伍的最后面。
请你编写一个程序，模拟这种小组队列。
输入格式：<br>
输入将包含一个或多个测试用例。
对于每个测试用例，第一行输入小组数量 t。
接下来 t 行，每行输入一个小组描述，第一个数表示这个小组的人数，接下来的数表示这个小组的人的编号。
编号是 0 到 999999 范围内的整数。
一个小组最多可包含 1000 个人。
最后，命令列表如下。 有三种不同的命令：
1、ENQUEUE x - 将编号是 x 的人插入队列；
2、DEQUEUE -... | __label__POS | 0.960936 |
//强类型枚举以及c++11对原有枚举类型的扩展
//声明强类型枚举，只需要在enum加上关键字class。
//enum class Type { General, Light, Medium, Heavy };
//优点：
//（1）强作用域，强类型枚举成员的名称不会被输出到其父作用域空间
//（2）转换限制，强类型枚举成员的值不可以与整形隐式地相互转换
//（3）可以指定底层类型。强类型枚举默认的底层类型为int，但也可以显式地指定底层类型。
//比如：
//enum class Type: char { General, Light, Medium, Heavy };
#include <iostream>
using... | __label__POS | 0.998892 |
### 2025.7.5
### 时长：1h20min
1. String ，string builder和string buffer它们的区别是什么
2. 都适用于什么场景？或者你在开发时候什么场景使用
3. 深拷贝和浅拷贝
4. 深拷贝怎么实现
5. jvm内存模型中，方法区，堆以及这个本地方法栈程序计数器他们的各自作用是什么？
6. jvm内存管理的工作过程
7. hashset和hashmap区别？如何处理哈希冲突
8. concurrentHashMap在jdk1.7和1.8的实现区别
9. 有看过具体的代码实现吗
10. 进程间通信方式。包括线程间通信
11. 进程和线程的区别
12. 一个进程可以有多少个线程
13.... | __label__POS | 0.999751 |
# 题目
达达是一名漫画家，她有一个奇特的爱好，就是在纸上画括号。
这一天，刚刚起床的达达画了一排括号序列，其中包含小括号 ( )、中括号 [ ] 和大括号 { }，总长度为 N。
这排随意绘制的括号序列显得杂乱无章，于是达达定义了什么样的括号序列是美观的：
空的括号序列是美观的；<br>
若括号序列 A 是美观的，则括号序列 (A)、[A]、{A} 也是美观的；<br>
若括号序列 A、B 都是美观的，则括号序列 AB 也是美观的。<br>
例如 [(){}]() 是美观的括号序列，而)({)[}]( 则不是。<br>
现在达达想在她绘制的括号序列中，找出其中连续的一段，满足这段子序列是美观的，并且长度尽量大。
你能帮帮... | __label__POS | 0.999896 |
# 题目
超市里有 N 件商品，每件商品都有利润 p<sub>i</sub> 和过期时间 d<sub>i</sub>，每天只能卖一件商品，过期商品不能再卖。
求合理安排每天卖的商品的情况下，可以得到的最大收益是多少。
输入格式<br>
输入包含多组测试用例。
每组测试用例，以输入整数 N 开始，接下来输入 N 对 p<sub>i</sub> 和 d<sub>i</sub>，分别代表第 i 件商品的利润和过期时间。
在输入中，数据之间可以自由穿插任意个空格或空行，输入至文件结尾时终止输入，保证数据正确。
输出格式<br>
对于每组产品，输出一个该组的最大收益值。
每个结果占一行。
数据范围<br>
0≤N≤10000,<... | __label__POS | 0.999928 |
# 题目
请实现一个函数用来匹配包括'.'和'*'的正则表达式。
模式中的字符'.'表示任意一个字符，而'*'表示它前面的字符可以出现任意次（含0次）。
在本题中，匹配是指字符串的所有字符匹配整个模式。
例如，字符串"aaa"与模式"a.a"和"ab*ac*a"匹配，但是与"aa.a"和"ab*a"均不匹配。
样例
```
输入：
s="aa"
p="a*"
输出:true
```
# 参考答案
```c++
class Solution {
public:
vector<vector<int>>f;
int n, m;
bool isMatch(string s, string p) {
... | __label__POS | 1.000008 |
# 题目
你在一家 IT 公司为大型写字楼或办公楼的计算机数据做备份。
然而数据备份的工作是枯燥乏味的，因此你想设计一个系统让不同的办公楼彼此之间互相备份，而你则坐在家中尽享计算机游戏的乐趣。
已知办公楼都位于同一条街上，你决定给这些办公楼配对（两个一组）。
每一对办公楼可以通过在这两个建筑物之间铺设网络电缆使得它们可以互相备份。
然而，网络电缆的费用很高。
当地电信公司仅能为你提供 K 条网络电缆，这意味着你仅能为 K 对办公楼（总计 2K 个办公楼）安排备份。
任意一个办公楼都属于唯一的配对组（换句话说，这 2K 个办公楼一定是相异的）。
此外，电信公司需按网络电缆的长度（公里数）收费。
因而，你需要选择这 K ... | __label__POS | 0.999503 |
# 题目
请实现一个函数按照之字形顺序从上向下打印二叉树。
即第一行按照从左到右的顺序打印，第二层按照从右到左的顺序打印，第三行再按照从左到右的顺序打印，其他行以此类推。
样例
```
输入如下图所示二叉树[8, 12, 2, null, null, 6, 4, null, null, null, null]
8
/ \
12 2
/ \
6 4
输出：[[8], [2, 12], [6, 4]]
```
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;... | __label__POS | 1.00001 |
# 题目
你将要实现一个功能强大的整数序列编辑器。
在开始时，序列是空的。
编辑器共有五种指令，如下：
1、I x，在光标处插入数值 x。<br>
2、D，将光标前面的第一个元素删除，如果前面没有元素，则忽略此操作。<br>
3、L，将光标向左移动，跳过一个元素，如果左边没有元素，则忽略此操作。<br>
4、R，将光标向右移动，跳过一个元素，如果右边没有元素，则忽略次操作。<br>
5、Q k，假设此刻光标之前的序列为 a<sub>1</sub>,a<sub>2</sub>,…,a<sub>n</sub>，输出 max<sub>1≤i≤k</sub>S<sub>i</sub>，其中 S<sub>i</sub>=a<sub>1<... | __label__POS | 0.999792 |
# 题目
在一个果园里，达达已经将所有的果子打了下来，而且按果子的不同种类分成了不同的堆。
达达决定把所有的果子合成一堆。
每一次合并，达达可以把两堆果子合并到一起，消耗的体力等于两堆果子的重量之和。
可以看出，所有的果子经过 n−1 次合并之后，就只剩下一堆了。
达达在合并果子时总共消耗的体力等于每次合并所耗体力之和。
因为还要花大力气把这些果子搬回家，所以达达在合并果子时要尽可能地节省体力。
假定每个果子重量都为 1，并且已知果子的种类数和每种果子的数目，你的任务是设计出合并的次序方案，使达达耗费的体力最少，并输出这个最小的体力耗费值。
例如有 3 种果子，数目依次为 1，2，9。
可以先将 1、2 堆合并，新堆... | __label__POS | 1.000002 |
# 题目
农民约翰的 N 头奶牛（编号为 1..N）计划逃跑并加入马戏团，为此它们决定练习表演杂技。
奶牛们不是非常有创意，只提出了一个杂技表演：
叠罗汉，表演时，奶牛们站在彼此的身上，形成一个高高的垂直堆叠。
奶牛们正在试图找到自己在这个堆叠中应该所处的位置顺序。
这 N 头奶牛中的每一头都有着自己的重量 W<sub>i</sub> 以及自己的强壮程度 S<sub>i</sub>。
一头牛支撑不住的可能性取决于它头上所有牛的总重量（不包括它自己）减去它的身体强壮程度的值，现在称该数值为风险值，风险值越大，这只牛撑不住的可能性越高。
您的任务是确定奶牛的排序，使得所有奶牛的风险值中的最大值尽可能的小。
输入格式<br>... | __label__POS | 0.999972 |
# 题目
格格兰郡的 N 名士兵随机散落在全郡各地。
格格兰郡中的位置由一对 (x,y) 整数坐标表示。
士兵可以进行移动，每次移动，一名士兵可以向上，向下，向左或向右移动一个单位（因此，他的 x 或 y 坐标也将加 1 或减 1）。
现在希望通过移动士兵，使得所有士兵彼此相邻的处于同一条水平线内，即所有士兵的 y 坐标相同并且 x 坐标相邻。
请你计算满足要求的情况下，所有士兵的总移动次数最少是多少。
需注意，两个或多个士兵不能占据同一个位置。
输入格式<br>
第一行输入整数 N，代表士兵的数量。
接下来的 N 行，每行输入两个整数 x 和 y，分别代表一个士兵所在位置的 x 坐标和 y 坐标，第 i 行即为第 i... | __label__POS | 0.999353 |
# 题目
今天某公司有 M 个任务需要完成。
每个任务都有相应的难度级别和完成任务所需时间。
第 i 个任务的难度级别为 y<sub>i</sub>，完成任务所需时间为 x<sub>i</sub> 分钟。
如果公司完成此任务，他们将获得（500×x<sub>i</sub>+2×y<sub>i</sub>）美元收入。
该公司有 N 台机器，每台机器都有最长工作时间和级别。
如果任务所需时间超过机器的最长工作时间，则机器无法完成此任务。
如果任务难度级别超过机器的级别，则机器无法完成次任务。
每台机器一天内只能完成一项任务。
每个任务只能由一台机器完成。
请为他们设计一个任务分配方案，使得该公司能够最大化他们今天可以完... | __label__POS | 1.000005 |
# 题目
输入一棵二叉搜索树，将该二叉搜索树转换成一个排序的双向链表。
要求不能创建任何新的结点，只能调整树中结点指针的指向。
注意：
需要返回双向链表最左侧的节点。
例如，输入下图中左边的二叉搜索树，则输出右边的排序双向链表。
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int... | __label__POS | 1.00001 |
# 题目
给定 N 个字符串 S<sub>1</sub>,S<sub>2</sub>…S<sub>N</sub>，接下来进行 M 次询问，每次询问给定一个字符串 T，求 S<sub>1</sub>∼S<sub>N</sub> 中有多少个字符串是 T 的前缀。
输入字符串的总长度不超过 10<sup>6</sup>，仅包含小写字母。
输入格式<br>
第一行输入两个整数 N，M。
接下来 N 行每行输入一个字符串 S<sub>i</sub>。
接下来 M 行每行一个字符串 T 用以询问。
输出格式<br>
对于每个询问，输出一个整数表示答案。
每个答案占一行。
输入样例：
```
3 2
ab
bc
abc
abc
ef... | __label__POS | 1.000009 |
# 题目
请实现一个函数，用来判断一棵二叉树是不是对称的。
如果一棵二叉树和它的镜像一样，那么它是对称的。
样例
```
如下图所示二叉树[1,2,2,3,4,4,3,null,null,null,null,null,null,null,null]为对称二叉树：
1
/ \
2 2
/ \ / \
3 4 4 3
如下图所示二叉树[1,2,2,null,4,4,3,null,null,null,null,null,null]不是对称二叉树：
1
/ \
2 2
\ / \
4 4 3
```
# 参考答案
```c++
/**
* Definition for ... | __label__POS | 1.00001 |
# 题目
有 n 个小朋友坐成一圈，每人有 a[i] 个糖果。
每人只能给左右两人传递糖果。
每人每次传递一个糖果代价为 1。
求使所有人获得均等糖果的最小代价。
输入格式<br>
第一行输入一个正整数 n，表示小朋友的个数。
接下来 n 行，每行一个整数 a[i]，表示第 i 个小朋友初始得到的糖果的颗数。
输出格式<br>
输出一个整数，表示最小代价。
数据范围<br>
1≤n≤1000000,<br>
0≤a[i]≤2×10<sup>9</sup>,<br>
数据保证一定有解。
输入样例：
```
4
1
2
5
4
```
输出样例：
```
4
```
# 参考答案
```c++
#include<iost... | __label__POS | 0.999996 |
# 题目
地图上有 N 个目标，用整数 X<sub>i</sub>,Y<sub>i</sub> 表示目标在地图上的位置，每个目标都有一个价值 Wi。
注意：不同目标可能在同一位置。
现在有一种新型的激光炸弹，可以摧毁一个包含 R×R 个位置的正方形内的所有目标。
激光炸弹的投放是通过卫星定位的，但其有一个缺点，就是其爆炸范围，即那个正方形的边必须和 x，y 轴平行。
求一颗炸弹最多能炸掉地图上总价值为多少的目标。
输入格式<br>
第一行输入正整数 N 和 R，分别代表地图上的目标数目和正方形的边长，数据用空格隔开。
接下来 N 行，每行输入一组数据，每组数据包括三个整数 X<sub>i</sub>,Y<sub>i</s... | __label__POS | 0.99976 |
# 题目
输入两个整数，求这两个整数的和是多少。
输入格式
输入两个整数A,B，用空格隔开，0≤A,B≤10的8次幂
输出格式
输出一个整数，表示这两个数的和
样例输入：
```
3 4
```
样例输出：
```
7
```
# 参考答案
### c++代码
```c++
#include <iostream>
using namespace std;
int main () {
int a, b;
cin >> a >> b;
cout << a + b << endl;
return 0;
}
```
### C 代码
```c
#include <stdio.h>
int m... | __label__POS | 0.999991 |
# 题目
从上到下按层打印二叉树，同一层的结点按从左到右的顺序打印，每一层打印到一行。
样例
```
输入如下图所示二叉树[8, 12, 2, null, null, 6, null, 4, null, null, null]
8
/ \
12 2
/
6
/
4
输出：[[8], [12, 2], [6], [4]]
```
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNo... | __label__POS | 1.00001 |
# 题目
恰逢 H 国国庆，国王邀请 n 位大臣来玩一个有奖游戏。
首先，他让每个大臣在左、右手上面分别写下一个整数，国王自己也在左、右手上各写一个整数。
然后，让这 n 位大臣排成一排，国王站在队伍的最前面。
排好队后，所有的大臣都会获得国王奖赏的若干金币，每位大臣获得的金币数分别是:
排在该大臣前面的所有人的左手上的数的乘积除以他自己右手上的数，然后向下取整得到的结果。
国王不希望某一个大臣获得特别多的奖赏，所以他想请你帮他重新安排一下队伍的顺序，使得获得奖赏最多的大臣，所获奖赏尽可能的少。
注意，国王的位置始终在队伍的最前面。
输入格式<br>
第一行包含一个整数 n，表示大臣的人数。
第二行包含两个整数 a ... | __label__POS | 0.999827 |
# 题目
输入一个英文句子，单词之间用一个空格隔开，且句首和句尾没有多余空格。
翻转句子中单词的顺序，但单词内字符的顺序不变。
为简单起见，标点符号和普通字母一样处理。
例如输入字符串"I am a student."，则输出"student. a am I"。
样例
```
输入："I am a student."
输出："student. a am I"
```
# 参考答案
```c++
class Solution {
public:
string reverseWords(string s)
{
if(!s.size()) return "" ; //特判... | __label__POS | 1.00001 |
# 题目
有 N 组物品和一个容量是 V 的背包。
每组物品有若干个，同一组内的物品最多只能选一个。
每件物品的体积是V<sub>ij</sub>，价值是 w<sub>ij</sub>，其中 i 是组号，j 是组内编号。
求解将哪些物品装入背包，可使物品总体积不超过背包容量，且总价值最大。
输出最大价值。
输入格式
第一行有两个整数 N，V，用空格隔开，分别表示物品组数和背包容量。
接下来有 N 组数据：
每组数据第一行有一个整数 S<sub>i</sub>，表示第 i 个物品组的物品数量；
每组数据接下来有 S<sub>i</sub> 行，每行有两个整数 v<sub>ij</sub>,w<sub>ij</sub>，用空... | __label__POS | 0.999987 |
# 题目
从 1∼n 这 n 个整数中随机选出 m 个，输出所有可能的选择方案。
输入格式<br>
两个整数 n,m ,在同一行用空格隔开。
输出格式<br>
按照从小到大的顺序输出所有方案，每行 1 个。
首先，同一行内的数升序排列，相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面（例如 1 3 5 7 排在 1 3 6 8 前面）。
数据范围<br>
n>0 ,<br>
0≤m≤n ,<br>
n+(n−m)≤25
输入样例：
```
5 3
```
输出样例：
```
1 2 3
1 2 4
1 2 5
1 3 4
1 3 5
1 4 5
2 3 4
2 ... | __label__POS | 0.999795 |
# 题目
输入一棵二叉树和一个整数，打印出二叉树中结点值的和为输入整数的所有路径。
从树的根结点开始往下一直到叶结点所经过的结点形成一条路径。
样例
```
给出二叉树如下所示，并给出num=22。
5
/ \
4 6
/ / \
12 13 6
/ \ / \
9 1 5 1
输出：[[5,4,12,1],[5,6,6,5]]
```
# 参考答案
```c++
/**
* Definition for a binary tree node.
* public class TreeNode {
* int val;
* Tree... | __label__POS | 1.00001 |
# 题目
有 N 头牛在畜栏中吃草。
每个畜栏在同一时间段只能提供给一头牛吃草，所以可能会需要多个畜栏。
给定 N 头牛和每头牛开始吃草的时间 A 以及结束吃草的时间 B，每头牛在 [A,B] 这一时间段内都会一直吃草。
当两头牛的吃草区间存在交集时（包括端点），这两头牛不能被安排在同一个畜栏吃草。
求需要的最小畜栏数目和每头牛对应的畜栏方案。
输入格式<br>
第 1 行：输入一个整数 N。
第 2..N+1 行：第 i+1 行输入第 i 头牛的开始吃草时间 A 以及结束吃草时间 B，数之间用空格隔开。
输出格式<br>
第 1 行：输入一个整数，代表所需最小畜栏数。
第 2..N+1 行：第 i+1 行输入第 i... | __label__POS | 0.986634 |
# 题目
一颗树有 n 个节点，这些节点被标号为：1,2,3…n，每个节点 i 都有一个权值 A[i]。
现在要把这棵树的节点全部染色，染色的规则是：
根节点 R 可以随时被染色；对于其他节点，在被染色之前它的父亲节点必须已经染上了色。
每次染色的代价为 T×A[i]，其中 T 代表当前是第几次染色。
求把这棵树染色的最小总代价。
输入格式
第一行包含两个整数 n 和 R，分别代表树的节点数以及根节点的序号。
第二行包含 n 个整数，代表所有节点的权值，第 i 个数即为第 i 个节点的权值 A[i]。
接下来 n−1 行，每行包含两个整数 a 和 b，代表两个节点的序号，两节点满足关系： a 节点是 b 节点的父节点。... | __label__POS | 0.999996 |
//一个对象既是普通类型（Trivial Type）又是标准布局类型（Standard-layout Type）那么这个对象就是POD类型。
//为什么我们需要 POD 类型满足这些条件呢，POD 类型在源码层级的操作上兼容于 ANSI C。POD 对象与 C 语言中的
//对象具有一些共同的特性，包括初始化、复制、内存布局与寻址：
//（1）可以使用字节赋值，比如用 memset、memcpy 对 POD 类型进行赋值操作；
//（2）对 C 内存布局兼容，POD 类型的数据可以使用 C 函数进行操作且总是安全的；
//（3）保证了静态初始化的安全有效，静态初始化可以提高性能，如将 POD 类型对象放入 BSS 段默认初始化为 0... | __label__POS | 0.999412 |
# 题目
汉诺塔问题，条件如下：
1、这里有 A、B、C 和 D 四座塔。
2、这里有 n 个圆盘，n 的数量是恒定的。
3、每个圆盘的尺寸都不相同。
4、所有的圆盘在开始时都堆叠在塔 A 上，且圆盘尺寸从塔顶到塔底逐渐增大。
5、我们需要将所有的圆盘都从塔 A 转移到塔 D 上。
6、每次可以移动一个圆盘，当塔为空塔或者塔顶圆盘尺寸大于被移动圆盘时，可将圆盘移至这座塔上。
请你求出将所有圆盘从塔 A 移动到塔 D，所需的最小移动次数是多少。
就是字符表示的就是自己，引号和斜杠均无需\进行转义，这在需要输出很多引号和斜杠代码中很方便。
//原始字符串是C++11新增的一个功能，程序中使用R"(a string)"来标识原始字符串：
//原始字符串同时包含其它特点：
//1. 字符串中的换行符将在屏幕上如实显示。
//2. 在表示字符串开头的"和(之间可以添加其它字符，不过必须在表示字符串结尾的)和"之间添加同样的字符。
string path = "C:\Program File... | __label__POS | 0.9999 |
# 题目
数字以 0123456789101112131415… 的格式序列化到一个字符序列中。
在这个序列中，第 5 位（从 0 开始计数）是 5，第 13 位是 1，第 19 位是 4，等等。
请写一个函数求任意位对应的数字。
样例
```
输入：13
输出：1
```
# 参考答案
```c++
class Solution {
public:
int digitAtIndex(int n) {
long long i = 1, s = 9, base = 1;//i表示是几位数，s表示位数共有多少个，base表示位数的起始值。
while(n > i * s) { //... | __label__POS | 0.999852 |
# 题目
给定一张 n 个点的带权无向图，点从 0∼n−1 标号，求起点 0 到终点 n−1 的最短 Hamilton 路径。
Hamilton 路径的定义是从 0 到 n−1 不重不漏地经过每个点恰好一次。
输入格式<br>
第一行输入整数 n。
接下来 n 行每行 n 个整数，其中第 i 行第 j 个整数表示点 i 到 j 的距离（记为 a[i,j]）。
对于任意的 x,y,z，数据保证 a[x,x]=0，a[x,y]=a[y,x] 并且 a[x,y]+a[y,z]≥a[x,z]。
输出格式<br>
输出一个整数，表示最短 Hamilton 路径的长度。
数据范围<br>
1≤n≤20<br>
0≤a[i,j]≤10... | __label__POS | 0.71892 |
# 题目
“飞行员兄弟”这个游戏，需要玩家顺利的打开一个拥有 16 个把手的冰箱。
已知每个把手可以处于以下两种状态之一：打开或关闭。
只有当所有把手都打开时，冰箱才会打开。
把手可以表示为一个 4×4 的矩阵，您可以改变任何一个位置 [i,j] 上把手的状态。
但是，这也会使得第 i 行和第 j 列上的所有把手的状态也随着改变。
请你求出打开冰箱所需的切换把手的次数最小值是多少。
输入格式<br>
输入一共包含四行，每行包含四个把手的初始状态。
符号 + 表示把手处于闭合状态，而符号 - 表示把手处于打开状态。
至少一个手柄的初始状态是关闭的。
输出格式<br>
第一行输出一个整数 N，表示所需的最小切换把手次数... | __label__POS | 0.976058 |
# 题目
输入一棵二叉树前序遍历和中序遍历的结果，请重建该二叉树。
注意:
二叉树中每个节点的值都互不相同；<br>
输入的前序遍历和中序遍历一定合法；
样例
```
给定：
前序遍历是：[3, 9, 20, 15, 7]
中序遍历是：[9, 3, 15, 20, 7]
返回：[3, 9, 20, null, null, 15, 7, null, null, null, null]
返回的二叉树如下所示：
3
/ \
9 20
/ \
15 7
```
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct T... | __label__POS | 1.00001 |
# 题目
请实现一个函数用来找出字符流中第一个只出现一次的字符。
例如，当从字符流中只读出前两个字符 go 时，第一个只出现一次的字符是 g。
当从该字符流中读出前六个字符 google 时，第一个只出现一次的字符是 l。
如果当前字符流没有存在出现一次的字符，返回 # 字符。
样例
```
输入："google"
输出："ggg#ll"
```
解释：每当字符流读入一个字符，就进行一次判断并输出当前的第一个只出现一次的字符。
# 参考答案
```c++
unordered_map<char,int>count;
queue<char> q;
//Insert one char from stringstream
void... | __label__POS | 0.912109 |
# 题目
分形，具有以非整数维形式充填空间的形态特征。
通常被定义为“一个粗糙或零碎的几何形状，可以分成数个部分，且每一部分都（至少近似地）是整体缩小后的形状”，即具有自相似的性质。
现在，定义“盒子分形”如下：
一级盒子分形：
```
X
```
二级盒子分形：
```
X X
X
X X
```
如果用 B(n−1) 代表第 n−1 级盒子分形，那么第 n 级盒子分形即为：
```
B(n - 1) B(n - 1)
B(n - 1)
B(n - 1) B(n - 1)
```
你的任务是绘制一个 n 级的盒子分形。
输入格式... | __label__POS | 0.997666 |
# 题目
有 N 头牛站成一行，被编队为 1、2、3…N，每头牛的身高都为整数。
当且仅当两头牛中间的牛身高都比它们矮时，两头牛方可看到对方。
现在，我们只知道其中最高的牛是第 P 头，它的身高是 H ，剩余牛的身高未知。
但是，我们还知道这群牛之中存在着 M 对关系，每对关系都指明了某两头牛 A 和 B 可以相互看见。
求每头牛的身高的最大可能值是多少。
输入格式<br>
第一行输入整数 N,P,H,M，数据用空格隔开。
接下来 M 行，每行输出两个整数 A 和 B ，代表牛 A 和牛 B 可以相互看见，数据用空格隔开。
输出格式<br>
一共输出 N 行数据，每行输出一个整数。
第 i 行输出的整数代表第 i 头... | __label__POS | 0.999827 |
# 题目
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 v<sub>i</sub>，价值是 w<sub>i</sub>。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出 最优选法的方案数。注意答案可能很大，请输出答案模 10<sup>9</sup>+7 的结果。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 v<sub>i</sub>,w<sub>i</sub>，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一个整数，表示 方案数 模 10<sup>9</sup>... | __label__POS | 0.999762 |
# 题目
给定一个树，树上的边都具有权值。
树中一条路径的异或长度被定义为路径上所有边的权值的异或和：
⊕ 为异或符号。
给定上述的具有 n 个节点的树，你能找到异或长度最大的路径吗？
输入格式<br>
第一行包含整数 n，表示树的节点数目。
接下来 n−1 行，每行包括三个整数 u，v，w，表示节点 u 和节点 v 之间有一条边权重为 w。
输出格式<br>
输出一个整数，表示异或长度最大的路径的... | __label__POS | 0.895871 |
# 题目
很久很久以前，森林里住着一群兔子。
有一天，兔子们想要研究自己的 DNA 序列。
我们首先选取一个好长好长的 DNA 序列（小兔子是外星生物，DNA 序列可能包含 26 个小写英文字母）。
然后我们每次选择两个区间，询问如果用两个区间里的 DNA 序列分别生产出来两只兔子，这两个兔子是否一模一样。
注意两个兔子一模一样只可能是他们的 DNA 序列一模一样。
输入格式
第一行输入一个 DNA 字符串 S。
第二行一个数字 m，表示 m 次询问。
接下来 m 行，每行四个数字 l<sub>1<sub>,r<sub>1<sub>,l<sub>2<sub>,r<sub>2<sub>，分别表示此次询问的两个区间，注意字... | __label__POS | 0.991361 |
# 题目
输入一棵二叉树的根结点，判断该树是不是平衡二叉树。
如果某二叉树中任意结点的左右子树的深度相差不超过 1，那么它就是一棵平衡二叉树。
注意：
规定空树也是一棵平衡二叉树。
样例
```
输入：二叉树[5,7,11,null,null,12,9,null,null,null,null]如下所示，
5
/ \
7 11
/ \
12 9
输出：true
```
# 参考答案
``c++
class Solution {
public:
bool isBalanced(TreeNode* root) {
/*
unit test
... | __label__POS | 1.00001 |
# 题目
给定 m 个序列，每个包含 n 个非负整数。
现在我们可以从每个序列中选择一个数字以形成具有 m 个整数的序列。
很明显，我们一共可以得到 n<sup>m</sup>个这种序列，然后我们可以计算每个序列中的数字之和，并得到 n<sup>m</sup> 个值。
现在请你求出这些序列和之中最小的 n 个值。
输入格式<br>
第一行输入一个整数 T，代表输入中包含测试用例的数量。
接下来输入 T 组测试用例。
对于每组测试用例，第一行输入两个整数 m 和 n。
接下在 m 行输入 m 个整数序列，数列中的整数均不超过 10000。
输出格式<br>
对于每组测试用例，均以递增顺序输出最小的 n 个序列和，数值之... | __label__POS | 0.998413 |
# 题目
如果一个字符串正着读和倒着读是一样的，则称它是回文的。
给定一个长度为 N 的字符串 S，求他的最长回文子串的长度是多少。
输入格式<br>
输入将包含最多 30 个测试用例，每个测试用例占一行，以最多 1000000 个小写字符的形式给出。
输入以一个以字符串 END 开头的行表示输入终止。
输出格式<br>
对于输入中的每个测试用例，输出测试用例编号和最大回文子串的长度（参考样例格式）。
每个输出占一行。
输入样例：
```
abcbabcbabcba
abacacbaaaab
END
```
输出样例：
```
Case 1: 13
Case 2: 6
```
# 参考答案
```c++
#include... | __label__POS | 0.984907 |
# 题目
假设海岸是一条无限长的直线，陆地位于海岸的一侧，海洋位于另外一侧。
每个小岛都位于海洋一侧的某个点上。
雷达装置均位于海岸线上，且雷达的监测范围为 d，当小岛与某雷达的距离不超过 d 时，该小岛可以被雷达覆盖。
我们使用笛卡尔坐标系，定义海岸线为 x 轴，海的一侧在 x 轴上方，陆地一侧在 x 轴下方。
现在给出每个小岛的具体坐标以及雷达的检测范围，请你求出能够使所有小岛都被雷达覆盖所需的最小雷达数目。
输入格式<br>
第一行输入两个整数 n 和 d，分别代表小岛数目和雷达检测范围。
接下来 n 行，每行输入两个整数，分别代表小岛的 x，y 轴坐标。
同一行数据之间用空格隔开。
输出格式<br>
输出一个... | __label__POS | 0.997233 |
# 题目
这里有 n 列火车将要进站再出站，但是，每列火车只有 1 节，那就是车头。
这 n 列火车按 1 到 n 的顺序从东方左转进站，这个车站是南北方向的，它虽然无限长，只可惜是一个死胡同，而且站台只有一条股道，火车只能倒着从西方出去，而且每列火车必须进站，先进后出。
也就是说这个火车站其实就相当于一个栈，每次可以让右侧头火车进栈，或者让栈顶火车出站。
车站示意如图：
```
出站<—— <——进站
|车|
|站|
|__|
```
现在请你按《字典序》输出前 20 种... | __label__POS | 0.999213 |
# 题目
有 N 件物品和一个容量是 V 的背包。每件物品只能使用一次。
第 i 件物品的体积是 v<sub>i</sub>，价值是 w<sub>i</sub>。
求解将哪些物品装入背包，可使这些物品的总体积不超过背包容量，且总价值最大。
输出 字典序最小的方案。这里的字典序是指：所选物品的编号所构成的序列。物品的编号范围是 1…N。
输入格式
第一行两个整数，N，V，用空格隔开，分别表示物品数量和背包容积。
接下来有 N 行，每行两个整数 v<sub>i</sub>,w<sub>i</sub>，用空格隔开，分别表示第 i 件物品的体积和价值。
输出格式
输出一行，包含若干个用空格隔开的整数，表示最优解中所选物品的编号序... | __label__POS | 0.999338 |
# 题目
请实现一个函数用来判断字符串是否表示数值（包括整数和小数）。
例如，字符串"+100","5e2","-123","3.1416"和"-1E-16"都表示数值。
但是"12e","1a3.14","1.2.3","+-5"和"12e+4.3"都不是。
注意:
* 小数可以没有整数部分，例如.123等于0.123；
* 小数点后面可以没有数字，例如233.等于233.0；
* 小数点前面和后面可以有数字，例如233.666;
* 当e或E前面没有数字时，整个字符串不能表示数字，例如.e1、e1；
* 当e或E后面没有整数时，整个字符串不能表示数字，例如12e、12e+5.4;
样例：
```
输入: "0"
输出... | __label__POS | 0.999985 |
# 题目
给定一个长度为 n 的数列 a<sub>1</sub>,a<sub>2</sub>,…,a<sub>n</sub>，每次可以选择一个区间 [l,r]，使下标在这个区间内的数都加一或者都减一。
求至少需要多少次操作才能使数列中的所有数都一样，并求出在保证最少次数的前提下，最终得到的数列可能有多少种。
输入格式<br>
第一行输入正整数 n。
接下来 n 行，每行输入一个整数，第 i+1 行的整数代表 a<sub>i</sub>。
输出格式<br>
第一行输出最少操作次数。
第二行输出最终能得到多少种结果。
数据范围<br>
0<n≤10<sup>5</sup>,<br>
0≤a<sub>i</sub><21474... | __label__POS | 0.997928 |
# 题目
假设现在有两个自然数 A 和 B，S 是 A<sup>B</sup> 的所有约数之和。
请你求出 S mod 9901 的值是多少。
输入格式<br>
在一行中输入用空格隔开的两个整数 A 和 B。
输出格式<br>
输出一个整数，代表 Smod 9901 的值。
数据范围<br>
0≤A,B≤5×10<sup>7</sup>
输入样例：
```
2 3
```
输出样例：
```
15
```
注意: A 和 B 不会同时为 0。
# 参考答案
```c++
#include<iostream>
#include<unordered_map>
using namespace std;
typedef long ... | __label__POS | 0.999445 |
# 题目
请设计一个函数，用来判断在一个矩阵中是否存在一条包含某字符串所有字符的路径。
路径可以从矩阵中的任意一个格子开始，每一步可以在矩阵中向左，向右，向上，向下移动一个格子。
如果一条路径经过了矩阵中的某一个格子，则之后不能再次进入这个格子。
注意：
输入的路径不为空；<br>
所有出现的字符均为大写英文字母；<br>
样例
```
matrix=
[
["A","B","C","E"],
["S","F","C","S"],
["A","D","E","E"]
]
str="BCCE" , return "true"
str="ASAE" , return "false"
```
# 参考答案
``... | __label__POS | 0.999828 |
# 题目
输入一组数字（可能包含重复数字），输出其所有的排列方式。
样例
```
输入：[1,2,3]
输出：
[
[1,2,3],
[1,3,2],
[2,1,3],
[2,3,1],
[3,1,2],
[3,2,1]
]
```
# 参考答案
```c++
class Solution {
public:
vector<bool> st;
vector<int> path;
vector<vector<int>> ans;
vector<vector<int>> permu... | __label__POS | 0.999988 |
# 题目
达达学习数学竞赛的时候受尽了同仁们的鄙视，终于有一天......受尽屈辱的达达黑化成为了黑暗英雄怪兽达达。
就如同中二漫画的情节一样，怪兽达达打算毁掉这个世界。
数学竞赛界的精英 lqr 打算阻止怪兽达达的阴谋，于是她集合了一支由数学竞赛选手组成的超级行动队。
由于队员们个个都智商超群，很快，行动队便来到了怪兽达达的黑暗城堡的下方。
但是，同样强大的怪兽达达在城堡周围布置了一条“不可越过”的坚固防线。
防线由很多防具组成，这些防具分成了 N 组。
我们可以认为防线是一维的，那么每一组防具都分布在防线的某一段上，并且同一组防具是等距离排列的。
也就是说，我们可以用三个整数 S， E 和 D 来描述一组防具，即这... | __label__POS | 0.999549 |
# 题目
一个字符串的前缀是从第一个字符开始的连续若干个字符，例如 abaab 共有 5 个前缀，分别是 a，ab，aba，abaa，abaab。
我们希望知道一个 N 位字符串 S 的前缀是否具有循环节。
换言之，对于每一个从头开始的长度为 i（i>1）的前缀，是否由重复出现的子串 A 组成，即 AAA…A （A 重复出现 K 次,K>1）。
如果存在，请找出最短的循环节对应的 K 值（也就是这个前缀串的所有可能重复节中，最大的 K 值）。
输入格式<br>
输入包括多组测试数据，每组测试数据包括两行。
第一行输入字符串 S 的长度 N。
第二行输入字符串 S。
输入数据以只包括一个 0 的行作为结尾。
输出格式<... | __label__POS | 0.963325 |
# 题目
请实现两个函数，分别用来序列化和反序列化二叉树。
您需要确保二叉树可以序列化为字符串，并且可以将此字符串反序列化为原始树结构。
样例
```
你可以序列化如下的二叉树
8
/ \
12 2
/ \
6 4
为："[8, 12, 2, null, null, 6, 4, null, null, null, null]"
```
注意:
* 以上的格式是AcWing序列化二叉树的方式，你不必一定按照此格式，所以可以设计出一些新的构造方式。
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct TreeN... | __label__POS | 1.000009 |
# 题目
蛐蛐国最近蚯蚓成灾了！
隔壁跳蚤国的跳蚤也拿蚯蚓们没办法，蛐蛐国王只好去请神刀手来帮他们消灭蚯蚓。
蛐蛐国里现在共有 n 只蚯蚓，第 i 只蚯蚓的长度为 a<sub>i</sub> ，所有蚯蚓的长度都是非负整数，即可能存在长度为 0 的蚯蚓。
每一秒，神刀手会在所有的蚯蚓中，准确地找到最长的那一只，将其切成两段。
若有多只最长的，则任选一只。
神刀手切开蚯蚓的位置由有理数 p 决定。
一只长度为 x 的蚯蚓会被切成两只长度分别为 ⌊px⌋ 和 x−⌊px⌋ 的蚯蚓。
特殊地，如果这两个数的其中一个等于 0，则这个长度为 0 的蚯蚓也会被保留。
此外，除了刚刚产生的两只新蚯蚓，其余蚯蚓的长度都会增加一个非负整... | __label__POS | 0.988495 |
# 题目
给定一个整数 M，对于任意一个整数集合 S，定义“校验值”如下:
从集合 S 中取出 M 对数(即 2×M 个数，不能重复使用集合中的数，如果 S 中的整数不够 M 对，则取到不能取为止)，使得“每对数的差的平方”之和最大，这个最大值就称为集合 S 的“校验值”。
现在给定一个长度为 N 的数列 A 以及一个整数 T。
我们要把 A 分成若干段，使得每一段的“校验值”都不超过 T。
求最少需要分成几段。
输入格式<br>
第一行输入整数 K，代表有 K 组测试数据。
对于每组测试数据，第一行包含三个整数 N,M,T 。
第二行包含 N 个整数，表示数列A<sub>1</sub>,A<sub>2</sub>…A... | __label__POS | 0.999472 |
# 题目
将一个骰子投掷 n 次，获得的总点数为 s，s 的可能范围为 n∼6n。
掷出某一点数，可能有多种掷法，例如投掷 2 次，掷出 3 点，共有 [1,2],[2,1] 两种掷法。
请求出投掷 n 次，掷出 n∼6n 点分别有多少种掷法。
样例1
```
输入：n=1
输出：[1, 1, 1, 1, 1, 1]
解释：投掷1次，可能出现的点数为1-6，共计6种。每种点数都只有1种掷法。所以输出[1, 1, 1, 1, 1, 1]。
```
样例2
```
输入：n=2
输出：[1, 2, 3, 4, 5, 6, 5, 4, 3, 2, 1]
解释：投掷2次，可能出现的点数为2-12，共计11种。每种点数可能掷法数... | __label__POS | 1.00001 |
# 题目
如何得到一个数据流中的中位数？
如果从数据流中读出奇数个数值，那么中位数就是所有数值排序之后位于中间的数值。
如果从数据流中读出偶数个数值，那么中位数就是所有数值排序之后中间两个数的平均值。
样例
```
输入：1, 2, 3, 4
输出：1,1.5,2,2.5
解释：每当数据流读入一个数据，就进行一次判断并输出当前的中位数。
```
# 参考答案
```c++
class Solution {
private PriorityQueue<Integer> maxHeap=new PriorityQueue(new Comparator<Integer>(){
public int co... | __label__POS | 1.00001 |
# 题目
依次读入一个整数序列，每当已经读入的整数个数为奇数时，输出已读入的整数构成的序列的中位数。
输入格式<br>
第一行输入一个整数 P，代表后面数据集的个数，接下来若干行输入各个数据集。
每个数据集的第一行首先输入一个代表数据集的编号的整数。
然后输入一个整数 M，代表数据集中包含数据的个数，M 一定为奇数，数据之间用空格隔开。
数据集的剩余行由数据集的数据构成，每行包含 10 个数据，最后一行数据量可能少于 10 个，数据之间用空格隔开。
输出格式<br>
对于每个数据集，第一行输出两个整数，分别代表数据集的编号以及输出中位数的个数（应为数据个数加一的二分之一），数据之间用空格隔开。
数据集的剩余行由输出的中位... | __label__POS | 0.949499 |
# 题目
在这个问题中，您必须分析特定的排序算法----超快速排序。
该算法通过交换两个相邻的序列元素来处理 n 个不同整数的序列，直到序列按升序排序。
对于输入序列 9 1 0 5 4，超快速排序生成输出 0 1 4 5 9。
您的任务是确定超快速排序需要执行多少交换操作才能对给定的输入序列进行排序。
输入格式
输入包括一些测试用例。
每个测试用例的第一行输入整数 n，代表该用例中输入序列的长度。
接下来 n 行每行输入一个整数 a<sub>i</sub>,代表用例中输入序列的具体数据，第 i 行的数据代表序列中第 i 个数。
当输入用例中包含的输入序列长度为 0 时，输入终止，该序列无需处理。
输出格式
对于每个... | __label__POS | 0.993047 |
# 题目
一列火车 n 节车厢，依次编号为 1,2,3,…,n。
每节车厢有两种运动方式，进栈与出栈，问 n 节车厢出栈的可能排列方式有多少种。
输入格式<br>
输入一个整数 n，代表火车的车厢数。
输出格式<br>
输出一个整数 s 表示 n 节车厢出栈的可能排列方式数量。
数据范围<br>
1≤n≤60000
输入样例：
```
3
```
输出样例：
```
5
```
# 参考答案
```c++
#include <stdio.h>
const int N = 11311;
const int base = 1e9; // 压 9 位
const int basebit = 9;
int n;
int su... | __label__POS | 0.939499 |
# 题目
把 1∼n 这 n 个整数排成一行后随机打乱顺序，输出所有可能的次序。
输入格式<br>
一个整数 n。
输出格式<br>
按照从小到大的顺序输出所有方案，每行 1 个。
首先，同一行相邻两个数用一个空格隔开。
其次，对于两个不同的行，对应下标的数一一比较，字典序较小的排在前面。
数据范围<br>
1≤n≤9
输入样例：
```
3
```
输出样例：
```
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
```
# 参考答案
```c++
#include<iostream>
using namespace std;
const int N = 10;
int path[N];//保... | __label__POS | 1.000005 |
# 题目
给定一棵二叉树的其中一个节点，请找出中序遍历序列的下一个节点。
注意：
* 如果给定的节点是中序遍历序列的最后一个，则返回空节点;
* 二叉树一定不为空，且给定的节点一定不是空节点；
样例
```
假定二叉树是：[2, 1, 3, null, null, null, null]， 给出的是值等于2的节点。
则应返回值等于3的节点。
解释：该二叉树的结构如下，2的后继节点是3。
2
/ \
1 3
```
# 参考答案
```c++
/**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* Tr... | __label__POS | 1.00001 |
# 题目
请用栈实现一个队列，支持如下四种操作：
* push(x) – 将元素x插到队尾；
* pop() – 将队首的元素弹出，并返回该元素；
* peek() – 返回队首元素；
* empty() – 返回队列是否为空；
注意：
* 你只能使用栈的标准操作：push to top，peek/pop from top, size 和 is empty；
* 如果你选择的编程语言没有栈的标准库，你可以使用list或者deque等模拟栈的操作；
* 输入数据保证合法，例如，在队列为空时，不会进行pop或者peek等操作；
样例
```
MyQueue queue = new MyQueue();
queue.push(1... | __label__POS | 0.998887 |
# 题目
给定一个长度为 n 的序列 A，A 中的数各不相同。
对于 A 中的每一个数 A<sub>i</sub>，求：
min<sub>1≤j<i</sub>|A<sub>i</sub>−A<sub>j</sub>|
以及令上式取到最小值的 j（记为 P<sub>i</sub>）。若最小值点不唯一，则选择使 A<sub>j</sub> 较小的那个。
输入格式
第一行输入整数 n，代表序列长度。
第二行输入 n 个整数A<sub>1</sub>…A<sub>n</sub>,代表序列的具体数值，数值之间用空格隔开。
输出格式
输出共 n−1 行，每行输出两个整数，数值之间用空格隔开。
分别表示当 i 取 2∼n 时，对应的... | __label__POS | 0.99947 |
# 题目
在与联盟的战斗中屡战屡败后，帝国撤退到了最后一个据点。
依靠其强大的防御系统，帝国击退了联盟的六波猛烈进攻。
经过几天的苦思冥想，联盟将军亚瑟终于注意到帝国防御系统唯一的弱点就是能源供应。
该系统由 N 个核电站供应能源，其中任何一个被摧毁都会使防御系统失效。
将军派出了 N 个特工进入据点之中，打算对能源站展开一次突袭。
不幸的是，由于受到了帝国空军的袭击，他们未能降落在预期位置。
作为一名经验丰富的将军，亚瑟很快意识到他需要重新安排突袭计划。
他现在最想知道的事情就是哪个特工距离其中任意一个发电站的距离最短。
你能帮他算出来这最短的距离是多少吗？
输入格式<br>
输入中包含多组测试用例。
第一行输... | __label__POS | 0.996938 |
# 题目
给定一个包含整数的二维矩阵，子矩形是位于整个阵列内的任何大小为 1×1 或更大的连续子阵列。
矩形的总和是该矩形中所有元素的总和。
在这个问题中，具有最大和的子矩形被称为最大子矩形。
例如，下列数组：
```
0 -2 -7 0
9 2 -6 2
-4 1 -4 1
-1 8 0 -2
```
其最大子矩形为：
```
9 2
-4 1
-1 8
```
它拥有最大和 15。
输入格式<br>
输入中将包含一个 N×N 的整数数组。
第一行只输入一个整数 N，表示方形二维数组的大小。
从第二行开始，输入由空格和换行符隔开的 N<sup>2</sup> 个整数，它们即为二维数组中的 N<sup>2<... | __label__POS | 0.99914 |
# 题目
地上有一个 m 行和 n 列的方格，横纵坐标范围分别是 0∼m−1 和 0∼n−1。
一个机器人从坐标 (0,0) 的格子开始移动，每一次只能向左，右，上，下四个方向移动一格。
但是不能进入行坐标和列坐标的数位之和大于 k 的格子。
请问该机器人能够达到多少个格子？
样例1
```
输入：k=7, m=4, n=5
输出：20
```
样例2
```
输入：k=18, m=40, n=40
输出：1484
解释：当k为18时，机器人能够进入方格（35,37），因为3+5+3+7 = 18。
但是，它不能进入方格（35,38），因为3+5+3+8 = 19。
```
注意:
1、0<=m<=50<... | __label__POS | 1.000002 |
# 题目
给定一个链表，若其中包含环，则输出环的入口节点。
若其中不包含环，则输出null。
样例
```
给定如上所示的链表：
[1, 2, 3, 4, 5, 6]
2
注意，这里的2表示编号是2的节点，节点编号从0开始。所以编号是2的节点就是val等于3的节点。
则输出环的入口节点3.
```
# 参考答案
```c++
/**
* Definition for singly-linked lis... | __label__POS | 1.00001 |
# 题目
七夕节因牛郎织女的传说而被扣上了「情人节」的帽子。
于是 TYVJ 今年举办了一次线下七夕祭。
Vani 同学今年成功邀请到了 cl 同学陪他来共度七夕，于是他们决定去 TYVJ 七夕祭游玩。
TYVJ 七夕祭和 11 区的夏祭的形式很像。
矩形的祭典会场由 N 排 M 列共计 N×M 个摊点组成。
虽然摊点种类繁多，不过 cl 只对其中的一部分摊点感兴趣，比如章鱼烧、苹果糖、棉花糖、射的屋……什么的。
Vani 预先联系了七夕祭的负责人 zhq，希望能够通过恰当地布置会场，使得各行中 cl 感兴趣的摊点数一样多，并且各列中 cl 感兴趣的摊点数也一样多。
不过 zhq 告诉 Vani，摊点已经随意布置完毕了... | __label__POS | 0.998715 |
# 题目
有 N 个物品和一个容量是 V 的背包。
物品之间具有依赖关系，且依赖关系组成一棵树的形状。如果选择一个物品，则必须选择它的父节点。
如下图所示：
如果选择物品5，则必须选择物品1和2。这是因为2是5的父节点，1是2的父节点。
每件物品的编号是 i，体积是 v<sub>i</sub>，价值是 w<sub>i</sub>，依赖的父节点编号是 p<sub>i</sub... | __label__POS | 1.000006 |
# 题目
输入一个整数 n，求从 1 到 n 这 n 个整数的十进制表示中 1 出现的次数。
例如输入 12，从 1 到 12 这些整数中包含 “1” 的数字有 1，10，11 和 12，其中 “1” 一共出现了 5 次。
样例
```
输入： 12
输出： 5
```
# 参考答案
```c++
class Solution {
public:
int numberOf1Between1AndN_Solution(int n) {
int count = 0;
for (int i = 1; i <= n; i *= 10) {
int a = n / i,b =... | __label__POS | 1.000009 |
# 1.线程和进程区别
### 一、关于进程和线程，首先从定义上理解就有所不同<br>
1、进程是什么？<br>
是具有一定独立功能的程序、它是系统进行资源分配和调度的一个独立单位，重点在系统调度和单独的单位，也就是说进程是可以独立运行的一段程序。<br>
2、线程又是什么？<br>
线程进程的一个实体，是CPU调度和分派的基本单位，他是比进程更小的能独立运行的基本单位，线程自己基本上不拥有系统资源。<br>
在运行时，只是暂用一些计数器、寄存器和栈 。<br>
### 二、他们之间的关系<br>
1、一个线程只能属于一个进程，而一个进程可以有多个线程，但至少有一... | __label__POS | 0.696491 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class M68k_const {
public static final int M68K_OPERAND_COUNT = 4;
public static final int M68K_REG_INVALID = 0;
public static final int M68K_REG_D0 = 1;
public static final int M68K_REG_D1 = 2;
public static final int M68K_REG_D2 ... | __label__POS | 1.000009 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class Arm_const {
public static final int ARM_SFT_INVALID = 0;
public static final int ARM_SFT_ASR = 1;
public static final int ARM_SFT_LSL = 2;
public static final int ARM_SFT_LSR = 3;
public static final int ARM_SFT_ROR = 4;
pub... | __label__POS | 1.000009 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class Arm64_const {
public static final int ARM64_SFT_INVALID = 0;
public static final int ARM64_SFT_LSL = 1;
public static final int ARM64_SFT_MSL = 2;
public static final int ARM64_SFT_LSR = 3;
public static final int ARM64_SFT_A... | __label__POS | 1.000009 |
// Capstone Java binding
// By Nguyen Anh Quynh & Dang Hoang Vu, 2013
package capstone;
import com.sun.jna.Structure;
import com.sun.jna.Union;
import java.util.List;
import java.util.Arrays;
import static capstone.Arm_const.*;
public class Arm {
public static class MemType extends Structure {
public int b... | __label__POS | 0.982631 |
# 题目
格雷编码是一个二进制数字系统，在该系统中，两个连续的数值仅有一个位数的差异。
给定一个代表编码总位数的非负整数 n，打印其格雷编码序列。即使有多个不同答案，你也只需要返回其中一种。
格雷编码序列必须以 0 开头。
示例 1:
输入: 2
输出: [0,1,3,2]
解释:
00 - 0
01 - 1
11 - 3
10 - 2
对于给定的 n，其格雷编码序列并不唯一。
例如，[0,2,3,1] 也是一个有效的格雷编码序列。
00 - 0
10 - 2
11 - 3
01 - 1
示例 2:
输入: ... | __label__POS | 1.00001 |
// Capstone Java binding
// By Nguyen Anh Quynh & Dang Hoang Vu, 2013
package capstone;
import com.sun.jna.Structure;
import com.sun.jna.Union;
import java.util.List;
import java.util.Arrays;
import static capstone.X86_const.*;
public class X86 {
public static class MemType extends Structure {
public int s... | __label__POS | 0.842272 |
// For Capstone Engine. AUTO-GENERATED FILE, DO NOT EDIT
package capstone;
public class Evm_const {
public static final int EVM_INS_STOP = 0;
public static final int EVM_INS_ADD = 1;
public static final int EVM_INS_MUL = 2;
public static final int EVM_INS_SUB = 3;
public static final int EVM_INS_DIV = 4;
public... | __label__POS | 1.000009 |
// Capstone Java binding
// By Nguyen Anh Quynh & Dang Hoang Vu, 2013
package capstone;
import com.sun.jna.Structure;
import com.sun.jna.Union;
import java.util.List;
import java.util.Arrays;
import static capstone.Mips_const.*;
public class Mips {
public static class MemType extends Structure {
public int... | __label__POS | 0.997453 |
# 题目
在一条环路上有 N 个加油站，其中第 i 个加油站有汽油 gas[i] 升。
你有一辆油箱容量无限的的汽车，从第 i 个加油站开往第 i+1 个加油站需要消耗汽油 cost[i] 升。你从其中的一个加油站出发，开始时油箱为空。
如果你可以绕环路行驶一周，则返回出发时加油站的编号，否则返回 -1。
说明:
* 如果题目有解，该答案即为唯一答案。
* 输入数组均为非空数组，且长度相同。
* 输入数组中的元素均为非负数。
示例 1:
输入:
gas = [1,2,3,4,5]
cost = [3,4,5,1,2]
输出: 3
解释:
从 3 号加油站(索引为 3... | __label__POS | 1 |
# 题目
请你设计一个数据结构，支持 添加新单词 和 查找字符串是否与任何先前添加的字符串匹配 。
实现词典类 WordDictionary ：
* WordDictionary() 初始化词典对象
* void addWord(word) 将 word 添加到数据结构中，之后可以对它进行匹配
* bool search(word) 如果数据结构中存在字符串与 word 匹配，则返回 true ；否则，返回 false 。word 中可能包含一些 '.' ，每个 . 都可以表示任何一个字母。
示例：
输入：
["WordDictionary","addWord","addWord","addWord",... | __label__POS | 0.999258 |
# 题目
给你一个未排序的整数数组 nums ，请你找出其中没有出现的最小的正整数。
请你实现时间复杂度为 O(n) 并且只使用常数级别额外空间的解决方案。
示例 1：
输入：nums = [1,2,0]
输出：3
示例 2：
输入：nums = [3,4,-1,1]
输出：2
示例 3：
输入：nums = [7,8,9,11,12]
输出：1
提示：
1 <= nums.length <= 5 * 10<sup>5</sup>
-2<sup>31</sup> <= nums[i] <= 2<sup>31</sup> - 1
# 参考答案
```c++
clas... | __label__POS | 1.00001 |
# 题目
使用下面描述的算法可以扰乱字符串 s 得到字符串 t ：<br>
1.如果字符串的长度为 1 ，算法停止<br>
2.如果字符串的长度 > 1 ，执行下述步骤：<br>
* 在一个随机下标处将字符串分割成两个非空的子字符串。即，如果已知字符串 s ，则可以将其分成两个子字符串 x 和 y ，且满足 s = x + y 。
* 随机 决定是要「交换两个子字符串」还是要「保持这两个子字符串的顺序不变」。即，在执行这一步骤之后，s 可能是 s = x + y 或者 s = y + x 。
* 在 x 和 y 这两个子字符串上继续从步骤 1 开始递归执行此算法。
给你两个 长度相等 的字符串 s1 和 s2，判断 s2 是否是 s... | __label__POS | 0.999352 |
# 题目
给你一个 无重叠的 ，按照区间起始端点排序的区间列表。
在列表中插入一个新的区间，你需要确保列表中的区间仍然有序且不重叠（如果有必要的话，可以合并区间）。
示例 1：
输入：intervals = [[1,3],[6,9]], newInterval = [2,5]
输出：[[1,5],[6,9]]
示例 2：
输入：intervals = [[1,2],[3,5],[6,7],[8,10],[12,16]], newInterval = [4,8]
输出：[[1,2],[3,10],[12,16]]
解释：这是因为新的区间 [4,8] 与 [3,5],[6,7],[8,1... | __label__POS | 0.999992 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.