斯坦福-CS106A-B-L-X-编程入门笔记-八-

斯坦福 CS106A/B/L/X 编程入门笔记（八）

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P6：【Lecture 06】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好吧，今天是星期一。我们自由了。我们今天被邀请到这个区域，叫做递归。嗯，让我想想，我提前通知你，我想你本周应该做作业2。我当然想鼓励你和理发师一起工作。如果你没有伴侣，你就在找。

会尽量帮你找到一个离广场很近的品牌叫。找搭档什么的？问问你的部门领导，活跃的费金。我自己，如果你想找搭档，我们很乐意帮你找。我强烈推荐。如果有人能和你谈谈，和你一起工作，这会使事情变得更容易解决。

所以这周，我们要做递归。我想提醒你，这是我们在这段视频中听到的第一个非常棘手的话题。我是说，我觉得所有的材料都很有挑战性和趣味性等等。但是这个。你真的需要学习一种新的程序思考方式的第一个材料吗？

我要说的是，很多学生觉得这很有挑战性。大多数学生需要一段时间去了解，坚持下去。所以我的天，如果你今天离开课堂，离开你的生活。我告诉你的，作为一个聚会的关于。可能，好吧，你可能不是唯一有这种感觉的人。

只是要做大量的练习。我们将成为这方面的一部分，我们将花费所有的时间来讨论这个递归概念。下周大部分时间，我们还将讨论递归的不同应用。所以就好像它不是，它并不总是有意义的。但最终我。你这样想会很舒服的。

我们的节目。所以说了这些，你知道，我认为这是一个必要的，棘手的话题。我认为这是一个特别好的练习话题。自己锻炼他的身体，也许一步一步地解决书上的问题，也许你可以通读这一章。

我在网站的电子日历上贴了一些视频。我不仅会发布我的演讲视频，但我有其他人解释递归的视频，因为有时候我的解释对你来说没有意义，因为你的思*方式或学习方式。来自其他人，来自其他一些导师。

包括斯坦福大学和其他学校。我非常尊敬，钦佩他，我有他们解释递归的视频。所以如果你去看，读，练这些东西，我想你和她在一起的机会会增加。所以无论如何，这是本周的主题。它来自教科书的第七章。

让我们深入研究一下。递归就是用事物本身来描述事物。所以我的意思是你试图解决这个问题，也许你的算法，或者你解决这个问题的过程。包括解决同一问题的更*或更简单的版本。听起来我在说谜语之类的东西。

但像很多算法一样，当你意识到或没有意识到它的时候，就有它的质量。例如，如何在字典中查找单词的算法。算法是你翻到有那个词的页面，然后阅读定义。但有时定义是你不知道会议室的词。那你怎么办？你去查他们。因此。

在字典中查找单词的过程可能涉及到在字典中查找单词。正确的。现在这就带来了一种危险，也许你会一直失控，不停地查单词，不停地查单词，不停地查单词。最终，这个过程。什么时候停下来的。是 啊。是的。

当你查找你想理解的一切的定义时，你知道定义中每个词的意思，那你就不用再查了，对吧？所以在某个时刻，这种自我重复停止了。但这是算法描述的一部分，既有效又优雅。还有很多结构。

当你在编写一些递归的或者类似于它们的代码时，就像硬盘上有文件的目录结构一样。文件持有者包含可以包含文件夹的文件夹。你还可以看到数据之类的东西，比如家谱。你知道有点自我相似。父母和孩子。

孩子可以成为其他孩子的父母等等。科学和自然中也有很多这样的事情，只是，你知道，动物的繁殖模式和云的形成，我们的花椰菜被螺旋状的外壳和各种各样的*东西粘在一起，相同图案的较*出现。

就像自然界中自相似的模式或算法。本周晚些时候。说你可以在重复较*的地方画出图形。同一个模式在其内部的更大引用是非常酷的。可以使用递归的自相似描述来绘制这样的模式。是的，我是说，这是一个概念。

你可以把这个概念应用到编程中。所以我想谈谈一个非编程的例子。第一。如果你有一大碗像M和S这样的糖果怎么办？现在，坦白说，如果我是一个好人，我会从一大堆糖果中长大。我会用糖果做这个。

然后你们就可以吃糖果了。然后大家都喜欢我，但我不是马里恩，我是一个可怕的，无害的。在里面死去的人。我没有给你带任何东西，你自己开始，如果你没有，但让我们谈谈11，40天的午餐时间。假设有人走回印*。

我们想把人数增加一倍。如果是的话，你知道。然后我们想找乐子。还有。所以，我是说。如果你数一数安曼，你会做什么，然后把他们拉起来。然后无论什么结局在那里都很重要，你就完了，对吧？但我们还是假装去伯克利吧。

所以我们无法计数。我们不知道怎么做。但我们是军团。我们很多人。我们都是。我们所有人。无法计数，伙计们。或许可以结合我们原始的智力力量？来解决这个棘手的问题。那么这和递归有什么关系呢？好。

递归是指当你有一个算法在某种程度上以较*的形式引用它自己。所以，就像画这个图案的算法，你画这个，然后在里面你画这个的*版本，你画这个的*版本，这个想法是一样的，查字典，查其他的单词。

这个问题是不是有一些自相似性的问题？它是M和M的翻倍，类似于其他一些知名人士的翻倍，这是一种思考问题的自相似方式。所以这真的。因为我们很多人。我们假设洞里的杰出人物的数量少于。可以。

如果我们都能讨论并提出一个共同的算法。每个人都将遵循完全相同的规则，尽管算法可以有beef、elphin或其他什么。但是算法涉及到一个，你在做所有的工作。我已经准备好了，我会把新的放进去。

你们每个人都要做少量的工作我们必须一起工作。帮助我们每个人，一点点打来的电话。他把显赫的人数增加了一倍。有点棘手。所以你真的有什么想法。你的建议。好吧，你说的是，每个人都会在凌晨一点起床。然后呢。好吧。

那么，如果我们有一个有趣的球，我们想加倍，然后我们有一个额外的便利设施，我们想用它来加倍，你是说我们每个人都可以遵循从整体上抓取一个的算法。还从大货源里抢了一个。现在我有两只手了。现在，我同意了。

把它放在你的目的地。现在每个人都这么做了。然后，夸张地说。他们基本上是对的。是的，我觉得那很好。就这样。这是一个很好的，像种子的整体方法，对吧？它有正确的心态。就像每个人一样，只是工作的一*部分。

这是一种递归的思*方式，*工人互相帮助，对吧？好吧，随便。我的意思是，我认为这通常是正确的答案。但是。如果我再多做一点呢。*步行街，在你描述这个额外的布尔是倾倒一个地方，然后备用的一个。

我们去把他们在那里。但也许可以减少对问题的限制，比如说我们只有一个碗和无限的供给，以及我们正在投入的任何东西。必须有人进入我们的目标，所以如果我照你说的去做，我拿出一个，把你放进去。

他们会回到我们的碗里，我们要加倍。所以我有点担心，比如，如果有10个人这么做。我不知道在我停下来之前应该有多少人这样做。你知道什么吗？我想你的描述是假设球会空出来，我们会填补另一个洞。

如果你这么做的话那就完全管用了。但我要说的是，没有其他的围棋需要做了这么少的额外想法的工作。在我看来，新版本的。对吧，对吧？干掉你的敌人。带走，供应伙伴。现在还在运作。不想让他回到任何地方，不是吗？

很冷。现在。一半就禁，下一个人，还是让别人轮到自己再犯吧。人们会这么做的。握着我的手，然后你退出2号命令，谢谢你。有人从洞里抢了最后一顿晚餐，他们拿了个汉堡，洞里什么也没留下。

你身边有人拿着两个名人说每个人都退后，现在我们完成了，每个人都做他们的2米和2米，你把洞的数量加倍，把碗里的M和M的数量加倍。完全正确。甚至你，我们都在利用。不要用代码来描述说，如果民意测验有他们。

我认为这是我所看到的正确方法，好像洞是空的或者别的什么。没什么可做的。否则就把他带出去，传下去。等它回来。然后再放两个，这样你就可以了。也许还不太清楚这个问题是如何自我相似的。因为要记住。

递归的整个思想是一个与它自身的另一个版本相似的过程。但你想看到某种方式，你会说。我要加倍他的球，所以我的算法。他出去了。墨西哥煎饼，在我旁边，请你谈谈这个好吗？这和我的走路不一样。

因为这和100分和双倍的足球不一样。等他们说，我现在已经完成了由整个乐队，但我的公司是说，这里是这样，但如果世界上有5个动物，如果这么少，那问题，只有500。我想出去，我有一个完整的。我想。我数不清。

我不知道有几岁，或者你身边有没有人，他们走到外面，一路往下走。你想听什么都行。然后你知道，就好像它在视觉上有税收，被要求加倍玻利瓦尔的人，我不知道怎么翻5倍，但那个人非常乐于助人。

它们的高度是原来的两倍，所以现在我们所关注的双门是球算法中ems数量的两倍。我们正在描述算法。本身。最好的形式部分，几乎就像是一个他们都在运行的函数，他们互相调用函数。做一些工作，你知道。

以身作则是有道理的。无论如何，你可以说约束是人造的。为什么？我只能说，好吧，好吧，如果你能帮我的话。你只需要急切的算法来描述它不需要更大的屏幕。更聪明的人愿意自己做所有的工作，而不是一群不必做的人。

做了你该做的。实际上是很重要的部分。因为喜欢。家从这里开始用一只手，但我想整个晚上，因为我是整个剧院。冷0，没什么好理解的。好长，一个方向。一边喊。我只是回来，把这两种回首放在他们的脚上。

什么也不给同一个人，他们认为，是的，我认为是这样。这是对原始问题的回击，是哪个。所以没用。也许你在担心什么。你拥有它，而其他的地方是某个点，有人提出最初的要求的唯一，而那个人成为一个结果。问题。哦。

什么？好吧，我想这已经不存在了，但我想他们已经检查过了。以及第一笔应收款项，每个人的照片此时此刻。不，好吧，好吧，不管他们开始做什么，他们都想继续走下去，我们就在那里。当欢迎回来的时候。所以我的意思是。

最后锻炼，这是个愚蠢的例子，但我认为这说明了我们在说什么。但让我们看看一些实际的代码。我认为真正的人，加上代码，可能会有助于了解财产计划，就是当你写一个调用自己的函数时。如果你这样做了。

你会得到一个函数，你会发现，我想回到上面，这样你就可以调用你自己的函数了。它又跳了起来。我就是这么说的。有趣的是，递归和循环一样强大，可以做很多事情。所以它们实际上是整个编程语言，叫做函数式编程语言。

他们没有。所有这些函数都可以调用函数。不知怎么的，你可以这样写整个程序。有点有趣。或许你学过函数式编程语言。简单的欲望不是这样一种语言，但那没关系。不管怎样，我们将使用递归和重新调整编程在其他很多。

当然。所以当你写信的时候。递归的。程序和代码。你肯定要担心一些功能。他把你的函数一般化了，但在某个时刻，你必须停止在问题的一部分调用自己。我们必须有这样的逻辑，如果球没有增强，我需要停下来回去。

某种程度上。所以这种停止你自己的情况，通常被称为基本情况。我会告诉你，当我展示具体的例子时，我想会有意义的。但是。但在这种情况下，您的函数不需要调用自己。如果你回答问题的时候已经掌握了信息。复发的病例。

更复杂的病例复查后再打电话给自己。当你写递归函数时。你应该具备的一般哲学是。我会让我的函数多次调用自己。每一个电话都像是一个人在帮助双重需求。从某种意义上说，每个调用都应该是整个工作的一*部分。

并且所有的调用将组合起来完成总的量。所以一个关键的问题是，这个问题和它本身有什么相似之处？对于我来说，得到这个解决方案的其他版本有什么帮助呢？那能帮我做我需要做的事吗？我们来看一个具体的例子。很多递归。

书和例子都是从计算的概念开始的，一个阶乘，它只是从一个到另一个的整数的乘积。这不是，这是一个可怕的，我从1开始，然后乘以慧。对右边最好的冲击，它是一个专有名词。好吧，那不是很有趣。不是很难，但你注意到。

如果你看这个模式。像四个保理是穷国可以看到一个。我想这一天会涨1，2，3，4，你知道的，比如说。5个因素，5乘以4515。保理只有54胜。所以我试着写阶乘函数。我可以利用这种关系。

在我的。那是什么？让我打开。可爱的创造者，我要打开这个文件。我打过电话了。递归专业开始。Cpp在这里有很多不同的功能。但我想写。或者是。我没有。为了它。阶乘。最后，我们刚才说五个阶乘等于五乘以四个阶乘。

对吗？所以你基本上可以在代码中这么说。你可以说，如果我没事，那么你也可以说，及时回来。我的没问题，但那不是一个完整的解决方案。你知道这个解决方案有什么问题吗？怎么了？是 啊。它永远不会结束。

因为阶乘5调用，阶乘。4因子4 3 3 2 1 0 0为负，也有一个阴性。它只是盘旋进入。你可以打电话，这最终会崩溃的。你的程序叫做堆栈溢出，因为你的函数有很多内存。最终会有太多的溢出。你的记忆。

你可能是。听说有一个网站叫做overflow，这是一个关于递归函数调用太多的概念的笑话。所以这就是我们需要一个基本案例的地方。我们必须告诉算法在某个时候停止这种自调用。

所以这个想法是大多数递归代码都有某种，如果你说，如果有的话。否则。一些东西，而这些家伙的区别在于，你有点像通常所说的基本情况。什么叫递归脸？基本情况是，我不需要打电话给我自己，因为这个问题很简单。

你只要回答就行了。所以你想问自己的问题是，什么数字很容易计算阶乘。我听到1和0。这些数字的工厂压力为10，而工厂压力为1。一家工厂要找一根骨头，这样你就可以做一些事情，你知道，如果安妮是0。或者，是1。

那么，返回1。我不需要把简单的东西叫做阶乘。如果你明白的话，我只回答，但对于大于1的数字。这很难，所以我将n-1的结束时间因子称为。所以我想在你脑子里找到这个的简单方法是，如果我叫三的阶乘呢？好吧。

那要做的是它要进入代码的其他部分，对吧？因为三不是0或1，所以这将导致三次返回。两卷，对吧？所以，二的阶乘需要计算它的结果。位于two上的工厂也进入代码的其他部分，它说，返回两倍于1的阶乘。

这就引出了第三个阶乘调用，一个阶乘权。一个。这是基本情况。这就是回归的意义。现在，有一件事想这么做是有麻烦的，嗯，这是什么意思？返回一个返回磨损。好吧，这意味着从两个调用的阶乘返回给打电话给你的人。

所以它会把这个还给你听。所以这东西变成了酒。所以这个工厂，只有两个调用返回两个乘以一。所以这意味着整个电话都回了，对不起，变成了坟墓。然后这个也会返回三次。所以这个返回6来理解。

就像每个呼叫都在等待下一个呼叫结束，这样它就可以返回它的答案。所以整件事就是这样运作的。如果你想看到递归代码，运行一个很好的方法就是在开始处放一个seal语句，然后说。阶乘打印的论文是和加大*加句柄。

只打印参数。刚刚看了函数调用。所以在缅因州。我会说。阶乘。五个。所以。Inf等于这个值，然后我将看到整个结果是如何相等的。好的，这意味着我在这里的文件顶部，它将调用我们写的工厂。如何使用未定义？

我没有听证会的原型，必须有一个。果味的。再试一次。我不清楚，因为上面写的是主沉船。我搞砸了。这是正确的。是的，所以。说阶乘，5因子自身4影响我们的参考阶乘的阶乘。总的结果是120。

所有这些电话都是打给电脑的。总体回答。这个版本比翻版的好吗？你知道，两个都好，只是思*方式不同而已。我只是给你们看，这是一个初步的例子，来理解这个机制。我不是说这个代码比这个品牌好得多。

但是我们今天会有问题的。本周，递归版本可能更容易在非递归中编写。到目前为止关于这个功能的任何问题，关于海外的回归。到目前为止。你能不能总是用一点*恶作剧来代替这个版本？所以基本上，是的。

但这并不意味着真正的版本同样容易写。有时是外观版本，你需要保留一些数据结构有时是递归版本。我们得耍点*把戏来解决这个问题，你总是可以用任何一种方法解决相同的整体问题。

但有些问题用一种方法比另一种方法更容易或更难解决。其他问题。

我们继续走，看看你能到哪里。所以我要跳过这一步。我们写的。所以，是的，你叫工厂，所有*多利亚，三个，叫*多利亚丽都，叫*多利亚一号。然后返回结果，返回两倍的结果，返回三次的结果，回到这里。

哪个返回四次的结果？是什么，后面6号？所以24个这样的调用，我认为学生们有一个很大的误解，可能是当他们看到这些递归调用时。

就像。他们看到这个递归调用是4，然后返回。ami 1的四次阶乘。阿美。1是3。所以当他们看到递归调用时，他们会去，好的，所以它会再次回到顶部。当你给自己打电话的时候，你会回到顶端。那种骑行。

但它遗漏了一些重要的东西。并不是说你的功能回到了顶端。就是你生成了一个新的函数副本。那只*狗在上面吗？这是一个非常重要的区别，在某些情况下。所以，这就是我用这些画这幅画的原因，像不同导演版本的功能期。

因为发生的事情并不仅仅是话题，等待其他版本完成。不管我用的是哪个版本，每个调用都有自己的身份。

所以不管怎样，如果这没什么意义的话，我想更多的例子会有帮助。嗯，让我们。我想，滚开。所以我想再举一个例子。给你，好的。我把这些给代码看，这是一种奇怪的代码。事实上，这一次，它使很少人回复，称自己为神秘。

随着它的发展。有时也是。那它有什么作用呢？我给你一点时间看看，然后我们一起讨论。如果你解决不了，好吧。在他的心里。随便和你的朋友谈谈。好吧，我知道不是每个人都完成了这项工作。我只是，我有。

有人认为他们知道答案是什么，一些你想勇敢分享的答案，你认为呢？看。3，3，4，4，80。我想那是对的。我想通过不同的电话，以帮助确保人们知道，希望将理解为什么这可能是正确的答案。

所以如果你看看最初的电话。这就是密码。所以，是348，对吧。所以不去咖啡馆，但如果是假的，不少于10个。所以它去了另一个。所以它两次称之为神秘。它称之为神秘在结束，除以10和在结束，蒙大拿，除以10。

除了最后一片沙漠，其他都是吗？正确的？那是34分，马丁只是最后一个8分。所以我们从8号线下34号线。所以这是两个从这里打来的电话。我专注于第一个电话。第一。所以第一个是34号。打电话来。也不少于10。

对吧。又是这样，去了另一个。把数字的两部分分开，我想这是四个右边的三部分。所以最后，是要用3，大厅里是要用4，对吧？所以让我们想想这些是怎么做的。所以现在三个高。他高兴地说，如果是在基本情况下。

他的部分，如果返回。钢琴和10乘3加3等于33。正确的。所以这个电话返回33。计算机代表两种形式。我不知道他在这方面是什么，这些事情都回哪里去了？他们一路跳到我面前。不，他们回到了之前打给他们的电话。

所以这个。三十三。就在这里变成了我的老鼠依偎着的哈哈。你知道的，这44变成了这个，在我的房子里盘旋。所以。我要退出这两个电话。情况是a是33，B是44。好吧，现在这家伙的任务是返回100乘以33加44。

正确的。所以这个返回33443，3，4，4。你注意到你过了34关，得到了3，3，4，4。正确的。所以有时候你可以发现一个模式，或者到底发生了什么。也许你找到了模式。所以，这个电话。计算3344的结果。

结果会去哪里？那个号码怎么了？是 啊。它变成了原版。打电话来。伪装ais 3344。现在我们要追查b的另一个电话，b是他的，monte是8。所以我们要计算出年龄的奥秘才能得到他的ab。

所以这里会弹出一个电话，8，*于10，所以它返回10乘以8加8，等于88。所以现在我可以回去听了。所以是3，3，4，4。B是80岁。所以现在我应该取一百次a，也就是3，3，4，4，0，0加。

所以总的结果是3，3，4，4，8，8。所以这看起来很奇怪。口吃的数字图像，所以有两个每个。所以这就是神秘的功能，真的。无论如何。有点像是大脑颠倒了，在所有这些代码中进行跟踪可能没有意义。

但这就是代码的执行方式。关于这个函数，关于这个，关于我们走过的路，你有问题吗？如果你不这样做，那就没有意义。下载今天电子版的zip文件。这个功能在里面。去编辑代码并放置一些seal语句。

然后自己运行它并观察它，看看会发生什么。而且，你知道，这段代码的执行对你来说更有意义。但是，在绘制这些图表的地方，您可以找出有帮助的不同调用。让我们看看能否一起解决另一个问题。

我想写一个名为calendar的函数。我想看看是不是奇怪，前后一样。所以如果你把绳子倒过来，你会有同样的东西吗？当然了。我们可以用一点，你可以移动所有的角色，看这些东西，如果你想这样想问题。

这是有帮助的。你也许能帮我们找到独处的方法，对吧？但我不想用循环来写，用递归来写。所以。我们不仅仅要学习递归。但我们可以问自己一些标准问题。我喜欢思考的事情。我们的。这个问题还有什么相似之处？

怎么问我的银幕，pgm，类似的演技，是否还有其他的东西。这是我们能想到的问题。我们可以考虑的另一个问题是，如果我有一大堆工人的话。每个工人都在做少量的工作。每个人的工作单位是什么。并与工作集体起来。

解决整体问题。这是另一种思考的方式。你能想到的第三件事，我谈到了这些案子，还有第一件。每一个排练问题都有基本情况。这是问题的简单版本。有哪些简单的流可以确定它们是否是回文？我们可以考虑一下。

这些都是有用的，我们应该扪心自问，因为我们正试图想出一个算法。如果你想用循环来解决这个问题。我的意思是，你们能做的就是把街道倒过来，然后你们可以平等地付出代价。但我们不能这么做。

我们可以查看现有的屏幕来找出问题所在。我们可以搬走，你怎么办？使用。一般来说。对。所以，是的。从第一个字母和第一个字母开始，然后继续移动。最后的第二封信是第三封给你看的。看看整个奇怪的事情。

如果你没有看到任何与右翼相反的问题，那就是右翼的一种循环版本。那么，我该如何选择骰子来计算出每个国家可以做的一点工作，如你刚才所述。这里的工作单位是什么？你说什么？

所以如果我想做赛车的话。你这样说，我可以让第一个工人看看这些边上的字母，看看它们是不是现场。然后下一个工人，他们做了什么？所以下一个工人会看a和a，对吧？好吧，然后下一个工人会在某个点上看。

你在这里完成了。所以。我们总是在谈论自我相似，对吧？如果我要做这项工作的一*部分，我要看看他的R。和这里。怎么样，你能用他的回文来形容回文吗？比如，这是怎么回事？就像我检查边缘一样。

然后其他人做类似的事情。我可以查一下除了赛车以外的其他词是否是笔迹。你知道我在说什么。比如，我还想知道它是不是回文？是 啊。他的车，是的，就像，如果我能告诉你。我是回文的先知。我知道他们的一切。

我知道他们向后看，只是说我不向前看。我知道。汽车。你这么问有多不对吗？我可以告诉你。如果你这样做，你的工作就是知道赛车是否是一个回文。你可以做很多，因为你可以说，好吧，我会检查R和R。这些都很好，你。

甲骨文告诉我，那是一辆车是回文。所以这两个事实加在一起，我有我的答案，对吧？这就是递归的思*过程。你没有神谕，但你的下一个电话是要和他的朋友们一起去工作。总的来说，这将回答这个难题。

即这个词的其余部分是否是回文。所以我想我们可以用你给我的想法来写。所以如果我们去找creator，我有一个函数hitter，is。在这里做手工。现在，我对此非常悲观。我只是说，回来。错，那是不对的。

所以。你说，看最后一封信的第一个字母。所以，好吧，我可以帮你。第一个。字母是S括号0，它的类型与强度有关，因为它只是一个字符。最后一封信。最后，他是支架。赖特庄园长度-1。可以。

所以我想知道他们是一样的。所以我想，你知道，每当你返回一个布尔值时，你就会有这样的想法，我应该早点停下来，还是应该继续，如果我知道我的字母不同，我其实不需要问关于这辆车的事情，对吧？因为如果你要求比赛。

仅仅因为这些都是正题，这样做是行不通的。所以我想你可以说，比如，你知道，如果第一个不等于最后一个，那么整个词不可能是一英镑的回报。错误的权利，但如果他们是平等的。我需要知道这个词的其余部分。所以，就像。

你知道，我需要把赛车变成一辆车，我也需要。一、 我该如何让自己变得非常。我把字符的底片切下来。我想我听到你们这么说了，所以我会把弦中间的等号当作潜艇从一开始。然后传递长度和字符数，这是它们的原始长度。

-2个字符，对吗？所以长度是-2。中间。所以现在我只想知道，是回文。中间。这是我的递归调用。正确的。这是算法的一般思想，这是我到目前为止写的两个问题，但这主要是思想。到目前为止，开局不错。正确的。所以。

嗯，让我来。让我稍微改写一下这段代码。因为我想。把所有的事情都当作一个测试来考虑是很有帮助的。真的，我想知道第一个和最后一个是一样的。中间是回文。所以如果你允许的话，我想对这些代码稍作修改。

我想说以下几点。商场，我只是想，先把这三个都申报一下。可以。现在我想说。我想知道第一个是否等于最后一个。我也想知道，其他的也是。回文。这是有道理的。回来了，真的。回答错误，就像，像，好吧。

你们一起推测试，对吧？我做了一些肯定的，肯定的测试，也许是。同样的，虽然，是的。好吧，但这段代码有一个问题，就是遗漏了一些我认为在递归中很重要的东西。这里面少了什么。如果你成功了。一般提示。

如果是递归周，问个问题。不管是什么问题，如果你只是想，基本上，你可能是对的。或者如果你没有，那可能就很近了。是的，基本上是非常重要的，因为没有基站，递归永远不会停止。在这种情况下，我的意思是。

代码会尝试做一些事情，但在某个时候没有东西，把两个字母拼起来。我想如果屏幕上出现非法索引会崩溃，或者类似的事情。所以让我们想想这些案子。通常是我们写的代码。所有这些都是反复出现的。所以说真的。

我们应该说，好吧，如果有的话，那我甚至不需要做我写的所有东西。如果屏幕很容易回答的问题，那么所有的数据库情况，但如果它不容易，那么我会做所有这些工作。点击这里。太好了，什么。

会是一根很容易决定是不是一磅房间的绳子。他们打过电话。当你说是的时候。只是一封信。他确实不清楚怎么处理这根绳子。但是，基本上，我认为这里的测试是，如果你逆转，它就会改变。这个字符串只有一个字母。很长。

答案是不，不会变的，对吧？如果不是的话。根据定义，他只是一个。这是日历。正确的。实际上，是一个空字符串。也不清楚该怎么办。但是让我们把空字符串定义为一磅，如果它是空的，或者是一个字母。

我会写*于或等于一的。它不会随着反转而改变，我称之为一磅。否则，我将进入这个递归的情况。我会把中间所有的字母，第一个字母和最后一个字母都切掉。中间是回文。我会回来的。是的。可以。我们试试吧。

如果我去我的主管道，我有一些测试在这里找到它。如果你再问一次，如果你想看这部作品，但你不太了解这里的流程，我认为，最好的方式，开始对美国，他们看到了。是回文。特许经营人，加上或少于s。处理类似的事情。

当你运行它的时候，它会产生很多输出。但是。它会说，是回文，夫人，它叫ada，它叫d赛车，它叫，它叫。踏上，没有宠物，瀑布，回文，额外的爪哇瀑布，赛车，瀑布，双机器人。这对调侃有用。在这里。

它在这里的操作系统上很有用，但后来它变成了为什么要在中间抢劫，蜜蜂赢了不匹配，所以它停下来了。如果你想看到他，你可以在输出中看到这些调用，这可能有助于看到进程的进展。可以。稍微改进一下这个代码。如果你。

如果你曾经拥有，如果返回真，否则，返回。假的，你可以把它缩短到，基本上，只需返回早期测试的结果，您可以看到return是否该测试为真。这是一种简短的表达方式。这是一个更好的版本。艾伦，我在查。

我想再做一个。我们还有5到6分钟。我想我们能完成这件事。

这是一对夫妇。啊哈。跳过。这个。一个很简单，我今天不打算做。它叫河内塔。这是a。在他们用这些做*玩具之前，我们已经看到了一个问题。你可以。放在你的桌子上，或者别的什么。作为一部分，你可以把这周带到地上。

比如，坐在头上，你可以看到它。这只不过是换了一只。但是有一个规则，你不能把一个大的磁盘放在一个*的上面。第一个没问题，我想第二个没问题，但是所有人都去度假，我想我们得说。然后我有一个*的。

你的手臂自由和关闭，我不能放一个大家伙。想象一下，如果我们要递归地求解河内的塔，我要传递有多少磁盘的参数。从0 1或2开始他们的目标是什么？我要你把它们移到哪一页？可能不是现在的情况。启动。所以。我玩。

这是更容易解决一个诅咒简单地比有人问，就像我总是做这两种方式。是的，但我想是这个。以后再试试，用一个循环。我想你会发现问题出在哪里是令人沮丧的。那我该怎么写呢？好。我有点黏糊糊的。

所以我们可以让我画出来。还有一个使用cli的方法叫做从一台电脑到另一台电脑的谦虚单，我想让我们的算法调用我有很多次要移动的东西。所有这些都是对的，为什么你不坐在我的词隐式删除从开始到任何过程。

那就是白痴。现在，好吧，如果你要递归地解决这个问题，那就意味着。你得考虑单身。如果我离开这里，离开这一页。为了这个。那过去和其他客人有什么相似之处？另一种圆盘运动。知道我在说什么吗，比如。

如何将5个磁盘移到一个磁头上？另一个在什么地方移动？有点棘手，对吧？我想你可以用另一种方式来思考这个问题。他的，我用这种语言来形容一个晚上什么的。你要通知什么。你得去玩，它愿意出来。

但他们不愿意做所有的事。一些被捕的人。我该怎么做？你知道什么样的心态。是 啊。所以你可以。拿第一个。上。是 啊。可以。所以，我想。你有一整套正确的行动，但我认为这将开始导致一个答案。

我认为递归有一个优点。他辩解不止。所以我找到了这个。我一下子就有了这个功能。但我没有功能。我当时5岁，因为那太好了。但我被要求快点。想象一下你一次上升到4。传记，4和移动，功能。

这个功能是如何解决我搬家的任务的？5个？你怎么向我转达？如果你说到点子上。第二件事。在生日那天。受伤了。当然，我没有一个函数是4，我有。好吧，她陷进去了。什么。如果递归是神奇的呢？递归是神奇的。

那会很有趣的。

我只有一两分钟的生命，我不知道我能不能公正地对待这件事。但是。我们试试吧。我要试试。所以，我被感动了。如果我要搬家的话。就像所有正确的价值观来帮助我们理解。如果我把五个磁盘从第一页移到第三页。

一件可能有用的事情是，我想要的是不是其他猪钉的数量。所以写了一个叫河内的助手。第三个标签号，如果你通过，开始，标签和结束标签。就像我三分之一的第一次，它会回到，或者别的什么。你知道我的意思。它。

它只是帮助我，就像我不必写一堆细胞是什么，另一个是什么。如果我有可以移动的魔法功能。四。这个过程看起来像，移动我的磁盘数量的桌子，-1。把他们从我的起薪中调走是暂时的。

我不想结束的地方，把它们从开始标记移到第三个。在那之后，我会做我该做的工作。

所有的，除了我的。会在这里，但我可以用我的，那是我唯一的线路，目的地。

所以，我会的。告诉那家伙。搬一张桌子。从起始页开始。到最后。这是我工作的一部分。

所以现在，在那之后。我有我的人要做，还有其他的。现在它的意思是，和所有其他的。

所以我要说。请递归地移动其余的光盘。第三钉。到最后。这有道理吗？我知道，我知道该走了。有一件事很重要，那就是缺失，对吧。少了什么。他告诉你，他的案子总是正确的答案。基本情况是什么？移动多少盘比较容易。

一个。你们真可爱。斯坦福，你还不够懒。搬桌子更容易。如果磁盘数为0长，请不要另谋高就。做这个。基本情况是你什么都不用做。所以我知道该走了，但我认为这是值得的。如果是密码。价格。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P7：【Lecture 07】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好的，所以我们一直在学习递归，有一些关于，我会说我实际上有几个哦，没关系，我希望我能做到，星期一晴朗，我想重申一点，你知道卡住了还是什么，看起来还不错，这很正常，它会变得更好，所以我想鼓励您。

就像花时间一样，这是一个正确的过程，我们要进行很多递归讲座的原因之一，重申喜欢它可能对您听到其他人有帮助，为我解释递归，您知道您实际上听说过递归，我的班级网页上有一些其他老师更好的视频。

这是朱莉·萨林斯基（Julie szalinski），她是我在斯坦福大学工作的榜样之一，她正在解释递归，这是他在斯图尔特·里吉斯（Stewart Regis）教授的课程，在华盛顿他也是我的导师。

