blocks|key|1586892|text|下面是是对算法的一个很好的描述，它也解释了松弛的概念。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1586893|“松弛”的概念来源于对最短路径的估计与螺旋张力弹簧长度的类比，而螺旋张力弹簧不是为压缩而设计的。最初，最短路径的成本被高估了，就像一个伸展的弹簧。当发现较短的路径时，估计成本降低，弹簧放松。最后，找到了最短的路径，如果存在的话，弹簧就会放松到休息的长度。|blockquote|1586894|entityMap|0|LINK|mutability|MUTABLE|url|http://www.egr.unlv.edu/~larmore/Courses/CSC269/pathing^0|0|3|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@$A|P|B|Q|1|R]]|C|$]]|$1|D|3|E|5|F|7|S|8|@]|9|@]|C|$]]|$1|G|3|-4|5|6|7|T|8|@]|9|@]|C|$]]]|H|$I|$5|J|K|L|C|$M|N]]]]

<a href="http://www.egr.unlv.edu/~larmore/Courses/CSC269/pathing" rel="noreferrer">Here's</a> a nice description of the Algorithm that also explains the notion of relaxation.

<blockquote>
 The notion of "relaxation" comes from an analogy between the estimate
 of the shortest path and the length of a helical tension spring, which
 is not designed for compression. Initially, the cost of the shortest
 path is an overestimate, likened to a stretched out spring. As shorter
 paths are found, the estimated cost is lowered, and the spring is
 relaxed. Eventually, the shortest path, if one exists, is found and
 the spring has been relaxed to its resting length.
</blockquote>

blocks|key|1586914|text|Dijkstra算法中的松弛过程是指更新连接到一个顶点v的所有顶点的代价，如果这些代价通过包含路径v来改进的话。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1586915|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|$]]

The relaxation process in Dijkstra's algorithm refers to updating the cost of all vertices connected to a vertex v, if those costs would be improved by including the path via v.

blocks|key|2063930|text|放松一个边缘(你也可以在其他最短路径算法中找到一个概念)试图通过使用另一个顶点来降低到达顶点的成本。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2063931|你在计算从一个起始顶点到所有其他顶点的距离，比如说S。在某种程度上，你有中间的结果--目前的估计。松弛是检查某些顶点u和v的过程。|2063932|if+directly_connected(v,+u)
++++if+est(S,+v)+>+est(S,+u)+%2B+dist(u,v)
+++++++est(S,+v)+=+est(S,+u)+%2B+dist(u,+v)|code-block|syntax|javascript|2063933|其中est(S,a)是距离的当前估计，dist(a,b)是图中两个邻接点之间的距离。|offset|length|style|CODE|2063934|在松弛过程中，您基本上检查的是，如果您当前的估计值从a到b可以通过“转移”通过c的路径来改进(这种“转移”将是从a到c和从c到b的路径的长度)。|2063935|entityMap^0|0|0|0|2|8|J|9|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|T|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|U|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|V|8|@$K|W|L|X|M|N]|$K|Y|L|Z|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|10|8|@]|9|@]|A|$]]|$1|Q|3|-4|5|6|7|11|8|@]|9|@]|A|$]]]|R|$]]

Relaxing an edge, (a concept you can find in other shortest-path algorithms as well) is trying to lower the cost of getting to a vertex by using another vertex.

You are calculating the distances from a beginning vertex, say S, to all the other vertices. At some point, you have intermediate results -- current estimates. The relaxation is the process where you check, for some vertices u and v:

<pre><code>if directly_connected(v, u)
 if est(S, v) &gt; est(S, u) + dist(u,v)
 est(S, v) = est(S, u) + dist(u, v)
</code></pre>

where <code>est(S,a)</code> is the current estimate of the distance, and <code>dist(a,b)</code> is the distance between two vertices that are neighbors in the graph.

What you are basically checking in the relaxation process is weather your current estimate from a to b could be improved by "diverting" the path through c (this "diversion" would be the length of a path from a to c and from c to b).

