0:07 大家好，今天我们来谈谈……
0:09 我们将讨论算法，并尝试讨论整个系列。
0:12 相关问题的算法
0:14 这里稍微介绍一下背景，这就是我们
0:17 就像我们在学习编程一样，但是从
0:19 真正的编程就是如此。
0:21 作为一种记录算法的方法
0:23 在本例中，我们使用的编程语言是 C。
0:26 语言现在经常被用来处理……
0:29 无论是小事还是大事
0:30 这提供了一些背景信息。
0:33 例如，在物理学中，我们都像……
0:35 我们在那里遵循牛顿力学，但是
0:37 然后还有弦理论，它试图
0:39 回答有关大的问题
0:41 之后的事情就是量子力学了。
0:44 谁在试图回答到底发生了什么？
0:47 小规模的或者类似的情况
0:49 我只想简单介绍一下背景……
0:51 而对于我们今天的主题来说，这就是我们正在讨论的内容。
0:53 那里有C语言编程，我们
0:56 假设这还算一般
0:58 这个过程似乎源于此。
1:02 我们在此文本框中输入的文本
1:04 编辑器不知何故将我们引向
1:10 让我们来看看整个系统是如何运作的。
1:13 我希望我的语言里也能有那么一点这样的特质。
1:16 从上下文可以清楚地看出，这种小规模
1:19 在这种情况下，是一种试图深入的尝试
1:22 建筑水平低，这一点很明显。
1:26 那是另一次机会了，再说，你还有
1:29 或者你将学习计算机体系结构。
1:32 在那里你将详细检查它，然后
1:36 这就像比编程更复杂一样。
1:41 分析和程序系统
1:43 工程学以及对我们来说重要的东西
1:52 你将拥有或有一个单独的东西，
1:54 将致力于数据结构和
2:00 我们实际做什么
2:03 编程，我们以及对谁以及
2:05 我们测试并实施各种各样的东西
2:08 我们用它做了其他可怕的事情。
2:16 围绕它的对话或激烈争论
2:42 所以，但是
2:50 编写文本或编程代码是
2:52 这只是他们开展的活动之一。
2:54 程序员，这还只是最基本的。
2:56 这里发生的活动很有趣，而且差不多。
3:05 电子邮件地址，指的是你工作时使用的地址。
3:07 用技术手段实现这一点是自然而然的。
3:13 这里是不是有什么配置问题？
3:15 编程方面，嗯，显然没那么厉害。
3:18 此类行政工作和此
3:20 如果我们将这种情况视为……
3:22 我们在那里编写该网页的代码。
3:27 我们如何编写浏览器指令？
3:50 那里有各种各样的 JavaScript 代码和马克笔。
4:14 让那台机器解决这个问题
5:19 或者一首诗或一首歌，把它写下来。
5:21 传单本身不是问题，问题在于……
5:24 也许可以像这样创造
5:27 嗯，那里的情况可能不一样。
5:29 复杂度越高，越容易越难
5:31 事情就是这样，但是写作不是问题。
5:32 这只是一项技术操作，仅此而已。
5:34 编程，这里指的是编码。
5:38 当然，你需要懂这门语言，但是但是但是
5:40 但在那之后，这就不再是个问题了。
5:42 是的，跟那首歌一模一样。
5:43 你需要记笔记，你需要知道如何记笔记。
5:46 也许这就是解决办法，而你需要为此付费。
5:49 但是，但是，但是，这并不是成为艺术家的必要条件。
5:52 或者作曲家，优秀的创作者，是的，就是这样
5:54 情况完全一样。
5:57 程序员们，真的太可惜了
5:59 这类语言有很多种，数量相当多。
6:02 技术细节会自然而然地发生变化。
6:04 语言无论如何都只是
6:06 衡量谁衡量
6:08 对于自动化而言，是的，这很重要。
6:10 弄清楚它是如何实现的
6:13 现在，在所有情况下，当我们
6:15 我们接到某种任务，仅此而已。
6:17 程序员基本上从事以下工作：
6:19 设计工作是指
6:21 设计一个解决方案，然后
6:23 这样做是可行的，然后因为
6:25 问题不同，所以你不能
6:27 为所有可能发生的人生事件做好准备
6:29 在这种情况下，所采取的措施是
6:32 尝试学习某些标准
6:34 模板解决方案或其他
6:36 换句话说，研究现有的
6:39 解决经典问题的算法
6:41 然后人们就假设，当它到来时……
6:43 一些新的任务，也许
6:45 将与现有的情况有些类似。
6:47 检查之后，程序员就能……
6:50 想出一个解决方案，所以我们现在就这么做。
6:53 我们来探讨两个经典案例。
6:55 哪些任务是
6:58 这些问题正在讨论中，在这里可以进行明确的辩论。
7:01 但是但是但是但是基本上大部分
7:03 计算机科学问题可以概括如下：
7:05 这两个任务正在搜索中
7:08 并且非常了解搜索排名
7:10 一般来说，我如何获取数据？
7:12 我需要从他们那里获得一些信息。
7:14 拔出意味着换句话说
7:17 简单来说，例如
7:20 你能告诉我怎么找人吗？
7:23 我不知道顾客的具体订单内容。
7:25 编号，这是这里的搜索任务，是的。
7:27 但总的来说，人们可以想到……
7:28 例如，数数是更明智的做法。
7:31 一些数字的平均值
7:34 这个数字并非直接存在于数据中，而是
7:36 需要从哪个来源提取这些数据？
7:40 这是一项间接搜索任务
7:42 但无论如何，它都是基于
7:45 搜索之后通常会进行排序。
7:47 人们说排序，但排序
7:54 我建议使用“排名”这个词。
7:56 顺便说一句，这曾经有人向我提出过。
7:58 我被一位学生纠正了，我完全
8:03 一般来说，这些数据都属于这一行。
8:05 排序任务通常是
8:10 按升序排列，但一般情况下
8:13 这是一项数据组织任务。
8:15 因此我们可以考虑这个排名和
8:17 我不知道我们该如何举个例子。
8:19 文件很多，需要分类。
8:21 像这样组织目录
8:24 决定我们何时应该在哪里
8:29 错误也是这里的一项搜索任务。
8:31 当我们说：“嘿，这里的订单是什么？”
8:33 你应该把代码中的函数放在这里。
8:37 一般情况下，逐个口头说明
8:40 是关于你需要找到的
8:42 信息和下一个任务是关于
8:43 需要以某种方式处理。
8:46 从某种意义上说，是的，那声咆哮，仿佛
8:50 顺序，但通常可以是
8:52 这意味着截然不同的事情，例如
8:58 右边或那里的女孩们
9:17 将会熟悉这些任务
9:22 解决它们，但无论如何你都会学到这一点。
9:26 用它来让它更好
9:37 这就是我们这门课程要讨论的内容。
9:42 总的来说，正如我们常说的， 瓦
9:43 瓦
9:59 这是该算法的描述吗？
10:01 是的，或者如果我们说没有增值税的话。
10:03 告诉我如何找到这样的
10:08 某处有人告诉我们这件事
10:09 在那里你需要从左向右走
10:12 前方背景中会看到一些东西。
10:13 我们可以在这里确认它是否真的好。
10:15 在我们前进的路上，他也尽力帮助我们。
10:17 给出一些指示，例如
10:21 是的，我们实现了目标。
10:25 我们经常使用这个概念。
10:27 在日常生活中，当我们说 方法
10:30 方法
10:33 说明步骤算法
10:35 这里每个人都差不多。
10:37 语言学家可能会辩称：
10:39 两者之间存在一些细微差别，
10:42 在这件事上，他们确实是我们的。
10:44 结合上下文，我们可以把它看作是这个的同义词。
10:46 现在我们继续……
10:50 信息学是一个框架，我们用这个词来描述它。
10:52 算法通常用于此目的。
10:58 我们希望符合某些标准，也就是说，
11:01 例如，一个人可以
11:03 我们可以通过画图来讨论算法吗？
11:05 美丽的画，无论美丽意味着什么。
11:08 因为它很美，所以很难完全分辨。
11:10 可能有所不同，而且确实如此。
11:12 主观上，是的，我们经常在
11:18 这意味着这些步骤如下
11:20 也就是说，那台机器可以使用的算法
11:23 执行完毕后，每个人都会同样理解。
11:24 这意味着我们需要明确一点。
11:27 同意采取这些步骤
11:30 应该清楚地理解
11:32 标准请求和任何
11:34 他喜欢工程学。
11:35 准确性是指例如如果
11:37 我不知道，你要用电吗？
11:39 电路图由……绘制
11:41 电工将进行检查，并发现……
11:43 再次强调，有一些标准证书。
11:45 并联连接是什么意思？
11:47 稳定的电流源是什么样的？
11:49 那里好像有个电阻器之类的东西。
11:51 难道不是一样的吗？
11:53 计算机科学，然后如果我们说
11:56 我们正在调查此事。
11:59 编程就是这样，而我们的
12:01 事件是由电脑触发的，所以这很自然。
12:03 接下来就要讨论这类算法了。
12:06 这也可以由计算机执行。
12:08 然后说一种语言，这样每个人
12:10 他们现在也能同样理解我们所说的话。
12:13 问题在于，完全
12:17 编程语言有很多种。
12:19 有很多设备，然后你需要
12:21 一些不同的东西
12:24 我们可以谈论的一种方式
12:27 这些算法有什么不同之处？
12:32 这并不完全是因为人们
12:38 自然地编写代码，并且该代码可以
12:40 混淆了已发明之物
12:43 人们发明了一种特定的结构，
12:45 我们通常称之为伪代码
12:49 一些完全不合适的代码
12:51 或许根本就没有什么编程。
12:53 他/她使用的编程语言
12:55 为男性而写，也旨在为男性而作。
13:20 现在事情就是这样，如果我们
13:22 我们在学生时代就习惯了。
13:24 解决各种数学问题
13:30 速度取决于到达那里所需的时间。
13:33 车子往这边开，往那边开。
13:37 是的，现在这项任务是……
13:52 会给我生成这样的输出，但是当我们
13:56 从算法角度来说，我们很关心这一点。
13:59 现在我们不在乎答案了。
14:01 换句话说，回答者很关心。
14:06 答案可以通过这种方式得出。
14:08 这导致了一系列不同的标准。
14:11 算法理论有很多种，
14:14 类似算法的其他东西
14:22 如果它永远有效，那我也会一直有效。
14:27 正在调查是否存在所有情况。
14:33 例如等等，现在不是这样。
14:35 就是这样，这就是理论，就是这样。
15:01 等等，不完全一样。
15:05 换句话说，就是该算法
15:07 总得有人来创造它，所以它需要是
15:09 以书面形式记录下来
15:12 这种情况需要一些伪代码。
15:14 检查该算法是否有效
15:16 这实际上是在处理一个算法。
15:17 通过这种方式可以证明其正确性。
15:19 做一下测试看看它是否存在。
15:23 效果好或效果差，然后
15:24 情况正在发生变化，这可能是因为
15:29 我的算法必须改变，因为
15:31 数据不同或输出结果不同
15:33 不一样，是的，现在这个这个这个
15:35 换句话说，程序员们从……做什么
15:41 这与它们是一体的事实有关
15:44 另一种方法是使用类似这样的算法。 现在
15:46 现在
15:51 我们应该如何看待算法？
15:59 从一开始就意味着我无法做到
16:01 我不确定我的说法是否正确。
16:04 我明白我正在解决什么问题。
16:09 这种情况经常发生，而且很容易被察觉。
16:12 通过你的工作，当人们……
16:14 编写了一些程序，结果发现
16:22 你并不完全理解你
16:24 顾客或客户本人说道
16:31 你做的不是那样，也许他做的是……
16:40 这就是与客户沟通的方式以及如何
16:46 总的来说，人们应该这样认为：
16:50 我想解决什么问题？
16:57 我可以谈谈这个问题吗？哦
16:59 如何解决
17:03 与我们分析的事实有关
17:13 是同义词，它不是分析。
17:16 将某事物分解成各个部分的过程
17:21 这个过程是合成，这意味着我
17:29 分离
17:30 分离化合物并进行测试
17:42 我们为什么会这样就更清楚了
17:45 程序功能因为我们
17:50 分析它们以便更好地理解它们
18:02 他说，人需要，他需要
18:11 意思是这样计算价格
18:13 需要折扣，不需要折扣，没有任何折扣
18:19 这意味着你需要仔细聆听，
18:40 换句话说，什么是什么是
18:46 情况以及最终结果是什么，也就是说……
19:19 需要这样检查弹簧。
19:27 出去跺跺脚，让别人
19:41 算法可能就像我们一样
19:45 或许是我们自己误解了什么。
19:51 我们编写的代码很糟糕，所以后果可能非常严重。
19:54 是的，这通常意味着需要安装。
19:56 这意味着我们需要了解什么是
19:58 输入是理解输出的必要条件。
20:00 需要弄清楚如何从输入中获取它
20:02 然后你需要像这样测试APU
20:06 现在你怎么能想到…… 解决方案
20:07 解决方案
20:11 这在很多方面都非常必要
20:14 尝试找到解决方案，结果是
20:16 人们经常会谈到两个
20:18 超越以往的策略
20:21 在信息学框架内，这些是策略
20:23 是从上到下，也是从下到上
20:26 向上或用英语来说，自上而下
20:29 自下而上，所以如果我们谈论的是
20:30 自上而下地，我们设想
20:33 我们都对青蛙有什么概念。
20:34 任何或不，如果我们想要
20:36 了解青蛙的习性，我们就能更好地理解它。
20:38 我们把它切成小块，然后
20:40 我们来解释一下左手是如何运作的。
20:42 右手明显是只青蛙，已经无法活动了。
20:45 我们没剪掉它，不过算了，这样行吗？
20:47 胳膊和腿看起来好些了，也许吧。
20:50 我们明白，这就是我们现在的编程方式。
20:52 我们做同样的事情
20:54 我们想象它一定是这样的。
20:56 我们设想的某种程序
20:58 这比那更高一级。
21:01 一层，然后我们该怎么办？
21:04 我们接受它，我们试图找到结构
21:07 把你的程序分成几部分，并进行划分。
21:10 某种结构元素
21:12 可以这样想象：
21:13 例如，我想要一些
21:16 网站的目的是让它如此运作，然后我
21:19 我想，好吧，那我需要一个页面，
21:21 会想象出某种情景，然后出现在某个地方。
21:23 数据库中必须有可用的数据。
21:25 这自然而然地就分解成了一幅图像。
21:27 逻辑，或者换句话说，前端
21:29 以及后端，然后我们将它们拆分。
21:32 然后那里发生了类似这样的事情：
21:34 我们从整体开始，试图爬行
21:37 向内，越来越深，越来越深，越来越深
21:39 直到我们最终到达那个点
21:41 我们现在就可以直接把它拿过来，像这样编写代码了。
21:44 自下而上的分支完全是另一回事
21:46 我们需要从……开始
21:49 底部，而且这种想法是这样的我们
21:52 然后，我们却认为，与其那样，不如那样。
21:54 我们思考整体，思考小事
21:56 我们可以采取的一步是
21:58 这意味着，例如我们知道
22:00 所以如果我们需要在那里建立一个网站，我们
22:02 我们完全不知道她那里还有什么其他东西。
22:04 我会做的，但就目前这个阶段而言，我们先接受它吧。
22:08 现在我们可以好好欣赏这个标志了。
22:10 我们正在考虑还能做些什么，好吗？
22:12 我需要一份联系表格，我会做一个。
22:14 联系表格意味着我们拥有
22:16 我们这里有个泡沫，而且它仍然保持不变。
22:19 我们正努力让它像这样发展壮大。
22:21 我们正在尝试将这些气泡连接起来，所以……
22:22 这里展示的内容在一种情况下的含义是
22:25 我有一个很大的抽象概念。
22:27 分层，而我正在尝试做的是我正在尝试
22:29 打破那些大三角形
22:31 所有的小三角形
22:33 较小的三角形以及来自
22:37 从抽象层面来探讨这个问题
22:39 技术层面上是的，而我此刻就在这里。
22:42 我有一些积木，我正在试用它们。
22:44 从下方连接到更大的模块
22:46 嗯，最后我已经连接到
22:48 或许选几个模块我就去。
22:51 是的，直到我最终到达顶峰。
22:53 我想要的，完全是无意的。
22:55 在填充时通常是
22:59 我们发明并分解它，通常在这里
23:03 这里有各种各样的瀑布模型
23:06 通常情况下，有些地方会有这样的地方。
23:10 主要是迭代式的，这意味着
23:12 我们先制作了第一版，然后是第二版。
23:13 然后是第三个，然后是第四个，以此类推。
23:15 我们在头上粘了些东西等等。
23:17 是的，如果这里的一切都很重要的话。
23:19 做好计划，深思熟虑
23:22 商业计划书，各种日程安排
23:24 新年愿景和决心
23:26 现在就开始吧，无需等待，立即开始！
23:28 明天，尽你所能。
23:30 向前迈出一小步，如此往复。
23:32 你可以把这些想法用语言表达出来。
23:35 然后就能很清楚地认识到这一点及其本质。
23:37 就是当我们试图解决
23:38 我们经常遇到的某种问题
23:41 我们将它们结合起来使用，这意味着有
23:43 我们充分理解并应用最佳方案。
23:50 一切都被构思成格言，当我们
23:52 我们不知道的时候，就做我们知道的事。
23:54 此时假设
23:56 我们只要做一点，就会过得更好。
24:01 向前，以便当人们有
24:03 根据经验，不这样做效果更好。
24:05 当然，当我们没有经验的时候，
24:06 我们总是很忙。
24:08 我们进行实验，科学通常
24:10 它一直都是这样运作的，因为……
24:12 那样根本无法把所有事情都涵盖进去。
24:15 这是自然而然的，也是源于限制。
24:21 这些积木是什么样的？
24:24 哪些算法开发者在运行
24:26 它们可能非常不同，但我们
24:28 我们或许还记得我们讨论过……
24:31 结构规划定理以及
24:34 他说任何方案都有可能实施。
24:36 使用三种方式写入
24:39 这意味着如果我们
24:41 我们基本上是想写点什么。
24:43 我们只需要一个算法
24:46 想办法写出这个问题
24:49 是的，在循环、条件和序列中，就是这样。
24:51 这就是一系列步骤。
24:53 该多项式由算法得出。
24:55 定义只需要在之后想出一些东西。
24:59 现在该如何处理这些分歧？
25:02 通常是自动的，这意味着
25:03 如果我明白我需要什么
25:06 不仅做一次，而是做很多次
25:09 我知道如果我需要循环的话
25:11 我知道这需要反复进行很多次。
25:15 例如，我不知道，我有一些词。
25:17 列个清单，我需要对它做些处理。
25:20 用符号表示，这是一个词语列表，含义如下
25:21 很多字意味着会有一个
25:24 一个循环，遍历所有词语，在一个
25:31 进程中许多字符将再次循环
25:34 处理符号时，显而易见的是
25:36 立即循环，是的，是的，必要
25:39 好的，那就把它工整地写下来。
25:40 起始条件结束时间到
25:43 这件事何时发生？但这一点毋庸置疑。
25:45 建筑只是一个循环中的循环
25:48 现在就立刻明确地说“是”，因为
25:51 很明显，当做出决定时
25:53 我需要选择该怎么做，这意味着
25:58 显然，两者都是必需的。
26:00 写一个类似这样的条件句：
26:02 换句话说，如果一切顺利，那就意味着一切顺利。
26:04 如果这个程序像这样的话……
26:07 我有一份需要逐一检查的单词清单。
26:09 选择某些词语，并在其中
26:11 将单词中的某些字母更改为
26:15 算法：我将遍历单词列表。
26:18 这是一个循环，我会选择一些特定的词语。
26:21 如果在循环内部，则对于每个
26:23 我将复习一下这个词的符号。
26:45 我们发布的时候会怎么样？
26:48 程序 a，这就是那些箭头所在的地方
26:50 某种程度上，这表明了我们的
26:52 程序运行过程中会不断变化。
26:54 控制流并不意味着那样。
26:56 总之，这里面肯定有值得注意的地方。
26:57 我选择向左还是向右
26:59 没错，而且这个周期与条件不同。
27:01 只是循环又回到了起点。
27:13 之后他被送过去了，然后开车去了那里。
27:15 迷宫，我们的工作也是如此。
27:17 建造迷宫实际上是
27:19 什么是算法？事情就是这样。
27:38 当她沿着那条小路走的时候
27:43 输出结果将如下所示，这里很简单。
27:45 一种思考“是什么”的方式
27:48 这些算法真酷
27:53 让我们想象一下它的样子。
27:56 算法，然后看到的不是文本而是
27:58 把这些记在心里，这就是我们
28:00 关于这些计划和那些
28:04 大概就是这样，基本上就是这样。
28:12 我在这里写了一条条件，是什么？
28:15 我的苍蝇现在会飞到这里来躲藏。
28:21 现在这些方块是图形化的。
28:26 我们能在这里画出算法代码吗？
28:29 所以很明显应该有更多。
28:30 把需要做的事情写在这里
28:32 这里可能有一些变量，需要一些说明。
28:33 某处某事的含义正在发生变化。
28:36 打印发送写在这里
28:38 有些收银员在里面很忙。
28:44 要做
28:57 如果我们这样想，内容就会像这样
28:59 用过程式编程术语来说，这是
29:01 有这些
29:14 这使我能够拥有我的所有代码
29:17 将事物分解成各个部分或进行分解
29:18 分析部分就是这样，然后
29:20 管理那段代码更容易，我不用自己管理。
29:22 需要一个大毛线球
29:25 现在把所有单独的盒子都拆开。
29:28 向前迈进
29:30 以下是一个示例，展示它可能的样子。
29:32 算法，如果你检查一下
29:35 某处的算法笔记或教科书
29:36 或者某处的科学文章
29:38 人们解决现代问题
29:41 你会得到类似这种风格的东西。
29:43 所以要注意伪代码。
29:45 这里没有编程语言，它是
29:47 哦，有这样的箭头吗？
29:49 他们程序中的某种符号
29:52 但这种情况并非如此，在这里是必要的。
29:55 如果你能读懂它，那是什么意思？
29:56 嗯，原来是那个算法错了。
30:00 一种非常古老的算法，人们曾尝试过
30:02 学习计算最大公约数
30:03 除数的最大公约数
30:05 这显然是一个除数，
30:07 能整除所有这样的数，并且是所有这样的数。
30:11 我取最大的除数，所以
30:13 这是这里建议的讨论方式。
30:18 如果我们说v会在这里
30:20 这里需要某种功能或程序。
30:23 命名数据将是数字 a 和 b
30:25 这里的评论告诉我们，我们
30:28 让我们尝试 a 和 b 来获得一个很棒的共同 div
30:33 所以，我们有一些 r，让我们取一个
30:36 让我们除以 b，取余数并加上
30:39 在这里，直到数值归零，我们都会做这些事情。
30:45 我们把它写在 b 中，然后重复这个过程。
30:48 步骤，然后当 r 变为零时
30:50 我们需要完成并达成最大的共识
30:52 除数将是 b 的值，这里也是如此。
30:55 我们遵循了这一算法
30:58 我们可以尝试实现 C 语言
30:59 那么现在让我们先试着互相了解一下。
31:01 我画的这个算法是怎么实现的？
31:03 请注意，在这种情况下，算法不会
31:05 当你在那里时，C 语言代码经常出现。
31:09 你可以在网上找到它。
31:11 编写代码也是可以的。
31:13 将其视为伪代码并执行
31:16 我会继续，而且我已经多次建议过……
31:18 当人们问我怎么了的时候
31:21 老师的密码无效，请您输入。
31:23 我会去了解一下到底发生了什么。
31:28 我们现在就试试。
31:30 这样做
31:33 现在的问题是，这对我们来说意味着什么？
31:36 他说这里有个号码。
31:38 是某个数 b，然后是
31:41 某个数 r 是模 b 的数
31:47 18
32:01 假设 r 是 12 的余数，我们
32:53 其余部分将是
33:28 我们做了我们刚才做的事，我们只是拿走了
34:25 我们来看看怎么做，我们会找到一个像这样的。
34:27 算法，我们不再理解它是如何运作的。
34:29 表现好的话，我们就能想到办法了。
34:31 我们可以思考一下，试试看。
34:33 例如，为自己设计一个解决方案。
34:38 会是这样，会是15、9和6给我们
34:40 如果我们看一下这三个数字，会发现什么？
34:42 是的最大公约数
34:46 从第15章第9节和第6节的内容可以清楚地看出：
34:48 他三岁了，是的，因为你看，这里有六个
34:51 最小的数字不可能是
34:53 大于六个的这六个
34:55 这一部分并没有分为五个部分。
34:58 但九不能被四整除。
35:00 三对每个人都合适，所以我们知道
35:04 现在 dbd 等于 tr，因为我们知道
35:09 这是输出结果，是的，我们的问题是
35:14 现在我们可以思考我们是否
35:16 我们也能以某种方式利用这个吗？
35:22 我们已经知道如何去做这件事了。
35:24 如果我们计算出来，它会退还给我们。
35:26 dbd 来自 15 和
35:28 我们将收到
35:31 如果我们不这样做，我们就得不到三个。 我们会数
35:33 我们会数
35:43 如果我们以 dbd 为例
35:51 6，哇，那是三个，是的，我们看到了。
35:56 这个说了三个，这个说了三个，这个说 星期五
35:57 星期五
36:10 现在是159，也就是3，大家都说3，好吧
36:22 你只需要把两个加起来就行了。
36:25 计算出除数，就完成了。
36:26 现在我们需要类似这样的东西。
36:29 例如，我们可以在其中进行自我评估。
36:32 真正的问题是什么？
36:38 现在我们需要这样一个例子，对吧？
36:49 例如，20 和 10 都是很好的常见数字。
36:53 除数是 10，如果我取和
36:57 他是两岁
37:00 现在我们正在观察事情会如何发展。
37:04 这可能是最大公约数
37:07 而且会有两个，我们不太喜欢这样。
37:11 我应该像这样写一些数字
37:24 我们可以在这里写下数字20。
37:28 10 等等，也许就这样吧。 发生
37:29 发生
37:52 32 可能
37:57 太好了，现在是32比20。
38:05 四个是，20 和 16 是 k o 32 和 16
38:08 总共有16个，所以也许我也可以推荐这个。
38:15 这些实际上都是 4 的约数，所以
38:18 我们可以猜测的选项之一
38:25 是啊，看看我们现在得到了什么
38:28 或者，一个好的答案总是“如果”吗？
38:38 现实中任何数字都是可能的。
38:48 乘积为 32 = 2 * 2 * 2 * 2 * 2
38:50 是的，所有这些数字都是
38:55 我也是一样。
38:58 他们不是朋友，是吗？
39:00 这些号码全部抽中
39:04 注意力优先，所以现在16不是
39:13 除了 2*2*5 之外，现在如果
39:16 让我们看看谁才是最大的。
39:18 公因数就是这些除数。
39:24 还有更多重复的，但这三个
39:27 这里没有二，只有五个，但是
39:33 最大公约数是
39:38 不是素因子的交集，因此
39:51 我明白了，我在这里是想演示如何
39:55 分析似乎是一项任务，我们可以
39:57 想出类似这样的方案，我们开始吧。
40:05 哦，那就三个吧。
40:17 七，是的，我现在在注意了
40:21 公共部分是 2*2，这里有两个
40:23 他们之中有三个，其中两个有五个
40:38 是的，60，这里是每20乘以
40:40 7 表示 140 伏安，我们得到
40:42 这样的数据在手指上清晰可见。
40:45 很难立即对他们进行评估。
40:47 我们原本不会想到这一点，但如果我们采取
40:49 我们不妨举个例子，看看其中任意一对。
40:53 我们会得到一对，其中 dbd 为 2*2*3
40:57 所以这等于 4*3，也就是 12。
40:59 如果我们接受这些，我们会得到这个结果。
41:03 4*7 等于 28，如果我们取
41:05 我们会把它变成 20 o
41:08 三个数字的真实DBD是4
41:11 所以现在我们不能像这样只取最低限度了。
41:12 这意味着如果我们猜对了
41:14 我们需要采取我们所能采取的最低限度措施。
41:17 我们大错特错，而且错得非常明显。
41:19 我们可以测试一下，也许测试能发现问题。
41:22 那么，这个想法就很好。
41:24 这意味着什么？我们如何思考？
41:26 因为我们需要找到那里的交点。
41:30 大概有八个，84、140，我猜的。
41:34 别忘了，60年前的事可能和我们现在的情况不一样。
41:36 我们可以尝试交叉路口。
41:38 我们想知道，如何才能提出拒绝意见？
41:43 那么我们该怎么办？我们取84吗？是的
41:48 指最公分母
41:50 除数，所以我们已经有了算法
41:52 所以接下来会发生这样的事。
41:57 24 60 24 这里将是 36
42:07 24 会变成 12，这里的 24 12 会变成零，我们得到
42:11 现在它们的交集是 12，看看
42:14 这两个数字是什么意思？
42:16 最大公约数是
42:20 12 这不可能是最大公约数
42:23 当我们……时，除数大于这个值
42:25 我们再加一个数字，这样我们就有了
42:27 我们已经想好怎么处理这些东西了。
42:31 我们去掉了数字12，所以如果是
42:35 是的，如果真是那样，我们就采取了
42:43 这些数字给出了答案。
42:45 很好，如果没有第三个的话。
42:47 这个数字是 12，答案是：
42:49 现在还有另一个数字，问题是……
42:51 这个数字是不是有什么玄机？
42:54 与此冲突的是，我们有140个东西。
42:57 至于第12点，我们会看看会发生什么。
43:01 现在是140和12，所以是140。
43:03 我们计算最大公约数
43:04 这里已经有前作的DBD版本了。
43:07 剩下的部分是八，你看。
43:16 将 12 和 8 改写为 4，得到 8 和 4
43:18 我们得到零，我们得到有四个。
43:19 两个数的最大公约数
43:21 事情就是这样，这才是真正的答案
43:23 如果我们有
43:25 更多数字表明，这一点显而易见。
43:28 我们只需要
43:33 迭代地不断计算
43:35 求数的最大公约数
43:38 他们成对出现，而且总是两个一组。
43:40 我们始终生成一个属于他们的号码。
43:42 最大公约数，就这些了。
43:44 这使我们能够设计一个算法
43:46 是的，类似的事情，我们可以再做一次。
43:49 测试其是否有效
43:51 事实上，我们依赖于其他人。
43:53 我们的想法基于现有的事物。
43:56 从算法上来说是这样，但在这种情况下，它指的是
44:00 那么，我们该如何思考这个问题呢？
44:02 这样可以吗？
44:05 是的，或者用你的想法来检验一下。
44:07 也就是说，并不是我们拿走了它。
44:09 现在我们立刻就知道它在这里。
44:11 这就是答案，我们能做到。
44:19 我们创建了一种算法，所以我们
44:21 我们试着核实了一下，所以现在的意思是
44:22 我假设这一点很清楚
44:24 你怎么用手指做到这一点？
44:27 你可以编写一个程序来输入各种内容。
44:29 是
44:33 好的，那就这样吧，我们继续。
44:35 我们要走了，他们却告诉我们，我们不在这里。
44:37 所需的最小公倍数是多少？
44:40 这确实是一个数字，是的。
44:44 其中 n 和 m 都是 的约数
44:46 最小的这类数是的，那就是
44:50 最小公倍数，嗯，那就是 t 如果
44:52 我们应该找一个，这样我们就可以
44:55 想想看，谷歌这个魔鬼可不会把它扔掉。
44:57 答案，但如果我们知道
44:59 稍微算一下数学，我们就可以
45:02 请注意，它实际上是最小的。
45:06 根据这个公式，现在这里是什么？
45:09 这里是数字的乘积，所以这里
45:10 很明显，这件事是真的。
45:17 数字的质因数重叠
45:18 这样我们就只有一个除数了。
45:21 我们也用它两次。
45:22 仅在我们分割后使用
45:26 根据定义，我们已经知道
45:28 我们知道怎么数数，我们知道怎么数数。
45:30 乘以我们，我们就能做好这件事。
45:35 现在我们不必再考虑这个问题了。
45:36 我们直接拿走就行了。
45:40 现在我们继续前进。
45:43 问题是，如果我们……该怎么办？
45:47 直觉可能会说，好吧，我们就这么办吧。
45:51 现在我们来计算这三个数的最大公约数。
45:56 再次提醒，你需要检查一下这个。
45:58 我们来试着这样检查一下手指。
46:00 例如，如果已知我拥有
46:05 大约四个10分，还有一些其他的
46:09 我不知道，比如说七。
46:13 那么这些数字的乘积将是
46:16 280，是的，这确实是倍数。
46:19 因为这些是除数，所以结果是 280。
46:22 能被7、10和4整除
46:25 现在这是否是最小的？可能不是。
46:28 那个公式不是
46:30 他们告诉我们需要带什么。
46:33 乘积并除以最大
46:35 现在的问题是，公因数是什么？
46:38 是这些数的最大公约数
46:40 在所有数字中，它是一个单位，因为
46:43 七是质数，这意味着
46:45 也许如果我们尝试这样做的话
46:48 天真地说，这就是它。
46:50 这是最小公倍数
46:52 但后来却发现事情很奇怪。
46:54 如果我们尝试一下会怎样
46:57 为了进一步分析，这四个是什么？
47:01 这是 2*2 等于 10，这是 2*5 等于 10。
47:04 七是什么？这是七
47:07 这就是这些东西现在的样子 元素
47:08 元素
47:11 工会？是的，我们真的需要它。
47:14 两个双人组，一个双人组，我们已经
47:16 我们需要一到五个，我们
47:19 我需要拿七块钱，所以就拿下这块吧。
47:24 多次选择“是”，因为我对此真的很感兴趣。
47:27 我真的需要这些，我也需要。
47:28 我真的需要一张七号牌，所以我来了。
47:30 我只拿走了那些部分
47:33 现在真的有必要，这里的东西就在这里。
47:37 4*5等于20*7等于140，这意味着如果
47:42 谁会说这些药必须服用？
47:44 最大公约数，并从中得出
47:46 如果我把它分成两半，那就错了。
47:49 是的，测试结果可能再次证实这一点。
47:51 外观指的是真实事物的样子。
47:54 这可能是真正的公式
47:56 如果我……公式看起来是这样的
47:58 我想要最小的倍数 数字
47:59 数字
48:05 在此我再次提醒各位，我们曾
48:10 4 107 我们说 2* 2 2* 5 和 7 我们说
48:13 正确答案是 140，也就是 2*
48:16 2*5*7，所以看看我们什么时候在这里拍的。
48:19 我们说a b c，我们把这些都倒了。
48:22 所以我们得到了顶部的数字 2* 2* 2*
48:25 5*7，我们发现我们是两个之一。
48:27 一次，两次，吃太多了
48:34 如果这里是，那么它就会重复。
48:36 这些数字远远超过我们所需的数量。
48:39 丢弃所有重复单元
48:41 如果这里有两个相同的人，是哪一个呢？
48:44 重复两次，所以这意味着我们
48:47 必须取并除以最大的
48:49 这里的公因数来自两个
48:51 如果某事在这里重复了两次
48:53 现在就拿一个，它可能就在这里。
48:57 重复两次
49:04 是的，你可以
49:13 除以最大公倍数
49:16 除数，现在你可以注意到这一点了。
49:18 如果这里到处都有单位的话
49:20 这些数字互质，也就是说
49:23 我们将这样得到那个真实数字。
49:25 如果结果证明这些
49:29 这些数字将呈现重复的模式。
49:32 那么这个公式就会变成这样
49:34 现在应该没事了。
49:39 因为我们还能再做一次，那就再做一次吧。
49:41 一个真正能考验我们的例子
49:45 假设这是两个 2 和两个全部
49:53 类似上面提到的那种。
49:56 八号现在是最大的
50:11 事情二，结果发现……
50:13 这件事必须要做，必须推广开来。
50:17 从这个最大公约数可以看出，这三个数字都是如此。
50:19 我们不必分享，但是
50:38 也就是c，所以当我们乘以
50:41 我们明白了这一切。
50:44 是的，我们也会去这些地方。
50:48 我们多次取走了碎片，那又怎样？
50:52 拿走这些，拿走这些，拿走那个
50:55 如何服用？你需要服用这个和
51:00 把这个扔掉，把这个也扔掉。
51:06 这里的部分意思是……
51:09 该部分只能计数一次。
51:11 一次哦不哦不哦不哦不好几次
51:29 那么我们想做什么？我们想拿走它。
51:41 我们已经扔掉它太多次了。
51:47 集合与离散数学
51:48 友谊需要你花时间去体会。
51:50 你会找到答案的，你会把它们全都写下来。
51:53 你会看到这样的元素，但这里是它。
51:55 举例说明我能做到的方法
51:57 用来分析某事和
51:59 这取决于我如何
52:02 我理解这项任务，或者说我可以完成它。
52:04 解决这个问题是否有效，以及为什么天真
52:06 我接受和假设的方式
52:08 我再拿一个。
52:11 我还要补充一点，有时候事情并非如此简单。
52:13 你又一次需要降低对自己的信心，因为
52:15 但直觉并非总是如此。
52:18 展望未来，简而言之就是：
52:21 概括有时可能并非如此
52:23 从两个方向移动时，这很容易理解。
52:25 你需要做三件事，你需要做
52:27 假设法律有效，如果
52:30 还记得我们之前谈到……的时候吗？
52:33 周期性出现的例子
52:35 在某个地方，嗯，我们举例子中提到过。
52:37 你很容易就能抓住法律的本质。
52:39 问题在于，法律究竟是什么，这一点完全不清楚。
52:40 如果我们理解他是
52:42 简单固然好，但如果我们理解了
52:45 事情比这要复杂一些。
52:47 那么，如何以及什么就不清楚了。
52:49 你需要完全按照这个格式来写。
52:50 这个例子说明了
52:52 搬到三并不意味着这里
52:53 我们拿过来，然后根据需要写信。
52:56 稍微想想会发生什么。
52:59 这就引出了算法评估的问题。
53:01 当然，是的，这意味着我们那些
53:03 我们只能想出有限数量的算法。
53:06 他们想要的只有一件事，那就是他们拥有
53:08 仍然给我们一个正确的答案。
53:10 还有一点是，可能存在那些
53:15 那么问题就变成了：哪个更好？
53:17 当然，天然的更好，就是这样。
53:19 这样可以减少资源消耗。
53:22 现在有很多不同的资源，时机已经成熟。
53:24 这意味着处理器必须工作，并且
53:26 这浪费了我们宝贵的时间。
53:28 还有一点就是记忆力。
53:30 记忆力在以前非常重要。
53:32 这件事现在看来仍然很重要。
53:34 如果我们写一些卫星在那里
53:39 价格昂贵，但通常人们都会去那里。
53:42 当网络速度很快的时候，当……
53:43 内存是在那里计算的。
53:47 千兆字节、太字节，还不够。
53:49 那个内存容量并不大。
53:51 问题在于时间非常漫长。
53:56 为了简单起见，我们还能说什么呢？
53:58 我们会处理好一切。
54:01 评估我们的算法如何运作
54:03 就时间而言，这就引出了……
54:05 算法复杂度的概念
54:08 很多人都不明白这一点
54:09 因为他们想象……
54:12 复杂性和效率是相同的。
54:14 这通常就是我们所说的有效的时候。
54:17 我们所说的算法是指一切
54:19 包括对此进行实证评估
54:21 “基于经验”是什么意思？
54:23 练习，嗯，那就意味着我放手了。
54:24 我测试了该应用程序的运行时间和耗时。
54:27 它奏效了，我惊叹道：哇，三秒钟就搞定了！
54:29 是的，这就是经验估计的问题所在
54:31 时间也取决于
54:33 编程语言以及来自设备和
54:36 来自很多不同的事物，然后
54:41 当我们使用这些物理参数时，算法就会发挥作用
54:44 那时我们就没有那种理论上的比较了。
54:47 其设计目的是为了让我们能够采取和
54:49 我们来数数走了多少步
54:53 然后是迈步的人
54:55 性能较差，我们将假设它是
54:58 好，这是一个很好的想法，也是个非常好的问题。
55:01 也就是说，每一步都不是等同于每一步
55:03 例如，某些除法运算
55:05 比任何金额都更昂贵
55:07 一种语言中的函数调用可以
55:17 我们正在比较两个篮子和一个篮子
55:20 有3000颗蓝莓，我不知道。
55:22 另一个篮子里放着卫生纸
55:25 我们放了两个油箱，所以现在有两个了。
55:28 比那里的瘀伤要少，或者
55:34 这是人类发明的，因为
55:37 我们无法评估一步操作
55:54 这意味着我们不进行比较，例如或
55:56 该算法在那里执行的操作量是原来的两倍。
56:35 我有很多东西。
56:40 然后尝试比较这两个数据。
56:43 基于步骤数的算法，即
56:45 很明显，如果这些算法是好的。
56:47 他们的工作时间取决于此。
56:51 数据中，总步数将是
56:53 无限，是的，一切都无限运作。
56:56 时间很长，但问题是在哪里？
56:58 在这里，无限也更加伟大。
57:00 事实证明我们不能从
57:02 从一个无穷大中减去另一个无穷大，并期望
57:04 买点聪明的东西，但这就是它。
57:06 数学家发明的工具，
57:09 我们可以这样计算出一些限制。
57:12 这些关系最终会指向何方？
57:14 相反，各种各样的符号出现了。
57:16 哪些人被认为是
57:19 尤其是那些学习数学分析的人
57:21 那些未来还会继续学习的人，或者
57:23 在黑暗中，取决于多少
57:25 我喜欢数学，这或许看起来是这样。
57:27 各种各样的想法是，我们
57:29 你能想象这里是什么样子吗？
57:31 我们迈出的那几步
57:34 算法 f 和 g 是函数，
57:36 估计算法步骤数，即
57:38 这里似乎存在某种算法。
57:40 n 就是所需步骤数。
57:43 当有 n 个数据时，算法 f 和
57:44 因此，需要多少步？
57:50 现在可能有五种选择，是的。
57:52 他们的步数可能是
57:55 同样的情况也可能是，左边那个占据了
57:57 少一点，也许这个占用的空间更小。
58:00 所以现在这段文字只是
58:04 问题在于……
58:06 左右无限就是我们。
58:10 向右无限远似乎是
58:11 一样，但结果却并非如此，嗯。
58:17 我们不能讲这样的笑话。
58:20 意思是想象一下它是这样的
58:23 情况是这样的，我们有一家酒店，
58:26 还有数不胜数的房间等着你去发现。
58:50 家中只有一人，然后他的家人来了。
58:57 我说第一个人
59:09 当我这样做的时候，一切就会突然变得清晰起来。
59:14 所有单号房间都将免费，
59:21 我可以带走我数数的孩子们
59:37 确定性措施
59:39 允许我们评估等式的符号
59:46 这意味着该算法有效。
60:04 有个小欧米伽，他/她只是 专用的特殊证书
60:06 专用的特殊证书
60:11 对于无穷大而言是不定的，但允许
60:18 是的，正确的尺寸是无限大的。 所以我们会说类似这样的话：左边这一个
60:21 所以我们会说类似这样的话：左边这一个 该函数有点偏离
60:24 该函数有点偏离 如果这是函数的右侧
60:27 如果这是函数的右侧
60:32 意思是如果左边是无穷大 比右边小，所以我们说o
60:34 比右边小，所以我们说o
60:50 再次无穷大，来自来自
60:58 这个算法是更好还是更差？
61:27 那它就什么也不做，所以也许是这样
61:34 数据排序相反 秩序，这意味着需要很多时间。
61:36 秩序，这意味着需要很多时间。 步骤 这是最糟糕的情况 这是
61:38 步骤 这是最糟糕的情况 这是 意味着尽可能少的步骤
61:40 意味着尽可能少的步骤 嗯，你可能需要它，那么最多是多少呢？
61:42 嗯，你可能需要它，那么最多是多少呢？ 很明显，我们能够处理这些案件。
61:44 很明显，我们能够处理这些案件。 需要进行检查，因为它们通常是
61:46 需要进行检查，因为它们通常是 说了一些关于……和……的事情
61:50 说了一些关于……和……的事情
61:54 我们对两件事不感兴趣，最好的
61:58 这意味着在平均情况下我们做得有多好 我们可以预期，从数学角度来看，
62:00 我们可以预期，从数学角度来看， 这可以表述为：我们考虑所有
62:02 这可以表述为：我们考虑所有 让我们来统计一下可能的数据集。
62:04 让我们来统计一下可能的数据集。
62:08 这些不同的数据集有多少个？ 是的，现在很明显，有可能就是这样。
62:12 是的，现在很明显，有可能就是这样。 这些数据集并不相等。
62:14 这些数据集并不相等。 如果有可能，我们可以去不同的地方。
62:16 如果有可能，我们可以去不同的地方。 口服重物等等
62:18 口服重物等等 而我们更感兴趣的，是最糟糕的情况。
62:20 而我们更感兴趣的，是最糟糕的情况。 这种情况通常是因为我们可能
62:23 这种情况通常是因为我们可能 我并不在意我们是否处于最佳状态。
62:25 我并不在意我们是否处于最佳状态。 我们马上就做，但是如果
62:27 我们马上就做，但是如果 最坏的情况是我们得等10天。
62:28 最坏的情况是我们得等10天。
62:32 最坏的情况，这实际上是一种保证
62:39 当然，仔细想想，这很重要。 当我们理解算法时，就应该理解它。
62:42 当我们理解算法时，就应该理解它。 我们知道它们工作效率有多高。
62:44 我们知道它们工作效率有多高。 需要再仔细想想……
62:46 需要再仔细想想…… 在某些情况下，因为情况可能如此
62:48 在某些情况下，因为情况可能如此 我选择该算法是基于……
62:49 我选择该算法是基于……
62:55 我应该取平均值，而不是那个
63:00 最后，通常还会做以下事情：
66:27 如果规模小，我们可以问“好的”。 哇，这真是所有数字的总和。
66:31 哇，这真是所有数字的总和。 是的，最大的成员，这些成员会
66:34 是的，最大的成员，这些成员会 这里列出的是这位成员
66:36 这里列出的是这位成员 非常肯定地说，
66:38 非常肯定地说， 需要注意的是，有些
66:40 需要注意的是，有些 例如，对数就有点像个笑话。
66:42 例如，对数就有点像个笑话。 比 n 慢，是的，任何 n
66:46 比 n 慢，是的，任何 n 度数边在这里是根部，这里
66:49 度数边在这里是根部，这里 n=15，这意味着我们正在寻找哪里
66:52 n=15，这意味着我们正在寻找哪里 是最高学位
66:56 是最高学位 对那位成员来说，然后因为我们
66:59 对那位成员来说，然后因为我们 我们说我们在数步数
67:01 我们说我们在数步数 数字，我们完全低估了数量。
67:03 数字，我们完全低估了数量。 迈出一步，这意味着什么？或者在这里
67:06 迈出一步，这意味着什么？或者在这里 一半还是100对我们来说都无关紧要，一半就够了。
67:08 一半还是100对我们来说都无关紧要，一半就够了。 油箱和100颗蓝莓，现在选哪个？
67:11 油箱和100颗蓝莓，现在选哪个？
67:16 有人说…… 我们还是忽略那些吧。
67:18 我们还是忽略那些吧。 有限数和常数
67:20 有限数和常数 让我们允许存在一定的准确性误差，也就是说，
67:23 让我们允许存在一定的准确性误差，也就是说， 假设有可能存在这种情况：
67:26 假设有可能存在这种情况： 步骤较少，但这些步骤是
67:27 步骤较少，但这些步骤是 价格更高，步骤也更多，但
67:30 价格更高，步骤也更多，但 也许那些步骤更便宜，是哪一种呢？
67:32 也许那些步骤更便宜，是哪一种呢？ 是更大还是更小，目前尚不清楚我们
67:35 是更大还是更小，目前尚不清楚我们 我们希望将这个想法付诸实践。
67:37 我们希望将这个想法付诸实践。 我们可以比较这些程序并得出结论
67:39 我们可以比较这些程序并得出结论 所以这个方法可能有效1万次
67:42 所以这个方法可能有效1万次 速度更快，但关键事项却更慢。
67:44 速度更快，但关键事项却更慢。 不是，但关键可能在于……
67:47 不是，但关键可能在于…… 那么，这个100代表什么？它在这里又意味着什么？
67:49 那么，这个100代表什么？它在这里又意味着什么？ 意味着 0 vi 不明确，所以我们正在寻找
67:52 意味着 0 vi 不明确，所以我们正在寻找 仅此而已，也就是说，我们拒绝一切。
67:55 仅此而已，也就是说，我们拒绝一切。 这里被拒绝的项乘以了什么？
67:57 这里被拒绝的项乘以了什么？ 我们只关注这个数字。
67:59 我们只关注这个数字。 它本身就构成了无穷，因为
68:01 它本身就构成了无穷，因为 这里是无穷大，这里是无穷大，是的，这个
68:05 这里是无穷大，这里是无穷大，是的，这个 不管你喜不喜欢那个酒店例子，对吧？
68:06 不管你喜不喜欢那个酒店例子，对吧？ 我们是如何安置这些孩子的？就像
68:08 我们是如何安置这些孩子的？就像 变得比无穷大两倍，而什么
68:11 变得比无穷大两倍，而什么 它仍然是一家酒店。
68:12 它仍然是一家酒店。 这么多房间，所以现在
68:14 这么多房间，所以现在
68:18 它们在哪里？尺寸大约是这样的吗？ 我们自己都对那玩意儿嗤之以鼻。
68:21 我们自己都对那玩意儿嗤之以鼻。 单层或双层都更大
68:23 单层或双层都更大
68:28 这就是括号里的内容。 上面写着这是某种函数
68:30 上面写着这是某种函数 取决于名词 n，所以是哪个名词
68:33 取决于名词 n，所以是哪个名词 算法序列，以及那个，还有这个大问题
68:36 算法序列，以及那个，还有这个大问题 在这种情况下，这意味着这是某件事
68:39 在这种情况下，这意味着这是某件事 现在还有什么不会超出这个范围呢？
68:42 现在还有什么不会超出这个范围呢？
68:47 例如，如果我有 100n
68:55 与 001 n 平方相比，这里的 n 将为 将会像现在这样趋近于无穷大。
68:59 将会像现在这样趋近于无穷大。 如果我将此与 n 平方进行比较
69:02 如果我将此与 n 平方进行比较 而且这似乎小于 n
69:05 而且这似乎小于 n 没错，确实如此，而且显然如此。
69:07 没错，确实如此，而且显然如此。 因为这里 n 的平方只占很小一部分，但是
69:09 因为这里 n 的平方只占很小一部分，但是 现在我们来看这里，它在这里。
69:11 现在我们来看这里，它在这里。 让我们看看这里每个 n 平方 1
69:13 让我们看看这里每个 n 平方 1 写出来的，这里甚至还有100篇呢。
69:16 写出来的，这里甚至还有100篇呢。
69:21 这是一个实际函数，这是 只有行被命名了，这是什么意思？
69:24 只有行被命名了，这是什么意思？ 这段铭文意味着这种不平等
69:27 这段铭文意味着这种不平等 小于或等于是正确的
69:29 小于或等于是正确的 铭文“o”大写是正确的。
69:32 铭文“o”大写是正确的。 如果我们能想出类似这样的东西……
69:35 如果我们能想出类似这样的东西……
69:45 如果这里有 100，请找出一个常数。 我们取 1000 作为我们的 k 值，
69:48 我们取 1000 作为我们的 k 值， 那么这里我们将有 k 1000 n^ 和 1000 n^
69:52 那么这里我们将有 k 1000 n^ 和 1000 n^ 确实比这大得多，是的。
69:54 确实比这大得多，是的。
70:18 100n 等于多少？
70:25 即使在这里，你看，n^v 也更小。 似乎我们每个人都可能遇到这种情况
70:27 似乎我们每个人都可能遇到这种情况 我们会说，我们会试着说，哦，伟大的
70:29 我们会说，我们会试着说，哦，伟大的
71:15 我亲眼所见。
71:20 它在这里长得像个正方形。
71:48 线性复杂度是指很多步骤 大约，并且大约需要不能
71:50 大约，并且大约需要不能 更多可能更少也可能
71:51 更多可能更少也可能 更昂贵但更便宜的步骤，但很重要
71:53 更昂贵但更便宜的步骤，但很重要 它们是如何增长的，对数增长得非常快。
71:55 它们是如何增长的，对数增长得非常快。 缓慢增长，n log n 略微加快 n
71:58 缓慢增长，n log n 略微加快 n 平方更快，立方更快。
72:00 平方更快，立方更快。 这里是 2 lan n，它是指数函数。
72:03 这里是 2 lan n，它是指数函数。 复杂性，现在你可以想象了
72:06 复杂性，现在你可以想象了 意思是如果我的数据很少
72:08 意思是如果我的数据很少 例如，八这个数字并不吓人。
72:10 例如，八这个数字并不吓人。 我的指数意味着
72:13 我的指数意味着 该算法是
72:15 该算法是 现在我们有很多步骤可以
72:18 现在我们有很多步骤可以 告诉我，哦，不是那样的，那是我。
72:20 告诉我，哦，不是那样的，那是我。 我注意到，甚至还有一个立方体
72:21 我注意到，甚至还有一个立方体 看起来情况更糟，但它在这里长得非常糟糕。
72:24 看起来情况更糟，但它在这里长得非常糟糕。
72:28 也就是 n，你想象一下你的 该算法是指数型的，所以你会有
72:30 该算法是指数型的，所以你会有 两天之内你就能尽可能多地收到这个。
72:33 两天之内你就能尽可能多地收到这个。 比粒子数量更多
72:35 比粒子数量更多 在宇宙中，然后说，那，那
72:39 在宇宙中，然后说，那，那 一台好的电脑会救你，可惜的是，这对你来说却是个坏消息。
72:41 一台好的电脑会救你，可惜的是，这对你来说却是个坏消息。 这样对人们没有帮助。
72:43 这样对人们没有帮助。 试图解决复杂问题
72:46 试图解决复杂问题 一直在寻找更好的算法
72:48 一直在寻找更好的算法
72:52 log n，所以它们非常简单。 诸如此类的任务
72:54 诸如此类的任务 可以在这段时间内解决
72:56 可以在这段时间内解决 数量很少，而且这些都比较复杂。
72:59 数量很少，而且这些都比较复杂。 他们通常有的任务
73:02 他们通常有的任务 非常复杂，结果发现那部分
73:04 非常复杂，结果发现那部分 有些任务已被证明是可行的。
73:07 有些任务已被证明是可行的。 不可能存在多项式时间，
73:09 不可能存在多项式时间，
73:14 不是千分之一，而是某种东西 到 n 的程度，它们会变得非常非常
73:16 到 n 的程度，它们会变得非常非常 仔细看，它的尺寸翻了一倍。
73:18 仔细看，它的尺寸翻了一倍。 数据量很大，突然就出现了。
73:21 数据量很大，突然就出现了。 是的，步骤非常多。
73:23 是的，步骤非常多。 因此，那里人很多。
73:25 因此，那里人很多。
73:29 为了找到更高效的算法 各种各样的近似值，例如
73:31 各种各样的近似值，例如 使这些任务成为可能
73:32 使这些任务成为可能 一般情况下，你可以用语言来解决这个问题。
73:35 一般情况下，你可以用语言来解决这个问题。 对不起，我在这里做什么？我在这里做什么？
73:38 对不起，我在这里做什么？我在这里做什么？ 我编写了算法，它是什么？
73:40 我编写了算法，它是什么？
73:44 可以这样想： 现在循环这是 o dysis 现在 n 如果
73:47 现在循环这是 o dysis 现在 n 如果 循环，循环，现在是循环的结束。
73:49 循环，循环，现在是循环的结束。
73:53 哦，最大的那个是立方体，以此类推。 不总是如此，因为这取决于……
73:55 不总是如此，因为这取决于…… 这些循环内部发生了什么，但是，但是，
73:58 这些循环内部发生了什么，但是，但是， 但是意思是，但是，但是这种事确实会发生。
74:00 但是意思是，但是，但是这种事确实会发生。 当我们应用以下公式时，就会出现对数：
74:03 当我们应用以下公式时，就会出现对数： 分而治之的手段
74:05 分而治之的手段
74:11 将其分成两个较小的部分
74:14 不管权利如何，然后 原来我们都面临着同样的问题。
74:16 原来我们都面临着同样的问题。
74:20 看看这个正方形，什么才算是一个循环？
74:29 换句话说，分而治之的策略很重要。
74:38 这是一个突如其来的变化 接下来还有什么重要的事情要做？
74:41 接下来还有什么重要的事情要做？ 了解算法很重要。
74:43 了解算法很重要。 一般来说可以分为两类。
74:45 一般来说可以分为两类。 类别是迭代的，并且
74:47 类别是迭代的，并且 递归算法及你需要了解的内容
74:50 递归算法及你需要了解的内容
75:06 迭代 第二次 第三次 第四次 第五次
75:10 该项目应该再次关注。 这方面存在很多问题。
75:12 这方面存在很多问题。
75:19 阶乘计算和一些 用户 asa，此处没有验证。
75:22 用户 asa，此处没有验证。 并且从一开始就未初始化
75:25 并且从一开始就未初始化
75:30 我们还是别深入讨论这个问题了，我
75:36 这里的函数只是打印了以下内容。
75:44 这样做，自然而然就会做到。
75:48 我们之前讨论过如何发挥功能。
75:52 让我们来看看算法本身是什么样子的。 这就是循环的初始阶段。
75:54 这就是循环的初始阶段。
76:36 我在此强调，这是…… 效率更高，但其复杂性也会更高。
76:38 效率更高，但其复杂性也会更高。 完全一样，因为什么？因为那个？
76:40 完全一样，因为什么？因为那个？ 你应该估算一下这里有多少步。
76:41 你应该估算一下这里有多少步。 需要，他们需要大约n，是的。
76:43 需要，他们需要大约n，是的。 意思是如果 n 无限大，那么
76:46 意思是如果 n 无限大，那么 步骤的数量正好是我们所需要的。
76:49 步骤的数量正好是我们所需要的。 这里有多少数据？我们知道这一点。
76:51 这里有多少数据？我们知道这一点。 这里是乘法，这里是等式，这里是减法
76:54 这里是乘法，这里是等式，这里是减法 缺点是这里仍然存在一些跳跃性。
76:56 缺点是这里仍然存在一些跳跃性。 我们只是大致估算一下步骤数量，
76:58 我们只是大致估算一下步骤数量， 我们自己决定采取哪一步
77:00 我们自己决定采取哪一步 是的，它不是n的平方。
77:02 是的，它不是n的平方。 步骤和不固定数量 是 否
77:04 步骤和不固定数量 是 否 我们知道，对数是一系列步骤。
77:07 我们知道，对数是一系列步骤。
77:22 其他算法都是递归的，因此 如果我们设想我们有
77:24 如果我们设想我们有
77:29 嗯，它可能看起来像这样，对吧？ 这里有一些数字，我们这里有一些东西。
77:31 这里有一些数字，我们这里有一些东西。 所以我们得到了这个，并且得到了一些代码。
77:34 所以我们得到了这个，并且得到了一些代码。 有可能存在递归
77:35 有可能存在递归 根据递归的实现
77:37 根据递归的实现
77:42 现在它面向某些人
77:45 正因为如此
77:59 这个号码仍然会返回一些内容。
78:05 因为零的阶乘是一，而且如果 他比我们所做的一切更伟大。
78:08 他比我们所做的一切更伟大。 我们取该数字并乘以
78:10 我们取该数字并乘以
78:19 我将尝试计算 4*3 的阶乘。 阶乘，好吧，我就这么说吧。
78:20 阶乘，好吧，我就这么说吧。
78:36 他们想象自己来自我所处的那个地方 我调用的是同一个函数，而且
78:38 我调用的是同一个函数，而且
78:54 他创作的方式并非编写代码。 记忆中的球就在下方
78:56 记忆中的球就在下方 它徘徊着，那里似乎有什么东西。
78:58 它徘徊着，那里似乎有什么东西。
79:06 这些控制权的转移正在发生，
79:14 人们或许需要这样想象。
79:19 该功能是在内存中创建一个块。 这反映了它的功能。
79:21 这反映了它的功能。 如果我说精细阶乘，这里
79:22 如果我说精细阶乘，这里 我给了三个，所以现在有
79:24 我给了三个，所以现在有
79:30 实现该功能所需的物品
79:46 一块内存，它有
81:32 我调用了这个函数，然后在这里 由于这个已经返回了两个，所以这个将有
81:35 由于这个已经返回了两个，所以这个将有 值三就是它将返回的全部内容
81:37 值三就是它将返回的全部内容 六，然后我说返回，是的
81:40 六，然后我说返回，是的 我又不是在闲逛。
81:41 我又不是在闲逛。 紧接着内存中的同一块，像这样
81:44 紧接着内存中的同一块，像这样 也就是说，你应该认为我就是每一个
81:46 也就是说，你应该认为我就是每一个 每次我调用该函数时
81:48 每次我调用该函数时 我现在正在创作一些像这样的新作品。
81:52 我现在正在创作一些像这样的新作品。 你应该想想那到底是什么。
81:54 你应该想想那到底是什么。 我应该选择哪种算法，迭代算法还是其他算法？
81:56 我应该选择哪种算法，迭代算法还是其他算法？ 递归是常态
81:59 递归是常态 任何递归算法都可以
82:02 任何递归算法都可以
82:09 很久很久以前，当我们还在学习的时候 在计算机科学领域，我们的老师非常
82:11 在计算机科学领域，我们的老师非常
82:15 这是为那些对我感兴趣的人准备的。 问我，我会给你链接。
82:17 问我，我会给你链接。 你将能够
82:18 你将能够 一般而言，阅读是指
82:21 一般而言，阅读是指 你应该把它看作是迭代的
82:24 你应该把它看作是迭代的 你应该选择这个选项。
82:27 你应该选择这个选项。 作为一种标准，原因就在于此。
82:31 作为一种标准，原因就在于此。 它更有效，因为
82:33 它更有效，因为 因为这样对他来说速度更快。
82:35 因为这样对他来说速度更快。 无需那些新的瓦特内存块
82:37 无需那些新的瓦特内存块 函数要应用
82:39 函数要应用 是的，但重点是其中有一部分
82:42 是的，但重点是其中有一部分 任务，尤其是那些有……的任务
82:43 任务，尤其是那些有……的任务 休息和
82:45 休息和 控制力会迭代地变得非常强
82:48 控制力会迭代地变得非常强 难就难在事情会朝着不同的方向发展。
82:50 难就难在事情会朝着不同的方向发展。 结果发现，其中一次迭代有
82:52 结果发现，其中一次迭代有 制作两个新的，如果我这样做的话
82:54 制作两个新的，如果我这样做的话 我做事都是反复迭代的，这就是我得到的结果。
82:56 我做事都是反复迭代的，这就是我得到的结果。 一次又一次的迭代，如果它们
82:58 一次又一次的迭代，如果它们
83:14 写起来更容易，也更容易
83:20 代码运行速度变慢通常是因为这个原因。 其中有函数调用等等。
83:21 其中有函数调用等等。 内存使用量是因为这些
83:23 内存使用量是因为这些 目前，功能块是这样创建的。
83:26 目前，功能块是这样创建的。 总之
83:28 总之
83:33 会结束，因为如果我们循环 写这篇文章时，我们可能会陷入一个永恒的循环。
83:36 写这篇文章时，我们可能会陷入一个永恒的循环。 完全相同的情况也可能
83:38 完全相同的情况也可能 递归的情况下也会发生这种情况。
83:41 递归的情况下也会发生这种情况。 这意味着可能存在无限递归，其中
83:43 这意味着可能存在无限递归，其中 我们一直打电话，我们一直打电话
83:44 我们一直打电话，我们一直打电话 只属于我自己，永不回头，那就是我。
83:47 只属于我自己，永不回头，那就是我。 我注意到，当时确实有那么一刻。
83:48 我注意到，当时确实有那么一刻。 当我们不再称阶乘为
83:50 当我们不再称阶乘为 这些函数，我们说只要返回它们就行了。
83:52 这些函数，我们说只要返回它们就行了。 意思很简单，还有什么比这更微妙的呢？
83:55 意思很简单，还有什么比这更微妙的呢？ 只要我……，循环就能运转。
83:58 只要我……，循环就能运转。 我想要无限递归，但是
84:00 我想要无限递归，但是 每次都会产生记忆
84:03 每次都会产生记忆 一个新的函数块以及什么
84:06 一个新的函数块以及什么 然后就会形成长期记忆。
84:07 然后就会形成长期记忆。 它填满了，然后就会发生堆栈溢出。
84:10 它填满了，然后就会发生堆栈溢出。
84:17 这里的一切都是自然的。
84:22 需要是指如果我需要
84:33 递归只是漫无目的地浏览菜单
84:43 用 return 代替 return 反复调用同一个函数
84:46 反复调用同一个函数 你产生了递归，并且你的回报
84:47 你产生了递归，并且你的回报 清除之前菜单的历史记录。
84:50 清除之前菜单的历史记录。 你不再需要的积分，你已经
84:52 你不再需要的积分，你已经 你可以完成它们，然后从你那里回来。
84:54 你可以完成它们，然后从你那里回来。 但你并没有做，这就是原因。
84:56 但你并没有做，这就是原因。 你邀请了一位新朋友，这仅仅意味着你
84:58 你邀请了一位新朋友，这仅仅意味着你 原则上编写一个低效算法
85:00 原则上编写一个低效算法 这会浪费你电脑的资源。
85:03 这会浪费你电脑的资源。 换句话说，这就是递归。
85:04 换句话说，这就是递归。 应该在必要时进行，而不是
85:07 应该在必要时进行，而不是 然后，当你只是想这么做的时候，因为你可以。
85:10 然后，当你只是想这么做的时候，因为你可以。 现在还剩下一些算法，
85:12 现在还剩下一些算法， 值得
85:13 值得 讨论哪些例子可以说明它是如何做到的
85:15 讨论哪些例子可以说明它是如何做到的
85:19 是的，这意味着我们现在要执行任务了。 我们正在讨论的是一个搜索任务，这是其中之一。
85:22 我们正在讨论的是一个搜索任务，这是其中之一。
85:53 在数据集中找出值 8。
86:15 数据行，一行一行地 我正在研究它的运作方式。
86:17 我正在研究它的运作方式。
86:24 等等等等，或者八等于八，是的 我找到一个，也许就此打住吧。
86:27 我找到一个，也许就此打住吧。 另一个任务是查找所有
86:29 另一个任务是查找所有 然后数一数有多少个
86:31 然后数一数有多少个
86:36 那么显然很容易看出，我可能 我需要它，或许我需要整份清单。
86:39 我需要它，或许我需要整份清单。 回顾一下，这就引出了……
86:40 回顾一下，这就引出了…… 讨论什么才是最好的以及
86:42 讨论什么才是最好的以及 最坏的情况显然是最好的情况。
86:44 最坏的情况显然是最好的情况。 我发现它时，它就在第一位置。
86:46 我发现它时，它就在第一位置。 因为我只需要最少的步骤
86:47 因为我只需要最少的步骤 这么做，最坏的情况就会发生。
86:50 这么做，最坏的情况就会发生。 是或当它处于最后位置时
86:52 是或当它处于最后位置时 或者当我没找到的时候，例如，如果
86:54 或者当我没找到的时候，例如，如果 我会寻找
86:55 我会寻找
87:00 我已经尽我所能地全部查看过了。 一般情况下，如果我浪费了一些步骤，
87:01 一般情况下，如果我浪费了一些步骤， 这里有 n 个元素，所以需要 n 步。
87:04 这里有 n 个元素，所以需要 n 步。 在一次迭代中，可能是这样的
87:06 在一次迭代中，可能是这样的 我需要采取更多措施。
87:08 我需要采取更多措施。 又加了，还有事要做。
87:10 又加了，还有事要做。 这里需要用某种条件来计算某些东西。
87:12 这里需要用某种条件来计算某些东西。 他躺在那里，也许还在打字。
87:15 他躺在那里，也许还在打字。 简而言之，这些步骤可能是……
87:16 简而言之，这些步骤可能是…… 重量各不相同，但对我来说，此刻
87:18 重量各不相同，但对我来说，此刻 关心排队是的，这意味着步骤
87:21 关心排队是的，这意味着步骤
87:27 也许是2n，也许是3n，也许是4n，如果我愿意的话 弄清楚对我来说那个常数是什么
87:29 弄清楚对我来说那个常数是什么 你应该做实验，但是要排队。
87:31 你应该做实验，但是要排队。 那么我们就说这是一个线性过程
87:33 那么我们就说这是一个线性过程 搜索算法，谁在搜索它？
87:35 搜索算法，谁在搜索它？ 复杂度与 n 一样大，即
87:38 复杂度与 n 一样大，即 这意味着它最多只会用到 n 行。
87:41 这意味着它最多只会用到 n 行。 步骤数量如此如此如此如此如此如此
87:45 步骤数量如此如此如此如此如此如此 找到答案，看看那会是什么样子。
87:48 找到答案，看看那会是什么样子。 伪代码，嗯，某种程度上是的，是的，我们
87:50 伪代码，嗯，某种程度上是的，是的，我们 我们有一个数组，我们有一个值，
87:53 我们有一个数组，我们有一个值， 我们正在寻找它，它通常被称为钥匙，是的。
87:55 我们正在寻找它，它通常被称为钥匙，是的。 嗯，我们有开始也有结束，所以因为
87:58 嗯，我们有开始也有结束，所以因为 我可能想找找
88:01 我可能想找找 在整个数组中或数组的某个部分中，
88:03 在整个数组中或数组的某个部分中，
88:08 从头到尾的迭代算法
88:13 如果找到了密钥，则等于密钥；否则等于密钥。 在这种情况下，我们会返回类似这样的结果。
88:15 在这种情况下，我们会返回类似这样的结果。 我们返回位置，例如这样
88:16 我们返回位置，例如这样 现在可以实施了
88:20 现在可以实施了 可以采用不同的实现方式，即
88:24 可以采用不同的实现方式，即 我想做什么？
88:27 我想做什么？
88:37 如果我发现 aas
88:39 aas 如果 x 为真，则返回“是”，否则返回“否”。
88:44 如果 x 为真，则返回“是”，否则返回“否”。 那我现在需要寻找什么呢？
88:46 那我现在需要寻找什么呢？ 这意味着继续寻找，一切都取决于……
88:49 这意味着继续寻找，一切都取决于……
88:54 i 和 j 是开始，而结束是我。
89:02 剩余列表为空，因为索引
89:11 那我该怎么办？就这么结束吧。 那感觉如何？我先从一个例子开始。
89:14 那感觉如何？我先从一个例子开始。
89:39 之前的算法是 对我来说，这样更好也更简单。
89:41 对我来说，这样更好也更简单。
91:43 全面统计，是的，以下是所有数据 从零到
91:46 从零到 99，现在这种情况可能是
91:50 99，现在这种情况可能是 你拿走了，然后说
91:54 你拿走了，然后说 那
91:54 那 你的猜测是
91:57 你的猜测是 15. 如果你猜对了会发生什么？
92:01 15. 如果你猜对了会发生什么？ 15 你可能击中了它
92:04 15 你可能击中了它 那太好了，你中奖了，也许吧。
92:08 那太好了，你中奖了，也许吧。 如果……的话，你现在可能就没那么幸运了。
92:11 如果……的话，你现在可能就没那么幸运了。 如果你运气不好，我会告诉你一些事情，或者
92:14 如果你运气不好，我会告诉你一些事情，或者 它小于15，或者它是
92:17 它小于15，或者它是 目前有超过15个
92:21 目前有超过15个 如果结果证实这一点，将会发生什么，目前尚不清楚。
92:24 如果结果证实这一点，将会发生什么，目前尚不清楚。 这低于 15，你的价值
92:26 这低于 15，你的价值 你这次运气不错，但也有可能……
92:29 你这次运气不错，但也有可能…… 你运气不好，然后你就非常
92:31 你运气不好，然后你就非常 这个地方的大部分区域完全
92:34 这个地方的大部分区域完全 目前尚不清楚是否有必要这样做。
92:39 目前尚不清楚是否有必要这样做。 猜猜看，我就是这么做的。
92:41 猜猜看，我就是这么做的。 认为数量应该更多或更少的假设
92:44 认为数量应该更多或更少的假设 很明显，你需要猜测，这样……
92:49 很明显，你需要猜测，这样…… 最大程度上，我们有很多含义
92:52 最大程度上，我们有很多含义 让我们先排除掉它的含义，它的意思是……
92:55 让我们先排除掉它的含义，它的意思是…… 你正在射击
92:56 你正在射击 中间部分，然后如果你……会发生什么？
92:59 中间部分，然后如果你……会发生什么？ 祝你好运，当然你要接受它。
93:03 祝你好运，当然你要接受它。 你在这里可以获得奖品，上面写着50。
93:06 你在这里可以获得奖品，上面写着50。 一开始，如果你运气不好，现在可能就没那么幸运了。
93:10 一开始，如果你运气不好，现在可能就没那么幸运了。 所以在这个阶段，你的速度已经尽可能快了。
93:12 所以在这个阶段，你的速度已经尽可能快了。 你会接受它，
93:14 你会接受它， 这样一来，你将取消一些可能的值。
93:18 这样一来，你将取消一些可能的值。
93:23 一半减少了，所以答案是 好吧，你再猜猜看。
93:25 好吧，你再猜猜看。 再说一遍，分成两半，你会得到一些东西。
93:27 再说一遍，分成两半，你会得到一些东西。
93:36 根据需要，然后也许你
93:44 你将剩余值的一半舍弃掉，所以 事实证明，目标不是猜测。
93:47 事实证明，目标不是猜测。
93:53 a 表示错误答案 a 是
93:59 问题是，如果我们这样做的话
94:06 由此可以清楚地看出你需要多少步骤。
94:19 你只需要从第 50 题开始解题即可。 只能从以下方面做出决定
94:20 只能从以下方面做出决定 25，然后只有12人中的6人。
94:25 25，然后只有12人中的6人。
94:29 所以这不是数量的问题。 步骤会是因为我每次
94:33 步骤会是因为我每次
94:42 n 的以 2 为底的近似对数 在这种情况下，结果是100。
94:45 在这种情况下，结果是100。 是的，你可以看看最糟糕的情况。
94:48 是的，你可以看看最糟糕的情况。 如果需要这样几个步骤，请问需要多少个步骤？
94:50 如果需要这样几个步骤，请问需要多少个步骤？ 这里某个地方，它曾经是某个地方，甚至
94:52 这里某个地方，它曾经是某个地方，甚至 某个地方有些奇怪，所以也许是这样。
94:53 某个地方有些奇怪，所以也许是这样。
95:04 你可能不会猜到具体步骤，但是如果
95:18 你会使用顺序搜索，就是这样。
95:24 猜了10次，是的，这意味着你
95:35 该算法可以像这样再次发挥作用。 那么，这之间有什么关系呢？
95:38 那么，这之间有什么关系呢？ 这与我们的问题有什么关系？
95:57 遵循同样的原则，并且
96:31 你看，我扔掉了一半，现在正在找
97:05 彼此之间是常数，如果我们
97:32 这意味着我们又有了一份清单，我们有一些东西。 我们正在寻找，我们有开始和结束，如此等等，直到
97:36 我们正在寻找，我们有开始和结束，如此等等，直到 总能找到折衷方案。
97:39 总能找到折衷方案。 然后取决于那条含义
97:42 然后取决于那条含义 我们来看一看
97:44 我们来看一看 e 或或我们的关键更大或
97:48 e 或或我们的关键更大或 如果既不大于也不小于，则小于
97:50 如果既不大于也不小于，则小于 比我们发现的要小，然后返回
97:52 比我们发现的要小，然后返回 中间的位置，如果不是
97:55 中间的位置，如果不是 然后是左端或右端
97:58 然后是左端或右端 我们来看一下并调整一下。
98:00 我们来看一下并调整一下。 右端表示它需要是
98:03 右端表示它需要是 通过 e 表示减少，因为在右侧
98:06 通过 e 表示减少，因为在右侧 左边没人，但右边有人，所以……
98:08 左边没人，但右边有人，所以…… 我没意见，我每次都来这里。
98:11 我没意见，我每次都来这里。 竞争逐渐缩小，我们不断迭代，直到
98:15 竞争逐渐缩小，我们不断迭代，直到 直到我们最终从中得到一个元素
98:17 直到我们最终从中得到一个元素 最后我们会返回索引。
98:19 最后我们会返回索引。 这意味着蜂蜜酒现在可能就是那样了。
98:23 这意味着蜂蜜酒现在可能就是那样了。 他或我们发现或
98:26 他或我们发现或 我没找到，所以如果真的存在的话……
98:28 我没找到，所以如果真的存在的话…… 我找不到，肯定有办法的。
98:30 我找不到，肯定有办法的。 请告诉我们如何分离它，否则我们会找到它。
98:32 请告诉我们如何分离它，否则我们会找到它。 在这种情况下，是否涉及该元素
98:34 在这种情况下，是否涉及该元素 中间是索引，所以哪个
98:38 中间是索引，所以哪个 如果该元素位于何处，它应该放在哪里？
98:41 如果该元素位于何处，它应该放在哪里？ 现在就像这里一样，这里是递归的
98:45 现在就像这里一样，这里是递归的 版本是，而不是迭代我们
98:47 版本是，而不是迭代我们 恰好完全类似
98:50 恰好完全类似 在算法中，只需代替那一步即可。
98:51 在算法中，只需代替那一步即可。 调整那里的最大值或最小值
98:55 调整那里的最大值或最小值 我们只需相应地调用一个新的即可。
98:56 我们只需相应地调用一个新的即可。 找到剩余部分，是的，它又出现了。
98:59 找到剩余部分，是的，它又出现了。 这里指的是递归。
99:01 这里指的是递归。 她用事实证明，这就是那一个
99:02 她用事实证明，这就是那一个 分支是的，但我画
99:05 分支是的，但我画 注意分支本身
99:06 注意分支本身
99:13 但这并不意味着我一定会这么做。 这件事，我实际上会去做，或者
99:15 这件事，我实际上会去做，或者
99:19 嗯，这意味着线性对我来说很合适。 如果线性主题合适
99:22 如果线性主题合适 这意味着我可以迭代，而且我
99:24 这意味着我可以迭代，而且我 没有理由存储内存
99:26 没有理由存储内存
99:33 在相同情况下 对数，但递归是这样的
99:36 对数，但递归是这样的
99:42 我没有享受任何特殊待遇。 从这里开始，我们继续前进。
99:45 从这里开始，我们继续前进。 正在对任务进行排序，这是它的类型
99:49 正在对任务进行排序，这是它的类型 经典的是泡沫算法，
99:51 经典的是泡沫算法， 正在接受审查，并非因为它是
99:54 正在接受审查，并非因为它是 优秀的算法，而且因为它非常
99:56 优秀的算法，而且因为它非常
100:01 仅用于教育目的或
100:14 一种加密数据的方法
100:25 关于来自 nu 的意思是当有 按相反顺序排列后，现在
100:27 按相反顺序排列后，现在
100:36 如果元素顺序错误 将其取并更改，例如五
100:38 将其取并更改，例如五 有人可能会说这是错误的。
100:40 有人可能会说这是错误的。 如果我们交换一下，这里就变成五和八了。
100:43 如果我们交换一下，这里就变成五和八了。
100:50 好的，九点和二点，再交换一下。 这是第一次运行
100:53 这是第一次运行
100:58 你需要检查元素对，并且
101:04 只要你仔细想想，就一定能做到。
101:25 因为那些元素像气泡一样
101:32 那么如果我们移动一个元素 我们这里可以完成这个过程。
101:33 我们这里可以完成这个过程。 重复九遍，现在站立不动
101:35 重复九遍，现在站立不动 一旦我们开车 1 p 到我们的地方 5 tr
101:38 一旦我们开车 1 p 到我们的地方 5 tr 无需更改，一切都很好 82
101:40 无需更改，一切都很好 82 需要换货，再换一次，我们搞定了。
101:42 需要换货，再换一次，我们搞定了。
102:09 不再是了，这是一个接一个地来。
102:37 让所有要素各就各位 是先运行整个列表还是先运行一部分。
102:39 是先运行整个列表还是先运行一部分。 停下来，如果一切都……该怎么办
102:42 停下来，如果一切都……该怎么办 列表已经排序好了，为什么还要这样做？
102:44 列表已经排序好了，为什么还要这样做？ 原则上，我们可以随心所欲地遵循我们想要遵循的一切。
102:46 原则上，我们可以随心所欲地遵循我们想要遵循的一切。 元素互换了几次，然后
102:49 元素互换了几次，然后 如果不需要改变，那就只需
102:51 如果不需要改变，那就只需 打破循环意味着有可能
102:52 打破循环意味着有可能 换个角度思考最佳整体结果
102:55 换个角度思考最佳整体结果 在这种情况下，这对我来说就应该是这样。
102:58 在这种情况下，这对我来说就应该是这样。 只需浏览一遍清单就足够了，这意味着
103:00 只需浏览一遍清单就足够了，这意味着 现在，一旦所有列表都出来了，就可以查看了。
103:03 现在，一旦所有列表都出来了，就可以查看了。 它应该排好队，哦，那个大的
103:05 它应该排好队，哦，那个大的 从 n 开始，是的，因为需要 n 个步骤。
103:09 从 n 开始，是的，因为需要 n 个步骤。 这项实施方案欠妥。
103:11 这项实施方案欠妥。
103:15 该算法最坏情况下的复杂度为 逆序
103:18 逆序 这意味着我们必须长时间这样做。
103:19 这意味着我们必须长时间这样做。 基本上，之所以在方格上，就是因为这个原因。
103:21 基本上，之所以在方格上，就是因为这个原因。 我必须一次性审查
103:23 我必须一次性审查 大约有 n 对，实际上是 n-vi，是的。
103:27 大约有 n 对，实际上是 n-vi，是的。 这意味着必须进行这样的演练。
103:29 这意味着必须进行这样的演练。 现在，如果我们保留一些元素
103:32 现在，如果我们保留一些元素
103:39 加快算法速度，但顺序不变。 也就是说，它不会在广场上。
103:41 也就是说，它不会在广场上。 正方形切成两半后仍然是正方形。
103:43 正方形切成两半后仍然是正方形。 那么，是无穷大还是只有一半？
103:45 那么，是无穷大还是只有一半？
103:50 不，不，这是一个重要的问题。是的。
103:56 你可以编写一个递归版本来解决这个问题。 可以说，当我
103:58 可以说，当我 我进行了排序，结果该元素排在了最上面。
104:01 我进行了排序，结果该元素排在了最上面。 只需邀请新的新的新的
104:04 只需邀请新的新的新的 按大小排序函数复制
104:06 按大小排序函数复制 一部分是这样，但我认为那应该已经是这样了。
104:08 一部分是这样，但我认为那应该已经是这样了。 为了明确我们讨论的内容，
104:11 为了明确我们讨论的内容， 现在这不是个好主意，事情快要发生了。
104:14 现在这不是个好主意，事情快要发生了。 问题是，下一个会是什么？
104:16 问题是，下一个会是什么？ 排序算法及其工作原理
104:18 排序算法及其工作原理 似乎在递归的情况下
104:20 似乎在递归的情况下 它有效，排序速度很快
104:22 它有效，排序速度很快 您将详细研究的方法
104:24 您将详细研究的方法
104:29 那么，关于它，你需要了解些什么呢？
104:34 看看 stdlib.h 是标准语言中的 s
104:37 stdlib.h 是标准语言中的 s 库函数 a q 排序和 b
104:40 库函数 a q 排序和 b 搜索他们具体做了什么
104:42 搜索他们具体做了什么 我们在这里讨论的是这意味着什么。
104:44 我们在这里讨论的是这意味着什么。 二分查找速度快
104:47 二分查找速度快 排序后，它们就可以被使用，然后
104:49 排序后，它们就可以被使用，然后 快速排序法基本原理
104:51 快速排序法基本原理 借鉴了该二进制文件的一个想法
104:54 借鉴了该二进制文件的一个想法 搜索结果显示我们将采取以下措施
104:57 搜索结果显示我们将采取以下措施 我们来做这件事，我们来选择一个阈值。
104:59 我们来做这件事，我们来选择一个阈值。
105:04 数据的左侧部分和数据的右侧部分 然后我们把零件缩小成这样
105:06 然后我们把零件缩小成这样
105:11 对，我们来调整一下，让左边
105:18 我们已经做到了，现在让我们向左转和向右转。 一部分用于独立对它们进行分类
105:20 一部分用于独立对它们进行分类 一个接一个地出现
105:22 一个接一个地出现 该算法的最佳运行时间复杂度为 log n。
105:25 该算法的最佳运行时间复杂度为 log n。 在复杂性方面，这意味着从 n 开始的 o 非常大。
105:27 在复杂性方面，这意味着从 n 开始的 o 非常大。
105:33 反复进行阈值选择 我们暂且不深入讨论这个问题。
105:35 我们暂且不深入讨论这个问题。
105:43 55 所以如果我们像这样尝试
105:47 出现在 n 步之后的 o 大事件中 如果如果我们
105:49 如果如果我们 我们会试着把它捡起来修好。
105:53 我们会试着把它捡起来修好。 所有较小的元素都放置在左侧。
105:55 所有较小的元素都放置在左侧。
106:06 这个例子不是55，而是33。 作为阈值和手段，如果我们
106:09 作为阈值和手段，如果我们
107:53 摆放水桶，使右边的水桶更大。 左边较小，所以这里是75。
107:56 左边较小，所以这里是75。 取而代之的是，右侧比左侧大。
107:58 取而代之的是，右侧比左侧大。 这里还有一些更小的，这是左边的这个。
108:00 这里还有一些更小的，这是左边的这个。 他当然会留在这里，现在他又来了。
108:03 他当然会留在这里，现在他又来了。 如果我们拿走最后一个，就可以观察情况了。
108:05 如果我们拿走最后一个，就可以观察情况了。 嗯，这里是64，左边部分将保留在这里。
108:09 嗯，这里是64，左边部分将保留在这里。 所以现在如果我们看这里，它就会在这里
108:11 所以现在如果我们看这里，它就会在这里 左侧中间44号，右侧较小
108:14 左侧中间44号，右侧较小 他个子更高，就那样排着队呢。
108:15 他个子更高，就那样排着队呢。 事实证明，一切皆有可能。
108:18 事实证明，一切皆有可能。 是的，所有这些都可以在同一个数组中实现。
108:21 是的，所有这些都可以在同一个数组中实现。 做得太少 ž 意味着线条
108:23 做得太少 ž 意味着线条 如果你看看现在发生的事情有多少，那就是他们的。
108:27 如果你看看现在发生的事情有多少，那就是他们的。 和我除法的次数完全相同
108:29 和我除法的次数完全相同 如果我尽力的话，能达到一半。
108:32 如果我尽力的话，能达到一半。 如果所有时间都减半的话
108:35 如果所有时间都减半的话
108:39 一行字让我多走了几步。 这是总复杂度乘以对数。
108:41 这是总复杂度乘以对数。 但或许我也很倒霉。
108:44 但或许我也很倒霉。 我每次都能猜对。
108:47 我每次都能猜对。 结局是空的，仅此而已。
108:48 结局是空的，仅此而已。
108:53 运气不好，右边什么也没有。
108:57 我每次只拿一个。 元素和快速排序
108:58 元素和快速排序 算法开始像那些算法一样运作。
109:01 算法开始像那些算法一样运作。 熔融算法气泡，还有那里
109:03 熔融算法气泡，还有那里 经过这些顺序搜索，我们得到 n
109:05 经过这些顺序搜索，我们得到 n 是的，有很多方法
109:07 是的，有很多方法 我该如何使这个除法成立？
109:10 我该如何使这个除法成立？ 如何才能做得更好？现在就去做吧
109:14 如何才能做得更好？现在就去做吧 用递归处理这个问题，结果却很奇怪。
109:16 用递归处理这个问题，结果却很奇怪。 简单来说，我们说这件事将会发生。
109:18 简单来说，我们说这件事将会发生。
109:32 我们找到阈值并将其分成两部分。 部分是的，仅此而已。
109:34 部分是的，仅此而已。
109:39 然后我们将其分成两部分，一部分来自 从那个开始到那个 q-vi 接下来从那个从
109:42 从那个开始到那个 q-vi 接下来从那个从
109:47 不要这样做，而是从这里走一步。
109:54 运行良好，我们认为这一个应用程序
110:00 那样一棵树，那棵树就是这样。
110:09 这里又是左右 没有左右之分，就是这样。
110:11 没有左右之分，就是这样。
110:18 写下这个、那个、那个分区
110:26 其中之一是标准，即伊玛目 最后一个要素，我们试图推动它。
110:28 最后一个要素，我们试图推动它。
110:39 在这两者之间，这个词可以非常、非常
110:59 你必须行动，你必须做人们会做的事。
111:33 迭代式开发对我没有任何好处。 我的意思是恰恰相反。
111:35 我的意思是恰恰相反。 编写大量代码，结果却只是
111:36 编写大量代码，结果却只是
111:49 这是 n 个正方形 tš，似乎可以说明
112:42 想办法让它们成为可能
