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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p01368 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#define MAX_V 1001
#define INF 1000000000
void add_edge(int, int);
bool dfs(int);
int bipartite_matching(int);
void warshall_floyd(int);
using namespace std;
vector<int> G[MAX_V];
bool used[MAX_V];
int match[MAX_V], d[MAX_V][MAX_V];
int main(void) {
int n, m, l, p[MAX_V], t[MAX_V];
while (scanf("%d %d %d", &n, &m, &l), n, m, l) {
for (int i = 0; i < MAX_V * 2; i++)
G[i].clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[i][j] = i == j ? 0 : INF;
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
d[a][b] = d[b][a] = c;
}
warshall_floyd(n);
for (int i = 0; i < l; i++)
scanf("%d %d", &p[i], &t[i]);
for (int i = 0; i < l; i++) {
for (int j = 0; j < l; j++) {
if (i == j)
continue;
else if (t[i] + d[p[i]][p[j]] <= t[j])
add_edge(i, j + l);
}
}
cout << l - bipartite_matching(2 * l) << endl;
}
return 0;
}
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
bool dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i], w = match[u];
if (w < 0 || !used[w] && dfs(w)) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int bipartite_matching(int V) {
int res = 0;
memset(match, -1, sizeof(match));
for (int v = 0; v < V; v++) {
if (match[v] < 0) {
memset(used, 0, sizeof(used));
if (dfs(v))
res++;
}
}
return res;
}
void warshall_floyd(int V) {
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
for (int k = 0; k < V; k++) {
d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
}
}
}
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
#define MAX_V 10000
#define INF 1000000000
void add_edge(int, int);
bool dfs(int);
int bipartite_matching(int);
void warshall_floyd(int);
using namespace std;
vector<int> G[MAX_V];
bool used[MAX_V];
int match[MAX_V], d[MAX_V][MAX_V];
int main(void) {
int n, m, l, p[MAX_V], t[MAX_V];
while (scanf("%d %d %d", &n, &m, &l), n, m, l) {
for (int i = 0; i < MAX_V * 2; i++)
G[i].clear();
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
d[i][j] = i == j ? 0 : INF;
for (int i = 0; i < m; i++) {
int a, b, c;
scanf("%d %d %d", &a, &b, &c);
d[a][b] = d[b][a] = c;
}
warshall_floyd(n);
for (int i = 0; i < l; i++)
scanf("%d %d", &p[i], &t[i]);
for (int i = 0; i < l; i++) {
for (int j = 0; j < l; j++) {
if (i == j)
continue;
else if (t[i] + d[p[i]][p[j]] <= t[j])
add_edge(i, j + l);
}
}
cout << l - bipartite_matching(2 * l) << endl;
}
return 0;
}
void add_edge(int u, int v) {
G[u].push_back(v);
G[v].push_back(u);
}
bool dfs(int v) {
used[v] = true;
for (int i = 0; i < G[v].size(); i++) {
int u = G[v][i], w = match[u];
if (w < 0 || !used[w] && dfs(w)) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int bipartite_matching(int V) {
int res = 0;
memset(match, -1, sizeof(match));
for (int v = 0; v < V; v++) {
if (match[v] < 0) {
memset(used, 0, sizeof(used));
if (dfs(v))
res++;
}
}
return res;
}
void warshall_floyd(int V) {
for (int i = 0; i < V; i++) {
for (int j = 0; j < V; j++) {
for (int k = 0; k < V; k++) {
d[j][k] = min(d[j][k], d[j][i] + d[i][k]);
}
}
}
} | replace | 5 | 6 | 5 | 6 | 0 | |
p01368 | C++ | Runtime Error | #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
// #define int long long
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define MAX_V 110
int n;
vector<int> g[MAX_V];
int match[MAX_V];
bool used[MAX_V];
void init(int n_) {
n = n_;
rep(i, 0, n_) g[i].clear();
}
void addEdge(int u, int v) {
g[u].emplace_back(v);
g[v].emplace_back(u);
}
bool augment(int v) {
used[v] = true;
for (int u : g[v]) {
int w = match[u];
if (w == -1 || (!used[w] && augment(w))) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int maximumMatching() {
int cnt = 0;
fill(match, match + MAX_V, -1);
for (int v = 0; v < n; v++) {
if (match[v] == -1) {
fill(used, used + MAX_V, false);
if (augment(v))
cnt++;
}
}
return cnt;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int N, M, L; cin >> N >> M >> L && N;) {
vector<vector<int>> g(N, vector<int>(N, INF));
rep(i, 0, M) {
int u, v, d;
cin >> u >> v >> d;
g[u][v] = g[v][u] = d;
}
rep(i, 0, N) g[i][i] = 0;
rep(k, 0, N) rep(i, 0, N) rep(j, 0, N) {
if (g[i][k] != INF && g[k][j] != INF)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
vector<int> p(L), t(L);
rep(i, 0, L) { cin >> p[i] >> t[i]; }
init(L + L);
int source = L + L, sink = source + 1;
rep(i, 0, L) {
rep(j, 0, L) {
if (i == j)
continue;
if (g[p[i]][p[j]] <= t[j] - t[i]) {
addEdge(i, L + j);
}
}
}
auto ans = L - maximumMatching();
cout << ans << endl;
}
return 0;
} | #include "bits/stdc++.h"
using namespace std;
#ifdef _DEBUG
#include "dump.hpp"
#else
#define dump(...)
#endif
// #define int long long
#define rep(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(c) begin(c), end(c)
const int INF =
sizeof(int) == sizeof(long long) ? 0x3f3f3f3f3f3f3f3fLL : 0x3f3f3f3f;
const int MOD = (int)(1e9) + 7;
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
#define MAX_V 2200
int n;
vector<int> g[MAX_V];
int match[MAX_V];
bool used[MAX_V];
void init(int n_) {
n = n_;
rep(i, 0, n_) g[i].clear();
}
void addEdge(int u, int v) {
g[u].emplace_back(v);
g[v].emplace_back(u);
}
bool augment(int v) {
used[v] = true;
for (int u : g[v]) {
int w = match[u];
if (w == -1 || (!used[w] && augment(w))) {
match[v] = u;
match[u] = v;
return true;
}
}
return false;
}
int maximumMatching() {
int cnt = 0;
fill(match, match + MAX_V, -1);
for (int v = 0; v < n; v++) {
if (match[v] == -1) {
fill(used, used + MAX_V, false);
if (augment(v))
cnt++;
}
}
return cnt;
}
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int N, M, L; cin >> N >> M >> L && N;) {
vector<vector<int>> g(N, vector<int>(N, INF));
rep(i, 0, M) {
int u, v, d;
cin >> u >> v >> d;
g[u][v] = g[v][u] = d;
}
rep(i, 0, N) g[i][i] = 0;
rep(k, 0, N) rep(i, 0, N) rep(j, 0, N) {
if (g[i][k] != INF && g[k][j] != INF)
g[i][j] = min(g[i][j], g[i][k] + g[k][j]);
}
vector<int> p(L), t(L);
rep(i, 0, L) { cin >> p[i] >> t[i]; }
init(L + L);
int source = L + L, sink = source + 1;
rep(i, 0, L) {
rep(j, 0, L) {
if (i == j)
continue;
if (g[p[i]][p[j]] <= t[j] - t[i]) {
addEdge(i, L + j);
}
}
}
auto ans = L - maximumMatching();
cout << ans << endl;
}
return 0;
} | replace | 30 | 31 | 30 | 31 | 0 | |
p01388 | C++ | Runtime Error | #include <iostream>
#define MAX 110
using namespace std;
int rmn_min(int x, int y) { return (x < y ? x : y); }
int main() {
int k = 0;
int u = 0;
int p = 0;
int c = 0;
char line[MAX];
cin >> line;
for (int i = 0; line[i] != 0; i++) {
switch (line[i]) {
case 'K':
k++;
break;
case 'U':
u++;
break;
case 'P':
p++;
break;
case 'C':
c++;
break;
}
}
cout << rmn_min(rmn_min(rmn_min(k, u), p), c) << endl;
return 0;
} | #include <iostream>
#define MAX 301
using namespace std;
int rmn_min(int x, int y) { return (x < y ? x : y); }
int main() {
int k = 0;
int u = 0;
int p = 0;
int c = 0;
char line[MAX];
cin >> line;
for (int i = 0; line[i] != 0; i++) {
switch (line[i]) {
case 'K':
k++;
break;
case 'U':
u++;
break;
case 'P':
p++;
break;
case 'C':
c++;
break;
}
}
cout << rmn_min(rmn_min(rmn_min(k, u), p), c) << endl;
return 0;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p01388 | C++ | Runtime Error | #include <cmath>
#include <iostream>
#include <string.h>
using namespace std;
int main(void) {
char KUPC[50];
int cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0, ans;
cin >> KUPC;
for (int i = 0; i < strlen(KUPC); i++) {
if (KUPC[i] == 'K')
cnt1++;
else if (KUPC[i] == 'U')
cnt2++;
else if (KUPC[i] == 'P')
cnt3++;
else if (KUPC[i] == 'C')
cnt4++;
}
ans = min(cnt1, min(cnt2, min(cnt3, cnt4)));
cout << ans << endl;
return 0;
}
| #include <cmath>
#include <iostream>
#include <string.h>
using namespace std;
int main(void) {
char KUPC[301];
int cnt1 = 0, cnt2 = 0, cnt3 = 0, cnt4 = 0, ans;
cin >> KUPC;
for (int i = 0; i < strlen(KUPC); i++) {
if (KUPC[i] == 'K')
cnt1++;
else if (KUPC[i] == 'U')
cnt2++;
else if (KUPC[i] == 'P')
cnt3++;
else if (KUPC[i] == 'C')
cnt4++;
}
ans = min(cnt1, min(cnt2, min(cnt3, cnt4)));
cout << ans << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01389 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int n, m;
int main() {
string s[20];
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> s[i];
int field[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
field[i][j] = stoi(s[i].substr(j, 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i + j == 0)
continue;
int a = 9999999, b = 999999;
if (i != 0)
a = field[i - 1][j];
if (j != 0)
b = field[i][j - 1];
field[i][j] = field[i][j] + min(a, b);
}
}
cout << field[n - 1][m - 1] << endl;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <string>
using namespace std;
int n, m;
int main() {
string s[60];
cin >> n >> m;
for (int i = 0; i < n; i++)
cin >> s[i];
int field[n][m];
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
field[i][j] = stoi(s[i].substr(j, 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
if (i + j == 0)
continue;
int a = 9999999, b = 999999;
if (i != 0)
a = field[i - 1][j];
if (j != 0)
b = field[i][j - 1];
field[i][j] = field[i][j] + min(a, b);
}
}
cout << field[n - 1][m - 1] << endl;
} | replace | 10 | 11 | 10 | 11 | 0 | |
p01389 | C++ | Runtime Error | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int cnt[50][50], dp[60][60];
int main() {
int h, w;
scanf("%d%d", &h, &w);
rep(i, h) rep(j, w) scanf("%1d", &cnt[i][j]);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = cnt[0][0];
rep(i, h) rep(j, w) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + cnt[i + 1][j]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + cnt[i][j + 1]);
}
printf("%d\n", dp[h - 1][w - 1]);
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int cnt[60][60], dp[60][60];
int main() {
int h, w;
scanf("%d%d", &h, &w);
rep(i, h) rep(j, w) scanf("%1d", &cnt[i][j]);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = cnt[0][0];
rep(i, h) rep(j, w) {
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j] + cnt[i + 1][j]);
dp[i][j + 1] = min(dp[i][j + 1], dp[i][j] + cnt[i][j + 1]);
}
printf("%d\n", dp[h - 1][w - 1]);
} | replace | 4 | 5 | 4 | 5 | 0 | |
p01391 | C++ | Time Limit Exceeded | #include <ctime>
#include <iostream>
#pragma warning(disable : 4996)
using namespace std;
int N, K, card[500][500], r[1000];
int main() {
srand((unsigned)time(NULL));
scanf("%d%d", &N, &K);
for (int i = 0; i < K; i++) {
for (int j = 0; j < N / 2; j++) {
scanf("%d", &card[i][j]);
}
}
while (true) {
for (int i = 0; i < N; i++)
r[i] = rand() % 2;
bool flag = true;
for (int i = 0; i < K; i++) {
int c = 0;
for (int j = 0; j < N / 2; j++) {
if (r[card[i][j] - 1])
c++;
}
if (c < N / 8 || 3 * N / 8 < c) {
flag = false;
break;
}
}
if (flag) {
for (int i = 0; i < N; i++) {
printf("%d", r[i]);
}
printf("\n");
}
}
return 0;
} | #include <ctime>
#include <iostream>
#pragma warning(disable : 4996)
using namespace std;
int N, K, card[500][500], r[1000];
int main() {
srand((unsigned)time(NULL));
scanf("%d%d", &N, &K);
for (int i = 0; i < K; i++) {
for (int j = 0; j < N / 2; j++) {
scanf("%d", &card[i][j]);
}
}
while (true) {
for (int i = 0; i < N; i++)
r[i] = rand() % 2;
bool flag = true;
for (int i = 0; i < K; i++) {
int c = 0;
for (int j = 0; j < N / 2; j++) {
if (r[card[i][j] - 1])
c++;
}
if (c < N / 8 || 3 * N / 8 < c) {
flag = false;
break;
}
}
if (flag) {
for (int i = 0; i < N; i++) {
printf("%d", r[i]);
}
printf("\n");
break;
}
}
return 0;
} | insert | 33 | 33 | 33 | 34 | TLE | |
p01392 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#define ll long long
using namespace std;
bool isprime[1000001];
int fact[1000001];
bool isfox[1000001];
int primes[78498];
int factorial(ll arg, int base) {
int ret = 0;
while (arg % base == 0) {
arg /= base;
ret++;
}
return ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
int cnt = 0;
ll a, b;
for (int i = 2; i < 1000001; i++) {
if (!isprime[i]) {
primes[cnt++] = i;
for (int j = 2; i * j < 1000001; j++) {
isprime[i * j] = true;
}
}
}
cin >> a >> b;
ll len, bias;
if (a - b < 2) {
bias = 2;
} else {
bias = a - b;
}
len = a + b - bias + 1;
fill((int *)fact, (int *)fact + 1000001, 1 << 29);
for (int i = 0; (ll)primes[i] * primes[i] <= a + b; i++) {
for (int j = (primes[i] - bias % primes[i]) % primes[i]; j < len;
j += primes[i]) {
if (isfox[j])
continue;
int tmp = factorial(j + bias, primes[i]);
if (tmp != 0) {
if (fact[j] == 1 << 29 || fact[j] >= tmp) {
fact[j] = tmp;
} else {
isfox[j] = true;
}
}
}
}
int res = 0;
for (int i = 0; i < len; i++) {
res += !isfox[i] ? 1 : 0;
}
cout << res << endl;
} | #include <algorithm>
#include <iostream>
#define ll long long
using namespace std;
bool isprime[1000001];
int fact[1000001];
bool isfox[1000001];
int primes[78498];
int factorial(ll arg, int base) {
int ret = 0;
while (arg % base == 0) {
arg /= base;
ret++;
}
return ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
int cnt = 0;
ll a, b;
for (int i = 2; i < 1000001; i++) {
if (!isprime[i]) {
primes[cnt++] = i;
for (int j = 2; i * j < 1000001; j++) {
isprime[i * j] = true;
}
}
}
cin >> a >> b;
ll len, bias;
if (a - b < 2) {
bias = 2;
} else {
bias = a - b;
}
len = a + b - bias + 1;
fill((int *)fact, (int *)fact + 1000001, 1 << 29);
for (int i = 0; i < 78498; i++) {
for (int j = (primes[i] - bias % primes[i]) % primes[i]; j < len;
j += primes[i]) {
if (isfox[j])
continue;
int tmp = factorial(j + bias, primes[i]);
if (tmp != 0) {
if (fact[j] == 1 << 29 || fact[j] >= tmp) {
fact[j] = tmp;
} else {
isfox[j] = true;
}
}
}
}
int res = 0;
for (int i = 0; i < len; i++) {
res += !isfox[i] ? 1 : 0;
}
cout << res << endl;
} | replace | 44 | 45 | 44 | 45 | 0 | |
p01392 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#pragma comment(linker, "/STACK:400000000")
#define EPS 1e-9
#define INF MOD
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (it = X.begin(); it != X.end(); it++)
#define iss istringstream
#define ite iterator
#define ll long long
#define mp make_pair
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < n; i++)
#define pi pair<int, int>
#define pb push_back
#define sec second
#define sh(i) (1LL << i)
#define sst stringstream
#define sz size()
#define vi vector<int>
#define vc vector
#define vl vector<ll>
#define vs vector<string>
bool isp[1000011];
int last[1000011];
ll A, B, a, b;
int main() {
cin >> A >> B;
a = max(2LL, A - B);
b = A + B;
fill(isp, isp + 1000011, 1);
fill(last, last + 2 * B + 1, INF);
for (ll i = 2; i * i <= b; i++) {
if (isp[i]) {
for (ll j = 2 * i; j * j <= b; j += i)
isp[j] = 0;
for (ll j = max(2LL, (a + i - 1) / i) * i; j <= b; j += i) {
if (last[j - a] > -1) {
ll x = j, y = 0;
while (x % i == 0)
x /= i, y++;
if (last[j - a] < y)
last[j - a] = -1;
else
last[j - a] = y;
}
}
}
}
int ans = 0;
rep2(i, a, b + 1) ans += last[i - a] > -1;
cout << ans << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#pragma comment(linker, "/STACK:400000000")
#define EPS 1e-9
#define INF MOD
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (it = X.begin(); it != X.end(); it++)
#define iss istringstream
#define ite iterator
#define ll long long
#define mp make_pair
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < n; i++)
#define pi pair<int, int>
#define pb push_back
#define sec second
#define sh(i) (1LL << i)
#define sst stringstream
#define sz size()
#define vi vector<int>
#define vc vector
#define vl vector<ll>
#define vs vector<string>
bool isp[1000011];
int last[1000011];
ll A, B, a, b;
int main() {
cin >> A >> B;
a = max(2LL, A - B);
b = A + B;
fill(isp, isp + 1000011, 1);
fill(last, last + 2 * B + 1, INF);
for (ll i = 2; i * i <= b; i++) {
if (isp[i]) {
for (ll j = 2 * i; j * j <= b; j += i)
isp[j] = 0;
for (ll j = max(2LL, (a + i - 1) / i) * i; j <= b; j += i) {
if (last[j - a] > -1) {
ll x = j, y = 0;
while (x % i == 0)
x /= i, y++;
if (last[j - a] < y)
last[j - a] = -1;
else
last[j - a] = y;
}
}
}
}
int ans = 0;
for (ll i = a; i <= b; i++)
ans += last[i - a] > -1;
cout << ans << endl;
} | replace | 76 | 77 | 76 | 78 | 0 | |
p01392 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
#include <queue>
#include <set>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define f first
#define s second
#define mp make_pair
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long s = a - b;
long long e = a + b;
const int MAX = 1500000;
vector<int> prime;
vector<bool> p(MAX, true);
vector<bool> ans(2 * b + 1, true);
p[0] = p[1] = false;
for (int i = 4; i < MAX; i += 2)
p[i] = false;
for (int i = 3; (long long)i * i < MAX; i += 2)
if (p[i])
for (int j = i + i; j < MAX; j += i)
p[j] = false;
REP(i, MAX) if (p[i]) prime.push_back(i);
// REP(i,prime.size()) cout << prime[i] << endl;
const int n = prime.size();
if (s == 0)
ans[0] = false;
if (s <= 1)
ans[1 - s] = false;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long t = 1;
t *= prime[i];
t *= prime[j];
t *= prime[j];
// printf("test: %d %d\n", i, j);
if (t > e)
break;
long long k = t * ((s + t - 1) / t);
if (k > e)
continue;
for (long long kk = k; kk <= e; kk += t) {
if (ans[kk - s]) {
int icnt = 0;
int jcnt = 0;
long long kkk = kk;
while (kkk % prime[i] == 0) {
kkk /= prime[i];
icnt++;
}
while (kkk % prime[j] == 0) {
kkk /= prime[j];
jcnt++;
}
if (icnt < jcnt)
ans[kk - s] = false;
}
}
}
}
int cnt = 0;
REP(i, ans.size()) if (ans[i]) cnt++;
cout << cnt << endl;
return 0;
} | #include <cstdio>
#include <iostream>
#include <queue>
#include <set>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define f first
#define s second
#define mp make_pair
using namespace std;
int main() {
long long a, b;
cin >> a >> b;
long long s = a - b;
long long e = a + b;
const int MAX = 1500000;
vector<int> prime;
vector<bool> p(MAX, true);
vector<bool> ans(2 * b + 1, true);
p[0] = p[1] = false;
for (int i = 4; i < MAX; i += 2)
p[i] = false;
for (int i = 3; (long long)i * i < MAX; i += 2)
if (p[i])
for (int j = i + i; j < MAX; j += i)
p[j] = false;
REP(i, MAX) if (p[i]) prime.push_back(i);
// REP(i,prime.size()) cout << prime[i] << endl;
const int n = prime.size();
if (s < 0) {
ans = vector<bool>(e + 1, true);
s = 0;
}
if (s == 0)
ans[0] = false;
if (s <= 1)
ans[1 - s] = false;
for (int i = 0; i < n; i++) {
for (int j = i + 1; j < n; j++) {
long long t = 1;
t *= prime[i];
t *= prime[j];
t *= prime[j];
// printf("test: %d %d\n", i, j);
if (t > e)
break;
long long k = t * ((s + t - 1) / t);
if (k > e)
continue;
for (long long kk = k; kk <= e; kk += t) {
if (ans[kk - s]) {
int icnt = 0;
int jcnt = 0;
long long kkk = kk;
while (kkk % prime[i] == 0) {
kkk /= prime[i];
icnt++;
}
while (kkk % prime[j] == 0) {
kkk /= prime[j];
jcnt++;
}
if (icnt < jcnt)
ans[kk - s] = false;
}
}
}
}
int cnt = 0;
REP(i, ans.size()) if (ans[i]) cnt++;
cout << cnt << endl;
return 0;
} | insert | 37 | 37 | 37 | 42 | TLE | |
p01392 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
#define MAX_N 1000007
long long A, B, W[MAX_N], cnt;
bool prime[MAX_N];
vector<short> V[MAX_N];
void primesieve() {
for (int i = 2; i * i <= 1000000; i++) {
for (int j = i * i; j <= 1000000; j += i)
prime[j] = true;
}
for (int i = 0; i <= 1000000; i++)
prime[i] ^= true;
}
int main() {
cin >> A >> B;
long long L = A - B, R = A + B;
primesieve();
if (L < 0)
L = 1;
for (long long i = L; i <= R; i++) {
W[i - L] = i;
}
for (long long i = 2; i <= 1000000; i++) {
if (prime[i] == false)
continue;
long long F = (L / i) * i;
if ((L % i) > 0)
F += i;
for (long long j = F; j <= R; j += i) {
int cnts = 0;
while (W[j - L] % i == 0) {
W[j - L] /= i;
cnts++;
}
if (cnts >= 1) {
V[j - L].push_back(cnts);
}
}
}
for (long long i = L; i <= R; i++) {
if (W[i - L] >= 2 && W[i - L] != i)
V[i - L].push_back(1);
}
for (long long i = L; i <= R; i++) {
bool OK = true;
if (i <= 1LL)
OK = false;
for (int j = 1; j < V[i - L].size(); j++) {
if (V[i - L][j - 1] < V[i - L][j])
OK = false;
}
if (OK == true)
cnt++;
}
cout << cnt << endl;
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
#define MAX_N 1000007
long long A, B, W[MAX_N], cnt;
bool prime[MAX_N];
vector<short> V[MAX_N];
void primesieve() {
for (int i = 2; i * i <= 1000000; i++) {
for (int j = i * i; j <= 1000000; j += i)
prime[j] = true;
}
for (int i = 0; i <= 1000000; i++)
prime[i] ^= true;
}
int main() {
cin >> A >> B;
long long L = A - B, R = A + B;
primesieve();
if (L <= 0)
L = 1;
for (long long i = L; i <= R; i++) {
W[i - L] = i;
}
for (long long i = 2; i <= 1000000; i++) {
if (prime[i] == false)
continue;
long long F = (L / i) * i;
if ((L % i) > 0)
F += i;
for (long long j = F; j <= R; j += i) {
int cnts = 0;
while (W[j - L] % i == 0) {
W[j - L] /= i;
cnts++;
}
if (cnts >= 1) {
V[j - L].push_back(cnts);
}
}
}
for (long long i = L; i <= R; i++) {
if (W[i - L] >= 2 && W[i - L] != i)
V[i - L].push_back(1);
}
for (long long i = L; i <= R; i++) {
bool OK = true;
if (i <= 1LL)
OK = false;
for (int j = 1; j < V[i - L].size(); j++) {
if (V[i - L][j - 1] < V[i - L][j])
OK = false;
}
if (OK == true)
cnt++;
}
cout << cnt << endl;
return 0;
} | replace | 19 | 20 | 19 | 20 | TLE | |
p01398 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int k(int a) {
for (int i = 0;; i++) {
if (a - 26 * i >= 'a' && a - 26 * i <= 'z')
return a - 26 * i;
}
}
int main() {
int a;
while (cin >> a, a) {
string b;
cin >> b;
int x[100], y[100];
for (int c = 0; c < a; c++) {
scanf("%d%d", &x[c], &y[c]);
x[c]--;
y[c]--;
}
for (int i = a - 1; i >= 0; i--) {
int d = (int)b[x[i]] + abs(x[i] - y[i]),
e = (int)b[y[i]] + abs(x[i] - y[i]);
d = k((char)d);
e = k((char)e);
b[x[i]] = e;
b[y[i]] = d;
}
cout << b << endl;
}
} | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <string>
using namespace std;
int k(int a) {
for (int i = 0;; i++) {
if (a - 26 * i >= 'a' && a - 26 * i <= 'z')
return a - 26 * i;
}
}
int main() {
int a;
while (cin >> a, a) {
string b;
cin >> b;
int x[100], y[100];
for (int c = 0; c < a; c++) {
scanf("%d%d", &x[c], &y[c]);
x[c]--;
y[c]--;
}
for (int i = a - 1; i >= 0; i--) {
int d = (int)b[x[i]] + abs(x[i] - y[i]),
e = (int)b[y[i]] + abs(x[i] - y[i]);
d = k(d);
e = k(e);
b[x[i]] = e;
b[y[i]] = d;
}
cout << b << endl;
}
} | replace | 26 | 28 | 26 | 28 | TLE | |
p01399 | C++ | Runtime Error | // 50
#include <algorithm>
#include <iostream>
using namespace std;
struct S {
int d, t, n;
bool operator<(S a) const {
if (t != a.t) {
return t < a.t;
} else {
return d < a.d;
}
}
};
int main() {
for (int n, m; cin >> n >> m, n | m;) {
S p[40];
for (int i = 0; i < n; i++) {
cin >> p[i].d;
p[i].n = i + 1;
p[i].t = m / p[i].d * p[i].d;
}
sort(p, p + n);
if (!(p[0] < p[1]) && !(p[1] < p[0])) {
cout << n << endl;
} else {
cout << p[0].n << endl;
}
}
return 0;
} | // 50
#include <algorithm>
#include <iostream>
using namespace std;
struct S {
int d, t, n;
bool operator<(S a) const {
if (t != a.t) {
return t < a.t;
} else {
return d < a.d;
}
}
};
int main() {
for (int n, m; cin >> n >> m, n | m;) {
S p[1000];
for (int i = 0; i < n; i++) {
cin >> p[i].d;
p[i].n = i + 1;
p[i].t = m / p[i].d * p[i].d;
}
sort(p, p + n);
if (!(p[0] < p[1]) && !(p[1] < p[0])) {
cout << n << endl;
} else {
cout << p[0].n << endl;
}
}
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p01400 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
map<string, int> mp;
struct edge {
int to, cost;
};
vector<edge> dis[600];
int d[600];
int main() {
int n, m;
for (;;) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
string s, a, g;
rep(i, 600) dis[i].clear();
cin >> s >> a >> g;
mp.clear();
mp[s] = 0;
mp[a] = 1;
mp[g] = 2;
int count = 3;
rep(i, m) {
string sa, sb;
int cost, pen;
int aa, bb;
cin >> sa >> sb >> cost >> pen;
cost = cost / 40 + pen;
if (mp.count(sa))
aa = mp[sa];
else
mp[sa] = aa = count++;
if (mp.count(sb))
bb = mp[sb];
else
mp[sb] = bb = count++;
edge e;
e.to = bb;
e.cost = cost;
dis[aa].push_back(e);
e.to = aa;
dis[bb].push_back(e);
// cout << sa << " " << aa << " " << sb <<" " << bb <<" " << cost << endl;
}
rep(i, 600) d[i] = 100000000;
priority_queue<pair<int, int>> que;
que.push(make_pair(0, 0));
while (!que.empty()) {
pair<int, int> now = que.top();
// cout << now.first << " " << now.second << endl;
que.pop();
if (now.first >= d[now.second])
continue;
d[now.second] = now.first;
rep(i, dis[now.second].size()) {
que.push(make_pair(now.first + dis[now.second][i].cost,
dis[now.second][i].to));
}
}
// cout << mp[a] << endl;
int res = d[mp[a]];
// cout << res << endl;
rep(i, 600) d[i] = 100000000;
que.push(make_pair(0, 1));
while (!que.empty()) {
pair<int, int> now = que.top();
// cout << now.first << " " << now.second << endl;
que.pop();
if (now.first >= d[now.second])
continue;
d[now.second] = now.first;
rep(i, dis[now.second].size()) {
que.push(make_pair(now.first + dis[now.second][i].cost,
dis[now.second][i].to));
}
}
res += d[mp[g]];
cout << res << endl;
}
} | #include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < int(n); ++i)
map<string, int> mp;
struct edge {
int to, cost;
};
vector<edge> dis[600];
int d[600];
int main() {
int n, m;
for (;;) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
string s, a, g;
rep(i, 600) dis[i].clear();
cin >> s >> a >> g;
mp.clear();
mp[s] = 0;
mp[a] = 1;
mp[g] = 2;
int count = 3;
rep(i, m) {
string sa, sb;
int cost, pen;
int aa, bb;
cin >> sa >> sb >> cost >> pen;
cost = cost / 40 + pen;
if (mp.count(sa))
aa = mp[sa];
else
mp[sa] = aa = count++;
if (mp.count(sb))
bb = mp[sb];
else
mp[sb] = bb = count++;
edge e;
e.to = bb;
e.cost = cost;
dis[aa].push_back(e);
e.to = aa;
dis[bb].push_back(e);
// cout << sa << " " << aa << " " << sb <<" " << bb <<" " << cost << endl;
}
rep(i, 600) d[i] = 100000000;
priority_queue<pair<int, int>, vector<pair<int, int>>,
greater<pair<int, int>>>
que;
que.push(make_pair(0, 0));
while (!que.empty()) {
pair<int, int> now = que.top();
// cout << now.first << " " << now.second << endl;
que.pop();
if (now.first >= d[now.second])
continue;
d[now.second] = now.first;
rep(i, dis[now.second].size()) {
que.push(make_pair(now.first + dis[now.second][i].cost,
dis[now.second][i].to));
}
}
// cout << mp[a] << endl;
int res = d[mp[a]];
// cout << res << endl;
rep(i, 600) d[i] = 100000000;
que.push(make_pair(0, 1));
while (!que.empty()) {
pair<int, int> now = que.top();
// cout << now.first << " " << now.second << endl;
que.pop();
if (now.first >= d[now.second])
continue;
d[now.second] = now.first;
rep(i, dis[now.second].size()) {
que.push(make_pair(now.first + dis[now.second][i].cost,
dis[now.second][i].to));
}
}
res += d[mp[g]];
cout << res << endl;
}
} | replace | 53 | 54 | 53 | 56 | TLE | |
p01401 | C++ | Runtime Error | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define fr first
#define sc second
typedef pair<int, int> P;
P s, g;
typedef pair<P, P> Q;
int h, w, sx, sy, gx, gy, c, dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0},
num[105][105];
bool used[25][105][105];
char wara[100];
int bfs();
int main() {
while (cin >> w >> h && w || h) {
memset(num, 0, sizeof(num));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> wara;
if (strcmp(wara, "S") == 0)
s = P(i, j);
else if (strcmp(wara, "G") == 0)
g = P(i, j);
else if (strcmp(wara, ".") != 0) {
c = max(c, atoi(wara));
num[i][j] = atoi(wara);
}
}
}
num[g.fr][g.sc] = c + 1;
cout << bfs() << endl;
c = 0;
}
}
int bfs() {
memset(used, false, sizeof(used));
queue<Q> que;
que.push(Q(s, P(1, 0)));
used[1][s.fr][s.sc] = true;
while (!que.empty()) {
Q q = que.front();
que.pop();
if (q.sc.fr == c + 1 && q.fr == g)
return q.sc.sc;
if (num[q.fr.fr][q.fr.sc] == q.sc.fr &&
!used[q.sc.fr + 1][q.fr.fr][q.fr.sc]) {
used[q.sc.fr + 1][q.fr.fr][q.fr.sc] = true;
q.sc.fr++;
}
for (int i = 0; i < 4; i++) {
int nx = q.fr.fr + dx[i], ny = q.fr.sc + dy[i];
bool flg = true;
if (nx >= 0 && nx < h && ny >= 0 && ny < w && !used[q.sc.fr][nx][ny]) {
used[q.sc.fr][nx][ny] = true;
que.push(Q(P(nx, ny), P(q.sc.fr + (flg ? 0 : 1), q.sc.sc + 1)));
}
}
}
return -1;
} | #include <algorithm>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
using namespace std;
#define fr first
#define sc second
typedef pair<int, int> P;
P s, g;
typedef pair<P, P> Q;
int h, w, sx, sy, gx, gy, c, dx[] = {0, 1, 0, -1}, dy[] = {1, 0, -1, 0},
num[105][105];
bool used[2500][105][105];
char wara[100];
int bfs();
int main() {
while (cin >> w >> h && w || h) {
memset(num, 0, sizeof(num));
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> wara;
if (strcmp(wara, "S") == 0)
s = P(i, j);
else if (strcmp(wara, "G") == 0)
g = P(i, j);
else if (strcmp(wara, ".") != 0) {
c = max(c, atoi(wara));
num[i][j] = atoi(wara);
}
}
}
num[g.fr][g.sc] = c + 1;
cout << bfs() << endl;
c = 0;
}
}
int bfs() {
memset(used, false, sizeof(used));
queue<Q> que;
que.push(Q(s, P(1, 0)));
used[1][s.fr][s.sc] = true;
while (!que.empty()) {
Q q = que.front();
que.pop();
if (q.sc.fr == c + 1 && q.fr == g)
return q.sc.sc;
if (num[q.fr.fr][q.fr.sc] == q.sc.fr &&
!used[q.sc.fr + 1][q.fr.fr][q.fr.sc]) {
used[q.sc.fr + 1][q.fr.fr][q.fr.sc] = true;
q.sc.fr++;
}
for (int i = 0; i < 4; i++) {
int nx = q.fr.fr + dx[i], ny = q.fr.sc + dy[i];
bool flg = true;
if (nx >= 0 && nx < h && ny >= 0 && ny < w && !used[q.sc.fr][nx][ny]) {
used[q.sc.fr][nx][ny] = true;
que.push(Q(P(nx, ny), P(q.sc.fr + (flg ? 0 : 1), q.sc.sc + 1)));
}
}
}
return -1;
} | replace | 15 | 16 | 15 | 16 | 0 | |
p01401 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MAX_V = 10000;
int w, h;
struct Edge {
int to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
map<pair<P, string>, int> ids;
vector<Edge> G[MAX_V];
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int to_id(P p, string s) {
pair<P, string> ps = pair<P, string>(p, s);
if (!ids.count(ps))
ids[ps] = ids.size();
return ids[ps];
}
int d[MAX_V];
int dijk(int s, int t) {
rep(i, MAX_V) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, s));
while (que.size()) {
P p = que.top();
que.pop();
int v = p.sc;
int cost = p.fr;
rep(i, G[v].size()) {
Edge e = G[v][i];
if (chmin(d[e.to], d[v] + e.cost)) {
que.push(P(d[e.to], e.to));
}
}
}
return d[t];
}
int diff(P p1, P p2) { return abs(p1.fr - p2.fr) + abs(p1.sc - p2.sc); }
string to_s(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int to_i(string &s) {
int ret;
stringstream ss;
ss << s;
ss >> ret;
return ret;
}
string maze[102][102];
void solve() {
rep(i, MAX_V) G[i].clear();
rep(i, h) rep(j, w) cin >> maze[i][j];
map<string, set<P>> points;
vector<int> vec;
rep(y, h) rep(x, w) {
if (maze[y][x] != ".")
points[maze[y][x]].insert(P(y, x));
if (maze[y][x] != "." && maze[y][x] != "S" && maze[y][x] != "G")
vec.pb(to_i(maze[y][x]));
}
sort(all(vec));
vec.erase(unique(all(vec)), vec.end());
/*
to_id("S");
rep(i,vec.size()) to_id(to_s(vec[i]));
to_id("G");
// */
rep(i, vec.size() + 1) {
string s = to_s(i);
string t = to_s(i + 1);
if (i == 0)
s = "S";
if (i == vec.size())
t = "G";
for (auto &e1 : points[s]) {
for (auto &e2 : points[t]) {
// cout<<s<<" -> "<<t<<" : "<<diff(e1,e2)<<endl;
G[to_id(e1, s)].pb(Edge(to_id(e2, t), diff(e1, e2)));
}
}
}
cout << dijk(to_id(*points["S"].begin(), "S"),
to_id(*points["G"].begin(), "G"))
<< endl;
}
int main() {
while (cin >> w >> h) {
if (w + h == 0)
break;
solve();
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef pair<int, int> P;
typedef long long ll;
const int MAX_V = 30000;
int w, h;
struct Edge {
int to, cost;
Edge(int to, int cost) : to(to), cost(cost) {}
};
map<pair<P, string>, int> ids;
vector<Edge> G[MAX_V];
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return true;
}
return false;
}
int to_id(P p, string s) {
pair<P, string> ps = pair<P, string>(p, s);
if (!ids.count(ps))
ids[ps] = ids.size();
return ids[ps];
}
int d[MAX_V];
int dijk(int s, int t) {
rep(i, MAX_V) d[i] = INF;
d[s] = 0;
priority_queue<P, vector<P>, greater<P>> que;
que.push(P(0, s));
while (que.size()) {
P p = que.top();
que.pop();
int v = p.sc;
int cost = p.fr;
rep(i, G[v].size()) {
Edge e = G[v][i];
if (chmin(d[e.to], d[v] + e.cost)) {
que.push(P(d[e.to], e.to));
}
}
}
return d[t];
}
int diff(P p1, P p2) { return abs(p1.fr - p2.fr) + abs(p1.sc - p2.sc); }
string to_s(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int to_i(string &s) {
int ret;
stringstream ss;
ss << s;
ss >> ret;
return ret;
}
string maze[102][102];
void solve() {
rep(i, MAX_V) G[i].clear();
rep(i, h) rep(j, w) cin >> maze[i][j];
map<string, set<P>> points;
vector<int> vec;
rep(y, h) rep(x, w) {
if (maze[y][x] != ".")
points[maze[y][x]].insert(P(y, x));
if (maze[y][x] != "." && maze[y][x] != "S" && maze[y][x] != "G")
vec.pb(to_i(maze[y][x]));
}
sort(all(vec));
vec.erase(unique(all(vec)), vec.end());
/*
to_id("S");
rep(i,vec.size()) to_id(to_s(vec[i]));
to_id("G");
// */
rep(i, vec.size() + 1) {
string s = to_s(i);
string t = to_s(i + 1);
if (i == 0)
s = "S";
if (i == vec.size())
t = "G";
for (auto &e1 : points[s]) {
for (auto &e2 : points[t]) {
// cout<<s<<" -> "<<t<<" : "<<diff(e1,e2)<<endl;
G[to_id(e1, s)].pb(Edge(to_id(e2, t), diff(e1, e2)));
}
}
}
cout << dijk(to_id(*points["S"].begin(), "S"),
to_id(*points["G"].begin(), "G"))
<< endl;
}
int main() {
while (cin >> w >> h) {
if (w + h == 0)
break;
solve();
}
return 0;
} | replace | 33 | 34 | 33 | 34 | 0 | |
p01401 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define p pair<int, int>
#define P pair<p, int>
using namespace std;
int parse(string a) {
int b = 0;
for (char c : a)
b = b * 10 + c - 48;
return b;
}
int main() {
int a, b;
while (cin >> b >> a, a | b) {
p G;
vector<P> d[102];
int MAX = 0;
for (int e = 0; e < a; e++) {
for (int g = 0; g < b; g++) {
string o;
cin >> o;
if (o == "S")
d[0].push_back(P(p(e, g), 0));
else if (o == "G")
G = p(e, g);
else if (o != ".") {
d[parse(o)].push_back(P(p(e, g), 0));
MAX = max(MAX, parse(o));
}
}
}
for (int i = 1; i <= MAX; i++) {
for (int j = 0; j < d[i].size(); j++) {
int MIN = 1 << 29;
for (int k = 0; k < d[i - 1].size(); k++) {
MIN = min(MIN,
d[i - 1][k].second +
abs(d[i][j].first.first - d[i - 1][k].first.first) +
abs(d[i][j].first.second - d[i - 1][k].first.second));
}
d[i][j].second = MIN;
}
}
int MINCOST = 1 << 29;
for (P s : d[MAX]) {
MINCOST = min(MINCOST, s.second + abs(G.first - s.first.first) +
abs(G.second - s.first.second));
}
cout << MINCOST << endl;
}
} | #include <algorithm>
#include <iostream>
#include <string>
#include <vector>
#define p pair<int, int>
#define P pair<p, int>
using namespace std;
int parse(string a) {
int b = 0;
for (char c : a)
b = b * 10 + c - 48;
return b;
}
int main() {
int a, b;
while (cin >> b >> a, a | b) {
p G;
vector<P> d[20000];
int MAX = 0;
for (int e = 0; e < a; e++) {
for (int g = 0; g < b; g++) {
string o;
cin >> o;
if (o == "S")
d[0].push_back(P(p(e, g), 0));
else if (o == "G")
G = p(e, g);
else if (o != ".") {
d[parse(o)].push_back(P(p(e, g), 0));
MAX = max(MAX, parse(o));
}
}
}
for (int i = 1; i <= MAX; i++) {
for (int j = 0; j < d[i].size(); j++) {
int MIN = 1 << 29;
for (int k = 0; k < d[i - 1].size(); k++) {
MIN = min(MIN,
d[i - 1][k].second +
abs(d[i][j].first.first - d[i - 1][k].first.first) +
abs(d[i][j].first.second - d[i - 1][k].first.second));
}
d[i][j].second = MIN;
}
}
int MINCOST = 1 << 29;
for (P s : d[MAX]) {
MINCOST = min(MINCOST, s.second + abs(G.first - s.first.first) +
abs(G.second - s.first.second));
}
cout << MINCOST << endl;
}
} | replace | 18 | 19 | 18 | 19 | 0 | |
p01401 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#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;
typedef unsigned int UI;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef istringstream ISS;
typedef ostringstream OSS;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define FOR(v, c) for (auto &v : c)
#define ITER(c) __typeof((c).begin())
#define EACH(it, c) for (ITER(c) it = c.begin(); it != c.end(); ++it)
#define ALL(c) (c).begin(), (c).end()
#define PB(n) push_back(n)
#define MP(a, b) make_pair((a), (b))
#define EXIST(c, e) ((c).find(e) != (c).end())
#define fst first
#define snd second
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) \
cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << (x) << endl
int distance(const PII &a, const PII &b) {
return abs(a.fst - b.fst) + abs(a.snd - b.snd);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int w, h;
cin >> w >> h;
if (!(w | h)) {
break;
}
vector<VS> board(h, VS(w));
FOR(line, board) {
FOR(word, line) { cin >> word; }
}
int n = 0, maxsize = 0;
PII s, g;
map<int, vector<PII>> index;
REP(i, 0, h) {
REP(j, 0, w) {
if (board[i][j] == ".") {
continue;
} else if (board[i][j] == "S") {
s = MP(i, j);
} else if (board[i][j] == "G") {
g = MP(i, j);
} else {
ISS iss(board[i][j]);
int num;
iss >> num;
index[num].PB(MP(i, j));
n = max(n, num);
maxsize = max(maxsize, (int)index[num].size());
}
}
}
index[0].PB(s);
index[n + 1].PB(g);
VVI dp(n + 2, VI(maxsize, INT_MAX));
dp[0][0] = 0;
REP(i, 0, n + 1) {
REP(f, 0, index[i].size()) {
REP(t, 0, index[i + 1].size()) {
dp[i + 1][t] = min(dp[i + 1][t],
dp[i][f] + distance(index[i][f], index[i + 1][t]));
}
}
}
cout << dp[n + 1][0] << endl;
}
return 0;
} | #include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#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;
typedef unsigned int UI;
typedef long long LL;
typedef unsigned long long ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef istringstream ISS;
typedef ostringstream OSS;
#define REP(i, m, n) for (int i = (int)(m); i < (int)(n); ++i)
#define FOR(v, c) for (auto &v : c)
#define ITER(c) __typeof((c).begin())
#define EACH(it, c) for (ITER(c) it = c.begin(); it != c.end(); ++it)
#define ALL(c) (c).begin(), (c).end()
#define PB(n) push_back(n)
#define MP(a, b) make_pair((a), (b))
#define EXIST(c, e) ((c).find(e) != (c).end())
#define fst first
#define snd second
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define DEBUG(x) \
cerr << __FILE__ << ":" << __LINE__ << ": " << #x << " = " << (x) << endl
int distance(const PII &a, const PII &b) {
return abs(a.fst - b.fst) + abs(a.snd - b.snd);
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (true) {
int w, h;
cin >> w >> h;
if (!(w | h)) {
break;
}
vector<VS> board(h, VS(w));
FOR(line, board) {
FOR(word, line) { cin >> word; }
}
int n = 0, maxsize = 1;
PII s, g;
map<int, vector<PII>> index;
REP(i, 0, h) {
REP(j, 0, w) {
if (board[i][j] == ".") {
continue;
} else if (board[i][j] == "S") {
s = MP(i, j);
} else if (board[i][j] == "G") {
g = MP(i, j);
} else {
ISS iss(board[i][j]);
int num;
iss >> num;
index[num].PB(MP(i, j));
n = max(n, num);
maxsize = max(maxsize, (int)index[num].size());
}
}
}
index[0].PB(s);
index[n + 1].PB(g);
VVI dp(n + 2, VI(maxsize, INT_MAX));
dp[0][0] = 0;
REP(i, 0, n + 1) {
REP(f, 0, index[i].size()) {
REP(t, 0, index[i + 1].size()) {
dp[i + 1][t] = min(dp[i + 1][t],
dp[i][f] + distance(index[i][f], index[i + 1][t]));
}
}
}
cout << dp[n + 1][0] << endl;
}
return 0;
} | replace | 71 | 72 | 71 | 72 | 0 | |
p01401 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, s, e) for (int i = (int)s; i < (int)e; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
#define pb push_back
#define mp nake_pair
typedef long long ll;
typedef vector<int> vi;
string s;
int perseInt(const string &s) {
int ret = 0;
rep(i, s.size()) ret = ret * 10 + (s[i] - '0');
return ret;
}
struct P {
int x, y;
P(){};
P(int x, int y) : x(x), y(y){};
int dist(const P &p) { return abs(x - p.x) + abs(y - p.y); }
};
vector<P> ps[2600];
int main() {
int w, h;
while (cin >> w >> h && w && h) {
int m = 0;
P g;
rep(i, 10010) ps[i].clear();
rep(i, h) rep(j, w) {
cin >> s;
if (s == ".")
continue;
else if (s == "S")
ps[0].pb({i, j});
else if (s == "G")
g = {i, j};
else {
int k = perseInt(s);
ps[k].pb({i, j});
m = max(m, k);
}
}
ps[++m].pb(g);
vector<vi> d(2600, vi(2600, 1e9));
d[0][0] = 0;
rep(i, m) {
rep(j, ps[i].size()) {
rep(k, ps[i + 1].size()) {
d[i + 1][k] = min(d[i + 1][k], d[i][j] + ps[i][j].dist(ps[i + 1][k]));
}
}
}
cout << d[m][0] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, s, e) for (int i = (int)s; i < (int)e; i++)
#define rep(i, n) REP(i, 0, n)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define fi first
#define se second
#define pb push_back
#define mp nake_pair
typedef long long ll;
typedef vector<int> vi;
string s;
int perseInt(const string &s) {
int ret = 0;
rep(i, s.size()) ret = ret * 10 + (s[i] - '0');
return ret;
}
struct P {
int x, y;
P(){};
P(int x, int y) : x(x), y(y){};
int dist(const P &p) { return abs(x - p.x) + abs(y - p.y); }
};
vector<P> ps[2600];
int main() {
int w, h;
while (cin >> w >> h && w && h) {
int m = 0;
P g;
rep(i, 2600) ps[i].clear();
rep(i, h) rep(j, w) {
cin >> s;
if (s == ".")
continue;
else if (s == "S")
ps[0].pb({i, j});
else if (s == "G")
g = {i, j};
else {
int k = perseInt(s);
ps[k].pb({i, j});
m = max(m, k);
}
}
ps[++m].pb(g);
vector<vi> d(2600, vi(2600, 1e9));
d[0][0] = 0;
rep(i, m) {
rep(j, ps[i].size()) {
rep(k, ps[i + 1].size()) {
d[i + 1][k] = min(d[i + 1][k], d[i][j] + ps[i][j].dist(ps[i + 1][k]));
}
}
}
cout << d[m][0] << endl;
}
} | replace | 36 | 37 | 36 | 37 | -11 | |
p01403 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
const int inf = 1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
int out[10000100] = {0};
int dp[10000100] = {0};
#define MAX 10000100
int main() {
out[1] = 2;
rep(i, MAX) dp[i] = i;
for (int i = 2; i < MAX; i++) {
if (dp[i] == i) {
for (int j = i; j < MAX; j += i)
dp[j] = dp[j] / i * (i - 1);
}
}
for (int i = 2; i < MAX; i++)
out[i] = out[i - 1] + dp[i];
int n;
cin >> n;
while (n--) {
int a;
cin >> a;
cout << out[a] << endl;
}
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define pb push_back
#define mp make_pair
#define all(in) in.begin(), in.end()
const double PI = acos(-1);
const double EPS = 1e-10;
const int inf = 1e9;
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
ll out[1000100] = {0};
ll dp[1000100] = {0};
#define MAX 1000100
int main() {
out[1] = 2;
rep(i, MAX) dp[i] = i;
for (int i = 2; i < MAX; i++) {
if (dp[i] == i) {
for (int j = i; j < MAX; j += i)
dp[j] = dp[j] / i * (i - 1);
}
}
for (int i = 2; i < MAX; i++)
out[i] = out[i - 1] + dp[i];
int n;
cin >> n;
while (n--) {
int a;
cin >> a;
cout << out[a] << endl;
}
} | replace | 24 | 27 | 24 | 27 | MLE | |
p01403 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define IINF (INT_MAX)
#define MAX_N 1000100
using namespace std;
typedef unsigned long long ll;
ll euler_phi(ll n) {
ll res = n;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
res = res / i * (i - 1);
for (; n % i == 0; n /= i)
;
}
}
if (n != 1)
res = res / n * (n - 1);
return res;
}
ll euler[MAX_N];
ll answer[MAX_N];
void euler_phi2() {
for (ll i = 0; i < MAX_N; i++)
euler[i] = i;
for (ll i = 2; i < MAX_N; i++) {
if (euler[i] == i) {
for (ll j = i; j < MAX_N; j += i)
euler[j] = euler[j] / i * (i - 1);
}
}
}
int main() {
euler_phi2();
answer[1] = 2;
REP(i, 2, MAX_N) answer[i] = answer[i - 1] + euler[i];
int t, n;
while (scanf("%d", &t), t)
rep(_, t) {
scanf("%d", &n);
printf("%lld\n", answer[n]);
}
return 0;
} | #include <bits/stdc++.h>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define IINF (INT_MAX)
#define MAX_N 1000100
using namespace std;
typedef unsigned long long ll;
ll euler_phi(ll n) {
ll res = n;
for (ll i = 2; i * i <= n; i++) {
if (n % i == 0) {
res = res / i * (i - 1);
for (; n % i == 0; n /= i)
;
}
}
if (n != 1)
res = res / n * (n - 1);
return res;
}
ll euler[MAX_N];
ll answer[MAX_N];
void euler_phi2() {
for (ll i = 0; i < MAX_N; i++)
euler[i] = i;
for (ll i = 2; i < MAX_N; i++) {
if (euler[i] == i) {
for (ll j = i; j < MAX_N; j += i)
euler[j] = euler[j] / i * (i - 1);
}
}
}
int main() {
euler_phi2();
answer[1] = 2;
REP(i, 2, MAX_N) answer[i] = answer[i - 1] + euler[i];
int t, n;
scanf("%d", &t);
rep(_, t) {
scanf("%d", &n);
printf("%lld\n", answer[n]);
}
return 0;
} | replace | 44 | 49 | 44 | 49 | TLE | |
p01407 | C++ | Memory Limit Exceeded | #define NDEBUG
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
template <class T> struct PrimalDual {
struct Edge {
int to, rev;
T cap, cost;
};
const int n;
const T inf = numeric_limits<T>::max();
VV<Edge> g;
V<T> pot, dist;
V<> pv, pe;
PrimalDual(int n) : n(n), g(n), pot(n), dist(n), pv(n), pe(n) {}
void add_edge(int from, int to, T cap, T cost) {
assert(from != to);
assert(cap >= 0);
assert(cost >= 0);
g[from].emplace_back(Edge{to, (int)g[to].size(), cap, cost});
g[to].emplace_back(Edge{from, (int)g[from].size() - 1, 0, -cost});
}
void dijkstra(int s) {
using P = pair<T, int>;
priority_queue<P, V<P>, greater<P>> pque;
fill(begin(dist), end(dist), inf);
pque.emplace(dist[s] = 0, s);
while (!pque.empty()) {
T d;
int v;
tie(d, v) = pque.top();
pque.pop();
if (d > dist[v])
continue;
for (int i = 0; i < g[v].size(); ++i) {
const Edge &e = g[v][i];
if (e.cap <= 0 or dist[e.to] <= dist[v] + e.cost - (pot[e.to] - pot[v]))
continue;
pv[e.to] = v;
pe[e.to] = i;
pque.emplace(dist[e.to] = dist[v] + e.cost - (pot[e.to] - pot[v]),
e.to);
}
}
}
T min_cost_flow(int s, int t, T f) {
assert(s != t);
assert(f >= 0);
T res = 0;
// fill(begin(pot), end(pot), 0);
while (f > 0) {
dijkstra(s);
if (dist[t] == inf)
return -1;
for (int v = 0; v < n; ++v)
pot[v] += dist[v];
T d = f;
for (int v = t; v != s; v = pv[v]) {
d = min(d, g[pv[v]][pe[v]].cap);
}
f -= d;
res += d * pot[t];
for (int v = t; v != s; v = pv[v]) {
Edge &e = g[pv[v]][pe[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, v, xl, xr;
cin >> n >> v >> xl >> xr;
PrimalDual<lint> g(2 * n + 4);
int sl = 2 * n, sr = 2 * n + 1, S = 2 * n + 2, T = 2 * n + 3;
g.add_edge(S, sl, 1, 0);
g.add_edge(sl, T, 1, 0);
g.add_edge(S, sr, 1, 0);
g.add_edge(sr, T, 1, 0);
V<> x(n), t(n), p(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> t[i] >> p[i];
if (abs(x[i] - xl) <= v * t[i]) {
g.add_edge(sl, 2 * i, 1, 0);
}
if (abs(x[i] - xr) <= v * t[i]) {
g.add_edge(sr, 2 * i, 1, 0);
}
g.add_edge(2 * i + 1, T, 1, 0);
g.add_edge(2 * i, 2 * i + 1, 1, -p[i]);
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (t[i] < t[j]) {
if (abs(x[j] - x[i]) <= v * (t[j] - t[i])) {
g.add_edge(2 * i + 1, 2 * j, 1, 0);
}
}
V<> idx{S, sl, sr};
{
V<> ii(n);
iota(begin(ii), end(ii), 0);
sort(begin(ii), end(ii), [&](int i, int j) { return t[i] < t[j]; });
for (int i : ii) {
idx.push_back(2 * i);
idx.push_back(2 * i + 1);
}
idx.push_back(T);
assert(idx.size() == g.size());
}
g.pot[S] = 0;
for (int i : idx) {
for (const auto &e : g.g[i])
if (e.cap > 0) {
g.pot[e.to] = min(g.pot[e.to], g.pot[i] + e.cost);
}
}
cout << -g.min_cost_flow(S, T, 2) << '\n';
}
| #define NDEBUG
#include <bits/stdc++.h>
using namespace std;
using lint = long long;
template <class T = int> using V = vector<T>;
template <class T = int> using VV = V<V<T>>;
template <class T> struct PrimalDual {
struct Edge {
int to, rev;
T cap, cost;
};
const int n;
const T inf = numeric_limits<T>::max();
VV<Edge> g;
V<T> pot, dist;
V<> pv, pe;
PrimalDual(int n) : n(n), g(n), pot(n), dist(n), pv(n), pe(n) {}
void add_edge(int from, int to, T cap, T cost) {
assert(from != to);
assert(cap >= 0);
assert(cost >= 0);
g[from].emplace_back(Edge{to, (int)g[to].size(), cap, cost});
g[to].emplace_back(Edge{from, (int)g[from].size() - 1, 0, -cost});
}
void dijkstra(int s) {
using P = pair<T, int>;
priority_queue<P, V<P>, greater<P>> pque;
fill(begin(dist), end(dist), inf);
pque.emplace(dist[s] = 0, s);
while (!pque.empty()) {
T d;
int v;
tie(d, v) = pque.top();
pque.pop();
if (d > dist[v])
continue;
for (int i = 0; i < g[v].size(); ++i) {
const Edge &e = g[v][i];
if (e.cap <= 0 or dist[e.to] <= dist[v] + e.cost - (pot[e.to] - pot[v]))
continue;
pv[e.to] = v;
pe[e.to] = i;
pque.emplace(dist[e.to] = dist[v] + e.cost - (pot[e.to] - pot[v]),
e.to);
}
}
}
T min_cost_flow(int s, int t, T f) {
assert(s != t);
assert(f >= 0);
T res = 0;
// fill(begin(pot), end(pot), 0);
while (f > 0) {
dijkstra(s);
if (dist[t] == inf)
return -1;
for (int v = 0; v < n; ++v)
pot[v] += dist[v];
T d = f;
for (int v = t; v != s; v = pv[v]) {
d = min(d, g[pv[v]][pe[v]].cap);
}
f -= d;
res += d * pot[t];
for (int v = t; v != s; v = pv[v]) {
Edge &e = g[pv[v]][pe[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
};
int main() {
cin.tie(nullptr);
ios::sync_with_stdio(false);
int n, v, xl, xr;
cin >> n >> v >> xl >> xr;
PrimalDual<int> g(2 * n + 4);
int sl = 2 * n, sr = 2 * n + 1, S = 2 * n + 2, T = 2 * n + 3;
g.add_edge(S, sl, 1, 0);
g.add_edge(sl, T, 1, 0);
g.add_edge(S, sr, 1, 0);
g.add_edge(sr, T, 1, 0);
V<> x(n), t(n), p(n);
for (int i = 0; i < n; ++i) {
cin >> x[i] >> t[i] >> p[i];
if (abs(x[i] - xl) <= v * t[i]) {
g.add_edge(sl, 2 * i, 1, 0);
}
if (abs(x[i] - xr) <= v * t[i]) {
g.add_edge(sr, 2 * i, 1, 0);
}
g.add_edge(2 * i + 1, T, 1, 0);
g.add_edge(2 * i, 2 * i + 1, 1, -p[i]);
}
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
if (t[i] < t[j]) {
if (abs(x[j] - x[i]) <= v * (t[j] - t[i])) {
g.add_edge(2 * i + 1, 2 * j, 1, 0);
}
}
V<> idx{S, sl, sr};
{
V<> ii(n);
iota(begin(ii), end(ii), 0);
sort(begin(ii), end(ii), [&](int i, int j) { return t[i] < t[j]; });
for (int i : ii) {
idx.push_back(2 * i);
idx.push_back(2 * i + 1);
}
idx.push_back(T);
assert(idx.size() == g.size());
}
g.pot[S] = 0;
for (int i : idx) {
for (const auto &e : g.g[i])
if (e.cap > 0) {
g.pot[e.to] = min(g.pot[e.to], g.pot[i] + e.cost);
}
}
cout << -g.min_cost_flow(S, T, 2) << '\n';
}
| replace | 80 | 81 | 80 | 81 | MLE | |
p01407 | C++ | Runtime Error | #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 popcount(n) (__builtin_popcountll(n))
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;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
using edge = struct {
int to, cap, cost, rev;
};
using G = vector<vector<edge>>;
const int inf = 1 << 29;
void add_edge(G &graph, int a, int b, int c, int d) {
graph[a].push_back({b, c, d, int(graph[b].size())});
graph[b].push_back({a, 0, -d, int(graph[a].size() - 1)});
}
using ord = tuple<int, int>;
vector<ord> top;
int min_cost_flow(G &graph, int s, int t, int f) {
const int n = graph.size();
vector<int> h(n, 0);
rep(i, n) {
int v = get<1>(top[i]);
for (auto &e : graph[v]) {
if (e.cap > 0)
chmin(h[e.to], h[v] + e.cost);
}
}
int res = 0;
while (f) {
cerr << f << endl;
vector<int> dist(n, inf), pv(n, 0), pe(n, 0);
using state = tuple<int, int>;
priority_queue<state, vector<state>, greater<state>> q;
dist[s] = 0, q.push(state(0, s));
while (!q.empty()) {
int c, v;
tie(c, v) = q.top();
q.pop();
if (dist[v] < c)
continue;
rep(i, graph[v].size()) {
edge &e = graph[v][i];
if (e.cap > 0 && chmin(dist[e.to], dist[v] + e.cost + h[v] - h[e.to])) {
pv[e.to] = v, pe[e.to] = i;
q.push(state(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1;
rep(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = pv[v])
chmin(d, graph[pv[v]][pe[v]].cap);
f -= d, res += d * h[t];
for (int v = t; v != s; v = pv[v]) {
edge &e = graph[pv[v]][pe[v]];
e.cap -= d;
graph[v][e.rev].cap += d;
}
}
return res;
}
int x[3010], t[3010], p[3010];
int main(void) {
int n, v, xl, xr;
cin >> n >> v >> xl >> xr;
const int src = 2 * n, dst = src + 1, l = dst + 1, r = l + 1, all = r + 1;
G graph(all);
top.push_back(ord(0, src));
top.push_back(ord(0, l));
top.push_back(ord(0, r));
top.push_back(ord(inf, dst));
rep(i, n) {
cin >> x[i] >> t[i] >> p[i];
top.push_back(ord(t[i], i));
top.push_back(ord(t[i], n + i));
}
sort(_all(top));
add_edge(graph, src, l, 1, 0);
add_edge(graph, src, r, 1, 0);
add_edge(graph, src, dst, 2, 0);
rep(i, n) {
if (abs(xl - x[i]) <= v * t[i])
add_edge(graph, l, i, 1, 0);
if (abs(xr - x[i]) <= v * t[i])
add_edge(graph, r, i, 1, 0);
add_edge(graph, i, i + n, 1, -p[i]);
add_edge(graph, i, i + n, 1, 0);
add_edge(graph, i + n, dst, 2, 0);
}
rep(i, n) rep(j, n) {
if (i == j)
continue;
if (abs(x[i] - x[j]) <= v * (t[j] - t[i]))
add_edge(graph, i + n, j, 2, 0);
}
cout << -min_cost_flow(graph, src, dst, 2) << 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 popcount(n) (__builtin_popcountll(n))
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;
const int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
const int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
using edge = struct {
int to, cap, cost, rev;
};
using G = vector<vector<edge>>;
const int inf = 1 << 29;
void add_edge(G &graph, int a, int b, int c, int d) {
graph[a].push_back({b, c, d, int(graph[b].size())});
graph[b].push_back({a, 0, -d, int(graph[a].size() - 1)});
}
using ord = tuple<int, int>;
vector<ord> top;
int min_cost_flow(G &graph, int s, int t, int f) {
const int n = graph.size();
vector<int> h(n, 0);
rep(i, n) {
int v = get<1>(top[i]);
for (auto &e : graph[v]) {
if (e.cap > 0)
chmin(h[e.to], h[v] + e.cost);
}
}
int res = 0;
while (f) {
vector<int> dist(n, inf), pv(n, 0), pe(n, 0);
using state = tuple<int, int>;
priority_queue<state, vector<state>, greater<state>> q;
dist[s] = 0, q.push(state(0, s));
while (!q.empty()) {
int c, v;
tie(c, v) = q.top();
q.pop();
if (dist[v] < c)
continue;
rep(i, graph[v].size()) {
edge &e = graph[v][i];
if (e.cap > 0 && chmin(dist[e.to], dist[v] + e.cost + h[v] - h[e.to])) {
pv[e.to] = v, pe[e.to] = i;
q.push(state(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1;
rep(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = pv[v])
chmin(d, graph[pv[v]][pe[v]].cap);
f -= d, res += d * h[t];
for (int v = t; v != s; v = pv[v]) {
edge &e = graph[pv[v]][pe[v]];
e.cap -= d;
graph[v][e.rev].cap += d;
}
}
return res;
}
int x[3010], t[3010], p[3010];
int main(void) {
int n, v, xl, xr;
cin >> n >> v >> xl >> xr;
const int src = 2 * n, dst = src + 1, l = dst + 1, r = l + 1, all = r + 1;
G graph(all);
top.push_back(ord(0, src));
top.push_back(ord(0, l));
top.push_back(ord(0, r));
top.push_back(ord(inf, dst));
rep(i, n) {
cin >> x[i] >> t[i] >> p[i];
top.push_back(ord(t[i], i));
top.push_back(ord(t[i], n + i));
}
sort(_all(top));
add_edge(graph, src, l, 1, 0);
add_edge(graph, src, r, 1, 0);
add_edge(graph, src, dst, 2, 0);
rep(i, n) {
if (abs(xl - x[i]) <= v * t[i])
add_edge(graph, l, i, 1, 0);
if (abs(xr - x[i]) <= v * t[i])
add_edge(graph, r, i, 1, 0);
add_edge(graph, i, i + n, 1, -p[i]);
add_edge(graph, i, i + n, 1, 0);
add_edge(graph, i + n, dst, 2, 0);
}
rep(i, n) rep(j, n) {
if (i == j)
continue;
if (abs(x[i] - x[j]) <= v * (t[j] - t[i]))
add_edge(graph, i + n, j, 2, 0);
}
cout << -min_cost_flow(graph, src, dst, 2) << endl;
return 0;
} | delete | 58 | 59 | 58 | 58 | 0 | 2
1
|
p01407 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mp make_pair
#define INF (1LL << 60)
typedef long long Int;
struct node {
int x, t, p;
};
bool operator<(const node &l, const node &r) {
return l.t != r.t ? l.t < r.t : l.x != r.x ? l.x < r.x : l.p < r.p;
}
int N, V, XL, XR;
node X[4000];
inline bool connect(int i, int j) {
return abs(X[j].x - X[i].x) <= (long long)V * abs(X[j].t - X[i].t);
}
pair<int, int> pre[10000];
int vis[10000];
Int h[10000];
vector<int> v[4000];
vector<Int> c[4000];
inline void add_edge(int _u, int _v, Int _c) {
v[_u].push_back(_v);
c[_u].push_back(_c);
}
int main() {
scanf("%d%d%d%d", &N, &V, &XL, &XR);
X[0].x = XL;
X[1].x = XR;
rep(i, N) scanf("%d%d%d", &X[i + 2].x, &X[i + 2].t, &X[i + 2].p);
N += 2;
sort(X, X + N);
rep(i, 2) add_edge(0, 2 + i * 2, 0);
rep(i, N) {
const int f = 2 + 2 * i + 1;
add_edge(f - 1, f, -X[i].p);
add_edge(f, 1, 0);
for (int j = i + 1; j < N; j++)
if (connect(i, j))
add_edge(f, 2 + j * 2, 0);
}
rep(i, N) h[2 + i * 2] = INF;
rep(i, 2) h[2 + i * 2] = 0, pre[2 + i * 2] = mp(0, i);
rep(i, N) {
const int f = 2 + i * 2 + 1;
h[f] = h[f - 1] - X[i].p;
pre[f] = mp(f - 1, 0);
rep(j, v[f].size()) if (h[v[f][j]] > h[f]) {
h[v[f][j]] = h[f];
pre[v[f][j]] = mp(f, j);
}
}
Int a = -h[1];
int cur = 1;
while (cur != 0) {
const int f = pre[cur].first;
const int k = pre[cur].second;
add_edge(cur, f, -c[f][k]);
c[f][k] = INF;
cur = f;
}
priority_queue<pair<Int, int>> q;
q.push(mp(0, 0));
while (!q.empty()) {
const pair<Int, int> vv(q.top());
q.pop();
const int cc = -vv.first;
const int ix = vv.second;
if (vis[ix])
continue;
vis[ix] = 1;
if (ix == 1) {
a -= h[1] + cc;
break;
}
rep(i, v[ix].size()) {
const Int nc = cc + c[ix][i] + h[ix] - h[v[ix][i]];
if (vis[v[ix][i]] == 0)
q.push(mp(-nc, v[ix][i]));
}
}
cout << a << endl;
return 0;
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mp make_pair
#define INF (1LL << 60)
typedef long long Int;
struct node {
int x, t, p;
};
bool operator<(const node &l, const node &r) {
return l.t != r.t ? l.t < r.t : l.x != r.x ? l.x < r.x : l.p < r.p;
}
int N, V, XL, XR;
node X[4000];
inline bool connect(int i, int j) {
return abs(X[j].x - X[i].x) <= (long long)V * abs(X[j].t - X[i].t);
}
pair<int, int> pre[10000];
int vis[10000];
Int h[10000];
vector<int> v[10000];
vector<Int> c[10000];
inline void add_edge(int _u, int _v, Int _c) {
v[_u].push_back(_v);
c[_u].push_back(_c);
}
int main() {
scanf("%d%d%d%d", &N, &V, &XL, &XR);
X[0].x = XL;
X[1].x = XR;
rep(i, N) scanf("%d%d%d", &X[i + 2].x, &X[i + 2].t, &X[i + 2].p);
N += 2;
sort(X, X + N);
rep(i, 2) add_edge(0, 2 + i * 2, 0);
rep(i, N) {
const int f = 2 + 2 * i + 1;
add_edge(f - 1, f, -X[i].p);
add_edge(f, 1, 0);
for (int j = i + 1; j < N; j++)
if (connect(i, j))
add_edge(f, 2 + j * 2, 0);
}
rep(i, N) h[2 + i * 2] = INF;
rep(i, 2) h[2 + i * 2] = 0, pre[2 + i * 2] = mp(0, i);
rep(i, N) {
const int f = 2 + i * 2 + 1;
h[f] = h[f - 1] - X[i].p;
pre[f] = mp(f - 1, 0);
rep(j, v[f].size()) if (h[v[f][j]] > h[f]) {
h[v[f][j]] = h[f];
pre[v[f][j]] = mp(f, j);
}
}
Int a = -h[1];
int cur = 1;
while (cur != 0) {
const int f = pre[cur].first;
const int k = pre[cur].second;
add_edge(cur, f, -c[f][k]);
c[f][k] = INF;
cur = f;
}
priority_queue<pair<Int, int>> q;
q.push(mp(0, 0));
while (!q.empty()) {
const pair<Int, int> vv(q.top());
q.pop();
const int cc = -vv.first;
const int ix = vv.second;
if (vis[ix])
continue;
vis[ix] = 1;
if (ix == 1) {
a -= h[1] + cc;
break;
}
rep(i, v[ix].size()) {
const Int nc = cc + c[ix][i] + h[ix] - h[v[ix][i]];
if (vis[v[ix][i]] == 0)
q.push(mp(-nc, v[ix][i]));
}
}
cout << a << endl;
return 0;
} | replace | 30 | 32 | 30 | 32 | 0 | |
p01407 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
typedef int Weight;
struct Edge {
int dest;
int cap, rev;
Weight weight;
bool operator<(const Edge &rhs) const { return weight > rhs.weight; }
};
const int V = 6010;
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
Weight h[V]; //??????????????£???
Weight dist[V]; //???????????¢
int prevv[V], preve[V]; //??´???????????¨??????
void add_edge(Graph &g, int src, int dest, int cap, Weight weight) {
g[src].push_back(Edge{dest, cap, (int)g[dest].size(), weight});
g[dest].push_back(Edge{src, 0, (int)g[src].size() - 1, -weight});
}
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const Weight INF = 1e9;
const Weight ZERO = 0;
//????????????double?????????eps?????????
Weight min_cost_flow(Graph &g, int s, int t, int f) {
Weight res = ZERO;
memset(h, ZERO, sizeof(h));
typedef pair<Weight, int> P;
REP(i, g.size() / 2 - 1) {
int v = i + 1;
REP(j, g[v].size()) {
Edge &e = g[v][j];
if (e.cap == 0)
continue;
int u = e.dest;
h[u] = min(h[u], h[v] + e.weight);
}
v = i + g.size() / 2 + 1;
REP(j, g[v].size()) {
Edge &e = g[v][j];
if (e.cap == 0)
continue;
int u = e.dest;
h[u] = min(h[u], h[v] + e.weight);
}
}
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(ZERO, s));
while (!que.empty()) {
P p = que.top();
que.pop();
const int v = p.second;
if (dist[v] < p.first)
continue;
REP(i, g[v].size()) {
Edge &e = g[v][i];
if (e.cap > 0 && dist[e.dest] > dist[v] + e.weight + h[v] - h[e.dest]) {
dist[e.dest] = dist[v] + e.weight + h[v] - h[e.dest];
prevv[e.dest] = v;
preve[e.dest] = i;
que.push(P(dist[e.dest], e.dest));
}
}
}
if (dist[t] == INF)
return -1;
REP(v, V) h[v] = h[v] + dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
res = res + d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
int V, Xl, Xr;
cin >> N >> V >> Xl >> Xr;
struct mogu {
int x;
long long int t;
long long int p;
};
vector<mogu> mogus;
mogus.push_back(mogu{Xl, 0, 0});
mogus.push_back(mogu{Xr, 0, 0});
for (int i = 0; i < N; ++i) {
int x, t, p;
cin >> x >> t >> p;
mogus.push_back(mogu{x, t, p});
}
sort(mogus.begin(), mogus.end(),
[](const mogu &l, const mogu &r) { return l.t < r.t; });
const int start = 0;
const int mo_in = start + 1;
const int mo_out = mo_in + N + 2;
const int goal = mo_out + N + 2;
Graph g(goal + 1);
add_edge(g, start, mo_in + 1, 1, 0);
add_edge(g, start, mo_in + 0, 1, 0);
for (int i = 0; i < N + 2; ++i) {
add_edge(g, mo_in + i, mo_out + i, 1, 0);
for (int j = i + 1; j < N + 2; ++j) {
const auto amogu(mogus[i]);
const auto bmogu(mogus[j]);
{
long long int time = bmogu.t - amogu.t;
if (time * V >= abs(bmogu.x - amogu.x)) {
add_edge(g, mo_out + i, mo_in + j, 1, -bmogu.p);
}
}
}
add_edge(g, mo_out + i, goal, 1, 0);
}
Weight ans = min_cost_flow(g, start, goal, 2);
cout << -ans << endl;
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
typedef int Weight;
struct Edge {
int dest;
int cap, rev;
Weight weight;
bool operator<(const Edge &rhs) const { return weight > rhs.weight; }
};
const int V = 6010;
typedef vector<Edge> Edges;
typedef vector<Edges> Graph;
typedef vector<Weight> Array;
typedef vector<Array> Matrix;
Weight h[V]; //??????????????£???
Weight dist[V]; //???????????¢
int prevv[V], preve[V]; //??´???????????¨??????
void add_edge(Graph &g, int src, int dest, int cap, Weight weight) {
g[src].push_back(Edge{dest, cap, (int)g[dest].size(), weight});
g[dest].push_back(Edge{src, 0, (int)g[src].size() - 1, -weight});
}
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) for (auto i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const Weight INF = 1e9;
const Weight ZERO = 0;
//????????????double?????????eps?????????
Weight min_cost_flow(Graph &g, int s, int t, int f) {
Weight res = ZERO;
memset(h, ZERO, sizeof(h));
typedef pair<Weight, int> P;
REP(i, g.size() / 2 - 1) {
int v = i + 2;
REP(j, g[v].size()) {
Edge &e = g[v][j];
if (e.cap == 0)
continue;
int u = e.dest;
h[u] = min(h[u], h[v] + e.weight);
}
v = i + g.size() / 2 + 1;
REP(j, g[v].size()) {
Edge &e = g[v][j];
if (e.cap == 0)
continue;
int u = e.dest;
h[u] = min(h[u], h[v] + e.weight);
}
}
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist, dist + V, INF);
dist[s] = 0;
que.push(P(ZERO, s));
while (!que.empty()) {
P p = que.top();
que.pop();
const int v = p.second;
if (dist[v] < p.first)
continue;
REP(i, g[v].size()) {
Edge &e = g[v][i];
if (e.cap > 0 && dist[e.dest] > dist[v] + e.weight + h[v] - h[e.dest]) {
dist[e.dest] = dist[v] + e.weight + h[v] - h[e.dest];
prevv[e.dest] = v;
preve[e.dest] = i;
que.push(P(dist[e.dest], e.dest));
}
}
}
if (dist[t] == INF)
return -1;
REP(v, V) h[v] = h[v] + dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, g[prevv[v]][preve[v]].cap);
f -= d;
res = res + d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = g[prevv[v]][preve[v]];
e.cap -= d;
g[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
int V, Xl, Xr;
cin >> N >> V >> Xl >> Xr;
struct mogu {
int x;
long long int t;
long long int p;
};
vector<mogu> mogus;
mogus.push_back(mogu{Xl, 0, 0});
mogus.push_back(mogu{Xr, 0, 0});
for (int i = 0; i < N; ++i) {
int x, t, p;
cin >> x >> t >> p;
mogus.push_back(mogu{x, t, p});
}
sort(mogus.begin(), mogus.end(),
[](const mogu &l, const mogu &r) { return l.t < r.t; });
const int start = 0;
const int mo_in = start + 1;
const int mo_out = mo_in + N + 2;
const int goal = mo_out + N + 2;
Graph g(goal + 1);
add_edge(g, start, mo_in + 1, 1, 0);
add_edge(g, start, mo_in + 0, 1, 0);
for (int i = 0; i < N + 2; ++i) {
add_edge(g, mo_in + i, mo_out + i, 1, 0);
for (int j = i + 1; j < N + 2; ++j) {
const auto amogu(mogus[i]);
const auto bmogu(mogus[j]);
{
long long int time = bmogu.t - amogu.t;
if (time * V >= abs(bmogu.x - amogu.x)) {
add_edge(g, mo_out + i, mo_in + j, 1, -bmogu.p);
}
}
}
add_edge(g, mo_out + i, goal, 1, 0);
}
Weight ans = min_cost_flow(g, start, goal, 2);
cout << -ans << endl;
return 0;
} | replace | 38 | 39 | 38 | 39 | TLE | |
p01407 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
os << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> void print(T a, int n, const string &split = " ") {
for (int i = 0; i < n; i++) {
cout << a[i];
if (i + 1 != n)
cout << split;
}
cout << endl;
}
template <typename T>
void print2d(T a, int w, int h, int width = -1, int br = 0) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <typename T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
#define dump(v) (cerr << #v << ": " << v << endl)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(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 clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))
template <typename T, typename U> void upmin(T &a, const U &b) {
a = min<T>(a, b);
}
template <typename T, typename U> void upmax(T &a, const U &b) {
a = max<T>(a, b);
}
template <typename T> void uniq(T &a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
template <typename FLOW, typename COST> class PrimalDual {
private:
struct PrimalDualEdge {
int to;
FLOW cap;
COST cost;
int rev;
PrimalDualEdge(int to, FLOW cap, COST cost, int rev)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
public:
int V;
vector<vector<PrimalDualEdge>> g;
PrimalDual(int V) : V(V), g(V) {}
void add_edge(int from, int to, FLOW cap, COST cost) {
g[from].push_back(PrimalDualEdge(to, cap, cost, g[to].size()));
g[to].push_back(PrimalDualEdge(from, 0, -cost, g[from].size() - 1));
}
void add_undirected(int a, int b, FLOW cap, COST cost) {
add_edge(a, b, cap, cost);
add_edge(b, a, cap, cost);
}
COST min_cost_flow(int s, int t, FLOW f) {
vector<COST> h(V);
COST res = 0;
int _f = f;
while (_f > 0) {
typedef pair<COST, int> _p;
const COST _INF = (COST)((1LL << 60) | (1 << 29));
priority_queue<_p, vector<_p>, greater<_p>> q;
vector<COST> dis(V, _INF);
vector<int> prevv(V), preve(V);
dis[s] = 0;
q.push(_p(0, s));
while (!q.empty()) {
_p p = q.top();
q.pop();
int v = p.second;
COST cost = p.first;
if (cost > dis[v])
continue;
for (int i = 0; i < g[v].size(); ++i) {
PrimalDualEdge &e = g[v][i];
const COST _eps = 1e-10;
COST c = cost + e.cost + h[v] - h[e.to];
if (e.cap > 0 && c + _eps < dis[e.to]) {
dis[e.to] = c;
prevv[e.to] = v;
preve[e.to] = i;
q.push(_p(c, e.to));
}
}
}
if (dis[t] == _INF) {
// cant flow _f
return _INF;
}
for (int i = 0; i < V; ++i)
h[i] += dis[i];
FLOW d = _f;
for (int i = t; i != s; i = prevv[i])
d = min(d, g[prevv[i]][preve[i]].cap);
_f -= d;
res += d * h[t];
for (int i = t; i != s; i = prevv[i]) {
PrimalDualEdge &e = g[prevv[i]][preve[i]];
e.cap -= d;
g[e.to][e.rev].cap += d;
}
}
return res;
}
COST min_cost_flow_spfa(int s, int t, FLOW f) {
COST res = 0;
int _f = f;
while (_f > 0) {
const COST _INF = (COST)((1LL << 60) | (1 << 29));
vector<COST> dis(V, _INF);
vector<int> prevv(V), preve(V);
vector<bool> in_q(V);
// queue<int> q;
priority_queue<int, vector<int>, greater<int>> q;
dis[s] = 0;
q.push(s);
in_q[s] = true;
while (!q.empty()) {
int v = q.top();
q.pop();
// int v = q.front(); q.pop();
COST cost = dis[v];
in_q[v] = false;
for (int i = 0; i < g[v].size(); ++i) {
PrimalDualEdge &e = g[v][i];
const COST _eps = 1e-10;
COST c = cost + e.cost;
if (e.cap > 0 && c + _eps < dis[e.to]) {
dis[e.to] = c;
prevv[e.to] = v;
preve[e.to] = i;
if (!in_q[e.to]) {
q.push(e.to);
in_q[e.to] = true;
}
}
}
}
if (dis[t] == _INF) {
// cant flow _f
return _INF;
}
FLOW d = _f;
for (int i = t; i != s; i = prevv[i])
d = min(d, g[prevv[i]][preve[i]].cap);
_f -= d;
res += d * dis[t];
for (int i = t; i != s; i = prevv[i]) {
PrimalDualEdge &e = g[prevv[i]][preve[i]];
e.cap -= d;
g[e.to][e.rev].cap += d;
}
}
return res;
}
};
int n;
int in(int i) { return 1 + 2 * i; }
int out(int i) { return in(i) + 1; }
int main() {
fast_io();
int x_left, x_right;
ll v;
cin >> n >> v >> x_left >> x_right;
int x[3333], t[3333], p[3333];
rep(i, n) cin >> x[i] >> t[i] >> p[i];
PrimalDual<int, int> pd(2 * n + 2 + 2);
int src = 0;
// int in = 1;
// int out = in + n;
// int left = out + n;
int left = 1 + 2 * n;
int right = left + 1;
int sink = right + 1;
pd.add_edge(src, sink, 2, 0);
pd.add_edge(src, left, 1, 0);
pd.add_edge(src, right, 1, 0);
rep(i, n) {
pd.add_edge(in(i), out(i), 1, -p[i]);
pd.add_edge(out(i), sink, 1, 0);
if (abs(x[i] - x_left) <= v * t[i])
pd.add_edge(left, in(i), 1, 0);
if (abs(x[i] - x_right) <= v * t[i])
pd.add_edge(right, in(i), 1, 0);
rep(j, n) {
if (t[i] < t[j]) {
if (abs(x[j] - x[i]) <= v * (t[j] - t[i]))
pd.add_edge(out(i), in(j), 1, 0);
}
}
}
int mcf = pd.min_cost_flow_spfa(src, sink, 2);
assert(mcf <= 0);
cout << -mcf << endl;
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
os << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "(" << p.first << ", " << p.second << ")";
return os;
}
template <typename T> void print(T a, int n, const string &split = " ") {
for (int i = 0; i < n; i++) {
cout << a[i];
if (i + 1 != n)
cout << split;
}
cout << endl;
}
template <typename T>
void print2d(T a, int w, int h, int width = -1, int br = 0) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <typename T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
#define dump(v) (cerr << #v << ": " << v << endl)
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define erep(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 clr(a, x) memset(a, x, sizeof(a))
#define sz(a) ((int)(a).size())
#define mp(a, b) make_pair(a, b)
#define ten(n) ((long long)(1e##n))
template <typename T, typename U> void upmin(T &a, const U &b) {
a = min<T>(a, b);
}
template <typename T, typename U> void upmax(T &a, const U &b) {
a = max<T>(a, b);
}
template <typename T> void uniq(T &a) {
sort(a.begin(), a.end());
a.erase(unique(a.begin(), a.end()), a.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
template <typename FLOW, typename COST> class PrimalDual {
private:
struct PrimalDualEdge {
int to;
FLOW cap;
COST cost;
int rev;
PrimalDualEdge(int to, FLOW cap, COST cost, int rev)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
public:
int V;
vector<vector<PrimalDualEdge>> g;
PrimalDual(int V) : V(V), g(V) {}
void add_edge(int from, int to, FLOW cap, COST cost) {
g[from].push_back(PrimalDualEdge(to, cap, cost, g[to].size()));
g[to].push_back(PrimalDualEdge(from, 0, -cost, g[from].size() - 1));
}
void add_undirected(int a, int b, FLOW cap, COST cost) {
add_edge(a, b, cap, cost);
add_edge(b, a, cap, cost);
}
COST min_cost_flow(int s, int t, FLOW f) {
vector<COST> h(V);
COST res = 0;
int _f = f;
while (_f > 0) {
typedef pair<COST, int> _p;
const COST _INF = (COST)((1LL << 60) | (1 << 29));
priority_queue<_p, vector<_p>, greater<_p>> q;
vector<COST> dis(V, _INF);
vector<int> prevv(V), preve(V);
dis[s] = 0;
q.push(_p(0, s));
while (!q.empty()) {
_p p = q.top();
q.pop();
int v = p.second;
COST cost = p.first;
if (cost > dis[v])
continue;
for (int i = 0; i < g[v].size(); ++i) {
PrimalDualEdge &e = g[v][i];
const COST _eps = 1e-10;
COST c = cost + e.cost + h[v] - h[e.to];
if (e.cap > 0 && c + _eps < dis[e.to]) {
dis[e.to] = c;
prevv[e.to] = v;
preve[e.to] = i;
q.push(_p(c, e.to));
}
}
}
if (dis[t] == _INF) {
// cant flow _f
return _INF;
}
for (int i = 0; i < V; ++i)
h[i] += dis[i];
FLOW d = _f;
for (int i = t; i != s; i = prevv[i])
d = min(d, g[prevv[i]][preve[i]].cap);
_f -= d;
res += d * h[t];
for (int i = t; i != s; i = prevv[i]) {
PrimalDualEdge &e = g[prevv[i]][preve[i]];
e.cap -= d;
g[e.to][e.rev].cap += d;
}
}
return res;
}
COST min_cost_flow_spfa(int s, int t, FLOW f) {
COST res = 0;
int _f = f;
while (_f > 0) {
const COST _INF = (COST)((1LL << 60) | (1 << 29));
vector<COST> dis(V, _INF);
vector<int> prevv(V), preve(V);
vector<bool> in_q(V);
// queue<int> q;
priority_queue<int, vector<int>, greater<int>> q;
dis[s] = 0;
q.push(s);
in_q[s] = true;
while (!q.empty()) {
int v = q.top();
q.pop();
// int v = q.front(); q.pop();
COST cost = dis[v];
in_q[v] = false;
for (int i = 0; i < g[v].size(); ++i) {
PrimalDualEdge &e = g[v][i];
const COST _eps = 1e-10;
COST c = cost + e.cost;
if (e.cap > 0 && c + _eps < dis[e.to]) {
dis[e.to] = c;
prevv[e.to] = v;
preve[e.to] = i;
if (!in_q[e.to]) {
q.push(e.to);
in_q[e.to] = true;
}
}
}
}
if (dis[t] == _INF) {
// cant flow _f
return _INF;
}
FLOW d = _f;
for (int i = t; i != s; i = prevv[i])
d = min(d, g[prevv[i]][preve[i]].cap);
_f -= d;
res += d * dis[t];
for (int i = t; i != s; i = prevv[i]) {
PrimalDualEdge &e = g[prevv[i]][preve[i]];
e.cap -= d;
g[e.to][e.rev].cap += d;
}
}
return res;
}
};
int n;
int in(int i) { return 1 + 2 * i; }
int out(int i) { return in(i) + 1; }
int main() {
fast_io();
int x_left, x_right;
ll v;
cin >> n >> v >> x_left >> x_right;
int x[3333], t[3333], p[3333];
vector<pair<int, pint>> a;
rep(i, n) {
cin >> x[i] >> t[i] >> p[i];
a.push_back(make_pair(t[i], pint(x[i], p[i])));
}
sort(all(a));
rep(i, n) {
t[i] = a[i].first;
x[i] = a[i].second.first;
p[i] = a[i].second.second;
}
PrimalDual<int, int> pd(2 * n + 2 + 2);
int src = 0;
// int in = 1;
// int out = in + n;
// int left = out + n;
int left = 1 + 2 * n;
int right = left + 1;
int sink = right + 1;
pd.add_edge(src, sink, 2, 0);
pd.add_edge(src, left, 1, 0);
pd.add_edge(src, right, 1, 0);
rep(i, n) {
pd.add_edge(in(i), out(i), 1, -p[i]);
pd.add_edge(out(i), sink, 1, 0);
if (abs(x[i] - x_left) <= v * t[i])
pd.add_edge(left, in(i), 1, 0);
if (abs(x[i] - x_right) <= v * t[i])
pd.add_edge(right, in(i), 1, 0);
rep(j, n) {
if (t[i] < t[j]) {
if (abs(x[j] - x[i]) <= v * (t[j] - t[i]))
pd.add_edge(out(i), in(j), 1, 0);
}
}
}
int mcf = pd.min_cost_flow_spfa(src, sink, 2);
assert(mcf <= 0);
cout << -mcf << endl;
} | replace | 291 | 292 | 291 | 302 | TLE | |
p01410 | C++ | Runtime Error | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mp make_pair
#define INF (1LL << 60)
struct MinCostFlow {
static const int N = 1024 * 4, M = 1024 * 8;
typedef long long cost_t;
int E, head[N], u[M], v[M], capa[M], rev[M], next[M];
cost_t cost[M];
int s, t, flow[M], prev[N];
cost_t r, h[N], dist[N];
void init() {
E = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int _u, int _v, int ca, cost_t co) {
u[E] = _u;
v[E] = _v;
capa[E] = ca;
cost[E] = co;
rev[E] = E + 1, next[E] = head[u[E]];
head[u[E]] = E;
E++;
u[E] = _v;
v[E] = _u;
capa[E] = 0;
cost[E] = -co;
rev[E] = E - 1, next[E] = head[u[E]];
head[u[E]] = E;
E++;
}
void ready(int _s, int _t) {
s = _s;
t = _t;
r = 0;
memset(flow, 0, sizeof(flow));
memset(h, 0, sizeof(h));
}
cost_t min_cost() { return r; }
bool pour(int f) {
while (f > 0) {
priority_queue<pair<cost_t, int>> q;
std::fill_n(dist, N, INF);
dist[s] = 0;
q.push(mp(0, s));
while (!q.empty()) {
pair<cost_t, int> z(q.top());
q.pop();
int cur = z.second;
if (dist[cur] < -z.first)
continue;
for (int x = head[cur]; x != -1; x = next[x])
if (capa[x] - flow[x] > 0) {
if (dist[v[x]] > dist[cur] + cost[x] + h[cur] - h[v[x]]) {
dist[v[x]] = dist[cur] + cost[x] + h[cur] - h[v[x]];
prev[v[x]] = x;
q.push(mp(-dist[v[x]], v[x]));
}
}
}
if (dist[t] == INF)
return false;
rep(i, N) h[i] += dist[i];
int d = f;
for (int cur = t; cur != s; cur = u[prev[cur]]) {
d = min(d, capa[prev[cur]] - flow[prev[cur]]);
}
f -= d;
r += d * h[t];
for (int cur = t; cur != s; cur = u[prev[cur]]) {
flow[prev[cur]] += d;
flow[rev[prev[cur]]] -= d;
}
}
return true;
}
} mcf;
int N, A[1000], B[1000];
int indexOf(const vector<int> &v, int val) {
return lower_bound(v.begin(), v.end(), val) - v.begin();
}
int main() {
scanf("%d", &N);
rep(i, N) scanf("%d%d", A + i, B + i);
vector<int> v;
rep(i, N) {
v.push_back(A[i]);
v.push_back(B[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
const int BIAS = 2000000;
mcf.init();
rep(i, N) {
mcf.add_edge(0, 2 + i, 1, 0);
mcf.add_edge(2 + i, 2 + N + indexOf(v, B[i]), 1, BIAS - A[i]);
mcf.add_edge(2 + i, 2 + N + indexOf(v, A[i]), 1, BIAS - B[i]);
}
rep(i, v.size()) { mcf.add_edge(2 + N + i, 1, 1, 0); }
mcf.add_edge(0, 1, N, BIAS);
mcf.ready(0, 1);
mcf.pour(N);
printf("%d\n", BIAS * N - (int)mcf.min_cost());
return 0;
} | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
#define mp make_pair
#define INF (1LL << 60)
struct MinCostFlow {
static const int N = 1024 * 4, M = 1024 * 16;
typedef long long cost_t;
int E, head[N], u[M], v[M], capa[M], rev[M], next[M];
cost_t cost[M];
int s, t, flow[M], prev[N];
cost_t r, h[N], dist[N];
void init() {
E = 0;
memset(head, -1, sizeof(head));
}
void add_edge(int _u, int _v, int ca, cost_t co) {
u[E] = _u;
v[E] = _v;
capa[E] = ca;
cost[E] = co;
rev[E] = E + 1, next[E] = head[u[E]];
head[u[E]] = E;
E++;
u[E] = _v;
v[E] = _u;
capa[E] = 0;
cost[E] = -co;
rev[E] = E - 1, next[E] = head[u[E]];
head[u[E]] = E;
E++;
}
void ready(int _s, int _t) {
s = _s;
t = _t;
r = 0;
memset(flow, 0, sizeof(flow));
memset(h, 0, sizeof(h));
}
cost_t min_cost() { return r; }
bool pour(int f) {
while (f > 0) {
priority_queue<pair<cost_t, int>> q;
std::fill_n(dist, N, INF);
dist[s] = 0;
q.push(mp(0, s));
while (!q.empty()) {
pair<cost_t, int> z(q.top());
q.pop();
int cur = z.second;
if (dist[cur] < -z.first)
continue;
for (int x = head[cur]; x != -1; x = next[x])
if (capa[x] - flow[x] > 0) {
if (dist[v[x]] > dist[cur] + cost[x] + h[cur] - h[v[x]]) {
dist[v[x]] = dist[cur] + cost[x] + h[cur] - h[v[x]];
prev[v[x]] = x;
q.push(mp(-dist[v[x]], v[x]));
}
}
}
if (dist[t] == INF)
return false;
rep(i, N) h[i] += dist[i];
int d = f;
for (int cur = t; cur != s; cur = u[prev[cur]]) {
d = min(d, capa[prev[cur]] - flow[prev[cur]]);
}
f -= d;
r += d * h[t];
for (int cur = t; cur != s; cur = u[prev[cur]]) {
flow[prev[cur]] += d;
flow[rev[prev[cur]]] -= d;
}
}
return true;
}
} mcf;
int N, A[1000], B[1000];
int indexOf(const vector<int> &v, int val) {
return lower_bound(v.begin(), v.end(), val) - v.begin();
}
int main() {
scanf("%d", &N);
rep(i, N) scanf("%d%d", A + i, B + i);
vector<int> v;
rep(i, N) {
v.push_back(A[i]);
v.push_back(B[i]);
}
sort(v.begin(), v.end());
v.erase(unique(v.begin(), v.end()), v.end());
const int BIAS = 2000000;
mcf.init();
rep(i, N) {
mcf.add_edge(0, 2 + i, 1, 0);
mcf.add_edge(2 + i, 2 + N + indexOf(v, B[i]), 1, BIAS - A[i]);
mcf.add_edge(2 + i, 2 + N + indexOf(v, A[i]), 1, BIAS - B[i]);
}
rep(i, v.size()) { mcf.add_edge(2 + N + i, 1, 1, 0); }
mcf.add_edge(0, 1, N, BIAS);
mcf.ready(0, 1);
mcf.pour(N);
printf("%d\n", BIAS * N - (int)mcf.min_cost());
return 0;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p01410 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define reep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) reep((i), 0, (n))
template <class T> class MinCostFlow {
public:
class edge {
public:
int to;
int capacity;
T cost;
int reve;
edge(int _to, int _capacity, int _reve, T _cost) {
this->to = _to;
this->capacity = _capacity;
this->reve = _reve;
this->cost = _cost;
}
};
static const int MV = 2010;
vector<edge> E[MV];
T dist[MV];
int prev_v[MV], prev_e[MV], NV;
MinCostFlow() { init(MV); }
void init(int NV = MV) {
this->NV = NV;
for (int i = 0; i < MV; i++) {
E[i].clear();
}
}
void addEdge(int x, int y, int cap, T cost) {
E[x].push_back(edge(y, cap, E[y].size(), cost));
E[y].push_back(edge(x, 0, E[x].size() - 1, -cost));
}
T minCost(int from, int to, int flow) {
T res = 0;
T inf = std::numeric_limits<T>::max() / 2;
memset(prev_v, 0, sizeof(prev_v));
memset(prev_e, 0, sizeof(prev_e));
while (flow > 0) {
fill(dist, dist + NV, inf);
dist[from] = 0;
bool up = true;
while (up) {
up = false;
for (int v = 0; v < NV; ++v) {
if (dist[v] == inf)
continue;
for (int i = 0; i < E[v].size(); ++i) {
edge &e = E[v][i];
if (e.capacity > 0 && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
prev_v[e.to] = v;
prev_e[e.to] = i;
up = true;
}
}
}
}
if (dist[to] == inf)
return -1;
int lc = flow;
for (int v = to; v != from; v = prev_v[v]) {
lc = min(lc, E[prev_v[v]][prev_e[v]].capacity);
}
flow -= lc;
res += lc * dist[to];
for (int v = to; v != from; v = prev_v[v]) {
edge &e = E[prev_v[v]][prev_e[v]];
e.capacity -= lc;
E[v][e.reve].capacity += lc;
}
}
return res;
}
};
MinCostFlow<int> mf;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
map<int, int> ma;
rep(i, n) {
cin >> a[i] >> b[i];
int ta;
ta = ma.size();
if (ma.count(a[i]) == 0)
ma[a[i]] = ta;
ta = ma.size();
if (ma.count(b[i]) == 0)
ma[b[i]] = ta;
}
int m = ma.size();
int source = n + m;
int sink = n + m + 1;
int MA = 1000000;
rep(i, n) {
mf.addEdge(source, i, 1, 0);
mf.addEdge(i, n + ma[a[i]], 1, MA - b[i]);
mf.addEdge(i, n + ma[b[i]], 1, MA - a[i]);
}
for (auto x : ma) {
mf.addEdge(n + x.second, sink, 1, 0);
}
mf.addEdge(source, sink, n, MA);
long long ans = mf.minCost(source, sink, n);
int t = n - mf.E[source].back().capacity;
// ans-=t*MA;
ans -= (n)*MA;
ans *= -1;
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define reep(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) reep((i), 0, (n))
template <class T> class MinCostFlow {
public:
class edge {
public:
int to;
int capacity;
T cost;
int reve;
edge(int _to, int _capacity, int _reve, T _cost) {
this->to = _to;
this->capacity = _capacity;
this->reve = _reve;
this->cost = _cost;
}
};
static const int MV = 3010;
vector<edge> E[MV];
T dist[MV];
int prev_v[MV], prev_e[MV], NV;
MinCostFlow() { init(MV); }
void init(int NV = MV) {
this->NV = NV;
for (int i = 0; i < MV; i++) {
E[i].clear();
}
}
void addEdge(int x, int y, int cap, T cost) {
E[x].push_back(edge(y, cap, E[y].size(), cost));
E[y].push_back(edge(x, 0, E[x].size() - 1, -cost));
}
T minCost(int from, int to, int flow) {
T res = 0;
T inf = std::numeric_limits<T>::max() / 2;
memset(prev_v, 0, sizeof(prev_v));
memset(prev_e, 0, sizeof(prev_e));
while (flow > 0) {
fill(dist, dist + NV, inf);
dist[from] = 0;
bool up = true;
while (up) {
up = false;
for (int v = 0; v < NV; ++v) {
if (dist[v] == inf)
continue;
for (int i = 0; i < E[v].size(); ++i) {
edge &e = E[v][i];
if (e.capacity > 0 && dist[e.to] > dist[v] + e.cost) {
dist[e.to] = dist[v] + e.cost;
prev_v[e.to] = v;
prev_e[e.to] = i;
up = true;
}
}
}
}
if (dist[to] == inf)
return -1;
int lc = flow;
for (int v = to; v != from; v = prev_v[v]) {
lc = min(lc, E[prev_v[v]][prev_e[v]].capacity);
}
flow -= lc;
res += lc * dist[to];
for (int v = to; v != from; v = prev_v[v]) {
edge &e = E[prev_v[v]][prev_e[v]];
e.capacity -= lc;
E[v][e.reve].capacity += lc;
}
}
return res;
}
};
MinCostFlow<int> mf;
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
map<int, int> ma;
rep(i, n) {
cin >> a[i] >> b[i];
int ta;
ta = ma.size();
if (ma.count(a[i]) == 0)
ma[a[i]] = ta;
ta = ma.size();
if (ma.count(b[i]) == 0)
ma[b[i]] = ta;
}
int m = ma.size();
int source = n + m;
int sink = n + m + 1;
int MA = 1000000;
rep(i, n) {
mf.addEdge(source, i, 1, 0);
mf.addEdge(i, n + ma[a[i]], 1, MA - b[i]);
mf.addEdge(i, n + ma[b[i]], 1, MA - a[i]);
}
for (auto x : ma) {
mf.addEdge(n + x.second, sink, 1, 0);
}
mf.addEdge(source, sink, n, MA);
long long ans = mf.minCost(source, sink, n);
int t = n - mf.E[source].back().capacity;
// ans-=t*MA;
ans -= (n)*MA;
ans *= -1;
cout << ans << endl;
} | replace | 22 | 23 | 22 | 23 | 0 | |
p01410 | C++ | Runtime Error | #include <bits/stdc++.h>
#define int long long
#define range(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const int vmax = 1001;
const int inf = 1 << 29;
struct edge {
int to, cap, cost, rev;
};
vector<edge> graph[vmax];
int h[vmax], dist[vmax];
int pv[vmax], pe[vmax];
typedef tuple<int, int> state;
void add_edge(int from, int to, int cap, int cost) {
graph[from].push_back({to, cap, cost, (int)graph[to].size()});
graph[to].push_back({from, 0, -cost, (int)graph[from].size() - 1});
}
int min_cost_flow(int s, int t, int f, int n) {
int res = 0;
fill(h, h + n, 0);
while (f > 0) {
priority_queue<state, vector<state>, greater<state>> q;
fill(dist, dist + n, inf);
dist[s] = 0;
q.push(state(0, s));
while (!q.empty()) {
int cost, v;
tie(cost, v) = q.top();
q.pop();
if (dist[v] < cost)
continue;
rep(i, graph[v].size()) {
edge &e = graph[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
pv[e.to] = v, pe[e.to] = i;
q.push(state(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1;
rep(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = pv[v])
d = min(d, graph[pv[v]][pe[v]].cap);
f -= d;
res += d * h[t];
for (int v = t; v != s; v = pv[v]) {
edge &e = graph[pv[v]][pe[v]];
e.cap -= d;
graph[v][e.rev].cap += d;
}
}
return res;
}
signed main(void) {
int n;
cin >> n;
vector<pair<int, int>> rects(n);
int idx = n;
map<int, int> l2i;
for (auto &e : rects) {
int a, b;
cin >> a >> b;
e = make_pair(a, b);
if (l2i.find(a) == end(l2i))
l2i[a] = idx++;
if (l2i.find(b) == end(l2i))
l2i[b] = idx++;
}
int dummy = idx++, s = idx++, t = idx++;
rep(i, n) { add_edge(s, i, 1, 0); }
range(i, n, dummy) { add_edge(i, t, 1, 0); }
add_edge(dummy, t, inf, 0);
rep(i, n) {
add_edge(i, l2i[rects[i].first], 1, -rects[i].second);
add_edge(i, l2i[rects[i].second], 1, -rects[i].first);
add_edge(i, dummy, 1, 0);
}
cout << -min_cost_flow(s, t, n, idx) << endl;
return 0;
} | #include <bits/stdc++.h>
#define int long long
#define range(i, a, n) for (int(i) = (a); (i) < (n); (i)++)
#define rep(i, n) for (int(i) = 0; (i) < (n); (i)++)
using namespace std;
const int vmax = 10001;
const int inf = 1 << 29;
struct edge {
int to, cap, cost, rev;
};
vector<edge> graph[vmax];
int h[vmax], dist[vmax];
int pv[vmax], pe[vmax];
typedef tuple<int, int> state;
void add_edge(int from, int to, int cap, int cost) {
graph[from].push_back({to, cap, cost, (int)graph[to].size()});
graph[to].push_back({from, 0, -cost, (int)graph[from].size() - 1});
}
int min_cost_flow(int s, int t, int f, int n) {
int res = 0;
fill(h, h + n, 0);
while (f > 0) {
priority_queue<state, vector<state>, greater<state>> q;
fill(dist, dist + n, inf);
dist[s] = 0;
q.push(state(0, s));
while (!q.empty()) {
int cost, v;
tie(cost, v) = q.top();
q.pop();
if (dist[v] < cost)
continue;
rep(i, graph[v].size()) {
edge &e = graph[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
pv[e.to] = v, pe[e.to] = i;
q.push(state(dist[e.to], e.to));
}
}
}
if (dist[t] == inf)
return -1;
rep(v, n) h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = pv[v])
d = min(d, graph[pv[v]][pe[v]].cap);
f -= d;
res += d * h[t];
for (int v = t; v != s; v = pv[v]) {
edge &e = graph[pv[v]][pe[v]];
e.cap -= d;
graph[v][e.rev].cap += d;
}
}
return res;
}
signed main(void) {
int n;
cin >> n;
vector<pair<int, int>> rects(n);
int idx = n;
map<int, int> l2i;
for (auto &e : rects) {
int a, b;
cin >> a >> b;
e = make_pair(a, b);
if (l2i.find(a) == end(l2i))
l2i[a] = idx++;
if (l2i.find(b) == end(l2i))
l2i[b] = idx++;
}
int dummy = idx++, s = idx++, t = idx++;
rep(i, n) { add_edge(s, i, 1, 0); }
range(i, n, dummy) { add_edge(i, t, 1, 0); }
add_edge(dummy, t, inf, 0);
rep(i, n) {
add_edge(i, l2i[rects[i].first], 1, -rects[i].second);
add_edge(i, l2i[rects[i].second], 1, -rects[i].first);
add_edge(i, dummy, 1, 0);
}
cout << -min_cost_flow(s, t, n, idx) << endl;
return 0;
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01410 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef vector<LL> VLL;
typedef complex<double> P;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#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 SORT(c) sort((c).begin(), (c).end())
#define MT(a, b, c) MP(a, MP(b, c))
#define T1 first
#define T2 second.first
#define T3 second.second
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MOD 1000000007
// AOJ 2293
struct edge {
int to, cost, cap, rev;
edge(int _to, int _cost, int _cap, int _ret)
: to(_to), cost(_cost), cap(_cap), rev(_ret){};
};
int n, a[1111], b[1111];
int inf = 1111111111;
vector<vector<edge>> g;
set<int> si;
int nid[111111];
int dist[3333], nv, pe[3333], pv[3333];
void addedge(int from, int to, int cost, int cap) {
g[from].PB(edge(to, cost, cap, g[to].size()));
g[to].PB(edge(from, -cost, 0, g[from].size() - 1));
}
inline void shortest_path(int s) {
int flag = true;
REP(i, nv) dist[i] = inf;
dist[s] = 0;
while (flag) {
flag = false;
REP(i, nv) {
REP(j, g[i].size()) {
if (g[i][j].cap > 0 && dist[g[i][j].to] > dist[i] + g[i][j].cost) {
dist[g[i][j].to] = dist[i] + g[i][j].cost;
pe[g[i][j].to] = j;
pv[g[i][j].to] = i;
flag = true;
}
}
}
}
}
int MinCostFlow(int s, int t, int f) {
int ret = 0;
while (f) {
shortest_path(s);
if (dist[t] == inf)
return inf;
int d = f, c = t;
while (c != s) {
d = min(d, g[pv[c]][pe[c]].cap);
c = pv[c];
}
f -= d;
ret += d * dist[t];
c = t;
while (c != s) {
g[pv[c]][pe[c]].cap -= d;
g[c][g[pv[c]][pe[c]].rev].cap += d;
c = pv[c];
}
}
return ret;
}
int main() {
cin >> n;
REP(i, n) {
scanf("%d%d", &a[i], &b[i]);
si.insert(a[i]);
si.insert(b[i]);
}
nv = si.size() + n + 3;
int k = n + 1;
memset(nid, -1, sizeof(nid));
g = vector<vector<edge>>(nv);
REP(i, n) {
int va, vb;
addedge(0, i + 1, 0, 1);
if (nid[a[i]] == -1)
nid[a[i]] = k++;
if (nid[b[i]] == -1)
nid[b[i]] = k++;
addedge(i + 1, nid[a[i]], -b[i], 1);
addedge(i + 1, nid[b[i]], -a[i], 1);
addedge(i + 1, nv - 2, 0, 1);
}
FOR(i, n + 1, nv - 2) addedge(i, nv - 1, 0, 1);
addedge(nv - 2, nv - 1, 0, inf);
cout << -MinCostFlow(0, nv - 1, n) << endl;
} | #include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdio.h>
#include <string>
#include <utility>
#include <vector>
using namespace std;
// conversion
//------------------------------------------
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();
}
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef pair<int, PII> TIII;
typedef long long LL;
typedef vector<LL> VLL;
typedef complex<double> P;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#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 SORT(c) sort((c).begin(), (c).end())
#define MT(a, b, c) MP(a, MP(b, c))
#define T1 first
#define T2 second.first
#define T3 second.second
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
#define MOD 1000000007
// AOJ 2293
struct edge {
int to, cost, cap, rev;
edge(int _to, int _cost, int _cap, int _ret)
: to(_to), cost(_cost), cap(_cap), rev(_ret){};
};
int n, a[1111], b[1111];
int inf = 1111111111;
vector<vector<edge>> g;
set<int> si;
int nid[1111111];
int dist[3333], nv, pe[3333], pv[3333];
void addedge(int from, int to, int cost, int cap) {
g[from].PB(edge(to, cost, cap, g[to].size()));
g[to].PB(edge(from, -cost, 0, g[from].size() - 1));
}
inline void shortest_path(int s) {
int flag = true;
REP(i, nv) dist[i] = inf;
dist[s] = 0;
while (flag) {
flag = false;
REP(i, nv) {
REP(j, g[i].size()) {
if (g[i][j].cap > 0 && dist[g[i][j].to] > dist[i] + g[i][j].cost) {
dist[g[i][j].to] = dist[i] + g[i][j].cost;
pe[g[i][j].to] = j;
pv[g[i][j].to] = i;
flag = true;
}
}
}
}
}
int MinCostFlow(int s, int t, int f) {
int ret = 0;
while (f) {
shortest_path(s);
if (dist[t] == inf)
return inf;
int d = f, c = t;
while (c != s) {
d = min(d, g[pv[c]][pe[c]].cap);
c = pv[c];
}
f -= d;
ret += d * dist[t];
c = t;
while (c != s) {
g[pv[c]][pe[c]].cap -= d;
g[c][g[pv[c]][pe[c]].rev].cap += d;
c = pv[c];
}
}
return ret;
}
int main() {
cin >> n;
REP(i, n) {
scanf("%d%d", &a[i], &b[i]);
si.insert(a[i]);
si.insert(b[i]);
}
nv = si.size() + n + 3;
int k = n + 1;
memset(nid, -1, sizeof(nid));
g = vector<vector<edge>>(nv);
REP(i, n) {
int va, vb;
addedge(0, i + 1, 0, 1);
if (nid[a[i]] == -1)
nid[a[i]] = k++;
if (nid[b[i]] == -1)
nid[b[i]] = k++;
addedge(i + 1, nid[a[i]], -b[i], 1);
addedge(i + 1, nid[b[i]], -a[i], 1);
addedge(i + 1, nv - 2, 0, 1);
}
FOR(i, n + 1, nv - 2) addedge(i, nv - 1, 0, 1);
addedge(nv - 2, nv - 1, 0, inf);
cout << -MinCostFlow(0, nv - 1, n) << endl;
} | replace | 88 | 89 | 88 | 89 | 0 | |
p01410 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define IINF (INT_MAX)
#define LLINF (LLONG_MAX)
#define MAX_V 3000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge {
ll to, cap, cost, rev;
edge(ll to = LLINF, ll cap = LLINF, ll cost = LLINF, ll rev = LLINF)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
int V;
vector<edge> G[MAX_V];
ll h[MAX_V], dist[MAX_V], prevv[MAX_V], preve[MAX_V];
void add_edge(ll from, ll to, ll cap, ll cost) {
G[from].push_back(edge(to, cap, cost, (ll)G[to].size()));
G[to].push_back(edge(from, 0, -cost, (ll)G[from].size() - 1));
}
ll min_cost_flow(ll s, ll t, ll f) {
ll res = 0;
rep(i, V) h[i] = 0;
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
rep(i, V) dist[i] = LLINF;
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
ll v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == LLINF)
return -1;
for (int v = 0; v < V; v++)
h[v] += dist[v];
ll d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, G[prevv[v]][preve[v]].cap);
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
cin >> N;
int *A = new int[N];
int *B = new int[N];
map<int, int> getIndex;
int dex = 0;
rep(i, N) {
cin >> A[i] >> B[i];
if (getIndex.find(A[i]) == getIndex.end())
getIndex[A[i]] = dex++;
if (getIndex.find(B[i]) == getIndex.end())
getIndex[B[i]] = dex++;
}
V = N + (int)getIndex.size();
int source = V, sink = source + 1, grave = sink + 1;
V += 3;
add_edge(grave, sink, LLINF, 0);
rep(i, N) add_edge(source, i, 1, 0);
rep(i, (int)getIndex.size()) add_edge(N + i, sink, 1, 0);
rep(i, N) {
int to1 = getIndex[A[i]] + N;
int to2 = getIndex[B[i]] + N;
add_edge(i, to1, 1, -B[i]);
add_edge(i, to2, 1, -A[i]);
add_edge(i, grave, LLINF, 0);
}
delete[] A;
delete[] B;
cout << -min_cost_flow(source, sink, N) << endl;
return 0;
} | #include <algorithm>
#include <climits>
#include <iostream>
#include <map>
#include <queue>
#include <vector>
#define REP(i, s, n) for (int i = s; i < n; i++)
#define rep(i, n) REP(i, 0, n)
#define IINF (INT_MAX)
#define LLINF (LLONG_MAX)
#define MAX_V 10000
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
struct edge {
ll to, cap, cost, rev;
edge(ll to = LLINF, ll cap = LLINF, ll cost = LLINF, ll rev = LLINF)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
int V;
vector<edge> G[MAX_V];
ll h[MAX_V], dist[MAX_V], prevv[MAX_V], preve[MAX_V];
void add_edge(ll from, ll to, ll cap, ll cost) {
G[from].push_back(edge(to, cap, cost, (ll)G[to].size()));
G[to].push_back(edge(from, 0, -cost, (ll)G[from].size() - 1));
}
ll min_cost_flow(ll s, ll t, ll f) {
ll res = 0;
rep(i, V) h[i] = 0;
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
rep(i, V) dist[i] = LLINF;
dist[s] = 0;
que.push(P(0, s));
while (!que.empty()) {
P p = que.top();
que.pop();
ll v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push(P(dist[e.to], e.to));
}
}
}
if (dist[t] == LLINF)
return -1;
for (int v = 0; v < V; v++)
h[v] += dist[v];
ll d = f;
for (int v = t; v != s; v = prevv[v])
d = min(d, G[prevv[v]][preve[v]].cap);
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int main() {
int N;
cin >> N;
int *A = new int[N];
int *B = new int[N];
map<int, int> getIndex;
int dex = 0;
rep(i, N) {
cin >> A[i] >> B[i];
if (getIndex.find(A[i]) == getIndex.end())
getIndex[A[i]] = dex++;
if (getIndex.find(B[i]) == getIndex.end())
getIndex[B[i]] = dex++;
}
V = N + (int)getIndex.size();
int source = V, sink = source + 1, grave = sink + 1;
V += 3;
add_edge(grave, sink, LLINF, 0);
rep(i, N) add_edge(source, i, 1, 0);
rep(i, (int)getIndex.size()) add_edge(N + i, sink, 1, 0);
rep(i, N) {
int to1 = getIndex[A[i]] + N;
int to2 = getIndex[B[i]] + N;
add_edge(i, to1, 1, -B[i]);
add_edge(i, to2, 1, -A[i]);
add_edge(i, grave, LLINF, 0);
}
delete[] A;
delete[] B;
cout << -min_cost_flow(source, sink, N) << endl;
return 0;
} | replace | 11 | 12 | 11 | 12 | 0 | |
p01410 | C++ | Runtime Error | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
namespace MCF {
// required <string.h> <vector> <queue> <algorithm>
#define MAXN 2100
#define MAXM 21000
#define wint int
#define cint long long
const wint wEPS = 0;
const wint wINF = 1001001001;
const cint cEPS = 0;
const cint cINF = 1001001001001001LL;
int n, m, ptr[MAXN], next[MAXM], zu[MAXM];
wint capa[MAXM], tof;
cint cost[MAXM], toc, d[MAXN], pot[MAXN];
int vis[MAXN], pree[MAXN];
void init(int _n) {
n = _n;
m = 0;
memset(ptr, ~0, n * 4);
}
void ae(int u, int v, wint w, cint c) {
next[m] = ptr[u];
ptr[u] = m;
zu[m] = v;
capa[m] = w;
cost[m] = +c;
++m;
next[m] = ptr[v];
ptr[v] = m;
zu[m] = u;
capa[m] = 0;
cost[m] = -c;
++m;
}
bool solve(int src, int ink, wint flo = wINF) {
int i, u, v;
wint f;
cint c, cc;
memset(pot, 0, n * sizeof(cint));
//*
for (bool cont = 1; cont;) {
cont = 0;
for (u = 0; u < n; ++u)
for (i = ptr[u]; ~i; i = next[i])
if (capa[i] > wEPS) {
if (pot[zu[i]] > pot[u] + cost[i] + cEPS) {
pot[zu[i]] = pot[u] + cost[i];
cont = 1;
}
}
}
//*/
for (toc = 0, tof = 0; tof + wEPS < flo;) {
typedef pair<cint, int> node;
priority_queue<node, vector<node>, greater<node>> q;
for (u = 0; u < n; ++u) {
d[u] = cINF;
vis[u] = 0;
}
for (q.push(make_pair(d[src] = 0, src)); !q.empty();) {
c = q.top().first;
u = q.top().second;
q.pop();
if (vis[u]++)
continue;
for (i = ptr[u]; ~i; i = next[i])
if (capa[i] > wEPS) {
cc = c + cost[i] + pot[u] - pot[v = zu[i]];
if (d[v] > cc) {
q.push(make_pair(d[v] = cc, v));
pree[v] = i;
}
}
}
if (!vis[ink])
return 0;
f = flo - tof;
for (v = ink; v != src; v = zu[i ^ 1]) {
i = pree[v];
f = min(f, capa[i]);
}
for (v = ink; v != src; v = zu[i ^ 1]) {
i = pree[v];
capa[i] -= f;
capa[i ^ 1] += f;
}
tof += f;
toc += f * (d[ink] - pot[src] + pot[ink]);
for (u = 0; u < n; ++u)
pot[u] += d[u];
}
return 1;
}
} // namespace MCF
int z[2100];
int b[1100];
int c[1100];
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d%d", b + i, c + i);
z[i * 2] = b[i];
z[i * 2 + 1] = c[i];
}
MCF::init(a * 3 + 2);
std::sort(z, z + a * 2);
int s = a * 3;
int t = a * 3 + 1;
for (int i = 0; i < a; i++) {
MCF::ae(s, i, 1, 0);
MCF::ae(i, t, 1, 1000000);
int L = lower_bound(z, z + a * 2, b[i]) - z;
int R = lower_bound(z, z + a * 2, c[i]) - z;
MCF::ae(i, a + L, 1, 1000000 - c[i]);
MCF::ae(i, a + R, 1, 1000000 - b[i]);
}
for (int i = 0; i < a * 2; i++)
MCF::ae(a + i, t, 1, 0);
MCF::solve(s, t, a);
printf("%lld\n", -MCF::toc + 1000000 * a);
} | #include <algorithm>
#include <queue>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
namespace MCF {
// required <string.h> <vector> <queue> <algorithm>
#define MAXN 3100
#define MAXM 21000
#define wint int
#define cint long long
const wint wEPS = 0;
const wint wINF = 1001001001;
const cint cEPS = 0;
const cint cINF = 1001001001001001LL;
int n, m, ptr[MAXN], next[MAXM], zu[MAXM];
wint capa[MAXM], tof;
cint cost[MAXM], toc, d[MAXN], pot[MAXN];
int vis[MAXN], pree[MAXN];
void init(int _n) {
n = _n;
m = 0;
memset(ptr, ~0, n * 4);
}
void ae(int u, int v, wint w, cint c) {
next[m] = ptr[u];
ptr[u] = m;
zu[m] = v;
capa[m] = w;
cost[m] = +c;
++m;
next[m] = ptr[v];
ptr[v] = m;
zu[m] = u;
capa[m] = 0;
cost[m] = -c;
++m;
}
bool solve(int src, int ink, wint flo = wINF) {
int i, u, v;
wint f;
cint c, cc;
memset(pot, 0, n * sizeof(cint));
//*
for (bool cont = 1; cont;) {
cont = 0;
for (u = 0; u < n; ++u)
for (i = ptr[u]; ~i; i = next[i])
if (capa[i] > wEPS) {
if (pot[zu[i]] > pot[u] + cost[i] + cEPS) {
pot[zu[i]] = pot[u] + cost[i];
cont = 1;
}
}
}
//*/
for (toc = 0, tof = 0; tof + wEPS < flo;) {
typedef pair<cint, int> node;
priority_queue<node, vector<node>, greater<node>> q;
for (u = 0; u < n; ++u) {
d[u] = cINF;
vis[u] = 0;
}
for (q.push(make_pair(d[src] = 0, src)); !q.empty();) {
c = q.top().first;
u = q.top().second;
q.pop();
if (vis[u]++)
continue;
for (i = ptr[u]; ~i; i = next[i])
if (capa[i] > wEPS) {
cc = c + cost[i] + pot[u] - pot[v = zu[i]];
if (d[v] > cc) {
q.push(make_pair(d[v] = cc, v));
pree[v] = i;
}
}
}
if (!vis[ink])
return 0;
f = flo - tof;
for (v = ink; v != src; v = zu[i ^ 1]) {
i = pree[v];
f = min(f, capa[i]);
}
for (v = ink; v != src; v = zu[i ^ 1]) {
i = pree[v];
capa[i] -= f;
capa[i ^ 1] += f;
}
tof += f;
toc += f * (d[ink] - pot[src] + pot[ink]);
for (u = 0; u < n; ++u)
pot[u] += d[u];
}
return 1;
}
} // namespace MCF
int z[2100];
int b[1100];
int c[1100];
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d%d", b + i, c + i);
z[i * 2] = b[i];
z[i * 2 + 1] = c[i];
}
MCF::init(a * 3 + 2);
std::sort(z, z + a * 2);
int s = a * 3;
int t = a * 3 + 1;
for (int i = 0; i < a; i++) {
MCF::ae(s, i, 1, 0);
MCF::ae(i, t, 1, 1000000);
int L = lower_bound(z, z + a * 2, b[i]) - z;
int R = lower_bound(z, z + a * 2, c[i]) - z;
MCF::ae(i, a + L, 1, 1000000 - c[i]);
MCF::ae(i, a + R, 1, 1000000 - b[i]);
}
for (int i = 0; i < a * 2; i++)
MCF::ae(a + i, t, 1, 0);
MCF::solve(s, t, a);
printf("%lld\n", -MCF::toc + 1000000 * a);
} | replace | 8 | 9 | 8 | 9 | 0 | |
p01411 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long i64;
typedef long double ld;
#define rep(i, s, e) for (int i = (s); i <= (e); i++)
int H, N, P, M, K;
vector<int> stick(505, -1);
vector<vector<ld>> dp(505, vector<ld>(101, 0));
int main() {
cin >> H >> N >> P >> M >> K;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
stick[a] = b;
}
dp[K][P] = 1;
for (int i = H; i >= 1; i--) {
if (stick[i] != -1) {
vector<vector<ld>> next(505, vector<ld>(101, 0));
rep(j, 1, N) rep(k, 0, K) {
int st = stick[i];
if (st == j)
next[k][j + 1] += dp[k][j];
else if (st + 1 == j)
next[k][j - 1] += dp[k][j];
else
next[k][j] += dp[k][j];
}
swap(dp, next);
} else {
vector<vector<ld>> next(101, vector<ld>(101, 0));
rep(j, 1, N) rep(k, 0, K) { next[k][j] += dp[k][j]; }
rep(j, 1, N) rep(k, 0, K) rep(st, 1, N - 1) {
if (st == j)
next[k][j + 1] += dp[k + 1][j];
else if (st + 1 == j)
next[k][j - 1] += dp[k + 1][j];
else
next[k][j] += dp[k + 1][j];
}
swap(dp, next);
}
}
ld result = 0;
ld sum = 0;
for (int i = 1; i <= N; i++) {
sum += dp[0][i];
result = max(result, dp[0][i]);
}
cout << fixed << setprecision(10) << result / sum << endl;
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long i64;
typedef long double ld;
#define rep(i, s, e) for (int i = (s); i <= (e); i++)
int H, N, P, M, K;
vector<int> stick(505, -1);
vector<vector<ld>> dp(505, vector<ld>(101, 0));
int main() {
cin >> H >> N >> P >> M >> K;
for (int i = 0; i < M; i++) {
int a, b;
cin >> a >> b;
stick[a] = b;
}
dp[K][P] = 1;
for (int i = H; i >= 1; i--) {
if (stick[i] != -1) {
vector<vector<ld>> next(505, vector<ld>(101, 0));
rep(j, 1, N) rep(k, 0, K) {
int st = stick[i];
if (st == j)
next[k][j + 1] += dp[k][j];
else if (st + 1 == j)
next[k][j - 1] += dp[k][j];
else
next[k][j] += dp[k][j];
}
swap(dp, next);
} else {
vector<vector<ld>> next(505, vector<ld>(101, 0));
rep(j, 1, N) rep(k, 0, K) { next[k][j] += dp[k][j]; }
rep(j, 1, N) rep(k, 0, K) rep(st, 1, N - 1) {
if (st == j)
next[k][j + 1] += dp[k + 1][j];
else if (st + 1 == j)
next[k][j - 1] += dp[k + 1][j];
else
next[k][j] += dp[k + 1][j];
}
swap(dp, next);
}
}
ld result = 0;
ld sum = 0;
for (int i = 1; i <= N; i++) {
sum += dp[0][i];
result = max(result, dp[0][i]);
}
cout << fixed << setprecision(10) << result / sum << endl;
return 0;
}
| replace | 44 | 45 | 44 | 45 | 0 | |
p01411 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
// bou height rest
ld dp[100][501][101];
int main() {
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 501; ++j) {
for (int k = 0; k < 101; ++k) {
dp[i][j][k] = 0;
}
}
}
int H, N, P, M, K;
cin >> H >> N >> P >> M >> K;
P--;
vector<int> lines(H, -1);
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
lines[a] = b;
}
int undecidednum = H - M;
dp[P][H][K] = 1;
for (int h = H - 1; h >= 0; --h) {
if (lines[h] != -1) {
for (int rest = 0; rest <= K; ++rest) {
for (int i = 0; i < N; ++i) {
dp[i][h][rest] = dp[i][h + 1][rest];
}
swap(dp[lines[h]][h][rest], dp[lines[h] + 1][h][rest]);
}
} else {
for (int rest = 0; rest <= K; ++rest) {
if (rest > undecidednum) {
} else {
ld per = (ld(rest) / undecidednum) / (N - 1);
{
vector<ld> pluss(N);
for (int sw = 0; sw < N - 1; ++sw) {
for (int i = 0; i < N; ++i) {
pluss[i] = dp[i][h + 1][rest] * per;
}
swap(pluss[sw], pluss[sw + 1]);
for (int i = 0; i < N; ++i) {
dp[i][h][rest - 1] += pluss[i];
}
}
}
{
vector<ld> pluss(N);
for (int i = 0; i < N; ++i) {
pluss[i] = dp[i][h + 1][rest] * (1 - per * (N - 1));
}
for (int i = 0; i < N; ++i) {
dp[i][h][rest] += pluss[i];
}
}
}
}
undecidednum--;
}
}
ld ans = 0;
for (int i = 0; i < N; ++i) {
ans = max(dp[i][0][0], ans);
}
cout << setprecision(22) << fixed << ans << endl;
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#pragma warning(disable : 4996)
using namespace std;
using ld = double;
template <class T> using Table = vector<vector<T>>;
// bou height rest
ld dp[100][501][101];
int main() {
for (int i = 0; i < 100; ++i) {
for (int j = 0; j < 501; ++j) {
for (int k = 0; k < 101; ++k) {
dp[i][j][k] = 0;
}
}
}
int H, N, P, M, K;
cin >> H >> N >> P >> M >> K;
P--;
vector<int> lines(H, -1);
for (int i = 0; i < M; ++i) {
int a, b;
cin >> a >> b;
a--;
b--;
lines[a] = b;
}
int undecidednum = H - M;
dp[P][H][K] = 1;
for (int h = H - 1; h >= 0; --h) {
if (lines[h] != -1) {
for (int rest = 0; rest <= K; ++rest) {
for (int i = 0; i < N; ++i) {
dp[i][h][rest] = dp[i][h + 1][rest];
}
swap(dp[lines[h]][h][rest], dp[lines[h] + 1][h][rest]);
}
} else {
for (int rest = 0; rest <= K; ++rest) {
if (rest > undecidednum) {
} else {
ld per = (ld(rest) / undecidednum) / (N - 1);
{
vector<ld> pluss(N);
for (int sw = 0; sw < N - 1; ++sw) {
for (int i = 0; i < N; ++i) {
pluss[i] = dp[i][h + 1][rest] * per;
}
swap(pluss[sw], pluss[sw + 1]);
for (int i = 0; i < N; ++i) {
dp[i][h][rest - 1] += pluss[i];
}
}
}
{
vector<ld> pluss(N);
for (int i = 0; i < N; ++i) {
pluss[i] = dp[i][h + 1][rest] * (1 - per * (N - 1));
}
for (int i = 0; i < N; ++i) {
dp[i][h][rest] += pluss[i];
}
}
}
}
undecidednum--;
}
}
ld ans = 0;
for (int i = 0; i < N; ++i) {
ans = max(dp[i][0][0], ans);
}
cout << setprecision(22) << fixed << ans << endl;
return 0;
} | replace | 4 | 5 | 4 | 5 | MLE | |
p01411 | C++ | Runtime Error | #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 503
double dp[2][101][101];
bool is_exist[NUM];
int line_loc[NUM], can_write_num[NUM];
int main() {
int H, N, P, M, K;
scanf("%d %d %d %d %d", &H, &N, &P, &M, &K);
for (int i = 0; i <= H + 1; i++) {
is_exist[i] = false;
can_write_num[i] = 1; // その高さ以下で、横棒を引ける高さの数
}
int height, loc;
for (int loop = 0; loop < M; loop++) {
scanf("%d %d", &height, &loc);
is_exist[height] = true;
line_loc[height] = loc;
can_write_num[height] = 0;
}
for (int h = 2; h <= H + 1; h++)
can_write_num[h] += can_write_num[h - 1];
for (int i = 0; i < 2; i++) {
for (int k = 0; k <= K; k++) {
for (int pos = 1; pos <= N; pos++)
dp[i][k][pos] = 0; // dp[高さ][横棒の設置本数][位置] = ゴール確率
}
}
int CURRENT = 0, NEXT = 1;
dp[CURRENT][0][P] = 1.0;
double loc_possi = 1.0 / (double)(N - 1), height_possi;
for (int h = H; h >= 1; h--) {
if (is_exist
[h]) { // 既に横棒が引かれている場合:該当する2箇所の確率を交換する
for (int num = 0; num <= K; num++) {
swap(dp[CURRENT][num][line_loc[h]], dp[CURRENT][num][line_loc[h] + 1]);
}
} else { // 横棒が引かれていない場合
for (int num = 0; num <= K; num++) {
for (int pos = 1; pos <= N; pos++)
dp[NEXT][num][pos] = 0.0;
}
for (int num = 0; num <= K; num++) {
height_possi = (double)(K - num) /
(double)can_write_num[h]; // その高さが選ばれる確率
for (int pos = 1; pos <= N; pos++) {
// 右に動く(★交換回数が1増える!!★)
if (pos != N) {
dp[NEXT][num + 1][pos + 1] +=
height_possi * loc_possi * dp[CURRENT][num][pos];
}
// 左に動く(★交換回数が1増える!!★)
if (pos != 1) {
dp[NEXT][num + 1][pos - 1] +=
height_possi * loc_possi * dp[CURRENT][num][pos];
}
// ★変わらず★
// 自分の高さが選ばれない場合
dp[NEXT][num][pos] += (1 - height_possi) * dp[CURRENT][num][pos];
// 自分の高さが選ばれ、かつ自分以外の場所が選ばれる場合
if (pos != 1 && pos != N) {
dp[NEXT][num + 1][pos] +=
height_possi * (1.0 - loc_possi * 2) * dp[CURRENT][num][pos];
} else { // pos == 1 || pos == N
dp[NEXT][num + 1][pos] +=
height_possi * (1.0 - loc_possi) * dp[CURRENT][num][pos];
}
}
}
swap(CURRENT, NEXT);
}
}
double ans = 0.0;
for (int pos = 1; pos <= N; pos++)
ans = max(ans, dp[CURRENT][K][pos]);
printf("%.10lf\n", ans);
return 0;
}
| #include <algorithm>
#include <cfloat>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <string>
#include <time.h>
#include <vector>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;
#define NUM 503
double dp[2][102][102];
bool is_exist[NUM];
int line_loc[NUM], can_write_num[NUM];
int main() {
int H, N, P, M, K;
scanf("%d %d %d %d %d", &H, &N, &P, &M, &K);
for (int i = 0; i <= H + 1; i++) {
is_exist[i] = false;
can_write_num[i] = 1; // その高さ以下で、横棒を引ける高さの数
}
int height, loc;
for (int loop = 0; loop < M; loop++) {
scanf("%d %d", &height, &loc);
is_exist[height] = true;
line_loc[height] = loc;
can_write_num[height] = 0;
}
for (int h = 2; h <= H + 1; h++)
can_write_num[h] += can_write_num[h - 1];
for (int i = 0; i < 2; i++) {
for (int k = 0; k <= K; k++) {
for (int pos = 1; pos <= N; pos++)
dp[i][k][pos] = 0; // dp[高さ][横棒の設置本数][位置] = ゴール確率
}
}
int CURRENT = 0, NEXT = 1;
dp[CURRENT][0][P] = 1.0;
double loc_possi = 1.0 / (double)(N - 1), height_possi;
for (int h = H; h >= 1; h--) {
if (is_exist
[h]) { // 既に横棒が引かれている場合:該当する2箇所の確率を交換する
for (int num = 0; num <= K; num++) {
swap(dp[CURRENT][num][line_loc[h]], dp[CURRENT][num][line_loc[h] + 1]);
}
} else { // 横棒が引かれていない場合
for (int num = 0; num <= K; num++) {
for (int pos = 1; pos <= N; pos++)
dp[NEXT][num][pos] = 0.0;
}
for (int num = 0; num <= K; num++) {
height_possi = (double)(K - num) /
(double)can_write_num[h]; // その高さが選ばれる確率
for (int pos = 1; pos <= N; pos++) {
// 右に動く(★交換回数が1増える!!★)
if (pos != N) {
dp[NEXT][num + 1][pos + 1] +=
height_possi * loc_possi * dp[CURRENT][num][pos];
}
// 左に動く(★交換回数が1増える!!★)
if (pos != 1) {
dp[NEXT][num + 1][pos - 1] +=
height_possi * loc_possi * dp[CURRENT][num][pos];
}
// ★変わらず★
// 自分の高さが選ばれない場合
dp[NEXT][num][pos] += (1 - height_possi) * dp[CURRENT][num][pos];
// 自分の高さが選ばれ、かつ自分以外の場所が選ばれる場合
if (pos != 1 && pos != N) {
dp[NEXT][num + 1][pos] +=
height_possi * (1.0 - loc_possi * 2) * dp[CURRENT][num][pos];
} else { // pos == 1 || pos == N
dp[NEXT][num + 1][pos] +=
height_possi * (1.0 - loc_possi) * dp[CURRENT][num][pos];
}
}
}
swap(CURRENT, NEXT);
}
}
double ans = 0.0;
for (int pos = 1; pos <= N; pos++)
ans = max(ans, dp[CURRENT][K][pos]);
printf("%.10lf\n", ans);
return 0;
}
| replace | 21 | 22 | 21 | 22 | 0 | |
p01412 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++)
cin >> A[i];
sort(A.begin(), A.end());
vector<int> last;
while (A.size() && A[0] == 0)
last.push_back(0), A.erase(A.begin());
if (A.size() && last.size() % 2)
last.insert(last.end() - 2, A[0]), A.erase(A.begin());
while (A.size() && A[0] == 1)
last.push_back(1), A.erase(A.begin());
if (A.size() >= 2 && A[A.size() - 1] == 3 && A[A.size() - 2] == 2)
swap(A[A.size() - 2], A[A.size() - 1]);
for (int i = 0; i < A.size(); i++)
cout << A[i] << endl;
for (int i = 0; i < last.size(); i++)
cout << last[i] << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> A(n);
for (int i = 0; i < n; i++)
cin >> A[i];
sort(A.begin(), A.end());
vector<int> last;
while (A.size() && A[0] == 0)
last.push_back(0), A.erase(A.begin());
if (A.size() && last.size() % 2)
last.insert(last.end() - 1, A[0]), A.erase(A.begin());
while (A.size() && A[0] == 1)
last.push_back(1), A.erase(A.begin());
if (A.size() >= 2 && A[A.size() - 1] == 3 && A[A.size() - 2] == 2)
swap(A[A.size() - 2], A[A.size() - 1]);
for (int i = 0; i < A.size(); i++)
cout << A[i] << endl;
for (int i = 0; i < last.size(); i++)
cout << last[i] << endl;
return 0;
} | replace | 16 | 17 | 16 | 17 | 0 | |
p01412 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
int n;
int a[101];
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
reverse(a, a + n);
int all = n;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 0)
all--;
else
break;
}
int zero = all;
for (int i = all - 1; i >= 0; i--) {
if (a[i] == 1)
all--;
else
break;
}
int sw = (n - all) - (zero - all);
sort(a + all, a + n);
if ((n - zero) % 2 == 1) {
if (zero - all >= 1)
swap(a[all + sw - 1], a[all + sw]);
else {
for (int i = all - 1; i + 2 < n; i += 2) {
swap(a[i], a[i + 2]);
}
all--;
}
}
sort(a, a + all);
if (all >= 2 && a[all - 2] == 2 && a[all - 1] == 3)
swap(a[all - 2], a[all - 1]);
for (int i = 0; i < n; i++) {
printf("%d\n", a[i]);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
using namespace std;
int n;
int a[101];
int main(void) {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
}
sort(a, a + n);
reverse(a, a + n);
int all = n;
for (int i = n - 1; i >= 0; i--) {
if (a[i] == 0)
all--;
else
break;
}
int zero = all;
for (int i = all - 1; i >= 0; i--) {
if (a[i] == 1)
all--;
else
break;
}
int sw = (n - all) - (zero - all);
sort(a + all, a + n);
if ((n - zero) % 2 == 1) {
if (zero - all >= 1)
swap(a[all + sw - 1], a[all + sw]);
else {
for (int i = all - 1; i + 2 < n; i += 2) {
swap(a[i], a[i + 2]);
}
all--;
}
}
if (all >= 0)
sort(a, a + all);
if (all >= 2 && a[all - 2] == 2 && a[all - 1] == 3)
swap(a[all - 2], a[all - 1]);
for (int i = 0; i < n; i++) {
printf("%d\n", a[i]);
}
return 0;
} | replace | 41 | 42 | 41 | 43 | 0 | |
p01412 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cout << *i << " ";
cout << endl;
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
string memo[101][101][2];
string rec(int x, int y, int z) {
if (memo[x][y][z] != "U")
return memo[x][y][z];
if (x < 0 || y < 0)
assert(false);
if (x == 0 && y == 0)
assert(false);
if (x == 0) {
if (z == 0)
return "Z";
return memo[x][y][z] = string(y, '1');
}
if (y == 0) {
if (x % 2 == 1 && z == 0)
return memo[x][y][z] = string(x, '0');
if (x % 2 == 0 && z == 1)
return memo[x][y][z] = string(x, '0');
return memo[x][y][z] = "Z";
}
if (z == 0) {
string res = "0" + rec(x - 1, y, 1);
if (res[res.size() - 1] == 'Z')
return memo[x][y][z] = "Z";
return memo[x][y][z] = res;
} else {
string s = "Z";
if (rec(x - 1, y, 0) != "Z")
s = min(s, "0" + rec(x - 1, y, 0));
if (rec(x, y - 1, 0) != "Z")
s = min(s, "1" + rec(x, y - 1, 0));
if (rec(x, y - 1, 1) != "Z")
s = min(s, "1" + rec(x, y - 1, 1));
if (s[s.size() - 1] == 'Z')
s = "Z";
memo[x][y][z] = s;
return s;
}
}
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int main() {
int N;
REP(y, 101) REP(x, 101) REP(z, 2) memo[x][y][z] = "U";
while (cin >> N) {
vector<int> a;
int c0 = 0, c1 = 0;
REP(i, N) {
int t;
cin >> t;
if (t == 0)
c0++;
else if (t == 1)
c1++;
else
a.push_back(t);
}
sort(a.begin(), a.end());
string s = "";
if (c0 + c1 > 0)
s = rec(c0, c1, 1);
if (s == "Z") {
s = string(c0 - 1, '0') + itos(a[0]) + "0";
a.erase(a.begin());
if (a.size() >= 2 && a[a.size() - 2] == 2 && a[a.size() - 1] == 3)
swap(a[a.size() - 2], a[a.size() - 1]);
REP(i, a.size()) cout << a[i] << endl;
REP(i, s.size()) cout << s[i] << endl;
} else {
if (a.size() >= 2 && a[a.size() - 2] == 2 && a[a.size() - 1] == 3)
swap(a[a.size() - 2], a[a.size() - 1]);
REP(i, a.size()) cout << a[i] << endl;
REP(i, s.size()) cout << s[i] << endl;
}
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)n; ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cout << *i << " ";
cout << endl;
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
string memo[101][101][2];
string rec(int x, int y, int z) {
if (memo[x][y][z] != "U")
return memo[x][y][z];
if (x < 0 || y < 0)
assert(false);
if (x == 0 && y == 0)
assert(false);
if (x == 0) {
if (z == 0)
return "Z";
return memo[x][y][z] = string(y, '1');
}
if (y == 0) {
if (x % 2 == 1 && z == 0)
return memo[x][y][z] = string(x, '0');
if (x % 2 == 0 && z == 1)
return memo[x][y][z] = string(x, '0');
return memo[x][y][z] = "Z";
}
if (z == 0) {
string res = "0" + rec(x - 1, y, 1);
if (res[res.size() - 1] == 'Z')
return memo[x][y][z] = "Z";
return memo[x][y][z] = res;
} else {
string s = "Z";
if (rec(x - 1, y, 0) != "Z")
s = min(s, "0" + rec(x - 1, y, 0));
if (rec(x, y - 1, 0) != "Z")
s = min(s, "1" + rec(x, y - 1, 0));
if (rec(x, y - 1, 1) != "Z")
s = min(s, "1" + rec(x, y - 1, 1));
if (s[s.size() - 1] == 'Z')
s = "Z";
memo[x][y][z] = s;
return s;
}
}
string itos(int n) {
stringstream ss;
ss << n;
return ss.str();
}
int main() {
int N;
REP(y, 101) REP(x, 101) REP(z, 2) memo[x][y][z] = "U";
while (cin >> N) {
vector<int> a;
int c0 = 0, c1 = 0;
REP(i, N) {
int t;
cin >> t;
if (t == 0)
c0++;
else if (t == 1)
c1++;
else
a.push_back(t);
}
sort(a.begin(), a.end());
string s = "";
if (c0 + c1 > 0)
s = rec(c0, c1, 1);
if (s == "Z") {
if (a.size() > 0) {
s = string(c0 - 1, '0') + itos(a[0]) + "0";
a.erase(a.begin());
if (a.size() >= 2 && a[a.size() - 2] == 2 && a[a.size() - 1] == 3)
swap(a[a.size() - 2], a[a.size() - 1]);
} else {
s = string(c0, '0');
}
REP(i, a.size()) cout << a[i] << endl;
REP(i, s.size()) cout << s[i] << endl;
} else {
if (a.size() >= 2 && a[a.size() - 2] == 2 && a[a.size() - 1] == 3)
swap(a[a.size() - 2], a[a.size() - 1]);
REP(i, a.size()) cout << a[i] << endl;
REP(i, s.size()) cout << s[i] << endl;
}
}
return 0;
} | replace | 98 | 102 | 98 | 106 | 0 | |
p01412 | C++ | Runtime Error | #include <algorithm>
#include <deque>
#include <iostream>
#include <array>
#include <cmath>
#include <map>
using namespace std;
// const int T=5;
// array<int,T> a;
// map<array<int,T>,array<int,T> > m;
// double pow(array<int,T> a){
// double d=a[T-1];
// for(int x=T-2;x>=0;x--){
// d=(a[x]==0&&d==0)?1:pow(a[x],d);
// }
// return d;
// }
// void dfs(int d){
// if(d<T){
// for(int i=0;i<T;i++){
// a[d]=i;
// dfs(d+1);
// }
// }else{
// auto c=a;
// sort(begin(c),end(c));
// if(m.count(c)==0||pow(m[c])<pow(a)-.5){
// m[c]=a;
// }
// }
// }
// int main(){
// dfs(0);
// for(auto e:m){
// for(auto f:e.second){
// cout<<f<<' ';
// }
// cout<<pow(e.second)<<endl;
// }
// }
int main() {
int N;
cin >> N;
deque<int> deq(N);
for (int i = 0; i < N; i++) {
cin >> deq[i];
}
sort(begin(deq), end(deq));
deque<int> ans;
auto o = find(begin(deq), end(deq), 1);
if (o != end(deq) && (o - begin(deq)) % 2) {
swap(*o, o[-1]);
}
while (!deq.empty() && deq[0] <= 1) {
ans.push_back(deq[0]);
deq.pop_front();
}
int nzf = 0;
while (nzf < ans.size() && ans[nzf] == 0) {
nzf++;
}
if (nzf % 2) {
ans.push_front(deq[0]);
deq.pop_front();
}
while (!deq.empty() && deq[0] == 1) {
ans.push_front(deq[0]);
deq.pop_front();
}
if (deq.size() >= 2 && deq.back() == 3 && deq[deq.size() - 2] == 2) {
swap(deq[deq.size() - 2], deq[deq.size() - 1]);
}
ans.insert(begin(ans), begin(deq), end(deq));
for (auto e : ans) {
cout << e << endl;
}
}
| #include <algorithm>
#include <deque>
#include <iostream>
#include <array>
#include <cmath>
#include <map>
using namespace std;
// const int T=5;
// array<int,T> a;
// map<array<int,T>,array<int,T> > m;
// double pow(array<int,T> a){
// double d=a[T-1];
// for(int x=T-2;x>=0;x--){
// d=(a[x]==0&&d==0)?1:pow(a[x],d);
// }
// return d;
// }
// void dfs(int d){
// if(d<T){
// for(int i=0;i<T;i++){
// a[d]=i;
// dfs(d+1);
// }
// }else{
// auto c=a;
// sort(begin(c),end(c));
// if(m.count(c)==0||pow(m[c])<pow(a)-.5){
// m[c]=a;
// }
// }
// }
// int main(){
// dfs(0);
// for(auto e:m){
// for(auto f:e.second){
// cout<<f<<' ';
// }
// cout<<pow(e.second)<<endl;
// }
// }
int main() {
int N;
cin >> N;
deque<int> deq(N);
for (int i = 0; i < N; i++) {
cin >> deq[i];
}
sort(begin(deq), end(deq));
deque<int> ans;
if (deq[0] <= 1) {
int no = count(begin(deq), end(deq), 1);
auto p = upper_bound(begin(deq), end(deq), 1);
auto o = lower_bound(begin(deq), end(deq), 1);
if (o != end(deq) && (o - begin(deq)) % 2) {
swap(*o, o[-1]);
if (o == p) {
p++;
}
}
ans.insert(begin(ans), begin(deq), p);
deq.erase(begin(deq), p);
}
if (deq.size() >= 2 && deq.back() == 3 && deq[deq.size() - 2] == 2) {
swap(deq[deq.size() - 2], deq[deq.size() - 1]);
}
ans.insert(begin(ans), begin(deq), end(deq));
for (auto e : ans) {
cout << e << endl;
}
} | replace | 58 | 77 | 58 | 70 | 0 | |
p01412 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
namespace {
typedef double real;
typedef long long ll;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vs) {
for (int i = 0; i < vs.size(); i++) {
os << vs[i] << endl;
}
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &vs) {
for (auto it = vs.begin(); it != vs.end(); it++)
is >> *it;
return is;
}
bool comp(int a, int b) {
if (a == b)
return true;
if (a > b)
return not comp(b, a);
if (a == 1)
return false;
if (a == 2) {
if (b == 3)
return false;
else
return true;
}
return true;
}
int N;
vector<int> A;
void input() {
cin >> N;
A.clear();
A.resize(N);
cin >> A;
}
const int INF = 1 << 30;
int step(vector<int> &ans, vector<int> &stack, int prev) {
int x = stack.back();
stack.pop_back();
if (comp(x, prev)) {
vector<int> a;
a.push_back(x);
a.insert(a.end(), ans.begin(), ans.end());
ans = a;
return INF;
} else {
ans.push_back(x);
if (prev == INF || x >= 30)
return INF;
real p = pow(real(prev), x);
return (p >= INF ? INF : int(p));
}
}
void solve() {
vector<int> nA;
int zcount = 0;
int ocount = 0;
for (int i = 0; i < N; i++) {
if (A[i] == 0)
zcount++;
else if (A[i] == 1)
ocount++;
else
nA.push_back(A[i]);
}
sort(nA.begin(), nA.end());
vector<int> ans;
if (zcount % 2 == 0) {
int p = nA.back();
nA.pop_back();
ans.push_back(p);
while (not nA.empty()) {
p = step(ans, nA, p);
}
for (int i = 0; i < zcount; i++)
ans.push_back(0);
for (int i = 0; i < ocount; i++)
ans.push_back(1);
} else {
int s = -1;
if (ocount >= 1) {
s = 1;
ocount--;
} else if (not nA.empty()) {
s = nA[0];
nA.erase(nA.begin(), nA.begin() + 1);
}
if (not nA.empty()) {
int p = nA.back();
nA.pop_back();
ans.push_back(p);
while (not nA.empty()) {
p = step(ans, nA, p);
}
}
for (int i = 0; i < zcount - 1; i++)
ans.push_back(0);
if (s >= 0)
ans.push_back(s);
ans.push_back(0);
for (int i = 0; i < ocount; i++)
ans.push_back(1);
}
cout << ans;
}
} // namespace
int main() {
input();
solve();
return 0;
} | #include <bits/stdc++.h>
using namespace std;
namespace {
typedef double real;
typedef long long ll;
template <class T> ostream &operator<<(ostream &os, const vector<T> &vs) {
for (int i = 0; i < vs.size(); i++) {
os << vs[i] << endl;
}
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &vs) {
for (auto it = vs.begin(); it != vs.end(); it++)
is >> *it;
return is;
}
bool comp(int a, int b) {
if (a == b)
return true;
if (a > b)
return not comp(b, a);
if (a == 1)
return false;
if (a == 2) {
if (b == 3)
return false;
else
return true;
}
return true;
}
int N;
vector<int> A;
void input() {
cin >> N;
A.clear();
A.resize(N);
cin >> A;
}
const int INF = 1 << 30;
int step(vector<int> &ans, vector<int> &stack, int prev) {
int x = stack.back();
stack.pop_back();
if (comp(x, prev)) {
vector<int> a;
a.push_back(x);
a.insert(a.end(), ans.begin(), ans.end());
ans = a;
return INF;
} else {
ans.push_back(x);
if (prev == INF || x >= 30)
return INF;
real p = pow(real(prev), x);
return (p >= INF ? INF : int(p));
}
}
void solve() {
vector<int> nA;
int zcount = 0;
int ocount = 0;
for (int i = 0; i < N; i++) {
if (A[i] == 0)
zcount++;
else if (A[i] == 1)
ocount++;
else
nA.push_back(A[i]);
}
sort(nA.begin(), nA.end());
vector<int> ans;
if (zcount % 2 == 0) {
if (not nA.empty()) {
int p = nA.back();
nA.pop_back();
ans.push_back(p);
while (not nA.empty()) {
p = step(ans, nA, p);
}
}
for (int i = 0; i < zcount; i++)
ans.push_back(0);
for (int i = 0; i < ocount; i++)
ans.push_back(1);
} else {
int s = -1;
if (ocount >= 1) {
s = 1;
ocount--;
} else if (not nA.empty()) {
s = nA[0];
nA.erase(nA.begin(), nA.begin() + 1);
}
if (not nA.empty()) {
int p = nA.back();
nA.pop_back();
ans.push_back(p);
while (not nA.empty()) {
p = step(ans, nA, p);
}
}
for (int i = 0; i < zcount - 1; i++)
ans.push_back(0);
if (s >= 0)
ans.push_back(s);
ans.push_back(0);
for (int i = 0; i < ocount; i++)
ans.push_back(1);
}
cout << ans;
}
} // namespace
int main() {
input();
solve();
return 0;
} | replace | 81 | 86 | 81 | 88 | 0 | |
p01413 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(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 long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
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--------------------*/
ll dist[10][10];
ll n, m, w, t;
ll shpdp[10][1111];
ll knapdp[1111][11111];
ll shp(int v, int used) {
if (used == (1 << n) - 1)
return dist[v][n];
if (shpdp[v][used] >= 0)
return shpdp[v][used];
ll res = INF;
REP(i, n) {
if ((used >> i) & 1)
continue;
chmin(res, shp(i, used | (1 << i)) + dist[v][i]);
}
return shpdp[v][used] = res;
}
ll knapsack(int i, int wei, vi &weight, vi &value) {
if (i == weight.size())
return 0;
if (knapdp[i][wei] >= 0)
return knapdp[i][wei];
ll res = 0;
if (weight[i] == 0)
res = knapsack(i + 1, wei, weight, value);
else {
if (wei >= weight[i]) {
chmax(res, knapsack(i, wei - weight[i], weight, value) + value[i]);
chmax(res, knapsack(i + 1, wei - weight[i], weight, value) + value[i]);
}
chmax(res, knapsack(i + 1, wei, weight, value));
}
return knapdp[i][wei] = res;
}
int main() {
cin.sync_with_stdio(false);
map<string, pii> mp;
cin >> n >> m >> w >> t;
REP(i, m) {
string s;
int v, p;
cin >> s >> v >> p;
mp[s] = pii(v, p);
}
vi x(n), y(n);
vector<vi> weight(n), value(n);
REP(i, n) {
int l;
cin >> l >> x[i] >> y[i];
REP(j, l) {
string r;
int q;
cin >> r >> q;
weight[i].push_back(mp[r].first);
value[i].push_back(mp[r].second - q);
}
}
x.push_back(0), y.push_back(0);
REP(i, n + 1) REP(j, n + 1) {
dist[i][j] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
vi cost(1 << n), val(1 << n);
REP(i, 1 << n) {
MS(shpdp, -1);
cost[i] = shp(n, i);
vi tw, tv;
REP(j, n) {
if ((i >> j) & 1)
continue;
REP(k, weight[j].size()) {
tw.push_back(weight[j][k]);
tv.push_back(value[j][k]);
}
}
MS(knapdp, -1);
val[i] = knapsack(0, w, tw, tv);
}
MS(knapdp, -1);
cout << knapsack(0, t, cost, val) << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(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 long long ll;
typedef long double ld;
typedef vector<ll> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
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--------------------*/
ll dist[10][10];
ll n, m, w, t;
ll shpdp[10][1111];
ll knapdp[555][11111];
ll shp(int v, int used) {
if (used == (1 << n) - 1)
return dist[v][n];
if (shpdp[v][used] >= 0)
return shpdp[v][used];
ll res = INF;
REP(i, n) {
if ((used >> i) & 1)
continue;
chmin(res, shp(i, used | (1 << i)) + dist[v][i]);
}
return shpdp[v][used] = res;
}
ll knapsack(int i, int wei, vi &weight, vi &value) {
if (i == weight.size())
return 0;
if (knapdp[i][wei] >= 0)
return knapdp[i][wei];
ll res = 0;
if (weight[i] == 0)
res = knapsack(i + 1, wei, weight, value);
else {
if (wei >= weight[i]) {
chmax(res, knapsack(i, wei - weight[i], weight, value) + value[i]);
chmax(res, knapsack(i + 1, wei - weight[i], weight, value) + value[i]);
}
chmax(res, knapsack(i + 1, wei, weight, value));
}
return knapdp[i][wei] = res;
}
int main() {
cin.sync_with_stdio(false);
map<string, pii> mp;
cin >> n >> m >> w >> t;
REP(i, m) {
string s;
int v, p;
cin >> s >> v >> p;
mp[s] = pii(v, p);
}
vi x(n), y(n);
vector<vi> weight(n), value(n);
REP(i, n) {
int l;
cin >> l >> x[i] >> y[i];
REP(j, l) {
string r;
int q;
cin >> r >> q;
weight[i].push_back(mp[r].first);
value[i].push_back(mp[r].second - q);
}
}
x.push_back(0), y.push_back(0);
REP(i, n + 1) REP(j, n + 1) {
dist[i][j] = abs(x[i] - x[j]) + abs(y[i] - y[j]);
}
vi cost(1 << n), val(1 << n);
REP(i, 1 << n) {
MS(shpdp, -1);
cost[i] = shp(n, i);
vi tw, tv;
REP(j, n) {
if ((i >> j) & 1)
continue;
REP(k, weight[j].size()) {
tw.push_back(weight[j][k]);
tv.push_back(value[j][k]);
}
}
MS(knapdp, -1);
val[i] = knapsack(0, w, tw, tv);
}
MS(knapdp, -1);
cout << knapsack(0, t, cost, val) << endl;
return 0;
} | replace | 23 | 24 | 23 | 24 | MLE | |
p01413 | C++ | Runtime Error | // #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#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 debug(...) fprintf(stderr, __VA_ARGS__)
#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};
const int INF = 1LL << 60;
const ll MOD = 1000000007LL;
int N, M, W, T;
int dp[1 << 8][8], rec[1 << 7][10010][8], best[1 << 7][8], tmr[1 << 7][8];
int res[10010];
map<string, int> item_map;
string S[10], R[10][10];
int V[10], P[10], L[10], X[10], Y[10], Q[10][10], idR[10][10], idS[10];
signed main() {
cin >> N >> M >> W >> T;
for (int i = 0; i < M; i++) {
cin >> S[i] >> V[i] >> P[i];
item_map[S[i]] = i;
}
for (int i = 0; i < N; i++) {
cin >> L[i] >> X[i] >> Y[i];
for (int k = 0; k < L[i]; k++) {
cin >> R[i][k] >> Q[i][k];
}
}
/*
int id = 0;
for(auto &e : item_map) e.second = id++;
for(int i=0; i<M; i++) idS[i] = item_map[ S[i] ];
*/
for (int i = 0; i < N; i++) {
for (int j = 0; j < L[i]; j++) {
idR[i][j] = item_map[R[i][j]];
}
}
N++;
fill(dp[0], dp[1 << N], INF);
dp[0][N - 1] = 0;
for (int bit = 0; bit < (1 << N); bit++) {
for (int i = 0; i < N; i++) {
if (dp[bit][i] == INF)
continue;
// fprintf(stderr, "dp[%lld][%lld] = %lld\n", bit, i, dp[bit][i]);
for (int k = 0; k < N; k++) {
if (i == k or (bit >> k & 1))
continue;
int nbit = bit | (1 << k);
int dis = abs(X[i] - X[k]) + abs(Y[i] - Y[k]);
chmin(dp[nbit][k], dp[bit][i] + dis);
}
}
}
fill(rec[0][0], rec[1 << N][0], -1);
rec[0][0][N - 1] = 0;
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int i = 0; i < N; i++) {
for (int k = 0; k < N - 1; k++) {
if (i == k or (bit >> k & 1))
continue;
int nbit = bit | (1 << k);
for (int w = 0; w <= W; w++) {
if (rec[bit][w][i] < 0)
continue;
// fprintf(stderr, "rec[%lld][%lld][%lld] = %lld\n", bit, w, i,
// rec[bit][w][i]);
chmax(rec[nbit][w][k], rec[bit][w][i]);
}
for (int x = 0; x < L[k]; x++) {
int earn = P[idR[k][x]] - Q[k][x];
int weight = V[idR[k][x]];
// if(nbit == 1) // fprintf(stderr, "earn = %lld, weight = %lld\n",
// earn, weight);
for (int w = 0; w <= W - weight; w++) {
if (rec[nbit][w][k] < 0)
continue;
chmax(rec[nbit][w + weight][k], rec[nbit][w][k] + earn);
}
}
}
}
}
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int i = 0; i < N - 1; i++) {
int ma = 0;
for (int j = 0; j <= W; j++)
ma = max(ma, rec[bit][j][i]);
best[bit][i] = ma;
tmr[bit][i] = dp[bit][i] + abs(X[i]) + abs(Y[i]);
if (tmr[bit][i] >= INF)
continue;
// fprintf(stderr, "best[%lld][%lld] = %lld, tmr = %lld\n", bit, i,
// best[bit][i], tmr[bit][i]);
}
}
for (int i = 0; i <= T; i++) {
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int k = 0; k < N - 1; k++) {
if (i + tmr[bit][k] > T)
continue;
chmax(res[i + tmr[bit][k]], res[i] + best[bit][k]);
}
}
}
cout << *max_element(res, res + T + 1) << endl;
return 0;
}
| // #define _GLIBCXX_DEBUG // for STL debug (optional)
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <deque>
#include <fstream>
#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 debug(...) fprintf(stderr, __VA_ARGS__)
#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};
const int INF = 1LL << 60;
const ll MOD = 1000000007LL;
int N, M, W, T;
int dp[1 << 8][8], rec[1 << 7][10010][8], best[1 << 7][8], tmr[1 << 7][8];
int res[10010];
map<string, int> item_map;
string S[10], R[10][10];
int V[10], P[10], L[10], X[10], Y[10], Q[10][10], idR[10][10], idS[10];
signed main() {
cin >> N >> M >> W >> T;
for (int i = 0; i < M; i++) {
cin >> S[i] >> V[i] >> P[i];
item_map[S[i]] = i;
}
for (int i = 0; i < N; i++) {
cin >> L[i] >> X[i] >> Y[i];
for (int k = 0; k < L[i]; k++) {
cin >> R[i][k] >> Q[i][k];
}
}
/*
int id = 0;
for(auto &e : item_map) e.second = id++;
for(int i=0; i<M; i++) idS[i] = item_map[ S[i] ];
*/
for (int i = 0; i < N; i++) {
for (int j = 0; j < L[i]; j++) {
idR[i][j] = item_map[R[i][j]];
}
}
N++;
fill(dp[0], dp[1 << N], INF);
dp[0][N - 1] = 0;
for (int bit = 0; bit < (1 << N); bit++) {
for (int i = 0; i < N; i++) {
if (dp[bit][i] == INF)
continue;
// fprintf(stderr, "dp[%lld][%lld] = %lld\n", bit, i, dp[bit][i]);
for (int k = 0; k < N; k++) {
if (i == k or (bit >> k & 1))
continue;
int nbit = bit | (1 << k);
int dis = abs(X[i] - X[k]) + abs(Y[i] - Y[k]);
chmin(dp[nbit][k], dp[bit][i] + dis);
}
}
}
fill(rec[0][0], rec[1 << (N - 1)][0], -1);
rec[0][0][N - 1] = 0;
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int i = 0; i < N; i++) {
for (int k = 0; k < N - 1; k++) {
if (i == k or (bit >> k & 1))
continue;
int nbit = bit | (1 << k);
for (int w = 0; w <= W; w++) {
if (rec[bit][w][i] < 0)
continue;
// fprintf(stderr, "rec[%lld][%lld][%lld] = %lld\n", bit, w, i,
// rec[bit][w][i]);
chmax(rec[nbit][w][k], rec[bit][w][i]);
}
for (int x = 0; x < L[k]; x++) {
int earn = P[idR[k][x]] - Q[k][x];
int weight = V[idR[k][x]];
// if(nbit == 1) // fprintf(stderr, "earn = %lld, weight = %lld\n",
// earn, weight);
for (int w = 0; w <= W - weight; w++) {
if (rec[nbit][w][k] < 0)
continue;
chmax(rec[nbit][w + weight][k], rec[nbit][w][k] + earn);
}
}
}
}
}
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int i = 0; i < N - 1; i++) {
int ma = 0;
for (int j = 0; j <= W; j++)
ma = max(ma, rec[bit][j][i]);
best[bit][i] = ma;
tmr[bit][i] = dp[bit][i] + abs(X[i]) + abs(Y[i]);
if (tmr[bit][i] >= INF)
continue;
// fprintf(stderr, "best[%lld][%lld] = %lld, tmr = %lld\n", bit, i,
// best[bit][i], tmr[bit][i]);
}
}
for (int i = 0; i <= T; i++) {
for (int bit = 0; bit < (1 << (N - 1)); bit++) {
for (int k = 0; k < N - 1; k++) {
if (i + tmr[bit][k] > T)
continue;
chmax(res[i + tmr[bit][k]], res[i] + best[bit][k]);
}
}
}
cout << *max_element(res, res + T + 1) << endl;
return 0;
}
| replace | 93 | 94 | 93 | 94 | 0 | |
p01414 | 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 zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int main() {
const string cols = "RGB";
int N;
cin >> N;
vector<pair<int, int>> vs(N);
rep(i, N) { cin >> vs[i].first >> vs[i].second; }
vector<string> G(4);
rep(i, 4) cin >> G[i];
static int dist[1 << 16];
minus(dist);
dist[0] = 0;
queue<int> q;
q.push(0);
while (!q.empty()) {
if (~dist[(1 << 16) - 1])
break;
int curr = q.front();
q.pop();
for (auto hw : vs) {
int h = hw.first, w = hw.second;
for (auto col : cols)
REP(i, -h + 1, 4) REP(j, -w + 1, 4) {
int next = curr;
REP(y, i, min(i + h, 4)) REP(x, j, min(j + w, 4)) {
if (G[y][x] == col)
next |= 1 << (y * 4 + x);
else
next &= ~(1 << (y * 4 + x));
}
if (dist[next] < 0) {
dist[next] = dist[curr] + 1;
q.push(next);
}
}
}
}
cout << dist[(1 << 16) - 1] << endl;
return 0;
} | #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 zero(a) memset(a, 0, sizeof a)
#define minus(a) memset(a, -1, sizeof a)
#define watch(a) \
{ cout << #a << " = " << a << endl; }
template <class T1, class T2> inline bool minimize(T1 &a, T2 b) {
return b < a && (a = b, 1);
}
template <class T1, class T2> inline bool maximize(T1 &a, T2 b) {
return a < b && (a = b, 1);
}
typedef long long ll;
int const inf = 1 << 29;
int main() {
const string cols = "RGB";
int N;
cin >> N;
vector<pair<int, int>> vs(N);
rep(i, N) { cin >> vs[i].first >> vs[i].second; }
vector<string> G(4);
rep(i, 4) cin >> G[i];
static int dist[1 << 16];
minus(dist);
dist[0] = 0;
queue<int> q;
q.push(0);
while (!q.empty()) {
if (~dist[(1 << 16) - 1])
break;
int curr = q.front();
q.pop();
for (auto hw : vs) {
int h = hw.first, w = hw.second;
for (auto col : cols)
REP(i, -h + 1, 4) REP(j, -w + 1, 4) {
int next = curr;
REP(y, max(0, i), min(i + h, 4)) REP(x, max(0, j), min(j + w, 4)) {
if (G[y][x] == col)
next |= 1 << (y * 4 + x);
else
next &= ~(1 << (y * 4 + x));
}
if (dist[next] < 0) {
dist[next] = dist[curr] + 1;
q.push(next);
}
}
}
}
cout << dist[(1 << 16) - 1] << endl;
return 0;
} | replace | 52 | 53 | 52 | 53 | -11 | |
p01414 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 100000000;
const double EPS = 1e-10;
const int MOD = 1000000007;
using namespace std;
typedef pair<int, int> P;
int n;
int h[20], w[20];
int brd[7][7];
int dp[(1 << 16)];
int main() {
rep(i, (1 << 16)) dp[i] = INF;
dp[0] = 0;
cin >> n;
rep(i, n) cin >> h[i] >> w[i];
for (int i = 3; i < 7; i++)
for (int j = 3; j < 7; j++) {
char c;
cin >> c;
if (c == 'R')
brd[i][j] = 1;
if (c == 'G')
brd[i][j] = 2;
if (c == 'B')
brd[i][j] = 3;
}
queue<int> que;
que.push(0);
while (!que.empty()) {
int q = que.front();
int Q = q;
que.pop();
int b[7][7];
rep(i, 7) rep(j, 7) b[i][j] = 0;
for (int i = 3; i < 7; i++)
for (int j = 3; j < 7; j++) {
b[i][j] = (q & 1);
q >>= 1;
}
q = Q;
rep(i, n) {
rep(j, 7) {
rep(k, 7) {
if (j + h[i] < 3 || k + w[i] < 3)
continue;
//{
int l = -1;
rep(hh, h[i]) {
if (j + hh >= 7)
continue;
rep(ww, w[i]) {
if (k + ww >= 7)
continue;
if (b[j + hh][k + ww] == 0 && brd[j + hh][k + ww] != 0) {
l = brd[j + hh][k + ww];
break;
}
}
}
if (l == -1)
continue;
bool ok = true;
rep(hh, h[i]) {
if (j + hh >= 7)
continue;
rep(ww, w[i]) {
if (k + ww >= 7)
continue;
if (b[j + hh][k + ww] == 0 && brd[j + hh][k + ww] != 0 &&
brd[j + hh][k + ww] != l) {
ok = false;
break;
}
}
if (!ok)
break;
}
if (!ok)
continue;
int x = 0;
for (int hh = 6; hh >= 3; hh--) {
for (int ww = 6; ww >= 3; ww--) {
if (j <= hh && hh < j + h[i] && k <= ww && ww < k + w[i]) {
x *= 2;
x += 1;
} else {
x *= 2;
x += b[hh][ww];
}
}
}
if (dp[x] > dp[q] + 1) {
dp[x] = dp[q] + 1;
que.push(x);
}
//}
}
}
}
}
cout << dp[(1 << 16) - 1] << endl;
} | #include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
const int INF = 100000000;
const double EPS = 1e-10;
const int MOD = 1000000007;
using namespace std;
typedef pair<int, int> P;
int n;
int h[20], w[20];
int brd[7][7];
int dp[(1 << 16)];
int main() {
rep(i, (1 << 16)) dp[i] = INF;
dp[0] = 0;
cin >> n;
rep(i, n) cin >> h[i] >> w[i];
for (int i = 3; i < 7; i++)
for (int j = 3; j < 7; j++) {
char c;
cin >> c;
if (c == 'R')
brd[i][j] = 1;
if (c == 'G')
brd[i][j] = 2;
if (c == 'B')
brd[i][j] = 3;
}
queue<int> que;
que.push(0);
while (!que.empty()) {
int q = que.front();
int Q = q;
que.pop();
int b[7][7];
rep(i, 7) rep(j, 7) b[i][j] = 0;
for (int i = 3; i < 7; i++)
for (int j = 3; j < 7; j++) {
b[i][j] = (q & 1);
q >>= 1;
}
q = Q;
rep(i, n) {
rep(j, 7) {
rep(k, 7) {
if (j + h[i] < 3 || k + w[i] < 3)
continue;
//{
int l = -1;
rep(hh, h[i]) {
if (j + hh >= 7)
continue;
rep(ww, w[i]) {
if (k + ww >= 7)
continue;
if (b[j + hh][k + ww] == 0 && brd[j + hh][k + ww] != 0) {
l = brd[j + hh][k + ww];
break;
}
}
}
if (l == -1)
continue;
bool ok = true;
rep(hh, h[i]) {
if (j + hh >= 7)
continue;
rep(ww, w[i]) {
if (k + ww >= 7)
continue;
if (b[j + hh][k + ww] == 0 && brd[j + hh][k + ww] != 0 &&
brd[j + hh][k + ww] != l) {
ok = false;
break;
}
}
if (!ok)
break;
}
if (!ok)
continue;
int x = 0;
for (int hh = 6; hh >= 3; hh--) {
for (int ww = 6; ww >= 3; ww--) {
if (j <= hh && hh < j + h[i] && k <= ww && ww < k + w[i]) {
x *= 2;
x += 1;
} else {
x *= 2;
x += b[hh][ww];
}
}
}
if (dp[x] > dp[q] + 1) {
dp[x] = dp[q] + 1;
que.push(x);
if (x == (1 << 16) - 1) {
queue<int> emp;
swap(que, emp);
}
}
//}
}
}
}
}
cout << dp[(1 << 16) - 1] << endl;
} | insert | 97 | 97 | 97 | 101 | TLE | |
p01414 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long i64;
typedef long double ld;
typedef pair<i64, i64> P;
#define rep(i, s, e) for (int i = (s); i <= (e); i++)
int n;
vector<int> h, w;
vector<vector<int>> fie(4, vector<int>(4));
vector<int> dist(1 << 16, -1);
int main() {
cin >> n;
h.resize(n);
w.resize(n);
rep(i, 0, n - 1) cin >> h[i] >> w[i];
rep(i, 0, 3) rep(j, 0, 3) {
char c;
cin >> c;
if (c == 'R')
fie[i][j] = 0;
if (c == 'G')
fie[i][j] = 1;
if (c == 'B')
fie[i][j] = 2;
}
queue<int> que;
que.push(0);
dist[0] = 0;
while (!que.empty()) {
int v = que.front();
que.pop();
if (v == (1 << 16) - 1) {
cout << dist[v] << endl;
return 0;
}
rep(c, 0, 2) rep(s, 0, n - 1) {
rep(i, -3, 3) rep(j, -3, 3) {
int u = v;
rep(x, max(i, 0), min(i + h[s] - 1, 3))
rep(y, max(j, 0), min(j + w[s] - 1, 3)) {
int index = (x * 4 + y);
if (u & (1 << index)) {
if (fie[x][y] != c)
u ^= (1 << index);
} else {
if (fie[x][y] == c)
u ^= (1 << index);
}
}
if (dist[u] == -1) {
dist[u] = dist[v] + 1;
que.push(u);
}
}
}
}
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <vector>
using namespace std;
typedef long long i64;
typedef long double ld;
typedef pair<i64, i64> P;
#define rep(i, s, e) for (int i = (s); i <= (e); i++)
int n;
vector<int> h, w;
vector<vector<int>> fie(4, vector<int>(4));
vector<int> dist(1 << 16, -1);
int main() {
cin >> n;
h.resize(n);
w.resize(n);
rep(i, 0, n - 1) cin >> h[i] >> w[i];
rep(i, 0, 3) rep(j, 0, 3) {
char c;
cin >> c;
if (c == 'R')
fie[i][j] = 0;
if (c == 'G')
fie[i][j] = 1;
if (c == 'B')
fie[i][j] = 2;
}
queue<int> que;
que.push(0);
dist[0] = 0;
while (!que.empty()) {
int v = que.front();
que.pop();
if (v == (1 << 16) - 1) {
cout << dist[v] << endl;
return 0;
}
rep(c, 0, 2) rep(s, 0, n - 1) {
rep(i, -h[s] + 1, 3) rep(j, -w[s] + 1, 3) {
int u = v;
rep(x, max(i, 0), min(i + h[s] - 1, 3))
rep(y, max(j, 0), min(j + w[s] - 1, 3)) {
int index = (x * 4 + y);
if (u & (1 << index)) {
if (fie[x][y] != c)
u ^= (1 << index);
} else {
if (fie[x][y] == c)
u ^= (1 << index);
}
}
if (dist[u] == -1) {
dist[u] = dist[v] + 1;
que.push(u);
}
}
}
}
}
| replace | 49 | 50 | 49 | 50 | TLE | |
p01414 | C++ | Time Limit Exceeded | #include <algorithm>
#include <queue>
#include <stdio.h>
using namespace std;
int p[20];
int q[20];
char str[5][5];
int bfs[1 << 16];
char col[5] = "RGB";
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d%d", p + i, q + i);
}
for (int i = 0; i < 4; i++)
scanf("%s", str[i]);
for (int i = 0; i < (1 << 16); i++)
bfs[i] = -1;
bfs[0] = 0;
queue<int> Q;
Q.push(0);
while (Q.size()) {
if (~bfs[(1 << 16) - 1])
break;
int at = Q.front();
Q.pop();
for (int i = 0; i < a; i++) {
for (int j = -p[i] + 1; j < 4; j++) {
for (int k = -q[i] + 1; k < 4; k++) {
for (int c = 0; c < 3; c++) {
int to = at;
for (int l = 0; l < p[i]; l++)
for (int m = 0; m < q[i]; m++) {
if (j + l < 0 || k + m < 0 || j + l > 3 || k + m > 3)
continue;
if (str[j + l][k + m] == col[c])
to |= (1 << ((j + l) * 4 + k + m));
else
to &= (~(1 << ((j + l) * 4 + k + m)));
}
if (!~bfs[to]) {
bfs[to] = bfs[at] + 1;
Q.push(to);
}
}
}
}
}
}
printf("%d\n", bfs[(1 << 16) - 1]);
} | #include <algorithm>
#include <queue>
#include <stdio.h>
using namespace std;
int p[20];
int q[20];
char str[5][5];
int bfs[1 << 16];
char col[5] = "RGB";
int main() {
int a;
scanf("%d", &a);
for (int i = 0; i < a; i++) {
scanf("%d%d", p + i, q + i);
}
for (int i = 0; i < 4; i++)
scanf("%s", str[i]);
for (int i = 0; i < (1 << 16); i++)
bfs[i] = -1;
bfs[0] = 0;
queue<int> Q;
Q.push(0);
while (Q.size()) {
if (~bfs[(1 << 16) - 1])
break;
int at = Q.front();
Q.pop();
for (int i = 0; i < a; i++) {
for (int j = -p[i] + 1; j < 4; j++) {
for (int k = -q[i] + 1; k < 4; k++) {
for (int c = 0; c < 3; c++) {
int to = at;
for (int l = max(0, -j); l < min(p[i], 4 - j); l++)
for (int m = max(0, -k); m < min(q[i], 4 - k); m++) {
// if(j+l<0||k+m<0||j+l>3||k+m>3)continue;
if (str[j + l][k + m] == col[c])
to |= (1 << ((j + l) * 4 + k + m));
else
to &= (~(1 << ((j + l) * 4 + k + m)));
}
if (!~bfs[to]) {
bfs[to] = bfs[at] + 1;
Q.push(to);
}
}
}
}
}
}
printf("%d\n", bfs[(1 << 16) - 1]);
} | replace | 32 | 36 | 32 | 35 | TLE | |
p01414 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(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 long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
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--------------------*/
const int dx[] = {-1, 0, 0, 1}, dy[] = {0, -1, 1, 0};
//[const int dx[] = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy[] = { 0, -1, 1, -1, 1, 0,
//-1, 1 };
bool valid(int x, int y, int h, int w) {
return (x >= 0 && y >= 0 && x < h && y < w);
}
int place(int x, int y, int w) { return w * x + y; }
int n, h, w;
int main() {
cin >> n;
vector<pii> v;
REP(i, n) {
int a, b;
cin >> a >> b;
v.emplace_back(a, b);
}
int fld[4][4];
REP(i, 4) REP(j, 4) {
char c;
cin >> c;
if (c == 'R')
fld[i][j] = 0;
else if (c == 'G')
fld[i][j] = 1;
else
fld[i][j] = 2;
}
vi d(1 << 16, INF);
d[0] = 0;
queue<int> que;
que.push(0);
while (!que.empty()) {
int t = que.front();
que.pop();
if (t == (1 << 16) - 1) {
cout << d[t] << endl;
break;
}
REP(i, n) REP(j, 3) {
int h = v[i].first, w = v[i].second;
FOR(u, 1 - h, 4) FOR(l, 1 - w, 4) {
int tmp = t;
REP(dx, h) REP(dy, w) {
int x = u + dx, y = l + dy;
if (!valid(x, y, 4, 4))
continue;
if (fld[x][y] == j) {
tmp |= (1 << (x * 4 + y));
} else {
if ((tmp >> (x * 4 + y)) & 1)
tmp ^= (1 << (x * 4 + y));
}
}
if (d[tmp] == INF) {
d[tmp] = d[t] + 1;
que.push(tmp);
}
}
}
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define FOR(i, k, n) for (int i = (int)(k); i < (int)(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 long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<string> vs;
typedef pair<int, int> pii;
const int MOD = 1000000007;
const int INF = MOD + 1;
const ld EPS = 1e-12;
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--------------------*/
const int dx[] = {-1, 0, 0, 1}, dy[] = {0, -1, 1, 0};
//[const int dx[] = { -1, -1, -1, 0, 0, 1, 1, 1 }, dy[] = { 0, -1, 1, -1, 1, 0,
//-1, 1 };
bool valid(int x, int y, int h, int w) {
return (x >= 0 && y >= 0 && x < h && y < w);
}
int place(int x, int y, int w) { return w * x + y; }
int n, h, w;
int main() {
cin >> n;
vector<pii> v;
REP(i, n) {
int a, b;
cin >> a >> b;
v.emplace_back(a, b);
}
int fld[4][4];
REP(i, 4) REP(j, 4) {
char c;
cin >> c;
if (c == 'R')
fld[i][j] = 0;
else if (c == 'G')
fld[i][j] = 1;
else
fld[i][j] = 2;
}
vi d(1 << 16, INF);
d[0] = 0;
queue<int> que;
que.push(0);
while (!que.empty()) {
int t = que.front();
que.pop();
if (t == (1 << 16) - 1) {
cout << d[t] << endl;
break;
}
REP(i, n) REP(j, 3) {
int h = v[i].first, w = v[i].second;
FOR(u, 1 - h, 4) FOR(l, 1 - w, 4) {
int tmp = t;
FOR(x, max(0, u), min(4, u + h)) FOR(y, max(0, l), min(4, l + w)) {
if (fld[x][y] == j) {
tmp |= (1 << (x * 4 + y));
} else {
if ((tmp >> (x * 4 + y)) & 1)
tmp ^= (1 << (x * 4 + y));
}
}
if (d[tmp] == INF) {
d[tmp] = d[t] + 1;
que.push(tmp);
}
}
}
}
return 0;
} | replace | 64 | 68 | 64 | 65 | TLE | |
p01414 | C++ | Time Limit Exceeded | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int dp[1 << 16], n;
vector<pair<int, int>> x;
int col[4][4];
queue<int> Q;
int main() {
for (int i = 0; i < (1 << 16); i++)
dp[i] = 999999999;
dp[0] = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
x.push_back(make_pair(a, b));
}
Q.push(0);
for (int i = 0; i < 4; i++) {
string V;
cin >> V;
for (int j = 0; j < 4; j++) {
if (V[j] == 'R')
col[i][j] = 1;
if (V[j] == 'B')
col[i][j] = 2;
if (V[j] == 'G')
col[i][j] = 3;
}
}
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
int F[4][4];
for (int i = 0; i < 16; i++) {
if ((a1 / (1 << i)) % 2 == 1)
F[i / 4][i % 4] = col[i / 4][i % 4];
else
F[i / 4][i % 4] = 0;
}
for (int i = 0; i < x.size(); i++) {
for (int j = 1 - (int)x[i].first; j <= 3; j++) {
for (int k = 1 - (int)x[i].second; k <= 3; k++) {
for (int o = 1; o < 4; o++) {
int G = 0;
for (int l = max(-j, 0); l < min(4 - j, x[i].first); l++) {
for (int m = max(-k, 0); m < min(4 - k, x[i].second); m++) {
int cx = j + l, cy = k + m, cl = cx * 4 + cy;
if (F[cx][cy] >= 1 && col[cx][cy] != o) {
G -= (1 << cl);
} else if (F[cx][cy] == 0 && col[cx][cy] == o) {
G += (1 << cl);
}
}
}
int bits = G;
if (dp[bits] > dp[a1] + 1) {
dp[bits] = dp[a1] + 1;
Q.push(bits);
}
}
}
}
}
}
cout << dp[65535] << endl;
return 0;
} | #include <iostream>
#include <queue>
#include <string>
#include <vector>
using namespace std;
int dp[1 << 16], n;
vector<pair<int, int>> x;
int col[4][4];
queue<int> Q;
int main() {
for (int i = 0; i < (1 << 16); i++)
dp[i] = 999999999;
dp[0] = 0;
cin >> n;
for (int i = 0; i < n; i++) {
int a, b;
cin >> a >> b;
x.push_back(make_pair(a, b));
}
Q.push(0);
for (int i = 0; i < 4; i++) {
string V;
cin >> V;
for (int j = 0; j < 4; j++) {
if (V[j] == 'R')
col[i][j] = 1;
if (V[j] == 'B')
col[i][j] = 2;
if (V[j] == 'G')
col[i][j] = 3;
}
}
while (!Q.empty()) {
int a1 = Q.front();
Q.pop();
int F[4][4];
for (int i = 0; i < 16; i++) {
if ((a1 / (1 << i)) % 2 == 1)
F[i / 4][i % 4] = col[i / 4][i % 4];
else
F[i / 4][i % 4] = 0;
}
for (int i = 0; i < x.size(); i++) {
for (int j = 1 - (int)x[i].first; j <= 3; j++) {
for (int k = 1 - (int)x[i].second; k <= 3; k++) {
for (int o = 1; o < 4; o++) {
int G = a1;
for (int l = max(-j, 0); l < min(4 - j, x[i].first); l++) {
for (int m = max(-k, 0); m < min(4 - k, x[i].second); m++) {
int cx = j + l, cy = k + m, cl = cx * 4 + cy;
if (F[cx][cy] >= 1 && col[cx][cy] != o) {
G -= (1 << cl);
} else if (F[cx][cy] == 0 && col[cx][cy] == o) {
G += (1 << cl);
}
}
}
int bits = G;
if (dp[bits] > dp[a1] + 1) {
dp[bits] = dp[a1] + 1;
Q.push(bits);
}
}
}
}
}
}
cout << dp[65535] << endl;
return 0;
} | replace | 46 | 47 | 46 | 47 | TLE | |
p01414 | C++ | Memory 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 << ']';
}
int main() {
for (int n; cin >> n && n;) {
vi hs(n), ws(n);
rep(i, n) cin >> hs[i] >> ws[i];
vs grid(4);
rep(i, 4) cin >> grid[i];
queue<pii> q;
q.emplace(0, 0);
vi vis(1 << 16);
while (q.size()) {
int bit, turn;
tie(bit, turn) = q.front();
q.pop();
if (bit == (1 << 16) - 1) {
cout << turn << endl;
break;
}
if (vis[bit])
continue;
vis[bit] = 1;
rep(k, n) {
repi(i0, -hs[k] + 1, 4) repi(j0, -ws[k] + 1, 4) {
bool ok = true;
char color = '?';
int mask = 0;
rep(i, hs[k]) rep(j, ws[k]) {
if (i0 + i < 0 || 4 <= i0 + i || j0 + j < 0 || 4 <= j0 + j)
continue;
mask |= 1 << (i0 + i) * 4 + (j0 + j);
if (bit >> (i0 + i) * 4 + (j0 + j) & 1)
continue;
if (color == '?')
color = grid[i0 + i][j0 + j];
if (grid[i0 + i][j0 + j] != color)
ok = false;
}
if (ok)
q.emplace(bit | mask, turn + 1);
}
}
}
}
} | #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 << ']';
}
int main() {
for (int n; cin >> n && n;) {
vi hs(n), ws(n);
rep(i, n) cin >> hs[i] >> ws[i];
vs grid(4);
rep(i, 4) cin >> grid[i];
queue<pii> q;
q.emplace(0, 0);
vi vis(1 << 16);
while (q.size()) {
int bit, turn;
tie(bit, turn) = q.front();
q.pop();
if (bit == (1 << 16) - 1) {
cout << turn << endl;
break;
}
if (vis[bit])
continue;
vis[bit] = 1;
rep(k, n) {
repi(i0, -hs[k] + 1, 4) repi(j0, -ws[k] + 1, 4) {
bool ok = true;
char color = '?';
int mask = 0;
rep(i, hs[k]) rep(j, ws[k]) {
if (i0 + i < 0 || 4 <= i0 + i || j0 + j < 0 || 4 <= j0 + j)
continue;
mask |= 1 << (i0 + i) * 4 + (j0 + j);
if (bit >> (i0 + i) * 4 + (j0 + j) & 1)
continue;
if (color == '?')
color = grid[i0 + i][j0 + j];
if (grid[i0 + i][j0 + j] != color)
ok = false;
}
if (ok && !vis[bit | mask])
q.emplace(bit | mask, turn + 1);
}
}
}
}
} | replace | 76 | 77 | 76 | 77 | MLE | |
p01414 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
char Color[3] = {'R', 'G', 'B'};
int main() {
int n;
cin >> n;
vector<int> h(n);
vector<int> w(n);
for (int i = 0; i < n; i++)
cin >> h[i] >> w[i];
string C;
for (int i = 0; i < 4; i++) {
string tmp;
cin >> tmp;
C = C + tmp;
}
queue<pair<int, int>> que; // cost bit(一致していたら1そうでなければ0)
vector<bool> used((1 << 16), false);
used[0] = true;
que.push({0, 0});
while (!que.empty()) {
int bit = que.front().second;
int cost = que.front().first;
// cout << cost << " " << str << endl;
que.pop();
if (bit == (1 << 16) - 1) {
cout << cost << endl;
break;
}
for (int ii = 0; ii < n; ii++) {
for (char color : Color) {
// cout << i << " " << color << endl;
for (int si = -3; si <= 3; si++) {
for (int sj = -3; sj <= 3; sj++) {
int gi = si + h[ii] - 1;
int gj = sj + w[ii] - 1;
int next;
next = bit;
// cout << i << " " << si << " " << gi << " " << sj << " " << gj <<
// " " << endl;
for (int i = si; i <= gi; i++) {
for (int j = sj; j <= gj; j++) {
if (0 <= i && i < 4 && 0 <= j && j < 4) {
int idx = i * 4 + j;
if (C[idx] == color)
next = next | (1 << idx);
else
next = next & ~(1 << idx);
}
}
}
if (!used[next]) {
// cout << "ok" << endl;
used[next] = true;
que.push({cost + 1, next});
}
}
}
}
}
}
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
char Color[3] = {'R', 'G', 'B'};
int main() {
int n;
cin >> n;
vector<int> h(n);
vector<int> w(n);
for (int i = 0; i < n; i++)
cin >> h[i] >> w[i];
string C;
for (int i = 0; i < 4; i++) {
string tmp;
cin >> tmp;
C = C + tmp;
}
queue<pair<int, int>> que; // cost bit(一致していたら1そうでなければ0)
vector<bool> used((1 << 16), false);
used[0] = true;
que.push({0, 0});
while (!que.empty()) {
int bit = que.front().second;
int cost = que.front().first;
// cout << cost << " " << str << endl;
que.pop();
if (bit == (1 << 16) - 1) {
cout << cost << endl;
break;
}
for (int ii = 0; ii < n; ii++) {
for (char color : Color) {
// cout << i << " " << color << endl;
for (int si = -3; si <= 3; si++) {
for (int sj = -3; sj <= 3; sj++) {
int gi = si + h[ii] - 1;
int gj = sj + w[ii] - 1;
int next;
next = bit;
// cout << i << " " << si << " " << gi << " " << sj << " " << gj <<
// " " << endl;
for (int i = max(si, 0); i <= min(gi, 3); i++) {
for (int j = max(sj, 0); j <= min(gj, 3); j++) {
int idx = i * 4 + j;
if (C[idx] == color)
next = next | (1 << idx);
else
next = next & ~(1 << idx);
}
}
if (!used[next]) {
// cout << "ok" << endl;
used[next] = true;
que.push({cost + 1, next});
}
}
}
}
}
}
return 0;
}
| replace | 51 | 61 | 51 | 58 | TLE | |
p01415 | C++ | Runtime Error | #include <cstdio>
int main(void) {
int n, k, t, u, v, l;
char d[1000] = {};
scanf("%d%d%d%d%d%d", &n, &k, &t, &u, &v, &l);
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
d[t] = 1;
}
double res = 0.0, rem = 0.0;
int carrot = 0;
for (int i = 0; i < l; i++) {
if (d[i])
carrot++;
if (carrot > k)
carrot = k, rem = 1.0 * t;
double now = 0.0;
while (now < 1.0) {
if (rem == 0.0) {
if (carrot) {
carrot--;
rem = 1.0 * t;
} else {
res += (1.0 - now) / u;
now = 1.0;
}
}
if (rem > (1.0 - now) / v) {
res += (1.0 - now) / v;
rem -= (1.0 - now) / v;
now = 1.0;
} else {
res += rem;
now += rem * v;
rem = 0.0;
}
}
}
printf("%f\n", res);
return 0;
} | #include <cstdio>
int main(void) {
int n, k, t, u, v, l;
char d[100000] = {};
scanf("%d%d%d%d%d%d", &n, &k, &t, &u, &v, &l);
for (int i = 0; i < n; i++) {
int t;
scanf("%d", &t);
d[t] = 1;
}
double res = 0.0, rem = 0.0;
int carrot = 0;
for (int i = 0; i < l; i++) {
if (d[i])
carrot++;
if (carrot > k)
carrot = k, rem = 1.0 * t;
double now = 0.0;
while (now < 1.0) {
if (rem == 0.0) {
if (carrot) {
carrot--;
rem = 1.0 * t;
} else {
res += (1.0 - now) / u;
now = 1.0;
}
}
if (rem > (1.0 - now) / v) {
res += (1.0 - now) / v;
rem -= (1.0 - now) / v;
now = 1.0;
} else {
res += rem;
now += rem * v;
rem = 0.0;
}
}
}
printf("%f\n", res);
return 0;
} | replace | 4 | 5 | 4 | 5 | 0 | |
p01415 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for (ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n)&1)
typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;
int main() {
int N, K, T, U, V, L;
cin >> N >> K >> T >> U >> V >> L;
vector<int> D(N);
REP(i, N) cin >> D[i];
double res = 0;
double pos = 0;
int carrot = 0;
int i = 0;
while (i < N) {
// move to a next carrot
res += (D[i] - pos) / U;
pos = D[i++];
carrot++;
while (carrot > 0 && pos < L - EPS) {
// eat carrot
// cout << pos << " " << res << endl;
carrot--;
double next = min(pos + T * V, (double)L);
;
while (i < N && D[i] < next) {
carrot++;
i++;
}
if (carrot > K) {
carrot = K + 1;
res += (D[i - 1] - pos) / V;
pos = D[i - 1];
} else {
res += (next - pos) / V;
pos = next;
}
}
assert(carrot == 0);
}
cout << fixed << setprecision(20) << res + (L - pos) / U << endl;
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory.h>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(c) (c).begin(), (c).end()
#define ITER(c) __typeof((c).begin())
#define PB(e) push_back(e)
#define FOREACH(i, c) for (ITER(c) i = (c).begin(); i != (c).end(); ++i)
#define MP(a, b) make_pair(a, b)
#define PARITY(n) ((n)&1)
typedef long long ll;
typedef pair<ll, ll> P;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 1e-10;
int main() {
int N, K, T, U, V, L;
cin >> N >> K >> T >> U >> V >> L;
vector<int> D(N);
REP(i, N) cin >> D[i];
double res = 0;
double pos = 0;
int carrot = 0;
int i = 0;
while (i < N) {
// move to a next carrot
res += (D[i] - pos) / U;
pos = D[i++];
carrot++;
while (carrot > 0) {
// eat carrot
// cout << pos << " " << res << endl;
carrot--;
double next = min(pos + T * V, (double)L);
;
while (i < N && D[i] < next) {
carrot++;
i++;
}
if (carrot > K) {
carrot = K + 1;
res += (D[i - 1] - pos) / V;
pos = D[i - 1];
} else {
res += (next - pos) / V;
pos = next;
}
}
assert(carrot == 0);
}
cout << fixed << setprecision(20) << res + (L - pos) / U << endl;
return 0;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p01415 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
int tx[] = {0, 1, 0, -1};
int ty[] = {-1, 0, 1, 0};
static const double EPS = 1e-8;
int main() {
int total_carrots;
int carrot_store_ability;
int power_up_duration;
int normal_speed;
int power_up_speed;
int goal_distance;
while (~scanf("%d %d %d %d %d %d", &total_carrots, &carrot_store_ability,
&power_up_duration, &normal_speed, &power_up_speed,
&goal_distance)) {
bool carrots[201];
memset(carrots, false, sizeof(carrots));
for (int carrot_idx = 0; carrot_idx < total_carrots; carrot_idx++) {
int distance;
scanf("%d", &distance);
carrots[distance] = true;
}
int current_pos = 0;
int current_carrots = 0;
int life = 0;
int high_speed_interval = 0;
for (int pos = 0; pos < goal_distance; pos++, life--) {
if (carrots[pos]) {
current_carrots++;
}
if ((life <= 0 && current_carrots > 0) ||
(current_carrots > carrot_store_ability)) {
current_carrots--;
life = power_up_duration * power_up_speed;
}
if (life > 0) {
high_speed_interval++;
}
}
printf("%.9lf\n", (double)high_speed_interval / (double)power_up_speed +
(double)(goal_distance - high_speed_interval) /
(double)normal_speed);
}
} | #define _USE_MATH_DEFINES
#define INF 0x3f3f3f3f
#include <algorithm>
#include <bitset>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
typedef pair<int, P> PP;
int tx[] = {0, 1, 0, -1};
int ty[] = {-1, 0, 1, 0};
static const double EPS = 1e-8;
int main() {
int total_carrots;
int carrot_store_ability;
int power_up_duration;
int normal_speed;
int power_up_speed;
int goal_distance;
while (~scanf("%d %d %d %d %d %d", &total_carrots, &carrot_store_ability,
&power_up_duration, &normal_speed, &power_up_speed,
&goal_distance)) {
bool carrots[10001];
memset(carrots, false, sizeof(carrots));
for (int carrot_idx = 0; carrot_idx < total_carrots; carrot_idx++) {
int distance;
scanf("%d", &distance);
carrots[distance] = true;
}
int current_pos = 0;
int current_carrots = 0;
int life = 0;
int high_speed_interval = 0;
for (int pos = 0; pos < goal_distance; pos++, life--) {
if (carrots[pos]) {
current_carrots++;
}
if ((life <= 0 && current_carrots > 0) ||
(current_carrots > carrot_store_ability)) {
current_carrots--;
life = power_up_duration * power_up_speed;
}
if (life > 0) {
high_speed_interval++;
}
}
printf("%.9lf\n", (double)high_speed_interval / (double)power_up_speed +
(double)(goal_distance - high_speed_interval) /
(double)normal_speed);
}
} | replace | 43 | 44 | 43 | 44 | 0 | |
p01415 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
enum State { Carrot, End };
typedef struct Event {
int x;
State state;
bool operator<(const Event &right) const { return x > right.x; }
} Event;
int N, K, T, U, V, L;
vector<int> D;
int main() {
cout.precision(16);
cout.setf(ios::fixed);
cin >> N >> K >> T >> U >> V >> L;
D.resize(N);
for (auto &v : D)
cin >> v;
priority_queue<Event> que;
for (auto v : D)
que.push(Event({v, Carrot}));
vector<bool> zone(L);
int count = 0;
while (!que.empty()) {
auto event = que.top();
que.pop();
if (event.state == Carrot) {
if (zone[event.x]) {
if (count < K) {
count++;
} else {
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x];
x--)
zone[x] = true;
}
} else {
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x]; x--)
zone[x] = true;
}
} else {
if (count && !zone[event.x]) {
count--;
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x]; x--)
zone[x] = true;
}
}
}
double span = 0;
for (int i = 0; i < L; i++)
span += zone[i];
cout << (L - span) / U + span / V << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
enum State { Carrot, End };
typedef struct Event {
int x;
State state;
bool operator<(const Event &right) const { return x > right.x; }
} Event;
int N, K, T, U, V, L;
vector<int> D;
int main() {
cout.precision(16);
cout.setf(ios::fixed);
cin >> N >> K >> T >> U >> V >> L;
D.resize(N);
for (auto &v : D)
cin >> v;
priority_queue<Event> que;
for (auto v : D)
que.push(Event({v, Carrot}));
vector<bool> zone(L);
int count = 0;
while (!que.empty()) {
auto event = que.top();
que.pop();
if (event.state == Carrot) {
if (zone[event.x]) {
if (count < K) {
count++;
} else {
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x];
x--)
zone[x] = true;
}
} else {
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x]; x--)
zone[x] = true;
}
} else {
if (count && event.x < L && !zone[event.x]) {
count--;
que.push({event.x + T * V, End});
for (int x = min(L, event.x + T * V) - 1; event.x <= x && !zone[x]; x--)
zone[x] = true;
}
}
}
double span = 0;
for (int i = 0; i < L; i++)
span += zone[i];
cout << (L - span) / U + span / V << endl;
return 0;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p01416 | C++ | Runtime Error | // #ifdef DEBUG
// #define _GLIBCXX_DEBUG
// #endif
#include <algorithm>
#include <bitset>
#include <complex>
#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 <valarray>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
// these require C++11
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
// Define a type which holds an unsigned integer value
template <std::size_t> struct int_ {};
template <class Tuple, size_t Pos>
std::ostream &print_tuple(std::ostream &out, const Tuple &t, int_<Pos>) {
out << std::get<std::tuple_size<Tuple>::value - Pos>(t) << ',';
return print_tuple(out, t, int_<Pos - 1>());
}
template <class Tuple>
std::ostream &print_tuple(std::ostream &out, const Tuple &t, int_<1>) {
return out << std::get<std::tuple_size<Tuple>::value - 1>(t);
}
template <class... Args>
ostream &operator<<(ostream &out, const std::tuple<Args...> &t) {
out << '(';
print_tuple(out, t, int_<sizeof...(Args)>());
return out << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
typedef complex<double> point;
// template<typename T,std::size_t N>
// struct _v_traits {using type = std::vector<typename
// _v_traits<T,N-1>::type>;}; template<typename T> struct _v_traits<T,1> {using
// type = std::vector<T>;}; template<typename T,std::size_t N=1> using vec =
// typename _v_traits<T,N>::type;
const char dot = '.';
inline int to_index(char c) { return c - 'A'; }
const vector<int> dy = {-1, 0, 1, 0};
const vector<int> dx = {0, 1, 0, -1};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int H, W;
cin >> H >> W;
vector<string> field(H);
for (string &s : field) {
cin >> s;
}
set<tuple<int, int>> should_press;
for (int y = 0; y < H; y++) {
for (int x = 0; x < W; x++) {
vector<int> v(26);
for (int i = 0; i < 4; i++) {
for (int k = 1; k < max(H, W); k++) {
int ny = y + k * dy[i], nx = x + k * dx[i];
if (ny < 0 or ny >= H or nx < 0 or nx >= W)
break;
const char here = field[ny][nx];
if (here != dot) {
v[to_index(here)]++;
// break;
}
}
}
if (*max_element(all(v)) >= 2) {
should_press.insert(make_tuple(y, x));
}
}
}
// dump(should_press);
bool cont = true;
int ret = 0;
while (cont) {
cont = false;
for (auto t : should_press) {
int y = get<0>(t), x = get<1>(t);
if (field[y][x] != dot)
continue;
vector<tuple<int, int>> tiles;
for (int i = 0; i < 4; i++) {
for (int k = 1; k < max(H, W); k++) {
int ny = y + k * dy[i], nx = x + k * dx[i];
if (ny < 0 or ny >= H or nx < 0 or nx >= W)
break;
const char here = field[ny][nx];
if (here != dot) {
tiles.emplace_back(ny, nx);
break;
}
}
}
for (int i = 0; i < tiles.size(); i++) {
for (int j = i + 1; j < tiles.size(); j++) {
char &ic = field[get<0>(tiles[i])][get<1>(tiles[i])];
char &ij = field[get<0>(tiles[j])][get<1>(tiles[j])];
if (ic == ij) {
ic = dot;
ij = dot;
ret += 2;
cont = true;
goto end;
}
}
}
end : {}
}
}
for (string s : field) {
cerr << s << endl;
}
cout << ret << endl;
return 0;
} | // #ifdef DEBUG
// #define _GLIBCXX_DEBUG
// #endif
#include <algorithm>
#include <bitset>
#include <complex>
#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 <valarray>
#include <vector>
#include <cctype>
#include <cstdio>
#include <cstdlib>
#include <cstring>
// these require C++11
#include <chrono>
#include <random>
#include <thread>
#include <unordered_map>
#include <unordered_set>
using namespace std;
#define int long long
#define all(c) c.begin(), c.end()
#define repeat(i, n) for (int i = 0; i < static_cast<int>(n); i++)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define dump(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define dump(x)
#endif
template <typename A, typename B>
ostream &operator<<(ostream &os, const pair<A, B> &p) {
os << "(" << p.first << "," << p.second << ")";
return os;
}
// Define a type which holds an unsigned integer value
template <std::size_t> struct int_ {};
template <class Tuple, size_t Pos>
std::ostream &print_tuple(std::ostream &out, const Tuple &t, int_<Pos>) {
out << std::get<std::tuple_size<Tuple>::value - Pos>(t) << ',';
return print_tuple(out, t, int_<Pos - 1>());
}
template <class Tuple>
std::ostream &print_tuple(std::ostream &out, const Tuple &t, int_<1>) {
return out << std::get<std::tuple_size<Tuple>::value - 1>(t);
}
template <class... Args>
ostream &operator<<(ostream &out, const std::tuple<Args...> &t) {
out << '(';
print_tuple(out, t, int_<sizeof...(Args)>());
return out << ')';
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
typedef complex<double> point;
// template<typename T,std::size_t N>
// struct _v_traits {using type = std::vector<typename
// _v_traits<T,N-1>::type>;}; template<typename T> struct _v_traits<T,1> {using
// type = std::vector<T>;}; template<typename T,std::size_t N=1> using vec =
// typename _v_traits<T,N>::type;
const char dot = '.';
inline int to_index(char c) { return c - 'A'; }
const vector<int> dy = {-1, 0, 1, 0};
const vector<int> dx = {0, 1, 0, -1};
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
int H, W;
cin >> H >> W;
vector<string> field(H);
for (string &s : field) {
cin >> s;
}
set<tuple<int, int>> should_press;
for (int y = 0; y < H; y++) {
for (int x = 0; x < W; x++) {
vector<int> v(26);
for (int i = 0; i < 4; i++) {
for (int k = 1; k < max(H, W); k++) {
int ny = y + k * dy[i], nx = x + k * dx[i];
if (ny < 0 or ny >= H or nx < 0 or nx >= W)
break;
const char here = field[ny][nx];
if (here != dot) {
v[to_index(here)]++;
// break;
}
}
}
if (*max_element(all(v)) >= 2) {
should_press.insert(make_tuple(y, x));
}
}
}
// dump(should_press);
bool cont = true;
int ret = 0;
while (cont) {
cont = false;
for (auto t : should_press) {
int y = get<0>(t), x = get<1>(t);
if (field[y][x] != dot)
continue;
vector<tuple<int, int>> tiles;
for (int i = 0; i < 4; i++) {
for (int k = 1; k < max(H, W); k++) {
int ny = y + k * dy[i], nx = x + k * dx[i];
if (ny < 0 or ny >= H or nx < 0 or nx >= W)
break;
const char here = field[ny][nx];
if (here != dot) {
tiles.emplace_back(ny, nx);
break;
}
}
}
for (int i = 0; i < tiles.size(); i++) {
for (int j = i + 1; j < tiles.size(); j++) {
char &ic = field[get<0>(tiles[i])][get<1>(tiles[i])];
char &ij = field[get<0>(tiles[j])][get<1>(tiles[j])];
if (ic == ij) {
ic = dot;
ij = dot;
ret += 2;
cont = true;
goto end;
}
}
}
end : {}
}
}
cout << ret << endl;
return 0;
} | delete | 164 | 167 | 164 | 164 | 0 | ..........
..........
..........
..........
....CC....
|
p01416 | C++ | Runtime Error | #include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void gstr(char *str) {
int i;
for (i = 0; (str[i] = getchar()) != '\n'; i++)
;
str[i] = '\0';
}
int main(void) {
int i, j, k, l, m, n, h, w, dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0},
ans = 0, f[20][20];
char s[500][501], *c[4];
scanf("%d%d%*c", &h, &w);
for (i = 0; i < h; i++)
gstr(s[i]);
memset(f, 0, sizeof(f));
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (isupper(s[i][j])) {
for (k = 0; k < 4; k++) {
for (l = 1;
i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w && !isupper(s[i + dy[k] * l][j + dx[k] * l]);
l++)
f[i + dy[k] * l][j + dx[k] * l]++;
}
}
}
}
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (!isupper(s[i][j]) && f[i][j] >= 2) {
for (k = 0; k < 4; k++) {
for (l = 0;
i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w && !isupper(s[i + dy[k] * l][j + dx[k] * l]);
l++)
;
if (i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w)
c[k] = &s[i + dy[k] * l][j + dx[k] * l];
else
c[k] = NULL;
}
for (k = 0; k < 3; k++) {
for (l = k + 1; l < 4; l++)
if (c[k] != NULL && c[l] != NULL && k != l && *c[k] == *c[l] &&
*c[k] != '.')
*c[k] = '.', *c[l] = '.', i = -1, ans += 2;
}
if (i == -1) {
memset(f, 0, sizeof(f));
for (k = 0; k < h; k++) {
for (l = 0; l < w; l++) {
if (isupper(s[k][l])) {
for (m = 0; m < 4; m++) {
for (n = 1; k + dy[m] * n >= 0 && k + dy[m] * n < h &&
l + dx[m] * n >= 0 && l + dx[m] * n < w &&
!isdigit(s[k + dy[m] * n][l + dx[m] * n]);
n++) {
f[k + dy[m] * n][l + dx[m] * n]++;
}
}
}
}
}
}
}
if (i == -1)
break;
}
}
printf("%d\n", ans);
return 0;
} | #include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
void gstr(char *str) {
int i;
for (i = 0; (str[i] = getchar()) != '\n'; i++)
;
str[i] = '\0';
}
int main(void) {
int i, j, k, l, m, n, h, w, dx[4] = {0, 1, 0, -1}, dy[4] = {-1, 0, 1, 0},
ans = 0, f[500][500];
char s[500][501], *c[4];
scanf("%d%d%*c", &h, &w);
for (i = 0; i < h; i++)
gstr(s[i]);
memset(f, 0, sizeof(f));
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (isupper(s[i][j])) {
for (k = 0; k < 4; k++) {
for (l = 1;
i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w && !isupper(s[i + dy[k] * l][j + dx[k] * l]);
l++)
f[i + dy[k] * l][j + dx[k] * l]++;
}
}
}
}
for (i = 0; i < h; i++) {
for (j = 0; j < w; j++) {
if (!isupper(s[i][j]) && f[i][j] >= 2) {
for (k = 0; k < 4; k++) {
for (l = 0;
i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w && !isupper(s[i + dy[k] * l][j + dx[k] * l]);
l++)
;
if (i + dy[k] * l >= 0 && i + dy[k] * l < h && j + dx[k] * l >= 0 &&
j + dx[k] * l < w)
c[k] = &s[i + dy[k] * l][j + dx[k] * l];
else
c[k] = NULL;
}
for (k = 0; k < 3; k++) {
for (l = k + 1; l < 4; l++)
if (c[k] != NULL && c[l] != NULL && k != l && *c[k] == *c[l] &&
*c[k] != '.')
*c[k] = '.', *c[l] = '.', i = -1, ans += 2;
}
if (i == -1) {
memset(f, 0, sizeof(f));
for (k = 0; k < h; k++) {
for (l = 0; l < w; l++) {
if (isupper(s[k][l])) {
for (m = 0; m < 4; m++) {
for (n = 1; k + dy[m] * n >= 0 && k + dy[m] * n < h &&
l + dx[m] * n >= 0 && l + dx[m] * n < w &&
!isdigit(s[k + dy[m] * n][l + dx[m] * n]);
n++) {
f[k + dy[m] * n][l + dx[m] * n]++;
}
}
}
}
}
}
}
if (i == -1)
break;
}
}
printf("%d\n", ans);
return 0;
} | replace | 14 | 15 | 14 | 15 | 0 | |
p01416 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
using T = tuple<int, int, char>;
int main() {
int M, N;
cin >> M >> N;
vector<T> V;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
char c;
cin >> c;
if (c != '.') {
V.emplace_back(j, i, c);
}
}
}
vector<int> X, Y;
for (auto t : V) {
int x, y;
tie(x, y, ignore) = t;
X.emplace_back(x);
Y.emplace_back(y);
sort(X.begin(), X.end());
sort(Y.begin(), Y.end());
}
X.erase(unique(X.begin(), X.end()), X.end());
vector<int> XX;
XX.push_back(X[0]);
for (int i = 1; i < X.size(); i++) {
if (X[i - 1] + 1 != X[i]) {
XX.push_back(X[i - 1] + 1);
}
XX.push_back(X[i]);
}
swap(X, XX);
Y.erase(unique(Y.begin(), Y.end()), Y.end());
vector<int> YY;
YY.push_back(Y[0]);
for (int i = 1; i < Y.size(); i++) {
if (Y[i - 1] + 1 != Y[i]) {
YY.push_back(Y[i - 1] + 1);
}
YY.push_back(Y[i]);
}
swap(Y, YY);
int x_max = X.size() - 1;
int y_max = Y.size() - 1;
char board[Y.size()][X.size()]; // y,x
for (int i = 0; i <= y_max; i++) {
for (int j = 0; j <= x_max; j++) {
board[i][j] = '.';
}
}
for (auto &t : V) {
int x, y;
char c;
tie(x, y, c) = t;
x = lower_bound(X.begin(), X.end(), x) - X.begin();
y = lower_bound(Y.begin(), Y.end(), y) - Y.begin();
board[y][x] = c;
}
/*
for(int i=0;i<=y_max;i++){
for(int j=0;j<=x_max;j++){
cout<<board[i][j];
}
cout<<endl;
}*/
bool updated = true;
int ans = 0;
while (updated) {
updated = false;
for (int y = 0; y <= y_max; y++) {
for (int x = 0; x <= x_max; x++) {
if (board[y][x] != '.')
continue;
char up = 'u', down = 'd', left = 'l', right = 'r';
int upd, downd, leftd, rightd;
for (int d = 1; x + d <= x_max; d++) {
if (board[y][x + d] != '.') {
right = board[y][x + d];
rightd = d;
break;
}
}
for (int d = -1; 0 <= x + d; d--) {
if (board[y][x + d] != '.') {
left = board[y][x + d];
leftd = d;
break;
}
}
for (int d = 1; y + d <= y_max; d++) {
if (board[y + d][x] != '.') {
down = board[y + d][x];
downd = d;
break;
}
}
for (int d = -1; 0 <= y + d; d--) {
if (board[y + d][x] != '.') {
up = board[y + d][x];
upd = d;
break;
}
}
if (up == down) {
board[y + upd][x] = board[y + downd][x] = '.';
ans += 2;
updated = true;
}
if (up == left) {
board[y + upd][x] = board[y][x + leftd] = '.';
ans += 2;
updated = true;
}
if (up == right) {
board[y + upd][x] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
if (down == left) {
board[y + downd][x] = board[y][x + leftd] = '.';
ans += 2;
updated = true;
}
if (down == right) {
board[y + downd][x] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
if (left == right) {
board[y][x + leftd] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
}
}
}
cout << ans << endl;
return 0;
}
| #include <algorithm>
#include <iostream>
#include <tuple>
#include <vector>
using namespace std;
using T = tuple<int, int, char>;
int main() {
int M, N;
cin >> M >> N;
vector<T> V;
for (int i = 0; i < M; i++) {
for (int j = 0; j < N; j++) {
char c;
cin >> c;
if (c != '.') {
V.emplace_back(j, i, c);
}
}
}
if (V.empty()) {
cout << 0 << endl;
return 0;
}
vector<int> X, Y;
for (auto t : V) {
int x, y;
tie(x, y, ignore) = t;
X.emplace_back(x);
Y.emplace_back(y);
sort(X.begin(), X.end());
sort(Y.begin(), Y.end());
}
X.erase(unique(X.begin(), X.end()), X.end());
vector<int> XX;
XX.push_back(X[0]);
for (int i = 1; i < X.size(); i++) {
if (X[i - 1] + 1 != X[i]) {
XX.push_back(X[i - 1] + 1);
}
XX.push_back(X[i]);
}
swap(X, XX);
Y.erase(unique(Y.begin(), Y.end()), Y.end());
vector<int> YY;
YY.push_back(Y[0]);
for (int i = 1; i < Y.size(); i++) {
if (Y[i - 1] + 1 != Y[i]) {
YY.push_back(Y[i - 1] + 1);
}
YY.push_back(Y[i]);
}
swap(Y, YY);
int x_max = X.size() - 1;
int y_max = Y.size() - 1;
char board[Y.size()][X.size()]; // y,x
for (int i = 0; i <= y_max; i++) {
for (int j = 0; j <= x_max; j++) {
board[i][j] = '.';
}
}
for (auto &t : V) {
int x, y;
char c;
tie(x, y, c) = t;
x = lower_bound(X.begin(), X.end(), x) - X.begin();
y = lower_bound(Y.begin(), Y.end(), y) - Y.begin();
board[y][x] = c;
}
/*
for(int i=0;i<=y_max;i++){
for(int j=0;j<=x_max;j++){
cout<<board[i][j];
}
cout<<endl;
}*/
bool updated = true;
int ans = 0;
while (updated) {
updated = false;
for (int y = 0; y <= y_max; y++) {
for (int x = 0; x <= x_max; x++) {
if (board[y][x] != '.')
continue;
char up = 'u', down = 'd', left = 'l', right = 'r';
int upd, downd, leftd, rightd;
for (int d = 1; x + d <= x_max; d++) {
if (board[y][x + d] != '.') {
right = board[y][x + d];
rightd = d;
break;
}
}
for (int d = -1; 0 <= x + d; d--) {
if (board[y][x + d] != '.') {
left = board[y][x + d];
leftd = d;
break;
}
}
for (int d = 1; y + d <= y_max; d++) {
if (board[y + d][x] != '.') {
down = board[y + d][x];
downd = d;
break;
}
}
for (int d = -1; 0 <= y + d; d--) {
if (board[y + d][x] != '.') {
up = board[y + d][x];
upd = d;
break;
}
}
if (up == down) {
board[y + upd][x] = board[y + downd][x] = '.';
ans += 2;
updated = true;
}
if (up == left) {
board[y + upd][x] = board[y][x + leftd] = '.';
ans += 2;
updated = true;
}
if (up == right) {
board[y + upd][x] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
if (down == left) {
board[y + downd][x] = board[y][x + leftd] = '.';
ans += 2;
updated = true;
}
if (down == right) {
board[y + downd][x] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
if (left == right) {
board[y][x + leftd] = board[y][x + rightd] = '.';
ans += 2;
updated = true;
}
}
}
}
cout << ans << endl;
return 0;
}
| insert | 18 | 18 | 18 | 22 | 0 | |
p01416 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define lp(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) lp(i, 0, n)
#define rlp(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define rrep(i, n) rlp(i, 0, n)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(c) begin(c), end(c)
typedef long long ll;
typedef unsigned long long ull;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
template <typename T> inline bool chmin(T &a, T b) {
if (a <= b)
return false;
a = b;
return true;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a >= b)
return false;
a = b;
return true;
}
template <typename T> inline void unique(T &c) {
sort(all(c));
c.erase(unique(all(c)), end(c));
}
template <typename T> inline T sq(T a) { return a * a; }
template <typename T> inline size_t index_of(vector<T> &c, T x) {
return lower_bound(all(c), x) - begin(c);
}
int m, n;
vector<tuple<char, int, int>> v;
vector<int> zx, zy;
char g[128][128];
int main() {
cin >> m >> n;
rep(i, m) rep(j, n) {
char c;
cin >> c;
if (c != '.') {
v.eb(c, i, j);
lp(k, -1, 2) {
zx.pb(i + k);
zy.pb(j + k);
}
}
}
unique(zx);
unique(zy);
m = zx.size();
n = zy.size();
memset(g, '.', sizeof(g));
for (auto &t : v) {
char c;
int x, y;
tie(c, x, y) = t;
g[index_of(zx, x)][index_of(zy, y)] = c;
}
int res = 0;
rep(k, 26) rep(x, m) rep(y, n) {
if (g[x][y] != '.')
continue;
map<char, vector<pair<int, int>>> cnt;
rep(dir, 4) {
int xx = x, yy = y;
while (true) {
xx += dx[dir], yy += dy[dir];
if (xx < 0 || xx >= m || yy < 0 || yy >= n)
break;
if (g[xx][yy] != '.') {
cnt[g[xx][yy]].eb(xx, yy);
break;
}
}
}
for (auto &t : cnt) {
if (t.second.size() < 2)
continue;
for (auto &p : t.second) {
g[p.first][p.second] = '.';
}
res += 2;
}
}
cout << res << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define lp(i, a, b) for (int i = (int)(a); i < (int)(b); i++)
#define rep(i, n) lp(i, 0, n)
#define rlp(i, a, b) for (int i = (int)(b)-1; i >= (int)(a); i--)
#define rrep(i, n) rlp(i, 0, n)
#define mp make_pair
#define mt make_tuple
#define pb push_back
#define eb emplace_back
#define all(c) begin(c), end(c)
typedef long long ll;
typedef unsigned long long ull;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, -1, 0, 1};
template <typename T> inline bool chmin(T &a, T b) {
if (a <= b)
return false;
a = b;
return true;
}
template <typename T> inline bool chmax(T &a, T b) {
if (a >= b)
return false;
a = b;
return true;
}
template <typename T> inline void unique(T &c) {
sort(all(c));
c.erase(unique(all(c)), end(c));
}
template <typename T> inline T sq(T a) { return a * a; }
template <typename T> inline size_t index_of(vector<T> &c, T x) {
return lower_bound(all(c), x) - begin(c);
}
int m, n;
vector<tuple<char, int, int>> v;
vector<int> zx, zy;
char g[160][160];
int main() {
cin >> m >> n;
rep(i, m) rep(j, n) {
char c;
cin >> c;
if (c != '.') {
v.eb(c, i, j);
lp(k, -1, 2) {
zx.pb(i + k);
zy.pb(j + k);
}
}
}
unique(zx);
unique(zy);
m = zx.size();
n = zy.size();
memset(g, '.', sizeof(g));
for (auto &t : v) {
char c;
int x, y;
tie(c, x, y) = t;
g[index_of(zx, x)][index_of(zy, y)] = c;
}
int res = 0;
rep(k, 26) rep(x, m) rep(y, n) {
if (g[x][y] != '.')
continue;
map<char, vector<pair<int, int>>> cnt;
rep(dir, 4) {
int xx = x, yy = y;
while (true) {
xx += dx[dir], yy += dy[dir];
if (xx < 0 || xx >= m || yy < 0 || yy >= n)
break;
if (g[xx][yy] != '.') {
cnt[g[xx][yy]].eb(xx, yy);
break;
}
}
}
for (auto &t : cnt) {
if (t.second.size() < 2)
continue;
for (auto &p : t.second) {
g[p.first][p.second] = '.';
}
res += 2;
}
}
cout << res << endl;
} | replace | 48 | 49 | 48 | 49 | 0 | |
p01416 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
typedef vector<vector<int>> Graph;
const int inf = 1e9;
const int mod = 1e9 + 7;
enum { X, Y, CHAR };
typedef vector<int> Tile;
int H, W;
vector<string> s;
// N, E, S, W
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool inside(int x, int y) { return 0 <= x && x < H && 0 <= y && y < W; }
Tile findNearestTile(int x, int y, int k) {
if (!inside(x, y) || s[x][y] == '#')
return Tile{-1, -1, -1};
if (isalpha(s[x][y]))
return Tile{x, y, s[x][y] - 'A'};
return findNearestTile(x + dx[k], y + dy[k], k);
}
bool hit(int sx, int sy) {
if (s[sx][sy] == '#')
return false;
if (isalpha(s[sx][sy])) {
rep(k, 4) {
int nx = sx + dx[k], ny = sy + dy[k];
if (!inside(nx, ny))
continue;
if (s[sx][sy] == s[nx][ny]) {
// cerr << "hey!" << endl;
// cerr << sx << " " << sy << " " << nx << " " << ny << endl;
// s[sx][sy] = '.';
// s[nx][ny] = '.';
return true;
}
}
return false;
}
// cout << "hit: " << sx << " " << sy << endl;
rep(start, 4) {
Tile tile1{-1, -1, -1};
rep(k, 4) {
// cout << start << " " << k << endl;
Tile tile2 = findNearestTile(sx, sy, (k + start) % 4);
if (tile2[CHAR] == -1) {
continue;
} else if (tile1[CHAR] == -1) {
tile1 = tile2;
} else if (tile1[CHAR] == tile2[CHAR]) {
// cout << sx << " " << sy << endl;
// cout << start << " " << k << endl;
// cout << tile1[X] << " " << tile1[Y] << " " << tile1[CHAR] << endl;
// cout << tile2[X] << " " << tile2[Y] << " " << tile2[CHAR] << endl;
s[tile1[X]][tile1[Y]] = '.';
s[tile2[X]][tile2[Y]] = '.';
return true;
}
}
}
return false;
}
bool search() {
rep(i, H) {
rep(j, W) {
if (hit(i, j)) {
// cout << "hit" << endl;
// cout << i << " " << j << endl;
return true;
}
}
}
return false;
}
bool checkCompress(string line) {
for (const auto &c : line) {
if (c != '.')
return false;
}
return true;
}
void compress(vector<string> &s) {
for (int i = 0; i < s.size();) {
if (checkCompress(s[i])) {
s.erase(s.begin() + i);
} else {
i++;
}
}
}
void rot(vector<string> &s) {
vector<string> t(s[0].size(), "");
rep(i, s.size()) rep(j, s[0].size()) { t[j] += s[i][j]; }
s = t;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> H >> W;
s.resize(H);
rep(i, H) cin >> s[i];
rep(x, H) {
rep(y, W) {
rep(k, 4) {
int nx = x + dx[k], ny = y + dy[k];
if (!inside(nx, ny))
continue;
if (isalpha(s[x][y]) && s[x][y] == s[nx][ny]) {
s[x][y] = '#';
s[nx][ny] = '#';
}
}
}
}
compress(s);
// for (auto line : s) cout << line << endl;
// cout << endl;
if (s.empty()) {
cout << 0 << endl;
return 0;
}
rot(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
compress(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
rot(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
H = s.size(), W = s[0].size();
int ans = 0;
while (search()) {
ans += 2;
// cout << ans << endl;
// rep(i, H) {
// cout << s[i] << endl;
// }
// cout << endl;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define int long long // <-----!!!!!!!!!!!!!!!!!!!
#define rep(i, n) for (int i = 0; i < (n); i++)
#define rep2(i, a, b) for (int i = (a); i < (b); i++)
#define rrep(i, n) for (int i = (n)-1; i >= 0; i--)
#define rrep2(i, a, b) for (int i = (b)-1; i >= (a); i--)
#define all(a) (a).begin(), (a).end()
typedef long long ll;
typedef pair<int, int> Pii;
typedef tuple<int, int, int> TUPLE;
typedef vector<int> V;
typedef vector<V> VV;
typedef vector<VV> VVV;
typedef vector<vector<int>> Graph;
const int inf = 1e9;
const int mod = 1e9 + 7;
enum { X, Y, CHAR };
typedef vector<int> Tile;
int H, W;
vector<string> s;
// N, E, S, W
const int dx[4] = {-1, 0, 1, 0};
const int dy[4] = {0, 1, 0, -1};
inline bool inside(int x, int y) { return 0 <= x && x < H && 0 <= y && y < W; }
Tile findNearestTile(int x, int y, int k) {
if (!inside(x, y) || s[x][y] == '#')
return Tile{-1, -1, -1};
if (isalpha(s[x][y]))
return Tile{x, y, s[x][y] - 'A'};
return findNearestTile(x + dx[k], y + dy[k], k);
}
bool hit(int sx, int sy) {
if (s[sx][sy] == '#')
return false;
if (isalpha(s[sx][sy])) {
rep(k, 4) {
int nx = sx + dx[k], ny = sy + dy[k];
if (!inside(nx, ny))
continue;
if (s[sx][sy] == s[nx][ny]) {
// cerr << "hey!" << endl;
// cerr << sx << " " << sy << " " << nx << " " << ny << endl;
s[sx][sy] = '.';
s[nx][ny] = '.';
return true;
}
}
return false;
}
// cout << "hit: " << sx << " " << sy << endl;
rep(start, 4) {
Tile tile1{-1, -1, -1};
rep(k, 4) {
// cout << start << " " << k << endl;
Tile tile2 = findNearestTile(sx, sy, (k + start) % 4);
if (tile2[CHAR] == -1) {
continue;
} else if (tile1[CHAR] == -1) {
tile1 = tile2;
} else if (tile1[CHAR] == tile2[CHAR]) {
// cout << sx << " " << sy << endl;
// cout << start << " " << k << endl;
// cout << tile1[X] << " " << tile1[Y] << " " << tile1[CHAR] << endl;
// cout << tile2[X] << " " << tile2[Y] << " " << tile2[CHAR] << endl;
s[tile1[X]][tile1[Y]] = '.';
s[tile2[X]][tile2[Y]] = '.';
return true;
}
}
}
return false;
}
bool search() {
rep(i, H) {
rep(j, W) {
if (hit(i, j)) {
// cout << "hit" << endl;
// cout << i << " " << j << endl;
return true;
}
}
}
return false;
}
bool checkCompress(string line) {
for (const auto &c : line) {
if (c != '.')
return false;
}
return true;
}
void compress(vector<string> &s) {
for (int i = 0; i < s.size();) {
if (checkCompress(s[i])) {
s.erase(s.begin() + i);
} else {
i++;
}
}
}
void rot(vector<string> &s) {
vector<string> t(s[0].size(), "");
rep(i, s.size()) rep(j, s[0].size()) { t[j] += s[i][j]; }
s = t;
}
signed main() {
std::ios::sync_with_stdio(false);
std::cin.tie(0);
cin >> H >> W;
s.resize(H);
rep(i, H) cin >> s[i];
rep(x, H) {
rep(y, W) {
rep(k, 4) {
int nx = x + dx[k], ny = y + dy[k];
if (!inside(nx, ny))
continue;
if (isalpha(s[x][y]) && s[x][y] == s[nx][ny]) {
s[x][y] = '#';
s[nx][ny] = '#';
}
}
}
}
compress(s);
// for (auto line : s) cout << line << endl;
// cout << endl;
if (s.empty()) {
cout << 0 << endl;
return 0;
}
rot(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
compress(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
rot(s);
// // for (auto line : s) cout << line << endl;
// // cout << endl;
H = s.size(), W = s[0].size();
int ans = 0;
while (search()) {
ans += 2;
// cout << ans << endl;
// rep(i, H) {
// cout << s[i] << endl;
// }
// cout << endl;
}
cout << ans << endl;
} | replace | 51 | 53 | 51 | 53 | TLE | |
p01417 | C++ | Runtime Error | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
template <typename T> inline T sqr(T x) { return x * x; }
template <typename T> inline void chmax(T &t, T f) {
if (t < f)
t = f;
}
int N, M;
int next_combination(int x) {
int l = x & -x;
int m = x + l;
int ls = x & ~m;
return m | ((ls / l) >> 1);
}
double solve(vector<double> &L, vector<double> &a, vector<double> &b) {
double res = 0.0;
for (int S = (1 << M) - 1; S < (1 << N); S = next_combination(S)) {
double total = 0.0;
rep(i, N) if (S >> i & 1) {
rep(j, i) if (S >> j & 1) {
total += sqr(L[i] - L[j]) + sqr(a[i] - a[j]) + sqr(b[i] - b[j]);
}
}
chmax(res, total);
}
return res;
}
int main() {
while (cin >> N >> M) {
vector<double> L(N), a(N), b(N);
rep(i, N) cin >> L[i] >> a[i] >> b[i];
cout << fixed << setprecision(16) << solve(L, a, b) << '\n';
}
return 0;
} | #include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
template <typename T> inline T sqr(T x) { return x * x; }
template <typename T> inline void chmax(T &t, T f) {
if (t < f)
t = f;
}
int N, M;
int next_combination(int x) {
int l = x & -x;
int m = x + l;
int ls = x & ~m;
return m | ((ls / l) >> 1);
}
double solve(vector<double> &L, vector<double> &a, vector<double> &b) {
if (M == 0)
return 0.0;
double res = 0.0;
for (int S = (1 << M) - 1; S < (1 << N); S = next_combination(S)) {
double total = 0.0;
rep(i, N) if (S >> i & 1) {
rep(j, i) if (S >> j & 1) {
total += sqr(L[i] - L[j]) + sqr(a[i] - a[j]) + sqr(b[i] - b[j]);
}
}
chmax(res, total);
}
return res;
}
int main() {
while (cin >> N >> M) {
vector<double> L(N), a(N), b(N);
rep(i, N) cin >> L[i] >> a[i] >> b[i];
cout << fixed << setprecision(16) << solve(L, a, b) << '\n';
}
return 0;
} | insert | 25 | 25 | 25 | 27 | 0 | |
p01417 | C++ | Runtime Error | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge {
int u, v;
ll w;
};
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
int main() {
int N, M;
cin >> N >> M;
vector<double> L(N), a(N), b(N);
for (int i = 0; i < N; i++)
cin >> L[i] >> a[i] >> b[i];
vector<vector<double>> d(N, vector<double>(N));
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++) {
double dL = L[i] - L[j], da = a[i] - a[j], db = b[i] - b[j];
d[i][j] = dL * dL + da * da + db * db;
}
double maxi = 0;
for (int S = (1 << M) - 1; S < (1 << N);) {
double sum = 0;
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++)
if ((S & (1 << i)) && (S & (1 << j)))
sum += d[i][j];
maxi = max(maxi, sum);
int x = S & -S, y = S + x;
S = ((S & ~y) / x >> 1) | y;
}
printf("%.10f\n", maxi);
} | #define _USE_MATH_DEFINES
#include <algorithm>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> i_i;
typedef pair<ll, int> ll_i;
typedef pair<double, int> d_i;
typedef pair<ll, ll> ll_ll;
typedef pair<double, double> d_d;
struct edge {
int u, v;
ll w;
};
ll MOD = 1000000007;
ll _MOD = 1000000009;
double EPS = 1e-10;
int main() {
int N, M;
cin >> N >> M;
if (M == 0) {
cout << 0 << endl;
return 0;
}
vector<double> L(N), a(N), b(N);
for (int i = 0; i < N; i++)
cin >> L[i] >> a[i] >> b[i];
vector<vector<double>> d(N, vector<double>(N));
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++) {
double dL = L[i] - L[j], da = a[i] - a[j], db = b[i] - b[j];
d[i][j] = dL * dL + da * da + db * db;
}
double maxi = 0;
for (int S = (1 << M) - 1; S < (1 << N);) {
double sum = 0;
for (int i = 0; i < N; i++)
for (int j = i + 1; j < N; j++)
if ((S & (1 << i)) && (S & (1 << j)))
sum += d[i][j];
maxi = max(maxi, sum);
int x = S & -S, y = S + x;
S = ((S & ~y) / x >> 1) | y;
}
printf("%.10f\n", maxi);
} | insert | 38 | 38 | 38 | 42 | 0 | |
p01417 | C++ | Time Limit Exceeded |
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
typedef long long ll;
typedef complex<int> P;
int n, m;
double ans = 0;
double x[21], y[21], z[21];
double f(int i, int j) {
return (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) +
(z[i] - z[j]) * (z[i] - z[j]);
}
void dfs(int p, vector<int> &v) {
if (p == n) {
if (v.size() == m) {
double sum = 0.0;
for (int i = 0; i < v.size() - 1; i++) {
for (int j = i + 1; j < v.size(); j++) {
sum += f(v[i], v[j]);
}
}
ans = max(ans, sum);
return;
}
} else {
dfs(p + 1, v);
v.push_back(p);
dfs(p + 1, v);
v.pop_back();
}
}
bool solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> z[i];
}
ans = 0.0;
vector<int> v;
dfs(0, v);
cout << ans << endl;
return true;
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <vector>
using namespace std;
#define pb push_back
typedef long long ll;
typedef complex<int> P;
int n, m;
double ans = 0;
double x[21], y[21], z[21];
double f(int i, int j) {
return (x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]) +
(z[i] - z[j]) * (z[i] - z[j]);
}
void dfs(int p, vector<int> &v) {
if (p == n) {
if (v.size() == m) {
double sum = 0.0;
for (int i = 0; i < v.size(); i++) { //
for (int j = 0; j < i; j++) { //
sum += f(v[i], v[j]);
}
}
ans = max(ans, sum);
return;
}
} else {
dfs(p + 1, v);
v.push_back(p);
dfs(p + 1, v);
v.pop_back();
}
}
bool solve() {
cin >> n >> m;
for (int i = 0; i < n; i++) {
cin >> x[i] >> y[i] >> z[i];
}
ans = 0.0;
vector<int> v;
dfs(0, v);
cout << ans << endl;
return true;
}
int main() {
cout.setf(ios::fixed);
cout.precision(10);
solve();
return 0;
}
| replace | 37 | 39 | 37 | 39 | TLE | |
p01417 | C++ | Runtime Error | #include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
int main(void) {
int N, M;
cin >> N >> M;
std::vector<std::vector<double>> colors(N, std::vector<double>(3));
for (int i = 0; i < N; i++) {
cin >> colors[i][0];
cin >> colors[i][1];
cin >> colors[i][2];
}
std::vector<std::vector<double>> dis(N, std::vector<double>(N));
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
if (i == j) {
dis[i][j] = 0;
} else {
dis[i][j] = pow(colors[i][0] - colors[j][0], 2) +
pow(colors[i][1] - colors[j][1], 2) +
pow(colors[i][2] - colors[j][2], 2);
dis[j][i] = dis[i][j];
}
}
}
double max = 0;
double now;
bool update = false;
std::vector<int> c(M);
for (int i = 0; i < M; i++) {
c[i] = i;
}
if (N != M && M != 1) {
while (c[0] < M) {
now = 0;
for (int i = 0; i < M - 1; i++) {
for (int j = i + 1; j < M; j++) {
now += dis[c[i]][c[j]];
}
}
if (now > max) {
max = now;
}
update = false;
int t = 0;
for (int i = M - 1; !(i > M) && !(update); i--) {
if (i == 0) {
c[i]++;
update = true;
for (int j = 0; j < t; j++) {
c[M - 1 - j] = c[M - 1 - t] + t - j;
}
} else if (c[i] < N - 1 - (M - i - 1)) {
c[i]++;
update = true;
for (int j = 0; j < t; j++) {
c[M - 1 - j] = c[M - 1 - t] + t - j;
}
} else {
t++;
}
}
}
}
cout << std::setprecision(30) << max << endl;
return 0;
} | #include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using std::cin;
using std::cout;
using std::endl;
int main(void) {
int N, M;
cin >> N >> M;
std::vector<std::vector<double>> colors(N, std::vector<double>(3));
for (int i = 0; i < N; i++) {
cin >> colors[i][0];
cin >> colors[i][1];
cin >> colors[i][2];
}
std::vector<std::vector<double>> dis(N, std::vector<double>(N));
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
if (i == j) {
dis[i][j] = 0;
} else {
dis[i][j] = pow(colors[i][0] - colors[j][0], 2) +
pow(colors[i][1] - colors[j][1], 2) +
pow(colors[i][2] - colors[j][2], 2);
dis[j][i] = dis[i][j];
}
}
}
double max = 0;
double now;
bool update = false;
std::vector<int> c(M);
for (int i = 0; i < M; i++) {
c[i] = i;
}
if (M > 1) {
while (!(c[0] > N - M)) {
now = 0;
for (int i = 0; i < M - 1; i++) {
for (int j = i + 1; j < M; j++) {
now += dis[c[i]][c[j]];
}
}
if (now > max) {
max = now;
}
update = false;
int t = 0;
for (int i = M - 1; !(i > M) && !(update); i--) {
if (i == 0) {
c[i]++;
update = true;
for (int j = 0; j < t; j++) {
c[M - 1 - j] = c[M - 1 - t] + t - j;
}
} else if (c[i] < N - 1 - (M - i - 1)) {
c[i]++;
update = true;
for (int j = 0; j < t; j++) {
c[M - 1 - j] = c[M - 1 - t] + t - j;
}
} else {
t++;
}
}
}
}
cout << std::setprecision(30) << max << endl;
return 0;
} | replace | 42 | 45 | 42 | 44 | 0 | |
p01417 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
std::iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
std::rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
std::rotate(k, itr2, last);
return true;
}
}
std::rotate(first, k, last);
return false;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<double>> v;
for (int i = 0; i < n; i++) {
vector<double> vv(3);
for (int j = 0; j < 3; j++)
cin >> vv[j];
v.push_back(vv);
}
vector<int> num(n);
for (int i = 0; i < n; i++)
num[i] = i;
double ret = 0;
if (m == 1) {
printf("%.20f\n", ret);
return 0;
}
do {
vector<int> c;
for (int i = 0; i < m; i++)
c.push_back(num[i]);
double sum = 0;
do {
sum += pow(v[c[0]][0] - v[c[1]][0], 2) + pow(v[c[0]][1] - v[c[1]][1], 2) +
pow(v[c[0]][2] - v[c[1]][2], 2);
} while (next_combination(c.begin(), c.begin() + 2, c.end()));
ret = max(ret, sum);
} while (next_combination(num.begin(), num.begin() + m, num.end()));
printf("%.20f\n", ret);
} | #include <bits/stdc++.h>
using namespace std;
template <typename Iterator>
inline bool next_combination(const Iterator first, Iterator k,
const Iterator last) {
if ((first == last) || (first == k) || (last == k))
return false;
Iterator itr1 = first;
Iterator itr2 = last;
++itr1;
if (last == itr1)
return false;
itr1 = last;
--itr1;
itr1 = k;
--itr2;
while (first != itr1) {
if (*--itr1 < *itr2) {
Iterator j = k;
while (!(*itr1 < *j))
++j;
std::iter_swap(itr1, j);
++itr1;
++j;
itr2 = k;
std::rotate(itr1, j, last);
while (last != j) {
++j;
++itr2;
}
std::rotate(k, itr2, last);
return true;
}
}
std::rotate(first, k, last);
return false;
}
int main() {
int n, m;
cin >> n >> m;
vector<vector<double>> v;
for (int i = 0; i < n; i++) {
vector<double> vv(3);
for (int j = 0; j < 3; j++)
cin >> vv[j];
v.push_back(vv);
}
vector<int> num(n);
for (int i = 0; i < n; i++)
num[i] = i;
double ret = 0;
if (m < 2) {
printf("%.20f\n", ret);
return 0;
}
do {
vector<int> c;
for (int i = 0; i < m; i++)
c.push_back(num[i]);
double sum = 0;
do {
sum += pow(v[c[0]][0] - v[c[1]][0], 2) + pow(v[c[0]][1] - v[c[1]][1], 2) +
pow(v[c[0]][2] - v[c[1]][2], 2);
} while (next_combination(c.begin(), c.begin() + 2, c.end()));
ret = max(ret, sum);
} while (next_combination(num.begin(), num.begin() + m, num.end()));
printf("%.20f\n", ret);
} | replace | 58 | 59 | 58 | 59 | 0 | |
p01417 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<PII> VPII;
#define fst first
#define snd second
// #define Y first
// #define X second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) (x).begin(), (x).end()
#define RANGE(x, y, maxX, maxY) \
(0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define rep(i, N) for (int i = 0; i < (N); i++)
#define rep2(i, j, N, M) rep(i, N) rep(j, M)
#define rep3(i, j, k, N, M, L) rep(i, N) rep(j, M) rep(k, L)
#define REP(i, init, N) for (int i = (init); i < (N); i++)
template <typename T> inline T fromString(const string &s) {
T res;
ISS iss(s);
iss >> res;
return res;
};
template <typename T> inline string toString(const T &a) {
OSS oss;
oss << a;
return oss.str();
};
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, -1, 0, 1};
int N, M;
VD ls, as, bs;
double distance(int i, int j) {
double l = ls[i] - ls[j];
double a = as[i] - as[j];
double b = bs[i] - bs[j];
return l * l + a * a + b * b;
}
double solve() {
double ans = 0;
for (LL p = 0; p < 1LL << N; p++) {
if (__builtin_popcount(p) != M)
continue;
double sum = 0;
rep(i, N) REP(j, i + 1, N) {
if (!(1 << i & p))
continue;
if (!(1 << j & p))
continue;
sum += distance(i, j);
}
ans = max(ans, sum);
}
return ans;
}
int main(void) {
while (cin >> N >> M, N) {
ls = VD(N);
as = VD(N);
bs = VD(N);
rep(i, N) { cin >> ls[i] >> as[i] >> bs[i]; }
printf("%.9f\n", solve());
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<PII> VPII;
#define fst first
#define snd second
// #define Y first
// #define X second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) (x).begin(), (x).end()
#define RANGE(x, y, maxX, maxY) \
(0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define rep(i, N) for (int i = 0; i < (N); i++)
#define rep2(i, j, N, M) rep(i, N) rep(j, M)
#define rep3(i, j, k, N, M, L) rep(i, N) rep(j, M) rep(k, L)
#define REP(i, init, N) for (int i = (init); i < (N); i++)
template <typename T> inline T fromString(const string &s) {
T res;
ISS iss(s);
iss >> res;
return res;
};
template <typename T> inline string toString(const T &a) {
OSS oss;
oss << a;
return oss.str();
};
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, -1, 0, 1};
int N, M;
VD ls, as, bs;
double distance(int i, int j) {
double l = ls[i] - ls[j];
double a = as[i] - as[j];
double b = bs[i] - bs[j];
return l * l + a * a + b * b;
}
double solve() {
double ans = 0;
for (LL p = 0; p < 1LL << N; p++) {
if (__builtin_popcount(p) != M)
continue;
double sum = 0;
rep(i, N) REP(j, i + 1, N) {
if (!(1 << i & p))
continue;
if (!(1 << j & p))
continue;
sum += distance(i, j);
}
ans = max(ans, sum);
}
return ans;
}
int main(void) {
while (cin >> N >> M, N) {
ls = VD(N);
as = VD(N);
bs = VD(N);
rep(i, N) { cin >> ls[i] >> as[i] >> bs[i]; }
printf("%.9f\n", solve());
return 0;
}
return 0;
} | insert | 95 | 95 | 95 | 97 | TLE | |
p01417 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
using namespace std;
double a[20], b[20], c[20];
double dist[20][32];
double squ(double x) { return x * x; }
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lf %lf %lf", a + i, b + i, c + i);
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
dist[i][j] = squ(a[i] - a[j]) + squ(b[i] - b[j]) + squ(c[i] - c[j]);
double ans = 0;
int comb = (1 << m) - 1;
while (comb < 1 << n) {
double sum = 0;
for (int i = 0; i < n; i++) {
if ((comb >> i & 1) ^ 1)
continue;
for (int j = i + 1; j < n; j++) {
if (comb >> j & 1)
sum += dist[i][j];
}
}
ans = max(ans, sum);
int x = comb & -comb, y = comb + x;
comb = ((comb & ~y) / x >> 1) | y;
}
printf("%.5f\n", ans);
return 0;
} | #include <algorithm>
#include <cstdio>
using namespace std;
double a[20], b[20], c[20];
double dist[20][32];
double squ(double x) { return x * x; }
int main() {
int n, m;
scanf("%d %d", &n, &m);
for (int i = 0; i < n; i++) {
scanf("%lf %lf %lf", a + i, b + i, c + i);
}
if (m == 0) {
printf("%.5f\n", 0.);
return 0;
}
for (int i = 0; i < n; i++)
for (int j = i + 1; j < n; j++)
dist[i][j] = squ(a[i] - a[j]) + squ(b[i] - b[j]) + squ(c[i] - c[j]);
double ans = 0;
int comb = (1 << m) - 1;
while (comb < 1 << n) {
double sum = 0;
for (int i = 0; i < n; i++) {
if ((comb >> i & 1) ^ 1)
continue;
for (int j = i + 1; j < n; j++) {
if (comb >> j & 1)
sum += dist[i][j];
}
}
ans = max(ans, sum);
int x = comb & -comb, y = comb + x;
comb = ((comb & ~y) / x >> 1) | y;
}
printf("%.5f\n", ans);
return 0;
} | insert | 12 | 12 | 12 | 16 | 0 | |
p01418 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int k, r, l;
double p, e, t;
double solve(int k, double r, double l) {
if (t + e < r || l < t - e) {
return 0.0;
}
double h = (r + l) / 2;
if (k == 0) {
if (t - e <= h && h <= t + e) {
return 1.0;
} else
return 0.0;
}
double k1 = 1.0 - p, k2 = p;
if (t > h) {
swap(k1, k2);
}
return k1 * solve(k - 1, r, h) + k2 * solve(k - 1, h, l);
}
int main() {
cin >> k >> r >> l >> p >> e >> t;
printf("%.20f\n", solve(k, r, l));
} | #include <bits/stdc++.h>
using namespace std;
int k, r, l;
double p, e, t;
double solve(int k, double r, double l) {
if (t + e < r || l < t - e) {
return 0.0;
}
if (t - e <= r && l <= t + e) {
return 1.0;
}
double h = (r + l) / 2;
if (k == 0) {
if (t - e <= h && h <= t + e) {
return 1.0;
} else
return 0.0;
}
double k1 = 1.0 - p, k2 = p;
if (t > h) {
swap(k1, k2);
}
return k1 * solve(k - 1, r, h) + k2 * solve(k - 1, h, l);
}
int main() {
cin >> k >> r >> l >> p >> e >> t;
printf("%.20f\n", solve(k, r, l));
} | insert | 9 | 9 | 9 | 12 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef pair<int, int> pii;
double p, e, t;
double solve(int k, double l, double r) {
double c = (l + r) / 2.0;
if (k == 0) {
return (t - e <= c && c <= t + e) ? 1.0 : 0.0;
}
if (c >= t) {
return (1.0 - p) * solve(k - 1, c, r) + p * solve(k - 1, l, c);
} else {
return (1.0 - p) * solve(k - 1, l, c) + p * solve(k - 1, c, r);
}
}
int main() {
int k, r, l;
cin >> k >> r >> l;
cin >> p >> e >> t;
double res = solve(k, l, r);
cout << fixed << setprecision(10) << res << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
typedef long long ll;
typedef pair<int, int> pii;
double p, e, t;
double solve(int k, double l, double r) {
double c = (l + r) / 2.0;
if (k == 0) {
return (t - e <= c && c <= t + e) ? 1.0 : 0.0;
}
if (t - e <= r && l <= t + e)
return 1.0;
if (l < t - e || t + e < r)
return 0.0;
if (c >= t) {
return (1.0 - p) * solve(k - 1, c, r) + p * solve(k - 1, l, c);
} else {
return (1.0 - p) * solve(k - 1, l, c) + p * solve(k - 1, c, r);
}
}
int main() {
int k, r, l;
cin >> k >> r >> l;
cin >> p >> e >> t;
double res = solve(k, l, r);
cout << fixed << setprecision(10) << res << endl;
return 0;
} | insert | 24 | 24 | 24 | 29 | TLE | |
p01418 | 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;
double K, R, L, P, E, T;
struct state {
int d, m;
double r, l;
state(int d, double r, double l, int m) : d(d), r(r), l(l), m(m){};
};
bool ok(double r, double l) {
if (T - E <= r && l <= T + E) {
return true;
} else {
return false;
}
}
bool out(double r, double l) {
if (l <= T - E && T + E <= r) {
return true;
} else {
return false;
}
}
bool ok2(double r, double l) {
double H = (r + l) / 2;
if (abs(T - H) < E) {
return true;
} else {
return false;
}
}
int main() {
cin >> K >> R >> L >> P >> E >> T;
stack<state> S;
S.push(state(0, R, L, 0));
double ans = 0;
while (!S.empty()) {
state st = S.top();
S.pop();
double H = (st.r + st.l) / 2;
if (ok(st.r, st.l)) {
double p = pow(1 - P, st.d - st.m) * pow(P, st.m);
ans += p;
continue;
}
if (out(st.r, st.l)) {
continue;
}
if (st.d == K) {
if (ok2(st.r, st.l)) {
double p = pow(1 - P, st.d - st.m) * pow(P, st.m);
ans += p;
continue;
}
continue;
}
if (T <= H) {
S.push(state(st.d + 1, st.r, H, st.m));
S.push(state(st.d + 1, H, st.l, st.m + 1));
continue;
} else {
S.push(state(st.d + 1, st.r, H, st.m + 1));
S.push(state(st.d + 1, H, st.l, st.m));
continue;
}
}
printf("%.6f\n", ans);
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;
double K, R, L, P, E, T;
struct state {
int d, m;
double r, l;
state(int d, double r, double l, int m) : d(d), r(r), l(l), m(m){};
};
bool ok(double r, double l) {
if (T - E <= r && l <= T + E) {
return true;
} else {
return false;
}
}
bool out(double r, double l) {
if (l <= T - E || T + E <= r) {
return true;
} else {
return false;
}
}
bool ok2(double r, double l) {
double H = (r + l) / 2;
if (abs(T - H) < E) {
return true;
} else {
return false;
}
}
int main() {
cin >> K >> R >> L >> P >> E >> T;
stack<state> S;
S.push(state(0, R, L, 0));
double ans = 0;
while (!S.empty()) {
state st = S.top();
S.pop();
double H = (st.r + st.l) / 2;
if (ok(st.r, st.l)) {
double p = pow(1 - P, st.d - st.m) * pow(P, st.m);
ans += p;
continue;
}
if (out(st.r, st.l)) {
continue;
}
if (st.d == K) {
if (ok2(st.r, st.l)) {
double p = pow(1 - P, st.d - st.m) * pow(P, st.m);
ans += p;
continue;
}
continue;
}
if (T <= H) {
S.push(state(st.d + 1, st.r, H, st.m));
S.push(state(st.d + 1, H, st.l, st.m + 1));
continue;
} else {
S.push(state(st.d + 1, st.r, H, st.m + 1));
S.push(state(st.d + 1, H, st.l, st.m));
continue;
}
}
printf("%.6f\n", ans);
return 0;
} | replace | 61 | 62 | 61 | 62 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#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()
const int INF = 1 << 29;
int k;
double r, l;
double p, e, t;
double rec(int num, double r, double l) {
if (t < r - e || l + e < t)
return 0;
double tt = (r + l) / 2;
if (num == k) {
if (abs(t - tt) < e)
return 1;
else
return 0;
}
if (tt < t) {
return p * rec(num + 1, r, tt) + (1.0 - p) * rec(num + 1, tt, l);
} else {
return (1.0 - p) * rec(num + 1, r, tt) + p * rec(num + 1, tt, l);
}
}
int main() {
cin >> k >> r >> l;
cin >> p >> e >> t;
printf("%.12f\n", rec(0, r, l));
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <string>
#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()
const int INF = 1 << 29;
int k;
double r, l;
double p, e, t;
double rec(int num, double r, double l) {
if (t < r - e || l + e < t)
return 0;
if (t - e < r && l < t + e)
return 1;
double tt = (r + l) / 2;
if (num == k) {
if (abs(t - tt) < e)
return 1;
else
return 0;
}
if (tt < t) {
return p * rec(num + 1, r, tt) + (1.0 - p) * rec(num + 1, tt, l);
} else {
return (1.0 - p) * rec(num + 1, r, tt) + p * rec(num + 1, tt, l);
}
}
int main() {
cin >> k >> r >> l;
cin >> p >> e >> t;
printf("%.12f\n", rec(0, r, l));
} | insert | 27 | 27 | 27 | 29 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, N) for (ll i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100
ll sq(ll num) { return num * num; }
ll mod_pow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return x % MOD;
ll res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
ll mod_add(ll a, ll b) { return (a + b) % MOD; }
ll mod_sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll mod_mul(ll a, ll b) { return a * b % MOD; }
int k;
double R, L, p, e, t;
double solve(int cnt, double r, double l) {
/*if (l + EPS < t - e || t + e + EPS < r)return 0.0;*/
////cout << cnt << " " << r << " " << l << endl;
double h = (r + l) / 2;
if (cnt == 0) {
// cout << r << " " << l << " " << h << endl;
if (t - e < h + EPS && h < t + e + EPS)
return 1.0;
return 0.0;
}
double res = 0;
if (t < h + EPS) {
res += (1 - p) * solve(cnt - 1, r, h);
res += p * solve(cnt - 1, h, l);
} else {
res += (1 - p) * solve(cnt - 1, h, l);
res += p * solve(cnt - 1, r, h);
}
// cout << "!" << cnt << " " << res << endl;
return res;
}
int main() {
cin >> k >> R >> L >> p >> e >> t;
printf("%.10lf\n", solve(k, R, L));
}
| #include <algorithm>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <fstream>
#include <functional>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <time.h>
#include <tuple>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<ll, ll> P;
typedef vector<ll> V;
typedef complex<double> Point;
#define PI acos(-1.0)
#define EPS 1e-10
const ll INF = 1e12;
const ll MOD = 1e9 + 7;
#define FOR(i, a, b) for (ll i = (a); i < (b); i++)
#define rep(i, N) for (ll i = 0; i < (N); i++)
#define ALL(s) (s).begin(), (s).end()
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
#define fi first
#define se second
#define N_SIZE (1LL << 20)
#define NIL -1
#define MAX_N 100100
ll sq(ll num) { return num * num; }
ll mod_pow(ll x, ll n) {
if (n == 0)
return 1;
if (n == 1)
return x % MOD;
ll res = sq(mod_pow(x, n / 2));
res %= MOD;
if (n % 2 == 1) {
res *= x;
res %= MOD;
}
return res;
}
ll mod_add(ll a, ll b) { return (a + b) % MOD; }
ll mod_sub(ll a, ll b) { return (a - b + MOD) % MOD; }
ll mod_mul(ll a, ll b) { return a * b % MOD; }
int k;
double R, L, p, e, t;
double solve(int cnt, double r, double l) {
if (l + EPS < t - e || t + e + EPS < r)
return 0.0;
////cout << cnt << " " << r << " " << l << endl;
double h = (r + l) / 2;
if (cnt == 0) {
// cout << r << " " << l << " " << h << endl;
if (t - e < h + EPS && h < t + e + EPS)
return 1.0;
return 0.0;
}
double res = 0;
if (t < h + EPS) {
res += (1 - p) * solve(cnt - 1, r, h);
res += p * solve(cnt - 1, h, l);
} else {
res += (1 - p) * solve(cnt - 1, h, l);
res += p * solve(cnt - 1, r, h);
}
// cout << "!" << cnt << " " << res << endl;
return res;
}
int main() {
cin >> k >> R >> L >> p >> e >> t;
printf("%.10lf\n", solve(k, R, L));
}
| replace | 65 | 66 | 65 | 67 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using ll = long long;
int K;
long double P;
long double rec(const int n, const long double l, const long double r,
const long double tl, const long double tr,
const long double t) {
const long double mid = (l + r) / 2;
if (n == K) {
return (tl <= mid and mid <= tr) ? 1 : 0;
}
if (tr <= mid) {
return (1 - P) * rec(n + 1, l, mid, tl, tr, t);
} else if (mid <= tl) {
return (1 - P) * rec(n + 1, mid, r, tl, tr, t);
} else {
return ((t <= mid) ? 1 - P : P) * rec(n + 1, l, mid, tl, mid, t) +
((t > mid) ? 1 - P : P) * rec(n + 1, mid, r, mid, tr, t);
}
}
int main() {
cin >> K;
long double R, L, E, T;
cin >> R >> L >> P >> E >> T;
const long double TL = T - E;
const long double TR = T + E;
cout << fixed << setprecision(15) << rec(0, R, L, TL, TR, T) << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <numeric>
#include <vector>
using namespace std;
using ll = long long;
int K;
long double P;
long double rec(const int n, const long double l, const long double r,
const long double tl, const long double tr,
const long double t) {
const long double mid = (l + r) / 2;
if (n == K) {
return (tl <= mid and mid <= tr) ? 1 : 0;
}
if (tl <= l and r <= tr) {
return 1;
} else if (tr < l) {
return 0;
} else if (tl > r) {
return 0;
}
if (tr <= mid) {
return (1 - P) * rec(n + 1, l, mid, tl, tr, t);
} else if (mid <= tl) {
return (1 - P) * rec(n + 1, mid, r, tl, tr, t);
} else {
return ((t <= mid) ? 1 - P : P) * rec(n + 1, l, mid, tl, mid, t) +
((t > mid) ? 1 - P : P) * rec(n + 1, mid, r, mid, tr, t);
}
}
int main() {
cin >> K;
long double R, L, E, T;
cin >> R >> L >> P >> E >> T;
const long double TL = T - E;
const long double TR = T + E;
cout << fixed << setprecision(15) << rec(0, R, L, TL, TR, T) << endl;
return 0;
} | insert | 18 | 18 | 18 | 25 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
double P, E, T;
double dfs(int k, double L, double R) {
double H = (R + L) / 2, PP = H >= T ? 1 - P : P;
if (k == 0 || (abs(L - T) <= E && abs(R - T) <= E))
return abs(H - T) <= E;
return PP * dfs(k - 1, H, R) + (1 - PP) * dfs(k - 1, L, H);
}
int main() {
double K, R, L;
cin >> K >> R >> L >> P >> E >> T;
printf("%.10f\n", dfs(K, L, R));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
double P, E, T;
double dfs(int k, double L, double R) {
double H = (R + L) / 2, PP = H >= T ? 1 - P : P;
if (k == 0 || (abs(L - T) <= E && abs(R - T) <= E))
return abs(H - T) <= E;
if (T < R - E || L + E < T)
return 0;
return PP * dfs(k - 1, H, R) + (1 - PP) * dfs(k - 1, L, H);
}
int main() {
double K, R, L;
cin >> K >> R >> L >> P >> E >> T;
printf("%.10f\n", dfs(K, L, R));
return 0;
} | insert | 8 | 8 | 8 | 10 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int k;
double p, e, t;
double ans = 0;
void dfs(double l, double r, int cnt, double x) {
double h = (l + r) / 2;
if (cnt == k) {
if (t - e <= h && h <= t + e)
ans += x;
return;
}
if (h >= t) {
dfs(l, h, cnt + 1, (1.0 - p) * x);
dfs(h, r, cnt + 1, p * x);
} else {
dfs(h, r, cnt + 1, (1.0 - p) * x);
dfs(l, h, cnt + 1, p * x);
}
}
int main() {
double l, r;
cin >> k >> l >> r;
cin >> p >> e >> t;
dfs(l, r, 0, 1.0);
cout << fixed;
cout.precision(20);
cout << ans << endl;
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int k;
double p, e, t;
double ans = 0;
void dfs(double l, double r, int cnt, double x) {
if (r < t - e)
return;
if (l > t + e)
return;
double h = (l + r) / 2;
if (cnt == k) {
if (t - e <= h && h <= t + e)
ans += x;
return;
}
if (h >= t) {
dfs(l, h, cnt + 1, (1.0 - p) * x);
dfs(h, r, cnt + 1, p * x);
} else {
dfs(h, r, cnt + 1, (1.0 - p) * x);
dfs(l, h, cnt + 1, p * x);
}
}
int main() {
double l, r;
cin >> k >> l >> r;
cin >> p >> e >> t;
dfs(l, r, 0, 1.0);
cout << fixed;
cout.precision(20);
cout << ans << endl;
return 0;
} | insert | 25 | 25 | 25 | 30 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef long long ll;
int K, R, L;
double P, E, T;
double dfs(int depth, double r, double l) {
// cout<<string(depth,'\t');printf("%.8f %.8f\n",l,r);
if (depth == K) {
// string(depth,'\t');printf("%.8f %d\n",(l+r)/2,abs(T-(l+r)/2)<=E);
return 1.0 * (abs(T - (l + r) / 2) <= E);
}
double h = (l + r) / 2;
if (l < T - E)
return 0;
if (r > T + E)
return 0;
double ret = 0.0;
if (h >= T) {
ret += dfs(depth + 1, r, h) * (1 - P);
ret += dfs(depth + 1, h, l) * (P);
} else {
ret += dfs(depth + 1, r, h) * (P);
ret += dfs(depth + 1, h, l) * (1 - P);
}
return ret;
}
int main() {
cin >> K >> R >> L;
cin >> P >> E >> T;
printf("%.20f\n", dfs(0, R, L));
return 0;
} | #include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
#define all(c) (c).begin(), (c).end()
#define rep(i, n) for (int i = 0; i < (n); i++)
#define pb(e) push_back(e)
#define mp(a, b) make_pair(a, b)
#define fr first
#define sc second
const int INF = 100000000;
int dx[4] = {1, 0, -1, 0};
int dy[4] = {0, 1, 0, -1};
using namespace std;
typedef long long ll;
int K, R, L;
double P, E, T;
inline double dfs(int depth, double r, double l) {
// cout<<string(depth,'\t');printf("%.8f %.8f\n",l,r);
if (depth == K) {
// string(depth,'\t');printf("%.8f %d\n",(l+r)/2,abs(T-(l+r)/2)<=E);
return 1.0 * (abs(T - (l + r) / 2) <= E);
}
double h = (l + r) / 2;
if (l < T - E)
return 0;
if (r > T + E)
return 0;
double ret = 0.0;
if (h >= T) {
ret += dfs(depth + 1, r, h) * (1 - P);
ret += dfs(depth + 1, h, l) * (P);
} else {
ret += dfs(depth + 1, r, h) * (P);
ret += dfs(depth + 1, h, l) * (1 - P);
}
return ret;
}
int main() {
cin >> K >> R >> L;
cin >> P >> E >> T;
printf("%.20f\n", dfs(0, R, L));
return 0;
} | replace | 35 | 36 | 35 | 36 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
int k, r, l;
double p, e, t;
double rec(int depth, double l, double r) {
// printf("%d %lf %lf\n", depth, l, r);
double mid = (l + r) / 2, ret = 0;
if (depth == k) {
if (mid >= t - e && mid <= t + e)
return 1;
return 0;
}
if (r + e < t || l - e > t)
return 0;
if (mid > t) {
ret += (1 - p) * rec(depth + 1, l, mid);
ret += p * rec(depth + 1, mid, r);
} else {
ret += p * rec(depth + 1, l, mid);
ret += (1 - p) * rec(depth + 1, mid, r);
}
return ret;
}
int main() {
scanf("%d %d %d %lf %lf %lf", &k, &l, &r, &p, &e, &t);
printf("%.12f\n", rec(0, l, r));
} | #include <cstdio>
using namespace std;
int k, r, l;
double p, e, t;
double rec(int depth, double l, double r) {
// printf("%d %lf %lf\n", depth, l, r);
double mid = (l + r) / 2, ret = 0;
if (depth == k) {
if (mid >= t - e && mid <= t + e)
return 1;
return 0;
}
if (r + e < t || l - e > t)
return 0;
if (r < t + e && l > t - e)
return 1;
if (mid > t) {
ret += (1 - p) * rec(depth + 1, l, mid);
ret += p * rec(depth + 1, mid, r);
} else {
ret += p * rec(depth + 1, l, mid);
ret += (1 - p) * rec(depth + 1, mid, r);
}
return ret;
}
int main() {
scanf("%d %d %d %lf %lf %lf", &k, &l, &r, &p, &e, &t);
printf("%.12f\n", rec(0, l, r));
} | insert | 17 | 17 | 17 | 19 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
const double eps = 1e-11;
int K, R, L;
double P, E, T;
bool equals(double a, double b) { return abs(a - b) < eps; }
double rec(double r, double l, int k, int flag) {
if (flag) {
double dist = min(abs(T - r), abs(T - l));
if (!equals(dist, E) && dist > E)
return 0.0;
}
if (k == 0) {
double t = (r + l) / 2.0;
double diff = abs(T - t);
return (equals(diff, E) || diff < E) ? 1.0 : 0.0;
} else {
double h = (r + l) / 2.0;
if (equals(h, T) || h > T) {
return (1 - P) * rec(r, h, k - 1, 0) + P * rec(h, l, k - 1, 1);
} else {
return (1 - P) * rec(h, l, k - 1, 0) + P * rec(r, h, k - 1, 1);
}
}
}
int main() {
cin >> K >> R >> L;
cin >> P;
cin >> E;
cin >> T;
printf("%.10f\n", rec(R, L, K, 0));
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
const double eps = 1e-11;
int K, R, L;
double P, E, T;
bool equals(double a, double b) { return abs(a - b) < eps; }
double rec(double r, double l, int k, int flag) {
if (flag) {
double dist = min(abs(T - r), abs(T - l));
if (!equals(dist, E) && dist > E)
return 0.0;
}
{
double tr = T - E;
double tl = T + E;
if ((equals(tr, r) || tr < r) && (equals(l, tl) || l < tl)) {
return 1.0;
}
}
if (k == 0) {
double t = (r + l) / 2.0;
double diff = abs(T - t);
return (equals(diff, E) || diff < E) ? 1.0 : 0.0;
} else {
double h = (r + l) / 2.0;
if (equals(h, T) || h > T) {
return (1 - P) * rec(r, h, k - 1, 0) + P * rec(h, l, k - 1, 1);
} else {
return (1 - P) * rec(h, l, k - 1, 0) + P * rec(r, h, k - 1, 1);
}
}
}
int main() {
cin >> K >> R >> L;
cin >> P;
cin >> E;
cin >> T;
printf("%.10f\n", rec(R, L, K, 0));
return 0;
} | insert | 18 | 18 | 18 | 26 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
double P, E, T;
double solve(double L, double R, int K) {
double H = (L + R) / 2.0;
if (K == 0) {
if (T - E <= H && H <= T + E) {
return 1;
} else {
return 0;
}
}
if (T - E > L || T + E < R) {
return 0;
}
double res = 0;
if (H < T) {
res += solve(L, H, K - 1) * (1 - P);
res += solve(H, R, K - 1) * P;
} else {
res += solve(H, R, K - 1) * (1 - P);
res += solve(L, H, K - 1) * P;
}
return res;
}
int main() {
int K;
double R, L;
cin >> K >> R >> L >> P >> E >> T;
printf("%.8f\n", solve(L, R, K));
return 0;
} | #include <bits/stdc++.h>
using namespace std;
double P, E, T;
double solve(double L, double R, int K) {
double H = (L + R) / 2.0;
if (K == 0) {
if (T - E <= H && H <= T + E) {
return 1;
} else {
return 0;
}
}
if (T - E <= L && L <= T + E && T - E <= R && R <= T + E) {
return 1;
}
if (T - E > L || T + E < R) {
return 0;
}
double res = 0;
if (H < T) {
res += solve(L, H, K - 1) * (1 - P);
res += solve(H, R, K - 1) * P;
} else {
res += solve(H, R, K - 1) * (1 - P);
res += solve(L, H, K - 1) * P;
}
return res;
}
int main() {
int K;
double R, L;
cin >> K >> R >> L >> P >> E >> T;
printf("%.8f\n", solve(L, R, K));
return 0;
} | insert | 14 | 14 | 14 | 18 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
double R, L, H;
double P, E, T;
int k;
double sleep(double L, double R, double k) {
double H = (L + R) / 2;
if (!k) {
if (abs(T - H) > E)
return 0.0;
return 1.0;
}
if (T + E < R)
return 0.0;
if (T - E > L)
return 0.0;
if (H < T)
return P * sleep(H, R, k - 1) + (1.0 - P) * sleep(L, H, k - 1);
else
return (1.0 - P) * sleep(H, R, k - 1) + P * sleep(L, H, k - 1);
}
int main() {
cin >> k >> R >> L >> P >> E >> T;
printf("%.8lf\n", sleep(L, R, k));
} | #include <cmath>
#include <cstdio>
#include <iostream>
using namespace std;
double R, L, H;
double P, E, T;
int k;
double sleep(double L, double R, double k) {
double H = (L + R) / 2;
if (!k) {
if (abs(T - H) > E)
return 0.0;
return 1.0;
}
if (T - E < R && L < T + E)
return 1.0;
if (T + E < R)
return 0.0;
if (T - E > L)
return 0.0;
if (H < T)
return P * sleep(H, R, k - 1) + (1.0 - P) * sleep(L, H, k - 1);
else
return (1.0 - P) * sleep(H, R, k - 1) + P * sleep(L, H, k - 1);
}
int main() {
cin >> k >> R >> L >> P >> E >> T;
printf("%.8lf\n", sleep(L, R, k));
} | insert | 17 | 17 | 17 | 19 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <cstdio>
#include <iostream>
using namespace std;
int R, L, K;
double P, E, T, ans = 0;
void b_search(int k, double r, double l, double p) {
if (l <= (T - E) || (T + E) <= r)
return;
if (k == K) {
double H = (r + l) / 2;
if (T - E < H && H < T + E)
ans += p;
} else {
double H = (r + l) / 2;
if (H <= T) {
b_search(k + 1, H, l, (1 - P) * p);
b_search(k + 1, r, H, P * p);
}
if (H > T) {
b_search(k + 1, r, H, (1 - P) * p);
b_search(k + 1, H, l, P * p);
}
}
}
int main() {
cin >> K >> R >> L >> P >> E >> T;
b_search(0, R, L, 1);
printf("%.8f\n", ans);
return 0;
} | #include <cstdio>
#include <iostream>
using namespace std;
int R, L, K;
double P, E, T, ans = 0;
void b_search(int k, double r, double l, double p) {
if (l <= (T - E) || (T + E) <= r)
return;
if ((T - E) <= r && l <= (T + E)) {
ans += p;
return;
}
if (k == K) {
double H = (r + l) / 2;
if (T - E < H && H < T + E)
ans += p;
} else {
double H = (r + l) / 2;
if (H <= T) {
b_search(k + 1, H, l, (1 - P) * p);
b_search(k + 1, r, H, P * p);
}
if (H > T) {
b_search(k + 1, r, H, (1 - P) * p);
b_search(k + 1, H, l, P * p);
}
}
}
int main() {
cin >> K >> R >> L >> P >> E >> T;
b_search(0, R, L, 1);
printf("%.8f\n", ans);
return 0;
} | replace | 10 | 11 | 10 | 14 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
int day[33];
double low, high;
LL sum = 0;
double P, E, T;
double Tp;
int K;
double res;
void gao(int u, int ntp, int tp, double R, double L) {
double H = (R + L) / 2;
// printf("H=%lf\n",H);
if (R >= low && L <= high) {
res += pow(1 - P, ntp) * pow(P, tp);
return;
}
if (R > high || L < low)
return;
if (u == K) {
Tp = H;
if (low <= Tp && Tp <= high) {
// printf("%d %d\n", K-tp,tp);
res += pow(1 - P, ntp) * pow(P, tp);
}
return;
}
if (H >= T) {
gao(u + 1, ntp + 1, tp, R, H);
gao(u + 1, ntp, tp + 1, H, L);
} else {
gao(u + 1, ntp, tp + 1, R, H);
gao(u + 1, ntp + 1, tp, H, L);
}
}
double R, L;
int main() {
while (scanf("%d%lf%lf", &K, &R, &L)) {
scanf("%lf%lf%lf", &P, &E, &T);
low = max(0.0, T - E);
high = T + E;
res = 0;
gao(0, 0, 0, R, L);
printf("%lf\n", res);
}
return 0;
} | #include <algorithm>
#include <cctype>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef unsigned long long uLL;
int day[33];
double low, high;
LL sum = 0;
double P, E, T;
double Tp;
int K;
double res;
void gao(int u, int ntp, int tp, double R, double L) {
double H = (R + L) / 2;
// printf("H=%lf\n",H);
if (R >= low && L <= high) {
res += pow(1 - P, ntp) * pow(P, tp);
return;
}
if (R > high || L < low)
return;
if (u == K) {
Tp = H;
if (low <= Tp && Tp <= high) {
// printf("%d %d\n", K-tp,tp);
res += pow(1 - P, ntp) * pow(P, tp);
}
return;
}
if (H >= T) {
gao(u + 1, ntp + 1, tp, R, H);
gao(u + 1, ntp, tp + 1, H, L);
} else {
gao(u + 1, ntp, tp + 1, R, H);
gao(u + 1, ntp + 1, tp, H, L);
}
}
double R, L;
int main() {
while (~scanf("%d%lf%lf", &K, &R, &L)) {
scanf("%lf%lf%lf", &P, &E, &T);
low = max(0.0, T - E);
high = T + E;
res = 0;
gao(0, 0, 0, R, L);
printf("%lf\n", res);
}
return 0;
} | replace | 64 | 65 | 64 | 65 | TLE | |
p01418 | C++ | Time Limit Exceeded | #include <iomanip>
#include <iostream>
using namespace std;
int K, L, R;
double P, E, T;
double solve(double l, double r, int d) {
double v = (l + r) / 2;
if (d == K)
return ((T - E <= v && v < T + E) ? 1.0 : 0.0);
if (v < T)
return solve(l, (l + r) / 2, d + 1) * P +
solve((l + r) / 2, r, d + 1) * (1.0 - P);
return solve(l, (l + r) / 2, d + 1) * (1.0 - P) +
solve((l + r) / 2, r, d + 1) * P;
}
int main() {
cin >> K >> L >> R >> P >> E >> T;
cout << fixed << setprecision(15) << solve(L, R, 0) << endl;
return 0;
} | #include <iomanip>
#include <iostream>
using namespace std;
int K, L, R;
double P, E, T;
inline double solve(double l, double r, int d) {
double v = (l + r) / 2;
if (d == K)
return ((T - E <= v && v < T + E) ? 1.0 : 0.0);
if (v < T)
return solve(l, (l + r) / 2, d + 1) * P +
solve((l + r) / 2, r, d + 1) * (1.0 - P);
return solve(l, (l + r) / 2, d + 1) * (1.0 - P) +
solve((l + r) / 2, r, d + 1) * P;
}
int main() {
cin >> K >> L >> R >> P >> E >> T;
cout << fixed << setprecision(15) << solve(L, R, 0) << endl;
return 0;
} | replace | 5 | 6 | 5 | 6 | TLE | |
p01419 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
void dfs(bool &end, int a, int b, vector<vector<int>> adjlist,
vector<int> &temp_node, vector<bool> &used) {
// cout << a << " ";
if (a == b) {
end = true;
return;
}
for (int i = 0; i < adjlist[a].size(); i++) {
if (used[adjlist[a][i]] == false) {
used[adjlist[a][i]] = true;
temp_node.push_back(adjlist[a][i]);
dfs(end, adjlist[a][i], b, adjlist, temp_node, used);
if (end)
return;
temp_node.pop_back();
}
}
}
int main() {
int r, c, m;
cin >> r >> c >> m;
vector<vector<bool>> room(r, vector<bool>(c, true));
vector<vector<int>> on(r, vector<int>(c, 0));
vector<vector<int>> off(r, vector<int>(c, 0));
vector<vector<int>> per_time(r, vector<int>(c, 0));
vector<int> x(m);
vector<int> y(m);
// 入力
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char input;
cin >> input;
if (input == '#')
room[i][j] = false;
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> per_time[i][j];
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> on[i][j];
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> off[i][j];
}
}
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
}
// mapの作成
map<pair<int, int>, int> M;
map<int, pair<int, int>> _M;
int num = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (room[i][j] == true) {
M[make_pair(i, j)] = num;
_M[num] = make_pair(i, j);
num++;
}
}
}
// 隣接リスト
vector<vector<int>> adjlist(num);
int di[4] = {0, 1, 0, -1};
int dj[4] = {1, 0, -1, 0};
// グラフを作成
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (room[i][j] == true) {
for (int h = 0; h < 4; h++) {
int ni = i + di[h];
int nj = j + dj[h];
if (0 <= ni && ni < r && 0 <= nj && nj < c) {
if (room[ni][nj] == true) {
int a = M[make_pair(i, j)];
int b = M[make_pair(ni, nj)];
adjlist[a].push_back(b);
// adjlist[b].push_back(a);
}
}
}
}
}
}
// o
vector<vector<int>> node(m); // 訪れる頂点の順番の配列
node[0].push_back(M[make_pair(x[0], y[0])]);
for (int i = 1; i < m; i++) {
int a = M[make_pair(x[i - 1], y[i - 1])];
int b = M[make_pair(x[i], y[i])];
vector<bool> used(num, false);
bool end = false;
used[a] = true;
dfs(end, a, b, adjlist, node[i], used);
}
// x
// 訪れる時刻
int nt = 0;
vector<vector<int>> t(num, vector<int>(0));
for (int i = 0; i < node.size(); i++) {
for (int j = 0; j < node[i].size(); j++) {
t[node[i][j]].push_back(nt);
nt++;
}
}
int ans = 0;
for (int i = 0; i < num; i++) {
int ni = _M[i].first;
int nj = _M[i].second;
if (t[i].size() == 0)
continue;
else {
ans += on[ni][nj] + off[ni][nj];
for (int j = 1; j < t[i].size(); j++) {
ans += min(on[ni][nj] + off[ni][nj],
(t[i][j] - t[i][j - 1]) * per_time[ni][nj]);
}
}
}
cout << ans << endl;
return 0;
}
| #include <bits/stdc++.h>
using namespace std;
void dfs(bool &end, int a, int b, vector<vector<int>> &adjlist,
vector<int> &temp_node, vector<bool> &used) {
// cout << a << " ";
if (a == b) {
end = true;
return;
}
for (int i = 0; i < adjlist[a].size(); i++) {
if (used[adjlist[a][i]] == false) {
used[adjlist[a][i]] = true;
temp_node.push_back(adjlist[a][i]);
dfs(end, adjlist[a][i], b, adjlist, temp_node, used);
if (end)
return;
temp_node.pop_back();
}
}
}
int main() {
int r, c, m;
cin >> r >> c >> m;
vector<vector<bool>> room(r, vector<bool>(c, true));
vector<vector<int>> on(r, vector<int>(c, 0));
vector<vector<int>> off(r, vector<int>(c, 0));
vector<vector<int>> per_time(r, vector<int>(c, 0));
vector<int> x(m);
vector<int> y(m);
// 入力
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
char input;
cin >> input;
if (input == '#')
room[i][j] = false;
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> per_time[i][j];
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> on[i][j];
}
}
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
cin >> off[i][j];
}
}
for (int i = 0; i < m; i++) {
cin >> x[i] >> y[i];
}
// mapの作成
map<pair<int, int>, int> M;
map<int, pair<int, int>> _M;
int num = 0;
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (room[i][j] == true) {
M[make_pair(i, j)] = num;
_M[num] = make_pair(i, j);
num++;
}
}
}
// 隣接リスト
vector<vector<int>> adjlist(num);
int di[4] = {0, 1, 0, -1};
int dj[4] = {1, 0, -1, 0};
// グラフを作成
for (int i = 0; i < r; i++) {
for (int j = 0; j < c; j++) {
if (room[i][j] == true) {
for (int h = 0; h < 4; h++) {
int ni = i + di[h];
int nj = j + dj[h];
if (0 <= ni && ni < r && 0 <= nj && nj < c) {
if (room[ni][nj] == true) {
int a = M[make_pair(i, j)];
int b = M[make_pair(ni, nj)];
adjlist[a].push_back(b);
// adjlist[b].push_back(a);
}
}
}
}
}
}
// o
vector<vector<int>> node(m); // 訪れる頂点の順番の配列
node[0].push_back(M[make_pair(x[0], y[0])]);
for (int i = 1; i < m; i++) {
int a = M[make_pair(x[i - 1], y[i - 1])];
int b = M[make_pair(x[i], y[i])];
vector<bool> used(num, false);
bool end = false;
used[a] = true;
dfs(end, a, b, adjlist, node[i], used);
}
// x
// 訪れる時刻
int nt = 0;
vector<vector<int>> t(num, vector<int>(0));
for (int i = 0; i < node.size(); i++) {
for (int j = 0; j < node[i].size(); j++) {
t[node[i][j]].push_back(nt);
nt++;
}
}
int ans = 0;
for (int i = 0; i < num; i++) {
int ni = _M[i].first;
int nj = _M[i].second;
if (t[i].size() == 0)
continue;
else {
ans += on[ni][nj] + off[ni][nj];
for (int j = 1; j < t[i].size(); j++) {
ans += min(on[ni][nj] + off[ni][nj],
(t[i][j] - t[i][j - 1]) * per_time[ni][nj]);
}
}
}
cout << ans << endl;
return 0;
}
| replace | 3 | 4 | 3 | 4 | TLE | |
p01420 | C++ | Runtime Error | #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define all(v) (v).begin(), (v).end()
using namespace std;
typedef pair<int, int> P;
const int MAX_N = 101;
const int MAX_M = 51;
ll comb[MAX_M][MAX_M];
double p[MAX_N];
int t[MAX_N], v[MAX_N];
double bp[MAX_N][MAX_M];
double prt[MAX_N];
double ans[MAX_N];
int main() {
int n, m, L;
cin >> n >> m >> L;
rep(i, n) {
cin >> p[i] >> t[i] >> v[i];
p[i] /= 100.0;
}
comb[0][0] = 1;
for (int i = 1; i <= m; i++) {
comb[i][0] = 1;
for (int j = 1; j <= i; j++) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
}
}
rep(i, n) { prt[i] = (double)L / v[i]; }
rep(i, n) {
rep(j, m + 1) {
bp[i][j] = 1.0;
bp[i][j] *= comb[m][j];
rep(k, j) { bp[i][j] *= p[i]; }
rep(k, m - j) { bp[i][j] *= (1.0 - p[i]); }
}
}
rep(i, n) {
bool flag = false;
ans[i] = 0.0;
rep(j, m + 1) {
double tm = bp[i][j];
rep(k, n) {
double sm = 0.0;
if (k != i) {
if (prt[i] + j * t[i] >= prt[k]) {
if (t[k] == 0) {
flag = true;
break;
}
int c = (int)((prt[i] + j * t[i] - prt[k] + EPS) / t[k]) + 1;
if (c > m) {
flag = true;
break;
}
for (int l = c; l <= m; l++) {
sm += bp[k][l];
}
} else {
sm = 1.0;
}
tm *= sm;
}
}
if (flag) {
break;
}
ans[i] += tm;
}
printf("%.10lf\n", ans[i]);
}
return 0;
} | #include <bits/stdc++.h>
#define ll long long
#define INF 1000000005
#define MOD 1000000007
#define EPS 1e-10
#define rep(i, n) for (int i = 0; i < (int)n; ++i)
#define all(v) (v).begin(), (v).end()
using namespace std;
typedef pair<int, int> P;
const int MAX_N = 101;
const int MAX_M = 51;
ll comb[MAX_M][MAX_M];
double p[MAX_N];
int t[MAX_N], v[MAX_N];
double bp[MAX_N][MAX_M];
double prt[MAX_N];
double ans[MAX_N];
int main() {
int n, m, L;
cin >> n >> m >> L;
rep(i, n) {
cin >> p[i] >> t[i] >> v[i];
p[i] /= 100.0;
}
comb[0][0] = 1;
for (int i = 1; i <= m; i++) {
comb[i][0] = 1;
for (int j = 1; j <= i; j++) {
comb[i][j] = comb[i - 1][j - 1] + comb[i - 1][j];
}
}
rep(i, n) {
if (v[i] == 0) {
prt[i] = INF;
} else {
prt[i] = (double)L / v[i];
}
}
rep(i, n) {
rep(j, m + 1) {
bp[i][j] = 1.0;
bp[i][j] *= comb[m][j];
rep(k, j) { bp[i][j] *= p[i]; }
rep(k, m - j) { bp[i][j] *= (1.0 - p[i]); }
}
}
rep(i, n) {
bool flag = false;
ans[i] = 0.0;
rep(j, m + 1) {
double tm = bp[i][j];
rep(k, n) {
double sm = 0.0;
if (k != i) {
if (prt[i] + j * t[i] >= prt[k]) {
if (t[k] == 0) {
flag = true;
break;
}
int c = (int)((prt[i] + j * t[i] - prt[k] + EPS) / t[k]) + 1;
if (c > m) {
flag = true;
break;
}
for (int l = c; l <= m; l++) {
sm += bp[k][l];
}
} else {
sm = 1.0;
}
tm *= sm;
}
}
if (flag) {
break;
}
ans[i] += tm;
}
printf("%.10lf\n", ans[i]);
}
return 0;
} | replace | 36 | 37 | 36 | 43 | 0 | |
p01421 | C++ | Runtime Error | #include <algorithm>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
const int NN = 50 * 50 * 2 + 1;
struct edge {
int s;
int t;
int st;
int ts;
int init;
int nex(int a) { return a == s ? t : s; }
int res(int a) { return a == s ? st : ts; }
void use(int a, int v) {
if (a == s) {
st -= v;
ts += v;
} else {
st += v;
ts -= v;
}
}
};
typedef vector<edge *>::iterator It;
template <int NN, int MM> struct MaxFlow {
edge es[MM];
int esize;
vector<edge *> edges[NN];
void add(int a, int b, int v) {
es[esize].s = a;
es[esize].t = b;
es[esize].st = v;
es[esize].ts = v;
es[esize].init = v;
edges[a].push_back(es + esize);
edges[b].push_back(es + esize);
esize++;
}
edge *pre[NN];
int done[NN];
int q[NN];
int s;
int t;
int flow() {
int ret = 0;
int f = 0;
while (1) {
f++;
int qs = 0;
int qe = 1;
q[0] = s;
done[s] = f;
while (qs < qe) {
int top = q[qs++];
for (It it = edges[top].begin(); it != edges[top].end(); it++) {
int nex = (*it)->nex(top);
if ((*it)->res(top) && done[nex] != f) {
q[qe++] = nex;
pre[nex] = *it;
done[nex] = f;
if (nex == t) {
goto OK;
}
}
}
}
break;
OK:
int p = t;
int res = INT_MAX;
while (p != s) {
int pp = pre[p]->nex(p);
res = min(res, pre[p]->res(pp));
p = pp;
}
p = t;
while (p != s) {
int pp = pre[p]->nex(p);
pre[p]->use(pp, res);
p = pp;
}
ret += res;
}
return ret;
}
};
MaxFlow<300, 1000> mf;
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int X, Y;
cin >> X >> Y;
mf.add(X, Y, 1);
}
cin >> mf.s >> mf.t;
cout << mf.flow() << endl;
int rev = 0;
for (int i = 0; i < mf.esize; i++) {
if (mf.es[i].st > mf.es[i].init) {
rev++;
}
}
cout << rev << endl;
for (int i = 0; i < mf.esize; i++) {
if (mf.es[i].st > mf.es[i].init) {
cout << i + 1 << endl;
}
}
return 0;
} | #include <algorithm>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef long long LL;
typedef pair<int, int> P;
const int NN = 50 * 50 * 2 + 1;
struct edge {
int s;
int t;
int st;
int ts;
int init;
int nex(int a) { return a == s ? t : s; }
int res(int a) { return a == s ? st : ts; }
void use(int a, int v) {
if (a == s) {
st -= v;
ts += v;
} else {
st += v;
ts -= v;
}
}
};
typedef vector<edge *>::iterator It;
template <int NN, int MM> struct MaxFlow {
edge es[MM];
int esize;
vector<edge *> edges[NN];
void add(int a, int b, int v) {
es[esize].s = a;
es[esize].t = b;
es[esize].st = v;
es[esize].ts = v;
es[esize].init = v;
edges[a].push_back(es + esize);
edges[b].push_back(es + esize);
esize++;
}
edge *pre[NN];
int done[NN];
int q[NN];
int s;
int t;
int flow() {
int ret = 0;
int f = 0;
while (1) {
f++;
int qs = 0;
int qe = 1;
q[0] = s;
done[s] = f;
while (qs < qe) {
int top = q[qs++];
for (It it = edges[top].begin(); it != edges[top].end(); it++) {
int nex = (*it)->nex(top);
if ((*it)->res(top) && done[nex] != f) {
q[qe++] = nex;
pre[nex] = *it;
done[nex] = f;
if (nex == t) {
goto OK;
}
}
}
}
break;
OK:
int p = t;
int res = INT_MAX;
while (p != s) {
int pp = pre[p]->nex(p);
res = min(res, pre[p]->res(pp));
p = pp;
}
p = t;
while (p != s) {
int pp = pre[p]->nex(p);
pre[p]->use(pp, res);
p = pp;
}
ret += res;
}
return ret;
}
};
MaxFlow<301, 1000> mf;
int main() {
int N, M;
cin >> N >> M;
for (int i = 0; i < M; i++) {
int X, Y;
cin >> X >> Y;
mf.add(X, Y, 1);
}
cin >> mf.s >> mf.t;
cout << mf.flow() << endl;
int rev = 0;
for (int i = 0; i < mf.esize; i++) {
if (mf.es[i].st > mf.es[i].init) {
rev++;
}
}
cout << rev << endl;
for (int i = 0; i < mf.esize; i++) {
if (mf.es[i].st > mf.es[i].init) {
cout << i + 1 << endl;
}
}
return 0;
} | replace | 106 | 107 | 106 | 107 | 0 | |
p01422 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N 25
#define MAX_C 300000
#define INF 9999999999.99
vector<int> yakusuu[MAX_C];
double dp[MAX_N][MAX_C];
int n;
int x[MAX_N];
void yaku() {
for (int i = 1; i < MAX_C; i++) {
for (int j = i; j < MAX_C; j += i) {
yakusuu[j].push_back(i);
}
}
}
int main() {
yaku();
cin >> n;
x[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
dp[0][0] = INF;
for (int i = 1; i < MAX_C; i++) {
dp[1][i] = 1.0 * abs(x[1] - i) / x[1];
}
for (int i = 2; i < MAX_N; i++) {
for (int j = 0; j < MAX_C; j++) {
dp[i][j] = INF;
}
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j < MAX_C; j++) {
for (int k = 0; k < yakusuu[j].size(); k++) {
double pos1 = dp[i - 1][yakusuu[j][k]];
double pos2 = 1.0 * abs(x[i] - j) / x[i];
double pos3 = max(pos1, pos2);
dp[i][j] = min(dp[i][j], pos3);
}
}
}
double minx = INF;
for (int i = 0; i < MAX_C; i++) {
minx = min(minx, dp[n][i]);
}
cout << fixed << setprecision(15) << minx << endl;
return 0;
} | #include <algorithm>
#include <cmath>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
#define MAX_N 22
#define MAX_C 222222
#define INF 9999999999.99
vector<int> yakusuu[MAX_C];
double dp[MAX_N][MAX_C];
int n;
int x[MAX_N];
void yaku() {
for (int i = 1; i < MAX_C; i++) {
for (int j = i; j < MAX_C; j += i) {
yakusuu[j].push_back(i);
}
}
}
int main() {
yaku();
cin >> n;
x[0] = 1;
for (int i = 1; i <= n; i++) {
cin >> x[i];
}
dp[0][0] = INF;
for (int i = 1; i < MAX_C; i++) {
dp[1][i] = 1.0 * abs(x[1] - i) / x[1];
}
for (int i = 2; i < MAX_N; i++) {
for (int j = 0; j < MAX_C; j++) {
dp[i][j] = INF;
}
}
for (int i = 2; i <= n; i++) {
for (int j = 1; j < MAX_C; j++) {
for (int k = 0; k < yakusuu[j].size(); k++) {
double pos1 = dp[i - 1][yakusuu[j][k]];
double pos2 = 1.0 * abs(x[i] - j) / x[i];
double pos3 = max(pos1, pos2);
dp[i][j] = min(dp[i][j], pos3);
}
}
}
double minx = INF;
for (int i = 0; i < MAX_C; i++) {
minx = min(minx, dp[n][i]);
}
cout << fixed << setprecision(15) << minx << endl;
return 0;
} | replace | 7 | 9 | 7 | 9 | MLE | |
p01422 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#ifdef _WIN32
#define scanfll(x) scanf("%I64d", x)
#define printfll(x) printf("%I64d", x)
#else
#define scanfll(x) scanf("%lld", x)
#define printfll(x) printf("%lld", x)
#endif
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define repi(i, a, b) \
for (long long i = (long long)(a); i < (long long)(b); i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template <class T1, class T2> bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2> bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
vll r(v.size());
rep(i, v.size()) r[i] = v[i];
return r;
}
using P = pair<ll, ll>;
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
o << "(" << v.first << ", " << v.second << ")";
return o;
}
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using s = int[];
(void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
-> basic_ostream<Ch, Tr> & {
os << "(";
print_tuple(os, t, gen_seq<sizeof...(Args)>());
return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
rep(i, v.size()) {
rep(j, v[i].size()) o << v[i][j] << " ";
cout << endl;
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const unordered_map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it;
o << "]";
return o;
}
void printbits(ll mask, ll n) {
rep(i, n) { cout << !!(mask & (1ll << i)); }
cout << endl;
}
#define ldout fixed << setprecision(40)
static const double EPS = 1e-14;
static const long long INF = 1e18;
static const long long mo = 1e9 + 7;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<double> a(n);
rep(i, a.size()) cin >> a[i];
const ll maxn = 400010;
static double dp[25][maxn];
rep(i, 25) rep(j, maxn) { dp[i][j] = INF; }
rep(i, maxn) { dp[1][i] = (double)abs(i - a[0]) / (double)a[0]; }
// rep(i, 20) { cout << dp[1][i] << " "; } cout << endl;
repi(i, 1, n) repi(j, 1, maxn) for (ll h = j; h < maxn; h += j) {
chmin(dp[i + 1][h], max(dp[i][j], (double)abs(h - a[i]) / (double)a[i]));
// rep(j, 20) { cout << dp[i+1][j] << " "; } cout << endl;
}
double ret = INF;
int i = n;
repi(j, 1, maxn) { chmin(ret, dp[i][j]); }
cout << ldout << ret << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#ifdef _WIN32
#define scanfll(x) scanf("%I64d", x)
#define printfll(x) printf("%I64d", x)
#else
#define scanfll(x) scanf("%lld", x)
#define printfll(x) printf("%lld", x)
#endif
#define rep(i, n) for (long long i = 0; i < (long long)(n); i++)
#define repi(i, a, b) \
for (long long i = (long long)(a); i < (long long)(b); i++)
#define pb push_back
#define all(x) (x).begin(), (x).end()
#define fi first
#define se second
#define mt make_tuple
#define mp make_pair
template <class T1, class T2> bool chmin(T1 &a, T2 b) {
return b < a && (a = b, true);
}
template <class T1, class T2> bool chmax(T1 &a, T2 b) {
return a < b && (a = b, true);
}
using ll = long long;
using ld = long double;
using vll = vector<ll>;
using vvll = vector<vll>;
using vld = vector<ld>;
using vi = vector<int>;
using vvi = vector<vi>;
vll conv(vi &v) {
vll r(v.size());
rep(i, v.size()) r[i] = v[i];
return r;
}
using P = pair<ll, ll>;
template <typename T, typename U>
ostream &operator<<(ostream &o, const pair<T, U> &v) {
o << "(" << v.first << ", " << v.second << ")";
return o;
}
template <size_t...> struct seq {};
template <size_t N, size_t... Is>
struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
template <size_t... Is> struct gen_seq<0, Is...> : seq<Is...> {};
template <class Ch, class Tr, class Tuple, size_t... Is>
void print_tuple(basic_ostream<Ch, Tr> &os, Tuple const &t, seq<Is...>) {
using s = int[];
(void)s{0, (void(os << (Is == 0 ? "" : ", ") << get<Is>(t)), 0)...};
}
template <class Ch, class Tr, class... Args>
auto operator<<(basic_ostream<Ch, Tr> &os, tuple<Args...> const &t)
-> basic_ostream<Ch, Tr> & {
os << "(";
print_tuple(os, t, gen_seq<sizeof...(Args)>());
return os << ")";
}
ostream &operator<<(ostream &o, const vvll &v) {
rep(i, v.size()) {
rep(j, v[i].size()) o << v[i][j] << " ";
cout << endl;
}
return o;
}
template <typename T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << '[';
rep(i, v.size()) o << v[i] << (i != v.size() - 1 ? ", " : "");
o << "]";
return o;
}
template <typename T> ostream &operator<<(ostream &o, const set<T> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it << (next(it) != m.end() ? ", " : "");
o << "]";
return o;
}
template <typename T, typename U>
ostream &operator<<(ostream &o, const unordered_map<T, U> &m) {
o << '[';
for (auto it = m.begin(); it != m.end(); it++)
o << *it;
o << "]";
return o;
}
void printbits(ll mask, ll n) {
rep(i, n) { cout << !!(mask & (1ll << i)); }
cout << endl;
}
#define ldout fixed << setprecision(40)
static const double EPS = 1e-14;
static const long long INF = 1e18;
static const long long mo = 1e9 + 7;
int main(void) {
cin.tie(0);
ios::sync_with_stdio(false);
ll n;
cin >> n;
vector<double> a(n);
rep(i, a.size()) cin >> a[i];
const ll maxn = 200010;
static double dp[25][maxn];
rep(i, 25) rep(j, maxn) { dp[i][j] = INF; }
rep(i, maxn) { dp[1][i] = (double)abs(i - a[0]) / (double)a[0]; }
// rep(i, 20) { cout << dp[1][i] << " "; } cout << endl;
repi(i, 1, n) repi(j, 1, maxn) for (ll h = j; h < maxn; h += j) {
chmin(dp[i + 1][h], max(dp[i][j], (double)abs(h - a[i]) / (double)a[i]));
// rep(j, 20) { cout << dp[i+1][j] << " "; } cout << endl;
}
double ret = INF;
int i = n;
repi(j, 1, maxn) { chmin(ret, dp[i][j]); }
cout << ldout << ret << endl;
return 0;
} | replace | 115 | 116 | 115 | 116 | MLE | |
p01422 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int maxn = 22;
const int maxm = 222222;
double dp[maxn][maxm];
int a[maxn];
double rat(int x, int y) { return 1.0 * abs(x - y) / x; }
int main() {
int n, i, j, k;
double ans, Min;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; ++i)
scanf("%d", &a[i]);
memset(dp, 0x7f, sizeof(dp));
for (i = 1; i < maxm; ++i) {
dp[1][i] = rat(a[1], i);
}
for (i = 2; i <= n; ++i) {
// Min = dp[0][0];
for (j = 1; j < maxm; ++j) {
for (k = 1; k * j < maxm; ++k) {
dp[i][k * j] = min(dp[i][k * j], max(dp[i - 1][j], rat(a[i], k * j)));
// printf ("%lf %lf %lf\n", dp[i][k * j], dp[i-1][j], rat (a[i], k *
// j)); Min = min (Min, dp[i][k * j]);
}
}
// printf ("Min: %lf\n", Min);
}
ans = dp[n][1];
for (j = 2; j < maxm; ++j) {
ans = min(ans, dp[n][j]);
}
printf("%.12lf\n", ans);
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
const int maxn = 22;
const int maxm = 150000;
double dp[maxn][maxm];
int a[maxn];
double rat(int x, int y) { return 1.0 * abs(x - y) / x; }
int main() {
int n, i, j, k;
double ans, Min;
while (~scanf("%d", &n)) {
for (i = 1; i <= n; ++i)
scanf("%d", &a[i]);
memset(dp, 0x7f, sizeof(dp));
for (i = 1; i < maxm; ++i) {
dp[1][i] = rat(a[1], i);
}
for (i = 2; i <= n; ++i) {
// Min = dp[0][0];
for (j = 1; j < maxm; ++j) {
for (k = 1; k * j < maxm; ++k) {
dp[i][k * j] = min(dp[i][k * j], max(dp[i - 1][j], rat(a[i], k * j)));
// printf ("%lf %lf %lf\n", dp[i][k * j], dp[i-1][j], rat (a[i], k *
// j)); Min = min (Min, dp[i][k * j]);
}
}
// printf ("Min: %lf\n", Min);
}
ans = dp[n][1];
for (j = 2; j < maxm; ++j) {
ans = min(ans, dp[n][j]);
}
printf("%.12lf\n", ans);
}
return 0;
} | replace | 16 | 17 | 16 | 17 | MLE | |
p01422 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
const double eps = 1e-9;
int N;
int a[20];
vector<double> v;
bool equals(double s, double t) { return fabs(s - t) < eps; }
double cost(int s, int t) { return (double)abs(s - t) / s; }
bool rec(int bx, int k, double lim) {
if (k == N)
return true;
for (int b = bx;; ++b) {
if (b % bx)
continue;
double newV = cost(a[k], b);
if (newV < lim || equals(newV, lim)) {
if (rec(b, k + 1, lim))
return true;
} else {
if (a[k] < b)
break;
else
continue;
}
}
return false;
}
double solve() {
v.push_back(0.0);
for (int m = 1; m <= 100000; ++m) {
for (int i = 0; i < N; ++i) {
v.push_back((double)m / a[i]);
}
}
sort(v.begin(), v.end());
int l = 0;
int r = v.size();
int ansi = 0;
while (l < r) {
int m = (l + r) / 2;
if (rec(1, 0, v[m])) {
ansi = r = m;
} else {
l = m + 1;
}
}
return v[ansi];
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
printf("%.12f\n", solve());
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
const double eps = 1e-9;
int N;
int a[20];
vector<double> v;
bool equals(double s, double t) { return fabs(s - t) < eps; }
double cost(int s, int t) { return (double)abs(s - t) / s; }
bool rec(int bx, int k, double lim) {
if (k == N)
return true;
for (int b = bx;; b += bx) {
double newV = cost(a[k], b);
if (newV < lim || equals(newV, lim)) {
if (rec(b, k + 1, lim))
return true;
} else {
if (a[k] < b)
break;
else
continue;
}
}
return false;
}
double solve() {
v.push_back(0.0);
for (int m = 1; m <= 100000; ++m) {
for (int i = 0; i < N; ++i) {
v.push_back((double)m / a[i]);
}
}
sort(v.begin(), v.end());
int l = 0;
int r = v.size();
int ansi = 0;
while (l < r) {
int m = (l + r) / 2;
if (rec(1, 0, v[m])) {
ansi = r = m;
} else {
l = m + 1;
}
}
return v[ansi];
}
int main() {
cin >> N;
for (int i = 0; i < N; ++i)
cin >> a[i];
printf("%.12f\n", solve());
return 0;
} | replace | 19 | 22 | 19 | 20 | TLE | |
p01423 | 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 int inf = 1LL << 30;
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);
int n, res;
using vvi = vector<vi>;
vvi costs;
vi invited, used;
void dfs(int v) {
if (v == n) {
int cost = 0;
rep(i, n) {
if (not invited[i])
continue;
int diff = inf;
rep(j, n) {
if (i != j and invited[j]) {
chmin(diff, costs[i][j]);
}
}
if (diff == inf)
continue;
cost += diff;
}
chmax(res, cost);
return;
}
// not use v
dfs(v + 1);
// use v
invited[v] = true;
vi idxs;
rep(u, v + 1, n) {
if (costs[v][u] == 0 and not used[u]) {
used[u] = true;
idxs.push_back(u);
}
}
dfs(v + 1);
for (auto &u : idxs) {
used[u] = false;
}
invited[v] = false;
}
int main(void) {
int m;
cin >> n >> m;
costs = vvi(n, vi(n));
rep(loop, m) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
costs[a][b] = costs[b][a] = c;
}
invited = used = vi(n);
res = 0;
dfs(0);
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 int inf = 1LL << 30;
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);
int n, res;
using vvi = vector<vi>;
vvi costs;
vi invited, used;
void dfs(int v) {
if (v == n) {
int cost = 0;
rep(i, n) {
if (not invited[i])
continue;
int diff = inf;
rep(j, n) {
if (i != j and invited[j]) {
chmin(diff, costs[i][j]);
}
}
if (diff == inf)
continue;
cost += diff;
}
chmax(res, cost);
return;
}
// not use v
dfs(v + 1);
if (used[v])
return;
// use v
invited[v] = true;
vi idxs;
rep(u, v + 1, n) {
if (costs[v][u] == 0 and not used[u]) {
used[u] = true;
idxs.push_back(u);
}
}
dfs(v + 1);
for (auto &u : idxs) {
used[u] = false;
}
invited[v] = false;
}
int main(void) {
int m;
cin >> n >> m;
costs = vvi(n, vi(n));
rep(loop, m) {
int a, b, c;
cin >> a >> b >> c;
a--, b--;
costs[a][b] = costs[b][a] = c;
}
invited = used = vi(n);
res = 0;
dfs(0);
cout << res << endl;
return 0;
} | insert | 96 | 96 | 96 | 99 | TLE | |
p01423 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
vector<int> neighbors[100];
set<set<int>> used;
int weight[100][100];
void dfs(set<int> vs) {
if (used.count(vs))
return;
int score = 0;
if (vs.size() > 1) {
for (auto &&i : vs) {
int c = 1e9;
for (auto &&j : vs) {
if (i != j) {
c = min(weight[i][j], c);
}
}
score += c;
}
}
ans = max(ans, score);
const int representative = *vs.begin();
int cost[100];
for (auto &&i : neighbors[representative])
cost[i] = 1e9;
for (auto &&i : vs) {
for (auto &&j : neighbors[representative]) {
cost[j] = min(weight[i][j], cost[j]);
}
}
for (auto &&i : neighbors[representative])
if (!vs.count(i) and cost[i] > 0) {
set<int> nvs = vs;
nvs.insert(i);
dfs(nvs);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
weight[a][b] = c;
weight[b][a] = c;
neighbors[a].push_back(b);
neighbors[b].push_back(a);
}
ans = 0;
for (int i = 0; i < n; i++) {
dfs({i});
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
int n, m;
int ans;
vector<int> neighbors[100];
set<set<int>> used;
int weight[100][100];
void dfs(set<int> vs) {
if (used.count(vs))
return;
used.insert(vs);
int score = 0;
if (vs.size() > 1) {
for (auto &&i : vs) {
int c = 1e9;
for (auto &&j : vs) {
if (i != j) {
c = min(weight[i][j], c);
}
}
score += c;
}
}
ans = max(ans, score);
const int representative = *vs.begin();
int cost[100];
for (auto &&i : neighbors[representative])
cost[i] = 1e9;
for (auto &&i : vs) {
for (auto &&j : neighbors[representative]) {
cost[j] = min(weight[i][j], cost[j]);
}
}
for (auto &&i : neighbors[representative])
if (!vs.count(i) and cost[i] > 0) {
set<int> nvs = vs;
nvs.insert(i);
dfs(nvs);
}
}
int main() {
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b, c;
cin >> a >> b >> c;
--a, --b;
weight[a][b] = c;
weight[b][a] = c;
neighbors[a].push_back(b);
neighbors[b].push_back(a);
}
ans = 0;
for (int i = 0; i < n; i++) {
dfs({i});
}
cout << ans << endl;
} | insert | 12 | 12 | 12 | 13 | TLE | |
p01423 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define inf (1LL << 50)
int N, M;
vector<vector<long long int>> bridge;
long long int solve(vector<long long int> D, long long int idx) {
long long int ret = 0;
for (int i = idx; i < N; i++) {
auto next = D;
for (int j = 0; j < N; j++) {
if (i != j && D[j] != -1) {
if (D[i] == -1)
D[i] = bridge[i][j];
D[i] = min(D[i], bridge[i][j]);
D[j] = min(D[j], bridge[i][j]);
}
}
long long int plus = 0;
for (int j = 0; j < N; j++) {
long long int x = D[j];
long long int y = next[j];
if (x == -1)
x = 0;
if (y == -1)
y = 0;
plus += x - y;
}
if (plus >= 0) {
ret = max(ret, solve(D, i + 1));
}
D = next;
}
long long int sum = 0;
for (int i = 0; i < N; i++) {
if (D[i] != -1) {
sum += D[i];
}
}
return max(sum, ret);
}
int main() {
cin >> N >> M;
bridge = vector<vector<long long int>>(N, vector<long long int>(N));
vector<pair<long long int, long long int>> bridgepair(M);
for (int i = 0; i < M; i++) {
long long int a, b, c;
cin >> a >> b >> c;
a--;
b--;
bridge[a][b] = c;
bridge[b][a] = c;
bridgepair[i] = (make_pair(a, b));
}
long long int ans = 0;
for (int i = 0; i < M; i++) {
auto x = vector<long long int>(N, -1);
x[bridgepair[i].first] = bridge[bridgepair[i].first][bridgepair[i].second];
x[bridgepair[i].second] = bridge[bridgepair[i].first][bridgepair[i].second];
ans = max(ans, solve(x, 0));
// bridge[bridgepair[i].first][bridgepair[i].second] = -inf;
// bridge[bridgepair[i].second][bridgepair[i].first] = -inf;
}
cout << ans << endl;
} | #include <bits/stdc++.h>
using namespace std;
#define inf (1LL << 50)
int N, M;
vector<vector<long long int>> bridge;
long long int solve(vector<long long int> D, long long int idx) {
long long int ret = 0;
for (int i = idx; i < N; i++) {
auto next = D;
for (int j = 0; j < N; j++) {
if (i != j && D[j] != -1) {
if (D[i] == -1)
D[i] = bridge[i][j];
D[i] = min(D[i], bridge[i][j]);
D[j] = min(D[j], bridge[i][j]);
}
}
long long int plus = 0;
for (int j = 0; j < N; j++) {
long long int x = D[j];
long long int y = next[j];
if (x == -1)
x = 0;
if (y == -1)
y = 0;
plus += x - y;
}
if (plus >= 0) {
ret = max(ret, solve(D, i + 1));
}
D = next;
}
long long int sum = 0;
for (int i = 0; i < N; i++) {
if (D[i] != -1) {
sum += D[i];
}
}
return max(sum, ret);
}
int main() {
cin >> N >> M;
bridge = vector<vector<long long int>>(N, vector<long long int>(N));
vector<pair<long long int, long long int>> bridgepair(M);
for (int i = 0; i < M; i++) {
long long int a, b, c;
cin >> a >> b >> c;
a--;
b--;
bridge[a][b] = c;
bridge[b][a] = c;
bridgepair[i] = (make_pair(a, b));
}
long long int ans = 0;
for (int i = 0; i < M; i++) {
auto x = vector<long long int>(N, -1);
x[bridgepair[i].first] = bridge[bridgepair[i].first][bridgepair[i].second];
x[bridgepair[i].second] = bridge[bridgepair[i].first][bridgepair[i].second];
ans = max(ans, solve(x, 0));
bridge[bridgepair[i].first][bridgepair[i].second] = -inf;
// bridge[bridgepair[i].second][bridgepair[i].first] = -inf;
}
cout << ans << endl;
} | replace | 65 | 66 | 65 | 66 | TLE | |
p01423 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MS(a) memset(a, 0, sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 1e5 + 10;
int n, m, mp[20][20], vis[20], ans;
vector<int> Q;
void dfs(int u) {
int tmp = 0;
for (int i = 0; i < (int)Q.size(); i++) {
int minn = INF;
for (int j = 0; j < (int)Q.size(); j++) {
if (i != j)
minn = min(minn, mp[Q[i]][Q[j]]);
}
if (minn == INF)
minn = 0;
tmp += minn;
}
ans = max(ans, tmp);
for (int v = u + 1; v <= n; v++) {
if (vis[v])
continue;
int flag = 1;
for (
int j = 0; j < (int)Q.size();
j++) { //?????????v???????????????????????????????????????v?°±???????????¨??????????????????
if (mp[v][Q[j]] == 0) {
flag = 0;
break;
}
}
if (flag) {
vis[v] = 1; // ???v
Q.push_back(v);
dfs(v);
vis[v] = 0; // ??????v ?????? ???v??????????????????????°?
Q.pop_back();
}
}
}
int main() {
n = read(), m = read();
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
mp[u][v] = mp[v][u] = w;
}
for (int i = 1; i <= n; i++) {
vis[i] = 1;
Q.push_back(i); // ?????????????????????????????????
dfs(0);
Q.pop_back();
vis[i] = 0;
}
cout << ans << endl;
return 0;
} | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define MS(a) memset(a, 0, sizeof(a))
#define MP make_pair
#define PB push_back
const int INF = 0x3f3f3f3f;
const ll INFLL = 0x3f3f3f3f3f3f3f3fLL;
inline ll read() {
ll x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-')
f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
//////////////////////////////////////////////////////////////////////////
const int maxn = 1e5 + 10;
int n, m, mp[105][105], vis[105], ans;
vector<int> Q;
void dfs(int u) {
int tmp = 0;
for (int i = 0; i < (int)Q.size(); i++) {
int minn = INF;
for (int j = 0; j < (int)Q.size(); j++) {
if (i != j)
minn = min(minn, mp[Q[i]][Q[j]]);
}
if (minn == INF)
minn = 0;
tmp += minn;
}
ans = max(ans, tmp);
for (int v = u + 1; v <= n; v++) {
if (vis[v])
continue;
int flag = 1;
for (
int j = 0; j < (int)Q.size();
j++) { //?????????v???????????????????????????????????????v?°±???????????¨??????????????????
if (mp[v][Q[j]] == 0) {
flag = 0;
break;
}
}
if (flag) {
vis[v] = 1; // ???v
Q.push_back(v);
dfs(v);
vis[v] = 0; // ??????v ?????? ???v??????????????????????°?
Q.pop_back();
}
}
}
int main() {
n = read(), m = read();
for (int i = 0; i < m; i++) {
int u, v, w;
scanf("%d%d%d", &u, &v, &w);
mp[u][v] = mp[v][u] = w;
}
for (int i = 1; i <= n; i++) {
vis[i] = 1;
Q.push_back(i); // ?????????????????????????????????
dfs(0);
Q.pop_back();
vis[i] = 0;
}
cout << ans << endl;
return 0;
} | replace | 25 | 26 | 25 | 26 | 0 | |
p01423 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(S) (S).begin(), (S).end()
template <typename T, typename E>
ostream &operator<<(std::ostream &os, const std::pair<T, E> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
int n, m;
while (cin >> n >> m && n + m) {
int score[110][110];
memset(score, 0, sizeof(score));
REP(i, m) {
int x, y, f;
cin >> x >> y >> f;
x--, y--;
score[x][y] = score[y][x] = f;
}
int res = 0;
REP(i, n) {
vector<int> fs;
REP(j, n) if (score[i][j] > 0) { fs.push_back(j); }
int size = fs.size();
if (size * (size - 1) / 2 <= m) {
REP2(mask, 1, 1 << size) {
vector<int> vs(1, i);
REP(j, mask) if (mask & (1 << j)) { vs.push_back(fs[j]); }
int sum = 0;
REP(j, vs.size()) {
int add = 1e9;
REP(k, vs.size()) if (j != k) {
add = min(add, score[vs[j]][vs[k]]);
}
sum += add;
}
res = max(res, sum);
}
}
}
cout << res << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cctype>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
#define REP2(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define REP(i, n) REP2(i, 0, n)
#define ALL(S) (S).begin(), (S).end()
template <typename T, typename E>
ostream &operator<<(std::ostream &os, const std::pair<T, E> &p) {
return os << "(" << p.first << ", " << p.second << ")";
}
typedef long long ll;
int main() {
ios::sync_with_stdio(false);
int n, m;
while (cin >> n >> m && n + m) {
int score[110][110];
memset(score, 0, sizeof(score));
REP(i, m) {
int x, y, f;
cin >> x >> y >> f;
x--, y--;
score[x][y] = score[y][x] = f;
}
int res = 0;
REP(i, n) {
vector<int> fs;
REP(j, n) if (score[i][j] > 0) { fs.push_back(j); }
int size = fs.size();
if (size * (size - 1) / 2 <= m) {
REP2(mask, 1, 1 << size) {
vector<int> vs(1, i);
REP(j, size) if (mask & (1 << j)) { vs.push_back(fs[j]); }
int sum = 0;
REP(j, vs.size()) {
int add = 1e9;
REP(k, vs.size()) if (j != k) {
add = min(add, score[vs[j]][vs[k]]);
}
sum += add;
}
res = max(res, sum);
}
}
}
cout << res << endl;
}
return 0;
} | replace | 57 | 58 | 57 | 58 | 0 | |
p01423 | C++ | Time Limit Exceeded | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#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;
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#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 SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
VVI G(101);
int is[101][101];
int dfs(int i, int num, VI &xs) {
if (SZ(xs) == num) {
int res = 0;
for (int j = 0; j < num; ++j) {
int tmp = 1e9;
for (int k = 0; k < num; ++k) {
if (j == k)
continue;
if (!is[xs[j]][xs[k]])
return 0;
tmp = min(is[xs[j]][xs[k]], tmp);
}
res += tmp;
}
return res;
}
int res = 0;
for (int to : G[i]) {
if (find(ALL(xs), to) != xs.end())
continue;
xs.PB(to);
res = max(res, dfs(to, num, xs));
xs.pop_back();
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, M;
cin >> N >> M;
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
G[u].PB(v);
G[v].PB(u);
is[u][v] = is[v][u] = c;
}
int ans = 0;
for (int i = 2; i <= min(N, 15); ++i) {
VI xs;
REP(u, N) {
xs.PB(u);
ans = max(ans, dfs(u, i, xs));
xs.pop_back();
}
}
cout << ans << endl;
return 0;
} | // include
//------------------------------------------
#include <algorithm>
#include <bitset>
#include <cctype>
#include <climits>
#include <cmath>
#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;
// typedef
//------------------------------------------
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
// container util
//------------------------------------------
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define PB push_back
#define MP make_pair
#define SZ(a) int((a).size())
#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 SORT(c) sort((c).begin(), (c).end())
// repetition
//------------------------------------------
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
// constant
//--------------------------------------------
const double EPS = 1e-10;
const double PI = acos(-1.0);
VVI G(101);
int is[101][101];
int dfs(int i, int num, VI &xs) {
if (SZ(xs) == num) {
int res = 0;
for (int j = 0; j < num; ++j) {
int tmp = 1e9;
for (int k = 0; k < num; ++k) {
if (j == k)
continue;
if (!is[xs[j]][xs[k]])
return 0;
tmp = min(is[xs[j]][xs[k]], tmp);
}
res += tmp;
}
return res;
}
int res = 0;
for (int to : G[i]) {
if (find(ALL(xs), to) != xs.end() || to <= i)
continue;
xs.PB(to);
res = max(res, dfs(to, num, xs));
xs.pop_back();
}
return res;
}
int main() {
cin.tie(0);
ios_base::sync_with_stdio(false);
int N, M;
cin >> N >> M;
REP(i, M) {
int u, v, c;
cin >> u >> v >> c;
--u, --v;
G[u].PB(v);
G[v].PB(u);
is[u][v] = is[v][u] = c;
}
int ans = 0;
for (int i = 2; i <= min(N, 15); ++i) {
VI xs;
REP(u, N) {
xs.PB(u);
ans = max(ans, dfs(u, i, xs));
xs.pop_back();
}
}
cout << ans << endl;
return 0;
} | replace | 80 | 81 | 80 | 81 | TLE | |
p01423 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) for (int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
const int INF = 1e8;
using namespace std;
#define int long long
int n, m;
int g[105][105];
int ans;
set<vector<bool>> memo;
void dfs(vector<bool> used) {
if (not(memo.emplace(used)).second)
return;
// for(auto i : used){ cout << i << ' ' ; } cout << endl;
vector<int> to;
rep(i, n) {
if (used[i])
continue;
bool f = true;
rep(j, n) {
if (not used[i])
continue;
if (i == j || g[j][i] == 0) {
f = false;
break;
}
}
if (f)
to.emplace_back(i);
}
for (auto i : to) {
used[i] = true;
dfs(used);
used[i] = false;
}
int sum = 0;
rep(i, n) {
if (not used[i])
continue;
int mini = INF;
rep(j, n) {
if (not used[j])
continue;
if (g[i][j] == 0)
continue;
mini = min(mini, g[i][j]);
}
if (mini == INF)
continue;
sum += mini;
}
ans = max(ans, sum);
}
signed main() {
cin >> n >> m;
vector<int> v;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g[a][b] = g[b][a] = c;
}
rep(i, n) {
vector<bool> tmp(n, 0);
tmp[i] = true;
dfs(tmp);
}
cout << ans << endl;
// for(auto i : memo){ for(auto j : i){ cout << j << ' '; } cout << endl; }
} | #include <bits/stdc++.h>
#define range(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, b) for (int i = 0; i < (b); i++)
#define all(a) (a).begin(), (a).end()
#define show(x) cerr << #x << " = " << (x) << endl;
const int INF = 1e8;
using namespace std;
#define int long long
int n, m;
int g[105][105];
int ans;
set<vector<bool>> memo;
void dfs(vector<bool> used) {
if (not(memo.emplace(used)).second)
return;
// for(auto i : used){ cout << i << ' ' ; } cout << endl;
vector<int> to;
rep(i, n) {
if (used[i])
continue;
bool f = true;
rep(j, n) {
if (not used[j])
continue;
if (i == j || g[j][i] == 0) {
f = false;
break;
}
}
if (f)
to.emplace_back(i);
}
for (auto i : to) {
used[i] = true;
dfs(used);
used[i] = false;
}
int sum = 0;
rep(i, n) {
if (not used[i])
continue;
int mini = INF;
rep(j, n) {
if (not used[j])
continue;
if (g[i][j] == 0)
continue;
mini = min(mini, g[i][j]);
}
if (mini == INF)
continue;
sum += mini;
}
ans = max(ans, sum);
}
signed main() {
cin >> n >> m;
vector<int> v;
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
g[a][b] = g[b][a] = c;
}
rep(i, n) {
vector<bool> tmp(n, 0);
tmp[i] = true;
dfs(tmp);
}
cout << ans << endl;
// for(auto i : memo){ for(auto j : i){ cout << j << ' '; } cout << endl; }
} | replace | 26 | 27 | 26 | 27 | TLE | |
p01424 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef vector<int> Node;
typedef vector<Node> Graph;
typedef pair<int, int> P;
typedef tuple<int, int, int, int> T;
const int INF = 1000000000;
int main() {
int N, M;
while (cin >> N >> M) {
vector<string> s(N);
REP(i, N) cin >> s[i];
bool d[100][100] = {};
REP(i, M) {
int a, b;
cin >> a >> b;
a--;
b--;
d[a][b] = true;
}
vector<P> next[100][10][26];
REP(i, N) REP(j, s[i].size()) {
if (j == s[i].size() - 1) {
REP(k, N) if (d[i][k]) { next[i][j][s[k][0] - 'a'].push_back(P(k, 0)); }
} else {
next[i][j][s[i][j + 1] - 'a'].push_back(P(i, j + 1));
}
}
vector<P> nextr[100][10][26];
REP(i, N) REP(j, s[i].size()) {
if (j == 0) {
REP(k, N) if (d[k][i]) {
nextr[i][j][s[k][s[k].size() - 1] - 'a'].push_back(
P(k, s[k].size() - 1));
}
} else {
nextr[i][j][s[i][j - 1] - 'a'].push_back(P(i, j - 1));
}
}
int dist[100][10][100][10] = {};
bool inque[100][10][100][10] = {};
// REP(i, N) REP(j, s[i].size()) REP(k, N) REP(l, s[k].size())
// dist[i][j][k][l] = INF;
queue<T> que;
REP(i, N) REP(k, N) {
if (s[i][0] == s[k][s[k].size() - 1]) {
que.push(T(i, 0, k, s[k].size() - 1));
dist[i][0][k][s[k].size() - 1] = 1;
}
}
int ans = 0;
const int MAX_D = 100000 / 40;
while (!que.empty()) {
int a, i, b, j;
tie(a, i, b, j) = que.front();
que.pop();
inque[a][i][b][j] = false;
int cdist = dist[a][i][b][j];
if (cdist > MAX_D)
continue;
// printf("(%d, %d) (%d, %d) : %d\n", a, i, b, j, cdist);
if (a == b && i == j) {
ans = max(ans, 2 * cdist - 1);
}
bool exist = false;
REP(c, 26)
for (auto p : next[a][i][c]) if (p.first == b && p.second == j) exist =
true;
if (exist) {
ans = max(ans, 2 * cdist);
}
REP(c, 26) for (auto p : next[a][i][c]) for (auto q : nextr[b][j][c]) {
int &ndist = dist[p.first][p.second][q.first][q.second];
bool &inq = inque[p.first][p.second][q.first][q.second];
if (ndist < cdist + 1) {
ndist = cdist + 1;
if (!inq) {
que.push(T(p.first, p.second, q.first, q.second));
inq = true;
}
}
}
}
if (ans >= MAX_D + 1)
ans = -1;
cout << ans << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef vector<int> Node;
typedef vector<Node> Graph;
typedef pair<int, int> P;
typedef tuple<int, int, int, int> T;
const int INF = 1000000000;
int main() {
int N, M;
while (cin >> N >> M) {
vector<string> s(N);
REP(i, N) cin >> s[i];
bool d[100][100] = {};
REP(i, M) {
int a, b;
cin >> a >> b;
a--;
b--;
d[a][b] = true;
}
vector<P> next[100][10][26];
REP(i, N) REP(j, s[i].size()) {
if (j == s[i].size() - 1) {
REP(k, N) if (d[i][k]) { next[i][j][s[k][0] - 'a'].push_back(P(k, 0)); }
} else {
next[i][j][s[i][j + 1] - 'a'].push_back(P(i, j + 1));
}
}
vector<P> nextr[100][10][26];
REP(i, N) REP(j, s[i].size()) {
if (j == 0) {
REP(k, N) if (d[k][i]) {
nextr[i][j][s[k][s[k].size() - 1] - 'a'].push_back(
P(k, s[k].size() - 1));
}
} else {
nextr[i][j][s[i][j - 1] - 'a'].push_back(P(i, j - 1));
}
}
int dist[100][10][100][10] = {};
bool inque[100][10][100][10] = {};
// REP(i, N) REP(j, s[i].size()) REP(k, N) REP(l, s[k].size())
// dist[i][j][k][l] = INF;
queue<T> que;
REP(i, N) REP(k, N) {
if (s[i][0] == s[k][s[k].size() - 1]) {
que.push(T(i, 0, k, s[k].size() - 1));
dist[i][0][k][s[k].size() - 1] = 1;
}
}
int ans = 0;
const int MAX_D = 100000 / 100;
while (!que.empty()) {
int a, i, b, j;
tie(a, i, b, j) = que.front();
que.pop();
inque[a][i][b][j] = false;
int cdist = dist[a][i][b][j];
if (cdist > MAX_D)
continue;
// printf("(%d, %d) (%d, %d) : %d\n", a, i, b, j, cdist);
if (a == b && i == j) {
ans = max(ans, 2 * cdist - 1);
}
bool exist = false;
REP(c, 26)
for (auto p : next[a][i][c]) if (p.first == b && p.second == j) exist =
true;
if (exist) {
ans = max(ans, 2 * cdist);
}
REP(c, 26) for (auto p : next[a][i][c]) for (auto q : nextr[b][j][c]) {
int &ndist = dist[p.first][p.second][q.first][q.second];
bool &inq = inque[p.first][p.second][q.first][q.second];
if (ndist < cdist + 1) {
ndist = cdist + 1;
if (!inq) {
que.push(T(p.first, p.second, q.first, q.second));
inq = true;
}
}
}
}
if (ans >= MAX_D + 1)
ans = -1;
cout << ans << endl;
}
return 0;
} | replace | 62 | 63 | 62 | 63 | TLE | |
p01424 | C++ | Time Limit Exceeded | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
struct State {
int lr;
int left;
int right;
int use;
State() { ; }
State(int lr, int left, int right, int use)
: lr(lr), left(left), right(right), use(use) {
;
}
};
int n, m;
char strs[110][20];
int len[110];
vector<int> g[110];
vector<int> revG[110];
ll memo[2][110][110][12];
int palinMemo[2][110][12];
State moveMemo[2][110][110][12];
int visit[2][110][110][12];
int isPalin(const int lr, const int index, const int use) {
if (palinMemo[lr][index][use] != -1) {
return palinMemo[lr][index][use];
}
int ret = 1;
int l = 0;
int r = len[index] - 1;
if (lr == 0) {
l += use;
} else {
r -= use;
}
while (l < r) {
if (strs[index][l] != strs[index][r]) {
ret = 0;
}
l++;
r--;
}
return palinMemo[lr][index][use] = ret;
}
State Move(const int lr, const int left, const int right, const int use) {
if (moveMemo[lr][left][right][use].lr != -1) {
return moveMemo[lr][left][right][use];
}
State ret(2, left, right, -1);
int l = 0;
int r = len[right] - 1;
if (lr == 0) {
l += use;
} else {
r -= use;
}
while (l < len[left] && r >= 0) {
if (strs[left][l] != strs[right][r]) {
goto end;
}
l++;
r--;
}
if (r == -1) {
ret.lr = 0;
ret.use = l;
} else {
ret.lr = 1;
ret.use = (len[right] - r) - 1;
}
end:
return moveMemo[lr][left][right][use] = ret;
}
ll calc(const int lr, const int left, const int right, const int use) {
if (memo[lr][left][right][use] != -1) {
return memo[lr][left][right][use];
}
// cout << lr << " " << left << " " << right << " " << use << endl;
if (visit[lr][left][right][use] >= 1) {
visit[lr][left][right][use] = 2;
return -(1LL << 60);
}
visit[lr][left][right][use] = 1;
ll ret = -(1LL << 60);
vector<int> *target = NULL;
FORIT(it, g[left]) {
if (*it == right) {
if ((lr == 0 && isPalin(lr, left, use)) ||
(lr == 1 && isPalin(lr, right, use))) {
ret = max(ret, 0LL);
}
break;
}
}
if (lr == 0) {
target = &revG[right];
} else {
target = &g[left];
}
FORIT(it, *target) {
if (*it >= n) {
continue;
}
State next;
if (lr == 0) {
next = Move(lr, left, *it, use);
} else {
next = Move(lr, *it, right, use);
}
if (next.use == -1) {
continue;
}
ret = max(ret, calc(next.lr, next.left, next.right, next.use) + len[*it]);
}
if (visit[lr][left][right][use] == 2 && ret >= 0) {
ret = 1LL << 60;
}
// cout << "ret:" << lr << " " << left << " " << right << " " << use << " " <<
// ret << endl;
visit[lr][left][right][use] = 0;
return ret;
}
int main() {
while (scanf("%d %d", &n, &m) > 0) {
MEMSET(palinMemo, -1);
MEMSET(memo, -1);
MEMSET(moveMemo, -1);
MEMSET(visit, 0);
REP(i, 110) {
g[i].clear();
revG[i].clear();
}
REP(i, n) {
scanf("%s", strs[i]);
len[i] = strlen(strs[i]);
}
REP(i, m) {
int f, t;
scanf("%d %d", &f, &t);
f--;
t--;
g[f].push_back(t);
revG[t].push_back(f);
}
len[n] = 0;
len[n + 1] = 0;
strs[n][0] = '\0';
strs[n + 1][0] = '\0';
REP(i, n) {
g[n].push_back(i);
revG[i].push_back(n);
g[i].push_back(n + 1);
revG[n + 1].push_back(i);
}
ll ans = calc(0, n, n + 1, 0);
ans = max(ans, 0LL);
if (ans >= (1LL << 60)) {
puts("-1");
} else {
printf("%lld\n", ans);
}
}
} | #include <algorithm>
#include <assert.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
struct State {
int lr;
int left;
int right;
int use;
State() { ; }
State(int lr, int left, int right, int use)
: lr(lr), left(left), right(right), use(use) {
;
}
};
int n, m;
char strs[110][20];
int len[110];
vector<int> g[110];
vector<int> revG[110];
ll memo[2][110][110][12];
int palinMemo[2][110][12];
State moveMemo[2][110][110][12];
int visit[2][110][110][12];
int isPalin(const int lr, const int index, const int use) {
if (palinMemo[lr][index][use] != -1) {
return palinMemo[lr][index][use];
}
int ret = 1;
int l = 0;
int r = len[index] - 1;
if (lr == 0) {
l += use;
} else {
r -= use;
}
while (l < r) {
if (strs[index][l] != strs[index][r]) {
ret = 0;
}
l++;
r--;
}
return palinMemo[lr][index][use] = ret;
}
State Move(const int lr, const int left, const int right, const int use) {
if (moveMemo[lr][left][right][use].lr != -1) {
return moveMemo[lr][left][right][use];
}
State ret(2, left, right, -1);
int l = 0;
int r = len[right] - 1;
if (lr == 0) {
l += use;
} else {
r -= use;
}
while (l < len[left] && r >= 0) {
if (strs[left][l] != strs[right][r]) {
goto end;
}
l++;
r--;
}
if (r == -1) {
ret.lr = 0;
ret.use = l;
} else {
ret.lr = 1;
ret.use = (len[right] - r) - 1;
}
end:
return moveMemo[lr][left][right][use] = ret;
}
ll calc(const int lr, const int left, const int right, const int use) {
if (memo[lr][left][right][use] != -1) {
return memo[lr][left][right][use];
}
// cout << lr << " " << left << " " << right << " " << use << endl;
if (visit[lr][left][right][use] >= 1) {
visit[lr][left][right][use] = 2;
return -(1LL << 60);
}
visit[lr][left][right][use] = 1;
ll ret = -(1LL << 60);
vector<int> *target = NULL;
FORIT(it, g[left]) {
if (*it == right) {
if ((lr == 0 && isPalin(lr, left, use)) ||
(lr == 1 && isPalin(lr, right, use))) {
ret = max(ret, 0LL);
}
break;
}
}
if (lr == 0) {
target = &revG[right];
} else {
target = &g[left];
}
FORIT(it, *target) {
if (*it >= n) {
continue;
}
State next;
if (lr == 0) {
next = Move(lr, left, *it, use);
} else {
next = Move(lr, *it, right, use);
}
if (next.use == -1) {
continue;
}
ret = max(ret, calc(next.lr, next.left, next.right, next.use) + len[*it]);
}
if (visit[lr][left][right][use] == 2 && ret >= 0) {
ret = 1LL << 60;
}
// cout << "ret:" << lr << " " << left << " " << right << " " << use << " " <<
// ret << endl;
visit[lr][left][right][use] = 0;
return memo[lr][left][right][use] = ret;
}
int main() {
while (scanf("%d %d", &n, &m) > 0) {
MEMSET(palinMemo, -1);
MEMSET(memo, -1);
MEMSET(moveMemo, -1);
MEMSET(visit, 0);
REP(i, 110) {
g[i].clear();
revG[i].clear();
}
REP(i, n) {
scanf("%s", strs[i]);
len[i] = strlen(strs[i]);
}
REP(i, m) {
int f, t;
scanf("%d %d", &f, &t);
f--;
t--;
g[f].push_back(t);
revG[t].push_back(f);
}
len[n] = 0;
len[n + 1] = 0;
strs[n][0] = '\0';
strs[n + 1][0] = '\0';
REP(i, n) {
g[n].push_back(i);
revG[i].push_back(n);
g[i].push_back(n + 1);
revG[n + 1].push_back(i);
}
ll ans = calc(0, n, n + 1, 0);
ans = max(ans, 0LL);
if (ans >= (1LL << 60)) {
puts("-1");
} else {
printf("%lld\n", ans);
}
}
} | replace | 143 | 144 | 143 | 144 | TLE | |
p01425 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define MP make_pair
#define PB push_back
typedef double DB;
typedef long long LL;
const DB EPS = 1e-8;
const DB PI = acos(-1);
const DB gg = 9.8;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline void checkMin(int &a, int b) {
if (b < a)
a = b;
}
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
const int N = int(1e2) + 9;
int n, l[N], b[N], r[N], t[N];
int X, Y;
DB V;
int low;
inline DB y(DB a, DB x) {
DB t = x / (V * cos(a));
return V * sin(a) * t - 0.5 * gg * t * t;
}
inline DB getM(DB a) {
DB t = V * sin(a) / gg;
return V * cos(a) * t;
}
bool ck(DB a) {
DB h = y(a, X);
if (sgn(h - Y) < 0 || sgn(h - low) > 0)
return false;
DB mx = getM(a), my = y(a, mx);
REP(i, n) {
DB h1 = y(a, l[i]), h2 = y(a, r[i]);
if (l[i] <= mx && mx <= r[i]) {
if (!(h1 <= b[i] && h2 <= b[i] && my <= b[i] ||
h1 >= t[i] && h2 >= t[i] && my >= t[i]))
return false;
} else {
if (!(h1 <= b[i] && h2 <= b[i] || h1 >= t[i] && h2 >= t[i]))
return false;
}
}
return true;
}
bool ck() {
REP(i, n) {
if (l[i] == 0 && b[i] == 0)
return false;
if (l[i] <= X && X <= r[i] && b[i] <= Y && Y <= t[i])
return false;
}
DB d = PI / 2 / 15000;
for (DB a = d; a <= PI / 2; a += d)
if (ck(a))
return true;
return false;
}
int main() {
freopen("in.txt", "r", stdin);
while (~scanf("%d%lf%d%d", &n, &V, &X, &Y)) {
low = INF;
REP(i, n) {
scanf("%d%d%d%d", &l[i], &b[i], &r[i], &t[i]);
if (l[i] > X) {
--i;
--n;
continue;
}
if (r[i] >= X) {
if (b[i] >= Y)
checkMin(low, b[i]);
r[i] = X;
}
}
puts(ck() ? "Yes" : "No");
}
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < n; ++i)
#define MP make_pair
#define PB push_back
typedef double DB;
typedef long long LL;
const DB EPS = 1e-8;
const DB PI = acos(-1);
const DB gg = 9.8;
const int INF = 0x3f3f3f3f;
const int MOD = 1e9 + 7;
inline void checkMin(int &a, int b) {
if (b < a)
a = b;
}
inline int sgn(double x) { return x < -EPS ? -1 : x > EPS; }
const int N = int(1e2) + 9;
int n, l[N], b[N], r[N], t[N];
int X, Y;
DB V;
int low;
inline DB y(DB a, DB x) {
DB t = x / (V * cos(a));
return V * sin(a) * t - 0.5 * gg * t * t;
}
inline DB getM(DB a) {
DB t = V * sin(a) / gg;
return V * cos(a) * t;
}
bool ck(DB a) {
DB h = y(a, X);
if (sgn(h - Y) < 0 || sgn(h - low) > 0)
return false;
DB mx = getM(a), my = y(a, mx);
REP(i, n) {
DB h1 = y(a, l[i]), h2 = y(a, r[i]);
if (l[i] <= mx && mx <= r[i]) {
if (!(h1 <= b[i] && h2 <= b[i] && my <= b[i] ||
h1 >= t[i] && h2 >= t[i] && my >= t[i]))
return false;
} else {
if (!(h1 <= b[i] && h2 <= b[i] || h1 >= t[i] && h2 >= t[i]))
return false;
}
}
return true;
}
bool ck() {
REP(i, n) {
if (l[i] == 0 && b[i] == 0)
return false;
if (l[i] <= X && X <= r[i] && b[i] <= Y && Y <= t[i])
return false;
}
DB d = PI / 2 / 15000;
for (DB a = d; a <= PI / 2; a += d)
if (ck(a))
return true;
return false;
}
int main() {
// freopen("in.txt", "r", stdin);
while (~scanf("%d%lf%d%d", &n, &V, &X, &Y)) {
low = INF;
REP(i, n) {
scanf("%d%d%d%d", &l[i], &b[i], &r[i], &t[i]);
if (l[i] > X) {
--i;
--n;
continue;
}
if (r[i] >= X) {
if (b[i] >= Y)
checkMin(low, b[i]);
r[i] = X;
}
}
puts(ck() ? "Yes" : "No");
}
} | replace | 90 | 91 | 90 | 91 | TLE | |
p01426 | C++ | Memory Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
typedef double Weight;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
const Weight INF = 1e18;
const Weight ZERO = 0;
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;
ld getdis(const vector<ld> &f, const vector<ld> &t) {
ld amin = -1e9;
ld amax = 1e9;
int n = 100;
while (n--) {
ld amid0 = (amin * 2 + amax) / 3;
ld amid1 = (amin + amax * 2) / 3;
ld len0 = 0;
ld len1 = 0;
{
for (int i = 0; i < f.size(); ++i) {
len0 += (t[i] - amid0 * f[i]) * (t[i] - amid0 * f[i]);
}
for (int i = 0; i < f.size(); ++i) {
len1 += (t[i] - amid1 * f[i]) * (t[i] - amid1 * f[i]);
}
}
if (len0 < len1) {
amax = amid1;
} else {
amin = amid0;
}
if (!n)
return len0;
}
}
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
namespace getcycle {
pair<int, vector<Edge>> dfs(const Graph &g, vector<int> &used, const int now,
const int id) {
if (used[now] == -1) {
used[now] = id;
for (auto e : g[now]) {
if (used[e.dst] == id) {
return make_pair(e.dst, vector<Edge>(1, e));
} else if (used[e.dst] != -1) {
continue;
} else {
assert(used[e.dst] == -1);
auto p(dfs(g, used, e.dst, id));
if (p.first == -1) {
return p;
} else if (p.first == -2) {
continue;
} else {
p.second.push_back(e);
if (p.first == now) {
return make_pair(-1, p.second);
} else {
return p;
}
}
}
}
return make_pair(-2, vector<Edge>(0));
} else {
assert(false);
return make_pair(0, vector<Edge>(0));
}
}
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<int> used(g.size(), -1);
int id = 0;
for (int i = 0; i < g.size(); ++i) {
if (used[i] == -1) {
vector<Edge> cycles = dfs(g, used, i, id).second;
id++;
if (!cycles.empty()) {
reverse(cycles.begin(), cycles.end());
return cycles;
}
}
}
return vector<Edge>(0);
}
} // namespace getcycle
// aoj2309???varify??????????????£??????????????§????????????????????????
pair<Weight, Graph> chu_liu(const Graph &g, const int start, const int e_size) {
Graph revg(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<Edge> memo(e_size);
for (auto es : g) {
for (auto e : es) {
// memo[e.id] = e;
revg[e.dst].emplace_back(e.dst, e.src, e.weight);
}
}
Graph tree(g.size());
ld total_len = 0;
for (int node = 0; node < g.size(); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
Weight cycle_len = 0;
vector<Edge> cycle_edges(getcycle::get_cycle(tree, start));
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
if (cycle_edges.empty()) {
return make_pair(total_len, g);
} else {
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(g.size() * g.size());
vector<pair<int, Weight>> prevs(g.size(), make_pair(-1, ZERO));
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
node_is_cycle[ce.dst] = true;
prevs[ce.dst] = make_pair(ce.src, ce.weight);
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
int ne_size = 0;
for (int s = 0; s < g.size(); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
} else if (src_is_cycle) {
newg[compress].push_back(Edge(compress, e.dst, e.weight, e.id));
ne_size++;
} else if (dst_is_cycle) {
newg[s].push_back(
Edge(s, compress, e.weight - prevs[e.dst].second, e.id));
ne_size++;
} else {
newg[s].push_back(Edge(s, e.dst, e.weight, e.id));
ne_size++;
}
}
}
auto p = chu_liu(newg, start, e_size);
Graph compress_tree(g.size());
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
Edge prev_edge(memo[e.id]);
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
ld fin_len = p.first + cycle_len;
return make_pair(fin_len, ans_tree);
}
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M, vector<ld>(N));
vector<vector<ld>> edges(M, vector<ld>(M));
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
cin >> vecs[i][j];
}
}
const int start = 0;
const int node = 1;
Graph g(M + 1);
int id = 0;
for (int i = 0; i < M; ++i) {
ld inidis = 0;
for (int j = 0; j < N; ++j) {
inidis += vecs[i][j] * vecs[i][j];
}
g[start].emplace_back(start, node + i, inidis, id++);
for (int j = 0; j < M; ++j) {
if (i != j) {
ld dis = getdis(vecs[i], vecs[j]);
g[node + i].emplace_back(node + i, node + j, dis, id++);
}
}
}
auto p = chu_liu(g, start, (g.size()) * ((g.size() + 1)));
cout << fixed << setprecision(22) << p.first << endl;
return 0;
} | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
template <class T> using Table = vector<vector<T>>;
const ld eps = 1e-9;
//// < "D:\D_Download\Visual Studio
///2015\Projects\programing_contest_c++\Debug\a.txt" > "D:\D_Download\Visual
///Studio 2015\Projects\programing_contest_c++\Debug\b.answer"
typedef double Weight;
struct Edge {
int src, dst;
Weight weight;
int id;
Edge(int src_, int dst_, Weight weight_, const int id_)
: src(src_), dst(dst_), weight(weight_), id(id_) {}
Edge(int src, int dst, Weight weight) : src(src), dst(dst), weight(weight) {}
Edge() : src(0), dst(0), weight(0) {}
};
const Weight INF = 1e18;
const Weight ZERO = 0;
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;
ld getdis(const vector<ld> &f, const vector<ld> &t) {
ld amin = -1e9;
ld amax = 1e9;
int n = 100;
while (n--) {
ld amid0 = (amin * 2 + amax) / 3;
ld amid1 = (amin + amax * 2) / 3;
ld len0 = 0;
ld len1 = 0;
{
for (int i = 0; i < f.size(); ++i) {
len0 += (t[i] - amid0 * f[i]) * (t[i] - amid0 * f[i]);
}
for (int i = 0; i < f.size(); ++i) {
len1 += (t[i] - amid1 * f[i]) * (t[i] - amid1 * f[i]);
}
}
if (len0 < len1) {
amax = amid1;
} else {
amin = amid0;
}
if (!n)
return len0;
}
}
struct Dscc {
public:
// belongs,newedges
pair<vector<vector<int>>, vector<vector<int>>>
get(const vector<vector<int>> &edges) {
nums.resize(edges.size());
fill(nums.begin(), nums.end(), -1);
vector<vector<int>> revedges(edges.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
revedges[j].push_back(i);
}
}
int num = 0;
for (int i = 0; i < edges.size(); ++i) {
dfs(i, num, edges);
}
vector<int> big(nums.size());
for (int i = 0; i < nums.size(); ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(edges.size());
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < big.size(); ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < unis.size(); ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
map<int, int> mp;
for (int i = 0; i < nums.size(); ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < unis.size(); ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(nums.size());
for (int i = 0; i < unis.size(); ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<int>> newedges(nums.size());
for (int i = 0; i < edges.size(); ++i) {
for (auto j : edges[i]) {
if (unis[i] != unis[j]) {
newedges[unis[i]].push_back(unis[j]);
}
}
}
return make_pair(belongs, newedges);
}
// belongs,newedges
pair<vector<vector<int>>, vector<vector<Edge>>>
get(const vector<vector<Edge>> &edges) {
const int old_node_size = edges.size();
nums.resize(old_node_size);
fill(nums.begin(), nums.end(), -1);
vector<vector<Edge>> revedges(old_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
revedges[j.dst].push_back(Edge(j.dst, j.src, j.weight));
}
}
int num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs(i, num, edges);
}
vector<int> big(old_node_size);
for (int i = 0; i < old_node_size; ++i) {
big[nums[i]] = i;
}
reverse(big.begin(), big.end());
unis.resize(old_node_size);
fill(unis.begin(), unis.end(), -1);
num = 0;
for (int i = 0; i < old_node_size; ++i) {
dfs2(big[i], num, revedges);
num++;
}
vector<int> nums;
for (int i = 0; i < old_node_size; ++i) {
nums.push_back(unis[i]);
}
sort(nums.begin(), nums.end());
nums.erase(unique(nums.begin(), nums.end()), nums.end());
const int new_node_size = nums.size();
map<int, int> mp;
for (int i = 0; i < new_node_size; ++i) {
mp[nums[i]] = i;
}
for (int i = 0; i < old_node_size; ++i) {
unis[i] = mp[unis[i]];
}
vector<vector<int>> belongs(new_node_size);
for (int i = 0; i < old_node_size; ++i) {
belongs[unis[i]].push_back(i);
}
vector<vector<Edge>> newedges(new_node_size);
for (const auto &e : edges) {
for (const auto &j : e) {
if (unis[j.src] != unis[j.dst]) {
newedges[unis[j.src]].push_back(
Edge(unis[j.src], unis[j.dst], j.weight));
}
}
}
return make_pair(belongs, newedges);
}
private:
vector<int> nums;
vector<int> unis;
void dfs(const int id, int &num, const vector<vector<int>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<int>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id])
dfs2(i, num, edges);
}
unis[id] = num;
return;
}
void dfs(const int id, int &num, const vector<vector<Edge>> &edges) {
if (nums[id] != -1)
return;
else {
nums[id] = -2;
for (auto i : edges[id]) {
dfs(i.dst, num, edges);
}
}
nums[id] = num++;
return;
}
void dfs2(const int id, const int &num, const vector<vector<Edge>> &edges) {
if (unis[id] != -1)
return;
else {
unis[id] = -2;
for (auto i : edges[id]) {
dfs2(i.dst, num, edges);
}
}
unis[id] = num;
return;
}
} dscc;
namespace getcycle {
pair<int, vector<Edge>> dfs(const Graph &g, vector<int> &used, const int now,
const int id) {
if (used[now] == -1) {
used[now] = id;
for (auto e : g[now]) {
if (used[e.dst] == id) {
return make_pair(e.dst, vector<Edge>(1, e));
} else if (used[e.dst] != -1) {
continue;
} else {
assert(used[e.dst] == -1);
auto p(dfs(g, used, e.dst, id));
if (p.first == -1) {
return p;
} else if (p.first == -2) {
continue;
} else {
p.second.push_back(e);
if (p.first == now) {
return make_pair(-1, p.second);
} else {
return p;
}
}
}
}
return make_pair(-2, vector<Edge>(0));
} else {
assert(false);
return make_pair(0, vector<Edge>(0));
}
}
vector<Edge> get_cycle(const Graph &g, const int start) {
vector<int> used(g.size(), -1);
int id = 0;
for (int i = 0; i < g.size(); ++i) {
if (used[i] == -1) {
vector<Edge> cycles = dfs(g, used, i, id).second;
id++;
if (!cycles.empty()) {
reverse(cycles.begin(), cycles.end());
return cycles;
}
}
}
return vector<Edge>(0);
}
} // namespace getcycle
// aoj2309???varify??????????????£??????????????§????????????????????????
pair<Weight, Graph> chu_liu(const Graph &g, const int start, const int e_size) {
Graph revg(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<Edge> memo(e_size);
for (auto es : g) {
for (auto e : es) {
// memo[e.id] = e;
revg[e.dst].emplace_back(e.dst, e.src, e.weight);
}
}
Graph tree(g.size());
ld total_len = 0;
for (int node = 0; node < g.size(); ++node) {
if (node == start)
continue;
else {
Weight amin = INF;
Edge min_edge;
for (auto reve : revg[node]) {
if (amin > reve.weight) {
amin = reve.weight;
min_edge = Edge(reve.dst, reve.src, reve.weight);
}
}
if (amin < INF) {
total_len += min_edge.weight;
tree[min_edge.src].emplace_back(min_edge);
}
}
}
revg.clear();
Weight cycle_len = 0;
vector<Edge> cycle_edges(getcycle::get_cycle(tree, start));
for (auto e : cycle_edges) {
cycle_len += e.weight;
}
if (cycle_edges.empty()) {
return make_pair(total_len, g);
} else {
vector<bool> node_is_cycle(g.size());
/*????´???°???Edge?????°????????§??????*/
vector<int> edge_is_cycle(g.size() * g.size());
vector<pair<int, Weight>> prevs(g.size(), make_pair(-1, ZERO));
for (auto ce : cycle_edges) {
node_is_cycle[ce.src] = true;
node_is_cycle[ce.dst] = true;
prevs[ce.dst] = make_pair(ce.src, ce.weight);
}
Graph newg(g.size());
const int compress = cycle_edges[0].src;
int ne_size = 0;
for (int s = 0; s < g.size(); ++s) {
bool src_is_cycle = node_is_cycle[s];
for (auto e : g[s]) {
bool dst_is_cycle = node_is_cycle[e.dst];
if (src_is_cycle && dst_is_cycle) {
} else if (src_is_cycle) {
newg[compress].push_back(Edge(compress, e.dst, e.weight, e.id));
ne_size++;
} else if (dst_is_cycle) {
newg[s].push_back(
Edge(s, compress, e.weight - prevs[e.dst].second, e.id));
ne_size++;
} else {
newg[s].push_back(Edge(s, e.dst, e.weight, e.id));
ne_size++;
}
}
}
auto p = chu_liu(newg, start, e_size);
Graph compress_tree(g.size());
Graph ans_tree(g.size());
for (auto es : compress_tree) {
for (auto e : es) {
Edge prev_edge(memo[e.id]);
ans_tree[prev_edge.src].emplace_back(prev_edge);
}
}
ld fin_len = p.first + cycle_len;
return make_pair(fin_len, ans_tree);
}
}
int main() {
int N, M;
cin >> N >> M;
vector<vector<ld>> vecs(M, vector<ld>(N));
vector<vector<ld>> edges(M, vector<ld>(M));
for (int i = 0; i < M; ++i) {
for (int j = 0; j < N; ++j) {
cin >> vecs[i][j];
}
}
const int start = 0;
const int node = 1;
Graph g(M + 1);
int id = 0;
for (int i = 0; i < M; ++i) {
ld inidis = 0;
for (int j = 0; j < N; ++j) {
inidis += vecs[i][j] * vecs[i][j];
}
g[start].emplace_back(start, node + i, inidis, id++);
for (int j = 0; j < M; ++j) {
if (i != j) {
ld dis = getdis(vecs[i], vecs[j]);
g[node + i].emplace_back(node + i, node + j, dis, id++);
}
}
}
auto p = chu_liu(g, start, (g.size()) * ((g.size() + 1)));
cout << fixed << setprecision(22) << p.first << endl;
return 0;
} | insert | 323 | 323 | 323 | 324 | MLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.