欢迎鸭~ 我的 B 站主页

sorry，B站账号正在迁移，打开会黑屏；

换一批

so？

[0 Format Error] 是什么意思？

题目标签

一阶段36数据的输入和输出21输出语句12数据的运算12输入输出8二阶段3translated3算术运算2单循环结构2字符数组2模拟2O2优化2implementation2strings2*12002多分支、嵌套分支结构1for循环1打擂台1一维数组1字符串1

状态

• 评测队列
• 服务状态

开发

• 开源
• API

支持

1.插入排序

思想：

把待排序的记录按其关键码值的大小逐个插入到一个已经排好序的有序序列中，直到所有的记录插入完为止，得到一个新的有序序列 。

实际中我们玩扑克牌时，就用了插入排序的思想：

演示过程动图：

**单趟：**若数组(arr)除最后一个元素外其余全部有序，设最后一个元素的下标为i，将arr[i]与前面的元素比较，前面的元素比他大则前面的元素向右移动，比他小则在该元素的后面插入。

**复合：**因为不知道数组中得到前几个元素是已经有序的，所以直接从第二个元素开始执行插入排序，单个过程与上述相同，将每个元素都进行一次插入排序。

代码如下：

// 插入排序
void InsertSort(int* a, int n)
{
	assert(a);
	int i = 0;
	for (i = 0; i < n - 1; i++)//因为x元素位置是i的下一个位置，为防止x越界，需要使 i < n-1
	{
		int end = i;//已经有序的最后一个元素(一个元素不需要排序，所以默认从0开始)
		int x = a[end + 1];//需要排序的元素

        //单趟
		while (end >= 0)
		{

            //若前一个数字大于x，则需将他向右移动
			if (a[end] > x)
			{
				a[end + 1] = a[end];
                //继续判断前面的元素
				--end;
			}

            //前面元素小于x
			else
			{
				break;
			}
		}

        //将x插入正确位置(两种情况)
        //1.前面的数字小于x
        //2.前面的数字都大于x，x放在下标为0处
		a[end + 1] = x;
	}
}

Copy

Copy

直接插入排序的特性总结：

1. 元素集合越接近有序，直接插入排序算法的时间效率越高
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)，它是一种稳定的排序算法
4. 稳定性：稳定

---

2.希尔排序

希尔排序法又称缩小增量法。

基本思想：

先选定一个整数gap，把待排序文件中所有记录分成gap个组，所有距离为gap的记录分在同一组内，并对每一组内的元素进行排序。

然后将gap逐渐减小重复上述分组和排序的工作。

当到达gap=1时，所有元素在统一组内排好序。

静态图演示：

**动图演示： **

这里重要的是理解分组思想，每一个组其实就是一个插入排序，相当于进行多次插入排序。

代码如下：

// 希尔排序
void ShellSort(int* a, int n)
{
	assert(a);
	int gap = n;
	while (gap > 1)
	{
		//gap /= 2;
		gap = gap / 3 + 1;
		for (int i = 0; i < n - gap; i++)
		{
			int end = i;
			int x = a[end + gap];
			while (end >= 0)
			{
				if (a[end] > x)
				{
					a[end + gap] = a[end];
					end -= gap;
				}
				else
				{
					break;
				}
			}
			a[end + gap] = x;
		}
	}
}

Copy

Copy

希尔排序的特性总结：

1. 希尔排序是对直接插入排序的优化。
2. 当gap > 1时都是预排序，目的是让数组更接近于有序。当gap == 1时，数组已经接近有序的了，这样就会很快。这样整体而言，可以达到优化的效果。
3. 希尔排序的时间复杂度不好计算，因为gap的取值方法很多，导致很难去计算，这里不深究。
4. 时间复杂度O(N^1.5)
5. 空间复杂度O(1)
6. 稳定性：不稳定。

---

3.选择排序

基本思想：

第一次从待排序的数据元素中选出最小（或最大）的一个元素，存放在序列的起始(末尾)位置，

然后选出次小(或次大)的一个元素，存放在最大(最小)元素的下一个位置，

重复这样的步骤直到全部待排序的数据元素排完 。

动图演示：

代码入下：

这里我们可以进行一个优化，最小值和最大值同时选，然后将最小值与起始位置交换，将最大值与末尾位置交换。

// 选择排序
void SelectSort(int* a, int n)
{
	assert(a);
	int begin = 0;//保存数组的起始位置
	int end = n - 1;//保存换数组的末尾位置

	while (begin < end)
	{
		int maxi = begin;//保存最大元素下标
		int mini = begin;//保存最小元素下标

        //遍历数组寻找最小和最大元素
		for (int i = begin; i <= end; i++)
		{
			if (a[i] < a[mini])
			{
				mini = i;
			}
			if (a[i] > a[maxi])
			{
				maxi = i;
			}
		}

        //将最小元素交换到起始位置
		Swap(a+begin, a+mini);

        //判断最大值的位置是否在起始位置
		if (maxi == begin)
		{
			maxi = mini;  
		}

        //将最大元素交换到末尾位置
		Swap(a+end, a+maxi);
        //移动数组起始和末尾位置
		begin++;
		end--;
	}
}

Copy

Copy

注意：