也许他是我见过的最好的老师，这是他在解释递归，他用Java来做，但是概念是，如果在我解释时听不懂的话，可能还是一样，他们以一种对您有意义的方式对其进行解释，之后您的部分也将。

可能会以本周在您的部分中适合您的方式进行解释，听不同的声音可能会递归阅读一些书本内容，也许会练习一些您知道的问题，尽您所能来尝试建立那些，递归肌肉有老笑话写这个问题，递归是为了理解递归，您必须先，明白。

你知道吗，你见过我吗，不确定我是否可以上网，但是您是否看到过，等待着**丨*丨*，这不是亲爱的，你在吃递归，像是同一部漫画中的*漫画，无论如何我还是喜欢，顺便说一句，对于那些最终有一天要教书的人。

千万不要使用Google ，您演讲中的图像搜索不执行我刚刚做的事情，因为，我保证您搜索的几乎所有色情内容，我在一次演讲中发生了这种事，当时我在寻找一些东西， ，我对我有些色情，是的。

我们今天要继续进行更多递归，教你一些我认为特别酷的方面，递归就是使用递归绘制图形时，叫做分形，所以让我们做一个分形是一个自相似的数学。

等式或集，您通常可以将其绘制为循环图形模式，因此，然后看到具有相同图形较*版本的图形，基本上，如果您看一下这些图，这些是，分形，你可以freakin分裂成另外两棵树，你可以画出你想出，模式。

您会找到具有相同模式相似版本的方法，一遍又一遍，分形很酷，如果你看着我不知道你是否，可以看到那边的Coach雪花动画*东西，而且您知道模式越自相似，就越复杂，您插入的副本有时很酷。

具体取决于您的操作方式，分形的可视化有时您可以放大和缩*， ，它会显示它几乎就像您可以无限放大一样，因为它可以，无限地制作自己的更多层，非常整洁，所以分形很有趣这里有一些特定的分形。

流行的sierpinski三角形是Triforce，它越来越*，其他三角形里面的三角形我要让你将其编码为作业，问题是科克雪花在那里，三角形的边缘伸出三角形的三角形，然后，开始形成雪花形状。

还有娜娜洞穴套装，圈子很少，圈子与复杂域有关，数字和东西，但无论如何，可爱的*图案非常酷，那是底部，一个上面有颜色的颜色，但是颜色是独立的，你可以画任何，如果您愿意，可以选择黑白或彩色其中的其他颜色。

分形发现它实际上是自然发生的，很多自然，现象具有这种反复出现的视觉模式，然后非常酷，我不会花很多时间在上面，但这不只是一些虚假的。

计算机科学的东西，如果您愿意，您可以在自然界中看到它，分形的程序通常您要做的是编写一个函数，我的意思是，递归权，我们将使用调用自身的递归函数，通常你要做的是传递某种参数，关于在哪里绘制并帮助人们绘制它。

因为在不同的地方，打电话给您可能会绘制同一事物的更大或更*的版本，通常通过分形或，取决于您的书写方式，它可能是零级或最*的，最简单的一级就像一级，然后二级可能是多次出现，继续前进，好吧。

我们将看看如何在，现在，如果我们要画东西，我们必须知道如何画东西，我是，在本课程中，大部分时间对在图形上做很多工作都不感兴趣，我们解决的或有关数据文件，字符串和集合以及Max和。

Q和类似这样的东西不是图形密集型的，当然，要说的方式是在动画球和类似的东西，这个，但是仅仅为了这种材料，我们想做一点绘图，所以，这是您可以使用的几个函数我们的库中有一个。

斯坦福图书馆称为G窗口图形窗口我想我认为它们是，不言自明地传递坐标，它会画一条线，在这些点和坐标系库之间，因此只需使用这些，简单的功能我想我们可以做所有需要做的事情。

在屏幕上画东西是正方形图案的一个例子，的正方形，所以这是我的问题，我基本上完成了，这里的代码将绘制此图，但想法是您绘制一个正方形， ，然后在其四个角绘制较*的正方形，所以这就是为什么，在我的代码中。

我实际上是在进行彩排电话，这四个电话是，要画四个不同的*方块，我有蓝色的线，上面的蓝线是画一种，大广场，我的问题是，蓝线在哪里，函数在右上角的图片中产生输出，因为，取决于您将代码行放在何处。

它实际上会更改数字，会看起来像这样，以便理解问题，我是否应该将蓝线放入，放置DVD或II，先看一秒钟，然后我打电话给某人，回答您是否愿意与您的好友交谈一分钟，好吧，让我们比较第二个um的音符。

因为它们有一个，我应该将蓝线位置放在哪里的答案，答案可能是正确的，你为什么认为它属于那里，左上角在右下角，我的大方盘放在它们的顶部，表示需要我在其中之后晚于左上方和下方绘制。

正确的是前两个电话人口将流向X＆Y电话， ，右下角将变为正数，因此请在下面绘制第一个，然后在它们上面画一个大的我，然后在左边画右上角的身体，对我来说，我认为这是正确的，如果您仔细查看，将会看到。

同样的订单人也要缩*级别，我认为同一订单，坚持在这里，所以我认为这是选择EEE是的，实际上我不知道。

我应该做的是，您已经知道我有一个可爱的创作者项目，今天，我应该粘贴了这个，我不认为我在这里有这个，等等，想我可以做到这一点，让我们看看我是如此灵活，我将其称为四方分形，所以称为四方分形。

我将尝试快速绘制它，方形的分形窗口，比如说一百个，也许是200，200个， ，以三百个的大*绘制它，并以三个为单位，我认为这是正确的，然后我从没复制过这条线，所以画一个灰色方块。

像这样把它放在这里让我们尝试oops窗口不是哦，是GW Wow ，我的幻灯片无法编译哦，什么，你再也不信任我了，你喜欢它甚至不会遥不可及吗，我说会掉下来哇，好吧，没关系，为什么呢，呵呵。

XY叹了口气mm-hmm哦，好吧，这不是我的幻灯片，我复制了这张，从别人那里我以后再看，想调试一下，我仍然同意您的看法，代理机构的权利我不确定，想想也许我没有正确设置颜色或某些我没有真正设置的颜色。

仔细地看了看，是的，我认为这些坐标不正确，协调，因为如果您想绘制它，就像真的，是的，我想那是对的，然后这些都是错的，尺寸合适，因为如果尺寸超出尺寸，我会觉得尺寸太大了。

不知道我没有仔细看过我从未运行过此演示，刚刚粘贴了这个，有人帮了我吗，认为一件事是不同的是那上面那是灰色，所以我可以说，窗口点集将颜色设置为灰色，我认为这是我可以做的，但是后来，认为它仍然是。

我认为这只是我认为代码只是错误而已，还是我不知道我没看过你的话是在说，哦，你要我将尺寸超过2y加2以上，我可以确定，看起来像是来自地狱的QR码，好吧，无论您知道什么，我都没有，实际预期运行的东西。

我认为不幸的是，代码是。

集中注意力，但绘制顺序的原则是正确的，让我们来看一下，我认为比我想写的东西虚假的东西，称为Cantor集的东西，稍后我会修复此幻灯片，Cantor集是，也许这是我能找到的最简单的分形。

所以也许这对我们来说会很好，可以找到一个分形我们实际上可以正确编码这只是一条水平线，幸运的是，这就像最简单的雀斑，你可能会有，然后你要做的是，你做的线越来越*，分段，每个分段都是原始分段长度的三分之一。

因此，如果，你要在这里把这个做的更*一些，每个都是三分之一，三分之一，三分之一，三分之一，这样就可以了，想要将与您一起使用的Cantor集编码为C ++函数，并通过，事物的坐标和水平我想要的行数。

例如水平，一是第二级的一行，就像第三级和第三级的命中一样，比该值再下一个，因此传递所有这些参数，如果必须分开，我希望您将每个水平的y坐标向下调整20个像素。

级别好，所以这是Cantor集的一个可爱的创建函数，我们想要对其进行编码，因此我们采用的是一个仅用于窗口的参数，用于绘制并说画一条线或其他我们要获取的XY坐标，这是直线左边缘的XY坐标。

我们还有一个参数，用于指定线的长度和一个参数，我们需要画几级，所以这应该是递归的，这意味着我们的功能可能会，自称是自我相似，我知道艾希莉问你，在星期三，我在星期一问你，这个问题是怎么回事，自相似性对。

因此绘制Cantor集与绘制另一个相似的方式，康托尔设定这个问题的相似性如何，您可以提出这个问题，你自己，你可能会问自己的另一个问题是他的基本情况对不起我，只是以为也许我只是停止讲话而你脱口而出是什么。

良好的基本案例，例如我什至没有的Cantor简易绘画集，需要做任何递归的事情，所以我们可以从那里开始，这真的很容易，康托尔只画一个线肯定可以，所以如果只有一个级别，那么我想要的就是这个。

我不能画一条直线，但是那，那条线是我想要的那条线，想要的只是一个，然后好吧，让他从这个XY画一条线，它应该在水平线上，所以结束坐标是什么，是的，x +长，我向右移动了那么多像素，y值是多少。

它与原始Y值相同，因为它是水平的，是的，所以，让我们尝试一下，我将关闭这个我们永远不会说的四方分形，然后再说一次，画一个等级7也许我会画一个等级，五个Cantor集。

所以您知道要做的第一层是您知道基本情况，这是一个非常简单的案例，我们不必非常了解递归，了解如何绘制，让我们运行它，窗口点将颜色设置为黑色怎么样，哦，对了，所以我看不到，因为如果这是第一级。

我要通过第五级对不起，对，我以为我还是会做一级代码，因为我很傻，等等，是的，看那条线，看那条美丽的线，我，真的感觉我们今天正在进步，它说什么时间了，差不多是上课的一半了，我曾经发生过的最好的事情。

所以在这里我们走吧，你们觉得您的，学费钱完全他妈的浪费在这一刻，你不认为，无论如何，您可以像这样雇用一个能胜任飞行高级学校的人，有一条线我要庆祝那个**的胜利，我们有一条线好吗，这很容易，但是好吧。

如果它不是一个级别的话，好吧，我认为这是很多学生陷入困境的时候，他们，顺利，我做了简单的部分，但这就是简单的部分，我不知道如何去做困难的部分，我知道那会是某种，递归调用之类的东西。

但我不太了解如何将它们缝合在一起，所以我建议这可能有助于想到最简单的递归案例，这种情况比基础证明要难一点，查看VAD可以帮助您了解模式，如果它是第二级怎么办，如果现在是第二级，请不要考虑递归，尽管。

只是写一些我们不想保留的不好的代码，如果，等级等于两个好吧，所以想象你想象这是一级，如果是水平，则绘制此图像；如果是三级，则绘制此图像，就像没有任何记录一样，您最多只能枚举一百万，这会很愚蠢。

但是这样做可能会帮助我们看到一些好的东西，如果您正在执行第二级，则意味着您正在绘制此图形，并且正在绘制，这些对吧好吧，我们已经有了代码来划清界限，已经知道该怎么做，所以我将其复制并粘贴到此处。

那是第一线的大级别，我们还需要做什么，对于第二级，听我清楚我不知道我在做什么我需要你的帮助，在家举手，但接下来没有递归，只给我，看起来应该是这样的代码，好吧，再画两条较*的线，然后你说第一个。

从相同的XY处开始，然后超过y，再加上20，则更低，我想我说20点就可以了，它结束了吗，是原来长度的三分之一，正确的长度超过3y加20 ，然后还有另一条线在右侧，窗口画一条线。

那条线从X加上长度2的三分之二开始，长度乘以3y加20，然后在这里就像X加整个，长度y加20对，就像三个三行，第二层好吧，让我们去尝试Cantor ，设置让我们画一个级别2嗨，好吧。

我们的非递归递归函数是，到目前为止进展非常顺利，两个级别都还不错，它有助于我们很好地看到一个模式吗，您可能会注意到此代码的一些相似部分适合刚接触初学者的人，这在两个地方都正确，所以mm-hmm很有意思。

我可以尝试删除该冗余，也许如果我做三级，也许我会在那里看到一个模式，我不知道，让我们。

尝试三级三级，我将从中绘制所有这三级，第二级，再加上四行，嗯，听起来很像我的代码，不知道我是否想这样做，也许我们可以再次看这张照片，或者我。

猜我有一张ASCII艺术的图片，这是水平的，四对，所以四级康托集，您看到里面有其他康托集吗，康托集的那个，你看到那里有任何自相似吗，是的，请具体说明您在哪里看到另一种癌症，所以每个，如果我是水平的话。

您也可以将它们视为Cantor集，第四层，第四层，第三层，四个Cantor集，不能绘制，但看起来像这样的三层康托尔设置正确，但是，等待的不是这是什么，也不是这是什么样子。

而不是一遍又一遍地尝试枚举所有这些行，我们不能仅仅注意到四级康托集是一条宽广的线，其中有两个，在其下面的三层Cantor集上，您会看到我们可以编写代码，也代表这种理解，所以这里的一般模式是。

您所在的级别下有两个较*的级别中的两个，向下平移您的下方，因此，如果要对此进行概括，您不仅会说，再画两条线，你会说再画两条康托集，所以我要评论，一秒钟，我将摆脱一些额外的代码，我们，在这里。

我想要一种不仅适用于第二级的模式，如果您是一个人，我想要一种适用于所有事物的模式，在第二级绘制一条线，然后绘制两个第一级康托集（如果您是，第三级，画一条线，第二级，绘制康托尔集，这样理解。

我不应该再两次打电话给抽奖线，我应该再两次打电话给康托，次，但我必须弄清楚将哪些参数传递给其他Cantor ，确定如果这个人是我在第四级，我想画这个家伙在第三级。

我应该让他通过哪些XY位置来绘制自己的XY坐标，圈了一顶帽子，是的，它和我的X相同，距离我20像素，对，好的，它的长度是多少，长度超过三对，他的水平数是多少，比我少一，正确的水平数绘制三级康托集*一点。

当然，只有在我们的函数起作用的情况下才起作用，但是我的意思是，这样的想法好吧，另一位Cantor将其放在，右下角，这是这里的XY坐标， Cantor在同一窗口中设置X是多少，嘿。

有点像这里的坐标Y是y加xx的长度，这是我的长度除以三对，他是我的1/3，他的等级数是等级减去1（如果有帮助的话） ，您可以将其隔开，以便将它们排成一行，这就是两个递归，您相信Cantor集吗？

您相信此代码吗？ ，好吧，你知道为什么会这样是没有错的，因为在缅因州我说，两个级别，这就是我所要求的，所以我说了两个五个级别，现在让我们再试一次，看看那你想看到更多的水平，我的意思是我很少得到代码。

上班，所以我想稍微庆祝一下，胜利在领奖台上绕圈哦，看那个，看看所有这些家伙，没有那么酷的东西变*，甚至不能，看到细线了，好吧，我们现在对此非常好，我认为，快要完成了，我想说几件事。

删除这些我不再需要的行，但我想我的意思是，我暂时将这些台词，当我绘制这些临时行时传递的参数是相同的参数，我在递归调用中使用过，因此可能对我有所帮助，模式并查看关系，这就是为什么我那样做的原因。

关于此代码的另一件事是，我仍然有一点冗余，对，我仍然在两种情况下都出现这行代码，所以当然，我们了解到的是，您始终会知道if和if中是否有东西，在某些代码的else分支中，您应该将其移出代码，这样。

我想我会做的是我会以不同的方式思考，认为它是Cantor设定的基本情况，你们是对的， ，一级康托集是易于绘制的康托集，但是您还不够懒，Cantor的绘制比这更容易，这是一个零级Cantor设置。

所以如果级别为零，则无事可做，否则画一条线，然后画两个较*的康托集，你可能会说，等待远方，我不知道我是否相信代码还能继续工作，我的意思是，首先运行它仍然可以正常工作，我认为那里仍然可以正常工作。

所以仍然可以，可以，但是我想说服您，其原因只是跟踪，如果您用第一级来调用它，它不是基本情况，所以它，到这里画一条线，一级康托尔集是一条线，然后画，零级康托集，它们都什么都不做，所以一级仍然有效。

它在我们不必重复该案例之前的操作方式，因此，大多数人可能会写此代码的方式是，他们会说，级别大于零做到这一点，然后我可能会写其他基本情况做，没什么，实际上在大多数递归中，如果。

如果在此示例中还有一个else，则else是隐式的，它是一个，空的情况下基本情况是空的，所以这就是Cantor集，我们在这里，你可以画一条不同的线，就像我要做的是，线，但我也会在Y加1处画线。

这意味着它会变粗，为2像素厚，这样可能会使分形更容易看到粗线，你知道，但这是相同的原理，所以好的，我们在一分钟前有这个例子，基本上是用这段代码完成的，这里我们在一分钟前有一个例子。

填充矩形的顺序无效的代码，我想谈一谈这个顺序，我觉得这很有趣，如果您在此处暂停一下，因为您不知道50毫秒后，绘制每行，有一个叫做posit的函数，使程序等待片刻，您可以观看程序动画，以便观看细线绘制。

看看如何，你看着他们走，我认为令学生惊讶的是订单，他们认为我会从中画画，否则它会从左向右画出某种东西，好像在走，喜欢上下左右，如果您想的话，我会在一秒钟内再次运行它，该命令使某些人感到惊讶。

我会鼓励您考虑，下课后要做的是您去下载该程序或其他任何方法并尝试，重新排列语句以查看其如何更改动画，例如，我先进行递归调用，然后再画线，好吧，它是从较*的层次中汲取的，这不应该让您感到惊讶。

因为如果您查看代码在做什么，它会绘制较*的Cantor集，首先，然后吸引我，所以如果我是七级，它将吸引六位，在我之前，如果我是三级，它将在画出我之前画出二，它会在绘制之前知道较*的水平和较*的线条。

这就是代码所说的更大的一行，所以它应该不会太令人震惊，可以改变这种有趣的另一件事是什么，如果您更改这两个递归调用的顺序会发生什么，这样就可以从右向左扫一下，而不是从左扫到，就在那边。

所以我的意思是无论我向您展示这个，因为我想了很多，的学生需要练习才能了解递归的原理，在做什么以及何时做，这可能对您玩耍很有帮助，像这样的代码，并尝试更改它的一些*方面，以查看有什么影响，对于我的行为。

我认为观看动画绘制动画就像这样，观察发生这种情况的一种视觉方式，我已经谈到过，有时，在顶部的顶部放一个seeout语句，然后打印出，参数，然后当所有这些行都转储时，您可以查看，通话。

您可以看到发生了什么，这是另一种方法，了解这一过程，所以你们对，康托尔设置代码，好吧，嗯，我想做更多的例子，这里还有另一个分形。

幻灯片如此雪花分形，但我想我要留给，您想自己看看，作为另一个例子，我想跳到，下面是我们评估数学表达式的示例，我认为这是。

有趣，这是字符串，请问我要，向您传递一个代表数学计算的字符串，我希望您进行计算，并找出结果，这里有两个约束条件，使，如果有诸如加号或时间或，然后我保证我会在它们周围加上括号，所以如果我做一个。

加一我不会只写一加一我会加括号1加一，括号，因此从这个意义上讲，该字符串将是您可能会称呼的，当我们尝试处理时，完全用括号括起来，实际上希望看到最大值，所以我们写了一个括号，之前我认为代码在这里没有用。

但是有点相似，概念，我可以假设括号是匹配的，所以不用担心，非法屏幕让事情变得更简单我们还假设所有数字，是个位数，没有空格，唯一的运算符是，很快就会看到加倍或倍增的时间，我想如果可以的话。

与这两个一起工作，您大概可以与其他运营商一起工作八次，因为，好吧，所以我要你递归解决这个问题我要你解决，递归，所以这当然意味着我希望你看起来如此相似，您会考虑如何评估一个大表达式，类似于评估一些。

其他事情对，我也希望您考虑一下基本情况， ，时间我问一个问题好吧，所以我想让你考虑一下，也有基础，但很容易评估，所以也许您可以帮我，有了其中一些问题，您不必告诉我代码，只需给我，从概念上讲。

什么是不带括号的简单表达式？ ，这样分开很容易，好吧，我们是自相似的，如何评估表达式类似于评估其他表达式，所以我认为您说得对，您说过看看每一项中的计算，一对括号我有一张图表，如果您正在评估。

可能会有所帮助，像屏幕上的*块这样复杂的东西，也许我可以，使用该模型评估您知道的整个屏幕，让我们来看您所说的，这就像一个简单的，没有括号，而没有括号，我想我会给你一个我认为有帮助的起点。

为了解决这个问题，我认为解决这个问题的最好方法是，一直在查看的字符串中的索引，当您进行递归调用时，您可能会沿着，方式，这可以告诉您您当前正在寻找的角色，处，但这将有助于您消耗字符串并查看。

不同的角色，所以这是我认为您应该设置的方式，我认为，这有点不明显，所以如果我像测试一样给你，问题或作业问题我想给你一个提示，我想你应该做的就是写这个评估函数，您真正应该做的是写一个像评估助手这样的助手。

，接受这个应该是字符串X，然后还接受一个int表示什么索引，您所处的位置，然后在评估字符串时应使用的内容，说是打电话给您的评估助手传递此表达式并从索引开始，将字符串的开头设为零，然后继续进行计算。

街道上的其他地方还可以，所以我想做的所有实际工作，应该在这里我想实际评估故事的不同部分，是的，为什么我要把角色切掉，使用子字符串哦，只需将其更改为int index I ，可以做到这一点。

我想原因是因为也许，练习是我的功能必须具有确切的签名，所以这是一个，我添加我认为需要的其他参数而又不违反内容的方法，问题的作者要求我这样做是一个很好的问题，所以我想，按照您说的做。

您说的没有括号的字符串更容易，过程，所以我为什么不这样做，让我们看一下其中的角色，索引好吧，我可以说这个字符是否是括号，这是一个复杂的情况，否则可能只是一个数字，您可以，测试一个字符是否为数字。

可以说它是否为数字，在C ++中，称为digit的方法还有其他字符，例如is的方法， alpha会告诉您是否是字母之类的东西，如果它是数字，那是，可能很简单，只是一些数字，例如您所知道的字符，七点左右。

所以我想返回七点，所以您可能会说返回CH ，虽然不太正确，但是您知道那是什么错误吗？ ，实际上是一个字符，而不是整数，字符7不是同一件事，作为整数7，有几种方法可以将字符转换为，等价的整数。

你不能只是转换成int ，是的，我认为有一种方法叫做care to integer，您可以将其称为，您可以做的另一件事是，您可以说这个角色-为零，这是骇客，基本上将其转换为等效值，我将把它放回去。

整数好吧，这是一个简单的案例，这就是您告诉我要做的事情，括号，如果是这样的话，这个很好，如果有括号，请记住我是如何谈论的，基本案例，然后像最简单的案例一样从基本案例向上看，递归调用。

我认为我强调的可能是，最简单的递归调用一个括号是加int的，它大约和，你可以没事的，所以如果你要处理括号，我真的想，关于自我相似性，所以也许我要做的是，我可以在括号中看到。

我目前所在的索引可能会超出括号，我会说，索引加号现在转到下一个索引，我应该查看，跟随括号正确，所以我想抓住它，所以现在我想说，像护理CH 2等于x index这样的新索引，即，*插入符号指向哦。

我想将其转换为数字，所以我，想照顾整数，但是你看到我的东西怎么样，开始看起来像在其他情况下的东西，这可能是一个地方，如果我要求函数评估下一步，我可以在哪里进行递归，也要对此进行评估。

它会正确返回我想要的数字2，因此，自我相似之处是您有一个数字或一个括号，后跟一个，表达式，后跟一个运算符，后跟一个表达式，后跟一个，现在关闭括号为什么我叫二元表达式，因为不是， 2可能是4加6或其他。

但最基本的情况是，只是一个数字，所以我认为这里的想法是您具有某种剩余价值， ，您具有某种正确的价值，但您还没有操作过如何获得，离开时，您现在正用一点索引指向它，让我们对其进行评估。

评估在我当前执行的新索引的表达式中找到的内容，我现在了解，我认为为了让此功能正常运行，我们希望所有电话，共享相同的索引，以便它们一起在字符串中移动，所以我，建议将其转换为获取。

在这里初始化int索引等于零，您现在在这里传递索引，这些家伙，其中一个调用增加索引时，它将修改所有，他们，因为他们都一起走过字符串，所以如果我看到一个，括号向前移过去，现在评估值，现在左侧的表情。

完成后，它应该已经读过第二个，并且应该有，把它变成了第二，它应该已经返回了int离开它的结果，还应该将索引增加到下一个字符，因此每次阅读，角色，并与角色做一些事情，如果。

我们从这个递归调用中得到了第二个数字和索引，将指向此处，将指向，为了评估此表达式所需的运算符，什么是下一个护理运算符等于x括号索引，所以现在我们读一下，该字符，或者我不能称它为运算符。 。

我处理过的那个已经消耗掉的角色，所以我要索引，再加上也要经过它，现在我的光标在这里，所以现在我想，知道操作员另一端的情况如何找到，抱歉，嗯，我可以再次称它为评估助手，但是，我要正确地称呼它。

所以现在如果我们正在这样做，在这里的例子中，我这里有一个2，我这里有一个2， ，字符加在这里，所以现在我有了所有需要的信息，我知道了，数字是，我知道我应该对它们执行什么操作，应该获得支持加号和时间。

基本上如果操作员是加号的话，然后返回左+右，否则有时必须返回左时间，现在你可能会说，男孩，这很复杂，我不知道，我认为，可能无法编译，因为递归您必须从所有返回，可能的分支。

所以我认为我需要做的事情是我需要做的几件事，这样做，我将删除此数字，因为我假设，你不是在看括号，而是在看数字，应该处理所有情况，在您之后还有另一件事失踪，读取左括号，运算符和表达式，我也应该。

阅读结束括号，所以在这里我应该说索引+ +移到，关闭括号字符，让我们看看我在哪里评估是不明确的，在这里我从main调用它，让我在main中运行它，在这里我删除main ，在另一个文件中。

我们即将完成这个工作，称为主分形编译，怎么评价是模棱两可的，在值上应该说字符串表达式，然后运行，得到什么，它正在工作，嗯，我认为这看起来像是一种魔术或，令人困惑的我的建议是在类运行后下载此代码。

并在递归函数的开头放置渗出的语句以进行跟踪，通过它，网站上有一个递归分配， ，今天去看看好运士兵，我会看到你们。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P8：【Lecture 08】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

好的，今天是第四周星期一，这周回溯是，递归的特殊用法，因此我们将基于上周学到的知识，好消息是，如果递归是，仍然很棘手，我想这可能对你们中的很多人来说，继续练习，希望我们花更长的时间。

递归世界-您越会感到自在，那么好消息，关于递归的作业3在本星期五到期的网站上，知道每周的作业速度都相当快， ，分配会减慢一点，它会开始每个星期加一个，讲座，例如作业4不会在下周五到期，而是在。

之后是星期一，所以我知道红色标志的最后期限是一个雄心勃勃的期限，这是我们一周之内要做几次这样的原因的一部分，因为我们，试图将我们的车削时间表与106 8分开，以使该层甚至不，无论如何。

同一天有太多人陷入混乱，仅供参考，这就是我们现在在课堂上的位置，称为回溯，所以事不宜迟，我想我想开放我的。

今天的幻灯片，其中一些材料来自第8章，但大多数，这本书的第9章对此进行了介绍，我认为这是一个棘手的话题，递归本身很难理解，但我认为这个特殊之处，本周的内容有点像另一个棘手的概念，位于，递归。

所以我想当我把同等水平的课程带回来，知道1864年，当我上大学时，我发现这个主题很棘手，就像当老师一样，当我第一次教这堂课时，我发现这个题目很难教，所以你，知道这是我当然可以掌握的东西，但我认为。

就像我们学习递归一样，它需要时间练习并精通，这些东西，所以我特别鼓励您练习问题，我鼓励您，观看视频，然后随着时间的流逝尝试了解您的知识，好吧，让我们谈谈所谓的穷举搜索。

厌倦了详尽的搜索的地方是检查所有可能的地方，选项，选择或值，以查看哪个是正确的，然后搜索，解决问题的方法现在有很多方法可以穷举，搜索，但您可以使用以下方法彻底搜索某些问题，递归，例如上周。

当艾希莉（Ashley）发表演讲时，她谈到了，递归地爬行目录以打印所有文件（如果您正在，搜索具有特定名称的特定文件，您可以使用类似的名称，逻辑，除了在文件名上使用if-else来查看是否找到了它，因此。

递归通常是一种在空间中搜索某些东西的方法，因此，许多详尽的搜索问题会打印掉所有排列，尝试所有密码的名称，因为您要入侵学生，数据库来改变你的成绩所有这些东西都是在这里，想要详尽的叶子搜索。

所以很多时候搜索空间都有一组，选项，一组选项，一组值，并且您想尝试为，所有这些事情，所以让我谈一谈您可以采用的一般策略，在解决此类问题时使用，然后我们来看一些具体示例，我认为以下是有关如何解决。

您已经阅读了详尽的搜索问题，基本上是一个探索，除了代表您需要执行的一组决策的参数，做出或需要做出的一些选择，您会有， if-else结构，基本上就是您将用作递归基础的结构，案例与递归案例。

如果没有更多决策，基本案例就很好，我需要做的然后我什么也不需要做，我会停下来，否则，当我说自己时，我们的调用是指该函数的调用，您知道当我们进行递归操作时，所有调用会一起工作，是整体任务的一部分。

因此此调用将处理一个决定，我将，谈论什么是真正的决定，但我可以选择，做出可能遵循的所有其他决定，当我说探索时，然后我的函数也称为探索意味着递归，你知道在那里定义，所以我仍然认为这太模糊了，超级容易理解。

所以我认为用，例如，在您的家庭作业中，您需要做的问题之一是，以二进制形式打印数字，所以我想对数字进行其他处理，二进制文件，这与作业上的问题不同，所以不，我不是，这里没有透露您的问题解决方案。

这是我想要的另一个问题，我要做的是编写一个名为print all binary的函数，我会通过一个，位数二进制数我要您打印所有二进制，有那么多数字的数字都可以，我也不想，您使用循环。

我希望您仅通过递归来执行此操作，所以我们已经解决了，递归有关自相似之前的当前问题，对，我已经向您展示了所有两位数字二进制的输出示例，数字的样子，以及所有三位二进制数字的样子，这个自我相似吗？

我讲的二进制数字类似于打印其他，二进制数，是，是的，我想你的意思是，如果你给我所有的数字，打印两个二进制数所必需的然后打印任务，三个基本上只是一个数字，可能是0或1，所以。

实际上让我无法完成幻灯片上的所有操作，除非我将其全屏修复，模式，但就像这件事，这里是您会注意到的所有两位数字二进制数字，确切的输出出现在此处，并且出现在此处，所以从概念上来说。

如果我基本上需要打印二进制数字，我希望所有，二进制数的前面的数字，但是我想在前面加上零或在前面加上一，放在那的前面确实有意义，所以现在相似，但是怎么办，我实际上将其转换为代码，让我再向前滑动一张幻灯片。

好吧，实际上，让我跳到一个可爱的创作者，然后我们可以。

开始谈论这个问题，所以在这里，这个文件叫做print binary cpp ，实际上我认为在我的文件中，我将其称为打印二进制而不是打印，除了我，我想所有的东西都叫做打印二进制，所以让我重命名它。

如果您按shift ctrl RI可以只写打印所有二进制文件就可以了，所以，打印所有看起来像这样的二进制文件，而我写的是这样做的，好吧，好像您说的是我需要打印所有2位二进制文​​件。

数字前面有一个零，后面有一个1，所以大概是这样。

以下打印0，然后打印您知道的，所以如果我要打印到，我要做的三位数二进制数字是祈祷为0，然后打印，所有2位数的二进制数字正确，然后执行此操作后，我需要打印1 ，每当我们进行递归时。

紧随其后的是所有2位二进制数，还有另一件事，我们必须总是做正确的事情，所以，你们有一天受了很好的训练，你会冒着冷汗醒来，像是从现在开始的18年后，您将以案例为基础，而我却没有为此付出任何代价。

基本情况下，二进制数的位数很容易，打印出来，我什至不需要为某些人使用递归，可能会想一个数字，因为您只打印了一个零或您放了一个1或，不管是什么，没错，这很容易打印，但是你们。

真正学习拥抱递归思*的优雅懒惰，这是一个二进制数不是最简单的二进制数，打印零位数字是最容易打印的二进制数字，因此它是，如果数字位数为零，则所有内容都不会执行任何操作。

我不需要做任何其他更类似于此递归案例的事情，因此，当我说打印像数字一样的三位数二进制数字时，等于三，所以更像是n位数字，则更像是n ，减去一位数字，就是说您可以在其中看到这种关系，这些数字正确，好吧。

让我们做吧，C做零，然后打印，两位数字的二进制数可以，请打印所有二进制数-或不打印-我的计数，数字-写n减一右然后打印一个然后再打印所有的数字， 2位二进制数字再次正确，我要删除这些注释，因为我。

认为他们不是很有帮助，但没错，这样看来，也许我们已经，好的开始，所以现在在这里我要用三个，我们稍后再写其他功能，但我会注释掉，让我们，打印所有的三位数二进制数字打印所有的二进制三，哎呀。

