connected-k-center 0.1__tar.gz

connected_k_center-0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Algorithms and Data Structures Group of the Heinrich Heine University Düsseldorf
+
+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.

connected_k_center-0.1/PKG-INFO

@@ -0,0 +1,30 @@
+Metadata-Version: 2.4
+Name: connected-k-center
+Version: 0.1
+Summary: Implementations of algorithms for connected k-center on path graphs.
+License: MIT
+License-File: LICENSE
+Author: Lukas Drexler
+Author-email: lukas.drexler@hhu.de
+Requires-Python: >=3.10,<4.0
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: numpy (>=1.26.4,<2.0.0)
+Requires-Dist: scikit-learn (>=1.6.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# Connected Path Graph Clustering
+
+A library for algorithms for the connected k-center problem (as described in [1]). In this problem setting, the input consists of a point set $P$ and a desired number of centers $k$, along with a *connectivity graph* $G = (P,E)$. The goal is to partition $P$ into (at most) $k$ *clusters* $C_1, \ldots, C_k$, such that, for every $i$, the subgraph of $G$ induced by $C_i$ is connected.
+
+As of now, only an algorithm for path graphs is implemented. A path graph is a graph whose connected components are simple paths. This algorithm was developed by Johanna Hillebrand and implemented by Julius Mann.
+
+
+### References
+[1] Drexler, L., Eube, J., Luo, K., Reineccius, D., Röglin, H., Schmidt, M., & Wargalla, J. (2024). Connected k-center and k-diameter clustering. Algorithmica, 86(11), 3425-3464.
+

connected_k_center-0.1/README.md

@@ -0,0 +1,9 @@
+# Connected Path Graph Clustering
+
+A library for algorithms for the connected k-center problem (as described in [1]). In this problem setting, the input consists of a point set $P$ and a desired number of centers $k$, along with a *connectivity graph* $G = (P,E)$. The goal is to partition $P$ into (at most) $k$ *clusters* $C_1, \ldots, C_k$, such that, for every $i$, the subgraph of $G$ induced by $C_i$ is connected.
+
+As of now, only an algorithm for path graphs is implemented. A path graph is a graph whose connected components are simple paths. This algorithm was developed by Johanna Hillebrand and implemented by Julius Mann.
+
+
+### References
+[1] Drexler, L., Eube, J., Luo, K., Reineccius, D., Röglin, H., Schmidt, M., & Wargalla, J. (2024). Connected k-center and k-diameter clustering. Algorithmica, 86(11), 3425-3464.

connected_k_center-0.1/build_extension.py

@@ -0,0 +1,69 @@
+import sys
+from typing import Any, Dict, List
+
+from setuptools import Extension
+from setuptools.command.build_ext import build_ext
+from setuptools.errors import CompileError
+
+extension = Extension(
+    name="connected_k_center._core",
+    sources=[
+        "connected_k_center/_core.cpp",
+        "connected_k_center/cpp/solver.cpp",
+        "connected_k_center/cpp/clustering.cpp",
+        "connected_k_center/cpp/geometry.cpp",
+        "connected_k_center/cpp/graph.cpp",
+    ],
+
+    include_dirs=["connected_k_center/cpp"],
+)
+
+
+class BuildExt(build_ext):
+    """Compiler-aware build: select C++17 and OpenMP flags per toolchain.
+
+    OpenMP parallelises the pairwise-distance and per-component computations.
+    The way it is enabled differs by compiler:
+      * GCC / Linux clang: ``-fopenmp`` for both compile and link.
+      * Apple clang (macOS): ``-Xpreprocessor -fopenmp`` and link ``libomp``
+        (its headers/libs come from Homebrew via CPPFLAGS/LDFLAGS).
+      * MSVC (Windows): ``/openmp`` and ``/std:c++17`` (it ignores ``-std=``).
+    """
+
+    def build_extensions(self) -> None:
+        if self.compiler.compiler_type == "msvc":
+            compile_args = ["/std:c++17", "/openmp", "/EHsc"]
+            link_args: List[str] = []
+        elif sys.platform == "darwin":
+            compile_args = ["-std=c++17", "-Xpreprocessor", "-fopenmp"]
+            link_args = ["-lomp"]
+        else:
+            compile_args = ["-std=c++17", "-fopenmp"]
+            link_args = ["-fopenmp"]
+
+        for extension in self.extensions:
+            extension.extra_compile_args = (
+                list(extension.extra_compile_args) + compile_args
+            )
+            extension.extra_link_args = (
+                list(extension.extra_link_args) + link_args
+            )
+
+        try:
+            build_ext.build_extensions(self)
+        except CompileError:
+            # Workaround Issue #2.
+            # '-stdlib=libc++' is added so the code can compile on macOS with
+            # Anaconda. Irrelevant (and unsupported) for MSVC.
+            if self.compiler.compiler_type == "msvc":
+                raise
+            for extension in self.extensions:
+                extension.extra_compile_args.append("-stdlib=libc++")
+                extension.extra_link_args.append("-stdlib=libc++")
+            build_ext.build_extensions(self)
+
+
+def build(setup_kwargs: Dict[str, Any]) -> None:
+    setup_kwargs.update(
+        {"ext_modules": [extension], "cmdclass": {"build_ext": BuildExt}}
+    )

connected_k_center-0.1/connected_k_center/__init__.py

@@ -0,0 +1,4 @@
+from connected_k_center.core import PathCKC
+from connected_k_center.io import read_instance
+
+__all__ = ["PathCKC", "read_instance"]

connected_k_center-0.1/connected_k_center/_core.cpp

@@ -0,0 +1,107 @@
+#include <Python.h>
+
+#include <vector>
+
+#include "connected_k_center/types.hpp"
+#include "connected_k_center/solver.hpp"
+
+typedef unsigned int uint;
+
+// Build the list of ckc::Point from a flat, row-major coordinate array.
+// Each point's id is its row index, matching the indexing used for the
+// adjacency list and the output labels.
+static std::vector<ckc::Point> array_to_points(const double *coords, uint n, uint d)
+{
+    std::vector<ckc::Point> points;
+    points.reserve(n);
+    for (uint i = 0; i < n; ++i)
+    {
+        ckc::Point p;
+        p.id = static_cast<int>(i);
+        p.coords.assign(coords + i * d, coords + i * d + d);
+        points.push_back(std::move(p));
+    }
+    return points;
+}
+
+// Rebuild the path-graph adjacency from per-point component ids. Points that
+// share a component id are chained in array order, reproducing the implicit
+// path structure of the original CSV format (consecutive rows linked, a new
+// component id starting a fresh path).
+static ckc::AdjacencyList component_ids_to_adjacency(const int *component_ids, uint n)
+{
+    ckc::AdjacencyList adj(n);
+    for (uint i = 1; i < n; ++i)
+    {
+        if (component_ids[i] == component_ids[i - 1])
+        {
+            adj[i].push_back(static_cast<int>(i - 1));
+            adj[i - 1].push_back(static_cast<int>(i));
+        }
+    }
+    return adj;
+}
+
+extern "C"
+{
+// "__declspec(dllexport)" causes the function to be exported when compiling on Windows.
+// Otherwise the symbol is not exported and ctypes raises
+//   "AttributeError: function 'connected_k_center_c' not found".
+#if defined(_WIN32) || defined(__CYGWIN__)
+    __declspec(dllexport)
+#endif
+    double
+    connected_k_center_c(double *coords,        // input points, row-major (n x d)
+                         int *component_ids,     // length n, path membership (array order = path order)
+                         uint n,                 // number of points
+                         uint d,                 // number of features
+                         int k,                  // cluster budget (result uses at most k)
+                         int metric,             // distance metric used by the algorithm (0 for RMSE, 1 for Euclidean, 2 for Manhattan)
+                         int *out_labels,        // length n, filled with the assigned center id per point
+                         int *out_num_centers)   // scalar, filled with the total number of centers used
+    {
+        std::vector<ckc::Point> points = array_to_points(coords, n, d);
+        ckc::AdjacencyList adj = component_ids_to_adjacency(component_ids, n);
+
+        ckc::SolverResult result = ckc::connected_k_center(k, points, adj, static_cast<ckc::Metric>(metric));
+
+        // optimal_radius < 0 signals that no feasible clustering was found.
+        if (result.optimal_radius < 0.0)
+        {
+            *out_num_centers = 0;
+            return -1.0;
+        }
+
+        // Default to -1 so any point left unassigned is detectable on the Python side.
+        for (uint i = 0; i < n; ++i)
+        {
+            out_labels[i] = -1;
+        }
+
+        int num_centers = 0;
+        for (const auto &component : result.components)
+        {
+            num_centers += component.num_centers;
+            for (const auto &assignment : component.assignments)
+            {
+                out_labels[assignment.point_id] = assignment.center_id;
+            }
+        }
+
+        *out_num_centers = num_centers;
+        return result.optimal_radius;
+    }
+} // extern "C"
+
+static struct PyModuleDef _coremodule = {
+    PyModuleDef_HEAD_INIT,
+    "connected_k_center._core",
+    NULL,
+    -1,
+    NULL,
+};
+
+PyMODINIT_FUNC PyInit__core(void)
+{
+    return PyModule_Create(&_coremodule);
+}

connected_k_center-0.1/connected_k_center/core.py

@@ -0,0 +1,153 @@
+import ctypes
+from typing import Any, Optional, Sequence
+
+import numpy as np
+from sklearn.base import BaseEstimator, ClusterMixin
+from sklearn.utils.validation import validate_data
+
+import connected_k_center._core  # type: ignore
+
+_DLL = ctypes.cdll.LoadLibrary(connected_k_center._core.__file__)
+
+_METRIC_CODES = {
+    "rmse": 0,
+    "euclidean": 1,
+    "manhattan": 2,
+}  # for passing metric parameter down to c++
+
+
+class PathCKC(ClusterMixin, BaseEstimator):
+    """Connected k-center clustering on path graphs.
+
+    The algorithm performs a binary search over all pairwise distances and
+    finds the minimum radius for which the points can be covered by at most
+    ``n_clusters`` connected clusters. The graph is assumed to be a disjoint
+    union of paths, supplied via ``component_ids``: points sharing a component
+    id are linked, in the order in which they appear in ``X``, to form a path.
+
+    This estimator is transductive -- it clusters a fixed, structured input and
+    does not learn a reusable predictor -- so it only exposes ``fit`` /
+    ``fit_predict`` and does not implement ``predict``, ``transform`` or
+    ``score``.
+    """
+
+    def __init__(self, n_clusters: int = 8, metric: str = "rmse"):
+        self.n_clusters = n_clusters
+        self.metric = metric
+
+    def fit(
+        self,
+        X: Sequence[Sequence[float]],
+        y: Any = None,
+        component_ids: Optional[Sequence[int]] = None,
+    ) -> "PathCKC":
+        self._validate_params()
+
+        _X = validate_data(
+            self,
+            X,
+            reset=True,
+            accept_sparse=False,
+            dtype=np.float64,
+            order="C",
+            accept_large_sparse=False,
+        )
+        assert isinstance(_X, np.ndarray), type(_X)
+        _X = np.ascontiguousarray(_X)
+
+        n_samples = _X.shape[0]
+        self.n_features_in_ = _X.shape[1]
+
+        if n_samples < self.n_clusters:
+            raise ValueError(
+                f"n_samples={n_samples} should be >= n_clusters={self.n_clusters}."
+            )
+
+        _component_ids = _validate_component_ids(component_ids, n_samples)
+
+        # Declare c types
+        c_coords = _X.ctypes.data_as(ctypes.POINTER(ctypes.c_double))
+        c_component_ids = _component_ids.ctypes.data_as(ctypes.POINTER(ctypes.c_int))
+        c_n = ctypes.c_uint(n_samples)
+        c_d = ctypes.c_uint(self.n_features_in_)
+        c_k = ctypes.c_int(self.n_clusters)
+        c_metric = ctypes.c_int(_METRIC_CODES[self.metric])
+
+        labels = np.empty(n_samples, dtype=np.int32, order="C")
+        c_labels = labels.ctypes.data_as(ctypes.POINTER(ctypes.c_int))
+        c_num_centers = ctypes.c_int()
+
+        _DLL.connected_k_center_c.argtypes = [
+            ctypes.POINTER(ctypes.c_double),  # coords
+            ctypes.POINTER(ctypes.c_int),  # component_ids
+            ctypes.c_uint,  # n_samples
+            ctypes.c_uint,  # n_features_in_
+            ctypes.c_int,  # n_clusters (k)
+            ctypes.c_int,  # metric
+            ctypes.POINTER(ctypes.c_int),  # labels
+            ctypes.POINTER(ctypes.c_int),  # num_centers
+        ]
+        _DLL.connected_k_center_c.restype = ctypes.c_double
+
+        radius = _DLL.connected_k_center_c(
+            c_coords,
+            c_component_ids,
+            c_n,
+            c_d,
+            c_k,
+            c_metric,
+            c_labels,
+            ctypes.byref(c_num_centers),
+        )
+
+        if radius < 0:
+            raise ValueError(
+                f"No feasible connected clustering exists for n_clusters="
+                f"{self.n_clusters}."
+            )
+
+        self.optimal_radius_ = radius
+        self.labels_ = labels
+        self.cluster_centers_indices_ = np.unique(labels)
+        self.n_clusters_used_ = c_num_centers.value
+
+        return self
+
+    def fit_predict(
+        self,
+        X: Sequence[Sequence[float]],
+        y: Any = None,
+        component_ids: Optional[Sequence[int]] = None,
+    ) -> np.ndarray:
+        return self.fit(X, component_ids=component_ids).labels_
+
+    def _validate_params(self) -> None:
+        if not isinstance(self.n_clusters, (int, np.integer)):
+            raise TypeError(
+                f"n_clusters must be an integer, got {type(self.n_clusters).__name__}"
+            )
+        if self.n_clusters < 1:
+            raise ValueError(f"n_clusters must be >= 1, got {self.n_clusters}")
+
+        if self.metric not in _METRIC_CODES:
+            raise ValueError(
+                f"metric must be one of {sorted(_METRIC_CODES)}, got {self.metric!r}"
+            )
+
+
+def _validate_component_ids(
+    component_ids: Optional[Sequence[int]],
+    n_samples: int,
+) -> np.ndarray:
+    # Default: a single path over all points, in the given order.
+    if component_ids is None:
+        return np.zeros(n_samples, dtype=np.int32)
+
+    ids = np.ascontiguousarray(component_ids, dtype=np.int32)
+    if ids.ndim != 1:
+        raise ValueError(f"component_ids must be 1D, got {ids.ndim}D")
+    if ids.shape[0] != n_samples:
+        raise ValueError(
+            f"component_ids has length {ids.shape[0]}, expected {n_samples}."
+        )
+    return ids

connected_k_center-0.1/connected_k_center/cpp/clustering.cpp

@@ -0,0 +1,138 @@
+#include "connected_k_center/clustering.hpp"
+#include "connected_k_center/geometry.hpp"
+
+#include <algorithm>
+#include <limits>
+#include <iterator>
+
+namespace ckc {
+
+// Intersection of two SORTED vectors
+static std::vector<int> intersect(const std::vector<int>& x, const std::vector<int>& y) {
+    std::vector<int> result;
+    std::set_intersection(x.begin(), x.end(), y.begin(), y.end(),
+                          std::back_inserter(result));
+    return result;
+}
+
+// Radius membership: M[i] = all centers that could cover point i within radius r *contiguously*
+std::vector<std::vector<int>> get_memberships_for_path(const std::vector<int>& path, const std::vector<Point>& points, double r, int n, Metric metric) {
+    std::vector<std::vector<int>> M(n);
+    const int m = static_cast<int>(path.size());
+
+    for (int center_idx = 0; center_idx < m; ++center_idx) {
+        const int center_id = path[center_idx];
+
+        // Extend to the left along the path
+        for (int i = center_idx; i >= 0; --i) {
+            const int target_id = path[i];
+            if (dist(points[target_id], points[center_id], metric) <= r) {
+                M[target_id].push_back(center_id);
+            } else {
+                break;
+            }
+        }
+
+        // Extend to the right along the path
+        for (int i = center_idx + 1; i < m; ++i) {
+            const int target_id = path[i];
+            if (dist(points[target_id], points[center_id], metric) <= r) {
+                M[target_id].push_back(center_id);
+            } else {
+                break;
+            }
+        }
+    }
+
+    // Sort (precondition for intersect())
+    for (int i = 0; i < n; ++i) {
+        std::sort(M[i].begin(), M[i].end());
+    }
+
+    return M;
+}
+
+
+// Find the optimal clustering of a connected component
+ComponentResult solve_dp_forward(const std::vector<int>& path_indices, const std::vector<std::vector<int>>& M, const std::vector<Point>& points) {
+    const int n = static_cast<int>(path_indices.size());
+
+    // Initialize DP matrix
+    std::vector<int> dp_num_centers(n, std::numeric_limits<int>::max());
+
+    // Avoid explicit backtracking; store results directly instead
+    std::vector<std::vector<int>> partial_centers(n);
+    std::vector<std::vector<ClusterAssignment>> partial_assignments(n);
+
+    // Right interval boundary
+    for (int i = 0; i < n; ++i) {
+        std::vector<int> current_valid_centers;
+
+        // Backward search for the (left) start point j of the 'current' cluster
+        for (int j = i; j >= 0; --j) {
+            const int u = path_indices[j];
+
+            if (j == i) {
+                current_valid_centers = M[u];
+            } else {
+                current_valid_centers = intersect(current_valid_centers, M[u]); // Only centers valid for ALL
+            }
+
+            if (current_valid_centers.empty()) break; // No suitable common center exists
+
+            // Center must lie within the interval [j...i]
+            int chosen_center = -1;
+            for (int c : current_valid_centers) {
+                for (int idx = j; idx <= i; ++idx) {
+                    if (path_indices[idx] == c) {
+                        chosen_center = c;
+                        break;
+                    }
+                }
+                if (chosen_center != -1) break; // Take the first valid one
+            }
+
+            // None of the centers lies WITHIN the interval
+            if (chosen_center == -1) continue;
+
+            // Combine the found cluster with those for [0,...,j-1]
+            const int prev_num_centers = (j == 0) ? 0 : dp_num_centers[j - 1];
+            if (prev_num_centers != std::numeric_limits<int>::max()) {
+                if (prev_num_centers + 1 < dp_num_centers[i]) {
+                    dp_num_centers[i] = prev_num_centers + 1; // Interval [j,...,i] has ONE additional cluster
+
+                    if (j > 0) {
+                        partial_centers[i]     = partial_centers[j - 1];
+                        partial_assignments[i] = partial_assignments[j - 1];
+                    } else {
+                        partial_centers[i].clear();
+                        partial_assignments[i].clear();
+                    }
+
+                    // Append the new center and the point assignments in the interval
+                    partial_centers[i].push_back(points[chosen_center].id);
+                    for (int idx = j; idx <= i; ++idx) {
+                        partial_assignments[i].push_back(
+                            {points[path_indices[idx]].id, points[chosen_center].id}
+                        );
+                    }
+                }
+            }
+        }
+    }
+
+    // Build the ComponentResult if a solution exists
+    ComponentResult result;
+    if (dp_num_centers[n - 1] == std::numeric_limits<int>::max()) {
+        result.feasible    = false;
+        result.num_centers = 0;
+    } else {
+        result.feasible    = true;
+        result.num_centers = dp_num_centers[n - 1];
+        result.centers     = partial_centers[n - 1];
+        result.assignments = partial_assignments[n - 1];
+    }
+    return result;
+}
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/connected_k_center/clustering.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "types.hpp"
+#include <vector>
+
+namespace ckc {
+
+/**
+ * Computes the radius membership for a path.
+ *
+ * M[i] contains all center IDs that could cover point i at radius r
+ * contiguously (i.e. with no gaps along the path).
+ *
+ * @param path    Ordered path as a vector of point IDs.
+ * @param points  All points.
+ * @param r       Search radius.
+ * @param n       Total number of points.
+ * @param metric  Distance metric to use.
+ * @return        Membership vector of size n.
+ */
+    std::vector<std::vector<int>> get_memberships_for_path(
+            const std::vector<int>& path,
+            const std::vector<Point>& points,
+            double r,
+            int n,
+            Metric metric
+    );
+
+/**
+ * Solves the 1D k-center problem on a path via forward DP.
+ *
+ * Finds the minimum number of clusters such that every point lies within
+ * radius r of its center and the center lies in the same interval.
+ *
+ * @param path_indices  Ordered point IDs of the path.
+ * @param M             Membership vector from get_memberships_for_path().
+ * @param points        All points.
+ * @return              ComponentResult (feasibility, centers and assignments).
+ */
+    ComponentResult solve_dp_forward(
+            const std::vector<int>& path_indices,
+            const std::vector<std::vector<int>>& M,
+            const std::vector<Point>& points
+    );
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/connected_k_center/geometry.hpp

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "types.hpp"
+#include <vector>
+
+namespace ckc {
+
+/**
+ * Computes the distance between two points.
+ * (e.g. root mean squared error over all coordinate dimensions)
+ *
+ * @return Distance, or 0.0 if a point has no coordinates.
+ */
+    double dist(const Point& a, const Point& b, Metric metric);
+
+/**
+ * Computes all pairwise distances between the given points.
+ * The result is sorted and deduplicated.
+ * The computation is (optionally) parallelized (OpenMP).
+ *
+ * @param points  Set of input points.
+ * @param metric  Distance metric to use.
+ * @return        Sorted, deduplicated vector of all pairwise distances.
+ */
+    std::vector<double> get_all_distances(const std::vector<Point>& points, Metric metric);
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/connected_k_center/graph.hpp

@@ -0,0 +1,46 @@
+#pragma once
+
+#include "types.hpp"
+#include<numeric>
+#include<vector>
+
+namespace ckc{
+	class Graph{
+	public:
+
+		std::vector<int> vertices;	// list of vertices
+		std::vector<int> degrees;	// list of vertex degrees
+		AdjacencyList adj;	// list of lists, where adj[i] contains all ids of neighbors of vertex i
+
+
+		explicit Graph(int n): vertices(n), degrees(n,0), adj(n){			// constructor (creates graph with n vertices and no edges)
+			std::iota(vertices.begin(), vertices.end(), 0);
+		}
+
+		Graph(AdjacencyList adjacency): vertices(adjacency.size()), degrees(adjacency.size()), adj(std::move(adjacency)){
+			std::iota(vertices.begin(), vertices.end(), 0);
+			for (std::size_t i = 0; i < adj.size(); ++i)
+			{
+				degrees[i] = static_cast<int>(adj[i].size());
+			}
+		}
+		
+
+		void add_edge(int u, int v);	//adds edge {u,v} to graph
+
+		
+		/**
+		 * Determines all connected components (sub-paths) from the adjacency list.
+		 *
+		 * Each component is returned as an ordered path (vector of point IDs),
+		 * starting at an endpoint (degree 0 or 1).
+		 *
+		 * @param adj  Adjacency list of the graph.
+		 * @param n    Number of nodes.
+		 * @return     Vector of paths; each path is a vector of point IDs.
+		 */
+	    std::vector<std::vector<int>> extract_paths();
+
+
+	};
+}

connected_k_center-0.1/connected_k_center/cpp/connected_k_center/solver.hpp

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "types.hpp"
+#include <vector>
+
+namespace ckc {
+
+/// Return value of connected_k_center().
+    struct SolverResult {
+        double optimal_radius = -1.0;            ///< -1.0 = no solution found
+        std::vector<ComponentResult> components; ///< result per connected component
+    };
+
+/**
+ * Solves the connected k-center problem.
+ *
+ * Performs a binary search over all pairwise distances and determines the
+ * minimum radius r* for which a covering with at most k clusters is possible.
+ *
+ * @param k       Maximum number of allowed cluster centers.
+ * @param points  Input points.
+ * @param adj     Adjacency list (i.e. graph structure).
+ * @param metric  Distance metric to use.
+ * @return        SolverResult with the optimal radius and per-component results.
+ */
+    SolverResult connected_k_center(int k, const std::vector<Point>& points, const AdjacencyList& adj, Metric metric = Metric::RMSE);
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/connected_k_center/types.hpp

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <vector>
+
+
+
+
+namespace ckc {
+
+    enum class Metric { RMSE = 0, Euclidean = 1, Manhattan = 2 };
+
+/// A point has an ID + a multi-dimensional coordinate
+    struct Point {
+        int id;
+        std::vector<double> coords;
+    };
+
+/// Assignment: point to a cluster center
+    struct ClusterAssignment {
+        int point_id;
+        int center_id;
+    };
+
+/// Result of the k-center algorithm for ONE connected component
+    struct ComponentResult {
+        bool feasible;
+        int num_centers;
+        std::vector<int> centers;
+        std::vector<ClusterAssignment> assignments;
+    };
+
+/// Adjacency list: adj[i] ~> neighbor IDs of point i
+    using AdjacencyList = std::vector<std::vector<int>>;
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/geometry.cpp

@@ -0,0 +1,69 @@
+#include "connected_k_center/geometry.hpp"
+
+#include <cmath>
+#include <algorithm>
+
+namespace ckc {
+
+// Distance function
+double dist(const Point& a, const Point& b, Metric metric) {
+    const int d = static_cast<int>(a.coords.size());
+    if (d == 0) return 0.0;
+
+    double sum = 0.0;
+
+    switch(metric) {
+        case Metric::RMSE:  //sqrt(mean of squares)
+            for (int i = 0; i < d; ++i)
+            {
+                double diff = a.coords[i] - b.coords[i];
+                sum += diff * diff;
+            }
+            return std::sqrt(sum / d);
+
+        case Metric::Euclidean:    //standard Euclidean distance
+            for (int i = 0; i < d; ++i)
+             {
+                double diff = a.coords[i] - b.coords[i];
+                sum += diff * diff;
+             }
+             return std::sqrt(sum);
+
+        case Metric::Manhattan: //Manhattan aka l_1 metric
+            for (int i = 0; i < d; ++i)
+            {
+                sum += std::abs(a.coords[i] - b.coords[i]);
+            }
+            return sum;
+    }
+    return 0.0;
+
+}
+
+
+// Compute the sorted list of all distinct pairwise distances
+std::vector<double> get_all_distances(const std::vector<Point>& points, Metric metric) {
+    const int n = static_cast<int>(points.size());
+    if (n < 2) return {0.0};
+
+    // Pre-allocate (required for parallel writes)
+    const int num_pairs = n * (n - 1) / 2;
+    std::vector<double> distances(num_pairs + 1);
+    distances[0] = 0.0;
+
+    // Computation can be parallelized
+    #pragma omp parallel for schedule(dynamic) default(none) shared(n, points, distances, metric)
+    for (int i = 0; i < n; ++i) {
+        for (int j = i + 1; j < n; ++j) {
+            int idx = 1 + i * n - (i * (i + 1)) / 2 + (j - i - 1);
+            distances[idx] = dist(points[i], points[j], metric);
+        }
+    }
+
+    // Remove duplicates
+    std::sort(distances.begin(), distances.end());
+    distances.erase(std::unique(distances.begin(), distances.end()), distances.end());
+    return distances;
+}
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/cpp/graph.cpp

@@ -0,0 +1,48 @@
+#include "connected_k_center/graph.hpp"
+
+namespace ckc{
+
+	void Graph::add_edge(int u, int v){
+		adj[u].push_back(v);
+		adj[v].push_back(u);
+		degrees[u]++;
+		degrees[v]++;
+	}
+
+
+	// Extract connected components as ordered paths
+	std::vector<std::vector<int>> Graph::extract_paths() {
+
+	    std::vector<std::vector<int>> paths;
+	    std::vector<bool> visited(vertices.size(), false);
+
+	    // Use path endpoints (degree 0 or 1) as start nodes
+	    for (std::size_t i = 0; i < vertices.size(); ++i) {
+	        if (!visited[i] && degrees[i] <= 1) {
+	            std::vector<int> path;
+	            int curr = i;
+	            int prev = -1; // Predecessor node on the path
+
+	            // Follow edges
+	            while (curr != -1) {
+	                path.push_back(curr);
+	                visited[curr] = true;
+
+	                int next = -1;
+	                for (int nb : adj[curr]) {
+					    if (nb != prev) {
+					        next = nb;
+					        break; // In a path graph there is at most one such neighbor
+					    }
+					}
+
+	                prev = curr;
+	                curr = next;
+	            }
+	            paths.push_back(path);
+	        }
+	    }
+
+	    return paths;
+	}
+}

connected_k_center-0.1/connected_k_center/cpp/solver.cpp

@@ -0,0 +1,72 @@
+#include "connected_k_center/solver.hpp"
+#include "connected_k_center/geometry.hpp"
+#include "connected_k_center/graph.hpp"
+#include "connected_k_center/clustering.hpp"
+
+#include <vector>
+
+namespace ckc {
+
+    /*///////////////////////////////////////////////////
+    //////////////////// Overall logic //////////////////
+    ///////////////////////////////////////////////////*/
+
+    SolverResult connected_k_center(int k, const std::vector<Point>& points, const AdjacencyList& adj, Metric metric) {
+        SolverResult result;
+        const int n = static_cast<int>(points.size());
+        if (n == 0) return result;
+
+        /// [Step 0] Compute pairwise distances
+
+        std::vector<double> distances = get_all_distances(points, metric);
+
+        /// [Step 1] Build the graph and extract paths (connected components)
+        Graph G(adj);
+        std::vector<std::vector<int>> paths = G.extract_paths();
+
+        /// [Step 2] Binary search over distances
+        int low_idx  = 0;
+        int high_idx = static_cast<int>(distances.size()) - 1;
+
+        while (low_idx <= high_idx) {
+            const int mid_idx = low_idx + (high_idx - low_idx) / 2;
+            const double r = distances[mid_idx];
+
+            int total_clusters = 0;
+            bool possible = true;
+            std::vector<ComponentResult> current_results;
+
+            const int num_paths = static_cast<int>(paths.size());
+            #pragma omp parallel for schedule(dynamic) default(none) shared(n, points, paths, r, possible, total_clusters, current_results, metric, num_paths)
+            for (int pi = 0; pi < num_paths; ++pi) {
+                const auto& path = paths[pi];
+
+                auto M = get_memberships_for_path(path, points, r, n, metric);
+
+                ComponentResult res = solve_dp_forward(path, M, points);
+
+                if (!res.feasible) {
+                    possible = false; // No valid clustering
+                    // break;
+                } else {
+                    #pragma omp critical
+                    {
+                        total_clusters += res.num_centers;
+                        current_results.push_back(res);
+                    }
+                }
+            }
+
+            if (possible && total_clusters <= k) {
+                result.optimal_radius = r;
+                result.components     = current_results;
+                high_idx              = mid_idx - 1;
+            } else {
+                low_idx = mid_idx + 1;
+            }
+        }
+
+        return result;
+    }
+
+} // namespace ckc

connected_k_center-0.1/connected_k_center/io.py

@@ -0,0 +1,54 @@
+from typing import Tuple, Union
+from os import PathLike
+
+import numpy as np
+
+
+def read_instance(
+    path: Union[str, "PathLike[str]"],
+) -> Tuple[np.ndarray, np.ndarray]:
+    """Read a path-graph clustering instance from a CSV/text file.
+
+    File format (as produced for the sanity-check instances):
+      * one point per non-empty line, given as its comma-separated coordinates
+        (a single value per line for the 1D case);
+      * an empty line starts a new connected component;
+      * the order of the lines encodes the order of the points along each path.
+
+    Returns ``(X, component_ids)`` ready to pass to
+    :meth:`PathCKC.fit`: ``X`` has shape ``(n_points, n_features)``
+    and ``component_ids`` is the length-``n_points`` path-membership array.
+    """
+    coords = []
+    component_ids = []
+    component = 0
+    seen_in_component = False
+
+    with open(path, "r") as f:
+        for line in f:
+            stripped = line.strip()
+
+            # Empty line -> boundary between components (ignore leading/repeated
+            # blanks so they don't create empty components).
+            if stripped == "":
+                if seen_in_component:
+                    component += 1
+                    seen_in_component = False
+                continue
+
+            values = [v for v in stripped.replace(",", " ").split() if v]
+            coords.append([float(v) for v in values])
+            component_ids.append(component)
+            seen_in_component = True
+
+    if not coords:
+        raise ValueError(f"No points found in instance file: {path}")
+
+    n_features = len(coords[0])
+    if any(len(row) != n_features for row in coords):
+        raise ValueError(
+            f"Inconsistent point dimensionality in instance file: {path}"
+        )
+
+    X = np.asarray(coords, dtype=np.float64)
+    return X, np.asarray(component_ids, dtype=np.int32)

connected_k_center-0.1/pyproject.toml

@@ -0,0 +1,43 @@
+[tool.poetry]
+name = "connected-k-center"
+version = "0.1"
+description = "Implementations of algorithms for connected k-center on path graphs."
+authors = ["Lukas Drexler <lukas.drexler@hhu.de>", "Julius Mann"]
+readme = "README.md"
+license = "MIT"
+packages = [
+    { include = "connected_k_center" }
+]
+include = ["images"]
+exclude = [
+    "connected_k_center/**/*.so",
+    "connected_k_center/**/*.pyd",
+    "connected_k_center/**/__pycache__",
+]
+
+[tool.poetry.dependencies]
+python = "^3.10"
+scikit-learn = "^1.6.1"
+numpy = "^1.26.4"
+
+[tool.poetry.group.dev.dependencies]
+black = {extras = ["jupyter"], version = "^24.4.2"}
+pre-commit = "^2.14.0"
+flake8 = "^7.0.0"
+mypy = "^1.10.0"
+tqdm = "^4.66.4"
+
+[tool.poetry.group.test.dependencies]
+pandas = "^2.2.2"
+
+[tool.poetry.build]
+script = "build_extension.py"
+generate-setup-file = true
+
+[build-system]
+requires = ["poetry-core", "setuptools"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.isort]
+profile = "black"
+line_length = 88

connected_k_center-0.1/setup.py

@@ -0,0 +1,31 @@
+# -*- coding: utf-8 -*-
+from setuptools import setup
+
+packages = \
+['connected_k_center']
+
+package_data = \
+{'': ['*'], 'connected_k_center': ['cpp/*', 'cpp/connected_k_center/*']}
+
+install_requires = \
+['numpy>=1.26.4,<2.0.0', 'scikit-learn>=1.6.1,<2.0.0']
+
+setup_kwargs = {
+    'name': 'connected-k-center',
+    'version': '0.1',
+    'description': 'Implementations of algorithms for connected k-center on path graphs.',
+    'long_description': '# Connected Path Graph Clustering\n\nA library for algorithms for the connected k-center problem (as described in [1]). In this problem setting, the input consists of a point set $P$ and a desired number of centers $k$, along with a *connectivity graph* $G = (P,E)$. The goal is to partition $P$ into (at most) $k$ *clusters* $C_1, \\ldots, C_k$, such that, for every $i$, the subgraph of $G$ induced by $C_i$ is connected.\n\nAs of now, only an algorithm for path graphs is implemented. A path graph is a graph whose connected components are simple paths. This algorithm was developed by Johanna Hillebrand and implemented by Julius Mann.\n\n\n### References\n[1] Drexler, L., Eube, J., Luo, K., Reineccius, D., Röglin, H., Schmidt, M., & Wargalla, J. (2024). Connected k-center and k-diameter clustering. Algorithmica, 86(11), 3425-3464.\n',
+    'author': 'Lukas Drexler',
+    'author_email': 'lukas.drexler@hhu.de',
+    'maintainer': 'None',
+    'maintainer_email': 'None',
+    'url': 'None',
+    'packages': packages,
+    'package_data': package_data,
+    'install_requires': install_requires,
+    'python_requires': '>=3.10,<4.0',
+}
+from build_extension import *
+build(setup_kwargs)
+
+setup(**setup_kwargs)