在进行最小值和最大值同时交换时也会出现一个问题，

如果最大值在起始位置的时候，交换了最小值之后，最大值就被交换到了min的位置，

如果继续交换max，就会将最小值交换到末尾位置。

所以，在每次交换了最小值之后应该判断一下最大值是否在起始位置，如果在需要将max赋值为min。

直接选择排序的特性总结：

1. 直接选择排序思考非常好理解，但是效率不是很好(不论数组是否有序都会执行原步骤)。实际中很少使用
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

---

4.堆排序

堆排序即利用堆的思想来进行排序，总共分为两个步骤：

1. 建堆

• 升序：建大堆
• 降序：建小堆

2. 利用堆删除思想来进行排序 建堆和堆删除中都用到了向下调整，因此掌握了向下调整，就可以完成堆排序。

这里以升序为例：

• 首先应该建一个大堆，不能直接使用堆来实现。可以将需要排序的数组看作是一个堆，但需要将数组结构变成堆。
• 我们可以从堆从下往上的第二行最右边开始依次向下调整直到调整到堆顶，这样就可以将数组调整成一个堆，且如果建立的是大堆，堆顶元素为最大值。
• 然后按照堆删的思想将堆顶和堆底的数据交换，但不同的是这里不删除最后一个元素。
• 这样最大元素就在最后一个位置，然后从堆顶向下调整到倒数第二个元素，这样次大的元素就在堆顶，重复上述步骤直到只剩堆顶时停止。

动图演示：

注意：实际中并没有删除堆中元素，图中为了方便表示，将交换后的位置画成了空。

代码如下：

// 堆排序
void AdjustDown(int* a, int n, int root)//向下调整
{
	assert(a);
	int parent = root;
	int child = parent * 2 + 1;
	while (child < n)
	{
		if (child + 1 < n && a[child + 1] > a[child])
		{
			child++;
		}
		if (a[child] > a[parent])
		{
			Swap(&a[child], &a[parent]);
			parent = child;
			child = parent * 2 + 1;
		}
		else
		{
			break;
		}
	}
}

void HeapSort(int* a, int n)
{
	assert(a);

    //建堆
	for (int i = (n - 1 - 1) / 2; i >= 0; i--)
	{
		AdjustDown(a, n, i);
	}

    //交换
	for (int i = n - 1; i > 0; i--)
	{
		Swap(&a[i], &a[0]);
		AdjustDown(a, i, 0);
	}
}

Copy

Copy

直接选择排序的特性总结：

1. 堆排序使用堆来选数，效率就高了很多。
2. 时间复杂度：O(N*logN)
3. 空间复杂度：O(1)
4. 稳定性：不稳定

---

5.冒泡排序

冒泡排序应该是我们最熟悉的排序了，在C语言阶段我们就学习了冒泡排序。

他的思想也非常简单：

两两元素相比，前一个比后一个大就交换，直到将最大的元素交换到末尾位置。这是第一趟

一共进行n-1趟这样的交换将可以把所有的元素排好。

(n-1趟是因为只剩两个元素时只需要一趟就可以完成)

动图演示：

代码如下：

// 冒泡排序
void BubbleSort(int* a, int n)
{
    assert(a);
	int i = 0;
	int flag = 0;

    //n-1趟排序
	for (i = 0; i < n-1; i++)
	{
		int j = 0;

        //一趟冒泡排序
		for (j = 0; j < n - i - 1; j++)
		{
			if (a[j] > a[j+1])
			{
				Swap(&a[j], &a[j+1]);
				flag = 1;
			}
		}

        //若某一趟排序中没有元素交换则说明所有元素已经有序，不需要再排序
		if (flag == 0)
		{
			break;
		}
	}
}

Copy

Copy

冒泡排序的特性总结：

1. 冒泡排序是一种非常容易理解的排序
2. 时间复杂度：O(N^2)
3. 空间复杂度：O(1)
4. 稳定性：稳定

---

6.快速排序

这里是排序算法的重点了，非常重要！

快速排序是Hoare于1962年提出的一种二叉树结构的交换排序方法，

其基本思想为：

任取待排序元素序列中的某元素作为基准值，按照该排序码将待排序集合分割成两子序列，左子序列中所有元素均小于基准值，右子序列中所有元素均大于基准值，然后最左右子序列重复该过程，直到所有元素都排列在相应位置上为止。

7.归并排序

7.1递归实现

基本思想：

归并排序（MERGE-SORT）是建立在归并操作上的一种有效的排序算法,该算法是采用分治法（Divide andConquer）的一个非常典型的应用。

将已有序的子序列合并，得到完全有序的序列；即先使每个子序列有序，再使子序列段间有序。

若将两个有序表合并成一个有序表，称为二路归并。

归并排序核心步骤：

按照其算法思想：

首先应在数组中找出有序的序列，但数组是否有序编译器可不知道。

所以可以将数组划分，一分二，二分四......直到每个序列中只有一个数字。

一个数字总可以认为他是有序的吧。

最后将同时划分的序列合并。

动图演示：

代码如下：