它会在看起来不太完全的一行上全部打印一堆数字，对，这可能是因为我在最后在此处编写了indle的代码中，而且我不想结束一点点下降，我不想结束，我想在所有数字之后都结束所有的数字，所以也许我会做。

诸如此类的东西，但是我必须在某个地方闲逛，我在哪里做什么，我会像这样结束所有事情，也许是在我修剪了所有两位数的二进制数字之后，找出indle，然后在它之后查找所有已知的一位数字二进制文件。

我要在正确的地方得到这些恩德，发生了什么事，我的输出中有很多东西看起来好像不应该那样，那里很奇怪，所以我想备份一秒钟，我们正在使用的方法中有一些好的想法，但它不会引导我们，正确答案。

我们错过了一些重要的事情，我认为我们需要，要做的是，我们需要收集这些数字，直到我们拥有所有三个像，我们正在打印三位数的二进制数，我们需要收集所有，数字，然后一旦我们有三位数，我们需要将它们打印出来。

您知道我吗，意味着我们在打印任何东西之前需要精确地三位数，所以，您能很好地收集数字吗？您可以像存储一样存储我们的数字，您可以将它们存储在变量中的任何其他内容，或者如果我们现在，将它们打印为输出。

我认为存储输出的最佳方法只是在，字符串，但是如果我创建一个字符串，则我希望该字符串存在于两个字符串之间，递归的不同调用，随着它逐渐增长到3或4 ，或我想要的长度是多少，我需要在整个过程中，各种函数调用。

所以如果我在这里声明一个字符串，那不是，真的会起作用，因为这意味着每个函数调用都会有其，自己的字符串，我有点想要共享和传递的字符串，这些不同的函数调用之间，所以我们要诀，在这里工作。

我上周五做的时候很简短地提到了这一点，那rushon的秋天，但我认为那个例子是，有点令人讨厌和棘手，但是您可以在其中做一些技巧。

递归，在其中编写所谓的辅助函数，该函数需要额外的时间，参数，所以我们被要求解决这个需要整数的二进制问题，并打印此输出，我们已经决定也许我们想要其他参数，也许我们想传递一个字符串或传递一些其他信息。

并不是真的应该更改打印所有二进制函数的标题，问题是给我们提供了一组预期的参数，我们，需要编写代码以使用预期的那些参数，但是，如果我们已经决定，出于递归的目的，我们可能想要的不仅仅是，我们想要更多的参数。

我们要做的是在某种程度上，编写其他一些函数，这些函数需要我们需要的额外参数，然后，我们使所需的函数调用我们的函数，然后我们的函数执行所有，真正的工作还可以，所以这就是我们将在此处使用的技巧， 。

我想传递的额外参数是输出字符串，所以我们做点什么。

像这样，让我们​​作空打印所有我喜欢命名的二进制助手，帮手，因为它可以很清楚地说明其用途，而我要做的是，我仍将采用整数数字，并且还将采用字符串，打印输出，所以也许我还不清楚我在做什么，在这里。

但是这些问题被证明是一个问题，所以我要用这个，的字符串不是打印每个0或打印我将要构建的每个，它们变成一串零和一，一旦我得到三个，或者是，正确的数量，我将打印出字符串，这使。

所以我基本上将从这里的打印二进制文件中获取此代码，到目前为止，我将其剪切并将其粘贴在这里，除非我会改变，这些呼叫说是helper helper，想法是此功能在这里，不败的人实际上要求写这个问题，我只是。

用它跳到这个真正可以完成工作的功能，所以我将，只是说打印所有二进制帮助程序，我将传递数字，然后传递一些，某种输出字符串，最初是我在，如果我只是开始，那么这一切的开始就是这样的开始，在递归过程中。

我当时的输出是什么， ，我听到几个人在喃喃自语或窃窃私语，或者，没关系，所以我现在要做的是，打印这些零和一个我将在字符串上放置零和一个，我正在构建的输出中，所以此参数的含义是，捕获我们要打印的输出。

所以我要对此进行注释， ，我要对此发表评论，我必须将输出字符串传递给它，递归调用，我传递的输出与此类似，为零，呼叫，并且该呼叫确实类似于1，所以与其，清除这些，我将它们作为字符串传递给他们。

但是您会注意到，你有敏锐的眼睛，我在代码中什么地方都没有创建任何东西，正确了，所以我的演绎能力告诉我，除非某处有一个座位声明，否则我们将不会看到任何输出，所以在哪里应该有一个outout语句。

我正在构建这些字符串，输出最终会在哪里打印出来，您怎么看？ ，低音情况很好，是递归中任何问题的好答案，可以在这种情况下碰巧是正确的答案，是的，您要打印，这些字符串在基本情况下。

所以我认为想法是您将print称为二进制， 3的调用打印二进制文件2的调用打印二进制文件1的调用，打印二进制0，并且所有这些调用都建立了这个，字符串，最后当您打印二进制0时，您说剪切我有一个。

字符串让我们打印我一直在构建的字符串，而不是将，所有人都什么都不做，实际上我会找出输出包络，所以这是，仍然是基本案例打印我们构建的字符串递归案例，现在建立零和那个代码，如果我运行，它还是不太正确。

我看到的输出甚至比以前更差，所以我想谈一谈，为什么它仍然不起作用，我们非常接近正确的答案，而且我认为，与许多递归算法一样，很难理解，除非您插入一些用于调试的临时输出，否则实际情况是什么。

我什至知道我已经在做什么，我什至做到了，递归有时理解您的代码有时很棘手，我将插入一个C ，出来说打印助手，我先打印数字，然后再打印，嵌套引号我将打印输出，所以这就是我，只是在跟踪这些电话。

这就是我所看到的，不带字符串的三进制prynt二进制，然后打印二进制，直到零，然后，以0毫米打印一个二进制文件好吧，我仍然认为这有点难，阅读，所以我会告诉你，我有一个特殊的调试功能。

我认为这使您不必再使用它就容易一些，功课或其他，但我喜欢在课堂上做，因为我认为这有助于，输出更容易理解，所以我有一个标题，我不知道我是否已经，包括递归点H有人给我发送了一封电子邮件。

如果该标头包含您自己，应该会很有趣，因为无论如何，但是不，或者或者也许我在其中插入了一个包含，本身不，但是那会很有趣，所以给您的是一个新功能， ，您可以调用名称递归缩进，如果您插入它，将执行以下操作：

，它将根据递归的多少级别缩进输出行，您现在所处的位置很深，因此将输出变为，递归3调用递归2调用递归1调用a ，递归零，最后还打印了一个东西递归一，用一个来称呼这个。

所以您看到每个呼叫如何导致另外两个呼叫，你看到了吗，然后这个电话导致了，导致了哦，不，不要，重新排列我的应用程序糟糕，这也导致您这样做，看看每次通话后叉如何分成两个较*的通话，很难知道发生了什么。

但这是我该向你展示我的想法了，我在幻灯片上有一张图片，也试图说明在哪里。

所以在这里，如果您调用print binary，则每个调用将再发出两个调用，再打两次电话这又打两次电话很有意义，因为，二进制文件，因此您尝试在一个调用中进行零调用，现在很多递归，到目前为止。

我们几乎已经看到，每个调用几乎都进行一次递归，调用是一种典型的最简单的递归过程， ，我们的很多示例都是在这种情况下，您在每个示例中都进行了多次调用，级别以及您打多个电话的原因是因为您正在探索所有。

选项会考虑这个问题，就像是我打电话给我的罐子一样，我们正在打第二个电话，我的职责是选择一个数字的值，该二进制输出，我可以选择一个零或一个一个，但实际上我需要做的是尝试同时服用两者，首先为零，然后设为零。

然后看看我这样做之后会发生什么，完成后，我还需要尝试选择一个，不是我只选择一个，一个或另一个是我要尝试两个我将详尽搜索，二进制数字的空间还可以，到目前为止我们的代码中存在的问题。

也许您见过的某人实际上是我们添加的原因，屏幕是因为我想在所有通话之间建立输出，已经积累了一大串英雄或其他东西，所以你去了，在屏幕上，您会看到二进制文件是我们的代码的目标。

这样做是不是您了解我们的代码有什么问题或需要做什么呢？ ，为了使字符串随着时间增长和积累，出了什么问题， ，我该如何解决呢，是的，问题是想一想，但是你说的对，我们说的是对的。 。

而不是这个漂亮的零传递零，我需要像输出那样传递，在我和我们之前，所以请考虑所有这些电话的链条，互相呼叫第一个呼叫经过一个空字符串，它们将输出的单个字符串传递给其跟随者。

这些功能应该将两个字符串传递给其跟随者，输出那些跟随者的跟随者，将三个，字符串，但此字符串需要在其中添加一个字符，从我之前的人那里寄给我的东西，所以你真正需要做的是，嘿，上一个电话给我发送了一些输出。

我想要那个输出，我想要，该输出后跟零，然后我也想尝试该输出后跟，一个，因此，如果您要跟踪这些呼叫，则初始呼叫会通过，所以让我们，再次运行示例输出以查看此处的不同调用，所以这是。

我打电话给带有三个数字的空字符串的打印助手， ，使两个递归调用停止它停止它doc好的等待我可以做到这一点我发誓，用过他，不是那么烦人吗，没什么太大的不同，比我上学的时候更讨厌所有的老师都这么讨厌。

电脑花了他15分钟才能插入投影机，通常，分辨率都很糟糕，所以一切都大*不对，然后它们就做出了，他们的字体像这样大，就像任何问题都使雾蒙蒙，足够大，我可以读懂，对吗我就回到那里，你看不懂你。

我的眼睛比我大，但我老了，但我知道你看不懂这句话， ，大字体使窗口达到我想要的大*，现在我，做一个老师好吧，所以我加了这个ctrl + cuz我在，对抗*字体我是字体精英，所以好的，三个打两个电话。

使两个打印助手，那里有一个零，它使两个打印助手对不起，我无法绘制，但是它使打印助手成为呼叫对象，随后是一个呼叫助手，所以您看到了吗，它分叉到这两个电话中，您可以分辨出是否是因为。

缩进权以零开始的打印助手说好吧，让我，探索可以跟随那个零的东西我可以跟随那个零和另一个零，或者我可以用一个1跟随那个零，所以我将其作为我的两个递归，电话，然后这个有两个零的家伙说的很好。

我可以在两个零后面加上一个零或一个，所以这个调用使，这两个电话，然后这两个电话，您会在这里看到一些差距，这是因为，在旁边这两个电话说嘿数字是零我是一个基数，情况下。

我将打印出我和所有呼叫伙伴已构建的字符串，我们构建的字符串是零零零，它显示为输出，那么这个家伙是，完成后，他回到这里的父级，继续进行第二个通话，这是一种基本情况下打印此，因此基本上输出结束。

打印出来是所有不同的可能性，现在存在的数字将您知道的大脑弯成椒盐脆饼，我认为前几次，您会看到这种类型的代码，很难编写这样的代码，甚至很难看懂它，你知道该怎么做，但我希望你有点开始成为。

确信此代码将探索并打印代表所有字符串的字符串，给定数量的二进制数字的位数（如果我关闭打印） ，声明，然后我决定我可以尝试四次，哎呀，为什么我，今天在这里有很多空白行，我是否省略了某种原因。

为什么我有空白，哦，我在这里有恩怨我不想要这些indel，对不起唯一， Endel应该在我打印输出字符串之后出现，所以让我尝试两个，所以我认为看起来正确，它说打印二进制3，但是应该，是你应该说四位。

所以我认为这是所有不同的四位数，二进制数，当然也存在自我相似性，因为，块是所有三位二进制数，并且出现了相同的块，再次在其他输出的下半年，好了，所以我认为这一课，这里带走的是，如果您想彻底探索一个空间。

，函数调用通常会多次调用每个后继调用，选择它可以使您仍然拥有与我们一样的原则，兄弟姐妹们的乐队在一起，每个*功能都会召唤一个，一点点的工作，你对那块，如果我们要制作数字，我们会选择数字。

那么工作可能会很好，如果您想做一个听起来很难的十位二进制数字，请处理一位数字，不知道该怎么做，但我会做十个数字之一，还不错，因此，对于我们每个人所做的一*部分工作，都采用相同的理由，那仍然存在。

但与众不同的是，代替我而已的只是一个，后继函数调用在这种情况下，我进行了一组后继函数调用，两个有时更多，最终在所有这些函数调用的结果之后，积累我会建立一些我们所有人都会建立的东西。

在这种情况下要执行的字符串，一旦完成构建，便会累积显示，或用它做点什么，但是函数调用将继续进行，其他后续函数调用，我们最终将构建许多不同的函数，我们将构建所​​有可能的选项的所有组合。

那里有这样的代码在我脑海中也反过来，案例是什么，或者它意味着什么，我们已经讨论了基本案例，就像这样，问题的简单版本，因果关系如果您要反转一个字符串，那么很容易找到该字符串，反向，它是空的。

或者是你知道的一个字母，那还好，这是我们在这里所做的事情，但在这种情况下，问题就更少了，简单，主要要求我们打印零位数字，这不是完全正确，不仅仅是我的前一个函数调用要求我打印零位数字，我们还是，一堆电话。

有四位数的电话和三位数的电话，然后我将两个数字称为一个数字，然后将I和列零数字称为I ，除了我之前所有的家伙都做过很多事情以外，没有太多工作要做，工作我必须承担他们得到的所有工作并显示出来。

所以现在是基本案例，可以被认为是所有工作的终点，为其付费的呼叫，而不是简单的切入点，没有任何工作，所以我的意思是这就是我对这些事情的看法，花费一些时间来适应um，你们到目前为止对。

关于到目前为止我们写的这段代码是，为什么我们不需要打印所有二进制文件，这是一个很好的问题，为什么我不只是，在缅因州打电话给我，我可以打电话给print binary Helper或重命名。

打印二进制帮助程序以打印所有二进制文件，我认为原因是，也许，指定此问题的人说，我要您编写此函数，然后我，希望它完全采用这些参数，并且不让您满意我的，要求必须是真实的，但是您说得很好，但是为了做到。

递归我想传递这个字符串，所以这两个之间不匹配，事情等等，如果你只得到，参数，但您也可以在其中使用一个字符串，递归是您创建了另一个具有字符串的函数，并且您，使所需的函数调用您的函数，只要您的函数，递归的。

那么你基本上就遵循了我之前问过的约束，是的，但是如果我们只是为自己编写这段代码，那么您是对的，我们，根本没有任何外部约束，我们只能写，助手和主要主叫然后助手和主要主叫必须通过，这个空字符串来启动进程。

但是那不适合你，谢谢继续，哦，为什么不为什么不把零放在前面，就像零加输出1加输出I ，猜想是因为像输出是我之前调用的内容，所以我觉得我在通话中正在做的事情是在补充他们所做的事情。

这是他们的工作加上我的工作，我的工作是零，那么我的工作是1 ，如果我将其移动到其他方式，它仍然可以工作，但我认为，打印出来的组合会改变，我很乐意这样运行，证明它没有什么不对。

除非问题陈述说订单需要匹配我的订单，否则它，以一点不同的顺序打印它们，您看到这里的情况如何吗，首先翻转是因为第一个调用很好，前三个调用选择了零，而第四个电话选择了一个零，但是当第四个电话选择了一个。

它是一个在前面，所以我的意思是它仍然可以工作，因为我喜欢在每次通话都添加到之前内容的结尾时考虑它，它，但是其他订单没有错，就这么快，如果您想使用以十进制为基数的十进制数字来执行此操作。

因为我想继续前进，所以不打算穿这件衣服，但是如果你这样做，以10为基数，您基本上会遇到类似的问题，除了，只有0和1，您就拥有了所有10位数字，那么您该怎么做，好吧，您可以一起使用递归和循环。

而不必只有两个，从每个现有呼叫派生的呼叫，您有10个，但我不知道，有那些树的图片，但基本上功能看起来像这样0 ，并以每个数字1到1的比例呼叫帮手，呼叫0到9 ，有了这个数字。

我现在可以说等一下Marty，您说没有递归， ，循环，您不能将它们混在一起，您说没有循环，有些情况下，像这样，循环是描述不同事物的一种优雅方式，后继函数调用make，但是整个过程仍然是递归的，因此在。

如果我要您解决此作业或测试之类的问题，我想说的是，只要您的整体过程可以使用循环，草书利润，您可以稍后充水或稍后追溯，但这基本上是，完全一样的代码，只不过我要遍历十个数字以进行递归，调用。

而不仅仅是手动提及两个数字以进行函数调用，我可以写成一个零的调用，然后用1和一个调用，我也可以用它来调用10行代码，会没事的，所以这是唯一的不同，告诉你有时候循环是可以的，让我们来看另一个问题，所以。

这种详尽搜索的特殊变化称为，回溯回溯是当您对其进行详尽搜索时，会陷入所谓的坏状态，而您不喜欢那里，已经获得，您想回溯，现在在，以前的问题没有这样的问题，因为我们要打印所有，二进制数字。

但有时我不想打印所有我不想打印的数字，处理所有我想找到的东西，所以这里有一些例子，可能会这样做，您可能想搜索一个单词的字谜或，国际象棋的移动策略和国际象棋棋盘是一个很好的例子，您知道。

深蓝色的播放Kasparov的计算机以及所有填充方式，脑部工作是尝试所有这些不同的国际象棋动作，然后检查，看看他们的表现如何，如果不好，则备份并尝试，这正是我所说的回溯，你尝试了一堆，选项回溯。

如果您不喜欢事情的进展，那么让我们看一下，首先，我将向您展示如何执行此操作的伪代码，回溯基本上与执行此操作的伪代码完全相同，因为我，如果您不喜欢自己的位置，则搜索做所谓的“选择欧盟”也会回溯。

所以我有本周使用的这种口头禅，您可能会听到，一遍又一遍，您会在“选择浏览”部分中听到，选择范式，我认为随着我们的观察，它将变得更加容易理解，一些代码，所以让我无需进一步尝试尝试演示。

问题我想和你们一起写一个叫骰子的函数，我会通过，一个无畏的结局，我想掷出一些病态的骰子，我也会像某些人一样通过你，我试图找出所有，骰子值的组合，如果您添加那么多骰子，您将获得，那个精确的总和。

所以将两个骰子控制过程中的一些骰子打印到七个，给你完全可以滚动到给你七点，现在得到它，这是二元绘画中的自相似性，在屏幕上显而易见，因为您可以使用两位数的二进制数字，只是将它们叠加在右侧，它们就在那儿。

但这就是，这里不是很正确，我的意思是如果您没有看到右侧的输出，考虑一下问题的性质，应该清楚为什么会这样，但是好吧，这个问题在很多方面确实与，打印二进制问题它仍然递归您仍然每个，打电话做一些工作。

我们需要跟踪工作，我们已经完成了类似于使用字符串来跟踪的方式，当我们使二进制数字正常工作的时候，所以让我问你一些，如果您有很多函数调用在工作，那么您会质疑单词的单位是什么。

我们一起试图找到三个骰子加起来的所有方法，无论冰的数量多少，您认为每种冰都属于某种工作单位，函数调用我的句柄，你认为滚动一个家伙好吗，如果有的话，也许三个骰子，那么我们将执行三个函数调用。

一个将处理每个骰子，好吧，如果我要带我去找第二个人的话，由da处理是什么意思，知道了，是的，我得到了什么，这意味着我要做什么，我想我是，决定它的价值是什么，但是让我更具体一点，我正在使你，完全正确。

但是现在你会发生什么，我该怎么办，我们正在谈论探索，几乎详尽地搜索了我所具有的价值是什么，你说甚至要去死，你减去，好吧，把它滚开，然后，如果我滚到五，那么现在那是五个，有人在努力做到正确。

我需要你尝试不同的价值观才能看到，如果他们让我接近目标，就让我接近目标，但我要尝试，我要尝试的所有值之一到六，因为我不知道那是什么，实际上可以将我的工作的几个价值很好地组合在一起，这就是。

这种思考过程还可以，让我们也考虑一下基本案例，多少次潜水很容易将零推到正确的位置，也许一个人死了，容易滚动，但比起零骰子是最简单的数字，我更懒惰，骰子滚动得很好，你什么都没做，所以让我们尝试写这个骰子。

我们将要编写的函数称为“骰子”，它需要一些，骰子和期望的一些好吧，如果骰子的数量为0，让我们尝试去做，好吧，如果有的话，就不要做上一个问题听起来很熟悉的事情，我将需要尝试至少一个骰子。

所以我将处理所有可能的骰子，值表示从一到六，看它们是否可以正常工作，话是什么意思，那就是我会尽我所能，然后看看会发生什么，然后我也会尝试我的骰子光束，看看会发生什么然后我会尝试我的骰子，是三岁，等等。

好吧，尝试一到六的数字我可以使用， for循环for right在两个等于1的循环中，我上升到六个I加号，对于这些值中的每一个，我将选择我作为我的，值，然后我将探讨可能发生的情况，然后。

在我完成探索之后，我要去吃午餐了，那就是我，需要做的如何在二元问题中很好地选择事物，数字我们怎么记得我们选择的，是的，我们将其正确地放入该字符串中。

这里的输出看起来并不像巧合那样，集合会在我们库中的输出中正确显示，所以我认为，我想在这里建立一个骰子值的集合。

到目前为止，我选择的还可以，但是我该如何在哪里放置该收藏呢？ ，希望您看到与二进制问题的相似之处，如果我要添加一个收藏，这里没有收藏，我应该从中做出一个参数，并增加该集合的种类，随着时间的流逝。

就像我随，做二进制数，所以骰子掷骰的值是英兹的，也许是向量，所以我为什么不真正做一个骰子，然后再做一些骰子，帮助器，我要添加的是intz的向量，这是我拥有的值。

到目前为止选择的就像我从另一个问题中得到的字符串一样，您通过收藏集，通常会通过参考传递它们，否则您将，制作副本以及它们的副本和副本，以便我将其作为矢量传递，现在参考，以便使调用类似于常规骰子。

一些需要打电话给助手，所以我需要给骰子打电话给一些助手，事情开始了，我会通过我感兴趣的骰子的数量，所需的总和我对传递给向量的东西感兴趣，最初是在所有这些操作开始时选择的，所以我没有选择任何东西，因此。

你会说的方式就是只说做一个称为V的intz向量，无论通过V还是传递一个空向量只是为了使事情顺利进行，所以，现在我要住在助手中，我要处理该代码，所以它做什么。

选择我的意思是我该如何指示我如何记住我如何保持追踪，选择了我，是的，把它放在向量中，向量就是用来存储我的东西，选择了点添加，现在我需要探索所有可能的东西，很好地遵循，看起来说探索的部分就是递归部分。

写下来探索意味着递归，所以我需要进行递归调用，下一个电话应该选择我在选择价值后应该做什么，所以我，将给骰子打电话给一些帮手，我应该传递多少参数，骰子下一个家伙需要处理我的骰子数减去一个对数，因为我。

我选了一个我选了我的饮食，当我死了的时候， ，下一个家伙试图达到我儿子的水平，除了我选择了我的价值，所以，让我们从试图达到正确期望的总数中削减很多，总和减去我，我将传递所选骰子的相同向量，我们都是。

通过所有这些电话共享，当我回来的时候，本来应该选择的，如果您愿意，我们可以稍后再讲，看起来我想谈谈我写的这个基本情况lul不做任何事，通常是回溯问题或详尽无遗的正确答案，搜索问题。

我谈到了基本情况在这些情况下的含义，意味着有些不同，这意味着我之前完成的通话，工作，轮到我了，别无他法，因为其他所有工作，呼叫完成了所有工作，所以如果我处于零的情况下我该怎么办，那我是什么意思。

我应该打印所有伟大的作品，这些呼叫在我之前完成，找出了像这样打印出的所有矢量，他们做得很好的选择，我不知道我们可以尝试，我不知道是否，会工作，但我想免费尝试所有骰子，以求得七个骰子的总和，幻灯片。

我知道输出应该是什么，所以让我们运行它并查看它，看起来很像二进制数字，不是因为我很健忘， ，应该被称为其他名称，而我正在使用的文件应该是，叫我好吧，让我们再试一次，如果您的病媒持续增长超过四个*时。

请致电医生，这个向量不断增长，在某个时候我们需要增长，将东西拉出向量，因为记住我们正在尝试滚动，三个骰子，这时我们打印了向量，因为其中有三个骰子，好的，让我们看一下函数调用，再次，所以找出递归缩进。

然后将一些辅助括号切成*方块，骰子逗号需要一些祝福你逗号，然后选择，所以我可以看，通话正确，哦，我们要穿很多衣服哦，我的天哪，是的，所以，我认为它做得很好，我们将三分之七切成*方块，已被选中。

然后我们尝试选择一个，因为请记住这个家伙，这将最终使make六个功能调用六个六个功能，称这是一个，这里是另一个，依此类推，但是嗯，我们，需要做的是，我们需要选择价值，探索可能发生的事情，然后。

当它回来时，我们需要取消选择一个，然后继续探索来，返回取消选择三项，探索遵循的三项回到第三项，您了解我们是否需要扭转，例如我们要添加一些东西，这个向量，当这些调用返回时，我们进行递归调用。

向量返回之前的状态，这样向量就不会越来越大，并像这样成长，这就是我们所说的不选择的步骤，我该如何，撤消我的选择，看起来通常与您所做的完全相反，当您做出选择时，选择是我将数字I放入向量中，想要撤消。

所以我需要从向量中删除值i ，*心，因为如果您只是保存而选择了移开眼睛，那是不正确的，因为那删除了要删除的参数，而不是要删除的值，从中删除索引，这意味着不会做您想要的，我认为有一种方法称为“删除回去”。

这意味着只需删除最后一个，最后添加的元素是我的，所以我认为，做我想做的事，但是如果我再运行一次，那就太难了，仍然会产生很多输出，但是现在输出看起来要多一点，合理，它会打印出一一一五一一六的数字。

我们做得更好，除了哎呀，我们正在打印所有可能的骰子组合，这不完全是我们应该做的，仍然整洁，详尽地打印了所有内容，但我们并没有完全解决整个问题，我想打印那些加起来等于特定金额的。

所以我如何将其整合到我的解决方案中，让我向您介绍一种方法，这实际上并不理想，因为我们可以做的就是在当下，我们将要打印这个，可以说您每分钟知道1 + 1个盘子，错误的歌曲，如果总和错误，我们就无法打印它。

在基本情况下，这似乎是一件很合理的事情，可以说嘿，如果向量的总和是正确的，然后打印出来，我怎么知道，如果向量的总和是正确的，我怎么知道，好吧，我可以遍历向量并将其加起来，但是有一些更简单的方法。

比我可以说的，如果期望的总和恰好为零，则意味着，沿途的一系列选择完全消除了，想要的儿子，直到他减少到零，而不是如果仍然是五，我没有将其撕裂得足够远，或者如果它为负值17我将其远离得太远了，对。

如果期望的总和为零，我希望你，了解这意味着通话完全找到正确的总数，因此，我再次运行它，然后告诉您我将关闭该调试输出cuz ，我认为此刻没有帮助，所以让我再次运行它，嘿，我已经，得到了输出，是的。

我做到了，最重要的是我们是否获得正确的输出，输出，因为你学到了，你就把功课还给你哦，等不，我们是刻薄严格的，我们关心我们关心的算法，风格我在乎效率我必须要一秒钟你必须要，第二。

但是这种解决方案可能不理想，在，对，我给你这张照片结束，然后我们回家。

好吧，我不会结束你，但我会以这张照片结束讲座，通过整个可能性树，甚至那些没有机会成为可能性的树，对，因为他们离这里太远了，我们不需要这样做，可以使其代码更高效，从而避免做类似我的事情。

当我们从这里恢复时，我们将在周三进行探讨，但是您可以考虑一下，从那时到现在下次见。

【斯坦福大学】CS106B C++中的抽象编程 · 2018年冬（完结·中英字幕·机翻） - P9：【Lecture 09】CS106B Programming Abstractions in C++ Win 2018 - 鬼谷良师 - BV1G7411k7jG

所以现在是第四周，是星期三，我们一直在研究递归回溯， ，今天我们将继续做更多的事情，这基本上是，这整个礼拜是你第四份作业的主题，在本周末结束，是的，那就是我们要做的，我只想做，我认为练习越多。

您看到的示例越多，它就越有意义。 ，鼓励您像往常一样独立练习，并且在本节中您还知道，接下来的几天，您还将获得更多练习，所以我想回到，上次我们正在尝试打印的所有问题。

导致某个太阳的掷骰子记得这一点，我们以此结束了课堂，我们实际上完成了它，让它正常工作，我将向您展示我们。

编写这是代码现在有几件事只是为了提醒您一些，沿途进行递归回溯时出现的概念，这是进行递归回溯时常用的技巧，因为，每个电话都会做出选择，您会收集一系列选择，然后，您与他们一起做某事，因此您需要跟踪那些选择。

是在解决这个特定问题的过程中做出的选择，在向量中保持跟踪，我们称其为向量选择，所以这意味着，您运行此函数，主函数要求三到七个三的骰子总和，掷骰子以使总和为7，它会打印所有这些组合，这是完全正确的。

但我想我在上课结束时曾简短地说过，真的不认为这是一个很好的解决方案，总的来说不好，这个解决方案我不知道该如何转弯，所以你会看到我的支票，希望课堂上传达的信息无论如何都不会太乏味。

这个解决方案的缺点不是什么？您认为有什么更好的解决方案？ ，关于它是的，它会检查每种可能性，即使其中一些可能性，不会导致好的结果，所以，如果您希望将其具体化，让我尝试帮助我做一些我不想让你做的事情。

我要给你看一些有点烂，有点脏的东西，但你知道，你们已经长大了，我想你可以应付，我要告诉你，称为全局变量的东西现在是全局变量，当您声明一个，您所有函数之外的变量现在我们通常不这样做。

因为限制程序中的数据范围很重要，以避免， bug可以更好地分离，但仅一*会儿，我将这样做，因为我想将其用于特定目的，所以我想计算，我们的函数被调用的次数就可以了，所以每次我们调用此函数时，我们写的帮手。

我要说的是电话加号，然后再加上，缅因州，我要看看总共C个电话花了多少电话： ，打电话好了，那就让我们运行吧，它需要259个电话，好吧，我不知道，知道也许那是我不知道那是好是坏我不知道让我们尝试。

掷骰子给我们11个中的一些，让我们看看结果如何打出1555个电话，这种调用很多，函数调用会产生开销，性能损失有太多的函数调用，我想你说的是，是某些功能调用可能不是必需的，所以我不知道。

如果只是从这个角度来看很明显，但是你知道我试图画这个，哎呀的图片我刚才做了什么对不起，我点击了错误的地方，它，我以某种方式丢掉了这里的东西，就像我们的，代码正在模糊地执行这样的操作，您知道我们正在计算。

我第一次可以在三口骰子上掷骰子，是从一到六的值，我们会尽力尝试为什么选择第一个意味着六个然后探索一个，一堆可能会在它发生后发生的事情，我们知道，右边显示的数字实际上是人类比我想表达的更强的陈述。

掷三个骰子，第一个骰子最大的价值是什么，我什至可以画三个，因为剩下的家伙必须至少是一个也对，所以如果第一个家伙，甚至是四到五个，剩下的两个家伙说最*，努力去做至少六到七个这样的事情，所以这是。

浪费很多电话，好吧，所以我要做的就是，尝试对我们的程序进行*的优化，这样我们就不会打电话，如果很明显，如果。

您可以在骰子中查看此代码，并编写一些函数，我们写的书给我们任何想法，例如如何分辨，值得打电话还是不打电话，意味着另一种说法，那就是说如果我们进入某种状态，我们知道那不可能从这里解决，也许我们会。

立即备份并停止，这是另一种思考方式，我检查了一下，并将这个想法纳入了代码中，如果有什么事情，我可以帮助您一点，然后我将尝试所有，这项工作，但某种程度上意味着我所做的可能，可能会导致良好的结果，所以例如。

如果我拿六个的第一个，我想要一共五个不需要好的结果的权利，是的，是的，好吧，我认为说这句话的好方法就是您刚才所说的，就像um，每个剩余要滚动的骰子可以是至少一个，并且在，最多六个。

这样我们从这里可以到达的求和空间就是这样，为什么我们不只是检查我们是否在我们期望的范围之内，对，所以所需的一些像最*所需的是一些所需的，一些必须至少是我剩下的骰子数量乘以一个正确的骰子数量。

我至少知道我能做的就是每个骰子得到一个，然后获得所需的总和，最多必须是剩下的骰子乘以6才有意义，也会减少负面影响，例如我们超调之类的东西，像这样的权利，如果我们这样做，它仍然会打印所有答案，但不是。

打印1500个电话，使847个电话减少了很多电话，我，想一下这里，如果我做三点七点或三点七点那个，印有两百张，现在它一路缩*到127 ，实际上有很多这样的电话， 27个是真正快速的通话。

您很快就知道保释，真正避免所有这些不必要的循环的方法是，更好的优化，所以看起来我只是想向您展示一下，当您回溯时，有很大的探索空间，如果您开始，沿着一条糟糕的道路走下去，您需要识别它，然后退出。

