blocks|key|387941|text|您可以在C和C%2B%2B中使用setjmp()/longjmp()，这是一种简单但有效的方法，可以绕过一直传递标志的需要。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|387942|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

You could use setjmp()/longjmp() in both C and C++ for a crude but effective way of bypassing the need to pass a flag all the way back.

blocks|key|3144758|text|一种又快又脏的方法是抛出一个异常，并在基础级别上捕获它(现在很多人都会尖叫着只对错误使用异常，我认为，建立解决方案是一个例外事件，因为找不到解决方案是常态)|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144759|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

A quick and dirty way is to throw an Exception and catch it at the base level (around right now a lot of people will scream to only use Exceptions for Errors, I argue, founding a solution is an exceptional event since not finding one is the norm)

blocks|key|1135567|text|如果你有一个在完成时设置的标志，然后在你的函数中检查它，你可以解决这个问题。例如：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1135568|void+foo(..)
{
+++if+(g_done)+return;
...
}|code-block|syntax|javascript|1135569|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

if you have a flag that is set when you are done and then which is checked in your functions you could solve this. e.g.

<pre><code>void foo(..)
{
 if (g_done) return;
...
}
</code></pre>

blocks|key|387958|text|在不确切知道您需要什么的情况下，我会考虑实现您自己的堆栈，并完全避免递归。这样，退出回溯树就变得微不足道了(单个“返回”)，而且还可以通过再次调用函数来恢复搜索以找到下一个解决方案，前提是用户定义的堆栈的状态被保留(在静态变量中)。当然，将简单的递归程序转换为循环会产生一些编程开销，但这是非常简单的。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|387959|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Without knowing exactly what you need, I would look at implementing your own stack, and avoid recursion completely. That way it becomes trivial to exit the backtracking tree (a single "return"), and it is also possible to resume the search to find the next solution by calling the function again, presuming the state of the user-defined stack is preserved (in static variables). Of course, there is a bit of programming overhead to convert a simple recursive program to a loop, but it's pretty straightforward to do.

blocks|key|387908|text|这实际上取决于你的实现，但你可以设置一些特殊的参数，并将其用作一个标志，比如“我们得到解决方案了吗?如果得到了解决方案，那么中止当前的例程，只获得输出的解决方案”。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|387909|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

It actually depends on your implementation, but you could set some special param and use it as a flag like "Did we get a solution? If yes, then abort your current routine and get only that solution to the output".

blocks|key|3144926|text|为什么要让函数立即退出？不回溯堆栈是很危险的，因为堆栈上可能有需要销毁的对象。抛出一个异常可能是由于这个技巧，它将清理堆栈。提供更多关于您正在尝试做什么的信息，我们也许能够提供其他方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3144927|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

Why do you want the function to immediately exit? Not backtracking through the stack is dangerous as you could have objects on it that need to be destroyed. Throwing an exception might due the trick for you, and it will cleanup the stack. Provide more information about what you are trying to do and we might be able to provide other approaches.

blocks|key|1135671|text|如果您的回溯算法实际上是递归足够深，这是重要的，您不应该使用递归，因为您将处于危险的堆栈。与其提交一些涉及longjmp的错误行为，不如考虑使用自己的堆分配堆栈将算法重写为迭代方法，堆分配堆栈存储表示状态的POD对象。当您找到解决方案时，可以在一个有效的步骤中销毁状态容器，并返回答案。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1135672|请参阅Way+to+go+from+recursion+to+iteration|offset|length|1135673|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/159590/way-to-go-from-recursion-to-iteration^0|0|3|11|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|O|8|@]|9|@$D|P|E|Q|1|R]]|A|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|A|$]]]|G|$H|$5|I|J|K|A|$L|M]]]]

If your backtracking algorithm is actually recursing deep enough for this to matter, you shouldn't use recursion because you'll be in danger of blowing the stack. Rather than committing some atrocity involving longjmp, you should consider rewriting your algorithm to an iterative approach with your own heap-allocated stack which stores a POD object representing the state. When you find your solution the state container can be destroyed in one efficient step and the answer can be returned.

