fast_code_id stringlengths 64 64 | fast_id stringlengths 64 64 | fast_time float64 0 0.39 | language stringclasses 1
value | measured_fast_code_id stringlengths 64 64 | measured_slow_code_id stringlengths 64 64 | measurement_metric stringclasses 1
value | pair_id stringlengths 6 9 | problem_id stringlengths 6 6 | slow_code_id stringlengths 64 64 | slow_id stringlengths 64 64 | slow_time float64 0 1.69 | speedup float64 2 72.5 | stratum stringclasses 3
values | sampling_key stringlengths 64 64 | slow_code stringlengths 107 29.9k | fast_code stringlengths 88 161k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
67bd165fe0788e3e68f90e6abc99635233720ffd1436374a57147ec066182b4e | 09d73dc7015d9356fcf8f9ab9d324f3c65a7c08eab98dd9672be8fdc886ea0bb | 0.019149 | cpp | 09d73dc7015d9356fcf8f9ab9d324f3c65a7c08eab98dd9672be8fdc886ea0bb | 8a707193dc4a72d29d6e9cf73fd12673076013156991794e13828744716b5b6f | PIE_released_gem5_runtime | pie_56337 | p02936 | 17c1279d41db82af0a21dda1b0f48e9aa1661ccacdcab6764e99e54fb94435e4 | 8a707193dc4a72d29d6e9cf73fd12673076013156991794e13828744716b5b6f | 0.684834 | 35.76256 | 8+ | 4f9c67fccda32bd8e5ca0fa0d4d44d05481d5f20f55975c5b0e9243ccba5b83e | #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... |
#include <cstdio>
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 p... |
c87da682c074a930eea24b1903dfe3b3d45d26f7b8af86e1b08b6de1c1b1fa0e | 3272d37a7879d0e85d4ebb3d3383e5329f61bdc8d5ac497c7de26ae18d63e74e | 0.27029 | cpp | 3272d37a7879d0e85d4ebb3d3383e5329f61bdc8d5ac497c7de26ae18d63e74e | 01598db4e31a4236b0574ce1e07b283072227a29642639f6b069b4fa53145fb4 | PIE_released_gem5_runtime | pie_5643 | p00962 | 4e2a2fdfd9687b31cdd4584104c237ce465da82dc3f6ad7a2669720ed64597cb | 01598db4e31a4236b0574ce1e07b283072227a29642639f6b069b4fa53145fb4 | 0.656363 | 2.428368 | 2-4 | 9111b53229549defb0be9ad427bba4fcf87fe5129b807c5c9450407d2c16a61f | #include <bits/stdc++.h>
using namespace std;
const long long inf = 0x3f3f3f3f3f3f3f3fLL;
typedef pair<int, int> PII;
typedef unsigned int uint;
typedef unsigned long long uLL;
const int N = 1e5 + 10;
int n, m;
vector<PII> adj[N], radj[N];
uLL cnt1[N], cnt2[N];
long long dis1[N], dis2[N];
struct ... | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define ll long long
const int maxn = 1e5 + 5;
int n, m;
bool bo[maxn];
int a[maxn], b[maxn], c[maxn];
int read() {
int x = 0, f = 1;
char ch = getchar();
for (; ch < '0' || ch > '9'; ch = getchar())
if (ch == '-')
... |
d314124239ed1f0c2496123a72bb71936cb9961ec72f37808aacacb903b406e5 | 93438c24576fb82729129a3633d5989d44551bb8e11e79a88ef550db19620d71 | 0.000193 | cpp | 93438c24576fb82729129a3633d5989d44551bb8e11e79a88ef550db19620d71 | 49a7f6e99d83196a16ca8d216c26a07d80d135be491305ad03af5d8399b8d0d3 | PIE_released_gem5_runtime | pie_5648 | p03320 | 4619cc790bc213748f54928298e2fbebf03c93e7344e488719723532b04e01a0 | 49a7f6e99d83196a16ca8d216c26a07d80d135be491305ad03af5d8399b8d0d3 | 0.001017 | 5.275108 | 4-8 | 6074e2869b1dfe48b57990da1f6f634f0d0314bed4f9f680a844b99d30b4f2f4 | #include <iostream>
#include <cstdio>
using namespace std;
double cal(long long x) {
long long y = 10, len = 1, sum = 0, ret = x;
while (y <= x)
y = (y << 1) + (y << 3), ++len;
while (len--) {
y /= 10;
sum += x / y;
x %= y;
}
return ret * 1.0 / sum;
}
bool judge(long long x) {
lo... | #include <cstdio>
#include <cstring>
#include <algorithm>
typedef long long ll;
typedef long double ld;
ld Max(ld a, ld b) { return a > b ? a : b; }
inline ll read()
{
ll x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (c >= '... |
5d90320571619f180392114792e97cfa758b4d61513f00746dd57742e0b5336d | 7cd5d50c9224435f4f67d39c8abb1efb8dd89ae3daea7eb4f31e1387e8b0f605 | 0.019627 | cpp | 7cd5d50c9224435f4f67d39c8abb1efb8dd89ae3daea7eb4f31e1387e8b0f605 | db8b17951e84c2749d0b29039294a3927ac67b601f7f8f26fbc4596783c53140 | PIE_released_gem5_runtime | pie_5655 | p03502 | 0f554554fd9c0e32ef59527f199ad5917ada9cc3860bb6a13308506f9c549039 | db8b17951e84c2749d0b29039294a3927ac67b601f7f8f26fbc4596783c53140 | 0.104551 | 5.326852 | 4-8 | 2993054960aaf466220945c5e676e739c6275847d2e2d132219a80e97a45ea45 | #include <bits/stdc++.h>
using namespace std;
int main()
{
int n, d, a, sum = 0;
cin >> n;
a = n;
while (a > 0) {
d = a % 10;
sum = sum + d;
a = a / 10;
}
if (n % sum == 0)
printf("Yes\n");
else
printf("No\n");
return 0;
}
| #include <stdio.h>
int main() {
int input;
int temp = 0;
scanf("%d", &input);
int cek = input;
while (input > 0) {
temp += input % 10;
input /= 10;
}
if (cek % temp == 0) {
printf("Yes\n");
} else
printf("No\n");
} |
61c82e90e272d10a5ba55896e7343138b340aba209e5fe2faf549e040eb29420 | cc90a5fd11b554398fd68b25411c2c5f692c4027ff44cc3f551dc4565d940f82 | 0.019817 | cpp | cc90a5fd11b554398fd68b25411c2c5f692c4027ff44cc3f551dc4565d940f82 | b9dc226552b704d49553d6b484806492e9cc8960ca409b9d8fb678a133b5fafc | PIE_released_gem5_runtime | pie_56568 | p00112 | 3d11ed7e2db7343a937ad35c6ba71c9a91f33f2407f8134737bdfd0a11dfed18 | b9dc226552b704d49553d6b484806492e9cc8960ca409b9d8fb678a133b5fafc | 0.104696 | 5.283111 | 4-8 | 8f191dde3e4135f3a0e1817c1e3a649a58463e23cd38476e586421dedd2d5407 | #include <list>
#include <iostream>
using namespace std;
int main() {
int i;
int n;
long long c;
for (;;) {
cin >> n;
if (n == 0)
break;
list<int> t;
c = 0;
for (i = 0; i < n; i++) {
int tmp;
cin >> tmp;
t.push_back(tmp);
}
t.sort();
list... | #include <algorithm>
#include <cstdio>
using namespace std;
int main() {
int i;
int n;
while (scanf("%d", &n), n) {
int a[10000];
for (i = 0; i < n; ++i)
scanf("%d", a + i);
sort(a, a + n);
long long sm = 0;
for (i = 0; i < n - 1; ++i)
sm += a[i] * (n - i - 1);
pr... |
a326c72950edd441dafe22b27d42762998a828a8a3462de1c155c767b2f39c35 | 4906417cf52298bb120e3f9a5c95d398be9b33684147d1fe366a2ce17d8d23a3 | 0.061386 | cpp | 4906417cf52298bb120e3f9a5c95d398be9b33684147d1fe366a2ce17d8d23a3 | 523158be80e98528826e6305e657b38304683e2cc271617bc015b8992b037353 | PIE_released_gem5_runtime | pie_56569 | p03204 | 856a9a137063b8054563f688f4d455c5566d377e0e37dbb9d95ba39aa9284b70 | 523158be80e98528826e6305e657b38304683e2cc271617bc015b8992b037353 | 0.429266 | 6.99287 | 4-8 | 60f52aeb2d23f5c350e98ed12c9b74f6176a720d1025c3e56f203813466673cf | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
vector<int> G[maxn];
int in[maxn], out[maxn], tol;
int sz[maxn], S[maxn], is[maxn], son[maxn];
void get_cal(int v, int fa, int limit)
{
son[v] = 0;
if (v >= limit)
return;
son[v] = 1;
for (int i = G[v].size() - 1; i >= 0; i... | #include <cstdio>
#include <queue>
using namespace std;
#define N 200050
int fa[N], sz[N], head[N], cnt, mx[N], f[N], ti = 1, as[N], n, a, b, fr[N], vl[N];
struct edge {
int t, next;
} ed[N * 2];
priority_queue<pair<int, int> > st;
int finds(int x) { return fa[x] == x ? x : fa[x] = finds(fa[x]); }
void adde(i... |
cbb22e4abf522f22b44309b1f1928931c4eed382196fc9ac77dabac03437c0e1 | c3a0207e7774913f06a327c4c23f5c46a1b0c626014b52def6ab4ec5a5b4cfdf | 0.097955 | cpp | c3a0207e7774913f06a327c4c23f5c46a1b0c626014b52def6ab4ec5a5b4cfdf | e36dc42a4de4830ea8ca5fa73aef74b6bb6d835249df840b180ce91f0a3bf92c | PIE_released_gem5_runtime | pie_56572 | p03409 | b89aedb6f472f3720bcfb9841e5b6e6f38193380c0e30e6d7cea9bff7765feb6 | e36dc42a4de4830ea8ca5fa73aef74b6bb6d835249df840b180ce91f0a3bf92c | 0.907515 | 9.264588 | 8+ | b89df8c939f9a8c904542d56e2ac46ec3f81aea88ee7ff338258809a6bbd5b3d | #include <bits/stdc++.h>
using namespace std;
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); }
#define pb push_back
#define mp make_pair
#define cotu cout
#define itn int
#define Red ... |
#include "bits/stdc++.h"
#define ll long long
#define int ll
#define fi first
#define si second
#define mp make_pair
#define pb push_back
#define pi pair<ll, ll>
#define node(a, b, c) mp(mp(a, b), c)
#define clr(x) memset(x, 0, sizeof(x));
#define f(i, l, r) for (int i = l; i <= r; i++)
#define rf(i, r, l)... |
8b568bb567e37a529906acbe49cf013df9144ac8a989e166ba7b302830043563 | 75e366dab850c76536de4b6c250c7e1c81456a02c6f7bf3ec87a8661e176d760 | 0.013439 | cpp | 75e366dab850c76536de4b6c250c7e1c81456a02c6f7bf3ec87a8661e176d760 | ae519fc7d678ff6cfb344d516f8e0e6de8453be66585ef9ec4ba4185f3b46c07 | PIE_released_gem5_runtime | pie_5658 | p00613 | 46a65d5649491d7e410a22a939967665d606fd107a4c3f829a938b047dec911f | ae519fc7d678ff6cfb344d516f8e0e6de8453be66585ef9ec4ba4185f3b46c07 | 0.071203 | 5.29846 | 4-8 | 43117bbab3e087915a0c98eecac70c87e76f403d158fc95b6fffbc01ada6b63d | #include <iostream>
using namespace std;
int main() {
int k, c, a;
while (cin >> k, k) {
a = 0;
for (int i = 0; i < k * (k - 1) / 2; i++) {
cin >> c;
a += c;
}
cout << (a / (k - 1)) << endl;
}
} | #import <cstdio>
int main() {
for (int k, c, a, i; scanf("%d", &k), k; printf("%d\n", a / --k))
for (a = i = 0; i++ < k * (k - 1) / 2; a += c)
scanf("%d", &c);
} |
2f1428b3170ec0b96ca7ab19c72e9d24c9313a65ccef690aac97861d8def4e80 | 01445fab7b5ddbf653727141a98f7e73340d61026b9fa33db3cd353efc0fccea | 0.142221 | cpp | 01445fab7b5ddbf653727141a98f7e73340d61026b9fa33db3cd353efc0fccea | 6b7674049f3f66845e2bceed596bd4c875ddf39aaab2c749564cf91867c4e706 | PIE_released_gem5_runtime | pie_56594 | p02949 | ab13d409a7aaec68cd7214c6fc721afd0c428bccc2287ad592775713fb72bd8e | 6b7674049f3f66845e2bceed596bd4c875ddf39aaab2c749564cf91867c4e706 | 0.377141 | 2.651801 | 2-4 | 3e59f71cb2b4ed2d1baee08e3db95478f1461a83ff3c8ddf354bdcd3c85f004e | #include <bits/stdc++.h>
using namespace std;
#define maxx 100010
#define mp make_pair
typedef pair<int, int> ii;
int ans[maxx], visitado[maxx];
vector<ii> ladj[maxx];
map<int, int> dicio;
int n, m, p = 0;
int nos = 0;
vector<int> dist;
void dfs(int x) {
visitado[x] = 1;
for (auto e : ladj[x]) {
i... | #include <bits/stdc++.h>
using namespace std;
const int MAXN = 6000;
vector<pair<long long, pair<int, int>>> adj;
vector<int> adj2[MAXN];
vector<int> adj3[MAXN];
long long dist[MAXN];
int pai[MAXN];
bitset<MAXN> mark, mark2;
int n, m;
void bfs2(int u) {
mark2[u] = 0;
queue<int> Q;
Q.push(u);
while... |
8883dd48a9a256071b26c6b0e841448711c3bd55159491a56f845c4d6cb1573e | 90040f578182b0fad45fb2ddc46c3499d8e47e39a4464efff4a83ee361a13249 | 0.103583 | cpp | 90040f578182b0fad45fb2ddc46c3499d8e47e39a4464efff4a83ee361a13249 | 48c61d1282b29a3cb6f4a1192a75e400a972ee89fea2317fcc06494b7913449e | PIE_released_gem5_runtime | pie_56599 | p00298 | 1060a2b8647854607d5e064ea2cdc9c4364627b444d1bc1003f3dcc600a9b3e0 | 48c61d1282b29a3cb6f4a1192a75e400a972ee89fea2317fcc06494b7913449e | 0.319831 | 3.087678 | 2-4 | ace4b14329a424d52f286d6222e04aa16f10e843ed9c99b50c39d2d014256417 | #include <bits/stdc++.h>
#define REP(i, n, N) for (int i = n; i < N; i++)
#define p(S) cout << (S) << endl
using namespace std;
int dp[1001][1001];
int w[100010], c[100010];
int sumw[100010];
int main() {
int n;
cin >> n;
REP(i, 0, n) {
cin >> c[i] >> w[i];
if (i > 0)
sumw[i] = sumw[i - ... | #include "bits/stdc++.h"
#define REP(i, n, N) for (int i = (n); i < (N); i++)
#define RREP(i, n, N) for (ll i = (N - 1); i >= n; i--)
#define CK(n, a, b) ((a) <= (n) && (n) < (b))
#define ALL(v) (v).begin(), (v).end()
#define p(s) cout << (s) << endl
#define p2(a, b) cout << (a) << " " << (b) << endl
#define v2(... |
397f10ce58df5c5c44ea270a07b03507aede3dd1842a6e7c6f6f73e7688a85cf | ce0c60659eec5d8c4020389ad1a4f6b05e90b9503e8c861be63b8ed8f7a24d7d | 0.051177 | cpp | ce0c60659eec5d8c4020389ad1a4f6b05e90b9503e8c861be63b8ed8f7a24d7d | 7fc201023abc5ee52b9c7e6f95e568d95442e184391258e95592638151dc5112 | PIE_released_gem5_runtime | pie_56604 | p02271 | f6324bb6b49fd9a09136d851c1b84b6661613a438b0b075b380b9cf74f14600d | 7fc201023abc5ee52b9c7e6f95e568d95442e184391258e95592638151dc5112 | 0.103778 | 2.027845 | 2-4 | 3eb9e88faa99fee381e48fd5c5c7358f056ee14851090df3a75467c7b7eb3234 | #include <iostream>
bool solve(int i, int m);
int n, q, A[2000], m[2000];
int main()
{
using namespace std;
cin >> n;
for (int i = 0; i < n; i++)
{
cin >> A[i];
}
cin >> q;
for (int i = 0; i < q; i++)
{
cin >> m[i];
}
for (int i = 0; i < q; i++)
{
if (solve(0, m[i]))
... | #include <cstdio>
#include <cstring>
int n, A[50], dp[21][2001];
int solve(int i, int m)
{
if (dp[i][m] != -1)
{
return dp[i][m];
}
if (m == 0)
dp[i][m] = 1;
else if (i >= n)
dp[i][m] = 0;
else if (solve(i + 1, m))
dp[i][m] = 1;
else if (solve(i + 1, m - A[i]))
dp[i][m] ... |
2faea8df98d6671dc0a877625b2452cdf0a8ca3dae46f38f98d8b716e1d11997 | 6decc81422cf5ffe7e9a8bf99e78a394902a1f11543aa01ea075e809554c373f | 0.071146 | cpp | 6decc81422cf5ffe7e9a8bf99e78a394902a1f11543aa01ea075e809554c373f | 9af36e3bf9ab96fdbcf799e01284ba8a57771e1f79ae32deee24850f7d11c6a9 | PIE_released_gem5_runtime | pie_56609 | p03429 | 7064dcc4bd11c803b411d037923988b3ab61443662b57e3c7e299f3efaf99c97 | 9af36e3bf9ab96fdbcf799e01284ba8a57771e1f79ae32deee24850f7d11c6a9 | 0.150028 | 2.108727 | 2-4 | 4203952b9bbaf5790371c301b97c7d4195930426d0dd51ea3a9baf6d656c9468 | #include <stdio.h>
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <string>
using namespace std;
typedef long long ll;
const int maxn = 1000 + 5;
char map[maxn][maxn];
int N, M, A, B;
int main()
{
memset(map, '.', sizeof(map));
scanf("%d%d%d%d", &N, &M, &A, &B);... | #include <bits/stdc++.h>
using namespace std;
#define INF 2000000000
typedef long long int ll;
typedef pair<ll, ll> ii;
typedef pair<ii, ll> iii;
typedef vector<ll> vi;
typedef vector<ii> vii;
#define getbit(n, i) (((n) & (1LL << (i))) != 0)
#define setbit0(n, i) ((n) & (~(1LL << (i))))
#define setbit1(n, i) ... |
5458f526b509cfca71018a6ef4973e7581f47830519050d4189ba4059292f1bb | ef921fb1b6091032e822b2053ec4b1faa441c2e2a303f3b6e1b052888556afce | 0.021638 | cpp | ef921fb1b6091032e822b2053ec4b1faa441c2e2a303f3b6e1b052888556afce | fd8423e91511257fbfb436e4c398aec7afc52b1e9876417226f73275d02143e8 | PIE_released_gem5_runtime | pie_56633 | p02686 | dc49bd2b2682d70b2f3becb506320c33b2f5bc90429554d3b787be4cc35c77ad | fd8423e91511257fbfb436e4c398aec7afc52b1e9876417226f73275d02143e8 | 0.098762 | 4.564264 | 4-8 | 19eb9c32c230ed4caedd7250f460e4b633e2512e73b5029a5a4713c43a85cd1d | #pragma GCC optimize("O3")
#pragma GCC target("avx2")
#include <cstdio>
#include <vector>
#include <algorithm>
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 << ... | #pragma GCC optimize("O3")
#pragma GCC target("avx2")
#include <cstdio>
#include <algorithm>
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... |
9f2dc0178a19161e17f8a740e952223187f79c5af2a9134b3c1a5316356840fe | da184a3ffc52c4fe60be2d7ed7003a40b471e033c8e930802f263b03c429cb1f | 0.106165 | cpp | da184a3ffc52c4fe60be2d7ed7003a40b471e033c8e930802f263b03c429cb1f | 27dfac040b9be884f916db2d88caa3b401a1477d89b668c6e6d943057395ae29 | PIE_released_gem5_runtime | pie_56793 | p04044 | 96f657cc6fa5f8b914f1a85b92c7430d8047fb7e11d567ef571efbf4d9162ca2 | 27dfac040b9be884f916db2d88caa3b401a1477d89b668c6e6d943057395ae29 | 0.368584 | 3.471811 | 2-4 | 8cd1a3fb73d5688c37829a4769774ad1ba52c4e49a41e8e5719eabe5d3252ded |
#include <bits/stdc++.h>
#define lln long long int
#define llu unsigned lln
#define sc(n) scanf("%d", &n);
#define scl(n) scanf("%lld", &n);
#define scd(n) scanf("%lf", &n);
#define pf(res) printf("%d\n", res);
#define pfl(res) printf("%lld\n", res);
#define pfd(res) printf("%lf\n", res);
#define maxii 10000... | #include <bits/stdc++.h>
using namespace std;
#define optimize() \
ios_base::sync_with_stdio(0); \
cin.tie(0); ... |
ccf16dc826ddb9af285f8fbb98f1fa284f21129bb528f8fada22e2a743a0cdf7 | 734297ae1adfd019391dbfd80bed540ff816c0efb485089a0869582bbae9997a | 0.003968 | cpp | 734297ae1adfd019391dbfd80bed540ff816c0efb485089a0869582bbae9997a | ed2b50ea1c6271b007722b99c2b7e496cf9f68f469dc1ad397309d83532f6ecd | PIE_released_gem5_runtime | pie_56832 | p02977 | fc927a7ddbddfae280d2e6e41417b90041ce6d1cc66b056cfff2f87d91b76c8f | ed2b50ea1c6271b007722b99c2b7e496cf9f68f469dc1ad397309d83532f6ecd | 0.02106 | 5.307834 | 4-8 | 0c7e16d188fc7cd69b66a88540daa32f5e20f04b0502c429d66371cc22d9371a | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int main()
{
int N;
scanf("%d", &N);
int t;
for (int i = 1; i <= N; t = i, i <<= 1)
if (N == i)
{
printf("No\n");
return 0;
}
if (N == 3)
{
printf(... | #include <cstdio>
using namespace std;
int n;
int main()
{
scanf("%d", &n);
if (n < 3) {
printf("No\n");
return 0;
}
if (n & 1)
{
printf("Yes\n");
printf("%d %d\n", 1, 2);
printf("%d %d\n", 2, 3);
printf("%d %d\n", 3, n + 1);
printf("%d %d\n", n + 1, n + 2);
printf("%... |
4437e83c31bbf64305b5afe10e666da5f15bdf5e3d30056f6ccc504dd3247c61 | f896e297a087c3286d54c2c2ca1e5b7cd85c53eead0d8631660ed5a6a10d53a8 | 0.107409 | cpp | f896e297a087c3286d54c2c2ca1e5b7cd85c53eead0d8631660ed5a6a10d53a8 | 1ad9a88f5ced0dd4e1c0d94110a65202c3d699dcc4c75ce24fd1fe38fd1fd059 | PIE_released_gem5_runtime | pie_56849 | p03262 | bc70eb576b2a95ac5dd55d6c9cad54956adf10c7a37a66348103d472505edf67 | 1ad9a88f5ced0dd4e1c0d94110a65202c3d699dcc4c75ce24fd1fe38fd1fd059 | 0.687733 | 6.402941 | 4-8 | fae573784cdf201ad9e0c40524ae6d656d4fb8d537bfb1218c78cbbf8fd3e690 | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <cmath>
#include <queue>
#include <numeric>
#include <climits>
#include <iterator>
#include <iomanip>
#include <stack>
#include <set>
#include <bitset>
#include <functional>
using namespace std;
const co... | #include <cstdio>
#include <climits>
#include <iostream>
#include <string>
#include <vector>
#include <set>
#include <cmath>
#include <stack>
#include <algorithm>
#include <iomanip>
#include <map>
#include <queue>
#include <functional>
#include <numeric>
#include <chrono>
#include <cstdlib>
using ll = l... |
97ad7d552b18c82eede8251cd3a6317bc1ced8a7f71582ca4580e8ab12770571 | 75afaf849677bed4568983e9e9d3b948554be54f971b2e98e45fb784d29045b5 | 0.019666 | cpp | 75afaf849677bed4568983e9e9d3b948554be54f971b2e98e45fb784d29045b5 | b78ac9544d88561653c5844a39d03305787c9c0f5f74db6611d5459bf678e5c8 | PIE_released_gem5_runtime | pie_56871 | p03719 | 75964fdd7e37d553fd1f794f80518f36388424137ff3055a5ee1187a1c7abbb3 | b78ac9544d88561653c5844a39d03305787c9c0f5f74db6611d5459bf678e5c8 | 0.374363 | 19.036268 | 8+ | 2eb309b5304c3d2869e5fcc2911401ba33ff76e9b3013049be159146278f3d93 | #include <iostream>
#include <bits/stdc++.h>
#define pb push_back
#define ob pop_back
#define xx first
#define yy second
#define dob double
#define rin(i, n, k) for (int i = 0; i < n; i += k)
#define int long long int
#define ss size()
using namespace std;
const int M = 1e9 + 7, maxn = 100010;
std::vector<i... | #include <stdio.h>
int main()
{
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
if (c >= a && c <= b)
{
printf("Yes\n");
}
else
printf("No\n");
} |
1df38a508edd4e5a0bacd88c77c82b639d8d98c82f02ae7f595d9905a6208169 | 946a9a75d035f1e6b27826c3511dc1892fe9e48086777cb88f3f62bed89e772a | 0.106211 | cpp | 946a9a75d035f1e6b27826c3511dc1892fe9e48086777cb88f3f62bed89e772a | 4d3234270733e39753262e4cd75e6806ca90311e9d7c59820b2de13e95ea38ff | PIE_released_gem5_runtime | pie_56902 | p03618 | 8e4eb9be81cfcc1277b3f740a309434bee2816415b92188f13ab205d24ee4532 | 4d3234270733e39753262e4cd75e6806ca90311e9d7c59820b2de13e95ea38ff | 0.27918 | 2.628555 | 2-4 | ec58f0842ea39eee4919e071c02bf87b9fb6425357a8f3f1afbe24a7b1da8ef6 | #include "bits/stdc++.h"
using namespace std;
#define OUT(x) cerr << #x << " = " << x << endl;
#define all(x) x.begin(), x.end()
#define mp make_pair
#define pii pair<int, int>
#define pll pair<long long, long long>
#define ll long long
long long fact[202020];
long long nCr(long long n, long long r) {
long ... | #include "bits/stdc++.h"
using namespace std;
int main() {
string s;
cin >> s;
vector<long long> cnt(26, 0);
long long n = s.size();
for (int i = 0; i < n; i++)
cnt[s[i] - 'a']++;
long long ans = 1 + n * (n - 1) / 2;
for (int i = 0; i < 26; i++)
if (cnt[i] >= 2)
ans -= cnt[i] * (cnt[... |
0c1330d5acf0997cd645659d1c64cb6e84f7f563e8759090ae3e65caf75c240d | bacb102ce1644d36260e716a1769a87cf4c43306ea91f5fe030bf94520b79cbb | 0.105093 | cpp | bacb102ce1644d36260e716a1769a87cf4c43306ea91f5fe030bf94520b79cbb | cf8be34020a76189ec8bc8db5a99a585fc64488b521a9c9ca9b112116d754179 | PIE_released_gem5_runtime | pie_56927 | p03852 | 27f8be6ab83f4e3e629dfb11afcadfe9acfc1b8126d1ad37fefb7b0327c9b595 | cf8be34020a76189ec8bc8db5a99a585fc64488b521a9c9ca9b112116d754179 | 0.686596 | 6.533257 | 4-8 | 1cb3aaad7069bc16543f4f6637084c7224d2c60ac733443377cc7855d3fcde6e |
#include <bits/stdc++.h>
#define lln long long int
#define llu unsigned lln
#define sc(n) scanf("%d", &n);
#define scl(n) scanf("%lld", &n);
#define scd(n) scanf("%lf", &n);
#define pf(res) printf("%d\n", res);
#define pfl(res) printf("%lld\n", res);
#define pfd(res) printf("%lf\n", res);
#define maxii 20000... | #include <bits/stdc++.h>
using namespace std;
int main() {
char c;
cin >> c;
if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') {
cout << "vowel" << endl;
}
else {
cout << "consonant" << endl;
}
return 0;
}
|
a8efaac1814f55ef5a3e34bd1ed03ede9eb32510a1f2333401099921906ca805 | b8b89a1b86769951cd8e88da6e2c88e4c55f3c7a0ca1fd6b4fa9d2fdce076f4d | 0.015317 | cpp | b8b89a1b86769951cd8e88da6e2c88e4c55f3c7a0ca1fd6b4fa9d2fdce076f4d | 09ad8a0f26ad82b1529f1cd05387b7ae5076a62b13cf7780803fa10bdc842252 | PIE_released_gem5_runtime | pie_56956 | p03915 | 47b4fa2d1fe331b0829576252aefef0b6974f50447833f94e7db4c78a137f923 | 09ad8a0f26ad82b1529f1cd05387b7ae5076a62b13cf7780803fa10bdc842252 | 0.348056 | 22.72283 | 8+ | af7f8196a6ba93400192b323b369032208e4b6a888c63e54a959fad25cd1d194 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const ll MAXN = 4e5 + 51;
struct Edge {
ll from, to, dist;
inline bool operator<(const Edge &rhs) const
{
return this->dist < rhs.dist;
}
};
Edge ed[MAXN];
ll nc, cnt, x, y, z, tot;
ll dist[MAXN], boss[MAXN];
inline ll read(... | #include <algorithm>
#include <cstdio>
inline int read() {
char c = getchar();
int x = 0;
for (; c < '0' || c > '9'; c = getchar())
;
for (; c >= '0' && c <= '9'; c = getchar())
x = x * 10 + c - '0';
return x;
}
inline int min(int a, int b) { return a < b ? a : b; }
inline void swap(int &a, in... |
712d0ee1938074c55c09886cb4d062ba357da3097c7926ff97702a3ef95dbe50 | 1e3672d33bfcb4e9b4001b6b7f0d88865520481e5a5b0a8e6acf4d0f4c180402 | 0.004131 | cpp | 1e3672d33bfcb4e9b4001b6b7f0d88865520481e5a5b0a8e6acf4d0f4c180402 | 27c2231eada26a5eabaf99cb8ec66007cb8b519d3b695c1389288438f54741c0 | PIE_released_gem5_runtime | pie_57012 | p00760 | 90860a98b548fea59a62663ab6997d06a90e58cc5617ea05bdb89212ac405089 | 27c2231eada26a5eabaf99cb8ec66007cb8b519d3b695c1389288438f54741c0 | 0.024519 | 5.935662 | 4-8 | 284af5ee54d32381faffec4c611f09a1dd1a569e9cacb60da10ff8c080df33af | #include <string>
#include <vector>
#include <iostream>
#include <cstdio>
#include <cstdlib>
#include <stack>
#include <queue>
#include <cmath>
#include <algorithm>
#include <functional>
#include <list>
#include <deque>
#include <bitset>
#include <set>
#include <map>
#include <cstdio>
#include <cstring>... | #include <stdio.h>
int main()
{
int n, Y, M, D;
int year = 20 * 5 + 19 * 5, year3 = 20 * 10;
int yearsum = 999 * year + (int)(1000 / 3) * 5;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d %d %d", &Y, &M, &D);
Y--;
M--;
D--;
printf("%d\n", yearsum - (Y * year + (int)(Y /... |
321b86dd444864d2da8a163fcf5c66278a3f12e43dd19f1ceaa765a31a587989 | b64c696bd622b61cf38dbb31d80f6b4b4f43fdfe5c0d38a7ae91ce5216a7da1c | 0.012849 | cpp | b64c696bd622b61cf38dbb31d80f6b4b4f43fdfe5c0d38a7ae91ce5216a7da1c | 0e90f73545afe339f9c01da6f539611d70cbb537a41b6354f2eda3ad92bf4923 | PIE_released_gem5_runtime | pie_57064 | p03721 | bbf057a5c995042a5a6d6bda872c28c30ccc8dd631319dcb1769fb966de999ce | 0e90f73545afe339f9c01da6f539611d70cbb537a41b6354f2eda3ad92bf4923 | 0.128185 | 9.976151 | 8+ | b8fd5fec30d9246033aeaec50c81d71cc126b07fe0deb7584d4e653706c32875 | #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... | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include <cstdio>
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) << "... |
39e456c33a3c6f3800acdcbc8d5a5cd800e3cea3fb98db42f985fe06e14c44e2 | bacbbd89b00ccc1a91bc21febdc77fb52fcb2f697074d72bf24a48a87762a07e | 0.0198 | cpp | bacbbd89b00ccc1a91bc21febdc77fb52fcb2f697074d72bf24a48a87762a07e | 95861eba6a8953dfeb53ce322b177d7b6e466050bc1e78d269c93c1304299c22 | PIE_released_gem5_runtime | pie_5717 | p00009 | 5a0e31ccbfc0925c1157ea59c92c1b768a4949d14a678383e4aa7f521f2d0bac | 95861eba6a8953dfeb53ce322b177d7b6e466050bc1e78d269c93c1304299c22 | 0.361494 | 18.257415 | 8+ | 59e3ceff3df317ac53089199a85f2ccdc931de769e4b6072612a524bb2fa4152 | #include <stdio.h>
#include <math.h>
bool flag[1000000];
int main(void)
{
long long i, j, p, n, count;
p = (long long)sqrt(1000000.0);
for (i = 3; i <= p; i = i + 2)
{
if (flag[i] == false)
{
for (j = i * i; j <= 1000000; j = j + 2 * i)
{
flag[j] = true;
}
}
... | #include <cstdio>
using namespace std;
#define MAX 1000000
int prime[MAX];
bool is_prime[MAX];
int sieve(int n) {
int p = 0;
for (int i = 0; i <= n; i++)
is_prime[i] = true;
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= n; i++) {
if (is_prime[i]) {
prime[p++] = i;
for ... |
1f847b389557ac34e86cd3808bf7dfa92f3d4cf5999382887027907e470fc07e | c9153df9ce199ed719611fcf98035d4a130c5d02495288b877761c44d232e864 | 0.107461 | cpp | c9153df9ce199ed719611fcf98035d4a130c5d02495288b877761c44d232e864 | 58d819ebbc004437b675dd9ef33d4e889623be8e7dcda04c0c88a850042096ed | PIE_released_gem5_runtime | pie_57196 | p03363 | 12b079e254192df9146c31bdbce8aa8ef60ea1e5425ef7df7c004a4106421c14 | 58d819ebbc004437b675dd9ef33d4e889623be8e7dcda04c0c88a850042096ed | 0.285427 | 2.656092 | 2-4 | 6ac1e88d03ca48d9aa8d0bb3c80f39cd4299c43ec9b31567b6f3a9d609e51f8e | #include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#def... | #include <iostream>
#include <fstream>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <queue>
#include <deque>
#include <stack>
#include <functional>
#include <algorithm>
#include <climits>
#include <cmath>
#include <iomanip>
using namespace std;
#define ll long long int
#def... |
781c1dda4aad3f83277de059edc5a4d6786450b8c9588298e960c297290a919c | 1bd9d998688d09eb3c2dfd553259bdeb8a08f6c4313e8a2e13530c8b7c9d9844 | 0.047192 | cpp | 1bd9d998688d09eb3c2dfd553259bdeb8a08f6c4313e8a2e13530c8b7c9d9844 | 30d385613b60679a1520ec2bd6f4de6879ae17b88db4f72e7145d86afe1741a3 | PIE_released_gem5_runtime | pie_57232 | p03990 | e3515ffe5696fd1c75029fdf6239d0a22d7964f945d79fc4a99329872e4e38e2 | 30d385613b60679a1520ec2bd6f4de6879ae17b88db4f72e7145d86afe1741a3 | 0.125693 | 2.663406 | 2-4 | cd08276fa99e30844953a37feb9ff3570f6732ca05786c9b53667ef4e6fe9850 | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
using namespace std;
const int N = 2e5 + 10;
struct Tree
{
struct edge {
int next, to;
} a[N << 1];
int head[N], cnt;
void link(int x, int y)
{
a[++cnt] = (edge){head[x], y};
head[x] = cnt;
... | #include <bits/stdc++.h>
#define MAXN 200005
using namespace std;
int n, cnt, last[MAXN];
int father[MAXN], deep[MAXN], dis[MAXN];
int q[MAXN], nnn[MAXN], mx[MAXN];
int tim, a[MAXN][2], xx, yy;
bool vis[MAXN], win[MAXN];
struct edge
{
int to, next, h;
} t[MAXN * 4];
void add(int u, int v, int h)
{
t[+... |
17943a94f8274ceb77d54d4fddd3a0cd9cac10b8dcf6c6fd7169d29a32ba079b | b3ccb9319c98996170fd02dd358583b429cb64a15c16cc34e0b69a46a28121d7 | 0.05377 | cpp | b3ccb9319c98996170fd02dd358583b429cb64a15c16cc34e0b69a46a28121d7 | d813011be66ee758b4a73970f5db2b81c0d9416d8bc97722287ba66f8de77341 | PIE_released_gem5_runtime | pie_57242 | p03969 | a1960fc2d3229fc5afa8c36d8e38c3b0b6b4b08584db63cbdb94ad11bc4586f6 | d813011be66ee758b4a73970f5db2b81c0d9416d8bc97722287ba66f8de77341 | 0.16251 | 3.022327 | 2-4 | fb8a95f7a8990b96bf4bb08a743fbcf1245a58498d1ca9d44cbbe288e59efac2 | #include <bits/stdc++.h>
using namespace std;
const int mod = 1e9 + 7;
int add(int x, int y) { return x + y < mod ? x + y : x + y - mod; }
int qpow(int x, int k)
{
int r = 1;
while (k)
{
if (k & 1)
r = 1ll * r * x % mod;
k >>= 1;
x = 1ll * x * x % mod;
}
return r;
}
int gcd(int a... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define reg register
#define mo 1000000007
#define maxn 1000
inline ll read()
{
reg ll x = 0, w = 0;
reg char ch = getchar();
while (!isdigit(ch))
w |= ch == '-', ch = getchar();
while (isdigit(ch))
x = (x << 3) + (x << 1) + (c... |
702e7e80b49b9ef7120fc67bb17f8f7cc9491a34c35df0e125b3142e15374275 | 5ea39ab26da283e09115dcc0fba0e0f702e1e8914ce0e186ee90dc63e3e36592 | 0.018044 | cpp | 5ea39ab26da283e09115dcc0fba0e0f702e1e8914ce0e186ee90dc63e3e36592 | 02b5d7e9ad82e5fe60be8d838053a470d110568454e26a5eb0d6277ddc71fb9f | PIE_released_gem5_runtime | pie_57262 | p02586 | d6d2bda4cd5655420138e5e3a24b7f7094bb0f3745ce50295dd4cd83132852ac | 02b5d7e9ad82e5fe60be8d838053a470d110568454e26a5eb0d6277ddc71fb9f | 0.079257 | 4.39249 | 4-8 | 3640bc08617a2915251ba5a9dee212b25ac692326f37e5960c728575f4dcf6d1 | #pragma GCC optimize("O2")
#pragma GCC target("avx2")
#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 << ... | #pragma GCC optimize("O2")
#pragma GCC target("avx2")
#include <algorithm>
#include <cstdio>
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... |
b91de1294e6b3d2421344592b4899134373921d6018ac31f47b62512fbad3ef2 | 02a628c33befd83b29d112a723b01018af29547d0fdd1465d1efbc43ed043e75 | 0.104975 | cpp | 02a628c33befd83b29d112a723b01018af29547d0fdd1465d1efbc43ed043e75 | 04ec662e52c7ed59454c156633be563e185fa542abcb26c77cdc72d413ffcc11 | PIE_released_gem5_runtime | pie_57274 | p03271 | 543f94c56a63abe67ea92e88e7f35d41bccb87737e730f6ac449afd4e7019a7e | 04ec662e52c7ed59454c156633be563e185fa542abcb26c77cdc72d413ffcc11 | 0.310483 | 2.957682 | 2-4 | 7c6f211d57b4698e949c111c4531034f1fc2fc2bb5833b3ccac854cf2465616c | #include <cstdio>
#include <vector>
#include <cstring>
using i64 = long long;
int n, flg = 1, t[300007];
std::vector<int> p[3];
int read() {
int x;
scanf("%d", &x);
return x;
}
void add(int p) {
while (p)
++t[p], p ^= p & -p;
}
int ask(int p) {
int r = 0;
while (p <= n)
r += t[p], p += p & -p... | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
using namespace std;
inline int read()
{
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
... |
0f788de65070cb103e288a7591cbf8d3d7f7cbd342f4547d16a8cc3f787ad6bf | 4b0896c3ba11b196d5c4a675186d9ee97777dada87684e430585d8e09b1949c0 | 0.019322 | cpp | 4b0896c3ba11b196d5c4a675186d9ee97777dada87684e430585d8e09b1949c0 | 5adacd142180efff9cb58e1da128e9f1d816464928465b984f386b05a0b7095b | PIE_released_gem5_runtime | pie_57293 | p03634 | 8ab799365c0e0e58e0b182eb5935c3b7abfe077c1431d5a1af47fbaf6b87ba22 | 5adacd142180efff9cb58e1da128e9f1d816464928465b984f386b05a0b7095b | 0.472561 | 24.457072 | 8+ | 0e9d600bc94668bb62a6f6cb02b07cc60f426da14e7de0ea3392adc4ca92544c | #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... |
#include <cstdio>
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 p... |
0643c1f068126a3b08da2850fde016e2dcb0b7473756e6855c07a64b92f0ee04 | bdc8bf7884903feb38c328f97af834325761acee806a5bdc12b650e260a9316e | 0.022678 | cpp | bdc8bf7884903feb38c328f97af834325761acee806a5bdc12b650e260a9316e | d2556084304caffe8f60ec44e459c2d999db91c7257a7ef73d3a2f3f4c932dad | PIE_released_gem5_runtime | pie_57420 | p03287 | f5d47e4017b616bba1cfb40bc7fed75e7ead5845ad675242a8795aa26d9e27d6 | d2556084304caffe8f60ec44e459c2d999db91c7257a7ef73d3a2f3f4c932dad | 0.237296 | 10.463545 | 8+ | ac499efacd2adf399fb1ddc0f9e2c66c644e3d46a86acc14b9e37696fd4dbbef | #include <bits/stdc++.h>
using namespace std;
#define repeat(i, n) for (int i = 0; i < (n); i++)
int main()
{
int N, M;
cin >> N >> M;
int A[100001] = {};
long long B[100001] = {};
map<int, int> MAP;
repeat(i, N) {
cin >> A[i];
B[i + 1] = B[i] + A[i];
B[i + 1] %= M;
MAP[(int)B[... |
#include <cstdio>
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 p... |
e7ac4e5b857b72715564e42d6743fb87b761541aab33ea2d162cccce83218fd9 | 7b053f331ba528e97f4bccf68e18e601f1026bd202a2919863bd68985f16980a | 0.018601 | cpp | 7b053f331ba528e97f4bccf68e18e601f1026bd202a2919863bd68985f16980a | 3481083de9c2395f9859a266ec7e2bcfd076b8accd06200c31373a979878b5e6 | PIE_released_gem5_runtime | pie_57480 | p02692 | 137d32224e8f5ed31cfba18ba3e91288c35316cb5584081dca339bd921272cf9 | 3481083de9c2395f9859a266ec7e2bcfd076b8accd06200c31373a979878b5e6 | 0.432961 | 23.276184 | 8+ | e295c3fdf3c1f20fcbf080bf510a4e8ec02718765dc4832444c102609254d3ec | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 1e5 + 5;
string s[N];
char ans[N];
int n, a, b, c;
void dfs(int id, int a, int b, int c) {
if (a < 0 || b < 0 || c < 0)
return;
if (id == n) {
puts("Yes");
for (int i = 0; i < n; i++)
cout << ans[i] << end... | #include <cstdio>
#include <algorithm>
#define maxn 100010
using namespace std;
char in[3];
int n, v[3], p[maxn], q[maxn], ans[maxn];
int main() {
int i;
scanf("%d", &n);
for (i = 0; i < 3; i++)
scanf("%d", &v[i]);
for (i = 1; i <= n; i++)
scanf("%s", in), p[i] = in[0] - 'A', q[i] = in[1] - 'A... |
c5fcd3e07a9e0aa6f1b2c32dc9534ac414cbd149700b26eeb6f027ae439fadbd | 9ff63e89eb3556906ff2c66d2a87f5b309f0b5ef07e28674ac6222f00f99eec1 | 0.064533 | cpp | 9ff63e89eb3556906ff2c66d2a87f5b309f0b5ef07e28674ac6222f00f99eec1 | add1e4335a2321dca13aeae3e1e42acd69159f831de8ba684d91a57d849c154d | PIE_released_gem5_runtime | pie_57499 | p02776 | 3fa7cc6f41b366a2336b13aece50c64c3c418d51342dccf8502159567dba2910 | add1e4335a2321dca13aeae3e1e42acd69159f831de8ba684d91a57d849c154d | 0.233378 | 3.61641 | 2-4 | 1565611b5757a70a6e1e087c8b4bdc5e5781a3406c3cb375d0e48d173060e90f | #include <bits/stdc++.h>
using namespace std;
const int N = 100005;
pair<int, int> p[N];
int n, m, a[N], vis[N];
vector<pair<int, int>> e[N];
vector<int> ans;
inline int dfs(int x)
{
vis[x] = 1;
int rt = a[x];
for (auto v : e[x])
{
int y = v.first;
if (vis[y])
continue;
int t =... | #pragma GCC optimize("Ofast")
#include <bits/stdc++.h>
using namespace std;
void *wmem;
char memarr[96000000];
template <class T> inline void walloc1d(T **arr, int x, void **mem = &wmem) {
static int skip[16] = {0, 15, 14, 13, 12, 11, 10, 9, 8, 7, 6, 5, 4, 3, 2, 1};
(*mem) = (void *)(((char *)(*mem)) + skip[... |
8809a7a9dc351f3d9114aa74de0c2b4eaa4957cf0522013fbb7ee249558596c7 | f19fb74643d93723e8784e5eb0a6907136949ec340bec8eed3121502ec1dbdfa | 0.031777 | cpp | f19fb74643d93723e8784e5eb0a6907136949ec340bec8eed3121502ec1dbdfa | 565b41d7a0dceb8ad255473b7cf9cbe00965de98129bc8c66bca2495f93a2dbb | PIE_released_gem5_runtime | pie_57503 | p02799 | ed2501333c8ef336b3cf4b0b6940ad785af92f1bd4d24907063b7c74ebf65d81 | 565b41d7a0dceb8ad255473b7cf9cbe00965de98129bc8c66bca2495f93a2dbb | 0.184484 | 5.805633 | 4-8 | 05370f3cf574f4ee8e12321266db9cdd07a0182b5d7f20ae3fa27df327a90de6 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 200005, maxm = 200005;
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;
}
#define... | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = (a), _ed = (b); i <= _ed; ++i)
#define DREP(i, a, b) for (int i = (a), _ed = (b); i >= _ed; --i)
typedef long long ll;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (... |
b0a7be80d45489614aa23bb021dd469ff6a08d836821ea9a9db0ce63a3930d5b | 2b9231b27892794cac235222493f74ffa971082e388db64cf9ceb6c679c08546 | 0.019859 | cpp | 2b9231b27892794cac235222493f74ffa971082e388db64cf9ceb6c679c08546 | 9dd46793651ad37e280a4b00dac2fec705f2a50083470319f2849b7881b5b183 | PIE_released_gem5_runtime | pie_57526 | p04004 | ab779e2dabadcb9614a6af621c810dcbba09790cf3f41eda17b63b203308240b | 9dd46793651ad37e280a4b00dac2fec705f2a50083470319f2849b7881b5b183 | 0.061014 | 3.072336 | 2-4 | 1de5978bdaea75ca4e332cc4167082dc085f852e838571d47c14d39d8e31200c | #include <cstring>
#include <iostream>
#include <cstdio>
#include <cstdlib>
using namespace std;
typedef long long ll;
const int maxn = 900010, rhl = 1000000007;
int N, M, K;
ll jie[maxn], inv[maxn], mi[maxn];
inline ll qsm(ll a, int b)
{
ll ret = 1;
for (; b; b >>= 1, (a *= a) %= rhl)
if (b & 1)
... | #include <cstdio>
using namespace std;
typedef long long ll;
const int maxn = 9e5 + 5;
const int mod = 1e9 + 7;
int n, m, k, Q;
ll ans;
ll f[maxn], fac[maxn], inv[maxn], bin[maxn];
ll power(ll b, int k)
{
ll res = 1;
for (; k; k >>= 1, b = b * b % mod)
if (k & 1)
res = res * b % mod;
retur... |
b20c0d9fb0159424c72309cceca30fb3a75f2347665564c3b7675244ba54a567 | 9bcf1912cdf0d386bb27ec58d2d6924c18510d91802d4cb09f762d29835b2351 | 0.109624 | cpp | 9bcf1912cdf0d386bb27ec58d2d6924c18510d91802d4cb09f762d29835b2351 | 2bb529226fde1444e1ca57dde5cac27296c5858ba5b619ee0c7f4d3ea6451672 | PIE_released_gem5_runtime | pie_57562 | p02882 | 916a9908ce52e761a8f6d6feb3d743282c08cbcea0f76def4a5d8d36bc09fe33 | 2bb529226fde1444e1ca57dde5cac27296c5858ba5b619ee0c7f4d3ea6451672 | 1.186395 | 10.822375 | 8+ | 3c56e3a28d3e0a8f45ba1e4b36620a33062c8600c28f49756920bc2db7da4700 | #include <bits/stdc++.h>
using namespace std;
const long double PI = (acos(-1));
const long double EPS = 0.0000000001;
long double a, b, x;
long double f(long double a, long double b, long double theta) {
if (theta > PI / 2.0 - EPS)
return 0.0;
long double ret;
if (a * tan(theta) <= b)
ret = a * ... | #include "bits/stdc++.h"
#define rep(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
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 > ... |
710097c36b32ba0f3f0d0971ea5de81857a0e4a33e25e4a70f320f96c125ab23 | d56a8b1fc9b119b86fb9a51ddb0b6074ff68ce39c79468cef5248063be31c05e | 0.018892 | cpp | d56a8b1fc9b119b86fb9a51ddb0b6074ff68ce39c79468cef5248063be31c05e | 7ab9fb2d3784f8d90779f2f804f652661df0fbe741af188b5a42ff9e4ae7ae7b | PIE_released_gem5_runtime | pie_57582 | p03279 | c757b66545b41adb6abb241f3c372a3bc45fd1750e39dfcbc6e7cf229b1afd02 | 7ab9fb2d3784f8d90779f2f804f652661df0fbe741af188b5a42ff9e4ae7ae7b | 0.09853 | 5.215398 | 4-8 | 1cd0f1ae94f13ecdbe73b90c51c10d835330a2559bdd500673ae033d09055808 |
#include <bits/stdc++.h>
#define F first
#define S second
#define PB push_back
#define sz(s) int((s).size())
#define bit(n, k) (((n) >> (k)) & 1)
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int maxn = 1e5 + 10, mod = 1e9 + 7;
const ll inf = 1e18;
... | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#include <utility>
#include <functional>
#include <cmath>
#include <vector>
using std::min;
using std::max;
using std::swap;
using std::sort;
using std::reverse;
using std::random_shuffle;
using std::lower_bound... |
98f535f4071dc8cfd23419bdf5ca717b22d8ab5a2cabd2376ca8bf87d6788c15 | 3148d1c9473342714a337216ea6031a7930b11c970fe16af60cec53caa902ae0 | 0.019538 | cpp | 3148d1c9473342714a337216ea6031a7930b11c970fe16af60cec53caa902ae0 | 1e5d48a4973427a27096d2307822531d8109432d1826c162f448cb533fc48b32 | PIE_released_gem5_runtime | pie_57622 | p03850 | 55c37c95fa017b8c4c2bee52ea93bf783f43e0aad9bd93c0665ff966605a68f5 | 1e5d48a4973427a27096d2307822531d8109432d1826c162f448cb533fc48b32 | 0.360886 | 18.470517 | 8+ | 27fbf5b2813539dd81fbf781f7df2a63a639f7caedb0737225bdf9221da4a9ef | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 1e5 + 100;
int n, a[N];
char op[N];
LL f[N][3];
void cmax(LL &x, LL y) { x = x > y ? x : y; }
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
{
scanf("%d", &a[i]);
op[i] = '!';
if (i == n)
... | #include <cctype>
#include <cstdio>
#include <algorithm>
using i64 = long long;
int fetc() {
int c = getchar();
while (c ^ '-' && c ^ '+')
c = getchar();
return c;
}
int read() {
int x = 0, c = getchar();
while (isspace(c))
c = getchar();
while (isdigit(c))
(x *= 10) += c & 15, c = getchar(... |
323401e2eb2991bbfe7458b497e95636c6ba14b7a76e9d853ab597601fad3fab | 260b466c91d74dbf16d068eb26e6d20738c3a9da5f77b73037977bfec6bd37da | 0.018924 | cpp | 260b466c91d74dbf16d068eb26e6d20738c3a9da5f77b73037977bfec6bd37da | ec9f1bfe0bb526c8abb9d76e69bcfab960f7ebef58400636979349283d90523e | PIE_released_gem5_runtime | pie_57627 | p01136 | 21a71c6842189d460593fa45b9b4bdd9cda4799371ea8d1989c86decde5abed9 | ec9f1bfe0bb526c8abb9d76e69bcfab960f7ebef58400636979349283d90523e | 0.099904 | 5.279188 | 4-8 | 556be9b40719fbfed9343b6cc87e22e287de9b218aaee8b6cbb15cfb59e4106e | #include <iostream>
#include <vector>
using namespace std;
typedef long long STATES;
int main(void)
{
register int i, j;
int n;
while (cin >> n && n)
{
STATES goal_state = 0;
for (i = 0; i < n; i++)
goal_state |= 1LL << i;
vector<STATES> free_days(30 + 1, 0);
for (i = 0; i < n... | #include <cstdio>
#include <cstring>
using namespace std;
typedef long long STATES;
int main(void)
{
STATES free_days[31], dp[51];
STATES goal_state, next;
register int i, j;
int n, answer, free_day, k;
while (scanf("%d", &n) == 1 && n)
{
memset(free_days, 0, sizeof(STATES) * 31);
memse... |
f31183571400971688235c8152be7c985c9694da502fa020e522936fbb9874db | 76eb245d7bc46855918a796768524b5dda349f180a00f9c69e3aec373a34815a | 0.104433 | cpp | 76eb245d7bc46855918a796768524b5dda349f180a00f9c69e3aec373a34815a | d15b10e3e74b5536e018671517c0f283a2efbd48a728094e97819bf7787f511b | PIE_released_gem5_runtime | pie_57636 | p02272 | 008f0623d3bf5a9c0394f25945e16bec683c5369f8e0a0753b7398e4eefe4542 | d15b10e3e74b5536e018671517c0f283a2efbd48a728094e97819bf7787f511b | 0.316813 | 3.033643 | 2-4 | 42be846abe94ecc8bd0975ba8415b049e9fbea3d34dac4bc3952a0a521777ce6 | #include <iostream>
#include <string>
#include <algorithm>
#include <cstdio>
using namespace std;
const int INF = 1000000001;
const int MAX = 500000;
int cnt;
int L[1 + MAX / 2] = {0}, R[1 + MAX / 2] = {0};
void merge(int *A, int left, int mid, int right)
{
int n1, n2, n, i, j;
n1 = mid - left;
n2 = ... | #include <iostream>
using namespace std;
const int INF = 1000000001;
const int MAX = 500000;
int cnt, N;
int S[MAX] = {0}, L[1 + MAX / 2] = {0}, R[1 + MAX / 2] = {0};
void merge(int *A, int left, int mid, int right)
{
int n1, n2, i, j;
n1 = mid - left;
n2 = right - mid;
for (int i = 0; i < n1; i++)
... |
2147bfb0014346ea8c7139b4d285ccf3facdd5ca221beb60c157a542064ce6e4 | 941bec10d11020ad3d40c5e5d7fb1485405500a9f90dba5bf026316e991627c8 | 0.016799 | cpp | 941bec10d11020ad3d40c5e5d7fb1485405500a9f90dba5bf026316e991627c8 | ea21d7e603d748a03fffa7aeefcd60ce28b4e722386fb6b9a91e8d0db58cd2b6 | PIE_released_gem5_runtime | pie_57648 | p03026 | 596f3972e83eb710c09ae9646fcb93a0d96a0932f2b6f7ab43e91da4aafbd03f | ea21d7e603d748a03fffa7aeefcd60ce28b4e722386fb6b9a91e8d0db58cd2b6 | 0.114019 | 6.787136 | 4-8 | 42f7ef0f2984501ce00a1a4a63d807d173ea6a3e9229720b62425fe282edcae8 | #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... | #include <cstdio>
#include <algorithm>
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) ... |
6a887a60e12db6f0e2dd2821e9dccb6549096af93f45a306550e20fa587f0ae1 | 45061dd3bac2d1b74c5f63abab349ec42fb4536046fffd3c71388852a7d36322 | 0.086326 | cpp | 45061dd3bac2d1b74c5f63abab349ec42fb4536046fffd3c71388852a7d36322 | b7ea2a6851680fd624bcaa1bf5fb2001a80c641d19ea7368c40ca2d0e46d68dd | PIE_released_gem5_runtime | pie_57664 | p02754 | d2cb0f5ad5fb388b26c822c20abb5ca9a38060576379006f3c19935cb35f9bd9 | b7ea2a6851680fd624bcaa1bf5fb2001a80c641d19ea7368c40ca2d0e46d68dd | 0.224279 | 2.598054 | 2-4 | 1c5007692b89724a50e1dc32bbe7a66aa471f3b730a2412970971fffbc9cba88 | #include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <s... | #include <iostream>
#include <cstdio>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <iomanip>
#include <stdlib.h>
#include <string.h>
#include <cstring>
#include <cmath>
#include <map>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <s... |
2c557cbc4d89ba79d92cfe03caf6a7478f414a8682e385b61ba9b5aa5f052bdc | 8bfbb78b00d639dc2c43e74b2edbb3eaf5b0356f35a75829a648f9c287ba456a | 0.078328 | cpp | 8bfbb78b00d639dc2c43e74b2edbb3eaf5b0356f35a75829a648f9c287ba456a | f950a2c04d6bf53a386e1e04156c4c09ebdec1c688a549e5b57a320fa453f9d1 | PIE_released_gem5_runtime | pie_57704 | p04022 | 0ff221712c7ac5d02fc3ccad09194cf06e28c7a355a23424b5d4e024b4fdb005 | f950a2c04d6bf53a386e1e04156c4c09ebdec1c688a549e5b57a320fa453f9d1 | 0.164227 | 2.096666 | 2-4 | f1bde23318eaf2c48484fdbfabfe32350228c46548f502a3f7801d5aa0e1dbd4 | #include <bits/stdc++.h>
#ifndef LOCAL
#pragma GCC optimize(3)
#define lld "%lld"
#else
#define lld "%I64d"
#endif
using namespace std;
typedef long long ll;
const int inf = 0x3f3f3f3f;
const int maxn = 1e5;
ll p[maxn];
bool vis[maxn];
map<ll, int> cnt;
int pCnt;
void init() {
for (int i = 2; i < maxn... |
#include <ext/pb_ds/hash_policy.hpp>
#include <ext/pb_ds/assoc_container.hpp>
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <cstring>
#include <cmath>
#define X first
#define Y second
#define ls rt << 1
#define rs rt <... |
f7e4ada838778c0e51c85f65585807d5d6b48e31f07cf50887bd31618b2d6438 | 09047c212519c8dc25434e71405a2693352822632c91fb3bd39d1d4af06b8a62 | 0.001341 | cpp | 09047c212519c8dc25434e71405a2693352822632c91fb3bd39d1d4af06b8a62 | 5f4b4a4ea24e27b802b17cd0d8be76c2f8e69a11ae7834547431e0cb4d6cb286 | PIE_released_gem5_runtime | pie_58057 | p03116 | 11892965b8459496d5e1c289d46a6d962c151d25dcfd20f46a66ba07638d4cf0 | 5f4b4a4ea24e27b802b17cd0d8be76c2f8e69a11ae7834547431e0cb4d6cb286 | 0.010175 | 7.585892 | 4-8 | b4448c9cc538eaa7f4dd0a89a7666ae22b7af9021dbeacf1eb9ff1ddbdbed436 | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
#include <set>
#include <queue>
#include <stack>
#include <bitset>
#include <functional>
#include <map>
#include <iomanip>
#include <limits>
#include <unordered_set>
#include <cmath>
#include <numeric>
#include <array>
#include... | #include <bits/stdc++.h>
using namespace std;
#define V vector
#define L long long
#define W V<L>
#define R(n) for (L i = 0; i < n; i++)
W S(V<W> p, L E) {
if (!E) {
return {1, 0};
}
V<V<W>> T(2);
for (W x : p) {
T[x[1] & 1].push_back({x[0] / 2, x[1] / 2});
if (x[0] & 1) {
T[(x[1] + 1) &... |
1a76b766d8be0e5b4c2bdf29e3fc4f10c7bdfbf1874ec0a247185b516603bdc3 | 4bf471366fc6adc2e241196a0a06642fd428e1180b7001dc9736eae1c97c21eb | 0.019886 | cpp | 4bf471366fc6adc2e241196a0a06642fd428e1180b7001dc9736eae1c97c21eb | 64109e26ece424bb9542e0b4ca38855f6d6761dcd5297dff745ab2695c207c04 | PIE_released_gem5_runtime | pie_58288 | p02962 | 3b33562cfe91307d2325fa95ad1c71e7afd0a04f93615f493e1e80c481cf67da | 64109e26ece424bb9542e0b4ca38855f6d6761dcd5297dff745ab2695c207c04 | 0.307544 | 15.465099 | 8+ | 0e4e78fb3d4d3a2f7af60638f1a6020f03dd4c8e58d051892cdaf63fbc2941fd | #pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <stdio.h>
#include <cstdio>
int v[2000001];
char s[2000001], t[500002];
void Zalgorithm(int N) {
int i = 1, j = 0, k = 0;
while (i < N) {
while (i + j < N && s[i + j] == s[j])
++j;
v[i] = j;
... | #pragma GCC target("avx")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <stdio.h>
#include <cstdio>
int v[1500001];
char s[1500001], t[500002];
void Zalgorithm(int N) {
int i = 1, j = 0, k = 0;
while (i < N) {
while (i + j < N && s[i + j] == s[j])
++j;
v[i] = j;
... |
4dce570a900b16e163f4112dea77f4ced2936171c39c2856f48a2e777037856e | c6d8a15420329aefe15224a52f5f400ae532f231c86f9503706647b839fd5c6a | 0.019711 | cpp | c6d8a15420329aefe15224a52f5f400ae532f231c86f9503706647b839fd5c6a | 5fa62d75f0b4acc03ffcf36e74f8ee5954825f19f90bc338c6c3b187ab57e3af | PIE_released_gem5_runtime | pie_58301 | p03858 | 470f92271c38b9195c492f1c18516d9cea313a8822c3296fc3ef7f3f37fefe31 | 5fa62d75f0b4acc03ffcf36e74f8ee5954825f19f90bc338c6c3b187ab57e3af | 0.228507 | 11.592689 | 8+ | 275b619789d4d88575b46b81aa27b13ac6e0c6d9707472f8ca1fe1cccfa133af | #include <iostream>
#include <algorithm>
#include <vector>
#include <set>
#include <map>
#include <queue>
using namespace std;
const int MAXN = 100005;
struct Point
{
int x, y, id;
Point(int _x = 0, int _y = 0, int _id = 0)
{
x = _x;
y = _y;
id = _id;
}
};
struct Node
{
int v, id;
... | #include <algorithm>
#include <cstdio>
using namespace std;
const int N = 100010;
int n, x, y, len;
long long ans;
int a[N][2];
int idx[N], idy[N];
bool fx[N * 4], fy[N * 4];
int d[N];
bool bz[N];
int dis(int x, int y, int xx, int yy) { return max(abs(xx - x), abs(yy - y)); }
void build(int l, int r, int s)... |
d32c321ca569fee0ca8beef49e46df9485514f7b4281b1762f7d0dadbc0f83c1 | 538ffa49e8e265b6b6eb95d26ae96480bbf4ecc1f839a6e098636e95ec838b2d | 0.07356 | cpp | 538ffa49e8e265b6b6eb95d26ae96480bbf4ecc1f839a6e098636e95ec838b2d | 5a459807bc6282b8b97122add067bcca692c25800596014494172af1a7d8426d | PIE_released_gem5_runtime | pie_58313 | p02348 | 5f02ea0246a9c45ea28247f60d705e9500a0e757d94937f8affa0e91f5b84d1c | 5a459807bc6282b8b97122add067bcca692c25800596014494172af1a7d8426d | 0.22865 | 3.108335 | 2-4 | 4244b3f5c5f63bfa2d1dedfb1cf02ba5bd022997467f31bdbb3ae1f4dee5524e | #include <iostream>
using namespace std;
#define INF 2147483647
#define ASTART (1 << 17)
int a[1 << 18][2];
int ti = 1;
int find(int i) {
int nv = INF, t = 0;
i += ASTART - 1;
nv = a[i][0];
t = a[i][1];
while (i > 0) {
i = (i - 1) / 2;
if (t < a[i][1])
nv = a[i][0], t = a[i][1];
}... | #include <iostream>
using namespace std;
#define INF (1 << 30) - 1 + (1 << 30)
int a[262144], n2, lazy[262144];
void lazyeval(int i) {
if (lazy[i] == INF)
return;
a[i] = lazy[i];
if (i < n2 - 1) {
lazy[2 * i + 1] = lazy[2 * i + 2] = lazy[i];
}
lazy[i] = INF;
}
int findsingle(int i) {
int ... |
3a0d3febdfb1051d344afd9fe19883cf9634766a292b644de888be37e8fa64d8 | 3fc19ef41b8d4bb8c36dd4a7ce0e867ea5e1c8f405344a79e1057bfe153bb6a7 | 0.001034 | cpp | 3fc19ef41b8d4bb8c36dd4a7ce0e867ea5e1c8f405344a79e1057bfe153bb6a7 | a93757b2a9861ecf88933802a5aa0fc4376794fea00502367d04d471fa6fa97e | PIE_released_gem5_runtime | pie_58315 | p03763 | 025d2676269b2bc1f717cca87fef33638c47b649e3d19e5dad32787f5489c811 | a93757b2a9861ecf88933802a5aa0fc4376794fea00502367d04d471fa6fa97e | 0.004482 | 4.334911 | 4-8 | 3394f5f3d8b6c827427977b9ea88d522c18d802181a6b914ec8d0ea8fe954b01 | #include <bits/stdc++.h>
#define ll long long int
#define sz 100100
using namespace std;
string ss[sz];
string tani(ll n, char ch)
{
ll i;
string s = "";
for (i = 1; i <= n; i++)
s += ch;
return s;
}
int main()
{
string s = "abcdefghijklmnopqrstuvwxyz";
ll i, j, k, p, x, d, c, a, b, n;
... | #include <bits/stdc++.h>
using namespace std;
string s;
struct node
{
int a[26];
node()
{
memset(a, 0, sizeof(a));
}
};
node d[52];
int main()
{
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t, i, j, n, m, l, r;
cin >> n;
for (i = 0; i < n; i++)
{
cin >> s;
... |
9644dc5b977ed3202574ff0f0c4a99f76abe3a96934c18aa2ee1c811fbb1aac7 | 3aa42b0c8b731f887f0f81225dc14526e670eea1cd8c1cf137f54e92291759ac | 0.02325 | cpp | 3aa42b0c8b731f887f0f81225dc14526e670eea1cd8c1cf137f54e92291759ac | 94e06203813454b0635be68e03f5ac5eae9a3f11438ee411d4095f2f3dfe551a | PIE_released_gem5_runtime | pie_58317 | p03428 | 5a6a10d4ccde86dff59255264b12c1fc256e3d5b8567a0590a9b78e9ad3ed761 | 94e06203813454b0635be68e03f5ac5eae9a3f11438ee411d4095f2f3dfe551a | 0.106332 | 4.573363 | 4-8 | 422aafaf2ab3c0c17cfd6f44594c29236f674ca444867f215e218e675dbf2c6d | #include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.);
const int N = 105;
int n, x[N], y[N];
double p[N + N];
signed main()
{
cin >> n;
for (int i = 0; i < n; i++)
cin >> x[i] >> y[i];
for (int i = 0; i < n; i++)
{
int tot = 0;
for (int j = 0; j < n; j++)
if (... | #include <cstdio>
#include <cmath>
#include <algorithm>
using namespace std;
const double pi = acos(-1);
int n, x[101], y[101];
double p[201];
int pp;
double Max(double a, double b) { return a > b ? a : b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d%d", &x[i], &y[i]);
fo... |
2dcb0d8465d19504b71e79072507549b319b29ed54167814f2a3aac475bc1062 | 5a468af218044f410f68a0e11a8c5a40419c2d71eff269fa2304af19ed24c90b | 0.082902 | cpp | 5a468af218044f410f68a0e11a8c5a40419c2d71eff269fa2304af19ed24c90b | 8d0f4b5b354105bf55007c8fda712e03d2387f80fdd753f85f735be6111604ab | PIE_released_gem5_runtime | pie_58345 | p02626 | 5be0379a3c425ea592d843d6d8cea368f1118446625f128d2835f2181ca4d322 | 8d0f4b5b354105bf55007c8fda712e03d2387f80fdd753f85f735be6111604ab | 0.180277 | 2.174587 | 2-4 | 1e90eb622f98a525e95f1e21f33299f773f61cddfd24c66efa6440e2958b2a48 | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) std::cout << ((f) ? "Yes" : "No") << endl;
#define YORN(f) std::cout << ((f) ? "YES" : "NO") << endl;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define repi(i, n) for (int i = 1; i < (int)(n); i++)
#define all(x) ... | #include <bits/stdc++.h>
#define ll long long int
#define ld long double
#define yorn(f) std::cout << ((f) ? "Yes" : "No") << endl;
#define YORN(f) std::cout << ((f) ? "YES" : "NO") << endl;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define repi(i, n) for (ll i = 1; i < (ll)(n); i++)
#define all(x) (x).... |
f19ceba7afdee7a8263ac58909885d66b78aa92209826ad107c19669fe6e7417 | 0f272d5b617334f7ac1cb1b27dcd6b811c071d50efb0d4954dc43f5ab063fc77 | 0.000194 | cpp | 0f272d5b617334f7ac1cb1b27dcd6b811c071d50efb0d4954dc43f5ab063fc77 | 8169ef0d7fef6c07ef04f3ff3d4a8ec03c57102ab9b628fe91464b9e15c5157f | PIE_released_gem5_runtime | pie_58356 | p03379 | 1ce8ae7a66e1bf03913cd24beea62600fc994f4a54328f2bba43a905775d2a72 | 8169ef0d7fef6c07ef04f3ff3d4a8ec03c57102ab9b628fe91464b9e15c5157f | 0.002709 | 13.984984 | 8+ | 01ca7eb7ae8a9d2b80f423d445487b9430d6c05fc0cde6eb57fb4f49d813537d | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ld long double
#define pii pair<int, int>
#define pll pair<ll, ll>
#define rep(n) for (int i = 0; i < n; i += 1)
#define prarr(a, n) rep(n) cout << a[i] << endl printf("%s\n", " ");
#define sc(a) scanf("%d", &a);
#define scl(a) scan... | #include <stdio.h>
#include <stdlib.h>
int a[200005], temp[200005];
int inc(const void *a, const void *b)
{
return *(int *)a - *(int *)b;
}
int main()
{
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
for (int i = 0; i < n; i++)
temp[i] = a[i];
qsort(a, n, sizeof(... |
0e532df2fe57d5169439f97bfc5bda4be06f68b2ed9985219f5608750feeaada | 6212a45d9d55349c691206b573d80af7472c77867d73c2f02b4227755bf12134 | 0.108582 | cpp | 6212a45d9d55349c691206b573d80af7472c77867d73c2f02b4227755bf12134 | 4dae1dc4da5afe657eb364c8f2522e409c884a760550b54b8e35982dea22e3dc | PIE_released_gem5_runtime | pie_58372 | p03309 | 32c1c7c878587f40bc2d58630da5b5d3557512e957c7d7794db2bf085eef9e3f | 4dae1dc4da5afe657eb364c8f2522e409c884a760550b54b8e35982dea22e3dc | 0.282975 | 2.606089 | 2-4 | 102fe384f70da1a39af7a53d568bf984f1b794b874815d0becfafbcd1aab62a5 | #include <bits/stdc++.h>
using namespace std;
const long long int INF = 1000000000000000000LL;
using ll = long long int;
using vi = vector<int>;
using Vi = vector<long long int>;
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rep(i, N) for (int i = 0; i < N; i++)
auto max(auto x, auto y) {
... | #include "bits/stdc++.h"
using namespace std;
const long long int INF = 1LL << 60;
const long long int Mod = 1000000007;
using ll = long long int;
using ci = const int;
using vi = vector<int>;
using Vi = vector<long long int>;
using P = pair<int, int>;
using PLL = pair<ll, ll>;
using matrix = vector<vector<ll>>;... |
a919d0fd3242a8ba6f5a544fb86c2663f3b829970ed267165fbb263606413b9d | ac4bd8ebb89797967f5a663fb89e0c2b5cce13f8b77c8ea9ac3f7372836ec62a | 0.105149 | cpp | ac4bd8ebb89797967f5a663fb89e0c2b5cce13f8b77c8ea9ac3f7372836ec62a | 83ddbb4c7dedf37b57651c8bf97aea49f40020d9f8d06288ec1da55bfafcbc27 | PIE_released_gem5_runtime | pie_58402 | p03653 | d43946194a874cf6a75776460d1b104e455710845f3dbc5a89d306b4a2772f57 | 83ddbb4c7dedf37b57651c8bf97aea49f40020d9f8d06288ec1da55bfafcbc27 | 1.176494 | 11.188864 | 8+ | 504cb0949ee6302cdbb2bc1d9432d5cdde8c1d359f892be8cd858569aafaa946 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 10;
const long long inf = 1e16;
long long pre[maxn], suf[maxn];
struct data {
int a, b, c;
data() {}
bool operator<(data d) const { return b - a < d.b - d.a; }
} arr[maxn];
int t[maxn * 4];
long long sum[maxn * 4];
int rev[maxn];
in... | #include <bits/stdc++.h>
using namespace std;
inline long long read()
{
long long x = 0, f = 1, c = getchar();
while (c < 48)
c == '-' && (f = -1), c = getchar();
while (c > 47)
x = x * 10 + c - '0', c = getchar();
return x * f;
}
typedef long long ll;
const ll MAXN = 100005;
struct Node {
l... |
96d170d5ddc0e4497c411b79cab8adceebe88dae9b256b08687a417998a4d12d | 5da9eb7b2eb71e6eda5381a0cbfd52821da20817ca7039b7220d43b31c45411e | 0.019935 | cpp | 5da9eb7b2eb71e6eda5381a0cbfd52821da20817ca7039b7220d43b31c45411e | c80f3e3df072500ae597967c77b40385cbc4b296ddf8dd301cb4bad51ed0cd22 | PIE_released_gem5_runtime | pie_58443 | p03940 | 3ad525d87dfd7864d4e492f4507f28354b7029b38bb12fefbbb1e0a65c62fa4d | c80f3e3df072500ae597967c77b40385cbc4b296ddf8dd301cb4bad51ed0cd22 | 0.906188 | 45.456469 | 8+ | 7a3bdf790dda2e3778714d7b91d27ba1b71ba879d01e4250fab8545f3fd2f787 | #include <bits/stdc++.h>
#define N 111111
#define M 444444
#define LL long long
using namespace std;
int n, i, k, j, a[N];
LL f[N], V1[M], V2[M], E, T;
void ins(int k, int l, int r, int x, LL z1, LL z2) {
if (l == r) {
V1[k] = z1;
V2[k] = z2;
return;
}
int md = l + r >> 1;
if (x <= md)
... | #include <cmath>
#include <cstdio>
#include <algorithm>
#define ll long long
using namespace std;
const int maxn = 100000 + 10;
ll f[maxn], xx[maxn];
ll n, e, t;
ll store;
int main() {
ll b1, b2, b3, b4;
ll p;
scanf("%lld%lld%lld", &n, &e, &t);
for (b1 = 1; b1 <= n; b1++) {
scanf("%lld", &xx[b... |
c569c092694aff2493729559379bcb27e88ae09c71cde7e72a28426be81cddfe | a76876655d6a02bc4f898de143486bcae482c59c002455368f7f95cb4b93d593 | 0.106034 | cpp | a76876655d6a02bc4f898de143486bcae482c59c002455368f7f95cb4b93d593 | 8c998c8212be7887e4ca371d0b486955d0d7376930f29715338be4753fd49223 | PIE_released_gem5_runtime | pie_58612 | p00748 | 6b94a1c9297d5bd2064ca2c8de65157afa62f05cef5285d9569280226c163496 | 8c998c8212be7887e4ca371d0b486955d0d7376930f29715338be4753fd49223 | 0.918027 | 8.657837 | 8+ | 8737759fa9300ad65b854d5d52f72e1b3cc3c3d4b82a3674f13b6089dda515f4 | #include <stdio.h>
#define N 1000000
int all[N + 1], odd[N + 1];
int pollock[1000];
int num;
int BackTrack(int n, int type) {
int i, tmp, ans = N + 1;
if (type && odd[n] <= N)
return odd[n];
if (!type && all[n] <= N)
return all[n];
for (i = num - 1; i >= 0; i--) {
if (pollock[i] > n)
... | #include <iostream>
#include <vector>
using namespace std;
int m;
int f(int n) { return n * (n + 1) * (n + 2) / 6; }
vector<int> l1, l2;
void r(int n, int step, vector<int> &l, int p) {
if (step + 1 >= m)
return;
for (int i = p; i >= 0; i--) {
int n2 = n - l[i];
if (n2 < 0)
continue;
... |
861cde84b93a809842c3c46b1c814d7c5578279ab9bd2c35a4560d88e8796f7b | 185ec0143560c80ae4ba4b801a54dd67b60c8ee9a206ab0d271846604279d8ea | 0.013204 | cpp | 185ec0143560c80ae4ba4b801a54dd67b60c8ee9a206ab0d271846604279d8ea | 1b67e0d33f74cd06d18c9d8be99add4652c97cdf604c774aea5d3178e50d4ed9 | PIE_released_gem5_runtime | pie_58620 | p03776 | cab902e88850f6492a85f65d39351d1bd368845677c8f868f50ec558be571c09 | 1b67e0d33f74cd06d18c9d8be99add4652c97cdf604c774aea5d3178e50d4ed9 | 0.09065 | 6.865601 | 4-8 | 4a664f5c4db69b0b4ffdd626cec69a8f26ec319cee9c49abf2b93a2923c2de5d | #include <bits/stdc++.h>
using namespace std;
long long dp[300][300], sum[300][300];
long long a[300];
long long n, l, r;
int main()
{
for (int i = 0; i <= 200; i++)
{
sum[0][i] = 0;
sum[i][0] = 1;
sum[i][i] = 1;
}
for (int i = 0; i <= 200; i++)
{
for (int j = 0; j <= 200; j++)
... | #include <stdio.h>
#include <stdlib.h>
#include <math.h>
#include <algorithm>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
ll v[55];
typedef struct Node {
ll val = 0;
int sum = 0;
} node;
node s[55];
ll dp[55][55];
ll C(int n, int m);
int main(void)
{
int n = 0, N, a... |
53411df039e315d4089185bd6cfa57475dd05623ce689473789c137590e07be7 | fc8d2a97326de273dec6261af0715477d404de4e06ef6f6fb423b4234b9af821 | 0.02879 | cpp | fc8d2a97326de273dec6261af0715477d404de4e06ef6f6fb423b4234b9af821 | dc4c89abd3f12dfbb4f36fcbf3d76a5207210ee2fae4ec4c1fc50ed7ef4df04a | PIE_released_gem5_runtime | pie_58673 | p00439 | 0cb5f3b9543473511376e2724e21c750aa6fa7e3a2ac4e53b349cf5a64968f1b | dc4c89abd3f12dfbb4f36fcbf3d76a5207210ee2fae4ec4c1fc50ed7ef4df04a | 0.113221 | 3.932588 | 2-4 | 72b95fd9fee82a865b700d0a8ea555804b2fb439c657662ce9d44f912ffb8e8d | #include <iostream>
#include <algorithm>
using namespace std;
int main() {
int n, k;
int a[1000000];
for (;;) {
cin >> n >> k;
if (!n && !k)
break;
for (int i = 0; i < n; i++)
cin >> a[i];
int sum = 0;
for (int i = 0; i < k; i++)
sum += a[i];
int m = sum;
... | #include <cstdio>
#include <algorithm>
using namespace std;
int main() {
int n, k;
int a[1000000];
for (;;) {
scanf("%d %d", &n, &k);
if (!n && !k)
break;
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
int sum = 0;
for (int i = 0; i < k; i++)
sum += a[i];
int... |
ff3b8b9ad9abe0df3784018d89a4ecb5de0df1de79af5338a65e71fc27fc562b | 6379cfcd2a6c7d85f07c73fd35a90bc2ce738de3ba9109c3e0366b32a5547c1c | 0.025092 | cpp | 6379cfcd2a6c7d85f07c73fd35a90bc2ce738de3ba9109c3e0366b32a5547c1c | f3c70ccad2a2d97b848f3ade3d51d7180d540a277c8a319c059370774b86b48a | PIE_released_gem5_runtime | pie_58680 | p03426 | b902adc4dec3b63c818b79457ff14e5ee315c2b1457cf50f9d61600d0e1ebc84 | f3c70ccad2a2d97b848f3ade3d51d7180d540a277c8a319c059370774b86b48a | 0.08024 | 3.197759 | 2-4 | 7b166b1d8ddbe65fa549a92273260e5979a6ad539d02c0f5817f16ec1a6ae019 | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define INF 1000000000000000000
int main() {
int H, W, D, Q;
cin >> H >> W >> D;
vector<vector<ll>> A(H, vector<ll>(W));
v... | #include <algorithm>
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(x) (x).begin(), (x).end()
#define ll long long
#define ld long double
#define INF 1000000000000000000
typedef pair<ll, ll> pll;
typedef pair<int, int> pint;
int main() {
cin.t... |
f90da7066ab317c5edae486ae5bddecc06916488e601b7e4888047d0bdabadb0 | 21d84f873af27de7629ac70c410cecea953b87e9dd7524370947c5a18882946b | 0.06719 | cpp | 21d84f873af27de7629ac70c410cecea953b87e9dd7524370947c5a18882946b | 8be41fe400ea49bd0f4669e69bb19e8031b659766a7a44c2075b8bb30ade9523 | PIE_released_gem5_runtime | pie_58707 | p03472 | e37c406ff13a240d7fa42369d2abd51f617ade53f9717334f1c444c7c77e6316 | 8be41fe400ea49bd0f4669e69bb19e8031b659766a7a44c2075b8bb30ade9523 | 0.635106 | 9.452439 | 8+ | 1adf388e3b77f0fae0cc274b64607e606c78d47735f28d04bc278e9b9f035e50 | #include <iostream>
#include <cstdlib>
#include <iomanip>
#include <cmath>
#include <string>
#include <cstring>
#include <algorithm>
#include <vector>
#include <sstream>
#include <set>
#include <queue>
#include <stack>
#include <cctype>
#include <map>
#include <climits>
#include <bitset>
using namespace... | #include <bits/stdc++.h>
using namespace std;
struct p
{
int l;
int r;
} a[1000000];
bool cmp(p xx, p yy)
{
return xx.l > yy.l;
}
int main()
{
int n, h, wsq = 0;
;
int c = 0;
cin >> n >> h;
for (int i = 1; i <= n; i++)
{
cin >> a[c++].l;
a[c].r = 1;
cin >> a[c++].l;
}
... |
a3f38c6880f80a20493a104e294682cced67ef87e8278c02d2c05f5c4e7adb05 | 1521d58cdc865e516b04f364ecbfbcc5391e4b3e0efce47f8bc65b7f55c68f6a | 0.056144 | cpp | 1521d58cdc865e516b04f364ecbfbcc5391e4b3e0efce47f8bc65b7f55c68f6a | 4be494da376e87850c5753eb7f28ad5ba7ef120fef6cd9d4fecdcb54a64c3101 | PIE_released_gem5_runtime | pie_58718 | p03230 | f1568246bc0f976b4125b8408778f43bcf5ae027e0648c7384b1b06a54ca3159 | 4be494da376e87850c5753eb7f28ad5ba7ef120fef6cd9d4fecdcb54a64c3101 | 0.189 | 3.366347 | 2-4 | ae884b1415f4bb8168f6318dcacb39fae4506d8c3fb644f3de179f5bd21e1dfb | #include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for (int i = a; i <= b; i++)
#define rf(i, a, b) for (int i = a; i >= b; i--)
#define pf push_front
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(... |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define FAST std::ios_base::sync_with_stdio(false)... |
0ea7a27e75d0774553796cf70f9cbe69a81d33ebce0cae87219633b1fe6845ff | 715b1d8b7f053e4799d69e43b26e0a79764c415981e80addcfac63acf26d895d | 0.018487 | cpp | 715b1d8b7f053e4799d69e43b26e0a79764c415981e80addcfac63acf26d895d | 3c638743c8e4a94d721a00b6d1a0e9fad95795fa39353c436b5bab1f2ffb611e | PIE_released_gem5_runtime | pie_58731 | p03442 | d8eed3bfc728c1a05ddac35bdb783e01ab6e08e24a07c5f3c9a5aafdde7a90ff | 3c638743c8e4a94d721a00b6d1a0e9fad95795fa39353c436b5bab1f2ffb611e | 0.512081 | 27.699898 | 8+ | 4deb913157992e2870c18c01bb058b9b17ad8ae8a3cff318170cc39d2efd8806 | #include <bits/stdc++.h>
using namespace std;
int n;
const int N = 100010, M = 16;
int s[N], cnt[M], ans, f[1000010];
void chkmin(int &x, int y)
{
if (y < x)
x = y;
}
int gi()
{
int f = 0;
char ch = getchar();
while (ch < '0' || ch > '9')
ch = getchar();
while (ch >= '0' && ch <= '9')
... | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <ctime>
#define INF 1e9
using namespace std;
const int maxn = 100010;
const double Pi = acos(-1.0);
template <class T>
void read(T &x)
{
x = 0;
int f = 0;
char ch = getchar();
while (ch < '0' || c... |
494ae74515f2e1bc85d84c0ee45cb8007dd82fa19fc5740d4bbf85cb43e82999 | 40e15cd23416b34b8af4649cf46bb2161399b5df2d954f30fdfd3a2b36134517 | 0.108359 | cpp | 40e15cd23416b34b8af4649cf46bb2161399b5df2d954f30fdfd3a2b36134517 | 0ddae31654fcc61c95ce3b3e73fb306a1e0a6b3448000e7bfec06e7f797075db | PIE_released_gem5_runtime | pie_58774 | p02720 | 7c124bb0ab740f2529ef0b4e4b8cb9b4f69f2e815b57c9a869b1473874a88fdd | 0ddae31654fcc61c95ce3b3e73fb306a1e0a6b3448000e7bfec06e7f797075db | 1.093191 | 10.08865 | 8+ | 7d96ad58eef0a7a14f59ac956027b88a77d94431ae60d071da80444139610fa9 | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_type>
using smalle... | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;
const int MOD_TYPE = 2;
const ll... |
51d85c54b5d32a15f3306d74202595aa414ca12ebea92eabcaee242c93cda454 | 93e4fc30f42a78f0abd64c131851a823fa43c5d4c0a444560f8b5ec034366a54 | 0.017239 | cpp | 93e4fc30f42a78f0abd64c131851a823fa43c5d4c0a444560f8b5ec034366a54 | 750707d62f4d085111a2d0d8e5f27c935f2d312c2ae22d4220caed54f1a1c99d | PIE_released_gem5_runtime | pie_58785 | p03181 | cdf77062ee32ef991b415a9c9d584979f33899d4733a69a36b565633d227ae0b | 750707d62f4d085111a2d0d8e5f27c935f2d312c2ae22d4220caed54f1a1c99d | 0.830115 | 48.152854 | 8+ | 12451f8b335c8db0360df5b480414b0fe1a9618025b335031c2aac867032e166 | #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 << (... | #pragma GCC optimize("O3")
#pragma GCC target("avx")
#include <cstdio>
#include <vector>
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(... |
9ac6fb180e17e3a505a96e61c03890e4d7a0a48484f4f8b57af329b09aa41aeb | cd7f6cf35c5dbac5d6269e236625d5109ee550455d4dfb41abcb2efe431685b2 | 0.048455 | cpp | cd7f6cf35c5dbac5d6269e236625d5109ee550455d4dfb41abcb2efe431685b2 | 954e16a9aa59e7475a6f76bc965484b7ea2b68ebef9effbc13c8104d0058be1d | PIE_released_gem5_runtime | pie_58823 | p03643 | 2d27179b367ae39bbe55ddbd7f5fd8ecbb001dbad0a1b60e2c9214606dc9fe8f | 954e16a9aa59e7475a6f76bc965484b7ea2b68ebef9effbc13c8104d0058be1d | 0.169595 | 3.500049 | 2-4 | 3506c11709616ff49d1c964d5516ed9a60d0f289453589e9ca72a762f7833ca2 | #include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define inf (int)(3e18)
#define int long long
#define mod (int)(1000000007)
#define intt long long
using namespace std;
int modpow(int x, int y, int m = mod) {
int res = 1;
while (y) {
if (y % 2) {
res *= x;
res %= m;... |
#include <bits/stdc++.h>
#define f(i, n) for (int i = 0; i < (n); i++)
#define inf (int)(3e18)
#define int long long
constexpr int mod = 998244353ll;
#define intt long long
#define itn long long
#define P pair<int, int>
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(i, n) for (int i = 1; i <= n; i... |
1d0d5437f071f522db25a4123a4326111b204f410e08c0bfc86d9387c8b68326 | 7082f15cc8376e822c84eb7a9dc230bdad489d584ed4f5f0653d129b10eba7c3 | 0.0654 | cpp | 7082f15cc8376e822c84eb7a9dc230bdad489d584ed4f5f0653d129b10eba7c3 | 75e462a2c1a256c0bff300b9daca22a4570e04aebb1b152eb6ba523ae2c63eb5 | PIE_released_gem5_runtime | pie_58833 | p03508 | 7eab27f0ce8d078fbb70975fe925d902281c5181c65d6ff5b2c96b0a16c521c2 | 75e462a2c1a256c0bff300b9daca22a4570e04aebb1b152eb6ba523ae2c63eb5 | 0.233548 | 3.5711 | 2-4 | ab068a5dce734982558ecd1f31f84b07c71ee687a08a6de53b035bc0ae86a654 |
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <deque>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <math.h>
#include <stdlib.h>
#include <map>
#include <set>
#include <time.h>
#include <bitset>
#include <list>
#include <asser... |
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <deque>
#include <string>
#include <string.h>
#include <vector>
#include <stack>
#include <queue>
#include <math.h>
#include <stdlib.h>
#include <map>
#include <set>
#include <time.h>... |
6b94053630044cfaafcced5b7257606c350a94f35542f0b40beee15b369f8e55 | 7915273535a825f4a005d89bd5b9f6cbe5c01a23465dfd888bbf16abd0e414b4 | 0.1082 | cpp | 7915273535a825f4a005d89bd5b9f6cbe5c01a23465dfd888bbf16abd0e414b4 | e00e657e5347067075efa79a92173add236e4df8a113717e9f3c295d9360df47 | PIE_released_gem5_runtime | pie_58847 | p02691 | efa5fa516f6a1ad1f365112baad7376818045eecb6f1f8eae7781b34230831c9 | e00e657e5347067075efa79a92173add236e4df8a113717e9f3c295d9360df47 | 0.304921 | 2.818125 | 2-4 | 1ac0b4f79a4a273b6ce280e3df9336a03c1765830fce2050abdd3901544f7eba | #include <cstring>
#include <iostream>
#include <vector>
#include <map>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long int64;
int P[400000];
int M[200000];
int main() {
memset(P, 0, sizeof(P));
memset(P, 0, sizeof(M));
int N;
cin >> N;
int tmp;
int64 an... | #include <cstring>
#include <iostream>
#include <vector>
#include <map>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
typedef long long int64;
map<int, int> P;
map<int, int> M;
int main() {
int N;
cin >> N;
int tmp;
int64 ans = 0;
for (int i = 0; i < N; ++i) {
cin >> ... |
2fa3f7f8e5a126705586931dfdbc5c5ebb0f88afa3456d8d3bd5c271021192e8 | 154d29823586458ee6dc85bfe8426f554b80be4f1996f5aebe264d49206b36bb | 0.105807 | cpp | 154d29823586458ee6dc85bfe8426f554b80be4f1996f5aebe264d49206b36bb | 4a11c514bc968685c331a1c816bdacd8505ef4675175867a83644d53f422ad84 | PIE_released_gem5_runtime | pie_58858 | p03588 | f3fbfc5d8cf418a0c8ff8a1e36f87bbae6a6944f1acd3b7d2cc275711b85bbc8 | 4a11c514bc968685c331a1c816bdacd8505ef4675175867a83644d53f422ad84 | 0.684835 | 6.472518 | 4-8 | b525aac84b9f5ffe0664246d3f32d019c6d00c2f1439645a649c8938af524687 | #include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <utility>
#include <functional>
#include <deque>
#include <cctype>
#include <stack>
#include <bitset>
using ll = long long;
typedef unsigned long long ... | #include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ull = unsigned long long;
typedef pair<int, int> Pi;
typedef pair<long long, long long> P;
typedef pair<long long, P> PP;
typedef pair<P, P> PPP;
const long long MOD = 1e9 + 7;
const long long INF = 5e18;
const int di[4] = {1, 0, -1, 0}... |
6d758736d667775021d9865496433190f30dd6bb60a4fedd6577f19133f3bed6 | d2bcfaa909085159ab91a5c3e9e8abf4da75cad6cd2253294e035994f0160192 | 0.025353 | cpp | d2bcfaa909085159ab91a5c3e9e8abf4da75cad6cd2253294e035994f0160192 | 10f37b11d7bbd727ea7eaecd8366e032ee85195852885acc13d2aa0baf20ccd8 | PIE_released_gem5_runtime | pie_58942 | p02589 | 107a56b54a3192dcc72127b9e5530061c3c9c3fee91b6d984ee9423390c961b8 | 10f37b11d7bbd727ea7eaecd8366e032ee85195852885acc13d2aa0baf20ccd8 | 0.072787 | 2.870886 | 2-4 | 26ca0fb4a152a07832119272e6159277e3c7a4adc547f176853e9eba5b72f144 | #pragma GCC optimize("O2")
#pragma GCC target("avx2")
#include <cstdio>
#include <algorithm>
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... | #pragma GCC optimize("O2")
#pragma GCC target("avx2")
#include <cstdio>
#include <algorithm>
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... |
067edb463cfd3802bc8f76b1384776cb4e7ea5c5a5e3683cf1f61eebc31d2b48 | ed91d3ce6eacb26c1ad86846da8cb08bb987d5b0286a68ae3671e2e294f8dfdb | 0.014701 | cpp | ed91d3ce6eacb26c1ad86846da8cb08bb987d5b0286a68ae3671e2e294f8dfdb | 4f83036e62523d9ff561452231c1815fb7cf1b23eabfd25306d8dc63c19807c0 | PIE_released_gem5_runtime | pie_58953 | p02371 | 6b03e492ca88374e5ff276d01f51020b5d356f4341ffc4fc090410e8cb980e1c | 4f83036e62523d9ff561452231c1815fb7cf1b23eabfd25306d8dc63c19807c0 | 0.271177 | 18.445741 | 8+ | 26dc290d942e822bf3904bd5f3524df3d2bf298395107d5d3820e70d06b9ae90 | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <functional>
#include <queue>
#include <stack>
#include <set>
#include <map>
#include <numeric>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cctype>
#include <cassert>
#include <sstream>
#define rep(... | #include <stdio.h>
#include <stdlib.h>
#define MAX_N 100000
#define INF 1000000000
typedef struct {
int to, dist;
} P;
P graph[MAX_N][16];
int graphptr[MAX_N];
int n;
typedef struct {
int prior;
P data;
} node_t;
typedef struct {
node_t *nodes;
int len;
int size;
} heap_t;
void push(heap_... |
64b0ebfa56c09e905cfb969cf6e8b8e5469aa7fa98930553ee08b2b3013d745c | 723c1df640435fb8b409277a5e154b92844ba2904fb95031f757b1a8cbdcde59 | 0.000191 | cpp | 723c1df640435fb8b409277a5e154b92844ba2904fb95031f757b1a8cbdcde59 | d2d48088b4411362fa916d3fb7adffea6313c02b7955968661d704d54ccdbdaf | PIE_released_gem5_runtime | pie_58977 | p03818 | 6b305e8098a1f6e6dd2293d0a3a8e52ec4add3479e63ce9dacf9bff8c3c41253 | d2d48088b4411362fa916d3fb7adffea6313c02b7955968661d704d54ccdbdaf | 0.00157 | 8.219909 | 8+ | 4c027ca8acfe272d232e0f81305dfe4727bacadf816ff58dcd28bfe85ba9eaba | #include <bits/stdc++.h>
using namespace std;
using VS = vector<string>;
using LL = long long;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using PLL = pair<LL, LL>;
using VL = vector<LL>;
using VVL = vector<VL>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(), (a)... | #include <stdio.h>
const int M = 1e5 + 5;
int arr[M] = {0};
int main() {
int n, i, j;
int num1 = 0;
int num2 = 0;
int ans = 0;
scanf("%d", &n);
for (i = 0; i < n; i++) {
scanf("%d", &j);
if (arr[j] == 0) {
arr[j] = 1;
num1++;
}
else {
num2++;
}
}
if... |
9bab41e68990387f0f0e2c6ed563e83889632536e07dc2215fdb136314d16eb2 | 3c53109579b55a2e07560c302f5ad5e901ca7545925e4d40f8a7438c631a3196 | 0.00136 | cpp | 3c53109579b55a2e07560c302f5ad5e901ca7545925e4d40f8a7438c631a3196 | f12521ce25ad525baec4ae17c1ea91e38659a0c4fcb354f1edc4f1598e38b885 | PIE_released_gem5_runtime | pie_58998 | p00358 | 479489169c279dc764c5147c2a9026142a9be57e996559bbb7848fa5b866d549 | f12521ce25ad525baec4ae17c1ea91e38659a0c4fcb354f1edc4f1598e38b885 | 0.005251 | 3.860281 | 2-4 | 97c1d456f3cc140046d65837f54df05ce526af5175f5d489a12778863a74ddfc | #include <bits/stdc++.h>
using namespace std;
int h, n;
vector<int> b;
int dp[101010][10];
int dfs(int i = 1, int bit = 0) {
if (i == h) {
return 0;
}
bit |= b[i];
int &ret = dp[i][bit];
if (~ret)
return ret;
ret = 0;
if (bit == 0)
ret = max(ret, dfs(i + 1, 0b111) + 2);
if ((b... | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define repto(i, n) for (int i = 0; i <= (n); i++)
#define all(c) (c).begin(), (c).end()
#define uniq(c) c.erase(unique(all(c)), (c).end())
#define _1 first
#define _2 s... |
4bbf1e8ab040930e72c3214609a44db4a56b2fa39eb84bf889b6fbc1246500f3 | 1fe94f6dd71b9cf8d91dc1d0536f86b6157d592dac6677bb7dbb7056f4334b0b | 0.018841 | cpp | 1fe94f6dd71b9cf8d91dc1d0536f86b6157d592dac6677bb7dbb7056f4334b0b | 5d42e98fc0606802e8466189a9d3ff2ccbcdc1efe27cde341d1e709faf0df2f6 | PIE_released_gem5_runtime | pie_59000 | p03725 | 1565c78b2c6a5ef8dc114551509e182a349cfb96dd15cf94f817e2452a1db220 | 5d42e98fc0606802e8466189a9d3ff2ccbcdc1efe27cde341d1e709faf0df2f6 | 0.626038 | 33.226779 | 8+ | aa381d97381c03426b072b8aca81909abc45637adde002a232dd4588877418f7 |
#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
typedef unsigned int ui;
#define forn(i, n) for (int i = 1; i <= n; i++)
#define pb push_back
#define all(x) x.begin(), x.end()
#define y1 qewr1234
const double PI = acos(-1.0);
const int DIR = 4;
const int X[] = {1, 0, -1, 0};
const in... | #include <stdlib.h>
#include <string.h>
#include <stdio.h>
#define Error(s) \
{ \
puts(s); \
exit(0); ... |
ebc8ed02823878eda24d0a5c6ee14c0a7166e6a6bcb615f080a811f0f73b7b09 | cb802d6c6356ce7690b2bb6021d297f4024e8deb9b09dc0fa8706d4fc3ac6b5c | 0.104184 | cpp | cb802d6c6356ce7690b2bb6021d297f4024e8deb9b09dc0fa8706d4fc3ac6b5c | 67bed35ca0ed28ece36511a437e4b30d11eacb34500e3da76115a036731e63a7 | PIE_released_gem5_runtime | pie_59077 | p02657 | b0ca9052bf7ec1283e861e222190a844ec12560caa7f96c39085c03d3f36563a | 67bed35ca0ed28ece36511a437e4b30d11eacb34500e3da76115a036731e63a7 | 0.371155 | 3.562488 | 2-4 | 7e4821cd59c79278ab211453a928a780f7cab4e7e3f51615ca86e722f0f1564c | #include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
#define N 100007
#define mod 1000000000000000000
#define pb push_back
vector<ll> v[N];
#define FAST \
ios_base::sync_with_stdio(false); ... | #include <bits/stdc++.h>
#define ll long long
#define endl '\n'
using namespace std;
#define FAST \
ios_base::sync_with_stdio(false); \
cin.tie(NULL);
int main()
... |
71416383f23438b65325ba19cc71f57e5a0d9c4aa2a55d4acad0a7e1a417d447 | bb3e7650f1037926336110044efd5727f80b88f3852c7b6ca6dc7c95f553c715 | 0.097639 | cpp | bb3e7650f1037926336110044efd5727f80b88f3852c7b6ca6dc7c95f553c715 | d11e3f3c508a9289460372144b0077eb56b63f84dcf90656ee6e3282d0a51e94 | PIE_released_gem5_runtime | pie_59093 | p03371 | bc7ee8150f39404076c3817de5bd5ffc40cb6a954a639201e1c6fdc942a300d3 | d11e3f3c508a9289460372144b0077eb56b63f84dcf90656ee6e3282d0a51e94 | 0.220909 | 2.262508 | 2-4 | 3277bb4aa1969979af26296c7f4e5c2e97851a415bab9698aa6c2a4e94a14864 | #include <bits/stdc++.h>
using namespace std;
int main()
{
int a, b, c, x, y;
cin >> a >> b >> c >> x >> y;
vector<long long> dp((int)1e5 + 1);
for (int i = 0; i <= (int)1e5; i++)
{
dp[i] = max(0, x - i) * a + max(0, y - i) * b + i * 2 * c * 1LL;
}
cout << *min_element(dp.begin(), dp.end());... | #include <iostream>
using namespace std;
int main()
{
int a, b, c, x, y, com, ext, tot = 0;
scanf("%d%d%d%d%d", &a, &b, &c, &x, &y);
if (y > x)
{
int t = x;
x = y;
y = t;
t = a;
a = b;
b = t;
}
com = y;
ext = x - y;
if (2 * c < a + b)
tot += com * c * 2;
else... |
050af43161f20c7bc51b74a14d244fb4fc3d349f91e1635d8cdb192304dcb2b1 | 11b9fe4b9b3eac04237c1d2eef36b3f7c573602e513b2c09e10c4bcc25cc01bc | 0.003692 | cpp | 11b9fe4b9b3eac04237c1d2eef36b3f7c573602e513b2c09e10c4bcc25cc01bc | 713888be34d68b7a263592dab15f9454d507a0d4a66501167a3aab1b5c1392e7 | PIE_released_gem5_runtime | pie_59135 | p03278 | fe507cfdcfb43168b2f744cfa1df1c534a9aa532cf6458074f5c3685408819c0 | 713888be34d68b7a263592dab15f9454d507a0d4a66501167a3aab1b5c1392e7 | 0.024114 | 6.531044 | 4-8 | 07b4ae43a18dc421d444811f6bb9c4ecf6d874eeea9e3fadda3de546b6a08220 |
#include <algorithm>
#include <iostream>
#include <cstdlib>
#include <cstring>
#include <cstdio>
#include <cmath>
#define re register
using namespace std;
inline int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
wh... | #include <iostream>
#include <cstdio>
#define ll long long
using namespace std;
inline int read()
{
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 3) + (x << 1) + (ch ^ 48);
... |
06f21757c3099f483e32d2527f7235599b58a3654964bda0d38c6475ce6ef673 | 9625640a825814aa4d2335674a3f90f455f88266b37bf781950284e77038f775 | 0.03076 | cpp | 9625640a825814aa4d2335674a3f90f455f88266b37bf781950284e77038f775 | d8c1ffe87c0e86316042b11430a1abac3da14c6f34e4ad7ffba9af44ec58a0a7 | PIE_released_gem5_runtime | pie_59145 | p03449 | cb08b6a9eaaf6f9e7de368ad13e6bd9fa7de9b0fdd5e1dff745361e16c429cb8 | d8c1ffe87c0e86316042b11430a1abac3da14c6f34e4ad7ffba9af44ec58a0a7 | 0.106677 | 3.468058 | 2-4 | 2a1738b9e535e796657595cef7d56d19703d24fedab7dcc668b8e4bc970f8793 | #include <iostream>
using namespace std;
int n;
int b[3][110], arr[3][110];
int dfs(int x, int y)
{
int p, q;
p = arr[x][y];
q = arr[x][y];
if (x == 2 && y == n)
{
return arr[x][y];
}
if (y + 1 <= n)
{
if (b[x][y + 1] > 0)
{
p += b[x][y + 1];
}
else
{
... | #include <cstdio>
#include <cstring>
#include <cmath>
using namespace std;
const int maxn = 1e2 + 10;
int n;
int a[maxn][maxn];
int dp[maxn][maxn];
int max(int a, int b)
{
return a > b ? a : b;
}
void solve()
{
dp[1][1] = a[1][1];
for (int i = 1; i <= 2; i++)
{
for (int j = 1; j <= n; j++)
... |
adae04209542c80f0e84610eb19cb66f86b8176d6dfe4b7cdda6967502c1fe3d | 36ee6d5a0f607e8ba92c673deb0898e53e5175332b3e915649742a914c19dcc4 | 0.022521 | cpp | 36ee6d5a0f607e8ba92c673deb0898e53e5175332b3e915649742a914c19dcc4 | e09ef45f01379ec569a9e1c56fa02e6e242bca4fd20dd88f5f9b1af493a916e3 | PIE_released_gem5_runtime | pie_59177 | p03376 | d2921d0d74106196e75ef9936d816d964afb2dea8a552ac2d58be270a0bef587 | e09ef45f01379ec569a9e1c56fa02e6e242bca4fd20dd88f5f9b1af493a916e3 | 0.067924 | 3.01605 | 2-4 | 1e7cf5b48bd70232a3da21247896f4fc4a01b57881704fffe399a7103722aca7 | #include <bits/stdc++.h>
#define ll long long
#define int ll
using namespace std;
ll c[55], f[250050], sz[55], fa[55];
struct node {
ll cost, value, count;
node(ll cost = 0, ll value = 0, ll count = 0) {
this->cost = cost, this->value = value, this->count = count;
}
inline friend bool operator<(cons... | #include <bits/stdc++.h>
using namespace std;
const int N = 55;
int n, x, d, fa[N], c[N * N * N];
struct node
{
int v, id;
long long w;
bool operator<(const node k) const
{
return v * k.w > w * k.v;
}
} a[N];
long long dp[N * N * N], ans;
int main()
{
ios::sync_with_stdio();
cin >> n >... |
d893d4fc178a8305ae7c18f055616304503cf5a3ae87dd4007310a3d3d3e85d8 | 98f65eb34a57d01956b40793be88414dc5abb672e22cee61e3a2a6f5eb68c9d4 | 0.060673 | cpp | 98f65eb34a57d01956b40793be88414dc5abb672e22cee61e3a2a6f5eb68c9d4 | 617f5dbb5fda78efe27192df2471b645934e4eaf7ba699c31d335eba8e5bffdc | PIE_released_gem5_runtime | pie_59244 | p03640 | 0423564d7fdb33942f952d3e734e047aa0663d7eaabdae6c86575b9f53a0d790 | 617f5dbb5fda78efe27192df2471b645934e4eaf7ba699c31d335eba8e5bffdc | 0.562011 | 9.262991 | 8+ | e0da86ce2ea390c0253443162f4f1757dd78c1e9e334e146d34cf9727c8ea222 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (ll i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define INF (1000000000)
#define MOD (1000000007)
#define MAX (500000)
#define pii pair<int, int>
class XY {
public:
ll x, y;
XY() { x = y = 0; }
XY... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i, j, n) for (int i = j; i < n; i++)
#define all(x) (x).begin(), (x).end()
#define pii pair<int, int>
#define pll pair<ll, ll>
#define vc vector
#define a first
#define b second
#define pb push_back
#define INF (1000000000)
#def... |
49ecd82d15b569d807052c1b9ce5c5b0a25dab47dfde5409259a4f4d7f7bc0d9 | 9be5e23ca709ac4db403ce7059a960d2f0eb23ef762e509660373d484ae1cdb6 | 0.051872 | cpp | 9be5e23ca709ac4db403ce7059a960d2f0eb23ef762e509660373d484ae1cdb6 | ea531e46a322a7dc246da7cc1950e478a856dd83e99218309de99b8ebeadd0d9 | PIE_released_gem5_runtime | pie_59256 | p03126 | 5d994d3c1b19653b7af3c04c7c0d89e4ab8217ac71193badcc12e621cf861f2b | ea531e46a322a7dc246da7cc1950e478a856dd83e99218309de99b8ebeadd0d9 | 0.488889 | 9.424858 | 8+ | c498748f25a8986606ddbeb9d76e5dc47424ba0ee9bb44bd0eba3e8a221f0b01 | #include <bits/stdc++.h>
using namespace std;
#define int unsigned long long
signed main() {
int a, b, d, w, f = 0;
int c[1000][1000] = {};
int e[1000] = {};
cin >> a >> b;
w = b;
for (int i = 0; i < a; i++) {
cin >> b;
for (int j = 0; j < b; j++) {
cin >> d;
c[i][d] = 1;
... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define mod 1000000007
#define am 998244353
#define INFi 2147483647
#define INFl 9223372036854775807LL
#define fi first
#define se second
#define be begin()
#define en end()
int abs(int a, int b) {
int c = max(a, b) - min(a, b);
return... |
d64622d422d7816a7b88801e8985fdc6e9b17849e8889d08ae1cf3760cacc6f8 | 75eda1aa7491b6b3a87a4e7e9c980d52a95951664147c70576120286530e04ab | 0.004735 | cpp | 75eda1aa7491b6b3a87a4e7e9c980d52a95951664147c70576120286530e04ab | d43449ae55d700d0f61029e474bf21a987c3ffbb8a5dfeea0ea6ee0e6cb17beb | PIE_released_gem5_runtime | pie_59282 | p03987 | 97cd564c884612d54be895883feab586311faba6d1fa8495122fee97a011601e | d43449ae55d700d0f61029e474bf21a987c3ffbb8a5dfeea0ea6ee0e6cb17beb | 0.103634 | 21.886955 | 8+ | 92e294e5a1835359386385ac6cada99ebc90885eb15e4acabbcf3fc0c5df939b | #include <iostream>
#include <cstring>
using namespace std;
long long a[401000], stack[401000], l[401000], r[401000], s[401000];
int main()
{
long long n;
cin >> n;
for (long long i = 1; i <= n; i++)
{
cin >> a[i];
s[i] = s[i - 1] + a[i];
}
long long top = 0;
for (long long i = 1; i <... | #include <cstdio>
const int maxn = 2e5 + 6;
#define read(a) scanf("%I64d", &a)
#define rep(a, b, c) for (int a = b; a <= c; a++)
#define per(a, b, c) for (int a = b; a >= c; a--)
#define ls rt << 1
#define rs rt << 1 | 1
#define mid ((l + r) >> 1)
#define int long long
template <class T> inline T max(T a, T b)... |
a77af9ef3b063adc043940622b454a1bf7a5007349f645e9a37a0e0b669ed17b | 2bb14fe5fb0d9196a09f0e2d165fbc20b13f950f80d256e32c10b250eaef77dd | 0.019342 | cpp | 2bb14fe5fb0d9196a09f0e2d165fbc20b13f950f80d256e32c10b250eaef77dd | fcf3104214bbef77ab27825be1db5ef294577ccd827e5293c3958f70ef29f33c | PIE_released_gem5_runtime | pie_59401 | p04038 | ce8cff63b06b41749c2980cbcf431fc027cc102b38cc7798097c820a6a2a7d96 | fcf3104214bbef77ab27825be1db5ef294577ccd827e5293c3958f70ef29f33c | 0.088546 | 4.577793 | 4-8 | bf17ee99b9ff58632a1a1bcee8829ff4103fd951801d348da7fa440cc19a42b1 | #include <bits/stdc++.h>
#define LL long long
#define db double
using namespace std;
const int N = 2000 + 10, mod = 1e9 + 7;
int rd()
{
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-')
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 ... | #include <stdio.h>
#include <algorithm>
#include <memory.h>
typedef long long ll;
const ll N = 2e3 + 5;
const ll P = 1e9 + 7;
ll n, k;
ll fac[N * N];
ll f[N][N];
ll read()
{
ll x = 0, f = 1;
char ch = getchar();
while ('0' > ch or ch > '9')
f = ch == '-' ? -1 : 1, ch = getchar();
while ('0' <... |
e204911f701cea808ea4d63d989627f4bd71f616d80e08f710a31f3415ee1422 | 0ff687516dbcfd7771ee0058c046e1fd55bdf7f21a850da19250bdba4f8ef5d3 | 0.108204 | cpp | 0ff687516dbcfd7771ee0058c046e1fd55bdf7f21a850da19250bdba4f8ef5d3 | 5680f89131e29fae01b125dc66102e282960f2731940c770597c2e7356fe3d02 | PIE_released_gem5_runtime | pie_59479 | p04000 | 824a6b351079ab9ae572048dea91bab82491b01c71d0d115dc8464a3579b178d | 5680f89131e29fae01b125dc66102e282960f2731940c770597c2e7356fe3d02 | 0.687539 | 6.354087 | 4-8 | 39737f05569234c62f2bbe63493abbc718421841d8043987e184fedccbaccb39 |
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>
long long mod = 1e9 + 7;
class Mint {
publ... |
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <queue>
#include <stack>
#include <vector>
#include <algorithm>
#include <map>
#include <unordered_map>
#include <set>
#include <deque>
#include <bitset>
long long mod = 1e9 + 7;
class Mint {
publ... |
a5388764d739b862afde98787fe965066c462cc6c0ddf92b0f9104c478a712b2 | 2efb9b708bf5fc4f477dae3640b08a72b512628fd0f833b0ca97b13869dfd4d5 | 0.017357 | cpp | 2efb9b708bf5fc4f477dae3640b08a72b512628fd0f833b0ca97b13869dfd4d5 | 47d3c6a4cdfcfc1f6436849119a08fb17422a6dc72c76709a0f65397f5caf297 | PIE_released_gem5_runtime | pie_596 | p03086 | 9bc1284376ca0e9fcc86ac30951f9d30846dfeb8511a04883281f736e8d5e686 | 47d3c6a4cdfcfc1f6436849119a08fb17422a6dc72c76709a0f65397f5caf297 | 0.109688 | 6.319454 | 4-8 | 783742d682245f93b4c42e6cd5676df88e12d6b97e0d79dd6daebbf527b5b44a | #include <iostream>
#include <string>
#include <regex>
#include <algorithm>
using namespace std;
int main()
{
string s;
cin >> s;
int res = 0;
smatch m;
for (auto it = cbegin(s); regex_search(it, cend(s), m, regex("[ACGT]+"));
it = m[0].second)
res = max<int>(res, m.str().size());
co... | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
int main()
{
char s[16], d[26];
scanf("%s", s);
for (char *p = d, c = 'A'; c <= 'Z'; ++c)
if (!strchr("ACGT", c))
*p++ = c;
int res = 0;
for (char *p = strtok(s, d); p; p = strtok(NULL, d))
... |
6501e9107e6223e23548922d18d85381381d6f9740743610555df9211c89bcc9 | 3b360a96a7eb043c8e3662eb1052ff897e927cb86d3345be2d45feb9f658861f | 0.019858 | cpp | 3b360a96a7eb043c8e3662eb1052ff897e927cb86d3345be2d45feb9f658861f | ccddfcb1c438cda8882c625572796ee7fcba33bbd8ea153aeb47bdbada4ec41c | PIE_released_gem5_runtime | pie_59683 | p02258 | 97d0961bb399c05803a587dcbfa183170ccdc36e2bdd265f7bfb39668ba8da73 | ccddfcb1c438cda8882c625572796ee7fcba33bbd8ea153aeb47bdbada4ec41c | 0.19054 | 9.594958 | 8+ | a3b957000e9ba699f386dcc20e7ddff480a0833173eda05f5072a11359d1453f | #include <stdio.h>
#include <algorithm>
using namespace std;
int main()
{
long int arr[200010] = {0};
long int arrmin;
long int dmax;
int n = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%ld", &arr[i]);
if (i == 0) {
arrmin = arr[0];
continue;
}
if (i =... | #include <stdio.h>
#include <algorithm>
using namespace std;
int main()
{
int minv;
int dmax = -2000000000;
int var;
int n;
scanf("%d", &n);
scanf("%d", &minv);
for (int i = 1; i < n; i++) {
scanf("%d", &var);
dmax = max(var - minv, dmax);
minv = min(var, minv);
}
printf("%d... |
73b24c9fc2bcf6ecedcb06a7096ebbadff848b44ca4d082421a349a65919726e | 8b08109a7159d6dda6237f252fb5564c7f4d64f8af3b96371493f2035ace461f | 0.106911 | cpp | 8b08109a7159d6dda6237f252fb5564c7f4d64f8af3b96371493f2035ace461f | fdc2cf795520741535638c3949499821cb08159f38e9f28c083857ec3def1bcb | PIE_released_gem5_runtime | pie_59761 | p01511 | 2ddcf2f2a3239f827e2bb17b4b697b063374f18026986c14c9875d412fe4d0a1 | fdc2cf795520741535638c3949499821cb08159f38e9f28c083857ec3def1bcb | 0.243253 | 2.275286 | 2-4 | fcb9fe57ef80bd4e01d243320596a1f95dca1ab0b903c549568b5d8a0cfe6928 | #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <cstdlib>
#include <cmath>
using namespace std;
#define MOD 1000000009
long long w, h, n;
struct Matrix {
long long n, m[80][80];
Matrix operator*(const Matrix &b) const {
Matrix c;
memset(c.m, 0, sizeof c.m)... | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
using namespace std;
using ll = long long;
using ld = long double;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { retu... |
df1df73162c1de03beca6c20976a3f2a50aa6b6eb7b93f75e4795e4484e2af4d | fcf84d21d7787a758c8665c16b6c9bebc46f20a616d4853aa00af1264883e65f | 0.011008 | cpp | fcf84d21d7787a758c8665c16b6c9bebc46f20a616d4853aa00af1264883e65f | 00235776978a9684f311d5105fd60d5abce7b64e4da6d6578b975244fc7034a1 | PIE_released_gem5_runtime | pie_59817 | p03680 | 46f4890d71b049dd71608abe40a38ec54d8251a0a03b0ffd94b86b9865b4d65e | 00235776978a9684f311d5105fd60d5abce7b64e4da6d6578b975244fc7034a1 | 0.286104 | 25.989512 | 8+ | e2244391e2c0da406c42d48eb5f8babfdcbdd0302bdbff65841d581662e3bd53 | #include <iostream>
#include <set>
using namespace std;
struct A {
int is = 0;
int num;
} pp[500000];
int main() {
pp[1].is = 1;
int n, i, y = 0;
cin >> n;
for (i = 1; i <= n; i++) {
cin >> pp[i].num;
}
int Count = 0, t = 1;
while (pp[2].is != 1) {
pp[t].is = 1;
t = pp[t].n... | #include <stdio.h>
int main()
{
int N;
scanf("%d", &N);
int time = 0;
int a[100000];
int i;
int x = 0;
for (i = 0; i <= N - 1; i++)
{
scanf("%d", &a[i]);
if (a[i] == 2)
{
x = 1;
}
}
if (x == 1)
{
int t = 0;
while (t != 1)
{
t = a[t] - 1;
... |
fdfd590e2fd4560e1bb24f8675cb11af0155e262b25396d7a0a9e1285b992aa2 | 3bb872db2d293784c3c1745b0dba453b006b94c4b54945f125fb05ef18831bbe | 0.003856 | cpp | 3bb872db2d293784c3c1745b0dba453b006b94c4b54945f125fb05ef18831bbe | 4cfd9882ffac5ab3a854be335d979622424c1914f757024933e1ece3f67ddb4e | PIE_released_gem5_runtime | pie_59861 | p03458 | a680825a14e545d5af3a4bc7a480977324bc59eae3032610ac70a0bae4fafcf4 | 4cfd9882ffac5ab3a854be335d979622424c1914f757024933e1ece3f67ddb4e | 0.040384 | 10.473919 | 8+ | 6f0c430f539e395bc89bf1c2b3e33eb13b69444833b89a6e9c0977db22cdd67c | #include <set>
#include <cstdio>
#include <queue>
#include <cmath>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
long long read() {
long long f = 1, x = 0;
char c = getchar();
while (c < '0' || '9' < c) {
if (c == '-')
f = -1;
c = getchar();
}
while... | #include <cstdio>
#include <algorithm>
#define MAXN 100006
#define MAXK 2006
using namespace std;
int n, k;
char c;
int map[MAXK][MAXK], a, b, black, maxone, minone = MAXN;
int main()
{
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
{
scanf("%d%d %c", &a, &b, &c);
black = 0;
if (c ... |
17ff7c35cf6dbc22027d5b53b61a14ab312ec04d1e9554dbe82a29533d0347c6 | e5c16b3e1cc2dfe61d28537c985e4d84cf2444f6314017b094b001134cca199b | 0.0264 | cpp | e5c16b3e1cc2dfe61d28537c985e4d84cf2444f6314017b094b001134cca199b | cf61077cc48b59595e02dcf3eee8b718acd80a7694b5b3f7cfa983815b5efb81 | PIE_released_gem5_runtime | pie_59879 | p02930 | e8d649c9ccf2d904436b332a1da74e06ccd9b3fe11341257b1a56222f74accf3 | cf61077cc48b59595e02dcf3eee8b718acd80a7694b5b3f7cfa983815b5efb81 | 0.083735 | 3.171764 | 2-4 | 93d6d2d817ba75a587ca45e49fbb64fbd8d45ad83031835088d778d481bc4df3 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = (a); i < (b); i++)
int G[505][505], n;
void solve(int l, int r, int t) {
if (l + 1 == r)
return;
int m = (l + r) / 2;
rep(i, l, m) rep(j, m, r) G[i][j] = t;
solve(l, m, t + 1);
solve(m, r, t + 1);
}
int main() {
sc... | #include <cstdio>
int n, i;
int main() {
scanf("%d", &n);
for (; n--;)
for (i = n; i--;)
printf("%d%c", __builtin_ffs(n ^ i), i ? ' ' : '\n');
} |
3a8ab2c1b712bc8bf593bcd29235157b3919b064932fed6db81833ac156acdc4 | 6844faa5f6ff931b19b6ee44615aaffff97a38610a72a81549956c587f9f358c | 0.019856 | cpp | 6844faa5f6ff931b19b6ee44615aaffff97a38610a72a81549956c587f9f358c | 8d6fdc74a8484280c14fb215a0f762b4a4e2982d0006fe2015229a1ebfdb4ac2 | PIE_released_gem5_runtime | pie_59887 | p02235 | bc518a86649185fcb2edcedfbff14fc8a934c97fb5e46398726ff7955e27029b | 8d6fdc74a8484280c14fb215a0f762b4a4e2982d0006fe2015229a1ebfdb4ac2 | 1.419193 | 71.473926 | 8+ | 6f3f029d8c24eadc7611d900daf3dd3513008587c9e3ea556cf8c73136fe7f91 | #include <cstdio>
#include <iostream>
#include <cmath>
#include <algorithm>
#include <cstring>
using namespace std;
const int maxn = 1000 + 5;
int dp[maxn][maxn];
char x[maxn];
char y[maxn];
int main()
{
int q;
scanf("%d", &q);
while (q--)
{
scanf("%s %s", x + 1, y + 1);
memset(dp, 0, s... | #include <stdio.h>
#include <string.h>
#define N 1010
char a[N];
char b[N];
int dp[N][N];
int main() {
int k;
scanf("%d", &k);
while (k--) {
scanf("%s", a);
scanf("%s", b);
int n = strlen(a);
int m = strlen(b);
for (int i = n - 1; i >= 0; i--)
a[i + 1] = a[i];
for (int... |
f4c452f3add2d9ae30891664da7181a7f70559914bdf8074295d649147629bfa | 9dd9e76caf10e9ebee9bcbd39cca1f0d48f517e35770cb3a23dd2bd9160130e8 | 0.101178 | cpp | 9dd9e76caf10e9ebee9bcbd39cca1f0d48f517e35770cb3a23dd2bd9160130e8 | cbef41c30a004b23bc2e9d24512054872acab0bd7e6d82984cfe615658bd42d9 | PIE_released_gem5_runtime | pie_59901 | p02558 | 2f17680c38c9f34f2bfa24dce217cb1249c25167f14c9c855c8682b2722b9648 | cbef41c30a004b23bc2e9d24512054872acab0bd7e6d82984cfe615658bd42d9 | 0.665279 | 6.575331 | 4-8 | 493913169a18af5d68fd8ece94ebeb03cae18b27aab52628ef86661ea46213d2 | #include <bits/stdc++.h>
using namespace std;
#define pii pair<int, int>
#define pll pair<long long, long long>
#define fi first
#define se second
#define mp make_pair
#define pb push_back
#define DEBUG 1
#define cerr \
if ... | #include <iostream>
using namespace std;
int N, Q;
int root[200005];
int find(int idx) {
if (idx == root[idx])
return idx;
int pidx = root[idx];
root[idx] = find(pidx);
return root[idx];
}
void join(int u, int v) {
int ru = find(u);
int rv = find(v);
root[rv] = ru;
}
int main() {
scan... |
def37f99e0aa74c10eccc675cf3a902eb96cc606e5ea43fcfab284c7cca26ca5 | 8a09b0769513acf5029bc84297f51e6fee0a38e9929c79166440bdffaebc92d3 | 0.043601 | cpp | 8a09b0769513acf5029bc84297f51e6fee0a38e9929c79166440bdffaebc92d3 | 16745234bb0c2dcb17356f9924b537ea1ca760141e888886e4a47c7dbe19c122 | PIE_released_gem5_runtime | pie_59912 | p03712 | b17941c003e71d348caf1cb495d11b58e056f027304a8761340a2b906dcbfe94 | 16745234bb0c2dcb17356f9924b537ea1ca760141e888886e4a47c7dbe19c122 | 0.356854 | 8.184487 | 8+ | 020d638c3bbb60644e01b3587e41452ad348f99e72a9b0f611efd6ed44c349c2 | #include <bits/stdc++.h>
#define ll long long int
#define sz 200010
using namespace std;
string ss[sz];
int main()
{
string x = "";
ll h, w, i, j, k, p, a, b;
cin >> h >> w;
for (i = 1; i <= h; i++)
cin >> ss[i];
for (i = 1; i <= w + 2; i++)
x += "#";
cout << x << endl;
for (i = 1; i ... | #include <bits/stdc++.h>
#define bye return 0
#define Yes \
cout << "Yes" \
<< "\n"
#define No ... |
55a80e0212216e5d8181b941e45b04a0c2ba6cd584600b848c39b448efcf8240 | a7a6191db2b37b1d9cf025019fc0ea7390104e9cf7be8143a0343a008aac5c57 | 0.085137 | cpp | a7a6191db2b37b1d9cf025019fc0ea7390104e9cf7be8143a0343a008aac5c57 | ce64481bf45e1e8ce542dde9d99b0689afd4cb71e988ba492bae89f307a04e37 | PIE_released_gem5_runtime | pie_59954 | p02781 | 6c49641e40d5eef6d150578732571d411758e6f7e6cf7985f7c453e35aa16bed | ce64481bf45e1e8ce542dde9d99b0689afd4cb71e988ba492bae89f307a04e37 | 0.890603 | 10.460796 | 8+ | 76225c38f84eb1a582eb6c8d39fdfcd1bbe399c794d1e8b3dd934ab283524c8f | #include <bits/stdc++.h>
using namespace std;
#define rep(i, j, k) for (int i = (int)(j); i <= (int)(k); i++)
#define debug(x) cerr << #x << ":" << x << endl
#define fix cout << fixed << setprecision(20);
const int maxn = (int)1e6 + 5;
long long dp[105][105][105];
int L;
int k;
string n;
long long f(int l, int ... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using P = pair<ll, ll>;
using Graph = vector<vector<ll>>;
#define rep(i, n) for (ll i = 0; i < (ll)(n); i++)
#define rep2(i, m, n) for (ll i = m; i < (ll)(n); i++)
#define rrep(i, n, m) for (ll i = n; i >= (ll)(m); i--)
const int dx[4] = {1, 0,... |
e0a3a8245411215f0a23fdb4d0434eefbd1ead5ad88938aba4eec6721ac703d8 | ec8d6b6f7f4a8550a6e879f6ceb0a171c9257de961db05182421940a7ef4e1cf | 0.087733 | cpp | ec8d6b6f7f4a8550a6e879f6ceb0a171c9257de961db05182421940a7ef4e1cf | 5ba2fb33cecf297b88f4fc006b9e3d04449b9bcd6ca2da70d40a9b53c132839a | PIE_released_gem5_runtime | pie_59957 | p03174 | 8c20cc0fa36d3469019147ab59b81b5bca3ab9d456fe0eb795eef9bdd092635f | 5ba2fb33cecf297b88f4fc006b9e3d04449b9bcd6ca2da70d40a9b53c132839a | 0.855994 | 9.756803 | 8+ | 1afffb5b030fb52fdf41332178521dc854c705a8f84483d0b0b0a43bf59fd45b | #include <bits/stdc++.h>
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... | #include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
#define FIO \
ios_base::sync_with_stdio(false); \
cin.tie(NU... |
b6d00f2531e8d78f01f22a158d750243d248a6992dcaba24e0c83bcb474398ee | 90554e8a57b83445c7ce094883f5f50376e1b0de5ab85b108a5dad5533eb687b | 0.081979 | cpp | 90554e8a57b83445c7ce094883f5f50376e1b0de5ab85b108a5dad5533eb687b | c44e7dd1905f6bdee96780e7f59692f1a3e51d8ce15088998b125146bcc64b84 | PIE_released_gem5_runtime | pie_6008 | p03170 | 327be73863c046c87c8f42ce01e57858cc4c139b6be41182ece8a655faad3d21 | c44e7dd1905f6bdee96780e7f59692f1a3e51d8ce15088998b125146bcc64b84 | 0.248139 | 3.026878 | 2-4 | 4e5912f2e7400e9d30707e2ffd1ec270bfb13be04f20b31eb918d35c03f12ef6 | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long
#define ld long double
#define lll __int128
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vector<int> >
#define pii pair<int, int>
#define piii pair<int, pair<int, int> >
#define pll pair<l... | #include <bits/stdc++.h>
using namespace std;
#define ll long long int
#define ull unsigned long long
#define ld long double
#define lll __int128
#define vi vector<int>
#define vl vector<ll>
#define vvi vector<vector<int> >
#define pii pair<int, int>
#define piii pair<int, pair<int, int> >
#define pll pair<l... |
3a2f2a525ab37370bb66676f9c470367f76ce6c4e489ef3ee993ed76ac0d6194 | 3c6cd5d94342125ec75680a9aedc0c8c100ba14091c421b9e1c8a995ac7ee03b | 0.017618 | cpp | 3c6cd5d94342125ec75680a9aedc0c8c100ba14091c421b9e1c8a995ac7ee03b | 42073ebef8ec4518e14823b1a68ba6f0a8ed0f5a650fd24b43be03421186f8a8 | PIE_released_gem5_runtime | pie_60115 | p03457 | c77d00f81274416d31dd58781702b2c04b775f63444477d68d072f3d5825e12e | 42073ebef8ec4518e14823b1a68ba6f0a8ed0f5a650fd24b43be03421186f8a8 | 0.133109 | 7.555313 | 4-8 | a590223bd3ebb103d019df6ba78ee232a4d5dc6e4ec09cfd2796155f92d46400 | #include <cstdio>
int main() {
int n;
while (~scanf("%d", &n))
{
int jin = 0;
int ti[100050] = {0};
int xi[100050] = {0};
int yi[100050] = {0};
int i;
for (i = 1; i <= n; i++)
{
scanf("%d%d%d", &ti[i], &xi[i], &yi[i]);
int sum = xi[i] + yi[i] - xi[i - 1] - yi[i... | #include <stdio.h>
int s[100005][5];
int main()
{
int n, first = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= 3; j++)
scanf("%d", &s[i][j]);
for (int i = 1; i <= n; i++)
{
int a, b;
a = (s[i][2] + s[i][3]) - (s[i - 1][2] + s[i - 1][3]);
if (a < 0)
... |
3d87f90d79ce8cbc07940b986a05478e57724491c6392c639688b81cc17d7b05 | 02cf6e5501c2fe8d1f5a3b1308f208a7cd98f72d48afa2c01787494c25b06c78 | 0.079355 | cpp | 02cf6e5501c2fe8d1f5a3b1308f208a7cd98f72d48afa2c01787494c25b06c78 | a79e19c50b7435fb7263abe92168e7f2df9fdd7dc96d9d4e58895c7cbb0d0ecc | PIE_released_gem5_runtime | pie_602 | p03554 | 9777ad11fce82f1dac79f97f72d1114c3800d99fd1bcc864e1fc92d61f0c455f | a79e19c50b7435fb7263abe92168e7f2df9fdd7dc96d9d4e58895c7cbb0d0ecc | 0.308914 | 3.89282 | 2-4 | cdb263fc2984b16107b6f9afbebecdf75da2965fc7f855519b416e46b615d79a | #include <vector>
#include <stdio.h>
#include <string.h>
#include <iostream>
#include <algorithm>
#define R register
typedef long long ll;
inline int read() {
R int x;
R bool f;
R char c;
for (f = 0; (c = getchar()) < '0' || c > '9'; f = c == '-')
;
for (x = c ^ '0'; (c = getchar()) >= '0' && c ... | #include <cstdio>
#include <cstring>
#include <algorithm>
#define MN 262150
using namespace std;
struct node {
int x, y;
} b[MN];
int t[MN << 1], a[MN];
int MQ, INF, n, m, ans, f0;
inline int read()
{
int n = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
... |
7eb8cdf3c78fc1a3584f59034d31d43903af581732ba22f5f9b22712c497c4c2 | c4c11b39471fe29425cc5828a9421174f36b835dbe12ffe7d9f4bb8bb2d3f9a3 | 0.01464 | cpp | c4c11b39471fe29425cc5828a9421174f36b835dbe12ffe7d9f4bb8bb2d3f9a3 | 182eaa5be320a16fe5834f8a7631cebecce011ab8ef2f52a59c8f57c870e836a | PIE_released_gem5_runtime | pie_60458 | p03692 | 1a4ec463eb43af501e928744ece53793f77dbf29c02d4f1af3528a9f46d96d0b | 182eaa5be320a16fe5834f8a7631cebecce011ab8ef2f52a59c8f57c870e836a | 0.064786 | 4.425386 | 4-8 | ab6a58b07660a48dda6590cb15297b48c18309c00283af71ab7b9e89f136dd23 | #include <cstdio>
#include <vector>
const long long MOD = 1000000007;
int N, M, sg[16], c0[15], c1[15], e[16][16];
std::vector<int> V[16];
long long O = 0;
long long DFS(int k)
{
if (k <= 2)
{
static long long H[15];
static int T[15];
H[0] = 1;
for (int i = 1; H[i - 1] && i <= N - 1; i+... | #include <cstdio>
const int MOD = 1000000007;
int N, M, e[15][15], emask[15][32768];
long long f[8192];
long long A(int u, int v)
{
long long W = 1;
int zero = u - v, nonzero = v | 3 << N - 2;
for (int i = 0; i < N; i++)
{
if (zero >> i & 1)
W = (W << emask[i][nonzero]) % MOD;
if (nonz... |
3fc8ad01195627c67b5694b8c3318396c1bf74276e38bd361f6e76e5f90e5f77 | 5f23eb4fe7cfca831453a0121d5a7df05cb61eee8b003701415ab4f94638aac1 | 0.079158 | cpp | 5f23eb4fe7cfca831453a0121d5a7df05cb61eee8b003701415ab4f94638aac1 | 666433d7201e9634fcfc632e32756182da7739d9014147910c577ae1c0960c4e | PIE_released_gem5_runtime | pie_60461 | p00909 | 7c8eba04f54d57e1f37f8256a49701df50c471944683ac049333801d3b25574e | 666433d7201e9634fcfc632e32756182da7739d9014147910c577ae1c0960c4e | 0.297592 | 3.759453 | 2-4 | 2abf4dc0265552e8790c723f9aba914ac862aa222a16ecd497154b307f384684 | #include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
const int S = 100010;
struct UnionFind {
vector<int> node;
vector<ll> weight;
UnionFind() : node(S, -1), weight(S, 0) {}
void unite(int u, int v, ll w) {
int ov = v, ou = u;
u = find(u), v = find(v);
int wa = weight[o... | #include <cstdio>
#include <iostream>
#include <vector>
#include <cassert>
#include <string>
using namespace std;
struct QuickFind {
int N;
vector<int> i2g;
vector< vector<int> > g2i;
vector<long long int> weight;
QuickFind(int N_) {
N = N_;
i2g.resize(N);
g2i.resize(N);
wei... |
d8919a34d1f2e9943adc6876f4df8d5f9fe17028253f00bced517e5e418ad947 | 6849e2e0c49b31a81510f0ac5b74437b8791a5ce43ca9646bac29199f03ef2aa | 0.072734 | cpp | 6849e2e0c49b31a81510f0ac5b74437b8791a5ce43ca9646bac29199f03ef2aa | 0f460787736ba5caee2928df8db5709fd54f3ea29676ebe763fd2aa03a6fc664 | PIE_released_gem5_runtime | pie_60472 | p03453 | bb9bbaa117713a1e77a6dc4e16ea39b37033945afd6bb6d6e4cb1871b9424636 | 0f460787736ba5caee2928df8db5709fd54f3ea29676ebe763fd2aa03a6fc664 | 0.149037 | 2.049077 | 2-4 | 9cea0f93376b58e4d75216ef46c4f64bb38ef39ba12c1a0ba75d6cc0b4aad4ef | #include <bits/stdc++.h>
using namespace std;
#define MXN 100005
#define x first
#define y second
typedef long long int LLI;
typedef pair<LLI,LLI> PII;
const int mod = 1e9+7;
vector<PII> edges[MXN];
LLI dist[2][MXN], ways[2][MXN];
priority_queue<PII, vector<PII>, greater<PII> > pq;... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U> ostream &opera... |
4c7dc9aac0b284d06510686465f4465035db2238916a03eeb4728336dd9218c6 | fad3e166fde14ed5c72a16ad595dfe0c2c52e3d7327a21dcb54e739c7055a42c | 0.018595 | cpp | fad3e166fde14ed5c72a16ad595dfe0c2c52e3d7327a21dcb54e739c7055a42c | 87504666c48f978ffe6b5cda5f6684f87f63e5a59231a22dbaa0c0d68e7e17ab | PIE_released_gem5_runtime | pie_60519 | p03787 | 9dea83724411cdb088931d60323eb9e75d4d8ed0db4b7bf3b45d98327c04417b | 87504666c48f978ffe6b5cda5f6684f87f63e5a59231a22dbaa0c0d68e7e17ab | 0.497153 | 26.73518 | 8+ | 183c371b6c757f78beda6b21c85654acaa61de18c1be3d4a76dfee971f659c90 | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
const int maxn = 100005, maxm = 400005;
int last[maxn], pre[maxm], other[maxm], t, cal[maxn], vis[maxn], q[maxn], head,
tail;
void add(int x, int y) {
++t;
pre[t] = ... | #include <cstdio>
#define maxn 100005
#define maxm 200005
int n, m, ia, pa, qa;
bool f, val[maxn], vis[maxn];
struct node {
int v;
node *nxt;
} edge[maxm * 2], *head[maxn], *ncnt;
void addedge(int u, int v)
{
ncnt++;
ncnt->v = v, ncnt->nxt = head[u];
head[u] = ncnt;
}
void dfs(int u)
{
vis[u] =... |
580ad9285048cdd781116870521908975fc4fee52ddca1f8bab85dcb28ea08f7 | bd4ed9205be24c7f30ed90e0f0151ef6d42d18dcdc18a4746cda3ebcb7b74df1 | 0.043759 | cpp | bd4ed9205be24c7f30ed90e0f0151ef6d42d18dcdc18a4746cda3ebcb7b74df1 | d8a26ca2a62580efbe954d31176fcfd0503762f8678884fa03c6331e87805c6d | PIE_released_gem5_runtime | pie_60531 | p03315 | ea25a1d316aabb9228f5e5dceb3bb4834375e63b9f46daafe9b9c2ab275df0bd | d8a26ca2a62580efbe954d31176fcfd0503762f8678884fa03c6331e87805c6d | 0.44923 | 10.266004 | 8+ | dc0c535a9f254ab32d75879cab6fd88e03eb20abd2f220a4b6ac2070538bfe7e | #include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <list>
#include <unordered_set>
#include <tuple>
#include <cmath>
#include <limits>
#include <type_traits>
#include <iomanip>
#include <unordered_map>
using namespa... | #include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <numeric>
#include <string>
#include <cstring>
#include <list>
#include <unordered_set>
#include <tuple>
#include <cmath>
#include <limits>
#include <type_traits>
#include <iomanip>
#include <unordered_map>
#include <que... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.