ó
    …~i·&  ã                   óV  • S r SSKrSSKJr  / SQr\" S5      \R                  S 5       5       r\" S5      \R                  SS j5       5       r\" S5      \R                  S 5       5       r	\" S5      \R                  S	 5       5       r
\" S5      \R                  " S
S9SS j5       5       rg)zStrongly connected components.é    N)Únot_implemented_for)Ú$number_strongly_connected_componentsÚstrongly_connected_componentsÚis_strongly_connectedÚ&kosaraju_strongly_connected_componentsÚcondensationÚ
undirectedc              #   ó$  #   • 0 n0 n[        5       n/ nSnU  Vs0 s H  of[        U R                  U   5      _M     nnU  GHF  nXƒ;  d  M  U/n	U	(       d  M  U	S   nXa;  a	  US-   nXQU'   Sn
Xv    H  nX±;  d  M
  U	R                  U5        Sn
  O   U
(       aä  X   X&'   U R                  U    H<  nX³;  d  M
  X   X   :”  a  [	        X&   X+   /5      X&'   M)  [	        X&   X   /5      X&'   M>     U	R                  5         X&   X   :X  ad  U1nU(       aD  XS      X   :”  a7  UR                  5       nUR                  U5        U(       a  XS      X   :”  a  M7  UR                  U5        Uv •  OUR                  U5        U	(       a  GM/  GMI     gs  snf 7f)a  Generate nodes in strongly connected components of graph.

Parameters
----------
G : NetworkX Graph
    A directed graph.

Returns
-------
comp : generator of sets
    A generator of sets of nodes, one for each strongly connected
    component of G.

Raises
------
NetworkXNotImplemented
    If G is undirected.

Examples
--------
Generate a sorted list of strongly connected components, largest first.

>>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
>>> nx.add_cycle(G, [10, 11, 12])
>>> [
...     len(c)
...     for c in sorted(nx.strongly_connected_components(G), key=len, reverse=True)
... ]
[4, 3]

If you only want the largest component, it's more efficient to
use max instead of sort.

>>> largest = max(nx.strongly_connected_components(G), key=len)

See Also
--------
connected_components
weakly_connected_components
kosaraju_strongly_connected_components

Notes
-----
Uses Tarjan's algorithm[1]_ with Nuutila's modifications[2]_.
Nonrecursive version of algorithm.

References
----------
.. [1] Depth-first search and linear graph algorithms, R. Tarjan
   SIAM Journal of Computing 1(2):146-160, (1972).

.. [2] On finding the strongly connected components in a directed graph.
   E. Nuutila and E. Soisalon-Soinen
   Information Processing Letters 49(1): 9-14, (1994)..

r   éÿÿÿÿé   TFN)ÚsetÚiterÚ_adjÚappendÚminÚpopÚaddÚupdate)ÚGÚpreorderÚlowlinkÚ	scc_foundÚ	scc_queueÚiÚvÚ	neighborsÚsourceÚqueueÚdoneÚwÚsccÚks                 Ún/home/mande/repo/quber/.venv/lib/python3.13/site-packages/networkx/algorithms/components/strongly_connected.pyr   r      s’  é € ðv €HØ€GÜ“€IØ€IØ	€AÙ-.Ó/ªQ¨”D˜Ÿ™ ™“OÒ#©Q€IÐ/ÜˆØÕ"Ø�HˆEß�%Ø˜"‘I�ØÓ$Ø˜A™�AØ"#˜Q‘KØ�Ø"œ�AØÕ(ØŸ™ QœØ$˜Ùñ	 &ö
 Ø!)¡�G‘JØŸV™V AœY˜ØÕ-Ø'™{¨X©[Ó8Ü-0°'±*¸g¹jÐ1IÓ-J £
ä-0°'±*¸h¹kÐ1JÓ-K £
ñ 'ð —I‘I”KØ‘z X¡[Ó0Ø ˜c˜Þ'¨H¸r±]Ñ,CÀhÁkÓ,QØ )§¡£˜AØŸG™G AœJö (¨H¸r±]Ñ,CÀhÁkÕ,Qð "×(Ñ(¨Ô-Ø!›	à!×(Ñ(¨Ô+÷9 ”%ò ùò 0ùs4   ‚F™"F»FÁ
FÁFÁ99FÂ6BFÅ.FÆFc              #   ón  #   • [        [        R                  " U R                  SS9US95      n[	        U5      n[        5       nU(       aê  [	        U5      U:  aÚ  UR                  5       nXT;   a  M-  U1nUR                  U5        U/nU(       a‡  [	        U5      U:  ax  UR                  5       nU R                  U    H=  n	X”;  d  M
  UR                  U	5        UR                  U	5        UR                  U	5        M?     U(       a  [	        U5      U:  a  Mx  Uv •  U(       a  [	        U5      U:  a  MØ  gggg7f)a  Generate nodes in strongly connected components of graph.

Parameters
----------
G : NetworkX Graph
    A directed graph.

source : node, optional (default=None)
    Specify a node from which to start the depth-first search.
    If not provided, the algorithm will start from an arbitrary node.

Yields
------
set
    A set of all nodes in a strongly connected component of `G`.

Raises
------
NetworkXNotImplemented
    If `G` is undirected.

NetworkXError
    If `source` is not a node in `G`.

Examples
--------
Generate a list of strongly connected components of a graph:

>>> G = nx.cycle_graph(4, create_using=nx.DiGraph())
>>> nx.add_cycle(G, [10, 11, 12])
>>> sorted(nx.kosaraju_strongly_connected_components(G), key=len, reverse=True)
[{0, 1, 2, 3}, {10, 11, 12}]

If you only want the largest component, it's more efficient to
use `max()` instead of `sorted()`.

>>> max(nx.kosaraju_strongly_connected_components(G), key=len)
{0, 1, 2, 3}

See Also
--------
strongly_connected_components

Notes
-----
Uses Kosaraju's algorithm.
F)Úcopy)r   N)
ÚlistÚnxÚdfs_postorder_nodesÚreverseÚlenr   r   r   r   r   )
r   r   ÚpostÚnÚseenÚrÚnewÚstackr   r    s
             r#   r   r   r   sî   é € ôd ”×&Ò& q§y¡y°e yÐ'<ÀVÑLÓM€DÜˆD‹	€AÜ‹5€DÞ
