#line 1 "combinatorial_opt/test/mincostflow.radixheaparray.yuki1288.test.cpp" #define PROBLEM "https://yukicoder.me/problems/no/1288" #line 2 "data_structure/radix_heap_array.hpp" #include #include #include #include #include template class radix_heap_array { int sz; Uint last; std::array>, std::numeric_limits::digits + 1> v; struct smallpii { unsigned b : 7; int j : 25; }; std::vector i2bj; template ::type* = nullptr> static inline unsigned bucket(U x) noexcept { return x ? 32 - __builtin_clz(x) : 0; } template ::type* = nullptr> static inline unsigned bucket(U x) noexcept { return x ? 64 - __builtin_clzll(x) : 0; } void pull() { if (!v[0].empty()) return; int b = 1; while (v[b].empty()) ++b; last = v[b].back().first; for (int j = 0; j < int(v[b].size()); j++) last = std::min(last, v[b][j].first); for (int j = 0; j < int(v[b].size()); j++) { int i = v[b][j].second; auto bnxt = bucket(v[b][j].first ^ last); i2bj[i] = {bnxt, int(v[bnxt].size())}, v[bnxt].emplace_back(std::move(v[b][j])); } v[b].clear(); } public: radix_heap_array() : sz(0), last(0) {} bool empty() const noexcept { return sz == 0; } int argmin_pop() { pull(), --sz; int i = v[0].back().second; i2bj[i].j = -1; v[0].pop_back(); return i; } void chmin(Uint vnew, int i) { if (i >= int(i2bj.size())) i2bj.resize(i + 1, {0, -1}); if (i2bj[i].j < 0) { auto b = bucket(vnew ^ last); ++sz, i2bj[i] = {b, int(v[b].size())}, v[b].emplace_back(vnew, i); } else if (v[i2bj[i].b][i2bj[i].j].first > vnew) { auto bold = i2bj[i].b, bnew = bucket(vnew ^ last); if (bnew < bold) { int ilast = v[bold].back().second, j = i2bj[i].j; std::swap(v[bold][j], v[bold].back()); i2bj[ilast].j = j, i2bj[i] = {bnew, int(v[bnew].size())}; v[bnew].emplace_back(vnew, i), v[bold].pop_back(); } else { v[bold][i2bj[i].j].first = vnew; } } } void pop() { argmin_pop(); } std::pair top() { return pull(), v[0].back(); } [[deprecated("NOT usual emplace opeation.")]] void emplace(Uint vnew, int i) { chmin(vnew, i); } void clear() noexcept { sz = 0, last = 0, i2bj.clear(); } }; #line 2 "combinatorial_opt/mincostflow_nonegativeloop.hpp" #include #line 4 "combinatorial_opt/mincostflow_nonegativeloop.hpp" #include #line 6 "combinatorial_opt/mincostflow_nonegativeloop.hpp" // CUT begin // Minimum cost flow WITH NO NEGATIVE CYCLE (just negative cost edge is allowed) // Verified: // - SRM 770 Div1 Medium https://community.topcoder.com/stat?c=problem_statement&pm=15702 // - CodeChef LTIME98 Ancient Magic https://www.codechef.com/problems/ANCT template ::max() / 2> struct MinCostFlow { struct _edge { int to, rev; Cap cap; Cost cost; template friend Ostream &operator<<(Ostream &os, const _edge &e) { return os << '(' << e.to << ',' << e.rev << ',' << e.cap << ',' << e.cost << ')'; } }; bool _is_dual_infeasible; int V; std::vector> g; std::vector dist; std::vector prevv, preve; std::vector dual; // dual[V]: potential std::vector> pos; bool _initialize_dual_dag() { std::vector deg_in(V); for (int i = 0; i < V; i++) { for (const auto &e : g[i]) deg_in[e.to] += (e.cap > 0); } std::vector st; st.reserve(V); for (int i = 0; i < V; i++) { if (!deg_in[i]) st.push_back(i); } for (int n = 0; n < V; n++) { if (int(st.size()) == n) return false; // Not DAG int now = st[n]; for (const auto &e : g[now]) { if (!e.cap) continue; deg_in[e.to]--; if (deg_in[e.to] == 0) st.push_back(e.to); if (dual[e.to] >= dual[now] + e.cost) dual[e.to] = dual[now] + e.cost; } } return true; } bool _initialize_dual_spfa() { // Find feasible dual's when negative cost edges exist dual.assign(V, 0); std::queue q; std::vector in_queue(V); std::vector nvis(V); for (int i = 0; i < V; i++) q.push(i), in_queue[i] = true; while (q.size()) { int now = q.front(); q.pop(), in_queue[now] = false; if (nvis[now] > V) return false; // Negative cycle exists nvis[now]++; for (const auto &e : g[now]) { if (!e.cap) continue; if (dual[e.to] > dual[now] + e.cost) { dual[e.to] = dual[now] + e.cost; if (!in_queue[e.to]) in_queue[e.to] = true, q.push(e.to); } } } return true; } bool initialize_dual() { return !_is_dual_infeasible or _initialize_dual_dag() or _initialize_dual_spfa(); } template void _dijkstra(int s) { // O(ElogV) prevv.assign(V, -1); preve.assign(V, -1); dist.assign(V, INF_COST); dist[s] = 0; heap q; q.emplace(0, s); while (!q.empty()) { auto p = q.top(); q.pop(); int v = p.second; if (dist[v] < Cost(p.first)) continue; for (int i = 0; i < (int)g[v].size(); i++) { _edge &e = g[v][i]; auto c = dist[v] + e.cost + dual[v] - dual[e.to]; if (e.cap > 0 and dist[e.to] > c) { dist[e.to] = c, prevv[e.to] = v, preve[e.to] = i; q.emplace(dist[e.to], e.to); } } } } MinCostFlow(int V = 0) : _is_dual_infeasible(false), V(V), g(V), dual(V, 0) { static_assert(INF_COST > 0, "INF_COST must be positive"); } int add_edge(int from, int to, Cap cap, Cost cost) { assert(0 <= from and from < V); assert(0 <= to and to < V); assert(cap >= 0); if (cost < 0) _is_dual_infeasible = true; pos.emplace_back(from, g[from].size()); g[from].push_back({to, (int)g[to].size() + (from == to), cap, cost}); g[to].push_back({from, (int)g[from].size() - 1, (Cap)0, -cost}); return int(pos.size()) - 1; } // Flush flow f from s to t. Graph must not have negative cycle. using Pque = std::priority_queue, std::vector>, std::greater>>; template std::pair flow(int s, int t, const Cap &flow_limit) { // You can also use radix_heap::type, int> as prique if (!initialize_dual()) throw; // Fail to find feasible dual Cost cost = 0; Cap flow_rem = flow_limit; while (flow_rem > 0) { _dijkstra(s); if (dist[t] == INF_COST) break; for (int v = 0; v < V; v++) dual[v] = std::min(dual[v] + dist[v], INF_COST); Cap d = flow_rem; for (int v = t; v != s; v = prevv[v]) d = std::min(d, g[prevv[v]][preve[v]].cap); flow_rem -= d; cost += d * (dual[t] - dual[s]); for (int v = t; v != s; v = prevv[v]) { _edge &e = g[prevv[v]][preve[v]]; e.cap -= d; g[v][e.rev].cap += d; } } return std::make_pair(flow_limit - flow_rem, cost); } struct edge { int from, to; Cap cap, flow; Cost cost; template friend Ostream &operator<<(Ostream &os, const edge &e) { return os << '(' << e.from << "->" << e.to << ',' << e.flow << '/' << e.cap << ",$" << e.cost << ')'; } }; edge get_edge(int edge_id) const { int m = int(pos.size()); assert(0 <= edge_id and edge_id < m); auto _e = g[pos[edge_id].first][pos[edge_id].second]; auto _re = g[_e.to][_e.rev]; return {pos[edge_id].first, _e.to, _e.cap + _re.cap, _re.cap, _e.cost}; } std::vector edges() const { std::vector ret(pos.size()); for (int i = 0; i < int(pos.size()); i++) ret[i] = get_edge(i); return ret; } template friend Ostream &operator<<(Ostream &os, const MinCostFlow &mcf) { os << "[MinCostFlow]V=" << mcf.V << ":"; for (int i = 0; i < mcf.V; i++) { for (auto &e : mcf.g[i]) os << "\n" << i << "->" << e.to << ":cap" << e.cap << ",$" << e.cost; } return os; } }; #line 4 "combinatorial_opt/test/mincostflow.radixheaparray.yuki1288.test.cpp" #include #include #include #line 8 "combinatorial_opt/test/mincostflow.radixheaparray.yuki1288.test.cpp" using namespace std; int main() { int N; string S; cin >> N >> S; vector V(N); for (auto &x : V) cin >> x; const int s = N * 5, t = s + 1; MinCostFlow graph(t + 1); for (int d = 0; d < 5; d++) { for (int i = 0; i < N - 1; i++) graph.add_edge(d * N + i, d * N + i + 1, N / 4, 0); } graph.add_edge(s - 1, 0, N / 4, 0); for (int i = 0; i < N; i++) { int b = 0; if (S[i] == 'u') b = N * 1; if (S[i] == 'k') b = N * 2; if (S[i] == 'i') b = N * 3; int fr = b + i + N, to = b + i; graph.add_edge(s, fr, 1, 0); graph.add_edge(fr, to, 1, V[i]); graph.add_edge(to, t, 1, 0); } auto cost = graph.flow>(s, t, N).second; cout << accumulate(V.begin(), V.end(), 0LL) - cost << '\n'; }