void _MergeSort(int* a, int left, int right,int* tmp)
{
    //区间中没有元素时不再合并
	if (left >= right)
	{
		return;
	}

    //划分数组，每次一分为二
	int mid = (left + right) / 2;
	_MergeSort(a, left, mid,tmp);//划分左区间
	_MergeSort(a, mid + 1, right,tmp);//划分右区间

    //合并有序序列
	int begin1 = left, end1 = mid;//有序序列1
	int begin2 = mid + 1, end2 = right;//有序序列2
	int i = left;
	while (begin1 <= end1 && begin2 <= end2)//注意结束条件为一个序列为空时就停止
	{
		if (a[begin1] < a[begin2])
		{
			tmp[i++] = a[begin1++];
		}
		else
		{
			tmp[i++] = a[begin2++];
		}
	}

    //两序列不可能同时为空，将剩余元素合并
	while (begin1 <= end1)
	{
		tmp[i++] = a[begin1++];
	}

	while (begin2 <= end2)
	{
		tmp[i++] = a[begin2++];
	}

    //将合并后的序列拷贝到原数组中
    //在这里拷贝的原因是 保证返回到上一层递归后两个子序列中的元素是有序的
	int j = 0;
	for (j = left; j <= right; j++)
	{
		a[j] = tmp[j];
	}
}

// 归并排序递归实现
void MergeSort(int* a, int n)
{
    assert(a);
    //因为需要将两个有序序列合并，需借助额外数组
	int* tmp = (int*)malloc(sizeof(int) * n);
	if (tmp == NULL)
	{
		perror("malloc");
		exit(-1);
	}

	_MergeSort(a, 0, n - 1,tmp);

	free(tmp);
	tmp = NULL;
}

Copy

Copy

8.计数排序(了解)

思想：计数排序又称为鸽巢原理，是对哈希直接定址法的变形应用。 操作步骤

1. 统计相同元素出现次数
2. 根据统计的结果将序列回收到原来的序列中

动图演示：

** 代码如下：**

// 计数排序
void CountSort(int* a, int n)
{
    assert(a);
    // 创建计数数组，数组大小为原数组中最大值-最小值+1
	int max = a[0], min = a[0];
	int i = 0;
	for (i = 0; i < n; i++)
	{
		if (a[i] > max)
		{
			max = a[i];
		}
		if (a[i] < min)
		{
			min = a[i];
		}
	}
	int range = max - min + 1;
	int* count = (int*)malloc(sizeof(int) * range);
    // 初始化计数数组为0
	memset(count, 0, range * 4);

	// 统计次数
	for (i = 0; i < n; i++)
	{
		count[a[i] - min]++;
	}
    // 根据次数，进行排序
	int j = 0;
	for (i = 0; i < range; i++)
	{
		while (count[i]--)
		{
			a[j++] = i+min;
		}
	}
    free(count);
    count = NULL;
}

Copy

Copy

注意：计数排序在排负数时，可将负数的类型转化成 unsigned int。

**数组中元素有正有负的情况时不适用计数排序。 **

计数排序的特性总结：

1. 计数排序在数据范围集中时，效率很高，但是适用范围及场景有限。
2. 时间复杂度：O(MAX(N,范围))
3. 空间复杂度：O(范围)
4. 稳定性：稳定

​感谢观看鸭​~ Waiting 评测：评测请求正在等待被评测机抓取 Fetched 评测：评测请求已被评测机抓取，正在准备开始评测 Compiling 评测：正在编译中 Judging 评测：编译成功，正在评测中 Accepted 通过：程序输出完全正确 Wrong Answer 不通过：程序输出与标准答案不一致（不包括行末空格以及文件末空行） Time Limit Exceeded 不通过：程序运行时间超过了题目限制 Memory Limit Exceeded 不通过：程序运行内存空间超过了题目限制 Runtime Error 不通过：程序运行时错误（如数组越界、被零除、运算溢出、栈溢出、无效指针等） Compile Error 不通过：编译失败 System Error 错误：系统错误（如果您遇到此问题，请及时在讨论区进行反馈） Canceled 其他：评测被取消 Unknown Error 其他：未知错误 Ignored 其他：被忽略 有“成绩取消”字样则说明管理员手动标记此记录为取消，可能违反了服务条款，比如代码被发现与其他用户的代码十分相似。

编译错误 可能有以下情况：

1. 递交时选错了编程语言
2. Java 的主类名没有使用 "Main"
3. 对于 C/C++：见下
4. 一般性的编译错误 对 C/C++ 选手的特别提醒：
5. __int64 在 GNU C++ 中应写成 long long 类型
6. main() 返回值必须定义为 int ，而不是 void
7. for 语句中的指标变量 i 将会在如"for (int i = 0...) {...}"语句之后变为无效
8. itoa 不是一个通用 ANSI 函数（标准 C/C++ 中无此函数）
9. printf 中使用 %lf 格式是不正确的

世界上最遥远的距离不是生与死，而是你亲手制造的BUG就在你眼前，你却怎么都找不到她。 AC=Answer Coarse=粗劣的答案

WA=Wonderful Answer=好答案

PC=Perfect Compile=完美的编译

RE=Run Excellently=完美运行

TLE=Time Limit Enough=时间充裕

MLE=Memory Limit Enough=内存充裕

OLE=Output Limit Enough=输出合法

CE=Compile Easily=轻松通过编译

