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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
c9c6a4e606ad0d94c244edb488998b962e5c0371c9fda2fe8b3a4a56a3416097 | d4fd84ba1022941fbaaa6407b17e58771dc0756d7fe44a24db6d4a49ef16b96e | 0.085149 | cpp | d4fd84ba1022941fbaaa6407b17e58771dc0756d7fe44a24db6d4a49ef16b96e | ffc2490ff923af0ff17ddcb08e512e16b97630835df80f81b30d7e85aae4af24 | PIE_released_gem5_runtime | pie_15514 | p03044 | aa6a27922fc2c8c9892c56ddc1455676a7e95e61651b60defed0d9da40562812 | ffc2490ff923af0ff17ddcb08e512e16b97630835df80f81b30d7e85aae4af24 | 0.625303 | 7.343655 | 4-8 | 9ebc35cace667d8384873a6d85079253edaf3e7c4860b44e827ffd6af9d94db9 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.siz... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define F first
#define S second
#define pii pair<int, int>
#define eb emplace_back
#define all(v) v.begin(), v.end()
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep3(i, l, n) for (int i = l; i < (n); ++i)
#define sz(v) (int)v.siz... |
da87c3cf55aee6b5ce7778ad14237f2112a296f3b345baa991afda0759ca96bd | 6b5d14ff891fd9cff1817d0d673fa7cf159c49d2980a9a19c5611053bc50c9e6 | 0.099176 | cpp | 6b5d14ff891fd9cff1817d0d673fa7cf159c49d2980a9a19c5611053bc50c9e6 | fcb9d70a127083a708f773f0261e94425187f9b33d3ae86ea5b7256d95c2bd4c | PIE_released_gem5_runtime | pie_1557 | p02120 | fff629f8af342db60cb62b8fd3bf2254745dadc03a802e276f6752815da4b523 | fcb9d70a127083a708f773f0261e94425187f9b33d3ae86ea5b7256d95c2bd4c | 0.615557 | 6.206721 | 4-8 | bc3114b843fcca3044b06da6ea53b9ab052fbb3ef26d4899137e2d29aed5c31e | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
int N, M, W[100000];
vector<int> g[100000];
bool v[100000];
int order[100000], low[100000], ptr;
int64 sum[100000], ans[100000];
vector<int> tree[100000];
void dfs(int idx, int par)
{
v[idx] = true;
order[idx] = ptr++;
low[idx] = ... | #include <bits/stdc++.h>
#include <utility>
using namespace std;
using int64 = long long;
const int mod = 1e9 + 7;
const int64 infll = (1LL << 62) - 1;
const int inf = (1 << 30) - 1;
struct IoSetup {
IoSetup() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(10);
... |
c4cc7e1e17564980fa61fb14a4993c0750403c3a47104226e12743bcee834cd1 | 1c3a089ab8cdb5844c4c278fe1d1f5e44233fc30d9ac97d1a5396eb8565606e3 | 0.0202 | cpp | 1c3a089ab8cdb5844c4c278fe1d1f5e44233fc30d9ac97d1a5396eb8565606e3 | 280a446d08d7d1cb06098aa73861ae19c6e8a78ad2b7563f01ced6587ded47fe | PIE_released_gem5_runtime | pie_15587 | p03620 | e42e0d01de10da5f6a41fc2be0fe1a7f1d4dd0699a5355e2543af5c8ae27e3f8 | 280a446d08d7d1cb06098aa73861ae19c6e8a78ad2b7563f01ced6587ded47fe | 0.098793 | 4.890745 | 4-8 | cd133595b89795b4a03bf158d79e92cf26d1de114129cb1772fbdd033a259e0b | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#define MAXN 2000
#define INF 0x3FFFFFFF
using namespace std;
typedef pair<int, int> PII;
char A[MAXN + 5], B[MAXN + 5];
vector<PII> need;
int n;
int seq1[MAXN + 5], seq2[MAXN + 5];
int psm1[MAXN + 5], psm2[MAXN + 5];
int sm1[MAXN ... | #include <cstdio>
#include <algorithm>
#include <cstring>
using namespace std;
#define MAXN 2010
#define INF 1000000000
int n, ans = INF;
char a[MAXN], b[MAXN];
int st[MAXN], L[MAXN], R[MAXN];
bool cmpL(int x, int y)
{
return L[x] < L[y];
}
bool cmpR(int x, int y)
{
return R[x] < R[y];
}
int main()
... |
87a0b11b9ef8124318adbf8cf6df9a5fd89f1a65aaf7df23e6fb89e4df8ee8f5 | 4da00a67430eb24455129221b90d533e949a38663e733e081fc337b1854e48a8 | 0.001019 | cpp | 4da00a67430eb24455129221b90d533e949a38663e733e081fc337b1854e48a8 | 2844e2694b63036e8f8779d6ac705327e5cdfacbc264a8016ee7e4c700ddf6cf | PIE_released_gem5_runtime | pie_15598 | p02859 | 7d7a841fb341ce94eff47004cb1c2fe7aa6fbb61cff6fbf239b8178dede48809 | 2844e2694b63036e8f8779d6ac705327e5cdfacbc264a8016ee7e4c700ddf6cf | 0.009657 | 9.473749 | 8+ | cb889ace61190594a7831739a3678c82a3840f21f696a5de2c2465e936d9404a | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define first f
#define second s
#define N 1000000
vector<ll> v(N);
ll l, m, n, sum, ans, maximum, minimum, mahakal, a, b, c, t, i, j, k;
ll cnt, cnt1, cnt2, cnt3;
string str, str1;
ll arr[N];
int main() {
cin >> n;... |
#include <bits/stdc++.h>
using namespace std;
#define ll long long
#define mod 1000000007
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(NULL); ... |
2020bd3c28260433d4bde7626389b31ecd95af7909eb3a815b38e96abb5a10e1 | 06cb88dd5485f9e5959c7ad28b899768e4baf03f6e6f1bf09c0809ff95e07121 | 0.164756 | cpp | 06cb88dd5485f9e5959c7ad28b899768e4baf03f6e6f1bf09c0809ff95e07121 | 833ab4de27d005381a24a1e9d64932c519098a3fa8e52094e8d9c4ccea04472d | PIE_released_gem5_runtime | pie_1566 | p02804 | d7dac62165fdd7ac72a23c43b387f0809de0fb7412029b63005d97fb3db6e9e0 | 833ab4de27d005381a24a1e9d64932c519098a3fa8e52094e8d9c4ccea04472d | 0.519975 | 3.156034 | 2-4 | 8bd185fc668746df6163a174af35c3480f449004fa35e273886d0424a2764b43 | #include <bits/stdc++.h>
using namespace std;
#define ms(x, y) memset(x, y, sizeof(x))
#define lowbit(x) ((x) & (-x))
#define sqr(x) ((x) * (x))
typedef long long LL;
typedef pair<int, int> pii;
typedef pair<LL, LL> pll;
const int maxn = 1e5 + 5;
const LL MOD = 1e9 + 7;
LL F[maxn], invF[maxn], inv[maxn];
voi... | #include <bits/stdc++.h>
using namespace std;
#define endl '\n'
#define pb push_back
#define mp make_pair
#define SZ(x) ((int)(x).size())
#define all(x) x.begin(),x.end()
#define mem0(s) memset(s,0,sizeof(s))
#define meminf(s) memset(s,0x3f,sizeof(s))
#define mp_insert(a,b,c) mp.insert(map<pair<int,int>,int>::... |
bf2f6ba276e2ed8814ac79627b34b9cd030ad2ae04dce755d752072d825ee4ec | 6738b819d167b2ba463cf54bfd7c3888886fd9d1b2d9af2c4720d53d671b969f | 0.008387 | cpp | 6738b819d167b2ba463cf54bfd7c3888886fd9d1b2d9af2c4720d53d671b969f | beea56877e53c99423c3787dd8440f60b56bca273a1691324fc3252a7b87279c | PIE_released_gem5_runtime | pie_1588 | p03544 | bf7d3b52abe729df6a15ab26c666328ccfd463b82808032076dea29857a92674 | beea56877e53c99423c3787dd8440f60b56bca273a1691324fc3252a7b87279c | 0.266822 | 31.814326 | 8+ | 37a90710917573cb6287cb91d39b88f7e18156f01e8084851362c913718b1a0f | #include <stdio.h>
#include <iostream>
#include <algorithm>
#include <string.h>
#define ll long long
using namespace std;
struct node
{
int a[1000] = {0};
int num;
} s[1005];
int main()
{
s[0].a[0] = 2;
s[0].num = 0;
s[1].a[0] = 1;
s[1].num = 0;
for (int i = 2; i <= 1000; i++)
{
for... | #include <cstdio>
long long f[100] = {2, 1}, x;
int main() {
scanf("%lld", &x);
for (int i = 2; i <= x; ++i)
f[i] = f[i - 1] + f[i - 2];
printf("%lld\n", f[x]);
return 0;
} |
ec337903b0ba18d454fc6782d0fd6178ca8b05e259abba18a9e19443daddaf46 | d3f195e6b0a8dac97453ff4b6dffca4102e1cade69662217f78a8b640bc95f2d | 0.111316 | cpp | d3f195e6b0a8dac97453ff4b6dffca4102e1cade69662217f78a8b640bc95f2d | ef93aacc0decf9564843d83f22b7e8aa114931c305682f1425b194b2fe3ee8e9 | PIE_released_gem5_runtime | pie_1604 | p02895 | 3e3f57007272633932e5fa47406aef04dfb4685b3c0f59e976ff3fb0c8540386 | ef93aacc0decf9564843d83f22b7e8aa114931c305682f1425b194b2fe3ee8e9 | 0.242795 | 2.181129 | 2-4 | 60bdc73dd0dd0c6e5f918d063fe87c4957e9d27bcbf0af94151d1e4b51e7a6b5 | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = a, _e = b; i <= _e; ++i)
#define ll long long
using namespace std;
const int N = 50;
int n;
char a[N][N];
ll f[N][N][N], ans;
ll calc(int l, int i, int r) {
if (l == r)
return 1;
if (l == i || i == r)
return 0;
if (f[l][i][r] != -1)
... | #include <bits/stdc++.h>
#define fo(i, a, b) for (int i = a, _e = b; i <= _e; ++i)
#define ll long long
using namespace std;
const int N = 50;
int n;
char a[N][N];
ll f[N][N][N], s[N][N], ss, ans;
int main() {
scanf("%d", &n);
n *= 2;
fo(i, 1, n) scanf("\n%s", a[i] + 1), f[i][i][i] = 1;
for (int len ... |
095f5974689ff705ee3ceffc0179f4baa009b96eb188de8e08ebf6712dda2e09 | 0f514f2905f180ea8b9338adb7440a373018047fdbb929db990c18d0ffe349c1 | 0.010961 | cpp | 0f514f2905f180ea8b9338adb7440a373018047fdbb929db990c18d0ffe349c1 | 67f8431a9e7b7ce392a0773c142cd2e86f4a01a272f34246258c88474a0da4b2 | PIE_released_gem5_runtime | pie_16054 | p02343 | 2f543b977fe7674d08095d5926e6b1bbed287c9e8c0c79f0edee7e131b7f4953 | 67f8431a9e7b7ce392a0773c142cd2e86f4a01a272f34246258c88474a0da4b2 | 0.066155 | 6.035485 | 4-8 | bf7b506e03ead165c72cbe7a439152bbe1c84307590965acded7081ca9b5c1c8 | #include <cstdio>
#include <vector>
using namespace std;
vector<int> l[10000];
int s[10000];
int n;
void unite(int x, int y) {
if (s[x] == s[y])
return;
int i, j, tmp;
int sx = s[x];
int sy = s[y];
for (i = 0; i < l[sy].size(); i++) {
tmp = l[sy][i];
s[tmp] = sx;
l[sx].push_back(... | #include <cstdio>
#include <cstdlib>
typedef struct node_ {
int key;
int height;
struct node_ *parent;
} node;
node *nd;
node *top(node *nd) {
while (true) {
if (nd->parent == NULL)
break;
nd = nd->parent;
}
return nd;
}
void unite(int x, int y) {
node *a = top(nd + x);
node... |
df29e7f9b8f4e64144f22c76088772cd32e09506d559ef3d9ac3747ec80f616c | 07b7709949d7edf42a3d4c43a3ffb19bb38be4b77c931e2a4cfc429922b88c74 | 0.006116 | cpp | 07b7709949d7edf42a3d4c43a3ffb19bb38be4b77c931e2a4cfc429922b88c74 | 15d9b4783a4b8ffc83d4c4ba44515be1b54d25a4b40d7a638ef20a70f356e5c3 | PIE_released_gem5_runtime | pie_16104 | p03416 | dbb718fec2f6d71eb2171e9272fce82eaad02c801ee532f799c619ba140c3c1c | 15d9b4783a4b8ffc83d4c4ba44515be1b54d25a4b40d7a638ef20a70f356e5c3 | 0.080572 | 13.173479 | 8+ | 0a0a6cdb3135d4db274f86b50e5ae49b0fb48b48687fc938c8584f95484f1924 | #include <iostream>
#include <string>
#include <cstring>
#include <algorithm>
#include <cstdio>
#include <cmath>
#include <set>
#include <map>
#include <vector>
#include <queue>
#include <sstream>
using namespace std;
#define sf scanf
#define pf printf
#define pfn printf("\n");
#define pfk printf(" ");
... | #include <stdio.h>
#include <math.h>
#include <string.h>
int main() {
int a, b;
scanf("%d %d", &a, &b);
int i, j;
int cnt = 0;
for (i = a; i <= b; i++) {
int c, d, e, f, g;
c = i / 10000;
d = i % 10000 / 1000;
e = i % 1000 / 100;
f = i % 100 / 10;
g = i % 10;
if (c =... |
a4e8a523326d23f37f9b25f209bc516fe3625a37dd6e64ce03a034cfeb399ce3 | 35e1a6bfe6faf43a4d026354b8a94b61ebbfb6adfe51a706e8b95dba7e77dbb3 | 0.021498 | cpp | 35e1a6bfe6faf43a4d026354b8a94b61ebbfb6adfe51a706e8b95dba7e77dbb3 | 1a1f42446bf7936d521302babb98837d408b1bc9266da4e90dba93f5869d85d6 | PIE_released_gem5_runtime | pie_16117 | p03056 | d37de98f41330f099eb53e1f8a063711b7746368848093ae9e9a3d5d0bcfd55f | 1a1f42446bf7936d521302babb98837d408b1bc9266da4e90dba93f5869d85d6 | 0.105695 | 4.916404 | 4-8 | d8d1e044579dbd0f83cef4de4a6224db9419cd91ea95c32d3692e442d469aa8e |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
w = -1;
c = getchar();
}
while (c >= '0' && c <= '9')
X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N... | #include <cstring>
#include <cstdio>
inline int min(int a, int b) { return a < b ? a : b; }
inline int max(int a, int b) { return a > b ? a : b; }
const int _ = 200;
int n, m, s[_][_], dp[2][_][_][_];
char a[_][_];
inline int chk(int x1, int y1, int x2, int y2) {
int res = s[x2][y2] - s[x2][y1 - 1] - s[x1 - 1]... |
48f14556ca94ee760f1c12805fe2144235de8d1f2d803c8bc3e0e50113b92a99 | 6e31ccd0c52817d58c74e7a566acfc356033df091ae2e9d8fafdd529a1ec2ee3 | 0.088508 | cpp | 6e31ccd0c52817d58c74e7a566acfc356033df091ae2e9d8fafdd529a1ec2ee3 | dbf836a426bf016361f02a7feffb0dd5336abb667c09341e1801a8e2026bdf30 | PIE_released_gem5_runtime | pie_16119 | p03296 | 2825a37b8c105493cb2d41ef435dff76ef5ff02d51991f9b4157ac62fcd87340 | dbf836a426bf016361f02a7feffb0dd5336abb667c09341e1801a8e2026bdf30 | 0.56273 | 6.357931 | 4-8 | e5b9b447ece07b9b698f4e97174fa434d977e1fcda9502a1e651fa77dca65447 |
#include <iostream>
#include <climits>
#include <bitset>
#include <stack>
#include <queue>
#include <iomanip>
#include <limits>
#include <string>
#include <cmath>
#include <set>
#include <map>
#include <math.h>
#include <algorithm>
#include <vector>
#include <string.h>
#include <complex>
using namespa... | #include <bits/stdc++.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> T;
long long int INF = 2e18;
const ll fact_table = 1200008;
double Pi = 3.1415926535897932384626;
priority_queue<ll> pql;
priority_que... |
f681c4ff0f29f847a499271745ee9fd3d6f2f6b1a202152ad1e58f1056be9c73 | e56eefd401725da5d66dc6c1b8c0dbc95dee060474f1af467a5315ed8023ccf6 | 0.055615 | cpp | e56eefd401725da5d66dc6c1b8c0dbc95dee060474f1af467a5315ed8023ccf6 | f8442c2d43ffd0d36d95126575684d964008de30238e129c72cb85d863b97cbd | PIE_released_gem5_runtime | pie_1614 | p03290 | f0f07009409750c9746d3828ba0c6afb04dc8b30fea127b538174ae11cbb4950 | f8442c2d43ffd0d36d95126575684d964008de30238e129c72cb85d863b97cbd | 0.533539 | 9.593418 | 8+ | f67d407337b07aa7936675b8a320f299497f0e841619dc54c3e8124b7d5f8160 | #include <iostream>
#include <algorithm>
#include <iomanip>
#include <string>
#include <vector>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
const int MOD = 1e9 + 7;
const int MOOD = 998244353;
#define PI 3.14159265359
typedef long long ll;
using name... | #include <iostream>
#include <algorithm>
#include <iomanip>
#include <string>
#include <vector>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <set>
#include <map>
const int MOD = 1e9 + 7;
const int MOOD = 998244353;
#define PI 3.14159265359
typedef long long ll;
using name... |
a973ada27c14dc8ba3ed90b6361523e5f339ca7269da5c183f867a4d23609686 | f51131d56a7d70f5fa2deb4196b7e62d5fd505191db6e99ec5772bd8d1454bfe | 0.000183 | cpp | f51131d56a7d70f5fa2deb4196b7e62d5fd505191db6e99ec5772bd8d1454bfe | 0785c0f1d1dd94be6841d0ef28c380ce3803a4239ce237ca796c6f0275f6dcc0 | PIE_released_gem5_runtime | pie_16140 | p03401 | 1a93721970ac7379494c96bec455b9141f4acaf5dbfc386f88ff47691487951e | 0785c0f1d1dd94be6841d0ef28c380ce3803a4239ce237ca796c6f0275f6dcc0 | 0.001851 | 10.094345 | 8+ | 4c47079a7bb9e219b9a034a47319753f49ca62f74339675ea28adc0fb3f4a30c | #include <iostream>
#include <stdio.h>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <set>
#include <queue>
#define ll long long
using namespace std;
int pos(int n)
{
if (n < 0)
return 0;
else
return n;
}
int main()
{
int a[100002][2]... | #include <cstdio>
#include <cctype>
int n, a[100010], tot;
int read() {
int ret, fl = 1;
char ch;
while (!isdigit(ch = getchar()))
(ch == '-') && (fl = -1);
ret = ch - '0';
while (isdigit(ch = getchar()))
ret *= 10, ret += ch - '0';
return ret * fl;
}
void print(int x) {
if (x < 0)
... |
aa84ff77e8138d5650424c3736148cd1982a7d53192caf39cfdb655fce144e00 | 47c79289b9e82b27925bfec59b43b9d0c0f5adca8b1d8c99825a546272ac1947 | 0.104979 | cpp | 47c79289b9e82b27925bfec59b43b9d0c0f5adca8b1d8c99825a546272ac1947 | 9d6ebd7d5376a126ee4f51e4bf9ac1f6c2d40efb0b30e873dbb6c6b660c75548 | PIE_released_gem5_runtime | pie_16161 | p03828 | 91ee55cd492ef916c2b12a8e816cf45c6ed8c61be23cc40ec448ffbfa85c879b | 9d6ebd7d5376a126ee4f51e4bf9ac1f6c2d40efb0b30e873dbb6c6b660c75548 | 0.274245 | 2.612388 | 2-4 | d619c04d787f58701301c316c3956c11a67f73336b9469c51c05a4a31ab98f7a | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vecto... | #include <iostream>
#include <cstdio>
#include <string>
#include <algorithm>
#include <utility>
#include <cmath>
#include <vector>
#include <queue>
#include <set>
#include <map>
#include <numeric>
#include <functional>
using namespace std;
typedef long long ll;
typedef vector<ll> vl;
typedef vector<vecto... |
ce2f51a2def06675f9c3857dc0094459c9d8dcd3dcb80591ebcbcdb1956930f1 | 897a5bd9f25aeed4059bd0e6683d3c28efbfdbb767fbc5f78f42c3aabe89d230 | 0.105985 | cpp | 897a5bd9f25aeed4059bd0e6683d3c28efbfdbb767fbc5f78f42c3aabe89d230 | 5aec671dd021af08824d7464c44f1495f604e52e17f6d348ab9ca0e82a90147e | PIE_released_gem5_runtime | pie_16175 | p03559 | cf9dfe68d5fa2897127e3b189e90ccbfef6f42cf0e8f0f36423961b9c76b60da | 5aec671dd021af08824d7464c44f1495f604e52e17f6d348ab9ca0e82a90147e | 0.283682 | 2.676618 | 2-4 | 732183abde459892dabeab76043c881a8e001851b6b92e2867f4b45a2770dad7 | #include <iostream>
#include <algorithm>
#include <fstream>
#include <utility>
#include <iomanip>
#include <cstring>
#include <string>
#include <sstream>
#include <vector>
#include <queue>
#include <cmath>
#include <map>
#include <set>
#define IO ... | #include <math.h>
#include <algorithm>
#include <iostream>
using namespace std;
typedef long long int LL;
const int N = 1e5 + 5;
int a[N];
int b[N];
int c[N];
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
for (int i = 0; i < n; i++)
cin >> b[i];
for (int i = 0... |
01c8b89be8b19a4efcba39c4360e0184b7b662f32a8c6303ffd4e878a87a6d10 | b2f4bbcd736b8faec483e5880445268755db6a73519328bc92f526db3881847a | 0.001016 | cpp | b2f4bbcd736b8faec483e5880445268755db6a73519328bc92f526db3881847a | 41b5f345d9d2857ea9c49ffb7bc11ec5222c2c205801625d9a17f1d54973642e | PIE_released_gem5_runtime | pie_16182 | p03182 | edbb65aced682fb10fcbaf2b958d4ad3e062bded8551762e5c38dca0eb9bf652 | 41b5f345d9d2857ea9c49ffb7bc11ec5222c2c205801625d9a17f1d54973642e | 0.012544 | 12.351962 | 8+ | 11a897168ad4ca8c32ed09c2ccf5b5cd60e4363d2658b8d649f361cc34ce73bf | #include <bits/stdc++.h>
#define ull unsigned long long
#define ll long long
#define endl '\n'
#define pb push_back
#define mod 1000000007
#define mp make_pair
#define pi acos(-1)
#define line cout << "----------------------------" << endl
#define fast ... | #include <bits/stdc++.h>
#define eps 1e-3
#define pi acos(-1.0)
#define inf 0x3f
#define INF 0x3f3f3f3f
#define pb push_back
#define debug1 cout << "&&";
#define debug2 cout << "**";
#define ms(a, x) memset(a, x, sizeof(a))
#define for0(i, n) for (int i = 0; i < n; ++i)
#define for1(i, n) for (int i = 1; i <=... |
1c8e3f2ddc7146dad33be2ac66dff9059a5116f88fd2a295d8bad4a54f2b8e1c | 97339af4f3758653ba85ed652f9ea028be156d9ce727ecffbe15c6f377fd5369 | 0.098763 | cpp | 97339af4f3758653ba85ed652f9ea028be156d9ce727ecffbe15c6f377fd5369 | 54612b92871154ec3cfab96f6145f9e409a00dabf2557aa3aec486e56772e662 | PIE_released_gem5_runtime | pie_16201 | p02718 | d3d9fcd377c6e06c3f68cc9c213072d84ea507e88aaf243d2b25811b4ae42613 | 54612b92871154ec3cfab96f6145f9e409a00dabf2557aa3aec486e56772e662 | 0.25927 | 2.625173 | 2-4 | 926b28ddacd9ae82ee34991047f2834d2534203cd74d3c963fd86a556533c9ae | #include "bits/stdc++.h"
#define _ ios_base::sync_with_stdio(0);cin.tie(0);
#include <iostream>
#include <stdio.h>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair <ll, ll > pll;
bool comp(const pll& a, const pll& b)... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
#define rep(i, x, y) for (int i = x; i < y; i++)
#define rel(i, x, y) for (int i = x - 1; i >= y; i--)
#define all(x) x.begin(), x.end()
int main()
{
cin.tie(nullptr);
ios::sync_with_stdio(false);
cout << fixed << setprecision(15);
i... |
a61e7be6cf59264dc368837fc1cb6347d6fe0f3fe0ff6f5c8c4462ad1c69c627 | 647ecdbc0c91735e24e82130bc0552838fff7ad2f2e1b9e55b9fa5ed7daecb9e | 0.108191 | cpp | 647ecdbc0c91735e24e82130bc0552838fff7ad2f2e1b9e55b9fa5ed7daecb9e | e293376412d2cb1470cb274261f36b1c4fd3667048a042c9674a778da1dfdc59 | PIE_released_gem5_runtime | pie_16368 | p03173 | 7e79c687a8067defde8470b58d0a4d41d49b4647fa2d183d4941f5b834ecb519 | e293376412d2cb1470cb274261f36b1c4fd3667048a042c9674a778da1dfdc59 | 0.418643 | 3.869485 | 2-4 | 313c4115f65bfb952f27d86ca3fb9d81ec22e4e7ff52123aae2d6a13da065dfa |
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <... |
#include <cstring>
#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <... |
32c529ffebea102242b38c1c25772aff754a535a320738a4c83e2e32dc232f8d | d2474df4040b1a644fe8b9e43571d184966aa8e5c762a88c4df36e0f374e2538 | 0.106792 | cpp | d2474df4040b1a644fe8b9e43571d184966aa8e5c762a88c4df36e0f374e2538 | ceb2eedffcf8c834ea4345edeb21f34505e744cf5680ee86bf2aca54d4bff43a | PIE_released_gem5_runtime | pie_16504 | p02888 | d5a2e9c16b550d3d76db295a88b7d4830129eddf57b4e97124bc7921df982353 | ceb2eedffcf8c834ea4345edeb21f34505e744cf5680ee86bf2aca54d4bff43a | 0.33324 | 3.120457 | 2-4 | f17244af255845ec68c34a0156c6a5041e3bb70995060ed74d3d377ded2f5703 | #define DEBUG 0
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include ... | #define DEBUG 0
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <chrono>
#include <cmath>
#include <complex>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include ... |
b6aaa7d57edf4fd23ffd1f9bc3934ae47ede6b950053981ddfdccd9578ed769e | 468e1a0c3fff4ddad772e8ca0f210a33f718b69200dafa73490cb212f945d879 | 0.054793 | cpp | 468e1a0c3fff4ddad772e8ca0f210a33f718b69200dafa73490cb212f945d879 | 3814fb1edd0b8f951c63c335e40acc19d979fc527c629e6cca2c09efd510d66b | PIE_released_gem5_runtime | pie_16593 | p01884 | d2c1c87753998da32d237c26af3aa0b5d363aa277c15a44a9947974649d02673 | 3814fb1edd0b8f951c63c335e40acc19d979fc527c629e6cca2c09efd510d66b | 0.383138 | 6.992485 | 4-8 | a5b4aa5c128669ef60062d7611443a788c2dba669ee2387b71726825a5b945e7 | #include <bits/stdc++.h>
using namespace std;
#define ull unsigned long long
#define ll long long
ll ans;
map<ull, ll> m;
const int maxn = 200005;
vector<int> g[maxn];
ull dp[maxn];
const ull b = 1000000007;
void dfs(int u, int p)
{
dp[u] = 1;
for (int i = 0; i < g[u].size(); i++)
{
int v = g[u... | #include <cstdio>
#include <vector>
#include <map>
using namespace std;
const int N = 100005;
int fa[N];
unsigned long long value[N];
int sons[N];
int rsons[N];
vector<int> now;
bool vis[N];
map<unsigned long long, int> times;
int main(int argc, char const *argv[])
{
int n;
scanf("%d", &n);
for (i... |
438702921e01978657a4c0684d79c86c68431a4d5325cdd611e8ed464a983116 | 4e2f8b3e8608275580a624ef16c061169e7591f882e70c87e48efbc2614f3c37 | 0.019606 | cpp | 4e2f8b3e8608275580a624ef16c061169e7591f882e70c87e48efbc2614f3c37 | eb22564b95802da12c7b51886ab9b26d41eb1a5794bf53282aa0b0e047ad9cc7 | PIE_released_gem5_runtime | pie_16716 | p03045 | 795a66d4e6dadf5ce7362383e93979a83a4384edafa40508bc5b6589da096d1c | eb22564b95802da12c7b51886ab9b26d41eb1a5794bf53282aa0b0e047ad9cc7 | 0.985312 | 50.255833 | 8+ | eda3e1d19e236c0b7a977bb4fb8394af76f4ffc01af67f415760f16d19d23e7c |
#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;
using namespace std;
template <typename T>
using ordered_set =
tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define F first
#define S second
#d... | #include <stdio.h>
const int maxn = 1e5 + 7;
int pre[maxn];
bool you[maxn];
int Find(int x)
{
if (pre[x] == x)
return x;
else
return pre[x] = Find(pre[x]);
}
void join(int x, int y)
{
int fx = Find(x);
int fy = Find(y);
if (fx != fy)
pre[fx] = fy;
}
int main()
{
int n, m, sum = 0,... |
53457ab5e909730a3c519f7978888311008d58bb7e975fdebd28da79d476cf6f | 89dbe2bdf560b814119e224ed0a2c554ec2c48fd077153ab70d594f81070836d | 0.03977 | cpp | 89dbe2bdf560b814119e224ed0a2c554ec2c48fd077153ab70d594f81070836d | a84fad162e1457572a529812c268fa5731ff42db4cfc64d49327046f7e0bf7d7 | PIE_released_gem5_runtime | pie_16753 | p02904 | 7f3147bad48003b65b2f9d77f9033fe067e673e065bbd9127e9673bf803a4ae8 | a84fad162e1457572a529812c268fa5731ff42db4cfc64d49327046f7e0bf7d7 | 0.137863 | 3.466507 | 2-4 | 7a8d0ea1d2336264d3357a52e909f3e50ac23a9218a269767324b3d515b34cb1 | #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 <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#includ... |
850b2d7c00ff0a6a650ea632babde15f0bd0d6fb8d2be867133798d981365c67 | 30676776f3dd3437ca105fdcffd2e67c71e28094a3ac506a81971b6fa005dc2b | 0.019198 | cpp | 30676776f3dd3437ca105fdcffd2e67c71e28094a3ac506a81971b6fa005dc2b | 325e6ad59d5da2580c4a009c9ce28504fa45df5ba50a5a34ac40b88a721a9fff | PIE_released_gem5_runtime | pie_1676 | p02807 | 6c309fabf42f75b3e6cb12360ec053e1cfa2748b48bc08bc42af86d13d3f54bd | 325e6ad59d5da2580c4a009c9ce28504fa45df5ba50a5a34ac40b88a721a9fff | 0.469303 | 24.445961 | 8+ | 1fa06831ca754a6efcdf2dc50051ab7df805240532b11cfe25d1c599980b8557 |
#include <bits/stdc++.h>
#define SIZE 300005
#define MOD 1000000007LL
#define EPS 1e-10
#define INF 2147483647
#define LLINF 9223372036854775807LL
#define REP(i, n) for (int i = 0; i < n; i++)
#define FOR(i, a, b) for (int i = a; i <= b; i++)
#define DOWN(i, b, a) for (int i = b; i >= a; i--)
#define SET(a, ... | #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) << "... |
64939e5a3b29fe968f5e03e2aa45910664457f43af81f6b3dab5cf69f3589ff5 | adb06a42b3aa164ae6cec8c9f6faa4c2e4660b1123792af912a29f1e034cedfe | 0.022751 | cpp | adb06a42b3aa164ae6cec8c9f6faa4c2e4660b1123792af912a29f1e034cedfe | 8cdd26ae93c1bae547848a8656fc61103d50b8258622676ede6c99387b098add | PIE_released_gem5_runtime | pie_16831 | p03574 | c7b9f0133a215f4e9d7efe8c2f36e7a85dc7e66ea4f1fcea14420d9b9f560799 | 8cdd26ae93c1bae547848a8656fc61103d50b8258622676ede6c99387b098add | 0.104321 | 4.58528 | 4-8 | 1ceb927ccf2117c6f278fb3f7703c915bf8dcbea9709a850519e0df3453bcf4e | #include <iostream>
#include <cstdio>
#include <cstring>
#define re register
#define maxn 51
using namespace std;
const int dx[] = {-1, -1, -1, 0, 0, 1, 1, 1};
const int dy[] = {-1, 0, 1, -1, 1, -1, 0, 1};
int n, m;
char map[maxn][maxn];
inline int work(int x, int y)
{
int tot = 0;
for (re int i = 0; i... |
#include <cstdio>
int main() {
char a[128][128] = {0};
int n, l, N, L;
const int K = 127;
scanf("%d%d", &n, &l);
for (N = 0; N < n; ++N) {
for (L = 0; L < l; ++L) {
scanf("%c", &a[N][L]);
if (a[N][L] == '\n')
scanf("%c", &a[N][L]);
}
}
for (N = 0; N < n; ++N) {
... |
09ca49af45c6dd66094e67ed676b857713bd560f0105794e13dc6ae388e64390 | d536c7b2289946eef5399ccb50beec8f657b45c690b7b4dab4c8e75f508b6221 | 0.00427 | cpp | d536c7b2289946eef5399ccb50beec8f657b45c690b7b4dab4c8e75f508b6221 | eca7513ab26705f9123a987b850ae55e430b66cc62c7e940014e685c98100de9 | PIE_released_gem5_runtime | pie_16878 | p02710 | cbf9e9062239e4d46ee07183e142a4d2f08f8871d58942349cacdfa6a328931c | eca7513ab26705f9123a987b850ae55e430b66cc62c7e940014e685c98100de9 | 0.202936 | 47.522559 | 8+ | 067e5061f1d4862aba9fc68c9233133efb88c2c412a1720ee70fc169fa9eb8d3 | #pragma GCC optimize("Ofast")
#pragma GCC target("avx2")
#include <bits/stdc++.h>
#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... | #pragma GCC optimize("Ofast")
#pragma GCC target("avx2")
#include <cstdio>
#include <cstring>
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) << " "
#defin... |
e090f95f14c56c75564365fbc4f367f264d3bede3923fab01f02224714180ce4 | fda1c86aa9b1a6b7837489540bcb4601ebf0fb8627b2d9984ddff0a9c7c38fa7 | 0.055791 | cpp | fda1c86aa9b1a6b7837489540bcb4601ebf0fb8627b2d9984ddff0a9c7c38fa7 | c08eba432192329ac9f6a622a19fe3a68765c667fa366def386cab5999a6c235 | PIE_released_gem5_runtime | pie_16906 | p03583 | 3e45a876b2d78c5d3efc045323871b8d7b9276e8cb1ec3b244b19f2b0e5efdd4 | c08eba432192329ac9f6a622a19fe3a68765c667fa366def386cab5999a6c235 | 0.126026 | 2.258892 | 2-4 | 786f5e7769f3e1fa423f4ff0eeabae2fe4b93cbe24595f91a03f116fe2ef4374 |
#ifndef _GLIBCXX_NO_ASSERT
#include <cassert>
#endif
#include <cctype>
#include <cerrno>
#include <cfloat>
#include <ciso646>
#include <climits>
#include <clocale>
#include <cmath>
#include <csetjmp>
#include <csignal>
#include <cstdarg>
#include <cstddef>
#include <cstdio>
#include <cstdlib>
#include... |
#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)((1e9) + 7)
#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++)
... |
b759deab05d7aa803cb48a8f2bc955128cea5048614b7b430f3b748c3c03d878 | e767cd096e377943a21b32c9191bed86ff40e7e33cdf84a3cea3cce382619aa0 | 0.105585 | cpp | e767cd096e377943a21b32c9191bed86ff40e7e33cdf84a3cea3cce382619aa0 | a4c8113858fee2ae9d6484e54afff6e7d648402536f8e0b4340482bf00b79844 | PIE_released_gem5_runtime | pie_16913 | p02851 | 86197ecac74db2933a4855d780eaa36b9dba22d283290743652934469d14c9ed | a4c8113858fee2ae9d6484e54afff6e7d648402536f8e0b4340482bf00b79844 | 0.680959 | 6.449377 | 4-8 | 0f39e8f665dfacf43e2c5aa4d62a7b1303ef5bbdf36c578d4bde232c8ac12865 | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <vector>
#include <cmath>
#include <algorithm>
#include <iomanip>
#include <cctype>
#include <queue>
#include <map>
#include <stack>
#include <string>
#include <cstring>
#include <set>
using namespace std;
typedef long long ll;
typedef ve... | #include <iostream>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <queue>
#include <map>
#include <set>
#include <sstream>
#define INF 0x3f3f3f3f
#define DOF 0x7f7f7f7f
#define mem(a, b) memset(a, b, sizeof(a))
#define IO ... |
04c6b18c039c727d0a8c7e329abd9159f1d0b6491dd392e30aa383c4e9ecee49 | 667533be4738568d75263a4acb7f1be20508a487a8130c26eef95ed68fba98b3 | 0.094333 | cpp | 667533be4738568d75263a4acb7f1be20508a487a8130c26eef95ed68fba98b3 | 1fd6eecfcfed2d2af14b4fe674ca2bf2d70b24a3faabf120b1477a5eea714216 | PIE_released_gem5_runtime | pie_16997 | p03564 | b5e1d84bc7760552f711d084297cc2e918a93777a49b0e00cbf0c0f89992ecc6 | 1fd6eecfcfed2d2af14b4fe674ca2bf2d70b24a3faabf120b1477a5eea714216 | 0.414142 | 4.39023 | 4-8 | 5da750e7d3decedc56471554be708d7ec511b45185681efbd8bc3043529b24dd | #include <iostream>
using namespace std;
int d[11][1 << 20];
main()
{
int n, k;
cin >> n >> k;
d[0][1] = 1;
for (int i = 0; i < n; i++)
{
for (int j = 0; j < 1e5; j++)
{
if (d[i][j])
{
d[i + 1][j + k] = d[i + 1][2 * j] = 1;
}
}
}
for (int i = 0; i < 1e5;... | #include <iostream>
using namespace std;
long n, k, ans = 1;
main()
{
cin >> n >> k;
for (int i = 0; i < n; i++)
{
ans += ans < k ? ans : k;
}
cout << ans << endl;
}
|
c2892edc0373d0233075045988b3f1c6cda67d33c5d307fa1b2bdc59c5354fdf | 3997f6378c7ab5be08abe57e3f0b5c893f119f5cccac5dc4a8814e03e9d44134 | 0.016611 | cpp | 3997f6378c7ab5be08abe57e3f0b5c893f119f5cccac5dc4a8814e03e9d44134 | 5cb35351e33cce3bfc380b81b9201d9423632cbd26310cedc5a83e50c944e444 | PIE_released_gem5_runtime | pie_17106 | p03812 | 7102566ab37d11b363a87ac9f8bf0cc8d18525ba524edfa18bca4bf4c591b8de | 5cb35351e33cce3bfc380b81b9201d9423632cbd26310cedc5a83e50c944e444 | 0.320352 | 19.285069 | 8+ | 1dcc07d52a1a873180ad7b9c071fa63d978eada68543c18a608a6bccdf6bcb7e | #include <bits/stdc++.h>
using namespace std;
#define fi first
#define se second
#define pb push_back
#define mp make_pair
typedef pair<long long, long long> ii;
vector<ii> vec;
long long a[100005], n, dp[100005];
vector<int> graph[100005];
int main() {
cin.tie(0), ios::sync_with_stdio(0);
cin >> n;
... | #include <cstdio>
typedef long long ll;
inline int rd() {
int x = 0, p = 1;
char a = getchar();
while ((a < 48 || a > 57) && a != '-')
a = getchar();
if (a == '-')
p = -p, a = getchar();
while (a > 47 && a < 58)
x = (x << 1) + (x << 3) + (a & 15), a = getchar();
return x * p;
}
const in... |
5c8a36f34fdca5d11f3e320c2178d2d05d78215cef5bb089c13d6652cca71fd0 | 1a3dbd2666e42775d27a5c52b993b96a9a62df17c37a15cb5fa2849de6015763 | 0.043254 | cpp | 1a3dbd2666e42775d27a5c52b993b96a9a62df17c37a15cb5fa2849de6015763 | 434dbf19f7a97e03ae8ce9e9b736d616bc56f3b84e1082d32a95954cfebc15e9 | PIE_released_gem5_runtime | pie_17113 | p02931 | 79f526956bb860dab7e8a00160b07e4de6e5fd8da3a316b6afc5adb438c4a17d | 434dbf19f7a97e03ae8ce9e9b736d616bc56f3b84e1082d32a95954cfebc15e9 | 0.127728 | 2.952954 | 2-4 | 158281e54c4fa199c42f17edf2214a70432b3a1f79eeed56a80af2c7047578e9 |
#ifndef Union_find_hpp
#define Union_find_hpp
#include <cassert>
#include <cstddef>
#include <vector>
class union_find
{
std::vector<int> link;
public:
explicit union_find(const size_t n) : link(n, -1) {}
size_t find(size_t x)
{
ass... |
#ifndef Union_find_hpp
#define Union_find_hpp
#include <cassert>
#include <cstddef>
#include <vector>
class union_find
{
std::vector<int> link;
public:
explicit union_find(const size_t n) : link(n, -1) {}
size_t find(size_t x)
{
ass... |
030982c20e819e2d253f8c392cf6c5688ce1b2060b3273ba9bf8e6d1fd50d993 | b21c8512f6ecf6035025cc1324a5549fd93b216f49c8982fb5a44b6ab764cc10 | 0.075193 | cpp | b21c8512f6ecf6035025cc1324a5549fd93b216f49c8982fb5a44b6ab764cc10 | d25def7eb538e0e2aa51cd31d1b6077b7b91d9d2f86369387f2ecda8561414d5 | PIE_released_gem5_runtime | pie_17121 | p02980 | 3f22c7b0040c89a737f39a0d870ee2878a283d128acb3d2b046c4a36112ef400 | d25def7eb538e0e2aa51cd31d1b6077b7b91d9d2f86369387f2ecda8561414d5 | 0.287704 | 3.826216 | 2-4 | 15bc4f8c39c7a220c69df5dae7cd78c54eca0044c3ac4b75c7ff994a8d9b5faa | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cmath>
using namespace std;
const int maxn = 5e5 + 1000;
typedef long long ll;
int n, m;
const int mod = 998244353;
int fr[maxn], ans;
inline int ksm(int num, int t) {
int res = 1;
for (; t; t >>= 1, num = 1ll * num * num % mod) {
... | #include <bits/stdc++.h>
using namespace std;
#define re register int
#define F(x, y, z) for (re x = y; x <= z; x++)
#define FOR(x, y, z) for (re x = y; x >= z; x--)
typedef long long ll;
#define I inline void
#define IN inline int
const int Mod = 998244353;
int n, m, ans, fac[505000], inv[505000], sum;
I add... |
3b6e70db5f48edd0d5c5a3bab2e458f597eedf9dd480b7cf23b427e0c6bcd075 | 12cd8983e9c47b4766726e04a758beed617f96a5906e38847126d99f538b578d | 0.063117 | cpp | 12cd8983e9c47b4766726e04a758beed617f96a5906e38847126d99f538b578d | 6fad6827854907beaa7ce416da6cb55a7b85ab53e1f4b28ffa5c8bdbc2aef02f | PIE_released_gem5_runtime | pie_17142 | p03244 | 8f05fe114220e34d0b370a1378e7304e1268847ad7717e357894e1252e37e808 | 6fad6827854907beaa7ce416da6cb55a7b85ab53e1f4b28ffa5c8bdbc2aef02f | 0.146209 | 2.316454 | 2-4 | dff7565ea4c3b1874bc158804cdff12c152327cdff31a1002e41365ad2fa03cc | #include <bits/stdc++.h>
#define reg register
using namespace std;
typedef long long ll;
const int MN = 1e5 + 5;
int n, a[MN], c[MN][2];
int main() {
scanf("%d", &n);
for (reg int i = 1; i <= n; i++)
scanf("%d", a + i);
for (reg int i = 1; i <= n; i++)
c[a[i]][i & 1]++;
reg int mx1 = 0, smx1 =... | #include <cstdio>
#include <cstring>
#include <algorithm>
int Min(int a, int b) { return a < b ? a : b; }
int Max(int a, int b) { return a > b ? a : b; }
inline int read()
{
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-')
f = -1;
c = getchar();
}
while (... |
420c19e672a55af214f32e812a05b0a3a569239bbdf221f7f2b7d579f3984d97 | 6c61bf5a9f832166921eba41b95dccd7b35595386eda7d7019b4461ed46aad29 | 0.004481 | cpp | 6c61bf5a9f832166921eba41b95dccd7b35595386eda7d7019b4461ed46aad29 | 38aad8204754565b518de226a68b6ad894f3b35682b99bc5fbb5488bd916b178 | PIE_released_gem5_runtime | pie_17162 | p03384 | fbf0b7ec58518150225efb85084e8e5875edc476e0058d0c2830866ce0fc8add | 38aad8204754565b518de226a68b6ad894f3b35682b99bc5fbb5488bd916b178 | 0.082912 | 18.504178 | 8+ | 146590772246dcdcd108bd09a2619d9e23f33c1c685dbd36b0e24e14f0a2d10f | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define eb emplace_back
#define ll long long
#define pii pair<int, int>
#define fr first
#define sc second
#define mk make_pair
#define sz(s) (int)s.size()
#define all(s) s.begin(), s.end()
#define ok puts("ok");
#define whatis(x) cerr << #x... | #include <cstdio>
using namespace std;
#define N 205000
int head[N], cnt, dep[N], l, r, in[N], st[N], n, a, b, ct, st2[N], fg, as1[N],
as2[N], is[N];
struct edge {
int t, next;
} ed[N * 2];
void adde(int f, int t) {
ed[++cnt] = (edge){t, head[f]};
head[f] = cnt;
ed[++cnt] = (edge){f, head[t]};
head[t... |
9cac21487a4b11067170d57b7e85dc87dcf65ea756a465130c4560f2c72a8ef1 | bbafb48d180d743ae646b0750737683abdc65ef5d93186c924a3d3735f895817 | 0.026306 | cpp | bbafb48d180d743ae646b0750737683abdc65ef5d93186c924a3d3735f895817 | bc3975992d48e461245cf9c8abbc63f2a66096e4d21a52623e0c1eb318ab3f98 | PIE_released_gem5_runtime | pie_17184 | p03004 | 0bc78d1e4c1ef10cb4c27ced4e9e3c4825e0d8951ad675860e7d0b60115b1a53 | bc3975992d48e461245cf9c8abbc63f2a66096e4d21a52623e0c1eb318ab3f98 | 0.5247 | 19.946157 | 8+ | 89d35721774062a6a29c3e7066914fde3418e491cb725649733938e1d87f6d70 | #include <bits/stdc++.h>
#include <math.h>
using namespace std;
#pragma GCC optimize("Ofast,unroll-loops,no-stack-protector")
typedef long double ld;
typedef long long ll;
struct Point {
ll x, y, x1 = 0, y1 = 0;
Point() {}
Point(ll _x, ll _y, char c) {
x = _x;
y = _y;
if (c == 'U') {
... | #include <stdio.h>
#include <math.h>
#define N 100000000
#define M 100005
int main()
{
int n;
double x[M], y[M];
char c[M];
double minS = -1, S1, S2, l = 0, r = N;
double minl1 = N, maxr1 = -N, maxu1 = -N, mind1 = N, xx1, yy1, move1 = 0;
double minl2 = N, maxr2 = -N, maxu2 = -N, mind2 = N, xx2, y... |
ab72b93bd11f5501f136f3b40e610086f97195295ad930f1cc1d0e1647ca695e | d80f136a75389096191181f6246b8bcd10cc72ca79902a10e17a4bf5020e0869 | 0.106569 | cpp | d80f136a75389096191181f6246b8bcd10cc72ca79902a10e17a4bf5020e0869 | 41d08ffdcb46c738cf08a7206f83f29c4bc6a603d0c7778895f00b27b72042a4 | PIE_released_gem5_runtime | pie_17219 | p01629 | 2e0592cd780e1d31a13cf406d6127d667589d8e11965a61a49c7a6a36011ee2b | 41d08ffdcb46c738cf08a7206f83f29c4bc6a603d0c7778895f00b27b72042a4 | 0.250289 | 2.348615 | 2-4 | 5ff0da89ed670c49f2407fc3db4d66a505ca6a6a350dfc72d04e68fa01b68863 | #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()
const int N = 55;
const int INF = 19191919;
int n, d;
int p[N][N];
int dp[N][N][N];
int par[N][N][N];
int ok[N][N][N] = {};
int main() {
cin >> n >> d;
rep(i, n)... | #include <bits/stdc++.h>
using namespace std;
#define GET_MACRO(_1, _2, _3, NAME, ...) NAME
#define _repl(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define _rep(i, n) _repl(i, 0, n)
#define rep(...) GET_MACRO(__VA_ARGS__, _repl, _rep)(__VA_ARGS__)
#define mp(a, b) make_pair((a), (b))
#define pb(a) push_... |
c92af574cb27666481173032e6a771cb4ef49a65976491d78b0d32b3e8027349 | 194089507c6c78f733979cbfd4151d495efc7fed2b0bca71941b804afc55fff3 | 0.014615 | cpp | 194089507c6c78f733979cbfd4151d495efc7fed2b0bca71941b804afc55fff3 | b9f2bb4da440f8d8d8e9ba6e59f31e38b3680d57f0529b5bd61cabb4528b3ead | PIE_released_gem5_runtime | pie_17221 | p02798 | 990d56c3b5970649ca3b094d79a54587a06d8775b0b2861cdd07dc3e75f45eba | b9f2bb4da440f8d8d8e9ba6e59f31e38b3680d57f0529b5bd61cabb4528b3ead | 0.077326 | 5.290754 | 4-8 | 2bdb1b26dfe22d14fbc6b95b7ecf0814977ba606dce3aec5cccb36a4e767b758 | #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 <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 ... |
a551c26aca80256f55508c594764177596f4e61e279c56d5a4d8328e432148fc | 433c1eeb0bb70e478b7a74f61adf7cf6a2838636adb6c6ed2e5a7e3cddfe4b77 | 0.001011 | cpp | 433c1eeb0bb70e478b7a74f61adf7cf6a2838636adb6c6ed2e5a7e3cddfe4b77 | 2febc73c29384b3653cb2813f493b00f140d17c82c99a17b1510ab231732bd3b | PIE_released_gem5_runtime | pie_17234 | p03920 | b942d1b7521d0c0607122393725c0823b04085feca03f900d9ac242a1bc31856 | 2febc73c29384b3653cb2813f493b00f140d17c82c99a17b1510ab231732bd3b | 0.0066 | 6.526322 | 4-8 | 1eb95141c2c15e89a8f8d322d8989467b26226023e3bd01beea55b42f556f837 | #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 <bitset>
#include <functional>
using namespace std;
const constexpr int INF ... | #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>
using ll = long long;
using namespace std;
const ll MOD = 1e9 + 7;
#... |
7f060e2ec7165af7ff12ae44707bd95a0a5483e86cf9ddf5c9c23370c73e2bc9 | c10328acdaeece9f9dc1b5e48061ed08a44bacad83bb038f44c42b2ed0e948a3 | 0.106785 | cpp | c10328acdaeece9f9dc1b5e48061ed08a44bacad83bb038f44c42b2ed0e948a3 | 6511017f95b41aade4f3c26fb2607fe65c95688789842e36af14fa9dcb82d652 | PIE_released_gem5_runtime | pie_17238 | p00775 | 18db545003bd62873bbbe5543cd30aeebd0477d25ab4ed56a2b186a7fefb0052 | 6511017f95b41aade4f3c26fb2607fe65c95688789842e36af14fa9dcb82d652 | 0.279323 | 2.615747 | 2-4 | 53d8aa0cce8da528c46a4bee5f386c4966af8fb81d650e3a6babda6fc245fdf1 | #include "bits/stdc++.h"
using namespace std;
typedef long double ld;
typedef complex<ld> Point;
const ld eps = 1e-9, pi = acos(-1.0);
class Line {
public:
Point a, b;
Line() : a(Point(0, 0)), b(Point(0, 0)) {}
Line(Point a, Point b) : a(a), b(b) {}
Point operator[](const int _n... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int INF = 1e9;
const ll LINF = 1e18;
template <class S, class T> ostream &operator<<(ostream &out, const pair<S, T> &o) {
out << "(" << o.first << "," << o.second << ")";
return out... |
d50f46b9f1062a03305e224608abc6c72538038282ab7818743368f7c7aaba35 | 4acdb9931487bffbd0aaadbc623f608e4d60a4985917a416b35ac8c24ff224a1 | 0.101228 | cpp | 4acdb9931487bffbd0aaadbc623f608e4d60a4985917a416b35ac8c24ff224a1 | f831ca77b9567b2d6d5c281effdba1d0cf5fc291d62b679932513b0d78c652d7 | PIE_released_gem5_runtime | pie_17248 | p00894 | 75bb87c3693137464d3c61171f1b6c3781c64fc9b65eb4d85a5e7e3a1a73f9c3 | f831ca77b9567b2d6d5c281effdba1d0cf5fc291d62b679932513b0d78c652d7 | 0.396509 | 3.917002 | 2-4 | 8dba2c40c86cf165836f7b92aec136d265619e79a056297772eb6d998ddfc303 | #include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
#include <vector>
#include <stack>
#include <queue>
using namespace std;
int n;
struct Point
{
int when;
Point() {}
Point(int _when) { when = _when; }
};
vector<Point> ... | #include <cstdio>
#include <iostream>
#include <sstream>
#include <iomanip>
#include <cstring>
#include <string>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <functional>
#include <cctype>
#include <ctime>
#include <stack>
#include <queue>
#include <deque>
#include <vector>
#include... |
9eab5a829775fff1804c55d4c46fb1ccd48e39eee4b7add7bc86f1eba89d2131 | c2c4a864b1dec2730a0dd78ad824a6382acb474f8e3aa5a5d1b6d79ec22fb092 | 0.097899 | cpp | c2c4a864b1dec2730a0dd78ad824a6382acb474f8e3aa5a5d1b6d79ec22fb092 | 333f430e2ec6045fcf2785f20764d159fe7fd2956a6f4348d2f8e851414da103 | PIE_released_gem5_runtime | pie_17380 | p03805 | bfcb0e572f9c18c719ccd4e2eae0c6216f153de94b398a4df228cac5b1ae330e | 333f430e2ec6045fcf2785f20764d159fe7fd2956a6f4348d2f8e851414da103 | 0.388217 | 3.965483 | 2-4 | 8897602256df13c49e698d4a6d05044a04f7fd710b1eb9fd00e5687036af3ae5 | #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
struct edge {
int to, from;
};
const int MAX_N = 100000;
vector<edge> G[MAX_N + 1];
int N, M;
void tracePath(int... | #pragma GCC target("avx2")
#pragma GCC optimize("O3")
#pragma GCC optimize("unroll-loops")
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
const int MAX_N = 8;
int dp[1 << (MAX_N - 1)][MAX_N + 1];
int d[MAX_N + 1][MAX_N + 1];
int N, M;
int main()
{
i... |
4825ba5bfd2d23d44ed850b36a0362cd56231342616f00286bddb8b1b1d8e84d | e1bede1ec7bb71fd6a5dfaa8efb435411b5d0b399b0d3e164c4a0ce12f1e2255 | 0.067899 | cpp | e1bede1ec7bb71fd6a5dfaa8efb435411b5d0b399b0d3e164c4a0ce12f1e2255 | 93459541d81dadfa2d39de8e0f0612161cea5d1b907832805cdc1d1150e1ec47 | PIE_released_gem5_runtime | pie_17422 | p03566 | 6b3c07f307cc3cbe1ee0097f90f86e7b7ba04a6a78763db1ae06029b1b2177d8 | 93459541d81dadfa2d39de8e0f0612161cea5d1b907832805cdc1d1150e1ec47 | 0.214068 | 3.152762 | 2-4 | e6d4ab98fdcf62c7b82ec06c5257319ea10f3bf0e6c6f76be84ad8e4c43ac8b0 | #include <bits/stdc++.h>
using namespace std;
#define MXN 20005
int mx[MXN], t[MXN], v[MXN], en;
double memo[MXN][105];
bool visited[MXN][105];
const int inf = 0x3f3f3f3f;
double dfs(int cur, int speed) {
if (cur == en + 1) {
if (speed)
return -inf;
else
return 0;
}
if (visited[cur]... | #include <iostream>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define rep(x, n) for (int x = 1; x <= n; ++x)
#define FOR(x, l, r) for (int x = l; x <= r; ++x)
const int maxN = 505;
struct T
{
double l, r, bg;
int a;
double ed()
{
return ... |
eb01a73775a500568bc0e242c4dbf42b7d694a29f1708d5cfb0163d5ecd550a9 | c969cc208611ffd53d40baf398eee3bc1510301505cf6cf1d252e9d780e1dc1a | 0.056444 | cpp | c969cc208611ffd53d40baf398eee3bc1510301505cf6cf1d252e9d780e1dc1a | 9dcea8e5176c031925a312532c7707acfa89d7e53192095fdf888f1b072300ea | PIE_released_gem5_runtime | pie_17442 | p02367 | f1c25a053563c2a8b4abdf44079205c66b2cb161c3387c17e2138b101cb159c9 | 9dcea8e5176c031925a312532c7707acfa89d7e53192095fdf888f1b072300ea | 0.217696 | 3.856869 | 2-4 | 7a314fc66a83bbbfdd9a630a45e778f8c725af4cdf07fd09e142fc405b0a7bf7 | #include <bits/stdc++.h>
#define N 100001
using namespace std;
typedef pair<int, int> P;
vector<int> G[N];
vector<P> ans;
int cnt[N], dep[N];
void dfs(int pos, int pre) {
for (int i = 0; i < G[pos].size(); i++) {
int nx = G[pos][i];
if (nx == pre || dep[nx] > dep[pos])
continue;
if (dep[n... | #include <bits/stdc++.h>
using namespace std;
class Lowlink{
public:
int V;
vector<vector<int> > G;
vector<int> ord;
vector<int> low; ... |
e46c21a902aee7f9b19a4c05e09c5efbd18ce838774e53db45b0b859bab4ca68 | 1481efb1258173b7f135360647a8f9a1cf9fdfcc28c4a3ff1fdff3f5924ca6b1 | 0.062281 | cpp | 1481efb1258173b7f135360647a8f9a1cf9fdfcc28c4a3ff1fdff3f5924ca6b1 | dde12643a2ab195ad19b04927dcc5992cfe34a8a969dbba253f2b33b43f8721f | PIE_released_gem5_runtime | pie_17506 | p03240 | 8729e3e59fdf6deaaa8ac3a741885bdbfb2906d9959a41991666e1a50a8f061a | dde12643a2ab195ad19b04927dcc5992cfe34a8a969dbba253f2b33b43f8721f | 0.456254 | 7.325772 | 4-8 | 9271ee94a4821e0bcb30c155dbc01310a1349896a2f6e0059d18d68f629539c3 | #include <bits/stdc++.h>
#include <algorithm>
using namespace std;
int main() {
int N;
cin >> N;
int X[110], Y[110], H[110];
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i] >> H[i];
}
int minheight = H[0];
for (int i = 0; i < N; i++) {
minheight = min(minheight, H[i]);
}
int A[11... | #include <bits/stdc++.h>
using namespace std;
int main() {
int N;
cin >> N;
int X[110], Y[110], H[110];
int pos = -1;
for (int i = 0; i < N; i++) {
cin >> X[i] >> Y[i] >> H[i];
if (H[i])
pos = i;
}
for (int i = 0; i <= 100; i++) {
for (int j = 0; j <= 100; j++) {
int hei... |
006f6fb6fb3a7697c05fb0749feab54c08e250a397dc963ae71865502ff5e579 | 8f57cb1a762a1001d971541c618e3d939c11f75ef2c828b79d9cb32b0afc8fca | 0.000202 | cpp | 8f57cb1a762a1001d971541c618e3d939c11f75ef2c828b79d9cb32b0afc8fca | b492a2bff98aa6b3ffe7956079526077a6b238e30bc13dfac93b0239d673f30c | PIE_released_gem5_runtime | pie_17632 | p02852 | 09eb8b232586413d1501f3a7402827621d762c53aa97f02c35fda74b0b973eb6 | b492a2bff98aa6b3ffe7956079526077a6b238e30bc13dfac93b0239d673f30c | 0.001439 | 7.133746 | 4-8 | c68bdb173aadec64c1304bf5c7b801c5fc283fb979377784d7b7119173200ca1 | #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 <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 ... |
d28e317cd8fbe82e88d4c19076f807007ce9157bf43b8a54f8734cba6ad167ee | 2081bdf69cd983bbdbf57b476a39061576960abaa1cb1d2ff589d1412ebd94fd | 0.001037 | cpp | 2081bdf69cd983bbdbf57b476a39061576960abaa1cb1d2ff589d1412ebd94fd | cecde279b64e60afb42962333bdcecccc77883cfbe210471d8a808be27bf5523 | PIE_released_gem5_runtime | pie_17645 | p02281 | e7468be83b1eec47b357af3a6c60591f5e86babd308f25b83abb761d5d01f0b0 | cecde279b64e60afb42962333bdcecccc77883cfbe210471d8a808be27bf5523 | 0.005097 | 4.917658 | 4-8 | 3db1b6c0d2e1b4bcf24d7b3e688fcb3a51ee300a0947ab67788b88171bc99bb0 | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
using namespace std;
typedef long long ll;
struct fun {
int a;
int b;
int c;
} ff[30];
bool cmp(const fun &x, const fun &y) { return x.a < y.a; }
int f[30];
void qian(int x) {
if (x != -1)
printf("... | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
struct tree {
int left;
int key;
int right;
} tr[30];
bool cmp(tree t1, tree t2);
void preorder(tree t);
void inorder(tree t);
void postorder(tree t);
int pre[30], ino[30], pos[30];
int j, k, l;
int main() {
int n;
... |
20e1c6f1d2ead199501fc9608495f9284074e0e8893bf201a1dd3c4bf2efa2ca | 982fac41f2ca804787c91df562b2e68b94daaac168bab36e06cd5fa91b0f16f5 | 0.000202 | cpp | 982fac41f2ca804787c91df562b2e68b94daaac168bab36e06cd5fa91b0f16f5 | 6a0da20dc8d25b686ede89e2f336bd92be116a639fbd7ee97a5380b26e8093ab | PIE_released_gem5_runtime | pie_17740 | p03660 | 4fbd339cf8ca23272c954dac953dd34203a187773ec60dcf4891539ee09bdda2 | 6a0da20dc8d25b686ede89e2f336bd92be116a639fbd7ee97a5380b26e8093ab | 0.005192 | 25.705589 | 8+ | 0028e5fe6a205b7e671d992f2da137602bb6303492e8d0da2d727a9c679ce9dd | #include <iostream>
#include <algorithm>
#include <cstring>
#include <cstdio>
using namespace std;
const int MAXN = 1e5 + 10;
int num1[MAXN], num2[MAXN];
int T, n;
int head[MAXN], net[2 * MAXN], u[2 * MAXN], v[2 * MAXN], tot;
int read()
{
int f = 0, w = 1;
char ch = getchar();
while (ch < '0' || ch > ... | #include <stdio.h>
int d[2][100010], w = 0;
int ta[100010], to[200010], nt[200010];
void f(int s) {
int i, j, t, r, q[100010];
d[w][q[t = 0] = s] = 1;
for (r = 1; r - t; t++) {
for (i = ta[q[t]]; i + 1; i = nt[i]) {
if (d[w][to[i]])
continue;
d[w][to[i]] = d[w][q[t]] + 1;
q... |
01e89ed5420f4f37cc454b46ff34219dfbea725fa6997f94c7623318eee64c14 | 5a847d8775f533ded143bdadd8d397098069c600c2e8a41e2370dcc0346b78b8 | 0.106993 | cpp | 5a847d8775f533ded143bdadd8d397098069c600c2e8a41e2370dcc0346b78b8 | edd127ee4fe0c289fd03c5b9d2ac3175b1d3bc768ba36a0a6a4976964adb6baa | PIE_released_gem5_runtime | pie_17831 | p03986 | 03a918d0387267bc2de9f3a19be9468fe89c74e5ae2cd7be6b81bba7e281dc20 | edd127ee4fe0c289fd03c5b9d2ac3175b1d3bc768ba36a0a6a4976964adb6baa | 0.680842 | 6.363435 | 4-8 | cfc08c2350119cc3559790228fc6c084f91d8bda324ecc8a679a15e4ff62a9ba | #include <iostream>
#include <climits>
#include <stack>
#include <queue>
#include <string>
#include <random>
#include <utility>
#include <cmath>
#include <set>
#include <map>
#include <math.h>
#include <string.h>
#include <iomanip>
#include <stdlib.h>
#include <algorithm>
#include <vector>
using namespa... | #include <bits/stdc++.h>
#include <unistd.h>
#include <sys/time.h>
#include <stdlib.h>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<P, ll> T;
long long int INF = 2e18;
const ll fact_table = 1200008;
double Pi = 3.1415926535897932384626;
priority_queue<ll> pql;
priority_que... |
4b7c2db38539e3d872b78b52a6af496874ce0c2c6208dfa98dce6c62ca5f5886 | 6d3409f16a551262a5719bf898495b87d596db92f8be26b33399643b72afccb0 | 0.013028 | cpp | 6d3409f16a551262a5719bf898495b87d596db92f8be26b33399643b72afccb0 | a50251f3055103ccf272d40167e67762cb8abca0cc00323232595e88f8246271 | PIE_released_gem5_runtime | pie_17865 | p03956 | 5e61373b1dc09350c060c8897941ccac9e6295d3c649c21326da0bbc2371cd64 | a50251f3055103ccf272d40167e67762cb8abca0cc00323232595e88f8246271 | 0.239608 | 18.391437 | 8+ | 001570b1c717514f1690722a6439321fe5e8ec1120144096f9da1246cd8431c3 | #include <cstdio>
#include <algorithm>
#include <vector>
using namespace std;
typedef long long ll;
const int MAXN = 1e5 + 5;
int n, m, flag;
int cnt[3], ncnt, ecnt, c[MAXN];
bool vis[MAXN], evis[MAXN];
struct node {
int v, w, id;
node(int _v, int _w, int _id) : v(_v), w(_w), id(_id) {}
};
vector<node> ... | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int N = 200005;
typedef long long ll;
int n, m, V, E, cnt[3], col[N];
bool vis[N], vise[N * 2], colored;
ll ans;
struct node {
int u, v, w, nxt;
} edge[N * 2];
int head[N], mcnt = 1;
void add_edge(int u, int v, int w) {
... |
4fc7caa545c672923c974e0d3630280bcf2f0e28bca6c465076e61c1dd236b1d | 951f2e734b19096fa26bedf37512ea75bb34410e3b351daeb1125ee396a6019f | 0.108776 | cpp | 951f2e734b19096fa26bedf37512ea75bb34410e3b351daeb1125ee396a6019f | 9a91402a1b75763b305a6a2e2f2241b3eafb3d346c82e9e01f20e631b817ce1c | PIE_released_gem5_runtime | pie_17987 | p02791 | 34f52e52749a4f07f6e442eb53342d2f8ca27bda306fa85976754b8450d067da | 9a91402a1b75763b305a6a2e2f2241b3eafb3d346c82e9e01f20e631b817ce1c | 0.284732 | 2.617608 | 2-4 | ac7d171a11c2a55ee6a9f2e003adabbe7f30275580dabfc687c9803925778f7a | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
ll n, ans = 1, dp;
vector<ll> p(201001);
int main() {
cin >> n;
rep(i, n) cin >> p.at(i);
for (ll i = 1; i < n; i++) {
if (i == 1)
dp = p.at(0);
else
dp = min(p.at(i -... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
const int inf = 1001001001;
int main() {
int n;
cin >> n;
vector<int> p(n);
rep(i, n) cin >> p.at(i);
int mn = 0, ans = 0;
rep(i, n) {
if (i == 0 || p.at(i) < mn) {
ans+... |
9f3d32de5f9c11f088d56354bffa5226218b3797f547697339228a8c14a88680 | 63d5811728b96fba2ec3c1fcc4d83e15e89d2d9eaa3fbb2f80fa372a2f3e5aa5 | 0.025221 | cpp | 63d5811728b96fba2ec3c1fcc4d83e15e89d2d9eaa3fbb2f80fa372a2f3e5aa5 | 8d474b1960d4386300fca61c4718cc4c07cb2e7cf461ca0eb8c94093add12ba3 | PIE_released_gem5_runtime | pie_1808 | p04021 | 993fa17e7fbc9483e76c4a7ab1cc988a2ed8036555d90b3edb4a9c7a72d27cd7 | 8d474b1960d4386300fca61c4718cc4c07cb2e7cf461ca0eb8c94093add12ba3 | 0.19267 | 7.639175 | 4-8 | 99d8114ca90597e7de27ee904610c27f0604f3104391409979440055ab9233dd | #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... |
62a640957289f8e94c9f96d4d3ee5ef8272784bd432be1fdd6b33a09b394caf0 | 220283ea341ffd4b850997457b74f5950b145255fc796349bc825a78c5202ed2 | 0.030323 | cpp | 220283ea341ffd4b850997457b74f5950b145255fc796349bc825a78c5202ed2 | 55e46ff6d07933021a8c07ccf70e275a5a20ef59eedf9ae408015d63bf3a39c1 | PIE_released_gem5_runtime | pie_18116 | p03945 | 4dee1d900c0e90e24061def76f2a70e8fe1316c721f4973d403efa8b436cce43 | 55e46ff6d07933021a8c07ccf70e275a5a20ef59eedf9ae408015d63bf3a39c1 | 0.104352 | 3.441323 | 2-4 | 29c71fb786fb9856689c48fb2b330275c5c7203ae35a79c5971279b7d3f60419 | #include <bits/stdc++.h>
using namespace std;
const int N = 100000 + 10;
int n;
char ss[N];
int main() {
scanf("%s", ss + 1);
n = (int)strlen(ss + 1);
int tot = 0;
for (int i = 1, j; i <= n; i = j + 1) {
for (j = i; j + 1 <= n && ss[j + 1] == ss[i]; j++)
;
tot++;
}
printf("%d\n", t... | #include <cstdio>
#include <cstring>
int main() {
char a[100050] = {0};
while (~scanf("%s", a))
{
int k = strlen(a);
int sum = 0;
for (int i = 1; i < k; i++)
{
if (a[i - 1] != a[i])
{
sum++;
}
}
printf("%d\n", sum);
}
return 0;
} |
4a00bdc398ae42f7b51b0b36c004e0220065abbd0582a9b5269d63e993918055 | 5b270e8dab4fec0159689983c732995475a4bb113d5e3ad93ea8ec6fec39dcba | 0.061014 | cpp | 5b270e8dab4fec0159689983c732995475a4bb113d5e3ad93ea8ec6fec39dcba | d84e7c3a8e3a0236864ff585579f11966b47577a297bbd751db6d707f2f23a03 | PIE_released_gem5_runtime | pie_18386 | p02948 | 1e0f5632a436c6d72331967b447ce74f9eb26fd7bfaf7e2e2a58c49f5edba115 | d84e7c3a8e3a0236864ff585579f11966b47577a297bbd751db6d707f2f23a03 | 0.21213 | 3.476734 | 2-4 | 23cf6431239e3a7f98ac2b0df6a92144e557c9837456142408cc8fed167aff69 | #include <bits/stdc++.h>
using namespace std;
const int N = (int)1e5;
vector<int> dat[N + 5];
priority_queue<int> pq;
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 1; i <= n; i++) {
int a, b;
scanf("%d %d", &a, &b);
dat[a].push_back(b);
}
while (!pq.empty()) {
pq.pop()... | #include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
#ifdef LOCAL
freopen("input.in", "r", stdin);
#endif
int n, m;
cin >> n >> m;
vector<int> adj[m + 1];
for (int i = 1; i <= n; i++) {
int time, reward;
cin >> time >> reward;
... |
f4b816ea4a3897c9fc6d246c9b6499ecd7259a80ad0d2b342367e7633f910a26 | 92f87362e87ff32f9da4f10d5ea9e07e29b06bf543a2fbdccbad3f0902ee6f17 | 0.10077 | cpp | 92f87362e87ff32f9da4f10d5ea9e07e29b06bf543a2fbdccbad3f0902ee6f17 | bcc2417b17c739e1d1f62616abe3e0575a248378a6ad45e3d4a421757da9fcba | PIE_released_gem5_runtime | pie_18397 | p03537 | e813bab82e39b5de450e32c398df55f68a29b0b12284acdb11115e342e06f1f1 | bcc2417b17c739e1d1f62616abe3e0575a248378a6ad45e3d4a421757da9fcba | 0.333031 | 3.304871 | 2-4 | 29896aa9d1c54f66bdd91516681efeb41340ddb17a7cf66ab8a43ec74d76df7a | #include <bits/stdc++.h>
#include <iostream>
#include <cstdio>
#include <vector>
#include <queue>
#include <map>
#include <cstring>
#include <string>
#include <math.h>
#include <algorithm>
#include <functional>
#define int long long
#define inf 10000000000007
#define pa pair<int, int>
#define ll long long... | #include <bits/stdc++.h>
#define int long long
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define ppap pair<pa, int>
#define PI 3.14159265358979323846
#define paa pair<int, char>
#define mp make_pair
#define pb push_back
#define EPS (1e-8)
int dx[8... |
c16c28753293b56bc67d4fef71841edb2a295086ce43a9f9edbbd9ead359cdc0 | bce5f1fb4174ea45ca1fba5f888bb774b4df500469e1bf120fb23e7d810d54e6 | 0.019978 | cpp | bce5f1fb4174ea45ca1fba5f888bb774b4df500469e1bf120fb23e7d810d54e6 | 64583d459b94302353e95f541745fe4f8d0c7f64fb061fc226ad238382a30f19 | PIE_released_gem5_runtime | pie_18430 | p02269 | e261be9e9a775755782d700ef178e3347347402808b68f2d25e35c91ad5e97e8 | 64583d459b94302353e95f541745fe4f8d0c7f64fb061fc226ad238382a30f19 | 0.977715 | 48.940078 | 8+ | deb385b17f166c469b28ceadb4410ad8359d191bf1563b5a7768ff57a9300ac2 | #include <iostream>
#include <string>
#include <cstring>
using namespace std;
const int MAXT = 1000003;
const int MAXN = 1000010;
int n;
string s;
int head[1000003], nex[MAXN], to[MAXN], top, top1, ans[MAXN];
void input()
{
cin >> n;
memset(head, -1, sizeof(head));
memset(nex, -1, sizeof(nex));
}
in... | #define INF 48828125 + 100
#include <cstdio>
#include <cstring>
int pow[] = {1, 5, 25, 125, 625, 3125, 15615, 78125, 390625, 1953125, 9765625};
bool hash[INF];
int HASH(char s[])
{
int h(0);
for (int i = strlen(s) - 1; i >= 0; --i)
{
if (s[i] == 'A')
h += 1 * pow[i];
if (s[i] == 'C')
... |
221f94e697f583172c5960c247d1ed11d65323d35b7622df07709c6e80582fc9 | 21141f1c509a0418be8e8ebc5e37c4dbaa39efd7e8cdfff6c0dddb18a77b044a | 0.09046 | cpp | 21141f1c509a0418be8e8ebc5e37c4dbaa39efd7e8cdfff6c0dddb18a77b044a | 4da9c02790e19d1dbf6c0c7c626905eacd2b4ffa80e6b6630322a739bd704e48 | PIE_released_gem5_runtime | pie_18617 | p03055 | ec429beef614c107e8200c687b5c8ea7326d02d97f260b0d068ee296f381f84f | 4da9c02790e19d1dbf6c0c7c626905eacd2b4ffa80e6b6630322a739bd704e48 | 0.644223 | 7.12165 | 4-8 | a6fddd2d3840d863366019f327a6292573f26953344b7e3ec509d73f2b0bfede | #include <bits/stdc++.h>
using namespace std;
using uint = unsigned int;
using ll = long long;
using ld = long double;
using ull = unsigned long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define dbg(x) cerr << #x ": " << (x) << endl
#define dbg_p(x) cerr << #x ": " << (x).first << ' ' << (x).... | #include <bits/stdc++.h>
const int maxn = 202020;
struct Edge {
int to;
int last;
} a[maxn << 1];
int n, m;
int tot;
int d[maxn];
int head[maxn];
inline void HA(int x, int y)
{
a[++tot] = {y, head[x]};
head[x] = tot;
a[++tot] = {x, head[y]};
head[y] = tot;
}
#define y a[i].to
inline void Df... |
eb809820424168045078782e3c75384cbf4023a5050f038c9403a742a9ffef71 | d6a32974d9dec63742d1f172bbd8f2ec4704d8d50717571ab2b2b0a244a7a610 | 0.023556 | cpp | d6a32974d9dec63742d1f172bbd8f2ec4704d8d50717571ab2b2b0a244a7a610 | fec3847be79b27c899c268ddaaf812c336f15682172722b8ab2129b0f2188e45 | PIE_released_gem5_runtime | pie_18702 | p03802 | 17ee2314e9cfa0b46c196b8752fe30c4ecb530f6170a8fa79009c05012b21569 | fec3847be79b27c899c268ddaaf812c336f15682172722b8ab2129b0f2188e45 | 0.270159 | 11.46882 | 8+ | b0e83c57ef072bdc6dc33a3e456ce77f82190265ce03198a1abbbd8ffd626ccf | #include <cmath>
#include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define fd(i, b, a) for (int i = b; i >= a; i--)
#define efo(i, v, u) for (int i = last[v], u = to[last[v]]; i; i = nxt[i], u = to[i])
#define max(x, y) ((x) > (y) ? (x) : (y))
#define min... | #include <cstdio>
#include <cstring>
#include <algorithm>
#define fo(i, a, b) for (int i = a; i <= b; i++)
#define fd(i, a, b) for (int i = a; i >= b; i--)
#define rep(i, a) for (int i = last[a]; i; i = next_[i])
using namespace std;
int read() {
char ch;
for (ch = getchar(); ch < '0' || ch > '9'; ch = get... |
4ae8f9ef36b3c44f42346427542bb78801e1972ca909b0b3e0bc71cc681ca9b5 | 23c7c926f3a778d8de5da371b9b9084fd727e8d083d844070079dc8e9d399f8a | 0.107752 | cpp | 23c7c926f3a778d8de5da371b9b9084fd727e8d083d844070079dc8e9d399f8a | c56b32b1fcd38cb2b3294a337e23ce5bb0cd98a43827a7977ae9ad8e873ca315 | PIE_released_gem5_runtime | pie_18719 | p01080 | fe53c5387e214f8e2740cf3d849e3ad8041a20e6b10cc3fb2f87d2e054ba4e36 | c56b32b1fcd38cb2b3294a337e23ce5bb0cd98a43827a7977ae9ad8e873ca315 | 0.373406 | 3.465426 | 2-4 | 767f9359cbbf89926e7652a1c00e6021c5642d0b6182c09e3d9678cf7b4b7293 | #define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using PII = pair<ll, ll>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
template <typename T> void chmin(T &a, const T &b) { a = min(a, b); }
template <typename T> void ... |
f93e13ba29f3146ab39c2db3a55deec468b86884fb65bdaf480059d83b96903c | 7875117de66474293c1e79dae08f5962379cef11f1e56a10fec11405dbc1955f | 0.104951 | cpp | 7875117de66474293c1e79dae08f5962379cef11f1e56a10fec11405dbc1955f | dc43f279e36f6fcad33fca9053ec6a5308b27e5bcb4a9535837c4c9c2637b4ea | PIE_released_gem5_runtime | pie_18727 | p03483 | 863b9c25b79219a3259523945fb63a7ccc2c7a57716bda51e74f065424a9041f | dc43f279e36f6fcad33fca9053ec6a5308b27e5bcb4a9535837c4c9c2637b4ea | 0.297079 | 2.830639 | 2-4 | c42a0dc985c84039b45e34e4af01157c619db0fbe7325c145138baa520061b0f | #include <cstdio>
#include <iostream>
#include <cstring>
#include <vector>
#define ll long long
#define debug cout << "debug" << endl;
using namespace std;
const int maxn = 2e5 + 50;
char s[maxn];
int c[maxn], cnt[maxn], ok, n;
bool vis[maxn];
vector<int> loc[30];
int lowbit(int x) { return x & (-x); }
voi... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
#include <math.h>
#include <time.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <set>
#include <map>
#include <queue>
#include <stack>
#include <bitset>
#include <vector>
using namespace std;
#define bll long long
#define... |
2f09cc72c73e787988a90cdbdb6542328df3b8300eead92cc841d2c192c9637a | b1822961e81575a25c2559bf2c07deb57e526a4a0b559bdcfc59f2a38751e1cb | 0.021387 | cpp | b1822961e81575a25c2559bf2c07deb57e526a4a0b559bdcfc59f2a38751e1cb | dfbd4265615984d411a62dc8b98a32977956f9046d04ec33b21fde4f9e2142c1 | PIE_released_gem5_runtime | pie_18728 | p01418 | ef8f9ec2ae561a3c89da9ee065148bf318964db9ee220ec1431ed4e5b878eb3c | dfbd4265615984d411a62dc8b98a32977956f9046d04ec33b21fde4f9e2142c1 | 0.106527 | 4.980975 | 4-8 | 23f7e92f4e9f3c7cb06c26dc6c0917e05aff19396c5037ab9d1721396001411a | #include <iostream>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <vector>
#include <stack>
#include <set>
#include <map>
#include <string>
#include <cctype>
#include <cstring>
#include <string>
#include <numeric>
#include <functional>
#include <iom... | #include <stdio.h>
#include <cstring>
double P, E, T;
double fabs(double x) {
if (x < 0)
x = -x;
return x;
}
double dfs(int k, double pro, double L, double R) {
if (k == 0) {
double mid = (L + R) / 2;
if (fabs(mid - T) <= E)
return pro;
return 0;
}
if (T + E < L || T - E > R)
... |
6139644457283c37dcea75084a5d89528dccefbdf7dc423ba5b720082e63f0e4 | c760911d47ea6c6b3d602e99259d76fda01015c2161996c0221c69a9722ea5b7 | 0.042589 | cpp | c760911d47ea6c6b3d602e99259d76fda01015c2161996c0221c69a9722ea5b7 | 0aa57f823f76180417ce5693ddd77e1e606ae41bb31962d88242af871bb4a300 | PIE_released_gem5_runtime | pie_18740 | p02349 | 6ea55e41956da1006984f407aba365dd821adf928ec531f784b8fc7c91ea4028 | 0aa57f823f76180417ce5693ddd77e1e606ae41bb31962d88242af871bb4a300 | 0.180443 | 4.236901 | 4-8 | d27f9d9febd0afbcdb7bdbf03fb6bcf5e75936eaae871cf0193602782012925a | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define dump(x) cerr << #x << " = " << (x) << e... | #include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define dump(x) cerr << #x << " = " << (x) << e... |
11db758235111de19962b4c3846dbea7be3f6c6ccd0509906f40cf32f629d31f | 3581f74465cd381ac58e9e338b9748601bff2b6265ed4c9e8148acbadf886a02 | 0.098084 | cpp | 3581f74465cd381ac58e9e338b9748601bff2b6265ed4c9e8148acbadf886a02 | 7253c9402e6f6d307d0de83ea2005a6c16ebe4e62a9b992d2db9c1fccd7b3b72 | PIE_released_gem5_runtime | pie_18743 | p03714 | 1f60d803c5b6b2d5e26cf58f064bf152b072de1fc7c45e2615f26548dd48b6ac | 7253c9402e6f6d307d0de83ea2005a6c16ebe4e62a9b992d2db9c1fccd7b3b72 | 0.627514 | 6.397702 | 4-8 | f826f4a1c041ec4aab80424f68e35f3d619b25691f2478e5b620bd57207dcbcd | #include <cmath>
#include <queue>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <algorithm>
#define mod 1000000007
using namespace std;
int n;
long long dp1[300010], dp2[300010], a[300010], sum1, sum2;
priority_queue<long long, vector<long long>, greater<long long> > q;
priority_queue<lon... | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <map>
#include <vector>
#include <queue>
#define LL long long
using namespace std;
const int MaxN = 1e5;
const LL Inf = 1LL << 60;
priority_queue<LL> q2;
priority_queue<LL, vector<LL>, ... |
847c07a1fa57ad6f93036aa39471ee11faa012a19d7949aa3324f7ac7091d712 | b0323351199abcae9ea72d8201780e04c432234a2610622f6cad43a8880ac04c | 0.085217 | cpp | b0323351199abcae9ea72d8201780e04c432234a2610622f6cad43a8880ac04c | 4721e7bc5c1f0d22ca1e7b11ee5488eb2f1df481e511b5ce29a285137f87bd01 | PIE_released_gem5_runtime | pie_18750 | p02604 | 0d3f8e694e37038791225351c37c3c117c4530a135a4f7597d061595a6209b6f | 4721e7bc5c1f0d22ca1e7b11ee5488eb2f1df481e511b5ce29a285137f87bd01 | 0.734853 | 8.623361 | 8+ | eb183d8131de9899d42160986e5e841a447af6a12b92cda2442c116874329cbc | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0, _n = (int)(n); i < _n; ++i)
#define ALL(v) (v).begin(), (v).end()
#define CLR(t, v) memset(t, (v), sizeof(t))
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os <<... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define REP(i, n) for (int i = 0, _n = (int)(n); i < _n; ++i)
#define ALL(v) (v).begin(), (v).end()
#define CLR(t, v) memset(t, (v), sizeof(t))
template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &a) {
return os <<... |
0584776dfd2768ceb964d088e55c6701aaf19b27a58f83a3d4663cb7d7958cff | d2f7617a168c85bda88994e4c36ec183d98ea5b6d06651dd4224c71fe17eb2d4 | 0.1064 | cpp | d2f7617a168c85bda88994e4c36ec183d98ea5b6d06651dd4224c71fe17eb2d4 | 7ef4118352124e761bb739533b54f2698242c6ec27ab54af3d7fcf8de77f111d | PIE_released_gem5_runtime | pie_1876 | p02548 | 3b790c44c02fd5e08f8b90bf5e483383e121cf67ff34aa1e8ec440ad8d4a7b6f | 7ef4118352124e761bb739533b54f2698242c6ec27ab54af3d7fcf8de77f111d | 0.32545 | 3.058756 | 2-4 | 6cbdab09fa049aa59da4272dc75d1ae9fcec02aba6eb54a088fb5b7e3943062c | #include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL (1LL << 62)
#define EPS 1e-9
#define rep(i, n) for (ll i = 0, i##_len = (ll)(n); i < i##_len; i++)
#define repf(i, n) for (ll i = 1, i##_len = (ll)(n + 1); i < i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#... | #include <bits/stdc++.h>
#define ll long long
#define MODV 1000000007
#define INFLL (1LL << 62)
#define EPS 1e-9
#define rep(i, n) for (ll i = 0, i##_len = (ll)(n); i < i##_len; i++)
#define repf(i, n) for (ll i = 1, i##_len = (ll)(n + 1); i < i##_len; i++)
#define all(v) v.begin(), v.end()
#define endl "\n"
#... |
867b7bb81b8f292950d2bbb2f537692a4458d8a5ba82c471bf815eec3bab8121 | 4fd6decf611a6ad0d76f0edab9b6e73a4f2b420215ace7de76f5f297bb95767b | 0.133313 | cpp | 4fd6decf611a6ad0d76f0edab9b6e73a4f2b420215ace7de76f5f297bb95767b | 1eaa5c67b4284f0a89ca23ed2689ef020531c55976dde5b9d78f1f13fd9a7638 | PIE_released_gem5_runtime | pie_18765 | p03305 | b572d96c724963ba3359d702a9797b32ffc8bce9b8df49ac0e60b88e30224e92 | 1eaa5c67b4284f0a89ca23ed2689ef020531c55976dde5b9d78f1f13fd9a7638 | 0.398429 | 2.988679 | 2-4 | 90a76a8220c3768170b1fd444a6effe67c2657e483ee8ec8473314655734e7ce | #include <cstdio>
#include <queue>
#include <vector>
#include <cstring>
#include <algorithm>
using namespace std;
const int Maxn = 1e5;
const long long Tot = 1e15;
typedef long long ll;
struct Edge {
int v;
ll m[2];
Edge(int a, int b, int c) { v = a, m[0] = b, m[1] = c; }
};
vector<Edge> G[Maxn + 5];... | #include <bits/stdc++.h>
#define LL long long
#define INF 1e18
#define MAXN 100005
LL min(LL x, LL y) {
if (x < y)
return x;
return y;
}
int n, m, s, t, u, v;
LL a, b, f = 1e15, ans[MAXN];
struct Graph
{
int cnt, head[MAXN], vis[MAXN];
LL dis[MAXN];
struct Edge {
int next, to;
LL dis;
... |
a273e29fec358291c7378c7bbde1c4c88920018e7b9a09265428035389a4916f | bcf7251a5f2dece3a721a42deeabd8cd893c478f3746e47f9fa2e12c5bca66d8 | 0.104953 | cpp | bcf7251a5f2dece3a721a42deeabd8cd893c478f3746e47f9fa2e12c5bca66d8 | 29917ecfe22627bfce14f8d7d86e7a7ae8cf74e333a51eecc48257bd53ead5c7 | PIE_released_gem5_runtime | pie_18799 | p03565 | 6d18e0183a4c38b32570ae398a2c4374ff06f2d22cec5089deabd9ca6cf1181a | 29917ecfe22627bfce14f8d7d86e7a7ae8cf74e333a51eecc48257bd53ead5c7 | 0.4751 | 4.526764 | 4-8 | d74a1fd3576300248641c7ad8415fe98b223fbb151ca0f8b5b4ddf955802346f | #include <iostream>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
using namespace std;
int main(void) {
string s, t;
cin >> s;
cin >> t;
int count = 0;
int check = 0;
vector<string> ans(100000);
if (s.length() >= t.length()) {
for (int i = 0; i <= s.length() - ... | #include <iostream>
#include <algorithm>
#include <cmath>
#include <vector>
#include <string>
#include <queue>
#include <utility>
#include <map>
#include <bitset>
#include <numeric>
#define ll long long
using namespace std;
using p = pair<ll, ll>;
ll dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
ll dy[8] = {1, 0, ... |
8d0bf6ddce4274ea0fb2ba79ed0edf0cf6ff9ef035976f82c9e905a8a1f58ccb | ec2a5b46f5c35c034dd08ed2caed0dc75150fb88c49676688a7c00d0aaa73140 | 0.108126 | cpp | ec2a5b46f5c35c034dd08ed2caed0dc75150fb88c49676688a7c00d0aaa73140 | 5cc0b3f321685560f95e5789845e329cfd58ff902bad57c400b8d525df7a478e | PIE_released_gem5_runtime | pie_18801 | p03211 | dcd4686bf3b9737ddd81085c596266c26b4993626341dea55dc51ea1ae3800ba | 5cc0b3f321685560f95e5789845e329cfd58ff902bad57c400b8d525df7a478e | 0.374814 | 3.466471 | 2-4 | 81df30d531f810a9924ddfe08cc780deac0f2262cc03a92570e5e416c2765057 | #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 <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <sstream>
using namespace std;
pair<int, long long> p[100006];
int main() {
string s;
cin >> s;
int ans = 1000;
for (int i = 0; i < s.size() - 2; i++)
{
string g = "";
g = s.substr(i, 3);
stringstr... |
a6502ac9730fb1d7c5542306bf89966f725f91b96f0cbd47f5cf7f3ef41fad04 | f358d9fd12872de3f6c4063d8934065685a28ab9452f95092c5909675a67fbda | 0.019743 | cpp | f358d9fd12872de3f6c4063d8934065685a28ab9452f95092c5909675a67fbda | 991495577c12d6a10e2dfc1ce225654efbcc13185763c3988deff05d321d11a6 | PIE_released_gem5_runtime | pie_18814 | p02912 | 1f948d8c860e85e3063f2e28fd2c64c220a4fe1685b34fbf19ba2629e08706a2 | 991495577c12d6a10e2dfc1ce225654efbcc13185763c3988deff05d321d11a6 | 0.096114 | 4.868382 | 4-8 | d31282d98d54eb928d58c8a4b273ca87833fd345b513cc61f748f5846ce66c33 | #include <queue>
#include <cstdio>
#include <algorithm>
using namespace std;
typedef long long LL;
int n, m;
LL ans;
priority_queue<int> Q;
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1, x; i <= n; i++)
{
scanf("%d", &x);
Q.push(x);
}
while (m--)
{
int t = Q.top();
Q.p... | #include <cstdio>
typedef long long LL;
const int MAXN = 100005;
void fix_down(int *h, int i, int n)
{
int j = i, k, t = h[i];
while ((j << 1) + 1 < n)
{
k = (j << 1) + 1;
if (k + 1 < n && h[k + 1] > h[k])
k = k + 1;
if (t >= h[k])
break;
h[j] = h[k];
j = k;
}
h[j]... |
06ca9dd1e5ac955651a0bff00581910b19de8c9a7be42ad8a86dcb8ab492be3a | a645363763411841bfd26a084c4cc0fb7cca6000da9018d34cf0b6d97056acc0 | 0.031624 | cpp | a645363763411841bfd26a084c4cc0fb7cca6000da9018d34cf0b6d97056acc0 | 311d9034a51e84105f513ecce1f5e32123d5ff928709d2b9be3f4b931a9a7dd8 | PIE_released_gem5_runtime | pie_1886 | p04026 | 8333395779d19e08e3f226ba8cf6e68123e1147f674584cdce007ed75dbb15a5 | 311d9034a51e84105f513ecce1f5e32123d5ff928709d2b9be3f4b931a9a7dd8 | 0.099817 | 3.156379 | 2-4 | b1a1da7cf6731c451211ebeaff718e272624fb51a9f7a3921e122cbc1f6139a0 | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
using namespace std;
typedef vector<int> vi;
typedef vector<vi> vvi;
int main(void) {
string s;
cin >> s;
int N = s.length();
int i, j;
for (i = 0; i < N - 1; i++) {
for (j = 0; j < 2; j++) {
if (s[i] == s[i +... | #include <cstdio>
#include <cstring>
using namespace std;
int main() {
char s[131072] = {};
scanf("%s", s);
size_t ub = strlen(s);
s[ub] = '$';
for (size_t i = 0; i < ub; ++i)
for (size_t j = 1; j <= 2; ++j)
if (s[i] == s[i + j]) {
printf("%llu %llu\n", i + 1, i + j + 1);
... |
2357f5968296382ab4b6b3cd14e2f9df17edf4e1eb485076d863818541507b13 | f1840f3d362232ffc976a3ff22420718161862e960278d83bc0c5d41bb7efe61 | 0.02015 | cpp | f1840f3d362232ffc976a3ff22420718161862e960278d83bc0c5d41bb7efe61 | a5276052a9bfd2fae1e71c440dbec13bbdbf60c84c976e76bb1b86fc6f92abf1 | PIE_released_gem5_runtime | pie_18875 | p03215 | a16b554be8163543a010ddcf011721e00cacec4577e60dc45b0607691d84c0f4 | a5276052a9bfd2fae1e71c440dbec13bbdbf60c84c976e76bb1b86fc6f92abf1 | 0.097739 | 4.850579 | 4-8 | 640517f99f22255c35974b032d2e7f7d8a9f4ee631755f6bba9b88c8fb1adbc6 | #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <math.h>
#include <vector>
using namespace std;
#define N 100010
#define LL long long
int a[N];
LL b[N];
vector<LL> q;
int main()
{
int i, j, k, n, m;
int x, y, z;
LL d, t, s;
scanf("%d%d", &n, &m);
b[0] = 0;
for (i = 1; ... | #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
#include <math.h>
using namespace std;
#define N 1000010
#define LL long long
int a[N], vis[N];
LL s[N], b[N], c[N], p[N];
int main()
{
int i, j, k, n, m;
int x, y, z;
LL d, t, ans;
scanf("%d%d", &n, &m);
p[0] = 1;
... |
32ab4d41bd99af49a2ab889d56fed8489f0a817d0e4ff53a9ee280ff7725d42a | 2e9cd44dce7834c689a53d23e41c9981b746b2a37722f525c4070364a8293b84 | 0.061638 | cpp | 2e9cd44dce7834c689a53d23e41c9981b746b2a37722f525c4070364a8293b84 | adb6989fe5c22e0a018cc387e924913990f0d94493f614448b57db128ba49adf | PIE_released_gem5_runtime | pie_18962 | p01460 | 81ce1a123e9c66f834adb9bf7ff82dbc50936bcf2a5e88fae05aec0504f2f41a | adb6989fe5c22e0a018cc387e924913990f0d94493f614448b57db128ba49adf | 0.147992 | 2.40098 | 2-4 | 2ce6ce8db3dd2b05fd843a3eecc22ba780985b47984cf89102e5a513b3449f1a | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <map>
using namespace std;
int n;
int A, B, C;
struct Coordinates
{
int map[40000];
bool rever;
Coordinates()
{
for (int i = 0; i < 40000; ++i)
map[i] = i;
rever = false;
}
void reverse()
{
rever = !reve... | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <map>
using namespace std;
const int maxn = 4e4 + 5;
bool RH, RV, R;
int row[maxn], colum[maxn];
int A, B, C, D, E, F, G, n, q;
struct HashMap
{
int mod;
int begin[100007], next[maxn], val[maxn], key[maxn];
int s, i, num;
void ini()
... |
0a9d8af03d1768233aeabb35ee1b02bb58de9a6211c8f4aa6ce75cf66aaea80f | 469baebe0b628b6ee7fef334606ed200b26ab0b98b987299c7b2da050ee1fe34 | 0.005396 | cpp | 469baebe0b628b6ee7fef334606ed200b26ab0b98b987299c7b2da050ee1fe34 | 7bf3f100e49001e0f39735498010f1c27656ea798ccd935473a630d1ea15c66e | PIE_released_gem5_runtime | pie_19060 | p02597 | 8065ab9634f8b75a8af30a7814892193fef26fec0000a48ae867195029935a6e | 7bf3f100e49001e0f39735498010f1c27656ea798ccd935473a630d1ea15c66e | 0.011095 | 2.056246 | 2-4 | 46e44ce3ff4d5e8c57a9bcc7e58c183f92f3ec27b6be003cdf19068b9e6b035a | #include <stdio.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
int main(void)
{
int N, total = 0, ope = 0;
char stones[200001] = {0};
if (!scanf("%d %s", &N, stones))
return -1;
rep(i, N) {
if (stones[i] == 'R')
total++;
}
ope = total;
rep(i, total) {
if (stones[i] == 'R')
... | #include <stdio.h>
#include <stdlib.h>
#pragma GCC optimize("O3")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
static inline int IN(void)
{
int x = 0, f = 0, c = getchar();
while (c < 48 || c > 57) {
f ^= c == 45, c = getchar();
}
while (c > 47 && c < 58) {
x = x ... |
3dabab375c8877d6c42cf7c31fd0141314737e7f61e0185626c83576101549dd | 976fcf515aed331a1db3e61bb157dc9cde2fb1f07218b36dee6cfa9eb109b431 | 0.145024 | cpp | 976fcf515aed331a1db3e61bb157dc9cde2fb1f07218b36dee6cfa9eb109b431 | 237fe2696cb9c9caa253dddeaa56e31f326ba05c875cc74bb47da970eb8bdf11 | PIE_released_gem5_runtime | pie_1918 | p02588 | 11cc2662ca26444658322c08f252efac9a7a68b463a7e23f01b8d4a0d776e9e8 | 237fe2696cb9c9caa253dddeaa56e31f326ba05c875cc74bb47da970eb8bdf11 | 0.462409 | 3.188489 | 2-4 | d8dcfe3f89590577d1f936bf94a60e7634e92bd4920d491aa31764ee5b2eef00 | #include <bits/stdc++.h>
#define ft first
#define sc second
#define pt(sth) cout << sth << "\n"
#define moca(a, s, b) a = ((a)s(b) + MOD) % MOD
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
ret... | #include <bits/stdc++.h>
#define ft first
#define sc second
#define pt(sth) cout << sth << "\n"
#define moca(a, s, b) a = ((a)s(b) + MOD) % MOD
using namespace std;
typedef long long ll;
typedef pair<ll, ll> pll;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
ret... |
81af2a86b04449b12597f638303f35302311709a3e246b8a2a5762bc5bde1a14 | 6e53fc674b4e6ba8b1fb92a62bf54363cbb773dbee631a7d4a0669a7c4486306 | 0.020115 | cpp | 6e53fc674b4e6ba8b1fb92a62bf54363cbb773dbee631a7d4a0669a7c4486306 | 4239568514faa82d81ff3b7b6405c6d9da04f4de847d407cd1fc034599929b5b | PIE_released_gem5_runtime | pie_22633 | p03162 | 611b3fc9c3de8f270b467c4dfbc4feef7a5066f4232c06b3d462fea8898e0015 | 4239568514faa82d81ff3b7b6405c6d9da04f4de847d407cd1fc034599929b5b | 1.458097 | 72.48784 | 8+ | 341f5ea3244f4e530b03137583c88daa94ec5a32a4a1c3f8c3c580d754257fa2 | #include <bits/stdc++.h>
using namespace std;
const int rest = 1000001;
int dp[3][rest];
int ac[rest][3];
int it;
int va(int a, int i) {
if (i == it) {
return 0;
}
if (dp[a][i] != -1) {
return dp[a][i];
}
int &ans = dp[a][i];
if (a == 0) {
ans = max(ans, va(1, i + 1) + ac[i][0]);
... | #include <cstdio>
#include <algorithm>
using std::max;
#define MAXN 100003
int d[MAXN][3], a[MAXN][3];
int main(void)
{
int i, N;
scanf("%d", &N);
for (i = 0; i < N; i++)
{
scanf("%d%d%d", &a[i][0], &a[i][1], &a[i][2]);
}
d[0][0] = a[0][0];
d[0][1] = a[0][1];
d[0][2] = a[0][2];
for ... |
26d5674a3855b0ea08c2b778637809ae3d48a7210204bbdef11488aaa553e43b | 8ed11f99244d10083708c78278cc62234aa34def894b7de512b2311fe092fbd6 | 0.032918 | cpp | 8ed11f99244d10083708c78278cc62234aa34def894b7de512b2311fe092fbd6 | 41e97c72a470cf3d7e970b20ba3d11a6f2c08b811ed5525444693b4c3beb4b68 | PIE_released_gem5_runtime | pie_24956 | p03575 | 75533aea334c0eece456a4580c168bbaaa5fde07fc5f3c0f4413b35939cf135e | 41e97c72a470cf3d7e970b20ba3d11a6f2c08b811ed5525444693b4c3beb4b68 | 0.123245 | 3.743981 | 2-4 | c4402e1d74352de86c42f9494b640cc04770a9f5a814305ea51c1b9893f5b7a1 | #include <cstdio>
#include <algorithm>
#include <cmath>
#include <vector>
using namespace std;
int n, m, cnt, idx;
int dfn[100001];
vector<int> G[100001];
inline int Tjcv(int u, int fa)
{
int child = 0, lowu;
lowu = dfn[u] = ++idx;
for (int i = 0, v; i < G[u].size(); i++)
{
v = G[u][i];
i... | #include <cstdio>
#include <vector>
using namespace std;
vector<int> e[60];
int n, m, dfn[60], low[60], tot, u, v, sta[60], cnt, co[60], cntot;
void dfs(int x, int las)
{
dfn[x] = low[x] = ++tot;
sta[++cnt] = x;
for (int i = 0; i < e[x].size(); ++i)
{
int y = e[x][i];
if (!dfn[y])
{
... |
bd2652fe6f6d73a792b863ef7cd363b2ec0b840fa71622c793456e314cb2f933 | 06d3c743cdc8820745c5abd823fa8cc9cdb7fbaa533bc429c51a0628dc160ded | 0.099644 | cpp | 06d3c743cdc8820745c5abd823fa8cc9cdb7fbaa533bc429c51a0628dc160ded | 02864a2ec7a325873e9292b48519131f35c6d154898967f8f30d573a12beb748 | PIE_released_gem5_runtime | pie_24973 | p03995 | 6b163d309fd6c35ff609c9d8544cf14e147c4163d986035d5486d62a38faa51e | 02864a2ec7a325873e9292b48519131f35c6d154898967f8f30d573a12beb748 | 0.435719 | 4.372763 | 4-8 | 7c9118a434b55d30c7b375234f66a879f69f98be69fc9e4fe74d5256529c6b04 | #include <bits/stdc++.h>
#define RG register
using namespace std;
struct node
{
int a, b, c;
node(int aa = 0, int bb = 0, int cc = 0)
{
a = aa;
b = bb;
c = cc;
}
} point[100005];
int t, n, m, q, pd[100005], vis[100005], father2[100005], father1[100005];
long long size1[100005], size2[1000... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 100010;
template <class T>
inline void read(T &re)
{
char ch;
int f = 1;
while ((ch = getchar()) < '0' || ch > '9')
if (ch == '-')
f = -1;
re = ch - 48;
while ((ch = getchar()) >= '0' && ch <= '9')
re = (re << 3) + (re << 1... |
ff418fb36441013d54f26cc43d321f0725232c37ea1de4b13b799ad800cf4ce8 | d5bb04a1d2df74332c5af3b9e2f503a886dd5d243d73186b3ffdcf030c6412bc | 0.026523 | cpp | d5bb04a1d2df74332c5af3b9e2f503a886dd5d243d73186b3ffdcf030c6412bc | dc7998210666b4ee557f9867e4702d7c2b1ed857572d6afa7683fa3ba3641fd6 | PIE_released_gem5_runtime | pie_25034 | p02925 | e8c076abfa8cf5b2b1ce146dc33dd6ab8e5cbceb93c0cf14df10247cfc709f49 | dc7998210666b4ee557f9867e4702d7c2b1ed857572d6afa7683fa3ba3641fd6 | 0.107183 | 4.041129 | 4-8 | 546a098b4d14edb6dc42713b7b668df48ea036affe1abcb4e24e5a80a530d040 | #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... |
fc94e0c2de8303dba732f7bd9dcc990ec35719040af725da77017c487f35032c | 665c3407def8958a7a98ea5e874e5ca4d6eb5ebf6d7ae9cea0585857f77def20 | 0.017317 | cpp | 665c3407def8958a7a98ea5e874e5ca4d6eb5ebf6d7ae9cea0585857f77def20 | 46d0975399a856cfe84ced9c489b8690c19c20acbe43ab7bf7ca8902ac21ebd6 | PIE_released_gem5_runtime | pie_25077 | p03612 | 4a1a40fa47b2cad5dc0819d0b13fca0028b7176104f843337baeae3471d32413 | 46d0975399a856cfe84ced9c489b8690c19c20acbe43ab7bf7ca8902ac21ebd6 | 0.133971 | 7.736573 | 4-8 | 4e50c6d20ae770746d2a57ad1b69c963dcfefa30ffe49ac31376e5184de04bd2 | #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>
#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 ... |
86fc69fa318912e92e0bd24a6469b99485da6ce6f12875e072a3e7d00b849826 | f7c1f423a30a54ad26238677dff7c1e9c592821c397fbff8c6fff88e16fd8e7b | 0.00505 | cpp | f7c1f423a30a54ad26238677dff7c1e9c592821c397fbff8c6fff88e16fd8e7b | a270409a6fb9c113e03c18a8920d2c2700a710bc3950c9b2270edc9491132733 | PIE_released_gem5_runtime | pie_25091 | p03318 | ea48c740f7c24f56145318da8076df9a5a9783b465f5e06eb804d7f52a97e2be | a270409a6fb9c113e03c18a8920d2c2700a710bc3950c9b2270edc9491132733 | 0.026779 | 5.302919 | 4-8 | 07723d56c7d2712b0cde562af452a64b7adfb40d3540883b44eb7ee203395b2a | #include <bits/stdc++.h>
using namespace std;
long long pw[20];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
pw[0] = 1;
for (int i = 1; i < 20; i++)
pw[i] = pw[i - 1] * 10;
int K;
cin >> K;
long long now = 0;
while (K--) {
now++;
auto nxt = now, nxt_sum = 0LL;
... | #include <stdio.h>
double cal(long long x)
{
long long sum = 0, temp = x;
while (x)
{
sum += x % 10;
x /= 10;
}
return (double)temp / sum;
}
int main()
{
long long num = 0, bot = 1, temp1, temp2;
int k;
scanf("%d", &k);
while (1)
{
while (1)
{
temp1 = num + bo... |
c812bd5a81289993108c7f957db2954adf9a3d149c6dd288201de7656ba6f364 | a3545087ef53124aa09f87efa9cc6555ec739b1d25d258c6a3fbfa81a2faac26 | 0.000195 | cpp | a3545087ef53124aa09f87efa9cc6555ec739b1d25d258c6a3fbfa81a2faac26 | 55c53fb54a6226afc5401a69f622758e21eba7cd3704a0e575dfb1709781d9d0 | PIE_released_gem5_runtime | pie_25193 | p03638 | 629cee4c18cc2e2df5c89ad3d45779493547d1fe3c5b6d51ccdd3a0ef5b897bf | 55c53fb54a6226afc5401a69f622758e21eba7cd3704a0e575dfb1709781d9d0 | 0.001296 | 6.65805 | 4-8 | 0df0e46da5339e9cde5734086acda8e583b36e1a73a0d819ad6308101dc73cc3 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int maxn = 1e2 + 3, maxxn = 1e4 + 2;
vector<pair<int, int> > v[maxn][maxn];
bool mark[maxn][maxn];
int ans[maxn][maxn];
pair<int, int> p[maxxn];
int c;
void dfs(int u, int k) {
mark[u][k] = 1;
if (p[c].first <= 0)
c++;
ans[u... | #include <cstdio>
const int maxn = 110;
int tag[maxn * maxn];
int tmp[maxn * maxn];
int ans[maxn][maxn];
int main()
{
int n, m;
while (~scanf("%d%d", &n, &m)) {
int times, cnt = 1, change = 1;
scanf("%d", ×);
for (int i = 1; i <= times; i++) {
scanf("%d", &tag[i]);
for (int... |
7351661dce4882a89a1eb36aafabd532209fad586173ff0b0f2519e15243c02c | d89a2a565e3558116ff71a028f07ca026d8bf44fe0f6a006b54a03e08acc00f1 | 0.019169 | cpp | d89a2a565e3558116ff71a028f07ca026d8bf44fe0f6a006b54a03e08acc00f1 | 1574fb4d670ec6709824c7069a884081847d3eac751d586f132d7f44c639f3ba | PIE_released_gem5_runtime | pie_25261 | p03739 | 8672a6efca1a79e98cc1c1a9f482dc68a03f7b8326f5583688f02ac9e19c7bca | 1574fb4d670ec6709824c7069a884081847d3eac751d586f132d7f44c639f3ba | 0.193139 | 10.075433 | 8+ | d3deccdcca0f36aa550e2914ab83bc609c34c5fb70ac9cffd5aa2b027e4b1501 | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char **argv) {
cin.tie(NULL);
ios::sync_with_stdio(0);
long n;
cin >> n;
long arr[100010];
memset(arr, 0, sizeof arr);
for (int i = 0; i < n; i++) {
long aux;
cin >> aux;
arr[i] = aux;
}
long contA = 0, contB = 0, ... | #include <cstring>
#include <cstdio>
#include <cmath>
#include <memory.h>
#include <algorithm>
#include <map>
#define ll long long
#define ld long double
#define maxn 310
#define For(i, j, k) for (ll i = j; i <= k; ++i)
#define FOr(i, j, k) for (ll i = j; i >= k; --i)
const ll inf = 1e9;
const ld eps = 1e-7... |
a7cc3e24b2fc7237b528d521215e252ec63cf3563f96df5003fe7fe9777ad86e | ed1491380ad9d50d40667eec13eb8e977ed97344520dcd24cdfea03c38558201 | 0.021636 | cpp | ed1491380ad9d50d40667eec13eb8e977ed97344520dcd24cdfea03c38558201 | 645ad48b9a0210669a51febc9a88708ea1c2f8a141bb35d5035b049b6f4038ce | PIE_released_gem5_runtime | pie_25277 | p02779 | e2dbf659452deaab559af599cb6819b50d57b031fb20e0f9685b461359cf43ca | 645ad48b9a0210669a51febc9a88708ea1c2f8a141bb35d5035b049b6f4038ce | 0.097854 | 4.52283 | 4-8 | 72a7e209b5a3025a66608e35331e0dce8c878ffa5c8feb1f15752545fb178665 | #include <cstdio>
#include <set>
using namespace std;
int main()
{
int N, t;
scanf("%d", &N);
set<int> a;
for (int i = 0; i < N; i++)
{
scanf("%d", &t);
a.insert(t);
}
if (N == a.size())
printf("YES\n");
else
printf("NO\n");
}
| #include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
int N, a[200000], flag = 1;
scanf("%d", &N);
for (int i = 0; i < N; i++)
scanf("%d", &a[i]);
sort(a, a + N);
for (int i = N - 1; i > 0; i--)
{
if (a[i] == a[i - 1])
{
flag = 0;
break;
}
}
... |
159890ccd91b32e25ea64e4639f53eebcda0ea1ff26983929b835971d37995d1 | 0c41276e8d23246217cee7369ded7e45b440aa5aefbca07a9bd650779ab12e51 | 0.007394 | cpp | 0c41276e8d23246217cee7369ded7e45b440aa5aefbca07a9bd650779ab12e51 | ef38872d27eb5c62d33ece80413ef6a2013a0e78f02e8cb0cb4f3bddc061a1d5 | PIE_released_gem5_runtime | pie_25323 | p03668 | e6ab8d813bc76914845766396d31fb9b90c8ac6f58a3a28dcfd168eda558758c | ef38872d27eb5c62d33ece80413ef6a2013a0e78f02e8cb0cb4f3bddc061a1d5 | 0.296247 | 40.068315 | 8+ | d9285edda8c48620a19fa05c692ebcf72b0f29a0e2846e2de64355e4ac694657 | #include <bits/stdc++.h>
#define int long long
#define rint register int
using namespace std;
template <typename tp> inline void read(tp &x) {
x = 0;
char c = getchar();
int f = 0;
for (; c < '0' || c > '9'; f |= c == '-', c = getchar())
;
for (; c >= '0' && c <= '9'; x = (x << 3) + (x << 1) + c - ... | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
typedef long long ll;
const int N = 2e6 + 5;
struct node {
int u, v, nxt;
} edge[N];
int head[N], mcnt;
void add_edge(int u, int v) {
mcnt++;
edge[mcnt].u = u;
edge[mcnt].v = v;
edge[mcnt].nxt = head[u];
head[u] = ... |
166b11d86e676b416de30a7fcfa044e433e64c66072ddcec982f31550cda2821 | 10bf7856d4ce7a48776d3b1448501b9033914f18d2e5be95579a236f6cacc815 | 0.028215 | cpp | 10bf7856d4ce7a48776d3b1448501b9033914f18d2e5be95579a236f6cacc815 | 158ca9dc5d7b2e46137268fae207db98df814d788d6d8e10ebc8916f0571fd0e | PIE_released_gem5_runtime | pie_25430 | p03241 | 5b9d018865c462c65d357f21297b3a31ecabe06053dc731db8d7c267107e4728 | 158ca9dc5d7b2e46137268fae207db98df814d788d6d8e10ebc8916f0571fd0e | 0.083267 | 2.951222 | 2-4 | 2591064c0685be81f767884d850bee16f4efeab840770cf3a3a5d8b0d47f34a3 | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
int main()
{
ll n, k;
cin >> n >> k;
vector<ll> v;
for (ll i = 1; i * i <= k; i++)
{
if (k % i == 0)
{
v.push_back(i);
if (k / i != i)
v.push_back(k / i);
}
}
ll counter;
sort(v.begin(), v.... | #include <stdio.h>
#include <math.h>
int d[20002], e[20002], c = 0;
int main()
{
int n, m, i, k, j;
scanf("%d%d", &n, &m);
for (i = 1, k = sqrt(m); i <= k; i++) {
if (m % i == 0) {
d[c] = i;
e[c++] = m / i;
}
}
for (i = c - 1; i >= 0; i--) {
d[c] = e[i], e[c] = d[i], c++;
... |
007a824d9092294cccc979a5189d3eb9c95f741d51a5189901554de930ae0b92 | 50dc4b9e14c1c45c4b040ce2b30543f4b38422756cdf8c4b664595f0f1d799c9 | 0.105178 | cpp | 50dc4b9e14c1c45c4b040ce2b30543f4b38422756cdf8c4b664595f0f1d799c9 | 92c578ffc5c8b1bcb763efef57d7df9f718d32b89c9c73adb4f1e0c2fac41014 | PIE_released_gem5_runtime | pie_25451 | p02775 | 8eb911cb02f41c9709d470575f3cf0978187460aa3b117f015280d5efa462a0a | 92c578ffc5c8b1bcb763efef57d7df9f718d32b89c9c73adb4f1e0c2fac41014 | 1.001147 | 9.518624 | 8+ | 53129db5173623de3e2e34259f9cc841c0ca8425b430c5923459c898938a8e47 | #include <bits/stdc++.h>
#pragma GCC optimize("O3")
using namespace std;
#define ll long long
#define ull unsigned long long
#define rep(i, n, N) for (int i = n; i <= N; ++i)
#define rap(i, n, N) for (int i = n; i >= N; --i)
#define mp make_pair
#define pb push_back
#define pob pop_back
#define pf push_front
... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define ull unsigned long long
#define mp make_pair
typedef pair<int, int> pii;
char str[1000009];
int f[1000009];
int main()
{
scanf("%s", str + 1);
int len = strlen(str + 1);
int answer = 0;
for (int i = 1; i <= len; i++) {
f... |
717b9e6763d63554f126bd11d8ab30dc3a8679c08b010f70dc7b505306d5eba7 | fb6646272a4a4794bec0a744000d17e64194313929552cdd0d846d5ccc3b71a1 | 0.009772 | cpp | fb6646272a4a4794bec0a744000d17e64194313929552cdd0d846d5ccc3b71a1 | 0ed0699fed075f6fd5fd88f2361078b02878e73c9aaa7d213f734afbf3dfdd55 | PIE_released_gem5_runtime | pie_25459 | p02602 | 2fff0372178c68676866f6f4e77abecc46b91cf1976fec5c34ee02d9e4425b72 | 0ed0699fed075f6fd5fd88f2361078b02878e73c9aaa7d213f734afbf3dfdd55 | 0.136746 | 13.994354 | 8+ | b08bfc89e8aaf6aa3731c74d1849cede7cd575323299aed756a8deb85504a2b6 | #include <cstdio>
#include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <cmath>
#include <math.h>
using namespace std;
int main() {
long int a[200005], n, k;
memset(a, 0, sizeof(a));
cin >> n >> k;
for (long int i = 0; i < n; i++) {
cin >> a[i];
}
for (long ... | #include <stdio.h>
int main() {
int t, k;
scanf("%d %d", &t, &k);
int nilai[t];
for (int i = 0; i < t; i++) {
scanf("%d", &nilai[i]);
}
for (int i = 0; i < t - k; i++) {
(nilai[i] < nilai[i + k]) ? puts("Yes") : puts("No");
}
return 0;
} |
022c48880b15928734aa70c1fde280224c50942841a995630533270649caad44 | b8e546d96a07b181dae83c400ce8aeb23c7217b237767f3507f611d097abf53c | 0.022327 | cpp | b8e546d96a07b181dae83c400ce8aeb23c7217b237767f3507f611d097abf53c | 18963ee85096dd38cef9aefabc9b465679023b3f773d8c09fcdd360a5312922b | PIE_released_gem5_runtime | pie_25485 | p03354 | 919514eea042e73d2c0f7c8b02629cf98ae337e82be82915070c166de533e6d2 | 18963ee85096dd38cef9aefabc9b465679023b3f773d8c09fcdd360a5312922b | 0.985847 | 44.154497 | 8+ | 738eebaddc69f3ff287aea53344285daae775c28ab2a5928f07292ebd425c5f6 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, int> pdi;
const int N = 100005;
int a[N];
int fa[N];
vector<int> rec[N];
set<int> big[N];
map<int, int> mp;
int fat(int x)
{
if (fa[x] == x)
return x;
return fa[x] = fat(fa[x]);
}
... | #include <cstdio>
#define MAX 100001
int Tree[MAX];
int findRoot(int x) {
if (Tree[x] == x)
return x;
else {
int tmp = findRoot(Tree[x]);
Tree[x] = tmp;
return tmp;
}
}
using namespace std;
int main()
{
int list[MAX];
int belong[MAX];
int n, m;
while (scanf("%d%d", &n, &m) !... |
5cbf7c3715f1dbbe599ff0081e098b194f67172c41620f311bb8ce22b80ed4e6 | 80609ce78f7499e2bbcec9c6050e061c19343019a7615a5830031216f6010e24 | 0.038646 | cpp | 80609ce78f7499e2bbcec9c6050e061c19343019a7615a5830031216f6010e24 | eb465cc3899d8c7f6cc57040e237335dd543e564df95748df247b4191cb5dea5 | PIE_released_gem5_runtime | pie_25532 | p01754 | cb78a006217918de9fa1b569038c87b5cae4a5cdd799cbf031dbba458588dc85 | eb465cc3899d8c7f6cc57040e237335dd543e564df95748df247b4191cb5dea5 | 0.116648 | 3.018377 | 2-4 | b76d6803f9294709731b96e18f49ae8f42f392690e6f751e0402c35739cab5d8 |
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, int> Pa;
struct BIT {
int d[500005];
int n;
void init(int _n) {
n = _n;
memset(d, 0, sizeof(d));
}
void add(int i, int x) {
while (i <= n) {
d[i] += x;
i += i & -i;
}
}
int sum(... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<ll, int> Pa;
ll N, P, Q;
Pa C[500005];
int main() {
cin >> N >> P >> Q;
ll sum = 0;
for (int i = 0; i < N; i++) {
ll c;
cin >> c;
sum += c;
C[i] = Pa((ll)(Q - i) * P - c, i);
}
sort(C, C + N);
ll re... |
23063db6cccb0829fa8378ce99151e3367aca0c458c749f478807b79deaebd19 | 38486f1aa96f74459cee22a31e0d2ae60510803cb537846fa88242d9488f8917 | 0.050887 | cpp | 38486f1aa96f74459cee22a31e0d2ae60510803cb537846fa88242d9488f8917 | f782e240d89c2468584b313a48e094bf1da05a45aad2251d643df4a036e6a471 | PIE_released_gem5_runtime | pie_25572 | p02553 | bddaeba9897fc8a37a693301ccdd7a057c29add9cf1b176e6a18a45c7298f453 | f782e240d89c2468584b313a48e094bf1da05a45aad2251d643df4a036e6a471 | 0.483172 | 9.494964 | 8+ | 1602fcbd5ab52c9f1b8158ee95c7e3c45e78a79cd9a7b1d6fd5a88dfd10d57d5 |
#include <bits/stdc++.h>
using namespace std;
#define Ff(i, a, n) for (i = a; i < n; i++)
#define Fr(i, a, n) for (i = a; i > n; i--)
#define ll long long
#define FAST ios_base::sync_with_stdio(false), cin.tie(0), cout.tie(0);
#define pb push_back
#define ff first
#define ss second
#define all(x) x.begin(), ... | #include <bits/stdc++.h>
#include <iostream>
#include <algorithm>
#include <cstring>
#define ios ios::sync_with_stdio(false)
#define mem(arr) memset(arr, 0, sizeof(arr))
using namespace std;
typedef long long ll;
const ll maxn = 1e6 + 10;
int main()
{
ll a, b, c, d;
ll sum;
cin >> a >> b >> c >> d;
... |
02b26898a3b0c7200bd8137d7770e1147ad99280dc43315076bd0e276ff54d10 | 2a938801522e2ce42ad90b1b47ef0e6150b4808caa6ae3991ba1405edf5dc264 | 0.001014 | cpp | 2a938801522e2ce42ad90b1b47ef0e6150b4808caa6ae3991ba1405edf5dc264 | 19ef6890d347e7bf472d345aa1b50c9edc0dddc2cda8cd731b911f01e7d53599 | PIE_released_gem5_runtime | pie_25604 | p03525 | 33aef8a36051fab7a8c8db3e3aea6d29d61988e7b356bcf1b26bc66776ae6a7f | 19ef6890d347e7bf472d345aa1b50c9edc0dddc2cda8cd731b911f01e7d53599 | 0.002224 | 2.19282 | 2-4 | 22fddf3c1deb98df79eb67d114a9013678544c189653326e6434ff09f5348968 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define sz(x) ((int)x.size())
#define sqr(x) ((x) * (x))
#define mem(a) memset(a, 0, sizeof(a))
#define all(x) x.begin(), x.end()
typedef pair<int, int> pii;
typedef long long ll;
typedef pair<ll, int> pli;
const int mn = 3e5 + 5;
const int m... | #include <bits/stdc++.h>
using namespace std;
int n, a[55], b[55];
int solve() {
sort(b + 1, b + 1 + n);
int ans = 0x3f3f3f3f;
for (int i = 2; i <= n; i++)
ans = min(ans, b[i] - b[i - 1]);
ans = min(ans, b[1]);
ans = min(ans, 24 - b[n]);
return ans;
}
int main() {
scanf("%d", &n);
for (i... |
fddc5cc556dd3880f8d6c56312d34ad43d3cbb4d97a1960f382035f7a1ed636b | b47c1750d7a8aaa8c5441b1c6064d22c20260d3b2bf8bc4a32d515caad15ca1b | 0.01986 | cpp | b47c1750d7a8aaa8c5441b1c6064d22c20260d3b2bf8bc4a32d515caad15ca1b | 339bd0154d4a00bebbededc3cf951d17edfc1ac3b64890e50316b1c13b9ad987 | PIE_released_gem5_runtime | pie_25651 | p03785 | 5eed55566ebd7db4ccf5a63fe4a15e9ce7f09bb0bd6c9211f8302bf3944d8ed2 | 339bd0154d4a00bebbededc3cf951d17edfc1ac3b64890e50316b1c13b9ad987 | 0.190196 | 9.576858 | 8+ | 8763a502591f9cd91461c6ab516473c7ed463ee5c2b9fb92a62cf817caec327a | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <queue>
#include <cmath>
#include <iostream>
#include <algorithm>
#define mt(a) memset(a, 0, sizeof(a))
#define ll long long
using namespace std;
int main(void)
{
int n, c, k;
int p[200005];
mt(p);
cin >> n >> c >> k;
for (int i ... | #include <cstdio>
#include <cstring>
#include <algorithm>
#define N 110000
using namespace std;
int n, c, k, t[N], l;
int main() {
scanf("%d%d%d", &n, &c, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", &t[i]);
sort(t + 1, t + n + 1);
int ans = 0;
l = 1;
t[n + 1] = 0x7FFFFFFF;
for (int i = ... |
59387744a2f08e9922cf100b5d994c2d91764cb2d81d37a38cb08a16da92fe52 | 58e5f2b34a6fac75b0207357c442e98c5cb4552ddcb5d9d9db3caa1848cc944e | 0.000193 | cpp | 58e5f2b34a6fac75b0207357c442e98c5cb4552ddcb5d9d9db3caa1848cc944e | 78a42cb25912fc28bd5d43c8b2baa1b41e9f02f5c9659842380f014169d51be2 | PIE_released_gem5_runtime | pie_25692 | p04013 | e12eef08b9f8012e025472e26c1c497edf899cbe7b788ca3cffc7d2e4b591982 | 78a42cb25912fc28bd5d43c8b2baa1b41e9f02f5c9659842380f014169d51be2 | 0.003858 | 20.035782 | 8+ | 2c623a6b566083443676e3eedc969b775accf193b07a40e950d378358d5c49d5 | #include <bits/stdc++.h>
using namespace std;
int n, A, a[51];
long long f[2][51][2510];
int main() {
cin >> n >> A;
for (int i = 1; i <= n; ++i)
cin >> a[i];
f[0][0][0] = 1;
for (int i = 1; i <= n; ++i) {
memset(f[i & 1], 0, sizeof(f[i & 1]));
for (int j = 0; j <= i; ++j) {
for (in... | #include <cstdio>
#define int long long
using namespace std;
int n, m, a[55], f[55][8005], ans;
signed main() {
scanf("%lld %lld", &n, &m);
f[0][0] = 1;
for (int i = 1; i <= n; i++)
scanf("%lld", &a[i]);
for (int i = 1; i <= n; i++)
for (int j = i; j > 0; j--)
for (int k = m * n; k >= a... |
d989b0ad46d05067ff898b3ec10f0279b68560d0adcabd6475c03f3b968fab81 | 26707f25d0faffea9ab4a6380124dde24b1318a192a3e2d31942b95c15e9d71b | 0.00518 | cpp | 26707f25d0faffea9ab4a6380124dde24b1318a192a3e2d31942b95c15e9d71b | 950ea5c2e77f95219bc2db8784798f421447b0c1a07c51c43208cff065d82be6 | PIE_released_gem5_runtime | pie_25762 | p03332 | d0526bbfde086f22f07afd6cd238d36b3dd10775d922905fa8c977697f9c0cb0 | 950ea5c2e77f95219bc2db8784798f421447b0c1a07c51c43208cff065d82be6 | 0.163468 | 31.555103 | 8+ | bbb1150ce6bd79019c8cb3785e2a8c11b9730d8ea9c0e764acc9d1c9a537ebb7 | #include <bits/stdc++.h>
#define int long long
using namespace std;
const int N = 3e5 + 5;
const int MOD = 998244353;
int n, a, b, k;
int fac[N], ifac[N];
int fpow(int x, int y) {
int res = 1;
while (y) {
if (y & 1)
res = res * x % MOD;
x = x * x % MOD;
y >>= 1;
}
return res;
}
v... | #include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
#define N 300010
#define Mod 998244353
#define LL long long
LL s1[N], s2[N];
LL find(LL x, LL y)
{
LL ans = 1;
x = x % Mod;
while (y)
{
if (y % 2)
ans = ans * x % Mod;
x = x * x % Mod;
y = y / 2;
... |
54a718d7499508dd649856a9d0170cd5ee18efff4abaf4a6445be0cf91989d2d | 4bc3ecba81cfb3c2f1891e95e27d5926a54fd46103375f13617db06d2dd1acf9 | 0.010783 | cpp | 4bc3ecba81cfb3c2f1891e95e27d5926a54fd46103375f13617db06d2dd1acf9 | 4dd8ac547b8d6fe86363a6a5460d70cbc5a5ec1b1dfd284f0f690ca2acccf528 | PIE_released_gem5_runtime | pie_25782 | p01462 | 7ee3cff4554667b00b6552112daa4a099802787130fdbb934734d6ecef634940 | 4dd8ac547b8d6fe86363a6a5460d70cbc5a5ec1b1dfd284f0f690ca2acccf528 | 0.064977 | 6.025804 | 4-8 | 68652ae8b2ea9f870d4ba818f420ec24773585a11bff165238b6dc0408ca683b | #include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <iostream>
using namespace std;
int n, m, p;
int num[20000 + 10];
double dp[20000 + 10];
struct E
{
int u, v;
} e[100 + 10];
double qpow(double d, int c)
{
if (c == 0)
return 1;
if (c == 1)
... | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cstring>
#include <cmath>
#define maxst 1 << 20
using namespace std;
int n, m, p, u, v;
int r[maxst];
double f[maxst];
int main() {
scanf("%d%d%d", &n, &m, &p);
const int maxs = 1 << n;
for (int i = 0; i < m; i++) {
scanf("%d%d", ... |
6d23d2e4246a42aa250b3cb1c77143c15679eb4ab3637ae3759280e84d9b68c9 | 95b4008abca52da92f5c91998feb34de846d317a527dd9bb827de10cf547bb9c | 0.07345 | cpp | 95b4008abca52da92f5c91998feb34de846d317a527dd9bb827de10cf547bb9c | d447e13ba18dba1fab3e190b81430e629d1516e97061b69c2dce080986480949 | PIE_released_gem5_runtime | pie_25793 | p01777 | fe3288648ca3f887afb2db842b027e09859144f51fe9e45a8dce9bda87d9c1e4 | d447e13ba18dba1fab3e190b81430e629d1516e97061b69c2dce080986480949 | 0.759093 | 10.334812 | 8+ | a5b67684ef3c44043b09639804a4efa39ecfeacc197b13ab62f90d71e8cbbe98 | #include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
int D, Q, x[131072], ls, rs, es, a, b;
vector<int> seg[262144];
int query(int k, int l, int r) {
if (r <= ls || rs <= l)
return 0;
if (ls <= l && r <= rs)
return lower_bound(seg[k].begin(), seg[k].end(), b) -
l... | #ifndef ___Class_RangeTree
#define ___Class_RangeTree
#include <limits>
#include <vector>
#include <algorithm>
template <typename Type> class RangeTree {
private:
int size_;
std::vector<std::vector<Type> > dat;
std::vector<std::vector<int> > vl;
inline int query_(int a, int b, Type x, int k, int l, int... |
523733c62428260fb2e82a84ad989600108f49581aecf8ac0685c4bb743f8b8d | 875f09d1ac3ee518ce8cdd733e34cfad73154a55606d88990264ac61bd2eb9a8 | 0.010334 | cpp | 875f09d1ac3ee518ce8cdd733e34cfad73154a55606d88990264ac61bd2eb9a8 | 1eea9c4b5424492c8be9e7e0da2e64c6ac10e0cf51aacd99d6fa1c26adfb135b | PIE_released_gem5_runtime | pie_25800 | p03609 | f2c4ae5353f7554fe2df0444b79c81bd04629346bf6e0ad6c69602cdbec95f7e | 1eea9c4b5424492c8be9e7e0da2e64c6ac10e0cf51aacd99d6fa1c26adfb135b | 0.054838 | 5.306453 | 4-8 | 13ad983a5492eba90d5b7131935f5abe7889ddf4c87f6de7f73204b6f98ddbdb | #include <iostream>
using namespace std;
int main()
{
long long int x, t;
cin >> x >> t;
if (x - t == 0)
{
cout << 0 << endl;
}
if (x - t > 0)
{
cout << x - t << endl;
}
if (x - t < 0)
{
cout << 0 << endl;
}
return 0;
} | #include <stdio.h>
int main()
{
int x, y;
while (~scanf("%d%d", &x, &y))
{
int ans;
ans = x - y;
if (ans > 0)
printf("%d\n", ans);
else
printf("0\n");
}
} |
4703b9d31fa971a2a48919304374b8d5937ea2b48b024bffa2087b1079a50d72 | cdf862c2c429f0d9c19d0e8c8f876d3b15fef0d6c59f29da432aa5bb0ca44109 | 0.000191 | cpp | cdf862c2c429f0d9c19d0e8c8f876d3b15fef0d6c59f29da432aa5bb0ca44109 | 10df5a9dd5393bf53d91b155f02821f8840b26cc77db72f9994ceb72056970a6 | PIE_released_gem5_runtime | pie_25803 | p03310 | a7b5a346893adc124c31d023174bca6e956a371b8f8be6e77fcc5722185a72f3 | 10df5a9dd5393bf53d91b155f02821f8840b26cc77db72f9994ceb72056970a6 | 0.001007 | 5.260455 | 4-8 | b582c934bf0d520b07642258f2733abc70b27181d042bfab47c843d9a5f34878 | #include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <limits>
using namespace std;
using uint = unsigned int;
using ll = long long;
#define FOR(i, a, b) for (int i = a; i < b; ++i)
#define REP(i, n) FOR(i, 0, n)
uint N;
ll A[200001];
uint l, c, r;
ll getVal() {
ll prev_di... | #include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <limits>
using ull = long long;
using namespace std;
const int MAX_N = 2 * 10e5 + 5;
ull arr[MAX_N];
int n;
int pre_l, pre_r;
ull solve(int mid) {
ull pre_diff = numeric_limits<ull>::max();
ull curr_diff;
int l = mid... |
b5b1ccf5b062da523ae87135528495f2792a06fd5be14c3adf04e80d5133166d | 7eafc688fbf1f8ddb94498cac542ba8aa04ce0e21e2ced2c7f5b7d784aa2fc4e | 0.030367 | cpp | 7eafc688fbf1f8ddb94498cac542ba8aa04ce0e21e2ced2c7f5b7d784aa2fc4e | a02cb16c6639423350bc29fb50179b10511a1ef5ab17fb4a121ab79e5b9a35bc | PIE_released_gem5_runtime | pie_26 | p00232 | a2addfd2023a6da446ac446329a9c84bc8878042de8c040bdeae58b5fa5512d1 | a02cb16c6639423350bc29fb50179b10511a1ef5ab17fb4a121ab79e5b9a35bc | 0.114226 | 3.761555 | 2-4 | 3e6b00178b350d7874ead065d17d631c009721853c09768b747ef1d46527903d | #include <iostream>
#include <algorithm>
using namespace std;
int main() {
double pb[100][5001];
int x, y, z, n, m, l, ub;
int v[4], e[51], a[51];
while (cin >> x >> y >> z && (x || y || z)) {
for (int i = 0; i < x; i++)
cin >> v[i];
for (int i = 0; i <= y; i++)
e[i] = a[i] = 0;
... | #include <cstdio>
#include <algorithm>
using namespace std;
int main() {
double pb[100][5001];
int x, y, z, n, m, l, ub, i, j, k;
int v[4], e[51], a[51];
while (scanf("%d %d %d", &x, &y, &z) && (x || y || z)) {
for (i = 0; i < x; i++)
scanf("%d", &v[i]);
for (i = 0; i <= y; i++)
e[i... |
1d80c5b69c7416fd7bf9e3ac00c8e82e4f366414284c3852c8e18f4e293d79f8 | 460da7298aa886e7712e130e441cf90eec12a1e34ce57c946c5af92db32ca4ba | 0.00103 | cpp | 460da7298aa886e7712e130e441cf90eec12a1e34ce57c946c5af92db32ca4ba | 3f565b44e1f4d4c7331d0731f46d66587022eef2ad75b256f94da59752b961d4 | PIE_released_gem5_runtime | pie_26306 | p03864 | 65d8fa1f7ad8e656f298b1977697bc59f33986541d6497f8758e1e73f13780a9 | 3f565b44e1f4d4c7331d0731f46d66587022eef2ad75b256f94da59752b961d4 | 0.009635 | 9.351654 | 8+ | a076eff87d95b1de467db80d38a6927fdffc30671acd72593e762763375c4dba | #include <bits/stdc++.h>
#define FAST \
ios_base::sync_with_stdio(0); \
cin.tie(0); \
cout.tie(0);
#define fr first
#define sc second... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define fast \
ios_base::sync_with_stdio(false); \
cin.tie(0); \
cout.... |
cc5870ffe759c9997a1e3d9da629d5d2fb264a050e7e78d97cd01c686221ed26 | f824c7a1b0f31c65e9a81f1bd1688e7fddad576a8fe2eeccaa939e298110a2ed | 0.053778 | cpp | f824c7a1b0f31c65e9a81f1bd1688e7fddad576a8fe2eeccaa939e298110a2ed | 20baf993893b84dab09bc1849ff7f34dee2890549b8e43099cf3ac95a95d62c6 | PIE_released_gem5_runtime | pie_26334 | p04012 | 378ab97980da73eb7d3830a5b28eec42c72d7889c7df589cc5ee4bc86b1dde87 | 20baf993893b84dab09bc1849ff7f34dee2890549b8e43099cf3ac95a95d62c6 | 0.190915 | 3.550036 | 2-4 | 2127b0aa94af3c25cae7344a09614d56dbf2cd54fbe0b307245b078803cf8d90 |
#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 ll long long
int a[32 + 4];
int main()
{
string s;
cin >> s;
for (int i = 0; i < s.size(); ++i) {
++a[s[i] - 96];
}
for (int i = 1; i <= 32; ++i) {
if (a[i] % 2 == 1) {
cout << "No\n";
return 0;
}
}
cout << "Yes\n... |
d22ad4a9ffdbda1c62a3db56d93ce9437035589e1b960381adad07689b843f44 | eb830452232acb7253062ef2b17e857fed27d734f6e8be7ec7c1938affb37641 | 0.075033 | cpp | eb830452232acb7253062ef2b17e857fed27d734f6e8be7ec7c1938affb37641 | 5832883a3fafdb0ec6aaef52596f49497d3702923e2b23d6717fa4dbd126b5fe | PIE_released_gem5_runtime | pie_26340 | p00768 | 026296f457fd7e4a684972ad72dcc3f09d7187419200e529fd2c9eac87c50872 | 5832883a3fafdb0ec6aaef52596f49497d3702923e2b23d6717fa4dbd126b5fe | 0.173633 | 2.314095 | 2-4 | e6024baf0bf6016c8d5bdec3d627d5ae20a860b62fca3ba7f89495ee3f506df0 | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define pb(a) push_back(a)
#define mp(a, b) make_pair(a, b)
#define ALL(a) (a).begin(), (a).end()
#define F first
#define S second
typedef pair<int, int> PI;
int m, t, p, r;
int app[400][400];
int pena[400];
v... | #include <cstdio>
#include <vector>
#include <algorithm>
using namespace std;
int a[50][2];
int b[50][10];
int main()
{
while (1) {
int m, t, p, r, i, j;
vector<pair<int, pair<int, int > > > v;
scanf("%d %d %d %d", &m, &t, &p, &r);
if (m == 0 && t == 0 && p == 0 && r == 0)
break;
... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.