See <a href="https://stackoverflow.com/questions/159590/way-to-go-from-recursion-to-iteration">Way to go from recursion to iteration</a>

blocks|key|3145039|text|首先，请注意，您不能对任何递归函数执行此操作。考虑以下代码：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|3145040|int+SumNum(int+nMax)
{
++++if+(0+==+nMax)
++++++++return+0;
++++else
++++++++return+nMax+%2B+SumNum(nMax-1);
}|code-block|syntax|javascript|3145041|实际值是在回溯过程中计算的。|3145042|但是，您可以通过以下方式重写代码：|3145043|int+SumNum(int+nMax,+int+nSum)
{
++++if+(0+==+nMax)
++++++++return+nSum;
++++else
++++++++return+SumNum(nMax-1,+nSum%2BnMax);
}|3145044|现在，您可以执行以下操作：|3145045|++++int+SumNum(int+nMax,+int+nSum)
++++{
++++++++if+(0+==+nMax)
++++++++++++throw+nSum;
++++++++else
++++++++++++return+SumNum(nMax-1,+nSum%2BnMax);
++++}


f()
{
++++++++int+nSum;

++++++++try
++++++++{
++++++++++++SumNum(100,+0);
++++++++}
++++++++catch+(int+_nSum)
++++++++{
++++++++++++nSum=+_nSum;
++++++++}
}|3145046|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|V|8|@]|9|@]|A|$]]|$1|K|3|L|5|D|7|W|8|@]|9|@]|A|$E|F]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

First, note that you can not do it for any recursive function.
Consider the following code:

<pre><code>int SumNum(int nMax)
{
 if (0 == nMax)
 return 0;
 else
 return nMax + SumNum(nMax-1);
}
</code></pre>

The actual value is calculated during the backtracking.

However, you can rewrite the code in the following way:

<pre><code>int SumNum(int nMax, int nSum)
{
 if (0 == nMax)
 return nSum;
 else
 return SumNum(nMax-1, nSum+nMax);
}
</code></pre>

Now, you can do the following trick:

<pre><code> int SumNum(int nMax, int nSum)
 {
 if (0 == nMax)
 throw nSum;
 else
 return SumNum(nMax-1, nSum+nMax);
 }


f()
{
 int nSum;

 try
 {
 SumNum(100, 0);
 }
 catch (int _nSum)
 {
 nSum= _nSum;
 }
}
</code></pre>

Is there any way in C/C++ to stop a backtracking algorithm after finding the first solution without exiting the program.

I want my function to immediately exit the function,not to quit every level of recurrsion one by one stating return.

Stopping Backtracking

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云智能顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云AI代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

功能1上新10个字符

功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符功能2描述100个字符。

功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符功能2上新100个字符。

功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符功能5描述100个字符

功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符功能5上新100个字符

功能4上新

文章&问答评论现已支持表情

全新交互，全新视觉，新增快捷键、悬浮工具栏、高亮块等功能并同时优化现有功能，全面提升创作效率和体验

社区富文本编辑器全新改版！诚邀体验～ 

精选全网热门MCP server，让你的AI更好用 🚀

💥开发者 MCP广场重磅上线！

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

聚焦“写作效率、视觉美观与运行性能”三方面进行全面升级，为您提供更高效、稳定的创作环境

社区富文本&Markdown编辑器全新改版上线，欢迎大家体验!

诚挚邀请您参与本次调研，分享您的真实使用感受与建议。您的反馈至关重要，感谢您的支持与参与！

社区新版编辑器体验调研

在C/C++中，有没有办法在找到第一个解后停止回溯算法，而不退出程序。我希望我的函数立即退出函数，而不是逐个声明return退出每一层递归。

问停止回溯
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问停止回溯EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问停止回溯
EN