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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p00255 | C++ | Runtime Error | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 1000
void calc(int n) {
int p, sump = 0;
int joi[SIZE];
for (int i = 0; i < n; i++) {
scanf("%d", &p);
sump += p;
}
for (int i = 0; i < n - 1; i++) {
scanf("%d", joi + i);
}
sort(joi, joi + n - 1);
ll ans = (ll)sump * n;
for (int i = n - 2; i >= 0; i--) {
sump += joi[i];
ans = max(ans, (ll)sump * (i + 1));
}
printf("%lld\n", ans);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
if (n == 0)
break;
calc(n);
}
return 0;
} | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 65010
void calc(int n) {
int p, sump = 0;
int joi[SIZE];
for (int i = 0; i < n; i++) {
scanf("%d", &p);
sump += p;
}
for (int i = 0; i < n - 1; i++) {
scanf("%d", joi + i);
}
sort(joi, joi + n - 1);
ll ans = (ll)sump * n;
for (int i = n - 2; i >= 0; i--) {
sump += joi[i];
ans = max(ans, (ll)sump * (i + 1));
}
printf("%lld\n", ans);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
if (n == 0)
break;
calc(n);
}
return 0;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p00255 | C++ | Time Limit Exceeded | #include <algorithm>
#include <functional>
#include <stdio.h>
using namespace std;
int main(void) {
int n, i, e, h[10000];
unsigned int x, z, a, w;
while (1) {
w = 0;
scanf("%d", &n);
if (n == 0)
break;
for (i = 0; i < n; i++) {
scanf("%d", &e);
w += e;
}
for (i = 0; i < n - 1; i++) {
scanf("%d", &h[i]);
}
sort(h, h + n - 1, greater<int>());
x = n * w;
z = w;
for (i = 0; i < n - 1; i++) {
z = z + h[i];
a = (n - (i + 1)) * z;
if (a > x) {
x = a;
}
}
printf("%u\n", x);
}
return 0;
} | #include <algorithm>
#include <functional>
#include <stdio.h>
using namespace std;
int main(void) {
int n, i, e, h[65000];
unsigned int x, z, a, w;
while (1) {
w = 0;
scanf("%d", &n);
if (n == 0)
break;
for (i = 0; i < n; i++) {
scanf("%d", &e);
w += e;
}
for (i = 0; i < n - 1; i++) {
scanf("%d", &h[i]);
}
sort(h, h + n - 1, greater<int>());
x = n * w;
z = w;
for (i = 0; i < n - 1; i++) {
z = z + h[i];
a = (n - (i + 1)) * z;
if (a > x) {
x = a;
}
}
printf("%u\n", x);
}
return 0;
} | replace | 6 | 7 | 6 | 7 | TLE | |
p00256 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct S {
ll y, m, d;
};
struct Ma {
ll b, ka, t, w, ki;
};
// 12,1,2,3...11
int M[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(ll y) { return (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)); }
S M2S(ll b, ll ka, ll t, ll w, ll ki) {
ka += b * 20;
t += ka * 20;
w += t * 18;
ki += w * 20;
S res;
res.y = 2012, res.m = 12, res.d = 21 + ki;
if (res.d <= 31)
return res;
while (res.d / (365 + check(res.y + 1)))
res.y++, res.d -= (365 + check(res.y));
assert(res.d != 0);
if (res.d <= 31)
return res;
res.y++, res.m = 1, res.d -= 31;
while (res.d / (M[res.m - 1] + (check(res.y) && res.m == 2))) {
res.d -= (M[res.m - 1] + (check(res.y) && res.m == 2));
res.m++;
}
if (res.d == 0)
res.m--, res.d = M[res.m - 1] + (check(res.y) && res.m == 2);
return res;
}
Ma S2M(ll y, ll m, ll d) {
y -= 2012;
if (y)
d += 10;
else
d = (d - 21);
for (int i = 0; i < m - 1 && y; i++)
d += (M[i] + (i == 1 && check(y + 2012)));
y--;
while (y > 0)
d += (365 + check(y + 2012)), y--;
Ma res;
d %= 13 * 20 * 20 * 18 * 20;
res.ki = d;
res.w = res.ki / 20;
res.ki %= 20;
res.t = res.w / 18;
res.w %= 18;
res.ka = res.t / 20;
res.t %= 20;
res.b = res.ka / 20;
res.ka %= 20;
return res;
}
int main() {
while (1) {
string str;
cin >> str;
if (str == "#")
break;
vector<int> a;
int i = 0, num = 0;
while (str[i]) {
if (str[i] == '.')
a.push_back(num), num = 0;
else
num = num * 10 + str[i] - '0';
i++;
}
a.push_back(num);
if (a.size() == 5) {
S ans = M2S(a[0], a[1], a[2], a[3], a[4]);
cout << ans.y << "." << ans.m << "." << ans.d << endl;
} else {
Ma ans = S2M(a[0], a[1], a[2]);
cout << ans.b << "." << ans.ka << "." << ans.t << "." << ans.w << "."
<< ans.ki << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct S {
ll y, m, d;
};
struct Ma {
ll b, ka, t, w, ki;
};
// 12,1,2,3...11
int M[] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
bool check(ll y) { return (y % 4 == 0 && (y % 100 != 0 || y % 400 == 0)); }
S M2S(ll b, ll ka, ll t, ll w, ll ki) {
ka += b * 20;
t += ka * 20;
w += t * 18;
ki += w * 20;
S res;
res.y = 2012, res.m = 12, res.d = 21 + ki;
if (res.d <= 31)
return res;
while (res.d / (365 + check(res.y + 1)))
res.y++, res.d -= (365 + check(res.y));
if (res.d == 0)
res.m--, res.d = M[res.m - 1] + (check(res.y) && res.m == 2);
if (res.d <= 31)
return res;
res.y++, res.m = 1, res.d -= 31;
while (res.d / (M[res.m - 1] + (check(res.y) && res.m == 2))) {
res.d -= (M[res.m - 1] + (check(res.y) && res.m == 2));
res.m++;
}
if (res.d == 0)
res.m--, res.d = M[res.m - 1] + (check(res.y) && res.m == 2);
return res;
}
Ma S2M(ll y, ll m, ll d) {
y -= 2012;
if (y)
d += 10;
else
d = (d - 21);
for (int i = 0; i < m - 1 && y; i++)
d += (M[i] + (i == 1 && check(y + 2012)));
y--;
while (y > 0)
d += (365 + check(y + 2012)), y--;
Ma res;
d %= 13 * 20 * 20 * 18 * 20;
res.ki = d;
res.w = res.ki / 20;
res.ki %= 20;
res.t = res.w / 18;
res.w %= 18;
res.ka = res.t / 20;
res.t %= 20;
res.b = res.ka / 20;
res.ka %= 20;
return res;
}
int main() {
while (1) {
string str;
cin >> str;
if (str == "#")
break;
vector<int> a;
int i = 0, num = 0;
while (str[i]) {
if (str[i] == '.')
a.push_back(num), num = 0;
else
num = num * 10 + str[i] - '0';
i++;
}
a.push_back(num);
if (a.size() == 5) {
S ans = M2S(a[0], a[1], a[2], a[3], a[4]);
cout << ans.y << "." << ans.m << "." << ans.d << endl;
} else {
Ma ans = S2M(a[0], a[1], a[2]);
cout << ans.b << "." << ans.ka << "." << ans.t << "." << ans.w << "."
<< ans.ki << endl;
}
}
return 0;
} | replace | 27 | 28 | 27 | 29 | 0 | |
p00256 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, a) for (int i = 0; i != (a); ++i)
#define repd(i, a) for (int i = (a); i >= 0; --i)
const int units[4] = {20, 18, 20, 20}, cycle = 13 * 20 * 20 * 20 * 18;
typedef long long ll;
bool isLeap(int y) { return (y % 4 == 0 && y % 100) || y % 400 == 0; }
int dayOfMonth(int y, int m) {
switch (m) {
case 2:
if (isLeap(y))
return 29;
else
return 28;
case 4:
case 6:
case 9:
case 11:
return 30;
default:
return 31;
}
}
// y2/m2/d2 - y1/m1/d1
ll countD(int y1, int m1, int d1, int y2, int m2, int d2) {
ll ret = 0;
while (true) {
if (y1 == y2 && m1 == m2) {
ret += d2 - d1;
break;
} else if (y1 == y2) {
ret += dayOfMonth(y1, m1) - d1 + 1;
d1 = 1;
++m1;
if (m1 > 12)
m1 = 1, ++y1;
} else {
ret += 28 + 30 * 4 + 31 * 7 + isLeap(y1) - countD(y1, 1, 1, y1, m1, d1);
++y1;
m1 = 1;
d1 = 1;
}
}
return ret;
}
void advD(int &y, int &m, int &d, ll days) {
while (true) {
int lim = dayOfMonth(y, m) - d + 1;
if (days < lim) {
d += days;
break;
}
days -= lim;
d = 1;
++m;
if (m > 12)
m = 1, ++y;
}
return;
}
int main() {
std::string s;
while (std::cin >> s, s != "#") {
// y.m.d
if (std::count(s.begin(), s.end(), '.') == 2) {
int y, m, d;
sscanf(s.c_str(), "%d.%d.%d", &y, &m, &d);
ll days = countD(2012, 12, 21, y, m, d);
days %= cycle;
std::vector<ll> v;
rep(i, 4) {
v.push_back(days % units[i]);
days /= units[i];
}
v.push_back(days);
repd(i, 4) printf("%lld%c", v[i], ".\n"[!i]);
}
// b.ka.t.w.ki
else {
int a[5];
sscanf(s.c_str(), "%d.%d.%d.%d.%d", a, a + 1, a + 2, a + 3, a + 4);
int days = 0;
repd(i, 5) {
days += a[4 - i];
if (i)
days *= units[i - 1];
}
int y = 2012, m = 12, d = 21;
advD(y, m, d, days);
printf("%d.%d.%d\n", y, m, d);
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
#include <vector>
#define rep(i, a) for (int i = 0; i != (a); ++i)
#define repd(i, a) for (int i = (a); i >= 0; --i)
const int units[4] = {20, 18, 20, 20}, cycle = 13 * 20 * 20 * 20 * 18;
typedef long long ll;
bool isLeap(int y) { return (y % 4 == 0 && y % 100) || y % 400 == 0; }
int dayOfMonth(int y, int m) {
switch (m) {
case 2:
if (isLeap(y))
return 29;
else
return 28;
case 4:
case 6:
case 9:
case 11:
return 30;
default:
return 31;
}
}
// y2/m2/d2 - y1/m1/d1
ll countD(int y1, int m1, int d1, int y2, int m2, int d2) {
ll ret = 0;
while (true) {
if (y1 == y2 && m1 == m2) {
ret += d2 - d1;
break;
} else if (y1 == y2) {
ret += dayOfMonth(y1, m1) - d1 + 1;
d1 = 1;
++m1;
if (m1 > 12)
m1 = 1, ++y1;
} else if (y2 - y1 > 1000) {
ret += (28 + 30 * 4 + 31 * 7) * 1000;
rep(i, 1000) ret += isLeap(y1 + i + 1);
ret -= countD(y1, 1, 1, y1, m1, d1);
y1 += 1000;
m1 = 1;
d1 = 1;
} else {
ret += 28 + 30 * 4 + 31 * 7 + isLeap(y1) - countD(y1, 1, 1, y1, m1, d1);
++y1;
m1 = 1;
d1 = 1;
}
}
return ret;
}
void advD(int &y, int &m, int &d, ll days) {
while (true) {
int lim = dayOfMonth(y, m) - d + 1;
if (days < lim) {
d += days;
break;
}
days -= lim;
d = 1;
++m;
if (m > 12)
m = 1, ++y;
}
return;
}
int main() {
std::string s;
while (std::cin >> s, s != "#") {
// y.m.d
if (std::count(s.begin(), s.end(), '.') == 2) {
int y, m, d;
sscanf(s.c_str(), "%d.%d.%d", &y, &m, &d);
ll days = countD(2012, 12, 21, y, m, d);
days %= cycle;
std::vector<ll> v;
rep(i, 4) {
v.push_back(days % units[i]);
days /= units[i];
}
v.push_back(days);
repd(i, 4) printf("%lld%c", v[i], ".\n"[!i]);
}
// b.ka.t.w.ki
else {
int a[5];
sscanf(s.c_str(), "%d.%d.%d.%d.%d", a, a + 1, a + 2, a + 3, a + 4);
int days = 0;
repd(i, 5) {
days += a[4 - i];
if (i)
days *= units[i - 1];
}
int y = 2012, m = 12, d = 21;
advD(y, m, d, days);
printf("%d.%d.%d\n", y, m, d);
}
}
return 0;
} | insert | 44 | 44 | 44 | 51 | TLE | |
p00256 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
// adjust problem by problem
const double EPS = 1e-8;
const double PI = acos(-1.0);
#ifdef __GNUC__
int popcount(int n) { return __builtin_popcount(n); }
int popcount(ll n) { return __builtin_popcountll(n); }
#endif
#ifndef __GNUC__
template <class T> int popcount(T n) {
int cnt = 0;
while (n) {
if (n % 2)
cnt++;
n /= 2;
}
return cnt;
}
#endif
template <class T> int SIZE(T a) { return a.size(); }
template <class T> string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T> T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++)
res = (res * 10 + str[i] - '0');
return res;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0)
res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
ll sumd[10000011];
const int md[2][12] = {{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
bool isLeap(int y) { return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0); }
int main() {
// テァツエツッテァツゥツ硬ay
for (int y = 2013; y <= 10000010; y++) {
if (isLeap(y))
sumd[y] = sumd[y - 1] + 366;
else
sumd[y] = sumd[y - 1] + 365;
}
string str;
while (getline(cin, str) && str != "#") {
int dot = 0;
for (int i = 0; i < (int)str.size(); i++) {
if (str[i] == '.')
dot++;
}
// s to m
if (dot == 2) {
vector<string> v = split(str, '.');
vector<int> vv;
for (int i = 0; i < (int)v.size(); i++)
vv.push_back(StringToInt<int>(v[i]));
ll pday = 0;
// 2012,12.21テ」ツ?凝」ツつ嘉・ツ按敕」ツつ?」ツ?ヲテ、ツスツ陛ヲツ猟・テァツオツ古ゥツ?偲」ツ?療」ツ?淌」ツ?凝」ツつ津ィツィツ暗ァツョツ療」ツ??
// テ」ツ?敕」ツ?ョテ・ツ?、テ」ツつ津ァツ板ィテ」ツ??」ツ?ヲテ」ツδ榲」ツδ、テヲツ堋ヲテ」ツ?ォテ・ツ、ツ嘉ヲツ渉?
if (vv[0] == 2012 && vv[1] == 12)
pday += vv[2] - 21;
else {
pday += 10;
pday += sumd[vv[0] - 1];
int c = isLeap(vv[0]);
for (int i = 0; i < 12; i++) {
if (vv[1] == i + 1) {
pday += vv[2];
break;
} else {
pday += md[c][i];
}
}
}
pday %= (ll)13 * 20 * 20 * 18 * 20;
// cout<<pday<<endl;
// pdayテ」ツつ津・ツ、ツ嘉ヲツ渉?
vector<int> res;
res.push_back(pday / (20 * 18 * 20 * 20));
pday %= (20 * 18 * 20 * 20);
res.push_back(pday / (20 * 18 * 20));
pday %= 20 * 18 * 20;
res.push_back(pday / (20 * 18));
pday %= 20 * 18;
res.push_back(pday / 20);
pday %= 20;
res.push_back(pday);
for (int i = 0; i < (int)res.size(); i++) {
cout << res[i];
if (i == (int)res.size() - 1)
cout << endl;
else
cout << ".";
}
}
// m to s
else {
vector<string> v = split(str, '.');
vector<int> vv;
for (int i = 0; i < (int)v.size(); i++)
vv.push_back(StringToInt<int>(v[i]));
ll sum = 0;
sum = sum + vv[0];
sum = sum * 20 + vv[1];
sum = sum * 20 + vv[2];
sum = sum * 18 + vv[3];
sum = sum * 20 + vv[4];
// 2012,12,21テ」ツ?凝」ツつ嘉」ツ?ョテァツオツ古ゥツ?仕ayテ」ツつ痴umテ」ツ?ィテ」ツ?凖」ツつ?
if (sum <= 10)
cout << 2012 << "." << 12 << "." << 21 + sum << endl;
else {
sum -= 10;
// テ」ツ?禿」ツ?禿」ツ?凝」ツつ嘉ァツエツッテァツゥツ酵earテ」ツつ津、ツスツソテ」ツ?」テ」ツ?ヲテ、ツコツ古・ツ按?ヲツ篠「テァツエツ「テ」ツ?ァテ」ツ??、ツスツ陛・ツケツエテ」ツ?セテ」ツ?ァテゥツ?イテ」ツつ?」ツつ凝」ツ?凝ィツェツソテ」ツ?ケテ」ツつ?
int ub = 10000010;
int lb = 2012;
while (ub - lb > 1) {
int mid = (ub + lb) / 2;
if (sumd[mid] >= sum)
ub = mid;
else
lb = mid;
}
// ubテ・ツケツエテ」ツ?古」ツ??ィツカツ?」ツ?暗」ツつ凝ヲツ慊?・ツ按敕」ツ?ョテ・ツケツエテ」ツ?ェテ」ツ?ョテ」ツ?ァ
// ub-1テ・ツケツエテ」ツ?セテ」ツ?ァテ・ツケツエテ」ツつ津ゥツ?イテ」ツつ?」ツ?ヲテ」ツ?甘」ツ??
sum -= sumd[ub - 1];
int resy = ub;
int c = isLeap(resy);
int resm, resd;
for (int i = 0; i < 12; i++) {
if (sum <= md[c][i]) {
resm = i + 1;
resd = sum;
break;
} else
sum -= md[c][i];
}
cout << resy << "." << resm << "." << resd << endl;
}
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
// adjust problem by problem
const double EPS = 1e-8;
const double PI = acos(-1.0);
#ifdef __GNUC__
int popcount(int n) { return __builtin_popcount(n); }
int popcount(ll n) { return __builtin_popcountll(n); }
#endif
#ifndef __GNUC__
template <class T> int popcount(T n) {
int cnt = 0;
while (n) {
if (n % 2)
cnt++;
n /= 2;
}
return cnt;
}
#endif
template <class T> int SIZE(T a) { return a.size(); }
template <class T> string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T> T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++)
res = (res * 10 + str[i] - '0');
return res;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0)
res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
unsigned int sumd[10000011];
const int md[2][12] = {{31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31},
{31, 29, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31}};
bool isLeap(int y) { return y % 4 == 0 && (y % 100 != 0 || y % 400 == 0); }
int main() {
// テァツエツッテァツゥツ硬ay
for (int y = 2013; y <= 10000010; y++) {
if (isLeap(y))
sumd[y] = sumd[y - 1] + 366;
else
sumd[y] = sumd[y - 1] + 365;
}
string str;
while (getline(cin, str) && str != "#") {
int dot = 0;
for (int i = 0; i < (int)str.size(); i++) {
if (str[i] == '.')
dot++;
}
// s to m
if (dot == 2) {
vector<string> v = split(str, '.');
vector<int> vv;
for (int i = 0; i < (int)v.size(); i++)
vv.push_back(StringToInt<int>(v[i]));
ll pday = 0;
// 2012,12.21テ」ツ?凝」ツつ嘉・ツ按敕」ツつ?」ツ?ヲテ、ツスツ陛ヲツ猟・テァツオツ古ゥツ?偲」ツ?療」ツ?淌」ツ?凝」ツつ津ィツィツ暗ァツョツ療」ツ??
// テ」ツ?敕」ツ?ョテ・ツ?、テ」ツつ津ァツ板ィテ」ツ??」ツ?ヲテ」ツδ榲」ツδ、テヲツ堋ヲテ」ツ?ォテ・ツ、ツ嘉ヲツ渉?
if (vv[0] == 2012 && vv[1] == 12)
pday += vv[2] - 21;
else {
pday += 10;
pday += sumd[vv[0] - 1];
int c = isLeap(vv[0]);
for (int i = 0; i < 12; i++) {
if (vv[1] == i + 1) {
pday += vv[2];
break;
} else {
pday += md[c][i];
}
}
}
pday %= (ll)13 * 20 * 20 * 18 * 20;
// cout<<pday<<endl;
// pdayテ」ツつ津・ツ、ツ嘉ヲツ渉?
vector<int> res;
res.push_back(pday / (20 * 18 * 20 * 20));
pday %= (20 * 18 * 20 * 20);
res.push_back(pday / (20 * 18 * 20));
pday %= 20 * 18 * 20;
res.push_back(pday / (20 * 18));
pday %= 20 * 18;
res.push_back(pday / 20);
pday %= 20;
res.push_back(pday);
for (int i = 0; i < (int)res.size(); i++) {
cout << res[i];
if (i == (int)res.size() - 1)
cout << endl;
else
cout << ".";
}
}
// m to s
else {
vector<string> v = split(str, '.');
vector<int> vv;
for (int i = 0; i < (int)v.size(); i++)
vv.push_back(StringToInt<int>(v[i]));
ll sum = 0;
sum = sum + vv[0];
sum = sum * 20 + vv[1];
sum = sum * 20 + vv[2];
sum = sum * 18 + vv[3];
sum = sum * 20 + vv[4];
// 2012,12,21テ」ツ?凝」ツつ嘉」ツ?ョテァツオツ古ゥツ?仕ayテ」ツつ痴umテ」ツ?ィテ」ツ?凖」ツつ?
if (sum <= 10)
cout << 2012 << "." << 12 << "." << 21 + sum << endl;
else {
sum -= 10;
// テ」ツ?禿」ツ?禿」ツ?凝」ツつ嘉ァツエツッテァツゥツ酵earテ」ツつ津、ツスツソテ」ツ?」テ」ツ?ヲテ、ツコツ古・ツ按?ヲツ篠「テァツエツ「テ」ツ?ァテ」ツ??、ツスツ陛・ツケツエテ」ツ?セテ」ツ?ァテゥツ?イテ」ツつ?」ツつ凝」ツ?凝ィツェツソテ」ツ?ケテ」ツつ?
int ub = 10000010;
int lb = 2012;
while (ub - lb > 1) {
int mid = (ub + lb) / 2;
if (sumd[mid] >= sum)
ub = mid;
else
lb = mid;
}
// ubテ・ツケツエテ」ツ?古」ツ??ィツカツ?」ツ?暗」ツつ凝ヲツ慊?・ツ按敕」ツ?ョテ・ツケツエテ」ツ?ェテ」ツ?ョテ」ツ?ァ
// ub-1テ・ツケツエテ」ツ?セテ」ツ?ァテ・ツケツエテ」ツつ津ゥツ?イテ」ツつ?」ツ?ヲテ」ツ?甘」ツ??
sum -= sumd[ub - 1];
int resy = ub;
int c = isLeap(resy);
int resm, resd;
for (int i = 0; i < 12; i++) {
if (sum <= md[c][i]) {
resm = i + 1;
resd = sum;
break;
} else
sum -= md[c][i];
}
cout << resy << "." << resm << "." << resd << endl;
}
}
}
return 0;
} | replace | 92 | 93 | 92 | 93 | MLE | |
p00256 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef long long int64;
#define __2012_12_21__ 735224
#define MAX_YEAR 10000000
int64 days[MAX_YEAR + 1];
int month[2][13] = {
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
{0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
bool urudosi(int year) {
return year % 400 == 0 || (year % 100 != 0 && year % 4 == 0);
}
void init_set() {
for (int i = 1; i <= MAX_YEAR; i++) {
days[i] = days[i - 1] + 365 + urudosi(i - 1);
}
}
int main() {
char buff[256];
int y, m, d; // 西暦
int b, ka, t, w, ki; // マヤ長期歴
init_set();
while (strcmp(fgets(buff, sizeof(buff), stdin), "#\n") != 0) {
/* 入力 */
if (sscanf(buff, "%d.%d.%d.%d.%d", &b, &ka, &t, &w, &ki) == 5) {
/*マヤ長期歴 → 西暦 */
int64 allday =
b * 144000 + ka * 7200 + t * 360 + w * 20 + ki + __2012_12_21__;
y = lower_bound(days, days + MAX_YEAR, allday) - days - 1;
allday -= days[y];
bool uru = urudosi(y);
m = lower_bound(month[uru], month[uru] + 13, allday) - month[uru];
d = allday - month[uru][m - 1];
printf("%d.%d.%d\n", y, m, d);
} else {
sscanf(buff, "%d.%d.%d", &y, &m, &d);
int64 allday = days[y] + month[urudosi(y)][m - 1] + d - __2012_12_21__;
ki = allday % 20;
w = allday / 20 % 18;
t = allday / 360 % 20;
ka = allday / 7200 % 20;
b = allday / 144000 % 13;
printf("%d.%d.%d.%d.%d\n", b, ka, t, w, ki);
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef unsigned int64;
#define __2012_12_21__ 735224
#define MAX_YEAR 10000000
int64 days[MAX_YEAR + 1];
int month[2][13] = {
{0, 31, 59, 90, 120, 151, 181, 212, 243, 273, 304, 334, 365},
{0, 31, 60, 91, 121, 152, 182, 213, 244, 274, 305, 335, 366}};
bool urudosi(int year) {
return year % 400 == 0 || (year % 100 != 0 && year % 4 == 0);
}
void init_set() {
for (int i = 1; i <= MAX_YEAR; i++) {
days[i] = days[i - 1] + 365 + urudosi(i - 1);
}
}
int main() {
char buff[256];
int y, m, d; // 西暦
int b, ka, t, w, ki; // マヤ長期歴
init_set();
while (strcmp(fgets(buff, sizeof(buff), stdin), "#\n") != 0) {
/* 入力 */
if (sscanf(buff, "%d.%d.%d.%d.%d", &b, &ka, &t, &w, &ki) == 5) {
/*マヤ長期歴 → 西暦 */
int64 allday =
b * 144000 + ka * 7200 + t * 360 + w * 20 + ki + __2012_12_21__;
y = lower_bound(days, days + MAX_YEAR, allday) - days - 1;
allday -= days[y];
bool uru = urudosi(y);
m = lower_bound(month[uru], month[uru] + 13, allday) - month[uru];
d = allday - month[uru][m - 1];
printf("%d.%d.%d\n", y, m, d);
} else {
sscanf(buff, "%d.%d.%d", &y, &m, &d);
int64 allday = days[y] + month[urudosi(y)][m - 1] + d - __2012_12_21__;
ki = allday % 20;
w = allday / 20 % 18;
t = allday / 360 % 20;
ka = allday / 7200 % 20;
b = allday / 144000 % 13;
printf("%d.%d.%d.%d.%d\n", b, ka, t, w, ki);
}
}
} | replace | 2 | 3 | 2 | 3 | MLE | |
p00257 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int mx, n;
while (cin >> mx, mx) {
cin >> n;
vi d(n + 2), v(n + 2);
bool ans = 1;
rep(i, n) cin >> d[i + 1];
function<void(int, vi &)> rec = [&](int c, vi &v) {
v[c] = 1;
if (c == n + 1)
return;
for (int i = 1; i <= mx && c + i < n + 2; i++) {
int to = c + i + d[c + i];
if (!v[to])
rec(to, v);
}
};
rec(0, v);
rep(i, n + 1) if (v[i]) {
vi vv(n + 2);
rec(i, vv);
if (!vv[n + 1]) {
ans = 0;
break;
}
}
cout << (ans ? "OK" : "NG") << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)n; i++)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define dbg(...) \
do { \
cerr << __LINE__ << ": "; \
dbgprint(#__VA_ARGS__, __VA_ARGS__); \
} while (0);
using namespace std;
namespace std {
template <class S, class T> struct hash<pair<S, T>> {
size_t operator()(const pair<S, T> &p) const {
return ((size_t)1e9 + 7) * hash<S>()(p.first) + hash<T>()(p.second);
}
};
template <class T> struct hash<vector<T>> {
size_t operator()(const vector<T> &v) const {
size_t h = 0;
for (auto i : v)
h = h * ((size_t)1e9 + 7) + hash<T>()(i) + 1;
return h;
}
};
} // namespace std
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "[ ";
rep(i, v.size()) os << v[i] << (i == v.size() - 1 ? " ]" : ", ");
return os;
}
template <class T> ostream &operator<<(ostream &os, const set<T> &v) {
os << "{ ";
for (const auto &i : v)
os << i << ", ";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const map<T, U> &v) {
os << "{";
for (const auto &i : v)
os << " " << i.first << ": " << i.second << ",";
return os << "}";
}
template <class T, class U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
void dbgprint(const string &fmt) { cerr << endl; }
template <class H, class... T>
void dbgprint(const string &fmt, const H &h, const T &...r) {
cerr << fmt.substr(0, fmt.find(",")) << "= " << h << " ";
dbgprint(fmt.substr(fmt.find(",") + 1), r...);
}
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> pi;
const int inf = (int)1e9;
const double INF = 1e12, EPS = 1e-9;
int main() {
cin.tie(0);
cin.sync_with_stdio(0);
int mx, n;
while (cin >> mx, mx) {
cin >> n;
vi d(n + 2), v(n + 2);
bool ans = 1;
rep(i, n) cin >> d[i + 1];
function<void(int, vi &)> rec = [&](int c, vi &v) {
v[c] = 1;
if (c == n + 1)
return;
for (int i = 1; i <= mx && c + i < n + 2; i++) {
int to = c + i + d[c + i];
to = max(0, min(to, n + 1));
if (!v[to])
rec(to, v);
}
};
rec(0, v);
rep(i, n + 1) if (v[i]) {
vi vv(n + 2);
rec(i, vv);
if (!vv[n + 1]) {
ans = 0;
break;
}
}
cout << (ans ? "OK" : "NG") << endl;
}
return 0;
}
| insert | 76 | 76 | 76 | 77 | -6 | double free or corruption (out)
|
p00257 | C++ | Runtime Error | #include <bits/stdc++.h>
#define N 255
using namespace std;
int m, n, d[N];
bool used[2][N], ans;
void dfs(int x, int idx) {
if (used[idx][x])
return;
x += d[x];
if (x < 0)
x = 0;
if (n + 1 < x)
x = n + 1;
for (int i = 1; i <= m; i++) {
int nx = x + i;
if (n + 1 < nx)
nx = n + 1;
dfs(nx, idx);
}
}
int main() {
while (1) {
cin >> m;
if (!m)
break;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> d[i];
memset(used, 0, sizeof(used));
ans = true;
dfs(0, 0);
if (!used[0][n + 1])
ans = false;
for (int i = 1; i < n + 1; i++) {
if (!used[0][i])
continue;
for (int j = 0; j <= n + 1; j++)
used[1][j] = false;
dfs(i, 1);
if (!used[1][n + 1])
ans = false;
}
if (ans)
cout << "OK" << endl;
else
cout << "NG" << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define N 255
using namespace std;
int m, n, d[N];
bool used[2][N], ans;
void dfs(int x, int idx) {
if (used[idx][x])
return;
used[idx][x] = true;
x += d[x];
if (x < 0)
x = 0;
if (n + 1 < x)
x = n + 1;
for (int i = 1; i <= m; i++) {
int nx = x + i;
if (n + 1 < nx)
nx = n + 1;
dfs(nx, idx);
}
}
int main() {
while (1) {
cin >> m;
if (!m)
break;
cin >> n;
for (int i = 1; i <= n; i++)
cin >> d[i];
memset(used, 0, sizeof(used));
ans = true;
dfs(0, 0);
if (!used[0][n + 1])
ans = false;
for (int i = 1; i < n + 1; i++) {
if (!used[0][i])
continue;
for (int j = 0; j <= n + 1; j++)
used[1][j] = false;
dfs(i, 1);
if (!used[1][n + 1])
ans = false;
}
if (ans)
cout << "OK" << endl;
else
cout << "NG" << endl;
}
return 0;
} | insert | 9 | 9 | 9 | 10 | -11 | |
p00257 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt"
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
int come[300];
bool dfs(const int now, const vector<vector<int>> &edges, const int goal) {
assert(come[now] == false);
come[now] = true;
if (now == goal)
return true;
else {
if (edges[now].empty())
return false;
for (auto e : edges[now]) {
if (e == now)
assert(false);
if (!dfs(e, edges, goal))
return false;
}
return true;
}
}
int main() {
while (1) {
memset(come, false, sizeof(come));
int amax;
cin >> amax;
if (!amax)
break;
int N;
cin >> N;
const int goal = N + 1;
const int start = 0;
vector<int> ds(goal + 1);
for (int i = 0; i < N; ++i) {
cin >> ds[i + 1];
}
vector<vector<int>> edges(N + 2);
for (int i = 0; i < N + 1; ++i) {
for (int j = 1; j <= amax; ++j) {
int next;
if (i + j >= goal) {
next = goal;
} else {
if (i + j + ds[i + j] >= goal) {
next = goal;
} else if (i + j + ds[i + j] < 0) {
next = 0;
} else {
next = i + j + ds[i + j];
}
}
if (find(edges[i].begin(), edges[i].end(), next) == edges[i].end()) {
edges[i].push_back(next);
}
sort(edges[i].begin(), edges[i].end());
}
}
auto p = dscc.get(edges);
int newstart = -1;
int newgoal = -1;
for (int i = 0; i < p.first.size(); ++i) {
auto b = p.first[i];
if (find(b.begin(), b.end(), 0) != b.end()) {
newstart = i;
}
if (find(b.begin(), b.end(), goal) != b.end()) {
newgoal = i;
}
}
if (newstart == -1 || newgoal == -1)
cout << "ff";
auto newedges = p.second;
bool ans = dfs(newstart, newedges, newgoal);
if (ans) {
cout << "OK" << endl;
} else {
cout << "NG" << endl;
}
}
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
// < "D:\D_Download\Visual Studio
// 2015\Projects\programing_contest_c++\Debug\a.txt"
typedef int Weight;
struct Edge {
int src, dst;
Weight weight;
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
};
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
int come[300];
bool dfs(const int now, const vector<vector<int>> &edges, const int goal) {
if (come[now])
return true;
come[now] = true;
if (now == goal)
return true;
else {
if (edges[now].empty())
return false;
for (auto e : edges[now]) {
if (e == now)
assert(false);
if (!dfs(e, edges, goal))
return false;
}
return true;
}
}
int main() {
while (1) {
memset(come, false, sizeof(come));
int amax;
cin >> amax;
if (!amax)
break;
int N;
cin >> N;
const int goal = N + 1;
const int start = 0;
vector<int> ds(goal + 1);
for (int i = 0; i < N; ++i) {
cin >> ds[i + 1];
}
vector<vector<int>> edges(N + 2);
for (int i = 0; i < N + 1; ++i) {
for (int j = 1; j <= amax; ++j) {
int next;
if (i + j >= goal) {
next = goal;
} else {
if (i + j + ds[i + j] >= goal) {
next = goal;
} else if (i + j + ds[i + j] < 0) {
next = 0;
} else {
next = i + j + ds[i + j];
}
}
if (find(edges[i].begin(), edges[i].end(), next) == edges[i].end()) {
edges[i].push_back(next);
}
sort(edges[i].begin(), edges[i].end());
}
}
auto p = dscc.get(edges);
int newstart = -1;
int newgoal = -1;
for (int i = 0; i < p.first.size(); ++i) {
auto b = p.first[i];
if (find(b.begin(), b.end(), 0) != b.end()) {
newstart = i;
}
if (find(b.begin(), b.end(), goal) != b.end()) {
newgoal = i;
}
}
if (newstart == -1 || newgoal == -1)
cout << "ff";
auto newedges = p.second;
bool ans = dfs(newstart, newedges, newgoal);
if (ans) {
cout << "OK" << endl;
} else {
cout << "NG" << endl;
}
}
return 0;
} | replace | 196 | 197 | 196 | 198 | 0 | |
p00258 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cerr << *i << " ";
cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
return (x >= 0 && y >= 0 && x < W && y < H);
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gets() {
int res = 0;
REP(i, 16) {
int c;
cin >> c;
res += c << i;
}
return res;
}
int main() {
int N, C;
while (cin >> N >> C && N) {
vector<int> a(N);
vector<int> b(C);
REP(i, N) a[i] = gets();
REP(i, C) b[i] = gets();
int dp[31][1 << 16] = {};
REP(i, 31) REP(j, 1 << 16) dp[i][j] = -INF;
dp[0][0] = 0;
int ans = 0;
REP(i, N) REP(j, C) REP(S, 1 << 16) {
int S2 = S | a[i];
int NS = S2 & (~b[j]);
int pt = __builtin_popcount(S2 & b[j]);
dp[i + 1][NS] = max(dp[i + 1][NS], dp[i][S] + pt);
// printf("dp[%d][%d] <- %d + %d\n", i + 1, NS, dp[i][S], pt);
ans = max(ans, dp[i + 1][NS]);
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cerr << *i << " ";
cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
return (x >= 0 && y >= 0 && x < W && y < H);
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int gets() {
int res = 0;
REP(i, 16) {
int c;
cin >> c;
res += c << i;
}
return res;
}
int main() {
int N, C;
while (cin >> N >> C && N) {
vector<int> a(N);
vector<int> b(C);
REP(i, N) a[i] = gets();
REP(i, C) b[i] = gets();
int dp[31][1 << 16] = {};
REP(i, 31) REP(j, 1 << 16) dp[i][j] = -INF;
dp[0][0] = 0;
int ans = 0;
REP(i, N) REP(S, 1 << 16) if (dp[i][S] >= 0) REP(j, C) {
int S2 = S | a[i];
int NS = S2 & (~b[j]);
int pt = __builtin_popcount(S2 & b[j]);
dp[i + 1][NS] = max(dp[i + 1][NS], dp[i][S] + pt);
// printf("dp[%d][%d] <- %d + %d\n", i + 1, NS, dp[i][S], pt);
ans = max(ans, dp[i + 1][NS]);
}
cout << ans << endl;
}
return 0;
} | replace | 58 | 59 | 58 | 59 | TLE | |
p00258 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n, m, x;
int a[30], b[30];
int dp[30][(1 << 16)];
int main() {
while (1) {
scanf("%d %d", &n, &m);
if (n == 0 && m == 0)
break;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
a[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &x);
a[i] = a[i] * 2 + x;
}
}
for (int i = 0; i < m; i++) {
b[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &x);
b[i] = b[i] * 2 + x;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] == -1)
continue;
for (int k = 0; k < m; k++) {
int S = (j | a[i] | b[k]) - b[k];
int cost = __builtin_popcount((j | a[i]) & b[k]);
dp[i + 1][S] = max(dp[i + 1][S], dp[i][j] + cost);
}
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++)
ans = max(ans, dp[n][i]);
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n, m, x;
int a[50], b[50];
int dp[50][(1 << 16)];
int main() {
while (1) {
scanf("%d %d", &n, &m);
if (n == 0 && m == 0)
break;
memset(dp, -1, sizeof(dp));
for (int i = 0; i < n; i++) {
a[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &x);
a[i] = a[i] * 2 + x;
}
}
for (int i = 0; i < m; i++) {
b[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &x);
b[i] = b[i] * 2 + x;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] == -1)
continue;
for (int k = 0; k < m; k++) {
int S = (j | a[i] | b[k]) - b[k];
int cost = __builtin_popcount((j | a[i]) & b[k]);
dp[i + 1][S] = max(dp[i + 1][S], dp[i][j] + cost);
}
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++)
ans = max(ans, dp[n][i]);
cout << ans << endl;
}
return 0;
} | replace | 3 | 5 | 3 | 5 | 0 | |
p00258 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (long long i = (a); i < (b); i++)
#define REP(i, N) for (long long i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define MOD 1000000007
#define EPS 1e-10
#define MAX_N 100100
#define MAX_M 100100
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
typedef pair<ll, string> PLS;
int n, c;
int dp[100][(1 << 16) + 10];
int bitnum(int mask) {
int res = 0;
while (mask > 0) {
res += mask & 1;
mask >>= 1;
}
return res;
}
int main() {
while (cin >> n >> c && n + c) {
vector<int> a(n), b(n);
REP(i, n) {
REP(j, 16) {
int t;
cin >> t;
if (t == 1) {
a[i] |= (1 << j);
}
}
}
REP(i, c) {
REP(j, 16) {
int t;
cin >> t;
if (t == 1) {
b[i] |= (1 << j);
}
}
}
REP(i, 100) {
REP(mask, (1 << 16) + 10) { dp[i][mask] = -INF; }
}
dp[0][a[0]] = 0;
REP(i, n) {
REP(j, c) {
REP(mask, (1 << 16)) {
if (dp[i][mask] == -INF)
continue;
int nxt = mask - (mask & b[j]);
if (i < n - 1) {
nxt |= a[i + 1];
}
dp[i + 1][nxt] =
max(dp[i + 1][nxt], dp[i][mask] + bitnum((mask & b[j])));
}
}
}
int ans = 0;
REP(i, (1 << 16)) {
if (dp[n][i] != -INF)
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
}
// struct pic
//
// int N;
//
// int main(){
// while (cin >> N&&N){
// REP(i, N - 1){
// int n, d;
// cin >> n >> d;
//
// }
// }
// } | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (long long i = (a); i < (b); i++)
#define REP(i, N) for (long long i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define fi first
#define se second
#define PI acos(-1.0)
#define INF 1000000007
#define MOD 1000000007
#define EPS 1e-10
#define MAX_N 100100
#define MAX_M 100100
typedef long long ll;
typedef pair<ll, ll> P;
typedef pair<double, double> PD;
typedef pair<string, ll> PS;
typedef vector<ll> V;
typedef pair<P, char> PC;
typedef pair<ll, string> PLS;
int n, c;
int dp[100][(1 << 16) + 10];
int bitnum(int mask) {
int res = 0;
while (mask > 0) {
res += mask & 1;
mask >>= 1;
}
return res;
}
int main() {
while (cin >> n >> c && n + c) {
vector<int> a(n + 10), b(n + 10);
REP(i, n) {
REP(j, 16) {
int t;
cin >> t;
if (t == 1) {
a[i] |= (1 << j);
}
}
}
REP(i, c) {
REP(j, 16) {
int t;
cin >> t;
if (t == 1) {
b[i] |= (1 << j);
}
}
}
REP(i, 100) {
REP(mask, (1 << 16) + 10) { dp[i][mask] = -INF; }
}
dp[0][a[0]] = 0;
REP(i, n) {
REP(j, c) {
REP(mask, (1 << 16)) {
if (dp[i][mask] == -INF)
continue;
int nxt = mask - (mask & b[j]);
if (i < n - 1) {
nxt |= a[i + 1];
}
dp[i + 1][nxt] =
max(dp[i + 1][nxt], dp[i][mask] + bitnum((mask & b[j])));
}
}
}
int ans = 0;
REP(i, (1 << 16)) {
if (dp[n][i] != -INF)
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
}
// struct pic
//
// int N;
//
// int main(){
// while (cin >> N&&N){
// REP(i, N - 1){
// int n, d;
// cin >> n >> d;
//
// }
// }
// } | replace | 55 | 56 | 55 | 56 | 0 | |
p00258 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
#define pb push_back
int cnt_bit(int n) {
int ret = 0;
while (n > 0) {
ret++;
n -= n & -n;
}
return ret;
}
int main() {
while (1) {
static int n, c, in;
static int a[32], b[32];
static int dp[32][1 << 16];
scanf("%d%d", &n, &c);
if (n == 0)
break;
for (int i = 0; i < n; i++) {
a[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
a[i] <<= 1;
a[i] |= in;
}
}
for (int i = 0; i < c; i++) {
b[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
b[i] <<= 1;
b[i] |= in;
}
}
int t = 0, t_ = 1;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < (1 << 16); j++) {
dp[i][j] = -1000000;
}
}
dp[t][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
for (int k = 0; k < c; k++) {
int sc = cnt_bit((j | a[i]) & b[k]);
int nex = (j | a[i]) - ((j | a[i]) & b[k]);
dp[t_][nex] = max(dp[t_][nex], dp[t][j] + sc);
}
}
swap(t, t_);
}
int ret = 0;
for (int i = 0; i < (1 << 16); i++) {
ret = max(ret, dp[t][i]);
}
printf("%d\n", ret);
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
typedef long long ll;
#define pb push_back
int cnt_bit(int n) {
int ret = 0;
while (n > 0) {
ret++;
n -= n & -n;
}
return ret;
}
int main() {
while (1) {
static int n, c, in;
static int a[32], b[32];
static int dp[32][1 << 16];
scanf("%d%d", &n, &c);
if (n == 0)
break;
for (int i = 0; i < n; i++) {
a[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
a[i] <<= 1;
a[i] |= in;
}
}
for (int i = 0; i < c; i++) {
b[i] = 0;
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
b[i] <<= 1;
b[i] |= in;
}
}
int t = 0, t_ = 1;
for (int i = 0; i < 2; i++) {
for (int j = 0; j < (1 << 16); j++) {
dp[i][j] = -1000000;
}
}
dp[t][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[t][j] < 0)
continue;
for (int k = 0; k < c; k++) {
int sc = cnt_bit((j | a[i]) & b[k]);
int nex = (j | a[i]) - ((j | a[i]) & b[k]);
dp[t_][nex] = max(dp[t_][nex], dp[t][j] + sc);
}
}
swap(t, t_);
}
int ret = 0;
for (int i = 0; i < (1 << 16); i++) {
ret = max(ret, dp[t][i]);
}
printf("%d\n", ret);
}
} | insert | 53 | 53 | 53 | 55 | TLE | |
p00258 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
#define reps(i, f, n) for (int i = f; i < int(n); ++i)
#define rep(i, n) reps(i, 0, n)
const int INF = 1001001001;
int input_bit() {
int r = 0;
rep(i, 16) {
int b;
cin >> b;
r <<= 1;
r += b;
}
return r;
}
int func(int n, int c) {
vi a(n);
rep(i, n) a[i] = input_bit();
vi b(c);
rep(i, c) b[i] = input_bit();
vvi dp(n + 1);
dp[0].assign(1 << 16, -INF);
dp[0][0] = 0;
rep(i, n) {
dp[i + 1].assign(1 << 16, -INF);
rep(m, 1 << 16) {
rep(j, c) {
int v = m | a[i];
int cnt = 0;
rep(k, 16) {
if (((v >> k) & 1) && ((b[j] >> k) & 1)) {
++cnt;
v ^= 1 << k;
}
}
dp[i + 1][v] = max(dp[i + 1][v], dp[i][m] + cnt);
}
}
dp[i].clear();
}
return *max_element(dp[n].begin(), dp[n].end());
}
int main() {
int n, c;
while (cin >> n >> c, n) {
cout << func(n, c) << endl;
}
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
#define reps(i, f, n) for (int i = f; i < int(n); ++i)
#define rep(i, n) reps(i, 0, n)
const int INF = 1001001001;
int input_bit() {
int r = 0;
rep(i, 16) {
int b;
cin >> b;
r <<= 1;
r += b;
}
return r;
}
int func(int n, int c) {
vi a(n);
rep(i, n) a[i] = input_bit();
vi b(c);
rep(i, c) b[i] = input_bit();
vvi dp(n + 1);
dp[0].assign(1 << 16, -INF);
dp[0][0] = 0;
rep(i, n) {
dp[i + 1].assign(1 << 16, -INF);
rep(m, 1 << 16) {
if (dp[i][m] == -INF)
continue;
rep(j, c) {
int v = m | a[i];
int cnt = 0;
rep(k, 16) {
if (((v >> k) & 1) && ((b[j] >> k) & 1)) {
++cnt;
v ^= 1 << k;
}
}
dp[i + 1][v] = max(dp[i + 1][v], dp[i][m] + cnt);
}
}
dp[i].clear();
}
return *max_element(dp[n].begin(), dp[n].end());
}
int main() {
int n, c;
while (cin >> n >> c, n) {
cout << func(n, c) << endl;
}
} | insert | 43 | 43 | 43 | 46 | TLE | |
p00258 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define fi first
#define se second
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
int dp[31][1 << 16], a[30][16], b[30][16], d1[30], d2[30];
int po[16];
int bit_cnt(int bit) {
int ans = 0;
while (bit > 0) {
ans += bit % 2;
bit /= 2;
}
return ans;
}
void init() {
fill((int *)dp, (int *)(dp + 31), -INF);
dp[0][0] = 0;
fill(d1, d1 + 30, 0);
fill(d2, d2 + 30, 0);
int tmp = 0;
po[0] = 1;
repi(i, 1, 16) po[i] = po[i - 1] * 2;
sort(po, po + 16, greater<int>());
}
signed main() {
while (1) {
int n, c;
scanf("%lld%lld", &n, &c);
if (n == 0 and c == 0)
break;
init();
rep(i, n) rep(j, 16) scanf("%lld", &a[i][j]);
rep(i, c) rep(j, 16) scanf("%lld", &b[i][j]);
rep(i, n) rep(j, 16) d1[i] += a[i][j] * po[j];
rep(i, c) rep(j, 16) d2[i] += b[i][j] * po[j];
rep(i, n) {
rep(j, 1 << 16) {
rep(k, c) {
int bit = j | d1[i];
int bit2 = bit & d2[k];
int score = bit_cnt(bit2);
bit -= bit2;
chmax(dp[i + 1][bit], dp[i][j] + score);
}
}
}
int ans = 0;
rep(i, 1 << 16) chmax(ans, dp[n][i]);
printf("%lld\n", ans);
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define fi first
#define se second
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
int dp[31][1 << 16], a[30][16], b[30][16], d1[30], d2[30];
int po[16];
int bit_cnt(int bit) {
int ans = 0;
while (bit > 0) {
ans += bit % 2;
bit /= 2;
}
return ans;
}
void init() {
fill((int *)dp, (int *)(dp + 31), -INF);
dp[0][0] = 0;
fill(d1, d1 + 30, 0);
fill(d2, d2 + 30, 0);
int tmp = 0;
po[0] = 1;
repi(i, 1, 16) po[i] = po[i - 1] * 2;
sort(po, po + 16, greater<int>());
}
signed main() {
while (1) {
int n, c;
scanf("%lld%lld", &n, &c);
if (n == 0 and c == 0)
break;
init();
rep(i, n) rep(j, 16) scanf("%lld", &a[i][j]);
rep(i, c) rep(j, 16) scanf("%lld", &b[i][j]);
rep(i, n) rep(j, 16) d1[i] += a[i][j] * po[j];
rep(i, c) rep(j, 16) d2[i] += b[i][j] * po[j];
rep(i, n) {
rep(j, 1 << 16) {
if (dp[i][j] == -INF)
continue;
rep(k, c) {
int bit = j | d1[i];
int bit2 = bit & d2[k];
int score = bit_cnt(bit2);
bit -= bit2;
chmax(dp[i + 1][bit], dp[i][j] + score);
}
}
}
int ans = 0;
rep(i, 1 << 16) chmax(ans, dp[n][i]);
printf("%lld\n", ans);
}
return 0;
}
| insert | 65 | 65 | 65 | 67 | TLE | |
p00258 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int a[30], b[30], dp[30][1 << 16];
int count(int num) {
int res = 0;
for (int i = 0; i < 16; i++)
if (num & (1 << i))
res++;
return res;
}
int main(void) {
int n, c, in;
while (cin >> n >> c, n | c) {
fill(a, a + n, 0);
fill(b, b + c, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 16; j++) {
cin >> in;
a[i] |= in << (15 - j);
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < 16; j++) {
cin >> in;
b[i] |= in << 15 - j;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] < 0)
continue;
int now = a[i] | j;
for (int k = 0; k < c; k++) {
int next = now & ~b[k];
dp[i + 1][next] = max(dp[i + 1][next], dp[i][j] + count(now & b[k]));
}
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int a[31], b[31], dp[31][1 << 16];
int count(int num) {
int res = 0;
for (int i = 0; i < 16; i++)
if (num & (1 << i))
res++;
return res;
}
int main(void) {
int n, c, in;
while (cin >> n >> c, n | c) {
fill(a, a + n, 0);
fill(b, b + c, 0);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 16; j++) {
cin >> in;
a[i] |= in << (15 - j);
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < 16; j++) {
cin >> in;
b[i] |= in << 15 - j;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] < 0)
continue;
int now = a[i] | j;
for (int k = 0; k < c; k++) {
int next = now & ~b[k];
dp[i + 1][next] = max(dp[i + 1][next], dp[i][j] + count(now & b[k]));
}
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++) {
ans = max(ans, dp[n][i]);
}
cout << ans << endl;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00258 | C++ | Time Limit Exceeded | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 35
int dp[SIZE][1 << 16];
void calc(int n) {
int c;
int in;
int a[SIZE] = {}, b[SIZE] = {};
scanf("%d", &c);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
a[i] = a[i] * 2 + in;
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
b[i] = b[i] * 2 + in;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < (1 << 16); j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
int now = j | a[i];
for (int k = 0; k < c; k++) {
int p = __builtin_popcount(now & b[k]);
dp[i + 1][now & (~(now & b[k]))] =
max(dp[i + 1][now & (~(now & b[k]))], dp[i][j] + p);
}
dp[i + 1][now] = max(dp[i][j], dp[i + 1][now]);
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++) {
ans = max(ans, dp[n][i]);
}
printf("%d\n", ans);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
if (n == 0)
break;
calc(n);
}
return 0;
} | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << x << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 35
int dp[SIZE][1 << 16];
void calc(int n) {
int c;
int in;
int a[SIZE] = {}, b[SIZE] = {};
scanf("%d", &c);
for (int i = 0; i < n; i++) {
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
a[i] = a[i] * 2 + in;
}
}
for (int i = 0; i < c; i++) {
for (int j = 0; j < 16; j++) {
scanf("%d", &in);
b[i] = b[i] * 2 + in;
}
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j < (1 << 16); j++) {
dp[i][j] = -INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < (1 << 16); j++) {
if (dp[i][j] == -INF)
continue;
int now = j | a[i];
for (int k = 0; k < c; k++) {
int p = __builtin_popcount(now & b[k]);
dp[i + 1][now & (~(now & b[k]))] =
max(dp[i + 1][now & (~(now & b[k]))], dp[i][j] + p);
}
dp[i + 1][now] = max(dp[i][j], dp[i + 1][now]);
}
}
int ans = 0;
for (int i = 0; i < (1 << 16); i++) {
ans = max(ans, dp[n][i]);
}
printf("%d\n", ans);
}
int main() {
int n;
while (scanf("%d", &n) != EOF) {
if (n == 0)
break;
calc(n);
}
return 0;
} | insert | 62 | 62 | 62 | 64 | TLE | |
p00259 | C++ | Runtime Error | #define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
#define all(c) (c).begin(), (c).end()
#define loop(i, a, b) for (ll i = a; i < ll(b); i++)
#define rep(i, b) loop(i, 0, b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
template <class T> ostream &operator<<(ostream &os, vector<T> const &);
template <int n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
tuple<T...> const &) {}
template <int n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
tuple<T...> const &t) {
os << (n == 0 ? "" : " ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T> ostream &operator<<(ostream &os, tuple<T...> const &t) {
_ot<0>(os, t);
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
return os << "(" << p.first << ", " << p.second << ") ";
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
rep(i, v.size()) os << v[i] << (i + 1 == (int)v.size() ? "" : " ");
return os;
}
#ifdef DEBUG
#define dump(...) \
(cerr << #__VA_ARGS__ << " = " << mt(__VA_ARGS__) << " [" << __LINE__ << "]" \
<< endl)
#else
#define dump(...)
#endif
// Verify : http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1102
class zerodive {};
#undef MCR
#define MCR Mint const &
int M;
struct Mint {
int x;
explicit Mint() : x(0) {}
explicit Mint(int y) {
if ((x = y % M + M) >= M)
x -= M;
}
Mint &operator+=(MCR m) {
if ((x += m.x) >= M)
x -= M;
return *this;
}
Mint &operator-=(MCR m) {
if ((x += M - m.x) >= M)
x -= M;
return *this;
}
Mint &operator*=(MCR m) {
x = 1LL * x * m.x % M;
return *this;
}
Mint &operator/=(MCR m) {
if (m.x % M == 0)
throw zerodive();
x = (1LL * x * m.exp(M - 2).x) % M;
return *this;
}
Mint operator+(MCR m) const { return Mint(*this) += m; }
Mint operator-(MCR m) const { return Mint(*this) -= m; }
Mint operator*(MCR m) const { return Mint(*this) *= m; }
Mint operator/(MCR m) const { return Mint(*this) /= m; }
bool operator<(MCR m) const { return x < m.x; }
Mint inv() const { return exp(M - 2); }
Mint exp(long long t) const {
/* !! default 0^0 = 1 !! */
// if(x==0) return Mint(0);
Mint e = *this, res = Mint(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
};
ostream &operator<<(ostream &os, Mint m) { return os << m.x; }
char e[1000];
typedef Mint C;
inline bool valid(C) { return true; }
class overflow {};
C expr(char *&p);
C term(char *&p);
C fact(char *&p);
C num(char *&p);
inline bool ispm(char c) { return c == '+' || c == '-'; }
inline bool ispd(char c) { return c == '*' || c == '/'; }
C num(char *&p) {
C res(0);
if (isdigit(*p) || *p == 'i') {
;
} else {
throw "num begin";
}
if (isdigit(*p)) {
while (isdigit(*p)) {
res *= C(10);
res += C(*p - '0');
if (!valid(res))
throw overflow();
p++;
}
} else {
// res = C(0,1);
p++;
}
if (*p == '\0' || *p == ')' || ispm(*p) || ispd(*p)) {
;
} else {
throw "num end";
}
if (!valid(res))
throw overflow();
return res;
}
C fact(char *&p) {
C res(0);
if (*p == '(' || isdigit(*p) || *p == 'i') {
;
} else {
throw "fact begin";
}
if (*p == '(') {
p++;
res += expr(p);
p++;
} else if (isdigit(*p) || *p == 'i') {
res += num(p);
}
if (*p == '\0' || *p == ')' || ispm(*p) || ispd(*p)) {
;
} else {
cout << p - e << endl;
throw "fact end";
}
if (!valid(res))
throw overflow();
return res;
}
C term(char *&p) {
C res;
if (*p == '(' || isdigit(*p) || *p == 'i') {
res = fact(p);
} else {
throw "term begin";
}
while (1) {
if (*p == '*') {
p++;
res *= fact(p);
} else if (*p == '/') {
p++;
res /= fact(p);
} else if (*p == '\0' || *p == ')' || *p == '+' || *p == '-') {
break;
} else {
throw "term end";
}
if (!valid(res))
throw overflow();
}
if (!valid(res))
throw overflow();
return res;
}
C expr(char *&p) {
C res;
if (*p == '(' || isdigit(*p) || *p == 'i') {
res = term(p);
} else {
throw "exp begin";
}
while (1) {
if (*p == '+') {
p++;
res += term(p);
} else if (*p == '-') {
p++;
res -= term(p);
} else if (*p == '\0' || *p == ')') {
break;
} else {
throw "exp end";
}
if (!valid(res))
throw overflow();
}
return res;
}
int main() {
while (cin >> M && M) {
string s;
getline(cin, s);
int ln = 0;
rep(i, s.size()) {
if (s[i] == ' ' || s[i] == ':')
continue;
e[ln++] = s[i];
}
e[ln] = 0;
try {
char *p = e;
auto ans = expr(p);
printf("%s = %d (mod %d)\n", e, ans.x, M);
} catch (const zerodive exp) {
puts("NG");
} catch (const char *) {
puts("NG");
}
}
} | #define _CRT_SECURE_NO_WARNINGS
// #define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
#define all(c) (c).begin(), (c).end()
#define loop(i, a, b) for (ll i = a; i < ll(b); i++)
#define rep(i, b) loop(i, 0, b)
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define mt make_tuple
template <class T> ostream &operator<<(ostream &os, vector<T> const &);
template <int n, class... T>
typename enable_if<(n >= sizeof...(T))>::type _ot(ostream &,
tuple<T...> const &) {}
template <int n, class... T>
typename enable_if<(n < sizeof...(T))>::type _ot(ostream &os,
tuple<T...> const &t) {
os << (n == 0 ? "" : " ") << get<n>(t);
_ot<n + 1>(os, t);
}
template <class... T> ostream &operator<<(ostream &os, tuple<T...> const &t) {
_ot<0>(os, t);
return os;
}
template <class T, class U>
ostream &operator<<(ostream &os, pair<T, U> const &p) {
return os << "(" << p.first << ", " << p.second << ") ";
}
template <class T> ostream &operator<<(ostream &os, vector<T> const &v) {
rep(i, v.size()) os << v[i] << (i + 1 == (int)v.size() ? "" : " ");
return os;
}
#ifdef DEBUG
#define dump(...) \
(cerr << #__VA_ARGS__ << " = " << mt(__VA_ARGS__) << " [" << __LINE__ << "]" \
<< endl)
#else
#define dump(...)
#endif
// Verify : http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1102
class zerodive {};
#undef MCR
#define MCR Mint const &
int M;
struct Mint {
int x;
explicit Mint() : x(0) {}
explicit Mint(int y) {
if ((x = y % M + M) >= M)
x -= M;
}
Mint &operator+=(MCR m) {
if ((x += m.x) >= M)
x -= M;
return *this;
}
Mint &operator-=(MCR m) {
if ((x += M - m.x) >= M)
x -= M;
return *this;
}
Mint &operator*=(MCR m) {
x = 1LL * x * m.x % M;
return *this;
}
Mint &operator/=(MCR m) {
if (m.x % M == 0)
throw zerodive();
x = (1LL * x * m.exp(M - 2).x) % M;
return *this;
}
Mint operator+(MCR m) const { return Mint(*this) += m; }
Mint operator-(MCR m) const { return Mint(*this) -= m; }
Mint operator*(MCR m) const { return Mint(*this) *= m; }
Mint operator/(MCR m) const { return Mint(*this) /= m; }
bool operator<(MCR m) const { return x < m.x; }
Mint inv() const { return exp(M - 2); }
Mint exp(long long t) const {
/* !! default 0^0 = 1 !! */
// if(x==0) return Mint(0);
Mint e = *this, res = Mint(1);
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
};
ostream &operator<<(ostream &os, Mint m) { return os << m.x; }
char e[1000000];
typedef Mint C;
inline bool valid(C) { return true; }
class overflow {};
C expr(char *&p);
C term(char *&p);
C fact(char *&p);
C num(char *&p);
inline bool ispm(char c) { return c == '+' || c == '-'; }
inline bool ispd(char c) { return c == '*' || c == '/'; }
C num(char *&p) {
C res(0);
if (isdigit(*p) || *p == 'i') {
;
} else {
throw "num begin";
}
if (isdigit(*p)) {
while (isdigit(*p)) {
res *= C(10);
res += C(*p - '0');
if (!valid(res))
throw overflow();
p++;
}
} else {
// res = C(0,1);
p++;
}
if (*p == '\0' || *p == ')' || ispm(*p) || ispd(*p)) {
;
} else {
throw "num end";
}
if (!valid(res))
throw overflow();
return res;
}
C fact(char *&p) {
C res(0);
if (*p == '(' || isdigit(*p) || *p == 'i') {
;
} else {
throw "fact begin";
}
if (*p == '(') {
p++;
res += expr(p);
p++;
} else if (isdigit(*p) || *p == 'i') {
res += num(p);
}
if (*p == '\0' || *p == ')' || ispm(*p) || ispd(*p)) {
;
} else {
cout << p - e << endl;
throw "fact end";
}
if (!valid(res))
throw overflow();
return res;
}
C term(char *&p) {
C res;
if (*p == '(' || isdigit(*p) || *p == 'i') {
res = fact(p);
} else {
throw "term begin";
}
while (1) {
if (*p == '*') {
p++;
res *= fact(p);
} else if (*p == '/') {
p++;
res /= fact(p);
} else if (*p == '\0' || *p == ')' || *p == '+' || *p == '-') {
break;
} else {
throw "term end";
}
if (!valid(res))
throw overflow();
}
if (!valid(res))
throw overflow();
return res;
}
C expr(char *&p) {
C res;
if (*p == '(' || isdigit(*p) || *p == 'i') {
res = term(p);
} else {
throw "exp begin";
}
while (1) {
if (*p == '+') {
p++;
res += term(p);
} else if (*p == '-') {
p++;
res -= term(p);
} else if (*p == '\0' || *p == ')') {
break;
} else {
throw "exp end";
}
if (!valid(res))
throw overflow();
}
return res;
}
int main() {
while (cin >> M && M) {
string s;
getline(cin, s);
int ln = 0;
rep(i, s.size()) {
if (s[i] == ' ' || s[i] == ':')
continue;
e[ln++] = s[i];
}
e[ln] = 0;
try {
char *p = e;
auto ans = expr(p);
printf("%s = %d (mod %d)\n", e, ans.x, M);
} catch (const zerodive exp) {
puts("NG");
} catch (const char *) {
puts("NG");
}
}
} | replace | 97 | 98 | 97 | 98 | 0 | |
p00259 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
using namespace std;
#define dump(n) cout << "# " << #n << '=' << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define iter(c) __typeof__((c).begin())
#define foreach(i, c) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define all(c) (c).begin(), (c).end()
#define mp make_pair
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int INFTY = 1 << 29;
const double EPS = 1e-9;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
rep(i, a.size()) os << (i ? " " : "") << a[i];
return os << ']';
}
// a^b mod m
int powmod(int a, int b, int m) {
if (b == 0)
return 1;
int x = powmod(a, b / 2, m);
x = x * x % m;
return b & 1 ? x * a % m : x;
}
int inv(int n, int m) { return powmod(n, m - 2, m); }
int expr(const string &s, int m, int &i);
int fact(const string &s, int m, int &i) {
int n = s.size();
if (s[i] == '(') {
i++;
int res = expr(s, m, i);
i++;
return res;
}
int res = 0;
while (i < n && isdigit(s[i]))
res = res * 10 + s[i++] - '0';
return res;
}
int term(const string &s, int m, int &i) {
int n = s.size();
int res = fact(s, m, i);
while (i < n) {
int op = s[i];
if (op != '*' && op != '/')
break;
int tmp = fact(s, m, ++i);
if (op == '*')
res = res * tmp % m;
if (op == '/') {
if (tmp == 0)
throw "NG";
res = res * inv(tmp, m) % m;
}
}
return res;
}
int expr(const string &s, int m, int &i) {
int n = s.size();
int res = term(s, m, i);
while (i < n) {
int op = s[i];
if (op != '+' && op != '-')
break;
int tmp = term(s, m, ++i);
if (op == '+')
res = (res + tmp) % m;
if (op == '-')
res = (res - tmp + m) % m;
}
return res;
}
int main() {
for (int p; cin >> p, p;) {
cin.ignore();
string s;
getline(cin, s);
assert(s[0] == ' ');
s.erase(remove(all(s), ' '), s.end());
try {
int i = 0;
int res = expr(s, p, i);
printf("%s = %d (mod %d)\n", s.c_str(), res, p);
} catch (const char *) {
puts("NG");
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
using namespace std;
#define dump(n) cout << "# " << #n << '=' << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define iter(c) __typeof__((c).begin())
#define foreach(i, c) for (iter(c) i = (c).begin(); i != (c).end(); ++i)
#define all(c) (c).begin(), (c).end()
#define mp make_pair
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int INFTY = 1 << 29;
const double EPS = 1e-9;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
rep(i, a.size()) os << (i ? " " : "") << a[i];
return os << ']';
}
// a^b mod m
int powmod(int a, int b, int m) {
if (b == 0)
return 1;
int x = powmod(a, b / 2, m);
x = x * x % m;
return b & 1 ? x * a % m : x;
}
int inv(int n, int m) { return powmod(n, m - 2, m); }
int expr(const string &s, int m, int &i);
int fact(const string &s, int m, int &i) {
int n = s.size();
if (s[i] == '(') {
i++;
int res = expr(s, m, i);
i++;
return res;
}
int res = 0;
while (i < n && isdigit(s[i]))
res = res * 10 + s[i++] - '0';
return res;
}
int term(const string &s, int m, int &i) {
int n = s.size();
int res = fact(s, m, i);
while (i < n) {
int op = s[i];
if (op != '*' && op != '/')
break;
int tmp = fact(s, m, ++i);
if (op == '*')
res = res * tmp % m;
if (op == '/') {
if (tmp == 0)
throw "NG";
res = res * inv(tmp, m) % m;
}
}
return res;
}
int expr(const string &s, int m, int &i) {
int n = s.size();
int res = term(s, m, i);
while (i < n) {
int op = s[i];
if (op != '+' && op != '-')
break;
int tmp = term(s, m, ++i);
if (op == '+')
res = (res + tmp) % m;
if (op == '-')
res = (res - tmp + m) % m;
}
return res;
}
int main() {
for (int p; cin >> p, p;) {
cin.ignore();
string s;
getline(cin, s);
// assert(s[0]==' ');
s.erase(remove(all(s), ' '), s.end());
try {
int i = 0;
int res = expr(s, p, i);
printf("%s = %d (mod %d)\n", s.c_str(), res, p);
} catch (const char *) {
puts("NG");
}
}
return 0;
} | replace | 121 | 122 | 121 | 122 | 0 | |
p00259 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define fi first
#define se second
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
int mod = -1;
int inv[50000];
int Pow(int x, int n) {
if (n < 0)
n += mod - 1;
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ans;
}
string erase_space(string str) {
int n = str.size();
string ans = "";
rep(i, n) {
if (str[i] == ' ')
continue;
ans += str[i];
}
return ans;
}
int flag;
class Arithmetic {
public:
string str;
int n;
void init(string s) {
str = s;
n = str.size();
}
int add(int a, int b) { return (mod + a + b % mod) % mod; }
int mul(int a, int b) { return (a * b) % mod; }
int div(int a, int b) {
if (b == 0) {
flag = 0;
return 0;
}
return mul(a, inv[b]);
}
P get_num(int p) {
int ans = 0, q = -1, f = 0;
if (str[p] == '(')
return solve(p + 1, 0);
if (str[p] == '-') {
f = 1;
p++;
}
if (str[p] == '(') {
P pi = solve(p + 1, 0);
return P(-pi.fi, pi.se);
}
repi(i, p, n) {
if (!isdigit(str[i]))
break;
ans = ans * 10 + (str[i] - '0');
q = i;
}
if (f)
return P(-ans, q);
return P(ans, q);
}
P solve(int pp = 0, int f = 0) {
P pi = get_num(pp);
int ans = pi.fi, p = pi.se + 1;
repi(i, p, n) {
if (f and str[i] == ')')
return P(ans, i - 1);
if (str[i] == ')')
return P(ans, i);
if (str[i] == '*' or str[i] == '/') {
pi = get_num(i + 1);
if (str[i] == '*')
ans = mul(ans, pi.fi);
if (str[i] == '/')
ans = div(ans, pi.fi);
// if(f and str[pi.se+1] == ')')return P(ans, pi.se);
}
if (str[i] == '+' or str[i] == '-') {
if (f)
return P(ans, i - 1);
if (str[i] == '+')
pi = solve(i + 1, 1);
if (str[i] == '-')
pi = solve(i, 1);
ans = add(ans, pi.fi);
}
i = pi.se;
}
return P(ans, n - 1);
}
};
signed main() {
Arithmetic A;
/*mod = 17;
string str = "1+3*(2+3/5*2)+7";
//string str = "(2+3/5*2)";
A.init(str);
//printf("%lld\n", Pow(5, -1));
printf("%lld\n", A.solve().fi);*/
while (1) {
string str;
getline(cin, str);
if (str == "0:")
break;
int idx = 0;
rep(i, str.size()) {
if (str[i] == ':') {
idx = i;
break;
}
}
mod = atoll(str.substr(0, idx).c_str());
str = erase_space(str.substr(idx + 1, str.size() - idx - 1));
rep(i, mod) inv[i] = Pow(i, -1);
flag = 1;
A.init(str);
P p = A.solve();
if (flag == 0)
cout << "NG" << endl;
else {
cout << str << " = " << p.fi;
printf(" (mod %lld)\n", mod);
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define UNIQUE(v) v.erase(unique(all(v)), v.end());
#define ZIP(v) sort(all(v)), UNIQUE(v)
#define ADD(a, b) a = (a + b) % mod
#define SUB(a, b) a = (a + mod - b) % mod
#define MUL(a, b) a = (a * b) % mod
#define repi(i, m, n) for (int i = m; i < n; i++)
#define drep(i, n, m) for (int i = n; i >= m; i--)
#define rep(i, n) repi(i, 0, n)
#define rrep(i, n) repi(i, 1, n + 1)
#define chmin(x, y) x = min(x, y)
#define chmax(x, y) x = max(x, y)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
#define dmp(x, y) make_pair(x, y)
#define pb(x) push_back(x)
#define fi first
#define se second
typedef pair<int, int> P;
typedef pair<int, P> PP;
typedef pair<P, int> Pi;
typedef vector<int> vi;
typedef deque<int> dq;
const int inf = 1e9 + 7;
const int INF = 1e18 + 7;
int mod = -1;
int inv[50000];
int Pow(int x, int n) {
if (n < 0)
n += mod - 1;
int ans = 1;
while (n > 0) {
if (n & 1)
ans = (ans * x) % mod;
x = (x * x) % mod;
n >>= 1;
}
return ans;
}
string erase_space(string str) {
int n = str.size();
string ans = "";
rep(i, n) {
if (str[i] == ' ')
continue;
ans += str[i];
}
return ans;
}
int flag;
class Arithmetic {
public:
string str;
int n;
void init(string s) {
str = s;
n = str.size();
}
int add(int a, int b) { return (mod + a + b % mod) % mod; }
int mul(int a, int b) { return (a * b) % mod; }
int div(int a, int b) {
if (b == 0) {
flag = 0;
return 0;
}
return mul(a, inv[b]);
}
P get_num(int p) {
int ans = 0, q = -1, f = 0;
if (str[p] == '(')
return solve(p + 1, 0);
if (str[p] == '-') {
f = 1;
p++;
}
if (str[p] == '(') {
P pi = solve(p + 1, 0);
return P(-pi.fi, pi.se);
}
repi(i, p, n) {
if (!isdigit(str[i]))
break;
ans = ans * 10 + (str[i] - '0');
q = i;
}
if (f)
return P(-ans, q);
return P(ans, q);
}
P solve(int pp = 0, int f = 0) {
P pi = get_num(pp);
int ans = pi.fi, p = pi.se + 1;
repi(i, p, n) {
if (f and str[i] == ')')
return P(ans, i - 1);
if (str[i] == ')')
return P(ans, i);
if (str[i] == '*' or str[i] == '/') {
pi = get_num(i + 1);
if (str[i] == '*')
ans = mul(ans, pi.fi);
if (str[i] == '/')
ans = div(ans, pi.fi);
// if(f and str[pi.se+1] == ')')return P(ans, pi.se);
}
if (str[i] == '+' or str[i] == '-') {
if (f)
return P(ans, i - 1);
if (str[i] == '+')
pi = solve(i + 1, 1);
if (str[i] == '-')
pi = solve(i, 1);
ans = add(ans, pi.fi);
}
i = pi.se;
}
return P(ans, n - 1);
}
};
signed main() {
Arithmetic A;
/*mod = 17;
string str = "1+3*(2+3/5*2)+7";
//string str = "(2+3/5*2)";
A.init(str);
//printf("%lld\n", Pow(5, -1));
printf("%lld\n", A.solve().fi);*/
while (1) {
string str;
getline(cin, str);
if (str == "0:")
break;
int idx = 0;
rep(i, str.size()) {
if (str[i] == ':') {
idx = i;
break;
}
}
mod = atoll(str.substr(0, idx).c_str());
str = erase_space(str.substr(idx + 1, str.size() - idx - 1));
// rep(i,mod)inv[i] = Pow(i, -1);
inv[1] = 1;
for (int i = 2; i < mod; i++)
inv[i] = mod - mod / i * inv[mod % i] % mod;
flag = 1;
A.init(str);
P p = A.solve();
if (flag == 0)
cout << "NG" << endl;
else {
cout << str << " = " << p.fi;
printf(" (mod %lld)\n", mod);
}
}
return 0;
}
| replace | 149 | 150 | 149 | 153 | TLE | |
p00261 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int main() {
int node[10][10];
node[0][0] = 1;
node[0][1] = 2;
node[1][0] = -1;
node[1][1] = 3;
node[2][0] = 1;
node[2][1] = -1;
node[3][0] = 4;
node[3][1] = 5;
node[4][0] = 5;
node[4][1] = 2;
node[5][0] = 2;
node[5][1] = 1;
while (1) {
string str;
cin >> str;
if (str == "#")
break;
int len = str.size();
int now = 0;
for (int i = 0; i < len; i++) {
int f = str[i] - '0';
now = node[now][f];
}
if (now == 5)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int main() {
int node[10][10];
node[0][0] = 1;
node[0][1] = 2;
node[1][0] = -1;
node[1][1] = 3;
node[2][0] = 1;
node[2][1] = -1;
node[3][0] = 4;
node[3][1] = 5;
node[4][0] = 5;
node[4][1] = 2;
node[5][0] = 2;
node[5][1] = 1;
while (1) {
string str;
cin >> str;
if (str == "#")
break;
int len = str.size();
int now = 0;
for (int i = 0; i < len; i++) {
if (now == -1)
break;
int f = str[i] - '0';
now = node[now][f];
}
if (now == 5)
cout << "Yes" << endl;
else
cout << "No" << endl;
}
} | insert | 26 | 26 | 26 | 28 | 0 | |
p00262 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int i, j, n, m, s, p, d[100];
while (cin >> n && n > 0) {
s = p = 0;
for (i = 0; i < n; i++) {
cin >> d[i];
s += d[i];
}
for (i = 1, m = 0; i <= 100; i++) {
m += i;
if (s == m)
break;
}
if (i < 101)
m = i;
else {
cout << -1 << endl;
continue;
}
for (i = 0; i <= 10000; i++) {
if (m == n && d[0] == 1 && d[m - 1] == m) {
for (j = 0; j < m; j++)
if (d[j] != j + 1)
j = 9999;
if (j == m)
break;
}
for (j = 0; j < n; j++)
d[j]--;
for (j = 0, p = 0; j < n; j++)
if (d[j] > 0)
d[p++] = d[j];
d[p] = n;
n = p + 1;
}
if (i > 10000)
cout << -1 << endl;
else
cout << i << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int i, j, n, m, s, p, d[6000];
while (cin >> n && n > 0) {
s = p = 0;
for (i = 0; i < n; i++) {
cin >> d[i];
s += d[i];
}
for (i = 1, m = 0; i <= 100; i++) {
m += i;
if (s == m)
break;
}
if (i < 101)
m = i;
else {
cout << -1 << endl;
continue;
}
for (i = 0; i <= 10000; i++) {
if (m == n && d[0] == 1 && d[m - 1] == m) {
for (j = 0; j < m; j++)
if (d[j] != j + 1)
j = 9999;
if (j == m)
break;
}
for (j = 0; j < n; j++)
d[j]--;
for (j = 0, p = 0; j < n; j++)
if (d[j] > 0)
d[p++] = d[j];
d[p] = n;
n = p + 1;
}
if (i > 10000)
cout << -1 << endl;
else
cout << i << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00262 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
int num[1000] = {}, co = n;
for (int i = 0; i < n; i++)
cin >> num[i];
for (int i = 0;; i++) {
bool kawa = 1;
if (i == 10000) {
cout << -1 << endl;
break;
}
for (int j = 0; j < co && kawa; j++)
if (num[j] != j + 1)
kawa = 0;
if (kawa) {
cout << i << endl;
break;
}
for (int j = 0; j < co; j++)
num[j] -= 1;
num[co] = co;
for (int j = 0; j <= co; j++) {
if (num[j] == 0) {
for (int k = j + 1; k <= co; k++) {
if (num[k] != 0) {
swap(num[j], num[k]);
break;
}
}
}
}
for (int j = co + 1; j >= 0; j--) {
if (num[j] != 0) {
co = j + 1;
break;
}
}
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
int num[2000] = {}, co = n;
for (int i = 0; i < n; i++)
cin >> num[i];
for (int i = 0;; i++) {
bool kawa = 1;
if (i == 10000) {
cout << -1 << endl;
break;
}
for (int j = 0; j < co && kawa; j++)
if (num[j] != j + 1)
kawa = 0;
if (kawa) {
cout << i << endl;
break;
}
for (int j = 0; j < co; j++)
num[j] -= 1;
num[co] = co;
for (int j = 0; j <= co; j++) {
if (num[j] == 0) {
for (int k = j + 1; k <= co; k++) {
if (num[k] != 0) {
swap(num[j], num[k]);
break;
}
}
}
}
for (int j = co + 1; j >= 0; j--) {
if (num[j] != 0) {
co = j + 1;
break;
}
}
}
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00262 | C++ | Runtime Error | #include <stdio.h>
int b[100];
int main() {
int a;
while (scanf("%d", &a), a) {
for (int i = 0; i < a; i++)
scanf("%d", b + i);
int now = 0;
int n = a;
while (1) {
bool ok = true;
for (int i = 0; i < n; i++)
if (b[i] != i + 1)
ok = false;
if (ok) {
printf("%d\n", now);
break;
} else if (now == 10000) {
printf("-1\n");
break;
}
now++;
for (int i = 0; i < n; i++) {
b[i]--;
}
int at = 0;
for (int i = 0; i < n; i++)
if (b[i])
b[at++] = b[i];
b[at++] = n;
n = at;
}
}
} | #include <stdio.h>
int b[10000];
int main() {
int a;
while (scanf("%d", &a), a) {
for (int i = 0; i < a; i++)
scanf("%d", b + i);
int now = 0;
int n = a;
while (1) {
bool ok = true;
for (int i = 0; i < n; i++)
if (b[i] != i + 1)
ok = false;
if (ok) {
printf("%d\n", now);
break;
} else if (now == 10000) {
printf("-1\n");
break;
}
now++;
for (int i = 0; i < n; i++) {
b[i]--;
}
int at = 0;
for (int i = 0; i < n; i++)
if (b[i])
b[at++] = b[i];
b[at++] = n;
n = at;
}
}
} | replace | 1 | 2 | 1 | 2 | 0 | |
p00262 | C++ | Runtime Error | #include <iostream>
using namespace std;
int blocks[101], n;
void update() {
for (int i = 0; i < n; i++)
blocks[i]--;
blocks[n++] = n;
int m = 0;
for (int i = 0; i < n; i++) {
if (blocks[i] == 0) {
m++;
} else
blocks[i - m] = blocks[i];
}
n -= m;
}
bool check() {
for (int i = 0; i < n; i++) {
if (blocks[i] != i + 1)
return false;
}
return true;
}
int main() {
while (true) {
cin >> n;
if (!n)
break;
for (int i = 0; i < n; i++)
cin >> blocks[i];
for (int i = 0; i <= 10000; i++) {
if (check()) {
cout << i << endl;
goto success;
}
update();
}
cout << -1 << endl;
success:;
}
} | #include <iostream>
using namespace std;
int blocks[1000001], n;
void update() {
for (int i = 0; i < n; i++)
blocks[i]--;
blocks[n++] = n;
int m = 0;
for (int i = 0; i < n; i++) {
if (blocks[i] == 0) {
m++;
} else
blocks[i - m] = blocks[i];
}
n -= m;
}
bool check() {
for (int i = 0; i < n; i++) {
if (blocks[i] != i + 1)
return false;
}
return true;
}
int main() {
while (true) {
cin >> n;
if (!n)
break;
for (int i = 0; i < n; i++)
cin >> blocks[i];
for (int i = 0; i <= 10000; i++) {
if (check()) {
cout << i << endl;
goto success;
}
update();
}
cout << -1 << endl;
success:;
}
} | replace | 3 | 4 | 3 | 4 | 0 | |
p00262 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int n, s;
bool triangle(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
if (v[i] != i + 1)
return false;
}
return true;
}
vector<int> shift(vector<int> v) {
vector<int> ret;
for (int i = 0; i < v.size(); i++) {
if (v[i])
ret.push_back(v[i]);
}
return ret;
}
int main() {
while (cin >> n, n) {
vector<int> v(n);
s = 0;
for (int i = 0; i < n; i++)
cin >> v[i], s += v[i];
bool flag = false;
for (int i = 0; i < 2000; i++) {
if (i * (i + 1) / 2 == s)
flag = true;
}
if (!flag)
cout << -1 << endl;
else {
int c = 0;
while (true) {
if (triangle(v))
break;
for (int i = 0; i < v.size(); i++)
v[i]--;
v.push_back(v.size());
v = shift(v);
c++;
}
cout << (c <= 10000 ? c : -1) << endl;
}
}
} | #include <iostream>
#include <vector>
using namespace std;
int n, s;
bool triangle(vector<int> v) {
for (int i = 0; i < v.size(); i++) {
if (v[i] != i + 1)
return false;
}
return true;
}
vector<int> shift(vector<int> v) {
vector<int> ret;
for (int i = 0; i < v.size(); i++) {
if (v[i])
ret.push_back(v[i]);
}
return ret;
}
int main() {
while (cin >> n, n) {
vector<int> v(n);
s = 0;
for (int i = 0; i < n; i++)
cin >> v[i], s += v[i];
bool flag = false;
for (int i = 0; i < 2000; i++) {
if (i * (i + 1) / 2 == s)
flag = true;
}
if (!flag)
cout << -1 << endl;
else {
int c = 0;
while (c <= 10000) {
if (triangle(v))
break;
for (int i = 0; i < v.size(); i++)
v[i]--;
v.push_back(v.size());
v = shift(v);
c++;
}
cout << (c <= 10000 ? c : -1) << endl;
}
}
} | replace | 34 | 35 | 34 | 35 | TLE | |
p00262 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n;
while (1) {
cin >> n;
if (!n)
return 0;
int x[105];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int res = -1;
for (int i = 0; i <= 10000; i++) {
for (int j = 0; j < n; j++)
if (x[j] != j + 1)
goto nxt;
res = i;
break;
nxt:;
int cur = 0;
for (int j = 0; j < n; j++) {
if (x[j] > 1) {
x[cur] = x[j] - 1;
cur++;
}
}
x[cur] = n;
n = cur + 1;
}
cout << res << endl;
}
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
using namespace std;
int main() {
int n;
while (1) {
cin >> n;
if (!n)
return 0;
int x[10005];
for (int i = 0; i < n; i++) {
cin >> x[i];
}
int res = -1;
for (int i = 0; i <= 10000; i++) {
for (int j = 0; j < n; j++)
if (x[j] != j + 1)
goto nxt;
res = i;
break;
nxt:;
int cur = 0;
for (int j = 0; j < n; j++) {
if (x[j] > 1) {
x[cur] = x[j] - 1;
cur++;
}
}
x[cur] = n;
n = cur + 1;
}
cout << res << endl;
}
} | replace | 10 | 11 | 10 | 11 | -6 | *** stack smashing detected ***: terminated
|
p00262 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
// adjust problem by problem
const double EPS = 1e-8;
const double PI = acos(-1.0);
#ifdef __GNUC__
int popcount(int n) { return __builtin_popcount(n); }
int popcount(ll n) { return __builtin_popcountll(n); }
#endif
#ifndef __GNUC__
template <class T> int popcount(T n) {
int cnt = 0;
while (n) {
if (n % 2)
cnt++;
n /= 2;
}
return cnt;
}
#endif
template <class T> int SIZE(T a) { return a.size(); }
template <class T> string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T> T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++)
res = (res * 10 + str[i] - '0');
return res;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0)
res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int N;
int bs[101];
int main() {
while (cin >> N && N) {
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> bs[i];
sum += bs[i];
}
bool ok = false;
int k = 0;
for (k = 1; k * (k + 1) / 2 <= sum; k++) {
if (k * (k + 1) / 2 == sum) {
ok = true;
break;
}
}
int sz = N;
if (!ok)
cout << -1 << endl;
else {
int iter = 0;
for (iter = 0; iter < 10000; iter++) {
ok = true;
// check
for (int i = 0; i < k; i++)
if (bs[i] != i + 1)
ok = false;
if (ok)
break;
// remake
int cnt = 0;
int val = 0;
for (int i = 0; i < sz; i++) {
if (bs[i] == 0)
cnt++;
else {
bs[i]--;
val++;
}
}
int pos = 0;
for (int i = 0; i < sz; i++)
if (bs[i] != 0)
bs[pos++] = bs[i];
bs[pos++] = val;
sz = pos;
}
if (iter == 10000)
cout << -1 << endl;
else
cout << iter << endl;
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
// adjust problem by problem
const double EPS = 1e-8;
const double PI = acos(-1.0);
#ifdef __GNUC__
int popcount(int n) { return __builtin_popcount(n); }
int popcount(ll n) { return __builtin_popcountll(n); }
#endif
#ifndef __GNUC__
template <class T> int popcount(T n) {
int cnt = 0;
while (n) {
if (n % 2)
cnt++;
n /= 2;
}
return cnt;
}
#endif
template <class T> int SIZE(T a) { return a.size(); }
template <class T> string IntToString(T num) {
string res;
stringstream ss;
ss << num;
return ss.str();
}
template <class T> T StringToInt(string str) {
T res = 0;
for (int i = 0; i < SIZE(str); i++)
res = (res * 10 + str[i] - '0');
return res;
}
template <class T> T gcd(T a, T b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
template <class T> T lcm(T a, T b) { return a / gcd(a, b) * b; }
template <class T> void PrintSeq(T &a, int sz) {
for (int i = 0; i < sz; i++) {
cout << a[i];
if (sz == i + 1)
cout << endl;
else
cout << ' ';
}
}
bool EQ(double a, double b) { return abs(a - b) < EPS; }
void fastStream() {
cin.tie(0);
std::ios_base::sync_with_stdio(0);
}
vector<string> split(string str, char del) {
vector<string> res;
for (int i = 0, s = 0; i < SIZE(str); i++) {
if (str[i] == del) {
if (i - s != 0)
res.push_back(str.substr(s, i - s));
s = i + 1;
} else if (i == SIZE(str) - 1) {
res.push_back(str.substr(s));
}
}
return res;
}
int N;
int bs[100001];
int main() {
while (cin >> N && N) {
int sum = 0;
for (int i = 0; i < N; i++) {
cin >> bs[i];
sum += bs[i];
}
bool ok = false;
int k = 0;
for (k = 1; k * (k + 1) / 2 <= sum; k++) {
if (k * (k + 1) / 2 == sum) {
ok = true;
break;
}
}
int sz = N;
if (!ok)
cout << -1 << endl;
else {
int iter = 0;
for (iter = 0; iter < 10000; iter++) {
ok = true;
// check
for (int i = 0; i < k; i++)
if (bs[i] != i + 1)
ok = false;
if (ok)
break;
// remake
int cnt = 0;
int val = 0;
for (int i = 0; i < sz; i++) {
if (bs[i] == 0)
cnt++;
else {
bs[i]--;
val++;
}
}
int pos = 0;
for (int i = 0; i < sz; i++)
if (bs[i] != 0)
bs[pos++] = bs[i];
bs[pos++] = val;
sz = pos;
}
if (iter == 10000)
cout << -1 << endl;
else
cout << iter << endl;
}
}
return 0;
} | replace | 93 | 94 | 93 | 94 | 0 | |
p00265 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define MAX 15
int main() {
bool T[MAX + 1];
int N, Q, q, x, L[MAX + 1];
for (int i = 0; i <= MAX; i++) {
T[i] = false;
L[i] = 0;
}
scanf("%d %d", &N, &Q);
for (int i = 0; i < N; i++) {
scanf("%d", &x);
T[x] = true;
}
int m = 0;
for (int i = 1; i <= MAX; i++) {
L[i] = m;
if (T[i])
m = i;
}
for (int i = 0; i < Q; i++) {
scanf("%d", &q);
int maxv = 0;
int cur = m;
while (cur) {
int p = cur % q;
maxv = max(maxv, p);
if (cur - p < 0)
break;
cur = L[cur - p];
}
printf("%d\n", maxv);
}
} | #include <bits/stdc++.h>
using namespace std;
#define MAX 300000
int main() {
bool T[MAX + 1];
int N, Q, q, x, L[MAX + 1];
for (int i = 0; i <= MAX; i++) {
T[i] = false;
L[i] = 0;
}
scanf("%d %d", &N, &Q);
for (int i = 0; i < N; i++) {
scanf("%d", &x);
T[x] = true;
}
int m = 0;
for (int i = 1; i <= MAX; i++) {
L[i] = m;
if (T[i])
m = i;
}
for (int i = 0; i < Q; i++) {
scanf("%d", &q);
int maxv = 0;
int cur = m;
while (cur) {
int p = cur % q;
maxv = max(maxv, p);
if (cur - p < 0)
break;
cur = L[cur - p];
}
printf("%d\n", maxv);
}
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00265 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, P> P3;
const ll MOD = ll(1e9 + 7);
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(3e5 + 5);
const double EPS = 1e-4;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define ALL(v) (v).begin(), (v).end()
int n, q, cmax, cnt[MAX_N];
int solve(int m) {
int ma = 0;
for (int i = 0; i < cmax; i += m) {
int bg = i + ma, en = min(i + m - 1, cmax);
if (cnt[en] - cnt[bg] <= 0)
continue;
ma = lower_bound(cnt + bg, cnt + en, cnt[en]) - (cnt + i);
}
return ma;
}
int main() {
cin >> n >> q;
REP(i, n) {
int c;
cin >> c;
cnt[c]++;
cmax = max(cmax, c);
}
REP(i, cmax) { cnt[i + 1] += cnt[i]; }
REP(i, q) {
int m;
cin >> m;
cout << solve(m) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<ll, P> P3;
const ll MOD = ll(1e9 + 7);
const int IINF = INT_MAX;
const ll LLINF = LLONG_MAX;
const int MAX_N = int(3e5 + 5);
const double EPS = 1e-4;
const int di[] = {0, 1, 0, -1}, dj[] = {1, 0, -1, 0};
#define REP(i, n) for (int i = 0; i < n; i++)
#define REPR(i, n) for (int i = n; i >= 0; i--)
#define SORT(v) sort((v).begin(), (v).end())
#define ALL(v) (v).begin(), (v).end()
int n, q, cmax, cnt[MAX_N];
int solve(int m) {
int ma = 0;
for (int i = 0; i < cmax; i += m) {
int bg = i + ma, en = min(i + m - 1, cmax);
if (bg > cmax || cnt[en] - cnt[bg] <= 0)
continue;
ma = lower_bound(cnt + bg, cnt + en, cnt[en]) - (cnt + i);
}
return ma;
}
int main() {
cin >> n >> q;
REP(i, n) {
int c;
cin >> c;
cnt[c]++;
cmax = max(cmax, c);
}
REP(i, cmax) { cnt[i + 1] += cnt[i]; }
REP(i, q) {
int m;
cin >> m;
cout << solve(m) << endl;
}
return 0;
}
| replace | 22 | 23 | 22 | 23 | 0 | |
p00265 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
typedef long long int ll;
#define FOR(i, a, n) for (int i = (ll)a; i < (ll)n; ++i)
#define TFOR(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end();
const int INF = 1LL << 30;
const ll LLINF = 1LL << 60;
int main() {
int n, q;
std::cin >> n >> q;
int max = 0;
std::bitset<300000> bit;
TFOR(i, n) {
int nn;
std::cin >> nn;
bit[nn - 1] = 1;
if (max < nn)
max = nn;
}
TFOR(i, q) {
int nn;
std::cin >> nn;
bool fl = 0;
for (int j = nn - 1; j >= 0; --j) {
for (int k = max / nn * nn + j; k > 0; k -= nn) {
if (bit[k - 1] == 1) {
std::cout << j << std::endl;
fl = 1;
}
if (fl == 1)
break;
}
if (fl == 1) {
fl = 0;
break;
}
}
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits.h>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
typedef long long int ll;
#define FOR(i, a, n) for (int i = (ll)a; i < (ll)n; ++i)
#define TFOR(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end();
const int INF = 1LL << 30;
const ll LLINF = 1LL << 60;
int main() {
int n, q;
std::cin >> n >> q;
int max = 0;
std::bitset<600000> bit;
TFOR(i, n) {
int nn;
std::cin >> nn;
bit[nn - 1] = 1;
if (max < nn)
max = nn;
}
TFOR(i, q) {
int nn;
std::cin >> nn;
bool fl = 0;
for (int j = nn - 1; j >= 0; --j) {
for (int k = max / nn * nn + j; k > 0; k -= nn) {
if (bit[k - 1] == 1) {
std::cout << j << std::endl;
fl = 1;
}
if (fl == 1)
break;
}
if (fl == 1) {
fl = 0;
break;
}
}
}
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p00265 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
using namespace std;
#define MAX_N 300000
#define MAX_Q 100000
int N, Q;
bool c[MAX_N + 1] = {false}, found = false;
int q[MAX_Q];
int ub, lb, range;
int main() {
int input;
range = 0;
scanf("%d%d", &N, &Q);
for (int i = 0; i < N; i++) {
scanf("%d", &input);
c[input] = true;
range = max(range, input);
}
for (int i = 0; i < Q; i++)
scanf("%d", &q[i]);
for (int i = 0; i < Q; i++) {
lb = 0;
ub = q[i];
int bucket = 0;
while (ub - lb > 1) {
found = false;
int mid = (lb + ub) / 2; // 目安
for (int p = bucket * q[i] + mid; p <= range; p += mid) {
for (int j = 0; j < (q[i] - mid); j++) {
if (c[p]) {
found = true;
bucket = p / q[i];
lb = p % q[i];
// break;
}
p++;
}
if (found)
break;
}
if (!found) {
ub = mid;
}
}
printf("%d\n", lb);
}
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
#define MAX_N 300000
#define MAX_Q 100000
int N, Q;
bool c[MAX_N + 1] = {false}, found = false;
int q[MAX_Q];
int ub, lb, range;
int main() {
int input;
range = 0;
scanf("%d%d", &N, &Q);
for (int i = 0; i < N; i++) {
scanf("%d", &input);
c[input] = true;
range = max(range, input);
}
for (int i = 0; i < Q; i++)
scanf("%d", &q[i]);
for (int i = 0; i < Q; i++) {
lb = 0;
ub = q[i];
int bucket = 0;
while (ub - lb > 1) {
found = false;
int mid = (lb + ub) / 2; // 目安
for (int p = bucket * q[i] + mid; p <= range; p += mid) {
for (int j = 0; j < (q[i] - mid); j++) {
if (c[p]) {
found = true;
bucket = p / q[i];
lb = p % q[i];
break;
}
p++;
}
if (found)
break;
}
if (!found) {
ub = mid;
}
}
printf("%d\n", lb);
}
return 0;
} | replace | 37 | 38 | 37 | 38 | TLE | |
p00266 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
const int N_MAX = 100000;
const int R_MAX = 50;
const int BigNumber = 1000000007;
long long *Factrial;
const int smallNMax = 100;
struct squaence {
int start, length, counter;
squaence() {}
squaence(int _start, int _end) {
start = _start;
length = _end - _start + 1;
counter = 0;
}
};
void SolveForLargeN(int N, int R) {
int s[R_MAX], t[R_MAX];
vector<int> st_vector(2 * R);
for (int r = 0; r < R; r++) {
int tmp_s, tmp_t;
cin >> tmp_s >> tmp_t;
s[r] = tmp_s - 1;
t[r] = tmp_t - 1;
st_vector[2 * r] = s[r];
st_vector[2 * r + 1] = t[r];
}
sort(st_vector.begin(), st_vector.end());
st_vector.erase(unique(st_vector.begin(), st_vector.end()), st_vector.end());
const int st_vector_size = st_vector.size();
vector<squaence> number(st_vector.size() * 2 + 1);
int n = 0;
for (int j = 0; j < st_vector_size; j++) {
if (n < st_vector[j])
number.push_back(squaence(n, st_vector[j] - 1));
n = st_vector[j];
number.push_back(squaence(n, n));
n++;
}
if (n < N)
number.push_back(squaence(n, N - 1));
map<int, int> index_map;
for (int i = 0; i < st_vector_size; i++) {
int v = st_vector[i];
auto it = find_if(number.begin(), number.end(),
[v](squaence s) { return s.start == v; });
index_map[v] = distance(number.begin(), it);
}
for (int r = 0; r < R; r++) {
int rs = index_map[s[r]];
int rt = index_map[t[r]];
int ns = number[rs].start;
int nt = number[rt].start;
int cs = number[rs].counter;
int ct = number[rt].counter;
if (ns < nt)
ct++;
else
cs--;
for (int i = rs + 1; i < rt; i++) {
int ni = number[i].start;
if (ni < nt) {
ct += number[i].length;
if (ns < ni)
number[i].counter++;
}
if (ni < ns) {
cs -= number[i].length;
if (nt < ni)
number[i].counter--;
}
}
number[rs].counter = cs;
number[rt].counter = ct;
swap(number[rs], number[rt]);
}
n = 0;
long long index = 0;
const int number_size = number.size();
for (int i = 0; i < number_size; i++) {
const squaence *s = &number[number_size - 1 - i];
if (s->counter != 0) {
long long f = 0;
for (int j = 0; j < s->length; j++, n++) {
f += Factrial[n] % BigNumber;
}
index += s->counter * f % BigNumber;
} else {
n += s->length;
}
}
cout << index % BigNumber << endl;
}
void SolveForSmallN(int N, int R) {
long long RevFactrial[smallNMax];
int number[smallNMax], counter[smallNMax];
RevFactrial[smallNMax - 1] = 1;
for (int i = smallNMax - 2; i >= 0; i--) {
RevFactrial[i] = (RevFactrial[i + 1] * (smallNMax - i - 1)) % BigNumber;
}
for (int n = 0; n < N; n++) {
number[n] = n;
counter[n] = 0;
}
for (int r = 0; r < R; r++) {
int s, t;
cin >> s >> t;
s--;
t--;
int ns = number[s];
int nt = number[t];
int cs = counter[t];
int ct = counter[s];
if (ns < nt)
cs++;
else
ct--;
for (int i = s + 1; i < t; i++) {
int ni = number[i];
if (ni < nt) {
cs++;
if (ns < ni)
counter[i]++;
}
if (ni < ns) {
ct--;
if (nt < ni)
counter[i]--;
}
}
counter[s] = cs;
counter[t] = ct;
number[s] = nt;
number[t] = ns;
}
long long index = 0;
for (int i = 0; i < N - 1; i++) {
index += counter[i] * RevFactrial[smallNMax - N + i] % BigNumber;
}
cout << index % BigNumber << endl;
}
int main() {
Factrial = new long long[N_MAX];
Factrial[0] = 1;
for (int i = 1; i < N_MAX; i++) {
Factrial[i] = (Factrial[i - 1] * i) % BigNumber;
}
int N, R;
while (true) {
cin >> N;
if (N == 0)
break;
cin >> R;
if (N > smallNMax)
SolveForLargeN(N, R);
else
SolveForSmallN(N, R);
}
delete[] Factrial;
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
const int N_MAX = 100000;
const int R_MAX = 50;
const int BigNumber = 1000000007;
long long *Factrial;
const int smallNMax = N_MAX;
struct squaence {
int start, length, counter;
squaence() {}
squaence(int _start, int _end) {
start = _start;
length = _end - _start + 1;
counter = 0;
}
};
void SolveForLargeN(int N, int R) {
int s[R_MAX], t[R_MAX];
vector<int> st_vector(2 * R);
for (int r = 0; r < R; r++) {
int tmp_s, tmp_t;
cin >> tmp_s >> tmp_t;
s[r] = tmp_s - 1;
t[r] = tmp_t - 1;
st_vector[2 * r] = s[r];
st_vector[2 * r + 1] = t[r];
}
sort(st_vector.begin(), st_vector.end());
st_vector.erase(unique(st_vector.begin(), st_vector.end()), st_vector.end());
const int st_vector_size = st_vector.size();
vector<squaence> number(st_vector.size() * 2 + 1);
int n = 0;
for (int j = 0; j < st_vector_size; j++) {
if (n < st_vector[j])
number.push_back(squaence(n, st_vector[j] - 1));
n = st_vector[j];
number.push_back(squaence(n, n));
n++;
}
if (n < N)
number.push_back(squaence(n, N - 1));
map<int, int> index_map;
for (int i = 0; i < st_vector_size; i++) {
int v = st_vector[i];
auto it = find_if(number.begin(), number.end(),
[v](squaence s) { return s.start == v; });
index_map[v] = distance(number.begin(), it);
}
for (int r = 0; r < R; r++) {
int rs = index_map[s[r]];
int rt = index_map[t[r]];
int ns = number[rs].start;
int nt = number[rt].start;
int cs = number[rs].counter;
int ct = number[rt].counter;
if (ns < nt)
ct++;
else
cs--;
for (int i = rs + 1; i < rt; i++) {
int ni = number[i].start;
if (ni < nt) {
ct += number[i].length;
if (ns < ni)
number[i].counter++;
}
if (ni < ns) {
cs -= number[i].length;
if (nt < ni)
number[i].counter--;
}
}
number[rs].counter = cs;
number[rt].counter = ct;
swap(number[rs], number[rt]);
}
n = 0;
long long index = 0;
const int number_size = number.size();
for (int i = 0; i < number_size; i++) {
const squaence *s = &number[number_size - 1 - i];
if (s->counter != 0) {
long long f = 0;
for (int j = 0; j < s->length; j++, n++) {
f += Factrial[n] % BigNumber;
}
index += s->counter * f % BigNumber;
} else {
n += s->length;
}
}
cout << index % BigNumber << endl;
}
void SolveForSmallN(int N, int R) {
long long RevFactrial[smallNMax];
int number[smallNMax], counter[smallNMax];
RevFactrial[smallNMax - 1] = 1;
for (int i = smallNMax - 2; i >= 0; i--) {
RevFactrial[i] = (RevFactrial[i + 1] * (smallNMax - i - 1)) % BigNumber;
}
for (int n = 0; n < N; n++) {
number[n] = n;
counter[n] = 0;
}
for (int r = 0; r < R; r++) {
int s, t;
cin >> s >> t;
s--;
t--;
int ns = number[s];
int nt = number[t];
int cs = counter[t];
int ct = counter[s];
if (ns < nt)
cs++;
else
ct--;
for (int i = s + 1; i < t; i++) {
int ni = number[i];
if (ni < nt) {
cs++;
if (ns < ni)
counter[i]++;
}
if (ni < ns) {
ct--;
if (nt < ni)
counter[i]--;
}
}
counter[s] = cs;
counter[t] = ct;
number[s] = nt;
number[t] = ns;
}
long long index = 0;
for (int i = 0; i < N - 1; i++) {
index += counter[i] * RevFactrial[smallNMax - N + i] % BigNumber;
}
cout << index % BigNumber << endl;
}
int main() {
Factrial = new long long[N_MAX];
Factrial[0] = 1;
for (int i = 1; i < N_MAX; i++) {
Factrial[i] = (Factrial[i - 1] * i) % BigNumber;
}
int N, R;
while (true) {
cin >> N;
if (N == 0)
break;
cin >> R;
if (N > smallNMax)
SolveForLargeN(N, R);
else
SolveForSmallN(N, R);
}
delete[] Factrial;
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p00268 | C++ | Time Limit Exceeded | #include <algorithm>
#include <complex>
#include <deque>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
double eps = 1e-6;
double x[110];
double y[110];
double px[700];
double py[700];
int ijk[700];
int v[700];
const double EPS = 1e-8;
const double INF = 1e12;
double PI = 3.14159265358;
struct P {
double x;
double y;
P() {}
P(double X, double Y) {
x = X;
y = Y;
}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
P operator*(const double &a) const { return P(x * a, y * a); }
/*operator+ (P a){
return P(x+a.x,y+a.y);
}
operator+ (P a){
return P(x+a.x,y+a.y);
}*/
};
inline bool operator<(const P &a, const P &b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
inline double cross(const P &a, const P &b) { return a.x * b.y - a.y * b.x; }
inline double dot(const P &a, const P &b) { return a.x * b.x + a.y * b.y; }
int ccw(P a, P b, P c) {
b = b - a;
c = c - a;
if (cross(b, c) > 0)
return +1; // counter clockwise
if (cross(b, c) < 0)
return -1; // clockwise
if (dot(b, c) < 0)
return +2; // c--a--b on line
if (b.x * b.x + b.y * b.y < c.x * c.x + c.y * c.y)
return -2; // a--b--c on line
return 0;
}
#define se second
#define fi first
bool intersectSS(const pair<P, P> &s, const pair<P, P> &t) {
return ccw(s.fi, s.se, t.fi) * ccw(s.fi, s.se, t.se) <= 0 &&
ccw(t.fi, t.se, s.fi) * ccw(t.fi, t.se, s.se) <= 0;
}
P pt[700];
P ps[300];
int s[400];
int t[400];
double left[400];
double right[400];
vector<pair<int, int>> g[700];
int UF[700];
int FIND(int a) {
if (UF[a] < 0)
return a;
return UF[a] = FIND(UF[a]);
}
void UNION(int a, int b) {
a = FIND(a);
b = FIND(b);
if (a == b)
return;
UF[a] += UF[b];
UF[b] = a;
}
int main() {
int a, b;
while (scanf("%d%d", &a, &b), a) {
for (int i = 0; i < 700; i++)
UF[i] = -1;
for (int i = 0; i < 700; i++)
g[i].clear();
for (int i = 0; i < a; i++)
scanf("%lf%lf", x + i, y + i);
for (int i = 0; i < a; i++) {
double X = cos(1) * x[i] - sin(1) * y[i];
double Y = sin(1) * x[i] + cos(1) * y[i];
x[i] = X;
y[i] = Y;
ps[i] = P(x[i], y[i]);
}
for (int i = 0; i < b; i++) {
int p, q;
scanf("%d%d", &p, &q);
p--;
q--;
s[i] = p;
t[i] = q;
px[i * 2] = (x[p] + x[q]) / 2 + eps;
py[i * 2] = (y[p] + y[q]) / 2;
px[i * 2 + 1] = (x[p] + x[q]) / 2 - eps;
py[i * 2 + 1] = (y[p] + y[q]) / 2;
pt[i * 2] = P(px[i * 2], py[i * 2]);
pt[i * 2 + 1] = P(px[i * 2 + 1], py[i * 2 + 1]);
}
deque<pair<int, int>> Q;
for (int i = 0; i < a; i++) {
vector<pair<double, pair<int, int>>> vec;
for (int j = 0; j < b; j++) {
if (s[j] == i) {
vec.push_back(make_pair(atan2(y[t[j]] - y[i], x[t[j]] - x[i]),
make_pair(j, t[j])));
}
if (t[j] == i) {
vec.push_back(make_pair(atan2(y[s[j]] - y[i], x[s[j]] - x[i]),
make_pair(j, s[j])));
}
}
std::sort(vec.begin(), vec.end());
int sz = vec.size();
for (int j = 0; j < vec.size(); j++) {
double th = vec[j].first;
double th2 = vec[(j + 1) % sz].first;
if (th > th2)
th2 += 2 * PI;
if (th2 - th <= PI + EPS)
continue;
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) {
if (intersectSS(
make_pair(pt[vec[j].second.first * 2 + k],
pt[vec[(j + 1) % sz].second.first * 2 + l]),
make_pair(ps[i], ps[vec[j].second.second])) &&
intersectSS(
make_pair(pt[vec[j].second.first * 2 + k],
pt[vec[(j + 1) % sz].second.first * 2 + l]),
make_pair(ps[i], ps[vec[(j + 1) % sz].second.second]))) {
g[vec[j].second.first * 2 + k].push_back(
make_pair(vec[(j + 1) % sz].second.first * 2 + l, 0));
g[vec[(j + 1) % sz].second.first * 2 + l].push_back(
make_pair(vec[j].second.first * 2 + k, 0));
UNION(vec[j].second.first * 2 + k,
vec[(j + 1) % sz].second.first * 2 + l);
}
}
}
}
for (int i = 0; i < b * 2; i++) {
ijk[i] = 999999999;
v[i] = 0;
bool OK = true;
int tt = s[i / 2];
for (int j = 0; j < b; j++) {
if (tt == s[j] || tt == t[j])
continue;
if (intersectSS(make_pair(ps[tt], ps[tt] + (pt[i] - ps[tt]) * 10000.0),
make_pair(ps[s[j]], ps[t[j]]))) {
OK = false;
break;
}
}
tt = t[i / 2];
for (int j = 0; j < b; j++) {
if (tt == s[j] || tt == t[j])
continue;
if (intersectSS(make_pair(ps[tt], ps[tt] + (pt[i] - ps[tt]) * 10000.0),
make_pair(ps[s[j]], ps[t[j]]))) {
OK = false;
break;
}
}
if (OK) {
ijk[i] = 0;
Q.push_back(make_pair(0, i));
}
for (int j = i + 1; j < b * 2; j++) {
int cnt = 0;
if (FIND(i) == FIND(j))
continue;
for (int k = 0; k < b; k++) {
if (intersectSS(make_pair(ps[s[k]], ps[t[k]]),
make_pair(pt[i], pt[j]))) {
cnt++;
if (cnt > 1)
break;
}
}
if (cnt < 2) {
if (cnt == 0) {
UNION(i, j);
}
g[i].push_back(make_pair(j, cnt));
g[j].push_back(make_pair(i, cnt));
}
}
}
while (Q.size()) {
int cost = -Q.front().first;
int at = Q.front().second;
Q.pop_front();
if (v[at])
continue;
v[at] = 1;
for (int i = 0; i < g[at].size(); i++) {
if (!v[g[at][i].first] &&
ijk[g[at][i].first] > cost + g[at][i].second) {
ijk[g[at][i].first] = cost + g[at][i].second;
if (g[at][i].second == 1)
Q.push_back(make_pair(-ijk[g[at][i].first], g[at][i].first));
else
Q.push_front(make_pair(-ijk[g[at][i].first], g[at][i].first));
}
}
}
int ret = 0;
for (int i = 0; i < b * 2; i++)
ret = max(ret, ijk[i]);
printf("%d\n", ret);
}
} | #include <algorithm>
#include <complex>
#include <deque>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
double eps = 1e-6;
double x[110];
double y[110];
double px[700];
double py[700];
int ijk[700];
int v[700];
const double EPS = 1e-8;
const double INF = 1e12;
double PI = 3.14159265358;
struct P {
double x;
double y;
P() {}
P(double X, double Y) {
x = X;
y = Y;
}
P operator+(const P &a) const { return P(x + a.x, y + a.y); }
P operator-(const P &a) const { return P(x - a.x, y - a.y); }
P operator*(const double &a) const { return P(x * a, y * a); }
/*operator+ (P a){
return P(x+a.x,y+a.y);
}
operator+ (P a){
return P(x+a.x,y+a.y);
}*/
};
inline bool operator<(const P &a, const P &b) {
return a.x < b.x || (a.x == b.x && a.y < b.y);
}
inline double cross(const P &a, const P &b) { return a.x * b.y - a.y * b.x; }
inline double dot(const P &a, const P &b) { return a.x * b.x + a.y * b.y; }
inline int ccw(P a, P b, P c) {
b = b - a;
c = c - a;
if (cross(b, c) > 0)
return +1; // counter clockwise
if (cross(b, c) < 0)
return -1; // clockwise
if (dot(b, c) < 0)
return +2; // c--a--b on line
if (b.x * b.x + b.y * b.y < c.x * c.x + c.y * c.y)
return -2; // a--b--c on line
return 0;
}
#define se second
#define fi first
bool intersectSS(const pair<P, P> &s, const pair<P, P> &t) {
return ccw(s.fi, s.se, t.fi) * ccw(s.fi, s.se, t.se) <= 0 &&
ccw(t.fi, t.se, s.fi) * ccw(t.fi, t.se, s.se) <= 0;
}
P pt[700];
P ps[300];
int s[400];
int t[400];
double left[400];
double right[400];
vector<pair<int, int>> g[700];
int UF[700];
int FIND(int a) {
if (UF[a] < 0)
return a;
return UF[a] = FIND(UF[a]);
}
void UNION(int a, int b) {
a = FIND(a);
b = FIND(b);
if (a == b)
return;
UF[a] += UF[b];
UF[b] = a;
}
int main() {
int a, b;
while (scanf("%d%d", &a, &b), a) {
for (int i = 0; i < 700; i++)
UF[i] = -1;
for (int i = 0; i < 700; i++)
g[i].clear();
for (int i = 0; i < a; i++)
scanf("%lf%lf", x + i, y + i);
for (int i = 0; i < a; i++) {
double X = cos(1) * x[i] - sin(1) * y[i];
double Y = sin(1) * x[i] + cos(1) * y[i];
x[i] = X;
y[i] = Y;
ps[i] = P(x[i], y[i]);
}
for (int i = 0; i < b; i++) {
int p, q;
scanf("%d%d", &p, &q);
p--;
q--;
s[i] = p;
t[i] = q;
px[i * 2] = (x[p] + x[q]) / 2 + eps;
py[i * 2] = (y[p] + y[q]) / 2;
px[i * 2 + 1] = (x[p] + x[q]) / 2 - eps;
py[i * 2 + 1] = (y[p] + y[q]) / 2;
pt[i * 2] = P(px[i * 2], py[i * 2]);
pt[i * 2 + 1] = P(px[i * 2 + 1], py[i * 2 + 1]);
}
deque<pair<int, int>> Q;
for (int i = 0; i < a; i++) {
vector<pair<double, pair<int, int>>> vec;
for (int j = 0; j < b; j++) {
if (s[j] == i) {
vec.push_back(make_pair(atan2(y[t[j]] - y[i], x[t[j]] - x[i]),
make_pair(j, t[j])));
}
if (t[j] == i) {
vec.push_back(make_pair(atan2(y[s[j]] - y[i], x[s[j]] - x[i]),
make_pair(j, s[j])));
}
}
std::sort(vec.begin(), vec.end());
int sz = vec.size();
for (int j = 0; j < vec.size(); j++) {
double th = vec[j].first;
double th2 = vec[(j + 1) % sz].first;
if (th > th2)
th2 += 2 * PI;
if (th2 - th <= PI + EPS)
continue;
for (int k = 0; k < 2; k++)
for (int l = 0; l < 2; l++) {
if (intersectSS(
make_pair(pt[vec[j].second.first * 2 + k],
pt[vec[(j + 1) % sz].second.first * 2 + l]),
make_pair(ps[i], ps[vec[j].second.second])) &&
intersectSS(
make_pair(pt[vec[j].second.first * 2 + k],
pt[vec[(j + 1) % sz].second.first * 2 + l]),
make_pair(ps[i], ps[vec[(j + 1) % sz].second.second]))) {
g[vec[j].second.first * 2 + k].push_back(
make_pair(vec[(j + 1) % sz].second.first * 2 + l, 0));
g[vec[(j + 1) % sz].second.first * 2 + l].push_back(
make_pair(vec[j].second.first * 2 + k, 0));
UNION(vec[j].second.first * 2 + k,
vec[(j + 1) % sz].second.first * 2 + l);
}
}
}
}
for (int i = 0; i < b * 2; i++) {
ijk[i] = 999999999;
v[i] = 0;
bool OK = true;
int tt = s[i / 2];
for (int j = 0; j < b; j++) {
if (tt == s[j] || tt == t[j])
continue;
if (intersectSS(make_pair(ps[tt], ps[tt] + (pt[i] - ps[tt]) * 10000.0),
make_pair(ps[s[j]], ps[t[j]]))) {
OK = false;
break;
}
}
tt = t[i / 2];
for (int j = 0; j < b; j++) {
if (tt == s[j] || tt == t[j])
continue;
if (intersectSS(make_pair(ps[tt], ps[tt] + (pt[i] - ps[tt]) * 10000.0),
make_pair(ps[s[j]], ps[t[j]]))) {
OK = false;
break;
}
}
if (OK) {
ijk[i] = 0;
Q.push_back(make_pair(0, i));
}
for (int j = i + 1; j < b * 2; j++) {
int cnt = 0;
if (FIND(i) == FIND(j))
continue;
for (int k = 0; k < b; k++) {
if (intersectSS(make_pair(ps[s[k]], ps[t[k]]),
make_pair(pt[i], pt[j]))) {
cnt++;
if (cnt > 1)
break;
}
}
if (cnt < 2) {
if (cnt == 0) {
UNION(i, j);
}
g[i].push_back(make_pair(j, cnt));
g[j].push_back(make_pair(i, cnt));
}
}
}
while (Q.size()) {
int cost = -Q.front().first;
int at = Q.front().second;
Q.pop_front();
if (v[at])
continue;
v[at] = 1;
for (int i = 0; i < g[at].size(); i++) {
if (!v[g[at][i].first] &&
ijk[g[at][i].first] > cost + g[at][i].second) {
ijk[g[at][i].first] = cost + g[at][i].second;
if (g[at][i].second == 1)
Q.push_back(make_pair(-ijk[g[at][i].first], g[at][i].first));
else
Q.push_front(make_pair(-ijk[g[at][i].first], g[at][i].first));
}
}
}
int ret = 0;
for (int i = 0; i < b * 2; i++)
ret = max(ret, ijk[i]);
printf("%d\n", ret);
}
} | replace | 42 | 43 | 42 | 43 | TLE | |
p00270 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
#define rep(i, x) for (int i = 0; i < x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define pb push_back
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define sor(vec) sort(vec.begin(), vec.end())
#define rev(vec) reverse(vec.begin(), vec.end())
#define pque(x) priority_queue<x>
#define rpque(x) priority_queue<x, vector<x>, greater<x>>
#define fr first
#define sc second
const int INF = 1000000000;
int main() {
int s, r, u, v, w, a, b, q;
static vector<P> G[100010];
scanf("%d%d", &s, &r);
rep(i, r) {
scanf("%d%d%d", &u, &v, &w);
G[u].pb(P(v, w));
G[v].pb(P(u, w));
}
scanf("%d%d%d", &a, &b, &q);
static bool used[100010];
static int d[100010];
rpque(P) que;
static vector<int> prev[100010];
rep(i, 100010) used[i] = false;
rep(i, 100010) d[i] = INF;
d[a] = 0;
que.push(P(0, a));
while (!que.empty()) {
P p = que.top();
que.pop();
if (!used[p.sc]) {
rep(i, G[p.sc].size()) {
P ed = G[p.sc][i];
if (d[ed.fr] > d[p.sc] + ed.sc) {
d[ed.fr] = d[p.sc] + ed.sc;
prev[ed.fr].clear();
prev[ed.fr].pb(p.sc);
que.push(P(d[ed.fr], ed.fr));
} else if (d[ed.fr] == d[p.sc] + ed.sc) {
prev[ed.fr].pb(p.sc);
}
}
used[p.sc] = true;
}
}
/*rep1(i,s){
printf("%d:",i);
rep(j,prev[i].size()){
printf("%d ",prev[i][j]);
}
printf("\n");
}*/
rep(i, 100010) used[i] = false;
queue<int> que0;
static vector<int> nG[100010];
que0.push(b);
used[b] = true;
while (!que0.empty()) {
int x = que0.front();
que0.pop();
rep(i, prev[x].size()) {
int p = prev[x][i];
nG[p].pb(x);
if (!used[p]) {
que0.push(p);
used[p] = true;
}
}
}
/*rep1(i,s){
printf("%d:",i);
rep(j,nG[i].size()){
printf("%d ",nG[i][j]);
}
printf("\n");
}*/
static bool used0[100010];
rep(i, 100010) used0[i] = used[i];
rep(ppp, q) {
int c, e;
scanf("%d%d", &c, &e);
if (!used0[e]) {
printf("No\n");
continue;
}
rep(i, 100010) used[i] = false;
stack<int> sta;
sta.push(c);
used[c] = true;
bool ret = false;
while (!sta.empty()) {
int x = sta.top();
sta.pop();
if (x == e) {
ret = true;
break;
}
rrep(i, nG[x].size()) {
int nex = nG[x][i];
if (!used[nex]) {
sta.push(nex);
used[nex] = true;
}
}
}
if (ret)
printf("Yes\n");
else
printf("No\n");
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
#define rep(i, x) for (int i = 0; i < x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define pb push_back
#define lb(vec, a) lower_bound(vec.begin(), vec.end(), a)
#define ub(vec, a) upper_bound(vec.begin(), vec.end(), a)
#define sor(vec) sort(vec.begin(), vec.end())
#define rev(vec) reverse(vec.begin(), vec.end())
#define pque(x) priority_queue<x>
#define rpque(x) priority_queue<x, vector<x>, greater<x>>
#define fr first
#define sc second
const int INF = 1000000000;
int main() {
int s, r, u, v, w, a, b, q;
static vector<P> G[100010];
scanf("%d%d", &s, &r);
rep(i, r) {
scanf("%d%d%d", &u, &v, &w);
G[u].pb(P(v, w));
G[v].pb(P(u, w));
}
scanf("%d%d%d", &a, &b, &q);
static bool used[100010];
static int d[100010];
rpque(P) que;
static vector<int> prev[100010];
rep(i, 100010) used[i] = false;
rep(i, 100010) d[i] = INF;
d[a] = 0;
que.push(P(0, a));
while (!que.empty()) {
P p = que.top();
que.pop();
if (!used[p.sc]) {
rep(i, G[p.sc].size()) {
P ed = G[p.sc][i];
if (d[ed.fr] > d[p.sc] + ed.sc) {
d[ed.fr] = d[p.sc] + ed.sc;
prev[ed.fr].clear();
prev[ed.fr].pb(p.sc);
que.push(P(d[ed.fr], ed.fr));
} else if (d[ed.fr] == d[p.sc] + ed.sc) {
prev[ed.fr].pb(p.sc);
}
}
used[p.sc] = true;
}
}
/*rep1(i,s){
printf("%d:",i);
rep(j,prev[i].size()){
printf("%d ",prev[i][j]);
}
printf("\n");
}*/
rep(i, 100010) used[i] = false;
queue<int> que0;
static vector<int> nG[100010];
que0.push(b);
used[b] = true;
while (!que0.empty()) {
int x = que0.front();
que0.pop();
rep(i, prev[x].size()) {
int p = prev[x][i];
nG[p].pb(x);
if (!used[p]) {
que0.push(p);
used[p] = true;
}
}
}
/*rep1(i,s){
printf("%d:",i);
rep(j,nG[i].size()){
printf("%d ",nG[i][j]);
}
printf("\n");
}*/
static bool used0[100010];
rep(i, 100010) used0[i] = used[i];
rep(ppp, q) {
int c, e;
scanf("%d%d", &c, &e);
if (!used0[e]) {
printf("No\n");
continue;
}
rep(i, 100010) used[i] = false;
stack<int> sta;
sta.push(c);
used[c] = true;
bool ret = false;
while (!sta.empty()) {
int x = sta.top();
sta.pop();
if (x == e) {
ret = true;
break;
}
if (d[x] < d[e]) {
rrep(i, nG[x].size()) {
int nex = nG[x][i];
if (!used[nex]) {
sta.push(nex);
used[nex] = true;
}
}
}
}
if (ret)
printf("Yes\n");
else
printf("No\n");
}
} | replace | 127 | 132 | 127 | 134 | TLE | |
p00271 | C++ | Time Limit Exceeded | #include <cstdio>
int main() {
for (int a, b; scanf("%d%d", &a, &b);)
printf("%d\n", a - b);
} | #include <cstdio>
int main() {
for (int a, b; scanf("%d%d", &a, &b) + 1;)
printf("%d\n", a - b);
} | replace | 2 | 3 | 2 | 3 | TLE | |
p00273 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int x, y, b, p;
int p1, p2;
cin >> x >> y >> b >> p;
p1 = x * b + y * p;
p2 = x * max(5, b) + y * max(2, p);
p2 *= 0.8;
return min(p1, p2);
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
int x, y, b, p;
int p1, p2;
cin >> x >> y >> b >> p;
p1 = x * b + y * p;
p2 = x * max(5, b) + y * max(2, p);
p2 *= 0.8;
cout << min(p1, p2) << endl;
}
return 0;
} | replace | 15 | 16 | 15 | 16 | 200 | |
p00274 | C++ | Runtime Error | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef vector<vb> vvb;
typedef vector<vpii> vvpii;
const int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
const int MOD = 1000000007;
const double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
bool odd(const int &n) { return n & 1; }
bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
void solve() {
int n;
while (cin >> n, n) {
vi k;
while (n--) {
int a;
cin >> a;
if (a)
k.pb(a);
}
if (*max_element(all(k)) < 2) {
cout << "NA" << endl;
continue;
}
cout << (k.size() == 1 ? 2 : k.size() + 1) << endl;
}
} | // clang-format off
#include <bits/stdc++.h>
#define int long long
#define main signed main()
// #define main int main()
#define loop(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n) loop(i, 0, n)
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define prec(n) fixed << setprecision(n)
#define stlice(from, to) substr(from, (to) - (from) + 1)
#define pb push_back
#define mp make_pair
#define mt make_tuple
#define fi first
#define se second
using namespace std;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<double> vd;
typedef vector<char> vc;
typedef vector<bool> vb;
typedef vector<string> vs;
typedef vector<pii> vpii;
typedef vector<vi> vvi;
typedef vector<vb> vvb;
typedef vector<vpii> vvpii;
const int INF = sizeof(int) == sizeof(long long) ? 1000000000000000000LL : 1000000000;
const int MOD = 1000000007;
const double PI = acos(-1);
template<typename A, typename B> bool cmin(A &a, const B &b) { return a > b ? (a = b, true) : false; }
template<typename A, typename B> bool cmax(A &a, const B &b) { return a < b ? (a = b, true) : false; }
bool odd(const int &n) { return n & 1; }
bool even(const int &n) { return !odd(n); }
void solve();
main { solve(); return 0; }
// clang-format on
void solve() {
int n;
while (cin >> n, n) {
vi k;
k.reserve(10000);
while (n--) {
int a;
cin >> a;
if (a)
k.pb(a);
}
if (*max_element(all(k)) < 2) {
cout << "NA" << endl;
continue;
}
cout << (k.size() == 1 ? 2 : k.size() + 1) << endl;
}
} | insert | 42 | 42 | 42 | 43 | 0 | |
p00274 | C++ | Runtime Error | #include <stdio.h>
int main(void) {
int N = 1;
static int k[100];
int i;
int a, b;
for (;;) {
scanf("%d", &N);
if (N == 0)
break;
for (i = 0; i < N; i++)
scanf("%d", &k[i]);
a = 0, b = 0;
for (i = 0; i < N; i++) {
if (k[i] == 0)
a++;
if (k[i] < 2)
b++;
}
if (b == N)
printf("NA\n");
else {
N = N - a + 1;
printf("%d\n", N);
}
}
}
| #include <stdio.h>
int main(void) {
int N = 1;
static int k[10000];
int i;
int a, b;
for (;;) {
scanf("%d", &N);
if (N == 0)
break;
for (i = 0; i < N; i++)
scanf("%d", &k[i]);
a = 0, b = 0;
for (i = 0; i < N; i++) {
if (k[i] == 0)
a++;
if (k[i] < 2)
b++;
}
if (b == N)
printf("NA\n");
else {
N = N - a + 1;
printf("%d\n", N);
}
}
}
| replace | 3 | 4 | 3 | 4 | 0 | |
p00274 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int a[1000];
while (1) {
cin >> n;
int c = 0;
int s = 0;
if (n == 0)
break;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= 1) {
c++;
if (a[i] == 0) {
s++;
}
}
}
if (n == 1 && a[0] >= 2) {
cout << 2 << endl;
} else {
if (c == n || n == 1 && a[0] <= 1) {
cout << "NA" << endl;
} else {
cout << n - s + 1 << endl;
}
}
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n, i, j;
int a[100001];
while (1) {
cin >> n;
int c = 0;
int s = 0;
if (n == 0)
break;
for (i = 0; i < n; i++) {
cin >> a[i];
if (a[i] <= 1) {
c++;
if (a[i] == 0) {
s++;
}
}
}
if (n == 1 && a[0] >= 2) {
cout << 2 << endl;
} else {
if (c == n || n == 1 && a[0] <= 1) {
cout << "NA" << endl;
} else {
cout << n - s + 1 << endl;
}
}
}
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00274 | C++ | Time Limit Exceeded | #include <stdio.h>
int main(void) {
int N, i, c;
int *k, *kk;
while (1) {
scanf("%d", &N);
if (N == 0)
break;
k = new int[N];
kk = new int[N];
for (i = 0; i < N; i++)
kk[i] = 0;
for (i = 0; i < N; i++)
scanf("%d", &k[i]);
i = 0, c = 0;
while (1) {
if (k[i % N] > 0) {
k[i % N]--;
kk[i % N]++;
c++;
}
if (kk[i % N] == 2) {
printf("%d\n", c);
break;
}
if (i > N * N) {
printf("NA\n");
break;
}
i++;
}
}
return 0;
} | #include <stdio.h>
int main(void) {
int N, i, c;
int *k, *kk;
while (1) {
scanf("%d", &N);
if (N == 0)
break;
k = new int[N];
kk = new int[N];
for (i = 0; i < N; i++)
kk[i] = 0;
for (i = 0; i < N; i++)
scanf("%d", &k[i]);
i = 0, c = 0;
while (1) {
if (k[i % N] > 0) {
k[i % N]--;
kk[i % N]++;
c++;
}
if (kk[i % N] == 2) {
printf("%d\n", c);
break;
}
if (i > N * 2) {
printf("NA\n");
break;
}
i++;
}
}
return 0;
} | replace | 26 | 27 | 26 | 27 | TLE | |
p00275 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
while (true) {
int N;
cin >> N;
if (N == 0)
break;
string c;
cin >> c;
int maisu[10];
for (int i = 0; i < c.size(); i++) {
maisu[i] = 0;
}
int ba = 0;
int turn = 0;
for (int i = 0; i < c.size(); i++) {
if (c[i] == 'M') {
maisu[turn]++;
} else if (c[i] == 'S') {
maisu[turn]++;
ba += maisu[turn];
maisu[turn] = 0;
} else {
maisu[turn]++;
maisu[turn] += ba;
ba = 0;
}
turn++;
turn %= N;
}
sort(maisu, maisu + N);
for (int i = 0; i < N; i++) {
cout << maisu[i] << " ";
}
cout << ba << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
while (true) {
int N;
cin >> N;
if (N == 0)
break;
string c;
cin >> c;
int maisu[10];
for (int i = 0; i < N; i++) {
maisu[i] = 0;
}
int ba = 0;
int turn = 0;
for (int i = 0; i < c.size(); i++) {
if (c[i] == 'M') {
maisu[turn]++;
} else if (c[i] == 'S') {
maisu[turn]++;
ba += maisu[turn];
maisu[turn] = 0;
} else {
maisu[turn]++;
maisu[turn] += ba;
ba = 0;
}
turn++;
turn %= N;
}
sort(maisu, maisu + N);
for (int i = 0; i < N; i++) {
cout << maisu[i] << " ";
}
cout << ba << endl;
}
return 0;
} | replace | 16 | 17 | 16 | 17 | -6 | *** stack smashing detected ***: terminated
|
p00275 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt"
int main() {
while (1) {
int N;
cin >> N;
string st;
cin >> st;
int f = 0;
vector<int> hs(N);
int p = 0;
for (int i = 0; i < 100; ++i) {
if (st[i] == 'S') {
f += 1 + hs[p];
hs[p] = 0;
} else if (st[i] == 'M') {
hs[p]++;
} else {
hs[p] += 1 + f;
f = 0;
}
p = (p + 1) % N;
}
sort(hs.begin(), hs.end());
for (int i = 0; i < N; ++i) {
cout << hs[i] << " ";
}
cout << f << endl;
}
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt"
int main() {
while (1) {
int N;
cin >> N;
if (!N)
break;
string st;
cin >> st;
int f = 0;
vector<int> hs(N);
int p = 0;
for (int i = 0; i < 100; ++i) {
if (st[i] == 'S') {
f += 1 + hs[p];
hs[p] = 0;
} else if (st[i] == 'M') {
hs[p]++;
} else {
hs[p] += 1 + f;
f = 0;
}
p = (p + 1) % N;
}
sort(hs.begin(), hs.end());
for (int i = 0; i < N; ++i) {
cout << hs[i] << " ";
}
cout << f << endl;
}
return 0;
} | insert | 15 | 15 | 15 | 17 | -11 | |
p00276 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
/*
*
*/
int main(int argc, char **argv) {
int Q, c, a, n;
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> c >> a >> n;
int lim = (c + a + n) / 3, res = 0;
if (lim > c)
lim = c;
int j = 0, k = 0, l = 0;
for (; j + k + l <= lim; j++) {
for (; j + k + l <= lim && k + l <= a; k++) {
for (; j + k + l <= lim && l <= n; l++) {
if (j * 3 + k * 2 + l <= c && k + l <= a) {
if (j + k + l > res)
res = j + k + l;
}
}
l = 0;
}
k = 0;
}
j = 0;
cout << res << endl;
}
return 0;
} | #include <iostream>
using namespace std;
/*
*
*/
int main(int argc, char **argv) {
int Q, c, a, n;
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> c >> a >> n;
int lim = (c + a + n) / 3, res = 0;
if (lim > c)
lim = c;
int j = 0, k = 0, l = 0;
for (;
(j + k + l <= lim && j * 3 + k * 2 + l <= c) && (k + l <= a && l <= n);
j++) {
for (; (j + k + l <= lim && j * 3 + k * 2 + l <= c) &&
(k + l <= a && l <= n);
k++) {
for (; (j + k + l <= lim && j * 3 + k * 2 + l <= c) &&
(k + l <= a && l <= n);
l++) {
if (j + k + l > res)
res = j + k + l;
}
l = 0;
}
k = 0;
}
j = 0;
cout << res << endl;
}
return 0;
} | replace | 17 | 24 | 17 | 28 | TLE | |
p00276 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, j) REP((i), 0, (j))
#define REP(i, j, k) for (int i = (j); (i) < (k); ++i)
#define BW(a, x, b) ((a) <= (x) && (x) <= (b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int *)a, (int *)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[32][32][32];
int dfs(int c, int a, int n) {
if (dp[c][a][n] >= 0)
return dp[c][a][n];
int res = 0;
if (c > 0 && a > 0 && n > 0)
res = max(res, dfs(c - 1, a - 1, n - 1) + 1);
if (c > 1 && a > 0)
res = max(res, dfs(c - 2, a - 1, n) + 1);
if (c > 2)
res = max(res, dfs(c - 3, a, n) + 1);
return dp[c][a][n] = res;
}
int main() {
cin >> Q;
rep(i, Q) {
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while (c > 8 && a > 4 && n > 0) {
res++;
c--;
a--;
n--;
}
while (c > 8 && a > 4) {
res++;
c -= 2;
a--;
}
while (c > 8) {
res++;
c -= 3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, j) REP((i), 0, (j))
#define REP(i, j, k) for (int i = (j); (i) < (k); ++i)
#define BW(a, x, b) ((a) <= (x) && (x) <= (b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int *)a, (int *)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[64][32][32];
int dfs(int c, int a, int n) {
if (dp[c][a][n] >= 0)
return dp[c][a][n];
int res = 0;
if (c > 0 && a > 0 && n > 0)
res = max(res, dfs(c - 1, a - 1, n - 1) + 1);
if (c > 1 && a > 0)
res = max(res, dfs(c - 2, a - 1, n) + 1);
if (c > 2)
res = max(res, dfs(c - 3, a, n) + 1);
return dp[c][a][n] = res;
}
int main() {
cin >> Q;
rep(i, Q) {
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while (c > 8 && a > 4 && n > 0) {
res++;
c--;
a--;
n--;
}
while (c > 8 && a > 4) {
res++;
c -= 2;
a--;
}
while (c > 8) {
res++;
c -= 3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p00276 | C++ | Time Limit Exceeded | #include <stdio.h>
int A[12];
int main() {
int i, a, b, c = 0, d = 0, n, e = 0, f = 0, l = -1, j;
char S[102];
scanf("%d", &d);
for (i = 0; i < d; i++) {
scanf("%d %d %d", &c, &a, &n);
while (1) {
if (c > 0 && a > 0 && n > 0) {
e++;
c--;
a--;
n--;
} else if (c > 1 && a > 0) {
c = c - 2;
a--;
e++;
} else if (c > 2) {
c = c - 3;
e++;
}
if (a == 0 && n == 0 && c < 3 || c == 0)
break;
}
printf("%d\n", e);
e = 0;
}
return 0;
} | #include <stdio.h>
int A[12];
int main() {
int i, a, b, c = 0, d = 0, n, e = 0, f = 0, l = -1, j;
char S[102];
scanf("%d", &d);
for (i = 0; i < d; i++) {
scanf("%d %d %d", &c, &a, &n);
while (1) {
if (c > 0 && a > 0 && n > 0) {
e++;
c--;
a--;
n--;
} else if (c > 1 && a > 0) {
c = c - 2;
a--;
e++;
} else if (c > 2) {
c = c - 3;
e++;
} else
break;
}
printf("%d\n", e);
e = 0;
}
return 0;
} | replace | 21 | 23 | 21 | 22 | TLE | |
p00276 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, j) REP((i), 0, (j))
#define REP(i, j, k) for (int i = (j); (i) < (k); ++i)
#define BW(a, x, b) ((a) <= (x) && (x) <= (b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int *)a, (int *)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[16][16][16];
int dfs(int c, int a, int n) {
if (dp[c][a][n] >= 0)
return dp[c][a][n];
int res = 0;
if (c > 0 && a > 0 && n > 0)
res = max(res, dfs(c - 1, a - 1, n - 1) + 1);
if (c > 1 && a > 0)
res = max(res, dfs(c - 2, a - 1, n) + 1);
if (c > 2)
res = max(res, dfs(c - 3, a, n) + 1);
return dp[c][a][n] = res;
}
int main() {
cin >> Q;
rep(i, Q) {
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while (c > 10 && a > 5 && n > 0) {
res++;
c--;
a--;
n--;
}
while (c > 10 && a > 5) {
res++;
c -= 2;
a--;
}
while (c > 10) {
res++;
c -= 3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define rep(i, j) REP((i), 0, (j))
#define REP(i, j, k) for (int i = (j); (i) < (k); ++i)
#define BW(a, x, b) ((a) <= (x) && (x) <= (b))
#define ALL(v) (v).begin(), (v).end()
#define LENGTHOF(x) (sizeof(x) / sizeof(*(x)))
#define AFILL(a, b) fill((int *)a, (int *)(a + LENGTHOF(a)), b)
#define MP make_pair
#define PB push_back
#define F first
#define S second
#define INF 1 << 30
#define EPS 1e-10
typedef pair<int, int> pi;
typedef pair<int, pi> pii;
typedef vector<int> vi;
typedef queue<int> qi;
typedef long long ll;
int Q;
int dp[128][128][128];
int dfs(int c, int a, int n) {
if (dp[c][a][n] >= 0)
return dp[c][a][n];
int res = 0;
if (c > 0 && a > 0 && n > 0)
res = max(res, dfs(c - 1, a - 1, n - 1) + 1);
if (c > 1 && a > 0)
res = max(res, dfs(c - 2, a - 1, n) + 1);
if (c > 2)
res = max(res, dfs(c - 3, a, n) + 1);
return dp[c][a][n] = res;
}
int main() {
cin >> Q;
rep(i, Q) {
memset(dp, -1, sizeof(dp));
int c, a, n;
cin >> c >> a >> n;
int res = 0;
while (c > 10 && a > 5 && n > 0) {
res++;
c--;
a--;
n--;
}
while (c > 10 && a > 5) {
res++;
c -= 2;
a--;
}
while (c > 10) {
res++;
c -= 3;
}
res += dfs(c, a, n);
printf("%d\n", res);
}
return 0;
} | replace | 35 | 36 | 35 | 36 | 0 | |
p00276 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int Q;
cin >> Q;
while (Q--) {
int C, A, N;
cin >> C >> A >> N;
int ans = 0;
for (int k = 0; k <= N; k++) {
for (int i = 0; i <= A; i++) {
for (int j = 0; j <= C / 3; j++) {
int c = i * 2 + j * 3 + k;
int a = i + k;
int n = k;
if (c <= C && a <= A && n <= N)
ans = max(ans, i + j + k);
}
}
}
cout << ans << endl;
}
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int Q;
cin >> Q;
while (Q--) {
int C, A, N;
cin >> C >> A >> N;
int ans = 0;
for (int k = 0; k <= N; k++) {
for (int i = 0; i <= (A - k); i++) {
for (int j = 0; j <= (C - k - 2 * i) / 3; j++) {
int c = i * 2 + j * 3 + k;
int a = i + k;
int n = k;
if (c <= C && a <= A && n <= N)
ans = max(ans, i + j + k);
}
}
}
cout << ans << endl;
}
} | replace | 13 | 15 | 13 | 15 | TLE | |
p00276 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
using namespace std;
int q;
int c, a, n;
int main(void) {
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d%d", &c, &a, &n);
int res = 0;
for (int j = 0; j <= c / 3; j++) {
for (int k = 0; k <= c / 2; k++) {
for (int l = 0; l <= min(c, min(a, n)); l++) {
int use_c = j * 3 + k * 2 + l;
int use_a = k + l;
int use_n = l;
if (use_c <= c && use_a <= a && use_n <= n)
res = max(res, j + k + l);
}
}
}
printf("%d\n", res);
}
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
int q;
int c, a, n;
int main(void) {
scanf("%d", &q);
for (int i = 0; i < q; i++) {
scanf("%d%d%d", &c, &a, &n);
int res = 0;
while (c > 0 && a > 0 && n > 0) {
c--;
a--;
n--;
res++;
}
while (c > 1 && a > 0) {
c -= 2;
a--;
res++;
}
while (c > 2) {
c -= 3;
res++;
}
printf("%d\n", res);
}
return 0;
} | replace | 13 | 23 | 13 | 27 | TLE | |
p00276 | C++ | Time Limit Exceeded | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int Q;
cin >> Q;
while (Q-- > 0) {
int c, a, n, ans = 0;
cin >> c >> a >> n;
// 1 1 1
for (int i = 0; i <= n; i++) {
// 2 1 0
for (int j = 0; j <= (a - i); j++) {
// 3 0 0
for (int k = 0; k <= (c - i - 2 * j); k++) {
int c_ = i + 2 * j + 3 * k, a_ = i + j, n_ = i;
if (c_ <= c && a_ <= a && n_ <= n)
ans = max(ans, i + j + k);
}
}
}
cout << ans << endl;
}
return 0;
} | #include <cstring>
#include <iostream>
using namespace std;
int main() {
int Q;
cin >> Q;
while (Q-- > 0) {
int c, a, n, ans = 0;
cin >> c >> a >> n;
// 1 1 1
for (int i = 0; i <= n; i++) {
// 2 1 0
for (int j = 0; j <= (a - i); j++) {
// 3 0 0
for (int k = 0; k <= (c - i - 2 * j) / 3; k++) {
int c_ = i + 2 * j + 3 * k, a_ = i + j, n_ = i;
if (c_ <= c && a_ <= a && n_ <= n)
ans = max(ans, i + j + k);
}
}
}
cout << ans << endl;
}
return 0;
} | replace | 16 | 17 | 16 | 17 | TLE | |
p00277 | C++ | Runtime Error | #include <climits>
#include <iostream>
#include <utility>
typedef std::pair<int, int> P;
const int MAX_N = 100000;
int n;
// fst: -得点, snd: チームの番号
P dat[MAX_N * 2 - 1];
int cnt[MAX_N];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i != n * 2 - 1; ++i)
dat[i] = std::make_pair(INT_MAX, INT_MAX);
return;
}
void update(int k, P x) {
k += n - 1;
dat[k] = x;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = std::min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
return;
}
// [a,b)
P query(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return std::make_pair(INT_MAX, INT_MAX);
if (a <= l && r <= b)
return dat[k];
else {
P vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
P vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return std::min(vl, vr);
}
}
int main() {
int N, R, L;
std::cin >> N >> R >> L;
init(N);
for (int i = 0; i != N; ++i)
update(i, std::make_pair(0, i));
int prevT = 0;
for (int i = 0; i != R; ++i) {
int d, t, x;
std::cin >> d >> t >> x;
--d;
if (t != prevT) {
P p = query(0, N, 0, 0, n);
cnt[p.second] += t - prevT;
}
P p = query(d, d + 1, 0, 0, n);
update(d, std::make_pair(p.first - x, p.second));
prevT = t;
}
if (prevT != L) {
P p = query(0, N, 0, 0, n);
cnt[p.second] += L - prevT;
}
int t = -1, id;
for (int i = 0; i != N; ++i) {
if (t < cnt[i]) {
t = cnt[i];
id = i + 1;
}
}
std::cout << id << std::endl;
return 0;
} | #include <climits>
#include <iostream>
#include <utility>
typedef std::pair<int, int> P;
const int MAX_N = 1 << 17;
int n;
// fst: -得点, snd: チームの番号
P dat[MAX_N * 2 - 1];
int cnt[MAX_N];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i != n * 2 - 1; ++i)
dat[i] = std::make_pair(INT_MAX, INT_MAX);
return;
}
void update(int k, P x) {
k += n - 1;
dat[k] = x;
while (k > 0) {
k = (k - 1) / 2;
dat[k] = std::min(dat[k * 2 + 1], dat[k * 2 + 2]);
}
return;
}
// [a,b)
P query(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return std::make_pair(INT_MAX, INT_MAX);
if (a <= l && r <= b)
return dat[k];
else {
P vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
P vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return std::min(vl, vr);
}
}
int main() {
int N, R, L;
std::cin >> N >> R >> L;
init(N);
for (int i = 0; i != N; ++i)
update(i, std::make_pair(0, i));
int prevT = 0;
for (int i = 0; i != R; ++i) {
int d, t, x;
std::cin >> d >> t >> x;
--d;
if (t != prevT) {
P p = query(0, N, 0, 0, n);
cnt[p.second] += t - prevT;
}
P p = query(d, d + 1, 0, 0, n);
update(d, std::make_pair(p.first - x, p.second));
prevT = t;
}
if (prevT != L) {
P p = query(0, N, 0, 0, n);
cnt[p.second] += L - prevT;
}
int t = -1, id;
for (int i = 0; i != N; ++i) {
if (t < cnt[i]) {
t = cnt[i];
id = i + 1;
}
}
std::cout << id << std::endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00277 | C++ | Time Limit Exceeded | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef pair<int, int> P;
const int INF = 1000000000;
int main() {
/*
int N,R,L;
int n,t,s;
int nowN=-1,befT=0,maxS;
static int scr[114514],time[114514];
scanf("%d%d%d",&N,&R,&L);
rep(i,R){
maxS=-INF;
scanf("%d%d%d",&n,&t,&s);
if(nowN>-1)time[nowN]+=t-befT;
scr[n-1]+=s;
rep(i,N)maxS=max(scr[i],maxS);
rep(i,N)if(scr[i]==maxS){nowN=i;break;}
befT=t;
}
maxS=-INF;
t=L;
time[nowN]+=t-befT;
rep(i,N)maxS=max(time[i],maxS);
rep(i,N)if(time[i]==maxS){nowN=i;break;}
printf("%d\n",nowN+1);
return 0;*/
int N, R, L;
int n, t, s;
int nowN = -1, befT = 0, maxS;
static int scr[114514], time[114514];
scanf("%d%d%d", &N, &R, &L);
rep(i, R) {
maxS = -INF;
scanf("%d%d%d", &n, &t, &s);
if (nowN > -1)
time[nowN] += t - befT;
scr[n - 1] += s;
if (nowN == -1) {
if (scr[n - 1] > 0)
nowN = n - 1;
else if (n == 0)
nowN = 1;
else
nowN = 0;
// else nowN =
// (scr[n-1]==scr[nowN]?min(n-1,nowN):(scr[n-1]>scr[nowN]?n-1:nowN));
} else if (n - 1 != nowN) {
if (scr[n - 1] >= scr[nowN]) {
if (scr[n - 1] == scr[nowN])
nowN = min(n - 1, nowN);
else
nowN = n - 1;
}
} else if (n - 1 == nowN) {
nowN = 0;
rep(i, N) if (scr[i] > scr[nowN]) nowN = i;
// rep(i,N)if(scr[i]==maxS){nowN=i;break;}
}
befT = t;
}
maxS = -INF;
t = L;
time[nowN] += t - befT;
rep(i, N) maxS = max(time[i], maxS);
rep(i, N) if (time[i] == maxS) {
nowN = i;
break;
}
printf("%d\n", nowN + 1);
return 0;
} | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define rep(i, n) for (int i = 0; i < n; ++i)
#define rrep(i, n) for (int i = 1; i <= n; ++i)
using namespace std;
typedef pair<int, int> P;
const int INF = 1000000000;
int main() {
/*
int N,R,L;
int n,t,s;
int nowN=-1,befT=0,maxS;
static int scr[114514],time[114514];
scanf("%d%d%d",&N,&R,&L);
rep(i,R){
maxS=-INF;
scanf("%d%d%d",&n,&t,&s);
if(nowN>-1)time[nowN]+=t-befT;
scr[n-1]+=s;
rep(i,N)maxS=max(scr[i],maxS);
rep(i,N)if(scr[i]==maxS){nowN=i;break;}
befT=t;
}
maxS=-INF;
t=L;
time[nowN]+=t-befT;
rep(i,N)maxS=max(time[i],maxS);
rep(i,N)if(time[i]==maxS){nowN=i;break;}
printf("%d\n",nowN+1);
return 0;*/
int N, R, L;
int n, t, s;
int nowN = -1, befT = 0, maxS;
static int scr[114514], time[114514];
scanf("%d%d%d", &N, &R, &L);
rep(i, R) {
maxS = -INF;
scanf("%d%d%d", &n, &t, &s);
if (nowN > -1)
time[nowN] += t - befT;
scr[n - 1] += s;
if (nowN == -1) {
if (scr[n - 1] > 0)
nowN = n - 1;
else if (n == 0)
nowN = 1;
else
nowN = 0;
// else nowN =
// (scr[n-1]==scr[nowN]?min(n-1,nowN):(scr[n-1]>scr[nowN]?n-1:nowN));
} else if (n - 1 != nowN) {
if (scr[n - 1] >= scr[nowN]) {
if (scr[n - 1] == scr[nowN])
nowN = min(n - 1, nowN);
else
nowN = n - 1;
}
} else if (n - 1 == nowN) {
if (s < 0) {
nowN = 0;
rep(i, N) if (scr[i] > scr[nowN]) nowN = i;
} else {
}
// rep(i,N)if(scr[i]==maxS){nowN=i;break;}
}
befT = t;
}
maxS = -INF;
t = L;
time[nowN] += t - befT;
rep(i, N) maxS = max(time[i], maxS);
rep(i, N) if (time[i] == maxS) {
nowN = i;
break;
}
printf("%d\n", nowN + 1);
return 0;
} | replace | 63 | 65 | 63 | 68 | TLE | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
const int INF = 1 << 29;
const double EPS = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
// segment-tree
int n; // nは2のべき乗
pii dat[100001 * 2 - 1];
// i番目の値(0-indexed)をxに変更
void update(int i, int x) {
// 葉のノード番号
int team = i;
i += n - 1;
dat[i].first += x;
dat[i].second = -team;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 初期化
void init(int _n) {
n = 1;
while (n < _n)
n *= 2;
for (int i = 0; i < _n; i++) {
update(i, 0);
}
}
/*
//[a,b)の最小値,l,rにはノードkに対応づく区画を与える
//外からはquery(a,b,0,0,n)のように呼ぶ
int query(int a,int b,int k,int l,int r){
if(r <=a||b <=l)//交差しない
return INT_MAX;
if(a <=l&&r<=b)//完全に含む
return dat[k];
else{
int vl =query(a, b, k*2+1, l, (l+r)/2);
int vr =query(a, b, k*2+2, (l+r)/2, r);
return max(vl,vr);
}
}
*/
int main() {
int N, R, L;
cin >> N >> R >> L;
init(N);
int team = 0;
int pret = 0;
int sum[110000];
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
d--;
update(d, x);
sum[team] += t - pret;
pret = t;
team = -dat[0].second;
}
sum[team] += L - pret;
int ans = 0;
for (int i = 0; i < N; i++) {
if (sum[ans] < sum[i]) {
ans = i;
}
}
cout << ans + 1 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
const int INF = 1 << 29;
const double EPS = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
// segment-tree
int n; // nは2のべき乗
pii dat[1000000 * 2 - 1];
// i番目の値(0-indexed)をxに変更
void update(int i, int x) {
// 葉のノード番号
int team = i;
i += n - 1;
dat[i].first += x;
dat[i].second = -team;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = max(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
// 初期化
void init(int _n) {
n = 1;
while (n < _n)
n *= 2;
for (int i = 0; i < _n; i++) {
update(i, 0);
}
}
/*
//[a,b)の最小値,l,rにはノードkに対応づく区画を与える
//外からはquery(a,b,0,0,n)のように呼ぶ
int query(int a,int b,int k,int l,int r){
if(r <=a||b <=l)//交差しない
return INT_MAX;
if(a <=l&&r<=b)//完全に含む
return dat[k];
else{
int vl =query(a, b, k*2+1, l, (l+r)/2);
int vr =query(a, b, k*2+2, (l+r)/2, r);
return max(vl,vr);
}
}
*/
int main() {
int N, R, L;
cin >> N >> R >> L;
init(N);
int team = 0;
int pret = 0;
int sum[110000];
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
d--;
update(d, x);
sum[team] += t - pret;
pret = t;
team = -dat[0].second;
}
sum[team] += L - pret;
int ans = 0;
for (int i = 0; i < N; i++) {
if (sum[ans] < sum[i]) {
ans = i;
}
}
cout << ans + 1 << endl;
return 0;
} | replace | 39 | 40 | 39 | 40 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
#define INF 2000000000
typedef pair<int, int> seg;
seg dat[1 << 18];
int ans[1 << 17];
int n, N, R, L;
void update(int i, seg x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
void init() {
n = 1;
while (n < N)
n *= 2;
n *= 2;
for (int i = 0; i < n * 2 - 1; i++)
dat[i] = make_pair(INF, INF);
for (int i = 0; i < N; i++)
update(i, make_pair(0, i));
}
seg query(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return make_pair(INF, INF);
if (a <= l && b >= r)
return dat[k];
seg vr = query(a, b, k, (l + r) / 2, r);
seg vl = query(a, b, k, l, (l + r) / 2);
return min(vr, vl);
}
void output() {
int m = 0;
for (int i = 0; i < N; i++) {
// cout << ans[i] << " ";
m = max(m, ans[i]);
}
for (int i = 0; i < N; i++) {
if (ans[i] == m) {
cout << i + 1 << endl;
return;
}
}
}
int main() {
int old_t = 0;
cin >> N >> R >> L;
init();
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
d--;
ans[query(0, N, 0, 0, n).second] += t - old_t;
seg s = dat[d + n - 1];
update(d, make_pair(s.first - x, s.second));
old_t = t;
}
ans[query(0, N, 0, 0, n).second] += L - old_t;
output();
} | #include <algorithm>
#include <iostream>
#include <map>
using namespace std;
#define INF 2000000000
typedef pair<int, int> seg;
seg dat[1 << 18 + 1];
int ans[1 << 17];
int n, N, R, L;
void update(int i, seg x) {
i += n - 1;
dat[i] = x;
while (i > 0) {
i = (i - 1) / 2;
dat[i] = min(dat[i * 2 + 1], dat[i * 2 + 2]);
}
}
void init() {
n = 1;
while (n < N)
n *= 2;
n *= 2;
for (int i = 0; i < n * 2 - 1; i++)
dat[i] = make_pair(INF, INF);
for (int i = 0; i < N; i++)
update(i, make_pair(0, i));
}
seg query(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return make_pair(INF, INF);
if (a <= l && b >= r)
return dat[k];
seg vr = query(a, b, k, (l + r) / 2, r);
seg vl = query(a, b, k, l, (l + r) / 2);
return min(vr, vl);
}
void output() {
int m = 0;
for (int i = 0; i < N; i++) {
// cout << ans[i] << " ";
m = max(m, ans[i]);
}
for (int i = 0; i < N; i++) {
if (ans[i] == m) {
cout << i + 1 << endl;
return;
}
}
}
int main() {
int old_t = 0;
cin >> N >> R >> L;
init();
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
d--;
ans[query(0, N, 0, 0, n).second] += t - old_t;
seg s = dat[d + n - 1];
update(d, make_pair(s.first - x, s.second));
old_t = t;
}
ans[query(0, N, 0, 0, n).second] += L - old_t;
output();
} | replace | 7 | 8 | 7 | 8 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define N_MAX 100000
typedef pair<int, int> P;
int main() {
int N, R, L;
int d, t, x;
int time[N_MAX] = {0};
int score[N_MAX] = {0};
cin >> N >> R >> L;
priority_queue<P> que;
for (int i = 1; i <= N; i++) {
que.push(P(0, N - i));
}
int now = 0;
for (int j = 0; j < R; j++) {
cin >> d >> t >> x;
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += t - now;
now = t;
score[d] += x;
que.push(P(score[d], N - d));
}
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += L - now;
priority_queue<P> que2;
for (int i = 1; i <= N; i++) {
que2.push(P(time[i], N - i));
}
p1 = que2.top();
cout << N - p1.second << endl;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define N_MAX 100001
typedef pair<int, int> P;
int main() {
int N, R, L;
int d, t, x;
int time[N_MAX] = {0};
int score[N_MAX] = {0};
cin >> N >> R >> L;
priority_queue<P> que;
for (int i = 1; i <= N; i++) {
que.push(P(0, N - i));
}
int now = 0;
for (int j = 0; j < R; j++) {
cin >> d >> t >> x;
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += t - now;
now = t;
score[d] += x;
que.push(P(score[d], N - d));
}
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += L - now;
priority_queue<P> que2;
for (int i = 1; i <= N; i++) {
que2.push(P(time[i], N - i));
}
p1 = que2.top();
cout << N - p1.second << endl;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define N_MAX 100000
typedef pair<int, int> P;
int main() {
int N, R, L;
int d, t, x;
int time[N_MAX] = {0};
int score[N_MAX] = {0};
cin >> N >> R >> L;
priority_queue<P> que;
for (int i = 1; i <= N; i++) {
que.push(P(0, N - i));
}
int now = 0;
for (int j = 0; j < R; j++) {
cin >> d >> t >> x;
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += t - now;
now = t;
score[d] += x;
que.push(P(score[d], N - d));
}
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += L - now;
priority_queue<P> que2;
for (int i = 1; i <= N; i++) {
que2.push(P(time[i], N - i));
}
p1 = que2.top();
cout << N - p1.second << endl;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <utility>
using namespace std;
#define N_MAX 100001
typedef pair<int, int> P;
int main() {
int N, R, L;
int d, t, x;
int time[N_MAX] = {0};
int score[N_MAX] = {0};
cin >> N >> R >> L;
priority_queue<P> que;
for (int i = 1; i <= N; i++) {
que.push(P(0, N - i));
}
int now = 0;
for (int j = 0; j < R; j++) {
cin >> d >> t >> x;
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += t - now;
now = t;
score[d] += x;
que.push(P(score[d], N - d));
}
P p1 = que.top();
while (score[N - p1.second] != p1.first) {
que.pop();
p1 = que.top();
}
time[N - p1.second] += L - now;
priority_queue<P> que2;
for (int i = 1; i <= N; i++) {
que2.push(P(time[i], N - i));
}
p1 = que2.top();
cout << N - p1.second << endl;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
using namespace std;
#define MAX 1111111
#define MIN -1111111
typedef pair<int, int> P;
void init(int n);
void update(int k, int x);
P maxx(int k1, int k2);
P dat[2 * 100001];
int tim[100001] = {0};
int N;
int main() {
int R, L;
cin >> N >> R >> L;
int n_tmp = N;
init(N);
memset(tim, 0, n_tmp + 1);
int now = 0;
dat[0] = P(MIN, 1);
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
tim[dat[0].second] += t - now;
update(d, x);
now = t;
}
tim[dat[0].second] += L - now;
int *ans = max_element(tim, tim + n_tmp + 1);
cout << ans - tim << endl;
}
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N - 1; i++) {
dat[i] = P(MIN, MAX);
}
for (int i = N - 1; i < N - 1 + n; i++) {
dat[i] = P(0, i - (N - 2));
}
return;
}
void update(int k, int x) {
k += N - 2;
P p = dat[k];
int score = p.first;
int team = p.second;
// cout << score << " " << team << endl;
dat[k] = P(score + x, team);
while (k > 0) {
k = (k - 1) / 2;
dat[k] = maxx(k * 2 + 1, k * 2 + 2);
// cout << dat[k].first << " " << dat[k].second << endl;
}
return;
}
P maxx(int k1, int k2) {
P p;
if (dat[k1].first == dat[k2].first) {
p = P(dat[k1].first, min(dat[k1].second, dat[k2].second));
} else {
p = max(dat[k1], dat[k2]);
}
return p;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
using namespace std;
#define MAX 1111111
#define MIN -1111111
typedef pair<int, int> P;
void init(int n);
void update(int k, int x);
P maxx(int k1, int k2);
P dat[4 * 100001];
int tim[100001] = {0};
int N;
int main() {
int R, L;
cin >> N >> R >> L;
int n_tmp = N;
init(N);
memset(tim, 0, n_tmp + 1);
int now = 0;
dat[0] = P(MIN, 1);
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
tim[dat[0].second] += t - now;
update(d, x);
now = t;
}
tim[dat[0].second] += L - now;
int *ans = max_element(tim, tim + n_tmp + 1);
cout << ans - tim << endl;
}
void init(int n) {
N = 1;
while (N < n)
N *= 2;
for (int i = 0; i < 2 * N - 1; i++) {
dat[i] = P(MIN, MAX);
}
for (int i = N - 1; i < N - 1 + n; i++) {
dat[i] = P(0, i - (N - 2));
}
return;
}
void update(int k, int x) {
k += N - 2;
P p = dat[k];
int score = p.first;
int team = p.second;
// cout << score << " " << team << endl;
dat[k] = P(score + x, team);
while (k > 0) {
k = (k - 1) / 2;
dat[k] = maxx(k * 2 + 1, k * 2 + 2);
// cout << dat[k].first << " " << dat[k].second << endl;
}
return;
}
P maxx(int k1, int k2) {
P p;
if (dat[k1].first == dat[k2].first) {
p = P(dat[k1].first, min(dat[k1].second, dat[k2].second));
} else {
p = max(dat[k1], dat[k2]);
}
return p;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[100010];
struct node {
int id, point;
} node[1 << 21];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[150010];
struct node {
int id, point;
} node[1 << 21];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[125010];
struct node {
int id, point;
} node[1 << 21];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[137510];
struct node {
int id, point;
} node[1 << 21];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[130010];
struct node {
int id, point;
} node[1 << 20];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[135010];
struct node {
int id, point;
} node[1 << 20];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[130625];
struct node {
int id, point;
} node[1 << 18];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | #include <bits/stdc++.h>
// #define DEBUG
using namespace std;
int n, a[131100];
struct node {
int id, point;
} node[1 << 18];
void add(int id, int x) {
id = n - 1 + id;
node[id].point += x;
while (id > 0) {
id = (id - 1) / 2;
int c1 = 2 * id + 1, c2 = 2 * id + 2;
if (node[c1].point >= node[c2].point)
node[id] = node[c1];
else
node[id] = node[c2];
}
}
void print() {
#ifdef DEBUG
int k = 1;
int x = 0;
while (true) {
for (int i = 0; i < k; ++i)
printf("(%d %d)", node[x + i].id, node[x + i].point);
puts("");
x += k;
k <<= 1;
if (x >= n)
break;
}
puts("");
#endif
}
int main() {
int m, r, l;
scanf("%d%d%d", &m, &r, &l);
n = 1;
while (n < m)
n <<= 1;
for (int i = 0; i < m; ++i)
node[n - 1 + i].id = i;
int pt = 0;
for (int i = 0; i < r; ++i) {
int d, t, x;
scanf("%d%d%d", &d, &t, &x);
if (pt < t) {
int id = node[0].id;
a[id] += t - pt;
}
add(d - 1, x);
print();
pt = t;
}
print();
a[node[0].id] += l - pt;
#ifdef DEBUG
for (int i = 0; i < n; ++i)
printf("%d ", a[i]);
puts("");
#endif
printf("%d\n", 1 + (max_element(a, a + n) - a));
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int a[200005][2];
int s[100005];
int main() {
int i, j, k;
int n, r, l;
int d = 0;
int t = 0;
int x = 0;
int nn = 0;
int f = 0;
memset(a, 0, sizeof(a));
memset(s, 0, sizeof(s));
cin >> n >> r >> l;
nn = 1;
while (nn < n) {
nn *= 2;
}
nn--;
for (i = 0; i < n; i++) {
a[nn + i][1] = i;
}
d = nn;
while (d != 0) {
d--;
if (a[d * 2 + 1][0] < a[d * 2 + 2][0]) {
a[d][0] = a[d * 2 + 2][0];
a[d][1] = a[d * 2 + 2][1];
} else {
a[d][0] = a[d * 2 + 1][0];
a[d][1] = a[d * 2 + 1][1];
}
}
for (i = 0; i < r; i++) {
cin >> d >> t >> x;
s[f] += t;
d--;
d += nn;
a[d][0] += x;
while (d != 0) {
d = (d - 1) / 2;
if (a[d * 2 + 1][0] < a[d * 2 + 2][0]) {
a[d][0] = a[d * 2 + 2][0];
a[d][1] = a[d * 2 + 2][1];
} else {
a[d][0] = a[d * 2 + 1][0];
a[d][1] = a[d * 2 + 1][1];
}
}
f = a[0][1];
s[f] -= t;
}
s[f] += l;
nn = 0;
for (i = 0; i < n; i++) {
if (s[nn] < s[i])
nn = i;
}
nn++;
cout << nn << endl;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int a[400005][2];
int s[100005];
int main() {
int i, j, k;
int n, r, l;
int d = 0;
int t = 0;
int x = 0;
int nn = 0;
int f = 0;
memset(a, 0, sizeof(a));
memset(s, 0, sizeof(s));
cin >> n >> r >> l;
nn = 1;
while (nn < n) {
nn *= 2;
}
nn--;
for (i = 0; i < n; i++) {
a[nn + i][1] = i;
}
d = nn;
while (d != 0) {
d--;
if (a[d * 2 + 1][0] < a[d * 2 + 2][0]) {
a[d][0] = a[d * 2 + 2][0];
a[d][1] = a[d * 2 + 2][1];
} else {
a[d][0] = a[d * 2 + 1][0];
a[d][1] = a[d * 2 + 1][1];
}
}
for (i = 0; i < r; i++) {
cin >> d >> t >> x;
s[f] += t;
d--;
d += nn;
a[d][0] += x;
while (d != 0) {
d = (d - 1) / 2;
if (a[d * 2 + 1][0] < a[d * 2 + 2][0]) {
a[d][0] = a[d * 2 + 2][0];
a[d][1] = a[d * 2 + 2][1];
} else {
a[d][0] = a[d * 2 + 1][0];
a[d][1] = a[d * 2 + 1][1];
}
}
f = a[0][1];
s[f] -= t;
}
s[f] += l;
nn = 0;
for (i = 0; i < n; i++) {
if (s[nn] < s[i])
nn = i;
}
nn++;
cout << nn << endl;
}
| replace | 4 | 5 | 4 | 5 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define INF (1e9)
typedef pair<int, int> pii;
const int MAX_N = (1 << 17);
struct RMQ {
int n;
pii dat[MAX_N];
void init(int n_) {
n = 1;
while (n < n_) {
n *= 2;
}
for (int i = 0; i < 2 * n - 1; i++) {
dat[i] = pii(-INF, -INF);
}
for (int i = 0; i < n_; i++) {
update(i, 0);
}
}
void update(int k, int a) {
int nk = k;
k += n - 1;
dat[k] = pii(a, -nk);
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
pii query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return pii(-INF, -INF);
if (a <= l && r <= b) {
return dat[k];
} else {
pii vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
pii vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
};
int main() {
int N, R, L;
cin >> N >> R >> L;
int d, t, x, pt = 0;
int point[MAX_N] = {};
RMQ r;
r.init(N);
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
d--;
point[-r.query(0, N, 0, 0, r.n).second] += t - pt;
r.update(d, x + r.dat[d + r.n - 1].first);
pt = t;
}
point[-r.query(0, N, 0, 0, r.n).second] += L - pt;
int mx = 0, num = -1;
for (int i = 0; i < N; i++) {
if (mx < point[i]) {
mx = point[i];
num = i + 1;
}
}
cout << num << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF (1e9)
typedef pair<int, int> pii;
const int MAX_N = (1 << 18);
struct RMQ {
int n;
pii dat[MAX_N];
void init(int n_) {
n = 1;
while (n < n_) {
n *= 2;
}
for (int i = 0; i < 2 * n - 1; i++) {
dat[i] = pii(-INF, -INF);
}
for (int i = 0; i < n_; i++) {
update(i, 0);
}
}
void update(int k, int a) {
int nk = k;
k += n - 1;
dat[k] = pii(a, -nk);
while (k > 0) {
k = (k - 1) / 2;
dat[k] = max(dat[k * 2 + 1], dat[k * 2 + 2]);
}
}
pii query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return pii(-INF, -INF);
if (a <= l && r <= b) {
return dat[k];
} else {
pii vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
pii vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return max(vl, vr);
}
}
};
int main() {
int N, R, L;
cin >> N >> R >> L;
int d, t, x, pt = 0;
int point[MAX_N] = {};
RMQ r;
r.init(N);
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
d--;
point[-r.query(0, N, 0, 0, r.n).second] += t - pt;
r.update(d, x + r.dat[d + r.n - 1].first);
pt = t;
}
point[-r.query(0, N, 0, 0, r.n).second] += L - pt;
int mx = 0, num = -1;
for (int i = 0; i < N; i++) {
if (mx < point[i]) {
mx = point[i];
num = i + 1;
}
}
cout << num << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00277 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <map>
#define f first
#define s second
#define MAX_T 100005
using namespace std;
typedef pair<int, int> P;
P teamp[MAX_T * 2 - 1];
P teamt[MAX_T * 2 - 1];
void init(int n);
void updateP(int k, int a, int n);
void updateT(int k, int a, int n);
int main() {
int N, R, L;
int d, t, x;
int befd = 0, beft = 0, nt, n = 1;
cin >> N >> R >> L;
while (n < N)
n *= 2;
init(n);
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
updateP(d - 1, x, n);
nt = t - beft;
beft = t;
updateT(befd, nt, n);
befd = teamp[0].s;
}
nt = L - beft;
updateT(befd, nt, n);
cout << teamt[0].s + 1 << endl;
}
void init(int n) {
for (int i = 0; i < n * 2 - 1; i++) {
teamp[i].f = 0;
teamt[i].f = 0;
}
for (int i = n - 1; i < n * 2 - 1; i++) {
teamp[i].s = i - (n - 1);
teamt[i].s = i - (n - 1);
}
return;
}
void updateP(int k, int a, int n) {
k += n - 1;
teamp[k].f += a;
while (k > 0) {
k = (k - 1) / 2;
if (teamp[k * 2 + 1].f >= teamp[k * 2 + 2].f) {
teamp[k].f = teamp[k * 2 + 1].f;
teamp[k].s = teamp[k * 2 + 1].s;
} else {
teamp[k].f = teamp[k * 2 + 2].f;
teamp[k].s = teamp[k * 2 + 2].s;
}
}
return;
}
void updateT(int k, int a, int n) {
k += n - 1;
teamt[k].f += a;
while (k > 0) {
k = (k - 1) / 2;
if (teamt[k * 2 + 1].f >= teamt[k * 2 + 2].f) {
teamt[k].f = teamt[k * 2 + 1].f;
teamt[k].s = teamt[k * 2 + 1].s;
} else {
teamt[k].f = teamt[k * 2 + 2].f;
teamt[k].s = teamt[k * 2 + 2].s;
}
}
return;
} | #include <algorithm>
#include <iostream>
#include <map>
#define f first
#define s second
#define MAX_T 100005
using namespace std;
typedef pair<int, int> P;
P teamp[MAX_T * 4 - 1];
P teamt[MAX_T * 4 - 1];
void init(int n);
void updateP(int k, int a, int n);
void updateT(int k, int a, int n);
int main() {
int N, R, L;
int d, t, x;
int befd = 0, beft = 0, nt, n = 1;
cin >> N >> R >> L;
while (n < N)
n *= 2;
init(n);
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
updateP(d - 1, x, n);
nt = t - beft;
beft = t;
updateT(befd, nt, n);
befd = teamp[0].s;
}
nt = L - beft;
updateT(befd, nt, n);
cout << teamt[0].s + 1 << endl;
}
void init(int n) {
for (int i = 0; i < n * 2 - 1; i++) {
teamp[i].f = 0;
teamt[i].f = 0;
}
for (int i = n - 1; i < n * 2 - 1; i++) {
teamp[i].s = i - (n - 1);
teamt[i].s = i - (n - 1);
}
return;
}
void updateP(int k, int a, int n) {
k += n - 1;
teamp[k].f += a;
while (k > 0) {
k = (k - 1) / 2;
if (teamp[k * 2 + 1].f >= teamp[k * 2 + 2].f) {
teamp[k].f = teamp[k * 2 + 1].f;
teamp[k].s = teamp[k * 2 + 1].s;
} else {
teamp[k].f = teamp[k * 2 + 2].f;
teamp[k].s = teamp[k * 2 + 2].s;
}
}
return;
}
void updateT(int k, int a, int n) {
k += n - 1;
teamt[k].f += a;
while (k > 0) {
k = (k - 1) / 2;
if (teamt[k * 2 + 1].f >= teamt[k * 2 + 2].f) {
teamt[k].f = teamt[k * 2 + 1].f;
teamt[k].s = teamt[k * 2 + 1].s;
} else {
teamt[k].f = teamt[k * 2 + 2].f;
teamt[k].s = teamt[k * 2 + 2].s;
}
}
return;
} | replace | 9 | 11 | 9 | 11 | 0 | |
p00277 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
// range MAXIMUM query
class RMQ {
private:
static const int MAX_N = 100000;
int n;
// score, -team_id
pii dat[2 * MAX_N - 1];
pii rec(int a, int b, int k, int l, int r) {
if (b <= l || r <= a) {
return {0, 0};
}
if (a <= l && r <= b) {
return dat[k];
} else {
pii rl = rec(a, b, 2 * k + 1, l, (l + r) / 2);
pii rr = rec(a, b, 2 * k + 2, (l + r) / 2, r);
return max(rl, rr);
}
}
public:
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++) {
dat[i] = {0, 0};
}
}
void update(int k, int a) {
int reaf = k + n - 1;
dat[reaf] = {dat[reaf].first + a, -k};
while (reaf > 0) {
reaf = (reaf - 1) / 2;
dat[reaf] = max(dat[reaf * 2 + 1], dat[2 * reaf + 2]);
}
}
pii query(int a, int b) { return rec(a, b + 1, 0, 0, n); }
};
int main() {
int team_n, record_n, end_time;
cin >> team_n >> record_n >> end_time;
RMQ r;
r.init(team_n);
REP(i, team_n) { r.update(i, 0); }
vi top(team_n);
int btime = 0;
REP(i, record_n) {
int team_id, time, point;
cin >> team_id >> time >> point;
team_id--;
pii t = r.query(0, team_n - 1);
top[-t.second] += time - btime;
btime = time;
// LOG("--> %d [%d] (%d)\n", t.first, -t.second, time - btime);
r.update(team_id, point);
}
pii t = r.query(0, team_n - 1);
top[-t.second] += end_time - btime;
cout << (max_element(ALL(top)) - top.begin() + 1) << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
// range MAXIMUM query
class RMQ {
private:
static const int MAX_N = 100000 * 2;
int n;
// score, -team_id
pii dat[2 * MAX_N - 1];
pii rec(int a, int b, int k, int l, int r) {
if (b <= l || r <= a) {
return {0, 0};
}
if (a <= l && r <= b) {
return dat[k];
} else {
pii rl = rec(a, b, 2 * k + 1, l, (l + r) / 2);
pii rr = rec(a, b, 2 * k + 2, (l + r) / 2, r);
return max(rl, rr);
}
}
public:
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++) {
dat[i] = {0, 0};
}
}
void update(int k, int a) {
int reaf = k + n - 1;
dat[reaf] = {dat[reaf].first + a, -k};
while (reaf > 0) {
reaf = (reaf - 1) / 2;
dat[reaf] = max(dat[reaf * 2 + 1], dat[2 * reaf + 2]);
}
}
pii query(int a, int b) { return rec(a, b + 1, 0, 0, n); }
};
int main() {
int team_n, record_n, end_time;
cin >> team_n >> record_n >> end_time;
RMQ r;
r.init(team_n);
REP(i, team_n) { r.update(i, 0); }
vi top(team_n);
int btime = 0;
REP(i, record_n) {
int team_id, time, point;
cin >> team_id >> time >> point;
team_id--;
pii t = r.query(0, team_n - 1);
top[-t.second] += time - btime;
btime = time;
// LOG("--> %d [%d] (%d)\n", t.first, -t.second, time - btime);
r.update(team_id, point);
}
pii t = r.query(0, team_n - 1);
top[-t.second] += end_time - btime;
cout << (max_element(ALL(top)) - top.begin() + 1) << endl;
} | replace | 28 | 29 | 28 | 29 | 0 | |
p00277 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, R, L;
cin >> N >> R >> L;
vector<long long int> data(N + 1, 0);
vector<int> timet(N + 1, 0);
int maxteam = 1;
int maxs = 0;
int time = 0;
int d, t, x;
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
timet[maxteam] += t - time;
data[d] += x;
time = t;
maxteam = 1;
maxs = data[1];
for (int j = 2; j <= N; j++) {
if (data[j] > maxs) {
maxs = data[j];
maxteam = j;
}
}
}
timet[maxteam] += L - time;
int k, ktoku;
k = 1;
ktoku = timet[1];
for (int i = 2; i <= N; i++) {
if (timet[i] > ktoku) {
ktoku = timet[i];
k = i;
}
}
cout << k << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, R, L;
cin >> N >> R >> L;
vector<long long int> data(N + 1, 0);
vector<int> timet(N + 1, 0);
int maxteam = 1;
int maxs = 0;
int time = 0;
int d, t, x;
for (int i = 0; i < R; i++) {
cin >> d >> t >> x;
timet[maxteam] += t - time;
data[d] += x;
time = t;
if (d == maxteam && x >= 0) {
maxs = data[d];
} else if (d != maxteam && data[d] < maxs) {
} else if (data[d] == maxs && d < maxteam) {
maxteam = d;
} else {
maxteam = 1;
maxs = data[1];
for (int j = 2; j <= N; j++) {
if (data[j] > maxs) {
maxs = data[j];
maxteam = j;
}
}
}
}
timet[maxteam] += L - time;
int k, ktoku;
k = 1;
ktoku = timet[1];
for (int i = 2; i <= N; i++) {
if (timet[i] > ktoku) {
ktoku = timet[i];
k = i;
}
}
cout << k << endl;
return 0;
} | replace | 19 | 25 | 19 | 32 | TLE | |
p00277 | C++ | Time Limit Exceeded | // 2013/11/05 Tazoe
#include <iostream>
using namespace std;
int main() {
int N, R, L;
cin >> N >> R >> L;
long long P[100001] = {0};
int W = 1;
int T[100001] = {0};
int tp = 0;
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
T[W] += t - tp;
tp = t;
P[d] += x;
if (x >= 0) {
if (P[W] < P[d] || (P[W] == P[d] && W > d)) {
W = d;
}
} else {
W = 1;
for (int j = 2; j <= N; j++) {
if (P[W] < P[j]) {
W = j;
}
}
}
// cout << W << ' ' << P[W] << endl;
}
T[W] += L - tp;
int C = 1;
for (int i = 2; i <= N; i++) {
if (T[C] < T[i]) {
C = i;
}
}
cout << C << endl;
return 0;
} | // 2013/11/05 Tazoe
#include <iostream>
using namespace std;
int main() {
int N, R, L;
cin >> N >> R >> L;
long long P[100001] = {0};
int W = 1;
int T[100001] = {0};
int tp = 0;
for (int i = 0; i < R; i++) {
int d, t, x;
cin >> d >> t >> x;
T[W] += t - tp;
tp = t;
P[d] += x;
if (x >= 0) {
if (P[W] < P[d] || (P[W] == P[d] && W > d)) {
W = d;
}
} else {
if (W == d) {
W = 1;
for (int j = 2; j <= N; j++) {
if (P[W] < P[j]) {
W = j;
}
}
}
}
// cout << W << ' ' << P[W] << endl;
}
T[W] += L - tp;
int C = 1;
for (int i = 2; i <= N; i++) {
if (T[C] < T[i]) {
C = i;
}
}
cout << C << endl;
return 0;
} | replace | 29 | 33 | 29 | 35 | TLE | |
p00279 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const double EPS = 1e-8;
const double INF = 1e77;
struct point {
double x, y;
point() : x(0), y(0) {}
point(double x, double y) : x(x), y(y) {}
point operator-(const point &a) const { return point(x - a.x, y - a.y); }
bool operator==(const point &a) const {
return abs(x - a.x) < EPS && abs(y - a.y) < EPS;
}
};
inline double cross(const point &a, const point &b) {
return a.x * b.y - a.y * b.x;
}
enum { CCW = 1, CW = -1, ON = 0 };
inline int ccw(const point &a, const point &b, const point &c) {
double rdir = cross(b - a, c - a);
if (rdir > EPS)
return CCW;
if (rdir < -EPS)
return CW;
return ON;
}
inline double area(const point &a, const point &b, const point &c) {
return abs(cross(b - a, c - a)) / 2;
}
int n;
point P[40];
int K;
double ans;
point Q[40], Q_ans[40];
bool vis[40];
int ub;
void dfs(int i, double a) { // a: area of the polygon Q[0...i-1]
ub++;
if (ub > 100000)
return; // テヲツ慊?ゥツ?ゥティツァツ」テ」ツ?凝」ツ?ゥテ」ツ??」ツ?凝」ツ?古ァツ「ツコテ、ツソツ。テ」ツ?ァテ」ツ?催」ツ?ェテ」ツ?湘」ツ?ヲテ」ツつづ・ツ債?・ツ按?」ツ?淌」ツ?湘」ツ?陛」ツつ禿ィツェツソテ」ツ?ケテ」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?..
if (i == K) {
if (a < ans) {
ans = a;
memcpy(Q_ans, Q, sizeof Q);
}
return;
}
// pruning
// テ・ツ?凖ィツ」ツ愿ァツつケテ」ツ?ョテヲツ閉ーテ」ツ?古ィツカツウテ」ツつ甘」ツ?ェテ」ツ?湘」ツ?ェテ」ツ?」テ」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?
int m = 0, next[40]; // next candidates
rep(j, n) {
if (!vis[j] && ccw(Q[i - 2], Q[i - 1], P[j]) == CCW &&
ccw(Q[i - 1], P[j], Q[0]) == CCW)
next[m++] = j;
}
if (m < K - i)
return;
// pruning
// テゥツ敖「テァツゥツ催」ツ?古、ツサツ甘」ツ?セテ」ツ?ァテ」ツ?ョテヲツ慊?・ツーツ湘」ツつ津ィツカツ?」ツ?暗」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?
double da = INF;
rep(j, m) da = min(da, area(Q[i - 1], P[next[j]], Q[0]));
if (ans < a + da + EPS)
return;
double res = INF;
rep(j, m) {
Q[i] = P[next[j]];
vis[next[j]] = true;
dfs(i + 1, a + area(Q[0], Q[i - 1], Q[i]));
vis[next[j]] = false;
}
}
int main() {
scanf("%d", &n);
rep(i, n) scanf("%lf%lf", &P[i].x, &P[i].y);
int q;
scanf("%d", &q);
int k[40], perm[40];
rep(i, q) scanf("%d", k + i);
{
pair<int, int> tmp[40];
rep(i, q) tmp[i] = make_pair(k[i], i);
sort(tmp, tmp + q);
rep(i, q) {
k[i] = tmp[i].first;
perm[tmp[i].second] = i;
}
}
int k_ans[40][40];
rep(i, n) k_ans[i][0] = -1; // NA
// k
// テ」ツ?ョテ・ツーツ湘」ツ?陛」ツ??ゥツ??」ツ?ォテ・ツ?ヲテァツ青?」ツ?療」ツ?ヲテ」ツ??」ツ??
// テ、ツクツ?・ツコツヲ NA
// テ」ツ?ォテ」ツ?ェテ」ツ?」テ」ツ?淌」ツつ嘉」ツ?敕」ツつ古、ツサツ・テゥツ卍催」ツ?ッテ・ツ?ィテゥツδィ
// NA
rep(i, q) {
K = k[i];
ans = INF;
rep(j, n) rep(k, n) if (j != k) { // fix an edge of the polygon
Q[0] = P[j];
Q[1] = P[k];
rep(l, n) vis[l] = false;
vis[j] = vis[k] = true;
// pruning
// テヲツ伉偲」ツつ嘉」ツ?凝」ツ?ォテ」ツδ?」ツδ。テ」ツ?ェテァツつケテ」ツ?ッテヲツ慊?・ツ按敕」ツ?凝」ツつ嘉ィツェツソテ」ツ?ケテ」ツ?ェテ」ツ??
rep(l, n) if (ccw(Q[0], Q[1], P[l]) != CCW ||
ccw(P[l], Q[0], Q[1]) != CCW) vis[l] = true;
ub = 0;
dfs(2, 0);
}
if (ans > INF / 2)
break; // NA
int j0 = 0;
vector<int> seq(K);
rep(j, K) {
seq[j] = find(P, P + n, Q_ans[j]) - P;
if (make_pair(Q_ans[j].y, Q_ans[j].x) <
make_pair(Q_ans[j0].y, Q_ans[j0].x))
j0 = j;
}
rep(j, j0) {
seq.push_back(seq[0]);
seq.erase(seq.begin());
}
rep(j, K) k_ans[i][j] = seq[j];
}
rep(i, q) {
int idx = perm[i];
if (k_ans[idx][0] == -1)
puts("NA");
else {
rep(j, k[idx])
printf("%d%c", k_ans[idx][j] + 1, j < k[idx] - 1 ? ' ' : '\n');
}
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const double EPS = 1e-8;
const double INF = 1e77;
struct point {
double x, y;
point() : x(0), y(0) {}
point(double x, double y) : x(x), y(y) {}
point operator-(const point &a) const { return point(x - a.x, y - a.y); }
bool operator==(const point &a) const {
return abs(x - a.x) < EPS && abs(y - a.y) < EPS;
}
};
inline double cross(const point &a, const point &b) {
return a.x * b.y - a.y * b.x;
}
enum { CCW = 1, CW = -1, ON = 0 };
inline int ccw(const point &a, const point &b, const point &c) {
double rdir = cross(b - a, c - a);
if (rdir > EPS)
return CCW;
if (rdir < -EPS)
return CW;
return ON;
}
inline double area(const point &a, const point &b, const point &c) {
return abs(cross(b - a, c - a)) / 2;
}
int n;
point P[40];
int K;
double ans;
point Q[40], Q_ans[40];
bool vis[40];
int ub;
void dfs(int i, double a) { // a: area of the polygon Q[0...i-1]
ub++;
if (ub > 10000)
return; // テヲツ慊?ゥツ?ゥティツァツ」テ」ツ?凝」ツ?ゥテ」ツ??」ツ?凝」ツ?古ァツ「ツコテ、ツソツ。テ」ツ?ァテ」ツ?催」ツ?ェテ」ツ?湘」ツ?ヲテ」ツつづ・ツ債?・ツ按?」ツ?淌」ツ?湘」ツ?陛」ツつ禿ィツェツソテ」ツ?ケテ」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?..
if (i == K) {
if (a < ans) {
ans = a;
memcpy(Q_ans, Q, sizeof Q);
}
return;
}
// pruning
// テ・ツ?凖ィツ」ツ愿ァツつケテ」ツ?ョテヲツ閉ーテ」ツ?古ィツカツウテ」ツつ甘」ツ?ェテ」ツ?湘」ツ?ェテ」ツ?」テ」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?
int m = 0, next[40]; // next candidates
rep(j, n) {
if (!vis[j] && ccw(Q[i - 2], Q[i - 1], P[j]) == CCW &&
ccw(Q[i - 1], P[j], Q[0]) == CCW)
next[m++] = j;
}
if (m < K - i)
return;
// pruning
// テゥツ敖「テァツゥツ催」ツ?古、ツサツ甘」ツ?セテ」ツ?ァテ」ツ?ョテヲツ慊?・ツーツ湘」ツつ津ィツカツ?」ツ?暗」ツ?淌」ツつ嘉ヲツ可禿」ツ?。テ・ツ按?」ツつ?
double da = INF;
rep(j, m) da = min(da, area(Q[i - 1], P[next[j]], Q[0]));
if (ans < a + da + EPS)
return;
double res = INF;
rep(j, m) {
Q[i] = P[next[j]];
vis[next[j]] = true;
dfs(i + 1, a + area(Q[0], Q[i - 1], Q[i]));
vis[next[j]] = false;
}
}
int main() {
scanf("%d", &n);
rep(i, n) scanf("%lf%lf", &P[i].x, &P[i].y);
int q;
scanf("%d", &q);
int k[40], perm[40];
rep(i, q) scanf("%d", k + i);
{
pair<int, int> tmp[40];
rep(i, q) tmp[i] = make_pair(k[i], i);
sort(tmp, tmp + q);
rep(i, q) {
k[i] = tmp[i].first;
perm[tmp[i].second] = i;
}
}
int k_ans[40][40];
rep(i, n) k_ans[i][0] = -1; // NA
// k
// テ」ツ?ョテ・ツーツ湘」ツ?陛」ツ??ゥツ??」ツ?ォテ・ツ?ヲテァツ青?」ツ?療」ツ?ヲテ」ツ??」ツ??
// テ、ツクツ?・ツコツヲ NA
// テ」ツ?ォテ」ツ?ェテ」ツ?」テ」ツ?淌」ツつ嘉」ツ?敕」ツつ古、ツサツ・テゥツ卍催」ツ?ッテ・ツ?ィテゥツδィ
// NA
rep(i, q) {
K = k[i];
ans = INF;
rep(j, n) rep(k, n) if (j != k) { // fix an edge of the polygon
Q[0] = P[j];
Q[1] = P[k];
rep(l, n) vis[l] = false;
vis[j] = vis[k] = true;
// pruning
// テヲツ伉偲」ツつ嘉」ツ?凝」ツ?ォテ」ツδ?」ツδ。テ」ツ?ェテァツつケテ」ツ?ッテヲツ慊?・ツ按敕」ツ?凝」ツつ嘉ィツェツソテ」ツ?ケテ」ツ?ェテ」ツ??
rep(l, n) if (ccw(Q[0], Q[1], P[l]) != CCW ||
ccw(P[l], Q[0], Q[1]) != CCW) vis[l] = true;
ub = 0;
dfs(2, 0);
}
if (ans > INF / 2)
break; // NA
int j0 = 0;
vector<int> seq(K);
rep(j, K) {
seq[j] = find(P, P + n, Q_ans[j]) - P;
if (make_pair(Q_ans[j].y, Q_ans[j].x) <
make_pair(Q_ans[j0].y, Q_ans[j0].x))
j0 = j;
}
rep(j, j0) {
seq.push_back(seq[0]);
seq.erase(seq.begin());
}
rep(j, K) k_ans[i][j] = seq[j];
}
rep(i, q) {
int idx = perm[i];
if (k_ans[idx][0] == -1)
puts("NA");
else {
rep(j, k[idx])
printf("%d%c", k_ans[idx][j] + 1, j < k[idx] - 1 ? ' ' : '\n');
}
}
return 0;
} | replace | 52 | 53 | 52 | 53 | TLE | |
p00279 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
namespace geometry {
// ???????????§??????
typedef complex<double> Point;
struct Segment {
Point p1, p2;
Segment(const Point &p1 = Point(), const Point &p2 = Point())
: p1(p1), p2(p2) {}
};
struct Circle {
Point p;
double r;
Circle(const Point &p = Point(), double r = 0.0) : p(p), r(r) {}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
// ??\??????
inline istream &operator>>(istream &is, Point &p) {
double x, y;
is >> x >> y;
p.real(x), p.imag(y);
return is;
}
inline istream &operator>>(istream &is, Segment &s) {
return is >> s.p1 >> s.p2;
}
inline istream &operator>>(istream &is, Circle &c) { return is >> c.p >> c.r; }
inline ostream &operator<<(ostream &os, Segment &s) {
return os << "{" << s.p1 << ", " << s.p2 << "}";
}
inline ostream &operator<<(ostream &os, Circle &c) {
return os << "{" << c.p << ", " << c.r << "}";
}
inline ostream &operator<<(ostream &os, Polygon &g) {
os << "{";
bool f = false;
for (auto &p : g) {
if (f)
os << ", ";
os << p;
f = true;
}
return os << "}";
}
// ?????°, ??????
const double PI = acos(-1);
const double EPS = 1e-8;
const double INF = 1e16;
const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
const int OUT = 0;
const int ON = 1;
const int IN = 2;
inline double square(double a) { return a * a; }
inline bool equal(double a, double b) { return abs(a - b) < EPS; }
inline bool equalVector(const Vector &a, const Vector &b) {
return equal(a.real(), b.real()) && equal(a.imag(), b.imag());
}
inline double norm(const Point &a) {
return square(a.real()) + square(a.imag());
}
inline double dot(const Point &a, const Point &b) {
return (conj(a) * b).real();
}
inline double cross(const Point &a, const Point &b) {
return (conj(a) * b).imag();
}
// ????????¢??° (x ??§?¨?, y ??§?¨?, ????§?)
// ????§?????????????????????? Point rp ?????£??\????????????
bool cmpx(const Point &a, const Point &b) {
if (!equal(a.real(), b.real()))
return a.real() < b.real();
return b.imag() < b.imag();
}
bool cmpy(const Point &a, const Point &b) {
if (!equal(a.imag(), b.imag()))
return a.imag() < b.imag();
return a.real() < b.real();
}
Point rp;
bool cmparg(const Point &a, const Point &b) {
double rada = arg(a - rp);
if (rada < 0.0)
rada += 2 * PI;
double radb = arg(b - rp);
if (radb < 0.0)
radb += 2 * PI;
if (!equal(rada, radb))
return rada < radb;
return norm(a) < norm(b);
}
// ??´???, ??????
bool orthgonal(const Vector &a, const Vector &b) {
return equal(dot(a, b), 0.0);
}
bool parallel(const Vector &a, const Vector &b) {
return equal(cross(a, b), 0.0);
}
// ????°?, ?°???±
Point project(const Segment &s, const Point &p) {
Vector base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / norm(base);
return s.p1 + base * r;
}
Point reflect(const Segment &s, const Point &p) {
return p + (project(s, p) - p) * 2.0;
}
// ??????????????????
int ccw(const Point &p0, const Point &p1, const Point &p2) {
Vector a = p1 - p0;
Vector b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) > norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
// ?????¢
double distanceLP(const Line &l, const Point &p) {
return abs((l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double distanceSP(const Segment &s, const Point &p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
return abs(p - s.p1);
if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
return abs(p - s.p2);
return distanceLP(s, p);
}
bool intersect(const Segment &s1, const Segment &s2);
double distance(const Segment &s1, const Segment &s2) {
if (intersect(s1, s2))
return 0.0;
return min(min(distanceSP(s1, s2.p1), distance(s1, s2.p2)),
min(distanceSP(s2, s1.p1), distance(s2, s1.p2)));
}
// ????????????
bool intersect(const Segment &s1, const Segment &s2) {
return ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0 &&
ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0;
}
int intersect(const Circle &c, const Segment &s) {
// ???????????° (0 ~ 2) ?????????
double dist = distanceSP(s, c.p) - c.r;
if (dist < -EPS)
return 2;
if (equal(dist, 0.0))
return 1;
return 0;
}
int intersect(const Circle &c1, const Circle &c2) {
// ???????????° (0 ~ 2) ?????????
double dist = abs(c1.p - c2.p) - (c1.r + c2.r);
if (dist < -EPS)
return 2;
if (equal(dist, 0.0))
return 1;
return 0;
}
// ??????
Point crossPoint(const Segment &s1, const Segment &s2) {
Vector base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
// !! ????????´?????¶????????????????????\????????¨ 0 ?????? !!
assert(!equal(d1 + d2, 0.0));
double t = d1 / (d1 + d2);
return s1.p1 + (s1.p2 - s1.p1) * t;
}
vector<Point> crossPoints(const Circle &c, const Line &l) {
vector<Point> res;
if (!intersect(c, l))
return res;
Vector pr = project(l, c.p);
Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
double base = sqrt(c.r * c.r - norm(pr - c.p));
res.push_back(pr + e * base);
res.push_back(pr - e * base);
if (equalVector(res[0], res[1]))
res.pop_back();
return res;
}
vector<Point> crossPoints(const Circle &c1, const Circle &c2) {
vector<Point> res;
if (!intersect(c1, c2))
return res;
double d = abs(c1.p - c2.p);
double a = acos(square(c1.r) + square(d) - square(c2.r) / (2 * c2.r * d));
double t = arg(c2.p - c1.p);
res.push_back(c1.p + polar(c1.r, t + a));
res.push_back(c1.p + polar(c1.r, t - a));
if (equalVector(res[0], res[1]))
res.pop_back();
}
// ??????
int contains(const Polygon &g, const Point &p) {
int n = g.size();
bool res = false;
for (int i = 0; i < n; i++) {
Point a = g[i] - p;
Point b = g[(i + 1) % n] - p;
if (abs(cross(a, b)) < EPS && dot(a, b) < EPS)
return ON;
if (a.imag() > b.imag())
swap(a, b);
if (a.imag() < EPS && EPS < b.imag() && cross(a, b) > EPS)
res = !res;
}
return res ? IN : OUT;
}
// ??????
Polygon convexHull(vector<Point> s) {
Polygon u, l;
if (s.size() < 3)
return s;
sort(s.begin(), s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size() - 1]);
l.push_back(s[s.size() - 2]);
for (int i = 2; i < s.size(); i++) {
int n = u.size();
while (n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE) {
u.pop_back();
n--;
}
u.push_back(s[i]);
}
for (int i = s.size() - 3; i >= 0; i--) {
int n = l.size();
while (n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE) {
l.pop_back();
n--;
}
l.push_back(s[i]);
}
reverse(l.begin(), l.end());
for (int i = u.size() - 2; i >= 1; i--) {
l.push_back(u[i]);
}
return l;
}
} // namespace geometry
namespace std {
bool operator<(const geometry::Point &a, const geometry::Point &b) {
return geometry::cmpx(a, b);
}
} // namespace std
using namespace geometry;
int n;
Point p[40];
vector<int> np[40];
vector<int> res[41];
bool cmp(int a, int b) { return cmparg(p[a], p[b]); }
double area(Point &p, Point &a, Point &b) { return cross(a - p, b - p) / 2; }
void solve() {
// [?§????][n ?§???¢][2??????][1??????]
static double dp[40][40][40][40];
fill_n(***dp, 40 * 40 * 40 * 40, INF);
for (int i = 0; i < n; i++) {
for (int j = 0; j < np[i].size(); j++) {
for (int k = j + 1; k < np[i].size(); k++) {
Point &p1 = p[np[i][j]];
Point &p2 = p[np[i][k]];
if (area(p[i], p1, p2) < 0.0)
continue;
if (p1.imag() < p[i].imag())
continue;
if (p2.imag() <= p[i].imag())
continue;
dp[i][3][j][k] = area(p[i], p1, p2);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 3; j < n; j++) {
for (int k = 0; k < np[i].size(); k++) {
for (int l = k + 1; l < np[i].size(); l++) {
for (int m = l + 1; m < np[i].size(); m++) {
Point &p0 = p[np[i][k]];
Point &p1 = p[np[i][l]];
Point &p2 = p[np[i][m]];
if (p2.imag() <= p[i].imag())
continue;
if (area(p0, p1, p2) < 0.0)
continue;
dp[i][j + 1][l][m] =
min(dp[i][j + 1][l][m], dp[i][j][k][l] + area(p[i], p1, p2));
}
}
}
}
}
for (int v = 3; v <= n; v++) {
int st = 0, t = 0, s = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (dp[st][v][s][t] > dp[i][v][j][k]) {
st = i;
s = j;
t = k;
}
}
}
}
res[v].push_back(np[st][t] + 1);
res[v].push_back(np[st][s] + 1);
for (int i = v; i > 3; i--) {
bool f = false;
for (int j = 0; j < n; j++) {
double cura = dp[st][i][s][t];
double prea = dp[st][i - 1][j][s];
double da = area(p[st], p[np[st][s]], p[np[st][t]]);
if (cura == INF || prea == INF)
continue;
if (area(p[np[st][j]], p[np[st][s]], p[np[st][t]]) < 0.0)
continue;
if (equal(cura - prea, da)) {
t = s;
s = j;
f = true;
break;
}
}
if (!f)
break;
res[v].push_back(np[st][s] + 1);
}
res[v].push_back(st + 1);
reverse(res[v].begin(), res[v].end());
}
}
void output(int v) {
if (res[v].size() != v)
cout << "NA" << endl;
else {
for (int i = 0; i < v; i++) {
if (i)
cout << " ";
cout << res[v][i];
}
cout << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j)
np[i].push_back(j);
}
rp = p[i];
sort(np[i].begin(), np[i].end(), cmp);
}
solve();
int Q;
cin >> Q;
while (Q--) {
int v;
cin >> v;
output(v);
}
} | #include <bits/stdc++.h>
using namespace std;
namespace geometry {
// ???????????§??????
typedef complex<double> Point;
struct Segment {
Point p1, p2;
Segment(const Point &p1 = Point(), const Point &p2 = Point())
: p1(p1), p2(p2) {}
};
struct Circle {
Point p;
double r;
Circle(const Point &p = Point(), double r = 0.0) : p(p), r(r) {}
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
// ??\??????
inline istream &operator>>(istream &is, Point &p) {
double x, y;
is >> x >> y;
p.real(x), p.imag(y);
return is;
}
inline istream &operator>>(istream &is, Segment &s) {
return is >> s.p1 >> s.p2;
}
inline istream &operator>>(istream &is, Circle &c) { return is >> c.p >> c.r; }
inline ostream &operator<<(ostream &os, Segment &s) {
return os << "{" << s.p1 << ", " << s.p2 << "}";
}
inline ostream &operator<<(ostream &os, Circle &c) {
return os << "{" << c.p << ", " << c.r << "}";
}
inline ostream &operator<<(ostream &os, Polygon &g) {
os << "{";
bool f = false;
for (auto &p : g) {
if (f)
os << ", ";
os << p;
f = true;
}
return os << "}";
}
// ?????°, ??????
const double PI = acos(-1);
const double EPS = 1e-8;
const double INF = 1e16;
const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
const int OUT = 0;
const int ON = 1;
const int IN = 2;
inline double square(double a) { return a * a; }
inline bool equal(double a, double b) { return abs(a - b) < EPS; }
inline bool equalVector(const Vector &a, const Vector &b) {
return equal(a.real(), b.real()) && equal(a.imag(), b.imag());
}
inline double norm(const Point &a) {
return square(a.real()) + square(a.imag());
}
inline double dot(const Point &a, const Point &b) {
return (conj(a) * b).real();
}
inline double cross(const Point &a, const Point &b) {
return (conj(a) * b).imag();
}
// ????????¢??° (x ??§?¨?, y ??§?¨?, ????§?)
// ????§?????????????????????? Point rp ?????£??\????????????
bool cmpx(const Point &a, const Point &b) {
if (!equal(a.real(), b.real()))
return a.real() < b.real();
return b.imag() < b.imag();
}
bool cmpy(const Point &a, const Point &b) {
if (!equal(a.imag(), b.imag()))
return a.imag() < b.imag();
return a.real() < b.real();
}
Point rp;
bool cmparg(const Point &a, const Point &b) {
double rada = arg(a - rp);
if (rada < 0.0)
rada += 2 * PI;
double radb = arg(b - rp);
if (radb < 0.0)
radb += 2 * PI;
if (!equal(rada, radb))
return rada < radb;
return norm(a) < norm(b);
}
// ??´???, ??????
bool orthgonal(const Vector &a, const Vector &b) {
return equal(dot(a, b), 0.0);
}
bool parallel(const Vector &a, const Vector &b) {
return equal(cross(a, b), 0.0);
}
// ????°?, ?°???±
Point project(const Segment &s, const Point &p) {
Vector base = s.p2 - s.p1;
double r = dot(p - s.p1, base) / norm(base);
return s.p1 + base * r;
}
Point reflect(const Segment &s, const Point &p) {
return p + (project(s, p) - p) * 2.0;
}
// ??????????????????
int ccw(const Point &p0, const Point &p1, const Point &p2) {
Vector a = p1 - p0;
Vector b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) > norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
// ?????¢
double distanceLP(const Line &l, const Point &p) {
return abs((l.p2 - l.p1, p - l.p1) / abs(l.p2 - l.p1));
}
double distanceSP(const Segment &s, const Point &p) {
if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
return abs(p - s.p1);
if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
return abs(p - s.p2);
return distanceLP(s, p);
}
bool intersect(const Segment &s1, const Segment &s2);
double distance(const Segment &s1, const Segment &s2) {
if (intersect(s1, s2))
return 0.0;
return min(min(distanceSP(s1, s2.p1), distance(s1, s2.p2)),
min(distanceSP(s2, s1.p1), distance(s2, s1.p2)));
}
// ????????????
bool intersect(const Segment &s1, const Segment &s2) {
return ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0 &&
ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0;
}
int intersect(const Circle &c, const Segment &s) {
// ???????????° (0 ~ 2) ?????????
double dist = distanceSP(s, c.p) - c.r;
if (dist < -EPS)
return 2;
if (equal(dist, 0.0))
return 1;
return 0;
}
int intersect(const Circle &c1, const Circle &c2) {
// ???????????° (0 ~ 2) ?????????
double dist = abs(c1.p - c2.p) - (c1.r + c2.r);
if (dist < -EPS)
return 2;
if (equal(dist, 0.0))
return 1;
return 0;
}
// ??????
Point crossPoint(const Segment &s1, const Segment &s2) {
Vector base = s2.p2 - s2.p1;
double d1 = abs(cross(base, s1.p1 - s2.p1));
double d2 = abs(cross(base, s1.p2 - s2.p1));
// !! ????????´?????¶????????????????????\????????¨ 0 ?????? !!
assert(!equal(d1 + d2, 0.0));
double t = d1 / (d1 + d2);
return s1.p1 + (s1.p2 - s1.p1) * t;
}
vector<Point> crossPoints(const Circle &c, const Line &l) {
vector<Point> res;
if (!intersect(c, l))
return res;
Vector pr = project(l, c.p);
Vector e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
double base = sqrt(c.r * c.r - norm(pr - c.p));
res.push_back(pr + e * base);
res.push_back(pr - e * base);
if (equalVector(res[0], res[1]))
res.pop_back();
return res;
}
vector<Point> crossPoints(const Circle &c1, const Circle &c2) {
vector<Point> res;
if (!intersect(c1, c2))
return res;
double d = abs(c1.p - c2.p);
double a = acos(square(c1.r) + square(d) - square(c2.r) / (2 * c2.r * d));
double t = arg(c2.p - c1.p);
res.push_back(c1.p + polar(c1.r, t + a));
res.push_back(c1.p + polar(c1.r, t - a));
if (equalVector(res[0], res[1]))
res.pop_back();
}
// ??????
int contains(const Polygon &g, const Point &p) {
int n = g.size();
bool res = false;
for (int i = 0; i < n; i++) {
Point a = g[i] - p;
Point b = g[(i + 1) % n] - p;
if (abs(cross(a, b)) < EPS && dot(a, b) < EPS)
return ON;
if (a.imag() > b.imag())
swap(a, b);
if (a.imag() < EPS && EPS < b.imag() && cross(a, b) > EPS)
res = !res;
}
return res ? IN : OUT;
}
// ??????
Polygon convexHull(vector<Point> s) {
Polygon u, l;
if (s.size() < 3)
return s;
sort(s.begin(), s.end());
u.push_back(s[0]);
u.push_back(s[1]);
l.push_back(s[s.size() - 1]);
l.push_back(s[s.size() - 2]);
for (int i = 2; i < s.size(); i++) {
int n = u.size();
while (n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE) {
u.pop_back();
n--;
}
u.push_back(s[i]);
}
for (int i = s.size() - 3; i >= 0; i--) {
int n = l.size();
while (n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE) {
l.pop_back();
n--;
}
l.push_back(s[i]);
}
reverse(l.begin(), l.end());
for (int i = u.size() - 2; i >= 1; i--) {
l.push_back(u[i]);
}
return l;
}
} // namespace geometry
namespace std {
bool operator<(const geometry::Point &a, const geometry::Point &b) {
return geometry::cmpx(a, b);
}
} // namespace std
using namespace geometry;
int n;
Point p[40];
vector<int> np[40];
vector<int> res[41];
bool cmp(int a, int b) { return cmparg(p[a], p[b]); }
double area(Point &p, Point &a, Point &b) { return cross(a - p, b - p) / 2; }
void solve() {
// [?§????][n ?§???¢][2??????][1??????]
static double dp[40][41][40][40];
fill_n(***dp, 40 * 41 * 40 * 40, INF);
for (int i = 0; i < n; i++) {
for (int j = 0; j < np[i].size(); j++) {
for (int k = j + 1; k < np[i].size(); k++) {
Point &p1 = p[np[i][j]];
Point &p2 = p[np[i][k]];
if (area(p[i], p1, p2) < 0.0)
continue;
if (p1.imag() < p[i].imag())
continue;
if (p2.imag() <= p[i].imag())
continue;
dp[i][3][j][k] = area(p[i], p1, p2);
}
}
}
for (int i = 0; i < n; i++) {
for (int j = 3; j < n; j++) {
for (int k = 0; k < np[i].size(); k++) {
for (int l = k + 1; l < np[i].size(); l++) {
for (int m = l + 1; m < np[i].size(); m++) {
Point &p0 = p[np[i][k]];
Point &p1 = p[np[i][l]];
Point &p2 = p[np[i][m]];
if (p2.imag() <= p[i].imag())
continue;
if (area(p0, p1, p2) < 0.0)
continue;
dp[i][j + 1][l][m] =
min(dp[i][j + 1][l][m], dp[i][j][k][l] + area(p[i], p1, p2));
}
}
}
}
}
for (int v = 3; v <= n; v++) {
int st = 0, t = 0, s = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
for (int k = 0; k < n; k++) {
if (dp[st][v][s][t] > dp[i][v][j][k]) {
st = i;
s = j;
t = k;
}
}
}
}
res[v].push_back(np[st][t] + 1);
res[v].push_back(np[st][s] + 1);
for (int i = v; i > 3; i--) {
bool f = false;
for (int j = 0; j < n; j++) {
double cura = dp[st][i][s][t];
double prea = dp[st][i - 1][j][s];
double da = area(p[st], p[np[st][s]], p[np[st][t]]);
if (cura == INF || prea == INF)
continue;
if (area(p[np[st][j]], p[np[st][s]], p[np[st][t]]) < 0.0)
continue;
if (equal(cura - prea, da)) {
t = s;
s = j;
f = true;
break;
}
}
if (!f)
break;
res[v].push_back(np[st][s] + 1);
}
res[v].push_back(st + 1);
reverse(res[v].begin(), res[v].end());
}
}
void output(int v) {
if (res[v].size() != v)
cout << "NA" << endl;
else {
for (int i = 0; i < v; i++) {
if (i)
cout << " ";
cout << res[v][i];
}
cout << endl;
}
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> p[i];
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (i != j)
np[i].push_back(j);
}
rp = p[i];
sort(np[i].begin(), np[i].end(), cmp);
}
solve();
int Q;
cin >> Q;
while (Q--) {
int v;
cin >> v;
output(v);
}
} | replace | 320 | 322 | 320 | 322 | 0 | |
p00280 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int J, Y;
void t(int j, int y, string str) {
if (j > J && y > Y)
return;
if (j == J && y == Y) {
cout << str << endl;
return;
}
if (j == 5 && y == 5) {
return;
}
if ((j <= 3 && y >= 5) || (j >= 5 && y <= 3)) {
return;
}
t(j + 1, y, str + "A");
t(j, y + 1, str + "B");
}
int main() {
scanf("%d %d", &J, &Y);
t(0, 0, "");
} | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int J, Y;
void t(int j, int y, string str) {
if (j > J || y > Y)
return;
if (j == J && y == Y) {
cout << str << endl;
return;
}
if (j == 5 && y == 5) {
return;
}
if ((j <= 3 && y >= 5) || (j >= 5 && y <= 3)) {
return;
}
t(j + 1, y, str + "A");
t(j, y + 1, str + "B");
}
int main() {
scanf("%d %d", &J, &Y);
t(0, 0, "");
} | replace | 9 | 10 | 9 | 10 | 0 | |
p00280 | C++ | Runtime Error | #include <iostream>
#include <string>
using namespace std;
int a, b;
void rec(string s, int x, int y) {
if (a == x && b == y) {
cout << s << endl;
return;
}
if ((x < 4 || y < 4) && (x == 5 || y == 5))
return;
rec(s + "A", x + 1, y);
rec(s + "B", x, y + 1);
}
int main() {
scanf("%d%d", &a, &b);
rec("", 0, 0);
} | #include <iostream>
#include <string>
using namespace std;
int a, b;
void rec(string s, int x, int y) {
if (a == x && b == y) {
cout << s << endl;
return;
}
if ((x < 4 || y < 4) && (x == 5 || y == 5))
return;
if (x + y > 9)
return;
rec(s + "A", x + 1, y);
rec(s + "B", x, y + 1);
}
int main() {
scanf("%d%d", &a, &b);
rec("", 0, 0);
} | insert | 11 | 11 | 11 | 13 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p00281 | C++ | Runtime Error | #include <algorithm>
#include <stdio.h>
using namespace std;
int s[11000];
int t[11000];
int e[11000];
int d[11000];
long long ret[11000];
int main() {
int a, b;
scanf("%d%d", &a, &b);
int p, q, r;
int sz = 0;
while (scanf("%d%d%d", &p, &q, &r), p) {
p--;
q--;
s[sz] = p;
t[sz] = q;
e[sz++] = r;
}
int c;
scanf("%d", &c);
for (int i = 0; i < c; i++) {
for (int j = 0; j < b; j++)
scanf("%d", d + j);
for (int j = 0; j < a; j++)
ret[j] = 0LL;
for (int j = 0; j < sz; j++)
ret[s[j]] += d[t[j]] * e[j];
for (int j = 0; j < a; j++) {
if (j)
printf(" ");
printf("%lld", ret[j]);
}
printf("\n");
}
} | #include <algorithm>
#include <stdio.h>
using namespace std;
int s[51000];
int t[51000];
int e[51000];
int d[11000];
long long ret[11000];
int main() {
int a, b;
scanf("%d%d", &a, &b);
int p, q, r;
int sz = 0;
while (scanf("%d%d%d", &p, &q, &r), p) {
p--;
q--;
s[sz] = p;
t[sz] = q;
e[sz++] = r;
}
int c;
scanf("%d", &c);
for (int i = 0; i < c; i++) {
for (int j = 0; j < b; j++)
scanf("%d", d + j);
for (int j = 0; j < a; j++)
ret[j] = 0LL;
for (int j = 0; j < sz; j++)
ret[s[j]] += d[t[j]] * e[j];
for (int j = 0; j < a; j++) {
if (j)
printf(" ");
printf("%lld", ret[j]);
}
printf("\n");
}
} | replace | 3 | 6 | 3 | 6 | 0 | |
p00281 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M, s, t, e;
cin >> N >> M;
vector<ll> S, T, E, c(N);
while (cin >> s >> t >> e, s) {
S.push_back(s - 1);
T.push_back(t - 1);
E.push_back(e);
}
ll L;
cin >> L;
for (int i = 0; i < L; i++) {
ll b[L];
for (int j = 0; j < N; j++) {
c[j] = 0;
}
for (int j = 0; j < M; j++) {
cin >> b[j];
}
for (int j = 0; j < (int)S.size(); j++) {
c[S[j]] += b[T[j]] * E[j];
}
for (int j = 0; j < N; j++) {
if (j > 0) {
cout << " ";
}
cout << c[j];
}
cout << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
ll N, M, s, t, e;
cin >> N >> M;
vector<ll> S, T, E, c(N);
while (cin >> s >> t >> e, s) {
S.push_back(s - 1);
T.push_back(t - 1);
E.push_back(e);
}
ll L;
cin >> L;
for (int i = 0; i < L; i++) {
ll b[M];
for (int j = 0; j < N; j++) {
c[j] = 0;
}
for (int j = 0; j < M; j++) {
cin >> b[j];
}
for (int j = 0; j < (int)S.size(); j++) {
c[S[j]] += b[T[j]] * E[j];
}
for (int j = 0; j < N; j++) {
if (j > 0) {
cout << " ";
}
cout << c[j];
}
cout << endl;
}
return 0;
} | replace | 18 | 19 | 18 | 19 | 0 | |
p00282 | C++ | Runtime Error | // Template {{{
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (int i = 0; i < v.size(); i++)
os << v[i] << (i + 1 < v.size() ? ", " : "");
os << "}";
return os;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
}
//}}}
const int BASE = 10000;
typedef vector<int> Num;
Num normalize(Num c) {
int carry = 0;
for (int i = 0; i < c.size(); i++) {
c[i] += carry;
carry = c[i] / BASE;
c[i] %= BASE;
}
if (carry > 0)
c.push_back(carry);
return c;
}
Num mul(const Num &a, const Num &b) {
int n = a.size();
int m = b.size();
Num c(n - 1 + m - 1 + 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c[i + j] += a[i] * b[j];
}
}
return normalize(c);
}
Num add(const Num &a, const Num &b) {
Num c(max(a.size(), b.size()));
for (int i = 0; i < c.size(); i++) {
if (i < a.size())
c[i] += a[i];
if (i < b.size())
c[i] += b[i];
}
return normalize(c);
}
Num pow(Num a, int b) {
Num res = {1};
while (b > 0) {
if (b & 1)
res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
void output(Num a) {
const vector<string> unit = {"", "Man", "Oku", "Cho", "Kei", "Gai",
"Jo", "Jou", "Ko", "Kan", "Sei", "Sai",
"Gok", "Ggs", "Nyt", "Fks", "Mts"};
for (int i = a.size() - 1; i >= 0; i--) {
if (a[i] != 0) {
cout << a[i] << unit[i];
}
}
cout << endl;
}
int main() {
iostream_init();
int A, B;
while (cin >> A >> B && A > 0) {
Num C = {A};
output(pow(C, B));
}
return 0;
}
/* vim:set foldmethod=marker: */ | // Template {{{
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
os << "{";
for (int i = 0; i < v.size(); i++)
os << v[i] << (i + 1 < v.size() ? ", " : "");
os << "}";
return os;
}
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool valid(int x, int w) { return 0 <= x && x < w; }
void iostream_init() {
ios::sync_with_stdio(false);
cin.tie(0);
}
//}}}
const int BASE = 10000;
typedef vector<int> Num;
Num normalize(Num c) {
int carry = 0;
for (int i = 0; i < c.size(); i++) {
c[i] += carry;
carry = c[i] / BASE;
c[i] %= BASE;
}
if (carry > 0)
c.push_back(carry);
return c;
}
Num mul(const Num &a, const Num &b) {
int n = a.size();
int m = b.size();
Num c(n - 1 + m - 1 + 1);
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
c[i + j] += a[i] * b[j];
}
}
return normalize(c);
}
Num add(const Num &a, const Num &b) {
Num c(max(a.size(), b.size()));
for (int i = 0; i < c.size(); i++) {
if (i < a.size())
c[i] += a[i];
if (i < b.size())
c[i] += b[i];
}
return normalize(c);
}
Num pow(Num a, int b) {
Num res = {1};
while (b > 0) {
if (b & 1)
res = mul(res, a);
a = mul(a, a);
b /= 2;
}
return res;
}
void output(Num a) {
const vector<string> unit = {"", "Man", "Oku", "Cho", "Kei", "Gai",
"Jo", "Jou", "Ko", "Kan", "Sei", "Sai",
"Gok", "Ggs", "Asg", "Nyt", "Fks", "Mts"};
for (int i = a.size() - 1; i >= 0; i--) {
if (a[i] != 0) {
cout << a[i] << unit[i];
}
}
cout << endl;
}
int main() {
iostream_init();
int A, B;
while (cin >> A >> B && A > 0) {
Num C = {A};
output(pow(C, B));
}
return 0;
}
/* vim:set foldmethod=marker: */ | replace | 77 | 78 | 77 | 78 | 0 | |
p00282 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
// #define int long long
#define DBG 1
#define dump(o) \
if (DBG) { \
cerr << #o << " " << (o) << " "; \
}
#define dumpl(o) \
if (DBG) { \
cerr << #o << " " << (o) << endl; \
}
#define dumpc(o) \
if (DBG) { \
cerr << #o; \
for (auto &e : (o)) \
cerr << " " << e; \
cerr << endl; \
}
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
vector<string> b = {"", "Man", "Oku", "Cho", "Kei", "Gai",
"Jo", "Jou", "Ko", "Kan", "Sei", "Sai",
"Gok", "Ggs", "Asg", "Nyt", "Fks", "Mts"};
for (int m, n; cin >> m >> n && m;) {
vector<int> v(b.size(), 0);
v[0] = 1;
rep(i, 0, n) {
rep(j, 0, v.size()) { v[j] *= m; }
rep(j, 0, v.size() - 1) {
int add = v[j] / 10000;
if (add) {
v[j + 1] += add;
v[j] %= 10000;
}
}
}
dumpc(v);
rrep(j, 0, v.size()) {
if (v[j] == 0)
continue;
cout << v[j] << b[j];
}
cout << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
// #define int long long
#define DBG 0
#define dump(o) \
if (DBG) { \
cerr << #o << " " << (o) << " "; \
}
#define dumpl(o) \
if (DBG) { \
cerr << #o << " " << (o) << endl; \
}
#define dumpc(o) \
if (DBG) { \
cerr << #o; \
for (auto &e : (o)) \
cerr << " " << e; \
cerr << endl; \
}
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9 + 7);
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (a > b) {
a = b;
return true;
}
return false;
}
signed main() {
vector<string> b = {"", "Man", "Oku", "Cho", "Kei", "Gai",
"Jo", "Jou", "Ko", "Kan", "Sei", "Sai",
"Gok", "Ggs", "Asg", "Nyt", "Fks", "Mts"};
for (int m, n; cin >> m >> n && m;) {
vector<int> v(b.size(), 0);
v[0] = 1;
rep(i, 0, n) {
rep(j, 0, v.size()) { v[j] *= m; }
rep(j, 0, v.size() - 1) {
int add = v[j] / 10000;
if (add) {
v[j + 1] += add;
v[j] %= 10000;
}
}
}
dumpc(v);
rrep(j, 0, v.size()) {
if (v[j] == 0)
continue;
cout << v[j] << b[j];
}
cout << endl;
}
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | v 1024 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
v 625 3164 3674 95 0 0 0 0 0 0 0 0 0 0 0 0 0 0
v 0 0 1 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
v 0 0 0 0 720 131 0 0 0 0 0 0 0 0 0 0 0 0
|
p00283 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int D, N;
vector<int> a(110), e(110), r(110); // 耐久力 経験値 必要な経験値
int dp[110][11000]; // 耐久力 i の時に 経験値 j の時の回数
int solve(int d, int exp) {
int ret = 10e8;
if (d <= 0)
return 0;
if (dp[d][exp] != -1)
return dp[d][exp];
for (int i = 0; i < N; i++) {
int E = min(110, exp + e[i]);
if (r[i] <= exp)
ret = min(ret, solve(d - a[i], E) + 1);
}
dp[d][exp] = ret;
return ret;
}
int main() {
while (cin >> D >> N, D + N) {
for (int i = 0; i < N; i++)
cin >> a[i] >> e[i] >> r[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 11000; j++)
dp[i][j] = -1;
int ret = solve(D, 0);
if (ret == 10e8)
cout << "NA" << endl;
else
cout << ret << endl;
}
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int D, N;
vector<int> a(110), e(110), r(110); // 耐久力 経験値 必要な経験値
int dp[110][11000]; // 耐久力 i の時に 経験値 j の時の回数
int solve(int d, int exp) {
int ret = 10e8;
if (d <= 0)
return 0;
if (dp[d][exp] != -1)
return dp[d][exp];
for (int i = 0; i < N; i++) {
int E = min(110, exp + e[i]);
if (a[i] == 0 && E == exp)
continue;
if (r[i] <= exp)
ret = min(ret, solve(d - a[i], E) + 1);
}
dp[d][exp] = ret;
return ret;
}
int main() {
while (cin >> D >> N, D + N) {
for (int i = 0; i < N; i++)
cin >> a[i] >> e[i] >> r[i];
for (int i = 0; i < 110; i++)
for (int j = 0; j < 11000; j++)
dp[i][j] = -1;
int ret = solve(D, 0);
if (ret == 10e8)
cout << "NA" << endl;
else
cout << ret << endl;
}
} | insert | 17 | 17 | 17 | 19 | 0 | |
p00283 | C++ | Time Limit Exceeded | #include <stdio.h>
int min(int a, int b) { return a < b ? a : b; }
int main(void) {
int n, d, i, j, k, inf = 10e8, l;
while (1) {
scanf("%d%d", &d, &n);
if (!d)
break;
int a[n], e[n], r[n], dp[d + 1][200];
for (i = 0; i < n; ++i)
scanf("%d%d%d", &a[i], &e[i], &r[i]);
for (i = 0; i <= d; ++i)
for (j = 0; j < 200; ++j)
dp[i][j] = inf;
dp[0][0] = 0;
for (i = 0; i <= 100; ++i) { // 経験値
for (j = 0; j < n; ++j)
if (i >= r[j]) { // 道具
for (k = 0; k <= d; ++k) {
for (l = 0; l <= i + e[j] && l <= 100; ++l) {
if (dp[min(d, k + a[j])][l] > dp[k][i] + 1)
dp[min(d, k + a[j])][l] = dp[k][i] + 1;
}
}
}
}
/*for(i = 0; i <= d; ++i) {
for(j = 0; j < 20; ++j) printf("%d ", dp[i][j]);
printf("\n");
}*/
int ans = inf;
for (i = 0; i <= 100; ++i)
if (ans > dp[d][i])
ans = dp[d][i];
if (ans != inf)
printf("%d\n", ans);
else
printf("NA\n");
}
return 0;
}
| #include <stdio.h>
int min(int a, int b) { return a < b ? a : b; }
int main(void) {
int n, d, i, j, k, inf = 10e8, l;
while (1) {
scanf("%d%d", &d, &n);
if (!d)
break;
int a[n], e[n], r[n], dp[d + 1][200];
for (i = 0; i < n; ++i)
scanf("%d%d%d", &a[i], &e[i], &r[i]);
for (i = 0; i <= d; ++i)
for (j = 0; j < 200; ++j)
dp[i][j] = inf;
dp[0][0] = 0;
for (i = 0; i <= 100; ++i) { // 経験値
for (j = 0; j < n; ++j)
if (i >= r[j]) { // 道具
for (k = 0; k <= d; ++k) {
if (dp[min(d, k + a[j])][min(100, i + e[j])] > dp[k][i] + 1)
dp[min(d, k + a[j])][min(100, i + e[j])] = dp[k][i] + 1;
}
}
}
/*for(i = 0; i <= d; ++i) {
for(j = 0; j < 20; ++j) printf("%d ", dp[i][j]);
printf("\n");
}*/
int ans = inf;
for (i = 0; i <= 100; ++i)
if (ans > dp[d][i])
ans = dp[d][i];
if (ans != inf)
printf("%d\n", ans);
else
printf("NA\n");
}
return 0;
}
| replace | 21 | 25 | 21 | 23 | TLE | |
p00283 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REPR(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y, x, h, w) (0 <= y && y < h && 0 <= x && x < w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
const int dy[] = {-1, 0, 1, 0};
const int dx[] = {0, 1, 0, -1};
typedef long long ll;
typedef pair<int, int> pii;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename Ch, typename Tr, typename C, typename = decltype(begin(C()))>
basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os, const C &c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &t) {
return o << '(' << t.first << ',' << t.second << ')';
}
template <int N, class Tp> void output(ostream &, const Tp &) {}
template <int N, class Tp, class, class... Ts>
void output(ostream &o, const Tp &t) {
if (N)
o << ',';
o << get<N>(t);
output<N + 1, Tp, Ts...>(o, t);
}
template <class... Ts> ostream &operator<<(ostream &o, const tuple<Ts...> &t) {
o << '(';
output<0, tuple<Ts...>, Ts...>(o, t);
return o << ')';
}
template <class T> void output(T t, char z = 10) {
if (t < 0)
t = -t, putchar(45);
int c[20];
int k = 0;
while (t)
c[k++] = t % 10, t /= 10;
for (k || (c[k++] = 0); k;)
putchar(c[--k] ^ 48);
putchar(z);
}
template <class T> void outputs(T t) { output(t); }
template <class S, class... T> void outputs(S a, T... t) {
output(a, 32);
outputs(t...);
}
template <class T> void output(T *a, int n) {
REP(i, n) cout << a[i] << (i != n - 1 ? ',' : '\n');
}
template <class T> void output(T *a, int n, int m) {
REP(i, n) output(a[i], m);
}
template <class T> bool input(T &t) {
int n = 1, c;
for (t = 0; !isdigit(c = getchar()) && ~c && c - 45;)
;
if (!~c)
return 0;
for (c - 45 && (n = 0, t = c ^ 48); isdigit(c = getchar());)
t = 10 * t + c - 48;
t = n ? -t : t;
return 1;
}
template <class S, class... T> bool input(S &a, T &...t) {
input(a);
return input(t...);
}
template <class T> bool inputs(T *a, int n) {
REP(i, n) if (!input(a[i])) return 0;
return 1;
}
int dp[101][101][101];
struct P {
int a, e, r;
void in() { cin >> a >> e >> r; }
bool operator<(const P &rhs) const { return r < rhs.r; }
} p[100];
int main() {
int d, n;
while (cin >> d >> n, d || n) {
REP(i, n) { p[i].in(); }
sort(p, p + n);
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
REP(i, n) {
for (int j = 0; j <= 100; ++j) {
REP(k, d + 1) {
chmin(dp[i + 1][j][k], dp[i][j][k]);
if (j >= p[i].r) {
REP(l, 100) {
chmin(dp[i + 1][min(100, j + p[i].e * l)][min(d, k + p[i].a * l)],
dp[i][j][k] + l);
}
}
}
}
}
int ans = INF;
REP(i, 101) chmin(ans, dp[n][i][d]);
if (ans == INF)
puts("NA");
else
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define REPR(i, n) for (int i = (int)(n)-1; i >= 0; --i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
#define valid(y, x, h, w) (0 <= y && y < h && 0 <= x && x < w)
#define tpl(...) make_tuple(__VA_ARGS__)
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
const int dy[] = {-1, 0, 1, 0};
const int dx[] = {0, 1, 0, -1};
typedef long long ll;
typedef pair<int, int> pii;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
template <typename Ch, typename Tr, typename C, typename = decltype(begin(C()))>
basic_ostream<Ch, Tr> &operator<<(basic_ostream<Ch, Tr> &os, const C &c) {
os << '[';
for (auto i = begin(c); i != end(c); ++i)
os << (i == begin(c) ? "" : " ") << *i;
return os << ']';
}
template <class S, class T>
ostream &operator<<(ostream &o, const pair<S, T> &t) {
return o << '(' << t.first << ',' << t.second << ')';
}
template <int N, class Tp> void output(ostream &, const Tp &) {}
template <int N, class Tp, class, class... Ts>
void output(ostream &o, const Tp &t) {
if (N)
o << ',';
o << get<N>(t);
output<N + 1, Tp, Ts...>(o, t);
}
template <class... Ts> ostream &operator<<(ostream &o, const tuple<Ts...> &t) {
o << '(';
output<0, tuple<Ts...>, Ts...>(o, t);
return o << ')';
}
template <class T> void output(T t, char z = 10) {
if (t < 0)
t = -t, putchar(45);
int c[20];
int k = 0;
while (t)
c[k++] = t % 10, t /= 10;
for (k || (c[k++] = 0); k;)
putchar(c[--k] ^ 48);
putchar(z);
}
template <class T> void outputs(T t) { output(t); }
template <class S, class... T> void outputs(S a, T... t) {
output(a, 32);
outputs(t...);
}
template <class T> void output(T *a, int n) {
REP(i, n) cout << a[i] << (i != n - 1 ? ',' : '\n');
}
template <class T> void output(T *a, int n, int m) {
REP(i, n) output(a[i], m);
}
template <class T> bool input(T &t) {
int n = 1, c;
for (t = 0; !isdigit(c = getchar()) && ~c && c - 45;)
;
if (!~c)
return 0;
for (c - 45 && (n = 0, t = c ^ 48); isdigit(c = getchar());)
t = 10 * t + c - 48;
t = n ? -t : t;
return 1;
}
template <class S, class... T> bool input(S &a, T &...t) {
input(a);
return input(t...);
}
template <class T> bool inputs(T *a, int n) {
REP(i, n) if (!input(a[i])) return 0;
return 1;
}
int dp[101][101][101];
struct P {
int a, e, r;
void in() { cin >> a >> e >> r; }
bool operator<(const P &rhs) const { return r < rhs.r; }
} p[100];
int main() {
int d, n;
while (cin >> d >> n, d || n) {
REP(i, n) { p[i].in(); }
sort(p, p + n);
memset(dp, 0x3f, sizeof(dp));
dp[0][0][0] = 0;
REP(i, n) {
for (int j = 0; j <= 100; ++j) {
REP(k, d + 1) {
chmin(dp[i + 1][j][k], dp[i][j][k]);
if (j >= p[i].r) {
chmin(dp[i + 1][min(100, j + p[i].e)][min(d, k + p[i].a)],
dp[i + 1][j][k] + 1);
// REP(l,100) {
// chmin(dp[i+1][min(100,j+p[i].e*l)][min(d,k+p[i].a*l)],
// dp[i][j][k] + l);
// }
}
}
}
}
int ans = INF;
REP(i, 101) chmin(ans, dp[n][i][d]);
if (ans == INF)
puts("NA");
else
cout << ans << endl;
}
} | replace | 116 | 120 | 116 | 122 | TLE | |
p00283 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#define INF 100000000
using namespace std;
int n;
int a[101], e[101], r[101];
int dp[101][20001];
int ans, cnt;
int maxr;
void saiki(int d, int ex, int kai) {
cnt++;
if (d <= 0)
dp[0][ex] = 0;
if (d > 0) {
for (int i = 0; i < n; i++) {
if (r[i] <= ex) {
int da = d - a[i];
if (da < 0)
da = 0;
if (maxr <= ex && a[i] == 0)
continue;
if (dp[da][ex + e[i]] < INF) {
dp[d][ex] = min(dp[d][ex], dp[da][ex + e[i]] + 1);
continue;
}
saiki(da, ex + e[i], kai + 1);
dp[d][ex] = min(dp[d][ex], dp[da][ex + e[i]] + 1);
}
}
}
}
int main() {
while (1) {
int d;
cin >> d >> n;
if (d == 0 && n == 0)
break;
maxr = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> e[i] >> r[i];
maxr = max(maxr, r[i]);
}
for (int i = 0; i <= d; i++)
for (int j = 0; j <= 20000; j++)
dp[i][j] = INF;
saiki(d, 0, 0);
if (dp[d][0] == INF)
cout << "NA" << endl;
else
cout << dp[d][0] << endl;
// cout << cnt <<endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#define INF 100000000
using namespace std;
int n;
int a[101], e[101], r[101];
int dp[101][20001];
int ans, cnt;
int maxr;
void saiki(int d, int ex, int kai) {
cnt++;
if (d <= 0)
dp[0][ex] = 0;
if (d > 0) {
for (int i = 0; i < n; i++) {
if (r[i] <= ex) {
int da = d - a[i];
if (da < 0)
da = 0;
if (maxr <= ex && a[i] == 0)
continue;
if (a[i] == 0 && e[i] == 0)
continue;
if (dp[da][ex + e[i]] < INF) {
dp[d][ex] = min(dp[d][ex], dp[da][ex + e[i]] + 1);
continue;
}
saiki(da, ex + e[i], kai + 1);
dp[d][ex] = min(dp[d][ex], dp[da][ex + e[i]] + 1);
}
}
}
}
int main() {
while (1) {
int d;
cin >> d >> n;
if (d == 0 && n == 0)
break;
maxr = 0;
for (int i = 0; i < n; i++) {
cin >> a[i] >> e[i] >> r[i];
maxr = max(maxr, r[i]);
}
for (int i = 0; i <= d; i++)
for (int j = 0; j <= 20000; j++)
dp[i][j] = INF;
saiki(d, 0, 0);
if (dp[d][0] == INF)
cout << "NA" << endl;
else
cout << dp[d][0] << endl;
// cout << cnt <<endl;
}
return 0;
} | insert | 21 | 21 | 21 | 23 | 0 | |
p00284 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
while (n--) {
cin >> a >> b;
if (a * b > 0) {
if (a < 0)
a *= -1, b *= -1, swap(a, b);
assert(a > 0);
int l = 0;
while (a < b) {
int k = __builtin_ctz(a);
while (a > b - (1 << k))
k--;
a += 1 << k;
l++;
}
cout << l << endl;
} else
cout << __builtin_popcount(-a) + __builtin_popcount(b) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b;
cin >> n;
while (n--) {
cin >> a >> b;
if ((a < 0 && b < 0) || (a > 0 && b > 0)) {
if (a < 0) {
a *= -1;
b *= -1;
swap(a, b);
}
int l = 0;
while (a < b) {
int k = __builtin_ctz(a);
while (a > b - (1 << k))
k--;
a += 1 << k;
l++;
}
cout << l << endl;
} else
cout << __builtin_popcount(-a) + __builtin_popcount(b) << endl;
}
} | replace | 9 | 13 | 9 | 15 | 0 | |
p00284 | C++ | Runtime Error | #include <bits/stdc++.h>
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dfs(int s, int g) {
if (s == g)
return 0;
int n = 1;
while (1) {
int a = g / n, b = s / n;
if (g < 0 && g % n)
a--;
if (s > 0 && s % n)
b++;
if (a - b > 0)
n <<= 1;
else {
n >>= 1;
int x = s / n, y = g / n;
if (s > 0 && s % n)
x++;
if (g < 0 && g % n)
y++;
return 1 + dfs(s, x * n) + dfs(y * n, g);
}
}
}
int main() {
int n;
scanf("%d", &n);
rep(i, n) {
int s, d;
scanf("%d%d", &s, &d);
printf("%d\n", dfs(s, d));
}
} | #include <bits/stdc++.h>
#define MOD 1000000007
#define INF 0x3f3f3f3f
#define INFL 0x3f3f3f3f3f3f3f3f
#define EPS (1e-10)
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dfs(int s, int g) {
if (s == g)
return 0;
int n = 1;
while (1) {
int a = g / n, b = s / n;
if (g < 0 && g % n)
a--;
if (s > 0 && s % n)
b++;
if (a - b > 0)
n <<= 1;
else {
n >>= 1;
int x = s / n, y = g / n;
if (s > 0 && s % n)
x++;
if (g < 0 && g % n)
y--;
return y - x + dfs(s, x * n) + dfs(y * n, g);
}
}
}
int main() {
int n;
scanf("%d", &n);
rep(i, n) {
int s, d;
scanf("%d%d", &s, &d);
printf("%d\n", dfs(s, d));
}
} | replace | 28 | 30 | 28 | 30 | 0 | |
p00285 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef long long ll;
typedef long double ld;
#define rep(i, x) for (int i = 0; i < x; i++)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rrep1(i, x) for (int i = x; i > 0; i--)
#define fr first
#define sc second
#define pb push_back
const int INF = 1000000000;
int cal(int bm, int bw) {
int d = abs(bm - bw);
return d * (d - 30) * (d - 30);
}
int main() {
while (1) {
int m, w;
int bm[15], bw[15];
scanf("%d%d", &m, &w);
if (m == 0 && w == 0)
break;
rep(i, m) scanf("%d", &bm[i]);
rep(i, w) scanf("%d", &bw[i]);
int dp[12][1 << 12] = {};
int ret = 0;
rep(i, m) {
rep(j, (1 << w)) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
rep(k, w) {
if ((j >> k) & 1)
continue;
dp[i + 1][j | (1 << k)] =
max(dp[i + 1][j | (1 << k)], dp[i][j] + cal(bm[i], bw[k]));
}
ret = max(ret, dp[i][j]);
}
}
rep(j, (1 << w)) ret = max(ret, dp[m][j]);
printf("%d\n", ret);
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
typedef long long ll;
typedef long double ld;
#define rep(i, x) for (int i = 0; i < x; i++)
#define rep1(i, x) for (int i = 1; i <= x; i++)
#define rrep(i, x) for (int i = x - 1; i >= 0; i--)
#define rrep1(i, x) for (int i = x; i > 0; i--)
#define fr first
#define sc second
#define pb push_back
const int INF = 1000000000;
int cal(int bm, int bw) {
int d = abs(bm - bw);
return d * (d - 30) * (d - 30);
}
int main() {
while (1) {
int m, w;
int bm[15], bw[15];
scanf("%d%d", &m, &w);
if (m == 0 && w == 0)
break;
rep(i, m) scanf("%d", &bm[i]);
rep(i, w) scanf("%d", &bw[i]);
static int dp[15][1 << 12] = {};
rep(i, 15) rep(j, (1 << 12)) { dp[i][j] = 0; }
int ret = 0;
rep(i, m) {
rep(j, (1 << w)) {
dp[i + 1][j] = max(dp[i + 1][j], dp[i][j]);
rep(k, w) {
if ((j >> k) & 1)
continue;
dp[i + 1][j | (1 << k)] =
max(dp[i + 1][j | (1 << k)], dp[i][j] + cal(bm[i], bw[k]));
}
ret = max(ret, dp[i][j]);
}
}
rep(j, (1 << w)) ret = max(ret, dp[m][j]);
printf("%d\n", ret);
}
} | replace | 40 | 41 | 40 | 42 | 0 | |
p00286 | C++ | Runtime Error | #include <iostream>
#include <string>
#include <vector>
using namespace std;
int H, N, Q, p[30][30];
vector<int> r[30], J;
string c[30];
string S;
vector<int> amida_add(vector<int> a, vector<int> b) {
vector<int> c = a, p = a, q = a;
for (int i = 0; i < a.size(); i++)
p[a[i]] = i;
for (int i = 0; i < b.size(); i++)
q[b[i]] = i;
for (int i = 0; i < a.size(); i++)
c[q[p[i]]] = i;
return c;
}
vector<int> amida_rep(vector<int> a, int rep) {
vector<int> dp[32], res = J;
for (int i = 0; i < 32; i++) {
dp[i].resize(a.size(), 0);
}
dp[0] = a;
for (int i = 0; i < 31; i++)
dp[i + 1] = amida_add(dp[i], dp[i]);
for (int i = 0; i < 31; i++) {
if ((rep / (1 << i)) % 2 == 1)
res = amida_add(res, dp[i]);
}
return res;
}
vector<int> solve(int L, int R) {
if (L == R) {
for (int i = 0; i < N; i++) {
if (S[L] == c[i][0])
return r[i];
}
}
vector<int> D;
D.push_back(L - 1);
int depth = 0;
for (int i = L; i <= R; i++) {
if (S[i] == '(')
depth++;
if (S[i] == ')')
depth--;
if (S[i] == '+' && depth == 0)
D.push_back(i);
}
D.push_back(R + 1);
if (D.size() >= 3) {
vector<int> T = J;
for (int i = 0; i < D.size() - 1; i++) {
vector<int> U = solve(D[i] + 1, D[i + 1] - 1);
T = amida_add(T, U);
}
return T;
}
int cl = -1, cr = -1;
for (int i = L; i <= R; i++) {
if (S[i] == '(') {
cl = i;
break;
}
}
for (int i = R; i >= L; i--) {
if (S[i] == ')') {
cr = i;
break;
}
}
if (cl != -1) {
int P = stoi(S.substr(L, cl - L));
vector<int> U = solve(cl + 1, cr - 1);
U = amida_rep(U, P);
return U;
}
int PP = stoi(S.substr(L, R - 1));
vector<int> UU = solve(R, R);
UU = amida_rep(UU, PP);
return UU;
}
int main() {
cin >> H >> N;
for (int j = 0; j < H; j++)
J.push_back(j);
for (int i = 0; i < N; i++) {
int w = 0;
cin >> c[i] >> w;
r[i] = J;
for (int j = 0; j < w - 1; j++) {
for (int k = 0; k < H - 1; k++) {
cin >> p[j][k];
if (p[j][k] == 1)
swap(r[i][k], r[i][k + 1]);
}
}
}
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> S;
vector<int> ans = solve(0, S.size() - 1);
for (int j = 0; j < ans.size(); j++) {
if (j)
cout << " ";
cout << ans[j] + 1;
}
cout << endl;
}
return 0;
}
| #include <iostream>
#include <string>
#include <vector>
using namespace std;
int H, N, Q, p[30][30];
vector<int> r[30], J;
string c[30];
string S;
vector<int> amida_add(vector<int> a, vector<int> b) {
vector<int> c = a, p = a, q = a;
for (int i = 0; i < a.size(); i++)
p[a[i]] = i;
for (int i = 0; i < b.size(); i++)
q[b[i]] = i;
for (int i = 0; i < a.size(); i++)
c[q[p[i]]] = i;
return c;
}
vector<int> amida_rep(vector<int> a, int rep) {
vector<int> dp[32], res = J;
for (int i = 0; i < 32; i++) {
dp[i].resize(a.size(), 0);
}
dp[0] = a;
for (int i = 0; i < 31; i++)
dp[i + 1] = amida_add(dp[i], dp[i]);
for (int i = 0; i < 31; i++) {
if ((rep / (1 << i)) % 2 == 1)
res = amida_add(res, dp[i]);
}
return res;
}
vector<int> solve(int L, int R) {
if (L == R) {
for (int i = 0; i < N; i++) {
if (S[L] == c[i][0])
return r[i];
}
}
vector<int> D;
D.push_back(L - 1);
int depth = 0;
for (int i = L; i <= R; i++) {
if (S[i] == '(')
depth++;
if (S[i] == ')')
depth--;
if (S[i] == '+' && depth == 0)
D.push_back(i);
}
D.push_back(R + 1);
if (D.size() >= 3) {
vector<int> T = J;
for (int i = 0; i < D.size() - 1; i++) {
vector<int> U = solve(D[i] + 1, D[i + 1] - 1);
T = amida_add(T, U);
}
return T;
}
int cl = -1, cr = -1;
for (int i = L; i <= R; i++) {
if (S[i] == '(') {
cl = i;
break;
}
}
for (int i = R; i >= L; i--) {
if (S[i] == ')') {
cr = i;
break;
}
}
if (cl != -1) {
int P = stoi(S.substr(L, cl - L));
vector<int> U = solve(cl + 1, cr - 1);
U = amida_rep(U, P);
return U;
}
int PP = stoi(S.substr(L, R - L));
vector<int> UU = solve(R, R);
UU = amida_rep(UU, PP);
return UU;
}
int main() {
cin >> H >> N;
for (int j = 0; j < H; j++)
J.push_back(j);
for (int i = 0; i < N; i++) {
int w = 0;
cin >> c[i] >> w;
r[i] = J;
for (int j = 0; j < w - 1; j++) {
for (int k = 0; k < H - 1; k++) {
cin >> p[j][k];
if (p[j][k] == 1)
swap(r[i][k], r[i][k + 1]);
}
}
}
cin >> Q;
for (int i = 0; i < Q; i++) {
cin >> S;
vector<int> ans = solve(0, S.size() - 1);
for (int j = 0; j < ans.size(); j++) {
if (j)
cout << " ";
cout << ans[j] + 1;
}
cout << endl;
}
return 0;
}
| replace | 82 | 83 | 82 | 83 | 0 | |
p00287 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
bool f[305][305][2];
int d[305][305];
int H, W, M, Q, h, w;
int ax[100], ay[100], bx[100], by[100];
map<int, int> X, Y;
int solve(int sx, int sy, int tx, int ty) {
memset(d, 1, sizeof(d));
deque<int> qx, qy;
qx.push_front(sx);
qy.push_front(sy);
d[sx][sy] = 0;
while (!qx.empty()) {
int px = qx.front();
qx.pop_front();
int py = qy.front();
qy.pop_front();
// cout<<px<<' '<<py<<endl;
if (px == tx && py == ty)
return d[px][py];
for (int i = 0; i < 4; i++) {
int nx = px + dx[i];
int ny = py + dy[i];
if (nx <= 0 || ny <= 0)
continue;
if (w <= nx || h <= ny)
continue;
int flg = 0;
if (i < 2) {
if (f[px][py][i])
flg = 1;
} else {
if (f[nx][ny][i - 2])
flg = 1;
}
if (d[px][py] + flg < d[nx][ny]) {
d[nx][ny] = d[px][py] + flg;
if (flg) {
qx.push_back(nx);
qy.push_back(ny);
} else {
qx.push_front(nx);
qy.push_front(ny);
}
}
}
}
return -1;
}
void func(map<int, int> &X) {
map<int, int>::iterator it;
int C = 0;
for (it = X.begin(); it != X.end(); ++it)
X[it->first] = ++C;
}
int sx[105], sy[105];
int tx[105], ty[105];
int main() {
scanf("%d %d %d", &W, &H, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d %d", &ax[i], &ay[i], &bx[i], &by[i]);
if (ax[i] > bx[i])
swap(ax[i], bx[i]);
if (ay[i] > by[i])
swap(ay[i], by[i]);
X[ax[i]] = Y[ay[i]] = i;
X[bx[i]] = Y[by[i]] = i;
}
X[0] = Y[0] = 1;
X[W] = Y[H] = M;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
scanf("%d %d %d %d", &sx[i], &sy[i], &tx[i], &ty[i]);
X[sx[i]] = Y[sy[i]] = i;
X[tx[i]] = Y[ty[i]] = i;
}
func(X);
func(Y);
w = X[W], h = Y[H];
for (int i = 0; i < M; i++) {
int AX = X[ax[i]], AY = Y[ay[i]];
int BX = X[bx[i]], BY = Y[by[i]];
if (AX == BX) {
for (int y = AY; y < BY; y++)
f[AX][y][0] = true;
} else {
for (int x = AX; x < BX; x++)
f[x][AY][1] = true;
}
}
for (int i = 0; i < Q; i++) {
sx[i] = X[sx[i]];
sy[i] = Y[sy[i]];
tx[i] = X[tx[i]];
ty[i] = Y[ty[i]];
printf("%d\n", solve(sx[i], sy[i], tx[i], ty[i]));
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int dx[] = {-1, 0, 1, 0};
int dy[] = {0, -1, 0, 1};
bool f[405][405][2];
int d[405][405];
int H, W, M, Q, h, w;
int ax[100], ay[100], bx[100], by[100];
map<int, int> X, Y;
int solve(int sx, int sy, int tx, int ty) {
memset(d, 1, sizeof(d));
deque<int> qx, qy;
qx.push_front(sx);
qy.push_front(sy);
d[sx][sy] = 0;
while (!qx.empty()) {
int px = qx.front();
qx.pop_front();
int py = qy.front();
qy.pop_front();
// cout<<px<<' '<<py<<endl;
if (px == tx && py == ty)
return d[px][py];
for (int i = 0; i < 4; i++) {
int nx = px + dx[i];
int ny = py + dy[i];
if (nx <= 0 || ny <= 0)
continue;
if (w <= nx || h <= ny)
continue;
int flg = 0;
if (i < 2) {
if (f[px][py][i])
flg = 1;
} else {
if (f[nx][ny][i - 2])
flg = 1;
}
if (d[px][py] + flg < d[nx][ny]) {
d[nx][ny] = d[px][py] + flg;
if (flg) {
qx.push_back(nx);
qy.push_back(ny);
} else {
qx.push_front(nx);
qy.push_front(ny);
}
}
}
}
return -1;
}
void func(map<int, int> &X) {
map<int, int>::iterator it;
int C = 0;
for (it = X.begin(); it != X.end(); ++it)
X[it->first] = ++C;
}
int sx[105], sy[105];
int tx[105], ty[105];
int main() {
scanf("%d %d %d", &W, &H, &M);
for (int i = 0; i < M; i++) {
scanf("%d %d %d %d", &ax[i], &ay[i], &bx[i], &by[i]);
if (ax[i] > bx[i])
swap(ax[i], bx[i]);
if (ay[i] > by[i])
swap(ay[i], by[i]);
X[ax[i]] = Y[ay[i]] = i;
X[bx[i]] = Y[by[i]] = i;
}
X[0] = Y[0] = 1;
X[W] = Y[H] = M;
scanf("%d", &Q);
for (int i = 0; i < Q; i++) {
scanf("%d %d %d %d", &sx[i], &sy[i], &tx[i], &ty[i]);
X[sx[i]] = Y[sy[i]] = i;
X[tx[i]] = Y[ty[i]] = i;
}
func(X);
func(Y);
w = X[W], h = Y[H];
for (int i = 0; i < M; i++) {
int AX = X[ax[i]], AY = Y[ay[i]];
int BX = X[bx[i]], BY = Y[by[i]];
if (AX == BX) {
for (int y = AY; y < BY; y++)
f[AX][y][0] = true;
} else {
for (int x = AX; x < BX; x++)
f[x][AY][1] = true;
}
}
for (int i = 0; i < Q; i++) {
sx[i] = X[sx[i]];
sy[i] = Y[sy[i]];
tx[i] = X[tx[i]];
ty[i] = Y[ty[i]];
printf("%d\n", solve(sx[i], sy[i], tx[i], ty[i]));
}
return 0;
} | replace | 6 | 8 | 6 | 8 | 0 | |
p00287 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <deque>
#include <iostream>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
typedef pair<int, int> Pii;
void compress(vector<int> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int w, h;
typedef pair<Pii, int> P;
vector<P> e[350][350];
int cost[350][350];
int solve(Pii s, Pii g) {
memset(cost, 0x1f, sizeof(cost));
deque<Pii> deq;
deq.push_back(s);
cost[s.first][s.second] = 0;
while (!deq.empty()) {
Pii cur = deq.front();
deq.pop_front();
if (cur == g)
return cost[g.first][g.second];
for (auto to : e[cur.first][cur.second]) {
int nf, ns;
tie(nf, ns) = to.first;
int ncost = cost[cur.first][cur.second] + to.second;
if (ncost < cost[nf][ns]) {
cost[nf][ns] = ncost;
if (to.second == 0) {
deq.push_front(Pii(nf, ns));
} else {
deq.push_back(Pii(nf, ns));
}
}
}
}
return -1;
}
int main() {
int m;
cin >> w >> h >> m;
vector<int> cx, cy;
cx.push_back(0);
cx.push_back(1);
cx.push_back(w - 1);
cx.push_back(w);
cy.push_back(0);
cy.push_back(1);
cy.push_back(h - 1);
cy.push_back(h);
vector<pair<Pii, Pii>> seg;
FOR(i, m) {
int pa, pb, qa, qb;
cin >> pa >> pb >> qa >> qb;
seg.emplace_back(Pii(pa, pb), Pii(qa, qb));
if (pa > qa || pb > qb)
swap(seg.back().first, seg.back().second);
if (pa - 1 >= 0)
cx.push_back(pa - 1);
cx.push_back(pa);
if (pa + 1 <= w)
cx.push_back(pa + 1);
if (qa - 1 >= 0)
cx.push_back(qa - 1);
cx.push_back(qa);
if (qa + 1 <= w)
cx.push_back(qa + 1);
if (pb - 1 >= 0)
cy.push_back(pb - 1);
cy.push_back(pb);
if (pb + 1 <= h)
cy.push_back(pb + 1);
if (qb - 1 >= 0)
cy.push_back(qb - 1);
cy.push_back(qb);
if (qb + 1 <= h)
cy.push_back(qb + 1);
}
compress(cx);
compress(cy);
auto co = [&cx, &cy](Pii xy) {
int a = lower_bound(cx.begin(), cx.end(), xy.first) - cx.begin();
int b = lower_bound(cy.begin(), cy.end(), xy.second) - cy.begin();
return Pii(a, b);
};
tie(w, h) = co(Pii(w, h));
FOR(i, m) {
seg[i].first = co(seg[i].first);
seg[i].second = co(seg[i].second);
}
FOR(x, sz(cx) - 2) FOR(y, sz(cy) - 1) {
int nx = x + 1, ny = y;
int c = 0;
for (auto &s : seg) {
if (s.first.first != nx)
continue;
if (s.second.first != nx)
continue;
if (s.first.second <= y && y < s.second.second)
c = 1;
}
e[x][y].push_back(P(Pii(nx, ny), c));
e[nx][ny].push_back(P(Pii(x, y), c));
}
FOR(x, sz(cx) - 1) FOR(y, sz(cy) - 2) {
int nx = x, ny = y + 1;
int c = 0;
for (auto &s : seg) {
if (s.first.second != ny)
continue;
if (s.second.second != ny)
continue;
if (s.first.first <= x && x < s.second.first)
c = 1;
}
e[x][y].push_back(P(Pii(nx, ny), c));
e[nx][ny].push_back(P(Pii(x, y), c));
}
int q;
cin >> q;
FOR(i, q) {
int a, b, c, d;
cin >> a >> b >> c >> d;
Pii s(a, b), g(c, d);
s = co(s);
s.first--;
s.second--;
g = co(g);
g.first--;
g.second--;
int ans = solve(s, g);
cout << ans << endl;
}
} | #include <algorithm>
#include <cstring>
#include <deque>
#include <iostream>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
typedef pair<int, int> Pii;
void compress(vector<int> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
}
int w, h;
typedef pair<Pii, int> P;
vector<P> e[650][650];
int cost[650][650];
int solve(Pii s, Pii g) {
memset(cost, 0x1f, sizeof(cost));
deque<Pii> deq;
deq.push_back(s);
cost[s.first][s.second] = 0;
while (!deq.empty()) {
Pii cur = deq.front();
deq.pop_front();
if (cur == g)
return cost[g.first][g.second];
for (auto to : e[cur.first][cur.second]) {
int nf, ns;
tie(nf, ns) = to.first;
int ncost = cost[cur.first][cur.second] + to.second;
if (ncost < cost[nf][ns]) {
cost[nf][ns] = ncost;
if (to.second == 0) {
deq.push_front(Pii(nf, ns));
} else {
deq.push_back(Pii(nf, ns));
}
}
}
}
return -1;
}
int main() {
int m;
cin >> w >> h >> m;
vector<int> cx, cy;
cx.push_back(0);
cx.push_back(1);
cx.push_back(w - 1);
cx.push_back(w);
cy.push_back(0);
cy.push_back(1);
cy.push_back(h - 1);
cy.push_back(h);
vector<pair<Pii, Pii>> seg;
FOR(i, m) {
int pa, pb, qa, qb;
cin >> pa >> pb >> qa >> qb;
seg.emplace_back(Pii(pa, pb), Pii(qa, qb));
if (pa > qa || pb > qb)
swap(seg.back().first, seg.back().second);
if (pa - 1 >= 0)
cx.push_back(pa - 1);
cx.push_back(pa);
if (pa + 1 <= w)
cx.push_back(pa + 1);
if (qa - 1 >= 0)
cx.push_back(qa - 1);
cx.push_back(qa);
if (qa + 1 <= w)
cx.push_back(qa + 1);
if (pb - 1 >= 0)
cy.push_back(pb - 1);
cy.push_back(pb);
if (pb + 1 <= h)
cy.push_back(pb + 1);
if (qb - 1 >= 0)
cy.push_back(qb - 1);
cy.push_back(qb);
if (qb + 1 <= h)
cy.push_back(qb + 1);
}
compress(cx);
compress(cy);
auto co = [&cx, &cy](Pii xy) {
int a = lower_bound(cx.begin(), cx.end(), xy.first) - cx.begin();
int b = lower_bound(cy.begin(), cy.end(), xy.second) - cy.begin();
return Pii(a, b);
};
tie(w, h) = co(Pii(w, h));
FOR(i, m) {
seg[i].first = co(seg[i].first);
seg[i].second = co(seg[i].second);
}
FOR(x, sz(cx) - 2) FOR(y, sz(cy) - 1) {
int nx = x + 1, ny = y;
int c = 0;
for (auto &s : seg) {
if (s.first.first != nx)
continue;
if (s.second.first != nx)
continue;
if (s.first.second <= y && y < s.second.second)
c = 1;
}
e[x][y].push_back(P(Pii(nx, ny), c));
e[nx][ny].push_back(P(Pii(x, y), c));
}
FOR(x, sz(cx) - 1) FOR(y, sz(cy) - 2) {
int nx = x, ny = y + 1;
int c = 0;
for (auto &s : seg) {
if (s.first.second != ny)
continue;
if (s.second.second != ny)
continue;
if (s.first.first <= x && x < s.second.first)
c = 1;
}
e[x][y].push_back(P(Pii(nx, ny), c));
e[nx][ny].push_back(P(Pii(x, y), c));
}
int q;
cin >> q;
FOR(i, q) {
int a, b, c, d;
cin >> a >> b >> c >> d;
Pii s(a, b), g(c, d);
s = co(s);
s.first--;
s.second--;
g = co(g);
g.first--;
g.second--;
int ans = solve(s, g);
cout << ans << endl;
}
} | replace | 23 | 25 | 23 | 25 | 0 | |
p00288 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
typedef pair<int, int> Pii;
using namespace std;
struct Edge {
int cap, to, cost, rev;
Edge() {}
Edge(int c, int t, int st, int r) : cap(c), to(t), cost(st), rev(r) {}
};
void addEdge(vector<vector<Edge>> &g, int from, int to, int cap, int cost) {
g[from].push_back(Edge(cap, to, cost, g[to].size()));
g[to].push_back(Edge(0, from, -cost, g[from].size() - 1)); // rev edge
}
// O(VE+FElogV)
int minCostFlow(vector<vector<Edge>> &g, int s, int t, int f,
bool negative = false) {
typedef pair<int, int> P;
const int n = g.size();
int res = 0;
vector<int> h(n), prevv(n), preve(n);
const int inf = 10000000; // check
if (negative) {
h.assign(n, inf);
h[s] = 0;
bool update = true;
while (update) {
update = false;
for (int v = 0; v < n; v++) {
if (h[v] == inf)
continue;
for (int i = 0; i < sz(g[v]); i++) {
auto &e = g[v][i];
if (e.cap > 0 && h[e.to] > h[v] + e.cost) {
h[e.to] = h[v] + e.cost;
prevv[e.to] = v;
preve[e.to] = i;
update = true;
}
}
}
}
}
while (f > 0) {
//????????????????????§????????????(cost = ???????????¨)
priority_queue<P, vector<P>, greater<P>> que;
vector<int> dist(n, inf);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < sz(g[v]); i++) {
auto &e = g[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1; //??????????????????
FOR(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d; //?????????????????????
res += d * h[t]; //???????????????????????????????¨?????????????
//??????????¨????
for (int v = t; v != s; v = prevv[v]) {
auto &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int popcount(long long x) {
x = (x & 0x5555555555555555ULL) + ((x & 0xAAAAAAAAAAAAAAAAULL) >> 1);
x = (x & 0x3333333333333333ULL) + ((x & 0xCCCCCCCCCCCCCCCCULL) >> 2);
x = (x & 0x0F0F0F0F0F0F0F0FULL) + ((x & 0xF0F0F0F0F0F0F0F0ULL) >> 4);
return (int)(x * 0x0101010101010101ULL >> 56);
}
struct P {
int x, y, c, f;
};
int main() {
int N, M, B;
while (scanf("%d%d%d", &N, &M, &B) && N) {
vector<P> people(N);
for (int i = 0; i < N; i++)
scanf("%d%d", &people[i].x, &people[i].y);
vector<P> place(M);
for (int i = 0; i < M; i++)
scanf("%d%d%d%d", &place[i].x, &place[i].y, &place[i].c, &place[i].f);
vector<vector<Edge>> g(N + M + 2);
auto f = [&](int D, int bit) {
if (D < 0)
return (int)1e9;
int ans = 1e9;
int sum = 0;
int cnt = 0;
for (int i = 0; i < M; i++) {
if (bit >> i & 1) {
sum += place[i].c;
cnt += place[i].f;
}
}
FOR(i, sz(g)) g[i].clear();
int s = g.size() - 1;
int t = g.size() - 2;
for (int i = 0; i < N; i++)
addEdge(g, s, i, 1, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if ((bit >> j & 1) == 0)
continue;
int dist = max(0, abs(people[i].x - place[j].x) +
abs(people[i].y - place[j].y) - D);
addEdge(g, i, N + j, 1, dist);
}
}
for (int i = 0; i < M; i++) {
addEdge(g, N + i, t, place[i].c, 0);
}
int res = minCostFlow(g, s, t, N);
if (res != -1)
ans = min(ans, res + cnt + popcount(bit) * D * B);
return ans;
};
int ans = 1e9;
for (int bit = 0; bit < (1 << M); bit++) {
int l = 0, r = 4001;
while (r - l > 2) {
int a = (2 * l + r) / 3;
int b = (l + 2 * r) / 3;
if (f(a, bit) > f(b, bit)) {
l = a;
} else {
r = b;
}
}
for (int i = l; i < r; i++)
ans = min(ans, f(i, bit));
}
cout << ans << endl;
}
} | #include <algorithm>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, n) for (int i = 0; i < (n); i++)
#define sz(c) ((int)c.size())
typedef pair<int, int> Pii;
using namespace std;
struct Edge {
int cap, to, cost, rev;
Edge() {}
Edge(int c, int t, int st, int r) : cap(c), to(t), cost(st), rev(r) {}
};
void addEdge(vector<vector<Edge>> &g, int from, int to, int cap, int cost) {
g[from].push_back(Edge(cap, to, cost, g[to].size()));
g[to].push_back(Edge(0, from, -cost, g[from].size() - 1)); // rev edge
}
// O(VE+FElogV)
int minCostFlow(vector<vector<Edge>> &g, int s, int t, int f,
bool negative = false) {
typedef pair<int, int> P;
const int n = g.size();
int res = 0;
vector<int> h(n), prevv(n), preve(n);
const int inf = 10000000; // check
if (negative) {
h.assign(n, inf);
h[s] = 0;
bool update = true;
while (update) {
update = false;
for (int v = 0; v < n; v++) {
if (h[v] == inf)
continue;
for (int i = 0; i < sz(g[v]); i++) {
auto &e = g[v][i];
if (e.cap > 0 && h[e.to] > h[v] + e.cost) {
h[e.to] = h[v] + e.cost;
prevv[e.to] = v;
preve[e.to] = i;
update = true;
}
}
}
}
}
while (f > 0) {
//????????????????????§????????????(cost = ???????????¨)
priority_queue<P, vector<P>, greater<P>> que;
vector<int> dist(n, inf);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
if (v == t)
break;
for (int i = 0; i < sz(g[v]); i++) {
auto &e = g[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1; //??????????????????
FOR(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d; //?????????????????????
res += d * h[t]; //???????????????????????????????¨?????????????
//??????????¨????
for (int v = t; v != s; v = prevv[v]) {
auto &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int popcount(long long x) {
x = (x & 0x5555555555555555ULL) + ((x & 0xAAAAAAAAAAAAAAAAULL) >> 1);
x = (x & 0x3333333333333333ULL) + ((x & 0xCCCCCCCCCCCCCCCCULL) >> 2);
x = (x & 0x0F0F0F0F0F0F0F0FULL) + ((x & 0xF0F0F0F0F0F0F0F0ULL) >> 4);
return (int)(x * 0x0101010101010101ULL >> 56);
}
struct P {
int x, y, c, f;
};
int main() {
int N, M, B;
while (scanf("%d%d%d", &N, &M, &B) && N) {
vector<P> people(N);
for (int i = 0; i < N; i++)
scanf("%d%d", &people[i].x, &people[i].y);
vector<P> place(M);
for (int i = 0; i < M; i++)
scanf("%d%d%d%d", &place[i].x, &place[i].y, &place[i].c, &place[i].f);
vector<vector<Edge>> g(N + M + 2);
auto f = [&](int D, int bit) {
if (D < 0)
return (int)1e9;
int ans = 1e9;
int sum = 0;
int cnt = 0;
for (int i = 0; i < M; i++) {
if (bit >> i & 1) {
sum += place[i].c;
cnt += place[i].f;
}
}
FOR(i, sz(g)) g[i].clear();
int s = g.size() - 1;
int t = g.size() - 2;
for (int i = 0; i < N; i++)
addEdge(g, s, i, 1, 0);
for (int i = 0; i < N; i++) {
for (int j = 0; j < M; j++) {
if ((bit >> j & 1) == 0)
continue;
int dist = max(0, abs(people[i].x - place[j].x) +
abs(people[i].y - place[j].y) - D);
addEdge(g, i, N + j, 1, dist);
}
}
for (int i = 0; i < M; i++) {
addEdge(g, N + i, t, place[i].c, 0);
}
int res = minCostFlow(g, s, t, N);
if (res != -1)
ans = min(ans, res + cnt + popcount(bit) * D * B);
return ans;
};
int ans = 1e9;
for (int bit = 0; bit < (1 << M); bit++) {
int l = 0, r = 4001;
while (r - l > 2) {
int a = (2 * l + r) / 3;
int b = (l + 2 * r) / 3;
if (f(a, bit) > f(b, bit)) {
l = a;
} else {
r = b;
}
}
for (int i = l; i < r; i++)
ans = min(ans, f(i, bit));
}
cout << ans << endl;
}
} | insert | 75 | 75 | 75 | 77 | TLE | |
p00288 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <queue>
#include <vector>
#define INF 1e9
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cap, cost, rev;
edge(int t, int ca, int co, int r) {
to = t;
cap = ca;
cost = co;
rev = r;
}
};
int V;
vector<edge> G[200];
int h[201];
int dist[201];
int prevv[201], preve[201];
void add_edge(int from, int to, int cap, int cost) {
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int min_cost_flow(int s, int t, int f) {
int res = 0;
fill(h, h + V, 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == INF)
return -1;
for (int v = 0; v < V; v++) {
h[v] += dist[v];
}
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int n, m, b;
int ax[101], ay[101];
int indist[101][6];
int bx[6], by[6], c[6], f[6];
int make_graph(int bit, int d) {
V = 2 + n + m * 2;
for (int i = 0; i < 2 + n + m * 2; i++)
G[i].clear();
for (int i = 0; i < n; i++) {
add_edge(0, 2 + i, 1, 0);
for (int j = 0; j < m; j++) {
if (bit >> j & 1) {
int adcost = 0;
if (indist[i][j] > d)
adcost = (indist[i][j] - d);
add_edge(2 + i, 2 + n + j, 1, adcost);
}
}
}
for (int i = 0; i < m; i++) {
add_edge(2 + n + i, 2 + n + m + i, c[i], 0);
add_edge(2 + n + m + i, 1, c[i], 0);
}
return min_cost_flow(0, 1, n);
}
int res;
int dicide_d(int bit) {
int fcost = 0;
int allcap = 0, cnt = 0;
for (int i = 0; i < m; i++) {
if (bit >> i & 1) {
fcost += f[i];
allcap += c[i];
cnt++;
}
}
if (allcap < n || res < fcost)
return -1;
int l = 0, r = 4001;
/*
for(int i=0;i<25;i++){
int ddl=(l*2+r)/3,ddr=(l+r*2)/3;
int dl=make_graph(bit,(l*2+r)/3)+ddl*b*cnt;
if(l*b*cnt+fcost>res)return -1;
int dr=make_graph(bit,(l+r*2)/3)+ddr*b*cnt;
if(dl>dr)l=(l*2+r)/3;
else r=(l+r*2)/3;
}
*/
for (int i = 0; i < 18; i++) {
int m = (l + r) / 2;
int dm = make_graph(bit, m);
int dm1 = make_graph(bit, m + 1);
if (dm >= b * cnt + dm1)
l = m;
else
r = m + 1;
}
return fcost +
min(make_graph(bit, (l * 2 + r) / 3) + ((l * 2 + r) / 3) * b * cnt,
make_graph(bit, (l + r * 2) / 3) + ((l + r * 2) / 3) * b * cnt);
}
int main(void) {
while (1) {
scanf("%d %d %d", &n, &m, &b);
if (n + m + b == 0)
break;
for (int i = 0; i < n; i++) {
scanf("%d %d", &ax[i], &ay[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &bx[i], &by[i], &c[i], &f[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
indist[i][j] = abs(ax[i] - bx[j]) + abs(ay[i] - by[j]);
}
}
res = INF;
for (int i = 1; i < (1 << m); i++) {
int icost = dicide_d(i);
if (icost != -1)
res = min(res, icost);
}
printf("%d\n", res);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <queue>
#include <vector>
#define INF 1e9
using namespace std;
typedef pair<int, int> P;
struct edge {
int to, cap, cost, rev;
edge(int t, int ca, int co, int r) {
to = t;
cap = ca;
cost = co;
rev = r;
}
};
int V;
vector<edge> G[200];
int h[201];
int dist[201];
int prevv[201], preve[201];
void add_edge(int from, int to, int cap, int cost) {
G[from].push_back(edge(to, cap, cost, G[to].size()));
G[to].push_back(edge(from, 0, -cost, G[from].size() - 1));
}
int min_cost_flow(int s, int t, int f) {
int res = 0;
fill(h, h + V, 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == INF)
return -1;
for (int v = 0; v < V; v++) {
h[v] += dist[v];
}
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int n, m, b;
int ax[101], ay[101];
int indist[101][6];
int bx[6], by[6], c[6], f[6];
int make_graph(int bit, int d) {
V = 2 + n + m * 2;
for (int i = 0; i < 2 + n + m * 2; i++)
G[i].clear();
for (int i = 0; i < n; i++) {
add_edge(0, 2 + i, 1, 0);
for (int j = 0; j < m; j++) {
if (bit >> j & 1) {
int adcost = 0;
if (indist[i][j] > d)
adcost = (indist[i][j] - d);
add_edge(2 + i, 2 + n + j, 1, adcost);
}
}
}
for (int i = 0; i < m; i++) {
add_edge(2 + n + i, 2 + n + m + i, c[i], 0);
add_edge(2 + n + m + i, 1, c[i], 0);
}
return min_cost_flow(0, 1, n);
}
int res;
int dicide_d(int bit) {
int fcost = 0;
int allcap = 0, cnt = 0;
for (int i = 0; i < m; i++) {
if (bit >> i & 1) {
fcost += f[i];
allcap += c[i];
cnt++;
}
}
if (allcap < n || res < fcost)
return -1;
int l = 0, r = 4001;
/*
for(int i=0;i<25;i++){
int ddl=(l*2+r)/3,ddr=(l+r*2)/3;
int dl=make_graph(bit,(l*2+r)/3)+ddl*b*cnt;
if(l*b*cnt+fcost>res)return -1;
int dr=make_graph(bit,(l+r*2)/3)+ddr*b*cnt;
if(dl>dr)l=(l*2+r)/3;
else r=(l+r*2)/3;
}
*/
for (int i = 0; i < 16; i++) {
int m = (l + r) / 2;
int dm = make_graph(bit, m);
int dm1 = make_graph(bit, m + 1);
if (dm >= b * cnt + dm1)
l = m;
else
r = m + 1;
}
return fcost +
min(make_graph(bit, (l * 2 + r) / 3) + ((l * 2 + r) / 3) * b * cnt,
make_graph(bit, (l + r * 2) / 3) + ((l + r * 2) / 3) * b * cnt);
}
int main(void) {
while (1) {
scanf("%d %d %d", &n, &m, &b);
if (n + m + b == 0)
break;
for (int i = 0; i < n; i++) {
scanf("%d %d", &ax[i], &ay[i]);
}
for (int i = 0; i < m; i++) {
scanf("%d %d %d %d", &bx[i], &by[i], &c[i], &f[i]);
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
indist[i][j] = abs(ax[i] - bx[j]) + abs(ay[i] - by[j]);
}
}
res = INF;
for (int i = 1; i < (1 << m); i++) {
int icost = dicide_d(i);
if (icost != -1)
res = min(res, icost);
}
printf("%d\n", res);
}
return 0;
} | replace | 126 | 127 | 126 | 127 | TLE | |
p00292 | C++ | Runtime Error |
#include <iostream>
using namespace std;
int main() {
int N = 0;
int K[10000], P[10000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> K[i];
P[i];
}
for (int i = 0; i < N; i++) {
int ans = K[i] % P[i];
if (ans == 0) {
cout << P[i] << endl;
} else {
cout << ans << endl;
}
}
return 0;
} |
#include <iostream>
using namespace std;
int main() {
int N = 0;
int K[10000], P[10000];
cin >> N;
for (int i = 0; i < N; i++) {
cin >> K[i];
cin >> P[i];
}
for (int i = 0; i < N; i++) {
int ans = K[i] % P[i];
if (ans == 0) {
cout << P[i] << endl;
} else {
cout << ans << endl;
}
}
return 0;
} | replace | 10 | 11 | 10 | 11 | -8 | |
p00292 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int s = 0;
vector<int> a(n);
vector<int> b(n);
while (s <= n - 1) {
cin >> a[s] >> b[s];
s++;
}
s = 0;
while (s <= n - 1) {
if (a[s] % b[s] == 0) {
cout << n << endl;
} else {
cout << a[s] % b[s] << endl;
s++;
}
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
cin >> n;
int s = 0;
vector<int> a(n);
vector<int> b(n);
while (s <= n - 1) {
cin >> a[s] >> b[s];
s++;
}
s = 0;
while (s <= n - 1) {
if (a[s] % b[s] == 0) {
cout << b[s] << endl;
s++;
} else {
cout << a[s] % b[s] << endl;
s++;
}
}
return 0;
} | replace | 17 | 18 | 17 | 19 | TLE | |
p00293 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main(void) {
int i, j, h, w, e, k, min = 9999;
int D = 0, A = 0, R = 0, E = 0, K = 0;
int a[101], b[101], c[101], d[101], scride, z[101] = {0}, p[101] = {0};
cin >> h;
for (i = 0; i < 101; i++) {
a[i] = 999;
b[i] = 999;
d[i] = 999;
c[i] = 999;
}
for (i = 0; i < h; i++) {
cin >> a[i] >> b[i];
}
cin >> w;
for (i = 0; i < w; i++) {
cin >> c[i] >> d[i];
}
while (1) {
if (D >= h && E >= w)
break;
if (a[D] < c[E] || (a[D] == c[E] && b[D] < d[E])) {
z[K] = a[D];
p[K] = b[D];
D++;
} else if (a[D] > c[E] || (a[D] == c[E] && b[D] > d[E])) {
z[K] = c[E];
p[K] = d[E];
E++;
} else {
z[K] = a[D];
p[K] = b[D];
D++;
E++;
}
K++;
}
// cout<<K<<" "<<D<<" "<<E;
for (i = 0; i < K - 1; i++) {
if (p[i] >= 10) {
cout << z[i] << ":" << p[i] << " ";
} else {
cout << z[i] << ":0" << p[i] << " ";
}
}
if (p[K - 1] >= 10) {
cout << z[K - 1] << ":" << p[K - 1] << endl;
} else {
cout << z[K - 1] << ":0" << p[K - 1] << endl;
}
// for(i=0;i<h+w;i++){
// cout<<a[i]<<b[i]<<endl;
// }
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
int i, h, w, e, k;
int D = 0, E = 0, K = 0;
int a[101], b[101], c[101], d[101], z[203] = {0}, p[203] = {0};
cin >> h;
for (i = 0; i < 101; i++) {
a[i] = 999;
b[i] = 999;
d[i] = 999;
c[i] = 999;
}
for (i = 0; i < h; i++) {
cin >> a[i] >> b[i];
}
cin >> w;
for (i = 0; i < w; i++) {
cin >> c[i] >> d[i];
}
while (1) {
if (D >= h && E >= w)
break;
if (a[D] < c[E] || (a[D] == c[E] && b[D] < d[E])) {
z[K] = a[D];
p[K] = b[D];
D++;
} else if (a[D] > c[E] || (a[D] == c[E] && b[D] > d[E])) {
z[K] = c[E];
p[K] = d[E];
E++;
} else {
z[K] = a[D];
p[K] = b[D];
D++;
E++;
}
K++;
}
// cout<<K<<" "<<D<<" "<<E;
for (i = 0; i < K - 1; i++) {
if (p[i] >= 10) {
cout << z[i] << ":" << p[i] << " ";
} else {
cout << z[i] << ":0" << p[i] << " ";
}
}
if (p[K - 1] >= 10) {
cout << z[K - 1] << ":" << p[K - 1] << endl;
} else {
cout << z[K - 1] << ":0" << p[K - 1] << endl;
}
// for(i=0;i<h+w;i++){
// cout<<a[i]<<b[i]<<endl;
// }
return 0;
} | replace | 3 | 6 | 3 | 6 | 0 | |
p00293 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int h[110] = {}, k[110] = {}, g[110];
for (int i = 0; i < 110; i++) {
g[i] = 100000;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i] >> k[i];
}
cin >> m;
for (int i = n; i < n + m; i++) {
cin >> h[i] >> k[i];
}
for (int i = 0; i < n + m; i++) {
g[i] = h[i] * 60 + k[i];
sort(g, g + n + m);
}
for (int i = 0; i < n + m; i++) {
if (g[i] == g[i + 1])
continue;
cout << g[i] / 60 << ":";
if (g[i] % 60 < 10)
cout << "0" << g[i] % 60;
else
cout << g[i] % 60;
if (i != n + m - 1)
cout << " ";
}
cout << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
int h[300] = {}, k[300] = {}, g[300];
for (int i = 0; i < 300; i++) {
g[i] = 100000;
}
cin >> n;
for (int i = 0; i < n; i++) {
cin >> h[i] >> k[i];
}
cin >> m;
for (int i = n; i < n + m; i++) {
cin >> h[i] >> k[i];
}
for (int i = 0; i < n + m; i++) {
g[i] = h[i] * 60 + k[i];
sort(g, g + n + m);
}
for (int i = 0; i < n + m; i++) {
if (g[i] == g[i + 1])
continue;
cout << g[i] / 60 << ":";
if (g[i] % 60 < 10)
cout << "0" << g[i] % 60;
else
cout << g[i] % 60;
if (i != n + m - 1)
cout << " ";
}
cout << endl;
return 0;
}
| replace | 4 | 6 | 4 | 6 | 0 | |
p00293 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#define Max 24 * 60 + 60 + 1
int main() {
int n, m, n2[101], m2[101];
cin >> n;
for (int i = 0; i < 100; i++)
n2[i] = Max;
for (int i = 0; i < n; i++) {
int h, m;
cin >> h >> m;
n2[i] = h * 60 + m;
}
cin >> m;
for (int i = 0; i < m; i++) {
int k, g;
cin >> k >> g;
n2[i + n] = k * 60 + g;
}
sort(n2, n2 + (m + n));
int suu = 0;
for (int i = 0; i < m + n; i++) {
if (n2[i] == n2[i + 1]) {
for (int j = i + 1; n2[i] == n2[j] && n2[j] != Max; j++) {
i++;
}
}
if (i != m + n - 1) {
printf("%d:%02d ", n2[i] / 60, n2[i] % 60);
} else
printf("%d:%02d\n", n2[i] / 60, n2[i] % 60);
}
} | #include "bits/stdc++.h"
using namespace std;
#define Max 24 * 60 + 60 + 1
int main() {
int n, m, n2[101], m2[101];
cin >> n;
for (int i = 0; i < 100; i++)
n2[i] = Max;
for (int i = 0; i < n; i++) {
int h, m;
cin >> h >> m;
n2[i] = h * 60 + m;
}
cin >> m;
for (int i = 0; i < m; i++) {
int k, g;
cin >> k >> g;
m2[i] = k * 60 + g;
}
for (int i = n; i < m + n; i++) {
n2[i] = m2[i - n];
}
sort(n2, n2 + (m + n));
int suu = 0;
for (int i = 0; i < m + n; i++) {
if (n2[i] == n2[i + 1]) {
for (int j = i + 1; n2[i] == n2[j] && n2[j] != Max; j++) {
i++;
}
}
if (i != m + n - 1) {
printf("%d:%02d ", n2[i] / 60, n2[i] % 60);
} else
printf("%d:%02d\n", n2[i] / 60, n2[i] % 60);
}
} | replace | 17 | 18 | 17 | 21 | 0 | |
p00293 | C++ | Runtime Error | #include <bitset>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
int a[100], b[100], n, m, i, min1 = 100, min2 = 100, num, sa = 0, sa1 = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
cin >> m;
for (int j = i; j < m + i; j++) {
cin >> a[j] >> b[j];
}
for (int i = 0; i < m + n; i++) {
for (int j = 0; j < m + n; j++) {
if (i == j) {
continue;
}
if (a[i] == a[j] && b[i] == b[j]) {
sa++;
}
}
}
sa1 = sa / 2;
for (int j = 0; j < n + m - sa1; j++) {
for (int l = 0; l < n + m; l++) {
if (min1 == a[l]) {
if (min2 > b[l]) {
min1 = a[l];
min2 = b[l];
num = l;
}
} else if (min1 > a[l]) {
min1 = a[l];
min2 = b[l];
num = l;
}
}
cout << min1 << ":";
printf("%02d", min2);
if (j == n + m - sa1 - 1) {
cout << endl;
} else {
cout << " ";
}
for (int k = 0; k < n + m; k++) {
if (min1 == a[k] && min2 == b[k]) {
a[k] = 100;
b[k] = 100;
}
}
a[num] = 1000;
b[num] = 1000;
min1 = 100;
min2 = 100;
}
return 0;
} | #include <bitset>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
int a[1000], b[1000], n, m, i, min1 = 100, min2 = 100, num, sa = 0, sa1 = 0;
cin >> n;
for (i = 0; i < n; i++) {
cin >> a[i] >> b[i];
}
cin >> m;
for (int j = i; j < m + i; j++) {
cin >> a[j] >> b[j];
}
for (int i = 0; i < m + n; i++) {
for (int j = 0; j < m + n; j++) {
if (i == j) {
continue;
}
if (a[i] == a[j] && b[i] == b[j]) {
sa++;
}
}
}
sa1 = sa / 2;
for (int j = 0; j < n + m - sa1; j++) {
for (int l = 0; l < n + m; l++) {
if (min1 == a[l]) {
if (min2 > b[l]) {
min1 = a[l];
min2 = b[l];
num = l;
}
} else if (min1 > a[l]) {
min1 = a[l];
min2 = b[l];
num = l;
}
}
cout << min1 << ":";
printf("%02d", min2);
if (j == n + m - sa1 - 1) {
cout << endl;
} else {
cout << " ";
}
for (int k = 0; k < n + m; k++) {
if (min1 == a[k] && min2 == b[k]) {
a[k] = 100;
b[k] = 100;
}
}
a[num] = 1000;
b[num] = 1000;
min1 = 100;
min2 = 100;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00293 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m, iimo1[201], iimo2[201], turu1[101], turu2[101], co1 = 0, co2 = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> iimo1[i] >> iimo2[i];
cin >> m;
for (int i = 0; i < m; i++)
cin >> turu1[i] >> turu2[i];
while (n != co1 || m != co2) {
if (co1 != 0 || co2 != 0)
cout << " ";
if (iimo1[co1] > turu1[co2] || n == co1) {
cout << turu1[co2] << ":";
if (turu2[co2] < 10)
cout << "0" << turu2[co2];
else
cout << turu2[co2];
co2++;
} else if (iimo1[co1] < turu1[co2] || m == co2) {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
} else if (iimo2[co1] > turu2[co2]) {
cout << turu1[co2] << ":";
if (turu2[co2] < 10)
cout << "0" << turu2[co2];
else
cout << turu2[co2];
co2++;
} else if (iimo2[co1] < turu2[co2]) {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
} else {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
co2++;
}
}
cout << endl;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m, iimo1[201], iimo2[201], turu1[201], turu2[201], co1 = 0, co2 = 0;
cin >> n;
for (int i = 0; i < n; i++)
cin >> iimo1[i] >> iimo2[i];
cin >> m;
for (int i = 0; i < m; i++)
cin >> turu1[i] >> turu2[i];
while (n != co1 || m != co2) {
if (co1 != 0 || co2 != 0)
cout << " ";
if (iimo1[co1] > turu1[co2] || n == co1) {
cout << turu1[co2] << ":";
if (turu2[co2] < 10)
cout << "0" << turu2[co2];
else
cout << turu2[co2];
co2++;
} else if (iimo1[co1] < turu1[co2] || m == co2) {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
} else if (iimo2[co1] > turu2[co2]) {
cout << turu1[co2] << ":";
if (turu2[co2] < 10)
cout << "0" << turu2[co2];
else
cout << turu2[co2];
co2++;
} else if (iimo2[co1] < turu2[co2]) {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
} else {
cout << iimo1[co1] << ":";
if (iimo2[co1] < 10)
cout << "0" << iimo2[co1];
else
cout << iimo2[co1];
co1++;
co2++;
}
}
cout << endl;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00293 | C++ | Runtime Error | #include <math.h>
#include <stdio.h>
#include <string.h>
int main(void) {
int a, s[101], d[101], f, g, h, i, j, z;
scanf("%d", &a);
for (i = 0; i < a; i++)
scanf("%d %d", &s[i], &d[i]);
scanf("%d", &f);
for (i = a; i < a + f; i++)
scanf("%d %d", &s[i], &d[i]);
for (i = 0; i < a + f; i++) {
for (j = i + 1; j < a + f; j++) {
if (s[i] > s[j]) {
g = s[i];
s[i] = s[j];
s[j] = g;
g = d[i];
d[i] = d[j];
d[j] = g;
}
}
}
h = a + f;
for (i = 0; i < a + f; i++) {
for (j = i + 1; j < a + f; j++) {
if (s[i] == s[j] && d[i] > d[j]) {
g = s[i];
s[i] = s[j];
s[j] = g;
g = d[i];
d[i] = d[j];
d[j] = g;
}
if (s[i] == s[j] && d[i] == d[j]) {
s[i] = -1;
d[i] = -1;
}
}
}
for (i = 0; i < a + f; i++) {
z = 0;
if (s[i] != -1 && d[i] != -1) {
printf("%d:%02d", s[i], d[i]);
z = 1;
if (i == a + f - 1)
z = 0;
}
if (z == 1)
printf(" ");
}
printf("\n");
} | #include <math.h>
#include <stdio.h>
#include <string.h>
int main(void) {
int a, s[1001], d[1001], f, g, h, i, j, z;
scanf("%d", &a);
for (i = 0; i < a; i++)
scanf("%d %d", &s[i], &d[i]);
scanf("%d", &f);
for (i = a; i < a + f; i++)
scanf("%d %d", &s[i], &d[i]);
for (i = 0; i < a + f; i++) {
for (j = i + 1; j < a + f; j++) {
if (s[i] > s[j]) {
g = s[i];
s[i] = s[j];
s[j] = g;
g = d[i];
d[i] = d[j];
d[j] = g;
}
}
}
h = a + f;
for (i = 0; i < a + f; i++) {
for (j = i + 1; j < a + f; j++) {
if (s[i] == s[j] && d[i] > d[j]) {
g = s[i];
s[i] = s[j];
s[j] = g;
g = d[i];
d[i] = d[j];
d[j] = g;
}
if (s[i] == s[j] && d[i] == d[j]) {
s[i] = -1;
d[i] = -1;
}
}
}
for (i = 0; i < a + f; i++) {
z = 0;
if (s[i] != -1 && d[i] != -1) {
printf("%d:%02d", s[i], d[i]);
z = 1;
if (i == a + f - 1)
z = 0;
}
if (z == 1)
printf(" ");
}
printf("\n");
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00294 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int N, M, p, ans = 100000;
int lis[10001] = {0}, lismap[100001] = {0};
cin >> N >> M >> p;
for (int i = 0; i < M; i++) {
int a;
cin >> a;
lis[i] = a;
lismap[a] = 1;
}
sort(lis, lis + M);
int che = 0;
for (int i = 0;; i++) {
if (lismap[(p + i) % N] == 1)
che++;
if (che == M) {
ans = min(ans, i);
break;
}
}
che = 0;
for (int i = 0;; i++) {
if (lismap[N + (p - i) % N] == 1)
che++;
if (che == M) {
ans = min(ans, i);
break;
}
}
for (int i = 0; i < M; i++) {
int karians1 = 0, karians2 = 0;
int a = lis[i] - p;
if (a < 0)
a += N;
karians1 += a * 2;
karians2 += a;
if (i == M - 1) {
int b = p - lis[0];
if (b < 0)
b += N;
karians1 += b;
karians2 += b * 2;
} else {
int b = p - lis[i + 1];
if (b < 0)
b += N;
karians1 += b;
karians2 += b * 2;
}
ans = min(ans, min(karians1, karians2));
}
cout << ans * 100 << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
int main() {
int N, M, p, ans = 100000;
int lis[10001] = {0}, lismap[100001] = {0};
cin >> N >> M >> p;
for (int i = 0; i < M; i++) {
int a;
cin >> a;
lis[i] = a;
lismap[a] = 1;
}
sort(lis, lis + M);
int che = 0;
for (int i = 0;; i++) {
if (lismap[(p + i) % N] == 1)
che++;
if (che == M) {
ans = min(ans, i);
break;
}
}
che = 0;
for (int i = 0;; i++) {
if (lismap[(N + (p - i)) % N] == 1)
che++;
if (che == M) {
ans = min(ans, i);
break;
}
}
for (int i = 0; i < M; i++) {
int karians1 = 0, karians2 = 0;
int a = lis[i] - p;
if (a < 0)
a += N;
karians1 += a * 2;
karians2 += a;
if (i == M - 1) {
int b = p - lis[0];
if (b < 0)
b += N;
karians1 += b;
karians2 += b * 2;
} else {
int b = p - lis[i + 1];
if (b < 0)
b += N;
karians1 += b;
karians2 += b * 2;
}
ans = min(ans, min(karians1, karians2));
}
cout << ans * 100 << endl;
return 0;
} | replace | 27 | 28 | 27 | 28 | TLE | |
p00294 | C++ | Runtime Error | #include <iostream>
#include <limits.h>
const long MAX_N = 100000;
const long MAX_M = 10000;
const long FEE = 100;
long next(bool *stations, long N, long current) {
long i = current + 1;
if (i >= N) {
i = 0;
}
if (i < 0) {
i = N - 1;
}
while (!stations[i]) {
i++;
if (i >= N) {
i = 0;
}
}
return i;
}
long previous(bool *stations, long N, long current) {
long i = current - 1;
if (i >= N) {
i = 0;
}
if (i < 0) {
i = N - 1;
}
while (!stations[i]) {
i--;
if (i < 0) {
i = N - 1;
}
}
return i;
}
int main(void) {
bool stations[MAX_M] = {false};
long N = 0;
long M = 0;
long p = 0;
std::cin >> N >> M >> p;
stations[0] = true;
for (long i = 0; i < M; i++) {
long d = 0;
std::cin >> d;
long index = (d - p);
if (index < 0) {
index += N;
}
stations[index] = true;
}
long cost = LONG_MAX;
long m = 0;
long clockwiseCurrent = 0;
long counterClockwiseCurrent = 0;
while (m <= M) {
long nextStation = next(stations, N, clockwiseCurrent);
long c = LONG_MAX;
if (nextStation == 0) {
c = clockwiseCurrent;
} else {
c = 2 * clockwiseCurrent + (N - nextStation);
}
cost = std::min(c, cost);
long previousStation = previous(stations, N, counterClockwiseCurrent);
if (previousStation == 0) {
c = N - counterClockwiseCurrent;
} else {
c = 2 * (N - counterClockwiseCurrent) + previousStation;
}
cost = std::min(c, cost);
m++;
clockwiseCurrent = nextStation;
counterClockwiseCurrent = previousStation;
}
std::cout << (cost * FEE) << std::endl;
return 0;
} | #include <iostream>
#include <limits.h>
const long MAX_N = 100000;
const long MAX_M = 10000;
const long FEE = 100;
long next(bool *stations, long N, long current) {
long i = current + 1;
if (i >= N) {
i = 0;
}
if (i < 0) {
i = N - 1;
}
while (!stations[i]) {
i++;
if (i >= N) {
i = 0;
}
}
return i;
}
long previous(bool *stations, long N, long current) {
long i = current - 1;
if (i >= N) {
i = 0;
}
if (i < 0) {
i = N - 1;
}
while (!stations[i]) {
i--;
if (i < 0) {
i = N - 1;
}
}
return i;
}
int main(void) {
bool stations[MAX_N] = {false};
long N = 0;
long M = 0;
long p = 0;
std::cin >> N >> M >> p;
stations[0] = true;
for (long i = 0; i < M; i++) {
long d = 0;
std::cin >> d;
long index = (d - p);
if (index < 0) {
index += N;
}
stations[index] = true;
}
long cost = LONG_MAX;
long m = 0;
long clockwiseCurrent = 0;
long counterClockwiseCurrent = 0;
while (m <= M) {
long nextStation = next(stations, N, clockwiseCurrent);
long c = LONG_MAX;
if (nextStation == 0) {
c = clockwiseCurrent;
} else {
c = 2 * clockwiseCurrent + (N - nextStation);
}
cost = std::min(c, cost);
long previousStation = previous(stations, N, counterClockwiseCurrent);
if (previousStation == 0) {
c = N - counterClockwiseCurrent;
} else {
c = 2 * (N - counterClockwiseCurrent) + previousStation;
}
cost = std::min(c, cost);
m++;
clockwiseCurrent = nextStation;
counterClockwiseCurrent = previousStation;
}
std::cout << (cost * FEE) << std::endl;
return 0;
} | replace | 52 | 53 | 52 | 53 | 0 | |
p00295 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
class FC {
public:
int p[31];
int n;
bool is_over() {
return p[1] == p[2] && p[2] == p[3] && p[3] == p[4] && p[4] == p[5] &&
p[5] == p[6] && p[6] == p[7] && p[7] == p[8] && p[8] == p[9] &&
p[10] == p[11] && p[11] == p[12] && p[13] == p[14] &&
p[14] == p[15] && p[16] == p[17] && p[17] == p[18] &&
p[19] == p[20] && p[20] == p[21];
}
void rot1() {
swap(p[7], p[22]);
swap(p[8], p[23]);
swap(p[9], p[24]);
swap(p[13], p[18]);
swap(p[10], p[12]);
}
void rot2() {
swap(p[1], p[19]);
swap(p[2], p[20]);
swap(p[3], p[21]);
swap(p[16], p[15]);
swap(p[21], p[19]);
}
void rot3() {
swap(p[1], p[24]);
swap(p[4], p[27]);
swap(p[7], p[30]);
swap(p[16], p[18]);
swap(p[10], p[21]);
}
void rot4() {
swap(p[3], p[22]);
swap(p[6], p[25]);
swap(p[9], p[28]);
swap(p[13], p[15]);
swap(p[12], p[19]);
}
};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
FC now;
for (int j = 1; j <= 30; j++) {
cin >> now.p[j];
}
now.n = 0;
queue<FC> que;
que.push(now);
while (!que.empty()) {
now = que.front();
que.pop();
if (now.is_over()) {
cout << now.n << endl;
break;
}
FC nex1 = now;
nex1.rot1();
nex1.n++;
que.push(nex1);
FC nex2 = now;
nex2.rot2();
nex2.n++;
que.push(nex2);
FC nex3 = now;
nex3.rot3();
nex3.n++;
que.push(nex3);
FC nex4 = now;
nex4.rot4();
nex4.n++;
que.push(nex4);
}
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
using namespace std;
class FC {
public:
int p[31];
int n;
bool is_over() {
return p[1] == p[2] && p[2] == p[3] && p[3] == p[4] && p[4] == p[5] &&
p[5] == p[6] && p[6] == p[7] && p[7] == p[8] && p[8] == p[9] &&
p[10] == p[11] && p[11] == p[12] && p[13] == p[14] &&
p[14] == p[15] && p[16] == p[17] && p[17] == p[18] &&
p[19] == p[20] && p[20] == p[21];
}
void rot1() {
swap(p[7], p[22]);
swap(p[8], p[23]);
swap(p[9], p[24]);
swap(p[13], p[18]);
swap(p[10], p[12]);
}
void rot2() {
swap(p[1], p[28]);
swap(p[2], p[29]);
swap(p[3], p[30]);
swap(p[16], p[15]);
swap(p[21], p[19]);
}
void rot3() {
swap(p[1], p[24]);
swap(p[4], p[27]);
swap(p[7], p[30]);
swap(p[16], p[18]);
swap(p[10], p[21]);
}
void rot4() {
swap(p[3], p[22]);
swap(p[6], p[25]);
swap(p[9], p[28]);
swap(p[13], p[15]);
swap(p[12], p[19]);
}
};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; i++) {
FC now;
for (int j = 1; j <= 30; j++) {
cin >> now.p[j];
}
now.n = 0;
queue<FC> que;
que.push(now);
while (!que.empty()) {
now = que.front();
que.pop();
if (now.is_over()) {
cout << now.n << endl;
break;
}
FC nex1 = now;
nex1.rot1();
nex1.n++;
que.push(nex1);
FC nex2 = now;
nex2.rot2();
nex2.n++;
que.push(nex2);
FC nex3 = now;
nex3.rot3();
nex3.n++;
que.push(nex3);
FC nex4 = now;
nex4.rot4();
nex4.n++;
que.push(nex4);
}
}
return 0;
} | replace | 24 | 27 | 24 | 27 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p00295 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int L[4][5] = {
{1, 4, 7, 10, 16}, {3, 6, 9, 12, 13}, {1, 2, 3, 15, 19}, {7, 8, 9, 10, 13}};
int R[4][5] = {{24, 27, 30, 21, 16},
{22, 25, 28, 19, 15},
{28, 29, 30, 16, 21},
{22, 23, 24, 12, 18}};
struct Cube {
int cube[31], s;
Cube() {}
void rot(int t) {
for (int i = 0; i < 5; ++i)
swap(cube[L[t][i]], cube[R[t][i]]);
}
bool fail(int a, int b) {
for (int i = a + 1; i <= b; ++i)
if (cube[a] != cube[i])
return 1;
return 0;
}
bool solved() {
if (fail(1, 9))
return 0;
if (fail(10, 12))
return 0;
if (fail(13, 15))
return 0;
if (fail(16, 18))
return 0;
if (fail(19, 21))
return 0;
if (fail(22, 30))
return 0;
return 1;
}
};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
Cube ini;
for (int i = 1; i <= 30; ++i)
cin >> ini.cube[i];
ini.s = 0;
queue<Cube> q;
q.push(ini);
while (!q.empty()) {
Cube c = q.front();
q.pop();
if (c.solved()) {
cout << c.s << endl;
break;
}
++c.s;
for (int i = 0; i < 4; ++i) {
c.rot(i);
q.push(c);
c.rot(i);
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int L[4][5] = {
{1, 4, 7, 10, 16}, {3, 6, 9, 12, 13}, {1, 2, 3, 15, 19}, {7, 8, 9, 10, 13}};
int R[4][5] = {{24, 27, 30, 21, 18},
{22, 25, 28, 19, 15},
{28, 29, 30, 16, 21},
{22, 23, 24, 12, 18}};
struct Cube {
int cube[31], s;
Cube() {}
void rot(int t) {
for (int i = 0; i < 5; ++i)
swap(cube[L[t][i]], cube[R[t][i]]);
}
bool fail(int a, int b) {
for (int i = a + 1; i <= b; ++i)
if (cube[a] != cube[i])
return 1;
return 0;
}
bool solved() {
if (fail(1, 9))
return 0;
if (fail(10, 12))
return 0;
if (fail(13, 15))
return 0;
if (fail(16, 18))
return 0;
if (fail(19, 21))
return 0;
if (fail(22, 30))
return 0;
return 1;
}
};
int main() {
int N;
cin >> N;
for (int i = 0; i < N; ++i) {
Cube ini;
for (int i = 1; i <= 30; ++i)
cin >> ini.cube[i];
ini.s = 0;
queue<Cube> q;
q.push(ini);
while (!q.empty()) {
Cube c = q.front();
q.pop();
if (c.solved()) {
cout << c.s << endl;
break;
}
++c.s;
for (int i = 0; i < 4; ++i) {
c.rot(i);
q.push(c);
c.rot(i);
}
}
}
return 0;
} | replace | 6 | 7 | 6 | 7 | MLE | |
p00295 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int N;
int p[31];
inline void rote1() {
swap(p[13], p[18]);
swap(p[7], p[22]);
swap(p[8], p[23]);
swap(p[9], p[24]);
swap(p[10], p[12]);
}
inline void rote2() {
swap(p[15], p[16]);
swap(p[1], p[28]);
swap(p[2], p[29]);
swap(p[3], p[30]);
swap(p[19], p[21]);
}
inline void rote3() {
swap(p[10], p[21]);
swap(p[1], p[24]);
swap(p[4], p[27]);
swap(p[7], p[30]);
swap(p[16], p[18]);
}
inline void rote4() {
swap(p[12], p[19]);
swap(p[3], p[22]);
swap(p[6], p[25]);
swap(p[9], p[28]);
swap(p[13], p[15]);
}
bool ok(vector<int> vec) {
int t = p[vec[0]];
rep(i, vec.size()) if (t != p[vec[i]]) return false;
return true;
}
bool ok() {
bool res = true;
res &= ok({21, 20, 19});
res &= ok({16, 17, 18});
res &= ok({10, 11, 12});
res &= ok({15, 14, 13});
res &= ok({1, 2, 3, 4, 5, 6, 7, 8, 9});
res &= ok({22, 23, 24, 25, 26, 27, 28, 29, 30});
return res;
}
int dfs(int cnt) {
if (ok())
return cnt;
if (cnt > 8)
return INF;
int res = INF;
rote1();
res = min(res, dfs(cnt + 1));
rote1();
rote2();
res = min(res, dfs(cnt + 1));
rote2();
rote3();
res = min(res, dfs(cnt + 1));
rote3();
rote4();
res = min(res, dfs(cnt + 1));
rote4();
return res;
}
void solve() {
rep(i, 30) cin >> p[i + 1];
cout << dfs(0) << endl;
}
int main() {
cin >> N;
while (N-- > 0)
solve();
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int N;
int p[31];
inline void rote1() {
swap(p[13], p[18]);
swap(p[7], p[22]);
swap(p[8], p[23]);
swap(p[9], p[24]);
swap(p[10], p[12]);
}
inline void rote2() {
swap(p[15], p[16]);
swap(p[1], p[28]);
swap(p[2], p[29]);
swap(p[3], p[30]);
swap(p[19], p[21]);
}
inline void rote3() {
swap(p[10], p[21]);
swap(p[1], p[24]);
swap(p[4], p[27]);
swap(p[7], p[30]);
swap(p[16], p[18]);
}
inline void rote4() {
swap(p[12], p[19]);
swap(p[3], p[22]);
swap(p[6], p[25]);
swap(p[9], p[28]);
swap(p[13], p[15]);
}
bool ok(vector<int> vec) {
int t = p[vec[0]];
rep(i, vec.size()) if (t != p[vec[i]]) return false;
return true;
}
bool ok() {
bool res = true;
res &= ok({21, 20, 19});
res &= ok({16, 17, 18});
res &= ok({10, 11, 12});
res &= ok({15, 14, 13});
res &= ok({1, 2, 3, 4, 5, 6, 7, 8, 9});
res &= ok({22, 23, 24, 25, 26, 27, 28, 29, 30});
return res;
}
int dfs(int cnt) {
if (ok())
return cnt;
if (cnt > 7)
return INF;
int res = INF;
rote1();
res = min(res, dfs(cnt + 1));
rote1();
rote2();
res = min(res, dfs(cnt + 1));
rote2();
rote3();
res = min(res, dfs(cnt + 1));
rote3();
rote4();
res = min(res, dfs(cnt + 1));
rote4();
return res;
}
void solve() {
rep(i, 30) cin >> p[i + 1];
cout << dfs(0) << endl;
}
int main() {
cin >> N;
while (N-- > 0)
solve();
return 0;
} | replace | 83 | 84 | 83 | 84 | TLE |
Subsets and Splits