Find a path from s to t using as few red nodes as possible The Next CEO of Stack OverflowDijkstra algorithm vs breadth first search for shortest path in graphAlgorithm to find diameter of a tree using BFS/DFS. Why does it work?Finding shortest path from a node to any node of a particular typeParallel algorithm to find if a set of nodes is on an elememtry cycle in a directed/undirected graphShortest path in unweighted graph using an iterator onlyShortest Path using DFS on weighted graphsCan a 3 Color DFS be used to identify cycles (not just detect them)?Find a path that contains specific nodes without back and forward edgesChecking if there is a single path that visits all nodes in a directed graphFind shortest path that goes through at least 5 red edges

Could a dragon use its wings to swim?

Calculate the Mean mean of two numbers

How dangerous is XSS

pgfplots: How to draw a tangent graph below two others?

Incomplete cube

A hang glider, sudden unexpected lift to 25,000 feet altitude, what could do this?

Is it possible to make a 9x9 table fit within the default margins?

Find the majority element, which appears more than half the time

Free fall ellipse or parabola?

How to unfasten electrical subpanel attached with ramset

Does Germany produce more waste than the US?

How can a day be of 24 hours?

Can you teleport closer to a creature you are Frightened of?

Is it OK to decorate a log book cover?

Mathematica command that allows it to read my intentions

Is the offspring between a demon and a celestial possible? If so what is it called and is it in a book somewhere?

Man transported from Alternate World into ours by a Neutrino Detector

Cannot restore registry to default in Windows 10?

Airship steam engine room - problems and conflict

Can Sri Krishna be called 'a person'?

Creating a script with console commands

Traveling with my 5 year old daughter (as the father) without the mother from Germany to Mexico

Why was Sir Cadogan fired?

How to implement Comparable so it is consistent with identity-equality



Find a path from s to t using as few red nodes as possible



The Next CEO of Stack OverflowDijkstra algorithm vs breadth first search for shortest path in graphAlgorithm to find diameter of a tree using BFS/DFS. Why does it work?Finding shortest path from a node to any node of a particular typeParallel algorithm to find if a set of nodes is on an elememtry cycle in a directed/undirected graphShortest path in unweighted graph using an iterator onlyShortest Path using DFS on weighted graphsCan a 3 Color DFS be used to identify cycles (not just detect them)?Find a path that contains specific nodes without back and forward edgesChecking if there is a single path that visits all nodes in a directed graphFind shortest path that goes through at least 5 red edges










3












$begingroup$


Was doing a little interview prep. Given an undirected graph G, such that each node is colored red or blue and |E|≥|V|, find a path in O(|E|) time such that starting and ending at 2 blue nodes, s and t, that you pass through as few red nodes as possible.



Initial Impressions: Since |E|≥|V|, O(|E|) time would include O(|E|+|V|), which means the solution likely uses BFS or DFS. Modifying the graph such that causing the all red nodes must be forced down a directed path of some long length (after making the whole graph directed) in order to use out-of-the-box BFS seems not viable, as it would mean constructing a new graph would be along O(|E||V|) time.



Another method I toyed around with was propagating values to nodes based on the safest path to that node while doing a DFS search, but not all values were guaranteed to update.



I still want to try to solve this myself, but I'm really stuck right now. Was wondering if there were any hints I could get. There are much simpler ways of doing this if it weren't for the O(|E|) time. Djikstras with creating some edge weights would work, but wouldn't be within the time bound.










share|cite|improve this question









$endgroup$







  • 1




    $begingroup$
    Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
    $endgroup$
    – Yuval Filmus
    4 hours ago















3












$begingroup$


Was doing a little interview prep. Given an undirected graph G, such that each node is colored red or blue and |E|≥|V|, find a path in O(|E|) time such that starting and ending at 2 blue nodes, s and t, that you pass through as few red nodes as possible.



Initial Impressions: Since |E|≥|V|, O(|E|) time would include O(|E|+|V|), which means the solution likely uses BFS or DFS. Modifying the graph such that causing the all red nodes must be forced down a directed path of some long length (after making the whole graph directed) in order to use out-of-the-box BFS seems not viable, as it would mean constructing a new graph would be along O(|E||V|) time.



