convex/monge.hpp

• View this file on GitHub
• Last update: 2026-03-14 22:08:09+09:00
• Include: #include "convex/monge.hpp"
• Link: https://codeforces.com/contest/2183/problem/H
• Link: https://topcoder-g-hatena-ne-jp.jag-icpc.org/spaghetti_source/20120915/1347668163.html

Depends on

• convex/larsch.hpp
• convex/smawk.hpp
• other/fibonacci_search.hpp

Verified with

• test/3_yukicoder/705.test.cpp

Code

#include "convex/larsch.hpp"

#include "convex/smawk.hpp"

#include "other/fibonacci_search.hpp"


// 定義域 [0, N] の範囲で f の monge 性を確認

template <typename T, typename F>
bool check_monge(int N, F f) {
  FOR(l, N + 1) FOR(k, l) FOR(j, k) FOR(i, j) {
    T lhs = f(i, l) + f(j, k);
    T rhs = f(i, k) + f(j, l);
    if (lhs < rhs) {
      print("monge ng");
      print(i, j, k, l, f(i, k), f(i, l), f(j, k), f(j, l), lhs, rhs);
      return false;
    }
  }
  print("monge ok");
  return true;
}

// newdp[j] = min (dp[i] + f(i,j))

template <typename T, typename F>
vc<T> monge_dp_update(int N, vc<T>& dp, F f) {
  assert(len(dp) == N + 1);
  auto select = [&](int i, int j, int k) -> int {
    if (i <= k) return j;
    return (dp[j] + f(j, i) > dp[k] + f(k, i) ? k : j);
  };
  vc<int> I = SMAWK(N + 1, N + 1, select);
  vc<T> newdp(N + 1, infty<T>);
  FOR(j, N + 1) {
    int i = I[j];
    chmin(newdp[j], dp[i] + f(i, j));
  }
  return newdp;
}

// 遷移回数を問わない場合

template <typename T, typename F>
vc<T> monge_shortest_path(int N, F f) {
  vc<T> dp(N + 1, infty<T>);
  dp[0] = 0;
  auto g = [&](int i, int j) -> T {
    ++i;
    if (i <= j) return infty<T>;
    return dp[j] + f(j, i);
  };
  LARSCH<T, decltype(g)> larsch(N, g);
  FOR(r, 1, N + 1) {
    int l = larsch.get_argmin();
    dp[r] = dp[l] + f(l, r);
  }
  return dp;
}

// https://codeforces.com/contest/2183/problem/H

template <typename T, typename F>
T monge_shortest_path_d_edge(int N, int d, T flim, F f) {
  assert(1 <= d && d <= N);
  if (d == 1) return f(0, N);
  if (d == N) {
    T ans = 0;
    FOR(i, N) ans += f(i, i + 1);
    return ans;
  }
  if (d == 2) {
    T ans = infty<T>;
    FOR(i, 1, N) chmin(ans, f(0, i) + f(i, N));
    return ans;
  }

  vc<pair<T, int>> dp(N + 1);
  map<T, pair<T, int>> MP;
  T ANS = -infty<T>;
  auto calc = [&](T lambda) -> pair<T, int> {
    if (MP.count(lambda)) return MP[lambda];
    dp[0] = {0, 0};
    auto eval = [&](int i, int j) -> T {
      ++i;
      if (i <= j) return infty<T>;
      return dp[j].fi + f(j, i);
    };
    LARSCH<T, decltype(eval)> larsch(N, eval);

    FOR(r, 1, N + 1) {
      int l = larsch.get_argmin();
      dp[r].fi = dp[l].fi + f(l, r) + lambda;
      dp[r].se = dp[l].se + 1;
    }
    chmax(ANS, dp[N].fi - lambda * d);
    return MP[lambda] = dp[N];
  };

  T lo = -3 * flim - 10, hi = 3 * flim + 10;
  while (lo + 1 < hi) {
    T mi = (lo + hi) / 2;
    int k = calc(mi).se;
    if (k == d) break;
    (k > d ? lo : hi) = mi;
  }
  return ANS;
}