并尝试另一条正确的道路，因为否则您将，搜索和搜索以及搜索和搜索此问题不是超级问题，进行调整以说明这一点，因为骰子搜索空间并不大，但是，如果您要掷十二个骰子，那么这真的很重要。

知道我的意思是因为我们成倍增长，无论如何在这里谈论有时被称为修剪通话树。

修剪通话树修剪这张图片的分支基本上可以了，这就是我想从上一次完成该示例起的全部内容，所以现在我。

希望那是上一张幻灯片的内容，讲座我想从星期三的当前讲座中打开幻灯片，讲座，让我现在就开始做，让我们再看一些。

问题要记住总体策略，然后再开始写另一个策略，从零开始，回溯的总体策略是，如果有选择的话，那么您将要处理其中之一，因此对于可能会选择的每件事，选择自己的部分，探索可能发生的事情，然后取消选择。

如果没有可能，选择共享探索，留下的选择让您停下来，或者打印找到的选择，或者，无论如何以及如何枚举或尝试所有我可以处理的所有事情，叫是问题，哦，好问题是，你们所有人都回答了您，只有当您使用UNAC时， 。

在这两种情况下，您都会遇到不好的问题，但是我想这些潜在的问题，达到您可以撤消的原因有两个，因为您已经做了所有，选择，现在您已经完成，现在要打印您选择的内容，或者，这样的事情，否则您可以撤消。

因为您知道自己不会，以获得良好的结果，因此一旦您确定了答案，则需要，回溯，所以我认为大多数情况下，这种代码具有以下三个步骤，选择“资源管理器”按顺序取消选择，所以我认为我们会通过，我们一起写的例子好吧。

让我们来看一个，点击了很多人，我喜欢这个我们一起做这个吧，从迷宫中逃脱这就像字面上的回溯是一样，所以我，要在这里是我要给你一个可以走的墙的*迷宫，穿过走廊，但是你不能穿过墙壁，因为我们是不朽的。

人类以及我所有的意思，您可能已经听说过有关如何，从迷宫中走出来有些人用右手握住墙壁，这样，看看是否有人导致退出，这是您的想法，如果您尝试，以某种方式，它不会导致退出您认为您的工作，你哭对不起。

我们在验尸官上向自己抽泣，然后你沿着走廊走了，这是你没有回头路的死胡同，选择是的，那你就被一条沟吃了，我，没关系，没人玩了，所以这真的是一个，回溯的想法，现在你可能会说好，等等，这个迷宫是如何工作的。

网格是什么，我想避免一些污垢和这里的细节，计算，所以我会有所帮助，我会给你一个叫做，基本上就像一个网格的迷宫，你可以问你知道网格有多大，它有很多行和列吗，您可以问自己是否在。

迷宫的边界就像使用网格一样可以标记正方形，就像您要离开一路走来的面包屑，您也可以进行画方形教学的工作，这意味着您已将其标记，就像是一个你不喜欢的坏广场，我不想再走那条路了。

所以我们可以将这些不同的方法称为，一种围绕网格的包装器，以便我们可以在，简单的函数调用好吧，让我向您展示我们将要访问的文件。

我在这里工作很好，我的项目去哪里了，我今天有一些电脑东西。

我不知道今天不是我在电脑上的日子，所以我在这里有文件，首先，我需要做的是，我需要去掷骰子，通过重命名关闭主要功能，然后在迷宫中我得到一个主要功能，在这里，我需要打开，现在我们要写这个转义符。

从迷宫里好吧，哦，我想我做了，我把。

右键在此处的屏幕上向上滑动，所以我想标记出一条路径，迷宫，如果有的话，我还想返回一个布尔值，表示true ，还是false是否存在这样的路径我是否找到了一条路径好吗，所以可以从任何给定的广场移到邻居。

什么是通用算法，这里是递归我们有哪些东西，通常考虑一下我们何时使用递归代码，是的， ，他们的基本情况是什么，回答是否可以逃脱是一件容易的事，如果已经，逃脱了，是的，我知道我可以，因为我有权利哦，是的。

你知道你有，如果您超出了基准范围，请转义。

如果我们不在此行和列的范围内，则超出范围，万岁我们逃脱了返回真实好的那里我还有其他地方吗？ 。

可能会问您有关从哪里可以肯定地说不从这里开始，不可能逃脱人类，为什么你要以基本情况为依据，基本上我想问你一些递归函数有多个，是的，如果我被墙壁包围着，是的，实际上我认为。

比这更简单的方法如果您就像在墙上一样，就会知道，如果你说他们从这里开始，你会说不，你，无法从那里开始，甚至都不能在那里，我认为，我认为您的案子是可以接受的，因为您可能会说，如果我被。

围墙或我周围任何可以问的问题，我可以从那些地方逃脱吗，如果他们都是墙，那么他们都会说不假，所以我会，也知道我无法逃避我，或者你知道我的意思，所以，会像我周围发生的事情那样的想法，所以我认为。

我们在这里可以说的是，如果迷宫在此行或列中有一堵墙， ，在没有返回错误的情况下还可以，所以现在我们开始了解，可能需要写主要算法的地方。

很难看到自相似，一点点的工作，一点点的进步，如果我们做到了，递归在这里我该怎么办我的电话要花点时间，帮我设法找到出路，尝试朝一个*方向向上走一步，左边，环顾四周，所以真的不像移动方法。

但是我们正在编写一种递归函数，就像你能从一个给定的广场逃脱迷宫，所以我怎么想这个想法，就像走一步公路休息，在这种情况下，您认为。

好吧，也许像我站在那里的标记， mais doc mark我一直在这里，现在在这里，所以还记得那个递归，回溯就像让我想起我将要做的所有事情，一个*选择，但我会尝试所有可以做的不同选择。

选择正确的，所以如果我要去所有四个方向，看看是否有这些工作，为什么我不只是说逃生迷宫迷宫，所以往上走就是一减一。

向上下降的同一列是行，向左向下的同一列是行，打电话减去左边剩下的然后右边走，所以这是一个想法，我们还不存在，请记住，mm-hmm必须返回一个表示true或，错误，您是否找到一条出路。

所以我需要在这里返回一些信息，我怎么知道，返回什么你说是的，转身说话，是的，谢谢，我再说一遍，您说过那些递归调用都返回布尔值，值，所以你们可能像您知道的那样考虑这些电话。

我正在执行的计算或步骤或其他任何操作，但是有，还有一些问题的答案会在您将逃生电源接通时返回，你还问那个电话，嘿，你找到了出路吗，是或否，如果它返回了真实，那么您应该知道的是，如果我去。

这样就可以有一个出口，所以如果我有一个出口我，可以去那里，然后我去那里的出口，如果他可以，我可以出去，你知道我的意思是如果我的邻居可以出去，我可以，只是步行到我的邻居，所以我也可以做同样的事情。

但是如果我尝试上去， ，返回一个错误的值，然后它不起作用，没有办法找到一个，从上往外走，这样行不通，所以我将尝试下一个，那么我会尝试下一个，所以我的意思是，你真的应该说，如果我试图逃脱迷宫。

它会返回真实的，我应该返回一个真值，您知道我的意思是，如果，如果返回true，则返回true；如果返回true，则返回true。 ，那就是我应该返回的内容，现在您给了我一个更优雅的版本。

您所说的想法只是将它们全部或两者之间称为，如果他们中的任何一个可行，那么我就可以工作，所以我认为这是表达这一点的好方法，我会按照你说的返回我是否可以逃脱迷宫上升或我可以逃脱，迷宫走了，我会把这等于真。

否则我可以逃脱迷宫走，向左走，否则我可以逃脱，向右走，是否可以走出，现在做这些事情之一，您可能会说等待确实意味着它做了所有，他们知道人们认为执行代码是它执行的第一个，等待，只有第一个为假时。

才继续到第二个，因为一个叫做短路的过程，评估，所以这是该算法的基本思想，我想我可以在这里运行，我们可能还没有完成哦你有一个问题哦我把我的索引弄乱了吗，我明白了哦，是的，你完全正确-一个代表左派。

所以谢谢你，没有什么比让400个编译器看着您喜欢的代码更好，我非常感谢，谢谢，嗯，可能是讨厌的，因为它，不会给我一个编译器错误，只是永远不会发现，那出口，我会一直想着哦，天哪，它怎么不起作用，所以是的。

我要在这里加载文件，所以如果您只是单击某处，应该尝试所有不同的方式，哎呀，发生了什么让我们看看这里发生了什么，这不是一个没有标记的开放，正方形好吧，所以如果您尝试标记一个，已经标记。

所以我的意思是我认为我们这里拥有的大多数都很好，但就像，只是对我们有点生气，因为我们正在尝试对正方形加倍标记，让我问这个问题，是否因为我们试图翻倍而崩溃，标记一个正方形是什么意思。

这在概念上是关于我们的算法的。

这是否意味着我们进入了一个循环并回到了正确的起点，我们有点，如果我们转了一圈，不想重新探索我们已经探索过的东西，就像Hansel和Gretel以及面包屑，或者如果您回来的话，再次回到面包屑。

您就会知道自己走错了路，或者。

嗯，不管你怎么想，如果这个正方形不是，标记为正确，实际上我认为这里有一个方法叫做，打开，这是一个好人，如果这个Square是开放的，那意味着它是我， ，我可以去这里吗，让我们尝试一下吧。

所以现在实际上我遇到了错误，因为它说并不是我的代码中的每条路径都返回一个值，所以这是一个，一个很常见的错误，当您遇到if else-if else-if else-if and 。

如果没有任何一个成功的案例，您将无话可说，我一路走到这里，然后我想发生的事情是我在一个广场上，没有开放我回到了以前去过的以前的广场，所以我，我想我应该说像这样正确的跌落，所以让我们再试一次，好吧。

这就是说1，我要在这里单击，这是很酷的事情，它几乎可以完成很多工作，我会改变的事情是，我认为如果你走到了尽头，那是行不通的，而你备份，我宁愿剪掉那些正方形，并说这些不是路径的一部分，我只想标记那些。

实际上是我们最终遵循的道路的一部分，所以像这样，将这些与这些平方成正比，我们实际上并不是在旅行那些不是，我们真正想走的那条路的一部分，我怎么可能有一个叫做，弄脏一个正方形，就像没有这个是坏的。

我实际上不想走，在这里我该怎么做，您认为与此相关的问题是，真的问同样的问题，这段代码在哪里选择，在哪里探索，在哪里选择，当我们说“标记”时，在哪里选择GZ？ ，我要去这里我要去这里是完全可以选择这里。

是探索，这是所有递归调用的return语句，递归调用始终是探索的一部分，好在哪里，我选择了不知道的地方，所以我认为，如果我尝试去所有四个方向而没有一个去，在这里取消选择就像，他们会工作。

那么我可以得出的结论是，这个广场对我没有好处，喜欢在这里我的邻居都没有为我工作这不是那里，将成为一个好的道路或解决方案的一部分，所以我认为选择不当会，需要来到这里，但是只是因为C ++的性质。

如果您说return ，退货后不能有任何代码，所以也许我要做的就是说完整，结果等于这个，然后如果我有两个选择，我会这样做，但随后我会，说返回结果，您知道我的意思，这就像我想做某事一样，在我回来之前。

我该如何选择呢？我可以说相反，我选择时所说的话我可以不加标记地说，但我认为，问题规范中还有一个更好的说法是，说我想去这个广场，我向你投掷分散体，我讨厌你，永远不会再回来了，所以，是的，所以。

如果我点击这里，当它回溯时，您会看到灰色吗？这是训练的一部分，我们是美好的时光，哦，每当发生什么情况时，您都不会抓狂的递归如何解决该问题，如果结果为假，则*脸只在差的正方形上取平方；如果。

这里的结果不好，然后污染是的，我们继续尝试，好吧，我很兴奋，我认为这一次实际上可能会奏效，开始，等待它很酷吧，我是说我不能给你更直观的印象，那么回溯的描述就是字面上的回溯，所以我。

意味着我可以打开其他迷宫，我认为这对于一般情况是有用的，但是，它必须尝试获得许多通行证，直到找到可行的通行证为止，问题是，如果没有路径，将会发生什么事，我认为这只会，尝试一堆东西。

最终将所有可到达的方格组合在一起， ，然后它会放弃，但是没关系，这可能就是它应该做的，所以在我想做之前，让我们对这个算法有其他疑问，你们的另一个问题也是，但是这样做对我们有意义吗。

在这里您看到回溯中的递归正在进行吗？ ，再次审问，哦，他们在改变，否则你的意思是我在这里你可能已经重新安排了，外套，这样就可以了，但我认为目前的方法是，如果您进入那里的中间分支。

那么您将无法达到其他目标，如果您想让它工作，您需要做的是其他的，您可以用不同的方式表达这一点，但基本上这是其中一种，它将解决有关狼牙棒的任何其他问题，请顺便探索一下，如果这个例子有点令人困惑。

它也在书中，我认为它在，第8章，也许9我认为这是8，您可以在本书的版本中通读，他们实际上使用for循环枚举了四个方向，因为它们，只是将它们全部声明出来，就声明了他们想要去的所有索引，到。

然后他们循环遍历，那就是您可以使用，循环，如果您想要，但是它仍然是递归和回溯的，是的，所以我的意思是我们要看到的一件事我想这也会出现，在下一个问题中，您会使用一些回溯问题，而有些则不会。

你怎么知道这取决于我的意思是你想做的就是你想，想想我所有的选择是什么，所以在这个问题上我去了，哦，它上下左右，这些是我的选择，然后您就，下一个问题是，如何以最干净的方式用C ++编写代码？ 。

有35种不同的选项，而我将它们包含在向量中，为什么我不只是，查看向量并在每个向量上重复出现，但是如果有四个， ，有点不同，以至于很难以任何方式将它们组合在一起，写出您知道的四件事。

就像我认为我们使用打印二进制文件或，看起来它要么是0要么是1，所以就像用0和，然后用1来调用它，我们不使用循环，但是我们是十进制数，以10为基数，有10个选择是相当多余的，可以写10个电话。

从今晚的0开始循环，是的，那很好，我想您也会看到，在下一个下一个示例中，好吧，让我关闭此主要方法，以便。

做下一个我想和你们做的下一个问题是我不说话，关于排列，我认为这个问题给了你一个向量的集合，在这种情况下的字符串，我想打印出该字符串的所有重排，该向量的所有向量的排列的向量排序，字符串。

所以如果向量包含ABCD，您将打印出所有这些I ，好吧，我第一次见到这个，就为你写了所有排列，问题去写吧，我想你会发现它并不是真的很好用，我的意思是似乎您可以通过一个循环或几个循环来完成此操作。

或类似的东西，但我认为您发现的只是它无法解决，就像您认为的那样干净利落，所以我想递归地执行此操作，想要通过回溯来做到这一点递归如何自我相似，置换某些事物与置换其他事物之间的相似性在哪里。

您看到此输出时会怎么想，你在这里看到任何相似之处吗，是，是的，你在周围，你说要选择第一个要成为我真正想要的元素，创建后跟所有其他三个的所有排列，权衡置换四个要素是选择一个并置换。

另一个折痕就是我非常喜欢自我相似性，所以我只是，认为这里问题的核心是我们需要将这个想法变成可行的C ++ ，编码什么是好的基本案例什么是易于置换为空的向量no ，元素，是的，在某些时候我们会耗尽元素。

所以也许，这是可以正常工作的方式，所以当您编写回溯时，算法，您通常会创建一个辅助函数，并且通常会传递额外的，参数通常可以帮助您使用这些额外参数的原因是，跟踪您所做的选择，我们实际上并不需要。

用迷宫做这件事Explorer是否注意到我们做迷宫时，没有写一个叫做Explorer Explorer迷宫助手的助手，为什么不，为什么我们不需要任何额外的参数，我们在哪里记得。

我们在这个问题中做出的选择，即迷宫对象正在存储，对我们来说，因此我们不需要建立其他结构来记住，对我们来说，这只是这个特定问题的一个方面，所以让我们开始吧，我有一个存储ma RT和y的向量。

我想对其进行置换，再说一遍，我们通常想做一个助手，所以让我们来，仍然使用称为V的字符串向量的辅助对象，但我们还将通过，以某种方式跟踪我们选择的内容您认为我们应该如何保持，跟踪我们选择了什么。

我们可以将我们应该打印的输出传递给字符串。

就像一个收藏，尽管我认为传递一个收藏可能会更容易，我们从到目前为止选择的元素中选择了一个向量，所以我会说。

在主置换函数中选择的字符串向量称为，实际上必须写将使称为选择的字符串向量，我们，将其传递给您，您知道我们总是必须打电话给助手以获取，整个过程都知道，所以我们将通过B并选择，因此最初我们已经。

什么也没选择，所以选择的向量为空，这就是递归开始的方式，好吧，你告诉我，我需要做的就是选择一个元素，然后按照，排列其余元素正确如何选择元素。

我应该选择像想象中的那样我是第一个电话我是第一个电话，我有BC和DI可以选择其中任何一个，我选择Hey well，我的意思是那是它的结尾，然后我选择一个，那就是，这就是我的全部意思。

我想可能不清楚我应做的演员选，一次选择所有一个，然后选择一个，然后尝试，应该选择B然后尝试选择C然后再尝试，没有不好的结果，这不是我要陷入糟糕状态的地方， ，从中退出或执行其他任何操作。

但我需要全部尝试，所有尝试，他们是第一位的，然后我需要尝试所有他们都第二位的，所以。

这里的想法是为每个选择选择哎呀探索，取消选择正确，因此对于每个选择均意味着对向量的每个元素，因此，从零到胎儿的大*，每英寸正确，所以我们将使用，在这里为每个元素循环，选择它，探索它，然后选择它如何。

我选择某种东西是否意味着这个问题，是的，将其放入所选的，向量就是我们存储所选内容的地方，所以听起来不错，选择点加V括号，我，要尝试我是第一位还是第二位，或者好吗，我需要做的其他事情是什么。

但这是选择我是否要。

第一个电话，我除了指示该选择之外还需要做些什么。

放在向量中让我我还没叫过我一直忽略的名字，您在最上面，对此我感到抱歉，现在看到我看着你这次不举手，我当答案是面对面的时候，我知道一个我知道的基本情况，没关系，否则我需要记住我的选择哦，是的，将其从。

向量V，因为我已经接听了，我不能让下一个呼叫也选择它，为我自己，所以将其从完全正确的选择中拉出来V不要，删除索引中的元素，我可以将其拉出，所以如果您不知道， ，如果很难想象这里发生了什么，但是想像一下。

向量最初是空的，我正在正确地查看ABCD的向量，如果我选择零元素a，那么我想将向量V设置为BCD ，知道我的意思，所以下次通话时他们没有，在那又是你所说的，好吧。

Explorer Explorer通常是，递归部分，所以我只说Permute helper，然后通过V并选择，然后，传递相同的参数，除了我更改了它们的状态，所以现在，下一个家伙有点不同。

下一个家伙在选择中得到一个A ，向量和V向量中的BCD，大概它们会进一步，选择会进一步改变向量等等，因此我选择了一些学生，有点混淆这里发生的事情请记住，置换助手是，如果我是第一个打电话给我。

就会导致一棵树，你知道，最终会导致大量跌倒的另一个电话，所有这些子调用都将返回，这意味着我现在拥有，完成处理或打印可能包含的所有内容，以字母A或元素I或其他元素开头，所以一旦完成，我需要。

取消使用字母A，然后前进并尝试字母B或尝试字母C或，下一步是哪一个我该如何选择，是的，所以我把它从选择的向量中拉出来，我想我认为这不是完全正确的，因为您必须想象，该代码将在第一个电话。

第二个电话和第三个电话上运行，在第四个电话中，第四个家伙不应该清除选择，第二或第三个人，但他们应该撤消做出正确选择的选择，就像我将如何删除最后一个元素很好，如果您说我删除了索引中的元素，请*心。

所以我认为您，我想说的是我是最后一个添加到所选向量的人，所以我想，删除我认为这称为删除回去或删除弹性删除最后一个，向量中的元素，即我在向量末尾插入的元素，首先，我需要做多条线，基本上是相反的。

这两条线中，我经常需要正确选择的是，选择的镜像代码，所以我必须从这里删除，我需要添加到，在这里正确，所以我怎么把它放回VI中可以说V点加了什么，我实际上已经没有值了，所以也许我要做的就是说字符串。

s等于那个，所以我将选择的字符串放在一边，现在我将按下，在这里，我将s放回V，但那不是很正确，因为我的方式，从V删除是因为我说删除索引I的人，所以我应该把，他们重新回到索引。

我必须尽我所能镜像这些事情，知道我的意思，所以我真正应该说的是插入索引，我把值s ，回到我带他离开的地方，好吗，我认为这里的模式，一开始很难读，但这是选择元素的想法，它探索接下来会发生什么。

然后再回来使用，是的，继续，哦，哦，你的意思是从这里拿出来，用它插入，然后我不需要，字符串是的，我认为那完全可以，而且可以正常工作，总是有不止一种方法做到这一点，我认为没有什么不好的。

关于有一个变量对我来说很好，所以这些想法中的任何一个都是，很好，这里有些东西不见了，后面的人都想告诉我，我现在在此代码中缺少什么，缺少基本情况谢谢，我很高兴您在这里使用基本情况，而实际上。

正确的答案这里没有基本情况正确的没有基本情况什么是，基本情况下，我知道我们说的是空话还是空话，或者您知道是否，向量或当我们回溯，基本情况通常遵循一系列先验调用，因此我不会将其视为。

空向量一定就像我要您置换一个空向量，就像我要你置换effete vector一样，它逐渐减少直到，并不是当我们达到基本情况时，我怎么知道我该如何，知道我已经掌握了基本情况，那时候将会发生什么。

所选向量已满，V向量为空，这就是您所知道的，选择了东西，我认为检查V可能最简单，空着选择饱满是可以接受的，我并不总是知道，有多少个元素构成满，所以我只寻找V为空，它更容易等于我们的等效思想，因此。

如果V为空，则为基数，这种情况意味着我已经完成了所需的所有选择，否则，如果B为空，我将做所有这些事情，我认为这个问题的重点是我应该打印所有这些，不同的排列方式，所以我只看一下选择的内容，然后输入。

恩德尔，这可能可行吗，没有主方法，但这是因为我，重命名它不是我们的错，让我们再试一次，我认为这是可行的，因为我的老鼠在这里某处，我的老鼠，我的名字很像它的肮脏字谜，实际上是我的全名。

真的是我不会告诉你那儿有什么，但是是的，你可能会学到，稍后，但是我认为它可以正常工作，如果您确定，我看不出它为什么起作用，对我来说真的没有意义，我一直回到这种方式，我认为我的。

如果我的意思是可爱的创建者是我的最爱，那么我喜欢在我前面有代码的最喜欢的方式，理解到底发生了什么的一种方法是在，函数调用的开始，所以如果我只是做C置换V等于选择的V怎么办，等于选择和endl。

我认为不是我做递归缩进的事情，它缩进了呼叫，让我们做，让我们做，我必须包括这个东西，称为递归H，然后如果您这样做，您可以说递归并缩进，紧随其后的是东西，所以请注意我实际上是很多，输出让他坚持下去的爱。

让我们走的短一点，让我们走， B和C好，更容易阅读，因此请重试，看看我们称之为什么，它的V充满了东西，并被选择为空，因此导致三个调用，导致此呼叫，它导致此呼叫，并导致此呼叫，它导致，我先尝试。

然后我先尝试B，然后我尝试，首先使用C，然后再探索所有可能具有，首先探索所有可能拥有B的东西，可能先是C，所以第二个电话是这个人，您已经选择了，等我在错误的地方，这个家伙在这里，您已经选择了。

我有B和C可以选择我要做什么，好吧，我会尝试两件事，我会尝试选择B，而我会尝试选择C和，因此，每个人之后都导致另一个呼叫，最终您明白了这一点，今天没有什么可供选择的地方，所以就像一棵树。

这里所有的电话排列都很好，您认为家伙们对此有新疑问，这样做有意义吗，在这里，您会发现选择我很有趣的地方，我没有任何打印输出可以表明我，我能不知道我是否有时间做，我想我可能会做，它。

但是脱鞘的感觉就像我可以在这里打印一个图，好吧，让我们，让我们在这里做我真的我的意思是我认为我当时，试图决定我要离开的那五分钟我该怎么办，我想我想做的就是尽可能地了解这一点，在那段时间，您知道了。

这是在我选择之后，所以我要做的是我会说我选择的正确，然后为什么，我不打印V现在等于V然后我说选择现在等于选择好了，因此更多的是印刷，您应该这样做，因为很难理解这些东西，去下载并打印它做所有这些事情。

所以现在在这里，当我选择时，我会说我不使用s，我将创建V和，我打印出来看起来很酷，好吧，让我们看看它看起来是否很好，所以看起来应该不错，之前类似，但是有更多的东西好吗，我看到置换没有什么了，选择了。

我选择了以后，它会说很难读，不是吗，我，嗯，哦，不，不是，再次，所以我选择了一个，所以现在就开始吧，进行第二次呼叫，因此选择了a，他们稍后选择了B，然后选择了b ，他们选择了C。

所以我不知道我不知道这很难读，具有所有额外的输出，但认为这样的消息会打印出来，这将是您更详细地遍历代码的一种方式，而我，完全鼓舞人心，我认为这是一种非常好的建立方式，关于这种代码到底发生了什么的直觉。

有一个简短的问题，还有几分钟，你知道我没有，想要开始像锻炼这样的新运动，或者与您进行任何其他运动，这还不够，时间，但让我问你这个变化，如果mm-hmm如果这里有重复的话该怎么办，就像BB 。

C你知道如果它是BB C吧，所以我打印了我可能不得不，关闭一些打印，因为它的输出太多了，但是让我，在那里删除这些真正的快速，所以现在我运行它，好吧，像打印所有的东西，但如果您仔细地浏览一下，我。

认为某些相同的行输出被正确打印两次甚至超过，两次我都明白为什么会这样，因为其中一项安排是，就像最初的第一天，然后是第二天和第一天，安排的原本是第二天，然后，说得好吧，这些是与众不同的。

因为它们彼此之间并没有区别，从用户的角度来看，我不想打印两次，关于如何快速修补补丁的任何想法，以便，媒体不会回来的，当然，有很多方法可以做到这一点，但是如果我们有两分钟，那么我。

认为每次打印时您所做的就是记住，您要做的就是这样，您保留了一组称为字符串的向量，打印出来的东西，或者是您打印过的东西，好吧，您传递另一个参数，因为这是新信息，我们试图在您记住这里。

进行创建的原始函数调用，将其设置为空，然后传递给它，这样，它将记住我们之前和现在打印时所打印的所有内容，在这里，当我执行打印输出时，我会将打印的内容添加到打印的设置中，广告选择还可以。

但我们错过了最后一件，我们现在想起了我们，打印，但要记住的重点是避免打印，同一件事两次正确，我如何合并它，这样它就不会，实际打印两次相同的东西是的，如果打印的内容不包含所选内容。

那么打印所选内容添加到所选内容，我认为，我需要导入set我想在这里设置点每个条纹太少的参数，哦，抱歉，我需要将打印的内容传递给我的递归调用，让我们尝试，再次，我想如果您检查我的眼睛不好，但我很确定我们。

剪掉那些重复项，所以您的想法很棒，所以我没时间了，让您转到“部分”，“星期五见”，我们将再做一些练习，谢谢。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P1：Lecture 01 - Introduction - 加加zero - BV1By411h75g

我们在课堂上所做的一切都会被发布在那个网站上，包括人们问我的最常见的问题，除了我是否应该在这个班，你要把讲课录下来吗，答案是我所做的是，我在电脑上运行这个程序，捕捉屏幕上的内容。

它能捕捉到我的电脑麦克风听到的声音，所以这意味着我得到了一个讲座的视频，但这只是一个屏幕，你看不到我美丽的笑脸，你们美丽的笑脸，如果我走到这里，你也听不到我说话，就像视频的这一部分，离麦克风很远。

所以说这个视频的质量很糟糕，但我会给你这些垃圾视频，如果你想要的话，我还是觉得亲自来上课比较好，但你以前做你想做的事，我得到任何进一步，我想介绍另一个人。

我不是一个人在教这门课，这里，我将用我才华横溢的头脑工作。

爸爸，她叫艾米，她坐在前面，我想让她说，嗨很快我的好的，嗨，大家好，我是艾米，我创了职业生涯新高，现在我和我的政治硕士一起在斯坦福工作，我惩罚他去的产品，哦，昨天我会穿黑色，像其他人一样，然后呃。

我没有脑袋，但这六个中的一个很酷的地方，你为什么喜欢一六六不问任何问题，你可能还不知道，但你会有一个很好的问题，而且是的，所以也许呃，问题真的希望他们在，你知道我是个坏警察，她是个好警察。

艾米不仅才华横溢，但也是大学里最好的人之一，所以如果你需要什么，她会帮助你的，如果你有与课程有关的问题，我想现在，正确的做法是发一封写给我们双方的电子邮件，然后我们都会试着回答，这对我们有帮助。

以后把工作分开，你要找这个和你一起工作的部门领导，你也可以问那个人问题，顺便说一下，你喜欢这个吗，我没有一张留胡子的照片，我今年早些时候种的，我刚拿到一张结婚照，我想我能修好它，我想我能修好它。

呃等一下。

呃，哦等等，我不能在这里画画，好啦，等一下等一下，让我试试，现在差不多准确了，是啊，是啊，无论如何，如果你有问题，给我们两个发邮件。

这真的很有帮助，因为我们在季度初收到很多电子邮件。

所以这真的有助于我们分散问题的工作量，祝福你，所以是的，很多人想知道这门课是什么，你到底该不该上这门课，让我们来谈谈计算机科学的三门主要入门课程，我们有一个零六a零六b。

一零六×一零六A是我们的第一堂课，这是为很多观众准备的，这应该是一堂课，那个，任何一个斯坦福大学的学生都应该能够在，有了这些编程变量的基础知识，如果语句，循环，数组，方法参数，这类事情，基本问题解决。

绘制图形，伟大的阶级，趣味课堂，完全没有预科1 0 6 B基本上跟在1 0 6 8后面，它更专注于处理数据和算法，了解可以将数据存储到的集合，像向量、列表、地图、集合、堆栈和队列，您学习了递归算法。

你学会了如何解决棘手的问题，处理充满数据的大文件，嗯你，你在那里学习一种叫做C++的语言，所以是1 0 6，一零六，X就是所有这些，但只是，所以你可以，我这样做是为了强调，你知道的。

um x是六个b中的一个的硬版本，都是和B一样的内容，但我们可能会更深入地探索它，我们可能会在一些主题上更进一步，我们可以在这里和那里添加一些*东西，但是一般来说，这和《一零六》中的内容是一样的。

我想有些人可能对什么有错误的信息，一零六x是，它不是一零六a和b的组合，我听说这不是两个班合二为一，尤其是一些研究生，我听得很清楚，这两个我都要，但我只有四分之一的空闲时间，所以我拿1 0 6 x。

这不是取1-0-6-x的真正理由，你应该拿1 0 6 x，因为你恨你自己，你也会恨我的，我是说，如果你有一点编码经验，你想在此基础上再接再厉，零六b是一个很好的类，它的步伐更，一个。

零六X基本上是你要做他们的家庭作业，加上我加入的其他东西，就因为我心情不好，你的考试会更难，你的曲线会更紧，你会有更多的问题需要解决，更少的时间来解决它们，参与课程的每个人都是好战和脾气暴躁的。

它对你不好，如果这听起来像是你想要的那种经历，你来对地方了，我知道你们比我年轻很多，但是你看过这部电影吗，这是一部古老的电影，叫做《帝国反击战》，有一幕，有几个人看过，伟大伟大嗯，这是一种独立的东西。

一点*纸条，不要，有这个，电影里有个叫卢克的家伙，他去了一个叫阿格巴系统的星球叫达巴，他遇到了一个叫尤达的人，尤达在训练他对抗这些坏人，你知道的，告诉他所有不好的事情，他要面对，卢克很好，我不自由。

尤达去，你会是，这就是零六x的精神，反正，对不起，我有点开玩笑，但我是认真的，这是一门比B更难的课，拿一零六B没有错，如果你想在不被踢屁股的情况下学习这些概念，一零六b是一个很好的方法，我们甚至解决了。

所以16B和这门课是在同一时间提供的，它现在在英伟达礼堂提供，六乙之一的导师是辛西娅·李，谁做得很好，她比我好，她会对你很好的，她会把你教得很好，所以你知道如果你开始取x，它对你来说太快了。

换成B没问题，没关系的，我只是让，你知道的，但就像我会尽我所能挑战你一样，因为，但我的感觉是这就是你报名参加这门课的原因，是你吗，在这所高中或其他课程自学之前，你有大量的编程经验。

或者你已经拥有一家初创公司或其他什么，你有很多这样的经验，你想挑战，所以这就是这门课的精神，好啦，如果你不确定这门课是否适合你，如果你去我们的网站，你去F A Q部分，常见问题部分。

这一页的第一部分谈到了不同的类，我们还有一份讲义，我给你看看这些东西，嗯，在我们的讲义区有一个讲义叫。