Another method I toyed around with was propagating values to nodes based on the safest path to that node while doing a DFS search, but not all values were guaranteed to update.



I still want to try to solve this myself, but I'm really stuck right now. Was wondering if there were any hints I could get. There are much simpler ways of doing this if it weren't for the O(|E|) time. Djikstras with creating some edge weights would work, but wouldn't be within the time bound.










share|cite|improve this question









$endgroup$







  • 1




    $begingroup$
    Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
    $endgroup$
    – Yuval Filmus
    4 hours ago













3












3








3





$begingroup$


Was doing a little interview prep. Given an undirected graph G, such that each node is colored red or blue and |E|≥|V|, find a path in O(|E|) time such that starting and ending at 2 blue nodes, s and t, that you pass through as few red nodes as possible.



Initial Impressions: Since |E|≥|V|, O(|E|) time would include O(|E|+|V|), which means the solution likely uses BFS or DFS. Modifying the graph such that causing the all red nodes must be forced down a directed path of some long length (after making the whole graph directed) in order to use out-of-the-box BFS seems not viable, as it would mean constructing a new graph would be along O(|E||V|) time.



Another method I toyed around with was propagating values to nodes based on the safest path to that node while doing a DFS search, but not all values were guaranteed to update.



I still want to try to solve this myself, but I'm really stuck right now. Was wondering if there were any hints I could get. There are much simpler ways of doing this if it weren't for the O(|E|) time. Djikstras with creating some edge weights would work, but wouldn't be within the time bound.










share|cite|improve this question









$endgroup$




Was doing a little interview prep. Given an undirected graph G, such that each node is colored red or blue and |E|≥|V|, find a path in O(|E|) time such that starting and ending at 2 blue nodes, s and t, that you pass through as few red nodes as possible.



Initial Impressions: Since |E|≥|V|, O(|E|) time would include O(|E|+|V|), which means the solution likely uses BFS or DFS. Modifying the graph such that causing the all red nodes must be forced down a directed path of some long length (after making the whole graph directed) in order to use out-of-the-box BFS seems not viable, as it would mean constructing a new graph would be along O(|E||V|) time.



Another method I toyed around with was propagating values to nodes based on the safest path to that node while doing a DFS search, but not all values were guaranteed to update.



I still want to try to solve this myself, but I'm really stuck right now. Was wondering if there were any hints I could get. There are much simpler ways of doing this if it weren't for the O(|E|) time. Djikstras with creating some edge weights would work, but wouldn't be within the time bound.







graphs






share|cite|improve this question













share|cite|improve this question











share|cite|improve this question




share|cite|improve this question










asked 7 hours ago









Hunter DyerHunter Dyer

334




334







  • 1




    $begingroup$
    Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
    $endgroup$
    – Yuval Filmus
    4 hours ago












  • 1




    $begingroup$
    Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
    $endgroup$
    – Yuval Filmus
    4 hours ago







1




1




$begingroup$
Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
$endgroup$
– Yuval Filmus
4 hours ago




$begingroup$
Try a variant of BFS in which you first find all red nodes reachable only via blue nodes, and so on.
$endgroup$
– Yuval Filmus
4 hours ago










2 Answers
2






active

oldest

votes


















4












$begingroup$

To solve this, you need to use $BFS$. But first, manipulate $G$ so that the path will always favor blue vertices.



The solution has 2 parts:



  1. Use $DFS$ on blue vertices only, to find all all-blue strongly connected components, or $SCC$. Let's denote each $SCC$ by $v'$. Now, each blue $v in v'$ will be "compressed" to a single vertex $u$, and an edge $(u,x)$ will be added for every $x in N(v')$.
    Note any such $x$ is necessarily red.
    This step costs $O(V+E) = O(E)$, since $DFS$ is $O(V+E)$, and you have at most $V$ blue vertices, which make no more than $E$ new edges to add.

Step 1 means all paths that are blue-only will be free. On the new graph, the $BFS$ will only consider the edges which pass through a red vertex.



  1. Use $BFS$ from $s$. That length of the path to $t$ will essentially be the shortest path under the constraint of least red vertices in the path.





share|cite|improve this answer