// https://topcoder-g-hatena-ne-jp.jag-icpc.org/spaghetti_source/20120915/1347668163.html

// Prop 1

// 上三角 monge A, B

// C[i][j] = min_k (A[i][k] + B[k][j])

template <typename T, typename F1, typename F2>
vvc<T> monge_matrix_product(int N, F1 A, F2 B) {
  vv(T, C, N + 1, N + 1, infty<T>);
  vc<int> K(N + 1);
  FOR(i, N + 1) C[i][i] = A(i, i) + B(i, i), K[i] = i;
  FOR(s, 1, N + 1) {
    vc<int> newK(N + 1 - s);
    FOR(i, N + 1 - s) {
      int j = i + s;
      int p = K[i], q = K[i + 1];
      FOR(k, p, q + 1) if (chmin(C[i][j], A(i, k) + B(k, j))) newK[i] = k;
    }
    swap(K, newK);
  }
  return C;
}

#line 1 "convex/larsch.hpp"
// 制約きつい https://codeforces.com/contest/2183/problem/H
template <class T, class F>
class LARSCH {
  struct reduce_row;
  struct reduce_col;
  struct ColMap {
    const ColMap* parent = nullptr;
    const std::vector<int>* v = nullptr;

    inline int map(int j) const {
      int x = v ? (*v)[j] : j;
      return parent ? parent->map(x) : x;
    }
  };

  struct Eval {
    const F* f = nullptr;
    long long a = 1;  // row = a*i + b
    long long b = 0;
    const ColMap* cm = nullptr;

    inline T operator()(int i, int j) const {
      int ii = int(a * i + b);
      int jj = cm ? cm->map(j) : j;
      return (*f)(ii, jj);
    }
  };

  struct reduce_row {
    int n;
    Eval e;
    int cur_row = 0;
    int state = 0;
    std::unique_ptr<reduce_col> rec;

    reduce_row(int n_, const Eval& e_) : n(n_), e(e_) {
      int m = n / 2;
      if (m) {
        Eval eo = e;
        eo.b = e.a + e.b;
        eo.a = 2 * e.a;
        rec = std::make_unique<reduce_col>(m, eo);
      }
    }

    inline void reset() {
      cur_row = 0;
      state = 0;
      if (rec) rec->reset();
    }

    inline int get_argmin() {
      int i = cur_row++;
      if ((i & 1) == 0) {
        int prev = state;
        int next = (i + 1 == n ? n - 1 : rec->get_argmin());
        state = next;
        int ret = prev;
        for (int j = prev + 1; j <= next; ++j) {
          if (e(i, ret) > e(i, j)) ret = j;
        }
        return ret;
      } else {
        return (e(i, state) <= e(i, i)) ? state : i;
      }
    }
  };

  struct reduce_col {
    int n;
    Eval e;
    int cur_row = 0;
    std::vector<int> cols;
    ColMap cm_here;
    reduce_row rec;

    reduce_col(int n_, const Eval& e_)
        : n(n_),
          e(e_),
          cols(),
          cm_here{e.cm, &cols},
          rec(n_, Eval{e.f, e.a, e.b, &cm_here}) {
      cols.reserve(n);
    }

    inline void reset() {
      cur_row = 0;
      cols.clear();
      rec.reset();
    }

    inline void push_col(int j, int i) {
      while (!cols.empty()) {
        int size = (int)cols.size();
        if (size == i) break;
        int last = cols.back();
        if (e(size - 1, last) > e(size - 1, j))
          cols.pop_back();
        else
          break;
      }
      if ((int)cols.size() != n) cols.push_back(j);
    }

    inline int get_argmin() {
      int i = cur_row++;
      if (i == 0) {
        cols.clear();
        cols.push_back(0);
      } else {
        push_col(2 * i - 1, i);
        push_col(2 * i, i);
      }
      return cols[rec.get_argmin()];
    }
  };