UKE=Unbelievably Keep Enough Score=难以置信地保持足够的分数

AU=All Unaccepted=全都不正确

AC = Apareciym 显形咒

SE=smile end(有趣的结局)

CE=camping email(度假电子邮件)

AC=abc calculate(abc计算)

MLE=my lime error(我的柠檬出问题了)

CE=count exit (数数通道)

TLE=toe low exit(小碎步通道)

OLE=oh light e(哦，闪亮的电子屏)

PE=physical education(体育课)

WA=wow accepted(噢答案)

CE = Crucio 钻心咒 （CO 是 Colloportus 禁锢咒）

PE = Petrificus 石化咒

RE = Reducto 粉碎咒

WA = Wingardium Leviosa 悬浮咒

MLE = Muggle-Repelling 驱逐咒

TLE = Tarantollegra 舞步咒

OLE = Obliviate 遗忘咒

AC = Answer Coarse=粗劣的答案

WA = Wonderful Answer=好答案

TLE = Time Limit Enough=时间充裕

MLE = Memory Limit Enough=内存充裕

CE = Compile Easily=轻松通过编译

RE = Run Excellently=完美运行

AC = awful correct 正确但很差劲

WA = wonderful answer 完美的答案

RE = right ending 正确的结果

CE = compiled easily 轻松的编译

TLE = time limit enough 时间充裕

MLE = memory limit enough 空间充裕

OLE = output length excellent 答案长度完美

AK = all knocked-off 全部失败

RE = Right Ending 正确答案

AC = 访问控制器(access controller)

WA = 警告报警(warning alarm)

RE = 返回(Return 缩写)

CE = 计算引擎(compute engine)

TLE = 小型语言编辑器(tiny language editor)

MLE = 中型语言编辑器(medium language editor)

OLE = 超大型语言编辑器(oversized language editor)

AC = Answer Crap 废物答案

WA = Wow Answer! 令人震惊的答案

RE = Run Excellently 程序正常运行

CE = Compile Excellently 程序正常编译

TLE = Time Limit Enough 时间限制充足

MLE = Memory Limit Enough 内存限制充足

PE = Pull request Excellently 一个优秀的提交

按照赛制不同，有不同的递交、排名规则。

OI 赛制所有题目均以最后一次递交为准，特别地，请避免编译错误。

OI 赛制排名规则为：总分高的排在前面，总分相等则排名相同。

ACM/ICPC 赛制所有题目递交后立即评测，以是否通过为准。

ACM/ICPC 赛制排名规则为：通过题目数多的排在前面，通过题目数相同的做题耗时（含罚时）少的排在前。

乐多 赛制下，选手可以多次提交一道题目，并获得实时评测结果。

乐多 赛制下，多次提交会导致选手的得分被扣除，排行榜将显示用户的最高得分。

乐多 赛制下，每道题的最终得分为:s*max(0.95^n,0.7).s,n分别代表本次得分和本次提交前的尝试次数。

乐多 排名规则为：按照如上规则折算后的分数从高到低排名。

IOI(严格) 赛制下，不同于IOI赛制，排行榜将被关闭至比赛结束。

IOI(严格) 赛制下，每道题的排行榜得分将为用户每个子任务在所有提交中的最大得分的和。

时间与空间限制以题目说明为准，默认限制参见限制。

1. 递交时选错了编程语言
2. Java 的主类名没有使用 "Main"
3. 对于 C/C++：见下
4. 一般性的编译错误

对 C/C++ 选手的特别提醒：

1. __int64 在 GNU C++ 中应写成 long long 类型
2. main() 返回值必须定义为 int ，而不是 void
3. for 语句中的指标变量 i 将会在如"for (int i = 0...) {...}"语句之后变为无效
4. itoa 不是一个通用 ANSI 函数（标准 C/C++ 中无此函数）
5. printf 中使用 %lf 格式是不正确的

刷题是一种出路，枚举是一种思想

打表是一种勇气，搜索是一种信仰

剪枝是一种精神，骗分是一种日常

爆零是一种宿命，WA是一种绝望

TLE是一种痛苦，RE是一种放弃

UKE是一种无奈，AC是一种原谅

AK是一种幻想，弃赛是一种颓废

吊打是一种必然，进队是一种奢望

#模拟只会猜题意，贪心只能过样例

数学上来先打表，ＤＰ一般看规律

组合数学靠运气，计算几何瞎暴力

#图论强行套模板，数论只会ＧＣＤ

#递归递推伤不起，搜索茫然ＴＬＥ

分治做得像枚举，暴力枚举数第一

数据结构干瞪眼，怒刷水题找信心

涨姿势也不容易，考试一来全懵逼

暴力出奇迹，骗分过样例。

数学先打表，ＤＰ看运气。

穷举ＴＬＥ，递推ＵＫＥ。

模拟ＭＬＥ，贪心还ＣＥ。

#想要骗到分，就要有方法。

图论背模板，数论背公式。

动规背方程，高精背代码。

如果都没背，干脆输样例。

模拟定想全，动规定找对。

贪心定证明，二分LM+1。

宜考NOIP , 小心别爆零.] 骗分过样例，暴力出奇迹。

山重水复疑无路，make后面不加to。

秦时明月汉时关，高价氧化低价还。