”3�t“9˜q“=Ø�H‰H‹JˆØ‹9ÙØˆcˆØ�‰�ŒØ�ˆÞœ˜D›	 A›Ø—	‘	“ˆAØ—V‘V˜A”Y�Ø•=Ø—G‘G˜A”JØ—H‘H˜Q”KØ—L‘L –Oñ	 ö œ˜D›	 A�ð Š	ö ”3�t“9˜q–=ˆ$�=ˆ$ùs   ‚C D5ÃAD5ÄD5Ä1D5c                 ó8   • [        S [        U 5       5       5      $ )aE  Returns number of strongly connected components in graph.

Parameters
----------
G : NetworkX graph
   A directed graph.

Returns
-------
n : integer
   Number of strongly connected components

Raises
------
NetworkXNotImplemented
    If G is undirected.

Examples
--------
>>> G = nx.DiGraph(
...     [(0, 1), (1, 2), (2, 0), (2, 3), (4, 5), (3, 4), (5, 6), (6, 3), (6, 7)]
... )
>>> nx.number_strongly_connected_components(G)
3

See Also
--------
strongly_connected_components
number_connected_components
number_weakly_connected_components

Notes
-----
For directed graphs only.
c              3   ó&   #   • U  H  nS v •  M	     g7f)r   N© )Ú.0r!   s     r#   Ú	<genexpr>Ú7number_strongly_connected_components.<locals>.<genexpr>Þ   s   é € Ð=Ò<�S�qÒ<ùs   ‚)Úsumr   ©r   s    r#   r   r   ¸   s   € ôL Ñ=Ô9¸!Ô<Ó=Ó=Ð=ó    c                 óž   • [        U 5      S:X  a  [        R                  " S5      e[        [        [	        U 5      5      5      [        U 5      :H  $ )aÓ  Test directed graph for strong connectivity.

A directed graph is strongly connected if and only if every vertex in
the graph is reachable from every other vertex.

Parameters
----------
G : NetworkX Graph
   A directed graph.

Returns
-------
connected : bool
  True if the graph is strongly connected, False otherwise.

Examples
--------
>>> G = nx.DiGraph([(0, 1), (1, 2), (2, 3), (3, 0), (2, 4), (4, 2)])
>>> nx.is_strongly_connected(G)
True
>>> G.remove_edge(2, 3)
>>> nx.is_strongly_connected(G)
False

Raises
------
NetworkXNotImplemented
    If G is undirected.

See Also
--------
is_weakly_connected
is_semiconnected
is_connected
is_biconnected
strongly_connected_components

Notes
-----
For directed graphs only.
r   z-Connectivity is undefined for the null graph.)r*   r'   ÚNetworkXPointlessConceptÚnextr   r8   s    r#   r   r   á   sG   € ôX ˆ1ƒv�ƒ{Ü×)Ò)Ø?ó
ð 	
ô ŒtÔ1°!Ó4Ó5Ó6¼#¸a»&Ñ@Ð@r9   T)Úreturns_graphc                 óÔ  ^^• Uc  [         R                  " U 5      n0 m0 n[         R                  " 5       nTUR                  S'   [	        U 5      S:X  a  U$ [        U5       H%  u  mnXBT'   TR                  U4S jU 5       5        M'     TS-   nUR                  [        U5      5        UR                  U4S jU R                  5        5       5        [         R                  " X2S5        U$ )aÏ  Returns the condensation of G.