  F f_;
  ColMap root_cm_;
  Eval root_eval_;
  std::unique_ptr<reduce_row> base_;

 public:
  explicit LARSCH(int n, F f)
      : f_(std::move(f)),
        root_cm_{nullptr, nullptr},
        root_eval_{&f_, 1, 0, &root_cm_} {
    base_ = std::make_unique<reduce_row>(n, root_eval_);
  }

  inline void reset() { base_->reset(); }
  inline int get_argmin() { return base_->get_argmin(); }
};
#line 2 "convex/smawk.hpp"

// select(i,j,k) は (i,j) -> (i,k) を行うかどうか
// 残念ながら monotone minima より高速な場合が存在しない説がある
// https://codeforces.com/contest/1423/problem/M
template <typename F>
vc<int> smawk(int H, int W, F select) {
  auto dfs = [&](auto& dfs, vc<int> X, vc<int> Y) -> vc<int> {
    int N = len(X);
    if (N == 0) return {};
    vc<int> YY;
    for (auto&& y: Y) {
      while (len(YY)) {
        int py = YY.back(), x = X[len(YY) - 1];
        if (!select(x, py, y)) break;
        YY.pop_back();
      }
      if (len(YY) < len(X)) YY.eb(y);
    }
    vc<int> XX;
    FOR(i, 1, len(X), 2) XX.eb(X[i]);
    vc<int> II = dfs(dfs, XX, YY);
    vc<int> I(N);
    FOR(i, len(II)) I[i + i + 1] = II[i];
    int p = 0;
    FOR(i, 0, N, 2) {
      int LIM = (i + 1 == N ? Y.back() : I[i + 1]);
      int best = Y[p];
      while (Y[p] < LIM) {
        ++p;
        if (select(X[i], best, Y[p])) best = Y[p];
      }
      I[i] = best;
    }
    return I;
  };
  vc<int> X(H), Y(W);
  iota(all(X), 0), iota(all(Y), 0);
  return dfs(dfs, X, Y);
}
#line 1 "other/fibonacci_search.hpp"
// returns: {fx, x}
// [L, R) での極小値をひとつ求める、単峰は不要
template <typename T, bool MINIMIZE, typename F>
pair<T, ll> fibonacci_search(F f, ll L, ll R) {
  assert(L < R);
  --R;
  ll a = L, b = L + 1, c = L + 2, d = L + 3;
  int n = 0;
  while (d < R) { b = c, c = d, d = b + c - a, ++n; }
  auto get = [&](ll x) -> T {
    if (R < x) return infty<T>;
    return (MINIMIZE ? f(x) : -f(x));
  };
  T ya = get(a), yb = get(b), yc = get(c), yd = get(d);
  // この中で極小ならば全体でも極小、を維持する
  FOR(n) {
    if (yb <= yc) {
      d = c, c = b, b = a + d - c;
      yd = yc, yc = yb, yb = get(b);
    } else {
      a = b, b = c, c = a + d - b;
      ya = yb, yb = yc, yc = get(c);
    }
  }
  ll x = a;
  T y = ya;
  if (chmin(y, yb)) x = b;
  if (chmin(y, yc)) x = c;
  if (chmin(y, yd)) x = d;
  if (MINIMIZE) return {y, x};
  return {-y, x};
}
#line 4 "convex/monge.hpp"

// 定義域 [0, N] の範囲で f の monge 性を確認

template <typename T, typename F>
bool check_monge(int N, F f) {
  FOR(l, N + 1) FOR(k, l) FOR(j, k) FOR(i, j) {
    T lhs = f(i, l) + f(j, k);
    T rhs = f(i, k) + f(j, l);
    if (lhs < rhs) {
      print("monge ng");
      print(i, j, k, l, f(i, k), f(i, l), f(j, k), f(j, l), lhs, rhs);
      return false;
    }
  }
  print("monge ok");
  return true;
}