君问归期未有期，点裂加倍匀两极。

酒酣胸胆尚开张，GM=gR方。

碧云天，黄叶地，高温高压催化剂。

横看成岭侧成峰，洛伦兹力不做功。

草树知春不久归，b方减去4ac。

瀚海阑干百丈冰，酸脱羟基醇脱氢

西江月·夜行OI道中 明月AC惊鹊，

RE半夜鸣蝉。

稻花香里说丰年，

听取WA声一片。

七八个TLE，

两三点MLE。

旧时茅店社林边，

路转CE忽见。

生命的意义?

如果26个英文字母

A,B,C,D,E,F,G,H,I,J,K,L,M,N,O,P,Q,R,S,T,U,V,W,X,Y,Z

分别等于

1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26

那么：

获得知识,Knowledge

=K+N+O+W+L+E+D+G+E

=11+14+15+23+12+5+4+7+5

=96%

努力工作，Workhard

=W+O+R+K+H+A+R+D

=23+15+18+11+8+1+18+4

=98%

也就是说知识和努力工作，对我们人生的影响，可以达到96%和98%。

好运,Luck

=L+U+C+K=

12+21+3+11=

47%

爱情,Love

=L+O+V+E

=12+15+22+5

=54%

看来，这些我们通常认为重要的东西 却并没起到最重要的作用。

那么， 什么可以决定我们100％的人生呢？

是Money（金钱）吗？

=M+O+N+E+Y

=13+15+14+5+25

=72% 看来也不是。

是Leadership (领导能力)吗？

=L+E+A+D+E+R+S+H+I+P

=12+5+1+4+5+18+19+9+16

=89%

还不是。

金钱，权力也不能完全决定我们的生活。 那是什么呢？其实， 真正能使我们生活圆满的东西就在我们的 代码里面！

输入输出流头文件,iostream

=I+O+S+T+R+E+A+M

=9+15+19+20+18+5+1+13

=100%

所以坚持写代码吧…

各种老师一回头 语文老师一回头，此地空余黄鹤楼。 数学老师一回头，二次函数对称轴。 英语老师一回头，sorry加上三克油。 化学老师一回头，二氧化碳变汽油。 物理老师一回头，一跟杠杆撬地球。 生物老师一回头，试管婴儿水中游。 地理老师一回头，大陆版块乱漂流。 劳技老师一回头，破铜烂铁来走秀。 政治老师一回头，布什改行卖豆油。 美术老师一回头，蒙娜丽莎也风流。 体育老师一回头，奥运取消打篮球。 电脑老师一回头，学生全成阿Ｑ友。 全体老师一回头，世界人民没自由。

所有头文件: 1.首先是最方便的万能头文件，顾名思义，可以将其理解为父亲头文件 （虽然方便了懒人，但是缺点也很明显--这一头文件很占用内存）： #include<bits/stdc++.h> 2.接着也是比较常用的，作用于数据流输入输出 cin>>和cout<<： #include 3.然后是各种算法的头文件(例如sort函数等)： #include 4.关于数学函数的头文件（例如max( )，min( )，abs( )等）（从C语言中的math.h继承而来）： #include 5.string字符串头文件： #include 6.接着是C语言的头文件： #include 7.普通队列(只能一边进一边出)(先进先出)的头文件： #include 8.双向队列(两边都可以进出)(先进先出)的头文件： #include 9.栈(先进后出，后进先出)的头文件： #include 10.列表的头文件： #include 11.动态数组(不需知道该数组的数量)的头文件: #include 12.图的头文件： #include 13.集合(内部自动有序且不含重复元素)的头文件： #include 14.控制电脑或小黑框头文件(不包含在万能头件)： #include<windows.h>

数学是火，点亮物理的灯； 物理是灯，照亮化学的路； 化学是路，通向生物的坑； 生物是坑，埋葬学理的人。 文言是火，点亮历史宫灯； 历史是灯，照亮社会之路； 社会是路，通向哲学大坑； 哲学是坑，埋葬文科生。

班长说:走，我们去炸了学校。 副班长说:这个主意不错 化学课代表负责提取氢气 物理课代表负责拼装氢弹 数学课代表负责计算爆破面积 地理课代表负责策划爆破地点 历史课代表负责记录光辉场面 生物课代表负责事后生态环境 政治课代表负责使用法律打官司 语文课代表负责乱写文章推卸责任 英语课代表负责到外国购买进口材料 体育课代表负责屠杀XXX

鼓起勇气敲起这键盘 只因为有你在 无向图，是否明白 害羞的我，说不出的爱 我也曾四处漂泊流浪 为求单元短路 直到我蓦然回首时 瞥见你复杂模样

提交一次一次一遍一遍 巡查于OJ 只为了AC出现 如何卡进超限时间 增广路止不住求最大流 深广把图搜 手敲着小小的键盘 没人陪在我左右

套用心爱的线段树 仿佛AC了全OJ 想要评测机了解 这AK的感觉

一个人的优化那网络流 明明想AC却超时超空 虽然我的常数可能不太够 有谁能懂我温柔 做一棵平衡树随数旋转 又回溯最初的根节点 后来我才卡进这就是你想要的时限 那么默默爆零是我给你最后的温柔

