結果
| 問題 |
No.1288 yuki collection
|
| コンテスト | |
| ユーザー |
 hitonanode
|
| 提出日時 | 2021-09-06 22:46:02 |
| 言語 | C++17 (gcc 13.3.0 + boost 1.87.0) |
| 結果 |
AC
|
| 実行時間 | 2,406 ms / 5,000 ms |
| コード長 | 9,771 bytes |
| コンパイル時間 | 1,297 ms |
| コンパイル使用メモリ | 98,568 KB |
| 最終ジャッジ日時 | 2025-01-24 08:32:48 |
|
ジャッジサーバーID （参考情報） |
judge1 / judge5 |
（要ログイン）
| ファイルパターン | 結果 |
|---|---|
| sample | AC * 3 |
| other | AC * 40 |
ソースコード
#line 1 "combinatorial_opt/test/mincostflow.yuki1288.test.cpp"
#define PROBLEM "https://yukicoder.me/problems/no/1288"
#line 2 "data_structure/radix_heap.hpp"
#include <array>
#include <cstddef>
#include <limits>
#include <tuple>
#include <type_traits>
#include <utility>
#include <vector>
// Radix heap for unsigned integer
template <class uint, class label, typename std::enable_if<std::is_unsigned<uint>::value>::type * = nullptr>
class radix_heap {
int sz;
uint last;
std::array<std::vector<std::pair<uint, label>>, std::numeric_limits<uint>::digits + 1> v;
template <class U, typename std::enable_if<sizeof(U) == 4>::type * = nullptr>
static inline int bucket(U x) noexcept {
return x ? 32 - __builtin_ctz(x) : 0;
}
template <class U, typename std::enable_if<sizeof(U) == 8>::type * = nullptr>
static inline int bucket(U x) noexcept {
return x ? 64 - __builtin_ctzll(x) : 0;
}
void pull() {
if (!v[0].empty()) return;
int i = 1;
while (v[i].empty()) ++i;
last = v[i].back().first;
for (int j = 0; j < int(v[i].size()); j++) last = std::min(last, v[i][j].first);
for (int j = 0; j < int(v[i].size()); j++) {
v[bucket(v[i][j].first ^ last)].emplace_back(std::move(v[i][j]));
}
v[i].clear();
}
public:
radix_heap() : sz(0), last(0) {}
std::size_t size() const noexcept { return sz; }
bool empty() const noexcept { return sz == 0; }
void push(uint x, const label &val) { ++sz, v[bucket(x ^ last)].emplace_back(x, val); }
void push(uint x, label &&val) { ++sz, v[bucket(x ^ last)].emplace_back(x, std::move(val)); }
template <class... Args> void emplace(uint x, Args &&...args) {
++sz, v[bucket(x ^ last)].emplace_back(std::piecewise_construct, std::forward_as_tuple(x), std::forward_as_tuple(args...));
}
void pop() { pull(), --sz, v[0].pop_back(); }
std::pair<uint, label> top() { return pull(), v[0].back(); }
uint top_key() { return pull(), v[0].back().first; }
label &top_label() { return pull(), v[0].back().second; }
void clear() {
sz = 0, last = 0;
for (auto &vec : v) vec.clear();
}
void swap(radix_heap<uint, label> &a) { std::swap(sz, a.sz), std::swap(last, a.last), v.swap(a.v); }
};
#line 3 "combinatorial_opt/mincostflow_nonegativeloop.hpp"
#include <cassert>
#line 5 "combinatorial_opt/mincostflow_nonegativeloop.hpp"
#include <queue>
#line 8 "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 <class Cap = long long, class Cost = long long, Cost INF_COST = std::numeric_limits<Cost>::max() / 2>
struct MinCostFlow {
struct _edge {
int to, rev;
Cap cap;
Cost cost;
template <class Ostream> 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<std::vector<_edge>> g;
std::vector<Cost> dist;
std::vector<int> prevv, preve;
std::vector<Cost> dual; // dual[V]: potential
std::vector<std::pair<int, int>> pos;
bool _initialize_dual_dag() {
std::vector<int> 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<int> 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<int> q;
std::vector<int> in_queue(V);
std::vector<int> 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();
}
void _dijkstra(int s) { // O(ElogV)
prevv.assign(V, -1);
preve.assign(V, -1);
dist.assign(V, INF_COST);
dist[s] = 0;
typedef typename std::make_unsigned<Cost>::type UCost;
using P = std::pair<UCost, int>;
// radix_heap<UCost, int> q;
std::priority_queue<P, std::vector<P>, std::greater<P>> q;
q.emplace(0, s);
while (!q.empty()) {
P p = q.top();
q.pop();
int v = p.second;
if (dist[v] < p.first) continue;
for (int i = 0; i < (int)g[v].size(); i++) {
_edge &e = g[v][i];
UCost 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;
assert(dist[e.to] >= 0);
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.
std::pair<Cap, Cost> flow(int s, int t, const Cap &flow_limit) {
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 <class Ostream> 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<edge> edges() const {
std::vector<edge> ret(pos.size());
for (int i = 0; i < int(pos.size()); i++) ret[i] = get_edge(i);
return ret;
}
template <class Ostream> 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 3 "combinatorial_opt/test/mincostflow.yuki1288.test.cpp"
#include <iostream>
#include <numeric>
#include <string>
#line 7 "combinatorial_opt/test/mincostflow.yuki1288.test.cpp"
using namespace std;
int main() {
int N;
string S;
cin >> N >> S;
vector<long long> V(N);
for (auto &x : V) cin >> x;
const int s = N * 5, t = s + 1;
MinCostFlow<int, long long> 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';
}