// newdp[j] = min (dp[i] + f(i,j))

template <typename T, typename F>
vc<T> monge_dp_update(int N, vc<T>& dp, F f) {
  assert(len(dp) == N + 1);
  auto select = [&](int i, int j, int k) -> int {
    if (i <= k) return j;
    return (dp[j] + f(j, i) > dp[k] + f(k, i) ? k : j);
  };
  vc<int> I = SMAWK(N + 1, N + 1, select);
  vc<T> newdp(N + 1, infty<T>);
  FOR(j, N + 1) {
    int i = I[j];
    chmin(newdp[j], dp[i] + f(i, j));
  }
  return newdp;
}

// 遷移回数を問わない場合

template <typename T, typename F>
vc<T> monge_shortest_path(int N, F f) {
  vc<T> dp(N + 1, infty<T>);
  dp[0] = 0;
  auto g = [&](int i, int j) -> T {
    ++i;
    if (i <= j) return infty<T>;
    return dp[j] + f(j, i);
  };
  LARSCH<T, decltype(g)> larsch(N, g);
  FOR(r, 1, N + 1) {
    int l = larsch.get_argmin();
    dp[r] = dp[l] + f(l, r);
  }
  return dp;
}

// https://codeforces.com/contest/2183/problem/H

template <typename T, typename F>
T monge_shortest_path_d_edge(int N, int d, T flim, F f) {
  assert(1 <= d && d <= N);
  if (d == 1) return f(0, N);
  if (d == N) {
    T ans = 0;
    FOR(i, N) ans += f(i, i + 1);
    return ans;
  }
  if (d == 2) {
    T ans = infty<T>;
    FOR(i, 1, N) chmin(ans, f(0, i) + f(i, N));
    return ans;
  }

  vc<pair<T, int>> dp(N + 1);
  map<T, pair<T, int>> MP;
  T ANS = -infty<T>;
  auto calc = [&](T lambda) -> pair<T, int> {
    if (MP.count(lambda)) return MP[lambda];
    dp[0] = {0, 0};
    auto eval = [&](int i, int j) -> T {
      ++i;
      if (i <= j) return infty<T>;
      return dp[j].fi + f(j, i);
    };
    LARSCH<T, decltype(eval)> larsch(N, eval);

    FOR(r, 1, N + 1) {
      int l = larsch.get_argmin();
      dp[r].fi = dp[l].fi + f(l, r) + lambda;
      dp[r].se = dp[l].se + 1;
    }
    chmax(ANS, dp[N].fi - lambda * d);
    return MP[lambda] = dp[N];
  };

  T lo = -3 * flim - 10, hi = 3 * flim + 10;
  while (lo + 1 < hi) {
    T mi = (lo + hi) / 2;
    int k = calc(mi).se;
    if (k == d) break;
    (k > d ? lo : hi) = mi;
  }
  return ANS;
}

// https://topcoder-g-hatena-ne-jp.jag-icpc.org/spaghetti_source/20120915/1347668163.html

// Prop 1

// 上三角 monge A, B

// C[i][j] = min_k (A[i][k] + B[k][j])

template <typename T, typename F1, typename F2>
vvc<T> monge_matrix_product(int N, F1 A, F2 B) {
  vv(T, C, N + 1, N + 1, infty<T>);
  vc<int> K(N + 1);
  FOR(i, N + 1) C[i][i] = A(i, i) + B(i, i), K[i] = i;
  FOR(s, 1, N + 1) {
    vc<int> newK(N + 1 - s);
    FOR(i, N + 1 - s) {
      int j = i + s;
      int p = K[i], q = K[i + 1];
      FOR(k, p, q + 1) if (chmin(C[i][j], A(i, k) + B(k, j))) newK[i] = k;
    }
    swap(K, newK);
  }
  return C;
}

Back to top page