写着n方n三的暴力 形单影只的我 任BUG将我剥落 一声叹息只能打表 我也想打到那集训队 给自己骗点分 任巨佬如此强大 又何处能够骗到分

OI总有许多挫折 请坚定自己的选择 即使在难过时刻 也要把代码写

一个人的优化那网络流 明明想AC却超时超空 虽然我的实力可能不太够 有谁能懂我温柔 做一棵平衡树随数旋转 又回溯最初的根节点 后来我才卡进这就是你想要的时限 那么默默爆零是我给你最后的温柔

为你写起这代码 这是鬼畜的风格 就算超时又如何 只想带给你AC 为你我努力刷题写dp 感谢你们的关注 就算明天for循环重复 有了陪伴就不孤独

---

咬下一口我的快速幂吧 尝尽这测评的A(C) WA T(LE) R(E) 身在文化课的OIer们啊 不要忘记你代码 也许对这世界有着无奈 已不再是那一个蒟蒻 即使NOIP爆零也要学会去承担

有了算法陪伴我已不再会孤单 你们的鼓励在我的心中永不会消散

oler神

洛谷新手村外，一个OIer开设的机房里，程序员kkk端坐在桌后。他头也不抬，冷冷地问：“你叫什么名字？”

“QAQ__"

“年龄？”

“25岁。”

“什么错误？”

“TLE。”

kkk程序员站起身熟练地打开病人的代码。他愣住了，蓝色的眼睛里闪出惊疑的神情。他重新审视着眼前这个人，冷冷地问：“你的洛谷名是什么颜色的？”

“棕色。”

“你是红名！”kkk程序员一针见血地说，“我当过管理员 （其实现在也是），这么多的代码，只有红名大佬才写的出来！”

病人微微一笑，说：“kkk程序员，你说我是红名，我就是红名吧。”

kkk程序员的目光柔和了，他吩咐同事：“准备改BUG。”

kkk程序员正在换工作服，同事跑来，低声告诉他病人拒绝使用O2优化。kkk程序员的眉毛扬了起来，他走进机房，生气地说：“年轻人，在这儿要听程序员的指挥！”

病人平静地回答：“kkk程序员，O2优化离头文件太近，我担心施行O2优化会影响头文件。而我，今后需要一个非常好用的头文件！”

kkk程序员再一次愣住了，竟有点口吃地说：“你，你能忍受吗？你的程序需要加上无数个剪枝，把原先的代码和你改的代码全部删掉！”

“试试看吧。”

电脑前，一向从容镇定的kkk程序员，这次双手却有些颤抖，他额上汗珠滚滚，同事帮他擦了一次又一次。最后他忍不住开口对病人说：“你挺不住可以哼叫。”

病人一声不吭，双手紧紧抓住身下的白床单，手背青筋暴起，汗如雨下。他越来越使劲，崭新的白床单居然被抓破了。（注：原因是因为不愿意看到自己的代码被改）

脱去工作服的kkk程序员擦着汗走过来，由衷地说：“年轻人，我真担心你会WA过去。”

病人脸色苍白。他勉强一笑，说：“我一直在数你的改的行数。”

kkk程序员吓了一跳，不相信地问：“我改了多少行？”

“2^6行。”

kkk程序员惊呆了，大声嚷道：“你是一个真正的OIer，一个会写代码的神犇！你堪称管理员！”

“你过奖了。”

kkk程序员的脸上浮出慈祥的神情。他想说什么又忍住了，挥手让同事出去，然后关上机房的门，注视着病人，说：“告诉我，你的真名叫什么？”

“chen_zhe。”

kkk程序员肃然起敬：“啊，AK IOI的神犇，久仰久仰，认识你很荣幸。”chen_zhe友好地把手伸了过去

已老。窃人者，自失其宝。所谓觉悟，乃是在漆黑的荒原中，开辟出一条属于自己的星光大道！当你对自己诚实的时候，世界上就没有人能够欺骗得了你。 世事易变，匪石弗转。愿追逐光明的我们，都会迎来属于自己的春天。越是困难，越要抬起头，地上可找不到任何希望！ 每个细节只需要再好一点点，最终结果将会更加完美。凡是过去，皆为序章有形的东西迟早会凋零，但只有回忆是永远不会凋零的。人，百年一世；龙，百年一岁。君生吾已老，君未变，而吾已老。

唧唧复唧唧，木兰开飞机， 开的什么机？波音747！

问女何所思，问女何所忆。女亦有所思，没钱买飞机。

昨夜见军帖，要用轰炸机，飞机十二架，架架买不起。

阿爷无大钱，木兰无金银，愿去买钢铁，从此造飞机。

东市买图纸，西市买螺丝，南市买玻璃，北市买铁皮。

旦辞爷娘去，暮宿旧机库，不闻爹娘唤女声，但闻铁皮摩擦滋啦声。

旦辞机库去，暮至军营旁，不闻爹娘唤女声，但闻将军大呼哈哈哈。

万里开飞机，关山一下没。热气传机翼，日光照玻璃。

将军被吓死，壮士魂已飞。飞来撞天子，天子躺病床．

策勋十二转，赏赐俩耳光。可汗问所欲，木兰不愿进牢房；愿开747，飞着回故乡。

