結果
| 問題 | No.1320 Two Type Min Cost Cycle |
| コンテスト | |
| ユーザー |
 rniya
|
| 提出日時 | 2024-04-07 20:57:53 |
| 言語 | C++17(gcc12) (gcc 12.4.0 + boost 1.90.0) |
| 結果 |
CE
(最新)
AC
(最初)
|
| 実行時間 | - |
| コード長 | 5,777 bytes |
| 記録 | |
| コンパイル時間 | 444 ms |
| コンパイル使用メモリ | 86,616 KB |
| 最終ジャッジ日時 | 2026-07-04 11:01:10 |
| 合計ジャッジ時間 | 1,029 ms |
|
ジャッジサーバーID （参考情報） |
temp-judge_0 / judge2_0 |
（要ログイン）
コンパイルエラー時のメッセージ・ソースコードは、提出者また管理者しか表示できないようにしております。（リジャッジ後のコンパイルエラーは公開されます）
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
ただし、clay言語の場合は開発者のデバッグのため、公開されます。
コンパイルメッセージ
main.cpp:72:35: error: ‘numeric_limits’ is not a member of ‘std’
72 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^~~~~~~~~~~~~~
main.cpp:72:51: error: expected primary-expression before ‘>’ token
72 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^
main.cpp:72:54: error: ‘::max’ has not been declared; did you mean ‘std::max’?
72 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^~~
| std::max
In file included from /usr/include/c++/12/algorithm:61,
from main.cpp:4:
/usr/include/c++/12/bits/stl_algo.h:5757:5: note: ‘std::max’ declared here
5757 | max(initializer_list<_Tp> __l, _Compare __comp)
| ^~~
main.cpp:160:35: error: ‘numeric_limits’ is not a member of ‘std’
160 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^~~~~~~~~~~~~~
main.cpp:160:51: error: expected primary-expression before ‘>’ token
160 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^
main.cpp:160:54: error: ‘::max’ has not been declared; did you mean ‘std::max’?
160 | constexpr static T inf = std::numeric_limits<T>::max() / 2;
| ^~~
| std::max
/usr/include/c++/12/bits/stl_algo.h:5757:5: note: ‘std::max’ declared here
5757 | max(initializer_list<_Tp> __l, _Compare __comp)
| ^~~
main.cpp: In function ‘int main()’:
main.cpp:181:57: error: ‘get’ was not declared in this scope; did you mean ‘std::get’?
181 | for (int i = 0; i < N; i++) ans = std::min(ans
ソースコード
#define PROBLEM "https://yukicoder.me/problems/no/1320"
#include <iostream>
#include <algorithm>
#include <cassert>
#include <numeric>
#include <queue>
#include <tuple>
#include <vector>
template <typename T> struct DirectedShortestCycle {
struct edge {
int from, to;
T cost;
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
std::vector<std::vector<int>> G;
std::vector<edge> edges;
DirectedShortestCycle(int n) : n(n), G(n) {}
void add_edge(int u, int v, T w) {
assert(0 <= u and u < n);
assert(0 <= v and v < n);
assert(w >= 0);
G[u].emplace_back(edges.size());
edges.emplace_back(u, v, w);
}
std::tuple<T, std::vector<int>, std::vector<int>> solve(int r) {
std::vector<int> prve(n, -1);
std::vector<T> dist(n, inf);
std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int>>, std::greater<>> pq;
for (const int& idx : G[r]) {
int u = edges[idx].to, w = edges[idx].cost;
if (w < dist[u]) {
dist[u] = w;
prve[u] = idx;
pq.emplace(dist[u], u);
}
}
while (not pq.empty()) {
auto [d, v] = pq.top();
pq.pop();
if (dist[v] < d) continue;
for (const int& idx : G[v]) {
int u = edges[idx].to, w = edges[idx].cost;
if (dist[u] <= dist[v] + w) continue;
dist[u] = dist[v] + w;
prve[u] = idx;
pq.emplace(dist[u], u);
}
}
if (dist[r] == inf) return {inf, {}, {}};
std::vector<int> vs, es;
vs.emplace_back(r);
while (true) {
int idx = prve[vs.back()];
es.emplace_back(idx);
vs.emplace_back(edges[idx].from);
if (vs.back() == r) break;
}
std::reverse(vs.begin(), vs.end());
std::reverse(es.begin(), es.end());
vs.pop_back();
return {dist[r], vs, es};
}
private:
constexpr static T inf = std::numeric_limits<T>::max() / 2;
int n;
};
template <typename T> struct UndirectedShortestCycle {
struct edge {
int from, to;
T cost;
edge(int from, int to, T cost) : from(from), to(to), cost(cost) {}
};
std::vector<std::vector<int>> G;
std::vector<edge> edges;
UndirectedShortestCycle(int n) : n(n), G(n) {}
void add_edge(int u, int v, T w) {
assert(0 <= u and u < n);
assert(0 <= v and v < n);
assert(w >= 0);
G[u].emplace_back(edges.size());
G[v].emplace_back(edges.size());
edges.emplace_back(u, v, w);
}
std::tuple<T, std::vector<int>, std::vector<int>> solve(int r) {
std::vector<int> label(n, -1), prve(n, -1);
std::vector<T> dist(n, inf);
std::priority_queue<std::pair<T, int>, std::vector<std::pair<T, int>>, std::greater<>> pq;
dist[r] = 0;
pq.emplace(dist[r], r);
label[r] = r;
while (not pq.empty()) {
auto [d, v] = pq.top();
pq.pop();
if (dist[v] < d) continue;
for (const int& idx : G[v]) {
int u = edges[idx].from ^ edges[idx].to ^ v, w = edges[idx].cost;
if (dist[u] <= dist[v] + w) continue;
dist[u] = dist[v] + w;
label[u] = label[v] == r ? u : label[v];
prve[u] = idx;
pq.emplace(dist[u], u);
}
}
std::vector<bool> used(edges.size(), false);
for (int& idx : prve) {
if (idx != -1) {
used[idx] = true;
}
}
T mini = inf;
int argmin = -1;
for (int i = 0; i < int(edges.size()); i++) {
if (used[i]) continue;
auto [u, v, w] = edges[i];
if (label[u] == -1) continue;
if (label[u] == label[v]) continue;
if (dist[u] + dist[v] + w < mini) {
mini = dist[u] + dist[v] + w;
argmin = i;
}
}
if (argmin == -1) return {mini, {}, {}};
std::vector<int> vs, es;
int a = edges[argmin].from, b = edges[argmin].to;
while (a != r) {
int idx = prve[a];
vs.emplace_back(a);
es.emplace_back(idx);
a = edges[idx].from ^ edges[idx].to ^ a;
}
vs.emplace_back(a);
std::reverse(vs.begin(), vs.end());
std::reverse(es.begin(), es.end());
es.emplace_back(argmin);
while (b != r) {
int idx = prve[b];
vs.emplace_back(b);
es.emplace_back(idx);
b = edges[idx].from ^ edges[idx].to ^ b;
}
return {mini, vs, es};
}
private:
constexpr static T inf = std::numeric_limits<T>::max() / 2;
int n;
};
constexpr long long inf = (1LL << 60) - 1;
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
int T;
std::cin >> T;
int N, M;
std::cin >> N >> M;
long long ans = inf;
if (T == 0) {
UndirectedShortestCycle<long long> G(N);
for (; M--;) {
int u, v, w;
std::cin >> u >> v >> w;
G.add_edge(--u, --v, w);
}
for (int i = 0; i < N; i++) ans = std::min(ans, get<0>(G.solve(i)));
} else {
DirectedShortestCycle<long long> G(N);
for (; M--;) {
int u, v, w;
std::cin >> u >> v >> w;
G.add_edge(--u, --v, w);
}
for (int i = 0; i < N; i++) ans = std::min(ans, get<0>(G.solve(i)));
}
std::cout << (ans == inf ? -1 : ans) << '\n';
return 0;
}