哪门课程适合我，所以你可以更详细地阅读，我们的页面中也有这个链接，上面写着FAQ，那一页还谈到了，我应该在1-0-6-X，所以如果你想给我发邮件，和艾米问这个，那很好，但我希望，如果你先看看这些资源。

然后把你的问题发邮件给我们，我们得到的大多数问题都是形式上的，这里有很多关于我的信息，你认为我应该在课堂上还是不应该很多时候，我想这个人可以自己做出一个很好的猜测，如果他们看到这个，但除此之外。

我们很乐意为您提供建议，如果你如果你愿意，好啦，这就是我想说的，现在你对这些课程有什么问题吗，或者他们之间的差异，或者任何一个，是呀，你有没有看到任何历史和优先考虑六个X中的一个申请。

就是拿一个零六个X就像你简历上的徽章一样，可能会帮助你找到实习或工作，或者男朋友女朋友什么的，不是真的，我是说，我认为最美好的事情之一，我爱上计算机科学的原因之一，在很大程度上。

人们根据你所做的和你能做的来评判你，如果你能解决很酷很棘手的问题，如果你已经建立了一些*应用程序或项目，你在课程或空闲时间做了一些整洁的事情，你可以和人们谈论这些，也可以给人们看，人们会想和你谈谈。

想采访你，你呀，想雇你，想和你约会，我就是这样认识我妻子的，我只能说这么多，嗯，所以我，我想说你不需要在这里给别人留下深刻印象，你知道这堂课更多的是关于你自己，想要一种更深更艰难的经历。

因为你在1O6B会很无聊，对你来说太容易了，同样，你可以看看1O6P网站来帮助你解决这个问题，你可以看看我们的网站来帮助你解决这个问题，如果你想看得更详细，但是很多人，你知道的。

六个x中的一个不是必需的，或者是秘密必需的，任何秘密，很酷的俱乐部之类的，所以说，讲义上没有提到的一件事是，今年我们还有其他课程，我们有一门课叫1-0-6-aj，这是一个但它是在JavaScript中。

我不打算在这里多谈这件事，因为我想如果你在这个班，你可能比一零六一个J的材料领先，基本上是一零六，难度等级，但在不同的编程语言中，如果你好奇的话，你可以发邮件给我们，好啦，所以我要继续前进。

我们还有一门课叫做六L之一，那是个实验室，这个季度不提供，所以我今天不想多谈这件事，上面说每年秋天和春天，但实际上是在这个冬春教的，所以这张幻灯片是错的，但是因为这个季度没有。

我不打算长篇大论地谈论这件事，但如果你在这个季度后想要更多的c+，你可能会把这个1-0-6升，那是为了更多的练习而开设的实验课，好啦，我们有一本书，它被称为C++中的编程抽象，另外。

它是由埃里克罗伯茨写的，他是斯坦福大学的教授，你需要买这本书吗，我知道你想知道，因为要花很多钱，你不必买，你不用花钱也能在这门课上得a加分，你想要它的主要原因，你可以在考试中使用它。

所以你可能想在考试中查一些东西，但是测试不允许您使用其他资源，就像你的笔记，您的打印件，你的幻灯片，所以这本书是你可能带来的主要资源，所以你有优势，如果你有一本书，如果你需要查什么，然而。

我带了一些孤独的书，我留在房间的前面，所以如果你没有一本书，有一种方法可以让你看一本书，如果你有电子副本，我不会让你用的，因为我不希望你在考试时把计算设备拿出来，你有一个问题。

我听别人说你考试可以抄*抄，你的问题是，你能给我一份备忘单吗，就像考试的笔记纸，一些教练允许，我不是个好教练，所以我不允许，但你看，我告诉你这听起来很像我，你为什么不让我把我的幻灯片。

你为什么不给我一张备忘单，原因是因为我喜欢问一些和以前考试很相似的问题，我把那些旧试卷给你看，所以你可以好好研究一下然后准备好，如果我让你带一堆笔记进来，你只是要把所有旧考试的答案。

然后我问的问题太简单了，这违背了这门课的精神，我不想在考试中给你惊喜和***钻，我想挑战你，但我不想给你惊喜，这到底是什么问题，我以前从没见过这个，我不喜欢那样，一点都不酷，所以我想给你大量的练习。

与你真正要解决的问题非常相似的问题，但如果你把他们都带在身边，当你进来的时候，你的武器太多，做不好，即使你不完全理解这个问题，所以我让你把书带来，因为这本书有很多语法之类的东西，在测试的背面。

我给你我的备忘单，我会给你很多语法，我认为你可能需要，希望在这些资源和共享的书籍之间，每个人最终都会，好啦，这就是我喜欢做测试的方式，我知道不是每个人都喜欢，但那是我喜欢的方式，是的。一个问题。

我们通常能有多少本书？有多少本装载机书，好像有六个，他们呆在这里，所以你上来看看，然后你回去，所以是的，如果你上去抓一个，他们会不会跑得太快，是呀，所以他们站在前面，是呀，所以无论如何。

你应该买这本书吗，你知道吗，有一件事我没说，这是一本好书吗，这是一个很好的参考，就像在课程中，很高兴通读这篇文章，帮助你更多地理解材料，但就喜欢而言，你需要吗，会被扣分吗。

或者没有它就不能解决一些家庭作业什么的，答案是否定的，所以我会让你决定，如果你想看的话，课程网站上有这本书的PDF格式，所以你不用买书就可以访问这本书，但同样，您不能将PDF进行测试，我想他不会打印出。

我可以打印PDF吗，你们真的在用这些金块想办法，我可以做一个盲文版本吗？我不要你带散纸，问题是，如果我，如果我真的能有一个完美的政策，我可能会说你可以带这种文件，但是你不能带这种文件，但最终发生的是。

如果有些文件可以，真的很难区分每个人都有什么样的文件，所以这真的是唯一的办法，我真的可以有一个可执行的政策，只是说没有文件，要不然什么纸都可以，我试过另一种方式，如果我让他们把一切，最终发生的是。

我有一个困难爬行，在那里我需要让新的测试很难解决，即使你有每一个旧的测试，所以我不喜欢，这使得我的考试越来越难，另一个问题，是啊，是啊，是啊，是啊，这篇课文和它一样吗，六乙是，和一个零一样的书，6B。

是啊，是啊，关于这一点的其他问题，有一些像这本书的旧版本流传开来，任何版本都可以，这些年他们变化不大，甚至有一个螺旋装订版在复印中心出售，那很好用，所以如果你看到有人用过这个，那很好，也是。

还有一些副本，我想在工程图书馆借阅，如果你想去看一会，好啦，所以我们有家庭作业，我们的成绩大部分来自家庭作业，会有8个编程任务，所以你们每人大约有一周或一周多一点的时间，你要自己做一些作业。

其中一些我会让你和一个搭档一起工作，可选地，你永远不必和搭档一起工作，但如果你想做一些任务，我会让你，对你的程序的评分将基于程序是否正常工作，当我运行它的时候，这就是所谓的功能。

以及它是否以时尚优雅的方式书写，以简洁的语法解决了这个问题，那些是，你知道的，伟大的两个重要部分，一旦我们向你致意，我们给你一个大致的分数，放进这些桶里，这是我们在所有事情中使用的同一种系统。

大多数人都有一个中间的桶，要么勾选减号，这意味着你的解决方案有一些问题，并检查，这意味着它很好，检查加，这意味着它真的很好，这就是我们所要求的一切，基本上还有一些其他的痕迹。

如果它真的真的非常非常可笑的好或真的真的非常糟糕，或者你没有提交，但这些痕迹很少见，你亲自和你的部门领导见面就能拿回你的成绩，他们在你的，你的节目和你谈谈，这叫交互式梯度问题，是啊，是啊，我们谈论风格。

不仅仅是页面上的代码，但也是解决方案本身的优雅，是啊，是啊，当我们接近完成第一个任务时，我会尽量说清楚，也就是星期五，我尽量说得更清楚些，这就是我要找的，就像我教材料一样，我会提到重要的文体方面的事情。

但它是从在你的程序上写评论，使用好的变量名缩进好，一直到识别冗余代码，以某种方式捕捉它，这样您就不必重复冗余代码，想出高效算法，这并不会使计算机用太长的时间来解决这个问题，像这样的事情。

我会很努力的去做，这样作业的规格就能告诉你我想要什么，也许不像子弹清单，但在文件的文本中，我会尽量提到我要找的一切，希望你不会太惊讶，你的分数是，但是你知道，风格往往有点争议，因为功能是如此客观。

你运行程序，它崩溃了，或者它的功能，或者它创造了正确的答案或错误的答案，这是相当明确的，风格更主观，你可能会说我喜欢我的代码，伟大的人可能会说，它是，这件事应该不一样或者应该更好，这可能会导致分歧。

但我想归根结底，就像你写的任何场景一样，现实世界设置中的代码，你会有某种要求你遵循的标准，不管是编码约定，一种编码样式，他们想让你使用的某个库，你可能会对这些决定有所贡献，但最终你必须接受这些选择。

这些决定是客观上正确的，还是仅仅是你的工作场所坚持的，或者别的什么，遵循一套风格准则是很重要的，所以在我们的课堂上，我们很重视这一点，是啊，是啊，你算全额学分，哪一个是完全信用的，基本上检查。

加就是全额学分，像加分或加分这样的事情几乎就像额外的学分，你可能会在一些分配规范上得到少量的额外分数，我们会提到你可以做的事情来获得额外的分数，但通常我们不会提供那么多额外的学分，因为我真的想百分百。

我想有些课上发生的事情，他们有这么多额外的学分，你需要百分之一百三十才能跟上大家，现在你要做这些额外的工作，即使我是个虐待狂，我不喜欢让你做更多的学分来通过或其他什么，所以还有一个问题，是啊，是啊。

你能在什么程度上得到帮助，就像其他同学一样，即使是在个人任务上，他们显然没有把它放在一起，但是问，就像嘿，我刚看到这个，是啊，是啊，你能得到同学的帮助吗，如果你卡住了什么的，我一会儿要谈这个。

我有张幻灯片，就像荣誉守则，什么是允许的，什么是不允许的，和东西，嗯，一般来说，你可以和别人交谈，只要你不给他们你的答案，或者详细地告诉他们，你如何解决这个问题，所以如果你想从概念上谈谈，如果你想谈谈。

嘿嘿，你为什么不看看课堂上的这个例子，你为什么不看看书中的那个例子，你为什么不试试这种一般的策略呢，那种东西完全没问题，你知道的，只要你不分享，基本上他们的答案是相互的，或者你怎么做的所有步骤。

那就没事了，是啊，是啊，如果我们选择在SCM中跟踪我们的代码，或者我们希望使用私有存储库，啊好吧，我有，我会提到的，也喜欢，我不希望你在公共场所张贴你的代码，就像在公共GitHub存储库上一样。

或者垃圾箱之类的东西，谷歌将在哪里显示您的代码，所以我是说这是我的试金石，如果谷歌或百度或任何搜索引擎，哦耶，混蛋们，我知道百度，我知道百度，我知道我的作业在百度上有一些答案，我发现我不*心。

如果用百度，我知道怎么用百度，呃对不起，大人，我要，我把它拿下来，嗯，我有没有提到六个B中的一个是同时，对不起，马马虎虎，是啊，是啊，就像一些学生把他们的工作放在版本控制系统或文件备份系统中。

我希望你能想办法做到这一点，那不会把它放在公众通道上，像谷歌之类的，如果可以的话，求求你了，嗯好吧，所以无论如何，那是家庭作业和评分，哦问题是的，去吧，A有样式指南吗，是呀，我的意思是。

不仅每个作业规范都提到了作业的重点问题，但我们这里也有一个链接说，类网页顶部的样式指南，如果你仔细看。

它会举一些例子，比如，不要这样，是呀，做那个什么的，所以你最好尖叫一下，在你做作业之前，是啊，是啊，所以我们这里有一个叫做迟到的政策，如果你拿一个零，六个a或b，这是同样的政策。

你的每个作业都有截止日期和时间，你知道星期三下午六点什么的，如果到时你还没赶到，上课迟到的单位是一节课，所以从周一到周三，或者从周三到周五，或者从周五到下周一，那就像是迟到的单位，我们称之为迟到的一天。

如果你的作业交得很晚，你的分数下降了多少，所以如果它能得到一张支票，另外，我们会给你一张支票之类的，但前三项这样的扣除是免费赠品，所以我们把那些空闲的日子叫做，所以我想你可以交三份作业，迟到的讲座。

整个季度都没有点球，或者你可以在相同的作业上使用其中的两个，两天后你可以交一份作业，在另一个任务中，一天迟到一天被说教，你最多只能在一项任务上使用两天的迟到时间，所以，如果它的截止日期是星期三。

你可以把它放在这里一天，或者在这里呆两天，在那之后，我们就再也受不了了，在那之后，我们给零，我们不接受迟到的工作，之后呢，除非有什么真正的悲剧发生，但总的来说，之后就没有了，你可以混搭。

就像如果你还剩最后一天，但你在两节课上交晚了，我们会利用你迟到的一天，但是医生，第二个给你一桶，就像，你知道的，使用这些的过程是自动的，你只要上交，如果很晚了，我们就用这个给你，如果你不用这些。

救他们没有任何好处，它们不会变成额外的学分或任何东西，所以你不妨，只是你知道，把它们留到本季度，在事情繁忙的地方，在你需要额外时间的地方，我想说的是，这是我在课程中的同情心部分，哪里像，如果你联系我。

你说嘿，我真的病了，我发烧了，我不舒服，你知道的，可以延长我的家庭作业吗？我想对你说的是，很抱歉你病了，这听起来是利用深夜的好时机，因为这些不应该放在，你生活中的坎坷和瘀伤。

这些是为了帮助你克服生活中的坎坷和瘀伤，我接受你的前三个理由，你可能没有完成你的任务，我很忙，我父母来看我，我的日子不好过，我的另一半，我打了一架，我觉得不舒服，这是我姐姐的婚礼，我想飞出去，随便啦。

好像所有的东西都很棒，用这些吧，所以我建议尽量保存一点，不要马上用完，因为你可能需要它们来做本季度晚些时候的事情，但总的来说，除了这些，我不知道，我不给很多额外的迟到延期，所以如果你说我没有迟到的日子。

现在我想飞到我的朋友那里，成人礼，我可能不会因此而延长你的课程，所以存一点酷，对此有什么问题吗，你是如何取得好成绩的，你一半的成绩来自于你每天每周做的事情，主要是家庭作业。

你每周去你的讨论区都会得到一点分数，我一会儿就会谈到这些，你不必来上课，如果你不想，我很想见你，但你不一定要来获得分数，你应该去你的部门获得参与积分，你应该在那里做练习，解决问题。

你参加下周开始的比赛会得到分数，这周你不必这么做，你会去一个*一点的房间，有八个人、十个人或十二个人，和一个本科生部门的领导，他会和你一起解决问题，所以你的成绩是，你不必去每一个。

但你得去找他们中的大多数才能得到满分。

你剩下的分数来自我们的两次考试，期中考试，日期，两个考试日期都在班级网页上，在这份信息讲义上，我没有复制，期中考试在11月2日星期四，那是第六周的星期四，晚上七点到九点，决赛在决赛周的星期一举行。

每周上午八点半至十一点半，我很乐意，如果你们都能，请把这个写下来，把它放在你的在线日历里，你的日程安排，不管怎样，去检查一下你的其他课程，看看你一般有没有这些空闲时间，斯坦福政策。

不让你上期末考试有冲突的课，我们有CS几乎独家许可这个时段，所以你不应该和这个期末考试有冲突，期中考试偶尔会碰到，比如物理考试或者经济考试，如果你有考试冲突，那和斯坦福有关，请联系我，我们会解决的。

如果你有考试冲突，那和斯坦福无关，我一般不会为此进行化妆测试，你朋友的婚礼什么的，我一般不给补考，除非是直接与斯坦福有关的冲突，我提到过我不是一个很好的人，这就是一个例子，但如果你和斯坦福有冲突。

请与我联系。

那是考试评分，你如何从这个映射到一个等级，我基本上把你放在一个曲线上，但我保证如果你能得到90%的分数，你至少得一个a-，如果你得到百分之八十的分数，我至少给你一个B减，你知道或者更好，你知道的。

所以我不打算，如果每个人都做得很好，我不会给某人一个F，谁在班上有89%的成绩之类的，对吧，我不会那么做的，但我会说这是一群有竞争力的人，所以曲线可能会更多地在一个零中，比这里的6b，如果你很担心。

你真的想确保你得到一个加分什么的，你得a加的机会比在b中得a加的机会大，比你听到的要多仅仅因为这两个类的性质，对呀，什么评分问题，我知道成绩有多重要，所以我不想在这件事上吝啬，好啦，哦后面的问题，是啊。

是啊，去吧，你怎么从你喜欢的分级桶里，分级桶如何变成百分比，这是个好问题，嗯，所以我承认我不是阅读自助餐系统的创造者，分级桶系统是为了给我们松懈，在课程结束时，我们如何进行映射，基本上，发生的事情是。

它是，基本上我们看有多少人得到检查，加分项，有多少人拿到支票，然后在季度末，我们在此基础上绘制了它们的含义，所以很多人想知道，我有张支票，是a b还是a-，还是C什么的，粗略地说，这到底是什么意思。

家庭作业的检查加分有点像A和检查，有点像B或B加，但如果很多人拿到支票，因为作业很难，或者很多人都得了减分，那么也许支票对那个任务意味着更高的东西，你知道我的意思。

所以你可以大致地把它们映射成A或B或类似的东西，打勾减去可能但那是，你知道的，我们动态地决定在最后，根据每个人的表现，澄清最后一点，就像最后一个要点，哦耶，嗯，我通常会确保大约一半的同学得到a。

从a减到a加，然后大约百分之三十的学生得到了一个b-到b+，有时更多的1 0 6 x往往会得到更高的分数，因为你们的马力都很大，你们都是很强壮的学生，但是，基本上你们中至少有80%的人会得A，B's嗯。

即使是很难上的课，我不喜欢你们中的一半不及格，只是因为它很难，你知道那不是，那不是那种难的，我宁愿，打你十周，然后给你一个A，你知道的，或者对你们中的一些人来说是A-，我不知道，但是呃，但是是的，就像。

我不是那种会喜欢，通过让每个人都看到来对抗严重的通货膨胀问题，那不是我的风格，所以好吧，是啊，是啊，谢谢你的邀请，在这节课中，我们将使用一些软件来完成我们的程序，被称为可爱的创造者。

大多数人称之为QT创造者，但我想应该读作可爱的创造者，它是一个用于编写c+程序的开发环境，我们在本课程中使用C++语言，每个人都应该把它设置在你的机器上，我一般假设你有笔记本电脑或电脑，或进入一个。

你现在应该去把这个软件安装到你的电脑上，帮我个忙，我已经写了一个如何设置这个的网页，你所要做的就是按照网页上说的去做，很多学生被设置在它不起作用的地方，通常，如果我追踪他们的步骤，不是他们干的。

他们没有按照指示去做，他们只是谷歌寻找可爱的创作者，他们找到了一个联系，他们跟踪那个网站。

所以转到班级网页，上面有一个链接说可爱的创造者。

所以点击那个，这些链接看起来有点，看起来有点奇怪，因为我的分辨率很*。

但你点击那个东西，上面写着可爱的造物主，然后它会问你什么操作系统，你有窗户，Mac Linux，你点击它，它说好，到这里下载此安装，它去这里下载这个，我有一些截图给你，所以就像，照它说的做，应该没问题。

对你们来说是件好事，今天的讲座结束后，如果你想做点什么，去尝试在你的机器上设置这个可爱的创建者软件，如果你能让一个简单的程序运行并打印一行输出，那太棒了，那太好了，因为我得到了很多人谁是。

今天是家庭作业的前一天，他们就像帮助我的，我的电脑不能和可爱的创作者一起工作，这听起来像是你的问题，我只是说去尝试设置它，如果由于某种原因，它不能在您的机器上正确设置，艾米和我很乐意帮你。

但你给我们的时间越多，你就越有可能有足够的时间来完成你的任务，所以今天或明天去做吧，或者别的什么，听从我们的指示，很多同学想问我们，就像，我可以用其他软件吗，就像我喜欢的那样，Xcode什么的。

我的意思是，简短回答，否，嗯，我是说，我不能阻止你，如果您知道您想使用的其他程序。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P10：Lecture 10 - Exhaustive Search - 加加zero - BV1By411h75g

欢迎上课，今天是星期一，已经是第四周了，六个中的一个，X呃，我们已经完成了十个星期中的三个星期，我们只是飞过这些东西，上周我们做了递归，本周我们将做更多的递归，我们要做一个递归的特殊应用，叫做回溯。

以及更多的内部错误，我不知道为什么，每次我开始一天，我得到这些错误，嗯哦好吧，我在回溯，所以，我的意思是，我们会花一整个星期在这基本上，它是用递归来解决某些问题的一种特殊方法。

包括探索可能是对的或可能是错的解决方案，如果你找到了一个错误的解决方案，你在算法中回溯并走不同的道路，所以这是一类我们可以用这种方法解决的问题，您知道，如果您到目前为止很好地处理了递归。

也许你也能处理好这件事，但我要说的是，当我年轻的时候学习这些材料的时候，很多年前，我发现回溯很棘手，尽管递归最终在某个时候为我点击了回溯，花了一段时间，因为它的点击，我也从我的学生那里看到了很多。

我看到学生们航行得很好，不知何故，本周砰的一声，他们碰壁了，我不明白，这是回溯的东西，我不知道，我不知道如何解决这些问题，所以不管怎样，这东西很难，这就是为什么我们会花很多时间练习它，嗯，家庭作业四。

它将于周五上市，将重点回溯，我们要解决一堆回溯问题，我知道你可能已经厌倦了每周五这么大的任务，好消息是下周五，不会有任务，但这就是为什么有期中考试，所以我喜欢这里没有变得更容易，你们都留下来了。

上星期五你本可以来的，但你做到了所以现在你完蛋了，你不是嗯是的，反正，所以我们这周要做回溯，所以让我们开始吧，与递归相同，我真的认为你不会做得更好，直到你练习，所以如果你在看讲座，这是有道理的。

解决方案对你来说是有意义的，那太好了，那是个好的开始，但我给你一个挑战，去用空白屏幕解决一些问题，看看你能不能做到，当你没有房间里的任何帮助来帮助回答问题时，所以好吧。

让我们跳进去吧，如果你想读更多，它主要来自书的第九章，虽然其中一些也在第八章，所以我想从一个叫做详尽搜索的东西开始，是一种回溯，会保佑你的，这将带领我们进入本周剩下的时间，好啦，什么是彻底的搜索，嗯。

它是当你有一套选择或价值观，你想处理或列出或检查什么的，你探索每一个，其中一个，所有这些现在有很多方法可以实现详尽的搜索，有时您可以使用循环或其他方法来完成，如果你要找的东西很简单。

就像我想搜索这个向量，你只需在向量上写一个for循环，这很简单，因为你在搜索一些线性的东西，但如果你在寻找比这更复杂的东西，也许仅仅一个循环并不容易解决它，你知道就像，例如，我们把目录爬虫程序写对了。

我们只是打印所有的文件和目录，你可以参考，就像对目录树的彻底搜索一样，因为这个结构不是线性的，它是嵌套的，等级，有更复杂的结构，递归实际上有助于在该空间上实现搜索，嗯，你什么时候能做好这件事。

我刚提到目录爬虫，你知道的，排列或搜索一组值的组合，对那个有好处，这对你有好处，你知道的，逻辑，组合器名称，密码，就像，如果你，如果你想写一个字典攻击，它尝试所有的密码，看看哪一个是正确的密码。

这就是你想要的东西，您希望彻底搜索所有可能的密码，直到你找到合适的，这些问题可能很棘手，解决或想出一个系统来解决，所以我要讲很多关于某些术语，就像我要谈论选择什么的，因为你知道当我们写递归代码的时候。

记住我们有一系列的电话，是的，每个调用都做少量的工作来解决一个大问题，在这里仍然是这样，所以我想当我谈到电话时，当我解决这些问题时，我要说的是每一个电话都做出了一个选择，下一次呼叫做出连续的选择。

我们在一系列的呼叫中做出一系列的选择，最终，所有这些选择的总和是我们搜索空间的一部分，我们看看这组选择，或者我们把它打印出来，就像我们，我们做一些事情与选择的顺序，我们正在进行的递归调用序列。

让我们看一些例子，其实对不起，让我们先看看伪代码，我看着我的例子，我想说这是一种通用的伪代码，比如如何写一个详尽的搜索算法，你在写某种函数，我叫搜索，它得到了某种参数，表示一组决策，你需要做的。

那是什么意思一个超级模糊的，但也许这意味着我有一套扑克牌，我必须选择所有的五张牌，或者一套卡片里的东西，一副牌，也可能是一组字母，我在搜索所有的密码或类似的东西，所以这里的算法是，如果有什么要做的决定。

那么让我来做一个选择，我会选择一些东西，然后我会搜索在这个选择之后会发生什么，现在我听到这里的每一件事都是这样，我想说的是每个电话都有一个选择，但它需要探索所有可能的单一选择，它可以做得很像，例如。

如果你想把所有的五张牌都打印出来，你可以在纸牌游戏中，嗯，其中一些牌是从这五张牌中的一些开始的，从梅花的王牌开始，所以也许我的电话抓住了俱乐部的王牌，说好吧，那是我选的牌，现在我要递归地选择另外四张牌。

一旦我完成了那个递归，我从理论上列举或检查了所有包含，梅花王牌或我说的任何牌，但现在我还没说完，我现在要试试两个梅花，在我尝试完A俱乐部之后，我尝试了梅花的两个，我告诉递归来探索其余的。

所以这不仅仅是我选择，然后我做递归，我可以为每一件事选择，我试着摘它，然后我做一个递归遍历，然后当它回来的时候，我尝试下一件事，尝试探索尝试探索尝试探索有点模糊，有点难跟上，不过，这样更合理。

当我们看到一些问题，所以好吧，这和递归有什么关系，我是说这些电话你说，搜索接下来的选择，这些都是递归调用，我们也知道在递归中我们总是有一个基本情况，在这里仍然如此，因为如果没有什么要做的决定。

就像我们试着把所有的五张牌都挑出来，如果我们已经选了五张牌，我们接到这个电话，那我们就停止，也许停止意味着打印我们一直在挑选的手，或者停止意味着退出程序，我不知道，如果这意味着什么，我们已经选够了。

所以现在这就像是一个基本情况，我会提到这里的基本情况有一点不同的含义，我是说当我上周谈到基本情况时，我们讨论过，基本情况是问题的一个简单版本，很容易解决，你只要立即回复，或者你马上打印一些东西。

您只知道在不进行任何递归调用的情况下该做什么，在这些问题的情况下，我不认为基本情况是这样的，我把它看作是每一个电话都在做出选择，做出选择，做出选择，基本情况不是一开始就没有选择。

我已经做了所有我需要做的选择，我已经建立了一个足够高的堆栈，我不需要把它建得更高，现在我展示我所建立的，那是我的基本情况，所以再一次，这并不是说我在解决一个简单的问题，以前的电话已经起作用了。

现在你来找我，没有更多的工作留给我这样做，我只是打印一些东西或返回一些东西或什么的，所以再一次，基本情况，稍微不同的思考方式，事实上，当我写这些问题的时候，我经常最后做基本情况。

因为我可以想象递归调用的工作，在我走到最后之前，基本情况，好啦，所以无论如何，一切都很模糊，我试图给你一个系统在这里，所以让我们来看看一个具体的问题，让我们编写一个名为print binary的函数。

打印所有具有一定数字的二进制数，你知道0和1，对呀，如果你一步一步地做这个，或者在可爱的创造者身上做这个，带着讲座页上的拉链，如果你想，好啦，所以乍一看，这可能看起来根本不需要使用递归，好吧，好你。

技术上来说你没有，但就像你可能会说的，哎呦，只要做一个循环，就像一个2到这个功率只是打印每一寸，或者你知道类似的事情，是啊，是啊，好啦，我是说，你看，有一些方法可以解决这个问题，而不需要递归回溯。

但是你知道，如果你想玩我的游戏，你必须这么做，递归的，不允许使用循环，如何做好，二进制二打印所有有两个二进制数字的数字，像个王子，意思是同样的顺序，对呀，所以好吧，嗯，让我们考虑一下。

让我们，让我们去找敏锐的创造者，我这里有打印二进制文件，好吧，如果我打印所有的两位二进制数字。

我打印零零，零一一，零一一，嗯，也许我们可以用我们的旧方法来思考递归一分钟，我们可以从基本情况开始，比如什么是容易打印的二进制数字，零位数。

好啦，就像，如果数字等于零LOL，我什么都不用做，还有其他容易打印的二进制数字吗。

就像一位数的二进制数字，只会在行上打印一个零，然后是一条线上的一个。

好啦，嗯，我可以在别的地方做得很好，如果数字是1，看到零，所有人都看到，让你一个和所有的这是很容易的其他，所以我想我会假设，我不打算担心负数，我可以抛出一个异常，我以后再做，否则我就假设数字大于1。

大于等于二，所以说，每个递归调用做一点点工作。

就像一点点工作，如果我打印一个两位数或三位数二进制数，在这里做一些工作的单位是什么，一个数字，好啦，这个问题本身是如何相似的呢？如果你看2-1和3-1，自我标记区在哪里，高阶数字优先。

然后打印0和1，所以如果你看这个，打印二进制2的输出，它就出现在那里，不是吗？它也出现在那里，所以我的意思是，这里的想法似乎是打印二进制文件，我应该打印一个零，后面跟着一个递归调用。

然后我应该打印一个1，后面跟着一个递归调用，有点对，那是一种，这里的想法，好啦，哦，天哪，我跑得很慢，我想我关闭了嘿松弛，走开啦，你在哪里，你喜欢我的*狗，啊，我怎么关闭它，我甚至没有松弛跑。

是因为铬吗，哦好吧，希望，希望他们不会像男人一样突然出现，乔的节目烂透了，哦我的天啊。

好了，我们永远不会谈论这一点，所以一种指纹是零，然后是其余的，然后打印一个1。

紧随其后的是红色，对我们就是这么说的，好啦，所以也许更像是，让我们做C出零，然后打印二进制的数字-1，也许我不想让它掉线，所以我会那样做，然后，我将做c出一个1和打印二进制，刚刚好，就像，前面一个零的。

前一个前面有一个像这样的东西，好吧，我可以试试，然后它做什么打印二进制，好吧，那，你只打印了一个零，然后去下一个。

你想要什么四零，是啊，是啊，他说得对，寿星们得到了，他说我们的代码只打印一个零，然后进行递归调用，所以它就像打印这个零，然后它试图这样做，所以我们必须在第一行写一个零，老兄，你知道我的意思。

你说的完全正确，我想这么做，但是再加上一个零，我们以前见过类似的东西，右与缩进的目录爬虫，我们是怎么做到的，因此，上一个调用可以传递一些信息，以便在下一个调用之前打印，我们该怎么办，是呀，你必须。

你必须添加参数，是啊，是啊，让我们向函数添加另一个参数，传递那个零或那个，我经常从学生那里听到的，你说你答对了，可能是像前缀字符串之类的传递，很多时候，当我在一个零中显示这个，6B，他们说的很好。

您应该将该零作为新参数传递，所以你可以在这前面打印，这是个不错的主意，只不过，我想你会发现，你知道如果这个人给这个人零分，这家伙想通过零分，打印二进制文件，所以我想你最终会有多个角色，在这里传递。

所以我想你想要的是你想说。

实际上，如果我去这个标题，或许你想让我说，字符串前缀等于没有开始，也许只是从没有前缀开始，所以我想我们要用这个参数做什么，这里是，它将存储所有的二进制数字，我们需要把我们的，就像如果我打印二进制。

这时我接到了打印二进制三的电话，然后他会给我一个零作为直线和零，然后在我一路跑到完成后回到他身边，他会再打电话给我，但他会递给我一串，我会把我后面的那个，再一次，为什么它需要是字符串而不是int井。

因为当我递归调用print二进制1时，我要通过他的零加我的零，他的零加我的一，等等，所以我得把这个东西种出来，所以我想我要做的是，如果是一位数字，好啦，所以我真正想做的是，我想把数字减一和零。

数字减一加一，这段代码有几个问题，但它越来越近了，加上零前缀，这真的很重要，我不知道你是否明白其中的区别，但就像之前的电话给我发了一个前缀，我想把这个也放在前缀上，因为如果在我之前有四个电话。

里面有1和0，我希望我的选择是，好啦，我们快到了，我们就快完成了，还是不太对，我的意思是，我可以运行它，如果你想要的，更糟的是，你所有的想法都很糟糕，好险啊，嗯，我们从来没有，是啊，是啊。

构建这个前缀的全部意义在于它被打印在一些东西的前面，我们从来没有把它打印在任何正确的地方，我想我们可能要重做我们的基本案例，所以再看看，我想让你重新思考这些不同的案例意味着什么，我们的代码真正在做什么。

我说的是选择和探索，遵循选择，那么这里到底发生了什么，这东西就像一个选择的集合，你一路走来，在递归调用上，我把它们储存成一根绳子，但这只是一个实现细节，它是一组0和1，我在按一定的顺序选择呼叫。