爹娘闻女来,端起机关枪；阿姊闻妹来，当户举手枪；小弟闻姊来,磨刀霍霍向爹娘。

开我机舱门，进我飞机舱，脱我战时袍，换上飞行装, 多装手榴弹，对外架机枪。

出门埋炸弹，亲友皆惊忙：离别十二年,不知木兰变猖狂。

疯子脚蹬地，呆子眼紧闭，两人并排走，谁能说我不正常?

刚刚有个傻冒告诉我鲁迅姓周，真逗啊！周迅是个演员好吗？笑死我了！真想一板砖呼死他！我记得鲁迅原名李大钊，浙江周树人，是著名的法西斯音乐家，一生有2000多项发明，被称为太空步的创始人。他拥有一个好嗓子，小学时就凭借着90分钟跑100米的优异成绩考上了新东方烹饪学校！毕业后成功进入富士康苦心练习勃鸡， 他擅长110米栏，左手反打技术高超，拿手全垒打，大灌篮，“后空翻180度右旋体360度后蹬地翻转720度”是他的经典动作，更难得可贵的是他落地没有水花。他还是恶魔果实能力者，传说中的三忍之一，曾大闹天宫，后改邪归正，统一三国，传说他有107个弟兄，个个铜头铁臂，面目狰狞，这便是羊村的起源，她生平淡泊名利，曾经锻造五色神石补天，因杀死西门庆等原因，上梁山当了土匪，后遇到高人阿凡达的指点，收买阿童木打死了白雪公主，与七个小矮人快乐的生活在一起。！并写了名侦探柯南的故事。名侦探柯南讲述的是要成为海贼王的八神太一收服了皮卡丘并登上创界山启动光能使者打败了鲨鱼辣椒，然后跟多啦A梦一起通过黄金十二宫收集七个葫芦娃召唤神龙复活二代火影，但最终为了保卫M78星云而成为了羊村村长，同蓝精灵们一起抵抗光头强的入侵的故事。她还写了《时间简史》，后来因抽了龙王三太子的筋，以命偿命。后被太乙真人救活，又送了他不少法宝。然后又创建了‘浴谷’，‘浴谷’是一个收集变形金刚一起打小怪兽的网站(阿米诺斯)。当时正值小黄人入侵时期，于是，她批量生产大白，成功抵御入侵，再一次拯救了人类！当她晚年时，热衷于炼丹，炼时经常失败，一大堆毒丹，她全吃了，等他快死之时，她与诸葛亮在大观园里吃唐僧肉，挽救了她10年寿命，哦，对，是100年才对，接着诸葛亮死了，她又把诸葛亮和曹操还有关羽的骨灰煲汤喝了，饱~。紧接着，他的爸爸苏轼，表哥苏辙和表舅苏洵创作了神仙版《清明上河图》并封印了敖丙和哪吒，并制造了太乙真人——猪八戒，猪八戒因和镇元大仙吃小孩被鲁迅送给孙悟空的前妈和后妈：蜀山汁魂-范无刀用来煲汤，黑白无常-谢必弹用来煮饭，结果饭里有把如意金箍棒，把孙悟空刺死了。然后他又发明了四大名著，分别是：《大白与小白》，《基佬的爱情故事》，《超人搞事员》和 《吃屎记》......然后她的儿子-玉皇大帝，因为搞gay被二郎神发现而搞在一起，最后邓某将他们分开，接着❤，紧接着特朗普发现，将他们斩了。天才眼镜狗林黛玉大喊强奸，鲁迅就叫周树人号召全联合国发动核弹计划，结果因为缺少骆驼的屎尿屁而发生核泄漏，只有骆驼活了下来，辛亏阿里巴巴和鲁迅发生关系，变成了莱利兄弟制造飞机躲过一劫，不幸阿里巴巴阵亡，复活了爱迪生，只好与她相爱相杀，全人类复活，并交配出了变种人。在深夜13号的星期五，金刚狼化身杰森，与邦邦一起买炸弹，结果复活的敖丙和哪吒因为将太乙真人塞入陈塘关，令其爆炸，地球失去重力，形成巨型黑洞，把宇宙消灭了。辛亏鲁迅和哪吒在最后关头进入四维空间，搞在一起，过上了幸福的生活！！！

3.1415926535 8979323846 2643383279 5028841971 6939937510 8214808651 3282306647 0938446095 5058223172 5359408128 4811174502 8410270193 8521105559 6446229489 5493038196 4428810975 6659334461 2847564823 3786783165 2712019091 4564856692 3460348610 4543266482 1339360726 0249141273 7245870066 0631558817 4881520920 9628292540 9171536436 7892590360 0113305305 4882046652 1384146951 9415116094 3305727036 5759591953 0921861173 8193261179 3105118548 0744623799 6274956735 1885752724 8912279381 8301194912 9833673362 4406566430 8602139494 6395224737 1907021798 6094370277 0539217176 2931767523 8467481846 7669405132

竞赛用：

#include <iostream>//输入输出
#include <cstdio>//加载库
#include <cstring>//跟字符串有关
#include <string>//跟字符串有关
#include <cmath>//数学库
#include <cstdlib>//一些函数
#include <queue>//队列
#include <algorithm>//算法
using namespace std;
int main(){
freopen(".in","r",stdin);
freopen(".out","w",stdout);
int a,b;
cin >>a>>b;
cout <<a+b;
return 0;
}

