sagemathgh-40547: Update NC k shortest simple path for Undirected graphs
    
<!-- ^ Please provide a concise and informative title. -->
<!-- ^ Don't put issue numbers in the title, do this in the PR
description below. -->
<!-- ^ For example, instead of "Fixes sagemath#12345" use "Introduce new method
to calculate 1 + 2". -->
<!-- v Describe your changes below in detail. -->
<!-- v Why is this change required? What problem does it solve? -->
<!-- v If this PR resolves an open issue, please link to it here. For
example, "Fixes sagemath#12345". -->

Update nc_k_shortest_simple_path algorithm for undirected graphs.

### 📝 Checklist

<!-- Put an `x` in all the boxes that apply. -->

- [x] The title is concise and informative.
- [x] The description explains in detail what this PR is about.
- [x] I have linked a relevant issue or discussion.
- [x] I have created tests covering the changes.
- [ ] I have updated the documentation and checked the documentation
preview.

### ⌛ Dependencies

<!-- List all open PRs that this PR logically depends on. For example,
-->
<!-- - sagemath#12345: short description why this is a dependency -->
<!-- - sagemath#34567: ... -->
sagemath#40510
    
URL: sagemath#40547
Reported by: Yuta Inoue
Reviewer(s): David Coudert

Author: Release Manager

src/sage/graphs/path_enumeration.pyx

@@ -332,12 +332,13 @@ def shortest_simple_paths(self, source, target, weight_function=None,
       supported:
 
       - ``'Yen'`` -- Yen's algorithm [Yen1970]_
+        (:meth:`~sage.graphs.path_enumeration.yen_k_shortest_simple_paths`)
 
-      - ``'Feng'`` -- an improved version of Yen's algorithm but that works only
-        for directed graphs [Feng2014]_
+      - ``'Feng'`` -- an improved version of Yen's algorithm [Feng2014]_
+        (:meth:`~sage.graphs.path_enumeration.feng_k_shortest_simple_paths`)
 
-      - ``'PNC'`` -- an improved version of Feng's algorithm. This also works only
-        for directed graphs [ACN2023]_
+      - ``'PNC'`` -- an improved version of Feng's algorithm [ACN2023]_
+        (:meth:`~sage.graphs.path_enumeration.pnc_k_shortest_simple_paths`)
 
     - ``report_edges`` -- boolean (default: ``False``); whether to report paths
       as list of vertices (default) or list of edges. When set to ``False``, the
@@ -471,13 +472,6 @@ def shortest_simple_paths(self, source, target, weight_function=None,
            ('101', '011', 1),
            ('011', '111', 1)])]
 
-    Feng's algorithm cannot be used on undirected graphs::
-
-        sage: list(graphs.PathGraph(2).shortest_simple_paths(0, 1, algorithm='Feng'))
-        Traceback (most recent call last):
-        ...
-        ValueError: Feng's algorithm works only for directed graphs
-
     If the algorithm is not implemented::
 
         sage: list(g.shortest_simple_paths(1, 5, algorithm='tip top'))
