problem_id
stringlengths 6
6
| language
stringclasses 2
values | original_status
stringclasses 3
values | original_src
stringlengths 19
243k
| changed_src
stringlengths 19
243k
| change
stringclasses 3
values | i1
int64 0
8.44k
| i2
int64 0
8.44k
| j1
int64 0
8.44k
| j2
int64 0
8.44k
| error
stringclasses 270
values | stderr
stringlengths 0
226k
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long llong;
int n, k;
llong T[MAX];
int check(llong P) {
int i = 0;
for (int j = 0; j < k; j++) {
llong s = 0;
while (s + T[i] <= P) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int solve() {
llong left = 0;
llong right = 100000 * 10000;
llong mid;
while (right > left) {
mid = (left + right) / 2;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> T[i];
llong ans = solve();
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long llong;
int n, k;
llong T[MAX];
int check(llong P) {
int i = 0;
for (int j = 0; j < k; j++) {
llong s = 0;
while (s + T[i] <= P) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int solve() {
llong left = 0;
llong right = 100000 * 10000;
llong mid;
while (right - 1 > left) {
mid = (left + right) / 2;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> T[i];
llong ans = solve();
cout << ans << endl;
return 0;
}
|
replace
| 26 | 27 | 26 | 27 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long llong;
int n, k;
llong T[MAX];
int check(llong P) {
int i = 0;
for (int j = 0; j < k; j++) {
llong s = 0;
while (s + T[i] <= P) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int solve() {
llong left = 0;
llong right = 100000 * 10000;
llong mid;
while (right > left) {
mid = (left + right) / 2 + 0.5;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> T[i];
llong ans = solve();
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long llong;
int n, k;
llong T[MAX];
int check(llong P) {
int i = 0;
for (int j = 0; j < k; j++) {
llong s = 0;
while (s + T[i] <= P) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int solve() {
llong left = 0;
llong right = 100000 * 10000;
llong mid;
while (right - 1 > left) {
mid = (left + right) / 2;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> T[i];
llong ans = solve();
cout << ans << endl;
return 0;
}
|
replace
| 26 | 28 | 26 | 28 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
// ------ main ------ //
int n, k, w[100000];
bool check(long long value) {
long long v = 0;
int c = 0;
for (int i = 0; i < n; i++) {
if (c >= k) {
return false;
}
if (v + w[i] > value) {
v = 0;
c++;
i--;
} else {
v += w[i];
}
}
if (c > n) {
return false;
}
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> w[i];
}
long long l = 0;
long long r = (1LL << 60);
long long m;
while (r - l > 0) {
m = (l + r) / 2;
if (check(m) == true) {
r = m;
} else {
l = m;
}
}
cout << r << endl;
return 0;
}
|
#include <iostream>
using namespace std;
// ------ main ------ //
int n, k, w[100000];
bool check(long long value) {
long long v = 0;
int c = 0;
for (int i = 0; i < n; i++) {
if (c >= k) {
return false;
}
if (v + w[i] > value) {
v = 0;
c++;
i--;
} else {
v += w[i];
}
}
if (c > n) {
return false;
}
return true;
}
int main() {
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> w[i];
}
long long l = 0;
long long r = (1LL << 60);
long long m;
while (r - l > 1) {
m = (l + r) / 2;
if (check(m) == true) {
r = m;
} else {
l = m;
}
}
cout << r << endl;
return 0;
}
|
replace
| 46 | 47 | 46 | 47 |
TLE
| |
p02270
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int w[100000];
int n, k;
int count(long long P) {
int count = 0, i;
long long Pn;
for (i = k; i > 0; i--) {
Pn = P;
while (Pn - w[count] >= 0) {
Pn -= w[count];
count++;
if (count == n)
break;
}
}
return count;
}
int main() {
int i;
long long max = 0, right, left, mid;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> w[i];
if (max < w[i])
max = w[i];
}
max *= n / k + 1;
left = 0;
right = max + 1;
while (left < right) {
mid = (left + right) / 2;
if (count(mid) == n)
right = mid;
else {
if (count(mid + 1) == n) {
mid++;
break;
} else
left = mid + 1;
}
}
cout << mid << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int w[100000];
int n, k;
int count(long long P) {
int count = 0, i;
long long Pn;
for (i = k; i > 0; i--) {
Pn = P;
while (Pn - w[count] >= 0) {
Pn -= w[count];
count++;
if (count == n)
return count;
}
}
return count;
}
int main() {
int i;
long long max = 0, right, left, mid;
cin >> n >> k;
for (i = 0; i < n; i++) {
cin >> w[i];
if (max < w[i])
max = w[i];
}
max *= n / k + 1;
left = 0;
right = max + 1;
while (left < right) {
mid = (left + right) / 2;
if (count(mid) == n)
right = mid;
else {
if (count(mid + 1) == n) {
mid++;
break;
} else
left = mid + 1;
}
}
cout << mid << endl;
return 0;
}
|
replace
| 16 | 17 | 16 | 17 |
0
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <iostream>
using namespace std;
int P(long long p, long long T[], int n, int k) {
int i = 0, j;
long long s;
for (j = 0; j <= k - 1; j++) {
s = 0;
while (s + T[i] <= p) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
int i;
int n, k;
long long T[100000];
long long left = 0;
long long right = 100000 * 10000;
long long mid;
int v;
cin >> n;
cin >> k;
for (i = 0; i <= n - 1; i++)
cin >> T[i];
while (right - left > 1) {
mid = (right - left) / 2;
v = P(mid, T, n, k);
if (v >= n)
right = mid;
else
left = mid;
}
cout << right << endl;
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
int P(long long p, long long T[], int n, int k) {
int i = 0, j;
long long s;
for (j = 0; j <= k - 1; j++) {
s = 0;
while (s + T[i] <= p) {
s += T[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
int i;
int n, k;
long long T[100000];
long long left = 0;
long long right = 100000 * 10000;
long long mid;
int v;
cin >> n;
cin >> k;
for (i = 0; i <= n - 1; i++)
cin >> T[i];
while (right - left > 1) {
mid = (right + left) / 2;
v = P(mid, T, n, k);
if (v >= n)
right = mid;
else
left = mid;
}
cout << right << endl;
return 0;
}
|
replace
| 33 | 34 | 33 | 34 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int main() {
int n, k, w[100000], max = 1, sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> w[i];
if (max < w[i])
max = w[i];
sum += w[i];
}
int ave = sum / n;
int t;
// tは平均値と要素の最大値のうちの大きいほう
if (ave < max)
t = max;
else
t = ave;
int P = t;
while (1) {
// Pは許容量、numは必要なトラック数
int s = 0, num = 1;
for (int j = 0; j < n; j++) {
s += w[j];
// sが許容量を超えたらnumを増やし、sの初期値を積めなかった荷物にする
if (s > P) {
num++;
s = w[j];
}
}
// もしトラックの数が足りたら
if (num <= k) {
cout << P << endl;
break;
}
// 足りなければ
else {
P++;
}
}
}
|
#include <iostream>
using namespace std;
int main() {
int n, k, w[100000], max = 1, sum = 0;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> w[i];
if (max < w[i])
max = w[i];
sum += w[i];
}
int ave = sum / k;
int t;
// tは平均値と要素の最大値のうちの大きいほう
if (ave < max)
t = max;
else
t = ave;
int P = t;
while (1) {
// Pは許容量、numは必要なトラック数
int s = 0, num = 1;
for (int j = 0; j < n; j++) {
s += w[j];
// sが許容量を超えたらnumを増やし、sの初期値を積めなかった荷物にする
if (s > P) {
num++;
s = w[j];
}
}
// もしトラックの数が足りたら
if (num <= k) {
cout << P << endl;
break;
}
// 足りなければ
else {
P++;
}
}
}
|
replace
| 12 | 13 | 12 | 13 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
using namespace std;
int w[100000], n, k;
int cntp(int p) {
int cnt = 1, wgh = 0;
for (int i = 0; i < n;) {
if (wgh + w[i] <= p) {
wgh += w[i++];
} else {
if (wgh > 0)
cnt++;
else
return k + 1;
wgh = 0;
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; scanf("%d", w + i++))
;
int l = 0, r = 100000, m;
while (l < r) {
m = (l + r) / 2; // printf("%d %d %d %d\n",l,m,r,cntp(m));
if (cntp(m) > k)
l = m + 1;
else
r = m;
}
for (m -= 20;; m++) {
// printf("%d %d\n",m,cntp(m));
if (cntp(m) <= k)
break;
}
printf("%d\n", m);
return 0;
}
|
#include <cstdio>
using namespace std;
int w[100000], n, k;
int cntp(int p) {
int cnt = 1, wgh = 0;
for (int i = 0; i < n;) {
if (wgh + w[i] <= p) {
wgh += w[i++];
} else {
if (wgh > 0)
cnt++;
else
return k + 1;
wgh = 0;
}
}
return cnt;
}
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i < n; scanf("%d", w + i++))
;
int l = 0, r = 1000000000, m;
while (l < r) {
m = (l + r) / 2; // printf("%d %d %d %d\n",l,m,r,cntp(m));
if (cntp(m) > k)
l = m + 1;
else
r = m;
}
for (m -= 20;; m++) {
// printf("%d %d\n",m,cntp(m));
if (cntp(m) <= k)
break;
}
printf("%d\n", m);
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <tuple>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
int main() {
int n, k;
int total = 0;
vector<int> w;
cin >> n >> k;
REP(i, n) {
int x;
cin >> x;
w.push_back(x);
total += x;
}
int p = 1;
while (1) {
int num = 0;
int track[k];
REP(i, k) {
track[i] = 0;
while (num < n && i < k && track[i] + w[num] <= p) {
track[i] += w[num];
num++;
}
}
if (num == n)
break;
p++;
}
cout << p << endl;
return 0;
}
|
#include <bits/stdc++.h>
#include <tuple>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
int main() {
int n, k;
int total = 0;
vector<int> w;
cin >> n >> k;
REP(i, n) {
int x;
cin >> x;
w.push_back(x);
total += x;
}
int p = total / k;
while (1) {
int num = 0;
int track[k];
REP(i, k) {
track[i] = 0;
while (num < n && i < k && track[i] + w[num] <= p) {
track[i] += w[num];
num++;
}
}
if (num == n)
break;
p++;
}
cout << p << endl;
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int num_truck(const vector<int> &w, int P) {
int num = 1;
int p = P;
for (int i = 0; i < w.size(); i++) {
if (w[i] > P)
return -1; //??????????????´???
if (p >= w[i]) {
p -= w[i];
continue;
}
num++;
p = P - w[i];
}
return num;
}
int calc_P(const vector<int> &w, int k, int min, int max) {
int mid = (min + max) / 2;
int num = num_truck(w, mid);
if (num > k)
return calc_P(w, k, mid + 1, max);
if (num < k)
return calc_P(w, k, min, mid - 1);
if (num == num_truck(w, mid - 1))
return calc_P(w, k, min, mid - 1);
return mid;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> w(n);
for (auto &i : w)
cin >> i;
int min_p = *max_element(w.begin(), w.end());
int max_p = accumulate(w.begin(), w.end(), 0);
cout << calc_P(w, k, min_p, max_p) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
int num_truck(const vector<int> &w, int P) {
int num = 1;
int p = P;
for (int i = 0; i < w.size(); i++) {
if (w[i] > P)
return -1; //??????????????´???
if (p >= w[i]) {
p -= w[i];
continue;
}
num++;
p = P - w[i];
}
return num;
}
int calc_P(const vector<int> &w, int k, int min, int max) {
// cout << min << " " << max << endl;
if (min > max)
return min;
int mid = (min + max) / 2;
int num = num_truck(w, mid);
if (num > k)
return calc_P(w, k, mid + 1, max);
if (num < k)
return calc_P(w, k, min, mid - 1);
if (num == num_truck(w, mid - 1))
return calc_P(w, k, min, mid - 1);
return mid;
}
int main() {
int n, k;
cin >> n >> k;
vector<int> w(n);
for (auto &i : w)
cin >> i;
int min_p = *max_element(w.begin(), w.end());
int max_p = accumulate(w.begin(), w.end(), 0);
cout << calc_P(w, k, min_p, max_p) << endl;
return 0;
}
|
insert
| 22 | 22 | 22 | 25 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
#include <vector>
using namespace std;
static int f(const int *ws, int n, int P, int k) {
int v = 0;
int c = 0;
int ntrack = 0;
for (int i = 0; i < n; ++i) {
if (c > 0 && P > 0 && c + ws[i] > P) {
c = 0;
ntrack++;
}
if (ntrack == k) {
break;
}
if (c + ws[i] <= P) {
c += ws[i];
v++;
}
}
return v;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
// vector<int> ws(n);
int ws[100000];
int max = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &ws[i]);
max += ws[i];
}
int min = 1;
int mid = (min + max) / 2;
while (min <= max) {
if (f(ws, n, mid, k) >= n) {
max = mid;
} else { // v < n
min = mid + 1;
}
mid = (min + max) / 2;
}
printf("%d\n", max);
return 0;
}
|
#include <cstdio>
#include <vector>
using namespace std;
static int f(const int *ws, int n, int P, int k) {
int v = 0;
int c = 0;
int ntrack = 0;
for (int i = 0; i < n; ++i) {
if (c > 0 && P > 0 && c + ws[i] > P) {
c = 0;
ntrack++;
}
if (ntrack == k) {
break;
}
if (c + ws[i] <= P) {
c += ws[i];
v++;
}
}
return v;
}
int main() {
int n, k;
scanf("%d %d", &n, &k);
// vector<int> ws(n);
int ws[100000];
int max = 0;
for (int i = 0; i < n; ++i) {
scanf("%d", &ws[i]);
max += ws[i];
}
int min = 1;
int mid = (min + max) / 2;
while (min < max) {
if (f(ws, n, mid, k) >= n) {
max = mid;
} else { // v < n
min = mid + 1;
}
mid = (min + max) / 2;
}
printf("%d\n", max);
return 0;
}
|
replace
| 41 | 42 | 41 | 42 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long ll;
int n, k;
ll T[MAX];
int check(ll p) {
int i = 0;
for (int j = 0; j < k; ++j) {
ll s = 0;
while (s + T[i] <= p) {
s += T[i];
i++;
if (i == n)
return i;
}
}
return i;
}
int slove() {
ll left = 0;
ll right = 100000 * 10000;
while (left < right) {
ll mid = left + (right - left) / 2;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main(int argc, char const *argv[]) {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> T[i];
}
ll ans = slove();
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 100000
typedef long long ll;
int n, k;
ll T[MAX];
int check(ll p) {
int i = 0;
for (int j = 0; j < k; ++j) {
ll s = 0;
while (s + T[i] <= p) {
s += T[i];
i++;
if (i == n)
return i;
}
}
return i;
}
int slove() {
ll left = 0;
ll right = 100000 * 10000;
while (left + 1 < right) {
ll mid = left + (right - left) / 2;
int v = check(mid);
if (v >= n)
right = mid;
else
left = mid;
}
return right;
}
int main(int argc, char const *argv[]) {
cin >> n >> k;
for (int i = 0; i < n; ++i) {
cin >> T[i];
}
ll ans = slove();
cout << ans << endl;
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
TLE
| |
p02270
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int n, k;
int A[100010];
bool f(ll p) {
ll temp = p;
int x = 0;
for (int i = 0; i < k; i++) {
while (temp >= A[x]) {
temp -= A[x];
x++;
}
temp = p;
}
if (x >= n)
return true;
else
return false;
}
ll binary_find(ll left, ll right) {
ll mid;
while (left + 1 < right) {
mid = (left + right) / 2;
if (f(mid))
right = mid;
else
left = mid;
}
return right;
}
int main() {
ll p, sum;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
}
p = binary_find(0, sum);
cout << p << endl;
return 0;
}
|
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
int n, k;
ll A[100010];
bool f(ll p) {
ll temp = p;
int x = 0;
for (int i = 0; i < k; i++) {
while (temp >= A[x]) {
temp -= A[x];
x++;
}
temp = p;
}
if (x >= n)
return true;
else
return false;
}
ll binary_find(ll left, ll right) {
ll mid;
while (left + 1 < right) {
mid = (left + right) / 2;
if (f(mid))
right = mid;
else
left = mid;
}
return right;
}
int main() {
ll p, sum;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> A[i];
sum += A[i];
}
p = binary_find(0, sum);
cout << p << endl;
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
-11
| |
p02270
|
C++
|
Runtime Error
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define len(n) (int)n.length()
#define pb push_back
#define ll long long
#define make_pair mkp
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
#define dbg(n) cerr << "//" << #n << ":" << n << endl
typedef pair<ll, ll> LLARR;
#define INF 999999999
int w[100003];
int n, k;
ll check(ll p) {
ll ret = 0;
ll tmp = 0;
ll i = 0;
REP(j, k) {
ll s = 0;
while (s + w[i] <= p) {
s += w[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
REP(i, n) { cin >> w[i]; }
ll ma = 10000 * 100000;
ll l = 0;
ll r = ma;
ll mid = 0;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check(mid) >= n) {
r = mid;
} else {
l = mid;
}
}
clog << "hoge" << endl;
cout << r << endl;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define len(n) (int)n.length()
#define pb push_back
#define ll long long
#define make_pair mkp
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
#define dbg(n) cerr << "//" << #n << ":" << n << endl
typedef pair<ll, ll> LLARR;
#define INF 999999999
int w[100003];
int n, k;
ll check(ll p) {
ll ret = 0;
ll tmp = 0;
ll i = 0;
REP(j, k) {
ll s = 0;
while (s + w[i] <= p) {
s += w[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
REP(i, n) { cin >> w[i]; }
ll ma = 10000 * 100000;
ll l = 0;
ll r = ma;
ll mid = 0;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check(mid) >= n) {
r = mid;
} else {
l = mid;
}
}
cout << r << endl;
return 0;
}
|
delete
| 62 | 63 | 62 | 62 |
0
|
hoge
|
p02270
|
C++
|
Runtime Error
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define len(n) (int)n.length()
#define pb push_back
#define ll long long
#define make_pair mkp
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
#define dbg(n) cerr << "//" << #n << ":" << n << endl
typedef pair<ll, ll> LLARR;
#define INF 999999999
int w[100003];
int n, k;
ll check(ll p) {
ll ret = 0;
ll tmp = 0;
ll i = 0;
REP(j, k) {
ll s = 0;
while (s + w[i] <= p) {
s += w[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
REP(i, n) { cin >> w[i]; }
dbg("kita");
ll ma = 10000 * 100000;
ll l = 0;
ll r = ma;
ll mid = 0;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check(mid) >= n) {
r = mid;
} else {
l = mid;
}
}
cout << r << endl;
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <algorithm>
#include <bitset>
#include <cassert>
#include <fstream>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define len(n) (int)n.length()
#define pb push_back
#define ll long long
#define make_pair mkp
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define FOR(i, m, n) for (int i = m; i < n; i++)
#define ALL(v) (v).begin(), (v).end()
#define dbg(n) cerr << "//" << #n << ":" << n << endl
typedef pair<ll, ll> LLARR;
#define INF 999999999
int w[100003];
int n, k;
ll check(ll p) {
ll ret = 0;
ll tmp = 0;
ll i = 0;
REP(j, k) {
ll s = 0;
while (s + w[i] <= p) {
s += w[i];
i++;
if (i == n)
return n;
}
}
return i;
}
int main() {
ios::sync_with_stdio(false);
cin >> n >> k;
REP(i, n) { cin >> w[i]; }
ll ma = 10000 * 100000;
ll l = 0;
ll r = ma;
ll mid = 0;
while (l + 1 < r) {
mid = (l + r) / 2;
if (check(mid) >= n) {
r = mid;
} else {
l = mid;
}
}
cout << r << endl;
return 0;
}
|
replace
| 49 | 50 | 49 | 50 |
0
|
//"kita":kita
|
p02270
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
vector<int> Input(const int n) {
vector<int> W;
for (int i = 0; i < n; i++) {
int w;
cin >> w;
W.push_back(w);
}
return W;
}
bool IsAllLoaded(int P, vector<int> &W, int k) {
int TrackIndex = 0;
int CurrentSum = 0;
int i = 0;
for (i = 0; i < W.size(); i++) {
if (W[i] > P) {
return false;
}
if (CurrentSum + W[i] > P) {
TrackIndex++;
if (TrackIndex == k) {
return false;
}
CurrentSum = 0;
}
CurrentSum += W[i];
}
return true;
}
int Calc(vector<int> W, int k) {
int Sum = accumulate(W.begin(), W.end(), 0);
int Ave = Sum / W.size();
int e = Sum;
int s = Ave;
int m = (e + s) / 2;
// cout << s << ' ' << m << ' ' << e << endl;
while (IsAllLoaded(m, W, k) || !IsAllLoaded(m + 1, W, k)) {
if (IsAllLoaded(m, W, k) && IsAllLoaded(m + 1, W, k)) {
e = m;
m = (s + m) / 2;
} else if (!IsAllLoaded(m, W, k) && !IsAllLoaded(m + 1, W, k)) {
s = m;
m = (e + m) / 2;
}
// cout << s << ' ' << m << ' ' << e << endl;
}
return m + 1;
}
int main() {
int n, k; // n:???????????° k:?????????????????°
cin >> n >> k;
vector<int> W = Input(n);
int P = Calc(
W,
k); // P:??????????????????????????????????????????????????§????????????????°????
cout << P << endl;
return 0;
}
|
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
vector<int> Input(const int n) {
vector<int> W;
for (int i = 0; i < n; i++) {
int w;
cin >> w;
W.push_back(w);
}
return W;
}
bool IsAllLoaded(int P, vector<int> &W, int k) {
int TrackIndex = 0;
int CurrentSum = 0;
int i = 0;
for (i = 0; i < W.size(); i++) {
if (W[i] > P) {
return false;
}
if (CurrentSum + W[i] > P) {
TrackIndex++;
if (TrackIndex == k) {
return false;
}
CurrentSum = 0;
}
CurrentSum += W[i];
}
return true;
}
int Calc(vector<int> W, int k) {
int Sum = accumulate(W.begin(), W.end(), 0);
int Ave = Sum / W.size();
int e = Sum;
int s = Ave;
int m = (e + s) / 2;
// cout << s << ' ' << m << ' ' << e << endl;
while (IsAllLoaded(m, W, k) || !IsAllLoaded(m + 1, W, k)) {
if (IsAllLoaded(m, W, k) && IsAllLoaded(m + 1, W, k)) {
e = m;
m = (s + m) / 2;
if (s == e)
return m;
} else {
s = m;
m = (e + m) / 2;
}
// cout << s << ' ' << m << ' ' << e << endl;
}
return m + 1;
}
int main() {
int n, k; // n:???????????° k:?????????????????°
cin >> n >> k;
vector<int> W = Input(n);
int P = Calc(
W,
k); // P:??????????????????????????????????????????????????§????????????????°????
cout << P << endl;
return 0;
}
|
replace
| 47 | 48 | 47 | 50 |
TLE
| |
p02270
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <iostream>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int MAX = 100000;
int function(int P, int k, int w[], int m) {
int j = 0;
int c = 0;
int nk = 0;
int np = 0;
while (nk < k) {
for (int i = j; i < m; i++, c++) {
np += w[i];
if (np > P) {
np = 0;
j = i;
break;
}
}
nk++;
}
return c;
}
int binarySearch(int key, int k, int w[], int m) {
int left = 0;
int right = MAX * 10000;
int mid;
while (left + 1 < right) {
mid = (left + right) / 2;
if (function(mid, k, w, m) < key)
left = mid;
else
right = mid;
}
return right;
}
int main() {
int n, k;
cin >> n >> k;
int w[n];
REP(i, n)
cin >> w[i];
cout << binarySearch(n, k, w, n) << endl;
}
|
#include <algorithm>
#include <iostream>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int MAX = 100000;
int function(int P, int k, int w[], int m) {
int j = 0;
int c = 0;
int nk = 0;
int np = 0;
while (nk < k) {
for (int i = j; i < m; i++, c++) {
np += w[i];
if (np > P) {
np = 0;
j = i;
break;
}
if (i == m - 1)
return m;
}
nk++;
}
return c;
}
int binarySearch(int key, int k, int w[], int m) {
int left = 0;
int right = MAX * 10000;
int mid;
while (left + 1 < right) {
mid = (left + right) / 2;
if (function(mid, k, w, m) < key)
left = mid;
else
right = mid;
}
return right;
}
int main() {
int n, k;
cin >> n >> k;
int w[n];
REP(i, n)
cin >> w[i];
cout << binarySearch(n, k, w, n) << endl;
}
|
insert
| 21 | 21 | 21 | 23 |
TLE
| |
p02270
|
C++
|
Runtime Error
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); i--)
#define ll long long
#define ull unsigned long long
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int w[10003];
REP(i, n) { cin >> w[i]; }
int l = 0, r = 1e9 + 1;
while (abs(r - l) > 1) {
int p = (r + l) / 2;
int j = 0;
REP(i, k) {
int tmpp = 0;
while (tmpp + w[j] <= p) {
tmpp += w[j];
j++;
if (j == n)
break;
}
if (j == n)
break;
}
if (j == n)
r = p;
else
l = p;
}
cout << r << endl;
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <set>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (n); i++)
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define RFOR(i, a, b) for (int i = (a)-1; i >= (b); i--)
#define ll long long
#define ull unsigned long long
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
const int INF = 1e9;
const int MOD = 1e9 + 7;
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, k;
cin >> n >> k;
int w[100003];
REP(i, n) { cin >> w[i]; }
int l = 0, r = 1e9 + 1;
while (abs(r - l) > 1) {
int p = (r + l) / 2;
int j = 0;
REP(i, k) {
int tmpp = 0;
while (tmpp + w[j] <= p) {
tmpp += w[j];
j++;
if (j == n)
break;
}
if (j == n)
break;
}
if (j == n)
r = p;
else
l = p;
}
cout << r << endl;
return 0;
}
|
replace
| 31 | 32 | 31 | 32 |
0
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
bool can_make(vector<int> &A, int m, vector<vector<int>> dp, size_t i = 0) {
if (i == A.size())
return !m;
if (!m)
return (dp[m][i] = 1);
if (m < 0)
return false;
if (~dp[m][i])
return dp[m][i];
if (m >= A[i])
if (can_make(A, m - A[i], dp, i + 1))
return (dp[m][i] = 1);
return (dp[m][i] = can_make(A, m, dp, i + 1));
}
int main() {
size_t n;
scanf("%zu", &n);
vector<int> A(n);
for (size_t i = 0; i < n; ++i)
scanf("%d", &A[i]);
size_t q;
scanf("%zu", &q);
for (size_t i = 0; i < q; ++i) {
int m;
scanf("%d", &m);
vector<vector<int>> dp(m + 1, vector<int>(A.size(), -1));
printf("%s\n", can_make(A, m, dp) ? "yes" : "no");
}
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
bool can_make(vector<int> &A, int m, vector<vector<int>> &dp, size_t i = 0) {
if (i == A.size())
return !m;
if (!m)
return (dp[m][i] = 1);
if (m < 0)
return false;
if (~dp[m][i])
return dp[m][i];
if (m >= A[i])
if (can_make(A, m - A[i], dp, i + 1))
return (dp[m][i] = 1);
return (dp[m][i] = can_make(A, m, dp, i + 1));
}
int main() {
size_t n;
scanf("%zu", &n);
vector<int> A(n);
for (size_t i = 0; i < n; ++i)
scanf("%d", &A[i]);
size_t q;
scanf("%zu", &q);
for (size_t i = 0; i < q; ++i) {
int m;
scanf("%d", &m);
vector<vector<int>> dp(m + 1, vector<int>(A.size(), -1));
printf("%s\n", can_make(A, m, dp) ? "yes" : "no");
}
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int n, A[20], s[20], b[1000000], bc = 0, q, m;
bool rec(int i) {
if (i == n) {
int sum = 0;
for (int j = 0; j < n; ++j) {
// cout << s[j] << ",";
if (s[j])
sum += A[j];
}
b[bc] = sum;
++bc;
// cout << endl;
return 0;
}
rec(i + 1);
s[i] = 1;
rec(i + 1);
s[i] = 0;
}
void combi() {
for (int i = 0; i < n; ++i)
;
rec(0);
}
bool judge(int in) {
for (int i = 0; i < bc; ++i)
if (in == b[i])
return true;
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
combi();
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> m;
if (judge(m))
cout << "yes";
else
cout << "no";
cout << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int n, A[20], s[20], b[10000000], bc = 0, q, m;
bool rec(int i) {
if (i == n) {
int sum = 0;
for (int j = 0; j < n; ++j) {
// cout << s[j] << ",";
if (s[j])
sum += A[j];
}
b[bc] = sum;
++bc;
// cout << endl;
return 0;
}
rec(i + 1);
s[i] = 1;
rec(i + 1);
s[i] = 0;
}
void combi() {
for (int i = 0; i < n; ++i)
;
rec(0);
}
bool judge(int in) {
for (int i = 0; i < bc; ++i)
if (in == b[i])
return true;
return false;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
combi();
cin >> q;
for (int i = 0; i < q; ++i) {
cin >> m;
if (judge(m))
cout << "yes";
else
cout << "no";
cout << endl;
}
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
using namespace std;
bool isSumExist(vector<int> A, int pos, int digit) {
if (digit == 0) {
return (true);
}
if (pos >= A.size() || digit < 0) {
return (false);
}
return (isSumExist(A, pos + 1, digit - A[pos]) ||
isSumExist(A, pos + 1, digit));
}
void solve() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int m;
cin >> m;
if (isSumExist(A, 0, m)) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
}
int main() {
solve();
return (0);
}
|
#include <iostream>
#include <vector>
using namespace std;
bool isSumExist(vector<int> &A, int pos, int digit) {
if (digit == 0) {
return (true);
}
if (pos >= A.size() || digit < 0) {
return (false);
}
return (isSumExist(A, pos + 1, digit - A[pos]) ||
isSumExist(A, pos + 1, digit));
}
void solve() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
int q;
cin >> q;
for (int i = 0; i < q; ++i) {
int m;
cin >> m;
if (isSumExist(A, 0, m)) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
}
int main() {
solve();
return (0);
}
|
replace
| 5 | 6 | 5 | 6 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
#include <iostream>
#define N_MAX 20
#define M_MAX 2001
#define NIL -1
using namespace std;
int n;
int a[N_MAX], dp[N_MAX][M_MAX];
// can make m after a[i] or not
bool solve(int i, int m) {
if (dp[i][m] != NIL)
return dp[i][m];
if (m == 0) {
dp[i][m] = 1;
} else if (i >= n) {
dp[i][m] = 0;
} else if (solve(i + 1, m)) {
dp[i][m] = 1;
} else if (solve(i + 1, m - a[i])) {
dp[i][m] = 1;
} else {
dp[i][m] = 0;
}
return dp[i][m];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= M_MAX; j++) {
dp[i][j] = NIL;
}
}
for (int i = 0; i < n; i++)
cin >> a[i];
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (solve(0, x))
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
|
#include <iostream>
#define N_MAX 100
#define M_MAX 100000
#define NIL -1
using namespace std;
int n;
int a[N_MAX], dp[N_MAX][M_MAX];
// can make m after a[i] or not
bool solve(int i, int m) {
if (dp[i][m] != NIL)
return dp[i][m];
if (m == 0) {
dp[i][m] = 1;
} else if (i >= n) {
dp[i][m] = 0;
} else if (solve(i + 1, m)) {
dp[i][m] = 1;
} else if (solve(i + 1, m - a[i])) {
dp[i][m] = 1;
} else {
dp[i][m] = 0;
}
return dp[i][m];
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= M_MAX; j++) {
dp[i][j] = NIL;
}
}
for (int i = 0; i < n; i++)
cin >> a[i];
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int x;
cin >> x;
if (solve(0, x))
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
|
replace
| 2 | 4 | 2 | 4 |
0
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <climits>
#include <iostream>
#include <list> //???????????????????????????
#include <vector> //????????¢??????????????????
using namespace std;
bool solve(int i, int m, vector<int> A) {
if (m == 0) {
return true;
}
int n = A.size();
if (i >= n) {
return false;
}
bool res = solve(i + 1, m, A) || solve(i + 1, m - A[i], A);
return res;
}
int main(void) {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int q;
cin >> q;
vector<int> mi(q);
for (int i = 0; i < q; i++) {
cin >> mi[i];
}
for (int j = 0; j < q; j++) {
if (solve(0, mi[j], A)) {
cout << "yes" << endl;
} else
cout << "no" << endl;
}
}
|
#include <climits>
#include <iostream>
#include <list> //???????????????????????????
#include <vector> //????????¢??????????????????
using namespace std;
bool solve(int i, int m, vector<int> &A) {
if (m == 0) {
return true;
}
int n = A.size();
if (i >= n) {
return false;
}
bool res = solve(i + 1, m, A) || solve(i + 1, m - A[i], A);
return res;
}
int main(void) {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int q;
cin >> q;
vector<int> mi(q);
for (int i = 0; i < q; i++) {
cin >> mi[i];
}
for (int j = 0; j < q; j++) {
if (solve(0, mi[j], A)) {
cout << "yes" << endl;
} else
cout << "no" << endl;
}
}
|
replace
| 6 | 7 | 6 | 7 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
#include <stdio.h>
#define MAX 20
int A[MAX], n;
bool check(int i, int m) {
if (m == 0)
return 1;
if (i >= n)
return 0;
int res = check(i + 1, m) || check(i + 1, m - A[i]);
return res;
}
int main() {
int q, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", m);
if (check(0, m)) {
printf("yes\n");
} else {
printf("no\n");
}
}
}
|
#include <stdio.h>
#define MAX 20
int A[MAX], n;
bool check(int i, int m) {
if (m == 0)
return 1;
if (i >= n)
return 0;
int res = check(i + 1, m) || check(i + 1, m - A[i]);
return res;
}
int main() {
int q, m;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &m);
if (check(0, m)) {
printf("yes\n");
} else {
printf("no\n");
}
}
}
|
replace
| 22 | 23 | 22 | 23 |
-11
| |
p02271
|
C++
|
Runtime Error
|
// 枝刈り無し
#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
int n, q;
vector<int> A;
bool solve(int i, int m) {
if (m == 0)
return true;
return solve(i + 1, m) || solve(i + 1, m - A[i]);
}
int main() {
cin >> n;
A.resize(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
cin >> q;
for (int j = 0; j < q; ++j) {
int m;
cin >> m;
bool ans = solve(0, m);
if (ans)
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
// 枝刈り無し
#include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
int n, q;
vector<int> A;
bool solve(int i, int m) {
if (m == 0)
return true;
if (i >= n)
return false;
return solve(i + 1, m) || solve(i + 1, m - A[i]);
}
int main() {
cin >> n;
A.resize(n);
for (int i = 0; i < n; ++i) {
cin >> A[i];
}
cin >> q;
for (int j = 0; j < q; ++j) {
int m;
cin >> m;
bool ans = solve(0, m);
if (ans)
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
insert
| 18 | 18 | 18 | 20 |
-11
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
bool serach(std::vector<int>, int);
bool serach(std::vector<int>, int, int, int);
int main(int argc, char const *argv[]) {
int n, q;
int a, m;
std::vector<int> A;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> a;
A.push_back(a);
}
std::cin >> q;
for (int i = 0; i < q; ++i) {
std::cin >> m;
if (serach(A, m))
std::cout << "yes" << std::endl;
else
std::cout << "no" << std::endl;
}
return 0;
}
bool serach(std::vector<int> A, int m) {
for (int i = 0; i < A.size(); ++i) {
if (serach(A, 0, m, i))
return true;
}
return false;
}
bool serach(std::vector<int> A, int sum, int m, int I) {
sum += A[I];
if (sum == m) {
return true;
} else if (sum > m) {
return false;
} else {
A.erase(A.begin() + I);
for (int i = 0; i < A.size(); ++i) {
if (serach(A, sum, m, i))
return true;
}
return false;
}
}
|
#include <iostream>
#include <vector>
bool serach(std::vector<int>, int);
bool serach(std::vector<int>, int, int, int);
int main(int argc, char const *argv[]) {
int n, q;
int a, m;
std::vector<int> A;
std::cin >> n;
for (int i = 0; i < n; ++i) {
std::cin >> a;
A.push_back(a);
}
std::cin >> q;
for (int i = 0; i < q; ++i) {
std::cin >> m;
if (serach(A, m))
std::cout << "yes" << std::endl;
else
std::cout << "no" << std::endl;
}
return 0;
}
bool serach(std::vector<int> A, int m) {
for (int i = 0; i < A.size(); ++i) {
if (serach(A, 0, m, i))
return true;
}
return false;
}
bool serach(std::vector<int> A, int sum, int m, int I) {
sum += A[I];
if (sum == m) {
return true;
} else if (sum > m) {
return false;
} else {
for (int i = I + 1; i < A.size(); ++i) {
if (serach(A, sum, m, i))
return true;
}
return false;
}
}
|
replace
| 43 | 45 | 43 | 44 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 1000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 10000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02271
|
C++
|
Runtime Error
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 1000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 100000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <cstdio>
bool solve(int A[], int size, int index, int remain) {
bool a, b;
if (remain == 0) {
return true;
} else if (size <= index || remain < 0) {
return false;
} else {
a = solve(A, size, index + 1, remain);
b = solve(A, size, index + 1, remain - A[index]);
}
return a || b;
}
int main() {
int n, q, A[2000], M[2000];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int m;
scanf("%d", &m);
if (solve(A, q, 0, m)) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
|
#include <cstdio>
bool solve(int A[], int size, int index, int remain) {
bool a, b;
if (remain == 0) {
return true;
} else if (size <= index || remain < 0) {
return false;
} else {
a = solve(A, size, index + 1, remain);
b = solve(A, size, index + 1, remain - A[index]);
}
return a || b;
}
int main() {
int n, q, A[2000], M[2000];
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
scanf("%d", &q);
for (int i = 0; i < q; i++) {
int m;
scanf("%d", &m);
if (solve(A, n, 0, m)) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
|
replace
| 25 | 26 | 25 | 26 |
TLE
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <bits/stdc++.h>
#include <tuple>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
bool solve(vector<int> a, int target) {
int last = a[a.size() - 1];
if (last == target)
return true;
a.pop_back();
if (a.empty())
return false;
return (solve(a, target) || solve(a, target - last));
}
int main() {
int n, q, x;
vector<int> a;
scanf("%d", &n);
REP(i, n) {
scanf("%d", &x);
a.push_back(x);
}
scanf("%d", &q);
REP(i, q) {
scanf("%d", &x);
if (solve(a, x))
printf("yes\n");
else
printf("no\n");
}
return 0;
}
|
#include <bits/stdc++.h>
#include <tuple>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
#define square(x) (x) * (x)
#define cube(x) (x) * (x) * (x)
const int INF = 1e9;
using namespace std;
bool solve(vector<int> a, int target) {
int last = a[a.size() - 1];
if (last == target)
return true;
a.pop_back();
if (a.empty())
return false;
return (solve(a, target - last) || solve(a, target));
}
int main() {
int n, q, x;
vector<int> a;
scanf("%d", &n);
REP(i, n) {
scanf("%d", &x);
a.push_back(x);
}
scanf("%d", &q);
REP(i, q) {
scanf("%d", &x);
if (solve(a, x))
printf("yes\n");
else
printf("no\n");
}
return 0;
}
|
replace
| 19 | 20 | 19 | 20 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
bool a[2001] = {0};
int x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 2001; j >= 0; j--) {
if (a[j]) {
a[j + x] = true;
}
}
a[x] = true;
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> x;
if (a[x]) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
return 0;
}
|
#include <iostream>
#include <string>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, q;
bool a[2001] = {0};
int x;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> x;
for (int j = 2000; j >= 0; j--) {
if (a[j]) {
a[j + x] = true;
}
}
a[x] = true;
}
cin >> q;
for (int i = 0; i < q; i++) {
cin >> x;
if (a[x]) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
return 0;
}
|
replace
| 15 | 16 | 15 | 16 |
-6
|
*** stack smashing detected ***: terminated
|
p02271
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define rep(i, n) FOR(i, 0, n)
#define DEBUG(x) cout << #x << ": " << x << endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;
#include <map>
#include <queue>
#include <set>
typedef long long ll;
typedef unsigned long long ull;
const int MAX_N = 1000000;
int F[MAX_N];
int NS;
int NT;
int S[MAX_N];
int T[MAX_N];
bool flag;
int target;
void print(int F[], int N) {
rep(i, N) { cout << F[i] << " "; }
cout << endl;
}
void Judge(int A[], int F[], int N) {
int ret = 0;
rep(i, N) { ret += A[i] * F[i]; }
if (ret == target)
flag = true;
}
void rec(int A[], int F[], int N, int i) {
if (i == N) {
Judge(A, F, N);
return;
}
F[i] = 0;
rec(A, F, N, i + 1);
F[i] = 1;
rec(A, F, N, i + 1);
};
int main() {
cin >> NS;
rep(i, NS) { cin >> S[i]; }
cin >> NT;
rep(i, NT) { cin >> T[i]; }
rep(i, NT) {
flag = false;
target = T[i];
rec(S, F, NS, i);
cout << (flag ? "yes" : "no") << endl;
}
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define rep(i, n) FOR(i, 0, n)
#define DEBUG(x) cout << #x << ": " << x << endl
#define vint vector<int>
#define vdouble vector<double>
#define vstring vector<string>
using namespace std;
#include <map>
#include <queue>
#include <set>
typedef long long ll;
typedef unsigned long long ull;
const int MAX_N = 1000000;
int F[MAX_N];
int NS;
int NT;
int S[MAX_N];
int T[MAX_N];
bool flag;
int target;
void print(int F[], int N) {
rep(i, N) { cout << F[i] << " "; }
cout << endl;
}
void Judge(int A[], int F[], int N) {
int ret = 0;
rep(i, N) { ret += A[i] * F[i]; }
if (ret == target)
flag = true;
}
void rec(int A[], int F[], int N, int i) {
if (i == N) {
Judge(A, F, N);
return;
}
F[i] = 0;
rec(A, F, N, i + 1);
F[i] = 1;
rec(A, F, N, i + 1);
};
int main() {
cin >> NS;
rep(i, NS) { cin >> S[i]; }
cin >> NT;
rep(i, NT) { cin >> T[i]; }
rep(i, NT) {
flag = false;
target = T[i];
rec(S, F, NS, 0);
cout << (flag ? "yes" : "no") << endl;
}
}
|
replace
| 67 | 68 | 67 | 68 |
-11
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int n, A[30];
int solve(int i, int m) {
if (m == 0)
return 1;
if (i >= n)
return 0;
int res = solve(i + 1, m) || solve(i + 1, m - A[i]);
return res;
}
int main() {
int q;
int M[210];
cin >> n;
for (int i = 0; i < n; n++) {
cin >> A[i];
}
cin >> q;
for (int j = 0; j < q; j++) {
cin >> M[j];
}
for (int j = 0; j < q; j++) {
if (solve(0, M[j]))
cout << "yes" << endl;
else {
cout << "no" << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
int n, A[30];
int solve(int i, int m) {
if (m == 0)
return 1;
if (i >= n)
return 0;
int res = solve(i + 1, m) || solve(i + 1, m - A[i]);
return res;
}
int main() {
int q;
int M[210];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
cin >> q;
for (int j = 0; j < q; j++) {
cin >> M[j];
}
for (int j = 0; j < q; j++) {
if (solve(0, M[j]))
cout << "yes" << endl;
else {
cout << "no" << endl;
}
}
return 0;
}
|
replace
| 23 | 24 | 23 | 24 |
TLE
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
int data[20], n;
bool solve(int i, int m) {
if (i > n)
return false;
if (m - data[i] == 0)
return true;
if (solve(i + 1, m - data[i]))
return true;
if (solve(i + 1, m))
return true;
return false;
}
int main() {
for (; cin >> n, n;) {
for (int i = 0; i < n; i++)
cin >> data[i];
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int tmp;
cin >> tmp;
if (solve(0, tmp))
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
}
|
#include <iostream>
using namespace std;
int data[20], n;
bool solve(int i, int m) {
if (i > n)
return false;
if (m - data[i] == 0)
return true;
if (solve(i + 1, m - data[i]))
return true;
if (solve(i + 1, m))
return true;
return false;
}
int main() {
for (; cin >> n;) {
for (int i = 0; i < n; i++)
cin >> data[i];
int q;
cin >> q;
for (int i = 0; i < q; i++) {
int tmp;
cin >> tmp;
if (solve(0, tmp))
cout << "yes" << endl;
else
cout << "no" << endl;
}
}
}
|
replace
| 18 | 19 | 18 | 19 |
TLE
| |
p02271
|
C++
|
Time Limit Exceeded
|
#include <cstdint>
#include <vector>
using namespace std;
static bool aux(vector<uint32_t> vec, uint32_t index, int32_t val) {
if (val == 0)
return true;
if (vec.size() == index || (val < 0)) {
return false;
}
int32_t rem = val - vec[index];
return aux(vec, index + 1, rem) || aux(vec, index + 1, val);
}
bool exausitve_search_search(vector<uint32_t> vec, int32_t val) {
return aux(vec, 0, val);
}
#if !defined(TEST)
#include <iostream>
static vector<uint32_t> array;
int32_t main() {
uint32_t num;
cin >> num;
for (uint32_t i = 0; i < num; i++) {
uint32_t val;
cin >> val;
array.push_back(val);
}
cin >> num;
for (uint32_t i = 0; i < num; i++) {
uint32_t val;
cin >> val;
if (exausitve_search_search(array, val)) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
return 0;
}
#endif
|
#include <cstdint>
#include <vector>
using namespace std;
static bool aux(vector<uint32_t> &vec, uint32_t index, int32_t val) {
if (val == 0)
return true;
if (vec.size() == index || (val < 0)) {
return false;
}
int32_t rem = val - vec[index];
return aux(vec, index + 1, rem) || aux(vec, index + 1, val);
}
bool exausitve_search_search(vector<uint32_t> vec, int32_t val) {
return aux(vec, 0, val);
}
#if !defined(TEST)
#include <iostream>
static vector<uint32_t> array;
int32_t main() {
uint32_t num;
cin >> num;
for (uint32_t i = 0; i < num; i++) {
uint32_t val;
cin >> val;
array.push_back(val);
}
cin >> num;
for (uint32_t i = 0; i < num; i++) {
uint32_t val;
cin >> val;
if (exausitve_search_search(array, val)) {
cout << "yes" << endl;
} else {
cout << "no" << endl;
}
}
return 0;
}
#endif
|
replace
| 5 | 6 | 5 | 6 |
TLE
| |
p02271
|
C++
|
Runtime Error
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 1000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
// 全探索
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <stack>
using namespace std;
const int MAX_N = 20;
const int MAX_N_2 = 10000000;
const int MAX_Q = 200;
// 入力値を保持するバッファ
int input_buffer[MAX_N + 1];
// 組み合わせの管理用バッファ
int comb_buffer[MAX_N + 1];
// 組み合わせから求めた和を格納する配列
int pos = 0;
int add_buffer[MAX_N_2];
void combinations(int n, int r);
void comb_sub(int n, int r, int m);
void add_combination(int m);
int main(void) {
int n, q, Q[MAX_Q + 1];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &input_buffer[i]);
}
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d", &Q[i]);
}
for (int i = 0; i < n; i++) {
combinations(n, i);
}
for (int i = 0; i < q; i++) {
bool judge = false;
for (int j = 0; j < pos; j++) {
if (add_buffer[j] == Q[i]) {
judge = true;
break;
}
}
if (judge) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
// 組み合わせを生成する関数の入り口
void combinations(int n, int r) {
if (r > 0 && r <= MAX_N) {
comb_sub(n, r, 0);
}
}
// 組み合わせを生成する関数
// n : 選択する数値の範囲 ( 1〜 n )
// r : 選ぶ数値の個数
// m : 選んだ数値の個数
void comb_sub(int n, int r, int m) {
if (r == 0) {
// r が 0 になったので、組み合わせを一つ生成できた
add_combination(m);
} else if (n == r) {
for (int i = r; i > 0; i--) {
// n が r と等しくなったならば、残りの数字 (1 から r まで) を全て選択
comb_buffer[m++] = i;
}
add_combination(m);
} else {
// nを選ばない場合
// 残りの数字の中から r 個の数字を選びます。
comb_sub(n - 1, r, m);
// nを選ぶ場合
// 数字 n を comb_buffer に追加して、残りの数字の中から r - 1 個を選びます。
comb_buffer[m] = n;
comb_sub(n - 1, r - 1, m + 1);
}
return;
}
// 入力数値の和を求める
void add_combination(int m) {
// 配列の初期化
add_buffer[pos] = 0;
for (int i = 0; i < m; i++) {
// 入力された数列の和を順番に求める
add_buffer[pos] += input_buffer[comb_buffer[i] - 1];
}
// 要素を進める
pos++;
return;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02271
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int m, n, q, A[20];
int ans(int x, int y) {
if (x == 0)
return 0;
if (ans(x, y + 1) == 0 || ans(x - A[y], y + 1) == 0)
return 0;
else
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
cin >> q;
for (int i = 0; i < q; i++) {
cin >> m;
if (ans(m, 0) == 0)
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n, q, A[20];
int ans(int x, int y) {
if (x == 0)
return 0;
if (y >= n)
return 1;
if (ans(x, y + 1) == 0 || ans(x - A[y], y + 1) == 0)
return 0;
else
return 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
cin >> q;
for (int i = 0; i < q; i++) {
cin >> m;
if (ans(m, 0) == 0)
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
insert
| 6 | 6 | 6 | 8 |
-11
| |
p02271
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int n, a[21], num;
bool saiki(int i, int sum) {
if (sum == num)
return 1;
if (saiki(i + 1, a[i] + sum))
return 1;
if (saiki(i + 1, sum))
return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int q;
cin >> q;
while (q--) {
cin >> num;
if (saiki(0, 0))
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int n, a[21], num;
bool saiki(int i, int sum) {
if (sum == num)
return 1;
if (i == n)
return 0;
if (saiki(i + 1, a[i] + sum))
return 1;
if (saiki(i + 1, sum))
return 1;
return 0;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> a[i];
int q;
cin >> q;
while (q--) {
cin >> num;
if (saiki(0, 0))
cout << "yes" << endl;
else
cout << "no" << endl;
}
return 0;
}
|
insert
| 7 | 7 | 7 | 9 |
-11
| |
p02271
|
C++
|
Runtime Error
|
#include <cstdio>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
struct Node {
size_t v;
bool used[20];
char padding[4];
Node() : v(0) { memset(used, false, 20); }
};
static vector<int> FindPossibleValues(const size_t *A, int n, size_t size) {
vector<int> values(size + 1);
values[size] = 1;
queue<Node> q;
Node root;
q.push(root);
while (!q.empty()) {
const Node p = q.front();
q.pop();
for (int i = 0; i < n; ++i) {
if (p.used[i])
continue;
Node new_node;
new_node.v = p.v + A[i];
memcpy(new_node.used, p.used, static_cast<size_t>(n));
new_node.used[i] = true;
q.push(new_node);
values[new_node.v] = 1;
}
}
return values;
}
int main() {
int n;
size_t A[20];
scanf("%d", &n);
size_t sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%lu", &A[i]);
sum += A[i];
}
vector<int> values = FindPossibleValues(A, n, sum);
int q;
scanf("%d", &q);
size_t m = 0;
for (int i = 0; i < q; ++i) {
scanf("%lu", &m);
if (m < values.size() && values[m]) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
|
#include <cstdio>
#include <queue>
#include <string.h>
#include <vector>
using namespace std;
struct Node {
size_t v;
bool used[20];
char padding[4];
Node() : v(0) { memset(used, false, 20); }
};
static vector<int> FindPossibleValues(const size_t *A, int n, size_t size) {
vector<int> values(size + 1);
values[size] = 1;
queue<Node> q;
Node root;
q.push(root);
while (!q.empty()) {
const Node p = q.front();
q.pop();
for (int i = 0; i < n; ++i) {
if (p.used[i] || values[p.v + A[i]])
continue;
Node new_node;
new_node.v = p.v + A[i];
memcpy(new_node.used, p.used, static_cast<size_t>(n));
new_node.used[i] = true;
q.push(new_node);
values[new_node.v] = 1;
}
}
return values;
}
int main() {
int n;
size_t A[20];
scanf("%d", &n);
size_t sum = 0;
for (int i = 0; i < n; ++i) {
scanf("%lu", &A[i]);
sum += A[i];
}
vector<int> values = FindPossibleValues(A, n, sum);
int q;
scanf("%d", &q);
size_t m = 0;
for (int i = 0; i < q; ++i) {
scanf("%lu", &m);
if (m < values.size() && values[m]) {
printf("yes\n");
} else {
printf("no\n");
}
}
return 0;
}
|
replace
| 27 | 28 | 27 | 28 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define INFTY 2000000000
int count = 0;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = new int[n1 + 1];
int *R = new int[n2 + 1];
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
count++;
}
delete[] L;
delete[] R;
}
void mergeSort(int A[], int left, int right) {
if (left + 1 >= right)
return;
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
int main() {
int n;
cin >> n;
int A[10];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, 0, n);
for (int i = 0; i < n - 1; i++) {
cout << A[i] << ' ';
}
cout << A[n - 1] << endl;
cout << count << endl;
}
|
#include <iostream>
using namespace std;
#define INFTY 2000000000
int count = 0;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = new int[n1 + 1];
int *R = new int[n2 + 1];
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
count++;
}
delete[] L;
delete[] R;
}
void mergeSort(int A[], int left, int right) {
if (left + 1 >= right)
return;
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
int main() {
int n;
cin >> n;
int A[n];
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, 0, n);
for (int i = 0; i < n - 1; i++) {
cout << A[i] << ' ';
}
cout << A[n - 1] << endl;
cout << count << endl;
}
|
replace
| 44 | 45 | 44 | 45 |
0
| |
p02272
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <limits.h>
#include <vector>
using namespace std;
void merge(vector<int> &A, int left, int mid, int right, int &c) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> L(n1 + 1, 0);
vector<int> R(n2 + 1, 0);
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INT_MAX;
R[n2] = INT_MAX;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
c++;
} else {
A[k] = R[j++];
c++;
}
}
}
void mergeSort(vector<int> &A, int left, int right, int &c) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid, c);
mergeSort(A, mid, right, c);
merge(A, left, mid, right, c);
}
}
int main() {
int count = 0;
int n = 0;
cin >> n;
vector<int> array(n, 0);
for (int i = 0; i < n; i++)
cin >> array[i];
mergeSort(array, 0, array.size(), count);
for (int n : array)
cout << n << ' ';
cout << endl;
cout << count << endl;
return 0;
}
|
#include <iostream>
#include <limits.h>
#include <vector>
using namespace std;
void merge(vector<int> &A, int left, int mid, int right, int &c) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> L(n1 + 1, 0);
vector<int> R(n2 + 1, 0);
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INT_MAX;
R[n2] = INT_MAX;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
c++;
} else {
A[k] = R[j++];
c++;
}
}
}
void mergeSort(vector<int> &A, int left, int right, int &c) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid, c);
mergeSort(A, mid, right, c);
merge(A, left, mid, right, c);
}
}
int main() {
int count = 0;
int n = 0;
cin >> n;
vector<int> array(n, 0);
for (int i = 0; i < n; i++)
cin >> array[i];
mergeSort(array, 0, array.size(), count);
for (int i = 0; i < array.size(); i++) {
if (i != array.size() - 1) {
cout << array[i] << ' ';
} else
cout << array[i] << endl;
}
cout << count << endl;
return 0;
}
|
replace
| 49 | 52 | 49 | 55 |
TLE
| |
p02272
|
C++
|
Runtime Error
|
#include <stdio.h>
#define SENTINEL 1000000001
int count = 0;
void trace(int a[], int size) {
for (int i = 0; i < size; ++i) {
if (i > 0) {
printf(" ");
}
printf("%d", a[i]);
}
printf("\n");
}
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int m = 0;
int n = 0;
for (int i = left; i < right; ++i) {
if (L[m] <= R[n]) {
A[i] = L[m];
++m;
} else {
A[i] = R[n];
++n;
}
count++;
}
}
void MergeSort(int A[], int left, int right) {
if (left >= right - 1)
return;
int mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
int main() {
int N;
int A[100];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
MergeSort(A, 0, N);
trace(A, N);
printf("%d\n", count);
return 0;
}
|
#include <stdio.h>
#define SENTINEL 1000000001
int count = 0;
void trace(int a[], int size) {
for (int i = 0; i < size; ++i) {
if (i > 0) {
printf(" ");
}
printf("%d", a[i]);
}
printf("\n");
}
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[n1], R[n2];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int m = 0;
int n = 0;
for (int i = left; i < right; ++i) {
if (L[m] <= R[n]) {
A[i] = L[m];
++m;
} else {
A[i] = R[n];
++n;
}
count++;
}
}
void MergeSort(int A[], int left, int right) {
if (left >= right - 1)
return;
int mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
int main() {
int N;
int A[500000];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", &A[i]);
}
MergeSort(A, 0, N);
trace(A, N);
printf("%d\n", count);
return 0;
}
|
replace
| 53 | 54 | 53 | 54 |
0
| |
p02272
|
C++
|
Memory Limit Exceeded
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
constexpr int MAX_N = 500'000;
constexpr int MAX_VAL = 1e9 + 1;
int merge(int *A, const int &left, const int &mid, const int &right) {
const int n1 = mid - left;
const int n2 = right - mid;
auto L = new int[n1 + 1];
auto R = new int[n2 + 1];
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = MAX_VAL;
R[n2] = MAX_VAL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
return right - left;
}
int mergeSort(int *A, const int &left, const int &right) {
int count = 0;
if (left + 1 < right) {
const int mid = (left + right) / 2;
count += mergeSort(A, left, mid);
count += mergeSort(A, mid, right);
return count + merge(A, left, mid, right);
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
int A[MAX_N];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int count = mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <string>
using namespace std;
constexpr int MAX_N = 500'000;
constexpr int MAX_VAL = 1e9 + 1;
int merge(int *A, const int &left, const int &mid, const int &right) {
const int n1 = mid - left;
const int n2 = right - mid;
auto L = new int[n1 + 1];
auto R = new int[n2 + 1];
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = MAX_VAL;
R[n2] = MAX_VAL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
delete[] L;
delete[] R;
return right - left;
}
int mergeSort(int *A, const int &left, const int &right) {
int count = 0;
if (left + 1 < right) {
const int mid = (left + right) / 2;
count += mergeSort(A, left, mid);
count += mergeSort(A, mid, right);
return count + merge(A, left, mid, right);
}
return 0;
}
int main() {
ios::sync_with_stdio(false);
int A[MAX_N];
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int count = mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i > 0) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
insert
| 37 | 37 | 37 | 39 |
MLE
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
#include <limits>
#define INFINITY 0xFFFFFF
void mergeSort(int *A, int left, int right);
using namespace std;
int ct = 0;
int main() {
int *S;
int n;
cin >> n;
S = new int[n];
for (int i = 0; i < n; ++i) {
cin >> S[i];
}
/*for (int i = 0; i < n; ++i) {
cout << S[i];
cout << " ";
}
cout << endl;
*/
mergeSort(S, 0, n);
for (int i = 0; i < n - 1; ++i) {
cout << S[i];
cout << " ";
}
cout << S[n - 1] << endl;
cout << ct << endl;
return 0;
}
void merge(int *A, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L;
int *R;
L = new int[n1 + 1];
R = new int[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1] = (int)INFINITY;
R[n2] = (int)INFINITY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i = i + 1;
ct++;
} else {
A[k] = R[j];
j = j + 1;
ct++;
}
}
delete[] L;
delete[] R;
}
void mergeSort(int *A, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
|
#include <iostream>
#include <limits>
#define INFINITY 0x7FFFFFFF
void mergeSort(int *A, int left, int right);
using namespace std;
int ct = 0;
int main() {
int *S;
int n;
cin >> n;
S = new int[n];
for (int i = 0; i < n; ++i) {
cin >> S[i];
}
/*for (int i = 0; i < n; ++i) {
cout << S[i];
cout << " ";
}
cout << endl;
*/
mergeSort(S, 0, n);
for (int i = 0; i < n - 1; ++i) {
cout << S[i];
cout << " ";
}
cout << S[n - 1] << endl;
cout << ct << endl;
return 0;
}
void merge(int *A, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L;
int *R;
L = new int[n1 + 1];
R = new int[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = A[mid + i];
}
L[n1] = (int)INFINITY;
R[n2] = (int)INFINITY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i = i + 1;
ct++;
} else {
A[k] = R[j];
j = j + 1;
ct++;
}
}
delete[] L;
delete[] R;
}
void mergeSort(int *A, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 50000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main(int argc, char const *argv[]) {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main(int argc, char const *argv[]) {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
const int MAX = 50000;
const int SENTINEL = 2000000000;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n;
cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
}
|
#include <iostream>
using namespace std;
const int MAX = 500000;
const int SENTINEL = 2000000000;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n;
cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int num_comp = 0;
const int MAX = 500000;
int L[MAX / 2 + 2];
int R[MAX / 2 + 2];
const int SENTINEL = 200000000;
// Merge
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
num_comp++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
// Merge sort
void Mergesort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
Mergesort(A, left, mid);
Mergesort(A, mid, right);
Merge(A, left, mid, right);
}
}
// MAIN FUNCTION
int main(int argc, char **argv) {
// Input
int A[MAX];
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
// Merge sort
Mergesort(A, 0, n);
// Print all elements
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << num_comp << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int num_comp = 0;
const int MAX = 500000;
int L[MAX / 2 + 2];
int R[MAX / 2 + 2];
const int SENTINEL = 2000000000;
// Merge
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
num_comp++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
// Merge sort
void Mergesort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
Mergesort(A, left, mid);
Mergesort(A, mid, right);
Merge(A, left, mid, right);
}
}
// MAIN FUNCTION
int main(int argc, char **argv) {
// Input
int A[MAX];
int n;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
// Merge sort
Mergesort(A, 0, n);
// Print all elements
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << num_comp << endl;
return 0;
}
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 500000
#define Sentinel 19970328
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
int i = 0, j = 0;
L[n1] = R[n2] = Sentinel;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergesort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (right + left) / 2;
mergesort(A, n, left, mid);
mergesort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergesort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define Sentinel 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
int i = 0, j = 0;
L[n1] = R[n2] = Sentinel;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergesort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (right + left) / 2;
mergesort(A, n, left, mid);
mergesort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergesort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 5000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int n, a[50105], m;
long long inf = 2e9;
void Merge(int left, int mid, int rigth) {
int n1 = mid - left, n2 = rigth - mid;
int l[n1], r[n2];
for (int i = 0; i < n1; i++) {
l[i] = a[left + i];
}
for (int i = 0; i < n2; i++) {
r[i] = a[mid + i];
}
l[n1] = inf;
r[n2] = inf;
int x = 0, y = 0;
for (int i = left; i < rigth; i++) {
if (l[x] > r[y]) {
a[i] = r[y];
y++;
} else {
a[i] = l[x];
x++;
}
m++;
}
}
void mergesort(int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
mergesort(l, mid);
mergesort(mid, r);
Merge(l, mid, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mergesort(0, n);
for (int i = 0; i < n; i++) {
cout << a[i];
if (i != n - 1)
printf(" ");
}
cout << endl;
cout << m << endl;
}
/*
*/
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500105], m;
long long inf = 2e9;
void Merge(int left, int mid, int rigth) {
int n1 = mid - left, n2 = rigth - mid;
int l[n1], r[n2];
for (int i = 0; i < n1; i++) {
l[i] = a[left + i];
}
for (int i = 0; i < n2; i++) {
r[i] = a[mid + i];
}
l[n1] = inf;
r[n2] = inf;
int x = 0, y = 0;
for (int i = left; i < rigth; i++) {
if (l[x] > r[y]) {
a[i] = r[y];
y++;
} else {
a[i] = l[x];
x++;
}
m++;
}
}
void mergesort(int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
mergesort(l, mid);
mergesort(mid, r);
Merge(l, mid, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mergesort(0, n);
for (int i = 0; i < n; i++) {
cout << a[i];
if (i != n - 1)
printf(" ");
}
cout << endl;
cout << m << endl;
}
/*
*/
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 50000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; i++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 17 | 18 | 17 | 18 |
-11
| |
p02272
|
C++
|
Runtime Error
|
//
// test.cpp
// AtCoder
//
// Created by A on 2018/06/01.
// Copyright © 2018年 A. All rights reserved.
//
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 200000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
//
// test.cpp
// AtCoder
//
// Created by A on 2018/06/01.
// Copyright © 2018年 A. All rights reserved.
//
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 11 | 12 | 11 | 12 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
using namespace std;
int merges(int start, int end) {
int middle;
if (start + 1 < end) {
middle = (start + end) / 2;
return (merges(start, middle) + merges(middle, end) - start + end);
} else {
return 0;
}
}
int main() {
int n, dat[5000000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> dat[i];
}
sort(dat, dat + n);
for (int i = 0; i < n; i++) {
if (i != 0) {
cout << " ";
}
cout << dat[i];
}
cout << endl << merges(0, n) << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <stack>
#include <stdio.h>
#include <string>
using namespace std;
int merges(int start, int end) {
int middle;
if (start + 1 < end) {
middle = (start + end) / 2;
return (merges(start, middle) + merges(middle, end) - start + end);
} else {
return 0;
}
}
int main() {
int n, dat[500000];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> dat[i];
}
sort(dat, dat + n);
for (int i = 0; i < n; i++) {
if (i != 0) {
cout << " ";
}
cout << dat[i];
}
cout << endl << merges(0, n) << endl;
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
-11
| |
p02272
|
C++
|
Memory Limit Exceeded
|
#include <iostream>
using namespace std;
int n;
int a[500005];
int count = 0;
void merge(int l, int mid, int r) {
int n1 = mid - l;
int n2 = r - mid;
int *lf = new int[n1];
int *rt = new int[n2];
for (int i = 0; i < n1; i++) {
lf[i] = a[l + i];
}
for (int i = 0; i < n2; i++) {
rt[i] = a[mid + i];
}
int i = 0;
int j = 0;
for (int k = l; k < r; k++) {
count++;
if ((lf[i] <= rt[j] && i != n1) || (j == n2)) {
a[k] = lf[i];
i++;
} else {
a[k] = rt[j];
j++;
}
}
}
void mergeSort(int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
mergeSort(l, mid);
mergeSort(mid, r);
merge(l, mid, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << a[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int n;
int a[500005];
int count = 0;
void merge(int l, int mid, int r) {
int n1 = mid - l;
int n2 = r - mid;
int *lf = new int[n1];
int *rt = new int[n2];
for (int i = 0; i < n1; i++) {
lf[i] = a[l + i];
}
for (int i = 0; i < n2; i++) {
rt[i] = a[mid + i];
}
int i = 0;
int j = 0;
for (int k = l; k < r; k++) {
count++;
if ((lf[i] <= rt[j] && i != n1) || (j == n2)) {
a[k] = lf[i];
i++;
} else {
a[k] = rt[j];
j++;
}
}
delete (lf);
delete (rt);
}
void mergeSort(int l, int r) {
if (l + 1 < r) {
int mid = (l + r) / 2;
mergeSort(l, mid);
mergeSort(mid, r);
merge(l, mid, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << a[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
insert
| 31 | 31 | 31 | 33 |
MLE
| |
p02272
|
C++
|
Memory Limit Exceeded
|
#include <cstdlib>
#include <iostream>
using namespace std;
#define INF 1000000000
int count = 0;
void merge(int a[], int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid, i, j, k;
int *m1 = (int *)malloc((n1 + 1) * sizeof(int)),
*m2 = (int *)malloc((n2 + 1) * sizeof(int));
for (i = 0; i < n1; i++)
m1[i] = a[left + i];
for (i = 0; i < n2; i++)
m2[i] = a[mid + i];
m1[n1] = m2[n2] = INF;
i = j = 0;
for (k = left; k < right; k++) {
count++;
if (m1[i] <= m2[j]) {
a[k] = m1[i];
i++;
} else {
a[k] = m2[j];
j++;
}
}
}
void mergesort(int a[], int left, int right) {
int mid;
if (right - left > 1) {
mid = (left + right) / 2;
mergesort(a, left, mid);
mergesort(a, mid, right);
merge(a, left, mid, right);
}
}
int main() {
int n, i;
int a[500000];
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
mergesort(a, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << ' ';
cout << a[i];
}
cout << endl << count << endl;
return 0;
}
|
#include <cstdlib>
#include <iostream>
using namespace std;
#define INF 1000000000
int count = 0;
void merge(int a[], int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid, i, j, k;
int *m1 = (int *)malloc((n1 + 1) * sizeof(int)),
*m2 = (int *)malloc((n2 + 1) * sizeof(int));
for (i = 0; i < n1; i++)
m1[i] = a[left + i];
for (i = 0; i < n2; i++)
m2[i] = a[mid + i];
m1[n1] = m2[n2] = INF;
i = j = 0;
for (k = left; k < right; k++) {
count++;
if (m1[i] <= m2[j]) {
a[k] = m1[i];
i++;
} else {
a[k] = m2[j];
j++;
}
}
free(m1);
free(m2);
}
void mergesort(int a[], int left, int right) {
int mid;
if (right - left > 1) {
mid = (left + right) / 2;
mergesort(a, left, mid);
mergesort(a, mid, right);
merge(a, left, mid, right);
}
}
int main() {
int n, i;
int a[500000];
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
mergesort(a, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << ' ';
cout << a[i];
}
cout << endl << count << endl;
return 0;
}
|
insert
| 25 | 25 | 25 | 27 |
MLE
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right);
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 29 | 30 | 29 | 30 |
-11
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#define MAX_N 500000
#define INF 1000000001
void print_array(int A[], int n) {
for (int i = 0; i < n; i++) {
printf("%d", A[i]);
if (i != n - 1) {
printf(" ");
}
}
printf("\n");
}
int merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = (int *)malloc(n1 * sizeof(int));
int *R = (int *)malloc(n2 * sizeof(int));
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INF;
R[n2] = INF;
int li = 0;
int ri = 0;
for (int i = left; i < right; i++) {
if (L[li] <= R[ri]) {
A[i] = L[li];
li++;
} else {
A[i] = R[ri];
ri++;
}
}
free(L);
free(R);
return li + ri;
}
int mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
int x1 = mergeSort(A, left, mid);
int x2 = mergeSort(A, mid, right);
int x3 = merge(A, left, mid, right);
return x1 + x2 + x3;
}
return 0;
}
int main() {
int n;
int A[MAX_N];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int cmpNum = mergeSort(A, 0, n);
print_array(A, n);
printf("%d\n", cmpNum);
}
|
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
#define MAX_N 500000
#define INF 1000000001
void print_array(int A[], int n) {
for (int i = 0; i < n; i++) {
printf("%d", A[i]);
if (i != n - 1) {
printf(" ");
}
}
printf("\n");
}
int merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = (int *)malloc((n1 + 1) * sizeof(int));
int *R = (int *)malloc((n2 + 1) * sizeof(int));
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INF;
R[n2] = INF;
int li = 0;
int ri = 0;
for (int i = left; i < right; i++) {
if (L[li] <= R[ri]) {
A[i] = L[li];
li++;
} else {
A[i] = R[ri];
ri++;
}
}
free(L);
free(R);
return li + ri;
}
int mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
int x1 = mergeSort(A, left, mid);
int x2 = mergeSort(A, mid, right);
int x3 = merge(A, left, mid, right);
return x1 + x2 + x3;
}
return 0;
}
int main() {
int n;
int A[MAX_N];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
int cmpNum = mergeSort(A, 0, n);
print_array(A, n);
printf("%d\n", cmpNum);
}
|
replace
| 21 | 23 | 21 | 23 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define INFTY 100100100
int S[500100] = {0};
int n, cnt = 0;
void merge(int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = new int[n1 + 1], *R = new int[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = S[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = S[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0, j = 0;
for (int k = left; k < right; ++k) {
if (L[i] <= R[j]) {
S[k] = L[i];
++i;
} else {
S[k] = R[j];
++j;
}
++cnt;
}
delete[] L, R;
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> S[i];
}
mergeSort(0, n);
for (int i = 0; i < n; ++i) {
cout << S[i];
if (i != n - 1) {
cout << " ";
} else {
cout << "\n";
}
}
cout << cnt << "\n";
}
|
#include <iostream>
using namespace std;
#define INFTY 1001001001
int S[500100] = {0};
int n, cnt = 0;
void merge(int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int *L = new int[n1 + 1], *R = new int[n2 + 1];
for (int i = 0; i < n1; ++i) {
L[i] = S[left + i];
}
for (int i = 0; i < n2; ++i) {
R[i] = S[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0, j = 0;
for (int k = left; k < right; ++k) {
if (L[i] <= R[j]) {
S[k] = L[i];
++i;
} else {
S[k] = R[j];
++j;
}
++cnt;
}
delete[] L, R;
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> S[i];
}
mergeSort(0, n);
for (int i = 0; i < n; ++i) {
cout << S[i];
if (i != n - 1) {
cout << " ";
} else {
cout << "\n";
}
}
cout << cnt << "\n";
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int INF = 1 << 30;
template <class RandomIt> size_t msort(RandomIt first, RandomIt last) {
if (first + 1 >= last)
return 0;
using T = typename RandomIt::value_type;
ptrdiff_t lhalf = (last - first) >> 1;
RandomIt mid = first + lhalf;
size_t count_ = 0;
count_ += msort(first, mid);
count_ += msort(mid, last);
ptrdiff_t rhalf = last - mid;
vector<T> L(lhalf + 1), R(rhalf + 1);
for (RandomIt in = first, out = L.begin(); in < mid; (++in, ++out))
*out = *in;
for (RandomIt in = first, out = R.begin(); in < last; (++in, ++out))
*out = *in;
L[lhalf] = R[rhalf] = INF;
size_t i = 0, j = 0;
for (RandomIt it = first; it < last; ++it) {
if (L[i] <= R[j]) {
*it = L[i];
++i;
} else {
*it = R[j];
++j;
}
++count_;
}
return count_;
}
int main() {
size_t n;
scanf("%zu", &n);
vector<int> S(n);
for (size_t i = 0; i < n; ++i)
scanf("%d", &S[i]);
size_t t = msort(S.begin(), S.end());
for (size_t i = 0; i < n; ++i)
printf("%d%c", S[i], i < n - 1 ? ' ' : '\n');
printf("%zu\n", t);
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
const int INF = 1 << 30;
template <class RandomIt> size_t msort(RandomIt first, RandomIt last) {
if (first + 1 >= last)
return 0;
using T = typename RandomIt::value_type;
ptrdiff_t lhalf = (last - first) >> 1;
RandomIt mid = first + lhalf;
size_t count_ = 0;
count_ += msort(first, mid);
count_ += msort(mid, last);
ptrdiff_t rhalf = last - mid;
vector<T> L(lhalf + 1), R(rhalf + 1);
for (RandomIt in = first, out = L.begin(); in < mid; (++in, ++out))
*out = *in;
for (RandomIt in = mid, out = R.begin(); in < last; (++in, ++out))
*out = *in;
L[lhalf] = R[rhalf] = INF;
size_t i = 0, j = 0;
for (RandomIt it = first; it < last; ++it) {
if (L[i] <= R[j]) {
*it = L[i];
++i;
} else {
*it = R[j];
++j;
}
++count_;
}
return count_;
}
int main() {
size_t n;
scanf("%zu", &n);
vector<int> S(n);
for (size_t i = 0; i < n; ++i)
scanf("%d", &S[i]);
size_t t = msort(S.begin(), S.end());
for (size_t i = 0; i < n; ++i)
printf("%d%c", S[i], i < n - 1 ? ' ' : '\n');
printf("%zu\n", t);
return 0;
}
|
replace
| 26 | 27 | 26 | 27 |
-6
|
malloc(): corrupted top size
|
p02272
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int a[120000], t[120000], r = 0;
void mergesort(int lo, int hi) {
if (lo == hi)
return;
int mid = (lo + hi) / 2;
mergesort(lo, mid);
mergesort(mid + 1, hi);
int i, j, k;
i = lo;
j = mid + 1;
for (k = lo; k <= hi; k++) {
if (i == mid + 1)
t[k] = a[j++];
else if (j == hi + 1)
t[k] = a[i++];
else if (a[i] < a[j])
t[k] = a[i++];
else
t[k] = a[j++];
r++;
}
for (k = lo; k <= hi; k++) {
a[k] = t[k];
}
}
int main() {
int m, n, i, j, s = 0, t = 0, te;
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
mergesort(0, n - 1);
for (i = 0; i < n - 1; i++)
cout << a[i] << " ";
cout << a[n - 1] << endl;
cout << r;
cout << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[500009], t[500009], r = 0;
void mergesort(int lo, int hi) {
if (lo == hi)
return;
int mid = (lo + hi) / 2;
mergesort(lo, mid);
mergesort(mid + 1, hi);
int i, j, k;
i = lo;
j = mid + 1;
for (k = lo; k <= hi; k++) {
if (i == mid + 1)
t[k] = a[j++];
else if (j == hi + 1)
t[k] = a[i++];
else if (a[i] < a[j])
t[k] = a[i++];
else
t[k] = a[j++];
r++;
}
for (k = lo; k <= hi; k++) {
a[k] = t[k];
}
}
int main() {
int m, n, i, j, s = 0, t = 0, te;
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
mergesort(0, n - 1);
for (i = 0; i < n - 1; i++)
cout << a[i] << " ";
cout << a[n - 1] << endl;
cout << r;
cout << endl;
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
#define NMAX 5000
#define SENTINEL 1000000001
int cnt = 0;
using namespace std;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[NMAX], R[NMAX];
for (int i = 0; i <= n1 - 1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i <= n2 - 1; i++) {
R[i] = A[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k <= right - 1; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void merge_sort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid);
merge_sort(A, mid, right);
merge(A, left, mid, right);
}
}
int main(void) {
int n;
int A[NMAX];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
merge_sort(A, 0, n);
for (int i = 0; i < n - 1; i++) {
cout << A[i] << " ";
}
cout << A[n - 1] << endl;
cout << cnt << endl;
return 0;
}
|
#include <cstdio>
#include <iostream>
#define NMAX 500000
#define SENTINEL 1000000001
int cnt = 0;
using namespace std;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
int L[NMAX], R[NMAX];
for (int i = 0; i <= n1 - 1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i <= n2 - 1; i++) {
R[i] = A[mid + i];
}
L[n1] = SENTINEL;
R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k <= right - 1; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void merge_sort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid);
merge_sort(A, mid, right);
merge(A, left, mid, right);
}
}
int main(void) {
int n;
int A[NMAX];
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
merge_sort(A, 0, n);
for (int i = 0; i < n - 1; i++) {
cout << A[i] << " ";
}
cout << A[n - 1] << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <stdio.h>
int count = 0;
int temp[500000];
void MergeSort(int *, int, int);
int main(void) {
int i, n;
int A[1000000000];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &A[i]);
MergeSort(A, 0, n - 1);
/*出力*/
for (i = 0; i < n - 1; i++)
printf("%d ", A[i]);
printf("%d\n", A[n - 1]);
printf("%d\n", count);
return 0;
}
/* left から right マージソート */
void MergeSort(int *A, int left, int right) {
int mid, i, j, k;
/* 配列の要素が一つの場合 */
if (left >= right)
return;
mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid + 1, right);
/* left から mid*/
for (i = left; i <= mid; i++)
temp[i] = A[i];
/* mid + 1からright */
for (i = mid + 1, j = right; i <= right; i++, j--)
temp[i] = A[j];
i = left;
j = right;
for (k = left; k <= right; k++) {
if (temp[i] <= temp[j])
A[k] = temp[i++];
else
A[k] = temp[j--];
count++;
}
}
|
#include <stdio.h>
int count = 0;
int temp[500000];
void MergeSort(int *, int, int);
int main(void) {
int i, n;
int A[1000000];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &A[i]);
MergeSort(A, 0, n - 1);
/*出力*/
for (i = 0; i < n - 1; i++)
printf("%d ", A[i]);
printf("%d\n", A[n - 1]);
printf("%d\n", count);
return 0;
}
/* left から right マージソート */
void MergeSort(int *A, int left, int right) {
int mid, i, j, k;
/* 配列の要素が一つの場合 */
if (left >= right)
return;
mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid + 1, right);
/* left から mid*/
for (i = left; i <= mid; i++)
temp[i] = A[i];
/* mid + 1からright */
for (i = mid + 1, j = right; i <= right; i++, j--)
temp[i] = A[j];
i = left;
j = right;
for (k = left; k <= right; k++) {
if (temp[i] <= temp[j])
A[k] = temp[i++];
else
A[k] = temp[j--];
count++;
}
}
|
replace
| 10 | 11 | 10 | 11 |
-11
| |
p02272
|
C++
|
Runtime Error
|
#define PI 3.14159265359
#define INF 200000000
#define MAX 500000
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int cnt = 0;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
//?????????2??????????????????????????¨??????????????§????????±??????
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = INF;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int n, A[MAX + 1], i;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl << cnt << endl;
return 0;
}
|
#define PI 3.14159265359
#define INF 2000000000
#define MAX 500000
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int cnt = 0;
int L[MAX / 2 + 2], R[MAX / 2 + 2];
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
//?????????2??????????????????????????¨??????????????§????????±??????
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = INF;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int n, A[MAX + 1], i;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl << cnt << endl;
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
using namespace std;
int A[50001], S = 0;
int merge(int l, int m, int r) {
int n1 = m - l, n2 = r - m, i, j;
int L[n1 + 1], R[n2 + 1];
for (i = 0; i < n1; i++)
L[i] = A[i + l];
for (i = 0; i < n2; i++)
R[i] = A[i + m];
i = j = 0;
for (int k = 0; k < r - l; k++, S++) {
if (j == n2 || (i < n1 && L[i] <= R[j]))
A[k + l] = L[i++];
else
A[k + l] = R[j++];
}
}
int mergeSort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergeSort(l, m);
mergeSort(m, r);
merge(l, m, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", S);
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
int A[500000], S = 0;
int merge(int l, int m, int r) {
int n1 = m - l, n2 = r - m, i, j;
int L[n1 + 1], R[n2 + 1];
for (i = 0; i < n1; i++)
L[i] = A[i + l];
for (i = 0; i < n2; i++)
R[i] = A[i + m];
i = j = 0;
for (int k = 0; k < r - l; k++, S++) {
if (j == n2 || (i < n1 && L[i] <= R[j]))
A[k + l] = L[i++];
else
A[k + l] = R[j++];
}
}
int mergeSort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergeSort(l, m);
mergeSort(m, r);
merge(l, m, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", S);
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
int b[100099], n = 0, ans = 0;
void Merge(int a[], int l, int r) {
int m = (l + r) / 2;
int i = l, j = m + 1, sum[r - l + 1], cnt = -1;
ans += r - l + 1;
while (i <= m && j <= r) {
if (a[i] < a[j])
sum[++cnt] = a[i++];
else
sum[++cnt] = a[j++];
}
while (i <= m)
sum[++cnt] = a[i++];
while (j <= r)
sum[++cnt] = a[j++];
for (int i = l; i <= r; i++)
a[i] = sum[i - l];
}
void Merge_sort(int a[], int l, int r) {
if (l < r) {
int m = (l + r) / 2;
Merge_sort(a, l, m);
Merge_sort(a, m + 1, r);
Merge(a, l, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> b[i];
Merge_sort(b, 0, n - 1);
for (int i = 0; i < n - 1; i++)
cout << b[i] << " ";
cout << b[n - 1] << endl;
cout << ans << endl;
return 0;
}
|
#include <iostream>
using namespace std;
int b[500099], n = 0, ans = 0;
void Merge(int a[], int l, int r) {
int m = (l + r) / 2;
int i = l, j = m + 1, sum[r - l + 1], cnt = -1;
ans += r - l + 1;
while (i <= m && j <= r) {
if (a[i] < a[j])
sum[++cnt] = a[i++];
else
sum[++cnt] = a[j++];
}
while (i <= m)
sum[++cnt] = a[i++];
while (j <= r)
sum[++cnt] = a[j++];
for (int i = l; i <= r; i++)
a[i] = sum[i - l];
}
void Merge_sort(int a[], int l, int r) {
if (l < r) {
int m = (l + r) / 2;
Merge_sort(a, l, m);
Merge_sort(a, m + 1, r);
Merge(a, l, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> b[i];
Merge_sort(b, 0, n - 1);
for (int i = 0; i < n - 1; i++)
cout << b[i] << " ";
cout << b[n - 1] << endl;
cout << ans << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 4], R[MAX / 4];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergesort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergesort(A, n, left, mid);
mergesort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergesort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergesort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergesort(A, n, left, mid);
mergesort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
mergesort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 5 | 6 | 5 | 6 |
0
| |
p02272
|
C++
|
Runtime Error
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <type_traits>
#include <vector>
using namespace std;
static int comp_count = 0;
#ifndef NDEBUG
#define _DBG 1
#include <stdio.h>
#else
#define _DBG 0
#endif
#define DbgP(fmt, ...) \
do { \
if (_DBG) { \
fprintf(stderr, fmt, __VA_ARGS__); \
} \
} while (0)
#define DbgFunc(fmt, ...) \
do { \
if (_DBG) { \
fprintf(stderr, "%s(", __FUNCTION__); \
fprintf(stderr, fmt, __VA_ARGS__); \
fputs(")\n", stderr); \
} \
} while (0)
template <typename R, typename A>
void merge(int left, int left_last, int right_last, R ar, A tmp) {
int right = left_last + 1;
int n = right_last - left + 1;
int t = left;
int c = left;
DbgFunc("%d,%d,%d,%d", left, left_last, right, right_last);
while (left <= left_last && right <= right_last) {
if (ar[left] <= ar[right]) {
tmp[t] = ar[left];
left++;
} else {
tmp[t] = ar[right];
right++;
}
t++;
}
while (left <= left_last) {
tmp[t++] = ar[left++];
}
while (right <= right_last) {
tmp[t++] = ar[right++];
}
for (int i = 0; i < n; i++) {
ar[right_last] = tmp[right_last];
right_last--;
}
comp_count += t - c;
}
template <typename R, typename A>
void m_sort(int left, int right, R ar, A tmp) {
if (left < right) {
int mid = (left + right) / 2;
m_sort(left, mid, ar, tmp);
m_sort(mid + 1, right, ar, tmp);
merge(left, mid, right, ar, tmp);
}
}
template <typename T> void merge_sort(T begin, T end) {
if (begin < end) {
int n = end - begin;
auto tmp = new typename decay<decltype(*begin)>::type[n];
m_sort(0, end - begin - 1, begin, tmp);
}
}
int ar[500000];
int main(int argc, char const *argv[]) {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i]);
}
merge_sort(ar, ar + n);
for (int i = 0; i < n - 1; i++) {
printf("%d ", ar[i]);
}
printf("%d\n", ar[n - 1]);
printf("%d\n", comp_count);
return 0;
}
|
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
#include <type_traits>
#include <vector>
using namespace std;
static int comp_count = 0;
#define NDEBUG 1
#ifndef NDEBUG
#define _DBG 1
#include <stdio.h>
#else
#define _DBG 0
#endif
#define DbgP(fmt, ...) \
do { \
if (_DBG) { \
fprintf(stderr, fmt, __VA_ARGS__); \
} \
} while (0)
#define DbgFunc(fmt, ...) \
do { \
if (_DBG) { \
fprintf(stderr, "%s(", __FUNCTION__); \
fprintf(stderr, fmt, __VA_ARGS__); \
fputs(")\n", stderr); \
} \
} while (0)
template <typename R, typename A>
void merge(int left, int left_last, int right_last, R ar, A tmp) {
int right = left_last + 1;
int n = right_last - left + 1;
int t = left;
int c = left;
DbgFunc("%d,%d,%d,%d", left, left_last, right, right_last);
while (left <= left_last && right <= right_last) {
if (ar[left] <= ar[right]) {
tmp[t] = ar[left];
left++;
} else {
tmp[t] = ar[right];
right++;
}
t++;
}
while (left <= left_last) {
tmp[t++] = ar[left++];
}
while (right <= right_last) {
tmp[t++] = ar[right++];
}
for (int i = 0; i < n; i++) {
ar[right_last] = tmp[right_last];
right_last--;
}
comp_count += t - c;
}
template <typename R, typename A>
void m_sort(int left, int right, R ar, A tmp) {
if (left < right) {
int mid = (left + right) / 2;
m_sort(left, mid, ar, tmp);
m_sort(mid + 1, right, ar, tmp);
merge(left, mid, right, ar, tmp);
}
}
template <typename T> void merge_sort(T begin, T end) {
if (begin < end) {
int n = end - begin;
auto tmp = new typename decay<decltype(*begin)>::type[n];
m_sort(0, end - begin - 1, begin, tmp);
}
}
int ar[500000];
int main(int argc, char const *argv[]) {
int n;
scanf("%d ", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &ar[i]);
}
merge_sort(ar, ar + n);
for (int i = 0; i < n - 1; i++) {
printf("%d ", ar[i]);
}
printf("%d\n", ar[n - 1]);
printf("%d\n", comp_count);
return 0;
}
|
insert
| 9 | 9 | 9 | 11 |
0
|
merge(0,0,1,1)
merge(0,1,2,2)
merge(3,3,4,4)
merge(0,2,3,4)
merge(5,5,6,6)
merge(5,6,7,7)
merge(8,8,9,9)
merge(5,7,8,9)
merge(0,4,5,9)
|
p02272
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
using namespace std;
int A[5000], S = 0;
int merge(int l, int m, int r) {
int n1 = m - l, n2 = r - m, i, j;
int L[n1 + 1], R[n2 + 1];
for (i = 0; i < n1; i++)
L[i] = A[i + l];
for (i = 0; i < n2; i++)
R[i] = A[i + m];
i = 0;
j = 0;
// printf("%d %d : \n", L[0], R[0]);
for (int k = 0; k < r - l; k++) {
if (j == n2 || (i < n1 && L[i] <= R[j]))
A[k + l] = L[i++];
else
A[k + l] = R[j++];
S++;
}
// for(int i = 0;i < 4;i++)printf(" %d", A[i]);
// puts("");
}
int mergeSort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergeSort(l, m);
mergeSort(m, r);
merge(l, m, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", S);
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
int A[500000], S = 0;
int merge(int l, int m, int r) {
int n1 = m - l, n2 = r - m, i, j;
int L[n1 + 1], R[n2 + 1];
for (i = 0; i < n1; i++)
L[i] = A[i + l];
for (i = 0; i < n2; i++)
R[i] = A[i + m];
i = 0;
j = 0;
// printf("%d %d : \n", L[0], R[0]);
for (int k = 0; k < r - l; k++) {
if (j == n2 || (i < n1 && L[i] <= R[j]))
A[k + l] = L[i++];
else
A[k + l] = R[j++];
S++;
}
// for(int i = 0;i < 4;i++)printf(" %d", A[i]);
// puts("");
}
int mergeSort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergeSort(l, m);
mergeSort(m, r);
merge(l, m, r);
}
}
int main() {
int n;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", S);
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Memory Limit Exceeded
|
#include <climits>
#include <iostream>
#include <vector>
void merge(std::vector<int> *A, int left, int mid, int right, int *count) {
int n1 = mid - left;
int n2 = right - mid;
std::vector<int> *L = new std::vector<int>(n1 + 1, 0);
std::vector<int> *R = new std::vector<int>(n2 + 1, 0);
for (int i = 0; i < n1; i++) {
L->at(i) = A->at(left + i);
}
for (int i = 0; i < n2; i++) {
R->at(i) = A->at(mid + i);
}
L->at(n1) = INT_MAX;
R->at(n2) = INT_MAX;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L->at(i) <= R->at(j)) {
A->at(k) = L->at(i);
i++;
} else {
A->at(k) = R->at(j);
j++;
}
(*count)++;
}
}
void merge_sort(std::vector<int> *A, int left, int right, int *count) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid, count);
merge_sort(A, mid, right, count);
merge(A, left, mid, right, count);
}
}
int main(void) {
int n = 0;
std::cin >> n;
std::vector<int> *A = new std::vector<int>(n, 0);
for (int i = 0; i < n; i++) {
int v = 0;
std::cin >> v;
A->at(i) = v;
}
int count = 0;
int left = 0;
int right = A->size();
int mid = (left + right) / 2;
merge_sort(A, left, right, &count);
for (int i = 0; i < n; i++) {
if (i < (n - 1)) {
std::cout << A->at(i) << " ";
} else {
std::cout << A->at(i) << std::endl;
}
}
std::cout << count << std::endl;
return 0;
}
|
#include <climits>
#include <iostream>
#include <vector>
void merge(std::vector<int> *A, int left, int mid, int right, int *count) {
int n1 = mid - left;
int n2 = right - mid;
std::vector<int> *L = new std::vector<int>(n1 + 1, 0);
std::vector<int> *R = new std::vector<int>(n2 + 1, 0);
for (int i = 0; i < n1; i++) {
L->at(i) = A->at(left + i);
}
for (int i = 0; i < n2; i++) {
R->at(i) = A->at(mid + i);
}
L->at(n1) = INT_MAX;
R->at(n2) = INT_MAX;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L->at(i) <= R->at(j)) {
A->at(k) = L->at(i);
i++;
} else {
A->at(k) = R->at(j);
j++;
}
(*count)++;
}
delete R;
delete L;
}
void merge_sort(std::vector<int> *A, int left, int right, int *count) {
if (left + 1 < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid, count);
merge_sort(A, mid, right, count);
merge(A, left, mid, right, count);
}
}
int main(void) {
int n = 0;
std::cin >> n;
std::vector<int> *A = new std::vector<int>(n, 0);
for (int i = 0; i < n; i++) {
int v = 0;
std::cin >> v;
A->at(i) = v;
}
int count = 0;
int left = 0;
int right = A->size();
int mid = (left + right) / 2;
merge_sort(A, left, right, &count);
for (int i = 0; i < n; i++) {
if (i < (n - 1)) {
std::cout << A->at(i) << " ";
} else {
std::cout << A->at(i) << std::endl;
}
}
std::cout << count << std::endl;
return 0;
}
|
insert
| 36 | 36 | 36 | 39 |
MLE
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
#define MAXN 100000 + 5
using namespace std;
int a[MAXN];
int t[MAXN];
int count = 0;
void merge(int *A, int x, int y, int *T) {
if (y - x > 1) {
int mid = x + (y - x) / 2;
int p = x, q = mid, i = x;
merge(A, x, mid, T);
merge(A, mid, y, T);
while (q < y || p < mid) {
if (q >= y || (p < mid && A[p] <= A[q]))
T[i++] = A[p++];
else
T[i++] = A[q++];
count++;
}
for (i = x; i < y; i++)
A[i] = T[i];
}
}
int main() {
int n;
int i, j;
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
merge(a, 0, n, t);
for (i = 0; i < n - 1; i++)
cout << t[i] << ' ';
cout << t[n - 1] << endl;
cout << count << endl;
return 0;
}
|
#include <iostream>
#define MAXN 500000 + 5
using namespace std;
int a[MAXN];
int t[MAXN];
int count = 0;
void merge(int *A, int x, int y, int *T) {
if (y - x > 1) {
int mid = x + (y - x) / 2;
int p = x, q = mid, i = x;
merge(A, x, mid, T);
merge(A, mid, y, T);
while (q < y || p < mid) {
if (q >= y || (p < mid && A[p] <= A[q]))
T[i++] = A[p++];
else
T[i++] = A[q++];
count++;
}
for (i = x; i < y; i++)
A[i] = T[i];
}
}
int main() {
int n;
int i, j;
cin >> n;
for (i = 0; i < n; i++)
cin >> a[i];
merge(a, 0, n, t);
for (i = 0; i < n - 1; i++)
cout << t[i] << ' ';
cout << t[n - 1] << endl;
cout << count << endl;
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define INFINITY 2000000000
#define MAX 50000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
L[n1] = R[n2] = INFINITY;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int A[MAX], n, l;
cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define INFINITY 2000000000
#define MAX 500000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
L[n1] = R[n2] = INFINITY;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int A[MAX], n, l;
cnt = 0;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> A[i];
}
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <stdio.h>
#define INF 999999999
int l[25002] = {};
int r[25002] = {};
int c;
void merge(int *s, int n, int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
l[i] = s[left + i];
for (i = 0; i < n2; i++)
r[i] = s[mid + i];
l[n1] = INF;
r[n2] = INF;
i = j = 0;
for (k = left; k < right; k++) {
c++;
if (l[i] <= r[j]) {
s[k] = l[i];
i++;
} else {
s[k] = r[j];
j++;
}
}
}
void mergesort(int *s, int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergesort(s, n, left, mid);
mergesort(s, n, mid, right);
merge(s, n, left, mid, right);
}
}
int main() {
int n, i, left, right;
int s[500000];
c = 0;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &s[i]);
left = 0;
right = n;
mergesort(s, n, left, right);
for (i = 0; i < n; i++) {
if (i != n - 1)
printf("%d ", s[i]);
else
printf("%d\n", s[i]);
}
printf("%d\n", c);
return 0;
}
|
#include <stdio.h>
#define INF 999999999
int l[250002] = {};
int r[250002] = {};
int c;
void merge(int *s, int n, int left, int mid, int right) {
int i, j, k;
int n1 = mid - left;
int n2 = right - mid;
for (i = 0; i < n1; i++)
l[i] = s[left + i];
for (i = 0; i < n2; i++)
r[i] = s[mid + i];
l[n1] = INF;
r[n2] = INF;
i = j = 0;
for (k = left; k < right; k++) {
c++;
if (l[i] <= r[j]) {
s[k] = l[i];
i++;
} else {
s[k] = r[j];
j++;
}
}
}
void mergesort(int *s, int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergesort(s, n, left, mid);
mergesort(s, n, mid, right);
merge(s, n, left, mid, right);
}
}
int main() {
int n, i, left, right;
int s[500000];
c = 0;
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &s[i]);
left = 0;
right = n;
mergesort(s, n, left, right);
for (i = 0; i < n; i++) {
if (i != n - 1)
printf("%d ", s[i]);
else
printf("%d\n", s[i]);
}
printf("%d\n", c);
return 0;
}
|
replace
| 3 | 5 | 3 | 5 |
0
| |
p02272
|
C++
|
Time Limit Exceeded
|
#include <iostream>
#include <vector>
#define INF 1000000000
#define nmax 500005
using namespace std;
int n;
int cnt = 0;
vector<int> a;
void merge(int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> l(nmax);
vector<int> r(nmax);
int i, j;
for (i = 0; i < n1; i++)
l[i] = a[left + i];
for (i = 0; i < n2; i++)
r[i] = a[mid + i];
l[n1] = INF;
r[n2] = INF;
i = 0;
j = 0;
for (int k = left; k < right; k++) {
if (l[i] <= r[j])
a[k] = l[i++];
else
a[k] = r[j++];
cnt++;
}
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << a[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
#include <vector>
#define INF 1000000000
#define nmax 500005
using namespace std;
int n;
int cnt = 0;
vector<int> a;
void merge(int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> l(n1 + 5);
vector<int> r(n1 + 5);
int i, j;
for (i = 0; i < n1; i++)
l[i] = a[left + i];
for (i = 0; i < n2; i++)
r[i] = a[mid + i];
l[n1] = INF;
r[n2] = INF;
i = 0;
j = 0;
for (int k = left; k < right; k++) {
if (l[i] <= r[j])
a[k] = l[i++];
else
a[k] = r[j++];
cnt++;
}
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main() {
cin >> n;
a.resize(n);
for (int i = 0; i < n; i++)
cin >> a[i];
mergeSort(0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << a[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 13 | 15 | 13 | 15 |
TLE
| |
p02272
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
using namespace std;
int MargeElem(int elem[], int start, int mid, int end) {
int i, j, k, l;
int num = 0;
int A[2500], B[2500];
i = mid - start;
j = end - mid;
l = (i > j) ? i : j;
for (k = 0; k < l; k++) {
A[k] = elem[start + k];
B[k] = elem[mid + k];
}
A[i] = 0x7FFFFFFF;
B[j] = 0x7FFFFFFF;
i = 0;
j = 0;
for (k = start; k < end; k++) {
++num;
if (A[i] <= B[j]) {
elem[k] = A[i];
++i;
} else {
elem[k] = B[j];
++j;
}
}
return num;
}
int MargeSort(int elem[], int start, int end) {
int mid;
int cnt = 0;
if ((start + 1) >= end) {
return 0;
}
mid = (start + end) / 2;
cnt += MargeSort(elem, start, mid);
cnt += MargeSort(elem, mid, end);
cnt += MargeElem(elem, start, mid, end);
return cnt;
}
int main(void) {
int i;
int num;
int cnt;
int elem[500002];
scanf("%d", &num);
for (i = 0; i < num; i++) {
scanf("%d", &elem[i]);
}
cnt = MargeSort(elem, 0, num);
printf("%d", elem[0]);
for (i = 1; i < num; i++) {
printf(" %d", elem[i]);
}
printf("\n%d\n", cnt);
return 0;
}
|
#include <cstdio>
#include <iostream>
using namespace std;
int MargeElem(int elem[], int start, int mid, int end) {
int i, j, k, l;
int num = 0;
int A[250001], B[250001];
i = mid - start;
j = end - mid;
l = (i > j) ? i : j;
for (k = 0; k < l; k++) {
A[k] = elem[start + k];
B[k] = elem[mid + k];
}
A[i] = 0x7FFFFFFF;
B[j] = 0x7FFFFFFF;
i = 0;
j = 0;
for (k = start; k < end; k++) {
++num;
if (A[i] <= B[j]) {
elem[k] = A[i];
++i;
} else {
elem[k] = B[j];
++j;
}
}
return num;
}
int MargeSort(int elem[], int start, int end) {
int mid;
int cnt = 0;
if ((start + 1) >= end) {
return 0;
}
mid = (start + end) / 2;
cnt += MargeSort(elem, start, mid);
cnt += MargeSort(elem, mid, end);
cnt += MargeElem(elem, start, mid, end);
return cnt;
}
int main(void) {
int i;
int num;
int cnt;
int elem[500002];
scanf("%d", &num);
for (i = 0; i < num; i++) {
scanf("%d", &elem[i]);
}
cnt = MargeSort(elem, 0, num);
printf("%d", elem[0]);
for (i = 1; i < num; i++) {
printf(" %d", elem[i]);
}
printf("\n%d\n", cnt);
return 0;
}
|
replace
| 7 | 8 | 7 | 8 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
const int INFTY = 1000000;
int cnt = 0;
void merge(int A[], int left, int mid, int right) {
int n1, n2;
int *L, *R;
n1 = mid - left;
n2 = right - mid;
L = new int[n1 + 1];
R = new int[n2 + 1];
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
cnt++;
} else {
A[k] = R[j++];
cnt++;
}
}
delete[] L;
delete[] R;
}
void mergeSort(int A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
int *A;
cin >> n;
A = new int[n];
for (int i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, 0, n);
for (int i = 0; i < n - 1; i++)
cout << A[i] << ' ';
cout << A[n - 1] << endl << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
const int INFTY = 1000000000;
int cnt = 0;
void merge(int A[], int left, int mid, int right) {
int n1, n2;
int *L, *R;
n1 = mid - left;
n2 = right - mid;
L = new int[n1 + 1];
R = new int[n2 + 1];
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i++];
cnt++;
} else {
A[k] = R[j++];
cnt++;
}
}
delete[] L;
delete[] R;
}
void mergeSort(int A[], int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
int *A;
cin >> n;
A = new int[n];
for (int i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, 0, n);
for (int i = 0; i < n - 1; i++)
cout << A[i] << ' ';
cout << A[n - 1] << endl << cnt << endl;
return 0;
}
|
replace
| 2 | 3 | 2 | 3 |
0
| |
p02272
|
C++
|
Runtime Error
|
//??????????????????
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep3(i, k, n) for (int i = k; i < n; i++)
#define INFTY 200000000
using namespace std;
int L[250002], R[250002], cnt;
//???????????????????£????????????§????????????
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
rep(i, n1) { L[i] = A[left + i]; }
rep(i, n2) { R[i] = A[mid + i]; }
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0, j = 0, k;
rep3(k, left, right) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void MergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
MergeSort(A, n, left, mid);
MergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main(void) {
int A[500000], n, i;
cnt = 0;
cin >> n;
rep(i, n) cin >> A[i];
MergeSort(A, n, 0, n);
rep(i, n) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
//??????????????????
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
#define rep3(i, k, n) for (int i = k; i < n; i++)
#define INFTY 2000000000
using namespace std;
int L[250002], R[250002], cnt;
//???????????????????£????????????§????????????
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
rep(i, n1) { L[i] = A[left + i]; }
rep(i, n2) { R[i] = A[mid + i]; }
L[n1] = INFTY;
R[n2] = INFTY;
int i = 0, j = 0, k;
rep3(k, left, right) {
cnt++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void MergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
MergeSort(A, n, left, mid);
MergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main(void) {
int A[500000], n, i;
cnt = 0;
cin >> n;
rep(i, n) cin >> A[i];
MergeSort(A, n, 0, n);
rep(i, n) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
// #include<cmath>
using namespace std;
const int INFTY = 1000000001;
int S[200010], n, cmp;
void merge(int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid;
vector<int> L(n1 + 1), R(n2 + 1);
for (int i = 0; i < n1; i++)
L[i] = S[left + i];
for (int i = 0; i < n2; i++)
R[i] = S[mid + i];
L[n1] = R[n2] = INFTY;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
S[k] = L[i];
i += 1;
cmp++;
} else {
S[k] = R[j];
j += 1;
cmp++;
}
}
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> S[i];
mergeSort(0, n);
int i = 0;
for (int j = 0; j < n; j++) {
if (i++)
cout << " ";
cout << S[j];
}
cout << endl;
cout << cmp << endl;
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <queue>
#include <stack>
#include <string>
#include <vector>
// #include<cmath>
using namespace std;
const int INFTY = 1000000001;
int S[500010], n, cmp;
void merge(int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid;
vector<int> L(n1 + 1), R(n2 + 1);
for (int i = 0; i < n1; i++)
L[i] = S[left + i];
for (int i = 0; i < n2; i++)
R[i] = S[mid + i];
L[n1] = R[n2] = INFTY;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
S[k] = L[i];
i += 1;
cmp++;
} else {
S[k] = R[j];
j += 1;
cmp++;
}
}
}
void mergeSort(int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(left, mid);
mergeSort(mid, right);
merge(left, mid, right);
}
}
int main(void) {
cin >> n;
for (int i = 0; i < n; i++)
cin >> S[i];
mergeSort(0, n);
int i = 0;
for (int j = 0; j < n; j++) {
if (i++)
cout << " ";
cout << S[j];
}
cout << endl;
cout << cmp << endl;
return 0;
}
|
replace
| 14 | 15 | 14 | 15 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 50000
#define INF 200000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int count;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = INF;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
count++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n;
count = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define INF 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int count;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = INF;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
count++;
if (L[i] <= R[j]) {
A[k] = L[i++];
} else {
A[k] = R[j++];
}
}
}
void mergeSort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n;
count = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> A[i];
mergeSort(A, n, 0, n);
for (int i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
replace
| 3 | 5 | 3 | 5 |
0
| |
p02272
|
C++
|
Time Limit Exceeded
|
#include <iostream>
using namespace std;
#define MAX 500000
#define INFTY 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2], count;
void marge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid;
int i, j, k;
for (i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (i = 0; i < n; i++) {
R[i] = A[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
i = 0;
j = 0;
for (k = left; k < right; k++) {
count++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void margeSort(int A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
margeSort(A, n, left, mid);
margeSort(A, n, mid, right);
marge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
count = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
margeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define INFTY 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2], count;
void marge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left, n2 = right - mid;
int i, j, k;
for (i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INFTY;
R[n2] = INFTY;
i = 0;
j = 0;
for (k = left; k < right; k++) {
count++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void margeSort(int A[], int n, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
margeSort(A, n, left, mid);
margeSort(A, n, mid, right);
marge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
count = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> A[i];
}
margeSort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i) {
cout << " ";
}
cout << A[i];
}
cout << endl;
cout << count << endl;
return 0;
}
|
replace
| 18 | 19 | 18 | 19 |
TLE
| |
p02272
|
C++
|
Runtime Error
|
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(uint32_t A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(uint32_t A[], int num) {
for (int i = 0; i < num; i++) {
cout << (i != 0 ? " " : "") << A[i];
}
cout << endl;
}
static int compared = 0;
static vector<uint32_t> L(25000);
static vector<uint32_t> R(25000);
static inline void merge(uint32_t A[], uint32_t left, uint32_t mid,
uint32_t right) {
uint32_t n1 = mid - left;
uint32_t n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = R[n2] = UINT32_MAX;
for (uint32_t i = 0, j = 0, k = left; k < right; k++) {
compared++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
static inline void mergeSort(uint32_t A[], uint32_t left, uint32_t right) {
if (left + 1 < right) {
uint32_t mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
cin >> n;
vector<uint32_t> A(n);
inputArray(&A[0], n);
mergeSort(&A[0], 0, n);
printArray(&A[0], n);
cout << compared << endl;
return 0;
}
|
#include <cstdint>
#include <iostream>
#include <vector>
using namespace std;
static void inputArray(uint32_t A[], int num) {
for (int i = 0; i < num; i++) {
cin >> A[i];
}
}
static void printArray(uint32_t A[], int num) {
for (int i = 0; i < num; i++) {
cout << (i != 0 ? " " : "") << A[i];
}
cout << endl;
}
static int compared = 0;
static vector<uint32_t> L(250000);
static vector<uint32_t> R(250000);
static inline void merge(uint32_t A[], uint32_t left, uint32_t mid,
uint32_t right) {
uint32_t n1 = mid - left;
uint32_t n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = R[n2] = UINT32_MAX;
for (uint32_t i = 0, j = 0, k = left; k < right; k++) {
compared++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
static inline void mergeSort(uint32_t A[], uint32_t left, uint32_t right) {
if (left + 1 < right) {
uint32_t mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
cin >> n;
vector<uint32_t> A(n);
inputArray(&A[0], n);
mergeSort(&A[0], 0, n);
printArray(&A[0], n);
cout << compared << endl;
return 0;
}
|
replace
| 21 | 23 | 21 | 23 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = int(m); i < (int)(n); i++)
using namespace std;
int num = 0;
void merge(vector<int> &A, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> L(n1), R(n2);
rep(i, n1) { L[i] = A[left + i]; }
rep(i, n2) { R[i] = A[mid + i]; }
L[n1] = 1001001001;
R[n2] = 1001001001;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
num++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void merge_sort(vector<int> &A, int left, int right) {
if ((left + 1) < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid);
merge_sort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
cin >> n;
vector<int> A(n);
rep(i, n) cin >> A[i];
merge_sort(A, 0, n);
cout << A[0];
for (int i = 1; i < n; i++)
cout << ' ' << A[i];
cout << endl;
cout << num << endl;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define irep(i, n) for (int i = int(n) - 1; i >= 0; i--)
#define FOR(i, m, n) for (int i = int(m); i < (int)(n); i++)
using namespace std;
int num = 0;
void merge(vector<int> &A, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
vector<int> L(n1 + 1), R(n2 + 1);
rep(i, n1) { L[i] = A[left + i]; }
rep(i, n2) { R[i] = A[mid + i]; }
L[n1] = 1001001001;
R[n2] = 1001001001;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
num++;
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
} else {
A[k] = R[j];
j++;
}
}
}
void merge_sort(vector<int> &A, int left, int right) {
if ((left + 1) < right) {
int mid = (left + right) / 2;
merge_sort(A, left, mid);
merge_sort(A, mid, right);
merge(A, left, mid, right);
}
}
int main() {
int n;
cin >> n;
vector<int> A(n);
rep(i, n) cin >> A[i];
merge_sort(A, 0, n);
cout << A[0];
for (int i = 1; i < n; i++)
cout << ' ' << A[i];
cout << endl;
cout << num << endl;
}
|
replace
| 28 | 29 | 28 | 29 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
int n, a[10005], l[10005], r[10005], inf = 5e5 + 1, s;
void merge(int x, int y) {
if (x == y)
return;
int c1 = (x + y) / 2;
int c2 = ((x + y) / 2) + 1;
merge(x, c1);
merge(c2, y);
for (int i = 0; i <= c1 - x; i++)
l[i] = a[i + x];
for (int i = 0; i <= y - c2; i++)
r[i] = a[i + c2];
l[c1 - x + 1] = inf;
r[y - c2 + 1] = inf;
int k = x, l1 = 0, r1 = 0;
for (int i = 0; i < y - x + 1; i++) {
a[k] = min(l[l1], r[r1]);
k++;
if (l[l1] > r[r1])
r1++;
else
l1++;
}
s += y - x + 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
merge(0, n - 1);
for (int i = 0; i < n; i++) {
if (i != 0)
cout << ' ';
cout << a[i];
}
cout << "\n" << s << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[500005], l[500005], r[500005], inf = 1e9 + 1, s;
void merge(int x, int y) {
if (x == y)
return;
int c1 = (x + y) / 2;
int c2 = ((x + y) / 2) + 1;
merge(x, c1);
merge(c2, y);
for (int i = 0; i <= c1 - x; i++)
l[i] = a[i + x];
for (int i = 0; i <= y - c2; i++)
r[i] = a[i + c2];
l[c1 - x + 1] = inf;
r[y - c2 + 1] = inf;
int k = x, l1 = 0, r1 = 0;
for (int i = 0; i < y - x + 1; i++) {
a[k] = min(l[l1], r[r1]);
k++;
if (l[l1] > r[r1])
r1++;
else
l1++;
}
s += y - x + 1;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
}
merge(0, n - 1);
for (int i = 0; i < n; i++) {
if (i != 0)
cout << ' ';
cout << a[i];
}
cout << "\n" << s << "\n";
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
using namespace std;
#define MAX 500000
#define NIL 1000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void Merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = NIL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void Sort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
Sort(A, n, left, mid);
Sort(A, n, mid, right);
Merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
Sort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
using namespace std;
#define MAX 500000
#define NIL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void Merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = R[n2] = NIL;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void Sort(int A[], int n, int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
Sort(A, n, left, mid);
Sort(A, n, mid, right);
Merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
for (i = 0; i < n; i++)
cin >> A[i];
Sort(A, n, 0, n);
for (i = 0; i < n; i++) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Memory Limit Exceeded
|
#include <bits/stdc++.h>
using namespace std;
int S[500000];
int n;
int cnt;
void merge(int l, int m, int r) {
int n1 = m - l;
int n2 = r - m;
int *L = (int *)malloc(sizeof(int) * (n1 + 1));
int *R = (int *)malloc(sizeof(int) * (n2 + 1));
for (int i = 0; i < n1; i++)
L[i] = S[l + i];
for (int i = 0; i < n2; i++)
R[i] = S[m + i];
L[n1] = INT_MAX;
R[n2] = INT_MAX;
int i = 0, j = 0;
for (int k = l; k < r; k++) {
if (L[i] <= R[j]) {
S[k] = L[i];
i++;
} else {
S[k] = R[j];
j++;
}
cnt++;
}
}
void mergesort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergesort(l, m);
mergesort(m, r);
merge(l, m, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> S[i];
mergesort(0, n);
for (int i = 0; i < n - 1; i++) {
cout << S[i] << ' ';
}
cout << S[n - 1] << endl;
cout << cnt << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int S[500000];
int n;
int cnt;
void merge(int l, int m, int r) {
int n1 = m - l;
int n2 = r - m;
int *L = (int *)malloc(sizeof(int) * (n1 + 1));
int *R = (int *)malloc(sizeof(int) * (n2 + 1));
for (int i = 0; i < n1; i++)
L[i] = S[l + i];
for (int i = 0; i < n2; i++)
R[i] = S[m + i];
L[n1] = INT_MAX;
R[n2] = INT_MAX;
int i = 0, j = 0;
for (int k = l; k < r; k++) {
if (L[i] <= R[j]) {
S[k] = L[i];
i++;
} else {
S[k] = R[j];
j++;
}
cnt++;
}
free(L);
free(R);
}
void mergesort(int l, int r) {
if (l + 1 < r) {
int m = (l + r) / 2;
mergesort(l, m);
mergesort(m, r);
merge(l, m, r);
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++)
cin >> S[i];
mergesort(0, n);
for (int i = 0; i < n - 1; i++) {
cout << S[i] << ' ';
}
cout << S[n - 1] << endl;
cout << cnt << endl;
}
|
insert
| 29 | 29 | 29 | 31 |
MLE
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
#include <stdio.h>
#define MAX 500000
#define INFINITY 100000000
int n;
int L[MAX / 2 + 1], R[MAX / 2 + 1];
int sum(0);
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INFINITY;
R[n2] = INFINITY;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
sum++;
} else {
A[k] = R[j];
j++;
sum++;
}
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
Merge(A, left, mid, right);
}
}
int main() {
int A[MAX];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", sum);
return 0;
}
|
#include <iostream>
#include <stdio.h>
#define MAX 500000
#define INFINITY 1000000000
int n;
int L[MAX / 2 + 1], R[MAX / 2 + 1];
int sum(0);
void Merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
L[i] = A[left + i];
}
for (int i = 0; i < n2; i++) {
R[i] = A[mid + i];
}
L[n1] = INFINITY;
R[n2] = INFINITY;
int i = 0, j = 0;
for (int k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
sum++;
} else {
A[k] = R[j];
j++;
sum++;
}
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
Merge(A, left, mid, right);
}
}
int main() {
int A[MAX];
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &A[i]);
}
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", sum);
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <cstdio>
using namespace std;
#define INF 123456789;
int L[300000], R[300000];
int cnt;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INF;
R[n2] = INF;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main(void) {
int n, A[600000];
cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i > 0)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", cnt);
return 0;
}
|
#include <cstdio>
using namespace std;
#define INF 1234567890;
int L[300000], R[300000];
int cnt;
void merge(int A[], int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++)
L[i] = A[left + i];
for (int i = 0; i < n2; i++)
R[i] = A[mid + i];
L[n1] = INF;
R[n2] = INF;
int i = 0;
int j = 0;
for (int k = left; k < right; k++) {
cnt++;
if (L[i] <= R[j])
A[k] = L[i++];
else
A[k] = R[j++];
}
}
void mergeSort(int A[], int left, int right) {
if (left + 1 < right) {
int mid = (left + right) / 2;
mergeSort(A, left, mid);
mergeSort(A, mid, right);
merge(A, left, mid, right);
}
}
int main(void) {
int n, A[600000];
cnt = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++)
scanf("%d", &A[i]);
mergeSort(A, 0, n);
for (int i = 0; i < n; i++) {
if (i > 0)
printf(" ");
printf("%d", A[i]);
}
printf("\n%d\n", cnt);
return 0;
}
|
replace
| 3 | 4 | 3 | 4 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MAX_LEN 50000
#define BIG 2000000000
int L[MAX_LEN / 2 + 2], R[MAX_LEN / 2 + 2];
int cnt;
void merge_sort_helper(int *A, int n, int l, int m, int r) {
for (int i = l; i < m; ++i)
L[i - l] = A[i];
for (int i = m; i < r; ++i)
R[i - m] = A[i];
L[m - l] = R[r - m] = BIG;
int idx1(0), idx2(0);
for (int idx0 = l; idx0 < r; ++idx0) {
A[idx0] = (L[idx1] <= R[idx2]) ? L[idx1++] : R[idx2++];
cnt++;
}
}
void merge_sort(int *A, int n, int l, int r) {
if (l < r - 1) {
int m = l + (r - l) / 2;
merge_sort(A, n, l, m);
merge_sort(A, n, m, r);
merge_sort_helper(A, n, l, m, r);
}
}
int main() {
int A[MAX_LEN], n, i, val;
cnt = 0;
cin >> n;
i = 0;
while (cin >> A[i++])
;
merge_sort(A, n, 0, n);
for (int i = 0; i < n; ++i) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
#include <iostream>
#include <string>
#include <vector>
using namespace std;
#define MAX_LEN 500000
#define BIG 2000000000
int L[MAX_LEN / 2 + 2], R[MAX_LEN / 2 + 2];
int cnt;
void merge_sort_helper(int *A, int n, int l, int m, int r) {
for (int i = l; i < m; ++i)
L[i - l] = A[i];
for (int i = m; i < r; ++i)
R[i - m] = A[i];
L[m - l] = R[r - m] = BIG;
int idx1(0), idx2(0);
for (int idx0 = l; idx0 < r; ++idx0) {
A[idx0] = (L[idx1] <= R[idx2]) ? L[idx1++] : R[idx2++];
cnt++;
}
}
void merge_sort(int *A, int n, int l, int r) {
if (l < r - 1) {
int m = l + (r - l) / 2;
merge_sort(A, n, l, m);
merge_sort(A, n, m, r);
merge_sort_helper(A, n, l, m, r);
}
}
int main() {
int A[MAX_LEN], n, i, val;
cnt = 0;
cin >> n;
i = 0;
while (cin >> A[i++])
;
merge_sort(A, n, 0, n);
for (int i = 0; i < n; ++i) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl;
cout << cnt << endl;
return 0;
}
|
replace
| 6 | 7 | 6 | 7 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <iostream>
#include <math.h>
using namespace std;
#define FOR(k, m, n) for (int(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define LL long long
#define MAX 600000
#define SENTINEL 200000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
//?????????????????????LR?????\??????
REP(i, n1) L[i] = A[left + i];
REP(i, n2) R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
//??????????????????????°?????????????A???????????¶????????????
FOR(k, left, right) {
cnt++;
L[i] <= R[j] ? A[k] = L[i++] : A[k] = R[j++];
}
}
void mergeSort(int A[], int n, int left, int right) {
//????´???°???1??????????????§???????????????????????°
if (left + 1 < right) {
int mid = (left + right) / 2;
//?????°???????????????????????????????????????
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
//??????????????????2?????????????????????
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
REP(i, n) cin >> A[i];
mergeSort(A, n, 0, n);
REP(i, n) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl << cnt << endl;
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <math.h>
using namespace std;
#define FOR(k, m, n) for (int(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define LL long long
#define MAX 600000
#define SENTINEL 2000000000
int L[MAX / 2 + 2], R[MAX / 2 + 2];
int cnt;
void merge(int A[], int n, int left, int mid, int right) {
int n1 = mid - left;
int n2 = right - mid;
//?????????????????????LR?????\??????
REP(i, n1) L[i] = A[left + i];
REP(i, n2) R[i] = A[mid + i];
L[n1] = R[n2] = SENTINEL;
int i = 0, j = 0;
//??????????????????????°?????????????A???????????¶????????????
FOR(k, left, right) {
cnt++;
L[i] <= R[j] ? A[k] = L[i++] : A[k] = R[j++];
}
}
void mergeSort(int A[], int n, int left, int right) {
//????´???°???1??????????????§???????????????????????°
if (left + 1 < right) {
int mid = (left + right) / 2;
//?????°???????????????????????????????????????
mergeSort(A, n, left, mid);
mergeSort(A, n, mid, right);
//??????????????????2?????????????????????
merge(A, n, left, mid, right);
}
}
int main() {
int A[MAX], n, i;
cnt = 0;
cin >> n;
REP(i, n) cin >> A[i];
mergeSort(A, n, 0, n);
REP(i, n) {
if (i)
cout << " ";
cout << A[i];
}
cout << endl << cnt << endl;
return 0;
}
|
replace
| 10 | 11 | 10 | 11 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAXN 100000 + 2
int AA[MAXN], TT[MAXN];
int n, g = 0;
void input() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> AA[i];
}
}
void syf(int *A, int x, int y, int *T) {
if (y - x > 1) {
int m = (x + y) / 2;
int i = x, p = x, q = m;
syf(A, x, m, T);
syf(A, m, y, T);
while (p < m || q < y) {
if (q >= y || (p < m && A[p] <= A[q]))
T[i++] = A[p++];
else
T[i++] = A[q++];
g++;
}
for (int i = x; i < y; ++i) {
A[i] = T[i];
AA[i] = T[i];
}
}
}
int main() {
input();
syf(AA, 0, n, TT);
for (int i = 0; i < n - 1; ++i) {
cout << AA[i] << " ";
}
cout << AA[n - 1] << endl;
cout << g << endl;
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAXN 500000 + 2
int AA[MAXN], TT[MAXN];
int n, g = 0;
void input() {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> AA[i];
}
}
void syf(int *A, int x, int y, int *T) {
if (y - x > 1) {
int m = (x + y) / 2;
int i = x, p = x, q = m;
syf(A, x, m, T);
syf(A, m, y, T);
while (p < m || q < y) {
if (q >= y || (p < m && A[p] <= A[q]))
T[i++] = A[p++];
else
T[i++] = A[q++];
g++;
}
for (int i = x; i < y; ++i) {
A[i] = T[i];
AA[i] = T[i];
}
}
}
int main() {
input();
syf(AA, 0, n, TT);
for (int i = 0; i < n - 1; ++i) {
cout << AA[i] << " ";
}
cout << AA[n - 1] << endl;
cout << g << endl;
return 0;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02272
|
C++
|
Runtime Error
|
#include <stdio.h>
#define SIZE 500
#define INFTY 120000
int count = 0;
void show(int *a, int size) {
int i;
printf("%d", a[0]);
for (i = 1; i < size; i++)
printf(" %d", a[i]);
printf("\n");
}
void Merge(int *A, int left, int mid, int right) {
int R[SIZE], L[SIZE];
int i, j, k, n1, n2;
n1 = mid - left;
n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[i + left];
for (j = 0; j < n2; j++)
R[j] = A[j + mid];
L[n1] = INFTY;
R[n2] = INFTY;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
}
else {
A[k] = R[j];
j++;
}
count++;
}
}
void MergeSort(int *A, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
return;
}
int main() {
int i, n, S[SIZE];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &S[i]);
MergeSort(S, 0, n);
show(S, n);
printf("%d\n", count);
return 0;
}
|
#include <stdio.h>
#define SIZE 500000
#define INFTY 1200000000
int count = 0;
void show(int *a, int size) {
int i;
printf("%d", a[0]);
for (i = 1; i < size; i++)
printf(" %d", a[i]);
printf("\n");
}
void Merge(int *A, int left, int mid, int right) {
int R[SIZE], L[SIZE];
int i, j, k, n1, n2;
n1 = mid - left;
n2 = right - mid;
for (i = 0; i < n1; i++)
L[i] = A[i + left];
for (j = 0; j < n2; j++)
R[j] = A[j + mid];
L[n1] = INFTY;
R[n2] = INFTY;
i = j = 0;
for (k = left; k < right; k++) {
if (L[i] <= R[j]) {
A[k] = L[i];
i++;
}
else {
A[k] = R[j];
j++;
}
count++;
}
}
void MergeSort(int *A, int left, int right) {
int mid;
if (left + 1 < right) {
mid = (left + right) / 2;
MergeSort(A, left, mid);
MergeSort(A, mid, right);
Merge(A, left, mid, right);
}
return;
}
int main() {
int i, n, S[SIZE];
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &S[i]);
MergeSort(S, 0, n);
show(S, n);
printf("%d\n", count);
return 0;
}
|
replace
| 2 | 4 | 2 | 4 |
0
| |
p02273
|
C++
|
Runtime Error
|
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
// 常に心してかかれ
// 簡単なことを簡単にできるように練習する
// びっくりするくらいつまらないことで詰まってることも多い
int n; // 問題で設定された呼び出し階層の深さ
class dot {
public:
double x;
double y;
dot(double X, double Y) {
x = X;
y = Y;
}
};
void makeDots(dot A, dot B, int m) { // m:この関数の呼び出し元の呼び出し階層
double tmp_x;
double tmp_y;
tmp_x = A.x + (B.x - A.x) / 3;
tmp_y = A.y + (B.y - A.y) / 3;
dot P(tmp_x, tmp_y);
tmp_x = sqrt(3.0) * (B.x - A.x) - (B.y - A.y);
tmp_y = (B.x - A.x) + sqrt(3.0) * (B.y - A.y);
tmp_x = tmp_x / (2 * sqrt(3.0));
tmp_y = tmp_y / (2 * sqrt(3.0));
tmp_x += A.x;
tmp_y += A.y;
dot Q(tmp_x, tmp_y);
tmp_x = A.x + 2 * (B.x - A.x) / 3;
tmp_y = A.y + 2 * (B.y - A.y) / 3;
dot R(tmp_x, tmp_y);
m++;
if (m == n) {
cout << A.x << " " << A.y << endl;
cout << P.x << " " << P.y << endl;
cout << Q.x << " " << Q.y << endl;
cout << R.x << " " << R.y << endl;
return;
}
makeDots(A, P, m);
makeDots(P, Q, m);
makeDots(Q, R, m);
makeDots(R, B, m);
}
int main() {
dot A(0, 0);
dot B(100, 0);
cin >> n;
if (n == 0) {
cout << "0.00000000 0.00000000" << endl;
cout << "100.00000000 0.00000000" << endl;
}
makeDots(A, B, 0);
cout << 100 << " " << 0 << endl;
return 0;
}
|
#include <iostream>
#include <math.h>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
using namespace std;
// 常に心してかかれ
// 簡単なことを簡単にできるように練習する
// びっくりするくらいつまらないことで詰まってることも多い
int n; // 問題で設定された呼び出し階層の深さ
class dot {
public:
double x;
double y;
dot(double X, double Y) {
x = X;
y = Y;
}
};
void makeDots(dot A, dot B, int m) { // m:この関数の呼び出し元の呼び出し階層
double tmp_x;
double tmp_y;
tmp_x = A.x + (B.x - A.x) / 3;
tmp_y = A.y + (B.y - A.y) / 3;
dot P(tmp_x, tmp_y);
tmp_x = sqrt(3.0) * (B.x - A.x) - (B.y - A.y);
tmp_y = (B.x - A.x) + sqrt(3.0) * (B.y - A.y);
tmp_x = tmp_x / (2 * sqrt(3.0));
tmp_y = tmp_y / (2 * sqrt(3.0));
tmp_x += A.x;
tmp_y += A.y;
dot Q(tmp_x, tmp_y);
tmp_x = A.x + 2 * (B.x - A.x) / 3;
tmp_y = A.y + 2 * (B.y - A.y) / 3;
dot R(tmp_x, tmp_y);
m++;
if (m == n) {
cout << A.x << " " << A.y << endl;
cout << P.x << " " << P.y << endl;
cout << Q.x << " " << Q.y << endl;
cout << R.x << " " << R.y << endl;
return;
}
makeDots(A, P, m);
makeDots(P, Q, m);
makeDots(Q, R, m);
makeDots(R, B, m);
}
int main() {
dot A(0, 0);
dot B(100, 0);
cin >> n;
if (n == 0) {
cout << "0.00000000 0.00000000" << endl;
cout << "100.00000000 0.00000000" << endl;
return 0;
}
makeDots(A, B, 0);
cout << 100 << " " << 0 << endl;
return 0;
}
|
insert
| 68 | 68 | 68 | 69 |
0
| |
p02274
|
C++
|
Runtime Error
|
#include <algorithm>
#include <assert.h>
#include <iostream>
using namespace std;
#define int long long
int tempmarge[1000100];
int N, A[10000000];
int MargeSort(int x[], int left, int right) {
int mid, i, j, k, cl, cr, c;
if (left >= right)
return 0;
mid = (left + right) / 2;
cl = MargeSort(x, left, mid);
cr = MargeSort(x, mid + 1, right);
for (i = left; i <= mid; i++)
tempmarge[i] = x[i];
for (i = mid + 1, j = right; i <= right; i++, j--)
tempmarge[i] = x[j];
i = left;
j = right;
c = 0;
for (k = left; k <= right; k++)
if (tempmarge[i] <= tempmarge[j])
x[k] = tempmarge[i++];
else {
c += mid + 1 - i;
x[k] = tempmarge[j--];
}
return c + cl + cr;
}
signed main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
cout << MargeSort(A, 0, N - 1) << endl;
for (int i = 0; i < N; i++)
cerr << A[i] << endl;
return 0;
}
|
#include <algorithm>
#include <assert.h>
#include <iostream>
using namespace std;
#define int long long
int tempmarge[1000100];
int N, A[10000000];
int MargeSort(int x[], int left, int right) {
int mid, i, j, k, cl, cr, c;
if (left >= right)
return 0;
mid = (left + right) / 2;
cl = MargeSort(x, left, mid);
cr = MargeSort(x, mid + 1, right);
for (i = left; i <= mid; i++)
tempmarge[i] = x[i];
for (i = mid + 1, j = right; i <= right; i++, j--)
tempmarge[i] = x[j];
i = left;
j = right;
c = 0;
for (k = left; k <= right; k++)
if (tempmarge[i] <= tempmarge[j])
x[k] = tempmarge[i++];
else {
c += mid + 1 - i;
x[k] = tempmarge[j--];
}
return c + cl + cr;
}
signed main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
cout << MargeSort(A, 0, N - 1) << endl;
return 0;
}
|
delete
| 39 | 41 | 39 | 39 |
0
|
1
2
3
4
5
|
p02274
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF (1000000001)
int N;
int A[(1 << 21) + 1];
int T[(1 << 21) + 1];
ll res = 0;
void marge(int l, int r) {
if (r - l == 2) {
if (A[l] > A[r - 1]) {
res++;
swap(A[l], A[r - 1]);
}
} else {
int m = (l + r) / 2;
marge(l, m);
marge(m, r);
for (int i = l, j = m, k = l; k < r; k++) {
if ((j < r && A[i] > A[j]) || i == m) {
res += (m - i);
T[k] = A[j++];
} else {
T[k] = A[i++];
}
}
for (int i = l; i < r; i++)
A[i] = T[i];
}
/*
cout <<"( " << l << " , "<< r << " ) " << endl;
for(int i=l;i<r;i++) cout << A[i] << " ";
cout << endl;
cout << "res = "<< res << endl;
*/
}
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
int n = 1;
while (n < N)
n *= 2;
for (int i = N; i < n; i++)
A[i] = INF + i;
N = n;
marge(0, N);
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define INF (1000000001)
int N;
int A[(1 << 21) + 1];
int T[(1 << 21) + 1];
ll res = 0;
void marge(int l, int r) {
if (r - l == 2) {
if (A[l] > A[r - 1]) {
res++;
swap(A[l], A[r - 1]);
}
} else {
int m = (l + r) / 2;
marge(l, m);
marge(m, r);
for (int i = l, j = m, k = l; k < r; k++) {
if ((j < r && A[i] > A[j]) || i == m) {
res += (m - i);
T[k] = A[j++];
} else {
T[k] = A[i++];
}
}
for (int i = l; i < r; i++)
A[i] = T[i];
}
/*
cout <<"( " << l << " , "<< r << " ) " << endl;
for(int i=l;i<r;i++) cout << A[i] << " ";
cout << endl;
cout << "res = "<< res << endl;
*/
}
int main() {
cin >> N;
for (int i = 0; i < N; i++)
cin >> A[i];
if (N == 1)
cout << 0 << endl;
else {
int n = 1;
while (n < N)
n *= 2;
for (int i = N; i < n; i++)
A[i] = INF + i;
N = n;
marge(0, N);
cout << res << endl;
}
}
|
replace
| 42 | 50 | 42 | 54 |
0
| |
p02274
|
C++
|
Runtime Error
|
#include <cstdio>
#include <iostream>
using namespace std;
typedef long long LL;
const int maxn = 2e4 + 5;
const int sentinel = 0x3f3f3f3f;
int l[maxn / 2 + 2], r[maxn / 2 + 2], a[maxn], n;
LL merge(int left, int mid, int right) {
int i, j, k;
LL cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
l[i] = a[left + i];
}
for (int i = 0; i < n2; i++) {
r[i] = a[mid + i];
}
l[n1] = r[n2] = sentinel;
i = j = 0;
for (int k = left; k < right; k++) {
if (l[i] <= r[j]) {
a[k] = l[i++];
} else {
a[k] = r[j++];
cnt += n1 - i;
}
}
return cnt;
}
LL mergesort(int left, int right) {
int mid;
LL v1, v2, v3;
if (left + 1 < right) {
mid = (left + right) >> 1;
v1 = mergesort(left, mid);
v2 = mergesort(mid, right);
v3 = merge(left, mid, right);
return v1 + v2 + v3;
} else {
return 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
LL ans = mergesort(0, n);
cout << ans << endl;
return 0;
}
/*
5
3 5 2 1 4
*/
|
#include <cstdio>
#include <iostream>
using namespace std;
typedef long long LL;
const int maxn = 2e5 + 5;
const int sentinel = 0x3f3f3f3f;
int l[maxn / 2 + 2], r[maxn / 2 + 2], a[maxn], n;
LL merge(int left, int mid, int right) {
int i, j, k;
LL cnt = 0;
int n1 = mid - left;
int n2 = right - mid;
for (int i = 0; i < n1; i++) {
l[i] = a[left + i];
}
for (int i = 0; i < n2; i++) {
r[i] = a[mid + i];
}
l[n1] = r[n2] = sentinel;
i = j = 0;
for (int k = left; k < right; k++) {
if (l[i] <= r[j]) {
a[k] = l[i++];
} else {
a[k] = r[j++];
cnt += n1 - i;
}
}
return cnt;
}
LL mergesort(int left, int right) {
int mid;
LL v1, v2, v3;
if (left + 1 < right) {
mid = (left + right) >> 1;
v1 = mergesort(left, mid);
v2 = mergesort(mid, right);
v3 = merge(left, mid, right);
return v1 + v2 + v3;
} else {
return 0;
}
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
LL ans = mergesort(0, n);
cout << ans << endl;
return 0;
}
/*
5
3 5 2 1 4
*/
|
replace
| 8 | 9 | 8 | 9 |
0
| |
p02274
|
C++
|
Runtime Error
|
#include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
#pragma warning(disable : 4996)
int a[101010], n;
struct BIT {
int bit[202020];
void init() { REP(i, 202020) bit[i] = 0; }
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= 202020) {
bit[i] += x;
i += i & -i;
}
}
};
vector<pair<LL, LL>> v;
int main() {
BIT bit;
bit.init();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.emplace_back(make_pair(a[i], i));
}
sort(ALL(v));
REP(i, n) { a[v[i].second] = i + 1; }
LL ans = 0;
for (int j = 0; j < n; j++) {
ans += j - bit.sum(a[j]);
bit.add(a[j], 1);
}
cout << ans << endl;
}
|
#include "bits/stdc++.h"
using namespace std;
using LL = long long;
using ULL = unsigned long long;
const double PI = acos(-1);
template <class T> constexpr T INF() { return ::std::numeric_limits<T>::max(); }
template <class T> constexpr T HINF() { return INF<T>() / 2; }
template <typename T_char> T_char TL(T_char cX) { return tolower(cX); };
template <typename T_char> T_char TU(T_char cX) { return toupper(cX); };
typedef pair<LL, LL> pii;
const int vy[] = {-1, -1, -1, 0, 1, 1, 1, 0},
vx[] = {-1, 0, 1, 1, 1, 0, -1, -1};
const int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
int popcnt(unsigned long long n) {
int cnt = 0;
for (int i = 0; i < 64; i++)
if ((n >> i) & 1)
cnt++;
return cnt;
}
int d_sum(LL n) {
int ret = 0;
while (n > 0) {
ret += n % 10;
n /= 10;
}
return ret;
}
int d_cnt(LL n) {
int ret = 0;
while (n > 0) {
ret++;
n /= 10;
}
return ret;
}
LL gcd(LL a, LL b) {
if (b == 0)
return a;
return gcd(b, a % b);
};
LL lcm(LL a, LL b) {
LL g = gcd(a, b);
return a / g * b;
};
#define ALL(qpqpq) (qpqpq).begin(), (qpqpq).end()
#define UNIQUE(wpwpw) \
sort(ALL((wpwpw))); \
(wpwpw).erase(unique(ALL((wpwpw))), (wpwpw).end())
#define LOWER(epepe) transform(ALL((epepe)), (epepe).begin(), TL<char>)
#define UPPER(rprpr) transform(ALL((rprpr)), (rprpr).begin(), TU<char>)
#define FOR(i, tptpt, ypypy) for (LL i = (tptpt); i < (ypypy); i++)
#define REP(i, upupu) FOR(i, 0, upupu)
#define INIT \
std::ios::sync_with_stdio(false); \
std::cin.tie(0)
#pragma warning(disable : 4996)
int a[202020], n;
struct BIT {
int bit[202020];
void init() { REP(i, 202020) bit[i] = 0; }
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= 202020) {
bit[i] += x;
i += i & -i;
}
}
};
vector<pair<LL, LL>> v;
int main() {
BIT bit;
bit.init();
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
v.emplace_back(make_pair(a[i], i));
}
sort(ALL(v));
REP(i, n) { a[v[i].second] = i + 1; }
LL ans = 0;
for (int j = 0; j < n; j++) {
ans += j - bit.sum(a[j]);
bit.add(a[j], 1);
}
cout << ans << endl;
}
|
replace
| 58 | 59 | 58 | 59 |
0
| |
p02274
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
template <class V, int ME> class BIT {
public:
V bit[1 << ME];
V total(int e) {
V s = 0;
e++;
while (e)
s += bit[e - 1], e -= e & -e;
return s;
}
void update(int e, V val) {
e++;
while (e <= 1 << ME)
bit[e - 1] += val, e += e & -e;
}
};
int main() {
int N, tmp;
cin >> N;
vector<int> inputs(N), rank(N);
vector<pii> x(N);
REP(i, N) {
cin >> x[i].first;
x[i].second = i;
}
sort(x.begin(), x.end());
REP(i, N) { rank[x[i].second] = i + 1; }
REP(i, N) { inputs[--rank[i]] = i; }
BIT<int, 17> bit;
ll res = 0;
REP(i, N) {
bit.update(inputs[i], 1);
// cout << bit.total(N) - bit.total(inputs[i]) << endl;
res += (bit.total(N) - bit.total(inputs[i]));
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef unsigned long long ull;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
const ull mod = 1e9 + 7;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
template <class V, int ME> class BIT {
public:
V bit[1 << ME];
V total(int e) {
V s = 0;
e++;
while (e)
s += bit[e - 1], e -= e & -e;
return s;
}
void update(int e, V val) {
e++;
while (e <= 1 << ME)
bit[e - 1] += val, e += e & -e;
}
};
int main() {
int N, tmp;
cin >> N;
vector<int> inputs(N), rank(N);
vector<pii> x(N);
REP(i, N) {
cin >> x[i].first;
x[i].second = i;
}
sort(x.begin(), x.end());
REP(i, N) { rank[x[i].second] = i + 1; }
REP(i, N) { inputs[--rank[i]] = i; }
BIT<int, 19> bit;
ll res = 0;
REP(i, N) {
bit.update(inputs[i], 1);
// cout << bit.total(N) - bit.total(inputs[i]) << endl;
res += (bit.total(N) - bit.total(inputs[i]));
}
cout << res << endl;
return 0;
}
|
replace
| 42 | 43 | 42 | 43 |
0
| |
p02274
|
C++
|
Runtime Error
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 100010;
int bit[MAX_N], n_, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int a[MAX_N], b[MAX_N];
P c[MAX_N];
int main() {
ll ans = 0;
cin >> n;
// n_=1;
// while(n_ < n) n_ *=2;
for (int j = 0; j < n; j++) {
cin >> b[j];
c[j] = P(b[j], j);
}
sort(c, c + n);
for (int j = 0; j < n; j++) {
c[j].first = j + 1;
swap(c[j].first, c[j].second);
}
sort(c, c + n);
for (int j = 0; j < n; j++) {
a[j] = c[j].second;
}
for (int j = 0; j < n; j++) {
ans += j - sum(a[j]);
add(a[j], 1);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
const int MAX_N = 1000100;
int bit[MAX_N], n_, n;
int sum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i, int x) {
while (i <= n) {
bit[i] += x;
i += i & -i;
}
}
int a[MAX_N], b[MAX_N];
P c[MAX_N];
int main() {
ll ans = 0;
cin >> n;
// n_=1;
// while(n_ < n) n_ *=2;
for (int j = 0; j < n; j++) {
cin >> b[j];
c[j] = P(b[j], j);
}
sort(c, c + n);
for (int j = 0; j < n; j++) {
c[j].first = j + 1;
swap(c[j].first, c[j].second);
}
sort(c, c + n);
for (int j = 0; j < n; j++) {
a[j] = c[j].second;
}
for (int j = 0; j < n; j++) {
ans += j - sum(a[j]);
add(a[j], 1);
}
cout << ans << endl;
}
|
replace
| 4 | 5 | 4 | 5 |
0
| |
p02274
|
Python
|
Time Limit Exceeded
|
n = int(input())
nd = list(map(int, input().split()))
c = 0
for i in range(n):
m = min(nd)
index = nd.index(m)
nd.remove(m)
c += index
print(c)
|
n = int(input())
nlist = list(map(int, input().split()))
W = [0 for i in range(n)]
def M(l, r): ##l~r-1 까지의 리스트.
if l + 1 >= r:
return 0
elif l + 2 == r:
if nlist[l] <= nlist[l + 1]:
return 0
else:
nlist[l], nlist[l + 1] = nlist[l + 1], nlist[l]
return 1
##위의 if문으로 (r-l)가 2이하일 경우는 해놓음
m = (l + r) // 2
i = l
j = m
k = l
cl = M(l, m)
cr = M(m, r)
c = 0
while i < m and j < r:
if nlist[i] <= nlist[j]:
W[k] = nlist[i] ##l부터 r까지 W에 크기순으로 대입해나감
k += 1
i += 1
else:
W[k] = nlist[j] ##일단 W[k]에는 더 작은쪽을 저장하는듯
k += 1
j += 1
c += m - i ##만약 nlist[i] > nlist[j]라면 i~m-1 까지 반전 하고있기 때문
##그러고 더 작은 nlist[j]를 안에 넣는것.
while i < m: ##i번째쪽에 더 큰것들이 남았을 경우 (j=r 이 되있는 상황이기에 더 반전수를 늘리지는 않음)
W[k] = nlist[i]
k += 1
i += 1
while j < r: ##j쪽에 큰게 남아있는경우도 동일
W[k] = nlist[j]
k += 1
j += 1
for i in range(l, r):
nlist[i] = W[i]
return cl + cr + c
print(M(0, n))
|
replace
| 1 | 9 | 1 | 47 |
TLE
| |
p02275
|
C++
|
Runtime Error
|
#include <iostream>
#define N 1000000
using namespace std;
int main() {
int i, j, n, k = 0;
int A[N], B[N], C[N];
cin >> n;
for (i = 0; i < n; ++i) {
cin >> A[i];
if (A[i] > k)
k = A[i];
}
for (i = 0; i <= k; ++i)
C[i] = 0;
for (i = 0; i < n; ++i)
C[A[i]]++;
for (i = 0; i <= k; ++i)
C[i] += C[i - 1];
for (j = n - 1; j >= 0; --j) {
B[C[A[j]] - 1] = A[j];
C[A[j]]--;
}
for (i = 0; i < n; ++i) {
cout << B[i];
if (i != n - 1)
cout << " ";
}
cout << "\n";
return 0;
}
|
#include <iostream>
#define N 2000000
using namespace std;
int main() {
int i, j, n, k = 0;
int A[N], B[N], C[N];
cin >> n;
for (i = 0; i < n; ++i) {
cin >> A[i];
if (A[i] > k)
k = A[i];
}
for (i = 0; i <= k; ++i)
C[i] = 0;
for (i = 0; i < n; ++i)
C[A[i]]++;
for (i = 0; i <= k; ++i)
C[i] += C[i - 1];
for (j = n - 1; j >= 0; --j) {
B[C[A[j]] - 1] = A[j];
C[A[j]]--;
}
for (i = 0; i < n; ++i) {
cout << B[i];
if (i != n - 1)
cout << " ";
}
cout << "\n";
return 0;
}
|
replace
| 1 | 2 | 1 | 2 |
-11
| |
p02275
|
C++
|
Runtime Error
|
#include "iostream"
using namespace std;
int main() {
int in[2000000];
int ans[2000000];
int co[10001];
int n;
cin >> n;
for (int i = 0; i <= 10000; i++) {
co[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> in[i];
co[in[i]]++;
}
co[0]--;
for (int i = 1; i <= 10000; i++) {
co[i] += co[i - 1];
}
for (int i = 0; i < n; i++) {
ans[co[in[i]]] = in[i];
co[in[i]]--;
}
for (int i = 0; i < n; i++) {
cout << ans[i];
if (i < n - 1)
cout << " ";
}
cout << endl;
return 0;
}
|
#include "iostream"
using namespace std;
int main() {
short in[2000000];
short ans[2000000];
int co[10001];
int n;
cin >> n;
for (int i = 0; i <= 10000; i++) {
co[i] = 0;
}
for (int i = 0; i < n; i++) {
cin >> in[i];
co[in[i]]++;
}
co[0]--;
for (int i = 1; i <= 10000; i++) {
co[i] += co[i - 1];
}
for (int i = 0; i < n; i++) {
ans[co[in[i]]] = in[i];
co[in[i]]--;
}
for (int i = 0; i < n; i++) {
cout << ans[i];
if (i < n - 1)
cout << " ";
}
cout << endl;
return 0;
}
|
replace
| 6 | 8 | 6 | 8 |
-11
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.