#pragma once

#include "../graph/shortest_path.hpp"

#include <cassert>

#include <vector>

template <class M1, class M2, class T = int>

std::vector<bool> MatroidIntersection(M1 matroid1, M2 matroid2, std::vector<T> weights = {}) {

using State = std::vector<bool>;

using Element = int;

assert(matroid1.size() == matroid2.size());

const int M = matroid1.size();

for (auto &x : weights) x *= M + 1;

if (weights.empty()) weights.assign(M, 0);

const Element gs = M, gt = M + 1;

State I(M);

while (true) {

ShortestPath<T> sssp(M + 2);

matroid1.set(I);

matroid2.set(I);

for (int e = 0; e < M; e++) {

if (I[e]) continue;

auto c1 = matroid1.circuit(e), c2 = matroid2.circuit(e);

if (c1.empty()) sssp.add_edge(e, gt, 0);

for (Element f : c1) {

if (f != e) sssp.add_edge(e, f, -weights[f] + 1);

}

if (c2.empty()) sssp.add_edge(gs, e, weights[e] + 1);

for (Element f : c2) {

if (f != e) sssp.add_edge(f, e, weights[e] + 1);

}

}

sssp.solve(gs);

auto aug_path = sssp.retrieve_path(gt);

if (aug_path.empty()) break;

for (auto e : aug_path) {

if (e != gs and e != gt) I[e] = !I[e];

}

}

return I;

}

title: (Weighted) matroid intersecition （（重みつき）マトロイド交叉）

documentation_of: ./matroid_intersection.hpp

マトロイド交叉（交差）問題 (matroid intersection)・共通独立集合問題とは，同じ台集合 $E$ を持つ二つのマトロイド $M_1 = (E, \mathcal{I}_1), M_2 = (E, \mathcal{I}_2)$ が与えられたとき，$X \in \mathcal{I}_1 \cap \mathcal{I}_2$ を満たす要素数最大の $X \subset E$ の一つを求めるもの．本問題は更に，重み関数 $f(e) : E \rightarrow \mathbb{R}$ が与えられたとき，要素数最大のもののうち特に $\sum_{e \in X} f(e)$ を最小化（最大化）するようなものを求める重みつき共通独立集合問題 （weighted matroid intersection problem） に一般化される．

本コードは，$n = |E|$，解となる集合の要素数の上界（例えば各マトロイドのランクの最小値）を $r$，マトロイドクラスのサーキットクエリ一回あたりの計算量を $c$ として，（重みなしの）マトロイド交叉を $O(nr(n + c))$ で求める．重みつきの場合は最短増加路を求めるパートが Bellman-Ford 法に置き換えられ，計算量は $O(nr(n^2 + c))$ となる（この計算量は例えば [2] のアルゴリズムを用いることで $O(nr(r + c + \log n))$ まで改善可能）．

`weights` を与えた場合，最小重み共通独立集合を求める．

UserDefinedMatroid m1, m2;

vector<int> weights(M);

assert(m1.size() == M);

assert(m2.size() == M);

std::vector<bool> maxindepset = MatroidIntersection(m1, m2, weights);

#pragma once

#include <cassert>

#include <utility>

#include <vector>

class GraphMatroid {

using Vertex = int;

using Element = int;

int M;

int V; // # of vertices of graph

std::vector<std::vector<std::pair<Vertex, Element>>> to;

std::vector<std::pair<Vertex, Vertex>> edges;

std::vector<Element> backtrack;

std::vector<Vertex> vprev;

std::vector<int> depth, root;

GraphMatroid(int V, std::vector<std::pair<Vertex, Vertex>> edges_)

: M(edges_.size()), V(V), to(V), edges(edges_) {

for (int e = 0; e < int(edges_.size()); e++) {

assert(edges_[e].first < V and edges_[e].second < V);

to[edges_[e].first].emplace_back(edges_[e].second, e);

to[edges_[e].second].emplace_back(edges_[e].first, e);

}

}

int size() const { return M; }

template <class State> void set(State I) {

assert(int(I.size()) == M);

backtrack.assign(V, -1);

vprev.resize(V);

depth.assign(V, -1);

root.resize(V);

static std::vector<Vertex> que(V);

int qb, qe;

for (Vertex i = 0; i < V; i++) {

if (backtrack[i] >= 0) continue;

que[qb = 0] = i, qe = 1, depth[i] = 0;

while (qb < qe) {

Vertex now = que[qb++];

root[now] = i;

for (auto nxt : to[now]) {

if (depth[nxt.first] < 0 and I[nxt.second]) {

backtrack[nxt.first] = nxt.second;

vprev[nxt.first] = now;

depth[nxt.first] = depth[now] + 1;

que[qe++] = nxt.first;

}

}

}

}

}

std::vector<Element> circuit(const Element e) const {

assert(0 <= e and e < M);

Vertex s = edges[e].first, t = edges[e].second;

if (root[s] != root[t]) return {};

std::vector<Element> ret{e};

auto step = [&](Vertex &i) { ret.push_back(backtrack[i]), i = vprev[i]; };

int ddepth = depth[s] - depth[t];

for (; ddepth > 0; --ddepth) step(s);

for (; ddepth < 0; ++ddepth) step(t);

while (s != t) step(s), step(t);

return ret;

}

};

#pragma once

#include <vector>

struct MatroidExample {

using Element = int;

int size() const; // # of elements of set we consider

// If I is independent and I + {e} is not, return elements of the circuit.

// If e \in I, or I + {e} is independent, return empty vector.

// If I is NOT independent, undefined.

template <class State = std::vector<bool>> void set(State I);

std::vector<Element> circuit(Element e) const;

};

#pragma once

#include <cassert>

#include <vector>

class PartitionMatroid {

using Element = int;

int M;

std::vector<std::vector<Element>> parts;

std::vector<int> belong;

std::vector<int> R;

std::vector<int> cnt;

std::vector<std::vector<Element>> circuits;

// parts: partition of [0, 1, ..., M - 1]

// R: only R[i] elements from parts[i] can be chosen for each i.

PartitionMatroid(int M, const std::vector<std::vector<int>> &parts_, const std::vector<int> &R_)

: M(M), parts(parts_), belong(M, -1), R(R_) {

assert(parts.size() == R.size());

for (int i = 0; i < int(parts.size()); i++) {

for (Element e : parts[i]) belong[e] = i;

}

for (Element e = 0; e < M; e++) {

// assert(belong[e] != -1);

if (belong[e] == -1) {

belong[e] = parts.size();

parts.push_back({e});

R.push_back(1);

}

}

}

int size() const { return M; }

template <class State> void set(const State &I) {

cnt = R;

for (int e = 0; e < M; e++) {

if (I[e]) cnt[belong[e]]--;

}

circuits.assign(cnt.size(), {});

for (int e = 0; e < M; e++) {

if (I[e] and cnt[belong[e]] == 0) circuits[belong[e]].push_back(e);

}

}

std::vector<Element> circuit(const Element e) const {

assert(0 <= e and e < M);

int p = belong[e];

if (cnt[p] == 0) {

auto ret = circuits[p];

ret.push_back(e);

return ret;

}

return {};

}

};