现在我要打这个电话，这可能是第一个电话，也可能是第十个电话，之前的那些电话，把一些字符放入字符串中，那里，这些代表了这些电话所做的选择，我的电话也需要做出选择，它这样做了，我选择零。

这条线是一种选择和探索，它在说，选择一个零，然后现在打印可以跟随该零的内容，当它运行完毕，当它回到这里，选择一个，尝试所有可以遵循的二进制东西，好啦，最终所有这些电话都完成了选择，别无选择。

如果是这样的话，这个字符串存储了在整个过程中所做的所有选择，我怎么知道什么时候没有选择，当数字为零时，所以我想让你重新考虑一下，此参数的含义，我知道如果你过了三关，然后打印所有三位二进制数。

但根据我们的守则，它的意思是在这里还需要选择多少位数字，现在，还有多少人可以这样选择，如果我说数字零，哈哈，我什么都不用做，那不是正确的想法，不是缅因州的人让我打印零数字，他们让我打印四位数。

我要求自己打印三张，也就是我自己打印两张，调整自己打印一个，只有我自己打印零，答案不是什么都不做，是对以前的人所做的一切的回应，我该如何回答他们的所作所为，我应该把他们做对的事印出来，如果没有选择。

打印您选择的内容，这个前缀是此时应该打印的全部内容，因为前缀有三个字符长，如果我在打印三个二进制文件，无论数字的值是多少，这就是我现在得到的，我甚至不需要这个权利，这其实不是一个有用的案例，其实呢。

这是个破了的窃丨听丨器，我们以前有过，但我们认为我们需要它，但我想我们没有，所以说，我们试试看，哇哦，它的工作原理，太神奇了，所以这与我们所做的大多数其他递归代码非常不同，还是很短，看起来很简单。

对案件含义的思*过程，以及这些叫声是如何相互交流的，与我们上周所做的完全不同，好啦，所以我称之为对三位数的二进制空间的穷尽搜索，本质上是现在，如果你在想象，这些电话发生了什么，我又可以用我的魔法了。

我可以把这个递归称为h，记住包括RE，在这里我可以，在每次通话开始时，我觉得你应该这么做，无论是否使用递归h，如果你想学习递归，只要说，看出去，数字，不如，我说数字等于，然后我说逗号前缀等于，加前缀。

所有的嘿，让我们看电话，那么它是做什么的呢，哦等等，它没有那样做，对不起对不起，对不起，对不起，我没有做，什么叫递归缩进，这就是我想做的，这就是我导入递归的原因，H递归缩进在那里，会让通话结束，好啦。

让我们试试看，所以打印二进制的三个说，我把所有三位数的号码都打印出来，好吧，那么首先我将尝试两个以0开头的数字，稍后，我将尝试两个数字，以一个右开始，这是我的两个电话，以0开头的两位数字。

尝试所有从零开始的一位数数字，所有以0开头的一位数，那是他的两个电话，每一个都用零打电话，剩下的数字是零和一，每一个都导致产出，因为那些太左了，行线是输出，我们代码的西雅图行，所有这些台词都是。

所以你可以看到一个前缀不断增长，当它变大的时候，你找到基本情况，把它打印出来，这就是我们的代码所做的，这有道理吗，你对那个代码有什么问题吗，好啦，呃好吧，如果你明白代码，哈哈哈。

我们为什么不试试这个的变体呢，让我们试试一个叫做打印十进制的，那么那是哪里，哦对不起，我想在我打印*数之前我会给你看这张照片，就像我们说的电话树，就在一分钟前，你还从侧面看到了这一点，我是竖着画的。

所以我叫它到目前为止而不是前缀，但你的单词前缀也很棒，所以这就像我到目前为止所选择的，或者我的前缀是什么，这是一棵由两位二进制数组成的树，但是很多算法都有这样的想法，一棵树不同的探索路径。

可能会导致答案，打印出来什么的，所以让我们打印十进制，这意味着打印所有的十进制数字，所以它基本上和打印二进制代码完全相同，只不过是十垒而不是二垒，对呀，好吧，我们走吧。

让我们去看看可爱的创造者，所以这里是打印十进制，我想我可以像打印二进制文件一样，我是说我可以我可以回到这里说，实际上，我想要一个字符串前缀作为这里的参数，只要是可选的，我能做到，然后我会去写它。

我必须写字符串前缀，我想我可以去复制粘贴，我喜欢复制我自己的代码，所以我可以把这个改成，打印十进制，哇塞，这个比我想象的要容易，好啦，嗯所以现在，但现在还在打印二进制数字，我该怎么办，是的。

所以我的意思是，我认为这是一个正确的解决办法，但我想部门领导不会给我充分的风格点，所以我听到有人说，循环是你想要的吗，是啊，是啊，是啊，是啊，您可以执行for循环，比如1=0整型数，我等于0到9。

我加加哦，看起来像循环，虽然打印前缀，加i，你得做，你得说字符串对整数，我不过没关系，好啦，当然可以，哦不，无无整数，只是耶，从整数到字符串，感谢您使用该功能，我想我得说包括，我想是在搅拌器里。

我想这就是功能所在，好啦，罚款，我们可以试试，让我们去Main，让我们取消对该调用的注释，哦伙计，五位数太多了，让我们做所有的三位十进制数字，下课后你可以留下来校对，如果你想，我觉得它很好用。

听着我的意思不是那个很难，那个应该不会花我们很长时间，但我确实想指出，我们在这里使用了一个循环，就像，我们在哪里作弊，我觉得这样可以，我是新来的，我不会用这个循环遍历所有的数字。

我不是用循环来摆脱递归部分，好啦，我只是使用循环来列举所有可能的单个选择，我的电话可能会选择打，我是说你看，我在这里也可以用，我可以用一个从0到1的for循环，但那似乎有点傻，那么这个呢。

几乎没有足够的碎片，我刚把它们写出来，但在这里因为有十个，我用了一个循环给他们，所以有时候当我们解决这些问题的时候，我会说嘿，你可以用一个循环，如果你想，但是你必须对自我使用递归，问题的类似部分。

所以我想说的是，如果我，如果我在作业或测试中告诉你类似的事情，我的意思是你可以用这样的*循环，提示你的电话，你要做的，但不是一个循环来解决整体，呃问题和避免递归部分，所以无论如何，那是打印十进制。

基本相同的想法，我展示它的唯一原因是为了表明有时循环是可以的，在这方面，好啦，我们再玩一会儿。

让我们做排列，排列，意思是把字符串的所有字母重新排列成所有可能的顺序，所以如果你把马蒂这个词，你把这些都放在那里的某个地方，呃，我猜，如果你知道我的全名，马蒂步，你重新安排它，你得到精子，帕蒂。

我想他们在我们的，我不知道，我不确定，啊，反正伤口很深，恶心，所以把这个词的所有字母重新排列成所有不同的可能顺序，对所以这感觉和前两个问题相似，把你知道的都打印出来，打印所有不同的方式。

你可以做一件详尽的事情，搜索这个字符串的所有排列，对呀，好啦，但你知道我给了你这个算法，战略或模式，就像你思考决定和选择，你可以选择什么，就像，这个问题的选材单位是什么？一个人应该打多少钱，做是。

像字母一样的字符，也许我选M先走，或者我应该把Y放在这里，比如选择用一个字母做什么，好啦，我觉得听起来不错，别人说的是你说的，是啊，是啊，嗯，嗯。

我们怎么做，如果我去找可爱的创造者，我现在有一个不同的文件要打开，我把这个叫0 0 0 1，随便啦，好啦，现在一个开放的置换，所以这里我有置换字符串的打印，给定字符串的所有可能的重排，好啦。

所以我的意思是，只要想象一下一般的模式，就像做出选择和探索一样，如果没有更多的选择，那我就完了，那种东西所以，嗯，我怎么做，我在这里怎么做，比如什么，什么样的选择，我如何做出选择，我不知道，帮我一下。

你下一步会做什么，取第一个字母，就像这里，好啦，所以就像这样把那封信从蓝色中剪下来，字母和琴弦可以把它们中的每一个都选在第一位，改变，然后将其从字符串中移除并传递给字符串，知道了知道了，好啦。

所以每一个字母都很像，如果我们说的是绳子，马蒂，我有点自我中心，我选了我的名字作为例子，所以你是说每一封信，就像我认为每一个电话堆积如山的方式，就是，他们每个人都在挑选下一个字母。

所以像这个人首先要选择，这五个中哪一个应该在输出中名列前茅，也许它选择了M，也可能是它挑选团队什么的，但我们选择了，现在我们把所有的四个字母，接下来的事情，所以你说，只是我需要把它循环一下。

就像一个例子，如果我要挑出M，然后做一个递归，做剩下的，就像把零拉出来，然后你知道吗，字符串s 2等于s点1的子搅拌，从一点开始，然后对一些模糊的东西进行排列，但你是说。

那只会打印第一个字母为m的字符串，我想这么做，然后我想打印所有第一个字母为a的东西，就像这段代码后面会有一些模糊的东西，比如，然后它就像s子字符串，零一后面跟着s点子，哎呀，那是什么潜艇，先生要你知道。

就像商店的信一样，所以你会做，就像五个字母中的每一个，但是你说过要用右圈，因为这些大块会完全一样，这些项的个数与s的长度有关，所以是的，我想这是个好主意，所以就像每一个，我等于零，我*于S点的长度。

我加上加上你说，选择字符i，然后转到i，但不包括i，然后从i加一开始，所以我们把除了字符i以外的所有东西都放在那里，然后排列其余的，在某种程度上这是正确的想法吗，是零，什么都不是，是啊，是啊，哦不。

那几乎完全正确，你说过，你说过这样下去，每次我们执行递归调用时，我们通过的力量更短，对呀，传球什么的，是啊，是啊，是啊，是啊，所以确切地说，嗯这根弦变短了，你一秒钟前说过整个过程将停止这样做。

当里面什么都没有的时候，X2和S2都被咬碎了，我觉得你的意思是，我的S 2会是下一个，太像了，如果s点长度为零，这就像一个基本情况，所以我们还没有完全的代码，但除此之外，我们会喜欢下一封信。

或者我会说选择下一个字母作为字符串的一部分，我们正在建造的，好啦，你说的最后一句话是什么，我认为这也是一个很好的建议，我们想把这个打印出来，并使每次我们使用第一个字母添加到，是啊，是啊。

我认为二进制问题的诀窍是传递前缀什么的，也是在这里行得通的诀窍，嗯，我的意思是看，并不总是一根弦，但不知何故，你需要跟踪你的电话正在做出的选择，你需要把这些选择交给下一个电话。

因此下一个调用可以看到它们或添加到它们或打印它们，或者任何电话需要做的事情，在这种情况下，我认为它应该打印所有的，所以我想我们只需要建造这些街道，是啊，是啊，所以所以我想，你说过像字符串前缀一样传递。

听起来不错，如果我去这里，我写字符串前缀，也许一开始和以前完全不同，好啦，所以现在在这里，如果我的长度为零，就是说，啊，其实呢，我还没有用前缀，对呀，如此排列的S 2，我得给他一个前缀，对呀。

那么我在这里传递什么，第一批，是啊，是啊，我想这不是第一个角色吧，我叫它C，就像这个角色对吧，所以就抽出一个角色，把绳子切成薄片，把他从绳子上切下来，现在用较*的字符串调用置换。

但这个人被选中成为下一个，基本上，好啦，所以如果我的长度为零，那是什么意思，这是基本情况，对呀，但是好吧，我怎么到这儿，这是什么意思，如果我的密码到了，真的吗，是呀，没有选择了，是呀。

我想你们都说了同样的话，你说过的，呃，前缀已被构建为包含每个字符，从S和S已经萎缩了，里面什么都没有了，S，s应该为空，前缀应为满，所以这意味着我们选择了一个排列，对呀，所以让我们把它打印出来。

看到前缀和所有，我们试试看，哦，看，它现在正在打印所有不同的字符串，你可能会说很好，这儿有什么菜？为什么它按这个顺序打印，我是说基本上是这样想的，是它先选了我吗，然后打印所有以m开头的字符串。

它为什么先挑M，m是不是字符串中的字符零，原来那是在里面传的，先挑第一个试试，所以它会打印所有以m开头的字符串，如果你仔细看，它下一口井挑什么，原始字符串中的下一个是，所以它会打印所有以。

下一个带绳子的，最初的字符串是r，所以它打印了所有以先生开头的，原始字符串中的下一个是T，所以它打印了所有以MT开头的，原始字符串中的下一个是y，所以它会打印所有以m y开头的，一旦它完成了。

它尝试了所有不同的第二个字符，可以跟随我，然后它回去，M部分就完成了，现在它开始打印所有以a开头的单词，所以看起来它在这里起作用了，我们换个名字吧，我应该用谁的名字，辛西娅怎么样，她是我的好兄弟。

所以让我们打印那个，喔喔，有一大群你可以看到输出只是倾倒，倾倒，有多少，有多少行输出。

不知道，我用Python作为计算器。

关于新型五人组，哦四，啊。

第一行是标题，我想这可能是有原因的，你知道为什么对，就像，第一个人有七个不同的选择，然后他把那个拔出来，然后接下来的所有，还剩六个让他们挑，它否决了它，所以说，是啊，是啊。

差不多吧，嗯，好啦，反正是排列，如果，哎呦，有个问题，是呀，去吧，是呀，所以是，哦，好吧，子字符串函数，它有这个属性，如果你在字符串的末尾开始或结束，就像如果长度是十，你给它一个10的索引，只会断掉。

如果你要求一个超出界限的真实角色，所以如果你说嘿，长度为10的绳子，把十点开始的信都给我，它会给你一个空字符串，但如果你要十一个，我想它会，它就会坠毁，这只是一个特殊的例外，如果你在最后。

你说从这里开始把一切都给我，这就像，哦，你是说绳子末端的一切，它让你一无所有，所以结果是，我是说我们很幸运，我是说我们得把一堆该死的，如果在这里检查其他，会很痛苦的，但是是的，算出来了，好啦。

所以就像这个真正快速的轻微变化，如果不是打印所有的排列，我要你回来，或者给我所有的排列，就像矢量什么的，嗯哼，那是什么？是啊，是啊，而基本情况，我们可以把它插在一个确定的，好啦，不是打印而是插入矢量。

我认为这是个好主意，如果你有推荐人，是啊，是啊，是啊，是啊，所以我想如果你想象一下，我们完全可以作弊，做一些不好的事情，你知道吗，就像我会做的是，我就会到这里的某个地方，我想包括矢量，风格不错。

我可以那么做但是但是像什么，如果我只是说像LOL向量的字符串，你知道的，LOL全局变量，无论如何不要这样做，所以我有一个全局变量，这是不好的，对吧，但在这里的置换，你说的不是打印出来。

就像V点添加前缀一样，让我们把它扔进矢量里，魔术全局矢量，现在在这里，在我调用置换之后，与其去见辛西娅，也许我会在这里做一个艾比，我的狗，然后我就像c出v手柄然后，A指纹，现在所有的一切，有些是重复的。

因为有很多，我不在乎那个，那很好，没关系，但我的意思是，在那里，我得到了他们作为一个矢量，那很管用，但那不是很好的风格，对吧，你知道我们什么时候去找我们的狗，我就像，真好笑，我妻子多么想给狗取名。

一些对婴儿来说是字谜的东西，就像四个，我们说好要有个孩子，你知道这就像，我知道你在做什么，嗯，它也起作用了，所以好吧，我是说这是一种把结果放在向量中的方法，但你有一个更好的，我觉得，解决方案的样式。

我不想去的地方，这个全局变量，我真正想要的是，你知道的，弦向量，V等于置换，然后我打印这样，你知道的，我不想要这个矢量，就像漂浮在这里，像这样，好啦，所以我的意思是，你能再说一遍你之前的建议吗，啊。

我想说我们可以在更改中引用这封信，以…的形式，那是个好主意，我是说有时候当我们想要一个我们操纵的收藏，我们通过引用传递它，我认为这是正确的想法，因为我想你知道你可以在这里画图，就像我可以做一个矢量一样。

我可以把东西放进去，我可以退回去，但听起来有点恶心，不是吗？我要打电话给下一个人，他返回一个矢量，我必须把它和我的矢量结合起来，听起来有点恶心，所以我认为更好的方法是，做一个矢量。

然后所有的电话都可以分享它，把它传给对方看，当他们都填好数据后，我们就可以把它送回主基地，基本上现在我们学习了静态变量，您可以创建一个静态向量，但我不喜欢那样，因为这个矢量会在。

递归调用是以我不希望的方式完成的，我想我不想用静态向量，所以你说的，我觉得是个好主意，就是嗯，让我们做一个矢量，我们通过引用传递，现在你可能会说好，嗯，也许你想要的是向量V，然后我排列艾比逗号V。

然后它就像把所有的东西都放进V里，但我想挑战你，如果我真的想让它看起来像那样，得有人做这个矢量并把它传来传去，所以它充满了数据，所以我的建议是，我想有时当参数不匹配时，我们的主要需求和递归所需的参数。

有时我们只是做另一个函数，在这两者之间架起桥梁，所以我认为你应该做如下的事情，如果你想做置换，那么我真正要做的是，我会有一些其他的函数，叫做虚空置换，获取字符串的字符串前缀和字符串V的向量的帮助器。

我想这是指，就像你说的参考，所以他们分享它，现在实际的置换函数，当你叫它的时候，它会说我想创建一个字符串v的向量，然后我想打电话给置换助手，然后我想返回V，所以就像我成功了一样，我把它传下去。

我把它还给你，我得为这种排序编译做一个原型，但这个想法，是啊，是啊，所以有没有可能，嗯，而不是这是有可能的是一个功能，然后使用默认值，哦，使用向量的默认值，等于空，或者别的什么，嗯可能。

但我不知道它是否也适用于推荐人，我觉得这样比较好，如果它是按值传递的，我不知道你能不能让它工作，我也想提醒你，就像我在教你策略一样，这适用于所有的编程语言，不是每种语言都有引用参数。

不是每种语言都有默认值，你能做这种事情的每一种语言，就像如果你用Java做这个问题，你经常要这样写，没有办法绕过它，是啊，是啊，去吧，是啊，是啊，所以也像以前一样，您认为这比使用静态变量要好。

就像它要研究变量，哎呦，什么时候好，当我明确地希望向量在这之后继续存在时，并在以后被此函数重用，就像一*时后回忆，如果你再打这个电话，一*时前的结果仍有帮助，在这种情况下，你一*时前需要的矢量。

你受够了，它说与你现在计算的新向量无关，但是是的，视为函数是第一类值和c加，有可能说，比如将置换帮助器函数存储在您的作用域内，避免命名空间，然后就像，哦，就像在一个范围内声明它，我是说你可以做很多事情。

我想我又是说，就像我认为这是做这件事的方法，这是最语言不可知论的，如果有两个函数，其中之一是问题语句需要的参数，另一个是解决问题所需的参数，您经常编写两个函数，你有一个叫另一个。

肯定有一些你可以逃脱惩罚，两者的某种结合，这可能包含了C Plus的一些特性，但坦率地说，我甚至不太喜欢C+，或者是在功能上完成的，呃，所以现在我只是在开玩笑，但我，你知道这是你通常说的方式，这样做。

你知道，就像你把矢量，你把它传下去，你还给我，我需要解决的一个问题是，因为这家伙在做真正的工作，下面的这些呼叫需要调用置换，帮助者而不是排列者，所以它实际上会做工作，哦，我必须通过V。

唯一一次任何东西被添加到，V哥在这里，把它打印出来的地方，所以如果我编译这个，从，啊，是啊，是啊，是啊，是啊，这个应该返回字符串的向量，所以我想我需要把我的原型固定在这里，是啊，是啊，事实上。

我还可以把前缀去掉，因为唯一真正需要前缀的人是帮助者，所以我的意思是，有时候你稍微清理一下，所以让我回到这里，所以没有前缀的排列，所以我传递s和空字符串和v，所以是的，现在我想我需要这个标题在这个上面。

所以我可以看到它与分号在那里，我想我现在很好，否，我不知道，复制粘贴，好啦，我想我现在很好，是呀，网络，但我只想指出，那是个例子，在那里，我不想把我想捕捉的所有东西都打印成一个集合。

所有的事情都有一些*技巧你必须做，你得收集，你得把它传下去，参照，你得把东西放进去，当你做完，你得把它拿出来，要么通过引用，要么通过返回，所以你得想想所有这些事情，如果你要收集他们，相反，印刷是伟大的。

因为打印会把它发送到控制台，它只是从这个函数中逃逸出来，到用户可以看到的世界，你知道的，但如果我想保留它，并把它带回代码的其他部分，这可能有点棘手，所以这就是我在这里做的，好的，好的，关于那个的问题。

我想再次提醒你，你经常需要这样的东西，我告诉你的地方，你得写这个函数，你就像，我做不到，我还需要五个参数，好吧，好吧，用五个参数写你自己的函数，让这个叫它，现在你没事了，只是你知道你，因为你得写这个。

不代表你不能写这个，你知道这很重要。

我们回去吧，那还有什么，还有什么还有什么，是啊，是啊，是啊，是啊，是啊，是啊，我们已经讨论过这个问题了，好啦，置换，我想我们可能有时间进行这种排列的变化，这是只是给定流的唯一子字符串的组合。

有一定数量的字母，这是一个非常相似的问题，很相似的问题，我想现在就打印出来，我不想把它们存储在矢量中，或者别的什么，注意到有像谷歌G O O G L E这样的重复，我不想再发疯了，因为有两个重力什么的。

你知道的，我对这个字符串中任何三个字母的所有唯一的三个字母顺序的意思是什么，任何一般的想法，就像，我将如何处理这件事，我会如何攻击这个，你说的话，只是制作它只有另一个的独特水平，和，啊，那很有趣。

我可以扫一扫，剪掉所有重复的，我可以这么做，那不是我想的，但是，然后只是排列字符串，所以我会做Og l e，但是三个方面呢，虽然，怎么样，我不想要所有的信，我只要三个，对呀，还有要做的，别人的手。

我先来个新的，我做了那个解决方案来做弦，啊，我们不想这样，我失去了粘液，这里应该有黏液，我是说，它说可以形成，是啊，是啊，是啊，是啊，我是说，有不同的方法可以把这件事做好，你可以写一个版本，打印谷歌。

但无论你做什么，你不会想要两个版本的黏液，一个有第一个O，然后是第二个O，一个是第二个O，然后是第一个O，我不认为这两个问题中的一个比另一个更好或更难解决，像不打印重复的东西这样的一般概念是什么，是啊。

是啊，也许您可以在打印前传递解决方案的向量，检查一下你是否已经找到了解决方案，是啊，是啊，我是说，我想我想，如果你想从排列问题到这个问题的最简单的改变，你用最少的打字就能做到的方法，我觉得是抄袭。

粘贴置换码，但是把你打印的所有字符串保存成一组，然后如果你以前没见过绳子，不要再印了，基本上像这样的东西。

我想只是为了时间，因为我只有一两分钟，我想我作为一个黑客要做的是，我将把这个函数改为组合函数，我不打算费心给它起一个合适的名字，所以我要在这里写谷歌，但是在这里，我想我要做的是把一个矢量。

我要做c出前缀，所以关键的是，如果你想象一下我出轨了，我有一套绳子叫做已经打印好了，你知道的，如果我能像这里一样作弊，我有一套叫已经印好了，然后我想你会做的是，当你打印东西的时候，你会说已经打印点。

添加此前缀，对呀。

但你要做的是在你印刷它之前，你会说如果已经打印的不包含这个，打印并添加到集合中，是啊，是啊，就像，如果你需要喜欢的会员，不管怎么说，你只要试着把它加到布景里，然后在最后打印出布景中的所有内容，当然。

我是说你可以把它加到布景里，然后打印一套也没问题，这段代码没有处理长度方面，长度为3或其他的排列，所以我认为当前的代码所做的是，它避免了打印同一字符串的两个副本，回家前的最后一件事，是啊，是啊。

所以我是说你可以用一个字符串，它有字符串的所有唯一字母，然后您可以递归地找到该字符串的所有字符串，它们被称为，当然可以，我告诉你吧，让我们在周三探讨这两种解决方案，不过，我得让你走。

所以祝你有美好的一天。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P11：Lecture 11 - Backtracking - 加加zero - BV1By411h75g

欢迎光临，今天是星期三，现在是第四周，我们今天要做一个关于递归回溯的讲座，我们周一开始的更多详尽的搜索内容，星期五作业四出去，你有时间做作业，这将是一项难得的任务，你要花一个多星期的时间来完成。

因为几周后就要期中考试了，所以好吧。

让我直接跳进去，我没有什么要宣布的，我不认为今天，所以我们来了一次又一次，我们在看书，如果你读了这本书，这些材料主要来自书的第八章和第九章，所以这是一个很好的参考，可以查看更多的例子。

回溯是我们上次讲的一个特例，彻底的搜索，所以让我再次提醒你，我再问你一次，我猜什么，那详尽的搜索是关于什么的，做详尽的搜索意味着什么，所以看看所有的可能性，也许是解决问题的空间，你可以做出选择的空间。

或者类似的东西，是啊，是啊，绝对的，一般来说，你能告诉我，或用于执行穷举搜索的算法策略类型，递归的，就像我在周一的课上使用了一些术语或一些常见的模式，你能想到那些东西吗，是啊，是啊，尾部递归。

哦有趣好吧，我想当你说尾部递归的时候，你说的是以某种方式进入下一个电话，但我不认为你必须利用这一点，做一个彻底的搜索，我是说，我在找一些有点不同的东西，你有什么想法，嗯，有一堆选择要做，代表了一种选择。

是啊，是啊，每次通话，每次递归调用都会做出选择，然后继续下一个递归调用，它将使更多的选择正确，所以这是一个选择东西的想法，然后探索或寻找可以跟随这个选择的东西，这就是详尽搜索的一般模板，基本情况是。

如果没有更多的决定要做，我们停下来，或者我们打印我们决定或选择的，或者类似的东西对吧，我刚刚谈到了基本情况是如何不同的，对基本情况有不同的思考方式，当你彻底搜索，基本情况不像，哦。

你让我解决一个简单的问题，所以我现在就解决它，不完全是那样的，更像是，啊，在我面前的电话已经做了很多工作，现在我们做完了所有的工作，所以我要打印一些东西，或者我会归还一些东西或类似的东西。

所以基本情况是这样想的，现在这是对每个选择的详尽搜索，尝试一下，然后寻找可能跟随这个选择的东西，好啦，那么现在回溯得很好的是什么，这是一种策略，一种算法策略，在那里你找到问题的解决方案。

通过尝试部分解决方案，看看它们是好的、正确的还是有希望的，如果他们不正确或不合适，你解开它们，回到你来的地方，你走回头路，它非常类似于穷尽搜索，不过，穷举搜索有点像回溯算法，在每个解决方案都合适的地方。

你只要把他们都找出来，你得一一列举，你得把它们都打印出来，你得把它们都放在一个向量里，回溯就像，我想去看看所有的解决方案，但有的不好，有的好，我想留下那些好的，所以这有点像穷尽搜索加过滤，你可能会说。

我们称之为蛮力技术，因为它只是检查一切，或者至少它确保它已经考虑到了一切，您经常使用递归来执行此操作，虽然我不知道我是否真的说过这句话，当我们刚开始学习递归的时候，但是你知道。

递归的思想并不比像循环这样的东西更强大或更强大，您实际上永远不需要递归来解决编程问题，你不用递归就能解决每一个问题，但是由于这些算法的策略通常是自相似的，递归通常是为它们实现解决方案的好方法，是啊。

是啊，两者有什么区别，回溯搜索和穷举搜索的区别在于穷举搜索，一旦我们到达终点，就像我们试图想出所有的四位二进制数字，或者我们试图想出一个字符串的所有排列，一旦我们到达终点，一旦我们选择了所有角色的顺序。

或者数字的所有位，没有坏数字这回事，不良排列，所以我们得到一个排列，然后我们把它打印出来，或者我们储存它，或者随便什么，所有的终点都很好，终点，我们只想把他们都找出来，回溯就像有些端点不好。

我不喜欢他们，我不想把它们打印出来，我甚至不想处理它们，如果我能避免，但我一会儿会谈谈你怎么能做到这一点，反正，有很多可以使用回溯的例子，有很多游戏，有很多涉及回溯的编程问题。

我认为最物理上可以理解的例子是如何走出迷宫，比如，基本上如果你在一个有墙壁的二*迷宫里，你可以向不同的方向移动，你想弄清楚，我如何走出迷宫，我是说走出迷宫有不同的策略，也许你听说过右手规则什么的。

但是逃离迷宫有不同的方法，但一个策略是尝试所有不同的方法，试着往上走，如果成功的话，然后你就出来了，不然下去试试，如果不行的话，试着往左走，如果不行的话，试着往右走，这些都是递归的东西，试着从左边逃跑。

试着从我上面逃走，如果我走上去，我走上去，而且是死路一条，我需要回到我原来的地方，你回来的方式是通过这种回溯过程，所以无论如何，这种尝试解决方案和毁灭的想法，如果你不喜欢你的结局，这就是回溯的想法。

并建立在详尽的搜索基础上，所以好吧，如果这是你如何进行详尽搜索的模板，回溯的模板几乎完全相同，看着我的冷静消退，哦哇哦，等一下等一下，太糟糕了，我得再做一次，Linux无法处理我的幻灯片有多酷。

我想是的，我强调了不同的部分，只是你选择了某样东西，然后你搜索了这个选择之后会发生什么，但是当你搜索完关于选择的后续信息后，你必须撤销，你必须撤销你所做的选择，你这么做是因为你知道。

也许这个选择在某种程度上改变了世界的状态，你决定不喜欢这种修改，我是说这里可能会有更多的细节，也许我想说的是，如果C后面的决定是糟糕的，然后你看，我的意思是，你如何编码这个是有变化的。

但关键是它基本上是一个穷尽的搜索算法，但有时你有一些逻辑，这就像撤销了你以前选择的东西，我想当我们看到一些问题时，你就会明白了，你就会明白我在说什么了，好啦，这里有一个快速的例子，你需要机械地回溯。

即使所有的结果都是我们想要打印的，但我会得到一个，我们不会在一秒钟内打印出所有的结果，所以这是一个叫做掷骰子的问题，我只想打印出你能做的所有可能的角色，两个六面骰子或三个六面骰子或任何权利。

所以我认为很明显，问题是自我相似的，就像，如果查看变量为1的输出，1的好规则是1 2 3 4 5 6谢谢，二的规则是基的输出，反复一的规则，前面有一个，前面的两个和三个，所以这有点像。

你可以看到n的骰子滚动与n的骰子滚动有关，减一，现在这里有一种自相似性，这和我一分钟前说的不完全一样，我是说有些路是好的，有些结果是好的，其他人是坏的，倒退的，这个问题并不完全有这一点，所以。

但我要说的是，我会用这个来解决一个问题，我们要打印所有的组合，所有的骰子，所以我的意思是，你怎么开始处理这样的问题。

如果你必须在这里掷骰子，它是，如果你要掷那么多骰子，并使用递归打印出它们可以拥有的不同值，您可以将此看作是一个详尽的搜索问题，如果你想想代码，上次我们打印二进制文件的时候，我们做了排列。

我们必须考虑一些我们传递的参数，从一个电话到下一个电话，我们对那些道具的参数做了什么，把你的手举起来，是啊，是啊，是啊是啊，所以在其他问题中，我们做了一个额外的参数，叫做前缀。

我们设置这个参数的原因是为了跟踪二进制数字，或者以前调用选择的字符串字符，对，我们应该写的标题没有这个参数，但我们加了它是因为我们决定需要它，这通常是这些问题的主题。

我们需要一些额外的参数来跟踪以前调用所做的选择，所以这里也是这样，所以我想我们真正想要的是一种叫做掷骰子的方法，帮工，你说的掷骰子，传一个矢量，你知道我们可以试着用一根绳子，前缀什么的。

但我想现在的情况是，我们选择一些骰子号码，我们想记住所有的骰子号码，我们最终想把它们像这样打印出来，看起来就是这样，当你打印一个矢量或某种集合时，所以也许储存角色，我们选择了一个整数向量。

那可能是个好办法，所以int向量选择了这样的东西，通常当我们将集合作为参数传递时，我们通过参考传递它们，所以所有的电话都将共享集合，我想我也想在这里做，嗯，如果你想开始，你基本上没有双关语。

你想你想让这个家伙，叫那个家伙来这个家伙做所有真正的工作，右上角的那个，所以基本上我只想叫骰子卷，帮助者，我想把我的骰子数，然后我想通过某种矢量，我的意思是你只需要在这里声明一个向量，int v向量。

然后超过他，他将被选入下一轮，或者类似的东西，好的，空向量，对，你明白的，所以这样做的唯一目的是启动这个，给他一个矢量，在他所有的电话中，人们一直在问静态矢量，我不想要静态矢量，因为只要打完一个电话。

我想让矢量消失，基本上，所以这就是为什么我不想要静态向量，好啦，现在这个帮手将是真正的工作，所以记住这里的模板，如果每个人都有选择，你知道我们只有一个选择，所以对于我的每个值，选择该值。