blocks|key|1024004|text|边松弛过程|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1024005|初始化|1024006|在最短路径算法中，高昂的代价告诉算法“不要沿着这条路走”。因此，在默认情况下，我们只知道起始节点是最短路径的一部分，而所有其他节点仍未确定。因此，我们为起始节点(例如S)分配了低成本的零，对其他节点(例如A、E)分配了很高的无穷大成本。|offset|length|style|BOLD|1024007|​|1024008|📷|atomic|1024009|1024010|S+:=+new+Node()
A+:=+new+Node()
E+:=+new+Node()

//+low+cost
S.edge_cost+=+0

//+high+cost
A.edge_cost+=+1000+//+"infinity"
E.edge_cost+=+1000+//+"infinity"|code-block|syntax|javascript|1024011|松驰|1024012|高成本只是暂时的，我们现在需要“放松”降低成本。为此，我们使用边缘成本(例如a、b和c)，并在节点较低的情况下更新它们。|1024013|1024014|1024015|1024016|//+Check+if+S+node+can+be+reduced
//+SS+:=+S.edge_cost+%2B+S.edge_cost+//+0+%2B+0+=+0
//+if+(S.edge_cost+>+SS)+{+//+0+>+0+=>+false
//+++S.edge_cost+=+SS
//+}

//+Check+if+A+node+can+be+reduced
SA+:=+S.edge_cost+%2B+a+//+0+%2B+3+=+3
if+(A.edge_cost+>+SA)+{+//+1000+>+3+=>+true
++A.edge_cost+=+SA+//+3
}

//+Check+if+E+node+can+be+reduced
AE+:=+A.edge_cost+%2B+b+//+3+%2B+5+=+8
if+(E.edge_cost+>+AE)+{+//+1000+>+8+=>+true
++E.edge_cost+=+AE+//+8
}|1024017|松弛重复|1024018|1024019|1024020|1024021|//+Note:+The+nodes+hold+memory,
//++so+the+`edge_cost`+remembers+the+previous+cost,
//++and+that's+what+the+edge+is+compared+against

SE+:=+S.edge_cost+%2B+c+//+0+%2B+1+=+1
if+(E.edge_cost+>+SE)+{+//+8+>+1+=>+true+
++E.edge_cost+=+SE+//+1
}|1024022|entityMap|0|IMAGE|mutability|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/3373acfabf5dc62cf3ddecf8c91697ff.png|imageAlt|1|https://developer.qcloudimg.com/http-save/yehe-900000/7cf3608d34efe2c0735bf7642a5954a7.png|2|https://developer.qcloudimg.com/http-save/yehe-900000/92020e983c0aa03ef6e5860bf9fd2ea9.png^0|0|0|2B|1|2U|1|2W|1|0|0|0|1|0|0|0|0|0|12|1|14|1|16|1|0|0|0|1|1|0|0|0|0|0|0|1|2|0|0|0^^$0|@$1|2|3|4|5|6|7|1N|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1O|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1P|8|@$F|1Q|G|1R|H|I]|$F|1S|G|1T|H|I]|$F|1U|G|1V|H|I]]|9|@]|A|$]]|$1|J|3|K|5|6|7|1W|8|@]|9|@]|A|$]]|$1|L|3|M|5|N|7|1X|8|@]|9|@$F|1Y|G|1Z|1|20]]|A|$]]|$1|O|3|K|5|6|7|21|8|@]|9|@]|A|$]]|$1|P|3|Q|5|R|7|22|8|@]|9|@]|A|$S|T]]|$1|U|3|V|5|6|7|23|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|24|8|@$F|25|G|26|H|I]|$F|27|G|28|H|I]|$F|29|G|2A|H|I]]|9|@]|A|$]]|$1|Y|3|K|5|6|7|2B|8|@]|9|@]|A|$]]|$1|Z|3|M|5|N|7|2C|8|@]|9|@$F|2D|G|2E|1|2F]]|A|$]]|$1|10|3|K|5|6|7|2G|8|@]|9|@]|A|$]]|$1|11|3|12|5|R|7|2H|8|@]|9|@]|A|$S|T]]|$1|13|3|14|5|6|7|2I|8|@]|9|@]|A|$]]|$1|15|3|K|5|6|7|2J|8|@]|9|@]|A|$]]|$1|16|3|M|5|N|7|2K|8|@]|9|@$F|2L|G|2M|1|2N]]|A|$]]|$1|17|3|K|5|6|7|2O|8|@]|9|@]|A|$]]|$1|18|3|19|5|R|7|2P|8|@]|9|@]|A|$S|T]]|$1|1A|3|-4|5|6|7|2Q|8|@]|9|@]|A|$]]]|1B|$1C|$5|1D|1E|1F|A|$1G|1H|1I|-4]]|1J|$5|1D|1E|1F|A|$1G|1K|1I|-4]]|1L|$5|1D|1E|1F|A|$1G|1M|1I|-4]]]]

