Floyd_Warshall.H

Go to the documentation of this file.

 
/*
                          Aleph_w
 
  Data structures & Algorithms
  version 2.0.0b
  https://github.com/lrleon/Aleph-w
 
  This file is part of Aleph-w library
 
  Copyright (c) 2002-2026 Leandro Rabindranath Leon
 
  Permission is hereby granted, free of charge, to any person obtaining a copy
  of this software and associated documentation files (the "Software"), to deal
  in the Software without restriction, including without limitation the rights
  to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  copies of the Software, and to permit persons to whom the Software is
  furnished to do so, subject to the following conditions:
 
  The above copyright notice and this permission notice shall be included in all
  copies or substantial portions of the Software.
 
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  SOFTWARE.
*/
 
 
# ifndef FLOYD_WARSHALL_H
# define FLOYD_WARSHALL_H
 
# include <sstream>
# include <iostream>
# include <limits>
# include <ahFunction.H>
# include <ahSort.H>
# include <tpl_indexArc.H>
# include <tpl_dynMat.H>
# include <tpl_graph.H>
# include <tpl_graph_utils.H>
# include <ah-errors.H>
 
namespace Aleph
{
  template <class GT,
            class Distance = Dft_Dist<GT>,
            class SA = Dft_Show_Arc<GT>>
  class Floyd_All_Shortest_Paths
  {
    typedef typename GT::Node Node;
    typedef typename GT::Arc Arc;
    typedef typename Distance::Distance_Type Distance_Type;
 
    DynArray<Node *> nodes;
    GT & g;
    const long n;
    const Distance_Type Inf;
    bool negative_cycle = false;
    DynMatrix<long> path_mat;
    DynMatrix<Distance_Type> dist;
    SA & sa;
 
  public:
    [[nodiscard]] constexpr bool has_negative_cycle() const noexcept { return negative_cycle; }
 
    const DynMatrix<long> &get_path_mat() const noexcept { return path_mat; }
 
    const DynMatrix<Distance_Type> &get_dist_mat() const noexcept
    {
      return dist;
    }
 
    DynArray<Node *> get_nodes() const noexcept { return nodes; }
 
    Node * select_node(long i) const noexcept { return nodes(i); }
 
 
    long index_node(Node *p) const
    {
      ah_invalid_argument_if(p == nullptr) << "Node pointer cannot be null";
      auto i = binary_search(nodes, p);
      ah_domain_error_if(i < 0 or i >= nodes.size() or nodes(i) != p)
        << "Floyd_All_Shortest_Paths::index_node() node not found";
      return i;
    }
 
  public:
    Floyd_All_Shortest_Paths(const GT & __g, SA & __sa)
      : g(const_cast<GT &>(__g)), n(g.get_num_nodes()),
        Inf(std::numeric_limits<Distance_Type>::max()),
        path_mat(n, n), dist(n, n), sa(__sa)
    {
      ah_invalid_argument_if(n <= 0) << "Graph must contain at least one node";
 
      long i = 0;
      nodes.reserve(n);
      for (typename GT::Node_Iterator it(g); it.has_curr(); it.next_ne())
        nodes.access(i++) = it.get_curr();
      in_place_sort(nodes); // sort by node pointer value
 
      dist.allocate();
      path_mat.allocate(); { // initialize matrices
        IndexArc<GT, Rand_Tree, SA> arcs(g, true, sa);
 
        for (long i = 0; i < n; ++i)
          for (long j = 0; j < n; ++j)
            path_mat(i, j) = -1;
 
        for (long i = 0; i < n; ++i)
          {
            Node *src = nodes(i);
            for (long j = 0; j < n; ++j)
              {
                if (i == j)
                  {
                    dist(i, j) = 0;
                    path_mat(i, j) = j;
                    continue;
                  }
 
                Node *tgt = nodes(j);
                Arc *arc = arcs.search_directed(src, tgt);
                if (arc == nullptr)
                  {
                    dist(i, j) = Inf;
                    continue;
                  }
 
                dist(i, j) = Distance()(arc);
                path_mat(i, j) = j;
              }
          }
      }
 
      for (long k = 0; k < n; ++k)
        for (long i = 0; i < n; ++i)
          {
            const Distance_Type & dik = dist(i, k);
            for (long j = 0; j < n; ++j)
              {
                const Distance_Type & dij = dist(i, j);
                if (dik == Inf)
                  continue;
 
                const Distance_Type & dkj = dist(k, j);
                if (dkj == Inf)
                  continue;
 
                // Calculate new distance through intermediate node k.
                // Important: avoid undefined behavior on signed overflow
                // (e.g. Inf - negative) and handle negative weights safely.
                bool can_add = true;
                if constexpr (std::numeric_limits<Distance_Type>::is_integer)
                  {
                    if constexpr (std::numeric_limits<Distance_Type>::is_signed)
                      {
                        const Distance_Type maxv = std::numeric_limits<Distance_Type>::max();
                        const Distance_Type minv = std::numeric_limits<Distance_Type>::lowest();
                        if (dkj > 0)
                          can_add = (dik <= maxv - dkj);
                        else if (dkj < 0)
                          can_add = (dik >= minv - dkj);
                      }
                    else
                      {
                        can_add = (dik <= std::numeric_limits<Distance_Type>::max() - dkj);
                      }
                  }
 
                if (!can_add)
                  continue;
 
                const Distance_Type new_dist = dik + dkj;
                if (new_dist < dij)
                  {
                    dist(i, j) = new_dist;
                    path_mat(i, j) = path_mat(i, k);
                  }
              }
          }
 
      // Check for negative cycles on the diagonal
      for (long idx = 0; idx < n; ++idx)
        if (dist(idx, idx) < 0)
          {
            negative_cycle = true;
            break;
          }
    }
 
    Floyd_All_Shortest_Paths(const GT & g, SA && sa = SA())
      : Floyd_All_Shortest_Paths(g, sa) {}
 
    std::string entry(const Distance_Type & e) const
    {
      if (e == Inf)
        return "Inf";
 
      std::stringstream ss;
      ss << e;
      return ss.str();
    }
 
    static void print(const DynMatrix<Distance_Type> & dist)
    {
      const Distance_Type Inf = std::numeric_limits<Distance_Type>::max();
      const int n = dist.rows();
      for (int i = 0; i < n; ++i)
        {
          for (int j = 0; j < n; ++j)
            if (dist.access(i, j) == Inf)
              std::cout << "inf ";
            else
              std::cout << dist.access(i, j) << " ";
          std::cout << '\n';
        }
      std::cout << '\n';
    }
 
    Path<GT> get_min_path(const long src_idx, const long tgt_idx) const
    {
      ah_out_of_range_error_if(src_idx < 0 or src_idx >= n)
        << "Source index out of range";
      ah_out_of_range_error_if(tgt_idx < 0 or tgt_idx >= n)
        << "Target index out of range";
 
      if (dist(src_idx, tgt_idx) == Inf)
        return Path<GT>(g);
 
      auto src = nodes(src_idx);
      Path<GT> path(g, src);
 
      if (src_idx == tgt_idx)
        return path;
 
      long i = src_idx;
      while (true)
        {
          const auto & k = path_mat(i, tgt_idx);
          auto p = nodes(k);
          path.append_directed(p);
          if (k == tgt_idx)
            break;
          i = k;
        }
 
      return path;
    }
 
    Path<GT> get_min_path(typename GT::Node *src,
                          typename GT::Node *tgt) const
    {
      return get_min_path(index_node(src), index_node(tgt));
    }
  };
} // end namespace Aleph
 
# endif // FLOYD_WARSHALL_H