$endgroup$












  • $begingroup$
    the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
    $endgroup$
    – Kevin Wang
    1 hour ago










  • $begingroup$
    I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
    $endgroup$
    – Apass.Jack
    1 hour ago


















1












$begingroup$

Convert $G$ to a directed graph $G'$ where we have two edges $(u,v)$ and $(v,u)$ in $G'$ for every edge $u,v$ in $G$. Let the length of $(u,v)$ be 1 if $v$ is a red node and 0 otherwise. Now run Dijkstra's algorithm on $G'$ from the starting node $s$ to the ending node $t$.





It is clear that the shortest path thus found passes as few red nodes as possible.



While we are running Dijkstra's algorithm, we are in one of two kinds of stages alternatively. One kind of stage is when we are exploring towards red nodes. The other kind of stage is when we are exploring towards blue nodes. Since each edge is checked/visited as most twice, the running time is $O(|E|)$.






share|cite|improve this answer











$endgroup$












  • $begingroup$
    Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
    $endgroup$
    – Hunter Dyer
    2 hours ago










  • $begingroup$
    I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
    $endgroup$
    – Apass.Jack
    2 hours ago











  • $begingroup$
    What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
    $endgroup$
    – Apass.Jack
    1 hour ago












Your Answer





StackExchange.ifUsing("editor", function ()
return StackExchange.using("mathjaxEditing", function ()
StackExchange.MarkdownEditor.creationCallbacks.add(function (editor, postfix)
StackExchange.mathjaxEditing.prepareWmdForMathJax(editor, postfix, [["$", "$"], ["\\(","\\)"]]);
);
);
, "mathjax-editing");

StackExchange.ready(function()
var channelOptions =
tags: "".split(" "),
id: "419"
;
initTagRenderer("".split(" "), "".split(" "), channelOptions);

StackExchange.using("externalEditor", function()
// Have to fire editor after snippets, if snippets enabled
if (StackExchange.settings.snippets.snippetsEnabled)
StackExchange.using("snippets", function()
createEditor();
);

else
createEditor();

);

function createEditor()
StackExchange.prepareEditor(
heartbeatType: 'answer',
autoActivateHeartbeat: false,
convertImagesToLinks: false,
noModals: true,
showLowRepImageUploadWarning: true,
reputationToPostImages: null,
bindNavPrevention: true,
postfix: "",
imageUploader:
brandingHtml: "Powered by u003ca class="icon-imgur-white" href="https://imgur.com/"u003eu003c/au003e",
contentPolicyHtml: "User contributions licensed under u003ca href="https://creativecommons.org/licenses/by-sa/3.0/"u003ecc by-sa 3.0 with attribution requiredu003c/au003e u003ca href="https://stackoverflow.com/legal/content-policy"u003e(content policy)u003c/au003e",
allowUrls: true
,
onDemand: true,
discardSelector: ".discard-answer"
,immediatelyShowMarkdownHelp:true
);



);













draft saved

draft discarded


















StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcs.stackexchange.com%2fquestions%2f106337%2ffind-a-path-from-s-to-t-using-as-few-red-nodes-as-possible%23new-answer', 'question_page');

);

Post as a guest















Required, but never shown

























2 Answers
2






active

oldest

votes








2 Answers
2






active

oldest

votes









active

oldest

votes






active

oldest

votes









4












$begingroup$

To solve this, you need to use $BFS$. But first, manipulate $G$ so that the path will always favor blue vertices.



The solution has 2 parts:



  1. Use $DFS$ on blue vertices only, to find all all-blue strongly connected components, or $SCC$. Let's denote each $SCC$ by $v'$. Now, each blue $v in v'$ will be "compressed" to a single vertex $u$, and an edge $(u,x)$ will be added for every $x in N(v')$.
    Note any such $x$ is necessarily red.
    This step costs $O(V+E) = O(E)$, since $DFS$ is $O(V+E)$, and you have at most $V$ blue vertices, which make no more than $E$ new edges to add.

Step 1 means all paths that are blue-only will be free. On the new graph, the $BFS$ will only consider the edges which pass through a red vertex.



  1. Use $BFS$ from $s$. That length of the path to $t$ will essentially be the shortest path under the constraint of least red vertices in the path.





share|cite|improve this answer











