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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p00461 | C++ | Time Limit Exceeded | #include <iostream>
#include <string>
using namespace std;
int cont;
int kaisu[1000000] = {0};
int main() {
for (;;) {
string str;
int n;
int m;
bool flg = true;
int cont = 0;
char temp = -1;
cin >> n;
if (n == 0) {
break;
}
cin >> m;
cin >> str;
for (int i = 0; i < m; i++) {
kaisu[i] = 0;
}
// ある位置から何回IOIを繰り返せるかを調べる
/*
for(int i = 0; i < m; i++){
if(str[i] == 'I')
{
for(int j = i;; j++){
if(str[j] == temp && temp != -1){
break;
}
if(str[j] == 'O'){
flg = true;
}
if(flg == true && str[j] == 'I' && temp != -1){
flg = false;
cont++;
}
temp = str[j];
// printf("%d文字目:今の文字:%c
続いている回数:%d\n",j,str[j], cont);
// getchar();
}
kaisu[i] = cont;
flg = false;
cont = 0;
temp = -1;
}
}
*/
for (int i = m - 1; i > 1; i--) {
if (str[i] == 'I' && str[i - 1] == 'O' && str[i - 2] == 'I') {
kaisu[i - 2] = kaisu[i] + 1;
}
}
cont = 0;
for (int i = 0; i < m; i++) {
cout << kaisu[i] << endl;
if (kaisu[i] >= n) {
cont++;
}
}
cout << cont << endl;
}
} | #include <iostream>
#include <string>
using namespace std;
int cont;
int kaisu[1000000] = {0};
int main() {
for (;;) {
string str;
int n;
int m;
bool flg = true;
int cont = 0;
char temp = -1;
cin >> n;
if (n == 0) {
break;
}
cin >> m;
cin >> str;
for (int i = 0; i < m; i++) {
kaisu[i] = 0;
}
// ある位置から何回IOIを繰り返せるかを調べる
/*
for(int i = 0; i < m; i++){
if(str[i] == 'I')
{
for(int j = i;; j++){
if(str[j] == temp && temp != -1){
break;
}
if(str[j] == 'O'){
flg = true;
}
if(flg == true && str[j] == 'I' && temp != -1){
flg = false;
cont++;
}
temp = str[j];
// printf("%d文字目:今の文字:%c
続いている回数:%d\n",j,str[j], cont);
// getchar();
}
kaisu[i] = cont;
flg = false;
cont = 0;
temp = -1;
}
}
*/
for (int i = m - 1; i > 1; i--) {
if (str[i] == 'I' && str[i - 1] == 'O' && str[i - 2] == 'I') {
kaisu[i - 2] = kaisu[i] + 1;
}
}
cont = 0;
for (int i = 0; i < m; i++) {
// cout << kaisu[i] << endl;
if (kaisu[i] >= n) {
cont++;
}
}
cout << cont << endl;
}
} | replace | 69 | 70 | 69 | 70 | TLE | |
p00461 | C++ | Time Limit Exceeded | /* {{{ Shinobu kawaii */
/*
______ __ _ __
.' ____ \ [ | (_) [ |
| (___ \_| | |--. __ _ .--. .--. | |.--. __ _
_.____`. | .-. | [ | [ `.-. |/ .'`\ \| '/'`\ \[ | | |
| \____) | | | | | | | | | | || \__. || \__/ | | \_/ |,
\______.'[___]|__][___][___||__]'.__.'[__;.__.' '.__.'_/
*/
// clang-format off
/* }}} */
#include <bits/stdc++.h>
using namespace std;
// #define int long long
struct Fast {Fast(){std::cin.tie(0);ios::sync_with_stdio(false);}} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
/* debug */
#define debug(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n';
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {return y >= 0 && x >= 0 && y < H && x < W;}
inline int in() {int x; cin >> x; return x;}
inline ll IN() {ll x; cin >> x; return x;}
inline vs split(const string& t, char c) {vs v; stringstream s(t); string b; while(getline(s, b, c)) v.eb(b); return v;}
template <typename T> inline bool chmin(T& a, const T& b) {if (a > b) a = b; return a > b;}
template <typename T> inline bool chmax(T& a, const T& b) {if (a < b) a = b; return a < b;}
template <typename T> inline void print(const T& x) {cout << x << '\n';}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v) {for (auto&& p : v) print(p);}
template <typename T> inline void print(const vector<T>& v, string s = " ") {REP(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}
// clang-format on
/* }}} */
signed main() {
int n;
while (cin >> n, n) {
int m = in();
string p = "I", s;
REP(_, n) p += "OI";
cin >> s;
int ans = 0;
for (auto pos = s.find(p); pos != string::npos; pos = s.find(p)) {
s[pos] = 'O';
++ans;
}
print(ans);
}
return 0;
} | /* {{{ Shinobu kawaii */
/*
______ __ _ __
.' ____ \ [ | (_) [ |
| (___ \_| | |--. __ _ .--. .--. | |.--. __ _
_.____`. | .-. | [ | [ `.-. |/ .'`\ \| '/'`\ \[ | | |
| \____) | | | | | | | | | | || \__. || \__/ | | \_/ |,
\______.'[___]|__][___][___||__]'.__.'[__;.__.' '.__.'_/
*/
// clang-format off
/* }}} */
#include <bits/stdc++.h>
using namespace std;
// #define int long long
struct Fast {Fast(){std::cin.tie(0);ios::sync_with_stdio(false);}} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) begin(v), end(v)
#define RALL(v) rbegin(v), rend(v)
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (ll i = (a); i < (ll)(n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (ll i = (a); i >= (ll)(n); --i)
#define DEP(i, n) DEPS(i, n, 0)
/* debug */
#define debug(x) cerr << x << " " << "(L:" << __LINE__ << ")" << '\n';
/* alias */
using ll = long long;
using ull = unsigned long long;
using vi = vector<int>;
using vvi = vector<vi>;
using vvvi = vector<vvi>;
using pii = pair<int, int>;
using D = double;
using P = complex<D>;
using vs = vector<string>;
template <typename T> using PQ = priority_queue<T>;
template <typename T> using minPQ = priority_queue<T, vector<T>, greater<T>>;
/* const */
const int INF = 1001001001;
const ll LINF = 1001001001001001001ll;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1}, dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {return y >= 0 && x >= 0 && y < H && x < W;}
inline int in() {int x; cin >> x; return x;}
inline ll IN() {ll x; cin >> x; return x;}
inline vs split(const string& t, char c) {vs v; stringstream s(t); string b; while(getline(s, b, c)) v.eb(b); return v;}
template <typename T> inline bool chmin(T& a, const T& b) {if (a > b) a = b; return a > b;}
template <typename T> inline bool chmax(T& a, const T& b) {if (a < b) a = b; return a < b;}
template <typename T> inline void print(const T& x) {cout << x << '\n';}
template <typename T, typename S> inline void print(const vector<pair<T, S>>& v) {for (auto&& p : v) print(p);}
template <typename T> inline void print(const vector<T>& v, string s = " ") {REP(i, v.size()) cout << v[i] << (i != (ll)v.size() - 1 ? s : "\n");}
// clang-format on
/* }}} */
signed main() {
int n;
while (cin >> n, n) {
int m = in();
string p = "I", s;
REP(_, n) p += "OI";
cin >> s;
int ans = 0;
REP(i, m) {
if (s[i] == 'O')
continue;
if (2 * n + 1 + i > m)
break;
if (p == s.substr(i, 2 * n + 1))
++ans;
}
print(ans);
}
return 0;
} | replace | 83 | 86 | 83 | 90 | TLE | |
p00461 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
string s;
while (std::cin >> n >> m >> s, n) {
string p;
for (int i = 0; i < n; i++) {
p += "IO";
}
p += "I";
if (p.length() > s.length()) {
std::cout << 0 << std::endl;
return 0;
}
int ans = 0;
for (int i = 0; i < s.length() - p.length(); i++) {
for (int j = 0; j < p.length(); j++) {
if (s[i + j] != p[j])
break;
if (j == p.length() - 1)
ans++;
}
}
std::cout << ans << std::endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main(int argc, char *argv[]) {
int n, m;
string s;
while (std::cin >> n >> m >> s, n) {
string p;
for (int i = 0; i < n; i++) {
p += "IO";
}
p += "I";
if (p.length() > s.length()) {
std::cout << 0 << std::endl;
return 0;
}
int ans = 0, pos = 0;
for (int i = 0; i < s.length(); i++) {
if (s[i] != p[pos]) {
if (s[i] == 'I')
pos = 1;
else
pos = 0;
} else {
pos++;
}
if (pos == p.length()) {
ans++;
i -= p.length() - 1;
pos = 0;
}
}
std::cout << ans << std::endl;
}
return 0;
} | replace | 16 | 23 | 16 | 30 | TLE | |
p00462 | C++ | Time Limit Exceeded | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
static const double EPS = 1e-8;
static const int tx[] = {0, 1, 0, -1};
static const int ty[] = {-1, 0, 1, 0};
static const int MAX_BUCKET = 1000;
vector<int> bucket[MAX_BUCKET];
int compute_dist(int dist, int lhs, int rhs) {
return min(dist - abs(lhs - rhs), abs(lhs - rhs));
}
int main() {
int total_dist, store_num, order_num;
while (~scanf("%d", &total_dist)) {
if (total_dist == 0)
break;
scanf("%d", &store_num);
scanf("%d", &order_num);
vector<int> store;
store.push_back(0);
for (int i = 0; i < store_num - 1; i++) {
int num;
scanf("%d", &num);
store.push_back(num);
}
sort(store.begin(), store.end());
int cost = 0;
for (int i = 0; i < order_num; i++) {
int num;
scanf("%d", &num);
int min_dist = INF;
for (int j = 0; j < store.size(); j++) {
min_dist = min(min_dist, compute_dist(total_dist, store[j], num));
}
cost += min_dist;
}
printf("%d\n", cost);
}
} | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
static const double EPS = 1e-8;
static const int tx[] = {0, 1, 0, -1};
static const int ty[] = {-1, 0, 1, 0};
static const int MAX_BUCKET = 1000;
vector<int> bucket[MAX_BUCKET];
int compute_dist(int dist, int lhs, int rhs) {
return min(dist - abs(lhs - rhs), abs(lhs - rhs));
}
int main() {
int total_dist, store_num, order_num;
while (~scanf("%d", &total_dist)) {
if (total_dist == 0)
break;
scanf("%d", &store_num);
scanf("%d", &order_num);
vector<int> store;
store.push_back(0);
for (int i = 0; i < store_num - 1; i++) {
int num;
scanf("%d", &num);
store.push_back(num);
}
sort(store.begin(), store.end());
int cost = 0;
for (int i = 0; i < order_num; i++) {
int num;
scanf("%d", &num);
int idx = lower_bound(store.begin(), store.end(), num) - store.begin();
int min_dist = compute_dist(total_dist, store[idx], num);
for (int j = idx - 1; j >= 0; j--) {
min_dist = min(min_dist, compute_dist(total_dist, store[j], num));
}
cost += min_dist;
}
printf("%d\n", cost);
}
} | replace | 62 | 64 | 62 | 66 | TLE | |
p00462 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) {
return n ? 1 + __builtin_popcount(n & (n - 1)) : 0;
}
#endif
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
template <class T> void max_swap(T &a, const T b) { a = max(a, b); }
template <class T> void min_swap(T &a, const T b) { a = min(a, b); }
const double EPS = 1e-10;
typedef long long ll;
typedef pair<int, int> pint;
int main() {
int round;
while (scanf("%d", &round), round) {
int n, m;
scanf("%d%d", &n, &m);
static int d[10100];
d[0] = 0;
for (int i = 1; i < n; ++i)
scanf("%d", d + i);
sort(d, d + n);
int res = 0;
while (m--) {
int k;
scanf("%d", &k);
int i = lower_bound(d, d + n, k) - d;
int dis = 1e9 + 10;
if (i > 0)
min_swap(dis, k - d[i - 1]);
if (i < n)
min_swap(dis, d[i] - k);
min_swap(dis, round - k);
res += dis;
}
printf("%d\n", res);
}
} | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#ifdef _MSC_VER
#define __typeof__ decltype
template <class T> int __builtin_popcount(T n) {
return n ? 1 + __builtin_popcount(n & (n - 1)) : 0;
}
#endif
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define popcount __builtin_popcount
template <class T> void max_swap(T &a, const T b) { a = max(a, b); }
template <class T> void min_swap(T &a, const T b) { a = min(a, b); }
const double EPS = 1e-10;
typedef long long ll;
typedef pair<int, int> pint;
int main() {
int round;
while (scanf("%d", &round), round) {
int n, m;
scanf("%d%d", &n, &m);
static int d[100100];
d[0] = 0;
for (int i = 1; i < n; ++i)
scanf("%d", d + i);
sort(d, d + n);
int res = 0;
while (m--) {
int k;
scanf("%d", &k);
int i = lower_bound(d, d + n, k) - d;
int dis = 1e9 + 10;
if (i > 0)
min_swap(dis, k - d[i - 1]);
if (i < n)
min_swap(dis, d[i] - k);
min_swap(dis, round - k);
res += dis;
}
printf("%d\n", res);
}
} | replace | 51 | 52 | 51 | 52 | 0 | |
p00462 | C++ | Runtime Error | #include <bits/stdc++.h>
#define f first
#define s second
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int main() {
int d, n, m;
while (cin >> d, d) {
cin >> n >> m;
int D[10001], M[10001];
;
D[0] = 0, D[n] = d;
for (int i = 1; i < n; i++)
cin >> D[i];
for (int i = 0; i < m; i++)
cin >> M[i];
sort(M, M + m);
sort(D, D + n + 1);
ll ans = 0;
int pos = 1;
for (int i = 0; i < m; i++) {
while (D[pos] <= M[i])
pos++;
ans += min(abs(D[pos] - M[i]), abs(D[pos - 1] - M[i]));
}
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define f first
#define s second
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
int main() {
int d, n, m;
while (cin >> d, d) {
cin >> n >> m;
int D[100001], M[100001];
;
D[0] = 0, D[n] = d;
for (int i = 1; i < n; i++)
cin >> D[i];
for (int i = 0; i < m; i++)
cin >> M[i];
sort(M, M + m);
sort(D, D + n + 1);
ll ans = 0;
int pos = 1;
for (int i = 0; i < m; i++) {
while (D[pos] <= M[i])
pos++;
ans += min(abs(D[pos] - M[i]), abs(D[pos - 1] - M[i]));
}
cout << ans << endl;
}
return 0;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p00462 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using namespace std;
int d, n, m, shop[100000], k[10000];
int main() {
while (true) {
cin >> d;
if (!d)
break;
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> shop[i];
}
shop[0] = 0;
shop[n] = d;
for (int i = 0; i < m; i++) {
cin >> k[i];
}
sort(shop, shop + n);
int sum = 0;
for (int i = 0; i < m; i++) {
int *s2 = upper_bound(shop, shop + n + 1, k[i]);
int *s1 = s2 - 1;
sum += min(k[i] - *s1, *s2 - k[i]);
}
cout << sum << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int d, n, m, shop[100001], k[10000];
int main() {
while (true) {
cin >> d;
if (!d)
break;
cin >> n >> m;
for (int i = 1; i < n; i++) {
cin >> shop[i];
}
shop[0] = 0;
shop[n] = d;
for (int i = 0; i < m; i++) {
cin >> k[i];
}
sort(shop, shop + n);
int sum = 0;
for (int i = 0; i < m; i++) {
int *s2 = upper_bound(shop, shop + n + 1, k[i]);
int *s1 = s2 - 1;
sum += min(k[i] - *s1, *s2 - k[i]);
}
cout << sum << endl;
}
return 0;
} | replace | 4 | 5 | 4 | 5 | TLE | |
p00462 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
using namespace std;
#define INF (1 << 29)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, m, d, k;
int dist[100000];
while (cin >> d && d) {
int ans = 0;
cin >> n >> m;
rep(i, n - 1) { cin >> dist[i + 1]; }
sort(dist + 1, dist + n);
dist[0] = 0;
dist[n] = d;
while (m--) {
cin >> k;
int i = upper_bound(dist, dist + n + 1, k) - dist;
ans += min(dist[i] - k, k - dist[i - 1]);
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
using namespace std;
#define INF (1 << 29)
#define rep(i, n) for (int i = 0; i < (n); i++)
int main() {
int n, m, d, k;
int dist[100001];
while (cin >> d && d) {
int ans = 0;
cin >> n >> m;
rep(i, n - 1) { cin >> dist[i + 1]; }
sort(dist + 1, dist + n);
dist[0] = 0;
dist[n] = d;
while (m--) {
cin >> k;
int i = upper_bound(dist, dist + n + 1, k) - dist;
ans += min(dist[i] - k, k - dist[i - 1]);
}
cout << ans << endl;
}
return 0;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p00463 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define P pair<int, int>
using namespace std;
P e[10000];
int main() {
int a, b, c, d;
while (cin >> a >> b >> c >> d, a | b || c || d) {
int f[1000], j[1000], sum = 0;
for (int g = 0; g < a; g++)
f[g] = g;
for (int g = 0; g < a; g++)
scanf("%d", &j[g]);
for (int g = 0; g < b; g++) {
int h, i;
scanf("%d%d", &h, &i);
h--;
e[g] = P(i, h);
}
sort(e, e + b);
for (int g = 0; g < b; g++) {
swap(f[e[g].second], f[e[g].second + 1]);
}
int MAX = 0, k[1000];
for (int l = 0; l < a; l++) {
k[l] = l;
if (f[l] < d)
sum += j[l];
}
for (int g = b - 1; g >= 0; g--) {
if (f[k[e[g].second]] < d) {
if (f[k[e[g].second + 1]] >= d) {
MAX = max(MAX, j[k[e[g].second]] - j[k[e[g].second + 1]]);
}
} else {
if (f[k[e[g].second + 1]] < d) {
MAX = max(MAX, j[k[e[g].second + 1]] - j[k[e[g].second]]);
}
}
swap(k[e[g].second], k[e[g].second + 1]);
}
cout << sum - MAX << endl;
}
} | #include <algorithm>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
#define P pair<int, int>
using namespace std;
P e[100000];
int main() {
int a, b, c, d;
while (cin >> a >> b >> c >> d, a | b || c || d) {
int f[1000], j[1000], sum = 0;
for (int g = 0; g < a; g++)
f[g] = g;
for (int g = 0; g < a; g++)
scanf("%d", &j[g]);
for (int g = 0; g < b; g++) {
int h, i;
scanf("%d%d", &h, &i);
h--;
e[g] = P(i, h);
}
sort(e, e + b);
for (int g = 0; g < b; g++) {
swap(f[e[g].second], f[e[g].second + 1]);
}
int MAX = 0, k[1000];
for (int l = 0; l < a; l++) {
k[l] = l;
if (f[l] < d)
sum += j[l];
}
for (int g = b - 1; g >= 0; g--) {
if (f[k[e[g].second]] < d) {
if (f[k[e[g].second + 1]] >= d) {
MAX = max(MAX, j[k[e[g].second]] - j[k[e[g].second + 1]]);
}
} else {
if (f[k[e[g].second + 1]] < d) {
MAX = max(MAX, j[k[e[g].second + 1]] - j[k[e[g].second]]);
}
}
swap(k[e[g].second], k[e[g].second + 1]);
}
cout << sum - MAX << endl;
}
} | replace | 12 | 13 | 12 | 13 | 0 | |
p00463 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
struct Border {
int position_height{0}, position_width{0};
};
void solve() {
int width, height, h, k;
std::cin >> width >> height >> h >> k;
while (width != 0 && height != 0) {
std::vector<int> start_pos(width);
std::vector<int> point(width);
for (auto i = 0; i < width; ++i)
start_pos[i] = i;
for (auto &p : point)
std::cin >> p;
std::vector<Border> border(height);
for (auto &b : border)
std::cin >> b.position_width >> b.position_height;
std::sort(border.begin(), border.end(),
[](const Border &a, const Border &b) {
return a.position_height < b.position_height;
});
int sum{0};
for (auto b = border.rbegin(); b != border.rend(); ++b) {
std::swap(point[b->position_width], point[b->position_width - 1]);
}
for (auto &b : border) {
std::swap(start_pos[b.position_width], start_pos[b.position_width - 1]);
if (start_pos[b.position_width] >= k &&
start_pos[b.position_width - 1] < k) {
if (point[start_pos[b.position_width]] -
point[start_pos[b.position_width - 1]] <
sum)
sum = point[start_pos[b.position_width]] -
point[start_pos[b.position_width - 1]];
}
if (start_pos[b.position_width - 1] >= k &&
start_pos[b.position_width] < k) {
if (point[start_pos[b.position_width - 1]] -
point[start_pos[b.position_width]] <
sum)
sum = point[start_pos[b.position_width - 1]] -
point[start_pos[b.position_width]];
}
}
for (auto i = 0; i < k; ++i) {
sum += point[i];
}
std::cout << sum << std::endl;
std::cin >> height >> width >> h >> k;
}
}
int main() { solve(); }
| #include <algorithm>
#include <functional>
#include <iostream>
#include <vector>
struct Border {
int position_height{0}, position_width{0};
};
void solve() {
int width, height, h, k;
std::cin >> width >> height >> h >> k;
while (width != 0 && height != 0) {
std::vector<int> start_pos(width);
std::vector<int> point(width);
for (auto i = 0; i < width; ++i)
start_pos[i] = i;
for (auto &p : point)
std::cin >> p;
std::vector<Border> border(height);
for (auto &b : border)
std::cin >> b.position_width >> b.position_height;
std::sort(border.begin(), border.end(),
[](const Border &a, const Border &b) {
return a.position_height < b.position_height;
});
int sum{0};
for (auto b = border.rbegin(); b != border.rend(); ++b) {
std::swap(point[b->position_width], point[b->position_width - 1]);
}
for (auto &b : border) {
std::swap(start_pos[b.position_width], start_pos[b.position_width - 1]);
if (start_pos[b.position_width] >= k &&
start_pos[b.position_width - 1] < k) {
if (point[start_pos[b.position_width]] -
point[start_pos[b.position_width - 1]] <
sum)
sum = point[start_pos[b.position_width]] -
point[start_pos[b.position_width - 1]];
}
if (start_pos[b.position_width - 1] >= k &&
start_pos[b.position_width] < k) {
if (point[start_pos[b.position_width - 1]] -
point[start_pos[b.position_width]] <
sum)
sum = point[start_pos[b.position_width - 1]] -
point[start_pos[b.position_width]];
}
}
for (auto i = 0; i < k; ++i) {
sum += point[i];
}
std::cout << sum << std::endl;
std::cin >> width >> height >> h >> k;
}
}
int main() { solve(); }
| replace | 52 | 53 | 52 | 53 | 0 | |
p00463 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string.h>
#include <vector>
using namespace std;
#define N 1000
#define M 100000
#define S second
#define F first
#define MP(i, j) make_pair((i), (j))
#define INF 1e9
typedef pair<int, int> P;
vector<int> vec[N + 1][2], vec2, vec3;
P yoko[M];
int s[N + 1];
int main() {
int n, m, h, k;
while (cin >> n >> m >> h >> k && n && m && h && k) {
int ans = INF, sum = 0;
memset(s, 0, sizeof s);
memset(yoko, 0, sizeof yoko);
vec2.clear();
vec3.clear();
for (int i = 0; i < n; i++) {
scanf("%d", s + i);
vec[i][0].clear();
vec[i][1].clear();
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
yoko[i] = MP(b, a);
}
sort(yoko, yoko + m);
for (int i = 0; i < n; i++) {
vec[i][0].push_back(i);
}
for (int i = 0; i < m; i++) {
// cout << 1 << endl;
int a = yoko[i].S;
a--;
int sz = vec[a][1].size();
for (int j = 0; j < vec[a + 1][1].size(); j++) {
vec[a][1].push_back(vec[a + 1][1][j]);
}
// cout << 2 << endl;
vec[a + 1][1].clear();
for (int j = 0; j < vec[a][1].size(); j++) {
vec[a + 1][1].push_back(vec[a][1][j]);
}
if (sz)
vec[a][1].erase(vec[a][1].begin(), vec[a][1].begin() + sz);
// cout << 3 << endl;
for (int j = 0; j < vec[a + 1][0].size(); j++) {
vec[a][0].push_back(vec[a + 1][0][j]);
vec[a + 1][1].push_back(vec[a + 1][0][j]);
}
// cout << 4 << endl;
vec[a + 1][0].erase(vec[a + 1][0].begin(), vec[a + 1][0].end());
for (int j = 0; j < 1; j++) {
vec[a + 1][0].push_back(vec[a][0][j]);
vec[a][1].push_back(vec[a][0][j]);
}
if (vec[a][0].size())
vec[a][0].erase(vec[a][0].begin(), vec[a][0].begin() + 1);
// cout << 5 << endl;
}
for (int i = 0; i < n; i++) {
if (k >= vec[i][0][0] + 1) {
sum += s[i];
vec2.push_back(i);
} else {
vec3.push_back(i);
}
sort(vec[i][1].begin(), vec[i][1].end());
}
for (int i = 0; i < vec2.size(); i++) {
for (int j = 0; j < vec3.size(); j++) {
if (s[vec2[i]] > s[vec3[j]]) {
if (binary_search(vec[vec3[j]][1].begin(), vec[vec3[j]][1].end(),
vec[vec2[i]][0][0])) {
ans = min(ans, sum - s[vec2[i]] + s[vec3[j]]);
}
}
}
}
ans = min(ans, sum);
cout << ans << endl;
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string.h>
#include <vector>
using namespace std;
#define N 1000
#define M 100000
#define S second
#define F first
#define MP(i, j) make_pair((i), (j))
#define INF 1e9
typedef pair<int, int> P;
vector<int> vec[N + 1][2], vec2, vec3;
P yoko[M];
int s[N + 1];
int main() {
int n, m, h, k;
while (cin >> n >> m >> h >> k && n && m && h && k) {
int ans = INF, sum = 0;
memset(s, 0, sizeof s);
memset(yoko, 0, sizeof yoko);
vec2.clear();
vec3.clear();
for (int i = 0; i < n; i++) {
scanf("%d", s + i);
vec[i][0].clear();
vec[i][1].clear();
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
yoko[i] = MP(b, a);
}
sort(yoko, yoko + m);
for (int i = 0; i < n; i++) {
vec[i][0].push_back(i);
}
for (int i = 0; i < m; i++) {
// cout << 1 << endl;
int a = yoko[i].S;
a--;
int sz = vec[a][1].size();
for (int j = 0; j < vec[a + 1][1].size(); j++) {
vec[a][1].push_back(vec[a + 1][1][j]);
}
// cout << 2 << endl;
vec[a + 1][1].clear();
for (int j = 0; j < sz; j++) {
vec[a + 1][1].push_back(vec[a][1][j]);
}
if (sz)
vec[a][1].erase(vec[a][1].begin(), vec[a][1].begin() + sz);
// cout << 3 << endl;
for (int j = 0; j < vec[a + 1][0].size(); j++) {
vec[a][0].push_back(vec[a + 1][0][j]);
vec[a + 1][1].push_back(vec[a + 1][0][j]);
}
// cout << 4 << endl;
vec[a + 1][0].erase(vec[a + 1][0].begin(), vec[a + 1][0].end());
for (int j = 0; j < 1; j++) {
vec[a + 1][0].push_back(vec[a][0][j]);
vec[a][1].push_back(vec[a][0][j]);
}
if (vec[a][0].size())
vec[a][0].erase(vec[a][0].begin(), vec[a][0].begin() + 1);
// cout << 5 << endl;
}
for (int i = 0; i < n; i++) {
if (k >= vec[i][0][0] + 1) {
sum += s[i];
vec2.push_back(i);
} else {
vec3.push_back(i);
}
sort(vec[i][1].begin(), vec[i][1].end());
}
for (int i = 0; i < vec2.size(); i++) {
for (int j = 0; j < vec3.size(); j++) {
if (s[vec2[i]] > s[vec3[j]]) {
if (binary_search(vec[vec3[j]][1].begin(), vec[vec3[j]][1].end(),
vec[vec2[i]][0][0])) {
ans = min(ans, sum - s[vec2[i]] + s[vec3[j]]);
}
}
}
}
ans = min(ans, sum);
cout << ans << endl;
}
} | replace | 50 | 51 | 50 | 51 | 0 | |
p00463 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// #include <utility>
// #include <memory>
// #include <functional>
// #include <deque>
// #include <cctype>
// #include <ctime>
// #include <numeric>
// #include <list>
// #include <iomanip>
// #if __cplusplus >= 201103L
// #include <array>
// #include <tuple>
// #include <initializer_list>
// #include <forward_list>
//
// #define cauto const auto&
// #else
// #endif
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long>> vvll, vvLL;
#define VV(T) vector<vector<T>>
template <class T>
void initvv(vector<vector<T>> &v, int a, int b, const T &t = T()) {
v.assign(a, vector<T>(b, t));
}
template <class F, class T> void convert(const F &f, T &t) {
stringstream ss;
ss << f;
ss >> t;
}
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) reep((i), 0, (n))
#define ALL(v) (v).begin(), (v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(), (v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x) cout << #x << " = " << (x) << endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#else
#define dump(x)
#define debug(x)
#endif
#define LDcout(x, n) fixed << setprecision(n) << x
#define MOD 1000000007LL
#define EPS 1e-8
static const int INF = 1 << 24;
void mainmain() {
int n, m, h, K;
while (cin >> n >> m >> h >> K, n) {
vint v(n);
set<pii> se;
rep(i, n) cin >> v[i];
vector<pii> w(m);
rep(i, m) cin >> w[i].S >> w[i].F;
sort(ALL(w));
vint pos(n);
rep(i, n) pos[i] = i;
rep(i, m) {
se.insert(minmax(pos[w[i].S], pos[w[i].S + 1]));
swap(pos[w[i].S], pos[w[i].S + 1]);
}
int ans = 0;
vint score(n);
rep(i, n) {
if (pos[i] < K) {
ans += v[i];
}
score[pos[i]] = v[i];
}
int tmp = 0;
for (pii x : se) {
if (x.F < K && x.S >= K) {
tmp = max(tmp, score[x.F] - score[x.S]);
}
}
cout << ans - tmp << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
mainmain();
} | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
// #include <utility>
// #include <memory>
// #include <functional>
// #include <deque>
// #include <cctype>
// #include <ctime>
// #include <numeric>
// #include <list>
// #include <iomanip>
// #if __cplusplus >= 201103L
// #include <array>
// #include <tuple>
// #include <initializer_list>
// #include <forward_list>
//
// #define cauto const auto&
// #else
// #endif
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vint;
typedef vector<vector<int>> vvint;
typedef vector<long long> vll, vLL;
typedef vector<vector<long long>> vvll, vvLL;
#define VV(T) vector<vector<T>>
template <class T>
void initvv(vector<vector<T>> &v, int a, int b, const T &t = T()) {
v.assign(a, vector<T>(b, t));
}
template <class F, class T> void convert(const F &f, T &t) {
stringstream ss;
ss << f;
ss >> t;
}
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define reep(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) reep((i), 0, (n))
#define ALL(v) (v).begin(), (v).end()
#define PB push_back
#define F first
#define S second
#define mkp make_pair
#define RALL(v) (v).rbegin(), (v).rend()
#define DEBUG
#ifdef DEBUG
#define dump(x) cout << #x << " = " << (x) << endl;
#define debug(x) \
cout << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#else
#define dump(x)
#define debug(x)
#endif
#define LDcout(x, n) fixed << setprecision(n) << x
#define MOD 1000000007LL
#define EPS 1e-8
static const int INF = 1 << 24;
void mainmain() {
int n, m, h, K;
while (cin >> n >> m >> h >> K, n) {
vint v(n);
set<pii> se;
rep(i, n) cin >> v[i];
vector<pii> w(m);
rep(i, m) cin >> w[i].S >> w[i].F, w[i].S--;
sort(ALL(w));
vint pos(n);
rep(i, n) pos[i] = i;
rep(i, m) {
se.insert(minmax(pos[w[i].S], pos[w[i].S + 1]));
swap(pos[w[i].S], pos[w[i].S + 1]);
}
int ans = 0;
vint score(n);
rep(i, n) {
if (pos[i] < K) {
ans += v[i];
}
score[pos[i]] = v[i];
}
int tmp = 0;
for (pii x : se) {
if (x.F < K && x.S >= K) {
tmp = max(tmp, score[x.F] - score[x.S]);
}
}
cout << ans - tmp << endl;
}
}
signed main() {
ios_base::sync_with_stdio(false);
cout << fixed << setprecision(0);
mainmain();
} | replace | 100 | 101 | 100 | 101 | 0 | |
p00463 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int s[1000], d[1000], y[1000];
P p[100000];
int main() {
int n, m, h, k;
while (scanf("%d%d%d%d", &n, &m, &h, &k), n) {
rep(i, n) scanf("%d", &s[i]);
rep(i, m) {
int a, b;
scanf("%d%d", &a, &b);
p[i] = {b, a};
}
sort(p, p + m);
iota(d, d + m, 0);
rep(i, m) {
swap(d[p[i].second - 1], d[p[i].second]);
p[i] = {d[p[i].second - 1], d[p[i].second]};
if (p[i].first > p[i].second)
swap(p[i].first, p[i].second);
}
rep(i, n) y[d[i]] = s[i];
int M = accumulate(y, y + k, 0);
int S = M;
rep(i, m) {
if (p[i].first < k && p[i].second >= k)
M = min(M, S + y[p[i].second] - y[p[i].first]);
}
printf("%d\n", M);
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int s[1000], d[1000], y[1000];
P p[100000];
int main() {
int n, m, h, k;
while (scanf("%d%d%d%d", &n, &m, &h, &k), n) {
rep(i, n) scanf("%d", &s[i]);
rep(i, m) {
int a, b;
scanf("%d%d", &a, &b);
p[i] = {b, a};
}
sort(p, p + m);
iota(d, d + n, 0);
rep(i, m) {
swap(d[p[i].second - 1], d[p[i].second]);
p[i] = {d[p[i].second - 1], d[p[i].second]};
if (p[i].first > p[i].second)
swap(p[i].first, p[i].second);
}
rep(i, n) y[d[i]] = s[i];
int M = accumulate(y, y + k, 0);
int S = M;
rep(i, m) {
if (p[i].first < k && p[i].second >= k)
M = min(M, S + y[p[i].second] - y[p[i].first]);
}
printf("%d\n", M);
}
} | replace | 17 | 18 | 17 | 18 | 0 | |
p00463 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, m, h, k;
typedef pair<int, int> P;
vector<P> ber;
long long int x[1001], ax[1001];
long long int sc[1001], scn[1001];
long long int yk[100001][2], ys[100001][2];
int resn;
long long int res;
long long int ans;
int main(void) {
while (1) {
scanf("%d%d%d%d", &n, &m, &h, &k);
if (n == 0 && m == 0 && h == 0 && k == 0)
break;
memset(x, 0, sizeof(x));
memset(ax, 0, sizeof(ax));
memset(sc, 0, sizeof(sc));
memset(scn, 0, sizeof(scn));
memset(yk, 0, sizeof(yk));
memset(ys, 0, sizeof(ys));
ber.clear();
res = 0;
ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", sc[i]);
scn[i] = sc[i];
x[i] = i;
ax[i] = i;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
ber.push_back(P(b, a));
}
sort(ber.begin(), ber.end());
for (int i = 0; i < m; i++) {
swap(x[ber[i].second], x[ber[i].second + 1]);
}
resn = -1;
for (int i = m - 1; i >= 0; i--) {
ys[i][0] = scn[ber[i].second], ys[i][1] = scn[ber[i].second + 1];
swap(x[ber[i].second], x[ber[i].second + 1]);
swap(scn[ber[i].second], scn[ber[i].second + 1]);
yk[i][0] = x[ber[i].second], yk[i][1] = x[ber[i].second + 1];
if (yk[i][0] <= k && yk[i][1] > k) {
long long int sa = ys[i][1] - ys[i][0];
if (sa >= res)
resn = i, res = sa;
}
if (yk[i][1] <= k && yk[i][0] > k) {
long long int sa = ys[i][0] - ys[i][1];
if (sa >= res)
resn = i, res = sa;
}
}
for (int i = 0; i < m; i++) {
if (i != resn)
swap(ax[ber[i].second], ax[ber[i].second + 1]);
}
for (int i = 1; i <= n; i++) {
if (ax[i] <= k)
ans += sc[i];
}
printf("%lld\n", ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int n, m, h, k;
typedef pair<int, int> P;
vector<P> ber;
long long int x[1001], ax[1001];
long long int sc[1001], scn[1001];
long long int yk[100001][2], ys[100001][2];
int resn;
long long int res;
long long int ans;
int main(void) {
while (1) {
scanf("%d%d%d%d", &n, &m, &h, &k);
if (n == 0 && m == 0 && h == 0 && k == 0)
break;
memset(x, 0, sizeof(x));
memset(ax, 0, sizeof(ax));
memset(sc, 0, sizeof(sc));
memset(scn, 0, sizeof(scn));
memset(yk, 0, sizeof(yk));
memset(ys, 0, sizeof(ys));
ber.clear();
res = 0;
ans = 0;
for (int i = 1; i <= n; i++) {
scanf("%lld", &sc[i]);
scn[i] = sc[i];
x[i] = i;
ax[i] = i;
}
for (int i = 0; i < m; i++) {
int a, b;
scanf("%d%d", &a, &b);
ber.push_back(P(b, a));
}
sort(ber.begin(), ber.end());
for (int i = 0; i < m; i++) {
swap(x[ber[i].second], x[ber[i].second + 1]);
}
resn = -1;
for (int i = m - 1; i >= 0; i--) {
ys[i][0] = scn[ber[i].second], ys[i][1] = scn[ber[i].second + 1];
swap(x[ber[i].second], x[ber[i].second + 1]);
swap(scn[ber[i].second], scn[ber[i].second + 1]);
yk[i][0] = x[ber[i].second], yk[i][1] = x[ber[i].second + 1];
if (yk[i][0] <= k && yk[i][1] > k) {
long long int sa = ys[i][1] - ys[i][0];
if (sa >= res)
resn = i, res = sa;
}
if (yk[i][1] <= k && yk[i][0] > k) {
long long int sa = ys[i][0] - ys[i][1];
if (sa >= res)
resn = i, res = sa;
}
}
for (int i = 0; i < m; i++) {
if (i != resn)
swap(ax[ber[i].second], ax[ber[i].second + 1]);
}
for (int i = 1; i <= n; i++) {
if (ax[i] <= k)
ans += sc[i];
}
printf("%lld\n", ans);
}
return 0;
} | replace | 35 | 36 | 35 | 36 | -11 | |
p00464 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define EPS 1e-8
#define DEB 0
int field[128][128];
int dp[128][128];
int h, w, n;
int main() {
while (scanf("%d%d%d", &h, &w, &n), h | w | n) {
memset(dp, 0, sizeof(dp));
rep(i, h) {
rep(j, w) { scanf("%d", &field[i + 1][j + 1]); }
}
dp[1][1] = n - 1;
REP(i, 1, h + 1) {
REP(j, 1, w + 1) {
int k1, k2;
if (dp[i - 1][j] % 2 && field[i - 1][j] == 0) {
k1 = 1;
} else {
k1 = 0;
}
if (dp[i][j - 1] % 2 && field[i][j - 1] == 1) {
k2 = 1;
} else {
k2 = 0;
}
dp[i][j] += (dp[i - 1][j] + k1) / 2 + (dp[i][j - 1] + k2) / 2;
}
}
#if DEB
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { printf("%2d ", dp[i][j]); }
puts("");
}
#endif
// Nツ嘉アツ姪堋づ個湘ウツ妥板づーツ青カツ青ャ
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { field[i][j] = (field[i][j] + dp[i][j]) % 2; }
}
#if DEB
puts("field");
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { printf("%2d ", field[i][j]); }
puts("");
}
#endif
int x = 1;
int y = 1;
for (;;) {
if (x > w || y > h)
break;
if (field[y][x] == 1) {
x++;
} else {
y++;
}
}
printf("%d %d\n", y, x);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define EPS 1e-8
#define DEB 0
int field[1024][1024];
int dp[1024][1024];
int h, w, n;
int main() {
while (scanf("%d%d%d", &h, &w, &n), h | w | n) {
memset(dp, 0, sizeof(dp));
rep(i, h) {
rep(j, w) { scanf("%d", &field[i + 1][j + 1]); }
}
dp[1][1] = n - 1;
REP(i, 1, h + 1) {
REP(j, 1, w + 1) {
int k1, k2;
if (dp[i - 1][j] % 2 && field[i - 1][j] == 0) {
k1 = 1;
} else {
k1 = 0;
}
if (dp[i][j - 1] % 2 && field[i][j - 1] == 1) {
k2 = 1;
} else {
k2 = 0;
}
dp[i][j] += (dp[i - 1][j] + k1) / 2 + (dp[i][j - 1] + k2) / 2;
}
}
#if DEB
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { printf("%2d ", dp[i][j]); }
puts("");
}
#endif
// Nツ嘉アツ姪堋づ個湘ウツ妥板づーツ青カツ青ャ
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { field[i][j] = (field[i][j] + dp[i][j]) % 2; }
}
#if DEB
puts("field");
REP(i, 1, h + 1) {
REP(j, 1, w + 1) { printf("%2d ", field[i][j]); }
puts("");
}
#endif
int x = 1;
int y = 1;
for (;;) {
if (x > w || y > h)
break;
if (field[y][x] == 1) {
x++;
} else {
y++;
}
}
printf("%d %d\n", y, x);
}
return 0;
} | replace | 19 | 21 | 19 | 21 | 0 | |
p00464 | C++ | Runtime Error |
#include <stdio.h>
#include <string.h>
int board[1234][1234];
int mark[1234][1234];
int main() {
for (;;) {
int h, w, n;
scanf("%d %d %d", &h, &w, &n);
if (h == 0 && w == 0 && n == 0)
break;
memset(board, 255, sizeof(board));
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
scanf("%d", &board[i][j]);
}
}
memset(mark, 0, sizeof(mark));
mark[0][0] = n - 1;
for (int sum = 0; sum < w + h - 1; ++sum) {
for (int vr = 0; vr <= sum; ++vr) {
int hr = sum - vr;
if (hr >= w)
continue;
if (hr < 0)
break;
if (board[vr][hr] == 0) {
mark[vr][hr + 1] += mark[vr][hr] / 2;
mark[vr + 1][hr] += mark[vr][hr] / 2 + (mark[vr][hr] % 2);
} else {
mark[vr][hr + 1] += mark[vr][hr] / 2 + (mark[vr][hr] % 2);
mark[vr + 1][hr] += mark[vr][hr] / 2;
}
if (mark[vr][hr] % 2) {
board[vr][hr] = (board[vr][hr] == 0) ? 1 : 0;
}
}
}
int py = 0, px = 0;
while (board[py][px] >= 0) {
if (board[py][px] == 0) {
++py;
} else {
++px;
}
}
printf("%d %d\n", py + 1, px + 1);
}
return 0;
} |
#include <stdio.h>
#include <string.h>
int board[1234][1234];
int mark[1234][1234];
int main() {
for (;;) {
int h, w, n;
scanf("%d %d %d", &h, &w, &n);
if (h == 0 && w == 0 && n == 0)
break;
memset(board, 255, sizeof(board));
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
scanf("%d", &board[i][j]);
}
}
memset(mark, 0, sizeof(mark));
mark[0][0] = n - 1;
for (int sum = 0; sum < w + h - 1; ++sum) {
for (int vr = 0; vr <= sum; ++vr) {
if (vr >= h)
break;
int hr = sum - vr;
if (hr >= w)
continue;
if (hr < 0)
break;
if (board[vr][hr] == 0) {
mark[vr][hr + 1] += mark[vr][hr] / 2;
mark[vr + 1][hr] += mark[vr][hr] / 2 + (mark[vr][hr] % 2);
} else {
mark[vr][hr + 1] += mark[vr][hr] / 2 + (mark[vr][hr] % 2);
mark[vr + 1][hr] += mark[vr][hr] / 2;
}
if (mark[vr][hr] % 2) {
board[vr][hr] = (board[vr][hr] == 0) ? 1 : 0;
}
}
}
int py = 0, px = 0;
while (board[py][px] >= 0) {
if (board[py][px] == 0) {
++py;
} else {
++px;
}
}
printf("%d %d\n", py + 1, px + 1);
}
return 0;
} | insert | 23 | 23 | 23 | 25 | 0 | |
p00464 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int h, w, n;
int a[1002][1002], b[1002][1002] = {0};
pair<int, int> walk(int x, int y) {
if (a[x][y] == 0)
x++;
else
y++;
if (x < h && y < w)
return walk(x, y);
pair<int, int> ret;
ret.first = x + 1;
ret.second = y + 1;
return ret;
}
int main() {
while (1) {
scanf("%d%d%d", &h, &w, &n);
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
scanf("%d", &a[i][j]);
b[i][j] = 0;
}
}
b[0][0] = n - 1;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
b[i][j + 1] += b[i][j] / 2;
b[i + 1][j] += b[i][j] / 2;
if (b[i][j] % 2 == 1) {
if (a[i][j] == 0)
b[i + 1][j]++;
else
b[i][j + 1]++;
}
a[i][j] += b[i][j];
a[i][j] %= 2;
}
}
pair<int, int> ret = walk(0, 0);
printf("%d %d\n", ret.first, ret.second);
}
} | #include <iostream>
using namespace std;
int h, w, n;
int a[1002][1002], b[1002][1002] = {0};
pair<int, int> walk(int x, int y) {
if (a[x][y] == 0)
x++;
else
y++;
if (x < h && y < w)
return walk(x, y);
pair<int, int> ret;
ret.first = x + 1;
ret.second = y + 1;
return ret;
}
int main() {
while (1) {
scanf("%d%d%d", &h, &w, &n);
if (h == 0)
break;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
scanf("%d", &a[i][j]);
b[i][j] = 0;
}
}
b[0][0] = n - 1;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
b[i][j + 1] += b[i][j] / 2;
b[i + 1][j] += b[i][j] / 2;
if (b[i][j] % 2 == 1) {
if (a[i][j] == 0)
b[i + 1][j]++;
else
b[i][j + 1]++;
}
a[i][j] += b[i][j];
a[i][j] %= 2;
}
}
pair<int, int> ret = walk(0, 0);
printf("%d %d\n", ret.first, ret.second);
}
} | insert | 21 | 21 | 21 | 23 | TLE | |
p00464 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int d[1005][1005];
bool e[1005][1005];
int a, b, c;
signed main() {
while (cin >> a >> b >> c, a | b | c) {
memset(d, 0, sizeof(d));
memset(e, false, sizeof(e));
for (int f = 0; f < a; f++) {
for (int g = 0; g < b; g++) {
scanf("%d", &e[f][g]);
}
}
d[0][0] = c - 1;
for (int h = 0; h < a + b - 1; h++) {
for (int i = 0; i <= h; i++) {
int x = i, y = h - i;
if (d[x][y] & 1) {
if (e[x][y]) {
d[x + 1][y] += d[x][y] / 2;
d[x][y + 1] += d[x][y] / 2 + 1;
} else {
d[x + 1][y] += d[x][y] / 2 + 1;
d[x][y + 1] += d[x][y] / 2;
}
} else {
d[x + 1][y] += d[x][y] / 2;
d[x][y + 1] += d[x][y] / 2;
}
e[x][y] = (e[x][y] + d[x][y]) & 1;
}
}
int x = 0, y = 0;
while (1) {
if (x == a || y == b) {
cout << x + 1 << " " << y + 1 << endl;
break;
}
if (e[x][y])
y++;
else
x++;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int d[3005][3005];
bool e[3005][3005];
int a, b, c;
signed main() {
while (cin >> a >> b >> c, a | b | c) {
memset(d, 0, sizeof(d));
memset(e, false, sizeof(e));
for (int f = 0; f < a; f++) {
for (int g = 0; g < b; g++) {
scanf("%d", &e[f][g]);
}
}
d[0][0] = c - 1;
for (int h = 0; h < a + b - 1; h++) {
for (int i = 0; i <= h; i++) {
int x = i, y = h - i;
if (d[x][y] & 1) {
if (e[x][y]) {
d[x + 1][y] += d[x][y] / 2;
d[x][y + 1] += d[x][y] / 2 + 1;
} else {
d[x + 1][y] += d[x][y] / 2 + 1;
d[x][y + 1] += d[x][y] / 2;
}
} else {
d[x + 1][y] += d[x][y] / 2;
d[x][y + 1] += d[x][y] / 2;
}
e[x][y] = (e[x][y] + d[x][y]) & 1;
}
}
int x = 0, y = 0;
while (1) {
if (x == a || y == b) {
cout << x + 1 << " " << y + 1 << endl;
break;
}
if (e[x][y])
y++;
else
x++;
}
}
} | replace | 3 | 5 | 3 | 5 | 0 | |
p00464 | C++ | Runtime Error | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 2000
long long x[MAX_N][MAX_N];
long long dp[MAX_N][MAX_N];
int h, w, n, cx, cy;
int main() {
while (true) {
memset(dp, 0, sizeof(dp));
cin >> h >> w >> n;
if (h == 0 && w == 0 && n == 0) {
break;
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
scanf("%d", x[i][j]);
}
}
dp[1][1] = n - 1;
for (int i = 2; i <= h + w; i++) {
for (int j = 1; j <= h; j++) {
int k = i - j;
if (k >= 1 && k <= w) {
if (x[j][k] == 0) {
dp[j][k + 1] += dp[j][k] / 2;
dp[j + 1][k] += (dp[j][k] + 1) / 2;
} else {
dp[j][k + 1] += (dp[j][k] + 1) / 2;
dp[j + 1][k] += dp[j][k] / 2;
}
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
x[i][j] += dp[i][j];
x[i][j] %= 2;
}
}
cx = 1;
cy = 1;
while (cx <= w && cy <= h) {
if (x[cy][cx] == 0) {
cy++;
} else {
cx++;
}
}
cout << cy << ' ' << cx << endl;
}
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 2000
long long x[MAX_N][MAX_N];
long long dp[MAX_N][MAX_N];
int h, w, n, cx, cy;
int main() {
while (true) {
memset(dp, 0, sizeof(dp));
cin >> h >> w >> n;
if (h == 0 && w == 0 && n == 0) {
break;
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
scanf("%d", &x[i][j]);
}
}
dp[1][1] = n - 1;
for (int i = 2; i <= h + w; i++) {
for (int j = 1; j <= h; j++) {
int k = i - j;
if (k >= 1 && k <= w) {
if (x[j][k] == 0) {
dp[j][k + 1] += dp[j][k] / 2;
dp[j + 1][k] += (dp[j][k] + 1) / 2;
} else {
dp[j][k + 1] += (dp[j][k] + 1) / 2;
dp[j + 1][k] += dp[j][k] / 2;
}
}
}
}
for (int i = 1; i <= h; i++) {
for (int j = 1; j <= w; j++) {
x[i][j] += dp[i][j];
x[i][j] %= 2;
}
}
cx = 1;
cy = 1;
while (cx <= w && cy <= h) {
if (x[cy][cx] == 0) {
cy++;
} else {
cx++;
}
}
cout << cy << ' ' << cx << endl;
}
return 0;
} | replace | 19 | 20 | 19 | 20 | -11 | |
p00465 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const LL INF = 1001001001001001;
int r, x[2], y[2];
LL grid[2][502][502];
bool done[2][502][502];
LL memo[2][5001];
struct P {
int g, x, y;
bool operator<(const P &t) const { return grid[g][x][y] > grid[g][t.x][t.y]; }
};
void search(int g) {
for (int i = 0; i < 502; i++) {
for (int j = 0; j < 502; j++) {
done[g][i][j] = false;
}
}
for (int i = 0; i <= 5000; i++) {
memo[g][i] = INF;
}
memo[g][0] = 0;
int num = 0;
LL level = 0;
LL mini = INF;
priority_queue<P> que;
que.push({g, x[g], y[g]});
while (!que.empty()) {
P p = que.top();
que.pop();
if (done[g][p.x][p.y])
continue;
done[g][p.x][p.y] = true;
// printf("%d %d %d\n", g, p.x, p.y);
if (grid[g][p.x][p.y] <= level) {
num++;
memo[g][num] = level;
} else {
// if (grid[g][p.x][p.y] == INF) break;
level = grid[g][p.x][p.y];
num++;
memo[g][num] = level;
}
if (num >= r)
return;
for (int dir = 0; dir < 4; dir++) {
int tx = p.x + dx[dir];
int ty = p.y + dy[dir];
if (!done[g][tx][ty] && done[g][tx][ty] != INF) {
que.push({g, tx, ty});
}
}
}
}
int main() {
while (scanf("%d", &r), r) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 502; j++) {
for (int k = 0; k < 502; k++) {
grid[i][j][k] = INF;
}
}
int h, w;
scanf("%d %d %d %d", &w, &h, &y[i], &x[i]);
for (int j = 1; j <= h; j++) {
for (int k = 1; k <= w; k++) {
scanf("%lld", &grid[i][j][k]);
}
}
}
for (int i = 0; i < 2; i++) {
search(i);
}
LL mini = INF;
for (int i = 0; i <= r; i++) {
mini = min(mini, memo[0][i] + memo[1][r - i]);
}
printf("%lld\n", mini);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long LL;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
const LL INF = 1001001001001001;
int r, x[2], y[2];
LL grid[2][502][502];
bool done[2][502][502];
LL memo[2][500001];
struct P {
int g, x, y;
bool operator<(const P &t) const { return grid[g][x][y] > grid[g][t.x][t.y]; }
};
void search(int g) {
for (int i = 0; i < 502; i++) {
for (int j = 0; j < 502; j++) {
done[g][i][j] = false;
}
}
for (int i = 0; i <= 5000; i++) {
memo[g][i] = INF;
}
memo[g][0] = 0;
int num = 0;
LL level = 0;
LL mini = INF;
priority_queue<P> que;
que.push({g, x[g], y[g]});
while (!que.empty()) {
P p = que.top();
que.pop();
if (done[g][p.x][p.y])
continue;
done[g][p.x][p.y] = true;
// printf("%d %d %d\n", g, p.x, p.y);
if (grid[g][p.x][p.y] <= level) {
num++;
memo[g][num] = level;
} else {
// if (grid[g][p.x][p.y] == INF) break;
level = grid[g][p.x][p.y];
num++;
memo[g][num] = level;
}
if (num >= r)
return;
for (int dir = 0; dir < 4; dir++) {
int tx = p.x + dx[dir];
int ty = p.y + dy[dir];
if (!done[g][tx][ty] && done[g][tx][ty] != INF) {
que.push({g, tx, ty});
}
}
}
}
int main() {
while (scanf("%d", &r), r) {
for (int i = 0; i < 2; i++) {
for (int j = 0; j < 502; j++) {
for (int k = 0; k < 502; k++) {
grid[i][j][k] = INF;
}
}
int h, w;
scanf("%d %d %d %d", &w, &h, &y[i], &x[i]);
for (int j = 1; j <= h; j++) {
for (int k = 1; k <= w; k++) {
scanf("%lld", &grid[i][j][k]);
}
}
}
for (int i = 0; i < 2; i++) {
search(i);
}
LL mini = INF;
for (int i = 0; i <= r; i++) {
mini = min(mini, memo[0][i] + memo[1][r - i]);
}
printf("%lld\n", mini);
}
return 0;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p00465 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <queue>
#include <stdio.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
struct cxy {
int cost, x, y;
bool operator<(const cxy &rhs) const { return cost < rhs.cost; }
bool operator>(const cxy &rhs) const { return cost > rhs.cost; }
};
int CalcTable(int *ret) {
int w, h, x, y;
scanf("%d%d%d%d", &w, &h, &x, &y);
static int m[500][500];
REP(i, h)
REP(j, w)
scanf("%d", &m[i][j]);
ret[0] = 0;
priority_queue<cxy, vector<cxy>, greater<cxy>> pq;
static bool used[500][500];
REP(i, h)
REP(j, w)
used[i][j] = false;
pq.push({1, --x, --y});
used[y][x] = true;
int c = 0;
static const int dxy[] = {0, -1, 0, 1, 0};
int b = 0;
while (!pq.empty()) {
cxy t = pq.top();
pq.pop();
b = max(b, t.cost);
ret[++c] = b;
REP(i, 4) {
int nx = t.x + dxy[i];
int ny = t.y + dxy[i + 1];
if (0 <= nx && nx < w && 0 <= ny && ny < h)
if (!used[ny][nx]) {
pq.push({m[ny][nx], nx, ny});
used[ny][nx] = true;
}
}
}
return w * h + 1;
}
int main() {
while (1) {
int r;
scanf("%d", &r);
if (r == 0)
break;
static int buf1[250001];
static int buf2[250001];
int r1 = CalcTable(buf1);
int r2 = CalcTable(buf2);
int ans = 1145141919;
REP(i, r1) {
int j = r - i;
if (j < r2)
ans = min(ans, buf1[i] + buf2[j]);
}
printf("%d\n", ans);
}
} | #include <algorithm>
#include <functional>
#include <queue>
#include <stdio.h>
using namespace std;
#define FOR(i, a, b) for (int i = a; i < b; i++)
#define REP(i, b) FOR(i, 0, b)
struct cxy {
int cost, x, y;
bool operator<(const cxy &rhs) const { return cost < rhs.cost; }
bool operator>(const cxy &rhs) const { return cost > rhs.cost; }
};
int CalcTable(int *ret) {
int w, h, x, y;
scanf("%d%d%d%d", &w, &h, &x, &y);
static int m[500][500];
REP(i, h)
REP(j, w)
scanf("%d", &m[i][j]);
ret[0] = 0;
priority_queue<cxy, vector<cxy>, greater<cxy>> pq;
static bool used[500][500];
REP(i, h)
REP(j, w)
used[i][j] = false;
pq.push({1, --x, --y});
used[y][x] = true;
int c = 0;
static const int dxy[] = {0, -1, 0, 1, 0};
int b = 0;
while (!pq.empty()) {
cxy t = pq.top();
pq.pop();
b = max(b, t.cost);
ret[++c] = b;
REP(i, 4) {
int nx = t.x + dxy[i];
int ny = t.y + dxy[i + 1];
if (0 <= nx && nx < w && 0 <= ny && ny < h)
if (!used[ny][nx]) {
pq.push({m[ny][nx], nx, ny});
used[ny][nx] = true;
}
}
}
return w * h + 1;
}
int main() {
while (1) {
int r;
scanf("%d", &r);
if (r == 0)
break;
static int buf1[250001];
static int buf2[250001];
int r1 = CalcTable(buf1);
int r2 = CalcTable(buf2);
int ans = 1145141919;
REP(i, r1) {
int j = r - i;
if (0 <= j && j < r2)
ans = min(ans, buf1[i] + buf2[j]);
}
printf("%d\n", ans);
}
} | replace | 65 | 66 | 65 | 66 | 0 | |
p00465 | C++ | Runtime Error | #include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, pair<int, int>> pp;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int level[2][100001];
int room[500][500];
bool visited[500][500];
int main() {
int r;
while (cin >> r, r) {
int w, h, ex, ey;
int e[2];
for (int i = 0; i < 2; ++i) {
cin >> w >> h >> ex >> ey;
for (int j = 0; j < h; ++j) {
for (int k = 0; k < w; ++k) {
cin >> room[j][k];
}
}
memset(visited, 0, sizeof(visited));
visited[--ey][--ex] = 1;
level[i][0] = 0;
int mlevel = 0, index = 1;
priority_queue<pp, vector<pp>, greater<pp>> pq;
pq.push(make_pair(room[ey][ex], make_pair(ex, ey)));
while (!pq.empty()) {
pp cur = pq.top();
pq.pop();
mlevel = max(mlevel, cur.first);
level[i][index++] = mlevel;
for (int j = 0; j < 4; ++j) {
int cx = cur.second.first + dx[j];
int cy = cur.second.second + dy[j];
if (cx >= 0 && cx < w && cy >= 0 && cy < h && visited[cy][cx] == 0) {
visited[cy][cx] = 1;
pq.push(make_pair(room[cy][cx], make_pair(cx, cy)));
}
}
}
e[i] = index - 1;
}
int ans = 1000000000;
for (int i = 0; i <= r; ++i) {
if (e[0] < r - i || e[1] < i)
continue;
ans = min(ans, level[1][i] + level[0][r - i]);
}
cout << ans << endl;
}
return 0;
} | #include <cstring>
#include <iostream>
#include <queue>
using namespace std;
typedef pair<int, pair<int, int>> pp;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
int level[2][250001];
int room[500][500];
bool visited[500][500];
int main() {
int r;
while (cin >> r, r) {
int w, h, ex, ey;
int e[2];
for (int i = 0; i < 2; ++i) {
cin >> w >> h >> ex >> ey;
for (int j = 0; j < h; ++j) {
for (int k = 0; k < w; ++k) {
cin >> room[j][k];
}
}
memset(visited, 0, sizeof(visited));
visited[--ey][--ex] = 1;
level[i][0] = 0;
int mlevel = 0, index = 1;
priority_queue<pp, vector<pp>, greater<pp>> pq;
pq.push(make_pair(room[ey][ex], make_pair(ex, ey)));
while (!pq.empty()) {
pp cur = pq.top();
pq.pop();
mlevel = max(mlevel, cur.first);
level[i][index++] = mlevel;
for (int j = 0; j < 4; ++j) {
int cx = cur.second.first + dx[j];
int cy = cur.second.second + dy[j];
if (cx >= 0 && cx < w && cy >= 0 && cy < h && visited[cy][cx] == 0) {
visited[cy][cx] = 1;
pq.push(make_pair(room[cy][cx], make_pair(cx, cy)));
}
}
}
e[i] = index - 1;
}
int ans = 1000000000;
for (int i = 0; i <= r; ++i) {
if (e[0] < r - i || e[1] < i)
continue;
ans = min(ans, level[1][i] + level[0][r - i]);
}
cout << ans << endl;
}
return 0;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p00465 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int w[2], h[2], l[2][500][500], sx[2], sy[2], r;
int dx[]{1, -1, 0, 0}, dy[]{0, 0, 1, -1};
int ans[2][100001], d[250000];
bool vis[500][500], used[500][500];
deque<P> que[250000];
int compress(int k) {
vector<int> x;
rep(i, h[k]) rep(j, w[k]) x.push_back(l[k][i][j]);
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
rep(i, x.size()) d[i] = x[i];
rep(i, h[k]) rep(j, w[k]) l[k][i][j] =
lower_bound(x.begin(), x.end(), l[k][i][j]) - x.begin();
return x.size();
}
void solve(int k) {
ans[k][0] = 0;
queue<P> Q;
int n = compress(k);
rep(i, n) que[i].clear();
memset(vis, 0, sizeof(vis));
memset(used, 0, sizeof(used));
Q.push(P(sx[k], sy[k]));
vis[sx[k]][sy[k]] = true;
int cnt = 0, Max = 0;
while (1) {
while (!Q.empty()) {
P p = Q.front();
Q.pop();
if (used[p.first][p.second])
continue;
used[p.first][p.second] = true;
cnt++;
if (cnt >= r)
break;
rep(i, 4) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if (0 <= nx && nx < h[k] && 0 <= ny && ny < w[k] && !vis[nx][ny]) {
vis[nx][ny] = true;
if (l[k][nx][ny] <= Max)
Q.push(P(nx, ny));
else
que[l[k][nx][ny]].push_back(P(nx, ny));
}
}
}
ans[k][cnt] = min(ans[k][cnt], d[Max]);
for (int i = Max; i < n; i++) {
if (!que[i].empty()) {
Max = i;
for (P p : que[i])
Q.push(p);
que[i].clear();
break;
}
}
if (cnt >= r || Q.empty())
break;
}
for (int i = r - 1; i >= 1; i--)
ans[k][i] = min(ans[k][i], ans[k][i + 1]);
}
int main() {
while (scanf("%d", &r), r) {
rep(k, 2) {
scanf("%d%d%d%d", &w[k], &h[k], &sy[k], &sx[k]);
sx[k]--;
sy[k]--;
rep(i, h[k]) rep(j, w[k]) scanf("%d", &l[k][i][j]);
}
fill(ans[0], ans[2], INT_MAX);
rep(k, 2) solve(k);
int Min = INT_MAX;
for (int i = 0; i <= r; i++) {
if (ans[0][i] == INT_MAX || ans[1][r - i] == INT_MAX)
continue;
Min = min(Min, ans[0][i] + ans[1][r - i]);
}
printf("%d\n", Min);
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int w[2], h[2], l[2][500][500], sx[2], sy[2], r;
int dx[]{1, -1, 0, 0}, dy[]{0, 0, 1, -1};
int ans[2][100001], d[250000];
bool vis[500][500], used[500][500];
vector<P> que[250000];
int compress(int k) {
vector<int> x;
rep(i, h[k]) rep(j, w[k]) x.push_back(l[k][i][j]);
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
rep(i, x.size()) d[i] = x[i];
rep(i, h[k]) rep(j, w[k]) l[k][i][j] =
lower_bound(x.begin(), x.end(), l[k][i][j]) - x.begin();
return x.size();
}
void solve(int k) {
ans[k][0] = 0;
queue<P> Q;
int n = compress(k);
rep(i, n) que[i].clear();
memset(vis, 0, sizeof(vis));
memset(used, 0, sizeof(used));
Q.push(P(sx[k], sy[k]));
vis[sx[k]][sy[k]] = true;
int cnt = 0, Max = 0;
while (1) {
while (!Q.empty()) {
P p = Q.front();
Q.pop();
if (used[p.first][p.second])
continue;
used[p.first][p.second] = true;
cnt++;
if (cnt >= r)
break;
rep(i, 4) {
int nx = p.first + dx[i], ny = p.second + dy[i];
if (0 <= nx && nx < h[k] && 0 <= ny && ny < w[k] && !vis[nx][ny]) {
vis[nx][ny] = true;
if (l[k][nx][ny] <= Max)
Q.push(P(nx, ny));
else
que[l[k][nx][ny]].push_back(P(nx, ny));
}
}
}
ans[k][cnt] = min(ans[k][cnt], d[Max]);
for (int i = Max; i < n; i++) {
if (!que[i].empty()) {
Max = i;
for (P p : que[i])
Q.push(p);
que[i].clear();
break;
}
}
if (cnt >= r || Q.empty())
break;
}
for (int i = r - 1; i >= 1; i--)
ans[k][i] = min(ans[k][i], ans[k][i + 1]);
}
int main() {
while (scanf("%d", &r), r) {
rep(k, 2) {
scanf("%d%d%d%d", &w[k], &h[k], &sy[k], &sx[k]);
sx[k]--;
sy[k]--;
rep(i, h[k]) rep(j, w[k]) scanf("%d", &l[k][i][j]);
}
fill(ans[0], ans[2], INT_MAX);
rep(k, 2) solve(k);
int Min = INT_MAX;
for (int i = 0; i <= r; i++) {
if (ans[0][i] == INT_MAX || ans[1][r - i] == INT_MAX)
continue;
Min = min(Min, ans[0][i] + ans[1][r - i]);
}
printf("%d\n", Min);
}
} | replace | 9 | 10 | 9 | 10 | MLE | |
p00466 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
int main(void) {
int a, b;
while (scanf("%d", &a) != 0) {
int c = 0;
for (int i = 1; i < 10; i++) {
scanf("%d", &b);
c += b;
}
c = a - c;
printf("%d\n", c);
}
return 0;
} | #include <cstdio>
using namespace std;
int main(void) {
int a, b;
while (scanf("%d", &a)) {
if (a == 0)
break;
int c = 0;
for (int i = 1; i < 10; i++) {
scanf("%d", &b);
c += b;
}
c = a - c;
printf("%d\n", c);
}
return 0;
} | replace | 5 | 6 | 5 | 8 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main(void) {
for (;;) {
int a, b, c, d;
cin >> a;
if (a == 0) {
break;
}
d = 0;
for (b = 0; b < 10; b++) {
cin >> c;
d = d + c;
}
b = a - d;
cout << b << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
for (;;) {
int a, b, c, d;
cin >> a;
if (a == 0) {
break;
}
d = 0;
for (b = 0; b < 9; b++) {
cin >> c;
d = d + c;
}
b = a - d;
cout << b << endl;
}
return 0;
} | replace | 10 | 11 | 10 | 11 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
while (1) {
int n;
int a;
int sum = 0;
cin >> n;
if (n == 0)
break;
for (int i = 0; i < 10; i++) {
cin >> a;
sum += a;
}
a = n - sum;
cout << a << endl;
}
return 0;
} | #include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main(void) {
while (1) {
int n;
int a;
int sum = 0;
cin >> n;
if (n == 0)
break;
for (int i = 0; i < 9; i++) {
cin >> a;
sum += a;
}
a = n - sum;
cout << a << endl;
}
return 0;
} | replace | 13 | 14 | 13 | 14 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int sum = 0, in;
while (cin >> sum, sum) {
for (int i = 0; i < 10; i++) {
cin >> in;
sum -= in;
}
cout << sum << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int sum = 0, in;
while (cin >> sum, sum) {
for (int i = 0; i < 9; i++) {
cin >> in;
sum -= in;
}
cout << sum << endl;
}
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int a, b, n = 1, i = 0;
cin >> a;
do {
if (a > 10000) {
break;
}
cin >> b;
a = a - b;
i++;
if (i = 9 * n) {
cout << a << endl;
n++;
}
} while (i <= 9 * n);
return 0;
} | #include <iostream>
using namespace std;
int main() {
int total;
cin >> total;
while (total != 0) {
int a, b, c, d, e, f, g, h, i, j;
cin >> a >> b >> c >> d >> e >> f >> g >> h >> i;
j = total - (a + b + c + d + e + f + g + h + i);
cout << j << endl;
cin >> total;
}
return 0;
} | replace | 3 | 18 | 3 | 12 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int total;
int books;
int count = 0;
while (true) {
if (count == 0) {
cin >> total;
if (total == 0) {
break;
}
count++;
} else {
cin >> books;
total -= books;
count++;
}
if (count == 10) {
cout << total << '\n';
}
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int total;
int books;
int count = 0;
while (true) {
if (count == 0) {
cin >> total;
if (total == 0) {
break;
}
count++;
} else {
cin >> books;
total -= books;
count++;
}
if (count == 10) {
cout << total << '\n';
count = 0;
}
}
return 0;
} | insert | 22 | 22 | 22 | 23 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define vi vector<int>
#define vvi vector<vector<int>>
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define all(in) in.begin(), in.end()
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
int main() {
int n;
while (cin >> n, n) {
int t;
rep(i, 10) {
cin >> t;
n -= t;
}
cout << n << endl;
}
} | #include <algorithm>
#include <array>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
#define vi vector<int>
#define vvi vector<vector<int>>
#define ll long long int
#define vl vector<ll>
#define vvl vector<vector<ll>>
#define vb vector<bool>
#define vc vector<char>
#define vs vector<string>
#define ld long double
#define INF 1e9
#define EPS 0.0000000001
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, s, n) for (int i = s; i < n; i++)
#define all(in) in.begin(), in.end()
template <class T, class S> void cmin(T &a, const S &b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &b) {
if (a < b)
a = b;
}
#define MAX 9999999
using namespace std;
typedef pair<int, int> pii;
typedef pair<double, double> pdd;
typedef pair<ll, ll> pll;
int main() {
int n;
while (cin >> n, n) {
int t;
rep(i, 9) {
cin >> t;
n -= t;
}
cout << n << endl;
}
} | replace | 52 | 53 | 52 | 53 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a;
while (1) {
int ruio = 0;
for (int i = 0; i < 9; i++) {
cin >> b;
ruio += b;
}
cout << a - ruio << endl;
cin >> a;
}
} | #include <iostream>
using namespace std;
int main() {
int a, b;
cin >> a;
while (a != 0) {
int ruio = 0;
for (int i = 0; i < 9; i++) {
cin >> b;
ruio += b;
}
cout << a - ruio << endl;
cin >> a;
}
} | replace | 5 | 6 | 5 | 6 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, a;
while (cin >> s, s) {
cin >> s;
for (int i = 0; i < 9; i++) {
cin >> a;
s -= a;
}
cout << s << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int s, a;
while (cin >> s) {
if (s == 0)
break;
for (int i = 0; i < 9; i++) {
cin >> a;
s -= a;
}
cout << s << endl;
}
} | replace | 5 | 7 | 5 | 8 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int total;
cin >> total;
int a, b, c, d, e, f, g, h, i, j;
while (total != 0) {
cin >> a >> b >> c >> d >> e >> f >> g >> h >> i >> j;
j = total - (a + b + c + d + e + f + g + h + i);
cout << j << '\n';
cin >> total;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int total;
cin >> total;
int a, b, c, d, e, f, g, h, i, j;
while (total != 0) {
cin >> a >> b >> c >> d >> e >> f >> g >> h >> i;
j = total - (a + b + c + d + e + f + g + h + i);
cout << j << '\n';
cin >> total;
}
return 0;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
int main() {
while (1) {
int n;
scanf("%d", &n);
for (int i = 0; i < 9; i++) {
int c;
scanf("%d", &c);
n -= c;
}
printf("%d\n", n);
}
} | #include <cstdio>
using namespace std;
int main() {
while (1) {
int n;
scanf("%d", &n);
if (n == 0)
break;
for (int i = 0; i < 9; i++) {
int c;
scanf("%d", &c);
n -= c;
}
printf("%d\n", n);
}
} | insert | 6 | 6 | 6 | 8 | TLE | |
p00466 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int sum;
int value[9];
while (cin >> sum || sum) {
for (int i = 0; i < 9; i++) {
cin >> value[i];
sum -= value[i];
}
cout << sum << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int sum;
int value[9];
while (cin >> sum, sum) {
for (int i = 0; i < 9; i++) {
cin >> value[i];
sum -= value[i];
}
cout << sum << endl;
}
return 0;
} | replace | 8 | 9 | 8 | 9 | TLE | |
p00467 | C++ | Runtime Error | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int masu[4000], n, m, iti, f;
while (cin >> n >> m) {
if (n == 0) {
break;
}
iti = f = 1;
for (int i = 1; i <= n + m; i++) {
cin >> masu[i];
if (i > n) {
iti += masu[i];
iti += masu[iti];
if (iti >= n && f == 1) {
printf("%d\n", i - n);
f = 0;
}
}
}
}
} | #include <cstdio>
#include <iostream>
using namespace std;
int main() {
int masu[9000], n, m, iti, f;
while (cin >> n >> m) {
if (n == 0) {
break;
}
iti = f = 1;
for (int i = 1; i <= n + m; i++) {
cin >> masu[i];
if (i > n) {
iti += masu[i];
iti += masu[iti];
if (iti >= n && f == 1) {
printf("%d\n", i - n);
f = 0;
}
}
}
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00467 | C++ | Runtime Error | #include <stdio.h>
int main() {
int s[9000], n, m, t, f, i;
while (scanf("%d%d", &n, &m), n)
for (i = t = f = 1; i <= n + m | scanf("%d", &s[i]); i++) {
;
if (i > n)
if (t += s[t += s[i]], t >= n & f == 1)
printf("%d\n", i - n, f = 0);
}
} | #include <stdio.h>
int main() {
int s[9000], n, m, t, f, i;
while (scanf("%d%d", &n, &m), n)
for (i = t = f = 1; i <= n + m; i++) {
scanf("%d", &s[i]);
if (i > n)
if (t += s[t += s[i]], t >= n & f == 1)
printf("%d\n", i - n, f = 0);
}
} | replace | 4 | 6 | 4 | 6 | -11 | |
p00467 | C++ | Runtime Error | #include <iostream>
using namespace std;
#include <cstring>
int main() {
int n, m;
cin >> n >> m;
while (n != 0 && m != 0) {
int date[1024];
memset(date, 0, sizeof(date));
for (int i = 0; i < n; ++i) {
cin >> date[i];
}
int me;
int point = 0;
int ans;
bool flg = true;
for (int i = 0; i < m; ++i) {
cin >> me;
if (flg) {
point += me;
point += date[point];
if (point >= n - 1) {
ans = i + 1;
flg = false;
}
}
}
cout << ans << endl;
}
} | #include <iostream>
using namespace std;
#include <cstring>
int main() {
int n, m;
while (cin >> n >> m && n != 0 && m != 0) {
int date[1024];
memset(date, 0, sizeof(date));
for (int i = 0; i < n; ++i) {
cin >> date[i];
}
int me;
int point = 0;
int ans;
bool flg = true;
for (int i = 0; i < m; ++i) {
cin >> me;
if (flg) {
point += me;
point += date[point];
if (point >= n - 1) {
ans = i + 1;
flg = false;
}
}
}
cout << ans << endl;
}
} | replace | 6 | 8 | 6 | 8 | TLE | |
p00467 | C++ | Runtime Error | #include <bits/stdc++.h>
#define fo(i, a) for (i = 0; i < a; i++)
using namespace std;
int main(void) {
int n, m, d, i, cnt = 0, now = 0, flag = 0, x[3001] = {0};
cin >> n >> m;
while (n != 0 && m != 0) {
fo(i, n) cin >> x[i];
i = 0;
fo(i, m) {
cin >> d;
now += d + x[now + d];
if (flag == 0)
cnt++;
if (now >= n)
flag = 1;
}
cout << cnt << endl;
cnt = 0;
now = 0;
flag = 0;
cin >> n >> m;
}
return 0;
} | #include <bits/stdc++.h>
#define fo(i, a) for (i = 0; i < a; i++)
using namespace std;
int main(void) {
int n, m, d, i, cnt = 0, now = 0, flag = 0, x[3001] = {0};
cin >> n >> m;
while (n != 0 && m != 0) {
fo(i, n) cin >> x[i];
i = 0;
fo(i, m) {
cin >> d;
now += d + x[now + d];
now = now > 1000 ? 1000 : now;
if (flag == 0)
cnt++;
if (now >= n)
flag = 1;
}
cout << cnt << endl;
cnt = 0;
now = 0;
flag = 0;
cin >> n >> m;
}
return 0;
} | insert | 13 | 13 | 13 | 16 | 0 | |
p00467 | C++ | Runtime Error | #include <stdio.h>
int main() {
int n, m, l[1024] = {0}, i, x, p, a;
while (1) {
scanf("%d%d", &n, &m);
p = 0;
a = 0;
if (n == 0 && m == 0) {
break;
}
for (i = 0; i < 1024; i++) {
l[i] = 0;
}
for (i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &x);
p += x + l[p + x];
if (p >= n - 1 && a == 0) {
a = i + 1;
}
}
printf("%d\n", a);
}
return 0;
} | #include <stdio.h>
int main() {
int n, m, l[10000], i, x, p, a;
while (1) {
scanf("%d%d", &n, &m);
p = 0;
a = 0;
if (n == 0 && m == 0) {
break;
}
for (i = 0; i < 1024; i++) {
l[i] = 0;
}
for (i = 0; i < n; i++) {
scanf("%d", &l[i]);
}
for (i = 0; i < m; i++) {
scanf("%d", &x);
p += x + l[p + x];
if (p >= n - 1 && a == 0) {
a = i + 1;
}
}
printf("%d\n", a);
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00467 | C++ | Runtime Error | #include <iostream>
using namespace std;
int t[2000], n, m, a, ans, pos;
void init() {
for (int i = 0; i < 2000; i++)
t[i] = 0;
}
int main() {
while (cin >> n >> m && n && m) {
init();
for (int i = 0; i < n; i++)
cin >> t[i];
ans = -1, pos = 0;
for (int i = 0; i < m; i++) {
cin >> a;
pos += a;
if (pos >= n - 1 && ans == -1)
ans = i + 1;
pos += t[pos];
if (pos >= n - 1 && ans == -1)
ans = i + 1;
}
cout << ans << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int t[2000], n, m, a, ans, pos;
void init() {
for (int i = 0; i < 2000; i++)
t[i] = 0;
}
int main() {
while (cin >> n >> m && n && m) {
init();
for (int i = 0; i < n; i++)
cin >> t[i];
ans = -1, pos = 0;
for (int i = 0; i < m; i++) {
cin >> a;
if (ans == -1) {
pos += a;
if (pos >= n - 1 && ans == -1)
ans = i + 1;
pos += t[pos];
if (pos >= n - 1 && ans == -1)
ans = i + 1;
}
}
cout << ans << endl;
}
return 0;
} | replace | 15 | 21 | 15 | 23 | 0 | |
p00467 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int n, m;
while (1) {
scanf("%d %d", &n, &m);
if (n == 0 && m == 0)
break;
int mas[n], me[m];
for (int i = 0; i < n; i++)
scanf("%d", &mas[i]);
for (int i = 0; i < m; i++)
scanf("%d", &me[i]);
int pos = 1, step = 0;
while (pos < n) {
pos = max(0, me[step] + mas[pos + me[step]]);
step++;
}
printf("%d\n", step);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
using namespace std;
int main(void) {
int n, m;
while (1) {
scanf("%d %d", &n, &m);
if (n == 0 && m == 0)
break;
int mas[n], me[m];
for (int i = 0; i < n; i++)
scanf("%d", &mas[i]);
for (int i = 0; i < m; i++)
scanf("%d", &me[i]);
int pos = 1, step = 0;
while (pos < n) {
pos = max(1, pos + me[step] + mas[pos + me[step] - 1]);
step++;
}
printf("%d\n", step);
}
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p00467 | C++ | Runtime Error | #include <iostream>
using namespace std;
#define MAX 1000
int main() {
int n, m;
int ms[MAX + 1];
while (true) {
cin >> n >> m;
if (!n && !m)
break;
for (int i = 0; i < n; i++)
cin >> ms[i];
int go, t = 0, cnt = 0;
bool flg = false;
for (int i = 0; i < m; i++) {
cin >> go;
if (!flg) {
t += go;
t += ms[t];
cnt++;
if (t >= n - 1)
flg = true;
}
}
cout << cnt << endl;
}
return 0;
} | #include <iostream>
using namespace std;
#define MAX 2000
int main() {
int n, m;
int ms[MAX + 1];
while (true) {
cin >> n >> m;
if (!n && !m)
break;
for (int i = 0; i < n; i++)
cin >> ms[i];
int go, t = 0, cnt = 0;
bool flg = false;
for (int i = 0; i < m; i++) {
cin >> go;
if (!flg) {
t += go;
t += ms[t];
cnt++;
if (t >= n - 1)
flg = true;
}
}
cout << cnt << endl;
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00467 | C++ | Runtime Error | #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) range(i, 0, b)
#define pb(a) push_back(a)
#define all(a) (a).begin(), (a).end()
#define debug(x) cout << "debug " << x << endl;
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n || m) {
int ans = -1, x = 0, face[1005];
rep(i, n) cin >> face[i];
rep(j, m) {
int inp;
cin >> inp;
x += inp;
x += face[x];
if (x >= n - 1 && ans == -1) {
ans = j + 1;
}
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) range(i, 0, b)
#define pb(a) push_back(a)
#define all(a) (a).begin(), (a).end()
#define debug(x) cout << "debug " << x << endl;
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n || m) {
int ans = -1, x = 0, face[1005];
rep(i, n) cin >> face[i];
rep(j, m) {
int inp;
cin >> inp;
x += inp;
x = min(x, n - 1);
x += face[x];
if (x >= n - 1 && ans == -1) {
ans = j + 1;
}
}
cout << ans << endl;
}
} | insert | 17 | 17 | 17 | 18 | -11 | |
p00467 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int pos = 0;
int n, m;
int cnt = 0;
while (cin >> n >> m, n) {
int array[n];
cnt = 0;
pos = 0;
for (int i = 0; i < n; i++) {
cin >> array[i];
}
for (int i = 0; i < m; i++) {
int tmp;
cin >> tmp;
if (pos < n) {
pos += tmp;
pos += array[pos];
cnt++;
}
}
cout << cnt << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int pos = 0;
int n, m;
int cnt = 0;
int array[n];
while (cin >> n >> m) {
if (n == 0)
break;
cnt = 0;
pos = 0;
for (int i = 0; i < n; i++) {
cin >> array[i];
}
for (int i = 0; i < m; i++) {
int tmp;
cin >> tmp;
if (pos < n) {
pos += tmp;
pos += array[pos];
cnt++;
}
}
cout << cnt << endl;
}
return 0;
} | replace | 7 | 9 | 7 | 11 | 0 | |
p00467 | C++ | Runtime Error | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int a, b;
while (cin >> a >> b) {
if (a + b == 0)
break;
int m[a], w = 0, o[b], c = 0;
r(i, a) cin >> m[i];
r(i, b) cin >> o[i];
r(i, b) {
c++;
w += o[i];
w += m[w];
if (w >= a)
break;
}
cout << c << endl;
}
} | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
int main() {
int a, b;
while (cin >> a >> b) {
if (a + b == 0)
break;
int m[1100], w = 0, o[1100], c = 0;
r(i, a) cin >> m[i];
r(i, b) cin >> o[i];
r(i, b) {
c++;
w += o[i];
w += m[w];
if (w >= a)
break;
}
cout << c << endl;
}
} | replace | 8 | 9 | 8 | 9 | 0 | |
p00467 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define mp make_pair
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cout << *i << " ";
cout << endl;
}
template <class T> void chmin(T &t, T f) {
if (t > f)
t = f;
}
template <class T> void chmax(T &t, T f) {
if (t < f)
t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
int sugoroku[1010];
int main() {
int n, m;
while (n = in(), m = in()) {
int i;
for (i = 1; i <= n; i++) {
cin >> sugoroku[i];
}
int nw = 1;
int res = -1;
for (i = 1; i <= m; i++) {
nw += in();
if (nw >= n && res == -1)
res = i;
nw += sugoroku[nw];
if (nw >= n && res == -1)
res = i;
}
cout << res << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long Int;
typedef vector<int> vint;
typedef pair<int, int> pint;
#define mp make_pair
template <class T> void pv(T a, T b) {
for (T i = a; i != b; ++i)
cout << *i << " ";
cout << endl;
}
template <class T> void chmin(T &t, T f) {
if (t > f)
t = f;
}
template <class T> void chmax(T &t, T f) {
if (t < f)
t = f;
}
int in() {
int x;
scanf("%d", &x);
return x;
}
int sugoroku[1010];
int main() {
int n, m;
while (n = in(), m = in()) {
int i;
for (i = 1; i <= n; i++) {
cin >> sugoroku[i];
}
int nw = 1;
int res = -1;
for (i = 1; i <= m; i++) {
if (res == -1) {
nw += in();
if (nw >= n && res == -1) {
res = i;
continue;
}
nw += sugoroku[nw];
if (nw >= n && res == -1)
res = i;
} else
in();
}
cout << res << endl;
}
return 0;
} | replace | 56 | 62 | 56 | 67 | 0 | |
p00467 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// common
typedef int i32;
typedef long long i64, ll;
typedef long double ld;
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, l, r) for (int i = (int)l; i < (int)(r); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// config
// #define NDEBUG
// #define INF 1<<30
// #define EPS 1e-8
// const ll MOD =100000007;
// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
#endif
template <class T> inline string toString(const vector<T> &x) {
stringstream ss;
REP(i, x.size()) {
if (i != 0)
ss << " ";
ss << x[i];
}
return ss.str();
}
template <class T> inline string toString(const vector<vector<T>> &map) {
stringstream ss;
REP(i, map.size()) {
if (i != 0)
ss << BR;
ss << toString(map[i]);
}
return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
string res;
stringstream ss;
for (auto &p : x)
ss << p.first << ":" << p.second << " ";
return ss.str();
}
string BITtoString(int bit) {
stringstream ss;
while (bit != 0) {
ss << (bit % 2);
bit /= 2;
}
string res = ss.str();
reverse(ALL(res));
return res;
}
template <typename T, typename V> inline T pmod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
#define nextInt(n) scanf("%d", &n)
#define defInt(n) \
int n; \
nextInt(n)
#define nextLong(n) scanf("%lld", &n)
#define defLong(n) \
ll n; \
nextLong(n)
#define nextDouble(n) scanf("%lf", &n)
struct UnionFind {
vector<int> par; // 親
vector<int> rank; // 木の深さ
vector<int> ss; // xの属する集合のサイズ:option
int size; // 集合の個数:option
UnionFind(int n) {
REP(i, n) par.push_back(i);
rank = vector<int>(n);
ss = vector<int>(n, 1);
size = n;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[x] = y;
ss[y] += ss[x];
} else {
par[y] = x;
ss[x] += ss[y];
}
if (rank[x] == rank[y])
rank[x]++;
size--;
}
};
namespace SpanningTree {
typedef double Cost;
struct Edge {
int from, to;
Cost cost;
Edge(int from, int to, Cost cost) : from(from), to(to), cost(cost){};
bool operator<(Edge r) const { return cost < r.cost; }
bool operator>(Edge r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
// O(E*log(V))
// verified by ACAC002 B
// http://judge.u-aizu.ac.jp/onlinejudge/creview.jsp?rid=899132&cid=ACAC002
Cost kruskal(Graph g) {
const int V = g.size();
UnionFind uf = UnionFind(V);
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
REP(u, V) for (Edge e : g[u]) que.push(e);
Cost res = 0;
while (!que.empty()) {
Edge e = que.top();
que.pop();
if (!uf.same(e.from, e.to)) {
uf.unite(e.from, e.to);
res += e.cost;
}
}
return res;
}
} // namespace SpanningTree
using namespace SpanningTree;
class Main {
public:
void run() {
// ifstream cin("in");
// ofstream cout( "out" );
while (true) {
int N, M;
nextInt(N);
nextInt(M);
if (N == 0 && M == 0)
break;
vector<int> as(N);
REP(i, N) nextInt(as[i]);
vector<int> bs(M);
REP(i, M) nextInt(bs[i]);
int pos = 0;
REP(j, M) {
pos += bs[j];
if (pos >= N - 1) {
cout << (j + 1) << endl;
break;
}
pos += as[pos];
if (pos >= N - 1) {
cout << (j + 1) << endl;
break;
}
DUMP(pos);
}
}
}
};
int main() {
cout << fixed << setprecision(13);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// common
typedef int i32;
typedef long long i64, ll;
typedef long double ld;
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define FOR(i, l, r) for (int i = (int)l; i < (int)(r); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// config
// #define NDEBUG
// #define INF 1<<30
// #define EPS 1e-8
// const ll MOD =100000007;
// debug
#ifdef NDEBUG
#define DUMP(x)
#define DUMPLN(x)
#define DEBUG(x)
#define DEBUGLN(x)
#define LINE()
#define LINELN()
#define CHECK(exp, act)
#define STOP(e)
#else
#define DUMP(x) cerr << #x << " = " << (x)
#define DUMPLN(x) DUMP(x) << endl
#define DEBUG(x) DUMP(x) << LINE() << " " << __FILE__
#define DEBUGLN(x) DEBUG(x) << endl
#define LINE() cerr << " (L" << __LINE__ << ")"
#define LINELN() LINE() << endl
#define CHECK(exp, act) \
if (exp != act) { \
DUMPLN(exp); \
DEBUGLN(act); \
}
#define STOP(e) \
CHECK(e, true); \
if (!(e)) \
exit(1);
#endif
template <class T> inline string toString(const vector<T> &x) {
stringstream ss;
REP(i, x.size()) {
if (i != 0)
ss << " ";
ss << x[i];
}
return ss.str();
}
template <class T> inline string toString(const vector<vector<T>> &map) {
stringstream ss;
REP(i, map.size()) {
if (i != 0)
ss << BR;
ss << toString(map[i]);
}
return ss.str();
}
template <class K, class V> string toString(map<K, V> &x) {
string res;
stringstream ss;
for (auto &p : x)
ss << p.first << ":" << p.second << " ";
return ss.str();
}
string BITtoString(int bit) {
stringstream ss;
while (bit != 0) {
ss << (bit % 2);
bit /= 2;
}
string res = ss.str();
reverse(ALL(res));
return res;
}
template <typename T, typename V> inline T pmod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
#define nextInt(n) scanf("%d", &n)
#define defInt(n) \
int n; \
nextInt(n)
#define nextLong(n) scanf("%lld", &n)
#define defLong(n) \
ll n; \
nextLong(n)
#define nextDouble(n) scanf("%lf", &n)
struct UnionFind {
vector<int> par; // 親
vector<int> rank; // 木の深さ
vector<int> ss; // xの属する集合のサイズ:option
int size; // 集合の個数:option
UnionFind(int n) {
REP(i, n) par.push_back(i);
rank = vector<int>(n);
ss = vector<int>(n, 1);
size = n;
}
int root(int x) {
if (par[x] == x)
return x;
return par[x] = root(par[x]);
}
bool same(int x, int y) { return root(x) == root(y); }
void unite(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
if (rank[x] < rank[y]) {
par[x] = y;
ss[y] += ss[x];
} else {
par[y] = x;
ss[x] += ss[y];
}
if (rank[x] == rank[y])
rank[x]++;
size--;
}
};
namespace SpanningTree {
typedef double Cost;
struct Edge {
int from, to;
Cost cost;
Edge(int from, int to, Cost cost) : from(from), to(to), cost(cost){};
bool operator<(Edge r) const { return cost < r.cost; }
bool operator>(Edge r) const { return cost > r.cost; }
};
typedef vector<vector<Edge>> Graph;
// O(E*log(V))
// verified by ACAC002 B
// http://judge.u-aizu.ac.jp/onlinejudge/creview.jsp?rid=899132&cid=ACAC002
Cost kruskal(Graph g) {
const int V = g.size();
UnionFind uf = UnionFind(V);
priority_queue<Edge, vector<Edge>, greater<Edge>> que;
REP(u, V) for (Edge e : g[u]) que.push(e);
Cost res = 0;
while (!que.empty()) {
Edge e = que.top();
que.pop();
if (!uf.same(e.from, e.to)) {
uf.unite(e.from, e.to);
res += e.cost;
}
}
return res;
}
} // namespace SpanningTree
using namespace SpanningTree;
class Main {
public:
void run() {
// ifstream cin("in");
// ofstream cout( "out" );
while (true) {
int N, M;
nextInt(N);
nextInt(M);
if (N == 0 && M == 0)
break;
vector<int> as(N);
REP(i, N) nextInt(as[i]);
vector<int> bs(M);
REP(i, M) nextInt(bs[i]);
int pos = 0;
REP(j, M) {
pos += bs[j];
if (pos >= N - 1) {
cout << (j + 1) << endl;
break;
}
pos += as[pos];
if (pos >= N - 1) {
cout << (j + 1) << endl;
break;
}
}
}
}
};
int main() {
cout << fixed << setprecision(13);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | delete | 216 | 217 | 216 | 216 | TLE | |
p00467 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int n, m, c, g, a[10000];
int main() {
while (true) {
cin >> n >> m;
c = 1;
g = 0;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= m; i++) {
int p;
cin >> p;
c += p;
c += a[c];
if (c >= n && g == 0) {
g = i;
}
}
cout << g << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int n, m, c, g, a[10000];
int main() {
while (true) {
cin >> n >> m;
c = 1;
g = 0;
if (n == 0 && m == 0)
break;
for (int i = 1; i <= n; i++)
cin >> a[i];
for (int i = 1; i <= m; i++) {
int p;
cin >> p;
c += p;
c += a[c];
if (c >= n && g == 0) {
g = i;
}
}
cout << g << endl;
}
return 0;
} | insert | 8 | 8 | 8 | 10 | TLE | |
p00467 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
while (1) {
int n, m;
int now = 1;
int field[110] = {0}, sai[110] = {0};
cin >> n >> m;
if (n == 0 && m == 0)
break;
for (int i = 1; i <= n; i++) {
cin >> field[i];
}
int cnt = 0;
for (int i = 1; i <= m; i++) {
cin >> sai[i];
}
for (int i = 1; i <= m; i++) {
now += sai[i];
now += field[now];
cnt++;
if (now >= n)
break;
}
cout << cnt << endl;
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int main() {
while (1) {
int n, m;
int now = 1;
int field[1010] = {0}, sai[1010] = {0};
cin >> n >> m;
if (n == 0 && m == 0)
break;
for (int i = 1; i <= n; i++) {
cin >> field[i];
}
int cnt = 0;
for (int i = 1; i <= m; i++) {
cin >> sai[i];
}
for (int i = 1; i <= m; i++) {
now += sai[i];
now += field[now];
cnt++;
if (now >= n)
break;
}
cout << cnt << endl;
}
return 0;
} | replace | 9 | 10 | 9 | 10 | TLE | |
p00467 | C++ | Runtime Error | #include <iostream>
#define MAX 2048
using namespace std;
int main() {
while (true) {
int ans = 0;
int pos = 0;
int n, m;
int sg[MAX];
scanf("%d%d", &n, &m);
if (n == 0 && m == 0)
break;
for (int i = 0; i < n; ++i) {
scanf("%d", &sg[i]);
}
bool end = false;
for (int i = 0; i < m; ++i) {
int t;
scanf("%d", &t);
pos += t;
if (!end && pos >= n) {
ans = i + 1;
end = true;
}
pos += sg[pos];
// cout << pos << endl;
if (!end && pos == n - 1) {
ans = i + 1;
end = true;
}
}
printf("%d\n", ans);
}
return 0;
} | #include <iostream>
#define MAX 2048
using namespace std;
int main() {
while (true) {
int ans = 0;
int pos = 0;
int n, m;
int sg[MAX];
scanf("%d%d", &n, &m);
if (n == 0 && m == 0)
break;
for (int i = 0; i < n; ++i) {
scanf("%d", &sg[i]);
}
bool end = false;
for (int i = 0; i < m; ++i) {
int t;
scanf("%d", &t);
pos += t;
if (pos >= n - 1) {
if (!end) {
ans = i + 1;
end = true;
}
continue;
} else {
pos += sg[pos];
if (!end && pos >= n - 1) {
ans = i + 1;
end = true;
}
}
}
printf("%d\n", ans);
}
return 0;
} | replace | 20 | 29 | 20 | 32 | 0 | |
p00467 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int N, M;
int field[2000], dice;
int main() {
while (scanf("%d %d", &N, &M), N || M) {
int now = 0;
rep(i, N) scanf("%d", &field[i]);
int ans;
bool flag = false;
rep(i, M) {
scanf("%d", &dice);
now = now + dice;
now = now + field[now];
if (now < 0)
now = 0;
if (!flag) {
if (now >= N)
flag = true;
ans = i;
}
}
printf("%d\n", ans + 1);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, j, k) for (int i = j; i < k; ++i)
#define rep(i, j) FOR(i, 0, j)
#define repr(i, j) for (int i = j; i >= 0; --i)
#define INF (1 << 30)
#define MOD 1e9 + 7
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> P;
int N, M;
int field[10000], dice;
int main() {
while (scanf("%d %d", &N, &M), N || M) {
int now = 0;
rep(i, N) scanf("%d", &field[i]);
int ans;
bool flag = false;
rep(i, M) {
scanf("%d", &dice);
now = now + dice;
now = now + field[now];
if (now < 0)
now = 0;
if (!flag) {
if (now >= N)
flag = true;
ans = i;
}
}
printf("%d\n", ans + 1);
}
return 0;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p00467 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 2147483647
#define llINF 9223372036854775807
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n + m) {
int sugoroku[n + 1000];
fill_n(sugoroku, n + 1000, 0);
for (int i = 0; i < n; i++)
cin >> sugoroku[i];
int now = 1;
int ans = -1;
int flag = true;
for (int i = 0; i < m; i++) {
int me;
cin >> me;
now = now + me + sugoroku[now + me - 1];
// cout<<now<<endl;
if (now < 0)
now = 0;
if (now >= n && flag) {
ans = i + 1;
flag = false;
}
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <queue>
#include <string>
#include <utility>
#include <vector>
#define INF 2147483647
#define llINF 9223372036854775807
#define pb push_back
#define mp make_pair
#define F first
#define S second
#define ll long long
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n + m) {
int sugoroku[n + 1000];
fill_n(sugoroku, n + 1000, 0);
for (int i = 0; i < n; i++)
cin >> sugoroku[i];
int now = 1;
int ans = -1;
int flag = true;
for (int i = 0; i < m; i++) {
int me;
cin >> me;
if (flag)
now = now + me + sugoroku[now + me - 1];
// cout<<now<<endl;
if (now < 0)
now = 0;
if (now >= n && flag) {
ans = i + 1;
flag = false;
}
}
cout << ans << endl;
}
return 0;
} | replace | 31 | 32 | 31 | 33 | 0 | |
p00467 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
while (true) {
int m = 0, n = 0, move[1000] = {}, turn = 0, flag = 0;
double masu[1000] = {};
cin >> m >> n;
if (n == 0 || m == 0)
break;
for (int i = 0; i < m; i++) {
cin >> masu[i];
}
for (int i = 0; i < n; i++) {
cin >> move[i];
}
for (int i = 0; i < n; i++) {
flag = flag + move[i];
flag = flag + masu[flag];
turn++;
if (flag == m)
break;
}
cout << turn << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
while (true) {
int m = 0, n = 0, move[1000] = {}, turn = 0, flag = 0;
double masu[1000] = {};
cin >> m >> n;
if (n == 0 || m == 0)
break;
for (int i = 0; i < m; i++) {
cin >> masu[i];
}
for (int i = 0; i < n; i++) {
cin >> move[i];
}
for (int i = 0; i < n; i++) {
flag = flag + move[i];
flag = flag + masu[flag];
turn++;
if (flag >= m)
break;
}
cout << turn << endl;
}
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p00468 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <set>
#include <string>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
int main() {
int n, m;
pair<int, int> p[512];
while (scanf("%d%d", &n, &m), n | m) {
set<int> st1, st2;
st1.insert(1);
rep(i, m) {
cin >> p[i].first >> p[i].second;
if (p[i].first == 1 || p[i].second == 1) {
st1.insert(p[i].first);
st1.insert(p[i].second);
}
}
rep(i, m) {
if (st1.find(p[i].first) != st1.end() &&
st1.find(p[i].second) == st1.end()) {
st2.insert(p[i].second);
}
if (st1.find(p[i].second) != st1.end() &&
st1.find(p[i].first) == st1.end()) {
st2.insert(p[i].first);
}
}
cout << (st1.size() - 1) + (st2.size()) << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <set>
#include <string>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
int main() {
int n, m;
pair<int, int> p[10010];
while (cin >> n >> m, n | m) {
set<int> st1, st2;
st1.insert(1);
rep(i, m) {
cin >> p[i].first >> p[i].second;
if (p[i].first == 1 || p[i].second == 1) {
st1.insert(p[i].first);
st1.insert(p[i].second);
}
}
rep(i, m) {
if (st1.find(p[i].first) != st1.end() &&
st1.find(p[i].second) == st1.end()) {
st2.insert(p[i].second);
}
if (st1.find(p[i].second) != st1.end() &&
st1.find(p[i].first) == st1.end()) {
st2.insert(p[i].first);
}
}
cout << (st1.size() - 1) + (st2.size()) << endl;
}
return 0;
} | replace | 11 | 13 | 11 | 13 | 0 | |
p00468 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
while (cin >> N >> M, N || M) {
vector<int> v[500];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
bool f[500] = {0};
for (int i = 0; i < v[0].size(); i++) {
f[v[0][i]] = 1;
for (int j = 0; j < v[i].size(); j++) {
f[v[v[0][i]][j]] = 1;
}
}
int ans = 0;
for (int i = 1; i < N; i++) {
if (f[i])
ans++;
}
cout << ans << endl;
}
} | #include <iostream>
#include <vector>
using namespace std;
int main() {
int N, M;
while (cin >> N >> M, N || M) {
vector<int> v[500];
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
v[a - 1].push_back(b - 1);
v[b - 1].push_back(a - 1);
}
bool f[500] = {0};
for (int i = 0; i < v[0].size(); i++) {
f[v[0][i]] = 1;
for (int j = 0; j < v[v[0][i]].size(); j++) {
f[v[v[0][i]][j]] = 1;
}
}
int ans = 0;
for (int i = 1; i < N; i++) {
if (f[i])
ans++;
}
cout << ans << endl;
}
} | replace | 19 | 20 | 19 | 20 | 0 | |
p00468 | C++ | Runtime Error | #include <cstdio>
constexpr int MAX_N = 500;
constexpr int MAX_M = 10000;
int N, M;
int e[MAX_N][MAX_N];
bool flag[MAX_N] = {false};
int dfs(int n = 0, int depth = 0) {
if (depth == 2) {
if (flag[n]) {
return 0;
} else {
flag[n] = true;
return 1;
}
}
int res = 0;
if (!flag[n]) {
++res;
flag[n] = true;
}
for (int i = 0; i < N; ++i) {
if (e[n][i]) {
res += dfs(i, depth + 1);
}
}
return res;
}
int main() {
while (true) {
scanf("%d%d", &N, &M);
if (N == 0 && M == 0) {
break;
}
for (int i = 0; i < N; ++i) {
flag[i] = false;
for (int j = 0; j < M; ++j) {
e[i][j] = false;
}
}
flag[0] = true;
for (int i = 0; i < M; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
e[a][b] = e[b][a] = true;
}
printf("%d\n", dfs());
}
return 0;
} | #include <cstdio>
constexpr int MAX_N = 500;
constexpr int MAX_M = 10000;
int N, M;
int e[MAX_N][MAX_N];
bool flag[MAX_N] = {false};
int dfs(int n = 0, int depth = 0) {
if (depth == 2) {
if (flag[n]) {
return 0;
} else {
flag[n] = true;
return 1;
}
}
int res = 0;
if (!flag[n]) {
++res;
flag[n] = true;
}
for (int i = 0; i < N; ++i) {
if (e[n][i]) {
res += dfs(i, depth + 1);
}
}
return res;
}
int main() {
while (true) {
scanf("%d%d", &N, &M);
if (N == 0 && M == 0) {
break;
}
for (int i = 0; i < N; ++i) {
flag[i] = false;
for (int j = 0; j < N; ++j) {
e[i][j] = false;
}
}
flag[0] = true;
for (int i = 0; i < M; ++i) {
int a, b;
scanf("%d%d", &a, &b);
--a, --b;
e[a][b] = e[b][a] = true;
}
printf("%d\n", dfs());
}
return 0;
} | replace | 43 | 44 | 43 | 44 | 0 | |
p00468 | 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" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
int main() {
while (1) {
int N, M;
cin >> N >> M;
if (!N)
break;
vector<vector<int>> edges(N);
for (int i = 0; i < N; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
vector<int> comes(N);
for (auto e : edges[0]) {
comes[e] = true;
}
vector<int> friends(N);
for (int i = 1; i < N; ++i) {
if (comes[i]) {
friends[i] = true;
for (auto e : edges[i])
friends[e] = true;
}
}
int ans = count(friends.begin() + 1, friends.end(), 1);
cout << ans << 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" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
int main() {
while (1) {
int N, M;
cin >> N >> M;
if (!N)
break;
vector<vector<int>> edges(N);
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
edges[a].push_back(b);
edges[b].push_back(a);
}
vector<int> comes(N);
for (auto e : edges[0]) {
comes[e] = true;
}
vector<int> friends(N);
for (int i = 1; i < N; ++i) {
if (comes[i]) {
friends[i] = true;
for (auto e : edges[i])
friends[e] = true;
}
}
int ans = count(friends.begin() + 1, friends.end(), 1);
cout << ans << endl;
}
return 0;
} | replace | 19 | 20 | 19 | 20 | -11 | |
p00468 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n) {
vector<vector<bool>> relation(n, vector<bool>(n));
for (int i = 0; i < n; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
relation[a][b] = relation[b][a] = true;
}
vector<bool> friends(n);
for (int i = 0; i < n; ++i) {
if (relation[0][i]) {
friends[i] = true;
for (int j = 0; j < n; ++j) {
if (relation[i][j]) {
friends[j] = true;
}
}
}
}
friends[0] = false;
cout << count(friends.begin(), friends.end(), true) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n, m;
while (cin >> n >> m, n) {
vector<vector<bool>> relation(n, vector<bool>(n));
for (int i = 0; i < m; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
relation[a][b] = relation[b][a] = true;
}
vector<bool> friends(n);
for (int i = 0; i < n; ++i) {
if (relation[0][i]) {
friends[i] = true;
for (int j = 0; j < n; ++j) {
if (relation[i][j]) {
friends[j] = true;
}
}
}
}
friends[0] = false;
cout << count(friends.begin(), friends.end(), true) << endl;
}
} | replace | 7 | 8 | 7 | 8 | -11 | |
p00469 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define INF (1 << 29)
set<string> st;
void solve(int K, int S, vector<string> &s, string str) {
if (K == 0) {
st.insert(str);
}
int N = s.size();
for (int i = 0; i < N; i++) {
if (S >> i & 1)
continue;
solve(K - 1, S | (1 << i), s, str + s[i]);
}
}
int main() {
int N, K;
while (cin >> N, N) {
vector<string> s(N);
cin >> K;
for (int i = 0; i < N; i++) {
cin >> s[i];
}
st.clear();
solve(K, 0, s, "");
cout << st.size() << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define INF (1 << 29)
set<string> st;
void solve(int K, int S, vector<string> &s, string str) {
if (K == 0) {
st.insert(str);
return;
}
int N = s.size();
for (int i = 0; i < N; i++) {
if (S >> i & 1)
continue;
solve(K - 1, S | (1 << i), s, str + s[i]);
}
}
int main() {
int N, K;
while (cin >> N, N) {
vector<string> s(N);
cin >> K;
for (int i = 0; i < N; i++) {
cin >> s[i];
}
st.clear();
solve(K, 0, s, "");
cout << st.size() << endl;
}
return 0;
} | insert | 11 | 11 | 11 | 12 | TLE | |
p00469 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int n, k;
string a[11];
set<string> all;
bool flag[11];
void solve(int num, string s) {
if (num == k) {
all.insert(s);
}
for (int i = 0; i < n; i++) {
if (flag[i])
continue;
flag[i] = true;
solve(num + 1, s + a[i]);
flag[i] = false;
}
}
int main() {
while (cin >> n >> k, n + k) {
all.clear();
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < 11; i++)
flag[i] = false;
solve(0, "");
cout << all.size() << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int n, k;
string a[11];
set<string> all;
bool flag[11];
void solve(int num, string s) {
if (num == k) {
all.insert(s);
return;
}
for (int i = 0; i < n; i++) {
if (flag[i])
continue;
flag[i] = true;
solve(num + 1, s + a[i]);
flag[i] = false;
}
}
int main() {
while (cin >> n >> k, n + k) {
all.clear();
for (int i = 0; i < n; i++) {
cin >> a[i];
}
for (int i = 0; i < 11; i++)
flag[i] = false;
solve(0, "");
cout << all.size() << endl;
}
} | insert | 11 | 11 | 11 | 12 | TLE | |
p00469 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int main() {
while (1) {
int a, b, c, x[11];
vector<int> vec;
scanf("%d", &a);
scanf("%d", &b);
for (int i = 0; i < a; i++) {
scanf("%d", &x[i]);
}
if (b == 2) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
if (x[j] >= 10) {
vec.push_back(x[i] * 100 + x[j]);
} else {
vec.push_back(x[i] * 10 + x[j]);
}
}
}
}
} else if (b == 3) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
for (int k = 0; k < a; k++) {
if (k != i) {
if (k != j) {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 10000 + x[j] * 100 + x[k]);
} else {
vec.push_back(x[i] * 1000 + x[j] * 100 + x[k]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 1000 + x[j] * 10 + x[k]);
} else {
vec.push_back(x[i] * 100 + x[j] * 10 + x[k]);
}
}
}
}
}
}
}
}
} else if (b == 4) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
for (int k = 0; k < a; k++) {
if (k != i) {
if (k != j) {
for (int h = 0; h < a; h++) {
if (h != i) {
if (h != j) {
if (h != k) {
if (x[h] >= 10) {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 1000000 + x[j] * 10000 +
x[k] * 100 + x[h]);
} else {
vec.push_back(x[i] * 100000 + x[j] * 10000 +
x[k] * 100 + x[h]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 100000 + x[j] * 1000 +
x[k] * 100 + x[h]);
} else {
vec.push_back(x[i] * 10000 + x[j] * 1000 +
x[k] * 100 + x[h]);
}
}
} else {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 100000 + x[j] * 1000 +
x[k] * 10 + x[h]);
} else {
vec.push_back(x[i] * 10000 + x[j] * 1000 +
x[k] * 10 + x[h]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 10000 + x[j] * 100 +
x[k] * 10 + x[h]);
} else {
vec.push_back(x[i] * 1000 + x[j] * 100 +
x[k] * 10 + x[h]);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
sort(vec.begin(), vec.end());
int ans = 1;
for (int i = 0; i < vec.size() - 1; i++) {
if (vec[i] != vec[i + 1]) {
ans++;
}
}
printf("%d\n", ans);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <vector>
using namespace std;
int main() {
while (1) {
int a, b, c, x[11];
vector<int> vec;
scanf("%d", &a);
scanf("%d", &b);
if (a == 0) {
break;
}
for (int i = 0; i < a; i++) {
scanf("%d", &x[i]);
}
if (b == 2) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
if (x[j] >= 10) {
vec.push_back(x[i] * 100 + x[j]);
} else {
vec.push_back(x[i] * 10 + x[j]);
}
}
}
}
} else if (b == 3) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
for (int k = 0; k < a; k++) {
if (k != i) {
if (k != j) {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 10000 + x[j] * 100 + x[k]);
} else {
vec.push_back(x[i] * 1000 + x[j] * 100 + x[k]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 1000 + x[j] * 10 + x[k]);
} else {
vec.push_back(x[i] * 100 + x[j] * 10 + x[k]);
}
}
}
}
}
}
}
}
} else if (b == 4) {
for (int i = 0; i < a; i++) {
for (int j = 0; j < a; j++) {
if (j != i) {
for (int k = 0; k < a; k++) {
if (k != i) {
if (k != j) {
for (int h = 0; h < a; h++) {
if (h != i) {
if (h != j) {
if (h != k) {
if (x[h] >= 10) {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 1000000 + x[j] * 10000 +
x[k] * 100 + x[h]);
} else {
vec.push_back(x[i] * 100000 + x[j] * 10000 +
x[k] * 100 + x[h]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 100000 + x[j] * 1000 +
x[k] * 100 + x[h]);
} else {
vec.push_back(x[i] * 10000 + x[j] * 1000 +
x[k] * 100 + x[h]);
}
}
} else {
if (x[k] >= 10) {
if (x[j] >= 10) {
vec.push_back(x[i] * 100000 + x[j] * 1000 +
x[k] * 10 + x[h]);
} else {
vec.push_back(x[i] * 10000 + x[j] * 1000 +
x[k] * 10 + x[h]);
}
} else {
if (x[j] >= 10) {
vec.push_back(x[i] * 10000 + x[j] * 100 +
x[k] * 10 + x[h]);
} else {
vec.push_back(x[i] * 1000 + x[j] * 100 +
x[k] * 10 + x[h]);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
sort(vec.begin(), vec.end());
int ans = 1;
for (int i = 0; i < vec.size() - 1; i++) {
if (vec[i] != vec[i + 1]) {
ans++;
}
}
printf("%d\n", ans);
}
return 0;
} | insert | 10 | 10 | 10 | 13 | -11 | |
p00469 | C++ | Time Limit Exceeded | #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;
template <class BidirectionalIterator>
bool next_combination(BidirectionalIterator first1, BidirectionalIterator last1,
BidirectionalIterator first2,
BidirectionalIterator last2) {
if ((first1 == last1) || (first2 == last2)) {
return false;
}
BidirectionalIterator m1 = last1;
BidirectionalIterator m2 = last2;
--m2;
while (--m1 != first1 && !(*m1 < *m2)) {
}
bool result = (m1 == first1) && !(*first1 < *m2);
if (!result) {
// ???
while (first2 != m2 && !(*m1 < *first2)) {
++first2;
}
first1 = m1;
std::iter_swap(first1, first2);
++first1;
++first2;
}
if ((first1 != last1) && (first2 != last2)) {
// ???
m1 = last1;
m2 = first2;
while ((m1 != first1) && (m2 != last2)) {
std::iter_swap(--m1, m2);
++m2;
}
// ??¢
std::reverse(first1, m1);
std::reverse(first1, last1);
std::reverse(m2, last2);
std::reverse(first2, last2);
}
return !result;
}
template <class BidirectionalIterator>
bool next_combination(BidirectionalIterator first, BidirectionalIterator middle,
BidirectionalIterator last) {
return next_combination(first, middle, middle, last);
}
int main() {
while (1) {
int N;
cin >> N;
int K;
cin >> K;
if (!N)
break;
vector<string> sts;
for (int i = 0; i < N; ++i) {
string st;
cin >> st;
sts.emplace_back(st);
}
vector<int> nums(N);
iota(nums.begin(), nums.end(), 0);
set<string> anss;
do {
string ans;
for (int i = 0; i < K; ++i) {
ans += sts[nums[i]];
}
anss.emplace(ans);
} while (next_permutation(nums.begin(), nums.end()));
cout << anss.size() << 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;
template <class BidirectionalIterator>
bool next_combination(BidirectionalIterator first1, BidirectionalIterator last1,
BidirectionalIterator first2,
BidirectionalIterator last2) {
if ((first1 == last1) || (first2 == last2)) {
return false;
}
BidirectionalIterator m1 = last1;
BidirectionalIterator m2 = last2;
--m2;
while (--m1 != first1 && !(*m1 < *m2)) {
}
bool result = (m1 == first1) && !(*first1 < *m2);
if (!result) {
// ???
while (first2 != m2 && !(*m1 < *first2)) {
++first2;
}
first1 = m1;
std::iter_swap(first1, first2);
++first1;
++first2;
}
if ((first1 != last1) && (first2 != last2)) {
// ???
m1 = last1;
m2 = first2;
while ((m1 != first1) && (m2 != last2)) {
std::iter_swap(--m1, m2);
++m2;
}
// ??¢
std::reverse(first1, m1);
std::reverse(first1, last1);
std::reverse(m2, last2);
std::reverse(first2, last2);
}
return !result;
}
template <class BidirectionalIterator>
bool next_combination(BidirectionalIterator first, BidirectionalIterator middle,
BidirectionalIterator last) {
return next_combination(first, middle, middle, last);
}
int main() {
while (1) {
int N;
cin >> N;
int K;
cin >> K;
if (!N)
break;
vector<string> sts;
for (int i = 0; i < N; ++i) {
string st;
cin >> st;
sts.emplace_back(st);
}
vector<int> nums(N);
iota(nums.begin(), nums.end(), 0);
set<string> anss;
do {
vector<int> anums(K);
iota(anums.begin(), anums.end(), 0);
do {
string ans;
for (int i = 0; i < K; ++i) {
ans += sts[nums[anums[i]]];
}
anss.emplace(ans);
} while (next_permutation(anums.begin(), anums.end()));
} while (next_combination(nums.begin(), nums.begin() + K, nums.end()));
cout << anss.size() << endl;
}
return 0;
} | replace | 73 | 80 | 73 | 83 | TLE | |
p00469 | C++ | Time Limit Exceeded | #include <cstdio>
#include <cstring>
#include <set>
using namespace std;
set<int> se;
int N, K;
int card[10];
bool used[10];
void rec(int num, int k) {
if (k == K) {
se.insert(num);
return;
}
for (int i = 0; i < N; i++) {
if (used[i] == true)
continue;
used[i] = true;
int nnum;
if (card[i] < 10)
nnum = num * 10 + card[i];
else
nnum = num * 100 + card[i];
rec(nnum, k + 1);
used[i] = false;
}
}
int main() {
while (true) {
scanf("%d%d", &N, &K);
se.clear();
for (int i = 0; i < N; i++) {
scanf("%d", card + i);
}
memset(used, false, sizeof(used));
rec(0, 0);
printf("%d\n", se.size());
}
return 0;
} | #include <cstdio>
#include <cstring>
#include <set>
using namespace std;
set<int> se;
int N, K;
int card[10];
bool used[10];
void rec(int num, int k) {
if (k == K) {
se.insert(num);
return;
}
for (int i = 0; i < N; i++) {
if (used[i] == true)
continue;
used[i] = true;
int nnum;
if (card[i] < 10)
nnum = num * 10 + card[i];
else
nnum = num * 100 + card[i];
rec(nnum, k + 1);
used[i] = false;
}
}
int main() {
while (true) {
scanf("%d%d", &N, &K);
if (N == 0 && K == 0)
break;
se.clear();
for (int i = 0; i < N; i++) {
scanf("%d", card + i);
}
memset(used, false, sizeof(used));
rec(0, 0);
printf("%d\n", se.size());
}
return 0;
} | insert | 35 | 35 | 35 | 37 | TLE | |
p00469 | C++ | Memory Limit Exceeded | #include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef _MSC_VER
#define __builtin_popcount __popcnt
#endif
int n, m;
int main() {
while (cin >> n >> m, n) {
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<set<ll>> dp(1 << n);
dp[0] = set<ll>({0});
for (int i = 1; i < 1 << n; i++) {
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
for (int k : dp[i - (1 << j)]) {
dp[i].insert(stoll(to_string(k) + to_string(a[j])));
}
}
}
}
set<ll> ret;
for (int i = 0; i < 1 << n; i++) {
if (__builtin_popcount(i) == m) {
ret.insert(dp[i].begin(), dp[i].end());
}
}
cout << ret.size() << endl;
}
return 0;
} | #include <iostream>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long ll;
#ifdef _MSC_VER
#define __builtin_popcount __popcnt
#endif
int n, m;
int main() {
while (cin >> n >> m, n) {
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
vector<set<ll>> dp(1 << n);
dp[0] = set<ll>({0});
for (int i = 1; i < 1 << n; i++) {
if (__builtin_popcount(i) > m)
continue;
for (int j = 0; j < n; j++) {
if (i & (1 << j)) {
for (int k : dp[i - (1 << j)]) {
dp[i].insert(stoll(to_string(k) + to_string(a[j])));
}
}
}
}
set<ll> ret;
for (int i = 0; i < 1 << n; i++) {
if (__builtin_popcount(i) == m) {
ret.insert(dp[i].begin(), dp[i].end());
}
}
cout << ret.size() << endl;
}
return 0;
} | insert | 21 | 21 | 21 | 23 | MLE | |
p00469 | C++ | Time Limit Exceeded | /* {{{ Shinobu kawaii */
/*
______ __ _ __
.' ____ \ [ | (_) [ |
| (___ \_| | |--. __ _ .--. .--. | |.--. __ _
_.____`. | .-. | [ | [ `.-. |/ .'`\ \| '/'`\ \[ | | |
| \____) | | | | | | | | | | || \__. || \__/ | | \_/ |,
\______.'[___]|__][___][___||__]'.__.'[__;.__.' '.__.'_/
*/
/* }}} */
#include <bits/stdc++.h>
using namespace std;
// #define int long long
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) (v).begin(), (v).end()
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (int i = (a); i >= n; --i)
#define DEP(i, n) DEPS(i, n, 0)
/* debug */
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
/* typedef */
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef pair<int, int> pii;
typedef double D;
typedef complex<D> P;
/* const */
const int INF = 999999999;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline int in() {
int x;
std::cin >> x;
return x;
}
template <typename T> void print(T x) { std::cout << x << '\n'; }
template <typename T> void print(std::vector<T> &v, string s = " ") {
REP(i, v.size()) {
if (i != 0)
std::cout << s;
std::cout << v[i];
}
std::cout << '\n';
}
/* }}} */
static int n, k;
vector<string> card;
set<string> chie;
signed main() {
while (cin >> n >> k, n || k) {
card = vector<string>(n);
REP(i, n) cin >> card[i];
sort(ALL(card));
do {
string s;
REP(i, k) s += card[i];
chie.insert(s);
} while (next_permutation(ALL(card)));
print(chie.size());
// cout << chie.size() << endl;
chie.clear();
}
return 0;
} | /* {{{ Shinobu kawaii */
/*
______ __ _ __
.' ____ \ [ | (_) [ |
| (___ \_| | |--. __ _ .--. .--. | |.--. __ _
_.____`. | .-. | [ | [ `.-. |/ .'`\ \| '/'`\ \[ | | |
| \____) | | | | | | | | | | || \__. || \__/ | | \_/ |,
\______.'[___]|__][___][___||__]'.__.'[__;.__.' '.__.'_/
*/
/* }}} */
#include <bits/stdc++.h>
using namespace std;
// #define int long long
struct Fast {
Fast() {
std::cin.tie(0);
ios::sync_with_stdio(false);
}
} fast;
/* cpp template {{{ */
/* short */
#define pb push_back
#define mp make_pair
#define Fi first
#define Se second
#define ALL(v) (v).begin(), (v).end()
#define X real()
#define Y imag()
/* REPmacro */
#define REPS(i, a, n) for (int i = (a); i < (n); ++i)
#define REP(i, n) REPS(i, 0, n)
#define RREP(i, n) REPS(i, 1, n + 1)
#define DEPS(i, a, n) for (int i = (a); i >= n; --i)
#define DEP(i, n) DEPS(i, n, 0)
/* debug */
#define debug(x) \
cerr << x << " " \
<< "(L:" << __LINE__ << ")" << '\n';
/* typedef */
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<vi> vii;
typedef vector<vii> viii;
typedef pair<int, int> pii;
typedef double D;
typedef complex<D> P;
/* const */
const int INF = 999999999;
const int MOD = 1e9 + 7;
const D EPS = 1e-9;
const int dx[] = {0, 1, 0, -1, 1, -1, 1, -1},
dy[] = {1, 0, -1, 0, 1, -1, -1, 1};
/* func */
inline bool inside(int y, int x, int H, int W) {
return y >= 0 && x >= 0 && y < H && x < W;
}
inline int in() {
int x;
std::cin >> x;
return x;
}
template <typename T> void print(T x) { std::cout << x << '\n'; }
template <typename T> void print(std::vector<T> &v, string s = " ") {
REP(i, v.size()) {
if (i != 0)
std::cout << s;
std::cout << v[i];
}
std::cout << '\n';
}
/* }}} */
static int n, k;
vector<string> card;
unordered_set<string> chie;
signed main() {
while (cin >> n >> k, n || k) {
card = vector<string>(n);
REP(i, n) cin >> card[i];
sort(ALL(card));
do {
string s;
REP(i, k) s += card[i];
chie.insert(s);
} while (next_permutation(ALL(card)));
print(chie.size());
// cout << chie.size() << endl;
chie.clear();
}
return 0;
} | replace | 86 | 87 | 86 | 87 | TLE | |
p00470 | C++ | Runtime Error | #include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int w, h;
while (cin >> w >> h) {
static int dp[111][111][4];
for (int i = 0; i < 111; i++)
for (int j = 0; j < 111; j++)
for (int k = 0; k < 4; k++)
dp[i][j][k] = 0;
for (int i = 0; i < h; i++)
dp[i][0][0] = 1;
for (int i = 0; i < w; i++)
dp[0][i][2] = 1;
for (int i = 1; i < h; i++) {
for (int j = 1; j < w; j++) {
if (i - 1 >= 0)
dp[i][j][0] += dp[i - 1][j][0] + dp[i - 1][j][1];
if (i - 1 >= 0)
dp[i][j][1] += dp[i - 1][j][2];
if (j - 1 >= 0)
dp[i][j][2] += dp[i][j - 1][2] + dp[i][j - 1][3];
if (j - 1 >= 0)
dp[i][j][3] += dp[i][j - 1][0];
for (int k = 0; k < 4; k++)
dp[i][j][k] %= 100000;
}
}
int ans = 0;
for (int i = 0; i < 4; i++)
ans += dp[h - 1][w - 1][i];
cout << ans % 100000 << endl;
}
} | #include <cstdlib>
#include <cstring>
#include <iostream>
using namespace std;
int main() {
int w, h;
while (cin >> w >> h && h | w) {
static int dp[111][111][4];
for (int i = 0; i < 111; i++)
for (int j = 0; j < 111; j++)
for (int k = 0; k < 4; k++)
dp[i][j][k] = 0;
for (int i = 0; i < h; i++)
dp[i][0][0] = 1;
for (int i = 0; i < w; i++)
dp[0][i][2] = 1;
for (int i = 1; i < h; i++) {
for (int j = 1; j < w; j++) {
if (i - 1 >= 0)
dp[i][j][0] += dp[i - 1][j][0] + dp[i - 1][j][1];
if (i - 1 >= 0)
dp[i][j][1] += dp[i - 1][j][2];
if (j - 1 >= 0)
dp[i][j][2] += dp[i][j - 1][2] + dp[i][j - 1][3];
if (j - 1 >= 0)
dp[i][j][3] += dp[i][j - 1][0];
for (int k = 0; k < 4; k++)
dp[i][j][k] %= 100000;
}
}
int ans = 0;
for (int i = 0; i < 4; i++)
ans += dp[h - 1][w - 1][i];
cout << ans % 100000 << endl;
}
} | replace | 7 | 8 | 7 | 8 | 0 | |
p00470 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
int w, h;
int dp[100][100][2][2];
int main() {
while (1) {
scanf("%d %d", &w, &h);
for (int i = 1; i < w; i++) {
dp[i][0][1][1] = 1;
}
for (int j = 1; j < h; j++) {
dp[0][j][0][0] = 1;
}
for (int i = 1; i < w; i++) {
for (int j = 1; j < h; j++) {
dp[i][j][0][0] = (dp[i][j - 1][0][0] + dp[i][j - 1][0][1]) % 100000;
dp[i][j][0][1] = dp[i][j - 1][1][1] % 100000;
dp[i][j][1][0] = dp[i - 1][j][0][0] % 100000;
dp[i][j][1][1] = (dp[i - 1][j][1][0] + dp[i - 1][j][1][1]) % 100000;
;
}
}
int ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
ans += dp[w - 1][h - 1][i][j];
ans %= 100000;
}
printf("%d\n", ans);
/*
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
printf("%d\t", dp[j][i][0][0] + dp[j][i][0][1] + dp[j][i][1][0] + dp[j][i][1][1]);
}
printf("\n");
}
*/ }
return 0;
} | #include <cstdio>
using namespace std;
int w, h;
int dp[100][100][2][2];
int main() {
while (1) {
scanf("%d %d", &w, &h);
if (w == 0 && h == 0)
break;
for (int i = 1; i < w; i++) {
dp[i][0][1][1] = 1;
}
for (int j = 1; j < h; j++) {
dp[0][j][0][0] = 1;
}
for (int i = 1; i < w; i++) {
for (int j = 1; j < h; j++) {
dp[i][j][0][0] = (dp[i][j - 1][0][0] + dp[i][j - 1][0][1]) % 100000;
dp[i][j][0][1] = dp[i][j - 1][1][1] % 100000;
dp[i][j][1][0] = dp[i - 1][j][0][0] % 100000;
dp[i][j][1][1] = (dp[i - 1][j][1][0] + dp[i - 1][j][1][1]) % 100000;
;
}
}
int ans = 0;
for (int i = 0; i < 2; i++)
for (int j = 0; j < 2; j++) {
ans += dp[w - 1][h - 1][i][j];
ans %= 100000;
}
printf("%d\n", ans);
/*
for(int i=0; i<h; i++){
for(int j=0; j<w; j++){
printf("%d\t", dp[j][i][0][0] + dp[j][i][0][1] + dp[j][i][1][0] + dp[j][i][1][1]);
}
printf("\n");
}
*/ }
return 0;
} | insert | 9 | 9 | 9 | 11 | TLE | |
p00470 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n; i >= 0; i--)
#define INF 100000005
#define MAX 100001
#define dmp make_pair
#define dpb push_back
#define P pair<int, int>
#define fi first
#define se second
using namespace std;
//__gcd(a,b), __builtin_popcount(a);
int dp[101][101][2][2];
int main() {
int w, h;
while (1) {
scanf("%d%d", &w, &h);
for (int i = 1; i <= w; i++) {
for (int j = 1; j <= h; j++) {
dp[i][j][0][0] = dp[i][j - 1][0][0] + dp[i][j - 1][1][0];
dp[i][j][0][1] = dp[i - 1][j][0][1] + dp[i - 1][j][1][1];
dp[i][j][1][0] = dp[i - 1][j][0][1];
dp[i][j][1][1] = dp[i][j - 1][0][0];
rep(x, 2) rep(y, 2) dp[i][j][x][y] = dp[i][j][x][y] % 100000;
dp[1][2][0][0] = dp[2][1][0][1] = 1;
dp[1][2][1][1] = dp[2][1][1][0] = 1;
}
}
int ans = 0;
rep(i, 2) ans += dp[w][h][0][i];
printf("%d\n", ans % 100000);
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define rep(i, n) for (int i = 0; i < n; i++)
#define rrep(i, n) for (int i = 1; i <= n; i++)
#define drep(i, n) for (int i = n; i >= 0; i--)
#define INF 100000005
#define MAX 100001
#define dmp make_pair
#define dpb push_back
#define P pair<int, int>
#define fi first
#define se second
using namespace std;
//__gcd(a,b), __builtin_popcount(a);
int dp[101][101][2][2];
int main() {
int w, h;
while (1) {
scanf("%d%d", &w, &h);
if (!w)
break;
for (int i = 1; i <= w; i++) {
for (int j = 1; j <= h; j++) {
dp[i][j][0][0] = dp[i][j - 1][0][0] + dp[i][j - 1][1][0];
dp[i][j][0][1] = dp[i - 1][j][0][1] + dp[i - 1][j][1][1];
dp[i][j][1][0] = dp[i - 1][j][0][1];
dp[i][j][1][1] = dp[i][j - 1][0][0];
rep(x, 2) rep(y, 2) dp[i][j][x][y] = dp[i][j][x][y] % 100000;
dp[1][2][0][0] = dp[2][1][0][1] = 1;
dp[1][2][1][1] = dp[2][1][1][0] = 1;
}
}
int ans = 0;
rep(i, 2) ans += dp[w][h][0][i];
printf("%d\n", ans % 100000);
}
return 0;
} | insert | 20 | 20 | 20 | 22 | TLE | |
p00470 | C++ | Runtime Error | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define LL long long
static const LL INF = 1 << 24;
static const LL LL_INF = 1 << 60;
static const int mod = 1e+5;
static const int MAX_N = 100;
int dx[] = {0, 1};
int dy[] = {1, 0};
using namespace std;
int w, h;
LL mem[MAX_N][MAX_N][2][2][2][2];
LL cal(int x, int y, int px, int py, int ppx, int ppy) {
LL res = 0;
if (mem[x][y][px][py][ppx][ppy] != 0)
return mem[x][y][px][py][ppx][ppy];
if (x >= w || y >= h)
return 0;
if (x == w - 1 && y == h - 1)
return 1;
FOR(i, 0, 1) {
if (px != ppx && py != ppy && px != dx[i] && py != dy[i])
continue;
res += cal(x + dx[i], y + dy[i], dx[i], dy[i], px, py) % mod;
}
return mem[x][y][px][py][ppx][ppy] = res % mod;
}
int main() {
while (1) {
cin >> w >> h;
memset(mem, 0, sizeof(mem));
if (w == 0 && h == 0)
break;
cout << cal(0, 0, 0, 0, 0, 0) << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define FOR(i, a, b) for (int i = a; i <= b; ++i)
#define LL long long
static const LL INF = 1 << 24;
static const LL LL_INF = 1 << 60;
static const int mod = 1e+5;
static const int MAX_N = 101;
int dx[] = {0, 1};
int dy[] = {1, 0};
using namespace std;
int w, h;
LL mem[MAX_N][MAX_N][2][2][2][2];
LL cal(int x, int y, int px, int py, int ppx, int ppy) {
LL res = 0;
if (mem[x][y][px][py][ppx][ppy] != 0)
return mem[x][y][px][py][ppx][ppy];
if (x >= w || y >= h)
return 0;
if (x == w - 1 && y == h - 1)
return 1;
FOR(i, 0, 1) {
if (px != ppx && py != ppy && px != dx[i] && py != dy[i])
continue;
res += cal(x + dx[i], y + dy[i], dx[i], dy[i], px, py) % mod;
}
return mem[x][y][px][py][ppx][ppy] = res % mod;
}
int main() {
while (1) {
cin >> w >> h;
memset(mem, 0, sizeof(mem));
if (w == 0 && h == 0)
break;
cout << cal(0, 0, 0, 0, 0, 0) << endl;
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00471 | C++ | Memory Limit Exceeded | #include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int x, y;
int sx, sy;
int N;
int hx[24], hy[24];
int fie[12][12];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
map<int, int> memo[24];
int dfs(int pos, int bit, bool done[12][12], int home) {
if (memo[pos].find(bit) != memo[pos].end())
return memo[pos][bit];
if (bit == (1 << N) - 1) {
for (int i = 0; i < 4; i++) {
int cx = hx[pos] + dx[i], cy = hy[pos] + dy[i];
while (fie[cx][cy] != -1) {
if (fie[cx][cy] == 100)
return 1;
cx += dx[i], cy += dy[i];
}
}
return 0;
}
int ans = 0;
for (int i = 0; i < 4; i++) {
int cx = hx[pos] + dx[i], cy = hy[pos] + dy[i];
while (fie[cx][cy] == -2 || fie[cx][cy] == 100 || done[cx][cy] == true) {
cx += dx[i], cy += dy[i];
}
if (fie[cx][cy] != -1) {
done[cx][cy] = true;
ans += dfs(fie[cx][cy], bit | (1 << fie[cx][cy]), done, home + 1);
done[cx][cy] = false;
}
}
if (home < 18)
memo[pos][bit] = ans;
return ans;
}
int main(void) {
while (1) {
scanf("%d%d", &x, &y);
if (x == 0 && y == 0)
break;
N = 0;
for (int i = 0; i < 24; i++) {
memo[i].clear();
}
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 12; j++) {
fie[j][i] = -1;
}
}
for (int i = 1; i <= y; i++) {
for (int j = 1; j <= x; j++) {
scanf("%d", &fie[j][i]);
if (fie[j][i] == 0) {
fie[j][i] = -2;
}
if (fie[j][i] == 2) {
fie[j][i] = 100;
sx = j;
sy = i;
}
if (fie[j][i] == 1) {
fie[j][i] = N;
hx[N] = j;
hy[N] = i;
N++;
}
}
}
hx[N] = sx, hy[N] = sy;
bool done[12][12];
memset(done, false, sizeof(done));
cout << dfs(N, 0, done, 0) << endl;
}
return 0;
} | #include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int x, y;
int sx, sy;
int N;
int hx[24], hy[24];
int fie[12][12];
int dx[4] = {0, 0, 1, -1}, dy[4] = {1, -1, 0, 0};
map<int, int> memo[24];
int dfs(int pos, int bit, bool done[12][12], int home) {
if (memo[pos].find(bit) != memo[pos].end())
return memo[pos][bit];
if (bit == (1 << N) - 1) {
for (int i = 0; i < 4; i++) {
int cx = hx[pos] + dx[i], cy = hy[pos] + dy[i];
while (fie[cx][cy] != -1) {
if (fie[cx][cy] == 100)
return 1;
cx += dx[i], cy += dy[i];
}
}
return 0;
}
int ans = 0;
for (int i = 0; i < 4; i++) {
int cx = hx[pos] + dx[i], cy = hy[pos] + dy[i];
while (fie[cx][cy] == -2 || fie[cx][cy] == 100 || done[cx][cy] == true) {
cx += dx[i], cy += dy[i];
}
if (fie[cx][cy] != -1) {
done[cx][cy] = true;
ans += dfs(fie[cx][cy], bit | (1 << fie[cx][cy]), done, home + 1);
done[cx][cy] = false;
}
}
if (home < 15)
memo[pos][bit] = ans;
return ans;
}
int main(void) {
while (1) {
scanf("%d%d", &x, &y);
if (x == 0 && y == 0)
break;
N = 0;
for (int i = 0; i < 24; i++) {
memo[i].clear();
}
for (int i = 0; i < 12; i++) {
for (int j = 0; j < 12; j++) {
fie[j][i] = -1;
}
}
for (int i = 1; i <= y; i++) {
for (int j = 1; j <= x; j++) {
scanf("%d", &fie[j][i]);
if (fie[j][i] == 0) {
fie[j][i] = -2;
}
if (fie[j][i] == 2) {
fie[j][i] = 100;
sx = j;
sy = i;
}
if (fie[j][i] == 1) {
fie[j][i] = N;
hx[N] = j;
hy[N] = i;
N++;
}
}
}
hx[N] = sx, hy[N] = sy;
bool done[12][12];
memset(done, false, sizeof(done));
cout << dfs(N, 0, done, 0) << endl;
}
return 0;
} | replace | 42 | 43 | 42 | 43 | MLE | |
p00471 | C++ | Time Limit Exceeded | #include <cstdio>
#include <map>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
struct P {
int x, y;
P() {}
P(int X, int Y) : x(X), y(Y) {}
};
map<int, int> dp[24];
int adj[24][4][23], deg[24][4], house_num;
int dfs(int id, int picked) {
if (dp[id].find(picked) != dp[id].end())
return dp[id][picked];
if (picked == (1 << (house_num + 1)) - 1) {
rep(k, 4) rep(a, deg[id][k]) if (adj[id][k][a] == house_num) return 1;
return 0;
}
int ans = 0;
rep(k, 4) rep(a, deg[id][k]) {
int next_id = adj[id][k][a];
if ((picked & (1 << next_id)) == 0) {
ans += dfs(next_id, picked | (1 << next_id));
break;
}
}
if (dp[id].size() < 1000)
dp[id][picked] = ans;
return ans;
}
int main() {
for (int n, m; scanf("%d%d", &n, &m), n;) {
int field[10][10], charch_x, charch_y, f[10][10];
house_num = 0;
rep(i, m) rep(j, n) {
scanf("%d", field[i] + j);
if (field[i][j] == 1)
f[i][j] = house_num++;
if (field[i][j] == 2)
charch_x = j, charch_y = i;
}
f[charch_y][charch_x] = house_num;
rep(i, m) rep(j, n) if (field[i][j] != 0) {
int id = f[i][j];
dp[id].clear();
rep(k, 4) {
deg[id][k] = 0;
int x = j + dx[k], y = i + dy[k];
while (0 <= y && y < m && 0 <= x && x < n) {
if (field[y][x] != 0)
adj[id][k][deg[id][k]++] = f[y][x];
x += dx[k], y += dy[k];
}
}
}
printf("%d\n", dfs(house_num, 1 << house_num));
}
return 0;
} | #include <cstdio>
#include <map>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, -1, 0, 1};
struct P {
int x, y;
P() {}
P(int X, int Y) : x(X), y(Y) {}
};
map<int, int> dp[24];
int adj[24][4][23], deg[24][4], house_num;
int dfs(int id, int picked) {
if (dp[id].find(picked) != dp[id].end())
return dp[id][picked];
if (picked == (1 << (house_num + 1)) - 1) {
rep(k, 4) rep(a, deg[id][k]) if (adj[id][k][a] == house_num) return 1;
return 0;
}
int ans = 0;
rep(k, 4) rep(a, deg[id][k]) {
int next_id = adj[id][k][a];
if ((picked & (1 << next_id)) == 0) {
ans += dfs(next_id, picked | (1 << next_id));
break;
}
}
if (dp[id].size() < 10000)
dp[id][picked] = ans;
return ans;
}
int main() {
for (int n, m; scanf("%d%d", &n, &m), n;) {
int field[10][10], charch_x, charch_y, f[10][10];
house_num = 0;
rep(i, m) rep(j, n) {
scanf("%d", field[i] + j);
if (field[i][j] == 1)
f[i][j] = house_num++;
if (field[i][j] == 2)
charch_x = j, charch_y = i;
}
f[charch_y][charch_x] = house_num;
rep(i, m) rep(j, n) if (field[i][j] != 0) {
int id = f[i][j];
dp[id].clear();
rep(k, 4) {
deg[id][k] = 0;
int x = j + dx[k], y = i + dy[k];
while (0 <= y && y < m && 0 <= x && x < n) {
if (field[y][x] != 0)
adj[id][k][deg[id][k]++] = f[y][x];
x += dx[k], y += dy[k];
}
}
}
printf("%d\n", dfs(house_num, 1 << house_num));
}
return 0;
} | replace | 35 | 36 | 35 | 36 | TLE | |
p00471 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define F first
#define S second
using namespace std;
int n, m;
int c;
int f[22][22];
typedef pair<int, int> P;
vector<P> v;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool used[33];
map<P, int> dp;
int solve(int bit, int h) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ")" << endl;
if (bit == (1 << c) - 1) {
if (v[h].F == v[0].F || v[h].S == v[0].S) {
return 1;
}
return 0;
}
if (dp.find(P(bit, h)) != dp.end()) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ") : " << dp[P(bit,h)]
// << endl;
return dp[P(bit, h)];
}
int ret = 0;
for (int i = 0; i < 4; i++) {
int nx = v[h].F + dx[i];
int ny = v[h].S + dy[i];
while (0 < nx && nx <= n && 0 < ny && ny <= m) {
if (f[nx][ny] && !used[f[nx][ny]]) {
used[f[nx][ny]] = true;
ret += solve(bit | (1 << f[nx][ny]), f[nx][ny]);
used[f[nx][ny]] = false;
break;
}
nx += dx[i];
ny += dy[i];
}
}
// cout << h << " : " << ret << endl;
if (__builtin_popcount(bit) > 15)
dp[P(bit, h)] = ret;
return ret;
}
int main(void) {
while (1) {
cin >> n >> m;
if (!n)
break;
c = 1;
v.clear();
v.push_back(P(0, 0));
memset(f, 0, sizeof(f));
memset(used, false, sizeof(used));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> f[j][i];
if (f[j][i] == 2) {
v[0].F = j;
v[0].S = i;
f[j][i] = 0;
} else if (f[j][i] == 1) {
f[j][i] = c;
v.push_back(P(j, i));
c++;
}
}
}
dp.clear();
cout << solve(1, 0) << endl;
// break;
}
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define F first
#define S second
using namespace std;
int n, m;
int c;
int f[22][22];
typedef pair<int, int> P;
vector<P> v;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool used[33];
map<P, int> dp;
int solve(int bit, int h) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ")" << endl;
if (bit == (1 << c) - 1) {
if (v[h].F == v[0].F || v[h].S == v[0].S) {
return 1;
}
return 0;
}
if (dp.find(P(bit, h)) != dp.end()) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ") : " << dp[P(bit,h)]
// << endl;
return dp[P(bit, h)];
}
int ret = 0;
for (int i = 0; i < 4; i++) {
int nx = v[h].F + dx[i];
int ny = v[h].S + dy[i];
while (0 < nx && nx <= n && 0 < ny && ny <= m) {
if (f[nx][ny] && !used[f[nx][ny]]) {
used[f[nx][ny]] = true;
ret += solve(bit | (1 << f[nx][ny]), f[nx][ny]);
used[f[nx][ny]] = false;
break;
}
nx += dx[i];
ny += dy[i];
}
}
// cout << h << " : " << ret << endl;
if (__builtin_popcount(bit) > 18)
dp[P(bit, h)] = ret;
return ret;
}
int main(void) {
while (1) {
cin >> n >> m;
if (!n)
break;
c = 1;
v.clear();
v.push_back(P(0, 0));
memset(f, 0, sizeof(f));
memset(used, false, sizeof(used));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> f[j][i];
if (f[j][i] == 2) {
v[0].F = j;
v[0].S = i;
f[j][i] = 0;
} else if (f[j][i] == 1) {
f[j][i] = c;
v.push_back(P(j, i));
c++;
}
}
}
dp.clear();
cout << solve(1, 0) << endl;
// break;
}
} | replace | 51 | 52 | 51 | 52 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <cstdio>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int px[24], py[24], kx, ky;
int num[24][4] = {0};
int H, W, N, ans;
int field[12][12] = {0};
int dx[] = {0, -1, 0, 1}, dy[] = {1, 0, -1, 0};
bool done[12][12];
map<int, int> memo[24];
int dfs(int pos, int bit) {
if (memo[pos].find(bit) != memo[pos].end())
return memo[pos][bit];
if (bit == (1 << N) - 1) {
rep(d, 4) {
int cx = px[pos] + dx[d], cy = py[pos] + dy[d];
while (field[cy][cx] != -1) {
if (field[cy][cx] == 64)
return 1;
cy += dy[d], cx += dx[d];
}
}
return 0;
}
int ans = 0;
rep(d, 4) {
int cx = px[pos] + dx[d], cy = py[pos] + dy[d];
while (field[cy][cx] == -2 || done[cy][cx] == 1 || field[cy][cx] == 64) {
cy += dy[d], cx += dx[d];
}
if (field[cy][cx] != -1) {
done[cy][cx] = 1;
ans += dfs(field[cy][cx], bit | (1 << field[cy][cx]));
done[cy][cx] = 0;
}
}
return memo[pos][bit] = ans;
}
int main() {
while (cin >> W >> H, W) {
N = ans = 0;
rep(i, 24) rep(j, 4) num[i][j] = -1;
rep(i, 12) rep(j, 12) field[i][j] = -1;
rep(i, H) rep(j, W) {
int t;
cin >> t;
switch (t) {
case 0:
field[i + 1][j + 1] = -2;
break;
case 1:
field[i + 1][j + 1] = N;
px[N] = j + 1, py[N] = i + 1;
N++;
break;
case 2:
kx = j + 1, ky = i + 1;
field[i + 1][j + 1] = 64;
break;
}
}
px[N] = kx, py[N] = ky;
rep(i, 24) memo[i].clear();
cout << dfs(N, 0) << endl;
}
} | #include <cstdio>
#include <iostream>
#include <map>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
int px[24], py[24], kx, ky;
int num[24][4] = {0};
int H, W, N, ans;
int field[12][12] = {0};
int dx[] = {0, -1, 0, 1}, dy[] = {1, 0, -1, 0};
bool done[12][12];
map<int, int> memo[24];
int dfs(int pos, int bit) {
if (memo[pos].find(bit) != memo[pos].end())
return memo[pos][bit];
if (bit == (1 << N) - 1) {
rep(d, 4) {
int cx = px[pos] + dx[d], cy = py[pos] + dy[d];
while (field[cy][cx] != -1) {
if (field[cy][cx] == 64)
return 1;
cy += dy[d], cx += dx[d];
}
}
return 0;
}
int ans = 0;
rep(d, 4) {
int cx = px[pos] + dx[d], cy = py[pos] + dy[d];
while (field[cy][cx] == -2 || done[cy][cx] == 1 || field[cy][cx] == 64) {
cy += dy[d], cx += dx[d];
}
if (field[cy][cx] != -1) {
done[cy][cx] = 1;
ans += dfs(field[cy][cx], bit | (1 << field[cy][cx]));
done[cy][cx] = 0;
}
}
if (__builtin_popcount(bit) < 15) {
return memo[pos][bit] = ans;
} else {
return ans;
}
}
int main() {
while (cin >> W >> H, W) {
N = ans = 0;
rep(i, 24) rep(j, 4) num[i][j] = -1;
rep(i, 12) rep(j, 12) field[i][j] = -1;
rep(i, H) rep(j, W) {
int t;
cin >> t;
switch (t) {
case 0:
field[i + 1][j + 1] = -2;
break;
case 1:
field[i + 1][j + 1] = N;
px[N] = j + 1, py[N] = i + 1;
N++;
break;
case 2:
kx = j + 1, ky = i + 1;
field[i + 1][j + 1] = 64;
break;
}
}
px[N] = kx, py[N] = ky;
rep(i, 24) memo[i].clear();
cout << dfs(N, 0) << endl;
}
} | replace | 44 | 45 | 44 | 49 | MLE | |
p00471 | C++ | Time Limit Exceeded | #include <stdio.h>
#include <string.h>
int map[10 + 2][10 + 2];
int housecnt;
int ans;
int cathx, cathy;
int calc(int x, int y, int depth) {
int i;
if (depth == housecnt && (cathx == x || cathy == y)) {
ans++;
return (0);
}
map[x][y] = 0;
i = 1;
while (map[x + i][y] == 0)
i++;
if (map[x + i][y] == 1) {
calc(x + i, y, depth + 1);
}
i = 1;
while (map[x - i][y] == 0)
i++;
if (map[x - i][y] == 1) {
calc(x - i, y, depth + 1);
}
i = 1;
while (map[x][y + i] == 0)
i++;
if (map[x][y + i] == 1) {
calc(x, y + i, depth + 1);
}
i = 1;
while (map[x][y - i] == 0)
i++;
if (map[x][y - i] == 1) {
calc(x, y - i, depth + 1);
}
map[x][y] = 1;
return (0);
}
int main(void) {
int w, h;
while (1) {
scanf("%d%d", &w, &h);
memset(map, -1, sizeof(map));
housecnt = ans = 0;
for (int y = 1; y <= h; y++) {
for (int x = 1; x <= w; x++) {
scanf("%d", &map[x][y]);
if (map[x][y] == 2) {
cathx = x;
cathy = y;
map[x][y] = 0;
}
if (map[x][y] == 1) {
housecnt++;
}
}
}
calc(cathx, cathy, 0);
printf("%d\n", ans);
}
return (0);
} | #include <stdio.h>
#include <string.h>
int map[10 + 2][10 + 2];
int housecnt;
int ans;
int cathx, cathy;
int calc(int x, int y, int depth) {
int i;
if (depth == housecnt && (cathx == x || cathy == y)) {
ans++;
return (0);
}
map[x][y] = 0;
i = 1;
while (map[x + i][y] == 0)
i++;
if (map[x + i][y] == 1) {
calc(x + i, y, depth + 1);
}
i = 1;
while (map[x - i][y] == 0)
i++;
if (map[x - i][y] == 1) {
calc(x - i, y, depth + 1);
}
i = 1;
while (map[x][y + i] == 0)
i++;
if (map[x][y + i] == 1) {
calc(x, y + i, depth + 1);
}
i = 1;
while (map[x][y - i] == 0)
i++;
if (map[x][y - i] == 1) {
calc(x, y - i, depth + 1);
}
map[x][y] = 1;
return (0);
}
int main(void) {
int w, h;
while (1) {
scanf("%d%d", &w, &h);
if (w == 0 && h == 0) {
break;
}
memset(map, -1, sizeof(map));
housecnt = ans = 0;
for (int y = 1; y <= h; y++) {
for (int x = 1; x <= w; x++) {
scanf("%d", &map[x][y]);
if (map[x][y] == 2) {
cathx = x;
cathy = y;
map[x][y] = 0;
}
if (map[x][y] == 1) {
housecnt++;
}
}
}
calc(cathx, cathy, 0);
printf("%d\n", ans);
}
return (0);
} | insert | 53 | 53 | 53 | 57 | TLE | |
p00471 | C++ | Memory Limit Exceeded | #include <cstdio>
#include <map>
#include <vector>
using namespace std;
typedef pair<int, int> P;
int m, n, pn, tmp;
int ans, upper;
map<int, int> dp[24];
// int dp[24][1<<18];
P pos[24];
int g[10][10];
int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
int rec(int vis, int id) {
if (dp[id].count(vis))
return dp[id][vis];
// if(__builtin_popcount(vis)>6 && dp[id][vis])return dp[id][vis];
if (!vis && !id)
return 1;
int res = 0;
int y = pos[id].first, x = pos[id].second;
for (int k = 0; k < 4; k++) {
int ty = y + dy[k], tx = x + dx[k];
for (;;) {
if (ty < 0 || tx < 0 || n <= ty || m <= tx)
break;
if (!vis && !g[ty][tx]) {
res += 1;
break;
}
if (0 < g[ty][tx]) {
int tmp = g[ty][tx] - 1;
if ((vis >> tmp) & 1) {
res += rec(vis - (1 << tmp), g[ty][tx]);
break;
}
}
ty += dy[k];
tx += dx[k];
}
}
if (__builtin_popcount(vis) > 6)
dp[id][vis] = res;
return res;
}
int main() {
while (scanf("%d%d", &m, &n), m || n) {
pn = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &tmp);
if (tmp == 1) {
g[i][j] = pn;
pos[pn] = P(i, j);
pn++;
} else if (tmp == 2) {
g[i][j] = 0;
pos[0] = P(i, j);
} else
g[i][j] = -1;
}
}
for (int i = 0; i < pn; i++)
dp[i].clear();
// for(int i=0;i<pn;i++)
// for(int j=0;j<(1<<18);j++)dp[i][j] = 0;
upper = (1 << (pn - 1));
printf("%d\n", rec(upper - 1, 0));
}
} | #include <cstdio>
#include <map>
#include <vector>
using namespace std;
typedef pair<int, int> P;
int m, n, pn, tmp;
int ans, upper;
map<int, int> dp[24];
// int dp[24][1<<18];
P pos[24];
int g[10][10];
int dy[] = {-1, 0, 1, 0}, dx[] = {0, 1, 0, -1};
int rec(int vis, int id) {
if (dp[id].count(vis))
return dp[id][vis];
// if(__builtin_popcount(vis)>6 && dp[id][vis])return dp[id][vis];
if (!vis && !id)
return 1;
int res = 0;
int y = pos[id].first, x = pos[id].second;
for (int k = 0; k < 4; k++) {
int ty = y + dy[k], tx = x + dx[k];
for (;;) {
if (ty < 0 || tx < 0 || n <= ty || m <= tx)
break;
if (!vis && !g[ty][tx]) {
res += 1;
break;
}
if (0 < g[ty][tx]) {
int tmp = g[ty][tx] - 1;
if ((vis >> tmp) & 1) {
res += rec(vis - (1 << tmp), g[ty][tx]);
break;
}
}
ty += dy[k];
tx += dx[k];
}
}
if (__builtin_popcount(vis) > 8)
dp[id][vis] = res;
return res;
}
int main() {
while (scanf("%d%d", &m, &n), m || n) {
pn = 1;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
scanf("%d", &tmp);
if (tmp == 1) {
g[i][j] = pn;
pos[pn] = P(i, j);
pn++;
} else if (tmp == 2) {
g[i][j] = 0;
pos[0] = P(i, j);
} else
g[i][j] = -1;
}
}
for (int i = 0; i < pn; i++)
dp[i].clear();
// for(int i=0;i<pn;i++)
// for(int j=0;j<(1<<18);j++)dp[i][j] = 0;
upper = (1 << (pn - 1));
printf("%d\n", rec(upper - 1, 0));
}
} | replace | 46 | 47 | 46 | 47 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) \
for (__typeof((X).begin()) it = (X).begin(); it != (X).end(); it++)
#define ite iterator
#define mp make_pair
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define sec second
#define sz(x) ((int)x.size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<int, int> pi;
typedef stringstream sst;
typedef vector<int> vi;
int m, n, a[111][111];
int h, Y[30], X[30];
int dy[] = {0, 1, 0, -1};
int dx[] = {1, 0, -1, 0};
map<int, int> M;
const int LIM = 16;
int f(int cur, int mask) {
if (__builtin_popcount(mask) <= LIM) {
if (M.find(cur << 24 | mask) != M.end())
return M[cur << 24 | mask];
}
int res = 0;
rep(d, 4) {
int y = Y[cur], x = X[cur];
while (1) {
y += dy[d];
x += dx[d];
if (y < 0 || y >= n || x < 0 || x >= m)
break;
if (a[y][x] == 0) {
if (mask == (1 << h) - 2)
res++;
}
if (a[y][x] >= 1) {
if ((mask >> a[y][x] & 1) == 0) {
res += f(a[y][x], mask | 1 << a[y][x]);
break;
}
}
}
}
if (__builtin_popcount(mask) <= LIM) {
M[cur << 24 | mask] = res;
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
while (cin >> m >> n && m) {
M.clear();
h = 1;
rep(i, n) rep(j, m) {
cin >> a[i][j];
if (a[i][j] == 0) {
a[i][j] = -1;
} else if (a[i][j] == 1) {
Y[h] = i, X[h] = j;
a[i][j] = h++;
} else {
Y[0] = i, X[0] = j;
a[i][j] = 0;
}
}
cout << f(0, 0) << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) \
for (__typeof((X).begin()) it = (X).begin(); it != (X).end(); it++)
#define ite iterator
#define mp make_pair
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define sec second
#define sz(x) ((int)x.size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<int, int> pi;
typedef stringstream sst;
typedef vector<int> vi;
int m, n, a[111][111];
int h, Y[30], X[30];
int dy[] = {0, 1, 0, -1};
int dx[] = {1, 0, -1, 0};
map<int, int> M;
const int LIM = 15;
int f(int cur, int mask) {
if (__builtin_popcount(mask) <= LIM) {
if (M.find(cur << 24 | mask) != M.end())
return M[cur << 24 | mask];
}
int res = 0;
rep(d, 4) {
int y = Y[cur], x = X[cur];
while (1) {
y += dy[d];
x += dx[d];
if (y < 0 || y >= n || x < 0 || x >= m)
break;
if (a[y][x] == 0) {
if (mask == (1 << h) - 2)
res++;
}
if (a[y][x] >= 1) {
if ((mask >> a[y][x] & 1) == 0) {
res += f(a[y][x], mask | 1 << a[y][x]);
break;
}
}
}
}
if (__builtin_popcount(mask) <= LIM) {
M[cur << 24 | mask] = res;
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
while (cin >> m >> n && m) {
M.clear();
h = 1;
rep(i, n) rep(j, m) {
cin >> a[i][j];
if (a[i][j] == 0) {
a[i][j] = -1;
} else if (a[i][j] == 1) {
Y[h] = i, X[h] = j;
a[i][j] = h++;
} else {
Y[0] = i, X[0] = j;
a[i][j] = 0;
}
}
cout << f(0, 0) << endl;
}
} | replace | 52 | 53 | 52 | 53 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
typedef pair<int, int> state;
int main() {
int n, m, field[10][10];
while (cin >> m >> n, n) {
int cnt = 0, x[25], y[25], sx, sy, res = 0;
map<state, int> ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> field[i][j];
if (field[i][j] == 2) {
field[i][j] = -1;
sx = i;
sy = j;
} else if (field[i][j] == 1) {
x[cnt] = i;
y[cnt] = j;
field[i][j] = ++cnt;
}
}
}
x[cnt] = sx;
y[cnt] = sy;
priority_queue<state, vector<state>, greater<state>> que;
que.push(state(0, cnt));
ans[state(0, cnt)] = 1;
while (!que.empty()) {
state st = que.top();
que.pop();
for (int i = 0; i < 4; i++) {
int nx = x[st.second] + dx[i], ny = y[st.second] + dy[i];
while (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (st.first == (1 << cnt) - 1) {
if (field[nx][ny] == -1) {
res += ans[st];
break;
}
} else if (field[nx][ny] > 0 &&
!(st.first >> (field[nx][ny] - 1) & 1)) {
state now =
state(st.first | (1 << (field[nx][ny] - 1)), field[nx][ny] - 1);
if (!ans[now])
que.push(now);
ans[now] += ans[st];
break;
}
nx += dx[i];
ny += dy[i];
}
}
}
cout << res << endl;
}
return 0;
} | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
typedef pair<int, int> state;
int main() {
int n, m, field[10][10];
while (cin >> m >> n, n) {
int cnt = 0, x[25], y[25], sx, sy, res = 0;
map<state, int> ans;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> field[i][j];
if (field[i][j] == 2) {
field[i][j] = -1;
sx = i;
sy = j;
} else if (field[i][j] == 1) {
x[cnt] = i;
y[cnt] = j;
field[i][j] = ++cnt;
}
}
}
x[cnt] = sx;
y[cnt] = sy;
priority_queue<state, vector<state>, greater<state>> que;
que.push(state(0, cnt));
ans[state(0, cnt)] = 1;
while (!que.empty()) {
state st = que.top();
que.pop();
for (int i = 0; i < 4; i++) {
int nx = x[st.second] + dx[i], ny = y[st.second] + dy[i];
while (nx >= 0 && nx < n && ny >= 0 && ny < m) {
if (st.first == (1 << cnt) - 1) {
if (field[nx][ny] == -1) {
res += ans[st];
break;
}
} else if (field[nx][ny] > 0 &&
!(st.first >> (field[nx][ny] - 1) & 1)) {
state now =
state(st.first | (1 << (field[nx][ny] - 1)), field[nx][ny] - 1);
if (!ans[now])
que.push(now);
ans[now] += ans[st];
break;
}
nx += dx[i];
ny += dy[i];
}
}
ans.erase(ans.find(st));
}
cout << res << endl;
}
return 0;
} | insert | 58 | 58 | 58 | 59 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <cstdlib>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
#define operation(x, y) \
{ \
if (house[y][x] >= 0 && !((visited >> house[y][x]) & 1)) { \
can_pass[y][x] = true; \
res += dfs(x, y, (visited | (1 << house[y][x]))); \
can_pass[y][x] = false; \
break; \
} \
if (!can_pass[y][x]) \
break; \
}
int w, h, num;
int sx, sy;
map<pair<short, int>, int> memo;
vector<vector<bool>> can_pass;
vector<vector<short>> house;
int dfs(int x, int y, int visited = 0) {
if (visited == (1 << num) - 1)
if (x == sx || y == sy)
return 1;
else
return 0;
if (memo.count(make_pair(house[y][x], visited)))
return memo[make_pair(house[y][x], visited)];
int res = 0;
for (int i = x + 1; i < w; ++i)
operation(i, y)
for (int i = x - 1; i >= 0; --i) operation(i, y)
for (int i = y + 1; i < h; ++i) operation(x, i)
for (int i = y - 1; i >= 0; --i) operation(x, i)
return memo[make_pair(house[y][x], visited)] = res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> w >> h, w) {
can_pass.clear();
can_pass.resize(h, vector<bool>(w, false));
house.clear();
house.resize(h, vector<short>(w, -1));
num = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
int in;
cin >> in;
if (in == 1) {
house[i][j] = num++;
}
else {
can_pass[i][j] = true;
if (in == 2) {
sx = j;
sy = i;
}
}
}
}
memo.clear();
cout << dfs(sx, sy) << endl;
}
return EXIT_SUCCESS;
} | #include <cstdlib>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
#define operation(x, y) \
{ \
if (house[y][x] >= 0 && !((visited >> house[y][x]) & 1)) { \
can_pass[y][x] = true; \
res += dfs(x, y, (visited | (1 << house[y][x]))); \
can_pass[y][x] = false; \
break; \
} \
if (!can_pass[y][x]) \
break; \
}
int w, h, num;
int sx, sy;
map<pair<short, int>, int> memo;
vector<vector<bool>> can_pass;
vector<vector<short>> house;
int dfs(int x, int y, int visited = 0) {
if (visited == (1 << num) - 1)
if (x == sx || y == sy)
return 1;
else
return 0;
if (memo.count(make_pair(house[y][x], visited)))
return memo[make_pair(house[y][x], visited)];
int res = 0;
for (int i = x + 1; i < w; ++i)
operation(i, y)
for (int i = x - 1; i >= 0; --i) operation(i, y)
for (int i = y + 1; i < h; ++i) operation(x, i)
for (int i = y - 1; i >= 0; --i) operation(x, i)
if (__builtin_popcount(visited) < 15)
memo[make_pair(house[y][x], visited)] = res;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> w >> h, w) {
can_pass.clear();
can_pass.resize(h, vector<bool>(w, false));
house.clear();
house.resize(h, vector<short>(w, -1));
num = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
int in;
cin >> in;
if (in == 1) {
house[i][j] = num++;
}
else {
can_pass[i][j] = true;
if (in == 2) {
sx = j;
sy = i;
}
}
}
}
memo.clear();
cout << dfs(sx, sy) << endl;
}
return EXIT_SUCCESS;
} | replace | 45 | 46 | 45 | 49 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define EPS 1e-8
#define DEB 0
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int w, h, sx, sy, home, last;
int field[16][16];
int num[16][16];
#if DEB
stack<int> st;
#endif
class state {
public:
int x, y, s;
state(int _x, int _y, int _s) {
x = _x;
y = _y;
s = _s;
}
bool operator<(const state &a) const {
if (x == a.x) {
if (y == a.y)
return s < a.s;
else
return y < a.y;
} else {
return x < a.x;
}
}
};
map<state, int> msi;
bool ischeck(int s) { return (((last & s)) == last); }
bool inside(int x, int y) { return (x < 0 || y < 0 || x >= w || y >= h); }
int dfs(int x, int y, int s) {
if ((1 << home) - 1 ==
s) { // ÆͳïÉßêé©Ç¤©
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = x + dx[k] * i;
int ty = y + dy[k] * i;
// if( inside(tx,ty) || field[ty][tx]==1 )break;
if (inside(tx, ty))
break;
if (field[ty][tx] == 2) {
#if DEB
printf("goal , (%d,%d) s:%d\n", x, y, s);
stack<int> tmp = st;
while (!tmp.empty()) {
printf("%d,", tmp.top());
tmp.pop();
}
puts("\n");
#endif
return 1;
}
}
}
return 0;
}
if (msi.count(state(x, y, s))) { // ùÉÊÁ½ê
return msi[state(x, y, s)];
}
if (ischeck(s)) {
return 0;
}
int ret = 0;
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = x + dx[k] * i;
int ty = y + dy[k] * i;
if (inside(tx, ty))
break;
if (field[ty][tx] == 1) {
// if( s&(1<<num[ty][tx]) ) break;
field[ty][tx] = 0;
#if DEB
st.push(num[ty][tx]);
#endif
ret += dfs(tx, ty, s | (1 << num[ty][tx]));
#if DEB
st.pop();
#endif
field[ty][tx] = 1;
break;
}
}
}
msi[state(x, y, s)] = ret;
return ret;
}
int main() {
while (scanf("%d%d", &w, &h), w | h) {
msi.clear();
memset(num, -1, sizeof(num));
home = last = 0;
rep(i, h) {
rep(j, w) {
scanf("%d", &field[i][j]);
if (field[i][j] == 2) {
sx = j;
sy = i;
}
if (field[i][j] == 1) {
num[i][j] = home;
home++;
}
}
}
// last homes
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = sx + dx[k] * i;
int ty = sy + dy[k] * i;
if (inside(tx, ty))
break;
if (field[ty][tx] == 1) {
last |= (1 << num[ty][tx]);
}
}
}
#if DEB
printf("home:%d sx,sy = %d,%d\n", home, sx, sy);
printf("last:%d\n", last);
rep(i, h) {
rep(j, w) { printf("%2d ", num[i][j]); }
puts("");
}
#endif
dfs(sx, sy, 0);
printf("%d\n", msi[state(sx, sy, 0)]);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <stack>
#include <vector>
using namespace std;
#define REP(i, a, n) for (int i = (a); i < (int)(n); i++)
#define rep(i, n) REP(i, 0, n)
#define mp make_pair
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define EPS 1e-8
#define DEB 0
const int dx[] = {0, 1, 0, -1};
const int dy[] = {-1, 0, 1, 0};
int w, h, sx, sy, home, last;
int field[16][16];
int num[16][16];
#if DEB
stack<int> st;
#endif
class state {
public:
char x, y;
int s;
state(char _x, char _y, int _s) {
x = _x;
y = _y;
s = _s;
}
bool operator<(const state &a) const {
if (x == a.x) {
if (y == a.y)
return s < a.s;
else
return y < a.y;
} else {
return x < a.x;
}
}
};
map<state, int> msi;
bool ischeck(int s) { return (((last & s)) == last); }
bool inside(int x, int y) { return (x < 0 || y < 0 || x >= w || y >= h); }
int dfs(int x, int y, int s) {
if ((1 << home) - 1 ==
s) { // ÆͳïÉßêé©Ç¤©
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = x + dx[k] * i;
int ty = y + dy[k] * i;
// if( inside(tx,ty) || field[ty][tx]==1 )break;
if (inside(tx, ty))
break;
if (field[ty][tx] == 2) {
#if DEB
printf("goal , (%d,%d) s:%d\n", x, y, s);
stack<int> tmp = st;
while (!tmp.empty()) {
printf("%d,", tmp.top());
tmp.pop();
}
puts("\n");
#endif
return 1;
}
}
}
return 0;
}
if (msi.count(state(x, y, s))) { // ùÉÊÁ½ê
return msi[state(x, y, s)];
}
if (ischeck(s)) {
return 0;
}
int ret = 0;
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = x + dx[k] * i;
int ty = y + dy[k] * i;
if (inside(tx, ty))
break;
if (field[ty][tx] == 1) {
// if( s&(1<<num[ty][tx]) ) break;
field[ty][tx] = 0;
#if DEB
st.push(num[ty][tx]);
#endif
ret += dfs(tx, ty, s | (1 << num[ty][tx]));
#if DEB
st.pop();
#endif
field[ty][tx] = 1;
break;
}
}
}
msi[state(x, y, s)] = ret;
return ret;
}
int main() {
while (scanf("%d%d", &w, &h), w | h) {
msi.clear();
memset(num, -1, sizeof(num));
home = last = 0;
rep(i, h) {
rep(j, w) {
scanf("%d", &field[i][j]);
if (field[i][j] == 2) {
sx = j;
sy = i;
}
if (field[i][j] == 1) {
num[i][j] = home;
home++;
}
}
}
// last homes
rep(k, 4) {
for (int i = 1; i < 20; i++) {
int tx = sx + dx[k] * i;
int ty = sy + dy[k] * i;
if (inside(tx, ty))
break;
if (field[ty][tx] == 1) {
last |= (1 << num[ty][tx]);
}
}
}
#if DEB
printf("home:%d sx,sy = %d,%d\n", home, sx, sy);
printf("last:%d\n", last);
rep(i, h) {
rep(j, w) { printf("%2d ", num[i][j]); }
puts("");
}
#endif
dfs(sx, sy, 0);
printf("%d\n", msi[state(sx, sy, 0)]);
}
return 0;
} | replace | 30 | 32 | 30 | 33 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define F first
#define S second
using namespace std;
int n, m;
int c;
int f[22][22];
typedef pair<int, int> P;
vector<P> v;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool used[33];
map<P, int> dp;
int solve(int bit, int h) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ")" << endl;
if (bit == (1 << c) - 1) {
if (v[h].F == v[0].F || v[h].S == v[0].S) {
return 1;
}
return 0;
}
if (dp.find(P(bit, h)) != dp.end()) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ") : " << dp[P(bit,h)]
// << endl;
return dp[P(bit, h)];
}
int ret = 0;
for (int i = 0; i < 4; i++) {
int nx = v[h].F + dx[i];
int ny = v[h].S + dy[i];
while (0 < nx && nx <= n && 0 < ny && ny <= m) {
if (f[nx][ny] && !used[f[nx][ny]]) {
used[f[nx][ny]] = true;
ret += solve(bit | (1 << f[nx][ny]), f[nx][ny]);
used[f[nx][ny]] = false;
break;
}
nx += dx[i];
ny += dy[i];
}
}
// cout << h << " : " << ret << endl;
if (__builtin_popcount(bit) < 18)
dp[P(bit, h)] = ret;
return ret;
}
int main(void) {
while (1) {
cin >> n >> m;
if (!n)
break;
c = 1;
v.clear();
v.push_back(P(0, 0));
memset(f, 0, sizeof(f));
memset(used, false, sizeof(used));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> f[j][i];
if (f[j][i] == 2) {
v[0].F = j;
v[0].S = i;
f[j][i] = 0;
} else if (f[j][i] == 1) {
f[j][i] = c;
v.push_back(P(j, i));
c++;
}
}
}
dp.clear();
cout << solve(1, 0) << endl;
// break;
}
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define F first
#define S second
using namespace std;
int n, m;
int c;
int f[22][22];
typedef pair<int, int> P;
vector<P> v;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
bool used[33];
map<P, int> dp;
int solve(int bit, int h) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ")" << endl;
if (bit == (1 << c) - 1) {
if (v[h].F == v[0].F || v[h].S == v[0].S) {
return 1;
}
return 0;
}
if (dp.find(P(bit, h)) != dp.end()) {
// cout << h << " = (" << v[h].F << "," << v[h].S << ") : " << dp[P(bit,h)]
// << endl;
return dp[P(bit, h)];
}
int ret = 0;
for (int i = 0; i < 4; i++) {
int nx = v[h].F + dx[i];
int ny = v[h].S + dy[i];
while (0 < nx && nx <= n && 0 < ny && ny <= m) {
if (f[nx][ny] && !used[f[nx][ny]]) {
used[f[nx][ny]] = true;
ret += solve(bit | (1 << f[nx][ny]), f[nx][ny]);
used[f[nx][ny]] = false;
break;
}
nx += dx[i];
ny += dy[i];
}
}
// cout << h << " : " << ret << endl;
if (__builtin_popcount(bit) < 13)
dp[P(bit, h)] = ret;
return ret;
}
int main(void) {
while (1) {
cin >> n >> m;
if (!n)
break;
c = 1;
v.clear();
v.push_back(P(0, 0));
memset(f, 0, sizeof(f));
memset(used, false, sizeof(used));
for (int i = 1; i <= m; i++) {
for (int j = 1; j <= n; j++) {
cin >> f[j][i];
if (f[j][i] == 2) {
v[0].F = j;
v[0].S = i;
f[j][i] = 0;
} else if (f[j][i] == 1) {
f[j][i] = c;
v.push_back(P(j, i));
c++;
}
}
}
dp.clear();
cout << solve(1, 0) << endl;
// break;
}
} | replace | 51 | 52 | 51 | 52 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <iostream>
#include <map>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
class range {
private:
struct Iterator {
int val;
int operator*() { return val; }
bool operator!=(Iterator &itr) { return val < itr.val; }
void operator++() { ++val; }
};
Iterator i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iterator &begin() { return i; }
Iterator &end() { return n; }
};
template <class T> T at(vector<T> v, int i) {
return v[(i % (int)v.size() + v.size()) % v.size()];
}
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
int main() {
while (true) {
int m, n;
cin >> m >> n;
if (m == 0 && n == 0)
break;
int p[n][m];
for (int i : range(n))
for (int j : range(m))
cin >> p[i][j];
vector<pair<int, int>> house;
for (int i : range(n))
for (int j : range(m))
if (p[i][j] == 1)
house.emplace_back(i, j);
int s[n][m];
for (int i : range(n))
for (int j : range(m))
s[i][j] = -1;
for (int i : range(house.size()))
s[house[i].first][house[i].second] = i;
queue<tuple<int, int, int>> que;
for (int i : range(n))
for (int j : range(m))
if (p[i][j] == 2)
que.push(make_tuple(i, j, (1 << house.size()) - 1));
int res = 0;
map<tuple<int, int, int>, int> mp;
++mp[que.front()];
while (!que.empty()) {
auto now = que.front();
que.pop();
int y = get<0>(now);
int x = get<1>(now);
int bit = get<2>(now);
// cerr << y << " " << x << " ";
// for (int i : range(7)) cerr << (bit >> i & 1);
// cerr << " " << mp[now] << endl;
for (int i : range(4)) {
int yy = y + dy[i];
int xx = x + dx[i];
while (true) {
if (yy < 0 || n <= yy)
break;
if (xx < 0 || m <= xx)
break;
if (p[yy][xx] == 1 && (bit & 1 << s[yy][xx])) {
auto t = make_tuple(yy, xx, bit ^ 1 << s[yy][xx]);
if (!mp.count(t))
que.push(t);
mp[t] += mp[now];
break;
}
if (p[yy][xx] == 2 && bit == 0)
res += mp[now];
yy += dy[i];
xx += dx[i];
}
}
}
cout << res << endl;
}
} | #include <iostream>
#include <map>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
class range {
private:
struct Iterator {
int val;
int operator*() { return val; }
bool operator!=(Iterator &itr) { return val < itr.val; }
void operator++() { ++val; }
};
Iterator i, n;
public:
range(int n) : i({0}), n({n}) {}
range(int i, int n) : i({i}), n({n}) {}
Iterator &begin() { return i; }
Iterator &end() { return n; }
};
template <class T> T at(vector<T> v, int i) {
return v[(i % (int)v.size() + v.size()) % v.size()];
}
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
int main() {
while (true) {
int m, n;
cin >> m >> n;
if (m == 0 && n == 0)
break;
int p[n][m];
for (int i : range(n))
for (int j : range(m))
cin >> p[i][j];
vector<pair<int, int>> house;
for (int i : range(n))
for (int j : range(m))
if (p[i][j] == 1)
house.emplace_back(i, j);
int s[n][m];
for (int i : range(n))
for (int j : range(m))
s[i][j] = -1;
for (int i : range(house.size()))
s[house[i].first][house[i].second] = i;
queue<tuple<int, int, int>> que;
for (int i : range(n))
for (int j : range(m))
if (p[i][j] == 2)
que.push(make_tuple(i, j, (1 << house.size()) - 1));
int res = 0;
map<tuple<int, int, int>, int> mp;
++mp[que.front()];
while (!que.empty()) {
auto now = que.front();
que.pop();
int y = get<0>(now);
int x = get<1>(now);
int bit = get<2>(now);
// cerr << y << " " << x << " ";
// for (int i : range(7)) cerr << (bit >> i & 1);
// cerr << " " << mp[now] << endl;
for (int i : range(4)) {
int yy = y + dy[i];
int xx = x + dx[i];
while (true) {
if (yy < 0 || n <= yy)
break;
if (xx < 0 || m <= xx)
break;
if (p[yy][xx] == 1 && (bit & 1 << s[yy][xx])) {
auto t = make_tuple(yy, xx, bit ^ 1 << s[yy][xx]);
if (!mp.count(t))
que.push(t);
mp[t] += mp[now];
break;
}
if (p[yy][xx] == 2 && bit == 0)
res += mp[now];
yy += dy[i];
xx += dx[i];
}
}
mp.erase(now);
}
cout << res << endl;
}
} | insert | 91 | 91 | 91 | 92 | MLE | |
p00471 | C++ | Memory Limit Exceeded | #include <cstdlib>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
#define operation(x, y) \
{ \
if (house[y][x] >= 0 && !((visited >> house[y][x]) & 1)) { \
can_pass[y][x] = true; \
res += dfs(x, y, (visited | (1 << house[y][x]))); \
can_pass[y][x] = false; \
break; \
} \
if (!can_pass[y][x]) \
break; \
}
int w, h, num;
int sx, sy;
map<pair<short, int>, int> memo;
vector<vector<bool>> can_pass;
vector<vector<short>> house;
int dfs(int x, int y, int visited = 0) {
if (visited == (1 << num) - 1)
if (x == sx || y == sy)
return 1;
else
return 0;
if (memo.count(make_pair(house[y][x], visited)))
return memo[make_pair(house[y][x], visited)];
int res = 0;
for (int i = x + 1; i < w; ++i)
operation(i, y)
for (int i = x - 1; i >= 0; --i) operation(i, y)
for (int i = y + 1; i < h; ++i) operation(x, i)
for (int i = y - 1; i >= 0; --i) operation(x, i)
if (__builtin_popcount(visited) < 20)
memo[make_pair(house[y][x], visited)] = res;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> w >> h, w) {
can_pass.clear();
can_pass.resize(h, vector<bool>(w, false));
house.clear();
house.resize(h, vector<short>(w, -1));
num = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
int in;
cin >> in;
if (in == 1) {
house[i][j] = num++;
}
else {
can_pass[i][j] = true;
if (in == 2) {
sx = j;
sy = i;
}
}
}
}
memo.clear();
cout << dfs(sx, sy) << endl;
}
return EXIT_SUCCESS;
} | #include <cstdlib>
#include <iostream>
#include <map>
#include <utility>
#include <vector>
using namespace std;
#define operation(x, y) \
{ \
if (house[y][x] >= 0 && !((visited >> house[y][x]) & 1)) { \
can_pass[y][x] = true; \
res += dfs(x, y, (visited | (1 << house[y][x]))); \
can_pass[y][x] = false; \
break; \
} \
if (!can_pass[y][x]) \
break; \
}
int w, h, num;
int sx, sy;
map<pair<short, int>, int> memo;
vector<vector<bool>> can_pass;
vector<vector<short>> house;
int dfs(int x, int y, int visited = 0) {
if (visited == (1 << num) - 1)
if (x == sx || y == sy)
return 1;
else
return 0;
if (memo.count(make_pair(house[y][x], visited)))
return memo[make_pair(house[y][x], visited)];
int res = 0;
for (int i = x + 1; i < w; ++i)
operation(i, y)
for (int i = x - 1; i >= 0; --i) operation(i, y)
for (int i = y + 1; i < h; ++i) operation(x, i)
for (int i = y - 1; i >= 0; --i) operation(x, i)
if (__builtin_popcount(visited) < 19)
memo[make_pair(house[y][x], visited)] = res;
return res;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> w >> h, w) {
can_pass.clear();
can_pass.resize(h, vector<bool>(w, false));
house.clear();
house.resize(h, vector<short>(w, -1));
num = 0;
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
int in;
cin >> in;
if (in == 1) {
house[i][j] = num++;
}
else {
can_pass[i][j] = true;
if (in == 2) {
sx = j;
sy = i;
}
}
}
}
memo.clear();
cout << dfs(sx, sy) << endl;
}
return EXIT_SUCCESS;
} | replace | 45 | 46 | 45 | 46 | MLE | |
p00472 | C++ | Runtime Error | // 57
#include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int d[10000] = {};
for (int i = 1; i < n; i++) {
cin >> d[i];
d[i] += d[i - 1];
}
int p = 0;
int s = 0;
while (m--) {
int a;
cin >> a;
s = (s + abs(d[p] - d[p + a])) % 100000;
p += a;
}
cout << s << endl;
return 0;
} | // 57
#include <cstdlib>
#include <iostream>
using namespace std;
int main() {
int n, m;
cin >> n >> m;
int d[100000] = {};
for (int i = 1; i < n; i++) {
cin >> d[i];
d[i] += d[i - 1];
}
int p = 0;
int s = 0;
while (m--) {
int a;
cin >> a;
s = (s + abs(d[p] - d[p + a])) % 100000;
p += a;
}
cout << s << endl;
return 0;
} | replace | 9 | 10 | 9 | 10 | 0 | |
p00472 | C++ | Runtime Error | #include <iostream>
const int MAX_N = 1 << 17, MOD = 100000; // ちょっと多いけど気にしないし
class SegmentTree {
public:
SegmentTree(int _n) {
n = 1;
while (n < _n)
n *= 2;
std::fill(data, data + MAX_N, 0);
}
void update(int k, int i) {
k += n - 1;
data[k] = i;
while (k > 0) {
k = (k - 1) / 2;
data[k] = (data[k * 2 + 1] + data[k * 2 + 2]) % MOD;
}
}
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return data[k];
else {
int cl = query(a, b, k * 2 + 1, l, (l + r) / 2),
cr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return (cl + cr) % MOD;
}
}
int getN() { return n; }
private:
int n, data[MAX_N];
};
int main() {
int n, m;
std::cin >> n >> m;
SegmentTree st(--n);
for (int i = 0; i < n; i++) {
int d;
std::cin >> d;
st.update(i, d);
}
int from = 0, to, res = 0;
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
to = from + a;
int lower = std::min(from, to), upper = std::max(from, to);
res = (res + st.query(lower, upper, 0, 0, st.getN())) % MOD;
from = to;
}
std::cout << res << std::endl;
} | #include <iostream>
const int MAX_N = 1 << 18,
MOD = 100000; // ちょっと多いけど気にしないし(少なかったし)
class SegmentTree {
public:
SegmentTree(int _n) {
n = 1;
while (n < _n)
n *= 2;
std::fill(data, data + MAX_N, 0);
}
void update(int k, int i) {
k += n - 1;
data[k] = i;
while (k > 0) {
k = (k - 1) / 2;
data[k] = (data[k * 2 + 1] + data[k * 2 + 2]) % MOD;
}
}
int query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return 0;
if (a <= l && r <= b)
return data[k];
else {
int cl = query(a, b, k * 2 + 1, l, (l + r) / 2),
cr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return (cl + cr) % MOD;
}
}
int getN() { return n; }
private:
int n, data[MAX_N];
};
int main() {
int n, m;
std::cin >> n >> m;
SegmentTree st(--n);
for (int i = 0; i < n; i++) {
int d;
std::cin >> d;
st.update(i, d);
}
int from = 0, to, res = 0;
for (int i = 0; i < m; i++) {
int a;
std::cin >> a;
to = from + a;
int lower = std::min(from, to), upper = std::max(from, to);
res = (res + st.query(lower, upper, 0, 0, st.getN())) % MOD;
from = to;
}
std::cout << res << std::endl;
} | replace | 2 | 3 | 2 | 4 | 0 | |
p00472 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#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 EPS 1e-10
#define MAX_N 20000
#define MAX_M 16
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;
int n, m;
int s[100001];
int a;
int main() {
cin >> n >> m;
int ans = 0;
s[1] = 0;
FOR(i, 2, n + 1) cin >> s[i];
FOR(i, 1, n + 1) s[i + 1] += s[i];
int now = 1;
REP(i, m) {
cin >> a;
ans = (ans + abs(s[now + a] - s[now])) % 100000;
now += a;
}
cout << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <functional>
#include <iomanip>
#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 EPS 1e-10
#define MAX_N 20000
#define MAX_M 16
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;
int n, m;
int s[100100];
int a;
int main() {
cin >> n >> m;
int ans = 0;
s[1] = 0;
FOR(i, 2, n + 1) cin >> s[i];
FOR(i, 1, n + 1) s[i + 1] += s[i];
int now = 1;
REP(i, m) {
cin >> a;
ans = (ans + abs(s[now + a] - s[now])) % 100000;
now += a;
}
cout << ans << endl;
} | replace | 39 | 40 | 39 | 40 | 0 | |
p00472 | C++ | Time Limit Exceeded | #include <algorithm> // require sort next_permutation count etc.
#include <cctype> // require tolower, toupper
#include <cfloat>
#include <climits> // require INT_MAX etc
#include <cmath> // require sqrt ceil floor
#include <cstdio> // require printf
#include <cstdlib> // require abs
#include <cstring> // require memset
#include <deque>
#include <fstream> // require freopen
#include <functional>
#include <iomanip> // require setw
#include <iostream>
#include <limits>
#include <map>
#include <numeric> // require accumulate
#include <queue>
#include <set>
#include <sstream> // require stringstream
#include <stack>
#include <stdint.h> // require uint64_t
#include <string>
#include <vector>
using namespace std;
const int M = 100000;
int main() {
// cut here before submit
// freopen ("testcase.traveler", "r", stdin );
int n, m;
while (cin >> n >> m && n && m) {
vector<int> d(n, 0);
for (int i = 0; i < n - 1; ++i) {
cin >> d[i];
} // end for
vector<int> a(m, 0);
for (int i = 0; i < m; ++i) {
cin >> a[i];
} // end for
int res = 0;
int curr = 0;
for (int i = 0; i < m; ++i) {
int sign = (a[i] > 0 ? 1 : -1);
int offset = (sign == 1 ? 0 : -1);
for (int j = 0; j < sign * a[i]; ++j) {
res = (res + d[curr + offset]) % M;
curr += sign;
} // end if
} // end for
cout << res << endl;
} // end loop
return 0;
} | #include <algorithm> // require sort next_permutation count etc.
#include <cctype> // require tolower, toupper
#include <cfloat>
#include <climits> // require INT_MAX etc
#include <cmath> // require sqrt ceil floor
#include <cstdio> // require printf
#include <cstdlib> // require abs
#include <cstring> // require memset
#include <deque>
#include <fstream> // require freopen
#include <functional>
#include <iomanip> // require setw
#include <iostream>
#include <limits>
#include <map>
#include <numeric> // require accumulate
#include <queue>
#include <set>
#include <sstream> // require stringstream
#include <stack>
#include <stdint.h> // require uint64_t
#include <string>
#include <vector>
using namespace std;
const int M = 100000;
int main() {
// cut here before submit
// freopen ("testcase.traveler", "r", stdin );
int n, m;
while (cin >> n >> m && n && m) {
vector<int> d(n, 0);
for (int i = 0; i < n - 1; ++i) {
cin >> d[i];
} // end for
vector<int> a(m, 0);
for (int i = 0; i < m; ++i) {
cin >> a[i];
} // end for
int res = 0;
int curr = 0;
for (int i = 0; i < m; ++i) {
// int sign = (a[i] > 0 ? 1 : -1 );
// int offset = (sign == 1 ? 0 : -1 );
int sum =
(a[i] > 0 ? accumulate(d.begin() + curr, d.begin() + curr + a[i], 0)
: accumulate(d.begin() + curr + a[i], d.begin() + curr, 0));
res = (res + sum) % M;
curr += a[i];
} // end for
cout << res << endl;
} // end loop
return 0;
} | replace | 46 | 53 | 46 | 54 | TLE | |
p00472 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
int main() {
int town[100] = {0};
int n, m;
int ans = 0;
int now = 0;
scanf("%d%d", &n, &m);
town[0] = 0;
for (int i = 1; i < n; i++) {
scanf("%d", &town[i]);
}
/*
for(int i = 0; i < n; i++)
printf("town%d:%d\n", i, town[i]);
*/
for (int i = 0; i < m; i++) {
int h;
scanf("%d", &h);
// printf("now:%d ans:%d\n", now, ans);
if (h > 0) {
for (int j = 0; j < h; j++) {
ans += town[++now];
// printf("mooov:%d\n", town[now]);
}
} else {
for (int j = 0; j < -h; j++) {
ans += town[now--];
// printf("mooov:%d\n", town[now]);
}
}
ans %= 100000;
}
printf("%d\n", ans);
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
int main() {
int town[1000000] = {0};
int n, m;
int ans = 0;
int now = 0;
scanf("%d%d", &n, &m);
town[0] = 0;
for (int i = 1; i < n; i++) {
scanf("%d", &town[i]);
}
/*
for(int i = 0; i < n; i++)
printf("town%d:%d\n", i, town[i]);
*/
for (int i = 0; i < m; i++) {
int h;
scanf("%d", &h);
// printf("now:%d ans:%d\n", now, ans);
if (h > 0) {
for (int j = 0; j < h; j++) {
ans += town[++now];
// printf("mooov:%d\n", town[now]);
}
} else {
for (int j = 0; j < -h; j++) {
ans += town[now--];
// printf("mooov:%d\n", town[now]);
}
}
ans %= 100000;
}
printf("%d\n", ans);
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00472 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m;
for (; cin >> n >> m, n;) {
long long int map[n + 2];
long long int sum = 0;
map[1] = 0;
for (int i = 2; i <= n; i++) {
int tmp;
cin >> tmp;
sum += tmp;
map[i] = sum;
// cout<<"map["<<i<<"]="<<map[i]<<endl;
}
long long int ans = 0;
int now = 1;
for (int i = 1; i <= m; i++) {
int tmp;
cin >> tmp;
int old = now;
now += tmp;
ans += abs(map[now] - map[old]);
}
cout << ans % 100000 << endl;
}
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int n, m;
for (; cin >> n >> m;) {
long long int map[n + 2];
long long int sum = 0;
map[1] = 0;
for (int i = 2; i <= n; i++) {
int tmp;
cin >> tmp;
sum += tmp;
map[i] = sum;
// cout<<"map["<<i<<"]="<<map[i]<<endl;
}
long long int ans = 0;
int now = 1;
for (int i = 1; i <= m; i++) {
int tmp;
cin >> tmp;
int old = now;
now += tmp;
ans += abs(map[now] - map[old]);
}
cout << ans % 100000 << endl;
}
} | replace | 6 | 7 | 6 | 7 | TLE | |
p00472 | C++ | Runtime Error | #include <iostream>
using namespace std;
#define MAX_N (1 << 16)
#define N 100000
#define mod 100000
class Range {
int data[MAX_N];
int n;
public:
void init(int pn) {
n = 1;
while (n < pn)
n <<= 1;
for (int i = 0; i < 2 * n; ++i)
data[i] = 0;
}
void add(int k, int a) {
k += n - 1;
while (k) {
data[k] = (data[k] + a) % mod;
k = (k - 1) / 2;
}
data[0] = (data[0] + a) % mod;
}
int query(int a, int b, int l, int r, int k) {
if (r <= a || b <= l)
return 0;
int sum = 0;
if (a <= l && r <= b)
return data[k];
sum += query(a, b, l, (l + r) / 2, 2 * k + 1);
sum += query(a, b, (l + r) / 2, r, 2 * k + 2);
return sum % mod;
}
int sum(int a, int b) { return query(a, b, 0, n, 0); }
};
int main() {
int n, m;
Range r;
int s, a, ans = 0;
cin >> n >> m;
r.init(n - 1);
for (int i = 0; i < n - 1; ++i) {
cin >> s;
r.add(i, s);
}
int pos = 0;
for (int i = 0; i < m; ++i) {
cin >> a;
if (a > 0) {
ans = (ans + r.sum(pos, pos + a)) % mod;
} else if (a < 0) {
ans = (ans + r.sum(pos + a, pos)) % mod;
}
pos += a;
}
cout << ans << endl;
return 0;
} | #include <iostream>
using namespace std;
#define MAX_N (1 << 18)
#define N 100000
#define mod 100000
class Range {
int data[MAX_N];
int n;
public:
void init(int pn) {
n = 1;
while (n < pn)
n <<= 1;
for (int i = 0; i < 2 * n; ++i)
data[i] = 0;
}
void add(int k, int a) {
k += n - 1;
while (k) {
data[k] = (data[k] + a) % mod;
k = (k - 1) / 2;
}
data[0] = (data[0] + a) % mod;
}
int query(int a, int b, int l, int r, int k) {
if (r <= a || b <= l)
return 0;
int sum = 0;
if (a <= l && r <= b)
return data[k];
sum += query(a, b, l, (l + r) / 2, 2 * k + 1);
sum += query(a, b, (l + r) / 2, r, 2 * k + 2);
return sum % mod;
}
int sum(int a, int b) { return query(a, b, 0, n, 0); }
};
int main() {
int n, m;
Range r;
int s, a, ans = 0;
cin >> n >> m;
r.init(n - 1);
for (int i = 0; i < n - 1; ++i) {
cin >> s;
r.add(i, s);
}
int pos = 0;
for (int i = 0; i < m; ++i) {
cin >> a;
if (a > 0) {
ans = (ans + r.sum(pos, pos + a)) % mod;
} else if (a < 0) {
ans = (ans + r.sum(pos + a, pos)) % mod;
}
pos += a;
}
cout << ans << endl;
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p00473 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define mp(a, b) make_pair((a), (b))
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;
const int INF = 1 << 30;
const long long int INF_ = 1LL << 58;
const double EPS = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void Solve() {
int n, t[10000];
cin >> n;
rep(i, 0, n - 1) cin >> t[i];
static int dp[2][2][6000];
fill_n((int *)dp, 2 * 2 * 6000, INF);
dp[0][0][1] = dp[0][1][0] = 0;
rep(i, 0, n - 1) {
rep(j, 0, i + 2) {
if (j - 1 >= 0)
dp[1][0][j] = min(dp[0][0][j - 1], dp[0][1][j - 1] + t[i]);
dp[1][1][j] = min(dp[0][1][j], dp[0][0][j] + t[i]);
dump(j);
dump(dp[1][0][j]);
dump(dp[1][1][j]);
}
swap(dp[0], dp[1]);
}
cout << min(dp[0][0][n / 2], dp[0][1][n / 2]) << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
Solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define mp(a, b) make_pair((a), (b))
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
typedef long long int ll;
typedef pair<int, int> pii;
// template<typename T> using vec=std::vector<T>;
const int INF = 1 << 30;
const long long int INF_ = 1LL << 58;
const double EPS = 1e-9;
const int dx[] = {1, 0, -1, 0}, dy[] = {0, 1, 0, -1};
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void Solve() {
int n, t[10000];
cin >> n;
rep(i, 0, n - 1) cin >> t[i];
static int dp[2][2][6000];
fill_n((int *)dp, 2 * 2 * 6000, INF);
dp[0][0][1] = dp[0][1][0] = 0;
rep(i, 0, n - 1) {
rep(j, 0, n / 2 + 100) {
if (j - 1 >= 0)
dp[1][0][j] = min(dp[0][0][j - 1], dp[0][1][j - 1] + t[i]);
dp[1][1][j] = min(dp[0][1][j], dp[0][0][j] + t[i]);
dump(j);
dump(dp[1][0][j]);
dump(dp[1][1][j]);
}
swap(dp[0], dp[1]);
}
cout << min(dp[0][0][n / 2], dp[0][1][n / 2]) << endl;
}
int main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
Solve();
return 0;
} | replace | 41 | 42 | 41 | 42 | 0 | |
p00473 | C++ | Runtime Error | // Bokan ga bokka--nn!!
// Daily Lunch Special Tanoshii !!
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#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 pair<P, P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 2000000000
#define s(x) scanf("%d", &x)
#define rep(i, x) for (int i = 0; i < x; i++)
int dp[5005][2][2];
int main() {
int n;
int v[10005];
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
dp[i][j][k] = INF;
dp[1][0][0] = 0;
int cur = 0, nex = 1;
for (int i = 1; i < n; i++) {
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 2; j++)
dp[i][j][nex] = INF;
for (int j = n - 1; j >= 0; j--) {
dp[j + 1][0][nex] = min(dp[j + 1][0][nex], dp[j][0][cur]);
dp[j][1][nex] = min(dp[j][1][nex], dp[j][0][cur] + v[i]);
dp[j][1][nex] = min(dp[j][1][nex], dp[j][1][cur]);
dp[j + 1][0][nex] = min(dp[j + 1][0][nex], dp[j][1][cur] + v[i]);
}
cur = 1 - cur;
nex = 1 - nex;
}
printf("%d\n", min(dp[n / 2][0][cur], dp[n / 2][1][cur]));
} | // Bokan ga bokka--nn!!
// Daily Lunch Special Tanoshii !!
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#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 pair<P, P> P2;
typedef long long ll;
#define pu push
#define pb push_back
#define mp make_pair
#define eps 1e-7
#define INF 2000000000
#define s(x) scanf("%d", &x)
#define rep(i, x) for (int i = 0; i < x; i++)
int dp[5005][2][2];
int main() {
int n;
int v[10005];
scanf("%d", &n);
for (int i = 1; i < n; i++) {
scanf("%d", &v[i]);
}
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 2; j++)
for (int k = 0; k < 2; k++)
dp[i][j][k] = INF;
dp[1][0][0] = 0;
int cur = 0, nex = 1;
for (int i = 1; i < n; i++) {
for (int i = 0; i < 5005; i++)
for (int j = 0; j < 2; j++)
dp[i][j][nex] = INF;
for (int j = min(n / 2, i); j >= max(0, i - n / 2); j--) {
dp[j + 1][0][nex] = min(dp[j + 1][0][nex], dp[j][0][cur]);
dp[j][1][nex] = min(dp[j][1][nex], dp[j][0][cur] + v[i]);
dp[j][1][nex] = min(dp[j][1][nex], dp[j][1][cur]);
dp[j + 1][0][nex] = min(dp[j + 1][0][nex], dp[j][1][cur] + v[i]);
}
cur = 1 - cur;
nex = 1 - nex;
}
printf("%d\n", min(dp[n / 2][0][cur], dp[n / 2][1][cur]));
} | replace | 45 | 46 | 45 | 46 | 0 | |
p00473 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 2000
#define INF 2000000000
int dp[2][MAX_N]
[2]; // dp[????????????][???????????§??§A?????????????????????][??´???]
int n, a[MAX_N];
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i];
}
memset(dp, 127, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dp[0][j][0] < INF) {
dp[1][j + 1][0] = min(dp[1][j + 1][0], dp[0][j][0]);
dp[1][j + 1][1] = min(dp[1][j + 1][1], dp[0][j][0] + a[i + 1]);
}
if (dp[0][j][1] < INF) {
dp[1][j][1] = min(dp[1][j][1], dp[0][j][1]);
dp[1][j][0] = min(dp[1][j][0], dp[0][j][1] + a[i + 1]);
}
}
for (int j = 0; j <= n; j++) {
dp[0][j][0] = dp[1][j][0];
dp[0][j][1] = dp[1][j][1];
dp[1][j][0] = INF;
dp[1][j][1] = INF;
}
}
cout << min(dp[0][n / 2][0], dp[0][n / 2][1]) << endl;
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
#define MAX_N 500000
#define INF 2000000000
int dp[2][MAX_N]
[2]; // dp[????????????][???????????§??§A?????????????????????][??´???]
int n, a[MAX_N];
int main() {
cin >> n;
for (int i = 1; i < n; i++) {
cin >> a[i];
}
memset(dp, 127, sizeof(dp));
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
if (dp[0][j][0] < INF) {
dp[1][j + 1][0] = min(dp[1][j + 1][0], dp[0][j][0]);
dp[1][j + 1][1] = min(dp[1][j + 1][1], dp[0][j][0] + a[i + 1]);
}
if (dp[0][j][1] < INF) {
dp[1][j][1] = min(dp[1][j][1], dp[0][j][1]);
dp[1][j][0] = min(dp[1][j][0], dp[0][j][1] + a[i + 1]);
}
}
for (int j = 0; j <= n; j++) {
dp[0][j][0] = dp[1][j][0];
dp[0][j][1] = dp[1][j][1];
dp[1][j][0] = INF;
dp[1][j][1] = INF;
}
}
cout << min(dp[0][n / 2][0], dp[0][n / 2][1]) << endl;
return 0;
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00473 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdbi;
typedef pair<int, pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1 << 30;
const ll mod = 10000;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
// #define int long long
#define addm(X, Y) ((X) = ((X) + (Y) % mod) % mod)
int n;
int a[10000 + 5];
ll dp[2][505][2][2];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n - 1) cin >> a[i];
int cur = 1, pre = 0;
rep(i, n) {
rep(j, n / 2 + 1) rep(k, 2) rep(l, 2) dp[cur][j][k][l] = INF;
rep(j, min(n / 2 + 1, i + 2)) {
if (j == i + 1) {
dp[cur][i + 1][0][0] = 0;
dp[cur][i + 1][0][1] = a[i];
} else if (j == 0) {
dp[cur][0][1][0] = 0;
dp[cur][0][1][1] = a[i];
} else {
dp[cur][j][0][0] = min(dp[pre][j - 1][0][0], dp[pre][j - 1][1][1]);
dp[cur][j][0][1] = dp[cur][j][0][0] + a[i];
dp[cur][j][1][0] = min(dp[pre][j][0][1], dp[pre][j][1][0]);
dp[cur][j][1][1] = dp[cur][j][1][0] + a[i];
}
}
swap(cur, pre);
}
cout << min(dp[pre][n / 2][0][0], dp[pre][n / 2][1][0]) << endl;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef unsigned __int128 HASH;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<ull, ull> pullull;
typedef pair<ll, int> plli;
typedef pair<double, int> pdbi;
typedef pair<int, pii> pipii;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vi> vvi;
typedef vector<vvi> vvvi;
typedef vector<pii> vpii;
typedef vector<vector<int>> mat;
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n); i > 0; i--)
#define rrep2(i, a, b) for (int i = (a); i > b; i--)
#define pb push_back
#define fi first
#define se second
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
const ll hmod1 = 999999937;
const ll hmod2 = 1000000000 + 9;
const ll INF = 1 << 30;
const ll mod = 10000;
const int dx4[4] = {1, 0, -1, 0};
const int dy4[4] = {0, 1, 0, -1};
const int dx8[8] = {1, 1, 1, 0, 0, -1, -1, -1};
const int dy8[8] = {0, 1, -1, 1, -1, 0, 1, -1};
const double pi = 3.141592653589793;
// #define int long long
#define addm(X, Y) ((X) = ((X) + (Y) % mod) % mod)
int n;
int a[10000 + 5];
ll dp[2][5005][2][2];
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
cin >> n;
rep(i, n - 1) cin >> a[i];
int cur = 1, pre = 0;
rep(i, n) {
rep(j, n / 2 + 1) rep(k, 2) rep(l, 2) dp[cur][j][k][l] = INF;
rep(j, min(n / 2 + 1, i + 2)) {
if (j == i + 1) {
dp[cur][i + 1][0][0] = 0;
dp[cur][i + 1][0][1] = a[i];
} else if (j == 0) {
dp[cur][0][1][0] = 0;
dp[cur][0][1][1] = a[i];
} else {
dp[cur][j][0][0] = min(dp[pre][j - 1][0][0], dp[pre][j - 1][1][1]);
dp[cur][j][0][1] = dp[cur][j][0][0] + a[i];
dp[cur][j][1][0] = min(dp[pre][j][0][1], dp[pre][j][1][0]);
dp[cur][j][1][1] = dp[cur][j][1][0] + a[i];
}
}
swap(cur, pre);
}
cout << min(dp[pre][n / 2][0][0], dp[pre][n / 2][1][0]) << endl;
} | replace | 44 | 45 | 44 | 45 | 0 | |
p00474 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MP make_pair
#define X first
#define Y second
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> P;
const int INF = 1 << 29;
int N, L;
int v[10002];
int memo[10002];
int dfs(int n) {
if (memo[n])
return memo[n];
int res = L - v[n];
int wait = 0;
if (v[n] < v[n + 1])
wait = dfs(n + 1);
if (v[n] < v[n - 1])
wait = max(wait, dfs(n - 1));
return memo[n] = res + wait;
}
int main() {
cin >> N >> L;
for (int i = 1; i <= N; i++)
cin >> v[i];
int ans = 0;
for (int i = 1; i <= N; i++) {
ans = max(ans, dfs(i));
}
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) for (int i = 0; i < (n); i++)
#define MP make_pair
#define X first
#define Y second
#define all(v) v.begin(), v.end()
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef pair<int, int> P;
const int INF = 1 << 29;
int N, L;
int v[100002];
int memo[100002];
int dfs(int n) {
if (memo[n])
return memo[n];
int res = L - v[n];
int wait = 0;
if (v[n] < v[n + 1])
wait = dfs(n + 1);
if (v[n] < v[n - 1])
wait = max(wait, dfs(n - 1));
return memo[n] = res + wait;
}
int main() {
cin >> N >> L;
for (int i = 1; i <= N; i++)
cin >> v[i];
int ans = 0;
for (int i = 1; i <= N; i++) {
ans = max(ans, dfs(i));
}
cout << ans << endl;
return 0;
} | replace | 27 | 29 | 27 | 29 | 0 | |
p00474 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <string>
#include <vector>
using namespace std;
int main() {
int i, j;
int a[100002], m, n;
long long b[100002], mx = -1;
a[0] = 0;
a[100001] = 0;
cin >> n >> m;
for (i = 1; i < n + 1; i++)
cin >> a[i];
for (i = 1; i < n + 1; i = j) {
for (; i < n + 1 && (a[i - 1] > a[i] || a[i + 1] > a[i]); i++)
;
if (i != n + 1) {
b[i] = m - a[i];
for (j = i - 1; j > 0; j--) {
if (a[j - 1] > a[j]) {
b[j] = m - a[j] + (b[j - 1] > b[j + 1] ? b[j - 1] : b[j + 1]);
break;
} else
b[j] = m - a[j] + b[j + 1];
}
for (j = i + 1; j < n + 1 && a[j - 1] > a[j]; j++)
b[j] = m - a[j] + b[j - 1];
}
}
for (i = 1; i < n + 1; i++) {
if (mx < b[i])
mx = b[i];
}
cout << mx << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <list>
#include <string>
#include <vector>
using namespace std;
int main() {
int i, j;
int a[100002], m, n;
long long b[100002], mx = -1;
a[0] = 0;
a[100001] = 0;
cin >> n >> m;
for (i = 1; i < n + 1; i++)
cin >> a[i];
for (i = 1; i < n + 1; i = j) {
for (; i < n + 1 && (a[i - 1] > a[i] || a[i + 1] > a[i]); i++)
;
if (i != n + 1) {
b[i] = m - a[i];
for (j = i - 1; j > 0; j--) {
if (a[j - 1] > a[j]) {
b[j] = m - a[j] + (b[j - 1] > b[j + 1] ? b[j - 1] : b[j + 1]);
break;
} else
b[j] = m - a[j] + b[j + 1];
}
for (j = i + 1; j < n + 1 && a[j - 1] > a[j]; j++)
b[j] = m - a[j] + b[j - 1];
} else
j = i;
}
for (i = 1; i < n + 1; i++) {
if (mx < b[i])
mx = b[i];
}
cout << mx << endl;
return 0;
} | replace | 33 | 34 | 33 | 35 | TLE | |
p00474 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int turara[100000];
int dp[100000];
int N, L;
int rec(int idx) {
if (~dp[idx])
return dp[idx];
int ret = 0;
if (idx > 0 && turara[idx - 1] > turara[idx])
ret = max(ret, rec(idx - 1));
if (idx < N - 1 && turara[idx + 1] > turara[idx])
ret = max(ret, rec(idx + 1));
return ret + (L - turara[idx]);
}
int main() {
fill_n(dp, 100000, -1);
scanf("%d %d", &N, &L);
for (int i = 0; i < N; i++) {
scanf("%d", &turara[i]);
}
int ret = 0;
for (int i = 0; i < N; i++) {
ret = max(ret, rec(i));
}
printf("%d\n", ret);
} | #include <bits/stdc++.h>
using namespace std;
int turara[100000];
int dp[100000];
int N, L;
int rec(int idx) {
if (~dp[idx])
return dp[idx];
int ret = 0;
if (idx > 0 && turara[idx - 1] > turara[idx])
ret = max(ret, rec(idx - 1));
if (idx < N - 1 && turara[idx + 1] > turara[idx])
ret = max(ret, rec(idx + 1));
return dp[idx] = ret + (L - turara[idx]);
}
int main() {
fill_n(dp, 100000, -1);
scanf("%d %d", &N, &L);
for (int i = 0; i < N; i++) {
scanf("%d", &turara[i]);
}
int ret = 0;
for (int i = 0; i < N; i++) {
ret = max(ret, rec(i));
}
printf("%d\n", ret);
} | replace | 14 | 15 | 14 | 15 | TLE | |
p00474 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef pair<int, int> P;
const int MAX_N = 100005;
const int MAX_L = 500001;
int a[MAX_N];
int k[MAX_N];
multimap<int, int> mp;
ll t[MAX_N];
int n, L;
int main() {
scanf("%d%d", &n, &L);
rep(i, n) {
scanf("%d", &a[i]);
k[i] = a[i];
mp.emplace(a[i], i);
}
sort(a, a + n, greater<int>());
int id = 0;
while (id < n) {
auto p = mp.equal_range(a[id]);
auto it = p.first;
int i = 0;
while (i < mp.count(a[id])) {
int prev = it->second;
if (prev != 0 && prev != n - 1) {
if (k[prev] > k[prev - 1] && k[prev] > k[prev + 1]) {
t[prev] = L - a[id];
} else if (k[prev] < k[prev - 1] && k[prev] > k[prev + 1]) {
t[prev] = t[prev - 1] + L - a[id];
} else if (k[prev] > k[prev - 1] && k[prev] < k[prev + 1]) {
t[prev] = t[prev + 1] + L - a[id];
} else {
t[prev] = max(t[prev - 1], t[prev + 1]) + L - a[id];
}
} else if (prev == 0) {
if (k[0] > k[1]) {
t[0] = L - a[id];
} else {
t[0] = t[1] + L - a[id];
}
} else {
if (k[n - 1] > k[n - 2]) {
t[n - 1] = L - a[id];
} else {
t[n - 1] = t[n - 2] + L - a[id];
}
}
it++;
i++;
}
id += i;
}
printf("%lld\n", *max_element(t, t + n));
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define rep(i, n) for (int i = 0; i < n; ++i)
using namespace std;
typedef pair<int, int> P;
const int MAX_N = 100005;
const int MAX_L = 500001;
int a[MAX_N];
int k[MAX_N];
multimap<int, int> mp;
ll t[MAX_N];
int n, L;
int main() {
scanf("%d%d", &n, &L);
rep(i, n) {
scanf("%d", &a[i]);
k[i] = a[i];
mp.emplace(a[i], i);
}
sort(a, a + n, greater<int>());
int id = 0;
while (id < n) {
auto p = mp.equal_range(a[id]);
auto it = p.first;
int i = 0;
while (it != p.second) {
int prev = it->second;
if (prev != 0 && prev != n - 1) {
if (k[prev] > k[prev - 1] && k[prev] > k[prev + 1]) {
t[prev] = L - a[id];
} else if (k[prev] < k[prev - 1] && k[prev] > k[prev + 1]) {
t[prev] = t[prev - 1] + L - a[id];
} else if (k[prev] > k[prev - 1] && k[prev] < k[prev + 1]) {
t[prev] = t[prev + 1] + L - a[id];
} else {
t[prev] = max(t[prev - 1], t[prev + 1]) + L - a[id];
}
} else if (prev == 0) {
if (k[0] > k[1]) {
t[0] = L - a[id];
} else {
t[0] = t[1] + L - a[id];
}
} else {
if (k[n - 1] > k[n - 2]) {
t[n - 1] = L - a[id];
} else {
t[n - 1] = t[n - 2] + L - a[id];
}
}
it++;
i++;
}
id += i;
}
printf("%lld\n", *max_element(t, t + n));
return 0;
} | replace | 32 | 33 | 32 | 33 | TLE | |
p00474 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
#define PII pair<int, int>
priority_queue<PII, vector<PII>, greater<PII>> Q;
int main(void) {
int N, L;
while (scanf("%d%d", &N, &L) && N != 0) {
int a[100005] = {0};
int temp;
int ans = 0;
for (int i = 1; i <= N; i++) {
scanf("%d", &temp);
Q.push(PII(temp, i));
}
while (!Q.empty()) {
int leng = Q.top().first;
int soej = Q.top().second;
Q.pop();
int time = a[soej] + L - leng;
a[soej - 1] = max(time, a[soej - 1]);
a[soej + 1] = max(time, a[soej + 1]);
}
for (int i = 1; i <= N; i++)
ans = max(a[i], ans);
printf("%d\n", ans);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <queue>
#include <vector>
using namespace std;
#define PII pair<int, int>
priority_queue<PII, vector<PII>, greater<PII>> Q;
int main(void) {
int N, L;
while (scanf("%d%d", &N, &L) != EOF) {
int a[100005] = {0};
int temp;
int ans = 0;
for (int i = 1; i <= N; i++) {
scanf("%d", &temp);
Q.push(PII(temp, i));
}
while (!Q.empty()) {
int leng = Q.top().first;
int soej = Q.top().second;
Q.pop();
int time = a[soej] + L - leng;
a[soej - 1] = max(time, a[soej - 1]);
a[soej + 1] = max(time, a[soej + 1]);
}
for (int i = 1; i <= N; i++)
ans = max(a[i], ans);
printf("%d\n", ans);
}
return 0;
} | replace | 14 | 15 | 14 | 15 | TLE | |
p00474 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll t[510];
int main() {
int n, l;
cin >> n >> l;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
t[0] = l - a[0];
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i])
t[i] = t[i - 1] + (l - a[i]);
else
t[i] = l - a[i];
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] < a[i + 1])
t[i] = max(t[i], t[i + 1] + (l - a[i]));
}
ll ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, t[i]);
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
ll t[100010];
int main() {
int n, l;
cin >> n >> l;
int a[n];
for (int i = 0; i < n; i++)
cin >> a[i];
t[0] = l - a[0];
for (int i = 1; i < n; i++) {
if (a[i - 1] > a[i])
t[i] = t[i - 1] + (l - a[i]);
else
t[i] = l - a[i];
}
for (int i = n - 2; i >= 0; i--) {
if (a[i] < a[i + 1])
t[i] = max(t[i], t[i + 1] + (l - a[i]));
}
ll ans = 0;
for (int i = 0; i < n; i++)
ans = max(ans, t[i]);
cout << ans << endl;
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.