<h1>Edge relaxation process</h1>
<h2>Initialization</h2>
In shortest-path algorithms, a high cost tells the algorithm &quot;do not go down that path&quot;. So by default, we only know that the starting node is apart of the shortest path, while all other nodes are still undetermined. Therefore, we assign a low cost of zero to the starting node (e.g. S), and a high cost of infinity to every other node (e.g. A, E).
<a href="https://i.stack.imgur.com/EVrSx.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/EVrSx.png" alt="shortest_path_01" /></a>
<pre class="lang-golang prettyprint-override"><code>S := new Node()
A := new Node()
E := new Node()

// low cost
S.edge_cost = 0

// high cost
A.edge_cost = 1000 // &quot;infinity&quot;
E.edge_cost = 1000 // &quot;infinity&quot;
</code></pre>
<h2>Relaxation</h2>
The high costs are only temporary, and we now need to &quot;relax&quot; reduce the costs. To do that, we use the edge costs (e.g. a, b, and c), and update the nodes if they are lower.
<a href="https://i.stack.imgur.com/J4Rpf.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/J4Rpf.png" alt="shortest_path_02" /></a>
<pre class="lang-golang prettyprint-override"><code>// Check if S node can be reduced
// SS := S.edge_cost + S.edge_cost // 0 + 0 = 0
// if (S.edge_cost &gt; SS) { // 0 &gt; 0 =&gt; false
// S.edge_cost = SS
// }

// Check if A node can be reduced
SA := S.edge_cost + a // 0 + 3 = 3
if (A.edge_cost &gt; SA) { // 1000 &gt; 3 =&gt; true
 A.edge_cost = SA // 3
}

// Check if E node can be reduced
AE := A.edge_cost + b // 3 + 5 = 8
if (E.edge_cost &gt; AE) { // 1000 &gt; 8 =&gt; true
 E.edge_cost = AE // 8
}
</code></pre>
<h2>Relaxation repeated</h2>
<a href="https://i.stack.imgur.com/Wd3AR.png" rel="nofollow noreferrer"><img src="https://i.stack.imgur.com/Wd3AR.png" alt="shortest_path_03" /></a>
<pre class="lang-golang prettyprint-override"><code>// Note: The nodes hold memory,
// so the `edge_cost` remembers the previous cost,
// and that's what the edge is compared against

SE := S.edge_cost + c // 0 + 1 = 1
if (E.edge_cost &gt; SE) { // 8 &gt; 1 =&gt; true 
 E.edge_cost = SE // 1
}
</code></pre>