$endgroup$












  • $begingroup$
    the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
    $endgroup$
    – Kevin Wang
    1 hour ago










  • $begingroup$
    I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
    $endgroup$
    – Apass.Jack
    1 hour ago















4












$begingroup$

To solve this, you need to use $BFS$. But first, manipulate $G$ so that the path will always favor blue vertices.



The solution has 2 parts:



  1. Use $DFS$ on blue vertices only, to find all all-blue strongly connected components, or $SCC$. Let's denote each $SCC$ by $v'$. Now, each blue $v in v'$ will be "compressed" to a single vertex $u$, and an edge $(u,x)$ will be added for every $x in N(v')$.
    Note any such $x$ is necessarily red.
    This step costs $O(V+E) = O(E)$, since $DFS$ is $O(V+E)$, and you have at most $V$ blue vertices, which make no more than $E$ new edges to add.

Step 1 means all paths that are blue-only will be free. On the new graph, the $BFS$ will only consider the edges which pass through a red vertex.



  1. Use $BFS$ from $s$. That length of the path to $t$ will essentially be the shortest path under the constraint of least red vertices in the path.





share|cite|improve this answer











$endgroup$












  • $begingroup$
    the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
    $endgroup$
    – Kevin Wang
    1 hour ago










  • $begingroup$
    I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
    $endgroup$
    – Apass.Jack
    1 hour ago













4












4








4





$begingroup$

To solve this, you need to use $BFS$. But first, manipulate $G$ so that the path will always favor blue vertices.



The solution has 2 parts:



  1. Use $DFS$ on blue vertices only, to find all all-blue strongly connected components, or $SCC$. Let's denote each $SCC$ by $v'$. Now, each blue $v in v'$ will be "compressed" to a single vertex $u$, and an edge $(u,x)$ will be added for every $x in N(v')$.
    Note any such $x$ is necessarily red.
    This step costs $O(V+E) = O(E)$, since $DFS$ is $O(V+E)$, and you have at most $V$ blue vertices, which make no more than $E$ new edges to add.

Step 1 means all paths that are blue-only will be free. On the new graph, the $BFS$ will only consider the edges which pass through a red vertex.



  1. Use $BFS$ from $s$. That length of the path to $t$ will essentially be the shortest path under the constraint of least red vertices in the path.





share|cite|improve this answer











$endgroup$



To solve this, you need to use $BFS$. But first, manipulate $G$ so that the path will always favor blue vertices.



The solution has 2 parts:



  1. Use $DFS$ on blue vertices only, to find all all-blue strongly connected components, or $SCC$. Let's denote each $SCC$ by $v'$. Now, each blue $v in v'$ will be "compressed" to a single vertex $u$, and an edge $(u,x)$ will be added for every $x in N(v')$.
    Note any such $x$ is necessarily red.
    This step costs $O(V+E) = O(E)$, since $DFS$ is $O(V+E)$, and you have at most $V$ blue vertices, which make no more than $E$ new edges to add.

Step 1 means all paths that are blue-only will be free. On the new graph, the $BFS$ will only consider the edges which pass through a red vertex.



  1. Use $BFS$ from $s$. That length of the path to $t$ will essentially be the shortest path under the constraint of least red vertices in the path.






share|cite|improve this answer














share|cite|improve this answer



share|cite|improve this answer








edited 2 hours ago









templatetypedef

5,59911945




5,59911945










answered 4 hours ago









loxlox

1866




1866











  • $begingroup$
    the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
    $endgroup$
    – Kevin Wang
    1 hour ago










  • $begingroup$
    I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
    $endgroup$
    – Apass.Jack
    1 hour ago
















  • $begingroup$
    the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
    $endgroup$
    – Kevin Wang
    1 hour ago










  • $begingroup$
    I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
    $endgroup$
    – Apass.Jack
    1 hour ago















$begingroup$
the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
$endgroup$
– Kevin Wang
1 hour ago




$begingroup$
the graph is undirected, so step 1 should be to find all all-blue connected components, not SCCs, right?
$endgroup$
– Kevin Wang
1 hour ago












$begingroup$
I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
$endgroup$
– Apass.Jack
1 hour ago




