problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p02361
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define INF 10000000000000000
#define ll long long
using namespace std;
int main() {
ll V, E, r;
cin >> V >> E >> r;
vector<vector<pair<ll, ll>>> edges(V);
for (ll i = 0; i < E; i++) {
ll s, t, d;
cin >> s >> t >> d;
edges[s].push_back(make_pair(t, d));
}
vector<ll> dist(V, INF);
dist[r] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, less<pair<ll, ll>>> pq;
pq.push(make_pair(0, r));
while (!pq.empty()) {
ll source = pq.top().second;
pq.pop();
for (pair<ll, ll> edge : edges[source]) {
if (dist[edge.first] > dist[source] + edge.second) {
dist[edge.first] = dist[source] + edge.second;
pq.push(make_pair(dist[edge.first], edge.first));
}
}
}
for (ll i = 0; i < V; i++) {
if (dist[i] == INF) {
cout << "INF" << endl;
} else {
cout << dist[i] << endl;
}
}
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
#define INF 10000000000000000
#define ll long long
using namespace std;
int main() {
ll V, E, r;
cin >> V >> E >> r;
vector<vector<pair<ll, ll>>> edges(V);
for (ll i = 0; i < E; i++) {
ll s, t, d;
cin >> s >> t >> d;
edges[s].push_back(make_pair(t, d));
}
vector<ll> dist(V, INF);
dist[r] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> pq;
pq.push(make_pair(0, r));
while (!pq.empty()) {
ll source = pq.top().second;
pq.pop();
for (pair<ll, ll> edge : edges[source]) {
if (dist[edge.first] > dist[source] + edge.second) {
dist[edge.first] = dist[source] + edge.second;
pq.push(make_pair(dist[edge.first], edge.first));
}
}
}
for (ll i = 0; i < V; i++) {
if (dist[i] == INF) {
cout << "INF" << endl;
} else {
cout << dist[i] << endl;
}
}
}
|
replace
| 20 | 21 | 20 | 21 |
TLE
| |
p02361
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define INF (INT_MAX / 2)
#define PI (2 * acos(0.0))
#define EPS (1e-8)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int Cost;
struct Edge {
int src, dst;
Cost cst;
Edge(int s, int d, Cost c) : src(s), dst(d), cst(c) {}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Cost> Array;
typedef vector<Array> Matrix;
int dx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int dy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
vector<Cost> dijkstra(const Graph &g, int s) {
const Cost inf = numeric_limits<Cost>::max() / 2;
typedef tuple<Cost, int> State;
priority_queue<State> q;
vector<Cost> dist(g.size(), inf);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
Cost c;
int v;
tie(c, v) = q.top();
q.pop();
c *= -1;
if (dist[v] < c)
continue;
for (auto &e : g[v]) {
if (dist[e.dst] > dist[v] + e.cst) {
dist[e.dst] = dist[v] + e.cst;
q.emplace(dist[e.dst], e.dst);
}
}
}
return dist;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int v, e, r;
int s, t, d;
cin >> v >> e >> r;
Graph g(v);
for (int i = 0; i < e; i++) {
cin >> s >> t >> d;
g[s].push_back(Edge(s, t, d));
}
vector<Cost> c = dijkstra(g, r);
for (int i = 0; i < (int)c.size(); i++) {
if (c[i] == numeric_limits<Cost>::max() / 2)
cout << "INF" << endl;
else
cout << c[i] << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF (INT_MAX / 2)
#define PI (2 * acos(0.0))
#define EPS (1e-8)
#define REP(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) REP(i, 0, n)
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef int Cost;
struct Edge {
int src, dst;
Cost cst;
Edge(int s, int d, Cost c) : src(s), dst(d), cst(c) {}
};
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Cost> Array;
typedef vector<Array> Matrix;
int dx[8] = {0, 1, 0, -1, 1, -1, 1, -1};
int dy[8] = {1, 0, -1, 0, 1, -1, -1, 1};
vector<Cost> dijkstra(const Graph &g, int s) {
const Cost inf = numeric_limits<Cost>::max() / 2;
typedef tuple<Cost, int> State;
priority_queue<State, vector<State>, greater<State>> q;
vector<Cost> dist(g.size(), inf);
dist[s] = 0;
q.emplace(0, s);
while (q.size()) {
Cost c;
int v;
tie(c, v) = q.top();
q.pop();
c *= -1;
if (dist[v] < c)
continue;
for (auto &e : g[v]) {
if (dist[e.dst] > dist[v] + e.cst) {
dist[e.dst] = dist[v] + e.cst;
q.emplace(dist[e.dst], e.dst);
}
}
}
return dist;
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(0);
int v, e, r;
int s, t, d;
cin >> v >> e >> r;
Graph g(v);
for (int i = 0; i < e; i++) {
cin >> s >> t >> d;
g[s].push_back(Edge(s, t, d));
}
vector<Cost> c = dijkstra(g, r);
for (int i = 0; i < (int)c.size(); i++) {
if (c[i] == numeric_limits<Cost>::max() / 2)
cout << "INF" << endl;
else
cout << c[i] << endl;
}
return 0;
}
|
replace
| 32 | 33 | 32 | 33 |
TLE
| |
p02361
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, j) for (int i = 0; i < (int)(j); i++)
constexpr int INF = 1 << 28;
struct Edge {
int to;
ll cost;
Edge(int to, ll cost) : to(to), cost(cost) {}
};
using EdgeList = vector<vector<Edge>>;
using Vatex = int;
constexpr ll INFL = 1LL << 60;
struct State {
int index;
ll cost;
State(int i, ll c) : index(i), cost(c) {}
bool operator>(const State &r) const { return cost < r.cost; }
};
//
//
vector<ll> dijkstra(const EdgeList &G, int start) {
priority_queue<State, vector<State>, greater<State>> que;
vector<ll> dist(G.size(), INFL);
que.emplace(start, 0);
dist[start] = 0;
while (not que.empty()) {
State now = que.top();
que.pop();
for (Edge e : G[now.index]) {
if (dist[e.to] > now.cost + e.cost) {
State nxt = State(e.to, now.cost + e.cost);
dist[e.to] = nxt.cost;
que.push(nxt);
}
}
}
return dist;
}
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_A&lang=jp
int main() {
int N, M, R;
cin >> N >> M >> R;
EdgeList E(N);
rep(i, M) {
int a, b, c;
cin >> a >> b >> c;
E[a].push_back(Edge(b, c));
}
auto dist = dijkstra(E, R);
for (ll d : dist)
cout << (d < INFL ? to_string(d) : "INF") << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, j) for (int i = 0; i < (int)(j); i++)
constexpr int INF = 1 << 28;
struct Edge {
int to;
ll cost;
Edge(int to, ll cost) : to(to), cost(cost) {}
};
using EdgeList = vector<vector<Edge>>;
using Vatex = int;
constexpr ll INFL = 1LL << 60;
struct State {
int index;
ll cost;
State(int i, ll c) : index(i), cost(c) {}
bool operator>(const State &r) const { return cost > r.cost; }
};
//
//
vector<ll> dijkstra(const EdgeList &G, int start) {
priority_queue<State, vector<State>, greater<State>> que;
vector<ll> dist(G.size(), INFL);
que.emplace(start, 0);
dist[start] = 0;
while (not que.empty()) {
State now = que.top();
que.pop();
for (Edge e : G[now.index]) {
if (dist[e.to] > now.cost + e.cost) {
State nxt = State(e.to, now.cost + e.cost);
dist[e.to] = nxt.cost;
que.push(nxt);
}
}
}
return dist;
}
// http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_A&lang=jp
int main() {
int N, M, R;
cin >> N >> M >> R;
EdgeList E(N);
rep(i, M) {
int a, b, c;
cin >> a >> b >> c;
E[a].push_back(Edge(b, c));
}
auto dist = dijkstra(E, R);
for (ll d : dist)
cout << (d < INFL ? to_string(d) : "INF") << endl;
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
TLE
| |
p02361
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int V, E, S;
LL d[100001];
typedef pair<LL, int> P;
vector<P> G[100001];
int main() {
cin >> V >> E >> S;
REP(i, E) {
int a, b;
LL c;
cin >> a >> b >> c;
G[a].push_back(make_pair(c, b));
// G[b].push_back(make_pair(c,a));
}
REP(i, 100001) { d[i] = 10e12; }
priority_queue<P> q;
q.push(make_pair(0, S));
while (!q.empty()) {
P p = q.top();
q.pop();
LL cost = p.first;
LL num = p.second;
if (d[num] < cost)
continue;
// cout<<num<<"aaa"<<cost<<endl;
d[num] = cost;
REP(i, G[num].size()) {
if (d[num] + G[num][i].first < d[G[num][i].second]) {
q.push(make_pair(d[num] + G[num][i].first, G[num][i].second));
d[G[num][i].second] = d[num] + G[num][i].first;
}
}
}
REP(i, V) {
if (d[i] == 10e12) {
cout << "INF" << endl;
} else {
cout << d[i] << endl;
}
}
return (0);
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
typedef long long LL;
int V, E, S;
LL d[100001];
typedef pair<LL, int> P;
vector<P> G[100001];
int main() {
cin >> V >> E >> S;
REP(i, E) {
int a, b;
LL c;
cin >> a >> b >> c;
G[a].push_back(make_pair(c, b));
// G[b].push_back(make_pair(c,a));
}
REP(i, 100001) { d[i] = 10e12; }
priority_queue<P, vector<P>, greater<P>> q;
q.push(make_pair(0, S));
while (!q.empty()) {
P p = q.top();
q.pop();
LL cost = p.first;
LL num = p.second;
if (d[num] < cost)
continue;
// cout<<num<<"aaa"<<cost<<endl;
d[num] = cost;
REP(i, G[num].size()) {
if (d[num] + G[num][i].first < d[G[num][i].second]) {
q.push(make_pair(d[num] + G[num][i].first, G[num][i].second));
d[G[num][i].second] = d[num] + G[num][i].first;
}
}
}
REP(i, V) {
if (d[i] == 10e12) {
cout << "INF" << endl;
} else {
cout << d[i] << endl;
}
}
return (0);
}
|
replace
| 21 | 22 | 21 | 22 |
TLE
| |
p02361
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
#define numof(array) (sizeof(array) / sizeof *(array))
const int INF = 1000000007;
const int MAX_V = 10000007;
typedef long long ll;
typedef pair<int, int> P; // first: ???????????¢???second: ???????????????
struct edge {
int to;
int cost;
};
int V = 0;
vector<edge> G[MAX_V];
int d[MAX_V];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> qu;
fill(d, d + V, INF);
d[s] = 0;
qu.push(P(0, s));
while (!qu.empty()) {
P p = qu.top();
qu.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
qu.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int E, r;
cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
edge e = {t, d};
// e.to = t; e.cost = d;
G[s].push_back(e);
}
dijkstra(r);
for (int i = 0; i < V; i++) {
if (d[i] == INF)
cout << "INF" << endl;
else
cout << d[i] << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
#define numof(array) (sizeof(array) / sizeof *(array))
const int INF = 1000000007;
const int MAX_V = 1000007;
typedef long long ll;
typedef pair<int, int> P; // first: ???????????¢???second: ???????????????
struct edge {
int to;
int cost;
};
int V = 0;
vector<edge> G[MAX_V];
int d[MAX_V];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> qu;
fill(d, d + V, INF);
d[s] = 0;
qu.push(P(0, s));
while (!qu.empty()) {
P p = qu.top();
qu.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
qu.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int E, r;
cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
edge e = {t, d};
// e.to = t; e.cost = d;
G[s].push_back(e);
}
dijkstra(r);
for (int i = 0; i < V; i++) {
if (d[i] == INF)
cout << "INF" << endl;
else
cout << d[i] << endl;
}
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
MLE
| |
p02361
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define INF 1000000000
using namespace std;
typedef pair<int, int> pii;
namespace MyLib {
class Dijkstra {
struct edge {
int to, cost;
edge(int to_, int cost_) : to(to_), cost(cost_) {}
};
bool isdirected;
vector<int> d;
vector<vector<edge>> G;
int V, E;
public:
Dijkstra(int _V, bool _isdirected = true)
: isdirected(_isdirected), V(_V), E(0), d(V), G(V) {}
void add(int a, int b, int c) {
G[a].push_back(edge(b, c));
if (!isdirected)
G[b].push_back(edge(a, c));
E++;
}
void calc(int start) {
fill(d.begin(), d.end(), INF);
priority_queue<pii, vector<pii>, greater<pii>> que;
d[start] = 0;
que.push(pii(0, start));
while (!que.empty()) {
pii p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (size_t i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(pii(d[e.to], e.to));
}
}
}
}
int dist(int to) { return d[to]; }
};
} // namespace MyLib
using namespace MyLib;
int main() {
int v, e, r;
cin >> v >> e >> r;
Dijkstra dk(v);
for (int i = 0, s, t, d; i < e; i++) {
cin >> s >> t >> d;
dk.add(s, t, d);
}
dk.calc(r);
for (int i = 0; i < v; i++) {
if (dk.dist(i) == INF)
cout << "INF" << endl;
else
cout << dk.dist(i) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define INF 1000000000
using namespace std;
typedef pair<int, int> pii;
namespace MyLib {
class Dijkstra {
struct edge {
int to, cost;
edge(int to_, int cost_) : to(to_), cost(cost_) {}
};
bool isdirected;
vector<int> d;
vector<vector<edge>> G;
int V, E;
public:
Dijkstra(int _V, bool _isdirected = true)
: isdirected(_isdirected), V(_V), E(0), d(_V), G(_V) {}
void add(int a, int b, int c) {
G[a].push_back(edge(b, c));
if (!isdirected)
G[b].push_back(edge(a, c));
E++;
}
void calc(int start) {
fill(d.begin(), d.end(), INF);
priority_queue<pii, vector<pii>, greater<pii>> que;
d[start] = 0;
que.push(pii(0, start));
while (!que.empty()) {
pii p = que.top();
que.pop();
int v = p.second;
if (d[v] < p.first)
continue;
for (size_t i = 0; i < G[v].size(); i++) {
edge e = G[v][i];
if (d[e.to] > d[v] + e.cost) {
d[e.to] = d[v] + e.cost;
que.push(pii(d[e.to], e.to));
}
}
}
}
int dist(int to) { return d[to]; }
};
} // namespace MyLib
using namespace MyLib;
int main() {
int v, e, r;
cin >> v >> e >> r;
Dijkstra dk(v);
for (int i = 0, s, t, d; i < e; i++) {
cin >> s >> t >> d;
dk.add(s, t, d);
}
dk.calc(r);
for (int i = 0; i < v; i++) {
if (dk.dist(i) == INF)
cout << "INF" << endl;
else
cout << dk.dist(i) << endl;
}
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
-6
|
terminate called after throwing an instance of 'std::length_error'
what(): cannot create std::vector larger than max_size()
|
p02361
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (auto it = (X).begin(); it != (X).end(); it++)
#define numa(x, a) for (auto x : a)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define pf push_front
#define sec second
#define sz(x) ((int)(x).size())
#define ALL(c) (c).begin(), (c).end()
#define loop(n) for (int xxxxxxxx = 0; xxxxxxxx < (n); xxxxxxxx++)
#define gcd(a, b) __gcd(a, b)
#define endl "\n"
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v)
os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v)
os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.front() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.top() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::unordered_map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
#define DEBUG1(var0) \
{ std::cerr << (#var0) << "=" << (var0) << endl; }
#define DEBUG2(var0, var1) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG1(var1); \
}
#define DEBUG3(var0, var1, var2) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG2(var1, var2); \
}
#define DEBUG4(var0, var1, var2, var3) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG3(var1, var2, var3); \
}
#define DEBUG5(var0, var1, var2, var3, var4) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG4(var1, var2, var3, var4); \
}
#define DEBUG6(var0, var1, var2, var3, var4, var5) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG5(var1, var2, var3, var4, var5); \
}
typedef istringstream iss;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
#define MAX_V 1100
int V, E;
vector<pair<int, ll>> edge[MAX_V];
ll dis[MAX_V];
void dijkstra(int s) {
fill(dis, dis + MAX_V, INF);
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
que;
dis[s] = 0;
que.push(mp(0, s));
while (!que.empty()) {
pair<ll, int> now = que.top();
que.pop();
int now_v = now.sec;
rep(i, sz(edge[now_v])) {
pair<int, ll> next = edge[now_v][i];
if (dis[next.fir] > dis[now_v] + next.sec) {
dis[next.fir] = dis[now_v] + next.sec;
que.push(mp(dis[next.fir], next.fir));
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int r;
cin >> V >> E >> r;
rep(i, E) {
int x, y;
ll z;
cin >> x >> y >> z;
edge[x].pb(mp(y, z));
}
dijkstra(r);
rep(i, V) {
if (dis[i] == INF) {
cout << "INF\n";
} else {
cout << dis[i] << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (auto it = (X).begin(); it != (X).end(); it++)
#define numa(x, a) for (auto x : a)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define pf push_front
#define sec second
#define sz(x) ((int)(x).size())
#define ALL(c) (c).begin(), (c).end()
#define loop(n) for (int xxxxxxxx = 0; xxxxxxxx < (n); xxxxxxxx++)
#define gcd(a, b) __gcd(a, b)
#define endl "\n"
using namespace std;
template <int POS, class TUPLE>
void deploy(std::ostream &os, const TUPLE &tuple) {}
template <int POS, class TUPLE, class H, class... Ts>
void deploy(std::ostream &os, const TUPLE &t) {
os << (POS == 0 ? "" : ", ") << get<POS>(t);
deploy<POS + 1, TUPLE, Ts...>(os, t);
}
template <class... Ts>
std::ostream &operator<<(std::ostream &os, const std::tuple<Ts...> &t) {
os << "(";
deploy<0, std::tuple<Ts...>, Ts...>(os, t);
os << ")";
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::vector<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v)
os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::set<T> &v) {
int remain = v.size();
os << "{";
for (auto e : v)
os << e << (--remain == 0 ? "}" : ", ");
return os;
}
template <class T> std::ostream &operator<<(std::ostream &os, std::queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.front() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T>
std::ostream &operator<<(std::ostream &os, std::priority_queue<T> q) {
os << "{";
for (; !q.empty(); q.pop()) {
os << q.top() << (q.size() != 1 ? ", " : "}");
}
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
template <class T, class K>
std::ostream &operator<<(std::ostream &os, std::unordered_map<T, K> &mp) {
int remain = mp.size();
os << "{";
for (auto e : mp)
os << "(" << e.first << " -> " << e.second << ")"
<< (--remain == 0 ? "}" : ", ");
return os;
}
#define DEBUG1(var0) \
{ std::cerr << (#var0) << "=" << (var0) << endl; }
#define DEBUG2(var0, var1) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG1(var1); \
}
#define DEBUG3(var0, var1, var2) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG2(var1, var2); \
}
#define DEBUG4(var0, var1, var2, var3) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG3(var1, var2, var3); \
}
#define DEBUG5(var0, var1, var2, var3, var4) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG4(var1, var2, var3, var4); \
}
#define DEBUG6(var0, var1, var2, var3, var4, var5) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
DEBUG5(var1, var2, var3, var4, var5); \
}
typedef istringstream iss;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
#define MAX_V 100100
int V, E;
vector<pair<int, ll>> edge[MAX_V];
ll dis[MAX_V];
void dijkstra(int s) {
fill(dis, dis + MAX_V, INF);
priority_queue<pair<ll, int>, vector<pair<ll, int>>, greater<pair<ll, int>>>
que;
dis[s] = 0;
que.push(mp(0, s));
while (!que.empty()) {
pair<ll, int> now = que.top();
que.pop();
int now_v = now.sec;
rep(i, sz(edge[now_v])) {
pair<int, ll> next = edge[now_v][i];
if (dis[next.fir] > dis[now_v] + next.sec) {
dis[next.fir] = dis[now_v] + next.sec;
que.push(mp(dis[next.fir], next.fir));
}
}
}
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
int r;
cin >> V >> E >> r;
rep(i, E) {
int x, y;
ll z;
cin >> x >> y >> z;
edge[x].pb(mp(y, z));
}
dijkstra(r);
rep(i, V) {
if (dis[i] == INF) {
cout << "INF\n";
} else {
cout << dis[i] << endl;
}
}
return 0;
}
|
replace
| 116 | 117 | 116 | 117 |
0
| |
p02361
|
C++
|
Runtime Error
|
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int N, M;
struct Edge {
int src, dst, weight;
Edge *next, *prev;
Edge(int s, int d, int w, Edge *n, Edge *p)
: src(s), dst(d), weight(w), next(n), prev(p) {}
Edge() : Edge(0, 0, 0, nullptr, nullptr) {}
void *operator new(size_t) {
static char buf[1000010];
static int i = 0;
Edge *res = (Edge *)(buf + i);
i += sizeof(Edge);
return res;
}
};
vector<Edge *> first;
void add_edge(int u, int v, int d) {
Edge *next = first[u];
first[u] = new Edge(u, v, d, next, nullptr);
if (next != nullptr)
next->prev = first[u];
}
int main() {
int V, E, r;
while (cin >> V >> E >> r) {
first.assign(V, nullptr);
for (int i = 0; i < E; ++i) {
int s, t, d;
cin >> s >> t >> d;
add_edge(s, t, d);
}
using State = pair<int, int>;
priority_queue<State> q;
vector<long long> dist(V, 1e18);
q.emplace(0, r);
dist[r] = 0;
while (q.size()) {
long long d, v;
tie(d, v) = q.top();
q.pop();
d = -d;
if (dist[v] < d)
continue;
for (Edge *e = first[v]; e != nullptr; e = e->next) {
if (dist[e->dst] > e->weight + dist[v]) {
dist[e->dst] = e->weight + dist[v];
q.emplace(-dist[e->dst], e->dst);
}
}
}
for (int i = 0; i < V; ++i) {
if (dist[i] == 1e18)
cout << "INF";
else
cout << dist[i];
cout << '\n';
}
}
// {
// vector<string> u, v;
// static char s[3000], t[3000];
// map<string,int> id;
// N = 0;
// M = 0;
// while(cin >> s >> t){
// u.push_back(s);
// v.push_back(t);
// if(id.count(s) == 0) id[s] = N++;
// if(id.count(t) == 0) id[t] = N++;
// ++M;
// }
// first.assign(N, nullptr);
// for(int i = 0; i < M; ++i){
// add_edge(id[u[i]], id[v[i]]);
// }
// }
}
|
#include <iostream>
#include <map>
#include <memory>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int N, M;
struct Edge {
int src, dst, weight;
Edge *next, *prev;
Edge(int s, int d, int w, Edge *n, Edge *p)
: src(s), dst(d), weight(w), next(n), prev(p) {}
Edge() : Edge(0, 0, 0, nullptr, nullptr) {}
void *operator new(size_t) {
static char buf[500010 * sizeof(Edge)];
static int i = 0;
Edge *res = (Edge *)(buf + i);
i += sizeof(Edge);
return res;
}
};
vector<Edge *> first;
void add_edge(int u, int v, int d) {
Edge *next = first[u];
first[u] = new Edge(u, v, d, next, nullptr);
if (next != nullptr)
next->prev = first[u];
}
int main() {
int V, E, r;
while (cin >> V >> E >> r) {
first.assign(V, nullptr);
for (int i = 0; i < E; ++i) {
int s, t, d;
cin >> s >> t >> d;
add_edge(s, t, d);
}
using State = pair<int, int>;
priority_queue<State> q;
vector<long long> dist(V, 1e18);
q.emplace(0, r);
dist[r] = 0;
while (q.size()) {
long long d, v;
tie(d, v) = q.top();
q.pop();
d = -d;
if (dist[v] < d)
continue;
for (Edge *e = first[v]; e != nullptr; e = e->next) {
if (dist[e->dst] > e->weight + dist[v]) {
dist[e->dst] = e->weight + dist[v];
q.emplace(-dist[e->dst], e->dst);
}
}
}
for (int i = 0; i < V; ++i) {
if (dist[i] == 1e18)
cout << "INF";
else
cout << dist[i];
cout << '\n';
}
}
// {
// vector<string> u, v;
// static char s[3000], t[3000];
// map<string,int> id;
// N = 0;
// M = 0;
// while(cin >> s >> t){
// u.push_back(s);
// v.push_back(t);
// if(id.count(s) == 0) id[s] = N++;
// if(id.count(t) == 0) id[t] = N++;
// ++M;
// }
// first.assign(N, nullptr);
// for(int i = 0; i < M; ++i){
// add_edge(id[u[i]], id[v[i]]);
// }
// }
}
|
replace
| 19 | 20 | 19 | 20 |
0
| |
p02361
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = (int)(s); i < (int)(t); ++i)
#define each(a, b) for (auto &(a) : (b))
#define all(v) (v).begin(), (v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)), v.erase(unique(all(v)), v.end())
#define cmx(x, y) x = max(x, y)
#define cmn(x, y) x = min(x, y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout << #x << " = " << (x) << endl
#define spair(p) cout << #p << ": " << p.fi << " " << p.se << endl
#define sar(a, n) \
cout << #a << ":"; \
rep(pachico, n) cout << " " << a[pachico]; \
cout << endl
#define svec(v) \
cout << #v << ":"; \
rep(pachico, v.size()) cout << " " << v[pachico]; \
cout << endl
#define svecp(v) \
cout << #v << ":"; \
each(pachico, v) cout << " {" << pachico.first << ":" << pachico.second \
<< "}"; \
cout << endl
#define sset(s) \
cout << #s << ":"; \
each(pachico, s) cout << " " << pachico; \
cout << endl
#define smap(m) \
cout << #m << ":"; \
each(pachico, m) cout << " {" << pachico.first << ":" << pachico.second \
<< "}"; \
cout << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 100005;
#define T int
class Dijkstra {
public:
struct edge {
int to;
T cost;
};
vector<vector<edge>> G;
vector<T> d;
int V;
using pti = pair<T, int>;
Dijkstra(int node_size) {
V = node_size;
G.resize(V), d.resize(V, numeric_limits<T>::max());
}
// 無向グラフの場合
void add_edge(int u, int v, T cost) { G[u].pb((edge){v, cost}); }
void solve(int s) {
set<pti> st;
d[s] = 0;
st.insert(pti(0, s));
while (!st.empty()) {
pti p = *(--st.end());
st.erase(--st.end());
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &w : G[v]) {
if (d[w.to] > d[v] + w.cost) {
d[w.to] = d[v] + w.cost;
st.insert(pti(d[w.to], w.to));
}
}
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, r;
cin >> n >> m >> r;
Dijkstra dj(n);
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
dj.add_edge(a, b, c);
}
dj.solve(r);
each(val, dj.d) {
if (val == numeric_limits<T>::max()) {
cout << "INF\n";
} else {
cout << val << "\n";
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define srep(i, s, t) for (int i = (int)(s); i < (int)(t); ++i)
#define each(a, b) for (auto &(a) : (b))
#define all(v) (v).begin(), (v).end()
#define len(v) (int)(v).size()
#define zip(v) sort(all(v)), v.erase(unique(all(v)), v.end())
#define cmx(x, y) x = max(x, y)
#define cmn(x, y) x = min(x, y)
#define fi first
#define se second
#define pb push_back
#define show(x) cout << #x << " = " << (x) << endl
#define spair(p) cout << #p << ": " << p.fi << " " << p.se << endl
#define sar(a, n) \
cout << #a << ":"; \
rep(pachico, n) cout << " " << a[pachico]; \
cout << endl
#define svec(v) \
cout << #v << ":"; \
rep(pachico, v.size()) cout << " " << v[pachico]; \
cout << endl
#define svecp(v) \
cout << #v << ":"; \
each(pachico, v) cout << " {" << pachico.first << ":" << pachico.second \
<< "}"; \
cout << endl
#define sset(s) \
cout << #s << ":"; \
each(pachico, s) cout << " " << pachico; \
cout << endl
#define smap(m) \
cout << #m << ":"; \
each(pachico, m) cout << " {" << pachico.first << ":" << pachico.second \
<< "}"; \
cout << endl
using namespace std;
typedef pair<int, int> P;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<P> vp;
typedef vector<string> vs;
const int MAX_N = 100005;
#define T int
class Dijkstra {
public:
struct edge {
int to;
T cost;
};
vector<vector<edge>> G;
vector<T> d;
int V;
using pti = pair<T, int>;
Dijkstra(int node_size) {
V = node_size;
G.resize(V), d.resize(V, numeric_limits<T>::max());
}
// 無向グラフの場合
void add_edge(int u, int v, T cost) { G[u].pb((edge){v, cost}); }
void solve(int s) {
set<pti> st;
d[s] = 0;
st.insert(pti(0, s));
while (!st.empty()) {
pti p = *(st.begin());
st.erase(st.begin());
int v = p.second;
if (d[v] < p.first)
continue;
for (auto &w : G[v]) {
if (d[w.to] > d[v] + w.cost) {
d[w.to] = d[v] + w.cost;
st.insert(pti(d[w.to], w.to));
}
}
}
}
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, m, r;
cin >> n >> m >> r;
Dijkstra dj(n);
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
dj.add_edge(a, b, c);
}
dj.solve(r);
each(val, dj.d) {
if (val == numeric_limits<T>::max()) {
cout << "INF\n";
} else {
cout << val << "\n";
}
}
return 0;
}
|
replace
| 79 | 81 | 79 | 81 |
TLE
| |
p02362
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int inf = 1000000000;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct Node {
int to, from, cost;
};
int main() {
int n, m, r;
cin >> n >> m >> r;
vector<int> dist(n, inf);
vector<Node> node(m);
for (int i = 0; i < m; i++) {
int s, t, d;
cin >> s >> t >> d;
node[i].to = t;
node[i].from = s;
node[i].cost = d;
}
dist[r] = 0;
int l = 0;
while (true) {
if (l > 1000000) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
bool f = false;
for (int i = 0; i < node.size(); i++) {
Node d = node[i];
if (dist[d.from] != inf && dist[d.to] > dist[d.from] + d.cost) {
dist[d.to] = dist[d.from] + d.cost;
f = true;
}
}
if (!f)
break;
l++;
}
for (int i = 0; i < n; i++) {
if (dist[i] == inf)
cout << "INF" << endl;
else
cout << dist[i] << endl;
}
return 0;
}
// EOF
|
#include <algorithm>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int inf = 1000000000;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
struct Node {
int to, from, cost;
};
int main() {
int n, m, r;
cin >> n >> m >> r;
vector<int> dist(n, inf);
vector<Node> node(m);
for (int i = 0; i < m; i++) {
int s, t, d;
cin >> s >> t >> d;
node[i].to = t;
node[i].from = s;
node[i].cost = d;
}
dist[r] = 0;
int l = 0;
while (true) {
if (l > 100000) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
bool f = false;
for (int i = 0; i < node.size(); i++) {
Node d = node[i];
if (dist[d.from] != inf && dist[d.to] > dist[d.from] + d.cost) {
dist[d.to] = dist[d.from] + d.cost;
f = true;
}
}
if (!f)
break;
l++;
}
for (int i = 0; i < n; i++) {
if (dist[i] == inf)
cout << "INF" << endl;
else
cout << dist[i] << endl;
}
return 0;
}
// EOF
|
replace
| 34 | 35 | 34 | 35 |
TLE
| |
p02362
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
#define INF 50000000000000
std::vector<int> G[100000];
struct edge {
int from, to, cost;
};
int V, E, r;
bool negativeflag = false;
bool possiblity[100000];
edge es[500000];
long long int d[100000];
void shortest_path(int s);
bool negative_path(int s);
bool reachable(int v);
int main(void) {
std::cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
int from, to, cost;
std::cin >> from >> to >> cost;
G[from].push_back(to);
// G[t].push_back(s);
es[i].from = from;
es[i].to = to;
es[i].cost = cost;
}
negativeflag = negative_path(r);
if (!negativeflag) {
shortest_path(r);
}
if (negativeflag) {
std::cout << "NEGATIVE CYCLE" << std::endl;
} else {
for (int i = 0; i < V; i++) {
if (d[i] != INF) {
std::cout << d[i] << std::endl;
} else {
std::cout << "INF" << std::endl;
}
}
}
return 0;
}
void shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[r] = 0;
while (1) {
// for(int j=0;j<V;j++){
bool flag = true;
for (int i = 0; i < E; i++) {
if (d[es[i].from] != INF) {
if (d[es[i].to] > d[es[i].from] + es[i].cost) {
d[es[i].to] = d[es[i].from] + es[i].cost;
flag = false;
}
}
}
if (flag) {
break;
}
}
}
bool negative_path(int s) {
bool flag = false;
for (int i = 0; i < V; i++) {
d[i] = INF;
possiblity[i] = false;
}
for (int j = 0; j < V; j++) {
for (int i = 0; i < E; i++) {
if (d[es[i].from] != INF) {
if (d[es[i].to] > d[es[i].from] + es[i].cost) {
d[es[i].to] = d[es[i].from] + es[i].cost;
if (j == V - 1) {
flag = true;
}
}
}
}
}
return flag;
/*for(int i=0;i<V;i++){
std::cout<<d[i]<<std::endl;
}
if(flag==false){
return false;
}else {
flag=reachable(r);
return flag;
}*/
}
bool reachable(int v) {
possiblity[v] = true;
if (d[v] < 0) {
return true;
} else {
for (int i = 0; i < G[v].size(); i++) {
if (possiblity[G[v][i]] == false) {
return reachable(G[v][i]);
}
}
}
return false;
}
|
#include <iostream>
#include <vector>
#define INF 50000000000000
std::vector<int> G[100000];
struct edge {
int from, to, cost;
};
int V, E, r;
bool negativeflag = false;
bool possiblity[100000];
edge es[500000];
long long int d[100000];
void shortest_path(int s);
bool negative_path(int s);
bool reachable(int v);
int main(void) {
std::cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
int from, to, cost;
std::cin >> from >> to >> cost;
G[from].push_back(to);
// G[t].push_back(s);
es[i].from = from;
es[i].to = to;
es[i].cost = cost;
}
negativeflag = negative_path(r);
if (!negativeflag) {
shortest_path(r);
}
if (negativeflag) {
std::cout << "NEGATIVE CYCLE" << std::endl;
} else {
for (int i = 0; i < V; i++) {
if (d[i] != INF) {
std::cout << d[i] << std::endl;
} else {
std::cout << "INF" << std::endl;
}
}
}
return 0;
}
void shortest_path(int s) {
for (int i = 0; i < V; i++) {
d[i] = INF;
}
d[r] = 0;
while (1) {
// for(int j=0;j<V;j++){
bool flag = true;
for (int i = 0; i < E; i++) {
if (d[es[i].from] != INF) {
if (d[es[i].to] > d[es[i].from] + es[i].cost) {
d[es[i].to] = d[es[i].from] + es[i].cost;
flag = false;
}
}
}
if (flag) {
break;
}
}
}
bool negative_path(int s) {
bool flag = false;
for (int i = 0; i < V; i++) {
d[i] = INF;
possiblity[i] = false;
}
d[r] = 0;
for (int j = 0; j < V; j++) {
for (int i = 0; i < E; i++) {
if (d[es[i].from] != INF) {
if (d[es[i].to] > d[es[i].from] + es[i].cost) {
d[es[i].to] = d[es[i].from] + es[i].cost;
if (j == V - 1) {
flag = true;
}
}
}
}
}
return flag;
/*for(int i=0;i<V;i++){
std::cout<<d[i]<<std::endl;
}
if(flag==false){
return false;
}else {
flag=reachable(r);
return flag;
}*/
}
bool reachable(int v) {
possiblity[v] = true;
if (d[v] < 0) {
return true;
} else {
for (int i = 0; i < G[v].size(); i++) {
if (possiblity[G[v][i]] == false) {
return reachable(G[v][i]);
}
}
}
return false;
}
|
insert
| 70 | 70 | 70 | 71 |
TLE
| |
p02362
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long, int> P;
#define MAX_N 150000
#define INF 100000000000000
priority_queue<P, vector<P>, greater<P>> Q;
vector<pair<int, long long>> X[MAX_N];
int N, M, A, B, C, O;
long long dist[MAX_N];
void dijkstra() {
for (int i = 0; i < MAX_N; i++) {
dist[i] = INF;
}
Q.push(make_pair(0, O));
dist[O] = 0;
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 8000000 || Q.size() >= 5000000) {
cout << "NEGATIVE CYCLE" << endl;
return;
}
P pa = Q.top();
Q.pop();
long long a1 = pa.first;
int a2 = pa.second;
for (int i = 0; i < X[a2].size(); i++) {
int to = X[a2][i].first;
if (dist[to] > a1 + X[a2][i].second) {
dist[to] = a1 + X[a2][i].second;
Q.push(make_pair(dist[to], to));
}
}
}
for (int i = 0; i < N; i++) {
if (dist[i] == INF) {
cout << "INF" << endl;
} else {
cout << dist[i] << endl;
}
}
return;
}
int main() {
cin >> N >> M >> O;
for (int i = 0; i < M; i++) {
cin >> A >> B >> C;
X[A].push_back(make_pair(B, C));
}
dijkstra();
return 0;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long, int> P;
#define MAX_N 150000
#define INF 100000000000000
priority_queue<P, vector<P>, greater<P>> Q;
vector<pair<int, long long>> X[MAX_N];
int N, M, A, B, C, O;
long long dist[MAX_N];
void dijkstra() {
for (int i = 0; i < MAX_N; i++) {
dist[i] = INF;
}
Q.push(make_pair(0, O));
dist[O] = 0;
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 8000000 || Q.size() >= 2000000) {
cout << "NEGATIVE CYCLE" << endl;
return;
}
P pa = Q.top();
Q.pop();
long long a1 = pa.first;
int a2 = pa.second;
for (int i = 0; i < X[a2].size(); i++) {
int to = X[a2][i].first;
if (dist[to] > a1 + X[a2][i].second) {
dist[to] = a1 + X[a2][i].second;
Q.push(make_pair(dist[to], to));
}
}
}
for (int i = 0; i < N; i++) {
if (dist[i] == INF) {
cout << "INF" << endl;
} else {
cout << dist[i] << endl;
}
}
return;
}
int main() {
cin >> N >> M >> O;
for (int i = 0; i < M; i++) {
cin >> A >> B >> C;
X[A].push_back(make_pair(B, C));
}
dijkstra();
return 0;
}
|
replace
| 24 | 25 | 24 | 25 |
MLE
| |
p02362
|
C++
|
Runtime Error
|
/*ベルマンフォード法自作ライブラリ*/
/*標準:単一始点からの他の全頂点への最短距離 & 閉ループ判定
* ,option1:単一始点&終点の最短距離。&辞書順経路復元,option2:経路復元(非辞書順)*/
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define dump1d_arr(array) \
REP(i, array.size()) \
cerr << #array << "[" << (i) << "] ==> " << (array[i]) << endl;
#define dump2d_arr(array) \
REP(i, array.size()) \
REP(j, array[i].size()) cerr << #array << "[" << (i) << "]" \
<< "[" << (j) << "] ==> " << (array[i][j]) \
<< endl;
#define dump(x) cerr << #x << " => " << (x) << endl;
#define CLR(vec) \
{ REP(i, vec.size()) vec[i] = 0; }
#define loINF (long)10000000000
#define shINF (short)10000
#define SORT(c) sort((c).begin(), (c).end())
// #define TRACE_ROUTE
// #define TRACE_ROUTE_DIC
using namespace std;
typedef vector<long> VL;
typedef vector<VL> VVL;
typedef vector<char> VC;
// global変数
VVL edge; // 隣接リスト
VL dis;
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
VL pre;
#endif
short bellman_ford(long start, long V) {
long update_flag = 1;
long edge_start, edge_end, edge_dis;
long roop_count = 0;
while (update_flag) {
dump(roop_count);
if (++roop_count >= V)
return -1;
update_flag = 0;
REP(i, edge.size()) { // 辺の始点
edge_start = edge[i][0];
edge_end = edge[i][1];
edge_dis = edge[i][2];
if (dis[edge_start] == loINF)
continue; // まだ候補すらない頂点
if (dis[edge_start] + edge_dis < dis[edge_end]) {
dis[edge_end] = dis[edge_start] + edge_dis;
update_flag = 1;
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
pre[edge_end] = edge_start;
#endif
}
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
else {
if (dis[edge_start] + edge_dis == dis[edge_end] &&
pre[edge_end] > edge_start) {
pre[edge_end] = edge_start;
update_flag = 1;
}
}
#endif
}
}
return 0;
}
#ifdef TRACE_ROUTE
string trace_route(long start, long goal) {
string tmp;
string route("");
long ver = goal;
while (ver != start) {
tmp = ("-" + to_string(ver));
route = (tmp + route);
ver = pre[ver];
}
route = (to_string(start) + route);
return route;
}
#endif
#ifdef TRACE_ROUTE_DIC
string trace_route_dic(long start, long goal) {
string route("");
long ver = start;
while (ver != goal) {
route += (to_string(ver) + "-");
ver = pre[ver];
}
route += to_string(goal);
return route;
}
short bellman_ford_dic(long start, long goal, long V) {
short flag = bellman_ford(goal, V);
if (ans_val == -1)
cout << "exist negative loop" << endl;
if (ans_val == 0) {
// 最短距離の表示
cout << dis[start] << endl;
// 辞書順の経路復元
cout << trace_route_dic(start, goal) << endl;
} else
cerr << "error" << endl;
}
#endif
/* テンプレの入力フォーマット
V E
v11 v12 dis
v21 v22 dis
.
.
start (goal)
*/
int main(void) {
long V, E;
long ver1, ver2, weight;
long start;
// 入力部分1
cin >> V >> E >> start; // V:頂点数 , E:辺数
// 入力部分1 ここまで
edge = VVL(E, VL(3, 0)); // 辺の端点とコストの組を格納
// 入力部分2
REP(i, E) { // 辺の情報を入力
cin >> ver1 >> ver2 >> weight;
/*有向グラフ ver1 ==> ver2 */
edge[i][0] = ver1;
edge[i][1] = ver2;
edge[i][2] = weight;
}
// 入力部分2ここまで
dis = VL(V + 1, loINF);
dis[start] = 0; // スタート地点は距離0
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
pre = VL(V + 1, loINF);
pre[start] = start;
#endif
// 辞書順の経路復元を行う場合。
#ifdef TRACE_ROUTE_DIC
long goal cin >> goal;
bellman_ford_dic(start, goal, V);
exit(0);
#endif
// それ以外
long ans_val = bellman_ford(start, V);
if (ans_val == -1)
cout << "NEGATIVE CYCLE" << endl;
else {
if (ans_val == 0) {
// 最短距離の表示 dis[i]にstartから頂点iまでの最短距離が格納されている。
FOR(i, 0, V) {
if (dis[i] == loINF)
cout << "INF" << endl;
else
cout << dis[i] << endl;
// 経路復元
#ifdef TRACE_ROUTE
cout << trace_route(start, i) << endl;
#endif
}
} else
cerr << "error" << endl;
}
return 0;
}
|
/*ベルマンフォード法自作ライブラリ*/
/*標準:単一始点からの他の全頂点への最短距離 & 閉ループ判定
* ,option1:単一始点&終点の最短距離。&辞書順経路復元,option2:経路復元(非辞書順)*/
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define dump1d_arr(array) \
REP(i, array.size()) \
cerr << #array << "[" << (i) << "] ==> " << (array[i]) << endl;
#define dump2d_arr(array) \
REP(i, array.size()) \
REP(j, array[i].size()) cerr << #array << "[" << (i) << "]" \
<< "[" << (j) << "] ==> " << (array[i][j]) \
<< endl;
#define dump(x) cerr << #x << " => " << (x) << endl;
#define CLR(vec) \
{ REP(i, vec.size()) vec[i] = 0; }
#define loINF (long)10000000000
#define shINF (short)10000
#define SORT(c) sort((c).begin(), (c).end())
// #define TRACE_ROUTE
// #define TRACE_ROUTE_DIC
using namespace std;
typedef vector<long> VL;
typedef vector<VL> VVL;
typedef vector<char> VC;
// global変数
VVL edge; // 隣接リスト
VL dis;
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
VL pre;
#endif
short bellman_ford(long start, long V) {
long update_flag = 1;
long edge_start, edge_end, edge_dis;
long roop_count = 0;
while (update_flag) {
if (++roop_count > V)
return -1;
update_flag = 0;
REP(i, edge.size()) { // 辺の始点
edge_start = edge[i][0];
edge_end = edge[i][1];
edge_dis = edge[i][2];
if (dis[edge_start] == loINF)
continue; // まだ候補すらない頂点
if (dis[edge_start] + edge_dis < dis[edge_end]) {
dis[edge_end] = dis[edge_start] + edge_dis;
update_flag = 1;
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
pre[edge_end] = edge_start;
#endif
}
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
else {
if (dis[edge_start] + edge_dis == dis[edge_end] &&
pre[edge_end] > edge_start) {
pre[edge_end] = edge_start;
update_flag = 1;
}
}
#endif
}
}
return 0;
}
#ifdef TRACE_ROUTE
string trace_route(long start, long goal) {
string tmp;
string route("");
long ver = goal;
while (ver != start) {
tmp = ("-" + to_string(ver));
route = (tmp + route);
ver = pre[ver];
}
route = (to_string(start) + route);
return route;
}
#endif
#ifdef TRACE_ROUTE_DIC
string trace_route_dic(long start, long goal) {
string route("");
long ver = start;
while (ver != goal) {
route += (to_string(ver) + "-");
ver = pre[ver];
}
route += to_string(goal);
return route;
}
short bellman_ford_dic(long start, long goal, long V) {
short flag = bellman_ford(goal, V);
if (ans_val == -1)
cout << "exist negative loop" << endl;
if (ans_val == 0) {
// 最短距離の表示
cout << dis[start] << endl;
// 辞書順の経路復元
cout << trace_route_dic(start, goal) << endl;
} else
cerr << "error" << endl;
}
#endif
/* テンプレの入力フォーマット
V E
v11 v12 dis
v21 v22 dis
.
.
start (goal)
*/
int main(void) {
long V, E;
long ver1, ver2, weight;
long start;
// 入力部分1
cin >> V >> E >> start; // V:頂点数 , E:辺数
// 入力部分1 ここまで
edge = VVL(E, VL(3, 0)); // 辺の端点とコストの組を格納
// 入力部分2
REP(i, E) { // 辺の情報を入力
cin >> ver1 >> ver2 >> weight;
/*有向グラフ ver1 ==> ver2 */
edge[i][0] = ver1;
edge[i][1] = ver2;
edge[i][2] = weight;
}
// 入力部分2ここまで
dis = VL(V + 1, loINF);
dis[start] = 0; // スタート地点は距離0
#if defined(TRACE_ROUTE) || defined(TRACE_ROUTE_DIC)
pre = VL(V + 1, loINF);
pre[start] = start;
#endif
// 辞書順の経路復元を行う場合。
#ifdef TRACE_ROUTE_DIC
long goal cin >> goal;
bellman_ford_dic(start, goal, V);
exit(0);
#endif
// それ以外
long ans_val = bellman_ford(start, V);
if (ans_val == -1)
cout << "NEGATIVE CYCLE" << endl;
else {
if (ans_val == 0) {
// 最短距離の表示 dis[i]にstartから頂点iまでの最短距離が格納されている。
FOR(i, 0, V) {
if (dis[i] == loINF)
cout << "INF" << endl;
else
cout << dis[i] << endl;
// 経路復元
#ifdef TRACE_ROUTE
cout << trace_route(start, i) << endl;
#endif
}
} else
cerr << "error" << endl;
}
return 0;
}
|
replace
| 41 | 43 | 41 | 42 |
0
|
roop_count => 0
roop_count => 1
|
p02362
|
C++
|
Runtime Error
|
#include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <string>
#include <vector>
using namespace std;
const double pi = 4 * atan(1.0);
using cWeightEdges = std::vector<std::vector<std::pair<int, int>>>;
struct cVertex {
int dist;
int prev;
};
constexpr int parent_null = -1;
inline void initialize_vertices(vector<cVertex> &Vertices, int start) {
for (auto &vertex : Vertices) {
vertex.dist = INT_MAX;
vertex.prev = parent_null;
}
if (0 <= start && start < Vertices.size()) {
Vertices[start].dist = 0;
}
}
inline void relax(int from, int to, int weight_from_to,
vector<cVertex> &Vertices) {
if (from < 0 || Vertices.size() - 1 < from || to < 0 ||
Vertices.size() - 1 < to)
return;
//????????§???????????§??????????????????????????????
if (Vertices[from].dist == INT_MAX && Vertices[from].prev == parent_null)
return;
if (Vertices[to].dist > Vertices[from].dist + weight_from_to) {
Vertices[to].dist = Vertices[from].dist + weight_from_to;
Vertices[to].prev = from;
}
}
pair<vector<cVertex>, bool> solve_by_BellmanFord(const cWeightEdges &Edges,
int start) {
if (Edges.empty())
return pair<vector<cVertex>, bool>();
vector<cVertex> Vertices(Edges.size());
initialize_vertices(Vertices, start);
int EdgeNum = 0;
for (const auto edge : Edges) {
EdgeNum += edge.size();
}
// relaxation process
for (int i = 0; i < EdgeNum - 1; ++i) {
for (int j = 0; j < Edges.size(); ++j) {
for (const auto &val : Edges[j]) {
relax(j, val.first, val.second, Vertices);
}
}
}
// check the validity of the algorithm (if there exists some negative weight
// cycles, we cannot define shortest path)
for (int i = 0; i < Edges.size(); ++i) {
for (const auto &val : Edges[i]) {
if (Vertices[i].dist < INT_MAX &&
Vertices[val.first].dist > Vertices[i].dist + val.second) {
return make_pair(vector<cVertex>(), true);
}
}
}
return make_pair(Vertices, false);
}
int main() {
int N, M, root;
cin >> N >> M >> root;
cWeightEdges Edges(N);
for (int i = 0; i < M; ++i) {
int s, t, w;
cin >> s >> t >> w;
Edges[s].push_back(make_pair(t, w));
}
auto ans = solve_by_BellmanFord(Edges, root);
if (ans.second) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (const auto &val : ans.first) {
if (val.dist == INT_MAX) {
cout << "INF" << endl;
} else {
cout << val.dist << endl;
}
}
}
system("pause");
return 0;
}
|
#include <algorithm>
#include <array>
#include <climits>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <queue>
#include <string>
#include <vector>
using namespace std;
const double pi = 4 * atan(1.0);
using cWeightEdges = std::vector<std::vector<std::pair<int, int>>>;
struct cVertex {
int dist;
int prev;
};
constexpr int parent_null = -1;
inline void initialize_vertices(vector<cVertex> &Vertices, int start) {
for (auto &vertex : Vertices) {
vertex.dist = INT_MAX;
vertex.prev = parent_null;
}
if (0 <= start && start < Vertices.size()) {
Vertices[start].dist = 0;
}
}
inline void relax(int from, int to, int weight_from_to,
vector<cVertex> &Vertices) {
if (from < 0 || Vertices.size() - 1 < from || to < 0 ||
Vertices.size() - 1 < to)
return;
//????????§???????????§??????????????????????????????
if (Vertices[from].dist == INT_MAX && Vertices[from].prev == parent_null)
return;
if (Vertices[to].dist > Vertices[from].dist + weight_from_to) {
Vertices[to].dist = Vertices[from].dist + weight_from_to;
Vertices[to].prev = from;
}
}
pair<vector<cVertex>, bool> solve_by_BellmanFord(const cWeightEdges &Edges,
int start) {
if (Edges.empty())
return pair<vector<cVertex>, bool>();
vector<cVertex> Vertices(Edges.size());
initialize_vertices(Vertices, start);
int EdgeNum = 0;
for (const auto edge : Edges) {
EdgeNum += edge.size();
}
// relaxation process
for (int i = 0; i < EdgeNum - 1; ++i) {
for (int j = 0; j < Edges.size(); ++j) {
for (const auto &val : Edges[j]) {
relax(j, val.first, val.second, Vertices);
}
}
}
// check the validity of the algorithm (if there exists some negative weight
// cycles, we cannot define shortest path)
for (int i = 0; i < Edges.size(); ++i) {
for (const auto &val : Edges[i]) {
if (Vertices[i].dist < INT_MAX &&
Vertices[val.first].dist > Vertices[i].dist + val.second) {
return make_pair(vector<cVertex>(), true);
}
}
}
return make_pair(Vertices, false);
}
int main() {
int N, M, root;
cin >> N >> M >> root;
cWeightEdges Edges(N);
for (int i = 0; i < M; ++i) {
int s, t, w;
cin >> s >> t >> w;
Edges[s].push_back(make_pair(t, w));
}
auto ans = solve_by_BellmanFord(Edges, root);
if (ans.second) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (const auto &val : ans.first) {
if (val.dist == INT_MAX) {
cout << "INF" << endl;
} else {
cout << val.dist << endl;
}
}
}
// system("pause");
return 0;
}
|
replace
| 107 | 108 | 107 | 108 |
0
|
sh: 1: pause: not found
|
p02362
|
C++
|
Runtime Error
|
/* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
#define P pair<ll, ll>
/* ---------- Constants */
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */
class DirectedGraph {
struct edge {
int from;
int to;
int cost;
};
int edge_num = 0;
public:
int V;
int E;
vector<edge> edges;
DirectedGraph(int v, int e) : V(v), edges(e), E(e){};
void add_edge(int from, int to, int cost) {
edges[edge_num++] = {from, to, cost};
}
// O(E * V)
vector<int> bellman_ford(int s) {
vector<int> d(V, INF);
d[s] = 0;
for (int j = 0; j < V; j++) {
bool update = false;
for (int i = 0; i < E; i++) {
edge e = edges[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
if (j == V - 1) {
vector<int> dd(0);
return dd;
}
}
}
if (!update)
break;
}
return move(d);
}
};
signed main() {
int V, E, start;
cin >> V >> E >> start;
DirectedGraph dg = DirectedGraph(V, E);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
dg.add_edge(s, t, d);
}
vector<int> dis = dg.bellman_ford(start);
if (dis.size() == 0) {
cout << "NEGATIVE CYCLE" << endl;
}
for (int i = 0; i < V; i++) {
if (dis[i] == INF) {
cout << "INF" << endl;
continue;
}
cout << dis[i] << endl;
}
return 0;
}
|
/* ---------- STL Libraries ---------- */
// IO library
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm library
#include <algorithm>
#include <cmath>
#include <numeric>
#include <random>
// container library
#include <array>
#include <bitset>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <unordered_map>
#include <vector>
/* ---------- Namespace ---------- */
using namespace std;
/* ---------- Type ---------- */
using ll = long long;
#define int ll
#define P pair<ll, ll>
/* ---------- Constants */
const ll MOD = 1e9 + 7;
const int INF = 1LL << 55;
/* v-v-v-v-v-v-v-v-v Main Part v-v-v-v-v-v-v-v-v */
class DirectedGraph {
struct edge {
int from;
int to;
int cost;
};
int edge_num = 0;
public:
int V;
int E;
vector<edge> edges;
DirectedGraph(int v, int e) : V(v), edges(e), E(e){};
void add_edge(int from, int to, int cost) {
edges[edge_num++] = {from, to, cost};
}
// O(E * V)
vector<int> bellman_ford(int s) {
vector<int> d(V, INF);
d[s] = 0;
for (int j = 0; j < V; j++) {
bool update = false;
for (int i = 0; i < E; i++) {
edge e = edges[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
if (j == V - 1) {
vector<int> dd(0);
return dd;
}
}
}
if (!update)
break;
}
return move(d);
}
};
signed main() {
int V, E, start;
cin >> V >> E >> start;
DirectedGraph dg = DirectedGraph(V, E);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
dg.add_edge(s, t, d);
}
vector<int> dis = dg.bellman_ford(start);
if (dis.size() == 0) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
for (int i = 0; i < V; i++) {
if (dis[i] == INF) {
cout << "INF" << endl;
continue;
}
cout << dis[i] << endl;
}
return 0;
}
|
insert
| 103 | 103 | 103 | 104 |
0
| |
p02362
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
#define int ll
signed main() {
using pii = pair<int, int>;
using piii = pair<pii, int>;
int v, e, s;
cin >> v >> e >> s;
vector<int> d(v, LLONG_MAX);
vector<piii> edge;
rep(i, e) {
int from, to, cost;
cin >> from >> to >> cost;
edge.push_back(piii(pii(from, to), cost));
}
d[s] = 0;
rep(i, v) {
bool update = false;
rep(j, edge.size()) {
int to = edge[j].first.second;
int from = edge[j].first.first;
int cost = edge[j].second;
if (d[from] == LLONG_MAX)
continue;
if (d[to] > d[from] + cost) {
d[to] = d[from] + cost;
update = true;
}
}
if (i == v - 1 && update)
return puts("NEGATIVE CYCLE");
}
rep(i, v) if (d[i] != LLONG_MAX) cout << d[i] << endl;
else cout << "INF" << endl;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
using ll = long long;
#define int ll
signed main() {
using pii = pair<int, int>;
using piii = pair<pii, int>;
int v, e, s;
cin >> v >> e >> s;
vector<int> d(v, LLONG_MAX);
vector<piii> edge;
rep(i, e) {
int from, to, cost;
cin >> from >> to >> cost;
edge.push_back(piii(pii(from, to), cost));
}
d[s] = 0;
rep(i, v) {
bool update = false;
rep(j, edge.size()) {
int to = edge[j].first.second;
int from = edge[j].first.first;
int cost = edge[j].second;
if (d[from] == LLONG_MAX)
continue;
if (d[to] > d[from] + cost) {
d[to] = d[from] + cost;
update = true;
}
}
if (i == v - 1 && update)
return puts("NEGATIVE CYCLE") * 0;
}
rep(i, v) if (d[i] != LLONG_MAX) cout << d[i] << endl;
else cout << "INF" << endl;
}
|
replace
| 33 | 34 | 33 | 34 |
0
| |
p02362
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <iostream>
#include <vector>
#define INF 999999999
#define ll long long
using namespace std;
const int MAX_N = 1000;
const int MAX_M = 2000;
struct edge {
int from; //?????????
int to; //??°??????
int cost; //??????
};
int d[MAX_N];
edge es[MAX_M];
bool flag; //???????????????????????????
void shortest_path(
int n, int m,
int s) // s???????????????????????????????????????????????¢????±???????
{
int cnt = 0;
fill(d, d + n, INF);
d[s] = 0;
while (true && cnt < n) {
bool update = false;
for (int i = 0; i < m; i++) {
edge e = es[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
break;
}
if (cnt == n) {
flag = true;
}
}
int main() {
int i, n, m, s;
cin >> n; //????????°
cin >> m; //?????°
cin >> s; //???????????????
for (int i = 0; i < m; i++) {
scanf("%d", &es[i].from);
scanf("%d", &es[i].to);
scanf("%d", &es[i].cost);
}
flag = false;
shortest_path(n, m, s);
if (!flag) {
for (int i = 0; i < n; i++) {
if (d[i] == INF) {
cout << "INF\n";
} else {
cout << d[i] << "\n";
}
}
} else {
cout << "NEGATIVE CYCLE\n";
}
}
|
#include <cstdio>
#include <iostream>
#include <vector>
#define INF 999999999
#define ll long long
using namespace std;
const int MAX_N = 1000;
const int MAX_M = 2000;
struct edge {
int from; //?????????
int to; //??°??????
int cost; //??????
};
int d[MAX_N];
edge es[MAX_M];
bool flag; //???????????????????????????
void shortest_path(
int n, int m,
int s) // s???????????????????????????????????????????????¢????±???????
{
int cnt = 0;
fill(d, d + n, INF);
d[s] = 0;
while (true && cnt < n) {
bool update = false;
for (int i = 0; i < m; i++) {
edge e = es[i];
if (d[e.from] != INF && d[e.to] > d[e.from] + e.cost) {
d[e.to] = d[e.from] + e.cost;
update = true;
}
}
if (!update)
break;
cnt++;
}
if (cnt == n) {
flag = true;
}
}
int main() {
int i, n, m, s;
cin >> n; //????????°
cin >> m; //?????°
cin >> s; //???????????????
for (int i = 0; i < m; i++) {
scanf("%d", &es[i].from);
scanf("%d", &es[i].to);
scanf("%d", &es[i].cost);
}
flag = false;
shortest_path(n, m, s);
if (!flag) {
for (int i = 0; i < n; i++) {
if (d[i] == INF) {
cout << "INF\n";
} else {
cout << d[i] << "\n";
}
}
} else {
cout << "NEGATIVE CYCLE\n";
}
}
|
insert
| 40 | 40 | 40 | 41 |
TLE
| |
p02362
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
#define shosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const double pi = acos(-1);
class Graph {
private:
vvi Gpro, Gd;
vvp Glist;
int GV, GE;
public:
Graph(int x, int y, bool z) {
GV = x;
GE = y;
Gd = vvi(y, vi(y, inf));
if (z)
Gpro = vvi(x, vi(x, inf));
else
Glist = vvp(x);
}
void Gpro_add(int x, int y, int z) { Gpro[x][y] = z; }
void Glist_add(int x, int y, int z) { Glist[x].push_back(P(y, z)); }
int open(int x, int y) { return Gd[x][y]; }
void DIJplus(int x) {
priority_queue<P> que;
Gd[x][x] = 0;
que.push(P(0, x));
while (!que.empty()) {
P p = que.top();
p.first *= -1;
que.pop();
int v = p.second;
if (Gd[x][v] < p.first)
continue;
for (int i = 0; i < Glist[v].size(); i++) {
P e = Glist[v][i];
if (Gd[x][e.first] > Gd[x][v] + e.second) {
Gd[x][e.first] = Gd[x][v] + e.second;
que.push(P(-1 * Gd[x][e.first], e.first));
}
}
}
}
void BELLMAN(int x) {
Gd[x][x] = 0;
while (1) {
bool update = 1;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < Glist[i].size(); j++) {
P e = P(Glist[i][j].first, Glist[i][j].second);
if (Gd[x][i] != inf && Gd[x][e.first] > Gd[x][i] + e.second) {
Gd[x][e.first] = Gd[x][i] + e.second;
update = 0;
}
}
}
if (update)
break;
}
}
bool FNL(int x) {
Gd[x][x] = 0;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < Glist[j].size(); k++) {
P e = P(Glist[j][k].first, Glist[j][k].second);
if (Gd[x][j] != inf && Gd[x][e.first] > Gd[x][j] + e.second) {
Gd[x][e.first] = Gd[x][j] + e.second;
if (i == GV - 1)
return 1;
}
}
}
}
Gd = vvi(GV, vi(GV, inf));
return 0;
}
void WARSHALL() {
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < GV; k++)
Gd[i][j] = min(Gd[i][j], Gd[i][k] + Gd[k][j]);
}
}
}
int PRIM() {
int Gans = 0;
vi mincost(GV, inf);
vector<bool> used(GV, 1);
mincost[0] = 0;
while (1) {
int v = -1;
for (int i = 0; i < GV; i++) {
if (used[i] && (v == -1 || mincost[i] < mincost[v]))
v = i;
}
if (v == -1)
break;
used[v] = 0;
Gans += mincost[v];
for (int i = 0; i < GV; i++) {
mincost[i] = min(mincost[i], Gpro[v][i]);
}
}
return Gans;
}
};
int V, E, r;
int main() {
cin >> V >> E >> r;
Graph graph(V, E, 0);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
graph.Glist_add(s, t, d);
}
if (graph.FNL(r)) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
graph.BELLMAN(r);
for (int i = 0; i < V; i++) {
if (graph.open(r, i) == inf)
cout << "INF" << endl;
else
cout << graph.open(r, i) << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
#define shosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const double pi = acos(-1);
class Graph {
private:
vvi Gpro, Gd;
vvp Glist;
int GV, GE;
public:
Graph(int x, int y, bool z) {
GV = x;
GE = y;
Gd = vvi(x, vi(x, inf));
if (z)
Gpro = vvi(x, vi(x, inf));
else
Glist = vvp(x);
}
void Gpro_add(int x, int y, int z) { Gpro[x][y] = z; }
void Glist_add(int x, int y, int z) { Glist[x].push_back(P(y, z)); }
int open(int x, int y) { return Gd[x][y]; }
void DIJplus(int x) {
priority_queue<P> que;
Gd[x][x] = 0;
que.push(P(0, x));
while (!que.empty()) {
P p = que.top();
p.first *= -1;
que.pop();
int v = p.second;
if (Gd[x][v] < p.first)
continue;
for (int i = 0; i < Glist[v].size(); i++) {
P e = Glist[v][i];
if (Gd[x][e.first] > Gd[x][v] + e.second) {
Gd[x][e.first] = Gd[x][v] + e.second;
que.push(P(-1 * Gd[x][e.first], e.first));
}
}
}
}
void BELLMAN(int x) {
Gd[x][x] = 0;
while (1) {
bool update = 1;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < Glist[i].size(); j++) {
P e = P(Glist[i][j].first, Glist[i][j].second);
if (Gd[x][i] != inf && Gd[x][e.first] > Gd[x][i] + e.second) {
Gd[x][e.first] = Gd[x][i] + e.second;
update = 0;
}
}
}
if (update)
break;
}
}
bool FNL(int x) {
Gd[x][x] = 0;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < Glist[j].size(); k++) {
P e = P(Glist[j][k].first, Glist[j][k].second);
if (Gd[x][j] != inf && Gd[x][e.first] > Gd[x][j] + e.second) {
Gd[x][e.first] = Gd[x][j] + e.second;
if (i == GV - 1)
return 1;
}
}
}
}
Gd = vvi(GV, vi(GV, inf));
return 0;
}
void WARSHALL() {
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < GV; k++)
Gd[i][j] = min(Gd[i][j], Gd[i][k] + Gd[k][j]);
}
}
}
int PRIM() {
int Gans = 0;
vi mincost(GV, inf);
vector<bool> used(GV, 1);
mincost[0] = 0;
while (1) {
int v = -1;
for (int i = 0; i < GV; i++) {
if (used[i] && (v == -1 || mincost[i] < mincost[v]))
v = i;
}
if (v == -1)
break;
used[v] = 0;
Gans += mincost[v];
for (int i = 0; i < GV; i++) {
mincost[i] = min(mincost[i], Gpro[v][i]);
}
}
return Gans;
}
};
int V, E, r;
int main() {
cin >> V >> E >> r;
Graph graph(V, E, 0);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
graph.Glist_add(s, t, d);
}
if (graph.FNL(r)) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
graph.BELLMAN(r);
for (int i = 0; i < V; i++) {
if (graph.open(r, i) == inf)
cout << "INF" << endl;
else
cout << graph.open(r, i) << endl;
}
}
|
replace
| 29 | 30 | 29 | 30 |
0
| |
p02362
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 1005, INF = 1e9;
int d[MAXN], x[MAXN], y[MAXN], w[MAXN];
int n, m, r;
bool bellman_ford(int r) {
fill(d, d + n, INF);
d[r] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
d[y[j]] = min(d[y[j]], d[x[j]] + w[j]);
for (int j = 0; j < m; j++)
if (d[y[j]] > d[x[j]] + w[j] && d[y[j]] < INF / 10)
return true;
return false;
}
int main() {
cin >> n >> m >> r;
for (int i = 0; i < m; i++)
cin >> x[i] >> y[i] >> w[i];
if (bellman_ford(r))
cout << "NEGATIVE CYCLE" << endl;
else
for (int i = 0; i < n; i++)
if (d[i] > INF / 10)
cout << "INF" << endl;
else
cout << d[i] << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
const int MAXN = 2005, INF = 1e9;
int d[MAXN], x[MAXN], y[MAXN], w[MAXN];
int n, m, r;
bool bellman_ford(int r) {
fill(d, d + n, INF);
d[r] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
d[y[j]] = min(d[y[j]], d[x[j]] + w[j]);
for (int j = 0; j < m; j++)
if (d[y[j]] > d[x[j]] + w[j] && d[y[j]] < INF / 10)
return true;
return false;
}
int main() {
cin >> n >> m >> r;
for (int i = 0; i < m; i++)
cin >> x[i] >> y[i] >> w[i];
if (bellman_ford(r))
cout << "NEGATIVE CYCLE" << endl;
else
for (int i = 0; i < n; i++)
if (d[i] > INF / 10)
cout << "INF" << endl;
else
cout << d[i] << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02362
|
C++
|
Time Limit Exceeded
|
#define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, const vector<T> &);
template <size_t n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
const tuple<T...> &) {}
template <size_t n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
const tuple<T...> &t) {
os << (n == 0 ? "" : " ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T> ostream &operator<<(ostream &os, const tuple<T...> &t) {
_ot<0>(os, t);
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ") ";
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (size_t i = 0; i < v.size(); i++)
os << v[i] << (i + 1 == v.size() ? "" : ", ");
return os;
}
#ifdef DEBUG
#define dump(...) \
(cerr << #__VA_ARGS__ << " = " << make_tuple(__VA_ARGS__) \
<< " (L : " << __LINE__ << ")" << endl)
#else
#define dump(...)
#endif
#define all(c) begin(c), end(c)
#define range(i, a, b) for (int i = a; i < (int)(b); i++)
#define rep(i, b) range(i, 0, b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
typedef long long ll;
// #define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
void fastios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int const mod = 1000000007;
auto const inf = numeric_limits<int>::max() / 8;
using Weight = long long;
using Capacity = int;
struct Edge {
int src, dst;
Weight weight;
Edge(int s, int d, int w) : src(s), dst(d), weight(w) {}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;
int V, E, r;
pair<vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
if (!update)
break;
if (i > V) {
negCycle = true;
}
}
return make_pair(dist, !negCycle);
}
int main() {
while (cin >> V >> E >> r) {
Graph g(V);
rep(i, E) {
int a, b, c;
cin >> a >> b >> c;
g[a].eb(a, b, c);
}
auto ans = bellmanFord(g, r);
if (ans.second) {
for (int i = 0; i < V; i++) {
if (ans.first[i] > 1e10)
cout << "INF";
else
cout << ans.first[i];
cout << endl;
}
} else {
cout << "NEGATIVE CYCLE" << endl;
}
}
}
|
#define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> ostream &operator<<(ostream &os, const vector<T> &);
template <size_t n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
const tuple<T...> &) {}
template <size_t n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
const tuple<T...> &t) {
os << (n == 0 ? "" : " ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T> ostream &operator<<(ostream &os, const tuple<T...> &t) {
_ot<0>(os, t);
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ") ";
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
for (size_t i = 0; i < v.size(); i++)
os << v[i] << (i + 1 == v.size() ? "" : ", ");
return os;
}
#ifdef DEBUG
#define dump(...) \
(cerr << #__VA_ARGS__ << " = " << make_tuple(__VA_ARGS__) \
<< " (L : " << __LINE__ << ")" << endl)
#else
#define dump(...)
#endif
#define all(c) begin(c), end(c)
#define range(i, a, b) for (int i = a; i < (int)(b); i++)
#define rep(i, b) range(i, 0, b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
typedef long long ll;
// #define int ll
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
void fastios() {
ios_base::sync_with_stdio(0);
cin.tie(0);
}
int const mod = 1000000007;
auto const inf = numeric_limits<int>::max() / 8;
using Weight = long long;
using Capacity = int;
struct Edge {
int src, dst;
Weight weight;
Edge(int s, int d, int w) : src(s), dst(d), weight(w) {}
};
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;
int V, E, r;
pair<vector<Weight>, bool> bellmanFord(const Graph &g, int s) {
int n = g.size();
const Weight inf = numeric_limits<Weight>::max() / 8;
Edges es;
for (int i = 0; i < n; i++)
for (auto &e : g[i])
es.emplace_back(e);
vector<Weight> dist(n, inf);
dist[s] = 0;
bool negCycle = false;
for (int i = 0;; i++) {
bool update = false;
for (auto &e : es) {
if (dist[e.src] != inf && dist[e.dst] > dist[e.src] + e.weight) {
dist[e.dst] = dist[e.src] + e.weight;
update = true;
}
}
if (!update)
break;
if (i > V) {
negCycle = true;
break;
}
}
return make_pair(dist, !negCycle);
}
int main() {
while (cin >> V >> E >> r) {
Graph g(V);
rep(i, E) {
int a, b, c;
cin >> a >> b >> c;
g[a].eb(a, b, c);
}
auto ans = bellmanFord(g, r);
if (ans.second) {
for (int i = 0; i < V; i++) {
if (ans.first[i] > 1e10)
cout << "INF";
else
cout << ans.first[i];
cout << endl;
}
} else {
cout << "NEGATIVE CYCLE" << endl;
}
}
}
|
insert
| 89 | 89 | 89 | 90 |
TLE
| |
p02362
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1005;
struct edge {
int to, cost;
};
int n, m, s, cnt[maxn];
int d[maxn];
int qh, qt, q[maxn * maxn];
bool ok = 1, inq[maxn];
vector<edge> G[maxn];
int main() {
cin >> n >> m >> s;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
G[u].pb(edge{v, w});
}
memset(d, 0x3f, sizeof(d));
d[s] = 0;
q[qt++] = s;
inq[s] = 1;
while (qh < qt) {
int u = q[qh++];
inq[u] = 0;
for (edge e : G[u]) {
if (d[e.to] > d[u] + e.cost) {
d[e.to] = d[u] + e.cost;
if (!inq[e.to]) {
q[qt++] = e.to;
inq[e.to] = 1;
++cnt[e.to];
if (cnt[u] > m + 5) {
ok = 0;
break;
}
}
}
}
}
if (!ok) {
cout << "NEGATIVE CYCLE" << '\n';
return 0;
} else
for (int i = 0; i < n; i++)
if (d[i] == INF)
cout << "INF" << '\n';
else
cout << d[i] << '\n';
}
|
#include <bits/stdc++.h>
#define pb push_back
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 1005;
struct edge {
int to, cost;
};
int n, m, s, cnt[maxn];
int d[maxn];
int qh, qt, q[maxn * maxn];
bool ok = 1, inq[maxn];
vector<edge> G[maxn];
int main() {
cin >> n >> m >> s;
for (int i = 0; i < m; i++) {
int u, v, w;
cin >> u >> v >> w;
G[u].pb(edge{v, w});
}
memset(d, 0x3f, sizeof(d));
d[s] = 0;
q[qt++] = s;
inq[s] = 1;
while (qh < qt) {
int u = q[qh++];
inq[u] = 0;
for (edge e : G[u]) {
if (d[e.to] > d[u] + e.cost) {
d[e.to] = d[u] + e.cost;
if (!inq[e.to]) {
q[qt++] = e.to;
inq[e.to] = 1;
++cnt[e.to];
if (cnt[u] > m + 5) {
ok = 0;
break;
}
}
}
}
if (cnt[u] > m + 5) {
ok = 0;
break;
}
}
if (!ok) {
cout << "NEGATIVE CYCLE" << '\n';
return 0;
} else
for (int i = 0; i < n; i++)
if (d[i] == INF)
cout << "INF" << '\n';
else
cout << d[i] << '\n';
}
|
insert
| 44 | 44 | 44 | 48 |
0
| |
p02362
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
template <typename T>
vector<T> shortest_path_faster_algorithm(WeightedGraph<T> &g, int s) {
const auto INF = numeric_limits<T>::max();
vector<T> dist(g.size(), INF);
vector<int> pending(g.size(), 0), times(g.size(), 0);
queue<int> que;
que.emplace(s);
pending[s] = true;
++times[s];
dist[s] = 0;
while (!que.empty()) {
int p = que.front();
que.pop();
pending[p] = false;
for (auto &e : g[p]) {
T next_cost = dist[p] + e.cost;
if (next_cost >= dist[e.to])
continue;
dist[e.to] = next_cost;
if (!pending[e.to]) {
if (++times[e.to] >= g.size())
return vector<T>();
pending[e.to] = true;
que.emplace(e.to);
}
}
}
return dist;
}
int main() {
int V, E, R;
scanf("%d %d %d", &V, &E, &R);
WeightedGraph<int> g;
for (int i = 0; i < E; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
g[a].emplace_back(b, c);
}
auto dists = shortest_path_faster_algorithm(g, R);
if (dists.empty())
puts("NEGATIVE CYCLE");
for (auto &dist : dists) {
if (dist == numeric_limits<int>::max())
puts("INF");
else
printf("%d\n", dist);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T> struct edge {
int src, to;
T cost;
edge(int to, T cost) : src(-1), to(to), cost(cost) {}
edge(int src, int to, T cost) : src(src), to(to), cost(cost) {}
edge &operator=(const int &x) {
to = x;
return *this;
}
operator int() const { return to; }
};
template <typename T> using Edges = vector<edge<T>>;
template <typename T> using WeightedGraph = vector<Edges<T>>;
using UnWeightedGraph = vector<vector<int>>;
template <typename T> using Matrix = vector<vector<T>>;
template <typename T>
vector<T> shortest_path_faster_algorithm(WeightedGraph<T> &g, int s) {
const auto INF = numeric_limits<T>::max();
vector<T> dist(g.size(), INF);
vector<int> pending(g.size(), 0), times(g.size(), 0);
queue<int> que;
que.emplace(s);
pending[s] = true;
++times[s];
dist[s] = 0;
while (!que.empty()) {
int p = que.front();
que.pop();
pending[p] = false;
for (auto &e : g[p]) {
T next_cost = dist[p] + e.cost;
if (next_cost >= dist[e.to])
continue;
dist[e.to] = next_cost;
if (!pending[e.to]) {
if (++times[e.to] >= g.size())
return vector<T>();
pending[e.to] = true;
que.emplace(e.to);
}
}
}
return dist;
}
int main() {
int V, E, R;
scanf("%d %d %d", &V, &E, &R);
WeightedGraph<int> g(V);
for (int i = 0; i < E; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
g[a].emplace_back(b, c);
}
auto dists = shortest_path_faster_algorithm(g, R);
if (dists.empty())
puts("NEGATIVE CYCLE");
for (auto &dist : dists) {
if (dist == numeric_limits<int>::max())
puts("INF");
else
printf("%d\n", dist);
}
}
|
replace
| 60 | 61 | 60 | 61 |
-11
| |
p02362
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
typedef long long LL;
typedef long double LD;
const LL INF = (1LL << 60);
typedef pair<LL, int> PLL;
bool bellman_ford(int n, vector<PLL> adjList[], int source, vector<LL> &dist);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<PLL> adjList[1005];
int n, m, r;
cin >> n >> m >> r;
for (int i = 0; i < m; i++) {
int s, t;
LL d;
cin >> s >> t >> d;
adjList[s].push_back({d, t});
}
vector<LL> dist;
bool has_negative_cycle = bellman_ford(n, adjList, r, dist);
if (has_negative_cycle) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (int i = 0; i < n; i++) {
if (dist[i] == INF)
cout << "INF" << endl;
else
cout << dist[i] << endl;
}
}
return 0;
}
/*
* @param n: number of nodes from 0 to n-1
* @param adjList: adjacency list representation of the graph
* @param source: source for shortest path
*
* @return dist[i]: shortest distance from source to node i, INF if unreachable
*
* tested on: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_B
*/
bool bellman_ford(int n, vector<PLL> adjList[], int source, vector<LL> &dist) {
dist.assign(n, INF);
dist[source] = 0;
for (int i = 0; i < n - 1; i++)
for (int u = 0; u < n; u++)
if (dist[u] != INF)
for (PLL v : adjList[u])
dist[v.se] = min(dist[v.se], dist[u] + v.fi);
bool has_negative_cycle = false;
for (int u = 0; u < n; u++)
for (PLL v : adjList[u])
if (dist[v.se] > dist[u] + v.fi)
has_negative_cycle = true;
return has_negative_cycle;
}
|
#include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
typedef long long LL;
typedef long double LD;
const LL INF = (1LL << 60);
typedef pair<LL, int> PLL;
bool bellman_ford(int n, vector<PLL> adjList[], int source, vector<LL> &dist);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
vector<PLL> adjList[1005];
int n, m, r;
cin >> n >> m >> r;
for (int i = 0; i < m; i++) {
int s, t;
LL d;
cin >> s >> t >> d;
adjList[s].push_back({d, t});
}
vector<LL> dist;
bool has_negative_cycle = bellman_ford(n, adjList, r, dist);
if (has_negative_cycle) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (int i = 0; i < n; i++) {
if (dist[i] == INF)
cout << "INF" << endl;
else
cout << dist[i] << endl;
}
}
return 0;
}
/*
* @param n: number of nodes from 0 to n-1
* @param adjList: adjacency list representation of the graph
* @param source: source for shortest path
*
* @return dist[i]: shortest distance from source to node i, INF if unreachable
*
* tested on: http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=GRL_1_B
*/
bool bellman_ford(int n, vector<PLL> adjList[], int source, vector<LL> &dist) {
dist.assign(n, INF);
dist[source] = 0;
for (int i = 0; i < n - 1; i++)
for (int u = 0; u < n; u++)
if (dist[u] != INF)
for (PLL v : adjList[u])
dist[v.se] = min(dist[v.se], dist[u] + v.fi);
bool has_negative_cycle = false;
for (int u = 0; u < n; u++)
for (PLL v : adjList[u])
if (dist[u] != INF && dist[v.se] > dist[u] + v.fi)
has_negative_cycle = true;
return has_negative_cycle;
}
|
replace
| 71 | 72 | 71 | 72 |
TLE
| |
p02362
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_V 1000
#define MAX_E 2000
#define INF 1e9
struct edge {
int from, to, cost;
};
int V, E;
int d[MAX_V];
edge es[MAX_E];
bool find_negative_loop(int s) {
for (int i = 0; i < MAX_V; i++) {
d[i] = INF;
}
d[s] = 0;
int count = 0;
// bool update = false;
while (true) {
bool update = true;
count++;
for (int i = 0; i < E; i++) {
if ((d[es[i].from] != INF) &&
(d[es[i].to] > d[es[i].from] + es[i].cost)) {
if (count == V) {
return true;
}
d[es[i].to] = d[es[i].from] + es[i].cost;
update = true;
}
}
if (!update) {
break;
}
}
return false;
}
int main() {
int r;
cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
}
if (find_negative_loop(r)) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (int i = 0; i < V; i++) {
if (d[i] == INF) {
cout << "INF" << endl;
} else {
cout << d[i] << endl;
}
}
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
#define MAX_V 1000
#define MAX_E 2000
#define INF 1e9
struct edge {
int from, to, cost;
};
int V, E;
int d[MAX_V];
edge es[MAX_E];
bool find_negative_loop(int s) {
for (int i = 0; i < MAX_V; i++) {
d[i] = INF;
}
d[s] = 0;
int count = 0;
// bool update = false;
while (true) {
bool update = false;
count++;
for (int i = 0; i < E; i++) {
if ((d[es[i].from] != INF) &&
(d[es[i].to] > d[es[i].from] + es[i].cost)) {
if (count == V) {
return true;
}
d[es[i].to] = d[es[i].from] + es[i].cost;
update = true;
}
}
if (!update) {
break;
}
}
return false;
}
int main() {
int r;
cin >> V >> E >> r;
for (int i = 0; i < E; i++) {
cin >> es[i].from >> es[i].to >> es[i].cost;
}
if (find_negative_loop(r)) {
cout << "NEGATIVE CYCLE" << endl;
} else {
for (int i = 0; i < V; i++) {
if (d[i] == INF) {
cout << "INF" << endl;
} else {
cout << d[i] << endl;
}
}
}
return 0;
}
|
replace
| 20 | 21 | 20 | 21 |
TLE
| |
p02363
|
C++
|
Runtime Error
|
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
using s64 = int64_t;
constexpr s64 INF = 1'010'000'000'000'000'000LL;
template <typename T, typename U> bool chmin(T &xmin, const U &x) {
if (x < xmin) {
xmin = x;
return true;
} else {
return false;
}
}
#define FOR(i, start, end) for (s64 i = (start); i < (end); ++i)
#define REP(i, n) FOR(i, 0, n)
s64 N;
s64 M;
vector<vector<s64>> G;
void print_g(ostream &out) {
REP(i, N) {
REP(j, N) {
s64 c = G[i][j];
if (c == INF)
out << "INF";
else
out << c;
out << (j == N - 1 ? '\n' : ' ');
}
}
}
bool floyd() {
REP(k, N) {
REP(i, N) {
if (G[i][k] == INF)
continue;
REP(j, N) {
if (G[k][j] == INF)
continue;
chmin(G[i][j], G[i][k] + G[k][j]);
if (i == j && G[i][j] < 0)
return false;
}
}
}
return true;
}
void solve() {
floyd();
// print_g(cerr);
REP(i, N) { cerr << G[i][i] << "\n"; }
REP(i, N) {
if (G[i][i] < 0) {
cout << "NEGATIVE CYCLE\n";
return;
}
}
print_g(cout);
}
int main() {
cin >> N;
G.assign(N, vector<s64>(N, INF));
REP(i, N) { G[i][i] = 0; }
cin >> M;
REP(_, M) {
s64 a, b, c;
cin >> a >> b >> c;
G[a][b] = c;
}
solve();
return 0;
}
|
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
using s64 = int64_t;
constexpr s64 INF = 1'010'000'000'000'000'000LL;
template <typename T, typename U> bool chmin(T &xmin, const U &x) {
if (x < xmin) {
xmin = x;
return true;
} else {
return false;
}
}
#define FOR(i, start, end) for (s64 i = (start); i < (end); ++i)
#define REP(i, n) FOR(i, 0, n)
s64 N;
s64 M;
vector<vector<s64>> G;
void print_g(ostream &out) {
REP(i, N) {
REP(j, N) {
s64 c = G[i][j];
if (c == INF)
out << "INF";
else
out << c;
out << (j == N - 1 ? '\n' : ' ');
}
}
}
bool floyd() {
REP(k, N) {
REP(i, N) {
if (G[i][k] == INF)
continue;
REP(j, N) {
if (G[k][j] == INF)
continue;
chmin(G[i][j], G[i][k] + G[k][j]);
if (i == j && G[i][j] < 0)
return false;
}
}
}
return true;
}
void solve() {
if (!floyd()) {
cout << "NEGATIVE CYCLE\n";
return;
}
print_g(cout);
}
int main() {
cin >> N;
G.assign(N, vector<s64>(N, INF));
REP(i, N) { G[i][i] = 0; }
cin >> M;
REP(_, M) {
s64 a, b, c;
cin >> a >> b >> c;
G[a][b] = c;
}
solve();
return 0;
}
|
replace
| 58 | 67 | 58 | 61 |
0
|
0
0
0
0
|
p02363
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long, long long> P;
#define MAX_N 1000
#define INF 1000000000000000LL
vector<P> X[MAX_N];
priority_queue<P, vector<P>, greater<P>> Q;
long long dist[MAX_N];
long long N, M, A, B, C;
int solve(int P) {
while (!Q.empty()) {
Q.pop();
}
for (int i = 0; i < MAX_N; i++) {
dist[i] = INF;
}
dist[P] = 0;
Q.push(make_pair(0, P));
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 1000000) {
return 1;
}
pair<long long, long long> pa = Q.top();
Q.pop();
long long a1 = pa.first, a2 = pa.second;
for (int i = 0; i < X[a2].size(); i++) {
long long to = X[a2][i].first;
if (dist[to] > a1 + X[a2][i].second) {
dist[to] = a1 + X[a2][i].second;
Q.push(make_pair(dist[to], to));
}
}
}
for (int i = 0; i < N; i++) {
if (i >= 1) {
cout << ' ';
}
if (dist[i] == INF) {
cout << "INF";
} else {
cout << dist[i];
}
}
cout << endl;
return 0;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A >> B >> C;
X[A].push_back(make_pair(B, C));
}
for (int i = 0; i < N; i++) {
int B = solve(i);
if (B == 1) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
}
return 0;
}
|
#include <algorithm>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef pair<long long, long long> P;
#define MAX_N 1000
#define INF 1000000000000000LL
vector<P> X[MAX_N];
priority_queue<P, vector<P>, greater<P>> Q;
long long dist[MAX_N];
long long N, M, A, B, C;
int solve(int P) {
while (!Q.empty()) {
Q.pop();
}
for (int i = 0; i < MAX_N; i++) {
dist[i] = INF;
}
dist[P] = 0;
Q.push(make_pair(0, P));
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 500000) {
return 1;
}
pair<long long, long long> pa = Q.top();
Q.pop();
long long a1 = pa.first, a2 = pa.second;
for (int i = 0; i < X[a2].size(); i++) {
long long to = X[a2][i].first;
if (dist[to] > a1 + X[a2][i].second) {
dist[to] = a1 + X[a2][i].second;
Q.push(make_pair(dist[to], to));
}
}
}
for (int i = 0; i < N; i++) {
if (i >= 1) {
cout << ' ';
}
if (dist[i] == INF) {
cout << "INF";
} else {
cout << dist[i];
}
}
cout << endl;
return 0;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A >> B >> C;
X[A].push_back(make_pair(B, C));
}
for (int i = 0; i < N; i++) {
int B = solve(i);
if (B == 1) {
cout << "NEGATIVE CYCLE" << endl;
return 0;
}
}
return 0;
}
|
replace
| 28 | 29 | 28 | 29 |
MLE
| |
p02363
|
C++
|
Runtime Error
|
// #define MYDEBUG
#include <bits/stdc++.h>
using namespace std;
#ifdef MYDEBUG
#define dbp(x) cout << #x << ": " << x << endl
#define dbp2(x, y) cout << #x << "," << #y << ": " << x << "," << y << endl
#define dbp3(x, y, z) \
cout << #x << "," << #y << "," << #z << ": " << x << "," << y << "," << z \
<< endl
#define dbp4(w, x, y, z) \
cout << #w << "," << #x << "," << #y << "," << #z << ": " << w << "," << x \
<< "," << y << "," << z << endl
#else
#define dbp(x)
#define dbp2(x, y)
#define dbp3(x, y, z)
#define dbp4(w, x, y, z)
#endif
#define ll long long
#define ull unsigned long long
#define eps 1e-14
#define all(x) x.begin(), x.end()
#define rep(i, from, to) for (int i = from; i < to; ++i)
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
size_t last = v.size() - 1;
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
if (i != last)
out << ",";
}
out << "]";
return out;
}
struct edge {
int from, to, cost;
edge(int from, int to, int cost) {
this->from = from;
this->to = to;
this->cost = cost;
}
edge() {
from = -1;
to = -1;
cost = -1;
}
bool operator<(const edge &e) const { return this->cost < e.cost; }
bool operator>(const edge &e) const { return e < *this; }
bool operator>=(const edge &e) const { return !(*this < e); }
bool operator<=(const edge &e) const { return !(*this > e); }
};
typedef struct edge edge;
typedef pair<int, int> P;
const int MAXV = 1100;
const int MAXE = 2100;
const int INF = 1e9 + 1e7;
edge eg[MAXE];
int V, E;
int d[MAXV][MAXV];
const string NEGATIVE = "NEGATIVE CYCLE";
void warshall_floyd() {
rep(i, 0, V) {
fill(d[i], d[i] + MAXV, INF);
d[i][i] = 0;
}
rep(i, 0, E) {
edge e = eg[i];
d[e.from][e.to] = e.cost;
}
rep(k, 0, V) {
rep(i, 0, V) {
rep(j, 0, V) {
if (d[i][k] != INF && d[k][j] != INF) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
if (d[i][i] < 0) {
cout << NEGATIVE << endl;
return;
}
}
}
rep(i, 0, V) {
rep(j, 0, V) {
if (j != V - 1) {
if (d[i][j] == INF) {
cout << "INF"
<< " ";
} else {
cout << d[i][j] << " ";
}
} else {
if (d[i][j] == INF) {
cout << "INF";
} else {
cout << d[i][j];
}
}
}
cout << endl;
}
}
void solve() {
cin >> V >> E;
rep(i, 0, E) {
int s, t, d;
cin >> s >> t >> d;
eg[i] = edge(s, t, d);
}
warshall_floyd();
}
int main() {
solve();
return 0;
}
|
// #define MYDEBUG
#include <bits/stdc++.h>
using namespace std;
#ifdef MYDEBUG
#define dbp(x) cout << #x << ": " << x << endl
#define dbp2(x, y) cout << #x << "," << #y << ": " << x << "," << y << endl
#define dbp3(x, y, z) \
cout << #x << "," << #y << "," << #z << ": " << x << "," << y << "," << z \
<< endl
#define dbp4(w, x, y, z) \
cout << #w << "," << #x << "," << #y << "," << #z << ": " << w << "," << x \
<< "," << y << "," << z << endl
#else
#define dbp(x)
#define dbp2(x, y)
#define dbp3(x, y, z)
#define dbp4(w, x, y, z)
#endif
#define ll long long
#define ull unsigned long long
#define eps 1e-14
#define all(x) x.begin(), x.end()
#define rep(i, from, to) for (int i = from; i < to; ++i)
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
size_t last = v.size() - 1;
for (size_t i = 0; i < v.size(); ++i) {
out << v[i];
if (i != last)
out << ",";
}
out << "]";
return out;
}
struct edge {
int from, to, cost;
edge(int from, int to, int cost) {
this->from = from;
this->to = to;
this->cost = cost;
}
edge() {
from = -1;
to = -1;
cost = -1;
}
bool operator<(const edge &e) const { return this->cost < e.cost; }
bool operator>(const edge &e) const { return e < *this; }
bool operator>=(const edge &e) const { return !(*this < e); }
bool operator<=(const edge &e) const { return !(*this > e); }
};
typedef struct edge edge;
typedef pair<int, int> P;
const int MAXV = 110;
const int MAXE = 10000;
const int INF = 2140000000;
edge eg[MAXE];
int V, E;
int d[MAXV][MAXV];
const string NEGATIVE = "NEGATIVE CYCLE";
void warshall_floyd() {
rep(i, 0, V) {
fill(d[i], d[i] + MAXV, INF);
d[i][i] = 0;
}
rep(i, 0, E) {
edge e = eg[i];
d[e.from][e.to] = e.cost;
}
rep(k, 0, V) {
rep(i, 0, V) {
rep(j, 0, V) {
if (d[i][k] != INF && d[k][j] != INF) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
if (d[i][i] < 0) {
cout << NEGATIVE << endl;
return;
}
}
}
rep(i, 0, V) {
rep(j, 0, V) {
if (j != V - 1) {
if (d[i][j] == INF) {
cout << "INF"
<< " ";
} else {
cout << d[i][j] << " ";
}
} else {
if (d[i][j] == INF) {
cout << "INF";
} else {
cout << d[i][j];
}
}
}
cout << endl;
}
}
void solve() {
cin >> V >> E;
rep(i, 0, E) {
int s, t, d;
cin >> s >> t >> d;
eg[i] = edge(s, t, d);
}
warshall_floyd();
}
int main() {
solve();
return 0;
}
|
replace
| 57 | 60 | 57 | 60 |
0
| |
p02363
|
C++
|
Runtime Error
|
/* "A quote? by me? hell no!" */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#define F first
#define S second
#define ll long long
#define int ll
#define fast() ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define per() cout << fixed << setprecision(12)
#define pb push_back
#define FOR(i, a, b) \
for (int i = a; ((a < b) ? (i <= b) : (i >= b)); ((a < b) ? (i++) : (i--)))
// #define endl '\n'
// #define cin in
// #define cout out
using namespace std;
const int MAX_N = 1e2 + 10;
const int INF = 1e12 + 10;
const ll mod = 1e18;
ofstream out("output.txt");
ifstream in("intput.txt");
typedef pair<int, int> pii;
int bpow(int t, int n) {
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * t) % mod;
t = (t * t) % mod, n >>= 1;
}
return ans;
}
int from[MAX_N], to[MAX_N], w[MAX_N];
int n, m;
int d[MAX_N][MAX_N];
bool relax(int e, int s) {
if (d[s][to[e]] > d[s][from[e]] + w[e] && d[s][from[e]] != INF) {
d[s][to[e]] = d[s][from[e]] + w[e];
return true;
}
return false;
}
bool ok = true;
void bellman(int s) {
fill(d[s], d[s] + MAX_N, INF);
d[s][s] = 0;
for (int i = 0; i < n - 1; i++)
for (int e = 0; e < m; e++)
relax(e, s);
for (int e = 0; e < m; e++)
if (relax(e, s))
ok = false;
}
int32_t main() {
fast();
per();
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> from[i] >> to[i] >> w[i];
for (int i = 0; i < n; i++)
bellman(i);
if (!ok)
return cout << "NEGATIVE CYCLE\n", 0;
for (int v = 0; v < n; v++, cout << '\n')
for (int u = 0; u < n; u++) {
if (d[v][u] != INF)
cout << d[v][u];
else
cout << "INF";
if (u != n - 1)
cout << " ";
}
}
|
/* "A quote? by me? hell no!" */
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
#define F first
#define S second
#define ll long long
#define int ll
#define fast() ios::sync_with_stdio(false), cin.tie(0), cout.tie(0)
#define per() cout << fixed << setprecision(12)
#define pb push_back
#define FOR(i, a, b) \
for (int i = a; ((a < b) ? (i <= b) : (i >= b)); ((a < b) ? (i++) : (i--)))
// #define endl '\n'
// #define cin in
// #define cout out
using namespace std;
const int MAX_N = 1e2 + 10;
const int INF = 1e12 + 10;
const ll mod = 1e18;
ofstream out("output.txt");
ifstream in("intput.txt");
typedef pair<int, int> pii;
int bpow(int t, int n) {
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * t) % mod;
t = (t * t) % mod, n >>= 1;
}
return ans;
}
int from[MAX_N * 100], to[MAX_N * 100], w[MAX_N * 100];
int n, m;
int d[MAX_N][MAX_N];
bool relax(int e, int s) {
if (d[s][to[e]] > d[s][from[e]] + w[e] && d[s][from[e]] != INF) {
d[s][to[e]] = d[s][from[e]] + w[e];
return true;
}
return false;
}
bool ok = true;
void bellman(int s) {
fill(d[s], d[s] + MAX_N, INF);
d[s][s] = 0;
for (int i = 0; i < n - 1; i++)
for (int e = 0; e < m; e++)
relax(e, s);
for (int e = 0; e < m; e++)
if (relax(e, s))
ok = false;
}
int32_t main() {
fast();
per();
cin >> n >> m;
for (int i = 0; i < m; i++)
cin >> from[i] >> to[i] >> w[i];
for (int i = 0; i < n; i++)
bellman(i);
if (!ok)
return cout << "NEGATIVE CYCLE\n", 0;
for (int v = 0; v < n; v++, cout << '\n')
for (int u = 0; u < n; u++) {
if (d[v][u] != INF)
cout << d[v][u];
else
cout << "INF";
if (u != n - 1)
cout << " ";
}
}
|
replace
| 41 | 42 | 41 | 42 |
0
| |
p02363
|
C++
|
Runtime Error
|
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef int32_t i32;
typedef int64_t i64;
typedef i64 ll;
typedef uint32_t uint;
typedef uint64_t ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) \
for (__typeof((o).begin()) it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
EACH(a, ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
EACH(p, m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <class T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
namespace EGraph {
typedef ll Cost;
Cost CINF = INF<Cost>();
struct Edge {
int from, to;
Cost cost;
Edge(int from, int to, Cost cost) : from(from), to(to), cost(cost){};
bool operator<(Edge r) const { return cost < r.cost; }
bool operator>(Edge r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
} // namespace EGraph
using namespace EGraph;
namespace ShortestPath {
using namespace EGraph;
struct Task {
int prev, pos;
Cost cost;
Task(int prev, int pos, Cost cost) : prev(prev), pos(pos), cost(cost){};
bool operator>(const Task &r) const { return cost > r.cost; }
};
// 最大も可 負の閉路が判定可能
// O(V*E)
vector<Cost> bellmanFord(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<Cost> d(V, CINF);
d[s] = 0;
fill(ALL(prev), -2);
REP(loop, V) {
REP(v, V) EACH(e, g[v]) if (d[v] != CINF) if (d[e->to] > d[v] + e->cost) {
d[e->to] = d[v] + e->cost;
prev[e->to] = e->from;
if (loop == V - 1)
d[e->to] = -CINF;
}
}
return d;
}
vector<Cost> bellmanFord(const Graph &g, const int s) {
vector<int> prev(g.size());
return bellmanFord(g, s, prev);
}
} // namespace ShortestPath
using namespace ShortestPath;
stringstream ss;
class Main {
public:
void run() {
int n, m;
cin >> n >> m;
Graph g(n);
REP(i, m) {
int s, t, d;
cin >> s >> t >> d;
g[s].push_back(Edge(s, t, d));
}
vector<vector<string>> res;
REP(r, n) {
auto ds = bellmanFord(g, r);
for (auto v : ds)
if (v == -CINF) {
cout << "NEGATIVE CYCLE" << endl;
return;
}
REP(i, n) {
if (ds[i] == CINF)
res[r][i] = "INF";
else {
ss << ds[i];
ss >> res[r][i];
ss.clear();
}
}
}
cout << res << endl;
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
}
|
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef int32_t i32;
typedef int64_t i64;
typedef i64 ll;
typedef uint32_t uint;
typedef uint64_t ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) \
for (__typeof((o).begin()) it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
EACH(a, ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
EACH(p, m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <class T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
namespace EGraph {
typedef ll Cost;
Cost CINF = INF<Cost>();
struct Edge {
int from, to;
Cost cost;
Edge(int from, int to, Cost cost) : from(from), to(to), cost(cost){};
bool operator<(Edge r) const { return cost < r.cost; }
bool operator>(Edge r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
} // namespace EGraph
using namespace EGraph;
namespace ShortestPath {
using namespace EGraph;
struct Task {
int prev, pos;
Cost cost;
Task(int prev, int pos, Cost cost) : prev(prev), pos(pos), cost(cost){};
bool operator>(const Task &r) const { return cost > r.cost; }
};
// 最大も可 負の閉路が判定可能
// O(V*E)
vector<Cost> bellmanFord(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<Cost> d(V, CINF);
d[s] = 0;
fill(ALL(prev), -2);
REP(loop, V) {
REP(v, V) EACH(e, g[v]) if (d[v] != CINF) if (d[e->to] > d[v] + e->cost) {
d[e->to] = d[v] + e->cost;
prev[e->to] = e->from;
if (loop == V - 1)
d[e->to] = -CINF;
}
}
return d;
}
vector<Cost> bellmanFord(const Graph &g, const int s) {
vector<int> prev(g.size());
return bellmanFord(g, s, prev);
}
} // namespace ShortestPath
using namespace ShortestPath;
stringstream ss;
class Main {
public:
void run() {
int n, m;
cin >> n >> m;
Graph g(n);
REP(i, m) {
int s, t, d;
cin >> s >> t >> d;
g[s].push_back(Edge(s, t, d));
}
vector<vector<string>> res(n, vector<string>(n));
REP(r, n) {
auto ds = bellmanFord(g, r);
for (auto v : ds)
if (v == -CINF) {
cout << "NEGATIVE CYCLE" << endl;
return;
}
REP(i, n) {
if (ds[i] == CINF)
res[r][i] = "INF";
else {
ss << ds[i];
ss >> res[r][i];
ss.clear();
}
}
}
cout << res << endl;
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
}
|
replace
| 185 | 186 | 185 | 186 |
-11
| |
p02363
|
C++
|
Runtime Error
|
#include <algorithm>
#include <array>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <map>
#include <math.h>
#define SENTINEL 1000000001
#define min(a, b) ((a) > (b) ? (b) : (a))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define INF 200000000000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
struct OwnEdge {
ll from, to, cost;
OwnEdge() : from(-1), to(-1), cost(-1) {}
OwnEdge(ll from, ll to, ll cost) : from(from), to(to), cost(cost) {}
};
OwnEdge edges[2000];
ll tod[100][100];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
scanf("%d %d", &V, &E);
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++) {
tod[i][j] = INF;
}
for (int i = 0; i < E; i++) {
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
edges[i] = OwnEdge(s, t, d);
}
for (int k = 0; k < V; k++) {
tod[k][k] = 0;
bool ns = false;
for (int i = 0; i < V; i++) {
for (int j = 0; j < E; j++) {
OwnEdge t = edges[j];
if (tod[k][t.from] != INF && tod[k][t.to] > (tod[k][t.from] + t.cost)) {
tod[k][t.to] = (tod[k][t.from] + t.cost);
if (i == (V - 1)) {
ns = true;
}
}
}
}
if (ns) {
printf("NEGATIVE CYCLE\n");
return 0;
}
}
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (j == 0) {
printf(tod[i][j] == INF ? "INF" : "%lld", tod[i][j]);
} else {
printf(tod[i][j] == INF ? " INF" : " %lld", tod[i][j]);
}
}
printf("\n");
}
return 0;
}
|
#include <algorithm>
#include <array>
#include <cstdio>
#include <functional>
#include <iostream>
#include <list>
#include <numeric>
#include <queue>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define _USE_MATH_DEFINES
#include <map>
#include <math.h>
#define SENTINEL 1000000001
#define min(a, b) ((a) > (b) ? (b) : (a))
#define max(a, b) ((a) > (b) ? (a) : (b))
#define INF 200000000000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<ll, int> pli;
struct OwnEdge {
ll from, to, cost;
OwnEdge() : from(-1), to(-1), cost(-1) {}
OwnEdge(ll from, ll to, ll cost) : from(from), to(to), cost(cost) {}
};
OwnEdge edges[10000];
ll tod[100][100];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
scanf("%d %d", &V, &E);
for (int i = 0; i < V; i++)
for (int j = 0; j < V; j++) {
tod[i][j] = INF;
}
for (int i = 0; i < E; i++) {
int s, t, d;
scanf("%d %d %d", &s, &t, &d);
edges[i] = OwnEdge(s, t, d);
}
for (int k = 0; k < V; k++) {
tod[k][k] = 0;
bool ns = false;
for (int i = 0; i < V; i++) {
for (int j = 0; j < E; j++) {
OwnEdge t = edges[j];
if (tod[k][t.from] != INF && tod[k][t.to] > (tod[k][t.from] + t.cost)) {
tod[k][t.to] = (tod[k][t.from] + t.cost);
if (i == (V - 1)) {
ns = true;
}
}
}
}
if (ns) {
printf("NEGATIVE CYCLE\n");
return 0;
}
}
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
if (j == 0) {
printf(tod[i][j] == INF ? "INF" : "%lld", tod[i][j]);
} else {
printf(tod[i][j] == INF ? " INF" : " %lld", tod[i][j]);
}
}
printf("\n");
}
return 0;
}
|
replace
| 37 | 38 | 37 | 38 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
struct side {
int n;
int m;
int l;
};
side sides[100000];
void mergesort(int l, int r) {
if (l == r)
return;
side temp;
if (l == r - 1) {
if (sides[l].l > sides[r].l) {
temp = sides[l];
sides[l] = sides[r];
sides[r] = temp;
}
return;
}
int mid = (l + r) / 2, now = 0;
side b[r - l + 1];
mergesort(l, mid - 1);
mergesort(mid, r);
for (int i = 0; i <= r - l; i++) {
if (sides[i + l - now].l < sides[mid + now].l) {
b[i] = sides[i + l - now];
if (i + l - now == mid - 1) {
for (i++; i <= r - l; i++) {
b[i] = sides[mid + now];
now++;
}
}
} else {
b[i] = sides[mid + now];
now++;
if (mid + now > r) {
for (i++; i <= r - l; i++)
b[i] = sides[i + l - now];
}
}
}
for (int i = 0; i <= r - l; i++)
sides[i + l] = b[i];
}
int main() {
int n, m, a, ans = 0, c = 1;
bool tree[10000];
scanf("%d%d", &n, &m);
tree[0] = true;
for (int i = 1; i < n; i++) {
tree[i] = false;
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &sides[i].n, &sides[i].m, &sides[i].l);
}
mergesort(0, m - 1);
while (c < n) {
a = 0;
while (tree[sides[a].n] == tree[sides[a].m])
a++;
ans += sides[a].l;
tree[sides[a].n] = tree[sides[a].m] = true;
c++;
}
printf("%d\n", ans);
}
|
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
struct side {
int n;
int m;
int l;
};
side sides[100000];
void mergesort(int l, int r) {
if (l == r)
return;
side temp;
if (l == r - 1) {
if (sides[l].l > sides[r].l) {
temp = sides[l];
sides[l] = sides[r];
sides[r] = temp;
}
return;
}
int mid = (l + r) / 2, now = 0;
side b[r - l + 1];
mergesort(l, mid - 1);
mergesort(mid, r);
for (int i = 0; i <= r - l; i++) {
if (sides[i + l - now].l < sides[mid + now].l) {
b[i] = sides[i + l - now];
if (i + l - now == mid - 1) {
for (i++; i <= r - l; i++) {
b[i] = sides[mid + now];
now++;
}
}
} else {
b[i] = sides[mid + now];
now++;
if (mid + now > r) {
for (i++; i <= r - l; i++)
b[i] = sides[i + l - now];
}
}
}
for (int i = 0; i <= r - l; i++)
sides[i + l] = b[i];
}
int main() {
int n, m, a, ans = 0, c = 1;
bool tree[10000];
scanf("%d%d", &n, &m);
if (m == 0) {
printf("0\n");
return 0;
}
tree[0] = true;
for (int i = 1; i < n; i++) {
tree[i] = false;
}
for (int i = 0; i < m; i++) {
scanf("%d%d%d", &sides[i].n, &sides[i].m, &sides[i].l);
}
mergesort(0, m - 1);
while (c < n) {
a = 0;
while (tree[sides[a].n] == tree[sides[a].m])
a++;
ans += sides[a].l;
tree[sides[a].n] = tree[sides[a].m] = true;
c++;
}
printf("%d\n", ans);
}
|
insert
| 51 | 51 | 51 | 55 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
using edge = tuple<int, int, int>;
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) {}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
}
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
cin >> V >> E;
UnionFind uf(V);
vector<edge> edges;
while (E--) {
int s, t, w;
cin >> s >> t >> w;
edges.emplace_back(w, s, t);
}
sort(begin(edges), end(edges));
int total_weight = 0;
int pos = 0;
int u, v, w;
tie(w, u, v) = edges[pos];
for (int i = 1; i < V; ++i) {
while (uf.root(u) == uf.root(v)) {
++pos;
w = get<0>(edges[pos]);
u = get<1>(edges[pos]);
v = get<2>(edges[pos]);
}
uf.unite(u, v);
total_weight += w;
}
cout << total_weight << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using edge = tuple<int, int, int>;
struct UnionFind {
vector<int> data;
UnionFind(int size) : data(size, -1) {}
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x != y) {
if (data[y] < data[x])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
}
int root(int x) { return data[x] < 0 ? x : data[x] = root(data[x]); }
int size(int x) { return -data[root(x)]; }
};
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int V, E;
cin >> V >> E;
if (V == 1) {
cout << 0 << endl;
return 0;
}
UnionFind uf(V);
vector<edge> edges;
while (E--) {
int s, t, w;
cin >> s >> t >> w;
edges.emplace_back(w, s, t);
}
sort(begin(edges), end(edges));
int total_weight = 0;
int pos = 0;
int u, v, w;
tie(w, u, v) = edges[pos];
for (int i = 1; i < V; ++i) {
while (uf.root(u) == uf.root(v)) {
++pos;
w = get<0>(edges[pos]);
u = get<1>(edges[pos]);
v = get<2>(edges[pos]);
}
uf.unite(u, v);
total_weight += w;
}
cout << total_weight << endl;
return 0;
}
|
insert
| 26 | 26 | 26 | 30 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
struct UF {
int N, par[100], sz[100];
void init(int _N) {
N = _N;
for (int i = 0; i < N; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (sz[x] < sz[y])
swap(x, y);
par[y] = x;
sz[x] += sz[y];
}
bool isSame(int x, int y) { return find(x) == find(y); }
};
typedef pair<int, int> P;
typedef pair<int, P> PP;
int main() {
int N, M;
cin >> N >> M;
vector<PP> es;
for (int i = 0; i < M; i++) {
int s, t, w;
cin >> s >> t >> w;
es.push_back(PP(w, P(s, t)));
}
sort(es.begin(), es.end());
UF uf;
uf.init(N);
int ans = 0;
for (int i = 0; i < M; i++) {
PP p = es[i];
if (uf.isSame(p.second.first, p.second.second))
continue;
ans += p.first;
uf.unite(p.second.first, p.second.second);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct UF {
int N, par[10000], sz[10000];
void init(int _N) {
N = _N;
for (int i = 0; i < N; i++) {
par[i] = i;
sz[i] = 1;
}
}
int find(int x) { return x == par[x] ? x : par[x] = find(par[x]); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (sz[x] < sz[y])
swap(x, y);
par[y] = x;
sz[x] += sz[y];
}
bool isSame(int x, int y) { return find(x) == find(y); }
};
typedef pair<int, int> P;
typedef pair<int, P> PP;
int main() {
int N, M;
cin >> N >> M;
vector<PP> es;
for (int i = 0; i < M; i++) {
int s, t, w;
cin >> s >> t >> w;
es.push_back(PP(w, P(s, t)));
}
sort(es.begin(), es.end());
UF uf;
uf.init(N);
int ans = 0;
for (int i = 0; i < M; i++) {
PP p = es[i];
if (uf.isSame(p.second.first, p.second.second))
continue;
ans += p.first;
uf.unite(p.second.first, p.second.second);
}
cout << ans << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02364
|
C++
|
Runtime Error
|
/* *******************Bismillahir Rahmanir Rahim************************
MD. ASFAKUL GHANI!
*ProMAGFAT*!
SECRET_warning :)->FAT CSE-25!
JAHANGIRNAGAR UNIVERSITY!
Dhaka,Bangladesh!
*/
#include <bits/stdc++.h>
#include <set>
using namespace std;
#define fasterIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define Im int main()
#define ll long long
#define sc scanf
#define pf printf
#define rn0 return 0
#define rn return
#define f0(i, n) for (ll i = 0; i < n; i++)
#define f1(i, n) for (ll i = 1; i <= n; i++)
#define f2(i, n) for (ll i = n - 1; i >= 0; i--)
#define pi 2 * acos(0.0)
#define modulo 1000003
#define dd double
#define PI 3.14159265358979
#define pi 2 * acos(0.0)
#define p_b push_back
#define ps push
/*
ll for_binarySearch(ll a,ll b,ll aa[],ll x){while(a<=b){ll
mid=(a+b)/2;if(aa[mid]==x) return 1;else if(aa[mid] > x) b=mid-1;else
a=mid+1;}return -1;} ll for_gcd(ll a,ll b){if(a==0) return b;else return
for_gcd(b%a,a);} ll for_prime(ll x){for (ll i=2;i*i<=x;i++){if(x%i==0) return
0;}return 1;} void for_swap(char *x,char *y){char temp;temp=*x;*x=*y;*y=temp;}
ll for_big_mod(ll b,ll p,ll m){if(p==0) return 1;else if(p%2==0){ll
k=for_big_mod(b,p/2,m);return (k*k)%m;}else return
((b%m)*(for_big_mod(b,p-1,m)))%m;} ll for_josephus(ll n,ll k){if(n==1) return
1;return (for_josephus(n-1,k)+k-1)%n+1;} ll for_gcdExtended(ll a,ll b,ll *x,ll
*y){if(a==0){*x=0;*y=1;return b;}ll x1,y1;ll
gcd=for_gcdExtended(b%a,a,&x1,&y1);*x=y1-(b/a)*x1;*y=x1;return gcd;}
*/
void debug1() { cout << "***" << endl; }
void debug11(ll n) { cout << n << endl; }
ll n, q;
ll par[1010];
ll rnk[1010];
pair<ll, pair<ll, ll>> pp[101010];
void FAT_init() {
for (ll i = 0; i < n; i += 1) {
par[i] = i, rnk[i] = 0;
}
}
ll FAT_find(ll x) {
if (x == par[x])
rn x;
else
rn par[x] = FAT_find(par[x]);
}
void FAT_union(ll a, ll b) {
ll x = FAT_find(a);
ll y = FAT_find(b);
if (rnk[x] > rnk[y]) {
par[y] = x;
} else if (rnk[y] > rnk[x]) {
par[x] = y;
} else {
par[y] = x;
rnk[x] += 1;
}
}
ll FAT_kruskal(pair<ll, pair<ll, ll>> pp[]) {
ll cnt = 0;
for (ll i = 0; i < q; i += 1) {
ll c = pp[i].first;
ll a = pp[i].second.first;
ll b = pp[i].second.second;
if (FAT_find(a) != FAT_find(b)) {
cnt += c;
// debug11(cnt);
FAT_union(a, b);
}
}
rn cnt;
}
Im {
/*#ifdef FAT
freopen("input.txt","w",stdin);
#endif // FAT*/
// fasterIO;
cin >> n >> q;
FAT_init();
for (ll i = 0; i < q; i += 1) {
ll u, v, w;
cin >> u >> v >> w;
pp[i] = make_pair(w, make_pair(u, v));
}
sort(pp, pp + q);
ll c1 = FAT_kruskal(pp);
cout << c1 << endl;
// main();
rn0;
}
|
/* *******************Bismillahir Rahmanir Rahim************************
MD. ASFAKUL GHANI!
*ProMAGFAT*!
SECRET_warning :)->FAT CSE-25!
JAHANGIRNAGAR UNIVERSITY!
Dhaka,Bangladesh!
*/
#include <bits/stdc++.h>
#include <set>
using namespace std;
#define fasterIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL)
#define Im int main()
#define ll long long
#define sc scanf
#define pf printf
#define rn0 return 0
#define rn return
#define f0(i, n) for (ll i = 0; i < n; i++)
#define f1(i, n) for (ll i = 1; i <= n; i++)
#define f2(i, n) for (ll i = n - 1; i >= 0; i--)
#define pi 2 * acos(0.0)
#define modulo 1000003
#define dd double
#define PI 3.14159265358979
#define pi 2 * acos(0.0)
#define p_b push_back
#define ps push
/*
ll for_binarySearch(ll a,ll b,ll aa[],ll x){while(a<=b){ll
mid=(a+b)/2;if(aa[mid]==x) return 1;else if(aa[mid] > x) b=mid-1;else
a=mid+1;}return -1;} ll for_gcd(ll a,ll b){if(a==0) return b;else return
for_gcd(b%a,a);} ll for_prime(ll x){for (ll i=2;i*i<=x;i++){if(x%i==0) return
0;}return 1;} void for_swap(char *x,char *y){char temp;temp=*x;*x=*y;*y=temp;}
ll for_big_mod(ll b,ll p,ll m){if(p==0) return 1;else if(p%2==0){ll
k=for_big_mod(b,p/2,m);return (k*k)%m;}else return
((b%m)*(for_big_mod(b,p-1,m)))%m;} ll for_josephus(ll n,ll k){if(n==1) return
1;return (for_josephus(n-1,k)+k-1)%n+1;} ll for_gcdExtended(ll a,ll b,ll *x,ll
*y){if(a==0){*x=0;*y=1;return b;}ll x1,y1;ll
gcd=for_gcdExtended(b%a,a,&x1,&y1);*x=y1-(b/a)*x1;*y=x1;return gcd;}
*/
void debug1() { cout << "***" << endl; }
void debug11(ll n) { cout << n << endl; }
ll n, q;
ll par[101000];
ll rnk[101000];
pair<ll, pair<ll, ll>> pp[101010];
void FAT_init() {
for (ll i = 0; i < n; i += 1) {
par[i] = i, rnk[i] = 0;
}
}
ll FAT_find(ll x) {
if (x == par[x])
rn x;
else
rn par[x] = FAT_find(par[x]);
}
void FAT_union(ll a, ll b) {
ll x = FAT_find(a);
ll y = FAT_find(b);
if (rnk[x] > rnk[y]) {
par[y] = x;
} else if (rnk[y] > rnk[x]) {
par[x] = y;
} else {
par[y] = x;
rnk[x] += 1;
}
}
ll FAT_kruskal(pair<ll, pair<ll, ll>> pp[]) {
ll cnt = 0;
for (ll i = 0; i < q; i += 1) {
ll c = pp[i].first;
ll a = pp[i].second.first;
ll b = pp[i].second.second;
if (FAT_find(a) != FAT_find(b)) {
cnt += c;
// debug11(cnt);
FAT_union(a, b);
}
}
rn cnt;
}
Im {
/*#ifdef FAT
freopen("input.txt","w",stdin);
#endif // FAT*/
// fasterIO;
cin >> n >> q;
FAT_init();
for (ll i = 0; i < q; i += 1) {
ll u, v, w;
cin >> u >> v >> w;
pp[i] = make_pair(w, make_pair(u, v));
}
sort(pp, pp + q);
ll c1 = FAT_kruskal(pp);
cout << c1 << endl;
// main();
rn0;
}
|
replace
| 51 | 53 | 51 | 53 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define MV 10000
#define INF 1e9
struct edge {
int to, cost;
};
vector<edge> G[MV];
bool used[MV];
int V, E;
int d[MV];
int prim() {
for (int i = 0; i < V; i++) {
d[i] = INF;
used[i] = false;
}
d[0] = 0;
used[0] = true;
for (int i = 0; i < G[0].size(); i++)
d[G[0][i].to] = G[0][i].cost;
int num = 0;
for (int j = 0; j < V; j++) {
int m = -1;
for (int i = 0; i < V; i++) {
if (used[i] == false && (m == -1 || d[m] > d[i]))
m = i;
}
/*if (m == -1)
break;*/
used[m] = true;
num += d[m];
for (int i = 0; i < G[m].size(); i++)
d[G[m][i].to] = min(d[G[m][i].to], G[m][i].cost);
}
return num;
}
int main() {
int first;
cin >> V >> E;
for (int i = 0; i < E; i++) {
int f, t;
edge e;
cin >> f >> e.to >> e.cost;
G[f].push_back(e);
/*
G[f]??????f????????§????????????????´???????????????????
*/
t = e.to;
e.to = f;
G[t].push_back(e);
}
int fl = prim();
cout << fl << endl;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define MV 10000
#define INF 1e9
struct edge {
int to, cost;
};
vector<edge> G[MV];
bool used[MV];
int V, E;
int d[MV];
int prim() {
for (int i = 0; i < V; i++) {
d[i] = INF;
used[i] = false;
}
d[0] = 0;
used[0] = true;
for (int i = 0; i < G[0].size(); i++)
d[G[0][i].to] = G[0][i].cost;
int num = 0;
for (int j = 0; j < V; j++) {
int m = -1;
for (int i = 0; i < V; i++) {
if (used[i] == false && (m == -1 || d[m] > d[i]))
m = i;
}
if (m == -1)
break;
used[m] = true;
num += d[m];
for (int i = 0; i < G[m].size(); i++)
d[G[m][i].to] = min(d[G[m][i].to], G[m][i].cost);
}
return num;
}
int main() {
int first;
cin >> V >> E;
for (int i = 0; i < E; i++) {
int f, t;
edge e;
cin >> f >> e.to >> e.cost;
G[f].push_back(e);
/*
G[f]??????f????????§????????????????´???????????????????
*/
t = e.to;
e.to = f;
G[t].push_back(e);
}
int fl = prim();
cout << fl << endl;
}
|
replace
| 36 | 38 | 36 | 38 |
-11
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
using namespace std;
typedef long long ll;
// ll:9187201950435737471 int:2139062143
#define setinf(x) memset((x), 127, sizeof(x))
#define MAX_V 100
class DisjointSet {
public:
vector<int> rank, p;
DisjointSet() {}
DisjointSet(int size) {
rank.resize(size, 0);
p.resize(size, 0);
for (int i = 0; i < size; i++)
makeSet(i);
}
void makeSet(int x) {
p[x] = x;
rank[x] = 0;
}
bool same(int x, int y) { return findSet(x) == findSet(y); }
void unite(int x, int y) { link(findSet(x), findSet(y)); }
void link(int x, int y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y]) {
rank[y]++;
}
}
}
int findSet(int x) {
if (x != p[x]) {
p[x] = findSet(p[x]);
}
return p[x];
}
};
class edge {
public:
int from, to, cost;
edge(int from = 0, int to = 0, int cost = 0)
: from(from), to(to), cost(cost) {}
bool operator<(const edge &e) const { return cost > e.cost; }
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
int V, E;
vector<edge> graph[MAX_V];
int solve() {
int mincost[V];
bool used[V];
memset(used, false, sizeof(used));
setinf(mincost);
mincost[0] = 0;
int ret = 0;
priority_queue<edge> pque;
for (int i = 0; i < graph[0].size(); i++) {
pque.push(graph[0][i]);
}
used[0] = true;
while (true) {
while (!pque.empty() && used[pque.top().to])
pque.pop();
if (pque.empty())
break;
int p = pque.top().to;
used[p] = true;
ret += pque.top().cost;
pque.pop();
for (int i = 0; i < graph[p].size(); i++) {
edge e = graph[p][i];
if (used[e.to])
continue;
pque.push(e);
}
}
return ret;
}
int main() {
cin >> V >> E;
for (int i = 0; i < E; i++) {
int s, t, w;
cin >> s >> t >> w;
graph[s].push_back(edge(s, t, w));
graph[t].push_back(edge(t, s, w));
}
cout << solve() << endl;
}
|
#include <algorithm>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
using namespace std;
typedef long long ll;
// ll:9187201950435737471 int:2139062143
#define setinf(x) memset((x), 127, sizeof(x))
#define MAX_V 10000
class DisjointSet {
public:
vector<int> rank, p;
DisjointSet() {}
DisjointSet(int size) {
rank.resize(size, 0);
p.resize(size, 0);
for (int i = 0; i < size; i++)
makeSet(i);
}
void makeSet(int x) {
p[x] = x;
rank[x] = 0;
}
bool same(int x, int y) { return findSet(x) == findSet(y); }
void unite(int x, int y) { link(findSet(x), findSet(y)); }
void link(int x, int y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y]) {
rank[y]++;
}
}
}
int findSet(int x) {
if (x != p[x]) {
p[x] = findSet(p[x]);
}
return p[x];
}
};
class edge {
public:
int from, to, cost;
edge(int from = 0, int to = 0, int cost = 0)
: from(from), to(to), cost(cost) {}
bool operator<(const edge &e) const { return cost > e.cost; }
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
int V, E;
vector<edge> graph[MAX_V];
int solve() {
int mincost[V];
bool used[V];
memset(used, false, sizeof(used));
setinf(mincost);
mincost[0] = 0;
int ret = 0;
priority_queue<edge> pque;
for (int i = 0; i < graph[0].size(); i++) {
pque.push(graph[0][i]);
}
used[0] = true;
while (true) {
while (!pque.empty() && used[pque.top().to])
pque.pop();
if (pque.empty())
break;
int p = pque.top().to;
used[p] = true;
ret += pque.top().cost;
pque.pop();
for (int i = 0; i < graph[p].size(); i++) {
edge e = graph[p][i];
if (used[e.to])
continue;
pque.push(e);
}
}
return ret;
}
int main() {
cin >> V >> E;
for (int i = 0; i < E; i++) {
int s, t, w;
cin >> s >> t >> w;
graph[s].push_back(edge(s, t, w));
graph[t].push_back(edge(t, s, w));
}
cout << solve() << endl;
}
|
replace
| 27 | 28 | 27 | 28 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct Edge {
int P1;
int P2;
int Wei;
};
int main(void) {
vector<Edge> EdgeCol;
int V, E;
cin >> V >> E;
if (V == 1)
cout << 1;
vector<int> Select(V, 0);
for (int i = 0; i < E; ++i) {
int s, t, w;
cin >> s >> t >> w;
EdgeCol.push_back(Edge{s, t, w});
}
sort(EdgeCol.begin(), EdgeCol.end(),
[](Edge E1, Edge E2) { return E1.Wei > E2.Wei; });
int WeiSum = 0;
int a = 1;
while (1) {
int aP1 = Select[EdgeCol.back().P1];
int aP2 = Select[EdgeCol.back().P2];
if (aP1 && aP2) {
if (aP1 != aP2) {
replace(Select.begin(), Select.end(), aP2, aP1);
WeiSum += EdgeCol.back().Wei;
}
} else if (!aP1 && !aP2) {
Select[EdgeCol.back().P1] = a;
Select[EdgeCol.back().P2] = a;
a++;
WeiSum += EdgeCol.back().Wei;
} else {
Select[EdgeCol.back().P1] = max(aP1, aP2);
Select[EdgeCol.back().P2] = max(aP1, aP2);
WeiSum += EdgeCol.back().Wei;
}
EdgeCol.pop_back();
if (all_of(Select.cbegin(), Select.cend(),
[=](int s) { return s == *Select.cbegin(); })) {
cout << WeiSum << endl;
return 0;
}
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
struct Edge {
int P1;
int P2;
int Wei;
};
int main(void) {
vector<Edge> EdgeCol;
int V, E;
cin >> V >> E;
if (V == 1) {
cout << 0 << endl;
return 0;
}
vector<int> Select(V, 0);
for (int i = 0; i < E; ++i) {
int s, t, w;
cin >> s >> t >> w;
EdgeCol.push_back(Edge{s, t, w});
}
sort(EdgeCol.begin(), EdgeCol.end(),
[](Edge E1, Edge E2) { return E1.Wei > E2.Wei; });
int WeiSum = 0;
int a = 1;
while (1) {
int aP1 = Select[EdgeCol.back().P1];
int aP2 = Select[EdgeCol.back().P2];
if (aP1 && aP2) {
if (aP1 != aP2) {
replace(Select.begin(), Select.end(), aP2, aP1);
WeiSum += EdgeCol.back().Wei;
}
} else if (!aP1 && !aP2) {
Select[EdgeCol.back().P1] = a;
Select[EdgeCol.back().P2] = a;
a++;
WeiSum += EdgeCol.back().Wei;
} else {
Select[EdgeCol.back().P1] = max(aP1, aP2);
Select[EdgeCol.back().P2] = max(aP1, aP2);
WeiSum += EdgeCol.back().Wei;
}
EdgeCol.pop_back();
if (all_of(Select.cbegin(), Select.cend(),
[=](int s) { return s == *Select.cbegin(); })) {
cout << WeiSum << endl;
return 0;
}
}
return 0;
}
|
replace
| 17 | 19 | 17 | 21 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <string>
#include <vector>
using namespace std;
#define inf 1000000007
#define int long long
#define rep(i, j, n) for (int i = j; i < n; i++)
typedef pair<int, int> P;
double pi = 3.141592653589793;
// ここから下
struct edge {
int u, v, cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
edge es[114514];
int v, e;
int par[100005];
int lank[100005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
lank[i] = 0;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (lank[x] < lank[y]) {
par[x] = y;
} else {
par[y] = x;
if (lank[x] == lank[y])
lank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int kruskal() {
sort(es, es + e, comp);
init(v);
int res = 0;
rep(i, 0, e) {
edge e = es[i];
if (!same(e.u, e.v)) {
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
signed main() {
cin >> v >> e;
rep(i, 0, e) {
int a, b, c;
cin >> a >> b >> c;
es[i] = edge{a, b, c};
es[i + e] = edge{a, b, c};
}
e *= 2;
cout << kruskal() << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string.h>
#include <string>
#include <string>
#include <vector>
using namespace std;
#define inf 1000000007
#define int long long
#define rep(i, j, n) for (int i = j; i < n; i++)
typedef pair<int, int> P;
double pi = 3.141592653589793;
// ここから下
struct edge {
int u, v, cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
edge es[214514];
int v, e;
int par[100005];
int lank[100005];
void init(int n) {
for (int i = 0; i < n; i++) {
par[i] = i;
lank[i] = 0;
}
}
int find(int x) {
if (par[x] == x) {
return x;
} else {
return par[x] = find(par[x]);
}
}
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (lank[x] < lank[y]) {
par[x] = y;
} else {
par[y] = x;
if (lank[x] == lank[y])
lank[x]++;
}
}
bool same(int x, int y) { return find(x) == find(y); }
int kruskal() {
sort(es, es + e, comp);
init(v);
int res = 0;
rep(i, 0, e) {
edge e = es[i];
if (!same(e.u, e.v)) {
unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
signed main() {
cin >> v >> e;
rep(i, 0, e) {
int a, b, c;
cin >> a >> b >> c;
es[i] = edge{a, b, c};
es[i + e] = edge{a, b, c};
}
e *= 2;
cout << kruskal() << endl;
return 0;
}
|
replace
| 27 | 28 | 27 | 28 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
using namespace std;
#include <chrono>
//?????????
#pragma region MACRO
#define putans(x) \
std::cerr << "[ answer ]: "; \
cout << (x) << endl
#define dputans(x) \
std::cerr << "[ answer ]: "; \
cout << setprecision(27) << (double)(x) << endl
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define RREP(i, a, n) for (int i = (int)(n - 1); i >= a; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) begin((a)), end((a))
#define mp make_pair
#define exist(container, n) ((container).find((n)) != (container).end())
#define equals(a, b) (fabs((a) - (b)) < EPS)
#ifdef _DEBUG //???????????????????????????????????????????????????
std::ifstream ifs("data.txt");
#define put ifs >>
#else //?????£????????????????????§?????????????????????
#define put cin >>
#endif
#pragma endregion
//???????????°??????????????´
#pragma region CODING_SUPPORT
#ifdef _DEBUG
#define dbg(var0) \
{ std::cerr << (#var0) << "=" << (var0) << endl; }
#define dbg2(var0, var1) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
dbg(var1); \
}
#define dbg3(var0, var1, var2) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
dbg2(var1, var2); \
}
#define dbgArray(a, n) \
{ \
std::cerr << (#a) << "="; \
rep(i, n) { std::cerr << (a[i]) << ","; } \
cerr << endl; \
}
#else
#define dbg(var0) \
{}
#define dbg2(var0, var1) \
{}
#define dbg3(var0, var1, var2) \
{}
#define dbgArray(a, n) \
{}
#endif
#pragma endregion
// typedef????????????????????????????¶????????????§?????????
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<int, string> pis;
typedef vector<string> vs;
typedef vector<int> vi;
#pragma endregion
//??????????????°(???????????????????????§??????)
#pragma region CONST_VAL
#define PI (2 * acos(0.0))
#define EPS (1e-10)
#define MOD (ll)(1e9 + 7)
#define INF (ll)(2 * 1e9)
#pragma endregion
// static const int MAX = 100;
// static const int WHITE = 0;
// static const int GRAY = 1;
// static const int BLACK = 2;
//
// static const int n = 100;
// int d[n][n];
/*
void floyd() {
rep(k, n) {
rep(i, n) {
if (d[i][k] == INF) continue;
rep(j, n) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void topologicalSort() {
auto bfs = [&](int s )->void{
queue<int> q;
q.push(s);
V[s] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
rep(i, G[u].size()) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !V[v]) {
q.push();
}
}
}
};
rep(i, n) {
indeg[i] = 0;
}
rep(u, n) {
rep(i, G[u].size()) {
int v = G[u][i];
indeg[v]++;
}
rep(i, n) {
if (indeg[i] == !V[i]) bfs(u);
}//????????§???????????????
}
}*/
//??????????£?????????°???
// https://www23.atwiki.jp/akitaicpc/pages/65.html
namespace UnionFindTree {
class UnionFindTree {
public:
UnionFindTree(int n);
~UnionFindTree();
bool Same(int x, int y);
void Unite(int x, int y);
int GetCount();
void mm() {}
private:
int *Par;
int *Rank;
int Count;
int Find(int x);
};
// n???????´???°???????????????UF??¨
UnionFindTree::UnionFindTree(int n) {
Par = new int[n];
Rank = new int[n];
Count = n;
for (int i = 0; i < n; i++) {
Par[i] = i;
}
}
UnionFindTree::~UnionFindTree() {
delete (Par);
delete (Rank);
}
int UnionFindTree::Find(int x) {
if (Par[x] == x)
return x;
else {
Par[x] = Find(Par[x]);
return Par[x];
}
}
// ??¨??????????±???????
// x??¨y????±??????????????????????
void UnionFindTree::Unite(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y)
return;
if (Rank[x] < Rank[y]) {
Par[x] = y;
} else {
Par[y] = x;
if (Rank[x] == Rank[y])
Rank[x]++;
}
}
// x??¨y???????????????????±????????????????
bool UnionFindTree::Same(int x, int y) { return Find(x) == Find(y); }
//????´???°????????°?????????
int UnionFindTree::GetCount() { return Count; }
} // namespace UnionFindTree
struct edge {
int u, v, cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
// Kruskal
int V, E;
static const int MAX_E = 100;
edge es[MAX_E];
int Kruskal() {
sort(es, es + E, comp);
UnionFindTree::UnionFindTree ufT(V);
int res = 0;
rep(i, E) {
edge e = es[i];
if (!ufT.Same(e.u, e.v)) {
ufT.Unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
void calc() {
int v, e;
put v >> e;
V = v;
E = e;
rep(i, e) {
int from, to, cost;
put from >> to >> cost;
es[i] = {from, to, cost};
}
cout << Kruskal() << endl;
}
int main() {
calc();
END:
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
#include <chrono>
//?????????
#pragma region MACRO
#define putans(x) \
std::cerr << "[ answer ]: "; \
cout << (x) << endl
#define dputans(x) \
std::cerr << "[ answer ]: "; \
cout << setprecision(27) << (double)(x) << endl
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define RREP(i, a, n) for (int i = (int)(n - 1); i >= a; i--)
#define rep(i, n) REP(i, 0, n)
#define rrep(i, n) RREP(i, 0, n)
#define all(a) begin((a)), end((a))
#define mp make_pair
#define exist(container, n) ((container).find((n)) != (container).end())
#define equals(a, b) (fabs((a) - (b)) < EPS)
#ifdef _DEBUG //???????????????????????????????????????????????????
std::ifstream ifs("data.txt");
#define put ifs >>
#else //?????£????????????????????§?????????????????????
#define put cin >>
#endif
#pragma endregion
//???????????°??????????????´
#pragma region CODING_SUPPORT
#ifdef _DEBUG
#define dbg(var0) \
{ std::cerr << (#var0) << "=" << (var0) << endl; }
#define dbg2(var0, var1) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
dbg(var1); \
}
#define dbg3(var0, var1, var2) \
{ \
std::cerr << (#var0) << "=" << (var0) << ", "; \
dbg2(var1, var2); \
}
#define dbgArray(a, n) \
{ \
std::cerr << (#a) << "="; \
rep(i, n) { std::cerr << (a[i]) << ","; } \
cerr << endl; \
}
#else
#define dbg(var0) \
{}
#define dbg2(var0, var1) \
{}
#define dbg3(var0, var1, var2) \
{}
#define dbgArray(a, n) \
{}
#endif
#pragma endregion
// typedef????????????????????????????¶????????????§?????????
#pragma region TYPE_DEF
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<string, string> pss;
typedef pair<int, string> pis;
typedef vector<string> vs;
typedef vector<int> vi;
#pragma endregion
//??????????????°(???????????????????????§??????)
#pragma region CONST_VAL
#define PI (2 * acos(0.0))
#define EPS (1e-10)
#define MOD (ll)(1e9 + 7)
#define INF (ll)(2 * 1e9)
#pragma endregion
// static const int MAX = 100;
// static const int WHITE = 0;
// static const int GRAY = 1;
// static const int BLACK = 2;
//
// static const int n = 100;
// int d[n][n];
/*
void floyd() {
rep(k, n) {
rep(i, n) {
if (d[i][k] == INF) continue;
rep(j, n) {
d[i][j] = min(d[i][j], d[i][k] + d[k][j]);
}
}
}
}
void topologicalSort() {
auto bfs = [&](int s )->void{
queue<int> q;
q.push(s);
V[s] = true;
while (!q.empty()) {
int u = q.front(); q.pop();
rep(i, G[u].size()) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !V[v]) {
q.push();
}
}
}
};
rep(i, n) {
indeg[i] = 0;
}
rep(u, n) {
rep(i, G[u].size()) {
int v = G[u][i];
indeg[v]++;
}
rep(i, n) {
if (indeg[i] == !V[i]) bfs(u);
}//????????§???????????????
}
}*/
//??????????£?????????°???
// https://www23.atwiki.jp/akitaicpc/pages/65.html
namespace UnionFindTree {
class UnionFindTree {
public:
UnionFindTree(int n);
~UnionFindTree();
bool Same(int x, int y);
void Unite(int x, int y);
int GetCount();
void mm() {}
private:
int *Par;
int *Rank;
int Count;
int Find(int x);
};
// n???????´???°???????????????UF??¨
UnionFindTree::UnionFindTree(int n) {
Par = new int[n];
Rank = new int[n];
Count = n;
for (int i = 0; i < n; i++) {
Par[i] = i;
}
}
UnionFindTree::~UnionFindTree() {
delete (Par);
delete (Rank);
}
int UnionFindTree::Find(int x) {
if (Par[x] == x)
return x;
else {
Par[x] = Find(Par[x]);
return Par[x];
}
}
// ??¨??????????±???????
// x??¨y????±??????????????????????
void UnionFindTree::Unite(int x, int y) {
x = Find(x);
y = Find(y);
if (x == y)
return;
if (Rank[x] < Rank[y]) {
Par[x] = y;
} else {
Par[y] = x;
if (Rank[x] == Rank[y])
Rank[x]++;
}
}
// x??¨y???????????????????±????????????????
bool UnionFindTree::Same(int x, int y) { return Find(x) == Find(y); }
//????´???°????????°?????????
int UnionFindTree::GetCount() { return Count; }
} // namespace UnionFindTree
struct edge {
int u, v, cost;
};
bool comp(const edge &e1, const edge &e2) { return e1.cost < e2.cost; }
// Kruskal
int V, E;
static const int MAX_E = 100000;
edge es[MAX_E];
int Kruskal() {
sort(es, es + E, comp);
UnionFindTree::UnionFindTree ufT(V);
int res = 0;
rep(i, E) {
edge e = es[i];
if (!ufT.Same(e.u, e.v)) {
ufT.Unite(e.u, e.v);
res += e.cost;
}
}
return res;
}
void calc() {
int v, e;
put v >> e;
V = v;
E = e;
rep(i, e) {
int from, to, cost;
put from >> to >> cost;
es[i] = {from, to, cost};
}
cout << Kruskal() << endl;
}
int main() {
calc();
END:
return 0;
}
|
replace
| 204 | 205 | 204 | 205 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <assert.h>
#include <stdio.h>
namespace beet {
template <typename T> void swap(T &a, T &b) {
T x = a;
a = b;
b = x;
}
template <typename T> struct Vector {
int sz, cap;
T *data;
Vector() : sz(0), cap(1) { data = new T[cap]; }
Vector(int sz) : sz(sz), cap(sz << 1) { data = new T[cap]; }
Vector(int sz, T t) : sz(sz), cap(sz << 1) {
data = new T[cap];
for (int i = 0; i < sz; i++)
data[i] = t;
}
~Vector() { delete[] data; }
void resolve() {
T *tmp = new T[cap];
for (int i = 0; i < sz; i++)
tmp[i] = data[i];
delete[] data;
data = tmp;
}
void resize(int nsz) {
cap = nsz << 1;
if (sz > cap)
sz = cap;
resolve();
}
void assign(int nsz, T t) {
resize(nsz);
sz = nsz;
for (int i = 0; i < sz; i++)
data[i] = t;
}
void push_back(T x) {
if (sz >= cap) {
cap <<= 1;
assert(sz < cap);
resolve();
}
data[sz++] = x;
}
void pop_back() { sz--; }
int size() const { return sz; }
const T operator[](int x) const { return data[x]; }
T &operator[](int x) {
assert(0 <= x && x < sz);
return data[x];
}
};
template <typename T> void sort(Vector<T> &vs) {
int n = vs.size();
Vector<T> tmp(n);
auto dfs = [&](int l, int r, auto &func) -> void {
// printf("%d %d\n",l,r);
if (l + 1 == r)
return;
int m = (l + r) >> 1;
func(l, m, func);
func(m, r, func);
for (int k = l; k < r; k++)
tmp[k] = vs[k];
int i = l, j = m, k = l;
while (i < m && j < r) {
if (tmp[i] < tmp[j]) {
vs[k++] = tmp[i++];
} else {
vs[k++] = tmp[j++];
}
}
while (i < m)
vs[k++] = tmp[i++];
while (j < r)
vs[k++] = tmp[j++];
};
dfs(0, n, dfs);
}
template <typename T> struct Kruskal {
struct edge {
int from, to;
T cost;
int used;
edge() {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
int n;
Vector<int> r, p;
Vector<edge> es;
Kruskal() {}
Kruskal(int n) : n(n), r(n, 1), p(n) {
for (int i = 0; i < n; i++)
p[i] = i;
}
int find(int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(int u, int v, T c) { es.push_back(edge(u, v, c)); }
T build() {
sort(es);
T res = 0;
for (int i = 0; i < (int)es.size(); i++) {
auto &e = es[i];
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
} // namespace beet
// INSERT ABOVE HERE
using namespace beet;
int main() {
int n, m;
scanf("%d %d", &n, &m);
Kruskal<int> mst(n);
for (int i = 0; i < m; i++) {
int s, t, w;
scanf("%d %d %d", &s, &t, &w);
mst.add_edge(s, t, w);
}
printf("%d\n", mst.build());
return 0;
}
|
#include <assert.h>
#include <stdio.h>
namespace beet {
template <typename T> void swap(T &a, T &b) {
T x = a;
a = b;
b = x;
}
template <typename T> struct Vector {
int sz, cap;
T *data;
Vector() : sz(0), cap(1) { data = new T[cap]; }
Vector(int sz) : sz(sz), cap(sz << 1) { data = new T[cap]; }
Vector(int sz, T t) : sz(sz), cap(sz << 1) {
data = new T[cap];
for (int i = 0; i < sz; i++)
data[i] = t;
}
~Vector() { delete[] data; }
void resolve() {
T *tmp = new T[cap];
for (int i = 0; i < sz; i++)
tmp[i] = data[i];
delete[] data;
data = tmp;
}
void resize(int nsz) {
cap = nsz << 1;
if (sz > cap)
sz = cap;
resolve();
}
void assign(int nsz, T t) {
resize(nsz);
sz = nsz;
for (int i = 0; i < sz; i++)
data[i] = t;
}
void push_back(T x) {
if (sz >= cap) {
cap <<= 1;
assert(sz < cap);
resolve();
}
data[sz++] = x;
}
void pop_back() { sz--; }
int size() const { return sz; }
const T operator[](int x) const { return data[x]; }
T &operator[](int x) {
assert(0 <= x && x < sz);
return data[x];
}
};
template <typename T> void sort(Vector<T> &vs) {
if (vs.size() == 0)
return;
int n = vs.size();
Vector<T> tmp(n);
auto dfs = [&](int l, int r, auto &func) -> void {
// printf("%d %d\n",l,r);
if (l + 1 == r)
return;
int m = (l + r) >> 1;
func(l, m, func);
func(m, r, func);
for (int k = l; k < r; k++)
tmp[k] = vs[k];
int i = l, j = m, k = l;
while (i < m && j < r) {
if (tmp[i] < tmp[j]) {
vs[k++] = tmp[i++];
} else {
vs[k++] = tmp[j++];
}
}
while (i < m)
vs[k++] = tmp[i++];
while (j < r)
vs[k++] = tmp[j++];
};
dfs(0, n, dfs);
}
template <typename T> struct Kruskal {
struct edge {
int from, to;
T cost;
int used;
edge() {}
edge(int from, int to, T cost) : from(from), to(to), cost(cost), used(0) {}
bool operator<(const edge &e) const { return cost < e.cost; }
};
int n;
Vector<int> r, p;
Vector<edge> es;
Kruskal() {}
Kruskal(int n) : n(n), r(n, 1), p(n) {
for (int i = 0; i < n; i++)
p[i] = i;
}
int find(int x) { return (x == p[x] ? x : p[x] = find(p[x])); }
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (r[x] < r[y])
swap(x, y);
r[x] += r[y];
p[y] = x;
}
void add_edge(int u, int v, T c) { es.push_back(edge(u, v, c)); }
T build() {
sort(es);
T res = 0;
for (int i = 0; i < (int)es.size(); i++) {
auto &e = es[i];
if (!same(e.from, e.to)) {
res += e.cost;
unite(e.from, e.to);
e.used = 1;
}
}
return res;
}
};
} // namespace beet
// INSERT ABOVE HERE
using namespace beet;
int main() {
int n, m;
scanf("%d %d", &n, &m);
Kruskal<int> mst(n);
for (int i = 0; i < m; i++) {
int s, t, w;
scanf("%d %d %d", &s, &t, &w);
mst.add_edge(s, t, w);
}
printf("%d\n", mst.build());
return 0;
}
|
insert
| 59 | 59 | 59 | 62 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
const int INF = 1145141919, MOD = 1e9 + 7;
const long long LINF = 8931145141919364364, LMOD = 998244353;
// const int dx[]={1,0,-1,0,1,1,-1,-1},dy[]={0,-1,0,1,1,-1,-1,1};
const int VMAX = 10010;
int V, E;
vector<vector<pair<int, int>>> edge;
bool used[VMAX];
long long MST(int start) {
rep(i, VMAX) used[i] = 0;
// {cost,{from,to}}
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
for (auto e : edge[start]) {
pq.push({e.second, {start, e.first}});
}
long long ret = 0;
int cnt = 1;
while (pq.size() || cnt < V) {
auto e = pq.top();
pq.pop();
int cost = e.first, from = e.second.first, to = e.second.second;
used[from] = 1;
if (!used[to]) {
ret += cost;
used[to] = 1;
cnt++;
for (auto e : edge[to]) {
pq.push({e.second, {to, e.first}});
}
}
}
return (cnt == V ? ret : -1);
}
int main() {
cin >> V >> E;
edge.resize(V);
int start;
rep(i, E) {
int from, to, cost;
cin >> from >> to >> cost;
start = from;
edge[from].push_back({to, cost});
edge[to].push_back({from, cost});
}
cout << MST(start) << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(x) (x).begin(), (x).end()
using namespace std;
const int INF = 1145141919, MOD = 1e9 + 7;
const long long LINF = 8931145141919364364, LMOD = 998244353;
// const int dx[]={1,0,-1,0,1,1,-1,-1},dy[]={0,-1,0,1,1,-1,-1,1};
const int VMAX = 10010;
int V, E;
vector<vector<pair<int, int>>> edge;
bool used[VMAX];
long long MST(int start) {
if (V == 1)
return 0;
rep(i, VMAX) used[i] = 0;
// {cost,{from,to}}
priority_queue<pair<int, pair<int, int>>, vector<pair<int, pair<int, int>>>,
greater<pair<int, pair<int, int>>>>
pq;
for (auto e : edge[start]) {
pq.push({e.second, {start, e.first}});
}
long long ret = 0;
int cnt = 1;
while (pq.size() || cnt < V) {
auto e = pq.top();
pq.pop();
int cost = e.first, from = e.second.first, to = e.second.second;
used[from] = 1;
if (!used[to]) {
ret += cost;
used[to] = 1;
cnt++;
for (auto e : edge[to]) {
pq.push({e.second, {to, e.first}});
}
}
}
return (cnt == V ? ret : -1);
}
int main() {
cin >> V >> E;
edge.resize(V);
int start;
rep(i, E) {
int from, to, cost;
cin >> from >> to >> cost;
start = from;
edge[from].push_back({to, cost});
edge[to].push_back({from, cost});
}
cout << MST(start) << endl;
return 0;
}
|
insert
| 13 | 13 | 13 | 15 |
0
| |
p02364
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
#define shosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const double pi = acos(-1);
class Graph {
private:
vvi Gpro, Gd;
vvp Glist;
int GV, GE;
public:
Graph(int x, int y, bool z) {
GV = x;
GE = y;
Gd = vvi(x, vi(x, inf));
if (z)
Gpro = vvi(x, vi(x, inf));
else
Glist = vvp(x);
}
void Gpro_add(int x, int y, int z) {
Gpro[x][y] = z;
Gpro[y][x] = z;
}
void Glist_add(int x, int y, int z) {
Glist[x].push_back(P(y, z));
Glist[y].push_back(P(x, z));
}
void Gd_add(int x, int y, int z) { Gd[x][y] = z; }
int open(int x, int y) { return Gd[x][y]; }
void DIJplus(int x) {
priority_queue<P> que;
Gd[x][x] = 0;
que.push(P(0, x));
while (!que.empty()) {
P p = que.top();
p.first *= -1;
que.pop();
int v = p.second;
if (Gd[x][v] < p.first)
continue;
for (int i = 0; i < Glist[v].size(); i++) {
P e = Glist[v][i];
if (Gd[x][e.first] > Gd[x][v] + e.second) {
Gd[x][e.first] = Gd[x][v] + e.second;
que.push(P(-1 * Gd[x][e.first], e.first));
}
}
}
}
void BELLMAN(int x) {
Gd[x][x] = 0;
while (1) {
bool update = 1;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < Glist[i].size(); j++) {
P e = P(Glist[i][j].first, Glist[i][j].second);
if (Gd[x][i] != inf && Gd[x][e.first] > Gd[x][i] + e.second) {
Gd[x][e.first] = Gd[x][i] + e.second;
update = 0;
}
}
}
if (update)
break;
}
}
bool FNL(int x) {
Gd[x][x] = 0;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < Glist[j].size(); k++) {
P e = P(Glist[j][k].first, Glist[j][k].second);
if (Gd[x][j] != inf && Gd[x][e.first] > Gd[x][j] + e.second) {
Gd[x][e.first] = Gd[x][j] + e.second;
if (i == GV - 1)
return 1;
}
}
}
}
Gd = vvi(GV, vi(GV, inf));
return 0;
}
void WARSHALL() {
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < GV; k++)
Gd[i][j] = min(Gd[i][j], Gd[i][k] + Gd[k][j]);
}
}
}
int PRIM() {
int Gans = 0;
vi mincost(GV, inf);
vector<bool> used(GV, 1);
mincost[0] = 0;
while (1) {
int v = -1;
for (int i = 0; i < GV; i++) {
if (used[i] && (v == -1 || mincost[i] < mincost[v]))
v = i;
}
if (v == -1)
break;
used[v] = 0;
Gans += mincost[v];
for (int i = 0; i < Glist[v].size(); i++) {
mincost[Glist[v][i].first] =
min(mincost[Glist[v][i].first], Glist[v][i].second);
}
}
return Gans;
}
};
int V, E;
int main() {
cin >> V >> E;
Graph gra(V, E, 0);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
gra.Glist_add(s, t, d);
}
cout << gra.PRIM() << endl;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <vector>
#define shosu(x) fixed << setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int, P> pip;
typedef vector<pip> vip;
const int inf = 1 << 30;
const double pi = acos(-1);
class Graph {
private:
vvi Gpro, Gd;
vvp Glist;
int GV, GE;
public:
Graph(int x, int y, bool z) {
GV = x;
GE = y;
// Gd=vvi(x,vi(x,inf));
if (z)
Gpro = vvi(x, vi(x, inf));
else
Glist = vvp(x);
}
void Gpro_add(int x, int y, int z) {
Gpro[x][y] = z;
Gpro[y][x] = z;
}
void Glist_add(int x, int y, int z) {
Glist[x].push_back(P(y, z));
Glist[y].push_back(P(x, z));
}
void Gd_add(int x, int y, int z) { Gd[x][y] = z; }
int open(int x, int y) { return Gd[x][y]; }
void DIJplus(int x) {
priority_queue<P> que;
Gd[x][x] = 0;
que.push(P(0, x));
while (!que.empty()) {
P p = que.top();
p.first *= -1;
que.pop();
int v = p.second;
if (Gd[x][v] < p.first)
continue;
for (int i = 0; i < Glist[v].size(); i++) {
P e = Glist[v][i];
if (Gd[x][e.first] > Gd[x][v] + e.second) {
Gd[x][e.first] = Gd[x][v] + e.second;
que.push(P(-1 * Gd[x][e.first], e.first));
}
}
}
}
void BELLMAN(int x) {
Gd[x][x] = 0;
while (1) {
bool update = 1;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < Glist[i].size(); j++) {
P e = P(Glist[i][j].first, Glist[i][j].second);
if (Gd[x][i] != inf && Gd[x][e.first] > Gd[x][i] + e.second) {
Gd[x][e.first] = Gd[x][i] + e.second;
update = 0;
}
}
}
if (update)
break;
}
}
bool FNL(int x) {
Gd[x][x] = 0;
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < Glist[j].size(); k++) {
P e = P(Glist[j][k].first, Glist[j][k].second);
if (Gd[x][j] != inf && Gd[x][e.first] > Gd[x][j] + e.second) {
Gd[x][e.first] = Gd[x][j] + e.second;
if (i == GV - 1)
return 1;
}
}
}
}
Gd = vvi(GV, vi(GV, inf));
return 0;
}
void WARSHALL() {
for (int i = 0; i < GV; i++) {
for (int j = 0; j < GV; j++) {
for (int k = 0; k < GV; k++)
Gd[i][j] = min(Gd[i][j], Gd[i][k] + Gd[k][j]);
}
}
}
int PRIM() {
int Gans = 0;
vi mincost(GV, inf);
vector<bool> used(GV, 1);
mincost[0] = 0;
while (1) {
int v = -1;
for (int i = 0; i < GV; i++) {
if (used[i] && (v == -1 || mincost[i] < mincost[v]))
v = i;
}
if (v == -1)
break;
used[v] = 0;
Gans += mincost[v];
for (int i = 0; i < Glist[v].size(); i++) {
mincost[Glist[v][i].first] =
min(mincost[Glist[v][i].first], Glist[v][i].second);
}
}
return Gans;
}
};
int V, E;
int main() {
cin >> V >> E;
Graph gra(V, E, 0);
for (int i = 0; i < E; i++) {
int s, t, d;
cin >> s >> t >> d;
gra.Glist_add(s, t, d);
}
cout << gra.PRIM() << endl;
}
|
replace
| 29 | 30 | 29 | 30 |
MLE
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <queue>
#include <stdio.h>
using namespace std;
const int V_MAX = 100;
const int INF = 100000000;
struct Edge {
bool operator<(const Edge &e) const { return w > e.w; }
int to;
int w;
};
int main() {
int v;
int e;
priority_queue<Edge> edge[V_MAX];
vector<int> tree;
bool check[V_MAX] = {false};
int ans = 0;
scanf("%d%d", &v, &e);
for (int i = 0; i < e; i++) {
int s, t, w;
Edge e1, e2;
scanf("%d%d%d", &s, &t, &w);
e1.to = t;
e1.w = w;
e2.to = s;
e2.w = w;
edge[s].push(e1);
edge[t].push(e2);
}
tree.push_back(0);
check[0] = true;
for (int i = 1; i < v; i++) {
int minW = INF;
int minV = 0;
int k = 0;
for (int j = 0; j < tree.size(); j++) {
int t = tree[j];
while (!edge[t].empty() && check[edge[t].top().to]) {
edge[t].pop();
}
if (edge[t].empty())
continue;
if (minW > edge[t].top().w) {
minV = edge[t].top().to;
minW = edge[t].top().w;
k = t;
}
}
edge[k].pop();
check[minV] = true;
tree.push_back(minV);
ans += minW;
}
printf("%d\n", ans);
return 0;
}
|
#include <algorithm>
#include <queue>
#include <stdio.h>
using namespace std;
const int V_MAX = 10000;
const int INF = 100000000;
struct Edge {
bool operator<(const Edge &e) const { return w > e.w; }
int to;
int w;
};
int main() {
int v;
int e;
priority_queue<Edge> edge[V_MAX];
vector<int> tree;
bool check[V_MAX] = {false};
int ans = 0;
scanf("%d%d", &v, &e);
for (int i = 0; i < e; i++) {
int s, t, w;
Edge e1, e2;
scanf("%d%d%d", &s, &t, &w);
e1.to = t;
e1.w = w;
e2.to = s;
e2.w = w;
edge[s].push(e1);
edge[t].push(e2);
}
tree.push_back(0);
check[0] = true;
for (int i = 1; i < v; i++) {
int minW = INF;
int minV = 0;
int k = 0;
for (int j = 0; j < tree.size(); j++) {
int t = tree[j];
while (!edge[t].empty() && check[edge[t].top().to]) {
edge[t].pop();
}
if (edge[t].empty())
continue;
if (minW > edge[t].top().w) {
minV = edge[t].top().to;
minW = edge[t].top().w;
k = t;
}
}
edge[k].pop();
check[minV] = true;
tree.push_back(minV);
ans += minW;
}
printf("%d\n", ans);
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02364
|
C++
|
Runtime Error
|
// ????????????????????°??????: ??£??\?????????
// Library
#include <algorithm>
#include <cassert>
#include <functional>
#include <queue>
#include <vector>
// Type
typedef int Vertex;
typedef int Weight;
struct Edge {
Vertex from, to;
Weight weight;
};
bool operator<(const Edge &lhs, const Edge &rhs) {
if (lhs.weight != rhs.weight)
return lhs.weight < rhs.weight;
if (lhs.from != rhs.from)
return lhs.from < rhs.from;
return lhs.to < rhs.to;
}
bool operator>(const Edge &lhs, const Edge &rhs) {
if (lhs.weight != rhs.weight)
return lhs.weight > rhs.weight;
if (lhs.from != rhs.from)
return lhs.from > rhs.from;
return lhs.to > rhs.to;
}
// Class
class Graph {
public:
explicit Graph(int size);
void add(const Vertex &from, const Vertex &to, const Weight &weight = 1);
const std::vector<Edge> minimum_spanning_tree() const;
private:
int size_;
std::vector<std::vector<Edge>> edge_;
};
// Implement
Graph::Graph(int size) : size_(size), edge_(size) {}
void Graph::add(const Vertex &from, const Vertex &to, const Weight &weight) {
edge_.at(from).push_back({from, to, weight});
edge_.at(to).push_back({to, from, weight});
}
// Minimum Spanning Tree: Prim's algorithm, O(|E| + |V| log |V|)
const std::vector<Edge> Graph::minimum_spanning_tree() const {
assert(
std::all_of(std::begin(edge_), std::end(edge_),
[](const std::vector<Edge> &list) { return !list.empty(); }));
std::vector<Edge> result;
std::priority_queue<Edge, std::vector<Edge>, std::greater<Edge>> q(
std::begin(edge_.front()), std::end(edge_.front()));
std::vector<bool> visited(size_, false);
visited.front() = true;
while (!q.empty()) {
auto current = q.top();
q.pop();
if (visited.at(current.to))
continue;
visited.at(current.to) = true;
result.push_back(current);
for (const auto &e : edge_.at(current.to))
if (!visited[e.to])
q.push(e);
}
assert(result.size() == size_ - 1);
return result;
}
#include <bits/stdc++.h>
using namespace std;
int main() {
int V, E;
cin >> V >> E;
Graph g(V);
for (int i = 0; i < E; ++i) {
int s, t, w;
cin >> s >> t >> w;
g.add(s, t, w);
}
auto mst = g.minimum_spanning_tree();
cout << accumulate(begin(mst), end(mst), 0, [](int sum, Edge e) {
return sum + e.weight;
}) << endl;
}
|
// ????????????????????°??????: ??£??\?????????
// Library
#include <algorithm>
#include <cassert>
#include <functional>
#include <queue>
#include <vector>
// Type
typedef int Vertex;
typedef int Weight;
struct Edge {
Vertex from, to;
Weight weight;
};
bool operator<(const Edge &lhs, const Edge &rhs) {
if (lhs.weight != rhs.weight)
return lhs.weight < rhs.weight;
if (lhs.from != rhs.from)
return lhs.from < rhs.from;
return lhs.to < rhs.to;
}
bool operator>(const Edge &lhs, const Edge &rhs) {
if (lhs.weight != rhs.weight)
return lhs.weight > rhs.weight;
if (lhs.from != rhs.from)
return lhs.from > rhs.from;
return lhs.to > rhs.to;
}
// Class
class Graph {
public:
explicit Graph(int size);
void add(const Vertex &from, const Vertex &to, const Weight &weight = 1);
const std::vector<Edge> minimum_spanning_tree() const;
private:
int size_;
std::vector<std::vector<Edge>> edge_;
};
// Implement
Graph::Graph(int size) : size_(size), edge_(size) {}
void Graph::add(const Vertex &from, const Vertex &to, const Weight &weight) {
edge_.at(from).push_back({from, to, weight});
edge_.at(to).push_back({to, from, weight});
}
// Minimum Spanning Tree: Prim's algorithm, O(|E| + |V| log |V|)
const std::vector<Edge> Graph::minimum_spanning_tree() const {
if (size_ == 1)
return {};
assert(
std::all_of(std::begin(edge_), std::end(edge_),
[](const std::vector<Edge> &list) { return !list.empty(); }));
std::vector<Edge> result;
std::priority_queue<Edge, std::vector<Edge>, std::greater<Edge>> q(
std::begin(edge_.front()), std::end(edge_.front()));
std::vector<bool> visited(size_, false);
visited.front() = true;
while (!q.empty()) {
auto current = q.top();
q.pop();
if (visited.at(current.to))
continue;
visited.at(current.to) = true;
result.push_back(current);
for (const auto &e : edge_.at(current.to))
if (!visited[e.to])
q.push(e);
}
assert(result.size() == size_ - 1);
return result;
}
#include <bits/stdc++.h>
using namespace std;
int main() {
int V, E;
cin >> V >> E;
Graph g(V);
for (int i = 0; i < E; ++i) {
int s, t, w;
cin >> s >> t >> w;
g.add(s, t, w);
}
auto mst = g.minimum_spanning_tree();
cout << accumulate(begin(mst), end(mst), 0, [](int sum, Edge e) {
return sum + e.weight;
}) << endl;
}
|
insert
| 48 | 48 | 48 | 50 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define TemplateVersion "3.2.0"
// Useful Marcos
//====================START=====================
// Compile use C++11 and above
#ifdef LOCAL
#define debug(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
#define MSG cout << "Finished" << endl
#else
#define debug(args...)
#define MSG
#endif
#if __cplusplus >= 201703L
template <typename... Args> void readln(Args &...args) { ((cin >> args), ...); }
template <typename... Args> void writeln(Args... args) {
((cout << args << " "), ...);
cout << endl;
}
#elif __cplusplus >= 201103L
void readln() {}
template <typename T, typename... Args> void readln(T &a, Args &...args) {
cin >> a;
readln(args...);
}
void writeln() { cout << endl; }
template <typename T, typename... Args> void writeln(T a, Args... args) {
cout << a << " ";
writeln(args...);
}
#endif
#if __cplusplus >= 201103L
#define FOR(_i, _begin, _end) for (auto _i = _begin; _i < _end; _i++)
#define FORR(_i, _begin, _end) for (auto _i = _begin; _i > _end; _i--)
#else
#define FOR(_i, _begin, _end) for (int _i = (int)_begin; _i < (int)_end; _i++)
#define FORR(_i, _begin, _end) for (int _i = (int)_begin; _i > (int)_end; _i--)
#define nullptr NULL
#endif
#if __cplusplus >= 201103L
#define VIS(_kind, _name, _size) \
vector<_kind> _name(_size); \
for (auto &i : _name) \
cin >> i;
#else
#define VIS(_kind, _name, _size) \
vector<_kind> _name; \
_name.resize(_size); \
for (int i = 0; i < _size; i++) \
cin >> _name[i];
#endif
// alias
#define mp make_pair
#define pb push_back
#define eb emplace_back
// Swap max/min
template <typename T> bool smax(T &a, const T &b) {
if (a > b)
return false;
a = b;
return true;
}
template <typename T> bool smin(T &a, const T &b) {
if (a < b)
return false;
a = b;
return true;
}
// ceil divide
template <typename T> T cd(T a, T b) { return (a + b - 1) / b; }
// min exchange
template <typename T> bool se(T &a, T &b) {
if (a < b)
return false;
swap(a, b);
return true;
}
// A better MAX choice
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef set<int> si;
typedef vector<string> cb;
//====================END=====================
// Constants here
const int MAXN = 10010;
const int MAXM = 100010;
int F[MAXN];
struct Edge {
int u, v, w;
} edge[MAXN];
int tol;
void addedge(int u, int v, int w) {
edge[tol].u = u;
edge[tol].v = v;
edge[tol++].w = w;
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
int find(int x) {
if (F[x] == -1)
return x;
else
return F[x] = find(F[x]);
}
int Kruskal(int n) {
memset(F, -1, sizeof(F));
sort(edge, edge + tol, cmp);
int cnt = 0;
int ans = 0;
for (int i = 0; i < tol; i++) {
int u = edge[i].u;
int v = edge[i].v;
int w = edge[i].w;
int t1 = find(u);
int t2 = find(v);
if (t1 != t2) {
ans += w;
F[t1] = t2;
cnt++;
}
if (cnt == n - 1)
break;
}
if (cnt < n - 1)
return -1;
else
return ans;
}
// Pre-Build Function
inline void build() {}
// Actual Solver
inline void solve() {
int n, m;
int u, v, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
addedge(u, v, w);
}
cout << Kruskal(n) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
#ifdef LOCAL
clock_t _begin = clock();
#endif
build();
solve();
#ifdef LOCAL
cerr << "Time elapsed: " << (double)(clock() - _begin) * 1000 / CLOCKS_PER_SEC
<< "ms." << endl;
#endif
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define TemplateVersion "3.2.0"
// Useful Marcos
//====================START=====================
// Compile use C++11 and above
#ifdef LOCAL
#define debug(args...) \
{ \
string _s = #args; \
replace(_s.begin(), _s.end(), ',', ' '); \
stringstream _ss(_s); \
istream_iterator<string> _it(_ss); \
err(_it, args); \
}
void err(istream_iterator<string> it) {}
template <typename T, typename... Args>
void err(istream_iterator<string> it, T a, Args... args) {
cerr << *it << " = " << a << endl;
err(++it, args...);
}
#define MSG cout << "Finished" << endl
#else
#define debug(args...)
#define MSG
#endif
#if __cplusplus >= 201703L
template <typename... Args> void readln(Args &...args) { ((cin >> args), ...); }
template <typename... Args> void writeln(Args... args) {
((cout << args << " "), ...);
cout << endl;
}
#elif __cplusplus >= 201103L
void readln() {}
template <typename T, typename... Args> void readln(T &a, Args &...args) {
cin >> a;
readln(args...);
}
void writeln() { cout << endl; }
template <typename T, typename... Args> void writeln(T a, Args... args) {
cout << a << " ";
writeln(args...);
}
#endif
#if __cplusplus >= 201103L
#define FOR(_i, _begin, _end) for (auto _i = _begin; _i < _end; _i++)
#define FORR(_i, _begin, _end) for (auto _i = _begin; _i > _end; _i--)
#else
#define FOR(_i, _begin, _end) for (int _i = (int)_begin; _i < (int)_end; _i++)
#define FORR(_i, _begin, _end) for (int _i = (int)_begin; _i > (int)_end; _i--)
#define nullptr NULL
#endif
#if __cplusplus >= 201103L
#define VIS(_kind, _name, _size) \
vector<_kind> _name(_size); \
for (auto &i : _name) \
cin >> i;
#else
#define VIS(_kind, _name, _size) \
vector<_kind> _name; \
_name.resize(_size); \
for (int i = 0; i < _size; i++) \
cin >> _name[i];
#endif
// alias
#define mp make_pair
#define pb push_back
#define eb emplace_back
// Swap max/min
template <typename T> bool smax(T &a, const T &b) {
if (a > b)
return false;
a = b;
return true;
}
template <typename T> bool smin(T &a, const T &b) {
if (a < b)
return false;
a = b;
return true;
}
// ceil divide
template <typename T> T cd(T a, T b) { return (a + b - 1) / b; }
// min exchange
template <typename T> bool se(T &a, T &b) {
if (a < b)
return false;
swap(a, b);
return true;
}
// A better MAX choice
const int INF = 0x3f3f3f3f;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef set<int> si;
typedef vector<string> cb;
//====================END=====================
// Constants here
const int MAXN = 10010;
const int MAXM = 100010;
int F[MAXN];
struct Edge {
int u, v, w;
} edge[MAXM];
int tol;
void addedge(int u, int v, int w) {
edge[tol].u = u;
edge[tol].v = v;
edge[tol++].w = w;
}
bool cmp(Edge a, Edge b) { return a.w < b.w; }
int find(int x) {
if (F[x] == -1)
return x;
else
return F[x] = find(F[x]);
}
int Kruskal(int n) {
memset(F, -1, sizeof(F));
sort(edge, edge + tol, cmp);
int cnt = 0;
int ans = 0;
for (int i = 0; i < tol; i++) {
int u = edge[i].u;
int v = edge[i].v;
int w = edge[i].w;
int t1 = find(u);
int t2 = find(v);
if (t1 != t2) {
ans += w;
F[t1] = t2;
cnt++;
}
if (cnt == n - 1)
break;
}
if (cnt < n - 1)
return -1;
else
return ans;
}
// Pre-Build Function
inline void build() {}
// Actual Solver
inline void solve() {
int n, m;
int u, v, w;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> u >> v >> w;
addedge(u, v, w);
}
cout << Kruskal(n) << "\n";
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.tie(nullptr);
#ifdef LOCAL
clock_t _begin = clock();
#endif
build();
solve();
#ifdef LOCAL
cerr << "Time elapsed: " << (double)(clock() - _begin) * 1000 / CLOCKS_PER_SEC
<< "ms." << endl;
#endif
return 0;
}
|
replace
| 110 | 111 | 110 | 111 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(n) for (int i = 0; i < n; i++)
#define repp(j, n) for (int j = 0; j < n; j++)
#define reppp(i, m, n) for (int i = m; i < n; i++)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
struct Edge {
int from, to;
ll cost;
Edge(int from, int to, ll cost) {
this->from = from;
this->to = to;
this->cost = cost;
}
bool operator<(const Edge &e) const { return cost < e.cost; }
bool operator>(const Edge &e) const { return cost > e.cost; }
};
struct Graph {
int V, E;
vector<vector<pair<int, ll>>> edges;
Graph() {
cin >> V >> E;
edges.resize(V);
int s, t;
ll w;
rep(E) {
cin >> s >> t >> w;
edges[s].emplace_back(t, w);
edges[t].emplace_back(s, w);
}
}
ll kruskal() {
ll ret = 0LL;
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
vector<bool> used(V, false);
used[0] = true;
for (pair<int, ll> e : edges[0])
que.push(Edge(0, e.first, e.second));
while (true) {
Edge e = que.top();
que.pop();
while (!que.empty() && used[e.to]) {
e = que.top();
que.pop();
}
if (used[e.to])
break;
ret += e.cost;
used[e.to] = true;
for (pair<int, ll> next : edges[e.to])
if (!used[next.first])
que.push(Edge(e.to, next.first, next.second));
}
return ret;
}
};
int main() {
Graph g = Graph();
cout << g.kruskal() << endl;
}
|
#include <bits/stdc++.h>
#define rep(n) for (int i = 0; i < n; i++)
#define repp(j, n) for (int j = 0; j < n; j++)
#define reppp(i, m, n) for (int i = m; i < n; i++)
#define all(c) c.begin(), c.end()
#define rall(c) c.rbegin(), c.rend()
#define debug(x) cerr << #x << ": " << x << endl
using namespace std;
typedef long long ll;
typedef pair<ll, ll> Pll;
typedef pair<int, int> Pii;
struct Edge {
int from, to;
ll cost;
Edge(int from, int to, ll cost) {
this->from = from;
this->to = to;
this->cost = cost;
}
bool operator<(const Edge &e) const { return cost < e.cost; }
bool operator>(const Edge &e) const { return cost > e.cost; }
};
struct Graph {
int V, E;
vector<vector<pair<int, ll>>> edges;
Graph() {
cin >> V >> E;
edges.resize(V);
int s, t;
ll w;
rep(E) {
cin >> s >> t >> w;
edges[s].emplace_back(t, w);
edges[t].emplace_back(s, w);
}
}
ll kruskal() {
ll ret = 0LL;
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
vector<bool> used(V, false);
used[0] = true;
for (pair<int, ll> e : edges[0])
que.push(Edge(0, e.first, e.second));
while (!que.empty()) {
Edge e = que.top();
que.pop();
while (!que.empty() && used[e.to]) {
e = que.top();
que.pop();
}
if (used[e.to])
break;
ret += e.cost;
used[e.to] = true;
for (pair<int, ll> next : edges[e.to])
if (!used[next.first])
que.push(Edge(e.to, next.first, next.second));
}
return ret;
}
};
int main() {
Graph g = Graph();
cout << g.kruskal() << endl;
}
|
replace
| 52 | 53 | 52 | 53 |
0
| |
p02364
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
const int kInfinity = 0x3F3F3F3F;
const int kNil = -1;
const int kMaxV = 110;
template <class T> struct Edge {
using w_type = T;
Edge(int u, int v, w_type w) : u(u), v(v), w(w) {}
int u, v;
w_type w;
bool operator<(const Edge<T> &rhs) const {
if (w != rhs.w) {
return w < rhs.w;
}
if (u != rhs.u) {
return u < rhs.u;
}
return v < rhs.v;
}
};
template <class Edge>
decltype(auto) Prim(vector<Edge> &edges,
typename vector<Edge>::size_type node_num,
typename vector<Edge>::size_type root) {
using size_type = typename vector<Edge>::size_type;
using const_it = typename vector<Edge>::const_iterator;
using w_type = typename Edge::w_type;
bitset<kMaxV> bs;
vector<vector<Edge>> adjacency(node_num, vector<Edge>());
for (const auto &e : edges) {
adjacency[e.u].push_back(e);
}
vector<w_type> key(node_num, kInfinity);
vector<int> parent(node_num, kNil);
key[root] = 0;
using Pair = pair<size_type, w_type>;
auto compare = [](const Pair &x, const Pair &y) {
return y.second < x.second || (!(x.second < y.second) && y.first < x.first);
};
priority_queue<Pair, vector<Pair>, decltype(compare)> que(compare);
que.emplace(root, 0);
while (!que.empty()) {
auto top_no = que.top().first;
auto top_key = que.top().second;
que.pop();
bs.set(top_no);
for (const auto &e : adjacency[top_no]) {
if (!bs.test(e.v) && e.w < key[e.v]) {
key[e.v] = e.w;
parent[e.v] = e.u;
que.emplace(e.v, e.w);
}
}
}
auto weight_sum = accumulate(key.begin(), key.end(), 0);
return weight_sum;
}
int main(int argc, char const *argv[]) {
vector<Edge<int>> edges;
unsigned V, E, r;
cin >> V >> E;
for (unsigned i = 0; i < E; ++i) {
unsigned u, v;
unsigned w;
cin >> u >> v >> w;
edges.emplace_back(u, v, w);
edges.emplace_back(v, u, w);
}
cout << Prim(edges, V, 0) << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <iostream>
#include <numeric>
#include <queue>
#include <vector>
using namespace std;
const int kInfinity = 0x3F3F3F3F;
const int kNil = -1;
const int kMaxV = 10010;
template <class T> struct Edge {
using w_type = T;
Edge(int u, int v, w_type w) : u(u), v(v), w(w) {}
int u, v;
w_type w;
bool operator<(const Edge<T> &rhs) const {
if (w != rhs.w) {
return w < rhs.w;
}
if (u != rhs.u) {
return u < rhs.u;
}
return v < rhs.v;
}
};
template <class Edge>
decltype(auto) Prim(vector<Edge> &edges,
typename vector<Edge>::size_type node_num,
typename vector<Edge>::size_type root) {
using size_type = typename vector<Edge>::size_type;
using const_it = typename vector<Edge>::const_iterator;
using w_type = typename Edge::w_type;
bitset<kMaxV> bs;
vector<vector<Edge>> adjacency(node_num, vector<Edge>());
for (const auto &e : edges) {
adjacency[e.u].push_back(e);
}
vector<w_type> key(node_num, kInfinity);
vector<int> parent(node_num, kNil);
key[root] = 0;
using Pair = pair<size_type, w_type>;
auto compare = [](const Pair &x, const Pair &y) {
return y.second < x.second || (!(x.second < y.second) && y.first < x.first);
};
priority_queue<Pair, vector<Pair>, decltype(compare)> que(compare);
que.emplace(root, 0);
while (!que.empty()) {
auto top_no = que.top().first;
auto top_key = que.top().second;
que.pop();
bs.set(top_no);
for (const auto &e : adjacency[top_no]) {
if (!bs.test(e.v) && e.w < key[e.v]) {
key[e.v] = e.w;
parent[e.v] = e.u;
que.emplace(e.v, e.w);
}
}
}
auto weight_sum = accumulate(key.begin(), key.end(), 0);
return weight_sum;
}
int main(int argc, char const *argv[]) {
vector<Edge<int>> edges;
unsigned V, E, r;
cin >> V >> E;
for (unsigned i = 0; i < E; ++i) {
unsigned u, v;
unsigned w;
cin >> u >> v >> w;
edges.emplace_back(u, v, w);
edges.emplace_back(v, u, w);
}
cout << Prim(edges, V, 0) << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02365
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using Int = int64_t;
using UInt = uint64_t;
using C = std::complex<double>;
#define rep(i, n) for (Int i = 0; i < (Int)(n); ++i)
#define guard(x) \
if (not(x)) \
continue;
#ifndef LOCAL_
#define fprintf \
if (false) \
fprintf
#endif
#define debug() fprintf(stderr, "#%d\n", __LINE__);
template <typename T>
using RQ = std::priority_queue<T, std::vector<T>, std::greater<T>>;
struct Tree {
Tree(Int n) : ps(n, -1) {}
std::vector<Int> ps;
Int root(Int x) {
if (ps[x] == -1)
return x;
return ps[x] = root(ps[x]);
}
void connect(Int parent, Int child) { ps[root(child)] = root(parent); }
};
int main() {
Int v, e, r;
std::cin >> v >> e >> r;
std::vector<Int> ss(e), ts(e), ws(e);
rep(i, e) std::cin >> ss[i] >> ts[i] >> ws[i];
std::vector<RQ<std::pair<Int, Int>>> qs(v);
std::vector<Int> os(v);
rep(i, e) {
Int s = ss[i], t = ts[i], w = ws[i];
qs[t].emplace(w, s);
}
std::vector<Int> xs(v);
xs[r] = 2;
Tree tree(v);
bool fail = false;
Int res = 0;
rep(i, v) {
fprintf(stderr, "i = %ld\n", i);
Int a = tree.root(i);
assert(xs[a] == 0 or xs[a] == 2);
guard(xs[a] == 0);
std::vector<std::pair<Int, Int>> ps(v); // p->i (cost, p)
std::vector<Int> ys;
while (xs[a] != 2) {
debug();
ys.emplace_back(a);
xs[a] = 1;
if (qs[a].empty()) {
fprintf(stderr, "fail\n");
fail = true;
break;
}
Int w, p;
do {
std::tie(w, p) = qs[a].top();
qs[a].pop();
} while (tree.root(a) == tree.root(p));
w += os[a];
p = tree.root(p);
ps[a] = std::make_pair(w, p);
res += w;
fprintf(stderr, "res += %ld, a = %ld, p = %ld\n", w, a, p);
if (xs[p] != 1) {
a = p;
} else {
Int nr = a;
Int b = a;
do {
fprintf(stderr, "b = %ld\n", b);
if (qs[nr].size() < qs[b].size())
nr = b;
b = ps[b].second;
debug();
} while (b != a);
fprintf(stderr, "new root = %ld\n", nr);
fprintf(stderr, "offset of new root : %ld -> %ld\n", os[nr],
os[nr] - ps[nr].first);
os[nr] -= ps[nr].first;
b = a;
do {
debug();
if (nr != b) {
tree.connect(nr, b);
fprintf(stderr, "connect : %ld <- %ld\n", nr, b);
while (not qs[b].empty()) {
Int w2, p2;
std::tie(w2, p2) = qs[b].top();
qs[b].pop();
w2 += os[b] - ps[b].first;
p2 = tree.root(p2);
Int nw = w2 - os[nr];
fprintf(stderr, "w2 = %ld\n", w2);
fprintf(stderr, "new edge : %ld -> %ld, w = %ld(prev=%ld)\n", p2,
b, nw, w2);
qs[nr].emplace(nw, p2);
debug();
}
}
b = ps[b].second;
} while (b != a);
// b = tree.root(ps[b].second);
// } while( b != tree.root(a) );
a = nr;
}
}
if (fail)
break;
for (Int y : ys) {
xs[y] = 2;
}
}
printf("%ld\n", res);
}
|
#include <bits/stdc++.h>
using Int = int64_t;
using UInt = uint64_t;
using C = std::complex<double>;
#define rep(i, n) for (Int i = 0; i < (Int)(n); ++i)
#define guard(x) \
if (not(x)) \
continue;
#ifndef LOCAL_
#define fprintf \
if (false) \
fprintf
#endif
#define debug() fprintf(stderr, "#%d\n", __LINE__);
template <typename T>
using RQ = std::priority_queue<T, std::vector<T>, std::greater<T>>;
struct Tree {
Tree(Int n) : ps(n, -1) {}
std::vector<Int> ps;
Int root(Int x) {
if (ps[x] == -1)
return x;
return ps[x] = root(ps[x]);
}
void connect(Int parent, Int child) {
parent = root(parent), child = root(child);
if (parent == child)
return;
ps[root(child)] = root(parent);
}
};
int main() {
Int v, e, r;
std::cin >> v >> e >> r;
std::vector<Int> ss(e), ts(e), ws(e);
rep(i, e) std::cin >> ss[i] >> ts[i] >> ws[i];
std::vector<RQ<std::pair<Int, Int>>> qs(v);
std::vector<Int> os(v);
rep(i, e) {
Int s = ss[i], t = ts[i], w = ws[i];
qs[t].emplace(w, s);
}
std::vector<Int> xs(v);
xs[r] = 2;
Tree tree(v);
bool fail = false;
Int res = 0;
rep(i, v) {
fprintf(stderr, "i = %ld\n", i);
Int a = tree.root(i);
assert(xs[a] == 0 or xs[a] == 2);
guard(xs[a] == 0);
std::vector<std::pair<Int, Int>> ps(v); // p->i (cost, p)
std::vector<Int> ys;
while (xs[a] != 2) {
debug();
ys.emplace_back(a);
xs[a] = 1;
if (qs[a].empty()) {
fprintf(stderr, "fail\n");
fail = true;
break;
}
Int w, p;
do {
std::tie(w, p) = qs[a].top();
qs[a].pop();
} while (tree.root(a) == tree.root(p));
w += os[a];
p = tree.root(p);
ps[a] = std::make_pair(w, p);
res += w;
fprintf(stderr, "res += %ld, a = %ld, p = %ld\n", w, a, p);
if (xs[p] != 1) {
a = p;
} else {
Int nr = a;
Int b = a;
do {
fprintf(stderr, "b = %ld\n", b);
if (qs[nr].size() < qs[b].size())
nr = b;
b = ps[b].second;
debug();
} while (b != a);
fprintf(stderr, "new root = %ld\n", nr);
fprintf(stderr, "offset of new root : %ld -> %ld\n", os[nr],
os[nr] - ps[nr].first);
os[nr] -= ps[nr].first;
b = a;
do {
debug();
if (nr != b) {
tree.connect(nr, b);
fprintf(stderr, "connect : %ld <- %ld\n", nr, b);
while (not qs[b].empty()) {
Int w2, p2;
std::tie(w2, p2) = qs[b].top();
qs[b].pop();
w2 += os[b] - ps[b].first;
p2 = tree.root(p2);
Int nw = w2 - os[nr];
fprintf(stderr, "w2 = %ld\n", w2);
fprintf(stderr, "new edge : %ld -> %ld, w = %ld(prev=%ld)\n", p2,
b, nw, w2);
qs[nr].emplace(nw, p2);
debug();
}
}
b = ps[b].second;
} while (b != a);
// b = tree.root(ps[b].second);
// } while( b != tree.root(a) );
a = nr;
}
}
if (fail)
break;
for (Int y : ys) {
xs[y] = 2;
}
}
printf("%ld\n", res);
}
|
replace
| 27 | 28 | 27 | 33 |
0
| |
p02366
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
int const INF = 1 << 29;
typedef vector<int> edges;
typedef vector<edges> graph;
namespace articulation {
int const MaxNum = 1000;
int prenum[MaxNum];
int lowest[MaxNum];
int parent[MaxNum];
int timer;
int V;
bool visited[MaxNum];
graph g;
void dfs(int curr) {
prenum[curr] = timer;
lowest[curr] = timer;
timer++;
visited[curr] = 1;
rep(i, g[curr].size()) {
int next = g[curr][i];
if (!visited[next]) {
parent[next] = curr;
dfs(next);
lowest[curr] = min(lowest[curr], lowest[next]);
} else if (next != curr) {
lowest[curr] = min(lowest[curr], prenum[next]);
}
}
}
vector<int> doit(int V_) {
V = V_;
rep(i, V) { visited[i] = 0; }
timer = 1;
dfs(0);
vector<int> ret;
int cnt = 0;
rep(i, V) {
if (i && parent[i] == 0) {
cnt++;
}
if (parent[i] > 0 && lowest[i] >= prenum[parent[i]]) {
ret.push_back(parent[i]);
}
}
if (cnt >= 2) {
ret.push_back(0);
}
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
} // namespace articulation
int main() {
using namespace articulation;
int N, M;
cin >> N >> M;
g.resize(N);
rep(i, M) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> arts = doit(N);
rep(i, arts.size()) { cout << arts[i] << endl; }
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
int const INF = 1 << 29;
typedef vector<int> edges;
typedef vector<edges> graph;
namespace articulation {
int const MaxNum = 100000;
int prenum[MaxNum];
int lowest[MaxNum];
int parent[MaxNum];
int timer;
int V;
bool visited[MaxNum];
graph g;
void dfs(int curr) {
prenum[curr] = timer;
lowest[curr] = timer;
timer++;
visited[curr] = 1;
rep(i, g[curr].size()) {
int next = g[curr][i];
if (!visited[next]) {
parent[next] = curr;
dfs(next);
lowest[curr] = min(lowest[curr], lowest[next]);
} else if (next != curr) {
lowest[curr] = min(lowest[curr], prenum[next]);
}
}
}
vector<int> doit(int V_) {
V = V_;
rep(i, V) { visited[i] = 0; }
timer = 1;
dfs(0);
vector<int> ret;
int cnt = 0;
rep(i, V) {
if (i && parent[i] == 0) {
cnt++;
}
if (parent[i] > 0 && lowest[i] >= prenum[parent[i]]) {
ret.push_back(parent[i]);
}
}
if (cnt >= 2) {
ret.push_back(0);
}
sort(ret.begin(), ret.end());
ret.erase(unique(ret.begin(), ret.end()), ret.end());
return ret;
}
} // namespace articulation
int main() {
using namespace articulation;
int N, M;
cin >> N >> M;
g.resize(N);
rep(i, M) {
int a, b;
cin >> a >> b;
g[a].push_back(b);
g[b].push_back(a);
}
vector<int> arts = doit(N);
rep(i, arts.size()) { cout << arts[i] << endl; }
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p02366
|
C++
|
Runtime Error
|
/*
??¢??????
lowlink
*/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
const int MAX_V = 100;
vector<int> G[MAX_V];
int ord[MAX_V], low[MAX_V];
int I;
int sum[MAX_V];
vector<int> arts;
void dfs(int v, int p) {
ord[v] = ++I;
low[v] = ord[v];
sum[v] = 1;
int mx = 0, c = 0;
for (int u : G[v])
if (u != p) {
if (ord[u])
chmin(low[v], ord[u]);
else {
dfs(u, v);
c++;
sum[v] += sum[u];
chmin(low[v], low[u]);
chmax(mx, low[u]);
}
}
if (p < 0) {
if (c > 1)
arts.pb(v);
} else {
// cout<<"v="<<v<<" mx="<<mx<<endl;
if (ord[v] <= mx)
arts.pb(v);
}
}
void arti(int N) { rep(i, N) if (ord[i] == 0) dfs(i, -1); }
int main() {
int N, M;
cin >> N >> M;
rep(i, M) {
int a, b;
cin >> a >> b;
G[a].pb(b);
G[b].pb(a);
}
arti(N);
sort(all(arts));
for (int a : arts)
cout << a << endl;
}
|
/*
??¢??????
lowlink
*/
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define all(c) c.begin(), c.end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
using namespace std;
const int MAX_V = 100000;
vector<int> G[MAX_V];
int ord[MAX_V], low[MAX_V];
int I;
int sum[MAX_V];
vector<int> arts;
void dfs(int v, int p) {
ord[v] = ++I;
low[v] = ord[v];
sum[v] = 1;
int mx = 0, c = 0;
for (int u : G[v])
if (u != p) {
if (ord[u])
chmin(low[v], ord[u]);
else {
dfs(u, v);
c++;
sum[v] += sum[u];
chmin(low[v], low[u]);
chmax(mx, low[u]);
}
}
if (p < 0) {
if (c > 1)
arts.pb(v);
} else {
// cout<<"v="<<v<<" mx="<<mx<<endl;
if (ord[v] <= mx)
arts.pb(v);
}
}
void arti(int N) { rep(i, N) if (ord[i] == 0) dfs(i, -1); }
int main() {
int N, M;
cin >> N >> M;
rep(i, M) {
int a, b;
cin >> a >> b;
G[a].pb(b);
G[b].pb(a);
}
arti(N);
sort(all(arts));
for (int a : arts)
cout << a << endl;
}
|
replace
| 15 | 16 | 15 | 16 |
0
| |
p02366
|
C++
|
Runtime Error
|
#include <iostream>
#include <set>
#include <vector>
using namespace std;
const int MAX_V = 100000;
vector<int> G[MAX_V];
int vertex, edge;
bool visited[MAX_V];
int prenum[MAX_V], parent[MAX_V], lowest[MAX_V];
int timer;
set<int> ap;
void dfs(int current, int prev) {
prenum[current] = lowest[current] = timer;
timer++;
visited[current] = true;
int next;
for (auto i = 0; i < G[current].size(); i++) {
next = G[current][i];
if (!visited[next]) {
parent[next] = current;
dfs(next, current);
lowest[current] = min(lowest[current], lowest[next]);
} else if (next != prev) {
lowest[current] = min(lowest[current], prenum[next]);
}
}
}
void ArticulationPoints(void) {
timer = 1;
dfs(0, -1);
int np = 0;
for (int i = 1; i < vertex; i++) {
int p = parent[i];
if (p == 0)
np++;
else if (prenum[p] <= lowest[i])
ap.insert(p);
}
if (np > 1)
ap.insert(0);
}
int main(void) {
cin >> vertex >> edge;
for (int i = 0; i < vertex; i++) {
visited[i] = false;
}
int s, t;
for (int i = 0; i < vertex; i++) {
cin >> s >> t;
G[s].push_back(t);
G[t].push_back(s);
}
ArticulationPoints();
for (auto it = ap.begin(); it != ap.end(); it++) {
cout << *it << endl;
}
return 0;
}
|
#include <iostream>
#include <set>
#include <vector>
using namespace std;
const int MAX_V = 100000;
vector<int> G[MAX_V];
int vertex, edge;
bool visited[MAX_V];
int prenum[MAX_V], parent[MAX_V], lowest[MAX_V];
int timer;
set<int> ap;
void dfs(int current, int prev) {
prenum[current] = lowest[current] = timer;
timer++;
visited[current] = true;
int next;
for (auto i = 0; i < G[current].size(); i++) {
next = G[current][i];
if (!visited[next]) {
parent[next] = current;
dfs(next, current);
lowest[current] = min(lowest[current], lowest[next]);
} else if (next != prev) {
lowest[current] = min(lowest[current], prenum[next]);
}
}
}
void ArticulationPoints(void) {
timer = 1;
dfs(0, -1);
int np = 0;
for (int i = 1; i < vertex; i++) {
int p = parent[i];
if (p == 0)
np++;
else if (prenum[p] <= lowest[i])
ap.insert(p);
}
if (np > 1)
ap.insert(0);
}
int main(void) {
cin >> vertex >> edge;
for (int i = 0; i < vertex; i++) {
visited[i] = false;
}
int s, t;
for (int i = 0; i < edge; i++) {
cin >> s >> t;
G[s].push_back(t);
G[t].push_back(s);
}
ArticulationPoints();
for (auto it = ap.begin(); it != ap.end(); it++) {
cout << *it << endl;
}
return 0;
}
|
replace
| 56 | 57 | 56 | 57 |
0
| |
p02367
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1ll << 29;
const ll MOD = 1000000007;
const double EPS = 1e-9;
const bool debug = 0;
//---------------------------------//
int V, E;
vector<int> g[112345];
vector<int> depth, low;
set<pii> bridge;
int dfs(int u, int p, int d) {
depth[u] = d;
low[u] = d;
for (int v : g[u]) {
if (v == p)
continue;
if (depth[v] == -1) {
chmin(low[u], dfs(v, u, d + 1));
if (depth[v] == low[v])
bridge.insert(pii(min(u, v), max(u, v)));
} else
chmin(low[u], low[v]);
}
return low[u];
}
int main() {
cin >> V >> E;
REP(i, E) {
int s, t;
scanf("%d %d", &s, &t);
g[s].push_back(t);
g[t].push_back(s);
}
depth.resize(V, -1);
low.resize(V, -1);
dfs(0, -1, 0);
for (set<pii>::iterator it = bridge.begin(); it != bridge.end(); ++it) {
printf("%d %d\n", it->first, it->second);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <typename A, typename B> inline bool chmin(A &a, B b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const ll INF = 1ll << 29;
const ll MOD = 1000000007;
const double EPS = 1e-9;
const bool debug = 0;
//---------------------------------//
int V, E;
vector<int> g[112345];
vector<int> depth, low;
set<pii> bridge;
int dfs(int u, int p, int d) {
depth[u] = d;
low[u] = d;
REP(i, g[u].size()) {
int v = g[u][i];
if (v == p)
continue;
if (depth[v] == -1) {
chmin(low[u], dfs(v, u, d + 1));
if (depth[v] == low[v])
bridge.insert(pii(min(u, v), max(u, v)));
} else
chmin(low[u], low[v]);
}
return low[u];
}
int main() {
cin >> V >> E;
REP(i, E) {
int s, t;
scanf("%d %d", &s, &t);
g[s].push_back(t);
g[t].push_back(s);
}
depth.resize(V, -1);
low.resize(V, -1);
dfs(0, -1, 0);
for (set<pii>::iterator it = bridge.begin(); it != bridge.end(); ++it) {
printf("%d %d\n", it->first, it->second);
}
return 0;
}
|
replace
| 37 | 38 | 37 | 39 |
TLE
| |
p02367
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define printV(v) \
for (auto &&x : v) { \
cerr << x << " "; \
} \
cerr << endl
#define printVV(vv) \
for (auto &&v : vv) { \
for (auto &&x : v) { \
cerr << x << " "; \
} \
cerr << endl; \
}
#define printP(p) cerr << p.first << " " << p.second << endl
#define printVP(vp) \
for (auto &&p : vp) \
printP(p);
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<Pii> vp;
const int inf = 1e9;
const int mod = 1e9 + 7;
typedef vector<vector<int>> Graph;
typedef pair<int, int> Edge; // (a < b: undirected)
class BICC {
private:
const int n;
Graph G;
vi depth;
vi par;
map<Edge, int> imosEdge;
map<Edge, int> EdgeType;
enum { UNUSED, USED_DFS, BRIDGE };
vector<Edge> bridges;
vi cmp;
int num_cc;
vi size_of_vertex;
Graph G_cc;
public:
BICC(int _n)
: n(_n), G(_n), depth(_n, -1), par(_n, -1), cmp(_n, -1), num_cc(0) {}
Edge getEdge(int a, int b) {
if (a > b)
swap(a, b);
return Edge(a, b);
}
void updateEdgeType(int a, int b, int type) {
if (a < 0 || b < 0)
return;
EdgeType[getEdge(a, b)] = type;
}
void addEdge(int a, int b) {
G[a].emplace_back(b);
G[b].emplace_back(a);
updateEdgeType(a, b, UNUSED);
}
void dfsTreeConstruct(int v, int pre) {
if (depth[v] != -1)
return;
depth[v] = (pre == -1 ? 0 : depth[pre] + 1);
par[v] = pre;
updateEdgeType(pre, v, USED_DFS);
for (auto &&nxt : G[v]) {
if (nxt != pre)
dfsTreeConstruct(nxt, v);
}
}
void updateImos(int a, int b) {
if (depth[a] < depth[b])
swap(a, b);
if (par[a] != -1) {
imosEdge[getEdge(a, par[a])]++;
}
if (par[b] != -1) {
imosEdge[getEdge(b, par[b])]--;
}
}
int imosFinal(int v, int pre) {
int t = 0;
for (auto &&nxt : G[v]) {
if (nxt != pre && EdgeType[getEdge(nxt, v)] == USED_DFS) {
t += imosFinal(nxt, v);
}
}
if (pre != -1)
imosEdge[getEdge(v, pre)] += t;
return pre == -1 ? 0 : imosEdge[getEdge(v, pre)];
}
int extractCC(int v, int color) {
if (cmp[v] != -1)
return 0;
cmp[v] = color;
int t = 1;
for (auto &&nxt : G[v]) {
if (EdgeType[getEdge(v, nxt)] != BRIDGE) {
t += extractCC(nxt, color);
}
}
return t;
}
void bicc() {
dfsTreeConstruct(0, -1);
for (auto &&p : EdgeType) {
Edge e;
int type;
tie(e, type) = p;
if (type == UNUSED) {
updateImos(e.first, e.second);
}
}
imosFinal(0, -1);
for (auto &&p : EdgeType) {
Edge e;
int type;
tie(e, type) = p;
if (type == USED_DFS) {
if (imosEdge[e] == 0) {
EdgeType[e] = BRIDGE;
bridges.emplace_back(e);
}
}
}
// rep(i, n) {
// int size_cc = extractCC(i, num_cc);
// if (size_cc > 0) {
// size_of_vertex.emplace_back(size_cc);
// num_cc++;
// }
// }
//
// r<set<int>> G_cc_st(num_cc);
// for (auto&& p : EdgeType) {
// Edge e;
// int type;
// tie(e, type) = p;
// if (type == BRIDGE) {
// G_cc_st[cmp[e.first]].insert(cmp[e.second]);
// G_cc_st[cmp[e.second]].insert(cmp[e.first]);
// }
// }
//
// rep(i, num_cc) {
// G_cc.emplace_back(vector<int>(all(G_cc_st[i])));
// }
}
vector<Edge> getBridges() { return bridges; }
};
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int V, E;
cin >> V >> E;
BICC bicc(V);
rep(i, E) {
int a, b;
cin >> a >> b;
bicc.addEdge(a, b);
}
bicc.bicc();
auto bridges = bicc.getBridges();
printVP(bridges);
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define printV(v) \
for (auto &&x : v) { \
cerr << x << " "; \
} \
cerr << endl
#define printVV(vv) \
for (auto &&v : vv) { \
for (auto &&x : v) { \
cerr << x << " "; \
} \
cerr << endl; \
}
#define printP(p) cerr << p.first << " " << p.second << endl
#define printVP(vp) \
for (auto &&p : vp) \
printP(p);
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<Pii> vp;
const int inf = 1e9;
const int mod = 1e9 + 7;
typedef vector<vector<int>> Graph;
typedef pair<int, int> Edge; // (a < b: undirected)
class BICC {
private:
const int n;
Graph G;
vi depth;
vi par;
map<Edge, int> imosEdge;
map<Edge, int> EdgeType;
enum { UNUSED, USED_DFS, BRIDGE };
vector<Edge> bridges;
vi cmp;
int num_cc;
vi size_of_vertex;
Graph G_cc;
public:
BICC(int _n)
: n(_n), G(_n), depth(_n, -1), par(_n, -1), cmp(_n, -1), num_cc(0) {}
Edge getEdge(int a, int b) {
if (a > b)
swap(a, b);
return Edge(a, b);
}
void updateEdgeType(int a, int b, int type) {
if (a < 0 || b < 0)
return;
EdgeType[getEdge(a, b)] = type;
}
void addEdge(int a, int b) {
G[a].emplace_back(b);
G[b].emplace_back(a);
updateEdgeType(a, b, UNUSED);
}
void dfsTreeConstruct(int v, int pre) {
if (depth[v] != -1)
return;
depth[v] = (pre == -1 ? 0 : depth[pre] + 1);
par[v] = pre;
updateEdgeType(pre, v, USED_DFS);
for (auto &&nxt : G[v]) {
if (nxt != pre)
dfsTreeConstruct(nxt, v);
}
}
void updateImos(int a, int b) {
if (depth[a] < depth[b])
swap(a, b);
if (par[a] != -1) {
imosEdge[getEdge(a, par[a])]++;
}
if (par[b] != -1) {
imosEdge[getEdge(b, par[b])]--;
}
}
int imosFinal(int v, int pre) {
int t = 0;
for (auto &&nxt : G[v]) {
if (nxt != pre && EdgeType[getEdge(nxt, v)] == USED_DFS) {
t += imosFinal(nxt, v);
}
}
if (pre != -1)
imosEdge[getEdge(v, pre)] += t;
return pre == -1 ? 0 : imosEdge[getEdge(v, pre)];
}
int extractCC(int v, int color) {
if (cmp[v] != -1)
return 0;
cmp[v] = color;
int t = 1;
for (auto &&nxt : G[v]) {
if (EdgeType[getEdge(v, nxt)] != BRIDGE) {
t += extractCC(nxt, color);
}
}
return t;
}
void bicc() {
dfsTreeConstruct(0, -1);
for (auto &&p : EdgeType) {
Edge e;
int type;
tie(e, type) = p;
if (type == UNUSED) {
updateImos(e.first, e.second);
}
}
imosFinal(0, -1);
for (auto &&p : EdgeType) {
Edge e;
int type;
tie(e, type) = p;
if (type == USED_DFS) {
if (imosEdge[e] == 0) {
EdgeType[e] = BRIDGE;
bridges.emplace_back(e);
}
}
}
// rep(i, n) {
// int size_cc = extractCC(i, num_cc);
// if (size_cc > 0) {
// size_of_vertex.emplace_back(size_cc);
// num_cc++;
// }
// }
//
// r<set<int>> G_cc_st(num_cc);
// for (auto&& p : EdgeType) {
// Edge e;
// int type;
// tie(e, type) = p;
// if (type == BRIDGE) {
// G_cc_st[cmp[e.first]].insert(cmp[e.second]);
// G_cc_st[cmp[e.second]].insert(cmp[e.first]);
// }
// }
//
// rep(i, num_cc) {
// G_cc.emplace_back(vector<int>(all(G_cc_st[i])));
// }
}
vector<Edge> getBridges() { return bridges; }
};
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
int V, E;
cin >> V >> E;
BICC bicc(V);
rep(i, E) {
int a, b;
cin >> a >> b;
bicc.addEdge(a, b);
}
bicc.bicc();
auto bridges = bicc.getBridges();
// printVP(bridges);
for (auto &&e : bridges) {
cout << e.first << " " << e.second << endl;
}
}
|
replace
| 183 | 184 | 183 | 187 |
0
|
2 3
|
p02367
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
// O(|V|+|E|)
template <class graph_type> class bridge_and_articulation {
public:
const int size;
graph_type graph;
vector<bool> used, is_art;
vector<int> ord, low, articulations;
vector<pair<int, int>> bridges;
bridge_and_articulation(const graph_type &graph)
: graph(graph), size(graph.size()), used(size), is_art(size), ord(size),
low(size) {
int k = 0;
for (int i = 0; i < size; ++i)
if (!used[i])
dfs(i, -1, k);
}
void dfs(int v, int p, int &k) { // v???????????¨???p=-1
used[v] = true;
ord[v] = low[v] = k++;
int count = 0;
for (const auto &edge : graph[v]) {
const int u = edge.to;
if (!used[u]) {
++count;
dfs(u, v, k);
low[v] = min(low[v], low[u]);
if (ord[v] < low[u])
bridges.push_back(make_pair(min(v, u), max(v, u)));
if (p != -1 and ord[v] <= low[u])
is_art[v] = true;
} else if (u != p)
low[v] = min(low[v], ord[u]);
}
if (p == -1 and count > 1)
is_art[v] = true;
if (is_art[v])
articulations.push_back(v);
}
bool is_bridge(int u, int v) const {
if (ord[u] > ord[v])
swap(u, v);
return ord[u] < low[v];
}
bool is_articulation(int v) const { return is_art[v]; }
};
struct edge {
int to;
};
void solve() {
int v, e;
cin >> v >> e;
vector<vector<edge>> graph(v);
rep(i, 0, e) {
int s, t;
cin >> s >> t;
graph[s].push_back(edge({t}));
graph[t].push_back(edge({s}));
}
bridge_and_articulation<vector<vector<edge>>> ba(graph);
vector<pair<int, int>> ans = ba.bridges;
sort(ans.begin(), ans.end());
for (auto &e : ans)
cout << e.first << " " << e.second << endl;
cerr << ba.ord << endl;
cerr << ba.low << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
// O(|V|+|E|)
template <class graph_type> class bridge_and_articulation {
public:
const int size;
graph_type graph;
vector<bool> used, is_art;
vector<int> ord, low, articulations;
vector<pair<int, int>> bridges;
bridge_and_articulation(const graph_type &graph)
: graph(graph), size(graph.size()), used(size), is_art(size), ord(size),
low(size) {
int k = 0;
for (int i = 0; i < size; ++i)
if (!used[i])
dfs(i, -1, k);
}
void dfs(int v, int p, int &k) { // v???????????¨???p=-1
used[v] = true;
ord[v] = low[v] = k++;
int count = 0;
for (const auto &edge : graph[v]) {
const int u = edge.to;
if (!used[u]) {
++count;
dfs(u, v, k);
low[v] = min(low[v], low[u]);
if (ord[v] < low[u])
bridges.push_back(make_pair(min(v, u), max(v, u)));
if (p != -1 and ord[v] <= low[u])
is_art[v] = true;
} else if (u != p)
low[v] = min(low[v], ord[u]);
}
if (p == -1 and count > 1)
is_art[v] = true;
if (is_art[v])
articulations.push_back(v);
}
bool is_bridge(int u, int v) const {
if (ord[u] > ord[v])
swap(u, v);
return ord[u] < low[v];
}
bool is_articulation(int v) const { return is_art[v]; }
};
struct edge {
int to;
};
void solve() {
int v, e;
cin >> v >> e;
vector<vector<edge>> graph(v);
rep(i, 0, e) {
int s, t;
cin >> s >> t;
graph[s].push_back(edge({t}));
graph[t].push_back(edge({s}));
}
bridge_and_articulation<vector<vector<edge>>> ba(graph);
vector<pair<int, int>> ans = ba.bridges;
sort(ans.begin(), ans.end());
for (auto &e : ans)
cout << e.first << " " << e.second << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
delete
| 99 | 101 | 99 | 99 |
0
|
[0,1,2,3,]
[0,0,0,3,]
|
p02367
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const int inf = 1e8;
class BRI {
public:
int N;
vi used;
vvi G;
vp bridge;
void add_edge(int s, int t) {
G[s].pb(t);
G[t].pb(s);
}
BRI(int size) {
N = size;
G = vvi(N);
}
int dfs(int i, int prev, int &n) {
if (used[i])
return used[i];
int m = n;
used[i] = n++;
rep(j, G[i].size()) {
if (prev == G[i][j])
continue;
if (used[i] < used[G[i][j]])
continue;
int res = dfs(G[i][j], i, n);
m = min(m, res);
if (used[i] < res)
bridge.pb(pii(min(i, G[i][j]), max(i, G[i][j])));
}
return m;
}
void bri() {
used = vi(N);
bridge = vp(0);
int n = 1;
rep(i, n) if (!used[i]) dfs(i, -1, n);
sort(all(bridge));
rep(i, bridge.size()) cout << bridge[i].first << " " << bridge[i].second
<< endl;
}
};
int main() {
int n, m;
cin >> n >> m;
BRI bri(n);
while (m--) {
int a, b;
cin >> a >> b;
bri.add_edge(a, b);
}
bri.bri();
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const int inf = 1e8;
class BRI {
public:
int N;
vi used;
vvi G;
vp bridge;
void add_edge(int s, int t) {
G[s].pb(t);
G[t].pb(s);
}
BRI(int size) {
N = size;
G = vvi(N);
}
int dfs(int i, int prev, int &n) {
if (used[i])
return used[i];
int m = n;
used[i] = n++;
rep(j, G[i].size()) {
if (prev == G[i][j])
continue;
if (used[i] < used[G[i][j]])
continue;
int res = dfs(G[i][j], i, n);
m = min(m, res);
if (used[i] < res)
bridge.pb(pii(min(i, G[i][j]), max(i, G[i][j])));
}
return m;
}
void bri() {
used = vi(N);
bridge = vp(0);
int n = 1;
rep(i, N) if (!used[i]) dfs(i, -1, n);
sort(all(bridge));
rep(i, bridge.size()) cout << bridge[i].first << " " << bridge[i].second
<< endl;
}
};
int main() {
int n, m;
cin >> n >> m;
BRI bri(n);
while (m--) {
int a, b;
cin >> a >> b;
bri.add_edge(a, b);
}
bri.bri();
}
|
replace
| 67 | 68 | 67 | 68 |
-11
| |
p02367
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.txt"
struct Edge {
int src;
int dst;
int id;
};
// res: bridges
// v: current node
// from: parent node
int dfs2(vector<vector<Edge>> &g, vector<int> &res, int v, int &count,
int from_id, vector<int> &low, vector<int> &pre) {
pre[v] = count++;
low[v] = pre[v];
for (auto it = g[v].begin(); it != g[v].end(); it++) {
int to = it->dst;
if (pre[to] == -1) {
// destination has not been visited
// visit destination and update low[v]
low[v] = min(low[v], dfs2(g, res, to, count, it->id, low, pre));
if (low[to] == pre[to]) {
// edge is not contained in a closed path -> bridge
// res.push_back(it->id);
res[it->id] = true;
}
} else {
if (from_id == it->id) {
// ignore a path to parent
continue;
}
low[v] = min(low[v], low[to]);
}
}
return low[v];
}
// Calculate bridges in a undirected graph.
// Assume graph is connected and has no parallel edges or self-loops.
// g: adjacency list
// V: number of nodes
void bridges(vector<vector<Edge>> &g, int V, vector<int> &res) {
if (V > 0) {
// assume at least the first vertex exists
vector<int> low(V, -1); // lowest reacheable index
vector<int> pre(V, -1); // pre-order index
int count = 0; // pre-order index counter
dfs2(g, res, 0, count, -1, low, pre); // start dfs from vertex 0
}
}
int main() {
int V, E;
cin >> V >> E;
vector<vector<Edge>> es(V);
vector<Edge> eids;
for (int i = 0; i < E; ++i) {
int s, t;
cin >> s >> t;
if (s > t)
swap(s, t);
es[s].push_back(Edge{s, t, i});
es[t].push_back(Edge{t, s, i});
eids.push_back(Edge{s, t, i});
}
vector<int> res(E);
bridges(es, V, res);
vector<Edge> bris;
for (int i = 0; i < V; ++i) {
if (res[i])
bris.push_back(eids[i]);
}
sort(bris.begin(), bris.end(), [=](const Edge &l, const Edge &r) {
return l.src == r.src ? l.dst < r.dst : l.src < r.src;
});
for (int i = 0; i < bris.size(); ++i) {
cout << bris[i].src << " " << bris[i].dst << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.txt"
struct Edge {
int src;
int dst;
int id;
};
// res: bridges
// v: current node
// from: parent node
int dfs2(vector<vector<Edge>> &g, vector<int> &res, int v, int &count,
int from_id, vector<int> &low, vector<int> &pre) {
pre[v] = count++;
low[v] = pre[v];
for (auto it = g[v].begin(); it != g[v].end(); it++) {
int to = it->dst;
if (pre[to] == -1) {
// destination has not been visited
// visit destination and update low[v]
low[v] = min(low[v], dfs2(g, res, to, count, it->id, low, pre));
if (low[to] == pre[to]) {
// edge is not contained in a closed path -> bridge
// res.push_back(it->id);
res[it->id] = true;
}
} else {
if (from_id == it->id) {
// ignore a path to parent
continue;
}
low[v] = min(low[v], low[to]);
}
}
return low[v];
}
// Calculate bridges in a undirected graph.
// Assume graph is connected and has no parallel edges or self-loops.
// g: adjacency list
// V: number of nodes
void bridges(vector<vector<Edge>> &g, int V, vector<int> &res) {
if (V > 0) {
// assume at least the first vertex exists
vector<int> low(V, -1); // lowest reacheable index
vector<int> pre(V, -1); // pre-order index
int count = 0; // pre-order index counter
dfs2(g, res, 0, count, -1, low, pre); // start dfs from vertex 0
}
}
int main() {
int V, E;
cin >> V >> E;
vector<vector<Edge>> es(V);
vector<Edge> eids;
for (int i = 0; i < E; ++i) {
int s, t;
cin >> s >> t;
if (s > t)
swap(s, t);
es[s].push_back(Edge{s, t, i});
es[t].push_back(Edge{t, s, i});
eids.push_back(Edge{s, t, i});
}
vector<int> res(E);
bridges(es, V, res);
vector<Edge> bris;
for (int i = 0; i < E; ++i) {
if (res[i])
bris.push_back(eids[i]);
}
sort(bris.begin(), bris.end(), [=](const Edge &l, const Edge &r) {
return l.src == r.src ? l.dst < r.dst : l.src < r.src;
});
for (int i = 0; i < bris.size(); ++i) {
cout << bris[i].src << " " << bris[i].dst << endl;
}
return 0;
}
|
replace
| 80 | 81 | 80 | 81 |
0
| |
p02367
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
struct edge {
int f, t;
};
const int V_MAX = (int)1e5 + 10;
vector<int> edges[V_MAX];
int ord[V_MAX];
int low[V_MAX];
bool used_v[V_MAX];
vector<edge> ans;
bool comp(edge e1, edge e2) {
if (e1.f == e2.f) {
return e1.t < e2.t;
} else {
return e1.f < e2.f;
}
}
void dfs(int u, int prev, int k) {
low[u] = ord[u] = k;
k += 1;
used_v[u] = true;
for (int i = 0; i < edges[u].size(); i++) {
int next = edges[u][i];
if (not used_v[next]) {
dfs(next, u, k);
low[u] = min(low[u], low[next]);
if (low[next] > ord[u]) {
edge e;
e.f = min(u, next);
e.t = max(u, next);
ans.push_back(e);
}
} else if (prev != next) {
low[u] = min(low[u], ord[next]);
}
}
return;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int v, e;
cin >> v >> e;
for (int i = 0; i < e; i++) {
int a, b;
scanf("%d %d", &a, &b);
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(0, -1, 1);
sort(ans.begin(), ans.end(), comp);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].f << " " << ans[i].t << "\n";
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <map>
#include <set>
#include <stdio.h>
#include <vector>
using namespace std;
struct edge {
int f, t;
};
const int V_MAX = (int)1e5 + 10;
vector<int> edges[V_MAX];
int ord[V_MAX];
int low[V_MAX];
bool used_v[V_MAX];
vector<edge> ans;
bool comp(edge e1, edge e2) {
if (e1.f == e2.f) {
return e1.t < e2.t;
} else {
return e1.f < e2.f;
}
}
void dfs(int u, int prev, int k) {
low[u] = ord[u] = k;
k += 1;
used_v[u] = true;
for (int i = 0; i < edges[u].size(); i++) {
int next = edges[u][i];
if (not used_v[next]) {
dfs(next, u, k);
low[u] = min(low[u], low[next]);
if (low[next] > ord[u]) {
edge e;
e.f = min(u, next);
e.t = max(u, next);
ans.push_back(e);
}
} else if (prev != next) {
low[u] = min(low[u], ord[next]);
}
}
return;
}
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
int v, e;
cin >> v >> e;
for (int i = 0; i < e; i++) {
int a, b;
// scanf("%d %d", &a, &b);
cin >> a >> b;
edges[a].push_back(b);
edges[b].push_back(a);
}
dfs(0, -1, 1);
sort(ans.begin(), ans.end(), comp);
for (int i = 0; i < ans.size(); i++) {
cout << ans[i].f << " " << ans[i].t << "\n";
}
return 0;
}
|
replace
| 62 | 63 | 62 | 64 |
-11
| |
p02368
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_N = 10000;
const int V = 10000;
vector<int> G[MAX_N];
vector<int> rG[MAX_N];
vector<int> vs; //??°?????????????????????
bool used[MAX_N]; //?????§????????????????????????
int cmp[MAX_N]; //?±????????????£????????????????????????????????????
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
if (!used[G[v][i]]) {
dfs(G[v][i]);
}
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (int i = 0; i < rG[v].size(); i++) {
if (!used[rG[v][i]]) {
rdfs(rG[v][i], k);
}
}
}
int scc(int n) //?????£??????????????°?????????
{
memset(used, 0, sizeof(used));
vs.clear();
for (int v = 0; v < n; v++) {
if (!used[v]) {
dfs(v);
}
}
memset(used, 0, sizeof(used));
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--) {
if (!used[vs[i]]) {
rdfs(vs[i], k++);
}
}
return k;
}
int main() {
int n, m, from, to, k, l, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> from >> to;
add_edge(from, to);
}
k = scc(m);
cin >> l;
for (int i = 0; i < l; i++) {
cin >> u >> v;
printf("%d\n", (cmp[u] == cmp[v]));
}
}
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_N = 10000;
const int V = 10000;
vector<int> G[MAX_N];
vector<int> rG[MAX_N];
vector<int> vs; //??°?????????????????????
bool used[MAX_N]; //?????§????????????????????????
int cmp[MAX_N]; //?±????????????£????????????????????????????????????
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
if (!used[G[v][i]]) {
dfs(G[v][i]);
}
}
vs.push_back(v);
}
void rdfs(int v, int k) {
used[v] = true;
cmp[v] = k;
for (int i = 0; i < rG[v].size(); i++) {
if (!used[rG[v][i]]) {
rdfs(rG[v][i], k);
}
}
}
int scc(int n) //?????£??????????????°?????????
{
memset(used, 0, sizeof(used));
vs.clear();
for (int v = 0; v < n; v++) {
if (!used[v]) {
dfs(v);
}
}
memset(used, 0, sizeof(used));
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--) {
if (!used[vs[i]]) {
rdfs(vs[i], k++);
}
}
return k;
}
int main() {
int n, m, from, to, k, l, u, v;
cin >> n >> m;
for (int i = 0; i < m; i++) {
cin >> from >> to;
add_edge(from, to);
}
k = scc(n);
cin >> l;
for (int i = 0; i < l; i++) {
cin >> u >> v;
printf("%d\n", (cmp[u] == cmp[v]));
}
}
|
replace
| 68 | 69 | 68 | 69 |
0
| |
p02368
|
C++
|
Runtime Error
|
/*
* Strongly Connected Components
* A direced graph is strongly connected if every two nodes are reachable from
* each other. In a strongly connected component of a directed graph, every two
* nodes of the component are mutually reachable.
*
* Input
* A directed graph G(V,E) and a sequence of queries where each query contains a
* pair of nodes u and v.
*
* |V| |E|
* s0 t0
* s1 t1
* :
* s|E|−1 t|E|−1
* Q
* u0 v0
* u1 v1
* :
* uQ−1 vQ−1
* |V| is the number of nodes and |E| is the number of edges in the graph. The
* graph nodes are named with the numbers 0, 1,..., |V|-1 respectively.
*
* si and ti represent source and target nodes of i-th edge (directed).
*
* ui and vi represent a pair of nodes given as the i-th query.
*
* Output
* For each query, pinrt "1" if the given nodes belong to the same strongly
* connected component, "0" otherwise.
*
* Constraints
* 1 ≤ |V| ≤ 10,000
* 0 ≤ |E| ≤ 30,000
* 1 ≤ Q ≤ 100,000
*/
#include <algorithm>
#include <functional>
#include <iostream>
#include <stack>
#include <vector>
#define MAXN 10010
#define MAXM 30030
using namespace std;
struct edge {
int to, next;
};
bool visited[MAXN];
void dfs(int i, vector<edge> &E, vector<int> &LE,
const function<void(int)> &preprocess,
const function<void(int)> &postprocess) {
if (visited[i])
return;
visited[i] = true;
preprocess(i);
for (int e = LE[i]; e != -1; e = E[e].next)
dfs(E[e].to, E, LE, preprocess, postprocess);
postprocess(i);
}
int main() {
vector<int> LE(MAXN, -1), LErev(MAXN, -1);
vector<edge> E(MAXN), Erev(MAXN + MAXM);
int n, m;
cin >> n >> m;
for (int src, dst, i = 0; i < m; ++i) {
cin >> src >> dst;
E[i] = {dst, LE[src]};
LE[src] = i;
Erev[i] = {src, LErev[dst]};
LErev[dst] = i;
}
// adding dummy node with index n for DFS
for (int i = m; i < m + n; ++i) {
Erev[i] = {i - m, LErev[n]};
LErev[n] = i;
}
fill(visited, visited + MAXN, false);
stack<int> grev_post; // pop off in descending postnumber order in Grev
dfs(
n, Erev, LErev, [](int x) { return; }, [&](int x) { grev_post.push(x); });
grev_post.pop(); // dummy node
vector<int> scc(n);
fill(visited, visited + MAXN, false);
for (int i = 1; !grev_post.empty(); ++i) {
while (!grev_post.empty() && scc[grev_post.top()])
grev_post.pop();
if (grev_post.empty())
break;
dfs(
grev_post.top(), E, LE, [&](int x) { scc[x] = i; },
[](int x) { return; });
}
int q;
cin >> q;
for (int s, t; cin >> s >> t;) {
cout << (scc[s] == scc[t]) << endl;
}
}
|
/*
* Strongly Connected Components
* A direced graph is strongly connected if every two nodes are reachable from
* each other. In a strongly connected component of a directed graph, every two
* nodes of the component are mutually reachable.
*
* Input
* A directed graph G(V,E) and a sequence of queries where each query contains a
* pair of nodes u and v.
*
* |V| |E|
* s0 t0
* s1 t1
* :
* s|E|−1 t|E|−1
* Q
* u0 v0
* u1 v1
* :
* uQ−1 vQ−1
* |V| is the number of nodes and |E| is the number of edges in the graph. The
* graph nodes are named with the numbers 0, 1,..., |V|-1 respectively.
*
* si and ti represent source and target nodes of i-th edge (directed).
*
* ui and vi represent a pair of nodes given as the i-th query.
*
* Output
* For each query, pinrt "1" if the given nodes belong to the same strongly
* connected component, "0" otherwise.
*
* Constraints
* 1 ≤ |V| ≤ 10,000
* 0 ≤ |E| ≤ 30,000
* 1 ≤ Q ≤ 100,000
*/
#include <algorithm>
#include <functional>
#include <iostream>
#include <stack>
#include <vector>
#define MAXN 10010
#define MAXM 30030
using namespace std;
struct edge {
int to, next;
};
bool visited[MAXN];
void dfs(int i, vector<edge> &E, vector<int> &LE,
const function<void(int)> &preprocess,
const function<void(int)> &postprocess) {
if (visited[i])
return;
visited[i] = true;
preprocess(i);
for (int e = LE[i]; e != -1; e = E[e].next)
dfs(E[e].to, E, LE, preprocess, postprocess);
postprocess(i);
}
int main() {
vector<int> LE(MAXN, -1), LErev(MAXN, -1);
vector<edge> E(MAXM), Erev(MAXN + MAXM);
int n, m;
cin >> n >> m;
for (int src, dst, i = 0; i < m; ++i) {
cin >> src >> dst;
E[i] = {dst, LE[src]};
LE[src] = i;
Erev[i] = {src, LErev[dst]};
LErev[dst] = i;
}
// adding dummy node with index n for DFS
for (int i = m; i < m + n; ++i) {
Erev[i] = {i - m, LErev[n]};
LErev[n] = i;
}
fill(visited, visited + MAXN, false);
stack<int> grev_post; // pop off in descending postnumber order in Grev
dfs(
n, Erev, LErev, [](int x) { return; }, [&](int x) { grev_post.push(x); });
grev_post.pop(); // dummy node
vector<int> scc(n);
fill(visited, visited + MAXN, false);
for (int i = 1; !grev_post.empty(); ++i) {
while (!grev_post.empty() && scc[grev_post.top()])
grev_post.pop();
if (grev_post.empty())
break;
dfs(
grev_post.top(), E, LE, [&](int x) { scc[x] = i; },
[](int x) { return; });
}
int q;
cin >> q;
for (int s, t; cin >> s >> t;) {
cout << (scc[s] == scc[t]) << endl;
}
}
|
replace
| 68 | 69 | 68 | 69 |
0
| |
p02368
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, b) for (int i = 0; i < int(b); i++)
#define eb emplace_back
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(int src_, int dst_, Weight weight_)
: src(src_), dst(dst_), weight(weight_) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;
vector<int> stronglyConnectedComponents(const Graph &g) {
int n = g.size();
Graph rg(n);
for (const Edges &es : g)
for (const Edge &e : es)
rg[e.dst].eb(e.dst, e.src, e.weight);
vector<int> S(n * 2);
vector<int> cmp(n, -1), added(n), visited(n), ord(n);
int sz = 0;
for (int i = 0; i < n; i++)
if (!visited[i]) {
int s = 0;
S[s++] = i;
while (s) {
int v = S[s - 1];
visited[v] = true;
bool pushed = false;
for (auto &e : g[v]) {
int dst = e.dst;
if (!visited[dst]) {
S[s++] = dst;
pushed = true;
}
}
if (pushed)
continue;
int t = S[s - 1];
if (!added[t]) {
added[t] = true;
ord[sz++] = t;
}
--s;
}
}
int k = 0;
for (int i = 0; i < n; i++) {
int u = ord[n - i - 1];
if (cmp[u] != -1)
continue;
int s = 0;
S[s++] = u;
while (s) {
int v = S[--s];
cmp[v] = k;
for (auto &e : rg[v]) {
int d = e.dst;
if (cmp[d] == -1)
S[s++] = d;
}
}
++k;
}
return cmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
Graph g(n);
rep(i, m) {
int a, b;
cin >> a >> b;
g[a].eb(a, b, 0);
}
vector<int> c = stronglyConnectedComponents(g);
int q;
cin >> q;
rep(i, q) {
int a, b;
cin >> a >> b;
cout << (c[a] == c[b]) << '\n';
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, b) for (int i = 0; i < int(b); i++)
#define eb emplace_back
using Weight = int;
struct Edge {
int src, dst;
Weight weight;
Edge(int src_, int dst_, Weight weight_)
: src(src_), dst(dst_), weight(weight_) {}
};
bool operator<(const Edge &e, const Edge &f) {
return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
e.src != f.src ? e.src < f.src
: e.dst < f.dst;
}
using Edges = vector<Edge>;
using Graph = vector<Edges>;
using Array = vector<Weight>;
using Matrix = vector<Array>;
vector<int> stronglyConnectedComponents(const Graph &g) {
int n = g.size();
Graph rg(n);
for (const Edges &es : g)
for (const Edge &e : es)
rg[e.dst].eb(e.dst, e.src, e.weight);
static int S[10010];
vector<int> cmp(n, -1), added(n), visited(n), ord(n);
int sz = 0;
for (int i = 0; i < n; i++)
if (!visited[i]) {
int s = 0;
S[s++] = i;
while (s) {
int v = S[s - 1];
visited[v] = true;
bool pushed = false;
for (auto &e : g[v]) {
int dst = e.dst;
if (!visited[dst]) {
S[s++] = dst;
pushed = true;
}
}
if (pushed)
continue;
int t = S[s - 1];
if (!added[t]) {
added[t] = true;
ord[sz++] = t;
}
--s;
}
}
int k = 0;
for (int i = 0; i < n; i++) {
int u = ord[n - i - 1];
if (cmp[u] != -1)
continue;
int s = 0;
S[s++] = u;
while (s) {
int v = S[--s];
cmp[v] = k;
for (auto &e : rg[v]) {
int d = e.dst;
if (cmp[d] == -1)
S[s++] = d;
}
}
++k;
}
return cmp;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
int n, m;
cin >> n >> m;
Graph g(n);
rep(i, m) {
int a, b;
cin >> a >> b;
g[a].eb(a, b, 0);
}
vector<int> c = stronglyConnectedComponents(g);
int q;
cin >> q;
rep(i, q) {
int a, b;
cin >> a >> b;
cout << (c[a] == c[b]) << '\n';
}
}
|
replace
| 29 | 30 | 29 | 30 |
0
| |
p02368
|
C++
|
Runtime Error
|
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef int32_t i32;
typedef int64_t i64;
typedef i64 ll;
typedef uint32_t uint;
typedef uint64_t ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) \
for (__typeof((o).begin()) it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
bool isF = true;
for (auto &v : ss) {
if (!isF)
os << " ";
os << v;
isF = false;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <class T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
namespace __scc {
typedef vector<vector<int>> Graph;
// O(V+E)
class Scc {
public:
// private:
int N;
Graph g;
vector<int> ord, low, cmp;
vector<bool> vis;
stack<int> st;
vector<bool> S;
int gi;
void dfs(int v, int p, int &k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
st.push(v);
S[v] = true;
for (int to : g[v]) {
if (!vis[to]) {
dfs(to, v, k);
low[v] = min(low[v], low[to]);
} else if (S[to]) {
low[v] = min(low[v], ord[to]);
}
}
if (low[v] != ord[v])
return;
while (st.top() != v) {
cmp[st.top()] = gi;
S[st.top()] = false;
st.pop();
}
cmp[v] = gi;
S[v] = false;
st.pop();
gi++;
}
public:
Scc(int N) : N(N) {
g = Graph(N);
ord = cmp = low = vector<int>(N, -1);
vis = S = vector<bool>(N);
}
void add_edge(int f, int t) { g[f].push_back(t); }
void scc() {
int k = 0;
gi = 0;
REP(v, N) if (!vis[v]) dfs(v, -1, k);
}
bool same(int i, int j) { return cmp[i] == cmp[j]; }
};
} // namespace __scc
using namespace __scc;
class Main {
public:
void run() {
// include check
int N, E;
nextInt(N);
nextInt(E);
Scc g(N);
REP(i, E) {
int s, t;
nextInt(s);
nextInt(t);
g.add_edge(s, t);
}
g.scc();
cerr << g.cmp << endl;
int Q;
nextInt(Q);
REP(q, Q) {
int u, v;
nextInt(u);
nextInt(v);
cout << (g.same(u, v) ? 1 : 0) << endl;
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
}
|
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef int32_t i32;
typedef int64_t i64;
typedef i64 ll;
typedef uint32_t uint;
typedef uint64_t ull;
#define ALL(c) (begin(c)), (end(c))
#define REP(i, n) FOR(i, 0, n)
#define REPr(i, n) FORr(i, 0, n)
#define FOR(i, l, r) for (int i = (int)(l); i < (int)(r); ++i)
#define FORr(i, l, r) for (int i = (int)(r)-1; i >= (int)(l); --i)
#define EACH(it, o) \
for (__typeof((o).begin()) it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
class range {
private:
struct Iter {
int v;
int operator*() { return v; }
bool operator!=(Iter &itr) { return v < itr.v; }
void operator++() { ++v; }
};
Iter i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iter &begin() { return i; }
Iter &end() { return n; }
};
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
bool isF = true;
for (auto &v : ss) {
if (!isF)
os << " ";
os << v;
isF = false;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
// input
char tmp[1000];
#define nextInt(n) scanf("%d", &n)
#define nextLong(n) scanf("%lld", &n) // I64d
#define nextDouble(n) scanf("%lf", &n)
#define nextChar(n) scanf("%c", &n)
#define nextString(n) \
scanf("%s", tmp); \
n = tmp
// values
template <class T> T INF() { assert(false); };
template <> int INF<int>() { return 1 << 28; };
template <> ll INF<ll>() { return 1LL << 58; };
template <> double INF<double>() { return 1e16; };
namespace __scc {
typedef vector<vector<int>> Graph;
// O(V+E)
class Scc {
public:
// private:
int N;
Graph g;
vector<int> ord, low, cmp;
vector<bool> vis;
stack<int> st;
vector<bool> S;
int gi;
void dfs(int v, int p, int &k) {
vis[v] = true;
ord[v] = k++;
low[v] = ord[v];
st.push(v);
S[v] = true;
for (int to : g[v]) {
if (!vis[to]) {
dfs(to, v, k);
low[v] = min(low[v], low[to]);
} else if (S[to]) {
low[v] = min(low[v], ord[to]);
}
}
if (low[v] != ord[v])
return;
while (st.top() != v) {
cmp[st.top()] = gi;
S[st.top()] = false;
st.pop();
}
cmp[v] = gi;
S[v] = false;
st.pop();
gi++;
}
public:
Scc(int N) : N(N) {
g = Graph(N);
ord = cmp = low = vector<int>(N, -1);
vis = S = vector<bool>(N);
}
void add_edge(int f, int t) { g[f].push_back(t); }
void scc() {
int k = 0;
gi = 0;
REP(v, N) if (!vis[v]) dfs(v, -1, k);
}
bool same(int i, int j) { return cmp[i] == cmp[j]; }
};
} // namespace __scc
using namespace __scc;
class Main {
public:
void run() {
// include check
int N, E;
nextInt(N);
nextInt(E);
Scc g(N);
REP(i, E) {
int s, t;
nextInt(s);
nextInt(t);
g.add_edge(s, t);
}
g.scc();
// cerr << g.cmp <<endl;
int Q;
nextInt(Q);
REP(q, Q) {
int u, v;
nextInt(u);
nextInt(v);
cout << (g.same(u, v) ? 1 : 0) << endl;
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
}
|
replace
| 240 | 241 | 240 | 241 |
0
|
1 1 0 0 0
|
p02368
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define M_PI 3.14159265358979323846
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define FILL(a, x) memset(a, x, sizeof(a))
// repetition
//------------------------------------------
#define FOR(i, s, n) for (int i = s; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
const int N = 100;
int idx[N];
int lowlink[N];
bool onstack[N];
struct edge {
int to;
edge(int _to) : to(_to){};
};
using node = vector<edge>;
using graph = vector<node>;
void visit(graph &g, int node, VVI &scc, stack<int> &st, vector<bool> &on,
VI &lowlink, VI &id, int &cur) {
lowlink[node] = id[node] = cur++;
st.push(node);
on[node] = true;
for (auto e : g[node]) {
if (id[e.to] == -1) {
visit(g, e.to, scc, st, on, lowlink, id, cur);
lowlink[node] = min(lowlink[node], lowlink[e.to]);
} else if (on[e.to]) {
lowlink[node] = min(lowlink[node], id[e.to]);
}
if (lowlink[node] == id[node]) {
scc.PB(VI());
while (1) {
int t_node = st.top();
st.pop();
on[t_node] = false;
scc.back().push_back(t_node);
if (t_node == node)
break;
}
}
}
}
VVI scc(graph &g) {
int n = g.size();
VI id(n, -1), low(n);
stack<int> st;
vector<bool> on(n);
int cur = 0;
VVI scc;
REP(i, n) if (id[i] == -1) visit(g, i, scc, st, on, low, id, cur);
return scc;
}
void addedge(graph &g, int from, int to) { g[from].PB(edge(to)); }
int main() {
int v, e;
scanf("%d%d", &v, &e);
graph g(v);
REP(i, e) {
int x, y;
scanf("%d%d", &x, &y);
addedge(g, x, y);
}
auto SCC = scc(g);
VI idx(v);
REP(i, SCC.size()) {
for (auto x : SCC[i]) {
idx[x] = i;
}
}
int q;
scanf("%d", &q);
REP(i, q) {
int x, y;
scanf("%d%d", &x, &y);
cout << (idx[x] == idx[y]) << endl;
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
#define M_PI 3.14159265358979323846
using namespace std;
// conversion
//------------------------------------------
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define FILL(a, x) memset(a, x, sizeof(a))
// repetition
//------------------------------------------
#define FOR(i, s, n) for (int i = s; i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
const int N = 100;
int idx[N];
int lowlink[N];
bool onstack[N];
struct edge {
int to;
edge(int _to) : to(_to){};
};
using node = vector<edge>;
using graph = vector<node>;
void visit(graph &g, int node, VVI &scc, stack<int> &st, vector<bool> &on,
VI &lowlink, VI &id, int &cur) {
lowlink[node] = id[node] = cur++;
st.push(node);
on[node] = true;
for (auto e : g[node]) {
if (id[e.to] == -1) {
visit(g, e.to, scc, st, on, lowlink, id, cur);
lowlink[node] = min(lowlink[node], lowlink[e.to]);
} else if (on[e.to]) {
lowlink[node] = min(lowlink[node], id[e.to]);
}
}
if (lowlink[node] == id[node] && !st.empty()) {
scc.PB(VI());
while (1) {
int t_node = st.top();
st.pop();
on[t_node] = false;
scc.back().push_back(t_node);
if (t_node == node)
break;
}
}
}
VVI scc(graph &g) {
int n = g.size();
VI id(n, -1), low(n);
stack<int> st;
vector<bool> on(n);
int cur = 0;
VVI scc;
REP(i, n) if (id[i] == -1) visit(g, i, scc, st, on, low, id, cur);
return scc;
}
void addedge(graph &g, int from, int to) { g[from].PB(edge(to)); }
int main() {
int v, e;
scanf("%d%d", &v, &e);
graph g(v);
REP(i, e) {
int x, y;
scanf("%d%d", &x, &y);
addedge(g, x, y);
}
auto SCC = scc(g);
VI idx(v);
REP(i, SCC.size()) {
for (auto x : SCC[i]) {
idx[x] = i;
}
}
int q;
scanf("%d", &q);
REP(i, q) {
int x, y;
scanf("%d%d", &x, &y);
cout << (idx[x] == idx[y]) << endl;
}
return 0;
}
|
replace
| 101 | 111 | 101 | 111 |
0
| |
p02368
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FF first
#define SS second
template <class S, class T> istream &operator>>(istream &is, pair<S, T> &p) {
return is >> p.FF >> p.SS;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << p.FF << " " << p.SS;
}
template <class T> void maxi(T &x, T y) {
if (x < y)
x = y;
}
template <class T> void mini(T &x, T y) {
if (x > y)
x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9 + 7;
/**
* Simple Graph Definition
*/
struct Edge {
int to, cost;
Edge(int t, int c = 0) : to(t), cost(c) {}
bool operator>(const Edge &rhs) const { return cost > rhs.cost; }
bool operator<(const Edge &rhs) const { return cost < rhs.cost; }
};
using Graph = vector<vector<Edge>>;
// ????????°???????????¨???
void add_edge(Graph &graph, int u, int v, int cost = 0) {
graph[u].push_back(Edge(v, cost));
graph[v].push_back(Edge(u, cost));
}
void SCC(const Graph &g, vector<vector<int>> &scc) {
const int n = g.size();
vector<int> num(n), low(n);
stack<int> S;
vector<bool> inS(n);
int time = 0;
function<void(int)> visit = [&](int v) {
low[v] = num[v] = ++time;
S.push(v);
inS[v] = true;
for (auto &e : g[v]) {
int w = e.to;
if (num[w] == 0) {
visit(w);
low[v] = min(low[v], low[w]);
} else if (inS[w])
low[v] = min(low[v], num[w]);
}
if (low[v] == num[v]) {
scc.push_back(vector<int>());
while (1) {
int w = S.top();
S.pop();
inS[w] = false;
scc.back().push_back(w);
if (v == w)
break;
}
}
};
REP(u, n) if (num[u] == 0) visit(u);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int V, E;
cin >> V >> E;
Graph G(V);
REP(i, E) {
int s, t;
cin >> s >> t;
G[s].EB(t);
}
vector<vector<int>> scc;
SCC(G, scc);
vector<int> gr(SZ(scc));
REP(i, SZ(scc))
for (int u : scc[i])
gr[u] = i;
int Q;
cin >> Q;
while (Q--) {
int u, v;
cin >> u >> v;
cout << (gr[u] == gr[v]) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define EB emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#define SORT(c) sort(ALL((c)))
#define RSORT(c) sort(RALL((c)))
#define UNIQ(c) (c).erase(unique(ALL((c))), end((c)))
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FF first
#define SS second
template <class S, class T> istream &operator>>(istream &is, pair<S, T> &p) {
return is >> p.FF >> p.SS;
}
template <class S, class T>
ostream &operator<<(ostream &os, const pair<S, T> &p) {
return os << p.FF << " " << p.SS;
}
template <class T> void maxi(T &x, T y) {
if (x < y)
x = y;
}
template <class T> void mini(T &x, T y) {
if (x > y)
x = y;
}
const double EPS = 1e-10;
const double PI = acos(-1.0);
const LL MOD = 1e9 + 7;
/**
* Simple Graph Definition
*/
struct Edge {
int to, cost;
Edge(int t, int c = 0) : to(t), cost(c) {}
bool operator>(const Edge &rhs) const { return cost > rhs.cost; }
bool operator<(const Edge &rhs) const { return cost < rhs.cost; }
};
using Graph = vector<vector<Edge>>;
// ????????°???????????¨???
void add_edge(Graph &graph, int u, int v, int cost = 0) {
graph[u].push_back(Edge(v, cost));
graph[v].push_back(Edge(u, cost));
}
void SCC(const Graph &g, vector<vector<int>> &scc) {
const int n = g.size();
vector<int> num(n), low(n);
stack<int> S;
vector<bool> inS(n);
int time = 0;
function<void(int)> visit = [&](int v) {
low[v] = num[v] = ++time;
S.push(v);
inS[v] = true;
for (auto &e : g[v]) {
int w = e.to;
if (num[w] == 0) {
visit(w);
low[v] = min(low[v], low[w]);
} else if (inS[w])
low[v] = min(low[v], num[w]);
}
if (low[v] == num[v]) {
scc.push_back(vector<int>());
while (1) {
int w = S.top();
S.pop();
inS[w] = false;
scc.back().push_back(w);
if (v == w)
break;
}
}
};
REP(u, n) if (num[u] == 0) visit(u);
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int V, E;
cin >> V >> E;
Graph G(V);
REP(i, E) {
int s, t;
cin >> s >> t;
G[s].EB(t);
}
vector<vector<int>> scc;
SCC(G, scc);
vector<int> gr(V);
REP(i, SZ(scc))
for (int u : scc[i])
gr[u] = i;
int Q;
cin >> Q;
while (Q--) {
int u, v;
cin >> u >> v;
cout << (gr[u] == gr[v]) << endl;
}
return 0;
}
|
replace
| 113 | 114 | 113 | 114 |
0
| |
p02368
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
// typedef tuple<int, int, int> T;
#define FOR(i, s, x) for (int i = s; i < (int)(x); i++)
#define REP(i, x) FOR(i, 0, x)
#define ALL(c) c.begin(), c.end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
struct StronglyConnectedComponents {
int V;
vector<vector<int>> G, rG;
vector<int> vs, cmp, stk;
vector<bool> used, added;
StronglyConnectedComponents(int V) : V(V) {
used.assign(V, false), added.assign(V, false);
G.resize(V), rG.resize(V);
stk.resize(2 * V), cmp.resize(V);
}
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int s) {
int sp = 0;
stk[sp++] = s;
while (sp) {
int v = stk[sp - 1];
used[v] = true;
bool pushed = false;
for (int c : G[v])
if (not used[c])
stk[sp++] = c, pushed = true;
if (not pushed) {
if (not added[v])
added[v] = true, vs.push_back(v);
sp--;
}
}
}
void rdfs(int s, int k) {
int sp = 0;
stk[sp++] = s;
while (sp) {
int v = stk[sp - 1];
sp--;
used[v] = true;
cmp[v] = k;
for (int c : rG[v])
if (not used[c])
stk[sp++] = c;
}
}
int run() {
fill(used.begin(), used.end(), false);
fill(added.begin(), added.end(), false);
vs.clear();
for (int v = 0; v < V; v++)
if (!used[v])
dfs(v);
fill(used.begin(), used.end(), false);
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--)
if (not used[vs[i]])
rdfs(vs[i], k++);
return k;
}
};
int main() {
int V, E;
scanf("%d %d", &V, &E);
StronglyConnectedComponents scc(V);
REP(_, E) {
int f, t;
scanf("%d %d", &f, &t);
scc.add_edge(f, t);
}
scc.run();
int Q;
scanf("%d", &Q);
REP(_, Q) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", (scc.cmp[x] == scc.cmp[y]));
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> Vi;
// typedef tuple<int, int, int> T;
#define FOR(i, s, x) for (int i = s; i < (int)(x); i++)
#define REP(i, x) FOR(i, 0, x)
#define ALL(c) c.begin(), c.end()
#define DUMP(x) cerr << #x << " = " << (x) << endl
const int dr[4] = {-1, 0, 1, 0};
const int dc[4] = {0, 1, 0, -1};
struct StronglyConnectedComponents {
int V;
vector<vector<int>> G, rG;
vector<int> vs, cmp, stk;
vector<bool> used, added;
StronglyConnectedComponents(int V) : V(V) {
used.assign(V, false), added.assign(V, false);
G.resize(V), rG.resize(V);
stk.resize(4 * V), cmp.resize(V);
}
void add_edge(int from, int to) {
G[from].push_back(to);
rG[to].push_back(from);
}
void dfs(int s) {
int sp = 0;
stk[sp++] = s;
while (sp) {
int v = stk[sp - 1];
used[v] = true;
bool pushed = false;
for (int c : G[v])
if (not used[c])
stk[sp++] = c, pushed = true;
if (not pushed) {
if (not added[v])
added[v] = true, vs.push_back(v);
sp--;
}
}
}
void rdfs(int s, int k) {
int sp = 0;
stk[sp++] = s;
while (sp) {
int v = stk[sp - 1];
sp--;
used[v] = true;
cmp[v] = k;
for (int c : rG[v])
if (not used[c])
stk[sp++] = c;
}
}
int run() {
fill(used.begin(), used.end(), false);
fill(added.begin(), added.end(), false);
vs.clear();
for (int v = 0; v < V; v++)
if (!used[v])
dfs(v);
fill(used.begin(), used.end(), false);
int k = 0;
for (int i = vs.size() - 1; i >= 0; i--)
if (not used[vs[i]])
rdfs(vs[i], k++);
return k;
}
};
int main() {
int V, E;
scanf("%d %d", &V, &E);
StronglyConnectedComponents scc(V);
REP(_, E) {
int f, t;
scanf("%d %d", &f, &t);
scc.add_edge(f, t);
}
scc.run();
int Q;
scanf("%d", &Q);
REP(_, Q) {
int x, y;
scanf("%d %d", &x, &y);
printf("%d\n", (scc.cmp[x] == scc.cmp[y]));
}
return 0;
}
|
replace
| 25 | 26 | 25 | 26 |
0
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[101];
bitset<101> mark;
bool Cyc;
void dfs(int x) {
if (mark[x])
Cyc = 1;
if (Cyc)
return;
mark[x] = 1;
for (int i = 0; i < adj[x].size(); i++)
dfs(adj[x][i]);
mark[x] = 0;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 0; i < min(50, n); i++)
dfs(i);
if (Cyc)
cout << 1 << endl;
else
cout << 0 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m;
vector<int> adj[101];
bitset<101> mark;
bool Cyc;
void dfs(int x) {
if (mark[x])
Cyc = 1;
if (Cyc)
return;
mark[x] = 1;
for (int i = 0; i < adj[x].size(); i++)
dfs(adj[x][i]);
mark[x] = 0;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
adj[x].push_back(y);
}
for (int i = 0; i < n; i += 5)
dfs(i);
if (Cyc)
cout << 1 << endl;
else
cout << 0 << endl;
}
|
replace
| 27 | 28 | 27 | 28 |
TLE
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct vertex {
vector<int> E; // cost,to
};
#define MAX_V 100
#define MAX_E 1000
bool isVisited[MAX_V];
bool isChecked[MAX_V];
vertex V[MAX_V];
bool rec(int i) {
isVisited[i] = true;
isChecked[i] = true;
for (auto &e : V[i].E) {
if (isVisited[e]) {
return true;
} else {
if (rec(e)) {
return true;
}
}
}
isVisited[i] = false;
return false;
}
int main() {
int nv, ne;
cin >> nv >> ne;
for (int i = 0; i < ne; i++) {
int s, t;
cin >> s >> t;
V[s].E.emplace_back(t);
}
fill(isVisited, isVisited + MAX_V, false);
fill(isChecked, isChecked + MAX_V, false);
for (int i = 0; i < nv; i++) {
if (isChecked[i])
continue;
if (rec(i)) {
cout << 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct vertex {
vector<int> E; // cost,to
};
#define MAX_V 100
#define MAX_E 1000
bool isVisited[MAX_V];
bool isChecked[MAX_V];
vertex V[MAX_V];
bool rec(int i) {
isVisited[i] = true;
isChecked[i] = true;
for (auto &e : V[i].E) {
if (isVisited[e]) {
return true;
} else if (!isChecked[e]) {
if (rec(e)) {
return true;
}
}
}
isVisited[i] = false;
return false;
}
int main() {
int nv, ne;
cin >> nv >> ne;
for (int i = 0; i < ne; i++) {
int s, t;
cin >> s >> t;
V[s].E.emplace_back(t);
}
fill(isVisited, isVisited + MAX_V, false);
fill(isChecked, isChecked + MAX_V, false);
for (int i = 0; i < nv; i++) {
if (isChecked[i])
continue;
if (rec(i)) {
cout << 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
|
replace
| 21 | 22 | 21 | 22 |
TLE
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <bitset>
#include <stdio.h>
#include <vector>
using namespace std;
#define PB push_back
const int N = 1e2 + 10;
bitset<N> went, in;
vector<int> graph[N];
bool f = true;
void dfs(int now) {
if (in[now]) {
f = false;
return;
}
in[now] = true;
went[now] = true;
for (int i = 0; i < graph[now].size(); i++)
dfs(graph[now][i]);
in[now] = false;
return;
}
int main() {
int n, m, l, r;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &l, &r);
graph[l].PB(r);
}
in.reset();
went.reset();
for (int i = 0; i < n; i++)
if (!went[i])
dfs(i);
if (f)
printf("0\n");
else
printf("1\n");
}
|
#include <bitset>
#include <stdio.h>
#include <vector>
using namespace std;
#define PB push_back
const int N = 1e2 + 10;
bitset<N> went, in;
vector<int> graph[N];
bool f = true;
void dfs(int now) {
if (in[now]) {
f = false;
return;
} else if (went[now])
return;
in[now] = true;
went[now] = true;
for (int i = 0; i < graph[now].size(); i++)
dfs(graph[now][i]);
in[now] = false;
return;
}
int main() {
int n, m, l, r;
scanf("%d%d", &n, &m);
while (m--) {
scanf("%d%d", &l, &r);
graph[l].PB(r);
}
in.reset();
went.reset();
for (int i = 0; i < n; i++)
if (!went[i])
dfs(i);
if (f)
printf("0\n");
else
printf("1\n");
}
|
replace
| 13 | 14 | 13 | 15 |
TLE
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<int> edges[1000];
bool used[100];
bool active[100];
bool dfs(int cur) {
active[cur] = true;
used[cur] = true;
for (int i = 0; i < edges[cur].size(); i++) {
if (active[edges[cur][i]]) {
return true;
}
if (dfs(edges[cur][i])) {
return true;
}
}
active[cur] = false;
return false;
}
int main() {
int N;
int M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int s;
int t;
cin >> s >> t;
edges[s].push_back(t);
}
for (int i = 0; i < N; i++) {
if (used[i]) {
continue;
}
if (dfs(i)) {
cout << 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
vector<int> edges[1000];
bool used[100];
bool active[100];
bool dfs(int cur) {
active[cur] = true;
used[cur] = true;
for (int i = 0; i < edges[cur].size(); i++) {
if (active[edges[cur][i]]) {
return true;
}
if (used[edges[cur][i]]) {
continue;
}
if (dfs(edges[cur][i])) {
return true;
}
}
active[cur] = false;
return false;
}
int main() {
int N;
int M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int s;
int t;
cin >> s >> t;
edges[s].push_back(t);
}
for (int i = 0; i < N; i++) {
if (used[i]) {
continue;
}
if (dfs(i)) {
cout << 1 << endl;
return 0;
}
}
cout << 0 << endl;
return 0;
}
|
insert
| 22 | 22 | 22 | 25 |
TLE
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MAX_V 100
using namespace std;
typedef long long ll;
vector<int> G[MAX_V];
bool cycle_exists = false;
bool activated[MAX_V];
bool checked[MAX_V];
void dfs(int i) {
if (activated[i]) {
cycle_exists = true;
} else {
activated[i] = true;
for (int j = 0; j < G[i].size(); ++j) {
dfs(G[i][j]);
}
activated[i] = false;
}
checked[i] = true;
}
int main() {
fill(activated, activated + MAX_V, false);
fill(checked, checked + MAX_V, false);
int V, E;
cin >> V >> E;
for (int i = 0; i < E; ++i) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
}
for (int i = 0; i < V; ++i)
if (!checked[i])
dfs(i);
if (cycle_exists)
cout << 1;
else
cout << 0;
cout << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
#define MAX_V 100
using namespace std;
typedef long long ll;
vector<int> G[MAX_V];
bool cycle_exists = false;
bool activated[MAX_V];
bool checked[MAX_V];
void dfs(int i) {
if (activated[i]) {
cycle_exists = true;
} else {
activated[i] = true;
for (int j = 0; j < G[i].size(); ++j)
if (!checked[G[i][j]])
dfs(G[i][j]);
activated[i] = false;
}
checked[i] = true;
}
int main() {
fill(activated, activated + MAX_V, false);
fill(checked, checked + MAX_V, false);
int V, E;
cin >> V >> E;
for (int i = 0; i < E; ++i) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
}
for (int i = 0; i < V; ++i)
if (!checked[i])
dfs(i);
if (cycle_exists)
cout << 1;
else
cout << 0;
cout << endl;
return 0;
}
|
replace
| 31 | 34 | 31 | 34 |
TLE
| |
p02369
|
C++
|
Memory Limit Exceeded
|
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
vector<int> X[10000];
int N, M, A, B;
bool ok = false;
queue<char> Q;
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A >> B;
if (A > B) {
ok = true;
}
X[A].push_back(B);
}
if (ok == false) {
cout << "0" << endl;
return 0;
}
for (int i = 0; i < N; i++) {
Q.push(i);
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 7000000) {
cout << "1" << endl;
return 0;
}
int a1 = Q.front();
Q.pop();
for (int j = 0; j < X[a1].size(); j++) {
Q.push(X[a1][j]);
}
}
}
cout << "0" << endl;
return 0;
}
|
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
vector<int> X[10000];
int N, M, A, B;
bool ok = false;
queue<char> Q;
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
cin >> A >> B;
if (A > B) {
ok = true;
}
X[A].push_back(B);
}
if (ok == false) {
cout << "0" << endl;
return 0;
}
for (int i = 0; i < N; i++) {
Q.push(i);
int cnt = 0;
while (!Q.empty()) {
cnt++;
if (cnt >= 1000000) {
cout << "1" << endl;
return 0;
}
int a1 = Q.front();
Q.pop();
for (int j = 0; j < X[a1].size(); j++) {
Q.push(X[a1][j]);
}
}
}
cout << "0" << endl;
return 0;
}
|
replace
| 26 | 27 | 26 | 27 |
MLE
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int V, E;
bool dfs(vector<vector<int>> &G, int u, vector<int> &color) {
color[u] = 1;
for (auto v : G[u]) {
if (color[v] == 1)
return true;
if (dfs(G, v, color))
return true;
}
color[u] = 2;
return false;
}
int main() {
cin >> V >> E;
vector<vector<int>> G(V);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
}
bool has_cycle = false;
vector<bool> done(V);
for (int i = 0; i < V; i++)
if (!done[i]) {
vector<int> color(V, 0);
has_cycle |= dfs(G, i, color);
for (int i = 0; i < V; i++)
if (color[i] == 2)
done[i] = true;
}
cout << has_cycle << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int V, E;
bool dfs(vector<vector<int>> &G, int u, vector<int> &color) {
color[u] = 1;
for (auto v : G[u]) {
if (color[v] == 1)
return true;
if (color[v] == 2)
continue;
if (dfs(G, v, color))
return true;
}
color[u] = 2;
return false;
}
int main() {
cin >> V >> E;
vector<vector<int>> G(V);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
G[s].push_back(t);
}
bool has_cycle = false;
vector<bool> done(V);
for (int i = 0; i < V; i++)
if (!done[i]) {
vector<int> color(V, 0);
has_cycle |= dfs(G, i, color);
for (int i = 0; i < V; i++)
if (color[i] == 2)
done[i] = true;
}
cout << has_cycle << endl;
return 0;
}
|
insert
| 10 | 10 | 10 | 12 |
TLE
| |
p02369
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> G[100];
bool used[100];
bool dfs(int p, int s) {
used[p] = true;
bool ret = false;
for (int i = 0; i < G[p].size(); i++) {
int to = G[p][i];
if (to == s)
return true;
ret |= dfs(to, s);
}
return ret;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
bool f = false;
for (int i = 0; i < N; i++) {
fill_n(used, N, false);
f |= dfs(i, i);
}
cout << f << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, M;
vector<int> G[100];
bool used[100];
bool dfs(int p, int s) {
used[p] = true;
bool ret = false;
for (int i = 0; i < G[p].size(); i++) {
int to = G[p][i];
if (to == s)
return true;
if (used[to])
continue;
ret |= dfs(to, s);
}
return ret;
}
int main() {
cin >> N >> M;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
G[a].push_back(b);
}
bool f = false;
for (int i = 0; i < N; i++) {
fill_n(used, N, false);
f |= dfs(i, i);
}
cout << f << endl;
return 0;
}
|
insert
| 13 | 13 | 13 | 15 |
0
| |
p02369
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
const int VISITED = 1, CURRENTLY_VISITED = 2;
int V, E;
bool findCycle(int node);
vector<vector<int>> adjacentList;
vector<int> states;
bool hasCycle() {
vector<int> states(V, 0);
for (int i = 0; i < V; i++) {
if (states[i] != VISITED && findCycle(i)) {
return true;
}
}
return false;
}
bool findCycle(int node) {
if (states[node] == CURRENTLY_VISITED)
return true;
states[node] = CURRENTLY_VISITED;
for (int nn : adjacentList[node]) {
if (states[node] != VISITED && findCycle(nn))
return true;
}
states[node] = VISITED;
return false;
}
int main() {
cin >> V >> E;
adjacentList = vector<vector<int>>(V);
states = vector<int>(V, 0);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
adjacentList[s].push_back(t);
}
cout << (hasCycle() ? 1 : 0) << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
#define REP(i, N) for (int i = 0; i < (int)N; i++)
const int VISITED = 1, CURRENTLY_VISITED = 2;
int V, E;
bool findCycle(int node);
vector<vector<int>> adjacentList;
vector<int> states;
bool hasCycle() {
vector<int> states(V, 0);
for (int i = 0; i < V; i++) {
if (states[i] != VISITED && findCycle(i)) {
return true;
}
}
return false;
}
bool findCycle(int node) {
if (states[node] == CURRENTLY_VISITED)
return true;
states[node] = CURRENTLY_VISITED;
for (int nn : adjacentList[node]) {
if (states[nn] != VISITED && findCycle(nn))
return true;
}
states[node] = VISITED;
return false;
}
int main() {
cin >> V >> E;
adjacentList = vector<vector<int>>(V);
states = vector<int>(V, 0);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
adjacentList[s].push_back(t);
}
cout << (hasCycle() ? 1 : 0) << endl;
return 0;
}
|
replace
| 50 | 51 | 50 | 51 |
TLE
| |
p02370
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
vector<int> edge[110];
int h[110];
int V;
int E;
int main() {
cin >> V;
cin >> E;
for (int i = 0; i < E; i++) {
int s;
int t;
cin >> s >> t;
edge[s].push_back(t);
h[t]++;
}
stack<int> st;
for (int i = 0; i < V; i++) {
if (h[i] == 0)
st.push(i);
}
vector<int> topolo;
while (!st.empty()) {
int v = st.top();
st.pop();
topolo.push_back(v);
for (int to : edge[v]) {
h[to]--;
if (h[to] == 0) {
st.push(to);
}
}
}
for (int ans : topolo) {
cout << ans << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
vector<int> edge[10010];
int h[10010];
int V;
int E;
int main() {
cin >> V;
cin >> E;
for (int i = 0; i < E; i++) {
int s;
int t;
cin >> s >> t;
edge[s].push_back(t);
h[t]++;
}
stack<int> st;
for (int i = 0; i < V; i++) {
if (h[i] == 0)
st.push(i);
}
vector<int> topolo;
while (!st.empty()) {
int v = st.top();
st.pop();
topolo.push_back(v);
for (int to : edge[v]) {
h[to]--;
if (h[to] == 0) {
st.push(to);
}
}
}
for (int ans : topolo) {
cout << ans << endl;
}
return 0;
}
|
replace
| 10 | 12 | 10 | 12 |
0
| |
p02370
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 100000;
static const int INFTY = (1 << 29);
vector<int> G[MAX];
list<int> out;
bool V[MAX];
int N;
int indeg[MAX];
void bfs(int s) {
queue<int> q;
q.push(s);
V[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
out.push_back(u);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !V[v]) {
V[v] = true;
q.push(v);
}
}
}
}
void tsort() {
for (int i = 0; i < N; i++)
indeg[i] = 0;
for (int u = 0; u < N; u++)
for (int i = 0; i < N; i++) {
int v = G[u][i];
indeg[v]++;
}
for (int u = 0; u < N; u++)
if (indeg[u] == 0 && !V[u])
bfs(u);
for (list<int>::iterator it = out.begin(); it != out.end(); it++)
cout << *it << endl;
}
int main() {
int s, t, M;
cin >> N >> M;
for (int i = 0; i < N; i++)
V[i] = false;
for (int i = 0; i < M; i++) {
cin >> s >> t;
G[s].push_back(t);
}
tsort();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <list>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 100000;
static const int INFTY = (1 << 29);
vector<int> G[MAX];
list<int> out;
bool V[MAX];
int N;
int indeg[MAX];
void bfs(int s) {
queue<int> q;
q.push(s);
V[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
out.push_back(u);
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !V[v]) {
V[v] = true;
q.push(v);
}
}
}
}
void tsort() {
for (int i = 0; i < N; i++)
indeg[i] = 0;
for (int u = 0; u < N; u++)
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i];
indeg[v]++;
}
for (int u = 0; u < N; u++)
if (indeg[u] == 0 && !V[u])
bfs(u);
for (list<int>::iterator it = out.begin(); it != out.end(); it++)
cout << *it << endl;
}
int main() {
int s, t, M;
cin >> N >> M;
for (int i = 0; i < N; i++)
V[i] = false;
for (int i = 0; i < M; i++) {
cin >> s >> t;
G[s].push_back(t);
}
tsort();
return 0;
}
|
replace
| 39 | 40 | 39 | 40 |
-11
| |
p02370
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <string>
#include <vector>
using namespace std;
const int INF = 1 << 30;
const int NIL = -1;
const int MAXV = 10005;
const int MAXE = 100005;
struct Edge {
int to, next;
} edge[MAXE];
list<int> ans;
int head[MAXE];
int indegree[MAXV];
bool vis[MAXV];
int cnt;
void bfs(int u) {
queue<int> q;
vis[u] = true;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
ans.push_back(u);
for (int i = head[u]; i != NIL; i = edge[i].next) {
u = edge[i].to;
if (!vis[u] && --indegree[u] == 0) {
vis[u] = true;
q.push(u);
}
}
}
}
void topologicalSort(int n) {
for (int i = 0; i < n; ++i)
vis[i] = false;
for (int i = 0; i < n; ++i) {
if (indegree[i] == 0 && !vis[i])
bfs(i);
}
}
void add(int u, int v) {
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int main(void) {
int V, E, s, t;
scanf("%d%d", &V, &E);
cnt = 0;
memset(head, NIL, sizeof(int) * (E + 1));
for (int i = 0; i < E; ++i) {
scanf("%d%d", &s, &t);
++indegree[t];
add(s, t);
}
topologicalSort(V);
for (list<int>::iterator it = ans.begin(); it != ans.end(); ++it)
printf("%d\n", *it);
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <string>
#include <vector>
using namespace std;
const int INF = 1 << 30;
const int NIL = -1;
const int MAXV = 10005;
const int MAXE = 100005;
struct Edge {
int to, next;
Edge() { next = -1; }
} edge[MAXE];
list<int> ans;
int head[MAXE];
int indegree[MAXV];
bool vis[MAXV];
int cnt;
void bfs(int u) {
queue<int> q;
vis[u] = true;
q.push(u);
while (!q.empty()) {
u = q.front();
q.pop();
ans.push_back(u);
for (int i = head[u]; i != NIL; i = edge[i].next) {
u = edge[i].to;
if (!vis[u] && --indegree[u] == 0) {
vis[u] = true;
q.push(u);
}
}
}
}
void topologicalSort(int n) {
for (int i = 0; i < n; ++i)
vis[i] = false;
for (int i = 0; i < n; ++i) {
if (indegree[i] == 0 && !vis[i])
bfs(i);
}
}
void add(int u, int v) {
edge[cnt].to = v;
edge[cnt].next = head[u];
head[u] = cnt++;
}
int main(void) {
int V, E, s, t;
scanf("%d%d", &V, &E);
cnt = 0;
memset(head, NIL, sizeof(int) * (E + 1));
for (int i = 0; i < E; ++i) {
scanf("%d%d", &s, &t);
++indegree[t];
add(s, t);
}
topologicalSort(V);
for (list<int>::iterator it = ans.begin(); it != ans.end(); ++it)
printf("%d\n", *it);
return 0;
}
|
insert
| 17 | 17 | 17 | 18 |
TLE
| |
p02370
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
vector<int> E[100];
int in[100];
bool used[100];
int main() {
int v, e;
scanf("%d%d", &v, &e);
rep(i, e) {
int s, t;
scanf("%d%d", &s, &t);
E[s].push_back(t);
in[t]++;
}
list<int> ls;
queue<int> que;
rep(i, v) {
if (!used[i] && !in[i])
que.push(i);
while (!que.empty()) {
int p = que.front();
que.pop();
used[p] = true;
ls.push_back(p);
for (int u : E[p]) {
in[u]--;
if (!used[u] && !in[u])
que.push(u);
}
}
}
for (int i : ls) {
printf("%d\n", i);
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
vector<int> E[10000];
int in[10000];
bool used[10000];
int main() {
int v, e;
scanf("%d%d", &v, &e);
rep(i, e) {
int s, t;
scanf("%d%d", &s, &t);
E[s].push_back(t);
in[t]++;
}
list<int> ls;
queue<int> que;
rep(i, v) {
if (!used[i] && !in[i])
que.push(i);
while (!que.empty()) {
int p = que.front();
que.pop();
used[p] = true;
ls.push_back(p);
for (int u : E[p]) {
in[u]--;
if (!used[u] && !in[u])
que.push(u);
}
}
}
for (int i : ls) {
printf("%d\n", i);
}
}
|
replace
| 4 | 7 | 4 | 7 |
0
| |
p02370
|
C++
|
Runtime Error
|
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
static const long long FAR = (1LL << 29);
static const int N = 100;
int n, m;
bool visited[N];
int p[N];
vector<int> G[N];
vector<int> sorted;
void bs(int i) {
queue<int> q;
q.push(i);
visited[i] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
visited[u] = true;
sorted.push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
p[v]--;
if (p[v] == 0 && !visited[v]) {
q.push(v);
visited[v] = true;
}
}
}
}
void ts() {
for (int i = 0; i < n; ++i) {
visited[i] = false;
p[i] = 0;
}
for (int u = 0; u < n; ++u) {
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
p[v]++;
}
}
for (int i = 0; i < n; ++i) {
if (p[i] == 0 && !visited[i])
bs(i);
}
for (int i = 0; i < sorted.size(); ++i)
cout << sorted[i] << endl;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
ts();
return 0;
}
|
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
static const long long FAR = (1LL << 29);
static const int N = 100000;
int n, m;
bool visited[N];
int p[N];
vector<int> G[N];
vector<int> sorted;
void bs(int i) {
queue<int> q;
q.push(i);
visited[i] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
visited[u] = true;
sorted.push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
p[v]--;
if (p[v] == 0 && !visited[v]) {
q.push(v);
visited[v] = true;
}
}
}
}
void ts() {
for (int i = 0; i < n; ++i) {
visited[i] = false;
p[i] = 0;
}
for (int u = 0; u < n; ++u) {
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
p[v]++;
}
}
for (int i = 0; i < n; ++i) {
if (p[i] == 0 && !visited[i])
bs(i);
}
for (int i = 0; i < sorted.size(); ++i)
cout << sorted[i] << endl;
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
ts();
return 0;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p02370
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N 100
static const long long FAR = (1L << 31);
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
vector<int> G[N];
vector<int> out;
bool Visited[N];
int n, m;
int indeg[N];
void bfs(int s) {
queue<int> q;
q.push(s);
Visited[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
out.push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !Visited[v]) {
Visited[v] = true;
q.push(v);
}
}
}
}
void tsort() {
for (int i = 0; i < n; ++i)
indeg[i] = 0;
for (int u = 0; u < n; ++u) {
for (int j = 0; j < G[u].size(); ++j) {
int v = G[u][j];
indeg[v]++;
}
}
for (int u = 0; u < n; ++u)
if (indeg[u] == 0 && !Visited[u])
bfs(u);
for (int i = 0; i < out.size(); ++i)
cout << out[i] << endl;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i)
Visited[i] = false;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
tsort();
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define N 100000
static const long long FAR = (1L << 31);
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
vector<int> G[N];
vector<int> out;
bool Visited[N];
int n, m;
int indeg[N];
void bfs(int s) {
queue<int> q;
q.push(s);
Visited[s] = true;
while (!q.empty()) {
int u = q.front();
q.pop();
out.push_back(u);
for (int i = 0; i < G[u].size(); ++i) {
int v = G[u][i];
indeg[v]--;
if (indeg[v] == 0 && !Visited[v]) {
Visited[v] = true;
q.push(v);
}
}
}
}
void tsort() {
for (int i = 0; i < n; ++i)
indeg[i] = 0;
for (int u = 0; u < n; ++u) {
for (int j = 0; j < G[u].size(); ++j) {
int v = G[u][j];
indeg[v]++;
}
}
for (int u = 0; u < n; ++u)
if (indeg[u] == 0 && !Visited[u])
bfs(u);
for (int i = 0; i < out.size(); ++i)
cout << out[i] << endl;
}
int main() {
cin >> n >> m;
for (int i = 0; i < n; ++i)
Visited[i] = false;
for (int i = 0; i < m; ++i) {
int u, v;
cin >> u >> v;
G[u].push_back(v);
}
tsort();
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02370
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
#define N 1000000
using namespace std;
queue<int> S; // ??\???????????????????????¨???????????????
vector<int> in[N]; // ??\??????
vector<int> out[N]; // ?????????
vector<int> G[N]; // ??\?????????????????????????????\???
void init(int V) { // ?????°??????????????°
for (int i = 0; i < V; i++)
in[i].clear();
for (int i = 0; i < V; i++) {
out[i] = G[i];
for (int j = 0; j < G[i].size(); j++)
in[G[i][j]].push_back(i);
}
for (int i = 0; i < V; i++)
if (!in[i].size())
S.push(i);
}
vector<int> Topological_Sort(int V) {
vector<int> res;
while (!S.empty()) {
int pos = S.front();
S.pop();
res.push_back(pos);
for (int i = 0; i < out[pos].size(); i++) {
int nx = out[pos][i];
if (in[nx].size() == 1)
S.push(nx);
for (int j = 0; j < in[nx].size(); j++)
if (pos == in[nx][j]) {
in[nx].erase(in[nx].begin() + j);
break;
}
out[pos].erase(out[pos].begin() + i);
i--;
}
}
for (int i = 0; i < V; i++)
if (in[i].size() || out[i].size())
res.clear();
return res;
}
int main() {
int v, e, s, t;
cin >> v >> e;
for (int i = 0; i < e; i++) {
cin >> s >> t;
G[s].push_back(t);
}
init(v);
vector<int> ans = Topological_Sort(v);
for (int i = 0; i < ans.size(); i++)
cout << ans[i] << endl;
return 0;
}
|
#include <bits/stdc++.h>
#define N 10005
using namespace std;
queue<int> S; // ??\???????????????????????¨???????????????
vector<int> in[N]; // ??\??????
vector<int> out[N]; // ?????????
vector<int> G[N]; // ??\?????????????????????????????\???
void init(int V) { // ?????°??????????????°
for (int i = 0; i < V; i++)
in[i].clear();
for (int i = 0; i < V; i++) {
out[i] = G[i];
for (int j = 0; j < G[i].size(); j++)
in[G[i][j]].push_back(i);
}
for (int i = 0; i < V; i++)
if (!in[i].size())
S.push(i);
}
vector<int> Topological_Sort(int V) {
vector<int> res;
while (!S.empty()) {
int pos = S.front();
S.pop();
res.push_back(pos);
for (int i = 0; i < out[pos].size(); i++) {
int nx = out[pos][i];
if (in[nx].size() == 1)
S.push(nx);
for (int j = 0; j < in[nx].size(); j++)
if (pos == in[nx][j]) {
in[nx].erase(in[nx].begin() + j);
break;
}
out[pos].erase(out[pos].begin() + i);
i--;
}
}
for (int i = 0; i < V; i++)
if (in[i].size() || out[i].size())
res.clear();
return res;
}
int main() {
int v, e, s, t;
cin >> v >> e;
for (int i = 0; i < e; i++) {
cin >> s >> t;
G[s].push_back(t);
}
init(v);
vector<int> ans = Topological_Sort(v);
for (int i = 0; i < ans.size(); i++)
cout << ans[i] << endl;
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
MLE
| |
p02370
|
C++
|
Runtime Error
|
#include <stdio.h>
#include <vector>
using namespace std;
const int V_MAX = 1000;
int main() {
int v, e;
int table[V_MAX] = {0};
vector<int> edge[V_MAX];
vector<int> ans;
scanf("%d %d", &v, &e);
for (int i = 0; i < e; i++) {
int s, t;
scanf("%d %d", &s, &t);
edge[s].push_back(t);
table[t]++;
}
for (int i = 0; i < v; i++) {
if (table[i] == 0) {
ans.push_back(i);
}
}
for (int i = 0; i < ans.size(); i++) {
vector<int> e = edge[ans[i]];
for (int j = 0; j < e.size(); j++) {
if (--(table[e[j]]) == 0) {
ans.push_back(e[j]);
}
}
}
for (vector<int>::iterator it = ans.begin(); it != ans.end(); it++) {
printf("%d\n", *it);
}
return 0;
}
|
#include <stdio.h>
#include <vector>
using namespace std;
const int V_MAX = 10000;
int main() {
int v, e;
int table[V_MAX] = {0};
vector<int> edge[V_MAX];
vector<int> ans;
scanf("%d %d", &v, &e);
for (int i = 0; i < e; i++) {
int s, t;
scanf("%d %d", &s, &t);
edge[s].push_back(t);
table[t]++;
}
for (int i = 0; i < v; i++) {
if (table[i] == 0) {
ans.push_back(i);
}
}
for (int i = 0; i < ans.size(); i++) {
vector<int> e = edge[ans[i]];
for (int j = 0; j < e.size(); j++) {
if (--(table[e[j]]) == 0) {
ans.push_back(e[j]);
}
}
}
for (vector<int>::iterator it = ans.begin(); it != ans.end(); it++) {
printf("%d\n", *it);
}
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02370
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1010;
typedef vector<int> vec;
typedef vector<vec> Graph;
Graph G(MAXN);
vec d(MAXN);
int main() {
int n, e;
scanf("%d%d", &n, &e);
for (int i = 0; i < e; i++) {
int s, t;
scanf("%d%d", &s, &t);
G[s].push_back(t);
d[t]++;
}
queue<int> que;
for (int i = 0; i < n; i++)
if (d[i] == 0)
que.push(i);
while (!que.empty()) {
int t = que.front();
que.pop();
printf("%d\n", t);
d[t] = INT_MAX;
for (int i = 0; i < G[t].size(); i++) {
d[G[t][i]]--;
if (d[G[t][i]] == 0)
que.push(G[t][i]);
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 10010;
typedef vector<int> vec;
typedef vector<vec> Graph;
Graph G(MAXN);
vec d(MAXN);
int main() {
int n, e;
scanf("%d%d", &n, &e);
for (int i = 0; i < e; i++) {
int s, t;
scanf("%d%d", &s, &t);
G[s].push_back(t);
d[t]++;
}
queue<int> que;
for (int i = 0; i < n; i++)
if (d[i] == 0)
que.push(i);
while (!que.empty()) {
int t = que.front();
que.pop();
printf("%d\n", t);
d[t] = INT_MAX;
for (int i = 0; i < G[t].size(); i++) {
d[G[t][i]]--;
if (d[G[t][i]] == 0)
que.push(G[t][i]);
}
}
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02370
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <list>
#include <vector>
#define N 10000
using namespace std;
list<int> l;
bool color[N] = {false};
vector<int> adj[N];
int n;
void topo(int k) {
for (int i = 0; i < adj[k].size(); i++)
topo(adj[k][i]);
if (!color[k])
l.push_front(k);
color[k] = true;
}
int main(void) {
int u, v;
int e;
cin >> n >> e;
for (int i = 0; i < e; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
for (int i = 0; i < n; i++) {
if (!color[i])
topo(i);
}
for (list<int>::iterator it = l.begin(); it != l.end(); it++)
cout << *it << endl;
return 0;
}
|
#include <iostream>
#include <list>
#include <vector>
#define N 10000
using namespace std;
list<int> l;
bool color[N] = {false};
vector<int> adj[N];
int n;
void topo(int k) {
for (int i = 0; i < adj[k].size(); i++) {
if (!color[adj[k][i]])
topo(adj[k][i]);
}
if (!color[k])
l.push_front(k);
color[k] = true;
}
int main(void) {
int u, v;
int e;
cin >> n >> e;
for (int i = 0; i < e; i++) {
cin >> u >> v;
adj[u].push_back(v);
}
for (int i = 0; i < n; i++) {
if (!color[i])
topo(i);
}
for (list<int>::iterator it = l.begin(); it != l.end(); it++)
cout << *it << endl;
return 0;
}
|
replace
| 12 | 14 | 12 | 16 |
TLE
| |
p02370
|
C++
|
Runtime Error
|
// O(|E| + |V|)
#include <algorithm>
#include <cassert>
#include <queue>
#include <vector>
using namespace std;
class TopologicalSort {
#define MAX_V 101
private:
struct Edge {
int to;
Edge(int to) : to(to) {}
};
int V;
vector<Edge> G[MAX_V];
public:
TopologicalSort(int V) : V(V) {
if (V >= MAX_V) {
assert(false);
}
}
void AddEdge(int from, int to) { G[from].push_back(Edge(to)); }
vector<int> Solve() {
int k = 0;
vector<int> ord(V), in(V);
for (int i = 0; i < V; i++) {
for (auto &e : G[i]) {
in[e.to]++;
}
}
queue<int> q;
for (int i = 0; i < V; i++) {
if (in[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
ord[k++] = v;
for (auto &e : G[v]) {
if (--in[e.to] == 0) {
q.push(e.to);
}
}
}
return (*max_element(in.begin(), in.end()) == 0) ? ord : vector<int>();
}
};
#include <iostream>
int main() {
int V, E;
cin >> V >> E;
TopologicalSort ts(V);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
ts.AddEdge(s, t);
}
vector<int> ans = ts.Solve();
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
// O(|E| + |V|)
#include <algorithm>
#include <cassert>
#include <queue>
#include <vector>
using namespace std;
class TopologicalSort {
#define MAX_V 10001
private:
struct Edge {
int to;
Edge(int to) : to(to) {}
};
int V;
vector<Edge> G[MAX_V];
public:
TopologicalSort(int V) : V(V) {
if (V >= MAX_V) {
assert(false);
}
}
void AddEdge(int from, int to) { G[from].push_back(Edge(to)); }
vector<int> Solve() {
int k = 0;
vector<int> ord(V), in(V);
for (int i = 0; i < V; i++) {
for (auto &e : G[i]) {
in[e.to]++;
}
}
queue<int> q;
for (int i = 0; i < V; i++) {
if (in[i] == 0) {
q.push(i);
}
}
while (!q.empty()) {
int v = q.front();
q.pop();
ord[k++] = v;
for (auto &e : G[v]) {
if (--in[e.to] == 0) {
q.push(e.to);
}
}
}
return (*max_element(in.begin(), in.end()) == 0) ? ord : vector<int>();
}
};
#include <iostream>
int main() {
int V, E;
cin >> V >> E;
TopologicalSort ts(V);
for (int i = 0; i < E; i++) {
int s, t;
cin >> s >> t;
ts.AddEdge(s, t);
}
vector<int> ans = ts.Solve();
for (int i = 0; i < ans.size(); i++) {
cout << ans[i] << endl;
}
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
struct edge {
int src;
int dst;
int weight;
};
using graph = vector<vector<edge>>;
pair<int, int> visit(int v, int parent, const graph &G) {
pair<int, int> r(0, v);
for (const auto &e : G[v]) {
if (e.dst == parent) {
continue;
}
auto t = visit(e.dst, v, G);
t.first += e.weight;
if (r.first < t.first) {
r = t;
}
}
return r;
}
int main() {
int n;
cin >> n;
graph G(n);
for (int i = 0; i < n; ++i) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(edge{s, t, w});
G[t].push_back(edge{t, s, w});
}
auto r = visit(0, -1, G);
auto t = visit(r.second, -1, G);
cout << t.first << endl;
return 0;
}
|
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
struct edge {
int src;
int dst;
int weight;
};
using graph = vector<vector<edge>>;
pair<int, int> visit(int v, int parent, const graph &G) {
pair<int, int> r(0, v);
for (const auto &e : G[v]) {
if (e.dst == parent) {
continue;
}
auto t = visit(e.dst, v, G);
t.first += e.weight;
if (r.first < t.first) {
r = t;
}
}
return r;
}
int main() {
int n;
cin >> n;
graph G(n);
for (int i = 0; i < n - 1; ++i) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(edge{s, t, w});
G[t].push_back(edge{t, s, w});
}
auto r = visit(0, -1, G);
auto t = visit(r.second, -1, G);
cout << t.first << endl;
return 0;
}
|
replace
| 34 | 35 | 34 | 35 |
0
| |
p02371
|
C++
|
Runtime Error
|
// Ref : https://book.mynavi.jp/ec/products/detail/id=35408
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct Tree {
int N, diameter;
vector<vector<pair<int, int>>> E;
vector<int> d; // ある点からの距離, -1なら未探索を表す
Tree(int n) : N(n), E(n), d(n){};
// 辺を追加する //
void addPoint(int a, int b, int c) {
E[a].push_back(make_pair(b, c));
E[b].push_back(make_pair(a, c));
}
// 任意の節を始点として、幅優先で各節の距離を計算する(BFS) //
void bfsDistance(int s) {
queue<int> q;
for (int i = 0; i < N; i++)
d[i] = -1; // 距離計算用の初期化
d[s] = 0;
q.push(s);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (unsigned int i = 0; i < E[cur].size(); i++) {
int next = E[cur][i].first;
if (d[next] != -1)
continue; // 探索済みはスキップ(BFS探索における親)
d[next] = d[cur] + E[cur][i].second;
q.push(next);
}
}
}
// 木の直径を求め、表示する //
void solveDiameter() {
int maxv, point;
// ある節からの最大距離となる節を求める(直径の片側の節)
bfsDistance(0);
maxv = 0;
for (int i = 0; i < N; i++) {
if (maxv < d[i]) {
maxv = d[i];
point = i;
}
}
// 直径の片側から最大の距離を求め、直径となる2つの節を決定する
bfsDistance(point);
maxv = 0;
for (int i = 0; i < N; i++) {
if (maxv < d[i])
maxv = d[i];
}
cout << maxv << endl;
}
};
int main() {
int n;
cin >> n;
Tree T(n);
for (int i = 0; i < (n - 1); i++) {
int s, t, w;
cin >> s >> t >> w;
T.addPoint(s, t, w);
}
T.solveDiameter();
return 0;
}
|
// Ref : https://book.mynavi.jp/ec/products/detail/id=35408
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct Tree {
int N, diameter;
vector<vector<pair<int, int>>> E;
vector<int> d; // ある点からの距離, -1なら未探索を表す
Tree(int n) : N(n), E(n), d(n){};
// 辺を追加する //
void addPoint(int a, int b, int c) {
E[a].push_back(make_pair(b, c));
E[b].push_back(make_pair(a, c));
}
// 任意の節を始点として、幅優先で各節の距離を計算する(BFS) //
void bfsDistance(int s) {
queue<int> q;
for (int i = 0; i < N; i++)
d[i] = -1; // 距離計算用の初期化
d[s] = 0;
q.push(s);
while (!q.empty()) {
int cur = q.front();
q.pop();
for (unsigned int i = 0; i < E[cur].size(); i++) {
int next = E[cur][i].first;
if (d[next] != -1)
continue; // 探索済みはスキップ(BFS探索における親)
d[next] = d[cur] + E[cur][i].second;
q.push(next);
}
}
}
// 木の直径を求め、表示する //
void solveDiameter() {
int maxv, point;
// ある節からの最大距離となる節を求める(直径の片側の節)
bfsDistance(0);
maxv = point = 0;
for (int i = 0; i < N; i++) {
if (maxv < d[i]) {
maxv = d[i];
point = i;
}
}
// 直径の片側から最大の距離を求め、直径となる2つの節を決定する
bfsDistance(point);
maxv = 0;
for (int i = 0; i < N; i++) {
if (maxv < d[i])
maxv = d[i];
}
cout << maxv << endl;
}
};
int main() {
int n;
cin >> n;
Tree T(n);
for (int i = 0; i < (n - 1); i++) {
int s, t, w;
cin >> s >> t >> w;
T.addPoint(s, t, w);
}
T.solveDiameter();
return 0;
}
|
replace
| 44 | 45 | 44 | 45 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX = 100000;
const int INF = 123456789;
vector<pair<int, int>> G[MAX];
bool vis[MAX];
int d[MAX];
int maxv;
void bfs(int s) {
for (int i = 0; i < n; i++)
d[i] = INF;
queue<int> q;
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
if (d[v] == INF) {
d[v] = d[u] + G[u][i].second;
q.push(v);
}
}
}
}
void solve() {
bfs(0);
maxv = 0;
int tgt = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INF)
continue;
if (maxv < d[i]) {
maxv = d[i];
tgt = i;
}
}
bfs(tgt);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INF)
continue;
maxv = max(maxv, d[i]);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(make_pair(t, w));
G[t].push_back(make_pair(s, w));
}
solve();
cout << maxv << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
const int MAX = 100000;
const int INF = 123456789;
vector<pair<int, int>> G[MAX];
bool vis[MAX];
int d[MAX];
int maxv;
void bfs(int s) {
for (int i = 0; i < n; i++)
d[i] = INF;
queue<int> q;
q.push(s);
d[s] = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int i = 0; i < G[u].size(); i++) {
int v = G[u][i].first;
if (d[v] == INF) {
d[v] = d[u] + G[u][i].second;
q.push(v);
}
}
}
}
void solve() {
bfs(0);
maxv = 0;
int tgt = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INF)
continue;
if (maxv < d[i]) {
maxv = d[i];
tgt = i;
}
}
bfs(tgt);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INF)
continue;
maxv = max(maxv, d[i]);
}
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(make_pair(t, w));
G[t].push_back(make_pair(s, w));
}
solve();
cout << maxv << endl;
return 0;
}
|
replace
| 54 | 55 | 54 | 55 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ---------------------
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// ---------------------
#define INF 922337203685477580
#define IINF (1 << 21)
typedef long long ll;
int N;
vector<pair<int, int>> G[100010];
int d[100010];
int available[100010];
void dfs(int s) {
available[s] = 0;
for (vector<pair<int, int>>::iterator it = G[s].begin(); it != G[s].end();
it++) {
int v = it->first;
int w = it->second;
if (!available[v])
continue;
d[v] = d[s] + w;
dfs(v);
}
}
int main() {
int N;
cin >> N;
REP(i, N - 1) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(make_pair(t, w));
G[t].push_back(make_pair(s, w));
}
REP(i, N) {
d[i] = IINF;
available[i] = 1;
}
d[0] = 0;
dfs(0); // tekitou yatsu
int farv = 0;
REP(i, N) {
if (d[i] == IINF)
continue;
if (d[farv] < d[i]) {
farv = i;
}
}
dump(farv);
dump(d[farv]);
dump(d[0]);
dump(d[1]);
dump(d[2]);
dump(d[3]);
REP(i, N) {
d[i] = IINF;
available[i] = 1;
}
d[farv] = 0;
dfs(farv); // tekitou yatsu
int maxv = 0;
REP(i, N) {
if (d[i] == IINF)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
// ---------------------
// repetition
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// debug
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
// ---------------------
#define INF 922337203685477580
#define IINF (1 << 21)
typedef long long ll;
int N;
vector<pair<int, int>> G[100010];
int d[100010];
int available[100010];
void dfs(int s) {
available[s] = 0;
for (vector<pair<int, int>>::iterator it = G[s].begin(); it != G[s].end();
it++) {
int v = it->first;
int w = it->second;
if (!available[v])
continue;
d[v] = d[s] + w;
dfs(v);
}
}
int main() {
int N;
cin >> N;
REP(i, N - 1) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(make_pair(t, w));
G[t].push_back(make_pair(s, w));
}
REP(i, N) {
d[i] = IINF;
available[i] = 1;
}
d[0] = 0;
dfs(0); // tekitou yatsu
int farv = 0;
REP(i, N) {
if (d[i] == IINF)
continue;
if (d[farv] < d[i]) {
farv = i;
}
}
// dump(farv);
// dump(d[farv]);
// dump(d[0]);
// dump(d[1]);
// dump(d[2]);
// dump(d[3]);
REP(i, N) {
d[i] = IINF;
available[i] = 1;
}
d[farv] = 0;
dfs(farv); // tekitou yatsu
int maxv = 0;
REP(i, N) {
if (d[i] == IINF)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
return 0;
}
|
replace
| 77 | 83 | 77 | 83 |
0
|
farv = 3
d[farv] = 5
d[0] = 0
d[1] = 2
d[2] = 3
d[3] = 5
|
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef stack<int> SI;
typedef queue<int> QI;
typedef list<int> LI;
typedef pair<int, int> PII;
typedef long long LL;
#define d(x) cout << #x << " = " << (x) << endl;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define EMP empty()
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define REACH(i, c) \
for (typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c, n) sort(c, c + n)
#define VSORT(c) sort((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define DFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define DREP(i, n) DFOR(i, n, 0)
#define INF 1000000000
const double EPS = 1e-10;
const double PI = acos(-1.0);
////////////////////////////////////////////////
static const int MAX = 10000;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
int n;
int d[MAX];
vector<pair<int, int>> adj[MAX];
void dik(int s) {
priority_queue<PII> PQ;
int col[MAX];
REP(i, n) {
d[i] = INF;
col[i] = WHITE;
}
d[s] = 0;
PQ.push(MP(0, s));
col[s] = GRAY;
while (!PQ.empty()) {
PII f = PQ.top();
PQ.pop();
int u = f.second;
col[u] = BLACK;
if (d[u] < f.first * (-1))
continue;
REP(j, adj[u].size()) {
int v = adj[u][j].first;
if (col[v] == BLACK)
continue;
if (d[v] > d[u] + adj[u][j].second) {
d[v] = d[u] + adj[u][j].second;
PQ.push(MP(d[v] * (-1), v));
col[v] = GRAY;
}
}
}
}
int main() {
cin >> n;
FOR(i, 1, n) {
int s, t, w;
cin >> s >> t >> w;
adj[s].PB(MP(t, w));
adj[t].PB(MP(s, w));
}
dik(0);
int maxcost = -1;
int u = 0;
REP(i, n) {
if (d[i] > maxcost && d[i] != INF) {
maxcost = d[i];
u = i;
}
}
dik(u);
maxcost = -1;
REP(i, n) {
if (d[i] > maxcost && d[i] != INF) {
maxcost = d[i];
}
}
cout << maxcost << endl;
return 0;
}
|
#include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef stack<int> SI;
typedef queue<int> QI;
typedef list<int> LI;
typedef pair<int, int> PII;
typedef long long LL;
#define d(x) cout << #x << " = " << (x) << endl;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define EMP empty()
#define SZ(a) int((a).size())
#define EACH(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define REACH(i, c) \
for (typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); ++i)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c, n) sort(c, c + n)
#define VSORT(c) sort((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define DFOR(i, b, a) for (int i = (b)-1; i >= (a); --i)
#define DREP(i, n) DFOR(i, n, 0)
#define INF 1000000000
const double EPS = 1e-10;
const double PI = acos(-1.0);
////////////////////////////////////////////////
static const int MAX = 100000;
static const int WHITE = 0;
static const int GRAY = 1;
static const int BLACK = 2;
int n;
int d[MAX];
vector<pair<int, int>> adj[MAX];
void dik(int s) {
priority_queue<PII> PQ;
int col[MAX];
REP(i, n) {
d[i] = INF;
col[i] = WHITE;
}
d[s] = 0;
PQ.push(MP(0, s));
col[s] = GRAY;
while (!PQ.empty()) {
PII f = PQ.top();
PQ.pop();
int u = f.second;
col[u] = BLACK;
if (d[u] < f.first * (-1))
continue;
REP(j, adj[u].size()) {
int v = adj[u][j].first;
if (col[v] == BLACK)
continue;
if (d[v] > d[u] + adj[u][j].second) {
d[v] = d[u] + adj[u][j].second;
PQ.push(MP(d[v] * (-1), v));
col[v] = GRAY;
}
}
}
}
int main() {
cin >> n;
FOR(i, 1, n) {
int s, t, w;
cin >> s >> t >> w;
adj[s].PB(MP(t, w));
adj[t].PB(MP(s, w));
}
dik(0);
int maxcost = -1;
int u = 0;
REP(i, n) {
if (d[i] > maxcost && d[i] != INF) {
maxcost = d[i];
u = i;
}
}
dik(u);
maxcost = -1;
REP(i, n) {
if (d[i] > maxcost && d[i] != INF) {
maxcost = d[i];
}
}
cout << maxcost << endl;
return 0;
}
|
replace
| 47 | 48 | 47 | 48 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <vector>
using namespace std;
static const int MAX = 100000;
static const int INFTY = 1 << 29;
class edge {
public:
int t, w;
edge() {}
edge(int t, int w) : t(t), w(w) {}
};
vector<edge> g[MAX];
int n, d[MAX];
bool vis[MAX];
int cnt;
void bfs(int s) {
for (int i = 0; i < n; i++)
d[i] = INFTY;
queue<int> q;
q.push(s);
d[s] = 0;
int u;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++) {
edge e = g[u][i];
if (d[e.t] = INFTY) {
d[e.t] = d[u] + e.w;
q.push(e.t);
}
}
}
}
void solve() {
bfs(0);
int maxv = 0;
int tgt = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
if (maxv < d[i]) {
maxv = d[i];
tgt = i;
}
}
bfs(tgt);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
}
int main() {
int s, t, w;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> s >> t >> w;
g[s].push_back(edge(t, w));
g[t].push_back(edge(s, w));
}
solve();
return 0;
}
|
#include <algorithm>
#include <climits>
#include <iostream>
#include <list>
#include <queue>
#include <set>
#include <vector>
using namespace std;
static const int MAX = 100000;
static const int INFTY = 1 << 29;
class edge {
public:
int t, w;
edge() {}
edge(int t, int w) : t(t), w(w) {}
};
vector<edge> g[MAX];
int n, d[MAX];
bool vis[MAX];
int cnt;
void bfs(int s) {
for (int i = 0; i < n; i++)
d[i] = INFTY;
queue<int> q;
q.push(s);
d[s] = 0;
int u;
while (!q.empty()) {
u = q.front();
q.pop();
for (int i = 0; i < g[u].size(); i++) {
edge e = g[u][i];
if (d[e.t] == INFTY) {
d[e.t] = d[u] + e.w;
q.push(e.t);
}
}
}
}
void solve() {
bfs(0);
int maxv = 0;
int tgt = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
if (maxv < d[i]) {
maxv = d[i];
tgt = i;
}
}
bfs(tgt);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
}
int main() {
int s, t, w;
cin >> n;
for (int i = 0; i < n - 1; i++) {
cin >> s >> t >> w;
g[s].push_back(edge(t, w));
g[t].push_back(edge(s, w));
}
solve();
return 0;
}
|
replace
| 36 | 37 | 36 | 37 |
TLE
| |
p02371
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
void dfs1(int &u, int nowcost, int &dis, int node, vector<bool> &used,
vector<vector<pair<int, int>>> &adj) {
used[node] = true;
if (dis < nowcost) {
dis = nowcost;
u = node;
}
// cout << node << " " << nowcost << endl;
for (int i = 0; i < (int)adj[node].size(); i++) {
// cout << "ok" << endl;
int to = adj[node][i].first;
int cost = adj[node][i].second;
if (!used[to]) {
dfs1(u, nowcost + cost, dis, to, used, adj);
}
}
}
void dfs2(int nowcost, int &dis, int node, vector<bool> &used,
vector<vector<pair<int, int>>> &adj) {
used[node] = true;
dis = max(dis, nowcost);
// cout << node << " " << nowcost << endl;
for (int i = 0; i < (int)adj[node].size(); i++) {
// cout << "ok" << endl;
int to = adj[node][i].first;
int cost = adj[node][i].second;
if (!used[to]) {
dfs2(nowcost + cost, dis, to, used, adj);
}
}
}
int main() {
int n;
cin >> n;
if (n == 1)
!printf("0\n");
vector<vector<pair<int, int>>> adj(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
int u;
int dis = 0;
vector<bool> used(n, false);
dfs1(u, 0, dis, 0, used, adj);
for (int i = 0; i < n; i++)
used[i] = false;
dis = 0;
dfs2(0, dis, u, used, adj);
cout << dis << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void dfs1(int &u, int nowcost, int &dis, int node, vector<bool> &used,
vector<vector<pair<int, int>>> &adj) {
used[node] = true;
if (dis < nowcost) {
dis = nowcost;
u = node;
}
// cout << node << " " << nowcost << endl;
for (int i = 0; i < (int)adj[node].size(); i++) {
// cout << "ok" << endl;
int to = adj[node][i].first;
int cost = adj[node][i].second;
if (!used[to]) {
dfs1(u, nowcost + cost, dis, to, used, adj);
}
}
}
void dfs2(int nowcost, int &dis, int node, vector<bool> &used,
vector<vector<pair<int, int>>> &adj) {
used[node] = true;
dis = max(dis, nowcost);
// cout << node << " " << nowcost << endl;
for (int i = 0; i < (int)adj[node].size(); i++) {
// cout << "ok" << endl;
int to = adj[node][i].first;
int cost = adj[node][i].second;
if (!used[to]) {
dfs2(nowcost + cost, dis, to, used, adj);
}
}
}
int main() {
int n;
cin >> n;
if (n == 1)
return !printf("0\n");
vector<vector<pair<int, int>>> adj(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
cin >> a >> b >> c;
adj[a].push_back({b, c});
adj[b].push_back({a, c});
}
int u;
int dis = 0;
vector<bool> used(n, false);
dfs1(u, 0, dis, 0, used, adj);
for (int i = 0; i < n; i++)
used[i] = false;
dis = 0;
dfs2(0, dis, u, used, adj);
cout << dis << endl;
return 0;
}
|
replace
| 40 | 41 | 40 | 41 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 10000;
static const int INFTY = (1 << 20);
int n;
int d[MAX];
class Edge {
public:
int t, w;
Edge() {}
Edge(int t, int w) : t(t), w(w) {}
};
vector<Edge> G[MAX];
void bfs(int s) {
for (int i = 0; i < n; i++) {
d[i] = INFTY;
}
queue<int> Q;
Q.push(s);
d[s] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < G[u].size(); i++) {
Edge e = G[u][i];
if (d[e.t] == INFTY) {
d[e.t] = d[u] + e.w;
Q.push(e.t);
}
}
}
}
void solve() {
bfs(0);
int maxv = 0;
int target;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
if (maxv < d[i]) {
maxv = d[i];
target = i;
}
}
bfs(target);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(Edge(t, w));
G[t].push_back(Edge(s, w));
}
solve();
return 0;
}
|
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 100000;
static const int INFTY = (1 << 20);
int n;
int d[MAX];
class Edge {
public:
int t, w;
Edge() {}
Edge(int t, int w) : t(t), w(w) {}
};
vector<Edge> G[MAX];
void bfs(int s) {
for (int i = 0; i < n; i++) {
d[i] = INFTY;
}
queue<int> Q;
Q.push(s);
d[s] = 0;
while (!Q.empty()) {
int u = Q.front();
Q.pop();
for (int i = 0; i < G[u].size(); i++) {
Edge e = G[u][i];
if (d[e.t] == INFTY) {
d[e.t] = d[u] + e.w;
Q.push(e.t);
}
}
}
}
void solve() {
bfs(0);
int maxv = 0;
int target;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
if (maxv < d[i]) {
maxv = d[i];
target = i;
}
}
bfs(target);
maxv = 0;
for (int i = 0; i < n; i++) {
if (d[i] == INFTY)
continue;
maxv = max(maxv, d[i]);
}
cout << maxv << endl;
}
int main() {
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(Edge(t, w));
G[t].push_back(Edge(s, w));
}
solve();
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 100000;
vector<pair<int, int>> graph[MAX];
vector<int> bfs(int start) {
vector<int> d(MAX, 0);
vector<bool> discovered(MAX, false);
queue<int> visiting;
visiting.push(start);
discovered[start] = true;
while (!visiting.empty()) {
int now = visiting.front();
visiting.pop();
for (auto it = graph[now].begin(); it != graph[now].end(); ++it) {
if (!discovered[(*it).first]) {
discovered[(*it).first] = true;
visiting.push((*it).first);
d[(*it).first] = d[now] + (*it).second;
}
}
}
return d;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
int s, t, w;
cin >> s >> t >> w;
graph[s].push_back(make_pair(t, w));
graph[t].push_back(make_pair(s, w));
}
vector<int> d = bfs(0);
int x = distance(d.begin(), max_element(d.begin(), d.end()));
d = bfs(x);
int diameter = *max_element(d.begin(), d.end());
cout << diameter << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
static const int MAX = 100000;
vector<pair<int, int>> graph[MAX];
vector<int> bfs(int start) {
vector<int> d(MAX, 0);
vector<bool> discovered(MAX, false);
queue<int> visiting;
visiting.push(start);
discovered[start] = true;
while (!visiting.empty()) {
int now = visiting.front();
visiting.pop();
for (auto it = graph[now].begin(); it != graph[now].end(); ++it) {
if (!discovered[(*it).first]) {
discovered[(*it).first] = true;
visiting.push((*it).first);
d[(*it).first] = d[now] + (*it).second;
}
}
}
return d;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n - 1; i++) {
int s, t, w;
cin >> s >> t >> w;
graph[s].push_back(make_pair(t, w));
graph[t].push_back(make_pair(s, w));
}
vector<int> d = bfs(0);
int x = distance(d.begin(), max_element(d.begin(), d.end()));
d = bfs(x);
int diameter = *max_element(d.begin(), d.end());
cout << diameter << endl;
return 0;
}
|
replace
| 39 | 40 | 39 | 40 |
0
| |
p02371
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
namespace tree {
namespace diameter {
using Weight = ll;
using Edge = pair<int, Weight>;
using Graph = vector<vector<Edge>>;
namespace detail {
using Result = pair<Weight, int>;
Result visit(int parent, int curr, Graph const G) {
Result ret(0, curr);
for (auto &&e : G[curr]) {
int to;
Weight weight;
tie(to, weight) = e;
if (to == parent) {
continue;
}
auto t = visit(curr, to, G);
t.first += weight;
if (ret.first < t.first) {
ret = t;
}
}
return ret;
}
} // namespace detail
using Result = tuple<Weight, int, int>;
Result diameter(Graph const &G) {
auto r = detail::visit(-1, 0, G);
auto t = detail::visit(-1, r.second, G);
return Result{t.first, r.second, t.second};
}
#define USE_TREE_DIAMETER \
using tree::diameter::Weight; \
using tree::diameter::Edge; \
using tree::diameter::Graph; \
using tree::diameter::diameter;
} // namespace diameter
} // namespace tree
USE_TREE_DIAMETER
int main() {
int N;
cin >> N;
Graph g(N);
rep(i, N - 1) {
int s, t, w;
cin >> s >> t >> w;
g[s].emplace_back(t, w);
g[t].emplace_back(s, w);
}
Weight w;
int _;
tie(w, _, _) = diameter(g);
cout << w << endl;
return 0;
}
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define all(c) (c).begin(), (c).end()
#define zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
namespace tree {
namespace diameter {
using Weight = ll;
using Edge = pair<int, Weight>;
using Graph = vector<vector<Edge>>;
namespace detail {
using Result = pair<Weight, int>;
Result visit(int parent, int curr, Graph const &G) {
Result ret(0, curr);
for (auto &&e : G[curr]) {
int to;
Weight weight;
tie(to, weight) = e;
if (to == parent) {
continue;
}
auto t = visit(curr, to, G);
t.first += weight;
if (ret.first < t.first) {
ret = t;
}
}
return ret;
}
} // namespace detail
using Result = tuple<Weight, int, int>;
Result diameter(Graph const &G) {
auto r = detail::visit(-1, 0, G);
auto t = detail::visit(-1, r.second, G);
return Result{t.first, r.second, t.second};
}
#define USE_TREE_DIAMETER \
using tree::diameter::Weight; \
using tree::diameter::Edge; \
using tree::diameter::Graph; \
using tree::diameter::diameter;
} // namespace diameter
} // namespace tree
USE_TREE_DIAMETER
int main() {
int N;
cin >> N;
Graph g(N);
rep(i, N - 1) {
int s, t, w;
cin >> s >> t >> w;
g[s].emplace_back(t, w);
g[t].emplace_back(s, w);
}
Weight w;
int _;
tie(w, _, _) = diameter(g);
cout << w << endl;
return 0;
}
|
replace
| 48 | 49 | 48 | 49 |
MLE
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define REP(i, j) for (int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for (int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef pair<int, int> P;
P visit(int v, int prev, vector<vector<P>> &G) {
P res(v, 0);
REP(i, G[v].size()) {
if (G[v][i].first != prev) {
P t = visit(G[v][i].first, v, G);
t.second += G[v][i].second;
if (res.second < t.second)
res = t;
}
}
return res;
}
int diameter(vector<vector<P>> &G) {
P r = visit(0, -1, G);
P t = visit(r.first, -1, G);
return t.second; // (r.first, t.first) is farthest pair
}
int main() {
int N;
cin >> N;
vector<vector<P>> G(N + 1);
REP(i, N) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(P(t, w));
G[t].push_back(P(s, w));
}
cout << diameter(G) << endl;
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define REP(i, j) for (int i = 0; i < (int)(j); ++i)
#define FOR(i, j, k) for (int i = (int)(j); i < (int)(k); ++i)
#define SORT(v) sort((v).begin(), (v).end())
#define REVERSE(v) reverse((v).begin(), (v).end())
typedef pair<int, int> P;
P visit(int v, int prev, vector<vector<P>> &G) {
P res(v, 0);
REP(i, G[v].size()) {
if (G[v][i].first != prev) {
P t = visit(G[v][i].first, v, G);
t.second += G[v][i].second;
if (res.second < t.second)
res = t;
}
}
return res;
}
int diameter(vector<vector<P>> &G) {
P r = visit(0, -1, G);
P t = visit(r.first, -1, G);
return t.second; // (r.first, t.first) is farthest pair
}
int main() {
int N;
cin >> N;
vector<vector<P>> G(N);
REP(i, N - 1) {
int s, t, w;
cin >> s >> t >> w;
G[s].push_back(P(t, w));
G[t].push_back(P(s, w));
}
cout << diameter(G) << endl;
return 0;
}
|
replace
| 47 | 49 | 47 | 49 |
0
| |
p02371
|
C++
|
Runtime Error
|
// 木の直径
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define MAX_N 100
const int WHITE = 0; // 未訪問
const int GRAY = 1; // 訪問中
const int BLACK = 2; // 訪問完了
const int INV = -1;
typedef struct {
int end;
int weight;
} DATA;
// 木の情報を保持する動的配列
vector<DATA> G[MAX_N];
// 各頂点の訪問状態を保持する配列
int color[MAX_N + 1];
// 頂点:0から一番離れた頂点のNo.
int Zero_Leave_V = -1;
// 最大距離
int Max_Distance = -1;
int N;
void depthFirstSearch(int now_v, int distance);
int main(void) {
int start;
DATA ele;
// 配列の初期化
for (int i = 0; i < MAX_N + 1; i++) {
color[i] = WHITE;
}
cin >> N;
for (int i = 0; i < N - 1; i++) {
cin >> start >> ele.end >> ele.weight;
G[start].push_back(ele);
// 双方向に設定する
swap(start, ele.end);
G[start].push_back(ele);
}
// 頂点:0を始点として, 深さ優先探索を実施して、一番遠い点を求める
depthFirstSearch(0, 0);
// 訪問情報の初期化
for (int i = 0; i < MAX_N + 1; i++) {
color[i] = WHITE;
}
Max_Distance = -1;
// 頂点:0から最も離れた点から, 最も離れた点との距離を求める
depthFirstSearch(Zero_Leave_V, 0);
cout << Max_Distance << endl;
return 0;
}
// 深さ優先探索を実施する関数
// now_vertex : 現在の頂点のNo.
// distance : 現在までの距離
void depthFirstSearch(int now_v, int distance) {
int end, mid_distance;
// 訪問中を設定
color[now_v] = GRAY;
for (unsigned int i = 0; i < G[now_v].size(); i++) {
end = G[now_v][i].end;
if (color[end] == WHITE) {
// 距離の計算
mid_distance = distance;
mid_distance += G[now_v][i].weight;
// 未訪問の頂点が存在する時は再帰的に関数コールする
depthFirstSearch(end, mid_distance);
}
}
// 訪問完了
color[now_v] = BLACK;
if (Max_Distance < distance) {
Zero_Leave_V = now_v;
Max_Distance = distance;
}
return;
}
|
// 木の直径
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
#include <vector>
using namespace std;
#define MAX_N 100000
const int WHITE = 0; // 未訪問
const int GRAY = 1; // 訪問中
const int BLACK = 2; // 訪問完了
const int INV = -1;
typedef struct {
int end;
int weight;
} DATA;
// 木の情報を保持する動的配列
vector<DATA> G[MAX_N];
// 各頂点の訪問状態を保持する配列
int color[MAX_N + 1];
// 頂点:0から一番離れた頂点のNo.
int Zero_Leave_V = -1;
// 最大距離
int Max_Distance = -1;
int N;
void depthFirstSearch(int now_v, int distance);
int main(void) {
int start;
DATA ele;
// 配列の初期化
for (int i = 0; i < MAX_N + 1; i++) {
color[i] = WHITE;
}
cin >> N;
for (int i = 0; i < N - 1; i++) {
cin >> start >> ele.end >> ele.weight;
G[start].push_back(ele);
// 双方向に設定する
swap(start, ele.end);
G[start].push_back(ele);
}
// 頂点:0を始点として, 深さ優先探索を実施して、一番遠い点を求める
depthFirstSearch(0, 0);
// 訪問情報の初期化
for (int i = 0; i < MAX_N + 1; i++) {
color[i] = WHITE;
}
Max_Distance = -1;
// 頂点:0から最も離れた点から, 最も離れた点との距離を求める
depthFirstSearch(Zero_Leave_V, 0);
cout << Max_Distance << endl;
return 0;
}
// 深さ優先探索を実施する関数
// now_vertex : 現在の頂点のNo.
// distance : 現在までの距離
void depthFirstSearch(int now_v, int distance) {
int end, mid_distance;
// 訪問中を設定
color[now_v] = GRAY;
for (unsigned int i = 0; i < G[now_v].size(); i++) {
end = G[now_v][i].end;
if (color[end] == WHITE) {
// 距離の計算
mid_distance = distance;
mid_distance += G[now_v][i].weight;
// 未訪問の頂点が存在する時は再帰的に関数コールする
depthFirstSearch(end, mid_distance);
}
}
// 訪問完了
color[now_v] = BLACK;
if (Max_Distance < distance) {
Zero_Leave_V = now_v;
Max_Distance = distance;
}
return;
}
|
replace
| 12 | 13 | 12 | 13 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
#define MAX_V 100
struct edge {
int to, weight;
};
vector<edge> G[MAX_V];
pii dfs(int prev, int v) { // searching farthest node
pii r(0, v);
rep(i, G[v].size()) {
struct edge e = G[v][i];
if (e.to == prev)
continue;
pii tmp = dfs(v, e.to);
tmp.first += e.weight;
if (r.first < tmp.first)
r = tmp;
}
return r;
}
int diameter() {
pii r = dfs(-1, 0);
pii t = dfs(-1, r.second);
return t.first; // (r.second, t.second) is farthest pair
}
int main() {
int n;
cin >> n;
rep(i, n - 1) {
int s, t, w;
cin >> s >> t >> w;
G[s].pb(edge{t, w});
G[t].pb(edge{s, w});
}
cout << diameter() << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
#define INF 999999999
#define MAX_V 100000
struct edge {
int to, weight;
};
vector<edge> G[MAX_V];
pii dfs(int prev, int v) { // searching farthest node
pii r(0, v);
rep(i, G[v].size()) {
struct edge e = G[v][i];
if (e.to == prev)
continue;
pii tmp = dfs(v, e.to);
tmp.first += e.weight;
if (r.first < tmp.first)
r = tmp;
}
return r;
}
int diameter() {
pii r = dfs(-1, 0);
pii t = dfs(-1, r.second);
return t.first; // (r.second, t.second) is farthest pair
}
int main() {
int n;
cin >> n;
rep(i, n - 1) {
int s, t, w;
cin >> s >> t >> w;
G[s].pb(edge{t, w});
G[t].pb(edge{s, w});
}
cout << diameter() << endl;
}
|
replace
| 9 | 10 | 9 | 10 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info {
Info(int arg_to, int arg_cost) {
to = arg_to;
cost = arg_cost;
}
int to, cost;
};
struct Data {
Data(int arg_node_id, int arg_cost_sum) {
node_id = arg_node_id;
cost_sum = arg_cost_sum;
}
bool operator<(const struct Data &arg) const {
return cost_sum > arg.cost_sum;
};
int node_id, cost_sum;
};
int main() {
int N;
scanf("%d", &N);
int *min_dist = new int[N];
vector<Info> V[N];
int from, to, cost;
for (int i = 0; i < N - 1; i++) {
scanf("%d %d %d", &from, &to, &cost);
V[from].push_back(Info(to, cost));
V[to].push_back(Info(from, cost));
}
min_dist[0] = 0;
for (int i = 1; i < N; i++)
min_dist[i] = BIG_NUM;
priority_queue<Data> Q;
for (int i = 0; i < V[0].size(); i++) {
min_dist[V[0][i].to] = V[0][i].cost;
Q.push(Data(V[0][i].to, V[0][i].cost));
}
int index;
while (!Q.empty()) {
if (Q.top().cost_sum > min_dist[Q.top().node_id]) {
Q.pop();
} else {
index = Q.top().node_id;
Q.pop();
for (int i = 0; i < V[index].size(); i++) {
if (min_dist[V[index][i].to] > min_dist[index] + V[index][i].cost) {
min_dist[V[index][i].to] = min_dist[index] + V[index][i].cost;
Q.push(Data(V[index][i].to, min_dist[V[index][i].to]));
}
}
}
}
int maximum = -1, max_index;
for (int i = 1; i < N; i++) {
if (maximum < min_dist[i]) {
maximum = min_dist[i];
max_index = i;
}
}
for (int i = 0; i < N; i++)
min_dist[i] = BIG_NUM;
min_dist[max_index] = 0;
for (int i = 0; i < V[max_index].size(); i++) {
min_dist[V[max_index][i].to] = V[max_index][i].cost;
Q.push(Data(V[max_index][i].to, V[max_index][i].cost));
}
while (!Q.empty()) {
if (Q.top().cost_sum > min_dist[Q.top().node_id]) {
Q.pop();
} else {
index = Q.top().node_id;
Q.pop();
for (int i = 0; i < V[index].size(); i++) {
if (min_dist[V[index][i].to] > min_dist[index] + V[index][i].cost) {
min_dist[V[index][i].to] = min_dist[index] + V[index][i].cost;
Q.push(Data(V[index][i].to, min_dist[V[index][i].to]));
}
}
}
}
int ans = -1;
for (int i = 0; i < N; i++)
ans = max(ans, min_dist[i]);
printf("%d\n", ans);
return 0;
}
|
#include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
struct Info {
Info(int arg_to, int arg_cost) {
to = arg_to;
cost = arg_cost;
}
int to, cost;
};
struct Data {
Data(int arg_node_id, int arg_cost_sum) {
node_id = arg_node_id;
cost_sum = arg_cost_sum;
}
bool operator<(const struct Data &arg) const {
return cost_sum > arg.cost_sum;
};
int node_id, cost_sum;
};
int main() {
int N;
scanf("%d", &N);
if (N == 1) {
printf("0\n");
return 0;
}
int *min_dist = new int[N];
vector<Info> V[N];
int from, to, cost;
for (int i = 0; i < N - 1; i++) {
scanf("%d %d %d", &from, &to, &cost);
V[from].push_back(Info(to, cost));
V[to].push_back(Info(from, cost));
}
min_dist[0] = 0;
for (int i = 1; i < N; i++)
min_dist[i] = BIG_NUM;
priority_queue<Data> Q;
for (int i = 0; i < V[0].size(); i++) {
min_dist[V[0][i].to] = V[0][i].cost;
Q.push(Data(V[0][i].to, V[0][i].cost));
}
int index;
while (!Q.empty()) {
if (Q.top().cost_sum > min_dist[Q.top().node_id]) {
Q.pop();
} else {
index = Q.top().node_id;
Q.pop();
for (int i = 0; i < V[index].size(); i++) {
if (min_dist[V[index][i].to] > min_dist[index] + V[index][i].cost) {
min_dist[V[index][i].to] = min_dist[index] + V[index][i].cost;
Q.push(Data(V[index][i].to, min_dist[V[index][i].to]));
}
}
}
}
int maximum = -1, max_index;
for (int i = 1; i < N; i++) {
if (maximum < min_dist[i]) {
maximum = min_dist[i];
max_index = i;
}
}
for (int i = 0; i < N; i++)
min_dist[i] = BIG_NUM;
min_dist[max_index] = 0;
for (int i = 0; i < V[max_index].size(); i++) {
min_dist[V[max_index][i].to] = V[max_index][i].cost;
Q.push(Data(V[max_index][i].to, V[max_index][i].cost));
}
while (!Q.empty()) {
if (Q.top().cost_sum > min_dist[Q.top().node_id]) {
Q.pop();
} else {
index = Q.top().node_id;
Q.pop();
for (int i = 0; i < V[index].size(); i++) {
if (min_dist[V[index][i].to] > min_dist[index] + V[index][i].cost) {
min_dist[V[index][i].to] = min_dist[index] + V[index][i].cost;
Q.push(Data(V[index][i].to, min_dist[V[index][i].to]));
}
}
}
}
int ans = -1;
for (int i = 0; i < N; i++)
ans = max(ans, min_dist[i]);
printf("%d\n", ans);
return 0;
}
|
insert
| 39 | 39 | 39 | 44 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a].push_back({b, c});
g[b].push_back({a, c});
}
vector<vector<int>> d(n);
vector<int> far(n);
function<void(int, int)> dfs = [&](int u, int prev) {
for (auto e : g[u])
if (e.first != prev) {
int v = e.first;
dfs(v, u);
far[u] = max(far[u], far[v] + e.second);
d[u].push_back(far[v] + e.second);
}
};
dfs(0, -1);
vector<vector<int>> left(n), right(n);
auto build = [&](int u) { // d is prepared
left[u].resize(g[u].size());
right[u].resize(g[u].size());
left[u].front() = d[u].front(), right[u].back() = d[u].back();
for (int i = 0; i < (int)g[u].size() - 1; i++)
left[u][i + 1] = max(left[u][i], d[u][i + 1]);
for (int i = (int)g[u].size() - 1; i >= 1; i--)
right[u][i - 1] = max(right[u][i], d[u][i - 1]);
return;
};
build(0);
function<void(int, int)> dfs2 = [&](int u, int prev) {
int idx = 0;
for (auto e : g[u])
if (e.first != prev) {
int v = e.first;
int ma = 0;
if (idx - 1 >= 0)
ma = max(ma, left[u][idx - 1]);
if (idx + 1 < (int)right[u].size())
ma = max(ma, right[u][idx + 1]);
d[v].push_back(ma + e.second);
build(v);
dfs2(v, u);
idx++;
}
};
dfs2(0, -1);
int ans = 0;
for (int i = 0; i < n; i++) {
/*
for (auto it : d[i]) {
cerr << it << ' ';
}
cerr << endl;
*/
if (d[i].size() >= 2) {
sort(d[i].rbegin(), d[i].rend());
ans = max(ans, d[i][0] + d[i][1]);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <set>
#include <string>
#include <vector>
using namespace std;
int main() {
int n;
scanf("%d", &n);
vector<vector<pair<int, int>>> g(n);
for (int i = 0; i < n - 1; i++) {
int a, b, c;
scanf("%d%d%d", &a, &b, &c);
g[a].push_back({b, c});
g[b].push_back({a, c});
}
if (n == 1) {
printf("0\n");
return 0;
}
vector<vector<int>> d(n);
vector<int> far(n);
function<void(int, int)> dfs = [&](int u, int prev) {
for (auto e : g[u])
if (e.first != prev) {
int v = e.first;
dfs(v, u);
far[u] = max(far[u], far[v] + e.second);
d[u].push_back(far[v] + e.second);
}
};
dfs(0, -1);
vector<vector<int>> left(n), right(n);
auto build = [&](int u) { // d is prepared
left[u].resize(g[u].size());
right[u].resize(g[u].size());
left[u].front() = d[u].front(), right[u].back() = d[u].back();
for (int i = 0; i < (int)g[u].size() - 1; i++)
left[u][i + 1] = max(left[u][i], d[u][i + 1]);
for (int i = (int)g[u].size() - 1; i >= 1; i--)
right[u][i - 1] = max(right[u][i], d[u][i - 1]);
return;
};
build(0);
function<void(int, int)> dfs2 = [&](int u, int prev) {
int idx = 0;
for (auto e : g[u])
if (e.first != prev) {
int v = e.first;
int ma = 0;
if (idx - 1 >= 0)
ma = max(ma, left[u][idx - 1]);
if (idx + 1 < (int)right[u].size())
ma = max(ma, right[u][idx + 1]);
d[v].push_back(ma + e.second);
build(v);
dfs2(v, u);
idx++;
}
};
dfs2(0, -1);
int ans = 0;
for (int i = 0; i < n; i++) {
/*
for (auto it : d[i]) {
cerr << it << ' ';
}
cerr << endl;
*/
if (d[i].size() >= 2) {
sort(d[i].rbegin(), d[i].rend());
ans = max(ans, d[i][0] + d[i][1]);
}
}
printf("%d\n", ans);
return 0;
}
|
insert
| 21 | 21 | 21 | 25 |
0
| |
p02371
|
C++
|
Runtime Error
|
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const int V_MAX = 100;
struct Edge {
int v;
int w;
};
int solve(vector<Edge> graph[], int v, int prev, int n, int &m) {
int first = 0;
int second = 0;
for (int i = 0; i < graph[v].size(); i++) {
if (graph[v][i].v == prev)
continue;
int res =
solve(graph, graph[v][i].v, v, n + graph[v][i].w, m) + graph[v][i].w;
if (second < res) {
if (first < res) {
second = first;
first = res;
} else {
second = res;
}
}
}
m = max(m, first + max(n, second));
return first;
}
int main() {
int n;
vector<Edge> graph[V_MAX];
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int s, t, w;
Edge e1, e2;
scanf("%d%d%d", &s, &t, &w);
e1.v = t;
e1.w = w;
e2.v = s;
e2.w = w;
graph[s].push_back(e1);
graph[t].push_back(e2);
}
int m = 0;
solve(graph, 0, 0, 0, m);
printf("%d\n", m);
return 0;
}
|
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
const int V_MAX = 100000;
struct Edge {
int v;
int w;
};
int solve(vector<Edge> graph[], int v, int prev, int n, int &m) {
int first = 0;
int second = 0;
for (int i = 0; i < graph[v].size(); i++) {
if (graph[v][i].v == prev)
continue;
int res =
solve(graph, graph[v][i].v, v, n + graph[v][i].w, m) + graph[v][i].w;
if (second < res) {
if (first < res) {
second = first;
first = res;
} else {
second = res;
}
}
}
m = max(m, first + max(n, second));
return first;
}
int main() {
int n;
vector<Edge> graph[V_MAX];
scanf("%d", &n);
for (int i = 0; i < n - 1; i++) {
int s, t, w;
Edge e1, e2;
scanf("%d%d%d", &s, &t, &w);
e1.v = t;
e1.w = w;
e2.v = s;
e2.w = w;
graph[s].push_back(e1);
graph[t].push_back(e2);
}
int m = 0;
solve(graph, 0, 0, 0, m);
printf("%d\n", m);
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.