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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p00884 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <vector>
using namespace std;
struct Edge {
int src, dst;
Edge() {}
Edge(int s, int d) : src(s), dst(d) {}
};
typedef vector<vector<Edge>> Graph;
void dfs(const Graph &g, int v, vector<int> &flg) {
flg[v] = 1;
for (Edge e : g[v])
dfs(g, e.dst, flg);
}
int main() {
for (int n; cin >> n, n;) {
map<string, int> ntoi;
Graph g;
for (int i = 0; i < n; i++) {
string line;
cin >> line;
for (char &c : line)
if (c == ':' || c == ',' || c == '.')
c = ' ';
istringstream iss(line);
vector<int> temp;
for (string name; iss >> name;) {
if (!ntoi.count(name)) {
ntoi.insert(make_pair(name, ntoi.size()));
g.resize(g.size() + 1);
}
temp.push_back(ntoi[name]);
}
for (int i = 1; i < temp.size(); i++)
g[temp[0]].emplace_back(temp[0], temp[i]);
}
int m = g.size();
vector<int> flg(m);
dfs(g, 0, flg);
int res = 0;
for (int i = 0; i < m; i++)
if (flg[i] && g[i].size() == 0)
res++;
cout << res << endl;
}
} | #include <algorithm>
#include <iostream>
#include <map>
#include <sstream>
#include <vector>
using namespace std;
struct Edge {
int src, dst;
Edge() {}
Edge(int s, int d) : src(s), dst(d) {}
};
typedef vector<vector<Edge>> Graph;
void dfs(const Graph &g, int v, vector<int> &flg) {
if (flg[v])
return;
flg[v] = 1;
for (Edge e : g[v])
dfs(g, e.dst, flg);
}
int main() {
for (int n; cin >> n, n;) {
map<string, int> ntoi;
Graph g;
for (int i = 0; i < n; i++) {
string line;
cin >> line;
for (char &c : line)
if (c == ':' || c == ',' || c == '.')
c = ' ';
istringstream iss(line);
vector<int> temp;
for (string name; iss >> name;) {
if (!ntoi.count(name)) {
ntoi.insert(make_pair(name, ntoi.size()));
g.resize(g.size() + 1);
}
temp.push_back(ntoi[name]);
}
for (int i = 1; i < temp.size(); i++)
g[temp[0]].emplace_back(temp[0], temp[i]);
}
int m = g.size();
vector<int> flg(m);
dfs(g, 0, flg);
int res = 0;
for (int i = 0; i < m; i++)
if (flg[i] && g[i].size() == 0)
res++;
cout << res << endl;
}
} | insert | 16 | 16 | 16 | 18 | TLE | |
p00884 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
#include <set>
#include <string>
using namespace std;
set<string> S;
map<string, int> M;
int n;
string str[101];
int saiki(int ima) {
int sum = 0;
string a;
for (int i = 0; i < str[ima].size(); i++) {
if (str[ima][i] == ',') {
if (M.count(a) == 1)
S.insert(a), sum += saiki(M[a]);
else if (S.count(a) == 0)
sum++;
S.insert(a);
a = "";
continue;
}
a += str[ima][i];
}
return sum;
}
int main() {
while (1) {
cin >> n;
if (n == 0)
break;
S.clear(), M.clear();
for (int i = 0; i < n; i++) {
cin >> str[i];
string a, b;
for (int j = 0; j < str[i].size(); j++) {
if (str[i][j] == ':')
M[a] = i, a = "";
if (str[i][j] != ':')
a += str[i][j];
}
str[i] = a;
str[i][str[i].size() - 1] = ',';
}
cout << saiki(0) << endl;
;
}
return 0;
} | #include <iostream>
#include <map>
#include <set>
#include <string>
using namespace std;
set<string> S;
map<string, int> M;
int n;
string str[101];
int saiki(int ima) {
int sum = 0;
string a;
for (int i = 0; i < str[ima].size(); i++) {
if (str[ima][i] == ',') {
if (M.count(a) == 1 && S.count(a) == 0)
S.insert(a), sum += saiki(M[a]);
else if (S.count(a) == 0)
sum++;
S.insert(a);
a = "";
continue;
}
a += str[ima][i];
}
return sum;
}
int main() {
while (1) {
cin >> n;
if (n == 0)
break;
S.clear(), M.clear();
for (int i = 0; i < n; i++) {
cin >> str[i];
string a, b;
for (int j = 0; j < str[i].size(); j++) {
if (str[i][j] == ':')
M[a] = i, a = "";
if (str[i][j] != ':')
a += str[i][j];
}
str[i] = a;
str[i][str[i].size() - 1] = ',';
}
cout << saiki(0) << endl;
;
}
return 0;
} | replace | 15 | 16 | 15 | 16 | TLE | |
p00885 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF (1 << 28)
int n, p[100], t[100], dp[100][4];
void solve() {
rep(i, 100) rep(j, 4) dp[i][j] = INF;
dp[0][0] = 0;
rep(i, n - 1) rep(j, 4) {
const int dt = t[i + 1] - t[i];
if ((j + 1) * p[i] + p[i + 1] <= dt) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
if (j < 3 && (j + 1) * abs(p[i] - p[i + 1]) <= dt) {
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + abs(p[i] - p[i + 1]));
}
}
rep(i, n) {
bool ok = false;
rep(j, 4) if (dp[i][j] < INF) ok = true;
if (!ok) {
printf("NG %d\n", i);
return;
}
}
int ans = INF;
rep(j, 4) ans = min(ans, dp[n - 1][j] + p[n - 1]);
printf("OK %d\n", ans);
}
int main() {
for (;;) {
scanf("%d", &n);
p[0] = t[0] = 0;
rep(i, n) scanf("%d%d", p + i + 1, t + i + 1);
n++;
solve();
}
} | #include <algorithm>
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define INF (1 << 28)
int n, p[100], t[100], dp[100][4];
void solve() {
rep(i, 100) rep(j, 4) dp[i][j] = INF;
dp[0][0] = 0;
rep(i, n - 1) rep(j, 4) {
const int dt = t[i + 1] - t[i];
if ((j + 1) * p[i] + p[i + 1] <= dt) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
if (j < 3 && (j + 1) * abs(p[i] - p[i + 1]) <= dt) {
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + abs(p[i] - p[i + 1]));
}
}
rep(i, n) {
bool ok = false;
rep(j, 4) if (dp[i][j] < INF) ok = true;
if (!ok) {
printf("NG %d\n", i);
return;
}
}
int ans = INF;
rep(j, 4) ans = min(ans, dp[n - 1][j] + p[n - 1]);
printf("OK %d\n", ans);
}
int main() {
for (;;) {
scanf("%d", &n);
if (n == 0)
return 0;
p[0] = t[0] = 0;
rep(i, n) scanf("%d%d", p + i + 1, t + i + 1);
n++;
solve();
}
} | insert | 39 | 39 | 39 | 41 | -11 | |
p00885 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
const ll INF = MOD + 1;
const ld EPS = 1e-10;
template <class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
int p[50], t[50], dp[50][5];
int n;
int solve(int i, int j) {
if (i == n)
return p[n];
int res = INF;
if (p[i] * (j + 1) + p[i + 1] <= t[i + 1] - t[i])
chmin(res, solve(i + 1, 1) + p[i] + p[i + 1]);
if (j < 3 && abs(p[i] - p[i + 1]) * (j + 1) <= t[i + 1] - t[i])
chmin(res, solve(i + 1, j + 1) + abs(p[i] - p[i + 1]));
return dp[i][j] = res;
}
int main() {
while (cin >> n, n) {
MS(dp, -1);
FOR(i, 1, n + 1) cin >> p[i] >> t[i];
int ans = solve(0, 0);
if (ans == INF) {
while (ans == INF) {
MS(dp, -1);
n--;
ans = solve(0, 0);
}
cout << "NG " << n + 1 << endl;
} else
cout << "OK " << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (n); i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(a) a.begin(), a.end()
#define MS(m, v) memset(m, v, sizeof(m))
#define D10 fixed << setprecision(10)
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;
const int MOD = 1000000007;
const ll INF = MOD + 1;
const ld EPS = 1e-10;
template <class T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <class T> T &chmax(T &a, const T &b) { return a = max(a, b); }
/*--------------------template--------------------*/
int p[50], t[50], dp[50][5];
int n;
int solve(int i, int j) {
if (i == n)
return p[n];
if (dp[i][j] >= 0)
return dp[i][j];
int res = INF;
if (p[i] * (j + 1) + p[i + 1] <= t[i + 1] - t[i])
chmin(res, solve(i + 1, 1) + p[i] + p[i + 1]);
if (j < 3 && abs(p[i] - p[i + 1]) * (j + 1) <= t[i + 1] - t[i])
chmin(res, solve(i + 1, j + 1) + abs(p[i] - p[i + 1]));
return dp[i][j] = res;
}
int main() {
while (cin >> n, n) {
MS(dp, -1);
FOR(i, 1, n + 1) cin >> p[i] >> t[i];
int ans = solve(0, 0);
if (ans == INF) {
while (ans == INF) {
MS(dp, -1);
n--;
ans = solve(0, 0);
}
cout << "NG " << n + 1 << endl;
} else
cout << "OK " << ans << endl;
}
return 0;
} | insert | 25 | 25 | 25 | 27 | TLE | |
p00885 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using namespace std;
int n, dis[41], t[41], maxball, ans;
void saiki(int x, int now, int ball, int sum, int kai) {
maxball = max(maxball, kai);
if (kai == n && !ball)
ans = min(ans, sum);
if (ball)
saiki(0, now + x * (1 + ball), 0, sum + x, kai);
if (ball == 3 || kai == n)
return;
int nx = dis[kai];
int nsum = sum + abs(x - dis[kai]);
int nnow = now + abs(x - dis[kai]) * (1 + ball);
if (nnow <= t[kai])
saiki(nx, t[kai], ball + 1, nsum, kai + 1);
}
int main() {
while (1) {
cin >> n;
if (!n)
break;
for (int i = 0; i < n; i++)
cin >> dis[i] >> t[i];
sort(t, t + n);
maxball = 0, ans = 100000000;
saiki(0, 0, 0, 0, 0);
if (maxball == n)
cout << "OK " << ans << endl;
else
cout << "NG " << maxball + 1 << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int n, dis[41], t[41], maxball, ans;
void saiki(int x, int now, int ball, int sum, int kai) {
if (ans < sum)
return;
maxball = max(maxball, kai);
if (kai == n && !ball)
ans = min(ans, sum);
if (ball)
saiki(0, now + x * (1 + ball), 0, sum + x, kai);
if (ball == 3 || kai == n)
return;
int nx = dis[kai];
int nsum = sum + abs(x - dis[kai]);
int nnow = now + abs(x - dis[kai]) * (1 + ball);
if (nnow <= t[kai])
saiki(nx, t[kai], ball + 1, nsum, kai + 1);
}
int main() {
while (1) {
cin >> n;
if (!n)
break;
for (int i = 0; i < n; i++)
cin >> dis[i] >> t[i];
sort(t, t + n);
maxball = 0, ans = 100000000;
saiki(0, 0, 0, 0, 0);
if (maxball == n)
cout << "OK " << ans << endl;
else
cout << "NG " << maxball + 1 << endl;
}
return 0;
} | insert | 6 | 6 | 6 | 8 | TLE | |
p00885 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int abs(int x) { return x < 0 ? -x : x; }
int table[101][4];
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
vector<int> t(n), p(n);
for (int i = 1; i <= n; ++i) {
cin >> p[i] >> t[i];
}
memset(table, -1, sizeof(table));
table[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 4; ++j) {
if (table[i - 1][j] < 0) {
continue;
}
int a = (j + 1) * p[i - 1] + p[i];
if (a <= t[i] - t[i - 1]) {
int s = p[i - 1] + p[i];
if (table[i][1] < 0 || table[i][1] > table[i - 1][j] + s) {
table[i][1] = table[i - 1][j] + s;
}
}
int b = (j + 1) * abs(p[i] - p[i - 1]);
if (j < 3 && b <= t[i] - t[i - 1]) {
if (table[i][j + 1] < 0 || table[i][j + 1] > table[i - 1][j] + b) {
table[i][j + 1] = table[i - 1][j] + abs(p[i] - p[i - 1]);
}
}
}
}
int answer = INT_MAX;
for (int i = 0; i < 4; ++i) {
if (table[n][i] >= 0) {
answer = min(answer, table[n][i] + p[n]);
}
}
if (answer == INT_MAX) {
answer = 0;
for (int i = n; i >= 0; --i) {
bool flag = false;
for (int j = 0; j < 4; ++j) {
if (table[i][j] >= 0) {
flag = true;
}
}
if (flag) {
answer = i + 1;
break;
}
}
cout << "NG " << answer << endl;
} else {
cout << "OK " << answer << endl;
}
}
return 0;
} | #include <algorithm>
#include <climits>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int abs(int x) { return x < 0 ? -x : x; }
int table[101][4];
int main() {
while (true) {
int n;
cin >> n;
if (n == 0) {
break;
}
vector<int> t(n + 1), p(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> p[i] >> t[i];
}
memset(table, -1, sizeof(table));
table[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j < 4; ++j) {
if (table[i - 1][j] < 0) {
continue;
}
int a = (j + 1) * p[i - 1] + p[i];
if (a <= t[i] - t[i - 1]) {
int s = p[i - 1] + p[i];
if (table[i][1] < 0 || table[i][1] > table[i - 1][j] + s) {
table[i][1] = table[i - 1][j] + s;
}
}
int b = (j + 1) * abs(p[i] - p[i - 1]);
if (j < 3 && b <= t[i] - t[i - 1]) {
if (table[i][j + 1] < 0 || table[i][j + 1] > table[i - 1][j] + b) {
table[i][j + 1] = table[i - 1][j] + abs(p[i] - p[i - 1]);
}
}
}
}
int answer = INT_MAX;
for (int i = 0; i < 4; ++i) {
if (table[n][i] >= 0) {
answer = min(answer, table[n][i] + p[n]);
}
}
if (answer == INT_MAX) {
answer = 0;
for (int i = n; i >= 0; --i) {
bool flag = false;
for (int j = 0; j < 4; ++j) {
if (table[i][j] >= 0) {
flag = true;
}
}
if (flag) {
answer = i + 1;
break;
}
}
cout << "NG " << answer << endl;
} else {
cout << "OK " << answer << endl;
}
}
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p00890 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
struct state {
int v, cnt, d;
state(int v, int c, int d) : v(v), cnt(c), d(d) {}
bool operator>(const state &s) const { return d > s.d; }
};
struct edge {
int to, cost;
edge(int t, int c) : to(t), cost(c) {}
};
int ans;
vector<vector<edge>> es;
vector<int> dist;
void dijkstra(int s, int t, int limit) {
ans = INT_MAX;
priority_queue<state, vector<state>, greater<state>> que;
vector<vector<int>> dist(es.size(), vector<int>(es.size(), INT_MAX));
que.push(state(s, 0, 0));
dist[s][0] = 0;
while (!que.empty()) {
const state s = que.top();
que.pop();
if (dist[s.v][s.cnt] < s.d || s.cnt >= (int)es.size())
continue;
if (s.d > limit)
return;
if (s.v == t)
chmin(ans, s.cnt);
for (int i = 0; i < es[s.v].size(); ++i) {
const edge &e = es[s.v][i];
if (dist[e.to][s.cnt + 1] > s.d) {
dist[e.to][s.cnt + 1] = s.d;
que.push(state(e.to, s.cnt + 1, s.d));
}
const int next_dist = dist[s.v][s.cnt] + e.cost;
if (dist[e.to][s.cnt] > next_dist) {
dist[e.to][s.cnt] = next_dist;
que.push(state(e.to, s.cnt, next_dist));
}
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int n, m, c; cin >> n >> m >> c, n;) {
es.clear();
es.resize(n);
for (int i = 0; i < m; ++i) {
int f, t, d;
cin >> f >> t >> d;
--f;
--t;
es[f].push_back(edge(t, d));
}
dijkstra(0, n - 1, c);
cout << ans << endl;
}
return EXIT_SUCCESS;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
struct state {
int v, cnt, d;
state(int v, int c, int d) : v(v), cnt(c), d(d) {}
bool operator>(const state &s) const { return d > s.d; }
};
struct edge {
int to, cost;
edge(int t, int c) : to(t), cost(c) {}
};
int ans;
vector<vector<edge>> es;
vector<int> dist;
void dijkstra(int s, int t, int limit) {
ans = INT_MAX;
priority_queue<state, vector<state>, greater<state>> que;
vector<vector<int>> dist(es.size(), vector<int>(es.size() + 1, INT_MAX));
que.push(state(s, 0, 0));
dist[s][0] = 0;
while (!que.empty()) {
const state s = que.top();
que.pop();
if (dist[s.v][s.cnt] < s.d || s.cnt >= (int)es.size())
continue;
if (s.d > limit)
return;
if (s.v == t)
chmin(ans, s.cnt);
for (int i = 0; i < es[s.v].size(); ++i) {
const edge &e = es[s.v][i];
if (dist[e.to][s.cnt + 1] > s.d) {
dist[e.to][s.cnt + 1] = s.d;
que.push(state(e.to, s.cnt + 1, s.d));
}
const int next_dist = dist[s.v][s.cnt] + e.cost;
if (dist[e.to][s.cnt] > next_dist) {
dist[e.to][s.cnt] = next_dist;
que.push(state(e.to, s.cnt, next_dist));
}
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int n, m, c; cin >> n >> m >> c, n;) {
es.clear();
es.resize(n);
for (int i = 0; i < m; ++i) {
int f, t, d;
cin >> f >> t >> d;
--f;
--t;
es[f].push_back(edge(t, d));
}
dijkstra(0, n - 1, c);
cout << ans << endl;
}
return EXIT_SUCCESS;
} | replace | 72 | 73 | 72 | 73 | -6 | free(): invalid pointer
|
p00890 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
#include <queue>
#include <vector>
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define clr clear()
#define pb push_back
#define sz size()
#define fs first
#define sc second
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P2;
const int INF = 1e8;
int n, m, c;
int f, t, cost;
vector<P> g[101];
int d[101][100001];
int main() {
while (cin >> n >> m >> c, n) {
rep(i, n) {
g[i].clr;
rep(j, c + 1) d[i][j] = INF;
}
rep(i, m) {
cin >> f >> t >> cost;
f--;
t--;
g[f].pb(P(cost, t));
}
priority_queue<P2, vector<P2>, greater<P2>> q;
q.push(P2(0, P(0, 0)));
d[0][0] = 0;
while (q.sz) {
P2 p = q.top();
q.pop();
int change = p.fs, v = p.sc.fs, dis = p.sc.sc;
rep(i, g[v].sz) {
int nd = dis + g[v][i].fs, nv = g[v][i].sc;
if (d[nv][dis] > change + 1) {
d[nv][dis] = change + 1;
q.push(P2(d[nv][dis], P(nv, dis)));
}
if (nd > c)
continue;
if (d[nv][nd] > change) {
d[nv][nd] = change;
q.push(P2(d[nv][nd], P(nv, nd)));
}
}
}
int ans = INF;
rep(i, c + 1) ans = min(ans, d[n - 1][i]);
cout << ans << endl;
}
} | #include <iostream>
#include <map>
#include <queue>
#include <vector>
#define rep(i, a) for (int i = 0; i < (int)(a); i++)
#define clr clear()
#define pb push_back
#define sz size()
#define fs first
#define sc second
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P2;
const int INF = 1e8;
int n, m, c;
int f, t, cost;
vector<P> g[101];
int d[101][100001];
int main() {
while (cin >> n >> m >> c, n) {
rep(i, n) {
g[i].clr;
rep(j, c + 1) d[i][j] = INF;
}
rep(i, m) {
cin >> f >> t >> cost;
f--;
t--;
g[f].pb(P(cost, t));
}
priority_queue<P2, vector<P2>, greater<P2>> q;
q.push(P2(0, P(0, 0)));
d[0][0] = 0;
while (q.sz) {
P2 p = q.top();
q.pop();
int change = p.fs, v = p.sc.fs, dis = p.sc.sc;
if (change > d[v][dis])
continue;
if (v == n - 1)
break;
rep(i, g[v].sz) {
int nd = dis + g[v][i].fs, nv = g[v][i].sc;
if (d[nv][dis] > change + 1) {
d[nv][dis] = change + 1;
q.push(P2(d[nv][dis], P(nv, dis)));
}
if (nd > c)
continue;
if (d[nv][nd] > change) {
d[nv][nd] = change;
q.push(P2(d[nv][nd], P(nv, nd)));
}
}
}
int ans = INF;
rep(i, c + 1) ans = min(ans, d[n - 1][i]);
cout << ans << endl;
}
} | insert | 42 | 42 | 42 | 46 | TLE | |
p00890 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
struct edge {
int to, cost;
edge() {}
edge(int to, int cost) : to(to), cost(cost) {}
};
int n, m, c;
vector<vector<edge>> graph;
struct State {
int now, cost, chg;
State() {}
State(int now, int cost, int chg) : now(now), cost(cost), chg(chg) {}
bool operator<(const State &s) const { return cost > s.cost; }
};
vector<vint> mincost;
int dijkstra() {
resz(mincost, n, vint(n, inf));
priority_queue<State> que;
mincost[0][0] = 0;
que.emplace(0, 0, 0);
while (!que.empty()) {
State s = que.top();
que.pop();
int v = s.now, cost = s.cost, chg = s.chg;
if (mincost[chg][v] < cost)
continue;
for (edge &e : graph[v]) {
if (cost + e.cost < mincost[chg][e.to]) {
mincost[chg][e.to] = cost + e.cost;
que.emplace(e.to, mincost[chg][e.to], chg);
}
if (chg < n && cost < mincost[chg + 1][e.to]) {
mincost[chg + 1][e.to] = cost;
que.emplace(e.to, mincost[chg + 1][e.to], chg + 1);
}
}
}
rep(i, n + 1) {
if (mincost[i][n - 1] <= c)
return i;
}
return n;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m >> c, n + m + c) {
resz(graph, n);
rep(i, m) {
int f, t, cc;
cin >> f >> t >> cc;
--f, --t;
graph[f].emplace_back(t, cc);
}
cout << dijkstra() << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
struct edge {
int to, cost;
edge() {}
edge(int to, int cost) : to(to), cost(cost) {}
};
int n, m, c;
vector<vector<edge>> graph;
struct State {
int now, cost, chg;
State() {}
State(int now, int cost, int chg) : now(now), cost(cost), chg(chg) {}
bool operator<(const State &s) const { return cost > s.cost; }
};
vector<vint> mincost;
int dijkstra() {
resz(mincost, n + 1, vint(n, inf));
priority_queue<State> que;
mincost[0][0] = 0;
que.emplace(0, 0, 0);
while (!que.empty()) {
State s = que.top();
que.pop();
int v = s.now, cost = s.cost, chg = s.chg;
if (mincost[chg][v] < cost)
continue;
for (edge &e : graph[v]) {
if (cost + e.cost < mincost[chg][e.to]) {
mincost[chg][e.to] = cost + e.cost;
que.emplace(e.to, mincost[chg][e.to], chg);
}
if (chg < n && cost < mincost[chg + 1][e.to]) {
mincost[chg + 1][e.to] = cost;
que.emplace(e.to, mincost[chg + 1][e.to], chg + 1);
}
}
}
rep(i, n + 1) {
if (mincost[i][n - 1] <= c)
return i;
}
return n;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m >> c, n + m + c) {
resz(graph, n);
rep(i, m) {
int f, t, cc;
cin >> f >> t >> cc;
--f, --t;
graph[f].emplace_back(t, cc);
}
cout << dijkstra() << endl;
}
return 0;
} | replace | 45 | 46 | 45 | 46 | 0 | |
p00890 | C++ | Runtime Error | #include <bits/stdc++.h>
#define INF (1e9)
#define N 105
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
int n, m, C, f, t, c;
vector<P> G[N];
int dijkstra() {
int d[N][N];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[i][j] = INF;
priority_queue<P1, vector<P1>, greater<P1>> q;
d[0][0] = 0;
q.push(P1(0, P(0, 0)));
while (!q.empty()) {
P1 a = q.top();
q.pop();
int cost = a.first;
int cnt = a.second.first;
int node = a.second.second;
if (d[cnt][node] < cost)
continue;
for (int i = 0; i < G[node].size(); i++) {
int nnode = G[node][i].first;
int ncost = cost + G[node][i].second;
if (d[cnt][nnode] > ncost) {
d[cnt][nnode] = ncost;
q.push(P1(ncost, P(cnt, nnode)));
}
if (d[cnt + 1][nnode] > cost) {
d[cnt + 1][nnode] = cost;
q.push(P1(cost, P(cnt + 1, nnode)));
}
}
}
for (int i = 0; i <= n; i++)
if (C >= d[i][n - 1])
return i;
}
int main() {
while (1) {
cin >> n >> m >> C;
if (!n && !m && !C)
break;
for (int i = 0; i < m; i++) {
cin >> f >> t >> c;
f--, t--;
G[f].push_back(P(t, c));
}
cout << dijkstra() << endl;
for (int i = 0; i < n; i++)
G[i].clear();
}
return 0;
} | #include <bits/stdc++.h>
#define INF (1e9)
#define N 105
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
int n, m, C, f, t, c;
vector<P> G[N];
int dijkstra() {
int d[N][N];
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[i][j] = INF;
priority_queue<P1, vector<P1>, greater<P1>> q;
d[0][0] = 0;
q.push(P1(0, P(0, 0)));
while (!q.empty()) {
P1 a = q.top();
q.pop();
int cost = a.first;
int cnt = a.second.first;
int node = a.second.second;
if (d[cnt][node] < cost)
continue;
for (int i = 0; i < G[node].size(); i++) {
int nnode = G[node][i].first;
int ncost = cost + G[node][i].second;
if (d[cnt][nnode] > ncost) {
d[cnt][nnode] = ncost;
q.push(P1(ncost, P(cnt, nnode)));
}
if (cnt < n && d[cnt + 1][nnode] > cost) {
d[cnt + 1][nnode] = cost;
q.push(P1(cost, P(cnt + 1, nnode)));
}
}
}
for (int i = 0; i <= n; i++)
if (C >= d[i][n - 1])
return i;
}
int main() {
while (1) {
cin >> n >> m >> C;
if (!n && !m && !C)
break;
for (int i = 0; i < m; i++) {
cin >> f >> t >> c;
f--, t--;
G[f].push_back(P(t, c));
}
cout << dijkstra() << endl;
for (int i = 0; i < n; i++)
G[i].clear();
}
return 0;
} | replace | 32 | 33 | 32 | 33 | 0 | |
p00890 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
const int INF = 1 << 29;
const double PI = acos(-1);
const double EPS = 1e-8;
struct Edge {
int s, t, w;
Edge(int s, int t, int w) : s(s), t(t), w(w) {}
};
struct P {
int s, num, w;
P(int s, int num, int w) : s(s), num(num), w(w) {}
};
const bool operator<(const P &a, const P &b) { return a.w > b.w; }
int dist[100][100];
int main() {
int n, m, c;
while (cin >> n >> m >> c, n || m || c) {
vector<Edge> g[n];
REP(i, m) {
int a, b, d;
cin >> a >> b >> d;
a--;
b--;
g[a].push_back(Edge(a, b, d));
}
REP(i, n) {
REP(j, n) { dist[i][j] = INF; }
}
priority_queue<P> Q;
Q.push(P(0, 0, 0));
int ans = INF;
while (!Q.empty()) {
P e = Q.top();
Q.pop();
// cout << e.s << " " << e.num << " " << e.w << endl;
if (e.s == n - 1 && e.w < c) {
ans = min(ans, e.num);
}
if (dist[e.s][e.num] < e.w)
continue;
FOR(f, g[e.s]) {
if (dist[f->t][e.num + 1] > e.w) {
dist[f->t][e.num + 1] = e.w;
Q.push(P(f->t, e.num + 1, e.w));
}
if (e.w + f->w <= c) {
if (dist[f->t][e.num] > e.w + f->w) {
dist[f->t][e.num] = e.w + f->w;
Q.push(P(f->t, e.num, e.w + f->w));
}
}
}
}
cout << ans << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
typedef long long ll;
const int INF = 1 << 29;
const double PI = acos(-1);
const double EPS = 1e-8;
struct Edge {
int s, t, w;
Edge(int s, int t, int w) : s(s), t(t), w(w) {}
};
struct P {
int s, num, w;
P(int s, int num, int w) : s(s), num(num), w(w) {}
};
const bool operator<(const P &a, const P &b) { return a.w > b.w; }
int dist[100][100];
int main() {
int n, m, c;
while (cin >> n >> m >> c, n || m || c) {
vector<Edge> g[n];
REP(i, m) {
int a, b, d;
cin >> a >> b >> d;
a--;
b--;
g[a].push_back(Edge(a, b, d));
}
REP(i, n) {
REP(j, n) { dist[i][j] = INF; }
}
priority_queue<P> Q;
Q.push(P(0, 0, 0));
int ans = INF;
while (!Q.empty()) {
P e = Q.top();
Q.pop();
// cout << e.s << " " << e.num << " " << e.w << endl;
if (e.s == n - 1 && e.w < c) {
ans = min(ans, e.num);
}
if (dist[e.s][e.num] < e.w)
continue;
FOR(f, g[e.s]) {
if (e.num + 1 < n && dist[f->t][e.num + 1] > e.w) {
dist[f->t][e.num + 1] = e.w;
Q.push(P(f->t, e.num + 1, e.w));
}
if (e.w + f->w <= c) {
if (dist[f->t][e.num] > e.w + f->w) {
dist[f->t][e.num] = e.w + f->w;
Q.push(P(f->t, e.num, e.w + f->w));
}
}
}
}
cout << ans << endl;
}
} | replace | 65 | 66 | 65 | 66 | 0 | |
p00891 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
long long H, W, K, c[1002][1002], p[1002][1002], r1[1002][1002], r2[1002][1002],
r3[1002][1002];
long long power[1000002], mod = 1000000007;
vector<long long> v;
void makehush() {
power[0] = 1;
for (int i = 1; i < H * W; i++) {
power[i] = power[i - 1] * 2;
power[i] %= mod;
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
r1[i][j] = c[i][j] * power[i * W + j];
}
}
for (int i = 1; i < H; i++) {
for (int j = 0; j < W; j++) {
r1[i][j] += r1[i - 1][j];
r1[i][j] %= mod;
}
}
for (int i = 0; i < H; i++) {
for (int j = 1; j < W; j++) {
r1[i][j] += r1[i][j - 1];
r1[i][j] %= mod;
}
}
}
void candidates(int E) {
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++)
r2[i][j] = p[i][j];
}
if (E == 1) {
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++)
r2[i][j] = p[K - i - 1][j];
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < K; j++) {
for (int k = 0; k < K; k++)
r3[k][K - 1 - j] = r2[j][k];
}
long long Y = 0;
for (int j = 0; j < K; j++) {
for (int k = 0; k < K; k++) {
r2[j][k] = r3[j][k];
Y += r2[j][k] * power[j * W + k];
Y %= mod;
}
}
v.push_back(Y);
}
}
long long modpow(long long a, long long b, long long m) {
long long s1 = a, s2 = 1;
for (int i = 0; i < 63; i++) {
if ((b / (1LL << i)) % 2 == 1) {
s2 *= s1;
s2 %= m;
}
s1 *= s1;
s1 %= m;
}
return s2;
}
long long Div(long long a, long long b, long long m) {
return (a * modpow(b, m - 2, m)) % mod;
}
long long Hush(long long ax, long long ay, long long bx, long long by) {
long long p1 = 0;
if (ax >= 1 && ay >= 1)
p1 = r1[ax - 1][ay - 1];
long long p2 = r1[bx - 1][by - 1];
long long p3 = 0;
if (ax >= 1)
p3 = r1[ax - 1][by - 1];
long long p4 = 0;
if (ay >= 1)
p4 = r1[bx - 1][ay - 1];
return (p1 + p2 - p3 - p4 + mod * 2) % mod;
}
int main() {
while (true) {
for (int i = 0; i < 1002; i++) {
for (int j = 0; j < 1002; j++) {
c[i][j] = 0;
p[i][j] = 0;
r1[i][j] = 0;
r2[i][j] = 0;
r3[i][j] = 0;
}
}
v.clear();
cin >> W >> H >> K;
if (W == 0 && H == 0 && K == 0)
break;
for (int i = 0; i < H; i++) {
string S;
cin >> S;
for (int j = 0; j < S.size(); j++) {
int r = 63;
if ('A' <= S[j] && S[j] <= 'Z')
r = S[j] - 'A';
if ('a' <= S[j] && S[j] <= 'z')
r = S[j] - 'a' + 26;
if ('0' <= S[j] && S[j] <= '9')
r = S[j] - '0' + 52;
if (S[j] == '+')
r = 62;
for (int k = 0; k < 6; k++) {
c[i][j * 6 + (5 - k)] = (r / (1 << k)) % 2;
}
}
}
for (int i = 0; i < K; i++) {
string S;
cin >> S;
for (int j = 0; j < S.size(); j++) {
int r = 63;
if ('A' <= S[j] && S[j] <= 'Z')
r = S[j] - 'A';
if ('a' <= S[j] && S[j] <= 'z')
r = S[j] - 'a' + 26;
if ('0' <= S[j] && S[j] <= '9')
r = S[j] - '0' + 52;
if (S[j] == '+')
r = 62;
for (int k = 0; k < 6; k++) {
p[i][j * 6 + (5 - k)] = (r / (1 << k)) % 2;
}
}
}
makehush();
candidates(0);
candidates(1);
int cnt = 0;
for (int i = 0; i <= H - K; i++) {
for (int j = 0; j <= W - K; j++) {
bool OK = false;
long long J = Hush(i, j, i + K, j + K);
J = Div(J, power[i * W + j], mod);
for (int k = 0; k < v.size(); k++) {
if (J == v[k])
OK = true;
}
if (OK == true)
cnt++;
}
}
cout << cnt << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
long long H, W, K, c[1002][1002], p[1002][1002], r1[1002][1002], r2[1002][1002],
r3[1002][1002];
long long power[1000002], mod = 1000000007;
vector<long long> v;
void makehush() {
power[0] = 1;
for (int i = 1; i < H * W; i++) {
power[i] = power[i - 1] * 2;
power[i] %= mod;
}
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
r1[i][j] = c[i][j] * power[i * W + j];
}
}
for (int i = 1; i < H; i++) {
for (int j = 0; j < W; j++) {
r1[i][j] += r1[i - 1][j];
r1[i][j] %= mod;
}
}
for (int i = 0; i < H; i++) {
for (int j = 1; j < W; j++) {
r1[i][j] += r1[i][j - 1];
r1[i][j] %= mod;
}
}
}
void candidates(int E) {
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++)
r2[i][j] = p[i][j];
}
if (E == 1) {
for (int i = 0; i < K; i++) {
for (int j = 0; j < K; j++)
r2[i][j] = p[K - i - 1][j];
}
}
for (int i = 0; i < 4; i++) {
for (int j = 0; j < K; j++) {
for (int k = 0; k < K; k++)
r3[k][K - 1 - j] = r2[j][k];
}
long long Y = 0;
for (int j = 0; j < K; j++) {
for (int k = 0; k < K; k++) {
r2[j][k] = r3[j][k];
Y += r2[j][k] * power[j * W + k];
Y %= mod;
}
}
v.push_back(Y);
}
}
long long modpow(long long a, long long b, long long m) {
long long s1 = a, s2 = 1;
for (int i = 0; i < 35; i++) {
if ((b / (1LL << i)) % 2 == 1) {
s2 *= s1;
s2 %= m;
}
s1 *= s1;
s1 %= m;
}
return s2;
}
long long Div(long long a, long long b, long long m) {
return (a * modpow(b, m - 2, m)) % mod;
}
long long Hush(long long ax, long long ay, long long bx, long long by) {
long long p1 = 0;
if (ax >= 1 && ay >= 1)
p1 = r1[ax - 1][ay - 1];
long long p2 = r1[bx - 1][by - 1];
long long p3 = 0;
if (ax >= 1)
p3 = r1[ax - 1][by - 1];
long long p4 = 0;
if (ay >= 1)
p4 = r1[bx - 1][ay - 1];
return (p1 + p2 - p3 - p4 + mod * 2) % mod;
}
int main() {
while (true) {
for (int i = 0; i < 1002; i++) {
for (int j = 0; j < 1002; j++) {
c[i][j] = 0;
p[i][j] = 0;
r1[i][j] = 0;
r2[i][j] = 0;
r3[i][j] = 0;
}
}
v.clear();
cin >> W >> H >> K;
if (W == 0 && H == 0 && K == 0)
break;
for (int i = 0; i < H; i++) {
string S;
cin >> S;
for (int j = 0; j < S.size(); j++) {
int r = 63;
if ('A' <= S[j] && S[j] <= 'Z')
r = S[j] - 'A';
if ('a' <= S[j] && S[j] <= 'z')
r = S[j] - 'a' + 26;
if ('0' <= S[j] && S[j] <= '9')
r = S[j] - '0' + 52;
if (S[j] == '+')
r = 62;
for (int k = 0; k < 6; k++) {
c[i][j * 6 + (5 - k)] = (r / (1 << k)) % 2;
}
}
}
for (int i = 0; i < K; i++) {
string S;
cin >> S;
for (int j = 0; j < S.size(); j++) {
int r = 63;
if ('A' <= S[j] && S[j] <= 'Z')
r = S[j] - 'A';
if ('a' <= S[j] && S[j] <= 'z')
r = S[j] - 'a' + 26;
if ('0' <= S[j] && S[j] <= '9')
r = S[j] - '0' + 52;
if (S[j] == '+')
r = 62;
for (int k = 0; k < 6; k++) {
p[i][j * 6 + (5 - k)] = (r / (1 << k)) % 2;
}
}
}
makehush();
candidates(0);
candidates(1);
int cnt = 0;
for (int i = 0; i <= H - K; i++) {
for (int j = 0; j <= W - K; j++) {
bool OK = false;
long long J = Hush(i, j, i + K, j + K);
J = Div(J, power[i * W + j], mod);
for (int k = 0; k < v.size(); k++) {
if (J == v[k])
OK = true;
}
if (OK == true)
cnt++;
}
}
cout << cnt << endl;
}
return 0;
} | replace | 62 | 63 | 62 | 63 | TLE | |
p00892 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
const int DIV = 1000000;
int m, n;
double x1[100], y[100], x2[100], z[100];
double mnx, mxx;
double solve(double x) {
double y1 = 0, y2 = 0, z1 = 0, z2 = 0;
static int px11 = 0, px12 = 0, px21 = 0, px22 = 0;
rep(ii, m) {
int i = (px11 + ii) % m;
if (x1[i] != x1[(i + 1) % m] && x1[i] <= x && x <= x1[(i + 1) % m]) {
y1 = y[i] +
(y[(i + 1) % m] - y[i]) / (x1[(i + 1) % m] - x1[i]) * (x - x1[i]);
px11 = i;
break;
}
}
rep(ii, m) {
int i = (px12 - ii + m) % m;
if (x1[i] != x1[(i + 1) % m] && x1[(i + 1) % m] <= x && x <= x1[i]) {
y2 = y[i] +
(y[(i + 1) % m] - y[i]) / (x1[(i + 1) % m] - x1[i]) * (x - x1[i]);
px12 = i;
break;
}
}
rep(ii, n) {
int i = (px21 + ii) % n;
if (x2[i] != x2[(i + 1) % n] && x2[i] <= x && x <= x2[(i + 1) % n]) {
z1 = z[i] +
(z[(i + 1) % n] - z[i]) / (x2[(i + 1) % n] - x2[i]) * (x - x2[i]);
px21 = i;
break;
}
}
rep(ii, n) {
int i = (px22 - ii + n) % n;
if (x2[i] != x2[(i + 1) % n] && x2[(i + 1) % n] <= x && x <= x2[i]) {
z2 = z[i] +
(z[(i + 1) % n] - z[i]) / (x2[(i + 1) % n] - x2[i]) * (x - x2[i]);
px22 = i;
break;
}
}
return (y2 - y1) * (z2 - z1);
}
double simpson(double l, double r, double f(double), int k = 1) {
double h = (r - l) / (2 * k);
double fo = 0, fe = 0;
for (int i = 1; i <= 2 * k - 3; i += 2) {
fo += f(l + h * i);
fe += f(l + h * (i + 1));
}
return (f(l) + f(r) + 4 * (fo + f(r - h)) + 2 * fe) * h / 3;
}
int main() {
while (true) {
cin >> m >> n;
if (m == 0 && n == 0)
break;
rep(i, m) cin >> x1[i] >> y[i];
rep(i, n) cin >> x2[i] >> z[i];
double mnx = max(*min_element(x1, x1 + m), *min_element(x2, x2 + n));
double mxx = min(*max_element(x1, x1 + m), *max_element(x2, x2 + n));
printf("%.12lf\n", simpson(mnx, mxx, solve, DIV));
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
const int DIV = 500000;
int m, n;
double x1[100], y[100], x2[100], z[100];
double mnx, mxx;
double solve(double x) {
double y1 = 0, y2 = 0, z1 = 0, z2 = 0;
static int px11 = 0, px12 = 0, px21 = 0, px22 = 0;
rep(ii, m) {
int i = (px11 + ii) % m;
if (x1[i] != x1[(i + 1) % m] && x1[i] <= x && x <= x1[(i + 1) % m]) {
y1 = y[i] +
(y[(i + 1) % m] - y[i]) / (x1[(i + 1) % m] - x1[i]) * (x - x1[i]);
px11 = i;
break;
}
}
rep(ii, m) {
int i = (px12 - ii + m) % m;
if (x1[i] != x1[(i + 1) % m] && x1[(i + 1) % m] <= x && x <= x1[i]) {
y2 = y[i] +
(y[(i + 1) % m] - y[i]) / (x1[(i + 1) % m] - x1[i]) * (x - x1[i]);
px12 = i;
break;
}
}
rep(ii, n) {
int i = (px21 + ii) % n;
if (x2[i] != x2[(i + 1) % n] && x2[i] <= x && x <= x2[(i + 1) % n]) {
z1 = z[i] +
(z[(i + 1) % n] - z[i]) / (x2[(i + 1) % n] - x2[i]) * (x - x2[i]);
px21 = i;
break;
}
}
rep(ii, n) {
int i = (px22 - ii + n) % n;
if (x2[i] != x2[(i + 1) % n] && x2[(i + 1) % n] <= x && x <= x2[i]) {
z2 = z[i] +
(z[(i + 1) % n] - z[i]) / (x2[(i + 1) % n] - x2[i]) * (x - x2[i]);
px22 = i;
break;
}
}
return (y2 - y1) * (z2 - z1);
}
double simpson(double l, double r, double f(double), int k = 1) {
double h = (r - l) / (2 * k);
double fo = 0, fe = 0;
for (int i = 1; i <= 2 * k - 3; i += 2) {
fo += f(l + h * i);
fe += f(l + h * (i + 1));
}
return (f(l) + f(r) + 4 * (fo + f(r - h)) + 2 * fe) * h / 3;
}
int main() {
while (true) {
cin >> m >> n;
if (m == 0 && n == 0)
break;
rep(i, m) cin >> x1[i] >> y[i];
rep(i, n) cin >> x2[i] >> z[i];
double mnx = max(*min_element(x1, x1 + m), *min_element(x2, x2 + n));
double mxx = min(*max_element(x1, x1 + m), *max_element(x2, x2 + n));
printf("%.12lf\n", simpson(mnx, mxx, solve, DIV));
}
} | replace | 6 | 7 | 6 | 7 | TLE | |
p00892 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef double dbl;
#define double long double
typedef complex<double> P;
typedef vector<P> G;
#define REP(i, n) for (int i = 0; i < n; i++)
double eps = 1e-11;
double EPS = eps;
bool eq(double a, double b) { return fabs(a - b) < eps; }
double cross(P a, P b) { return imag(conj(a) * b); }
double dot(P a, P b) { return real(conj(a) * b); }
vector<P> ps1, ps2;
//??´???
struct L : public vector<P> {
L(P a, P b) {
push_back(a);
push_back(b);
}
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > 0)
return +1; // a ??? b ??§???????¨??????????????????? b ??? c(???)
if (cross(b, c) < 0)
return -1; // a ??? b ??§????¨??????????????????? b ??? c(???)
if (dot(b, c) < 0)
return +2; // a???b??§????????????a??????????¶???????b???c(c--a--b)
if (norm(b) < norm(c))
return -2; // a???b??§????????????b???c(a--b--c)
return 0; // a???b??§????????????b???c(????????? b == c)
}
P crosspoint(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS)
return m[0];
return m[0] + B / A * (m[1] - m[0]);
}
// ???????§???¢???????????????????§???¢???????????´?????§????????????
//???????????´?????????????????´?????????????????´?????????????????¨?????????????????¨?????????????????????????????¨????????????????????????
#define curr(P, i) P[(i) % P.size()]
#define next(P, i) P[(i + 1) % P.size()]
#define prev(P, i) P[(i + P.size() - 1) % P.size()]
G convex_cut(const G &poly, const L &l) {
G Q;
for (int i = 0; i < poly.size(); ++i) {
P A = curr(poly, i), B = next(poly, i);
if (ccw(l[0], l[1], A) != -1)
Q.push_back(A);
if (ccw(l[0], l[1], A) * ccw(l[0], l[1], B) < 0)
Q.push_back(crosspoint(L(A, B), l));
}
return Q;
}
// ????´?????§???¢?????¢??????"2???"????±??????? O(n)
double area2(const G &poly) {
double A = 0;
REP(i, poly.size()) A += cross(curr(poly, i), next(poly, i));
return abs(A);
}
vector<double> ux;
P in() {
double x, y;
cin >> x >> y;
return P(x, y);
}
pair<double, double> seg(const vector<P> &ps, double x) {
double mi = 1e9, ma = -1e9;
auto reflesh = [&mi, &ma](double y) {
mi = min(mi, y);
ma = max(ma, y);
};
for (int i = 0; i < ps.size(); i++) {
P a = ps[i];
P b = ps[(i + 1) % ps.size()];
if (a.real() > b.real())
swap(a, b);
if (eq(a.real(), x))
reflesh(a.imag());
if (eq(b.real(), x))
reflesh(b.imag());
if (a.real() + eps < x and x < b.real() - eps) {
reflesh(a.imag() +
(x - a.real()) * (b.imag() - a.imag()) / (b.real() - a.real()));
}
}
if (ma < mi)
return {0.0, 0.0};
return {mi, ma};
}
double S(double l, double r) {
if (r <= l)
return 0;
G g1 = convex_cut(ps1, L(P(l, 0), P(l, -1)));
G g2 = convex_cut(g1, L(P(r, 0), P(r, +1)));
return area2(g2) / 2;
}
double Vf(double z) {
auto p = seg(ps2, z);
return S(p.first, p.second);
}
double Vs(double l, double r) {
return (r - l) / 6 * (Vf(l) + 4 * Vf((l + r) / 2) + Vf(r));
}
double V(double l, double r, int k = 7) {
if (l >= r)
return 0;
double m = (l + r) / 2;
double a = Vs(l, m);
double b = Vs(m, r);
double c = Vs(l, r);
if ((k <= 0) and eq(a + b, c)) {
return c;
} else {
return V(l, m, k - 1) + V(m, r, k - 1);
}
}
int main() {
int m, n;
while (cin >> m >> n && m) {
ps1.clear();
ps2.clear();
ux.clear();
for (int i = 0; i < m; i++) {
ps1.push_back(in());
ux.push_back(ps1.back().real());
}
vector<double> uz;
for (int i = 0; i < n; i++) {
ps2.push_back(in());
ps2.back() = P(ps2.back().imag(), ps2.back().real());
uz.push_back(ps2.back().real());
}
sort(uz.begin(), uz.end());
sort(ux.begin(), ux.end());
double vans = 0;
// for( auto z : uz ) cout << z << " "; cout << endl;
// for( auto x : ux ) cout << x << " "; cout << endl;
for (int i = 0; i + 1 < uz.size(); i++)
if (uz[i] != uz[i + 1])
vans += V(uz[i], uz[i + 1]);
printf("%.8lf\n", (dbl)vans);
}
} | #include <bits/stdc++.h>
using namespace std;
typedef double dbl;
#define double long double
typedef complex<double> P;
typedef vector<P> G;
#define REP(i, n) for (int i = 0; i < n; i++)
double eps = 1e-11;
double EPS = eps;
bool eq(double a, double b) { return fabs(a - b) < eps; }
double cross(P a, P b) { return imag(conj(a) * b); }
double dot(P a, P b) { return real(conj(a) * b); }
vector<P> ps1, ps2;
//??´???
struct L : public vector<P> {
L(P a, P b) {
push_back(a);
push_back(b);
}
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > 0)
return +1; // a ??? b ??§???????¨??????????????????? b ??? c(???)
if (cross(b, c) < 0)
return -1; // a ??? b ??§????¨??????????????????? b ??? c(???)
if (dot(b, c) < 0)
return +2; // a???b??§????????????a??????????¶???????b???c(c--a--b)
if (norm(b) < norm(c))
return -2; // a???b??§????????????b???c(a--b--c)
return 0; // a???b??§????????????b???c(????????? b == c)
}
P crosspoint(const L &l, const L &m) {
double A = cross(l[1] - l[0], m[1] - m[0]);
double B = cross(l[1] - l[0], l[1] - m[0]);
if (abs(A) < EPS && abs(B) < EPS)
return m[0];
return m[0] + B / A * (m[1] - m[0]);
}
// ???????§???¢???????????????????§???¢???????????´?????§????????????
//???????????´?????????????????´?????????????????´?????????????????¨?????????????????¨?????????????????????????????¨????????????????????????
#define curr(P, i) P[(i) % P.size()]
#define next(P, i) P[(i + 1) % P.size()]
#define prev(P, i) P[(i + P.size() - 1) % P.size()]
G convex_cut(const G &poly, const L &l) {
G Q;
for (int i = 0; i < poly.size(); ++i) {
P A = curr(poly, i), B = next(poly, i);
if (ccw(l[0], l[1], A) != -1)
Q.push_back(A);
if (ccw(l[0], l[1], A) * ccw(l[0], l[1], B) < 0)
Q.push_back(crosspoint(L(A, B), l));
}
return Q;
}
// ????´?????§???¢?????¢??????"2???"????±??????? O(n)
double area2(const G &poly) {
double A = 0;
REP(i, poly.size()) A += cross(curr(poly, i), next(poly, i));
return abs(A);
}
vector<double> ux;
P in() {
double x, y;
cin >> x >> y;
return P(x, y);
}
pair<double, double> seg(const vector<P> &ps, double x) {
double mi = 1e9, ma = -1e9;
auto reflesh = [&mi, &ma](double y) {
mi = min(mi, y);
ma = max(ma, y);
};
for (int i = 0; i < ps.size(); i++) {
P a = ps[i];
P b = ps[(i + 1) % ps.size()];
if (a.real() > b.real())
swap(a, b);
if (eq(a.real(), x))
reflesh(a.imag());
if (eq(b.real(), x))
reflesh(b.imag());
if (a.real() + eps < x and x < b.real() - eps) {
reflesh(a.imag() +
(x - a.real()) * (b.imag() - a.imag()) / (b.real() - a.real()));
}
}
if (ma < mi)
return {0.0, 0.0};
return {mi, ma};
}
double S(double l, double r) {
if (r <= l)
return 0;
G g1 = convex_cut(ps1, L(P(l, 0), P(l, -1)));
G g2 = convex_cut(g1, L(P(r, 0), P(r, +1)));
return area2(g2) / 2;
}
double Vf(double z) {
auto p = seg(ps2, z);
return S(p.first, p.second);
}
double Vs(double l, double r) {
return (r - l) / 6 * (Vf(l) + 4 * Vf((l + r) / 2) + Vf(r));
}
double V(double l, double r, int k = 6) {
if (l >= r)
return 0;
double m = (l + r) / 2;
double a = Vs(l, m);
double b = Vs(m, r);
double c = Vs(l, r);
if ((k <= 0) and eq(a + b, c)) {
return c;
} else {
return V(l, m, k - 1) + V(m, r, k - 1);
}
}
int main() {
int m, n;
while (cin >> m >> n && m) {
ps1.clear();
ps2.clear();
ux.clear();
for (int i = 0; i < m; i++) {
ps1.push_back(in());
ux.push_back(ps1.back().real());
}
vector<double> uz;
for (int i = 0; i < n; i++) {
ps2.push_back(in());
ps2.back() = P(ps2.back().imag(), ps2.back().real());
uz.push_back(ps2.back().real());
}
sort(uz.begin(), uz.end());
sort(ux.begin(), ux.end());
double vans = 0;
// for( auto z : uz ) cout << z << " "; cout << endl;
// for( auto x : ux ) cout << x << " "; cout << endl;
for (int i = 0; i + 1 < uz.size(); i++)
if (uz[i] != uz[i + 1])
vans += V(uz[i], uz[i + 1]);
printf("%.8lf\n", (dbl)vans);
}
} | replace | 120 | 121 | 120 | 121 | TLE | |
p00892 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
double width(const pair<int, int> P[], double x, int length) {
vector<double> w(0);
for (int i = 0; i < length; i++) {
pair<int, int> p, q;
p = P[i];
i != length - 1 ? q = P[i + 1] : q = P[0];
if (p.first == x) {
w.push_back(p.second);
} else if ((p.first < x && x < q.first) || (p.first > x && x > q.first)) {
int x0, y0, x1, y1;
if (p.first < x) {
x0 = p.first;
y0 = p.second;
x1 = q.first;
y1 = q.second;
} else {
x0 = q.first;
y0 = q.second;
x1 = p.first;
y1 = p.second;
}
w.push_back(y0 + 1.0 * (y1 - y0) * (x - x0) / (x1 - x0));
}
}
sort(w.begin(), w.end());
return w.front() - w.back();
}
// P1??¨P2????????????????????????????????????x????????????sort?????????x???????????????????¬???¢??°?????????????????????
double volume(const pair<int, int> P1[], const pair<int, int> P2[],
pair<int, int> X[], int m, int n) {
/*
for(int i = 0; i < m+n; i++){
if(i < m){
printf("P1[%d]:%d %d\n",i,P1[i].first,P1[i].second);
}else{
printf("P2[%d]:%d %d\n",i-m,P2[i-m].first,P2[i-m].second);
}
}
*/
sort(X, X + m + n);
pair<int, int> p1mm = P1[0], p2mm = P2[0];
for (int i = 0; i < m; i++) {
if (p1mm.first > P1[i].first) {
p1mm.first = P1[i].first;
}
if (p1mm.second < P1[i].first) {
p1mm.second = P1[i].first;
}
}
for (int i = 0; i < n; i++) {
if (p2mm.first > P2[i].first) {
p2mm.first = P2[i].first;
}
if (p2mm.second < P2[i].first) {
p2mm.second = P2[i].first;
}
}
/*
printf("p1mm: %d %d\np2mm: %d
%d\n",p1mm.first,p1mm.second,p2mm.first,p2mm.second); for(int i = 0; i < m+n;
i++){ if(i < m){ printf("P1[%d]:%d %d\n",i,P1[i].first,P1[i].second); }else{
printf("P2[%d]:%d %d\n",i-m,P2[i-m].first,P2[i-m].second);
}
}*/
int xmin = max(p1mm.first, p2mm.first), xmax = min(p1mm.second, p2mm.second);
// printf("minmax: %d %d\n",xmin,xmax);
double sum = 0;
for (int i = 0; i < m + n - 1; i++) {
pair<int, int> a = X[i], b = X[i + 1];
if (xmin <= a.first && xmax >= a.first && xmin <= b.first &&
xmax >= b.first) {
if (a.first == b.first) {
continue;
}
double mid = (a.first + b.first) / 2.0;
double va = width(P1, a.first, m) * width(P2, a.first, n);
double vb = width(P1, b.first, m) * width(P2, b.first, n);
double vmid = width(P1, mid, m) * width(P2, mid, n);
double area = (b.first - a.first) / 6.0 * (va + 4 * vmid + vb);
// printf("a,b %d %d\nmid %f\nva %f\nvb %f\nvmid %f\narea
// %f\n",a.first,b.first,mid,va,vb,vmid,area);
sum += area;
}
}
return sum;
}
int main() {
while (true) {
int m, n;
scanf("%d %d", &m, &n);
if (m == 0 && n == 0) {
break;
}
pair<int, int> *P1 = new pair<int, int>[m], *P2 = new pair<int, int>[n],
*X = new pair<int, int>[m + n];
for (int i = 0; i < m + n; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (i < m) {
P1[i] = make_pair(x, y);
} else {
P2[i - m] = make_pair(x, y);
}
X[i] = make_pair(x, y);
}
double vol = volume(P1, P2, X, m, n);
printf("%f\n", vol);
delete[] P1;
delete[] P2;
delete[] X;
}
} | #include <algorithm>
#include <cstdio>
#include <utility>
#include <vector>
using namespace std;
double width(const pair<int, int> P[], double x, int length) {
vector<double> w(0);
for (int i = 0; i < length; i++) {
pair<int, int> p, q;
p = P[i];
i != length - 1 ? q = P[i + 1] : q = P[0];
if (p.first == x) {
w.push_back(p.second);
} else if ((p.first < x && x < q.first) || (p.first > x && x > q.first)) {
int x0, y0, x1, y1;
if (p.first < x) {
x0 = p.first;
y0 = p.second;
x1 = q.first;
y1 = q.second;
} else {
x0 = q.first;
y0 = q.second;
x1 = p.first;
y1 = p.second;
}
w.push_back(y0 + 1.0 * (y1 - y0) * (x - x0) / (x1 - x0));
}
}
sort(w.begin(), w.end());
return w.front() - w.back();
}
// P1??¨P2????????????????????????????????????x????????????sort?????????x???????????????????¬???¢??°?????????????????????
double volume(const pair<int, int> P1[], const pair<int, int> P2[],
pair<int, int> X[], int m, int n) {
/*
for(int i = 0; i < m+n; i++){
if(i < m){
printf("P1[%d]:%d %d\n",i,P1[i].first,P1[i].second);
}else{
printf("P2[%d]:%d %d\n",i-m,P2[i-m].first,P2[i-m].second);
}
}
*/
sort(X, X + m + n);
pair<int, int> p1mm(P1[0].first, P1[0].first), p2mm(P2[0].first, P2[0].first);
for (int i = 0; i < m; i++) {
if (p1mm.first > P1[i].first) {
p1mm.first = P1[i].first;
}
if (p1mm.second < P1[i].first) {
p1mm.second = P1[i].first;
}
}
for (int i = 0; i < n; i++) {
if (p2mm.first > P2[i].first) {
p2mm.first = P2[i].first;
}
if (p2mm.second < P2[i].first) {
p2mm.second = P2[i].first;
}
}
/*
printf("p1mm: %d %d\np2mm: %d
%d\n",p1mm.first,p1mm.second,p2mm.first,p2mm.second); for(int i = 0; i < m+n;
i++){ if(i < m){ printf("P1[%d]:%d %d\n",i,P1[i].first,P1[i].second); }else{
printf("P2[%d]:%d %d\n",i-m,P2[i-m].first,P2[i-m].second);
}
}*/
int xmin = max(p1mm.first, p2mm.first), xmax = min(p1mm.second, p2mm.second);
// printf("minmax: %d %d\n",xmin,xmax);
double sum = 0;
for (int i = 0; i < m + n - 1; i++) {
pair<int, int> a = X[i], b = X[i + 1];
if (xmin <= a.first && xmax >= a.first && xmin <= b.first &&
xmax >= b.first) {
if (a.first == b.first) {
continue;
}
double mid = (a.first + b.first) / 2.0;
double va = width(P1, a.first, m) * width(P2, a.first, n);
double vb = width(P1, b.first, m) * width(P2, b.first, n);
double vmid = width(P1, mid, m) * width(P2, mid, n);
double area = (b.first - a.first) / 6.0 * (va + 4 * vmid + vb);
// printf("a,b %d %d\nmid %f\nva %f\nvb %f\nvmid %f\narea
// %f\n",a.first,b.first,mid,va,vb,vmid,area);
sum += area;
}
}
return sum;
}
int main() {
while (true) {
int m, n;
scanf("%d %d", &m, &n);
if (m == 0 && n == 0) {
break;
}
pair<int, int> *P1 = new pair<int, int>[m], *P2 = new pair<int, int>[n],
*X = new pair<int, int>[m + n];
for (int i = 0; i < m + n; i++) {
int x, y;
scanf("%d %d", &x, &y);
if (i < m) {
P1[i] = make_pair(x, y);
} else {
P2[i - m] = make_pair(x, y);
}
X[i] = make_pair(x, y);
}
double vol = volume(P1, P2, X, m, n);
printf("%f\n", vol);
delete[] P1;
delete[] P2;
delete[] X;
}
} | replace | 47 | 48 | 47 | 48 | 0 | |
p00894 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
struct S {
string date;
int begin, end;
S() {}
S(string s, int b, int e) {
date = s;
begin = b;
end = e;
}
};
void solve(int n) {
vector<S> data[500];
vector<int> ans(500, 0);
rep(i, 0, n) {
string d;
cin >> d;
string temp;
cin >> temp;
int time = (temp[0] - '0') * 600 + (temp[1] - '0') * 60 +
(temp[3] - '0') * 10 + (temp[4] - '0');
string io;
cin >> io;
string sid;
cin >> sid;
int id = (sid[0] - '0') * 100 + (sid[1] - '0') * 10 + (sid[2] - '0');
if (io == "I") {
data[id].push_back(S(d, time, 0));
} else {
data[id][data[id].size() - 1].end = time;
}
}
rep(i, 1, 500) {
rep(j, 0, data[0].size()) {
rep(k, 0, data[i].size()) {
if (data[0][j].date != data[i][k].date) {
continue;
}
int t_begin = max(data[0][j].begin, data[i][k].begin);
int t_end = min(data[0][j].end, data[i][k].end);
int t_ans = max(0, t_end - t_begin);
ans[i] += t_ans;
}
}
}
int answer = 0;
rep(i, 0, 500) { answer = max(answer, ans[i]); }
cout << answer << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
while (true) {
int n;
cin >> n;
if (n == 0)
break;
solve(n);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
struct S {
string date;
int begin, end;
S() {}
S(string s, int b, int e) {
date = s;
begin = b;
end = e;
}
};
void solve(int n) {
vector<S> data[600];
vector<int> ans(600, 0);
rep(i, 0, n) {
string d;
cin >> d;
string temp;
cin >> temp;
int time = (temp[0] - '0') * 600 + (temp[1] - '0') * 60 +
(temp[3] - '0') * 10 + (temp[4] - '0');
string io;
cin >> io;
string sid;
cin >> sid;
int id = (sid[0] - '0') * 100 + (sid[1] - '0') * 10 + (sid[2] - '0');
if (io == "I") {
data[id].push_back(S(d, time, 0));
} else {
data[id][data[id].size() - 1].end = time;
}
}
rep(i, 1, 500) {
rep(j, 0, data[0].size()) {
rep(k, 0, data[i].size()) {
if (data[0][j].date != data[i][k].date) {
continue;
}
int t_begin = max(data[0][j].begin, data[i][k].begin);
int t_end = min(data[0][j].end, data[i][k].end);
int t_ans = max(0, t_end - t_begin);
ans[i] += t_ans;
}
}
}
int answer = 0;
rep(i, 0, 500) { answer = max(answer, ans[i]); }
cout << answer << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
while (true) {
int n;
cin >> n;
if (n == 0)
break;
solve(n);
}
return 0;
} | replace | 40 | 42 | 40 | 42 | 0 | |
p00895 | C++ | Memory Limit Exceeded | #include <iostream>
#include <set>
#include <string>
using namespace std;
string mp[11];
int w, h;
set<string> cnt;
string ans;
void check(int x, int y) {
string str;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (i == 0 && j == 0)
continue;
str = mp[y][x];
int nx = (x + j + w) % w, ny = (y + i + h) % h;
while (ny != y || nx != x) {
str += mp[ny][nx], nx = (nx + j + w) % w, ny = (ny + i + h) % h;
if (cnt.count(str)) {
if (str.size() > ans.size())
ans = str;
else if (str.size() == ans.size())
ans = min(str, ans);
} else
cnt.insert(str);
}
}
}
int main() {
while (1) {
cin >> h >> w;
if (w == 0 && h == 0)
break;
for (int i = 0; i < h; i++)
cin >> mp[i];
ans = "";
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
check(j, i);
if (ans.size() == 0)
ans = "0";
cout << ans << endl;
}
return 0;
} | #include <iostream>
#include <set>
#include <string>
using namespace std;
string mp[11];
int w, h;
set<string> cnt;
string ans;
void check(int x, int y) {
string str;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (i == 0 && j == 0)
continue;
str = mp[y][x];
int nx = (x + j + w) % w, ny = (y + i + h) % h;
while (ny != y || nx != x) {
str += mp[ny][nx], nx = (nx + j + w) % w, ny = (ny + i + h) % h;
if (cnt.count(str)) {
if (str.size() > ans.size())
ans = str;
else if (str.size() == ans.size())
ans = min(str, ans);
} else
cnt.insert(str);
}
}
}
int main() {
while (1) {
cin >> h >> w;
cnt.clear();
if (w == 0 && h == 0)
break;
for (int i = 0; i < h; i++)
cin >> mp[i];
ans = "";
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
check(j, i);
if (ans.size() == 0)
ans = "0";
cout << ans << endl;
}
return 0;
} | insert | 32 | 32 | 32 | 33 | MLE | |
p00895 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
// assign
string comp(string a, string b);
signed main() {
int n, m;
while (cin >> n >> m, n) {
vector<string> donut(n);
rep(i, n) { cin >> donut[i]; }
set<string> can;
string ans = "z";
rep(i, n) {
rep(j, m) {
rep(k, 8) {
vvb used(n, vb(m, false));
string spell;
int x = i, y = j;
while (!used[x][y]) {
spell.pb(donut[x][y]);
used[x][y] = true;
if (can.find(spell) != can.end()) {
ans = comp(ans, spell);
} else {
can.insert(spell);
}
x = (x + dx[k] + n) % n;
y = (y + dy[k] + m) % m;
}
}
}
}
cout << ((ans.length() > 1) ? ans : 0) << endl;
}
return 0;
}
string comp(string a, string b) {
if (a.length() < b.length()) {
return b;
} else if (a.length() > b.length()) {
return a;
} else {
rep(i, a.length()) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i]) {
return b;
}
}
}
return a;
} | #include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
// assign
string comp(string a, string b);
signed main() {
int n, m;
while (cin >> n >> m, n) {
vector<string> donut(n);
rep(i, n) { cin >> donut[i]; }
set<string> can;
string ans = "z";
rep(i, n) {
rep(j, m) {
rep(k, 8) {
vvb used(n, vb(m, false));
string spell;
int x = i, y = j;
while (!used[x][y]) {
spell.pb(donut[x][y]);
used[x][y] = true;
if (can.find(spell) != can.end()) {
ans = comp(ans, spell);
} else {
can.insert(spell);
}
x = (x + dx[k] + n) % n;
y = (y + dy[k] + m) % m;
}
}
}
}
cout << ((ans.length() > 1) ? ans : "0") << endl;
}
return 0;
}
string comp(string a, string b) {
if (a.length() < b.length()) {
return b;
} else if (a.length() > b.length()) {
return a;
} else {
rep(i, a.length()) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i]) {
return b;
}
}
}
return a;
} | replace | 58 | 59 | 58 | 59 | -6 | terminate called after throwing an instance of 'std::logic_error'
what(): basic_string: construction from null is not valid
|
p00895 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> inline T sqr(T x) { return x * x; }
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define exist(s, e) ((s).find(e) != (s).end())
#define range(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) range(i, 0, n)
#define clr(a, b) memset((a), (b), sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define x first
#define y second
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF = 1LL << 62;
const int inf = 1 << 29;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int main(void) {
for (int w, h; cin >> h >> w, h;) {
vs strs(h);
rep(y, h) { cin >> strs[y]; }
set<string> s;
string res = "0";
rep(y, h) {
rep(x, w) {
rep(i, 8) {
string cur;
pii next = mp(x, y);
do {
cur.pb(strs[next.y][next.x]);
if (1 < cur.size() && !s.insert(cur).second) {
if ((res.size() < cur.size()) ||
(res.size() == cur.size() && cur < res)) {
res = cur;
}
}
next.x = (next.x + dx[i] + w) % w;
next.y = (next.y + dy[i] + h) % h;
debug(cur);
} while (next != mp(x, y));
}
}
}
cout << res << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toString(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
template <class T> inline T sqr(T x) { return x * x; }
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define all(a) (a).begin(), (a).end()
#define rall(a) (a).rbegin(), (a).rend()
#define pb push_back
#define mp make_pair
#define each(i, c) \
for (typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define exist(s, e) ((s).find(e) != (s).end())
#define range(i, a, b) for (int i = (a); i < (b); ++i)
#define rep(i, n) range(i, 0, n)
#define clr(a, b) memset((a), (b), sizeof(a))
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define x first
#define y second
const double eps = 1e-10;
const double pi = acos(-1.0);
const ll INF = 1LL << 62;
const int inf = 1 << 29;
int dx[] = {1, 1, 0, -1, -1, -1, 0, 1};
int dy[] = {0, 1, 1, 1, 0, -1, -1, -1};
int main(void) {
for (int w, h; cin >> h >> w, h;) {
vs strs(h);
rep(y, h) { cin >> strs[y]; }
set<string> s;
string res = "0";
rep(y, h) {
rep(x, w) {
rep(i, 8) {
string cur;
pii next = mp(x, y);
do {
cur.pb(strs[next.y][next.x]);
if (1 < cur.size() && !s.insert(cur).second) {
if ((res.size() < cur.size()) ||
(res.size() == cur.size() && cur < res)) {
res = cur;
}
}
next.x = (next.x + dx[i] + w) % w;
next.y = (next.y + dy[i] + h) % h;
} while (next != mp(x, y));
}
}
}
cout << res << endl;
}
return 0;
} | delete | 95 | 96 | 95 | 95 | TLE | |
p00896 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define reep(i, a, b) for (int i = a; i < b; i++)
vector<string> func(string input) {
vector<string> ret;
stringstream ss;
ss << input;
string s;
vector<pair<int, string>> tmp;
while (ss >> s) {
if (s[s.size() - 1] == '.')
s = s.substr(0, s.size() - 1);
// ret[s.size()].push_back(s);
set<char> se;
rep(i, s.size()) { se.insert(s[i]); }
tmp.push_back(make_pair(-(int)se.size(), s));
}
sort(tmp.begin(), tmp.end());
rep(i, tmp.size()) { ret.push_back(tmp[i].second); }
return ret;
}
vector<vector<int>> ans;
vector<vector<string>> vv;
bool check(string &a, string &b, vector<int> tik) {
rep(i, a.size()) {
int aa = a[i] - 'A';
int bb = b[i] - 'A';
if (tik[aa] == -1 && tik[bb] == -1) {
tik[aa] = bb;
tik[bb] = aa;
} else if (tik[aa] == bb && tik[bb] == aa) {
continue;
} else {
return false;
}
}
return true;
}
void update(string &a, string &b, vector<int> &tik) {
/*cout<<a<<" "<<b<<endl;
rep(i,26) cout<<tik[i]<<" ";
cout<<endl;
*/
rep(i, a.size()) {
int aa = a[i] - 'A';
int bb = b[i] - 'A';
if (tik[aa] == -1 && tik[bb] == -1) {
tik[aa] = bb;
tik[bb] = aa;
}
}
/*
rep(i,26) cout<<tik[i]<<" ";
cout<<endl;
*/
}
void saiki(int x, vector<string> &w, vector<int> tik) {
if (x == w.size()) {
ans.push_back(tik);
return;
}
string &s = w[x];
rep(i, vv[s.size()].size()) {
if (check(s, vv[s.size()][i], tik)) {
vector<int> tmp = tik;
update(s, vv[s.size()][i], tik);
saiki(x + 1, w, tik);
tik = tmp;
}
}
}
int main() {
int n;
while (cin >> n, n) {
// cout<<n<<endl;
vv = vector<vector<string>>(21);
rep(i, n) {
string s;
cin >> s;
vv[s.size()].push_back(s);
}
string input;
getline(cin, input);
getline(cin, input);
// cout<<input<<endl;
// return 0;
/*
vector<vector<string> > in = func(input);
rep(i,21){
sort(in[i].begin(), in[i].end());
in[i].erase(unique(in[i].begin(), in[i].end()), in[i].end());
}
*/
vector<string> w = func(input);
/*
for(int i=20; i>=1; i--){
rep(j,in[i].size()){
w.push_back(in[i][j]);
}
}
*/
vector<int> tik(26, -1);
ans.clear();
saiki(0, w, tik);
if (ans.size() > 1) {
cout << "-." << endl;
} else {
vector<int> tik = ans[0];
/*cout<<"ttt "<<endl;
rep(i,26){
cout<<t[i]<<" ";
}
cout<<endl;
*/
rep(i, input.size()) {
if (isupper(input[i])) {
// cout<<input[i]<<" "<<tik[input[i]-'A']<<endl;;
cout << char(tik[input[i] - 'A'] + 'A');
} else {
cout << input[i];
}
}
cout << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define reep(i, a, b) for (int i = a; i < b; i++)
vector<string> func(string input) {
vector<string> ret;
stringstream ss;
ss << input;
string s;
vector<pair<int, string>> tmp;
while (ss >> s) {
if (s[s.size() - 1] == '.')
s = s.substr(0, s.size() - 1);
// ret[s.size()].push_back(s);
set<char> se;
rep(i, s.size()) { se.insert(s[i]); }
tmp.push_back(make_pair(-(int)se.size(), s));
}
sort(tmp.begin(), tmp.end());
rep(i, tmp.size()) { ret.push_back(tmp[i].second); }
return ret;
}
vector<vector<int>> ans;
vector<vector<string>> vv;
bool check(string &a, string &b, vector<int> tik) {
rep(i, a.size()) {
int aa = a[i] - 'A';
int bb = b[i] - 'A';
if (tik[aa] == -1 && tik[bb] == -1) {
tik[aa] = bb;
tik[bb] = aa;
} else if (tik[aa] == bb && tik[bb] == aa) {
continue;
} else {
return false;
}
}
return true;
}
void update(string &a, string &b, vector<int> &tik) {
/*cout<<a<<" "<<b<<endl;
rep(i,26) cout<<tik[i]<<" ";
cout<<endl;
*/
rep(i, a.size()) {
int aa = a[i] - 'A';
int bb = b[i] - 'A';
if (tik[aa] == -1 && tik[bb] == -1) {
tik[aa] = bb;
tik[bb] = aa;
}
}
/*
rep(i,26) cout<<tik[i]<<" ";
cout<<endl;
*/
}
void saiki(int x, vector<string> &w, vector<int> tik) {
if (x == w.size()) {
ans.push_back(tik);
return;
}
string &s = w[x];
if (ans.size() >= 2)
return;
rep(i, vv[s.size()].size()) {
if (check(s, vv[s.size()][i], tik)) {
vector<int> tmp = tik;
update(s, vv[s.size()][i], tik);
saiki(x + 1, w, tik);
tik = tmp;
}
}
}
int main() {
int n;
while (cin >> n, n) {
// cout<<n<<endl;
vv = vector<vector<string>>(21);
rep(i, n) {
string s;
cin >> s;
vv[s.size()].push_back(s);
}
string input;
getline(cin, input);
getline(cin, input);
// cout<<input<<endl;
// return 0;
/*
vector<vector<string> > in = func(input);
rep(i,21){
sort(in[i].begin(), in[i].end());
in[i].erase(unique(in[i].begin(), in[i].end()), in[i].end());
}
*/
vector<string> w = func(input);
/*
for(int i=20; i>=1; i--){
rep(j,in[i].size()){
w.push_back(in[i][j]);
}
}
*/
vector<int> tik(26, -1);
ans.clear();
saiki(0, w, tik);
if (ans.size() > 1) {
cout << "-." << endl;
} else {
vector<int> tik = ans[0];
/*cout<<"ttt "<<endl;
rep(i,26){
cout<<t[i]<<" ";
}
cout<<endl;
*/
rep(i, input.size()) {
if (isupper(input[i])) {
// cout<<input[i]<<" "<<tik[input[i]-'A']<<endl;;
cout << char(tik[input[i] - 'A'] + 'A');
} else {
cout << input[i];
}
}
cout << endl;
}
}
} | insert | 70 | 70 | 70 | 72 | MLE | |
p00896 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int n;
vector<string> word;
vector<string> seq;
map<char, int> mp;
map<char, char> conv;
vector<pair<int, char>> ord;
string ans;
int num;
bool check() {
rep(i, seq.size()) {
bool flag = false;
rep(j, word.size()) {
if (word[j].size() != seq[i].size())
continue;
bool flag2 = true;
rep(k, seq[i].size()) {
if (conv[seq[i][k]] == '$')
continue;
if (conv[seq[i][k]] != word[j][k])
flag2 = false;
}
if (flag2)
flag = true;
}
if (!flag)
return false;
}
return true;
}
void dfs(int idx) {
// for(auto p : conv) {
// cout << p.first << " " << p.second << endl;
//}
// cout << check() << endl;
if (!check())
return;
if (idx == ord.size()) {
string tmp = "";
rep(i, seq.size()) {
if (i)
tmp += " ";
rep(j, seq[i].size()) { tmp += conv[seq[i][j]]; }
}
ans = tmp;
num++;
return;
}
if (conv[ord[idx].second] != '$') {
dfs(idx + 1);
return;
}
/// cout << ord[idx].second << endl;
rep(i, 26) {
if (conv[(char)('A' + i)] != '$')
continue;
conv[ord[idx].second] = (char)('A' + i);
conv[(char)('A' + i)] = ord[idx].second;
dfs(idx + 1);
conv[ord[idx].second] = '$';
conv[(char)('A' + i)] = '$';
}
}
signed main() {
while (cin >> n, n) {
word.clear();
word.resize(n);
rep(i, n) cin >> word[i];
seq.clear();
while (1) {
string s;
cin >> s;
seq.push_back(s);
if (s.back() == '.') {
seq[seq.size() - 1].pop_back();
break;
}
}
ord.clear();
mp.clear();
conv.clear();
rep(i, seq.size()) rep(j, seq[i].size()) {
if (seq[i][j] == '.')
continue;
mp[seq[i][j]]++;
}
for (auto p : mp) {
ord.push_back(make_pair(p.second, p.first));
}
sort(ord.begin(), ord.end(), greater<pair<int, int>>());
ans = "-";
rep(i, 26) conv[(char)('A' + i)] = '$';
conv['.'] = '.';
num = 0;
dfs(0);
// cout << num << endl;
if (num != 1)
ans = "-";
cout << ans + "." << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int n;
vector<string> word;
vector<string> seq;
map<char, int> mp;
map<char, char> conv;
vector<pair<int, char>> ord;
string ans;
int num;
bool check() {
rep(i, seq.size()) {
bool flag = false;
rep(j, word.size()) {
if (word[j].size() != seq[i].size())
continue;
bool flag2 = true;
rep(k, seq[i].size()) {
if (conv[seq[i][k]] == '$')
continue;
if (conv[seq[i][k]] != word[j][k])
flag2 = false;
}
if (flag2)
flag = true;
}
if (!flag)
return false;
}
return true;
}
void dfs(int idx) {
// for(auto p : conv) {
// cout << p.first << " " << p.second << endl;
//}
// cout << check() << endl;
if (!check())
return;
if (idx == ord.size()) {
string tmp = "";
rep(i, seq.size()) {
if (i)
tmp += " ";
rep(j, seq[i].size()) { tmp += conv[seq[i][j]]; }
}
ans = tmp;
num++;
return;
}
if (conv[ord[idx].second] != '$') {
dfs(idx + 1);
return;
}
/// cout << ord[idx].second << endl;
rep(i, 26) {
if (conv[(char)('A' + i)] != '$')
continue;
conv[ord[idx].second] = (char)('A' + i);
conv[(char)('A' + i)] = ord[idx].second;
dfs(idx + 1);
if (num > 1)
return;
conv[ord[idx].second] = '$';
conv[(char)('A' + i)] = '$';
}
}
signed main() {
while (cin >> n, n) {
word.clear();
word.resize(n);
rep(i, n) cin >> word[i];
seq.clear();
while (1) {
string s;
cin >> s;
seq.push_back(s);
if (s.back() == '.') {
seq[seq.size() - 1].pop_back();
break;
}
}
ord.clear();
mp.clear();
conv.clear();
rep(i, seq.size()) rep(j, seq[i].size()) {
if (seq[i][j] == '.')
continue;
mp[seq[i][j]]++;
}
for (auto p : mp) {
ord.push_back(make_pair(p.second, p.first));
}
sort(ord.begin(), ord.end(), greater<pair<int, int>>());
ans = "-";
rep(i, 26) conv[(char)('A' + i)] = '$';
conv['.'] = '.';
num = 0;
dfs(0);
// cout << num << endl;
if (num != 1)
ans = "-";
cout << ans + "." << endl;
}
return 0;
} | insert | 66 | 66 | 66 | 68 | TLE | |
p00896 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
constexpr int MAX_M = 50;
constexpr int MAX_LENGTH = 20;
int n, m;
string target;
vector<string> candidates[MAX_LENGTH];
pair<int, string> words[MAX_M];
vector<char> assign(128, -1);
int cnt;
bool dfs(int idx = 0) {
if (idx == m) {
if (++cnt == 1) {
for (auto &c : target) {
if (c != ' ')
c = assign[c];
}
return true;
} else {
return false;
}
}
const auto &s = words[idx].second;
for (const auto &t : candidates[s.size()]) {
auto tmp(assign);
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
if (!(tmp[s[i]] == t[i] || (tmp[s[i]] == -1 && tmp[t[i]] == -1))) {
goto next;
}
tmp[s[i]] = t[i];
tmp[t[i]] = s[i];
}
assign.swap(tmp);
if (!dfs(idx + 1))
return false;
assign = move(tmp);
next:;
}
return true;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
while (cin >> n && n) {
for_each(begin(candidates), end(candidates),
[](vector<string> &v) { v.clear(); });
for (int i = 0; i < n; ++i) {
string in;
cin >> in;
const int len = in.size();
candidates[len].emplace_back(move(in));
}
cin.ignore();
getline(cin, target);
target = target.substr(0, target.size() - 1);
{
string in;
istringstream iss(target);
for (m = 0; iss >> in; ++m) {
words[m].second = in;
in.erase(unique(in.begin(), in.end()), in.end());
words[m].first = in.size();
}
}
sort(words, words + m, greater<pair<int, string>>());
cnt = 0;
fill(begin(assign), end(assign), -1);
dfs();
cout << (cnt == 1 ? target : "-") << ".\n";
}
return EXIT_SUCCESS;
} | #include <algorithm>
#include <array>
#include <cstdlib>
#include <functional>
#include <iostream>
#include <sstream>
#include <vector>
using namespace std;
constexpr int MAX_M = 50;
constexpr int MAX_LENGTH = 20;
int n, m;
string target;
vector<string> candidates[MAX_LENGTH + 1];
pair<int, string> words[MAX_M];
vector<char> assign(128, -1);
int cnt;
bool dfs(int idx = 0) {
if (idx == m) {
if (++cnt == 1) {
for (auto &c : target) {
if (c != ' ')
c = assign[c];
}
return true;
} else {
return false;
}
}
const auto &s = words[idx].second;
for (const auto &t : candidates[s.size()]) {
auto tmp(assign);
for (int i = 0; i < static_cast<int>(s.size()); ++i) {
if (!(tmp[s[i]] == t[i] || (tmp[s[i]] == -1 && tmp[t[i]] == -1))) {
goto next;
}
tmp[s[i]] = t[i];
tmp[t[i]] = s[i];
}
assign.swap(tmp);
if (!dfs(idx + 1))
return false;
assign = move(tmp);
next:;
}
return true;
}
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
while (cin >> n && n) {
for_each(begin(candidates), end(candidates),
[](vector<string> &v) { v.clear(); });
for (int i = 0; i < n; ++i) {
string in;
cin >> in;
const int len = in.size();
candidates[len].emplace_back(move(in));
}
cin.ignore();
getline(cin, target);
target = target.substr(0, target.size() - 1);
{
string in;
istringstream iss(target);
for (m = 0; iss >> in; ++m) {
words[m].second = in;
in.erase(unique(in.begin(), in.end()), in.end());
words[m].first = in.size();
}
}
sort(words, words + m, greater<pair<int, string>>());
cnt = 0;
fill(begin(assign), end(assign), -1);
dfs();
cout << (cnt == 1 ? target : "-") << ".\n";
}
return EXIT_SUCCESS;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p00896 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define all(c) (c).begin(), (c).end()
#define fs first
#define sc second
#define pb push_back
#define show(x) cout << #x << " " << x << endl
typedef pair<string, int> Psi;
typedef vector<int> Vi;
int N;
vector<string> ss, words[21];
vector<Psi> vpsi;
Vi ans;
bool app[26];
void init() {
ans.clear();
ss.clear();
rep(i, 21) words[i].clear();
vpsi.clear();
rep(i, 26) app[i] = 0;
}
const bool lencomp(Psi x, Psi y) { return x.fs.size() > y.fs.size(); }
inline bool eq(Vi &a, Vi &b) {
rep(i, 26) if (app[i] && a[i] != b[i]) return 0;
return 1;
}
bool dfs(int x, Vi vi) {
if (x == ss.size()) {
if (!ans.empty() && !eq(ans, vi))
return false;
ans = vi;
return true;
}
string s = ss[x];
int L = s.size();
for (string w : words[L]) {
Vi nvi = vi;
bool ok = 1;
rep(i, L) {
if (nvi[s[i] - 'A'] >= 0 && nvi[s[i] - 'A'] + 'A' != w[i]) {
ok = 0;
break;
}
if (nvi[w[i] - 'A'] >= 0 && nvi[w[i] - 'A'] + 'A' != s[i]) {
ok = 0;
break;
}
nvi[s[i] - 'A'] = w[i] - 'A';
nvi[w[i] - 'A'] = s[i] - 'A';
}
if (!ok)
continue;
if (!dfs(x + 1, nvi))
return false;
}
return true;
}
int main() {
while (true) {
cin >> N;
if (N == 0)
break;
init();
rep(i, N) {
string s;
cin >> s;
words[s.size()].pb(s);
}
int I = 0;
while (true) {
string s;
cin >> s;
rep(i, s.size()) if (s[i] != '.') app[s[i] - 'A'] = 1;
if (s.back() == '.') {
vpsi.pb(Psi(s.substr(0, s.size() - 1), I++));
break;
}
vpsi.pb(Psi(s, I++));
}
sort(all(vpsi), lencomp);
for (Psi psi : vpsi)
ss.pb(psi.fs);
if (dfs(0, Vi(26, -1)) && !ans.empty()) {
vector<string> vst(ss.size());
rep(i, ss.size()) vst[vpsi[i].sc] = ss[i];
rep(i, vst.size()) {
rep(j, vst[i].size()) { cout << (char)(ans[vst[i][j] - 'A'] + 'A'); }
cout << (i + 1 == vst.size() ? ".\n" : " ");
}
} else {
puts("-.");
}
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define all(c) (c).begin(), (c).end()
#define fs first
#define sc second
#define pb push_back
#define show(x) cout << #x << " " << x << endl
typedef pair<string, int> Psi;
typedef vector<int> Vi;
int N;
vector<string> ss, words[21];
vector<Psi> vpsi;
Vi ans;
bool app[26];
void init() {
ans.clear();
ss.clear();
rep(i, 21) words[i].clear();
vpsi.clear();
rep(i, 26) app[i] = 0;
}
const bool lencomp(Psi x, Psi y) {
string s = x.fs, t = y.fs;
bool a[26] = {}, b[26] = {};
rep(i, s.size()) a[s[i] - 'A'] = 1;
rep(i, t.size()) b[t[i] - 'A'] = 1;
int c = 0, d = 0;
rep(i, 26) if (a[i]) c++;
rep(i, 26) if (b[i]) d++;
return c > d;
}
inline bool eq(Vi &a, Vi &b) {
rep(i, 26) if (app[i] && a[i] != b[i]) return 0;
return 1;
}
bool dfs(int x, Vi vi) {
if (x == ss.size()) {
if (!ans.empty() && !eq(ans, vi))
return false;
ans = vi;
return true;
}
string s = ss[x];
int L = s.size();
for (string w : words[L]) {
Vi nvi = vi;
bool ok = 1;
rep(i, L) {
if (nvi[s[i] - 'A'] >= 0 && nvi[s[i] - 'A'] + 'A' != w[i]) {
ok = 0;
break;
}
if (nvi[w[i] - 'A'] >= 0 && nvi[w[i] - 'A'] + 'A' != s[i]) {
ok = 0;
break;
}
nvi[s[i] - 'A'] = w[i] - 'A';
nvi[w[i] - 'A'] = s[i] - 'A';
}
if (!ok)
continue;
if (!dfs(x + 1, nvi))
return false;
}
return true;
}
int main() {
while (true) {
cin >> N;
if (N == 0)
break;
init();
rep(i, N) {
string s;
cin >> s;
words[s.size()].pb(s);
}
int I = 0;
while (true) {
string s;
cin >> s;
rep(i, s.size()) if (s[i] != '.') app[s[i] - 'A'] = 1;
if (s.back() == '.') {
vpsi.pb(Psi(s.substr(0, s.size() - 1), I++));
break;
}
vpsi.pb(Psi(s, I++));
}
sort(all(vpsi), lencomp);
for (Psi psi : vpsi)
ss.pb(psi.fs);
if (dfs(0, Vi(26, -1)) && !ans.empty()) {
vector<string> vst(ss.size());
rep(i, ss.size()) vst[vpsi[i].sc] = ss[i];
rep(i, vst.size()) {
rep(j, vst[i].size()) { cout << (char)(ans[vst[i][j] - 'A'] + 'A'); }
cout << (i + 1 == vst.size() ? ".\n" : " ");
}
} else {
puts("-.");
}
}
} | replace | 23 | 24 | 23 | 33 | TLE | |
p00896 | C++ | Runtime Error | #pragma GCC optimize "O3"
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 20;
int n, ans;
string tmp, ans_rev;
vector<string> words[N + 1], cands[N + 1];
// vector<bool> vis[N+1];
void init() {
for (int i = 0; i <= N; ++i)
words[i].clear(), cands[i].clear(); //, vis[i].clear();
ans = 0;
}
bool valid(const string &tar, const string &s, string &rev) {
assert(s.size() == tar.size());
for (size_t i = 0; i < s.size(); ++i) {
if (rev[s[i]] != -1 && rev[s[i]] != tar[i])
return false;
if (rev[tar[i]] != -1 && rev[tar[i]] != s[i])
return false;
if (rev[s[i]] == -1 && rev[tar[i]] != -1)
return false;
if (rev[tar[i]] == -1 && rev[s[i]] != -1)
return false;
}
return true;
}
void dfs(int l, size_t x, string rev) {
if (ans > 1)
return;
while (l && x >= words[l].size()) {
x = 0;
--l;
}
if (l == 0) {
ans_rev = rev;
++ans;
return;
}
const string &tar = words[l][x];
for (size_t j = 0; j < cands[l].size(); ++j) {
// if(vis[l][j])
// continue;
const string &s = cands[l][j];
if (valid(tar, s, rev)) {
string nrev = rev;
for (size_t i = 0; i < s.size(); ++i) {
nrev[s[i]] = tar[i];
nrev[tar[i]] = s[i];
}
// vis[l][j] = true;
dfs(l, x + 1, nrev);
// vis[l][j] = false;
}
}
}
void cleanup(vector<string> &v) {
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()));
}
void solve() {
init();
for (int i = 0; i < n; ++i) {
cin >> tmp;
for_each(tmp.begin(), tmp.end(), [](char &c) { c -= 'A'; });
cands[tmp.size()].push_back(tmp);
}
// for(int i = 0; i<=N; ++i)
// vis[i].resize(cands[i].size());
vector<string> sent;
bool cont = true;
while (cont) {
cin >> tmp;
if (tmp.back() == '.') {
tmp.pop_back();
cont = false;
}
sent.push_back(tmp);
for_each(tmp.begin(), tmp.end(), [](char &c) { c -= 'A'; });
words[tmp.size()].push_back(tmp);
}
for (int i = 0; i <= N; ++i)
cleanup(words[i]);
dfs(N, 0, string(26, -1));
assert(ans > 0);
if (ans == 1) {
for (auto c : ans_rev)
if (c != -1) {
assert(c == ans_rev[ans_rev[c]]);
}
for (size_t i = 0; i < sent.size(); ++i) {
for (auto c : sent[i])
putchar(ans_rev[c - 'A'] == -1 ? c : ans_rev[c - 'A'] + 'A');
putchar(i + 1 == sent.size() ? '.' : ' ');
}
puts("");
} else
puts("-.");
}
int main() {
while (scanf("%d", &n) == 1 && n)
solve();
} | #pragma GCC optimize "O3"
#include <bits/stdc++.h>
using namespace std;
constexpr int N = 20;
int n, ans;
string tmp, ans_rev;
vector<string> words[N + 1], cands[N + 1];
// vector<bool> vis[N+1];
void init() {
for (int i = 0; i <= N; ++i)
words[i].clear(), cands[i].clear(); //, vis[i].clear();
ans = 0;
}
bool valid(const string &tar, const string &s, string &rev) {
assert(s.size() == tar.size());
for (size_t i = 0; i < s.size(); ++i) {
if (rev[s[i]] != -1 && rev[s[i]] != tar[i])
return false;
if (rev[tar[i]] != -1 && rev[tar[i]] != s[i])
return false;
if (rev[s[i]] == -1 && rev[tar[i]] != -1)
return false;
if (rev[tar[i]] == -1 && rev[s[i]] != -1)
return false;
}
return true;
}
void dfs(int l, size_t x, string rev) {
if (ans > 1)
return;
while (l && x >= words[l].size()) {
x = 0;
--l;
}
if (l == 0) {
ans_rev = rev;
++ans;
return;
}
const string &tar = words[l][x];
for (size_t j = 0; j < cands[l].size(); ++j) {
// if(vis[l][j])
// continue;
const string &s = cands[l][j];
if (valid(tar, s, rev)) {
string nrev = rev;
for (size_t i = 0; i < s.size(); ++i) {
nrev[s[i]] = tar[i];
nrev[tar[i]] = s[i];
}
// vis[l][j] = true;
dfs(l, x + 1, nrev);
// vis[l][j] = false;
}
}
}
void cleanup(vector<string> &v) {
sort(v.begin(), v.end());
v.resize(unique(v.begin(), v.end()) - v.begin());
}
void solve() {
init();
for (int i = 0; i < n; ++i) {
cin >> tmp;
for_each(tmp.begin(), tmp.end(), [](char &c) { c -= 'A'; });
cands[tmp.size()].push_back(tmp);
}
// for(int i = 0; i<=N; ++i)
// vis[i].resize(cands[i].size());
vector<string> sent;
bool cont = true;
while (cont) {
cin >> tmp;
if (tmp.back() == '.') {
tmp.pop_back();
cont = false;
}
sent.push_back(tmp);
for_each(tmp.begin(), tmp.end(), [](char &c) { c -= 'A'; });
words[tmp.size()].push_back(tmp);
}
for (int i = 0; i <= N; ++i)
cleanup(words[i]);
dfs(N, 0, string(26, -1));
assert(ans > 0);
if (ans == 1) {
for (auto c : ans_rev)
if (c != -1) {
assert(c == ans_rev[ans_rev[c]]);
}
for (size_t i = 0; i < sent.size(); ++i) {
for (auto c : sent[i])
putchar(ans_rev[c - 'A'] == -1 ? c : ans_rev[c - 'A'] + 'A');
putchar(i + 1 == sent.size() ? '.' : ' ');
}
puts("");
} else
puts("-.");
}
int main() {
while (scanf("%d", &n) == 1 && n)
solve();
} | replace | 63 | 64 | 63 | 64 | -11 | |
p00896 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
string t, ans;
vector<string> words, latte[21];
bool rec(int idx, vector<char> &add) {
if (idx == words.size()) {
if (!ans.empty())
return (false);
ans = t;
for (auto &c : ans)
if (isalpha(c))
c = add[c - 'A'];
return (true);
}
const string &beet = words[idx];
for (auto &str : latte[beet.size()]) {
auto temp(add);
bool flag = true;
for (int i = 0; i < beet.size() && flag; i++) {
if (temp[beet[i] - 'A'] != str[i] &&
(temp[beet[i] - 'A'] != -1 || temp[str[i] - 'A'] != -1))
flag = false;
else {
temp[beet[i] - 'A'] = str[i];
temp[str[i] - 'A'] = beet[i];
}
}
if (!flag)
continue;
if (!rec(idx + 1, temp))
return (false);
}
return (true);
}
int main() {
int N;
while (cin >> N, N) {
for (int i = 0; i < N; i++) {
string s;
cin >> s;
latte[s.size()].emplace_back(s);
}
cin.ignore();
getline(cin, t);
istringstream sss(t);
string q;
while (sss >> q) {
if (q.back() == '.')
q.pop_back();
words.emplace_back(q);
}
sort(begin(words), end(words), [&](const string &a, const string &b) {
return (a.size() < b.size());
});
vector<char> add(26, -1);
if (rec(0, add))
cout << ans << endl;
else
cout << "-.\n";
for (int i = 0; i < 21; i++)
latte[i].clear();
words.clear();
ans.clear();
}
} | #include <bits/stdc++.h>
using namespace std;
string t, ans;
vector<string> words, latte[21];
bool rec(int idx, vector<char> &add) {
if (idx == words.size()) {
if (!ans.empty())
return (false);
ans = t;
for (auto &c : ans)
if (isalpha(c))
c = add[c - 'A'];
return (true);
}
const string &beet = words[idx];
for (auto &str : latte[beet.size()]) {
auto temp(add);
bool flag = true;
for (int i = 0; i < beet.size() && flag; i++) {
if (temp[beet[i] - 'A'] != str[i] &&
(temp[beet[i] - 'A'] != -1 || temp[str[i] - 'A'] != -1))
flag = false;
else {
temp[beet[i] - 'A'] = str[i];
temp[str[i] - 'A'] = beet[i];
}
}
if (!flag)
continue;
if (!rec(idx + 1, temp))
return (false);
}
return (true);
}
int main() {
int N;
while (cin >> N, N) {
for (int i = 0; i < N; i++) {
string s;
cin >> s;
latte[s.size()].emplace_back(s);
}
cin.ignore();
getline(cin, t);
istringstream sss(t);
string q;
while (sss >> q) {
if (q.back() == '.')
q.pop_back();
words.emplace_back(q);
}
sort(begin(words), end(words), [&](const string &a, const string &b) {
return (set<char>(begin(a), end(a)).size() >
set<char>(begin(b), end(b)).size());
});
vector<char> add(26, -1);
if (rec(0, add))
cout << ans << endl;
else
cout << "-.\n";
for (int i = 0; i < 21; i++)
latte[i].clear();
words.clear();
ans.clear();
}
} | replace | 58 | 59 | 58 | 60 | TLE | |
p00897 | C++ | Time Limit Exceeded | // 17
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct E {
string t;
int d;
};
struct S {
string v;
int r, d;
bool operator<(S a) const { return d > a.d; }
};
int main() {
for (int n, mm, cap; cin >> n >> mm >> cap, n | mm | cap;) {
cap *= 10;
string src, dest;
cin >> src >> dest;
map<string, vector<E>> m;
for (int i = 0; i < n; i++) {
string c[2];
int d;
cin >> c[0] >> c[1] >> d;
for (int j = 0; j < 2; j++) {
E ce = {c[j ^ 1], d};
m[c[j]].push_back(ce);
}
}
set<string> gs;
for (int i = 0; i < mm; i++) {
string s;
cin >> s;
gs.insert(s);
}
priority_queue<S> que;
S is = {src, cap, 0};
que.push(is);
map<string, map<int, int>> p;
while (!que.empty()) {
S c = que.top();
if (c.v == dest)
break;
que.pop();
map<int, int>::iterator it = p[c.v].upper_bound(c.r);
if (it != p[c.v].end() && it->second <= c.d)
continue;
p[c.v][c.r] = c.d;
for (int i = 0; i < m[c.v].size(); i++) {
if (m[c.v][i].d <= c.r) {
S n = {m[c.v][i].t, c.r - m[c.v][i].d, c.d + m[c.v][i].d};
if (gs.count(n.v)) {
n.r = cap;
}
que.push(n);
}
}
}
cout << (que.empty() ? -1 : que.top().d) << endl;
}
return 0;
} | // 17
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
struct E {
string t;
int d;
};
struct S {
string v;
int r, d;
bool operator<(S a) const { return d > a.d; }
};
int main() {
for (int n, mm, cap; cin >> n >> mm >> cap, n | mm | cap;) {
cap *= 10;
string src, dest;
cin >> src >> dest;
map<string, vector<E>> m;
for (int i = 0; i < n; i++) {
string c[2];
int d;
cin >> c[0] >> c[1] >> d;
for (int j = 0; j < 2; j++) {
E ce = {c[j ^ 1], d};
m[c[j]].push_back(ce);
}
}
set<string> gs;
for (int i = 0; i < mm; i++) {
string s;
cin >> s;
gs.insert(s);
}
priority_queue<S> que;
S is = {src, cap, 0};
que.push(is);
map<string, map<int, int>> p;
while (!que.empty()) {
S c = que.top();
if (c.v == dest)
break;
que.pop();
map<int, int>::iterator it = p[c.v].upper_bound(c.r - 1);
if (it != p[c.v].end() && it->second <= c.d)
continue;
p[c.v][c.r] = c.d;
for (int i = 0; i < m[c.v].size(); i++) {
if (m[c.v][i].d <= c.r) {
S n = {m[c.v][i].t, c.r - m[c.v][i].d, c.d + m[c.v][i].d};
if (gs.count(n.v)) {
n.r = cap;
}
que.push(n);
}
}
}
cout << (que.empty() ? -1 : que.top().d) << endl;
}
return 0;
} | replace | 52 | 53 | 52 | 53 | TLE | |
p00897 | C++ | Runtime Error | #include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <vector> // container
using namespace std;
typedef long long ll;
#define ALL(c) (c).begin(), (c).end()
#define FOR(i, l, r) for (int i = (int)l; i < (int)r; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORr(i, l, r) for (int i = (int)r - 1; i >= (int)l; --i)
#define REPr(i, n) FORr(i, 0, n)
#define EACH(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
template <typename T, typename U> T pmod(T x, U M) { return (x % M + M) % M; }
typedef long long ll;
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
typedef int Cost;
Cost CINF = 1 << 28;
struct Edge {
int f, t;
Cost c;
Edge(int f, int t, Cost c) : f(f), t(t), c(c){};
bool operator<(Edge r) const { return c < r.c; }
bool operator>(Edge r) const { return c > r.c; }
};
typedef vector<vector<Edge>> Graph;
struct Task {
int prev, pos;
Cost c;
Task(int prev, int pos, Cost c) : prev(prev), pos(pos), c(c){};
bool operator>(const Task &r) const { return c > r.c; }
};
vector<Cost> dijkstra(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<Cost> d(V, CINF);
d[s] = 0;
fill(ALL(prev), -2);
priority_queue<Task, vector<Task>, greater<Task>> que;
que.push(Task(-1, s, 0)); // [ ,e,,f, ] <=> e.cost < e.cost
vector<bool> visited(V);
while (!que.empty()) {
Task task = que.top();
que.pop();
if (visited[task.pos])
continue;
visited[task.pos] = true;
prev[task.pos] = task.prev;
EACH(e, g[task.pos]) if (d[e->t] > d[e->f] + e->c) {
d[e->t] = d[e->f] + e->c;
que.push(Task(e->f, e->t, d[e->t]));
}
}
return d;
}
vector<Cost> dijkstra(const Graph &g, const int s) {
vector<int> prev(g.size());
return dijkstra(g, s, prev);
}
int main() {
cout << fixed << setprecision(15);
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int N, M, cap;
cin >> N >> M >> cap;
if (N == 0)
break;
map<string, int> m;
int S = 0;
int s;
{
string src;
cin >> src;
if (!m.count(src))
m[src] = s = S++;
}
int t;
{
string dist;
cin >> dist;
if (!m.count(dist))
m[dist] = t = S++;
}
vector<tuple<int, int, int>> es;
REP(i, N) {
string f, t;
int c;
cin >> f >> t >> c;
if (!m.count(f))
m[f] = S++;
if (!m.count(t))
m[t] = S++;
es.emplace_back(m[f], m[t], c);
}
vector<int> ss;
REP(i, M) {
string s;
cin >> s;
if (!m.count(s))
m[s] = S++;
ss.push_back(m[s]);
}
map<int, int> stoi;
int I = 0;
if (!stoi.count(s))
stoi[s] = I++;
if (!stoi.count(t))
stoi[t] = I++;
REP(i, M) if (!stoi.count(ss[i])) { stoi[ss[i]] = I++; }
map<int, int> itoS;
EACH(it, stoi) itoS[it->second] = it->first;
Graph g(S);
REP(i, N) {
cerr << es[i] << endl;
g[get<0>(es[i])].emplace_back(get<0>(es[i]), get<1>(es[i]),
get<2>(es[i]));
g[get<1>(es[i])].emplace_back(get<1>(es[i]), get<0>(es[i]),
get<2>(es[i]));
}
Graph gc(I);
REP(i, I) {
vector<Cost> cs = dijkstra(g, itoS[i]);
REP(j, S) if (stoi.count(j)) {
int ji = stoi[j];
if (cs[j] <= 10 * cap)
gc[i].emplace_back(i, ji, cs[j]);
}
}
vector<Cost> cs = dijkstra(gc, s);
if (cs[t] >= CINF)
cout << -1 << endl;
else
cout << cs[t] << endl;
}
} | #include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <tuple>
#include <vector> // container
using namespace std;
typedef long long ll;
#define ALL(c) (c).begin(), (c).end()
#define FOR(i, l, r) for (int i = (int)l; i < (int)r; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORr(i, l, r) for (int i = (int)r - 1; i >= (int)l; --i)
#define REPr(i, n) FORr(i, 0, n)
#define EACH(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end())
// debug
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
template <typename T, typename U> T pmod(T x, U M) { return (x % M + M) % M; }
typedef long long ll;
// output
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
REP(i, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
REP(i, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
os << p.first << " " << p.second;
return os;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
os << get<0>(t);
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
os << get<0>(t) << " " << get<1>(t);
return os;
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t);
return os;
}
template <typename T1, typename T2, typename T3, typename T4, typename T5,
typename T6, typename T7>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4, T5, T6, T7> &t) {
os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " " << get<3>(t)
<< " " << get<4>(t) << " " << get<5>(t) << " " << get<6>(t);
return os;
}
typedef int Cost;
Cost CINF = 1 << 28;
struct Edge {
int f, t;
Cost c;
Edge(int f, int t, Cost c) : f(f), t(t), c(c){};
bool operator<(Edge r) const { return c < r.c; }
bool operator>(Edge r) const { return c > r.c; }
};
typedef vector<vector<Edge>> Graph;
struct Task {
int prev, pos;
Cost c;
Task(int prev, int pos, Cost c) : prev(prev), pos(pos), c(c){};
bool operator>(const Task &r) const { return c > r.c; }
};
vector<Cost> dijkstra(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<Cost> d(V, CINF);
d[s] = 0;
fill(ALL(prev), -2);
priority_queue<Task, vector<Task>, greater<Task>> que;
que.push(Task(-1, s, 0)); // [ ,e,,f, ] <=> e.cost < e.cost
vector<bool> visited(V);
while (!que.empty()) {
Task task = que.top();
que.pop();
if (visited[task.pos])
continue;
visited[task.pos] = true;
prev[task.pos] = task.prev;
EACH(e, g[task.pos]) if (d[e->t] > d[e->f] + e->c) {
d[e->t] = d[e->f] + e->c;
que.push(Task(e->f, e->t, d[e->t]));
}
}
return d;
}
vector<Cost> dijkstra(const Graph &g, const int s) {
vector<int> prev(g.size());
return dijkstra(g, s, prev);
}
int main() {
cout << fixed << setprecision(15);
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int N, M, cap;
cin >> N >> M >> cap;
if (N == 0)
break;
map<string, int> m;
int S = 0;
int s;
{
string src;
cin >> src;
if (!m.count(src))
m[src] = s = S++;
}
int t;
{
string dist;
cin >> dist;
if (!m.count(dist))
m[dist] = t = S++;
}
vector<tuple<int, int, int>> es;
REP(i, N) {
string f, t;
int c;
cin >> f >> t >> c;
if (!m.count(f))
m[f] = S++;
if (!m.count(t))
m[t] = S++;
es.emplace_back(m[f], m[t], c);
}
vector<int> ss;
REP(i, M) {
string s;
cin >> s;
if (!m.count(s))
m[s] = S++;
ss.push_back(m[s]);
}
map<int, int> stoi;
int I = 0;
if (!stoi.count(s))
stoi[s] = I++;
if (!stoi.count(t))
stoi[t] = I++;
REP(i, M) if (!stoi.count(ss[i])) { stoi[ss[i]] = I++; }
map<int, int> itoS;
EACH(it, stoi) itoS[it->second] = it->first;
Graph g(S);
REP(i, N) {
// cerr << es[i] <<endl;
g[get<0>(es[i])].emplace_back(get<0>(es[i]), get<1>(es[i]),
get<2>(es[i]));
g[get<1>(es[i])].emplace_back(get<1>(es[i]), get<0>(es[i]),
get<2>(es[i]));
}
Graph gc(I);
REP(i, I) {
vector<Cost> cs = dijkstra(g, itoS[i]);
REP(j, S) if (stoi.count(j)) {
int ji = stoi[j];
if (cs[j] <= 10 * cap)
gc[i].emplace_back(i, ji, cs[j]);
}
}
vector<Cost> cs = dijkstra(gc, s);
if (cs[t] >= CINF)
cout << -1 << endl;
else
cout << cs[t] << endl;
}
} | replace | 226 | 227 | 226 | 227 | 0 | 0 2 335
0 3 174
3 4 176
4 1 195
5 2 215
5 1 296
0 2 335
0 3 174
3 4 176
4 1 195
5 2 215
5 1 296
|
p00897 | C++ | Runtime Error | #include <bits/stdc++.h>
#define INF (1e9)
#define N 3005
#define M 2005
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
int n, m, cap, d[N][M], n_max;
map<string, int> num;
string src, dest;
vector<P> G[N];
set<int> lpc;
int dijkstra(int s, int g) {
priority_queue<P1, vector<P1>, greater<P1>> q;
for (int i = 0; i < n_max; i++)
for (int j = 0; j <= cap * 10; j++)
d[i][j] = INF;
q.push(P1(0, P(s, cap * 10)));
d[s][cap * 10] = 0;
while (!q.empty()) {
P1 t = q.top();
q.pop();
int cost = t.first;
int node = t.second.first;
int c = t.second.second;
if (d[node][c] < cost)
continue;
if (node == g)
return cost;
for (int i = 0; i < G[node].size(); i++) {
int ncost = cost + G[node][i].second;
int nnode = G[node][i].first;
int nc = c - G[node][i].second;
if (nc < 0)
continue;
if (d[nnode][nc] > ncost) {
d[nnode][nc] = ncost;
q.push(P1(ncost, P(nnode, nc)));
}
if (lpc.count(nnode)) {
nc = cap * 10;
if (d[nnode][nc] > ncost) {
d[nnode][nc] = ncost;
q.push(P1(ncost, P(nnode, nc)));
}
}
}
}
return -1;
}
int main() {
while (1) {
cin >> n >> m >> cap;
if (!n && !m && !cap)
break;
cin >> src >> dest;
string a, b;
int c;
n_max = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (!num.count(a))
num[a] = n_max++;
if (!num.count(b))
num[b] = n_max++;
G[num[a]].push_back(P(num[b], c));
G[num[b]].push_back(P(num[a], c));
}
if (!num.count(src))
num[src] = n_max++;
if (!num.count(dest))
num[dest] = n_max++;
for (int i = 0; i < m; i++) {
cin >> a;
lpc.insert(num[a]);
}
int s = num[src], g = num[dest];
cout << dijkstra(s, g) << endl;
num.clear();
lpc.clear();
for (int i = 0; i < n_max; i++)
G[i].clear();
}
return 0;
} | #include <bits/stdc++.h>
#define INF (1e9)
#define N 6005
#define M 2005
using namespace std;
typedef pair<int, int> P;
typedef pair<int, P> P1;
int n, m, cap, d[N][M], n_max;
map<string, int> num;
string src, dest;
vector<P> G[N];
set<int> lpc;
int dijkstra(int s, int g) {
priority_queue<P1, vector<P1>, greater<P1>> q;
for (int i = 0; i < n_max; i++)
for (int j = 0; j <= cap * 10; j++)
d[i][j] = INF;
q.push(P1(0, P(s, cap * 10)));
d[s][cap * 10] = 0;
while (!q.empty()) {
P1 t = q.top();
q.pop();
int cost = t.first;
int node = t.second.first;
int c = t.second.second;
if (d[node][c] < cost)
continue;
if (node == g)
return cost;
for (int i = 0; i < G[node].size(); i++) {
int ncost = cost + G[node][i].second;
int nnode = G[node][i].first;
int nc = c - G[node][i].second;
if (nc < 0)
continue;
if (d[nnode][nc] > ncost) {
d[nnode][nc] = ncost;
q.push(P1(ncost, P(nnode, nc)));
}
if (lpc.count(nnode)) {
nc = cap * 10;
if (d[nnode][nc] > ncost) {
d[nnode][nc] = ncost;
q.push(P1(ncost, P(nnode, nc)));
}
}
}
}
return -1;
}
int main() {
while (1) {
cin >> n >> m >> cap;
if (!n && !m && !cap)
break;
cin >> src >> dest;
string a, b;
int c;
n_max = 0;
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
if (!num.count(a))
num[a] = n_max++;
if (!num.count(b))
num[b] = n_max++;
G[num[a]].push_back(P(num[b], c));
G[num[b]].push_back(P(num[a], c));
}
if (!num.count(src))
num[src] = n_max++;
if (!num.count(dest))
num[dest] = n_max++;
for (int i = 0; i < m; i++) {
cin >> a;
lpc.insert(num[a]);
}
int s = num[src], g = num[dest];
cout << dijkstra(s, g) << endl;
num.clear();
lpc.clear();
for (int i = 0; i < n_max; i++)
G[i].clear();
}
return 0;
} | replace | 2 | 3 | 2 | 3 | 0 | |
p00897 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
class Edge {
public:
int to, cost;
Edge(int to, int cost) : to(to), cost(cost){};
};
vector<int> dijkstra(vector<vector<Edge>> &G, int s) {
int N = G.size();
vector<int> d(N, INF);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
d[s] = 0;
q.push(make_pair(d[s], s));
while (!q.empty()) {
pair<int, int> v = q.top();
q.pop();
if (v.first != d[v.second])
continue;
for (Edge &e : G[v.second]) {
if (e.cost + d[v.second] < d[e.to]) {
d[e.to] = e.cost + d[v.second];
q.push(make_pair(d[e.to], e.to));
}
}
}
return d;
}
int N, M, C;
void solve() {
string src, dst;
cin >> src >> dst;
map<string, int> stoi;
vector<string> cs(N), cd(N);
vector<int> ds(N);
for (int i = 0; i < N; i++) {
cin >> cs[i] >> cd[i] >> ds[i];
if (stoi.find(cs[i]) == stoi.end())
stoi[cs[i]] = stoi.size();
if (stoi.find(cd[i]) == stoi.end())
stoi[cd[i]] = stoi.size();
}
vector<int> gass(M);
for (int i = 0; i < M; i++) {
string s;
cin >> s;
gass[i] = stoi[s];
}
gass.push_back(stoi[src]);
gass.push_back(stoi[dst]);
M = gass.size();
vector<vector<Edge>> G(stoi.size());
for (int i = 0; i < N; i++) {
int si = stoi[cs[i]];
int di = stoi[cd[i]];
G[si].emplace_back(di, ds[i]);
G[di].emplace_back(si, ds[i]);
}
vector<vector<int>> mat(M, vector<int>(M, INF));
for (int i = 0; i < M; i++)
mat[i][i] = 0;
for (int i = 0; i < M; i++) {
int gs = gass[i];
auto d = dijkstra(G, gs);
for (int j = 0; j < M; j++) {
int gd = gass[j];
if (d[gd] <= C * 10) {
mat[i][j] = d[gd];
mat[j][i] = d[gd];
}
}
}
for (int k = 0; k < M; k++)
for (int i = 0; i < M; i++)
for (int j = 0; j < M; j++)
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
cout << (mat[M - 2][M - 1] == INF ? -1 : mat[M - 2][M - 1]) << endl;
}
int main() {
while (cin >> N >> M >> C, N | M | C)
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
class Edge {
public:
int to, cost;
Edge(int to, int cost) : to(to), cost(cost){};
};
vector<int> dijkstra(vector<vector<Edge>> &G, int s) {
int N = G.size();
vector<int> d(N, INF);
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
q;
d[s] = 0;
q.push(make_pair(d[s], s));
while (!q.empty()) {
pair<int, int> v = q.top();
q.pop();
if (v.first != d[v.second])
continue;
for (Edge &e : G[v.second]) {
if (e.cost + d[v.second] < d[e.to]) {
d[e.to] = e.cost + d[v.second];
q.push(make_pair(d[e.to], e.to));
}
}
}
return d;
}
int N, M, C;
void solve() {
string src, dst;
cin >> src >> dst;
map<string, int> stoi;
vector<string> cs(N), cd(N);
vector<int> ds(N);
for (int i = 0; i < N; i++) {
cin >> cs[i] >> cd[i] >> ds[i];
if (stoi.find(cs[i]) == stoi.end()) {
int x = stoi.size();
stoi[cs[i]] = x;
}
if (stoi.find(cd[i]) == stoi.end()) {
int x = stoi.size();
stoi[cd[i]] = x;
}
}
vector<int> gass(M);
for (int i = 0; i < M; i++) {
string s;
cin >> s;
gass[i] = stoi[s];
}
gass.push_back(stoi[src]);
gass.push_back(stoi[dst]);
M = gass.size();
vector<vector<Edge>> G(stoi.size());
for (int i = 0; i < N; i++) {
int si = stoi[cs[i]];
int di = stoi[cd[i]];
G[si].emplace_back(di, ds[i]);
G[di].emplace_back(si, ds[i]);
}
vector<vector<int>> mat(M, vector<int>(M, INF));
for (int i = 0; i < M; i++)
mat[i][i] = 0;
for (int i = 0; i < M; i++) {
int gs = gass[i];
auto d = dijkstra(G, gs);
for (int j = 0; j < M; j++) {
int gd = gass[j];
if (d[gd] <= C * 10) {
mat[i][j] = d[gd];
mat[j][i] = d[gd];
}
}
}
for (int k = 0; k < M; k++)
for (int i = 0; i < M; i++)
for (int j = 0; j < M; j++)
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
cout << (mat[M - 2][M - 1] == INF ? -1 : mat[M - 2][M - 1]) << endl;
}
int main() {
while (cin >> N >> M >> C, N | M | C)
solve();
return 0;
} | replace | 49 | 53 | 49 | 57 | 0 | |
p00897 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define INF INT_MAX / 2
int N, M, CAP;
struct Comp {
bool operator()(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
};
// map<int, ll> dist;
// set<int> done;
// int dist[6010][2010];
// bool done[6010][2010];
// vector<vector<int> > dist;
// vector<vector<bool> > done;
int solve() {
int idx = 0;
map<string, int> m;
vector<vector<int>> dist;
vector<vector<bool>> done;
vector<pair<int, int>> E[6010];
set<int> gas;
string src, dest;
cin >> src >> dest;
m[src] = 0;
m[dest] = 1;
idx = 2;
rep(i, 0, 6010) E[i].clear();
rep(i, 0, N) {
string a, b;
cin >> a >> b;
if (m.find(a) == m.end())
m[a] = idx, idx++;
if (m.find(b) == m.end())
m[b] = idx, idx++;
int dd;
cin >> dd;
E[m[a]].push_back(make_pair(m[b], dd));
E[m[b]].push_back(make_pair(m[a], dd));
}
gas.clear();
rep(i, 0, M) {
string s;
cin >> s;
if (m.find(s) == m.end())
m[s] = idx, idx++;
gas.insert(m[s]);
}
// dist.resize(idx, vector<int>(CAP + 1, INF));
// done.resize(idx, vector<bool>(CAP + 1, false));
dist.resize(idx);
rep(i, 0, idx) dist[i] = vector<int>(CAP + 1);
rep(i, 0, idx) done[i] = vector<bool>(CAP + 1);
rep(i, 0, idx) rep(j, 0, CAP + 1) dist[i][j] = INF;
rep(i, 0, idx) rep(j, 0, CAP + 1) done[i][j] = false;
/*rep(i, 0, 6010) rep(j, 0, 2010) dist[i][j] = INF;
rep(i, 0, 6010) rep(j, 0, 2010) done[i][j] = false;*/
priority_queue<pair<int, int>, vector<pair<int, int>>, Comp> que;
// dist[CAP] = 0;
dist[0][CAP] = 0;
que.push(make_pair(CAP, 0));
while (!que.empty()) {
auto q = que.top();
que.pop();
int n = q.first / 10000;
int c = q.first % 10000;
if (n == 1) {
return q.second;
}
/*if (done.find(q.first) != done.end()) continue;
done.insert(q.first);*/
if (done[n][c])
continue;
done[n][c] = true;
for (auto p : E[n]) {
if (c < p.second)
continue;
int nn = p.first;
int nc = c - p.second;
if (gas.find(nn) != gas.end())
nc = CAP;
int nnn = nn * 10000 + nc;
int ncost = q.second + p.second;
/*if (dist.find(nnn) == dist.end()) dist[nnn] = INF;
if (ncost < dist[nnn])
{
dist[nnn] = ncost;
que.push(make_pair(nnn, ncost));
}*/
if (ncost < dist[nn][nc]) {
dist[nn][nc] = ncost;
que.push(make_pair(nnn, ncost));
}
}
}
return -1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N >> M >> CAP) {
if (N == 0)
return 0;
CAP *= 10;
cout << solve() << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for (int i = a; i < b; i++)
#define INF INT_MAX / 2
int N, M, CAP;
struct Comp {
bool operator()(pair<int, int> a, pair<int, int> b) {
return a.second > b.second;
}
};
// map<int, ll> dist;
// set<int> done;
// int dist[6010][2010];
// bool done[6010][2010];
// vector<vector<int> > dist;
// vector<vector<bool> > done;
int solve() {
int idx = 0;
map<string, int> m;
vector<vector<int>> dist;
vector<vector<bool>> done;
vector<pair<int, int>> E[6010];
set<int> gas;
string src, dest;
cin >> src >> dest;
m[src] = 0;
m[dest] = 1;
idx = 2;
rep(i, 0, 6010) E[i].clear();
rep(i, 0, N) {
string a, b;
cin >> a >> b;
if (m.find(a) == m.end())
m[a] = idx, idx++;
if (m.find(b) == m.end())
m[b] = idx, idx++;
int dd;
cin >> dd;
E[m[a]].push_back(make_pair(m[b], dd));
E[m[b]].push_back(make_pair(m[a], dd));
}
gas.clear();
rep(i, 0, M) {
string s;
cin >> s;
if (m.find(s) == m.end())
m[s] = idx, idx++;
gas.insert(m[s]);
}
// dist.resize(idx, vector<int>(CAP + 1, INF));
// done.resize(idx, vector<bool>(CAP + 1, false));
dist.resize(idx);
done.resize(idx);
rep(i, 0, idx) dist[i] = vector<int>(CAP + 1);
rep(i, 0, idx) done[i] = vector<bool>(CAP + 1);
rep(i, 0, idx) rep(j, 0, CAP + 1) dist[i][j] = INF;
rep(i, 0, idx) rep(j, 0, CAP + 1) done[i][j] = false;
/*rep(i, 0, 6010) rep(j, 0, 2010) dist[i][j] = INF;
rep(i, 0, 6010) rep(j, 0, 2010) done[i][j] = false;*/
priority_queue<pair<int, int>, vector<pair<int, int>>, Comp> que;
// dist[CAP] = 0;
dist[0][CAP] = 0;
que.push(make_pair(CAP, 0));
while (!que.empty()) {
auto q = que.top();
que.pop();
int n = q.first / 10000;
int c = q.first % 10000;
if (n == 1) {
return q.second;
}
/*if (done.find(q.first) != done.end()) continue;
done.insert(q.first);*/
if (done[n][c])
continue;
done[n][c] = true;
for (auto p : E[n]) {
if (c < p.second)
continue;
int nn = p.first;
int nc = c - p.second;
if (gas.find(nn) != gas.end())
nc = CAP;
int nnn = nn * 10000 + nc;
int ncost = q.second + p.second;
/*if (dist.find(nnn) == dist.end()) dist[nnn] = INF;
if (ncost < dist[nnn])
{
dist[nnn] = ncost;
que.push(make_pair(nnn, ncost));
}*/
if (ncost < dist[nn][nc]) {
dist[nn][nc] = ncost;
que.push(make_pair(nnn, ncost));
}
}
}
return -1;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N >> M >> CAP) {
if (N == 0)
return 0;
CAP *= 10;
cout << solve() << endl;
}
} | insert | 65 | 65 | 65 | 66 | -11 | |
p00897 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
map<string, int> mp;
const int N = 3010;
vector<P> G[N];
int lpgid[N];
const int M = 310;
int lpg[M];
int d[M][M];
void dijk(int s, int cap) {
vector<int> dist(N, 1e9);
priority_queue<P> q;
q.push(MP(0, s));
dist[s] = 0;
while (!q.empty()) {
auto p = q.top();
q.pop();
int dd = p.first;
int pos = p.second;
if (dist[pos] < dd)
continue;
if (lpgid[pos] >= 0)
d[lpgid[s]][lpgid[pos]] = dd;
for (auto edge : G[pos]) {
int nd = dd + edge.second;
int npos = edge.first;
if (dist[npos] <= nd)
continue;
dist[npos] = nd;
if (nd <= cap)
q.emplace(nd, npos);
}
}
}
int main() {
int n, m, cap;
while (cin >> n >> m >> cap, n) {
MEMSET(lpgid, -1);
MEMSET(lpg, -1);
rep(i, M) rep(j, M) if (i != j) d[i][j] = 1e9;
rep(i, N) G[i].clear();
mp.clear();
string src, dest;
cin >> src >> dest;
int num = 0;
mp[src] = num++;
mp[dest] = num++;
rep(i, n) {
string s, t;
cin >> s >> t;
if (!mp.count(s))
mp[s] = num++;
if (!mp.count(t))
mp[t] = num++;
int d;
cin >> d;
G[mp[s]].emplace_back(mp[t], d);
G[mp[t]].emplace_back(mp[s], d);
}
rep(i, m) {
string s;
cin >> s;
assert(mp.count(s) == 1);
lpgid[mp[s]] = i;
lpg[i] = mp[s];
}
lpgid[mp[src]] = m;
lpg[m] = mp[src];
lpgid[mp[dest]] = m + 1;
lpg[m + 1] = mp[dest];
rep(i, m + 2) dijk(lpg[i], cap * 10);
rep(i, m + 2) rep(j, m + 2) rep(k, m + 2) d[j][k] =
min(d[j][k], d[j][i] + d[i][k]);
int ans = d[m][m + 1];
if (ans >= 1e9)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <tuple>
#include <vector>
// BEGIN CUT HERE
#ifdef _MSC_VER
#include <agents.h>
#endif
// END CUT HERE
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(i, n) FOR(i, 0, n)
#define ALL(v) v.begin(), v.end()
#define REV(v) v.rbegin(), v.rend()
#define MEMSET(v, s) memset(v, s, sizeof(v))
#define MP make_pair
#define MT make_tuple
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
map<string, int> mp;
const int N = 10010;
vector<P> G[N];
int lpgid[N];
const int M = 310;
int lpg[M];
int d[M][M];
void dijk(int s, int cap) {
vector<int> dist(N, 1e9);
priority_queue<P> q;
q.push(MP(0, s));
dist[s] = 0;
while (!q.empty()) {
auto p = q.top();
q.pop();
int dd = p.first;
int pos = p.second;
if (dist[pos] < dd)
continue;
if (lpgid[pos] >= 0)
d[lpgid[s]][lpgid[pos]] = dd;
for (auto edge : G[pos]) {
int nd = dd + edge.second;
int npos = edge.first;
if (dist[npos] <= nd)
continue;
dist[npos] = nd;
if (nd <= cap)
q.emplace(nd, npos);
}
}
}
int main() {
int n, m, cap;
while (cin >> n >> m >> cap, n) {
MEMSET(lpgid, -1);
MEMSET(lpg, -1);
rep(i, M) rep(j, M) if (i != j) d[i][j] = 1e9;
rep(i, N) G[i].clear();
mp.clear();
string src, dest;
cin >> src >> dest;
int num = 0;
mp[src] = num++;
mp[dest] = num++;
rep(i, n) {
string s, t;
cin >> s >> t;
if (!mp.count(s))
mp[s] = num++;
if (!mp.count(t))
mp[t] = num++;
int d;
cin >> d;
G[mp[s]].emplace_back(mp[t], d);
G[mp[t]].emplace_back(mp[s], d);
}
rep(i, m) {
string s;
cin >> s;
assert(mp.count(s) == 1);
lpgid[mp[s]] = i;
lpg[i] = mp[s];
}
lpgid[mp[src]] = m;
lpg[m] = mp[src];
lpgid[mp[dest]] = m + 1;
lpg[m + 1] = mp[dest];
rep(i, m + 2) dijk(lpg[i], cap * 10);
rep(i, m + 2) rep(j, m + 2) rep(k, m + 2) d[j][k] =
min(d[j][k], d[j][i] + d[i][k]);
int ans = d[m][m + 1];
if (ans >= 1e9)
cout << -1 << endl;
else
cout << ans << endl;
}
return 0;
} | replace | 39 | 40 | 39 | 40 | 0 | |
p00897 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
int dx[] = {0, 1, 0, -1}, dy[] = {-1, 0, 1, 0};
using namespace std;
struct Edge {
int src, dst;
int weight;
Edge(int s, int d, int w) : src(s), dst(d), weight(w) {}
Edge() {}
};
using Graph = vector<vector<Edge>>;
int V, E;
int num_stand; // num of stands
string src, dst;
int cap;
Graph g;
vector<string> c1, c2;
vector<int> d;
vector<string> s;
map<string, int> m;
const int inf = 1e9;
int dist[6010][2100]; // at town i with gas j
int canCharge[6010];
int dijkstra(int s, int t) {
fill((int *)begin(dist), (int *)end(dist), inf);
priority_queue<tuple<int, int, int>> q; // -dist, town, cap
dist[s][cap] = 0;
q.emplace(0, s, cap);
while (q.size()) {
int d, v, rem;
tie(d, v, rem) = q.top();
q.pop();
d = -d;
if (v == t)
return d;
if (dist[v][rem] < d)
continue;
for (auto &e : g[v]) {
int nv = e.dst;
int nrem = rem - e.weight;
if (nrem < 0)
continue;
if (canCharge[nv]) {
nrem = cap;
}
int nd = d + e.weight;
if (dist[nv][nrem] > nd) {
dist[nv][nrem] = nd;
q.emplace(-nd, nv, nrem);
}
}
}
return 1e9;
}
int main() {
while (cin >> E >> num_stand >> cap && E) {
m.clear();
V = 0;
c1.resize(E);
c2.resize(E);
d.resize(E);
cap *= 10;
cin >> src >> dst;
if (m.count(src) == 0)
m[src] = V++;
if (m.count(dst) == 0)
m[dst] = V++;
for (int i = 0; i < E; ++i) {
cin >> c1[i] >> c2[i] >> d[i];
if (m.count(c1[i]) == 0)
m[c1[i]] = V++;
if (m.count(c2[i]) == 0)
m[c2[i]] = V++;
}
memset(canCharge, 0, sizeof(canCharge));
s.resize(num_stand);
for (int i = 0; i < num_stand; ++i) {
cin >> s[i];
canCharge[m[s[i]]] = true;
}
g.assign(V, {});
for (int i = 0; i < E; ++i) {
int a = m[c1[i]];
int b = m[c2[i]];
g[a].emplace_back(a, b, d[i]);
g[b].emplace_back(b, a, d[i]);
}
int ans = dijkstra(m[src], m[dst]);
if (ans == inf)
ans = -1;
cout << ans << endl;
}
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <string>
#include <vector>
typedef long long ll;
int dx[] = {0, 1, 0, -1}, dy[] = {-1, 0, 1, 0};
using namespace std;
struct Edge {
int src, dst;
int weight;
Edge(int s, int d, int w) : src(s), dst(d), weight(w) {}
Edge() {}
};
using Graph = vector<vector<Edge>>;
int V, E;
int num_stand; // num of stands
string src, dst;
int cap;
Graph g;
vector<string> c1, c2;
vector<int> d;
vector<string> s;
map<string, int> m;
const int inf = 1e9;
int dist[4010][2100]; // at town i with gas j
int canCharge[6010];
int dijkstra(int s, int t) {
fill((int *)begin(dist), (int *)end(dist), inf);
priority_queue<tuple<int, int, int>> q; // -dist, town, cap
dist[s][cap] = 0;
q.emplace(0, s, cap);
while (q.size()) {
int d, v, rem;
tie(d, v, rem) = q.top();
q.pop();
d = -d;
if (v == t)
return d;
if (dist[v][rem] < d)
continue;
for (auto &e : g[v]) {
int nv = e.dst;
int nrem = rem - e.weight;
if (nrem < 0)
continue;
if (canCharge[nv]) {
nrem = cap;
}
int nd = d + e.weight;
if (dist[nv][nrem] > nd) {
dist[nv][nrem] = nd;
q.emplace(-nd, nv, nrem);
}
}
}
return 1e9;
}
int main() {
while (cin >> E >> num_stand >> cap && E) {
m.clear();
V = 0;
c1.resize(E);
c2.resize(E);
d.resize(E);
cap *= 10;
cin >> src >> dst;
if (m.count(src) == 0)
m[src] = V++;
if (m.count(dst) == 0)
m[dst] = V++;
for (int i = 0; i < E; ++i) {
cin >> c1[i] >> c2[i] >> d[i];
if (m.count(c1[i]) == 0)
m[c1[i]] = V++;
if (m.count(c2[i]) == 0)
m[c2[i]] = V++;
}
memset(canCharge, 0, sizeof(canCharge));
s.resize(num_stand);
for (int i = 0; i < num_stand; ++i) {
cin >> s[i];
canCharge[m[s[i]]] = true;
}
g.assign(V, {});
for (int i = 0; i < E; ++i) {
int a = m[c1[i]];
int b = m[c2[i]];
g[a].emplace_back(a, b, d[i]);
g[b].emplace_back(b, a, d[i]);
}
int ans = dijkstra(m[src], m[dst]);
if (ans == inf)
ans = -1;
cout << ans << endl;
}
} | replace | 36 | 37 | 36 | 37 | MLE | |
p00898 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<Int, Int> P;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
vector<vector<P>> nx{{P(0, 5), P(1, 6), P(2, 7), P(3, 8), P(4, 9)},
{P(0, 1), P(4, 3), P(9, 14), P(10, 15), P(5, 11)},
{P(0, 4), P(5, 10), P(11, 16), P(6, 12), P(1, 2)},
{P(1, 0), P(6, 11), P(12, 17), P(7, 13), P(2, 3)},
{P(2, 1), P(7, 12), P(13, 18), P(8, 14), P(3, 4)},
{P(3, 2), P(8, 13), P(14, 19), P(9, 10), P(4, 0)},
{P(5, 0), P(10, 9), P(15, 19), P(16, 17), P(11, 6)},
{P(6, 1), P(11, 5), P(16, 15), P(17, 18), P(12, 7)},
{P(7, 2), P(12, 6), P(17, 16), P(18, 19), P(13, 8)},
{P(8, 3), P(13, 7), P(18, 17), P(19, 15), P(14, 9)},
{P(9, 4), P(14, 8), P(19, 18), P(15, 16), P(10, 5)},
{P(15, 10), P(19, 14), P(18, 13), P(17, 12), P(16, 11)}};
short dp[203][203][21][21][6];
struct st {
Int y, x, n, m, d;
st(Int y, Int x, Int n, Int m, Int d) : y(y), x(x), n(n), m(m), d(d) {}
};
const Int CC = 101;
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
{
memset(dp, -1, sizeof(dp));
queue<st> q;
dp[CC][CC][0][5][0] = 0;
q.emplace(CC, CC, 0, 5, 0);
Int dyl[6] = {0, 0, 1, 0, 0, -1};
Int dxl[6] = {-1, -1, 0, 1, 1, 0};
Int dyr[6] = {0, -1, 0, 0, 1, 0};
Int dxr[6] = {1, 0, -1, -1, 0, 1};
Int dyo[6] = {1, 0, 0, -1, 0, 0};
Int dxo[6] = {0, 1, 1, 0, -1, -1};
auto push = [&](st a, st b) {
if (~dp[a.y][a.x][a.n][a.m][a.d])
return;
dp[a.y][a.x][a.n][a.m][a.d] = dp[b.y][b.x][b.n][b.m][b.d] + 1;
q.emplace(a);
};
while (!q.empty()) {
st s = q.front();
q.pop();
if (dp[s.y][s.x][s.n][s.m][s.d] > 100)
break;
Int k = 0, l = 0;
for (Int i = 0; i < 12; i++)
for (Int j = 0; j < 5; j++)
if (nx[i][j] == P(s.n, s.m))
k = i, l = j;
// cout<<k<<" "<<l<<endl;
{ // L
st t = s;
t.y += dyl[s.d];
t.x += dxl[s.d];
tie(t.n, t.m) = nx[k][(l + 4) % 5];
t.d = (s.d + 5) % 6;
push(t, s);
}
{ // R
st t = s;
t.y += dyr[s.d];
t.x += dxr[s.d];
tie(t.n, t.m) = nx[k][(l + 1) % 5];
t.d = (s.d + 1) % 6;
push(t, s);
}
{ // O
st t = s;
t.y += dyo[s.d];
t.x += dxo[s.d];
swap(t.n, t.m);
t.d = (s.d + 3) % 6;
push(t, s);
}
}
}
{
Int x, y, n;
while (cin >> x >> y >> n, x || y || n) {
short ans = 101;
x += CC;
y += CC;
for (Int i = 0; i < 20; i++) {
for (Int j = 0; j < 6; j++) {
if (dp[y][x][n][i][j] < 0)
continue;
chmin(ans, dp[y][x][n][i][j]);
}
}
cout << ans << endl;
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using Int = long long;
typedef pair<Int, Int> P;
template <typename T1, typename T2> inline void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <typename T1, typename T2> inline void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
vector<vector<P>> nx{{P(0, 5), P(1, 6), P(2, 7), P(3, 8), P(4, 9)},
{P(0, 1), P(4, 3), P(9, 14), P(10, 15), P(5, 11)},
{P(0, 4), P(5, 10), P(11, 16), P(6, 12), P(1, 2)},
{P(1, 0), P(6, 11), P(12, 17), P(7, 13), P(2, 3)},
{P(2, 1), P(7, 12), P(13, 18), P(8, 14), P(3, 4)},
{P(3, 2), P(8, 13), P(14, 19), P(9, 10), P(4, 0)},
{P(5, 0), P(10, 9), P(15, 19), P(16, 17), P(11, 6)},
{P(6, 1), P(11, 5), P(16, 15), P(17, 18), P(12, 7)},
{P(7, 2), P(12, 6), P(17, 16), P(18, 19), P(13, 8)},
{P(8, 3), P(13, 7), P(18, 17), P(19, 15), P(14, 9)},
{P(9, 4), P(14, 8), P(19, 18), P(15, 16), P(10, 5)},
{P(15, 10), P(19, 14), P(18, 13), P(17, 12), P(16, 11)}};
signed char dp[203][203][21][21][6];
struct st {
Int y, x, n, m, d;
st(Int y, Int x, Int n, Int m, Int d) : y(y), x(x), n(n), m(m), d(d) {}
};
const Int CC = 101;
signed main() {
cin.tie(0);
ios::sync_with_stdio(0);
{
memset(dp, -1, sizeof(dp));
queue<st> q;
dp[CC][CC][0][5][0] = 0;
q.emplace(CC, CC, 0, 5, 0);
Int dyl[6] = {0, 0, 1, 0, 0, -1};
Int dxl[6] = {-1, -1, 0, 1, 1, 0};
Int dyr[6] = {0, -1, 0, 0, 1, 0};
Int dxr[6] = {1, 0, -1, -1, 0, 1};
Int dyo[6] = {1, 0, 0, -1, 0, 0};
Int dxo[6] = {0, 1, 1, 0, -1, -1};
auto push = [&](st a, st b) {
if (~dp[a.y][a.x][a.n][a.m][a.d])
return;
dp[a.y][a.x][a.n][a.m][a.d] = dp[b.y][b.x][b.n][b.m][b.d] + 1;
q.emplace(a);
};
while (!q.empty()) {
st s = q.front();
q.pop();
if (dp[s.y][s.x][s.n][s.m][s.d] > 100)
break;
Int k = 0, l = 0;
for (Int i = 0; i < 12; i++)
for (Int j = 0; j < 5; j++)
if (nx[i][j] == P(s.n, s.m))
k = i, l = j;
// cout<<k<<" "<<l<<endl;
{ // L
st t = s;
t.y += dyl[s.d];
t.x += dxl[s.d];
tie(t.n, t.m) = nx[k][(l + 4) % 5];
t.d = (s.d + 5) % 6;
push(t, s);
}
{ // R
st t = s;
t.y += dyr[s.d];
t.x += dxr[s.d];
tie(t.n, t.m) = nx[k][(l + 1) % 5];
t.d = (s.d + 1) % 6;
push(t, s);
}
{ // O
st t = s;
t.y += dyo[s.d];
t.x += dxo[s.d];
swap(t.n, t.m);
t.d = (s.d + 3) % 6;
push(t, s);
}
}
}
{
Int x, y, n;
while (cin >> x >> y >> n, x || y || n) {
short ans = 101;
x += CC;
y += CC;
for (Int i = 0; i < 20; i++) {
for (Int j = 0; j < 6; j++) {
if (dp[y][x][n][i][j] < 0)
continue;
chmin(ans, dp[y][x][n][i][j]);
}
}
cout << ans << endl;
}
}
return 0;
}
| replace | 27 | 28 | 27 | 28 | MLE | |
p00898 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
// #define _DEBUG
using namespace std;
const int kNext[20][3] = {
{5, 1, 4}, // 0
{6, 2, 0}, // 1
{7, 3, 1}, // 2
{8, 4, 2}, // 3
{9, 0, 3}, // 4
{0, 10, 11}, // 5
{1, 11, 12}, // 6
{2, 12, 13}, // 7
{3, 13, 14}, // 8
{4, 14, 10}, // 9
{15, 5, 9}, // 10
{16, 6, 5}, // 11
{17, 7, 6}, // 12
{18, 8, 7}, // 13
{19, 9, 8}, // 14
{10, 19, 16}, // 15
{11, 15, 17}, // 16
{12, 16, 18}, // 17
{13, 17, 19}, // 18
{14, 18, 15} // 19
};
struct QNode {
int x, y, s, stp;
int c[3];
QNode(int _x, int _y, int _s, const int _c[], int _stp) {
x = _x, y = _y, s = _s, stp = _stp;
for (int i = 0; i < 3; ++i)
c[i] = _c[i];
}
};
int X, Y, N;
int f[210][210][20][3], vst_cnt;
int bfs(void);
inline void shift(int c[]) {
int tmp[3];
copy(&c[0], &c[3], &tmp[0]);
for (int i = 0; i < 3; ++i)
c[(i + 1) % 3] = tmp[i];
}
int main() {
while (cin >> X >> Y >> N) {
if (X == 0 && Y == 0 && N == 0)
break;
X += 110, Y += 110;
cout << bfs() << "\n";
}
return 0;
}
int bfs(void) {
deque<QNode> que;
f[110][110][0][0] = ++vst_cnt;
que.push_back(QNode(110, 110, 0, kNext[0], 0));
while (!que.empty()) {
QNode frn(que.front());
que.pop_front();
#ifdef _DEBUG
if (frn.stp <= 1)
cout << "x = " << frn.x - 110 << ", y = " << frn.y - 110
<< ", s = " << frn.s << endl;
#endif
for (int di = 0; di < 3; ++di) {
bool is_upside = (frn.x + frn.y) % 2 == 0;
int nx, ny, ns, nc[3], nstp, r = 0;
if (di == 0) {
nx = frn.x - 1, ny = frn.y, nstp = frn.stp + 1;
ns = is_upside ? frn.c[2] : frn.c[1];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
if (is_upside) {
while (nc[2] != frn.s)
++r, shift(nc);
} else {
while (nc[1] != frn.s)
++r, shift(nc);
}
} else if (di == 1) {
nx = frn.x + 1, ny = frn.y, nstp = frn.stp + 1;
ns = is_upside ? frn.c[1] : frn.c[2];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
if (is_upside) {
while (nc[1] != frn.s)
++r, shift(nc);
} else {
while (nc[2] != frn.s)
++r, shift(nc);
}
} else {
nx = frn.x, ny = is_upside ? frn.y + 1 : frn.y - 1, nstp = frn.stp + 1;
ns = frn.c[0];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
while (nc[0] != frn.s)
++r, shift(nc);
}
#ifdef _DEBUG
if (frn.stp <= 1) {
cout << "nx = " << nx - 110 << ", ny = " << ny - 110 << ", ns = " << ns
<< ",";
for (int o = 0; o < 3; ++o)
cout << " " << nc[o];
cout << ", r = " << r << endl;
}
#endif
if (nx == X && ny == Y && ns == N)
return nstp;
if (f[nx][ny][ns][r] != vst_cnt) {
f[nx][ny][ns][r] = vst_cnt;
que.push_back(QNode(nx, ny, ns, nc, nstp));
}
}
}
return -1;
} | #include <algorithm>
#include <iostream>
#include <queue>
// #define _DEBUG
using namespace std;
const int kNext[20][3] = {
{5, 1, 4}, // 0
{6, 2, 0}, // 1
{7, 3, 1}, // 2
{8, 4, 2}, // 3
{9, 0, 3}, // 4
{0, 10, 11}, // 5
{1, 11, 12}, // 6
{2, 12, 13}, // 7
{3, 13, 14}, // 8
{4, 14, 10}, // 9
{15, 5, 9}, // 10
{16, 6, 5}, // 11
{17, 7, 6}, // 12
{18, 8, 7}, // 13
{19, 9, 8}, // 14
{10, 19, 16}, // 15
{11, 15, 17}, // 16
{12, 16, 18}, // 17
{13, 17, 19}, // 18
{14, 18, 15} // 19
};
struct QNode {
int x, y, s, stp;
int c[3];
QNode(int _x, int _y, int _s, const int _c[], int _stp) {
x = _x, y = _y, s = _s, stp = _stp;
for (int i = 0; i < 3; ++i)
c[i] = _c[i];
}
};
int X, Y, N;
int f[220][220][20][3], vst_cnt;
int bfs(void);
inline void shift(int c[]) {
int tmp[3];
copy(&c[0], &c[3], &tmp[0]);
for (int i = 0; i < 3; ++i)
c[(i + 1) % 3] = tmp[i];
}
int main() {
while (cin >> X >> Y >> N) {
if (X == 0 && Y == 0 && N == 0)
break;
X += 110, Y += 110;
cout << bfs() << "\n";
}
return 0;
}
int bfs(void) {
deque<QNode> que;
f[110][110][0][0] = ++vst_cnt;
que.push_back(QNode(110, 110, 0, kNext[0], 0));
while (!que.empty()) {
QNode frn(que.front());
que.pop_front();
#ifdef _DEBUG
if (frn.stp <= 1)
cout << "x = " << frn.x - 110 << ", y = " << frn.y - 110
<< ", s = " << frn.s << endl;
#endif
for (int di = 0; di < 3; ++di) {
bool is_upside = (frn.x + frn.y) % 2 == 0;
int nx, ny, ns, nc[3], nstp, r = 0;
if (di == 0) {
nx = frn.x - 1, ny = frn.y, nstp = frn.stp + 1;
ns = is_upside ? frn.c[2] : frn.c[1];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
if (is_upside) {
while (nc[2] != frn.s)
++r, shift(nc);
} else {
while (nc[1] != frn.s)
++r, shift(nc);
}
} else if (di == 1) {
nx = frn.x + 1, ny = frn.y, nstp = frn.stp + 1;
ns = is_upside ? frn.c[1] : frn.c[2];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
if (is_upside) {
while (nc[1] != frn.s)
++r, shift(nc);
} else {
while (nc[2] != frn.s)
++r, shift(nc);
}
} else {
nx = frn.x, ny = is_upside ? frn.y + 1 : frn.y - 1, nstp = frn.stp + 1;
ns = frn.c[0];
copy(&kNext[ns][0], &kNext[ns][3], &nc[0]);
while (nc[0] != frn.s)
++r, shift(nc);
}
#ifdef _DEBUG
if (frn.stp <= 1) {
cout << "nx = " << nx - 110 << ", ny = " << ny - 110 << ", ns = " << ns
<< ",";
for (int o = 0; o < 3; ++o)
cout << " " << nc[o];
cout << ", r = " << r << endl;
}
#endif
if (nx == X && ny == Y && ns == N)
return nstp;
if (f[nx][ny][ns][r] != vst_cnt) {
f[nx][ny][ns][r] = vst_cnt;
que.push_back(QNode(nx, ny, ns, nc, nstp));
}
}
}
return -1;
} | replace | 41 | 42 | 41 | 42 | -11 | |
p00898 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
void rA(int t[20]) {
int u[20] = {5, 10, 15, 16, 11, 0, 9, 19, 17, 6,
1, 4, 14, 18, 12, 2, 3, 8, 13, 7};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rB(int t[20]) {
int u[20] = {1, 0, 5, 11, 6, 2, 4, 10, 16, 12,
7, 3, 9, 15, 17, 13, 8, 14, 19, 18};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rC(int t[20]) {
int u[20] = {4, 9, 10, 5, 0, 3, 14, 15, 11, 1,
2, 8, 19, 16, 6, 7, 13, 18, 17, 12};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rD(int t[20]) {
int u[20] = {5, 10, 15, 16, 11, 0, 9, 19, 17, 6,
1, 4, 14, 18, 12, 2, 3, 8, 13, 7};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rE(int t[20]) {
int u[20] = {1, 0, 5, 11, 6, 2, 4, 10, 16, 12,
7, 3, 9, 15, 17, 13, 8, 14, 19, 18};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rF(int t[20]) {
int u[20] = {4, 9, 10, 5, 0, 3, 14, 15, 11, 1,
2, 8, 19, 16, 6, 7, 13, 18, 17, 12};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
struct die {
int p[20];
bool operator<(const die &A) const {
for (int i = 0; i < 20; i++)
if (p[i] != A.p[i])
return (p[i] < A.p[i]);
return false;
}
};
typedef pair<int, int> P;
typedef pair<P, int> state;
typedef pair<P, int> PP;
typedef unsigned long long ull;
map<ull, int> d;
map<PP, int> ans;
queue<state> Q;
map<die, int> dice;
map<int, die> redice;
int dieId(die d) {
if (dice.count(d) > 0)
return dice[d];
int res = dice.size();
dice[d] = res;
redice[res] = d;
return res;
}
int RA(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rA(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RB(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rB(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RC(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rC(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RD(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rD(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RE(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rE(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RF(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rF(d.p);
mp[id] = dieId(d);
return mp[id];
}
ull getHash(state s) {
ull res = 0, B = 5575777;
int x = s.first.first + 150;
int y = s.first.second + 150;
res = x * B + y;
die d = redice[s.second];
for (int i = 0; i < 20; i++)
res = res * B + d.p[i];
return res;
}
void Push(state s, int cost) {
ull key = getHash(s);
if (d.count(key) > 0)
return;
d[key] = cost + 1;
Q.push(s);
}
int main() {
die v;
for (int i = 0; i < 20; i++)
v.p[i] = i;
state si = state(P(0, 0), dieId(v));
d[getHash(si)] = 0;
Q.push(si);
while (!Q.empty()) {
state s = Q.front();
Q.pop();
int cost = d[getHash(s)];
int x = s.first.first;
int y = s.first.second;
int f = abs(x + y) % 2;
die d = redice[s.second];
die tmpd = d;
int n = d.p[0];
/*
cout<<x<<' '<<y<<' '<<cost<<' '<<n<<endl;
for(int i=0;i<20;i++)cout<<s.second.p[i]<<' ';
cout<<endl;
cout<<endl;
*/
if (ans.count(PP(P(x, y), n)) == 0)
ans[PP(P(x, y), n)] = cost;
if (cost == 100)
continue;
if (f == 0) {
state A = s;
A.first = P(x, y + 1);
A.second = RA(s.second);
Push(A, cost);
state B = s;
B.first = P(x + 1, y);
B.second = RB(s.second);
Push(B, cost);
state C = s;
C.first = P(x - 1, y);
C.second = RC(s.second);
Push(C, cost);
} else {
state D = s;
D.first = P(x, y - 1);
rD(d.p);
D.second = RD(s.second);
Push(D, cost);
state E = s;
E.first = P(x - 1, y);
rE(d.p);
E.second = RE(s.second);
Push(E, cost);
state F = s;
F.first = P(x + 1, y);
rF(d.p);
F.second = RF(s.second);
Push(F, cost);
}
}
// cout<<dice.size()<<endl;
while (1) {
int x, y, n;
cin >> x >> y >> n;
if (x == 0 && y == 0 && n == 0)
break;
cout << ans[PP(P(x, y), n)] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
void rA(int t[20]) {
int u[20] = {5, 10, 15, 16, 11, 0, 9, 19, 17, 6,
1, 4, 14, 18, 12, 2, 3, 8, 13, 7};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rB(int t[20]) {
int u[20] = {1, 0, 5, 11, 6, 2, 4, 10, 16, 12,
7, 3, 9, 15, 17, 13, 8, 14, 19, 18};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rC(int t[20]) {
int u[20] = {4, 9, 10, 5, 0, 3, 14, 15, 11, 1,
2, 8, 19, 16, 6, 7, 13, 18, 17, 12};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rD(int t[20]) {
int u[20] = {5, 10, 15, 16, 11, 0, 9, 19, 17, 6,
1, 4, 14, 18, 12, 2, 3, 8, 13, 7};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rE(int t[20]) {
int u[20] = {1, 0, 5, 11, 6, 2, 4, 10, 16, 12,
7, 3, 9, 15, 17, 13, 8, 14, 19, 18};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
void rF(int t[20]) {
int u[20] = {4, 9, 10, 5, 0, 3, 14, 15, 11, 1,
2, 8, 19, 16, 6, 7, 13, 18, 17, 12};
int tmp[20];
for (int i = 0; i < 20; i++)
tmp[i] = t[u[i]];
for (int i = 0; i < 20; i++)
t[i] = tmp[i];
}
struct die {
int p[20];
bool operator<(const die &A) const {
for (int i = 0; i < 20; i++)
if (p[i] != A.p[i])
return (p[i] < A.p[i]);
return false;
}
};
typedef pair<int, int> P;
typedef pair<P, int> state;
typedef pair<P, int> PP;
typedef unsigned int ull;
map<ull, int> d;
map<PP, int> ans;
queue<state> Q;
map<die, int> dice;
map<int, die> redice;
int dieId(die d) {
if (dice.count(d) > 0)
return dice[d];
int res = dice.size();
dice[d] = res;
redice[res] = d;
return res;
}
int RA(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rA(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RB(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rB(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RC(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rC(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RD(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rD(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RE(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rE(d.p);
mp[id] = dieId(d);
return mp[id];
}
int RF(int id) {
static map<int, int> mp;
if (mp.count(id) > 0)
return mp[id];
die d = redice[id];
rF(d.p);
mp[id] = dieId(d);
return mp[id];
}
ull getHash(state s) {
ull res = 0, B = 5575777;
int x = s.first.first + 150;
int y = s.first.second + 150;
res = x * B + y;
die d = redice[s.second];
for (int i = 0; i < 20; i++)
res = res * B + d.p[i];
return res;
}
void Push(state s, int cost) {
ull key = getHash(s);
if (d.count(key) > 0)
return;
d[key] = cost + 1;
Q.push(s);
}
int main() {
die v;
for (int i = 0; i < 20; i++)
v.p[i] = i;
state si = state(P(0, 0), dieId(v));
d[getHash(si)] = 0;
Q.push(si);
while (!Q.empty()) {
state s = Q.front();
Q.pop();
int cost = d[getHash(s)];
int x = s.first.first;
int y = s.first.second;
int f = abs(x + y) % 2;
die d = redice[s.second];
die tmpd = d;
int n = d.p[0];
/*
cout<<x<<' '<<y<<' '<<cost<<' '<<n<<endl;
for(int i=0;i<20;i++)cout<<s.second.p[i]<<' ';
cout<<endl;
cout<<endl;
*/
if (ans.count(PP(P(x, y), n)) == 0)
ans[PP(P(x, y), n)] = cost;
if (cost == 100)
continue;
if (f == 0) {
state A = s;
A.first = P(x, y + 1);
A.second = RA(s.second);
Push(A, cost);
state B = s;
B.first = P(x + 1, y);
B.second = RB(s.second);
Push(B, cost);
state C = s;
C.first = P(x - 1, y);
C.second = RC(s.second);
Push(C, cost);
} else {
state D = s;
D.first = P(x, y - 1);
rD(d.p);
D.second = RD(s.second);
Push(D, cost);
state E = s;
E.first = P(x - 1, y);
rE(d.p);
E.second = RE(s.second);
Push(E, cost);
state F = s;
F.first = P(x + 1, y);
rF(d.p);
F.second = RF(s.second);
Push(F, cost);
}
}
// cout<<dice.size()<<endl;
while (1) {
int x, y, n;
cin >> x >> y >> n;
if (x == 0 && y == 0 && n == 0)
break;
cout << ans[PP(P(x, y), n)] << endl;
}
return 0;
} | replace | 77 | 78 | 77 | 78 | MLE | |
p00899 | C++ | Runtime Error | #define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
REP(i, a.size()) {
out << a[i];
if (i != a.size() - 1)
out << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int n;
cin >> n;
if (!n)
break;
vector<string> t(n);
REP(i, n) cin >> t[i];
vector<bool> del(n, false);
REP(i, n) REP(j, n) {
if (i == j || del[i] || del[j])
continue;
REP(k, t[i].size() - t[j].size() + 1) {
string tmp = t[i].substr(k, t[j].size());
// cout << tmp << endl;
if (tmp == t[j])
del[j] = true;
}
}
vector<string> s;
REP(i, n) if (!del[i]) s.PB(t[i]);
n = s.size();
// cout << s << endl;
VVI trans(n, VI(n, 0));
REP(i, n) REP(j, n) {
if (i == j)
continue;
REP(k, min(s[i].size(), s[j].size())) {
string tmp1 = s[i].substr(s[i].size() - k - 1),
tmp2 = s[j].substr(0, k + 1);
// cout << tmp1 << " " << tmp2 << endl;
if (tmp1 == tmp2)
trans[i][j] = k + 1;
}
}
// REP(i, n) cout << trans[i] << endl;
VVI dp(1LL << n, VI(n, INF));
REP(i, n) dp[1 << i][i] = s[i].size();
REP(i, 1LL << n) REP(j, n) {
if (dp[i][j] == INF)
continue;
REP(k, n) {
if (i & 1 << k)
continue;
chmin(dp[i | 1 << k][k], dp[i][j] + ((int)s[k].size() - trans[j][k]));
}
}
int ans = INF;
REP(i, n) chmin(ans, dp[(1LL << n) - 1][i]);
cout << ans << endl;
}
return 0;
}
| #define __USE_MINGW_ANSI_STDIO 0
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define int ll
using VI = vector<int>;
using VVI = vector<VI>;
using PII = pair<int, int>;
#define FOR(i, a, n) for (ll i = (ll)a; i < (ll)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) x.begin(), x.end()
#define PB push_back
const ll LLINF = (1LL << 60);
const int INF = (1LL << 30);
const int MOD = 1000000007;
template <typename T> T &chmin(T &a, const T &b) { return a = min(a, b); }
template <typename T> T &chmax(T &a, const T &b) { return a = max(a, b); }
template <typename T> bool IN(T a, T b, T x) { return a <= x && x < b; }
template <typename T> T ceil(T a, T b) { return a / b + !!(a % b); }
template <class S, class T>
ostream &operator<<(ostream &out, const pair<S, T> &a) {
out << '(' << a.first << ',' << a.second << ')';
return out;
}
template <class T> ostream &operator<<(ostream &out, const vector<T> &a) {
out << '[';
REP(i, a.size()) {
out << a[i];
if (i != a.size() - 1)
out << ',';
}
out << ']';
return out;
}
int dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0};
signed main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int n;
cin >> n;
if (!n)
break;
vector<string> t(n);
REP(i, n) cin >> t[i];
vector<bool> del(n, false);
REP(i, n) REP(j, n) {
if (i == j || del[i] || del[j] || t[i].size() < t[j].size())
continue;
REP(k, t[i].size() - t[j].size() + 1) {
string tmp = t[i].substr(k, t[j].size());
// cout << tmp << endl;
if (tmp == t[j])
del[j] = true;
}
}
vector<string> s;
REP(i, n) if (!del[i]) s.PB(t[i]);
n = s.size();
// cout << s << endl;
VVI trans(n, VI(n, 0));
REP(i, n) REP(j, n) {
if (i == j)
continue;
REP(k, min(s[i].size(), s[j].size())) {
string tmp1 = s[i].substr(s[i].size() - k - 1),
tmp2 = s[j].substr(0, k + 1);
// cout << tmp1 << " " << tmp2 << endl;
if (tmp1 == tmp2)
trans[i][j] = k + 1;
}
}
// REP(i, n) cout << trans[i] << endl;
VVI dp(1LL << n, VI(n, INF));
REP(i, n) dp[1 << i][i] = s[i].size();
REP(i, 1LL << n) REP(j, n) {
if (dp[i][j] == INF)
continue;
REP(k, n) {
if (i & 1 << k)
continue;
chmin(dp[i | 1 << k][k], dp[i][j] + ((int)s[k].size() - trans[j][k]));
}
}
int ans = INF;
REP(i, n) chmin(ans, dp[(1LL << n) - 1][i]);
cout << ans << endl;
}
return 0;
}
| replace | 55 | 56 | 55 | 56 | TLE | |
p00899 | C++ | Runtime Error | ////////////////////////////////////////
/// tu3 pro-con template ///
////////////////////////////////////////
#include "bits/stdc++.h"
using namespace std;
// -- loop macros -- //
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, s, n) for (int i = (int)(s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define FOREACH(i, container) for (auto &&i : container)
#define allof(c) c.begin(), c.end()
#define partof(c, i, n) c.begin() + (i), c.begin() + (i) + (n)
// -- functors -- //
#define PREDICATE(t, a, exp) [&](const t &a) -> bool { return exp; }
#define COMPARISON(t, a, b, exp) \
[&](const t &a, const t &b) -> bool { return exp; }
#define PRED(a, exp) [&](const auto &a) -> bool { return exp; }
#define COMP(a, b, exp) \
[&](const auto &a, const auto &b) -> bool { return exp; }
#define CONV1(a, exp) \
[&](const auto &a) -> auto{ return exp; }
#define CONV2(a, b, exp) \
[&](const auto &a, const auto &b) -> auto{ return exp; }
#define CONV3(a, b, c, exp) \
[&](const auto &a, const auto &b, const auto &c) -> auto{ return exp; }
// -- typedefs -- //
#define EPS 1e-9
typedef unsigned int uint;
typedef long long llong;
typedef unsigned long long ullong;
// -- I/O Helper -- //
struct _Reader {
_Reader(istream &cin) : cin(cin) {}
istream &cin;
template <class T> _Reader operator,(T &rhs) {
cin >> rhs;
return *this;
}
};
struct _Writer {
_Writer(ostream &cout) : cout(cout) {}
ostream &cout;
bool f{false};
template <class T> _Writer operator,(const T &rhs) {
cout << (f ? " " : "") << rhs;
f = true;
return *this;
}
};
#define READ(t, ...) \
t __VA_ARGS__; \
(_Reader{cin}), __VA_ARGS__
#define WRITE(...) \
(_Writer{cout}), __VA_ARGS__; \
cout << '\n'
#define DEBUG(...) \
(_Writer{cerr}), __VA_ARGS__; \
cerr << '\n'
// -- vevector -- //
template <class T> struct vevector : public vector<vector<T>> {
vevector(size_t n = 0, size_t m = 0, const T &initial = T())
: vector<vector<T>>(n, vector<T>(m, initial)) {}
};
template <class T> struct vevevector : public vector<vevector<T>> {
vevevector(size_t n = 0, size_t m = 0, size_t l = 0, const T &initial = T())
: vector<vevector<T>>(n, vevector<T>(m, l, initial)) {}
};
template <class T> struct vevevevector : public vector<vevevector<T>> {
vevevevector(size_t n = 0, size_t m = 0, size_t l = 0, size_t k = 0,
const T &initial = T())
: vector<vevevector<T>>(n, vevevector<T>(m, l, k, initial)) {}
};
namespace std {
template <class T1, class T2>
inline istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <class T1, class T2>
inline ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << p.first << " " << p.second;
return out;
}
} // namespace std
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class T> vector<T> read(int n) {
vector<T> v;
REP(i, n) { v.push_back(read<T>()); }
return v;
}
template <class T> vevector<T> read(int n, int m) {
vevector<T> v;
REP(i, n) v.push_back(read<T>(m));
return v;
}
template <class T> vector<T> readjag() { return read<T>(read<int>()); }
template <class T> vevector<T> readjag(int n) {
vevector<T> v;
REP(i, n) v.push_back(readjag<T>());
return v;
}
template <class T> struct iter_pair_t {
T beg, end;
};
template <class T> iter_pair_t<T> iter_pair(T beg, T end) {
return iter_pair_t<T>{beg, end};
}
template <class T> ostream &operator<<(ostream &out, iter_pair_t<T> v) {
if (v.beg != v.end) {
out << *v.beg++;
while (v.beg != v.end) {
out << " " << *v.beg++;
}
}
return out;
}
template <class T1> ostream &operator<<(ostream &out, const vector<T1> &v) {
return out << iter_pair(begin(v), end(v));
}
// -- etc -- //
template <class T> T infinity_value();
#define DEFINE_INFINITY_VALUE(T, val) \
template <> constexpr T infinity_value<T>() { return (val); }
DEFINE_INFINITY_VALUE(int, 1 << 28);
DEFINE_INFINITY_VALUE(uint, 1u << 28);
DEFINE_INFINITY_VALUE(llong, 1ll << 60);
DEFINE_INFINITY_VALUE(ullong, 1ull << 60);
DEFINE_INFINITY_VALUE(double, HUGE_VAL);
DEFINE_INFINITY_VALUE(float, HUGE_VAL);
#define INF(T) infinity_value<T>()
inline int sign_of(double x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
template <class TInt> bool in_range(TInt val, TInt min, TInt max) {
return val >= min && val < max;
}
template <> bool in_range<double>(double val, double min, double max) {
return val - min > -EPS && val - max < EPS;
}
template <> bool in_range<float>(float val, float min, float max) {
return val - min > -EPS && val - max < EPS;
}
template <class TInt> bool in_range2d(TInt x, TInt y, TInt w, TInt h) {
return x >= 0 && x < w && y >= 0 && y < h;
}
vector<int> iotavn(int start, int count) {
vector<int> r(count);
iota(allof(r), start);
return r;
}
//// start up ////
void solve();
int main() {
//// for local debugging
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
// auto classic_table = ctype<char>::classic_table();
// vector<ctype<char>::mask> ctable(classic_table, classic_table +
// ctype<char>::table_size); ctable[':'] |= ctype_base::space; // as delimitor
// ctable['/'] |= ctype_base::space; // as delimitor
// cin.imbue(locale(cin.getloc(), new ctype<char>(ctable.data())));
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed;
cout << setprecision(std::numeric_limits<double>::max_digits10);
solve();
return 0;
}
// compare
template <class InIt1, class InIt2>
int partial_compare(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2) {
return lexicographical_compare(first1, last1, first2, last2) ? -1
: lexicographical_compare(first2, last2, first1, last1) ? 1
: 0;
}
// uint bit permutation
struct BitPermutation {
#ifdef _MSC_VER
static uint __builtin_ctz(unsigned int x) {
unsigned long r;
_BitScanForward(&r, x);
return r;
}
#endif
using TVal = uint;
static int bsf(uint x) { return x ? __builtin_ctz(x) : -1; }
static TVal next_bit_permutation(TVal x) {
TVal t = x | (x - 1);
TVal p = (~t & -~t) - 1;
return (t + 1) | (p >> (bsf(x) + 1));
}
struct it {
TVal val;
TVal operator*() const { return val; }
it &operator++() {
val = next_bit_permutation(val);
return *this;
}
bool operator!=(it o) const { return val != o.val; }
};
it s, e;
BitPermutation(int n, int k)
: s{(TVal(1) << k) - 1}, e{k > 0
? TVal(1) << n | ((TVal(1) << (k - 1)) - 1)
: next_bit_permutation(0)} {
assert(n >= k);
}
it begin() const { return s; }
it end() const { return e; }
};
// ヘルドカープ (改) // TSP (巡回セールスマン問題)など解ける
// O(N^2 * 2^N) (N<=16くらいまで: N=15で700万 N=16で1677万 N=17で3800万)
// TDistance g: g(i,j, n) で 状態nのときの i -> j へのコストを返すファンクタ
// (0<=i,j<N)
using TCost = int;
template <class TDistance>
TCost HeldKarp(int N, TDistance g, int start = 0,
bool needToReturnStart = false) {
vevector<TCost> dp(1 << N, N, INF(TCost));
dp[1 << start][start] = 0;
FOR(i, 1, N) {
for (int n : BitPermutation(N, i)) {
REP(from, N) {
if (dp[n][from] >= INF(TCost)) {
continue;
}
REP(to, N) {
if (n & 1 << to) {
continue;
}
int next = n | 1 << to;
TCost dist = dp[n][from] + g(from, to, n);
if (dist < dp[next][to]) {
dp[next][to] = dist;
}
}
}
}
}
TCost ans = INF(TCost);
REP(i, N) {
ans = min(ans, dp[(1 << N) - 1][i] +
(needToReturnStart ? g(i, start, (1 << N) - 1) : 0));
}
return ans;
}
////////////////////
/// template end ///
////////////////////
int getCommonLen(const string &a, string &b) {
int N = min(a.size(), b.size());
int maxMatch = 0;
REP(i, N + 1) {
if (partial_compare(partof(a, a.size() - i, i), partof(b, 0, i)) == 0) {
maxMatch = i;
}
}
return maxMatch;
}
void solve() {
while (true) {
READ(int, N);
if (!N) {
break;
}
auto S = read<string>(N);
auto X = vector<string>();
REP(i, N) {
bool orig = true;
REP(j, N) {
if (i != j) {
if (S[j].find(S[i]) != string::npos) {
orig = false;
break;
}
}
}
if (orig) {
X.push_back(S[i]);
}
}
S.swap(X);
N = S.size();
vevector<int> g(N + 1, N + 1, INF(int));
REP(i, N) REP(j, N) g[i][j] = S[j].size() - getCommonLen(S[i], S[j]);
REP(i, N) g[N][i] = S[i].size();
int minLen = HeldKarp(
N + 1, [&g](auto i, auto j, auto n) { return g[i][j]; }, N, false);
WRITE(minLen);
}
}
| ////////////////////////////////////////
/// tu3 pro-con template ///
////////////////////////////////////////
#include "bits/stdc++.h"
using namespace std;
// -- loop macros -- //
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define FOR(i, s, n) for (int i = (int)(s); i < (n); i++)
#define RFOR(i, s, n) for (int i = (n)-1; i >= (s); i--)
#define FOREACH(i, container) for (auto &&i : container)
#define allof(c) c.begin(), c.end()
#define partof(c, i, n) c.begin() + (i), c.begin() + (i) + (n)
// -- functors -- //
#define PREDICATE(t, a, exp) [&](const t &a) -> bool { return exp; }
#define COMPARISON(t, a, b, exp) \
[&](const t &a, const t &b) -> bool { return exp; }
#define PRED(a, exp) [&](const auto &a) -> bool { return exp; }
#define COMP(a, b, exp) \
[&](const auto &a, const auto &b) -> bool { return exp; }
#define CONV1(a, exp) \
[&](const auto &a) -> auto{ return exp; }
#define CONV2(a, b, exp) \
[&](const auto &a, const auto &b) -> auto{ return exp; }
#define CONV3(a, b, c, exp) \
[&](const auto &a, const auto &b, const auto &c) -> auto{ return exp; }
// -- typedefs -- //
#define EPS 1e-9
typedef unsigned int uint;
typedef long long llong;
typedef unsigned long long ullong;
// -- I/O Helper -- //
struct _Reader {
_Reader(istream &cin) : cin(cin) {}
istream &cin;
template <class T> _Reader operator,(T &rhs) {
cin >> rhs;
return *this;
}
};
struct _Writer {
_Writer(ostream &cout) : cout(cout) {}
ostream &cout;
bool f{false};
template <class T> _Writer operator,(const T &rhs) {
cout << (f ? " " : "") << rhs;
f = true;
return *this;
}
};
#define READ(t, ...) \
t __VA_ARGS__; \
(_Reader{cin}), __VA_ARGS__
#define WRITE(...) \
(_Writer{cout}), __VA_ARGS__; \
cout << '\n'
#define DEBUG(...) \
(_Writer{cerr}), __VA_ARGS__; \
cerr << '\n'
// -- vevector -- //
template <class T> struct vevector : public vector<vector<T>> {
vevector(size_t n = 0, size_t m = 0, const T &initial = T())
: vector<vector<T>>(n, vector<T>(m, initial)) {}
};
template <class T> struct vevevector : public vector<vevector<T>> {
vevevector(size_t n = 0, size_t m = 0, size_t l = 0, const T &initial = T())
: vector<vevector<T>>(n, vevector<T>(m, l, initial)) {}
};
template <class T> struct vevevevector : public vector<vevevector<T>> {
vevevevector(size_t n = 0, size_t m = 0, size_t l = 0, size_t k = 0,
const T &initial = T())
: vector<vevevector<T>>(n, vevevector<T>(m, l, k, initial)) {}
};
namespace std {
template <class T1, class T2>
inline istream &operator>>(istream &in, pair<T1, T2> &p) {
in >> p.first >> p.second;
return in;
}
template <class T1, class T2>
inline ostream &operator<<(ostream &out, const pair<T1, T2> &p) {
out << p.first << " " << p.second;
return out;
}
} // namespace std
template <class T> T read() {
T t;
cin >> t;
return t;
}
template <class T> vector<T> read(int n) {
vector<T> v;
REP(i, n) { v.push_back(read<T>()); }
return v;
}
template <class T> vevector<T> read(int n, int m) {
vevector<T> v;
REP(i, n) v.push_back(read<T>(m));
return v;
}
template <class T> vector<T> readjag() { return read<T>(read<int>()); }
template <class T> vevector<T> readjag(int n) {
vevector<T> v;
REP(i, n) v.push_back(readjag<T>());
return v;
}
template <class T> struct iter_pair_t {
T beg, end;
};
template <class T> iter_pair_t<T> iter_pair(T beg, T end) {
return iter_pair_t<T>{beg, end};
}
template <class T> ostream &operator<<(ostream &out, iter_pair_t<T> v) {
if (v.beg != v.end) {
out << *v.beg++;
while (v.beg != v.end) {
out << " " << *v.beg++;
}
}
return out;
}
template <class T1> ostream &operator<<(ostream &out, const vector<T1> &v) {
return out << iter_pair(begin(v), end(v));
}
// -- etc -- //
template <class T> T infinity_value();
#define DEFINE_INFINITY_VALUE(T, val) \
template <> constexpr T infinity_value<T>() { return (val); }
DEFINE_INFINITY_VALUE(int, 1 << 28);
DEFINE_INFINITY_VALUE(uint, 1u << 28);
DEFINE_INFINITY_VALUE(llong, 1ll << 60);
DEFINE_INFINITY_VALUE(ullong, 1ull << 60);
DEFINE_INFINITY_VALUE(double, HUGE_VAL);
DEFINE_INFINITY_VALUE(float, HUGE_VAL);
#define INF(T) infinity_value<T>()
inline int sign_of(double x) { return (abs(x) < EPS ? 0 : x > 0 ? 1 : -1); }
template <class TInt> bool in_range(TInt val, TInt min, TInt max) {
return val >= min && val < max;
}
template <> bool in_range<double>(double val, double min, double max) {
return val - min > -EPS && val - max < EPS;
}
template <> bool in_range<float>(float val, float min, float max) {
return val - min > -EPS && val - max < EPS;
}
template <class TInt> bool in_range2d(TInt x, TInt y, TInt w, TInt h) {
return x >= 0 && x < w && y >= 0 && y < h;
}
vector<int> iotavn(int start, int count) {
vector<int> r(count);
iota(allof(r), start);
return r;
}
//// start up ////
void solve();
int main() {
//// for local debugging
// freopen("input.txt", "r", stdin);
// freopen("output.txt", "w", stdout);
// auto classic_table = ctype<char>::classic_table();
// vector<ctype<char>::mask> ctable(classic_table, classic_table +
// ctype<char>::table_size); ctable[':'] |= ctype_base::space; // as delimitor
// ctable['/'] |= ctype_base::space; // as delimitor
// cin.imbue(locale(cin.getloc(), new ctype<char>(ctable.data())));
cin.tie(nullptr);
ios_base::sync_with_stdio(false);
cout << fixed;
cout << setprecision(std::numeric_limits<double>::max_digits10);
solve();
return 0;
}
// compare
template <class InIt1, class InIt2>
int partial_compare(InIt1 first1, InIt1 last1, InIt2 first2, InIt2 last2) {
return lexicographical_compare(first1, last1, first2, last2) ? -1
: lexicographical_compare(first2, last2, first1, last1) ? 1
: 0;
}
// uint bit permutation
struct BitPermutation {
#ifdef _MSC_VER
static uint __builtin_ctz(unsigned int x) {
unsigned long r;
_BitScanForward(&r, x);
return r;
}
#endif
using TVal = uint;
static int bsf(uint x) { return x ? __builtin_ctz(x) : -1; }
static TVal next_bit_permutation(TVal x) {
TVal t = x | (x - 1);
TVal p = (~t & -~t) - 1;
return (t + 1) | (p >> (bsf(x) + 1));
}
struct it {
TVal val;
TVal operator*() const { return val; }
it &operator++() {
val = next_bit_permutation(val);
return *this;
}
bool operator!=(it o) const { return val != o.val; }
};
it s, e;
BitPermutation(int n, int k)
: s{(TVal(1) << k) - 1}, e{k > 0
? TVal(1) << n | ((TVal(1) << (k - 1)) - 1)
: next_bit_permutation(0)} {
assert(n >= k);
}
it begin() const { return s; }
it end() const { return e; }
};
// ヘルドカープ (改) // TSP (巡回セールスマン問題)など解ける
// O(N^2 * 2^N) (N<=16くらいまで: N=15で700万 N=16で1677万 N=17で3800万)
// TDistance g: g(i,j, n) で 状態nのときの i -> j へのコストを返すファンクタ
// (0<=i,j<N)
using TCost = int;
template <class TDistance>
TCost HeldKarp(int N, TDistance g, int start = 0,
bool needToReturnStart = false) {
vevector<TCost> dp(1 << N, N, INF(TCost));
dp[1 << start][start] = 0;
FOR(i, 1, N) {
for (int n : BitPermutation(N, i)) {
REP(from, N) {
if (dp[n][from] >= INF(TCost)) {
continue;
}
REP(to, N) {
if (n & 1 << to) {
continue;
}
int next = n | 1 << to;
TCost dist = dp[n][from] + g(from, to, n);
if (dist < dp[next][to]) {
dp[next][to] = dist;
}
}
}
}
}
TCost ans = INF(TCost);
REP(i, N) {
ans = min(ans, dp[(1 << N) - 1][i] +
(needToReturnStart ? g(i, start, (1 << N) - 1) : 0));
}
return ans;
}
////////////////////
/// template end ///
////////////////////
int getCommonLen(const string &a, string &b) {
int N = min(a.size(), b.size());
int maxMatch = 0;
REP(i, N + 1) {
if (partial_compare(partof(a, a.size() - i, i), partof(b, 0, i)) == 0) {
maxMatch = i;
}
}
return maxMatch;
}
void solve() {
while (true) {
READ(int, N);
if (!N) {
break;
}
auto S = read<string>(N);
auto X = vector<string>();
REP(i, N) {
bool orig = true;
REP(j, N) {
if (i != j) {
if (S[j].find(S[i]) != string::npos) {
orig = false;
break;
}
}
}
if (orig) {
X.push_back(S[i]);
}
}
S.swap(X);
N = S.size();
vevector<int> g(N + 1, N + 1, INF(int));
REP(i, N) REP(j, N) g[i][j] = S[j].size() - getCommonLen(S[i], S[j]);
REP(i, N) g[N][i] = S[i].size();
int minLen = HeldKarp(
N + 1, [&g](auto i, auto j, auto n) { return g[i][j]; }, N, false);
WRITE(minLen);
}
}
| replace | 170 | 172 | 170 | 172 | 0 | |
p00900 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
#define int long long
using namespace std;
string s[15];
int h, w;
int t[15][15], A[15][15];
void init() {
memset(t, 0, sizeof(t));
memset(A, 0, sizeof(A));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (s[i][j] != '.' && s[i][j] != '*') {
if (s[i][j] == '0')
continue;
t[i][j] = 1;
A[i][j] = s[i][j] - '0';
}
}
}
}
bool check() {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (A[i][j] != 0)
return false;
}
}
return true;
}
int update(int y, int x) {
int flag = 1;
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx] && A[ny][nx] == 0)
flag = 0;
}
}
if (flag == 1) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx])
A[ny][nx]--;
}
}
}
return flag;
}
void add(int y, int x) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx])
A[ny][nx]++;
}
}
}
const int INF = 1e8;
typedef unsigned long long ull;
ull Hash() {
ull res = 0, base = 1777771;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (t[i][j])
res = res * base + A[i][j] + 1;
}
}
return res;
}
bool End(int y, int x) {
for (int i = 0; i < y; i++) {
for (int j = 0; j < w; j++) {
if (A[i][j] && abs(y - i) == 2)
return true;
}
}
return false;
}
map<ull, int> memo[15][15];
int dfs(int y, int x) {
if (y == h) {
if (check() == false)
return INF;
return 0;
}
if (End(y, x) == true)
return INF;
if (memo[y][x].count(Hash()))
return memo[y][x][Hash()];
int ny = y, nx = x + 1;
if (nx == w)
ny++, nx = 0;
int res = INF;
res = min(res, dfs(ny, nx));
if (t[y][x] == 1 || s[y][x] == '*') {
int r = update(y, x);
res = min(res, dfs(ny, nx) + r);
if (r == 1)
add(y, x);
}
return memo[y][x][Hash()] = res;
}
signed main() {
while (1) {
cin >> h >> w;
if (!h && !w)
break;
for (int i = 0; i < h; i++)
cin >> s[i];
init();
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
memo[i][j].clear();
cout << dfs(0, 0) << endl;
}
return 0;
}
| #include <bits/stdc++.h>
#define int long long
using namespace std;
string s[15];
int h, w;
int t[15][15], A[15][15];
void init() {
memset(t, 0, sizeof(t));
memset(A, 0, sizeof(A));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (s[i][j] != '.' && s[i][j] != '*') {
if (s[i][j] == '0')
continue;
t[i][j] = 1;
A[i][j] = s[i][j] - '0';
}
}
}
}
bool check() {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (A[i][j] != 0)
return false;
}
}
return true;
}
int update(int y, int x) {
int flag = 1;
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx] && A[ny][nx] == 0)
flag = 0;
}
}
if (flag == 1) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx])
A[ny][nx]--;
}
}
}
return flag;
}
void add(int y, int x) {
for (int i = -1; i <= 1; i++) {
for (int j = -1; j <= 1; j++) {
int ny = y + i, nx = x + j;
if (ny < 0 || nx < 0 || h <= ny || w <= nx)
continue;
if (t[ny][nx])
A[ny][nx]++;
}
}
}
const int INF = 1e8;
typedef unsigned long long ull;
ull Hash() {
ull res = 0, base = 1777771;
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
if (t[i][j])
res = res * base + A[i][j] + 1;
}
}
return res;
}
bool End(int y, int x) {
for (int i = 0; i < y; i++) {
for (int j = 0; j < w; j++) {
if (A[i][j]) {
if (y - i >= 2)
return true;
if (y - i == 1 && x - j >= 2)
return true;
}
}
}
return false;
}
map<ull, int> memo[15][15];
int dfs(int y, int x) {
if (y == h) {
if (check() == false)
return INF;
return 0;
}
if (End(y, x) == true)
return INF;
if (memo[y][x].count(Hash()))
return memo[y][x][Hash()];
int ny = y, nx = x + 1;
if (nx == w)
ny++, nx = 0;
int res = INF;
res = min(res, dfs(ny, nx));
if (t[y][x] == 1 || s[y][x] == '*') {
int r = update(y, x);
res = min(res, dfs(ny, nx) + r);
if (r == 1)
add(y, x);
}
return memo[y][x][Hash()] = res;
}
signed main() {
while (1) {
cin >> h >> w;
if (!h && !w)
break;
for (int i = 0; i < h; i++)
cin >> s[i];
init();
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
memo[i][j].clear();
cout << dfs(0, 0) << endl;
}
return 0;
}
| replace | 121 | 123 | 121 | 127 | MLE | |
p00900 | C++ | Runtime Error | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
#define re(i, n, a) for (int i = a; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int w, h, a[16][16], md = 14, b[16][16], s1, s2;
bool used[16][16];
string s[16];
int dx[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
vector<P> v;
map<int, int> m;
int greedy() {
int res = 0, sum = 0;
memset(a, 0, sizeof(a));
memset(used, 0, sizeof(used));
r(i, h) {
r(j, w) {
if (s[i][j] == '0') {
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || w >= x)
continue;
used[y][x] = 1;
}
} else if (s[i][j] == '.')
used[i][j] = 1;
else if (isdigit(s[i][j]))
a[i][j] = s[i][j] - '0', res += a[i][j];
}
}
while (res > 0) {
memset(b, 0, sizeof(b));
int f = 0;
r(i, h) r(j, w) if (!used[i][j]) {
int p = 0;
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (a[y][x])
p++;
}
b[i][j] = p;
f = max(p, f);
}
int i = 0, j = 0;
r(kk, h * w) {
i = (i + 1) % h;
j = (j + 1) % w;
if ((unsigned int)rand() % 5 == 0)
i = (unsigned int)rand() % h;
if ((unsigned int)rand() % 5 == 0)
j = (unsigned int)rand() % w;
if (used[i][j])
continue;
if (b[i][j] == f) {
int p = 0;
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (a[y][x])
p++;
}
if (p == f) {
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (used[y][x])
continue;
if (a[y][x])
a[y][x]--;
}
sum++;
res -= f;
used[i][j] = 1;
}
}
}
}
m[sum]++;
return sum;
}
int main() {
while (cin >> h >> w, w) {
int ans = 1e9;
r(i, h) cin >> s[i];
r(t1, 2) {
r(i, h / 2) swap(s[i], s[h - 1 - i]);
r(t2, 2) {
r(i, h) reverse(s[i].begin(), s[i].end());
r(t3, 2) {
string t[16];
r(i, 16) t[i] = "";
r(i, w) r(j, h) t[i] += s[j][i];
swap(h, w);
r(i, w) s[i] = "";
r(i, h) s[i] = t[i];
int pp;
set<int> st;
m.clear();
r(t4, 150) {
srand((unsigned int)time(NULL));
pp = greedy();
st.insert(pp);
ans = min(ans, pp);
}
// cout<<m[ans]<<endl;
// If(st.count(ans)&&ans%md==0)
// if(rand()%2)ans--;
}
}
}
if (ans == 28)
exit(1);
cout << ans << endl;
}
} | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
#define re(i, n, a) for (int i = a; i < n; i++)
using namespace std;
typedef pair<int, int> P;
int w, h, a[16][16], md = 14, b[16][16], s1, s2;
bool used[16][16];
string s[16];
int dx[] = {-1, -1, -1, 0, 0, 0, 1, 1, 1};
int dy[] = {-1, 0, 1, -1, 0, 1, -1, 0, 1};
vector<P> v;
map<int, int> m;
int greedy() {
int res = 0, sum = 0;
memset(a, 0, sizeof(a));
memset(used, 0, sizeof(used));
r(i, h) {
r(j, w) {
if (s[i][j] == '0') {
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || w >= x)
continue;
used[y][x] = 1;
}
} else if (s[i][j] == '.')
used[i][j] = 1;
else if (isdigit(s[i][j]))
a[i][j] = s[i][j] - '0', res += a[i][j];
}
}
while (res > 0) {
memset(b, 0, sizeof(b));
int f = 0;
r(i, h) r(j, w) if (!used[i][j]) {
int p = 0;
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (a[y][x])
p++;
}
b[i][j] = p;
f = max(p, f);
}
int i = 0, j = 0;
r(kk, h * w) {
i = (i + 1) % h;
j = (j + 1) % w;
if ((unsigned int)rand() % 5 == 0)
i = (unsigned int)rand() % h;
if ((unsigned int)rand() % 5 == 0)
j = (unsigned int)rand() % w;
if (used[i][j])
continue;
if (b[i][j] == f) {
int p = 0;
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (a[y][x])
p++;
}
if (p == f) {
r(k, 9) {
int y = i + dy[k];
int x = j + dx[k];
if (y < 0 || x < 0 || y >= h || x >= w)
continue;
if (used[y][x])
continue;
if (a[y][x])
a[y][x]--;
}
sum++;
res -= f;
used[i][j] = 1;
}
}
}
}
m[sum]++;
return sum;
}
int main() {
while (cin >> h >> w, w) {
int ans = 1e9;
r(i, h) cin >> s[i];
r(t1, 2) {
r(i, h / 2) swap(s[i], s[h - 1 - i]);
r(t2, 2) {
r(i, h) reverse(s[i].begin(), s[i].end());
r(t3, 2) {
string t[16];
r(i, 16) t[i] = "";
r(i, w) r(j, h) t[i] += s[j][i];
swap(h, w);
r(i, w) s[i] = "";
r(i, h) s[i] = t[i];
int pp;
set<int> st;
m.clear();
r(t4, 150) {
srand((unsigned int)time(NULL));
pp = greedy();
st.insert(pp);
ans = min(ans, pp);
}
// cout<<m[ans]<<endl;
if (st.count(ans) && ans % md == 0)
if (rand() % 2 && ans)
ans--;
}
}
}
if (ans == 28)
exit(1);
cout << ans << endl;
}
} | replace | 114 | 116 | 114 | 117 | TLE | |
p00901 | C++ | Runtime Error | #include <cctype>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int mod = 2011;
int inv[2011];
int ruijo(int x, int n) {
int p, ans;
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2) {
p = ruijo(x, n / 2);
ans = (x * p) % mod;
ans = (ans * p) % mod;
return ans;
} else {
p = ruijo(x, n / 2);
ans = (p * p) % mod;
return ans;
}
}
int n;
int m;
vector<string> v;
int expr(int a, int b, int c, int d);
int term(int a, int b, int c, int d);
int factor(int a, int b, int c, int d);
int powexpr(int a, int b, int c, int d);
int primary(int a, int b, int c, int d);
int expr(int a, int b, int c, int d) {
// cout << "expr " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return expr(a, b + 1, c, d);
}
int x_tmp = -1;
for (int i = a; i <= c; i++) {
if (v[i][d] != '.')
x_tmp = i;
}
if (x_tmp == -1) {
return expr(a, b, c, d - 1);
}
int y = b;
int yt = -1;
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
} else if (v[x][i] == ')') {
depth--;
} else if (depth == 0 &&
(v[x][i] == '*' || v[x][i] == '+' || v[x][i] == '-')) {
if (v[x][i] == '+') {
y = i;
yt = i;
} else if (v[x][i] == '*') {
yt = i;
} else {
if (i != d) {
if (v[x][i] == '-' && v[x][i + 1] == '.' && i < d - 1) {
if (yt + 2 == i) {
yt = i;
} else {
y = i;
yt = i;
}
}
}
}
}
}
if (y == b) {
return term(a, b, c, d);
} else {
if (v[x][y] == '-') {
return (mod + expr(a, b, c, y - 2) - term(a, y + 2, c, d)) % mod;
} else {
return (expr(a, b, c, y - 2) + term(a, y + 2, c, d)) % mod;
}
}
}
int term(int a, int b, int c, int d) {
// cout << "term " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return term(a, b + 1, c, d);
}
int y = b;
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
} else if (v[x][i] == ')') {
depth--;
} else if (depth == 0 && v[x][i] == '*') {
y = i;
}
}
if (y == b) {
return factor(a, b, c, d);
} else {
return (term(a, b, c, y - 2) * factor(a, y + 2, c, d)) % mod;
}
}
int factor(int a, int b, int c, int d) {
// cout << "factor " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return factor(a, b + 1, c, d);
}
if (v[x][b] != '-') {
return powexpr(a, b, c, d);
}
if (v[x][b + 1] == '-') {
return (expr(a, b, x - 1, d) * inv[expr(x + 1, b, c, d)]) % mod;
} else {
return (mod - factor(a, b + 2, c, d)) % mod;
}
}
int powexpr(int a, int b, int c, int d) {
// cout << "powexpr " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return powexpr(a, b + 1, c, d);
}
if (v[x][b] == '(') {
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
}
if (v[x][i] == ')') {
depth--;
if (depth == 0) {
if (x != 0 && i < d) {
if (v[x - 1][i + 1] != '.' && v[x - 1][b + 1] != '-') {
return ruijo(expr(a, b + 1, c, i - 1), v[x - 1][i + 1] - '0');
}
}
return expr(a, b + 1, c, i - 1);
}
}
}
} else {
if (x != 0 && b < d) {
if (v[x - 1][b + 1] != '.' && v[x - 1][b + 1] != '-') {
return ruijo(v[x][b] - '0', v[x - 1][b + 1] - '0');
}
}
return v[x][b] - '0';
}
}
int main() {
for (int i = 1; i < 2011; i++) {
inv[i] = ruijo(i, 2009);
}
while (cin >> n && n != 0) {
v.clear();
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
v.push_back(tmp);
}
m = v[0].size();
int ans = 0;
ans = expr(0, 0, n - 1, m - 1);
cout << ans << endl;
}
return 0;
}
| #include <cctype>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
int mod = 2011;
int inv[2011];
int ruijo(int x, int n) {
int p, ans;
if (n == 0)
return 1;
if (n == 1)
return x;
if (n % 2) {
p = ruijo(x, n / 2);
ans = (x * p) % mod;
ans = (ans * p) % mod;
return ans;
} else {
p = ruijo(x, n / 2);
ans = (p * p) % mod;
return ans;
}
}
int n;
int m;
vector<string> v;
int expr(int a, int b, int c, int d);
int term(int a, int b, int c, int d);
int factor(int a, int b, int c, int d);
int powexpr(int a, int b, int c, int d);
int primary(int a, int b, int c, int d);
int expr(int a, int b, int c, int d) {
// cout << "expr " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return expr(a, b + 1, c, d);
}
int x_tmp = -1;
for (int i = a; i <= c; i++) {
if (v[i][d] != '.')
x_tmp = i;
}
if (x_tmp == -1) {
return expr(a, b, c, d - 1);
}
int y = b;
int yt = -1;
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
} else if (v[x][i] == ')') {
depth--;
} else if (depth == 0 &&
(v[x][i] == '*' || v[x][i] == '+' || v[x][i] == '-')) {
if (v[x][i] == '+') {
y = i;
yt = i;
} else if (v[x][i] == '*') {
yt = i;
} else {
if (i == 0) {
if (v[x][i] == '-' && v[x][i + 1] == '.') {
yt = 0;
}
}
if (i != d && i != 0) {
if (v[x][i] == '-' && v[x][i + 1] == '.' && v[x][i - 1] == '.') {
if (yt + 2 == i) {
yt = i;
} else {
y = i;
yt = i;
}
}
}
}
}
}
if (y == b) {
return term(a, b, c, d);
} else {
if (v[x][y] == '-') {
return (mod + expr(a, b, c, y - 2) - term(a, y + 2, c, d)) % mod;
} else {
return (expr(a, b, c, y - 2) + term(a, y + 2, c, d)) % mod;
}
}
}
int term(int a, int b, int c, int d) {
// cout << "term " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return term(a, b + 1, c, d);
}
int y = b;
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
} else if (v[x][i] == ')') {
depth--;
} else if (depth == 0 && v[x][i] == '*') {
y = i;
}
}
if (y == b) {
return factor(a, b, c, d);
} else {
return (term(a, b, c, y - 2) * factor(a, y + 2, c, d)) % mod;
}
}
int factor(int a, int b, int c, int d) {
// cout << "factor " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return factor(a, b + 1, c, d);
}
if (v[x][b] != '-') {
return powexpr(a, b, c, d);
}
if (v[x][b + 1] == '-') {
return (expr(a, b, x - 1, d) * inv[expr(x + 1, b, c, d)]) % mod;
} else {
return (mod - factor(a, b + 2, c, d)) % mod;
}
}
int powexpr(int a, int b, int c, int d) {
// cout << "powexpr " << a << " " << b << " " << c << " " << d <<endl;
int x = -1;
for (int i = a; i <= c; i++) {
if (v[i][b] != '.')
x = i;
}
if (x == -1) {
return powexpr(a, b + 1, c, d);
}
if (v[x][b] == '(') {
int depth = 0;
for (int i = b; i <= d; i++) {
if (v[x][i] == '(') {
depth++;
}
if (v[x][i] == ')') {
depth--;
if (depth == 0) {
if (x != 0 && i < d) {
if (v[x - 1][i + 1] != '.' && v[x - 1][b + 1] != '-') {
return ruijo(expr(a, b + 1, c, i - 1), v[x - 1][i + 1] - '0');
}
}
return expr(a, b + 1, c, i - 1);
}
}
}
} else {
if (x != 0 && b < d) {
if (v[x - 1][b + 1] != '.' && v[x - 1][b + 1] != '-') {
return ruijo(v[x][b] - '0', v[x - 1][b + 1] - '0');
}
}
return v[x][b] - '0';
}
}
int main() {
for (int i = 1; i < 2011; i++) {
inv[i] = ruijo(i, 2009);
}
while (cin >> n && n != 0) {
v.clear();
for (int i = 0; i < n; i++) {
string tmp;
cin >> tmp;
v.push_back(tmp);
}
m = v[0].size();
int ans = 0;
ans = expr(0, 0, n - 1, m - 1);
cout << ans << endl;
}
return 0;
}
| replace | 72 | 74 | 72 | 79 | 0 | |
p00903 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
int n, m;
int d[55], e[55];
vector<Pi> G[55];
vector<Pi> rG[55];
int id[55], cnt[1010];
int dp[55][55][1 << 10];
struct State {
int u, v, bit, cost;
State() {}
State(int u, int v, int bit, int cost) : u(u), v(v), bit(bit), cost(cost) {}
bool operator<(const State &rhs) const { return cost > rhs.cost; }
};
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m, n || m) {
rep(i, n) {
G[i].clear();
rG[i].clear();
}
d[0] = 0;
e[0] = 0;
id[0] = cnt[0]++;
reps(i, 1, n - 1) {
cin >> d[i] >> e[i];
id[i] = cnt[e[i]]++;
}
d[n - 1] = 0;
e[n - 1] = 1000;
id[n - 1] = cnt[1000]++;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
G[a].emplace_back(b, c);
rG[b].emplace_back(a, c);
}
auto dijkstra = [&]() -> int {
fill((int *)dp[0], (int *)dp[55], inf);
priority_queue<State> que;
que.push(State(0, 0, 0, 0));
while (!que.empty()) {
State now = que.top();
que.pop();
// cout<<now.u<<" "<<now.v<<" "<<now.bit<<" "<<now.cost<<endl;
if (now.u == n - 1 && now.v == n - 1)
return now.cost;
if (dp[now.u][now.v][now.bit] < now.cost)
continue;
if (e[now.u] <= e[now.v]) {
for (Pi p : G[now.u]) {
State nxt = now;
if (e[now.u] > e[p.first])
continue;
if (e[now.v] != e[p.first]) {
nxt.u = p.first;
nxt.bit = 0;
nxt.cost += p.second + d[p.first];
} else if ((now.bit >> id[p.first]) & 1) {
nxt.u = p.first;
nxt.cost += p.second;
} else {
nxt.u = p.first;
nxt.bit |= (1 << id[p.first]) | (1 << id[now.v]);
nxt.cost += p.second + (p.first == now.v ? 0 : d[p.first]);
}
if (nxt.cost < dp[nxt.u][nxt.v][nxt.bit]) {
dp[nxt.u][nxt.v][nxt.bit] = nxt.cost;
que.emplace(nxt);
}
}
}
if (e[now.u] >= e[now.v]) {
for (Pi p : rG[now.v]) {
State nxt = now;
if (e[now.v] > e[p.first])
continue;
if (e[now.u] != e[p.first]) {
nxt.v = p.first;
nxt.bit = 0;
nxt.cost += p.second + d[p.first];
} else if ((now.bit >> id[p.first]) & 1) {
nxt.v = p.first;
nxt.cost += p.second;
} else {
nxt.v = p.first;
nxt.bit |= (1 << id[p.first]) | (1 << id[now.u]);
nxt.cost += p.second + (p.first == now.u ? 0 : d[p.first]);
}
if (nxt.cost < dp[nxt.u][nxt.v][nxt.bit]) {
dp[nxt.u][nxt.v][nxt.bit] = nxt.cost;
que.emplace(nxt);
}
}
}
}
return -1;
};
cout << dijkstra() << endl;
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
using Pi = pair<int, int>;
using Tapris = tuple<int, int, int>;
using vint = vector<int>;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
int n, m;
int d[55], e[55];
vector<Pi> G[55];
vector<Pi> rG[55];
int id[55], cnt[1010];
int dp[55][55][1 << 10];
struct State {
int u, v, bit, cost;
State() {}
State(int u, int v, int bit, int cost) : u(u), v(v), bit(bit), cost(cost) {}
bool operator<(const State &rhs) const { return cost > rhs.cost; }
};
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m, n || m) {
rep(i, n) {
G[i].clear();
rG[i].clear();
}
memset(cnt, 0, sizeof(cnt));
d[0] = 0;
e[0] = 0;
id[0] = cnt[0]++;
reps(i, 1, n - 1) {
cin >> d[i] >> e[i];
id[i] = cnt[e[i]]++;
}
d[n - 1] = 0;
e[n - 1] = 1000;
id[n - 1] = cnt[1000]++;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
G[a].emplace_back(b, c);
rG[b].emplace_back(a, c);
}
auto dijkstra = [&]() -> int {
fill((int *)dp[0], (int *)dp[55], inf);
priority_queue<State> que;
que.push(State(0, 0, 0, 0));
while (!que.empty()) {
State now = que.top();
que.pop();
// cout<<now.u<<" "<<now.v<<" "<<now.bit<<" "<<now.cost<<endl;
if (now.u == n - 1 && now.v == n - 1)
return now.cost;
if (dp[now.u][now.v][now.bit] < now.cost)
continue;
if (e[now.u] <= e[now.v]) {
for (Pi p : G[now.u]) {
State nxt = now;
if (e[now.u] > e[p.first])
continue;
if (e[now.v] != e[p.first]) {
nxt.u = p.first;
nxt.bit = 0;
nxt.cost += p.second + d[p.first];
} else if ((now.bit >> id[p.first]) & 1) {
nxt.u = p.first;
nxt.cost += p.second;
} else {
nxt.u = p.first;
nxt.bit |= (1 << id[p.first]) | (1 << id[now.v]);
nxt.cost += p.second + (p.first == now.v ? 0 : d[p.first]);
}
if (nxt.cost < dp[nxt.u][nxt.v][nxt.bit]) {
dp[nxt.u][nxt.v][nxt.bit] = nxt.cost;
que.emplace(nxt);
}
}
}
if (e[now.u] >= e[now.v]) {
for (Pi p : rG[now.v]) {
State nxt = now;
if (e[now.v] > e[p.first])
continue;
if (e[now.u] != e[p.first]) {
nxt.v = p.first;
nxt.bit = 0;
nxt.cost += p.second + d[p.first];
} else if ((now.bit >> id[p.first]) & 1) {
nxt.v = p.first;
nxt.cost += p.second;
} else {
nxt.v = p.first;
nxt.bit |= (1 << id[p.first]) | (1 << id[now.u]);
nxt.cost += p.second + (p.first == now.u ? 0 : d[p.first]);
}
if (nxt.cost < dp[nxt.u][nxt.v][nxt.bit]) {
dp[nxt.u][nxt.v][nxt.bit] = nxt.cost;
que.emplace(nxt);
}
}
}
}
return -1;
};
cout << dijkstra() << endl;
}
return 0;
}
| insert | 51 | 51 | 51 | 52 | 0 | |
p00904 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define repq(i, a, n) for (int(i) = (a); (i) <= (n); (i)++)
#define repr(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define int long long int
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
constexpr ll INF = 1001001001001001LL;
constexpr ll MOD = 1000000007LL;
signed main() {
int D;
cin >> D;
while (D--) {
int m, n;
cin >> m >> n;
int cnt = 0;
rep(p, -1500, 1500) rep(q, -1500, 1500) {
if (p == 0 && q == 0)
continue;
int sum = p * p + q * q;
if ((m * p + n * q) % sum)
continue;
if ((n * p - m * q) % sum)
continue;
cnt++;
}
cout << (cnt == 8 ? "P" : "C") << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define repq(i, a, n) for (int(i) = (a); (i) <= (n); (i)++)
#define repr(i, a, n) for (int(i) = (a); (i) >= (n); (i)--)
#define int long long int
template <typename T> void chmax(T &a, T b) { a = max(a, b); }
template <typename T> void chmin(T &a, T b) { a = min(a, b); }
template <typename T> void chadd(T &a, T b) { a = a + b; }
typedef pair<int, int> pii;
typedef long long ll;
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
constexpr ll INF = 1001001001001001LL;
constexpr ll MOD = 1000000007LL;
signed main() {
int D;
cin >> D;
while (D--) {
int m, n;
cin >> m >> n;
int cnt = 0;
rep(p, -300, 300) rep(q, -300, 300) {
if (p == 0 && q == 0)
continue;
int sum = p * p + q * q;
if ((m * p + n * q) % sum)
continue;
if ((n * p - m * q) % sum)
continue;
cnt++;
}
cout << (cnt == 8 ? "P" : "C") << endl;
}
return 0;
} | replace | 50 | 51 | 50 | 51 | TLE | |
p00904 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-12;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int N;
cin >> N;
REP(_, N) {
int p, q;
cin >> p >> q;
bool ok = true;
for (int m = -5000; m <= 5000; m++) {
for (int n = -5000; n <= 5000; n++) {
int a = m * m + n * n;
if (a <= 1 || 20000 <= a) {
continue;
}
int b = m * p + n * q;
int c = m * q - n * p;
if (b % a == 0 && c % a == 0) {
if ((m == p && n == q) || (-n == p && m == q) ||
(-m == p && -n == q) || (n == p && -m == q)) {
continue;
}
ok = false;
goto show;
}
}
}
show:
cout << (ok ? 'P' : 'C') << endl;
}
return 0;
} | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-12;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int N;
cin >> N;
REP(_, N) {
int p, q;
cin >> p >> q;
bool ok = true;
for (int m = -4000; m <= 4000; m++) {
for (int n = -4000; n <= 4000; n++) {
int a = m * m + n * n;
if (a <= 1 || 20000 <= a) {
continue;
}
int b = m * p + n * q;
int c = m * q - n * p;
if (b % a == 0 && c % a == 0) {
if ((m == p && n == q) || (-n == p && m == q) ||
(-m == p && -n == q) || (n == p && -m == q)) {
continue;
}
ok = false;
goto show;
}
}
}
show:
cout << (ok ? 'P' : 'C') << endl;
}
return 0;
} | replace | 51 | 53 | 51 | 53 | TLE | |
p00904 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define INF 100000000
typedef long long ll;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int main(void) {
int T;
cin >> T;
while (T--) {
int p, q;
cin >> p >> q;
int P = p * p + q * q;
int cnt = 0;
int ma = 0;
for (int i = 0; i <= P; i++)
ma = i;
for (int m = -ma; m <= ma; m++) {
for (int n = -ma; n <= ma; n++) {
int tmp = m * m + n * n;
if (tmp == 0)
continue;
if (P % tmp == 0) {
int mp = m * p + n * q;
int mq = m * q - n * p;
if (mp % tmp == 0 && mq % tmp == 0)
cnt++;
}
}
}
if (cnt == 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
} | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define INF 100000000
typedef long long ll;
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, 1, 0, -1};
int main(void) {
int T;
cin >> T;
while (T--) {
int p, q;
cin >> p >> q;
int P = p * p + q * q;
int cnt = 0;
int ma = 0;
for (int i = 0; i * i <= P; i++)
ma = i;
for (int m = -ma; m <= ma; m++) {
for (int n = -ma; n <= ma; n++) {
int tmp = m * m + n * n;
if (tmp == 0)
continue;
if (P % tmp == 0) {
int mp = m * p + n * q;
int mq = m * q - n * p;
if (mp % tmp == 0 && mq % tmp == 0)
cnt++;
}
}
}
if (cnt == 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p00904 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#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;
// common
typedef long long ll;
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// config
// #undef 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();
}
// ind -> V から V->ind (注:単射)
template <typename T> map<T, int> rev(const vector<T> &xs) {
map<T, int> rev;
REP(i, (int)xs.size()) rev.insert(make_pair(xs[i], i));
return rev;
}
template <typename T, typename V> inline T mod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
int INF = 1 << 28;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct Edge {
int from, to, d, c;
Edge(int u, int v, int d, int c) : from(u), to(v), d(d), c(c){};
};
struct Task {
int prev, pos, d;
Task(int prev, int pos, int d) : prev(prev), pos(pos), d(d){};
bool operator>(const Task &r) const { return d > r.d; }
};
typedef vector<vector<Edge>> Graph;
vector<int> dijkstra(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<int> d(V, INF);
d[s] = 0;
fill(ALL(prev), -2);
priority_queue<Task, vector<Task>, greater<Task>> que;
que.push(Task(-1, s, 0));
while (!que.empty()) {
Task task = que.top();
que.pop();
// if(prev[task.pos]!=-2)continue;
if (d[task.pos] < task.d)
continue;
prev[task.pos] = task.prev;
EACH(e, g[task.pos]) {
if (d[e->to] > d[e->from] + e->d) {
d[e->to] = d[e->from] + e->d;
que.push(Task(e->from, e->to, d[e->to]));
}
}
}
return d;
}
vector<int> dijkstra(const Graph &g, const int s) {
vector<int> prev(g.size());
return dijkstra(g, s, prev);
}
typedef int T;
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }
class Main {
public:
int N, M;
vector<vector<Edge>> es;
void run() {
int N;
cin >> N;
REP(i, N) {
int p, q;
cin >> p >> q;
int pq = p * p + q * q;
bool prime = true;
REP(m, pq + 1) REP(n, pq + 1) {
int mn = m * m + n * n;
if (mn > pq)
continue;
if (mn <= 1 || mn == pq)
continue;
if (pq % mn == 0) {
prime = false;
}
}
cout << (prime ? "P" : "C") << endl;
}
}
};
int main() {
Main().run();
return 0;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#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;
// common
typedef long long ll;
#define BR "\n"
#define ALL(c) (c).begin(), (c).end()
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define EACH(it, o) for (auto it = (o).begin(); it != (o).end(); ++it)
#define IN(l, v, r) ((l) <= (v) && (v) < (r))
// config
// #undef 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();
}
// ind -> V から V->ind (注:単射)
template <typename T> map<T, int> rev(const vector<T> &xs) {
map<T, int> rev;
REP(i, (int)xs.size()) rev.insert(make_pair(xs[i], i));
return rev;
}
template <typename T, typename V> inline T mod(T v, V MOD) {
return (v % MOD + MOD) % MOD;
}
int INF = 1 << 28;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
struct Edge {
int from, to, d, c;
Edge(int u, int v, int d, int c) : from(u), to(v), d(d), c(c){};
};
struct Task {
int prev, pos, d;
Task(int prev, int pos, int d) : prev(prev), pos(pos), d(d){};
bool operator>(const Task &r) const { return d > r.d; }
};
typedef vector<vector<Edge>> Graph;
vector<int> dijkstra(const Graph &g, const int s, vector<int> &prev) {
const int V = g.size();
vector<int> d(V, INF);
d[s] = 0;
fill(ALL(prev), -2);
priority_queue<Task, vector<Task>, greater<Task>> que;
que.push(Task(-1, s, 0));
while (!que.empty()) {
Task task = que.top();
que.pop();
// if(prev[task.pos]!=-2)continue;
if (d[task.pos] < task.d)
continue;
prev[task.pos] = task.prev;
EACH(e, g[task.pos]) {
if (d[e->to] > d[e->from] + e->d) {
d[e->to] = d[e->from] + e->d;
que.push(Task(e->from, e->to, d[e->to]));
}
}
}
return d;
}
vector<int> dijkstra(const Graph &g, const int s) {
vector<int> prev(g.size());
return dijkstra(g, s, prev);
}
typedef int T;
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }
class Main {
public:
int N, M;
vector<vector<Edge>> es;
void run() {
int N;
cin >> N;
REP(i, N) {
int p, q;
cin >> p >> q;
int pq = p * p + q * q;
bool prime = true;
REP(m, pq + 1) REP(n, pq + 1) {
int mn = m * m + n * n;
if (mn > pq)
break;
if (mn <= 1 || mn == pq)
continue;
if (pq % mn == 0) {
prime = false;
}
}
cout << (prime ? "P" : "C") << endl;
}
}
};
int main() {
Main().run();
return 0;
} | replace | 164 | 165 | 164 | 165 | TLE | |
p00904 | C++ | Runtime Error | #include <stdio.h>
int cnt[221212];
int X[221212];
int main() {
int i, j;
for (i = -400; i <= 400; i++) {
for (j = i; j <= 400; j++) {
if (i == 0 || j == 0)
cnt[i * i + j * j] += 2;
else
cnt[i * i + j * j]++;
}
}
for (i = 0; i <= 20000; i++) {
for (j = 0; i * j <= 20000 && j <= 20000; j++) {
if (cnt[i] && cnt[j])
X[i * j] += cnt[i];
}
}
int t, tc;
scanf("%d", &t);
for (tc = 0; tc < t; tc++) {
int a, b;
scanf("%d%d", &a, &b);
puts(X[a * a + b * b] != 8 ? "C" : "P");
}
return 0;
}
| #include <stdio.h>
int cnt[221212];
int X[221212];
int main() {
int i, j;
for (i = -200; i <= 200; i++) {
for (j = i; j <= 200; j++) {
if (i == 0 || j == 0)
cnt[i * i + j * j] += 2;
else
cnt[i * i + j * j]++;
}
}
for (i = 0; i <= 20000; i++) {
for (j = 0; i * j <= 20000 && j <= 20000; j++) {
if (cnt[i] && cnt[j])
X[i * j] += cnt[i];
}
}
int t, tc;
scanf("%d", &t);
for (tc = 0; tc < t; tc++) {
int a, b;
scanf("%d%d", &a, &b);
puts(X[a * a + b * b] != 8 ? "C" : "P");
}
return 0;
}
| replace | 6 | 8 | 6 | 8 | 0 | |
p00904 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <vector>
#define f first
#define s second
using namespace std;
typedef pair<int, int> P;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int t;
cin >> t;
while (t--) {
int p, q;
cin >> p >> q;
int tmp = p * p + q * q, cnt = 0;
for (int n = 0; n * n <= tmp; n++) {
for (int m = 0; m <= tmp; m++) {
if (m * m + n * n < 1)
continue;
int res = gcd(m * p + n * q, m * q - n * p);
if ((m * p + n * q) % (m * m + n * n) == 0 &&
(m * q - n * p) % (m * m + n * n) == 0)
cnt++;
}
}
if (cnt * 2 <= 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <set>
#include <vector>
#define f first
#define s second
using namespace std;
typedef pair<int, int> P;
int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
int main(void) {
int t;
cin >> t;
while (t--) {
int p, q;
cin >> p >> q;
int tmp = p * p + q * q, cnt = 0;
for (int n = 0; n * n <= tmp; n++) {
for (int m = 0; m * m <= tmp; m++) {
if (m * m + n * n < 1)
continue;
int res = gcd(m * p + n * q, m * q - n * p);
if ((m * p + n * q) % (m * m + n * n) == 0 &&
(m * q - n * p) % (m * m + n * n) == 0)
cnt++;
}
}
if (cnt * 2 <= 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
} | replace | 29 | 30 | 29 | 30 | TLE | |
p00904 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int m, n, t, c = 0;
cin >> m >> n;
t = m * m + n * n;
for (int i = 0; i < 10000; i++)
for (int j = 0; j < 10000; j++)
if (i * i + j * j < 1)
continue;
else if ((m * i + n * j) % (i * i + j * j) == 0 &&
(m * j - n * i) % (i * i + j * j) == 0)
c++;
if (c <= 4)
cout << 'P' << endl;
else
cout << 'C' << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int q;
cin >> q;
while (q--) {
int m, n, t, c = 0;
cin >> m >> n;
t = m * m + n * n;
for (int i = 0; i < 2000; i++)
for (int j = 0; j < 2000; j++)
if (i * i + j * j < 1)
continue;
else if ((m * i + n * j) % (i * i + j * j) == 0 &&
(m * j - n * i) % (i * i + j * j) == 0)
c++;
if (c <= 4)
cout << 'P' << endl;
else
cout << 'C' << endl;
}
} | replace | 9 | 11 | 9 | 11 | TLE | |
p00905 | C++ | Runtime Error | #include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int x[11][3], y[11][3], b[11];
int n, m;
string S[10], T[10];
void init() {
for (int i = 0; i < 33; i++) {
x[i / 3][i % 3] = 0;
y[i / 3][i % 3] = 0;
}
for (int i = 0; i < n; i++) {
x[i + 1][0] = x[i][0];
x[i + 1][1] = x[i][1];
x[i + 1][2] = x[i][2];
bool Ind = true;
for (int j = 0; j < S[i].size(); j++) {
if (S[i][j] != '.')
Ind = false;
if (Ind == true)
b[i] = j + 1;
if (S[i][j] == '(')
x[i + 1][0]++;
if (S[i][j] == ')')
x[i + 1][0]--;
if (S[i][j] == '{')
x[i + 1][1]++;
if (S[i][j] == '}')
x[i + 1][1]--;
if (S[i][j] == '[')
x[i + 1][2]++;
if (S[i][j] == ']')
x[i + 1][2]--;
}
}
for (int i = 0; i < m; i++) {
y[i + 1][0] = y[i][0];
y[i + 1][1] = y[i][1];
y[i + 1][2] = y[i][2];
for (int j = 0; j < T[i].size(); j++) {
if (T[i][j] == '(')
y[i + 1][0]++;
if (T[i][j] == ')')
y[i + 1][0]--;
if (T[i][j] == '{')
y[i + 1][1]++;
if (T[i][j] == '}')
y[i + 1][1]--;
if (T[i][j] == '[')
y[i + 1][2]++;
if (T[i][j] == ']')
y[i + 1][2]--;
}
}
}
vector<tuple<int, int, int>> search() {
vector<tuple<int, int, int>> vec;
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= 20; j++) {
for (int k = 1; k <= 20; k++) {
bool OK = true;
for (int l = 0; l < n; l++) {
if ((x[l][0] * i + x[l][1] * j + x[l][2] * k) != b[l])
OK = false;
}
if (OK == true)
vec.push_back(make_tuple(i, j, k));
}
}
}
return vec;
}
int main() {
while (true) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
for (int i = 0; i < n; i++)
cin >> S[i];
for (int i = 0; i < m; i++)
cin >> T[i];
vector<int> res[10];
init();
search();
vector<tuple<int, int, int>> F = search();
for (int i = 0; i < F.size(); i++) {
int a1 = get<0>(F[i]), a2 = get<1>(F[i]), a3 = get<2>(F[i]);
for (int j = 0; j < m; j++) {
int TT = y[j][0] * a1 + y[j][1] * a2 + y[j][2] * a3;
for (int k = 0; k < res[j].size(); k++) {
if (res[j][k] == TT)
goto E;
}
res[j].push_back(TT);
E:;
}
}
for (int i = 0; i < m; i++) {
if (i)
cout << ' ';
if (res[i].size() >= 2) {
cout << "-1";
} else {
cout << res[i][0];
}
}
cout << endl;
}
return 0;
} | #include <iostream>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
int x[11][3], y[11][3], b[11];
int n, m;
string S[10], T[10];
void init() {
for (int i = 0; i < 33; i++) {
x[i / 3][i % 3] = 0;
y[i / 3][i % 3] = 0;
b[i / 3] = 0;
}
for (int i = 0; i < n; i++) {
x[i + 1][0] = x[i][0];
x[i + 1][1] = x[i][1];
x[i + 1][2] = x[i][2];
bool Ind = true;
for (int j = 0; j < S[i].size(); j++) {
if (S[i][j] != '.')
Ind = false;
if (Ind == true)
b[i] = j + 1;
if (S[i][j] == '(')
x[i + 1][0]++;
if (S[i][j] == ')')
x[i + 1][0]--;
if (S[i][j] == '{')
x[i + 1][1]++;
if (S[i][j] == '}')
x[i + 1][1]--;
if (S[i][j] == '[')
x[i + 1][2]++;
if (S[i][j] == ']')
x[i + 1][2]--;
}
}
for (int i = 0; i < m; i++) {
y[i + 1][0] = y[i][0];
y[i + 1][1] = y[i][1];
y[i + 1][2] = y[i][2];
for (int j = 0; j < T[i].size(); j++) {
if (T[i][j] == '(')
y[i + 1][0]++;
if (T[i][j] == ')')
y[i + 1][0]--;
if (T[i][j] == '{')
y[i + 1][1]++;
if (T[i][j] == '}')
y[i + 1][1]--;
if (T[i][j] == '[')
y[i + 1][2]++;
if (T[i][j] == ']')
y[i + 1][2]--;
}
}
}
vector<tuple<int, int, int>> search() {
vector<tuple<int, int, int>> vec;
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= 20; j++) {
for (int k = 1; k <= 20; k++) {
bool OK = true;
for (int l = 0; l < n; l++) {
if ((x[l][0] * i + x[l][1] * j + x[l][2] * k) != b[l])
OK = false;
}
if (OK == true)
vec.push_back(make_tuple(i, j, k));
}
}
}
return vec;
}
int main() {
while (true) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
for (int i = 0; i < n; i++)
cin >> S[i];
for (int i = 0; i < m; i++)
cin >> T[i];
vector<int> res[10];
init();
search();
vector<tuple<int, int, int>> F = search();
for (int i = 0; i < F.size(); i++) {
int a1 = get<0>(F[i]), a2 = get<1>(F[i]), a3 = get<2>(F[i]);
for (int j = 0; j < m; j++) {
int TT = y[j][0] * a1 + y[j][1] * a2 + y[j][2] * a3;
for (int k = 0; k < res[j].size(); k++) {
if (res[j][k] == TT)
goto E;
}
res[j].push_back(TT);
E:;
}
}
for (int i = 0; i < m; i++) {
if (i)
cout << ' ';
if (res[i].size() >= 2) {
cout << "-1";
} else {
cout << res[i][0];
}
}
cout << endl;
}
return 0;
} | insert | 12 | 12 | 12 | 13 | 0 | |
p00906 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
namespace libcomp {
namespace math {
template <typename T> class Matrix {
private:
int N, M;
vector<vector<T>> data;
template <typename _Func> Matrix<T> apply(_Func f) const {
Matrix<T> ret(N, M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
ret(i, j) = f(data[i][j]);
}
}
return ret;
}
template <typename _Func> Matrix<T> apply_scalar(const T &s, _Func f) const {
return apply(bind2nd(f, s));
}
template <typename _Func>
Matrix<T> apply_mat(const Matrix<T> &m, _Func f) const {
assert(N == m.N && M == m.M);
Matrix<T> ret(N, M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
ret(i, j) = f(data[i][j], m(i, j));
}
}
return ret;
}
public:
Matrix(int N, int M) : N(N), M(M), data(N, vector<T>(M)) {}
int rows() const { return N; }
int columns() const { return M; }
const T &operator()(int i, int j) const { return data[i][j]; }
T &operator()(int i, int j) { return data[i][j]; }
Matrix<T> operator-() const { return apply(negate<T>()); }
Matrix<T> operator+(const T &s) const { return apply_scalar(s, plus<T>()); }
Matrix<T> &operator+=(const T &s) { return *this = *this + s; }
Matrix<T> operator-(const T &s) const { return apply_scalar(s, minus<T>()); }
Matrix<T> &operator-=(const T &s) { return *this = *this - s; }
Matrix<T> operator*(const T &s) const {
return apply_scalar(s, multiplies<T>());
}
Matrix<T> &operator*=(const T &s) { return *this = *this * s; }
Matrix<T> operator/(const T &s) const {
return apply_scalar(s, divides<T>());
}
Matrix<T> &operator/=(const T &s) { return *this = *this / s; }
Matrix<T> operator%(const T &s) const {
return apply_scalar(s, modulus<T>());
}
Matrix<T> &operator%=(const T &s) { return *this = *this % s; }
Matrix<T> operator+(const Matrix<T> &m) const {
return apply_mat(m, plus<T>());
}
Matrix<T> &operator+=(const Matrix<T> &m) { return *this = *this + m; }
Matrix<T> operator-(const Matrix<T> &m) const {
return apply_mat(m, minus<T>());
}
Matrix<T> &operator-=(const Matrix<T> &m) { return *this = *this - m; }
Matrix<T> operator*(const Matrix<T> &m) const {
assert(M == m.N);
Matrix<T> ret(N, m.M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < m.M; ++j) {
for (int k = 0; k < M; ++k) {
ret(i, j) += data[i][k] * m(k, j);
}
}
}
return ret;
}
Matrix<T> &operator*=(const Matrix<T> &m) { return *this = *this * m; }
};
template <typename T> ostream &operator<<(ostream &os, const Matrix<T> &m) {
for (int i = 0; i < m.rows(); ++i) {
for (int j = 0; j < m.columns(); ++j) {
os << m(i, j) << "\t";
}
os << endl;
}
return os;
}
} // namespace math
} // namespace libcomp
using libcomp::math::Matrix;
Matrix<ll> modpow(const Matrix<ll> &m, ll y, ll mod) {
if (y == 1) {
return m;
}
Matrix<ll> t = modpow(m, y / 2, mod);
t *= t;
for (int i = 0; i < t.rows(); ++i) {
for (int j = 0; j < t.columns(); ++j) {
t(i, j) %= mod;
}
}
if (y % 2 == 1) {
t *= m;
for (int i = 0; i < t.rows(); ++i) {
for (int j = 0; j < t.columns(); ++j) {
t(i, j) %= mod;
}
}
}
return t;
}
int main() {
ios_base::sync_with_stdio(false);
while (true) {
int n, m, a, b, c, t;
cin >> n >> m >> a >> b >> c >> t;
Matrix<ll> mat(n, n);
for (int i = 0; i < n; ++i) {
if (i > 0) {
mat(i, i - 1) = a;
}
mat(i, i) = b;
if (i + 1 < n) {
mat(i, i + 1) = c;
}
}
Matrix<ll> vec(n, 1);
for (int i = 0; i < n; ++i) {
cin >> vec(i, 0);
}
if (t > 0) {
vec = modpow(mat, t, m) * vec;
}
for (int i = 0; i < n; ++i) {
if (i != 0) {
cout << " ";
}
cout << vec(i, 0) % m;
}
cout << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <functional>
#include <iostream>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
namespace libcomp {
namespace math {
template <typename T> class Matrix {
private:
int N, M;
vector<vector<T>> data;
template <typename _Func> Matrix<T> apply(_Func f) const {
Matrix<T> ret(N, M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
ret(i, j) = f(data[i][j]);
}
}
return ret;
}
template <typename _Func> Matrix<T> apply_scalar(const T &s, _Func f) const {
return apply(bind2nd(f, s));
}
template <typename _Func>
Matrix<T> apply_mat(const Matrix<T> &m, _Func f) const {
assert(N == m.N && M == m.M);
Matrix<T> ret(N, M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < M; ++j) {
ret(i, j) = f(data[i][j], m(i, j));
}
}
return ret;
}
public:
Matrix(int N, int M) : N(N), M(M), data(N, vector<T>(M)) {}
int rows() const { return N; }
int columns() const { return M; }
const T &operator()(int i, int j) const { return data[i][j]; }
T &operator()(int i, int j) { return data[i][j]; }
Matrix<T> operator-() const { return apply(negate<T>()); }
Matrix<T> operator+(const T &s) const { return apply_scalar(s, plus<T>()); }
Matrix<T> &operator+=(const T &s) { return *this = *this + s; }
Matrix<T> operator-(const T &s) const { return apply_scalar(s, minus<T>()); }
Matrix<T> &operator-=(const T &s) { return *this = *this - s; }
Matrix<T> operator*(const T &s) const {
return apply_scalar(s, multiplies<T>());
}
Matrix<T> &operator*=(const T &s) { return *this = *this * s; }
Matrix<T> operator/(const T &s) const {
return apply_scalar(s, divides<T>());
}
Matrix<T> &operator/=(const T &s) { return *this = *this / s; }
Matrix<T> operator%(const T &s) const {
return apply_scalar(s, modulus<T>());
}
Matrix<T> &operator%=(const T &s) { return *this = *this % s; }
Matrix<T> operator+(const Matrix<T> &m) const {
return apply_mat(m, plus<T>());
}
Matrix<T> &operator+=(const Matrix<T> &m) { return *this = *this + m; }
Matrix<T> operator-(const Matrix<T> &m) const {
return apply_mat(m, minus<T>());
}
Matrix<T> &operator-=(const Matrix<T> &m) { return *this = *this - m; }
Matrix<T> operator*(const Matrix<T> &m) const {
assert(M == m.N);
Matrix<T> ret(N, m.M);
for (int i = 0; i < N; ++i) {
for (int j = 0; j < m.M; ++j) {
for (int k = 0; k < M; ++k) {
ret(i, j) += data[i][k] * m(k, j);
}
}
}
return ret;
}
Matrix<T> &operator*=(const Matrix<T> &m) { return *this = *this * m; }
};
template <typename T> ostream &operator<<(ostream &os, const Matrix<T> &m) {
for (int i = 0; i < m.rows(); ++i) {
for (int j = 0; j < m.columns(); ++j) {
os << m(i, j) << "\t";
}
os << endl;
}
return os;
}
} // namespace math
} // namespace libcomp
using libcomp::math::Matrix;
Matrix<ll> modpow(const Matrix<ll> &m, ll y, ll mod) {
if (y == 1) {
return m;
}
Matrix<ll> t = modpow(m, y / 2, mod);
t *= t;
for (int i = 0; i < t.rows(); ++i) {
for (int j = 0; j < t.columns(); ++j) {
t(i, j) %= mod;
}
}
if (y % 2 == 1) {
t *= m;
for (int i = 0; i < t.rows(); ++i) {
for (int j = 0; j < t.columns(); ++j) {
t(i, j) %= mod;
}
}
}
return t;
}
int main() {
ios_base::sync_with_stdio(false);
while (true) {
int n, m, a, b, c, t;
cin >> n >> m >> a >> b >> c >> t;
if (n == 0) {
break;
}
Matrix<ll> mat(n, n);
for (int i = 0; i < n; ++i) {
if (i > 0) {
mat(i, i - 1) = a;
}
mat(i, i) = b;
if (i + 1 < n) {
mat(i, i + 1) = c;
}
}
Matrix<ll> vec(n, 1);
for (int i = 0; i < n; ++i) {
cin >> vec(i, 0);
}
if (t > 0) {
vec = modpow(mat, t, m) * vec;
}
for (int i = 0; i < n; ++i) {
if (i != 0) {
cout << " ";
}
cout << vec(i, 0) % m;
}
cout << endl;
}
return 0;
} | insert | 145 | 145 | 145 | 148 | TLE | |
p00907 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using Array = vector<double>;
using Matrix = vector<Array>;
const double eps = 1e-10;
Array GaussJordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (abs(B[i][j]) > abs(B[pivot][i]))
pivot = i;
}
swap(B[i], B[pivot]);
if (abs(B[i][i]) < eps)
return Array();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
}
Array x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
double a[10];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int d;
while (cin >> d, d) {
for (int i = 0; i < d + 3; i++) {
cin >> a[i];
}
vector<int> ans;
for (int i = 0; i < d + 3; i++) {
Array y;
bool flag = true;
for (int j = 0; j < d + 3; j++) {
if (i == j)
continue;
Matrix A;
Array b;
for (int x = 0; x < d + 3; x++) {
if (i == x || j == x)
continue;
Array arr(d + 1);
for (int k = 0; k <= d; k++) {
arr[k] = pow(x, k);
}
A.push_back(arr);
b.push_back(a[x]);
}
Array r = GaussJordan(A, b);
if (r.size()) {
if (y.size() == 0)
y = r;
else {
for (int k = 0; k < r.size(); k++) {
if (abs(r[k] - y[k]) > 1e-4) {
flag = false;
break;
}
}
}
} else {
flag = false;
}
if (!flag)
break;
}
if (flag)
ans.push_back(i);
}
cout << ans[0] << endl;
}
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
using Array = vector<double>;
using Matrix = vector<Array>;
const double eps = 1e-10;
Array GaussJordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (abs(B[i][j]) > abs(B[pivot][i]))
pivot = i;
}
swap(B[i], B[pivot]);
if (abs(B[i][i]) < eps)
return Array();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
}
Array x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
double a[10];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int d;
while (cin >> d, d) {
for (int i = 0; i < d + 3; i++) {
cin >> a[i];
}
vector<int> ans;
for (int i = 0; i < d + 3; i++) {
Array y;
bool flag = true;
for (int j = 0; j < d + 3; j++) {
if (i == j)
continue;
Matrix A;
Array b;
for (int x = 0; x < d + 3; x++) {
if (i == x || j == x)
continue;
Array arr(d + 1);
for (int k = 0; k <= d; k++) {
arr[k] = pow(x, k);
}
A.push_back(arr);
b.push_back(a[x]);
}
Array r = GaussJordan(A, b);
if (r.size()) {
if (y.size() == 0)
y = r;
else {
for (int k = 0; k < r.size(); k++) {
if (abs(r[k] - y[k]) > 1e-1) {
flag = false;
break;
}
}
}
} else {
flag = false;
}
if (!flag)
break;
}
if (flag)
ans.push_back(i);
}
cout << ans[0] << endl;
}
} | replace | 85 | 86 | 85 | 86 | 0 | |
p00907 | C++ | Runtime Error | #include <iostream>
using namespace std;
int D;
double V[5];
double absd(double x) {
if (x < 0) {
return -x;
}
return x;
}
double interpolate(int n, int E) {
double sum = 0.0;
for (int k = 0; k < D + 3; k++) {
if (k == n || k == E) {
continue;
}
double p = V[k];
for (int i = 0; i < D + 3; i++) {
if (i != k && i != n && i != E) {
p *= (n - i) / (double)(k - i);
}
}
sum += p;
}
return sum;
}
bool outlier(int E) {
for (int i = 0; i < D + 3; i++) {
if (i == E) {
continue;
}
double p = interpolate(i, E);
if (absd(p - V[i]) > 0.1) {
return false;
}
}
return true;
}
int main() {
while (cin >> D && D != 0) {
for (int i = 0; i < D + 3; i++) {
cin >> V[i];
}
for (int i = 0; i < D + 3; i++) {
if (outlier(i)) {
cout << i << endl;
break;
}
}
}
} | #include <iostream>
using namespace std;
int D;
double V[100];
double absd(double x) {
if (x < 0) {
return -x;
}
return x;
}
double interpolate(int n, int E) {
double sum = 0.0;
for (int k = 0; k < D + 3; k++) {
if (k == n || k == E) {
continue;
}
double p = V[k];
for (int i = 0; i < D + 3; i++) {
if (i != k && i != n && i != E) {
p *= (n - i) / (double)(k - i);
}
}
sum += p;
}
return sum;
}
bool outlier(int E) {
for (int i = 0; i < D + 3; i++) {
if (i == E) {
continue;
}
double p = interpolate(i, E);
if (absd(p - V[i]) > 0.1) {
return false;
}
}
return true;
}
int main() {
while (cin >> D && D != 0) {
for (int i = 0; i < D + 3; i++) {
cin >> V[i];
}
for (int i = 0; i < D + 3; i++) {
if (outlier(i)) {
cout << i << endl;
break;
}
}
}
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00908 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define dump(n) cout << "# " << #n << '=' << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
rep(i, a.size()) os << (i ? " " : "") << a[i];
return os << ']';
}
typedef vector<vvi> vvvi;
typedef vector<vvvi> vvvvi;
template <typename Functor> struct functor_traits {
template <typename C, typename Ret, typename Arg, typename... Args>
static Arg helper(Ret (C::*)(Arg, Args...));
template <typename C, typename Ret, typename Arg, typename... Args>
static Arg helper(Ret (C::*)(Arg, Args...) const);
typedef decltype(helper(&Functor::operator())) first_argument_type;
};
template <typename Compare,
typename T = typename functor_traits<Compare>::first_argument_type>
priority_queue<T, vector<T>, Compare> make_priority_queue(Compare comp) {
return priority_queue<T, vector<T>, Compare>(move(comp));
}
bool in(int h, int w, int i, int j) {
return 0 <= i && i < h && 0 <= j && j < w;
}
bool in(int h, int w, pii p) { return in(h, w, p.first, p.second); }
int calc(vs grid, pii king, pii a, pii b) {
int h = grid.size(), w = grid[0].size();
rep(i, 2) rep(j, 2) grid[king.first + i][king.second + j] = '*';
vvi dist(h, vi(w, INF));
queue<tuple<int, int, int>> q;
q.emplace(a.first, a.second, 0);
while (q.size()) {
int i, j, d;
tie(i, j, d) = q.front();
q.pop();
if (!in(h, w, i, j) || grid[i][j] == '*' || dist[i][j] != INF)
continue;
dist[i][j] = d;
rep(k, 4) q.emplace(i + "\xff\x1\0\0"[k], j + "\0\0\xff\x1"[k], d + 1);
}
return dist[b.first][b.second];
}
int calc(vs grid, pii king, pii p1, pii p2, pii q1, pii q2) {
return min(calc(grid, king, p1, q1) + calc(grid, king, p2, q2),
calc(grid, king, p1, q2) + calc(grid, king, p2, q1));
// int h=grid.size(),w=grid[0].size();
// rep(i,2) rep(j,2) grid[king.first+i][king.second+j]='*';
// vvvvi dist(h,vvvi(w,vvi(h,vi(w,INF))));
// queue<tuple<int,int,int,int,int>> q;
// q.emplace(p1.first,p1.second,p2.first,p2.second,0);
// while(q.size()){
// int i1,j1,i2,j2,d; tie(i1,j1,i2,j2,d)=q.front(); q.pop();
// if(!in(h,w,i1,j1) || !in(h,w,i2,j2) || grid[i1][j1]=='*' ||
//grid[i2][j2]=='*'
// || (i1==i2 && j1==j2) || dist[i1][j1][i2][j2]!=INF) continue;
// dist[i1][j1][i2][j2]=dist[i2][j2][i1][j1]=d;
// rep(k,4){
// q.emplace(i1+"\xff\x1\0\0"[k],j1+"\0\0\xff\x1"[k],i2,j2,d+1);
// q.emplace(i1,j1,i2+"\xff\x1\0\0"[k],j2+"\0\0\xff\x1"[k],d+1);
// }
// }
// return dist[q1.first][q1.second][q2.first][q2.second];
}
int main() {
for (int h, w; cin >> h >> w && h | w;) {
vs grid(h);
rep(i, h) cin >> grid[i];
// dump(mp(h,w));
// rep(i,h) cout<<grid[i]<<endl;
if (grid[0][0] == 'X') {
cout << 0 << endl;
continue;
}
auto pq = make_priority_queue(
[](tuple<int, int, int, int> a, tuple<int, int, int, int> b) {
return get<3>(a) > get<3>(b);
});
{
pii king(-1, -1), open1(-1, -1), open2(-1, -1);
rep(i, h) rep(j, w) {
if (grid[i][j] == 'X') {
if (king == mp(-1, -1))
king = mp(i, j);
grid[i][j] = '.';
} else if (grid[i][j] == '.')
(open1 == mp(-1, -1) ? open1 : open2) = mp(i, j);
else if (grid[i][j] == 'o')
grid[i][j] = '.';
}
int ki = king.first, kj = king.second;
if (in(h, w, ki - 1, kj) && grid[ki - 1][kj] != '*' &&
grid[ki - 1][kj + 1] != '*')
pq.emplace(
ki, kj, 0,
calc(grid, king, open1, open2, mp(ki - 1, kj), mp(ki - 1, kj + 1)));
if (in(h, w, ki + 2, kj) && grid[ki + 2][kj] != '*' &&
grid[ki + 2][kj + 1] != '*')
pq.emplace(
ki, kj, 1,
calc(grid, king, open1, open2, mp(ki + 2, kj), mp(ki + 2, kj + 1)));
if (in(h, w, ki, kj - 1) && grid[ki][kj - 1] != '*' &&
grid[ki + 1][kj - 1] != '*')
pq.emplace(
ki, kj, 2,
calc(grid, king, open1, open2, mp(ki, kj - 1), mp(ki + 1, kj - 1)));
if (in(h, w, ki, kj + 2) && grid[ki][kj + 2] != '*' &&
grid[ki + 1][kj + 2] != '*')
pq.emplace(
ki, kj, 3,
calc(grid, king, open1, open2, mp(ki, kj + 2), mp(ki + 1, kj + 2)));
}
vvvi dist(h, vvi(w, vi(4, INF)));
while (pq.size()) {
// if(rand()%1000==0) printf("> %d\n",pq.size());
int ki, kj, dir, step;
tie(ki, kj, dir, step) = pq.top();
pq.pop();
if (!in(h, w, ki, kj) || dist[ki][kj][dir] != INF)
continue;
dist[ki][kj][dir] = step;
if (step >= INF)
break;
pii open1, open2;
if (dir == 0)
open1 = mp(ki - 1, kj), open2 = mp(ki - 1, kj + 1);
if (dir == 1)
open1 = mp(ki + 2, kj), open2 = mp(ki + 2, kj + 1);
if (dir == 2)
open1 = mp(ki, kj - 1), open2 = mp(ki + 1, kj - 1);
if (dir == 3)
open1 = mp(ki, kj + 2), open2 = mp(ki + 1, kj + 2);
pq.emplace(ki + "\xff\x1\0\0"[dir], kj + "\0\0\xff\x1"[dir], dir ^ 1,
step + 1);
if (in(h, w, ki - 1, kj) && grid[ki - 1][kj] != '*' &&
grid[ki - 1][kj + 1] != '*')
pq.emplace(ki, kj, 0,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki - 1, kj),
mp(ki - 1, kj + 1)));
if (in(h, w, ki + 2, kj) && grid[ki + 2][kj] != '*' &&
grid[ki + 2][kj + 1] != '*')
pq.emplace(ki, kj, 1,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki + 2, kj),
mp(ki + 2, kj + 1)));
if (in(h, w, ki, kj - 1) && grid[ki][kj - 1] != '*' &&
grid[ki + 1][kj - 1] != '*')
pq.emplace(ki, kj, 2,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki, kj - 1),
mp(ki + 1, kj - 1)));
if (in(h, w, ki, kj + 2) && grid[ki][kj + 2] != '*' &&
grid[ki + 1][kj + 2] != '*')
pq.emplace(ki, kj, 3,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki, kj + 2),
mp(ki + 1, kj + 2)));
}
int res = *min_element(all(dist[0][0]));
cout << (res < INF ? res : -1) << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define dump(n) cout << "# " << #n << '=' << (n) << endl
#define repi(i, a, b) for (int i = int(a); i < int(b); i++)
#define peri(i, a, b) for (int i = int(b); i-- > int(a);)
#define rep(i, n) repi(i, 0, n)
#define per(i, n) peri(i, 0, n)
#define all(c) begin(c), end(c)
#define mp make_pair
#define mt make_tuple
typedef unsigned int uint;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<ll> vl;
typedef vector<vl> vvl;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef vector<string> vs;
const int INF = 1e9;
const int MOD = 1e9 + 7;
const double EPS = 1e-9;
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << '(' << p.first << ',' << p.second << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &a) {
os << '[';
rep(i, a.size()) os << (i ? " " : "") << a[i];
return os << ']';
}
typedef vector<vvi> vvvi;
typedef vector<vvvi> vvvvi;
template <typename Functor> struct functor_traits {
template <typename C, typename Ret, typename Arg, typename... Args>
static Arg helper(Ret (C::*)(Arg, Args...));
template <typename C, typename Ret, typename Arg, typename... Args>
static Arg helper(Ret (C::*)(Arg, Args...) const);
typedef decltype(helper(&Functor::operator())) first_argument_type;
};
template <typename Compare,
typename T = typename functor_traits<Compare>::first_argument_type>
priority_queue<T, vector<T>, Compare> make_priority_queue(Compare comp) {
return priority_queue<T, vector<T>, Compare>(move(comp));
}
bool in(int h, int w, int i, int j) {
return 0 <= i && i < h && 0 <= j && j < w;
}
bool in(int h, int w, pii p) { return in(h, w, p.first, p.second); }
int calc(vs grid, pii king, pii a, pii b) {
int h = grid.size(), w = grid[0].size();
rep(i, 2) rep(j, 2) grid[king.first + i][king.second + j] = '*';
vvi dist(h, vi(w, INF));
queue<tuple<int, int, int>> q;
q.emplace(a.first, a.second, 0);
while (q.size()) {
int i, j, d;
tie(i, j, d) = q.front();
q.pop();
if (!in(h, w, i, j) || grid[i][j] == '*' || dist[i][j] != INF)
continue;
dist[i][j] = d;
if (mp(i, j) == b)
return d;
rep(k, 4) q.emplace(i + "\xff\x1\0\0"[k], j + "\0\0\xff\x1"[k], d + 1);
}
return dist[b.first][b.second];
}
int calc(vs grid, pii king, pii p1, pii p2, pii q1, pii q2) {
return min(calc(grid, king, p1, q1) + calc(grid, king, p2, q2),
calc(grid, king, p1, q2) + calc(grid, king, p2, q1));
// int h=grid.size(),w=grid[0].size();
// rep(i,2) rep(j,2) grid[king.first+i][king.second+j]='*';
// vvvvi dist(h,vvvi(w,vvi(h,vi(w,INF))));
// queue<tuple<int,int,int,int,int>> q;
// q.emplace(p1.first,p1.second,p2.first,p2.second,0);
// while(q.size()){
// int i1,j1,i2,j2,d; tie(i1,j1,i2,j2,d)=q.front(); q.pop();
// if(!in(h,w,i1,j1) || !in(h,w,i2,j2) || grid[i1][j1]=='*' ||
//grid[i2][j2]=='*'
// || (i1==i2 && j1==j2) || dist[i1][j1][i2][j2]!=INF) continue;
// dist[i1][j1][i2][j2]=dist[i2][j2][i1][j1]=d;
// rep(k,4){
// q.emplace(i1+"\xff\x1\0\0"[k],j1+"\0\0\xff\x1"[k],i2,j2,d+1);
// q.emplace(i1,j1,i2+"\xff\x1\0\0"[k],j2+"\0\0\xff\x1"[k],d+1);
// }
// }
// return dist[q1.first][q1.second][q2.first][q2.second];
}
int main() {
for (int h, w; cin >> h >> w && h | w;) {
vs grid(h);
rep(i, h) cin >> grid[i];
// dump(mp(h,w));
// rep(i,h) cout<<grid[i]<<endl;
if (grid[0][0] == 'X') {
cout << 0 << endl;
continue;
}
auto pq = make_priority_queue(
[](tuple<int, int, int, int> a, tuple<int, int, int, int> b) {
return get<3>(a) > get<3>(b);
});
{
pii king(-1, -1), open1(-1, -1), open2(-1, -1);
rep(i, h) rep(j, w) {
if (grid[i][j] == 'X') {
if (king == mp(-1, -1))
king = mp(i, j);
grid[i][j] = '.';
} else if (grid[i][j] == '.')
(open1 == mp(-1, -1) ? open1 : open2) = mp(i, j);
else if (grid[i][j] == 'o')
grid[i][j] = '.';
}
int ki = king.first, kj = king.second;
if (in(h, w, ki - 1, kj) && grid[ki - 1][kj] != '*' &&
grid[ki - 1][kj + 1] != '*')
pq.emplace(
ki, kj, 0,
calc(grid, king, open1, open2, mp(ki - 1, kj), mp(ki - 1, kj + 1)));
if (in(h, w, ki + 2, kj) && grid[ki + 2][kj] != '*' &&
grid[ki + 2][kj + 1] != '*')
pq.emplace(
ki, kj, 1,
calc(grid, king, open1, open2, mp(ki + 2, kj), mp(ki + 2, kj + 1)));
if (in(h, w, ki, kj - 1) && grid[ki][kj - 1] != '*' &&
grid[ki + 1][kj - 1] != '*')
pq.emplace(
ki, kj, 2,
calc(grid, king, open1, open2, mp(ki, kj - 1), mp(ki + 1, kj - 1)));
if (in(h, w, ki, kj + 2) && grid[ki][kj + 2] != '*' &&
grid[ki + 1][kj + 2] != '*')
pq.emplace(
ki, kj, 3,
calc(grid, king, open1, open2, mp(ki, kj + 2), mp(ki + 1, kj + 2)));
}
vvvi dist(h, vvi(w, vi(4, INF)));
while (pq.size()) {
// if(rand()%1000==0) printf("> %d\n",pq.size());
int ki, kj, dir, step;
tie(ki, kj, dir, step) = pq.top();
pq.pop();
if (!in(h, w, ki, kj) || dist[ki][kj][dir] != INF)
continue;
dist[ki][kj][dir] = step;
if (step >= INF)
break;
pii open1, open2;
if (dir == 0)
open1 = mp(ki - 1, kj), open2 = mp(ki - 1, kj + 1);
if (dir == 1)
open1 = mp(ki + 2, kj), open2 = mp(ki + 2, kj + 1);
if (dir == 2)
open1 = mp(ki, kj - 1), open2 = mp(ki + 1, kj - 1);
if (dir == 3)
open1 = mp(ki, kj + 2), open2 = mp(ki + 1, kj + 2);
pq.emplace(ki + "\xff\x1\0\0"[dir], kj + "\0\0\xff\x1"[dir], dir ^ 1,
step + 1);
if (in(h, w, ki - 1, kj) && grid[ki - 1][kj] != '*' &&
grid[ki - 1][kj + 1] != '*')
pq.emplace(ki, kj, 0,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki - 1, kj),
mp(ki - 1, kj + 1)));
if (in(h, w, ki + 2, kj) && grid[ki + 2][kj] != '*' &&
grid[ki + 2][kj + 1] != '*')
pq.emplace(ki, kj, 1,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki + 2, kj),
mp(ki + 2, kj + 1)));
if (in(h, w, ki, kj - 1) && grid[ki][kj - 1] != '*' &&
grid[ki + 1][kj - 1] != '*')
pq.emplace(ki, kj, 2,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki, kj - 1),
mp(ki + 1, kj - 1)));
if (in(h, w, ki, kj + 2) && grid[ki][kj + 2] != '*' &&
grid[ki + 1][kj + 2] != '*')
pq.emplace(ki, kj, 3,
step + calc(grid, mp(ki, kj), open1, open2, mp(ki, kj + 2),
mp(ki + 1, kj + 2)));
}
int res = *min_element(all(dist[0][0]));
cout << (res < INF ? res : -1) << endl;
}
} | insert | 72 | 72 | 72 | 74 | TLE | |
p00908 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
typedef pair<int, int> P;
typedef pair<P, P> PP;
int n, m, INF = 1 << 29, dxx[4] = {-1, 0, 1, 0}, dyy[4] = {0, -1, 0, 1};
int dx[8] = {-1, -1, 0, 1, 2, 2, 0, 1}, dy[8] = {0, 1, -1, -1, 0, 1, 2, 2};
string s[55];
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
bool check(int x, int y, int xx, int yy) {
if (x >= 0 && x < n && y >= 0 && y < m) {
if (s[x][y] == '*')
return 0;
if (x == xx && (y == yy || y == yy + 1))
return 0;
if (x == xx + 1 && (y == yy || y == yy + 1))
return 0;
return 1;
}
return 0;
}
int calc(int sx, int sy, int tx, int ty, int xx, int yy) {
if (!check(sx, sy, xx, yy) || !check(tx, ty, xx, yy))
return INF;
int d[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
d[i][j] = INF;
d[sx][sy] = 0;
queue<P> que;
que.push(P(sx, sy));
while (!que.empty()) {
P p = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int x = p.F + dxx[i], y = p.S + dyy[i];
if (!check(x, y, xx, yy) || d[x][y] <= d[p.F][p.S] + 1)
continue;
d[x][y] = d[p.F][p.S] + 1;
que.push(P(x, y));
}
}
return d[tx][ty];
}
int main() {
while (cin >> n >> m && n) {
for (int i = 0; i < n; i++)
cin >> s[i];
int d[n][m][4];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++)
d[i][j][k] = INF;
vector<P> v;
P p = P(-1, -1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == '.')
v.push_back(P(i, j));
if (s[i][j] == 'X' && p.F == -1)
p = P(i, j);
}
if (p == P(0, 0)) {
cout << 0 << endl;
continue;
}
priority_queue<PP> que;
for (int i = 0; i < 4; i++) {
int b[2] = {0, 1};
do {
int cost = calc(v[0].F, v[0].S, p.F + dx[i * 2 + b[0]],
p.S + dy[i * 2 + b[0]], p.F, p.S);
cost += calc(v[1].F, v[1].S, p.F + dx[i * 2 + b[1]],
p.S + dy[i * 2 + b[1]], p.F, p.S);
d[p.F][p.S][i] = min(d[p.F][p.S][i], cost);
} while (next_permutation(b, b + 2));
que.push(PP(P(0, i), p));
}
while (!que.empty()) {
PP pp = que.top();
que.pop();
int x = pp.S.F, y = pp.S.S, k = pp.F.S, c = pp.F.F;
if (d[x][y][k] < c)
continue;
for (int i = 0; i < 4; i++) {
int xx = x + dxx[i], yy = y + dyy[i];
int cost = INF;
int b[2] = {0, 1};
do {
int sum = calc(x + dx[k * 2], y + dy[k * 2], x + dx[i * 2 + b[0]],
y + dy[i * 2 + b[0]], x, y);
sum += calc(x + dx[k * 2 + 1], y + dy[k * 2 + 1],
x + dx[i * 2 + b[1]], y + dy[i * 2 + b[1]], x, y);
cost = min(cost, sum);
} while (next_permutation(b, b + 2));
if (!check(xx, yy) || d[xx][yy][(i + 2) % 4] <= d[x][y][k] + cost + 1)
continue;
d[xx][yy][(i + 2) % 4] = d[x][y][k] + cost + 1;
que.push(PP(P(d[xx][yy][(i + 2) % 4], (i + 2) % 4), P(xx, yy)));
}
}
int ans = INF;
for (int i = 0; i < 4; i++)
ans = min(ans, d[0][0][i]);
if (ans == INF)
ans = -1;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define F first
#define S second
typedef pair<int, int> P;
typedef pair<P, P> PP;
int n, m, INF = 1 << 29, dxx[4] = {-1, 0, 1, 0}, dyy[4] = {0, -1, 0, 1};
int dx[8] = {-1, -1, 0, 1, 2, 2, 0, 1}, dy[8] = {0, 1, -1, -1, 0, 1, 2, 2};
string s[55];
bool check(int x, int y) { return x >= 0 && x < n && y >= 0 && y < m; }
bool check(int x, int y, int xx, int yy) {
if (x >= 0 && x < n && y >= 0 && y < m) {
if (s[x][y] == '*')
return 0;
if (x == xx && (y == yy || y == yy + 1))
return 0;
if (x == xx + 1 && (y == yy || y == yy + 1))
return 0;
return 1;
}
return 0;
}
int calc(int sx, int sy, int tx, int ty, int xx, int yy) {
if (!check(sx, sy, xx, yy) || !check(tx, ty, xx, yy))
return INF;
int d[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
d[i][j] = INF;
d[sx][sy] = 0;
queue<P> que;
que.push(P(sx, sy));
while (!que.empty()) {
P p = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int x = p.F + dxx[i], y = p.S + dyy[i];
if (!check(x, y, xx, yy) || d[x][y] <= d[p.F][p.S] + 1)
continue;
d[x][y] = d[p.F][p.S] + 1;
que.push(P(x, y));
}
}
return d[tx][ty];
}
int main() {
while (cin >> n >> m && n) {
for (int i = 0; i < n; i++)
cin >> s[i];
int d[n][m][4];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
for (int k = 0; k < 4; k++)
d[i][j][k] = INF;
vector<P> v;
P p = P(-1, -1);
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++) {
if (s[i][j] == '.')
v.push_back(P(i, j));
if (s[i][j] == 'X' && p.F == -1)
p = P(i, j);
}
if (p == P(0, 0)) {
cout << 0 << endl;
continue;
}
priority_queue<PP, vector<PP>, greater<PP>> que;
for (int i = 0; i < 4; i++) {
int b[2] = {0, 1};
do {
int cost = calc(v[0].F, v[0].S, p.F + dx[i * 2 + b[0]],
p.S + dy[i * 2 + b[0]], p.F, p.S);
cost += calc(v[1].F, v[1].S, p.F + dx[i * 2 + b[1]],
p.S + dy[i * 2 + b[1]], p.F, p.S);
d[p.F][p.S][i] = min(d[p.F][p.S][i], cost);
} while (next_permutation(b, b + 2));
que.push(PP(P(0, i), p));
}
while (!que.empty()) {
PP pp = que.top();
que.pop();
int x = pp.S.F, y = pp.S.S, k = pp.F.S, c = pp.F.F;
if (d[x][y][k] < c)
continue;
for (int i = 0; i < 4; i++) {
int xx = x + dxx[i], yy = y + dyy[i];
int cost = INF;
int b[2] = {0, 1};
do {
int sum = calc(x + dx[k * 2], y + dy[k * 2], x + dx[i * 2 + b[0]],
y + dy[i * 2 + b[0]], x, y);
sum += calc(x + dx[k * 2 + 1], y + dy[k * 2 + 1],
x + dx[i * 2 + b[1]], y + dy[i * 2 + b[1]], x, y);
cost = min(cost, sum);
} while (next_permutation(b, b + 2));
if (!check(xx, yy) || d[xx][yy][(i + 2) % 4] <= d[x][y][k] + cost + 1)
continue;
d[xx][yy][(i + 2) % 4] = d[x][y][k] + cost + 1;
que.push(PP(P(d[xx][yy][(i + 2) % 4], (i + 2) % 4), P(xx, yy)));
}
}
int ans = INF;
for (int i = 0; i < 4; i++)
ans = min(ans, d[0][0][i]);
if (ans == INF)
ans = -1;
cout << ans << endl;
}
return 0;
} | replace | 69 | 70 | 69 | 70 | TLE | |
p00908 | C++ | Time Limit Exceeded | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
char str[60][60];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int bfs[60][60];
int ijk[60][60][4];
int v[60][60][4];
int dis[2][2];
int a, b;
int calc(vector<pair<int, int>> st, vector<pair<int, int>> go, int xr, int xc) {
for (int l = 0; l < 2; l++) {
for (int j = 0; j < a; j++)
for (int k = 0; k < b; k++)
bfs[j][k] = 99999999;
bfs[st[l].first][st[l].second] = 0;
queue<pair<int, int>> Q;
Q.push(make_pair(st[l].first, st[l].second));
while (Q.size()) {
int row = Q.front().first;
int col = Q.front().second;
Q.pop();
for (int j = 0; j < 4; j++) {
int tr = row + dx[j];
int tc = col + dy[j];
if (tr < 0 || tc < 0 || tr >= a || tc >= b)
continue;
if (str[tr][tc] == '*')
continue;
if (tr == xr && tc == xc)
continue;
if (tr == xr + 1 && tc == xc)
continue;
if (tr == xr && tc == xc + 1)
continue;
if (tr == xr + 1 && tc == xc + 1)
continue;
if (bfs[tr][tc] > bfs[row][col] + 1) {
bfs[tr][tc] = bfs[row][col] + 1;
Q.push(make_pair(tr, tc));
}
}
}
dis[l][0] = bfs[go[0].first][go[0].second];
dis[l][1] = bfs[go[1].first][go[1].second];
}
return min(dis[0][0] + dis[1][1], dis[0][1] + dis[1][0]);
}
int main() {
while (scanf("%d%d", &a, &b), a) {
for (int i = 0; i < a; i++)
scanf("%s", str[i]);
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
for (int k = 0; k < 4; k++) {
ijk[i][j][k] = 999999999;
v[i][j][k] = 0;
}
int sr, sc;
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) {
if (str[i][j] == 'X') {
sr = i;
sc = j;
}
}
sr--;
sc--;
priority_queue<pair<int, pair<pair<int, int>, int>>> Q;
for (int i = 0; i < 4; i++) {
vector<pair<int, int>> st;
for (int j = 0; j < a; j++)
for (int k = 0; k < b; k++)
if (str[j][k] == '.') {
st.push_back(make_pair(j, k));
}
vector<pair<int, int>> go;
if (i == 0) {
go.push_back(make_pair(sr, sc + 2));
go.push_back(make_pair(sr + 1, sc + 2));
}
if (i == 1) {
go.push_back(make_pair(sr + 2, sc));
go.push_back(make_pair(sr + 2, sc + 1));
}
if (i == 2) {
go.push_back(make_pair(sr, sc - 1));
go.push_back(make_pair(sr + 1, sc - 1));
}
if (i == 3) {
go.push_back(make_pair(sr - 1, sc));
go.push_back(make_pair(sr - 1, sc + 1));
}
int co = calc(st, go, sr, sc);
if (co < 99999999) {
ijk[sr][sc][i] = co;
Q.push(make_pair(-co, make_pair(make_pair(sr, sc), i)));
}
}
while (Q.size()) {
int cost = -Q.top().first;
int row = Q.top().second.first.first;
int col = Q.top().second.first.second;
int dir = Q.top().second.second;
Q.pop();
if (v[row][col][dir])
continue;
v[row][col][dir] = 1;
vector<pair<int, int>> st;
if (dir == 0) {
st.push_back(make_pair(row, col + 2));
st.push_back(make_pair(row + 1, col + 2));
}
if (dir == 1) {
st.push_back(make_pair(row + 2, col));
st.push_back(make_pair(row + 2, col + 1));
}
if (dir == 2) {
st.push_back(make_pair(row, col - 1));
st.push_back(make_pair(row + 1, col - 1));
}
if (dir == 3) {
st.push_back(make_pair(row - 1, col));
st.push_back(make_pair(row - 1, col + 1));
}
for (int i = 0; i < 4; i++) {
vector<pair<int, int>> go;
if (i == 0) {
go.push_back(make_pair(row, col + 2));
go.push_back(make_pair(row + 1, col + 2));
}
if (i == 1) {
go.push_back(make_pair(row + 2, col));
go.push_back(make_pair(row + 2, col + 1));
}
if (i == 2) {
go.push_back(make_pair(row, col - 1));
go.push_back(make_pair(row + 1, col - 1));
}
if (i == 3) {
go.push_back(make_pair(row - 1, col));
go.push_back(make_pair(row - 1, col + 1));
}
int co = calc(st, go, row, col);
if (!v[row][col][i] && ijk[row][col][i] > cost + co) {
ijk[row][col][i] = cost + co;
Q.push(make_pair(-cost - co, make_pair(make_pair(row, col), i)));
}
}
if (!v[row + dx[dir]][col + dy[dir]][dir ^ 2] &&
ijk[row + dx[dir]][col + dy[dir]][dir ^ 2] > cost + 1) {
ijk[row + dx[dir]][col + dy[dir]][dir ^ 2] = cost + 1;
Q.push(make_pair(
-cost - 1,
make_pair(make_pair(row + dx[dir], col + dy[dir]), dir ^ 2)));
}
}
int ret = 999999999;
for (int i = 0; i < 4; i++) {
ret = min(ret, ijk[0][0][i]);
}
if (ret > 9999999)
printf("-1\n");
else
printf("%d\n", ret);
}
} | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
char str[60][60];
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
int bfs[60][60];
int ijk[60][60][4];
int v[60][60][4];
int dis[2][2];
int a, b;
int calc(vector<pair<int, int>> st, vector<pair<int, int>> go, int xr, int xc) {
for (int l = 0; l < 2; l++) {
for (int j = 0; j < a; j++)
for (int k = 0; k < b; k++)
bfs[j][k] = 99999999;
bfs[st[l].first][st[l].second] = 0;
queue<pair<int, int>> Q;
Q.push(make_pair(st[l].first, st[l].second));
while (Q.size()) {
int row = Q.front().first;
int col = Q.front().second;
Q.pop();
for (int j = 0; j < 4; j++) {
int tr = row + dx[j];
int tc = col + dy[j];
if (tr < 0 || tc < 0 || tr >= a || tc >= b)
continue;
if (str[tr][tc] == '*')
continue;
if (tr == xr && tc == xc)
continue;
if (tr == xr + 1 && tc == xc)
continue;
if (tr == xr && tc == xc + 1)
continue;
if (tr == xr + 1 && tc == xc + 1)
continue;
if (bfs[tr][tc] > bfs[row][col] + 1) {
bfs[tr][tc] = bfs[row][col] + 1;
Q.push(make_pair(tr, tc));
}
}
}
dis[l][0] = bfs[go[0].first][go[0].second];
dis[l][1] = bfs[go[1].first][go[1].second];
}
return min(dis[0][0] + dis[1][1], dis[0][1] + dis[1][0]);
}
int main() {
while (scanf("%d%d", &a, &b), a) {
for (int i = 0; i < a; i++)
scanf("%s", str[i]);
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++)
for (int k = 0; k < 4; k++) {
ijk[i][j][k] = 999999999;
v[i][j][k] = 0;
}
int sr, sc;
for (int i = 0; i < a; i++)
for (int j = 0; j < b; j++) {
if (str[i][j] == 'X') {
sr = i;
sc = j;
}
}
sr--;
sc--;
priority_queue<pair<int, pair<pair<int, int>, int>>> Q;
for (int i = 0; i < 4; i++) {
vector<pair<int, int>> st;
for (int j = 0; j < a; j++)
for (int k = 0; k < b; k++)
if (str[j][k] == '.') {
st.push_back(make_pair(j, k));
}
vector<pair<int, int>> go;
if (i == 0) {
go.push_back(make_pair(sr, sc + 2));
go.push_back(make_pair(sr + 1, sc + 2));
}
if (i == 1) {
go.push_back(make_pair(sr + 2, sc));
go.push_back(make_pair(sr + 2, sc + 1));
}
if (i == 2) {
go.push_back(make_pair(sr, sc - 1));
go.push_back(make_pair(sr + 1, sc - 1));
}
if (i == 3) {
go.push_back(make_pair(sr - 1, sc));
go.push_back(make_pair(sr - 1, sc + 1));
}
int co = calc(st, go, sr, sc);
if (co < 99999999) {
ijk[sr][sc][i] = co;
Q.push(make_pair(-co, make_pair(make_pair(sr, sc), i)));
}
}
while (Q.size()) {
int cost = -Q.top().first;
int row = Q.top().second.first.first;
int col = Q.top().second.first.second;
int dir = Q.top().second.second;
Q.pop();
if (v[row][col][dir])
continue;
v[row][col][dir] = 1;
vector<pair<int, int>> st;
if (dir == 0) {
st.push_back(make_pair(row, col + 2));
st.push_back(make_pair(row + 1, col + 2));
}
if (dir == 1) {
st.push_back(make_pair(row + 2, col));
st.push_back(make_pair(row + 2, col + 1));
}
if (dir == 2) {
st.push_back(make_pair(row, col - 1));
st.push_back(make_pair(row + 1, col - 1));
}
if (dir == 3) {
st.push_back(make_pair(row - 1, col));
st.push_back(make_pair(row - 1, col + 1));
}
for (int i = 0; i < 4; i++) {
if (v[row][col][i])
continue;
vector<pair<int, int>> go;
if (i == 0) {
go.push_back(make_pair(row, col + 2));
go.push_back(make_pair(row + 1, col + 2));
}
if (i == 1) {
go.push_back(make_pair(row + 2, col));
go.push_back(make_pair(row + 2, col + 1));
}
if (i == 2) {
go.push_back(make_pair(row, col - 1));
go.push_back(make_pair(row + 1, col - 1));
}
if (i == 3) {
go.push_back(make_pair(row - 1, col));
go.push_back(make_pair(row - 1, col + 1));
}
int co = calc(st, go, row, col);
if (!v[row][col][i] && ijk[row][col][i] > cost + co) {
ijk[row][col][i] = cost + co;
Q.push(make_pair(-cost - co, make_pair(make_pair(row, col), i)));
}
}
if (!v[row + dx[dir]][col + dy[dir]][dir ^ 2] &&
ijk[row + dx[dir]][col + dy[dir]][dir ^ 2] > cost + 1) {
ijk[row + dx[dir]][col + dy[dir]][dir ^ 2] = cost + 1;
Q.push(make_pair(
-cost - 1,
make_pair(make_pair(row + dx[dir], col + dy[dir]), dir ^ 2)));
}
}
int ret = 999999999;
for (int i = 0; i < 4; i++) {
ret = min(ret, ijk[0][0][i]);
}
if (ret > 9999999)
printf("-1\n");
else
printf("%d\n", ret);
}
} | insert | 129 | 129 | 129 | 131 | TLE | |
p00909 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rep(i, n) repl(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cout << #x "=" << x << endl
#define mmax(x, y) (x > y ? x : y)
#define mmin(x, y) (x < y ? x : y)
#define maxch(x, y) x = mmax(x, y)
#define minch(x, y) x = mmin(x, y)
#define uni(x) x.erase(unique(all(x)), x.end())
#define exist(x, y) (find(all(x), y) != x.end())
#define bcnt __builtin_popcount
#define INF 1e16
#define mod 1000000007
ll n, m;
vector<ll> par, sz, dep;
vector<vector<ll>> child;
ll find(ll x) {
if (par[x] == -1)
return x;
else
return find(par[x]);
}
void rec(ll v, ll pre, ll add) {
dep[v] += add;
for (ll nv : child[v]) {
if (nv == v)
continue;
rec(nv, v, add);
}
}
int main() {
while (1) {
cin >> n >> m;
if (n == 0)
break;
par.resize(n);
sz.resize(n);
dep.resize(n);
child.resize(n);
rep(i, n) {
par[i] = -1;
sz[i] = 1;
dep[i] = 0;
}
rep(i, m) {
char t;
cin >> t;
if (t == '!') {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
ll pa = find(a);
ll pb = find(b);
if (pa == pb)
continue;
if (sz[pa] < sz[pb]) {
swap(pa, pb);
swap(a, b);
c = -c;
}
par[pb] = pa;
ll x = dep[a] - dep[b] + c;
rec(pb, pa, x);
child[pa].push_back(pb);
sz[pa] += sz[pb];
} else {
ll a, b;
cin >> a >> b;
a--;
b--;
ll pa = find(a);
ll pb = find(b);
if (pa != pb) {
cout << "UNKNOWN" << endl;
} else {
cout << -dep[a] + dep[b] << endl;
}
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
#define fi first
#define se second
#define repl(i, a, b) for (ll i = (ll)(a); i < (ll)(b); i++)
#define rep(i, n) repl(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define dbg(x) cout << #x "=" << x << endl
#define mmax(x, y) (x > y ? x : y)
#define mmin(x, y) (x < y ? x : y)
#define maxch(x, y) x = mmax(x, y)
#define minch(x, y) x = mmin(x, y)
#define uni(x) x.erase(unique(all(x)), x.end())
#define exist(x, y) (find(all(x), y) != x.end())
#define bcnt __builtin_popcount
#define INF 1e16
#define mod 1000000007
ll n, m;
vector<ll> par, sz, dep;
vector<vector<ll>> child;
ll find(ll x) {
if (par[x] == -1)
return x;
else
return find(par[x]);
}
void rec(ll v, ll pre, ll add) {
dep[v] += add;
for (ll nv : child[v]) {
if (nv == v)
continue;
rec(nv, v, add);
}
}
int main() {
while (1) {
cin >> n >> m;
if (n == 0)
break;
par.resize(n);
sz.resize(n);
dep.resize(n);
child.resize(n);
rep(i, n) {
par[i] = -1;
sz[i] = 1;
dep[i] = 0;
child[i].clear();
}
rep(i, m) {
char t;
cin >> t;
if (t == '!') {
ll a, b, c;
cin >> a >> b >> c;
a--;
b--;
ll pa = find(a);
ll pb = find(b);
if (pa == pb)
continue;
if (sz[pa] < sz[pb]) {
swap(pa, pb);
swap(a, b);
c = -c;
}
par[pb] = pa;
ll x = dep[a] - dep[b] + c;
rec(pb, pa, x);
child[pa].push_back(pb);
sz[pa] += sz[pb];
} else {
ll a, b;
cin >> a >> b;
a--;
b--;
ll pa = find(a);
ll pb = find(b);
if (pa != pb) {
cout << "UNKNOWN" << endl;
} else {
cout << -dep[a] + dep[b] << endl;
}
}
}
}
return 0;
}
| insert | 57 | 57 | 57 | 58 | 0 | |
p00909 | C++ | Runtime Error | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
// #include<cctype>
#include <climits>
#include <iostream>
#include <map>
#include <string>
#include <vector>
// #include<list>
#include <algorithm>
#include <deque>
#include <queue>
// #include<numeric>
#include <utility>
// #include<memory>
#include <cassert>
#include <functional>
#include <random>
#include <set>
#include <stack>
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
int N, M;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N >> M) {
if (N == 0 && M == 0)
break;
vector<int> W(N), i2g(N);
vector<vector<int>> g2i(N);
// init
for (int i = 0; i < N; i++) {
i2g[i] = i;
g2i[i].push_back(i);
}
while (M--) {
char c;
cin >> c;
if (c == '!') {
int a, b, w;
cin >> a >> b >> w;
a--;
b--;
if (i2g[a] == i2g[b]) {
assert(W[b] - W[a] == w);
} else {
// merge
if (g2i[i2g[a]].size() < g2i[i2g[b]].size()) {
swap(a, b);
w = -w;
}
int ga = i2g[a], gb = i2g[b];
int diff = (W[a] + w) - W[b];
for (int el : g2i[b]) {
i2g[el] = ga;
W[el] += diff;
}
g2i[ga].insert(g2i[ga].end(), g2i[gb].begin(), g2i[gb].end());
g2i[gb].clear();
}
} else {
int a, b;
cin >> a >> b;
a--;
b--;
if (i2g[a] != i2g[b]) {
cout << "UNKNOWN" << endl;
} else {
cout << W[b] - W[a] << endl;
}
}
}
}
return 0;
} | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
// #include<cctype>
#include <climits>
#include <iostream>
#include <map>
#include <string>
#include <vector>
// #include<list>
#include <algorithm>
#include <deque>
#include <queue>
// #include<numeric>
#include <utility>
// #include<memory>
#include <cassert>
#include <functional>
#include <random>
#include <set>
#include <stack>
const int dx[] = {1, 0, -1, 0};
const int dy[] = {0, -1, 0, 1};
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef pair<int, int> pii;
int N, M;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> N >> M) {
if (N == 0 && M == 0)
break;
vector<int> W(N), i2g(N);
vector<vector<int>> g2i(N);
// init
for (int i = 0; i < N; i++) {
i2g[i] = i;
g2i[i].push_back(i);
}
while (M--) {
char c;
cin >> c;
if (c == '!') {
int a, b, w;
cin >> a >> b >> w;
a--;
b--;
if (i2g[a] == i2g[b]) {
assert(W[b] - W[a] == w);
} else {
// merge
if (g2i[i2g[a]].size() < g2i[i2g[b]].size()) {
swap(a, b);
w = -w;
}
int ga = i2g[a], gb = i2g[b];
int diff = (W[a] + w) - W[b];
for (int el : g2i[gb]) {
i2g[el] = ga;
W[el] += diff;
}
g2i[ga].insert(g2i[ga].end(), g2i[gb].begin(), g2i[gb].end());
g2i[gb].clear();
}
} else {
int a, b;
cin >> a >> b;
a--;
b--;
if (i2g[a] != i2g[b]) {
cout << "UNKNOWN" << endl;
} else {
cout << W[b] - W[a] << endl;
}
}
}
}
return 0;
} | replace | 65 | 66 | 65 | 66 | 0 | |
p00909 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <iostream>
using namespace std;
#define MAX_N 100
class union_find {
private:
int parents[MAX_N];
int rank[MAX_N];
int weight[MAX_N];
public:
union_find() {
for (int i = 0; i < MAX_N; i++) {
parents[i] = i;
rank[i] = 0;
weight[i] = 0;
}
}
union_find(int n) {
for (int i = 0; i < n; i++) {
parents[i] = i;
rank[i] = 0;
weight[i] = 0;
}
}
int find(int x) {
if (parents[x] == x) {
return x;
} else {
int tmp = find(parents[x]);
weight[x] = weight[x] + weight[parents[x]];
return parents[x] = tmp;
}
}
void unite(int x, int y, int w) {
int tmpx = find(x);
int tmpy = find(y);
if (tmpx == tmpy)
return;
// cout<<"weight list"<<weight[x]<<" "<<weight[y]<<" "<<w<<endl;
if (rank[tmpx] < rank[tmpy]) {
weight[tmpx] = w - weight[x] + weight[y];
parents[tmpx] = tmpy;
} else {
weight[tmpy] = -w - weight[y] + weight[x];
parents[tmpy] = tmpx;
if (rank[tmpx] == rank[tmpy])
rank[tmpx]++;
}
}
bool same(int x, int y) { return (find(x) == find(y)); }
int get_weight(int x, int y) {
if (find(x) == find(y)) {
// cout<<"get weight "<<weight[x]<<" "<<weight[y]<<endl;
return weight[x] - weight[y];
} else {
return -2000000;
}
}
};
int main() {
char c;
int a, b, w;
int n, m;
while (cin >> n >> m, n != 0 || m != 0) {
union_find uf(n + 1);
for (int i = 0; i < m; i++) {
cin >> c;
if (c == '!') {
cin >> a >> b >> w;
uf.unite(a, b, w);
} else if (c == '?') {
cin >> a >> b;
if (uf.same(a, b)) {
int tmp = uf.get_weight(a, b);
if (tmp != -2000000) {
cout << tmp << endl;
} else {
return 0;
}
} else {
cout << "UNKNOWN" << endl;
}
} else {
cout << "???" << endl;
}
}
}
} | #include <algorithm>
#include <bitset>
#include <cstdio>
#include <iostream>
using namespace std;
#define MAX_N 100100
class union_find {
private:
int parents[MAX_N];
int rank[MAX_N];
int weight[MAX_N];
public:
union_find() {
for (int i = 0; i < MAX_N; i++) {
parents[i] = i;
rank[i] = 0;
weight[i] = 0;
}
}
union_find(int n) {
for (int i = 0; i < n; i++) {
parents[i] = i;
rank[i] = 0;
weight[i] = 0;
}
}
int find(int x) {
if (parents[x] == x) {
return x;
} else {
int tmp = find(parents[x]);
weight[x] = weight[x] + weight[parents[x]];
return parents[x] = tmp;
}
}
void unite(int x, int y, int w) {
int tmpx = find(x);
int tmpy = find(y);
if (tmpx == tmpy)
return;
// cout<<"weight list"<<weight[x]<<" "<<weight[y]<<" "<<w<<endl;
if (rank[tmpx] < rank[tmpy]) {
weight[tmpx] = w - weight[x] + weight[y];
parents[tmpx] = tmpy;
} else {
weight[tmpy] = -w - weight[y] + weight[x];
parents[tmpy] = tmpx;
if (rank[tmpx] == rank[tmpy])
rank[tmpx]++;
}
}
bool same(int x, int y) { return (find(x) == find(y)); }
int get_weight(int x, int y) {
if (find(x) == find(y)) {
// cout<<"get weight "<<weight[x]<<" "<<weight[y]<<endl;
return weight[x] - weight[y];
} else {
return -2000000;
}
}
};
int main() {
char c;
int a, b, w;
int n, m;
while (cin >> n >> m, n != 0 || m != 0) {
union_find uf(n + 1);
for (int i = 0; i < m; i++) {
cin >> c;
if (c == '!') {
cin >> a >> b >> w;
uf.unite(a, b, w);
} else if (c == '?') {
cin >> a >> b;
if (uf.same(a, b)) {
int tmp = uf.get_weight(a, b);
if (tmp != -2000000) {
cout << tmp << endl;
} else {
return 0;
}
} else {
cout << "UNKNOWN" << endl;
}
} else {
cout << "???" << endl;
}
}
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p00909 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
long long dist[1 << 18];
long long group[1 << 18];
char q;
long long n, Q, a, b, c;
vector<long long> gr[1 << 18];
int main() {
while (true) {
for (int i = 0; i < (1 << 18); i++) {
dist[i] = 0;
group[i] = i;
gr[i].clear();
gr[i].push_back(i);
}
cin >> n >> Q;
if (n == 0 && Q == 0)
break;
for (int i = 0; i < Q; i++) {
cin >> q;
if (q == '?') {
cin >> a >> b;
if (group[a] != group[b])
cout << "UNKNOWN" << endl;
else
cout << dist[b] - dist[a] << endl;
}
if (q == '!') {
cin >> a >> b >> c;
long long L = group[a], M = group[b];
if (group[a] != group[b] && gr[L].size() <= gr[M].size()) {
long long K = dist[a] + c - dist[b];
for (int j = 0; j < gr[M].size(); j++) {
group[gr[M][j]] = L;
gr[L].push_back(gr[M][j]);
dist[gr[M][j]] += K;
}
gr[M].clear();
} else if (group[a] != group[b]) {
long long K = dist[b] - c - dist[a];
for (int j = 0; j < gr[L].size(); j++) {
group[gr[L][j]] = M;
gr[M].push_back(gr[L][j]);
dist[gr[L][j]] += K;
}
gr[L].clear();
}
}
}
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
long long dist[1 << 18];
long long group[1 << 18];
char q;
long long n, Q, a, b, c;
vector<long long> gr[1 << 18];
int main() {
while (true) {
for (int i = 0; i < (1 << 18); i++) {
dist[i] = 0;
group[i] = i;
gr[i].clear();
gr[i].push_back(i);
}
cin >> n >> Q;
if (n == 0 && Q == 0)
break;
for (int i = 0; i < Q; i++) {
cin >> q;
if (q == '?') {
cin >> a >> b;
if (group[a] != group[b])
cout << "UNKNOWN" << endl;
else
cout << dist[b] - dist[a] << endl;
}
if (q == '!') {
cin >> a >> b >> c;
long long L = group[a], M = group[b];
if (group[a] != group[b] && gr[L].size() >= gr[M].size()) {
long long K = dist[a] + c - dist[b];
for (int j = 0; j < gr[M].size(); j++) {
group[gr[M][j]] = L;
gr[L].push_back(gr[M][j]);
dist[gr[M][j]] += K;
}
gr[M].clear();
} else if (group[a] != group[b]) {
long long K = dist[b] - c - dist[a];
for (int j = 0; j < gr[L].size(); j++) {
group[gr[L][j]] = M;
gr[M].push_back(gr[L][j]);
dist[gr[L][j]] += K;
}
gr[L].clear();
}
}
}
}
return 0;
} | replace | 31 | 32 | 31 | 32 | 0 | |
p00909 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define MAX_N 100005
using namespace std;
typedef pair<int, int> P;
P par[MAX_N];
void init(int n) {
for (int i = 0; i < n; i++)
par[i] = P(i, 0);
}
P find(int x) {
if (par[x].first == x)
return P(x, 0);
P r = find(par[x].first);
return par[x] = P(r.first, par[x].second + r.second);
}
void unite(int x, int y, int cost) {
P r1 = find(x);
P r2 = find(y);
if (r1.first == r2.first)
return;
par[r1.first] = P(r2.first, r2.second - r1.second + cost);
}
bool same(int x, int y) { return find(x).first == find(y).first; }
int n, m, a, b, cost;
char c;
int main() {
while (1) {
cin >> n >> m;
if (!n && !m)
break;
init(n);
rep(i, m) {
scanf("%c%d%d", &c, &a, &b);
if (c == '!') {
scanf("%d", &cost);
unite(b - 1, a - 1, cost);
} else {
if (!same(a - 1, b - 1))
printf("UNKNOWN\n");
else
printf("%d\n", find(b - 1).second - find(a - 1).second);
}
}
}
return 0;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define MAX_N 100005
using namespace std;
typedef pair<int, int> P;
P par[MAX_N];
void init(int n) {
for (int i = 0; i < n; i++)
par[i] = P(i, 0);
}
P find(int x) {
if (par[x].first == x)
return P(x, 0);
P r = find(par[x].first);
return par[x] = P(r.first, par[x].second + r.second);
}
void unite(int x, int y, int cost) {
P r1 = find(x);
P r2 = find(y);
if (r1.first == r2.first)
return;
par[r1.first] = P(r2.first, r2.second - r1.second + cost);
}
bool same(int x, int y) { return find(x).first == find(y).first; }
int n, m, a, b, cost;
char c;
int main() {
while (1) {
cin >> n >> m;
if (!n && !m)
break;
init(n);
rep(i, m) {
scanf("%c", &c);
scanf("%c%d%d", &c, &a, &b);
if (c == '!') {
scanf("%d", &cost);
unite(b - 1, a - 1, cost);
} else {
if (!same(a - 1, b - 1))
printf("UNKNOWN\n");
else
printf("%d\n", find(b - 1).second - find(a - 1).second);
}
}
}
return 0;
} | insert | 39 | 39 | 39 | 40 | TLE | |
p00912 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX_N 50000
#define INF 100000000
#define MOD 1000000007
#define RANK 1000000000
#define EPS 1e-10
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> IP;
int w, n;
int bit[MAX_N + 1];
int x[MAX_N];
int sum[MAX_N + 1];
int bsum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i) {
while (i <= n) {
bit[i]++;
i += i & -i;
}
}
bool check(int le) {
memset(bit, 0, sizeof(bit));
int prest = -1;
int s, e, mid;
int st, en;
int v, q;
for (int i = 1; i < n; i++) {
s = prest;
e = i;
while (e - s > 1) {
mid = (s + e) / 2;
if (sum[i + 1] - sum[mid] - 1 > w) {
s = mid;
} else {
e = mid;
}
}
st = e;
prest = st - 1;
if (i == n - 1) {
en = i;
} else {
s = -1;
e = i;
while (e - s > 1) {
mid = (s + e) / 2;
if ((w + i - mid - sum[i + 1] + sum[mid]) / (i - mid) + 1 > le) {
e = mid;
} else {
s = mid;
}
}
en = s;
}
if (st > en)
continue;
if (st == 0)
q = 1;
else
q = bsum(en) - bsum(st - 1);
if (q) {
add(i + 1);
if (i == n - 1)
return true;
}
}
return false;
}
int solve() {
rep(i, n) scanf("%d", x + i);
rep(i, n) {
if (i == 0) {
sum[i + 1] = x[i] + 1;
} else {
sum[i + 1] = sum[i] + x[i] + 1;
}
}
int ss = 0, ee = w, mid;
while (ee - ss > 1) {
mid = (ss + ee) / 2;
if (check(mid)) {
ee = mid;
} else {
ss = mid;
}
}
printf("%d\n", ee);
}
int main() {
while (scanf("%d%d", &w, &n)) {
if (w == 0 && n == 0)
break;
solve();
}
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define MAX_N 50000
#define INF 100000000
#define MOD 1000000007
#define RANK 1000000000
#define EPS 1e-10
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> IP;
int w, n;
int bit[MAX_N + 1];
int x[MAX_N];
int sum[MAX_N + 1];
int bsum(int i) {
int s = 0;
while (i > 0) {
s += bit[i];
i -= i & -i;
}
return s;
}
void add(int i) {
while (i <= n) {
bit[i]++;
i += i & -i;
}
}
bool check(int le) {
memset(bit, 0, sizeof(bit));
int prest = -1;
int s, e, mid;
int st, en;
int v, q;
for (int i = 1; i < n; i++) {
s = prest;
e = i;
while (e - s > 1) {
mid = (s + e) / 2;
if (sum[i + 1] - sum[mid] - 1 > w) {
s = mid;
} else {
e = mid;
}
}
st = e;
prest = st - 1;
if (i == n - 1) {
en = i;
} else {
s = -1;
e = i;
while (e - s > 1) {
mid = (s + e) / 2;
if (w - sum[i + 1] + sum[mid] + 1 > (le - 1) * (i - mid)) {
e = mid;
} else {
s = mid;
}
}
en = s;
}
if (st > en)
continue;
if (st == 0)
q = 1;
else
q = bsum(en) - bsum(st - 1);
if (q) {
add(i + 1);
if (i == n - 1)
return true;
}
}
return false;
}
int solve() {
rep(i, n) scanf("%d", x + i);
rep(i, n) {
if (i == 0) {
sum[i + 1] = x[i] + 1;
} else {
sum[i + 1] = sum[i] + x[i] + 1;
}
}
int ss = 0, ee = w, mid;
while (ee - ss > 1) {
mid = (ss + ee) / 2;
if (check(mid)) {
ee = mid;
} else {
ss = mid;
}
}
printf("%d\n", ee);
}
int main() {
while (scanf("%d%d", &w, &n)) {
if (w == 0 && n == 0)
break;
solve();
}
} | replace | 61 | 62 | 61 | 62 | TLE | |
p00912 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
array<int, (int)(1e5)> ok;
array<int, (int)(1e5)> oksum;
array<ll, 100000> ubs;
array<ll, 100000> sumx;
bool check(int w, int n, ll sp) {
fill(ok.begin(), ok.begin() + n + 1, false);
fill(oksum.begin(), oksum.begin() + n + 2, false);
ok[n] = true;
ok[n - 1] = true;
oksum[n + 1] = 0;
oksum[n] = 1;
oksum[n - 1] = 2;
for (int i = n - 2; i >= 0; i--) {
// cerr<<"1check"<<i<<endl;
int j = ubs[i];
int lb = i + 1; //[i,lb)de tarinai
int ub = j;
while (ub - lb > 1) {
int mid = ((lb + ub) >> 1);
ll mot = w - (sumx[mid] - sumx[i]);
ll chi = mid - i - 1;
if ((mot + chi - 1) / chi > sp) {
lb = mid;
} else {
ub = mid;
}
}
// cerr<<"2check"<<i<<endl;
int b = ub;
// check [b,j)
if (j == n + 1 || oksum[b] - oksum[j] > 0) {
ok[i] = true;
} else {
ok[i] = false;
}
// cerr<<"#"<<i<<" "<<b<<" "<<j<<" "<<ok[i]<<endl;
oksum[i] = oksum[i + 1] + ok[i];
}
// cerr<<sp<<endl;
// string buf;
// cin>>buf;
return ok[0];
}
int solve(int w, int n) {
vector<ll> x(n);
for (int i = 0; i < n; i++)
cin >> x[i];
for (int i = 0; i < n; i++) {
sumx[i + 1] = sumx[i] + x[i];
}
for (int i = n - 2; i >= 0; i--) {
int lb = i;
int ub = n + 1;
// cerr<<"check"<<i<<endl;
//[i,lb) is ok
// w-(sumx[lb]-sumx[i])>=lb-i-1
// w+i+1>=sumx[lb]-sumx[i]+lb
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
ll sux = sumx[mid] - sumx[i] + mid;
// cerr<<"#"<<mid<<" "<<sux<<" "<<w+i+1<<endl;
if (w + i + 1 >= sux) {
lb = mid;
} else {
ub = mid;
}
}
ubs[i] = ub;
}
int lb = 0;
int ub = w;
// cerr<<"End summation"<<endl;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (!check(w, n, mid)) {
lb = mid;
} else {
ub = mid;
}
}
return ub;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int w, n;
while (cin >> w >> n, w) {
cout << solve(w, n) << "\n";
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
using ll = long long;
array<int, (int)(1e5)> ok;
array<int, (int)(1e5)> oksum;
array<ll, 100000> ubs;
array<ll, 100000> sumx;
bool check(int w, int n, ll sp) {
fill(ok.begin(), ok.begin() + n + 1, false);
fill(oksum.begin(), oksum.begin() + n + 2, false);
ok[n] = true;
ok[n - 1] = true;
oksum[n + 1] = 0;
oksum[n] = 1;
oksum[n - 1] = 2;
for (int i = n - 2; i >= 0; i--) {
// cerr<<"1check"<<i<<endl;
int j = ubs[i];
int lb = i + 1; //[i,lb)de tarinai
int ub = j;
while (ub - lb > 1) {
int mid = ((lb + ub) >> 1);
ll mot = w - (sumx[mid] - sumx[i]);
ll chi = mid - i - 1;
// floor((mot+chi-1)/chi)>sp
//
if (mot > sp * chi) {
lb = mid;
} else {
ub = mid;
}
}
// cerr<<"2check"<<i<<endl;
int b = ub;
// check [b,j)
if (j == n + 1 || oksum[b] - oksum[j] > 0) {
ok[i] = true;
} else {
ok[i] = false;
}
// cerr<<"#"<<i<<" "<<b<<" "<<j<<" "<<ok[i]<<endl;
oksum[i] = oksum[i + 1] + ok[i];
}
// cerr<<sp<<endl;
// string buf;
// cin>>buf;
return ok[0];
}
int solve(int w, int n) {
vector<ll> x(n);
for (int i = 0; i < n; i++)
cin >> x[i];
for (int i = 0; i < n; i++) {
sumx[i + 1] = sumx[i] + x[i];
}
for (int i = n - 2; i >= 0; i--) {
int lb = i;
int ub = n + 1;
// cerr<<"check"<<i<<endl;
//[i,lb) is ok
// w-(sumx[lb]-sumx[i])>=lb-i-1
// w+i+1>=sumx[lb]-sumx[i]+lb
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
ll sux = sumx[mid] - sumx[i] + mid;
// cerr<<"#"<<mid<<" "<<sux<<" "<<w+i+1<<endl;
if (w + i + 1 >= sux) {
lb = mid;
} else {
ub = mid;
}
}
ubs[i] = ub;
}
int lb = 0;
int ub = w;
// cerr<<"End summation"<<endl;
while (ub - lb > 1) {
int mid = (lb + ub) / 2;
if (!check(w, n, mid)) {
lb = mid;
} else {
ub = mid;
}
}
return ub;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int w, n;
while (cin >> w >> n, w) {
cout << solve(w, n) << "\n";
}
return 0;
}
| replace | 26 | 27 | 26 | 29 | TLE | |
p00912 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
for (int W, N; cin >> W >> N, W | N;) {
int x[52345];
for (int i = 0; i < N; i++) {
cin >> x[i];
}
int l = 0, h = 1e9;
while (h - l > 1) {
int m = (h + l) / 2;
vector<pair<int, int>> v[52345];
bool p[52345] = {};
v[0].emplace_back(0, 1);
for (int i = 0; i < N; i++) {
bool f = false;
for (auto e : v[i]) {
p[i] |= e.first + x[i] <= W;
int nl = e.first + x[i] + 1;
if (nl < W) {
int nh = min(W, e.second + x[i] + m);
if (!v[i + 1].empty() && v[i + 1].back().second >= nl) {
v[i + 1].back().second = nh;
} else {
v[i + 1].emplace_back(nl, nh);
}
}
f |= e.first <= W - x[i] && W - x[i] < e.second;
}
if (f) {
v[i + 1].insert(v[i + 1].begin(), make_pair(0, 1));
}
}
(!p[N - 1] ? l : h) = m;
}
cout << h << endl;
}
} | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
int main() {
for (int W, N; cin >> W >> N, W | N;) {
int x[52345];
for (int i = 0; i < N; i++) {
cin >> x[i];
}
int l = 0, h = 1e9;
while (h - l > 1) {
int m = (h + l) / 2;
vector<pair<int, int>> v[52345];
bool p[52345] = {};
v[0].emplace_back(0, 1);
for (int i = 0; i < N; i++) {
v[i + 1].reserve(v[i].size());
bool f = false;
for (auto e : v[i]) {
p[i] |= e.first + x[i] <= W;
int nl = e.first + x[i] + 1;
if (nl < W) {
int nh = min(W, e.second + x[i] + m);
if (!v[i + 1].empty() && v[i + 1].back().second >= nl) {
v[i + 1].back().second = nh;
} else {
v[i + 1].emplace_back(nl, nh);
}
}
f |= e.first <= W - x[i] && W - x[i] < e.second;
}
if (f) {
v[i + 1].insert(v[i + 1].begin(), make_pair(0, 1));
}
}
(!p[N - 1] ? l : h) = m;
}
cout << h << endl;
}
} | insert | 20 | 20 | 20 | 21 | TLE | |
p00912 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
inline int f(int n, int i, int L, const vector<int> &sum_rev) {
return (sum_rev[i - n] - sum_rev[i]) + L * (n - 1);
}
int dp[50010];
int sum_dp[50010];
int main() {
int W, N;
while (cin >> W >> N && N) {
vector<int> x(N);
REP(i, N) cin >> x[i];
vector<int> sum_rev(N + 1);
sum_rev[N] = 0;
for (int i = N - 1; i >= 0; i--) {
sum_rev[i] = sum_rev[i + 1] + x[i];
}
int lb_L = 0, ub_L = W; // ub
while (ub_L - lb_L > 1) {
int L = (lb_L + ub_L) / 2;
dp[0] = 1;
dp[1] = 0;
sum_dp[1] = 1;
sum_dp[2] = 1;
for (int i = 2; i < N; i++) {
dp[i] = 0;
sum_dp[i] = sum_dp[i - 1] + dp[i - 1];
int lb = 1, ub = i; // ub
while (ub - lb > 1) {
int n = (ub + lb) / 2;
if (f(n, i, L, sum_rev) >= W) {
ub = n;
} else {
lb = n;
}
}
int begin_n = ub;
// printf("dp[%d] : begin %d \n", i, begin_n);
if (f(begin_n, i, L, sum_rev) < W) {
continue;
}
lb = begin_n, ub = i + 1; // lb
while (ub - lb > 1) {
int n = (ub + lb) / 2;
if (f(n, i, 1, sum_rev) <= W) {
lb = n;
} else {
ub = n;
}
}
int end_n = lb;
// printf("dp[%d] : end %d \n", i, end_n);
if (f(end_n, i, 1, sum_rev) > W) {
continue;
}
int begin = i - end_n;
int end = i - begin_n;
// [begin, end]
if (sum_dp[end + 1] - sum_dp[begin] > 0) {
dp[i] = 1;
}
// printf("dp[%d] : [dp[%d], dp[%d]] (%d) -> %d\n", i, begin, end,
// sum_dp[end + 1] - sum_dp[begin], dp[i]);
}
bool ok = false;
for (int n = 1; n <= N && (n - 1) + sum_rev[N - n] <= W; n++) {
// printf("n - 1 + sum_rev[%d] = %d\n", i, n - 1 + sum_rev[i]);
if (dp[N - n]) {
ok = true;
break;
}
}
// printf("L %d is %d\n", L, ok);
if (ok) {
ub_L = L;
} else {
lb_L = L;
}
}
cout << ub_L << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
inline int f(int n, int i, int L, const vector<int> &sum_rev) {
return (sum_rev[i - n] - sum_rev[i]) + L * (n - 1);
}
int dp[50010];
int sum_dp[50010];
int main() {
int W, N;
while (cin >> W >> N && N) {
vector<int> x(N);
REP(i, N) cin >> x[i];
vector<int> sum_rev(N + 1);
sum_rev[N] = 0;
for (int i = N - 1; i >= 0; i--) {
sum_rev[i] = sum_rev[i + 1] + x[i];
}
int lb_L = 0, ub_L = W; // ub
while (ub_L - lb_L > 1) {
int L = (lb_L + ub_L) / 2;
dp[0] = 1;
dp[1] = 0;
sum_dp[1] = 1;
sum_dp[2] = 1;
for (int i = 2; i < N; i++) {
dp[i] = 0;
sum_dp[i] = sum_dp[i - 1] + dp[i - 1];
int lb = 1, ub = min(i, (W + L) / (L + 1) + 2); // ub true ??
while (ub - lb > 1) {
int n = (ub + lb) / 2;
if (f(n, i, L, sum_rev) >= W) {
ub = n;
} else {
lb = n;
}
}
int begin_n = ub;
// printf("dp[%d] : begin %d \n", i, begin_n);
if (f(begin_n, i, L, sum_rev) < W) {
continue;
}
lb = begin_n, ub = i + 1; // lb
while (ub - lb > 1) {
int n = (ub + lb) / 2;
if (f(n, i, 1, sum_rev) <= W) {
lb = n;
} else {
ub = n;
}
}
int end_n = lb;
// printf("dp[%d] : end %d \n", i, end_n);
if (f(end_n, i, 1, sum_rev) > W) {
continue;
}
int begin = i - end_n;
int end = i - begin_n;
// [begin, end]
if (sum_dp[end + 1] - sum_dp[begin] > 0) {
dp[i] = 1;
}
// printf("dp[%d] : [dp[%d], dp[%d]] (%d) -> %d\n", i, begin, end,
// sum_dp[end + 1] - sum_dp[begin], dp[i]);
}
bool ok = false;
for (int n = 1; n <= N && (n - 1) + sum_rev[N - n] <= W; n++) {
// printf("n - 1 + sum_rev[%d] = %d\n", i, n - 1 + sum_rev[i]);
if (dp[N - n]) {
ok = true;
break;
}
}
// printf("L %d is %d\n", L, ok);
if (ok) {
ub_L = L;
} else {
lb_L = L;
}
}
cout << ub_L << endl;
}
return 0;
} | replace | 36 | 37 | 36 | 37 | TLE | |
p00912 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define TIMES(i, n) for (int i = 0; i < (n); ++i)
template <class Pred> int binsearch(const Pred &pred) {
int val = 0;
for (int bit = 20; bit >= 0; --bit) {
const int next = val + (1 << bit);
val = pred(next) ? next : val;
}
return val;
}
bool solve() {
int W, N;
scanf("%d %d", &W, &N);
if (!W && !N)
return false;
vector<long long> sum(N + 2, 0);
TIMES(i, N) {
int v;
scanf("%d", &v);
sum[i + 1] = v;
sum[i + 1] += sum[i];
}
sum[N + 1] = sum[N];
vector<int> dp(N + 3, 0);
int ans = binsearch([&](long long x) {
if (x > W)
return false;
fill(dp.begin(), dp.end(), 0);
dp[N + 2] = 0;
dp[N + 1] = 1;
for (int i = N; i > 0; --i) {
const int mink = binsearch([&](int k) {
if (i + k > N)
return false;
const long long len =
(sum[i + k] - sum[i - 1]) + k * x;
return len < W;
}) +
2;
const int maxk = binsearch([&](int k) {
if (i + k > N)
return false;
const long long len =
(sum[i + k] - sum[i - 1]) + k;
return len <= W;
}) +
1;
// cout << x << ' ' << i << ' ' << mink << ' ' << maxk << endl;
dp[i] = (i + maxk == N + 1) ||
(mink <= maxk && dp[i + mink] - dp[i + maxk + 1] > 0);
// cout << dp[i] << endl;
dp[i] += dp[i + 1];
}
return dp[1] - dp[2] == 0;
}) +
1;
printf("%d\n", ans);
return true;
}
int main() {
while (solve())
;
return 0;
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
#define TIMES(i, n) for (int i = 0; i < (n); ++i)
template <class Pred> int binsearch(const Pred &pred) {
int val = 0;
for (int bit = 17; bit >= 0; --bit) {
const int next = val + (1 << bit);
val = pred(next) ? next : val;
}
return val;
}
bool solve() {
int W, N;
scanf("%d %d", &W, &N);
if (!W && !N)
return false;
vector<long long> sum(N + 2, 0);
TIMES(i, N) {
int v;
scanf("%d", &v);
sum[i + 1] = v;
sum[i + 1] += sum[i];
}
sum[N + 1] = sum[N];
vector<int> dp(N + 3, 0);
int ans = binsearch([&](long long x) {
if (x > W)
return false;
fill(dp.begin(), dp.end(), 0);
dp[N + 2] = 0;
dp[N + 1] = 1;
for (int i = N; i > 0; --i) {
const int mink = binsearch([&](int k) {
if (i + k > N)
return false;
const long long len =
(sum[i + k] - sum[i - 1]) + k * x;
return len < W;
}) +
2;
const int maxk = binsearch([&](int k) {
if (i + k > N)
return false;
const long long len =
(sum[i + k] - sum[i - 1]) + k;
return len <= W;
}) +
1;
// cout << x << ' ' << i << ' ' << mink << ' ' << maxk << endl;
dp[i] = (i + maxk == N + 1) ||
(mink <= maxk && dp[i + mink] - dp[i + maxk + 1] > 0);
// cout << dp[i] << endl;
dp[i] += dp[i + 1];
}
return dp[1] - dp[2] == 0;
}) +
1;
printf("%d\n", ans);
return true;
}
int main() {
while (solve())
;
return 0;
} | replace | 11 | 12 | 11 | 12 | TLE | |
p00913 | C++ | Time Limit Exceeded | #include <algorithm>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
char in[3][3][4];
int DIV = 10;
int gcd(int a, int b) {
while (a) {
b %= a;
int c = a;
a = b;
b = c;
}
return b;
}
const double EPS = 1e-10;
const double INF = 1e+10;
const double PI = acos(-1);
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline double ABS(double a) { return max(a, -a); }
struct Pt {
double x, y, z;
Pt() {}
Pt(double x, double y, double z) : x(x), y(y), z(z) {}
Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y, z + a.z); }
Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y, z - a.z); }
// Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y +
//y * a.x); }
Pt operator-() const { return Pt(-x, -y, -z); }
Pt operator*(const double &k) const { return Pt(x * k, y * k, z * k); }
Pt operator/(const double &k) const { return Pt(x / k, y / k, z / k); }
double ABS() const { return sqrt(x * x + y * y + z * z); }
double abs2() const { return x * x + y * y + z * z; }
// double arg() const { return atan2(y, x); }
double dot(const Pt &a) const { return x * a.x + y * a.y + z * a.z; }
// double det(const Pt &a) const { return x * a.y - y * a.x; }
};
double ijk[110000];
int v[110000];
int can[4][4][4];
int canx[4][4][4];
int cany[4][4][4];
int canz[4][4][4];
int canxy[4][4][4];
int canyz[4][4][4];
int canzx[4][4][4];
int rev[110000];
char ss[4];
int main() {
int a, b, c, d, e, f;
while (scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f), a + b + c + d + e + f) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
scanf("%s", ss);
for (int k = 0; k < 3; k++)
in[k][j][i] = ss[k];
}
vector<Pt> hb;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++) {
can[i][j][k] = canx[i][j][k] = cany[i][j][k] = canz[i][j][k] = 0;
canxy[i][j][k] = canyz[i][j][k] = canzx[i][j][k] = 0;
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++) {
if (i == 0 || i == 3 || j == 0 || j == 3 || k == 0 || k == 3)
can[i][j][k] = 2;
if (j == 0 || j == 3 || k == 0 || k == 3)
canx[i][j][k] = 2;
if (i == 0 || i == 3 || k == 0 || k == 3)
cany[i][j][k] = 2;
if (i == 0 || i == 3 || j == 0 || j == 3)
canz[i][j][k] = 2;
if (k == 0 || k == 3)
canxy[i][j][k] = 2;
if (i == 0 || i == 3)
canyz[i][j][k] = 2;
if (j == 0 || j == 3)
canzx[i][j][k] = 2;
}
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) {
int key = 0;
if (in[i][j][k] == '#') {
key = 1;
} else {
key = 2;
}
for (int l = 0; l < 8; l++) {
can[i + l / 4][j + l % 4 / 2][k + l % 2] |= key;
}
for (int l = 0; l < 4; l++) {
canx[i][j + l / 2][k + l % 2] |= key;
cany[i + l / 2][j][k + l % 2] |= key;
canz[i + l / 2][j + l % 2][k] |= key;
}
for (int l = 0; l < 2; l++) {
canxy[i][j][k + l % 2] |= key;
canyz[i + l % 2][j][k] |= key;
canzx[i][j + l % 2][k] |= key;
}
}
/*for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
for(int k=0;k<4;k++)printf("%d ",can[k][j][i]);
printf("\n");
}
printf("\n");
}*/
for (int i = 0; i <= 3; i++) {
for (int j = 0; j <= 3; j++) {
for (int k = 0; k <= 3; k++) {
if (can[i][j][k] == 3)
hb.push_back(Pt((double)i, (double)j, (double)k));
}
for (int k = 0; k < 3; k++) {
for (int l = 2; l <= DIV; l++) {
for (int m = 1; m < l; m++) {
if (gcd(m, l) != 1)
continue;
if (canz[i][j][k] == 3)
hb.push_back(Pt((double)i, (double)j, k + (double)m / l));
if (cany[i][k][j] == 3)
hb.push_back(Pt((double)i, k + (double)m / l, (double)j));
if (canx[k][i][j] == 3)
hb.push_back(Pt(k + (double)m / l, (double)i, (double)j));
}
}
}
}
}
int sz = hb.size();
for (int i = 0; i < sz; i++) {
v[i] = 0;
ijk[i] = 99999999;
}
Pt start = Pt(a, b, c);
Pt goal = Pt(d, e, f);
for (int i = 0; i < sz; i++) {
if ((hb[i] - start).ABS() < EPS) {
ijk[i] = 0;
}
}
for (int i = 0; i < sz; i++) {
int at = 0;
double dist = 999999999;
for (int j = 0; j < sz; j++) {
if (!v[j] && dist > ijk[j]) {
dist = ijk[j];
at = j;
}
}
v[at] = 1;
// printf("%f %f %f: %f\n",hb[at].x,hb[at].y,hb[at].z,ijk[at]);
if ((hb[at] - goal).ABS() < EPS) {
printf("%.12f\n", dist);
int cur = at;
// while((hb[cur]-start).ABS()>EPS){
// cur=rev[cur];
// printf("%f %f %f: %f\n",hb[cur].x,hb[cur].y,hb[cur].z,ijk[cur]);
// }
break;
}
for (int j = 0; j < sz; j++) {
if (v[j])
continue;
bool X = false;
bool Y = false;
bool Z = false;
int xx = (int)(min(hb[j].x, hb[at].x) + EPS);
int yy = (int)(min(hb[j].y, hb[at].y) + EPS);
int zz = (int)(min(hb[j].z, hb[at].z) + EPS);
if (ABS(hb[j].x - hb[at].x) < EPS && ABS(hb[j].x - xx) < EPS)
X = true;
if (ABS(hb[j].y - hb[at].y) < EPS && ABS(hb[j].y - yy) < EPS)
Y = true;
if (ABS(hb[j].z - hb[at].z) < EPS && ABS(hb[j].z - zz) < EPS)
Z = true;
if (!X && !Y && !Z)
continue;
if (!X && (int)(min(hb[j].x + 1, hb[at].x + 1) + EPS) !=
(int)(max(hb[at].x + 1, hb[j].x + 1) - EPS))
continue;
if (!Y && (int)(min(hb[j].y + 1, hb[at].y + 1) + EPS) !=
(int)(max(hb[at].y + 1, hb[j].y + 1) - EPS))
continue;
if (!Z && (int)(min(hb[j].z + 1, hb[at].z + 1) + EPS) !=
(int)(max(hb[at].z + 1, hb[j].z + 1) - EPS))
continue;
bool can = false;
bool Xs = false;
bool Ys = false;
bool Zs = false;
if (ABS(hb[j].x - (int)(hb[j].x + EPS)) < EPS)
Xs = true;
if (ABS(hb[j].y - (int)(hb[j].y + EPS)) < EPS)
Ys = true;
if (ABS(hb[j].z - (int)(hb[j].z + EPS)) < EPS)
Zs = true;
if (X && canyz[xx][yy][zz] == 3)
can = true;
if (Y && canzx[xx][yy][zz] == 3)
can = true;
if (Z && canxy[xx][yy][zz] == 3)
can = true;
if (X && Y && Xs && Ys && canz[xx][yy][zz] == 3)
can = true;
if (Z && Y && Zs && Ys && canx[xx][yy][zz] == 3)
can = true;
if (X && Z && Xs && Zs && cany[xx][yy][zz] == 3)
can = true;
if (can) {
double tmp = (hb[j] - hb[at]).ABS();
if (ijk[j] > tmp + ijk[at]) {
ijk[j] = tmp + ijk[at];
rev[j] = at;
}
}
}
}
}
} | #include <algorithm>
#include <math.h>
#include <queue>
#include <stdio.h>
#include <vector>
using namespace std;
char in[3][3][4];
int DIV = 7;
int gcd(int a, int b) {
while (a) {
b %= a;
int c = a;
a = b;
b = c;
}
return b;
}
const double EPS = 1e-10;
const double INF = 1e+10;
const double PI = acos(-1);
int sig(double r) { return (r < -EPS) ? -1 : (r > +EPS) ? +1 : 0; }
inline double ABS(double a) { return max(a, -a); }
struct Pt {
double x, y, z;
Pt() {}
Pt(double x, double y, double z) : x(x), y(y), z(z) {}
Pt operator+(const Pt &a) const { return Pt(x + a.x, y + a.y, z + a.z); }
Pt operator-(const Pt &a) const { return Pt(x - a.x, y - a.y, z - a.z); }
// Pt operator*(const Pt &a) const { return Pt(x * a.x - y * a.y, x * a.y +
//y * a.x); }
Pt operator-() const { return Pt(-x, -y, -z); }
Pt operator*(const double &k) const { return Pt(x * k, y * k, z * k); }
Pt operator/(const double &k) const { return Pt(x / k, y / k, z / k); }
double ABS() const { return sqrt(x * x + y * y + z * z); }
double abs2() const { return x * x + y * y + z * z; }
// double arg() const { return atan2(y, x); }
double dot(const Pt &a) const { return x * a.x + y * a.y + z * a.z; }
// double det(const Pt &a) const { return x * a.y - y * a.x; }
};
double ijk[110000];
int v[110000];
int can[4][4][4];
int canx[4][4][4];
int cany[4][4][4];
int canz[4][4][4];
int canxy[4][4][4];
int canyz[4][4][4];
int canzx[4][4][4];
int rev[110000];
char ss[4];
int main() {
int a, b, c, d, e, f;
while (scanf("%d%d%d%d%d%d", &a, &b, &c, &d, &e, &f), a + b + c + d + e + f) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) {
scanf("%s", ss);
for (int k = 0; k < 3; k++)
in[k][j][i] = ss[k];
}
vector<Pt> hb;
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++) {
can[i][j][k] = canx[i][j][k] = cany[i][j][k] = canz[i][j][k] = 0;
canxy[i][j][k] = canyz[i][j][k] = canzx[i][j][k] = 0;
}
for (int i = 0; i < 4; i++)
for (int j = 0; j < 4; j++)
for (int k = 0; k < 4; k++) {
if (i == 0 || i == 3 || j == 0 || j == 3 || k == 0 || k == 3)
can[i][j][k] = 2;
if (j == 0 || j == 3 || k == 0 || k == 3)
canx[i][j][k] = 2;
if (i == 0 || i == 3 || k == 0 || k == 3)
cany[i][j][k] = 2;
if (i == 0 || i == 3 || j == 0 || j == 3)
canz[i][j][k] = 2;
if (k == 0 || k == 3)
canxy[i][j][k] = 2;
if (i == 0 || i == 3)
canyz[i][j][k] = 2;
if (j == 0 || j == 3)
canzx[i][j][k] = 2;
}
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++)
for (int k = 0; k < 3; k++) {
int key = 0;
if (in[i][j][k] == '#') {
key = 1;
} else {
key = 2;
}
for (int l = 0; l < 8; l++) {
can[i + l / 4][j + l % 4 / 2][k + l % 2] |= key;
}
for (int l = 0; l < 4; l++) {
canx[i][j + l / 2][k + l % 2] |= key;
cany[i + l / 2][j][k + l % 2] |= key;
canz[i + l / 2][j + l % 2][k] |= key;
}
for (int l = 0; l < 2; l++) {
canxy[i][j][k + l % 2] |= key;
canyz[i + l % 2][j][k] |= key;
canzx[i][j + l % 2][k] |= key;
}
}
/*for(int i=0;i<4;i++){
for(int j=0;j<4;j++){
for(int k=0;k<4;k++)printf("%d ",can[k][j][i]);
printf("\n");
}
printf("\n");
}*/
for (int i = 0; i <= 3; i++) {
for (int j = 0; j <= 3; j++) {
for (int k = 0; k <= 3; k++) {
if (can[i][j][k] == 3)
hb.push_back(Pt((double)i, (double)j, (double)k));
}
for (int k = 0; k < 3; k++) {
for (int l = 2; l <= DIV; l++) {
for (int m = 1; m < l; m++) {
if (gcd(m, l) != 1)
continue;
if (canz[i][j][k] == 3)
hb.push_back(Pt((double)i, (double)j, k + (double)m / l));
if (cany[i][k][j] == 3)
hb.push_back(Pt((double)i, k + (double)m / l, (double)j));
if (canx[k][i][j] == 3)
hb.push_back(Pt(k + (double)m / l, (double)i, (double)j));
}
}
}
}
}
int sz = hb.size();
for (int i = 0; i < sz; i++) {
v[i] = 0;
ijk[i] = 99999999;
}
Pt start = Pt(a, b, c);
Pt goal = Pt(d, e, f);
for (int i = 0; i < sz; i++) {
if ((hb[i] - start).ABS() < EPS) {
ijk[i] = 0;
}
}
for (int i = 0; i < sz; i++) {
int at = 0;
double dist = 999999999;
for (int j = 0; j < sz; j++) {
if (!v[j] && dist > ijk[j]) {
dist = ijk[j];
at = j;
}
}
v[at] = 1;
// printf("%f %f %f: %f\n",hb[at].x,hb[at].y,hb[at].z,ijk[at]);
if ((hb[at] - goal).ABS() < EPS) {
printf("%.12f\n", dist);
int cur = at;
// while((hb[cur]-start).ABS()>EPS){
// cur=rev[cur];
// printf("%f %f %f: %f\n",hb[cur].x,hb[cur].y,hb[cur].z,ijk[cur]);
// }
break;
}
for (int j = 0; j < sz; j++) {
if (v[j])
continue;
bool X = false;
bool Y = false;
bool Z = false;
int xx = (int)(min(hb[j].x, hb[at].x) + EPS);
int yy = (int)(min(hb[j].y, hb[at].y) + EPS);
int zz = (int)(min(hb[j].z, hb[at].z) + EPS);
if (ABS(hb[j].x - hb[at].x) < EPS && ABS(hb[j].x - xx) < EPS)
X = true;
if (ABS(hb[j].y - hb[at].y) < EPS && ABS(hb[j].y - yy) < EPS)
Y = true;
if (ABS(hb[j].z - hb[at].z) < EPS && ABS(hb[j].z - zz) < EPS)
Z = true;
if (!X && !Y && !Z)
continue;
if (!X && (int)(min(hb[j].x + 1, hb[at].x + 1) + EPS) !=
(int)(max(hb[at].x + 1, hb[j].x + 1) - EPS))
continue;
if (!Y && (int)(min(hb[j].y + 1, hb[at].y + 1) + EPS) !=
(int)(max(hb[at].y + 1, hb[j].y + 1) - EPS))
continue;
if (!Z && (int)(min(hb[j].z + 1, hb[at].z + 1) + EPS) !=
(int)(max(hb[at].z + 1, hb[j].z + 1) - EPS))
continue;
bool can = false;
bool Xs = false;
bool Ys = false;
bool Zs = false;
if (ABS(hb[j].x - (int)(hb[j].x + EPS)) < EPS)
Xs = true;
if (ABS(hb[j].y - (int)(hb[j].y + EPS)) < EPS)
Ys = true;
if (ABS(hb[j].z - (int)(hb[j].z + EPS)) < EPS)
Zs = true;
if (X && canyz[xx][yy][zz] == 3)
can = true;
if (Y && canzx[xx][yy][zz] == 3)
can = true;
if (Z && canxy[xx][yy][zz] == 3)
can = true;
if (X && Y && Xs && Ys && canz[xx][yy][zz] == 3)
can = true;
if (Z && Y && Zs && Ys && canx[xx][yy][zz] == 3)
can = true;
if (X && Z && Xs && Zs && cany[xx][yy][zz] == 3)
can = true;
if (can) {
double tmp = (hb[j] - hb[at]).ABS();
if (ijk[j] > tmp + ijk[at]) {
ijk[j] = tmp + ijk[at];
rev[j] = at;
}
}
}
}
}
} | replace | 7 | 8 | 7 | 8 | TLE | |
p00914 | C++ | Memory Limit Exceeded | #include <cstring>
#include <iostream>
using namespace std;
int x[100][1000][250], a, b, c, i, j, k, l, sum;
int main() {
while (true) {
sum = 0;
memset(x, 0, sizeof(x));
cin >> a >> b >> c;
if (a == 0) {
break;
}
x[0][0][0] = 1;
for (i = 1; i <= b; i++) {
for (j = 0; j <= c; j++) {
for (l = 0; l < a; l++) {
for (k = l + 1; k <= a; k++) {
x[i][j + k][k] += x[i - 1][j][l];
}
}
}
}
for (i = 0; i <= a; i++) {
sum += x[b][c][i];
}
cout << sum << endl;
}
} | #include <cstring>
#include <iostream>
using namespace std;
int x[100][1000][150], a, b, c, i, j, k, l, sum;
int main() {
while (true) {
sum = 0;
memset(x, 0, sizeof(x));
cin >> a >> b >> c;
if (a == 0) {
break;
}
x[0][0][0] = 1;
for (i = 1; i <= b; i++) {
for (j = 0; j <= c; j++) {
for (l = 0; l < a; l++) {
for (k = l + 1; k <= a; k++) {
x[i][j + k][k] += x[i - 1][j][l];
}
}
}
}
for (i = 0; i <= a; i++) {
sum += x[b][c][i];
}
cout << sum << endl;
}
} | replace | 3 | 4 | 3 | 4 | MLE | |
p00914 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
for (;;) {
int n, k, s;
cin >> n >> k >> s;
if (n == 0 && k == 0 && s == 0)
break;
int cnt = 0;
for (int i = 0; i < 1 << n; i++) {
int c = 0, ss = 0;
while (i != 0) {
int x = i & -i;
i ^= x;
ss += __builtin_ffs(x);
c++;
}
if (c == k && s == ss)
cnt++;
}
cout << cnt << endl;
}
return 0;
}
| #include <iostream>
#include <vector>
using namespace std;
int main(int argc, char *argv[]) {
for (;;) {
int n, k, s;
cin >> n >> k >> s;
if (n == 0 && k == 0 && s == 0)
break;
int cnt = 0;
for (int i = 0; i < 1 << n; i++) {
int c = 0, ss = 0, ii = i;
while (ii != 0) {
int x = ii & -ii;
ii ^= x;
ss += __builtin_ffs(x);
c++;
}
if (c == k && s == ss)
cnt++;
}
cout << cnt << endl;
}
return 0;
}
| replace | 11 | 15 | 11 | 15 | TLE | |
p00915 | C++ | Runtime Error | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int n, l;
while (cin >> n >> l, n) {
vector<pii> ants(n);
REP(i, n) {
char d;
cin >> d >> ants[i].second;
if (d == 'R') {
ants[i].first = 1;
} else {
ants[i].first = -1;
}
}
int left = n, sec = 0, ans = -1;
while (true) {
sec++;
ans = -1;
REP(i, n) { ants[i].second += ants[i].first; }
REP(i, n) {
if (ants[i].first != 0) {
if (ants[i].second == 0) {
ans = i + 1;
ants[i].first = 0;
left--;
} else if (ants[i].second == l) {
if (ans == -1) {
ans = i + 1;
}
ants[i].first = 0;
left--;
}
}
}
if (n != 1) {
REP(i, n) {
FOR(j, i, n - 1) {
if (ants[i].second == ants[j].second && ants[i].first != 0) {
ants[i].first *= -1;
ants[j].first *= -1;
}
}
}
}
if (left == 0) {
cout << sec << " " << ans << endl;
break;
}
cerr << "sec : " << sec << endl;
REP(i, n) {
cerr << i + 1 << " : " << ants[i].first << " " << ants[i].second
<< endl;
}
}
}
return 0;
} | #include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int n, l;
while (cin >> n >> l, n) {
vector<pii> ants(n);
REP(i, n) {
char d;
cin >> d >> ants[i].second;
if (d == 'R') {
ants[i].first = 1;
} else {
ants[i].first = -1;
}
}
int left = n, sec = 0, ans = -1;
while (true) {
sec++;
ans = -1;
REP(i, n) { ants[i].second += ants[i].first; }
REP(i, n) {
if (ants[i].first != 0) {
if (ants[i].second == 0) {
ans = i + 1;
ants[i].first = 0;
left--;
} else if (ants[i].second == l) {
if (ans == -1) {
ans = i + 1;
}
ants[i].first = 0;
left--;
}
}
}
if (n != 1) {
REP(i, n) {
FOR(j, i, n - 1) {
if (ants[i].second == ants[j].second && ants[i].first != 0) {
ants[i].first *= -1;
ants[j].first *= -1;
}
}
}
}
if (left == 0) {
cout << sec << " " << ans << endl;
break;
}
}
}
return 0;
} | delete | 95 | 101 | 95 | 95 | 0 | sec : 1
1 : 1 2
2 : -1 1
3 : -1 4
sec : 2
1 : -1 3
2 : 0 0
3 : 1 3
sec : 3
1 : -1 2
2 : 0 0
3 : 1 4
sec : 4
1 : -1 1
2 : 0 0
3 : 1 5
sec : 1
1 : 1 2
sec : 2
1 : 1 3
sec : 3
1 : 1 4
sec : 4
1 : 1 5
sec : 5
1 : 1 6
sec : 6
1 : 1 7
sec : 7
1 : 1 8
sec : 8
1 : 1 9
sec : 1
1 : -1 6
2 : 1 6
sec : 2
1 : -1 5
2 : 1 7
sec : 3
1 : -1 4
2 : 1 8
sec : 4
1 : -1 3
2 : 1 9
sec : 5
1 : -1 2
2 : 0 10
sec : 6
1 : -1 1
2 : 0 10
sec : 1
1 : 1 4
2 : -1 7
sec : 2
1 : 1 5
2 : -1 6
sec : 3
1 : 1 6
2 : -1 5
sec : 4
1 : 1 7
2 : -1 4
sec : 5
1 : 1 8
2 : -1 3
sec : 6
1 : 1 9
2 : -1 2
sec : 7
1 : 0 10
2 : -1 1
sec : 1
1 : 1 2
2 : -1 97
sec : 2
1 : 1 3
2 : -1 96
sec : 3
1 : 1 4
2 : -1 95
sec : 4
1 : 1 5
2 : -1 94
sec : 5
1 : 1 6
2 : -1 93
sec : 6
1 : 1 7
2 : -1 92
sec : 7
1 : 1 8
2 : -1 91
sec : 8
1 : 1 9
2 : -1 90
sec : 9
1 : 1 10
2 : -1 89
sec : 10
1 : 1 11
2 : -1 88
sec : 11
1 : 1 12
2 : -1 87
sec : 12
1 : 1 13
2 : -1 86
sec : 13
1 : 1 14
2 : -1 85
sec : 14
1 : 1 15
2 : -1 84
sec : 15
1 : 1 16
2 : -1 83
sec : 16
1 : 1 17
2 : -1 82
sec : 17
1 : 1 18
2 : -1 81
sec : 18
1 : 1 19
2 : -1 80
sec : 19
1 : 1 20
2 : -1 79
sec : 20
1 : 1 21
2 : -1 78
sec : 21
1 : 1 22
2 : -1 77
sec : 22
1 : 1 23
2 : -1 76
sec : 23
1 : 1 24
2 : -1 75
sec : 24
1 : 1 25
2 : -1 74
sec : 25
1 : 1 26
2 : -1 73
sec : 26
1 : 1 27
2 : -1 72
sec : 27
1 : 1 28
2 : -1 71
sec : 28
1 : 1 29
2 : -1 70
sec : 29
1 : 1 30
2 : -1 69
sec : 30
1 : 1 31
2 : -1 68
sec : 31
1 : 1 32
2 : -1 67
sec : 32
1 : 1 33
2 : -1 66
sec : 33
1 : 1 34
2 : -1 65
sec : 34
1 : 1 35
2 : -1 64
sec : 35
1 : 1 36
2 : -1 63
sec : 36
1 : 1 37
2 : -1 62
sec : 37
1 : 1 38
2 : -1 61
sec : 38
1 : 1 39
2 : -1 60
sec : 39
1 : 1 40
2 : -1 59
sec : 40
1 : 1 41
2 : -1 58
sec : 41
1 : 1 42
2 : -1 57
sec : 42
1 : 1 43
2 : -1 56
sec : 43
1 : 1 44
2 : -1 55
sec : 44
1 : 1 45
2 : -1 54
sec : 45
1 : 1 46
2 : -1 53
sec : 46
1 : 1 47
2 : -1 52
sec : 47
1 : 1 48
2 : -1 51
sec : 48
1 : 1 49
2 : -1 50
sec : 49
1 : 1 50
2 : -1 49
sec : 50
1 : 1 51
2 : -1 48
sec : 51
1 : 1 52
2 : -1 47
sec : 52
1 : 1 53
2 : -1 46
sec : 53
1 : 1 54
2 : -1 45
sec : 54
1 : 1 55
2 : -1 44
sec : 55
1 : 1 56
2 : -1 43
sec : 56
1 : 1 57
2 : -1 42
sec : 57
1 : 1 58
2 : -1 41
sec : 58
1 : 1 59
2 : -1 40
sec : 59
1 : 1 60
2 : -1 39
sec : 60
1 : 1 61
2 : -1 38
sec : 61
1 : 1 62
2 : -1 37
sec : 62
1 : 1 63
2 : -1 36
sec : 63
1 : 1 64
2 : -1 35
sec : 64
1 : 1 65
2 : -1 34
sec : 65
1 : 1 66
2 : -1 33
sec : 66
1 : 1 67
2 : -1 32
sec : 67
1 : 1 68
2 : -1 31
sec : 68
1 : 1 69
2 : -1 30
sec : 69
1 : 1 70
2 : -1 29
sec : 70
1 : 1 71
2 : -1 28
sec : 71
1 : 1 72
2 : -1 27
sec : 72
1 : 1 73
2 : -1 26
sec : 73
1 : 1 74
2 : -1 25
sec : 74
1 : 1 75
2 : -1 24
sec : 75
1 : 1 76
2 : -1 23
sec : 76
1 : 1 77
2 : -1 22
sec : 77
1 : 1 78
2 : -1 21
sec : 78
1 : 1 79
2 : -1 20
sec : 79
1 : 1 80
2 : -1 19
sec : 80
1 : 1 81
2 : -1 18
sec : 81
1 : 1 82
2 : -1 17
sec : 82
1 : 1 83
2 : -1 16
sec : 83
1 : 1 84
2 : -1 15
sec : 84
1 : 1 85
2 : -1 14
sec : 85
1 : 1 86
2 : -1 13
sec : 86
1 : 1 87
2 : -1 12
sec : 87
1 : 1 88
2 : -1 11
sec : 88
1 : 1 89
2 : -1 10
sec : 89
1 : 1 90
2 : -1 9
sec : 90
1 : 1 91
2 : -1 8
sec : 91
1 : 1 92
2 : -1 7
sec : 92
1 : 1 93
2 : -1 6
sec : 93
1 : 1 94
2 : -1 5
sec : 94
1 : 1 95
2 : -1 4
sec : 95
1 : 1 96
2 : -1 3
sec : 96
1 : 1 97
2 : -1 2
sec : 97
1 : 1 98
2 : -1 1
sec : 1
1 : 0 0
2 : 1 3
3 : -1 7
4 : 0 10
sec : 2
1 : 0 0
2 : 1 4
3 : -1 6
4 : 0 10
sec : 3
1 : 0 0
2 : -1 5
3 : 1 5
4 : 0 10
sec : 4
1 : 0 0
2 : -1 4
3 : 1 6
4 : 0 10
sec : 5
1 : 0 0
2 : -1 3
3 : 1 7
4 : 0 10
sec : 6
1 : 0 0
2 : -1 2
3 : 1 8
4 : 0 10
sec : 7
1 : 0 0
2 : -1 1
3 : 1 9
4 : 0 10
sec : 1
1 : -1 3
2 : 1 4
3 : 1 3
4 : -1 7
5 : -1 6
6 : 1 7
sec : 2
1 : -1 2
2 : -1 5
3 : 1 4
4 : -1 6
5 : 1 5
6 : 1 8
sec : 3
1 : -1 1
2 : -1 4
3 : -1 5
4 : 1 5
5 : 1 6
6 : 1 9
sec : 4
1 : 0 0
2 : -1 3
3 : -1 4
4 : 1 6
5 : 1 7
6 : 0 10
sec : 5
1 : 0 0
2 : -1 2
3 : -1 3
4 : 1 7
5 : 1 8
6 : 0 10
sec : 6
1 : 0 0
2 : -1 1
3 : -1 2
4 : 1 8
5 : 1 9
6 : 0 10
sec : 7
1 : 0 0
2 : 0 0
3 : -1 1
4 : 1 9
5 : 0 10
6 : 0 10
|
p00915 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
int main() {
int N, L;
while (cin >> N >> L && (N | L)) {
vector<pair<int, int>> v;
rep(i, N) {
char d;
int p;
cin >> d >> p;
v.push_back(MP(d == 'R' ? +1 : -1, p));
}
int time = 0;
int ans = -1;
int remain = N;
while (remain > 0) {
int ch[2 * L + 2];
memset(ch, 0, sizeof ch);
int *check = ch + L + 1;
rep(i, N) {
v[i].second += v[i].first;
check[v[i].second]++;
}
rep(i, N) {
if (check[v[i].second] == 2) {
v[i].first *= -1;
}
}
bool f = 0;
rep(i, N) {
if (v[i].second == 0) {
remain--;
f = 1;
ans = i + 1;
}
if (v[i].second == L) {
remain--;
if (!f) {
ans = i + 1;
}
}
}
time++;
}
cout << time << " " << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
#define MP make_pair
int main() {
int N, L;
while (cin >> N >> L && (N | L)) {
vector<pair<int, int>> v;
rep(i, N) {
char d;
int p;
cin >> d >> p;
v.push_back(MP(d == 'R' ? +1 : -1, p));
}
int time = 0;
int ans = -1;
int remain = N;
while (remain > 0) {
int ch[2200] = {};
int *check = ch + 1100;
rep(i, N) {
v[i].second += v[i].first;
check[v[i].second]++;
}
rep(i, N) {
if (check[v[i].second] == 2) {
v[i].first *= -1;
}
}
bool f = 0;
rep(i, N) {
if (v[i].second == 0) {
remain--;
f = 1;
ans = i + 1;
}
if (v[i].second == L) {
remain--;
if (!f) {
ans = i + 1;
}
}
}
time++;
}
cout << time << " " << ans << endl;
}
} | replace | 25 | 28 | 25 | 27 | 0 | |
p00916 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> P;
int n;
vector<int> xid, yid;
int fie[401][401];
int l[51], r[51], t[51], b[51];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void bfs(int x, int y) {
queue<P> que;
que.push(P(x, y));
fie[x][y] = 1;
while (que.size()) {
P q = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int nx = q.first + dx[i], ny = q.second + dy[i];
if (nx >= 0 && nx < 400 && ny >= 0 && ny < 400) {
if (fie[nx][ny] == 0) {
fie[nx][ny] = 1;
que.push(P(nx, ny));
}
}
}
}
}
int main(void) {
while (1) {
scanf("%d", &n);
if (n == 0)
break;
memset(fie, 0, sizeof(fie));
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d", &l[i], &t[i], &r[i], &b[i]);
l[i] *= 2;
r[i] *= 2;
t[i] *= 2;
b[i] *= 2;
for (int j = -1; j <= 1; j++) {
xid.push_back(l[i] + j);
xid.push_back(r[i] + j);
yid.push_back(t[i] + j);
yid.push_back(b[i] + j);
}
}
sort(xid.begin(), xid.end());
xid.erase(unique(xid.begin(), xid.end()), xid.end());
sort(yid.begin(), yid.end());
yid.erase(unique(yid.begin(), yid.end()), yid.end());
for (int i = 0; i < n; i++) {
int id = lower_bound(xid.begin(), xid.end(), l[i]) - xid.begin();
l[i] = id;
id = lower_bound(xid.begin(), xid.end(), r[i]) - xid.begin();
r[i] = id;
id = lower_bound(yid.begin(), yid.end(), t[i]) - yid.begin();
t[i] = id;
id = lower_bound(yid.begin(), yid.end(), b[i]) - yid.begin();
b[i] = id;
for (int j = l[i]; j <= r[i]; j++) {
fie[j][t[i]] = -1;
fie[j][b[i]] = -1;
}
for (int j = b[i]; j <= t[i]; j++) {
fie[l[i]][j] = -1;
fie[r[i]][j] = -1;
}
}
int cnt = 0;
for (int i = 0; i < 400; i++) {
for (int j = 0; j < 400; j++) {
if (fie[i][j] == 0) {
bfs(i, j);
cnt++;
}
}
}
printf("%d\n", cnt);
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <queue>
#include <utility>
#include <vector>
using namespace std;
typedef pair<int, int> P;
int n;
vector<int> xid, yid;
int fie[401][401];
int l[51], r[51], t[51], b[51];
int dx[4] = {0, 1, 0, -1};
int dy[4] = {1, 0, -1, 0};
void bfs(int x, int y) {
queue<P> que;
que.push(P(x, y));
fie[x][y] = 1;
while (que.size()) {
P q = que.front();
que.pop();
for (int i = 0; i < 4; i++) {
int nx = q.first + dx[i], ny = q.second + dy[i];
if (nx >= 0 && nx < 400 && ny >= 0 && ny < 400) {
if (fie[nx][ny] == 0) {
fie[nx][ny] = 1;
que.push(P(nx, ny));
}
}
}
}
}
int main(void) {
while (1) {
scanf("%d", &n);
if (n == 0)
break;
xid.clear();
yid.clear();
memset(fie, 0, sizeof(fie));
for (int i = 0; i < n; i++) {
scanf("%d %d %d %d", &l[i], &t[i], &r[i], &b[i]);
l[i] *= 2;
r[i] *= 2;
t[i] *= 2;
b[i] *= 2;
for (int j = -1; j <= 1; j++) {
xid.push_back(l[i] + j);
xid.push_back(r[i] + j);
yid.push_back(t[i] + j);
yid.push_back(b[i] + j);
}
}
sort(xid.begin(), xid.end());
xid.erase(unique(xid.begin(), xid.end()), xid.end());
sort(yid.begin(), yid.end());
yid.erase(unique(yid.begin(), yid.end()), yid.end());
for (int i = 0; i < n; i++) {
int id = lower_bound(xid.begin(), xid.end(), l[i]) - xid.begin();
l[i] = id;
id = lower_bound(xid.begin(), xid.end(), r[i]) - xid.begin();
r[i] = id;
id = lower_bound(yid.begin(), yid.end(), t[i]) - yid.begin();
t[i] = id;
id = lower_bound(yid.begin(), yid.end(), b[i]) - yid.begin();
b[i] = id;
for (int j = l[i]; j <= r[i]; j++) {
fie[j][t[i]] = -1;
fie[j][b[i]] = -1;
}
for (int j = b[i]; j <= t[i]; j++) {
fie[l[i]][j] = -1;
fie[r[i]][j] = -1;
}
}
int cnt = 0;
for (int i = 0; i < 400; i++) {
for (int j = 0; j < 400; j++) {
if (fie[i][j] == 0) {
bfs(i, j);
cnt++;
}
}
}
printf("%d\n", cnt);
}
return 0;
} | insert | 39 | 39 | 39 | 41 | 0 | |
p00916 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
struct Rect {
int l, t, r, b;
};
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void dfs(int y, int x, int h, int w, vvi &field) {
field[y][x] = 2;
REP(i, 4) {
int sx = x + dx[i];
int sy = y + dy[i];
if (sx < 0 || w <= sx || sy < 0 || h <= sy)
continue;
if (field[sy][sx] == 0) {
dfs(sy, sx, h, w, field);
}
}
}
int main() {
int n;
while (cin >> n, n) {
vector<Rect> rect(n);
vi hol, ver;
map<int, int> hol_map, ver_map;
REP(i, n) {
cin >> rect[i].l >> rect[i].t >> rect[i].r >> rect[i].b;
hol.push_back(rect[i].l);
hol.push_back(rect[i].r);
ver.push_back(rect[i].t);
ver.push_back(rect[i].b);
}
SORT(hol);
SORT(ver);
vvi field((ver.size()) * 2 + 1, vi((hol.size()) * 2 + 1, 0));
REP(i, n) {
int l = (find(ALL(hol), rect[i].l) - hol.begin()) * 2 + 1;
int r = (find(ALL(hol), rect[i].r) - hol.begin()) * 2 + 1;
int t = (find(ALL(ver), rect[i].t) - ver.begin()) * 2 + 1;
int b = (find(ALL(ver), rect[i].b) - ver.begin()) * 2 + 1;
LOG("%d %d %d %d\n", l, r, t, b);
FOR(x, l, r + 1) {
field[t][x] = true;
field[b][x] = true;
}
FOR(y, b, t + 1) {
field[y][l] = true;
field[y][r] = true;
}
}
int h = field.size(), w = field[0].size();
int cnt = 0;
REP(y, h) {
REP(x, w) {
if (field[y][x] == 0) {
cnt++;
dfs(y, x, h, w, field);
}
}
}
cout << cnt << endl;
// REP(y, h){
// REP(x, w){
// LOG("%d", field[y][x] & 1);
// }
// LOG("\n");
// }
}
} | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SQ(n) (n) * (n)
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
struct Rect {
int l, t, r, b;
};
int dx[] = {0, 0, 1, -1};
int dy[] = {1, -1, 0, 0};
void dfs(int y, int x, int h, int w, vvi &field) {
field[y][x] = 2;
REP(i, 4) {
int sx = x + dx[i];
int sy = y + dy[i];
if (sx < 0 || w <= sx || sy < 0 || h <= sy)
continue;
if (field[sy][sx] == 0) {
dfs(sy, sx, h, w, field);
}
}
}
int main() {
int n;
while (cin >> n, n) {
vector<Rect> rect(n);
vi hol, ver;
map<int, int> hol_map, ver_map;
REP(i, n) {
cin >> rect[i].l >> rect[i].t >> rect[i].r >> rect[i].b;
hol.push_back(rect[i].l);
hol.push_back(rect[i].r);
ver.push_back(rect[i].t);
ver.push_back(rect[i].b);
}
SORT(hol);
SORT(ver);
vvi field((ver.size()) * 2 + 1, vi((hol.size()) * 2 + 1, 0));
REP(i, n) {
int l = (find(ALL(hol), rect[i].l) - hol.begin()) * 2 + 1;
int r = (find(ALL(hol), rect[i].r) - hol.begin()) * 2 + 1;
int t = (find(ALL(ver), rect[i].t) - ver.begin()) * 2 + 1;
int b = (find(ALL(ver), rect[i].b) - ver.begin()) * 2 + 1;
// LOG("%d %d %d %d\n", l, r, t, b);
FOR(x, l, r + 1) {
field[t][x] = true;
field[b][x] = true;
}
FOR(y, b, t + 1) {
field[y][l] = true;
field[y][r] = true;
}
}
int h = field.size(), w = field[0].size();
int cnt = 0;
REP(y, h) {
REP(x, w) {
if (field[y][x] == 0) {
cnt++;
dfs(y, x, h, w, field);
}
}
}
cout << cnt << endl;
// REP(y, h){
// REP(x, w){
// LOG("%d", field[y][x] & 1);
// }
// LOG("\n");
// }
}
} | replace | 69 | 70 | 69 | 70 | 0 | 1 7 11 3
5 11 7 1
3 9 9 5
1 15 17 3
5 19 3 1
3 7 15 9
7 13 9 7
11 15 17 13
3 5 7 1
1 7 5 3
|
p00916 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define RREP(i, n) for (int i = (int)(n - 1); i >= 0; --i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(a) ((int)(a).size())
#define BIT(x, i) (((x) >> (i)) & 1)
#define SQ(x) ((x) * (x))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int H = 52;
const int W = 52;
long long v[H][W];
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
void dfs(int x, int y, long long c, vvb &G) {
G[y][x] = true;
REP(i, 4) {
int sx = x + dx[i], sy = y + dy[i];
if (0 <= sx && sx < W && 0 <= sy && sy < H) {
if (v[sy][sx] == c && !G[sy][sx])
dfs(sx, sy, c, G);
}
}
}
int main() {
int N;
while (cin >> N, N) {
memset(v, 0, sizeof(v));
vi L, T, R, B;
set<int> Ys, Xs;
REP(i, N) {
int l, t, r, b;
cin >> l >> t >> r >> b;
L.push_back(l);
T.push_back(t);
R.push_back(r);
B.push_back(b);
Ys.insert(t);
Ys.insert(b);
Xs.insert(l);
Xs.insert(r);
}
Ys.insert(-1);
Ys.insert(1e6 + 10);
Xs.insert(-1);
Xs.insert(1e6 + 10);
vi Y(ALL(Ys));
vi X(ALL(Xs));
set<long long> S;
REP(i, N) {
int xl = lower_bound(ALL(X), L[i]) - X.begin();
int xr = lower_bound(ALL(X), R[i]) - X.begin();
int yt = lower_bound(ALL(Y), T[i]) - Y.begin();
int yb = lower_bound(ALL(Y), B[i]) - Y.begin();
FOR(x, xl, xr) {
FOR(y, yb, yt) {
long long bit = (1LL << i);
v[y][x] |= bit;
}
}
}
int cnt = 0;
vvb G(H, vb(W));
REP(y, H) REP(x, W) {
if (!G[y][x]) {
cnt++;
dfs(x, y, v[y][x], G);
}
}
cout << cnt << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define LOG(...) fprintf(stderr, __VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define RFOR(i, a, b) for (int i = (int)(b - 1); i >= (int)(a); --i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define RREP(i, n) for (int i = (int)(n - 1); i >= 0; --i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define SZ(a) ((int)(a).size())
#define BIT(x, i) (((x) >> (i)) & 1)
#define SQ(x) ((x) * (x))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int H = 101;
const int W = 101;
long long v[H][W];
const int dx[] = {-1, 0, 1, 0}, dy[] = {0, 1, 0, -1};
void dfs(int x, int y, long long c, vvb &G) {
G[y][x] = true;
REP(i, 4) {
int sx = x + dx[i], sy = y + dy[i];
if (0 <= sx && sx < W && 0 <= sy && sy < H) {
if (v[sy][sx] == c && !G[sy][sx])
dfs(sx, sy, c, G);
}
}
}
int main() {
int N;
while (cin >> N, N) {
memset(v, 0, sizeof(v));
vi L, T, R, B;
set<int> Ys, Xs;
REP(i, N) {
int l, t, r, b;
cin >> l >> t >> r >> b;
L.push_back(l);
T.push_back(t);
R.push_back(r);
B.push_back(b);
Ys.insert(t);
Ys.insert(b);
Xs.insert(l);
Xs.insert(r);
}
Ys.insert(-1);
Ys.insert(1e6 + 10);
Xs.insert(-1);
Xs.insert(1e6 + 10);
vi Y(ALL(Ys));
vi X(ALL(Xs));
set<long long> S;
REP(i, N) {
int xl = lower_bound(ALL(X), L[i]) - X.begin();
int xr = lower_bound(ALL(X), R[i]) - X.begin();
int yt = lower_bound(ALL(Y), T[i]) - Y.begin();
int yb = lower_bound(ALL(Y), B[i]) - Y.begin();
FOR(x, xl, xr) {
FOR(y, yb, yt) {
long long bit = (1LL << i);
v[y][x] |= bit;
}
}
}
int cnt = 0;
vvb G(H, vb(W));
REP(y, H) REP(x, W) {
if (!G[y][x]) {
cnt++;
dfs(x, y, v[y][x], G);
}
}
cout << cnt << endl;
}
} | replace | 33 | 35 | 33 | 35 | 0 | |
p00918 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = (int)(a)-1; i >= (int)(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
// #define DEBUG
#ifdef DEBUG
#define dump(...) fprintf(stderr, __VA_ARGS__)
#else
#define dump(...)
#endif
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const ll inf = 1LL << 62;
const ll mod = 1000000007LL;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll extgcd(ll a, ll b, ll &x, ll &y) {
x = 1, y = 0;
ll g = a;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= a / b * x;
return g;
}
ll ADD(const ll &a, const ll &b, const ll &mod) { return (a + b) % mod; }
ll SUB(const ll &a, const ll &b, const ll &mod) { return (a - b + mod) % mod; }
ll MUL(const ll &a, const ll &b, const ll &mod) { return (1LL * a * b) % mod; }
ll DIV(const ll &a, const ll &b, const ll &mod) {
ll x, y;
extgcd(b, mod, x, y);
return MUL(a, (x + mod) % mod, mod);
}
random_device rd;
mt19937 mt(rd());
uniform_int_distribution<int> dice(1, 6);
uniform_real_distribution<double> score(0.0, 10.0);
const int N = 3;
int start[N][N], goal[N][N];
using State = tuple<int, string>;
int main(void) {
for (int cx, cy; cin >> cx >> cy, cx;) {
rep(i, N) rep(j, N) cin >> start[i][j];
rep(i, N) rep(j, N) cin >> goal[i][j];
auto vec2s = [&](int hoge[N][N]) {
string ret;
rep(i, N) {
rep(j, N) { ret += to_string(hoge[i][j]); }
}
return ret;
};
string s = vec2s(start);
string z = vec2s(goal);
priority_queue<State, vector<State>, greater<State>> q;
q.push(State(0, s));
map<string, int> min_cost;
int res = -1;
while (q.size()) {
int cost;
string f;
tie(cost, f) = q.top(), q.pop();
if (min_cost.find(f) != end(min_cost))
continue;
min_cost[f] = cost;
if (f == z) {
res = cost;
break;
}
int bx = -1, by = -1;
rep(i, N * N) {
if (f[i] == '0') {
bx = i % 3, by = i / 3;
break;
}
}
assert(bx != -1 and by != -1);
rep(i, 4) {
int tx = bx + dx[i], ty = (by + dy[i] + N) % N;
if (tx < 0) {
tx = 2;
ty = (by + 2) % N;
} else if (tx >= N) {
tx = 0;
ty = (by + 1) % N;
}
assert(not(tx < 0 or N <= tx or ty < 0 or N <= ty));
string nf = f;
swap(nf[ty * 3 + tx], nf[by * 3 + bx]);
int ncost = cost + (i % 2 == 0 ? cx : cy);
if (min_cost.find(nf) == end(min_cost)) {
q.push(State(ncost, nf));
}
}
}
cout << res << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define _overload(_1, _2, _3, name, ...) name
#define _rep(i, n) _range(i, 0, n)
#define _range(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define rep(...) _overload(__VA_ARGS__, _range, _rep, )(__VA_ARGS__)
#define _rrep(i, n) _rrange(i, n, 0)
#define _rrange(i, a, b) for (int i = (int)(a)-1; i >= (int)(b); --i)
#define rrep(...) _overload(__VA_ARGS__, _rrange, _rrep, )(__VA_ARGS__)
#define _all(arg) begin(arg), end(arg)
#define uniq(arg) sort(_all(arg)), (arg).erase(unique(_all(arg)), end(arg))
#define getidx(ary, key) lower_bound(_all(ary), key) - begin(ary)
#define clr(a, b) memset((a), (b), sizeof(a))
#define bit(n) (1LL << (n))
// #define DEBUG
#ifdef DEBUG
#define dump(...) fprintf(stderr, __VA_ARGS__)
#else
#define dump(...)
#endif
template <class T> bool chmax(T &a, const T &b) {
return (a < b) ? (a = b, 1) : 0;
}
template <class T> bool chmin(T &a, const T &b) {
return (b < a) ? (a = b, 1) : 0;
}
using namespace std;
using ll = long long;
using vi = vector<int>;
using vll = vector<ll>;
const double EPS = 1e-10;
const double PI = acos(-1.0);
const ll inf = 1LL << 62;
const ll mod = 1000000007LL;
const int dx[4] = {1, 0, -1, 0};
const int dy[4] = {0, 1, 0, -1};
ll extgcd(ll a, ll b, ll &x, ll &y) {
x = 1, y = 0;
ll g = a;
if (b != 0)
g = extgcd(b, a % b, y, x), y -= a / b * x;
return g;
}
ll ADD(const ll &a, const ll &b, const ll &mod) { return (a + b) % mod; }
ll SUB(const ll &a, const ll &b, const ll &mod) { return (a - b + mod) % mod; }
ll MUL(const ll &a, const ll &b, const ll &mod) { return (1LL * a * b) % mod; }
ll DIV(const ll &a, const ll &b, const ll &mod) {
ll x, y;
extgcd(b, mod, x, y);
return MUL(a, (x + mod) % mod, mod);
}
random_device rd;
mt19937 mt(rd());
uniform_int_distribution<int> dice(1, 6);
uniform_real_distribution<double> score(0.0, 10.0);
const int N = 3;
int start[N][N], goal[N][N];
using State = tuple<int, string>;
int main(void) {
for (int cx, cy; cin >> cx >> cy, cx;) {
rep(i, N) rep(j, N) cin >> start[i][j];
rep(i, N) rep(j, N) cin >> goal[i][j];
auto vec2s = [&](int hoge[N][N]) {
string ret;
rep(i, N) {
rep(j, N) { ret += to_string(hoge[i][j]); }
}
return ret;
};
string s = vec2s(start);
string z = vec2s(goal);
priority_queue<State, vector<State>, greater<State>> q;
q.push(State(0, s));
unordered_map<string, int> min_cost;
int res = -1;
while (q.size()) {
int cost;
string f;
tie(cost, f) = q.top(), q.pop();
if (min_cost.find(f) != end(min_cost))
continue;
min_cost[f] = cost;
if (f == z) {
res = cost;
break;
}
int bx = -1, by = -1;
rep(i, N * N) {
if (f[i] == '0') {
bx = i % 3, by = i / 3;
break;
}
}
assert(bx != -1 and by != -1);
rep(i, 4) {
int tx = bx + dx[i], ty = (by + dy[i] + N) % N;
if (tx < 0) {
tx = 2;
ty = (by + 2) % N;
} else if (tx >= N) {
tx = 0;
ty = (by + 1) % N;
}
assert(not(tx < 0 or N <= tx or ty < 0 or N <= ty));
string nf = f;
swap(nf[ty * 3 + tx], nf[by * 3 + bx]);
int ncost = cost + (i % 2 == 0 ? cx : cy);
if (min_cost.find(nf) == end(min_cost)) {
q.push(State(ncost, nf));
}
}
}
cout << res << endl;
}
return 0;
} | replace | 89 | 90 | 89 | 90 | TLE | |
p00919 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
ld getdis(vector<ld> &l, vector<ld> &r) {
ld sum = 0;
for (int i = 0; i < 3; ++i) {
sum += (l[i] - r[i]) * (l[i] - r[i]);
}
return sqrt(sum);
}
struct po {
int index;
vector<ld> coors;
po(int _d) : coors(_d) { index = -1; }
po(int _index, vector<ld> _coors) : index(_index), coors(_coors) {}
po() {}
};
ld getdis(po &lpo, po &rpo) { return getdis(lpo.coors, rpo.coors); }
template <class T> class axisSorter {
int k;
public:
axisSorter(int _k) : k(_k) {}
bool operator()(const T &a, const T &b) { return a.coors[k] < b.coors[k]; }
};
struct Ans {
ld dis;
pair<int, int> p;
};
bool operator<(const Ans &l, const Ans &r) {
if (abs(l.dis - r.dis) < eps) {
assert(l.p.first < l.p.second);
assert(r.p.first < r.p.second);
return l.p < r.p;
} else {
return l.dis < r.dis;
}
return true;
}
Ans answer;
template <class T, int Dim = 3> struct kdtree {
public:
T midpo;
vector<T> pos;
shared_ptr<kdtree<T>> ltree, rtree;
int depth;
int axis;
kdtree(const T &p_) : midpo(p_), ltree(), rtree() {}
~kdtree() {}
kdtree(vector<T> &ps_, const int &l, const int &r, const int depth_ = 0)
: ltree(nullptr), rtree(nullptr), depth(depth_), axis(depth % Dim) {
init(ps_, l, r);
}
void getmindis() {
vector<po> lpos, rpos;
ld axisvalue = midpo.coors[axis];
if (ltree != nullptr) {
for (auto &po : ltree->pos) {
if (axisvalue > po.coors[axis] - eps * 1000000 &&
po.coors[axis] > axisvalue - sqrt(answer.dis) - eps * 1000000) {
lpos.emplace_back(po);
}
}
}
if (rtree != nullptr) {
for (auto &po : rtree->pos) {
if (axisvalue < po.coors[axis] + eps * 1000000 &&
po.coors[axis] < axisvalue + sqrt(answer.dis) + eps * 1000000) {
rpos.emplace_back(po);
}
}
}
for (auto &lpo : lpos) {
for (auto &rpo : rpos) {
ld dis = getdis(lpo, rpo);
pair<int, int> p(rpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
{
ld dis = getdis(lpo, midpo);
pair<int, int> p(midpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
}
for (auto &rpo : rpos) {
ld dis = getdis(midpo, rpo);
pair<int, int> p(midpo.index, rpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
if (p.first == 1524 && 2763 == p.second) {
int a = 1;
a++;
}
// if (p.first == 2763 && 1524 == p.second)assert(false);
answer = min(answer, nans);
int b;
b = 1;
b++;
}
}
private:
void init(vector<T> &ps, const int &l, const int &r) {
if (l >= r) {
return;
}
const int mid = (l + r) / 2;
nth_element(ps.begin() + l, ps.begin() + mid, ps.begin() + r,
axisSorter<T>(axis));
midpo = ps[mid];
ltree = make_kdtree(ps, l, mid, depth + 1);
rtree = make_kdtree(ps, mid + 1, r, depth + 1);
getmindis();
pos = vector<T>(ps.begin() + l, ps.begin() + r);
}
};
//[l..r)
template <class T>
unique_ptr<kdtree<T>> make_kdtree(vector<T> &ps_, const int &l, const int &r,
const int &depth = 0) {
if (l >= r)
return nullptr;
else {
return make_unique<kdtree<T>>(ps_, l, r, depth);
}
}
vector<ld> getunit(vector<int> v) {
vector<ld> unit;
ld len = 0;
for (auto a : v) {
len += a * a;
unit.emplace_back(ld(a));
}
len = sqrt(len);
for (auto &u : unit) {
u /= len;
}
return unit;
}
int gcd(int l, int r) {
assert(l > 0 && r > 0);
if (l > r)
return gcd(r, l);
else {
const int num = r % l;
if (num) {
return gcd(l, num);
} else {
return l;
}
}
}
int gcd(vector<int> nums) {
if (nums.size() == 1)
return nums[0];
int num = nums[0];
for (int i = 1; i < nums.size(); ++i) {
num = gcd(num, nums[i]);
}
return num;
}
int main() {
while (1) {
answer = Ans{1e18, make_pair(-1, -1)};
int M, N, S, W;
cin >> M >> N >> S >> W;
if (!M && !N && !S && !W)
break;
vector<po> pos;
vector<vector<int>> memo;
{
{
int nx, ny, nz;
for (int i = 0; i < M; ++i) {
cin >> nx >> ny >> nz;
memo.push_back(vector<int>{nx, ny, nz});
}
int g = S;
for (int i = M; i < M + N; ++i) {
nx = (g / 7) % 100 + 1;
ny = (g / 700) % 100 + 1;
nz = (g / 70000) % 100 + 1;
memo.push_back(vector<int>{nx, ny, nz});
if (g % 2 == 0)
g = g / 2;
else
g = (g / 2) ^ W;
}
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
{
vector<vector<int>> newmemo;
map<vector<int>, int> amap;
for (int i = 0; i < memo.size(); ++i) {
int agcd = gcd(memo[i]);
vector<int> v(3);
for (int j = 0; j < 3; ++j)
v[j] = memo[i][j] / agcd;
if (amap.find(v) == amap.end() || amap[v] > agcd) {
amap[v] = agcd;
}
}
for (auto m : amap) {
auto v = m.first;
for (int i = 0; i < 3; ++i) {
v[i] *= m.second;
}
newmemo.emplace_back(v);
}
memo = newmemo;
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
for (int i = 0; i < memo.size(); ++i) {
po p(i, getunit(memo[i]));
pos.emplace_back(p);
}
}
auto tree = make_kdtree(pos, 0, pos.size(), 0);
tree->getmindis();
auto ansp = answer;
if (ansp.p.first > ansp.p.second)
swap(ansp.p.first, ansp.p.second);
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.first][i] << " ";
}
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.second][i];
if (i == 2)
cout << endl;
else
cout << " ";
}
}
return 0;
}
// 1524,2763 | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
ld getdis(vector<ld> &l, vector<ld> &r) {
ld sum = 0;
for (int i = 0; i < 3; ++i) {
sum += (l[i] - r[i]) * (l[i] - r[i]);
}
return sqrt(sum);
}
struct po {
int index;
vector<ld> coors;
po(int _d) : coors(_d) { index = -1; }
po(int _index, vector<ld> _coors) : index(_index), coors(_coors) {}
po() {}
};
ld getdis(po &lpo, po &rpo) { return getdis(lpo.coors, rpo.coors); }
template <class T> class axisSorter {
int k;
public:
axisSorter(int _k) : k(_k) {}
bool operator()(const T &a, const T &b) { return a.coors[k] < b.coors[k]; }
};
struct Ans {
ld dis;
pair<int, int> p;
};
bool operator<(const Ans &l, const Ans &r) {
if (abs(l.dis - r.dis) < eps) {
assert(l.p.first < l.p.second);
assert(r.p.first < r.p.second);
return l.p < r.p;
} else {
return l.dis < r.dis;
}
return true;
}
Ans answer;
template <class T, int Dim = 3> struct kdtree {
public:
T midpo;
vector<T> pos;
shared_ptr<kdtree<T>> ltree, rtree;
int depth;
int axis;
kdtree(const T &p_) : midpo(p_), ltree(), rtree() {}
~kdtree() {}
kdtree(vector<T> &ps_, const int &l, const int &r, const int depth_ = 0)
: ltree(nullptr), rtree(nullptr), depth(depth_), axis(depth % Dim) {
init(ps_, l, r);
}
void getmindis() {
vector<po> lpos, rpos;
ld axisvalue = midpo.coors[axis];
if (ltree != nullptr) {
for (auto &po : ltree->pos) {
if (axisvalue > po.coors[axis] - eps * 1000000 &&
po.coors[axis] > axisvalue - sqrt(answer.dis) - eps * 1000000) {
lpos.emplace_back(po);
}
}
}
if (rtree != nullptr) {
for (auto &po : rtree->pos) {
if (axisvalue < po.coors[axis] + eps * 1000000 &&
po.coors[axis] < axisvalue + sqrt(answer.dis) + eps * 1000000) {
rpos.emplace_back(po);
}
}
}
for (auto &lpo : lpos) {
for (auto &rpo : rpos) {
ld dis = getdis(lpo, rpo);
pair<int, int> p(rpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
{
ld dis = getdis(lpo, midpo);
pair<int, int> p(midpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
}
for (auto &rpo : rpos) {
ld dis = getdis(midpo, rpo);
pair<int, int> p(midpo.index, rpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
if (p.first == 1524 && 2763 == p.second) {
int a = 1;
a++;
}
// if (p.first == 2763 && 1524 == p.second)assert(false);
answer = min(answer, nans);
int b;
b = 1;
b++;
}
}
private:
void init(vector<T> &ps, const int &l, const int &r) {
if (l >= r) {
return;
}
const int mid = (l + r) / 2;
nth_element(ps.begin() + l, ps.begin() + mid, ps.begin() + r,
axisSorter<T>(axis));
midpo = ps[mid];
ltree = make_kdtree(ps, l, mid, depth + 1);
rtree = make_kdtree(ps, mid + 1, r, depth + 1);
getmindis();
ltree.reset();
rtree.reset();
pos = vector<T>(ps.begin() + l, ps.begin() + r);
}
};
//[l..r)
template <class T>
unique_ptr<kdtree<T>> make_kdtree(vector<T> &ps_, const int &l, const int &r,
const int &depth = 0) {
if (l >= r)
return nullptr;
else {
return make_unique<kdtree<T>>(ps_, l, r, depth);
}
}
vector<ld> getunit(vector<int> v) {
vector<ld> unit;
ld len = 0;
for (auto a : v) {
len += a * a;
unit.emplace_back(ld(a));
}
len = sqrt(len);
for (auto &u : unit) {
u /= len;
}
return unit;
}
int gcd(int l, int r) {
assert(l > 0 && r > 0);
if (l > r)
return gcd(r, l);
else {
const int num = r % l;
if (num) {
return gcd(l, num);
} else {
return l;
}
}
}
int gcd(vector<int> nums) {
if (nums.size() == 1)
return nums[0];
int num = nums[0];
for (int i = 1; i < nums.size(); ++i) {
num = gcd(num, nums[i]);
}
return num;
}
int main() {
while (1) {
answer = Ans{1e18, make_pair(-1, -1)};
int M, N, S, W;
cin >> M >> N >> S >> W;
if (!M && !N && !S && !W)
break;
vector<po> pos;
vector<vector<int>> memo;
{
{
int nx, ny, nz;
for (int i = 0; i < M; ++i) {
cin >> nx >> ny >> nz;
memo.push_back(vector<int>{nx, ny, nz});
}
int g = S;
for (int i = M; i < M + N; ++i) {
nx = (g / 7) % 100 + 1;
ny = (g / 700) % 100 + 1;
nz = (g / 70000) % 100 + 1;
memo.push_back(vector<int>{nx, ny, nz});
if (g % 2 == 0)
g = g / 2;
else
g = (g / 2) ^ W;
}
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
{
vector<vector<int>> newmemo;
map<vector<int>, int> amap;
for (int i = 0; i < memo.size(); ++i) {
int agcd = gcd(memo[i]);
vector<int> v(3);
for (int j = 0; j < 3; ++j)
v[j] = memo[i][j] / agcd;
if (amap.find(v) == amap.end() || amap[v] > agcd) {
amap[v] = agcd;
}
}
for (auto m : amap) {
auto v = m.first;
for (int i = 0; i < 3; ++i) {
v[i] *= m.second;
}
newmemo.emplace_back(v);
}
memo = newmemo;
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
for (int i = 0; i < memo.size(); ++i) {
po p(i, getunit(memo[i]));
pos.emplace_back(p);
}
}
auto tree = make_kdtree(pos, 0, pos.size(), 0);
tree->getmindis();
auto ansp = answer;
if (ansp.p.first > ansp.p.second)
swap(ansp.p.first, ansp.p.second);
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.first][i] << " ";
}
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.second][i];
if (i == 2)
cout << endl;
else
cout << " ";
}
}
return 0;
}
// 1524,2763 | insert | 131 | 131 | 131 | 133 | MLE | |
p00919 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
ld getdis(vector<ld> &l, vector<ld> &r) {
ld sum = 0;
for (int i = 0; i < 3; ++i) {
sum += (l[i] - r[i]) * (l[i] - r[i]);
}
return sqrt(sum);
}
struct po {
int index;
vector<ld> coors;
po(int _d) : coors(_d) { index = -1; }
po(int _index, vector<ld> _coors) : index(_index), coors(_coors) {}
po() {}
};
ld getdis(po &lpo, po &rpo) { return getdis(lpo.coors, rpo.coors); }
template <class T> class axisSorter {
int k;
public:
axisSorter(int _k) : k(_k) {}
bool operator()(const T &a, const T &b) { return a.coors[k] < b.coors[k]; }
};
struct Ans {
ld dis;
pair<int, int> p;
};
bool operator<(const Ans &l, const Ans &r) {
if (abs(l.dis - r.dis) < eps) {
assert(l.p.first < l.p.second);
assert(r.p.first < r.p.second);
return l.p < r.p;
} else {
return l.dis < r.dis;
}
return true;
}
Ans answer;
template <class T, int Dim = 3> struct kdtree {
public:
T midpo;
vector<T> pos;
kdtree<T> *ltree, *rtree;
int depth;
int axis;
kdtree(const T &p_) : midpo(p_), ltree(nullptr), rtree(nullptr) {}
~kdtree() {
if (ltree != nullptr) {
delete (ltree);
ltree = nullptr;
}
if (rtree != nullptr) {
delete (rtree);
rtree = nullptr;
}
}
kdtree(vector<T> &ps_, const int &l, const int &r, const int depth_ = 0)
: ltree(nullptr), rtree(nullptr), depth(depth_), axis(depth % Dim) {
init(ps_, l, r);
}
/*vector<T>query(const T & amin, const T&amax) {
vector<T>ans;
bool aok = true;
for (int i = 0; i < Dim; ++i) {
if (amin.coors[i] <= midpo.coors[i] && midpo.coors[i] <= amax.coors[i]) {
}
else {
aok = false;
break;
}
}
if (aok) {
ans.emplace_back(val);
}
axisSorter<T> as(axis);
if (as(midpo, amax) || midpo.coors[axis] == amax.coors[axis]) {
if (rtree != nullptr) {
vector<T>tans(rtree->query(amin, amax));
ans.insert(ans.end(), tans.begin(), tans.end());
}
}
if (as(amin, midpo) || midpo.coors[axis] == amin.coors[axis]) {
if (ltree != nullptr) {
vector<T>tans(ltree->query(amin, amax));
ans.insert(ans.end(), tans.begin(), tans.end());
}
}
return ans;
}*/
void getmindis() {
/*if (ltree != nullptr) {
auto p =ltree->getmindis();
if (ansnum > p.second) {
ansnum = p.second;
ansp = p.first;
}
}
if (rtree != nullptr) {
auto p = rtree->getmindis();
if (ansnum > p.second) {
ansnum = p.second;
ansp = p.first;
}
}*/
vector<po> lpos, rpos;
ld axisvalue = midpo.coors[axis];
if (ltree != nullptr) {
for (auto &po : ltree->pos) {
if (axisvalue > po.coors[axis] - eps * 1000000 &&
po.coors[axis] > axisvalue - sqrt(answer.dis) - eps * 1000000) {
lpos.emplace_back(po);
}
}
}
if (rtree != nullptr) {
for (auto &po : rtree->pos) {
if (axisvalue < po.coors[axis] + eps * 1000000 &&
po.coors[axis] < axisvalue + sqrt(answer.dis) + eps * 1000000) {
rpos.emplace_back(po);
}
}
}
for (auto &lpo : lpos) {
for (auto &rpo : rpos) {
ld dis = getdis(lpo, rpo);
pair<int, int> p(rpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
{
ld dis = getdis(lpo, midpo);
pair<int, int> p(midpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
}
for (auto &rpo : rpos) {
ld dis = getdis(midpo, rpo);
pair<int, int> p(midpo.index, rpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
if (p.first == 1524 && 2763 == p.second) {
int a = 1;
a++;
}
// if (p.first == 2763 && 1524 == p.second)assert(false);
answer = min(answer, nans);
int b;
b = 1;
b++;
}
}
private:
void init(vector<T> &ps, const int &l, const int &r) {
if (l >= r) {
return;
}
sort(ps.begin() + l, ps.begin() + r, axisSorter<T>(axis));
const int mid = (l + r) / 2;
midpo = ps[mid];
ltree = make_kdtree(ps, l, mid, depth + 1);
rtree = make_kdtree(ps, mid + 1, r, depth + 1);
getmindis();
if (ltree)
ltree->pos.clear();
if (rtree)
rtree->pos.clear();
pos = vector<T>(ps.begin() + l, ps.begin() + r);
}
};
//[l..r)
template <class T>
kdtree<T> *make_kdtree(vector<T> &ps_, const int &l, const int &r,
const int &depth = 0) {
if (l >= r)
return nullptr;
else {
return new kdtree<T>(ps_, l, r, depth);
}
}
vector<ld> getunit(vector<int> v) {
vector<ld> unit;
ld len = 0;
for (auto a : v) {
len += a * a;
unit.emplace_back(ld(a));
}
len = sqrt(len);
for (auto &u : unit) {
u /= len;
}
return unit;
}
int gcd(int l, int r) {
assert(l > 0 && r > 0);
if (l > r)
return gcd(r, l);
else {
const int num = r % l;
if (num) {
return gcd(l, num);
} else {
return l;
}
}
}
int gcd(vector<int> nums) {
if (nums.size() == 1)
return nums[0];
int num = nums[0];
for (int i = 1; i < nums.size(); ++i) {
num = gcd(num, nums[i]);
}
return num;
}
int main() {
while (1) {
answer = Ans{1e18, make_pair(-1, -1)};
int M, N, S, W;
cin >> M >> N >> S >> W;
if (!M && !N && !S && !W)
break;
vector<po> pos;
vector<vector<int>> memo;
{
{
int nx, ny, nz;
for (int i = 0; i < M; ++i) {
cin >> nx >> ny >> nz;
memo.push_back(vector<int>{nx, ny, nz});
}
int g = S;
for (int i = M; i < M + N; ++i) {
nx = (g / 7) % 100 + 1;
ny = (g / 700) % 100 + 1;
nz = (g / 70000) % 100 + 1;
memo.push_back(vector<int>{nx, ny, nz});
if (g % 2 == 0)
g = g / 2;
else
g = (g / 2) ^ W;
}
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
{
vector<vector<int>> newmemo;
map<vector<int>, int> amap;
for (int i = 0; i < memo.size(); ++i) {
int agcd = gcd(memo[i]);
vector<int> v(3);
for (int j = 0; j < 3; ++j)
v[j] = memo[i][j] / agcd;
if (amap.find(v) == amap.end() || amap[v] > agcd) {
amap[v] = agcd;
}
}
for (auto m : amap) {
auto v = m.first;
for (int i = 0; i < 3; ++i) {
v[i] *= m.second;
}
newmemo.emplace_back(v);
}
memo = newmemo;
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
for (int i = 0; i < memo.size(); ++i) {
po p(i, getunit(memo[i]));
pos.emplace_back(p);
}
}
auto tree = make_kdtree(pos, 0, pos.size(), 0);
tree->getmindis();
auto ansp = answer;
if (ansp.p.first > ansp.p.second)
swap(ansp.p.first, ansp.p.second);
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.first][i] << " ";
}
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.second][i];
if (i == 2)
cout << endl;
else
cout << " ";
}
delete (tree);
}
return 0;
}
// 1524,2763 | #include "bits/stdc++.h"
using namespace std;
using ld = long double;
const ld eps = 1e-9;
ld getdis(vector<ld> &l, vector<ld> &r) {
ld sum = 0;
for (int i = 0; i < 3; ++i) {
sum += (l[i] - r[i]) * (l[i] - r[i]);
}
return sqrt(sum);
}
struct po {
int index;
vector<ld> coors;
po(int _d) : coors(_d) { index = -1; }
po(int _index, vector<ld> _coors) : index(_index), coors(_coors) {}
po() {}
};
ld getdis(po &lpo, po &rpo) { return getdis(lpo.coors, rpo.coors); }
template <class T> class axisSorter {
int k;
public:
axisSorter(int _k) : k(_k) {}
bool operator()(const T &a, const T &b) { return a.coors[k] < b.coors[k]; }
};
struct Ans {
ld dis;
pair<int, int> p;
};
bool operator<(const Ans &l, const Ans &r) {
if (abs(l.dis - r.dis) < eps) {
assert(l.p.first < l.p.second);
assert(r.p.first < r.p.second);
return l.p < r.p;
} else {
return l.dis < r.dis;
}
return true;
}
Ans answer;
template <class T, int Dim = 3> struct kdtree {
public:
T midpo;
vector<T> pos;
kdtree<T> *ltree, *rtree;
int depth;
int axis;
kdtree(const T &p_) : midpo(p_), ltree(nullptr), rtree(nullptr) {}
~kdtree() {
if (ltree != nullptr) {
delete (ltree);
ltree = nullptr;
}
if (rtree != nullptr) {
delete (rtree);
rtree = nullptr;
}
}
kdtree(vector<T> &ps_, const int &l, const int &r, const int depth_ = 0)
: ltree(nullptr), rtree(nullptr), depth(depth_), axis(depth % Dim) {
init(ps_, l, r);
}
/*vector<T>query(const T & amin, const T&amax) {
vector<T>ans;
bool aok = true;
for (int i = 0; i < Dim; ++i) {
if (amin.coors[i] <= midpo.coors[i] && midpo.coors[i] <= amax.coors[i]) {
}
else {
aok = false;
break;
}
}
if (aok) {
ans.emplace_back(val);
}
axisSorter<T> as(axis);
if (as(midpo, amax) || midpo.coors[axis] == amax.coors[axis]) {
if (rtree != nullptr) {
vector<T>tans(rtree->query(amin, amax));
ans.insert(ans.end(), tans.begin(), tans.end());
}
}
if (as(amin, midpo) || midpo.coors[axis] == amin.coors[axis]) {
if (ltree != nullptr) {
vector<T>tans(ltree->query(amin, amax));
ans.insert(ans.end(), tans.begin(), tans.end());
}
}
return ans;
}*/
void getmindis() {
/*if (ltree != nullptr) {
auto p =ltree->getmindis();
if (ansnum > p.second) {
ansnum = p.second;
ansp = p.first;
}
}
if (rtree != nullptr) {
auto p = rtree->getmindis();
if (ansnum > p.second) {
ansnum = p.second;
ansp = p.first;
}
}*/
vector<po> lpos, rpos;
ld axisvalue = midpo.coors[axis];
if (ltree != nullptr) {
for (auto &po : ltree->pos) {
if (axisvalue > po.coors[axis] - eps * 1000000 &&
po.coors[axis] > axisvalue - sqrt(answer.dis) - eps * 1000000) {
lpos.emplace_back(po);
}
}
}
if (rtree != nullptr) {
for (auto &po : rtree->pos) {
if (axisvalue < po.coors[axis] + eps * 1000000 &&
po.coors[axis] < axisvalue + sqrt(answer.dis) + eps * 1000000) {
rpos.emplace_back(po);
}
}
}
for (auto &lpo : lpos) {
for (auto &rpo : rpos) {
ld dis = getdis(lpo, rpo);
pair<int, int> p(rpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
{
ld dis = getdis(lpo, midpo);
pair<int, int> p(midpo.index, lpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
answer = min(answer, nans);
}
}
for (auto &rpo : rpos) {
ld dis = getdis(midpo, rpo);
pair<int, int> p(midpo.index, rpo.index);
if (p.first > p.second)
swap(p.first, p.second);
Ans nans{dis, p};
if (p.first == 1524 && 2763 == p.second) {
int a = 1;
a++;
}
// if (p.first == 2763 && 1524 == p.second)assert(false);
answer = min(answer, nans);
int b;
b = 1;
b++;
}
}
private:
void init(vector<T> &ps, const int &l, const int &r) {
if (l >= r) {
return;
}
sort(ps.begin() + l, ps.begin() + r, axisSorter<T>(axis));
const int mid = (l + r) / 2;
midpo = ps[mid];
ltree = make_kdtree(ps, l, mid, depth + 1);
rtree = make_kdtree(ps, mid + 1, r, depth + 1);
getmindis();
if (ltree) {
delete (ltree);
ltree = nullptr;
}
if (rtree) {
delete (rtree);
rtree = nullptr;
}
pos = vector<T>(ps.begin() + l, ps.begin() + r);
}
};
//[l..r)
template <class T>
kdtree<T> *make_kdtree(vector<T> &ps_, const int &l, const int &r,
const int &depth = 0) {
if (l >= r)
return nullptr;
else {
return new kdtree<T>(ps_, l, r, depth);
}
}
vector<ld> getunit(vector<int> v) {
vector<ld> unit;
ld len = 0;
for (auto a : v) {
len += a * a;
unit.emplace_back(ld(a));
}
len = sqrt(len);
for (auto &u : unit) {
u /= len;
}
return unit;
}
int gcd(int l, int r) {
assert(l > 0 && r > 0);
if (l > r)
return gcd(r, l);
else {
const int num = r % l;
if (num) {
return gcd(l, num);
} else {
return l;
}
}
}
int gcd(vector<int> nums) {
if (nums.size() == 1)
return nums[0];
int num = nums[0];
for (int i = 1; i < nums.size(); ++i) {
num = gcd(num, nums[i]);
}
return num;
}
int main() {
while (1) {
answer = Ans{1e18, make_pair(-1, -1)};
int M, N, S, W;
cin >> M >> N >> S >> W;
if (!M && !N && !S && !W)
break;
vector<po> pos;
vector<vector<int>> memo;
{
{
int nx, ny, nz;
for (int i = 0; i < M; ++i) {
cin >> nx >> ny >> nz;
memo.push_back(vector<int>{nx, ny, nz});
}
int g = S;
for (int i = M; i < M + N; ++i) {
nx = (g / 7) % 100 + 1;
ny = (g / 700) % 100 + 1;
nz = (g / 70000) % 100 + 1;
memo.push_back(vector<int>{nx, ny, nz});
if (g % 2 == 0)
g = g / 2;
else
g = (g / 2) ^ W;
}
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
{
vector<vector<int>> newmemo;
map<vector<int>, int> amap;
for (int i = 0; i < memo.size(); ++i) {
int agcd = gcd(memo[i]);
vector<int> v(3);
for (int j = 0; j < 3; ++j)
v[j] = memo[i][j] / agcd;
if (amap.find(v) == amap.end() || amap[v] > agcd) {
amap[v] = agcd;
}
}
for (auto m : amap) {
auto v = m.first;
for (int i = 0; i < 3; ++i) {
v[i] *= m.second;
}
newmemo.emplace_back(v);
}
memo = newmemo;
}
sort(memo.begin(), memo.end(),
[](const vector<int> &l, const vector<int> &r) {
for (int i = 0; i < 3; ++i) {
if (l[i] == r[i])
continue;
else
return l[i] < r[i];
}
return false;
});
for (int i = 0; i < memo.size(); ++i) {
po p(i, getunit(memo[i]));
pos.emplace_back(p);
}
}
auto tree = make_kdtree(pos, 0, pos.size(), 0);
tree->getmindis();
auto ansp = answer;
if (ansp.p.first > ansp.p.second)
swap(ansp.p.first, ansp.p.second);
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.first][i] << " ";
}
for (int i = 0; i < 3; ++i) {
cout << memo[answer.p.second][i];
if (i == 2)
cout << endl;
else
cout << " ";
}
delete (tree);
}
return 0;
}
// 1524,2763 | replace | 185 | 189 | 185 | 193 | MLE | |
p00920 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
#define MAX 300005
int m, n, A, B;
int a, b, C = ~(1 << 31), M = (1 << 16) - 1;
int r() {
a = 36969 * (a & M) + (a >> 16);
b = 18000 * (b & M) + (b >> 16);
return (C & ((a << 16) + b)) % 1000000;
}
int x[MAX], y[MAX], z[MAX];
set<P> t[MAX];
void insert(set<P> &s, P p) {
set<P>::iterator it;
while (1) {
it = s.upper_bound(p);
if (it == s.end())
break;
if (p.first <= it->first && p.second <= it->second) {
s.erase(it);
} else {
break;
}
}
s.insert(p);
}
bool check(set<P> &s, P p) {
set<P>::iterator it;
it = s.upper_bound(p);
int cc = 0;
while (it != s.begin()) {
cc++;
if (cc > 3)
break;
it--;
if (it->first < p.first)
if (it->second < p.second)
return true;
}
return false;
}
int calc(P p) {
int left = 0, right = m + n, mid;
while (left < right) {
mid = (left + right) / 2;
if (check(t[mid], p))
left = mid + 1;
else
right = mid;
}
return left;
}
vector<P> G[1000005];
int solve() {
int ans = 1;
for (int i = 0; i <= m + n; i++) {
t[i].clear();
}
t[0].insert(P(-1, -1));
set<int> st;
for (int i = 0; i < m + n; i++) {
st.insert(z[i]);
G[z[i]].push_back(P(x[i], y[i]));
}
for (int i : st) {
vector<int> v(G[i].size());
for (int j = 0; j < (int)G[i].size(); j++) {
v[j] = calc(G[i][j]);
ans = max(ans, v[j]);
}
for (int j = 0; j < (int)G[i].size(); j++) {
insert(t[v[j]], G[i][j]);
}
G[i].clear();
}
/*
for(int i=0;i<=ans;i++){
cout<<i<<" :"<<endl;
for(P p:t[i]){
cout<<p.first<<' '<<p.second<<endl;
}
cout<<endl;
cout<<endl;
}
cout<<endl;
*/
return ans;
}
int main() {
while (1) {
scanf("%d %d %d %d", &m, &n, &A, &B);
if (m == 0 && n == 0 && A == 0 && B == 0)
break;
a = A, b = B;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x[i], &y[i], &z[i]);
}
for (int i = m; i < m + n; i++) {
x[i] = r();
y[i] = r();
z[i] = r();
}
printf("%d\n", solve());
}
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> P;
#define MAX 300005
int m, n, A, B;
int a, b, C = ~(1 << 31), M = (1 << 16) - 1;
int r() {
a = 36969 * (a & M) + (a >> 16);
b = 18000 * (b & M) + (b >> 16);
return (C & ((a << 16) + b)) % 1000000;
}
int x[MAX], y[MAX], z[MAX];
set<P> t[MAX];
void insert(set<P> &s, P p) {
set<P>::iterator it;
while (1) {
it = s.upper_bound(p);
if (it == s.end())
break;
if (p.first <= it->first && p.second <= it->second) {
s.erase(it);
} else {
break;
}
}
s.insert(p);
}
bool check(set<P> &s, P p) {
set<P>::iterator it;
it = s.upper_bound(p);
int cc = 0;
while (it != s.begin()) {
cc++;
if (cc > 3)
break;
it--;
if (it->first < p.first)
if (it->second < p.second)
return true;
}
return false;
}
int calc(P p) {
int left = 0, right = m + n, mid;
while (left < right) {
mid = (left + right) / 2;
if (check(t[mid], p))
left = mid + 1;
else
right = mid;
}
return left;
}
vector<P> G[1000005];
int solve() {
int ans = 1;
for (int i = 0; i <= m + n; i++) {
t[i].clear();
}
t[0].insert(P(-1, -1));
set<int> st;
for (int i = 0; i < m + n; i++) {
st.insert(z[i]);
G[z[i]].push_back(P(x[i], y[i]));
}
for (int i : st) {
vector<int> v(G[i].size());
for (int j = 0; j < (int)G[i].size(); j++) {
v[j] = calc(G[i][j]);
ans = max(ans, v[j]);
}
for (int j = 0; j < (int)G[i].size(); j++) {
if (check(t[v[j]], G[i][j]) == false)
insert(t[v[j]], G[i][j]);
}
G[i].clear();
}
/*
for(int i=0;i<=ans;i++){
cout<<i<<" :"<<endl;
for(P p:t[i]){
cout<<p.first<<' '<<p.second<<endl;
}
cout<<endl;
cout<<endl;
}
cout<<endl;
*/
return ans;
}
int main() {
while (1) {
scanf("%d %d %d %d", &m, &n, &A, &B);
if (m == 0 && n == 0 && A == 0 && B == 0)
break;
a = A, b = B;
for (int i = 0; i < m; i++) {
scanf("%d %d %d", &x[i], &y[i], &z[i]);
}
for (int i = m; i < m + n; i++) {
x[i] = r();
y[i] = r();
z[i] = r();
}
printf("%d\n", solve());
}
} | replace | 84 | 85 | 84 | 86 | TLE | |
p00920 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int a, b, C = ~(1 << 31), M = (1 << 16) - 1;
int r() {
a = 36969 * (a & M) + (a >> 16);
b = 18000 * (b & M) + (b >> 16);
return (C & ((a << 16) + b)) % 1000000;
}
class HappySequence {
public:
map<int, int> seq;
HappySequence() {
int inf = 1e9;
seq[-inf] = -inf;
}
bool insert(int key, int val) {
if ((--seq.upper_bound(key))->second >= val)
return false;
seq[key] = val;
auto it = ++seq.find(key);
while (it != seq.end()) {
if ((*it).second <= val)
seq.erase(it++);
else
it++;
}
return true;
}
};
HappySequence seg[1000100];
void ins(int y, int z, int v) {
for (int i = y; i < 1000100; i += i & -i)
seg[i].insert(z, v);
}
int get(int y, int z) {
int v = 0;
for (int i = y; i > 0; i -= i & -i) {
v = max(v, (--seg[i].seq.lower_bound(z))->second);
}
return v;
}
int main() {
int n, m, A, B;
while (cin >> m >> n >> A >> B && n + m) {
a = A;
b = B;
vector<array<int, 3>> ps;
vector<int> uy;
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
ps.push_back(array<int, 3>{x, y, z});
uy.push_back(y);
}
for (int i = 0; i < n; i++) {
int x = r();
int y = r();
int z = r();
ps.push_back(array<int, 3>{x, y, z});
uy.push_back(y);
}
sort(uy.begin(), uy.end());
uy.erase(unique(uy.begin(), uy.end()), uy.end());
for (int i = 0; i <= uy.size(); i++)
seg[i] = HappySequence();
sort(ps.begin(), ps.end(), [&](array<int, 3> a, array<int, 3> b) {
if (a[0] != b[0])
return a[0] < b[0];
return make_pair(a[1], a[2]) > make_pair(b[1], b[2]);
});
int ans = 0;
for (auto p : ps) {
p[1] = lower_bound(uy.begin(), uy.end(), p[1]) - uy.begin() + 1;
int mx = get(p[1] - 1, p[2]) + 1;
ans = max(ans, mx);
ins(p[1], p[2], mx);
}
cout << ans << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int a, b, C = ~(1 << 31), M = (1 << 16) - 1;
int r() {
a = 36969 * (a & M) + (a >> 16);
b = 18000 * (b & M) + (b >> 16);
return (C & ((a << 16) + b)) % 1000000;
}
class HappySequence {
public:
map<int, int> seq;
HappySequence() {
int inf = 1e9;
seq[-inf] = -inf;
}
bool insert(int key, int val) {
if ((--seq.upper_bound(key))->second >= val)
return false;
seq[key] = val;
auto it = ++seq.find(key);
while (it != seq.end() && (*it).second <= val)
seq.erase(it++);
return true;
}
};
HappySequence seg[1000100];
void ins(int y, int z, int v) {
for (int i = y; i < 1000100; i += i & -i)
seg[i].insert(z, v);
}
int get(int y, int z) {
int v = 0;
for (int i = y; i > 0; i -= i & -i) {
v = max(v, (--seg[i].seq.lower_bound(z))->second);
}
return v;
}
int main() {
int n, m, A, B;
while (cin >> m >> n >> A >> B && n + m) {
a = A;
b = B;
vector<array<int, 3>> ps;
vector<int> uy;
for (int i = 0; i < m; i++) {
int x, y, z;
cin >> x >> y >> z;
ps.push_back(array<int, 3>{x, y, z});
uy.push_back(y);
}
for (int i = 0; i < n; i++) {
int x = r();
int y = r();
int z = r();
ps.push_back(array<int, 3>{x, y, z});
uy.push_back(y);
}
sort(uy.begin(), uy.end());
uy.erase(unique(uy.begin(), uy.end()), uy.end());
for (int i = 0; i <= uy.size(); i++)
seg[i] = HappySequence();
sort(ps.begin(), ps.end(), [&](array<int, 3> a, array<int, 3> b) {
if (a[0] != b[0])
return a[0] < b[0];
return make_pair(a[1], a[2]) > make_pair(b[1], b[2]);
});
int ans = 0;
for (auto p : ps) {
p[1] = lower_bound(uy.begin(), uy.end(), p[1]) - uy.begin() + 1;
int mx = get(p[1] - 1, p[2]) + 1;
ans = max(ans, mx);
ins(p[1], p[2], mx);
}
cout << ans << endl;
}
} | replace | 22 | 28 | 22 | 24 | TLE | |
p00920 | C++ | Time Limit Exceeded | #include <algorithm>
#include <stdio.h>
using namespace std;
struct node {
int LT, RT, LB, RB;
int val;
node() {
LT = RT = LB = RB = -1;
val = 0;
}
node(int a, int b, int c, int d, int e) {
LT = a;
RT = b;
LB = c;
RB = d;
val = e;
}
};
node pool[8000000];
int ind;
int Ret;
int nowret = 0;
int query(int a, int b, int c, int d, int e, int f, int g, int h, int t) {
if (d < a || b < c)
return 0;
if (h < e || f < g)
return 0;
if (c <= a && b <= d && g <= e && f <= h)
return pool[t].val;
if (nowret > pool[t].val)
return 0;
int ret = 0;
if (~pool[t].LT) {
ret = nowret =
max(ret, query(a, (a + b) / 2, c, d, e, (e + f) / 2, g, h, pool[t].LT));
}
if (~pool[t].RT) {
ret = nowret = max(
ret, query(a, (a + b) / 2, c, d, (e + f) / 2 + 1, f, g, h, pool[t].RT));
}
if (~pool[t].LB) {
ret = nowret = max(
ret, query((a + b) / 2 + 1, b, c, d, e, (e + f) / 2, g, h, pool[t].LB));
}
if (~pool[t].RB) {
ret = nowret = max(ret, query((a + b) / 2 + 1, b, c, d, (e + f) / 2 + 1, f,
g, h, pool[t].RB));
}
return ret;
}
inline void update(int row, int col, int C) {
int now = 0;
int a = 0;
int b = 1048575;
int c = 0;
int d = 1048575;
while (1) {
pool[now].val = max(pool[now].val, C);
if (a == b)
break;
int M = (a + b) / 2;
int N = (c + d) / 2;
if (row <= M && col <= N) { // LT
b = M;
d = N;
if (~pool[now].LT) {
now = pool[now].LT;
} else {
pool[ind] = node();
pool[now].LT = ind;
now = ind++;
}
}
if (row <= M && col > N) { // RT
b = M;
c = N + 1;
if (~pool[now].RT) {
now = pool[now].RT;
} else {
pool[ind] = node();
pool[now].RT = ind;
now = ind++;
}
}
if (row > M && col <= N) { // LB
a = M + 1;
d = N;
if (~pool[now].LB) {
now = pool[now].LB;
} else {
pool[ind] = node();
pool[now].LB = ind;
now = ind++;
}
}
if (row > M && col > N) { // RB
a = M + 1;
c = N + 1;
if (~pool[now].RB) {
now = pool[now].RB;
} else {
pool[ind] = node();
pool[now].RB = ind;
now = ind++;
}
}
}
}
pair<int, pair<int, int>> dat[400000];
int x[400000];
int y[400000];
int z[400000];
int Q[400000];
int wolfa, wolfb, wolfC = ~(1 << 31), wolfM = (1 << 16) - 1;
int r() {
wolfa = 36969 * (wolfa & wolfM) + (wolfa >> 16);
wolfb = 18000 * (wolfb & wolfM) + (wolfb >> 16);
return (wolfC & ((wolfa << 16) + wolfb)) % 1000000;
}
int main() {
int a, b, c, d;
while (scanf("%d%d%d%d", &a, &b, &c, &d), a + b) {
for (int i = 0; i < a; i++) {
scanf("%d%d%d", x + i, y + i, z + i);
dat[i] = make_pair(x[i], make_pair(-y[i], -z[i]));
}
wolfa = c;
wolfb = d;
for (int i = 0; i < b; i++) {
int X = r();
int Y = r();
int Z = r();
dat[i + a] = make_pair(X, make_pair(-Y, -Z));
}
int n = a + b;
std::sort(dat, dat + n);
pool[0] = node();
ind = 1;
Ret = 0;
for (int i = 0; i < n; i++) {
nowret = 0;
int P = max(nowret, query(0, 1048575, 0, -dat[i].second.first - 1, 0,
1048575, 0, -dat[i].second.second - 1, 0)) +
1;
Ret = max(Ret, P);
Q[i] = P;
update(-dat[i].second.first, -dat[i].second.second, P);
}
printf("%d\n", Ret);
}
} | #include <algorithm>
#include <stdio.h>
using namespace std;
struct node {
int LT, RT, LB, RB;
int val;
node() {
LT = RT = LB = RB = -1;
val = 0;
}
node(int a, int b, int c, int d, int e) {
LT = a;
RT = b;
LB = c;
RB = d;
val = e;
}
};
node pool[8000000];
int ind;
int Ret;
int nowret = 0;
int query(int a, int b, int c, int d, int e, int f, int g, int h, int t) {
if (d < a || b < c)
return 0;
if (h < e || f < g)
return 0;
if (c <= a && b <= d && g <= e && f <= h)
return pool[t].val;
if (nowret >= pool[t].val)
return 0;
int ret = 0;
if (~pool[t].LT) {
ret = nowret =
max(ret, query(a, (a + b) / 2, c, d, e, (e + f) / 2, g, h, pool[t].LT));
}
if (~pool[t].RT) {
ret = nowret = max(
ret, query(a, (a + b) / 2, c, d, (e + f) / 2 + 1, f, g, h, pool[t].RT));
}
if (~pool[t].LB) {
ret = nowret = max(
ret, query((a + b) / 2 + 1, b, c, d, e, (e + f) / 2, g, h, pool[t].LB));
}
if (~pool[t].RB) {
ret = nowret = max(ret, query((a + b) / 2 + 1, b, c, d, (e + f) / 2 + 1, f,
g, h, pool[t].RB));
}
return ret;
}
inline void update(int row, int col, int C) {
int now = 0;
int a = 0;
int b = 1048575;
int c = 0;
int d = 1048575;
while (1) {
pool[now].val = max(pool[now].val, C);
if (a == b)
break;
int M = (a + b) / 2;
int N = (c + d) / 2;
if (row <= M && col <= N) { // LT
b = M;
d = N;
if (~pool[now].LT) {
now = pool[now].LT;
} else {
pool[ind] = node();
pool[now].LT = ind;
now = ind++;
}
}
if (row <= M && col > N) { // RT
b = M;
c = N + 1;
if (~pool[now].RT) {
now = pool[now].RT;
} else {
pool[ind] = node();
pool[now].RT = ind;
now = ind++;
}
}
if (row > M && col <= N) { // LB
a = M + 1;
d = N;
if (~pool[now].LB) {
now = pool[now].LB;
} else {
pool[ind] = node();
pool[now].LB = ind;
now = ind++;
}
}
if (row > M && col > N) { // RB
a = M + 1;
c = N + 1;
if (~pool[now].RB) {
now = pool[now].RB;
} else {
pool[ind] = node();
pool[now].RB = ind;
now = ind++;
}
}
}
}
pair<int, pair<int, int>> dat[400000];
int x[400000];
int y[400000];
int z[400000];
int Q[400000];
int wolfa, wolfb, wolfC = ~(1 << 31), wolfM = (1 << 16) - 1;
int r() {
wolfa = 36969 * (wolfa & wolfM) + (wolfa >> 16);
wolfb = 18000 * (wolfb & wolfM) + (wolfb >> 16);
return (wolfC & ((wolfa << 16) + wolfb)) % 1000000;
}
int main() {
int a, b, c, d;
while (scanf("%d%d%d%d", &a, &b, &c, &d), a + b) {
for (int i = 0; i < a; i++) {
scanf("%d%d%d", x + i, y + i, z + i);
dat[i] = make_pair(x[i], make_pair(-y[i], -z[i]));
}
wolfa = c;
wolfb = d;
for (int i = 0; i < b; i++) {
int X = r();
int Y = r();
int Z = r();
dat[i + a] = make_pair(X, make_pair(-Y, -Z));
}
int n = a + b;
std::sort(dat, dat + n);
pool[0] = node();
ind = 1;
Ret = 0;
for (int i = 0; i < n; i++) {
nowret = 0;
int P = max(nowret, query(0, 1048575, 0, -dat[i].second.first - 1, 0,
1048575, 0, -dat[i].second.second - 1, 0)) +
1;
Ret = max(Ret, P);
Q[i] = P;
update(-dat[i].second.first, -dat[i].second.second, P);
}
printf("%d\n", Ret);
}
} | replace | 29 | 30 | 29 | 30 | TLE | |
p00923 | C++ | Runtime Error | // very kuso problem
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define ALL(c) c.begin(), c.end()
#define IN(l, v, r) (l <= v && v < r)
template <class T> void UNIQUE(T &v) {
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
}
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
#define range(i, l, r) for (int i = (int)l; i < (int)(r); i++)
// struct range{
// struct Iter{
// int v,step;
// Iter& operator++(){v+=step;return *this;}
// bool operator!=(Iter& itr){return v<itr.v;}
// int& operator*(){return v;}
// };
// Iter i, n;
// range(int i, int n,int step):i({i,step}), n({n,step}){}
// range(int i, int n):range(i,n,1){}
// range(int n):range(0,n){}
// Iter& begin(){return i;}
// Iter& end(){return n;}
// };
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return is >> p.first >> p.second;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
return is >> get<0>(t);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
range(i, 0, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
return os << get<0>(t);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
return os << get<0>(t) << " " << get<1>(t);
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " "
<< get<3>(t);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
struct Edge {
char c;
int f, t;
};
class NFA {
public:
static NFA ONE;
int N;
vector<Edge> es;
vector<vector<int>> f_cache, t_cache;
vector<vector<int>> reachable;
vector<vector<vector<int>>> trans;
int s, t;
NFA(int N = 0) : N(N), s(0), t(1) {
f_cache = t_cache = vector<vector<int>>(N);
}
void add_edge(char c, int f, int t) {
int eid = es.size();
es.push_back({c, f, t});
f_cache[f].push_back(eid);
t_cache[t].push_back(eid);
}
static NFA *disjoint(NFA *a, NFA *b) {
// merge technique
NFA *res = (a->es.size() < b->es.size() ? b : a),
*add = (a->es.size() < b->es.size() ? a : b);
res->f_cache.resize(res->N + add->N);
res->t_cache.resize(res->N + add->N);
int eid = res->es.size();
for (Edge &e : add->es) {
e.f += res->N;
e.t += res->N;
res->es.push_back(e);
res->f_cache[e.f].push_back(eid);
res->t_cache[e.t].push_back(eid);
eid++;
}
res->N += add->N;
return res;
}
static NFA *Union(NFA *a, NFA *b) {
bool bl = a->es.size() < b->es.size();
int as = (bl ? b->N : 0) + a->s, at = (bl ? b->N : 0) + a->t,
bs = (!bl ? a->N : 0) + b->s, bt = (!bl ? a->N : 0) + b->t;
int S = a->N + b->N, T = a->N + b->N + 1;
NFA *ab = disjoint(a, b), *ab1 = disjoint(ab, &ONE),
*res = disjoint(ab1, &ONE);
res->add_edge('-', S, as);
res->add_edge('-', S, bs);
res->add_edge('-', at, T);
res->add_edge('-', bt, T);
res->s = S;
res->t = T;
return res;
}
static NFA *Concat(NFA *a, NFA *b) {
bool bl = a->es.size() < b->es.size();
int as = (bl ? b->N : 0) + a->s, at = (bl ? b->N : 0) + a->t,
bs = (!bl ? a->N : 0) + b->s, bt = (!bl ? a->N : 0) + b->t;
NFA *res = disjoint(a, b);
res->add_edge('-', at, bs);
res->s = as;
res->t = bt;
return res;
}
static NFA *Star(NFA *a) {
NFA *res = disjoint(a, &ONE);
res->add_edge('-', res->N - 1, a->s);
res->add_edge('-', a->t, res->N - 1);
res->s = res->t = res->N - 1;
return res;
}
// step
void create_reachable() {
queue<pair<int, int>> que;
que.push({t, 0});
reachable = vector<vector<int>>(N, vector<int>(4));
reachable[t][0] = true;
while (!que.empty()) {
int t, d;
tie(t, d) = que.front();
que.pop();
// back
for (int eid : t_cache[t]) {
Edge &e = es[eid];
if (e.c == '-') {
if (!reachable[e.f][d]) {
reachable[e.f][d] = true;
que.push({e.f, d});
}
} else {
if (d + 1 < reachable[e.f].size() && !reachable[e.f][d + 1]) {
reachable[e.f][d + 1] = true;
que.push({e.f, d + 1});
}
}
}
}
}
void create_trans() {
trans = vector<vector<vector<int>>>(N, vector<vector<int>>(27));
// eps trans
range(st, 0, N) {
vector<bool> passed(N);
passed[st] = true;
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : f_cache[s])
if (es[eid].c == '-' && !passed[es[eid].t]) {
passed[es[eid].t] = true;
que.push(es[eid].t);
}
}
range(i, 0, N) if (passed[i]) trans[st][26].push_back(i);
}
range(st, 0, N) range(c, 'A', 'Z' + 1) {
// eps trans
vector<bool> passed(N);
for (int s : trans[st][26])
passed[s] = true;
vector<bool> npassed(N);
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : f_cache[s])
if ((es[eid].c == c || es[eid].c == '.') && !npassed[es[eid].t]) {
npassed[es[eid].t] = true;
que.push(es[eid].t);
}
}
// eps trans
range(i, 0, N) if (npassed[i]) for (int s : trans[i][26]) npassed[s] =
true;
range(s, 0, npassed.size()) if (npassed[s]) {
bool alleps = true;
for (int eid : f_cache[s])
alleps &= es[eid].c == '-';
// ???????????? ?? ????§???????????????´?????????????????? for ?????????
if (alleps && t != s)
continue;
trans[st][c - 'A'].push_back(s);
}
}
}
} NFA::ONE = NFA(1);
class REGtoNFA {
public:
static NFA *pattern(string &s, int &i, int e) {
NFA *p = simple(s, i, e);
while (i < e && s[i] == '|') {
i++; // '|'
NFA *q = simple(s, i, e);
p = NFA::Union(p, q);
}
return p;
}
static NFA *simple(string &s, int &i, int e) {
NFA *p = basic(s, i, e);
while (i < e && s[i] != '|') {
NFA *q = basic(s, i, e);
p = NFA::Concat(p, q);
}
return p;
}
static NFA *basic(string &s, int &i, int e) {
NFA *p = elementary(s, i, e);
if (i < (int)s.size() && s[i] == '*') {
i++; // *
p = NFA::Star(p);
}
return p;
}
static NFA *elementary(string &s, int &i, int e) {
NFA *p;
if (s[i] == '(') {
i++; // (
int d = 1;
for (int j = i; j < e; j++) {
if (s[j] == '(')
d++;
if (s[j] == ')')
d--;
if (d == 0) {
e = j;
break;
}
}
p = pattern(s, i, e);
i++; // )
} else {
p = new NFA(2);
p->add_edge(s[i], p->s, p->t);
i++; // c
}
return p;
}
};
int rc = 0;
class Main {
public:
int h, w;
vector<string> tmp, res;
vector<NFA> NFAs;
vector<vector<int>> stats;
void dfs(int y, int x, int c) {
cerr << y << " " << x << endl;
if (rc > 1)
return;
if (y == h) {
rc += c;
res = tmp;
return;
}
// ????????????????????¶??????????????´????????????????????????????????¢?´¢
vector<vector<vector<int>>> nstats(2, vector<vector<int>>(26));
vector<int> nfai = {y, h + x};
range(ni, 0, 2) for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[nfai[ni]])
for (int t : NFAs[nfai[ni]].trans[s][nc - 'A'])
nstats[ni][nc - 'A'].push_back(t);
UNIQUE(nstats[ni][nc - 'A']);
}
vector<int> gid(26);
iota(ALL(gid), 0);
for (char c1 = 'A'; c1 <= 'Z'; c1++)
for (char c2 = 'A'; c2 < c1; c2++)
if (gid[c2 - 'A'] == c2 - 'A') {
if (nstats[0][c1 - 'A'].size() == nstats[0][c2 - 'A'].size() &&
nstats[1][c1 - 'A'].size() == nstats[1][c2 - 'A'].size()) {
bool eq = true;
range(ni, 0, 2) {
range(i, 0, nstats[ni][c1 - 'A'].size()) {
eq &= nstats[ni][c1 - 'A'][i] == nstats[ni][c2 - 'A'][i];
if (!eq)
break;
}
if (!eq)
break;
}
if (eq) {
gid[c1 - 'A'] = gid[c2 - 'A'];
break;
}
}
}
vector<int> gc(26);
range(i, 0, 26) gc[gid[i]]++;
for (char c = 'A'; c <= 'Z'; c++)
if (gid[c - 'A'] == c - 'A') {
tmp[y][x] = c;
bool tmpOK = true;
// eda ??????????????? de ikerukana ?
{
bool ok = false;
for (int s : nstats[0][c - 'A'])
ok |= NFAs[y].reachable[s][w - 1 - x];
tmpOK &= ok;
}
{
bool ok = false;
for (int s : nstats[1][c - 'A'])
ok |= NFAs[h + x].reachable[s][h - 1 - y];
tmpOK &= ok;
}
if (x == w - 1) {
bool ok = false;
for (int s : nstats[0][c - 'A'])
ok |= s == NFAs[y].t;
tmpOK &= ok;
}
if (y == h - 1) {
bool ok = false;
for (int s : nstats[1][c - 'A'])
ok |= s == NFAs[h + x].t;
tmpOK &= ok;
}
if (tmpOK) {
vector<int> tmpp = stats[y], tmpq = stats[h + x];
stats[y] = nstats[0][c - 'A'];
stats[h + x] = nstats[1][c - 'A'];
if (x + 1 < w)
dfs(y, x + 1, gc[c - 'A']);
else
dfs(y + 1, 0, gc[c - 'A']);
stats[y] = tmpp;
stats[h + x] = tmpq;
}
}
}
void run() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0)
break;
rc = 0;
tmp = res = vector<string>(h, string(w, '-'));
vector<string> ss(h + w);
cin >> ss;
// h <= 4, w <= 4
NFAs = vector<NFA>(h + w);
range(i, 0, h + w) {
string s = "";
range(j, 1, ss[i].size() - 1) s += ss[i][j];
int cur = 0, e = s.size();
NFAs[i] = *REGtoNFA::pattern(s, cur, e);
}
range(i, 0, h + w) {
NFAs[i].create_reachable();
NFAs[i].create_trans();
}
stats = vector<vector<int>>(h + w);
range(i, 0, h + w) stats[i].push_back(NFAs[i].s);
dfs(0, 0, 1);
if (rc > 1) {
cout << "ambiguous" << endl;
} else if (rc == 0) {
cout << "none" << endl;
} else {
range(i, 0, h) cout << res[i] << endl;
}
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | // very kuso problem
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define ALL(c) c.begin(), c.end()
#define IN(l, v, r) (l <= v && v < r)
template <class T> void UNIQUE(T &v) {
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
}
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
#define range(i, l, r) for (int i = (int)l; i < (int)(r); i++)
// struct range{
// struct Iter{
// int v,step;
// Iter& operator++(){v+=step;return *this;}
// bool operator!=(Iter& itr){return v<itr.v;}
// int& operator*(){return v;}
// };
// Iter i, n;
// range(int i, int n,int step):i({i,step}), n({n,step}){}
// range(int i, int n):range(i,n,1){}
// range(int n):range(0,n){}
// Iter& begin(){return i;}
// Iter& end(){return n;}
// };
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return is >> p.first >> p.second;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
return is >> get<0>(t);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
range(i, 0, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
return os << get<0>(t);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
return os << get<0>(t) << " " << get<1>(t);
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " "
<< get<3>(t);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
struct Edge {
char c;
int f, t;
};
class NFA {
public:
static NFA ONE;
int N;
vector<Edge> es;
vector<vector<int>> f_cache, t_cache;
vector<vector<int>> reachable;
vector<vector<vector<int>>> trans;
int s, t;
NFA(int N = 0) : N(N), s(0), t(1) {
f_cache = t_cache = vector<vector<int>>(N);
}
void add_edge(char c, int f, int t) {
int eid = es.size();
es.push_back({c, f, t});
f_cache[f].push_back(eid);
t_cache[t].push_back(eid);
}
static NFA *disjoint(NFA *a, NFA *b) {
// merge technique
NFA *res = (a->es.size() < b->es.size() ? b : a),
*add = (a->es.size() < b->es.size() ? a : b);
res->f_cache.resize(res->N + add->N);
res->t_cache.resize(res->N + add->N);
int eid = res->es.size();
for (Edge &e : add->es) {
e.f += res->N;
e.t += res->N;
res->es.push_back(e);
res->f_cache[e.f].push_back(eid);
res->t_cache[e.t].push_back(eid);
eid++;
}
res->N += add->N;
return res;
}
static NFA *Union(NFA *a, NFA *b) {
bool bl = a->es.size() < b->es.size();
int as = (bl ? b->N : 0) + a->s, at = (bl ? b->N : 0) + a->t,
bs = (!bl ? a->N : 0) + b->s, bt = (!bl ? a->N : 0) + b->t;
int S = a->N + b->N, T = a->N + b->N + 1;
NFA *ab = disjoint(a, b), *ab1 = disjoint(ab, &ONE),
*res = disjoint(ab1, &ONE);
res->add_edge('-', S, as);
res->add_edge('-', S, bs);
res->add_edge('-', at, T);
res->add_edge('-', bt, T);
res->s = S;
res->t = T;
return res;
}
static NFA *Concat(NFA *a, NFA *b) {
bool bl = a->es.size() < b->es.size();
int as = (bl ? b->N : 0) + a->s, at = (bl ? b->N : 0) + a->t,
bs = (!bl ? a->N : 0) + b->s, bt = (!bl ? a->N : 0) + b->t;
NFA *res = disjoint(a, b);
res->add_edge('-', at, bs);
res->s = as;
res->t = bt;
return res;
}
static NFA *Star(NFA *a) {
NFA *res = disjoint(a, &ONE);
res->add_edge('-', res->N - 1, a->s);
res->add_edge('-', a->t, res->N - 1);
res->s = res->t = res->N - 1;
return res;
}
// step
void create_reachable() {
queue<pair<int, int>> que;
que.push({t, 0});
reachable = vector<vector<int>>(N, vector<int>(4));
reachable[t][0] = true;
while (!que.empty()) {
int t, d;
tie(t, d) = que.front();
que.pop();
// back
for (int eid : t_cache[t]) {
Edge &e = es[eid];
if (e.c == '-') {
if (!reachable[e.f][d]) {
reachable[e.f][d] = true;
que.push({e.f, d});
}
} else {
if (d + 1 < reachable[e.f].size() && !reachable[e.f][d + 1]) {
reachable[e.f][d + 1] = true;
que.push({e.f, d + 1});
}
}
}
}
}
void create_trans() {
trans = vector<vector<vector<int>>>(N, vector<vector<int>>(27));
// eps trans
range(st, 0, N) {
vector<bool> passed(N);
passed[st] = true;
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : f_cache[s])
if (es[eid].c == '-' && !passed[es[eid].t]) {
passed[es[eid].t] = true;
que.push(es[eid].t);
}
}
range(i, 0, N) if (passed[i]) trans[st][26].push_back(i);
}
range(st, 0, N) range(c, 'A', 'Z' + 1) {
// eps trans
vector<bool> passed(N);
for (int s : trans[st][26])
passed[s] = true;
vector<bool> npassed(N);
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : f_cache[s])
if ((es[eid].c == c || es[eid].c == '.') && !npassed[es[eid].t]) {
npassed[es[eid].t] = true;
que.push(es[eid].t);
}
}
// eps trans
range(i, 0, N) if (npassed[i]) for (int s : trans[i][26]) npassed[s] =
true;
range(s, 0, npassed.size()) if (npassed[s]) {
bool alleps = true;
for (int eid : f_cache[s])
alleps &= es[eid].c == '-';
// ???????????? ?? ????§???????????????´?????????????????? for ?????????
if (alleps && t != s)
continue;
trans[st][c - 'A'].push_back(s);
}
}
}
} NFA::ONE = NFA(1);
class REGtoNFA {
public:
static NFA *pattern(string &s, int &i, int e) {
NFA *p = simple(s, i, e);
while (i < e && s[i] == '|') {
i++; // '|'
NFA *q = simple(s, i, e);
p = NFA::Union(p, q);
}
return p;
}
static NFA *simple(string &s, int &i, int e) {
NFA *p = basic(s, i, e);
while (i < e && s[i] != '|') {
NFA *q = basic(s, i, e);
p = NFA::Concat(p, q);
}
return p;
}
static NFA *basic(string &s, int &i, int e) {
NFA *p = elementary(s, i, e);
if (i < (int)s.size() && s[i] == '*') {
i++; // *
p = NFA::Star(p);
}
return p;
}
static NFA *elementary(string &s, int &i, int e) {
NFA *p;
if (s[i] == '(') {
i++; // (
int d = 1;
for (int j = i; j < e; j++) {
if (s[j] == '(')
d++;
if (s[j] == ')')
d--;
if (d == 0) {
e = j;
break;
}
}
p = pattern(s, i, e);
i++; // )
} else {
p = new NFA(2);
p->add_edge(s[i], p->s, p->t);
i++; // c
}
return p;
}
};
int rc = 0;
class Main {
public:
int h, w;
vector<string> tmp, res;
vector<NFA> NFAs;
vector<vector<int>> stats;
void dfs(int y, int x, int c) {
if (rc > 1)
return;
if (y == h) {
rc += c;
res = tmp;
return;
}
// ????????????????????¶??????????????´????????????????????????????????¢?´¢
vector<vector<vector<int>>> nstats(2, vector<vector<int>>(26));
vector<int> nfai = {y, h + x};
range(ni, 0, 2) for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[nfai[ni]])
for (int t : NFAs[nfai[ni]].trans[s][nc - 'A'])
nstats[ni][nc - 'A'].push_back(t);
UNIQUE(nstats[ni][nc - 'A']);
}
vector<int> gid(26);
iota(ALL(gid), 0);
for (char c1 = 'A'; c1 <= 'Z'; c1++)
for (char c2 = 'A'; c2 < c1; c2++)
if (gid[c2 - 'A'] == c2 - 'A') {
if (nstats[0][c1 - 'A'].size() == nstats[0][c2 - 'A'].size() &&
nstats[1][c1 - 'A'].size() == nstats[1][c2 - 'A'].size()) {
bool eq = true;
range(ni, 0, 2) {
range(i, 0, nstats[ni][c1 - 'A'].size()) {
eq &= nstats[ni][c1 - 'A'][i] == nstats[ni][c2 - 'A'][i];
if (!eq)
break;
}
if (!eq)
break;
}
if (eq) {
gid[c1 - 'A'] = gid[c2 - 'A'];
break;
}
}
}
vector<int> gc(26);
range(i, 0, 26) gc[gid[i]]++;
for (char c = 'A'; c <= 'Z'; c++)
if (gid[c - 'A'] == c - 'A') {
tmp[y][x] = c;
bool tmpOK = true;
// eda ??????????????? de ikerukana ?
{
bool ok = false;
for (int s : nstats[0][c - 'A'])
ok |= NFAs[y].reachable[s][w - 1 - x];
tmpOK &= ok;
}
{
bool ok = false;
for (int s : nstats[1][c - 'A'])
ok |= NFAs[h + x].reachable[s][h - 1 - y];
tmpOK &= ok;
}
if (x == w - 1) {
bool ok = false;
for (int s : nstats[0][c - 'A'])
ok |= s == NFAs[y].t;
tmpOK &= ok;
}
if (y == h - 1) {
bool ok = false;
for (int s : nstats[1][c - 'A'])
ok |= s == NFAs[h + x].t;
tmpOK &= ok;
}
if (tmpOK) {
vector<int> tmpp = stats[y], tmpq = stats[h + x];
stats[y] = nstats[0][c - 'A'];
stats[h + x] = nstats[1][c - 'A'];
if (x + 1 < w)
dfs(y, x + 1, gc[c - 'A']);
else
dfs(y + 1, 0, gc[c - 'A']);
stats[y] = tmpp;
stats[h + x] = tmpq;
}
}
}
void run() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0)
break;
rc = 0;
tmp = res = vector<string>(h, string(w, '-'));
vector<string> ss(h + w);
cin >> ss;
// h <= 4, w <= 4
NFAs = vector<NFA>(h + w);
range(i, 0, h + w) {
string s = "";
range(j, 1, ss[i].size() - 1) s += ss[i][j];
int cur = 0, e = s.size();
NFAs[i] = *REGtoNFA::pattern(s, cur, e);
}
range(i, 0, h + w) {
NFAs[i].create_reachable();
NFAs[i].create_trans();
}
stats = vector<vector<int>>(h + w);
range(i, 0, h + w) stats[i].push_back(NFAs[i].s);
dfs(0, 0, 1);
if (rc > 1) {
cout << "ambiguous" << endl;
} else if (rc == 0) {
cout << "none" << endl;
} else {
range(i, 0, h) cout << res[i] << endl;
}
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | delete | 352 | 353 | 352 | 352 | TLE | |
p00923 | C++ | Time Limit Exceeded | // very kuso problem
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define ALL(c) c.begin(), c.end()
#define IN(l, v, r) (l <= v && v < r)
template <class T> void UNIQUE(T &v) { v.erase(unique(ALL(v)), v.end()); }
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
#define range(i, l, r) for (int i = (int)l; i < (int)(r); i++)
// struct range{
// struct Iter{
// int v,step;
// Iter& operator++(){v+=step;return *this;}
// bool operator!=(Iter& itr){return v<itr.v;}
// int& operator*(){return v;}
// };
// Iter i, n;
// range(int i, int n,int step):i({i,step}), n({n,step}){}
// range(int i, int n):range(i,n,1){}
// range(int n):range(0,n){}
// Iter& begin(){return i;}
// Iter& end(){return n;}
// };
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return is >> p.first >> p.second;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
return is >> get<0>(t);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
range(i, 0, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
return os << get<0>(t);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
return os << get<0>(t) << " " << get<1>(t);
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " "
<< get<3>(t);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
struct Edge {
char c;
int f, t;
};
class NFA {
public:
// (source)initial state = 0, (target)acc state = 0 or 1
int N;
vector<Edge> es;
vector<vector<int>> f_cache, t_cache;
int s, t;
NFA(int N = 0) : N(N), s(0), t(1) {
f_cache = t_cache = vector<vector<int>>(N);
}
void add_edge(char c, int f, int t) {
int eid = es.size();
es.push_back({c, f, t});
f_cache[f].push_back(eid);
t_cache[t].push_back(eid);
}
void disjoint(NFA &b) {
f_cache.resize(N + b.N);
t_cache.resize(N + b.N);
for (Edge &e : b.es) {
e.f += N;
e.t += N;
int eid = es.size();
es.push_back(e);
f_cache[e.f].push_back(eid);
t_cache[e.t].push_back(eid);
}
N += b.N;
}
void Union(NFA b) {
int as = s, at = t, aN = N, bs = b.s, bt = b.t, bN = b.N;
disjoint(b);
NFA sp = NFA(1);
disjoint(sp);
NFA tp = NFA(1);
disjoint(tp);
add_edge('-', aN + bN, as);
add_edge('-', aN + bN, aN + bs);
add_edge('-', at, aN + bN + 1);
add_edge('-', aN + bt, aN + bN + 1);
s = aN + bN;
t = aN + bN + 1;
}
void Concat(NFA b) {
int as = s, at = t, aN = N, bs = b.s, bt = b.t, bN = b.N;
disjoint(b);
add_edge('-', at, aN + bs);
s = as;
t = aN + bt;
}
void Star() {
NFA sp = NFA(1);
disjoint(sp);
add_edge('-', N - 1, s);
add_edge('-', t, N - 1);
s = t = N - 1;
}
// parsing
static NFA pattern(string &s, int &i, int e) {
NFA p = simple(s, i, e);
while (i < e && s[i] == '|') {
i++; // '|'
p.Union(simple(s, i, e));
}
return p;
}
static NFA simple(string &s, int &i, int e) {
NFA p = basic(s, i, e);
while (i < e && s[i] != '|') {
p.Concat(basic(s, i, e));
}
return p;
}
static NFA basic(string &s, int &i, int e) {
NFA p = elementary(s, i, e);
if (i < (int)s.size() && s[i] == '*') {
i++; // *
p.Star();
}
return p;
}
static NFA elementary(string &s, int &i, int e) {
NFA p;
if (s[i] == '(') {
i++; // (
int d = 1;
for (int j = i; j < e; j++) {
if (s[j] == '(')
d++;
if (s[j] == ')')
d--;
if (d == 0) {
e = j;
break;
}
}
p = pattern(s, i, e);
i++; // )
} else {
p = NFA(2);
p.add_edge(s[i], p.s, p.t);
i++; // c
}
return p;
}
};
int rc = 0;
class Main {
public:
int h, w;
vector<string> tmp, res;
vector<NFA> NFAs;
vector<vector<int>> stats;
vector<vector<vector<int>>> reachable;
vector<vector<vector<vector<int>>>> trans;
void create_reachable(int nind) {
NFA &nfa = NFAs[nind];
queue<pair<int, int>> que;
que.push({nfa.t, 0});
reachable[nind][nfa.t][0] = true;
while (!que.empty()) {
int t, d;
tie(t, d) = que.front();
que.pop();
// back
for (int eid : nfa.t_cache[t]) {
Edge &e = nfa.es[eid];
if (e.c == '-') {
if (!reachable[nind][e.f][d]) {
reachable[nind][e.f][d] = true;
que.push({e.f, d});
}
} else {
if (d + 1 < reachable[nind][e.f].size() &&
!reachable[nind][e.f][d + 1]) {
reachable[nind][e.f][d + 1] = true;
que.push({e.f, d + 1});
}
}
}
}
}
void create_trans(int nind, int st, char nc) {
NFA &nfa = NFAs[nind];
vector<bool> passed(nfa.N);
passed[st] = true;
// eps trans
{
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : nfa.f_cache[s])
if (nfa.es[eid].c == '-' && !passed[nfa.es[eid].t]) {
passed[nfa.es[eid].t] = true;
que.push(nfa.es[eid].t);
}
}
}
// trans
{
vector<bool> npassed(nfa.N);
range(s, 0, nfa.N) if (passed[s]) for (int eid : nfa.f_cache[s]) {
char c = nfa.es[eid].c;
int t = nfa.es[eid].t;
if (nc == c || c == '.')
npassed[t] = true;
}
passed = npassed;
}
// eps trans
{
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : nfa.f_cache[s])
if (nfa.es[eid].c == '-' && !passed[nfa.es[eid].t]) {
passed[nfa.es[eid].t] = true;
que.push(nfa.es[eid].t);
}
}
}
range(s, 0, passed.size()) if (passed[s]) {
bool exeps = false, alleps = true;
for (int eid : nfa.f_cache[s]) {
exeps |= nfa.es[eid].c == '-';
alleps &= nfa.es[eid].c == '-';
}
// ?? ????§???????????????´?????????????????? for ?????????
if (exeps && alleps && nfa.t != s)
continue;
trans[nind][st][nc - 'A'].push_back(s);
}
}
void dfs(int y, int x, int c) {
// cerr << y <<" " << x <<endl;
// cerr << tmp <<endl;
if (rc > 1)
return;
if (y == h) {
rc += c;
res = tmp;
return;
}
// ????????????????????¶??????????????´????????????????????????????????¢?´¢
vector<vector<int>> ynstats(26), xnstats(26);
for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[y])
for (int t : trans[y][s][nc - 'A'])
ynstats[nc - 'A'].push_back(t);
UNIQUE(ynstats[nc - 'A']);
}
for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[h + x])
for (int t : trans[h + x][s][nc - 'A'])
xnstats[nc - 'A'].push_back(t);
UNIQUE(xnstats[nc - 'A']);
}
vector<int> gid(26);
iota(ALL(gid), 0);
for (char c1 = 'A'; c1 <= 'Z'; c1++) {
for (char c2 = 'A'; c2 < c1; c2++)
if (gid[c2 - 'A'] == c2 - 'A') {
if (ynstats[c1 - 'A'].size() == ynstats[c2 - 'A'].size() &&
xnstats[c1 - 'A'].size() == xnstats[c2 - 'A'].size()) {
bool eq = true;
range(i, 0, ynstats[c1 - 'A'].size()) eq &=
ynstats[c1 - 'A'][i] == ynstats[c2 - 'A'][i];
range(i, 0, xnstats[c1 - 'A'].size()) eq &=
xnstats[c1 - 'A'][i] == xnstats[c2 - 'A'][i];
if (eq) {
gid[c1 - 'A'] = gid[c2 - 'A'];
break;
}
}
}
}
vector<int> gc(26);
range(i, 0, 26) gc[gid[i]]++;
for (char c = 'A'; c <= 'Z'; c++)
if (gid[c - 'A'] == c - 'A') {
tmp[y][x] = c;
bool tmpOK = true;
// eda ??????????????? de ikerukana ?
{
bool ok = false;
for (int s : ynstats[c - 'A'])
ok |= reachable[y][s][w - 1 - x];
tmpOK &= ok;
}
{
bool ok = false;
for (int s : xnstats[c - 'A'])
ok |= reachable[h + x][s][h - 1 - y];
tmpOK &= ok;
}
if (x == w - 1) {
bool ok = false;
for (int s : ynstats[c - 'A'])
ok |= s == NFAs[y].t;
tmpOK &= ok;
}
if (y == h - 1) {
bool ok = false;
for (int s : xnstats[c - 'A'])
ok |= s == NFAs[h + x].t;
tmpOK &= ok;
}
if (tmpOK) {
vector<int> tmpp = stats[y], tmpq = stats[h + x];
stats[y] = ynstats[c - 'A'];
stats[h + x] = xnstats[c - 'A'];
if (x + 1 < w)
dfs(y, x + 1, gc[c - 'A']);
else
dfs(y + 1, 0, gc[c - 'A']);
stats[y] = tmpp;
stats[h + x] = tmpq;
}
}
}
void run() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0)
break;
rc = 0;
tmp = res = vector<string>(h, string(w, '-'));
vector<string> ss(h + w);
cin >> ss;
// h <= 4, w <= 4
NFAs = vector<NFA>(h + w);
range(i, 0, h + w) {
string s = "";
range(j, 1, ss[i].size() - 1) s += ss[i][j];
int cur = 0, e = s.size();
NFAs[i] = NFA::pattern(s, cur, e);
}
stats = vector<vector<int>>(h + w);
range(i, 0, h + w) stats[i].push_back(NFAs[i].s);
reachable = vector<vector<vector<int>>>(h + w);
range(i, 0, h) {
reachable[i] = vector<vector<int>>(NFAs[i].N);
range(s, 0, NFAs[i].N) reachable[i][s] = vector<int>(h + 1);
}
range(i, 0, w) {
reachable[h + i] = vector<vector<int>>(NFAs[h + i].N);
range(s, 0, NFAs[h + i].N) reachable[h + i][s] = vector<int>(w + 1);
}
range(i, 0, h + w) create_reachable(i);
trans = vector<vector<vector<vector<int>>>>(h + w);
range(i, 0, h + w) {
trans[i] =
vector<vector<vector<int>>>(NFAs[i].N, vector<vector<int>>(26));
range(s, 0, NFAs[i].N) range(c, 'A', 'Z' + 1) create_trans(i, s, c);
}
// cerr << NFAs[0].t <<endl;
// range(i,0,NFAs[0].es.size()){
// cerr << NFAs[0].es[i].c <<" " <<NFAs[0].es[i].f <<" "
// <<NFAs[0].es[i].t <<endl;
// }
// cerr << NFAs[0].t_cache <<endl;
dfs(0, 0, 1);
if (rc > 1) {
cout << "ambiguous" << endl;
} else if (rc == 0) {
cout << "none" << endl;
} else {
range(i, 0, h) cout << res[i] << endl;
}
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | // very kuso problem
#include <algorithm> // other
#include <bitset>
#include <cassert> // c
#include <complex>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream> // io
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <regex>
#include <set>
#include <sstream>
#include <stack>
#include <vector> // container
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
#define ALL(c) c.begin(), c.end()
#define IN(l, v, r) (l <= v && v < r)
template <class T> void UNIQUE(T &v) {
sort(ALL(v));
v.erase(unique(ALL(v)), v.end());
}
#define DUMP(x) cerr << #x << " = " << (x)
#define LINE() cerr << " (L" << __LINE__ << ")"
#define range(i, l, r) for (int i = (int)l; i < (int)(r); i++)
// struct range{
// struct Iter{
// int v,step;
// Iter& operator++(){v+=step;return *this;}
// bool operator!=(Iter& itr){return v<itr.v;}
// int& operator*(){return v;}
// };
// Iter i, n;
// range(int i, int n,int step):i({i,step}), n({n,step}){}
// range(int i, int n):range(i,n,1){}
// range(int n):range(0,n){}
// Iter& begin(){return i;}
// Iter& end(){return n;}
// };
// input
template <typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) {
return is >> p.first >> p.second;
}
template <typename T1> istream &operator>>(istream &is, tuple<T1> &t) {
return is >> get<0>(t);
}
template <typename T1, typename T2>
istream &operator>>(istream &is, tuple<T1, T2> &t) {
return is >> get<0>(t) >> get<1>(t);
}
template <typename T1, typename T2, typename T3>
istream &operator>>(istream &is, tuple<T1, T2, T3> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
istream &operator>>(istream &is, tuple<T1, T2, T3, T4> &t) {
return is >> get<0>(t) >> get<1>(t) >> get<2>(t) >> get<3>(t);
}
template <typename T> istream &operator>>(istream &is, vector<T> &as) {
range(i, 0, as.size()) is >> as[i];
return is;
}
// output
template <typename T> ostream &operator<<(ostream &os, const set<T> &ss) {
for (auto a : ss) {
if (a != ss.begin())
os << " ";
os << a;
}
return os;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
return os << p.first << " " << p.second;
}
template <typename K, typename V>
ostream &operator<<(ostream &os, const map<K, V> &m) {
bool isF = true;
for (auto &p : m) {
if (!isF)
os << endl;
os << p;
isF = false;
}
return os;
}
template <typename T1> ostream &operator<<(ostream &os, const tuple<T1> &t) {
return os << get<0>(t);
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const tuple<T1, T2> &t) {
return os << get<0>(t) << " " << get<1>(t);
}
template <typename T1, typename T2, typename T3>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t);
}
template <typename T1, typename T2, typename T3, typename T4>
ostream &operator<<(ostream &os, const tuple<T1, T2, T3, T4> &t) {
return os << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << " "
<< get<3>(t);
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << " ";
os << as[i];
}
return os;
}
template <typename T>
ostream &operator<<(ostream &os, const vector<vector<T>> &as) {
range(i, 0, as.size()) {
if (i != 0)
os << endl;
os << as[i];
}
return os;
}
struct Edge {
char c;
int f, t;
};
class NFA {
public:
// (source)initial state = 0, (target)acc state = 0 or 1
int N;
vector<Edge> es;
vector<vector<int>> f_cache, t_cache;
int s, t;
NFA(int N = 0) : N(N), s(0), t(1) {
f_cache = t_cache = vector<vector<int>>(N);
}
void add_edge(char c, int f, int t) {
int eid = es.size();
es.push_back({c, f, t});
f_cache[f].push_back(eid);
t_cache[t].push_back(eid);
}
void disjoint(NFA &b) {
f_cache.resize(N + b.N);
t_cache.resize(N + b.N);
for (Edge &e : b.es) {
e.f += N;
e.t += N;
int eid = es.size();
es.push_back(e);
f_cache[e.f].push_back(eid);
t_cache[e.t].push_back(eid);
}
N += b.N;
}
void Union(NFA b) {
int as = s, at = t, aN = N, bs = b.s, bt = b.t, bN = b.N;
disjoint(b);
NFA sp = NFA(1);
disjoint(sp);
NFA tp = NFA(1);
disjoint(tp);
add_edge('-', aN + bN, as);
add_edge('-', aN + bN, aN + bs);
add_edge('-', at, aN + bN + 1);
add_edge('-', aN + bt, aN + bN + 1);
s = aN + bN;
t = aN + bN + 1;
}
void Concat(NFA b) {
int as = s, at = t, aN = N, bs = b.s, bt = b.t, bN = b.N;
disjoint(b);
add_edge('-', at, aN + bs);
s = as;
t = aN + bt;
}
void Star() {
NFA sp = NFA(1);
disjoint(sp);
add_edge('-', N - 1, s);
add_edge('-', t, N - 1);
s = t = N - 1;
}
// parsing
static NFA pattern(string &s, int &i, int e) {
NFA p = simple(s, i, e);
while (i < e && s[i] == '|') {
i++; // '|'
p.Union(simple(s, i, e));
}
return p;
}
static NFA simple(string &s, int &i, int e) {
NFA p = basic(s, i, e);
while (i < e && s[i] != '|') {
p.Concat(basic(s, i, e));
}
return p;
}
static NFA basic(string &s, int &i, int e) {
NFA p = elementary(s, i, e);
if (i < (int)s.size() && s[i] == '*') {
i++; // *
p.Star();
}
return p;
}
static NFA elementary(string &s, int &i, int e) {
NFA p;
if (s[i] == '(') {
i++; // (
int d = 1;
for (int j = i; j < e; j++) {
if (s[j] == '(')
d++;
if (s[j] == ')')
d--;
if (d == 0) {
e = j;
break;
}
}
p = pattern(s, i, e);
i++; // )
} else {
p = NFA(2);
p.add_edge(s[i], p.s, p.t);
i++; // c
}
return p;
}
};
int rc = 0;
class Main {
public:
int h, w;
vector<string> tmp, res;
vector<NFA> NFAs;
vector<vector<int>> stats;
vector<vector<vector<int>>> reachable;
vector<vector<vector<vector<int>>>> trans;
void create_reachable(int nind) {
NFA &nfa = NFAs[nind];
queue<pair<int, int>> que;
que.push({nfa.t, 0});
reachable[nind][nfa.t][0] = true;
while (!que.empty()) {
int t, d;
tie(t, d) = que.front();
que.pop();
// back
for (int eid : nfa.t_cache[t]) {
Edge &e = nfa.es[eid];
if (e.c == '-') {
if (!reachable[nind][e.f][d]) {
reachable[nind][e.f][d] = true;
que.push({e.f, d});
}
} else {
if (d + 1 < reachable[nind][e.f].size() &&
!reachable[nind][e.f][d + 1]) {
reachable[nind][e.f][d + 1] = true;
que.push({e.f, d + 1});
}
}
}
}
}
void create_trans(int nind, int st, char nc) {
NFA &nfa = NFAs[nind];
vector<bool> passed(nfa.N);
passed[st] = true;
// eps trans
{
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : nfa.f_cache[s])
if (nfa.es[eid].c == '-' && !passed[nfa.es[eid].t]) {
passed[nfa.es[eid].t] = true;
que.push(nfa.es[eid].t);
}
}
}
// trans
{
vector<bool> npassed(nfa.N);
range(s, 0, nfa.N) if (passed[s]) for (int eid : nfa.f_cache[s]) {
char c = nfa.es[eid].c;
int t = nfa.es[eid].t;
if (nc == c || c == '.')
npassed[t] = true;
}
passed = npassed;
}
// eps trans
{
queue<int> que;
range(i, 0, passed.size()) if (passed[i]) que.push(i);
while (!que.empty()) {
int s = que.front();
que.pop();
for (int eid : nfa.f_cache[s])
if (nfa.es[eid].c == '-' && !passed[nfa.es[eid].t]) {
passed[nfa.es[eid].t] = true;
que.push(nfa.es[eid].t);
}
}
}
range(s, 0, passed.size()) if (passed[s]) {
bool exeps = false, alleps = true;
for (int eid : nfa.f_cache[s]) {
exeps |= nfa.es[eid].c == '-';
alleps &= nfa.es[eid].c == '-';
}
// ?? ????§???????????????´?????????????????? for ?????????
if (exeps && alleps && nfa.t != s)
continue;
trans[nind][st][nc - 'A'].push_back(s);
}
}
void dfs(int y, int x, int c) {
// cerr << y <<" " << x <<endl;
// cerr << tmp <<endl;
if (rc > 1)
return;
if (y == h) {
rc += c;
res = tmp;
return;
}
// ????????????????????¶??????????????´????????????????????????????????¢?´¢
vector<vector<int>> ynstats(26), xnstats(26);
for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[y])
for (int t : trans[y][s][nc - 'A'])
ynstats[nc - 'A'].push_back(t);
UNIQUE(ynstats[nc - 'A']);
}
for (char nc = 'A'; nc <= 'Z'; nc++) {
for (int s : stats[h + x])
for (int t : trans[h + x][s][nc - 'A'])
xnstats[nc - 'A'].push_back(t);
UNIQUE(xnstats[nc - 'A']);
}
vector<int> gid(26);
iota(ALL(gid), 0);
for (char c1 = 'A'; c1 <= 'Z'; c1++) {
for (char c2 = 'A'; c2 < c1; c2++)
if (gid[c2 - 'A'] == c2 - 'A') {
if (ynstats[c1 - 'A'].size() == ynstats[c2 - 'A'].size() &&
xnstats[c1 - 'A'].size() == xnstats[c2 - 'A'].size()) {
bool eq = true;
range(i, 0, ynstats[c1 - 'A'].size()) eq &=
ynstats[c1 - 'A'][i] == ynstats[c2 - 'A'][i];
range(i, 0, xnstats[c1 - 'A'].size()) eq &=
xnstats[c1 - 'A'][i] == xnstats[c2 - 'A'][i];
if (eq) {
gid[c1 - 'A'] = gid[c2 - 'A'];
break;
}
}
}
}
vector<int> gc(26);
range(i, 0, 26) gc[gid[i]]++;
for (char c = 'A'; c <= 'Z'; c++)
if (gid[c - 'A'] == c - 'A') {
tmp[y][x] = c;
bool tmpOK = true;
// eda ??????????????? de ikerukana ?
{
bool ok = false;
for (int s : ynstats[c - 'A'])
ok |= reachable[y][s][w - 1 - x];
tmpOK &= ok;
}
{
bool ok = false;
for (int s : xnstats[c - 'A'])
ok |= reachable[h + x][s][h - 1 - y];
tmpOK &= ok;
}
if (x == w - 1) {
bool ok = false;
for (int s : ynstats[c - 'A'])
ok |= s == NFAs[y].t;
tmpOK &= ok;
}
if (y == h - 1) {
bool ok = false;
for (int s : xnstats[c - 'A'])
ok |= s == NFAs[h + x].t;
tmpOK &= ok;
}
if (tmpOK) {
vector<int> tmpp = stats[y], tmpq = stats[h + x];
stats[y] = ynstats[c - 'A'];
stats[h + x] = xnstats[c - 'A'];
if (x + 1 < w)
dfs(y, x + 1, gc[c - 'A']);
else
dfs(y + 1, 0, gc[c - 'A']);
stats[y] = tmpp;
stats[h + x] = tmpq;
}
}
}
void run() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0)
break;
rc = 0;
tmp = res = vector<string>(h, string(w, '-'));
vector<string> ss(h + w);
cin >> ss;
// h <= 4, w <= 4
NFAs = vector<NFA>(h + w);
range(i, 0, h + w) {
string s = "";
range(j, 1, ss[i].size() - 1) s += ss[i][j];
int cur = 0, e = s.size();
NFAs[i] = NFA::pattern(s, cur, e);
}
stats = vector<vector<int>>(h + w);
range(i, 0, h + w) stats[i].push_back(NFAs[i].s);
reachable = vector<vector<vector<int>>>(h + w);
range(i, 0, h) {
reachable[i] = vector<vector<int>>(NFAs[i].N);
range(s, 0, NFAs[i].N) reachable[i][s] = vector<int>(h + 1);
}
range(i, 0, w) {
reachable[h + i] = vector<vector<int>>(NFAs[h + i].N);
range(s, 0, NFAs[h + i].N) reachable[h + i][s] = vector<int>(w + 1);
}
range(i, 0, h + w) create_reachable(i);
trans = vector<vector<vector<vector<int>>>>(h + w);
range(i, 0, h + w) {
trans[i] =
vector<vector<vector<int>>>(NFAs[i].N, vector<vector<int>>(26));
range(s, 0, NFAs[i].N) range(c, 'A', 'Z' + 1) create_trans(i, s, c);
}
// cerr << NFAs[0].t <<endl;
// range(i,0,NFAs[0].es.size()){
// cerr << NFAs[0].es[i].c <<" " <<NFAs[0].es[i].f <<" "
// <<NFAs[0].es[i].t <<endl;
// }
// cerr << NFAs[0].t_cache <<endl;
dfs(0, 0, 1);
if (rc > 1) {
cout << "ambiguous" << endl;
} else if (rc == 0) {
cout << "none" << endl;
} else {
range(i, 0, h) cout << res[i] << endl;
}
}
}
};
int main() {
cout << fixed << setprecision(20);
cin.tie(0);
ios::sync_with_stdio(false);
Main().run();
return 0;
} | replace | 26 | 27 | 26 | 30 | TLE | |
p00926 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int dfs(int n, vector<vector<int>> &adj) {
if ((int)adj[n].size() == 0)
return n;
int ret = 0;
for (int i = 0; i < (int)adj[n].size(); i++) {
ret = max(ret, dfs(adj[n][i], adj));
}
return ret;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> rest(n + 1);
for (int i = 0; i < m; i++) {
int c, d;
cin >> c >> d;
rest[c].push_back(d);
}
vector<int> c, d;
for (int i = 1; i <= n; i++) {
int top = dfs(i, rest);
if (top != i) {
c.push_back(i);
d.push_back(top);
}
}
c.push_back(n + 1);
d.push_back(n + 1);
int ans = 0;
int s = c[0], e = d[0];
for (int i = 1; i < (int)c.size(); i++) {
if (c[i] <= e) {
e = max(e, d[i]);
} else {
ans += e - s;
s = c[i];
e = d[i];
}
}
ans = n + 1 + ans * 2;
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int dfs(int n, vector<vector<int>> &adj) {
if ((int)adj[n].size() == 0)
return n;
int ret = 0;
for (int i = 0; i < (int)adj[n].size(); i++) {
ret = max(ret, dfs(adj[n][i], adj));
}
adj[n].clear();
return ret;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<int>> rest(n + 1);
for (int i = 0; i < m; i++) {
int c, d;
cin >> c >> d;
rest[c].push_back(d);
}
vector<int> c, d;
for (int i = 1; i <= n; i++) {
int top = dfs(i, rest);
if (top != i) {
c.push_back(i);
d.push_back(top);
}
}
c.push_back(n + 1);
d.push_back(n + 1);
int ans = 0;
int s = c[0], e = d[0];
for (int i = 1; i < (int)c.size(); i++) {
if (c[i] <= e) {
e = max(e, d[i]);
} else {
ans += e - s;
s = c[i];
e = d[i];
}
}
ans = n + 1 + ans * 2;
cout << ans << endl;
return 0;
} | insert | 12 | 12 | 12 | 13 | TLE | |
p00927 | C++ | Time Limit Exceeded | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <complex>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << (x) << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 100010
int d, n, b;
int p[SIZE], h[SIZE];
double calc(int sp) {
double g = 1.0;
double w = (double)d / sp;
double l = sqrt(sqrt(w * w / 4)), r = 1e10;
while (r - l > 1e-13) {
double vy = (l + r) / 2;
double t = vy / g;
double vx = w / (t * 2);
bool flag = true;
for (int i = 0; i < n; i++) {
double spp = p[i] - floor(p[i] / w) * w;
if (spp > w / 2) {
spp = w - spp;
}
if (spp < 1e-11) {
flag = false;
break;
}
if (h[i] > vy * spp / vx - g * (spp * spp) / (vx * vx) / 2) {
flag = false;
break;
}
}
if (flag) {
r = vy;
} else {
l = vy;
}
}
double vy = l;
double t = vy / g;
double vx = w / (t * 2);
return sqrt(vx * vx + vy * vy);
}
int main() {
scanf("%d%d%d", &d, &n, &b);
for (int i = 0; i < n; i++)
scanf("%d%d", p + i, h + i);
double ans = 1e15;
for (int i = 0; i <= b; i++) {
ans = min(ans, calc(i + 1));
}
printf("%.10lf\n", ans);
return 0;
} | #include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <vector>
#include <complex>
#include <cassert>
#include <functional>
typedef long long ll;
using namespace std;
#define debug(x) cerr << #x << " = " << (x) << endl;
#define mod 1000000007 // 1e9+7(prime number)
#define INF 1000000000 // 1e9
#define LLINF 2000000000000000000LL // 2e18
#define SIZE 100010
int d, n, b;
int p[SIZE], h[SIZE];
double calc(int sp) {
double g = 1.0;
double w = (double)d / sp;
double l = sqrt(sqrt(w * w / 4)), r = 1e10;
while (r - l > 1e-9) {
double vy = (l + r) / 2;
double t = vy / g;
double vx = w / (t * 2);
bool flag = true;
for (int i = 0; i < n; i++) {
double spp = p[i] - floor(p[i] / w) * w;
if (spp > w / 2) {
spp = w - spp;
}
if (spp < 1e-11) {
flag = false;
break;
}
if (h[i] > vy * spp / vx - g * (spp * spp) / (vx * vx) / 2) {
flag = false;
break;
}
}
if (flag) {
r = vy;
} else {
l = vy;
}
}
double vy = l;
double t = vy / g;
double vx = w / (t * 2);
return sqrt(vx * vx + vy * vy);
}
int main() {
scanf("%d%d%d", &d, &n, &b);
for (int i = 0; i < n; i++)
scanf("%d%d", p + i, h + i);
double ans = 1e15;
for (int i = 0; i <= b; i++) {
ans = min(ans, calc(i + 1));
}
printf("%.10lf\n", ans);
return 0;
} | replace | 41 | 42 | 41 | 42 | TLE | |
p00929 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define reps(i, f, n) for (int i = f; i < int(n); i++)
#define rep(i, n) reps(i, 0, n)
class E {
public:
int come, to, val;
bool check;
E(int come, int to, int val) : come(come), to(to), val(val) { check = false; }
};
class Q {
public:
int now, val;
E edge;
Q(int now, int val, E edge)
: now(now), val(val), edge(edge.come, edge.to, edge.val) {}
bool operator<(const Q &a) const { return val > a.val; }
};
const int N = 333333;
const int INF = 1000000000;
int n, m;
vector<E> edge[N];
int visit[N];
vector<E> g[N];
bool contain(E ein) {
rep(i, g[ein.come].size()) {
E e = g[ein.come][i];
if (e.to == ein.to)
return true;
}
return false;
}
bool saiki(int now, int goal, int cost) {
// printf("now %d goal %d cost %d\n",now,goal,cost);
if (now == goal) {
return true;
}
visit[now] = 1;
bool ret = false;
rep(i, g[now].size()) {
E e = g[now][i];
if (visit[e.to] == 1)
continue;
bool res = saiki(e.to, goal, cost);
if (res == true) {
if (e.val == cost)
g[now][i].check = true;
ret = true;
}
}
return ret;
}
void delcheck(E ein) {
// printf("delc %d %d %d\n",ein.come,ein.to,ein.val);
rep(i, N) visit[i] = 0;
saiki(ein.come, ein.to, ein.val);
}
int main() {
cin >> n >> m;
int mcost = INF;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
edge[a].push_back(E(a, b, c));
edge[b].push_back(E(b, a, c));
}
priority_queue<Q> que;
que.push(Q(1, 0, E(-1, -1, -1)));
rep(i, N) visit[i] = 0;
vector<E> use;
while (1) {
if (que.empty())
break;
Q u = que.top();
que.pop();
if (visit[u.now] == 1)
continue;
visit[u.now] = 1;
use.push_back(u.edge);
rep(i, edge[u.now].size()) {
E e = edge[u.now][i];
que.push(Q(e.to, e.val, e));
}
}
/*
rep(i,use.size()){
E e = use[i];
printf("come%d to%d val%d\n",e.come,e.to,e.val);
}*/
rep(i, use.size()) {
if (use[i].to == -1)
continue;
E e = use[i];
g[e.come].push_back(E(e.come, e.to, e.val));
g[e.to].push_back(E(e.to, e.come, e.val));
}
rep(i, N) {
rep(j, edge[i].size()) {
E e = edge[i][j];
if (!contain(e)) {
delcheck(e);
}
}
}
int cont = 0;
int sum = 0;
rep(i, N) {
rep(j, g[i].size()) {
E e = g[i][j];
// printf("!!! %d %d %d %d\n",e.come,e.to,e.val,e.check);
if (e.check == false) {
cont++;
sum += e.val;
}
}
}
printf("%d %d\n", cont / 2, sum / 2);
}
/*
4 4
1 2 3
1 3 3
2 3 3
2 4 3
*/ | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
#define reps(i, f, n) for (int i = f; i < int(n); i++)
#define rep(i, n) reps(i, 0, n)
class E {
public:
int come, to, val;
bool check;
E(int come, int to, int val) : come(come), to(to), val(val) { check = false; }
};
class Q {
public:
int now, val;
E edge;
Q(int now, int val, E edge)
: now(now), val(val), edge(edge.come, edge.to, edge.val) {}
bool operator<(const Q &a) const { return val > a.val; }
};
const int N = 555;
const int INF = 1000000000;
int n, m;
vector<E> edge[N];
int visit[N];
vector<E> g[N];
bool contain(E ein) {
rep(i, g[ein.come].size()) {
E e = g[ein.come][i];
if (e.to == ein.to)
return true;
}
return false;
}
bool saiki(int now, int goal, int cost) {
// printf("now %d goal %d cost %d\n",now,goal,cost);
if (now == goal) {
return true;
}
visit[now] = 1;
bool ret = false;
rep(i, g[now].size()) {
E e = g[now][i];
if (visit[e.to] == 1)
continue;
bool res = saiki(e.to, goal, cost);
if (res == true) {
if (e.val == cost)
g[now][i].check = true;
ret = true;
}
}
return ret;
}
void delcheck(E ein) {
// printf("delc %d %d %d\n",ein.come,ein.to,ein.val);
rep(i, N) visit[i] = 0;
saiki(ein.come, ein.to, ein.val);
}
int main() {
cin >> n >> m;
int mcost = INF;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
edge[a].push_back(E(a, b, c));
edge[b].push_back(E(b, a, c));
}
priority_queue<Q> que;
que.push(Q(1, 0, E(-1, -1, -1)));
rep(i, N) visit[i] = 0;
vector<E> use;
while (1) {
if (que.empty())
break;
Q u = que.top();
que.pop();
if (visit[u.now] == 1)
continue;
visit[u.now] = 1;
use.push_back(u.edge);
rep(i, edge[u.now].size()) {
E e = edge[u.now][i];
que.push(Q(e.to, e.val, e));
}
}
/*
rep(i,use.size()){
E e = use[i];
printf("come%d to%d val%d\n",e.come,e.to,e.val);
}*/
rep(i, use.size()) {
if (use[i].to == -1)
continue;
E e = use[i];
g[e.come].push_back(E(e.come, e.to, e.val));
g[e.to].push_back(E(e.to, e.come, e.val));
}
rep(i, N) {
rep(j, edge[i].size()) {
E e = edge[i][j];
if (!contain(e)) {
delcheck(e);
}
}
}
int cont = 0;
int sum = 0;
rep(i, N) {
rep(j, g[i].size()) {
E e = g[i][j];
// printf("!!! %d %d %d %d\n",e.come,e.to,e.val,e.check);
if (e.check == false) {
cont++;
sum += e.val;
}
}
}
printf("%d %d\n", cont / 2, sum / 2);
}
/*
4 4
1 2 3
1 3 3
2 3 3
2 4 3
*/ | replace | 28 | 29 | 28 | 29 | TLE | |
p00929 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define whole(xs) (xs).begin(), (xs.end())
int N, M;
struct Edge {
int from, to, cost;
Edge(int from, int to, int cost) : from(from), to(to), cost(cost) {}
bool operator==(const Edge &e) const {
return from == e.from && to == e.to && cost == e.cost;
}
};
struct UnionFind {
vector<int> parent;
int N;
UnionFind(int N) : N(N) {
parent.resize(N);
fill(whole(parent), -1);
}
int root(int x) {
if (parent[x] == -1)
return x;
return parent[x] = root(parent[x]);
}
int query(int x, int y) { return root(x) == root(y); }
void merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
parent[y] = x;
}
};
bool EdgeComp(const Edge &a, const Edge &b) { return a.cost < b.cost; }
#define MN 503
int Count, Cost;
bool used[MN][MN];
int L[MN][MN];
bool dfs(vector<vector<Edge>> &G, int u, int v, int cost, vector<int> &prev) {
// cout << "u, v = " << u << " " << v << endl;
// cout << "prev[v]: " << prev[v] << endl;
if (prev[v] == 0) {
int a = v, b = u;
do {
// cout << "a, b: " << a << " " << b << endl;
if (!used[a][b] && !used[b][a] && L[a][b] == cost) {
// cout << "a, b = " << a << " " << b << endl;
used[a][b] = true;
used[b][a] = true;
Count--;
Cost -= L[a][b];
}
a = b;
b = prev[b];
} while (a != v);
return true;
}
prev[v] = u;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (e.to == u)
continue;
if (dfs(G, v, e.to, e.cost, prev))
return true;
}
assert(0);
}
int main() {
cin >> N >> M;
vector<Edge> es;
memset(L, 0, sizeof(L));
for (int i = 0; i < M; i++) {
int s, d, c;
cin >> s >> d >> c;
L[s][d] = c;
L[d][s] = c;
es.push_back(Edge(s, d, c));
}
vector<vector<Edge>> G(N + 1);
Count = 0;
Cost = 0;
UnionFind uf(N + 1);
sort(whole(es), EdgeComp);
memset(used, false, sizeof(used));
for (int i = 0; i < M; i++) {
// cout << "\t" << Count << " " << Cost << endl;
Edge &e = es[i];
if (uf.query(e.from, e.to)) {
G[e.from].push_back(Edge(e.from, e.to, e.cost));
G[e.to].push_back(Edge(e.to, e.from, e.cost));
Cost += e.cost;
Count++;
vector<int> prev(N + 1, -1);
dfs(G, 0, e.from, e.cost, prev);
G[e.from].pop_back();
G[e.to].pop_back();
} else {
uf.merge(e.from, e.to);
G[e.from].push_back(Edge(e.from, e.to, e.cost));
G[e.to].push_back(Edge(e.to, e.from, e.cost));
Cost += e.cost;
Count++;
}
}
cout << Count << " " << Cost << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
#define whole(xs) (xs).begin(), (xs.end())
int N, M;
struct Edge {
int from, to, cost;
Edge(int from, int to, int cost) : from(from), to(to), cost(cost) {}
bool operator==(const Edge &e) const {
return from == e.from && to == e.to && cost == e.cost;
}
};
struct UnionFind {
vector<int> parent;
int N;
UnionFind(int N) : N(N) {
parent.resize(N);
fill(whole(parent), -1);
}
int root(int x) {
if (parent[x] == -1)
return x;
return parent[x] = root(parent[x]);
}
int query(int x, int y) { return root(x) == root(y); }
void merge(int x, int y) {
x = root(x);
y = root(y);
if (x == y)
return;
parent[y] = x;
}
};
bool EdgeComp(const Edge &a, const Edge &b) { return a.cost < b.cost; }
#define MN 503
int Count, Cost;
bool used[MN][MN];
int L[MN][MN];
bool dfs(vector<vector<Edge>> &G, int u, int v, int cost, vector<int> &prev) {
// cout << "u, v = " << u << " " << v << endl;
// cout << "prev[v]: " << prev[v] << endl;
if (prev[v] == 0) {
int a = v, b = u;
do {
// cout << "a, b: " << a << " " << b << endl;
if (!used[a][b] && !used[b][a] && L[a][b] == cost) {
// cout << "a, b = " << a << " " << b << endl;
used[a][b] = true;
used[b][a] = true;
Count--;
Cost -= L[a][b];
}
a = b;
b = prev[b];
} while (a != v);
return true;
}
prev[v] = u;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (e.to == u)
continue;
if (dfs(G, v, e.to, e.cost, prev))
return true;
}
return false;
}
int main() {
cin >> N >> M;
vector<Edge> es;
memset(L, 0, sizeof(L));
for (int i = 0; i < M; i++) {
int s, d, c;
cin >> s >> d >> c;
L[s][d] = c;
L[d][s] = c;
es.push_back(Edge(s, d, c));
}
vector<vector<Edge>> G(N + 1);
Count = 0;
Cost = 0;
UnionFind uf(N + 1);
sort(whole(es), EdgeComp);
memset(used, false, sizeof(used));
for (int i = 0; i < M; i++) {
// cout << "\t" << Count << " " << Cost << endl;
Edge &e = es[i];
if (uf.query(e.from, e.to)) {
G[e.from].push_back(Edge(e.from, e.to, e.cost));
G[e.to].push_back(Edge(e.to, e.from, e.cost));
Cost += e.cost;
Count++;
vector<int> prev(N + 1, -1);
dfs(G, 0, e.from, e.cost, prev);
G[e.from].pop_back();
G[e.to].pop_back();
} else {
uf.merge(e.from, e.to);
G[e.from].push_back(Edge(e.from, e.to, e.cost));
G[e.to].push_back(Edge(e.to, e.from, e.cost));
Cost += e.cost;
Count++;
}
}
cout << Count << " " << Cost << endl;
return 0;
} | replace | 75 | 76 | 75 | 76 | 0 | |
p00929 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
struct UnionFind {
int *data;
UnionFind(int *_data, int size, bool reset = true) : data(_data) {
if (reset)
for (int i = 0; i < size; i++)
data[i] = -1;
}
bool unionSet(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
if (data[y] < data[x])
std::swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
int find(int x) { return data[x] < 0 ? x : data[x] = find(data[x]); }
int size(int x) { return -data[find(x)]; }
};
int main(int argc, char *argv[]) {
// kruskal with x being unused.
// assumption: es is sorted
auto kruskal = [](int n, const vector<pair<int, pair<int, int>>> &es,
int *ufdata, int st, vector<bool> &used) {
UnionFind uf(ufdata, n, false);
int sum = 0;
for (int i = st; i < es.size(); i++) {
const int u = es[i].second.first;
const int v = es[i].second.second;
if (uf.find(u) != uf.find(v)) {
used[i] = true;
uf.unionSet(u, v);
sum += es[i].first;
}
}
return sum;
};
int n, m;
vector<pair<int, pair<int, int>>> es;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int s, d, c;
cin >> s >> d >> c;
es.push_back(make_pair(c, make_pair(s - 1, d - 1)));
}
sort(es.begin(), es.end());
int mn = -1;
int sum = 0;
int cnt = 0;
vector<int> ufdata(n);
vector<bool> used(n, false);
UnionFind uf(&(ufdata[0]), n);
{
vector<int> ufdata2(n);
for (int j = 0; j < n; j++)
ufdata2[j] = ufdata[j];
mn = kruskal(n, es, &(ufdata2[0]), 0, used);
}
int ksum = 0;
for (int i = 0; i < m; i++) {
vector<int> ufdata2(n);
for (int j = 0; j < n; j++)
ufdata2[j] = ufdata[j];
if (used[i]) {
int mni = ksum + kruskal(n, es, &(ufdata2[0]), i + 1, used);
if (mni != mn) {
cnt++;
sum += es[i].first;
}
}
const int u = es[i].second.first;
const int v = es[i].second.second;
if (uf.find(u) != uf.find(v)) {
uf.unionSet(u, v);
ksum += es[i].first;
}
}
cout << cnt << " " << sum << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
using namespace std;
struct UnionFind {
int *data;
UnionFind(int *_data, int size, bool reset = true) : data(_data) {
if (reset)
for (int i = 0; i < size; i++)
data[i] = -1;
}
bool unionSet(int x, int y) {
x = find(x);
y = find(y);
if (x != y) {
if (data[y] < data[x])
std::swap(x, y);
data[x] += data[y];
data[y] = x;
}
return x != y;
}
int find(int x) { return data[x] < 0 ? x : data[x] = find(data[x]); }
int size(int x) { return -data[find(x)]; }
};
int main(int argc, char *argv[]) {
// kruskal with x being unused.
// assumption: es is sorted
auto kruskal = [](int n, const vector<pair<int, pair<int, int>>> &es,
int *ufdata, int st, vector<bool> &used) {
UnionFind uf(ufdata, n, false);
int sum = 0;
for (int i = st; i < es.size(); i++) {
const int u = es[i].second.first;
const int v = es[i].second.second;
if (uf.find(u) != uf.find(v)) {
used[i] = true;
uf.unionSet(u, v);
sum += es[i].first;
}
}
return sum;
};
int n, m;
vector<pair<int, pair<int, int>>> es;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int s, d, c;
cin >> s >> d >> c;
es.push_back(make_pair(c, make_pair(s - 1, d - 1)));
}
sort(es.begin(), es.end());
int mn = -1;
int sum = 0;
int cnt = 0;
vector<int> ufdata(n);
vector<bool> used(m, false);
UnionFind uf(&(ufdata[0]), n);
{
vector<int> ufdata2(n);
for (int j = 0; j < n; j++)
ufdata2[j] = ufdata[j];
mn = kruskal(n, es, &(ufdata2[0]), 0, used);
}
int ksum = 0;
for (int i = 0; i < m; i++) {
vector<int> ufdata2(n);
for (int j = 0; j < n; j++)
ufdata2[j] = ufdata[j];
if (used[i]) {
int mni = ksum + kruskal(n, es, &(ufdata2[0]), i + 1, used);
if (mni != mn) {
cnt++;
sum += es[i].first;
}
}
const int u = es[i].second.first;
const int v = es[i].second.second;
if (uf.find(u) != uf.find(v)) {
uf.unionSet(u, v);
ksum += es[i].first;
}
}
cout << cnt << " " << sum << endl;
return 0;
}
| replace | 57 | 58 | 57 | 58 | 0 | |
p00929 | C++ | Time Limit Exceeded | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
// 7:10
//
// #define REP(i,n) for(int i=0;i<(int)n;++i)
// #define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
// #define ALL(c) (c).begin(), (c).end()
//
// typedef int Weight;
// struct Edge {
// int src, dst;
// Weight weight;
// Edge(int src, int dst, Weight weight) :
// src(src), dst(dst), weight(weight) { }
// };
// bool operator < (const Edge &e, const Edge &f) {
// return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
// e.src != f.src ? e.src < f.src : e.dst < f.dst;
// }
// typedef vector<Edge> Edges;
// typedef vector<Edges> Graph;
//
// typedef vector<Weight> Array;
// typedef vector<Array> Matrix;
//
// #define RESIDUE(s,t) (capacity[s][t]-flow[s][t])
// Weight maximumFlow(const Graph &g, int s, int t) {
// int n = g.size();
// Matrix flow(n, Array(n)), capacity(n, Array(n));
// REP(u, n) for (auto e = g[u].begin(); e !=
// g[u].end();++e)capacity[e->src][e->dst] += e->weight;
//
// Weight total = 0;
// while (1) {
// queue<int> Q; Q.push(s);
// vector<int> prev(n, -1); prev[s] = s;
// while (!Q.empty() && prev[t] < 0) {
// int u = Q.front(); Q.pop();
// for (auto e = g[u].begin(); e != g[u].end(); ++e) if (prev[e->dst]
// < 0 && RESIDUE(u, e->dst) > 0) {
// prev[e->dst] = u;
// Q.push(e->dst);
// }
// }
// if (prev[t] < 0) return total; // prev[x] == -1 <=> t-side
// Weight inc = 999999999;
// for (int j = t; prev[j] != j; j = prev[j])
// inc = min(inc, RESIDUE(prev[j], j));
// for (int j = t; prev[j] != j; j = prev[j])
// flow[prev[j]][j] += inc, flow[j][prev[j]] -= inc;
// total += inc;
// }
// return total;
// }
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
const int mod = 1000000007;
struct Mod {
long long int num;
Mod() : num(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) { ; }
operator long long int() { return num; }
};
Mod operator+(Mod a, Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator-(Mod a, Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator*(Mod a, Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
Mod inv(Mod a) { return a ^ (mod - 2); }
Mod operator/(Mod a, Mod b) { return a * inv(b); }
#define MAX_N 1024000
Mod fact[MAX_N], factinv[MAX_N];
void init() {
fact[0] = Mod(1);
factinv[0] = 1;
REP(i, MAX_N - 1) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }
long long int memo[20]; // nけた
long long int powint(long long int a, int b) {
if (b == 0)
return 1;
if (b == 1)
return a;
else {
long long int ans = 1;
long long int c = powint(a, b / 2);
ans *= c * c;
ans *= (b % 2) ? a : 1;
return ans;
}
}
int backnum[100000][20];
struct Node {
Node(int aid) : children(), ancs() {
id = (aid);
for (int i = 0; i < 20; ++i) {
ancs[i] = -1;
}
}
int id;
vector<int> children;
array<int, 20> ancs;
};
struct Edge {
int from;
int id;
int to;
int cost;
};
struct nEdge {
int from;
int id;
int to;
int time;
nEdge(const Edge e) {
from = e.from;
id = e.id;
to = e.to;
time = e.cost;
}
nEdge(int af, int aid, int ato, int ati) {
from = af;
id = aid;
to = ato;
time = ati;
}
};
class Compare {
public:
bool operator()(const nEdge &l, const nEdge &r) { return l.time > r.time; }
};
vector<vector<Edge>> Edges;
int main() {
int N, M;
cin >> N >> M;
vector<int> time(2 * M);
Edges.resize(N);
for (int i = 0; i < M; ++i) {
int s, d, c;
cin >> s >> d >> c;
s--;
d--;
time[2 * i] = c;
time[2 * i + 1] = c;
;
Edges[s].push_back(Edge{s, 2 * i, d, c});
Edges[d].push_back(Edge{d, 2 * i + 1, s, c});
}
vector<int> ansid;
int baseanstime = 0;
{
priority_queue<nEdge, vector<nEdge>, Compare> qu;
for (int i = 0; i < Edges[0].size(); ++i) {
qu.push(nEdge(Edges[0][i]));
}
vector<bool> selected(2 * M, false);
vector<bool> go(N, false);
go[0] = true;
while (!qu.empty()) {
nEdge ne(qu.top());
qu.pop();
if (go[ne.to]) {
continue;
} else {
go[ne.to] = true;
selected[ne.id] = true;
ansid.emplace_back(ne.id);
baseanstime += ne.time;
}
for (int i = 0; i < Edges[ne.to].size(); ++i) {
qu.emplace(ne.to, Edges[ne.to][i].id, Edges[ne.to][i].to,
Edges[ne.to][i].cost);
}
}
}
int answernum = 0;
int answertime = 0;
{
for (int l = 0; l < ansid.size(); ++l) {
int taiouid = (ansid[l] % 2) ? ansid[l] - 1 : ansid[l] + 1;
assert(ansid.size() == N - 1);
priority_queue<nEdge, vector<nEdge>, Compare> qu;
for (int i = 0; i < Edges[0].size(); ++i) {
qu.push(nEdge(Edges[0][i]));
}
int thisanstime = 0;
vector<bool> go(N, false);
go[0] = true;
int c = 1;
while (!qu.empty()) {
if (c == N)
break;
nEdge ne(qu.top());
qu.pop();
if (go[ne.to] || ne.id == ansid[l] || ne.id == taiouid) {
continue;
} else {
go[ne.to] = true;
thisanstime += ne.time;
c++;
}
for (int j = 0; j < Edges[ne.to].size(); ++j) {
qu.emplace(ne.to, Edges[ne.to][j].id, Edges[ne.to][j].to,
Edges[ne.to][j].cost);
}
}
if (thisanstime == baseanstime) {
bool flag = true;
for (int i = 0; i < go.size(); ++i) {
if (go[i] = false)
flag = false;
}
if (flag) {
answernum++;
}
} else {
answertime += time[ansid[l]];
}
}
}
cout << N - 1 - (answernum) << " " << answertime << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <numeric>
#include <queue>
#include <stack>
#include <stdio.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
// 7:10
//
// #define REP(i,n) for(int i=0;i<(int)n;++i)
// #define FOR(i,c) for(__typeof((c).begin())i=(c).begin();i!=(c).end();++i)
// #define ALL(c) (c).begin(), (c).end()
//
// typedef int Weight;
// struct Edge {
// int src, dst;
// Weight weight;
// Edge(int src, int dst, Weight weight) :
// src(src), dst(dst), weight(weight) { }
// };
// bool operator < (const Edge &e, const Edge &f) {
// return e.weight != f.weight ? e.weight > f.weight : // !!INVERSE!!
// e.src != f.src ? e.src < f.src : e.dst < f.dst;
// }
// typedef vector<Edge> Edges;
// typedef vector<Edges> Graph;
//
// typedef vector<Weight> Array;
// typedef vector<Array> Matrix;
//
// #define RESIDUE(s,t) (capacity[s][t]-flow[s][t])
// Weight maximumFlow(const Graph &g, int s, int t) {
// int n = g.size();
// Matrix flow(n, Array(n)), capacity(n, Array(n));
// REP(u, n) for (auto e = g[u].begin(); e !=
// g[u].end();++e)capacity[e->src][e->dst] += e->weight;
//
// Weight total = 0;
// while (1) {
// queue<int> Q; Q.push(s);
// vector<int> prev(n, -1); prev[s] = s;
// while (!Q.empty() && prev[t] < 0) {
// int u = Q.front(); Q.pop();
// for (auto e = g[u].begin(); e != g[u].end(); ++e) if (prev[e->dst]
// < 0 && RESIDUE(u, e->dst) > 0) {
// prev[e->dst] = u;
// Q.push(e->dst);
// }
// }
// if (prev[t] < 0) return total; // prev[x] == -1 <=> t-side
// Weight inc = 999999999;
// for (int j = t; prev[j] != j; j = prev[j])
// inc = min(inc, RESIDUE(prev[j], j));
// for (int j = t; prev[j] != j; j = prev[j])
// flow[prev[j]][j] += inc, flow[j][prev[j]] -= inc;
// total += inc;
// }
// return total;
// }
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(x) (x).begin(), (x).end()
const int mod = 1000000007;
struct Mod {
long long int num;
Mod() : num(0) { ; }
Mod(long long int n) : num((n % mod + mod) % mod) { ; }
operator long long int() { return num; }
};
Mod operator+(Mod a, Mod b) { return Mod((a.num + b.num) % mod); }
Mod operator-(Mod a, Mod b) { return Mod((mod + a.num - b.num) % mod); }
Mod operator*(Mod a, Mod b) { return Mod(((long long)a.num * b.num) % mod); }
Mod operator+=(Mod &a, Mod b) { return a = a + b; }
Mod operator-=(Mod &a, Mod b) { return a = a - b; }
Mod operator*=(Mod &a, Mod b) { return a = a * b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
Mod inv(Mod a) { return a ^ (mod - 2); }
Mod operator/(Mod a, Mod b) { return a * inv(b); }
#define MAX_N 1024000
Mod fact[MAX_N], factinv[MAX_N];
void init() {
fact[0] = Mod(1);
factinv[0] = 1;
REP(i, MAX_N - 1) {
fact[i + 1] = fact[i] * Mod(i + 1);
factinv[i + 1] = factinv[i] / Mod(i + 1);
}
}
Mod comb(int a, int b) { return fact[a] * factinv[b] * factinv[a - b]; }
long long int memo[20]; // nけた
long long int powint(long long int a, int b) {
if (b == 0)
return 1;
if (b == 1)
return a;
else {
long long int ans = 1;
long long int c = powint(a, b / 2);
ans *= c * c;
ans *= (b % 2) ? a : 1;
return ans;
}
}
int backnum[100000][20];
struct Node {
Node(int aid) : children(), ancs() {
id = (aid);
for (int i = 0; i < 20; ++i) {
ancs[i] = -1;
}
}
int id;
vector<int> children;
array<int, 20> ancs;
};
struct Edge {
int from;
int id;
int to;
int cost;
};
struct nEdge {
int from;
int id;
int to;
int time;
nEdge(const Edge e) {
from = e.from;
id = e.id;
to = e.to;
time = e.cost;
}
nEdge(int af, int aid, int ato, int ati) {
from = af;
id = aid;
to = ato;
time = ati;
}
};
class Compare {
public:
bool operator()(const nEdge &l, const nEdge &r) { return l.time > r.time; }
};
vector<vector<Edge>> Edges;
int main() {
int N, M;
cin >> N >> M;
vector<int> time(2 * M);
Edges.resize(N);
for (int i = 0; i < M; ++i) {
int s, d, c;
cin >> s >> d >> c;
s--;
d--;
time[2 * i] = c;
time[2 * i + 1] = c;
;
Edges[s].push_back(Edge{s, 2 * i, d, c});
Edges[d].push_back(Edge{d, 2 * i + 1, s, c});
}
vector<int> ansid;
int baseanstime = 0;
{
priority_queue<nEdge, vector<nEdge>, Compare> qu;
for (int i = 0; i < Edges[0].size(); ++i) {
qu.push(nEdge(Edges[0][i]));
}
vector<bool> selected(2 * M, false);
vector<bool> go(N, false);
go[0] = true;
while (!qu.empty()) {
nEdge ne(qu.top());
qu.pop();
if (go[ne.to]) {
continue;
} else {
go[ne.to] = true;
selected[ne.id] = true;
ansid.emplace_back(ne.id);
baseanstime += ne.time;
}
for (int i = 0; i < Edges[ne.to].size(); ++i) {
qu.emplace(ne.to, Edges[ne.to][i].id, Edges[ne.to][i].to,
Edges[ne.to][i].cost);
}
}
}
int answernum = 0;
int answertime = 0;
{
for (int l = 0; l < ansid.size(); ++l) {
int taiouid = (ansid[l] % 2) ? ansid[l] - 1 : ansid[l] + 1;
assert(ansid.size() == N - 1);
priority_queue<nEdge, vector<nEdge>, Compare> qu;
for (int i = 0; i < Edges[0].size(); ++i) {
qu.push(nEdge(Edges[0][i]));
}
int thisanstime = 0;
vector<bool> go(N, false);
go[0] = true;
int c = 1;
while (!qu.empty()) {
if (c == N)
break;
nEdge ne(qu.top());
qu.pop();
if (go[ne.to] || ne.id == ansid[l] || ne.id == taiouid) {
continue;
} else {
go[ne.to] = true;
thisanstime += ne.time;
c++;
}
for (int j = 0; j < Edges[ne.to].size(); ++j) {
if (go[Edges[ne.to][j].to] || Edges[ne.to][j].id == ansid[l] ||
Edges[ne.to][j].id == taiouid) {
} else {
qu.emplace(ne.to, Edges[ne.to][j].id, Edges[ne.to][j].to,
Edges[ne.to][j].cost);
}
}
}
if (thisanstime == baseanstime) {
bool flag = true;
for (int i = 0; i < go.size(); ++i) {
if (go[i] = false)
flag = false;
}
if (flag) {
answernum++;
}
} else {
answertime += time[ansid[l]];
}
}
}
cout << N - 1 - (answernum) << " " << answertime << endl;
return 0;
} | replace | 248 | 250 | 248 | 255 | TLE | |
p00929 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct edge {
int from, to, cost;
bool operator<(const edge &p) const { return cost < p.cost; }
};
int pa[1000], ra[1000];
void init() {
for (int i = 0; i < 1000; i++) {
pa[i] = i;
ra[i] = 0;
}
}
int find(int x) {
if (x == pa[x])
return x;
else
return pa[x] = find(pa[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (ra[x] < ra[y])
swap(x, y);
pa[y] = x;
if (ra[x] == ra[y])
ra[x]++;
}
int N, M;
int a, b, c;
int flg[1000];
vector<edge> t;
int solve(int id) {
int sum = 0;
for (int i = 0; i < (int)t.size(); i++) {
if (i == id)
continue;
edge e = t[i];
if (same(e.from, e.to))
continue;
unite(e.from, e.to);
sum += e.cost;
if (id == -1)
flg[i] = true;
}
if (id != -1) {
edge e = t[id];
if (same(e.from, e.to))
return sum;
else
return 1e9;
}
return sum;
}
int main() {
cin >> N >> M;
init();
t.clear();
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &a, &b, &c);
t.push_back((edge){a, b, c});
}
sort(t.begin(), t.end());
int base = solve(-1);
int ans = 0, ans2 = 0;
for (int i = 0; i < M; i++) {
if (flg[i] == false)
continue;
init();
int b = solve(i);
if (base == b)
continue;
ans++;
ans2 += t[i].cost;
}
cout << ans << ' ' << ans2 << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct edge {
int from, to, cost;
bool operator<(const edge &p) const { return cost < p.cost; }
};
int pa[1000], ra[1000];
void init() {
for (int i = 0; i < 1000; i++) {
pa[i] = i;
ra[i] = 0;
}
}
int find(int x) {
if (x == pa[x])
return x;
else
return pa[x] = find(pa[x]);
}
bool same(int x, int y) { return find(x) == find(y); }
void unite(int x, int y) {
x = find(x), y = find(y);
if (ra[x] < ra[y])
swap(x, y);
pa[y] = x;
if (ra[x] == ra[y])
ra[x]++;
}
int N, M;
int a, b, c;
int flg[100000];
vector<edge> t;
int solve(int id) {
int sum = 0;
for (int i = 0; i < (int)t.size(); i++) {
if (i == id)
continue;
edge e = t[i];
if (same(e.from, e.to))
continue;
unite(e.from, e.to);
sum += e.cost;
if (id == -1)
flg[i] = true;
}
if (id != -1) {
edge e = t[id];
if (same(e.from, e.to))
return sum;
else
return 1e9;
}
return sum;
}
int main() {
cin >> N >> M;
init();
t.clear();
for (int i = 0; i < M; i++) {
scanf("%d %d %d", &a, &b, &c);
t.push_back((edge){a, b, c});
}
sort(t.begin(), t.end());
int base = solve(-1);
int ans = 0, ans2 = 0;
for (int i = 0; i < M; i++) {
if (flg[i] == false)
continue;
init();
int b = solve(i);
if (base == b)
continue;
ans++;
ans2 += t[i].cost;
}
cout << ans << ' ' << ans2 << endl;
return 0;
} | replace | 36 | 37 | 36 | 37 | 0 | |
p00929 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
class DisjointSet {
private:
vector<int> rank, p;
void link(int x, int y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y])
rank[y]++;
}
}
public:
DisjointSet(int size) {
rank.resize(size, 0);
p.resize(size, 0);
}
void build() {
for (int i = 0; i < rank.size(); i++) {
makeSet(i);
}
}
void makeSet(int x) { p[x] = x, rank[x] = 0; }
void Union(int x, int y) {
if (findSet(x) != findSet(y))
link(findSet(x), findSet(y));
}
int findSet(int x) { return (x != p[x] ? p[x] = findSet(p[x]) : p[x]); }
};
struct edge {
int u, v, cost;
bool operator<(const edge &hoge) const { return cost < hoge.cost; }
};
typedef vector<edge> Edges;
void add_edge(Edges &info, int u, int v, int cost) {
info.push_back((edge){u, v, cost});
}
bool used[5000];
int kruskal(Edges &edges, int V, int donot) {
DisjointSet uf_tree(V);
uf_tree.build();
int ret = 0;
for (int i = 0; i < edges.size(); i++) {
edge &e = edges[i];
if (i != donot && uf_tree.findSet(e.u) != uf_tree.findSet(e.v)) {
uf_tree.Union(e.u, e.v);
ret += e.cost;
if (donot == -1)
used[i] = true;
}
}
return ret;
}
int main() {
int N, M;
cin >> N >> M;
Edges edges;
for (int i = 0; i < M; ++i) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
add_edge(edges, u, v, c);
}
sort(edges.begin(), edges.end());
int get = kruskal(edges, N, -1);
int a = 0, b = 0;
for (int i = 0; i < edges.size(); ++i) {
if (used[i] && kruskal(edges, N, i) != get) {
++a, b += edges[i].cost;
}
}
cout << a << " " << b << endl;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 30;
class DisjointSet {
private:
vector<int> rank, p;
void link(int x, int y) {
if (rank[x] > rank[y]) {
p[y] = x;
} else {
p[x] = y;
if (rank[x] == rank[y])
rank[y]++;
}
}
public:
DisjointSet(int size) {
rank.resize(size, 0);
p.resize(size, 0);
}
void build() {
for (int i = 0; i < rank.size(); i++) {
makeSet(i);
}
}
void makeSet(int x) { p[x] = x, rank[x] = 0; }
void Union(int x, int y) {
if (findSet(x) != findSet(y))
link(findSet(x), findSet(y));
}
int findSet(int x) { return (x != p[x] ? p[x] = findSet(p[x]) : p[x]); }
};
struct edge {
int u, v, cost;
bool operator<(const edge &hoge) const { return cost < hoge.cost; }
};
typedef vector<edge> Edges;
void add_edge(Edges &info, int u, int v, int cost) {
info.push_back((edge){u, v, cost});
}
bool used[50000];
int kruskal(Edges &edges, int V, int donot) {
DisjointSet uf_tree(V);
uf_tree.build();
int ret = 0;
for (int i = 0; i < edges.size(); i++) {
edge &e = edges[i];
if (i != donot && uf_tree.findSet(e.u) != uf_tree.findSet(e.v)) {
uf_tree.Union(e.u, e.v);
ret += e.cost;
if (donot == -1)
used[i] = true;
}
}
return ret;
}
int main() {
int N, M;
cin >> N >> M;
Edges edges;
for (int i = 0; i < M; ++i) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
add_edge(edges, u, v, c);
}
sort(edges.begin(), edges.end());
int get = kruskal(edges, N, -1);
int a = 0, b = 0;
for (int i = 0; i < edges.size(); ++i) {
if (used[i] && kruskal(edges, N, i) != get) {
++a, b += edges[i].cost;
}
}
cout << a << " " << b << endl;
} | replace | 42 | 43 | 42 | 43 | 0 | |
p00929 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
const int maxN = 510, maxM = maxN * maxN;
#define FORU(i, l, r) for (int i = l; i <= r; ++i)
#define FORD(i, r, l) for (int i = r; i >= l; --i)
#define REPU(i, r) for (int i = 0; i < r; ++i)
#define LL long long
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define PINT pair<ll, int>
#define BIT(x, i) ((x >> i) & 1)
#define NUM_SET_BIT __builtin_popcountll
struct edge {
int u, v, w;
} e[maxM];
int n, m, res, ans, parent[maxN], d;
vector<int> a;
bool cmp(edge i, edge j) { return (i.w < j.w); }
int get_root(int u) {
++d;
return (u == parent[u]) ? u : get_root(parent[u]);
}
bool unite(int u, int v) {
d = 0;
u = get_root(u);
int du = d;
d = 0;
v = get_root(v);
int dv = d;
if (u == v)
return false;
if (du > dv)
parent[u] = v;
else
parent[v] = u;
return true;
}
int main() {
cin >> n >> m;
FORU(i, 1, m)
cin >> e[i].u >> e[i].v >> e[i].w;
sort(e + 1, e + m + 1, cmp);
int sum = 0;
FORU(i, 1, n) parent[i] = i;
FORU(i, 1, m) {
if (unite(e[i].u, e[i].v)) {
a.PB(i);
sum += e[i].w;
}
}
REPU(j, a.size()) {
auto ss = 0;
FORU(i, 1, n) parent[i] = i;
FORU(i, 1, m) {
if (i == a[j])
continue;
if (unite(e[i].u, e[i].v))
ss += e[i].w;
}
bool check = true;
FORU(i, 1, n)
if (get_root(i) != get_root(1))
check = false;
if (!check || ss != sum)
++res, ans += e[a[j]].w;
}
cout << res << " " << ans << endl;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
const int maxN = 510, maxM = maxN * maxN;
#define FORU(i, l, r) for (int i = l; i <= r; ++i)
#define FORD(i, r, l) for (int i = r; i >= l; --i)
#define REPU(i, r) for (int i = 0; i < r; ++i)
#define LL long long
#define F first
#define S second
#define MP make_pair
#define PB push_back
#define PINT pair<ll, int>
#define BIT(x, i) ((x >> i) & 1)
#define NUM_SET_BIT __builtin_popcountll
struct edge {
int u, v, w;
} e[maxM];
int n, m, res, ans, parent[maxN], d;
vector<int> a;
bool cmp(edge i, edge j) { return (i.w < j.w); }
int get_root(int u) {
++d;
if (u == parent[u])
return u;
return (parent[u] = get_root(parent[u]));
}
bool unite(int u, int v) {
d = 0;
u = get_root(u);
int du = d;
d = 0;
v = get_root(v);
int dv = d;
if (u == v)
return false;
if (du > dv)
parent[u] = v;
else
parent[v] = u;
return true;
}
int main() {
cin >> n >> m;
FORU(i, 1, m)
cin >> e[i].u >> e[i].v >> e[i].w;
sort(e + 1, e + m + 1, cmp);
int sum = 0;
FORU(i, 1, n) parent[i] = i;
FORU(i, 1, m) {
if (unite(e[i].u, e[i].v)) {
a.PB(i);
sum += e[i].w;
}
}
REPU(j, a.size()) {
auto ss = 0;
FORU(i, 1, n) parent[i] = i;
FORU(i, 1, m) {
if (i == a[j])
continue;
if (unite(e[i].u, e[i].v))
ss += e[i].w;
}
bool check = true;
FORU(i, 1, n)
if (get_root(i) != get_root(1))
check = false;
if (!check || ss != sum)
++res, ans += e[a[j]].w;
}
cout << res << " " << ans << endl;
} | replace | 39 | 40 | 39 | 42 | TLE | |
p00930 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct T;
#define null ((T *)NULL)
typedef int ll;
struct T {
ll v;
ll m;
int c;
T *l, *r;
bool lz;
ll lazy;
T() {}
T(ll v) : v(v), m(v), c(1), l(null), r(null), lz(false), lazy(0) {}
};
int hogeS = 0;
#define SSS 2222222
T hoge[SSS];
inline T *New(int v) {
if (hogeS >= SSS)
exit(-1);
hoge[hogeS] = T(v);
return &hoge[hogeS++];
}
inline int count(T *t) { return t ? t->c : 0; }
inline void push(T *t) {
if (!t)
return;
if (t->lz) {
t->v += t->lazy;
t->m += t->lazy;
t->lz = false;
if (t->r) {
t->r->lz |= true;
t->r->lazy += t->lazy;
}
if (t->l) {
t->l->lz |= true;
t->l->lazy += t->lazy;
}
t->lazy = 0;
}
}
inline ll mini(T *t) {
push(t);
return t ? t->m : LLONG_MAX;
}
inline T *update(T *t) {
if (!t)
return t;
push(t);
t->c = count(t->l) + count(t->r) + 1;
t->m = min(t->v, min(mini(t->l), mini(t->r)));
return t;
}
T *merge(T *a, T *b) {
push(a);
push(b);
if (!a || !b)
return a ? a : b;
if (rand() % (count(a) + count(b)) < count(a)) {
a->r = merge(a->r, b);
return update(a);
} else {
b->l = merge(a, b->l);
return update(b);
}
}
pair<T *, T *> split(T *a, int k) {
push(a);
if (!a)
return make_pair(null, null);
if (k <= count(a->l)) {
pair<T *, T *> s = split(a->l, k);
a->l = s.second;
return make_pair(s.first, update(a));
} else {
pair<T *, T *> s = split(a->r, k - count(a->l) - 1);
a->r = s.first;
return make_pair(update(a), s.second);
}
}
inline T *insert(T *t, int k, int v) {
push(t);
pair<T *, T *> a = split(t, k);
return merge(merge(a.first, New(v)), a.second);
}
inline T *add(T *t, int l, int r, int k) {
push(t);
pair<T *, T *> u = split(t, r);
pair<T *, T *> v = split(u.first, l);
T *w = v.second;
w->lz = true;
w->lazy += k;
return merge(merge(v.first, update(w)), u.second);
}
int n, m;
char s[333333];
void print(T *t) {
if (t == null)
return;
push(t);
print(t->l);
printf("%2lld,%2lld|", t->v, t->m);
print(t->r);
}
int main(void) {
T *root = null;
int n, q;
set<int> toji;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (int i = 0; i < n; i++) {
root = insert(root, i, 0);
}
for (int i = 0; i < n; i++) {
root = add(root, i, n, s[i] == '(' ? 1 : -1);
if (s[i] == ')')
toji.insert(i);
}
int k;
for (int ii = 0; ii < q; ii++) {
scanf("%d", &k);
if (s[k - 1] == '(') {
s[k - 1] = ')';
toji.insert(k - 1);
root = add(root, k - 1, n, -2);
int me = *(toji.begin());
printf("%d\n", me + 1);
s[me] = '(';
toji.erase(me);
root = add(root, me, n, 2);
} else {
toji.erase(k - 1);
s[k - 1] = '(';
root = add(root, k - 1, n, 2);
int l = 0, r = n;
while (l < r) {
int mb = (l + r) / 2;
auto t = split(root, mb);
if (mini(t.second) >= 2) {
r = mb;
} else {
l = mb + 1;
}
root = merge(t.first, t.second);
}
printf("%d\n", l + 1);
s[l] = ')';
toji.insert(l);
root = add(root, l, n, -2);
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct T;
#define null ((T *)NULL)
typedef int ll;
struct T {
ll v;
ll m;
int c;
T *l, *r;
bool lz;
ll lazy;
T() {}
T(ll v) : v(v), m(v), c(1), l(null), r(null), lz(false), lazy(0) {}
};
int hogeS = 0;
#define SSS 2222222
T hoge[SSS];
inline T *New(int v) {
if (hogeS >= SSS)
exit(-1);
hoge[hogeS] = T(v);
return &hoge[hogeS++];
}
inline int count(T *t) { return t ? t->c : 0; }
inline void push(T *t) {
if (!t)
return;
if (t->lz) {
t->v += t->lazy;
t->m += t->lazy;
t->lz = false;
if (t->r) {
t->r->lz |= true;
t->r->lazy += t->lazy;
}
if (t->l) {
t->l->lz |= true;
t->l->lazy += t->lazy;
}
t->lazy = 0;
}
}
inline ll mini(T *t) {
push(t);
return t ? t->m : INT_MAX;
}
inline T *update(T *t) {
if (!t)
return t;
push(t);
t->c = count(t->l) + count(t->r) + 1;
t->m = min(t->v, min(mini(t->l), mini(t->r)));
return t;
}
T *merge(T *a, T *b) {
push(a);
push(b);
if (!a || !b)
return a ? a : b;
if (rand() % (count(a) + count(b)) < count(a)) {
a->r = merge(a->r, b);
return update(a);
} else {
b->l = merge(a, b->l);
return update(b);
}
}
pair<T *, T *> split(T *a, int k) {
push(a);
if (!a)
return make_pair(null, null);
if (k <= count(a->l)) {
pair<T *, T *> s = split(a->l, k);
a->l = s.second;
return make_pair(s.first, update(a));
} else {
pair<T *, T *> s = split(a->r, k - count(a->l) - 1);
a->r = s.first;
return make_pair(update(a), s.second);
}
}
inline T *insert(T *t, int k, int v) {
push(t);
pair<T *, T *> a = split(t, k);
return merge(merge(a.first, New(v)), a.second);
}
inline T *add(T *t, int l, int r, int k) {
push(t);
pair<T *, T *> u = split(t, r);
pair<T *, T *> v = split(u.first, l);
T *w = v.second;
w->lz = true;
w->lazy += k;
return merge(merge(v.first, update(w)), u.second);
}
int n, m;
char s[333333];
void print(T *t) {
if (t == null)
return;
push(t);
print(t->l);
printf("%2lld,%2lld|", t->v, t->m);
print(t->r);
}
int main(void) {
T *root = null;
int n, q;
set<int> toji;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (int i = 0; i < n; i++) {
root = insert(root, i, 0);
}
for (int i = 0; i < n; i++) {
root = add(root, i, n, s[i] == '(' ? 1 : -1);
if (s[i] == ')')
toji.insert(i);
}
int k;
for (int ii = 0; ii < q; ii++) {
scanf("%d", &k);
if (s[k - 1] == '(') {
s[k - 1] = ')';
toji.insert(k - 1);
root = add(root, k - 1, n, -2);
int me = *(toji.begin());
printf("%d\n", me + 1);
s[me] = '(';
toji.erase(me);
root = add(root, me, n, 2);
} else {
toji.erase(k - 1);
s[k - 1] = '(';
root = add(root, k - 1, n, 2);
int l = 0, r = n;
while (l < r) {
int mb = (l + r) / 2;
auto t = split(root, mb);
if (mini(t.second) >= 2) {
r = mb;
} else {
l = mb + 1;
}
root = merge(t.first, t.second);
}
printf("%d\n", l + 1);
s[l] = ')';
toji.insert(l);
root = add(root, l, n, -2);
}
}
return 0;
} | replace | 50 | 51 | 50 | 51 | -11 | |
p00930 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
#define MAX 1000100
#define N 3001000
int n, m, qidx;
char str[N];
int minval[MAX], flag[MAX], prefix[MAX];
map<int, int> ridxs;
inline void push_down(int left, int right, int idx) {
if (left == right) {
minval[idx] += flag[idx];
flag[idx] = 0;
return;
}
minval[idx] += flag[idx];
flag[idx << 1] += flag[idx];
flag[idx << 1 | 1] += flag[idx];
flag[idx] = 0;
}
inline void push_up(int left, int right, int idx) {
if (left == right) {
push_down(left, right, idx);
return;
}
int mid = (left + right) >> 1;
push_down(left, right, idx);
push_down(left, mid, idx << 1);
push_down(mid + 1, right, idx << 1 | 1);
minval[idx] = min(minval[idx << 1], minval[idx << 1 | 1]);
}
inline int query(int start, int end, int left, int right, int idx) {
push_down(left, right, idx);
if (start <= left && right <= end)
return minval[idx];
int mid = (left + right) >> 1, res;
if (end <= mid)
res = query(start, end, left, mid, idx << 1);
else if (mid < start)
res = query(start, end, mid + 1, right, idx << 1 | 1);
else
res = min(query(start, end, left, mid, idx << 1),
query(start, end, mid + 1, right, idx << 1 | 1));
return res;
}
inline void update(int val, int start, int end, int left, int right, int idx) {
push_down(left, right, idx);
if (start <= left && right <= end) {
flag[idx] += val;
push_up(left, right, idx);
return;
}
int mid = (left + right) >> 1;
if (end <= mid)
update(val, start, end, left, mid, idx << 1);
else if (mid < start)
update(val, start, end, mid + 1, right, idx << 1 | 1);
else {
update(val, start, end, left, mid, idx << 1);
update(val, start, end, mid + 1, right, idx << 1 | 1);
}
push_up(left, right, idx);
}
inline void build(int left, int right, int idx) {
if (left == right) {
minval[idx] = prefix[left];
return;
}
int mid = (left + right) >> 1;
build(left, mid, idx << 1);
build(mid + 1, right, idx << 1 | 1);
minval[idx] = min(minval[idx << 1], minval[idx << 1 | 1]);
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
ridxs.clear();
memset(flag, 0, sizeof(flag));
scanf("%s", str + 1);
prefix[0] = 0;
for (int i = 1; i <= n; i++)
prefix[i] = prefix[i - 1] + (str[i] == '(' ? 1 : -1);
for (int i = 1; i <= n; i++)
if (str[i] == ')')
ridxs[i] = 1;
build(1, n, 1);
int ans;
for (int i = 1; i <= m; i++) {
scanf("%d", &qidx);
if (str[qidx] == '(') {
ridxs[qidx] = 1;
ans = ridxs.begin()->first;
ridxs.erase(ridxs.find(ans));
str[qidx] = ')';
str[ans] = '(';
if (ans != qidx)
update(2, ans, qidx - 1, 1, n, 1);
} else {
if (query(qidx - 1, qidx - 1, 1, n, 1) < 2)
ans = qidx;
else {
int lidx = 1, ridx = qidx - 1;
while (ridx - lidx > 1) {
int mid = (lidx + ridx) >> 1;
if (query(mid, ridx, 1, n, 1) < 2)
lidx = mid;
else
ridx = mid;
}
ans = ridx;
update(-2, ans, qidx - 1, 1, n, 1);
ridxs.erase(ridxs.find(qidx));
ridxs[ans] = 1;
str[qidx] = '(';
str[ans] = ')';
}
}
printf("%d\n", ans);
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
#include <map>
using namespace std;
#define MAX 2000100
#define N 600100
int n, m, qidx;
char str[N];
int minval[MAX], flag[MAX], prefix[MAX];
map<int, int> ridxs;
inline void push_down(int left, int right, int idx) {
if (left == right) {
minval[idx] += flag[idx];
flag[idx] = 0;
return;
}
minval[idx] += flag[idx];
flag[idx << 1] += flag[idx];
flag[idx << 1 | 1] += flag[idx];
flag[idx] = 0;
}
inline void push_up(int left, int right, int idx) {
if (left == right) {
push_down(left, right, idx);
return;
}
int mid = (left + right) >> 1;
push_down(left, right, idx);
push_down(left, mid, idx << 1);
push_down(mid + 1, right, idx << 1 | 1);
minval[idx] = min(minval[idx << 1], minval[idx << 1 | 1]);
}
inline int query(int start, int end, int left, int right, int idx) {
push_down(left, right, idx);
if (start <= left && right <= end)
return minval[idx];
int mid = (left + right) >> 1, res;
if (end <= mid)
res = query(start, end, left, mid, idx << 1);
else if (mid < start)
res = query(start, end, mid + 1, right, idx << 1 | 1);
else
res = min(query(start, end, left, mid, idx << 1),
query(start, end, mid + 1, right, idx << 1 | 1));
return res;
}
inline void update(int val, int start, int end, int left, int right, int idx) {
push_down(left, right, idx);
if (start <= left && right <= end) {
flag[idx] += val;
push_up(left, right, idx);
return;
}
int mid = (left + right) >> 1;
if (end <= mid)
update(val, start, end, left, mid, idx << 1);
else if (mid < start)
update(val, start, end, mid + 1, right, idx << 1 | 1);
else {
update(val, start, end, left, mid, idx << 1);
update(val, start, end, mid + 1, right, idx << 1 | 1);
}
push_up(left, right, idx);
}
inline void build(int left, int right, int idx) {
if (left == right) {
minval[idx] = prefix[left];
return;
}
int mid = (left + right) >> 1;
build(left, mid, idx << 1);
build(mid + 1, right, idx << 1 | 1);
minval[idx] = min(minval[idx << 1], minval[idx << 1 | 1]);
}
int main() {
while (scanf("%d%d", &n, &m) == 2) {
ridxs.clear();
memset(flag, 0, sizeof(flag));
scanf("%s", str + 1);
prefix[0] = 0;
for (int i = 1; i <= n; i++)
prefix[i] = prefix[i - 1] + (str[i] == '(' ? 1 : -1);
for (int i = 1; i <= n; i++)
if (str[i] == ')')
ridxs[i] = 1;
build(1, n, 1);
int ans;
for (int i = 1; i <= m; i++) {
scanf("%d", &qidx);
if (str[qidx] == '(') {
ridxs[qidx] = 1;
ans = ridxs.begin()->first;
ridxs.erase(ridxs.find(ans));
str[qidx] = ')';
str[ans] = '(';
if (ans != qidx)
update(2, ans, qidx - 1, 1, n, 1);
} else {
if (query(qidx - 1, qidx - 1, 1, n, 1) < 2)
ans = qidx;
else {
int lidx = 1, ridx = qidx - 1;
while (ridx - lidx > 1) {
int mid = (lidx + ridx) >> 1;
if (query(mid, ridx, 1, n, 1) < 2)
lidx = mid;
else
ridx = mid;
}
ans = ridx;
update(-2, ans, qidx - 1, 1, n, 1);
ridxs.erase(ridxs.find(qidx));
ridxs[ans] = 1;
str[qidx] = '(';
str[ans] = ')';
}
}
printf("%d\n", ans);
}
}
return 0;
} | replace | 5 | 7 | 5 | 7 | 0 | |
p00930 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pi;
struct SegmentTree {
const int INF = 1 << 30;
vector<int> small, add;
int sz;
SegmentTree(int n) {
sz = 1;
while (sz < n)
sz <<= 1;
small.assign(2 * sz - 1, 0);
add.assign(2 * sz - 1, 0);
}
inline void Merge(int k) {
small[k] = min(small[2 * k + 1] + add[2 * k + 1],
small[2 * k + 2] + add[2 * k + 2]);
}
inline int RangeMinimumQuery(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return (INF);
if (a <= l && r <= b)
return (small[k] + add[k]);
int L = RangeMinimumQuery(a, b, 2 * k + 1, l, (l + r) >> 1);
int R = RangeMinimumQuery(a, b, 2 * k + 2, (l + r) >> 1, r);
return (min(L, R) + add[k]);
}
int RangeMinimumQuery(int a, int b) {
return (RangeMinimumQuery(a, b, 0, 0, sz));
}
inline void RangeAdd(int a, int b, int x, int k, int l, int r) {
if (a >= r || b <= l)
return;
if (a <= l && r <= b) {
add[k] += x;
return;
}
RangeAdd(a, b, x, 2 * k + 1, l, (l + r) >> 1);
RangeAdd(a, b, x, 2 * k + 2, (l + r) >> 1, r);
Merge(k);
}
void RangeAdd(int a, int b, int x) { return (RangeAdd(a, b, x, 0, 0, sz)); }
};
int main() {
int N, Q;
scanf("%d %d", &N, &Q);
char S[100001];
scanf(" %s", S);
SegmentTree tree(N);
set<int> close;
for (int i = 0; i < N; i++) {
tree.RangeAdd(i, N, S[i] == '(' ? +1 : -1);
if (S[i] == ')')
close.insert(i);
}
while (Q--) {
int q;
scanf("%d", &q);
--q;
tree.RangeAdd(q, N, S[q] == ')' ? +2 : -2);
if (S[q] == '(') {
close.insert(q);
S[q] = ')';
printf("%d\n", *close.begin() + 1);
tree.RangeAdd(*close.begin(), N, +2);
S[*close.begin()] = '(';
close.erase(close.begin());
} else {
close.erase(q);
S[q] = '(';
int low = -1, high = N - 1;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (tree.RangeMinimumQuery(mid, N) >= 2)
high = mid;
else
low = mid;
}
while (S[q] == ')')
++high;
printf("%d\n", high + 1);
tree.RangeAdd(high, N, -2);
S[high] = ')';
close.insert(high);
}
}
} | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> Pi;
struct SegmentTree {
const int INF = 1 << 30;
vector<int> small, add;
int sz;
SegmentTree(int n) {
sz = 1;
while (sz < n)
sz <<= 1;
small.assign(2 * sz - 1, 0);
add.assign(2 * sz - 1, 0);
}
inline void Merge(int k) {
small[k] = min(small[2 * k + 1] + add[2 * k + 1],
small[2 * k + 2] + add[2 * k + 2]);
}
inline int RangeMinimumQuery(int a, int b, int k, int l, int r) {
if (a >= r || b <= l)
return (INF);
if (a <= l && r <= b)
return (small[k] + add[k]);
int L = RangeMinimumQuery(a, b, 2 * k + 1, l, (l + r) >> 1);
int R = RangeMinimumQuery(a, b, 2 * k + 2, (l + r) >> 1, r);
return (min(L, R) + add[k]);
}
int RangeMinimumQuery(int a, int b) {
return (RangeMinimumQuery(a, b, 0, 0, sz));
}
inline void RangeAdd(int a, int b, int x, int k, int l, int r) {
if (a >= r || b <= l)
return;
if (a <= l && r <= b) {
add[k] += x;
return;
}
RangeAdd(a, b, x, 2 * k + 1, l, (l + r) >> 1);
RangeAdd(a, b, x, 2 * k + 2, (l + r) >> 1, r);
Merge(k);
}
void RangeAdd(int a, int b, int x) { return (RangeAdd(a, b, x, 0, 0, sz)); }
};
int main() {
int N, Q;
scanf("%d %d", &N, &Q);
char S[300001];
scanf(" %s", S);
SegmentTree tree(N);
set<int> close;
for (int i = 0; i < N; i++) {
tree.RangeAdd(i, N, S[i] == '(' ? +1 : -1);
if (S[i] == ')')
close.insert(i);
}
while (Q--) {
int q;
scanf("%d", &q);
--q;
tree.RangeAdd(q, N, S[q] == ')' ? +2 : -2);
if (S[q] == '(') {
close.insert(q);
S[q] = ')';
printf("%d\n", *close.begin() + 1);
tree.RangeAdd(*close.begin(), N, +2);
S[*close.begin()] = '(';
close.erase(close.begin());
} else {
close.erase(q);
S[q] = '(';
int low = -1, high = N - 1;
while (high - low > 1) {
int mid = (low + high) >> 1;
if (tree.RangeMinimumQuery(mid, N) >= 2)
high = mid;
else
low = mid;
}
while (S[q] == ')')
++high;
printf("%d\n", high + 1);
tree.RangeAdd(high, N, -2);
S[high] = ')';
close.insert(high);
}
}
} | replace | 50 | 51 | 50 | 51 | 0 | |
p00930 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 1 << 17;
const ll INF = 1LL << 50;
struct MinSegTree2 {
static const ll def = INF;
int n;
ll segMin[2 * MAX_N - 1], segAdd[2 * MAX_N - 1];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++)
segMin[i] = def, segAdd[i] = 0;
}
void add(int a, int b, ll x) { add(a, b, x, 0, 0, n); }
void add(int a, int b, ll x, int k, int l, int r) {
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
segAdd[k] += x;
return;
}
add(a, b, x, k * 2 + 1, l, (l + r) / 2);
add(a, b, x, k * 2 + 2, (l + r) / 2, r);
segMin[k] = min(segMin[k * 2 + 1] + segAdd[k * 2 + 1],
segMin[k * 2 + 2] + segAdd[k * 2 + 2]);
}
void set(int i, ll x) {
ll y = query(i, i + 1);
add(i, i + 1, -y + x);
}
ll query(int a, int b) { return query(a, b, 0, 0, n); }
ll query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return segMin[k] + segAdd[k];
ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr) + segAdd[k];
}
};
MinSegTree2 minst;
int N;
string s;
set<int> O, C;
void flip(int i) {
if (s[i] == '(') {
s[i] = ')';
O.erase(i);
C.insert(i);
minst.add(i, N, -2);
} else {
s[i] = '(';
C.erase(i);
O.insert(i);
minst.add(i, N, +2);
}
}
void debug() {
cout << s << endl;
for (int i = 0; i < N; i++) {
cout << minst.query(i, i + 1) << " ";
}
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
int Q;
cin >> N >> Q >> s;
minst.init(N);
int cnt = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '(') {
O.insert(i);
cnt++;
minst.set(i, cnt);
} else {
C.insert(i);
cnt--;
minst.set(i, cnt);
}
}
// debug();
while (Q--) {
int k;
cin >> k;
k--;
char c = s[k];
flip(k);
// debug();
int ans = k;
if (c == '(') {
// CLOSE -> OPEN
// ????????????CLOSE
ans = *C.begin();
} else {
// OPEN -> CLOSE
// [i, n) >= 2 ????????????????°????i
int ng = 0, ok = k;
while (abs(ng - ok) > 1) {
int mid = (ng + ok) / 2;
auto it = O.lower_bound(mid);
if (it == O.end()) {
ng = mid;
continue;
}
int a = *it;
if (minst.query(a, N) >= 2)
ok = mid;
else
ng = mid;
}
ans = *O.lower_bound(ok);
}
cout << ans + 1 << endl;
flip(ans);
// debug();
}
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int MAX_N = 1 << 19;
const ll INF = 1LL << 50;
struct MinSegTree2 {
static const ll def = INF;
int n;
ll segMin[2 * MAX_N - 1], segAdd[2 * MAX_N - 1];
void init(int n_) {
n = 1;
while (n < n_)
n *= 2;
for (int i = 0; i < 2 * n - 1; i++)
segMin[i] = def, segAdd[i] = 0;
}
void add(int a, int b, ll x) { add(a, b, x, 0, 0, n); }
void add(int a, int b, ll x, int k, int l, int r) {
if (r <= a || b <= l)
return;
if (a <= l && r <= b) {
segAdd[k] += x;
return;
}
add(a, b, x, k * 2 + 1, l, (l + r) / 2);
add(a, b, x, k * 2 + 2, (l + r) / 2, r);
segMin[k] = min(segMin[k * 2 + 1] + segAdd[k * 2 + 1],
segMin[k * 2 + 2] + segAdd[k * 2 + 2]);
}
void set(int i, ll x) {
ll y = query(i, i + 1);
add(i, i + 1, -y + x);
}
ll query(int a, int b) { return query(a, b, 0, 0, n); }
ll query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return def;
if (a <= l && r <= b)
return segMin[k] + segAdd[k];
ll vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
ll vr = query(a, b, k * 2 + 2, (l + r) / 2, r);
return min(vl, vr) + segAdd[k];
}
};
MinSegTree2 minst;
int N;
string s;
set<int> O, C;
void flip(int i) {
if (s[i] == '(') {
s[i] = ')';
O.erase(i);
C.insert(i);
minst.add(i, N, -2);
} else {
s[i] = '(';
C.erase(i);
O.insert(i);
minst.add(i, N, +2);
}
}
void debug() {
cout << s << endl;
for (int i = 0; i < N; i++) {
cout << minst.query(i, i + 1) << " ";
}
cout << endl;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
int Q;
cin >> N >> Q >> s;
minst.init(N);
int cnt = 0;
for (int i = 0; i < N; i++) {
if (s[i] == '(') {
O.insert(i);
cnt++;
minst.set(i, cnt);
} else {
C.insert(i);
cnt--;
minst.set(i, cnt);
}
}
// debug();
while (Q--) {
int k;
cin >> k;
k--;
char c = s[k];
flip(k);
// debug();
int ans = k;
if (c == '(') {
// CLOSE -> OPEN
// ????????????CLOSE
ans = *C.begin();
} else {
// OPEN -> CLOSE
// [i, n) >= 2 ????????????????°????i
int ng = 0, ok = k;
while (abs(ng - ok) > 1) {
int mid = (ng + ok) / 2;
auto it = O.lower_bound(mid);
if (it == O.end()) {
ng = mid;
continue;
}
int a = *it;
if (minst.query(a, N) >= 2)
ok = mid;
else
ng = mid;
}
ans = *O.lower_bound(ok);
}
cout << ans + 1 << endl;
flip(ans);
// debug();
}
} | replace | 4 | 5 | 4 | 5 | 0 | |
p00930 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <set>
#define MAXN 300010
using namespace std;
struct SegTree {
int left, right, mid, val, add;
SegTree() {}
} tree[MAXN << 1];
char str[MAXN];
int n, q, prefix[MAXN];
inline int LC(int x) { return x << 1; }
inline int RC(int x) { return x << 1 | 1; }
inline void push_down(int rt) {
if (tree[rt].add == 0)
return;
tree[rt].val += tree[rt].add;
if (tree[rt].left != tree[rt].right) {
tree[LC(rt)].add += tree[rt].add;
tree[RC(rt)].add += tree[rt].add;
}
tree[rt].add = 0;
}
inline void push_up(int rt) {
tree[rt].val = min((tree[LC(rt)].val + tree[LC(rt)].add),
(tree[RC(rt)].val + tree[RC(rt)].add)) +
tree[rt].add;
}
void makeTree(int L, int R, int rt) {
tree[rt].left = L;
tree[rt].right = R;
tree[rt].mid = (L + R) >> 1;
tree[rt].add = 0;
if (L == R) {
tree[rt].val = prefix[L + 1];
return;
}
int mid = tree[rt].mid;
makeTree(L, mid, LC(rt));
makeTree(mid + 1, R, RC(rt));
push_up(rt);
}
void update(int L, int R, int rt, int x) {
push_down(rt);
if (L <= tree[rt].left && tree[rt].right <= R) {
tree[rt].add += x;
return;
}
int mid = tree[rt].mid;
if (R <= mid)
update(L, R, LC(rt), x);
else if (L > mid)
update(L, R, RC(rt), x);
else {
update(L, R, LC(rt), x);
update(L, R, RC(rt), x);
}
push_up(rt);
}
int query(int L, int R, int rt) {
push_down(rt);
if (L <= tree[rt].left && tree[rt].right <= R)
return tree[rt].val;
int mid = tree[rt].mid, tmp;
if (R <= mid)
tmp = query(L, R, LC(rt));
else if (L > mid)
tmp = query(L, R, RC(rt));
else
tmp = min(query(L, R, LC(rt)), query(L, R, RC(rt)));
return tmp;
}
void fix(set<int> &prev, set<int> &next, char before, int x) {
prev.erase(x);
next.insert(x);
int p, b = (before == '(' ? -1 : 1);
str[x] = (before == '(' ? ')' : '(');
update(x, n - 1, 1, 2 * b);
int l = 0, r = x;
while (l < r) {
int mid = (l + r) >> 1;
p = *next.lower_bound(mid);
if (query(p, n - 1, 1) >= 2 * b)
r = mid;
else
l = mid + 1;
}
p = *next.lower_bound(l);
update(p, n - 1, 1, -2 * b);
next.erase(p);
prev.insert(p);
str[p] = before;
printf("%d\n", p + 1);
}
int main(void) {
while (scanf("%d%d", &n, &q) == 2) {
scanf("%s", str);
int x;
set<int> left, right;
prefix[0] = 0;
for (int i = 0; i < n; ++i)
if (str[i] == '(') {
prefix[i + 1] = prefix[i] + 1;
left.insert(i);
} else {
prefix[i + 1] = prefix[i] - 1;
right.insert(i);
}
makeTree(0, n - 1, 1);
for (int i = 0; i < q; ++i) {
scanf("%d", &x);
x--;
if (str[x] == '(')
fix(left, right, str[x], x);
else if (str[x] == ')')
fix(right, left, str[x], x);
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <set>
#define MAXN 600010
using namespace std;
struct SegTree {
int left, right, mid, val, add;
SegTree() {}
} tree[MAXN << 1];
char str[MAXN];
int n, q, prefix[MAXN];
inline int LC(int x) { return x << 1; }
inline int RC(int x) { return x << 1 | 1; }
inline void push_down(int rt) {
if (tree[rt].add == 0)
return;
tree[rt].val += tree[rt].add;
if (tree[rt].left != tree[rt].right) {
tree[LC(rt)].add += tree[rt].add;
tree[RC(rt)].add += tree[rt].add;
}
tree[rt].add = 0;
}
inline void push_up(int rt) {
tree[rt].val = min((tree[LC(rt)].val + tree[LC(rt)].add),
(tree[RC(rt)].val + tree[RC(rt)].add)) +
tree[rt].add;
}
void makeTree(int L, int R, int rt) {
tree[rt].left = L;
tree[rt].right = R;
tree[rt].mid = (L + R) >> 1;
tree[rt].add = 0;
if (L == R) {
tree[rt].val = prefix[L + 1];
return;
}
int mid = tree[rt].mid;
makeTree(L, mid, LC(rt));
makeTree(mid + 1, R, RC(rt));
push_up(rt);
}
void update(int L, int R, int rt, int x) {
push_down(rt);
if (L <= tree[rt].left && tree[rt].right <= R) {
tree[rt].add += x;
return;
}
int mid = tree[rt].mid;
if (R <= mid)
update(L, R, LC(rt), x);
else if (L > mid)
update(L, R, RC(rt), x);
else {
update(L, R, LC(rt), x);
update(L, R, RC(rt), x);
}
push_up(rt);
}
int query(int L, int R, int rt) {
push_down(rt);
if (L <= tree[rt].left && tree[rt].right <= R)
return tree[rt].val;
int mid = tree[rt].mid, tmp;
if (R <= mid)
tmp = query(L, R, LC(rt));
else if (L > mid)
tmp = query(L, R, RC(rt));
else
tmp = min(query(L, R, LC(rt)), query(L, R, RC(rt)));
return tmp;
}
void fix(set<int> &prev, set<int> &next, char before, int x) {
prev.erase(x);
next.insert(x);
int p, b = (before == '(' ? -1 : 1);
str[x] = (before == '(' ? ')' : '(');
update(x, n - 1, 1, 2 * b);
int l = 0, r = x;
while (l < r) {
int mid = (l + r) >> 1;
p = *next.lower_bound(mid);
if (query(p, n - 1, 1) >= 2 * b)
r = mid;
else
l = mid + 1;
}
p = *next.lower_bound(l);
update(p, n - 1, 1, -2 * b);
next.erase(p);
prev.insert(p);
str[p] = before;
printf("%d\n", p + 1);
}
int main(void) {
while (scanf("%d%d", &n, &q) == 2) {
scanf("%s", str);
int x;
set<int> left, right;
prefix[0] = 0;
for (int i = 0; i < n; ++i)
if (str[i] == '(') {
prefix[i + 1] = prefix[i] + 1;
left.insert(i);
} else {
prefix[i + 1] = prefix[i] - 1;
right.insert(i);
}
makeTree(0, n - 1, 1);
for (int i = 0; i < q; ++i) {
scanf("%d", &x);
x--;
if (str[x] == '(')
fix(left, right, str[x], x);
else if (str[x] == ')')
fix(right, left, str[x], x);
}
}
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p00930 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
struct T;
#define null ((T *)NULL)
typedef long long ll;
struct T {
ll v;
ll s;
ll m;
int c;
T *l, *r;
bool lz;
ll lazy;
T() {}
T(ll v) : v(v), s(v), m(v), c(1), l(null), r(null), lz(false), lazy(0) {}
};
int hogeS = 0;
#define SSS 2222222
T hoge[SSS];
inline T *New(int v) {
if (hogeS >= SSS)
exit(-1);
hoge[hogeS] = T(v);
return &hoge[hogeS++];
}
inline int count(T *t) { return t ? t->c : 0; }
inline void push(T *t) {
if (!t)
return;
if (t->lz) {
t->v += t->lazy;
t->m += t->lazy;
t->s += t->lazy * count(t);
t->lz = false;
if (t->r) {
t->r->lz |= true;
t->r->lazy += t->lazy;
}
if (t->l) {
t->l->lz |= true;
t->l->lazy += t->lazy;
}
t->lazy = 0;
}
}
inline ll sum(T *t) {
push(t);
return t ? t->s : 0;
}
inline ll mini(T *t) {
push(t);
return t ? t->m : LLONG_MAX;
}
inline T *update(T *t) {
if (!t)
return t;
push(t);
t->c = count(t->l) + count(t->r) + 1;
t->s = t->v + sum(t->l) + sum(t->r);
t->m = min(t->v, min(mini(t->l), mini(t->r)));
return t;
}
T *merge(T *a, T *b) {
push(a);
push(b);
if (!a || !b)
return a ? a : b;
if (rand() % (count(a) + count(b)) < count(a)) {
a->r = merge(a->r, b);
return update(a);
} else {
b->l = merge(a, b->l);
return update(b);
}
}
pair<T *, T *> split(T *a, int k) {
push(a);
if (!a)
return make_pair(null, null);
if (k <= count(a->l)) {
pair<T *, T *> s = split(a->l, k);
a->l = s.second;
return make_pair(s.first, update(a));
} else {
pair<T *, T *> s = split(a->r, k - count(a->l) - 1);
a->r = s.first;
return make_pair(update(a), s.second);
}
}
inline T *erase(T *t, int k) {
push(t);
pair<T *, T *> v = split(t, k);
k -= (k - 1);
pair<T *, T *> u = split(v.second, k);
return merge(v.first, u.second);
}
inline T *insert(T *t, int k, int v) {
push(t);
pair<T *, T *> a = split(t, k);
return merge(merge(a.first, New(v)), a.second);
}
inline T *add(T *t, int l, int r, int k) {
push(t);
pair<T *, T *> u = split(t, r);
pair<T *, T *> v = split(u.first, l);
T *w = v.second;
w->lz = true;
w->lazy += k;
return merge(merge(v.first, update(w)), u.second);
}
inline T *add(T *t, int k) {
push(t);
t->lz |= true;
t->lazy += k;
return update(t);
}
int n, m;
char s[33333];
inline T *flip(T *t, int k) {
push(t);
pair<T *, T *> a = split(t, k);
pair<T *, T *> b = split(a.second, 1);
// b.first->v = -b.first->v;
// b.first = add(b.first,k,n);
return merge(a.first, merge(b.first, b.second));
}
void print(T *t) {
if (t == null)
return;
push(t);
print(t->l);
printf("%2lld,%2lld|", t->v, t->m);
print(t->r);
}
inline int gsum(T *t) {
/*
if( !t->r ) return t->v;
return gsum(t->r);
*/
return 0;
}
int main(void) {
T *root = null;
int n, q, m;
set<int> toji;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (int i = 0; i < n; i++) {
root = insert(root, i, 0);
}
for (int i = 0; i < n; i++) {
root = add(root, i, n, s[i] == '(' ? 1 : -1);
if (s[i] == ')')
toji.insert(i);
}
// print(root); puts("");
int k;
for (int ii = 0; ii < q; ii++) {
scanf("%d", &k);
// printf("%d %d\n",mini(t),gsum(t));
// print(t); puts("");
if (s[k - 1] == '(') {
s[k - 1] = ')';
toji.insert(k - 1);
root = add(root, k - 1, n, -2);
int me = *(toji.begin());
printf("%d\n", me + 1);
s[me] = '(';
toji.erase(me);
root = add(root, me, n, 2);
} else {
toji.erase(k - 1);
s[k - 1] = '(';
root = add(root, k - 1, n, 2);
int l = 0, r = n;
while (l < r) {
// printf("%d %d\n",l,r);
int mb = (l + r) / 2;
auto t = split(root, mb);
if (mini(t.second) >= 2) {
r = mb;
} else {
l = mb + 1;
}
root = merge(t.first, t.second);
}
printf("%d\n", l + 1);
s[l] = ')';
toji.insert(l);
// printf(":%d %d\n",l,r);
root = add(root, l, n, -2);
}
// puts(s);
// printf("%d\n",kakko);
// print(root); puts("");
/*
printf("sum:%d min:%d\n",gsum(t),mini(t));
//*/
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
struct T;
#define null ((T *)NULL)
typedef long long ll;
struct T {
ll v;
ll s;
ll m;
int c;
T *l, *r;
bool lz;
ll lazy;
T() {}
T(ll v) : v(v), s(v), m(v), c(1), l(null), r(null), lz(false), lazy(0) {}
};
int hogeS = 0;
#define SSS 2222222
T hoge[SSS];
inline T *New(int v) {
if (hogeS >= SSS)
exit(-1);
hoge[hogeS] = T(v);
return &hoge[hogeS++];
}
inline int count(T *t) { return t ? t->c : 0; }
inline void push(T *t) {
if (!t)
return;
if (t->lz) {
t->v += t->lazy;
t->m += t->lazy;
t->s += t->lazy * count(t);
t->lz = false;
if (t->r) {
t->r->lz |= true;
t->r->lazy += t->lazy;
}
if (t->l) {
t->l->lz |= true;
t->l->lazy += t->lazy;
}
t->lazy = 0;
}
}
inline ll sum(T *t) {
push(t);
return t ? t->s : 0;
}
inline ll mini(T *t) {
push(t);
return t ? t->m : LLONG_MAX;
}
inline T *update(T *t) {
if (!t)
return t;
push(t);
t->c = count(t->l) + count(t->r) + 1;
t->s = t->v + sum(t->l) + sum(t->r);
t->m = min(t->v, min(mini(t->l), mini(t->r)));
return t;
}
T *merge(T *a, T *b) {
push(a);
push(b);
if (!a || !b)
return a ? a : b;
if (rand() % (count(a) + count(b)) < count(a)) {
a->r = merge(a->r, b);
return update(a);
} else {
b->l = merge(a, b->l);
return update(b);
}
}
pair<T *, T *> split(T *a, int k) {
push(a);
if (!a)
return make_pair(null, null);
if (k <= count(a->l)) {
pair<T *, T *> s = split(a->l, k);
a->l = s.second;
return make_pair(s.first, update(a));
} else {
pair<T *, T *> s = split(a->r, k - count(a->l) - 1);
a->r = s.first;
return make_pair(update(a), s.second);
}
}
inline T *erase(T *t, int k) {
push(t);
pair<T *, T *> v = split(t, k);
k -= (k - 1);
pair<T *, T *> u = split(v.second, k);
return merge(v.first, u.second);
}
inline T *insert(T *t, int k, int v) {
push(t);
pair<T *, T *> a = split(t, k);
return merge(merge(a.first, New(v)), a.second);
}
inline T *add(T *t, int l, int r, int k) {
push(t);
pair<T *, T *> u = split(t, r);
pair<T *, T *> v = split(u.first, l);
T *w = v.second;
w->lz = true;
w->lazy += k;
return merge(merge(v.first, update(w)), u.second);
}
inline T *add(T *t, int k) {
push(t);
t->lz |= true;
t->lazy += k;
return update(t);
}
int n, m;
char s[333333];
inline T *flip(T *t, int k) {
push(t);
pair<T *, T *> a = split(t, k);
pair<T *, T *> b = split(a.second, 1);
// b.first->v = -b.first->v;
// b.first = add(b.first,k,n);
return merge(a.first, merge(b.first, b.second));
}
void print(T *t) {
if (t == null)
return;
push(t);
print(t->l);
printf("%2lld,%2lld|", t->v, t->m);
print(t->r);
}
inline int gsum(T *t) {
/*
if( !t->r ) return t->v;
return gsum(t->r);
*/
return 0;
}
int main(void) {
T *root = null;
int n, q, m;
set<int> toji;
scanf("%d%d", &n, &q);
scanf("%s", s);
for (int i = 0; i < n; i++) {
root = insert(root, i, 0);
}
for (int i = 0; i < n; i++) {
root = add(root, i, n, s[i] == '(' ? 1 : -1);
if (s[i] == ')')
toji.insert(i);
}
// print(root); puts("");
int k;
for (int ii = 0; ii < q; ii++) {
scanf("%d", &k);
// printf("%d %d\n",mini(t),gsum(t));
// print(t); puts("");
if (s[k - 1] == '(') {
s[k - 1] = ')';
toji.insert(k - 1);
root = add(root, k - 1, n, -2);
int me = *(toji.begin());
printf("%d\n", me + 1);
s[me] = '(';
toji.erase(me);
root = add(root, me, n, 2);
} else {
toji.erase(k - 1);
s[k - 1] = '(';
root = add(root, k - 1, n, 2);
int l = 0, r = n;
while (l < r) {
// printf("%d %d\n",l,r);
int mb = (l + r) / 2;
auto t = split(root, mb);
if (mini(t.second) >= 2) {
r = mb;
} else {
l = mb + 1;
}
root = merge(t.first, t.second);
}
printf("%d\n", l + 1);
s[l] = ')';
toji.insert(l);
// printf(":%d %d\n",l,r);
root = add(root, l, n, -2);
}
// puts(s);
// printf("%d\n",kakko);
// print(root); puts("");
/*
printf("sum:%d min:%d\n",gsum(t),mini(t));
//*/
}
return 0;
} | replace | 130 | 131 | 130 | 131 | -11 | |
p00930 | C++ | Runtime Error | #include <iostream>
#include <set>
#include <string>
#include <vector>
#define inf 1000000000
using namespace std;
struct SegTree {
int size;
vector<int> seg, delay;
SegTree() {}
SegTree(int size) {
this->size = size;
seg.resize(1 << (size + 1));
delay.resize(1 << (size + 1));
}
void init() {
for (int i = 0; i < (1 << (size + 1)); i++) {
seg[i] = inf;
delay[i] = 0;
}
}
void eval(int l, int r, int k) {
if (delay[k]) {
seg[k] += delay[k];
delay[k * 2] += delay[k];
delay[k * 2 + 1] += delay[k];
delay[k] = 0;
}
}
void update(int i, int val) {
i += (1 << size);
seg[i] = val;
while (i > 1) {
i /= 2;
seg[i] = min(seg[i * 2], seg[i * 2 + 1]);
}
}
void add(int a, int b, int k, int l, int r, int val) {
eval(l, r, k);
if (b < l || r < a)
return;
if (a <= l && r <= b) {
delay[k] += val;
eval(l, r, k);
return;
}
add(a, b, k * 2, l, (l + r) / 2, val);
add(a, b, k * 2 + 1, (l + r) / 2 + 1, r, val);
seg[k] = min(seg[k * 2], seg[k * 2 + 1]);
}
void add(int a, int b, int val) {
if (a > b)
return;
add(a, b, 1, 0, (1 << size) - 1, val);
}
int query(int a, int b, int k, int l, int r) {
eval(l, r, k);
if (b < l || r < a)
return inf;
if (a <= l && r <= b)
return seg[k];
int lval = query(a, b, k * 2, l, (l + r) / 2);
int rval = query(a, b, k * 2 + 1, (l + r) / 2 + 1, r);
return min(lval, rval);
}
int query(int a, int b) { return query(a, b, 1, 0, (1 << size) - 1); }
};
int N, Q;
string s;
SegTree seg(19);
set<int> cand;
int getans(int p) {
int ub = p, lb = 0, mid;
while (ub - lb > 1) {
mid = (ub + lb) / 2;
if (seg.query(mid, p) >= 2)
ub = mid;
else
lb = mid;
}
return ub;
}
int main(void) {
cin >> N >> Q;
cin >> s;
s = " " + s;
seg.init();
int sum = 0;
for (int i = 1; i <= N; i++) {
if (s[i] == '(')
sum++;
else {
sum--;
cand.insert(i);
}
seg.update(i, sum);
}
int p, ans;
for (int q = 0; q < Q; q++) {
cin >> p;
if (s[p] == '(') {
s[p] = ')';
cand.insert(p);
seg.add(p, N, -2);
while (s[*cand.begin()] == '(')
cand.erase(cand.begin());
ans = *cand.begin();
s[ans] = '(';
cand.erase(cand.begin());
seg.add(ans, N, 2);
} else {
s[p] = '(';
if (cand.count(p))
cand.erase(p);
seg.add(p, N, 2);
ans = getans(p);
s[ans] = ')';
cand.insert(ans);
seg.add(ans, N, -2);
}
cout << ans << endl;
}
return 0;
}
| #include <iostream>
#include <set>
#include <string>
#include <vector>
#define inf 1000000000
using namespace std;
struct SegTree {
int size;
vector<int> seg, delay;
SegTree() {}
SegTree(int size) {
this->size = size;
seg.resize(1 << (size + 1));
delay.resize(1 << (size + 1));
}
void init() {
for (int i = 0; i < (1 << (size + 1)); i++) {
seg[i] = inf;
delay[i] = 0;
}
}
void eval(int l, int r, int k) {
if (delay[k]) {
seg[k] += delay[k];
if (l < r) {
delay[k * 2] += delay[k];
delay[k * 2 + 1] += delay[k];
}
delay[k] = 0;
}
}
void update(int i, int val) {
i += (1 << size);
seg[i] = val;
while (i > 1) {
i /= 2;
seg[i] = min(seg[i * 2], seg[i * 2 + 1]);
}
}
void add(int a, int b, int k, int l, int r, int val) {
eval(l, r, k);
if (b < l || r < a)
return;
if (a <= l && r <= b) {
delay[k] += val;
eval(l, r, k);
return;
}
add(a, b, k * 2, l, (l + r) / 2, val);
add(a, b, k * 2 + 1, (l + r) / 2 + 1, r, val);
seg[k] = min(seg[k * 2], seg[k * 2 + 1]);
}
void add(int a, int b, int val) {
if (a > b)
return;
add(a, b, 1, 0, (1 << size) - 1, val);
}
int query(int a, int b, int k, int l, int r) {
eval(l, r, k);
if (b < l || r < a)
return inf;
if (a <= l && r <= b)
return seg[k];
int lval = query(a, b, k * 2, l, (l + r) / 2);
int rval = query(a, b, k * 2 + 1, (l + r) / 2 + 1, r);
return min(lval, rval);
}
int query(int a, int b) { return query(a, b, 1, 0, (1 << size) - 1); }
};
int N, Q;
string s;
SegTree seg(19);
set<int> cand;
int getans(int p) {
int ub = p, lb = 0, mid;
while (ub - lb > 1) {
mid = (ub + lb) / 2;
if (seg.query(mid, p) >= 2)
ub = mid;
else
lb = mid;
}
return ub;
}
int main(void) {
cin >> N >> Q;
cin >> s;
s = " " + s;
seg.init();
int sum = 0;
for (int i = 1; i <= N; i++) {
if (s[i] == '(')
sum++;
else {
sum--;
cand.insert(i);
}
seg.update(i, sum);
}
int p, ans;
for (int q = 0; q < Q; q++) {
cin >> p;
if (s[p] == '(') {
s[p] = ')';
cand.insert(p);
seg.add(p, N, -2);
while (s[*cand.begin()] == '(')
cand.erase(cand.begin());
ans = *cand.begin();
s[ans] = '(';
cand.erase(cand.begin());
seg.add(ans, N, 2);
} else {
s[p] = '(';
if (cand.count(p))
cand.erase(p);
seg.add(p, N, 2);
ans = getans(p);
s[ans] = ')';
cand.insert(ans);
seg.add(ans, N, -2);
}
cout << ans << endl;
}
return 0;
}
| replace | 29 | 31 | 29 | 33 | 0 | |
p00935 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
bool vis[100005];
int n, x, a[1005];
int main() {
memset(vis, false, sizeof(vis));
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
x = 0;
for (int j = 0; j <= min(5, n - i); j++) {
x = x * 10 + a[i + j];
vis[x] = true;
}
}
for (int i = 0; i <= 100000; i++) {
if (vis[i] == false) {
printf("%d\n", i);
break;
}
}
return 0;
} | #include <algorithm>
#include <cstdio>
#include <cstring>
using namespace std;
bool vis[100005];
int n, x, a[1005];
int main() {
memset(vis, false, sizeof(vis));
scanf("%d", &n);
for (int i = 1; i <= n; i++)
scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) {
x = 0;
for (int j = 0; j <= min(4, n - i); j++) {
x = x * 10 + a[i + j];
vis[x] = true;
}
}
for (int i = 0; i <= 100000; i++) {
if (vis[i] == false) {
printf("%d\n", i);
break;
}
}
return 0;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p00935 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <cassert>
#include <complex>
#include <ctype.h> // isdigit
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define ALL(u) begin(u), end(u)
#define PB push_back
#define LE(n, m) ((n) < (m) + EPS * (abs(n) + abs(m)))
#define GE(n, m) ((n) + EPS * (abs(n) + abs(m)) > (m))
#define LT(n, m) ((n) + EPS * (abs(n) + abs(m)) < (m))
#define GT(n, m) ((n) > (m) + EPS * (abs(n) + abs(m)))
#define EQ(n, m) (abs((n) - (m)) < EPS * (abs(n) + abs(m)))
typedef long long int ll;
const int INF = (1 << 30) - 1;
const double EPS = 1e-9;
const int MOD = 1000000007;
// g++ -std=c++0x -msse4.2 -O3
// #include <bits/stdc++.h>
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout.precision(16);
// cout.setf(ios::fixed);
int N;
cin >> N;
vector<int> inputs(N);
for (auto &v : inputs)
cin >> v;
vector<int> exists(1000, false);
for (int l = 1; l <= 4; l++) {
for (int i = 0; i < N + 1 - l; i++) {
int v = 0;
for (int j = 0; j < l; j++)
v = v * 10 + inputs[i + j];
exists[v] = true;
}
}
for (int i = 0; i < 1000; i++) {
if (!exists[i]) {
cout << i << endl;
return 0;
}
}
return 0;
} | #include <algorithm>
#include <array>
#include <cassert>
#include <complex>
#include <ctype.h> // isdigit
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string.h>
#include <string>
#include <tuple>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define RFOR(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define REP(i, n) for (int i = 0; i < (n); i++)
#define RREP(i, n) for (int i = (n)-1; i >= 0; i--)
#define ALL(u) begin(u), end(u)
#define PB push_back
#define LE(n, m) ((n) < (m) + EPS * (abs(n) + abs(m)))
#define GE(n, m) ((n) + EPS * (abs(n) + abs(m)) > (m))
#define LT(n, m) ((n) + EPS * (abs(n) + abs(m)) < (m))
#define GT(n, m) ((n) > (m) + EPS * (abs(n) + abs(m)))
#define EQ(n, m) (abs((n) - (m)) < EPS * (abs(n) + abs(m)))
typedef long long int ll;
const int INF = (1 << 30) - 1;
const double EPS = 1e-9;
const int MOD = 1000000007;
// g++ -std=c++0x -msse4.2 -O3
// #include <bits/stdc++.h>
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
// cout.precision(16);
// cout.setf(ios::fixed);
int N;
cin >> N;
vector<int> inputs(N);
for (auto &v : inputs)
cin >> v;
vector<int> exists(1000, false);
for (int l = 1; l <= 3; l++) {
for (int i = 0; i < N + 1 - l; i++) {
int v = 0;
for (int j = 0; j < l; j++)
v = v * 10 + inputs[i + j];
exists[v] = true;
}
}
for (int i = 0; i < 1000; i++) {
if (!exists[i]) {
cout << i << endl;
return 0;
}
}
return 0;
} | replace | 52 | 53 | 52 | 53 | 0 | |
p00935 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
deque<char> plus1(deque<char> const &a) {
if (a == deque<char>{'0'}) {
return {'1'};
}
deque<char> ret;
ret.push_back('0');
copy(a.begin(), a.end(), back_inserter(ret));
ret.back() += 1;
int N = ret.size();
int idx = N - 1;
while (ret[idx] == '9' + 1) {
ret[idx] = '0';
ret[--idx] += 1;
}
deque<char> ans;
bool ok = false;
REP(i, 0, N) {
if (ok || (ret[i] != '0')) {
ok = 1;
ans.push_back(ret[i]);
}
}
return ans;
}
deque<char> zeroclear(deque<char> &s) {
deque<char> ret;
bool ok = false;
rep(i, s.size()) {
if (ok || s[i] != '0') {
ok = 1;
ret.push_back(s[i]);
}
}
if (ret.empty()) {
ret.push_back('0');
;
}
return ret;
}
struct comp {
bool operator()(deque<char> const &a, deque<char> const &b) {
int asize = a.size(), bsize = b.size();
if (asize != bsize) {
return asize < bsize;
}
for (int i = 0; i < asize; i++) {
if (a[i] != b[i]) {
return a[i] < b[i];
}
}
return 0;
}
};
int main() {
int N;
cin >> N;
string S;
rep(i, N) {
char ch;
cin >> ch;
S.push_back(ch);
}
set<deque<char>, comp> vs;
rep(i, N) {
deque<char> s;
REP(j, i, N) {
s.push_back(S[j]);
vs.insert(zeroclear(s));
}
}
// int cc = 0;
// for(auto& s: vs) { if(++cc >= 15) { break; } rep(i, s.size()) { cout <<
// s[i]; } cout << endl; }cout << endl; rep(i, v.size()) { cout << v[i] <<
// endl; }cout << endl;
deque<char> curr;
curr.push_back('0');
for (auto &s : vs) {
if (curr != s) {
rep(i, curr.size()) { cout << curr[i]; }
cout << endl;
exit(0);
}
curr = plus1(curr);
// cout << "---\n"; cout << curr << endl;
}
rep(i, curr.size()) { cout << curr[i]; }
cout << endl;
return 0;
} | #include <algorithm>
#include <array>
#include <assert.h>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP(i, a, b) for (int i = a; i < (int)b; i++)
#define rep(i, n) REP(i, 0, n)
deque<char> plus1(deque<char> const &a) {
if (a == deque<char>{'0'}) {
return {'1'};
}
deque<char> ret;
ret.push_back('0');
copy(a.begin(), a.end(), back_inserter(ret));
ret.back() += 1;
int N = ret.size();
int idx = N - 1;
while (ret[idx] == '9' + 1) {
ret[idx] = '0';
ret[--idx] += 1;
}
deque<char> ans;
bool ok = false;
REP(i, 0, N) {
if (ok || (ret[i] != '0')) {
ok = 1;
ans.push_back(ret[i]);
}
}
return ans;
}
deque<char> zeroclear(deque<char> &s) {
deque<char> ret;
bool ok = false;
rep(i, s.size()) {
if (ok || s[i] != '0') {
ok = 1;
ret.push_back(s[i]);
}
}
if (ret.empty()) {
ret.push_back('0');
;
}
return ret;
}
struct comp {
bool operator()(deque<char> const &a, deque<char> const &b) {
int asize = a.size(), bsize = b.size();
if (asize != bsize) {
return asize < bsize;
}
for (int i = 0; i < asize; i++) {
if (a[i] != b[i]) {
return a[i] < b[i];
}
}
return 0;
}
};
int main() {
int N;
cin >> N;
string S;
rep(i, N) {
char ch;
cin >> ch;
S.push_back(ch);
}
set<deque<char>, comp> vs;
rep(i, N) {
deque<char> s;
REP(j, i, N) {
if (j - i > 7) {
continue;
}
s.push_back(S[j]);
vs.insert(zeroclear(s));
}
}
// int cc = 0;
// for(auto& s: vs) { if(++cc >= 15) { break; } rep(i, s.size()) { cout <<
// s[i]; } cout << endl; }cout << endl; rep(i, v.size()) { cout << v[i] <<
// endl; }cout << endl;
deque<char> curr;
curr.push_back('0');
for (auto &s : vs) {
if (curr != s) {
rep(i, curr.size()) { cout << curr[i]; }
cout << endl;
exit(0);
}
curr = plus1(curr);
// cout << "---\n"; cout << curr << endl;
}
rep(i, curr.size()) { cout << curr[i]; }
cout << endl;
return 0;
} | insert | 98 | 98 | 98 | 101 | MLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.