$begingroup$
I believe that is a typo by lox. Yes, it should be connected components instead of SCC.
$endgroup$
– Apass.Jack
1 hour ago











1












$begingroup$

Convert $G$ to a directed graph $G'$ where we have two edges $(u,v)$ and $(v,u)$ in $G'$ for every edge $u,v$ in $G$. Let the length of $(u,v)$ be 1 if $v$ is a red node and 0 otherwise. Now run Dijkstra's algorithm on $G'$ from the starting node $s$ to the ending node $t$.





It is clear that the shortest path thus found passes as few red nodes as possible.



While we are running Dijkstra's algorithm, we are in one of two kinds of stages alternatively. One kind of stage is when we are exploring towards red nodes. The other kind of stage is when we are exploring towards blue nodes. Since each edge is checked/visited as most twice, the running time is $O(|E|)$.






share|cite|improve this answer











$endgroup$












  • $begingroup$
    Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
    $endgroup$
    – Hunter Dyer
    2 hours ago










  • $begingroup$
    I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
    $endgroup$
    – Apass.Jack
    2 hours ago











  • $begingroup$
    What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
    $endgroup$
    – Apass.Jack
    1 hour ago
















1












$begingroup$

Convert $G$ to a directed graph $G'$ where we have two edges $(u,v)$ and $(v,u)$ in $G'$ for every edge $u,v$ in $G$. Let the length of $(u,v)$ be 1 if $v$ is a red node and 0 otherwise. Now run Dijkstra's algorithm on $G'$ from the starting node $s$ to the ending node $t$.





It is clear that the shortest path thus found passes as few red nodes as possible.



While we are running Dijkstra's algorithm, we are in one of two kinds of stages alternatively. One kind of stage is when we are exploring towards red nodes. The other kind of stage is when we are exploring towards blue nodes. Since each edge is checked/visited as most twice, the running time is $O(|E|)$.






share|cite|improve this answer











$endgroup$












  • $begingroup$
    Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
    $endgroup$
    – Hunter Dyer
    2 hours ago










  • $begingroup$
    I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
    $endgroup$
    – Apass.Jack
    2 hours ago











  • $begingroup$
    What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
    $endgroup$
    – Apass.Jack
    1 hour ago














1












1








1





$begingroup$

Convert $G$ to a directed graph $G'$ where we have two edges $(u,v)$ and $(v,u)$ in $G'$ for every edge $u,v$ in $G$. Let the length of $(u,v)$ be 1 if $v$ is a red node and 0 otherwise. Now run Dijkstra's algorithm on $G'$ from the starting node $s$ to the ending node $t$.





It is clear that the shortest path thus found passes as few red nodes as possible.



While we are running Dijkstra's algorithm, we are in one of two kinds of stages alternatively. One kind of stage is when we are exploring towards red nodes. The other kind of stage is when we are exploring towards blue nodes. Since each edge is checked/visited as most twice, the running time is $O(|E|)$.






share|cite|improve this answer











$endgroup$



Convert $G$ to a directed graph $G'$ where we have two edges $(u,v)$ and $(v,u)$ in $G'$ for every edge $u,v$ in $G$. Let the length of $(u,v)$ be 1 if $v$ is a red node and 0 otherwise. Now run Dijkstra's algorithm on $G'$ from the starting node $s$ to the ending node $t$.





It is clear that the shortest path thus found passes as few red nodes as possible.



While we are running Dijkstra's algorithm, we are in one of two kinds of stages alternatively. One kind of stage is when we are exploring towards red nodes. The other kind of stage is when we are exploring towards blue nodes. Since each edge is checked/visited as most twice, the running time is $O(|E|)$.







share|cite|improve this answer














share|cite|improve this answer



share|cite|improve this answer








edited 1 hour ago

























answered 3 hours ago









Apass.JackApass.Jack

13.7k1940




13.7k1940











  • $begingroup$
    Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
    $endgroup$
    – Hunter Dyer
    2 hours ago










  • $begingroup$
    I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
    $endgroup$
    – Apass.Jack
    2 hours ago











  • $begingroup$
    What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
    $endgroup$
    – Apass.Jack
    1 hour ago

















  • $begingroup$
    Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
    $endgroup$
    – Hunter Dyer
    2 hours ago










  • $begingroup$
    I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
    $endgroup$
    – Apass.Jack
    2 hours ago











  • $begingroup$
    What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
    $endgroup$
    – Apass.Jack
    1 hour ago
















