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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
539610ef135470e75567ccea8841d12f5d06e260cd57c134eb3a3a0a0958b2f3 | 576c160d2b22fcd6cbfafd6dd54de54eef5a285c5599bc541ce3146b44468626 | 0.00756 | cpp | 576c160d2b22fcd6cbfafd6dd54de54eef5a285c5599bc541ce3146b44468626 | f6cd3422bfe98aca8fbec0481fd683c12ab07a180a0399bf7a93d6cad1876221 | PIE_released_gem5_runtime | pie_35097 | p02574 | b5ceca067ec89ce963763d37538335e812a6dc4be1ebff4e9cd01a4c25706f24 | f6cd3422bfe98aca8fbec0481fd683c12ab07a180a0399bf7a93d6cad1876221 | 0.207672 | 27.470732 | 8+ | 0e279a04dbd9a831d0c8d1d341728376a31de3618cc0b2b0191b390e574be939 | #include <stdio.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
const int MOD = 1e9 + 7, MAX = 1e6;
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 * 10 + c - 48, c = getchar();
}
ret... | #include <stdio.h>
#define rep(i, N) for (int i = 0; i < (int)N; i++)
#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 ... |
5d085f7b313f634593296e9b6cc08485393e663759f2ff367873fe7d506402f1 | ca2c6ece49a0cb1db29a64e9dceb63b4d6266617ece5754afb823707db1f05db | 0.106853 | cpp | ca2c6ece49a0cb1db29a64e9dceb63b4d6266617ece5754afb823707db1f05db | 448a6f5e543336623d45d37c6376219b57e33448a68f1f55438499365763ed83 | PIE_released_gem5_runtime | pie_35135 | p02966 | 9bf6f00ca5a179c63e4732e50bd45d892b3713d2ef320616865ee51ea21c7d08 | 448a6f5e543336623d45d37c6376219b57e33448a68f1f55438499365763ed83 | 0.32415 | 3.033597 | 2-4 | 49e9ca25867bd5661046a715d51cbdca9c742e79e0d5b3d7639de55cb4edfc7f | #include <bits/stdc++.h>
using namespace std;
const int N = 500 + 5;
long long n, a[N][N], g[2][N][N], f[N][N], cnt, sum = 0x3f3f3f3f3f3f3f3f;
void init() {
scanf("%lld", &n);
for (int i = 0; ++i <= n;)
for (int j = 0; ++j <= n; i == j ?: scanf("%lld", &a[i][j]))
;
}
long long gg(int k, int lx, int... | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int N = 500;
const LL INF = (1LL << 50) - 1;
int n, a[N + 9][N + 9];
void into() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n; ++j)
if (i ^ j)
scanf("%d", &a[i][j]);
}
LL sum[N + 9][N + 9... |
317966d0f804f33fc4ab222e5e5322e033277ab6ae7c55fc95bc23948abf63c8 | ad481210e7514870d2bc13416ae6ac11f1e4443b1b1d7d4d5a319861522808f1 | 0.026131 | cpp | ad481210e7514870d2bc13416ae6ac11f1e4443b1b1d7d4d5a319861522808f1 | 5cce4a9a4fd6884f39ec251fa2af02923f46554a67d6bdbbda1ad1671046654a | PIE_released_gem5_runtime | pie_35193 | p02758 | 839da65ad30c6b6211bf308233fab4311fb46aa3e2c677e92c8eb076557fe9af | 5cce4a9a4fd6884f39ec251fa2af02923f46554a67d6bdbbda1ad1671046654a | 0.066541 | 2.546452 | 2-4 | 3f8b58083e424f8c669ded848d20dfe83bd5a9bb412b774bce224cad85457eaa | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const ll Maxn = 200005;
const ll Mod = 998244353;
ll N;
struct Robot {
ll X;
ll D;
} a[Maxn];
ll Touch_Far_Robot[Maxn];
ll Touch_Far_Robot_Tree[4 * Maxn];
ll dp[Maxn];
bool Have_Test_Poi[Maxn];
bool cmp(Robot a, Robot b)
{
return ... | #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 LL MOD = 998244353;
void run_case() {
int n;
cin >> n;
vector<pll> a(n), st... |
18f54ef355b4114989702838e112db2955c0ff429a22639839eb9ddd49433ecd | cfc5d5cc70443604f22a20b15656d048224d9566782c7dc6d28bf69258976019 | 0.019198 | cpp | cfc5d5cc70443604f22a20b15656d048224d9566782c7dc6d28bf69258976019 | 1151c70023ed91c9ab675a2f12f64e7a6ddc6753f4a8a8a22c5f7810f88dd397 | PIE_released_gem5_runtime | pie_35216 | p02707 | ed7b6b7c6cad86b67f92dab6c533824a69ef1f8aaf3a50155728e20b88f87e02 | 1151c70023ed91c9ab675a2f12f64e7a6ddc6753f4a8a8a22c5f7810f88dd397 | 0.193335 | 10.07043 | 8+ | 1419555e005cb449d6c4e546ad7b01b0b5063325b8f220cabfdab15145277bbc |
#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) << " "
#defi... | #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... |
8ca58d87ae1e0799f038109b5fcd73916124a86d22f0c0fa62c0990017f9b31b | e9332d4356d5aff903cc40682fa6f1318307ba0d1ffabe993854aea31e32ebb3 | 0.055322 | cpp | e9332d4356d5aff903cc40682fa6f1318307ba0d1ffabe993854aea31e32ebb3 | 257b3586083f2dedd618f6363ed52ad445ad89f814d5cef15fc52990cc301435 | PIE_released_gem5_runtime | pie_35265 | p02648 | 02908457ba0c7727e01f9e816838862d002566331fc7ce9ea107fd54f69ce4d5 | 257b3586083f2dedd618f6363ed52ad445ad89f814d5cef15fc52990cc301435 | 0.444598 | 8.036582 | 8+ | 907d85608cceb08b0b00e3d15a9fbbbf5b3c7850a94474ab63b3a10568ea7613 | #include <bits/stdc++.h>
#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] = {0, 1, 0, -1, 1, 1,... | #include <bits/stdc++.h>
#define inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<double, double>
#define PI 3.14159265358979323846
#define mp make_pair
#define pb push_back
#define EPS (1e-8)
int dx[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int dy[8] = {1, 0, -1, 0, -1, 1, 1, -1};
usin... |
61ecd63e092f93be451a29082ea8cb5ec8e28944bcded98155b490b41f6a2d11 | 2300c2d10ede790c26232edc4087fab42a4cb1dd850d607cff4949fb95d4c031 | 0.10866 | cpp | 2300c2d10ede790c26232edc4087fab42a4cb1dd850d607cff4949fb95d4c031 | 1348fae43f53eb6445af90bb8fe313716f69eb48b1f90816af4945527f7233ce | PIE_released_gem5_runtime | pie_35338 | p02773 | b2b9c90f5ae3d7e2093019feddb84c177a0e196153b8fadcadf32745d602fc26 | 1348fae43f53eb6445af90bb8fe313716f69eb48b1f90816af4945527f7233ce | 1.090045 | 10.0317 | 8+ | 4490612a6ffa8e13165602eb42b5fe424520ad2c29c804393b9ea747b71b45ec | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
char tmp[N];
pair<int, string> A[N];
map<string, int> idx;
map<string, int> mp;
map<int, vector<string> > rmp;
int main()
{
int n, mx = -1;
scanf("%d", &n);
string s;
for (int i = 0; i < n; ++i) {
scanf("%s", tmp);
strin... | #include <bits/stdc++.h>
using namespace std;
const int N = 2e5 + 5;
int n, mx = 0;
map<string, int> mp;
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
string s;
cin >> s;
mx = max(mx, ++mp[s]);
}
for (auto it : mp) {
if (it.second == mx) {
cout << it.first << endl;
... |
50e20ee2ababa7ab98490b434c86cecdbd78dcc315606cc92bba1fa3262cb03f | 937801d716057d353488154b0d485e0925f45b3022fa9d2f098692e563fb17c3 | 0.017184 | cpp | 937801d716057d353488154b0d485e0925f45b3022fa9d2f098692e563fb17c3 | 801b5c90bf09c0da86f6876db64800e13c862d1c50f759e06ba19ba1c3097697 | PIE_released_gem5_runtime | pie_3571 | p02989 | 63cd0c5211fb19a847172c3d4e35b37723028eee5289b348cc2cbd3a076600e0 | 801b5c90bf09c0da86f6876db64800e13c862d1c50f759e06ba19ba1c3097697 | 0.174676 | 10.164823 | 8+ | 14d0100fac57306dffcf858631f7cc9075ff11f421c1f3dab911975c21c4019b | #include <bits/stdc++.h>
using namespace std;
#define trace(...) __f(#__VA_ARGS__, __VA_ARGS__)
template <typename Arg1>
void __f(const char *name, Arg1 &&arg1) {
cerr << name << " : " << arg1 << "\n";
}
template <typename Arg1, typename... Args>
void __f(const char *na, Arg1 &&arg1, Args &&...args) {
const... | #include <stdio.h>
#include <algorithm>
using namespace std;
int a[100005] = {0};
int main()
{
int n;
while (~scanf("%d", &n))
{
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
sort(a + 1, a + 1 + n);
if (a[n / 2] == a[n / 2 + 1])
printf("0\n");
else
printf("%d\n"... |
4de05146c155ca50dc0c0968441291386657bbb60868286451ba296e4622b975 | c73b905e603bd3172f410f66b307704f7150e84a483201e60403fbc829cd2c45 | 0.109319 | cpp | c73b905e603bd3172f410f66b307704f7150e84a483201e60403fbc829cd2c45 | c7d9215f7a6abb6ddf3764eb6938b2a81afca6e2fa1317490ce47626d58d783b | PIE_released_gem5_runtime | pie_35750 | p01564 | 6a47999163c4e847cb82e9a1f27debe24596459b48c3fd63835bf24482ada91c | c7d9215f7a6abb6ddf3764eb6938b2a81afca6e2fa1317490ce47626d58d783b | 1.518784 | 13.893098 | 8+ | 008c7a08ff9f1c347bc28295e5c5e8fcd5eec8bb18122b0fdaaeb0a8e18b6c28 | #define NDEBUG
#include <iostream>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
#include <tuple>
#include <cassert>
#include <unistd.h>
using namespace std;
typedef long long ll;
struct LCNode {
typedef LCNode *NP;
typedef int D;
static c... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
constexpr ll TEN(int n) { return (n==0) ? 1 : 10*TEN(n-1); }
template<class T> using V = vector<T>;
template<class T> using VV = V<V<T>>;
using P = pair<int, int>;
struct HL {
V<int> _ord, _rord, big, small;
HL(int n = 0) : _ord(n), _... |
a4f456961e3f8ed2be7b6cb94e68bb1ad646cce033a8994124bc9af005b2b431 | 38759f770e1fa5ce3f4ad9c479a3cf41534eee04db163b15835ab8aaa765cfc3 | 0.060516 | cpp | 38759f770e1fa5ce3f4ad9c479a3cf41534eee04db163b15835ab8aaa765cfc3 | 91ccfd9b4affcf0b72f1398df0ab98d4b7fdf581d4f20d843e3f897ba31eb839 | PIE_released_gem5_runtime | pie_35858 | p02913 | 51d183482d81edb2f5fef0920546d494b4d9a02c06643065c6ed6105d6745798 | 91ccfd9b4affcf0b72f1398df0ab98d4b7fdf581d4f20d843e3f897ba31eb839 | 0.195453 | 3.229754 | 2-4 | 37c144073d5239ef10f427957412a7bafec15ce76dd2bd16f404d981c8e3c38d | #include <bits/stdc++.h>
#define mp make_pair
#define ff first
#define ss second
using namespace std;
typedef long long LL;
typedef pair<LL, LL> PLL;
typedef pair<int, int> PII;
const PLL M = mp(1e9 + 7, 1e9 + 9);
const LL base = 875329;
const int N = 1e5 + 7;
ostream &operator<<(ostream &os, PLL hash) {
... | #include <iostream>
#include <cstdio>
#include <vector>
using namespace std;
char s[5005];
int Next[5005];
vector<char> v[5005];
int main()
{
int n, i, j, k, t, max = 0;
scanf("%d%s", &n, s);
for (i = 0; i < n; i++)
for (j = i; j < n; j++)
v[i].push_back(s[j]);
for (i = 0; i < n; i++)
... |
8984f4217be90a3334ceffc6f58efd1b211158d630e2949867a35adec322e253 | 8937969f5b0d24158e304258ea1aaf3aaa5e72ea0c3176b97c701c7be489e23c | 0.096722 | cpp | 8937969f5b0d24158e304258ea1aaf3aaa5e72ea0c3176b97c701c7be489e23c | 44ec79ca57b1721e2c95706a0233be1373eb67c3870752093a9ac4461e2439c1 | PIE_released_gem5_runtime | pie_35898 | p03256 | eb6a7a421336e9b70d0283591625d9550abb667d7e2de6edf895cbe7b6bfe1f0 | 44ec79ca57b1721e2c95706a0233be1373eb67c3870752093a9ac4461e2439c1 | 0.647888 | 6.698452 | 4-8 | 0d8cda44fdaccb9737fd6d317a7f4fd8bdeca39b60488836fd912798bf5e7add | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
vector<int> g[212345];
int main() {
std::ios::sync_with_stdio(false), std::cin.tie(0);
int n, m;
cin >> n >> m;
string s;
cin >> s;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--;
b--;
g[a].push_b... |
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <tuple>
#include <cmath>
#include <random>
#include <cassert>
using namespace std;
using ll = long long;
const int N = 2e5;
std::vector<std::vector<int>... |
241f7112ff59c87836b97d3f2efc8c03cac93549f21bbbdf3eba487d37c01e87 | e6eff9a0854643940c7a26c0bc22637cbadb54f46d97078310d5585fe2d590fa | 0.104921 | cpp | e6eff9a0854643940c7a26c0bc22637cbadb54f46d97078310d5585fe2d590fa | 9e785c0e10a4d5919f608e624e1f4fb4c5556dc128d8406ea3a11178aebde584 | PIE_released_gem5_runtime | pie_35938 | p01426 | 945b5779ddb0f7d7a5cabe2be484edc8f631ee1125d17bb255bea60a570ad38a | 9e785c0e10a4d5919f608e624e1f4fb4c5556dc128d8406ea3a11178aebde584 | 0.420045 | 4.003449 | 4-8 | dba1995c268cf3caaba2518e59ba7d9d12cd2ae771e05cba1cd9df47acf4e224 | #include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <iostream>
#include <queue>
#include <stack>
#include <vector>
#include <map>
#include <set>
#include <string>
#include <iomanip>
using namespace std;
#define eps 1e-12
#define INF 1000000
#define maxn 200005
double a[10... | #include <iostream>
#include <cstring>
#include <cstdio>
#include <cstdlib>
#include <cmath>
using namespace std;
const int maxn = 110;
const int maxe = 50010;
struct Edge
{
int u, v;
double w;
} edge[maxe];
int nv, ne;
void add(int u, int v, double w)
{
edge[ne].u = u;
edge[ne].v = v;
edge[... |
a04747cdc024dc20c51fd43e472642d00594bf0893a914713ef2e6cd37920353 | 39b7958099abdd8d81d907b30b3eaa3eb7eacca53f13935178aaefa9655ba3c5 | 0.109243 | cpp | 39b7958099abdd8d81d907b30b3eaa3eb7eacca53f13935178aaefa9655ba3c5 | 4ba5de1c27bec4534cca95eb38e84497e38331dafa499ca1f4f0c9d4a393e2f8 | PIE_released_gem5_runtime | pie_35963 | p03546 | 9f794c329ae1e31af71aeeb63b5f6f219a2193d2fa8a0a9c56c819d78329cc04 | 4ba5de1c27bec4534cca95eb38e84497e38331dafa499ca1f4f0c9d4a393e2f8 | 0.693014 | 6.343801 | 4-8 | e05448e150f3822d0d95c4e3903dbfbb26a755bcb3ac317ee3d6063c97bed00a | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define SIZE 200005
#define INF 1000000005LL
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
int H, W;
int c[11][11];
int V;
struct edge {
int to, cost;
};
vector<edge> G[SIZ... | #include <bits/stdc++.h>
#define rep(i, a, b) for (int i = int(a); i < int(b); ++i)
#define SIZE 15
#define INF 1000000005LL
#define MOD 1000000007
using namespace std;
typedef long long int ll;
typedef pair<int, int> P;
ll d[SIZE][SIZE];
int V;
void warshall_floyd_init() {
fill(d[0], d[SIZE], INF);
rep... |
45728fc2b826cf6aa98e9f66d90a84826ec4b8fd53ef2e9e00c1e6dd5c1965f2 | a32e7ff4f8db1cd71390bd6dba533fd3ad95837b0d75214502fdf4a62cb56b83 | 0.013397 | cpp | a32e7ff4f8db1cd71390bd6dba533fd3ad95837b0d75214502fdf4a62cb56b83 | 503389e22901f568f554adca594cb607037857566291590667fb96bfec7f7acb | PIE_released_gem5_runtime | pie_35989 | p03654 | 951266bbb6da850c204959d47e058018cc4a0e2096cfb509d59bdafae06d5191 | 503389e22901f568f554adca594cb607037857566291590667fb96bfec7f7acb | 0.446033 | 33.294186 | 8+ | 1debea616fccef2e5f92aa7f6cd0f15ca2397ba6503c97a74ebaef62588987f6 | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <cmath>
#include <vector>
#define SF scanf
#define PF printf
#define MAXN 100010
#define INF 0x3FFFFFFF
using namespace std;
typedef long long ll;
int siz[MAXN];
ll ans;
int siz1, d1, d2;
ll dep[MAXN];
vector<int> a[MAXN], w[MAXN];
int n... | #include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 100010
#define LL long long
#define INF 1000000000
int Adj[MAXN], V[MAXN * 2], nxt[MAXN * 2], W[MAXN * 2], c;
void AddEdge(int u, int v, int w)
{
c++;
V[c] = v, W[c] = w, nxt[c] = Adj[u];
Adj[u] = c;
}
int siz[MAXN], mx[MAXN], rt, ... |
8de2031e90c9e4cb7a82c6ddcb7d3e513525542e16ff3fb99a5e059ba4ae46d4 | aa796323451c4e58d7514d7288d7f7bc8212739f441c85c8f386ccd7a24bca02 | 0.096643 | cpp | aa796323451c4e58d7514d7288d7f7bc8212739f441c85c8f386ccd7a24bca02 | 09629c4c137dc3c66516aab2e5e1afab9baf3f2816765f95dd789d59e3fc7764 | PIE_released_gem5_runtime | pie_36002 | p03789 | 776a96a832e8b5cf2a7ed6aa899e720d129a8a00a548c0d2fb26f4e2652fa966 | 09629c4c137dc3c66516aab2e5e1afab9baf3f2816765f95dd789d59e3fc7764 | 0.287361 | 2.973428 | 2-4 | b22cb4c582ef36a3225c5c7af9b403f85c6a316ba03395355ed23d079fc8d56d | #include <bits/stdc++.h>
#define INF 0x3f3f3f3f
#define maxn 500100
#define lson root << 1
#define rson root << 1 | 1
#define lent (t[root].r - t[root].l + 1)
#define lenl (t[lson].r - t[lson].l + 1)
#define lenr (t[rson].r - t[rson].l + 1)
#define N 1111
#define eps 1e-6
#define pi acos(-1.0)
#define e exp(... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define pb push_back
const int maxn = 1e5 + 20;
string s;
int mkay()
{
int n = s.size();
s[n - 1]++;
for (int j = n - 1; j >= 0; j--)
{
if (s[j] <= '9')
return j;
s[j - 1]++;
s[j] = '0';
}
}
int main()
{
i... |
da60e177556c2354347fe57940b667d19dae6efb4c2e577f4d955ad1b9f2120d | 961b7c13d388566031effe809ec387a1fad2e8416b3ec8888ca4da94144978ef | 0.030864 | cpp | 961b7c13d388566031effe809ec387a1fad2e8416b3ec8888ca4da94144978ef | 128b7e5c17d85c362adebc5dd3373e0690a125f7dfcad9623914c9d2b6ae699e | PIE_released_gem5_runtime | pie_36011 | p03772 | 007d3d18dd474df3ec330703482988367bba0ddb3538271753c34612725ccf21 | 128b7e5c17d85c362adebc5dd3373e0690a125f7dfcad9623914c9d2b6ae699e | 0.117241 | 3.798621 | 2-4 | 6aedd29c7c6a0cd6a25fa31e3541249d353aa5d04647f80327a6e142b1cc64ed | #include <iostream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>... | #include <cstdio>
#include <cstring>
#include <algorithm>
#define MAXN 100
#define MO 1000000007
using namespace std;
typedef long long LL;
int a[MAXN + 5], n;
LL f[MAXN + 5][MAXN + 5][MAXN + 5];
int main()
{
scanf("%d", &n);
for (int i = 1; i <= 2 * n - 1; i++)
scanf("%d", &a[i]);
sort(a + 1, a... |
3eff5f92a253657eebaf03199e735cc33b452909d24b29d4a6720f6ce04dde33 | 4f27900fbf2c7ab8ef993a735e6a0c04f949a08db855a13e1a6189217f6108f9 | 0.139059 | cpp | 4f27900fbf2c7ab8ef993a735e6a0c04f949a08db855a13e1a6189217f6108f9 | 56cbd62e3e3f31909c7ac58688fac50672eeac1d8ab8b543c24bfedc7e48126e | PIE_released_gem5_runtime | pie_36021 | p00042 | 90ac5a4862e8794b9afd4bdbb2e5936b2c5043e667ca1696d936fc906537f89b | 56cbd62e3e3f31909c7ac58688fac50672eeac1d8ab8b543c24bfedc7e48126e | 0.974991 | 7.011353 | 4-8 | 213028582cfee24aa06aa5d386c8ecf41256815828530ad3993415f1dd102d47 | #include <iostream>
#include <vector>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
#define INF (1 << 21)
int dp[1001][1001];
pair<int, int> solve(vector<int> value, vector<int> weight, int W, int N) {
for (int i = 0; i < 1001; i++)
for (int j = 0; j < 1001; j++)
... | #include <bits/stdc++.h>
using namespace std;
struct Item {
int v, w;
int idx;
};
const int INF = 1000000000;
class Knapsack {
public:
int maximumWeight;
vector<Item> items;
Knapsack(int maximumWeight_, vector<Item> items_)
: maximumWeight(maximumWeight_), items(items_) {
used.resize(items... |
e1847f4f43038559cc14e1804cc02f9e166cdfb1489229af433e5480aab34271 | 30d64161671ad68df2aeecfa8b72a9cced4f1dee2dfc26a6813f05155f1bea19 | 0.022076 | cpp | 30d64161671ad68df2aeecfa8b72a9cced4f1dee2dfc26a6813f05155f1bea19 | e97e02f8646f4af372bc0440914bbc2fb7dc08b73cc936d41553fb8195c82be7 | PIE_released_gem5_runtime | pie_36027 | p02595 | 288f83cae956b2e568e59cd8ffd10fd1559b868fcebb7869829faa9f2d7716e4 | e97e02f8646f4af372bc0440914bbc2fb7dc08b73cc936d41553fb8195c82be7 | 0.109624 | 4.965667 | 4-8 | b6e64ffe05d17e688848c9548d6e7afe5dd28b0252abe570023adc10de089398 | #include <iostream>
#include <cmath>
using namespace std;
int main()
{
double n, d, x, i, s = 0, a, b;
cin >> n >> d;
for (i = 0; i < n; i++)
{
cin >> a >> b;
x = sqrt((a * a) + (b * b));
if (x <= d)
s++;
}
cout << s << endl;
}
| #include <stdio.h>
#include <math.h>
int main()
{
long long int a, b, i, p, q, count = 0;
scanf("%lld%lld", &a, &b);
for (i = 0; i < a; i++) {
scanf("%lld%lld", &p, &q);
if ((double)(sqrt(pow(p, 2) + pow(q, 2))) <= b)
count++;
}
printf("%lld\n", count);
return 0;
}
|
c4d3f0c69b66206258c3e60bbb2e79da5d8fd346438a08b272a1220b67f190f6 | aa67a8cbc5efc0824c727b4e57e29391e4bc6fd798c863438c21ff191d2ea322 | 0.06689 | cpp | aa67a8cbc5efc0824c727b4e57e29391e4bc6fd798c863438c21ff191d2ea322 | cc9dd8fed3b921537ffb44ce5007dcb6bc8f5c14ae278f5e00e0e98064ace0bb | PIE_released_gem5_runtime | pie_3637 | p02756 | 9d63b13b269e637d63105d6895486f30a3be6e47087b8b60fd3dab7b6dfdb2e8 | cc9dd8fed3b921537ffb44ce5007dcb6bc8f5c14ae278f5e00e0e98064ace0bb | 0.188383 | 2.816327 | 2-4 | 8353c77fcea62891a0d2f2a3703f201e0b36cdd348725b2feda4f82a31a88636 | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef int64_t Int;
using namespace std;
int main() {
string S;
int Q;
cin >> S >> Q;
vector<int> T(200010), F(200010);
vector<char> C(200010);
bool rev = false;
rep(q, Q) {
cin >> T[q];
if (T[q] == 1)
... | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
typedef int64_t Int;
using namespace std;
int main() {
string S;
int Q;
cin >> S >> Q;
deque<char> DQ;
rep(i, S.length()) DQ.push_back(S[i]);
bool head = true;
rep(q, Q) {
int T;
cin >> T;
if (T == 1)
... |
2a502feb2a87628fc7ef0a97b1fc05f6c2cc350e859e27cd4f5be1267ab52047 | 14e61a1eef95dcf1a154ac89d726f8d1790216170a9e1fbe5862e37813f40c81 | 0.005636 | cpp | 14e61a1eef95dcf1a154ac89d726f8d1790216170a9e1fbe5862e37813f40c81 | baaf006be417d49959c32083a03aafa2f904dfafa33828a8716147d57168257d | PIE_released_gem5_runtime | pie_36484 | p03248 | aae3e45152ac627bade197304afe2a1258ac467e9c45857b799af034e8a07051 | baaf006be417d49959c32083a03aafa2f904dfafa33828a8716147d57168257d | 0.109107 | 19.358931 | 8+ | 7be52a208d8cf73a50139000e1c6bf03bc8e5997a5907dac877f73134d72bf88 | #include <bits/stdc++.h>
#define fi first
#define se second
#define ll long long
#define pb push_back
#define mp make_pair
#define mt make_tuple
using namespace std;
int niz[100010];
vector<int> graf[100010];
vector<pair<int, int>> res;
int main()
{
ios_base::sync_with_stdio(false);
cin.tie(NULL);
... | #include <cstdio>
#include <cstring>
char arr[100010];
int prv[100010];
int main() {
scanf("%s", arr + 1);
int n = strlen(arr + 1);
if (arr[1] == '0' || arr[n] == '1') {
puts("-1");
return 0;
}
for (int i = n - 1; i; --i)
if (arr[i] != arr[n - i]) {
puts("-1");
return 0;
... |
2b7cfd6118f2b391d101a2172b0a909116649aa1e967ccf80ed19a6752e03c37 | b9cde14c3a80a7812b3dc5e371428ef92cf189d9fbeb73faa6f348224bdcb5c4 | 0.019825 | cpp | b9cde14c3a80a7812b3dc5e371428ef92cf189d9fbeb73faa6f348224bdcb5c4 | d13dbe884f28ac71b6f241c3ec789dff3d1f44266a414a8ce1f8940c7536d3b8 | PIE_released_gem5_runtime | pie_365 | p02759 | 844ec1530d8d3fc28a64cb603712db9249ca5fe03fcaf4fd3e7b86610b4a6455 | d13dbe884f28ac71b6f241c3ec789dff3d1f44266a414a8ce1f8940c7536d3b8 | 0.374673 | 18.899433 | 8+ | 21b9616d98503659c3841bed7f28e7554121d1a39c338ac979c268a779a96023 | #include <bits/stdc++.h>
using namespace std;
int gcd(long long a, long long b)
{
if (b == 0)
return a;
return gcd(b, a % b);
}
const int N = 1e5 + 5;
vector<int> adj[N];
bool visited[N];
int nodesNum;
void dfs(int node)
{
if (visited[node])
return;
visited[node] = true;
for (int child... | #include <stdio.h>
int main() {
int N;
scanf("%d", &N);
if (N % 2 == 0) {
printf("%d", N / 2);
}
else {
printf("%d", (N / 2) + 1);
}
} |
8560a5ba2c0882ee67884c851a811896338a40777c5e73d69fd41d3ed4edf428 | b629616c0e22257fcbc0721553ce56028fbeb2ec0021113310613ea03fdf4afd | 0.095895 | cpp | b629616c0e22257fcbc0721553ce56028fbeb2ec0021113310613ea03fdf4afd | a29ed20bb675bab149facdc46a36f4dd4b41753d6f404ad7756a2e73364c49bc | PIE_released_gem5_runtime | pie_36523 | p00731 | c63df5bdea44cc994831ca10bb83a7659f67b7277508700c18616fe3314e6145 | a29ed20bb675bab149facdc46a36f4dd4b41753d6f404ad7756a2e73364c49bc | 0.422269 | 4.40345 | 4-8 | f5cf6462980a0f8f5a7a5fb01012526702aa13191c72c0d286fd1889b120d2b6 | #include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <numeric>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <utility>
#include <sstream>
#include <complex>
#include <fstream>
#include <b... | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e16;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (int i = (a); i < (b);... |
53e8b881c2921aea644fee9ef40055d4842924713c467e083952b7c422466acb | 2d0e8c8293f36aa5bed5932bd479222c48bde12ad54bc94ea46e37960ad3ab2e | 0.000192 | cpp | 2d0e8c8293f36aa5bed5932bd479222c48bde12ad54bc94ea46e37960ad3ab2e | b0ec4d924ecce7be8c354127f0598181421c934c174ad412eb27b8294d8ea8ac | PIE_released_gem5_runtime | pie_36530 | p03870 | 25a1b38c9d05336c3de85dba22472a362c54514e9789815179c74845efe02631 | b0ec4d924ecce7be8c354127f0598181421c934c174ad412eb27b8294d8ea8ac | 0.000943 | 4.918794 | 4-8 | aee94a4ca32778c6c13114a3904da1bcbac240d368a2f99e87cce81e8c61b1cc | #include <cstdio>
#include <set>
int a[100000];
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &a[i]);
int xor_sum = 0;
for (int i = 0; i < n; i++)
xor_sum ^= a[i];
std::set<int> s;
for (int i = 0; i < n; i++)
s.insert(a[i] ^ (a[i] - 1));
int ans =... | #include <cstdio>
int check[30];
int main() {
for (int bit = 29; bit >= 0; bit--) {
check[bit] = 0;
}
int n;
scanf("%d", &n);
int xor_sum = 0;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
xor_sum ^= a;
a = a ^ (a - 1);
switch (a) {
case 1073741823:
c... |
f2bcce5dd1792364ebd849b456194a8db597deb4532e35befac9037f0484c1c6 | 91fa0550ede37f560fa4070ae1488b7b2d0f798c162ca9eaaa7c3b1921031c2f | 0.000191 | cpp | 91fa0550ede37f560fa4070ae1488b7b2d0f798c162ca9eaaa7c3b1921031c2f | 056747798fa71d5352e9350bc209524db4527e55d611a3d018fe099aa895062e | PIE_released_gem5_runtime | pie_36556 | p03387 | 18b7de0092a402a99aafbab3d1d6ebf55cd2baf0e59446cf34b2b8c440992b10 | 056747798fa71d5352e9350bc209524db4527e55d611a3d018fe099aa895062e | 0.006671 | 34.876776 | 8+ | db1368751a3abcd679901b6e9deffd55a9bf21db6cd30742303cdd3dbd10fb7b | #include <cstdio>
#include <queue>
#include <cstring>
#include <iostream>
#include <algorithm>
using namespace std;
int vis[110][110][110];
struct node
{
int a, b, c, s;
node(int aa, int bb, int cc, int ss) : a(aa), b(bb), c(cc), s(ss) {}
};
int bfs(int a, int b, int c)
{
queue<node> q;
q.push(nod... | #include <stdio.h>
int main()
{
long long max, sum, a, b, c;
while (scanf("%lld%lld%lld", &a, &b, &c) != EOF)
{
max = a > b ? a : b;
max = max > c ? max : c;
sum = (max - a) + (max - b) + (max - c);
if (sum % 2 == 0)
printf("%lld\n", sum / 2);
else
{
printf("%lld\n... |
ab786d85591fab6cbbb069676aecaf110b2888df92957bbab7ee5810acd65cc6 | 9ac748a61a15e134310ab80eac4249a677ba5056773066d415b8797a89718f97 | 0.018633 | cpp | 9ac748a61a15e134310ab80eac4249a677ba5056773066d415b8797a89718f97 | d566a2a61cd8f75e882de51bb91ecdc3850471e337a5dfc7a454c2c39914e2d5 | PIE_released_gem5_runtime | pie_36580 | p03820 | 29a5374db7cc36d16fd870ea68fcb0ef180f544ff7460ccfd519367942b52e08 | d566a2a61cd8f75e882de51bb91ecdc3850471e337a5dfc7a454c2c39914e2d5 | 0.107874 | 5.789435 | 4-8 | a82cad40eba86152aad22da9ced53a6db217ce7194cc5bd90142dce716589f52 | #include <bits/stdc++.h>
#define debug(x) cout << #x " = " << x;
#define st first
#define nd second
using namespace std;
using namespace placeholders;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PII;
typedef pair<ll, ll> PLL;
const int MAXN = 2E3 + 10;
const int MOD = 1E9 + 7... | #include <cstdio>
typedef long long ll;
const int MAXN = 2E3 + 10;
const int MOD = 1E9 + 7;
ll modExp(ll e, ll n, ll m = MOD) {
ll ret = 1;
for (; n; n >>= 1, e = e * e % m)
if (n & 1)
ret = ret * e % m;
return ret;
}
inline void update(int &x, int y) {
if ((x += y) >= MOD)
x -= MOD;
}... |
d46a5c818d36b19aeb310c8a81f9d0cfb3bab44cac77cc0d63229c25c49d82c9 | b35c09d158beb6ef5d093ebcca843f3b41bdc1c8a0191081f535ccb400b13d25 | 0.01238 | cpp | b35c09d158beb6ef5d093ebcca843f3b41bdc1c8a0191081f535ccb400b13d25 | 689e9e9d30c94832cbb4f303f9cfe46e7f1b234fa4aecfd2ba0b56746582c7a9 | PIE_released_gem5_runtime | pie_36917 | p02712 | 5e0cd7cba7a0e5e6438f32a4c9821adc44d9103fc51789f8a29fe55a97b09a02 | 689e9e9d30c94832cbb4f303f9cfe46e7f1b234fa4aecfd2ba0b56746582c7a9 | 0.087878 | 7.098319 | 4-8 | 15f5cd2452cc1098bebe92dd84ab0f85023789ec6117e770ae2d8ab832b19970 | #include <iostream>
#include <cstdio>
#include <iomanip>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
#include <map>
using namespace std;
string s[10005];
int main()
{
int n;
cin >> n;
long long ans = 0;
for (int i = 1; i <= n; i++)
{
if (i % 3 == 0)
c... | #include <stdio.h>
int main() {
long long int n;
scanf("%lld", &n);
long long int total = 0;
for (int i = 0; i <= n; i++) {
if (i % 3 == 0 && i % 5 == 0) {
continue;
} else if (i % 3 == 0) {
continue;
} else if (i % 5 == 0) {
continue;
} else {
total += i;
... |
1d54a9bb0b9d3e11318f631cb7ba16f1bcb1e4aa8baca14178125698f98b3408 | ea9900b562ae529aab7c69bbd19efd95a26e37997dd4de1ea0a398d2feacef90 | 0.02028 | cpp | ea9900b562ae529aab7c69bbd19efd95a26e37997dd4de1ea0a398d2feacef90 | bf854baf5679321f5e8c3088208b0c4abe8bcf50e7fe1c9a258cda9bcab54d96 | PIE_released_gem5_runtime | pie_3699 | p03853 | f8053172570077d79be76127b37a33c0ad53bc9e18bf7ff9fbcd4355aed50130 | bf854baf5679321f5e8c3088208b0c4abe8bcf50e7fe1c9a258cda9bcab54d96 | 0.214042 | 10.554499 | 8+ | 4260ae905d1ad2fc332eec5a7b20ee9e1078ff1dcf2dbe4d29445dba2b08f748 | #include <iostream>
#include <stdio.h>
#include <math.h>
using namespace std;
int main() {
int h, w;
cin >> h >> w;
char str[1001][1001] = {'\0'};
int i, j;
fflush(stdin);
for (i = 1; i <= h; i++) {
for (j = 1; j <= w; j++) {
cin >> str[i][j];
}
}
for (i = 1; i <= h; i++) {
... | #include <stdio.h>
#include <string.h>
int main()
{
int h, w, i, j;
char c[310][300];
scanf("%d %d", &h, &w);
getchar();
for (i = 1; i <= h; i++) {
scanf("%s", &c[i]);
}
for (i = 1; i <= h; i++) {
puts(c[i]);
puts(c[i]);
}
return 0;
} |
7956a311a0827e3e80893c0cfe4cf5d9a085375422a9400ff73865b39b531999 | 3dfb85f159adec9c44aad44111d600c5c79fb66b825416708a90f410e788128e | 0.010311 | cpp | 3dfb85f159adec9c44aad44111d600c5c79fb66b825416708a90f410e788128e | 703261bd1a818d9c6c11b35a046ebd83835aae03e8b96d30e5de8482c3a5cdc9 | PIE_released_gem5_runtime | pie_3724 | p02764 | 8dd1d99abf04501382ed45a65859cbe726d14deeb457cf4d40db42295e1fad2a | 703261bd1a818d9c6c11b35a046ebd83835aae03e8b96d30e5de8482c3a5cdc9 | 0.047241 | 4.581824 | 4-8 | 5257a7046b72a2a59a0ce76f8d8999f15a165f469715a3e745a844cd3e52c870 | #include <bits/stdc++.h>
using namespace std;
const int N = 65;
const double eps = 1e-8;
int n, k;
double x[N], y[N], c[N], r[N];
double dis(pair<double, double> a, pair<double, double> b) {
return sqrt((a.first - b.first) * (a.first - b.first) +
(a.second - b.second) * (a.second - b.second));
}
... | #include <stdio.h>
#include <math.h>
#define maxn 65
#define eps 1e-8
double x[maxn], y[maxn], c[maxn], X[65 * 65 * 2], Y[65 * 65 * 2], r[maxn];
int tot, N, K;
double dis(double x, double y, double c, double X, double Y) {
return sqrt((X - x) * (X - x) + (Y - y) * (Y - y));
}
void cal(double x1, double y1, do... |
2190801eada8f8208e74e6e4d82ab15de21ef860c04d03c070eec53cf8e29405 | cb7cc22fc664fac113f21c389818e62a12dcd2981143622bbe85550cdc5bd143 | 0.09414 | cpp | cb7cc22fc664fac113f21c389818e62a12dcd2981143622bbe85550cdc5bd143 | 76198cb81c0d37494739786d836c4a52a1330d6e92d8ef9ce226f944903557b7 | PIE_released_gem5_runtime | pie_3745 | p00323 | 66e837730a73d1b69ed8c6dcb03ae9d2af2854243e0adae3496ca88c2b95eb1a | 76198cb81c0d37494739786d836c4a52a1330d6e92d8ef9ce226f944903557b7 | 0.231811 | 2.462401 | 2-4 | ff0086eafa7560884440684a2b4bc338b605ce4dd38106fd8a8c258cd7eddd51 | #include <deque>
#include <queue>
#include <vector>
#include <algorithm>
#include <iostream>
#include <set>
#include <cmath>
#include <tuple>
#include <string>
#include <chrono>
#include <functional>
#include <iterator>
#include <random>
#include <unordered_set>
#include <unordered_map>
#include <array>
... | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define fi first
#define se second
template <typename A, typename B> inline bool chmax(A &a, B b) {
if (a < b) {
a = b;
return 1;
}
... |
c7639c31266097ee861808d95e5430061f62d1e9b57f44d868f784d46670f521 | c3fc913a8617e9e8b7b26ba77219db99b35c02699c128c29b00bf5c21cdaac6a | 0.098213 | cpp | c3fc913a8617e9e8b7b26ba77219db99b35c02699c128c29b00bf5c21cdaac6a | 884818199fda81b2239fe568036ee8682289a420635a2a35306258a0d492d8c4 | PIE_released_gem5_runtime | pie_37558 | p00590 | dbac3d6ead88e67520828e5b10008ff7d54c3b44ae886083678354ac7bf3253a | 884818199fda81b2239fe568036ee8682289a420635a2a35306258a0d492d8c4 | 0.307424 | 3.130187 | 2-4 | fa10dcb36534ef05ee3bbec394a2ce655f6bbd20f5c85840d50e3eced069ef4f | #include <bits/stdc++.h>
#define ll long long int
using namespace std;
ll i, j, k, l, n, counter;
bool ara3[200000];
void seive()
{
for (i = 2; i <= 100001; i++)
{
ara3[i] = true;
}
ara3[1] = false;
for (i = 2; i <= 100001; i++)
{
for (j = 2; i * j <= 100001; j++)
{
if (ara3... | #include <iostream>
#include <math.h>
using namespace std;
int IsPrime(int a, int b)
{
int i, p = 0, q = 0;
if (a == 1 || b == 1)
{
return 0;
}
for (i = 2; i <= sqrt(a); i++)
{
if (a % i == 0)
{
p = 1;
break;
}
}
for (i = 2; i <= sqrt(b); i++)
{
if (b %... |
fca305f8215e8653f9748746484a7e861dc8b3b997d23b4ad88a5d5bacebf690 | 580e046ebfa72cb0296db754f790d20a3f333a10a77f2e24791a76411869cc46 | 0.105989 | cpp | 580e046ebfa72cb0296db754f790d20a3f333a10a77f2e24791a76411869cc46 | 5c1f91d9bf6cc6e2b8cbb8b5c9e2e078ea353a9b9edf444ff9be5f7576b042ba | PIE_released_gem5_runtime | pie_37566 | p03018 | 5c78143c9f42960145027baf6acbd5cf69224b1835d172323076976854884aab | 5c1f91d9bf6cc6e2b8cbb8b5c9e2e078ea353a9b9edf444ff9be5f7576b042ba | 0.635583 | 5.996658 | 4-8 | 67b1534b50ed8faf66ff5acbbf811db46a7e1aaba51c0b1b4b07f1e34442b49f | #include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <list>
#include <set>
#include <string>
using namespace std;
int gcd(int a, int b) {
int c = a % b;
while (c != 0) {
a = b;
b = c;
c = a % b;
}
return b;
}
struct UnionFind {
vector<int> par;
Un... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define ll long long
int main() {
string s;
cin >> s;
int n = s.size();
rep(i, n - 1) {
if (s[i] == 'B' && s[i + 1] == 'C')
s[i] = 'K', s[i + 1] = 'D';
}
reverse(s.begin(), s.end());
ll k = 0, ... |
1b72a63a1d10fd851ed5af4ee959fe8ad42f262caa44840d761d676c258c3352 | 66a4990d3bd6c7bf57aa935232e26f218e6a773496e051f455df06ba15648086 | 0.032262 | cpp | 66a4990d3bd6c7bf57aa935232e26f218e6a773496e051f455df06ba15648086 | 6d6c0c32711ed7a4c16e688301b5f8638913677f8c155602670663795e9c3e74 | PIE_released_gem5_runtime | pie_37639 | p03822 | 15d8b16c123bef17973498769c6bebb82d6f8fa7ef980ec042f04a0574c6e6f1 | 6d6c0c32711ed7a4c16e688301b5f8638913677f8c155602670663795e9c3e74 | 0.112166 | 3.476719 | 2-4 | 2c520b5e89414c74fdab4da5c600ef006ccde6715d345ead92be0698ac2ae8d0 | #define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int ll
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<ll> VL;
typedef vector<VL> VVL;
typedef pair<int, int> PII;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i,... | #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 ... |
f21772e707376f74a81264e25696143d84d68ca5ea6d4954eee656c47df70d88 | c751a65e5d8ba721a9e581ea49cc415eecdce49a857b9ea168a95fed5cf1a0ed | 0.03305 | cpp | c751a65e5d8ba721a9e581ea49cc415eecdce49a857b9ea168a95fed5cf1a0ed | fe896fe392f84ec6ee53cb32228f36bdc0884626b48612f9c3efee609579afc2 | PIE_released_gem5_runtime | pie_37670 | p03361 | 00653fbf80eae4a5c4ab8106c911c022f9025f89d86fe1ddcd23f400bf6f5f51 | fe896fe392f84ec6ee53cb32228f36bdc0884626b48612f9c3efee609579afc2 | 0.094633 | 2.863331 | 2-4 | 0f75f8c80710c6936bfcbbd653587b7c29beedb464c3b4924c0a7bdaf2d88888 | #pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, greater<Q_type>>;
const ... | #define MOD_TYPE 1
#pragma region Macros
#include <bits/stdc++.h>
using namespace std;
using ll = long long int;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
using pld = pair<ld, ld>;
template <typename Q_type>
using smaller_queue = priority_queue<Q_type, vector<Q_type>, great... |
ab730947ca9ad2ecac96adb2a3879154c2250cbe992099c9e9250c1a2ba5c7e2 | 086e837f0f3e3eab99289829ff33b4bf759633b454c0f15aa1d056efc5dd0f86 | 0.040709 | cpp | 086e837f0f3e3eab99289829ff33b4bf759633b454c0f15aa1d056efc5dd0f86 | 6a14c06f596bb3fa7bd79e60b86ce906ee69d8ca43cd7d22393d0900a4a19e16 | PIE_released_gem5_runtime | pie_37681 | p03427 | b4c86fc45921ebfc06feb4b8fb7a4572afd27187b14013c290c010d8a3598ea3 | 6a14c06f596bb3fa7bd79e60b86ce906ee69d8ca43cd7d22393d0900a4a19e16 | 0.262394 | 6.445582 | 4-8 | 0593c56753eaf6deafae55c22ace837d8134a8158e71c6e5a819dc4c07b50df3 | #include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <utility>
#include <functional>
#include <deque>
#include <cctype>
#include <stack>
#include <bitset>
using ll = long long;
typedef unsigned long long ... | #include <iostream>
#include <string>
#include <algorithm>
#include <iomanip>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <utility>
#include <functional>
#include <deque>
#include <cctype>
#include <stack>
#include <bitset>
#include <set>
using namespace std;
using ll = l... |
3bc2227227126fc27eb00cdea74aac216299fb380072802a67fd565f974e42f1 | 3afbe6e17e7dda5cef143b7578c9686da290ea6f079805430a5ac29d846902da | 0.047337 | cpp | 3afbe6e17e7dda5cef143b7578c9686da290ea6f079805430a5ac29d846902da | b714daa995633270b137c83f58e63b009b65509200b4c660690d9246905a8ad6 | PIE_released_gem5_runtime | pie_37714 | p03383 | 3f31307c562645398abe2fd458b91ac73459b210ee8ccbb6ad0a7cd4ae7fb679 | b714daa995633270b137c83f58e63b009b65509200b4c660690d9246905a8ad6 | 0.099548 | 2.102969 | 2-4 | 1740b2e5a94bdae62152e5d5ed52447409990f5dd404c2849e6ba9df94be4973 |
#include <assert.h>
#include <ctype.h>
#include <errno.h>
#include <float.h>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <limits>
#include <locale>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <time.h>
#include <wchar.h>
#include <wctype.h... | #include <bits/stdc++.h>
using namespace std;
int n, m;
char s[15][15];
int cnt[15][35];
int tr[15], tc[15];
void colstrs(int now, bool js = m & 1) {
if (now == m) {
puts("YES");
exit(0);
}
if (~tc[now]) {
colstrs(now + 1, js);
return;
}
if (js) {
bool can = 1;
for (int ... |
1a4016dac03ce9a65c6e17821e0689d3f9ed0012092289c8a15d7316c73ab162 | bc81fb6b1c97662310170776fe16216cae2a5ef7f9b0fd62bc07e4fdf9d4cbb4 | 0.042462 | cpp | bc81fb6b1c97662310170776fe16216cae2a5ef7f9b0fd62bc07e4fdf9d4cbb4 | 50b91d06c6505a991dd84e478de6799114e7be5143e58348abc26933b96da9b3 | PIE_released_gem5_runtime | pie_37761 | p02323 | 1f77f230c6f2f35b94acdf859d6addd608c1e2d60592e50b0b6d130da4774fec | 50b91d06c6505a991dd84e478de6799114e7be5143e58348abc26933b96da9b3 | 0.115557 | 2.721396 | 2-4 | 29025d361dde8875114dcb8522bee336d316de4b37e0dd8b25e3cbc1032e5af1 | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
#define MAX 15
#define INF 1 << 28
int n;
int d[MAX][MAX];
int dp[1 << MAX][MAX];
int rec(int s, int v) {
if (dp[s][v] >= 0)
return dp[s][v];
if (s == (1 << n) - 1 && v == 0)
return dp[s][v] = 0;
int res =... | #include <bits/stdc++.h>
using namespace std;
struct TSP {
int n, d[16][16], dp[(1 << 16)][16];
TSP(int sz) : n(sz) {
for (int i = 0; i < 16; i++)
for (int j = 0; j < 16; j++)
d[i][j] = 1e8;
}
void add(int a, int b, int c) { d[a][b] = c; }
int solve() {
for (int i = 0; i < (1 <<... |
0626c329b0347233009b5fc9812cf3f7b92cdce78eaf18e4ce60997c82ac479b | d0b40895d4cd7faa61f152aeb8191440dd5c379faefc07ba656d4a01628067c2 | 0.046333 | cpp | d0b40895d4cd7faa61f152aeb8191440dd5c379faefc07ba656d4a01628067c2 | 683dd0771e8323bbc435aba81287ed6580a7886162920e652828a590c297a8d3 | PIE_released_gem5_runtime | pie_37768 | p00453 | 7d97a9bdc23ef16b98834c05d1fd4d06ba8f9b109f82fb2e1e970a65c12d92e1 | 683dd0771e8323bbc435aba81287ed6580a7886162920e652828a590c297a8d3 | 0.236155 | 5.096948 | 4-8 | 10d2795e8b2bbfe530c061f36be3626294c4018290ed9db21b374d2e7de3d18a | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <vector>
#include <string>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <algorithm>
using namespace std;
#define rep(i, j) REP((i), 0, (j))
#define REP(i, j, k) for (int i = (j... | #include <cstdio>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 29;
int N, M;
int dp[256][128][16];
vector<P> s[151];
int main() {
while (scanf("%d%d", &N, &M) && N || M) {
for (int i = 0; i < 151; i++)
s[i].clear();... |
a3929a431fc5a6a42121d4601c1c957bb02d3cb3adc5eff96e8b7dd003b1cac4 | cbda78967fe21a1b68e1dbb9585734bfdce240a7024e31c90d3b48a85af3f580 | 0.0067 | cpp | cbda78967fe21a1b68e1dbb9585734bfdce240a7024e31c90d3b48a85af3f580 | 7d8f9280d692ade17b062f9cb3bb86efdb745f86984a5f71dcdd71573960c13c | PIE_released_gem5_runtime | pie_37773 | p03804 | 364f644b360a3e21dd55c7e3d2c6d8b93a185112a0c1f19d62c8f94f54698ba3 | 7d8f9280d692ade17b062f9cb3bb86efdb745f86984a5f71dcdd71573960c13c | 0.035287 | 5.266725 | 4-8 | 4e556446cfb8e2bd55d1b189f80f935d2cf0dc448a4dc978ae7080f71f81ff6b | #include <bits/stdc++.h>
using namespace std;
int n, m;
static bool mp[55][55], mp1[55][55];
bool is_cmp()
{
for (int i = 1; i <= n - m + 1; i++)
for (int j = 1; j <= n - m + 1; j++)
{
int flag = 1;
for (int h = 1; h <= m; h++)
for (int k = 1; k <= m; k++)
if (mp[i + ... | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <string>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
#include <queue>
#include <set>
using namespace std;
typedef long long LL;
const int MaxN = 1e5;
const int Inf = 1 << 30;
char s[55][55], t[55][55];
int main()
... |
37b93470f2f9f84f2640266d1930e47282867358342477c3876f2cde6343401b | de1df215224bac802a1b19a26e3abd2fada15c78f550a7c9d98242f4137dd579 | 0.001025 | cpp | de1df215224bac802a1b19a26e3abd2fada15c78f550a7c9d98242f4137dd579 | 81051311fb71d49f593fecc1a988343cffe4cd67c3b4dac67db0454e9412a9d4 | PIE_released_gem5_runtime | pie_37789 | p03701 | b0e1fe5eed50b7130675a3546290a79336d8ff7eb976d296650a9864e242e350 | 81051311fb71d49f593fecc1a988343cffe4cd67c3b4dac67db0454e9412a9d4 | 0.005886 | 5.743374 | 4-8 | 7e0a3789b6efc02a6789ff39efb0b87069fb4af0274544c4dcd44e9056f9b226 | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <cstdio>
#include <utility>
#include <set>
#include <list>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <iomanip>
... | #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <map>
#include <math.h>
#include <queue>
#include <deque>
#include <stack>
#include <cstdio>
#include <utility>
#include <set>
#include <list>
#include <cmath>
#include <stdio.h>
#include <string.h>
#include <iomanip>
... |
6a0d212a18b28d5c64d7413bd944947ee3042b8e6af01d8ccc58b2031317effa | 4b1f010422f6cf401ec573290d1c89dcb4f33ee9369b6665be13098dcaccaf52 | 0.019498 | cpp | 4b1f010422f6cf401ec573290d1c89dcb4f33ee9369b6665be13098dcaccaf52 | 11109de0561af776a245431f402309b1d80927717a380bf97a156f333820ab01 | PIE_released_gem5_runtime | pie_37820 | p03623 | 3d542fef94a1ca88041838e561db2629a974abe0fa2afcd8478a1c66e4f7321c | 11109de0561af776a245431f402309b1d80927717a380bf97a156f333820ab01 | 0.104004 | 5.33397 | 4-8 | 01640377ce6ec4af26cc171552ddc0b7bbf8f8a8a493cf859ba851fb54eab1c3 | #include <iostream>
#include <cstdio>
#include <cmath>
using namespace std;
int main()
{
int x = 0, A = 0, B = 0;
cin >> x >> A >> B;
if (abs(x - A) > abs(x - B))
{
cout << "B";
} else
{
cout << "A";
}
return 0;
} | #include <stdio.h>
int main() {
int n, a, b;
scanf("%d %d %d", &n, &a, &b);
int a1 = a - n;
int b1 = b - n;
if (a1 < 0) {
a1 *= -1;
}
if (b1 < 0) {
b1 *= -1;
}
if (a1 < b1) {
printf("A");
}
else {
printf("B");
}
return 0;
}
|
8a677b9369f7f2d617995e5340589793b095ab5b323aa78cb3f3cb42a4cda3c4 | e72bd29b2b12a7ed7ce54116bda78f53d4b71966dc487b4016532e85996605c5 | 0.096686 | cpp | e72bd29b2b12a7ed7ce54116bda78f53d4b71966dc487b4016532e85996605c5 | 77a473d9372fdd2fc672d89cd18cba1226cd4406d80301d7dff840ef795d0d06 | PIE_released_gem5_runtime | pie_37873 | p03683 | 3ca6a1cc75f5c4712525dd4f132322019986576b788a810b8ef4165df0e5564a | 77a473d9372fdd2fc672d89cd18cba1226cd4406d80301d7dff840ef795d0d06 | 0.226294 | 2.340513 | 2-4 | 0b6c61ab9ba799098a5e6fb36e449ea068ccb5500f89b261b41a8e287bf9a870 | #include <bits/stdc++.h>
using namespace std;
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
using LL = long long;
using VL = vector<LL>;
using VVL = vector<VL>;
using PLL = pair<LL, LL>;
using VS = vector<string>;
#define ALL(a) begin((a)), end((a))
#define RALL(a) (a).rbegin(),... | #include <iostream>
using namespace std;
typedef long long ll;
int main()
{
ll n, m;
cin >> n >> m;
if (abs(n - m) > 1)
{
cout << 0 << endl;
return 0;
}
if (n == m)
{
ll brojac = 1;
for (ll i = 1; i <= n; i++)
{
brojac *= i;
brojac %= 1000000007;
}
... |
58f51cf3213d0542348c647eea01e4dfc6685f48cba16a3e49f7a6f44e2425f8 | 52b7ef8f1339e654419c5fd550c63cdd129071df8c338250477d6cf1fc3aefe8 | 0.021974 | cpp | 52b7ef8f1339e654419c5fd550c63cdd129071df8c338250477d6cf1fc3aefe8 | 2e6d31c71b74ea8d63dd2b83b92a3eaa7e21dda9edb5856d51e9d75a66757f28 | PIE_released_gem5_runtime | pie_37905 | p03576 | ee6149673117414a4bf5eb6353df45bd4ff09417cf97ece31ddfd4d25aafd4f0 | 2e6d31c71b74ea8d63dd2b83b92a3eaa7e21dda9edb5856d51e9d75a66757f28 | 0.106475 | 4.845418 | 4-8 | 3165407b7421f4e6c4fa9ba4688729517a78f37c8ecd7e1dea4a6866e342bf0e | #include <bits/stdc++.h>
using namespace std;
#define ll unsigned long long
struct ac {
int x, y;
} a[55], d[55];
int cmp1(ac b, ac c)
{
return b.x < c.x;
}
int cmp2(ac b, ac c)
{
return b.y < c.y;
}
int sl(int x1, int y1, int x2, int y2, int i)
{
int xl = min(x1, x2), xr = max(x1, x2);
int yl ... | #include <stdio.h>
#include <stdlib.h>
struct node
{
long long x, y;
int a, b;
} point[55];
int incx(const void *a, const void *b)
{
struct node m = *(struct node *)a;
struct node n = *(struct node *)b;
if (m.x < n.x)
return -1;
else
return 1;
}
int incy(const void *a, const void *b)
{... |
c9a21b82326959dd426008f4e25d8d4fae5ca13e2eb91c4d6eb9783638a231d5 | 239a2108e01c135c8868e0a05ebe3369172f468a3e1046978c38792b52e96e5a | 0.020048 | cpp | 239a2108e01c135c8868e0a05ebe3369172f468a3e1046978c38792b52e96e5a | ceb45f72a42d81ad31de27e0a06c0323707c65d8304573753dd1a8432ae36f06 | PIE_released_gem5_runtime | pie_37914 | p00225 | 96c308a5fac44fa58359bc45d3b34f00c61ec896134a31f92fe3c2fe44b9848e | ceb45f72a42d81ad31de27e0a06c0323707c65d8304573753dd1a8432ae36f06 | 0.104437 | 5.209348 | 4-8 | 94eee9c9ee5585444f8a6feb19621f3d5ec72b13134151fcd57e763e0568d5d2 | #include <iostream>
using namespace std;
bool visit[26], g[26][26];
bool dfs(int v) {
visit[v] = true;
bool f = false;
for (int i = 0; i < 26; i++)
if (g[v][i]) {
f = true;
if (!visit[i])
dfs(i);
}
return f;
}
int graph_num(void) {
int res = 0;
for (int i = 0; i < 26... | #include <cstdio>
#include <cstring>
using namespace std;
bool visit[26], g[26][26];
bool dfs(int v) {
visit[v] = true;
bool f = false;
for (int i = 0; i < 26; i++)
if (g[v][i]) {
f = true;
if (!visit[i])
dfs(i);
}
return f;
}
int graph_num(void) {
int res = 0;
for ... |
2be76ef368632deb4a0de9fac6b429d1fc32225725a6e236577539ff67abc4d0 | c7d2781632585ed40f61f744e98736e5a377d3e332f1d457095e49e56461e5f5 | 0.112359 | cpp | c7d2781632585ed40f61f744e98736e5a377d3e332f1d457095e49e56461e5f5 | 5b1be56676e07054aec95578c89a961d9558d04e5420b9aad8e20e33e6184ba3 | PIE_released_gem5_runtime | pie_37948 | p03767 | f93ae1df4f4627884f3a2cb1d9f4a9509d7c847c2d2b47dbbd2dbd39283b69fd | 5b1be56676e07054aec95578c89a961d9558d04e5420b9aad8e20e33e6184ba3 | 0.262405 | 2.335415 | 2-4 | affbe30f415813f2b2be0476c5e86af28f301074dd5a6be84f2e412229939d45 | #include <iostream>
#include <algorithm>
#include <string>
#include <vector>
#include <math.h>
#include <map>
#include <functional>
#include <queue>
#include <stack>
using namespace std;
int main() {
int n;
cin >> n;
int a[364364] = {};
long long int ans = 0;
for (int i = 0; i < 3 * n; i++) {
... | #include <bits/stdc++.h>
using namespace std;
#define all(vec) vec.begin(), vec.end()
typedef long long int ll;
typedef pair<int, int> P;
const ll MOD = 1000000007;
const ll INF = 1000000010;
const ll LINF = 4000000000000000010LL;
const int MAX = 310;
const double EPS = 1e-9;
int dx[4] = {0, 1, 0, -1};
int d... |
403bf776ed61a83e6a0d114133180ad10a0e4fbc03a756327eebaf6dcb706bc4 | 1becaa9846d0fba4c342a1cdf3f33124b496e9689dab2854d4e34e5b4fdd3b85 | 0.020252 | cpp | 1becaa9846d0fba4c342a1cdf3f33124b496e9689dab2854d4e34e5b4fdd3b85 | 31964a716efa102cf0ae89f641554bec28614ab73b444a92fb97a2a8d6b324f0 | PIE_released_gem5_runtime | pie_37998 | p02996 | 4623b9b395a83710fec850913837c711da3fca77815b1a99d18ab9c7bf80f00b | 31964a716efa102cf0ae89f641554bec28614ab73b444a92fb97a2a8d6b324f0 | 0.454574 | 22.445855 | 8+ | 4d6778363fb27c325ded3e523038a831183cdef91c3f94140e464197d21f862a | #include <bits/stdc++.h>
using namespace std;
#define sz(a) int(a.size())
#define ll long long
#define ull unsigned long long
#define mod (ll)(1000000007)
#define endl '\n'
#define ENGZ \
ios::sync_with_stdio(0); ... | #include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
struct node {
int x, y;
} a[200008];
bool cmp(node q, node p) {
if (q.y == p.y)
return q.x < p.x;
else
return q.y < p.y;
}
int main() {
int n;
while (~scanf("%d", &n)) {
for (int i = 0; i < n; i++)
... |
f2a8cb6566d83bf4b6acb2264313baf0aa6f92f4d02855d646515567cf9b5a4c | 0c4034805e6c06331cbe11a71afd7e18d2644a401bf7b9938a556933db9a48c6 | 0.108545 | cpp | 0c4034805e6c06331cbe11a71afd7e18d2644a401bf7b9938a556933db9a48c6 | 8843c237474cd93f3d4827b80b9e47a9d0d5c7c0dfc1c0a9c3d7eb0b4432a081 | PIE_released_gem5_runtime | pie_38089 | p02815 | 26ff0c6f561becc957be8a2d1c4c2e48a8633e50d4923af81473f3dbac4f32b4 | 8843c237474cd93f3d4827b80b9e47a9d0d5c7c0dfc1c0a9c3d7eb0b4432a081 | 0.277082 | 2.552689 | 2-4 | 20706f0c9a098a3fbb1ec10b82863864ed5738bfd3aea6c6fd540c4e25dd3408 | #include <bits/stdc++.h>
#define debug1 cout << "?" << endl;
#define debug2 cout << "?" << i << endl;
#define PII pair<int, int>
typedef long long ll;
const int maxn = 2e5 + 9;
const double pi = acos(-1);
const int mod = 1e9 + 7;
const int INF = 1e9;
const double ep = 1e-7;
using namespace std;
ll kpow(ll a,... | #include <bits/stdc++.h>
typedef long long ll;
const int maxn = 2e5 + 9;
const int mod = 1e9 + 7;
using namespace std;
ll kpow(ll a, ll b)
{
ll ans = 1;
while (b)
{
if (b & 1)
ans = (ans * a) % mod;
a = (a * a) % mod;
b >>= 1;
}
return ans;
}
int main()
{
ll n, i, a[maxn], ... |
0fbc4883edb18160a59beb3db99d862b55fb781ce770280dc200f20af076573b | 17eed0afa77d938e3dbf15ec6dfa158eb32486e118eeb18e4f7972eb0c812896 | 0.109294 | cpp | 17eed0afa77d938e3dbf15ec6dfa158eb32486e118eeb18e4f7972eb0c812896 | 2787feb951cae19bf0e8916c175dfd8a3f2e5c1b97b607f589b612d9994f349a | PIE_released_gem5_runtime | pie_38136 | p04035 | ea41eea09dc357cdc004c775fac809457f556bdfa167253304e23bf40d93c63a | 2787feb951cae19bf0e8916c175dfd8a3f2e5c1b97b607f589b612d9994f349a | 0.375929 | 3.439619 | 2-4 | 057f1ce54a14e04a26c26844dcc354f3e1db10bd2d23927d3c3809fd06ce5a98 | #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 inf 1000000007
#define pa pair<int, int>
#define ll long long
#define pal pair<ll, ll>
... | #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... |
01df1c270f6fde1fc663cc5afc3815abd8b4f254c8fdb3a6924a71327d374966 | 752ace1e4772f43ffea9e5c1b3b157eba22e4b75708d8c0c1c1f535a115e331c | 0.006881 | cpp | 752ace1e4772f43ffea9e5c1b3b157eba22e4b75708d8c0c1c1f535a115e331c | 47600a581139b36e7cc1cc944f3f69a14e9ae0cee6d56bb394b75354275f2c0e | PIE_released_gem5_runtime | pie_38353 | p03478 | 14b340dc57967dacb9ad842e9e13e72628b017d285f3718bd7e4451d0fcf02a9 | 47600a581139b36e7cc1cc944f3f69a14e9ae0cee6d56bb394b75354275f2c0e | 0.1298 | 18.863837 | 8+ | 0601ca95ed4ff1668e51fbee0a22b451ad623336a93d46748196ffd4575522c1 | #include <bits/stdc++.h>
using namespace std;
#define pb push_back
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep1(i, n) for (int i = 1; i <= n; i++)
#define mp make_pair
#define F first
#define S second
#define IOS ... | #include <stdio.h>
int main() {
int n, a, b, sum = 0;
scanf("%d %d %d", &n, &a, &b);
for (int i = 1; i <= n; i++) {
int c = 0, t = i;
for (int j = 0; j < 5; j++) {
c += t % 10;
t /= 10;
}
if (c >= a && c <= b) {
sum += i;
}
}
printf("%d", sum);
return 0;
} |
4b6ab41d141c2405299d600d3ce18dc5fb1baf8494d5ead423af0cbdd64d94a7 | 66d46c3abea59b00dddb9d896c158b9b50afb1275c56e8ed7d354ae10a9c3305 | 0.005942 | cpp | 66d46c3abea59b00dddb9d896c158b9b50afb1275c56e8ed7d354ae10a9c3305 | 0b48eb9ea580c32eca86916a01717a25aecf9974f35fdffa3b02714289fddd52 | PIE_released_gem5_runtime | pie_3838 | p03816 | 1ad871ed3691ba6a86d98f0b7c2c8a3324495816ff4d7978f256a755b6b59d6d | 0b48eb9ea580c32eca86916a01717a25aecf9974f35fdffa3b02714289fddd52 | 0.124312 | 20.922198 | 8+ | 035136b03fd8689c1b823c8f0bff76c0cb1e176d045a49961f6c95742ea76b68 | #include <bits/stdc++.h>
using namespace std;
int ar[1000000], cc[100050];
vector<pair<int, int> > gg[100050];
map<int, int> o;
int main()
{
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> ar[i];
cc[ar[i]]++;
}
sort(ar, ar + n);
long long h = 0, l = 0;
for (int i = 0; i < 10005... | #include <cstdio>
int n, ne, cur;
int a[100005];
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &cur);
if (!a[cur]) {
a[cur] = 1;
ne++;
}
}
int ans;
int pan = n - ne;
if (pan % 2 == 0)
ans = ne;
else
ans = ne - 1;
printf("%d", ans)... |
2dd14602cdafb867339bd4b84690e9629ddae4fd45c2866bc2632bdc9e2d6eec | d27e1076b784ad2317e5cbb357c5b8e10f5e1e14f8ad245a15be7d1a22b1e51d | 0.078287 | cpp | d27e1076b784ad2317e5cbb357c5b8e10f5e1e14f8ad245a15be7d1a22b1e51d | bdfbec90801e23a5bab0f432a085f87b7343a2727169f8369abb588ab60aff31 | PIE_released_gem5_runtime | pie_38449 | p03053 | 2ce3140419f3bec5dbefef2f5c8dc3127ecc13e67435270cd0d0abd67590299c | bdfbec90801e23a5bab0f432a085f87b7343a2727169f8369abb588ab60aff31 | 0.815625 | 10.4184 | 8+ | 2adf42432b58ea4a5b38724b39b165ed690a1f89a83ef2d11461b1d790fb5006 | #include <iostream>
#include <queue>
#include <cstring>
const int maxn = 1010;
using namespace std;
struct Node {
int x, y;
};
queue<Node> Q;
int a[maxn][maxn], d[maxn][maxn];
int vis[maxn][maxn];
int main() {
memset(vis, 0, sizeof(vis));
memset(d, 0, sizeof(d));
ios::sync_with_stdio(false);
cin... | #include <cstdio>
#include <queue>
#include <algorithm>
using namespace std;
char c[1001][1002];
int d[1000001];
int main() {
int n, m;
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++)
scanf("%s", c[i] + 1);
queue<int> q;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= m; j++)
... |
8d5c96192a8d568bbef0b93d3bef8a54a3d2f580c4c60beaa81848cb04251ab7 | 7c654e49432031ebae2b515010832c70b4b8280aef9aef6d398a16bf90b01ef4 | 0.002057 | cpp | 7c654e49432031ebae2b515010832c70b4b8280aef9aef6d398a16bf90b01ef4 | e12928255585f9b93dae18be34f931361c50d91ed07858bfea7cda66e37d819d | PIE_released_gem5_runtime | pie_38537 | p02552 | 5c048dc99bf7aafe50e8f3cf96fdfef13d2d09ca4798013c44e5ba72208060eb | e12928255585f9b93dae18be34f931361c50d91ed07858bfea7cda66e37d819d | 0.007215 | 3.507117 | 2-4 | 1151ff0e99e014bcb3e4f5c5f5009e2641a7e604d23019731aaebbd5b6ca6657 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
vector<ll> adj[100005];
ll vis[100005];
ll n, m;
void add(ll x, ll y) {
adj[x].push_back(y);
adj[y].push_back(x);
}
void solve() {
ll x;
cin >> x;
cout << 1 - x << endl;
}
int main() {
ll t;
t = 1;
whil... | #include <bits/stdc++.h>
using namespace std;
#define mod 1000000007
#define ll long long
ll bow(ll x, ll y) {
ll res = 1;
for (ll i = 1; i <= y; ++i) {
res = res * x % mod;
}
return res;
}
void solve() {
ll x;
cin >> x;
cout << 1 - x << endl;
}
int main() {
ios::sync_with_stdio(0);
... |
2601b5df940a365252420bba9ea57e92399d1081199334f6927d22658e88fa9e | a0a2e684cbab043b2589cf4bffe5ed0e8c84e1e169728047419c34de71e1bd5c | 0.097992 | cpp | a0a2e684cbab043b2589cf4bffe5ed0e8c84e1e169728047419c34de71e1bd5c | 73a73cfed367e6df8e4fd7a5bc9f1eb762b7630884cc72b09709bfe206d1edd9 | PIE_released_gem5_runtime | pie_38560 | p00762 | bcc75121817f746edde0ba2b03091c76258428e2a29cf487c9878f962a5e72d1 | 73a73cfed367e6df8e4fd7a5bc9f1eb762b7630884cc72b09709bfe206d1edd9 | 0.684838 | 6.988678 | 4-8 | 29c1f94ff75770d8a75aa6b14c2496af4211ec35f4d747dac9cb5cc9c638ced9 |
#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <cstdlib>
#include <algorithm>
#include <vector>
using namespace std;
#define out(v) cerr << #v << ": " << (v) << endl
#define SZ(v) ((int)(v).size())
const int maxint = -1u >> 1;
template <class T> bool get_max(T &a, const ... | #include <iostream>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <vector>
#include <algorithm>
using namespace std;
typedef long long int lint;
struct {
int nDice, tmp_score, last_score;
} mp[201][201] = {};
int opposide[7] = {0, 6, 5, 4, 3, 2, 1};
int right_side[7][7... |
1bb6b15431b8ce2037f9d2935153826d01c5d9a40ea58bdc66d41bcc5bdf308d | 05d331447f8236a0e9677394ffe9d482c67bcbf8862b9784fe2408646bba6692 | 0.006165 | cpp | 05d331447f8236a0e9677394ffe9d482c67bcbf8862b9784fe2408646bba6692 | f097c2ec355650a29e2bed7696b9f2c0fad9ccd7abcb7bd24dea55fa88bcd53e | PIE_released_gem5_runtime | pie_38667 | p01835 | 25e63a3f694a641ef799bdabcdc5cd6836d552943203d3a84c6439e530660f5b | f097c2ec355650a29e2bed7696b9f2c0fad9ccd7abcb7bd24dea55fa88bcd53e | 0.250452 | 40.62218 | 8+ | 2d76a61fe5487a678b724334c01d131d4807ab562623e28552533e819a55784c | #include <iostream>
#include <stdio.h>
#include <math.h>
#include <string.h>
#include <time.h>
#include <stdlib.h>
#include <string>
#include <bitset>
#include <vector>
#include <set>
#include <map>
#include <queue>
#include <algorithm>
#include <sstream>
#include <stack>
#include <iomanip>
using namesp... | #include <cstdio>
#include <algorithm>
using namespace std;
#define MAXN 200010
#define INF 1000000000
struct node
{
int l, r, mx, mn, tg;
} t[MAXN * 4];
int cnt, n, k, rt, tm, ans;
void Build(int &i, int l, int r)
{
if (i == 0)
i = ++cnt;
if (l == r)
{
t[i].l = t[i].r = t[i].mx = t[i].mn... |
152bd13195bf1aa0a38152b59129a0357b93e01a29002aa6823bdd4ccbeb1787 | b2bf1bd1327f045a423dab1b3ff377253e9234de5719b0e4bff5dcb4fdfe874a | 0.105407 | cpp | b2bf1bd1327f045a423dab1b3ff377253e9234de5719b0e4bff5dcb4fdfe874a | 5817c0e6137211ecfd49f6420ed925244f240aae227bd6a3f222516aff0e2496 | PIE_released_gem5_runtime | pie_38673 | p04052 | 5596a5fdc785fc9ebeaddc0599cc1460dc67d489987dc09faa468949850f829c | 5817c0e6137211ecfd49f6420ed925244f240aae227bd6a3f222516aff0e2496 | 0.319031 | 3.02665 | 2-4 | 335b326d3b49df5ea4ca28e0ba97c39d3371264f4f62406449369febf3c3866f | #include <iostream>
#include <sstream>
#include <iomanip>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cctype>
#include <cstring>
#include <vector>
#include <list>
#include <queue>
#include <deque>
#include <stack>
#include <map>
#include <set>
#include <algorithm>
#include <iterator>... | #include <bits/stdc++.h>
#define LL long long
using namespace std;
const int N = 5e5 + 10, M = 1e8 + 10;
int rd()
{
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-')
w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch =... |
1b921e82f0697a3cc6dd3ed1f100033d3456d4705a30e86ea22e8a5f79beea1e | 9534d8ba5462effc8a505f2b6323a3fad9d6b786ce745875c3a9e050ba844a17 | 0.124571 | cpp | 9534d8ba5462effc8a505f2b6323a3fad9d6b786ce745875c3a9e050ba844a17 | ed8a0713440e47cde336576be494f381bb1ed9c87371f3a26c4dc1a8d99ef4dc | PIE_released_gem5_runtime | pie_38701 | p00721 | be1558afb2872c80d2e281a3deae0cd632aba8cf69d1ee093cf2596b7fda1c6a | ed8a0713440e47cde336576be494f381bb1ed9c87371f3a26c4dc1a8d99ef4dc | 0.394338 | 3.16558 | 2-4 | 188984e9e26ba326710d0b2aefac68130eee4b419846f9e688cf62ae2aa8928d | #include <iostream>
#include <iomanip>
#include <vector>
#include <map>
#include <algorithm>
#include <string>
#include <cstring>
#include <queue>
#include <cctype>
using namespace std;
#define fr first
#define sc second
typedef pair<int, int> Pt;
typedef pair<Pt, int> P;
Pt ST, GL;
int h, w, c, used[20]... | #include <iostream>
#include <algorithm>
#include <queue>
#include <cstring>
using namespace std;
#define INF 1 << 29
typedef pair<int, int> Pi;
int h, w;
char mas[50][50];
int graph[11][11];
int min_cost[50][50];
Pi gomi[11];
int gomi_size, uoo;
int memo[12][1 << 11];
const int dy[] = {1, 0, 0, -1}, dx[]... |
db29a620297231cb49e82f9da25a22a774b8136226805c25585280daca23f05d | ce2b506328dd0f05910e00a1be5c1127158e6b6a905f27ae1c5370c7d9a9acb6 | 0.006868 | cpp | ce2b506328dd0f05910e00a1be5c1127158e6b6a905f27ae1c5370c7d9a9acb6 | 9840123f8cb2dcbcd292f51134d3207a2fd8f1df9d06c99be5455588cfdba0a9 | PIE_released_gem5_runtime | pie_38742 | p03647 | dea9ad3f4712e60e920ecdf7190ac95539c4fa110d3b92c1147b5bd64b4e79df | 9840123f8cb2dcbcd292f51134d3207a2fd8f1df9d06c99be5455588cfdba0a9 | 0.234807 | 34.190775 | 8+ | 178388708085c092f6811092c0fbbeee9fa99b322b47330259c66fb25dd67e9d | #include <stdio.h>
#include <string.h>
#include <algorithm>
#include <vector>
using namespace std;
vector<int> p[200010];
int main()
{
int n, m, i, j, k, x, y, flag = 0;
scanf("%d%d", &n, &m);
for (i = 0; i < m; i++)
{
scanf("%d%d", &x, &y);
p[x].push_back(y);
p[y].push_back(x);
}
... | #include <stdio.h>
#include <string.h>
#include <stdlib.h>
int cmp(const void *p, const void *q)
{
return (*(int *)p - *(int *)q);
}
int a[300000], b[300000], c[300000], d[300000];
int main()
{
int n, m, i, j, k, l, r, z;
scanf("%d%d", &n, &m);
for (k = j = i = 0; i < m; i++)
{
scanf("%d%d", ... |
dd3c094aae5749cc53d10f9a36cae74dfc95bcb1e28d96f672802531b875121f | 1e0cf4845bdce2a1ecdb9c1be4496652d2b081bbd0af9315f8cfbfb825a303cb | 0.105455 | cpp | 1e0cf4845bdce2a1ecdb9c1be4496652d2b081bbd0af9315f8cfbfb825a303cb | 452206e705b31402ccdf62639558f025dbc457c1de1f5e07932d8c6672aaa93e | PIE_released_gem5_runtime | pie_38781 | p01537 | 0e49294927fce4c4908c9373e4f5ef87145df6b53fd97e8336ff7ea6ece8f789 | 452206e705b31402ccdf62639558f025dbc457c1de1f5e07932d8c6672aaa93e | 0.743475 | 7.050182 | 4-8 | 03cd76db79aee9d4c4ba4144d56a37ad02d8134a0bb5e600a827ee9036fb80e0 | #define _CRT_SECURE_NO_WARNINGS
#include <iostream>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <string>
#include <vector>
#include <algorithm>
#include <cmath>
#include <sstream>
#include <utility>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vv... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define all(c) begin(c), end(c)
#define dump(x) cerr << __LINE__ << ":\t" #x " = " << x << endl
using ld = long double;
using P = complex<ld>;
using G = vector<P>;
const ld pi = acos(-1);
c... |
343738050b2b67e1f3a2b5d71345fce30ed6905e395be4a968912ae0918cba50 | 5b87f8ec4ad7bc12579d259a0c7914ef5c856ed18a14deaf388acbf73a93ea86 | 0.05549 | cpp | 5b87f8ec4ad7bc12579d259a0c7914ef5c856ed18a14deaf388acbf73a93ea86 | 147429faf0a8ecf74034fe19945c9b2b45ff1c94b27f8cdbd226826775460ec4 | PIE_released_gem5_runtime | pie_38783 | p01089 | 96931f486586b49e942e85505f0d3e03c949452b1ad94dc6f8aa7a0b2e71a270 | 147429faf0a8ecf74034fe19945c9b2b45ff1c94b27f8cdbd226826775460ec4 | 0.149977 | 2.702761 | 2-4 | 7e1a1d6f64af3e086ea7d2efc85ec50a9e00b13314de721b8d553a454d9ded64 | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
vector<vector<int> > A;
void Min(int &a, int b) { a = min(a, b); }
bool DP() {
sort(A.begin(), A.end());
A.erase(unique(A.begin(), A.end()), A.end());
int n = A.size();
for (int i = 0; i < n; i++)
for (int j = 0, used[10] = {}; j < A[i]... | #include <bits/stdc++.h>
#define INF 1e9
using namespace std;
vector<vector<int> > A;
typedef pair<short, short> P;
bool bfs() {
sort(A.begin(), A.end());
A.erase(unique(A.begin(), A.end()), A.end());
int n = A.size();
for (int i = 0; i < n; i++)
for (int j = 0, used[10] = {}; j < A[i].size(); j++... |
57eb41a312d2ddf593f20f5bcf25e8e3447d2e50caf33e31b6774dc88d6ebade | ea74b73c55846f4616421bc067193773e8a3a91895e399c2f1230b5002f22d81 | 0.000187 | cpp | ea74b73c55846f4616421bc067193773e8a3a91895e399c2f1230b5002f22d81 | af80bec633b0aab1dcd669c085e46da7983f617a023df5949d72fb9b0d5934fd | PIE_released_gem5_runtime | pie_38920 | p03673 | 46175438dd7e7d300893cd92b213071c202376d2027eb242c9f719a143b9b4c3 | af80bec633b0aab1dcd669c085e46da7983f617a023df5949d72fb9b0d5934fd | 0.001826 | 9.776865 | 8+ | 5e4da1f094fea79fd48c72a1709721fffde37e20ba06e1385e636d3cfc262c19 | #include <bits/stdc++.h>
#define INF 200001
using namespace std;
inline int read()
{
register int number_read = 0, if_ok_read = 1;
char ch_read = getchar();
while (ch_read < '0' || ch_read > '9')
{
if (ch_read == '-')
if_ok_read = -1;
ch_read = getchar();
}
while (ch_read >= '0' &&... | #include <cstdio>
int n, a[200010];
inline int read() {
register int ret = 0;
char c = getchar();
while (c < '0' || c > '9')
c = getchar();
while (c >= '0' && c <= '9')
ret = (ret << 1) + (ret << 3) + (c ^ 48), c = getchar();
return ret;
}
int main()
{
n = read();
for (register int i = 1... |
8ee0c7cd0cab8907238a2fad4f9aad9f031b3fda29b166b9b136dfacf3e5d2e4 | 5910224bd9a1f681dc8faca7882a5452eb85cd8fdc1edd7a53aa42de0567959e | 0.006575 | cpp | 5910224bd9a1f681dc8faca7882a5452eb85cd8fdc1edd7a53aa42de0567959e | 0f63ab51a531719ff5754708af4da44e15d1fbcbc7d3837f1a63767fbbdb3c9c | PIE_released_gem5_runtime | pie_39075 | p03295 | e1866dca6afcef9b391699729aaa946b103b3fc216f776816b3b2ac7476d164e | 0f63ab51a531719ff5754708af4da44e15d1fbcbc7d3837f1a63767fbbdb3c9c | 0.109545 | 16.662011 | 8+ | 12eeddc1ef070401c02a9cb98edc7b677f3a2be028f231b07b4daf766351ec16 | #include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> A, pair<int, int> B) {
if (A.second == B.second)
return A.first < B.first;
return A.second < B.second;
}
int main() {
int n, m;
vector<pair<int, int> > v(m);
scanf("%d %d", &n, &m);
for (int i = 0; i < m; i++) {
int a, ... | #include <stdio.h>
#include <algorithm>
using namespace std;
#define ll long long
#define INF 0x3f3f3f3f
struct po {
int a, b;
} f[100010];
bool cmp(po x, po y)
{
if (x.a == y.a)
return x.b < y.b;
return x.a < y.a;
}
int main()
{
int n, m, ans = 0, t = INF;
scanf("%d%d", &n, &m);
for (i... |
957a0b711b6677bee0d77f0bebf682366f22681c90108fd8ed15d35296269272 | 17c2e45db3544e9fb5570daf93c2979ca1fb48867bfd6e7b4f40d1de2317531f | 0.012713 | cpp | 17c2e45db3544e9fb5570daf93c2979ca1fb48867bfd6e7b4f40d1de2317531f | 871048cf077ddcea4a3a9f5ee9c535a0fde78b6a0ca75bb40c08d5031523c839 | PIE_released_gem5_runtime | pie_39108 | p00033 | 6df392cf097f44e27fdec6319520bf7e8e931a3b133b72a738560866f129ab73 | 871048cf077ddcea4a3a9f5ee9c535a0fde78b6a0ca75bb40c08d5031523c839 | 0.067179 | 5.284311 | 4-8 | 37eb8267f261fcc1bdf05578be926fd70657f99fd7b8ee6ea63cabaedee29e1d | #include <bits/stdc++.h>
using namespace std;
int a[20];
bool check(int x)
{
int pre = 0;
for (int i = 0; i < 10; i++)
if (x & (1 << i))
{
if (a[i] < pre)
return false;
pre = a[i];
}
return true;
}
bool dfs(int i, int x, int pre)
{
if (i == 10)
{
return check... | #include <cstdio>
int a, l1, l2, n;
bool f;
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++)
{
f = 0;
l1 = 0;
l2 = -1;
for (int j = 1; j <= 10; j++)
{
scanf("%d", &a);
if (!f && a < l2 && a < l1) {
printf("NO\n");
f = 1;
continue;
... |
0d37c5eb8482c6208e275bfac5f69951216d02bd1d4b7f5cea59cac3afc164c7 | 79c4726c2e9afdcafb4d325f5b3dfaa0f03d6cef162e13f01a995e110cee24ed | 0.012872 | cpp | 79c4726c2e9afdcafb4d325f5b3dfaa0f03d6cef162e13f01a995e110cee24ed | 8f99a2cace7b1d32840f31c38ff74da5d1f9c631c61fff90181b4fee25978c77 | PIE_released_gem5_runtime | pie_39115 | p03629 | 1a26fc375c876bb3c002b35704b7119bc9d841532cefc3087d78844fb05545f5 | 8f99a2cace7b1d32840f31c38ff74da5d1f9c631c61fff90181b4fee25978c77 | 0.341541 | 26.53448 | 8+ | 675d838ba65a6c69ca6350fecb899b7b1d3ee07b39401d073d3faf178c817404 | #include <bits/stdc++.h>
using namespace std;
typedef long long lint;
typedef long double louble;
template <typename T1, typename T2> inline T1 max(T1 a, T2 b) { return a < b ? b : a; }
template <typename T1, typename T2> inline T1 min(T1 a, T2 b) { return a < b ? a : b; }
namespace ae86
{
const int bufl = 1 <<... | #include <stdio.h>
#include <string.h>
#define N 200002
#define M 26
char s[N], a[N], f[N];
int head[M] = {0}, last[N][M], c[N], l;
int dfs(int p, int d)
{
int i, td = d + 1, tp;
a[d] = s[p], f[d] = 1;
for (i = 0; i < M; i++) {
if (d + c[tp = last[p][i]] < l) {
if (tp) {
if (td < l ... |
97c845d55b6769aac5fd13c5aee49c6cd5b8c21cbc11fbabbd5f471ceb8914ad | 6cacfcf3ea6bbc2c11941f9b22bd4fd69ebb9f5a20a7ef2e46d7ced5c214df3c | 0.011153 | cpp | 6cacfcf3ea6bbc2c11941f9b22bd4fd69ebb9f5a20a7ef2e46d7ced5c214df3c | 40456525b2aba5e4b09ab4a9f6b3429101f46674c164e85715c74b58f7a946f1 | PIE_released_gem5_runtime | pie_39135 | p03724 | 25d7bd54e411b13ce600fe696d0f11beaadb06d0f9ec53595b98e594bbc0dc89 | 40456525b2aba5e4b09ab4a9f6b3429101f46674c164e85715c74b58f7a946f1 | 0.089321 | 8.008584 | 8+ | 99e1d40095a4a8411cb30ca4fceaeb772943cde952c1cd82e40de996f13ea44e | #include <iostream>
#include <cstdio>
#include <algorithm>
using namespace std;
int main()
{
int n, m;
while (cin >> n >> m)
{
int a[100000] = {0};
int b[100000], c[100000];
for (int i = 0; i < m; i++)
{
cin >> b[i] >> c[i];
}
for (int i = 0; i < m; i++)
{
a... | #include <cstdio>
#include <algorithm>
#define MAXN 100006
using namespace std;
int n, m, u, v, du[MAXN];
int main()
{
scanf("%d%d", &n, &m);
for (int i = 1; i <= m; i++)
{
scanf("%d%d", &u, &v);
du[u]++;
du[v]++;
}
for (int i = 1; i <= n; i++)
if (du[i] % 2 == 1)
{
p... |
51c4bf55cd373d45e104276b86699028d7217f9a2ed701921345d06bd678ce2d | 9c6ea01d73779614337aa3a3c997955f713f1276f6ef6e008c6f3114ce4b708a | 0.017308 | cpp | 9c6ea01d73779614337aa3a3c997955f713f1276f6ef6e008c6f3114ce4b708a | 846a991885afaa2f9b0e6021de47955beaac43efa73308d44a9c3fe9cdf6f616 | PIE_released_gem5_runtime | pie_39164 | p03353 | a28cf468197d5d2b5003dd0858052f70a9ffff97b1e1a6edb6eb486be497fe00 | 846a991885afaa2f9b0e6021de47955beaac43efa73308d44a9c3fe9cdf6f616 | 0.230079 | 13.293204 | 8+ | 3b37c003b977d8bfc5e31c02ba839addbda138fc3b6b4d9d167909d0a20688e3 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<double, int> pdi;
const int N = 50005;
string str[N];
int main()
{
string a;
cin >> a;
int k, cnt = 0;
scanf("%d", &k);
int siz = a.size();
int mini;
for (int i = 0; i < siz; i++)
... | #include <cstdio>
#include <cstring>
using namespace std;
int N, K;
char sz[5000];
bool ok(int n, char a[], int lo) {
if (lo == 0)
return true;
for (int i = n; i < n + lo; i++) {
if (sz[i] != a[i - n])
return false;
}
return true;
}
void sou(char a[]) {
if (K == 0)
return;
char... |
e066de2bb8c89bffb973033238fe49147e39fd3b72d8218d7d0e5c24a4f013fd | a0064ca0ecd2f7b3f659eb9ea65637e48af0f10e5631bce9b3acfba7dcdd9bde | 0.014358 | cpp | a0064ca0ecd2f7b3f659eb9ea65637e48af0f10e5631bce9b3acfba7dcdd9bde | afb33c3c3738b3e44f579ef2196d08d7195b244cac8ebb02b62b901dd59ebb0c | PIE_released_gem5_runtime | pie_39225 | p03832 | 19e66c62122e2f257071372646b6a3c8ce94a902f347819a6555d498a0e43e96 | afb33c3c3738b3e44f579ef2196d08d7195b244cac8ebb02b62b901dd59ebb0c | 0.677689 | 47.198157 | 8+ | 110e6af11a01725835c19cb543507255a3f0a13407e106cacb79f8ff42c299f2 | #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 ... |
afb8839424fc9e97b7335ac7ee3e9f1555113935a217b22beb135c0587189c3d | 6cf9734f64eef9375e38b2e07efdd2af2c3f0b97382d75de009a7df350a2d52b | 0.041733 | cpp | 6cf9734f64eef9375e38b2e07efdd2af2c3f0b97382d75de009a7df350a2d52b | 186aea3353a1756a5bf244ff976a4de2123a52704dc7d8a668c7175e310ca7d1 | PIE_released_gem5_runtime | pie_39251 | p03328 | 5db52ba5354047f17cf8e5a8489fd509a44ff2f3398739fa9aa61d87fe8712b9 | 186aea3353a1756a5bf244ff976a4de2123a52704dc7d8a668c7175e310ca7d1 | 0.123961 | 2.970343 | 2-4 | f3a041a187aec40fac0de8b52a7ddb20b0925b6d7c939f802a5e86a28f55306d | #include <algorithm>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define fst first
#define snd second
using ll = long long;
using I = pair<int, int>;
int main() {
... | #include <algorithm>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <vector>
using namespace std;
#define fst first
#define snd second
using ll = long long;
using I = pair<int, int>;
int main() {
... |
b6abbe17745e7354d59ca82d02d12d3307bb6cfdf40b1db7b1359d0e833b1271 | 8674b4aaddd68d7851c44ae4cf47d5e8a4ce3f54738cf29199b53d20cb4e3e72 | 0.106614 | cpp | 8674b4aaddd68d7851c44ae4cf47d5e8a4ce3f54738cf29199b53d20cb4e3e72 | 5a91ce913e0e5e556f26712cd1680333b7cff1af403c4a75682bb4cb8a7a14b0 | PIE_released_gem5_runtime | pie_39287 | p02721 | f09cd4d0eff462f0b5b2aa208aa7da3c5eac023fd1477810e8b77c3870054617 | 5a91ce913e0e5e556f26712cd1680333b7cff1af403c4a75682bb4cb8a7a14b0 | 0.278006 | 2.607589 | 2-4 | 0d61d3db8571fba4f2e0022478d2e54c69896ae55be6840e43a9a952f6998a42 | #include <bits/stdc++.h>
#define INF 1000000000
#define LINF 1000000000000000000
#define MOD 1000000007
#define mod 1000007
#define INF63 1061109567
#define INF127 9187201950435737471
#define UINF 18446744073709551615
#define F first
#define S second
#define ll long long
#define N 200010
using namespace std... | #include <bits/stdc++.h>
#define INF 1000000000
#define LINF 1000000000000000000
#define MOD 1000000007
#define mod 1000007
#define INF63 1061109567
#define INF127 9187201950435737471
#define UINF 18446744073709551615
#define F first
#define S second
#define ll long long
#define N 200010
using namespace std... |
2494fdb34e98698feabe773239ccc1c1bda749996f89129b18d48cc2c3eb5f9d | 9ff7d82bc9ed3eec640bfb723d96a613af84f35b422643dec7f9298ae13137a2 | 0.044333 | cpp | 9ff7d82bc9ed3eec640bfb723d96a613af84f35b422643dec7f9298ae13137a2 | 80026560d9b615ceab65a49806a197e2e501a8ee35ce62422e668d7b99851702 | PIE_released_gem5_runtime | pie_39329 | p03621 | 413599eff861e71a29ba235d9a413e96fd70c2156dc4eae9385a6e27dba224cf | 80026560d9b615ceab65a49806a197e2e501a8ee35ce62422e668d7b99851702 | 0.19222 | 4.335778 | 4-8 | 2a48e2a5876527e709ba26c8ca794b4c4d00eec215060c480b874d9ed0f2788a | #include <cstdio>
#include <algorithm>
#include <cstring>
#include <cmath>
#include <vector>
using namespace std;
static_assert(sizeof(long) >= 8, "sizeof(long) >= 8");
constexpr int mod = 998244353;
long fac[100001], inv[100001];
int dp[10001];
int solve(int x, int y) {
dp[0] = 1;
for (int i = 1; i <= ... | #include <cstdio>
using namespace std;
static_assert(sizeof(long) >= 8, "sizeof(long) >= 8");
constexpr int mod = 998244353;
int fac[20001], inv[20001];
int dp[10001];
int solve(int x, int y) {
dp[0] = 1;
for (int i = 1; i <= x; i++)
for (int j = 1; j <= y; j++)
dp[j] = (dp[j] + (long)i * dp[j -... |
cbc981f997fa805783687983d5bf909ed85c8070e798c3cae603ef4946d1e03b | 232f3396961651198a36f6e2bc6256a7a4d5d9ad61faecae98a2aa9a2141eb3d | 0.105111 | cpp | 232f3396961651198a36f6e2bc6256a7a4d5d9ad61faecae98a2aa9a2141eb3d | 967ac30df58b1f75041c674494d392b192f690f56b5707bc8c015cf822304c6c | PIE_released_gem5_runtime | pie_39333 | p02570 | f9fb73c7cde11a473701273a185d2cb8ad3a935943d9c11c6a7b4bd77432ba36 | 967ac30df58b1f75041c674494d392b192f690f56b5707bc8c015cf822304c6c | 0.869183 | 8.269197 | 8+ | f4db937d1d78bac9eb787ad5189d5828819ea1132cf4af0063f22a30ab05e638 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
ll n, m;
vector<ll> vis(200006, 0);
vector<ll> ad[200006];
void add(ll x, ll y) {
ad[x].push_back(y);
ad[y].push_back(x);
}
void dfs(ll node) {
vis[node] = 1;
for (ll x : ad[node]) {
if (!vis[x])
dfs(x);... | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define endl "\n"
void solve() {
ll d, t, s;
cin >> d >> t >> s;
if (d <= t * s) {
cout << "Yes\n";
return;
}
cout << "No\n";
}
int main() {
ll t;
t = 1;
while (t--)
solve();
return 0;
} |
47c9db7ee6099b58cd73eca09cb6f0ed4387db8875363525f1afd1befc736f04 | 442c6180acb8190437d87c4c160246972f5a4524b8091f0cb2142d9ee659406e | 0.020818 | cpp | 442c6180acb8190437d87c4c160246972f5a4524b8091f0cb2142d9ee659406e | c2978c0f08185d5b9297351f9420865d45588c21fcad65589757ea2e30d4de07 | PIE_released_gem5_runtime | pie_39337 | p03022 | 662f11f3d89133e402d5627238a560e01ac066eee32222c485a1f4306a24b1c2 | c2978c0f08185d5b9297351f9420865d45588c21fcad65589757ea2e30d4de07 | 0.958425 | 46.038016 | 8+ | cad803703e5c21385dc205b7bda03fe26e408f110969b2c1b3fbf1108341dc27 | #include <cstdio>
const int MOD = 998244353;
const int INV2 = (MOD + 1) >> 1;
int add(int x, int y) { return (x + y >= MOD ? x + y - MOD : x + y); }
int sub(int x, int y) { return (x - y < 0 ? x - y + MOD : x - y); }
int mul(int x, int y) { return 1LL * x * y % MOD; }
int pow_mod(int b, int p) {
int ret = 1;
... | #include <cstdio>
#include <cstring>
#define retrun return
#define cpnst const
typedef long long ll;
cpnst ll mod = 998244353, inv2 = (mod + 1) >> 1;
ll qpow(ll x, ll k)
{
ll r = 1;
for (; k; k >>= 1, (x *= x) %= mod)
if (k & 1)
(r *= x) %= mod;
return r;
}
ll N, A[1111111];
void FWT(ll *x, int... |
48aba4d5fb94f4915b0735eac6cf485571728eb072dbf03cdcccfe9a0262399d | 1a8d77b14dc7b5c9d1ca5f283efe9569cd81fe71107e67cd57fafe7aeb881093 | 0.039226 | cpp | 1a8d77b14dc7b5c9d1ca5f283efe9569cd81fe71107e67cd57fafe7aeb881093 | 0696c0fcd568cdd897a179989c54d122e74ffa1a3a3babfc1067e459bc103407 | PIE_released_gem5_runtime | pie_3936 | p01360 | cf27842acb53314d77ba90d014352dc8ac8401f8be1f7881c95809c02d959400 | 0696c0fcd568cdd897a179989c54d122e74ffa1a3a3babfc1067e459bc103407 | 0.089812 | 2.289616 | 2-4 | c4f7e228b8709f5f37d60551ad9003f51a4630170e18c217a1ba8f88fb4bd9bf | #include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <map>
#define INF 100005
using namespace std;
int F[INF][2];
char str[INF];
int X[3] = {3, 1, 2};
int getnum(char c0, char c1)
{
return X[(c0 - 48) % 3] <= X[(c1 - 48) % 3];
}
int main()
{
int n, m, i, j;
while ... | #include "bits/stdc++.h"
using namespace std;
using ll = int64_t;
enum {
LEFT,
RIGHT
};
bool isOK(ll left_sq, ll right_sq) {
if (left_sq == -1 || right_sq == -1) {
return true;
}
ll l = (left_sq % 3 + 2) % 3;
ll r = (right_sq % 3 + 2) % 3;
return l <= r;
}
int main() {
string s;
whil... |
5fb1214eb9fd4fd24ee68c039cd733c21d49ebeec66470c41b8c2845d38204c7 | 93bf68eb8fe8db811508f9d699a4b70c8e6913b31b4a3aaf35ae49384916c9bb | 0.034605 | cpp | 93bf68eb8fe8db811508f9d699a4b70c8e6913b31b4a3aaf35ae49384916c9bb | 40f0cd69605b38990ae83d43ae37feae3bab372c01ea63203c72d2d87fa29944 | PIE_released_gem5_runtime | pie_39823 | p00930 | 56b76f6c9376578129b47ba7f059eeb803a36ad957dbb2c3e071310334674588 | 40f0cd69605b38990ae83d43ae37feae3bab372c01ea63203c72d2d87fa29944 | 0.538242 | 15.553818 | 8+ | b139f48899e872f35db1aa5b2ca06e69dbf5e2b22b2f141a271528b1b0ec06c7 | #include <stdio.h>
#include <string.h>
#define lson rt << 1
#define rson rt << 1 | 1
#define mid ((l + r) >> 1)
#define clr(a, b) memset(a, b, sizeof(a))
inline int min(int a, int b) { return a < b ? a : b; }
const int MAX_N = 300010;
struct SegTree {
int f, a, lazy;
} node[MAX_N << 2];
char s[MAX_N];
int... | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (i = 0; i < n; i++)
#define repl(i, n) for (i = 1; i <= n; i++)
#define sz(x) (int)x.size()
#define pb push_back
#define all(x) x.begin(), x.end()
#define uu first
#define vv second
#define mem(x, y) memset(x, y, sizeof(x))
#define un(x) x.er... |
fb7942da3c3a13199d74ce1a37b977b9cf402b199465614b7c93d0c496940908 | 74b1de8701f159d079c0ec450ea3f07557bdcd6fe3e9221710222b5e3010f70f | 0.015071 | cpp | 74b1de8701f159d079c0ec450ea3f07557bdcd6fe3e9221710222b5e3010f70f | d8c639af4faed750082a26c8fe3a33f263b1af4b8c220aa0df8cd4bdb7e16a17 | PIE_released_gem5_runtime | pie_399 | p03952 | 4c1e8212fce28ee0034d83a673382195abd0c71056ff46b7a5c71ee4d9d3b599 | d8c639af4faed750082a26c8fe3a33f263b1af4b8c220aa0df8cd4bdb7e16a17 | 0.080818 | 5.362554 | 4-8 | 0dbd834cbfe31909ffdd9bb6ddf7c0ad922f2d2ce8be247eac3d0ad80fad5152 | #include <iostream>
using namespace std;
int a[200005];
int main(int argc, char **argv) {
int n, m;
cin >> n >> m;
if (m == 1 || m == 2 * n - 1)
{
puts("No");
return 0;
}
puts("Yes");
a[n] = m;
a[n - 1] = m - 1;
a[n + 1] = m + 1;
int now = 0;
for (int i = 1; i < n * 2; i++)
... | #include <cstdio>
int N, X;
int main() {
scanf("%d%d", &N, &X);
if (X == 1 || X == 2 * N - 1)
return !puts("No");
puts("Yes");
if (N == 2)
return !puts("1\n2\n3");
if (X == 2) {
for (int i = 1; i <= N - 2; i++)
printf("%d\n", 4 + i);
printf("3\n2\n1\n4\n");
for (int i = ... |
038afa43bd5a50762c163b59c3d4cf65e94a18632124e4061da2f2a516b6ca89 | 090f9f9cb866972e6d1efc7ae07e74ca0346981bfa8968f4da0dd099cc18cf24 | 0.005173 | cpp | 090f9f9cb866972e6d1efc7ae07e74ca0346981bfa8968f4da0dd099cc18cf24 | dde2fef09ccca4829e782a8d9ad71046d2406dc16b99f66efbd15151a95c5a19 | PIE_released_gem5_runtime | pie_4048 | p03013 | 7b119d3b93c9e06c639c26af9bc2cf04eb0333c8e1380966e90ce066f7e99d07 | dde2fef09ccca4829e782a8d9ad71046d2406dc16b99f66efbd15151a95c5a19 | 0.25966 | 50.195962 | 8+ | 3d52e07c920ca2470df0cf38602347a2e1559e19a4ad44b8ffff4edbdde3ab13 | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll memo[1000002];
ll n;
map<ll, bool> s;
ll dp(ll x) {
if (x > n)
{
memo[x] = 0;
return 0;
}
if (s[x]) {
memo[x] = 0;
return 0;
}
ll to_add = 0;
if (x == n)
{
return 1;
}
if (memo[x] != -1)
... | #include <stdio.h>
long long mod = 1e9 + 7;
long long vis[100005], a[100005] = {1, 1, 2};
int main()
{
long long i, x, n, k;
scanf("%lld%lld", &n, &k);
for (i = 1; i <= k; i++)
{
scanf("%lld", &x);
vis[x] = 1;
}
if (vis[1])
a[1] = 0;
for (i = 2; i <= n; i++)
{
if (vis[i])
... |
b4b92b3ab7c804904d6ae2104875b46422629e4110b468205edf5e9bee130d53 | 09353040781e7cfd2ecd6a0a46770ab787415f2913f26169b44225f6207896c9 | 0.019946 | cpp | 09353040781e7cfd2ecd6a0a46770ab787415f2913f26169b44225f6207896c9 | c34d2d38005364ea22114dc8cec84560c4b36796e75687b5ec386e0f12b27707 | PIE_released_gem5_runtime | pie_40667 | p03325 | abea82f34fb2e97e55873911de8f64c3804be6c29a9228ac79bff147130db2d9 | c34d2d38005364ea22114dc8cec84560c4b36796e75687b5ec386e0f12b27707 | 0.097731 | 4.899674 | 4-8 | e22808e7f2b9adf643d1e7f8c367c794c7a2ca680624857efdbd136776bd62af | #include <cstdio>
#include <vector>
using namespace std;
int N, t;
vector<int> v;
int rec(int x, int cnt) {
if (x % 2 == 1)
return cnt;
return rec(x / 2, cnt + 1);
}
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &t);
if (t % 2 == 0)
v.push_back(t);... | #include <cstdio>
using namespace std;
int N, t, ans;
int main() {
int N;
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &t);
while (t % 2 == 0) {
t /= 2;
ans++;
}
}
printf("%d", ans);
} |
731f31568bce4f1a6b16f6b5d2cad694c601e55aa6e3892e0d13107856d535a7 | b5f1eeac201ab31ddfdeca292c826bff287a344133c04ff33d6f9624456801b5 | 0.069297 | cpp | b5f1eeac201ab31ddfdeca292c826bff287a344133c04ff33d6f9624456801b5 | b92cdbb7d22dae5cb8a32379c552733ee6ffa5ef0bd58e221b8db0e2c51d67e2 | PIE_released_gem5_runtime | pie_40703 | p02795 | 784c6d55292436464c0c9307fd044d973ddc9ac71aa8d42929b3d23e9ad6e0ed | b92cdbb7d22dae5cb8a32379c552733ee6ffa5ef0bd58e221b8db0e2c51d67e2 | 0.241677 | 3.487558 | 2-4 | 45ec34d0ca486e7d84038c0c80d316234fcf0c1e656cc50e9f780d3a4baf02d8 |
#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++)
... |
5af57a221fcfe57d934f998635067bbedd208755f50e1155908192959b7142e0 | 49e86957bd5764a8517e9a0769d3237703699bb54593b07fc91e1e188a7050e6 | 0.013307 | cpp | 49e86957bd5764a8517e9a0769d3237703699bb54593b07fc91e1e188a7050e6 | 61ae4016c3458ac2b120f6fde40408fcf085a6281956b96f224bde85147713c1 | PIE_released_gem5_runtime | pie_40772 | p03032 | b615d36d067027ce92aabc0530879ef0c9da98b359a927bb183ed9c302a9054a | 61ae4016c3458ac2b120f6fde40408fcf085a6281956b96f224bde85147713c1 | 0.831247 | 62.465727 | 8+ | 43160e38903958b047856c8b40b00a453baeb5d533a25ed5b049ab2520882d21 | #include <bits/stdc++.h>
using namespace std;
#define all(v) ((v).begin()), ((v).end())
#define ll long long
#define fastIO \
cout << fixed << setprecision(12), ios::sync_with_stdio(false), \
cin.tie(nullptr), cout.tie(nullptr)
do... | #include <cstdio>
#include <algorithm>
using std::min;
using std::max;
using std::sort;
#define MAXN 103
int main(void)
{
int N, K, R;
int a[MAXN], plate[MAXN];
scanf("%d%d", &N, &K);
int i, j, res = 0;
for (i = 0; i < N; i++)
{
scanf("%d", a + i);
}
R = min(N, K);
for (int A = 0; ... |
97c198803955589be52323d8f5e2fe26ca80987b53b9cd2954b65aa7e9e25e70 | c4c70d289dde34de6465cd890957ebba062d9f99f46cdae43358da5bd0f5d6ba | 0.019609 | cpp | c4c70d289dde34de6465cd890957ebba062d9f99f46cdae43358da5bd0f5d6ba | 81056477fa8ce32a8c10954dc0af10d5f3bdef1b3d9ef7879c8c611455a2f2a5 | PIE_released_gem5_runtime | pie_4078 | p02571 | 4406fc14d0ed74290c423cc346c0d11b53003e679e617c95d5973b351a2119f7 | 81056477fa8ce32a8c10954dc0af10d5f3bdef1b3d9ef7879c8c611455a2f2a5 | 0.103605 | 5.283489 | 4-8 | 274991ce237b96b7db122c01bc7faa722c258940e0b5351f20bb49ac7e111bcc | #include <cmath>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
int lt, ls, i, j, tt, ans = 0x7fffffff;
char s[1010], t[1010];
int main() {
scanf("%s%s", s + 1, t + 1);
ls = strlen(s + 1);
lt = strlen(t + 1);
for (i = 1; i <= ls... | #include <cstdio>
#include <cstring>
#define min(a, b) ((a) < (b) ? (a) : (b))
char s[1003], t[1003];
int lens, lent, ans = 1 << 30, sum;
int main() {
scanf("%s%s", s, t);
lens = strlen(s), lent = strlen(t);
for (int i = 0; i < lens - lent + 1; i++) {
sum = 0;
for (int j = 0; j < lent; j++)
... |
1027afc724c6b8a7ae3d1704e7a57fa4673750a49657398bb8f4f5427f279b69 | ae5dcbfcec598c960bc52f99216f87c04da7d1d0a044ee1bb307f90559196eba | 0.001022 | cpp | ae5dcbfcec598c960bc52f99216f87c04da7d1d0a044ee1bb307f90559196eba | 193aa7a71375f17db1a46973a65c083e97ba0614a62b48c25ccb61d8792121e2 | PIE_released_gem5_runtime | pie_40798 | p03356 | e74a5badbeb0f691b326d444c33a6586499b96f14c3bd004e8682749049b884d | 193aa7a71375f17db1a46973a65c083e97ba0614a62b48c25ccb61d8792121e2 | 0.002276 | 2.226449 | 2-4 | c373d187a023d3b7ee39728bcd9891a8080d360b9e45c86a230103b5faab1256 | #include <bits/stdc++.h>
#define INF 1000000000;
#define debug(x) cerr << #x << ": " << x << '\n';
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int MAX_N = (int)1e5;
template <size_t N>
class unionFindTree {
private:
int par[N];
int rank[N];
int united[N];
public:
union... | #include <bits/stdc++.h>
#define debug(x) cerr << #x << ": " << x << '\n';
using namespace std;
using ll = long long;
using P = pair<int, int>;
const int INF = (int)1e9;
#ifndef UNION_FIND_TREE
#define UNION_FIND_TREE
class UnionFindTree {
private:
int N;
unique_ptr<int[]> parent;
unique_ptr<int[]> ran... |
38356dda747b899aad4265c9deb8bce20d9d77132d38af7c576fa8eaaa2c7300 | 49a3831e68ddbbe32612c2f7546706876b00760f89e09d41ef0d51d0e1c5be57 | 0.021222 | cpp | 49a3831e68ddbbe32612c2f7546706876b00760f89e09d41ef0d51d0e1c5be57 | ee3869e8ea0a75c0a7cac873f004571ce22209108c492fc4b3fa62820b60557a | PIE_released_gem5_runtime | pie_40849 | p03735 | 9932b73619ed56acb1af066d3e0fd8a5d33decb62c561b1627f0ab8e8810bc44 | ee3869e8ea0a75c0a7cac873f004571ce22209108c492fc4b3fa62820b60557a | 0.346161 | 16.31143 | 8+ | 14c968697931c42018a2199c1bb3767806331526473b6ae19ea8d37ceb86d723 | #include <bits/stdc++.h>
using namespace std;
#define ll long long
#define REP(i, a, b) for (int i = (a), _end_ = (b); i <= _end_; i++)
#define DREP(i, a, b) for (int i = (a), _end_ = (b); i >= _end_; i--)
#define EREP(i, a) for (int i = start[(a)]; i; i = e[i].next)
template <class T> inline void chkmax(T &a, T ... | #include <cstdio>
#include <algorithm>
#include <cstdlib>
#include <ctime>
#define inf 1e18 + 2
using namespace std;
typedef unsigned long long ll;
inline ll rd()
{
ll x = 0, p = 1;
char a = getchar();
while ((a < 48 || a > 57) && a != '-')
a = getchar();
if (a == '-')
p = -p, a = getchar();... |
2687af3bc09bb8a61912b66b8a2609727e66c85c9d96ea5298ff0049f1cbd1ec | 95f634bec22725cd05630ebb2870883413e08b1e4d2fcc580b592ba746f6d7d2 | 0.10402 | cpp | 95f634bec22725cd05630ebb2870883413e08b1e4d2fcc580b592ba746f6d7d2 | f4d9672185334ad73fbe48d6c0ab8696f7b9226de48c637a6f8d090d46c2de4b | PIE_released_gem5_runtime | pie_40882 | p00965 | 1581764da2e65612db54d6fc69488ac73b8bab384e4d7d0707fbd5eaba64f23a | f4d9672185334ad73fbe48d6c0ab8696f7b9226de48c637a6f8d090d46c2de4b | 0.235631 | 2.265258 | 2-4 | 24eccdfc092780d3f78266489a3c1f87d13cf38ed1b766f22ba6c252cf718b02 | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2 * 1e5 + 100;
int a[maxn], b[maxn], s[maxn], sum[maxn], rr[maxn], ll[maxn];
int main()
{
int n, t, last, ans2 = 0, ans1 = 0;
scanf("%d", &n);
priority_queue<int, vector<int>, greater<int> > r;
priority_queue<int, vector<int>, less<int> > l... | #include <iostream>
#include <cstdio>
#include <algorithm>
#include <cstring>
#include <vector>
#include <queue>
#include <set>
using namespace std;
const int maxn = 200000 + 10;
struct Node {
int l, r;
bool operator<(const Node &b) const { return r == b.r && l > b.l || r < b.r; }
} P[maxn];
vector<int... |
d5e980ba26adf2afee5c3940a2374206ef953d0f3d41a80107793bae5727a255 | 84a49262fa2810a87ff51f92709554864d7ab466a4d27b85fe81be3ff3d8ad4e | 0.021795 | cpp | 84a49262fa2810a87ff51f92709554864d7ab466a4d27b85fe81be3ff3d8ad4e | 53c4650d865be809b47a146249ef366958a909a09447e2be74bcb9c511d4c477 | PIE_released_gem5_runtime | pie_40912 | p02784 | b2f5efa4e081402cae71669eff9f1c91d06b3ccb140cbef567aad360bc347112 | 53c4650d865be809b47a146249ef366958a909a09447e2be74bcb9c511d4c477 | 0.106861 | 4.902988 | 4-8 | 147e15a068f9d4c7ce19fb04455e3509a5caf92ba3086322164cace9b422d7ff | #include <bits/stdc++.h>
using namespace std;
int main()
{
map<int, bool> move_map;
bool yes = false;
int h, n;
cin >> h >> n;
for (int i = 0; i < n; i++) {
int a;
cin >> a;
h -= a;
}
if (h > 0) {
cout << "No";
} else {
cout << "Yes";
}
} | #include <stdio.h>
int main()
{
int i;
long long int H, N, sum = 0, arr[100000];
scanf("%lld %lld", &H, &N);
for (i = 0; i < N; i++)
{
scanf("%lld", &arr[i]);
sum = sum + arr[i];
}
if (sum >= H)
{
printf("Yes\n");
}
else if (sum < H)
{
printf("No\n");
}
return ... |
7e83bdd4251a1a163957b5a5c6bcc413b9b08dc27679dd0c8fe47a5514629d2e | 65d9abc885d6007820ffd08a83a5463f0bc4003782f117b79969c8d905b87c31 | 0.004826 | cpp | 65d9abc885d6007820ffd08a83a5463f0bc4003782f117b79969c8d905b87c31 | fed99e2703e6f25dff94002b43a47e0a5f13d00d9c043955f80a7e7665d4698a | PIE_released_gem5_runtime | pie_41253 | p00496 | 6636d67c2bc55e121774d9d11188f4634c9e641055840e0193f8f0e91b71eda4 | fed99e2703e6f25dff94002b43a47e0a5f13d00d9c043955f80a7e7665d4698a | 0.026124 | 5.41282 | 4-8 | 023026824fcf9129674ce213c2cfd0f60e392470aa13baf203a93e22f373f000 |
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <string>
#include <algorithm>
#include <vector>
#include <queue>
#include <stack>
#include <functional>
#include <iostream>
#include <map>
#include <set>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P>... | #include <stdio.h>
int max(int a, int b) { return a < b ? b : a; }
int n, t, s;
int dp[3005] = {}, a[3005], b[3005], ret = 0;
int main() {
scanf("%d%d%d", &n, &t, &s);
for (int i = 1; i <= n; i++)
scanf("%d%d", &a[i], &b[i]);
for (int i = 1; i <= n; i++) {
for (int j = t; j >= b[i]; j--) {
... |
0056d6efa871b8582e3bfd0436304934152eed642c5db9ea48c08285b79252ab | 1bfc50ee40ee63d21c418d801df9c816bfcb170755f97c21ecff2d55891d728e | 0.034947 | cpp | 1bfc50ee40ee63d21c418d801df9c816bfcb170755f97c21ecff2d55891d728e | 37cb19910d51c08f4c5c4657351b34d1ef38b7019453299831eb02cc43495bb1 | PIE_released_gem5_runtime | pie_41264 | p03790 | c33de5131d7922df1821f4c6f25e8a830c54c53f56d404a6d238834d55af2eb1 | 37cb19910d51c08f4c5c4657351b34d1ef38b7019453299831eb02cc43495bb1 | 0.112094 | 3.207552 | 2-4 | 0869a1f07d5c18658536f453b001a282d200c150b0259d6bf211da75f7dde5c1 | #include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;
const int MAXN = 200005;
int segsiz;
int mn[MAXN * 4];
int Query(int pos, int L = 1, int R = segsiz, int id = 1)
{
if (L == R)
return mn[id];
int ret = mn[id], mid = (L + R) / 2;
if (pos <= mid)
return min(ret, Que... | #include <bits/stdc++.h>
using namespace std;
const int Maxn = 100005;
struct node {
long long l, r, x, d;
node(long long l, long long r, long long x, long long d)
:
l(l), r(r), x(x), d(d) {}
node() { l = r = x = d = 0; }
bool operator<(const node &b) const { return l < b.l; }
};
int n, b... |
afb106540e2cb697fc666ff0d36b8d1682d9b643949f4fc50bd5750bd3d5168f | b01c1f092c8067d3fbde68e09d82136ae9f39d7a8ae09c6b9bb6020767ec762b | 0.022301 | cpp | b01c1f092c8067d3fbde68e09d82136ae9f39d7a8ae09c6b9bb6020767ec762b | 6d4d8f297a938117602ab8efb385410759792efc1f5762f0d7f463b85c196813 | PIE_released_gem5_runtime | pie_41298 | p02881 | 95f5a9b8847a987e83efcef3f9c249a3dabbe90a053e4e4807f5e8fbae9187e9 | 6d4d8f297a938117602ab8efb385410759792efc1f5762f0d7f463b85c196813 | 0.080573 | 3.612987 | 2-4 | af626cbf2c659f1fccdac87c5e7b20d0f06b7c2a8d669df879b3ea93bbac84fd | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <deque>
#include <set>
#include <stdlib.h>
#include ... | #include <stdio.h>
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits.h>
#include <map>
#include <math.h>
#include <queue>
#include <deque>
#include <set>
#include <stdlib.h>
#include ... |
7fb1c33a892eab370e650abfae78dd959740905683bdb12a9f9fa4a2af73a144 | 79eeed8338cb15e5659de56bc84039fd82dfb0a0171e2a8eb9138c270d77a06d | 0.107747 | cpp | 79eeed8338cb15e5659de56bc84039fd82dfb0a0171e2a8eb9138c270d77a06d | 7fa306dd631ad4f0c78b28e552ea440f66f2b5ec1aeb0a7995623d708e88a892 | PIE_released_gem5_runtime | pie_413 | p02893 | f304b2afe287a014f08d4c8401641c3a1f481587ce07076ad813cdf52c99934b | 7fa306dd631ad4f0c78b28e552ea440f66f2b5ec1aeb0a7995623d708e88a892 | 0.451918 | 4.194245 | 4-8 | b6a9d4db5694406f7c5b12c3382655dae62de2f00b376ec297dde8eb086b6b7d | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for(LL i = (l) ; i < (r); ++i)
#define incII(i, l, r) for(LL i = (l) ; i <= (r); ++i)
#define decID(i, l, r) for(LL i = (r) - 1; i >= (l); --i)
#define decII(i, l, r) ... | #include <bits/stdc++.h>
using namespace std;
typedef long long signed int LL;
typedef long long unsigned int LU;
#define incID(i, l, r) for(LL i = (l) ; i < (r); ++i)
#define incII(i, l, r) for(LL i = (l) ; i <= (r); ++i)
#define decID(i, l, r) for(LL i = (r) - 1; i >= (l); --i)
#define decII(i, l, r) ... |
5becbc2c69160878757b552c3e9d19e4780b5257f0707a5489c55688394ad3fc | 9c7530ebd72285df9c7e5122fd218efce302a3da1c01ce98516a647a2e529933 | 0.020087 | cpp | 9c7530ebd72285df9c7e5122fd218efce302a3da1c01ce98516a647a2e529933 | 133dff291b30370bc2beae3962f91509d9a073e43fe703cb7c0e0e0b21622eb8 | PIE_released_gem5_runtime | pie_4132 | p03953 | a0aed9a6ce7cc4e45b1da8c93ae49a7e9170d6a950b1e2cf81bcedba89d3def0 | 133dff291b30370bc2beae3962f91509d9a073e43fe703cb7c0e0e0b21622eb8 | 0.466554 | 23.227137 | 8+ | f80f69933c2f94171bf755013bf93c5f7fa0597607a662b550faabd1787868e6 | #include <bits/stdc++.h>
#define N 100005
#define int long long
using namespace std;
int n, m, x[N], a[N], p[N], s[N], cnt;
long long k;
int be[N], num[N], v[N];
vector<int> q[N];
void dfs(int x, int dep)
{
num[x] = dep;
v[x] = 1;
be[x] = cnt;
q[cnt].push_back(x);
if (!v[p[x]])
dfs(p[x], dep +... | #include <cstdio>
#include <algorithm>
#define int long long
const int N = 200003;
int x[N], ans[N], g[N], n, m, k, used[N], siz;
signed main() {
scanf("%lld", &n);
for (int i = 1; i <= n; i++)
scanf("%lld", x + i), g[i] = i;
for (int i = n; i; i--)
x[i] -= x[i - 1];
scanf("%lld%lld", &m, &k);
... |
5640b88015e9255daba83eb7c1a7512afcba1683ff13da06675b920d667e15aa | a730eb39d93e6dab7391e386c8c12ce282216eedd9ee4ed2bf67cf2f4b1a21a9 | 0.104782 | cpp | a730eb39d93e6dab7391e386c8c12ce282216eedd9ee4ed2bf67cf2f4b1a21a9 | 5212f1e4ce3a439c4c21da84e146df89aa797189590f9e06a6d62308ef300931 | PIE_released_gem5_runtime | pie_41334 | p03132 | 87f18e5efaa5a74d9257b3699a4938967a7705493652cdf2b8b76dada3f48acd | 5212f1e4ce3a439c4c21da84e146df89aa797189590f9e06a6d62308ef300931 | 0.997906 | 9.523658 | 8+ | 5b20e2eafee0e3273d8bb308ae2210846a4f3688a18a621b5fbeef819b82025c | #include <bits/stdc++.h>
const int N = 200010;
typedef long long ll;
ll dp[N][5];
int a[N];
void update(ll &a, ll b) {
if (a == -1 || a > b) {
a = b;
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
}
memset(dp, -1, sizeof(dp));
dp[0][0] =... | #include <bits/stdc++.h>
using namespace std;
#define inf 0x3f3f3f3f
typedef long long ll;
const int N = 2e5 + 5;
int n, a[N][3];
ll dp[N][5];
int main()
{
scanf("%d", &n);
for (int i = 1; i <= n; i++)
{
scanf("%d", &a[i][0]);
a[i][1] = a[i][0] % 2 == 0;
a[i][2] = a[i][0] == 0 ? 2 : a[i]... |
94d983ebbc014b5ea808228c56ffbb3b9a11ea73d08ea7d29e3fced0e3c32d9c | deb8f1714d253bb242e88ec55792149f2f7f1b81ffcaf764abf5aeb14a581126 | 0.000193 | cpp | deb8f1714d253bb242e88ec55792149f2f7f1b81ffcaf764abf5aeb14a581126 | fc8d05ed612c44554a3eaced372a942909f397a0fc3714176b0d1c332de5e42a | PIE_released_gem5_runtime | pie_41364 | p03848 | 738da6aa85b5c7a4422dbf2f75a19cc7a0d31c392d0e89be64ecf72687ac01de | fc8d05ed612c44554a3eaced372a942909f397a0fc3714176b0d1c332de5e42a | 0.00143 | 7.398062 | 4-8 | bc3cb649f6ac49129e6823e3b8eb0266ee4dfb60a9adf902a678820c1dca8a79 | #include <iostream>
#include <cmath>
#include <algorithm>
#include <cstdio>
#include <stack>
#include <queue>
#include <map>
#include <cstring>
using namespace std;
const int MAX = 1e5 + 10;
int a[MAX];
int p[MAX];
long long mod_exp(int b) {
long long res, t;
res = 1;
t = 2;
while (b) {
if ... | #include <cstdio>
#include <algorithm>
using namespace std;
int result(int a, int b, int m)
{
long long d = 1, t = a;
while (b)
{
if (b & 1)
d = (d * t) % m;
b /= 2;
t = (t * t) % m;
}
return d;
}
int a[100010];
int main()
{
int n;
while (scanf("%d", &n) != EOF)
{
... |
fe8fef4b25de1b458022aaf1013b3b3b2027a08962c2616ac85e750ae2aff3b0 | 4f4c2cc861f85a96abd1efe5773a0e9c8ec7be1213c3faadf971fc1322726f7d | 0.020793 | cpp | 4f4c2cc861f85a96abd1efe5773a0e9c8ec7be1213c3faadf971fc1322726f7d | a25b97f13241fae7822deaf82764fcf6c996f8dc5edac07aebc36696190b9458 | PIE_released_gem5_runtime | pie_41431 | p03736 | 5d8ac44386b539fb00a6d18628928936c7069e0535386b22a535ec7bb6b936b4 | a25b97f13241fae7822deaf82764fcf6c996f8dc5edac07aebc36696190b9458 | 1.471605 | 70.775286 | 8+ | 0c0b06fb43fb5e90d9cdc9a575052206379f41a3709578c1453e1e6e30ebab9b | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#define MAXN 200010
long long A[MAXN << 2], B[MAXN << 2], T[MAXN << 2];
inline void pushDown(int x) {
if (!T[x])
return;
A[x << 1] += T[x];
A[x << 1 | 1] += T[x];
B[x << 1] += T[x];
B[x << 1 | 1] += T[x];
T[x << 1] +=... | #include <cstdio>
#include <algorithm>
#include <cstring>
#define MN 200005
using namespace std;
typedef long long ll;
int n, q;
ll mk[MN << 2];
struct node {
ll mi[4];
friend node operator+(node x, node y) {
node z;
for (int i = 1; i <= 3; i++)
z.mi[i] = min(x.mi[i], y.mi[i]);
return... |
c32237e7a6e2efce18f315e207bee456bd6773c2005b9f000a3dd6ed61355598 | 054ea51aaa2a1fa77b6c648f32d7f9e81da41be973b398f5063a8ca80d21bdba | 0.111938 | cpp | 054ea51aaa2a1fa77b6c648f32d7f9e81da41be973b398f5063a8ca80d21bdba | ecb7f0c677dbf9aa82a3294c23a0d8334c4e8811cc2aa8167c0f03eedc82c1e2 | PIE_released_gem5_runtime | pie_41564 | p02702 | 147e402fed2aa90a77046dd89b1093db2bfb3fb7c2f174f72300a937fea69da6 | ecb7f0c677dbf9aa82a3294c23a0d8334c4e8811cc2aa8167c0f03eedc82c1e2 | 0.426868 | 3.813441 | 2-4 | 5528bb467ec37b0b5ebdfca7307449ab946518ecec358fd01f61bc82ab28e240 |
#include <bits/stdc++.h>
#define LL long long int
#define getcx getchar_unlocked
#define X first
#define Y second
#define PB push_back
#define MP make_pair
#define MAX 200005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL (LL(1e18))
#define rep(i, a, n) for (i = a; i < n; i++)
#define rev(i, a... |
#include <bits/stdc++.h>
#define LL long long int
#define getcx getchar_unlocked
#define X first
#define Y second
#define PB push_back
#define MP make_pair
#define MAX 200005
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL (LL(1e18))
#define rep(i, a, n) for (i = a; i < n; i++)
#define rev(i, a... |
73df96730361b795911d981181576eaaf4141f17537b0e535aefd3413ed0b531 | 1f574ed08bb7550e82c82b8ec93e57959c6e11f3d361a3713374b51e198d48eb | 0.000188 | cpp | 1f574ed08bb7550e82c82b8ec93e57959c6e11f3d361a3713374b51e198d48eb | 1e1695d57cfd19bae1ad3797be545ec73a313c7fa90327e1473a3b83bef9fd02 | PIE_released_gem5_runtime | pie_41615 | p03627 | bc97c2f8c33e3dd3b33f4c6b3eeb541dbdd1b0735c78b541bc87aeb03f1c2620 | 1e1695d57cfd19bae1ad3797be545ec73a313c7fa90327e1473a3b83bef9fd02 | 0.005197 | 27.677346 | 8+ | f77d5e9ec13f6856d4c2cc28107b65589a3761210430a15b352692326607ba6a | #include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;
int f[1000000];
int main() {
int n;
cin >> n;
memset(f, 0, sizeof(f));
for (int i = 1; i <= n; i++)
cin >> f[i];
sort(f + 1, f + 1 + n);
int flag = 0, max1 = 0, max2 = 0;
for (int i = n - 1; i >= 1; i--)
... | #include <cstdio>
#include <cstring>
#include <algorithm>
#define ll long long
#define N 100005
#define mod 1000000007
#define rep(i, j, k) for (ll i = j; i <= k; ++i)
#define per(i, j, k) for (ll i = j; i >= k; --i)
using namespace std;
inline ll read() {
char ch = getchar();
ll x = 0, f = 1;
while (c... |
bb1cda78b489f061092dbdbea2d714388d3b39732f6ed192a01056f9e788808f | 83a2e9a308259885c7fde8031c40cefbdb96c66d9461fa5834f8f803ff592e77 | 0.019877 | cpp | 83a2e9a308259885c7fde8031c40cefbdb96c66d9461fa5834f8f803ff592e77 | d5520f579c0cad3612afccbe1f2003695ea5672a4e0d88295b380bb9cd2022ad | PIE_released_gem5_runtime | pie_41691 | p03249 | 8d9c22da6f1dee098753768fd20734538b22ce90ef1e038f1748eab384d7a6ad | d5520f579c0cad3612afccbe1f2003695ea5672a4e0d88295b380bb9cd2022ad | 0.387386 | 19.489109 | 8+ | 329cfbe60e04028baff039c263f0bbd7e07db95fb75768cefc953c5122dddf47 |
#include <iostream>
#include <algorithm>
#include <math.h>
#include <string.h>
#include <cstdio>
#include <vector>
#include <set>
#include <cassert>
#include <cstdlib>
#include <complex>
#include <cctype>
#include <cmath>
#include <ctime>
#include <deque>
#include <queue>
#include <stack>
#include <ma... | #include <cstdio>
#include <algorithm>
#include <vector>
#define file(x) freopen(#x ".in", "r", stdin), freopen(#x ".out", "w", stdout)
const int N(1e5 + 10);
struct edge {
int x, y;
} e[N];
struct node {
long long d;
int id;
} a[N];
inline int operator<(const node &l, const node &r)
{
return l.d < r.d;... |
5f5ad34717762f76385731ed2e63dbdb8d49c7017e8b85e4f75e624792968cc3 | 3f1182c55f67974811910714275e70a56e8d9496f5056dac872d1382426a18b5 | 0.082558 | cpp | 3f1182c55f67974811910714275e70a56e8d9496f5056dac872d1382426a18b5 | 6c10c81673eb9c1e037893e247570420dbccc59cd23d5eec5d13d8e59f6f56e8 | PIE_released_gem5_runtime | pie_4176 | p02368 | ef9808bb6b7e22fd3b1c3ad87cb515605d320343d8426aed748823b24065a436 | 6c10c81673eb9c1e037893e247570420dbccc59cd23d5eec5d13d8e59f6f56e8 | 0.532911 | 6.455002 | 4-8 | cfdc5bfb86226bd24b790278050a73544d4cd49ae99b9629f9886f75d2fb5040 | #include <iostream>
#include <vector>
#include <algorithm>
#include <set>
#include <stack>
using namespace std;
vector<vector<int>> G1(100000), G2(100000);
vector<bool> visit1(100000, false), visit2(100000, false);
int timer = 0;
void dfs1(int u, vector<int> &prenum) {
visit1[u] = true;
for (int v : G1[u... | #include "bits/stdc++.h"
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF 1 << 30
#define LINF 1LL << 60
class SCC {
public:
ll V;
vector<vector<ll>> G;
vector<vector<ll>> rG;
vector<ll> group;
vector<ll> List;
vector<int> visited;
... |
2dec5bebfd78cce7e373077a666bdb94f9f811969b94bbd2141399f7e6b9dc64 | 94f6f2bd3cd065aef863331db5ba23f850babb5682f0ad3d2ac585422e0b5fec | 0.048868 | cpp | 94f6f2bd3cd065aef863331db5ba23f850babb5682f0ad3d2ac585422e0b5fec | 0725212cb42271a02af01bc0875f16829b4da41e6e1ce2051e4f4a08732b9a6f | PIE_released_gem5_runtime | pie_41785 | p03580 | b0b62c96cfeef03fe0c46fa0b83225084ea0218a80c9568314ba8f4d31e0393f | 0725212cb42271a02af01bc0875f16829b4da41e6e1ce2051e4f4a08732b9a6f | 0.146061 | 2.988871 | 2-4 | 53261e3d51c08db7ec7b7af9da915e66814efb6ac856dd2fed04d0fd51c43625 | #include <bits/stdc++.h>
using namespace std;
int main()
{
int N;
string S;
int dp[500005] = {};
int pos = -1;
cin >> N >> S;
for (int i = 2; i < N; i++) {
dp[i + 1] = dp[i];
if (S.substr(i - 2, 3) == "101") {
pos = i - 3;
for (int j = i - 2; j >= 0 && S[j] != '0'; j--) {
... | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using Pi = pair<int, int>;
using Pl = pair<ll, ll>;
using vint = vector<int>;
using vvint = vector<vint>;
using vvvint = vector<vvint>;
using vdouble = vector<double>;
using vvdouble = vector<vdouble>;
using vvvdouble = vector<vvdouble>;
usi... |
319f981c6c54efd3c9ae2433a79f40bcdeeb6a997bc831d8138338ba786af4d0 | 35285f727863a7441025cf4605d2d32546823e0075dd3b8dfb60eb33c6d87b78 | 0.101373 | cpp | 35285f727863a7441025cf4605d2d32546823e0075dd3b8dfb60eb33c6d87b78 | 7d60546b5b17600e80573fcf206980229ec02d38865dfb1d9a0f771cd0da0ab1 | PIE_released_gem5_runtime | pie_41794 | p03393 | 0161a877f31eb455ce15f0fc8f728d6b3f7fa5d656895d0db247f29f7356affa | 7d60546b5b17600e80573fcf206980229ec02d38865dfb1d9a0f771cd0da0ab1 | 0.655427 | 6.465472 | 4-8 | 57ce60b86c8f5fb86fc5e16f5bd260bb2ac5d134538faeeccde6029e4ebce74f | #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 <vector>
#include <algorithm>
#include <string>
#include <map>
#include <cmath>
#include <queue>
#include <numeric>
#include <climits>
#include <iterator>
#include <iomanip>
#include <stack>
#include <set>
#include <cstdio>
#include <bitset>
#include <functional>
#include <t... |
518657a839d977bac70ffb536151718fe867a459f60413ba131eda7e16a58629 | f447feeda8940a3a74d64b28ae18f69eae2176003e53a39f3a4e723029669fa9 | 0.006514 | cpp | f447feeda8940a3a74d64b28ae18f69eae2176003e53a39f3a4e723029669fa9 | 86c7e04c360fb5bb9c8e053a500182f7c08f9f00002a17d76c825aa3222c79e5 | PIE_released_gem5_runtime | pie_4180 | p00916 | 785dc23aa93d39828911fc456073af37502b4a3bd21f903314dc9b148786ffcf | 86c7e04c360fb5bb9c8e053a500182f7c08f9f00002a17d76c825aa3222c79e5 | 0.097943 | 15.035074 | 8+ | ae7be6eb18f519744c518e9f8fc7fd82b2c173f74a05243e9ebd9e416d6e04fc | #include <iostream>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <vector>
#include <map>
using namespace std;
#define N 207
vector<int> vx, vy;
map<int, int> hx, hy;
int dx[4] = {0, 0, 1, -1};
int dy[4] = {1, -1, 0, 0};
int vis[N][N];
int l[55], r... | #include <stdio.h>
#include <string.h>
#include <algorithm>
using namespace std;
const int MAXN = 60;
int n;
int l[MAXN], t[MAXN], r[MAXN], b[MAXN];
int x[MAXN * 2], w;
int y[MAXN * 2], h;
bool c[MAXN * 4][MAXN * 4];
int ans;
const int dx[] = {0, -1, 0, 1};
const int dy[] = {-1, 0, 1, 0};
void init()
{
... |
103d5fa1dc6e4d71f0bc924f2680bf6e31c1ca65df2e76bb030303fcef7f0794 | d55c721d3d6c1714336744d0b6b76fd602a925b04b6cc32ced6a04a2dbaa3d0d | 0.168988 | cpp | d55c721d3d6c1714336744d0b6b76fd602a925b04b6cc32ced6a04a2dbaa3d0d | 3041e8e2f8b865fae06d77692e2addd9a40bebd1729b46a411db683f74d1f585 | PIE_released_gem5_runtime | pie_4184 | p00474 | 934caa751f5652d4a06c19180d99759414fc2f215b9662adcfbe0fed6443c47c | 3041e8e2f8b865fae06d77692e2addd9a40bebd1729b46a411db683f74d1f585 | 0.411785 | 2.436767 | 2-4 | e5e41dbe0a6a1afe1d3dd2b9ffd763914312428a1335aa4b8fd9a2259ec2bdae | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PB push_back
#define INF (1LL << 61LL)
typedef pair<int, int> pii;
int N, L, a[100005], dx[] = {-1, 1};
vector<int> g[100005];
bool flg[100005];
int cal(int x) {
int res = L - a[x], temp = 0;
for (int i = 0; i < g[x].size(); ++i)... | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define PB push_back
#define INF (1LL << 61LL)
typedef pair<int, int> pii;
int N, L, a[100005], dx[] = {-1, 1};
bool flg[100005];
int cal(int x) {
int res = L - a[x], temp = 0;
for (int i = 0; i < 2; ++i) {
if (a[x] < a[x + dx[i]])
... |
a159adb39dfa77d9af7d24843b5cbd25c076bdbb953945b4ae355363e92a758a | 7d59268a451b463a713ea0fc16f5872117481cdc8145641ef18dfc1ff7bce5a1 | 0.104159 | cpp | 7d59268a451b463a713ea0fc16f5872117481cdc8145641ef18dfc1ff7bce5a1 | f85bca4b764e661188862ae2553c0f42f1ae9bf84f8fd899e9c72434dd3b94ee | PIE_released_gem5_runtime | pie_41890 | p03331 | 0e5460256747b196cb0c70bd66a9202229a405a49ebd1634e6423061c91dcb86 | f85bca4b764e661188862ae2553c0f42f1ae9bf84f8fd899e9c72434dd3b94ee | 0.661284 | 6.348769 | 4-8 | a168fad77352588deac1ec2ad7761ddae3f45ba901fd3537eccda20925705a73 | #include <iostream>
#include <climits>
#include <stack>
#include <queue>
#include <string>
#include <set>
#include <map>
#include <math.h>
#include <algorithm>
#include <vector>
#include <string.h>
#include <random>
#include <iomanip>
#include <limits>
using namespace std;
typedef long long ll;
typedef ... | #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... |
196752a249a4a0a2cfcd8370a6686bb70b76d217255d9e8e230703e6b98e6103 | d3c69683701f3569f8f8056fdccf69db6c3471d315c2bd3bc340ae6768a879f9 | 0.023183 | cpp | d3c69683701f3569f8f8056fdccf69db6c3471d315c2bd3bc340ae6768a879f9 | f654cedfda077c1479921d47bd2c2bbe4ccd4ccd58a34481d3375105d8382fac | PIE_released_gem5_runtime | pie_419 | p02964 | 91fff2f4f508dcedabb4cfd764cdf56dad1eaf61bbb92f7090afe557ab0e06e5 | f654cedfda077c1479921d47bd2c2bbe4ccd4ccd58a34481d3375105d8382fac | 0.168231 | 7.256666 | 4-8 | 0a7ca398cef000c3c8586fc0792cd1e4c4a0bd07334565937f7b67c50da585d7 | #include "bits/stdc++.h"
using namespace std;
#ifndef LOCAL
#define endl '\n'
#endif
#define fr(i, a, b) for (int i = a; i <= b; i++)
#define rf(i, a, b) for (int i = a; i >= b; i--)
#define pf push_front
#define pb push_back
#define eb emplace_back
#define fi first
#define se second
#define all(x) x.begin(... | #include <bits/stdc++.h>
using namespace std;
const int maxn = 2e5 + 7;
long long n, k, d;
int a[maxn], lst[maxn], to[maxn], zz[maxn], t, hs[maxn];
int main() {
scanf("%lld%lld", &n, &k);
for (int i = 1; i <= n; ++i)
scanf("%d", &a[i]);
for (int i = n; i; --i)
lst[a[i]] = i;
for (int i = n; i; ... |
b5f8e49d4618b6d603f0b451307f30815bf72d8006323f4577b5fef402c62fdf | 60eb03dae75b20de53b13399a62c8012548bad981adf95ed44289c313f5c44ba | 0.111301 | cpp | 60eb03dae75b20de53b13399a62c8012548bad981adf95ed44289c313f5c44ba | 0be2417adfe32d7b226856f6f3c27c37c171a56c0e6abf3b325d06e2479a6448 | PIE_released_gem5_runtime | pie_41913 | p01110 | 8c0e4220a9840782b5107bb7acb34b06abc3ac78958f8d9fac84aaafb2170dec | 0be2417adfe32d7b226856f6f3c27c37c171a56c0e6abf3b325d06e2479a6448 | 0.277432 | 2.492634 | 2-4 | cbb6d176ac778e338edfe3f8c9254a85cdd43f645802c31e1cd2389a30f08ac3 | #include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>
using namespace std;
long long l[10000], r[10000], x1, x2, y1, y2, m, n, t, p, d[10000], c[10000], a[300][300],
b[300][300], x, y;
int main()
{
while (1)
{
scanf("%lld%lld%lld%lld", &n, &m, &t, &p);
... |
#include <iostream>
#include <algorithm>
#include <cstdio>
#include <string>
#include <cstring>
#include <vector>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <utility>
#include <cmath>
#include <climits>
#include <deque>
#include <functional>
#define INF 0x7fffffff
#define... |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.