Algorithms: Graph Algorithms

    static int bellman_ford(ReadOnlySpan<int> from_vertex, ReadOnlySpan<int> to_vertex, ReadOnlySpan<int> weight, int n, int source, int target) {
        checked {
            int m = from_vertex.Length;
            alg_require(((n >= 0) && (n <= 1000000)));
            alg_require(((m >= 0) && (m <= 1000000)));
            alg_require((from_vertex.Length == m));
            alg_require((to_vertex.Length == m));
            alg_require((weight.Length == m));
            alg_require(((n >= 1) && (source >= 0) && (source < n)));
            alg_require(((target >= 0) && (target < n)));
            for (int alg_i = 0; alg_i < from_vertex.Length; alg_i++) {
                int alg_value = from_vertex[alg_i];

int bellman_ford(const std::vector<int>& from_vertex, const std::vector<int>& to_vertex, const std::vector<int>& weight, int n, int source, int target) {
    alg_require(from_vertex.size() <= 1000000);
    alg_require(to_vertex.size() <= 1000000);
    alg_require(weight.size() <= 1000000);
    int m = (int)from_vertex.size();
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((m >= 0) && (m <= 1000000)));
    alg_require(((int)from_vertex.size() == m));
    alg_require(((int)to_vertex.size() == m));
    alg_require(((int)weight.size() == m));
    alg_require(((n >= 1) && (source >= 0) && (source < n)));
    alg_require(((target >= 0) && (target < n)));

int bellman_ford(const int *from_vertex, size_t from_vertex_length, const int *to_vertex, size_t to_vertex_length, const int *weight, size_t weight_length, int n, int source, int target) {
    int alg_error = 0;
    int alg_result = INT_MIN;
    errno = 0;
    int *distance = NULL;
    if (from_vertex_length > 1000000 || (from_vertex_length && !from_vertex)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (to_vertex_length > 1000000 || (to_vertex_length && !to_vertex)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (weight_length > 1000000 || (weight_length && !weight)) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    int m = (int)from_vertex_length;
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }
    if (!(((n >= 0) && (n <= 1000000)))) { errno = EINVAL; alg_result = INT_MIN; goto alg_cleanup; }
    if (alg_error) { errno = ERANGE; alg_result = INT_MIN; goto alg_cleanup; }

def bellman_ford(from_vertex: list[int], to_vertex: list[int], weight: list[int], n: int, source: int, target: int) -> int:
    alg_require(isinstance(from_vertex, (list, tuple)) and len(from_vertex) <= 1000000)
    alg_require(isinstance(to_vertex, (list, tuple)) and len(to_vertex) <= 1000000)
    alg_require(isinstance(weight, (list, tuple)) and len(weight) <= 1000000)
    alg_require(type(n) is int and -2147483648 <= n <= 2147483647)
    alg_require(type(source) is int and -2147483648 <= source <= 2147483647)
    alg_require(type(target) is int and -2147483648 <= target <= 2147483647)
    m: int = len(from_vertex)
    alg_require(n >= 0 and n <= 1000000)
    alg_require(m >= 0 and m <= 1000000)
    alg_require(len(from_vertex) == m)
    alg_require(len(to_vertex) == m)

function bellman_ford(from_vertex, to_vertex, weight, n, source, target) {
    alg_require(from_vertex instanceof Int32Array);
    alg_require(to_vertex instanceof Int32Array);
    alg_require(weight instanceof Int32Array);
    alg_require(Number.isInteger(n) && n >= -2147483648 && n <= 2147483647);
    alg_require(Number.isInteger(source) && source >= -2147483648 && source <= 2147483647);
    alg_require(Number.isInteger(target) && target >= -2147483648 && target <= 2147483647);
    let m = from_vertex.length;
    alg_require(((n >= 0) && (n <= 1000000)));
    alg_require(((m >= 0) && (m <= 1000000)));
    alg_require((from_vertex.length == m));
    alg_require((to_vertex.length == m));