$begingroup$
Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
$endgroup$
– Hunter Dyer
2 hours ago




$begingroup$
Yeah that definitely works, but the runtime of Dijkstra's is O(|E| + |V|log|V|) which is more than O(|E|).
$endgroup$
– Hunter Dyer
2 hours ago












$begingroup$
I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
$endgroup$
– Apass.Jack
2 hours ago





$begingroup$
I will show shortly that this particular run of Dijkstra's algorithm actually takes $O(|E|)$ time.
$endgroup$
– Apass.Jack
2 hours ago













$begingroup$
What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
$endgroup$
– Apass.Jack
1 hour ago





$begingroup$
What is nice about this simple kind of transformation is that it also works when we are dealing with a weighted graph. Just add a sufficiently large weight to edges that end with a red node. Also this algorithm seems significantly easier to code as well.
$endgroup$
– Apass.Jack
1 hour ago


















draft saved

draft discarded
















































Thanks for contributing an answer to Computer Science Stack Exchange!


  • Please be sure to answer the question. Provide details and share your research!

But avoid


  • Asking for help, clarification, or responding to other answers.

  • Making statements based on opinion; back them up with references or personal experience.

Use MathJax to format equations. MathJax reference.


To learn more, see our tips on writing great answers.




draft saved


draft discarded














StackExchange.ready(
function ()
StackExchange.openid.initPostLogin('.new-post-login', 'https%3a%2f%2fcs.stackexchange.com%2fquestions%2f106337%2ffind-a-path-from-s-to-t-using-as-few-red-nodes-as-possible%23new-answer', 'question_page');

);

Post as a guest















Required, but never shown





















































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown

































Required, but never shown














Required, but never shown












Required, but never shown







Required, but never shown







Popular posts from this blog

Oświęcim Innehåll Historia | Källor | Externa länkar | Navigeringsmeny50°2′18″N 19°13′17″Ö / 50.03833°N 19.22139°Ö / 50.03833; 19.2213950°2′18″N 19°13′17″Ö / 50.03833°N 19.22139°Ö / 50.03833; 19.221393089658Nordisk familjebok, AuschwitzInsidan tro och existensJewish Community i OświęcimAuschwitz Jewish Center: MuseumAuschwitz Jewish Center

Valle di Casies Indice Geografia fisica | Origini del nome | Storia | Società | Amministrazione | Sport | Note | Bibliografia | Voci correlate | Altri progetti | Collegamenti esterni | Menu di navigazione46°46′N 12°11′E / 46.766667°N 12.183333°E46.766667; 12.183333 (Valle di Casies)46°46′N 12°11′E / 46.766667°N 12.183333°E46.766667; 12.183333 (Valle di Casies)Sito istituzionaleAstat Censimento della popolazione 2011 - Determinazione della consistenza dei tre gruppi linguistici della Provincia Autonoma di Bolzano-Alto Adige - giugno 2012Numeri e fattiValle di CasiesDato IstatTabella dei gradi/giorno dei Comuni italiani raggruppati per Regione e Provincia26 agosto 1993, n. 412Heraldry of the World: GsiesStatistiche I.StatValCasies.comWikimedia CommonsWikimedia CommonsValle di CasiesSito ufficialeValle di CasiesMM14870458910042978-6

Typsetting diagram chases (with TikZ?) Announcing the arrival of Valued Associate #679: Cesar Manara Planned maintenance scheduled April 17/18, 2019 at 00:00UTC (8:00pm US/Eastern)How to define the default vertical distance between nodes?Draw edge on arcNumerical conditional within tikz keys?TikZ: Drawing an arc from an intersection to an intersectionDrawing rectilinear curves in Tikz, aka an Etch-a-Sketch drawingLine up nested tikz enviroments or how to get rid of themHow to place nodes in an absolute coordinate system in tikzCommutative diagram with curve connecting between nodesTikz with standalone: pinning tikz coordinates to page cmDrawing a Decision Diagram with Tikz and layout manager