//高精度乘法
#include <bits/stdc++.h>
using namespace std;
int a[2001],b[2001],ans[4002];
int main(){
string s1,s2;
cin >>s1>>s2;
reverse(s1.begin(),s1.end());
reverse(s2.begin(),s2.end());
int len1=s1.size(),len2=s2.size();
for(int i=0;i<len1;i++) a[i]=s1[i]-'0';
for(int i=0;i<len2;i++) b[i]=s2[i]-'0';
//正确
//	for(int i=0;i<len1;i++){
//		cout <<a[i]<<" ";
//	}
//	cout <<endl;
//	for(int i=0;i<len2;i++){
//		cout <<b[i]<<" ";
//	}
//	return 0;
for(int i=0;i<len1;i++){
for(int j=0;j<len2;j++){
ans[i+j]+=a[i]*b[j];
ans[i+j+1]+=ans[i+j]/10;
ans[i+j]%=10;
}
}
int len=len1+len2;
while(ans[len-1]==0&&len>=2){
len--;
}
for(int i=len-1;i>=0;i--){
cout <<ans[i];
}
return 0;
}

//高精度加法
#include <bits/stdc++.h>
using namespace std;
int a[1001],b[1001],ans[10001];
int main(){
string s1,s2;
cin >>s1>>s2;
int s1len=s1.size(),s2len=s2.size(),len=max(s1len,s2len);
reverse(s1.begin(),s1.end());
reverse(s2.begin(),s2.end());
for(int i=0;i<s1len;i++){
a[i]=int(s1[i]-'0');
}
for(int i=0;i<s2len;i++){
b[i]=int(s2[i]-'0');
}
for(int i=0;i<len;i++){
ans[i]+=a[i]+b[i];
if(ans[i]>=10){
ans[i+1]++;
ans[i]-=10;
}
}
//	for(int i=0;i<len;i++){
//		cout <<ans[i]<<" ";
//	}
//	return 0;
if(a[0]+b[0]>=10){
for(int i=len;i>=0;i--){
cout <<ans[i];
}
}else{
for(int i=len-1;i>=0;i--){
cout <<ans[i];
}
}
return 0;
}

接下来开始鉴赏迷惑行为。如果选中了你的代码，而你不希望被公开展示，可以私信我撤下。

1. 文件人

2. 我成功啦

3

3. freopen 拼写人

4. 我爱 CCF（这位仁兄很遗憾爆零了）

5. 喜报：//freopen

6. 放弃治疗人（dict）

7. "r"，"w" 人

8. 数组定义人

9. freopen 写反人

10. 综合性弃疗人

11. random() 人

12. freopen 文件名人

13. 没有用 -std=c++14 自测变量名冲突人

14. 数组读入人

15. 又一个 freopen 人

16. 用 == 赋值人

17. for 循环人（逗号表达式只计算最右侧的值作为答案，即 i<m 在此处没有一点作用）

18. 我觉得应该和第 16 位交换一下代码

19. "stdin" 人

20. 你说得对，但是我们明日方舟怎么你了

21. 没有用 -std=c++14 自测函数名冲突人

22. 非 void 类型函数不 return 人（会直接 RE 爆零）

23. fclose 人（我寻思竞赛下可以不写的东西为什么要写还写错了）

24. 耐心人

25. void struct 人

26. 我也是第一次听说 minmax 也会冲突

27. “所以这十分至关重要，一定要写出来”人

28. 喜报：freopen("dict1.in","r",stdin); 人

29. 温馨提醒，不能这样子初始化数组

[错误] narrowing conversion of '1.0e+9' from 'double' to 'int' [-Wnarrowing]

---

上面的选手都因为各种失误获得了零分，非常可惜。我们看一些乐趣味十足的选手吧！

1. 原神，启动！

2. namespace ccf_is_so_great

3. 最爱 CCF 的一集

4. 素质最低的一集

5. 血的教训（多测不清空）

6. 英语 150 只能考 131 不够好

7. 非常好 NOIP，让我的代码旋转

8. 这位老哥如果你没考好不要骂我(chen_zhe)

9. 无处不在的 kkksc03

10. 帮他提交代码

//0pts
#include<bits/stdc++.h>
using namespace std;
int main(){
	freopen("run.in","r",stdin);
	freopen("run.out","w",stdout);
	cout<<114514;
	return 0;
}

/*
 * Never gOnna gIve you uP
 * wile(1919810) RP+=114514
 * Everyone is HOMO!
 * I love CCF!

 * The electric light flowing in your fingers,
   Is the only faith in my whole life.
   Only my RAILGUN will live forever!!!

 * Oh, I've already got 120pts... QwQ
   I tried to write a brute force for T4
   But I'll only get 8pts...
   I'll just cout 114514 because I'm a HOMOrous person

 * PS:
   If anyone scanned "CCF" or "HOMO" or "114514"
   This code will be showned
   Pls paste my code in T3 & T4 on LUOGU or CSDN
   To show my love to CCF
*/

11. 自信即巅峰