我将搜索或探索选择该值后会发生什么，当我回来的时候，我不会选择那个值，那么我怎么知道，如果有选择要做好，2。在这个问题上我们有什么疡？什么样的，每次调用递归函数要处理多少工作量，它选择一个模具的值。

所以如果我掷三个骰子，他们可能会有三个电话，他们每个人都会从六个骰子中选择一个的价值，第一个调用将尝试这里涉及一个的所有选项，它会尝试所有涉及2的选项，它会尝试所有涉及三的选项。

这第二个调用将尝试所有的选项，涉及一个在它的位置到两个，在它的三个点在它的点，第三次调用将尝试所有在这里有一个或在这里有两个的选项，三个在这里，所以每一个调用都在处理它的所有可能性。

好的，好的，所以如果要做出选择，你怎么知道，如果有什么选择要做好，这个骰子的数量是你需要选择正确值的东西的数量，就像如果骰子数为零，这将是一个基本情况，但也许我会回到那里做什么，否则。

对于我选择的每个可能的值，都有选择要做，我的选择是我在管理价值观，我可以选择的东西是数字1到6，对呀，我会试着选择那个号码，然后探索随之而来的事情，我如何表示我正在选择那个数字，把它放在向量里，是啊。

是啊，绝对如此选择点，添加值，我和现在让我们来探索所有可能跟随这个选择的事情，对呀，所以探索，搜索，这通常是递归部分，所以我叫掷骰子，帮工，我首先传递什么参数，骰子减去一，因为我在处理一个死亡。

所以剩下的电话少了一个死亡，他们需要处理的骰子，我将通过相同的选择向量，因为我们共享一个选定的向量，现在当我回到这里，我写了《不可选择》，我认为这个想法就像，我选择我的人的价值是1，然后我探索。

但现在我回来了，我想试试会发生什么，如果我的人有价值2，我不想既有价值一又有价值二，所以我想撤销这个，这样我就可以和我两个一起再做一次，我有两个，所以选择的方式正好相反，你以前的所作所为。

当你做选择的时候，所以这将被选择移除右，*心点，虽然remove需要索引，你可能会认为就在那里，但这意味着我从向量中去掉了i的值，但这不是remove的参数，它不需要一个值就可以删除。

它需要一个索引来删除什么索引是我的值，我想移除，它是向量中的最后一个值，因为电话越来越多，他们把东西放在矢量的末端，所以它会选择点大*减去一，但是等等，是这样吗，因为这些调用都是在向量的末尾添加元素。

所以我的元素还是会在最后，就在这里，你不觉得这些人，伙计们会追杀我的，那么为什么这是对的呢，你觉得怎么样，否，你是说我写错了代码吗？你是说我不是一个好的程序员，你认为这是对还是错，因为每一个电话。

啊是的，你有很好的递归，禅宗，你所说的完全正确，这个力很强，你说的是对的，你说其他电话都有相同的密码，所以他们在添加东西和探索东西，但当他们的电话从它所做的事情中回来时，他们要去掉他们加的骰子。

所以理论上每个电话都会自动清理，你明白吗，就像任何一个电话的净结果，当调用完全完成并返回时，它没有比以前放更多的骰子，所以每次我添加一个和删除一个，没有不平衡，没有那个就没有办法得到这个，反之亦然。

所以在这家伙做完之后，我知道矢量和之前一样，所以我现在把最后一个去掉是对的，如果你还不相信，我去打印，我们可以检查一下，但这是对的，是啊，是啊，继续吧，因为我们正在处理冒险中的步骤，每次，哎呦。

我们能用一个链表，嗯，好消息是非常正确的，矢量的远端是快速，前端是慢的部分，因为前端涉及到换挡，NN没有任何移动，如果我们把指数0加起来，我完全同意，也许矢量不如链表好，这是一个很好的观点，但这没关系。

我觉得可以，所以这很接近，但还有一件事我们还没写，是基本情况，如果我们得到零骰子，记住，基本情况意味着前面的调用已经完成了工作，现在没有工作可做了，当我们到达这里时，所有的值都已经被选中了。

那我该怎么做，是啊，是啊，只需打印出选定的矢量在一个漂亮的，是啊，是啊，把我们选的打印出来，把我们选的骰子打印出来，它应该用花括号打印它们，这正是，向量的默认打印如下所示，我只能看到被选中的人。

所有这些都是基本的情况，让我们，我们试试看，所以，哦函数f做，我有一个错别字，少了一个卷发，哦耶，是啊，是啊，我这里没有卷发，谢谢，编译，我对代码中其他地方的一些未使用的东西有一些警告，没关系，嗯。

运行它和什么，我得到了什么，一一一二，我想它起作用了，你看，看起来很不错，呵呵，只是如果再次，如果你，如果你想更明白一点，有点想知道发生了什么，我真的觉得你想做的事，我喜欢包括，这是可选的。

但是您可以包括这个递归，然后在这里，当你做每一个帮手呼叫，你可以说，看出去，助手空间骰子等于加骰子加选择等于，选择的加号加号和所有加号，注意电话，然后让我们看看，哦，天哪，大量输出，大量输出，没关系。

嗯，但让我们看看它，所以如果你用三个骰子打电话给帮手，没有什么是选择的，我们称之为二骰子，你选择了一个，然后我把它叫做一的冰，我在某个时候选择了另一个，我把它叫做零骰子，这导致了大量的输出。

然后这个人回到这个人身边，他现在用一个二而不是一个，所以这个人回到这里，这家伙继续他的一是二，所以从一到六的那种被他尝试过，那这家伙就完蛋了，所以他回到这里，所以这个人试着给第二个人二分。

所以我的意思是，你可以用这种格式观看呼叫树，以及向左缩进的行的输出，这些是输出线，这些是我们每次遇到的基本情况，现在，这在很大程度上仍然是一个详尽的搜索，但我必须做这一步，撤销我所做的选择。

所以我想谈谈这个，我们上次做的问题，就像打印二进制数字，打印十进制数字，我们不必在那里取消任何选择，我不知道你是否真的记得那个代码是什么样子的，你可能会想，比如为什么那个。

为什么我们不必在那个问题上做出选择，但就一会儿，我今天不打算多谈这个，但让我重新打开类似的排列什么的，所以记住我们写了置换然后置换，找了个变态帮手，我们通过了一根绳子什么的，上面是我们的实际代码。

在这里没有不选择的余地，你知道他们有点像，选择此字符，探索置换其余部分，在那之后，这里没有像“不可选择”这样的权利，为什么没有脱鞋，是呀，如果我们不打包，是啊，是啊，因为我们不是通过引用传递字符串。

我们在做一个新的弦，它是我们的前缀，加上另一个角色，如果这是对字符串的引用，我们在上面加等于字符，然后在这个帮助回忆之后，我们必须做-等于或不-等于，但是我们得把这个字符去掉，去撤销我们的选择。

所以真的，这是一个实现细节，我们通过引用传递向量，我们按值传递字符串，你可能会说很好，那么也许我们应该通过值传递向量，然后我们就不必做不可选择的权利，也许回到这里，从今天开始在我们的代码中。

也许我们应该删除这个符号，我不喜欢那样，因为我想这意味着我们要做很多很多，大量矢量拷贝，我们在另一个代码中复制的字符串，但是弦是非常*的东西，向量更大更笨重，我真的不喜欢，我们会做很多很多的递归调用。

每一个都会复制一个越来越大的矢量，所以无论如何，这是一个彻底搜索的问题，但它必须在每个步骤之后执行清理步骤或撤消步骤，有多大，我应该喝吗，做个点赞，你应该停止像没有一样传递它，哎呦，原来如此，是啊。

是啊，比如在什么时候复制字符串会变得太贵，嗯，我是说这有点武断，坦白说，我不知道一个字符串到底使用了多少字节的内存，与给定大*的向量的比较，但我知道字符串元素是一个接一个的字符，向量元素是每个4个字节。

所以至少有一个四x，那里发生了一些事情，矢量内部还有其他场，所以我不知道，门槛在什么之前，你会在乎这个的，我的意思是坦白说，如果我删除符号，可能没那么糟，但我是说总的来说，如果你要这么做，这些深度探索。

也许你在探索棋步，你想写人工智能解棋盘，那玩意儿会有数以百万计的电话，或者有这么多的动作在移动在移动，就像，如果每个递归调用都在复制向量，你只是沉沦了，你的算法可能非常非常慢，即使只有矢量。

每个矢量只有十个或十五个元素，只是太多了，所以我想这就是我们的工作方式，这是IT字符串的最佳实践，你知道的，如果我们玩棋盘，也许我们可以通过引用传递一个字符串，没有，因为琴弦是超长的。

但是因为我们有很多电话，我想这可能就是，嗯，好啦，反正，那是掷骰子，现在呢，我什么都没做，嗯，本期的，就像，有些路不好走，或者一些正确的事情，因为我想我在说那个，穷尽搜索和回溯是有区别的。

有时你会得到一个你不太喜欢的结果。

所以我们来谈谈这方面，如果我们修改这个呢，啊，这只是电话的照片，所以你不需要看到你们都很好，嗯，来吧，来吧，来我的节目，连动画都做不好，好啦，管他呢那我在哪，让我们做一个，我不仅想掷骰子。

但我想展示我滚动的两个数字，加到给定的总和，就像一套或三种染料的总和，加起来是七，你知道这种可能性吗，好啦，所以我认为做一个最*的改变并不难，把我们的掷骰子代码转换成，所以，我要做到这一点真正的快。

然后我想喜欢，在那之后谈谈代码有什么更好的地方，所以让我复制一下，我将删除此打印语句，但我这里有个标题叫骰子和，它是，所以我想我想做的是，我想写虚骰子和，帮助者，然后我想粘贴，是啊，是啊。

现在我要说的是int v的向量，然后我要叫戴斯帮手，骰子期望和逗号v，所以这种方法并没有什么作用，就像另一个，但现在我想把注意力集中在这里的帮手身上，所以我认为最重要的是我们不叫掷骰子助手。

我们叫戴斯帮手，我们必须通过想要的总和，还是那么好，现在最*的变化是什么，这个代码说它的名字是骰子和，但它根本不看总数，所以我认为最*的变化就像，我们并不总是想把这件事做好，其中一些现在是坏的。

它们加起来不对，好吧好吧，我提前想到了，我为今天的课做了一点准备，如果要得到向量的内容之和，这里有一个，这里有一个函数，我写了求和，它需要一个向量，它只是循环所有的ins，只是把它们加起来，它回到一些。

只是，我只是不想我的手指，我有很多腕管，我想把代码打出来，所以我只是为你写了代码，所以我想在这个帮手里，我只想说，如果所选向量中所有元素的和是所需和，我会刊登事实，否则，我不会的，所以这可能会奏效。

所以让我们去主楼一会儿，确保梅因现在就打电话，主要呼叫骰子卷，我要把它评论出来，如果选择行并单击控件，削减它不评论或评论他们，所以现在我在做骰子，三逗号七之和，所以让我们，我不知道那是什么。

让我们运行这个然后好，所以我想它起作用了，也许我搞错了，也许那个问题太容易了，事实上，我甚至没有请你帮忙，我只是一个人做的，我想它只是在那里让我感觉很好，好像我真的很聪明，嗯好吧，但我要说。

我们所做的并不是一个理想的解决方案，它的功能不正确，到目前为止，我们的解决方案有哪些不理想的地方，是呀，也许不是像一些，当你这么做的时候，就像递归的东西，你可以减去所选的，在战争结束时，准确的说是。

这是一个有趣的转折，我喜欢你的建议，所以你说，而不是在最后把所有的东西加起来，也许我可以在这里传递一个越来越*的金额，把它削减到零，你为什么喜欢那样，更好，否，你说的对，我喜欢你的主意。

我的意思是我认为关键是做这件事需要一分钟，这就像大O的n和我们要做到这一点，很多时候，每次我们做一个基本案例，我们要这么做，这不是很多复杂的计算与一些，它是N的大O，如果我们只是跟踪一个和。

不知何故或将这笔钱削减到零，也许那样能达到同样的目的，不必一遍又一遍地循环所有这些向量，所以我喜欢这样，让我们马上就做，你也有不同的建议吗，如果你现在的歌是二，比你想要的歌还大，没有理由迭代。

如果它太*了，然后就像，它是，它是加上潜在的，那我们就永远吃不饱，是啊，是啊，是呀，所以这两个都是，我不是，没有一个正确的答案，你们两个都在这里，嗯，这个代码在浪费时间，所以在它的一些叫声中。

就像你说的，有时我喜欢，如果我在滚动，如果我想掷四个骰子，我想得到一个正好是八的和，好啦，四个骰子，八和，如果我掷前两个，我选6，没有办法得到八的和，如果我已经有十二个了，对呀。

但是这段代码正在愉快地探索所有这些，然后选择不打印它发现的东西。

你明白吗，所以说，给大家看一下，我想我有一张照片，在这个例子中，我有三个骰子，我想试着看三个骰子加起来是五的和，所以好吧，如果我选六个作为第一个，你不能把一个负的卷对，所以我的意思是。

即使在那里做那棵树也没有意义，所有的电话，有一大堆电话会在那下面，完全是浪费时间，就像这里，如果我选一个，事实上，我应该把这些涂成更多的红色，因为如果我有两个骰子和一个1和一个4，我已经有五个了。

所以下一个染料必须至少是一个，对呀，所以其实这个也应该是红色的，我还没有把这棵树弄得足够红，如果有什么，你发现这是个问题了吗，我想你也指出了这种情况发生在事情的另一面，如果我想要四个骰子，加起来17个。

我掷两个一，那么即使剩下的两种染料是6，我不能一直加到七十，对呀，所以我不能，这就像，如果你在任何一个方向上都太远，那么您的代码就是在浪费时间，我们需要担心的是，就像有几个例子出现了一到五个。

一一五五一一二，比如这个例子中的1-1-5和5-1-1，我只是假设这些是不同的，把它们都打印出来也没关系，如果我在乎，那些是一样的，我可能会想要一些排序有序的收藏，或者是那些会出来的东西。

就像我们做了一个字谜的例子，字谜都是一样的，因为我们把信分类了，我可能想在这里做一些类似的模糊的事情，在那里我将与那些相等的，我不会再探索这些了，是啊，是啊，会有这种变化吗，我会担心的地方，2。

对于这个问题我宁愿不考虑它，但是但是是的，嗯反正，其中一些都是很好的观察。

你的第一个观察是一遍又一遍地计算总和是浪费的，你的第二个观察是不要探索，比如说树，有时我们称它们为调用树或决策树，数值是低还是高，才有可能得到正确的答案，那么我们怎样才能把这些事情做好呢？

我想先做你的总结，所以我想你说的是，如果我选择我为我的死，所以我记得我在努力把想要的15或什么的总数弄对，所以现在我的染料，我选三个，所以剩下的骰子，我可以告诉它。

我在寻找一个想要的12而不是15的总和，我可以把它拔出来，所以我认为有两种方法可以做到这一点，你可以把这个人减为零，或者你可以以某种方式保留另一个int，那是在计数，看看它是否达到所需的金额。

这些都一样好，每种方法都有优缺点，我想如果你不介意的话，我宁愿做我保留另一个int的那个，我数了一下，我马上告诉你为什么，我想这对事物的边界的另一个建议很有帮助，但是，如果我加上一些东西。

比如到目前为止，我的和，换句话说，就像这是当前所选向量中的东西的总和，所以从某种意义上说，这是完全多余的信息，因为我已经有了那个矢量，我可以在上面循环得到总和，但我为什么不把这笔钱单独存起来呢？

这样我就不用绕圈了，我不必把工作做对，所以说，换句话说，在这里当你第一次开始，到目前为止，你得到的总和为零，所以我会通过0，但现在在这里，每当我做递归调用时，我把什么作为到目前为止的和传递给下一个。

它将与这笔钱有关，对呀，不管之前的电话选择了什么，而现在，我选i，所以我应该做到目前为止的和，加上我对，加相等，嗯，加相等，将修改变量，我想我不想修改它，因为当循环绕着，我不希望它被添加。

所以我可以添加下一个，我每个人都绕着，我希望它是原值，加上下一个我所以所以我认为这是很好的现在，到目前为止我想要这个的目的是什么，这并不能优化代码，任何，你的意思是，我想现在在这里。

而不是说一些所有的选择，我可以说，如果到目前为止我的总和等于，好啦，所以那些是，这就像一个优化，就矢量上的循环而言，它加快了一点，那很好，好啦，所以我想我们做了第一个，我是说，我想我们应该运行它。

别让我弄坏了，但是哇，大乐趣，看起来我认为它仍然在打印正确的东西，好啦，所以我们现在做了第一名，我们现在做第二件事，嗯很快，我想做一个黑客来了解一些关于代码的东西，我想计算它当前进行了多少次递归调用。

所以就像在这里，我要做一个邪恶的全局变量，呼叫等于零，不不不不是这样的，千万别这么做，无论什么权利，嗯对，所以不要不要那样做，但我刚刚做到了，所以说，我想我可以做一个静态的，我什么都不知道。

但在这里我要叫骰子和，然后当我做完，我要打印它打的电话数，然后在计算电话数量方面，我要上去找这个帮手，我要说的是调用加基本情况递归情况，我不在乎，是个电话，好啦，所以我运行它，它打印了所有的东西。

上面写着二百五十九，好吧好吧，也许你想一分钟，为什么是二百五十九，不过，好吧，所以这很酷，二百五十九呼叫正确，怎么样，如果是四个骰子，四个骰子，我数到十一什么的，让我们把那个电话注释掉，我们往左掷骰子。

我们跑吧，它打了一千五百五十五个电话，稍微超过它的周围，六次，上一个电话的号码，太巧了好吧好吧，我把它放回三个骰子，只是为了让它的产量少一点，是啊，问题，为什么它不做，为什么不是6比3，嗯，嗯。

让我们看看6的三次方是多少。

蟒蛇六次，六乘六。

所以说，216，原来是这么多，如果真的是，我觉得，因为我们实际上要打第四个电话让基本案例打印，你明白我的意思吗，就像我们选择三个骰子，然后我们用骰子设置为零进行第四次呼叫，还有那个，是呀，五个也是。

所以会是，但是是的，就像验证过的，所以我的意思是，应该是这个，但我是说这个案子只是一个，它不像是分支出来的，当然，但我们触底了，每次我们完成一条树的探索路径，应该是一个很好的样子，我们可以遍历树。

向上数节点，如果你想，我确实认为每次我们增加一个死亡，我们在这里大约上升了六倍，但是你看，我是说，我觉得重要的是，我想数一下我们一次保存的电话数，我们做了这个优化，我们称之为第二个。

所以第二个优化是，不要探索那棵树，价值太高的地方，哎呦，你举起手来，你对此有何评论？是啊，是啊，对不起，我想球的数量将是66个，哦原来是，更像是。

呃，六到零，六到零，一加六，二加六，六加三，是呀，这样好多了，这实际上正是它的电话数量，是啊，是啊，所以我用错了数学，谢谢你数学比我好，在这里你应该得到更恰当的感谢，因为i在范围内，一千。

是啊，是啊，无论如何，去接一零三和一零九，然后你会比我更擅长组合数学，好啦，所以我不想探索那些决策树，如果你不可能得到正确的答案，所以这是我正在做的部分，选择一个数字，然后探索，然后把它放回去。

我想我们需要某种，如果这里的陈述是这样的，如果这条路好，我想探索，但如果这条路不好走，我不想，嗯，我怎么知道这条路是好是坏，我怎么知道这是否可能，也许我会给你一个提示，你能帮我计算一下。

我能创造的最大价值，也许在这里，计算最少最多，你知道的，最*和最大可能和的排序，就像，最低金额是多少，如果我选择I作为下一个死亡，是的，到目前为止，加上数字，到目前为止，这是我的总数，另外我是说。

我想我会选择I作为我的死亡对吧，另外，接下来的事情我至少能做些什么，就像在所有的骰子上掷一个，减去剩下的一个骰子，对呀，如果我为自己选I，那你就跟着我吧，好啦，然后最大值是，我选i。

然后所有剩下的骰子都是高赌徒，他们都是六个对，好啦，所以现在我有了这些界限，我认为if语句更容易写，对呀，如果什么，那我应该这么做，如果需要一些负最*值，还是*于或大于max，是啊，是啊。

我想我想那很接近，基本上只要最*值和最大值，如果所需和在最*值和最大值之间，我想当我们想把这件事做好的时候，所以如果最*值*于或等于和，并且所需和*于或等于max，然后我想选择和探索，然后不选择右。

好啦，让我们试试看，还记得我们是怎么接到两个五九个电话的吗，然后我们接到了1500个电话，或者随便什么吧，让我们这样运行吧，因为一件事，我的输出正确吗，看起来我有，我有3个6号电话。

所以我认为这是打印所有与以前相同的输出行，三六，如果我回到四个骰子，电话会少得多，等等，不是那个，如果我把这个注释掉，把那个注释掉，记得我当时一千五百，我觉得，差不多现在是二百四十五。

所以它肯定消除了相当多的那些电话，所以在去掉那些我们不需要计算的和，删除这些调用，我们不需要制作这是一个更好的代码版本，它消除了一些开销和缓慢之类的东西，人们把太多的递归联系在一起。

所以关于家庭作业的问题，有时我会对你说，您的代码需要喜欢，通过避免坏的分支来修剪决策树，这就是我所说的，如果你知道你所到的地方，当你之前的电话无法得到回应时，您应该立即退出，而不进行更多的递归调用。

在那之后，你明白你有最后一个，就像田径一样，你不需要喜欢棕色，然后你不必做正确的事，所以我是说写这个代码的另一种方式，我想我会留给你自己玩，不是把总数传递到目前为止，把你选择的眼睛从这里拉出来缩*这个。

然后你只有三个参数，对我来说，在某些方面稍微改变了这个逻辑，在我的脑海里，这个版本有道理，但我认为我们用鳟鱼的版本完全没问题，你完全可以写问题来解决它，是啊，是啊，好啦，是的，是的。

因为我们在清除载体的时候，不管怎样，我们已经完成了这个功能，用静态变量做一个向量不是更有效吗，却没有一个，清理，所以最后就看你的了，好吧，又来了，就像我认为我认为你们，嗯，也许像静态变量，比我做得更多。

这就是静态变量的特点，就是，它将在递归完成后停留在那里，就像在电话完全打完之后，不管里面有什么东西，它都会留下来，现在你又说要把里面的东西拿出来，所以到最后会是空的，所以，也许这是好的，这很好。

我是说你可以这么做，我认为这些算法有不同的版本，你并不总是百分之百地，完美地清理矢量，如果你走进死胡同，你只是出于某种原因立即退出了整件事，现在矢量不是空的，所以我发现，还有一件事要记住。

静态变量在很多语言中都不存在，所以我不想教你太多的技巧，只有在C++中才能工作，你说得很对，在这个问题中，在你返回之前，所有的向量元素都被清理干净，所以静态变量可以工作，因为你每次都是空的。

我觉得一般情况下，您通常创建一个局部变量并传递它，你在这里通常都是这么做的，反正，是啊，是啊，这些都是合理的变化。

我想给你看另一个问题，我只想再完成一件事，趁我们有时间，所以废话，废话废话，我说过要修剪这棵树，好啦，伟大的嗯，只是副业，我不打算编码这个，但如果你真的想解决他的问题，就像我想打印一一五。

但不是一、五、一，也不是五、一，我怎么让它不那样做，你可以想出很多不同的方法，这是个反问句，我不会打电话问你答案的，但是有很多不同的方法可以做到这一点，实际上，你可以让它工作。

只需对代码进行非常非常*的更改，所以如果你在想象什么，喜欢集合和向量，喜欢计算东西，或者任何你可以用更少的工作来做的事情，所以这是值得考虑的事情，但我想再做一个问题，也就是所谓的子列表，我想叫它子集。

但从技术上讲，这不是一个数学集，一组的数据结构，我想做的是，我把弦的矢量传给你，比如名字，或者任何我想打印的权力集的所有可能的子集，名单上的人，所以就像其中一个子集是整件事。

其中一个子集只有基因和鲍勃在里面，或者只是鲍勃或者马特什么的，还有一个子集是这些人中没有一个，零人对，我不在乎，它们按什么顺序印刷，我只想把它们都打印出来，那么我们该怎么做呢，我们怎么做。

感觉就像排列组合问题，我们环顾四周，选择一个名字，探索什么的，我选择这个问题的原因之一是，如果你沿着这条路走下去，我想你会发现你最终得到了一些不太正确的东西，嗯，所以我的意思是图片，代码可能是什么样子。

你会说，好啦，我想做所有的子集，所以我要在弦上循环，我会选择和探索其他的，或者类似的东西对吧，大多数人的代码都是这样开始的。

让我去找我可爱的造物主，我要把这个主骰子注释掉，然后我这里有一个叫做子列表的文件，我现在就在这里工作，所以我成名了，一组名字，我打电话给苏布斯，我很确定这只是一个空的，如何做好，很多人认为，好啦，好吧。

我需要，也许我有帮手，我不知道，但我需要做一些循环，I=0*于v点大*，我从向量中选择元素i，所以我说字符串s等于v i，然后我会做v点移除i或者你知道我的意思，就像我会选择那个。

这是大多数人在这里开始的，我要你相信我，这通常不是你想要的方式，今天我想教你们的重要一课，在本例中，问题是这些回溯和搜索问题，不要总是把所有的事情都循环起来，我认为我表现出的大部分问题。

你把所有的东西都翻了一遍，挑了一个东西。

这个不是那个方向，所以让我试着向你展示，为什么你这么做，当我刚刚开始写作的时候，你最终会得到一些看起来像这样的东西，为了你喜欢的决策树，你会说很好，这些都是可用的人，我还没有选择任何人。

所以也许我会试着选择简，然后我会探索我还能选择谁或任何权利，然后在我探索完之后，也许我会回来说不，我再也不选简了，我要选鲍勃，我会看看我能用它做些什么，你知道对，但你会发现你最终会做这样的事情。

你有鲍勃·简还是有简，你得到了同样的两个人，那些彼此没有区别，在这个问题上，所以我真的不想把这个和那个分开，我不想探索这两种方式，事实上，我在这里做的是，我在做向量的排列。

我现在只用一个向量来解决置换字符串问题，这不是问题所在，这不是我要解决的问题，所以我想我有点过于模式匹配了，好啦，那么有什么缺陷呢？有什么问题，我到底需要做什么，我想这又回到了这个概念。

就像每一个电话都做出了一个选择，我们误会了，对于这个问题，这些选择是什么，选择不是，结果矢量谁先走，谁应该第二，谁应该是第三名，这就是排列，这应该是子集，就像，如果我打印子集，如果我要考虑。

你可能会做出什么选择，鲍勃，这与产量有关，你正在打印，是啊，是啊，其中包括，鲍勃是否应该包括在集合中，没关系，如果他是第一或第三，或者别的什么，关键是他在不在，这才是真正的选择，不是命令，但是包容。

排除，所以说，而不是一棵树说，谁先走？谁第二，这棵树应该看起来更像，让我们看看简，简在不在，这是两种可能，如果我决定让她去，让我们看看鲍勃应该在里面还是不在，对于每一个选择，我们都做同样的事情，这里是。

我没有留下简，我会试着留住鲍勃，下一个我尽量不留鲍勃，我尽量不去，我会尽量不保持那种类似的想法，不同决策树，你看它一分为二，不是每一步都在。

所以真的就，什么电话，你的电话做什么，我觉得你还是想帮她取消，你说向量v，但你也可能我们称之为次级帮手，但你也传递一个字符串向量，你选择了那样的东西，像这样，然后这里的这个人只是说选择的字符串的向量。

叫做子列表，选择帮助者V，好啦，现在好了，这家伙没有把所有的元素都循环起来，为什么我们不直接说他会处理第一个，或者他要对付他们中的一个，他将决定那个人是被保留还是被排除在外。

所以像弦我这样的东西等于V0，V点，移除零，所以我选择了这个人，我要去，我来处理这个人，所以现在我应该探索或搜索，所以这就像我选择，我猜，但实际上我必须选择是保留他们还是排除他们，那么我该如何选择。

这里有两个分店，有一个说是的，包括他们，还有一个是不，排除他们，对呀，那么包括什么呢？那我喜欢怎么做，是呀，我觉得我们还应该写上，向量中要包含或不包含的元素，然后在移除元素之前。

我们在讲座剩下的时间里做我认为很好的功能，所以你说我们需要弄清楚，嗯，这个调用要处理哪个元素，所以我们可以通过索引或类似的东西，我想另一种方法就像，让我们都同意每个人都在某个索引处选择元素，挑最后一个。

拿第一个，随便啦，很简单，这样您就不必显式地传递它，我想我们可以说每个调用进程都是第一个元素，然后把它去掉，如果要在所选向量中包含该元素，你可以把它加到所选的向量上，你可以添加我的选择。

探索是一个递归调用权，你用v说subliss助手，现在选择更*，选择现在更大了，现在可能更大，当这个回来的时候，我想试试这个的一个版本，我不包括那个人，我怎么没把他们包括好，我不想让他们在选定的向量中。

所以我会再做一次选择点移除，它是所选向量的最后一个元素，所以我会选择网点大*，减一，我想和他们一起做另一棵树，不在里面，所以我想再做一次，像这样，我本可以按相反的顺序做的。

但就像我在做一个有他们的探索和一个没有他们的探索，这里没有基本情况，基本情况是什么，我没时间了，所以它很快，基本情况是什么，V大*为零，当我看到我打印了我选择正确的东西时，我该怎么办。

所以如果点实际上是空的方法，如果这些空的看到选择的Endel，否则我们会做所有其他的事情，所以让我来试试，希望我们能成功，然后我们回家，我经营，WAP，WAP，那不太对，那不太对，你从来没有选择。

我从不犹豫，这意味着把它们放回V中，我在这里需要做什么，所以我们应该从生活开始，我告诉你吧，我已经检查过了，所以我就到此为止，星期五的第一件事是，我们会修好的，好啦，我不想让你迟到。

【编程抽象方法 cs106x 2017】斯坦福—中英字幕 - P12：Lecture 12 - Backtracking 2 - 加加zero - BV1By411h75g

好啦，我们何不现在就开始呢？呃，我想我想这个麦克风完全正确，这是这个麦克风，开了吗，有用吗，好啦，只有我是对的，哦我的天啊，哦好吧，我会试着把我的声音，尽我所能，嗨很高兴见到你们，今天是星期五，第四周。

我们今天仍然在讨论递归和回溯，我们在哪里，我们这个星期五就在这里，只是更多的回溯问题，今天的讲座结束后，你可以去看看作业四，它现在就在网站上，这是一个集中在回溯上的问题集合，只是想看看我们要去哪里。

看看下周的日历就知道了，我们将学习一种叫做链表的东西，它涉及到另一个叫做指针的主题，那是窃丨听丨器吗，我在课堂上有窃丨听丨器的第一个案例，是啊，是啊，下周指针和链表，然后我们要期中考试，下一个是星期四晚上。

确保你的日历上有这个，一定要检查你的时间表和日历，我很快就会发布一些练习考试的问题，也许这个周末，也许下周初你可以看看，你可以对考试有更多的了解，但我给你们的建议是，从今天开始不到一周。

但接下来的星期一，所以你有更多的时间，我的建议是假装它应该在这里，尽快把它做完，因为那样你就有更多的时间专注于考试，我觉得你花在学习上的时间越多，你通过考试的可能性就越大，所以我会给你一大堆练习题。

这将与真正的测试问题非常相似，如果你只是去做一堆，或者看着一堆，你很有可能通过真正的考试，就像那些练习题一样，好啦，所以我以后会更多地谈论测试，但这是我对你今后的总体建议，上次我们讲完课。

我们在研究一个叫做子列表的问题，我们应该打印一个向量的所有子集，我们差一点就完成了，但我们没有，我就停了下来，我让我们带着程序中的一个bug走了，所以我想重温，我想修复bug，稍等一下。

如果我运行这个文件，它向我显示了这个输出，也就是，输出不对，少了很多线条，所以，我的意思是看，我可以只是，我们只是谈论修复是什么或bug是什么或其他什么，但我也想谈谈一个过程。

因为我想你们中的很多人会去写，递归代码或回溯代码，一开始可能是错的，你是做什么的，你怎么把它修好，所以你必须有一个过程，我觉得你能做的第一件事，你可以去看看代码，看看你是否明显地看到了bug。

但我想这取决于你的鹰眼，啊哈，就在那里，你知道的，很多时候这很有效，如果bug的性质是，你的代码中有一个错误，你必须改变错误，但更难注意到，哦，我错过了什么，我应该让你知道，很难注意到一件事的缺乏。

所以我不认为仅仅盯着代码，直到你看到bug总是有效的，所以就寻找bug的具体建议而言，我一直在做的事情一遍又一遍，在递归的开始，这里，我插入一些打印声明，我打印的地方，我把参数打印出来。

我会打印v的值是多少，选择的价值是什么，我想如果你看看那一连串的电话，可能前面有个凹痕，我想你开始看到等待，那不是一组电话，我以为，为什么会是，所以这开始引导你进入一个过程，雾现在到底在哪里。

