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 |
|---|---|---|---|---|---|---|---|---|---|---|---|
p02868 | C++ | Runtime Error | #include <cassert>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
template <typename T> using vec = vector<T>;
template <typename T> using vvec = vector<vec<T>>;
int main() {
int N, M;
cin >> N >> M;
vec<ll> L(M), R(M), C(M);
vvec<int> lid(N + 1), rid(N + 1);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i] >> C[i];
lid[L[i]].push_back(i);
rid[R[i]].push_back(i);
}
const ll inf = 1e18;
vec<ll> dp(N + 1, inf);
vec<ll> val(N + 1, inf);
dp[1] = 0;
map<ll, int> m;
m[0] = 1;
auto dec = [&](ll x) {
assert(m.count(x));
m[x]--;
if (m[x] == 0)
m.erase(x);
};
for (int i = 1; i <= N; i++) {
if (m.empty()) {
cout << -1 << endl;
return 0;
}
dp[i] = m.begin()->first;
for (auto &id : rid[i]) {
if (val[id] == inf)
continue;
dec(val[id]);
}
for (auto &id : lid[i]) {
// cerr << i << " " << dp[i]+C[id] << endl;
m[dp[i] + C[id]]++;
val[id] = dp[i] + C[id];
}
if (i == 1)
dec(0);
}
cout << (dp[N] != inf ? dp[N] : -1) << endl;
} | #include <cassert>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
typedef long long ll;
template <typename T> using vec = vector<T>;
template <typename T> using vvec = vector<vec<T>>;
int main() {
int N, M;
cin >> N >> M;
vec<ll> L(M), R(M), C(M);
vvec<int> lid(N + 1), rid(N + 1);
for (int i = 0; i < M; i++) {
cin >> L[i] >> R[i] >> C[i];
lid[L[i]].push_back(i);
rid[R[i]].push_back(i);
}
const ll inf = 1e18;
vec<ll> dp(N + 1, inf);
vec<ll> val(M + 1, inf);
dp[1] = 0;
map<ll, int> m;
m[0] = 1;
auto dec = [&](ll x) {
assert(m.count(x));
m[x]--;
if (m[x] == 0)
m.erase(x);
};
for (int i = 1; i <= N; i++) {
if (m.empty()) {
cout << -1 << endl;
return 0;
}
dp[i] = m.begin()->first;
for (auto &id : rid[i]) {
if (val[id] == inf)
continue;
dec(val[id]);
}
for (auto &id : lid[i]) {
// cerr << i << " " << dp[i]+C[id] << endl;
m[dp[i] + C[id]]++;
val[id] = dp[i] + C[id];
}
if (i == 1)
dec(0);
}
cout << (dp[N] != inf ? dp[N] : -1) << endl;
} | replace | 21 | 22 | 21 | 22 | 0 | |
p02868 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long>> in(n, vector<long long>(0)),
out(n, vector<long long>(0));
vector<long long> c(m);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r >> c[i];
in[l - 1].push_back(i);
out[r - 1].push_back(i);
}
vector<long long> dist(n, 1LL << 48), dist_c(m, 1LL << 48);
dist[0] = 0;
set<long long> dist_set;
for (int i = 0; i < n; i++) {
if (dist_set.size() > 0) {
dist[i] = min(dist[i], *dist_set.begin());
}
for (int j = 0; j < static_cast<int>(in[i].size()); j++) {
dist_c[in[i][j]] = dist[i] + c[in[i][j]];
dist_set.insert(dist_c[in[i][j]]);
}
for (int j = 0; j < static_cast<int>(out[i].size()); j++) {
dist_set.erase(dist_set.find(dist_c[out[i][j]]));
}
}
if (dist[n - 1] < (1LL << 48)) {
cout << dist[n - 1] << endl;
} else {
cout << "-1" << endl;
}
}
| #include <algorithm>
#include <iostream>
#include <set>
#include <vector>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
vector<vector<long long>> in(n, vector<long long>(0)),
out(n, vector<long long>(0));
vector<long long> c(m);
for (int i = 0; i < m; i++) {
int l, r;
cin >> l >> r >> c[i];
in[l - 1].push_back(i);
out[r - 1].push_back(i);
}
vector<long long> dist(n, 1LL << 48), dist_c(m, 1LL << 48);
dist[0] = 0;
multiset<long long> dist_set;
for (int i = 0; i < n; i++) {
if (dist_set.size() > 0) {
dist[i] = min(dist[i], *dist_set.begin());
}
for (int j = 0; j < static_cast<int>(in[i].size()); j++) {
dist_c[in[i][j]] = dist[i] + c[in[i][j]];
dist_set.insert(dist_c[in[i][j]]);
}
for (int j = 0; j < static_cast<int>(out[i].size()); j++) {
dist_set.erase(dist_set.find(dist_c[out[i][j]]));
}
}
if (dist[n - 1] < (1LL << 48)) {
cout << dist[n - 1] << endl;
} else {
cout << "-1" << endl;
}
}
| replace | 24 | 25 | 24 | 25 | 0 | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<vector<pair<ll, ll>>> G(N);
for (int i = 1; i < N; i++) {
G[i].push_back(make_pair(i - 1, 0));
}
ll L, R, C;
for (int i = 0; i < M; i++) {
cin >> L >> R >> C;
L--;
R--;
G[L].push_back(make_pair(R, C));
}
vector<ll> d(N);
for (int i = 0; i < N; i++) {
d[i] = INF;
}
d[0] = 0;
priority_queue<pair<ll, ll>> que;
que.push(make_pair(0, 0));
while (!que.empty()) {
auto p = que.top();
que.pop();
ll v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
auto e = G[v][i];
if (d[e.first] > d[v] + e.second) {
d[e.first] = d[v] + e.second;
que.push(make_pair(d[e.first], e.first));
}
}
}
if (d[N - 1] >= INF) {
cout << -1 << endl;
} else {
cout << d[N - 1] << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll INF = 1LL << 60;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
ll modpow(ll a, ll n, ll mod) {
ll res = 1;
while (n > 0) {
if (n & 1)
res = res * a % mod;
a = a * a % mod;
n >>= 1;
}
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<vector<pair<ll, ll>>> G(N);
for (int i = 1; i < N; i++) {
G[i].push_back(make_pair(i - 1, 0));
}
ll L, R, C;
for (int i = 0; i < M; i++) {
cin >> L >> R >> C;
L--;
R--;
G[L].push_back(make_pair(R, C));
}
vector<ll> d(N);
for (int i = 0; i < N; i++) {
d[i] = INF;
}
d[0] = 0;
priority_queue<pair<ll, ll>, vector<pair<ll, ll>>, greater<pair<ll, ll>>> que;
que.push(make_pair(0, 0));
while (!que.empty()) {
auto p = que.top();
que.pop();
ll v = p.second;
if (d[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
auto e = G[v][i];
if (d[e.first] > d[v] + e.second) {
d[e.first] = d[v] + e.second;
que.push(make_pair(d[e.first], e.first));
}
}
}
if (d[N - 1] >= INF) {
cout << -1 << endl;
} else {
cout << d[N - 1] << endl;
}
return 0;
}
| replace | 66 | 67 | 66 | 67 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
typedef pair<int, int> PI;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
const ll INF = 1e18 + 7;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<vector<PI>> G(N + 1);
vector<ll> D(N + 1, INF);
REP(i, M) {
int l, r, c;
scanf("%d %d %d", &l, &r, &c);
G[l].push_back(PI(r, c));
}
REP2(i, 1, N) { G[i + 1].push_back(PI(i, 0)); }
D[1] = 0;
priority_queue<PI, vector<PI>, greater<PI>> que;
que.push(PI(0, 1));
while (!que.empty()) {
PI p = que.top();
que.pop();
// cout << p << endl;
if (p.second == N) {
break;
}
if (p.first > D[p.second]) {
continue;
}
for (const auto &w : G[p.second]) {
if (D[w.first] > D[p.second] + w.second) {
D[w.first] = D[p.second] + w.second;
que.push(PI(D[w.first], w.first));
}
}
}
if (D[N] < INF) {
cout << D[N] << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REPD(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define PB(e) push_back(e)
#define FOREACH(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define BIT(n, m) (((n) >> (m)) & 1)
typedef long long ll;
typedef pair<ll, ll> PI;
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
out << "(" << p.first << ", " << p.second << ")";
return out;
}
template <typename T> ostream &operator<<(ostream &out, const vector<T> &v) {
out << "[";
REP(i, v.size()) {
if (i > 0)
out << ", ";
out << v[i];
}
out << "]";
return out;
}
const ll INF = 1e18 + 7;
int main() {
int N, M;
scanf("%d %d", &N, &M);
vector<vector<PI>> G(N + 1);
vector<ll> D(N + 1, INF);
REP(i, M) {
int l, r, c;
scanf("%d %d %d", &l, &r, &c);
G[l].push_back(PI(r, c));
}
REP2(i, 1, N) { G[i + 1].push_back(PI(i, 0)); }
D[1] = 0;
priority_queue<PI, vector<PI>, greater<PI>> que;
que.push(PI(0, 1));
while (!que.empty()) {
PI p = que.top();
que.pop();
// cout << p << endl;
if (p.second == N) {
break;
}
if (p.first > D[p.second]) {
continue;
}
for (const auto &w : G[p.second]) {
if (D[w.first] > D[p.second] + w.second) {
D[w.first] = D[p.second] + w.second;
que.push(PI(D[w.first], w.first));
}
}
}
if (D[N] < INF) {
cout << D[N] << endl;
} else {
cout << -1 << endl;
}
return 0;
}
| replace | 23 | 24 | 23 | 24 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <utility>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define P pair<int, int>
#define PLI pair<ll, int>
#define PLL pair<ll, ll>
#define VI vector<int>
#define VII vector<VI>
using namespace std;
const ll INF = 1e18;
struct edge {
int to;
ll co;
edge(int t, ll c) : to(t), co(c) {}
bool operator<(const edge e) const { return co > e.co; }
};
int N, M;
vector<edge> G[100005];
ll cost[100005];
int main() {
cin >> N >> M;
rep(i, M) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
G[l].emplace_back(r, c);
}
rep(i, N - 1) { G[i + 1].emplace_back(i, 0); }
rep(i, N) cost[i] = INF;
cost[0] = 0;
priority_queue<edge> pq;
pq.emplace(0, 0);
while (!pq.empty()) {
edge now = pq.top();
pq.pop();
if (cost[now.to] < now.co)
continue;
for (auto e : G[now.to]) {
if (cost[e.to] > cost[now.to] + e.co) {
cost[e.to] = cost[now.to] + e.co;
pq.emplace(e.to, e.co);
}
}
}
if (cost[N - 1] == INF)
cout << -1 << endl;
else
cout << cost[N - 1] << endl;
return 0;
}
| #include <algorithm>
#include <functional>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <random>
#include <set>
#include <string>
#include <utility>
typedef long long ll;
#define rep(i, n) for (int i = 0; i < n; i++)
#define pb push_back
#define P pair<int, int>
#define PLI pair<ll, int>
#define PLL pair<ll, ll>
#define VI vector<int>
#define VII vector<VI>
using namespace std;
const ll INF = 1e18;
struct edge {
int to;
ll co;
edge(int t, ll c) : to(t), co(c) {}
bool operator<(const edge e) const { return co > e.co; }
};
int N, M;
vector<edge> G[100005];
ll cost[100005];
int main() {
cin >> N >> M;
rep(i, M) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
G[l].emplace_back(r, c);
}
rep(i, N - 1) { G[i + 1].emplace_back(i, 0); }
rep(i, N) cost[i] = INF;
cost[0] = 0;
priority_queue<edge> pq;
pq.emplace(0, 0);
while (!pq.empty()) {
edge now = pq.top();
pq.pop();
if (cost[now.to] < now.co)
continue;
for (auto e : G[now.to]) {
if (cost[e.to] > cost[now.to] + e.co) {
cost[e.to] = cost[now.to] + e.co;
pq.emplace(e.to, cost[e.to]);
}
}
}
if (cost[N - 1] == INF)
cout << -1 << endl;
else
cout << cost[N - 1] << endl;
return 0;
} | replace | 57 | 58 | 57 | 58 | TLE | |
p02868 | C++ | Runtime Error | #include "./bits/stdc++.h"
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define linf 122337203685477000
using namespace std;
typedef long long ll;
/*
vector.push_back()
vector<int> hoge(3,-1); {-1,-1,-1}
vector<vector<int>> hogehoge(2,vector<int>(2,-1)); {{-1,-1},{-1,-1}}
cin >>temp;
scanf("%d %d %d",&A,&B,&Q);
sort(a.begin(),a.end());
a.push_back(4000000000000);
a.insert(a.begin(),-1000000000000);
upper_bound(a.begin(),a.end(),x); // list[i] > x のイテレータ取得. *itrで数値化
std::priority_queue<
int,
std::vector<int>,
decltype(compare) // 比較関数オブジェクトを指定
> que(comp);
*/
template <typename T> void debug(T arr);
template <typename T> void debug(T arr, int dim);
vector<long long> dijkstra(int n, int start,
vector<vector<pair<long long, long long>>> &edge) {
vector<long long> shortest(n, linf);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
shortest[start] = 0LL;
que.push(pair<long long, long long>(0, start));
while (!que.empty()) {
pair<long long, long long> now = que.top();
que.pop();
long long v = now.second;
if (shortest[v] < now.first) {
continue;
} else {
for (int i = 0; i < edge[v].size(); ++i) {
long long to = edge[v][i].first;
long long cost = edge[v][i].second;
long long new_cost = shortest[v] + cost;
if (new_cost < shortest[to]) {
shortest[to] = new_cost;
que.push(pair<long long, long long>(new_cost, to));
}
}
}
}
return shortest;
}
int main(void) {
ll n, m;
ll l, r, c;
cin >> n >> m;
vector<vector<ll>> arr(n, vector<ll>(n, linf));
vector<vector<pair<long long, long long>>> edge;
edge.push_back({});
for (int i = 1; i < n; ++i) {
vector<pair<long long, long long>> temp;
temp = {pair<long long, long long>(i - 1, 0)};
edge.push_back(temp);
}
for (int i = 0; i < m; ++i) {
scanf("%lld %lld %lld", &l, &r, &c);
edge[l - 1].push_back(pair<long long, long long>(r - 1, c));
}
vector<long long> shortest;
shortest = dijkstra(n, 0, edge);
if (shortest[n - 1] == linf) {
cout << -1 << endl;
} else {
cout << shortest[n - 1] << endl;
}
};
template <typename T> void debug(T arr) {
for (auto col : arr) {
cout << col << " ";
}
cout << endl;
};
template <typename T> void debug(T arr, int dim) {
for (auto raw : arr) {
for (auto col : raw) {
cout << col << " ";
}
cout << endl;
}
};
| #include "./bits/stdc++.h"
#include <iostream>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define linf 122337203685477000
using namespace std;
typedef long long ll;
/*
vector.push_back()
vector<int> hoge(3,-1); {-1,-1,-1}
vector<vector<int>> hogehoge(2,vector<int>(2,-1)); {{-1,-1},{-1,-1}}
cin >>temp;
scanf("%d %d %d",&A,&B,&Q);
sort(a.begin(),a.end());
a.push_back(4000000000000);
a.insert(a.begin(),-1000000000000);
upper_bound(a.begin(),a.end(),x); // list[i] > x のイテレータ取得. *itrで数値化
std::priority_queue<
int,
std::vector<int>,
decltype(compare) // 比較関数オブジェクトを指定
> que(comp);
*/
template <typename T> void debug(T arr);
template <typename T> void debug(T arr, int dim);
vector<long long> dijkstra(int n, int start,
vector<vector<pair<long long, long long>>> &edge) {
vector<long long> shortest(n, linf);
priority_queue<pair<long long, long long>, vector<pair<long long, long long>>,
greater<pair<long long, long long>>>
que;
shortest[start] = 0LL;
que.push(pair<long long, long long>(0, start));
while (!que.empty()) {
pair<long long, long long> now = que.top();
que.pop();
long long v = now.second;
if (shortest[v] < now.first) {
continue;
} else {
for (int i = 0; i < edge[v].size(); ++i) {
long long to = edge[v][i].first;
long long cost = edge[v][i].second;
long long new_cost = shortest[v] + cost;
if (new_cost < shortest[to]) {
shortest[to] = new_cost;
que.push(pair<long long, long long>(new_cost, to));
}
}
}
}
return shortest;
}
int main(void) {
ll n, m;
ll l, r, c;
cin >> n >> m;
vector<vector<pair<long long, long long>>> edge;
edge.push_back({});
for (int i = 1; i < n; ++i) {
vector<pair<long long, long long>> temp;
temp = {pair<long long, long long>(i - 1, 0)};
edge.push_back(temp);
}
for (int i = 0; i < m; ++i) {
scanf("%lld %lld %lld", &l, &r, &c);
edge[l - 1].push_back(pair<long long, long long>(r - 1, c));
}
vector<long long> shortest;
shortest = dijkstra(n, 0, edge);
if (shortest[n - 1] == linf) {
cout << -1 << endl;
} else {
cout << shortest[n - 1] << endl;
}
};
template <typename T> void debug(T arr) {
for (auto col : arr) {
cout << col << " ";
}
cout << endl;
};
template <typename T> void debug(T arr, int dim) {
for (auto raw : arr) {
for (auto col : raw) {
cout << col << " ";
}
cout << endl;
}
};
| delete | 64 | 65 | 64 | 64 | 0 | |
p02868 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
const long long INF = (long long)1e18;
const long long MOD = 1'000'000'007;
string yn(bool f) { return f ? "Yes" : "No"; }
string YN(bool f) { return f ? "YES" : "NO"; }
#define L first.first
#define R first.second
#define C second
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int N, M;
vector<int> dis;
vector<pair<pair<int, int>, int>> in;
vector<vector<pair<int, int>>> z;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
Q;
cin >> N >> M;
in.resize(M);
z.resize(N + 10);
dis.resize(N + 10, INF);
for (int i = 0; i < M; i++) {
cin >> in[i].L >> in[i].R >> in[i].C;
z[in[i].L].push_back(make_pair(in[i].R, in[i].C));
}
sort(in.begin(), in.end());
dis[1] = 0;
int c = 0;
for (int i = 0; i < z[1].size(); i++) {
Q.push(make_pair(z[1][i].second, z[1][i].first));
}
for (int i = 2; i <= N; i++) {
pair<int, int> t;
t = Q.top();
while (t.second < i) {
Q.pop();
if (Q.size() == 0) {
cout << -1 << endl;
return 0;
}
t = Q.top();
}
dis[i] = t.first;
for (int j = 0; j < z[i].size(); j++) {
Q.push(make_pair(z[i][j].second + dis[i], z[i][j].first));
}
}
if (dis[N] != INF)
cout << dis[N] << endl;
else
cout << -1 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define int long long
#define endl "\n"
const long long INF = (long long)1e18;
const long long MOD = 1'000'000'007;
string yn(bool f) { return f ? "Yes" : "No"; }
string YN(bool f) { return f ? "YES" : "NO"; }
#define L first.first
#define R first.second
#define C second
signed main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
int N, M;
vector<int> dis;
vector<pair<pair<int, int>, int>> in;
vector<vector<pair<int, int>>> z;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
Q;
cin >> N >> M;
in.resize(M);
z.resize(N + 10);
dis.resize(N + 10, INF);
for (int i = 0; i < M; i++) {
cin >> in[i].L >> in[i].R >> in[i].C;
z[in[i].L].push_back(make_pair(in[i].R, in[i].C));
}
sort(in.begin(), in.end());
dis[1] = 0;
int c = 0;
for (int i = 0; i < z[1].size(); i++) {
Q.push(make_pair(z[1][i].second, z[1][i].first));
}
for (int i = 2; i <= N; i++) {
pair<int, int> t;
if (Q.size())
t = Q.top();
else {
cout << -1 << endl;
return 0;
}
while (t.second < i) {
Q.pop();
if (Q.size() == 0) {
cout << -1 << endl;
return 0;
}
t = Q.top();
}
dis[i] = t.first;
for (int j = 0; j < z[i].size(); j++) {
Q.push(make_pair(z[i][j].second + dis[i], z[i][j].first));
}
}
if (dis[N] != INF)
cout << dis[N] << endl;
else
cout << -1 << endl;
return 0;
} | replace | 59 | 60 | 59 | 65 | 0 | |
p02868 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define rer(i, a, b) for (ll i = ll(a) - 1; i >= ll(b); i--)
#define sz(v) (int)(v).size()
#define pb push_back
#define sc second
#define fr first
#define sor(v) sort(v.begin(), v.end())
#define rev(s) reverse(s.begin(), s.end())
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define uniq(vec) vec.erase(unique(vec.begin(), vec.end()), vec.end())
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
const ll MOD = 1000000007;
const ll MAX_N = 100010, INF = 1e17;
struct LazySegmentTree {
ll node[2 * MAX_N - 1], lazy[2 * MAX_N - 1], SIZE; // SIZE:nを２べきにしたもの
bool lazyflag[2 * MAX_N - 1];
// 初期化
void init(int n_) {
// 要素数を2べきに
SIZE = 1;
while (SIZE < n_)
SIZE *= 2;
// 全ての値をI_MAXに
rep(i, 0, 2 * SIZE - 1) node[i] = INF;
}
// k番目のノードについて遅延評価を行う
void eval(int k, int l, int r) {
// 遅延配列が空でない場合、自ノード及び子ノードへの値の伝播が起こる
if (lazyflag[k]) {
node[k] = lazy[k];
// 最下段かどうかのチェックをしよう
if (r - l > 1) {
lazy[k * 2 + 1] = lazy[k * 2 + 2] = lazy[k];
lazyflag[k * 2 + 1] = lazyflag[k * 2 + 2] = true;
}
lazyflag[k] = false;
}
}
void update(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = SIZE;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = x;
lazyflag[k] = true;
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
ll getmin(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = SIZE;
eval(k, l, r);
if (b <= l || r <= a)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = getmin(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = getmin(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
LazySegmentTree S;
vector<PP> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
v.resize(m);
rep(i, 0, m) {
cin >> v[i].fr.fr >> v[i].fr.sc >> v[i].sc;
v[i].fr.fr--;
}
sor(v);
S.init(n);
S.update(0, 1, 0);
rep(i, 0, m) {
int l = v[i].fr.fr, r = v[i].fr.sc, c = v[i].sc;
ll M = S.getmin(l, l + 1);
if (M == INF)
break;
ll ng = r, ok = l;
while (ng - ok > 1) {
ll mid = (ng + ok) / 2;
if (S.getmin(mid, mid + 1) <= M + c)
ok = mid;
else
ng = mid;
}
if (ok + 1 < r)
S.update(ok + 1, r, M + c);
}
cout << (S.getmin(n - 1, n) == INF ? -1 : S.getmin(n - 1, n)) << "\n";
} | #include <bits/stdc++.h>
#define rep(i, a, b) for (ll i = ll(a); i < ll(b); i++)
#define rer(i, a, b) for (ll i = ll(a) - 1; i >= ll(b); i--)
#define sz(v) (int)(v).size()
#define pb push_back
#define sc second
#define fr first
#define sor(v) sort(v.begin(), v.end())
#define rev(s) reverse(s.begin(), s.end())
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define uniq(vec) vec.erase(unique(vec.begin(), vec.end()), vec.end())
using namespace std;
typedef long long int ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> PP;
const ll MOD = 1000000007;
const ll MAX_N = 400010, INF = 1e17;
struct LazySegmentTree {
ll node[2 * MAX_N - 1], lazy[2 * MAX_N - 1], SIZE; // SIZE:nを２べきにしたもの
bool lazyflag[2 * MAX_N - 1];
// 初期化
void init(int n_) {
// 要素数を2べきに
SIZE = 1;
while (SIZE < n_)
SIZE *= 2;
// 全ての値をI_MAXに
rep(i, 0, 2 * SIZE - 1) node[i] = INF;
}
// k番目のノードについて遅延評価を行う
void eval(int k, int l, int r) {
// 遅延配列が空でない場合、自ノード及び子ノードへの値の伝播が起こる
if (lazyflag[k]) {
node[k] = lazy[k];
// 最下段かどうかのチェックをしよう
if (r - l > 1) {
lazy[k * 2 + 1] = lazy[k * 2 + 2] = lazy[k];
lazyflag[k * 2 + 1] = lazyflag[k * 2 + 2] = true;
}
lazyflag[k] = false;
}
}
void update(int a, int b, ll x, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = SIZE;
eval(k, l, r);
if (b <= l || r <= a)
return;
if (a <= l && r <= b) {
lazy[k] = x;
lazyflag[k] = true;
eval(k, l, r);
} else {
update(a, b, x, 2 * k + 1, l, (l + r) / 2);
update(a, b, x, 2 * k + 2, (l + r) / 2, r);
node[k] = min(node[2 * k + 1], node[2 * k + 2]);
}
}
ll getmin(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r < 0)
r = SIZE;
eval(k, l, r);
if (b <= l || r <= a)
return INF;
if (a <= l && r <= b)
return node[k];
ll vl = getmin(a, b, 2 * k + 1, l, (l + r) / 2);
ll vr = getmin(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
LazySegmentTree S;
vector<PP> v;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, m;
cin >> n >> m;
v.resize(m);
rep(i, 0, m) {
cin >> v[i].fr.fr >> v[i].fr.sc >> v[i].sc;
v[i].fr.fr--;
}
sor(v);
S.init(n);
S.update(0, 1, 0);
rep(i, 0, m) {
int l = v[i].fr.fr, r = v[i].fr.sc, c = v[i].sc;
ll M = S.getmin(l, l + 1);
if (M == INF)
break;
ll ng = r, ok = l;
while (ng - ok > 1) {
ll mid = (ng + ok) / 2;
if (S.getmin(mid, mid + 1) <= M + c)
ok = mid;
else
ng = mid;
}
if (ok + 1 < r)
S.update(ok + 1, r, M + c);
}
cout << (S.getmin(n - 1, n) == INF ? -1 : S.getmin(n - 1, n)) << "\n";
} | replace | 18 | 19 | 18 | 19 | 0 | |
p02868 | C++ | Time Limit Exceeded | #include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <forward_list>
#include <random>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define lcm(a, b) (a) / __gcd((a), (b)) * (b)
#define endl '\n'
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> LP;
typedef pair<int, P> iP;
typedef pair<P, P> PP;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1000000007;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<int> Div(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.pb(i);
if (i * i != n)
ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
LL dijkstra();
vector<LP> graph[SIZE];
LL dist[SIZE];
int n, m;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
graph[l].pb(MP(r, c));
graph[r].pb(MP(l, c));
}
for (int i = 2; i <= n; ++i) {
graph[i].pb(MP(i - 1, 0));
}
LL res = dijkstra();
if (res == LINF)
res = -1;
cout << res << endl;
return 0;
}
LL dijkstra() {
priority_queue<LP, vector<LP>, greater<LP>> pq;
pq.push(MP(1, 0));
for (int i = 0; i < SIZE; ++i) {
dist[i] = LINF;
}
while (!pq.empty()) {
LP node = pq.top();
pq.pop();
if (node.F == n)
continue;
for (int i = 0; i < graph[node.F].size(); ++i) {
LP p = graph[node.F][i];
if (dist[p.F] > node.S + p.S) {
dist[p.F] = node.S + p.S;
pq.push(MP(p.F, dist[p.F]));
}
}
}
return dist[n];
}
| #include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <ios>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <valarray>
#include <vector>
#if __cplusplus >= 201103L
#include <array>
#include <forward_list>
#include <random>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <unordered_map>
#include <unordered_set>
#endif
#define F first
#define S second
#define MP make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
#define lcm(a, b) (a) / __gcd((a), (b)) * (b)
#define endl '\n'
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
typedef pair<LL, LL> LP;
typedef pair<int, P> iP;
typedef pair<P, P> PP;
static const int INF = INT_MAX;
static const LL LINF = LLONG_MAX;
static const int MIN = INT_MIN;
static const LL LMIN = LLONG_MIN;
static const int MOD = 1000000007;
static const int SIZE = 200005;
const int dx[] = {0, -1, 1, 0};
const int dy[] = {-1, 0, 0, 1};
vector<int> Div(int n) {
vector<int> ret;
for (int i = 1; i * i <= n; ++i) {
if (n % i == 0) {
ret.pb(i);
if (i * i != n)
ret.pb(n / i);
}
}
sort(all(ret));
return ret;
}
LL dijkstra();
vector<LP> graph[SIZE];
LL dist[SIZE];
int n, m;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
graph[l].pb(MP(r, c));
}
for (int i = 2; i <= n; ++i) {
graph[i].pb(MP(i - 1, 0));
}
LL res = dijkstra();
if (res == LINF)
res = -1;
cout << res << endl;
return 0;
}
LL dijkstra() {
priority_queue<LP, vector<LP>, greater<LP>> pq;
pq.push(MP(1, 0));
for (int i = 0; i < SIZE; ++i) {
dist[i] = LINF;
}
while (!pq.empty()) {
LP node = pq.top();
pq.pop();
if (node.F == n)
continue;
for (int i = 0; i < graph[node.F].size(); ++i) {
LP p = graph[node.F][i];
if (dist[p.F] > node.S + p.S) {
dist[p.F] = node.S + p.S;
pq.push(MP(p.F, dist[p.F]));
}
}
}
return dist[n];
}
| delete | 106 | 107 | 106 | 106 | TLE | |
p02868 | C++ | Time Limit Exceeded | // Copyright 2019 yaito3014
#include "bits/stdc++.h"
using namespace std;
using namespace literals;
struct Edge {
int to, cost;
Edge() = default;
Edge(int t, int c) : to(t), cost(c) {}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<vector<Edge>> G(N);
for (int i = 0; i < N - 1; ++i)
G[i + 1].push_back(Edge(i, 0)); // N→1にはノーコストで動ける
for (int i = 0; i < M; ++i) {
int L, R, C;
cin >> L >> R >> C;
G[--L].push_back(Edge(--R, C)); // C使ってL→Rに行ける
}
vector<int64_t> cost(N, INT64_MAX);
cost[0] = 0;
using P = pair<int64_t, int>; // first: cost, second: index
priority_queue<P> que;
que.push(P(0, 0));
while (!que.empty()) {
P cur = que.top();
que.pop();
for (Edge &nxt : G[cur.second]) {
int64_t c = cur.first + nxt.cost;
if (cost[nxt.to] <= c)
continue;
cost[nxt.to] = c;
que.push(P(c, nxt.to));
}
}
int64_t ans = cost[N - 1];
if (ans == INT64_MAX)
ans = -1;
cout << ans << endl;
}
| // Copyright 2019 yaito3014
#include "bits/stdc++.h"
using namespace std;
using namespace literals;
struct Edge {
int to, cost;
Edge() = default;
Edge(int t, int c) : to(t), cost(c) {}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<vector<Edge>> G(N);
for (int i = 0; i < N - 1; ++i)
G[i + 1].push_back(Edge(i, 0)); // N→1にはノーコストで動ける
for (int i = 0; i < M; ++i) {
int L, R, C;
cin >> L >> R >> C;
G[--L].push_back(Edge(--R, C)); // C使ってL→Rに行ける
}
vector<int64_t> cost(N, INT64_MAX);
cost[0] = 0;
using P = pair<int64_t, int>; // first: cost, second: index
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, 0));
while (!que.empty()) {
P cur = que.top();
que.pop();
for (Edge &nxt : G[cur.second]) {
int64_t c = cur.first + nxt.cost;
if (cost[nxt.to] <= c)
continue;
cost[nxt.to] = c;
que.push(P(c, nxt.to));
}
}
int64_t ans = cost[N - 1];
if (ans == INT64_MAX)
ans = -1;
cout << ans << endl;
}
| replace | 27 | 28 | 27 | 28 | TLE | |
p02868 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long double ld;
typedef long long ll;
using namespace std;
const ll inf = 1e18;
struct Segment {
int l;
int r;
int c;
bool operator<(const Segment &rhs) { return l < rhs.l; }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
freopen("input.txt", "r", stdin);
cout << setprecision(20);
int l, n;
cin >> l >> n;
vector<Segment> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].l >> a[i].r >> a[i].c;
}
sort(a.begin(), a.end());
ll ans = inf;
set<pair<ll, int>> len;
int dist = 0;
int j1 = 0;
len.insert(make_pair(0, 1));
auto lol = make_pair(inf, l);
len.insert(lol);
while (!len.empty()) {
if (dist >= len.begin()->second) {
len.erase(len.begin());
continue;
}
pair<ll, int> x = *len.begin();
int pos = x.second;
dist = pos;
ll cost = x.first;
int j2 = j1;
while (j2 < n && a[j2].l <= pos) {
if (a[j2].r > pos) {
ll ccost = a[j2].c + cost;
if (a[j2].r == l) {
ans = min(ans, ccost);
}
len.insert(make_pair(ccost, a[j2].r));
}
j2++;
}
j1 = j2;
}
if (ans == inf) {
cout << "-1";
} else {
cout << ans;
}
return 0;
}
| #include <bits/stdc++.h>
typedef long double ld;
typedef long long ll;
using namespace std;
const ll inf = 1e18;
struct Segment {
int l;
int r;
int c;
bool operator<(const Segment &rhs) { return l < rhs.l; }
};
int main() {
std::ios_base::sync_with_stdio(false);
std::cin.tie(nullptr);
// freopen("input.txt", "r", stdin);
cout << setprecision(20);
int l, n;
cin >> l >> n;
vector<Segment> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i].l >> a[i].r >> a[i].c;
}
sort(a.begin(), a.end());
ll ans = inf;
set<pair<ll, int>> len;
int dist = 0;
int j1 = 0;
len.insert(make_pair(0, 1));
auto lol = make_pair(inf, l);
len.insert(lol);
while (!len.empty()) {
if (dist >= len.begin()->second) {
len.erase(len.begin());
continue;
}
pair<ll, int> x = *len.begin();
int pos = x.second;
dist = pos;
ll cost = x.first;
int j2 = j1;
while (j2 < n && a[j2].l <= pos) {
if (a[j2].r > pos) {
ll ccost = a[j2].c + cost;
if (a[j2].r == l) {
ans = min(ans, ccost);
}
len.insert(make_pair(ccost, a[j2].r));
}
j2++;
}
j1 = j2;
}
if (ans == inf) {
cout << "-1";
} else {
cout << ans;
}
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()
|
p02868 | C++ | Runtime Error | /// kAAzuki Hoshino
/*
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long
typedef long long ll;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define INF 100000000000000000
#define mod 1000000007
#define dmp(x) cerr << "line " << __LINE__ << " " << #x << ":" << x << endl
#define fs first
#define sc second
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int MAXN = 101010;
int t[MAXN], lazy[MAXN];
void init() {
fill_n(t, MAXN, INF);
fill_n(lazy, MAXN, INF);
}
void push(int v) {
t[v * 2] = min(lazy[v], t[2 * v]);
lazy[v * 2] = min(lazy[v], lazy[2 * v]);
t[v * 2 + 1] = min(t[2 * v + 1], lazy[v]);
lazy[v * 2 + 1] = min(lazy[v], lazy[2 * v + 1]);
// lazy[v] = INF;
}
void update(int v, int tl, int tr, int l, int r, int addend) {
if (l > r)
return;
if (l == tl && tr == r) {
t[v] = min(addend, t[v]);
lazy[v] = min(addend, lazy[v]);
} else {
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), addend);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
int query(int v, int tl, int tr, int l, int r) {
if (l > r)
return INF;
if (l <= tl && tr <= r)
return t[v];
push(v);
int tm = (tl + tr) / 2;
return min(query(v * 2, tl, tm, l, min(r, tm)),
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int n, m, X[MAXN], T[MAXN], P[MAXN], B[MAXN], ans[MAXN];
vector<pair<int, int>> adj[MAXN];
int dist[MAXN];
signed main() {
IOS;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
init();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
adj[l].pb({r, c});
}
update(1, 0, n - 1, 0, 0, 0);
for (int i = 0; i < n; i++) {
dist[i] = query(1, 0, n - 1, i, i);
for (auto t : adj[i]) {
int cur = dist[i] + t.sc;
int l = i, r = t.fs;
update(1, 0, n - 1, l, r, cur);
}
}
if (dist[n - 1] >= INF) {
dist[n - 1] = -1;
}
cout << dist[n - 1] << endl;
return 0;
}
///....
| /// kAAzuki Hoshino
/*
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("unroll-loops")
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
#define int long long
typedef long long ll;
typedef tree<int, null_type, less<int>, rb_tree_tag,
tree_order_statistics_node_update>
ordered_set;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pi;
typedef vector<pi> vpi;
#define INF 100000000000000000
#define mod 1000000007
#define dmp(x) cerr << "line " << __LINE__ << " " << #x << ":" << x << endl
#define fs first
#define sc second
#define pb push_back
#define all(c) (c).begin(), (c).end()
#define mt make_tuple
#define IOS \
ios::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0)
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &p) {
return o << "(" << p.fs << "," << p.sc << ")";
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &vc) {
o << "{";
for (const T &v : vc)
o << v << ",";
o << "}";
return o;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
#define MAXN 1 << 20
int t[MAXN], lazy[MAXN];
void init() {
fill_n(t, MAXN, INF);
fill_n(lazy, MAXN, INF);
}
void push(int v) {
t[v * 2] = min(lazy[v], t[2 * v]);
lazy[v * 2] = min(lazy[v], lazy[2 * v]);
t[v * 2 + 1] = min(t[2 * v + 1], lazy[v]);
lazy[v * 2 + 1] = min(lazy[v], lazy[2 * v + 1]);
// lazy[v] = INF;
}
void update(int v, int tl, int tr, int l, int r, int addend) {
if (l > r)
return;
if (l == tl && tr == r) {
t[v] = min(addend, t[v]);
lazy[v] = min(addend, lazy[v]);
} else {
push(v);
int tm = (tl + tr) / 2;
update(v * 2, tl, tm, l, min(r, tm), addend);
update(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, addend);
t[v] = min(t[v * 2], t[v * 2 + 1]);
}
}
int query(int v, int tl, int tr, int l, int r) {
if (l > r)
return INF;
if (l <= tl && tr <= r)
return t[v];
push(v);
int tm = (tl + tr) / 2;
return min(query(v * 2, tl, tm, l, min(r, tm)),
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r));
}
int n, m, X[MAXN], T[MAXN], P[MAXN], B[MAXN], ans[MAXN];
vector<pair<int, int>> adj[MAXN];
int dist[MAXN];
signed main() {
IOS;
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
init();
cin >> n >> m;
for (int i = 0; i < m; i++) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
adj[l].pb({r, c});
}
update(1, 0, n - 1, 0, 0, 0);
for (int i = 0; i < n; i++) {
dist[i] = query(1, 0, n - 1, i, i);
for (auto t : adj[i]) {
int cur = dist[i] + t.sc;
int l = i, r = t.fs;
update(1, 0, n - 1, l, r, cur);
}
}
if (dist[n - 1] >= INF) {
dist[n - 1] = -1;
}
cout << dist[n - 1] << endl;
return 0;
}
///....
| replace | 47 | 48 | 47 | 48 | 0 | |
p02868 | C++ | Time Limit Exceeded | #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
// #define NDEBUG
#endif
#define __precision__ 10
#define iostream_untie true
#define debug_stream std::cerr
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#define all(v) std::begin(v), std::end(v)
#define rall(v) std::rbegin(v), std::rend(v)
#define odd(n) ((n)&1)
#define even(n) (not __odd(n))
#define __popcount(n) __builtin_popcountll(n)
#define __clz32(n) __builtin_clz(n)
#define __clz64(n) __builtin_clzll(n)
#define __ctz32(n) __builtin_ctz(n)
#define __ctz64(n) __builtin_ctzll(n)
using i32 = int_least32_t;
using i64 = int_least64_t;
using u32 = uint_least32_t;
using u64 = uint_least64_t;
using pii = std::pair<i32, i32>;
using pll = std::pair<i64, i64>;
template <class T> using heap = std::priority_queue<T>;
template <class T>
using rheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class K, class T> using hashmap = std::unordered_map<K, T>;
template <class T> using hashset = std::unordered_set<T>;
namespace execution {
using namespace std::chrono;
system_clock::time_point start_time, end_time;
long long get_elapsed_time() {
end_time = system_clock::now();
return duration_cast<milliseconds>(end_time - start_time).count();
}
void print_elapsed_time() {
std::cerr << "\n----- Exec time : " << get_elapsed_time() << " ms -----\n\n";
}
struct setupper {
setupper() {
if (iostream_untie)
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cout << std::fixed << std::setprecision(__precision__);
#ifdef stderr_path
if (freopen(stderr_path, "a", stderr)) {
std::cerr << std::fixed << std::setprecision(__precision__);
}
#endif
#ifdef stdout_path
if (not freopen(stdout_path, "w", stdout)) {
freopen("CON", "w", stdout);
std::cerr << "Failed to open the stdout file\n\n";
}
std::cout << "";
#endif
#ifdef stdin_path
if (not freopen(stdin_path, "r", stdin)) {
freopen("CON", "r", stdin);
std::cerr << "Failed to open the stdin file\n\n";
}
#endif
#ifdef LOCAL
std::cerr << "----- stderr at LOCAL -----\n\n";
atexit(print_elapsed_time);
#else
fclose(stderr);
#endif
#ifdef __clock__
start_time = system_clock::now();
#endif
}
} __setupper;
class myclock_t {
system_clock::time_point built_pt, last_pt;
int built_ln, last_ln;
std::string built_func, last_func;
bool is_built;
public:
myclock_t() : is_built(false) {}
void build(int crt_ln, const std::string &crt_func) {
is_built = true, last_pt = built_pt = system_clock::now(),
last_ln = built_ln = crt_ln, last_func = built_func = crt_func;
}
void set(int crt_ln, const std::string &crt_func) {
if (is_built)
last_pt = system_clock::now(), last_ln = crt_ln, last_func = crt_func;
else
debug_stream << "[ " << crt_ln << " : " << crt_func << " ] "
<< "myclock_t::set failed (yet to be built!)\n";
}
void get(int crt_ln, const std::string &crt_func) {
if (is_built) {
system_clock::time_point crt_pt(system_clock::now());
long long diff = duration_cast<milliseconds>(crt_pt - last_pt).count();
debug_stream << diff << " ms elapsed from"
<< " [ " << last_ln << " : " << last_func << " ]";
if (last_ln == built_ln)
debug_stream << " (when built)";
debug_stream << " to"
<< " [ " << crt_ln << " : " << crt_func << " ]"
<< "\n";
last_pt = built_pt, last_ln = built_ln, last_func = built_func;
} else {
debug_stream << "[ " << crt_ln << " : " << crt_func << " ] "
<< "myclock_t::get failed (yet to be built!)\n";
}
}
};
} // namespace execution
#ifdef __clock__
execution::myclock_t __myclock;
#define build_clock() __myclock.build(__LINE__, __func__)
#define set_clock() __myclock.set(__LINE__, __func__)
#define get_clock() __myclock.get(__LINE__, __func__)
#else
#define build_clock() ((void)0)
#define set_clock() ((void)0)
#define get_clock() ((void)0)
#endif
namespace std {
template <class P> void rsort(P __first, P __last) {
sort(__first, __last, greater<>());
}
template <class T> size_t hash_combine(size_t seed, T const &key) {
return seed ^ (hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2));
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
return hash_combine(hash_combine(0, pr.first), pr.second);
}
};
template <class tuple_t, size_t index = tuple_size<tuple_t>::value - 1>
struct tuple_hash_calc {
static size_t apply(size_t seed, tuple_t const &t) {
return hash_combine(tuple_hash_calc<tuple_t, index - 1>::apply(seed, t),
get<index>(t));
}
};
template <class tuple_t> struct tuple_hash_calc<tuple_t, 0> {
static size_t apply(size_t seed, tuple_t const &t) {
return hash_combine(seed, get<0>(t));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &t) const {
return tuple_hash_calc<tuple<T...>>::apply(0, t);
}
};
template <class T, class U>
istream &operator>>(std::istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(std::ostream &s, const pair<T, U> &p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v)
s >> e;
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
bool is_front = true;
for (const T &e : v) {
if (not is_front)
s << ' ';
else
is_front = false;
s << e;
}
return s;
}
template <class tuple_t, size_t index> struct tupleos {
static ostream &apply(ostream &s, const tuple_t &t) {
tupleos<tuple_t, index - 1>::apply(s, t);
return s << " " << get<index>(t);
}
};
template <class tuple_t> struct tupleos<tuple_t, 0> {
static ostream &apply(ostream &s, const tuple_t &t) { return s << get<0>(t); }
};
template <class... T> ostream &operator<<(ostream &s, const tuple<T...> &t) {
return tupleos<tuple<T...>, tuple_size<tuple<T...>>::value - 1>::apply(s, t);
}
template <> ostream &operator<<(ostream &s, const tuple<> &t) { return s; }
string revstr(string str) {
reverse(str.begin(), str.end());
return str;
}
} // namespace std
#ifdef LOCAL
#define dump(...) \
debug_stream << "[ " << __LINE__ << " : " << __FUNCTION__ << " ]\n", \
dump_func(#__VA_ARGS__, __VA_ARGS__)
template <class T> void dump_func(const char *ptr, const T &x) {
debug_stream << '\t';
for (char c = *ptr; c != '\0'; c = *++ptr)
if (c != ' ')
debug_stream << c;
debug_stream << " : " << x << '\n';
}
template <class T, class... rest_t>
void dump_func(const char *ptr, const T &x, rest_t... rest) {
debug_stream << '\t';
for (char c = *ptr; c != ','; c = *++ptr)
if (c != ' ')
debug_stream << c;
debug_stream << " : " << x << ",\n";
dump_func(++ptr, rest...);
}
#else
#define dump(...) ((void)0)
#endif
template <class P> void read_range(P __first, P __second) {
for (P i = __first; i != __second; ++i)
std::cin >> *i;
}
template <class P> void write_range(P __first, P __second) {
for (P i = __first; i != __second;
std::cout << (++i == __second ? '\n' : ' '))
std::cout << *i;
}
// substitue y for x if x > y.
template <class T> inline bool sbmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
// substitue y for x if x < y.
template <class T> inline bool sbmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
// binary search.
i64 bin(const std::function<bool(i64)> &pred, i64 ok, i64 ng) {
while (std::abs(ok - ng) > 1) {
i64 mid = (ok + ng) / 2;
(pred(mid) ? ok : ng) = mid;
}
return ok;
}
double bin(const std::function<bool(double)> &pred, double ok, double ng,
const double eps) {
while (std::abs(ok - ng) > eps) {
double mid = (ok + ng) / 2;
(pred(mid) ? ok : ng) = mid;
}
return ok;
}
// be careful that val is type-sensitive.
template <class T, class A, size_t N> void init(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// reset all bits.
template <class A> void reset(A &array) { memset(array, 0, sizeof(array)); }
/* The main code follows. */
using namespace std;
int main() {
void __solve();
u32 t = 1;
#ifdef LOCAL
t = 1;
#endif
// t = -1;
// cin >> t;
while (t--) {
__solve();
}
}
#ifndef LAZY_SEGMENT_TREE_HPP
#define LAZY_SEGMENT_TREE_HPP
template <class Monoid, class Action> class lazy_segment_tree {
using value_type = typename Monoid::value_type;
using operand_type = typename Action::value_type;
Monoid *const monoid_ptr, &monoid;
Action *const action_ptr, &action;
const size_t orig_n, ext_n;
std::vector<value_type> data;
std::vector<operand_type> lazy;
size_t left_node(size_t node) const { return left_node(node); }
size_t right_node(size_t node) const { return right_node(node); }
void recalc(size_t node) {
data[node] = monoid(data[left_node(node)], data[right_node(node)]);
}
void update(size_t begin, size_t end, const operand_type &operand,
size_t node, size_t l, size_t r) {
if (end <= l || r <= begin)
return;
if (begin <= l && r <= end) {
action.act(data[node], operand);
if (node < ext_n)
action(lazy[node], operand);
} else {
update(0, ext_n, lazy[node], left_node(node), l, (l + r) >> 1);
update(0, ext_n, lazy[node], right_node(node), (l + r) >> 1, r);
lazy[node] = action.identity();
update(begin, end, operand, left_node(node), l, (l + r) >> 1);
update(begin, end, operand, right_node(node), (l + r) >> 1, r);
recalc(node);
}
}
void left_bound(size_t idx,
const std::function<bool(const value_type &)> &pred,
size_t node, size_t l, size_t r, value_type &now,
size_t &res) {
if (idx <= l || r < res)
return;
if (r <= idx) {
const value_type nxt = monoid(data[node], now);
if (pred(nxt)) {
res = l, now = nxt;
return;
}
}
if (r - l > 1) {
action(lazy[right_node(node)], lazy[node]);
action.act(data[right_node(node)], lazy[node]);
left_bound(idx, pred, right_node(node), (l + r) >> 1, r, now, res);
action(lazy[left_node(node)], lazy[node]);
action.act(data[left_node(node)], lazy[node]);
left_bound(idx, pred, left_node(node), l, (l + r) >> 1, now, res);
lazy[node] = action.identity();
}
}
void right_bound(size_t idx,
const std::function<bool(const value_type &)> &pred,
size_t node, size_t l, size_t r, value_type &now,
size_t &res) {
if (idx >= r || l > res)
return;
if (l >= idx) {
const value_type nxt = monoid(now, data[node]);
if (pred(nxt)) {
res = r, now = nxt;
return;
}
}
if (r - l > 1) {
action(lazy[left_node(node)], lazy[node]);
action.act(data[left_node(node)], lazy[node]);
right_bound(idx, pred, left_node(node), l, (l + r) >> 1, now, res);
action(lazy[right_node(node)], lazy[node]);
action.act(data[right_node(node)], lazy[node]);
right_bound(idx, pred, right_node(node), (l + r) >> 1, r, now, res);
lazy[node] = action.identity();
}
}
public:
explicit lazy_segment_tree(size_t n)
: monoid_ptr{new Monoid}, monoid{*monoid_ptr},
action_ptr{new Action}, action{*action_ptr}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Monoid &_monoid)
: monoid_ptr{}, monoid{_monoid},
action_ptr{new Action}, action{*action_ptr}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Action &_actor)
: monoid_ptr{new Monoid}, monoid{*monoid_ptr},
action_ptr{}, action{_actor}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Monoid &_monoid, Action &_actor)
: monoid_ptr{}, monoid{_monoid}, action_ptr{}, action{_actor}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
~lazy_segment_tree() {
if (monoid_ptr)
delete monoid_ptr;
if (action_ptr)
delete action_ptr;
}
// copy of value at index i.
value_type operator[](size_t i) { return fold(i, i + 1); }
void build(value_type *__first, value_type *__last) {
std::copy(__first, __last, &data[ext_n]);
for (size_t i = ext_n; i; --i)
recalc(i);
}
template <class iterator> void build(iterator __first, iterator __last) {
static_assert(
std::is_same<typename std::iterator_traits<iterator>::value_type,
value_type>::value,
"iterator's value_type should be equal to Monoid's");
std::copy(__first, __last, &data[ext_n]);
for (size_t i = ext_n - 1; i; --i)
recalc(i);
}
void init(const value_type &x) {
for (size_t i = 0; i != ext_n; ++i)
data[i | ext_n] = x;
for (size_t i = ext_n - 1; i; --i)
recalc(i);
}
void update(size_t index, const operand_type &operand) {
update(index, index + 1, operand);
}
void update(size_t begin, size_t end, const operand_type &operand) {
assert(0 <= begin && end <= orig_n);
update(begin, end, operand, 1, 0, ext_n);
}
value_type fold(size_t begin, size_t end) {
assert(0 <= begin && end <= orig_n);
value_type left_val{monoid.identity()}, right_val{monoid.identity()};
size_t l{begin += ext_n}, r{end += ext_n};
--end;
while (begin >>= 1, end >>= 1) {
if (l < r) {
if (l & 1)
left_val = monoid(left_val, data[l++]);
if (r & 1)
right_val = monoid(data[--r], right_val);
}
action.act(left_val, lazy[begin]);
action.act(right_val, lazy[end]);
l >>= 1, r >>= 1;
}
return monoid(left_val, right_val);
}
// minimum l where range [l, index) meets the condition.
size_t left_bound(size_t index,
const std::function<bool(const value_type &)> &pred) {
assert(index <= orig_n);
size_t res = index;
value_type now = monoid.identity();
left_bound(index, pred, 1, 0, ext_n, now, res);
return res;
}
// maximum r where range [index, r) meets the condition.
size_t right_bound(size_t index,
const std::function<bool(const value_type &)> &pred) {
assert(index < orig_n);
size_t res = index;
value_type now = monoid.identity();
right_bound(index, pred, 1, 0, ext_n, now, res);
return res < orig_n ? res : orig_n;
}
}; // class lazy_segment_tree
#endif
void __solve() {
int n;
cin >> n;
int m;
cin >> m;
vector<vector<pii>> fro(n), to(n);
for (i32 i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
fro[l].emplace_back(r, c);
to[r].emplace_back(l, c);
}
const i64 inf = 1e18;
struct mono {
using value_type = i64;
i64 operator()(i64 x, i64 y) { return min(x, y); }
i64 identity() { return inf; }
};
struct action {
using value_type = i64;
void operator()(i64 &x, i64 y) { x = min(x, y); }
void act(i64 &x, i64 y) { x = min(x, y); }
i64 identity() { return inf; }
};
lazy_segment_tree<mono, action> seg(n);
seg.update(0, 0);
for (i32 i = 0; i < n; ++i) {
for (auto itv : to[i]) {
int l, c;
tie(l, c) = itv;
seg.update(i, seg.fold(l, i) + c);
}
for (auto itv : fro[i]) {
int r, c;
tie(r, c) = itv;
seg.update(i, r + 1, seg[i] + c);
}
}
if (seg[n - 1] != inf) {
cout << seg[n - 1] << "\n";
} else {
cout << -1 << "\n";
}
}
| #ifdef LOCAL
#define _GLIBCXX_DEBUG
#define __clock__
#else
#pragma GCC optimize("Ofast")
// #define NDEBUG
#endif
#define __precision__ 10
#define iostream_untie true
#define debug_stream std::cerr
#include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <complex>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#define all(v) std::begin(v), std::end(v)
#define rall(v) std::rbegin(v), std::rend(v)
#define odd(n) ((n)&1)
#define even(n) (not __odd(n))
#define __popcount(n) __builtin_popcountll(n)
#define __clz32(n) __builtin_clz(n)
#define __clz64(n) __builtin_clzll(n)
#define __ctz32(n) __builtin_ctz(n)
#define __ctz64(n) __builtin_ctzll(n)
using i32 = int_least32_t;
using i64 = int_least64_t;
using u32 = uint_least32_t;
using u64 = uint_least64_t;
using pii = std::pair<i32, i32>;
using pll = std::pair<i64, i64>;
template <class T> using heap = std::priority_queue<T>;
template <class T>
using rheap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class K, class T> using hashmap = std::unordered_map<K, T>;
template <class T> using hashset = std::unordered_set<T>;
namespace execution {
using namespace std::chrono;
system_clock::time_point start_time, end_time;
long long get_elapsed_time() {
end_time = system_clock::now();
return duration_cast<milliseconds>(end_time - start_time).count();
}
void print_elapsed_time() {
std::cerr << "\n----- Exec time : " << get_elapsed_time() << " ms -----\n\n";
}
struct setupper {
setupper() {
if (iostream_untie)
std::ios::sync_with_stdio(false), std::cin.tie(nullptr);
std::cout << std::fixed << std::setprecision(__precision__);
#ifdef stderr_path
if (freopen(stderr_path, "a", stderr)) {
std::cerr << std::fixed << std::setprecision(__precision__);
}
#endif
#ifdef stdout_path
if (not freopen(stdout_path, "w", stdout)) {
freopen("CON", "w", stdout);
std::cerr << "Failed to open the stdout file\n\n";
}
std::cout << "";
#endif
#ifdef stdin_path
if (not freopen(stdin_path, "r", stdin)) {
freopen("CON", "r", stdin);
std::cerr << "Failed to open the stdin file\n\n";
}
#endif
#ifdef LOCAL
std::cerr << "----- stderr at LOCAL -----\n\n";
atexit(print_elapsed_time);
#else
fclose(stderr);
#endif
#ifdef __clock__
start_time = system_clock::now();
#endif
}
} __setupper;
class myclock_t {
system_clock::time_point built_pt, last_pt;
int built_ln, last_ln;
std::string built_func, last_func;
bool is_built;
public:
myclock_t() : is_built(false) {}
void build(int crt_ln, const std::string &crt_func) {
is_built = true, last_pt = built_pt = system_clock::now(),
last_ln = built_ln = crt_ln, last_func = built_func = crt_func;
}
void set(int crt_ln, const std::string &crt_func) {
if (is_built)
last_pt = system_clock::now(), last_ln = crt_ln, last_func = crt_func;
else
debug_stream << "[ " << crt_ln << " : " << crt_func << " ] "
<< "myclock_t::set failed (yet to be built!)\n";
}
void get(int crt_ln, const std::string &crt_func) {
if (is_built) {
system_clock::time_point crt_pt(system_clock::now());
long long diff = duration_cast<milliseconds>(crt_pt - last_pt).count();
debug_stream << diff << " ms elapsed from"
<< " [ " << last_ln << " : " << last_func << " ]";
if (last_ln == built_ln)
debug_stream << " (when built)";
debug_stream << " to"
<< " [ " << crt_ln << " : " << crt_func << " ]"
<< "\n";
last_pt = built_pt, last_ln = built_ln, last_func = built_func;
} else {
debug_stream << "[ " << crt_ln << " : " << crt_func << " ] "
<< "myclock_t::get failed (yet to be built!)\n";
}
}
};
} // namespace execution
#ifdef __clock__
execution::myclock_t __myclock;
#define build_clock() __myclock.build(__LINE__, __func__)
#define set_clock() __myclock.set(__LINE__, __func__)
#define get_clock() __myclock.get(__LINE__, __func__)
#else
#define build_clock() ((void)0)
#define set_clock() ((void)0)
#define get_clock() ((void)0)
#endif
namespace std {
template <class P> void rsort(P __first, P __last) {
sort(__first, __last, greater<>());
}
template <class T> size_t hash_combine(size_t seed, T const &key) {
return seed ^ (hash<T>()(key) + 0x9e3779b9 + (seed << 6) + (seed >> 2));
}
template <class T, class U> struct hash<pair<T, U>> {
size_t operator()(pair<T, U> const &pr) const {
return hash_combine(hash_combine(0, pr.first), pr.second);
}
};
template <class tuple_t, size_t index = tuple_size<tuple_t>::value - 1>
struct tuple_hash_calc {
static size_t apply(size_t seed, tuple_t const &t) {
return hash_combine(tuple_hash_calc<tuple_t, index - 1>::apply(seed, t),
get<index>(t));
}
};
template <class tuple_t> struct tuple_hash_calc<tuple_t, 0> {
static size_t apply(size_t seed, tuple_t const &t) {
return hash_combine(seed, get<0>(t));
}
};
template <class... T> struct hash<tuple<T...>> {
size_t operator()(tuple<T...> const &t) const {
return tuple_hash_calc<tuple<T...>>::apply(0, t);
}
};
template <class T, class U>
istream &operator>>(std::istream &s, pair<T, U> &p) {
return s >> p.first >> p.second;
}
template <class T, class U>
ostream &operator<<(std::ostream &s, const pair<T, U> &p) {
return s << p.first << " " << p.second;
}
template <class T> istream &operator>>(istream &s, vector<T> &v) {
for (T &e : v)
s >> e;
return s;
}
template <class T> ostream &operator<<(ostream &s, const vector<T> &v) {
bool is_front = true;
for (const T &e : v) {
if (not is_front)
s << ' ';
else
is_front = false;
s << e;
}
return s;
}
template <class tuple_t, size_t index> struct tupleos {
static ostream &apply(ostream &s, const tuple_t &t) {
tupleos<tuple_t, index - 1>::apply(s, t);
return s << " " << get<index>(t);
}
};
template <class tuple_t> struct tupleos<tuple_t, 0> {
static ostream &apply(ostream &s, const tuple_t &t) { return s << get<0>(t); }
};
template <class... T> ostream &operator<<(ostream &s, const tuple<T...> &t) {
return tupleos<tuple<T...>, tuple_size<tuple<T...>>::value - 1>::apply(s, t);
}
template <> ostream &operator<<(ostream &s, const tuple<> &t) { return s; }
string revstr(string str) {
reverse(str.begin(), str.end());
return str;
}
} // namespace std
#ifdef LOCAL
#define dump(...) \
debug_stream << "[ " << __LINE__ << " : " << __FUNCTION__ << " ]\n", \
dump_func(#__VA_ARGS__, __VA_ARGS__)
template <class T> void dump_func(const char *ptr, const T &x) {
debug_stream << '\t';
for (char c = *ptr; c != '\0'; c = *++ptr)
if (c != ' ')
debug_stream << c;
debug_stream << " : " << x << '\n';
}
template <class T, class... rest_t>
void dump_func(const char *ptr, const T &x, rest_t... rest) {
debug_stream << '\t';
for (char c = *ptr; c != ','; c = *++ptr)
if (c != ' ')
debug_stream << c;
debug_stream << " : " << x << ",\n";
dump_func(++ptr, rest...);
}
#else
#define dump(...) ((void)0)
#endif
template <class P> void read_range(P __first, P __second) {
for (P i = __first; i != __second; ++i)
std::cin >> *i;
}
template <class P> void write_range(P __first, P __second) {
for (P i = __first; i != __second;
std::cout << (++i == __second ? '\n' : ' '))
std::cout << *i;
}
// substitue y for x if x > y.
template <class T> inline bool sbmin(T &x, const T &y) {
return x > y ? x = y, true : false;
}
// substitue y for x if x < y.
template <class T> inline bool sbmax(T &x, const T &y) {
return x < y ? x = y, true : false;
}
// binary search.
i64 bin(const std::function<bool(i64)> &pred, i64 ok, i64 ng) {
while (std::abs(ok - ng) > 1) {
i64 mid = (ok + ng) / 2;
(pred(mid) ? ok : ng) = mid;
}
return ok;
}
double bin(const std::function<bool(double)> &pred, double ok, double ng,
const double eps) {
while (std::abs(ok - ng) > eps) {
double mid = (ok + ng) / 2;
(pred(mid) ? ok : ng) = mid;
}
return ok;
}
// be careful that val is type-sensitive.
template <class T, class A, size_t N> void init(A (&array)[N], const T &val) {
std::fill((T *)array, (T *)(array + N), val);
}
// reset all bits.
template <class A> void reset(A &array) { memset(array, 0, sizeof(array)); }
/* The main code follows. */
using namespace std;
int main() {
void __solve();
u32 t = 1;
#ifdef LOCAL
t = 1;
#endif
// t = -1;
// cin >> t;
while (t--) {
__solve();
}
}
#ifndef LAZY_SEGMENT_TREE_HPP
#define LAZY_SEGMENT_TREE_HPP
template <class Monoid, class Action> class lazy_segment_tree {
using value_type = typename Monoid::value_type;
using operand_type = typename Action::value_type;
Monoid *const monoid_ptr, &monoid;
Action *const action_ptr, &action;
const size_t orig_n, ext_n;
std::vector<value_type> data;
std::vector<operand_type> lazy;
size_t left_node(size_t node) const { return node << 1; }
size_t right_node(size_t node) const { return node << 1 | 1; }
void recalc(size_t node) {
data[node] = monoid(data[left_node(node)], data[right_node(node)]);
}
void update(size_t begin, size_t end, const operand_type &operand,
size_t node, size_t l, size_t r) {
if (end <= l || r <= begin)
return;
if (begin <= l && r <= end) {
action.act(data[node], operand);
if (node < ext_n)
action(lazy[node], operand);
} else {
update(0, ext_n, lazy[node], left_node(node), l, (l + r) >> 1);
update(0, ext_n, lazy[node], right_node(node), (l + r) >> 1, r);
lazy[node] = action.identity();
update(begin, end, operand, left_node(node), l, (l + r) >> 1);
update(begin, end, operand, right_node(node), (l + r) >> 1, r);
recalc(node);
}
}
void left_bound(size_t idx,
const std::function<bool(const value_type &)> &pred,
size_t node, size_t l, size_t r, value_type &now,
size_t &res) {
if (idx <= l || r < res)
return;
if (r <= idx) {
const value_type nxt = monoid(data[node], now);
if (pred(nxt)) {
res = l, now = nxt;
return;
}
}
if (r - l > 1) {
action(lazy[right_node(node)], lazy[node]);
action.act(data[right_node(node)], lazy[node]);
left_bound(idx, pred, right_node(node), (l + r) >> 1, r, now, res);
action(lazy[left_node(node)], lazy[node]);
action.act(data[left_node(node)], lazy[node]);
left_bound(idx, pred, left_node(node), l, (l + r) >> 1, now, res);
lazy[node] = action.identity();
}
}
void right_bound(size_t idx,
const std::function<bool(const value_type &)> &pred,
size_t node, size_t l, size_t r, value_type &now,
size_t &res) {
if (idx >= r || l > res)
return;
if (l >= idx) {
const value_type nxt = monoid(now, data[node]);
if (pred(nxt)) {
res = r, now = nxt;
return;
}
}
if (r - l > 1) {
action(lazy[left_node(node)], lazy[node]);
action.act(data[left_node(node)], lazy[node]);
right_bound(idx, pred, left_node(node), l, (l + r) >> 1, now, res);
action(lazy[right_node(node)], lazy[node]);
action.act(data[right_node(node)], lazy[node]);
right_bound(idx, pred, right_node(node), (l + r) >> 1, r, now, res);
lazy[node] = action.identity();
}
}
public:
explicit lazy_segment_tree(size_t n)
: monoid_ptr{new Monoid}, monoid{*monoid_ptr},
action_ptr{new Action}, action{*action_ptr}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Monoid &_monoid)
: monoid_ptr{}, monoid{_monoid},
action_ptr{new Action}, action{*action_ptr}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Action &_actor)
: monoid_ptr{new Monoid}, monoid{*monoid_ptr},
action_ptr{}, action{_actor}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
lazy_segment_tree(size_t n, Monoid &_monoid, Action &_actor)
: monoid_ptr{}, monoid{_monoid}, action_ptr{}, action{_actor}, orig_n{n},
ext_n(n > 1 ? 1 << (32 - __builtin_clz(n - 1)) : 1),
data(ext_n << 1, monoid.identity()), lazy(ext_n, action.identity()) {}
~lazy_segment_tree() {
if (monoid_ptr)
delete monoid_ptr;
if (action_ptr)
delete action_ptr;
}
// copy of value at index i.
value_type operator[](size_t i) { return fold(i, i + 1); }
void build(value_type *__first, value_type *__last) {
std::copy(__first, __last, &data[ext_n]);
for (size_t i = ext_n; i; --i)
recalc(i);
}
template <class iterator> void build(iterator __first, iterator __last) {
static_assert(
std::is_same<typename std::iterator_traits<iterator>::value_type,
value_type>::value,
"iterator's value_type should be equal to Monoid's");
std::copy(__first, __last, &data[ext_n]);
for (size_t i = ext_n - 1; i; --i)
recalc(i);
}
void init(const value_type &x) {
for (size_t i = 0; i != ext_n; ++i)
data[i | ext_n] = x;
for (size_t i = ext_n - 1; i; --i)
recalc(i);
}
void update(size_t index, const operand_type &operand) {
update(index, index + 1, operand);
}
void update(size_t begin, size_t end, const operand_type &operand) {
assert(0 <= begin && end <= orig_n);
update(begin, end, operand, 1, 0, ext_n);
}
value_type fold(size_t begin, size_t end) {
assert(0 <= begin && end <= orig_n);
value_type left_val{monoid.identity()}, right_val{monoid.identity()};
size_t l{begin += ext_n}, r{end += ext_n};
--end;
while (begin >>= 1, end >>= 1) {
if (l < r) {
if (l & 1)
left_val = monoid(left_val, data[l++]);
if (r & 1)
right_val = monoid(data[--r], right_val);
}
action.act(left_val, lazy[begin]);
action.act(right_val, lazy[end]);
l >>= 1, r >>= 1;
}
return monoid(left_val, right_val);
}
// minimum l where range [l, index) meets the condition.
size_t left_bound(size_t index,
const std::function<bool(const value_type &)> &pred) {
assert(index <= orig_n);
size_t res = index;
value_type now = monoid.identity();
left_bound(index, pred, 1, 0, ext_n, now, res);
return res;
}
// maximum r where range [index, r) meets the condition.
size_t right_bound(size_t index,
const std::function<bool(const value_type &)> &pred) {
assert(index < orig_n);
size_t res = index;
value_type now = monoid.identity();
right_bound(index, pred, 1, 0, ext_n, now, res);
return res < orig_n ? res : orig_n;
}
}; // class lazy_segment_tree
#endif
void __solve() {
int n;
cin >> n;
int m;
cin >> m;
vector<vector<pii>> fro(n), to(n);
for (i32 i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
fro[l].emplace_back(r, c);
to[r].emplace_back(l, c);
}
const i64 inf = 1e18;
struct mono {
using value_type = i64;
i64 operator()(i64 x, i64 y) { return min(x, y); }
i64 identity() { return inf; }
};
struct action {
using value_type = i64;
void operator()(i64 &x, i64 y) { x = min(x, y); }
void act(i64 &x, i64 y) { x = min(x, y); }
i64 identity() { return inf; }
};
lazy_segment_tree<mono, action> seg(n);
seg.update(0, 0);
for (i32 i = 0; i < n; ++i) {
for (auto itv : to[i]) {
int l, c;
tie(l, c) = itv;
seg.update(i, seg.fold(l, i) + c);
}
for (auto itv : fro[i]) {
int r, c;
tie(r, c) = itv;
seg.update(i, r + 1, seg[i] + c);
}
}
if (seg[n - 1] != inf) {
cout << seg[n - 1] << "\n";
} else {
cout << -1 << "\n";
}
}
| replace | 311 | 313 | 311 | 313 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T> vector<T> gen_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto gen_v(size_t a, Ts... ts) {
return vector<decltype(gen_v<T>(ts...))>(a, gen_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class T, class... Tail>
void tiedSort(vector<T> &a, vector<Tail> &...tail) {
int n = a.size();
using S = tuple<T, Tail...>;
vector<S> s(n);
for (int i = 0; i < n; i++)
s[i] = make_tuple(a[i], tail[i]...);
sort(s.begin(), s.end());
for (int i = 0; i < n; i++)
tie(a[i], tail[i]...) = s[i];
}
struct RangeUpdateQuery {
int n;
vector<int> d;
vector<int> timestamp;
int time;
RangeUpdateQuery(int m) {
for (n = 1; n < m; n *= 2)
;
d.assign(n * 2, INF);
time = 0;
timestamp.assign(n * 2, 0);
}
void update(int l, int r, int x) {
time++;
for (; l && l + (l & -l) <= r; l += l & -l) {
d[(n + l) / (l & -l)] = x;
timestamp[(n + l) / (l & -l)] = time;
}
for (; l < r; r -= r & -r) {
d[(n + r) / (r & -r) - 1] = x;
timestamp[(n + r) / (r & -r) - 1] = time;
}
}
int get(int i) {
int ret = d[n + i];
int max_time = timestamp[n + i];
for (int j = (n + i) / 2; j > 0; j >>= 1) {
if (max_time > timestamp[j])
continue;
max_time = timestamp[j];
ret = d[j];
}
return ret;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> L(M), R(M), C(M);
rep(i, 0, M) {
cin >> L[i] >> R[i] >> C[i];
L[i]--;
}
tiedSort(L, R, C);
RangeUpdateQuery ruq(N);
ruq.update(0, 1, 0);
rep(i, 0, M) {
dump(i, L[i], R[i], C[i]);
int mini = ruq.get(L[i]);
if (mini == INF) {
cout << -1 << endl;
return 0;
}
int c = mini + C[i];
auto f = [&](int x) { return ruq.get(x) > c; };
auto binarySearch = [&](int ng, int ok) {
if (f(ng))
return ng;
while (ng + 1 < ok) {
int m = (ng + ok) / 2;
if (f(m))
ok = m;
else
ng = m;
}
return ok;
};
int l = binarySearch(L[i], N);
dump(l);
dump(ruq.get(l));
vector<int> tmp(N);
rep(i, 0, N) { tmp[i] = ruq.get(i); }
dump(tmp);
ruq.update(l, R[i], c);
}
int ans = ruq.get(N - 1);
if (ans == INF)
ans = -1;
cout << ans << endl;
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
#define int long long
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = 1000000007;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
template <typename T> vector<T> gen_v(size_t a) { return vector<T>(a); }
template <typename T, typename... Ts> auto gen_v(size_t a, Ts... ts) {
return vector<decltype(gen_v<T>(ts...))>(a, gen_v<T>(ts...));
}
template <typename T, typename V>
typename enable_if<is_class<T>::value == 0>::type fill_v(T &t, const V &v) {
t = v;
}
template <typename T, typename V>
typename enable_if<is_class<T>::value != 0>::type fill_v(T &t, const V &v) {
for (auto &e : t)
fill_v(e, v);
}
template <class T, class... Tail>
void tiedSort(vector<T> &a, vector<Tail> &...tail) {
int n = a.size();
using S = tuple<T, Tail...>;
vector<S> s(n);
for (int i = 0; i < n; i++)
s[i] = make_tuple(a[i], tail[i]...);
sort(s.begin(), s.end());
for (int i = 0; i < n; i++)
tie(a[i], tail[i]...) = s[i];
}
struct RangeUpdateQuery {
int n;
vector<int> d;
vector<int> timestamp;
int time;
RangeUpdateQuery(int m) {
for (n = 1; n < m; n *= 2)
;
d.assign(n * 2, INF);
time = 0;
timestamp.assign(n * 2, 0);
}
void update(int l, int r, int x) {
time++;
for (; l && l + (l & -l) <= r; l += l & -l) {
d[(n + l) / (l & -l)] = x;
timestamp[(n + l) / (l & -l)] = time;
}
for (; l < r; r -= r & -r) {
d[(n + r) / (r & -r) - 1] = x;
timestamp[(n + r) / (r & -r) - 1] = time;
}
}
int get(int i) {
int ret = d[n + i];
int max_time = timestamp[n + i];
for (int j = (n + i) / 2; j > 0; j >>= 1) {
if (max_time > timestamp[j])
continue;
max_time = timestamp[j];
ret = d[j];
}
return ret;
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
int N, M;
cin >> N >> M;
vector<int> L(M), R(M), C(M);
rep(i, 0, M) {
cin >> L[i] >> R[i] >> C[i];
L[i]--;
}
tiedSort(L, R, C);
RangeUpdateQuery ruq(N);
ruq.update(0, 1, 0);
rep(i, 0, M) {
dump(i, L[i], R[i], C[i]);
int mini = ruq.get(L[i]);
if (mini == INF) {
cout << -1 << endl;
return 0;
}
int c = mini + C[i];
auto f = [&](int x) { return ruq.get(x) > c; };
auto binarySearch = [&](int ng, int ok) {
if (f(ng))
return ng;
while (ng + 1 < ok) {
int m = (ng + ok) / 2;
if (f(m))
ok = m;
else
ng = m;
}
return ok;
};
int l = binarySearch(L[i], N);
dump(l);
dump(ruq.get(l));
// vector<int> tmp(N);
// rep(i, 0, N) {
// tmp[i] = ruq.get(i);
// }
// dump(tmp);
ruq.update(l, R[i], c);
}
int ans = ruq.get(N - 1);
if (ans == INF)
ans = -1;
cout << ans << endl;
return 0;
} | replace | 135 | 138 | 135 | 140 | TLE | |
p02868 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <iostream>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF bit(60)
#define pb push_back
#define mod 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
using tTree = __gnu_pbds::tree<ll, __gnu_pbds::null_type, less<ll>,
__gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
using pa = pair<ll, ll>;
int qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
} while (b >>= 1);
return ans;
}
int qp(int a, ll b, int mo) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define FACSIZE 2002
ll invfac[FACSIZE];
ll fac[FACSIZE];
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
void make_fact(ll);
void make_invfact(ll);
struct edge {
ll to;
ll cost;
};
int main(void) {
ll n, m;
cin >> n >> m;
vector<ll> L(n);
vector<ll> R(n);
vector<ll> C(n);
rep(i, m) cin >> L[i] >> R[i] >> C[i];
vector<vector<edge>> graph(n + 1, vector<edge>());
rep(i, m) {
edge e;
e.to = R[i];
e.cost = C[i];
graph[L[i]].push_back(e);
}
for (ll i = n - 1; i > 0; i--) {
edge e;
e.to = i;
e.cost = 0;
graph[i + 1].push_back(e);
}
/*
for (auto v : graph)
{
for (auto x : v)
{
cout << x.to << "," << x.cost << endl;
}
}
//*/
vector<ll> dis(n + 1, LLONG_MAX);
dis[1] = 0;
priority_queue<pa, vector<pa>, greater<pa>> pque;
pque.push(make_pair(0, 1));
while (!pque.empty()) {
auto pq = pque.top();
pque.pop();
for (auto x : graph[pq.second]) {
if (dis[x.to] > dis[pq.second] + x.cost) {
dis[x.to] = dis[pq.second] + x.cost;
pque.push(make_pair(dis[x.to], x.to));
}
}
}
/*
for (auto x : dis)
cout << x << " ";
cout << endl;
//*/
if (dis[n] == LLONG_MAX)
cout << -1 << endl;
else
cout << dis[n] << endl;
return 0;
}
ll mod_pow(ll x, ll r) {
if (r == 0)
return 1;
else if (r == 1)
return x % mod;
else if (r % 2 == 0) {
ll t = mod_pow(x, r / 2) % mod;
return t * t % mod;
} else {
ll t = mod_pow(x, r / 2) % mod;
ll k = t * t % mod;
return k * x % mod;
}
}
ll mod_add(ll a, ll b) { return (a + b) % mod; }
ll mod_mul(ll a, ll b) { return (a * b) % mod; }
ll mod_div(ll a, ll b) { return mod_mul(a, mod_pow(b, mod - 2)); }
void make_fact(ll n) {
fac[0] = 1;
rep(i, n) { fac[i + 1] = mod_mul(fac[i], i + 1); }
}
void make_invfact(ll n) {
invfac[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) {
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
} | #include <bits/stdc++.h>
#include <iostream>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define rep_r(i, n) for (int i = n - 1; i >= 0; i--)
#define rep1(i, n) for (int i = 1; i <= (int)(n); i++)
#define REP(i, n) for (int i = 0, i##_len = (n); i < i##_len; ++i)
#define all(x) (x).begin(), (x).end()
#define SZ(x) ((ll)(x).size())
#define bit(n) (1LL << (n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());
#define INF bit(60)
#define pb push_back
#define mod 1000000007
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
using namespace std;
using uif = uint_fast64_t;
using ll = long long int;
using tTree = __gnu_pbds::tree<ll, __gnu_pbds::null_type, less<ll>,
__gnu_pbds::rb_tree_tag,
__gnu_pbds::tree_order_statistics_node_update>;
using pa = pair<ll, ll>;
int qp(int a, ll b) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mod;
a = 1ll * a * a % mod;
} while (b >>= 1);
return ans;
}
int qp(int a, ll b, int mo) {
int ans = 1;
do {
if (b & 1)
ans = 1ll * ans * a % mo;
a = 1ll * a * a % mo;
} while (b >>= 1);
return ans;
}
int gcd(int a, int b) { return b ? gcd(b, a % b) : a; }
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
#define FACSIZE 2002
ll invfac[FACSIZE];
ll fac[FACSIZE];
ll mod_pow(ll, ll);
ll mod_add(ll, ll);
ll mod_mul(ll, ll);
ll mod_div(ll, ll);
void make_fact(ll);
void make_invfact(ll);
struct edge {
ll to;
ll cost;
};
int main(void) {
ll n, m;
cin >> n >> m;
vector<ll> L(m);
vector<ll> R(m);
vector<ll> C(m);
rep(i, m) cin >> L[i] >> R[i] >> C[i];
vector<vector<edge>> graph(n + 1, vector<edge>());
rep(i, m) {
edge e;
e.to = R[i];
e.cost = C[i];
graph[L[i]].push_back(e);
}
for (ll i = n - 1; i > 0; i--) {
edge e;
e.to = i;
e.cost = 0;
graph[i + 1].push_back(e);
}
/*
for (auto v : graph)
{
for (auto x : v)
{
cout << x.to << "," << x.cost << endl;
}
}
//*/
vector<ll> dis(n + 1, LLONG_MAX);
dis[1] = 0;
priority_queue<pa, vector<pa>, greater<pa>> pque;
pque.push(make_pair(0, 1));
while (!pque.empty()) {
auto pq = pque.top();
pque.pop();
for (auto x : graph[pq.second]) {
if (dis[x.to] > dis[pq.second] + x.cost) {
dis[x.to] = dis[pq.second] + x.cost;
pque.push(make_pair(dis[x.to], x.to));
}
}
}
/*
for (auto x : dis)
cout << x << " ";
cout << endl;
//*/
if (dis[n] == LLONG_MAX)
cout << -1 << endl;
else
cout << dis[n] << endl;
return 0;
}
ll mod_pow(ll x, ll r) {
if (r == 0)
return 1;
else if (r == 1)
return x % mod;
else if (r % 2 == 0) {
ll t = mod_pow(x, r / 2) % mod;
return t * t % mod;
} else {
ll t = mod_pow(x, r / 2) % mod;
ll k = t * t % mod;
return k * x % mod;
}
}
ll mod_add(ll a, ll b) { return (a + b) % mod; }
ll mod_mul(ll a, ll b) { return (a * b) % mod; }
ll mod_div(ll a, ll b) { return mod_mul(a, mod_pow(b, mod - 2)); }
void make_fact(ll n) {
fac[0] = 1;
rep(i, n) { fac[i + 1] = mod_mul(fac[i], i + 1); }
}
void make_invfact(ll n) {
invfac[n] = mod_pow(fac[n], mod - 2);
for (int i = n - 1; i >= 0; i--) {
invfac[i] = mod_mul(invfac[i + 1], i + 1);
}
} | replace | 86 | 89 | 86 | 89 | 0 | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100005;
const ll INF = 1e15;
struct edge {
int to, cost;
};
vector<edge> G[MAX_N];
ll d[MAX_N];
void init() {
rep(i, MAX_N) { d[i] = INF; }
}
int main() {
init();
int N, M;
edge e;
cin >> N >> M;
rep(i, N - 1) {
e.to = i;
e.cost = 0;
G[i + 1].push_back(e);
}
rep(i, M) {
int l, r, c;
cin >> l >> r >> c;
e.to = r - 1;
e.cost = c;
G[l - 1].push_back(e);
}
priority_queue<P, vector<P>, greater<P>> Q;
d[0] = 0;
Q.push(P(0, 0));
while (!Q.empty()) {
P p = Q.top();
Q.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;
Q.push(P(d[e.to], e.to));
}
}
}
if (d[N - 1] == INF)
cout << "-1" << endl;
else
cout << d[N - 1] << endl;
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
const int MAX_N = 100005;
const ll INF = 1e15;
struct edge {
int to, cost;
};
vector<edge> G[MAX_N];
ll d[MAX_N];
void init() {
rep(i, MAX_N) { d[i] = INF; }
}
int main() {
init();
int N, M;
edge e;
cin >> N >> M;
rep(i, N - 1) {
e.to = i;
e.cost = 0;
G[i + 1].push_back(e);
}
rep(i, M) {
int l, r, c;
cin >> l >> r >> c;
e.to = r - 1;
e.cost = c;
G[l - 1].push_back(e);
}
priority_queue<P, vector<P>, greater<P>> Q;
d[0] = 0;
Q.push(P(0, 0));
while (!Q.empty()) {
P p = Q.top();
Q.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;
Q.push(P(d[e.to], e.to));
}
}
}
if (d[N - 1] == INF)
cout << "-1" << endl;
else
cout << d[N - 1] << endl;
return 0;
} | replace | 4 | 5 | 4 | 5 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <algorithm>
#include <complex>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define REP(i, m, n) for (int i = int(m); i < int(n); i++)
#define RREP(i, m, n) for (int i = int(n) - 1; i >= int(m); --i)
#define EACH(i, c) for (auto &(i) : c)
#define all(c) begin(c), end(c)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(begin(c), end(c))
#define pb emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#ifdef LOCAL
#define DEBUG(s) cout << (s) << endl
#define dump(x) cerr << #x << " = " << (x) << endl
#define BR cout << endl;
#else
#define DEBUG(s) \
do { \
} while (0)
#define dump(x) \
do { \
} while (0)
#define BR
#endif
using namespace std;
using UI = unsigned int;
using UL = unsigned long;
using LL = long long int;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int, int>;
using VP = vector<PII>;
struct edge {
int to, cost;
edge(int to, int cost) : to(to), cost(cost) {}
};
constexpr LL INF = 1LL << 60;
template <typename T = pair<int, LL>>
void Dijkstra(int s, vector<vector<edge>> &g, vector<LL> &d) {
int numv = d.size();
priority_queue<T, vector<T>, greater<T>> q;
for (int i = 0; i < numv; ++i)
d[i] = INF;
d[s] = 0;
q.emplace(0, s);
while (!q.empty()) {
T p = q.top();
q.pop();
LL v = p.second; // vertex
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;
q.emplace(d[e.to], e.to);
}
}
}
}
void solve() {
int n, m, l, r, c;
cin >> n >> m;
vector<vector<edge>> es(n);
REP(i, 0, m) {
cin >> l >> r >> c;
--l;
--r;
es[l].pb(r, c);
}
REP(i, 1, n) es[i].pb(i - 1, 0);
VLL d(n);
Dijkstra(0, es, d);
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << d[n - 1] << endl;
}
int main() {
solve();
return 0;
} | #include <algorithm>
#include <complex>
#include <cstdio>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define REP(i, m, n) for (int i = int(m); i < int(n); i++)
#define RREP(i, m, n) for (int i = int(n) - 1; i >= int(m); --i)
#define EACH(i, c) for (auto &(i) : c)
#define all(c) begin(c), end(c)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(begin(c), end(c))
#define pb emplace_back
#define MP make_pair
#define SZ(a) int((a).size())
#ifdef LOCAL
#define DEBUG(s) cout << (s) << endl
#define dump(x) cerr << #x << " = " << (x) << endl
#define BR cout << endl;
#else
#define DEBUG(s) \
do { \
} while (0)
#define dump(x) \
do { \
} while (0)
#define BR
#endif
using namespace std;
using UI = unsigned int;
using UL = unsigned long;
using LL = long long int;
using ULL = unsigned long long;
using VI = vector<int>;
using VVI = vector<VI>;
using VLL = vector<LL>;
using VVLL = vector<VLL>;
using VS = vector<string>;
using PII = pair<int, int>;
using VP = vector<PII>;
struct edge {
int to, cost;
edge(int to, int cost) : to(to), cost(cost) {}
};
constexpr LL INF = 1LL << 60;
template <typename T = pair<LL, int>>
void Dijkstra(int s, vector<vector<edge>> &g, vector<LL> &d) {
int numv = d.size();
priority_queue<T, vector<T>, greater<T>> q;
for (int i = 0; i < numv; ++i)
d[i] = INF;
d[s] = 0;
q.emplace(0, s);
while (!q.empty()) {
T p = q.top();
q.pop();
LL v = p.second; // vertex
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;
q.emplace(d[e.to], e.to);
}
}
}
}
void solve() {
int n, m, l, r, c;
cin >> n >> m;
vector<vector<edge>> es(n);
REP(i, 0, m) {
cin >> l >> r >> c;
--l;
--r;
es[l].pb(r, c);
}
REP(i, 1, n) es[i].pb(i - 1, 0);
VLL d(n);
Dijkstra(0, es, d);
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << d[n - 1] << endl;
}
int main() {
solve();
return 0;
} | replace | 61 | 62 | 61 | 62 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
#define p_ary(ary, a, b) \
do { \
cout << "["; \
for (int count = (a); count < (b); ++count) \
cout << ary[count] << ((b)-1 == count ? "" : ", "); \
cout << "]\n"; \
} while (0)
#define p_map(map, it) \
do { \
cout << "{"; \
for (auto(it) = map.begin();; ++(it)) { \
if ((it) == map.end()) { \
cout << "}\n"; \
break; \
} else \
cout << "" << (it)->first << "=>" << (it)->second << ", "; \
} \
} while (0)
int MAX_N = 100010;
ll INF = 1LL << 60;
vector<vector<P>> edges(MAX_N);
vector<ll> dist(MAX_N, INF);
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < edges[v].size(); ++i) {
P e = edges[v][i];
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
que.push(P(dist[e.first], e.first));
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
edges[l - 1].push_back(P(r - 1, c));
}
for (int i = 1; i < n; ++i)
edges[i].push_back(P(i - 1, 0));
dijkstra(0);
cout << (dist[n - 1] < INF ? dist[n - 1] : -1) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
#define p_ary(ary, a, b) \
do { \
cout << "["; \
for (int count = (a); count < (b); ++count) \
cout << ary[count] << ((b)-1 == count ? "" : ", "); \
cout << "]\n"; \
} while (0)
#define p_map(map, it) \
do { \
cout << "{"; \
for (auto(it) = map.begin();; ++(it)) { \
if ((it) == map.end()) { \
cout << "}\n"; \
break; \
} else \
cout << "" << (it)->first << "=>" << (it)->second << ", "; \
} \
} while (0)
int MAX_N = 100010;
ll INF = 1LL << 60;
vector<vector<P>> edges(MAX_N);
vector<ll> dist(MAX_N, INF);
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < edges[v].size(); ++i) {
P e = edges[v][i];
if (dist[e.first] > dist[v] + e.second) {
dist[e.first] = dist[v] + e.second;
que.push(P(dist[e.first], e.first));
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
for (int i = 0; i < m; ++i) {
int l, r, c;
cin >> l >> r >> c;
edges[l - 1].push_back(P(r - 1, c));
}
for (int i = 1; i < n; ++i)
edges[i].push_back(P(i - 1, 0));
dijkstra(0);
cout << (dist[n - 1] < INF ? dist[n - 1] : -1) << endl;
return 0;
} | replace | 4 | 5 | 4 | 5 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) (v).begin(), (v).end()
#define chmin(x, y) x = min(x, y)
typedef pair<int, int> P;
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const ll MOD = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<int, int, ll>> LRC(M);
int l, r;
ll c;
rep(i, M) {
cin >> l >> r >> c;
--l, --r;
LRC[i] = forward_as_tuple(l, r, c);
}
sort(all(LRC));
vector<ll> dp(N, LINF);
dp[0] = 0;
rep(i, M) {
tie(l, r, c) = LRC[i];
// cout << l << r << c << endl;
if (dp[l] == LINF)
continue;
for (int j = l + 1; j <= r; j++) {
dp[j] = min(dp[j], dp[l] + c);
}
}
// rep(j, N) cout << dp[j] << ' ';
if (dp[N - 1] == LINF)
cout << -1 << endl;
else
cout << dp[N - 1] << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define all(v) (v).begin(), (v).end()
#define chmin(x, y) x = min(x, y)
typedef pair<int, int> P;
typedef long long ll;
const int INF = 1001001001;
const ll LINF = 1001002003004005006ll;
const ll MOD = 1e9 + 7;
int main() {
int N, M;
cin >> N >> M;
vector<tuple<int, int, ll>> LRC(M);
int l, r;
ll c;
rep(i, M) {
cin >> l >> r >> c;
--l, --r;
LRC[i] = forward_as_tuple(l, r, c);
}
sort(all(LRC));
vector<ll> dp(N, LINF);
dp[0] = 0;
rep(i, M) {
tie(l, r, c) = LRC[i];
// cout << l << r << c << endl;
if (dp[l] == LINF)
continue;
for (int j = r; j > l; j--) {
if (dp[j] > dp[l] + c)
dp[j] = dp[l] + c;
else
break;
}
}
// rep(j, N) cout << dp[j] << ' ';
if (dp[N - 1] == LINF)
cout << -1 << endl;
else
cout << dp[N - 1] << endl;
return 0;
}
| replace | 33 | 35 | 33 | 38 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include "stdio.h"
#include <algorithm>
#include <bitset>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
using Pii = pair<int, int>;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 50;
const long long mod_const = 1e9 + 7;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
using MIte = multimap<ll, ll, greater<ll>>::iterator;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using pll = pair<long long, long long>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, pll>> vpath(M);
rep(i, M) {
ll l, r, c;
cin >> l >> r >> c;
l--;
r--;
vpath[i] = make_pair(l, make_pair(r, c));
}
sort(vpath.begin(), vpath.end());
vector<ll> vLen(N, longinf);
vLen[0] = 0;
rep(i, M) {
ll start = vpath[i].first;
ll end = vpath[i].second.first;
ll d = vpath[i].second.second;
if (start == 0) {
for (int j = start + 1; j <= end; ++j) {
vLen[j] = min(vLen[j], vLen[start] + d);
}
} else {
if (vLen[start] != longinf) {
for (int j = start + 1; j <= end; ++j) {
vLen[j] = min(vLen[j], vLen[start] + d);
}
}
}
}
if (vLen[N - 1] == longinf) {
cout << "-1" << endl;
} else {
cout << vLen[N - 1] << endl;
}
return 0;
}
| #include "stdio.h"
#include <algorithm>
#include <bitset>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <limits.h>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define rep(i, n) REP(i, 0, n)
using ll = long long;
using Pii = pair<int, int>;
const int inf = 1e9 + 7;
const ll longinf = 1LL << 50;
const long long mod_const = 1e9 + 7;
int dy[] = {0, 0, 1, -1, 0};
int dx[] = {1, -1, 0, 0, 0};
using MIte = multimap<ll, ll, greater<ll>>::iterator;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
using pll = pair<long long, long long>;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
ll N, M;
cin >> N >> M;
vector<pair<ll, pll>> vpath(M);
rep(i, M) {
ll l, r, c;
cin >> l >> r >> c;
l--;
r--;
vpath[i] = make_pair(l, make_pair(r, c));
}
sort(vpath.begin(), vpath.end());
vector<ll> vLen(N, longinf);
vLen[0] = 0;
rep(i, M) {
ll start = vpath[i].first;
ll end = vpath[i].second.first;
ll d = vpath[i].second.second;
if (start == 0) {
for (int j = start + 1; j <= end; ++j) {
vLen[j] = min(vLen[j], vLen[start] + d);
}
} else {
if (vLen[start] != longinf) {
if (vLen[start] + d <= vLen[end]) {
for (int j = start + 1; j <= end; ++j) {
vLen[j] = min(vLen[j], vLen[start] + d);
}
}
}
}
}
if (vLen[N - 1] == longinf) {
cout << "-1" << endl;
} else {
cout << vLen[N - 1] << endl;
}
return 0;
}
| replace | 85 | 87 | 85 | 89 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
class CompareDist {
public:
bool operator()(pair<int, int> n1, pair<int, int> n2) {
return n1.second < n2.second;
}
};
class Dijkstra { // O((N+M)logN)
private:
static const int INF = 1e9 + 7;
vector<vector<pair<long long, int>>> graph; // pair<cost,next_path>
vector<long long> total_cost;
vector<vector<int>> shortest_path;
public:
Dijkstra(vector<vector<pair<long long, int>>> graph, int start, int size,
bool path_check = false) {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
// greater<pair<long long,int>>> q;
CompareDist>
q;
vector<long long> cost(size, 1e18 + 7);
vector<vector<int>> path(size);
if (path_check)
for (int i = 0; i < size; i++)
path[i].push_back(i); // 自分は必ず通る
cost[start] = 0;
q.push(make_pair(0ll, start));
while (!q.empty()) {
auto now = q.top();
q.pop();
int prev = now.second;
if (cost[prev] < now.first)
continue;
for (auto next : graph[prev]) {
if (cost[next.second] <= cost[now.second] + next.first)
continue;
cost[next.second] = cost[now.second] + next.first;
// 先頭からpathを追加
// if(path_check)
// path[next.second].insert(path[next.second].begin(),path[now.second].begin(),path[now.second].end());
q.push(next);
}
}
total_cost = cost;
if (path_check)
shortest_path = path;
}
vector<long long> get_cost() { return total_cost; }
vector<vector<int>> get_path() { return shortest_path; }
};
#define ll long long
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
// 長さ、次の場所のペア
vector<vector<pair<ll, int>>> graph(n);
rep(i, 0, m) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
graph[l].push_back(make_pair(c, r));
}
rep(i, 1, n) graph[i].push_back(make_pair(0, i - 1));
Dijkstra g(graph, 0, n);
if (g.get_cost()[n - 1] == inf)
cout << -1 << endl;
else
cout << g.get_cost()[n - 1] << endl;
/*
vector<ll> ans = Dijk(graph,0,n);
if(ans[n-1] == inf) cout << -1 << endl;
else cout << ans[n-1] << endl;
*/
} | #include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18 + 7;
class CompareDist {
public:
bool operator()(pair<int, int> n1, pair<int, int> n2) {
return n1.second > n2.second;
}
};
class Dijkstra { // O((N+M)logN)
private:
static const int INF = 1e9 + 7;
vector<vector<pair<long long, int>>> graph; // pair<cost,next_path>
vector<long long> total_cost;
vector<vector<int>> shortest_path;
public:
Dijkstra(vector<vector<pair<long long, int>>> graph, int start, int size,
bool path_check = false) {
priority_queue<pair<long long, int>, vector<pair<long long, int>>,
// greater<pair<long long,int>>> q;
CompareDist>
q;
vector<long long> cost(size, 1e18 + 7);
vector<vector<int>> path(size);
if (path_check)
for (int i = 0; i < size; i++)
path[i].push_back(i); // 自分は必ず通る
cost[start] = 0;
q.push(make_pair(0ll, start));
while (!q.empty()) {
auto now = q.top();
q.pop();
int prev = now.second;
if (cost[prev] < now.first)
continue;
for (auto next : graph[prev]) {
if (cost[next.second] <= cost[now.second] + next.first)
continue;
cost[next.second] = cost[now.second] + next.first;
// 先頭からpathを追加
// if(path_check)
// path[next.second].insert(path[next.second].begin(),path[now.second].begin(),path[now.second].end());
q.push(next);
}
}
total_cost = cost;
if (path_check)
shortest_path = path;
}
vector<long long> get_cost() { return total_cost; }
vector<vector<int>> get_path() { return shortest_path; }
};
#define ll long long
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, m;
cin >> n >> m;
// 長さ、次の場所のペア
vector<vector<pair<ll, int>>> graph(n);
rep(i, 0, m) {
int l, r, c;
cin >> l >> r >> c;
l--;
r--;
graph[l].push_back(make_pair(c, r));
}
rep(i, 1, n) graph[i].push_back(make_pair(0, i - 1));
Dijkstra g(graph, 0, n);
if (g.get_cost()[n - 1] == inf)
cout << -1 << endl;
else
cout << g.get_cost()[n - 1] << endl;
/*
vector<ll> ans = Dijk(graph,0,n);
if(ans[n-1] == inf) cout << -1 << endl;
else cout << ans[n-1] << endl;
*/
} | replace | 7 | 8 | 7 | 8 | TLE | |
p02868 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using P = pair<int, int>;
struct edge {
int to;
long long cost;
};
const long long INF = 1ll << 60;
const int MAX_V = 100000;
int V;
vector<edge> G[MAX_V + 1];
long long d[MAX_V + 1];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.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;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
V = n;
for (int i = 0; i < m; i++) {
int l, r;
long long c;
cin >> l >> r >> c;
l--;
r--;
G[l].push_back(edge{r, c});
}
for (int i = 0; i < n - 1; i++) {
G[i + 1].push_back(edge{i, 0});
}
dijkstra(0);
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << d[n - 1] << endl;
} | #include <bits/stdc++.h>
using namespace std;
using P = pair<long long, int>;
struct edge {
int to;
long long cost;
};
const long long INF = 1ll << 60;
const int MAX_V = 100000;
int V;
vector<edge> G[MAX_V + 1];
long long d[MAX_V + 1];
void dijkstra(int s) {
priority_queue<P, vector<P>, greater<P>> que;
fill(d, d + V, INF);
d[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.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;
que.push(P(d[e.to], e.to));
}
}
}
}
int main() {
int n, m;
cin >> n >> m;
V = n;
for (int i = 0; i < m; i++) {
int l, r;
long long c;
cin >> l >> r >> c;
l--;
r--;
G[l].push_back(edge{r, c});
}
for (int i = 0; i < n - 1; i++) {
G[i + 1].push_back(edge{i, 0});
}
dijkstra(0);
if (d[n - 1] == INF)
cout << -1 << endl;
else
cout << d[n - 1] << endl;
} | replace | 3 | 4 | 3 | 4 | TLE | |
p02868 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
// 遅延伝播セグ木
template <class T, class U> class LazySegTree {
/*
区間更新・区間和
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return b; };
auto merge_lazy = [](ll a, ll b) { return b; };
auto multiply_lazy = [](ll a, int n) { return a * n; };
区間加算・区間和
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return a + b; };
auto merge_lazy = [](ll a, ll b) { return a + b; };
auto multiply_lazy = [](ll a, int n) { return a * n; };
区間更新・区間最小
auto operation = [](ll a, ll b) { return min(a, b); };
auto adapt_lazy = [](ll a, ll b) { return b; };
auto merge_lazy = [](ll a, ll b) { return b; };
auto multiply_lazy = [](ll a, int n) { return a; };
区間加算・区間最小
auto operation = [](ll a, ll b) { return min(a, b); };
auto adapt_lazy = [](ll a, ll b) { return a + b; };
auto merge_lazy = [](ll a, ll b) { return a + b; };
auto multiply_lazy = [](ll a, int n) { return a; };
*/
int n;
vector<T> dat;
vector<U> lazy;
vector<int> width;
function<T(T, T)> operation;
function<T(T, U)> adapt_lazy;
function<U(U, U)> merge_lazy;
function<U(U, int)> multiply_lazy;
T init, def, lazy_def;
// ツリー上のノード k に lazy 値 v をセット
void set_lazy(int k, U v) {
if (lazy[k] == lazy_def) {
lazy[k] = v;
dat[k] = adapt_lazy(dat[k], multiply_lazy(v, width[k]));
} else {
lazy[k] = merge_lazy(lazy[k], v);
dat[k] = adapt_lazy(dat[k], multiply_lazy(v, width[k]));
}
}
// lazy を 1 段下ろす
void push(int k) {
if (lazy[k] == lazy_def)
return;
set_lazy(k * 2 + 1, lazy[k]);
set_lazy(k * 2 + 2, lazy[k]);
lazy[k] = lazy_def;
}
// 区間[a,b)の区間クエリ。ノードk=[l,r)に着目している。
long long _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
push(k);
long long c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
long long c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
public:
// _n:必要サイズ, _def:初期値, _operation:クエリ関数,
// _adapt_lazy:区間作用素適用関数, _merge_lazy:区間作用素マージ関数,
// _multiply_lazy:作用素を要素数で変形
LazySegTree(
size_t _n, T _init, T _def, T _lazy_def, function<T(T, T)> _operation,
function<T(T, U)> _adapt_lazy, function<U(U, U)> _merge_lazy,
function<U(U, int)> _multiply_lazy = [](U u, int n) { return u; })
: init(_init), def(_def), lazy_def(_lazy_def), operation(_operation),
adapt_lazy(_adapt_lazy), merge_lazy(_merge_lazy),
multiply_lazy(_multiply_lazy) {
n = 1;
while (n < _n)
n *= 2;
dat = vector<long long>(2 * n - 1, init);
lazy = vector<long long>(2 * n - 1, lazy_def);
width = vector<int>(2 * n - 1);
width[0] = n;
repr(i, 1, 2 * n - 1) width[i] = width[(i - 1) / 2] / 2;
}
// 区間[a,b)にvを作用させる
void range_operation(int a, int b, long long v, int k = 0, int l = 0,
int r = -1) {
if (r == -1)
r = n;
if (r <= a || b <= l)
return; // 交差しない
if (a <= l && r <= b) { // a,l,r,bの順で完全に含まれる
set_lazy(k, v);
return;
}
push(k);
range_operation(a, b, v, 2 * k + 1, l, (l + r) / 2); // 左の子
range_operation(a, b, v, 2 * k + 2, (l + r) / 2, r); // 右の子
dat[k] = operation(dat[k * 2 + 1], dat[k * 2 + 2]);
}
// [a, b)の区間クエリを実行
long long query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
long long operator[](int i) { return query(i, i + 1); }
};
int main(void) {
int N, M;
cin >> N >> M;
vec<tuple<int, int, int>> LCR(M);
rep(i, N) {
int l, r, c;
cin >> l >> r >> c;
l--;
LCR[i] = mt(l, c, r);
}
sort(all(LCR));
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return min(a, b); };
auto merge_lazy = [](ll a, ll b) { return min(a, b); };
auto multiply_lazy = [](ll a, int n) { return a; };
LazySegTree<ll, ll> st(N, INFL, 0, INFL, operation, adapt_lazy, merge_lazy,
multiply_lazy);
st.range_operation(0, 1, 0);
rep(i, M) {
int l, r, c;
tie(l, c, r) = LCR[i];
ll d = st[l];
st.range_operation(l, r, d + c);
}
if (st[N - 1] == INFL) {
cout << -1 << endl;
} else {
cout << st[N - 1] << endl;
}
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/timeb.h>
#include <vector>
using namespace std;
#define repr(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) repr(i, 0, n)
#define reprrev(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define reprev(i, n) reprrev(i, 0, n)
#define repi(itr, ds) for (auto itr = ds.begin(); itr != ds.end(); itr++)
#define chmin(mi, value) mi = min(mi, value)
#define chmax(ma, value) ma = max(ma, value)
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define mp make_pair
#define mt make_tuple
#define INF 1050000000
#define INFR INT_MAX
#define INFL (long long)(4e18)
#define INFLR LLONG_MAX
#define EPS (1e-10)
#define MOD 1000000007
// #define MOD 998244353
#define PI 3.141592653589793238
#define RMAX 4294967295
using vi = vector<int>;
using vvi = vector<vector<int>>;
using vvvi = vector<vector<vector<int>>>;
using vvvvi = vector<vector<vector<vector<int>>>>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vector<ll>>;
using vvvll = vector<vector<vector<ll>>>;
using vd = vector<double>;
using vvd = vector<vector<double>>;
using vvvd = vector<vector<vector<double>>>;
using vb = vector<bool>;
using vvb = vector<vector<bool>>;
using vc = vector<char>;
using vvc = vector<vector<char>>;
using vs = vector<string>;
using vvs = vector<vector<string>>;
using Pi = pair<int, int>;
using vPi = vector<Pi>;
using vvPi = vector<vector<Pi>>;
using vvvPi = vector<vector<vector<Pi>>>;
using vvvvPi = vector<vector<vector<vector<Pi>>>>;
using Pll = pair<ll, ll>;
using vPll = vector<Pll>;
using Pd = pair<double, double>;
using vPd = vector<Pd>;
template <class T> using vec = vector<T>;
template <class T> using pql = priority_queue<T, vector<T>, greater<T>>;
using Comp = complex<double>;
// vvvvvvvvvvvvvvvvvvvvvvv debug output vvvvvvvvvvvvvvvvvvvvvvv
// vector input
template <typename T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &x : vec)
is >> x;
return is;
}
// pair
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &pair_var) {
os << "(" << pair_var.first << ", " << pair_var.second << ")";
return os;
}
// vector
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// deque
template <typename T> ostream &operator<<(ostream &os, const deque<T> &vec) {
os << "{";
for (int i = 0; i < vec.size(); i++) {
os << vec[i] << (i + 1 == vec.size() ? "" : ", ");
}
os << "}";
return os;
}
// map
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &map_var) {
os << "{";
repi(itr, map_var) {
os << *itr;
itr++;
if (itr != map_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// set
template <typename T> ostream &operator<<(ostream &os, const set<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
// multiset
template <typename T>
ostream &operator<<(ostream &os, const multiset<T> &set_var) {
os << "{";
repi(itr, set_var) {
os << *itr;
itr++;
if (itr != set_var.end())
os << ", ";
itr--;
}
os << "}";
return os;
}
#define DUMPOUT cerr
void dump_func() { DUMPOUT << endl; }
template <class Head, class... Tail>
void dump_func(Head &&head, Tail &&...tail) {
DUMPOUT << head;
if (sizeof...(Tail) > 0) {
DUMPOUT << ", ";
}
dump_func(std::move(tail)...);
}
#ifdef DEBUG_
#define DEB
#define dump(...) \
DUMPOUT << " " << string(#__VA_ARGS__) << ": " \
<< "[" << to_string(__LINE__) << ":" << __FUNCTION__ << "]" << endl \
<< " ", \
dump_func(__VA_ARGS__)
#else
#define DEB if (false)
#define dump(...)
#endif
// ^^^^^^^^^^^^^^^^^^^^^^^ debug output ^^^^^^^^^^^^^^^^^^^^^^^
string YN(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "YES" : "NO");
}
string yn(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "Yes" : "No");
}
string ON(bool y, int id = 0) {
if (id)
cout << id;
return (y ? "OK" : "NG");
}
int dir4[4][2] = {{0, -1}, {-1, 0}, {1, 0}, {0, 1}};
int dir8[8][2] = {{-1, -1}, {0, -1}, {1, -1}, {-1, 0},
{1, 0}, {-1, 1}, {0, 1}, {1, 1}};
// [a,b)
int irand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_int_distribution<int> dist(a, b - 1);
return dist(Rand);
}
// [a,b)
double drand(int a, int b) {
static mt19937 Rand(static_cast<unsigned int>(time(nullptr)));
uniform_real_distribution<double> dist(a, b);
return dist(Rand);
}
// https://qiita.com/IgnorantCoder/items/3101d6276e9bdddf872c
template <typename A, typename F> inline auto transform(const A &v, F &&f) {
using result_type =
decltype(std::declval<F>()(std::declval<typename A::value_type>()));
vector<result_type> y(v.size());
std::transform(std::cbegin(v), std::cend(v), std::begin(y), f);
return y;
}
// generate vector which has multiple dimension
template <class T> vector<T> make_v(size_t size, const T &init) {
return vector<T>(size, init);
}
template <class... Ts> auto make_v(size_t size, Ts... rest) {
return vector<decltype(make_v(rest...))>(size, make_v(rest...));
}
template <typename T> T Max(vector<T> a) { return *max_element(all(a)); }
template <typename T> T Min(vector<T> a) { return *min_element(all(a)); }
template <typename T> T Sum(vector<T> a) { return accumulate(all(a), (T)0); }
// for counting using map
template <typename T> void Add(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
m[item] = 1;
} else {
m[item]++;
}
}
// for counting using map
template <typename T> void Erase(map<T, int> &m, T item) {
if (m.find(item) == m.end()) {
} else {
if (m[item] == 1) {
m.erase(item);
} else {
m[item]--;
}
}
}
// get method for map with default value
template <typename T, typename U> U Get(map<T, U> m, T key, U def) {
if (m.find(key) == m.end()) {
return def;
} else {
return m[key];
}
}
template <typename T> inline bool Contains(const set<T> &t, const T &key) {
return t.find(key) != t.end();
}
template <typename T, typename U>
inline bool Contains(const map<T, U> &t, const T &key) {
return t.find(key) != t.end();
}
template <class T> struct Edge {
int from, to;
T cost;
Edge(int f, int t, T c) : from(f), to(t), cost(c) {}
};
template <class T> bool operator<(const Edge<T> e1, const Edge<T> e2) {
return e1.cost < e2.cost || (e1.cost == e2.cost && e1.from < e2.from) ||
(e1.cost == e2.cost && e1.from == e2.from && e1.to < e2.to);
}
template <class T> ostream &operator<<(ostream &os, const Edge<T> &edge) {
os << "(" << edge.from << "->" << edge.to << ":" << edge.cost << ")";
return os;
}
template <class T = int> class Graph {
int n;
bool directed;
vector<vector<Edge<T>>> edges;
public:
Graph(int n, bool directed)
: n(n), directed(directed), edges(vector<vector<Edge<T>>>(n)) {}
void add_edge(int s, int t, T cost) {
edges[s].emplace_back(s, t, cost);
if (!directed) {
edges[t].emplace_back(t, s, cost);
}
}
Graph() {}
vector<Edge<T>> &operator[](size_t i) { return edges[i]; }
int size() const { return n; }
};
//======================================================
// 遅延伝播セグ木
template <class T, class U> class LazySegTree {
/*
区間更新・区間和
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return b; };
auto merge_lazy = [](ll a, ll b) { return b; };
auto multiply_lazy = [](ll a, int n) { return a * n; };
区間加算・区間和
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return a + b; };
auto merge_lazy = [](ll a, ll b) { return a + b; };
auto multiply_lazy = [](ll a, int n) { return a * n; };
区間更新・区間最小
auto operation = [](ll a, ll b) { return min(a, b); };
auto adapt_lazy = [](ll a, ll b) { return b; };
auto merge_lazy = [](ll a, ll b) { return b; };
auto multiply_lazy = [](ll a, int n) { return a; };
区間加算・区間最小
auto operation = [](ll a, ll b) { return min(a, b); };
auto adapt_lazy = [](ll a, ll b) { return a + b; };
auto merge_lazy = [](ll a, ll b) { return a + b; };
auto multiply_lazy = [](ll a, int n) { return a; };
*/
int n;
vector<T> dat;
vector<U> lazy;
vector<int> width;
function<T(T, T)> operation;
function<T(T, U)> adapt_lazy;
function<U(U, U)> merge_lazy;
function<U(U, int)> multiply_lazy;
T init, def, lazy_def;
// ツリー上のノード k に lazy 値 v をセット
void set_lazy(int k, U v) {
if (lazy[k] == lazy_def) {
lazy[k] = v;
dat[k] = adapt_lazy(dat[k], multiply_lazy(v, width[k]));
} else {
lazy[k] = merge_lazy(lazy[k], v);
dat[k] = adapt_lazy(dat[k], multiply_lazy(v, width[k]));
}
}
// lazy を 1 段下ろす
void push(int k) {
if (lazy[k] == lazy_def)
return;
set_lazy(k * 2 + 1, lazy[k]);
set_lazy(k * 2 + 2, lazy[k]);
lazy[k] = lazy_def;
}
// 区間[a,b)の区間クエリ。ノードk=[l,r)に着目している。
long long _query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def; // 交差しない
if (a <= l && r <= b)
return dat[k]; // a,l,r,bの順で完全に含まれる
push(k);
long long c1 = _query(a, b, 2 * k + 1, l, (l + r) / 2); // 左の子
long long c2 = _query(a, b, 2 * k + 2, (l + r) / 2, r); // 右の子
return operation(c1, c2);
}
public:
// _n:必要サイズ, _def:初期値, _operation:クエリ関数,
// _adapt_lazy:区間作用素適用関数, _merge_lazy:区間作用素マージ関数,
// _multiply_lazy:作用素を要素数で変形
LazySegTree(
size_t _n, T _init, T _def, T _lazy_def, function<T(T, T)> _operation,
function<T(T, U)> _adapt_lazy, function<U(U, U)> _merge_lazy,
function<U(U, int)> _multiply_lazy = [](U u, int n) { return u; })
: init(_init), def(_def), lazy_def(_lazy_def), operation(_operation),
adapt_lazy(_adapt_lazy), merge_lazy(_merge_lazy),
multiply_lazy(_multiply_lazy) {
n = 1;
while (n < _n)
n *= 2;
dat = vector<long long>(2 * n - 1, init);
lazy = vector<long long>(2 * n - 1, lazy_def);
width = vector<int>(2 * n - 1);
width[0] = n;
repr(i, 1, 2 * n - 1) width[i] = width[(i - 1) / 2] / 2;
}
// 区間[a,b)にvを作用させる
void range_operation(int a, int b, long long v, int k = 0, int l = 0,
int r = -1) {
if (r == -1)
r = n;
if (r <= a || b <= l)
return; // 交差しない
if (a <= l && r <= b) { // a,l,r,bの順で完全に含まれる
set_lazy(k, v);
return;
}
push(k);
range_operation(a, b, v, 2 * k + 1, l, (l + r) / 2); // 左の子
range_operation(a, b, v, 2 * k + 2, (l + r) / 2, r); // 右の子
dat[k] = operation(dat[k * 2 + 1], dat[k * 2 + 2]);
}
// [a, b)の区間クエリを実行
long long query(int a, int b) { return _query(a, b, 0, 0, n); }
// 添字でアクセス
long long operator[](int i) { return query(i, i + 1); }
};
int main(void) {
int N, M;
cin >> N >> M;
vec<tuple<int, int, int>> LCR(M);
rep(i, M) {
int l, r, c;
cin >> l >> r >> c;
l--;
LCR[i] = mt(l, c, r);
}
sort(all(LCR));
auto operation = [](ll a, ll b) { return a + b; };
auto adapt_lazy = [](ll a, ll b) { return min(a, b); };
auto merge_lazy = [](ll a, ll b) { return min(a, b); };
auto multiply_lazy = [](ll a, int n) { return a; };
LazySegTree<ll, ll> st(N, INFL, 0, INFL, operation, adapt_lazy, merge_lazy,
multiply_lazy);
st.range_operation(0, 1, 0);
rep(i, M) {
int l, r, c;
tie(l, c, r) = LCR[i];
ll d = st[l];
st.range_operation(l, r, d + c);
}
if (st[N - 1] == INFL) {
cout << -1 << endl;
} else {
cout << st[N - 1] << endl;
}
return 0;
}
| replace | 427 | 428 | 427 | 428 | -6 | malloc(): corrupted top size
|
p02868 | C++ | Time Limit Exceeded | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (in i = 0; i < (in)(n); i++)
#define REP(i, a, b) for (in i = (in)(a); i < (in)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout << "yes" << endl
#define no cout << "no" << endl
const double PI = 3.14159265358979323846;
const in MOD = 1000000007;
const in INF = 1e18 + 7;
const in inf = 1e9 + 7;
using P = pair<in, in>;
vector<in> dx = {0, 1, -1, 0};
vector<in> dy = {1, 0, 0, -1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
in n, m;
cin >> n >> m;
using T = tuple<in, in, in>;
in x, y, z;
priority_queue<P, vector<P>, greater<P>> que;
priority_queue<T, vector<T>, greater<T>> hen;
rep(i, m) {
cin >> x >> y >> z;
x--, y--;
hen.emplace(x, y, z);
}
vector<in> d(n, -1);
d[0] = 0;
in now = 1;
while (1) {
tie(x, y, z) = hen.top();
if (x == 0) {
que.emplace(z, y);
hen.pop();
} else
break;
}
while (!que.empty() && d[n - 1] == -1) {
tie(x, y) = que.top();
if (y < now) {
que.pop();
continue;
}
d[now] = x;
while (!hen.empty()) {
tie(x, y, z) = hen.top();
if (x != now)
break;
hen.pop();
que.emplace(z + d[now], y);
}
now++;
}
cout << d[n - 1] << endl;
} /*
./problem.exe
*/ | // #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define all(v) v.begin(), v.end()
using in = int64_t;
#define rep(i, n) for (in i = 0; i < (in)(n); i++)
#define REP(i, a, b) for (in i = (in)(a); i < (in)(b); i++)
#define Yes cout << "Yes" << endl
#define No cout << "No" << endl
#define yes cout << "yes" << endl
#define no cout << "no" << endl
const double PI = 3.14159265358979323846;
const in MOD = 1000000007;
const in INF = 1e18 + 7;
const in inf = 1e9 + 7;
using P = pair<in, in>;
vector<in> dx = {0, 1, -1, 0};
vector<in> dy = {1, 0, 0, -1};
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(10);
in n, m;
cin >> n >> m;
using T = tuple<in, in, in>;
in x, y, z;
priority_queue<P, vector<P>, greater<P>> que;
priority_queue<T, vector<T>, greater<T>> hen;
rep(i, m) {
cin >> x >> y >> z;
x--, y--;
hen.emplace(x, y, z);
}
vector<in> d(n, -1);
d[0] = 0;
in now = 1;
while (!hen.empty()) {
tie(x, y, z) = hen.top();
if (x == 0) {
que.emplace(z, y);
hen.pop();
} else
break;
}
while (!que.empty() && d[n - 1] == -1) {
tie(x, y) = que.top();
if (y < now) {
que.pop();
continue;
}
d[now] = x;
while (!hen.empty()) {
tie(x, y, z) = hen.top();
if (x != now)
break;
hen.pop();
que.emplace(z + d[now], y);
}
now++;
}
cout << d[n - 1] << endl;
} /*
./problem.exe
*/ | replace | 39 | 40 | 39 | 40 | TLE | |
p02869 | C++ | Time Limit Exceeded | // https://atcoder.jp/contests/nikkei2019-2-qual/tasks/nikkei2019_2_qual_e
#define CIN_ONLY
#define DECIMAL_DIGITS 10
#define STATIC_MOD 1e9 + 7
#ifdef BTK
/*<head>*/
#include "Template.hpp"
/*</head>*/
#else
/*<body>*/
/* #region auto includes */
/* #region stl */
/*<stl>*/
#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
/*</stl>*/
/* #endregion */
/* #region template/IncludeSTL.hpp*/
/**
* @file IncludeSTL.hpp
* @author btk
* @brief 標準ライブラリをincludeするだけ
* @version 0.1
* @date 2019-07-21
* @todo 何故か2回includeされる（展開scriptに
* @copyright Copyright (c) 2019
*
*/
/* #endregion */
/* #region template/Macro.hpp*/
/**
* @file Macro.hpp
* @author btk
* @brief マクロとか，LLとか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
//! LL
using LL = long long;
/**
* @def DEBUG
* @brief デバッグ用のif文 提出時はif(0)で実行されない
*/
/*</head>*/
#ifdef BTK
#define DEBUG if (1)
#else
#ifdef CIN_ONLY
#define FAST_IO
#endif
#define DEBUG if (0)
#endif
/**
* @def ALL(v)
* @brief
* ALLマクロ
*/
#define ALL(v) (v).begin(), (v).end()
/**
* @def REC(ret, ...)
* @brief
* 再帰ラムダをするためのマクロ
*/
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
/**
* @def VAR_NAME(var)
* @brief 変数名を取得する
*/
#define VAR_NAME(var) #var
/**
* @brief
* rangeで生まれる使わない変数を消す用（警告消し）
*/
template <typename T> inline T &unused_var(T &v) { return v; }
/* #endregion */
/* #region template/IO.hpp*/
/**
* @file IO.hpp
* @author btk
* @brief cin高速化とか，出力の小数桁固定とか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*/
/**
* @brief 入出力の設定を行うための構造体
*/
struct cww {
/**
* @brief Construct a new cww::cww object
* @details
* CIN_ONLYを定義すると，submit時にcinとscanfの同期を切る設定が走る
* DECIMAL_DIGITSを定義すると，doubleの出力時指定した桁数分小数部を吐くようになる
*/
cww() {
#ifdef FAST_IO
ios::sync_with_stdio(false);
cin.tie(0);
#endif
#ifdef DECIMAL_DIGITS
cout << fixed;
cout << setprecision(DECIMAL_DIGITS);
#endif
}
};
//! 入出力設定構造体を実体化
cww star;
/**
* @brief
* vectorに直接cin流すためのやつ
* @tparam T
* @param is
* @param v
* @return istream&
*/
template <typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
/* #endregion */
/* #region template/Loop.hpp*/
/**
* @file Loop.hpp
* @author btk
* @brief rangeとかループ系のクラス
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
/**
* @brief
* rangeを逆向きに操作したいとき用
* @details
* ループの範囲は[bg,ed)なので注意
* @see range
*/
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
/**
* @brief Construct a new reverse range object
*
* @param n
*/
reverse_range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new reverse range object
*
* @param i
* @param n
*/
reverse_range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I &begin() { return n; }
/**
* @brief
* end iterator
* @return I&
*/
I &end() { return i; }
};
/**
* @brief
* python みたいな range-based for を実現
* @details
* ループの範囲は[bg,ed)なので注意
* !つけると逆向きにループが回る (reverse_range)
* 空間計算量はO(1)
* 使わない変数ができて警告が出がちなので，unused_varとかを使って警告消しするとよい
*/
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
/**
* @brief Construct a new range object
*
* @param n
*/
range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new range object
*
* @param i
* @param n
*/
range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I &begin() { return i; }
/**
* @brief
* end iterator
* @return I&
*/
I &end() { return n; }
/**
* @brief
* 逆向きに参照するrange(reverse_rangeを取得できるs)
* @return reverse_range
*/
reverse_range operator!() { return reverse_range(*i, *n); }
};
/* #endregion */
/* #region template/MinMaxOperation.hpp*/
/**
* @file MinMaxOperation.hpp
* @author btk
* @brief 最大値とか最小値を求める
* @version 0.1
* @date 2019-07-04
*
* @copyright Copyright (c) 2019
*
*/
/**
* @brief 2項の最小値求める
*
* @tparam T
*/
template <typename T> struct min_op {
/**
* @brief 本体
*
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l < r ? l : r; }
};
/**
* @brief 2項の最大値求める
*
* @tparam T
*/
template <typename T> struct max_op {
/**
* @brief 本体
*
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l > r ? l : r; }
};
/**
* @brief テンプレート再帰の末尾
*
* @tparam F 二項演算
* @tparam T
* @param v
* @return T
*/
template <typename F, typename T> inline T multi_op(T &&v) { return v; }
/**
* @brief 複数項における演算の結果を返す
*
* @tparam F
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename F, typename T, typename... Ts>
inline T multi_op(const T head, Ts &&...tail) {
return F::exec(head, multi_op<F>(tail...));
}
/**
* @brief 複数項の最小値
* @see multi_op
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T multi_min(T &&head, Ts &&...tail) {
return multi_op<min_op<T>>(head, tail...);
}
/**
* @brief 複数項の最大値
* @see multi_op
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T multi_max(T &&head, Ts &&...tail) {
return multi_op<max_op<T>>(head, tail...);
}
/**
* @brief
* 先頭の値をFで参照する関数に基づいて変更できたらする
* @tparam F
* @tparam T
* @tparam Ts
* @param target
* @param candidates
* @return true
* @return false
*/
template <typename F, typename T, typename... Ts>
inline bool ch_op(T &target, Ts &&...candidates) {
const T old = target;
target = multi_op<F>(target, candidates...);
return old != target;
}
/**
* @brief change min
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmin(T &target, Ts &&...candidates) {
return ch_op<min_op<T>>(target, candidates...);
}
/**
* @brief chminのmax版
* @see chmin
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmax(T &target, Ts &&...candidates) {
return ch_op<max_op<T>>(target, candidates...);
}
/* #endregion */
/* #region template/Random.hpp*/
/**
* @file Random.hpp
* @author btk
* @brief 乱数生成系
* @version 0.1
* @date 2019-07-13
* @copyright Copyright (c) 2019
*/
//! 乱数のシード値をプロセスIDとして取得
const pid_t pid = getpid();
/**
* @brief XorShift32の実装
*/
class XorShift32 {
private:
//! XorShiftの現在の値
unsigned value;
/**
* @brief XorShift32のアルゴリズムに基づいて value を更新
*/
inline void update() {
value = value ^ (value << 13);
value = value ^ (value >> 17);
value = value ^ (value << 5);
}
/**
* @brief 値を更新し，更新前の値を返却
* @return unsigned 呼び出し時の value を用いる
*/
inline unsigned get() {
unsigned v = value;
update();
return v;
}
public:
/**
* @brief [0, 2^bit) の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31> inline int next_int() {
return (int)(get() >> (32 - bit));
}
/**
* @brief [-2^bit,2^bit)の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31> inline int next_signed() {
unsigned v = get();
return (int)((v >> (31 - bit)) - (1 << (bit)));
}
/**
* @brief next_int呼び出し時の最大値を取得
* @tparam 31
* @return int
*/
template <int bit = 31> inline int range_max() {
return (int)((1u << bit) - 1);
};
/**
* @brief Construct a new XorShift32 object
* @param seed
* @details 初期シードをvalueとするXorShift32のインスタンスを生成
*/
XorShift32(const unsigned seed) {
value = seed;
update();
}
/**
* @brief Construct a new XorShift 32 object
* @details 初期シードをプロセスIDとするXorShift32のインスタンスを生成
*/
XorShift32() : XorShift32(pid) {}
};
/* #endregion */
/* #region Template.hpp*/
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
/* #endregion */
/* #endregion */
/*</body>*/
#endif
LL N;
LL K;
LL a[112345];
LL b[112345];
LL c[112345];
bool solve() {
set<LL> di;
auto ad = [&](LL m) {
for (int i : range(-1, 2)) {
if (m + i >= 0) {
di.insert(m + i);
}
}
};
for (LL k = 1; k * k <= N; k++) {
if (N % k == 0) {
ad(k);
ad(N / k);
}
}
N--;
for (LL k = 1; k * k <= N; k++) {
if (N % k == 0) {
ad(k);
ad(N / k);
}
}
N++;
for (auto p : di) {
set<LL> re;
for (int i : range(N))
re.insert(K + 2 * N + i);
bool ok = true;
for (int i : range(N)) {
a[i] = K + i;
b[i] = K + N + (p + i) % N;
auto it = re.lower_bound(a[i] + b[i]);
if (it != re.end()) {
c[i] = *it;
re.erase(c[i]);
} else {
ok = false;
break;
}
}
if (ok)
return true;
}
return false;
}
int main() {
/* write here */
cin >> N >> K;
if (solve()) {
for (int i : range(N)) {
cout << a[i] << " " << b[i] << " " << c[i] << endl;
}
} else {
cout << -1 << endl;
}
return 0;
} | // https://atcoder.jp/contests/nikkei2019-2-qual/tasks/nikkei2019_2_qual_e
#define CIN_ONLY
#define DECIMAL_DIGITS 10
#define STATIC_MOD 1e9 + 7
#ifdef BTK
/*<head>*/
#include "Template.hpp"
/*</head>*/
#else
/*<body>*/
/* #region auto includes */
/* #region stl */
/*<stl>*/
#include <bits/stdc++.h>
#include <sys/types.h>
#include <unistd.h>
using namespace std;
/*</stl>*/
/* #endregion */
/* #region template/IncludeSTL.hpp*/
/**
* @file IncludeSTL.hpp
* @author btk
* @brief 標準ライブラリをincludeするだけ
* @version 0.1
* @date 2019-07-21
* @todo 何故か2回includeされる（展開scriptに
* @copyright Copyright (c) 2019
*
*/
/* #endregion */
/* #region template/Macro.hpp*/
/**
* @file Macro.hpp
* @author btk
* @brief マクロとか，LLとか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
//! LL
using LL = long long;
/**
* @def DEBUG
* @brief デバッグ用のif文 提出時はif(0)で実行されない
*/
/*</head>*/
#ifdef BTK
#define DEBUG if (1)
#else
#ifdef CIN_ONLY
#define FAST_IO
#endif
#define DEBUG if (0)
#endif
/**
* @def ALL(v)
* @brief
* ALLマクロ
*/
#define ALL(v) (v).begin(), (v).end()
/**
* @def REC(ret, ...)
* @brief
* 再帰ラムダをするためのマクロ
*/
#define REC(ret, ...) std::function<ret(__VA_ARGS__)>
/**
* @def VAR_NAME(var)
* @brief 変数名を取得する
*/
#define VAR_NAME(var) #var
/**
* @brief
* rangeで生まれる使わない変数を消す用（警告消し）
*/
template <typename T> inline T &unused_var(T &v) { return v; }
/* #endregion */
/* #region template/IO.hpp*/
/**
* @file IO.hpp
* @author btk
* @brief cin高速化とか，出力の小数桁固定とか
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*/
/**
* @brief 入出力の設定を行うための構造体
*/
struct cww {
/**
* @brief Construct a new cww::cww object
* @details
* CIN_ONLYを定義すると，submit時にcinとscanfの同期を切る設定が走る
* DECIMAL_DIGITSを定義すると，doubleの出力時指定した桁数分小数部を吐くようになる
*/
cww() {
#ifdef FAST_IO
ios::sync_with_stdio(false);
cin.tie(0);
#endif
#ifdef DECIMAL_DIGITS
cout << fixed;
cout << setprecision(DECIMAL_DIGITS);
#endif
}
};
//! 入出力設定構造体を実体化
cww star;
/**
* @brief
* vectorに直接cin流すためのやつ
* @tparam T
* @param is
* @param v
* @return istream&
*/
template <typename T>
std::istream &operator>>(std::istream &is, std::vector<T> &v) {
for (auto &it : v)
is >> it;
return is;
}
/* #endregion */
/* #region template/Loop.hpp*/
/**
* @file Loop.hpp
* @author btk
* @brief rangeとかループ系のクラス
* @version 0.1
* @date 2019-07-13
*
* @copyright Copyright (c) 2019
*
*/
/**
* @brief
* rangeを逆向きに操作したいとき用
* @details
* ループの範囲は[bg,ed)なので注意
* @see range
*/
class reverse_range {
private:
struct I {
int x;
int operator*() { return x - 1; }
bool operator!=(I &lhs) { return x > lhs.x; }
void operator++() { --x; }
};
I i, n;
public:
/**
* @brief Construct a new reverse range object
*
* @param n
*/
reverse_range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new reverse range object
*
* @param i
* @param n
*/
reverse_range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I &begin() { return n; }
/**
* @brief
* end iterator
* @return I&
*/
I &end() { return i; }
};
/**
* @brief
* python みたいな range-based for を実現
* @details
* ループの範囲は[bg,ed)なので注意
* !つけると逆向きにループが回る (reverse_range)
* 空間計算量はO(1)
* 使わない変数ができて警告が出がちなので，unused_varとかを使って警告消しするとよい
*/
class range {
private:
struct I {
int x;
int operator*() { return x; }
bool operator!=(I &lhs) { return x < lhs.x; }
void operator++() { ++x; }
};
I i, n;
public:
/**
* @brief Construct a new range object
*
* @param n
*/
range(int n) : i({0}), n({n}) {}
/**
* @brief Construct a new range object
*
* @param i
* @param n
*/
range(int i, int n) : i({i}), n({n}) {}
/**
* @brief
* begin iterator
* @return I&
*/
I &begin() { return i; }
/**
* @brief
* end iterator
* @return I&
*/
I &end() { return n; }
/**
* @brief
* 逆向きに参照するrange(reverse_rangeを取得できるs)
* @return reverse_range
*/
reverse_range operator!() { return reverse_range(*i, *n); }
};
/* #endregion */
/* #region template/MinMaxOperation.hpp*/
/**
* @file MinMaxOperation.hpp
* @author btk
* @brief 最大値とか最小値を求める
* @version 0.1
* @date 2019-07-04
*
* @copyright Copyright (c) 2019
*
*/
/**
* @brief 2項の最小値求める
*
* @tparam T
*/
template <typename T> struct min_op {
/**
* @brief 本体
*
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l < r ? l : r; }
};
/**
* @brief 2項の最大値求める
*
* @tparam T
*/
template <typename T> struct max_op {
/**
* @brief 本体
*
* @param l
* @param r
* @return T
*/
static T exec(const T l, const T r) { return l > r ? l : r; }
};
/**
* @brief テンプレート再帰の末尾
*
* @tparam F 二項演算
* @tparam T
* @param v
* @return T
*/
template <typename F, typename T> inline T multi_op(T &&v) { return v; }
/**
* @brief 複数項における演算の結果を返す
*
* @tparam F
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename F, typename T, typename... Ts>
inline T multi_op(const T head, Ts &&...tail) {
return F::exec(head, multi_op<F>(tail...));
}
/**
* @brief 複数項の最小値
* @see multi_op
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T multi_min(T &&head, Ts &&...tail) {
return multi_op<min_op<T>>(head, tail...);
}
/**
* @brief 複数項の最大値
* @see multi_op
* @tparam T
* @tparam Ts
* @param head
* @param tail
* @return T
*/
template <typename T, typename... Ts>
inline T multi_max(T &&head, Ts &&...tail) {
return multi_op<max_op<T>>(head, tail...);
}
/**
* @brief
* 先頭の値をFで参照する関数に基づいて変更できたらする
* @tparam F
* @tparam T
* @tparam Ts
* @param target
* @param candidates
* @return true
* @return false
*/
template <typename F, typename T, typename... Ts>
inline bool ch_op(T &target, Ts &&...candidates) {
const T old = target;
target = multi_op<F>(target, candidates...);
return old != target;
}
/**
* @brief change min
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmin(T &target, Ts &&...candidates) {
return ch_op<min_op<T>>(target, candidates...);
}
/**
* @brief chminのmax版
* @see chmin
* @tparam T 型
* @param target 変更する値
* @param candidates
* @return 更新があればtrue
*/
template <typename T, typename... Ts>
inline bool chmax(T &target, Ts &&...candidates) {
return ch_op<max_op<T>>(target, candidates...);
}
/* #endregion */
/* #region template/Random.hpp*/
/**
* @file Random.hpp
* @author btk
* @brief 乱数生成系
* @version 0.1
* @date 2019-07-13
* @copyright Copyright (c) 2019
*/
//! 乱数のシード値をプロセスIDとして取得
const pid_t pid = getpid();
/**
* @brief XorShift32の実装
*/
class XorShift32 {
private:
//! XorShiftの現在の値
unsigned value;
/**
* @brief XorShift32のアルゴリズムに基づいて value を更新
*/
inline void update() {
value = value ^ (value << 13);
value = value ^ (value >> 17);
value = value ^ (value << 5);
}
/**
* @brief 値を更新し，更新前の値を返却
* @return unsigned 呼び出し時の value を用いる
*/
inline unsigned get() {
unsigned v = value;
update();
return v;
}
public:
/**
* @brief [0, 2^bit) の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31> inline int next_int() {
return (int)(get() >> (32 - bit));
}
/**
* @brief [-2^bit,2^bit)の範囲の乱数値を取り出す
* @tparam デフォルトは31
* @return int
*/
template <int bit = 31> inline int next_signed() {
unsigned v = get();
return (int)((v >> (31 - bit)) - (1 << (bit)));
}
/**
* @brief next_int呼び出し時の最大値を取得
* @tparam 31
* @return int
*/
template <int bit = 31> inline int range_max() {
return (int)((1u << bit) - 1);
};
/**
* @brief Construct a new XorShift32 object
* @param seed
* @details 初期シードをvalueとするXorShift32のインスタンスを生成
*/
XorShift32(const unsigned seed) {
value = seed;
update();
}
/**
* @brief Construct a new XorShift 32 object
* @details 初期シードをプロセスIDとするXorShift32のインスタンスを生成
*/
XorShift32() : XorShift32(pid) {}
};
/* #endregion */
/* #region Template.hpp*/
/**
* @file Template.hpp
* @brief 競技プログラミング用テンプレート
* @author btk15049
* @date 2019/05/02
*/
/* #endregion */
/* #endregion */
/*</body>*/
#endif
LL N;
LL K;
LL a[112345];
LL b[112345];
LL c[112345];
bool solve() {
set<LL> di;
auto ad = [&](LL m) {
for (int i : range(0, 2)) {
if (m + i >= 0) {
di.insert(m + i);
}
}
};
for (LL k = 1; k * k <= N; k++) {
if (N % k == 0) {
ad(k);
ad(N / k);
}
}
N--;
for (LL k = 1; k * k <= N; k++) {
if (N % k == 0) {
ad(k);
ad(N / k);
}
}
N++;
for (auto p : di) {
set<LL> re;
for (int i : range(N))
re.insert(K + 2 * N + i);
bool ok = true;
for (int i : range(N)) {
a[i] = K + i;
b[i] = K + N + (p + i) % N;
auto it = re.lower_bound(a[i] + b[i]);
if (it != re.end()) {
c[i] = *it;
re.erase(c[i]);
} else {
ok = false;
break;
}
}
if (ok)
return true;
}
return false;
}
int main() {
/* write here */
cin >> N >> K;
if (solve()) {
for (int i : range(N)) {
cout << a[i] << " " << b[i] << " " << c[i] << endl;
}
} else {
cout << -1 << endl;
}
return 0;
} | replace | 496 | 497 | 496 | 497 | TLE | |
p02869 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
struct tri {
ll f, s, t;
};
bool comp(const tri &l, const tri &r) { return l.t < r.t; }
int main(void) {
SPEEDUP
cout << setprecision(15);
int N;
ll K;
cin >> N >> K;
vector<tri> v(N);
ll b;
b = K + 2 * N - 1;
int index = 0;
repp(x, K, K + N) {
if (x & 1 == 0)
continue;
v[index].f = x;
v[index].s = b;
v[index].t = x + b;
++index;
--b;
}
repp(x, K, K + N) {
if (x & 1)
continue;
v[index].f = x;
v[index].s = b;
v[index].t = x + b;
++index;
--b;
}
sort(all(v), comp);
ll c = K + 2 * N;
rep(i, N) {
if (v[i].t > c) {
cout << -1 << endl;
return 0;
}
v[i].t = c;
++c;
}
rep(i, N) cout << v[i].f SP v[i].s SP v[i].t << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, N) for (int i = 0, i##_max = (N); i < i##_max; ++i)
#define repp(i, l, r) for (int i = (l), i##_max = (r); i < i##_max; ++i)
#define per(i, N) for (int i = (N)-1; i >= 0; --i)
#define perr(i, l, r) for (int i = r - 1, i##_min(l); i >= i##_min; --i)
#define all(arr) (arr).begin(), (arr).end()
#define SP << " " <<
#define SPF << " "
#define SPEEDUP \
cin.tie(0); \
ios::sync_with_stdio(false);
#define MAX_I INT_MAX // 1e9
#define MIN_I INT_MIN //-1e9
#define MAX_UI UINT_MAX // 1e9
#define MAX_LL LLONG_MAX // 1e18
#define MIN_LL LLONG_MIN //-1e18
#define MAX_ULL ULLONG_MAX // 1e19
typedef long long ll;
typedef pair<int, int> PII;
typedef pair<char, char> PCC;
typedef pair<ll, ll> PLL;
typedef pair<char, int> PCI;
typedef pair<int, char> PIC;
typedef pair<ll, int> PLI;
typedef pair<int, ll> PIL;
typedef pair<ll, char> PLC;
typedef pair<char, ll> PCL;
inline void YesNo(bool b) { cout << (b ? "Yes" : "No") << endl; }
inline void YESNO(bool b) { cout << (b ? "YES" : "NO") << endl; }
inline void Yay(bool b) { cout << (b ? "Yay!" : ":(") << endl; }
struct tri {
ll f, s, t;
};
bool comp(const tri &l, const tri &r) { return l.t < r.t; }
int main(void) {
SPEEDUP
cout << setprecision(15);
int N;
ll K;
cin >> N >> K;
vector<tri> v(N);
ll b;
b = K + 2 * N - 1;
int index = 0;
repp(x, K, K + N) {
if ((x & 1) == 0)
continue;
v[index].f = x;
v[index].s = b;
v[index].t = x + b;
++index;
--b;
}
repp(x, K, K + N) {
if (x & 1)
continue;
v[index].f = x;
v[index].s = b;
v[index].t = x + b;
++index;
--b;
}
sort(all(v), comp);
ll c = K + 2 * N;
rep(i, N) {
if (v[i].t > c) {
cout << -1 << endl;
return 0;
}
v[i].t = c;
++c;
}
rep(i, N) cout << v[i].f SP v[i].s SP v[i].t << endl;
return 0;
}
| replace | 50 | 51 | 50 | 51 | 0 | |
p02869 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
// C++14
// tuple_util::apply( function, result, tuple<args>)
#include <tuple>
#include <utility>
namespace tuple_util {
template <class F, class R, class... Args, size_t... I>
void apply(F &f, R &res, tuple<Args...> &t, index_sequence<I...>) {
res = f(get<I>(t)...);
}
template <class F, class R, class... Args>
void apply(F &f, R &res, tuple<Args...> &t) {
apply(f, res, t, index_sequence_for<Args...>{});
}
template <class T, size_t... I>
void input(istream &is, T &t, index_sequence<I...>) {
using s = int[];
(void)s{(void(is >> get<I>(t)), 0)...};
}
template <class T, size_t... I>
void output(ostream &os, T &t, index_sequence<I...>) {
using s = int[];
(void)s{(void(os << get<I>(t) << " "), 0)...};
}
} // namespace tuple_util
template <class... Args> istream &operator>>(istream &is, tuple<Args...> &t) {
tuple_util::input(is, t, index_sequence_for<Args...>{});
return is;
}
template <class... Args>
ostream &operator<<(ostream &os, const tuple<Args...> &t) {
tuple_util::output(os, t, index_sequence_for<Args...>{});
return os;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
long long n, k;
cin >> n, k;
if (2 * k - 1 > n) {
println(-1);
return 0;
}
vector<int> a(n);
for (int i = 0; i < n; i++) {
a[i] = 2 * n + i - k;
}
vector<int> used(2 * n, 0);
vector<tuple<int, int, int>> b;
for (int i = 0, j = n * 2 - 1; i < 2 * n; i += 2, j--) {
if (i >= j)
break;
used[i] = 1;
used[j] = 1;
b.emplace_back(i + j, i, j);
}
for (int i = 0, j = 2 * n - 1; i < 2 * n; i++, j--) {
while (i < 2 * n - 1 && used[i])
i++;
while (j > i && used[j])
j--;
if (i < 2 * n - 1 && j > i) {
used[i] = 1;
used[j] = 1;
b.emplace_back(i + j, i, j);
}
}
sort(b.begin(), b.end());
assert(b.size() == n);
for (int i = 0; i < n; i++) {
int x, y, z;
tie(ignore, x, y) = b[i];
z = a[i];
if (x + y > z) {
assert(x + y <= z);
}
b[i] = make_tuple(x + k, y + k, z + 2 * k);
}
println(join(b, "\n"));
return 0;
}
| #include <algorithm>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdio>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
namespace {
using Integer = long long; //__int128;
template <class T, class S> istream &operator>>(istream &is, pair<T, S> &p) {
return is >> p.first >> p.second;
}
template <class T> istream &operator>>(istream &is, vector<T> &vec) {
for (T &val : vec)
is >> val;
return is;
}
template <class T> istream &operator,(istream &is, T &val) { return is >> val; }
template <class T, class S>
ostream &operator<<(ostream &os, const pair<T, S> &p) {
return os << p.first << " " << p.second;
}
template <class T> ostream &operator<<(ostream &os, const vector<T> &vec) {
for (size_t i = 0; i < vec.size(); i++)
os << vec[i] << (i == vec.size() - 1 ? "" : " ");
return os;
}
template <class T> ostream &operator,(ostream &os, const T &val) {
return os << " " << val;
}
// C++14
// tuple_util::apply( function, result, tuple<args>)
#include <tuple>
#include <utility>
namespace tuple_util {
template <class F, class R, class... Args, size_t... I>
void apply(F &f, R &res, tuple<Args...> &t, index_sequence<I...>) {
res = f(get<I>(t)...);
}
template <class F, class R, class... Args>
void apply(F &f, R &res, tuple<Args...> &t) {
apply(f, res, t, index_sequence_for<Args...>{});
}
template <class T, size_t... I>
void input(istream &is, T &t, index_sequence<I...>) {
using s = int[];
(void)s{(void(is >> get<I>(t)), 0)...};
}
template <class T, size_t... I>
void output(ostream &os, T &t, index_sequence<I...>) {
using s = int[];
(void)s{(void(os << get<I>(t) << " "), 0)...};
}
} // namespace tuple_util
template <class... Args> istream &operator>>(istream &is, tuple<Args...> &t) {
tuple_util::input(is, t, index_sequence_for<Args...>{});
return is;
}
template <class... Args>
ostream &operator<<(ostream &os, const tuple<Args...> &t) {
tuple_util::output(os, t, index_sequence_for<Args...>{});
return os;
}
template <class H> void print(const H &head) { cout << head; }
template <class H, class... T> void print(const H &head, const T &...tail) {
cout << head << " ";
print(tail...);
}
template <class... T> void println(const T &...values) {
print(values...);
cout << endl;
}
template <class H> void eprint(const H &head) { cerr << head; }
template <class H, class... T> void eprint(const H &head, const T &...tail) {
cerr << head << " ";
eprint(tail...);
}
template <class... T> void eprintln(const T &...values) {
eprint(values...);
cerr << endl;
}
class range {
Integer start_, end_, step_;
public:
struct range_iterator {
Integer val, step_;
range_iterator(Integer v, Integer step) : val(v), step_(step) {}
Integer operator*() { return val; }
void operator++() { val += step_; }
bool operator!=(range_iterator &x) {
return step_ > 0 ? val < x.val : val > x.val;
}
};
range(Integer len) : start_(0), end_(len), step_(1) {}
range(Integer start, Integer end) : start_(start), end_(end), step_(1) {}
range(Integer start, Integer end, Integer step)
: start_(start), end_(end), step_(step) {}
range_iterator begin() { return range_iterator(start_, step_); }
range_iterator end() { return range_iterator(end_, step_); }
};
inline string operator"" _s(const char *str, size_t size) {
return move(string(str));
}
constexpr Integer my_pow(Integer x, Integer k, Integer z = 1) {
return k == 0 ? z
: k == 1 ? z * x
: (k & 1) ? my_pow(x * x, k >> 1, z * x)
: my_pow(x * x, k >> 1, z);
}
constexpr Integer my_pow_mod(Integer x, Integer k, Integer M, Integer z = 1) {
return k == 0 ? z % M
: k == 1 ? z * x % M
: (k & 1) ? my_pow_mod(x * x % M, k >> 1, M, z * x % M)
: my_pow_mod(x * x % M, k >> 1, M, z);
}
constexpr unsigned long long operator"" _ten(unsigned long long value) {
return my_pow(10, value);
}
inline int k_bit(Integer x, int k) { return (x >> k) & 1; } // 0-indexed
mt19937 mt(chrono::duration_cast<chrono::nanoseconds>(
chrono::steady_clock::now().time_since_epoch())
.count());
template <class T> string join(const vector<T> &v, const string &sep) {
stringstream ss;
for (size_t i = 0; i < v.size(); i++) {
if (i > 0)
ss << sep;
ss << v[i];
}
return ss.str();
}
inline string operator*(string s, int k) {
string ret;
while (k) {
if (k & 1)
ret += s;
s += s;
k >>= 1;
}
return ret;
}
} // namespace
constexpr long long mod = 9_ten + 7;
int main() {
long long n, k;
cin >> n, k;
if (2 * k - 1 > n) {
println(-1);
return 0;
}
vector<int> a(n);
for (int i = 0; i < n; i++) {
a[i] = 2 * n + i - k;
}
vector<int> used(2 * n, 0);
vector<tuple<int, int, int>> b;
for (int i = 0, j = n * 2 - 1; i < 2 * n; i += 2, j--) {
if (i >= j)
break;
if (i + j > a.back())
break;
used[i] = 1;
used[j] = 1;
b.emplace_back(i + j, i, j);
}
for (int i = 0, j = 2 * n - 1; i < 2 * n; i++, j--) {
while (i < 2 * n - 1 && used[i])
i++;
while (j > i && used[j])
j--;
if (i < 2 * n - 1 && j > i) {
used[i] = 1;
used[j] = 1;
b.emplace_back(i + j, i, j);
}
}
sort(b.begin(), b.end());
assert(b.size() == n);
for (int i = 0; i < n; i++) {
int x, y, z;
tie(ignore, x, y) = b[i];
z = a[i];
if (x + y > z) {
assert(x + y <= z);
}
b[i] = make_tuple(x + k, y + k, z + 2 * k);
}
println(join(b, "\n"));
return 0;
}
| insert | 185 | 185 | 185 | 187 | 0 | |
p02869 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int dm = 1 << 20;
char dn[dm], *di = dn;
inline void putint(int X) {
int keta = 0;
char C[10];
while (X) {
*(C + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
*di++ = '\n';
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int N, K;
scanf("%d", &N);
scanf("%d", &K);
if ((N + 1) / 2 >= K) {
int B = K + N;
int C = K + N + N;
int b = N / 2;
int n = !(N & 1);
rep(i, (N + 1) / 2) {
putint(K + i);
putint(B + b + i);
putint(C + i * 2);
}
for (int i = (N + 1) / 2; i < N; i++) {
putint(K + i);
putint(K + b + i);
putint(B + i * 2 + n);
}
fwrite(dn, 1, di - dn, stdout);
} else {
printf("-1");
return 0;
}
Would you please return 0;
} | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep1(i, n) for (int i = 1; i <= (n); i++)
#define co(x) cout << (x) << "\n"
#define cosp(x) cout << (x) << " "
#define ce(x) cerr << (x) << "\n"
#define cesp(x) cerr << (x) << " "
#define pb push_back
#define mp make_pair
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define Would
#define you
#define please
const int dm = 1 << 21;
char dn[dm], *di = dn;
inline void putint(int X) {
int keta = 0;
char C[10];
while (X) {
*(C + keta) = '0' + X % 10;
X /= 10;
keta++;
}
for (int i = keta - 1; i >= 0; i--)
*di++ = (*(C + i));
*di++ = '\n';
}
int main() {
// cin.tie(0);
// ios::sync_with_stdio(false);
int N, K;
scanf("%d", &N);
scanf("%d", &K);
if ((N + 1) / 2 >= K) {
int B = K + N;
int C = K + N + N;
int b = N / 2;
int n = !(N & 1);
rep(i, (N + 1) / 2) {
putint(K + i);
putint(B + b + i);
putint(C + i * 2);
}
for (int i = (N + 1) / 2; i < N; i++) {
putint(K + i);
putint(K + b + i);
putint(B + i * 2 + n);
}
fwrite(dn, 1, di - dn, stdout);
} else {
printf("-1");
return 0;
}
Would you please return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p02869 | C++ | Runtime Error | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
constexpr long long int MOD = 1000000007;
// constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
// constexpr long long int MOD = 998244353;
constexpr long double EPS = 1e-12;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int N, K;
cin >> K >> N;
if (2 * N * K + (2 * N - 1) * (2 * N) / 2 >
N * K + 2 * N * N + N * (N - 1) / 2) {
cout << -1 << endl;
return 0;
}
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
int cnt = 0;
for (int i = 0; i < N; i += 2) {
a[i] = K + cnt++;
}
for (int i = 1; i < N; i += 2) {
a[i] = K + cnt++;
}
cnt = 2 * N;
if (N & 1) {
for (int i = N - 1; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
for (int i = N - 2; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
} else {
for (int i = N - 2; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
for (int i = N - 1; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
}
cnt = 2 * N;
for (int i = 0; i < N; i++) {
c[i] = K + cnt++;
}
for (int i = 0; i < N; i++) {
cout << a[i] << " " << b[i] << " " << c[i] << endl;
}
} | #include "algorithm"
#include "bitset"
#include "cassert"
#include "climits"
#include "cmath"
#include "cstdio"
#include "ctime"
#include "functional"
#include "iomanip"
#include "iostream"
#include "list"
#include "map"
#include "numeric"
#include "queue"
#include "random"
#include "set"
#include "stack"
#include "string"
#include "unordered_map"
#include "unordered_set"
using namespace std;
constexpr long long int MOD = 1000000007;
// constexpr int MOD = 1000000007;
// constexpr int MOD = 998244353;
// constexpr long long int MOD = 998244353;
constexpr long double EPS = 1e-12;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long int N, K;
cin >> N >> K;
if (2 * N * K + (2 * N - 1) * (2 * N) / 2 >
N * K + 2 * N * N + N * (N - 1) / 2) {
cout << -1 << endl;
return 0;
}
vector<int> a(N);
vector<int> b(N);
vector<int> c(N);
int cnt = 0;
for (int i = 0; i < N; i += 2) {
a[i] = K + cnt++;
}
for (int i = 1; i < N; i += 2) {
a[i] = K + cnt++;
}
cnt = 2 * N;
if (N & 1) {
for (int i = N - 1; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
for (int i = N - 2; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
} else {
for (int i = N - 2; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
for (int i = N - 1; i >= 0; i -= 2) {
b[i] = K + --cnt;
}
}
cnt = 2 * N;
for (int i = 0; i < N; i++) {
c[i] = K + cnt++;
}
for (int i = 0; i < N; i++) {
cout << a[i] << " " << b[i] << " " << c[i] << endl;
}
} | replace | 34 | 35 | 34 | 35 | 0 | |
p02869 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define watch(x) cout << (#x) << "=" << (x) << '\n'
#define mset(d, val) memset(d, val, sizeof(d))
#define setp(x) cout << fixed << setprecision(x)
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fore(i, a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define F first
#define S second
#define INF ll(1e18)
#define MOD 998244353
#define pqueue priority_queue
#define fbo find_by_order
#define ook order_of_key
typedef long long ll;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef long double ld;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
#define MAXN 100005
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, k;
cin >> n >> k;
if (2 * k - 1 > n) {
cout << -1 << '\n';
return 0;
}
ll cur = k + 2 * n;
ll i = k;
ll j = cur - i;
bool used[MAXN];
mset(used, 0);
while (j > i) {
cout << i << " " << j << " " << cur << '\n';
used[i - k] = used[j - k] = 1;
cur++;
i += 2;
j--;
}
i = k + 1;
j = k + 2 * n - 1;
while (cur < k + 3 * n) {
while (used[j - k])
j--;
used[i - k] = used[j - k] = 1;
cout << i << " " << j << " " << cur << '\n';
cur++;
i += 2;
}
return 0;
}
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
#define watch(x) cout << (#x) << "=" << (x) << '\n'
#define mset(d, val) memset(d, val, sizeof(d))
#define setp(x) cout << fixed << setprecision(x)
#define forn(i, a, b) for (int i = a; i < b; i++)
#define fore(i, a, b) for (int i = a; i <= b; i++)
#define pb push_back
#define F first
#define S second
#define INF ll(1e18)
#define MOD 998244353
#define pqueue priority_queue
#define fbo find_by_order
#define ook order_of_key
typedef long long ll;
typedef pair<ll, ll> ii;
typedef vector<ll> vi;
typedef vector<ii> vii;
typedef long double ld;
typedef tree<ll, null_type, less<ll>, rb_tree_tag,
tree_order_statistics_node_update>
pbds;
#define MAXN 300005
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
ll n, k;
cin >> n >> k;
if (2 * k - 1 > n) {
cout << -1 << '\n';
return 0;
}
ll cur = k + 2 * n;
ll i = k;
ll j = cur - i;
bool used[MAXN];
mset(used, 0);
while (j > i) {
cout << i << " " << j << " " << cur << '\n';
used[i - k] = used[j - k] = 1;
cur++;
i += 2;
j--;
}
i = k + 1;
j = k + 2 * n - 1;
while (cur < k + 3 * n) {
while (used[j - k])
j--;
used[i - k] = used[j - k] = 1;
cout << i << " " << j << " " << cur << '\n';
cur++;
i += 2;
}
return 0;
}
| replace | 28 | 29 | 28 | 29 | 0 | |
p02869 | C++ | Runtime Error | #include <cstdio>
#define Maxn 100000
int k, n;
int ans[Maxn + 5][3];
int main() {
scanf("%d%d", &k, &n);
if (n < 2 * k - 1) {
puts("-1");
return 0;
}
int len = 0;
for (int i = 0; i < n / 2; i++) {
ans[++len][0] = k + n / 2 - 1 - i;
ans[len][1] = k + n + i * 2 + 1;
ans[len][2] = k + n * 2 + i;
}
for (int i = 0; i < (n + 1) / 2; i++) {
ans[++len][0] = k + n - 1 - i;
ans[len][1] = k + n + i * 2;
ans[len][2] = k + n * 2 + n / 2 + i;
}
for (int i = 1; i <= len; i++) {
printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}
return 0;
}
| #include <cstdio>
#define Maxn 100000
int k, n;
int ans[Maxn + 5][3];
int main() {
scanf("%d%d", &n, &k);
if (n < 2 * k - 1) {
puts("-1");
return 0;
}
int len = 0;
for (int i = 0; i < n / 2; i++) {
ans[++len][0] = k + n / 2 - 1 - i;
ans[len][1] = k + n + i * 2 + 1;
ans[len][2] = k + n * 2 + i;
}
for (int i = 0; i < (n + 1) / 2; i++) {
ans[++len][0] = k + n - 1 - i;
ans[len][1] = k + n + i * 2;
ans[len][2] = k + n * 2 + n / 2 + i;
}
for (int i = 1; i <= len; i++) {
printf("%d %d %d\n", ans[i][0], ans[i][1], ans[i][2]);
}
return 0;
}
| replace | 5 | 6 | 5 | 6 | 0 | |
p02869 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <class T> inline T updmax(T &a, T b) { return a = max(a, b); }
template <class T> inline T updmin(T &a, T b) { return a = min(a, b); }
class Solution {
public:
void solve() {
long long n, k;
cin >> n >> k;
if (2 * k - 1 > n) {
cout << "-1\n";
return;
}
vector<vector<long long>> ans(n, vector<long long>(3, 0));
for (int i = 0; i < n; i++)
ans[i][2] = k + 2 * n + i;
int idx = 0;
for (int i = 0; i < n; i++) {
ans[idx][1] = k + n + i;
idx += 2;
if (idx >= n)
idx = 1;
}
idx = 1;
for (int i = 0; i < n; i++) {
ans[idx][0] = k + i;
idx += 2;
if (idx >= n)
idx = 0;
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cout << ans[i][j] << " ";
cout << "\n";
}
return;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Solution solution;
solution.solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
template <class T> inline T updmax(T &a, T b) { return a = max(a, b); }
template <class T> inline T updmin(T &a, T b) { return a = min(a, b); }
class Solution {
public:
void solve() {
long long n, k;
cin >> n >> k;
if (2 * k - 1 > n) {
cout << "-1\n";
return;
}
vector<vector<long long>> ans(n, vector<long long>(3, 0));
for (int i = 0; i < n; i++)
ans[i][2] = k + 2 * n + i;
int x = k + n;
for (int i = 0; i < n; i += 2, x++)
ans[i][1] = x;
for (int i = 1; i < n; i += 2, x++)
ans[i][1] = x;
x = k;
for (int i = 1; i < n; i += 2, x++)
ans[i][0] = x;
for (int i = 0; i < n; i += 2, x++)
ans[i][0] = x;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cout << ans[i][j] << " ";
cout << "\n";
}
return;
}
};
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
Solution solution;
solution.solve();
return 0;
} | replace | 19 | 33 | 19 | 29 | -11 | |
p02869 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
// #define ll __int128
#define int ll
// #define int ll
// #define char ll
#define double ld
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;
#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for (int i = 0; i < int(n); ++i)
#define SZ(a) ((int)((a).size()))
#define triple(T) tuple<T, T, T>
#define quad(T) tuple<T, T, T, T>
#define watch(x) cerr << (#x) << " = " << (x) << endl;
#ifdef MAX_HOME
#define cerr cout
#else
#define cerr \
if (false) \
cerr
#endif
const double PI = 2 * acos(0.0);
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1>
inline istream &operator>>(istream &in, pair<T0, T1> &a) {
return in >> a.first >> a.second;
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T> inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
fori(i, a.size()) out << a[i]
<< vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MAX_HOME
freopen("input.txt", "r", stdin);
clock_t start = clock();
#endif
cout << setprecision(12) << fixed;
smain();
#ifdef MAX_HOME
cout << "\n\nTOTAL EXECUTION TIME: "
<< float(clock() - start) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
bool rec(vi a, vector<pair<int, pii>> &res) {
if (a.empty())
return true;
for (int i = 1; i < a.size(); ++i) {
for (int j = i + 1; j < a.size(); ++j) {
if (a[0] + a[i] <= a[j]) {
vi b = a;
b.erase(b.begin() + j);
b.erase(b.begin() + i);
b.erase(b.begin() + 0);
if (rec(b, res)) {
res.push_back({a[0], {a[i], a[j]}});
return true;
}
}
}
}
return false;
}
vector<pair<int, pii>> solve(int k, int n) {
vi a(3 * n);
fori(i, 3 * n) { a[i] = k + i; }
vector<pair<int, pii>> ret;
rec(a, ret);
return ret;
}
void bad() {
cout << "-1";
exit(0);
}
void smain() {
int n, k;
cin >> n >> k;
vector<pair<int, pii>> aans = solve(k, n);
watch(aans);
vi hi;
fori(i, n) { hi.push_back(2 * n + k + i); }
vi a(n), b(n);
fori(i, n) {
a[i] = k + i;
b[i] = k + n + i;
}
int f = -1;
for (int i = n - 1; i >= 0; --i) {
if (b[n - 1] + a[i] <= hi.back()) {
f = i;
break;
}
}
if (f == -1) {
bad();
}
vector<pair<int, pii>> kek;
for (int i = n - 1; i >= 0; --i) {
kek.push_back({b[i] + a[f], {b[i], a[f]}});
f--;
if (f == -1)
f = n - 1;
}
sort(ALL(kek));
fori(i, n) {
if (kek[i].first > hi[i])
bad();
}
fori(i, n) {
cout << kek[i].second.first << ' ' << kek[i].second.second << ' ' << hi[i]
<< '\n';
}
} | #include <bits/stdc++.h>
#include <random>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef double ld;
// #define ll __int128
#define int ll
// #define int ll
// #define char ll
#define double ld
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<vvc> vvvc;
typedef pair<int, int> pii;
typedef pair<pii, pii> piii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<pii> vpi;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<short> vs;
typedef vector<vs> vvs;
typedef vector<vvs> vvvs;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<vvl> vvvl;
typedef vector<ld> vld;
typedef vector<vld> vvld;
typedef vector<vvld> vvvld;
typedef vector<string> vst;
typedef vector<vst> vvst;
typedef pair<ld, ld> pld;
#define inmin(a, b) a = min(a, (b))
#define inmax(a, b) a = max(a, (b))
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.rbegin(), a.rend()
#define sqr(x) ((x) * (x))
#define fori(i, n) for (int i = 0; i < int(n); ++i)
#define SZ(a) ((int)((a).size()))
#define triple(T) tuple<T, T, T>
#define quad(T) tuple<T, T, T, T>
#define watch(x) cerr << (#x) << " = " << (x) << endl;
#ifdef MAX_HOME
#define cerr cout
#else
#define cerr \
if (false) \
cerr
#endif
const double PI = 2 * acos(0.0);
#define rand shittttty_shit
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rng_64(chrono::steady_clock::now().time_since_epoch().count());
const string DIGITS = "0123456789";
const string ALPH = "abcdefghijklmnopqrstuvwxyz";
template <class T0, class T1>
inline ostream &operator<<(ostream &out, pair<T0, T1> &a) {
return out << "{" << a.first << ", " << a.second << "}";
}
template <class T0, class T1>
inline istream &operator>>(istream &in, pair<T0, T1> &a) {
return in >> a.first >> a.second;
}
template <class T0, class T1, class T2>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< "}";
}
template <class T0, class T1, class T2, class T3>
inline ostream &operator<<(ostream &out, tuple<T0, T1, T2, T3> &a) {
return out << "{" << get<0>(a) << ", " << get<1>(a) << ", " << get<2>(a)
<< ", " << get<3>(a) << "}";
}
template <class T> inline ostream &operator<<(ostream &out, vector<T> &a) {
out << "[";
fori(i, a.size()) out << a[i]
<< vector<string>{", ", "] "}[i + 1 == a.size()];
return out;
}
void smain();
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifdef MAX_HOME
freopen("input.txt", "r", stdin);
clock_t start = clock();
#endif
cout << setprecision(12) << fixed;
smain();
#ifdef MAX_HOME
cout << "\n\nTOTAL EXECUTION TIME: "
<< float(clock() - start) / CLOCKS_PER_SEC << endl;
#endif
return 0;
}
bool rec(vi a, vector<pair<int, pii>> &res) {
if (a.empty())
return true;
for (int i = 1; i < a.size(); ++i) {
for (int j = i + 1; j < a.size(); ++j) {
if (a[0] + a[i] <= a[j]) {
vi b = a;
b.erase(b.begin() + j);
b.erase(b.begin() + i);
b.erase(b.begin() + 0);
if (rec(b, res)) {
res.push_back({a[0], {a[i], a[j]}});
return true;
}
}
}
}
return false;
}
vector<pair<int, pii>> solve(int k, int n) {
vi a(3 * n);
fori(i, 3 * n) { a[i] = k + i; }
vector<pair<int, pii>> ret;
rec(a, ret);
return ret;
}
void bad() {
cout << "-1";
exit(0);
}
void smain() {
int n, k;
cin >> n >> k;
// vector<pair<int, pii>> aans = solve(k, n);
// watch(aans);
vi hi;
fori(i, n) { hi.push_back(2 * n + k + i); }
vi a(n), b(n);
fori(i, n) {
a[i] = k + i;
b[i] = k + n + i;
}
int f = -1;
for (int i = n - 1; i >= 0; --i) {
if (b[n - 1] + a[i] <= hi.back()) {
f = i;
break;
}
}
if (f == -1) {
bad();
}
vector<pair<int, pii>> kek;
for (int i = n - 1; i >= 0; --i) {
kek.push_back({b[i] + a[f], {b[i], a[f]}});
f--;
if (f == -1)
f = n - 1;
}
sort(ALL(kek));
fori(i, n) {
if (kek[i].first > hi[i])
bad();
}
fori(i, n) {
cout << kek[i].second.first << ' ' << kek[i].second.second << ' ' << hi[i]
<< '\n';
}
} | replace | 149 | 151 | 149 | 151 | 0 | |
p02869 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
const int maxn = 1e5 + 10;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-')
f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
return x * f;
}
int k, m, n;
int a[maxn];
int main() {
n = read();
k = read();
long long sum = 0, ans = 0;
for (register int i = 0; i < 2 * n; i++)
sum += k + i;
for (register int i = 2 * n; i < 3 * n; i++)
ans += k + i;
if (ans < sum) {
puts("-1");
return 0;
}
for (register int i = 0; i < n * 2; i++) {
if (i % 2)
a[i] = i / 2 + k;
else
a[i] = i / 2 + k + n;
}
if (n % 2 == 0) {
for (register int i = 0; i < n; i++) {
if (i % 2 == 1)
a[i] += n;
else
a[i] -= n;
}
}
for (register int i = 0; i < n; i++)
printf("%d %d %d\n", a[i], a[i + n], k + n * 2 + i);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
const int maxn = 1e6 + 10;
int read() {
int x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-')
f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + c - 48;
c = getchar();
}
return x * f;
}
int k, m, n;
int a[maxn];
int main() {
n = read();
k = read();
long long sum = 0, ans = 0;
for (register int i = 0; i < 2 * n; i++)
sum += k + i;
for (register int i = 2 * n; i < 3 * n; i++)
ans += k + i;
if (ans < sum) {
puts("-1");
return 0;
}
for (register int i = 0; i < n * 2; i++) {
if (i % 2)
a[i] = i / 2 + k;
else
a[i] = i / 2 + k + n;
}
if (n % 2 == 0) {
for (register int i = 0; i < n; i++) {
if (i % 2 == 1)
a[i] += n;
else
a[i] -= n;
}
}
for (register int i = 0; i < n; i++)
printf("%d %d %d\n", a[i], a[i + n], k + n * 2 + i);
return 0;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p02869 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <random>
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
constexpr int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
constexpr int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
if (2 * k + 2 * n - 1 > k + 2 * n - 1 + (n + 1) / 2) {
cout << -1 << endl;
return 0;
}
vector<ll> a(n), b(n), c(n);
REP(i, n) {
a[i] = k + i;
b[i] = k + n + i;
c[i] = k + n + n + i;
}
int s = (n - 1) / 2;
REP(i, s) { swap(a[i], a[2 * s - i]); }
if (n % 2 == 0)
abort();
vector<int> pos(n);
REP(i, n) pos[i] = i;
sort(ALL(pos),
[&](int i, int j) { return a[i] + b[n - 1 - i] < a[j] + b[n - 1 - j]; });
REP(i, n) {
assert(a[pos[i]] + b[n - 1 - pos[i]] <= c[i]);
cout << a[pos[i]] << " " << b[n - 1 - pos[i]] << " " << c[i] << endl;
}
}
| #include "bits/stdc++.h"
#include <random>
#define REP(i, n) for (ll i = 0; i < ll(n); ++i)
#define RREP(i, n) for (ll i = ll(n) - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < ll(n); ++i)
#define RFOR(i, m, n) for (ll i = ll(n) - 1; i >= ll(m); --i)
#define ALL(v) (v).begin(), (v).end()
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
constexpr int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
constexpr int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using vvi = vector<vi>;
using vvl = vector<vl>;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
ll n, k;
cin >> n >> k;
if (2 * k + 2 * n - 1 > k + 2 * n - 1 + (n + 1) / 2) {
cout << -1 << endl;
return 0;
}
vector<ll> a(n), b(n), c(n);
REP(i, n) {
a[i] = k + i;
b[i] = k + n + i;
c[i] = k + n + n + i;
}
if (n & 1) {
int s = (n / 2 + 1) / 2, t = n / 4;
REP(i, s) { swap(a[i], a[2 * s - 1 - i]); }
REP(i, t) { swap(a[2 * s + i], a[2 * s + 2 * t - i]); }
} else {
int s = ((n - 1) / 2 + 1) / 2, t = (n - 1) / 4;
REP(i, s) { swap(a[i], a[2 * s - 1 - i]); }
REP(i, t) { swap(a[2 * s + i], a[2 * s + 2 * t - i]); }
}
vector<int> pos(n);
REP(i, n) pos[i] = i;
sort(ALL(pos),
[&](int i, int j) { return a[i] + b[n - 1 - i] < a[j] + b[n - 1 - j]; });
REP(i, n) {
assert(a[pos[i]] + b[n - 1 - pos[i]] <= c[i]);
cout << a[pos[i]] << " " << b[n - 1 - pos[i]] << " " << c[i] << endl;
}
}
| replace | 55 | 59 | 55 | 65 | 0 | |
p02870 | C++ | Memory Limit Exceeded | #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); i++)
#define pb push_back
#define ALL(x) (x).begin(), (x).end()
#define st first
#define nd second
using namespace std;
const int maxN = 1 << 13;
const int mod = 998244353;
template <class T1, class T2> inline void addMod(T1 &a, T2 b) {
a = (a + b) % mod;
}
template <class T1, class T2> inline void multMod(T1 &a, T2 b) {
a = a * b % mod;
}
long long qpow(long long a, long long b) {
long long res0 = 1;
for (; b != 0; b >>= 1) {
if (b & 1)
multMod(res0, a);
multMod(a, a);
}
return res0;
}
vector<int> vs[maxN][maxN];
char in[maxN][maxN];
bool can[maxN][maxN], canot[maxN][maxN], meet[maxN][maxN], vis[maxN];
int state[maxN], xr;
vector<int> G[maxN];
void ans(long long a) {
printf("%lld\n", a);
exit(0);
}
void dfs(int v) {
xr ^= state[v];
vis[v] = true;
for (int u : G[v])
if (!vis[u])
dfs(u);
}
long long f(int v, int n, int m) {
if (n % 2 == 0)
return qpow(2, m);
int comps = 0;
for (; v < n * 2; v += 2)
if (!vis[v]) {
xr = 0;
dfs(v);
if (xr != 0)
return 0;
comps++;
}
return qpow(2, m - n + comps);
}
void solve() {
int n;
scanf("%d", &n);
n++;
FOR(i, 1, n - 1)
scanf("%s", &in[i][1]);
FOR(i, 1, n - 1)
vs[i][i].pb(0), vs[i][n - 1 - i].pb(n - 1);
FOR(v, 1, n - 1) {
int j0 = v, j1 = v, d0 = -1, d1 = 1;
FOR(i, 1, n - 1) {
j0 += d0, j1 += d1;
for (int j : {j0, j1})
vs[i][j].pb(v);
if (j0 == 0)
d0 = 1;
if (j1 == n - 1)
d1 = -1;
}
}
FOR(i, 1, n - 1) FOR(j, 1, n - 1) {
assert(vs[i][j].size() == 2);
int u = vs[i][j][0], v = vs[i][j][1];
if (in[i][j] != '?')
in[i][j] == 'o' ? can[u][v] = can[v][u] = true
: canot[u][v] = canot[v][u] = true;
meet[v][u] = meet[u][v] = true;
}
int m0 = 0, m1 = 0;
FOR(v, 0, n) FOR(u, 0, v) {
if (can[v][u] and canot[v][u])
ans(0);
if (!can[v][u] and !canot[v][u] and meet[v][u]) {
G[u].pb(v), G[v].pb(u);
u % 2 ? m1++ : m0++;
}
if (can[v][u])
state[v] ^= 1, state[u] ^= 1;
}
long long res = f(0, (n + 1) / 2, m0);
multMod(res, f(1, n / 2, m1));
ans(res);
}
int main() {
int t;
t = 1; // scanf ("%d", &t);
while (t--)
solve();
return 0;
}
| #pragma GCC optimize("O3")
#include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = (a); i < (int)(b); i++)
#define pb push_back
#define ALL(x) (x).begin(), (x).end()
#define st first
#define nd second
using namespace std;
const int maxN = 1 << 11;
const int mod = 998244353;
template <class T1, class T2> inline void addMod(T1 &a, T2 b) {
a = (a + b) % mod;
}
template <class T1, class T2> inline void multMod(T1 &a, T2 b) {
a = a * b % mod;
}
long long qpow(long long a, long long b) {
long long res0 = 1;
for (; b != 0; b >>= 1) {
if (b & 1)
multMod(res0, a);
multMod(a, a);
}
return res0;
}
vector<int> vs[maxN][maxN];
char in[maxN][maxN];
bool can[maxN][maxN], canot[maxN][maxN], meet[maxN][maxN], vis[maxN];
int state[maxN], xr;
vector<int> G[maxN];
void ans(long long a) {
printf("%lld\n", a);
exit(0);
}
void dfs(int v) {
xr ^= state[v];
vis[v] = true;
for (int u : G[v])
if (!vis[u])
dfs(u);
}
long long f(int v, int n, int m) {
if (n % 2 == 0)
return qpow(2, m);
int comps = 0;
for (; v < n * 2; v += 2)
if (!vis[v]) {
xr = 0;
dfs(v);
if (xr != 0)
return 0;
comps++;
}
return qpow(2, m - n + comps);
}
void solve() {
int n;
scanf("%d", &n);
n++;
FOR(i, 1, n - 1)
scanf("%s", &in[i][1]);
FOR(i, 1, n - 1)
vs[i][i].pb(0), vs[i][n - 1 - i].pb(n - 1);
FOR(v, 1, n - 1) {
int j0 = v, j1 = v, d0 = -1, d1 = 1;
FOR(i, 1, n - 1) {
j0 += d0, j1 += d1;
for (int j : {j0, j1})
vs[i][j].pb(v);
if (j0 == 0)
d0 = 1;
if (j1 == n - 1)
d1 = -1;
}
}
FOR(i, 1, n - 1) FOR(j, 1, n - 1) {
assert(vs[i][j].size() == 2);
int u = vs[i][j][0], v = vs[i][j][1];
if (in[i][j] != '?')
in[i][j] == 'o' ? can[u][v] = can[v][u] = true
: canot[u][v] = canot[v][u] = true;
meet[v][u] = meet[u][v] = true;
}
int m0 = 0, m1 = 0;
FOR(v, 0, n) FOR(u, 0, v) {
if (can[v][u] and canot[v][u])
ans(0);
if (!can[v][u] and !canot[v][u] and meet[v][u]) {
G[u].pb(v), G[v].pb(u);
u % 2 ? m1++ : m0++;
}
if (can[v][u])
state[v] ^= 1, state[u] ^= 1;
}
long long res = f(0, (n + 1) / 2, m0);
multMod(res, f(1, n / 2, m1));
ans(res);
}
int main() {
int t;
t = 1; // scanf ("%d", &t);
while (t--)
solve();
return 0;
}
| replace | 9 | 10 | 9 | 10 | MLE | |
p02873 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int a[100000], min;
char s[100000];
long int sum;
scanf("%s", s);
a[0] = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] == '<')
a[i + 1] = a[i] + 1;
else
a[i + 1] = a[i] - 1;
}
/*
printf("%d",a[0]);
for(int i=0;s[i]!='\0';i++) printf(",%d",a[i+1]);
printf("\n");
*/
for (int i = 0;; i++) {
if (i > 0 && s[i - 1] == '\0')
break;
if (s[i - 1] == '>' && (s[i] == '<' || s[i] == '\0')) {
min = -1 * a[i];
a[i] = 0;
for (int j = 1; s[i - j] == '>' && i - j >= 0; j++) {
a[i - j] += min;
}
for (int j = 0; s[i + j] == '<' && s[i] != '\0'; j++) {
a[i + j + 1] += min;
}
}
}
/*
printf("%d",a[0]);
for(int i=0;s[i]!='\0';i++)
if(s[i]=='<'&&s[i+1]=='>'){
if(a[i]>a[i+2]) printf(",%d",a[i]+1);
else printf(",%d",a[i+2]+1);
}
else printf(",%d",a[i+1]);
printf("\n");
*/
sum = a[0];
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] == '<' && s[i + 1] == '>') {
if (a[i] > a[i + 2])
sum += a[i] + 1;
else
sum += a[i + 2] + 1;
} else
sum += a[i + 1];
}
printf("%ld\n", sum);
return 0;
} | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int a[500000], min;
char s[500000];
long int sum;
scanf("%s", s);
a[0] = 0;
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] == '<')
a[i + 1] = a[i] + 1;
else
a[i + 1] = a[i] - 1;
}
/*
printf("%d",a[0]);
for(int i=0;s[i]!='\0';i++) printf(",%d",a[i+1]);
printf("\n");
*/
for (int i = 0;; i++) {
if (i > 0 && s[i - 1] == '\0')
break;
if (s[i - 1] == '>' && (s[i] == '<' || s[i] == '\0')) {
min = -1 * a[i];
a[i] = 0;
for (int j = 1; s[i - j] == '>' && i - j >= 0; j++) {
a[i - j] += min;
}
for (int j = 0; s[i + j] == '<' && s[i] != '\0'; j++) {
a[i + j + 1] += min;
}
}
}
/*
printf("%d",a[0]);
for(int i=0;s[i]!='\0';i++)
if(s[i]=='<'&&s[i+1]=='>'){
if(a[i]>a[i+2]) printf(",%d",a[i]+1);
else printf(",%d",a[i+2]+1);
}
else printf(",%d",a[i+1]);
printf("\n");
*/
sum = a[0];
for (int i = 0; s[i] != '\0'; i++) {
if (s[i] == '<' && s[i + 1] == '>') {
if (a[i] > a[i + 2])
sum += a[i] + 1;
else
sum += a[i + 2] + 1;
} else
sum += a[i + 1];
}
printf("%ld\n", sum);
return 0;
} | replace | 8 | 10 | 8 | 10 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define nmax 500005
#define oo 1000000007
#define reset(x, y) memset(x, y, sizeof(x))
#define s second
#define f first
#define PB(x) push_back(x)
#define Task ""
#define For(i, x, y) for (int i = x; i <= y; i++)
#define Fod(i, x, y) for (int i = x; i >= y; i--)
#define FOR(i, x) for (int i : x)
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vti;
typedef vector<vti> vtv;
typedef vector<ll> vli;
string s;
int n;
vti e[nmax];
int deg[nmax];
int Q[nmax];
void Enter() {
cin >> s;
n = s.length();
s = ' ' + s;
reset(deg, 0);
For(i, 1, n) if (s[i] == '<') e[i].PB(i + 1);
else e[i + 1].PB(i);
}
void Solve() {
queue<int> q;
For(i, 1, n + 1) if (!deg[i]) q.push(i);
int dem = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : e[u]) {
Q[v] = Q[u] + 1;
q.push(v);
}
}
ll res = 0;
For(i, 1, n + 1) res += Q[i];
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen(Task".inp", "r", stdin);
// freopen(Task".out", "w", stdout);
Enter();
Solve();
}
| #include <bits/stdc++.h>
#define nmax 500005
#define oo 1000000007
#define reset(x, y) memset(x, y, sizeof(x))
#define s second
#define f first
#define PB(x) push_back(x)
#define Task ""
#define For(i, x, y) for (int i = x; i <= y; i++)
#define Fod(i, x, y) for (int i = x; i >= y; i--)
#define FOR(i, x) for (int i : x)
using namespace std;
typedef long long ll;
typedef unsigned int ui;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pii;
typedef vector<int> vti;
typedef vector<vti> vtv;
typedef vector<ll> vli;
string s;
int n;
vti e[nmax];
int deg[nmax];
int Q[nmax];
void Enter() {
cin >> s;
n = s.length();
s = ' ' + s;
reset(deg, 0);
For(i, 1, n) if (s[i] == '<') {
e[i].PB(i + 1);
deg[i + 1]++;
}
else {
e[i + 1].PB(i);
deg[i]++;
}
}
void Solve() {
queue<int> q;
For(i, 1, n + 1) if (!deg[i]) q.push(i);
int dem = 0;
while (!q.empty()) {
int u = q.front();
q.pop();
for (int v : e[u]) {
Q[v] = Q[u] + 1;
q.push(v);
}
}
ll res = 0;
For(i, 1, n + 1) res += Q[i];
cout << res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
// freopen(Task".inp", "r", stdin);
// freopen(Task".out", "w", stdout);
Enter();
Solve();
}
| replace | 34 | 36 | 34 | 42 | TLE | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn];
long long get(int x) { return 1ll * (x - 1) * x / 2; }
int main() {
freopen("inp.txt", "r", stdin);
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
long long res = 0;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && s[j] == '<') {
j++;
}
int len = j - i;
int i1 = j;
while (j < n && s[j] == '>') {
j++;
}
int len1 = j - i1;
// cerr << len <<" " << len1 << endl;
res += get(min(len, len1)) + get(max(len, len1) + 1);
i = j - 1;
}
cout << res;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[maxn];
long long get(int x) { return 1ll * (x - 1) * x / 2; }
int main() {
// freopen("inp.txt", "r", stdin);
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
int n = s.length();
long long res = 0;
for (int i = 0; i < n; i++) {
int j = i;
while (j < n && s[j] == '<') {
j++;
}
int len = j - i;
int i1 = j;
while (j < n && s[j] == '>') {
j++;
}
int len1 = j - i1;
// cerr << len <<" " << len1 << endl;
res += get(min(len, len1)) + get(max(len, len1) + 1);
i = j - 1;
}
cout << res;
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02873 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3fLL
// #define mod 998244353
#define MOD 1000000007
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pint;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pint> vpint;
int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
const int SIZE = 100050;
// ↑templete
int main() {
string S;
cin >> S;
int N = S.length();
ll A[SIZE] = {}, B[SIZE] = {};
int a = 0;
for (int i = 0; i <= N; i++) {
if (i == N) {
A[i] = a;
continue;
}
if (S[i] == '<') {
A[i] = a;
a++;
} else {
A[i] = a;
a = 0;
}
}
int b = 0;
for (int i = N; i >= 0; i--) {
if (i == 0) {
B[i] = b;
continue;
}
if (S[i - 1] == '>') {
B[i] = b;
b++;
} else {
B[i] = b;
b = 0;
}
}
ll ans = 0;
for (int i = 0; i <= N; i++)
ans += max(A[i], B[i]);
cout << ans << endl;
return 0;
} | #define _CRT_SECURE_NO_WARNINGS
#define _USE_MATH_DEFINES
#include <algorithm>
#include <array>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <utility>
#include <vector>
using namespace std;
#define INF 0x3f3f3f3f
#define INFLL 0x3f3f3f3f3f3f3f3fLL
// #define mod 998244353
#define MOD 1000000007
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef pair<int, int> pint;
typedef pair<ll, ll> pll;
typedef tuple<int, int, int> tint;
typedef vector<int> vint;
typedef vector<ll> vll;
typedef vector<ull> vull;
typedef vector<pint> vpint;
int dx[8] = {0, 0, -1, 1, 1, 1, -1, -1};
int dy[8] = {-1, 1, 0, 0, 1, -1, 1, -1};
const int SIZE = 500050;
// ↑templete
int main() {
string S;
cin >> S;
int N = S.length();
ll A[SIZE] = {}, B[SIZE] = {};
int a = 0;
for (int i = 0; i <= N; i++) {
if (i == N) {
A[i] = a;
continue;
}
if (S[i] == '<') {
A[i] = a;
a++;
} else {
A[i] = a;
a = 0;
}
}
int b = 0;
for (int i = N; i >= 0; i--) {
if (i == 0) {
B[i] = b;
continue;
}
if (S[i - 1] == '>') {
B[i] = b;
b++;
} else {
B[i] = b;
b = 0;
}
}
ll ans = 0;
for (int i = 0; i <= N; i++)
ans += max(A[i], B[i]);
cout << ans << endl;
return 0;
} | replace | 45 | 46 | 45 | 46 | 0 | |
p02873 | C++ | Runtime Error | ///------------------ ONESHOTAC -------------------
#include <bits/stdc++.h>
#define FOR(i, j, k) for (int i = j; i <= k; i++)
#define FORD(i, j, k) for (int i = j; i >= k; i--)
#define mp make_pair
// #define f first
// #define s second
// #define int long long
using namespace std;
const int MOD = 1e9 + 7;
const int N = 200005;
int n;
int res[N];
string s;
int d[N];
vector<int> ke[N];
long long sum = 0;
void BFS() {
queue<int> qu;
FOR(i, 1, n) {
if (d[i] == 0) {
qu.push(i);
}
}
while (qu.size()) {
int u = qu.front();
qu.pop();
for (int v : ke[u]) {
d[v]--;
if (d[v] == 0) {
res[v] = res[u] + 1;
qu.push(v);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("AGC040.inp","r",stdin);
// freopen("AGC040.out","w",stdout);
cin >> s;
s = ' ' + s;
n = s.size();
FOR(i, 1, n - 1) {
if (s[i] == '>') {
// ke[i].push_back(i + 1);
d[i]++;
ke[i + 1].push_back(i);
} else {
// ke[i + 1].push_back(i);
d[i + 1]++;
ke[i].push_back(i + 1);
}
}
BFS();
FOR(i, 1, n) sum += res[i];
cout << sum;
return 0;
}
| ///------------------ ONESHOTAC -------------------
#include <bits/stdc++.h>
#define FOR(i, j, k) for (int i = j; i <= k; i++)
#define FORD(i, j, k) for (int i = j; i >= k; i--)
#define mp make_pair
// #define f first
// #define s second
// #define int long long
using namespace std;
const int MOD = 1e9 + 7;
const int N = 500005;
int n;
int res[N];
string s;
int d[N];
vector<int> ke[N];
long long sum = 0;
void BFS() {
queue<int> qu;
FOR(i, 1, n) {
if (d[i] == 0) {
qu.push(i);
}
}
while (qu.size()) {
int u = qu.front();
qu.pop();
for (int v : ke[u]) {
d[v]--;
if (d[v] == 0) {
res[v] = res[u] + 1;
qu.push(v);
}
}
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// freopen("AGC040.inp","r",stdin);
// freopen("AGC040.out","w",stdout);
cin >> s;
s = ' ' + s;
n = s.size();
FOR(i, 1, n - 1) {
if (s[i] == '>') {
// ke[i].push_back(i + 1);
d[i]++;
ke[i + 1].push_back(i);
} else {
// ke[i + 1].push_back(i);
d[i + 1]++;
ke[i].push_back(i + 1);
}
}
BFS();
FOR(i, 1, n) sum += res[i];
cout << sum;
return 0;
}
| replace | 11 | 12 | 11 | 12 | 0 | |
p02873 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define pb push_back
#define eb emplace_back
#define ins insert
#define ph push
#define f first
#define s second
#define cbr cerr << "hi\n"
#define mmst(x, v) memset((x), v, sizeof((x)))
#define siz(x) ((ll)x.size())
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
#define btinpct(x) __builtin_popcountll((x))
mt19937
rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // can be used by calling rng() or shuffle(A, A+n, rng)
inline long long rand(long long x, long long y) {
return (rng() % (y + 1 - x)) + x;
} // inclusivesss
string inline to_string(char c) {
string s(1, c);
return s;
}
template <typename T> inline T gcd(T a, T b) {
return a == 0 ? b : gcd(b % a, a);
}
#define ll long long int
#define ld long double
#define FOR(ii, ss, ee) for (ll ii = (ss); ii <= (ll)(ee); ++ii)
#define DEC(ii, ss, ee) for (ll ii = (ss); ii >= (ll)(ee); --ii)
typedef pair<ll, ll> pi;
typedef pair<ll, pi> spi;
typedef pair<pi, pi> dpi;
#define LLINF ((long long)1e18) // 1234567890987654321
#define INF 1234567890ll
// #define cerr if(0)cout
#define MAXN (500003)
int main() {
FAST string s;
cin >> s;
vector<pair<ll, char>> v;
FOR(i, 0, s.size() - 1) {
if (v.empty())
v.eb(1, s[i]);
else if (s[i] == s[i - 1])
++v.back().f;
else
v.eb(1, s[i]);
}
ll ans = 0;
FOR(i, 1, siz(v) - 1) if (v[i - 1].s == '<' && v[i].s == '>') {
ans += v[i - 1].f * (v[i - 1].f - 1) / 2;
ans += v[i].f * (v[i].f - 1) / 2;
ans += max(v[i].f, v[i - 1].f);
}
if (v.size() & 1)
assert(0), ans += v.back().f * (v.back().f + 1) / 2;
if (v.size() > 1 && v[0].s == '>')
assert(0), ans += v[0].f * (v[0].f + 1) / 2;
cout << ans << '\n';
}
| #include "bits/stdc++.h"
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(0);
#define pb push_back
#define eb emplace_back
#define ins insert
#define ph push
#define f first
#define s second
#define cbr cerr << "hi\n"
#define mmst(x, v) memset((x), v, sizeof((x)))
#define siz(x) ((ll)x.size())
#define all(x) (x).begin(), (x).end()
#define lbd(x, y) lower_bound(all(x), y)
#define ubd(x, y) upper_bound(all(x), y)
#define btinpct(x) __builtin_popcountll((x))
mt19937
rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // can be used by calling rng() or shuffle(A, A+n, rng)
inline long long rand(long long x, long long y) {
return (rng() % (y + 1 - x)) + x;
} // inclusivesss
string inline to_string(char c) {
string s(1, c);
return s;
}
template <typename T> inline T gcd(T a, T b) {
return a == 0 ? b : gcd(b % a, a);
}
#define ll long long int
#define ld long double
#define FOR(ii, ss, ee) for (ll ii = (ss); ii <= (ll)(ee); ++ii)
#define DEC(ii, ss, ee) for (ll ii = (ss); ii >= (ll)(ee); --ii)
typedef pair<ll, ll> pi;
typedef pair<ll, pi> spi;
typedef pair<pi, pi> dpi;
#define LLINF ((long long)1e18) // 1234567890987654321
#define INF 1234567890ll
// #define cerr if(0)cout
#define MAXN (500003)
int main() {
FAST string s;
cin >> s;
vector<pair<ll, char>> v;
FOR(i, 0, s.size() - 1) {
if (v.empty())
v.eb(1, s[i]);
else if (s[i] == s[i - 1])
++v.back().f;
else
v.eb(1, s[i]);
}
ll ans = 0;
FOR(i, 1, siz(v) - 1) if (v[i - 1].s == '<' && v[i].s == '>') {
ans += v[i - 1].f * (v[i - 1].f - 1) / 2;
ans += v[i].f * (v[i].f - 1) / 2;
ans += max(v[i].f, v[i - 1].f);
}
if (v.back().s == '<')
ans += v.back().f * (v.back().f + 1) / 2;
if (v[0].s == '>')
ans += v[0].f * (v[0].f + 1) / 2;
cout << ans << '\n';
}
| replace | 64 | 68 | 64 | 68 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main(void) {
char S[1000000];
cin >> S;
vector<int> vec;
for (int i = 0; S[i] != '\0';) {
if (S[i] == '<') {
int n = 0;
// vec.push_back(n);
while (S[i] == '<') {
n++;
vec.push_back(n);
i++;
}
} else {
int n = 0;
while (S[i] == '>') {
n++;
i++;
}
if (vec[vec.size() - 1] < n) {
vec[vec.size() - 1] = n;
}
n--;
while (n >= 0) {
vec.push_back(n);
n--;
}
}
}
long long sum = 0;
for (int i = 0; i < vec.size(); i++) {
sum += vec[i];
// cout << vec[i] << " ";
}
// cout << endl;
cout << sum << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(void) {
char S[1000000];
cin >> S;
vector<int> vec;
for (int i = 0; S[i] != '\0';) {
if (S[i] == '<') {
int n = 0;
// vec.push_back(n);
while (S[i] == '<') {
n++;
vec.push_back(n);
i++;
}
} else {
int n = 0;
while (S[i] == '>') {
n++;
i++;
}
if (vec.size() != 0) {
if (vec[vec.size() - 1] < n) {
vec[vec.size() - 1] = n;
}
} else {
vec.push_back(n);
}
n--;
while (n >= 0) {
vec.push_back(n);
n--;
}
}
}
long long sum = 0;
for (int i = 0; i < vec.size(); i++) {
sum += vec[i];
// cout << vec[i] << " ";
}
// cout << endl;
cout << sum << endl;
return 0;
} | replace | 26 | 28 | 26 | 32 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
// use gp_hash_table<int,int,custom_hash> m;
// in place of map
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define repa(i, a, n) for (int i = a; i < n; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; --i)
#define repba(i, b, a) for (int i = b; i >= a; --i)
#define repab(i, a, b) for (int i = a; i < b; ++i)
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define msi map<string, int>
#define mii map<int, int>
#define viip vector<pair<int, pair<int, int>>>
#define mp make_pair
#define vip vector<pair<int, int>>
#define pb push_back
#define po pop_back
#define fi first
#define sec second
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define s(v) v.size()
ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // use rng()%n for numbers in range [0,n-1]
// This custom_hash is for unordered_map
// use map<int, int, custom_hash> mp;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
#ifndef ONLINE_JUDGE
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
string s;
cin >> s;
ll sum = 0;
int n = (int)s(s) + 1;
vi v(n);
v[0] = 0;
int c = 0;
rep(i, n - 1) {
if (s[i] == '<') {
c++;
v[i + 1] = c;
} else {
c = 0;
v[i + 1] = 0;
}
v[i + 1] = c;
}
// rep(i,n){
// cout<<v[i]<<" ";
// }
// cout<<"\n";
c = 0;
repr(i, n - 1) {
if (s[i] == '>') {
c++;
v[i] = max(v[i], c);
} else {
c = 0;
continue;
}
}
rep(i, n) {
// cout<<v[i]<<" ";
sum += v[i];
}
cout << sum;
return 0;
} | #include <bits/stdc++.h>
// use gp_hash_table<int,int,custom_hash> m;
// in place of map
#include <ext/pb_ds/assoc_container.hpp>
using namespace std;
using namespace __gnu_pbds;
#define rep(i, n) for (int i = 0; i < n; ++i)
#define repa(i, a, n) for (int i = a; i < n; ++i)
#define repr(i, n) for (int i = n - 1; i >= 0; --i)
#define repba(i, b, a) for (int i = b; i >= a; --i)
#define repab(i, a, b) for (int i = a; i < b; ++i)
#define ll long long
#define ull unsigned long long
#define vi vector<int>
#define msi map<string, int>
#define mii map<int, int>
#define viip vector<pair<int, pair<int, int>>>
#define mp make_pair
#define vip vector<pair<int, int>>
#define pb push_back
#define po pop_back
#define fi first
#define sec second
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define s(v) v.size()
ll mod = 1000000007;
mt19937 rng(chrono::steady_clock::now()
.time_since_epoch()
.count()); // use rng()%n for numbers in range [0,n-1]
// This custom_hash is for unordered_map
// use map<int, int, custom_hash> mp;
struct custom_hash {
static uint64_t splitmix64(uint64_t x) {
// http://xorshift.di.unimi.it/splitmix64.c
x += 0x9e3779b97f4a7c15;
x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9;
x = (x ^ (x >> 27)) * 0x94d049bb133111eb;
return x ^ (x >> 31);
}
size_t operator()(uint64_t x) const {
static const uint64_t FIXED_RANDOM =
chrono::steady_clock::now().time_since_epoch().count();
return splitmix64(x + FIXED_RANDOM);
}
};
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
// #ifndef ONLINE_JUDGE
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// #endif
string s;
cin >> s;
ll sum = 0;
int n = (int)s(s) + 1;
vi v(n);
v[0] = 0;
int c = 0;
rep(i, n - 1) {
if (s[i] == '<') {
c++;
v[i + 1] = c;
} else {
c = 0;
v[i + 1] = 0;
}
v[i + 1] = c;
}
// rep(i,n){
// cout<<v[i]<<" ";
// }
// cout<<"\n";
c = 0;
repr(i, n - 1) {
if (s[i] == '>') {
c++;
v[i] = max(v[i], c);
} else {
c = 0;
continue;
}
}
rep(i, n) {
// cout<<v[i]<<" ";
sum += v[i];
}
cout << sum;
return 0;
} | replace | 57 | 61 | 57 | 61 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 2e5 + 10;
char c[maxn];
int len, head[maxn], num;
struct Le {
int nt, to;
} edge[maxn << 1];
bool vis[maxn];
int M[maxn];
void dfs(int u, int dis) {
M[u] = max(M[u], dis);
for (int i = head[u]; i; i = edge[i].nt) {
int v = edge[i].to;
dfs(v, dis + 1);
}
}
ll ans;
void add(int f, int t) {
edge[++num].nt = head[f];
edge[num].to = t;
head[f] = num;
}
int main() {
scanf("%s", c + 1);
len = strlen(c + 1);
for (int i = 1; i <= len; ++i) {
if (c[i] == '>')
add(i + 1, i), vis[i] = 1;
else
add(i, i + 1), vis[i + 1] = 1;
}
for (int i = 1; i <= len + 1; ++i) {
// cout<<vis[i]<<"*";
if (!vis[i])
dfs(i, 0);
} // puts("");
for (int i = 1; i <= len + 1; ++i)
ans += M[i]; //,cout<<M[i]<<" ";
// puts("");
cout << ans << "\n";
return 0;
} | #include <bits/stdc++.h>
#define ll long long
using namespace std;
const int maxn = 5e5 + 10;
char c[maxn];
int len, head[maxn], num;
struct Le {
int nt, to;
} edge[maxn << 1];
bool vis[maxn];
int M[maxn];
void dfs(int u, int dis) {
M[u] = max(M[u], dis);
for (int i = head[u]; i; i = edge[i].nt) {
int v = edge[i].to;
dfs(v, dis + 1);
}
}
ll ans;
void add(int f, int t) {
edge[++num].nt = head[f];
edge[num].to = t;
head[f] = num;
}
int main() {
scanf("%s", c + 1);
len = strlen(c + 1);
for (int i = 1; i <= len; ++i) {
if (c[i] == '>')
add(i + 1, i), vis[i] = 1;
else
add(i, i + 1), vis[i + 1] = 1;
}
for (int i = 1; i <= len + 1; ++i) {
// cout<<vis[i]<<"*";
if (!vis[i])
dfs(i, 0);
} // puts("");
for (int i = 1; i <= len + 1; ++i)
ans += M[i]; //,cout<<M[i]<<" ";
// puts("");
cout << ans << "\n";
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02873 | C++ | Runtime Error | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, x) for (int i = 0; i < x; i++)
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
const ll MOD = 1e9 + 7;
const int n_max = 1e5 + 10;
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(tail) != 0)
cout << ' ';
print(forward<Tail>(tail)...);
}
template <class T> void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back())
cout << ' ';
}
cout << endl;
}
template <class T> void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
int main() {
string s;
cin >> s;
ll n = s.size() + 1;
ll INF = INT_MAX;
vector<ll> a(n, -INF);
vector<ll> btm;
rep(i, n - 2) {
if (i == 0 && s[i] == '<')
btm.push_back(i);
if (s[i] == '>' && s[i + 1] == '<')
btm.push_back(i + 1);
if (i == n - 3 && s[i + 1] == '>')
btm.push_back(i + 2);
}
for (auto i : btm)
a[i] = 0;
// 左に更新
for (auto i : btm) {
ll temp = 1;
while (i - temp >= 0 && s[i - temp] == '>') {
a[i - temp] = temp;
temp++;
}
}
// 右に更新
for (auto i : btm) {
ll temp = 1;
while (i + temp <= n - 1 && s[i + temp - 1] == '<') {
a[i + temp] = max(a[i + temp], temp);
temp++;
}
}
// print(btm);
// print(a);
ll res = 0;
rep(i, n) {
res += a[i];
assert(a[i] != -INF);
}
cout << res << endl;
} | #include <algorithm>
#include <bits/stdc++.h>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, x) for (int i = 0; i < x; i++)
#define pb push_back
#define mp make_pair
typedef long long ll;
typedef long double ld;
typedef pair<int, int> P;
typedef pair<ll, ll> Pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<vector<vector<int>>> vvvi;
const ll MOD = 1e9 + 7;
const int n_max = 1e5 + 10;
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head &&head, Tail &&...tail) {
cout << head;
if (sizeof...(tail) != 0)
cout << ' ';
print(forward<Tail>(tail)...);
}
template <class T> void print(vector<T> &vec) {
for (auto &a : vec) {
cout << a;
if (&a != &vec.back())
cout << ' ';
}
cout << endl;
}
template <class T> void print(vector<vector<T>> &df) {
for (auto &vec : df) {
print(vec);
}
}
int main() {
string s;
cin >> s;
ll n = s.size() + 1;
ll INF = INT_MAX;
vector<ll> a(n, -INF);
vector<ll> btm;
rep(i, n - 2) {
if (i == 0 && s[i] == '<')
btm.push_back(i);
if (s[i] == '>' && s[i + 1] == '<')
btm.push_back(i + 1);
if (i == n - 3 && s[i + 1] == '>')
btm.push_back(i + 2);
}
if (n == 2) {
if (s[0] == '>')
btm.push_back(1);
else
btm.push_back(0);
}
for (auto i : btm)
a[i] = 0;
// 左に更新
for (auto i : btm) {
ll temp = 1;
while (i - temp >= 0 && s[i - temp] == '>') {
a[i - temp] = temp;
temp++;
}
}
// 右に更新
for (auto i : btm) {
ll temp = 1;
while (i + temp <= n - 1 && s[i + temp - 1] == '<') {
a[i + temp] = max(a[i + temp], temp);
temp++;
}
}
// print(btm);
// print(a);
ll res = 0;
rep(i, n) {
res += a[i];
assert(a[i] != -INF);
}
cout << res << endl;
} | insert | 60 | 60 | 60 | 66 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
struct io {
io() {
ios::sync_with_stdio(false);
cin.tie(0);
};
};
const int MOD = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 62;
int main(void) {
string s;
cin >> s;
vll v(s.size() + 1, -1);
vi point;
if (s[0] == '<')
point.push_back(0);
if (s[s.size() - 1] == '>')
point.push_back(s.size());
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == '>' && s[i + 1] == '<')
point.push_back(i + 1);
}
for (int i = 0; i < point.size(); i++) {
v[point[i]] = 0;
}
for (int I = 0; I < point.size(); I++) {
int start = point[I];
// 左
for (int i = start; i > 0; i--) {
if (s[i - 1] == '>')
v[i - 1] = max(v[i - 1], v[i] + 1);
else {
break;
}
}
// 右
for (int i = start; i < v.size() - 1; i++) {
if (s[i] == '<') {
v[i + 1] = max(v[i + 1], v[i] + 1);
}
}
}
ll sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += v[i];
}
fin(sum);
}
| #include <algorithm>
#include <bitset>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
typedef long double ld;
typedef long long int ll;
typedef unsigned long long int ull;
typedef vector<int> vi;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<double> vd;
typedef vector<string> vs;
typedef vector<ll> vll;
typedef vector<pair<int, int>> vpii;
typedef vector<vector<int>> vvi;
typedef vector<vector<char>> vvc;
typedef vector<vector<string>> vvs;
typedef vector<vector<ll>> vvll;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rrep(i, n) for (int i = 1; i <= (n); ++i)
#define drep(i, n) for (int i = (n)-1; i >= 0; --i)
#define fin(ans) cout << (ans) << endl
#define STI(s) atoi(s.c_str())
#define mp(p, q) make_pair(p, q)
#define pb(n) push_back(n)
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define Sort(a) sort(a.begin(), a.end())
#define Rort(a) sort(a.rbegin(), a.rend())
#define MATHPI acos(-1)
#define itn int
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
struct io {
io() {
ios::sync_with_stdio(false);
cin.tie(0);
};
};
const int MOD = 1000000007;
const int INF = INT_MAX;
const ll LLINF = 1LL << 62;
int main(void) {
string s;
cin >> s;
vll v(s.size() + 1, -1);
vi point;
if (s[0] == '<')
point.push_back(0);
if (s[s.size() - 1] == '>')
point.push_back(s.size());
for (int i = 0; i < s.size() - 1; i++) {
if (s[i] == '>' && s[i + 1] == '<')
point.push_back(i + 1);
}
for (int i = 0; i < point.size(); i++) {
v[point[i]] = 0;
}
for (int I = 0; I < point.size(); I++) {
int start = point[I];
// 左
for (int i = start; i > 0; i--) {
if (s[i - 1] == '>')
v[i - 1] = max(v[i - 1], v[i] + 1);
else {
break;
}
}
// 右
for (int i = start; i < v.size() - 1; i++) {
if (s[i] == '<') {
v[i + 1] = max(v[i + 1], v[i] + 1);
} else {
break;
}
}
}
ll sum = 0;
for (int i = 0; i < v.size(); i++) {
sum += v[i];
}
fin(sum);
}
| insert | 99 | 99 | 99 | 101 | TLE | |
p02873 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll NumCount(ll Count0, ll Count1, string S, ll AC0, ll AC1) {
ll AllCount = 0;
if (Count0 <= Count1) {
AllCount += AC1;
AllCount += AC0 - Count0;
} else {
AllCount += AC1 - Count1;
AllCount += AC0;
}
return AllCount;
}
int main() {
string S;
cin >> S;
ll Count0 = 0;
ll ACount0 = 0;
ll Count1 = 0;
ll ACount1 = 0;
ll AllCount = 0;
if (S.size() == 1) {
cout << 1;
} else {
if (S[0] == '<') {
Count0++;
ACount0 += Count0;
} else {
Count1++;
ACount1 += Count1;
}
for (int i = 1; i < S.size() - 1; i++) {
if (S[i - 1] == '<' && S[i] == '<') {
Count0++;
ACount0 += Count0;
} else if (S[i - 1] == '>' && S[i] == '<') {
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
Count0 = 1;
ACount0 = Count0;
Count1 = 0;
ACount1 = 0;
} else {
Count1++;
ACount1 += Count1;
}
}
if (S[S.size() - 2] == '>' && S[S.size() - 1] == '<') {
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
AllCount++;
} else if (S[S.size() - 1] == '>') {
Count1++;
ACount1 += Count1;
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
} else {
Count0++;
ACount0 += Count0;
AllCount += ACount0;
}
cout << AllCount;
}
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <functional>
#include <initializer_list>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
ll NumCount(ll Count0, ll Count1, string &S, ll AC0, ll AC1) {
ll AllCount = 0;
if (Count0 <= Count1) {
AllCount += AC1;
AllCount += AC0 - Count0;
} else {
AllCount += AC1 - Count1;
AllCount += AC0;
}
return AllCount;
}
int main() {
string S;
cin >> S;
ll Count0 = 0;
ll ACount0 = 0;
ll Count1 = 0;
ll ACount1 = 0;
ll AllCount = 0;
if (S.size() == 1) {
cout << 1;
} else {
if (S[0] == '<') {
Count0++;
ACount0 += Count0;
} else {
Count1++;
ACount1 += Count1;
}
for (int i = 1; i < S.size() - 1; i++) {
if (S[i - 1] == '<' && S[i] == '<') {
Count0++;
ACount0 += Count0;
} else if (S[i - 1] == '>' && S[i] == '<') {
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
Count0 = 1;
ACount0 = Count0;
Count1 = 0;
ACount1 = 0;
} else {
Count1++;
ACount1 += Count1;
}
}
if (S[S.size() - 2] == '>' && S[S.size() - 1] == '<') {
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
AllCount++;
} else if (S[S.size() - 1] == '>') {
Count1++;
ACount1 += Count1;
AllCount += NumCount(Count0, Count1, S, ACount0, ACount1);
} else {
Count0++;
ACount0 += Count0;
AllCount += ACount0;
}
cout << AllCount;
}
} | replace | 16 | 17 | 16 | 17 | TLE | |
p02873 | C++ | Runtime Error | #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 FORD(i, b, a) for (int i = b; i >= a; --i)
#define sz(v) ((int)v.size())
#define all(v) v.begin(), v.end()
#define uni(v) v.erase(unique(all(v)), v.end())
using namespace std;
const int maxn = 1e5 + 10;
int n;
int a[maxn], in[maxn];
vector<int> adj[maxn];
void dfs(int u) {
for (int v : adj[u])
if (a[v] <= a[u]) {
a[v] = a[u] + 1;
dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
n = sz(s);
REP(i, n) if (s[i] == '<') {
adj[i].push_back(i + 1);
in[i + 1]++;
}
else {
adj[i + 1].push_back(i);
in[i]++;
}
REP(i, n + 1) if (!in[i]) { dfs(i); }
long long res = 0;
REP(i, n + 1) res += a[i];
cout << res << "\n";
return 0;
}
| #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 FORD(i, b, a) for (int i = b; i >= a; --i)
#define sz(v) ((int)v.size())
#define all(v) v.begin(), v.end()
#define uni(v) v.erase(unique(all(v)), v.end())
using namespace std;
const int maxn = 5e5 + 10;
int n;
int a[maxn], in[maxn];
vector<int> adj[maxn];
void dfs(int u) {
for (int v : adj[u])
if (a[v] <= a[u]) {
a[v] = a[u] + 1;
dfs(v);
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
string s;
cin >> s;
n = sz(s);
REP(i, n) if (s[i] == '<') {
adj[i].push_back(i + 1);
in[i + 1]++;
}
else {
adj[i + 1].push_back(i);
in[i]++;
}
REP(i, n + 1) if (!in[i]) { dfs(i); }
long long res = 0;
REP(i, n + 1) res += a[i];
cout << res << "\n";
return 0;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
typedef long long ll;
typedef pair<int64_t, int64_t> pll;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define ALL(a) begin(a), end(a)
#define sz(s) (s).size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
void solve() {
vector<ll> dp(500010, 0);
REP(i, 500005)
dp[i + 1] = dp[i] + i + 1;
string s;
cin >> s;
ll ans = 0;
vector<ll> x;
ll tem = 1;
REP(i, s.size() - 1) {
if (s[i] != s[i + 1]) {
x.push_back(tem);
ans += dp[tem];
tem = 1;
} else
tem++;
}
x.push_back(tem);
ans += dp[tem];
// for(auto it:x)cout<<it<<endl;cout<<endl<<ans<<endl;
if (s[0] == '>')
x.erase(x.begin());
if (s[s.size() - 1] == '<')
x.erase(x.end() - 1);
for (ll j = 0; j < x.size() - 1; j += 2) {
ans -= min(x[j], x[j + 1]);
}
// for(auto it:x)cout<<it<<endl;
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const long double PI = acos(-1);
typedef long long ll;
typedef pair<int64_t, int64_t> pll;
int dx[] = {1, -1, 0, 0, 1, -1, 1, -1};
int dy[] = {0, 0, 1, -1, 1, -1, -1, 1};
#define INF (2147483647)
#define mod (1000000007)
#define limit (7368791)
#define rep(i, a, b) for (int64_t i = (a); i < (b); i++)
#define REP(i, n) rep(i, 0, n)
#define ALL(a) begin(a), end(a)
#define sz(s) (s).size()
#define pb push_back
#define mp make_pair
#define fi first
#define se second
void solve() {
vector<ll> dp(500010, 0);
REP(i, 500005)
dp[i + 1] = dp[i] + i + 1;
string s;
cin >> s;
ll ans = 0;
vector<ll> x;
ll tem = 1;
REP(i, s.size() - 1) {
if (s[i] != s[i + 1]) {
x.push_back(tem);
ans += dp[tem];
tem = 1;
} else
tem++;
}
x.push_back(tem);
ans += dp[tem];
// for(auto it:x)cout<<it<<endl;cout<<endl<<ans<<endl;
if (s[0] == '>')
x.erase(x.begin());
if (s[s.size() - 1] == '<')
x.erase(x.end() - 1);
if (x.size() >= 2)
for (ll j = 0; j < x.size() - 1; j += 2) {
ans -= min(x[j], x[j + 1]);
}
// for(auto it:x)cout<<it<<endl;
cout << ans << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
solve();
return 0;
}
| replace | 44 | 47 | 44 | 48 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
#include <numeric>
using ll = long long;
using namespace std;
ll mod = 1e9;
int main() {
string s;
cin >> s;
int N = s.size();
vector<pair<int, ll>> ans;
ll cnt(1);
for (int i(0); i < N - 1; i++) {
if (s[i] != s[i + 1]) {
if (s[i] == '<') {
ans.push_back({cnt, (ll)(cnt * (cnt - 1)) / 2});
} else {
int tmp = 0;
if (!ans.empty()) {
if (ans.back().first > cnt)
tmp = ans.back().first - cnt;
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
} else {
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
}
}
cnt = 1;
} else {
cnt++;
}
}
if (s[N - 1] == '<') {
ans.push_back({cnt, (ll)(cnt * (cnt + 1)) / 2});
} else {
int tmp = 0;
if (ans.back().first > cnt)
tmp = ans.back().first - cnt;
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
}
ll sum(0);
for (int i(0); i < ans.size(); i++) {
sum += ans[i].second;
}
cout << sum << endl;
return 0;
}
| #include <bits/stdc++.h>
#include <numeric>
using ll = long long;
using namespace std;
ll mod = 1e9;
int main() {
string s;
cin >> s;
int N = s.size();
vector<pair<int, ll>> ans;
ll cnt(1);
for (int i(0); i < N - 1; i++) {
if (s[i] != s[i + 1]) {
if (s[i] == '<') {
ans.push_back({cnt, (ll)(cnt * (cnt - 1)) / 2});
} else {
int tmp = 0;
if (!ans.empty()) {
if (ans.back().first > cnt)
tmp = ans.back().first - cnt;
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
} else {
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
}
}
cnt = 1;
} else {
cnt++;
}
}
if (s[N - 1] == '<') {
ans.push_back({cnt, (ll)(cnt * (cnt + 1)) / 2});
} else {
int tmp = 0;
if (!ans.empty()) {
if (ans.back().first > cnt)
tmp = ans.back().first - cnt;
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
} else {
ans.push_back({cnt, tmp + (ll)(cnt * (cnt + 1)) / 2});
}
}
ll sum(0);
for (int i(0); i < ans.size(); i++) {
sum += ans[i].second;
}
cout << sum << endl;
return 0;
}
| replace | 36 | 39 | 36 | 43 | 0 | |
p02873 | C++ | Runtime Error | /*input
<>>><<><<<<<>>><
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<long long, null_type, less_equal<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC optimize("unroll-loops,no-stack-protector")
// order_of_key #of elements less than x
// find_by_order kth element
typedef long long int ll;
#define ld long double
#define pii pair<ll, ll>
#define f first
#define s second
#define pb push_back
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define FILL(n, x) memset(n, x, sizeof(n))
#define ALL(_a) _a.begin(), _a.end()
#define sz(x) (int)x.size()
const ll maxn = 200005;
const ll maxlg = __lg(maxn) + 2;
const ll INF64 = 4000000000000000LL;
const int INF = 0x3f3f3f3f;
const ll MOD = ll(1e9 + 7);
const ld PI = acos(-1);
const ld eps = 1e-9;
#define lowb(x) x & (-x)
#define MNTO(x, y) x = min(x, (__typeof__(x))y)
#define MXTO(x, y) x = max(x, (__typeof__(x))y)
ll mult(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
ll mypow(ll a, ll b) {
if (b <= 0)
return 1;
ll res = 1LL;
while (b) {
if (b & 1)
res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
int arr[maxn];
int main() {
string s;
cin >> s;
arr[0] = 0;
REP1(i, s.length()) {
if (s[i - 1] == '<')
MXTO(arr[i], arr[i - 1] + 1);
}
ll ans = arr[s.length()];
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == '>')
MXTO(arr[i], arr[i + 1] + 1);
ans += arr[i];
}
cout << ans;
} | /*input
<>>><<><<<<<>>><
*/
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace std;
using namespace __gnu_pbds;
typedef tree<long long, null_type, less_equal<long long>, rb_tree_tag,
tree_order_statistics_node_update>
indexed_set;
#pragma GCC optimize("unroll-loops,no-stack-protector")
// order_of_key #of elements less than x
// find_by_order kth element
typedef long long int ll;
#define ld long double
#define pii pair<ll, ll>
#define f first
#define s second
#define pb push_back
#define REP(i, n) for (int i = 0; i < n; i++)
#define REP1(i, n) for (int i = 1; i <= n; i++)
#define FILL(n, x) memset(n, x, sizeof(n))
#define ALL(_a) _a.begin(), _a.end()
#define sz(x) (int)x.size()
const ll maxn = 500005;
const ll maxlg = __lg(maxn) + 2;
const ll INF64 = 4000000000000000LL;
const int INF = 0x3f3f3f3f;
const ll MOD = ll(1e9 + 7);
const ld PI = acos(-1);
const ld eps = 1e-9;
#define lowb(x) x & (-x)
#define MNTO(x, y) x = min(x, (__typeof__(x))y)
#define MXTO(x, y) x = max(x, (__typeof__(x))y)
ll mult(ll a, ll b) { return ((a % MOD) * (b % MOD)) % MOD; }
ll mypow(ll a, ll b) {
if (b <= 0)
return 1;
ll res = 1LL;
while (b) {
if (b & 1)
res = mult(res, a);
a = mult(a, a);
b >>= 1;
}
return res;
}
int arr[maxn];
int main() {
string s;
cin >> s;
arr[0] = 0;
REP1(i, s.length()) {
if (s[i - 1] == '<')
MXTO(arr[i], arr[i - 1] + 1);
}
ll ans = arr[s.length()];
for (int i = s.length() - 1; i >= 0; i--) {
if (s[i] == '>')
MXTO(arr[i], arr[i + 1] + 1);
ans += arr[i];
}
cout << ans;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define cinsc \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOR(i, k, n) for (int64 i = k; i < (int64)n; i++)
#define FORr(i, k, n) for (int64 i = (int64)k; i >= n; i--)
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define FOREACHr(it, l) for (auto it = l.rbegin(); it != l.rend(); it++)
#define IN(A, B, C) assert(B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define SQ(x) ((x) * (x))
const double pi = acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int, int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
// ONLINE_JUDGE LOCAL
int64 powr(int64 x, int64 y, int64 p) {
int res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void in_o() {
#ifndef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
cinsc;
}
int main() {
in_o();
string s;
cin >> s;
int n = (int)s.size();
vector<int> a(n + 1);
for (int i = 0; i < n; i++) {
if (s[i] == '<') {
a[i + 1] = max(a[i + 1], a[i] + 1);
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
a[i] = max(a[i], a[i + 1] + 1);
}
}
long long ans = 0;
for (int i = 0; i <= n; i++) {
ans += a[i];
}
cout << ans << '\n';
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define cinsc \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); \
cout.tie(0);
#define all(cont) cont.begin(), cont.end()
#define rall(cont) cont.end(), cont.begin()
#define FOR(i, k, n) for (int64 i = k; i < (int64)n; i++)
#define FORr(i, k, n) for (int64 i = (int64)k; i >= n; i--)
#define FOREACH(it, l) for (auto it = l.begin(); it != l.end(); it++)
#define FOREACHr(it, l) for (auto it = l.rbegin(); it != l.rend(); it++)
#define IN(A, B, C) assert(B <= A && A <= C)
#define MP make_pair
#define PB push_back
#define INF (int)1e9
#define EPS 1e-9
#define PI 3.1415926535897932384626433832795
#define MOD 1000000007
#define read(type) readInt<type>()
#define SQ(x) ((x) * (x))
const double pi = acos(-1.0);
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<string> VS;
typedef vector<PII> VII;
typedef vector<VI> VVI;
typedef map<int, int> MPII;
typedef set<int> SETI;
typedef multiset<int> MSETI;
typedef long int int32;
typedef unsigned long int uint32;
typedef long long int int64;
typedef unsigned long long int uint64;
// ONLINE_JUDGE LOCAL
int64 powr(int64 x, int64 y, int64 p) {
int res = 1;
x = x % p;
if (x == 0)
return 0;
while (y > 0) {
if (y & 1)
res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
void in_o() {
#ifndef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
#endif
cinsc;
}
int main() {
string s;
cin >> s;
int n = (int)s.size();
vector<int> a(n + 1);
for (int i = 0; i < n; i++) {
if (s[i] == '<') {
a[i + 1] = max(a[i + 1], a[i] + 1);
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
a[i] = max(a[i], a[i + 1] + 1);
}
}
long long ans = 0;
for (int i = 0; i <= n; i++) {
ans += a[i];
}
cout << ans << '\n';
return 0;
}
| delete | 61 | 62 | 61 | 61 | 0 | |
p02873 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#define all(v) (v).begin(), (v).end()
#define io ios::sync_with_stdio(0)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define rson rt << 1 | 1, mid + 1, r
#define lson rt << 1, l, mid
#define lll __int128
#define pii pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define eps 1e-12
#define int long long
const int mod = 1e9 + 7;
inline int ksm(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1)
ans = ans * a % mod;
return ans;
}
char s[200000];
int c[2000000], b[2000000];
signed main() {
io;
cin >> s + 1;
int n = strlen(s + 1) + 1;
for (int i = 2; i <= n; i++) {
if (s[i - 1] == '<')
b[i] = b[i - 1] + 1;
}
for (int i = n - 1; i; i--) {
if (s[i] == '>')
c[i] = c[i + 1] + 1;
}
int ans = 0;
rep(i, 1, n) ans += max(c[i], b[i]);
cout << ans << endl;
getchar(); //
getchar();
}
| #include "bits/stdc++.h"
using namespace std;
#define all(v) (v).begin(), (v).end()
#define io ios::sync_with_stdio(0)
#define rep(i, a, b) for (int i = a; i <= b; i++)
#define rson rt << 1 | 1, mid + 1, r
#define lson rt << 1, l, mid
#define lll __int128
#define pii pair<int, int>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define eps 1e-12
#define int long long
const int mod = 1e9 + 7;
inline int ksm(int a, int b) {
int ans = 1;
for (; b; b >>= 1, a = a * a % mod)
if (b & 1)
ans = ans * a % mod;
return ans;
}
char s[2000000];
int c[2000000], b[2000000];
signed main() {
io;
cin >> s + 1;
int n = strlen(s + 1) + 1;
for (int i = 2; i <= n; i++) {
if (s[i - 1] == '<')
b[i] = b[i - 1] + 1;
}
for (int i = n - 1; i; i--) {
if (s[i] == '>')
c[i] = c[i + 1] + 1;
}
int ans = 0;
rep(i, 1, n) ans += max(c[i], b[i]);
cout << ans << endl;
getchar(); //
getchar();
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<long long> VLL;
typedef vector<pair<int, int>> VP;
#define INF (int)(1e9)
#define MAXX 1.1529215e+18
#define inf 999999
#define EPS (1e-7)
#define MOD (1e9 + 7)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.begin(), a.end(), greater<int>()
#define ROT(a) a.begin(), a.begin() + 1, a.end()
#define RROT(a) a.begin(), a.end() - 1, a.end()
#define PB push_back
#define MP make_pair
#define PI acos(-1.0)
/*--------------------------------------------*/
ll sum(ll n, ll m) {
ll a = max(n, m);
ll b = min(n, m);
return (a * (a + 1) / 2 + b * (b - 1) / 2);
}
int main() {
string s;
cin >> s;
ll n = s.size();
vector<ll> a;
ll count = 1;
rep(i, n - 1) {
if (s[i] == s[i + 1]) {
count++;
} else {
a.PB(count);
count = 1;
}
if (i == n - 2) {
a.PB(count);
}
}
ll ans = 0;
ll num = a.size();
if (s[0] == '>') {
ans += sum(0, a[0]);
a.erase(a.begin());
num--;
}
rep(i, num / 2) ans += sum(a[2 * i], a[2 * i + 1]);
if (num % 2 == 1) {
ans += sum(a[num - 1], 0);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<long long> VLL;
typedef vector<pair<int, int>> VP;
#define INF (int)(1e9)
#define MAXX 1.1529215e+18
#define inf 999999
#define EPS (1e-7)
#define MOD (1e9 + 7)
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, n) for (int i = 1; i <= (int)(n); i++)
#define FOR(i, k, n) for (int i = (k); i < (int)(n); i++)
#define ALL(a) a.begin(), a.end()
#define RALL(a) a.begin(), a.end(), greater<int>()
#define ROT(a) a.begin(), a.begin() + 1, a.end()
#define RROT(a) a.begin(), a.end() - 1, a.end()
#define PB push_back
#define MP make_pair
#define PI acos(-1.0)
/*--------------------------------------------*/
ll sum(ll n, ll m) {
ll a = max(n, m);
ll b = min(n, m);
return (a * (a + 1) / 2 + b * (b - 1) / 2);
}
int main() {
string s;
cin >> s;
ll n = s.size();
vector<ll> a;
ll count = 1;
if (n == 1) {
cout << 1 << endl;
return 0;
}
rep(i, n - 1) {
if (s[i] == s[i + 1]) {
count++;
} else {
a.PB(count);
count = 1;
}
if (i == n - 2) {
a.PB(count);
}
}
ll ans = 0;
ll num = a.size();
if (s[0] == '>') {
ans += sum(0, a[0]);
a.erase(a.begin());
num--;
}
rep(i, num / 2) ans += sum(a[2 * i], a[2 * i + 1]);
if (num % 2 == 1) {
ans += sum(a[num - 1], 0);
}
cout << ans << endl;
} | insert | 40 | 40 | 40 | 45 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long
#define db long double
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
using namespace std;
bool good(int index, vector<int> ans, string s) {
int n = ans.size();
if (ans[index] != -1)
return false;
if (index != 0) {
if (s[index - 1] == '<' && ans[index - 1] == -1)
return false;
}
if (index != n - 1) {
if (s[index] == '>' && ans[index + 1] == -1)
return false;
}
return true;
}
int main() {
#ifdef LOCAL
freopen("A_input.txt", "r", stdin);
// freopen("A_output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size() + 1;
vector<int> ans(n, -1);
queue<int> possible;
for (int i = 0; i < n; ++i) {
if (good(i, ans, s)) {
possible.push(i);
ans[i] = -2;
}
}
while (possible.size()) {
int V = possible.front();
possible.pop();
int val = 0;
if (V != 0)
val = max(val, ans[V - 1] + 1);
if (V != n - 1)
val = max(val, ans[V + 1] + 1);
ans[V] = val;
// cout << V << " " << val << endl;
for (int j = V - 1; j <= V + 1; j++) {
if (j >= 0 && j <= n - 1 && good(j, ans, s)) {
possible.push(j);
ans[j] = -2;
}
}
}
ll an = 0;
for (int i = 0; i < n; ++i)
an += ans[i];
cout << an;
}
| #include <bits/stdc++.h>
#define ll long long
#define db long double
#define x first
#define y second
#define mp make_pair
#define pb push_back
#define all(a) a.begin(), a.end()
using namespace std;
bool good(int index, vector<int> &ans, string &s) {
int n = ans.size();
if (ans[index] != -1)
return false;
if (index != 0) {
if (s[index - 1] == '<' && ans[index - 1] == -1)
return false;
}
if (index != n - 1) {
if (s[index] == '>' && ans[index + 1] == -1)
return false;
}
return true;
}
int main() {
#ifdef LOCAL
freopen("A_input.txt", "r", stdin);
// freopen("A_output.txt", "w", stdout);
#endif
ios_base::sync_with_stdio(0);
cin.tie(0);
string s;
cin >> s;
int n = s.size() + 1;
vector<int> ans(n, -1);
queue<int> possible;
for (int i = 0; i < n; ++i) {
if (good(i, ans, s)) {
possible.push(i);
ans[i] = -2;
}
}
while (possible.size()) {
int V = possible.front();
possible.pop();
int val = 0;
if (V != 0)
val = max(val, ans[V - 1] + 1);
if (V != n - 1)
val = max(val, ans[V + 1] + 1);
ans[V] = val;
// cout << V << " " << val << endl;
for (int j = V - 1; j <= V + 1; j++) {
if (j >= 0 && j <= n - 1 && good(j, ans, s)) {
possible.push(j);
ans[j] = -2;
}
}
}
ll an = 0;
for (int i = 0; i < n; ++i)
an += ans[i];
cout << an;
}
| replace | 11 | 12 | 11 | 12 | TLE | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 100005;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9')
c = getchar();
int sum = 0;
while ('0' <= c && c <= '9')
sum = sum * 10 + c - 48, c = getchar();
return sum;
}
char s[maxn];
int n, a[maxn], b[maxn];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
ll sum = 0;
for (int i = 1; i <= n; ++i)
a[i] = s[i] == '<' ? a[i - 1] + 1 : 0;
for (int i = n - 1; ~i; --i)
b[i] = s[i + 1] == '>' ? b[i + 1] + 1 : 0;
for (int i = 0; i <= n; ++i)
sum += max(a[i], b[i]);
printf("%lld\n", sum);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 500005;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9')
c = getchar();
int sum = 0;
while ('0' <= c && c <= '9')
sum = sum * 10 + c - 48, c = getchar();
return sum;
}
char s[maxn];
int n, a[maxn], b[maxn];
int main() {
scanf("%s", s + 1);
n = strlen(s + 1);
ll sum = 0;
for (int i = 1; i <= n; ++i)
a[i] = s[i] == '<' ? a[i - 1] + 1 : 0;
for (int i = n - 1; ~i; --i)
b[i] = s[i + 1] == '>' ? b[i + 1] + 1 : 0;
for (int i = 0; i <= n; ++i)
sum += max(a[i], b[i]);
printf("%lld\n", sum);
return 0;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <list>
#include <string>
using namespace std;
int main() {
string str;
cin >> str;
list<int> l(1), r(1);
int cnt = 0;
for (auto &&i : str) {
if (i == '<') {
cnt++;
} else {
if (l.size())
cnt = 0;
}
l.push_back(cnt);
}
reverse(begin(str), end(str));
cnt = 0;
for (auto &&i : str) {
if (i == '>') {
cnt++;
} else {
cnt = 0;
}
r.push_front(cnt);
}
long long sum = 0;
while (!l.empty()) {
sum += max(l.front(), r.front());
l.pop_front();
r.pop_front();
}
cout << sum << "\n";
} | #include <algorithm>
#include <iostream>
#include <list>
#include <string>
using namespace std;
int main() {
string str;
cin >> str;
list<int> l(1), r(1);
int cnt = 0;
for (auto &&i : str) {
if (i == '<') {
cnt++;
} else {
cnt = 0;
}
l.push_back(cnt);
}
reverse(begin(str), end(str));
cnt = 0;
for (auto &&i : str) {
if (i == '>') {
cnt++;
} else {
cnt = 0;
}
r.push_front(cnt);
}
long long sum = 0;
while (!l.empty()) {
sum += max(l.front(), r.front());
l.pop_front();
r.pop_front();
}
cout << sum << "\n";
}
| replace | 16 | 18 | 16 | 17 | TLE | |
p02873 | C++ | Runtime Error | #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
#define fax(i, a) for (int i = 0; i < (a); i++)
#define f0x(i, a, b) for (int i = (a); i < (b); i++)
#define f0xd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define faxd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define memeset memset
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize
template <class T> void ckmin(T &a, T b) { a = min(a, b); }
template <class T> void ckmax(T &a, T b) { a = max(a, b); }
template <class T, int... Ns> struct BIT {
T val = 0;
void upd(T v) { val += v; }
T query() { return val; }
};
template <class T, int N, int... Ns> struct BIT<T, N, Ns...> {
BIT<T, Ns...> bit[N + 1];
template <typename... Args> void upd(int pos, Args... args) {
for (; pos <= N; pos += (pos & -pos))
bit[pos].upd(args...);
}
template <typename... Args> T sum(int r, Args... args) {
T res = 0;
for (; r; r -= (r & -r))
res += bit[r].query(args...);
return res;
}
template <typename... Args> T query(int l, int r, Args... args) {
return sum(r, args...) - sum(l - 1, args...);
}
};
namespace input {
template <class T> void re(complex<T> &x);
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
void re(ld &x) {
string t;
re(t);
x = stold(t);
}
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
template <class T> void re(complex<T> &x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { fax(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { fax(i, SZ) re(a[i]); }
} // namespace input
using namespace input;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(ll x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(ld x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char *x) { cout << x; }
void pr(const string &x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T> void pr(const T &x);
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void pr(const T &x) {
pr("{"); // const iterator needed for vector<bool>
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
void ps() { pr("\n"); } // print w/ spaces
template <class T, class... Ts> void ps(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(" ");
ps(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
using namespace output;
namespace io {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0); // fast I/O
if (sz(s)) {
setIn(s + ".in"), setOut(s + ".out");
} // for USACO
}
} // namespace io
using namespace io;
const int MOD = 1000000007; // 998244353
const ll INF = 1e18;
const int MX = 200005;
const ld PI = 4 * atan((ld)1);
int ans[MX];
bool end[MX];
void solve() {
string s;
re(s);
fax(i, sz(s) - 1) {
if (s[i] == '>' && s[i + 1] == '<') {
ans[i + 1] = 0;
}
}
fax(i, sz(s)) {
if (s[i] == '<') {
ans[i + 1] = max(ans[i + 1], ans[i] + 1);
}
}
faxd(i, sz(s)) {
if (s[i] == '>') {
ans[i] = max(ans[i], ans[i + 1] + 1);
}
}
ll ret = 0;
fax(i, sz(s) + 1) { ret += ans[i]; }
cout << ret << "\n";
}
int main() {
setIO();
int t = 1;
while (t--) {
solve();
}
}
| #pragma GCC optimize("O3")
#pragma GCC target("sse4")
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef long double ld;
typedef complex<ld> cd;
typedef pair<int, int> pi;
typedef pair<ll, ll> pl;
typedef pair<ld, ld> pd;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef vector<ld> vd;
typedef vector<ll> vl;
typedef vector<pi> vpi;
typedef vector<pl> vpl;
typedef vector<cd> vcd;
#define fax(i, a) for (int i = 0; i < (a); i++)
#define f0x(i, a, b) for (int i = (a); i < (b); i++)
#define f0xd(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define faxd(i, a) for (int i = (a)-1; i >= 0; i--)
#define trav(a, x) for (auto &a : x)
#define memeset memset
#define mp make_pair
#define pb push_back
#define f first
#define s second
#define lb lower_bound
#define ub upper_bound
#define sz(x) (int)x.size()
#define all(x) begin(x), end(x)
#define rsz resize
template <class T> void ckmin(T &a, T b) { a = min(a, b); }
template <class T> void ckmax(T &a, T b) { a = max(a, b); }
template <class T, int... Ns> struct BIT {
T val = 0;
void upd(T v) { val += v; }
T query() { return val; }
};
template <class T, int N, int... Ns> struct BIT<T, N, Ns...> {
BIT<T, Ns...> bit[N + 1];
template <typename... Args> void upd(int pos, Args... args) {
for (; pos <= N; pos += (pos & -pos))
bit[pos].upd(args...);
}
template <typename... Args> T sum(int r, Args... args) {
T res = 0;
for (; r; r -= (r & -r))
res += bit[r].query(args...);
return res;
}
template <typename... Args> T query(int l, int r, Args... args) {
return sum(r, args...) - sum(l - 1, args...);
}
};
namespace input {
template <class T> void re(complex<T> &x);
template <class T1, class T2> void re(pair<T1, T2> &p);
template <class T> void re(vector<T> &a);
template <class T, size_t SZ> void re(array<T, SZ> &a);
template <class T> void re(T &x) { cin >> x; }
void re(double &x) {
string t;
re(t);
x = stod(t);
}
void re(ld &x) {
string t;
re(t);
x = stold(t);
}
template <class T, class... Ts> void re(T &t, Ts &...ts) {
re(t);
re(ts...);
}
template <class T> void re(complex<T> &x) {
T a, b;
re(a, b);
x = cd(a, b);
}
template <class T1, class T2> void re(pair<T1, T2> &p) { re(p.f, p.s); }
template <class T> void re(vector<T> &a) { fax(i, sz(a)) re(a[i]); }
template <class T, size_t SZ> void re(array<T, SZ> &a) { fax(i, SZ) re(a[i]); }
} // namespace input
using namespace input;
namespace output {
void pr(int x) { cout << x; }
void pr(long x) { cout << x; }
void pr(ll x) { cout << x; }
void pr(unsigned x) { cout << x; }
void pr(unsigned long x) { cout << x; }
void pr(unsigned long long x) { cout << x; }
void pr(float x) { cout << x; }
void pr(double x) { cout << x; }
void pr(ld x) { cout << x; }
void pr(char x) { cout << x; }
void pr(const char *x) { cout << x; }
void pr(const string &x) { cout << x; }
void pr(bool x) { pr(x ? "true" : "false"); }
template <class T1, class T2> void pr(const pair<T1, T2> &x);
template <class T> void pr(const T &x);
template <class T, class... Ts> void pr(const T &t, const Ts &...ts) {
pr(t);
pr(ts...);
}
template <class T1, class T2> void pr(const pair<T1, T2> &x) {
pr("{", x.f, ", ", x.s, "}");
}
template <class T> void pr(const T &x) {
pr("{"); // const iterator needed for vector<bool>
bool fst = 1;
for (const auto &a : x)
pr(!fst ? ", " : "", a), fst = 0;
pr("}");
}
void ps() { pr("\n"); } // print w/ spaces
template <class T, class... Ts> void ps(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(" ");
ps(ts...);
}
void pc() { pr("]\n"); } // debug w/ commas
template <class T, class... Ts> void pc(const T &t, const Ts &...ts) {
pr(t);
if (sizeof...(ts))
pr(", ");
pc(ts...);
}
#define dbg(x...) pr("[", #x, "] = ["), pc(x);
} // namespace output
using namespace output;
namespace io {
void setIn(string s) { freopen(s.c_str(), "r", stdin); }
void setOut(string s) { freopen(s.c_str(), "w", stdout); }
void setIO(string s = "") {
ios_base::sync_with_stdio(0);
cin.tie(0); // fast I/O
if (sz(s)) {
setIn(s + ".in"), setOut(s + ".out");
} // for USACO
}
} // namespace io
using namespace io;
const int MOD = 1000000007; // 998244353
const ll INF = 1e18;
const int MX = 500005;
const ld PI = 4 * atan((ld)1);
int ans[MX];
bool end[MX];
void solve() {
string s;
re(s);
fax(i, sz(s) - 1) {
if (s[i] == '>' && s[i + 1] == '<') {
ans[i + 1] = 0;
}
}
fax(i, sz(s)) {
if (s[i] == '<') {
ans[i + 1] = max(ans[i + 1], ans[i] + 1);
}
}
faxd(i, sz(s)) {
if (s[i] == '>') {
ans[i] = max(ans[i], ans[i + 1] + 1);
}
}
ll ret = 0;
fax(i, sz(s) + 1) { ret += ans[i]; }
cout << ret << "\n";
}
int main() {
setIO();
int t = 1;
while (t--) {
solve();
}
}
| replace | 170 | 171 | 170 | 171 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 200010;
int n;
vector<int> adj[maxn];
int dp[maxn];
int dfs(int u) {
if (dp[u] != -1) {
return dp[u];
}
dp[u] = 0;
for (int v : adj[u]) {
dp[u] = max(dp[u], dfs(v) + 1);
}
return dp[u];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
n = s.length() + 1;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == '<') {
adj[i + 1].push_back(i);
} else {
adj[i].push_back(i + 1);
}
}
for (int i = 0; i < n; ++i) {
dp[i] = -1;
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
ans += dfs(i);
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int maxn = 500010;
int n;
vector<int> adj[maxn];
int dp[maxn];
int dfs(int u) {
if (dp[u] != -1) {
return dp[u];
}
dp[u] = 0;
for (int v : adj[u]) {
dp[u] = max(dp[u], dfs(v) + 1);
}
return dp[u];
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
string s;
cin >> s;
n = s.length() + 1;
for (int i = 0; i < n - 1; ++i) {
if (s[i] == '<') {
adj[i + 1].push_back(i);
} else {
adj[i].push_back(i + 1);
}
}
for (int i = 0; i < n; ++i) {
dp[i] = -1;
}
ll ans = 0;
for (int i = 0; i < n; ++i) {
ans += dfs(i);
}
cout << ans << endl;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int max_n = 100005;
char s[max_n];
int l[max_n], r[max_n];
int main() {
scanf(" %s", s + 1);
int n = strlen(s + 1) + 1;
for (int i = 2; i <= n; i++) {
if (s[i - 1] == '<')
l[i] = l[i - 1] + 1;
}
for (int i = n - 1; i >= 1; i--) {
if (s[i] == '>')
r[i] = r[i + 1] + 1;
}
ll ans = 0;
for (int i = 1; i <= n; i++)
ans += max(l[i], r[i]);
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int max_n = 500005;
char s[max_n];
int l[max_n], r[max_n];
int main() {
scanf(" %s", s + 1);
int n = strlen(s + 1) + 1;
for (int i = 2; i <= n; i++) {
if (s[i - 1] == '<')
l[i] = l[i - 1] + 1;
}
for (int i = n - 1; i >= 1; i--) {
if (s[i] == '>')
r[i] = r[i + 1] + 1;
}
ll ans = 0;
for (int i = 1; i <= n; i++)
ans += max(l[i], r[i]);
printf("%lld\n", ans);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02873 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1 << 29)
#define LLINF (1LL << 60)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
string to_string(string s) { return s; }
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
template <class S> string to_string(unordered_set<S> s) {
string ret = "{";
for (S x : s)
ret += to_string(x) + ",";
return ret + "}";
}
template <class S, class T> string to_string(map<S, T> m) {
string ret = "{";
for (pair<S, T> x : m)
ret += to_string(x) + ",";
return ret + "}";
}
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < (int)v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int A[100001];
int main() {
cin.tie(0);
string S;
cin >> S;
S = ">" + S + "<";
int N = S.size() - 1;
FORIN(i, 1, N + 1) {
if (S[i - 1] == '>' && S[i] == '<') {
A[i] = 0;
for (int j = i - 1; j > 0 && S[j] == '>'; --j) {
A[j - 1] = max(A[j - 1], A[j] + 1);
}
for (int j = i; j < N && S[j] == '<'; ++j) {
A[j] = max(A[j], A[j - 1] + 1);
}
} // debug(A);
} // debug("Ok,",A);
print(accumulate(A, A + N, 0LL));
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_set>
#include <vector>
using namespace std;
#define FOR(i, N) for (int i = 0; i < (int)N; i++)
#define FORIN(i, a, b) for (int i = a; i < (int)b; i++)
#define ALL(x) (x).begin(), (x).end()
#define MOD 1000000007
#define INF (1 << 29)
#define LLINF (1LL << 60)
#define DEBUG(...) debug(__LINE__, ":" __VA_ARGS__)
using Pi = pair<int, int>;
using ll = long long;
string to_string(string s) { return s; }
template <class S, class T> string to_string(pair<S, T> p) {
return "{" + to_string(p.first) + "," + to_string(p.second) + "}";
}
template <class S> string to_string(unordered_set<S> s) {
string ret = "{";
for (S x : s)
ret += to_string(x) + ",";
return ret + "}";
}
template <class S, class T> string to_string(map<S, T> m) {
string ret = "{";
for (pair<S, T> x : m)
ret += to_string(x) + ",";
return ret + "}";
}
template <class T> string to_string(vector<T> v) {
string ret = "{";
for (int i = 0; i < (int)v.size() - 1; ++i) {
ret += to_string(v[i]) + ",";
}
if (v.size() > 0) {
ret += to_string(v.back());
}
ret += "}";
return ret;
}
void debug() { cerr << endl; }
template <class Head, class... Tail> void debug(Head head, Tail... tail) {
cerr << to_string(head) << " ";
debug(tail...);
}
void print() { cout << endl; }
template <class Head, class... Tail> void print(Head head, Tail... tail) {
cout << to_string(head);
print(tail...);
}
int A[500001];
int main() {
cin.tie(0);
string S;
cin >> S;
S = ">" + S + "<";
int N = S.size() - 1;
FORIN(i, 1, N + 1) {
if (S[i - 1] == '>' && S[i] == '<') {
A[i] = 0;
for (int j = i - 1; j > 0 && S[j] == '>'; --j) {
A[j - 1] = max(A[j - 1], A[j] + 1);
}
for (int j = i; j < N && S[j] == '<'; ++j) {
A[j] = max(A[j], A[j - 1] + 1);
}
} // debug(A);
} // debug("Ok,",A);
print(accumulate(A, A + N, 0LL));
return 0;
} | replace | 72 | 73 | 72 | 73 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long int
const int INF = 2147483647;
const ll MOD = 1000000007;
using namespace std;
int main() {
vector<ll> a;
string s;
cin >> s;
int n = s.length();
char init = s[0], last = s[n - 1];
ll count = 1;
FOR(i, 1, n) {
if (s[i] == s[i - 1]) {
count++;
} else {
a.push_back(count);
count = 1;
}
}
a.push_back(count);
ll ans = 0;
if (init == '>') {
ans += a[0] * (a[0] + 1) / 2;
a.erase(a.begin());
}
REP(i, a.size() - 1) {
if (i % 2 != 0)
continue;
ll mi = min(a[i], a[i + 1]);
ll ma = max(a[i], a[i + 1]);
ans += mi * (mi - 1) / 2;
ans += ma * (ma + 1) / 2;
}
if (last == '<') {
ans += a[a.size() - 1] * (a[a.size() - 1] + 1) / 2;
}
cout << ans << endl;
}
| #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ll long long int
const int INF = 2147483647;
const ll MOD = 1000000007;
using namespace std;
int main() {
vector<ll> a;
string s;
cin >> s;
int n = s.length();
char init = s[0], last = s[n - 1];
ll count = 1;
FOR(i, 1, n) {
if (s[i] == s[i - 1]) {
count++;
} else {
a.push_back(count);
count = 1;
}
}
a.push_back(count);
ll ans = 0;
if (init == '>') {
ans += a[0] * (a[0] + 1) / 2;
a.erase(a.begin());
if (a.empty()) {
cout << ans << endl;
return 0;
}
}
REP(i, a.size() - 1) {
if (i % 2 != 0)
continue;
ll mi = min(a[i], a[i + 1]);
ll ma = max(a[i], a[i + 1]);
ans += mi * (mi - 1) / 2;
ans += ma * (ma + 1) / 2;
}
if (last == '<') {
ans += a[a.size() - 1] * (a[a.size() - 1] + 1) / 2;
}
cout << ans << endl;
}
| insert | 30 | 30 | 30 | 34 | 0 | |
p02873 | C++ | Runtime Error | #include <deque>
#include <stdio.h>
#include <utility>
using namespace std;
using ll = long long;
ll max(ll x, ll y) {
if (x < y) {
return y;
} else {
return x;
}
}
int main(void) {
ll ans = 0LL;
deque<pair<char, ll>> v = {make_pair(getchar(), 1LL)};
int d;
while ((d = getchar()) != EOF) {
if (d != v.back().first) {
v.push_back(make_pair(d, 0LL));
}
v.back().second++;
}
if (v.front().first == '>') {
ans += (v.front().second + 1LL) * v.front().second / 2LL;
v.pop_front();
}
if (v.back().first == '<') {
ans += (v.back().second + 1LL) * v.back().second / 2LL;
v.pop_back();
}
while (!v.empty()) {
ll open, close;
open = v.front().second;
v.pop_front();
close = v.front().second;
v.pop_front();
ans += (open - 1LL) * open / 2LL + (close - 1LL) * close / 2LL +
max(open, close);
}
printf("%lld\n", ans);
return 0;
}
| #include <deque>
#include <stdio.h>
#include <utility>
using namespace std;
using ll = long long;
ll max(ll x, ll y) {
if (x < y) {
return y;
} else {
return x;
}
}
int main(void) {
ll ans = 0LL;
deque<pair<char, ll>> v = {make_pair(getchar(), 1LL)};
int d;
while ((d = getchar()) != EOF) {
if (d == '\n') {
continue;
}
if (d != v.back().first) {
v.push_back(make_pair(d, 0LL));
}
v.back().second++;
}
if (v.front().first == '>') {
ans += (v.front().second + 1LL) * v.front().second / 2LL;
v.pop_front();
}
if (v.back().first == '<') {
ans += (v.back().second + 1LL) * v.back().second / 2LL;
v.pop_back();
}
while (!v.empty()) {
ll open, close;
open = v.front().second;
v.pop_front();
close = v.front().second;
v.pop_front();
ans += (open - 1LL) * open / 2LL + (close - 1LL) * close / 2LL +
max(open, close);
}
printf("%lld\n", ans);
return 0;
}
| insert | 20 | 20 | 20 | 23 | -11 | |
p02873 | C++ | Runtime Error | /// not today
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x).size()
#define pb push_back
#define ll long long
#define xmax(x, y) (x) = max((x), (y))
#define xmin(x, y) (x) = min((x), (y))
#define F first
#define S second
#define pii pair<int, int>
#define pll pair<long long, long long>
#define int long long
#define pipii pair<int, pair<int, int>>
#define pf push_front
const int maxn = 1000 * 100 + 5;
int a[maxn];
vector<int> v;
int32_t main() {
string s;
cin >> s;
for (int i = 0; i < SZ(s); i++) {
if (i == SZ(s) - 1 and s[i] == '>')
v.pb(SZ(s));
else if ((i == 0 and s[i] == '<') or
(i > 0 and s[i] == '<' and s[i - 1] == '>'))
v.pb(i);
}
for (int i = 0; i < SZ(v); i++) {
int x = v[i];
for (int j = x + 1; j < SZ(s) + 1 and s[j - 1] == '<'; j++) {
xmax(a[j], a[j - 1] + 1);
}
for (int j = x - 1; j >= 0 and s[j] == '>'; j--) {
xmax(a[j], a[j + 1] + 1);
}
}
int sum = 0;
for (int i = 0; i < SZ(s) + 1; i++)
sum += a[i];
cout << sum << endl;
return false;
}
| /// not today
#include <bits/stdc++.h>
using namespace std;
#define SZ(x) (int)(x).size()
#define pb push_back
#define ll long long
#define xmax(x, y) (x) = max((x), (y))
#define xmin(x, y) (x) = min((x), (y))
#define F first
#define S second
#define pii pair<int, int>
#define pll pair<long long, long long>
#define int long long
#define pipii pair<int, pair<int, int>>
#define pf push_front
const int maxn = 5000 * 100 + 5;
int a[maxn];
vector<int> v;
int32_t main() {
string s;
cin >> s;
for (int i = 0; i < SZ(s); i++) {
if (i == SZ(s) - 1 and s[i] == '>')
v.pb(SZ(s));
else if ((i == 0 and s[i] == '<') or
(i > 0 and s[i] == '<' and s[i - 1] == '>'))
v.pb(i);
}
for (int i = 0; i < SZ(v); i++) {
int x = v[i];
for (int j = x + 1; j < SZ(s) + 1 and s[j - 1] == '<'; j++) {
xmax(a[j], a[j - 1] + 1);
}
for (int j = x - 1; j >= 0 and s[j] == '>'; j--) {
xmax(a[j], a[j + 1] + 1);
}
}
int sum = 0;
for (int i = 0; i < SZ(s) + 1; i++)
sum += a[i];
cout << sum << endl;
return false;
}
| replace | 18 | 19 | 18 | 19 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define x first
#define y second
#define mp make_pair
#define pb push_back
template <typename TYPE> inline void chkmax(TYPE &x, TYPE y) {
x < y ? x = y : 0;
}
template <typename TYPE> inline void chkmin(TYPE &x, TYPE y) {
y < x ? x = y : 0;
}
template <typename TYPE> void readint(TYPE &x) {
x = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
x *= f;
}
const int MAXN = 505;
int n, a[MAXN];
char s[MAXN];
int main() {
#ifndef ONLINE_JUDGE
// freopen("code.in","r",stdin);
// freopen("code.out","w",stdout);
#endif
ll ans = 0;
scanf("%s", s + 1);
n = strlen(s + 1) + 1;
s[0] = '>';
s[n] = '<';
for (int i = 1; i <= n; ++i)
if (s[i - 1] == '>' && s[i] == '<') {
a[i] = 0;
for (int j = i - 1; s[j] == '>' && j; --j)
chkmax(a[j], a[j + 1] + 1);
for (int j = i + 1; s[j - 1] == '<' && j <= n; ++j)
chkmax(a[j], a[j - 1] + 1);
}
for (int i = 1; i <= n; ++i)
ans += a[i];
printf("%lld\n", ans);
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
#define x first
#define y second
#define mp make_pair
#define pb push_back
template <typename TYPE> inline void chkmax(TYPE &x, TYPE y) {
x < y ? x = y : 0;
}
template <typename TYPE> inline void chkmin(TYPE &x, TYPE y) {
y < x ? x = y : 0;
}
template <typename TYPE> void readint(TYPE &x) {
x = 0;
int f = 1;
char c;
for (c = getchar(); !isdigit(c); c = getchar())
if (c == '-')
f = -1;
for (; isdigit(c); c = getchar())
x = x * 10 + c - '0';
x *= f;
}
const int MAXN = 500005;
int n, a[MAXN];
char s[MAXN];
int main() {
#ifndef ONLINE_JUDGE
// freopen("code.in","r",stdin);
// freopen("code.out","w",stdout);
#endif
ll ans = 0;
scanf("%s", s + 1);
n = strlen(s + 1) + 1;
s[0] = '>';
s[n] = '<';
for (int i = 1; i <= n; ++i)
if (s[i - 1] == '>' && s[i] == '<') {
a[i] = 0;
for (int j = i - 1; s[j] == '>' && j; --j)
chkmax(a[j], a[j + 1] + 1);
for (int j = i + 1; s[j - 1] == '<' && j <= n; ++j)
chkmax(a[j], a[j - 1] + 1);
}
for (int i = 1; i <= n; ++i)
ans += a[i];
printf("%lld\n", ans);
return 0;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p02873 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const int INF = (1 << 30);
const ll INFLL = (1ll << 60);
const ll MOD = (ll)(1e9 + 7);
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
a = (a < MOD) ? a : (a - MOD);
b = (b < MOD) ? b : (b - MOD);
a += b;
a = (a < MOD) ? a : (a - MOD);
}
ll a[100100];
queue<int> q;
int main(void) {
int n, i;
ll b = 0ll, ans = 0ll;
string s;
cin >> s;
n = s.l_ength();
if (s[0] == '<') {
q.push(0);
}
if (s[n - 1] == '>') {
q.push(n);
}
for (i = 1; i < n; ++i) {
if (s[i - 1] == '>' && s[i] == '<') {
q.push(i);
}
}
while (!q.empty()) {
i = q.front();
q.pop();
if (i == 0) {
if (s[0] == '<') {
a[1] = max(a[1], a[0] + 1);
q.push(1);
}
} else if (i == n) {
if (s[n - 1] == '>') {
a[n - 1] = max(a[n - 1], a[n] + 1);
q.push(n - 1);
}
} else {
if (s[i - 1] == '>') {
a[i - 1] = max(a[i - 1], a[i] + 1);
q.push(i - 1);
}
if (s[i] == '<') {
a[i + 1] = max(a[i + 1], a[i] + 1);
q.push(i + 1);
}
}
}
for (i = 0; i <= n; ++i) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
const int INF = (1 << 30);
const ll INFLL = (1ll << 60);
const ll MOD = (ll)(1e9 + 7);
#define l_ength size
void mul_mod(ll &a, ll b) {
a *= b;
a %= MOD;
}
void add_mod(ll &a, ll b) {
a = (a < MOD) ? a : (a - MOD);
b = (b < MOD) ? b : (b - MOD);
a += b;
a = (a < MOD) ? a : (a - MOD);
}
ll a[555555];
queue<int> q;
int main(void) {
int n, i;
ll b = 0ll, ans = 0ll;
string s;
cin >> s;
n = s.l_ength();
if (s[0] == '<') {
q.push(0);
}
if (s[n - 1] == '>') {
q.push(n);
}
for (i = 1; i < n; ++i) {
if (s[i - 1] == '>' && s[i] == '<') {
q.push(i);
}
}
while (!q.empty()) {
i = q.front();
q.pop();
if (i == 0) {
if (s[0] == '<') {
a[1] = max(a[1], a[0] + 1);
q.push(1);
}
} else if (i == n) {
if (s[n - 1] == '>') {
a[n - 1] = max(a[n - 1], a[n] + 1);
q.push(n - 1);
}
} else {
if (s[i - 1] == '>') {
a[i - 1] = max(a[i - 1], a[i] + 1);
q.push(i - 1);
}
if (s[i] == '<') {
a[i + 1] = max(a[i + 1], a[i] + 1);
q.push(i + 1);
}
}
}
for (i = 0; i <= n; ++i) {
ans += a[i];
}
cout << ans << endl;
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
vector<int64_t> A(S.size() + 1, 0);
for (int i = 1; i <= S.size(); i++) {
if (S.at(i - 1) == '<') {
A.at(i) = A.at(i - 1) + 1;
} else {
int64_t cnt = 0;
for (int j = i - 1; j < S.size(); j++) {
if (S.at(j) == '<')
break;
cnt++;
}
A.at(i - 1) = max(A.at(i - 1), cnt);
int64_t tmp = cnt - 1, j = i;
while (tmp >= 0) {
A.at(j) = tmp;
tmp--;
j++;
}
}
}
int64_t ans = 0;
for (auto a : A)
ans += a;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
string S;
cin >> S;
vector<int64_t> A(S.size() + 1, 0);
for (int i = 1; i <= S.size(); i++) {
if (S.at(i - 1) == '<') {
A.at(i) = A.at(i - 1) + 1;
} else {
int64_t cnt = 0;
for (int j = i - 1; j < S.size(); j++) {
if (S.at(j) == '<')
break;
cnt++;
}
A.at(i - 1) = max(A.at(i - 1), cnt);
int64_t tmp = cnt - 1, j = i;
while (tmp >= 0) {
A.at(j) = tmp;
tmp--;
j++;
}
i = j - 1;
}
}
int64_t ans = 0;
for (auto a : A)
ans += a;
cout << ans << endl;
} | insert | 24 | 24 | 24 | 25 | TLE | |
p02873 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < (int)(n); i++)
#define N 200010
int main() {
char a[N];
long long b[N];
f(i, N) a[i] = 0;
int n, k;
int x, y, z;
long long s, ans;
bool v = true;
ans = 0;
scanf("%s", a);
n = strlen(a);
b[0] = 0;
f(i, n) {
if (a[i] == '<')
b[i + 1] = b[i] + 1;
else
b[i + 1] = 0;
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] == '>')
b[i] = max(b[i], b[i + 1] + 1);
}
f(i, n + 1) ans += b[i];
printf("%lld\n", ans);
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define MOD 1000000007
#define f(i, n) for (int i = 0; i < (int)(n); i++)
#define N 500010
int main() {
char a[N];
long long b[N];
f(i, N) a[i] = 0;
int n, k;
int x, y, z;
long long s, ans;
bool v = true;
ans = 0;
scanf("%s", a);
n = strlen(a);
b[0] = 0;
f(i, n) {
if (a[i] == '<')
b[i + 1] = b[i] + 1;
else
b[i + 1] = 0;
}
for (int i = n - 1; i >= 0; i--) {
if (a[i] == '>')
b[i] = max(b[i], b[i + 1] + 1);
}
f(i, n + 1) ans += b[i];
printf("%lld\n", ans);
return 0;
}
| replace | 14 | 15 | 14 | 15 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int i;
int chk = 0;
long ans = 0;
int a[n + 1];
for (i = 0; i < n + 1; i++) {
a[i] = 0;
}
while (chk == 0) {
chk = 1;
for (i = 0; i < n; i++) {
if (s[i] == '<') {
if (a[i] >= a[i + 1]) {
a[i + 1] = a[i] + 1;
chk = 0;
}
} else {
if (a[i] <= a[i + 1]) {
a[i] = a[i + 1] + 1;
chk = 0;
}
}
}
}
for (i = 0; i <= n; i++) {
ans += a[i];
}
cout << ans;
}
| #include <iostream>
#include <string>
using namespace std;
int main() {
string s;
cin >> s;
int n = s.length();
int i;
int chk = 0;
long ans = 0;
int a[n + 1];
for (i = 0; i < n + 1; i++) {
a[i] = 0;
}
while (chk == 0) {
chk = 1;
for (i = 0; i < n; i++) {
if (s[i] == '<') {
if (a[i] >= a[i + 1]) {
a[i + 1] = a[i] + 1;
chk = 0;
}
} else {
if (a[i] <= a[i + 1]) {
a[i] = a[i + 1] + 1;
chk = 0;
}
}
}
for (i = n - 1; i >= 0; i--) {
if (s[i] == '<') {
if (a[i] >= a[i + 1]) {
a[i + 1] = a[i] + 1;
chk = 0;
}
} else {
if (a[i] <= a[i + 1]) {
a[i] = a[i + 1] + 1;
chk = 0;
}
}
}
}
for (i = 0; i <= n; i++) {
ans += a[i];
}
cout << ans;
} | insert | 30 | 30 | 30 | 43 | TLE | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int maxn = 300100;
char str[maxn];
int l[maxn], r[maxn];
int Max(int x, int y) { return x > y ? x : y; }
int main() {
// freopen("A.in","r",stdin);
scanf("%s", str + 1);
int n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
if (str[i] == '<')
l[i] = l[i - 1] + 1;
else
l[i] = 0;
}
for (int i = n; i >= 1; i--) {
if (str[i] == '>')
r[i - 1] = r[i] + 1;
else
r[i - 1] = 0;
}
long long ans = 0;
for (int i = 0; i <= n; i++)
ans += Max(l[i], r[i]);
printf("%lld\n", ans);
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
const int maxn = 500100;
char str[maxn];
int l[maxn], r[maxn];
int Max(int x, int y) { return x > y ? x : y; }
int main() {
// freopen("A.in","r",stdin);
scanf("%s", str + 1);
int n = strlen(str + 1);
for (int i = 1; i <= n; i++) {
if (str[i] == '<')
l[i] = l[i - 1] + 1;
else
l[i] = 0;
}
for (int i = n; i >= 1; i--) {
if (str[i] == '>')
r[i - 1] = r[i] + 1;
else
r[i - 1] = 0;
}
long long ans = 0;
for (int i = 0; i <= n; i++)
ans += Max(l[i], r[i]);
printf("%lld\n", ans);
return 0;
}
| replace | 2 | 3 | 2 | 3 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
#define eb emplace_back
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 2e5 + 233;
char s[maxn];
ll ans = 0;
int main() {
scanf("%s", s);
int n = strlen(s);
int cur = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '<') {
cur++;
ans += cur;
} else {
int j = i;
while (j + 1 < n && s[j + 1] == s[j])
j++;
// cout<<i<<"->"<<j<<endl;
ll siz = j - i + 1;
if (siz >= cur) {
ans -= cur;
ans += siz * (siz + 1) / 2;
} else {
ans += (siz - 1) * (siz) / 2;
}
cur = 0;
i = j;
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
#define ll long long
#define pb push_back
#define pii pair<int, int>
#define mp make_pair
#define fi first
#define se second
#define eb emplace_back
using namespace std;
const int mod = 1e9 + 7;
const int maxn = 1e6 + 233;
char s[maxn];
ll ans = 0;
int main() {
scanf("%s", s);
int n = strlen(s);
int cur = 0;
for (int i = 0; i < n; i++) {
if (s[i] == '<') {
cur++;
ans += cur;
} else {
int j = i;
while (j + 1 < n && s[j + 1] == s[j])
j++;
// cout<<i<<"->"<<j<<endl;
ll siz = j - i + 1;
if (siz >= cur) {
ans -= cur;
ans += siz * (siz + 1) / 2;
} else {
ans += (siz - 1) * (siz) / 2;
}
cur = 0;
i = j;
}
}
cout << ans << endl;
return 0;
}
| replace | 10 | 11 | 10 | 11 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 100000;
char s[maxn + 5];
int n;
int a[maxn + 5], v[maxn + 5];
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
s[0] = '>';
s[n + 1] = '<';
for (int i = 1; i <= n + 1; i++) {
if (s[i - 1] == '>' && s[i] == '<')
v[i] = -1;
if (s[i - 1] == '<' && s[i] == '>')
v[i] = 1;
}
int flag = 0;
for (int i = 1; i <= n + 1; i++) {
if (v[i] == -1)
flag = 1;
else if (!flag)
continue;
else {
if (v[i] == 1)
flag = 0;
a[i] = max(a[i], a[i - 1] + 1);
}
}
flag = 0;
for (int i = n + 1; i >= 1; i--) {
if (v[i] == -1)
flag = 1;
else if (!flag)
continue;
else {
if (v[i] == 1)
flag = 0;
a[i] = max(a[i], a[i + 1] + 1);
}
}
int sum = 0;
for (int i = 1; i <= n + 1; i++)
sum += a[i];
printf("%lld\n", sum);
return 0;
} | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int maxn = 500000;
char s[maxn + 5];
int n;
int a[maxn + 5], v[maxn + 5];
signed main() {
scanf("%s", s + 1);
n = strlen(s + 1);
s[0] = '>';
s[n + 1] = '<';
for (int i = 1; i <= n + 1; i++) {
if (s[i - 1] == '>' && s[i] == '<')
v[i] = -1;
if (s[i - 1] == '<' && s[i] == '>')
v[i] = 1;
}
int flag = 0;
for (int i = 1; i <= n + 1; i++) {
if (v[i] == -1)
flag = 1;
else if (!flag)
continue;
else {
if (v[i] == 1)
flag = 0;
a[i] = max(a[i], a[i - 1] + 1);
}
}
flag = 0;
for (int i = n + 1; i >= 1; i--) {
if (v[i] == -1)
flag = 1;
else if (!flag)
continue;
else {
if (v[i] == 1)
flag = 0;
a[i] = max(a[i], a[i + 1] + 1);
}
}
int sum = 0;
for (int i = 1; i <= n + 1; i++)
sum += a[i];
printf("%lld\n", sum);
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 100100;
int N;
string s;
int A[MAXN];
int blo[MAXN];
int res[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
N = s.length();
blo[N] = 0;
for (int i = N - 1; i >= 0; i--) {
if (s[i] == '<') {
blo[i] = 0;
} else {
blo[i] = blo[i + 1] + 1;
}
}
res[0] = blo[0];
for (int i = 0; i < N; i++) {
if (s[i] == '<') {
res[i + 1] = max(blo[i + 1], res[i] + 1);
} else {
res[i + 1] = blo[i + 1];
}
}
ll ans = 0;
for (int i = 0; i <= N; i++)
ans += res[i];
cout << ans << "\n";
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAXN = 500100;
int N;
string s;
int A[MAXN];
int blo[MAXN];
int res[MAXN];
int main() {
ios_base::sync_with_stdio(0);
cin >> s;
N = s.length();
blo[N] = 0;
for (int i = N - 1; i >= 0; i--) {
if (s[i] == '<') {
blo[i] = 0;
} else {
blo[i] = blo[i + 1] + 1;
}
}
res[0] = blo[0];
for (int i = 0; i < N; i++) {
if (s[i] == '<') {
res[i + 1] = max(blo[i + 1], res[i] + 1);
} else {
res[i + 1] = blo[i + 1];
}
}
ll ans = 0;
for (int i = 0; i <= N; i++)
ans += res[i];
cout << ans << "\n";
} | replace | 4 | 5 | 4 | 5 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long int ll;
typedef pair<int, int> P;
string s;
ll l[101010], r[101010];
int main() {
cin >> s;
int n = s.size();
l[0] = 0;
r[n] = 0;
rep(i, n) {
if (s[i] == '<') {
l[i + 1] = l[i] + 1LL;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
r[i] = r[i + 1] + 1LL;
}
}
ll res = 0;
rep(i, n + 1) res += max(l[i], r[i]);
cout << res << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef long long int ll;
typedef pair<int, int> P;
string s;
ll l[505050], r[505050];
int main() {
cin >> s;
int n = s.size();
l[0] = 0;
r[n] = 0;
rep(i, n) {
if (s[i] == '<') {
l[i + 1] = l[i] + 1LL;
}
}
for (int i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
r[i] = r[i + 1] + 1LL;
}
}
ll res = 0;
rep(i, n + 1) res += max(l[i], r[i]);
cout << res << endl;
return 0;
}
| replace | 7 | 8 | 7 | 8 | 0 | |
p02873 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
string s;
cin >> s;
ll n = s.length();
ll st = -1, en = -1;
for (ll i = 0; i < n; i++) {
if (s[i] == '<') {
st = i;
break;
}
}
for (ll i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
en = i;
break;
}
}
// cout<<st<<" "<<en<<endl;
// if(st==-1||en==-1){
// cout<<(n*(n-1))/2<<endl;
// }
// else{
ll ans = 0;
for (ll i = st; i <= en;) {
ll c1 = 0;
while (i <= en && s[i] == '<') {
c1++;
i++;
}
ll c2 = 0;
while (i <= en && s[i] == '>') {
c2++;
i++;
}
// cout<<c1<<" "<<c2<<endl;
if (c1 > c2)
swap(c1, c2);
ans += ((c1) * (c1 - 1) / 2);
ans += ((c2) * (c2 + 1) / 2);
// cout<<"ans: "<<ans<<endl;
}
ll c1 = st;
ans += ((c1) * (c1 + 1) / 2);
ll c2 = n - en - 1;
ans += ((c2) * (c2 + 1) / 2);
cout << ans << endl;
// }
} | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
int main() {
string s;
cin >> s;
ll n = s.length();
ll st = -1, en = -1;
for (ll i = 0; i < n; i++) {
if (s[i] == '<') {
st = i;
break;
}
}
for (ll i = n - 1; i >= 0; i--) {
if (s[i] == '>') {
en = i;
break;
}
}
if (st == -1) {
cout << (n * (n + 1)) / 2 << endl;
return 0;
}
// cout<<"fgh"<<endl;
// cout<<st<<" "<<en<<endl;
// if(st==-1||en==-1){
// cout<<(n*(n-1))/2<<endl;
// }
// else{
ll ans = 0;
for (ll i = st; i <= en;) {
ll c1 = 0;
while (i <= en && s[i] == '<') {
c1++;
i++;
}
ll c2 = 0;
while (i <= en && s[i] == '>') {
c2++;
i++;
}
// cout<<c1<<" "<<c2<<endl;
if (c1 > c2)
swap(c1, c2);
ans += ((c1) * (c1 - 1) / 2);
ans += ((c2) * (c2 + 1) / 2);
// cout<<"ans: "<<ans<<endl;
}
ll c1 = st;
ans += ((c1) * (c1 + 1) / 2);
ll c2 = n - en - 1;
ans += ((c2) * (c2 + 1) / 2);
cout << ans << endl;
// }
} | insert | 22 | 22 | 22 | 29 | TLE | |
p02873 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
// Solve when the interval [a, b] contains no ><
// -> It has form <<<<<<>>>>>>>
ll solve(string str, int a, int b) {
int x = 0;
int y = 0;
for (int i = a; i <= b; ++i) {
if (str[i] == '<')
++x;
else
++y;
}
// Middle element: max(x, y)
ll res = max(x, y);
// Left side: 1 + 2 + ... + x-1
res += (ll)x * (x - 1) / 2;
// Right side: 1 + 2 + ... + y-1
res += (ll)y * (y - 1) / 2;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string str;
cin >> str;
int n = str.size();
// If we have ><, we want zero in the middle
// Divide and conquer on occurrences of ><
ll sum = 0;
int p = 0;
for (int i = 0; i + 1 < n; ++i) {
if (str[i] == '>' && str[i + 1] == '<') {
sum += solve(str, p, i);
p = i + 1;
}
}
sum += solve(str, p, n - 1);
cout << sum << '\n';
}
| #include <iostream>
#include <vector>
using namespace std;
using ll = long long;
// Solve when the interval [a, b] contains no ><
// -> It has form <<<<<<>>>>>>>
ll solve(const string &str, int a, int b) {
int x = 0;
int y = 0;
for (int i = a; i <= b; ++i) {
if (str[i] == '<')
++x;
else
++y;
}
// Middle element: max(x, y)
ll res = max(x, y);
// Left side: 1 + 2 + ... + x-1
res += (ll)x * (x - 1) / 2;
// Right side: 1 + 2 + ... + y-1
res += (ll)y * (y - 1) / 2;
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
string str;
cin >> str;
int n = str.size();
// If we have ><, we want zero in the middle
// Divide and conquer on occurrences of ><
ll sum = 0;
int p = 0;
for (int i = 0; i + 1 < n; ++i) {
if (str[i] == '>' && str[i + 1] == '<') {
sum += solve(str, p, i);
p = i + 1;
}
}
sum += solve(str, p, n - 1);
cout << sum << '\n';
}
| replace | 7 | 8 | 7 | 8 | TLE | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define sb __builtin_popcount
#define MOD (ll)1000000007
int rate[100000 + 10];
long long values[100000 + 10];
int32_t main() {
long long ans = 0, tmp = 0;
string s;
cin >> s;
int n = s.size() + 1;
vector<int> rate;
rate.push_back(0);
for (int i = 1; i < n; i++) {
if (s[i - 1] == '<') {
rate.push_back(rate[i - 1] + 1);
} else {
rate.push_back(rate[i - 1] - 1);
}
}
values[0] = 1;
// case 1
for (int i = 1; i < n; i++) { // scan input array from left to right
if (rate[i] > rate[i - 1]) {
values[i] = values[i - 1] + 1; // case 1, a
} else
values[i] = 1; // case 1,b
}
ans = values[n - 1]; // case 2
for (int i = n - 2; i >= 0; i--) { // scan input array from right to left
if (rate[i] > rate[i + 1]) {
tmp = values[i + 1] + 1; // case 2, a
} else
tmp = 1; // case 2, b
ans += max(tmp, values[i]); // maximum of the two values for child (i)
values[i] = tmp;
}
cout << ans - n;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define pb push_back
#define sb __builtin_popcount
#define MOD (ll)1000000007
long long values[600000];
int32_t main() {
long long ans = 0, tmp = 0;
string s;
cin >> s;
int n = s.size() + 1;
vector<int> rate;
rate.push_back(0);
for (int i = 1; i < n; i++) {
if (s[i - 1] == '<') {
rate.push_back(rate[i - 1] + 1);
} else {
rate.push_back(rate[i - 1] - 1);
}
}
values[0] = 1;
// case 1
for (int i = 1; i < n; i++) { // scan input array from left to right
if (rate[i] > rate[i - 1]) {
values[i] = values[i - 1] + 1; // case 1, a
} else
values[i] = 1; // case 1,b
}
ans = values[n - 1]; // case 2
for (int i = n - 2; i >= 0; i--) { // scan input array from right to left
if (rate[i] > rate[i + 1]) {
tmp = values[i + 1] + 1; // case 2, a
} else
tmp = 1; // case 2, b
ans += max(tmp, values[i]); // maximum of the two values for child (i)
values[i] = tmp;
}
cout << ans - n;
return 0;
} | replace | 7 | 9 | 7 | 8 | 0 | |
p02873 | C++ | Time Limit Exceeded | // Author : Ritik Patel
// Institution: Pandit Deendayal Petroleum University
#include <bits/stdc++.h>
using namespace std;
#define ub upper_bound // first element > val(itr)
#define lb lower_bound // first element >= val(itr)
#define pb push_back
#define sz(a) int((a).size())
#define all(c) (c).begin(), (c).end()
#define rall(a) (a).rbegin(), (a).rend()
#define tr(c, i) for (typeof((c)).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define what_is(x) cout << #x << " is: " << x << endl;
#define UNIQUE(v) \
do { \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
} while (false)
#define bitcount(a) __builtin_popcount(a) // count set bits
#define lzcount(x) \
__builtin_clz(x) // count leading zeros in binary representation of number
#define tzcount(x) \
__builtin_ctz(x) // count trailing zeros in binary representation of number
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
typedef long long ll;
typedef long double lld;
const ll MOD = 1e9 + 7;
const lld PI = acos(-1.0);
template <typename T> T gcd(T a, T b) {
if (b > a)
return gcd(b, a);
return b == 0 ? a : gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a * b / gcd(a, b); }
template <typename T> T fast_power(T x, T y) {
T ans = 1;
while (y > 0) {
if (y & 1LL)
ans = (ans * x);
y >>= 1LL;
x = (x * x);
}
return ans;
}
template <typename X> inline X abs(const X &a) { return a < 0 ? -a : a; }
template <typename X> inline X sqr(const X &a) { return a * a; }
template <typename T> inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
// ll findMMI_fermat(ll n,ll M) {ll ans= fast_power(n,M-2,M);return ans;}//i.e
// In (a/b)%M..it calculates MMI of b wrt M,only if M is prime ll add(ll a,ll
// b,ll M) { return mod(( mod(a,M ) + mod(b,M )),M); } ll sub(ll a, ll b,ll
// M) { return mod((mod(a,M ) + M - mod(b,M )),M); }
ll mult(ll a, ll b, ll M) { return (a % M * b % M) % M; }
bool isprime(ll a) {
if (a == 2) {
return 1;
}
if (!(a & 1)) {
return 0;
}
for (ll i = 3; i * i <= a; i += 2) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) { // when a and b are coprimes
if (a == 0) {
x = 0;
y = 1;
return b;
}
T p = b / a;
T g = extgcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
ll inv(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y);
return (x + m) % m;
}
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int INF = 1 << 30;
const ll LINF = 1ll << 60;
/* For counting number of digits, directly do floor(log10(n)+1)
/* -------------------------------Main
Code------------------------------- */
int main() {
FAST string s;
cin >> s;
int prev;
if (s[0] == '<')
prev = 0;
else
prev = 1;
int done = 1;
ll ans = 0;
for (int i = 0; i < sz(s);) {
int len1 = 0, len2 = 0;
if (s[i] == '<') {
int j = i;
while (s[j] == '<' && j < sz(s)) {
j++;
}
int k = j;
while (s[k] == '>' && k < sz(s)) {
k++;
}
len1 = j - i;
len2 = k - j;
if (len1 == len2) {
ans += (ll)len1 * (len1 - 1) / 2;
ans += (ll)len2 * (len2 + 1) / 2;
} else {
int mn = min(len1, len2);
int mx = max(len1, len2);
ans += (ll)mn * (mn - 1) / 2;
ans += (ll)mx * (mx + 1) / 2;
}
i = k;
} else {
int j = i;
while (s[j] == '>' && j < sz(s)) {
j++;
}
int len = j - i;
ans += (ll)len * (len + 1) / 2;
}
}
cout << ans << "\n";
return 0;
}
| // Author : Ritik Patel
// Institution: Pandit Deendayal Petroleum University
#include <bits/stdc++.h>
using namespace std;
#define ub upper_bound // first element > val(itr)
#define lb lower_bound // first element >= val(itr)
#define pb push_back
#define sz(a) int((a).size())
#define all(c) (c).begin(), (c).end()
#define rall(a) (a).rbegin(), (a).rend()
#define tr(c, i) for (typeof((c)).begin() i = (c).begin(); i != (c).end(); i++)
#define present(c, x) ((c).find(x) != (c).end())
#define cpresent(c, x) (find(all(c), x) != (c).end())
#define what_is(x) cout << #x << " is: " << x << endl;
#define UNIQUE(v) \
do { \
sort((v).begin(), (v).end()); \
(v).erase(unique((v).begin(), (v).end()), (v).end()); \
} while (false)
#define bitcount(a) __builtin_popcount(a) // count set bits
#define lzcount(x) \
__builtin_clz(x) // count leading zeros in binary representation of number
#define tzcount(x) \
__builtin_ctz(x) // count trailing zeros in binary representation of number
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(nullptr); \
cout.tie(nullptr);
typedef long long ll;
typedef long double lld;
const ll MOD = 1e9 + 7;
const lld PI = acos(-1.0);
template <typename T> T gcd(T a, T b) {
if (b > a)
return gcd(b, a);
return b == 0 ? a : gcd(b, a % b);
}
template <typename T> T lcm(T a, T b) { return a * b / gcd(a, b); }
template <typename T> T fast_power(T x, T y) {
T ans = 1;
while (y > 0) {
if (y & 1LL)
ans = (ans * x);
y >>= 1LL;
x = (x * x);
}
return ans;
}
template <typename X> inline X abs(const X &a) { return a < 0 ? -a : a; }
template <typename X> inline X sqr(const X &a) { return a * a; }
template <typename T> inline string toStr(T x) {
stringstream st;
st << x;
string s;
st >> s;
return s;
}
// ll findMMI_fermat(ll n,ll M) {ll ans= fast_power(n,M-2,M);return ans;}//i.e
// In (a/b)%M..it calculates MMI of b wrt M,only if M is prime ll add(ll a,ll
// b,ll M) { return mod(( mod(a,M ) + mod(b,M )),M); } ll sub(ll a, ll b,ll
// M) { return mod((mod(a,M ) + M - mod(b,M )),M); }
ll mult(ll a, ll b, ll M) { return (a % M * b % M) % M; }
bool isprime(ll a) {
if (a == 2) {
return 1;
}
if (!(a & 1)) {
return 0;
}
for (ll i = 3; i * i <= a; i += 2) {
if (a % i == 0) {
return 0;
}
}
return 1;
}
template <typename T>
T extgcd(T a, T b, T &x, T &y) { // when a and b are coprimes
if (a == 0) {
x = 0;
y = 1;
return b;
}
T p = b / a;
T g = extgcd(b - p * a, a, y, x);
x -= p * y;
return g;
}
ll inv(ll a, ll m) {
ll x, y;
extgcd(a, m, x, y);
return (x + m) % m;
}
typedef vector<int> vi;
typedef vector<ll> vl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
int dx[] = {1, -1, 0, 0};
int dy[] = {0, 0, 1, -1};
const int INF = 1 << 30;
const ll LINF = 1ll << 60;
/* For counting number of digits, directly do floor(log10(n)+1)
/* -------------------------------Main
Code------------------------------- */
int main() {
FAST string s;
cin >> s;
int prev;
if (s[0] == '<')
prev = 0;
else
prev = 1;
int done = 1;
ll ans = 0;
for (int i = 0; i < sz(s);) {
int len1 = 0, len2 = 0;
if (s[i] == '<') {
int j = i;
while (s[j] == '<' && j < sz(s)) {
j++;
}
int k = j;
while (s[k] == '>' && k < sz(s)) {
k++;
}
len1 = j - i;
len2 = k - j;
if (len1 == len2) {
ans += (ll)len1 * (len1 - 1) / 2;
ans += (ll)len2 * (len2 + 1) / 2;
} else {
int mn = min(len1, len2);
int mx = max(len1, len2);
ans += (ll)mn * (mn - 1) / 2;
ans += (ll)mx * (mx + 1) / 2;
}
i = k;
} else {
int j = i;
while (s[j] == '>' && j < sz(s)) {
j++;
}
int len = j - i;
ans += (ll)len * (len + 1) / 2;
i = j;
}
}
cout << ans << "\n";
return 0;
}
| insert | 157 | 157 | 157 | 158 | TLE | |
p02873 | C++ | Runtime Error | #pragma GCC target("avx2")
#pragma GCC optimize("O3")
// # include <x86intrin.h>
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define For(i, x, y) for (ll i = x; i <= y; i++)
#define FOr(i, x, y) for (ll i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
// ROAD to... Red
inline void Input_Output() {
// freopen(".in", "r", stdin);
// freopen(".out", "w", stdout);
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int cnt[N];
string s;
int a[N];
vector<int> g[N];
int u[N];
int ans, res;
int cur;
int was[N];
int deg[N];
int main() {
SpeedForce;
cin >> s;
s = '#' + s;
n = sz(s);
for (int i = 1; i < n; i++) {
if (s[i] == '<')
g[i].pb(i + 1), u[i + 1] = 1;
else
g[i + 1].pb(i), u[i] = 1;
}
queue<int> q;
for (int i = 1; i <= n; i++)
if (!u[i]) {
was[i] = 1;
q.push(i);
}
for (int i = 1; i <= n; i++)
deg[i] = sz(g[i]);
while (q.size()) {
int v = q.front();
q.pop();
for (auto to : g[v]) {
deg[to]--;
if (!deg[to]) {
was[to] = 1;
q.push(to);
}
a[to] = max(a[to], a[v] + 1);
}
}
cout << accumulate(a + 1, a + n + 1, 0ll);
return Accepted;
}
// B...a
| #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define _USE_MATH_DEFINES_
#define ll long long
#define ld long double
#define Accepted 0
#define pb push_back
#define mp make_pair
#define sz(x) (int)(x.size())
#define every(x) x.begin(), x.end()
#define F first
#define S second
#define lb lower_bound
#define ub upper_bound
#define For(i, x, y) for (ll i = x; i <= y; i++)
#define FOr(i, x, y) for (ll i = x; i >= y; i--)
#define SpeedForce ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0)
// ROAD to... Red
inline void Input_Output() {
// freopen(".in", "r", stdin);
// freopen(".out", "w", stdout);
}
const double eps = 0.000001;
const ld pi = acos(-1);
const int maxn = 1e7 + 9;
const int mod = 1e9 + 7;
const ll MOD = 1e18 + 9;
const ll INF = 1e18 + 123;
const int inf = 2e9 + 11;
const int mxn = 1e6 + 9;
const int N = 6e5 + 123;
const int M = 22;
const int pri = 997;
const int Magic = 2101;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int n, m, k;
int cnt[N];
string s;
int a[N];
vector<int> g[N];
int u[N];
int ans, res;
int cur;
int was[N];
int deg[N];
int main() {
SpeedForce;
cin >> s;
s = '#' + s;
n = sz(s);
for (int i = 1; i < n; i++) {
if (s[i] == '<')
g[i].pb(i + 1), u[i + 1] = 1;
else
g[i + 1].pb(i), u[i] = 1;
}
queue<int> q;
for (int i = 1; i <= n; i++)
if (!u[i]) {
was[i] = 1;
q.push(i);
}
for (int i = 1; i <= n; i++)
deg[i] = sz(g[i]);
while (q.size()) {
int v = q.front();
q.pop();
for (auto to : g[v]) {
deg[to]--;
if (!deg[to]) {
was[to] = 1;
q.push(to);
}
a[to] = max(a[to], a[v] + 1);
}
}
cout << accumulate(a + 1, a + n + 1, 0ll);
return Accepted;
}
// B...a
| delete | 0 | 4 | 0 | 0 | 0 | |
p02873 | C++ | Runtime Error | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define int long long
using namespace std;
vector<vector<int>> adj;
int dp[100005];
int vis[100005];
int ans = 0;
int dfs(int ver) {
vis[ver] = 1;
int mx = 0;
for (auto i : adj[ver]) {
if (vis[i] == 0)
mx = max(mx, dfs(i));
else {
mx = max(mx, dp[i]);
}
}
dp[ver] = mx + 1;
ans = max(dp[ver], ans);
return dp[ver];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// #ifndef ONLINE_JUDGE
// freopen ("INPUT.txt" , "r" , stdin);
// freopen ("OUTPUT.txt" , "w" , stdout);
// #endif
clock_t clk;
clk = clock();
// -------------------------------------Code starts
// here---------------------------------------------------------------------
string s;
cin >> s;
int n = s.length();
adj.resize(n + 1);
for (int i = 0; i < n; i++) {
if (s[i] == '>')
adj[i].push_back(i + 1);
else {
adj[i + 1].push_back(i);
}
}
for (int i = 0; i <= n; i++) {
if (vis[i] == 0)
dfs(i);
}
int ans = 0;
for (int i = 0; i <= n; i++)
ans += dp[i] - 1;
// cout<<(ans*(ans-1))/2;
cout << ans;
// -------------------------------------Code ends
// here------------------------------------------------------
clk = clock() - clk;
cerr << fixed << setprecision(6) << "Time: " << ((double)clk) / CLOCKS_PER_SEC
<< "\n";
return 0;
} | #pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <bits/stdc++.h>
#define int long long
using namespace std;
vector<vector<int>> adj;
int dp[500005];
int vis[500005];
int ans = 0;
int dfs(int ver) {
vis[ver] = 1;
int mx = 0;
for (auto i : adj[ver]) {
if (vis[i] == 0)
mx = max(mx, dfs(i));
else {
mx = max(mx, dp[i]);
}
}
dp[ver] = mx + 1;
ans = max(dp[ver], ans);
return dp[ver];
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
// #ifndef ONLINE_JUDGE
// freopen ("INPUT.txt" , "r" , stdin);
// freopen ("OUTPUT.txt" , "w" , stdout);
// #endif
clock_t clk;
clk = clock();
// -------------------------------------Code starts
// here---------------------------------------------------------------------
string s;
cin >> s;
int n = s.length();
adj.resize(n + 1);
for (int i = 0; i < n; i++) {
if (s[i] == '>')
adj[i].push_back(i + 1);
else {
adj[i + 1].push_back(i);
}
}
for (int i = 0; i <= n; i++) {
if (vis[i] == 0)
dfs(i);
}
int ans = 0;
for (int i = 0; i <= n; i++)
ans += dp[i] - 1;
// cout<<(ans*(ans-1))/2;
cout << ans;
// -------------------------------------Code ends
// here------------------------------------------------------
clk = clock() - clk;
cerr << fixed << setprecision(6) << "Time: " << ((double)clk) / CLOCKS_PER_SEC
<< "\n";
return 0;
} | replace | 8 | 10 | 8 | 10 | 0 | Time: 0.000066
|
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define maxn 200005
#define ll long long
#define mod 1000000007
typedef pair<int, int> P;
int n;
char s[maxn];
vector<int> v[maxn];
bool used[maxn];
ll d[maxn];
void dfs(int now) {
if (used[now])
return;
used[now] = 1;
d[now] = 0;
if (v[now].empty())
return;
for (int x : v[now]) {
dfs(x);
d[now] = max(d[now], d[x]);
}
d[now]++;
}
int main() {
// cin >> n;
scanf("%s", s + 1);
n = strlen(s + 1) + 1;
for (int i = 1; i <= n - 1; i++) {
if (s[i] == '<')
v[i + 1].push_back(i);
else
v[i].push_back(i + 1);
}
for (int i = 1; i <= n; i++) {
if (!used[i])
dfs(i);
// printf("i=%d %d\n", i, d[i]);
}
ll ans = 0;
for (int i = 1; i <= n; i++)
ans += d[i];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define maxn 500005
#define ll long long
#define mod 1000000007
typedef pair<int, int> P;
int n;
char s[maxn];
vector<int> v[maxn];
bool used[maxn];
ll d[maxn];
void dfs(int now) {
if (used[now])
return;
used[now] = 1;
d[now] = 0;
if (v[now].empty())
return;
for (int x : v[now]) {
dfs(x);
d[now] = max(d[now], d[x]);
}
d[now]++;
}
int main() {
// cin >> n;
scanf("%s", s + 1);
n = strlen(s + 1) + 1;
for (int i = 1; i <= n - 1; i++) {
if (s[i] == '<')
v[i + 1].push_back(i);
else
v[i].push_back(i + 1);
}
for (int i = 1; i <= n; i++) {
if (!used[i])
dfs(i);
// printf("i=%d %d\n", i, d[i]);
}
ll ans = 0;
for (int i = 1; i <= n; i++)
ans += d[i];
cout << ans << endl;
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define fileio freopen("in.in", "r", stdin), freopen("out.out", "w", stdout);
#define ll long long int
#define FF first
#define SS second
#define mp make_pair
#define pb push_back
#define pii pair<int, int>
#define pll pair<long long int, long long int>
#define sd(x) scanf("%d", &x)
#define slld(x) scanf("%lld", &x)
#define pd(x) printf("%d\n", x)
#define plld(x) printf("%lld\n", x)
#define pss printf
#define MOD 1000000007
#define INF 1e18
#define eps 0.00001
#define endl '\n'
#define debug(n1) cout << n1 << endl
int n;
string s;
ll ans = 0;
int val[200005];
int main() {
SPEED;
cin >> s;
n = s.length();
int i = 0, j = 0;
while (i < n && j < n) {
while (j < n && s[i] == s[j])
j++;
if (s[i] == '>') {
for (int h = j; h >= i; h--)
val[h] = max(val[h], j - h);
} else {
for (int h = i; h <= j; h++)
val[h] = max(val[h], h - i);
}
i = j;
}
for (int i = 0; i <= n; i++)
ans += val[i];
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define SPEED \
ios::sync_with_stdio(false); \
cin.tie(0); \
cout.tie(0)
#define fileio freopen("in.in", "r", stdin), freopen("out.out", "w", stdout);
#define ll long long int
#define FF first
#define SS second
#define mp make_pair
#define pb push_back
#define pii pair<int, int>
#define pll pair<long long int, long long int>
#define sd(x) scanf("%d", &x)
#define slld(x) scanf("%lld", &x)
#define pd(x) printf("%d\n", x)
#define plld(x) printf("%lld\n", x)
#define pss printf
#define MOD 1000000007
#define INF 1e18
#define eps 0.00001
#define endl '\n'
#define debug(n1) cout << n1 << endl
int n;
string s;
ll ans = 0;
int val[500005];
int main() {
SPEED;
cin >> s;
n = s.length();
int i = 0, j = 0;
while (i < n && j < n) {
while (j < n && s[i] == s[j])
j++;
if (s[i] == '>') {
for (int h = j; h >= i; h--)
val[h] = max(val[h], j - h);
} else {
for (int h = i; h <= j; h++)
val[h] = max(val[h], h - i);
}
i = j;
}
for (int i = 0; i <= n; i++)
ans += val[i];
cout << ans << endl;
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p02873 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, k, n) for (int i = (int)(k); i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rREP(i, k, n) for (int i = (int)(n)-1; i >= k; i--)
int main() {
string s;
cin >> s;
int lc[50010] = {};
int rc[50010] = {};
int cn = 0;
rep(i, s.size()) {
lc[i] = cn;
if (s[i] == '<')
cn++;
else
cn = 0;
}
lc[s.size()] = cn;
cn = 0;
rrep(i, s.size()) {
rc[i + 1] = cn;
if (s[i] == '>')
cn++;
else
cn = 0;
}
rc[0] = cn;
ll sn = 0;
rep(i, s.size() + 1) { sn += max(lc[i], rc[i]); }
cout << sn << endl;
return 0;
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define ll long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define REP(i, k, n) for (int i = (int)(k); i < (int)(n); i++)
#define rrep(i, n) for (int i = (int)(n)-1; i >= 0; i--)
#define rREP(i, k, n) for (int i = (int)(n)-1; i >= k; i--)
int main() {
string s;
cin >> s;
int lc[500100] = {};
int rc[500100] = {};
int cn = 0;
rep(i, s.size()) {
lc[i] = cn;
if (s[i] == '<')
cn++;
else
cn = 0;
}
lc[s.size()] = cn;
cn = 0;
rrep(i, s.size()) {
rc[i + 1] = cn;
if (s[i] == '>')
cn++;
else
cn = 0;
}
rc[0] = cn;
ll sn = 0;
rep(i, s.size() + 1) { sn += max(lc[i], rc[i]); }
cout << sn << endl;
return 0;
}
| replace | 24 | 26 | 24 | 26 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const ll inf = 3e18;
const char sp = ' ';
int N, A[100000];
ll res;
string S;
int main() {
cin >> S;
N = S.size() + 1;
for (int i = 0; i < N - 1; i++) {
if (S[i] == '<') {
A[i + 1] = A[i] + 1;
}
}
for (int i = N - 1; i >= 0; i--) {
if (S[i] == '>') {
A[i] = max(A[i], A[i + 1] + 1);
}
}
for (int i = 0; i < N; i++) {
res += A[i];
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll mod = 1000000007;
const ll inf = 3e18;
const char sp = ' ';
int N, A[500000];
ll res;
string S;
int main() {
cin >> S;
N = S.size() + 1;
for (int i = 0; i < N - 1; i++) {
if (S[i] == '<') {
A[i + 1] = A[i] + 1;
}
}
for (int i = N - 1; i >= 0; i--) {
if (S[i] == '>') {
A[i] = max(A[i], A[i + 1] + 1);
}
}
for (int i = 0; i < N; i++) {
res += A[i];
}
cout << res << endl;
} | replace | 7 | 8 | 7 | 8 | 0 | |
p02873 | C++ | Runtime Error | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int a[200010];
int main() {
string s;
cin >> s;
int n = s.size();
rep(i, n) {
if (s[i] == '<')
a[i + 1] = a[i] + 1;
}
for (int i = n; i >= 1; i--) {
if (s[i - 1] == '>')
chmax(a[i - 1], a[i] + 1);
}
ll ans = 0;
rep(i, n + 1) { ans += a[i]; }
cout << ans << endl;
} | #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
template <class T> inline bool chmax(T &a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> inline bool chmin(T &a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(vec) vec.begin(), vec.end()
typedef long long ll;
typedef pair<ll, ll> pll;
typedef pair<int, int> pii;
const ll mod = 1e9 + 7;
const int inf = 1 << 30;
int a[500010];
int main() {
string s;
cin >> s;
int n = s.size();
rep(i, n) {
if (s[i] == '<')
a[i + 1] = a[i] + 1;
}
for (int i = n; i >= 1; i--) {
if (s[i - 1] == '>')
chmax(a[i - 1], a[i] + 1);
}
ll ans = 0;
rep(i, n + 1) { ans += a[i]; }
cout << ans << endl;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p02873 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef pair<int, int> P;
typedef long long ll;
vector<int> dp(100100, -1);
string s;
int n;
int rec(int node) {
if (dp[node] >= 0) {
return dp[node];
} else {
int res = 0;
if (node > 0 && node <= n && s[node - 1] == '<') {
res = max(res, rec(node - 1) + 1);
}
if (node < n && s[node] == '>') {
res = max(res, rec(node + 1) + 1);
}
return dp[node] = res;
}
}
int main() {
cin >> s;
n = s.length();
rep(i, n + 2) { dp[i] = -1; }
rep(i, n + 2) {
if (dp[i] == -1) {
rec(i);
}
}
ll ans = 0;
rep(i, n + 1) { ans += dp[i]; }
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef pair<int, int> P;
typedef long long ll;
vector<int> dp(500100, -1);
string s;
int n;
int rec(int node) {
if (dp[node] >= 0) {
return dp[node];
} else {
int res = 0;
if (node > 0 && node <= n && s[node - 1] == '<') {
res = max(res, rec(node - 1) + 1);
}
if (node < n && s[node] == '>') {
res = max(res, rec(node + 1) + 1);
}
return dp[node] = res;
}
}
int main() {
cin >> s;
n = s.length();
rep(i, n + 2) { dp[i] = -1; }
rep(i, n + 2) {
if (dp[i] == -1) {
rec(i);
}
}
ll ans = 0;
rep(i, n + 1) { ans += dp[i]; }
cout << ans << endl;
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p02873 | C++ | Runtime Error |
#include <bits/stdc++.h>
#define deb(x) cerr << (#x) << " is " << (x) << "\n"
#define ll long long int
#define ld long double
using namespace std;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll powmod(ll a, ll b) {
ll res = 1ll;
while (b) {
if (b % 2 == 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b /= 2;
}
return res;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("D:\\V S Code\\cpp\\competitiveProgramming\\Input.txt", "r", stdin);
freopen("D:\\V S Code\\cpp\\competitiveProgramming\\OPT.txt", "w", stdout);
#endif
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.length();
n++;
ll arr[n + 10];
arr[0] = 0;
ll x = 0;
ll sum = 0;
memset(arr, -1, sizeof(arr));
for (int i = 0; i < n - 1; i++) {
int j;
if (s[i] == '>')
continue;
arr[i] = 0;
for (j = i; j < n - 1 and s[j] == '<'; j++)
arr[j + 1] = arr[j] + 1;
i = j;
}
if (arr[n - 1] == -1)
arr[n - 1] = 0;
for (int i = n - 1; i > 0; i--) {
if (arr[i] == 0) {
for (int j = i - 1; j >= 0 and s[j] == '>'; j--)
arr[j] = max(arr[j], arr[j + 1] + 1);
}
}
sum = 0;
for (int i = 0; i < n; i++)
sum += arr[i];
cout << sum;
} |
#include <bits/stdc++.h>
#define deb(x) cerr << (#x) << " is " << (x) << "\n"
#define ll long long int
#define ld long double
using namespace std;
const ll MOD = 1e9 + 7;
const ll INF = 1e18;
ll powmod(ll a, ll b) {
ll res = 1ll;
while (b) {
if (b % 2 == 1)
res = (res * a) % MOD;
a = (a * a) % MOD;
b /= 2;
}
return res;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
string s;
cin >> s;
int n = s.length();
n++;
ll arr[n + 10];
arr[0] = 0;
ll x = 0;
ll sum = 0;
memset(arr, -1, sizeof(arr));
for (int i = 0; i < n - 1; i++) {
int j;
if (s[i] == '>')
continue;
arr[i] = 0;
for (j = i; j < n - 1 and s[j] == '<'; j++)
arr[j + 1] = arr[j] + 1;
i = j;
}
if (arr[n - 1] == -1)
arr[n - 1] = 0;
for (int i = n - 1; i > 0; i--) {
if (arr[i] == 0) {
for (int j = i - 1; j >= 0 and s[j] == '>'; j--)
arr[j] = max(arr[j], arr[j + 1] + 1);
}
}
sum = 0;
for (int i = 0; i < n; i++)
sum += arr[i];
cout << sum;
} | delete | 21 | 25 | 21 | 21 | 0 | |
p02873 | C++ | Runtime Error | /*
<>>><<><<<< < > > > <
012345678910 11 12 13 14 15
0<1>2>3>4<5<6>7<8<9<10<11<12>13>14>15<16
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string S;
cin >> S;
vector<ll> num(S.size(), 10);
if (S[0] == '<') {
num[0] = 0;
}
if (S[S.size() - 1] == '>') {
num[S.size()] = 0;
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '>' && S[i + 1] == '<') {
num[i + 1] = 0;
}
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '<' && S[i + 1] == '<') {
num[i + 1] = num[i] + 1;
}
}
for (int i = S.size() - 1; i >= 0; i--) {
if (S[i - 1] == '>' && S[i] == '>') {
num[i] = num[i + 1] + 1;
}
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '<' && S[i + 1] == '>') {
num[i + 1] = max(num[i], num[i + 2]) + 1;
}
}
if (S[0] == '>') {
num[0] = num[1] + 1;
}
if (S[S.size() - 1] == '<') {
num[S.size()] = num[S.size() - 1] + 1;
}
ll sum = 0;
for (int i = 0; i < S.size() + 1; i++) {
// cout << num[i] << " ";
sum += num[i];
}
cout << sum << endl;
} | /*
<>>><<><<<< < > > > <
012345678910 11 12 13 14 15
0<1>2>3>4<5<6>7<8<9<10<11<12>13>14>15<16
*/
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
string S;
cin >> S;
vector<int> num(S.size());
if (S[0] == '<') {
num[0] = 0;
}
if (S[S.size() - 1] == '>') {
num[S.size()] = 0;
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '>' && S[i + 1] == '<') {
num[i + 1] = 0;
}
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '<' && S[i + 1] == '<') {
num[i + 1] = num[i] + 1;
}
}
for (int i = S.size() - 1; i >= 0; i--) {
if (S[i - 1] == '>' && S[i] == '>') {
num[i] = num[i + 1] + 1;
}
}
for (int i = 0; i < S.size() - 1; i++) {
if (S[i] == '<' && S[i + 1] == '>') {
num[i + 1] = max(num[i], num[i + 2]) + 1;
}
}
if (S[0] == '>') {
num[0] = num[1] + 1;
}
if (S[S.size() - 1] == '<') {
num[S.size()] = num[S.size() - 1] + 1;
}
ll sum = 0;
for (int i = 0; i < S.size() + 1; i++) {
// cout << num[i] << " ";
sum += num[i];
}
cout << sum << endl;
} | replace | 12 | 13 | 12 | 13 | -6 | Fatal glibc error: malloc assertion failure in sysmalloc: (old_top == initial_top (av) && old_size == 0) || ((unsigned long) (old_size) >= MINSIZE && prev_inuse (old_top) && ((unsigned long) old_end & (pagesize - 1)) == 0)
|
p02874 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define End exit(0)
#define LL long long
#define mp make_pair
#define SZ(x) ((int)x.size())
#define GO cerr << "GO" << endl
#define DE(x) cout << #x << " = " << x << endl
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
void proc_status() {
freopen("/proc/self/status", "r", stdin);
string s;
while (getline(cin, s))
if (s[2] == 'P') {
cerr << s << endl;
return;
}
}
template <typename T> inline T read() {
register T x = 0;
register char c;
register int f(1);
while (!isdigit(c = getchar()))
if (c == '-')
f = -1;
while (x = (x << 1) + (x << 3) + (c ^ 48), isdigit(c = getchar()))
;
return x * f;
}
template <typename T> inline bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T> inline bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const int maxN = 1e5 + 2;
struct Info {
int a, b;
bool operator>(const Info &B) const { return a > B.a; }
} info[maxN + 2];
int n, N;
int L[maxN + 2], R[maxN + 2];
void input() {
n = read<int>();
for (int i = 1; i <= n; ++i)
L[i] = read<int>(), R[i] = read<int>();
}
int solve() {
int p = 1e9, q = 0;
for (int i = 1; i <= n; ++i)
chkmin(p, R[i]);
for (int i = 1; i <= n; ++i)
chkmax(q, L[i]);
for (int i = 1; i <= n; ++i)
info[i].a = max(p - L[i] + 1, 0);
for (int i = 1; i <= n; ++i)
info[i].b = max(R[i] - q + 1, 0);
sort(info + 1, info + 1 + n, greater<Info>());
static int suf[maxN + 2];
suf[n + 1] = 1e9;
for (int i = n; i >= 1; --i)
suf[i] = min(suf[i + 1], info[i].b);
int ans = 0;
for (int i = 1; i <= n; ++i)
chkmax(ans, max(p - q + 1, 0) + R[i] - L[i] + 1);
for (int i = 1; i < n; ++i)
chkmax(ans, suf[i + 1] + info[i].a);
return ans;
}
int main() {
#ifndef ONLINE_JUDGE
freopen("xhc.in", "r", stdin);
freopen("xhc.out", "w", stdout);
#endif
input();
printf("%d\n", solve());
return 0;
}
| #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define End exit(0)
#define LL long long
#define mp make_pair
#define SZ(x) ((int)x.size())
#define GO cerr << "GO" << endl
#define DE(x) cout << #x << " = " << x << endl
#define DEBUG(...) fprintf(stderr, __VA_ARGS__)
void proc_status() {
freopen("/proc/self/status", "r", stdin);
string s;
while (getline(cin, s))
if (s[2] == 'P') {
cerr << s << endl;
return;
}
}
template <typename T> inline T read() {
register T x = 0;
register char c;
register int f(1);
while (!isdigit(c = getchar()))
if (c == '-')
f = -1;
while (x = (x << 1) + (x << 3) + (c ^ 48), isdigit(c = getchar()))
;
return x * f;
}
template <typename T> inline bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
}
template <typename T> inline bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
}
const int maxN = 1e5 + 2;
struct Info {
int a, b;
bool operator>(const Info &B) const { return a > B.a; }
} info[maxN + 2];
int n, N;
int L[maxN + 2], R[maxN + 2];
void input() {
n = read<int>();
for (int i = 1; i <= n; ++i)
L[i] = read<int>(), R[i] = read<int>();
}
int solve() {
int p = 1e9, q = 0;
for (int i = 1; i <= n; ++i)
chkmin(p, R[i]);
for (int i = 1; i <= n; ++i)
chkmax(q, L[i]);
for (int i = 1; i <= n; ++i)
info[i].a = max(p - L[i] + 1, 0);
for (int i = 1; i <= n; ++i)
info[i].b = max(R[i] - q + 1, 0);
sort(info + 1, info + 1 + n, greater<Info>());
static int suf[maxN + 2];
suf[n + 1] = 1e9;
for (int i = n; i >= 1; --i)
suf[i] = min(suf[i + 1], info[i].b);
int ans = 0;
for (int i = 1; i <= n; ++i)
chkmax(ans, max(p - q + 1, 0) + R[i] - L[i] + 1);
for (int i = 1; i < n; ++i)
chkmax(ans, suf[i + 1] + info[i].a);
return ans;
}
int main() {
input();
printf("%d\n", solve());
return 0;
}
| delete | 91 | 95 | 91 | 91 | TLE | |
p02874 | Python | Runtime Error | #!/usr/bin/env python3
n = int(input())
p = sorted(list(map(int, input().split())) for _ in range(n))
lmax = n - 1
rmin = 0
for i in range(n):
if p[i][1] <= p[rmin][1]:
rmin = i
ans = 0
# same(lmax, rmin)
dmax = 0
for i in range(n):
if i == lmax or i == rmin:
continue
if p[i][1] - p[i][0] > p[dmax][1] - p[dmax][0]:
dmax = i
d1 = max(0, p[rmin][1] - p[lmax][0] + 1)
d2 = max(0, p[dmax][1] - p[dmax][0] + 1)
ans = max(ans, d1 + d2)
# !same(lmax, rmin)
m = lmax
for i in range(rmin, lmax)[::-1]:
if p[i + 1][1] < p[m][1]:
m = i + 1
d1 = max(0, p[rmin][1] - p[i][0] + 1)
d2 = max(0, p[m][1] - p[lmax][0] + 1)
ans = max(ans, d1 + d2)
print(ans)
| #!/usr/bin/env python3
n = int(input())
p = sorted(list(map(int, input().split())) for _ in range(n))
lmax = n - 1
rmin = 0
for i in range(n):
if p[i][1] <= p[rmin][1]:
rmin = i
ans = 0
# same(lmax, rmin)
dmax = 0
for i in range(n):
if i == lmax or i == rmin:
continue
if p[i][1] - p[i][0] > p[dmax][1] - p[dmax][0]:
dmax = i
d1 = max(0, p[rmin][1] - p[lmax][0] + 1)
d2 = max(0, p[dmax][1] - p[dmax][0] + 1)
ans = max(ans, d1 + d2)
# !same(lmax, rmin)
m = lmax
for i in range(rmin, lmax)[::-1]:
if p[i + 1][1] < p[m][1]:
m = i + 1
d1 = max(0, p[rmin][1] - p[i][0] + 1)
d2 = max(0, p[m][1] - p[lmax][0] + 1)
ans = max(ans, d1 + d2)
print(ans)
| replace | 19 | 21 | 19 | 21 | 0 | |
p02874 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
constexpr int INF = 1000000000000000000;
constexpr int mod = 1000000007;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int kaijo[2000010];
struct edge {
int to, cost;
};
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
void init_fact() {
kaijo[0] = 1;
for (int i = 1; i <= 2000000; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
}
int modpow(int a, int b) {
if (b == 0)
return 1;
if (b % 2)
return modpow(a, b - 1) * a % mod;
int memo = modpow(a, b / 2);
return memo * memo % mod;
}
int comb(int a, int b) {
if (!kaijo[0])
init_fact();
return kaijo[a] * modpow(kaijo[a - b], mod - 2) % mod *
modpow(kaijo[b], mod - 2) % mod;
}
int inv(int x) {
x = modpow(x, mod - 2);
return x;
}
bool kosa(double ax, double ay, double bx, double by, double cx, double cy,
double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return tc * td < 0 && ta * tb < 0;
}
int n, ans;
P p[100010], R[100010];
struct LmaQ {
int siz = 1;
vector<int> dat;
LmaQ(int n) {
while (siz < n)
siz *= 2;
dat.resize(siz * 2 - 1, 0);
rep(i, n) dat[i + siz - 1] = p[i].first;
for (int i = siz - 2; i >= 0; i--)
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
int query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = siz;
if (a <= l && r <= b)
return dat[k];
if (r <= a || b <= l)
return 0;
int vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
struct RmiQ {
int siz = 1;
vector<int> dat;
RmiQ(int n) {
while (siz < n)
siz *= 2;
dat.resize(siz * 2 - 1, INF);
rep(i, n) dat[i + siz - 1] = p[i].second;
for (int i = siz - 2; i >= 0; i--)
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
int query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = siz;
if (a <= l && r <= b)
return dat[k];
if (r <= a || b <= l)
return INF;
int vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
signed main() {
cin >> n;
rep(i, n) {
cin >> p[i].first >> p[i].second;
p[i].second++;
R[i] = {p[i].second, i};
}
assert(n != 2);
sort(p, p + n);
sort(R, R + n);
rep(i, n) {
int A = p[i].second - p[i].first;
int Lmax = (i == n - 1 ? p[n - 2].first : p[n - 1].first);
int Rmin = (i == R[0].second ? R[1].first : R[0].first);
int B = max(0ll, Rmin - Lmax);
chmax(ans, A + B);
}
LmaQ L(n);
RmiQ R(n);
rep(i, n - 1) {
int A = R.query(0, i + 1) - L.query(0, i + 1);
int B = R.query(i + 1, n) - L.query(i + 1, n);
chmax(A, 0ll);
chmax(B, 0ll);
chmax(ans, A + B);
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define ll long long
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < n; i++)
#define all(v) v.begin(), v.end()
#define pb push_back
template <class T> void chmax(T &a, T b) {
if (a < b)
a = b;
}
template <class T> void chmin(T &a, T b) {
if (a > b)
a = b;
}
constexpr int INF = 1000000000000000000;
constexpr int mod = 1000000007;
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
int kaijo[2000010];
struct edge {
int to, cost;
};
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
bool prime(int a) {
if (a == 1)
return false;
for (int i = 2; i * i <= a; i++) {
if (a % i == 0)
return false;
}
return true;
}
void init_fact() {
kaijo[0] = 1;
for (int i = 1; i <= 2000000; i++) {
kaijo[i] = kaijo[i - 1] * i;
kaijo[i] %= mod;
}
}
int modpow(int a, int b) {
if (b == 0)
return 1;
if (b % 2)
return modpow(a, b - 1) * a % mod;
int memo = modpow(a, b / 2);
return memo * memo % mod;
}
int comb(int a, int b) {
if (!kaijo[0])
init_fact();
return kaijo[a] * modpow(kaijo[a - b], mod - 2) % mod *
modpow(kaijo[b], mod - 2) % mod;
}
int inv(int x) {
x = modpow(x, mod - 2);
return x;
}
bool kosa(double ax, double ay, double bx, double by, double cx, double cy,
double dx, double dy) {
double ta = (cx - dx) * (ay - cy) + (cy - dy) * (cx - ax);
double tb = (cx - dx) * (by - cy) + (cy - dy) * (cx - bx);
double tc = (ax - bx) * (cy - ay) + (ay - by) * (ax - cx);
double td = (ax - bx) * (dy - ay) + (ay - by) * (ax - dx);
return tc * td < 0 && ta * tb < 0;
}
int n, ans;
P p[100010], R[100010];
struct LmaQ {
int siz = 1;
vector<int> dat;
LmaQ(int n) {
while (siz < n)
siz *= 2;
dat.resize(siz * 2 - 1, 0);
rep(i, n) dat[i + siz - 1] = p[i].first;
for (int i = siz - 2; i >= 0; i--)
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
int query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = siz;
if (a <= l && r <= b)
return dat[k];
if (r <= a || b <= l)
return 0;
int vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return max(vl, vr);
}
};
struct RmiQ {
int siz = 1;
vector<int> dat;
RmiQ(int n) {
while (siz < n)
siz *= 2;
dat.resize(siz * 2 - 1, INF);
rep(i, n) dat[i + siz - 1] = p[i].second;
for (int i = siz - 2; i >= 0; i--)
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
int query(int a, int b, int k = 0, int l = 0, int r = -1) {
if (r == -1)
r = siz;
if (a <= l && r <= b)
return dat[k];
if (r <= a || b <= l)
return INF;
int vl = query(a, b, 2 * k + 1, l, (l + r) / 2);
int vr = query(a, b, 2 * k + 2, (l + r) / 2, r);
return min(vl, vr);
}
};
signed main() {
cin >> n;
rep(i, n) {
cin >> p[i].first >> p[i].second;
p[i].second++;
R[i] = {p[i].second, i};
}
if (n == 2) {
int A = max(0ll, p[0].second - p[0].first);
int B = max(0ll, p[1].second - p[1].first);
cout << A + B << endl;
return 0;
}
sort(p, p + n);
sort(R, R + n);
rep(i, n) {
int A = p[i].second - p[i].first;
int Lmax = (i == n - 1 ? p[n - 2].first : p[n - 1].first);
int Rmin = (i == R[0].second ? R[1].first : R[0].first);
int B = max(0ll, Rmin - Lmax);
chmax(ans, A + B);
}
LmaQ L(n);
RmiQ R(n);
rep(i, n - 1) {
int A = R.query(0, i + 1) - L.query(0, i + 1);
int B = R.query(i + 1, n) - L.query(i + 1, n);
chmax(A, 0ll);
chmax(B, 0ll);
chmax(ans, A + B);
}
cout << ans << endl;
return 0;
} | replace | 126 | 127 | 126 | 132 | 0 | |
p02874 | C++ | Time Limit Exceeded | typedef long long ll;
typedef long double ld;
#include <bits/stdc++.h>
using namespace std;
struct aa {
ll l, r;
};
int main() {
ll n;
std::cin >> n;
vector<aa> a(n);
ll maxl = -1;
ll minr = 1e18;
ll maxli;
ll minri;
ll ans = 0;
for (int i = 0; i < n; i++) {
std::cin >> a[i].l >> a[i].r;
a[i].r++;
ans = max(ans, a[i].r - a[i].l);
if (a[i].l > maxl) {
maxl = a[i].l;
maxli = i;
}
if (a[i].r < minr) {
minr = a[i].r;
minri = i;
}
}
ans += max(0ll, minr - maxl);
vector<aa> b(n);
for (int i = 0; i < n; i++) {
b[i].l = max(0ll, minr - a[i].l);
b[i].r = max(0ll, a[i].r - maxl);
}
sort(b.begin(), b.end(), [](auto const &lhs, auto const &rhs) {
if (lhs.l != rhs.l)
return lhs.l < rhs.l;
else if (lhs.r != rhs.r)
return lhs.r > rhs.r;
return true;
});
ll lmin = b[1].l;
ll rmin = b[0].r;
for (int i = 1; i < n; i++) {
rmin = min(rmin, b[i - 1].r);
lmin = b[i].l;
ans = max(ans, lmin + rmin);
}
std::cout << ans << std::endl;
}
| typedef long long ll;
typedef long double ld;
#include <bits/stdc++.h>
using namespace std;
struct aa {
ll l, r;
};
int main() {
ll n;
std::cin >> n;
vector<aa> a(n);
ll maxl = -1;
ll minr = 1e18;
ll maxli;
ll minri;
ll ans = 0;
for (int i = 0; i < n; i++) {
std::cin >> a[i].l >> a[i].r;
a[i].r++;
ans = max(ans, a[i].r - a[i].l);
if (a[i].l > maxl) {
maxl = a[i].l;
maxli = i;
}
if (a[i].r < minr) {
minr = a[i].r;
minri = i;
}
}
ans += max(0ll, minr - maxl);
vector<aa> b(n);
for (int i = 0; i < n; i++) {
b[i].l = max(0ll, minr - a[i].l);
b[i].r = max(0ll, a[i].r - maxl);
}
sort(b.begin(), b.end(), [](auto const &lhs, auto const &rhs) {
if (lhs.l != rhs.l)
return lhs.l < rhs.l;
return lhs.r > rhs.r;
});
ll lmin = b[1].l;
ll rmin = b[0].r;
for (int i = 1; i < n; i++) {
rmin = min(rmin, b[i - 1].r);
lmin = b[i].l;
ans = max(ans, lmin + rmin);
}
std::cout << ans << std::endl;
}
| replace | 43 | 46 | 43 | 44 | TLE | |
p02874 | C++ | Runtime Error | #if __has_include("../library/Basic/Debug.hpp")
#include "../library/Basic/Debug.hpp"
#else
/* ----- Header Files ----- */
// IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>
// container
#include <array>
#include <bitset>
#include <complex>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// others
#include <cassert>
#include <cstdint>
#include <ctime>
#include <functional>
#include <limits>
#include <random>
/* ----- Type Alias ----- */
using lint = long long int;
using ldouble = long double;
template <class T> using MaxHeap = std::priority_queue<T>;
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T> T ndvec(T v) { return v; }
template <class T, class... Ts> auto ndvec(size_t l, Ts... ts) {
return std::vector<decltype(ndvec<T>(ts...))>(l, ndvec<T>(ts...));
}
template <class Cost = int> struct Edge {
int src, dst;
Cost cost;
Edge(int src = -1, int dst = -1, Cost cost = 1)
: src(src), dst(dst), cost(cost){};
bool operator<(const Edge<Cost> &e) const { return this->cost < e.cost; }
bool operator>(const Edge<Cost> &e) const { return this->cost > e.cost; }
};
template <class Cost = int> using Edges = std::vector<Edge<Cost>>;
template <class Cost = int> using Graph = std::vector<std::vector<Edge<Cost>>>;
#endif
/* ----- Misc ----- */
void fastio() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
}
struct Fout {
int precision;
explicit Fout(int precision) : precision(precision) {}
};
std::ostream &operator<<(std::ostream &os, const Fout &fio) {
os << std::fixed << std::setprecision(fio.precision);
return os;
}
/* ----- Constants ----- */
// constexpr int INF = std::numeric_limits<int>::max() / 3;
// constexpr int MOD = 1000000007;
// const Real PI = acos(-1);
// constexpr Real EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));
struct Seg {
int l, r;
int len() { return std::max(0, r - l + 1); }
};
int main() {
int n;
std::cin >> n;
std::vector<Seg> segs(n);
for (auto &s : segs) {
std::cin >> s.l >> s.r;
}
std::sort(segs.begin(), segs.end(), [](const Seg &a, const Seg &b) {
return a.r != b.r ? a.r < b.r : a.l < b.l;
});
// r最小，l最小を持ってくる
auto base = segs.front();
segs.erase(segs.begin());
--n;
std::sort(segs.begin(), segs.end(), [](const Seg &a, const Seg &b) {
return a.l != b.l ? a.l < b.l : a.r < b.r;
});
std::vector<int> back(n);
Seg backs;
backs.l = 0, backs.r = 1e9;
back[0] = backs.len();
for (int i = 1; i <= n; ++i) {
auto seg = segs[n - i];
backs.l = std::max(backs.l, seg.l);
backs.r = std::min(backs.r, seg.r);
back[i] = backs.len();
}
int ans = 0;
Seg fseg = base;
for (int i = 0; i < n; ++i) {
int f = fseg.len();
int b = back[n - i];
ans = std::max(ans, f + b);
fseg.l = std::max(fseg.l, segs[i].l);
fseg.r = std::min(fseg.r, segs[i].r);
}
fseg = base;
fseg.l = std::max(fseg.l, segs.back().l);
fseg.r = std::min(fseg.r, segs.back().r);
for (int i = 0; i < n - 1; ++i) {
auto seg = segs[i];
ans = std::max(ans, seg.len() + fseg.len());
}
std::cout << ans << std::endl;
return 0;
}
| #if __has_include("../library/Basic/Debug.hpp")
#include "../library/Basic/Debug.hpp"
#else
/* ----- Header Files ----- */
// IO
#include <cstdio>
#include <iomanip>
#include <ios>
#include <iostream>
// algorithm
#include <algorithm>
#include <cmath>
#include <numeric>
// container
#include <array>
#include <bitset>
#include <complex>
#include <deque>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// others
#include <cassert>
#include <cstdint>
#include <ctime>
#include <functional>
#include <limits>
#include <random>
/* ----- Type Alias ----- */
using lint = long long int;
using ldouble = long double;
template <class T> using MaxHeap = std::priority_queue<T>;
template <class T>
using MinHeap = std::priority_queue<T, std::vector<T>, std::greater<T>>;
template <class T> T ndvec(T v) { return v; }
template <class T, class... Ts> auto ndvec(size_t l, Ts... ts) {
return std::vector<decltype(ndvec<T>(ts...))>(l, ndvec<T>(ts...));
}
template <class Cost = int> struct Edge {
int src, dst;
Cost cost;
Edge(int src = -1, int dst = -1, Cost cost = 1)
: src(src), dst(dst), cost(cost){};
bool operator<(const Edge<Cost> &e) const { return this->cost < e.cost; }
bool operator>(const Edge<Cost> &e) const { return this->cost > e.cost; }
};
template <class Cost = int> using Edges = std::vector<Edge<Cost>>;
template <class Cost = int> using Graph = std::vector<std::vector<Edge<Cost>>>;
#endif
/* ----- Misc ----- */
void fastio() {
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
}
struct Fout {
int precision;
explicit Fout(int precision) : precision(precision) {}
};
std::ostream &operator<<(std::ostream &os, const Fout &fio) {
os << std::fixed << std::setprecision(fio.precision);
return os;
}
/* ----- Constants ----- */
// constexpr int INF = std::numeric_limits<int>::max() / 3;
// constexpr int MOD = 1000000007;
// const Real PI = acos(-1);
// constexpr Real EPS = 1e-10;
// std::mt19937 mt(int(std::time(nullptr)));
struct Seg {
int l, r;
int len() { return std::max(0, r - l + 1); }
};
int main() {
int n;
std::cin >> n;
std::vector<Seg> segs(n);
for (auto &s : segs) {
std::cin >> s.l >> s.r;
}
std::sort(segs.begin(), segs.end(), [](const Seg &a, const Seg &b) {
return a.r != b.r ? a.r < b.r : a.l < b.l;
});
// r最小，l最小を持ってくる
auto base = segs.front();
segs.erase(segs.begin());
--n;
std::sort(segs.begin(), segs.end(), [](const Seg &a, const Seg &b) {
return a.l != b.l ? a.l < b.l : a.r < b.r;
});
std::vector<int> back(n + 1);
Seg backs;
backs.l = 0, backs.r = 1e9;
back[0] = backs.len();
for (int i = 1; i <= n; ++i) {
auto seg = segs[n - i];
backs.l = std::max(backs.l, seg.l);
backs.r = std::min(backs.r, seg.r);
back[i] = backs.len();
}
int ans = 0;
Seg fseg = base;
for (int i = 0; i < n; ++i) {
int f = fseg.len();
int b = back[n - i];
ans = std::max(ans, f + b);
fseg.l = std::max(fseg.l, segs[i].l);
fseg.r = std::min(fseg.r, segs[i].r);
}
fseg = base;
fseg.l = std::max(fseg.l, segs.back().l);
fseg.r = std::min(fseg.r, segs.back().r);
for (int i = 0; i < n - 1; ++i) {
auto seg = segs[i];
ans = std::max(ans, seg.len() + fseg.len());
}
std::cout << ans << std::endl;
return 0;
}
| replace | 116 | 117 | 116 | 117 | 0 | |
p02874 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int mod = 1e9 + 7;
const int MAX = 510000;
const int V = 100005;
ll dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
ll dx[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
struct lr {
ll l;
ll r;
bool operator<(const lr &t) const { return l == t.l ? r < t.r : l > t.l; }
};
int main() {
ll n;
cin >> n;
vector<struct lr> v(n);
ll ans = 0;
rep(i, n) {
cin >> v[i].l >> v[i].r;
ans = max(v[i].r - v[i].l + 1, ans);
}
sort(all(v));
multiset<ll> fil, fir, sel, ser;
rep(i, n) {
sel.insert(v[i].l);
ser.insert(v[i].r);
}
rep(i, n - 1) {
auto itrl = sel.find(v[i].l);
auto itrr = ser.find(v[i].r);
fil.insert(v[i].l);
fir.insert(v[i].r);
sel.erase(itrl);
ser.erase(itrr);
auto itr = --fil.end();
auto itr2 = --sel.end();
ans = max(ans, *fir.begin() - *itr + 1 + *ser.begin() - *itr2 + 1);
// cout << *fir.begin() << " " << *ser.begin() << endl;
}
for (ll i = n - 2; i >= 1; i--) {
auto itrl = fil.find(v[i].l);
auto itrr = fir.find(v[i].r);
fil.insert(v[i + 1].l);
fir.insert(v[i + 1].r);
sel.erase(itrl);
ser.erase(itrr);
auto itr = --fil.end();
ans = max(ans, *fir.begin() - *itr + 1 + v[i].r - v[i].l + 1);
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef pair<ll, ll> P;
typedef vector<P> vpl;
#define rep(i, n) for (ll i = 0; i < (n); i++)
#define REP(i, a, b) for (ll i = (a); i < (b); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
const int inf = 1 << 30;
const ll linf = 1LL << 62;
const int mod = 1e9 + 7;
const int MAX = 510000;
const int V = 100005;
ll dy[8] = {1, 0, -1, 0, 1, -1, 1, -1};
ll dx[8] = {0, 1, 0, -1, 1, -1, -1, 1};
const double pi = acos(-1);
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
template <typename T1, typename T2> inline void print2(T1 a, T2 b) {
cout << a << " " << b << endl;
}
struct lr {
ll l;
ll r;
bool operator<(const lr &t) const { return l == t.l ? r < t.r : l > t.l; }
};
int main() {
ll n;
cin >> n;
vector<struct lr> v(n);
ll ans = 0;
rep(i, n) {
cin >> v[i].l >> v[i].r;
ans = max(v[i].r - v[i].l + 1, ans);
}
sort(all(v));
multiset<ll> fil, fir, sel, ser;
rep(i, n) {
sel.insert(v[i].l);
ser.insert(v[i].r);
}
rep(i, n - 1) {
auto itrl = sel.find(v[i].l);
auto itrr = ser.find(v[i].r);
fil.insert(v[i].l);
fir.insert(v[i].r);
sel.erase(itrl);
ser.erase(itrr);
auto itr = --fil.end();
auto itr2 = --sel.end();
ans = max(ans, *fir.begin() - *itr + 1 + *ser.begin() - *itr2 + 1);
// cout << *fir.begin() << " " << *ser.begin() << endl;
}
for (ll i = n - 2; i >= 1; i--) {
auto itrl = fil.find(v[i].l);
auto itrr = fir.find(v[i].r);
fil.insert(v[i + 1].l);
fir.insert(v[i + 1].r);
fil.erase(itrl);
fir.erase(itrr);
auto itr = --fil.end();
ans = max(ans, *fir.begin() - *itr + 1 + v[i].r - v[i].l + 1);
}
cout << ans << endl;
} | replace | 79 | 81 | 79 | 81 | -6 | free(): double free detected in tcache 2
|
p02874 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<ll, P> Q;
typedef complex<double> C;
#define cx real()
#define cy imag()
const ll INF = 1LL << 60;
const double DINF = 1e30;
const ll mod = 1000000007;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, -1, 0, 1};
const C I = C(0, 1);
const double EPS = 1e-10;
const ll NCK_MAX = 510000;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll extgcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
ll q = a / b, g = extgcd(b, a - q * b, x, y);
ll z = x - q * y;
x = y;
y = z;
return g;
}
ll invmod(ll a, ll m) { // a^-1 mod m
ll x, y;
extgcd(a, m, x, y);
x %= m;
if (x < 0)
x += m;
return x;
}
ll *fac, *finv, *inv;
void nCk_init(ll mod) {
fac = new ll[NCK_MAX];
finv = new ll[NCK_MAX];
inv = new ll[NCK_MAX];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < NCK_MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll nCk(ll n, ll k, ll mod) {
if (fac == NULL)
nCk_init(mod);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
template <typename T> class Zip {
vector<T> d;
bool flag;
void init() {
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
flag = false;
}
public:
Zip() { flag = false; }
void add(T x) {
d.push_back(x);
flag = true;
}
ll getNum(T x) {
if (flag)
init();
return lower_bound(d.begin(), d.end(), x) - d.begin();
}
ll size() {
if (flag)
init();
return (ll)d.size();
}
};
class UnionFind {
vector<ll> par, rank; // par > 0: number, par < 0: -par
public:
UnionFind(ll n) : par(n, 1), rank(n, 0) {}
ll getSize(ll x) { return par[find(x)]; }
ll find(ll x) {
if (par[x] > 0)
return x;
return -(par[x] = -find(-par[x]));
}
void merge(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = -y;
} else {
par[x] += par[y];
par[y] = -x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool isSame(ll x, ll y) { return find(x) == find(y); }
};
template <typename T> class SegmentTree {
ll n;
vector<T> node;
function<T(T, T)> fun, fun2;
bool customChange;
T outValue, initValue;
public:
void init(ll num, function<T(T, T)> resultFunction, T init, T out,
function<T(T, T)> changeFunction = NULL) {
// changeFunction: (input, beforevalue) => newvalue
fun = resultFunction;
fun2 = changeFunction;
customChange = changeFunction != NULL;
n = 1;
while (n < num)
n *= 2;
node.resize(2 * n - 1);
fill(node.begin(), node.end(), init);
outValue = out;
initValue = init;
}
void valueChange(ll num, T value) {
num += n - 1;
if (customChange)
node[num] = fun2(value, node[num]);
else
node[num] = value;
while (num > 0)
num = (num - 1) / 2,
node[num] = fun(node[num * 2 + 1], node[num * 2 + 2]);
}
T rangeQuery(ll a, ll b, ll l = 0, ll r = -1, ll k = 0) { // [a, b)
if (r == -1)
r = n;
if (a <= l && r <= b)
return node[k];
if (b <= l || r <= a)
return outValue;
ll mid = (l + r) / 2;
return fun(rangeQuery(a, b, l, mid, 2 * k + 1),
rangeQuery(a, b, mid, r, 2 * k + 2));
}
};
template <typename T> class Graph {
struct edge {
ll to;
T cost;
};
struct edge_data {
ll from, to;
T cost;
};
ll v;
vector<vector<edge>> e, re;
vector<edge_data> ed;
vector<bool> used;
vector<ll> vs, cmp;
bool isDirected, isMinasEdge;
public:
Graph(ll _v, bool _isDirected = true, ll range_add = 0) {
// range_add 0:no / 1:in / 2:out / 3:in+out
//_v++;
v = _v, isDirected = _isDirected;
isMinasEdge = false;
e.resize(v), re.resize(v);
}
void add_edge(ll s, ll t, T cost = 1) {
e[s].push_back((edge){t, cost});
if (!isDirected)
e[t].push_back((edge){s, cost});
else
re[t].push_back((edge){s, cost});
ed.push_back((edge_data){s, t, cost});
if (cost < 0)
isMinasEdge = true;
}
vector<T> dijkstra(ll s) {
vector<T> d(v, INF);
d[s] = 0;
auto edge_cmp = [](const edge &a, const edge &b) {
return a.cost > b.cost;
};
priority_queue<edge, vector<edge>, decltype(edge_cmp)> pq(edge_cmp);
pq.push((edge){s, 0});
while (!pq.empty()) {
edge temp = pq.top();
pq.pop();
if (d[temp.to] < temp.cost)
continue;
for (const edge &next : e[temp.to]) {
T cost = temp.cost + next.cost;
if (d[next.to] > cost) {
d[next.to] = cost;
pq.push((edge){next.to, cost});
}
}
}
return d;
}
vector<T> bellmanford(ll s) {
vector<T> d(v, INF);
d[s] = 0;
for (ll i = 0; i < v; i++) {
for (const edge_data &temp : ed) {
if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
d[temp.to] = d[temp.from] + temp.cost;
if (!isDirected && d[temp.to] != INF &&
d[temp.from] > d[temp.to] + temp.cost)
d[temp.from] = d[temp.to] + temp.cost;
}
}
for (ll i = 0; i < v; i++) {
for (const edge_data &temp : ed) {
if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
d[temp.to] = -INF;
if (!isDirected && d[temp.to] != INF &&
d[temp.from] > d[temp.to] + temp.cost)
d[temp.from] = -INF;
}
}
return d;
}
vector<T> shortest_path(ll s) {
if (isMinasEdge)
return bellmanford(s);
else
return dijkstra(s);
}
T kruskal() {
// if (isDirected)
UnionFind uf(v);
auto edge_data_cmp = [](const edge_data &a, const edge_data &b) {
return a.cost < b.cost;
};
sort(ed.begin(), ed.end(), edge_data_cmp);
T ans = 0;
for (const edge_data &temp : ed) {
if (uf.isSame(temp.from, temp.to))
continue;
uf.merge(temp.from, temp.to);
ans += temp.cost;
}
return ans;
}
void scc_dfs(ll s) {
used[s] = true;
for (const edge &i : e[s])
if (!used[i.to])
scc_dfs(i.to);
vs.push_back(s);
}
void scc_rdfs(ll s, ll k) {
used[s] = true;
cmp[s] = k;
for (const edge &i : re[s])
if (!used[i.to])
scc_rdfs(i.to, k);
}
vector<ll> scc() {
used.resize(v);
fill(used.begin(), used.end(), false);
cmp.resize(v);
vs.clear();
for (ll i = 0; i < v; i++)
if (!used[i])
scc_dfs(i);
used.resize(v);
fill(used.begin(), used.end(), false);
ll k = 0;
for (ll i = vs.size() - 1; i >= 0; i--)
if (!used[vs[i]])
scc_rdfs(vs[i], k++);
return cmp;
}
};
ll n, l, r, ans;
P p[100000];
set<ll> otherL, otherR;
int main() {
scanf("%lld", &n);
for (ll i = 0; i < n; i++)
scanf("%lld%lld", &l, &r), p[i] = P(l, r), otherL.insert(l),
otherR.insert(r);
for (ll i = 0; i < n; i++) {
otherL.erase(otherL.lower_bound(p[i].first)),
otherR.erase(otherR.lower_bound(p[i].second));
ll temp = p[i].second - p[i].first + 1;
auto l2 = otherL.end(), r2 = otherR.begin();
l2--;
l = *l2, r = *r2;
if (l <= r)
temp += r - l + 1;
ans = max(ans, temp);
otherL.insert(p[i].first), otherR.insert(p[i].second);
}
sort(p, p + n);
ll mn = INF;
for (ll i = 0; i < n - 1; i++) {
mn = min(mn, p[i].second);
if (mn < p[i].first)
break;
otherL.erase(otherL.lower_bound(p[i].first)),
otherR.erase(otherR.lower_bound(p[i].second));
ll temp = mn - p[i].first + 1;
auto l2 = otherL.end(), r2 = otherR.begin();
l2--;
l = *l2, r = *r2;
// printf("%lld / %lld - %lld\n", temp, l, r);
if (l <= r)
temp += r - l + 1;
ans = max(ans, temp);
}
printf("%lld\n", ans);
}
| #include <algorithm>
#include <bitset>
#include <cassert>
#include <complex>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<ll, P> Q;
typedef complex<double> C;
#define cx real()
#define cy imag()
const ll INF = 1LL << 60;
const double DINF = 1e30;
const ll mod = 1000000007;
const ll dx[4] = {1, 0, -1, 0};
const ll dy[4] = {0, -1, 0, 1};
const C I = C(0, 1);
const double EPS = 1e-10;
const ll NCK_MAX = 510000;
ll gcd(ll a, ll b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
ll extgcd(ll a, ll b, ll &x, ll &y) {
if (b == 0) {
x = 1, y = 0;
return a;
}
ll q = a / b, g = extgcd(b, a - q * b, x, y);
ll z = x - q * y;
x = y;
y = z;
return g;
}
ll invmod(ll a, ll m) { // a^-1 mod m
ll x, y;
extgcd(a, m, x, y);
x %= m;
if (x < 0)
x += m;
return x;
}
ll *fac, *finv, *inv;
void nCk_init(ll mod) {
fac = new ll[NCK_MAX];
finv = new ll[NCK_MAX];
inv = new ll[NCK_MAX];
fac[0] = fac[1] = 1;
finv[0] = finv[1] = 1;
inv[1] = 1;
for (ll i = 2; i < NCK_MAX; i++) {
fac[i] = fac[i - 1] * i % mod;
inv[i] = mod - inv[mod % i] * (mod / i) % mod;
finv[i] = finv[i - 1] * inv[i] % mod;
}
}
ll nCk(ll n, ll k, ll mod) {
if (fac == NULL)
nCk_init(mod);
if (n < k)
return 0;
if (n < 0 || k < 0)
return 0;
return fac[n] * (finv[k] * finv[n - k] % mod) % mod;
}
template <typename T> class Zip {
vector<T> d;
bool flag;
void init() {
sort(d.begin(), d.end());
d.erase(unique(d.begin(), d.end()), d.end());
flag = false;
}
public:
Zip() { flag = false; }
void add(T x) {
d.push_back(x);
flag = true;
}
ll getNum(T x) {
if (flag)
init();
return lower_bound(d.begin(), d.end(), x) - d.begin();
}
ll size() {
if (flag)
init();
return (ll)d.size();
}
};
class UnionFind {
vector<ll> par, rank; // par > 0: number, par < 0: -par
public:
UnionFind(ll n) : par(n, 1), rank(n, 0) {}
ll getSize(ll x) { return par[find(x)]; }
ll find(ll x) {
if (par[x] > 0)
return x;
return -(par[x] = -find(-par[x]));
}
void merge(ll x, ll y) {
x = find(x);
y = find(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[y] += par[x];
par[x] = -y;
} else {
par[x] += par[y];
par[y] = -x;
if (rank[x] == rank[y])
rank[x]++;
}
}
bool isSame(ll x, ll y) { return find(x) == find(y); }
};
template <typename T> class SegmentTree {
ll n;
vector<T> node;
function<T(T, T)> fun, fun2;
bool customChange;
T outValue, initValue;
public:
void init(ll num, function<T(T, T)> resultFunction, T init, T out,
function<T(T, T)> changeFunction = NULL) {
// changeFunction: (input, beforevalue) => newvalue
fun = resultFunction;
fun2 = changeFunction;
customChange = changeFunction != NULL;
n = 1;
while (n < num)
n *= 2;
node.resize(2 * n - 1);
fill(node.begin(), node.end(), init);
outValue = out;
initValue = init;
}
void valueChange(ll num, T value) {
num += n - 1;
if (customChange)
node[num] = fun2(value, node[num]);
else
node[num] = value;
while (num > 0)
num = (num - 1) / 2,
node[num] = fun(node[num * 2 + 1], node[num * 2 + 2]);
}
T rangeQuery(ll a, ll b, ll l = 0, ll r = -1, ll k = 0) { // [a, b)
if (r == -1)
r = n;
if (a <= l && r <= b)
return node[k];
if (b <= l || r <= a)
return outValue;
ll mid = (l + r) / 2;
return fun(rangeQuery(a, b, l, mid, 2 * k + 1),
rangeQuery(a, b, mid, r, 2 * k + 2));
}
};
template <typename T> class Graph {
struct edge {
ll to;
T cost;
};
struct edge_data {
ll from, to;
T cost;
};
ll v;
vector<vector<edge>> e, re;
vector<edge_data> ed;
vector<bool> used;
vector<ll> vs, cmp;
bool isDirected, isMinasEdge;
public:
Graph(ll _v, bool _isDirected = true, ll range_add = 0) {
// range_add 0:no / 1:in / 2:out / 3:in+out
//_v++;
v = _v, isDirected = _isDirected;
isMinasEdge = false;
e.resize(v), re.resize(v);
}
void add_edge(ll s, ll t, T cost = 1) {
e[s].push_back((edge){t, cost});
if (!isDirected)
e[t].push_back((edge){s, cost});
else
re[t].push_back((edge){s, cost});
ed.push_back((edge_data){s, t, cost});
if (cost < 0)
isMinasEdge = true;
}
vector<T> dijkstra(ll s) {
vector<T> d(v, INF);
d[s] = 0;
auto edge_cmp = [](const edge &a, const edge &b) {
return a.cost > b.cost;
};
priority_queue<edge, vector<edge>, decltype(edge_cmp)> pq(edge_cmp);
pq.push((edge){s, 0});
while (!pq.empty()) {
edge temp = pq.top();
pq.pop();
if (d[temp.to] < temp.cost)
continue;
for (const edge &next : e[temp.to]) {
T cost = temp.cost + next.cost;
if (d[next.to] > cost) {
d[next.to] = cost;
pq.push((edge){next.to, cost});
}
}
}
return d;
}
vector<T> bellmanford(ll s) {
vector<T> d(v, INF);
d[s] = 0;
for (ll i = 0; i < v; i++) {
for (const edge_data &temp : ed) {
if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
d[temp.to] = d[temp.from] + temp.cost;
if (!isDirected && d[temp.to] != INF &&
d[temp.from] > d[temp.to] + temp.cost)
d[temp.from] = d[temp.to] + temp.cost;
}
}
for (ll i = 0; i < v; i++) {
for (const edge_data &temp : ed) {
if (d[temp.from] != INF && d[temp.to] > d[temp.from] + temp.cost)
d[temp.to] = -INF;
if (!isDirected && d[temp.to] != INF &&
d[temp.from] > d[temp.to] + temp.cost)
d[temp.from] = -INF;
}
}
return d;
}
vector<T> shortest_path(ll s) {
if (isMinasEdge)
return bellmanford(s);
else
return dijkstra(s);
}
T kruskal() {
// if (isDirected)
UnionFind uf(v);
auto edge_data_cmp = [](const edge_data &a, const edge_data &b) {
return a.cost < b.cost;
};
sort(ed.begin(), ed.end(), edge_data_cmp);
T ans = 0;
for (const edge_data &temp : ed) {
if (uf.isSame(temp.from, temp.to))
continue;
uf.merge(temp.from, temp.to);
ans += temp.cost;
}
return ans;
}
void scc_dfs(ll s) {
used[s] = true;
for (const edge &i : e[s])
if (!used[i.to])
scc_dfs(i.to);
vs.push_back(s);
}
void scc_rdfs(ll s, ll k) {
used[s] = true;
cmp[s] = k;
for (const edge &i : re[s])
if (!used[i.to])
scc_rdfs(i.to, k);
}
vector<ll> scc() {
used.resize(v);
fill(used.begin(), used.end(), false);
cmp.resize(v);
vs.clear();
for (ll i = 0; i < v; i++)
if (!used[i])
scc_dfs(i);
used.resize(v);
fill(used.begin(), used.end(), false);
ll k = 0;
for (ll i = vs.size() - 1; i >= 0; i--)
if (!used[vs[i]])
scc_rdfs(vs[i], k++);
return cmp;
}
};
ll n, l, r, ans;
P p[100000];
multiset<ll> otherL, otherR;
int main() {
scanf("%lld", &n);
for (ll i = 0; i < n; i++)
scanf("%lld%lld", &l, &r), p[i] = P(l, r), otherL.insert(l),
otherR.insert(r);
for (ll i = 0; i < n; i++) {
otherL.erase(otherL.lower_bound(p[i].first)),
otherR.erase(otherR.lower_bound(p[i].second));
ll temp = p[i].second - p[i].first + 1;
auto l2 = otherL.end(), r2 = otherR.begin();
l2--;
l = *l2, r = *r2;
if (l <= r)
temp += r - l + 1;
ans = max(ans, temp);
otherL.insert(p[i].first), otherR.insert(p[i].second);
}
sort(p, p + n);
ll mn = INF;
for (ll i = 0; i < n - 1; i++) {
mn = min(mn, p[i].second);
if (mn < p[i].first)
break;
otherL.erase(otherL.lower_bound(p[i].first)),
otherR.erase(otherR.lower_bound(p[i].second));
ll temp = mn - p[i].first + 1;
auto l2 = otherL.end(), r2 = otherR.begin();
l2--;
l = *l2, r = *r2;
// printf("%lld / %lld - %lld\n", temp, l, r);
if (l <= r)
temp += r - l + 1;
ans = max(ans, temp);
}
printf("%lld\n", ans);
}
| replace | 322 | 323 | 322 | 323 | 0 | |
p02874 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 1000000007;
signed main() {
int n;
cin >> n;
pair<int, int> p[n], q[n];
int l, r;
pair<int, pair<int, int>> t[n];
for (int i = 0; i < n; i++) {
cin >> l >> r;
p[i] = make_pair(r, l);
q[i] = make_pair(l, r);
t[i] = make_pair(r - l, make_pair(l, r));
}
sort(p, p + n);
sort(q, q + n);
sort(t, t + n);
int mxl = q[n - 1].first, mxr = q[n - 1].second, mil = p[0].second;
int ans1 = p[1].first - mil;
for (int i = 0; p[i].first < mxr; i++) {
mil = max(mil, p[i].second);
ans1 = max(ans1, p[i + 1].first - mil);
cerr << ans1 << endl;
}
int ans2, x = 0, y = 0;
vector<int> tt;
for (int i = 0; i < n; i++) {
if (x == 0 && mxl == t[i].second.first) {
x = 1;
continue;
}
if (y == 0 && p[0].first == t[i].second.second) {
y = 1;
continue;
}
tt.push_back(t[i].first);
}
// cerr<<ans1<<' '<<ans1+1-q[n-1].first+p[0].first+1<<'
// '<<tt[tt.size()-1]+1+max(0LL,p[0].first-mxl+1)<<' '<<t[n-1].first+1<<endl;
cout << max(ans1 + 1 - q[n - 1].first + p[0].first + 1,
max(tt[tt.size() - 1] + 1 + max(0LL, p[0].first - mxl + 1),
t[n - 1].first + 1));
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
const int MOD = 1000000007;
signed main() {
int n;
cin >> n;
pair<int, int> p[n], q[n];
int l, r;
pair<int, pair<int, int>> t[n];
for (int i = 0; i < n; i++) {
cin >> l >> r;
p[i] = make_pair(r, l);
q[i] = make_pair(l, r);
t[i] = make_pair(r - l, make_pair(l, r));
}
sort(p, p + n);
sort(q, q + n);
sort(t, t + n);
int mxl = q[n - 1].first, mxr = q[n - 1].second, mil = p[0].second;
int ans1 = p[1].first - mil;
for (int i = 0; p[i].first < mxr; i++) {
mil = max(mil, p[i].second);
ans1 = max(ans1, p[i + 1].first - mil);
cerr << ans1 << endl;
}
int ans2, x = 0, y = 0;
vector<int> tt;
for (int i = 0; i < n; i++) {
if (x == 0 && mxl == t[i].second.first) {
x = 1;
continue;
}
if (y == 0 && p[0].first == t[i].second.second) {
y = 1;
continue;
}
tt.push_back(t[i].first);
}
// cerr<<ans1<<' '<<ans1+1-q[n-1].first+p[0].first+1<<'
// '<<tt[tt.size()-1]+1+max(0LL,p[0].first-mxl+1)<<' '<<t[n-1].first+1<<endl;
if (tt.size() == 0) {
cout << max(ans1 + 1 - q[n - 1].first + p[0].first + 1, t[n - 1].first + 1);
return 0;
}
cout << max(ans1 + 1 - q[n - 1].first + p[0].first + 1,
max(tt[tt.size() - 1] + 1 + max(0LL, p[0].first - mxl + 1),
t[n - 1].first + 1));
return 0;
}
| replace | 42 | 43 | 42 | 46 | 0 | 4
5
5
|
p02874 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
const long long MOD = 1000000007LL;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
struct segment_tree {
const long INF = 2 * 1e9;
long n = 1;
long data[100013];
segment_tree(int a) {
while (n < a)
n *= 2;
for (int i = 0; i < 2 * n; i++)
data[i] = INF;
}
// segment treeの大きさ取得
long nreturn() { return n; }
// 0-indexでk番目の値をaに変更
void change(long k, long a) {
k += n - 1;
data[k] = a;
while (k > 0) {
k = (k - 1) / 2;
data[k] = min(data[2 * k + 1], data[2 * k + 2]);
// cout << "data" << k << "is changed to" << data[k] << endl;
}
return;
}
// 区間[a,b)の最小値:呼ぶときはrmq(a,b,0,0,n)
long rmq(long a, long b, long k, long l, long r) {
if (a >= r || b <= l)
return INF;
if (a <= l && b >= r)
return data[k];
long teml = rmq(a, b, 2 * k + 1, l, (l + r) / 2);
long temr = rmq(a, b, 2 * k + 2, (l + r) / 2, r);
return min(teml, temr);
}
};
int main() {
int n;
cin >> n;
pair<long, long> lr[n];
rep(i, n) cin >> lr[i].first >> lr[i].second;
sort(lr, lr + n);
segment_tree tree(n);
rep(i, n) tree.change(i, lr[i].second);
long ans = 0;
long nn = tree.nreturn();
for (int i = 0; i < n - 1; i++) {
long tmp =
max(long(0), long(1) + tree.rmq(0, i + 1, 0, 0, nn) - lr[i].first);
tmp +=
max(long(0), long(1) + tree.rmq(i + 1, nn, 0, 0, nn) - lr[n - 1].first);
ans = max(ans, tmp);
tmp = 0;
tmp += (lr[i].second - lr[i].first) + 1;
tmp += max(long(0), long(1) +
min(tree.rmq(0, i, 0, 0, nn),
tree.rmq(i + 1, nn, 0, 0, nn)) -
lr[n - 1].first);
ans = max(ans, tmp);
}
cout << ans << endl;
/*segment_tree tree(7);
for(int i = 0;i<7;i++) tree.change(i,i);
for(int i = 0;i<15;i++) cout << tree.data[i] << " " ;
cout << tree.rmq(1,2,0,0,7);*/
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
const long long MOD = 1000000007LL;
const string alpha = "abcdefghijklmnopqrstuvwxyz";
struct segment_tree {
const long INF = 2 * 1e9;
long n = 1;
long data[300013];
segment_tree(int a) {
while (n < a)
n *= 2;
for (int i = 0; i < 2 * n; i++)
data[i] = INF;
}
// segment treeの大きさ取得
long nreturn() { return n; }
// 0-indexでk番目の値をaに変更
void change(long k, long a) {
k += n - 1;
data[k] = a;
while (k > 0) {
k = (k - 1) / 2;
data[k] = min(data[2 * k + 1], data[2 * k + 2]);
// cout << "data" << k << "is changed to" << data[k] << endl;
}
return;
}
// 区間[a,b)の最小値:呼ぶときはrmq(a,b,0,0,n)
long rmq(long a, long b, long k, long l, long r) {
if (a >= r || b <= l)
return INF;
if (a <= l && b >= r)
return data[k];
long teml = rmq(a, b, 2 * k + 1, l, (l + r) / 2);
long temr = rmq(a, b, 2 * k + 2, (l + r) / 2, r);
return min(teml, temr);
}
};
int main() {
int n;
cin >> n;
pair<long, long> lr[n];
rep(i, n) cin >> lr[i].first >> lr[i].second;
sort(lr, lr + n);
segment_tree tree(n);
rep(i, n) tree.change(i, lr[i].second);
long ans = 0;
long nn = tree.nreturn();
for (int i = 0; i < n - 1; i++) {
long tmp =
max(long(0), long(1) + tree.rmq(0, i + 1, 0, 0, nn) - lr[i].first);
tmp +=
max(long(0), long(1) + tree.rmq(i + 1, nn, 0, 0, nn) - lr[n - 1].first);
ans = max(ans, tmp);
tmp = 0;
tmp += (lr[i].second - lr[i].first) + 1;
tmp += max(long(0), long(1) +
min(tree.rmq(0, i, 0, 0, nn),
tree.rmq(i + 1, nn, 0, 0, nn)) -
lr[n - 1].first);
ans = max(ans, tmp);
}
cout << ans << endl;
/*segment_tree tree(7);
for(int i = 0;i<7;i++) tree.change(i,i);
for(int i = 0;i<15;i++) cout << tree.data[i] << " " ;
cout << tree.rmq(1,2,0,0,7);*/
} | replace | 16 | 17 | 16 | 17 | 0 | |
p02874 | C++ | Time Limit Exceeded | #define y1 askjdkasldjlkasd
#include <bits/stdc++.h>
#undef y1
using namespace std;
#define pb push_back
#define mp make_pair
#define fi(a, b) for (int i = a; i <= b; i++)
#define fj(a, b) for (int j = a; j <= b; j++)
#define fo(a, b) for (int o = a; o <= b; o++)
#define fdi(a, b) for (int i = a; i >= b; i--)
#define fdj(a, b) for (int j = a; j >= b; j--)
#define fdo(a, b) for (int o = a; o >= b; o--)
#define sz(x) (int)x.size()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
#ifdef LOCAL
#define err(...) fprintf(stderr, __VA_ARGS__)
#else
#define err(...) while (0)
#endif
double START_TIME;
void exit() {
#ifdef LOCAL
cerr << "TIME: " << setprecision(5) << fixed
<< (clock() - START_TIME) / CLOCKS_PER_SEC << endl;
#endif
exit(0);
}
template <typename A, typename B>
ostream &operator<<(ostream &os, pair<A, B> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
fi(0, sz(v) - 1) { os << v[i] << " "; }
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> t) {
for (auto z : t) {
os << z << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, map<T1, T2> t) {
cerr << endl;
for (auto z : t) {
os << "\t" << z.first << " -> " << z.second << endl;
}
return os;
}
#ifdef LOCAL
#define dbg(x) \
{ cerr << __LINE__ << "\t" << #x << ": " << x << endl; }
#define dbg0(x, n) \
{ \
cerr << __LINE__ << "\t" << #x << ": "; \
for (int ABC = 0; ABC < n; ABC++) \
cerr << x[ABC] << ' '; \
cerr << endl; \
}
#else
#define dbg(x) \
while (0) { \
}
#define dbg0(x, n) \
while (0) { \
}
#endif
#ifdef LOCAL
#define ass(x) \
if (!(x)) { \
cerr << __LINE__ << "\tassertion failed: " << #x << endl, abort(); \
}
#else
#define ass(x) assert(x)
#endif
///////////////////////////////////////////////////
const int MAX = 1e5 + 41;
const int INF = 1e9 + 41;
int n;
int a[MAX];
int b[MAX];
int ans;
int f(int l, int r) { return max(0, r - l + 1); }
int calc1() {
multiset<int> l, r;
fi(0, n - 1) {
l.insert(a[i]);
r.insert(b[i]);
}
int res = 0;
fi(0, n - 1) {
l.erase(l.find(a[i]));
r.erase(r.find(b[i]));
int v1 = b[i] - a[i] + 1;
int v2 = max(0, (*r.begin()) - (*l.rbegin()) + 1);
res = max(res, v1 + v2);
//
// err("l = %d r = %d v1 = %d v2 %d\n", a[i], b[i], v1, v2);
//
l.insert(a[i]);
r.insert(b[i]);
}
return res;
}
void solve() {
fi(0, n - 1) ans = calc1();
dbg(ans);
int l = 0, r = 0, p = -1;
fi(0, n - 1) {
if (p == -1 || (r > b[i] || (r == b[i] && l < a[i]))) {
l = a[i];
r = b[i];
p = i;
}
}
vi v;
fi(0, n - 1) {
if (i != p)
v.pb(i);
}
sort(v.begin(), v.end(), [&](int i, int j) { return a[i] < a[j]; });
int R1 = r;
int L2 = -INF;
int R2 = INF;
fdi(sz(v) - 1, 0) {
int cl = a[v[i]];
int cr = b[v[i]];
int L1 = (i ? max(a[v[i - 1]], l) : l);
//
// err("i = %d L1 = %d R1 = %d L2 = %d R2 = %d cl = %d cr = %d\n", i, L1,
// R1, L2, R2, cl, cr);
//
if (cl > l) {
L2 = max(L2, cl);
R2 = min(R2, cr);
ans = max(ans, f(L1, R1) + f(L2, R2));
} else {
ans = max(ans, f(max(L2, cl), min(R2, cr)) + f(L1, R1));
}
}
printf("%d\n", ans);
}
int main() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
START_TIME = (double)clock();
#endif
scanf("%d", &n);
fi(0, n - 1) scanf("%d %d", &a[i], &b[i]);
solve();
exit();
return 0;
}
| #define y1 askjdkasldjlkasd
#include <bits/stdc++.h>
#undef y1
using namespace std;
#define pb push_back
#define mp make_pair
#define fi(a, b) for (int i = a; i <= b; i++)
#define fj(a, b) for (int j = a; j <= b; j++)
#define fo(a, b) for (int o = a; o <= b; o++)
#define fdi(a, b) for (int i = a; i >= b; i--)
#define fdj(a, b) for (int j = a; j >= b; j--)
#define fdo(a, b) for (int o = a; o >= b; o--)
#define sz(x) (int)x.size()
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
typedef pair<ll, ll> pll;
typedef vector<pll> vpll;
typedef vector<ll> vll;
#ifdef LOCAL
#define err(...) fprintf(stderr, __VA_ARGS__)
#else
#define err(...) while (0)
#endif
double START_TIME;
void exit() {
#ifdef LOCAL
cerr << "TIME: " << setprecision(5) << fixed
<< (clock() - START_TIME) / CLOCKS_PER_SEC << endl;
#endif
exit(0);
}
template <typename A, typename B>
ostream &operator<<(ostream &os, pair<A, B> p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, vector<T> v) {
fi(0, sz(v) - 1) { os << v[i] << " "; }
return os;
}
template <typename T> ostream &operator<<(ostream &os, set<T> t) {
for (auto z : t) {
os << z << " ";
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, map<T1, T2> t) {
cerr << endl;
for (auto z : t) {
os << "\t" << z.first << " -> " << z.second << endl;
}
return os;
}
#ifdef LOCAL
#define dbg(x) \
{ cerr << __LINE__ << "\t" << #x << ": " << x << endl; }
#define dbg0(x, n) \
{ \
cerr << __LINE__ << "\t" << #x << ": "; \
for (int ABC = 0; ABC < n; ABC++) \
cerr << x[ABC] << ' '; \
cerr << endl; \
}
#else
#define dbg(x) \
while (0) { \
}
#define dbg0(x, n) \
while (0) { \
}
#endif
#ifdef LOCAL
#define ass(x) \
if (!(x)) { \
cerr << __LINE__ << "\tassertion failed: " << #x << endl, abort(); \
}
#else
#define ass(x) assert(x)
#endif
///////////////////////////////////////////////////
const int MAX = 1e5 + 41;
const int INF = 1e9 + 41;
int n;
int a[MAX];
int b[MAX];
int ans;
int f(int l, int r) { return max(0, r - l + 1); }
int calc1() {
multiset<int> l, r;
fi(0, n - 1) {
l.insert(a[i]);
r.insert(b[i]);
}
int res = 0;
fi(0, n - 1) {
l.erase(l.find(a[i]));
r.erase(r.find(b[i]));
int v1 = b[i] - a[i] + 1;
int v2 = max(0, (*r.begin()) - (*l.rbegin()) + 1);
res = max(res, v1 + v2);
//
// err("l = %d r = %d v1 = %d v2 %d\n", a[i], b[i], v1, v2);
//
l.insert(a[i]);
r.insert(b[i]);
}
return res;
}
void solve() {
ans = calc1();
dbg(ans);
int l = 0, r = 0, p = -1;
fi(0, n - 1) {
if (p == -1 || (r > b[i] || (r == b[i] && l < a[i]))) {
l = a[i];
r = b[i];
p = i;
}
}
vi v;
fi(0, n - 1) {
if (i != p)
v.pb(i);
}
sort(v.begin(), v.end(), [&](int i, int j) { return a[i] < a[j]; });
int R1 = r;
int L2 = -INF;
int R2 = INF;
fdi(sz(v) - 1, 0) {
int cl = a[v[i]];
int cr = b[v[i]];
int L1 = (i ? max(a[v[i - 1]], l) : l);
//
// err("i = %d L1 = %d R1 = %d L2 = %d R2 = %d cl = %d cr = %d\n", i, L1,
// R1, L2, R2, cl, cr);
//
if (cl > l) {
L2 = max(L2, cl);
R2 = min(R2, cr);
ans = max(ans, f(L1, R1) + f(L2, R2));
} else {
ans = max(ans, f(max(L2, cl), min(R2, cr)) + f(L1, R1));
}
}
printf("%d\n", ans);
}
int main() {
#ifdef LOCAL
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
START_TIME = (double)clock();
#endif
scanf("%d", &n);
fi(0, n - 1) scanf("%d %d", &a[i], &b[i]);
solve();
exit();
return 0;
}
| replace | 131 | 132 | 131 | 132 | TLE | |
p02875 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 998244353;
long long modPow(long long a, long long p) {
if (p == 0)
return 1;
auto res = modPow(a, p / 2);
res = (res * res) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
long long calcInv(long long a) { return modPow(a, MOD - 2); }
int main() {
const int maxSize = 1000001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
int N;
while (cin >> N) {
long long res = modPow(3, N);
for (int i = N / 2 + 1; i <= N; i++) {
long long sub = comb(N, i) * modPow(2, N - i);
res = (res + MOD - 2 * sub % MOD) % MOD;
}
cout << res << endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
const int MOD = 998244353;
long long modPow(long long a, long long p) {
if (p == 0)
return 1;
auto res = modPow(a, p / 2);
res = (res * res) % MOD;
if (p % 2)
res = (res * a) % MOD;
return res;
}
long long calcInv(long long a) { return modPow(a, MOD - 2); }
int main() {
const int maxSize = 10000001;
vector<long long> inv(maxSize);
vector<long long> fact(maxSize);
vector<long long> factInv(maxSize);
for (int i = 0; i < 2; i++)
inv[i] = fact[i] = factInv[i] = 1;
for (int i = 2; i < maxSize; i++) {
inv[i] = inv[MOD % i] * (MOD - MOD / i) % MOD;
fact[i] = fact[i - 1] * i % MOD;
factInv[i] = factInv[i - 1] * inv[i] % MOD;
}
auto comb = [&](int n, int r) {
if (n < r || r < 0)
return 0LL;
return fact[n] * factInv[n - r] % MOD * factInv[r] % MOD;
};
int N;
while (cin >> N) {
long long res = modPow(3, N);
for (int i = N / 2 + 1; i <= N; i++) {
long long sub = comb(N, i) * modPow(2, N - i);
res = (res + MOD - 2 * sub % MOD) % MOD;
}
cout << res << endl;
}
} | replace | 20 | 21 | 20 | 21 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.