blocks|key|1026037|text|我还不能发表评论，但让我试着回答对已被接受的答案的评论。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1026038|user3245268评论道：
是否有理由说边是放松的，而不是节点的路径?为什么“边”松弛而不是“路径”松弛？|blockquote|1026039|通常边缘相对于路径放松的原因可能是，在执行Dijkstra的算法时，没有任何路径的显式表示；在此阶段，您所拥有的只是每个节点的前身指针。|1026040|很明显，如果边是松弛的，那么隐式的新最短路径也是松弛的，所以它与类比放松路径是不矛盾的。但是在算法中，你还没有真正考虑路径，放松路径边的概念在上下文中同样有意义。|1026041|亚历克西评论道：
这个解释没什么意义。弹簧是边缘吗？那么当一个弹簧放松的时候，其他弹簧会发生什么呢？为什么一开始他们都不放松？或者泉是最短的路？那么，它们是不可压缩的，超出什么？为什么要说“放松弹簧”而不是“短绳”呢？我听说“放松”来自运筹学，但我还不知道细节.|1026042|是的，弹簧是边缘。|1026043|当一个弹簧放松时，部分子图中的一些“张力”可能被释放，而另一些弹簧也可能因此而放松。|1026044|在开始时，从起始节点到任何其他节点的(初步)最短距离被初始化为无穷大，因此所有弹簧都被扩展到无穷大。|1026045|弹簧应该是“在静止状态下是不可压缩的”，但我认为这是相当令人困惑的，而图的另一种“脐带模型”更容易理解。线可以|1026046|被扔到合适的长度|unordered-list-item|1026047|当它们还没有被探索的时候，就会超出它们的适当长度。|1026048|当它们不是任何最短路径的一部分时，就到处晃荡。|1026049|当放松一条边缘时，“新最短路径”的边缘从过度延伸到仅仅延伸，而“旧最短路径”的边缘则从漫漫到松散。|1026050|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|13|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|14|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|15|8|@]|9|@]|A|$]]|$1|G|3|H|5|6|7|16|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|17|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|18|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|19|8|@]|9|@]|A|$]]|$1|O|3|P|5|6|7|1A|8|@]|9|@]|A|$]]|$1|Q|3|R|5|6|7|1B|8|@]|9|@]|A|$]]|$1|S|3|T|5|U|7|1C|8|@]|9|@]|A|$]]|$1|V|3|W|5|U|7|1D|8|@]|9|@]|A|$]]|$1|X|3|Y|5|U|7|1E|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|1F|8|@]|9|@]|A|$]]|$1|11|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]]|12|$]]

I can't comment yet but let me have a go at answering the comments on the accepted answer.
<blockquote>
user3245268 commented:
Is there a reason for telling that the EDGE is relaxed, and not the
path to the node v. Why &quot;EDGE&quot; relaxation and not &quot;PATH&quot; relaxation
</blockquote>
The reason why typically edges are relaxed as opposed to paths might be that during the execution of Dijkstra's algorithm, no explicit representation of any path is present; all you have at this stage are the predecessor pointers of each node.
Obviously, if an edge is relaxed, the implicit new shortest path is relaxed as well, so it does not contradict the analogy to relax a path. But in the algorithm, where you don't really think about paths yet, the notion of relaxing an edge on the path instead makes just as much sense in the context.
<blockquote>
Alexey commented:
Makes little sense this explanation. Are springs the edges? Then what happens to other springs when one is relaxed? Why aren't they all relaxed at the beginning? Or are springs shortest paths? Then they are not compressible beyond what? Why to talk about &quot;relaxing springs&quot; and not &quot;shortening cords&quot;? I've heard that &quot;relaxation&quot; comes from Operations Research, but i cannot yet figure out details...
</blockquote>
Yes, springs are the edges.
When one spring is relaxed, some &quot;tension&quot; in part of the subgraph may be released and some other springs may relax as well as a result.
At the beginning, the (preliminary) shortest distance from the starting node to any other node is initialized to infinity, so all springs are streched out to infinity.
The springs are supposed to be &quot;not compressible [beyond their resting state],&quot; but I do think that this is rather confusing, and that the alternative &quot;cord model&quot; of a graph is a bit simpler to grasp. Cords can
<ul>
<li>be streched to their proper length</li>
<li>be overstreched beyond their proper length while they are not explored yet or</li>
<li>just dangle about when they are not part of any shortest path</li>
</ul>
When relaxing an edge, the edge of the &quot;new shortest path&quot; goes from overstreched to just streched, while the edge of the &quot;old shortest path&quot; goes from streched to loose.

blocks|key|1023957|text|设在图中，如果我们有(u，v)∈E，其中w(u，v)=10，那么如果在它们之间加上第三个顶点，如w(u，y)=1和w(y，v)=3，我们现在就找到了在u和v之间的一条带权重∈的路径，现在我们将考虑第二条路径最短，即(u，y，v)，而忽略第一条路径，这就是松弛。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1023958|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|$]]

lets suppose in graph if we have (u,v)∈ E where w(u,v)=10 
then if by adding a third vertex in between them like w(u,y)=1 and w(y,v)=3 now we find a path between u and v with weight 1+3=4&lt;10. Now we will consider the second path as shortest which is (u,y,v) and will ignore the first one, this is relaxation.