@@ -528,7 +522,7 @@ def shortest_simple_paths(self, source, target, weight_function=None,
         sage: s == t
         True
 
-    Check that "Yen" and "Feng" provide same results on random digraphs::
+    Check that "Yen", "Feng" and "PNC" provide same results on random digraphs::
 
         sage: G = digraphs.RandomDirectedGNP(30, .05)
         sage: while not G.is_strongly_connected():
@@ -546,6 +540,23 @@ def shortest_simple_paths(self, source, target, weight_function=None,
         ....:         raise ValueError(f"something goes wrong u={u}, v={v}, G={G.edges()}!")
         ....:     if i == 100:
         ....:         break
+
+    Check that "Yen", "Feng" and "PNC" provide same results on random undirected graphs::
+
+        sage: G = graphs.RandomGNP(30, .5)
+        sage: for u, v in list(G.edges(labels=False, sort=False)):
+        ....:     G.set_edge_label(u, v, randint(1, 10))
+        sage: V = G.vertices(sort=False)
+        sage: shuffle(V)
+        sage: u, v = V[:2]
+        sage: it_Y = G.shortest_simple_paths(u, v, by_weight=True, report_weight=True, algorithm='Yen')
+        sage: it_F = G.shortest_simple_paths(u, v, by_weight=True, report_weight=True, algorithm='Feng')
+        sage: it_P = G.shortest_simple_paths(u, v, by_weight=True, report_weight=True, algorithm='PNC')
+        sage: for i, (y, f, p) in enumerate(zip(it_Y, it_F, it_P)):
+        ....:     if y[0] != f[0] or y[0] != p[0]:
+        ....:         raise ValueError(f"something goes wrong u={u}, v={v}, G={G.edges()}!")
+        ....:     if i == 100:
+        ....:         break
     """
     if source not in self:
         raise ValueError("vertex '{}' is not in the graph".format(source))
@@ -569,9 +580,6 @@ def shortest_simple_paths(self, source, target, weight_function=None,
         algorithm = "Feng" if self.is_directed() else "Yen"
 
     if algorithm in ("Feng", "PNC"):
-        if not self.is_directed():
-            raise ValueError(f"{algorithm}'s algorithm works only for directed graphs")
-
         yield from nc_k_shortest_simple_paths(self, source=source, target=target,
                                               weight_function=weight_function,
                                               by_weight=by_weight, check_weight=check_weight,
@@ -897,8 +905,6 @@ def nc_k_shortest_simple_paths(self, source, target, weight_function=None,
     Return an iterator over the simple paths between a pair of vertices in
     increasing order of weights.
 
-    Works only for directed graphs.
-
     For unweighted graphs, paths are returned in order of increasing number
     of edges.
 
@@ -1001,6 +1007,14 @@ def nc_k_shortest_simple_paths(self, source, target, weight_function=None,
          (40.0, [(1, 2, 20), (2, 5, 20)]),
          (60.0, [(1, 4, 30), (4, 5, 30)])]
 
+    Algorithm works for undirected graphs as well::
+
+        sage: g = Graph([(1, 2, 20), (1, 3, 10), (1, 4, 30), (2, 5, 20), (3, 5, 10), (4, 5, 30)])
+        sage: list(nc_k_shortest_simple_paths(g, 5, 1, by_weight=True))
+        [[5, 3, 1], [5, 2, 1], [5, 4, 1]]
+        sage: [len(P) for P in nc_k_shortest_simple_paths(g, 5, 1)]
+        [3, 3, 3]
+
     TESTS::
 
         sage: from sage.graphs.path_enumeration import nc_k_shortest_simple_paths
@@ -1150,9 +1164,6 @@ def nc_k_shortest_simple_paths(self, source, target, weight_function=None,
         sage: for i in range(len(A) - 1):
         ....:     assert A[i] <= A[i + 1]
     """
-    if not self.is_directed():
-        raise ValueError("this algorithm works only for directed graphs")
-
     if source not in self:
         raise ValueError("vertex '{}' is not in the graph".format(source))
     if target not in self:
@@ -1164,6 +1175,11 @@ def nc_k_shortest_simple_paths(self, source, target, weight_function=None,
 
     if self.has_loops() or self.allows_multiple_edges():
         G = self.to_simple(to_undirected=False, keep_label='min', immutable=False)
+        if not G.is_directed():
+            G = G.to_directed()
+    elif not self.is_directed():
+        # Turn the graph into a mutable directed graph
+        G = self.to_directed(data_structure='sparse')
     else:
         G = self.copy(immutable=False)
 
@@ -1416,8 +1432,6 @@ def feng_k_shortest_simple_paths(self, source, target, weight_function=None,
     Return an iterator over the simple paths between a pair of vertices in
     increasing order of weights.
 
-    Works only for directed graphs.
-
     For unweighted graphs, paths are returned in order of increasing number
     of edges.
 
@@ -1487,8 +1501,6 @@ def pnc_k_shortest_simple_paths(self, source, target, weight_function=None,
     Return an iterator over the simple paths between a pair of vertices in
     increasing order of weights.
 
-    Works only for directed graphs.
-
     In case of weighted graphs, negative weights are not allowed.
 
     If ``source`` is the same vertex as ``target``, then ``[[source]]`` is