The condensation of G is the graph with each of the strongly connected
components contracted into a single node.

Parameters
----------
G : NetworkX DiGraph
   A directed graph.

scc:  list or generator (optional, default=None)
   Strongly connected components. If provided, the elements in
   `scc` must partition the nodes in `G`. If not provided, it will be
   calculated as scc=nx.strongly_connected_components(G).

Returns
-------
C : NetworkX DiGraph
   The condensation graph C of G.  The node labels are integers
   corresponding to the index of the component in the list of
   strongly connected components of G.  C has a graph attribute named
   'mapping' with a dictionary mapping the original nodes to the
   nodes in C to which they belong.  Each node in C also has a node
   attribute 'members' with the set of original nodes in G that
   form the SCC that the node in C represents.

Raises
------
NetworkXNotImplemented
    If G is undirected.

Examples
--------
Contracting two sets of strongly connected nodes into two distinct SCC
using the barbell graph.

>>> G = nx.barbell_graph(4, 0)
>>> G.remove_edge(3, 4)
>>> G = nx.DiGraph(G)
>>> H = nx.condensation(G)
>>> H.nodes.data()
NodeDataView({0: {'members': {0, 1, 2, 3}}, 1: {'members': {4, 5, 6, 7}}})
>>> H.graph["mapping"]
{0: 0, 1: 0, 2: 0, 3: 0, 4: 1, 5: 1, 6: 1, 7: 1}

Contracting a complete graph into one single SCC.

>>> G = nx.complete_graph(7, create_using=nx.DiGraph)
>>> H = nx.condensation(G)
>>> H.nodes
NodeView((0,))
>>> H.nodes.data()
NodeDataView({0: {'members': {0, 1, 2, 3, 4, 5, 6}}})

Notes
-----
After contracting all strongly connected components to a single node,
the resulting graph is a directed acyclic graph.

Úmappingr   c              3   ó*   >#   • U  H  oT4v •  M
     g 7f©Nr3   )r4   r,   r   s     €r#   r5   Úcondensation.<locals>.<genexpr>_  s   øé € Ð1¢y !˜1•v¢yùs   ƒr   c              3   óX   >#   • U  H  u  pTU   TU   :w  d  M  TU   TU   4v •  M!     g 7frA   r3   )r4   Úur   r?   s      €r#   r5   rB   b  s6   øé € ð Ú-6¡T Q¸'À!¹*ÈÐPQÉ
Ñ:RÓ ˆ�‰�W˜Q‘ZÕ ªYùs   ƒ*™*Úmembers)r'   r   ÚDiGraphÚgraphr*   Ú	enumerater   Úadd_nodes_fromÚrangeÚadd_edges_fromÚedgesÚset_node_attributes)r   r!   rE   ÚCÚ	componentÚnumber_of_componentsr   r?   s         @@r#   r   r     sÑ   ù€ ð~ �{Ü×.Ò.¨qÓ1ˆØ€GØ€GÜ
�
Š
‹€Aà €A‡G�GˆIÑÜ
ˆ1ƒv�ƒ{ØˆÜ! #ž‰ˆˆ9Ø�‰
Ø�‰Ô1¡yÓ1Ö1ñ 'ð ˜q™5ÐØ×Ñ”UÐ/Ó0Ô1Ø×Ñô Ø-.¯W©W¬Yóô ô ×Ò˜1 yÔ1Ø€Hr9   rA   )Ú__doc__Únetworkxr'   Únetworkx.utils.decoratorsr   Ú__all__Ú_dispatchabler   r   r   r   r   r3   r9   r#   Ú<module>rV      sé   ðÙ $ã Ý 9ò€ñ �\Ó"Ø×Ññ^,ó ó #ð^,ñB �\Ó"Ø×ÑóAó ó #ðAñH �\Ó"Ø×Ññ$>ó ó #ð$>ñN �\Ó"Ø×Ññ/Aó ó #ð/Añd �\Ó"Ø×Ò Ñ%óPó &ó #ñPr9   