在这种特殊情况下，我来提醒你我们在做什么，我们讨论了回溯问题如何有一个决策树，你选择走一条路而不是另一条路，我们为这个子集问题做出的决定，我们是关于给定元素的，我想把它包括在选择的内容中吗。

还是我想把它排除在选择之外，所以我们有两个案子，让我们把它们添加到选定的，然后重复或者让我们把它们从选择中移除，然后在没有它们的情况下再次复发，所以是两个，每个都有两个子调用，好吧，这就是我们的结局。

现在看起来很不错，你知道少了什么吗，我是说，这里有什么问题，事实上，我想你可能会看到，如果你记得回到模板的类型，如何描述回溯问题，模板的哪一部分缺失了，是的，联合国选择，所以你应该选择，探索未选择权。

所以看看这个代码，我选择处理零号元素，然后我探索了我可以用零元素做的两件事，我可以把他包括在内，或者我可以把他排除在外，然后我就完蛋了，我选择和探索，哎呀，我没有很好地回溯，我是说递归调用又回来了。

但我没有撤销，我认为一个很好的启发式是，当你做回溯时，任何变化，你的电话，你应该检查一下，确保在调用退出时撤消这些更改，所以这是一个很好的经验法则，这里我把矢量中的元素零取了出来，我再也没把它放回去。

所以我需要做的是在最后这里，我需要说和选择，我得说，索引零处的V点插入，值优先，我一开始从那里提取的价值，好吧，现在有了这个变化，我要得到所有我想要得到的子集，所以关于那个问题的任何问题，真的。

我只是想让你原谅我最后没有解决它，星期三的课，只要我们冷静，我会继续前进，我只是不想你看不起我，好啦，所以总的来说我们今天会做更多的题。

更多问题示例，我想今天的问题会对你的一些家庭作业问题有特别的帮助。

所以让我们来谈谈一个叫做八皇后问题的特殊问题，或者更广泛地说，董事会的N皇后问题，n乘n的棋盘，默认是八乘八，这就是真正的棋盘，这个想法是，你能在黑板上放八个皇后还是在黑板上放皇后。

在没有蜂后能够互相攻击的情况下，所以如果你不下棋，我是说女王可以向八个方向移动--上、下、左、右和对角线，我不知道为什么它变白了，但是蚁后可以以45度的增量向这些方向移动，对呀，所以像这样的配置。

我相信这是一个有效的解决方案，但如果女王在这里，那就行不通了，因为这两个人可以互相攻击，对呀，那么我如何找到这样的配置，如果我给你一些网格或棋盘什么的，我要求你把所有的皇后都放在上面。

这看起来确实是一个问题，你会想去探索所有可能的解决方案，这感觉像是一个详尽的搜索问题，但你可以想象，如果你试着把一些女王放在一些地方，那将是一个糟糕的位置，因为它们可以互相攻击。

所以也许我们会想走出这些路，所以这是一个回溯问题，我们不会打印每一个配置，我们要把好的配置打印出来，好啦，嗯，有任何回溯问题，如果我们要制定它，就像，尝试所有的选择，你知道的，选择。

探索并选择什么是选择，每个电话在这里要做的工作单位是什么，你觉得怎么样，放一个女王，这似乎是一个相当具体的行动，对呀，所以会有像，一次最多总共可能有八个递归调用，好啦。

所以如果我的选择是现在把一个女王放在哪里，接下来我们要做的是思考这个选择的所有选项，我想有时候我们谈论决定和选择，我的决定是我要把一个女王，但选择是，我把女王放在哪里，黑板上有八乘八的正方形。

所以我想我能做的是对每一个方块，我可以选择在那里放一个女王，然后我可以探索，然后我可以选择正确。

这就是我所描述的每个平方的朴素算法，在那里放一个皇后，把其余的皇后，那可能是递归，对呀，然后哎呀，如果这让我不高兴，那我就把王后赶下台，所以有时我们谈论大O或运行时或其他什么，就像那要多久。

它要尝试多少不同的解决方案，嗯，我是说这个女王有64个方块，然后这些方块中的每一个我都要开始一个呼叫树，下一个有63个，所以它只是凌乱的权利，就像我的意思，我不想再因为滥用组合学而惹上麻烦。

但就像我想让你相信会有很多不同的道路，我们必须在这里检查，对呀，我不会花时间这样写代码，并运行它，因为我们甚至不会看到代码在合理的时间内完成，所以我不希望这是我们的算法，我觉得我们应该想个更聪明的办法。

也许我们需要做的是我们需要备份并看看它，所以我发布了一个解决方案，与其说我想不出解决办法，不如说我想不出解决办法，这里有一个，但这里有一个解决办法，也许通过观察这个解决方案的一些品质。

也许我们可以推断出一些优化，我们可以对我们的算法进行优化，这块板有什么特性吗，但你认为我们可以利用我们的密码，是呀，大人，所以我们每行只能放一个皇后，所以我们可以，你知道的，当然。

这个解决方案有一个品质，我很肯定，每一个有效的解决方案都有一个特点，就是每一行都有一个皇后，不可能有两个，因为他们可以互相攻击，每列也只有一个皇后，所以在限制解空间方面，当我们试图把一个女王。

我们可以减少一些关于其他问题的事情，但你能说的，是啊，是啊，黑色方块上有四个皇后，黑色方块上有四个皇后，那很有趣，有同样数量的皇后在黑色，是白色的，是啊，是啊，我觉得，您可以对此进行很多*的优化。

或者你可以对这些解决方案做很多很好的观察，我想展示它有多强大，只是为了做一个优化，比如，让我们做一个简单的版本的第一个建议，每列都有一个皇后，就每个递归调用所做的功而言。

假设一号电话将决定把这个放在哪里，但这会把她放在这个专栏的某个地方，二号电话会处理这个女王，这会把她放在这个专栏的某个地方，所以现在不是每个电话都有六十四或六十三或六十二个选项，每次呼叫最多有八个选项。

那至少会减少很多东西。

在我们的组合呼叫树爆炸中，所以不用这个算法。

也许更像这样的，其中每个调用处理一列，你可以用一排做同样的事情，你还可以做得更多，同时考虑行和列，把它排除在外，你知道你可以做的更多，但现在解决方案空间*了很多，更像是八个，你知道每打一个电话比六十四。

好啦，所以如果我们真的要编码这个，我会给你提供一些帮助代码，帮助解决这里一些不太递归的部分，所以我有课，我带来了所谓的董事会，就像一个网格，只是行和列，你可以构造一个给定大*的板，你知道如果你过了8。

做一个八乘八的木板，你可以问是否可以在给定的位置放一个女王，所以它会检查所有现存的蚁后，看看它们是否能互相攻击，你也可以在那里放一个皇后，或者拿走，如果我们或你可以打印黑板，所以如果我们有。

让我们试着弄清楚如何，如何解决，我这里有可爱的造物主，我要重新命名我的主，我要打开另一个文件，称为八皇后，在这里就像，让我这样，我们要写的是索尔皇后，以参考板为参数，他们只是做一个八号的木板什么的。

我们说解决皇后，所以现在我们需要写，解决皇后，帮我开始，我们在做递归，我们在做回溯，我们将不得不考虑基本情况，我们得考虑选择，探索，Unche，考虑在调用之间传递参数，在这里。

有什么事情是你首先要做的吗，我是说，我们只是大致描述了算法应该是什么，所以说，创建一个helper方法，并在父级上使用int description列，好的很好，让我们做一个帮手的方法。

我想在很多回溯问题中，我们需要一个帮手。

因为我们讨论了每个调用如何处理一列，我们不知道该处理哪一列，除非我们被告知，所以我们需要，是每个电话都能接收到的信息，调用如何接收信息是通过参数，所以是的，让我们写一个助手说。

在这一栏中放置一个皇后，好啦，所以让我们做虚空，解决获取相同板并将其放入列中的帮助器，或者叫伟大，所以我认为这个想法会像，如果您调用解决助手，你要从第一列开始调用它。

然后这个调用将在第2列调用它，这个调用将在第三列调用它，以此类推，我们从左到右，我认为考虑一下假设是很重要的，就像如果我在做第五栏，我想我可以合理地假设，是因为前四个电话已经把他们的皇后。

他们在合法的地方这样做了，所以我不是在处理一些无效的状态，当我必须做出正确的决定，在我之前所有的人都做出了合法的选择，所以我想我要说。

你知道的，前提是，你知道的，列零到调用，减去一个合法地在里面放了皇后，或者类似的东西，好啦，所以这是一个好的开始。

我们说过，每次调用都要遍历，好好想想怎么把女王摆正。

那么我该怎么做呢，没有人在前面叫过你，到站了，所以如果有空位，董事会有办法，我们可以说如果放一些东西安全，但是板点是安全的，我们要传递一行和一列，你想让我过哪排，同一行，行和呼叫号码，一样就像。

如果我加入。

如果我不叫你，想让我试试四个，“那么你想让我把什么作为一排来传递呢？”，但是你应该循环所有的行，好啦，试试看吧，是啊，是啊，没错，这是一种回溯，我不知道哪排是正确的排吗。

这就是为什么我们要竭尽全力地尝试每一排，但只对我负责的当前专栏负责。

我的电话是对的，好啦，那么现在每一行呢，事实上，我想看看真正的快，我很确定这块板用的是一个数字，我可能错了，不过，让我再确认一下，还是零基，我换了吗，以前是一个基地，然后我总是在课堂上做错，是啊，是啊。

我来确认一下，是啊，是啊，好啦，它是零基的，好啦，酷所以所以让我们做，行等于，零行*于板，点大*，行加加，我可以写不到八点，但就像，我想我们希望它能适用于其他板材尺寸和其他东西，对呀，所以对于每一行。

你说的是，让我们看看在这里放一个女王可以吗，所以说，如果在这排和我的纵队放一个女王安全的话，不选择的权利，所以选择就像让我们在这里放一个女王，所以板点的东西叫做放置后在行调用探索是递归的部分。

解决帮助器传递相同的板和什么调用移动过列到下一个，然后不选择就像拿走那个后右板点移除行调用，是啊，是啊，试试看，啊，你知道我没有做什么，嗯在这里，这东西只需要叫帮手就行了，所以我们只需要说解决助手。

这块板，我们从第0列开始，我的意思是，你知道的，你可能会说，啊，我能在这里加一个额外的参数吗，或者别的什么，那可能没问题，我只是那是一个C加的东西，如果是Java，你得把它写成帮助什么的，所以是的。

然后在这里，我认为缅因州需要更名为，他们称之为主皇后，所以好吧，哇哦，哎呀哎呀，呃，啊，上面写着非法索引第0行第8栏，所以柱子向上穿过七个，哼，那么这是怎么发生的呢？嗯是的，我们没有基本情况，哎呦。

没有基本情况，对呀，哎呀哎呀，是呀，我的意思是，我就知道，但你很清楚，基本情况是什么，如果调用等于，或者至少和木板一样大，那是基本情况，否则还有更多的工作要做，我现在会再做那种事。

还记得我之前说过什么是基本情况吗，当一个回溯问题对，基本情况不像，你让我计算1的阶乘，这很容易，更像是其他的电话都是在我之前打的，他们已经做了所有的工作，所以我不需要做太多。

我只需要用他们做的所有工作做点什么，如果我到了这个地步，如果我在29号线，我知道什么是真的，如果我到了这里，我找到了解决办法，我怎么知道它是有效的，我没有把他们放在不好的地方，说是，去吧。

你一直到最后一栏，所以这意味着你一定是一个地方，八柱，所以这意味着有第九个递归调用比所有调用都大，是啊，是啊，是啊，是啊，我的意思是，我认为一个想法是这样的先决条件，如果我调用一个8的参数值。

也就是第九纵队，我有一个先决条件，即所有先前的列都有效，放置，女王在里面，这意味着所有八列都有有效的位置，所以就像我以我的先决条件，假设我的代码是正确的，如果我到29号线，我找到了一个解决办法。

所以让我们只做，让我们打印它，看看如何板和所有并运行它，我发现了什么，哇太酷了，所以看看它做了什么，它吐了出来，这是一个解决方案，这也是一个解决方案，而且它只是打印出所有不同的解决方案，酷嗯。

我们可以坐在这里，通过画线之类的东西来验证它们，但是，否则我们不能那样做，呵呵，这些看起来不错，这些看起来像它的工作，所以我的意思是，我想这就是它的内脏，我想我们基本上解决了这里的一般问题，是啊，是啊。

假设我们只想要一个板输出，我们如何取消所有，是啊，是啊，你的问题可能，我可以展示一个解决方案，然后停下来，那正是我接下来想做的，原来你是，我想谈的事情你说对了，但是嗯，所以做那件事有好的方法和坏的方法。

对呀，就像一种方式就像嗯，退出，有一个，有一个，有一个退出函数，它只是退出您的程序，停止程序，所以说，我不喜欢那个解决办法，它是它是一个黑客，我不知道，这不仅仅是因为像一些风格指南说的不要说退出。

不仅如此，因为我可能想打印一个解决方案，然后让我的程序做更多的事情，我的程序可能不想很好地关闭自己，好啦，嗯，也许不是退出，我应该说回归，或许它能逃出去，离开这里，或许那样就能解决问题不，你不相信我。

哎呀哎呀，没修好，为什么那不能解决问题呢？单曲，呃打电话，是呀，它无论如何都打算做，是呀，从声明中，所以你什么都没做，所以我想，每当你看到回报，你总是想问，我回到哪里，我怎么，我是怎么到这里的。

我在哪里，我的生活在做什么，嗯，这就像电话，是啊，是啊，这是第八个电话，也可能是第N个电话，我想嗯，如果我说回来，它将返回到先前的呼叫，如果有八九个人堆在一起，我从这里回来，只是要回到那个。

我真的想说回到缅因州的路上，不管是谁，没有真正的命令，没有停止递归的语法，现在呢，我想下车，事情不是这样的，但我的意思是我们可以，我们可以让它做到这一点，我只是在解释。

没有一个神奇的关键字可以做到这一点，我们需要做的，取而代之的是，我们需要考虑去，没有安静，嗯那是那是黑魔法，我们这里不这么做，不不不，但如果我们想找到解决办法，这实际上是回溯算法中非常常见的事情。

有时不是有时你想像我刚才做的那样打印所有的解决方案，但有时你想要一个单一的解决方案，所以一个诀窍是我需要说，好啦，此时此刻，它是有价值的，即使回归不是很正确，这是代码中我知道我有解决方案的时刻。

似乎我应该利用那一刻来告诉我的递归，停止做它正在做的事情，换句话说，我接到了八九个电话，上面的人需要给，他下面的人不会再出现了，函数调用如何向调用它们的地方提供信息，我怎么会，我会得到什么好的回报。

我可以返回一些数字来指示你是否应该继续，我是说，但好像有点啊，是或否，你应该继续吗，还是不应该继续，通常你应该，但如果你找到了解决办法，你不应该，如果是或不是，真假，它是布尔右。

所以让我们把它变成一个双函数，让我们说说它的作用，这里，是吗，你知道的，如果找不到解决办法，回返，假的，所以如果我在这里找到解决办法，我会回归真实，现在我们再说一遍，单独不喜欢展开所有这些电话。

但如果打电话给我的人寻找真正的价值，他们会做出正确的反应，那么我还需要改变什么呢，我的意思是，只是我做了不会修复它像，我希望你能理解，哦其实，这是个错误，因为我不总是回来，就像，如果你说你要还一头公牛。

你总是要回公牛，就像这里的代码路径，就像如果我尝试所有这些不同的事情，我找不到任何解决办法，也许我需要返回假的，或者类似的东西，我没有找到答案，所以我想如果我加上它编译，但它仍然打印出所有的解决方案。

你知道我需要再改变一点，有一天我还需要做什么，我还没有调用是和变量等于，所以在这里你是对的，当我打电话给解决助手时，所以再一次，记住谁在叫谁谁在回第8个呼叫者的地方，或者我猜这是第9个电话。

做这件事的人，哪里是真的，回去吧，返回到上一个调用，在这里的代码是什么，上一个电话打到这里，他们在等我，就像之前的电话一样，我就在这里，我在这里真正地回到他们身边，所以你说的很好，你说过，让我们捕捉。

电话正返回给我们，让我们说，公牛，这个值告诉我下一个人是否找到了解决方案，现在我用这个值还能做什么，你想解决这个问题吗，还有，我会用这个布尔值做什么，返回结果而不是错误的权利，所以我想这是对的。

我想我要稍微调整一下，因为嗯，假设我们要探索八种可能性，右边八排，在第三排，我发现我得到了一个真正的解决方案，我不需要做其他五个，对呀，我不想做其他五个，所以我的意思是，如果我把返回结果写在这里。

结果是找到了解决办法，但我认为它仍然会探索其他解决方案，我想避免这种情况，所以你能给出一个解决这个问题的方法吗，所以之后它可能会扩大它的结果，所以如果结果是真的，返回结果立即停止，是啊，是啊，那太好了。

我告诉你学生们最常见的错误是，他们会说好的，如果结果是真的，在这里返回true，那很好，但他们会说，否则现在这里返回为假，当然这是不正确的，这种描述方式有什么不对，不是很优雅，但它的功能有什么问题。

然后它就会停止第一个正确的，就像有多达八件事我可能需要尝试，这就像我尝试八个中的第一个，如果失败了，其他七个我都不试，这是不对的，我需要继续尝试，直到我找到一个有效的，所以只有当我看到一个真实的。

我应该早点停下来吗，如果我看到一个假的，我不应该还任何东西，我应该让循环继续做它的事情，好啦，所以我认为一些微妙之处，我可能会对这个代码进行一些详细的讨论，但我认为这些微妙之处很重要。

因为我只想早点停下来，如果我找到答案，如果结果是真的，那就别说了，如果我完成了所有的8个而我从来没有这样做，这意味着我的八个分支都不成功，这意味着我应该返回假，所以我认为这个版本的程序打印了一个板。

如果你想要一个变体让你有点挠头，我可以给你一个int数吗？要打印多少个解决方案，什么，如果我想打印我找到的前三个解决方案，然后停下来，你会怎么做，好好想想，你无论如何都可以考虑这种技术的变化。

但是这种打印一个解决方案而不是打印所有解决方案的想法，你经常有这种布尔模式，如果我找到了答案，停止，关于八个皇后或皇后的问题，是啊，是啊，是啊，是啊，所以我在想，如果我们找到一个，那我们就不，啊。

如果你找到了解决办法，你不能把皇后赶下台，是啊，是啊，那倒是真的，我想我没意见，因为我要离开董事会了，就像解决了的状态，所以我实际上能做的是，我甚至不能打印黑板，就像，如果我把它拿走，递归不会打印它。

但它使董事会进入了一个解决的状态，现在在缅因州，我可以说解决皇后，然后我可以说打印板与否，我想我打印的板子里应该有解决方案，所以现在它离开了那条路，也许我想那样做，我不知道，你当然可以争辩说。

也许我想在这里打印，然后我想把这里所有的皇后都换掉，当我出去把板子放回空状态时，你可以这么做，那很好，但实际情况是，现在就像，我们走到最后，被回溯，尝试其他选择，但如果我们返回真。

我们从来没有做好这件事，我不知道我是否正确地理解了你的问题，我是说基本上如果我们发现这种探索有效，我们不会放弃任何一个，因为我们喜欢我们的发现，我们想把它留在那里，但如果我们不喜欢我们的发现。

我们立即撤销它，然后尝试其他方法，所以我认为这个解决方案，如果它找到了解决办法，我们把皇后留在那里，如果我们找不到解决办法，所有的电话都会撤销他们的工作，当我们最后拿着一块空木板离开时。

如果我们找不到解决办法，所以如果你不想，您必须修改代码来解决这个问题，比如，如果你想撤销皇后，即使你找到了解决办法，你可以在这里放一条线，也就是说，删除点名，或者，我想你可以把这个剪下来。

贴在四行一和四行二之间，或者类似的东西，那一定很有趣，也是，当然可以，这两个都不是对的或错的，这取决于问题规范说了什么，是一个很好的数学方法，哦，像数学一样，我们需要打多少电话。

我是说你可以在每个电话上做组合，这是八叉子吗，你可以开始计算乘法了，但我想事情就像逃避电话，喜欢好，这里不安全，从树上剪掉很多电话，你可以把它移除，如果声明实际上，但是你的代码会探索所有这些愚蠢的调用。

它不需要探索的树木，所以我认为优化方面真的很重要，如果你愿意，我可以在这里放一个末端，数数电话，我想我不打算做这件事，如果你不介意的话，但我想以后编辑这个文件会很有趣，创建一个调用计数的全局丑陋变量。

运行它，尝试打开和关闭各种优化，看着那些电话的来来回回，我想向你们展示的是，有一种方法叫设置延迟，每次你把女王，会停顿一秒钟，它会打印电路板，这样你就可以观察算法，我觉得看着很有趣，这是我们的代码。

它在做完全相同的计算，只不过每次我们把女王，板在内部打印自己，这就是我们看到这个的原因，我觉得真正有趣的是，在更左边的地方，他们移动的频率较低，就像你一直在摆弄那些，在上，权利，更多在这里。

如果你仔细想想，因为我们找到了，所以这是一个解决方案，反正，你明白我在说什么吗，就像更左边的，你呆的时间越长，因为你必须在你之后探索所有这些事情，在你回来移动到下一个相对于更远的右边之前。

没有那么多东西跟着你，所以在你找到解决方案之前，你有一个更快的探索，还是放弃回去，是啊，是啊。

哎呦，为什么不是，滑梯上的那个，这里的那个，对呀，你更像是回去，就像，嗯，我的意思是，我想这很能说明问题，我们找到的解决方案有第一个女王在这里，因为我觉得，我们先试了这个。

所以任何有第一个女王的解决方案，对于任何有第一个女王的解决方案，以此类推，就像嗯，为什么这家伙不在更高的地方，我是说那些规则不是真的吗，他在这里或更早的时候，我们不能解决这个问题，在这里也听到了。

我想我想这可能是真的，如果你坐下来好好看看，我想你发现的是，这个女王在这里是没有解决办法的，另一个女王在这里或这里，如果你被困在这里，你可以用第一个，第二个也可以，我没有坐在那里跟踪，但我想我相信。

由于我们如何搜索的性质，这一定是，所以说，你知道的。

好啦，反正，那是皇后区的问题，皇后区的问题，如果你想看到N个皇后不同的结局，你可以试试，你知道5号或者其他什么的，并查看一些大*端口，没有任何解决办法，嗯。

有五个确实，但我的意思是你可以尝试不同大*的棋盘看看它是否有趣，我喜欢那个，你要做作业，四叫伯乐，你在二*板上搜索单词，肯定有这方面的喜欢，如果你能找到一种方法，通过连接这个网格上的字母来制造一个单词。

你想把它还回去吗，当你找到一条路的时候你想停下来，所以这种编码风格，用递归找到解决方案，如果你看到了，跳出递归，这段代码是一个很好的参考，所以无论如何。

好啦，还有什么，让我们继续前进，所以让我们看看我想做什么，我想做这个多米诺骨牌问题，但实际上，我真的很想解决这个旅行问题，所以我想看看我是否回到这个多米诺骨牌问题，很快的嗯，所以我一直想这样做。

现在有几节课了，在我的幻灯片里，但我还没读到，所以这一个是找到一种方法来跟踪所有到达给定点的方法，所以这就像你知道我们从零开始，我们想画并找到所有到达某个x y位置的方法，所以这是所有这些详尽的，倒掉。

所有的解决方案，各种各样的问题，你唯一能做的三个动作是去东北或东北，现在实际上翻转，所以北方是下降的，因为坐标是主导计算机，但是不管怎么样，如果你想从0到21，你可以斜着走然后写，或者你可以去。

你知道这是一个，这是一个正在进行的部分，你可以往下走，然后再过去，或者你可以过去然后下去，所以你想打印或者尝试所有不同的方法，我们的要求是有道理的，有了这三种方法，你可以移动打印。

所有能让你到达某个地方的方法，然后呢，当然什么，这三招最重要的是你不能倒退，你不能下去，然后向右，然后离开，你不能，你不能回去，原来如此。

所以我这里有一个文件，叫做旅行点CPP，让我把主改名为主皇后或其他什么，然后旅行，我这里有个主干道，我们现在需要写这个，我取一个参数g点，我根本没谈过这个，只是一个很蠢的*东西。

有一个得到X和得到Y什么的，这很容易，所以嗯，我隐含地从零点到那里，那么怎么做呢，去东北方还是东北，你想告诉我基本情况，也许或者喜欢，你说呢，是啊，是啊，好啦，当然，有不同的方法可以做到这一点。

我认为你的解决方案很好，让我们从那里开始你说，让我们写一个助手，告诉我们我们在哪里，目标在哪里，因为我们从零开始，但是当我们进行这些递归调用时，我们要从那里开始，所以另一种方法是把目标降低到零。

但我想你说的话会更好，我想做的，就是把这个画动画，所以你是说，使像虚空旅行助手采取这个点目标，它需要一个g点，我和我一样的地方，我的位置在哪里，所以说，我要打电话给旅行助手，我将通过目标。

我的位置就像G点，原点，零，我将通过原点或类似的方法，好的，好的，酷好的开始好的开始下一个，还有什么，基本情况是，是啊，是啊，基本情况，我是说很多时候递归，你得想想基本情况，所以好吧，简单的基本情况是。

如果目标等于我，听起来我们在玩，有某种暗杀企图什么的，嗯，如果目标是我，那我就完了，现在这个愚蠢的函数的目标是什么，它应该打印出所有这些路径，所以在理论上，我想打印一些东西，我猜，但我要印什么。

我需要打印，我是如何到达目标的，我怎么知道我是怎么到达目标的，在你以前的位置向量几个点，好啦，当然可以，让我们跟踪，我是说，在所有这些问题中，当我们穷尽搜索或回溯时。

我们需要跟踪我们在某种程度上做出的选择，从一个电话传到另一个电话，选择向量或字符串，这里的格式只是用空格分隔，但我想把它作为一个矢量会很好，也是，所以就像，嗯，也许是字符串，因为我在打印东和北。

我不会打印坐标本身，就像我所选择的东西的字符串向量，所以也许我会说是被选中的，然后在这里我将通过向量字符串引用选择也可以点引用，总是做一个g点参考，哦，就像这里的我。

我这么做的原因是像我这样的人可能会在每个电话中改变，就像我们可以，我们也可以探索一下，但我的意思是，基本上我需要看到我的选择，当我谈到这个基本情况时，对耶，去吧，所以你认为它是一个矢量会更好地使用。

就像输出字符串，我们可以用一根绳子或一条*溪或类似的东西，是啊，是啊，我是说这个问题，我不在乎太多，如果输出与之完全匹配，我可以带个*牙套什么的，我觉得很好，我只想确保我打印的是正确的顺序。

如果你想要没有括号的，我想你可以传递一个字符串，并将一个e或其他东西连接到字符串上，我只是随便，这两种都可以，如果我不是目标，我该怎么办，迈出一步，迈出一步，离目标更近一步，好的递归情况。

向目标迈进一步，所以我说你可以往东或往北或东北，对呀，比如我在这里到底该做什么，你先走，还要检查一下，看看你是否喜欢比，所以不要走得太远，就像，如果我走过它，我不能回去，好啦，所以也许像，如果。

*于或等于目标得到x，*于或等于目标，为什么你这么想，我不喜欢那样，好吧，那么，如果我没有走得太远，然后做一些递归，是啊，是啊，去吧，有一个从零到一的for循环，表示，啊，去做。

x和y的不同变体被一个修正，是啊，是啊，我告诉你吧，我不想在这里太聪明，我可以把这三个案子写出来，而不是试图想出一些循环，我可以写东部的代码，然后为北方写代码，然后写东北的代码，三个都分开了。

如果它是超级丑陋和多余的，我们也许可以试着修好它什么的，但我没事，就像我想把这个问题和那个子列表问题进行比较，在那里你不总是需要一个循环，你知道的，我觉得，我想我解决这个问题的目标之一是向你展示。

有时候没有循环也没关系，就像如果只有几个案子，很容易一一列举，你不必总是把它变成一个for循环，所以我想说，往东走试试，试着往北走，然后再试着往东北走，一次又一次，当我说尝试的时候，选择，然后东北右。

那么我该如何选择东方呢，东边是我的位置，右边X加一个，所以也许像G点东部这样的地方是我的，我的x加零，我的Y加1，东北是两个加一个，所以我要做，我必须做出选择，所以我必须喜欢，做选定的点，最后加上东方。

我不再是我了，我是东方人，对呀，同样选择的向量，然后取消他选择的点，移除选定的网点大*，现在减去一个，你可能在为你的循环辩护，但我是说你看，我想先把这些案子写下来，所以再来一次，但有了北右，北北。

然后呢，往东北走，移除东北，对呀，好啦，所以如果你要在这里做一个循环，你知道的，我觉得你很聪明把0和1，三角洲之类的，我可以接受下面这样的事情，宣布这三点东北方东北，然后你可以把它们变成一个*矢量。

然后，对于他们中的每一个，你可以选择，探索unches，你可以做那样的事，也许我们会回来的，我想，我想试着得到一些以前有效的东西，我清理得太多了，对呀，我们喜欢那样吗，让我们，让我们看看，它是做什么的。

哎呀，没有匹配功能，对于，哎呦，这是字符串的向量，其实不是吗，它不是点的向量，G分，所以我应该加上东方，我应该把绳子往北加，这里我应该加上东北弦，好啦，不管目标是什么，让我们做四和三，哇，看看这些。

那看起来对吗，就不一定匹配字符而言，幻灯片上的输出，但就像那些似乎把我们引向那个地方的动作一样，我觉得他们还可以，所以这就是如何做到这一点的勇气，我想和你谈谈，虽然，因为你可能会说。

但我的意思是我不知道，这是回溯问题吗，我们只是把它们都扔掉，我是说，你知道，有些问题只是把所有的，答案现在出来了，嗯，我们做了一点回溯，就像不选择这些，但我想谈谈，就像，如果我们想喜欢，画出。

因为我们看到了八个皇后，我们看到它尝试了所有的东西，如果我们想喜欢，观看此算法运行。

所以如果我们想看呢，尝试所有的*线条，你知道随着它的发展，那么我们怎样才能做好呢，那么我们能做什么呢，我们可以走过去在窗户上画画，就像我们可以把窗户传来传去。

我们已经在你的作业上做过了，三你的分形和东西，你绕过一扇窗户，如果我回到这里，看到这一切都发生在G窗口上，所以如果在这里，我说在这个G窗口上旅行呢，G配音，然后这里我的助手也拿G配音，然后在这里。

我的助手拿着G配音，在这里G配音，然后在这里，当我叫它，我说G就像现在我有窗户，如果我想和他说话，也许我可以有这个递归，就像画线一样，有点，你知道的，所以我只想谈谈你可能会对代码进行什么样的修改。

为了达到这个目的，我想我看到这些黄线，我得马上把它修好，但我想我可以说划清界限，东北部，从我到东方，或从我到北方，我可以这么做，我可以这么做，我有一些稍微不同的想法，就像是，也许我可以添加另一个参数。

就像前面说的，或者我是怎么到这里的，然后对我来说就像以前一样，我会画一个，这可能会帮助我避免画三条线，一个给东边，一个给北方，东北一张，也许我可以划清界限，从我以前的人到我这里来，差不多吧。

如果我们探索一下，呃首先在我忘记之前，我得在这里说G配音，我得说G配音，我要说开始了，如果我通过了前一个点怎么办，喜欢而不只是我，我像三一样通过了，我通过了我，所以现在，如果你一开始没有真正的热情。

所以也许我会把原点传递两次什么的，它不是一个真正有效的值，不过，好吧，如果你要超过我和普瑞芙，那我把什么传给下面的这些电话，就像，呃，不久的将来，我，所以我是这三个人的牧师，对呀，呃是的，去吧。

为什么你要和我划清界限，是从我到北方的吗，我可以画一条线，从我到东从我到北从我到东北，我想我是这么想的，也许我不必写三次代码，如果我只是从Prieve那里把它画给我，所以就像这里。

我可以说G W B点从Pre点画线，获取x Prieve点，给我点，得到x我的点，现在就得到这样的东西，嗯，如果我想做的好，我来试试，我来看看，如果那样有什么用的话，我只剩一两分钟了，哦G配音未申报。

哎呦，我没有，哎呦，这叫图形抱歉，我应该打电话，可能没时间了，所以这里我称之为旅行，G w b，G点目标，目标x，目标y，然后我叫G，好啦，我们试试看，它在画这些微*的线条。

因为它是从相距一个像素的点绘制它们的，你知道，我想我没有时间完成它了，所以好吧，别再把我们丢在这里了，我知道我知道，我知道我就像那些糟糕的网飞节目之一，他们想让你点击这里的下一集，所以看几件事。

我能做的一件事就是，我可以把这些线相乘，x和y大约是50，这样线条看起来更大，我可以这么做，但我想给你看的另一件事，但我想把时间花在，如果我想展示算法，我真的应该在屏幕上画线，然后如果我回溯。

我应该把屏幕上的线条去掉，所以幻灯片中的解决方案，用不同的颜色和材料，所以你可以看看，如果你想的话，我得让你走，祝你周末愉快，开始做家庭作业，星期一见。