blocks|key|2064018|text|边缘松弛|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2064019|放松边v+->+w意味着测试从s到w最著名的方式是否从s到v，然后取边从v到w，如果是的话，更新我们的数据结构。|blockquote|2064020|Java代码：|2064021|private+void+relax(DirectedEdge+e)+{
++++int+v+=+e.from(),+w+=+e.to;
++++if+(distTo[w]+>+distTo[v]+%2B+e.weight())+{
++++++++distTo[w]+=+distTo[v]+%2B+e.weight();
++++++++edgeTo[w]+=+e;
++++}
}|code-block|syntax|javascript|2064022|也有顶点松弛。这意味着放松指向给定顶点的所有边。|2064023|private+void+relax(EdgeWeightedGraph+G,+int+v)+{
++++for+(DirectedEdge+e+:+G.adj(v))+{
++++++++relax(e);
++++}
}|2064024|来自https://algs4.cs.princeton.edu/44sp/|offset|length|2064025|entityMap|0|LINK|mutability|MUTABLE|url|https://algs4.cs.princeton.edu/44sp/^0|0|0|0|0|0|0|2|10|0|0^^$0|@$1|2|3|4|5|6|7|11|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|12|8|@]|9|@]|A|$]]|$1|E|3|F|5|6|7|13|8|@]|9|@]|A|$]]|$1|G|3|H|5|I|7|14|8|@]|9|@]|A|$J|K]]|$1|L|3|M|5|6|7|15|8|@]|9|@]|A|$]]|$1|N|3|O|5|I|7|16|8|@]|9|@]|A|$J|K]]|$1|P|3|Q|5|6|7|17|8|@]|9|@$R|18|S|19|1|1A]]|A|$]]|$1|T|3|-4|5|6|7|1B|8|@]|9|@]|A|$]]]|U|$V|$5|W|X|Y|A|$Z|10]]]]

Edge relaxation.

<blockquote>
 To relax an edge v -> w means to test whether the best-known way from
 s to w is to from s to v, then take the edge from v to w, and, if so,
 update our data structures.
</blockquote>

Java code:

<pre><code>private void relax(DirectedEdge e) {
 int v = e.from(), w = e.to;
 if (distTo[w] &gt; distTo[v] + e.weight()) {
 distTo[w] = distTo[v] + e.weight();
 edgeTo[w] = e;
 }
}
</code></pre>

There is also vertex relaxation. That means to relax all the edges pointing from a given vertex.

<pre><code>private void relax(EdgeWeightedGraph G, int v) {
 for (DirectedEdge e : G.adj(v)) {
 relax(e);
 }
}
</code></pre>

From <a href="https://algs4.cs.princeton.edu/44sp/" rel="nofollow noreferrer">https://algs4.cs.princeton.edu/44sp/</a>

blocks|key|1024029|text|看看https://www.youtube.com/watch?v=2E7MmKv0Y24&t=1336s时间:+28:30。有趣的是，最短的路径就是那些处于紧张状态下的路径。对我来说，这正好是放松的反面。哦，好吧。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1024030|entityMap|0|LINK|mutability|MUTABLE|url|https://www.youtube.com/watch?v=2E7MmKv0Y24&t=1336s^0|2|1F|0|0^^$0|@$1|2|3|4|5|6|7|L|8|@]|9|@$A|M|B|N|1|O]]|C|$]]|$1|D|3|-4|5|6|7|P|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]]]

Take a look at <a href="https://www.youtube.com/watch?v=2E7MmKv0Y24&amp;t=1336s" rel="nofollow noreferrer">https://www.youtube.com/watch?v=2E7MmKv0Y24&amp;t=1336s</a> Time: 28:30. Funny thing is that the shortest paths are the ones that are under TENSION. To me this is the exact opposite of RELAX. Oh well.

What does <code>relaxation of an edge</code> mean in the context of graph theory ? I came across this while studying up on Dijkstra's algorithm for single source shortest path.

Relaxation of an edge in Dijkstra's algorithm

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

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

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

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

文章

问答

视频

教程

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯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编辑器全新改版上线，欢迎大家体验!

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

社区新版编辑器体验调研

在图论的背景下，relaxation of an edge是什么意思？我是在研究Dijkstra的单源最短路径算法时遇到这个问题的。

问Dijkstra算法中边的松弛
EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Dijkstra算法中边的松弛EN

回答 8

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Dijkstra算法中边的松弛
EN