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
|
|---|---|---|---|---|---|---|---|---|---|---|---|
p01171 | C++ | Time Limit Exceeded | #include <cstdio>
using namespace std;
#define MAXNUM 1000001
bool prime[MAXNUM];
void eratosthenes() {
prime[0] = prime[1] = false;
for (int i = 2; i < MAXNUM; i++) {
prime[i] = true;
}
for (int i = 2; i * i < MAXNUM; i++) {
if (prime[i]) {
for (int j = i * i; j < MAXNUM; j += i) {
prime[j] = false;
}
}
}
}
int getkey(int a) {
int t;
for (int i = a; i >= 2; i--) {
if (a % i != 0)
continue;
if (prime[i]) {
t = i;
break;
}
}
int ret = t;
for (int i = t - 1; i >= 2; i--) {
if (a % i != 0)
continue;
if (prime[i])
ret -= i;
}
return ret;
}
int main() {
eratosthenes();
int a, b;
while (scanf("%d%d", &a, &b)) {
if (getkey(a) > getkey(b))
puts("a");
else
puts("b");
}
} | #include <cstdio>
using namespace std;
#define MAXNUM 1000001
bool prime[MAXNUM];
void eratosthenes() {
prime[0] = prime[1] = false;
for (int i = 2; i < MAXNUM; i++) {
prime[i] = true;
}
for (int i = 2; i * i < MAXNUM; i++) {
if (prime[i]) {
for (int j = i * i; j < MAXNUM; j += i) {
prime[j] = false;
}
}
}
}
int getkey(int a) {
int t;
for (int i = a; i >= 2; i--) {
if (a % i != 0)
continue;
if (prime[i]) {
t = i;
break;
}
}
int ret = t;
for (int i = t - 1; i >= 2; i--) {
if (a % i != 0)
continue;
if (prime[i])
ret -= i;
}
return ret;
}
int main() {
eratosthenes();
int a, b;
while (scanf("%d%d", &a, &b), (a || b)) {
if (getkey(a) > getkey(b))
puts("a");
else
puts("b");
}
} | replace | 46 | 47 | 46 | 47 | TLE | |
p01171 | C++ | Runtime Error | #include <bitset>
#include <stdio.h>
#include <vector>
const int N = 100000;
int main() {
std::bitset<N> p;
std::vector<int> v, A, B;
int i, j, a, b;
for (i = 2; i < N; ++i)
if (!p[i])
for (v.push_back(i), j = i * 2; j < N; j += i)
p[j] = 1;
while (scanf("%d%d", &a, &b), a) {
A.clear(), B.clear();
for (i = 0; i < v.size(); ++i) {
if (a % v[i] == 0)
A.push_back(v[i]);
if (b % v[i] == 0)
B.push_back(v[i]);
}
for (a = A.back(), i = 0; i < A.size() - 1; ++i)
a -= A[i];
for (b = B.back(), i = 0; i < B.size() - 1; ++i)
b -= B[i];
puts(a > b ? "a" : "b");
}
return 0;
} | #include <bitset>
#include <stdio.h>
#include <vector>
const int N = 1000000;
int main() {
std::bitset<N> p;
std::vector<int> v, A, B;
int i, j, a, b;
for (i = 2; i < N; ++i)
if (!p[i])
for (v.push_back(i), j = i * 2; j < N; j += i)
p[j] = 1;
while (scanf("%d%d", &a, &b), a) {
A.clear(), B.clear();
for (i = 0; i < v.size(); ++i) {
if (a % v[i] == 0)
A.push_back(v[i]);
if (b % v[i] == 0)
B.push_back(v[i]);
}
for (a = A.back(), i = 0; i < A.size() - 1; ++i)
a -= A[i];
for (b = B.back(), i = 0; i < B.size() - 1; ++i)
b -= B[i];
puts(a > b ? "a" : "b");
}
return 0;
} | replace | 3 | 4 | 3 | 4 | 0 | |
p01171 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define MP make_pair
typedef long long LL;
typedef pair<int, int> PII;
const int NUM = 200000;
int prime[NUM];
vector<int> primelist;
int gen() {
for (int i = 0; i < NUM; i++) {
prime[i] = 1;
}
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= NUM; i++) {
for (int j = 2 * i; j < NUM; j += i) {
prime[j] = 0;
}
}
for (int i = 0; i < NUM; i++) {
if (prime[i] == 1)
primelist.push_back(i);
}
}
int main() {
gen();
while (true) {
int a, b;
int keya = 0, keyb = 0;
scanf("%d %d", &a, &b);
if (a == 0)
break;
int k;
for (int i = 0; primelist[i] <= a; i++) {
if (a % primelist[i] == 0) {
keya -= primelist[i];
k = primelist[i];
}
}
keya += 2 * k;
for (int i = 0; primelist[i] <= b; i++) {
if (b % primelist[i] == 0) {
keyb -= primelist[i];
k = primelist[i];
}
}
keyb += 2 * k;
if (keya < keyb)
printf("b\n");
else
printf("a\n");
}
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define REP(i, n) FOR(i, 0, n)
#define MP make_pair
typedef long long LL;
typedef pair<int, int> PII;
const int NUM = 2000000;
int prime[NUM];
vector<int> primelist;
int gen() {
for (int i = 0; i < NUM; i++) {
prime[i] = 1;
}
prime[0] = 0;
prime[1] = 0;
for (int i = 2; i * i <= NUM; i++) {
for (int j = 2 * i; j < NUM; j += i) {
prime[j] = 0;
}
}
for (int i = 0; i < NUM; i++) {
if (prime[i] == 1)
primelist.push_back(i);
}
}
int main() {
gen();
while (true) {
int a, b;
int keya = 0, keyb = 0;
scanf("%d %d", &a, &b);
if (a == 0)
break;
int k;
for (int i = 0; primelist[i] <= a; i++) {
if (a % primelist[i] == 0) {
keya -= primelist[i];
k = primelist[i];
}
}
keya += 2 * k;
for (int i = 0; primelist[i] <= b; i++) {
if (b % primelist[i] == 0) {
keyb -= primelist[i];
k = primelist[i];
}
}
keyb += 2 * k;
if (keya < keyb)
printf("b\n");
else
printf("a\n");
}
} | replace | 23 | 24 | 23 | 24 | 0 | |
p01171 | C++ | Runtime Error | //============================================================================
// Name : A.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool is_prime(int a) {
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0)
return false;
}
return true;
}
vector<int> ps;
int f(int a) {
vector<ll> v;
for (int p : ps) {
if (a % p == 0)
v.push_back(p);
}
if (v.size() == 0)
return 0;
ll ret = v.back();
for (int i = 0; i < (int)v.size() - 1; i++) {
ret -= v[i];
}
return ret;
}
int main() {
for (int i = 0; i <= 200000; i++) {
if (is_prime(i))
ps.push_back(i);
}
int n, m;
while (cin >> n >> m, n + m) {
if (f(n) > f(m)) {
cout << "a" << endl;
} else {
cout << "b" << endl;
}
}
} | //============================================================================
// Name : A.cpp
// Author :
// Version :
// Copyright : Your copyright notice
// Description : Hello World in C++, Ansi-style
//============================================================================
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
bool is_prime(int a) {
for (int i = 2; i * i <= a; ++i) {
if (a % i == 0)
return false;
}
return true;
}
vector<int> ps;
int f(int a) {
vector<ll> v;
for (int p : ps) {
if (a % p == 0)
v.push_back(p);
}
if (v.size() == 0)
return 0;
ll ret = v.back();
for (int i = 0; i < (int)v.size() - 1; i++) {
ret -= v[i];
}
return ret;
}
int main() {
for (int i = 2; i <= 2000000; i++) {
if (is_prime(i))
ps.push_back(i);
}
int n, m;
while (cin >> n >> m, n + m) {
if (f(n) > f(m)) {
cout << "a" << endl;
} else {
cout << "b" << endl;
}
}
} | replace | 38 | 39 | 38 | 39 | -8 | |
p01171 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define CLR(a) memset((a), 0, sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
bool b[1000001] = {false};
int main() {
vector<int> prime;
FOR(i, 2, 10001) {
if (!b[i]) {
for (int j = i + i; j < 1001; j += i) {
b[j] = true;
}
prime.push_back(i);
}
}
int n, m;
while (cin >> n >> m, n) {
int count = 0;
vector<int> np;
while (n != 1) {
if (n % prime[count] == 0) {
if (np.size() == 0 || prime[count] != np[np.size() - 1])
np.push_back(prime[count]);
n /= prime[count];
} else {
count++;
}
}
vector<int> mp;
count = 0;
while (m != 1) {
if (m % prime[count] == 0) {
if (mp.size() == 0 || prime[count] != mp[mp.size() - 1])
mp.push_back(prime[count]);
m /= prime[count];
} else {
count++;
}
}
int ansn = np[np.size() - 1];
int ansm = mp[mp.size() - 1];
REP(i, np.size() - 1) { ansn -= np[i]; }
REP(i, mp.size() - 1) { ansm -= mp[i]; }
string anss = (ansn > ansm) ? "a" : "b";
cout << anss << endl;
}
} | #include <algorithm>
#include <cassert>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define CLR(a) memset((a), 0, sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
bool b[1000001] = {false};
int main() {
vector<int> prime;
FOR(i, 2, 1000001) {
if (!b[i]) {
for (int j = i + i; j < 1001; j += i) {
b[j] = true;
}
prime.push_back(i);
}
}
int n, m;
while (cin >> n >> m, n) {
int count = 0;
vector<int> np;
while (n != 1) {
if (n % prime[count] == 0) {
if (np.size() == 0 || prime[count] != np[np.size() - 1])
np.push_back(prime[count]);
n /= prime[count];
} else {
count++;
}
}
vector<int> mp;
count = 0;
while (m != 1) {
if (m % prime[count] == 0) {
if (mp.size() == 0 || prime[count] != mp[mp.size() - 1])
mp.push_back(prime[count]);
m /= prime[count];
} else {
count++;
}
}
int ansn = np[np.size() - 1];
int ansm = mp[mp.size() - 1];
REP(i, np.size() - 1) { ansn -= np[i]; }
REP(i, mp.size() - 1) { ansm -= mp[i]; }
string anss = (ansn > ansm) ? "a" : "b";
cout << anss << endl;
}
} | replace | 48 | 49 | 48 | 49 | 0 | |
p01171 | C++ | Runtime Error | #include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
using namespace std;
typedef vector<int> vi;
const int lim = 1000001;
vi prime_fact(int x, const vi &table) {
vi res;
while (x > 1) {
res.push_back(table[x]);
x /= table[x];
}
sort(all(res));
res.erase(unique(all(res)), res.end());
return res;
}
int main() {
vi table(lim, 1);
for (int i = 2; i * i <= lim; i++) {
if (table[i] == 1) {
for (int j = i; j <= lim; j += i)
table[j] = i;
}
}
int a, b;
while (cin >> a >> b, a) {
vi va = prime_fact(a, table), vb = prime_fact(b, table);
a = 2 * va.back() - accumulate(all(va), 0);
b = 2 * vb.back() - accumulate(all(vb), 0);
cout << (a > b ? "a" : "b") << endl;
}
} | #include <bits/stdc++.h>
#define all(a) (a).begin(), (a).end()
using namespace std;
typedef vector<int> vi;
const int lim = 1000001;
vi prime_fact(int x, const vi &table) {
vi res;
while (x > 1) {
res.push_back(table[x]);
x /= table[x];
}
sort(all(res));
res.erase(unique(all(res)), res.end());
return res;
}
int main() {
vi table(lim, 1);
for (int i = 2; i <= lim; i++) {
if (table[i] == 1) {
for (int j = i; j <= lim; j += i)
table[j] = i;
}
}
int a, b;
while (cin >> a >> b, a) {
vi va = prime_fact(a, table), vb = prime_fact(b, table);
a = 2 * va.back() - accumulate(all(va), 0);
b = 2 * vb.back() - accumulate(all(vb), 0);
cout << (a > b ? "a" : "b") << endl;
}
} | replace | 19 | 20 | 19 | 20 | 0 | |
p01172 | C++ | Runtime Error | #include <iostream>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
for (int r; (r = a % b) != 0;) {
a = b;
b = r;
}
return b;
}
int main() {
int x, y;
while (cin >> x >> y) {
const int g = gcd(x, y);
x /= g;
y /= g;
vector<int> seen(y, -1);
seen[x] = 0;
for (int c = 1;; c++) {
x = (10 * x) % y;
if (x == 0) {
cout << c << " 0" << endl;
break;
} else if (seen[x] != -1) {
cout << seen[x] << ' ' << c - seen[x] << endl;
break;
}
seen[x] = c;
}
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
int gcd(int a, int b) {
if (a < b) {
swap(a, b);
}
for (int r; (r = a % b) != 0;) {
a = b;
b = r;
}
return b;
}
int main() {
int x, y;
while (cin >> x >> y && x != 0) {
const int g = gcd(x, y);
x /= g;
y /= g;
vector<int> seen(y, -1);
seen[x] = 0;
for (int c = 1;; c++) {
x = (10 * x) % y;
if (x == 0) {
cout << c << " 0" << endl;
break;
} else if (seen[x] != -1) {
cout << seen[x] << ' ' << c - seen[x] << endl;
break;
}
seen[x] = c;
}
}
return 0;
} | replace | 17 | 18 | 17 | 18 | -8 | |
p01172 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (cin >> a >> b, a) {
int s[1000000011] = {}, c = 0, g = __gcd(a, b);
a /= g, b /= g;
while (!s[a]) {
s[a] = (++c);
a = (a * 10) % b;
if (a < 0)
return 0;
}
if (a)
c++;
cout << s[a] - 1 << ' ' << c - s[a] << endl;
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int a, b;
while (cin >> a >> b, a) {
int s[1000000] = {};
int c = 0, g = __gcd(a, b);
a /= g, b /= g;
while (!s[a]) {
s[a] = (++c);
a = (a * 10) % b;
if (a < 0)
return 0;
}
if (a)
c++;
cout << s[a] - 1 << ' ' << c - s[a] << endl;
}
} | replace | 5 | 6 | 5 | 7 | -11 | |
p01172 | C++ | Runtime Error | #include <bits/stdc++.h>
#define N 1000005
using namespace std;
int m[N];
int a, b, cnt, ans1, ans2;
int main() {
while (1) {
cin >> a >> b;
if (!a && !b)
break;
memset(m, -1, sizeof(m));
a %= b;
cnt = 0;
while (1) {
a *= 10;
if (m[a] != -1) {
ans1 = m[a], ans2 = cnt - m[a];
break;
}
m[a] = cnt;
a %= b;
if (!a) {
ans1 = cnt + 1, ans2 = 0;
break;
}
cnt++;
}
cout << ans1 << ' ' << ans2 << endl;
}
return 0;
} | #include <bits/stdc++.h>
#define N 10000005
using namespace std;
int m[N];
int a, b, cnt, ans1, ans2;
int main() {
while (1) {
cin >> a >> b;
if (!a && !b)
break;
memset(m, -1, sizeof(m));
a %= b;
cnt = 0;
while (1) {
a *= 10;
if (m[a] != -1) {
ans1 = m[a], ans2 = cnt - m[a];
break;
}
m[a] = cnt;
a %= b;
if (!a) {
ans1 = cnt + 1, ans2 = 0;
break;
}
cnt++;
}
cout << ans1 << ' ' << ans2 << endl;
}
return 0;
} | replace | 1 | 2 | 1 | 2 | 0 | |
p01172 | C++ | Runtime Error | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = double;
const ld eps = 1e-9;
int adiv(int a) {
map<int, int> mp;
int num(a);
for (int i = 2; i <= a; ++i) {
while (num % i == 0) {
mp[i]++;
num /= i;
}
}
int anum = 0;
for (auto m : mp) {
anum -= m.first;
}
anum += 2 * prev(mp.end())->first;
return anum;
}
int main() {
while (true) {
int x, y;
cin >> x >> y;
if (!x)
break;
map<int, int> mp;
vector<int> v(1e6 + 1, -1);
int ans1 = 0, ans2 = 0;
while (true) {
x *= 10;
int a = x / y;
int b = x % y;
if (b == 0) {
ans1++;
break;
} else {
if (v[x / 10] == -1) {
v[x / 10] = ans1;
ans1++;
x = b;
} else {
ans2 = ans1 - v[x];
ans1 = v[x];
break;
}
}
}
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
| #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = double;
const ld eps = 1e-9;
int adiv(int a) {
map<int, int> mp;
int num(a);
for (int i = 2; i <= a; ++i) {
while (num % i == 0) {
mp[i]++;
num /= i;
}
}
int anum = 0;
for (auto m : mp) {
anum -= m.first;
}
anum += 2 * prev(mp.end())->first;
return anum;
}
int main() {
while (true) {
int x, y;
cin >> x >> y;
if (!x)
break;
map<int, int> mp;
vector<int> v(1e6 + 1, -1);
int ans1 = 0, ans2 = 0;
while (true) {
x *= 10;
int a = x / y;
int b = x % y;
if (b == 0) {
ans1++;
break;
} else {
if (v[x / 10] == -1) {
v[x / 10] = ans1;
ans1++;
x = b;
} else {
ans2 = ans1 - v[x / 10];
ans1 = v[x / 10];
break;
}
}
}
cout << ans1 << " " << ans2 << endl;
}
return 0;
}
| replace | 49 | 51 | 49 | 51 | 0 | |
p01172 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
while (cin >> x >> y && (x || y)) {
map<int, int> mp;
int cnt = 0;
while (!mp.count(x % y)) {
if (x % y == 0)
break;
mp[x % y] = cnt++;
x %= y;
x *= 10;
}
if (x % y == 0) {
cout << cnt << " " << 0 << endl;
} else {
cout << mp[x % y] << " " << cnt - mp[x % y] << endl;
}
}
} | #include <bits/stdc++.h>
using namespace std;
int main() {
int x, y;
while (cin >> x >> y && (x || y)) {
unordered_map<int, int> mp;
int cnt = 0;
while (!mp.count(x % y)) {
if (x % y == 0)
break;
mp[x % y] = cnt++;
x %= y;
x *= 10;
}
if (x % y == 0) {
cout << cnt << " " << 0 << endl;
} else {
cout << mp[x % y] << " " << cnt - mp[x % y] << endl;
}
}
} | replace | 6 | 7 | 6 | 7 | TLE | |
p01183 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int N;
int a[20];
double opt;
int getNum[20];
int sel[20];
const double EPS = (1e-10);
bool EQ(double a, double b) { return abs(a - b) < EPS; }
bool check(int *tmparry) {
sort(tmparry, tmparry + 3);
return (tmparry[2] < tmparry[0] + tmparry[1]);
}
void dfs(int pos, int cur) {
if (pos == 6) {
for (int i = 0; i < 6; i++)
sel[i] = getNum[i];
sort(sel, sel + 6);
// 6!通りの組み合わせをすべて試す
do {
int tmparry[3];
for (int i = 0; i < 3; i++)
tmparry[i] = a[sel[i]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[0]];
tmparry[1] = a[sel[4]];
tmparry[2] = a[sel[3]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[2]];
tmparry[1] = a[sel[5]];
tmparry[2] = a[sel[3]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[1]];
tmparry[1] = a[sel[5]];
tmparry[2] = a[sel[4]];
if (!check(tmparry))
continue;
double theta =
a[sel[1]] * a[sel[1]] + a[sel[4]] * a[sel[4]] - a[sel[5]] * a[sel[5]];
theta /= (2.0 * a[sel[1]] * a[sel[4]]);
theta = acos(theta);
double x0 = a[sel[4]] * cos(theta);
double y0 = a[sel[4]] * sin(theta);
double a0 = a[sel[1]];
double l1 = a[sel[2]];
double l2 = a[sel[0]];
double l3 = a[sel[3]];
double x1 = (a0 * a0 + l2 * l2 - l1 * l1) / (2.0 * a0);
double y1 =
((-2 * x0 * x1) + x0 * x0 + y0 * y0 + l2 * l2 - l3 * l3) / (2.0 * y0);
double h = sqrt(l2 * l2 - (x1 * x1 + y1 * y1));
double s = (a[sel[1]] + a[sel[4]] + a[sel[5]]) / 2.0;
double S = sqrt(s * (s - a[sel[1]]) * (s - a[sel[4]]) * (s - a[sel[5]]));
double V = (S * h) / 3.0;
if (!EQ(opt, V) && opt < V)
opt = V;
// opt=max(opt,V);
} while (next_permutation(sel, sel + 6));
} else {
// cur以降から選ぶ
for (int i = cur; i < N; i++) {
getNum[pos] = i;
dfs(pos + 1, i + 1);
}
}
}
int main() {
while (cin >> N && N) {
memset(getNum, 0, sizeof(getNum));
opt = -1;
for (int i = 0; i < N; i++)
cin >> a[i];
dfs(0, 0);
printf("%.10f\n", opt);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int N;
int a[20];
double opt;
int getNum[20];
int sel[20];
const double EPS = (1e-10);
bool EQ(double a, double b) { return abs(a - b) < EPS; }
bool check(int *tmparry) {
sort(tmparry, tmparry + 3);
return (tmparry[2] < tmparry[0] + tmparry[1]);
}
void dfs(int pos, int cur) {
if (pos == 6) {
for (int i = 0; i < 6; i++)
sel[i] = getNum[i];
sort(sel, sel + 6);
const int size = 3;
const int plc[] = {1, 4, 5};
const int plc2[] = {0, 2, 3};
int comb = (1 << size) - 1;
while (comb < (1 << 6)) {
int x = comb & -comb, y = comb + x;
comb = ((comb & ~y) / x >> 1) | y;
int cnt = 0;
for (int i = 0; i < 6; i++) {
if ((comb >> i) & 1) {
sel[plc[cnt++]] = getNum[i];
}
}
cnt = 0;
int tmp[3];
for (int i = 0; i < 6; i++)
if (!((comb >> i) & 1))
tmp[cnt++] = getNum[i];
sort(tmp, tmp + 3);
// 6!通りの組み合わせをすべて試す
do {
for (int i = 0; i < 3; i++)
sel[plc2[i]] = tmp[i];
int tmparry[3];
for (int i = 0; i < 3; i++)
tmparry[i] = a[sel[i]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[0]];
tmparry[1] = a[sel[4]];
tmparry[2] = a[sel[3]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[2]];
tmparry[1] = a[sel[5]];
tmparry[2] = a[sel[3]];
if (!check(tmparry))
continue;
tmparry[0] = a[sel[1]];
tmparry[1] = a[sel[5]];
tmparry[2] = a[sel[4]];
if (!check(tmparry))
continue;
double theta = a[sel[1]] * a[sel[1]] + a[sel[4]] * a[sel[4]] -
a[sel[5]] * a[sel[5]];
theta /= (2.0 * a[sel[1]] * a[sel[4]]);
theta = acos(theta);
double x0 = a[sel[4]] * cos(theta);
double y0 = a[sel[4]] * sin(theta);
double a0 = a[sel[1]];
double l1 = a[sel[2]];
double l2 = a[sel[0]];
double l3 = a[sel[3]];
double x1 = (a0 * a0 + l2 * l2 - l1 * l1) / (2.0 * a0);
double y1 = ((-2 * x0 * x1) + x0 * x0 + y0 * y0 + l2 * l2 - l3 * l3) /
(2.0 * y0);
double h = sqrt(l2 * l2 - (x1 * x1 + y1 * y1));
double s = (a[sel[1]] + a[sel[4]] + a[sel[5]]) / 2.0;
double S =
sqrt(s * (s - a[sel[1]]) * (s - a[sel[4]]) * (s - a[sel[5]]));
double V = (S * h) / 3.0;
if (!EQ(opt, V) && opt < V)
opt = V;
} while (next_permutation(tmp, tmp + 3));
}
} else {
// cur以降から選ぶ
for (int i = cur; i < N; i++) {
getNum[pos] = i;
dfs(pos + 1, i + 1);
}
}
}
int main() {
while (cin >> N && N) {
memset(getNum, 0, sizeof(getNum));
opt = -1;
for (int i = 0; i < N; i++)
cin >> a[i];
dfs(0, 0);
printf("%.10f\n", opt);
}
return 0;
} | replace | 27 | 70 | 27 | 92 | TLE | |
p01183 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <cstdio>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
// 三角形が作れるかどうか
bool tri(int a, int b, int c) {
int p[] = {a, b, c};
sort(p, p + 3);
return p[0] + p[1] > p[2];
}
double volume(double U, double V, double W, double u, double v, double w) {
double X = (w - U + v) * (U + v + w);
double x = (U - v + w) * (v - w + U);
double Y = (u - V + w) * (V + w + u);
double y = (V - w + u) * (w - u + V);
double Z = (v - W + u) * (W + u + v);
double z = (W - u + v) * (u - v + W);
double a = sqrt(x * Y * Z);
double b = sqrt(y * Z * X);
double c = sqrt(z * X * Y);
double d = sqrt(x * y * z);
return sqrt((-a + b + c + d) * (a - b + c + d) * (a + b - c + d) *
(a + b + c - d)) /
(192 * u * v * w);
}
int main() {
for (int n; scanf("%d", &n), n;) {
int L[15];
rep(i, n) scanf("%d", L + i);
double ans = 0;
rep(a, n) rep(b, n) if (a != b) rep(c, n) if (a != c && b != c)
rep(d, n) if (a != d && b != d && c != d)
rep(e, n) if (a != e && b != e && c != e && d != e)
rep(f, n) if (a != f && b != f && c != f && d != f && e != f) {
if (tri(L[a], L[b], L[c]) && tri(L[a], L[e], L[f]) &&
tri(L[b], L[f], L[d]) && tri(L[c], L[d], L[e]))
ans = max(ans, volume(L[a], L[b], L[c], L[d], L[e], L[f]));
}
printf("%.9f\n", ans);
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
// 三角形が作れるかどうか
bool tri(int a, int b, int c) {
int p[] = {a, b, c};
sort(p, p + 3);
return p[0] + p[1] > p[2];
}
double volume(double U, double V, double W, double u, double v, double w) {
double X = (w - U + v) * (U + v + w);
double x = (U - v + w) * (v - w + U);
double Y = (u - V + w) * (V + w + u);
double y = (V - w + u) * (w - u + V);
double Z = (v - W + u) * (W + u + v);
double z = (W - u + v) * (u - v + W);
double a = sqrt(x * Y * Z);
double b = sqrt(y * Z * X);
double c = sqrt(z * X * Y);
double d = sqrt(x * y * z);
return sqrt((-a + b + c + d) * (a - b + c + d) * (a + b - c + d) *
(a + b + c - d)) /
(192 * u * v * w);
}
int main() {
for (int n; scanf("%d", &n), n;) {
int L[15];
rep(i, n) scanf("%d", L + i);
double ans = 0;
int p[15] = {1, 1, 1, 1, 1, 1};
do {
int m = 0, q[6];
rep(i, n) if (p[i] == 1) q[m++] = i;
do {
int a = L[q[0]];
int b = L[q[1]];
int c = L[q[2]];
int d = L[q[3]];
int e = L[q[4]];
int f = L[q[5]];
if (tri(a, b, c) && tri(a, e, f) && tri(b, f, d) && tri(c, d, e))
ans = max(ans, volume(a, b, c, d, e, f));
} while (next_permutation(q, q + 5)); // 一つの辺は固定していい
} while (prev_permutation(p, p + n));
printf("%.9f\n", ans);
}
return 0;
} | replace | 37 | 45 | 37 | 53 | TLE | |
p01186 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
class Data {
public:
int t1, t2, r1, r2;
bool operator<(const Data &d) const { return t1 < d.t1; }
};
int n;
vector<Data> d;
vector<int> nextTV;
vector<vector<int>> memo;
int solve(int a, int b) {
if (a == n + 1 || b == n + 1)
return 0;
if (a == n && b == n)
return 0;
if (memo[a][b] != -1)
return memo[a][b];
int ret = 0;
ret = max(ret, solve(a, b + 1));
ret = max(ret, solve(a + 1, b));
if (a == b) {
ret = max(ret, d[a].r1 + solve(nextTV[a], b + 1));
ret = max(ret, d[b].r2 + solve(a + 1, nextTV[b]));
} else if (a > b) {
ret = max(ret, d[b].r2 + solve(a, nextTV[b]));
} else {
ret = max(ret, d[a].r1 + solve(nextTV[a], b));
}
}
int main() {
for (;;) {
cin >> n;
if (n == 0)
return 0;
d.resize(n + 1);
for (int i = 0; i < n; ++i) {
string s;
int h1, m1, h2, m2;
char c;
cin >> s >> h1 >> c >> m1 >> h2 >> c >> m2 >> d[i].r1 >> d[i].r2;
d[i].t1 = h1 * 60 + m1;
d[i].t2 = h2 * 60 + m2;
}
d[n].t1 = INT_MAX / 2;
d[n].t2 = INT_MAX / 2 + 1;
d[n].r1 = d[n].r2 = 0;
sort(d.begin(), d.end());
nextTV.resize(n + 1);
for (int i = 0; i <= n; ++i) {
Data tmp;
tmp.t1 = d[i].t2;
nextTV[i] = lower_bound(d.begin(), d.end(), tmp) - d.begin();
}
memo.assign(n + 1, vector<int>(n + 1, -1));
cout << solve(0, 0) << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
class Data {
public:
int t1, t2, r1, r2;
bool operator<(const Data &d) const { return t1 < d.t1; }
};
int n;
vector<Data> d;
vector<int> nextTV;
vector<vector<int>> memo;
int solve(int a, int b) {
if (a == n + 1 || b == n + 1)
return 0;
if (a == n && b == n)
return 0;
if (memo[a][b] != -1)
return memo[a][b];
int ret = 0;
ret = max(ret, solve(a, b + 1));
ret = max(ret, solve(a + 1, b));
if (a == b) {
ret = max(ret, d[a].r1 + solve(nextTV[a], b + 1));
ret = max(ret, d[b].r2 + solve(a + 1, nextTV[b]));
} else if (a > b) {
ret = max(ret, d[b].r2 + solve(a, nextTV[b]));
} else {
ret = max(ret, d[a].r1 + solve(nextTV[a], b));
}
return memo[a][b] = ret;
}
int main() {
for (;;) {
cin >> n;
if (n == 0)
return 0;
d.resize(n + 1);
for (int i = 0; i < n; ++i) {
string s;
int h1, m1, h2, m2;
char c;
cin >> s >> h1 >> c >> m1 >> h2 >> c >> m2 >> d[i].r1 >> d[i].r2;
d[i].t1 = h1 * 60 + m1;
d[i].t2 = h2 * 60 + m2;
}
d[n].t1 = INT_MAX / 2;
d[n].t2 = INT_MAX / 2 + 1;
d[n].r1 = d[n].r2 = 0;
sort(d.begin(), d.end());
nextTV.resize(n + 1);
for (int i = 0; i <= n; ++i) {
Data tmp;
tmp.t1 = d[i].t2;
nextTV[i] = lower_bound(d.begin(), d.end(), tmp) - d.begin();
}
memo.assign(n + 1, vector<int>(n + 1, -1));
cout << solve(0, 0) << endl;
}
} | insert | 50 | 50 | 50 | 52 | TLE | |
p01187 | 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;
}
struct Dinic {
using Flow = int;
struct Edge {
int to, rev;
Flow cap;
Edge() {}
Edge(int to, int rev, Flow cap) : to(to), rev(rev), cap(cap) {}
};
int n;
vector<vector<Edge>> g;
vector<bool> used;
vector<int> level;
vector<int> iter;
Dinic(int n) : n(n), g(n), used(n), level(n), iter(n){};
void addArc(int from, int to, Flow cap) {
g[from].emplace_back(to, (int)g[to].size(), cap);
g[to].emplace_back(from, (int)g[from].size() - 1, 0);
}
void addEdge(int a, int b, Flow cap) {
g[a].emplace_back(b, (int)g[b].size(), cap);
g[b].emplace_back(a, (int)g[a].size() - 1, cap);
}
Flow maximumFlow(int s, int t) {
Flow total = 0;
while (true) {
levelize(s);
if (level[t] < 0)
return total;
fill(iter.begin(), iter.end(), 0);
Flow f;
while (true) {
f = augment(s, t, INF);
if (f == 0)
break;
total += f;
}
}
}
Flow augment(int v, int t, Flow f) {
if (v == t)
return f;
for (int &i = iter[v]; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
Flow d = augment(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
void levelize(int s) {
fill(level.begin(), level.end(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (q.size()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int N; cin >> N && N;) {
int M;
cin >> M;
Dinic dinic(M + N + 2);
int s = dinic.n - 2, t = s + 1;
unordered_map<int, int> mp;
rep(i, 0, M) {
int d;
cin >> d;
mp[d] = i;
}
rep(i, 0, N) {
int M;
cin >> M;
rep(j, 0, M) {
int d;
cin >> d;
if (mp.count(d))
dinic.addArc(mp[d], M + i, 1);
}
}
rep(i, 0, M) dinic.addArc(s, i, 1);
rep(i, 0, N) dinic.addArc(M + i, t, 1);
cout << dinic.maximumFlow(s, t) << 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;
}
struct Dinic {
using Flow = int;
struct Edge {
int to, rev;
Flow cap;
Edge() {}
Edge(int to, int rev, Flow cap) : to(to), rev(rev), cap(cap) {}
};
int n;
vector<vector<Edge>> g;
vector<bool> used;
vector<int> level;
vector<int> iter;
Dinic(int n) : n(n), g(n), used(n), level(n), iter(n){};
void addArc(int from, int to, Flow cap) {
g[from].emplace_back(to, (int)g[to].size(), cap);
g[to].emplace_back(from, (int)g[from].size() - 1, 0);
}
void addEdge(int a, int b, Flow cap) {
g[a].emplace_back(b, (int)g[b].size(), cap);
g[b].emplace_back(a, (int)g[a].size() - 1, cap);
}
Flow maximumFlow(int s, int t) {
Flow total = 0;
while (true) {
levelize(s);
if (level[t] < 0)
return total;
fill(iter.begin(), iter.end(), 0);
Flow f;
while (true) {
f = augment(s, t, INF);
if (f == 0)
break;
total += f;
}
}
}
Flow augment(int v, int t, Flow f) {
if (v == t)
return f;
for (int &i = iter[v]; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
Flow d = augment(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
void levelize(int s) {
fill(level.begin(), level.end(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (q.size()) {
int v = q.front();
q.pop();
for (int i = 0; i < g[v].size(); i++) {
Edge &e = g[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
};
signed main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int N; cin >> N && N;) {
int M;
cin >> M;
Dinic dinic(M + N + 2);
int s = dinic.n - 2, t = s + 1;
unordered_map<int, int> mp;
rep(i, 0, M) {
int d;
cin >> d;
mp[d] = i;
}
rep(i, 0, N) {
int m;
cin >> m;
rep(j, 0, m) {
int d;
cin >> d;
if (mp.count(d))
dinic.addArc(mp[d], M + i, 1);
}
}
rep(i, 0, M) dinic.addArc(s, i, 1);
rep(i, 0, N) dinic.addArc(M + i, t, 1);
cout << dinic.maximumFlow(s, t) << endl;
}
return 0;
} | replace | 118 | 121 | 118 | 121 | 0 | |
p01187 | C++ | Runtime Error | #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
struct Dinic {
const int INF = 1 << 28;
struct edge {
int to, cap, rev;
edge() {}
edge(int to, int cap, int rev) : to(to), cap(cap), rev(rev) {}
};
int n;
vector<vector<edge>> G;
vector<map<int, int>> M;
vector<int> level, iter;
Dinic() {}
Dinic(int sz) : n(sz), G(n), M(n), level(n), iter(n) {}
void add_edge(int from, int to, int cap) {
M[from][to] = G[from].size();
M[to][from] = G[to].size();
G[from].push_back(edge(to, cap, G[to].size()));
// undirected
// G[to].push_back(edge(from,cap,G[from].size()-1));
// directed
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int flow(int s, int t, int lim) {
int fl = 0;
for (;;) {
bfs(s);
if (level[t] < 0 || lim == 0)
return fl;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, lim)) > 0) {
fl += f;
lim -= f;
}
}
}
int flow(int s, int t) { return flow(s, t, INF); }
// cap==1 only
bool back_edge(int s, int t, int from, int to) {
for (int i = 0; i < (int)G[from].size(); i++) {
edge &e = G[from][i];
if (e.to == to) {
if (e.cap == 0 && flow(from, to, 1) == 0) {
flow(from, s, 1);
flow(t, to, 1);
return 1;
}
}
}
return 0;
}
};
int main() {
int n, m, x, N;
while (cin >> n, n) {
map<int, int> M;
cin >> N;
r(i, N) {
cin >> x;
M[x] = i;
}
Dinic d(N + n + 2);
r(i, N) d.add_edge(N + n, i, 1);
r(i, n) d.add_edge(N + i, N + n + 1, 1);
r(i, n) {
cin >> m;
r(j, m) {
cin >> x;
if (M.count(x))
d.add_edge(M[x], n + i, 1);
}
}
cout << d.flow(N + n, N + n + 1, 1e8) << endl;
}
}
| #include <bits/stdc++.h>
#define r(i, n) for (int i = 0; i < n; i++)
using namespace std;
struct Dinic {
const int INF = 1 << 28;
struct edge {
int to, cap, rev;
edge() {}
edge(int to, int cap, int rev) : to(to), cap(cap), rev(rev) {}
};
int n;
vector<vector<edge>> G;
vector<map<int, int>> M;
vector<int> level, iter;
Dinic() {}
Dinic(int sz) : n(sz), G(n), M(n), level(n), iter(n) {}
void add_edge(int from, int to, int cap) {
M[from][to] = G[from].size();
M[to][from] = G[to].size();
G[from].push_back(edge(to, cap, G[to].size()));
// undirected
// G[to].push_back(edge(from,cap,G[from].size()-1));
// directed
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < (int)G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int flow(int s, int t, int lim) {
int fl = 0;
for (;;) {
bfs(s);
if (level[t] < 0 || lim == 0)
return fl;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, lim)) > 0) {
fl += f;
lim -= f;
}
}
}
int flow(int s, int t) { return flow(s, t, INF); }
// cap==1 only
bool back_edge(int s, int t, int from, int to) {
for (int i = 0; i < (int)G[from].size(); i++) {
edge &e = G[from][i];
if (e.to == to) {
if (e.cap == 0 && flow(from, to, 1) == 0) {
flow(from, s, 1);
flow(t, to, 1);
return 1;
}
}
}
return 0;
}
};
int main() {
int n, m, x, N;
while (cin >> n, n) {
map<int, int> M;
cin >> N;
r(i, N) {
cin >> x;
M[x] = i;
}
Dinic d(N + n + 2);
r(i, N) d.add_edge(N + n, i, 1);
r(i, n) d.add_edge(N + i, N + n + 1, 1);
r(i, n) {
cin >> m;
r(j, m) {
cin >> x;
if (M.count(x))
d.add_edge(M[x], N + i, 1);
}
}
cout << d.flow(N + n, N + n + 1, 1e8) << endl;
}
}
| replace | 114 | 115 | 114 | 115 | 0 | |
p01187 | 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 3000
// 辺を表す構造体(行先、容量、逆辺のインデックス)
struct Edge {
Edge(int arg_to, int arg_capacity, int arg_rev_index) {
to = arg_to;
capacity = arg_capacity;
rev_index = arg_rev_index;
}
int to, capacity, rev_index;
};
int V, E;
int N;
map<int, int> MAP;
vector<Edge> G[NUM]; // グラフの隣接リスト表現
int dist[NUM]; // sourceからの距離
int cheked_index[NUM]; // どこまで調べ終わったか
// fromからtoへ向かう容量capacityの辺をグラフに追加する
void add_edge(int from, int to, int capacity) {
G[from].push_back(Edge(to, capacity, G[to].size()));
G[to].push_back(Edge(from, 0, G[from].size() - 1)); // 逆辺の、初期容量は0
}
// sourceからの最短距離をBFSで計算する
void bfs(int source) {
for (int i = 0; i < V; i++)
dist[i] = -1;
queue<int> Q;
dist[source] = 0;
Q.push(source);
while (!Q.empty()) {
int node_id = Q.front();
Q.pop();
for (int i = 0; i < G[node_id].size(); i++) {
Edge &e = G[node_id][i];
if (e.capacity > 0 &&
dist[e.to] < 0) { // 辺の容量が正で、かつエッジの行先に未訪問の場合
dist[e.to] = dist[node_id] + 1;
Q.push(e.to);
}
}
}
}
// 増加パスをDFSで探す
int dfs(int node_id, int sink, int flow) {
if (node_id == sink)
return flow; // 終点についたらflowをreturn
for (int &i = cheked_index[node_id]; i < G[node_id].size();
i++) { // node_idから出ているエッジを調査
Edge &e = G[node_id][i];
if (e.capacity > 0 &&
dist[node_id] <
dist[e.to]) { // 流せる余裕があり、かつsourceからの距離が増加する方法である場合
int tmp_flow = dfs(e.to, sink, min(flow, e.capacity)); // 流せるだけ流す
if (tmp_flow > 0) { // 流せた場合
e.capacity -= tmp_flow; // 流した分、エッジの容量を削減する
G[e.to][e.rev_index].capacity +=
tmp_flow; // 逆辺の容量を、流した分だけ増加させる
return tmp_flow;
}
}
}
return 0;
}
// sourceからsinkへの最大流を求める
int max_flow(int source, int sink) { // source:始点 sink:終点
int flow = 0, add;
while (true) { // 増加パスが存在する限り、流量を追加し続ける
bfs(source);
if (dist[sink] < 0)
break; // sourceからsinkへと辿り着く残余グラフがない、つまり増加パスが無くなった場合、break
for (int i = 0; i < V; i++)
cheked_index[i] = 0;
while ((add = dfs(source, sink, BIG_NUM)) >
0) { // 増加パスが見つかる間、加算
flow += add;
}
}
return flow;
}
void func() {
MAP.clear();
for (int i = 0; i < NUM; i++)
G[i].clear();
int num, tmp, index = 2;
scanf("%d", &num);
int source = 0, sink = 1;
for (int loop = 0; loop < num; loop++) {
scanf("%d", &tmp);
MAP[tmp] = index;
add_edge(source, index, 1); // sourceからindexに、容量1の辺を張る
index++;
}
int integrate;
for (int loop = 0; loop < N; loop++) {
scanf("%d", &num);
add_edge(index, sink, 1); // 1人の人物につき、最大流量1の集約路を張る
integrate = index;
index++;
for (int i = 0; i < num; i++) {
scanf("%d", &tmp);
auto at = MAP.find(tmp);
if (at == MAP.end())
continue; // Isaccの都合の良い日でなければ無視
add_edge(MAP[tmp], index, 1); // Isaccの都合の良い日から、
add_edge(index, integrate, 1);
index++;
}
}
V = index;
printf("%d\n", max_flow(source, sink));
}
int main() {
while (true) {
scanf("%d", &N);
if (N == 0)
break;
func();
}
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 3000
// 辺を表す構造体(行先、容量、逆辺のインデックス)
struct Edge {
Edge(int arg_to, int arg_capacity, int arg_rev_index) {
to = arg_to;
capacity = arg_capacity;
rev_index = arg_rev_index;
}
int to, capacity, rev_index;
};
int V, E;
int N;
map<int, int> MAP;
vector<Edge> G[NUM]; // グラフの隣接リスト表現
int dist[NUM]; // sourceからの距離
int cheked_index[NUM]; // どこまで調べ終わったか
// fromからtoへ向かう容量capacityの辺をグラフに追加する
void add_edge(int from, int to, int capacity) {
G[from].push_back(Edge(to, capacity, G[to].size()));
G[to].push_back(Edge(from, 0, G[from].size() - 1)); // 逆辺の、初期容量は0
}
// sourceからの最短距離をBFSで計算する
void bfs(int source) {
for (int i = 0; i < V; i++)
dist[i] = -1;
queue<int> Q;
dist[source] = 0;
Q.push(source);
while (!Q.empty()) {
int node_id = Q.front();
Q.pop();
for (int i = 0; i < G[node_id].size(); i++) {
Edge &e = G[node_id][i];
if (e.capacity > 0 &&
dist[e.to] < 0) { // 辺の容量が正で、かつエッジの行先に未訪問の場合
dist[e.to] = dist[node_id] + 1;
Q.push(e.to);
}
}
}
}
// 増加パスをDFSで探す
int dfs(int node_id, int sink, int flow) {
if (node_id == sink)
return flow; // 終点についたらflowをreturn
for (int &i = cheked_index[node_id]; i < G[node_id].size();
i++) { // node_idから出ているエッジを調査
Edge &e = G[node_id][i];
if (e.capacity > 0 &&
dist[node_id] <
dist[e.to]) { // 流せる余裕があり、かつsourceからの距離が増加する方法である場合
int tmp_flow = dfs(e.to, sink, min(flow, e.capacity)); // 流せるだけ流す
if (tmp_flow > 0) { // 流せた場合
e.capacity -= tmp_flow; // 流した分、エッジの容量を削減する
G[e.to][e.rev_index].capacity +=
tmp_flow; // 逆辺の容量を、流した分だけ増加させる
return tmp_flow;
}
}
}
return 0;
}
// sourceからsinkへの最大流を求める
int max_flow(int source, int sink) { // source:始点 sink:終点
int flow = 0, add;
while (true) { // 増加パスが存在する限り、流量を追加し続ける
bfs(source);
if (dist[sink] < 0)
break; // sourceからsinkへと辿り着く残余グラフがない、つまり増加パスが無くなった場合、break
for (int i = 0; i < V; i++)
cheked_index[i] = 0;
while ((add = dfs(source, sink, BIG_NUM)) >
0) { // 増加パスが見つかる間、加算
flow += add;
}
}
return flow;
}
void func() {
MAP.clear();
for (int i = 0; i < NUM; i++)
G[i].clear();
int num, tmp, index = 2;
scanf("%d", &num);
int source = 0, sink = 1;
for (int loop = 0; loop < num; loop++) {
scanf("%d", &tmp);
MAP[tmp] = index;
add_edge(source, index, 1); // sourceからindexに、容量1の辺を張る
index++;
}
int integrate;
for (int loop = 0; loop < N; loop++) {
scanf("%d", &num);
add_edge(index, sink, 1); // 1人の人物につき、最大流量1の集約路を張る
integrate = index;
index++;
for (int i = 0; i < num; i++) {
scanf("%d", &tmp);
auto at = MAP.find(tmp);
if (at == MAP.end())
continue; // Isaccの都合の良い日でなければ無視
add_edge(MAP[tmp], integrate, 1); // Isaccの都合の良い日から、
}
}
V = index;
printf("%d\n", max_flow(source, sink));
}
int main() {
while (true) {
scanf("%d", &N);
if (N == 0)
break;
func();
}
return 0;
}
| replace | 137 | 140 | 137 | 138 | 0 | |
p01190 | C++ | Runtime Error | #include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// cin.sync_with_stdio(false);
// streambuf
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
template <class T, int s> using va = vector<array<T, s>>;
template <class T, class T2> using umap = unordered_map<T, T2>;
template <class T> using uset = unordered_set<T>;
template <class T, class S> void cmin(T &a, const S &&b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &&b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a) for (int i = 1; i <= a; i++)
#define rrep(i, a) for (int i = a - 1; i >= 0; i--)
#define rrep1(i, a) for (int i = a; i; i--)
const ll mod = 1000000007;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<signed>().max();
#endif
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using pque = priority_queue<T, vector<T>, function<T(T, T)>>;
template <class T> inline void hash_combine(size_t &seed, const T &v) {
hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename S, typename T> struct hash<pair<S, T>> {
inline size_t operator()(const pair<S, T> &v) const {
size_t seed = 0;
hash_combine(seed, v.first);
hash_combine(seed, v.second);
return seed;
}
};
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
} // namespace std
ll pow(ll base, ll i, ll mod) {
ll a = 1;
while (i) {
if (i & 1) {
a *= base;
a %= mod;
}
base *= base;
base %= mod;
i /= 2;
}
return a;
}
class unionfind {
vector<int> par, rank,
size_; //????????§??????????????¢???????????????????????????rank???????????????size?????????
public:
unionfind(int n) : par(n), rank(n), size_(n, 1) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
ll gcd(ll a, ll b) {
while (b) {
ll c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int popcnt(unsigned long long a) {
a = (a & 0x5555555555555555) + (a >> 1 & 0x5555555555555555);
a = (a & 0x3333333333333333) + (a >> 2 & 0x3333333333333333);
a = (a & 0x0f0f0f0f0f0f0f0f) + (a >> 4 & 0x0f0f0f0f0f0f0f0f);
a = (a & 0x00ff00ff00ff00ff) + (a >> 8 & 0x00ff00ff00ff00ff);
a = (a & 0x0000ffff0000ffff) + (a >> 16 & 0x0000ffff0000ffff);
return (a & 0xffffffff) + (a >> 32);
}
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater_ = Func())
: obj(bufsize(n), e), e(e), updater(updater_) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
template <class T> class matrix {
vector<vector<T>> obj;
pair<int, int> s;
public:
matrix(pair<int, int> size, T e = 0) : matrix(size.first, size.second, e) {}
matrix(int n, int m = -1, T e = 0)
: obj(n, vector<T>(m == -1 ? n : m, e)), s(n, m == -1 ? n : m) {}
static matrix e(int n) {
matrix a = (n);
for (int i = 0; i < n; i++)
a[i][i] = 1;
return a;
}
matrix &operator+=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] += p.obj[i][j];
return *this;
}
matrix operator+(const matrix &p) {
matrix res(*this);
return res += p;
}
matrix &operator-=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] -= p.obj[i][j];
return *this;
}
matrix operator-(const matrix &p) {
matrix res(*this);
return res -= p;
}
matrix &operator*=(T p) {
for (auto &a : obj)
for (auto &b : a)
b *= p;
return *this;
}
matrix operator*(T p) {
matrix res(*this);
return res *= p;
}
matrix operator*(const matrix &p) {
if (s.second != p.s.first)
throw runtime_error("matrix error");
matrix ret(s.first, p.s.second);
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
for (int k = 0; k < p.s.second; k++)
ret[i][k] += obj[i][j] * p.obj[j][k];
return ret;
}
matrix &operator*=(const matrix &p) { return *this = *this * p; }
pair<int, int> size() const { return s; }
matrix &mod(T m) {
for (auto &a : obj)
for (auto &b : a)
b %= m;
return *this;
}
typename vector<vector<T>>::reference operator[](int t) { return obj[t]; }
};
template <class T> inline matrix<T> pow(matrix<T> &base, unsigned exp) {
auto base_(base);
if (base_.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
res *= base_;
if (!(exp /= 2))
break;
base_ *= base_;
}
return res;
}
template <class T> inline matrix<T> modpow(matrix<T> &base, unsigned exp, T m) {
auto base_(base);
if (base.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
(res *= base_).mod(m);
if (!(exp /= 2))
break;
(base_ *= base_).mod(m);
}
return res;
}
template <class T> int id(vector<T> &a, T b) {
return lower_bound(ALL(a), b) - a.begin();
}
class Flow {
int V;
struct edge {
int to, cap, rev, cost;
};
vector<vector<edge>> G;
vector<int> level, iter, h, dist, prevv, preve;
Flow(int size) : G(size + 1), V(size + 1) {}
void add_edge(int from, int to, int cap, int cost = 0) {
G[from].push_back(edge{to, cap, (int)G[to].size(), cost});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1, -cost});
}
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
level.resize(V);
iter.resize(V);
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, numeric_limits<int>::max())) > 0) {
flow += f;
}
}
}
typedef pair<int, int> P;
int min_cost_flow(int s, int t, int f) {
int res = 0;
h.resize(V);
dist.resize(V);
prevv.resize(V);
preve.resize(V);
fill(h.begin(), h.end(), 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist.begin(), dist.end(), numeric_limits<int>::max());
dist[s] = 0;
que.push({0, s});
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push({dist[e.to], e.to});
}
}
}
if (dist[t] == numeric_limits<int>::max()) {
return -1;
}
for (int v = 0; v < V; v++)
h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
const ld eps = 1e-11, pi = acos(-1.0);
typedef complex<ld> P;
typedef vector<P> VP;
ld dot(P a, P b) { return real(conj(a) * b); }
ld cross(P a, P b) { return imag(conj(a) * b); }
namespace std {
bool operator<(const P &a, const P &b) {
return abs(a.real() - b.real()) < eps ? a.imag() < b.imag()
: a.real() < b.real();
}
} // namespace std
struct L {
P a, b;
}; // line->l,segment->s
struct C {
P p;
ld r;
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // counter clockwise
if (cross(b, c) < -eps)
return -1; // clockwise
if (dot(b, c) < 0)
return 2; // c--a--b on line
if (norm(b) < norm(c))
return -2; // a--b--c on line
return 0; // a--c--b on line
}
bool isis_ll(L l, L m) { // is intersect
return abs(cross(l.b - l.a, m.b - m.a)) > eps;
}
bool isis_ls(L l, L s) {
ld a = cross(l.b - l.a, s.a - l.a);
ld b = cross(l.b - l.a, s.b - l.a);
return (a * b < eps);
}
bool isis_lp(L l, P p) { return abs(cross(l.b - p, l.a - p)) < eps; }
bool isis_ss(L s, L t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
P is_ll(L s, L t) { // intersect
P sv = s.b - s.a, tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
bool isis_sp(L s, P p) {
return abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps;
}
P proj(L l, P p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
ld dist_lp(L l, P p) { return abs(p - proj(l, p)); }
ld dist_ll(L l, L m) { return isis_ll(l, m) ? 0 : dist_lp(l, m.a); }
ld dist_ls(L l, L s) {
if (isis_ls(l, s))
return 0;
return min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(L s, P p) {
P r = proj(s, p);
if (isis_sp(s, r))
return abs(r - p);
return min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(L s, L t) {
if (isis_ss(s, t))
return 0;
ld a = min(dist_sp(s, t.a), dist_sp(t, s.a));
ld b = min(dist_sp(s, t.b), dist_sp(t, s.b));
return min(a, b);
}
VP is_cc(C c1, C c2) {
VP res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
P diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * P(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * P(rc, -rs));
return res;
}
bool isis_vc(vector<C> vc) {
VP crs;
int n = vc.size();
rep(i, n) rep(j, i) for (P p : is_cc(vc[i], vc[j])) crs.push_back(p);
rep(i, n) crs.push_back(vc[i].p);
for (P p : crs) {
bool valid = true;
rep(i, n) if (abs(p - vc[i].p) > vc[i].r + eps) valid = false;
if (valid)
return true;
}
return false;
}
VP is_lc(C c, L l) {
VP res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
P nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
VP is_sc(C c, L l) {
VP v = is_lc(c, l), res;
for (P p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
vector<L> tangent_cp(C c, P p) { //????????\????
vector<L> ret;
P v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan(l)) {
return ret;
}
P v1 = v * P(l / d, c.r / d);
P v2 = v * P(l / d, -c.r / d);
ret.push_back(L{p, p + v1});
if (l < eps)
return ret;
ret.push_back(L{p, p + v2});
return ret;
}
vector<L> tangent_cc(C c1, C c2) {
vector<L> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
P center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
P out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<L> nret = tangent_cp(c1, out);
ret.insert(ret.end(), ALL(nret));
} else {
P v = c2.p - c1.p;
v /= abs(v);
P q1 = c1.p + v * P(0, 1) * c1.r;
P q2 = c1.p + v * P(0, -1) * c1.r;
ret.push_back(L{q1, q1 + v});
ret.push_back(L{q2, q2 + v});
}
return ret;
}
ld area(const VP &p) { //??¢?????
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
bool is_polygon(L l, VP &g) {
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i];
P b = g[(i + 1) % n];
if (isis_ss(l, L{a, b}))
return true;
}
return false;
}
int is_in_Polygon(const VP &g, P p) {
bool in = false;
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i] - p, b = g[(i + 1) % n] - p;
if (imag(a) > imag(b))
swap(a, b);
if (imag(a) <= 0 && 0 < imag(b))
if (cross(a, b) < 0)
in = !in;
if (abs(cross(a, b)) < eps && dot(a, b) < eps)
return 0; // on
}
if (in)
return 1; // in
return -1; // out
}
VP ConvexHull(VP ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
VP ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
VP ConvexCut(const VP &ps, L l) {
VP Q;
for (int i = 0; i < (int)ps.size(); i++) {
P A = ps[i], B = ps[(i + 1) % ps.size()];
if (ccw(l.a, l.b, A) != -1)
Q.push_back(A);
if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0)
Q.push_back(is_ll(L{A, B}, l));
}
return Q;
}
double dist2(P a) { return real(a) * real(a) + imag(a) * imag(a); }
// Suffix Array ?????????O(|S|log^2|S|), ????´¢O(|T|log|S|),
// ?????????????§????O(|S|)
class StringSearch {
const int n;
string S;
public:
vector<int> sa, rank;
StringSearch(const string &S_) : n(S_.size()), S(S_), sa(n + 1), rank(n + 1) {
for (int i = 0; i <= n; i++) {
sa[i] = i;
rank[i] = i < n ? S[i] : -1;
}
vector<int> tmp(n + 1);
for (int k = 1; k <= n; k *= 2) {
auto Compare_SA = [=](int i, int j) {
if (this->rank[i] != this->rank[j])
return this->rank[i] < this->rank[j];
int ri = i + k <= n ? this->rank[i + k] : -1;
int rj = j + k <= n ? this->rank[j + k] : -1;
return ri < rj;
};
sort(sa.begin(), sa.end(), Compare_SA);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (Compare_SA(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; i++) {
this->rank[i] = tmp[i];
}
}
}
bool Contain(const string &T) {
int a = 0, b = n;
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
vector<int> LCPArray() {
for (int i = 0; i <= n; i++)
rank[sa[i]] = i;
int h = 0;
vector<int> lcp(n + 1);
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (S[j + h] != S[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
return lcp;
}
};
// 0l
// 1A
// 141
// 101
// 2a
// 301
// 331
// 432
int dp[340][340][5];
vector<string> t;
string f4(int i, int j);
string f1(int i, int j) {
if (i == j)
return t[i];
rep(k, j - i) {
if (dp[i][k][4] && dp[i + k + 1][j - k - 1 - i][1])
return f4(i, i + k) + f1(i + k + 1, j) + ')';
if (dp[i][k][0] && dp[i + k + 1][j - k - 1 - i][1])
return '(' + f1(i + k + 1, j) + ')';
}
return "";
}
string f3(int i, int j) {
rep(k, j - i) {
if (dp[i][k][0] && dp[i + k + 1][j - k - 1 - i][1])
return '(' + f1(i + k + 1, j);
if (dp[i][k][3] && dp[i + k + 1][j - k - 1 - i][1])
return f3(i, i + k) + " " + f1(i + k + 1, j);
}
return "";
}
string f4(int i, int j) {
rep(k, j - i) {
if (dp[i][k][3] && dp[i + k + 1][j - k - 1 - i][2])
return f3(i, i + k) + " ";
}
}
int main() {
int n;
cin >> n;
string tmp;
getline(cin, tmp);
while (n--) {
string s;
getline(cin, s);
t.clear();
rep(i, s.size()) {
if (s[i] >= 'A' && s[i] <= 'Z') {
tmp = "";
while (s[i] >= 'A' && s[i] <= 'Z')
tmp += s[i];
t.push_back(tmp);
}
if (s[i] == 'l' && s[i + 1] == 'i')
t.push_back("l");
if (s[i] == 'a' && s[i + 1] == 'n')
t.push_back("a");
}
fill(dp[0][0], dp[340][0], 0);
rep(i, t.size()) dp[i][0][(t[i] == "l" ? 0 : t[i] == "a" ? 2 : 1)] = 1;
rep1(i, t.size() - 1) {
rep(j, t.size() - i) {
rep(k, i) {
dp[j][i][1] =
min(dp[j][i][1] + dp[j][k][4] * dp[j + k + 1][i - k - 1][1] +
dp[j][k][0] * dp[j + k + 1][i - k - 1][1],
20000);
dp[j][i][4] = min(
dp[j][i][4] + dp[j][k][3] * dp[j + k + 1][i - k - 1][2], 20000);
dp[j][i][3] =
min(dp[j][i][3] + dp[j][k][0] * dp[j + k + 1][i - k - 1][1] +
dp[j][k][3] * dp[j + k + 1][i - k - 1][1],
20000);
}
}
}
if (dp[0][t.size() - 1][1] == 1) {
cout << f1(0, t.size() - 1) << endl;
} else
cout << "AMBIGUOUS" << endl;
}
} | #include <algorithm>
#include <array>
#include <chrono>
#include <cmath>
#include <complex>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <map>
#include <numeric>
#include <queue>
#include <string>
#include <tuple>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>
// cin.sync_with_stdio(false);
// streambuf
using namespace std;
typedef long long ll;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef pair<double, double> pdd;
using vi = vector<int>;
using vll = vector<ll>;
using vpii = vector<pii>;
template <class T, int s> using va = vector<array<T, s>>;
template <class T, class T2> using umap = unordered_map<T, T2>;
template <class T> using uset = unordered_set<T>;
template <class T, class S> void cmin(T &a, const S &&b) {
if (a > b)
a = b;
}
template <class T, class S> void cmax(T &a, const S &&b) {
if (a < b)
a = b;
}
#define ALL(a) a.begin(), a.end()
#define rep(i, a) for (int i = 0; i < a; i++)
#define rep1(i, a) for (int i = 1; i <= a; i++)
#define rrep(i, a) for (int i = a - 1; i >= 0; i--)
#define rrep1(i, a) for (int i = a; i; i--)
const ll mod = 1000000007;
#ifndef INT_MAX
const int INT_MAX = numeric_limits<signed>().max();
#endif
template <class T> using heap = priority_queue<T, vector<T>, greater<T>>;
template <class T> using pque = priority_queue<T, vector<T>, function<T(T, T)>>;
template <class T> inline void hash_combine(size_t &seed, const T &v) {
hash<T> hasher;
seed ^= hasher(v) + 0x9e3779b9 + (seed << 6) + (seed >> 2);
}
namespace std {
template <typename S, typename T> struct hash<pair<S, T>> {
inline size_t operator()(const pair<S, T> &v) const {
size_t seed = 0;
hash_combine(seed, v.first);
hash_combine(seed, v.second);
return seed;
}
};
// Recursive template code derived from Matthieu M.
template <class Tuple, size_t Index = std::tuple_size<Tuple>::value - 1>
struct HashValueImpl {
static void apply(size_t &seed, Tuple const &tuple) {
HashValueImpl<Tuple, Index - 1>::apply(seed, tuple);
hash_combine(seed, std::get<Index>(tuple));
}
};
template <class Tuple> struct HashValueImpl<Tuple, 0> {
static void apply(size_t &seed, Tuple const &tuple) {
hash_combine(seed, std::get<0>(tuple));
}
};
template <typename... TT> struct hash<std::tuple<TT...>> {
size_t operator()(std::tuple<TT...> const &tt) const {
size_t seed = 0;
HashValueImpl<std::tuple<TT...>>::apply(seed, tt);
return seed;
}
};
} // namespace std
ll pow(ll base, ll i, ll mod) {
ll a = 1;
while (i) {
if (i & 1) {
a *= base;
a %= mod;
}
base *= base;
base %= mod;
i /= 2;
}
return a;
}
class unionfind {
vector<int> par, rank,
size_; //????????§??????????????¢???????????????????????????rank???????????????size?????????
public:
unionfind(int n) : par(n), rank(n), size_(n, 1) { iota(ALL(par), 0); }
int find(int x) {
if (par[x] == x)
return x;
return par[x] = find(par[x]);
}
void unite(int x, int y) {
x = find(x), y = find(y);
if (x == y)
return;
if (rank[x] < rank[y])
swap(x, y);
par[y] = x;
size_[x] += size_[y];
if (rank[x] == rank[y])
rank[x]++;
}
bool same(int x, int y) { return find(x) == find(y); }
int size(int x) { return size_[find(x)]; }
};
ll gcd(ll a, ll b) {
while (b) {
ll c = a % b;
a = b;
b = c;
}
return a;
}
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int popcnt(unsigned long long a) {
a = (a & 0x5555555555555555) + (a >> 1 & 0x5555555555555555);
a = (a & 0x3333333333333333) + (a >> 2 & 0x3333333333333333);
a = (a & 0x0f0f0f0f0f0f0f0f) + (a >> 4 & 0x0f0f0f0f0f0f0f0f);
a = (a & 0x00ff00ff00ff00ff) + (a >> 8 & 0x00ff00ff00ff00ff);
a = (a & 0x0000ffff0000ffff) + (a >> 16 & 0x0000ffff0000ffff);
return (a & 0xffffffff) + (a >> 32);
}
template <class T, class Func = function<T(T, T)>> class segtree {
vector<T> obj;
int offset;
Func updater;
T e;
int bufsize(int num) {
int i = 1;
for (; num > i; i <<= 1)
;
offset = i - 1;
return (i << 1) - 1;
}
T query(int a, int b, int k, int l, int r) {
if (r <= a || b <= l)
return e;
if (a <= l && r <= b)
return obj[k];
else
return updater(query(a, b, k * 2 + 1, l, (l + r) / 2),
query(a, b, k * 2 + 2, (l + r) / 2, r));
}
public:
T query(int a, int b) { //[a,b)
return query(a, b, 0, 0, offset + 1);
}
void updateall(int l = 0, int r = -1) {
if (r < 0)
r = offset + 1;
l += offset, r += offset;
do {
l = l - 1 >> 1, r = r - 1 >> 1;
for (int i = l; i < r; i++)
obj[i] = updater(obj[i * 2 + 1], obj[i * 2 + 2]);
} while (l);
}
void update(int k, T &a) {
k += offset;
obj[k] = a;
while (k) {
k = k - 1 >> 1;
obj[k] = updater(obj[k * 2 + 1], obj[k * 2 + 2]);
}
}
segtree(int n, T e, const Func &updater_ = Func())
: obj(bufsize(n), e), e(e), updater(updater_) {}
segtree(vector<T> &vec, T e, const Func &updater = Func())
: obj(bufsize(vec.size()), e), e(e), updater(updater) {
copy(vec.begin(), vec.end(), obj.begin() + offset);
updateall();
}
typename vector<T>::reference operator[](int n) { return obj[n + offset]; }
};
template <class T> class matrix {
vector<vector<T>> obj;
pair<int, int> s;
public:
matrix(pair<int, int> size, T e = 0) : matrix(size.first, size.second, e) {}
matrix(int n, int m = -1, T e = 0)
: obj(n, vector<T>(m == -1 ? n : m, e)), s(n, m == -1 ? n : m) {}
static matrix e(int n) {
matrix a = (n);
for (int i = 0; i < n; i++)
a[i][i] = 1;
return a;
}
matrix &operator+=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] += p.obj[i][j];
return *this;
}
matrix operator+(const matrix &p) {
matrix res(*this);
return res += p;
}
matrix &operator-=(const matrix &p) {
if (s != p.s)
throw runtime_error("matrix error");
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
obj[i][j] -= p.obj[i][j];
return *this;
}
matrix operator-(const matrix &p) {
matrix res(*this);
return res -= p;
}
matrix &operator*=(T p) {
for (auto &a : obj)
for (auto &b : a)
b *= p;
return *this;
}
matrix operator*(T p) {
matrix res(*this);
return res *= p;
}
matrix operator*(const matrix &p) {
if (s.second != p.s.first)
throw runtime_error("matrix error");
matrix ret(s.first, p.s.second);
for (int i = 0; i < s.first; i++)
for (int j = 0; j < s.second; j++)
for (int k = 0; k < p.s.second; k++)
ret[i][k] += obj[i][j] * p.obj[j][k];
return ret;
}
matrix &operator*=(const matrix &p) { return *this = *this * p; }
pair<int, int> size() const { return s; }
matrix &mod(T m) {
for (auto &a : obj)
for (auto &b : a)
b %= m;
return *this;
}
typename vector<vector<T>>::reference operator[](int t) { return obj[t]; }
};
template <class T> inline matrix<T> pow(matrix<T> &base, unsigned exp) {
auto base_(base);
if (base_.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
res *= base_;
if (!(exp /= 2))
break;
base_ *= base_;
}
return res;
}
template <class T> inline matrix<T> modpow(matrix<T> &base, unsigned exp, T m) {
auto base_(base);
if (base.size().first != base_.size().second)
throw runtime_error("matrix error");
matrix<T> res = matrix<T>::e(base_.size().first);
for (;;) {
if (exp & 1)
(res *= base_).mod(m);
if (!(exp /= 2))
break;
(base_ *= base_).mod(m);
}
return res;
}
template <class T> int id(vector<T> &a, T b) {
return lower_bound(ALL(a), b) - a.begin();
}
class Flow {
int V;
struct edge {
int to, cap, rev, cost;
};
vector<vector<edge>> G;
vector<int> level, iter, h, dist, prevv, preve;
Flow(int size) : G(size + 1), V(size + 1) {}
void add_edge(int from, int to, int cap, int cost = 0) {
G[from].push_back(edge{to, cap, (int)G[to].size(), cost});
G[to].push_back(edge{from, 0, (int)G[from].size() - 1, -cost});
}
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
int dfs(int v, int t, int f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
level.resize(V);
iter.resize(V);
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, numeric_limits<int>::max())) > 0) {
flow += f;
}
}
}
typedef pair<int, int> P;
int min_cost_flow(int s, int t, int f) {
int res = 0;
h.resize(V);
dist.resize(V);
prevv.resize(V);
preve.resize(V);
fill(h.begin(), h.end(), 0);
while (f > 0) {
priority_queue<P, vector<P>, greater<P>> que;
fill(dist.begin(), dist.end(), numeric_limits<int>::max());
dist[s] = 0;
que.push({0, s});
while (!que.empty()) {
P p = que.top();
que.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
edge &e = G[v][i];
if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
prevv[e.to] = v;
preve[e.to] = i;
que.push({dist[e.to], e.to});
}
}
}
if (dist[t] == numeric_limits<int>::max()) {
return -1;
}
for (int v = 0; v < V; v++)
h[v] += dist[v];
int d = f;
for (int v = t; v != s; v = prevv[v]) {
d = min(d, G[prevv[v]][preve[v]].cap);
}
f -= d;
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
};
const ld eps = 1e-11, pi = acos(-1.0);
typedef complex<ld> P;
typedef vector<P> VP;
ld dot(P a, P b) { return real(conj(a) * b); }
ld cross(P a, P b) { return imag(conj(a) * b); }
namespace std {
bool operator<(const P &a, const P &b) {
return abs(a.real() - b.real()) < eps ? a.imag() < b.imag()
: a.real() < b.real();
}
} // namespace std
struct L {
P a, b;
}; // line->l,segment->s
struct C {
P p;
ld r;
};
int ccw(P a, P b, P c) {
b -= a;
c -= a;
if (cross(b, c) > eps)
return 1; // counter clockwise
if (cross(b, c) < -eps)
return -1; // clockwise
if (dot(b, c) < 0)
return 2; // c--a--b on line
if (norm(b) < norm(c))
return -2; // a--b--c on line
return 0; // a--c--b on line
}
bool isis_ll(L l, L m) { // is intersect
return abs(cross(l.b - l.a, m.b - m.a)) > eps;
}
bool isis_ls(L l, L s) {
ld a = cross(l.b - l.a, s.a - l.a);
ld b = cross(l.b - l.a, s.b - l.a);
return (a * b < eps);
}
bool isis_lp(L l, P p) { return abs(cross(l.b - p, l.a - p)) < eps; }
bool isis_ss(L s, L t) {
return ccw(s.a, s.b, t.a) * ccw(s.a, s.b, t.b) <= 0 &&
ccw(t.a, t.b, s.a) * ccw(t.a, t.b, s.b) <= 0;
}
P is_ll(L s, L t) { // intersect
P sv = s.b - s.a, tv = t.b - t.a;
return s.a + sv * cross(tv, t.a - s.a) / cross(tv, sv);
}
bool isis_sp(L s, P p) {
return abs(s.a - p) + abs(s.b - p) - abs(s.b - s.a) < eps;
}
P proj(L l, P p) {
ld t = dot(p - l.a, l.a - l.b) / norm(l.a - l.b);
return l.a + t * (l.a - l.b);
}
ld dist_lp(L l, P p) { return abs(p - proj(l, p)); }
ld dist_ll(L l, L m) { return isis_ll(l, m) ? 0 : dist_lp(l, m.a); }
ld dist_ls(L l, L s) {
if (isis_ls(l, s))
return 0;
return min(dist_lp(l, s.a), dist_lp(l, s.b));
}
ld dist_sp(L s, P p) {
P r = proj(s, p);
if (isis_sp(s, r))
return abs(r - p);
return min(abs(s.a - p), abs(s.b - p));
}
ld dist_ss(L s, L t) {
if (isis_ss(s, t))
return 0;
ld a = min(dist_sp(s, t.a), dist_sp(t, s.a));
ld b = min(dist_sp(s, t.b), dist_sp(t, s.b));
return min(a, b);
}
VP is_cc(C c1, C c2) {
VP res;
ld d = abs(c1.p - c2.p);
ld rc = (d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d);
ld dfr = c1.r * c1.r - rc * rc;
if (abs(dfr) < eps)
dfr = 0.0;
else if (dfr < 0.0)
return res; // no intersection
ld rs = sqrt(dfr);
P diff = (c2.p - c1.p) / d;
res.push_back(c1.p + diff * P(rc, rs));
if (dfr != 0.0)
res.push_back(c1.p + diff * P(rc, -rs));
return res;
}
bool isis_vc(vector<C> vc) {
VP crs;
int n = vc.size();
rep(i, n) rep(j, i) for (P p : is_cc(vc[i], vc[j])) crs.push_back(p);
rep(i, n) crs.push_back(vc[i].p);
for (P p : crs) {
bool valid = true;
rep(i, n) if (abs(p - vc[i].p) > vc[i].r + eps) valid = false;
if (valid)
return true;
}
return false;
}
VP is_lc(C c, L l) {
VP res;
ld d = dist_lp(l, c.p);
if (d < c.r + eps) {
ld len = (d > c.r) ? 0.0 : sqrt(c.r * c.r - d * d); // safety;
P nor = (l.a - l.b) / abs(l.a - l.b);
res.push_back(proj(l, c.p) + len * nor);
res.push_back(proj(l, c.p) - len * nor);
}
return res;
}
VP is_sc(C c, L l) {
VP v = is_lc(c, l), res;
for (P p : v)
if (isis_sp(l, p))
res.push_back(p);
return res;
}
vector<L> tangent_cp(C c, P p) { //????????\????
vector<L> ret;
P v = c.p - p;
ld d = abs(v);
ld l = sqrt(norm(v) - c.r * c.r);
if (isnan(l)) {
return ret;
}
P v1 = v * P(l / d, c.r / d);
P v2 = v * P(l / d, -c.r / d);
ret.push_back(L{p, p + v1});
if (l < eps)
return ret;
ret.push_back(L{p, p + v2});
return ret;
}
vector<L> tangent_cc(C c1, C c2) {
vector<L> ret;
if (abs(c1.p - c2.p) - (c1.r + c2.r) > -eps) {
P center = (c1.p * c2.r + c2.p * c1.r) / (c1.r + c2.r);
ret = tangent_cp(c1, center);
}
if (abs(c1.r - c2.r) > eps) {
P out = (-c1.p * c2.r + c2.p * c1.r) / (c1.r - c2.r);
vector<L> nret = tangent_cp(c1, out);
ret.insert(ret.end(), ALL(nret));
} else {
P v = c2.p - c1.p;
v /= abs(v);
P q1 = c1.p + v * P(0, 1) * c1.r;
P q2 = c1.p + v * P(0, -1) * c1.r;
ret.push_back(L{q1, q1 + v});
ret.push_back(L{q2, q2 + v});
}
return ret;
}
ld area(const VP &p) { //??¢?????
ld res = 0;
int n = p.size();
rep(j, n) res += cross(p[j], p[(j + 1) % n]);
return res / 2;
}
bool is_polygon(L l, VP &g) {
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i];
P b = g[(i + 1) % n];
if (isis_ss(l, L{a, b}))
return true;
}
return false;
}
int is_in_Polygon(const VP &g, P p) {
bool in = false;
int n = g.size();
for (int i = 0; i < n; i++) {
P a = g[i] - p, b = g[(i + 1) % n] - p;
if (imag(a) > imag(b))
swap(a, b);
if (imag(a) <= 0 && 0 < imag(b))
if (cross(a, b) < 0)
in = !in;
if (abs(cross(a, b)) < eps && dot(a, b) < eps)
return 0; // on
}
if (in)
return 1; // in
return -1; // out
}
VP ConvexHull(VP ps) {
int n = ps.size();
int k = 0;
sort(ps.begin(), ps.end());
VP ch(2 * n);
for (int i = 0; i < n; ch[k++] = ps[i++])
while (k >= 2 && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
for (int i = n - 2, t = k + 1; i >= 0; ch[k++] = ps[i--])
while (k >= t && ccw(ch[k - 2], ch[k - 1], ps[i]) <= 0)
--k;
ch.resize(k - 1);
return ch;
}
VP ConvexCut(const VP &ps, L l) {
VP Q;
for (int i = 0; i < (int)ps.size(); i++) {
P A = ps[i], B = ps[(i + 1) % ps.size()];
if (ccw(l.a, l.b, A) != -1)
Q.push_back(A);
if (ccw(l.a, l.b, A) * ccw(l.a, l.b, B) < 0)
Q.push_back(is_ll(L{A, B}, l));
}
return Q;
}
double dist2(P a) { return real(a) * real(a) + imag(a) * imag(a); }
// Suffix Array ?????????O(|S|log^2|S|), ????´¢O(|T|log|S|),
// ?????????????§????O(|S|)
class StringSearch {
const int n;
string S;
public:
vector<int> sa, rank;
StringSearch(const string &S_) : n(S_.size()), S(S_), sa(n + 1), rank(n + 1) {
for (int i = 0; i <= n; i++) {
sa[i] = i;
rank[i] = i < n ? S[i] : -1;
}
vector<int> tmp(n + 1);
for (int k = 1; k <= n; k *= 2) {
auto Compare_SA = [=](int i, int j) {
if (this->rank[i] != this->rank[j])
return this->rank[i] < this->rank[j];
int ri = i + k <= n ? this->rank[i + k] : -1;
int rj = j + k <= n ? this->rank[j + k] : -1;
return ri < rj;
};
sort(sa.begin(), sa.end(), Compare_SA);
tmp[sa[0]] = 0;
for (int i = 1; i <= n; i++) {
tmp[sa[i]] = tmp[sa[i - 1]] + (Compare_SA(sa[i - 1], sa[i]) ? 1 : 0);
}
for (int i = 0; i <= n; i++) {
this->rank[i] = tmp[i];
}
}
}
bool Contain(const string &T) {
int a = 0, b = n;
while (b - a > 1) {
int c = (a + b) / 2;
if (S.compare(sa[c], T.length(), T) < 0)
a = c;
else
b = c;
}
return S.compare(sa[b], T.length(), T) == 0;
}
vector<int> LCPArray() {
for (int i = 0; i <= n; i++)
rank[sa[i]] = i;
int h = 0;
vector<int> lcp(n + 1);
for (int i = 0; i < n; i++) {
int j = sa[rank[i] - 1];
if (h > 0)
h--;
for (; j + h < n && i + h < n; h++) {
if (S[j + h] != S[i + h])
break;
}
lcp[rank[i] - 1] = h;
}
return lcp;
}
};
// 0l
// 1A
// 141
// 101
// 2a
// 301
// 331
// 432
int dp[340][340][5];
vector<string> t;
string f4(int i, int j);
string f1(int i, int j) {
if (i == j)
return t[i];
rep(k, j - i) {
if (dp[i][k][4] && dp[i + k + 1][j - k - 1 - i][1])
return f4(i, i + k) + f1(i + k + 1, j) + ')';
if (dp[i][k][0] && dp[i + k + 1][j - k - 1 - i][1])
return '(' + f1(i + k + 1, j) + ')';
}
return "";
}
string f3(int i, int j) {
rep(k, j - i) {
if (dp[i][k][0] && dp[i + k + 1][j - k - 1 - i][1])
return '(' + f1(i + k + 1, j);
if (dp[i][k][3] && dp[i + k + 1][j - k - 1 - i][1])
return f3(i, i + k) + " " + f1(i + k + 1, j);
}
return "";
}
string f4(int i, int j) {
rep(k, j - i) {
if (dp[i][k][3] && dp[i + k + 1][j - k - 1 - i][2])
return f3(i, i + k) + " ";
}
}
int main() {
int n;
cin >> n;
string tmp;
getline(cin, tmp);
while (n--) {
string s;
getline(cin, s);
t.clear();
rep(i, s.size()) {
if (s[i] >= 'A' && s[i] <= 'Z') {
tmp = "";
while (s[i] >= 'A' && s[i] <= 'Z')
tmp += s[i++];
t.push_back(tmp);
}
if (s[i] == 'l' && s[i + 1] == 'i')
t.push_back("l");
if (s[i] == 'a' && s[i + 1] == 'n')
t.push_back("a");
}
fill(dp[0][0], dp[340][0], 0);
rep(i, t.size()) dp[i][0][(t[i] == "l" ? 0 : t[i] == "a" ? 2 : 1)] = 1;
rep1(i, t.size() - 1) {
rep(j, t.size() - i) {
rep(k, i) {
dp[j][i][1] =
min(dp[j][i][1] + dp[j][k][4] * dp[j + k + 1][i - k - 1][1] +
dp[j][k][0] * dp[j + k + 1][i - k - 1][1],
20000);
dp[j][i][4] = min(
dp[j][i][4] + dp[j][k][3] * dp[j + k + 1][i - k - 1][2], 20000);
dp[j][i][3] =
min(dp[j][i][3] + dp[j][k][0] * dp[j + k + 1][i - k - 1][1] +
dp[j][k][3] * dp[j + k + 1][i - k - 1][1],
20000);
}
}
}
if (dp[0][t.size() - 1][1] == 1) {
cout << f1(0, t.size() - 1) << endl;
} else
cout << "AMBIGUOUS" << endl;
}
} | replace | 760 | 761 | 760 | 761 | -6 | terminate called after throwing an instance of 'std::bad_alloc'
what(): std::bad_alloc
|
p01192 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
int n;
int c[100];
int greedy(int x) {
int res = 0;
for (int i = n - 1; i >= 0; i--) {
res += x / c[i];
x %= c[i];
}
return res;
}
int dp[5000];
void solve() {
if (c[0] != 1) {
printf("Cannot pay some amount");
return;
}
fill(dp, dp + 5000, 1e9);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int val = c[i];
for (int j = 0; j < 2000; j++) {
if (j - val >= 0)
dp[j] = min(dp[j], dp[j - val] + 1);
}
}
for (int num = 0; num < 2000; num++) {
int cost = greedy(num);
if (cost != dp[num]) {
// cout<<num<<' '<<cost<<' '<<dp[num]<<endl;
printf("Cannot use greedy algorithm");
return;
}
}
for (int j = 2000; j < 5000; j++) {
for (int i = 0; i < n; i++) {
int val = c[i];
dp[j] = min(dp[j], dp[j - val] + 1);
}
if (dp[j] != dp[j - c[n - 2]] + 1) {
printf("Cannot use greedy algorithm");
return;
}
}
printf("OK");
}
int main() {
for (int tc = 1;; tc++) {
scanf("%d", &n);
if (n == 0)
break;
for (int i = 0; i < n; i++)
scanf("%d", &c[i]);
printf("Case #%d: ", tc);
solve();
printf("\n");
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
int n;
int c[100];
int greedy(int x) {
int res = 0;
for (int i = n - 1; i >= 0; i--) {
res += x / c[i];
x %= c[i];
}
return res;
}
int dp[5000];
void solve() {
if (c[0] != 1) {
printf("Cannot pay some amount");
return;
}
fill(dp, dp + 5000, 1e9);
dp[0] = 0;
for (int i = 0; i < n; i++) {
int val = c[i];
for (int j = 0; j < 2000; j++) {
if (j - val >= 0)
dp[j] = min(dp[j], dp[j - val] + 1);
}
}
for (int num = 0; num < 2000; num++) {
int cost = greedy(num);
if (cost != dp[num]) {
// cout<<num<<' '<<cost<<' '<<dp[num]<<endl;
printf("Cannot use greedy algorithm");
return;
}
}
for (int j = 2000; j < 5000; j++) {
for (int i = 0; i < n; i++) {
int val = c[i];
dp[j] = min(dp[j], dp[j - val] + 1);
}
if (dp[j] != dp[j - c[n - 1]] + 1) {
printf("Cannot use greedy algorithm");
return;
}
}
printf("OK");
}
int main() {
for (int tc = 1;; tc++) {
scanf("%d", &n);
if (n == 0)
break;
for (int i = 0; i < n; i++)
scanf("%d", &c[i]);
printf("Case #%d: ", tc);
solve();
printf("\n");
}
return 0;
} | replace | 49 | 50 | 49 | 50 | 0 | |
p01199 | C++ | Time Limit Exceeded | #include <iostream>
#include <vector>
using namespace std;
#define min(a, b) (a > b ? b : a)
struct Edge {
int to, cap, rev;
Edge() {}
Edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
typedef vector<Edge> Graph;
#define N 400
#define INF 1000000007
Graph g[N];
bool used[N];
void add_edge(int from, int to, int cap) {
g[from].push_back(Edge(to, cap, g[to].size()));
g[to].push_back(Edge(from, 0, g[from].size() - 1));
}
int dfs(int s, int t, int f) {
if (s == t || f == 0)
return f;
used[s] = true;
for (int i = 0; i < g[s].size(); ++i) {
Edge &e = g[s][i];
if (e.cap > 0 && !used[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int ret = 0;
while (true) {
int f = dfs(s, t, INF);
for (int i = 0; i < N; ++i)
used[i] = false;
if (f == 0)
break;
ret += f;
}
return ret;
}
int main() {
int n, m, l;
while (cin >> n >> m >> l) {
int mat[N][N];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
mat[i][j] = INF;
for (int i = 0; i < n; ++i)
mat[i][i] = 0;
for (int i = 0; i < m; ++i) {
int a, b, d;
cin >> a >> b >> d;
--a;
--b;
mat[a][b] = mat[b][a] = d;
}
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
add_edge(0, i + 1, p);
}
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
add_edge(n + i + 1, 2 * n + 1, k);
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (mat[i][j] < l) {
add_edge(i + 1, n + j + 1, INF);
}
}
}
cout << max_flow(0, 2 * n + 1) << endl;
}
return 0;
} | #include <iostream>
#include <vector>
using namespace std;
#define min(a, b) (a > b ? b : a)
struct Edge {
int to, cap, rev;
Edge() {}
Edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
typedef vector<Edge> Graph;
#define N 400
#define INF 1000000007
Graph g[N];
bool used[N];
void add_edge(int from, int to, int cap) {
g[from].push_back(Edge(to, cap, g[to].size()));
g[to].push_back(Edge(from, 0, g[from].size() - 1));
}
int dfs(int s, int t, int f) {
if (s == t || f == 0)
return f;
used[s] = true;
for (int i = 0; i < g[s].size(); ++i) {
Edge &e = g[s][i];
if (e.cap > 0 && !used[e.to]) {
int d = dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
g[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
int max_flow(int s, int t) {
int ret = 0;
while (true) {
int f = dfs(s, t, INF);
for (int i = 0; i < N; ++i)
used[i] = false;
if (f == 0)
break;
ret += f;
}
return ret;
}
int main() {
int n, m, l;
while (cin >> n >> m >> l) {
int mat[N][N];
for (int i = 0; i < n; ++i)
for (int j = 0; j < n; ++j)
mat[i][j] = INF;
for (int i = 0; i < n; ++i)
mat[i][i] = 0;
for (int i = 0; i < m; ++i) {
int a, b, d;
cin >> a >> b >> d;
--a;
--b;
mat[a][b] = mat[b][a] = d;
}
for (int i = 0; i <= 2 * n + 1; ++i)
g[i].clear();
for (int i = 0; i < n; ++i) {
int p;
cin >> p;
add_edge(0, i + 1, p);
}
for (int i = 0; i < n; ++i) {
int k;
cin >> k;
add_edge(n + i + 1, 2 * n + 1, k);
}
for (int k = 0; k < n; ++k) {
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
mat[i][j] = min(mat[i][j], mat[i][k] + mat[k][j]);
}
}
}
for (int i = 0; i < n; ++i) {
for (int j = 0; j < n; ++j) {
if (mat[i][j] < l) {
add_edge(i + 1, n + j + 1, INF);
}
}
}
cout << max_flow(0, 2 * n + 1) << endl;
}
return 0;
} | insert | 71 | 71 | 71 | 73 | TLE | |
p01199 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define SOUR (N + N)
#define SINK (N + N + 1)
#define INF (1 << 29)
class Node {
public:
vector<int> to;
};
int flow[205][205], capa[205][205], N, M, L;
void Connect(vector<Node> &node, int u, int v, int w) {
flow[v][u] += w;
capa[v][u] += w;
capa[u][v] += w;
node[u].to.push_back(v);
node[v].to.push_back(u);
}
int dfs(int p, int T, int mf, vector<Node> &graph, vector<int> &level,
vector<bool> &finished) {
if (p == T)
return mf;
if (finished[p])
return 0;
finished[p] = true;
for (int i = 0; i < graph[p].to.size(); i++) {
int next = graph[p].to[i], fw = capa[p][next] - flow[p][next];
if (level[p] >= level[next])
continue;
if (fw <= 0)
continue;
int f = dfs(next, T, min(mf, fw), graph, level, finished);
if (f > 0) {
finished[p] = false;
flow[p][next] += f;
flow[next][p] -= f;
return f;
}
}
return 0;
}
int dinic(int S, int T, vector<Node> &graph) {
bool end = false;
int total = 0;
while (!end) {
end = true;
vector<int> level(graph.size(), -1);
level[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int n = q.front();
q.pop();
for (int i = 0; i < graph[n].to.size(); i++) {
int next = graph[n].to[i];
if (level[next] != -1)
continue;
if (capa[n][next] - flow[n][next] <= 0)
continue;
level[next] = level[n] + 1;
q.push(next);
}
}
if (level[T] == -1)
break;
vector<bool> finished(graph.size());
while (1) {
int fw = dfs(S, T, INF, graph, level, finished);
if (fw <= 0)
break;
total += fw;
end = false;
}
}
return total;
}
int main() {
while (cin >> N >> M >> L, (N || M || L)) {
int d[100][100];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
d[i][j] = INF;
d[i][i] = d[j][j] = 0;
}
for (int i = 0; i < M; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
d[u][v] = w;
d[v][u] = w;
}
for (int k = 0; k < N; k++)
for (int y = 0; y < N; y++)
for (int x = 0; x < N; x++)
d[x][y] = min(d[x][y], d[x][k] + d[k][y]);
memset(flow, 0, sizeof(flow));
memset(capa, 0, sizeof(capa));
vector<Node> node(SINK + 1);
int in, out;
for (int i = 0; i < N; i++) {
cin >> in;
Connect(node, SOUR, i, in);
}
for (int i = 0; i < N; i++) {
cin >> out;
Connect(node, N + i, SINK, out);
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
if (d[i][j] < L)
Connect(node, i, N + j, INF);
}
cout << dinic(SOUR, SINK, node) << endl;
}
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define SOUR (N + N)
#define SINK (N + N + 1)
#define INF (1 << 29)
class Node {
public:
vector<int> to;
};
int flow[205][205], capa[205][205], N, M, L;
void Connect(vector<Node> &node, int u, int v, int w) {
flow[v][u] += w;
capa[v][u] += w;
capa[u][v] += w;
node[u].to.push_back(v);
node[v].to.push_back(u);
}
int dfs(int p, int T, int mf, vector<Node> &graph, vector<int> &level,
vector<bool> &finished) {
if (p == T)
return mf;
if (finished[p])
return 0;
finished[p] = true;
for (int i = 0; i < graph[p].to.size(); i++) {
int next = graph[p].to[i], fw = capa[p][next] - flow[p][next];
if (level[p] >= level[next])
continue;
if (fw <= 0)
continue;
int f = dfs(next, T, min(mf, fw), graph, level, finished);
if (f > 0) {
finished[p] = false;
flow[p][next] += f;
flow[next][p] -= f;
return f;
}
}
return 0;
}
int dinic(int S, int T, vector<Node> &graph) {
bool end = false;
int total = 0;
while (!end) {
end = true;
vector<int> level(graph.size(), -1);
level[S] = 0;
queue<int> q;
q.push(S);
while (!q.empty()) {
int n = q.front();
q.pop();
for (int i = 0; i < graph[n].to.size(); i++) {
int next = graph[n].to[i];
if (level[next] != -1)
continue;
if (capa[n][next] - flow[n][next] <= 0)
continue;
level[next] = level[n] + 1;
q.push(next);
}
}
if (level[T] == -1)
break;
vector<bool> finished(graph.size());
while (1) {
int fw = dfs(S, T, INF, graph, level, finished);
if (fw <= 0)
break;
total += fw;
end = false;
}
}
return total;
}
int main() {
while (cin >> N >> M >> L) {
int d[100][100];
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
d[i][j] = INF;
d[i][i] = d[j][j] = 0;
}
for (int i = 0; i < M; i++) {
int u, v, w;
cin >> u >> v >> w;
u--;
v--;
d[u][v] = w;
d[v][u] = w;
}
for (int k = 0; k < N; k++)
for (int y = 0; y < N; y++)
for (int x = 0; x < N; x++)
d[x][y] = min(d[x][y], d[x][k] + d[k][y]);
memset(flow, 0, sizeof(flow));
memset(capa, 0, sizeof(capa));
vector<Node> node(SINK + 1);
int in, out;
for (int i = 0; i < N; i++) {
cin >> in;
Connect(node, SOUR, i, in);
}
for (int i = 0; i < N; i++) {
cin >> out;
Connect(node, N + i, SINK, out);
}
for (int i = 0; i < N; i++)
for (int j = 0; j < N; j++) {
if (d[i][j] < L)
Connect(node, i, N + j, INF);
}
cout << dinic(SOUR, SINK, node) << endl;
}
} | replace | 96 | 97 | 96 | 97 | -11 | |
p01199 | C++ | Runtime Error | #include <cstring>
#include <iostream>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
#define debug(x) cout << #x << " is " << x << endl;
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 29;
struct edge {
int to, cap, rev;
edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
const int N = 101;
vector<vector<edge>> G;
int visit[N];
void add_edge(int from, int to, int cap) {
G[from].push_back(edge(to, cap, G[to].size()));
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
int dfs(int s, int g, int f) {
if (s == g)
return f;
visit[s] = 1;
rep(i, G[s].size()) {
if (visit[G[s][i].to] || G[s][i].cap <= 0)
continue;
int d = dfs(G[s][i].to, g, min(f, G[s][i].cap));
if (d > 0) {
G[s][i].cap -= d;
G[G[s][i].to][G[s][i].rev].cap += d;
return d;
}
}
return 0;
}
int ford_fulkerson(int s, int g) {
int flow = 0;
while (1) {
memset(visit, 0, sizeof(visit));
int f = dfs(s, g, INF);
if (f == 0)
return flow;
flow += f;
}
}
int v[N];
int dist[N][N];
int main() {
int n, m, l;
while (cin >> n >> m >> l) {
rep(i, n) rep(j, n) dist[i][j] = INF;
rep(i, m) {
int a, b, d;
cin >> a >> b >> d;
a--, b--;
dist[a][b] = dist[b][a] = d;
}
rep(i, n) rep(j, n) rep(k, n) dist[j][k] =
min(dist[j][k], dist[j][i] + dist[i][k]);
// rep(i, n){
// rep(j, n) cout << dist[i][j] << ' ';
// cout << endl;
// }cout << endl;
G.clear();
G.resize(2 * n + 2);
int s = 2 * n, g = 2 * n + 1;
rep(i, n) {
int p;
cin >> p;
add_edge(s, i, p);
}
rep(i, n) {
int k;
cin >> k;
add_edge(n + i, g, k);
}
rep(i, n) rep(j, n) {
if (i == j || dist[i][j] < l) {
add_edge(i, j + n, INF);
}
}
cout << ford_fulkerson(s, g) << endl;
}
return 0;
} | #include <cstring>
#include <iostream>
#include <vector>
#define FOR(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, n) FOR(i, 0, n)
#define debug(x) cout << #x << " is " << x << endl;
using namespace std;
typedef pair<int, int> P;
const int INF = 1 << 29;
struct edge {
int to, cap, rev;
edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
const int N = 101;
vector<vector<edge>> G;
int visit[3 * N];
void add_edge(int from, int to, int cap) {
G[from].push_back(edge(to, cap, G[to].size()));
G[to].push_back(edge(from, 0, G[from].size() - 1));
}
int dfs(int s, int g, int f) {
if (s == g)
return f;
visit[s] = 1;
rep(i, G[s].size()) {
if (visit[G[s][i].to] || G[s][i].cap <= 0)
continue;
int d = dfs(G[s][i].to, g, min(f, G[s][i].cap));
if (d > 0) {
G[s][i].cap -= d;
G[G[s][i].to][G[s][i].rev].cap += d;
return d;
}
}
return 0;
}
int ford_fulkerson(int s, int g) {
int flow = 0;
while (1) {
memset(visit, 0, sizeof(visit));
int f = dfs(s, g, INF);
if (f == 0)
return flow;
flow += f;
}
}
int v[N];
int dist[N][N];
int main() {
int n, m, l;
while (cin >> n >> m >> l) {
rep(i, n) rep(j, n) dist[i][j] = INF;
rep(i, m) {
int a, b, d;
cin >> a >> b >> d;
a--, b--;
dist[a][b] = dist[b][a] = d;
}
rep(i, n) rep(j, n) rep(k, n) dist[j][k] =
min(dist[j][k], dist[j][i] + dist[i][k]);
// rep(i, n){
// rep(j, n) cout << dist[i][j] << ' ';
// cout << endl;
// }cout << endl;
G.clear();
G.resize(2 * n + 2);
int s = 2 * n, g = 2 * n + 1;
rep(i, n) {
int p;
cin >> p;
add_edge(s, i, p);
}
rep(i, n) {
int k;
cin >> k;
add_edge(n + i, g, k);
}
rep(i, n) rep(j, n) {
if (i == j || dist[i][j] < l) {
add_edge(i, j + n, INF);
}
}
cout << ford_fulkerson(s, g) << endl;
}
return 0;
} | replace | 22 | 23 | 22 | 23 | 0 | |
p01204 | C++ | Runtime Error | #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 EPS (1e-7)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
// 作成中 VerifyしたものにはVerifyと書いてある
// Verify AOJ 0115
class Point3d {
public:
double x, y, z;
Point3d(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
Point3d operator+(const Point3d &a) {
return Point3d(x + a.x, y + a.y, z + a.z);
}
Point3d operator-(const Point3d &a) {
return Point3d(x - a.x, y - a.y, z - a.z);
}
Point3d operator*(const double &d) { return Point3d(x * d, y * d, z * d); }
Point3d operator/(const double &d) { return Point3d(x / d, y / d, z / d); }
bool operator<(const Point3d &p) const {
return !equals(x, p.x) ? x < p.x : ((!equals(y, p.y)) ? y < p.y : z < p.z);
}
bool operator==(const Point3d &p) const {
return equals(x, p.x) && equals(y, p.y) && equals(z, p.z);
}
};
// Verify AOJ 0115
struct Segment3d {
Point3d p[2];
Segment3d(Point3d p1 = Point3d(), Point3d p2 = Point3d()) {
p[0] = p1, p[1] = p2;
}
bool operator==(const Segment3d &seg) const {
return p[0] == seg.p[0] && p[1] == seg.p[1];
}
};
typedef Point3d Vector3d;
typedef Segment3d Line3d;
ostream &operator<<(ostream &os, const Point3d &p) {
os << "(" << p.x << "," << p.y << "," << p.z << ")";
}
ostream &operator<<(ostream &os, const Segment3d &seg) {
os << "(" << seg.p[0] << "," << seg.p[1] << ")";
}
// Verify AOJ 0115
double dot(const Point3d &a, const Point3d &b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
// Verify AOJ 0115
Vector3d cross(const Point3d &a, const Point3d &b) {
return Vector3d(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x);
}
// Verify AOJ 0115
inline double norm(const Point3d &p) {
return p.x * p.x + p.y * p.y + p.z * p.z;
}
// Verify AOJ 0115
inline double abs(const Point3d &p) { return sqrt(norm(p)); }
inline double toRad(double theta) { return theta * M_PI / 180.0; }
bool on_line3d(Line3d line, Point3d p) {
return equals(abs(cross(p - line.p[0], line.p[1] - line.p[0])), 0);
}
bool on_segment3d(Segment3d seg, Point3d p) {
if (!on_line3d(seg, p))
return false;
double dist[3] = {abs(seg.p[1] - seg.p[0]), abs(p - seg.p[0]),
abs(p - seg.p[1])};
return on_line3d(seg, p) && equals(dist[0], dist[1] + dist[2]);
}
// Verify AOJ 0115
bool point_on_the_triangle3d(Point3d tri1, Point3d tri2, Point3d tri3,
Point3d p) {
// 線分上にpがあった場合、三角形内とみなす
// if( on_segment3d(Segment3d(tri1,tri2),p) ) return true;
// if( on_segment3d(Segment3d(tri2,tri3),p) ) return true;
// if( on_segment3d(Segment3d(tri3,tri1),p) ) return true;
Vector3d v1 = tri2 - tri1;
Vector3d v2 = tri3 - tri2;
Vector3d v3 = tri1 - tri3;
Vector3d cp[3] = {cross(v1, p - tri1), cross(v2, p - tri2),
cross(v3, p - tri3)};
double d1 = dot(cp[0], cp[1]);
double d2 = dot(cp[0], cp[2]);
// 線分上にpがあった場合,三角形内とはみなさない
// if( ( !equals(d1,0.0) && d1 > 0 ) && ( !equals(d2,0.0) && d2 > 0 ) ) return
// true;
// 線分上にpがあった場合,三角形内とみなす
if ((equals(d1, 0.0) || d1 > 0) && (equals(d2, 0.0) || d2 > 0))
return true;
return false;
}
inline Point3d rotateX(Point3d p, double rad) {
return Point3d(p.x, p.y * cos(rad) - p.z * sin(rad),
p.y * sin(rad) + p.z * cos(rad));
}
inline Point3d rorateY(Point3d p, double rad) {
return Point3d(p.x * cos(rad) + p.z * sin(rad), p.y,
-p.x * sin(rad) + p.z * cos(rad));
}
inline Point3d rorateZ(Point3d p, double rad) {
return Point3d(p.x * cos(rad) - p.y * sin(rad),
p.x * sin(rad) + p.y * cos(rad), p.z);
}
inline Point3d rotateEuler(Point3d p, double alpha, double beta, double gamma) {
return Point3d(
(cos(alpha) * cos(beta) * cos(gamma) - sin(alpha) * sin(gamma)) * p.x +
(-cos(alpha) * cos(beta) * sin(gamma) - sin(alpha) * cos(gamma)) *
p.y +
(cos(alpha) * sin(beta)) * p.z,
(sin(alpha) * cos(beta) * cos(gamma) + cos(alpha) * sin(gamma)) * p.x +
(-sin(alpha) * cos(beta) * sin(gamma) + cos(alpha) * cos(gamma)) *
p.y +
(sin(alpha) * sin(beta)) * p.z,
(-sin(beta) * cos(gamma)) * p.x + (sin(beta) * sin(gamma)) * p.y +
(cos(beta)) * p.z);
}
inline Point3d rotateRollPitchYaw(Point3d p, double roll, double pitch,
double yaw) {
return Point3d(
(cos(roll) * cos(pitch)) * p.x +
(cos(roll) * sin(pitch) * sin(yaw) - sin(roll) * cos(yaw)) * p.y +
(cos(roll) * sin(pitch) * cos(yaw) + sin(roll) * sin(yaw)) * p.z,
(sin(roll) * cos(pitch)) * p.x +
(sin(roll) * sin(pitch) * sin(yaw) + cos(roll) * cos(yaw)) * p.y +
(sin(roll) * sin(pitch) * cos(yaw) - cos(roll) * sin(yaw)) * p.z,
-sin(pitch) * p.x + cos(pitch) * sin(yaw) * p.y +
cos(pitch) * cos(yaw) * p.z);
}
class Plane3d {
public:
Point3d normal_vector; // 法線ベクトル
double d; // 平面方程式 normal_vector.x * x + normal_vector.y * y +
// normal_vector.z * z + d = 0
Plane3d(Point3d normal_vector = Point3d(), double d = 0)
: normal_vector(normal_vector), d(d) {}
Plane3d(Vector3d a, Vector3d b, Vector3d c) {
Vector3d v1 = b - a;
Vector3d v2 = c - a;
Vector3d tmp = cross(v1, v2);
normal_vector = tmp / abs(tmp);
set_d(a);
}
// Verify AOJ 0115
// 法線ベクトルnormal_vectorと平面上の１点からdを計算する
void set_d(Point3d p) { d = dot(normal_vector, p); }
// 平面と点pの距離を求める
double distanceP(Point3d p) {
Point3d a = normal_vector * d; // 平面上の適当な点をつくる
return abs(dot(p - a, normal_vector));
}
// 平面上でもっとも点pと近い点を求める
Point3d nearest_point(Point3d p) {
Point3d a = normal_vector * d;
return p - (normal_vector * dot(p - a, normal_vector));
}
// Verify AOJ 0115
// 平面と線分が交差するか
bool intersectS(Segment3d seg) {
Point3d a = normal_vector * d;
double res1 = dot(a - seg.p[0], normal_vector);
double res2 = dot(a - seg.p[1], normal_vector);
if (res1 > res2)
swap(res1, res2);
// cout << res1 << " < " << res2 << endl;
if ((equals(res1, 0.0) || res1 < 0) && (equals(res2, 0.0) || res2 > 0))
return true;
return false;
}
// Verify AOJ 0115
// 平面と線分の交点を求める
Point3d crosspointS(Segment3d seg) {
Point3d a = normal_vector * d;
double dot_p0a = fabs(dot(seg.p[0] - a, normal_vector));
double dot_p1a = fabs(dot(seg.p[1] - a, normal_vector));
if (equals(dot_p0a + dot_p1a, 0))
return seg.p[0];
return seg.p[0] + (seg.p[1] - seg.p[0]) * (dot_p0a / (dot_p0a + dot_p1a));
}
};
double distanceLP(Line3d line, Point3d p) {
return abs(cross(line.p[1] - line.p[0], p - line.p[0])) /
abs(line.p[1] - line.p[0]);
}
Point3d project(Segment3d seg, Point3d p) {
Vector3d base = seg.p[1] - seg.p[0];
double t = dot(p - seg.p[0], base) / norm(base);
return seg.p[0] + base * t;
}
Point3d reflect(Segment3d seg, Point3d p) {
return p + (project(seg, p) - p) * 2.0;
}
// Verify AOJ 2081
bool isParallel(Line3d l1, Line3d l2) {
Vector3d A = l1.p[0], B = l1.p[1], C = l2.p[0], D = l2.p[1];
Vector3d AB = B - A, CD = D - C;
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double tmp = dot(n1, n2);
tmp = 1 - tmp * tmp;
return equals(tmp, 0.0);
}
// Verify AOJ 2081
// l1,l2が平行な時には使用できないので注意
Segment3d nearest_segmentLL(Line3d l1, Line3d l2) {
assert(isParallel(l1, l2)); // 平行な場合は使用不可
// l1.p[0] = A, l1.p[1] = B, l2.p[0] = C, l2.p[1] = D
Vector3d AB = l1.p[1] - l1.p[0];
Vector3d CD = l2.p[1] - l2.p[0];
Vector3d AC = l2.p[0] - l1.p[0];
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double d1 =
(dot(n1, AC) - dot(n1, n2) * dot(n2, AC)) / (1.0 - pow(dot(n1, n2), 2));
double d2 =
(dot(n1, n2) * dot(n1, AC) - dot(n2, AC)) / (1.0 - pow(dot(n1, n2), 2));
return Segment3d(l1.p[0] + n1 * d1, l2.p[0] + n2 * d2);
}
// Verify AOJ 2081
bool intersectLL(Line3d l1, Line3d l2) {
Vector3d A = l1.p[0], B = l1.p[1], C = l2.p[0], D = l2.p[1];
// そもそもl1,l2が直線じゃない
if (equals(abs(B - A), 0.0) || equals(abs(D - C), 0.0)) {
/*
この場合は注意
そもそも与えられた線分が線分になっていないので、交差するかどうかは判定できない
*/
return false;
}
Vector3d AB = B - A, CD = D - C;
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double tmp = dot(n1, n2);
tmp = 1 - tmp * tmp;
if (equals(tmp, 0.0))
return 0; // 直線が平行
Segment3d ns = nearest_segmentLL(l1, l2);
if (ns.p[0] == ns.p[1])
return true;
return false;
}
bool intersectSS(Segment3d seg1, Segment3d seg2) {
if (isParallel(seg1, seg2))
return false;
Segment3d seg = nearest_segmentLL(seg1, seg2);
if (!(seg.p[0] == seg.p[1]))
return false;
Point3d cp = seg.p[1];
return on_segment3d(seg1, cp) && on_segment3d(seg2, cp);
}
Line3d line[110];
Point3d source_p, sink_p;
int source, sink;
double fw[110][110];
int main() {
int N;
while (cin >> N, N) {
cin >> source_p.x >> source_p.y >> source_p.z >> sink_p.x >> sink_p.y >>
sink_p.z;
source = sink = -1;
rep(i, N) {
rep(j, 2) cin >> line[i].p[j].x >> line[i].p[j].y >> line[i].p[j].z;
if (on_line3d(line[i], source_p)) {
assert(source == -1);
source = i;
}
if (on_line3d(line[i], sink_p)) {
assert(sink == -1);
sink = i;
}
}
assert(source != -1 && sink != -1);
rep(i, N) rep(j, N) fw[i][j] = IINF;
rep(i, N) REP(j, i, N) {
if (i == j)
fw[i][j] = 0;
else if (isParallel(line[i], line[j])) {
double area = abs(
cross(line[i].p[1] - line[i].p[0], line[j].p[1] - line[i].p[0]));
fw[i][j] = fw[j][i] = area / abs(line[i].p[1] - line[i].p[0]);
} else if (!intersectLL(line[i], line[j])) {
Segment3d seg = nearest_segmentLL(line[i], line[j]);
fw[i][j] = fw[j][i] = abs(seg.p[1] - seg.p[0]);
}
}
rep(k, N) rep(i, N)
rep(j, N) if (!equals(fw[i][k], IINF) && !equals(fw[k][j], IINF))
fw[i][j] = min(fw[i][j], fw[i][k] + fw[k][j]);
printf("%.4f\n", fw[source][sink]);
}
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 EPS (1e-7)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
// 作成中 VerifyしたものにはVerifyと書いてある
// Verify AOJ 0115
class Point3d {
public:
double x, y, z;
Point3d(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
Point3d operator+(const Point3d &a) {
return Point3d(x + a.x, y + a.y, z + a.z);
}
Point3d operator-(const Point3d &a) {
return Point3d(x - a.x, y - a.y, z - a.z);
}
Point3d operator*(const double &d) { return Point3d(x * d, y * d, z * d); }
Point3d operator/(const double &d) { return Point3d(x / d, y / d, z / d); }
bool operator<(const Point3d &p) const {
return !equals(x, p.x) ? x < p.x : ((!equals(y, p.y)) ? y < p.y : z < p.z);
}
bool operator==(const Point3d &p) const {
return equals(x, p.x) && equals(y, p.y) && equals(z, p.z);
}
};
// Verify AOJ 0115
struct Segment3d {
Point3d p[2];
Segment3d(Point3d p1 = Point3d(), Point3d p2 = Point3d()) {
p[0] = p1, p[1] = p2;
}
bool operator==(const Segment3d &seg) const {
return p[0] == seg.p[0] && p[1] == seg.p[1];
}
};
typedef Point3d Vector3d;
typedef Segment3d Line3d;
ostream &operator<<(ostream &os, const Point3d &p) {
os << "(" << p.x << "," << p.y << "," << p.z << ")";
}
ostream &operator<<(ostream &os, const Segment3d &seg) {
os << "(" << seg.p[0] << "," << seg.p[1] << ")";
}
// Verify AOJ 0115
double dot(const Point3d &a, const Point3d &b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}
// Verify AOJ 0115
Vector3d cross(const Point3d &a, const Point3d &b) {
return Vector3d(a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x);
}
// Verify AOJ 0115
inline double norm(const Point3d &p) {
return p.x * p.x + p.y * p.y + p.z * p.z;
}
// Verify AOJ 0115
inline double abs(const Point3d &p) { return sqrt(norm(p)); }
inline double toRad(double theta) { return theta * M_PI / 180.0; }
bool on_line3d(Line3d line, Point3d p) {
return equals(abs(cross(p - line.p[0], line.p[1] - line.p[0])), 0);
}
bool on_segment3d(Segment3d seg, Point3d p) {
if (!on_line3d(seg, p))
return false;
double dist[3] = {abs(seg.p[1] - seg.p[0]), abs(p - seg.p[0]),
abs(p - seg.p[1])};
return on_line3d(seg, p) && equals(dist[0], dist[1] + dist[2]);
}
// Verify AOJ 0115
bool point_on_the_triangle3d(Point3d tri1, Point3d tri2, Point3d tri3,
Point3d p) {
// 線分上にpがあった場合、三角形内とみなす
// if( on_segment3d(Segment3d(tri1,tri2),p) ) return true;
// if( on_segment3d(Segment3d(tri2,tri3),p) ) return true;
// if( on_segment3d(Segment3d(tri3,tri1),p) ) return true;
Vector3d v1 = tri2 - tri1;
Vector3d v2 = tri3 - tri2;
Vector3d v3 = tri1 - tri3;
Vector3d cp[3] = {cross(v1, p - tri1), cross(v2, p - tri2),
cross(v3, p - tri3)};
double d1 = dot(cp[0], cp[1]);
double d2 = dot(cp[0], cp[2]);
// 線分上にpがあった場合,三角形内とはみなさない
// if( ( !equals(d1,0.0) && d1 > 0 ) && ( !equals(d2,0.0) && d2 > 0 ) ) return
// true;
// 線分上にpがあった場合,三角形内とみなす
if ((equals(d1, 0.0) || d1 > 0) && (equals(d2, 0.0) || d2 > 0))
return true;
return false;
}
inline Point3d rotateX(Point3d p, double rad) {
return Point3d(p.x, p.y * cos(rad) - p.z * sin(rad),
p.y * sin(rad) + p.z * cos(rad));
}
inline Point3d rorateY(Point3d p, double rad) {
return Point3d(p.x * cos(rad) + p.z * sin(rad), p.y,
-p.x * sin(rad) + p.z * cos(rad));
}
inline Point3d rorateZ(Point3d p, double rad) {
return Point3d(p.x * cos(rad) - p.y * sin(rad),
p.x * sin(rad) + p.y * cos(rad), p.z);
}
inline Point3d rotateEuler(Point3d p, double alpha, double beta, double gamma) {
return Point3d(
(cos(alpha) * cos(beta) * cos(gamma) - sin(alpha) * sin(gamma)) * p.x +
(-cos(alpha) * cos(beta) * sin(gamma) - sin(alpha) * cos(gamma)) *
p.y +
(cos(alpha) * sin(beta)) * p.z,
(sin(alpha) * cos(beta) * cos(gamma) + cos(alpha) * sin(gamma)) * p.x +
(-sin(alpha) * cos(beta) * sin(gamma) + cos(alpha) * cos(gamma)) *
p.y +
(sin(alpha) * sin(beta)) * p.z,
(-sin(beta) * cos(gamma)) * p.x + (sin(beta) * sin(gamma)) * p.y +
(cos(beta)) * p.z);
}
inline Point3d rotateRollPitchYaw(Point3d p, double roll, double pitch,
double yaw) {
return Point3d(
(cos(roll) * cos(pitch)) * p.x +
(cos(roll) * sin(pitch) * sin(yaw) - sin(roll) * cos(yaw)) * p.y +
(cos(roll) * sin(pitch) * cos(yaw) + sin(roll) * sin(yaw)) * p.z,
(sin(roll) * cos(pitch)) * p.x +
(sin(roll) * sin(pitch) * sin(yaw) + cos(roll) * cos(yaw)) * p.y +
(sin(roll) * sin(pitch) * cos(yaw) - cos(roll) * sin(yaw)) * p.z,
-sin(pitch) * p.x + cos(pitch) * sin(yaw) * p.y +
cos(pitch) * cos(yaw) * p.z);
}
class Plane3d {
public:
Point3d normal_vector; // 法線ベクトル
double d; // 平面方程式 normal_vector.x * x + normal_vector.y * y +
// normal_vector.z * z + d = 0
Plane3d(Point3d normal_vector = Point3d(), double d = 0)
: normal_vector(normal_vector), d(d) {}
Plane3d(Vector3d a, Vector3d b, Vector3d c) {
Vector3d v1 = b - a;
Vector3d v2 = c - a;
Vector3d tmp = cross(v1, v2);
normal_vector = tmp / abs(tmp);
set_d(a);
}
// Verify AOJ 0115
// 法線ベクトルnormal_vectorと平面上の１点からdを計算する
void set_d(Point3d p) { d = dot(normal_vector, p); }
// 平面と点pの距離を求める
double distanceP(Point3d p) {
Point3d a = normal_vector * d; // 平面上の適当な点をつくる
return abs(dot(p - a, normal_vector));
}
// 平面上でもっとも点pと近い点を求める
Point3d nearest_point(Point3d p) {
Point3d a = normal_vector * d;
return p - (normal_vector * dot(p - a, normal_vector));
}
// Verify AOJ 0115
// 平面と線分が交差するか
bool intersectS(Segment3d seg) {
Point3d a = normal_vector * d;
double res1 = dot(a - seg.p[0], normal_vector);
double res2 = dot(a - seg.p[1], normal_vector);
if (res1 > res2)
swap(res1, res2);
// cout << res1 << " < " << res2 << endl;
if ((equals(res1, 0.0) || res1 < 0) && (equals(res2, 0.0) || res2 > 0))
return true;
return false;
}
// Verify AOJ 0115
// 平面と線分の交点を求める
Point3d crosspointS(Segment3d seg) {
Point3d a = normal_vector * d;
double dot_p0a = fabs(dot(seg.p[0] - a, normal_vector));
double dot_p1a = fabs(dot(seg.p[1] - a, normal_vector));
if (equals(dot_p0a + dot_p1a, 0))
return seg.p[0];
return seg.p[0] + (seg.p[1] - seg.p[0]) * (dot_p0a / (dot_p0a + dot_p1a));
}
};
double distanceLP(Line3d line, Point3d p) {
return abs(cross(line.p[1] - line.p[0], p - line.p[0])) /
abs(line.p[1] - line.p[0]);
}
Point3d project(Segment3d seg, Point3d p) {
Vector3d base = seg.p[1] - seg.p[0];
double t = dot(p - seg.p[0], base) / norm(base);
return seg.p[0] + base * t;
}
Point3d reflect(Segment3d seg, Point3d p) {
return p + (project(seg, p) - p) * 2.0;
}
// Verify AOJ 2081
bool isParallel(Line3d l1, Line3d l2) {
Vector3d A = l1.p[0], B = l1.p[1], C = l2.p[0], D = l2.p[1];
Vector3d AB = B - A, CD = D - C;
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double tmp = dot(n1, n2);
tmp = 1 - tmp * tmp;
return equals(tmp, 0.0);
}
// Verify AOJ 2081
// l1,l2が平行な時には使用できないので注意
Segment3d nearest_segmentLL(Line3d l1, Line3d l2) {
assert(!isParallel(l1, l2)); // 平行な場合は使用不可
// l1.p[0] = A, l1.p[1] = B, l2.p[0] = C, l2.p[1] = D
Vector3d AB = l1.p[1] - l1.p[0];
Vector3d CD = l2.p[1] - l2.p[0];
Vector3d AC = l2.p[0] - l1.p[0];
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double d1 =
(dot(n1, AC) - dot(n1, n2) * dot(n2, AC)) / (1.0 - pow(dot(n1, n2), 2));
double d2 =
(dot(n1, n2) * dot(n1, AC) - dot(n2, AC)) / (1.0 - pow(dot(n1, n2), 2));
return Segment3d(l1.p[0] + n1 * d1, l2.p[0] + n2 * d2);
}
// Verify AOJ 2081
bool intersectLL(Line3d l1, Line3d l2) {
Vector3d A = l1.p[0], B = l1.p[1], C = l2.p[0], D = l2.p[1];
// そもそもl1,l2が直線じゃない
if (equals(abs(B - A), 0.0) || equals(abs(D - C), 0.0)) {
/*
この場合は注意
そもそも与えられた線分が線分になっていないので、交差するかどうかは判定できない
*/
return false;
}
Vector3d AB = B - A, CD = D - C;
Vector3d n1 = AB / abs(AB), n2 = CD / abs(CD);
double tmp = dot(n1, n2);
tmp = 1 - tmp * tmp;
if (equals(tmp, 0.0))
return 0; // 直線が平行
Segment3d ns = nearest_segmentLL(l1, l2);
if (ns.p[0] == ns.p[1])
return true;
return false;
}
bool intersectSS(Segment3d seg1, Segment3d seg2) {
if (isParallel(seg1, seg2))
return false;
Segment3d seg = nearest_segmentLL(seg1, seg2);
if (!(seg.p[0] == seg.p[1]))
return false;
Point3d cp = seg.p[1];
return on_segment3d(seg1, cp) && on_segment3d(seg2, cp);
}
Line3d line[110];
Point3d source_p, sink_p;
int source, sink;
double fw[110][110];
int main() {
int N;
while (cin >> N, N) {
cin >> source_p.x >> source_p.y >> source_p.z >> sink_p.x >> sink_p.y >>
sink_p.z;
source = sink = -1;
rep(i, N) {
rep(j, 2) cin >> line[i].p[j].x >> line[i].p[j].y >> line[i].p[j].z;
if (on_line3d(line[i], source_p)) {
assert(source == -1);
source = i;
}
if (on_line3d(line[i], sink_p)) {
assert(sink == -1);
sink = i;
}
}
assert(source != -1 && sink != -1);
rep(i, N) rep(j, N) fw[i][j] = IINF;
rep(i, N) REP(j, i, N) {
if (i == j)
fw[i][j] = 0;
else if (isParallel(line[i], line[j])) {
double area = abs(
cross(line[i].p[1] - line[i].p[0], line[j].p[1] - line[i].p[0]));
fw[i][j] = fw[j][i] = area / abs(line[i].p[1] - line[i].p[0]);
} else if (!intersectLL(line[i], line[j])) {
Segment3d seg = nearest_segmentLL(line[i], line[j]);
fw[i][j] = fw[j][i] = abs(seg.p[1] - seg.p[0]);
}
}
rep(k, N) rep(i, N)
rep(j, N) if (!equals(fw[i][k], IINF) && !equals(fw[k][j], IINF))
fw[i][j] = min(fw[i][j], fw[i][k] + fw[k][j]);
printf("%.4f\n", fw[source][sink]);
}
return 0;
} | replace | 248 | 249 | 248 | 249 | -6 | 1d612717-5c0d-4ded-b1cb-d9ae4fbfa129.out: /home/alex/Documents/bug-detection/input/Project_CodeNet/data/p01204/C++/s776448578.cpp:236: Segment3d nearest_segmentLL(Line3d, Line3d): Assertion `isParallel(l1,l2)' failed.
|
p01207 | C++ | Time Limit Exceeded | #include <cstdio>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
bool is_valid(const char *a, const char *b, int hit, int blow) {
rep(i, 4) rep(j, 4) if (a[i] == b[j]) {
if (i == j)
hit--;
else
blow--;
}
return hit == 0 && blow == 0;
}
int main() {
vector<int> cand0; // どの桁の数字も異なるような 4 桁の数
rep(i, 10000) {
char s[5];
sprintf(s, "%04d", i);
if (!(s[0] == s[1] || s[0] == s[2] || s[0] == s[3] || s[1] == s[2] ||
s[1] == s[3] || s[2] == s[3]))
cand0.push_back(i);
}
for (int n; scanf("%d", &n), n;) {
vector<int> in(n), hit(n), blow(n);
rep(i, n) scanf("%d%d%d", &in[i], &hit[i], &blow[i]);
// 入力された質問に矛盾しない数全体
vector<int> cand;
rep(j, cand0.size()) {
char s[5];
sprintf(s, "%04d", cand0[j]);
bool ok = true;
rep(i, n) {
char t[5];
sprintf(t, "%04d", in[i]);
if (!is_valid(s, t, hit[i], blow[i])) {
ok = false;
break;
}
}
if (ok)
cand.push_back(cand0[j]);
}
if (cand.size() == 1) {
printf("%04d\n", cand[0]);
continue;
}
int ans = -1;
rep(i, cand0.size()) {
char s[5];
sprintf(s, "%04d", cand0[i]); // 最後の 1 回に発言するべき数
bool ok = true;
vector<int> reply(cand.size());
rep(j, cand.size()) {
char t[5];
sprintf(t, "%04d", cand[j]);
int hit = 0, blow = 0;
rep(k, 4) rep(l, 4) if (s[k] == t[l]) {
if (k == l)
hit++;
else
blow++;
}
reply[j] = hit * 10 + blow;
rep(k, j) if (reply[k] == reply[j]) {
ok = false;
break;
}
}
if (ok) { // 真の解がどれであったとしても特定できるとき
if (ans == -1) {
ans = cand0[i];
break;
}
}
}
if (ans != -1)
printf("%04d\n", ans);
else
puts("????");
}
return 0;
} | #include <cstdio>
#include <vector>
#define rep(i, n) for (int i = 0; i < (n); i++)
using namespace std;
bool is_valid(const char *a, const char *b, int hit, int blow) {
rep(i, 4) rep(j, 4) if (a[i] == b[j]) {
if (i == j)
hit--;
else
blow--;
}
return hit == 0 && blow == 0;
}
int main() {
vector<int> cand0; // どの桁の数字も異なるような 4 桁の数
rep(i, 10000) {
char s[5];
sprintf(s, "%04d", i);
if (!(s[0] == s[1] || s[0] == s[2] || s[0] == s[3] || s[1] == s[2] ||
s[1] == s[3] || s[2] == s[3]))
cand0.push_back(i);
}
for (int n; scanf("%d", &n), n;) {
vector<int> in(n), hit(n), blow(n);
rep(i, n) scanf("%d%d%d", &in[i], &hit[i], &blow[i]);
// 入力された質問に矛盾しない数全体
vector<int> cand;
rep(j, cand0.size()) {
char s[5];
sprintf(s, "%04d", cand0[j]);
bool ok = true;
rep(i, n) {
char t[5];
sprintf(t, "%04d", in[i]);
if (!is_valid(s, t, hit[i], blow[i])) {
ok = false;
break;
}
}
if (ok)
cand.push_back(cand0[j]);
}
if (cand.size() == 1) {
printf("%04d\n", cand[0]);
continue;
}
if (cand.size() > 16) {
puts("????");
continue;
}
int ans = -1;
rep(i, cand0.size()) {
char s[5];
sprintf(s, "%04d", cand0[i]); // 最後の 1 回に発言するべき数
bool ok = true;
vector<int> reply(cand.size());
rep(j, cand.size()) {
char t[5];
sprintf(t, "%04d", cand[j]);
int hit = 0, blow = 0;
rep(k, 4) rep(l, 4) if (s[k] == t[l]) {
if (k == l)
hit++;
else
blow++;
}
reply[j] = hit * 10 + blow;
rep(k, j) if (reply[k] == reply[j]) {
ok = false;
break;
}
}
if (ok) { // 真の解がどれであったとしても特定できるとき
if (ans == -1) {
ans = cand0[i];
break;
}
}
}
if (ans != -1)
printf("%04d\n", ans);
else
puts("????");
}
return 0;
} | insert | 54 | 54 | 54 | 59 | TLE | |
p01208 | C++ | Runtime Error | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1 << 29;
typedef long long ll;
typedef pair<int, int> pii;
int X[1000];
int Y[1000];
int dir(int a, int b) {
if (X[a] == X[b]) {
if (Y[a] < Y[b])
return 0;
else
return 2;
} else {
if (X[a] < X[b])
return 1;
else
return 3;
}
}
int dis(int a, int b) { return abs(X[a] - X[b]) + abs(Y[a] - Y[b]); }
struct P {
int now, d, cost, len;
P(int now, int d, int cost, int len) : now(now), d(d), cost(cost), len(len) {}
bool operator<(const P &b) const {
return cost != b.cost ? cost > b.cost : len > b.len;
}
};
pii g[1000][4];
int dist[1000][4];
string name[1000];
int main() {
int m, n;
while (cin >> m >> n, m || n) {
map<string, int> mp;
REP(i, m) {
cin >> name[i] >> X[i] >> Y[i];
mp[name[i]] = i;
}
REP(i, n) REP(j, 4) g[i][j] = pii(-1, 0);
REP(i, n) {
string s, t;
cin >> s >> t;
int a = mp[s];
int b = mp[t];
g[a][dir(a, b)] = pii(b, dis(a, b));
g[b][dir(b, a)] = pii(a, dis(a, b));
}
string s, t;
cin >> s >> t;
int start = mp[s];
int end = mp[t];
priority_queue<P> Q;
REP(i, m) REP(j, 4) dist[i][j] = INF;
REP(i, 4) {
Q.push(P(start, i, 0, 1));
dist[start][i] = 0;
}
int ans = INF;
while (!Q.empty()) {
P p = Q.top();
Q.pop();
int nd = (p.d + 3) % 4;
int now = p.now;
if (dist[now][p.d] > p.cost)
continue;
int dd[2] = {p.d, nd};
// cout << now << " " << p.d << endl;
if (now == end) {
ans = p.len;
break;
}
REP(i, 2) {
pii e = g[now][dd[i]];
int b = e.first;
if (b != -1) {
int nd = dist[now][p.d] + e.second;
if (dist[b][dd[i]] > nd) {
dist[b][dd[i]] = nd;
Q.push(P(b, dd[i], nd, p.len + 1));
}
}
}
}
if (ans == INF)
cout << "impossible" << endl;
else
cout << ans << endl;
}
} | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
#define REP(i, n) for (int i = 0; i < (int)n; ++i)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
#define ALL(c) (c).begin(), (c).end()
const int INF = 1 << 29;
typedef long long ll;
typedef pair<int, int> pii;
int X[1000];
int Y[1000];
int dir(int a, int b) {
if (X[a] == X[b]) {
if (Y[a] < Y[b])
return 0;
else
return 2;
} else {
if (X[a] < X[b])
return 1;
else
return 3;
}
}
int dis(int a, int b) { return abs(X[a] - X[b]) + abs(Y[a] - Y[b]); }
struct P {
int now, d, cost, len;
P(int now, int d, int cost, int len) : now(now), d(d), cost(cost), len(len) {}
bool operator<(const P &b) const {
return cost != b.cost ? cost > b.cost : len > b.len;
}
};
pii g[1000][4];
int dist[1000][4];
string name[1000];
int main() {
int m, n;
while (cin >> m >> n, m || n) {
map<string, int> mp;
REP(i, m) {
cin >> name[i] >> X[i] >> Y[i];
mp[name[i]] = i;
}
REP(i, m) REP(j, 4) g[i][j] = pii(-1, 0);
REP(i, n) {
string s, t;
cin >> s >> t;
int a = mp[s];
int b = mp[t];
g[a][dir(a, b)] = pii(b, dis(a, b));
g[b][dir(b, a)] = pii(a, dis(a, b));
}
string s, t;
cin >> s >> t;
int start = mp[s];
int end = mp[t];
priority_queue<P> Q;
REP(i, m) REP(j, 4) dist[i][j] = INF;
REP(i, 4) {
Q.push(P(start, i, 0, 1));
dist[start][i] = 0;
}
int ans = INF;
while (!Q.empty()) {
P p = Q.top();
Q.pop();
int nd = (p.d + 3) % 4;
int now = p.now;
if (dist[now][p.d] > p.cost)
continue;
int dd[2] = {p.d, nd};
// cout << now << " " << p.d << endl;
if (now == end) {
ans = p.len;
break;
}
REP(i, 2) {
pii e = g[now][dd[i]];
int b = e.first;
if (b != -1) {
int nd = dist[now][p.d] + e.second;
if (dist[b][dd[i]] > nd) {
dist[b][dd[i]] = nd;
Q.push(P(b, dd[i], nd, p.len + 1));
}
}
}
}
if (ans == INF)
cout << "impossible" << endl;
else
cout << ans << endl;
}
} | replace | 66 | 67 | 66 | 67 | 0 | |
p01209 | 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))
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;
ll convert(char c) {
if (isdigit(c))
return c - '0';
else
return c - 'A' + 10;
}
const int prime[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int main(void) {
ll n;
string m;
while (cin >> n >> m, n) {
ll num[11] = {0};
ll mten = 0LL;
for (auto &d : m)
mten = n * mten + convert(d);
rep(i, 11) {
ll cur = prime[i];
while (cur < mten)
num[i] += mten / cur, cur *= prime[i];
}
ll ans = -1LL;
rep(i, 11) {
ll cur = n, coef = 0LL;
while (cur % prime[i] == 0)
cur /= prime[i], coef++;
if (coef == 0)
continue;
if (ans == -1)
ans = num[i] / coef;
else
chmin(ans, num[i] / coef);
}
cout << ans << 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))
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;
ll convert(char c) {
if (isdigit(c))
return c - '0';
else
return c - 'A' + 10;
}
const int prime[11] = {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31};
int main(void) {
ll n;
string m;
while (cin >> n >> m, n) {
ll num[11] = {0};
ll mten = 0LL;
for (auto &d : m)
mten = n * mten + convert(d);
rep(i, 11) {
ll cur = prime[i];
while (1) {
num[i] += mten / cur;
if (cur > mten / prime[i])
break;
cur *= prime[i];
}
}
ll ans = -1LL;
rep(i, 11) {
ll cur = n, coef = 0LL;
while (cur % prime[i] == 0)
cur /= prime[i], coef++;
if (coef == 0)
continue;
if (ans == -1)
ans = num[i] / coef;
else
chmin(ans, num[i] / coef);
}
cout << ans << endl;
}
return 0;
} | replace | 47 | 49 | 47 | 53 | 0 | |
p01213 | C++ | Time Limit Exceeded | #include <iostream>
#include <string>
using namespace std;
int n;
string S, dp[320][320];
int dp2[320][320];
inline string LCS(string &a1, string &a2) {
for (int i = 0; i <= a1.size(); i++) {
for (int j = 0; j <= a2.size(); j++)
dp2[i][j] = -1;
}
dp2[0][0] = 0;
for (int i = 0; i <= a1.size(); i++)
dp[i][0] = "";
for (int i = 0; i <= a2.size(); i++)
dp[0][i] = "";
for (int i = 0; i <= a1.size(); i++) {
for (int j = 0; j <= a2.size(); j++) {
if (i < a1.size() && j < a2.size() && a1[i] == a2[j]) {
if (dp2[i + 1][j + 1] < dp2[i][j] + 1) {
dp[i + 1][j + 1] = dp[i][j] + a1[i];
dp2[i + 1][j + 1] = dp2[i][j] + 1;
}
}
if (dp2[i + 1][j] < dp2[i][j]) {
dp[i + 1][j] = dp[i][j];
dp2[i + 1][j] = dp2[i][j];
}
if (dp2[i][j + 1] < dp2[i][j]) {
dp[i][j + 1] = dp[i][j];
dp2[i + 1][j] = dp2[i][j];
}
}
}
return dp[a1.size()][a2.size()];
}
int main() {
while (cin >> S) {
for (int i = 0; i < 102400; i++)
dp[i / 320][i % 320] = "";
if (S == "#END")
break;
n = S.size();
string V = "";
for (int i = 1; i < n; i++) {
string T = S.substr(0, i), U = S.substr(i, n - i);
string W = LCS(T, U);
if (V.size() < W.size())
V = W;
}
cout << V << endl;
}
return 0;
} | #include <iostream>
#include <string>
using namespace std;
int n;
string S, dp[320][320];
int dp2[320][320];
inline string LCS(string &a1, string &a2) {
for (int i = 0; i <= a1.size(); i++) {
for (int j = 0; j <= a2.size(); j++)
dp2[i][j] = -1;
}
dp2[0][0] = 0;
for (int i = 0; i <= a1.size(); i++)
dp[i][0] = "";
for (int i = 0; i <= a2.size(); i++)
dp[0][i] = "";
for (int i = 0; i <= a1.size(); i++) {
for (int j = 0; j <= a2.size(); j++) {
if (i < a1.size() && j < a2.size() && a1[i] == a2[j]) {
if (dp2[i + 1][j + 1] < dp2[i][j] + 1) {
dp[i + 1][j + 1] = dp[i][j] + a1[i];
dp2[i + 1][j + 1] = dp2[i][j] + 1;
}
}
if (dp2[i + 1][j] < dp2[i][j]) {
dp[i + 1][j] = dp[i][j];
dp2[i + 1][j] = dp2[i][j];
}
if (dp2[i][j + 1] < dp2[i][j]) {
dp[i][j + 1] = dp[i][j];
dp2[i][j + 1] = dp2[i][j];
}
}
}
return dp[a1.size()][a2.size()];
}
int main() {
while (cin >> S) {
for (int i = 0; i < 102400; i++)
dp[i / 320][i % 320] = "";
if (S == "#END")
break;
n = S.size();
string V = "";
for (int i = 1; i < n; i++) {
string T = S.substr(0, i), U = S.substr(i, n - i);
string W = LCS(T, U);
if (V.size() < W.size())
V = W;
}
cout << V << endl;
}
return 0;
} | replace | 30 | 31 | 30 | 31 | TLE | |
p01213 | C++ | Runtime Error | #include <algorithm>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
char str[310];
int dp[310][310];
int rev[310][310];
int main() {
while (1) {
scanf("%s", str);
if (str[0] == '#')
return 0;
int ret = 0;
string ans = "";
int len = strlen(str);
for (int i = 0; str[i + 1]; i++) {
int n = i + 1;
int m = len - m;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= m; k++)
dp[j][k] = -999999;
dp[0][0] = 0;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= m; k++) {
if (j < n && dp[j + 1][k] < dp[j][k]) {
dp[j + 1][k] = dp[j][k];
rev[j + 1][k] = 1;
}
if (k < m && dp[j][k + 1] < dp[j][k]) {
dp[j][k + 1] = dp[j][k];
rev[j][k + 1] = 2;
}
if (j < n && k < m && dp[j + 1][k + 1] < dp[j][k] + 1 &&
str[j] == str[i + 1 + k]) {
dp[j + 1][k + 1] = dp[j][k] + 1;
rev[j + 1][k + 1] = 0;
}
}
if (ret < dp[n][m]) {
ret = dp[n][m];
string to = "";
int tn = n;
int tm = m;
while (tn && tm) {
if (rev[tn][tm] == 1)
tn--;
else if (rev[tn][tm] == 2)
tm--;
else {
tn--;
tm--;
to = str[tn] + to;
}
}
ans = to;
}
}
// printf("%d ",ret);
printf("%s\n", ans.c_str());
}
} | #include <algorithm>
#include <stdio.h>
#include <string.h>
#include <string>
using namespace std;
char str[310];
int dp[310][310];
int rev[310][310];
int main() {
while (1) {
scanf("%s", str);
if (str[0] == '#')
return 0;
int ret = 0;
string ans = "";
int len = strlen(str);
for (int i = 0; str[i + 1]; i++) {
int n = i + 1;
int m = len - n;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= m; k++)
dp[j][k] = -999999;
dp[0][0] = 0;
for (int j = 0; j <= n; j++)
for (int k = 0; k <= m; k++) {
if (j < n && dp[j + 1][k] < dp[j][k]) {
dp[j + 1][k] = dp[j][k];
rev[j + 1][k] = 1;
}
if (k < m && dp[j][k + 1] < dp[j][k]) {
dp[j][k + 1] = dp[j][k];
rev[j][k + 1] = 2;
}
if (j < n && k < m && dp[j + 1][k + 1] < dp[j][k] + 1 &&
str[j] == str[i + 1 + k]) {
dp[j + 1][k + 1] = dp[j][k] + 1;
rev[j + 1][k + 1] = 0;
}
}
if (ret < dp[n][m]) {
ret = dp[n][m];
string to = "";
int tn = n;
int tm = m;
while (tn && tm) {
if (rev[tn][tm] == 1)
tn--;
else if (rev[tn][tm] == 2)
tm--;
else {
tn--;
tm--;
to = str[tn] + to;
}
}
ans = to;
}
}
// printf("%d ",ret);
printf("%s\n", ans.c_str());
}
} | replace | 18 | 19 | 18 | 19 | -11 | |
p01213 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int sz1, sz2;
string s;
vector<int> c[128];
int off[128][322];
int dp[301][301];
pair<int, int> to[301][301];
int flag[301][301];
int dp_search(int sz1, int sz2) {
memset(dp, -1, sizeof(dp));
memset(flag, 0, sizeof(flag));
int r;
dp[0][sz1] = 0;
to[0][sz1] = make_pair(-1, -1);
for (int p1 = 0; p1 <= sz1; p1++) {
for (int p2 = sz1; p2 <= sz2; p2++) {
if (dp[p1][p2] != -1) {
if (p1 < sz1) {
int i = off[s[p1]][p2];
if (sz1 <= i && i < sz2) {
r = dp[p1][p2] + 1;
if (r > dp[p1 + 1][i + 1]) {
to[p1 + 1][i + 1] = make_pair(p1, p2);
dp[p1 + 1][i + 1] = r;
flag[p1 + 1][i + 1] = 1;
}
}
r = dp[p1][p2];
if (r > dp[p1 + 1][p2]) {
to[p1 + 1][p2] = make_pair(p1, p2);
dp[p1 + 1][p2] = r;
}
}
if (p2 < sz2) {
r = dp[p1][p2];
if (r > dp[p1][p2 + 1]) {
to[p1][p2 + 1] = make_pair(p1, p2);
dp[p1][p2 + 1] = r;
}
}
}
}
}
return dp[sz1][sz2];
}
string get(int sz1, int sz2) {
string ans = "";
while (sz1 != -1) {
int x = to[sz1][sz2].first;
int y = to[sz1][sz2].second;
if (flag[sz1][sz2]) {
ans = string(1, s[x]) + ans;
}
sz1 = x;
sz2 = y;
}
return ans;
}
int main() {
while (cin >> s && s[0] != '#') {
int last[26];
for (int i = 0; i < 26; i++)
last[i] = 9999;
for (int i = s.size(); i >= 0; i--) {
last[s[i] - 'A'] = i;
for (int j = 0; j < 26; j++) {
off[j + 'A'][i] = last[j];
}
}
int save[333] = {0};
int currentmx = 0;
for (int i = 1; i < s.size(); i++) {
sz1 = i;
sz2 = s.size();
if (min(sz1, sz2 - sz1) <= currentmx)
continue;
save[i] = dp_search(sz1, sz2);
currentmx = max(save[i], currentmx);
}
for (int i = 1; i < s.size(); i++) {
if (save[i] == currentmx) {
sz1 = i;
sz2 = s.size();
dp_search(sz1, sz2);
cout << get(sz1, sz2) << endl;
break;
}
}
}
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int sz1, sz2;
string s;
vector<int> c[128];
int off[128][322];
int dp[301][301];
pair<int, int> to[301][301];
int flag[301][301];
int dp_search(int sz1, int sz2) {
memset(dp, -1, sizeof(dp));
memset(flag, 0, sizeof(flag));
int r;
dp[0][sz1] = 0;
to[0][sz1] = make_pair(-1, -1);
for (int p1 = 0; p1 <= sz1; p1++) {
for (int p2 = sz1; p2 <= sz2; p2++) {
if (dp[p1][p2] != -1) {
if (p1 < sz1) {
int i = off[s[p1]][p2];
if (i != 9999) {
r = dp[p1][p2] + 1;
if (r > dp[p1 + 1][i + 1]) {
to[p1 + 1][i + 1] = make_pair(p1, p2);
dp[p1 + 1][i + 1] = r;
flag[p1 + 1][i + 1] = 1;
}
}
r = dp[p1][p2];
if (r > dp[p1 + 1][p2]) {
to[p1 + 1][p2] = make_pair(p1, p2);
dp[p1 + 1][p2] = r;
}
}
if (p2 < sz2) {
r = dp[p1][p2];
if (r > dp[p1][p2 + 1]) {
to[p1][p2 + 1] = make_pair(p1, p2);
dp[p1][p2 + 1] = r;
}
}
}
}
}
return dp[sz1][sz2];
}
string get(int sz1, int sz2) {
string ans = "";
while (sz1 != -1) {
int x = to[sz1][sz2].first;
int y = to[sz1][sz2].second;
if (flag[sz1][sz2]) {
ans = string(1, s[x]) + ans;
}
sz1 = x;
sz2 = y;
}
return ans;
}
int main() {
while (cin >> s && s[0] != '#') {
int last[26];
for (int i = 0; i < 26; i++)
last[i] = 9999;
for (int i = s.size(); i >= 0; i--) {
last[s[i] - 'A'] = i;
for (int j = 0; j < 26; j++) {
off[j + 'A'][i] = last[j];
}
}
int save[333] = {0};
int currentmx = 0;
for (int i = 1; i < s.size(); i++) {
sz1 = i;
sz2 = s.size();
if (min(sz1, sz2 - sz1) <= currentmx)
continue;
save[i] = dp_search(sz1, sz2);
currentmx = max(save[i], currentmx);
}
for (int i = 1; i < s.size(); i++) {
if (save[i] == currentmx) {
sz1 = i;
sz2 = s.size();
dp_search(sz1, sz2);
cout << get(sz1, sz2) << endl;
break;
}
}
}
} | replace | 27 | 28 | 27 | 28 | TLE | |
p01214 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#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()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const int inf = 1e8;
vector<string> p, tmp, in;
void turn() {
tmp = vector<string>(p[0].size(), "");
rep(i, p[0].size()) rep(j, p.size()) tmp[i] += p[j][p[0].size() - i - 1];
p = tmp;
}
int f() {
int co = 0;
rep(i, tmp.size()) {
bool h = true;
rep(j, tmp[i].size()) if (tmp[i][j] != '#') h = false;
if (h)
co++;
}
return co;
}
int main() {
int q;
cin >> q;
while (q--) {
int n, m;
cin >> n >> m;
p = vector<string>(n);
rep(i, n) cin >> p[i];
int nx = inf, ny = inf, mx = -inf, my = -inf;
rep(i, n) rep(j, m) if (p[i][j] == '#') {
nx = min(nx, i);
mx = max(mx, i);
ny = min(ny, j);
my = max(my, j);
}
if (nx == inf)
return -1;
tmp = vector<string>(0);
loop(i, nx, mx + 1) { tmp.pb(p[i].substr(ny, my - ny + 1)); }
p = tmp;
cin >> n >> m;
in = vector<string>(n);
rep(i, n) cin >> in[i];
tmp = in;
int out = f();
bool H = false;
rep(w, 4) {
turn();
if (n - p.size() + 1 <= 0 || m - p[0].size() + 1 <= 0)
continue;
rep(i, n - p.size() + 1) rep(j, m - p[0].size() + 1) {
tmp = in;
bool h = true;
rep(k, p.size()) rep(l, p[0].size()) {
if (p[k][l] == '#' && in[i + k][j + l] == '#')
h = false;
else if (p[k][l] == '#')
tmp[i + k][j + l] = '#';
}
if (!h)
continue;
out = max(out, f());
H = true;
}
}
if (H)
cout << out << endl;
else
cout << -1 << endl;
}
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#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()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef pair<int, pii> pip;
typedef vector<pip> vip;
const double PI = acos(-1);
const double EPS = 1e-8;
const int inf = 1e8;
vector<string> p, tmp, in;
void turn() {
tmp = vector<string>(p[0].size(), "");
rep(i, p[0].size()) rep(j, p.size()) tmp[i] += p[j][p[0].size() - i - 1];
p = tmp;
}
int f() {
int co = 0;
rep(i, tmp.size()) {
bool h = true;
rep(j, tmp[i].size()) if (tmp[i][j] != '#') h = false;
if (h)
co++;
}
return co;
}
int main() {
int q;
cin >> q;
while (q--) {
int n, m;
cin >> n >> m;
p = vector<string>(n);
rep(i, n) cin >> p[i];
int nx = inf, ny = inf, mx = -inf, my = -inf;
rep(i, n) rep(j, m) if (p[i][j] == '#') {
nx = min(nx, i);
mx = max(mx, i);
ny = min(ny, j);
my = max(my, j);
}
if (nx == inf)
return -1;
tmp = vector<string>(0);
loop(i, nx, mx + 1) { tmp.pb(p[i].substr(ny, my - ny + 1)); }
p = tmp;
cin >> n >> m;
in = vector<string>(n);
rep(i, n) cin >> in[i];
tmp = in;
int out = f();
bool H = false;
rep(w, 4) {
turn();
int aa = p.size(), bb = p[0].size();
if (n - aa + 1 <= 0 || m - bb + 1 <= 0)
continue;
rep(i, n - p.size() + 1) rep(j, m - p[0].size() + 1) {
tmp = in;
bool h = true;
rep(k, p.size()) rep(l, p[0].size()) {
if (p[k][l] == '#' && in[i + k][j + l] == '#')
h = false;
else if (p[k][l] == '#')
tmp[i + k][j + l] = '#';
}
if (!h)
continue;
out = max(out, f());
H = true;
}
}
if (H)
cout << out << endl;
else
cout << -1 << endl;
}
} | replace | 76 | 77 | 76 | 78 | 0 | |
p01214 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cerr << *i << " ";
cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
return (x >= 0 && y >= 0 && x < W && y < H);
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int main() {
int N;
cin >> N;
while (N--) {
int H1, W1, H2, W2;
cin >> H1 >> W1;
vector<string> block(H1);
REP(i, H1) cin >> block[i];
cin >> H2 >> W2;
vector<string> grid(H2);
REP(i, H2) cin >> grid[i];
int ans = -1;
for (int iter = 0; iter < 4; iter++) {
for (int by = -H1 + 1; by < H2; by++) {
int y1 = max(by, 0), y2 = min(H2, by + H1);
if (y2 - y1 <= ans)
continue;
for (int bx = -W1 + 1; bx < W2; bx++) {
bool exist = false;
REP(y, H1)
REP(x,
W1) if (block[y][x] == '#' && (!valid(bx + x, by + y, W2, H2) ||
grid[by + y][bx + x] == '#')) {
exist = true;
break;
}
if (exist)
continue; // dame
vector<string> grid_es = grid;
REP(y, H1)
REP(x, W1) if (block[y][x] == '#') grid_es[by + y][bx + x] = '#';
int cnt = 0;
for (int y = y1; y < y2; y++) {
bool ok = true;
for (int x = 0; x < W2; x++) {
if (grid_es[y][x] != '#') {
ok = false;
break;
}
}
if (ok)
cnt++;
}
ans = max(ans, cnt);
}
}
swap(H1, W1);
vector<string> new_block(H1, string(W1, ' '));
for (int y = 0; y < H1; y++) {
for (int x = 0; x < W1; x++) {
new_block[y][x] = block[x][H1 - y - 1];
}
}
block = new_block;
}
cout << ans << endl;
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define FORIT(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); ++i)
template <class T> void debug(T begin, T end) {
for (T i = begin; i != end; ++i)
cerr << *i << " ";
cerr << endl;
}
inline bool valid(int x, int y, int W, int H) {
return (x >= 0 && y >= 0 && x < W && y < H);
}
typedef long long ll;
const int INF = 100000000;
const double EPS = 1e-8;
const int MOD = 1000000007;
int dx[8] = {1, 0, -1, 0, 1, -1, -1, 1};
int dy[8] = {0, 1, 0, -1, 1, 1, -1, -1};
int main() {
int N;
cin >> N;
while (N--) {
int H1, W1, H2, W2;
cin >> H1 >> W1;
vector<string> block(H1);
REP(i, H1) cin >> block[i];
cin >> H2 >> W2;
vector<string> grid(H2);
REP(i, H2) cin >> grid[i];
int ans = -1;
for (int iter = 0; iter < 4; iter++) {
int my1 = INF, my2 = -INF;
REP(y, H1)
REP(x, W1) if (block[y][x] == '#') my1 = min(my1, y),
my2 = max(my2, y);
for (int by = -my1; by + my2 < H2; by++) {
int y1 = max(by, 0), y2 = min(H2, by + H1);
if (y2 - y1 <= ans)
continue;
for (int bx = -W1 + 1; bx < W2; bx++) {
bool exist = false;
REP(y, H1)
REP(x,
W1) if (block[y][x] == '#' && (!valid(bx + x, by + y, W2, H2) ||
grid[by + y][bx + x] == '#')) {
exist = true;
break;
}
if (exist)
continue; // dame
vector<string> grid_es = grid;
REP(y, H1)
REP(x, W1) if (block[y][x] == '#') grid_es[by + y][bx + x] = '#';
int cnt = 0;
for (int y = y1; y < y2; y++) {
bool ok = true;
for (int x = 0; x < W2; x++) {
if (grid_es[y][x] != '#') {
ok = false;
break;
}
}
if (ok)
cnt++;
}
ans = max(ans, cnt);
}
}
swap(H1, W1);
vector<string> new_block(H1, string(W1, ' '));
for (int y = 0; y < H1; y++) {
for (int x = 0; x < W1; x++) {
new_block[y][x] = block[x][H1 - y - 1];
}
}
block = new_block;
}
cout << ans << endl;
}
return 0;
} | replace | 51 | 52 | 51 | 56 | TLE | |
p01218 | C++ | Memory 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 EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
bool LT(double a, double b) { return !equals(a, b) && a < b; }
bool LTE(double a, double b) { return equals(a, b) || a < b; }
struct Point {
double x, y, z;
Point operator-(const Point &p) const {
return (Point){x - p.x, y - p.y, z - p.z};
}
bool operator<(const Point &p) const {
return ((!equals(z, p.z)) ? z > p.z
: ((!equals(y, p.y)) ? y < p.y : LT(x, p.x)));
}
};
typedef pair<double, int> ii;
struct Edge {
int to, cap;
double cost;
int rev;
Edge(int to = 0, int cap = 0, double cost = 0, int rev = 0)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
const int MAX_V = 1100, IINF = INT_MAX;
int V;
vector<Edge> G[MAX_V];
double h[MAX_V], dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
inline void add_edge(int from, int to, int cap, double cost) {
G[from].push_back(Edge(to, cap, cost, G[to].size()));
G[to].push_back(Edge(from, 0, -cost, G[from].size() - 1));
}
double min_cost_flow(int s, int t) {
double res = 0;
fill(h, h + V, 0);
while (1) {
priority_queue<ii, vector<ii>, greater<ii>> Q;
fill(dist, dist + V, IINF);
dist[s] = 0;
Q.push(ii(0, s));
while (!Q.empty()) {
ii p = Q.top();
Q.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (LT(0, e.cap) &&
!equals(dist[v] + e.cost + h[v] - h[e.to], dist[e.to]) &&
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;
Q.push(ii(dist[e.to], e.to));
}
}
}
// if( dist[t] == IINF ) break;
rep(v, V) h[v] += dist[v];
if (h[t] >= 0LL)
break;
int d = IINF;
for (int v = t; v != s; v = prevv[v])
d = min(d, G[prevv[v]][preve[v]].cap);
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int N, K;
Point ps[100];
const double MAX = 10000;
double getDist(Point p) { return sqrt(p.x * p.x + p.y * p.y + p.z * p.z); }
void compute() {
map<int, int> counter;
bool failed = false;
rep(i, N) counter[(int)ps[i].z]++;
for (map<int, int>::iterator it = counter.begin(); it != counter.end();
it++) {
if (it->second > K) {
failed = true;
break;
}
}
if (failed) {
puts("-1");
return;
}
rep(i, N * 4) G[i].clear();
int source = N * 2;
int sink = source + 2;
V = sink + 1;
add_edge(source, source + 1, K, 0);
rep(i, N) {
add_edge(source + 1, i, 1, 0);
add_edge(i, N + i, 1, -MAX);
add_edge(N + i, sink, 1, 0);
}
rep(i, N) rep(j, N) if (i != j && ps[i].z > ps[j].z) {
add_edge(N + i, j, 1, getDist(ps[i] - ps[j]));
}
printf("%.10f\n", min_cost_flow(source, sink) + N * MAX);
}
int main() {
while (cin >> N >> K, N | K) {
rep(i, N) cin >> ps[i].x >> ps[i].y >> ps[i].z;
compute();
}
return 0;
}
/*
const int MAX_V = 110;////////////////////////////////////////////////////////
const float DINF = 1e10;
int N,K;
Point ps[MAX_V];
//double memo[MAX_V][MAX_V][MAX_V][MAX_V];
typedef unsigned long long ull;
const ull base = 1000000007ULL;
unordered_map<ull,float> memo;
float mini;
float abs(Point p) { return sqrt(p.x*p.x+p.y*p.y+p.z*p.z); }
float rec(int cur,int *prev,int kept){
if( cur >= N ) return 0;
//rep(i,4) cout << prev[i] << " "; cout << endl;
int st[4];
rep(i,4) st[i] = prev[i];
sort(st,st+4);
ull key = 0ULL;
rep(i,4) {
key *= base;
key += (ull)(st[i]+1);
}
if( memo.count(key) ) return memo[key];
//double &ret = memo[st[0]+1][st[1]+1][st[2]+1][st[3]+1];
//if( !equals(ret,DINF) ) return ret;
float ret = DINF;
rep(i,4){
if( i && prev[i-1] == -1 ) continue;
int temp = prev[i];
if( prev[i] == -1 ) {
if( kept + 1 > K ) continue;
if( i && prev[i-1] > cur ) continue;
prev[i] = cur;
ret = min(ret,rec(cur+1,prev,kept+1));
} else {
if( LT(ps[cur].z,ps[prev[i]].z) ) {
if( i && prev[i-1] > cur ) continue;
prev[i] = cur;
ret = min(ret,rec(cur+1,prev,kept)+abs(ps[cur]-ps[temp]));
}
}
prev[i] = temp;
}
return memo[key] = ret;
}
int main(){
while( cin >> N >> K, N|K ){
map<int,int> counter;
bool failed = false;
rep(i,N) {
cin >> ps[i].x >> ps[i].y >> ps[i].z;
int cnt = ++counter[ps[i].z];
if( cnt > K ) failed = true;
}
if( failed ) { puts("-1"); continue; }
sort(ps,ps+N);
//rep(i,N+2) rep(j,N+2) rep(k,N+2) rep(l,N+2) memo[i][j][k][l] = DINF;
memo.clear();
int temp[4] = {-1,-1,-1,-1};
mini = rec(0,temp,0);
if( equals(mini,DINF) ) puts("-1");
else printf("%.10lf\n",mini);
}
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 EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
bool LT(double a, double b) { return !equals(a, b) && a < b; }
bool LTE(double a, double b) { return equals(a, b) || a < b; }
struct Point {
double x, y, z;
Point operator-(const Point &p) const {
return (Point){x - p.x, y - p.y, z - p.z};
}
bool operator<(const Point &p) const {
return ((!equals(z, p.z)) ? z > p.z
: ((!equals(y, p.y)) ? y < p.y : LT(x, p.x)));
}
};
typedef pair<double, int> ii;
struct Edge {
int to, cap;
double cost;
int rev;
Edge(int to = 0, int cap = 0, double cost = 0, int rev = 0)
: to(to), cap(cap), cost(cost), rev(rev) {}
};
const int MAX_V = 1100, IINF = INT_MAX;
int V;
vector<Edge> G[MAX_V];
double h[MAX_V], dist[MAX_V];
int prevv[MAX_V], preve[MAX_V];
inline void add_edge(int from, int to, int cap, double cost) {
G[from].push_back(Edge(to, cap, cost, G[to].size()));
G[to].push_back(Edge(from, 0, -cost, G[from].size() - 1));
}
double min_cost_flow(int s, int t) {
double res = 0;
fill(h, h + V, 0);
while (1) {
priority_queue<ii, vector<ii>, greater<ii>> Q;
fill(dist, dist + V, IINF);
dist[s] = 0;
Q.push(ii(0, s));
while (!Q.empty()) {
ii p = Q.top();
Q.pop();
int v = p.second;
if (dist[v] < p.first)
continue;
for (int i = 0; i < G[v].size(); i++) {
Edge &e = G[v][i];
if (LT(0, e.cap) &&
!equals(dist[v] + e.cost + h[v] - h[e.to], dist[e.to]) &&
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;
Q.push(ii(dist[e.to], e.to));
}
}
}
// if( dist[t] == IINF ) break;
rep(v, V) h[v] += dist[v];
if (h[t] >= 0LL)
break;
int d = IINF;
for (int v = t; v != s; v = prevv[v])
d = min(d, G[prevv[v]][preve[v]].cap);
res += d * h[t];
for (int v = t; v != s; v = prevv[v]) {
Edge &e = G[prevv[v]][preve[v]];
e.cap -= d;
G[v][e.rev].cap += d;
}
}
return res;
}
int N, K;
Point ps[100];
const double MAX = 10000;
double getDist(Point p) { return sqrt(p.x * p.x + p.y * p.y + p.z * p.z); }
void compute() {
if (N <= K) {
puts("0");
return;
}
map<int, int> counter;
bool failed = false;
rep(i, N) counter[(int)ps[i].z]++;
for (map<int, int>::iterator it = counter.begin(); it != counter.end();
it++) {
if (it->second > K) {
failed = true;
break;
}
}
if (failed) {
puts("-1");
return;
}
rep(i, N * 4) G[i].clear();
int source = N * 2;
int sink = source + 2;
V = sink + 1;
add_edge(source, source + 1, K, 0);
rep(i, N) {
add_edge(source + 1, i, 1, 0);
add_edge(i, N + i, 1, -MAX);
add_edge(N + i, sink, 1, 0);
}
rep(i, N) rep(j, N) if (i != j && ps[i].z > ps[j].z) {
add_edge(N + i, j, 1, getDist(ps[i] - ps[j]));
}
printf("%.10f\n", min_cost_flow(source, sink) + N * MAX);
}
int main() {
while (cin >> N >> K, N | K) {
rep(i, N) cin >> ps[i].x >> ps[i].y >> ps[i].z;
compute();
}
return 0;
}
/*
const int MAX_V = 110;////////////////////////////////////////////////////////
const float DINF = 1e10;
int N,K;
Point ps[MAX_V];
//double memo[MAX_V][MAX_V][MAX_V][MAX_V];
typedef unsigned long long ull;
const ull base = 1000000007ULL;
unordered_map<ull,float> memo;
float mini;
float abs(Point p) { return sqrt(p.x*p.x+p.y*p.y+p.z*p.z); }
float rec(int cur,int *prev,int kept){
if( cur >= N ) return 0;
//rep(i,4) cout << prev[i] << " "; cout << endl;
int st[4];
rep(i,4) st[i] = prev[i];
sort(st,st+4);
ull key = 0ULL;
rep(i,4) {
key *= base;
key += (ull)(st[i]+1);
}
if( memo.count(key) ) return memo[key];
//double &ret = memo[st[0]+1][st[1]+1][st[2]+1][st[3]+1];
//if( !equals(ret,DINF) ) return ret;
float ret = DINF;
rep(i,4){
if( i && prev[i-1] == -1 ) continue;
int temp = prev[i];
if( prev[i] == -1 ) {
if( kept + 1 > K ) continue;
if( i && prev[i-1] > cur ) continue;
prev[i] = cur;
ret = min(ret,rec(cur+1,prev,kept+1));
} else {
if( LT(ps[cur].z,ps[prev[i]].z) ) {
if( i && prev[i-1] > cur ) continue;
prev[i] = cur;
ret = min(ret,rec(cur+1,prev,kept)+abs(ps[cur]-ps[temp]));
}
}
prev[i] = temp;
}
return memo[key] = ret;
}
int main(){
while( cin >> N >> K, N|K ){
map<int,int> counter;
bool failed = false;
rep(i,N) {
cin >> ps[i].x >> ps[i].y >> ps[i].z;
int cnt = ++counter[ps[i].z];
if( cnt > K ) failed = true;
}
if( failed ) { puts("-1"); continue; }
sort(ps,ps+N);
//rep(i,N+2) rep(j,N+2) rep(k,N+2) rep(l,N+2) memo[i][j][k][l] = DINF;
memo.clear();
int temp[4] = {-1,-1,-1,-1};
mini = rec(0,temp,0);
if( equals(mini,DINF) ) puts("-1");
else printf("%.10lf\n",mini);
}
return 0;
}
*/ | insert | 95 | 95 | 95 | 99 | MLE | |
p01219 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
// (?????????,??????,??????)
struct edge {
int to;
ll cap;
int rev;
};
const int MAX_V = 110; // TODO:initialize
const ll F_INF = 12345678901234LL; // TODO:initialize
vector<edge> G[MAX_V];
int level[MAX_V]; // s??????????????¢
int iter[MAX_V]; // ???????????§??????????????£??????
void add_edge(int from, int to, ll cap) {
G[from].pb({to, cap, (int)G[to].size()});
G[to].pb({from, 0, (int)G[from].size() - 1});
}
void dinic_bfs(int s) {
memset(level, -1, sizeof(level));
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
rep(i, G[v].size()) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
// ?¢?????????????dfs??§??¢???
ll dinic_dfs(int v, int t, ll f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); ++i) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
int d = dinic_dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// s??????t???????????§???
ll max_flow(int s, int t) {
ll flow = 0;
while (1) {
dinic_bfs(s);
if (level[t] < 0)
return flow;
memset(iter, 0, sizeof(iter));
ll f;
while ((f = dinic_dfs(s, t, F_INF)) > 0)
flow += f;
}
}
int main() {
vector<string> days({"Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
"Saturday", "Sunday"});
map<string, int> d;
rep(i, days.size()) d[days[i]] = i;
int n;
ll w;
while (cin >> n >> w, n) {
rep(i, MAX_V) G[i].clear();
int S = n + 7, T = S + 1;
rep(i, 7) add_edge(S, i, w);
ll sumt = 0;
rep(i, n) {
ll t;
int c;
cin >> t >> c;
sumt += t;
add_edge(7 + i, T, t);
while (c--) {
string s;
cin >> s;
add_edge(d[s], 7 + i, w);
}
}
cout << (max_flow(S, T) == sumt ? "Yes" : "No") << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
#define rep(i, n) for (int(i) = 0; (i) < (int)(n); ++(i))
#define all(x) (x).begin(), (x).end()
#define pb push_back
#define fi first
#define se second
#define dbg(x) cout << #x " = " << ((x)) << endl
template <class T, class U>
ostream &operator<<(ostream &o, const pair<T, U> &p) {
o << "(" << p.fi << "," << p.se << ")";
return o;
}
template <class T> ostream &operator<<(ostream &o, const vector<T> &v) {
o << "[";
for (T t : v) {
o << t << ",";
}
o << "]";
return o;
}
// (?????????,??????,??????)
struct edge {
int to;
ll cap;
int rev;
};
const int MAX_V = 110; // TODO:initialize
const ll F_INF = 12345678901234LL; // TODO:initialize
vector<edge> G[MAX_V];
int level[MAX_V]; // s??????????????¢
int iter[MAX_V]; // ???????????§??????????????£??????
void add_edge(int from, int to, ll cap) {
G[from].pb({to, cap, (int)G[to].size()});
G[to].pb({from, 0, (int)G[from].size() - 1});
}
void dinic_bfs(int s) {
memset(level, -1, sizeof(level));
queue<int> que;
level[s] = 0;
que.push(s);
while (!que.empty()) {
int v = que.front();
que.pop();
rep(i, G[v].size()) {
edge &e = G[v][i];
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
que.push(e.to);
}
}
}
}
// ?¢?????????????dfs??§??¢???
ll dinic_dfs(int v, int t, ll f) {
if (v == t)
return f;
for (int &i = iter[v]; i < G[v].size(); ++i) {
edge &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
ll d = dinic_dfs(e.to, t, min(f, e.cap));
if (d > 0) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
// s??????t???????????§???
ll max_flow(int s, int t) {
ll flow = 0;
while (1) {
dinic_bfs(s);
if (level[t] < 0)
return flow;
memset(iter, 0, sizeof(iter));
ll f;
while ((f = dinic_dfs(s, t, F_INF)) > 0)
flow += f;
}
}
int main() {
vector<string> days({"Monday", "Tuesday", "Wednesday", "Thursday", "Friday",
"Saturday", "Sunday"});
map<string, int> d;
rep(i, days.size()) d[days[i]] = i;
int n;
ll w;
while (cin >> n >> w, n) {
rep(i, MAX_V) G[i].clear();
int S = n + 7, T = S + 1;
rep(i, 7) add_edge(S, i, w);
ll sumt = 0;
rep(i, n) {
ll t;
int c;
cin >> t >> c;
sumt += t;
add_edge(7 + i, T, t);
while (c--) {
string s;
cin >> s;
add_edge(d[s], 7 + i, w);
}
}
cout << (max_flow(S, T) == sumt ? "Yes" : "No") << endl;
}
return 0;
} | replace | 66 | 67 | 66 | 67 | TLE | |
p01220 | 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;
struct Point {
void set(double arg_x, double arg_y) {
x = arg_x;
y = arg_y;
}
double x, y;
};
int N;
Point point[1000];
double R;
Point calc_Cross_Point(double x1, double x2, double x3, double x4, double y1,
double y2, double y3, double y4) {
Point ret;
ret.x = ((x2 - x1) * (y3 * (x4 - x3) + x3 * (y3 - y4)) -
(x4 - x3) * (y1 * (x2 - x1) + x1 * (y1 - y2))) /
((y2 - y1) * (x4 - x3) - (y4 - y3) * (x2 - x1));
if (x1 != x2) {
ret.y = ((y2 - y1) * ret.x + y1 * (x2 - x1) + x1 * (y1 - y2)) / (x2 - x1);
} else {
ret.y = ((y4 - y3) * ret.x + y3 * (x4 - x3) + x3 * (y3 - y4)) / (x4 - x3);
}
return ret;
}
double calc_S(Point a, Point b, Point c, Point d) {
return fabs((b.x * a.y - b.y * a.x) + (c.x * b.y - c.y * b.x) +
(d.x * c.y - d.y * c.x) + (a.x * d.y - a.y * d.x)) /
2;
}
void func() {
if (N % 3 == 0)
N /= 3;
if (N == 1) {
printf("0.433013\n");
return;
}
double base_degree = 360.0 / (double)(3 * N);
for (int i = 0; i < 3 * N; i++) {
point[i].x = R * cos(((90 - base_degree * i) * M_PI) / 180.0);
point[i].y = R * sin(((90 - base_degree * i) * M_PI) / 180.0);
}
Point a, b, c, d, ret;
a.set(point[0].x, point[0].y);
ret =
calc_Cross_Point(point[0].x, point[N].x, point[1].x, point[2 * N + 1].x,
point[0].y, point[N].y, point[1].y, point[2 * N + 1].y);
b.set(ret.x, ret.y);
c.set(0, 0);
ret = calc_Cross_Point(point[0].x, point[2 * N].x, point[3 * N - 1].x,
point[N - 1].x, point[0].y, point[2 * N].y,
point[3 * N - 1].y, point[N - 1].y);
d.set(ret.x, ret.y);
printf("%.10lf\n", (double)3 * N * calc_S(a, b, c, d));
}
int main() {
R = 1.0 / sqrt(3.0);
while (true) {
scanf("%d", &N);
if (N == 0)
break;
func();
}
} | #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;
struct Point {
void set(double arg_x, double arg_y) {
x = arg_x;
y = arg_y;
}
double x, y;
};
int N;
Point point[5000];
double R;
Point calc_Cross_Point(double x1, double x2, double x3, double x4, double y1,
double y2, double y3, double y4) {
Point ret;
ret.x = ((x2 - x1) * (y3 * (x4 - x3) + x3 * (y3 - y4)) -
(x4 - x3) * (y1 * (x2 - x1) + x1 * (y1 - y2))) /
((y2 - y1) * (x4 - x3) - (y4 - y3) * (x2 - x1));
if (x1 != x2) {
ret.y = ((y2 - y1) * ret.x + y1 * (x2 - x1) + x1 * (y1 - y2)) / (x2 - x1);
} else {
ret.y = ((y4 - y3) * ret.x + y3 * (x4 - x3) + x3 * (y3 - y4)) / (x4 - x3);
}
return ret;
}
double calc_S(Point a, Point b, Point c, Point d) {
return fabs((b.x * a.y - b.y * a.x) + (c.x * b.y - c.y * b.x) +
(d.x * c.y - d.y * c.x) + (a.x * d.y - a.y * d.x)) /
2;
}
void func() {
if (N % 3 == 0)
N /= 3;
if (N == 1) {
printf("0.433013\n");
return;
}
double base_degree = 360.0 / (double)(3 * N);
for (int i = 0; i < 3 * N; i++) {
point[i].x = R * cos(((90 - base_degree * i) * M_PI) / 180.0);
point[i].y = R * sin(((90 - base_degree * i) * M_PI) / 180.0);
}
Point a, b, c, d, ret;
a.set(point[0].x, point[0].y);
ret =
calc_Cross_Point(point[0].x, point[N].x, point[1].x, point[2 * N + 1].x,
point[0].y, point[N].y, point[1].y, point[2 * N + 1].y);
b.set(ret.x, ret.y);
c.set(0, 0);
ret = calc_Cross_Point(point[0].x, point[2 * N].x, point[3 * N - 1].x,
point[N - 1].x, point[0].y, point[2 * N].y,
point[3 * N - 1].y, point[N - 1].y);
d.set(ret.x, ret.y);
printf("%.10lf\n", (double)3 * N * calc_S(a, b, c, d));
}
int main() {
R = 1.0 / sqrt(3.0);
while (true) {
scanf("%d", &N);
if (N == 0)
break;
func();
}
} | replace | 28 | 29 | 28 | 29 | 0 | |
p01223 | C++ | Time Limit Exceeded | #include <stdio.h>
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int main(void) {
int t, n, h[101], i, up = 0, down = 0;
scanf("%d", &t);
while (t--, scanf("%d", &n)) {
for (i = 0; i < n; i++)
scanf("%d", &h[i]);
for (i = up = down = 0; i < n - 1; i++) {
up = max(up, h[i + 1] - h[i]);
down = min(down, h[i + 1] - h[i]);
}
printf("%d %d\n", up, -down);
}
return 0;
} | #include <stdio.h>
int max(int x, int y) { return x > y ? x : y; }
int min(int x, int y) { return x < y ? x : y; }
int main(void) {
int t, n, h[101], i, up = 0, down = 0;
scanf("%d", &t);
while (t--) {
scanf("%d", &n);
for (i = 0; i < n; i++)
scanf("%d", &h[i]);
for (i = up = down = 0; i < n - 1; i++) {
up = max(up, h[i + 1] - h[i]);
down = min(down, h[i + 1] - h[i]);
}
printf("%d %d\n", up, -down);
}
return 0;
} | replace | 11 | 12 | 11 | 13 | TLE | |
p01223 | C++ | Time Limit Exceeded | #include <iostream>
#include <map>
using namespace std;
typedef pair<int, int> P;
P solve(int n, int h[]) {
P answer(0, 0);
for (int i = 0; i < n - 1; ++i) {
if (h[i] < h[i + 1]) {
answer.first = max(answer.first, h[i + 1] - h[i]);
}
if (h[i] > h[i + 1]) {
answer.second = max(answer.second, h[i] - h[i + 1]);
}
}
return answer;
}
int main() {
int t, n;
int h[100];
P answer;
cin >> t;
for (int case_num = 0; case_num < t; ++t) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
answer = solve(n, h);
cout << answer.first << ' ' << answer.second << endl;
}
return 0;
} | #include <iostream>
#include <map>
using namespace std;
typedef pair<int, int> P;
P solve(int n, int h[]) {
P answer(0, 0);
for (int i = 0; i < n - 1; ++i) {
if (h[i] < h[i + 1]) {
answer.first = max(answer.first, h[i + 1] - h[i]);
}
if (h[i] > h[i + 1]) {
answer.second = max(answer.second, h[i] - h[i + 1]);
}
}
return answer;
}
int main() {
int t, n;
int h[100];
P answer;
cin >> t;
for (int case_num = 0; case_num < t; ++case_num) {
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> h[i];
}
answer = solve(n, h);
cout << answer.first << ' ' << answer.second << endl;
}
return 0;
} | replace | 25 | 26 | 25 | 26 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#define r(i, n) for (int i = 1; i < n; i++)
using namespace std;
int main() {
long long n, p, a, b;
while (cin >> n, n) {
long long s = 1;
if (n == 1)
s--;
for (int i = 2; i < n / 2; i++)
if (n % i == 0)
s += i + n / i;
if (n < s)
cout << "abundant number" << endl;
else if (n > s)
cout << "deficient number" << endl;
else
cout << "perfect number" << endl;
}
} | #include <bits/stdc++.h>
#define r(i, n) for (int i = 1; i < n; i++)
using namespace std;
int main() {
long long n, p, a, b;
while (cin >> n, n) {
long long s = 1;
if (n == 1)
s--;
for (int i = 2; i * i < n; i++)
if (n % i == 0)
s += i + n / i;
if (n < s)
cout << "abundant number" << endl;
else if (n > s)
cout << "deficient number" << endl;
else
cout << "perfect number" << endl;
}
} | replace | 9 | 10 | 9 | 10 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <stdio.h>
int main() {
long long int N, i, j, yaku;
while (scanf("%d", &N), N) {
yaku = 0;
for (i = 1; i * i <= N; i++) {
if (N % i == 0) {
yaku += i + N / i;
}
if (N == i * i) {
yaku -= i;
}
if (yaku > 2 * N)
break;
}
// printf("%d\n",yaku);
if (yaku > 2 * N) {
puts("abundant number");
} else if (yaku == 2 * N) {
puts("perfect number");
} else {
puts("deficient number");
}
}
return 0;
} | #include <stdio.h>
int main() {
long long int N, i, j, yaku;
while (scanf("%lld", &N)) {
if (N == 0)
break;
yaku = 0;
for (i = 1; i * i <= N; i++) {
if (N % i == 0) {
yaku += i + N / i;
}
if (N == i * i) {
yaku -= i;
}
if (yaku > 2 * N)
break;
}
// printf("%d\n",yaku);
if (yaku > 2 * N) {
puts("abundant number");
} else if (yaku == 2 * N) {
puts("perfect number");
} else {
puts("deficient number");
}
}
return 0;
} | replace | 4 | 5 | 4 | 7 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n, n != 0) {
int sum = 0;
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0)
sum += i;
}
if (sum < n)
cout << "deficient number" << endl;
if (sum == n)
cout << "perfect number" << endl;
if (sum > n)
cout << "abundant number" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n, n != 0) {
if (n == 1) {
cout << "deficient number" << endl;
continue;
}
int sum = 1;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (n / i != i) {
sum += (i + n / i);
} else {
sum += i;
}
}
}
if (sum < n)
cout << "deficient number" << endl;
if (sum == n)
cout << "perfect number" << endl;
if (sum > n)
cout << "abundant number" << endl;
}
return 0;
} | replace | 7 | 11 | 7 | 20 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <stdio.h>
#pragma warning(disable : 4996)
int n;
int main() {
while (true) {
scanf("%d", &n);
if (n == 0)
break;
int ret = 0;
for (int i = 1; i < n; i++) {
if (n % i == 0)
ret += i;
}
if (n > ret) {
printf("deficient number\n");
} else if (n == ret) {
printf("perfect number\n");
} else {
printf("abundant number\n");
}
}
return 0;
} | #include <stdio.h>
#pragma warning(disable : 4996)
int n;
int main() {
while (true) {
scanf("%d", &n);
if (n == 0)
break;
int ret = n > 1 ? 1 : 0;
for (int i = 2; i * i <= n; i++) {
if (n % i == 0) {
if (i * i != n) {
ret += i + n / i;
} else {
ret += i;
}
}
}
if (n > ret) {
printf("deficient number\n");
} else if (n == ret) {
printf("perfect number\n");
} else {
printf("abundant number\n");
}
}
return 0;
} | replace | 8 | 12 | 8 | 17 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <cmath>
#include <iostream>
using namespace std;
int main() {
long long int n, sum;
while (cin >> n, n) {
int N = n;
sum = 1;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
int j = 1, temp = 1;
while (n % i == 0 && i != 1) {
n /= i;
temp += (int)pow(i, j++);
}
// cout <<"temp"<< temp << endl;
sum *= temp;
}
}
sum -= N;
// cout << sum << endl;
if (sum > N)
cout << "abundant number" << endl;
else if (sum < N)
cout << "deficient number" << endl;
else
cout << "perfect number" << endl;
}
return 0;
} | #include <cmath>
#include <iostream>
using namespace std;
int main() {
int n, sum;
while (cin >> n, n) {
int N = n;
sum = 1;
for (int i = 1; i <= n; i++) {
if (n % i == 0) {
int j = 1, temp = 1;
while (n % i == 0 && i != 1) {
n /= i;
temp += (int)pow(i, j++);
}
// cout <<"temp"<< temp << endl;
sum *= temp;
}
}
sum -= N;
// cout << sum << endl;
if (sum > N)
cout << "abundant number" << endl;
else if (sum < N)
cout << "deficient number" << endl;
else
cout << "perfect number" << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long a = 6;
while (cin >> a && a != 0) {
long long sum = 1, a2 = a;
int i = 2;
while (a != 1) {
if (a % i == 0) {
int j = 1;
long long sum2 = 1;
while (a % i == 0) {
sum2 += (pow(i, j));
j++;
a /= i;
}
sum *= sum2;
}
i++;
}
sum -= a2;
if (a2 == sum)
cout << "perfect number" << endl;
else if (a2 > sum)
cout << "deficient number" << endl;
else
cout << "abundant number" << endl;
}
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int main() {
long long a = 6;
while (cin >> a && a != 0) {
long long sum = 1, a2 = a;
int i = 2;
while (a != 1) {
if (a % i == 0) {
int j = 1;
long long sum2 = 1;
while (a % i == 0) {
sum2 += (pow(i, j));
j++;
a /= i;
}
sum *= sum2;
}
if (i == 2)
i++;
else
i += 2;
}
sum -= a2;
if (a2 == sum)
cout << "perfect number" << endl;
else if (a2 > sum)
cout << "deficient number" << endl;
else
cout << "abundant number" << endl;
}
} | replace | 22 | 23 | 22 | 26 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#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 <utility>
#include <vector>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define dump(x) cerr << #x << " = " << (x) << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
int main() {
int n;
while (cin >> n) {
if (n == 0)
break;
int sum = 0;
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0)
sum += i;
}
if (sum == n)
cout << "perfect number" << endl;
else if (sum < n)
cout << "deficient number" << endl;
else if (sum > n)
cout << "abundant number" << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#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 <utility>
#include <vector>
using namespace std;
typedef vector<int> vi;
typedef pair<int, int> pii;
typedef long long ll;
#define dump(x) cerr << #x << " = " << (x) << endl
#define rep(i, n) for (int i = 0; i < (n); i++)
#define all(a) (a).begin(), (a).end()
#define pb push_back
int main() {
int n;
while (cin >> n) {
if (n == 0)
break;
int sum = 0;
for (int i = 1; i <= sqrt(n); i++) {
if (n % i == 0) {
if (i != n)
sum += i;
if (i * i != n && i != 1)
sum += n / i;
}
}
if (sum == n)
cout << "perfect number" << endl;
else if (sum < n)
cout << "deficient number" << endl;
else if (sum > n)
cout << "abundant number" << endl;
}
return 0;
} | replace | 38 | 41 | 38 | 45 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main(void) {
long long n;
while (cin >> n, n) {
if (n == 1) {
cout << "deficient number" << endl;
continue;
}
long long total = 1;
long long a = 0;
for (int i = 2; a != i && i < n; i++) {
if (n % i == 0) {
total += i;
total += (n / i);
a = n / i;
if (a == i) {
total -= i;
break;
}
}
if (total > n)
break;
}
// cout << "a = " << a << endl;
// cout << total << " ";
if (n == total)
cout << "perfect number" << endl;
if (n < total)
cout << "abundant number" << endl;
if (n > total)
cout << "deficient number" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main(void) {
long long n;
while (cin >> n, n) {
if (n == 1) {
cout << "deficient number" << endl;
continue;
}
long long total = 1;
long long a = 0;
for (int i = 2; a != i && i < n / 2; i++) {
if (n % i == 0) {
total += i;
total += (n / i);
a = n / i;
if (a == i) {
total -= i;
break;
}
}
if (total > n)
break;
}
// cout << "a = " << a << endl;
// cout << total << " ";
if (n == total)
cout << "perfect number" << endl;
if (n < total)
cout << "abundant number" << endl;
if (n > total)
cout << "deficient number" << endl;
}
return 0;
} | replace | 18 | 19 | 18 | 19 | TLE | |
p01224 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n) {
if (!n)
break;
int count = 0;
for (int i = 1; i <= n / 2; i++) {
if (n % i == 0)
count += i;
}
if (count == n)
cout << "perfect number" << endl;
else if (count > n)
cout << "abundant number" << endl;
else
cout << "deficient number" << endl;
}
return 0;
} | #include <iostream>
using namespace std;
int main() {
int n;
while (cin >> n) {
if (!n)
break;
int count = 0;
for (int i = 1; i * i < n; i++) {
if (i == 1)
count++;
else if (n % i == 0) {
count += (i + n / i);
}
}
if (count == n)
cout << "perfect number" << endl;
else if (count > n)
cout << "abundant number" << endl;
else
cout << "deficient number" << endl;
}
return 0;
} | replace | 9 | 12 | 9 | 15 | TLE | |
p01226 | C++ | Runtime Error | #include <iostream>
using namespace std;
int main() {
int t;
cin >> t;
for (; t--;) {
int h, w;
cin >> h >> w;
// cout<<h<<" "<<w<<endl;
char maps[h][w];
int x, y;
// char move; //^=0,>=1,v=2,<=3
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
cin >> maps[i][j];
if (maps[i][j] == '^' || maps[i][j] == '>' || maps[i][j] == 'v' ||
maps[i][j] == '<') {
x = i;
y = j;
}
}
int n;
cin >> n;
for (; n--;) {
char tmp;
cin >> tmp;
if (tmp == 'U') {
maps[x][y] = '^';
if (x > 0 && maps[x - 1][y] == '.') {
maps[x][y] = '.';
x--;
maps[x][y] = '^';
}
}
if (tmp == 'D') {
maps[x][y] = 'v';
if (x < h - 1 && maps[x + 1][y] == '.') {
maps[x][y] = '.';
x++;
maps[x][y] = 'v';
}
}
if (tmp == 'L') {
maps[x][y] = '<';
if (y > 0 && maps[x][y - 1] == '.') {
maps[x][y] = '.';
y--;
maps[x][y] = '<';
}
}
if (tmp == 'R') {
maps[x][y] = '>';
if (y < w - 1 && maps[x][y + 1] == '.') {
maps[x][y] = '.';
y++;
maps[x][y] = '>';
}
}
if (tmp == 'S') {
int dx = 0, dy = 0;
int tmpx = x, tmpy = y;
if (maps[x][y] == '^')
dx = -1;
else if (maps[x][y] == 'v')
dx = 1;
else if (maps[x][y] == '<')
dy = -1;
else
dy = 1;
while (tmpx + dx < h && tmpy + dy < w) {
tmpx += dx;
tmpy += dy;
if (maps[tmpx][tmpy] == '*') {
maps[tmpx][tmpy] = '.';
break;
}
if (maps[tmpx][tmpy] == '#') {
break;
}
}
}
}
for (int i = 0; i < h; i++, cout << endl)
for (int j = 0; j < w; j++) {
cout << maps[i][j];
}
if (t != 0)
cout << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int t;
cin >> t;
for (; t--;) {
int h, w;
cin >> h >> w;
// cout<<h<<" "<<w<<endl;
char maps[h][w];
int x, y;
// char move; //^=0,>=1,v=2,<=3
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++) {
cin >> maps[i][j];
if (maps[i][j] == '^' || maps[i][j] == '>' || maps[i][j] == 'v' ||
maps[i][j] == '<') {
x = i;
y = j;
}
}
int n;
cin >> n;
for (; n--;) {
char tmp;
cin >> tmp;
if (tmp == 'U') {
maps[x][y] = '^';
if (x > 0 && maps[x - 1][y] == '.') {
maps[x][y] = '.';
x--;
maps[x][y] = '^';
}
}
if (tmp == 'D') {
maps[x][y] = 'v';
if (x < h - 1 && maps[x + 1][y] == '.') {
maps[x][y] = '.';
x++;
maps[x][y] = 'v';
}
}
if (tmp == 'L') {
maps[x][y] = '<';
if (y > 0 && maps[x][y - 1] == '.') {
maps[x][y] = '.';
y--;
maps[x][y] = '<';
}
}
if (tmp == 'R') {
maps[x][y] = '>';
if (y < w - 1 && maps[x][y + 1] == '.') {
maps[x][y] = '.';
y++;
maps[x][y] = '>';
}
}
if (tmp == 'S') {
int dx = 0, dy = 0;
int tmpx = x, tmpy = y;
if (maps[x][y] == '^')
dx = -1;
else if (maps[x][y] == 'v')
dx = 1;
else if (maps[x][y] == '<')
dy = -1;
else
dy = 1;
while (tmpx + dx < h && tmpy + dy < w && tmpx + dx >= 0 &&
tmpy + dy >= 0) {
tmpx += dx;
tmpy += dy;
if (maps[tmpx][tmpy] == '*') {
maps[tmpx][tmpy] = '.';
break;
}
if (maps[tmpx][tmpy] == '#') {
break;
}
}
}
}
for (int i = 0; i < h; i++, cout << endl)
for (int j = 0; j < w; j++) {
cout << maps[i][j];
}
if (t != 0)
cout << endl;
}
} | replace | 72 | 73 | 72 | 74 | -11 | |
p01227 | C++ | Runtime Error | #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
#define MP make_pair
#define PB push_back
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
int main() {
int times;
cin >> times;
REP(i, times) {
int n, k;
cin >> n >> k;
int x[100100];
REP(j, n) cin >> x[j];
vector<int> v;
REP(j, n - 1) { v.PB(x[j + 1] - x[j]); }
sort(ALL(v));
reverse(ALL(v));
int btw = x[n - 1] - x[0];
REP(j, k - 1) { btw -= v[j]; }
cout << max(0, btw) << endl;
}
}
| #include <algorithm>
#include <cstdio>
#include <iostream>
#include <vector>
#define MP make_pair
#define PB push_back
#define ALL(a) (a).begin(), (a).end()
#define REP(i, n) for (int i = 0; i < (n); ++i)
using namespace std;
typedef pair<int, int> P;
int main() {
int times;
cin >> times;
REP(i, times) {
int n, k;
cin >> n >> k;
int x[100100];
REP(j, n) cin >> x[j];
vector<int> v;
REP(j, n - 1) { v.PB(x[j + 1] - x[j]); }
sort(ALL(v));
reverse(ALL(v));
int btw = x[n - 1] - x[0];
REP(j, min(n - 1, k - 1)) { btw -= v[j]; }
cout << max(0, btw) << endl;
}
}
| replace | 23 | 24 | 23 | 24 | 0 | |
p01227 | C++ | Runtime Error | #include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> dist;
int pre;
dist.push_back(0);
REP(i, n) {
int tmp;
cin >> tmp;
if (i)
dist.push_back(tmp - pre);
pre = tmp;
}
SORT(dist);
REP(i, n - 1) dist[i + 1] += dist[i];
cout << dist[n - k] << endl;
}
return 0;
} | #include <bits/stdc++.h>
typedef long long LL;
#define SORT(c) sort((c).begin(), (c).end())
#define FOR(i, a, b) for (int i = (a); i < (b); ++i)
#define REP(i, n) FOR(i, 0, n)
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
vector<int> dist;
int pre;
dist.push_back(0);
REP(i, n) {
int tmp;
cin >> tmp;
if (i)
dist.push_back(tmp - pre);
pre = tmp;
}
SORT(dist);
REP(i, n - 1) dist[i + 1] += dist[i];
cout << dist[max(n - k, 0)] << endl;
}
return 0;
} | replace | 26 | 27 | 26 | 27 | 0 | |
p01227 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int t;
cin >> t;
for (int a = 0; a < t; a++) {
int n, k, x[100000], sum;
vector<int> vec;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (i)
vec.push_back(x[i] - x[i - 1]);
}
sum = x[n - 1] - x[0];
sort(vec.begin(), vec.end(), greater<int>());
for (int i = 0; i < k - 1; i++) {
sum -= vec[i];
}
cout << sum << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int t;
cin >> t;
for (int a = 0; a < t; a++) {
int n, k, x[100000], sum;
vector<int> vec;
cin >> n >> k;
for (int i = 0; i < n; i++) {
cin >> x[i];
if (i)
vec.push_back(x[i] - x[i - 1]);
}
sum = x[n - 1] - x[0];
sort(vec.begin(), vec.end(), greater<int>());
for (int i = 0; i < min(n, k) - 1; i++) {
sum -= vec[i];
}
cout << sum << endl;
}
return 0;
} | replace | 19 | 20 | 19 | 20 | 0 | |
p01227 | C++ | Runtime Error | /* 2012-10-26T16:24:59 */
#define DEBUG_ON
#define CONDITION true
using namespace std; /*{{{*/
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
#define INF (1e9)
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef complex<double> P;
#define FOR(i, b, e) for (typeof(e) i = (b); i != (e); i < (e) ? ++i : --i)
#define REP(i, n) FOR(i, 0, n)
#define IFC(c) \
if (c) \
continue;
#define IFB(c) \
if (c) \
break;
#define IFR(c, r) \
if (c) \
return r;
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SZ(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define BIT(n) (1ULL << (n))
#define BITOF(n, m) ((ULL)(n) >> (m)&1)
#define RANGE(a, b, c) ((a) <= (b) && (b) <= (c))
#define PQ priority_queue
#define SC static_cast
#ifdef DEBUG_ON
#define dprt(fmt, ...) \
if (CONDITION) \
fprintf(stderr, fmt, __VA_ARGS__)
#define darr(a) \
if (CONDITION) \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define darr_range(a, f, t) \
if (CONDITION) \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define dvec(v) \
if (CONDITION) \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define darr2(a, n, m) \
if (CONDITION) \
FOR(i, 0, (n)) { darr_range((a)[i], 0, (m)); }
#define dvec2(v) \
if (CONDITION) \
FOR(i, 0, SZ(v)) { dvec((v)[i]); }
#define WAIT() \
if (CONDITION) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (CONDITION) \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl;
#define dumpf() \
if (CONDITION) \
cerr << __PRETTY_FUNCTION__ << endl;
#define dumpv(x) \
if (CONDITION) \
cerr << " [L:" << __LINE__ << "] " << #x << " = "; \
REP(q, (x).size()) cerr << (x)[q] << " "; \
cerr << endl;
#define where() \
if (CONDITION) \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl;
#define show_bits(b, s) \
if (CONDITION) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
#else
#define cerr \
if (0) \
cerr
#define dprt(fmt, ...)
#define darr(a)
#define darr_range(a, f, t)
#define dvec(v)
#define darr2(a, n, m)
#define dvec2(v)
#define WAIT()
#define dump(x)
#define dumpf()
#define dumpv(x)
#define where()
#define show_bits(b, s)
#endif
inline int onbits_count(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int bits_count(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c;
}
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();
}
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
IFC(s[i] == ' ');
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
/*}}}*/
int main() {
std::ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int pre;
cin >> pre;
int s = pre;
VI dist;
REP(i, n - 1) {
int x;
cin >> x;
dist.PB(x - pre);
pre = x;
}
int e = pre;
int ans = e - s;
RSORT(dist);
REP(i, k - 1) { ans -= dist[i]; }
cout << max(0, ans) << endl;
}
} | /* 2012-10-26T16:24:59 */
#define DEBUG_ON
#define CONDITION true
using namespace std; /*{{{*/
#include <algorithm>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <sys/time.h>
#include <vector>
#define INF (1e9)
static const double PI = acos(-1.0);
static const double EPS = 1e-10;
typedef long long int LL;
typedef unsigned long long int ULL;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef complex<double> P;
#define FOR(i, b, e) for (typeof(e) i = (b); i != (e); i < (e) ? ++i : --i)
#define REP(i, n) FOR(i, 0, n)
#define IFC(c) \
if (c) \
continue;
#define IFB(c) \
if (c) \
break;
#define IFR(c, r) \
if (c) \
return r;
#define OPOVER(_op, _type) inline bool operator _op(const _type &t) const
#define arrsz(a) (sizeof(a) / sizeof(a[0]))
#define F first
#define S second
#define MP(a, b) make_pair(a, b)
#define SZ(a) ((LL)a.size())
#define PB(e) push_back(e)
#define SORT(v) sort((v).begin(), (v).end())
#define RSORT(v) sort((v).rbegin(), (v).rend())
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EACH(c, it) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define EXIST(s, e) ((s).find(e) != (s).end())
#define BIT(n) (1ULL << (n))
#define BITOF(n, m) ((ULL)(n) >> (m)&1)
#define RANGE(a, b, c) ((a) <= (b) && (b) <= (c))
#define PQ priority_queue
#define SC static_cast
#ifdef DEBUG_ON
#define dprt(fmt, ...) \
if (CONDITION) \
fprintf(stderr, fmt, __VA_ARGS__)
#define darr(a) \
if (CONDITION) \
copy((a), (a) + arrsz(a), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define darr_range(a, f, t) \
if (CONDITION) \
copy((a) + (f), (a) + (t), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define dvec(v) \
if (CONDITION) \
copy(ALL(v), ostream_iterator<int>(cerr, " ")); \
cerr << endl
#define darr2(a, n, m) \
if (CONDITION) \
FOR(i, 0, (n)) { darr_range((a)[i], 0, (m)); }
#define dvec2(v) \
if (CONDITION) \
FOR(i, 0, SZ(v)) { dvec((v)[i]); }
#define WAIT() \
if (CONDITION) { \
string _wait_; \
cerr << "(hit return to continue)" << endl; \
getline(cin, _wait_); \
}
#define dump(x) \
if (CONDITION) \
cerr << " [L" << __LINE__ << "] " << #x << " = " << (x) << endl;
#define dumpf() \
if (CONDITION) \
cerr << __PRETTY_FUNCTION__ << endl;
#define dumpv(x) \
if (CONDITION) \
cerr << " [L:" << __LINE__ << "] " << #x << " = "; \
REP(q, (x).size()) cerr << (x)[q] << " "; \
cerr << endl;
#define where() \
if (CONDITION) \
cerr << __FILE__ << ": " << __PRETTY_FUNCTION__ << " [L: " << __LINE__ \
<< "]" << endl;
#define show_bits(b, s) \
if (CONDITION) { \
REP(i, s) { \
cerr << BITOF(b, s - 1 - i); \
if (i % 4 == 3) \
cerr << ' '; \
} \
cerr << endl; \
}
#else
#define cerr \
if (0) \
cerr
#define dprt(fmt, ...)
#define darr(a)
#define darr_range(a, f, t)
#define dvec(v)
#define darr2(a, n, m)
#define dvec2(v)
#define WAIT()
#define dump(x)
#define dumpf()
#define dumpv(x)
#define where()
#define show_bits(b, s)
#endif
inline int onbits_count(ULL b) {
int c = 0;
while (b != 0) {
c += (b & 1);
b >>= 1;
}
return c;
}
inline int bits_count(ULL b) {
int c = 0;
while (b != 0) {
++c;
b >>= 1;
}
return c;
}
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();
}
inline double now() {
struct timeval tv;
gettimeofday(&tv, NULL);
return (static_cast<double>(tv.tv_sec) +
static_cast<double>(tv.tv_usec) * 1e-6);
}
inline VS split(string s, char delimiter) {
VS v;
string t;
REP(i, s.length()) {
IFC(s[i] == ' ');
if (s[i] == delimiter)
v.PB(t), t = "";
else
t += s[i];
}
v.PB(t);
return v;
}
template <typename T1, typename T2>
ostream &operator<<(ostream &s, const pair<T1, T2> &d) {
return s << "(" << d.first << ", " << d.second << ")";
}
/*}}}*/
int main() {
std::ios_base::sync_with_stdio(false);
int t;
cin >> t;
while (t--) {
int n, k;
cin >> n >> k;
int pre;
cin >> pre;
int s = pre;
VI dist;
REP(i, n - 1) {
int x;
cin >> x;
dist.PB(x - pre);
pre = x;
}
int e = pre;
int ans = e - s;
RSORT(dist);
REP(i, k - 1) {
if (i >= dist.size()) {
break;
}
ans -= dist[i];
}
cout << max(0, ans) << endl;
}
} | replace | 228 | 229 | 228 | 234 | 0 | |
p01227 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int set, i, j, p, q, n, k, input[10010], st, en, sa[10010], cont;
scanf("%d", &set);
for (q = 0; q < set; q++) {
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &input[i]);
}
st = input[0];
en = input[n - 1];
cont = en - st;
for (i = 1; i < n; i++) {
sa[i - 1] = input[i] - input[i - 1];
}
sort(sa, sa + n - 1, greater<int>());
for (i = 0; i < k - 1; i++) {
cont -= sa[i];
}
if (cont < 0) {
cont = 0;
}
printf("%d\n", cont);
}
} | #include <algorithm>
#include <functional>
#include <iostream>
using namespace std;
int main() {
int set, i, j, p, q, n, k, input[100100], st, en, sa[100100], cont;
scanf("%d", &set);
for (q = 0; q < set; q++) {
scanf("%d%d", &n, &k);
for (i = 0; i < n; i++) {
scanf("%d", &input[i]);
}
st = input[0];
en = input[n - 1];
cont = en - st;
for (i = 1; i < n; i++) {
sa[i - 1] = input[i] - input[i - 1];
}
sort(sa, sa + n - 1, greater<int>());
for (i = 0; i < k - 1; i++) {
cont -= sa[i];
}
if (cont < 0) {
cont = 0;
}
printf("%d\n", cont);
}
} | replace | 6 | 7 | 6 | 7 | 0 | |
p01227 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; t++) {
int n, k;
cin >> n >> k;
int x[n], gap[n - 1];
for (int j = 0; j < n; j++)
cin >> x[j];
for (int j = 0; j < n - 1; j++)
gap[j] = x[j + 1] - x[j];
sort(&gap[0], &gap[n - 1]);
int sum = 0;
if ((n - 1) - (k - 1) > 0) {
for (int j = 0; j < (n - 1) - (k - 1); j++)
sum += gap[j];
}
cout << sum << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
int main() {
int t;
cin >> t;
for (int i = 0; i < t; i++) {
int n, k;
cin >> n >> k;
int x[n], gap[n - 1];
for (int j = 0; j < n; j++)
cin >> x[j];
for (int j = 0; j < n - 1; j++)
gap[j] = x[j + 1] - x[j];
sort(&gap[0], &gap[n - 1]);
int sum = 0;
if ((n - 1) - (k - 1) > 0) {
for (int j = 0; j < (n - 1) - (k - 1); j++)
sum += gap[j];
}
cout << sum << endl;
}
return 0;
} | replace | 7 | 8 | 7 | 8 | TLE | |
p01227 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 100;
/* typedef */
/* global variables */
int xs[MAX_N], dxs[MAX_N];
/* subroutines */
/* main */
int main() {
int tn;
cin >> tn;
while (tn--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> xs[i];
sort(xs, xs + n);
for (int i = 0; i < n - 1; i++)
dxs[i] = xs[i + 1] - xs[i];
sort(dxs, dxs + n - 1);
int sum = 0;
for (int i = 0; i < n - k; i++)
sum += dxs[i];
cout << sum << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <string>
#include <utility>
#include <vector>
using namespace std;
/* constant */
const int MAX_N = 100000;
/* typedef */
/* global variables */
int xs[MAX_N], dxs[MAX_N];
/* subroutines */
/* main */
int main() {
int tn;
cin >> tn;
while (tn--) {
int n, k;
cin >> n >> k;
for (int i = 0; i < n; i++)
cin >> xs[i];
sort(xs, xs + n);
for (int i = 0; i < n - 1; i++)
dxs[i] = xs[i + 1] - xs[i];
sort(dxs, dxs + n - 1);
int sum = 0;
for (int i = 0; i < n - k; i++)
sum += dxs[i];
cout << sum << endl;
}
return 0;
} | replace | 22 | 23 | 22 | 23 | 0 | |
p01227 | C++ | Runtime Error | #include <bits/stdc++.h>
#define loop(i, a, b) for (int i = (a); i < int(b); i++)
#define rep(i, b) loop(i, 0, b)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
using namespace std;
typedef vector<int> vi;
int main() {
int t;
cin >> t;
rep(_, t) {
int n, k;
cin >> n >> k;
vi x(n);
rep(i, n) cin >> x[i];
sort(all(x));
vi d(n - 1);
int s = 0;
rep(i, n - 1) {
d[i] = x[i + 1] - x[i];
s += d[i];
}
sort(rall(d));
rep(i, k - 1) { s -= d[i]; }
s = max(0, s);
cout << s << endl;
}
} | #include <bits/stdc++.h>
#define loop(i, a, b) for (int i = (a); i < int(b); i++)
#define rep(i, b) loop(i, 0, b)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
using namespace std;
typedef vector<int> vi;
int main() {
int t;
cin >> t;
rep(_, t) {
int n, k;
cin >> n >> k;
vi x(n);
rep(i, n) cin >> x[i];
sort(all(x));
vi d(n - 1);
int s = 0;
rep(i, n - 1) {
d[i] = x[i + 1] - x[i];
s += d[i];
}
sort(rall(d));
int end = min(k - 1, n - 1);
rep(i, end) { s -= d[i]; }
s = max(0, s);
cout << s << endl;
}
} | replace | 28 | 29 | 28 | 31 | 0 | |
p01227 | C++ | Runtime Error | #include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>
int main() {
int t;
std::cin >> t;
std::vector<int> space;
space.reserve(100000);
for (int i = 0; i < t; ++i) {
int n, k;
std::cin >> n >> k;
if (k >= n) {
// テゥツ?ゥテ・ツスツ禿」ツ?ォテ、ツクツ?・ツ崢榲・ツ?・テ・ツ環崚」ツ?凖」ツつ?
std::cin >> n;
std::cout << 0 << std::endl;
continue;
}
space.resize(n - 1);
int before_pos, road_size, first_pos;
std::cin >> before_pos;
first_pos = before_pos;
for (int j = 1; j < n; ++j) {
int new_pos;
std::cin >> new_pos;
if (j == n - 1)
road_size = new_pos;
space[j - 1] = new_pos - before_pos;
before_pos = new_pos;
}
std::sort(space.begin(), space.end(), std::greater<int>());
std::cout << road_size - first_pos -
std::accumulate(space.begin(), space.begin() + k - 1, 0)
<< std::endl;
space.clear();
}
} | #include <algorithm>
#include <functional>
#include <iostream>
#include <numeric>
#include <vector>
int main() {
int t;
std::cin >> t;
std::vector<int> space;
space.reserve(100000);
for (int i = 0; i < t; ++i) {
int n, k;
std::cin >> n >> k;
if (k >= n) {
// テゥツ?ゥテ・ツスツ禿」ツ?ォテ、ツクツ?・ツ崢榲・ツ?・テ・ツ環崚」ツ?凖」ツつ?
for (int j = 0; j < n; ++j)
std::cin >> k;
std::cout << 0 << std::endl;
continue;
}
space.resize(n - 1);
int before_pos, road_size, first_pos;
std::cin >> before_pos;
first_pos = before_pos;
for (int j = 1; j < n; ++j) {
int new_pos;
std::cin >> new_pos;
if (j == n - 1)
road_size = new_pos;
space[j - 1] = new_pos - before_pos;
before_pos = new_pos;
}
std::sort(space.begin(), space.end(), std::greater<int>());
std::cout << road_size - first_pos -
std::accumulate(space.begin(), space.begin() + k - 1, 0)
<< std::endl;
space.clear();
}
} | replace | 17 | 18 | 17 | 19 | 0 | |
p01228 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef unsigned char uc;
struct R {
uc notes[1024];
int num;
void push(const uc ¬e) { notes[num++] = note; }
};
R rolls[8];
char hexmap[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
int gcd_of(int a, int b) {
while (a != b) {
if (a > b)
a -= b;
else
b -= a;
}
return a;
}
int lcm_of(const int &a, const int &b) { return a * b / gcd_of(a, b); }
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
// load
char buff[2049];
cin >> buff;
char *p = buff;
auto &r = rolls[i];
r.num = 0;
while (*p != 0) {
r.push((*p - '0') * 16 + (*(p + 1) - '0'));
p += 2;
}
// comp
int gcd = r.num;
int clen = 1;
for (int j = 1; j < r.num; j++) {
if (r.notes[j] == 0) {
clen++;
} else {
gcd = gcd_of(gcd, clen);
clen = 1;
if (gcd == 1)
break;
}
}
gcd = gcd_of(gcd, clen);
if (gcd != 1) {
r.num /= gcd;
for (int j = 0; j < r.num; j++)
r.notes[j] = r.notes[j * gcd];
}
}
int lcm = rolls[0].num;
for (int i = 1; i < n; i++) {
lcm = lcm_of(lcm, rolls[i].num);
}
if (lcm > 1024) {
cout << "Too complex.";
} else {
// combine
int m[8];
for (int i = 0; i < n; i++)
m[i] = lcm / rolls[i].num;
for (int i = 0; i < lcm; i++) {
uc v = 0;
for (int j = 0; j < n; j++) {
if (i % m[j] == 0)
v |= rolls[j].notes[i / m[j]];
}
cout << hexmap[v / 16] << hexmap[v % 16];
}
}
cout << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
typedef unsigned char uc;
struct R {
uc notes[1024];
int num;
void push(const uc ¬e) { notes[num++] = note; }
};
R rolls[8];
char hexmap[16] = {'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
int gcd_of(int a, int b) {
while (a != b) {
if (a > b)
a -= b;
else
b -= a;
}
return a;
}
int lcm_of(const int &a, const int &b) { return a * b / gcd_of(a, b); }
int main() {
int t;
cin >> t;
while (t--) {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
// load
char buff[2049];
cin >> buff;
char *p = buff;
auto &r = rolls[i];
r.num = 0;
while (*p != 0) {
r.push((*p - '0') * 16 + (*(p + 1) - '0'));
p += 2;
}
// comp
int gcd = r.num;
int clen = 1;
for (int j = 1; j < r.num; j++) {
if (r.notes[j] == 0) {
clen++;
} else {
gcd = gcd_of(gcd, clen);
clen = 1;
if (gcd == 1)
break;
}
}
gcd = gcd_of(gcd, clen);
if (gcd != 1) {
r.num /= gcd;
for (int j = 0; j < r.num; j++)
r.notes[j] = r.notes[j * gcd];
}
}
int lcm = rolls[0].num;
for (int i = 1; i < n; i++) {
lcm = lcm_of(lcm, rolls[i].num);
if (lcm > 1024)
break; // for overflow
}
if (lcm > 1024) {
cout << "Too complex.";
} else {
// combine
int m[8];
for (int i = 0; i < n; i++)
m[i] = lcm / rolls[i].num;
for (int i = 0; i < lcm; i++) {
uc v = 0;
for (int j = 0; j < n; j++) {
if (i % m[j] == 0)
v |= rolls[j].notes[i / m[j]];
}
cout << hexmap[v / 16] << hexmap[v % 16];
}
}
cout << endl;
}
return 0;
} | insert | 69 | 69 | 69 | 71 | TLE | |
p01228 | C++ | Runtime Error | // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#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 FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
// #define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vs in(n);
rep(i, n) cin >> in[i];
rep(i, n) {
int t = in[i].size() / 2;
rep(j, in[i].size()) if (in[i][j] != '0') t = gcd(t, j / 2);
if (t == 0) {
in[i] = "00";
} else {
string w = "";
rep(j, in[i].size() / t / 2) {
w += in[i][j * 2 * t];
w += in[i][j * 2 * t + 1];
}
in[i] = w;
}
}
ll t = 1;
rep(i, n) t = lcm(t, in[i].size());
// rep(i,n)cout<<in[i]<<endl;cout<<endl;
if (t > 2048)
cout << "Too complex." << endl;
else {
rep(i, n) {
int w = t / in[i].size();
string a = "";
rep(j, in[i].size() / 2) {
a += in[i][2 * j];
a += in[i][2 * j + 1];
a += string(2 * w - 2, '0');
}
in[i] = a;
}
rep(i, t) {
int s = 0;
rep(j, n) s += in[j][i] - '0';
printf("%01X", s);
}
cout << endl;
}
}
}
| // g++ -std=c++11 a.cpp
#include <algorithm>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <iomanip>
#include <iostream>
#include <map>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <typeinfo>
#include <unordered_map>
#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 FOR(i, a) for (auto i : a)
#define pb push_back
#define all(in) in.begin(), in.end()
#define shosu(x) fixed << setprecision(x)
using namespace std;
// kaewasuretyuui
typedef long long ll;
// #define int ll
typedef int Def;
typedef pair<Def, Def> pii;
typedef vector<Def> vi;
typedef vector<vi> vvi;
typedef vector<pii> vp;
typedef vector<vp> vvp;
typedef vector<string> vs;
typedef vector<double> vd;
typedef vector<vd> vvd;
typedef pair<Def, pii> pip;
typedef vector<pip> vip;
#define mt make_tuple
typedef tuple<int, int, int> tp;
typedef vector<tp> vt;
template <typename A, typename B> bool cmin(A &a, const B &b) {
return a > b ? (a = b, true) : false;
}
template <typename A, typename B> bool cmax(A &a, const B &b) {
return a < b ? (a = b, true) : false;
}
// template<class C>constexpr int size(const C &c){return (int)c.size();}
// template<class T,size_t N> constexpr int size(const T
// (&xs)[N])noexcept{return (int)N;}
const double PI = acos(-1);
const double EPS = 1e-9;
Def inf = sizeof(Def) == sizeof(long long) ? 2e18 : 1e9 + 10;
int dx[] = {0, 1, 0, -1};
int dy[] = {1, 0, -1, 0};
ll gcd(ll a, ll b) { return (b == 0 ? a : gcd(b, a % b)); }
ll lcm(ll a, ll b) { return a / gcd(a, b) * b; }
int main() {
int q;
cin >> q;
while (q--) {
int n;
cin >> n;
vs in(n);
rep(i, n) cin >> in[i];
rep(i, n) {
int t = in[i].size() / 2;
rep(j, in[i].size()) if (in[i][j] != '0') t = gcd(t, j / 2);
if (t == 0) {
in[i] = "00";
} else {
string w = "";
rep(j, in[i].size() / t / 2) {
w += in[i][j * 2 * t];
w += in[i][j * 2 * t + 1];
}
in[i] = w;
}
}
ll t = 1;
rep(i, n) {
t = lcm(t, in[i].size());
if (t > 2048)
break;
}
// rep(i,n)cout<<in[i]<<endl;cout<<endl;
if (t > 2048)
cout << "Too complex." << endl;
else {
rep(i, n) {
int w = t / in[i].size();
string a = "";
rep(j, in[i].size() / 2) {
a += in[i][2 * j];
a += in[i][2 * j + 1];
a += string(2 * w - 2, '0');
}
in[i] = a;
}
rep(i, t) {
int s = 0;
rep(j, n) s += in[j][i] - '0';
printf("%01X", s);
}
cout << endl;
}
}
}
| replace | 84 | 85 | 84 | 89 | 0 | |
p01229 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
typedef complex<double> P;
typedef pair<P, P> Edge;
typedef long long ll;
const double PI = 4 * atan(1.0);
#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int dp[2][321];
int main() {
int t;
cin >> t;
while (t--) {
memset(dp, 0, sizeof(dp));
int n;
cin >> n;
int a[101];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1) {
cout << a[0] << endl;
continue;
}
dp[0][a[0]] = a[1];
for (int i = 1; i < n - 1; i++) {
memset(dp[i % 2], 0, sizeof(dp[i % 2]));
for (int j = 0; j < 321; j++) {
// ツ遷ツ暗堋つウツつケツづゥ
if (dp[(i - 1) % 2][j] - 1 >= 0)
dp[i % 2][dp[(i - 1) % 2][j] - 1] =
max(dp[i % 2][dp[(i - 1) % 2][j] - 1], j + a[i + 1]);
// ツ遷ツ暗堋つウツつケツづ按つ「
dp[i % 2][dp[(i - 1) % 2][j]] =
max(dp[i % 2][dp[(i - 1) % 2][j]], a[i + 1]);
}
}
int maxNum = 0;
for (int i = 0; i < 321; i++)
maxNum = max(dp[(n - 2) % 2][i], maxNum);
cout << maxNum << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <string>
#include <vector>
using namespace std;
#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
typedef complex<double> P;
typedef pair<P, P> Edge;
typedef long long ll;
const double PI = 4 * atan(1.0);
// #define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int dp[2][321];
int main() {
int t;
cin >> t;
while (t--) {
memset(dp, 0, sizeof(dp));
int n;
cin >> n;
int a[101];
for (int i = 0; i < n; i++)
cin >> a[i];
if (n == 1) {
cout << a[0] << endl;
continue;
}
dp[0][a[0]] = a[1];
for (int i = 1; i < n - 1; i++) {
memset(dp[i % 2], 0, sizeof(dp[i % 2]));
for (int j = 0; j < 321; j++) {
// ツ遷ツ暗堋つウツつケツづゥ
if (dp[(i - 1) % 2][j] - 1 >= 0)
dp[i % 2][dp[(i - 1) % 2][j] - 1] =
max(dp[i % 2][dp[(i - 1) % 2][j] - 1], j + a[i + 1]);
// ツ遷ツ暗堋つウツつケツづ按つ「
dp[i % 2][dp[(i - 1) % 2][j]] =
max(dp[i % 2][dp[(i - 1) % 2][j]], a[i + 1]);
}
}
int maxNum = 0;
for (int i = 0; i < 321; i++)
maxNum = max(dp[(n - 2) % 2][i], maxNum);
cout << maxNum << endl;
}
return 0;
} | replace | 29 | 30 | 29 | 30 | 0 | |
p01229 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, maxi;
int Ea[81], dp[81][321][321];
int rec(int idx, int prev, int now) {
if (idx == n - 1)
return now;
if (dp[idx][prev][now])
return dp[idx][prev][now];
int res = 0;
res = max(res, rec(idx + 1, now, Ea[idx + 1]));
for (int i = 0; i < n; i++) {
if (now > 0)
res = max(res, rec(idx + 1, now - 1, prev + Ea[idx + 1]));
}
return dp[idx][prev][now] = res;
}
int main() {
int N;
cin >> N;
while (N--) {
memset(dp, 0, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++)
cin >> Ea[i];
cout << ((n == 1) ? Ea[0] : rec(1, Ea[0], Ea[1])) << endl;
}
} | #include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, maxi;
int Ea[81], dp[81][321][321];
int rec(int idx, int prev, int now) {
if (idx == n - 1)
return now;
if (dp[idx][prev][now])
return dp[idx][prev][now];
int res = 0;
res = max(res, rec(idx + 1, now, Ea[idx + 1]));
if (now > 0)
res = max(res, rec(idx + 1, now - 1, prev + Ea[idx + 1]));
return dp[idx][prev][now] = res;
}
int main() {
int N;
cin >> N;
while (N--) {
memset(dp, 0, sizeof(dp));
cin >> n;
for (int i = 0; i < n; i++)
cin >> Ea[i];
cout << ((n == 1) ? Ea[0] : rec(1, Ea[0], Ea[1])) << endl;
}
} | replace | 15 | 19 | 15 | 17 | TLE | |
p01229 | C++ | Memory Limit Exceeded | // 15
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int p[400][400][81];
int dfs(vector<int> v) {
if (v.size() <= 2) {
return v.back();
} else {
if (p[v[0]][v[1]][v.size()]++) {
return 0;
} else {
int n = dfs(vector<int>(v.begin() + 1, v.end()));
if (v[1]) {
v[2] += v[0];
v[1]--;
n = max(n, dfs(vector<int>(v.begin() + 1, v.end())));
}
return n;
}
}
}
int main() {
int n;
cin >> n;
while (n--) {
int l;
cin >> l;
vector<int> v(l);
for (int i = 0; i < l; i++) {
cin >> v[i];
}
fill(p[0][0], p[400][0], false);
cout << dfs(v) << endl;
}
return 0;
} | // 15
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool p[400][400][81];
int dfs(vector<int> v) {
if (v.size() <= 2) {
return v.back();
} else {
if (p[v[0]][v[1]][v.size()]++) {
return 0;
} else {
int n = dfs(vector<int>(v.begin() + 1, v.end()));
if (v[1]) {
v[2] += v[0];
v[1]--;
n = max(n, dfs(vector<int>(v.begin() + 1, v.end())));
}
return n;
}
}
}
int main() {
int n;
cin >> n;
while (n--) {
int l;
cin >> l;
vector<int> v(l);
for (int i = 0; i < l; i++) {
cin >> v[i];
}
fill(p[0][0], p[400][0], false);
cout << dfs(v) << endl;
}
return 0;
} | replace | 7 | 8 | 7 | 8 | MLE | |
p01230 | C++ | Runtime Error | #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))
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--------------------*/
typedef ll Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return (abs(dat) < EPS); }
Matrix operator-(Matrix mat) {
REP(i, mat.size()) REP(j, mat[0].size()) mat[i][j] = -mat[i][j];
return mat;
}
Matrix operator+(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] + rhs[i][j];
return lhs;
}
Matrix operator-(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] - rhs[i][j];
return lhs;
}
Matrix operator*(const Matrix &lhs, const Matrix &rhs) {
Matrix res(lhs.size(), Array(rhs[0].size(), 0));
REP(i, lhs.size())
REP(j, rhs[0].size()) REP(k, rhs.size()) res[i][j] =
fma(lhs[i][k], rhs[k][j], res[i][j]);
return res;
}
Array operator+(const Array &lhs, const Array &rhs) {
Array res = lhs;
REP(i, rhs.size()) res[i] = res[i] + rhs[i];
return res;
}
Array operator*(const Matrix &lhs, const Array &rhs) {
Array res(lhs.size());
REP(i, lhs.size())
res[i] = inner_product(begin(lhs[i]), end(lhs[i]), begin(rhs), Data(0));
return res;
}
Array operator*(Data scalar, const Array &rhs) {
Array res(rhs.size());
REP(i, rhs.size())
res[i] = scalar * rhs[i];
return res;
}
Matrix transpose(const Matrix &A) {
const ll n = A[0].size(), m = A.size();
Matrix res(n, Array(m, 0));
REP(i, n) REP(j, m) res[i][j] = A[j][i];
return res;
}
Data inner_product_ex(const Array &a, const Array &b, const Matrix &m) {
Array b_prime = m * b;
return inner_product(begin(a), end(a), begin(b_prime), Data(0));
}
Data norm(const Array &a) {
return inner_product(begin(a), end(a), begin(a), Data(0));
}
Data norm(const Array &a, const Matrix &M) { return inner_product_ex(a, a, M); }
ll rankMat(Matrix A) {
const ll n = A.size(), m = A[0].size();
ll r = 0;
for (ll i = 0; r < n && i < m; ++i) {
ll pivot = r;
for (ll j = r + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (ll k = m - 1; k >= i; --k)
A[r][k] = A[r][k] / A[r][i];
for (ll j = r + 1; j < n; ++j)
for (ll k = m - 1; k >= i; --k)
A[j][k] = fma(-A[r][k], A[j][i], A[j][k]);
++r;
}
return r;
}
Data det(Matrix A) {
const ll n = A.size();
Data D = Data(1);
for (ll i = 0; i < n; ++i) {
ll pivot = i;
for (ll j = i + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[i]);
D = D * A[i][i] * Data(i != pivot ? -1 : 1);
if (is_zero(A[i][i]))
break;
for (ll j = i + 1; j < n; ++j)
for (ll k = n - 1; k >= i; --k)
A[j][k] = A[j][k] - A[i][k] * A[j][i] / A[i][i];
}
return D;
}
Matrix pow(Matrix x, ll n) {
ll sz = x.size();
Matrix res(sz, Array(sz));
REP(i, sz) res[i][i] = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
void output(bool f) { cout << (f ? "yes" : "no") << endl; }
ll n, m, z;
map<pii, ll> mp;
int main() {
cin.sync_with_stdio(false);
cout << fixed << setprecision(10);
while (cin >> n >> m >> z, n) {
vector<vi> node(n);
REP(i, m) {
ll a, b;
cin >> a >> b;
a--;
b--;
if (b == 0)
swap(a, b);
mp[pii(b, a)] = 1 + i * 2;
node[a].push_back(1 + i * 2);
mp[pii(a, b)] = 2 + i * 2;
node[b].push_back(2 + i * 2);
}
ll nn = mp.size() + 1;
Matrix mat(nn, Array(nn));
for (auto e : mp) {
ll from = e.first.first, to = e.first.second;
if (from == 0) {
mat[0][mp[pii(from, to)]] = 1;
}
for (auto i : node[from]) {
if (i == mp[pii(to, from)])
continue;
mat[i][mp[pii(from, to)]] = 1;
}
}
Matrix ans(1, Array(nn));
ans[0][0] = 1;
ans = ans * pow(mat, z);
bool f = false;
for (auto i : node[n - 1]) {
if (ans[0][i])
f = true;
}
output(f);
}
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))
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--------------------*/
typedef ll Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return (abs(dat) < EPS); }
Matrix operator-(Matrix mat) {
REP(i, mat.size()) REP(j, mat[0].size()) mat[i][j] = -mat[i][j];
return mat;
}
Matrix operator+(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] + rhs[i][j];
return lhs;
}
Matrix operator-(Matrix lhs, const Matrix &rhs) {
REP(i, lhs.size()) REP(j, lhs[0].size()) lhs[i][j] = lhs[i][j] - rhs[i][j];
return lhs;
}
Matrix operator*(const Matrix &lhs, const Matrix &rhs) {
Matrix res(lhs.size(), Array(rhs[0].size(), 0));
REP(i, lhs.size())
REP(j, rhs[0].size()) REP(k, rhs.size()) res[i][j] =
fma(lhs[i][k], rhs[k][j], res[i][j]);
return res;
}
Array operator+(const Array &lhs, const Array &rhs) {
Array res = lhs;
REP(i, rhs.size()) res[i] = res[i] + rhs[i];
return res;
}
Array operator*(const Matrix &lhs, const Array &rhs) {
Array res(lhs.size());
REP(i, lhs.size())
res[i] = inner_product(begin(lhs[i]), end(lhs[i]), begin(rhs), Data(0));
return res;
}
Array operator*(Data scalar, const Array &rhs) {
Array res(rhs.size());
REP(i, rhs.size())
res[i] = scalar * rhs[i];
return res;
}
Matrix transpose(const Matrix &A) {
const ll n = A[0].size(), m = A.size();
Matrix res(n, Array(m, 0));
REP(i, n) REP(j, m) res[i][j] = A[j][i];
return res;
}
Data inner_product_ex(const Array &a, const Array &b, const Matrix &m) {
Array b_prime = m * b;
return inner_product(begin(a), end(a), begin(b_prime), Data(0));
}
Data norm(const Array &a) {
return inner_product(begin(a), end(a), begin(a), Data(0));
}
Data norm(const Array &a, const Matrix &M) { return inner_product_ex(a, a, M); }
ll rankMat(Matrix A) {
const ll n = A.size(), m = A[0].size();
ll r = 0;
for (ll i = 0; r < n && i < m; ++i) {
ll pivot = r;
for (ll j = r + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (ll k = m - 1; k >= i; --k)
A[r][k] = A[r][k] / A[r][i];
for (ll j = r + 1; j < n; ++j)
for (ll k = m - 1; k >= i; --k)
A[j][k] = fma(-A[r][k], A[j][i], A[j][k]);
++r;
}
return r;
}
Data det(Matrix A) {
const ll n = A.size();
Data D = Data(1);
for (ll i = 0; i < n; ++i) {
ll pivot = i;
for (ll j = i + 1; j < n; ++j)
if (abs(A[j][i]) > abs(A[pivot][i]))
pivot = j;
swap(A[pivot], A[i]);
D = D * A[i][i] * Data(i != pivot ? -1 : 1);
if (is_zero(A[i][i]))
break;
for (ll j = i + 1; j < n; ++j)
for (ll k = n - 1; k >= i; --k)
A[j][k] = A[j][k] - A[i][k] * A[j][i] / A[i][i];
}
return D;
}
Matrix pow(Matrix x, ll n) {
ll sz = x.size();
Matrix res(sz, Array(sz));
REP(i, sz) res[i][i] = 1;
while (n > 0) {
if (n & 1)
res = res * x;
x = x * x;
n >>= 1;
}
return res;
}
void output(bool f) { cout << (f ? "yes" : "no") << endl; }
ll n, m, z;
map<pii, ll> mp;
int main() {
cin.sync_with_stdio(false);
cout << fixed << setprecision(10);
while (cin >> n >> m >> z, n) {
mp.clear();
vector<vi> node(n);
REP(i, m) {
ll a, b;
cin >> a >> b;
a--;
b--;
if (b == 0)
swap(a, b);
mp[pii(b, a)] = 1 + i * 2;
node[a].push_back(1 + i * 2);
mp[pii(a, b)] = 2 + i * 2;
node[b].push_back(2 + i * 2);
}
ll nn = mp.size() + 1;
Matrix mat(nn, Array(nn));
for (auto e : mp) {
ll from = e.first.first, to = e.first.second;
if (from == 0) {
mat[0][mp[pii(from, to)]] = 1;
}
for (auto i : node[from]) {
if (i == mp[pii(to, from)])
continue;
mat[i][mp[pii(from, to)]] = 1;
}
}
Matrix ans(1, Array(nn));
ans[0][0] = 1;
ans = ans * pow(mat, z);
bool f = false;
for (auto i : node[n - 1]) {
if (ans[0][i])
f = true;
}
output(f);
}
return 0;
} | insert | 148 | 148 | 148 | 149 | 0 | |
p01233 | C++ | Runtime Error | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
bool go(LL x, LL y, LL a, LL b) {
if (x == a)
return true;
if (y == b)
return true;
if (x + y == a + b)
return true;
if (x - y == a - b)
return true;
return false;
}
typedef pair<int, int> P;
int main() {
int T;
cin >> T;
while (T--) {
LL x1, y1, x2, y2, X, Y;
cin >> x1 >> y1 >> x2 >> y2 >> X >> Y;
if (x1 == X && y1 == Y) {
cout << 0 << endl;
} else if (x2 == X && y2 == Y) {
cout << 0 << endl;
} else if (go(x1, y1, X, Y) && go(x2, y2, X, Y)) {
cout << 1 << endl;
} else if (go(x1, y1, X, Y) || go(x2, y2, X, Y)) {
cout << 2 << endl;
} else if (go(x1, y1, x2, y2)) {
cout << 3 << endl;
} else {
vector<P> vp;
for (int iter = 0; iter < 2; iter++) {
vp.push_back(P(x1, y2));
vp.push_back(P(x1 - y1 + y2, y2));
vp.push_back(P(-x1 + y1 + y2, y2));
vp.push_back(P(x2, -x1 + x2 + y1));
vp.push_back(P(x2, +x1 - x2 + y1));
if ((x1 - y1 + x2 + y2) % 2 == 0) {
vp.push_back(P((x1 - y1 + x2 + y2) / 2, (-x1 + y1 + x2 + y2) / 2));
}
swap(x1, x2);
swap(y1, y2);
}
bool ok = false;
for (auto p : vp) {
assert(p.first != x1 || p.second != y1);
assert(p.first != x2 || p.second != y2);
if (go(p.first, p.second, X, Y)) {
ok = true;
}
}
cout << (ok ? 3 : 4) << endl;
}
}
return 0;
} | #include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
using namespace std;
typedef long long LL;
bool go(LL x, LL y, LL a, LL b) {
if (x == a)
return true;
if (y == b)
return true;
if (x + y == a + b)
return true;
if (x - y == a - b)
return true;
return false;
}
typedef pair<int, int> P;
int main() {
int T;
cin >> T;
while (T--) {
LL x1, y1, x2, y2, X, Y;
cin >> x1 >> y1 >> x2 >> y2 >> X >> Y;
if (x1 == X && y1 == Y) {
cout << 0 << endl;
} else if (x2 == X && y2 == Y) {
cout << 0 << endl;
} else if (go(x1, y1, X, Y) && go(x2, y2, X, Y)) {
cout << 1 << endl;
} else if (go(x1, y1, X, Y) || go(x2, y2, X, Y)) {
cout << 2 << endl;
} else if (go(x1, y1, x2, y2)) {
cout << 3 << endl;
} else {
vector<P> vp;
for (int iter = 0; iter < 2; iter++) {
vp.push_back(P(x1, y2));
vp.push_back(P(x1 - y1 + y2, y2));
vp.push_back(P(x1 + y1 - y2, y2));
vp.push_back(P(x2, -x1 + x2 + y1));
vp.push_back(P(x2, +x1 - x2 + y1));
if ((x1 - y1 + x2 + y2) % 2 == 0) {
vp.push_back(P((x1 - y1 + x2 + y2) / 2, (-x1 + y1 + x2 + y2) / 2));
}
swap(x1, x2);
swap(y1, y2);
}
bool ok = false;
for (auto p : vp) {
assert(p.first != x1 || p.second != y1);
assert(p.first != x2 || p.second != y2);
if (go(p.first, p.second, X, Y)) {
ok = true;
}
}
cout << (ok ? 3 : 4) << endl;
}
}
return 0;
} | replace | 41 | 42 | 41 | 42 | 0 | |
p01235 | C++ | Runtime Error | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#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 inf (1 << 29)
#define EPS (1e-11)
#define all(n) (n).begin(), (n).end()
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
class Point {
public:
double x, y;
Point(double x = -inf, double y = -inf) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
bool operator<(const Point &p) const {
return !equals(x, p.x) ? x < p.x : y < p.y;
}
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
struct Segment {
Point p1, p2;
Segment(Point p1 = Point(-inf, -inf), Point p2 = Point(-inf, -inf))
: p1(p1), p2(p2) {}
bool operator==(const Segment &p) const { return p.p1 == p1 && p.p2 == p2; }
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream &operator<<(ostream &os, const Point &a) {
os << "(" << a.x << "," << a.y << ")";
}
ostream &operator<<(ostream &os, const Segment &a) {
os << "( " << a.p1 << " , " << a.p2 << " )";
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
// rad は角度をラジアンで持たせること
Point rotate(Point a, double rad) {
return Point(cos(rad) * a.x - sin(rad) * a.y,
sin(rad) * a.x + cos(rad) * a.y);
}
// 度をラジアンに変換
double toRad(double agl) { return agl * M_PI / 180.0; }
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) < norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2 - l.p1, m.p2 - m.p1)) > EPS || // non-parallel
abs(cross(l.p2 - l.p1, m.p1 - l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2 - l.p1, s.p1 - l.p1) * // s[0] is left of l
cross(l.p2 - l.p1, s.p2 - l.p1) <
EPS; // s[1] is right of l
}
bool intersectLP(Line l, Point p) {
return abs(cross(l.p2 - p, l.p1 - p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1 - p) + abs(s.p2 - p) - abs(s.p2 - s.p1) <
EPS; // triangle inequality
}
Point projection(Line l, Point p) {
double t = dot(p - l.p1, l.p1 - l.p2) / norm(l.p1 - l.p2);
return l.p1 + (l.p1 - l.p2) * t;
}
Point reflection(Line l, Point p) { return p + (projection(l, p) - p) * 2; }
double distanceLP(Line l, Point p) { return abs(p - projection(l, p)); }
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s))
return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r))
return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t))
return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l, Line m) {
double A = cross(l.p2 - l.p1, m.p2 - m.p1);
double B = cross(l.p2 - l.p1, l.p2 - m.p1);
if (abs(A) < EPS && abs(B) < EPS)
return m.p1; // same line
if (abs(A) < EPS)
assert(false); // !!!PRECONDITION NOT SATISFIED!!!
return m.p1 + (m.p2 - m.p1) * (B / A);
}
// -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-|
struct SP {
Segment seg;
int type; // type 0 -> Point, type 1 -> Segment;
SP(Segment seg = Segment(), int type = inf) : seg(seg), type(type) {}
};
struct Edge {
int from, to;
double cost;
Edge(int from = inf, int to = inf, double cost = inf)
: from(from), to(to), cost(cost) {}
bool operator<(const Edge &a) const { return cost < a.cost; }
};
typedef vector<Edge> vE;
typedef vector<vE> vvE;
int N;
vector<SP> vec;
vector<vector<Edge>> segmentArrangementVer1(vector<Segment> vs,
vector<Point> &ps) {
rep(i, vs.size()) REP(j, i + 1, vs.size()) if (intersectSS(vs[i], vs[j]))
ps.push_back(Point(crosspoint(vs[i], vs[j])));
//
ps.push_back(vec[0].seg.p1);
ps.push_back(vec[1].seg.p2);
//
sort(all(ps));
ps.erase(unique(all(ps)), ps.end());
vector<vector<Edge>> ret(ps.size());
for (int i = 0; i < vs.size(); i++) {
vector<pair<double, int>> list;
rep(j, ps.size()) if (intersectSP(vs[i], ps[j]))
list.push_back(pair<double, int>(norm(vs[i].p1 - ps[j]), j));
sort(all(list));
// for(int j=0;j<list.size()-1;++j) is not good
for (int j = 0; j + 1 < list.size(); ++j) {
int from = list[j].second, to = list[j + 1].second;
double cost = abs(ps[from] - ps[to]);
ret[from].push_back(Edge(from, to, cost));
ret[to].push_back(Edge(to, from, cost));
}
}
return ret;
}
void toSegOnly(vector<Segment> &vs) {
rep(i, 2) {
REP(j, 2, 2 + N) {
assert(vec[i].seg.p1 == vec[i].seg.p2);
Point prj = projection(vec[j].seg, vec[i].seg.p1);
// cout << i << "," << j << " : " << prj << endl;
if (intersectSP(vec[j].seg, prj)) {
if (vec[i].seg.p1 == prj)
continue;
// cout << vec[i].seg.p1 << " intersect : " << i << " and " << j << " "
// << prj << endl;
Point e = vec[i].seg.p1 - prj;
// cout << "fe : " << e << endl;
e = (e / abs(e)) * 1000;
// cout << "e : " << e << endl;
vs.push_back(Segment(vec[i].seg.p1 - e, prj + e));
}
}
}
/*
cout << "VS =----------------- " << vs.size() << endl;
rep(i,vs.size())
cout << vs[i] << endl;
*/
REP(j, 2, 2 + N) {
Segment seg =
Segment(vec[j].seg.p1 - vec[j].seg.p2, vec[j].seg.p2 - vec[j].seg.p2);
Point rig = rotate(seg.p1, toRad(90.0));
rig = (rig / abs(rig)) * 1000;
vs.push_back(Segment(vec[j].seg.p1 - rig, vec[j].seg.p1 + rig));
vs.push_back(Segment(vec[j].seg.p2 - rig, vec[j].seg.p2 + rig));
}
}
// segment merge--------
bool merge_if_able(Segment &s, Segment t) {
if (abs(cross(s.p2 - s.p1, t.p2 - t.p1)) > EPS)
return false;
if (ccw(s.p1, t.p1, s.p2) == +1 || ccw(s.p1, t.p1, s.p2) == -1)
return false; // not on the same line
if (ccw(s.p1, s.p2, t.p1) == -2 || ccw(t.p1, t.p2, s.p1) == -2)
return false; // separated
s = Segment(min(s.p1, t.p1), max(s.p2, t.p2));
return true;
}
void merge_segments(vector<Segment> &segs) {
for (int i = 0; i < segs.size(); ++i)
if (segs[i].p2 < segs[i].p1)
swap(segs[i].p2, segs[i].p1);
for (int i = 0; i < segs.size(); ++i)
for (int j = i + 1; j < segs.size(); ++j)
if (merge_if_able(segs[i], segs[j]))
segs[j--] = segs.back(), segs.pop_back();
}
// -------------------
struct Pox {
int cur;
double cost;
Pox(int cur = inf, double cost = inf) : cur(cur), cost(cost) {}
bool operator<(const Pox &a) const { return cost > a.cost; }
};
void dijkstra(vvE &G, int st, int ed) {
int n = G.size();
double mincost[n];
rep(i, n) mincost[i] = inf;
mincost[st] = 0;
priority_queue<Pox> Q;
Q.push(Pox(st, 0));
while (!Q.empty()) {
Pox pox = Q.top();
Q.pop();
if (pox.cur == ed) {
cout << setiosflags(ios::fixed) << setprecision(5) << pox.cost << endl;
return;
}
rep(i, G[pox.cur].size()) {
int next = G[pox.cur][i].to;
double cost = G[pox.cur][i].cost;
if (!equals(mincost[next], pox.cost + cost) &&
mincost[next] > pox.cost + cost) {
mincost[next] = pox.cost + cost;
Q.push(Pox(next, pox.cost + cost));
}
}
}
cout << "Impossible" << endl;
}
void compute() {
vector<Segment> vs;
toSegOnly(vs);
/*
cout << "vs------bef" << endl;
rep(i,vs.size())
{
cout << vs[i] << endl;
}
rep(i,vs.size())
if(!equals(vs[i].p1.x,vs[i].p2.x) && vs[i].p1.x > vs[i].p2.x)
swap(vs[i].p1,vs[i].p2);
*/
merge_segments(vs);
/*
cout << "vs------aft" << endl;
rep(i,vs.size())
{
cout << vs[i] << endl;
}
*/
vector<Point> ps;
vvE G = segmentArrangementVer1(vs, ps);
int st_index, ed_index;
rep(i, ps.size()) {
// cout << "ps[" << i << "] = "<< ps[i] << endl;
if (ps[i] == vec[0].seg.p1)
st_index = i;
if (ps[i] == vec[1].seg.p1)
ed_index = i;
}
// cout << "st = " << st_index << endl;
// cout << "ed = " << ed_index << endl;
/*
cout << "G-----" << endl;
rep(i,G.size())
{
cout << "node " << i << endl;
rep(j,G[i].size())
{
cout << "(" << G[i][j].from << "," << G[i][j].to << "," <<
G[i][j].cost << ") ";
}
cout << endl;
}
*/
dijkstra(G, st_index, ed_index);
}
int main() {
int CNT = 1;
while (cin >> N, N) {
vec.clear();
vec.resize(N + 2);
double x, y;
rep(i, 2) {
cin >> x >> y;
vec[i].seg.p1 = vec[i].seg.p2 = Point(x, y);
vec[i].type = 0;
}
rep(i, N) cin >> vec[2 + i].seg.p1.x >> vec[2 + i].seg.p1.y >>
vec[2 + i].seg.p2.x >> vec[2 + i].seg.p2.y;
cout << "Case " << CNT++ << ": ";
compute();
}
return 0;
} | #include <algorithm>
#include <cassert>
#include <cmath>
#include <complex>
#include <iomanip>
#include <iostream>
#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 inf (1 << 29)
#define EPS (1e-8)
#define all(n) (n).begin(), (n).end()
#define COUNTER_CLOCKWISE 1
#define CLOCKWISE -1
#define ONLINE_BACK 2
#define ONLINE_FRONT -2
#define ON_SEGMENT 0
#define equals(a, b) (fabs((a) - (b)) < EPS)
using namespace std;
//*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-
class Point {
public:
double x, y;
Point(double x = -inf, double y = -inf) : x(x), y(y) {}
Point operator+(Point p) { return Point(x + p.x, y + p.y); }
Point operator-(Point p) { return Point(x - p.x, y - p.y); }
Point operator*(double a) { return Point(a * x, a * y); }
Point operator/(double a) { return Point(x / a, y / a); }
bool operator<(const Point &p) const {
return !equals(x, p.x) ? x < p.x : y < p.y;
}
bool operator==(const Point &p) const {
return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
}
};
struct Segment {
Point p1, p2;
Segment(Point p1 = Point(-inf, -inf), Point p2 = Point(-inf, -inf))
: p1(p1), p2(p2) {}
bool operator==(const Segment &p) const { return p.p1 == p1 && p.p2 == p2; }
};
typedef Point Vector;
typedef Segment Line;
typedef vector<Point> Polygon;
ostream &operator<<(ostream &os, const Point &a) {
os << "(" << a.x << "," << a.y << ")";
}
ostream &operator<<(ostream &os, const Segment &a) {
os << "( " << a.p1 << " , " << a.p2 << " )";
}
double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
double norm(Point a) { return a.x * a.x + a.y * a.y; }
double abs(Point a) { return sqrt(norm(a)); }
// rad は角度をラジアンで持たせること
Point rotate(Point a, double rad) {
return Point(cos(rad) * a.x - sin(rad) * a.y,
sin(rad) * a.x + cos(rad) * a.y);
}
// 度をラジアンに変換
double toRad(double agl) { return agl * M_PI / 180.0; }
int ccw(Point p0, Point p1, Point p2) {
Point a = p1 - p0;
Point b = p2 - p0;
if (cross(a, b) > EPS)
return COUNTER_CLOCKWISE;
if (cross(a, b) < -EPS)
return CLOCKWISE;
if (dot(a, b) < -EPS)
return ONLINE_BACK;
if (norm(a) < norm(b))
return ONLINE_FRONT;
return ON_SEGMENT;
}
bool intersectLL(Line l, Line m) {
return abs(cross(l.p2 - l.p1, m.p2 - m.p1)) > EPS || // non-parallel
abs(cross(l.p2 - l.p1, m.p1 - l.p1)) < EPS; // same line
}
bool intersectLS(Line l, Line s) {
return cross(l.p2 - l.p1, s.p1 - l.p1) * // s[0] is left of l
cross(l.p2 - l.p1, s.p2 - l.p1) <
EPS; // s[1] is right of l
}
bool intersectLP(Line l, Point p) {
return abs(cross(l.p2 - p, l.p1 - p)) < EPS;
}
bool intersectSS(Line s, Line t) {
return ccw(s.p1, s.p2, t.p1) * ccw(s.p1, s.p2, t.p2) <= 0 &&
ccw(t.p1, t.p2, s.p1) * ccw(t.p1, t.p2, s.p2) <= 0;
}
bool intersectSP(Line s, Point p) {
return abs(s.p1 - p) + abs(s.p2 - p) - abs(s.p2 - s.p1) <
EPS; // triangle inequality
}
Point projection(Line l, Point p) {
double t = dot(p - l.p1, l.p1 - l.p2) / norm(l.p1 - l.p2);
return l.p1 + (l.p1 - l.p2) * t;
}
Point reflection(Line l, Point p) { return p + (projection(l, p) - p) * 2; }
double distanceLP(Line l, Point p) { return abs(p - projection(l, p)); }
double distanceLL(Line l, Line m) {
return intersectLL(l, m) ? 0 : distanceLP(l, m.p1);
}
double distanceLS(Line l, Line s) {
if (intersectLS(l, s))
return 0;
return min(distanceLP(l, s.p1), distanceLP(l, s.p2));
}
double distanceSP(Line s, Point p) {
Point r = projection(s, p);
if (intersectSP(s, r))
return abs(r - p);
return min(abs(s.p1 - p), abs(s.p2 - p));
}
double distanceSS(Line s, Line t) {
if (intersectSS(s, t))
return 0;
return min(min(distanceSP(s, t.p1), distanceSP(s, t.p2)),
min(distanceSP(t, s.p1), distanceSP(t, s.p2)));
}
Point crosspoint(Line l, Line m) {
double A = cross(l.p2 - l.p1, m.p2 - m.p1);
double B = cross(l.p2 - l.p1, l.p2 - m.p1);
if (abs(A) < EPS && abs(B) < EPS)
return m.p1; // same line
if (abs(A) < EPS)
assert(false); // !!!PRECONDITION NOT SATISFIED!!!
return m.p1 + (m.p2 - m.p1) * (B / A);
}
// -*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-*-|
struct SP {
Segment seg;
int type; // type 0 -> Point, type 1 -> Segment;
SP(Segment seg = Segment(), int type = inf) : seg(seg), type(type) {}
};
struct Edge {
int from, to;
double cost;
Edge(int from = inf, int to = inf, double cost = inf)
: from(from), to(to), cost(cost) {}
bool operator<(const Edge &a) const { return cost < a.cost; }
};
typedef vector<Edge> vE;
typedef vector<vE> vvE;
int N;
vector<SP> vec;
vector<vector<Edge>> segmentArrangementVer1(vector<Segment> vs,
vector<Point> &ps) {
rep(i, vs.size()) REP(j, i + 1, vs.size()) if (intersectSS(vs[i], vs[j]))
ps.push_back(Point(crosspoint(vs[i], vs[j])));
//
ps.push_back(vec[0].seg.p1);
ps.push_back(vec[1].seg.p2);
//
sort(all(ps));
ps.erase(unique(all(ps)), ps.end());
vector<vector<Edge>> ret(ps.size());
for (int i = 0; i < vs.size(); i++) {
vector<pair<double, int>> list;
rep(j, ps.size()) if (intersectSP(vs[i], ps[j]))
list.push_back(pair<double, int>(norm(vs[i].p1 - ps[j]), j));
sort(all(list));
// for(int j=0;j<list.size()-1;++j) is not good
for (int j = 0; j + 1 < list.size(); ++j) {
int from = list[j].second, to = list[j + 1].second;
double cost = abs(ps[from] - ps[to]);
ret[from].push_back(Edge(from, to, cost));
ret[to].push_back(Edge(to, from, cost));
}
}
return ret;
}
void toSegOnly(vector<Segment> &vs) {
rep(i, 2) {
REP(j, 2, 2 + N) {
assert(vec[i].seg.p1 == vec[i].seg.p2);
Point prj = projection(vec[j].seg, vec[i].seg.p1);
// cout << i << "," << j << " : " << prj << endl;
if (intersectSP(vec[j].seg, prj)) {
if (vec[i].seg.p1 == prj)
continue;
// cout << vec[i].seg.p1 << " intersect : " << i << " and " << j << " "
// << prj << endl;
Point e = vec[i].seg.p1 - prj;
// cout << "fe : " << e << endl;
e = (e / abs(e)) * 1000;
// cout << "e : " << e << endl;
vs.push_back(Segment(vec[i].seg.p1 - e, prj + e));
}
}
}
/*
cout << "VS =----------------- " << vs.size() << endl;
rep(i,vs.size())
cout << vs[i] << endl;
*/
REP(j, 2, 2 + N) {
Segment seg =
Segment(vec[j].seg.p1 - vec[j].seg.p2, vec[j].seg.p2 - vec[j].seg.p2);
Point rig = rotate(seg.p1, toRad(90.0));
rig = (rig / abs(rig)) * 1000;
vs.push_back(Segment(vec[j].seg.p1 - rig, vec[j].seg.p1 + rig));
vs.push_back(Segment(vec[j].seg.p2 - rig, vec[j].seg.p2 + rig));
}
}
// segment merge--------
bool merge_if_able(Segment &s, Segment t) {
if (abs(cross(s.p2 - s.p1, t.p2 - t.p1)) > EPS)
return false;
if (ccw(s.p1, t.p1, s.p2) == +1 || ccw(s.p1, t.p1, s.p2) == -1)
return false; // not on the same line
if (ccw(s.p1, s.p2, t.p1) == -2 || ccw(t.p1, t.p2, s.p1) == -2)
return false; // separated
s = Segment(min(s.p1, t.p1), max(s.p2, t.p2));
return true;
}
void merge_segments(vector<Segment> &segs) {
for (int i = 0; i < segs.size(); ++i)
if (segs[i].p2 < segs[i].p1)
swap(segs[i].p2, segs[i].p1);
for (int i = 0; i < segs.size(); ++i)
for (int j = i + 1; j < segs.size(); ++j)
if (merge_if_able(segs[i], segs[j]))
segs[j--] = segs.back(), segs.pop_back();
}
// -------------------
struct Pox {
int cur;
double cost;
Pox(int cur = inf, double cost = inf) : cur(cur), cost(cost) {}
bool operator<(const Pox &a) const { return cost > a.cost; }
};
void dijkstra(vvE &G, int st, int ed) {
int n = G.size();
double mincost[n];
rep(i, n) mincost[i] = inf;
mincost[st] = 0;
priority_queue<Pox> Q;
Q.push(Pox(st, 0));
while (!Q.empty()) {
Pox pox = Q.top();
Q.pop();
if (pox.cur == ed) {
cout << setiosflags(ios::fixed) << setprecision(5) << pox.cost << endl;
return;
}
rep(i, G[pox.cur].size()) {
int next = G[pox.cur][i].to;
double cost = G[pox.cur][i].cost;
if (!equals(mincost[next], pox.cost + cost) &&
mincost[next] > pox.cost + cost) {
mincost[next] = pox.cost + cost;
Q.push(Pox(next, pox.cost + cost));
}
}
}
cout << "Impossible" << endl;
}
void compute() {
vector<Segment> vs;
toSegOnly(vs);
/*
cout << "vs------bef" << endl;
rep(i,vs.size())
{
cout << vs[i] << endl;
}
rep(i,vs.size())
if(!equals(vs[i].p1.x,vs[i].p2.x) && vs[i].p1.x > vs[i].p2.x)
swap(vs[i].p1,vs[i].p2);
*/
merge_segments(vs);
/*
cout << "vs------aft" << endl;
rep(i,vs.size())
{
cout << vs[i] << endl;
}
*/
vector<Point> ps;
vvE G = segmentArrangementVer1(vs, ps);
int st_index, ed_index;
rep(i, ps.size()) {
// cout << "ps[" << i << "] = "<< ps[i] << endl;
if (ps[i] == vec[0].seg.p1)
st_index = i;
if (ps[i] == vec[1].seg.p1)
ed_index = i;
}
// cout << "st = " << st_index << endl;
// cout << "ed = " << ed_index << endl;
/*
cout << "G-----" << endl;
rep(i,G.size())
{
cout << "node " << i << endl;
rep(j,G[i].size())
{
cout << "(" << G[i][j].from << "," << G[i][j].to << "," <<
G[i][j].cost << ") ";
}
cout << endl;
}
*/
dijkstra(G, st_index, ed_index);
}
int main() {
int CNT = 1;
while (cin >> N, N) {
vec.clear();
vec.resize(N + 2);
double x, y;
rep(i, 2) {
cin >> x >> y;
vec[i].seg.p1 = vec[i].seg.p2 = Point(x, y);
vec[i].type = 0;
}
rep(i, N) cin >> vec[2 + i].seg.p1.x >> vec[2 + i].seg.p1.y >>
vec[2 + i].seg.p2.x >> vec[2 + i].seg.p2.y;
cout << "Case " << CNT++ << ": ";
compute();
}
return 0;
} | replace | 12 | 13 | 12 | 13 | 0 | |
p01236 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
int H, W;
vector<pair<int, int>> get_z(int now_x, int now_y) {
int rest = W + 1;
vector<pair<int, int>> z;
while (rest--) {
if (!now_x && !now_y)
break;
if (!now_x) {
now_y--;
now_x = W - 1;
} else {
now_x--;
}
z.push_back(make_pair(now_x, now_y));
}
reverse(z.begin(), z.end());
return z;
}
bool connect(pair<int, int> &l, pair<int, int> &r) {
return abs(l.first - r.first) <= 1 && abs(l.second - r.second) <= 1;
}
int main() {
int case_cnt = 0;
while (cin >> W >> H) {
if (!H)
break;
case_cnt++;
vector<vector<int>> field(H, vector<int>(W));
for (int i = 0; i < H; ++i) {
string st;
cin >> st;
for (int j = 0; j < W; ++j) {
field[i][j] = st[j] == '#';
}
}
map<vector<pair<int, int>>, pair<int, int>> prevs;
prevs.emplace(vector<pair<int, int>>(0), make_pair(0, 0));
int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
for (int now_y = 0; now_y < H; ++now_y) {
for (int now_x = 0; now_x < W; ++now_x) {
pair<int, int> now(now_x, now_y);
map<vector<pair<int, int>>, pair<int, int>> next_prevs;
vector<pair<int, int>> zahyous(get_z(now_x, now_y));
for (auto &&aprev : prevs) {
const int prev_min_cnt = aprev.second.first;
const int prev_max_cnt = aprev.second.second;
for (int now_black = 0; now_black < 2; ++now_black) {
vector<pair<int, int>> next_p(aprev.first);
// black
int now_num = now_black;
{
bool x_hasi = now_x == 0 || now_x == W - 1;
bool y_hasi = now_y == 0 || now_y == H - 1;
if (x_hasi && y_hasi) {
if (H == 1 || W == 1)
now_num *= 6;
else
now_num *= 4;
} else if (x_hasi || y_hasi) {
if (x_hasi && now_x == 0 && now_x == W - 1)
now_num *= 3;
else if (y_hasi && now_y == 0 && now_y == H - 1)
now_num *= 3;
else
now_num *= 2;
}
}
for (int i = 0; i < zahyous.size(); ++i) {
int bai = 1;
if (now_x == 0 && zahyous[i].first == 0)
bai++;
if (now_x == W - 1 && zahyous[i].first == W - 1)
bai++;
if (now_y == 0 && zahyous[i].second == 0)
bai++;
if (now_y == H - 1 && zahyous[i].second == H - 1)
bai++;
if (connect(zahyous[i], now)) {
if (now_black) {
next_p[i].second += bai;
}
if (next_p[i].first) {
now_num += bai;
}
}
}
bool ok = true;
if (zahyous.size() == W + 1) {
bool f_black = field[zahyous[0].second][zahyous[0].first] == 1;
int num = next_p[0].second;
if ((f_black ^ (num >= 5))) {
ok = false;
}
}
if (ok) {
if (zahyous.size() == W + 1) {
next_p.erase(next_p.begin());
}
next_p.push_back(make_pair(now_black, now_num));
for (int i = 0; i < next_p.size(); ++i) {
next_p[i].second = min(5, next_p[i].second);
}
if (next_prevs.find(next_p) == next_prevs.end()) {
next_prevs[next_p] = make_pair(prev_min_cnt + now_black,
prev_max_cnt + now_black);
} else {
next_prevs[next_p] = make_pair(
min(next_prevs[next_p].first, prev_min_cnt + now_black),
max(next_prevs[next_p].second, prev_max_cnt + now_black));
}
}
}
}
prevs = move(next_prevs);
next_prevs.clear();
}
}
int amin = 1000;
int amax = -1;
{
vector<pair<int, int>> zahyous(get_z(0, H));
for (auto &&pr : prevs) {
bool valid = true;
for (int i = 0; i < pr.first.size(); ++i) {
bool f_black = field[zahyous[i].second][zahyous[i].first] == 1;
int num = pr.first[i].second;
if (f_black ^ (num >= 5)) {
valid = false;
}
}
if (valid) {
amin = min(amin, pr.second.first);
amax = max(amax, pr.second.second);
}
}
}
cout << "Case " << case_cnt << ": ";
if (amin == 1000) {
cout << "Impossible" << endl;
} else {
cout << amax - amin << endl;
}
}
return 0;
}
| #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
int H, W;
vector<pair<int, int>> get_z(int now_x, int now_y) {
int rest = W + 1;
vector<pair<int, int>> z;
while (rest--) {
if (!now_x && !now_y)
break;
if (!now_x) {
now_y--;
now_x = W - 1;
} else {
now_x--;
}
z.push_back(make_pair(now_x, now_y));
}
reverse(z.begin(), z.end());
return z;
}
bool connect(pair<int, int> &l, pair<int, int> &r) {
return abs(l.first - r.first) <= 1 && abs(l.second - r.second) <= 1;
}
int main() {
int case_cnt = 0;
while (cin >> W >> H) {
if (!H)
break;
case_cnt++;
vector<vector<int>> field(H, vector<int>(W));
for (int i = 0; i < H; ++i) {
string st;
cin >> st;
for (int j = 0; j < W; ++j) {
field[i][j] = st[j] == '#';
}
}
map<vector<pair<int, int>>, pair<int, int>> prevs;
prevs.emplace(vector<pair<int, int>>(0), make_pair(0, 0));
int dx8[8] = {-1, -1, -1, 0, 1, 1, 1, 0};
int dy8[8] = {-1, 0, 1, 1, 1, 0, -1, -1};
for (int now_y = 0; now_y < H; ++now_y) {
for (int now_x = 0; now_x < W; ++now_x) {
pair<int, int> now(now_x, now_y);
map<vector<pair<int, int>>, pair<int, int>> next_prevs;
vector<pair<int, int>> zahyous(get_z(now_x, now_y));
for (auto &&aprev : prevs) {
const int prev_min_cnt = aprev.second.first;
const int prev_max_cnt = aprev.second.second;
for (int now_black = 0; now_black < 2; ++now_black) {
vector<pair<int, int>> next_p(aprev.first);
// black
int now_num = now_black;
{
bool x_hasi = now_x == 0 || now_x == W - 1;
bool y_hasi = now_y == 0 || now_y == H - 1;
if (x_hasi && y_hasi) {
if (H == 1 || W == 1)
now_num *= 6;
else
now_num *= 4;
} else if (x_hasi || y_hasi) {
if (x_hasi && now_x == 0 && now_x == W - 1)
now_num *= 3;
else if (y_hasi && now_y == 0 && now_y == H - 1)
now_num *= 3;
else
now_num *= 2;
}
}
for (int i = 0; i < zahyous.size(); ++i) {
int bai = 1;
if (now_x == 0 && zahyous[i].first == 0)
bai++;
if (now_x == W - 1 && zahyous[i].first == W - 1)
bai++;
if (now_y == 0 && zahyous[i].second == 0)
bai++;
if (now_y == H - 1 && zahyous[i].second == H - 1)
bai++;
if (connect(zahyous[i], now)) {
if (now_black) {
next_p[i].second += bai;
}
if (next_p[i].first) {
now_num += bai;
}
}
}
bool ok = true;
if (zahyous.size() == W + 1) {
bool f_black = field[zahyous[0].second][zahyous[0].first] == 1;
int num = next_p[0].second;
if ((f_black ^ (num >= 5))) {
ok = false;
}
}
if (ok) {
if (zahyous.size() == W + 1) {
next_p.erase(next_p.begin());
}
next_p.push_back(make_pair(now_black, now_num));
for (int i = 0; i < next_p.size(); ++i) {
next_p[i].second = min(5, next_p[i].second);
}
if (next_p.size() == W + 1 && next_p[0].second < 3)
next_p[0].second = 0;
if (next_prevs.find(next_p) == next_prevs.end()) {
next_prevs[next_p] = make_pair(prev_min_cnt + now_black,
prev_max_cnt + now_black);
} else {
next_prevs[next_p] = make_pair(
min(next_prevs[next_p].first, prev_min_cnt + now_black),
max(next_prevs[next_p].second, prev_max_cnt + now_black));
}
}
}
}
prevs = move(next_prevs);
next_prevs.clear();
}
}
int amin = 1000;
int amax = -1;
{
vector<pair<int, int>> zahyous(get_z(0, H));
for (auto &&pr : prevs) {
bool valid = true;
for (int i = 0; i < pr.first.size(); ++i) {
bool f_black = field[zahyous[i].second][zahyous[i].first] == 1;
int num = pr.first[i].second;
if (f_black ^ (num >= 5)) {
valid = false;
}
}
if (valid) {
amin = min(amin, pr.second.first);
amax = max(amax, pr.second.second);
}
}
}
cout << "Case " << case_cnt << ": ";
if (amin == 1000) {
cout << "Impossible" << endl;
} else {
cout << amax - amin << endl;
}
}
return 0;
}
| insert | 120 | 120 | 120 | 122 | TLE | |
p01240 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int field[21][21];
int dp[2][1 << 20];
int h, w;
//
// int dfs(int a,int s){
// if(a==h*w)return 0;
// if(dp[a][s]!=-1)return dp[a][s];
// int res=0;
// int curh=a/w;
// int curw=a%w;
// // ツ置ツつゥツづ按つ「
// {
// int ns=s;
// ns&=~(1<<curw);
// res=max(res,dfs(a+1,ns));
// }
// // ツ置ツつッツづゥツづ按づァツ置ツつュ
// if((curw==0||!((s>>(curw-1))&1))&&(curh==0||!((s>>(curw))&1))){
// int ns=s;
// ns|=(1<<curw);
// res=max(res,dfs(a+1,ns)+field[curh][curw]);
// }
// return dp[a][s]=res;
//}
int main() {
int t;
cin >> t;
int cnt = 0;
while (cnt < t) {
cnt++;
cin >> w >> h;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
cin >> field[i][j];
memset(dp, 0, sizeof(dp));
for (int i = h * w - 1; i >= 0; i--) {
for (int j = 0; j < (1 << w); j++) {
int s = j;
int nxt = i % 2;
int cur = (i + 1) % 2;
int curh = i / w;
int curw = i % w;
dp[nxt][s] = 0;
// ツ置ツつゥツづ按つ「
{
int ns = s;
ns &= ~(1 << curw);
dp[nxt][s] = max(dp[nxt][s], dp[cur][ns]);
}
// ツ置ツつッツづゥツづ按づァツ置ツつュ
if ((curw == 0 || !((s >> (curw - 1)) & 1)) &&
(curh == 0 || !((s >> (curw)) & 1))) {
int ns = s;
ns |= (1 << curw);
dp[nxt][s] = max(dp[nxt][s], dp[cur][ns] + field[curh][curw]);
}
}
}
int res = dp[0][0];
cout << "Case " << cnt << ": " << res << endl;
}
return 0;
} | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
int field[21][21];
int dp[2][1 << 20];
int h, w;
//
// int dfs(int a,int s){
// if(a==h*w)return 0;
// if(dp[a][s]!=-1)return dp[a][s];
// int res=0;
// int curh=a/w;
// int curw=a%w;
// // ツ置ツつゥツづ按つ「
// {
// int ns=s;
// ns&=~(1<<curw);
// res=max(res,dfs(a+1,ns));
// }
// // ツ置ツつッツづゥツづ按づァツ置ツつュ
// if((curw==0||!((s>>(curw-1))&1))&&(curh==0||!((s>>(curw))&1))){
// int ns=s;
// ns|=(1<<curw);
// res=max(res,dfs(a+1,ns)+field[curh][curw]);
// }
// return dp[a][s]=res;
//}
int main() {
int t;
cin >> t;
int cnt = 0;
while (cnt < t) {
cnt++;
cin >> w >> h;
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
cin >> field[i][j];
if (w > h) {
int tf[21][21];
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
tf[w - 1 - j][i] = field[i][j];
swap(h, w);
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
field[i][j] = tf[i][j];
}
memset(dp, 0, sizeof(dp));
for (int i = h * w - 1; i >= 0; i--) {
for (int j = 0; j < (1 << w); j++) {
int s = j;
int nxt = i % 2;
int cur = (i + 1) % 2;
int curh = i / w;
int curw = i % w;
dp[nxt][s] = 0;
// ツ置ツつゥツづ按つ「
{
int ns = s;
ns &= ~(1 << curw);
dp[nxt][s] = max(dp[nxt][s], dp[cur][ns]);
}
// ツ置ツつッツづゥツづ按づァツ置ツつュ
if ((curw == 0 || !((s >> (curw - 1)) & 1)) &&
(curh == 0 || !((s >> (curw)) & 1))) {
int ns = s;
ns |= (1 << curw);
dp[nxt][s] = max(dp[nxt][s], dp[cur][ns] + field[curh][curw]);
}
}
}
int res = dp[0][0];
cout << "Case " << cnt << ": " << res << endl;
}
return 0;
} | insert | 43 | 43 | 43 | 53 | TLE | |
p01240 | 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 all(c) (c).begin(), (c).end()
#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;
template <class T> constexpr bool in_range(T y, T x, T H, T W) {
return 0 <= y && y < H && 0 <= x && x < W;
}
namespace flow {
struct edge {
int to, cap, rev;
edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
class dinic {
private:
vector<vector<edge>> G;
vector<int> level;
vector<int> iter;
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto &e : G[v]) {
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
int dfs(int v, int t, int flow) {
if (v == t)
return flow;
for (int &i = iter[v]; i < G[v].size(); i++) {
auto &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
if (int d = dfs(e.to, t, min(flow, e.cap))) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
public:
dinic(int N) : G(N), level(N), iter(N) {}
void add_edge(int from, int to, int cap) {
G[from].emplace_back(to, cap, G[to].size());
G[to].emplace_back(from, 0, G[from].size() - 1);
}
int max_flow(int s, int t) {
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, inf)) > 0) {
flow += f;
}
}
}
};
} // namespace flow
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int main() {
int TC;
cin >> TC;
rep(tc, TC) {
int W, H;
cin >> W >> H;
vector<vector<int>> G(H);
rep(i, H) G[i].resize(W);
int total = 0;
rep(i, H) rep(j, W) cin >> G[i][j], total += G[i][j];
flow::dinic dn((H * W + 10) / 2 + 10);
const int SRC = (H * W + 10) / 2, SINK = (H * W + 10) / 2 + 1;
rep(i, H) rep(j, W) {
if ((i + j) % 2) {
dn.add_edge(SRC, i * W + j, G[i][j]);
rep(k, 4) {
int ni = i + dy[k], nj = j + dx[k];
if (!in_range(ni, nj, H, W))
continue;
dn.add_edge(i * W + j, ni * W + nj, inf);
}
} else {
dn.add_edge(i * W + j, SINK, G[i][j]);
}
}
cout << "Case " << tc + 1 << ": " << total - dn.max_flow(SRC, SINK) << 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 all(c) (c).begin(), (c).end()
#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;
template <class T> constexpr bool in_range(T y, T x, T H, T W) {
return 0 <= y && y < H && 0 <= x && x < W;
}
namespace flow {
struct edge {
int to, cap, rev;
edge(int t, int c, int r) : to(t), cap(c), rev(r) {}
};
class dinic {
private:
vector<vector<edge>> G;
vector<int> level;
vector<int> iter;
void bfs(int s) {
fill(level.begin(), level.end(), -1);
queue<int> q;
level[s] = 0;
q.push(s);
while (!q.empty()) {
int v = q.front();
q.pop();
for (auto &e : G[v]) {
if (e.cap > 0 && level[e.to] < 0) {
level[e.to] = level[v] + 1;
q.push(e.to);
}
}
}
}
int dfs(int v, int t, int flow) {
if (v == t)
return flow;
for (int &i = iter[v]; i < G[v].size(); i++) {
auto &e = G[v][i];
if (e.cap > 0 && level[v] < level[e.to]) {
if (int d = dfs(e.to, t, min(flow, e.cap))) {
e.cap -= d;
G[e.to][e.rev].cap += d;
return d;
}
}
}
return 0;
}
public:
dinic(int N) : G(N), level(N), iter(N) {}
void add_edge(int from, int to, int cap) {
G[from].emplace_back(to, cap, G[to].size());
G[to].emplace_back(from, 0, G[from].size() - 1);
}
int max_flow(int s, int t) {
int flow = 0;
for (;;) {
bfs(s);
if (level[t] < 0)
return flow;
fill(iter.begin(), iter.end(), 0);
int f;
while ((f = dfs(s, t, inf)) > 0) {
flow += f;
}
}
}
};
} // namespace flow
int dx[4] = {-1, 0, 1, 0};
int dy[4] = {0, -1, 0, 1};
int main() {
int TC;
cin >> TC;
rep(tc, TC) {
int W, H;
cin >> W >> H;
vector<vector<int>> G(H);
rep(i, H) G[i].resize(W);
int total = 0;
rep(i, H) rep(j, W) cin >> G[i][j], total += G[i][j];
flow::dinic dn(H * W + 2);
const int SRC = H * W, SINK = H * W + 1;
rep(i, H) rep(j, W) {
if ((i + j) % 2) {
dn.add_edge(SRC, i * W + j, G[i][j]);
rep(k, 4) {
int ni = i + dy[k], nj = j + dx[k];
if (!in_range(ni, nj, H, W))
continue;
dn.add_edge(i * W + j, ni * W + nj, inf);
}
} else {
dn.add_edge(i * W + j, SINK, G[i][j]);
}
}
cout << "Case " << tc + 1 << ": " << total - dn.max_flow(SRC, SINK) << endl;
}
return 0;
} | replace | 113 | 115 | 113 | 115 | 0 | |
p01244 | C++ | Time Limit Exceeded | #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
vector<int> primes;
void hurui(const int amax) {
static bool flag = false;
if (flag)
return;
vector<int> sos;
sos = vector<int>(amax + 1, true);
sos[0] = false;
sos[1] = false;
for (int i = 2; i <= amax; ++i) {
if (sos[i]) {
for (int j = 2 * i; j <= amax; j += i)
sos[j] = false;
}
}
for (int i = 0; i <= amax; ++i) {
if (sos[i]) {
primes.push_back(i);
}
}
flag = true;
}
long long int K;
ld solve(long long int now_num, int pr_id, int use_max, ld now_val) {
if (use_max == 0) {
return now_val;
}
if (primes.size() == pr_id) {
return now_val;
} else {
ld ans = now_val;
int now_use = 0;
long long int pr_sum = 1;
long long int div_sum = 1;
ld next_val = now_val * pr_sum / div_sum;
long long int next_num = now_num;
while (next_num <= K) {
ans = max(ans, solve(next_num, pr_id + 1, now_use, next_val));
now_use++;
div_sum *= primes[pr_id];
pr_sum += div_sum;
next_val = now_val * pr_sum / div_sum;
next_num *= primes[pr_id];
}
return ans;
}
}
int main() {
hurui(1e3);
int case_id = 0;
while (true) {
cin >> K;
ld ans = solve(1, 0, 1000, 1);
cout << setprecision(10) << fixed << ans << endl;
}
return 0;
}
| #include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
vector<int> primes;
void hurui(const int amax) {
static bool flag = false;
if (flag)
return;
vector<int> sos;
sos = vector<int>(amax + 1, true);
sos[0] = false;
sos[1] = false;
for (int i = 2; i <= amax; ++i) {
if (sos[i]) {
for (int j = 2 * i; j <= amax; j += i)
sos[j] = false;
}
}
for (int i = 0; i <= amax; ++i) {
if (sos[i]) {
primes.push_back(i);
}
}
flag = true;
}
long long int K;
ld solve(long long int now_num, int pr_id, int use_max, ld now_val) {
if (use_max == 0) {
return now_val;
}
if (primes.size() == pr_id) {
return now_val;
} else {
ld ans = now_val;
int now_use = 0;
long long int pr_sum = 1;
long long int div_sum = 1;
ld next_val = now_val * pr_sum / div_sum;
long long int next_num = now_num;
while (next_num <= K) {
ans = max(ans, solve(next_num, pr_id + 1, now_use, next_val));
now_use++;
div_sum *= primes[pr_id];
pr_sum += div_sum;
next_val = now_val * pr_sum / div_sum;
next_num *= primes[pr_id];
}
return ans;
}
}
int main() {
hurui(1e3);
int case_id = 0;
while (true) {
cin >> K;
if (!K)
break;
ld ans = solve(1, 0, 1000, 1);
cout << setprecision(10) << fixed << ans << endl;
}
return 0;
}
| insert | 64 | 64 | 64 | 66 | TLE | |
p01248 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX - 1;
int memo[1111];
int func(int pos, const int &n, const int &width, const vector<int> &a) {
if (memo[pos] != -1)
return memo[pos];
if (pos >= n)
return 0;
int w = 0;
int res = INF;
int p;
int pp = -1;
for (p = pos; p < n; p++) {
w += a[p];
int tmp = func(p + 1, n, width, a) + abs(width - w);
if (res > tmp) {
pp = p;
res = tmp;
}
}
if (pp + 1 == n)
return max(0, w - width);
memo[pos] = res;
return res;
}
int main(void) {
int n, w;
int Case = 1;
while (cin >> n >> w, n | w) {
for (int i = 0; i < 1111; i++)
memo[i] = -1;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
cout << "Case " << Case++ << ": " << func(0, n, w, a) << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
const int INF = INT_MAX - 1;
int memo[1111];
int func(int pos, const int &n, const int &width, const vector<int> &a) {
if (memo[pos] != -1)
return memo[pos];
if (pos >= n)
return 0;
int w = 0;
int res = INF;
int p;
int pp = -1;
for (p = pos; p < n; p++) {
w += a[p];
int tmp = func(p + 1, n, width, a) + abs(width - w);
if (res > tmp) {
pp = p;
res = tmp;
}
}
if (pp + 1 == n) {
memo[pos] = max(0, w - width);
return memo[pos];
}
memo[pos] = res;
return res;
}
int main(void) {
int n, w;
int Case = 1;
while (cin >> n >> w, n | w) {
for (int i = 0; i < 1111; i++)
memo[i] = -1;
vector<int> a(n);
for (int i = 0; i < n; i++)
cin >> a[i];
cout << "Case " << Case++ << ": " << func(0, n, w, a) << endl;
}
return 0;
} | replace | 23 | 25 | 23 | 27 | TLE | |
p01250 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
#define PI 3.14159265358979323846264
int main() {
while (true) {
long double p;
cin >> p;
for (long double i = 0; i < 20000000; i += 1) {
long double q1 = (PI - p) * i;
long double q2 = (PI + p) * i;
int r1 = q1, r2 = q2;
if (r1 < r2) {
cout << r2 << '/' << (int)i << endl;
break;
}
}
}
return 0;
} | #include <iostream>
using namespace std;
#define PI 3.14159265358979323846264
int main() {
while (true) {
long double p;
cin >> p;
if (p == 0)
break;
for (long double i = 0; i < 20000000; i += 1) {
long double q1 = (PI - p) * i;
long double q2 = (PI + p) * i;
int r1 = q1, r2 = q2;
if (r1 < r2) {
cout << r2 << '/' << (int)i << endl;
break;
}
}
}
return 0;
} | insert | 7 | 7 | 7 | 9 | TLE | |
p01250 | C++ | Time Limit Exceeded | #include <cmath>
#include <iostream>
using namespace std;
const int MAX = pow(2, 30);
int main() {
while (true) {
double r;
cin >> r;
if (r == 0) {
break;
}
for (int i = 2; i < MAX; i++) {
for (int j = 1; j < MAX; j++) {
double diff = (double)i / j - M_PI;
if (-r <= diff && diff <= r) {
cout << i << "/" << j << endl;
goto end;
} else if (diff < -r) {
break;
}
}
}
end:;
}
} | #include <cmath>
#include <iostream>
using namespace std;
const int MAX = pow(2, 30);
int main() {
while (true) {
double r;
cin >> r;
if (r == 0) {
break;
}
for (int i = 2; i < MAX; i++) {
int j = (int)floor(i / (M_PI + r));
for (; j < MAX; j++) {
double diff = (double)i / j - M_PI;
if (-r <= diff && diff <= r) {
cout << i << "/" << j << endl;
goto end;
} else if (diff < -r) {
break;
}
}
}
end:;
}
} | replace | 14 | 15 | 14 | 16 | TLE | |
p01251 | C++ | Runtime Error | #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int dy[] = {0, -1, 0, 1};
const int dx[] = {1, 0, -1, 0};
int W, H, N;
bool field[1000][1000];
bool used[4][110][110];
int main() {
while (cin >> W >> H >> N && (W | H | N)) {
memset(field, 0, sizeof(field));
memset(used, 0, sizeof(used));
for (int i = 0; i <= 2 * H; i++) {
field[i][0] = true;
field[i][2 * W] = true;
}
for (int i = 0; i <= 2 * W; i++) {
field[0][i] = true;
field[2 * H][i] = true;
}
for (int i = 0; i < N; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (y1 == y2) {
int minx = min(x1, x2);
int maxx = max(x1, x2);
for (int j = minx * 2; j <= maxx * 2; j++)
field[2 * y1][j] = true;
} else {
int miny = min(y1, y2);
int maxy = max(y1, y2);
for (int j = miny * 2; j <= maxy * 2; j++)
field[j][2 * x1] = true;
}
}
int xe1, ye1, xe2, ye2;
int gx, gy;
int sx, sy;
int sang;
cin >> xe1 >> ye1 >> xe2 >> ye2;
cin >> gx >> gy;
gx = gx * 2 + 1;
gy = gy * 2 + 1;
if (ye1 == ye2) {
if (ye1 == 0) {
sang = 3;
sx = min(xe1, xe2) * 2 + 1;
sy = ye1;
} else {
sang = 1;
sx = min(xe1, xe2) * 2 + 1;
sy = ye1 * 2;
}
} else {
if (xe1 == 0) {
sang = 0;
sx = xe1;
sy = min(ye1, ye2) * 2 + 1;
} else {
sang = 2;
sx = xe1 * 2;
sy = min(ye1, ye2) * 2 + 1;
}
}
field[sy][sx] = false;
// for(int i=2*H;i>=0;i--){
// for(int j=0;j<=2*W;j++){
// if(field[i][j])cout<<"*";
// else cout<<" ";
// }
// cout<<endl;
// }
int cx = sx;
int cy = sy;
int cang = sang;
bool ok = true;
int tern = 0;
while (1) {
if (used[cang][cy][cx]) {
tern++;
ok = false;
break;
} else if (cy == gy && cx == gx)
break;
// cout<<cang<<" "<<cy<<" "<<cx<<" "<<tern<<endl;
used[cang][cy][cx] = true;
int ny = cy + dy[cang];
int nx = cx + dx[cang];
int nyl = ny + dy[(cang + 3) % 4];
int nxl = nx + dx[(cang + 3) % 4];
int ry = cy + dy[(cang + 1) % 4];
int rx = cx + dx[(cang + 1) % 4];
if (!field[ny][nx] && !field[nyl][nxl]) {
cy = nyl;
cx = nxl;
cang = (cang + 3) % 4;
tern++;
// if(cy%2==1&&cx%2==1)tern++;
} else if (!field[ny][nx] && field[nyl][nxl]) {
cy = ny;
cx = nx;
if (cy % 2 == 1 && cx % 2 == 1)
tern++;
} else if (field[ny][nx] && !field[ry][rx]) {
cy = ry;
cx = rx;
cang = (cang + 1) % 4;
if (cy % 2 == 1 && cx % 2 == 1)
tern++;
} else
cang = (cang + 1) % 4;
}
if (!ok)
cout << "Impossible" << endl;
else
cout << tern << endl;
}
return 0;
}
| #include <algorithm>
#include <cstring>
#include <iostream>
#include <vector>
using namespace std;
const int dy[] = {0, -1, 0, 1};
const int dx[] = {1, 0, -1, 0};
int W, H, N;
bool field[1000][1000];
bool used[4][1000][1000];
int main() {
while (cin >> W >> H >> N && (W | H | N)) {
memset(field, 0, sizeof(field));
memset(used, 0, sizeof(used));
for (int i = 0; i <= 2 * H; i++) {
field[i][0] = true;
field[i][2 * W] = true;
}
for (int i = 0; i <= 2 * W; i++) {
field[0][i] = true;
field[2 * H][i] = true;
}
for (int i = 0; i < N; i++) {
int x1, x2, y1, y2;
cin >> x1 >> y1 >> x2 >> y2;
if (y1 == y2) {
int minx = min(x1, x2);
int maxx = max(x1, x2);
for (int j = minx * 2; j <= maxx * 2; j++)
field[2 * y1][j] = true;
} else {
int miny = min(y1, y2);
int maxy = max(y1, y2);
for (int j = miny * 2; j <= maxy * 2; j++)
field[j][2 * x1] = true;
}
}
int xe1, ye1, xe2, ye2;
int gx, gy;
int sx, sy;
int sang;
cin >> xe1 >> ye1 >> xe2 >> ye2;
cin >> gx >> gy;
gx = gx * 2 + 1;
gy = gy * 2 + 1;
if (ye1 == ye2) {
if (ye1 == 0) {
sang = 3;
sx = min(xe1, xe2) * 2 + 1;
sy = ye1;
} else {
sang = 1;
sx = min(xe1, xe2) * 2 + 1;
sy = ye1 * 2;
}
} else {
if (xe1 == 0) {
sang = 0;
sx = xe1;
sy = min(ye1, ye2) * 2 + 1;
} else {
sang = 2;
sx = xe1 * 2;
sy = min(ye1, ye2) * 2 + 1;
}
}
field[sy][sx] = false;
// for(int i=2*H;i>=0;i--){
// for(int j=0;j<=2*W;j++){
// if(field[i][j])cout<<"*";
// else cout<<" ";
// }
// cout<<endl;
// }
int cx = sx;
int cy = sy;
int cang = sang;
bool ok = true;
int tern = 0;
while (1) {
if (used[cang][cy][cx]) {
tern++;
ok = false;
break;
} else if (cy == gy && cx == gx)
break;
// cout<<cang<<" "<<cy<<" "<<cx<<" "<<tern<<endl;
used[cang][cy][cx] = true;
int ny = cy + dy[cang];
int nx = cx + dx[cang];
int nyl = ny + dy[(cang + 3) % 4];
int nxl = nx + dx[(cang + 3) % 4];
int ry = cy + dy[(cang + 1) % 4];
int rx = cx + dx[(cang + 1) % 4];
if (!field[ny][nx] && !field[nyl][nxl]) {
cy = nyl;
cx = nxl;
cang = (cang + 3) % 4;
tern++;
// if(cy%2==1&&cx%2==1)tern++;
} else if (!field[ny][nx] && field[nyl][nxl]) {
cy = ny;
cx = nx;
if (cy % 2 == 1 && cx % 2 == 1)
tern++;
} else if (field[ny][nx] && !field[ry][rx]) {
cy = ry;
cx = rx;
cang = (cang + 1) % 4;
if (cy % 2 == 1 && cx % 2 == 1)
tern++;
} else
cang = (cang + 1) % 4;
}
if (!ok)
cout << "Impossible" << endl;
else
cout << tern << endl;
}
return 0;
}
| replace | 12 | 13 | 12 | 13 | 0 | |
p01253 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, T;
while (cin >> N >> T, (N || T)) {
string s;
cin >> s;
double dp[1000][2] = {0};
dp[0][0] = 1.0;
for (int i = 1; i <= T; i++) {
for (int j = 0; j < N; j++)
dp[j][i % 2] = 0.0;
for (int j = 0; j < N; j++)
for (int k = 1; k <= 6; k++)
dp[(j + k) % N][i % 2] += dp[j][(i + 1) % 2] / 6.0;
}
double res = 0;
for (int i = 0; i < N; i++) {
double sum = 0;
for (int j = 0; j < N; j++)
if (s[(i + j) % N] == 'R')
sum += dp[j][T % 2];
res = max(res, sum);
}
cout.setf(ios::fixed);
cout.precision(10);
cout << res << endl;
}
} | #include <algorithm>
#include <iostream>
#include <string>
using namespace std;
int main() {
int N, T;
while (cin >> N >> T, (N || T)) {
string s;
cin >> s;
double dp[2005][2] = {0};
dp[0][0] = 1.0;
for (int i = 1; i <= T; i++) {
for (int j = 0; j < N; j++)
dp[j][i % 2] = 0.0;
for (int j = 0; j < N; j++)
for (int k = 1; k <= 6; k++)
dp[(j + k) % N][i % 2] += dp[j][(i + 1) % 2] / 6.0;
}
double res = 0;
for (int i = 0; i < N; i++) {
double sum = 0;
for (int j = 0; j < N; j++)
if (s[(i + j) % N] == 'R')
sum += dp[j][T % 2];
res = max(res, sum);
}
cout.setf(ios::fixed);
cout.precision(10);
cout << res << endl;
}
} | replace | 11 | 12 | 11 | 12 | 0 | |
p01254 | C++ | Memory Limit Exceeded | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF (1 << 21)
struct NODE {
int to, cost, flag;
NODE(int to, int cost, int flag) : to(to), cost(cost), flag(flag){};
};
bool operator<(const NODE &a, const NODE &b) {
if (a.cost != b.cost)
return a.cost > b.cost;
else
return a.flag > b.flag;
}
int main() {
int n, m, s, t;
while (cin >> n && n) {
cin >> s >> t >> m;
s--, t--;
vector<int> v[n];
vector<pair<int, int>> e[n];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].push_back(b);
e[b].push_back(make_pair(a, i));
}
bool memo[2][1000] = {0};
priority_queue<NODE> Q;
Q.push(NODE(s, 0, 0));
while (Q.size()) {
NODE q = Q.top();
Q.pop();
if (memo[!!q.flag][q.to])
memo[!!q.flag][q.to] = true;
else
memo[!!q.flag][q.to] = true;
if (q.to == t) {
cout << q.cost << " " << q.flag << endl;
break;
}
for (int i = 0; i < v[q.to].size(); i++)
Q.push(NODE(v[q.to][i], q.cost + 1, q.flag));
if (!q.flag)
for (int i = 0; i < e[q.to].size(); i++)
Q.push(NODE(e[q.to][i].first, q.cost + 1, e[q.to][i].second + 1));
}
}
} | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define INF (1 << 21)
struct NODE {
int to, cost, flag;
NODE(int to, int cost, int flag) : to(to), cost(cost), flag(flag){};
};
bool operator<(const NODE &a, const NODE &b) {
if (a.cost != b.cost)
return a.cost > b.cost;
else
return a.flag > b.flag;
}
int main() {
int n, m, s, t;
while (cin >> n && n) {
cin >> s >> t >> m;
s--, t--;
vector<int> v[n];
vector<pair<int, int>> e[n];
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
a--, b--;
v[a].push_back(b);
e[b].push_back(make_pair(a, i));
}
bool memo[2][1000] = {0};
priority_queue<NODE> Q;
Q.push(NODE(s, 0, 0));
while (Q.size()) {
NODE q = Q.top();
Q.pop();
if (memo[!!q.flag][q.to])
continue;
else
memo[!!q.flag][q.to] = true;
if (q.to == t) {
cout << q.cost << " " << q.flag << endl;
break;
}
for (int i = 0; i < v[q.to].size(); i++)
Q.push(NODE(v[q.to][i], q.cost + 1, q.flag));
if (!q.flag)
for (int i = 0; i < e[q.to].size(); i++)
Q.push(NODE(e[q.to][i].first, q.cost + 1, e[q.to][i].second + 1));
}
}
} | replace | 38 | 39 | 38 | 39 | MLE | |
p01257 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int n, m, cost[100001], op[1023];
void dfs(int sum) {
rep(i, (1 << n) - 1) if (cost[sum + op[i]] > cost[sum] + 1)
cost[sum + op[i]] = cost[sum] + 1,
dfs(sum + op[i]);
}
int main() {
while (cin >> n >> m, n) {
int coin[10], s = 0;
rep(i, n) cin >> coin[i];
rep(i, 1 << n) if (i > 0) {
s = 0;
rep(j, n) if (i & 1 << j) s += coin[j];
op[i - 1] = s;
}
sort(op, op + (1 << n) - 1, greater<int>());
rep(i, m + 1) cost[i] = 1 << 20;
cost[0] = 0;
dfs(0);
cout << cost[m] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
int n, m, cost[100001], op[1023];
void dfs(int sum) {
rep(i,
(1 << n) - 1) if (sum + op[i] <= m && cost[sum + op[i]] > cost[sum] + 1)
cost[sum + op[i]] = cost[sum] + 1,
dfs(sum + op[i]);
}
int main() {
while (cin >> n >> m, n) {
int coin[10], s = 0;
rep(i, n) cin >> coin[i];
rep(i, 1 << n) if (i > 0) {
s = 0;
rep(j, n) if (i & 1 << j) s += coin[j];
op[i - 1] = s;
}
sort(op, op + (1 << n) - 1, greater<int>());
rep(i, m + 1) cost[i] = 1 << 20;
cost[0] = 0;
dfs(0);
cout << cost[m] << endl;
}
return 0;
} | replace | 6 | 7 | 6 | 8 | 0 | |
p01257 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
#define INF 1000000000;
using namespace std;
int n, m, a[11];
vector<int> coin;
int used[11];
void mk_coin(int sum, int k) {
for (int i = k; i < n; i++) {
if (used[i] == 1)
continue;
used[i] = 1;
coin.push_back(sum + a[i]);
mk_coin(sum + a[i], i + 1);
used[i] = 0;
}
}
int main() {
while (1) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
coin.clear();
for (int i = 0; i < n; i++)
cin >> a[i];
mk_coin(0, 0);
int dp[100010] = {};
for (int i = 1; i <= m; i++)
dp[i] = INF;
for (int i = 0; i < coin.size(); i++)
for (int j = 0; j <= m; j++)
dp[j + coin[i]] = min(dp[j] + 1, dp[j + coin[i]]);
cout << dp[m] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
#define INF 1000000000;
using namespace std;
int n, m, a[11];
vector<int> coin;
int used[11];
void mk_coin(int sum, int k) {
for (int i = k; i < n; i++) {
if (used[i] == 1)
continue;
used[i] = 1;
coin.push_back(sum + a[i]);
mk_coin(sum + a[i], i + 1);
used[i] = 0;
}
}
int main() {
while (1) {
cin >> n >> m;
if (n == 0 && m == 0)
break;
coin.clear();
for (int i = 0; i < n; i++)
cin >> a[i];
mk_coin(0, 0);
int dp[100010] = {};
for (int i = 1; i <= m; i++)
dp[i] = INF;
for (int i = 0; i < coin.size(); i++)
for (int j = 0; j <= m - coin[i]; j++)
dp[j + coin[i]] = min(dp[j] + 1, dp[j + coin[i]]);
cout << dp[m] << endl;
}
return 0;
} | replace | 33 | 34 | 33 | 34 | 0 | |
p01261 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll pascal[61][61] = {{0ll}};
int main() {
for (int i = 0; i <= 60; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= i; ++j) {
pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
}
}
while (true) {
int n, x;
ll m;
cin >> n >> m;
if (n == 0 && m == 0) {
break;
}
--m;
if (m == 0) {
cout << string(n, '0') << endl;
continue;
}
for (x = 0; x < n; ++x) {
if (m >= pascal[n][x]) {
m -= pascal[n][x];
} else {
break;
}
}
string answer(n, '0');
for (int y = x - 1, z = n; y > 0; --y) {
for (int w = y; w < z; ++w) {
if (m >= pascal[w - 1][y - 1]) {
m -= pascal[w - 1][y - 1];
} else {
answer[w] = '1';
z = w;
break;
}
}
}
answer[m] = '1';
reverse(answer.begin(), answer.end());
cout << answer << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
using namespace std;
typedef long long ll;
ll pascal[61][61] = {{0ll}};
int main() {
for (int i = 0; i <= 60; ++i) {
pascal[i][0] = 1;
for (int j = 1; j <= i; ++j) {
pascal[i][j] = pascal[i - 1][j - 1] + pascal[i - 1][j];
}
}
while (true) {
int n, x;
ll m;
cin >> n >> m;
if (n == 0 && m == 0) {
break;
}
--m;
if (m == 0) {
cout << string(n, '0') << endl;
continue;
}
for (x = 0; x < n; ++x) {
if (m >= pascal[n][x]) {
m -= pascal[n][x];
} else {
break;
}
}
string answer(n, '0');
for (int y = x - 1, z = n; y > 0; --y) {
for (int w = y; w < z; ++w) {
if (m >= pascal[w][y]) {
m -= pascal[w][y];
} else {
answer[w] = '1';
z = w;
break;
}
}
}
answer[m] = '1';
reverse(answer.begin(), answer.end());
cout << answer << endl;
}
return 0;
} | replace | 37 | 39 | 37 | 39 | 0 | |
p01267 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using LL = long long;
constexpr long long MOD = 1000000000 + 7;
constexpr long long INF = 1000000000;
const double PI = acos(-1);
int main() {
int n, a, b, c, x;
int y[101];
while (cin >> n >> a >> b >> c >> x && n) {
for (int i = 0; i < n; i++) {
cin >> y[i];
}
int cont = 0, icont = 0;
if (x == y[0])
icont++;
while (cont <= 10000 && icont < n) {
x = (a * x + b) % c;
if (x == y[icont]) {
icont++;
}
cont++;
}
if (cont > 10000) {
cout << -1 << endl;
} else
cout << cont << endl;
}
system("pause");
} | #include <algorithm>
#include <cmath>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
using LL = long long;
constexpr long long MOD = 1000000000 + 7;
constexpr long long INF = 1000000000;
const double PI = acos(-1);
int main() {
int n, a, b, c, x;
int y[101];
while (cin >> n >> a >> b >> c >> x && n) {
for (int i = 0; i < n; i++) {
cin >> y[i];
}
int cont = 0, icont = 0;
if (x == y[0])
icont++;
while (cont <= 10000 && icont < n) {
x = (a * x + b) % c;
if (x == y[icont]) {
icont++;
}
cont++;
}
if (cont > 10000) {
cout << -1 << endl;
} else
cout << cont << endl;
}
} | delete | 41 | 42 | 41 | 41 | 0 | sh: 1: pause: not found
|
p01267 | C++ | Runtime Error | #include <iostream>
#define REP(i, a, n) for (int i = ((int)a); i < ((int)n); i++)
using namespace std;
int N, A, B, C, X, Y[200];
int main(void) {
while (cin >> N >> A >> B >> C >> X) {
REP(i, 0, N) cin >> Y[i];
int ans = 0, k = 0;
while (ans <= 10000) {
if (X == Y[k]) {
k++;
if (k == N)
break;
}
X = (((A % C) * X) % C + B) % C;
ans++;
}
cout << (ans <= 10000 ? ans : -1) << endl;
}
return 0;
} | #include <iostream>
#define REP(i, a, n) for (int i = ((int)a); i < ((int)n); i++)
using namespace std;
int N, A, B, C, X, Y[200];
int main(void) {
while (cin >> N >> A >> B >> C >> X, N) {
REP(i, 0, N) cin >> Y[i];
int ans = 0, k = 0;
while (ans <= 10000) {
if (X == Y[k]) {
k++;
if (k == N)
break;
}
X = (((A % C) * X) % C + B) % C;
ans++;
}
cout << (ans <= 10000 ? ans : -1) << endl;
}
return 0;
} | replace | 7 | 8 | 7 | 8 | -8 | |
p01267 | C++ | Time Limit Exceeded | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, X;
while (cin >> N >> A >> B >> C >> X, N || A || B || C || X) {
int Y[100];
for (int i = 0; i < N; ++i) {
cin >> Y[i];
}
int need[10001] = {0};
int cnt = 0;
for (int i = 0; i < N; ++i) {
if (!need[Y[i]])
++cnt;
++need[Y[i]];
}
int ans = -1;
int pos = 0;
for (int t = 0; t < 10000 * 1000; ++t) {
if (Y[pos] == X) {
if (++pos == N) {
ans = t;
break;
}
}
X = (A * X + B) % C;
}
cout << ans << endl;
}
} | #include <iostream>
using namespace std;
int main() {
int N, A, B, C, X;
while (cin >> N >> A >> B >> C >> X, N || A || B || C || X) {
int Y[100];
for (int i = 0; i < N; ++i) {
cin >> Y[i];
}
int need[10001] = {0};
int cnt = 0;
for (int i = 0; i < N; ++i) {
if (!need[Y[i]])
++cnt;
++need[Y[i]];
}
int ans = -1;
int pos = 0;
for (int t = 0; t <= 10000; ++t) {
if (Y[pos] == X) {
if (++pos == N) {
ans = t;
break;
}
}
X = (A * X + B) % C;
}
cout << ans << endl;
}
} | replace | 21 | 22 | 21 | 22 | TLE | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 2) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 1);
}
int main() {
vector<int> prime;
for (int i = 2; i < 150000; i++) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
cin >> n >> m;
if (n == 0 && m == 0) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
for (int i = ptr; i < ptr + m; i++) {
for (int j = i; j < ptr + m; j++) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
cout << c[m - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 2) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 1);
}
int main() {
vector<int> prime;
for (int i = 2; i < 150000; i++) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
cin >> n >> m;
if (n == -1 && m == -1) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
for (int i = ptr; i < ptr + m; i++) {
for (int j = i; j < ptr + m; j++) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
cout << c[m - 1] << endl;
}
return 0;
} | replace | 32 | 33 | 32 | 33 | -11 | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> Prime(100000), Matsuzaki(1000);
int judge(int n) {
if (n < 2)
return 0;
if (n == 2)
return 1;
if (n % 2 == 0)
return 0;
for (int i = 3; i <= n / i; i += 2) {
if (n % i == 0)
return 0;
}
return 1;
}
int main() {
int a = 0, b = 0, N, P, ii;
for (int i = 2; i < 1000000; i++) {
if (judge(i))
Prime[b++] = i;
}
while (1) {
cin >> N >> P;
if (N == -1 && P == -1)
break;
a = 0;
for (int i = 0; i < b; i++) {
if (Prime[i] > N) {
ii = i;
break;
}
}
for (int i = ii; i < ii + 100; i++) {
for (int j = i; j < ii + 100; j++) {
Matsuzaki[a] = Prime[i] + Prime[j];
a++;
}
}
sort(Matsuzaki.begin(), Matsuzaki.begin() + a);
cout << Matsuzaki[P - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> Prime(1000000), Matsuzaki(100000);
int judge(int n) {
if (n < 2)
return 0;
if (n == 2)
return 1;
if (n % 2 == 0)
return 0;
for (int i = 3; i <= n / i; i += 2) {
if (n % i == 0)
return 0;
}
return 1;
}
int main() {
int a = 0, b = 0, N, P, ii;
for (int i = 2; i < 1000000; i++) {
if (judge(i))
Prime[b++] = i;
}
while (1) {
cin >> N >> P;
if (N == -1 && P == -1)
break;
a = 0;
for (int i = 0; i < b; i++) {
if (Prime[i] > N) {
ii = i;
break;
}
}
for (int i = ii; i < ii + 100; i++) {
for (int j = i; j < ii + 100; j++) {
Matsuzaki[a] = Prime[i] + Prime[j];
a++;
}
}
sort(Matsuzaki.begin(), Matsuzaki.begin() + a);
cout << Matsuzaki[P - 1] << endl;
}
return 0;
} | replace | 5 | 6 | 5 | 6 | -6 | malloc(): corrupted top size
|
p01268 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int hurui[200000] = {0};
int sosuu[100000];
int cnt = 0;
vector<int> retu;
int N, P;
for (int i = 2; i <= 200000; i++) {
if (hurui[i] == 0) {
sosuu[cnt] = i;
cnt++;
for (int j = i; j <= 200000; j += i) {
hurui[j] = 1;
}
}
}
while (1) {
cin >> N >> P;
if (N == -1 && P == 1)
break;
for (int i = 0;; i++) {
if (sosuu[i] > N) {
for (int j = 0; j < P; j++) {
for (int k = j; k < P + 1; k++) {
retu.push_back(sosuu[i + j] + sosuu[i + k]);
}
}
break;
}
}
sort(retu.begin(), retu.end());
cout << retu[P - 1] << endl;
retu.clear();
}
} | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int hurui[200000] = {0};
int sosuu[100000];
int cnt = 0;
vector<int> retu;
int N, P;
for (int i = 2; i <= 200000; i++) {
if (hurui[i] == 0) {
sosuu[cnt] = i;
cnt++;
for (int j = i; j <= 200000; j += i) {
hurui[j] = 1;
}
}
}
while (1) {
cin >> N >> P;
if (N == -1 && P == -1)
break;
for (int i = 0;; i++) {
if (sosuu[i] > N) {
for (int j = 0; j < P; j++) {
for (int k = j; k < P + 1; k++) {
retu.push_back(sosuu[i + j] + sosuu[i + k]);
}
}
break;
}
}
sort(retu.begin(), retu.end());
cout << retu[P - 1] << endl;
retu.clear();
}
} | replace | 27 | 28 | 27 | 28 | TLE | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
using namespace std;
bool e[100010];
void erato() {
fill(e, e + 150010, true);
e[0] = e[1] = false;
for (int i = 0; i < 150010; i++) {
if (!e[i])
continue;
for (int j = i + i; j < 150010; j += i) {
e[j] = false;
}
}
}
int main() {
erato();
int n, p;
int primeNumbers[100];
int addPrimeNumbers[100010];
while (cin >> n >> p, n != -1 && p != -1) {
while (1) {
if (e[++n])
break;
}
for (int i = 0; i < p; n++) {
if (e[n]) {
primeNumbers[i] = n;
i++;
}
}
int countPrimeNumbers = 0;
for (int i = 0; i < p; i++) {
for (int j = i; j < p; j++) {
addPrimeNumbers[countPrimeNumbers] = primeNumbers[i] + primeNumbers[j];
countPrimeNumbers++;
}
}
sort(addPrimeNumbers, addPrimeNumbers + countPrimeNumbers);
cout << addPrimeNumbers[p - 1] << endl;
}
} | #include <algorithm>
#include <iostream>
using namespace std;
bool e[150010];
void erato() {
fill(e, e + 150010, true);
e[0] = e[1] = false;
for (int i = 0; i < 150010; i++) {
if (!e[i])
continue;
for (int j = i + i; j < 150010; j += i) {
e[j] = false;
}
}
}
int main() {
erato();
int n, p;
int primeNumbers[100];
int addPrimeNumbers[100010];
while (cin >> n >> p, n != -1 && p != -1) {
while (1) {
if (e[++n])
break;
}
for (int i = 0; i < p; n++) {
if (e[n]) {
primeNumbers[i] = n;
i++;
}
}
int countPrimeNumbers = 0;
for (int i = 0; i < p; i++) {
for (int j = i; j < p; j++) {
addPrimeNumbers[countPrimeNumbers] = primeNumbers[i] + primeNumbers[j];
countPrimeNumbers++;
}
}
sort(addPrimeNumbers, addPrimeNumbers + countPrimeNumbers);
cout << addPrimeNumbers[p - 1] << endl;
}
} | replace | 4 | 5 | 4 | 5 | -11 | |
p01268 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
typedef complex<double> P;
typedef long long ll;
const int MAX_SIZE = 10000;
const int MAX_PRIME = 1000000;
int prime[MAX_PRIME + 1];
bool isPrime[MAX_PRIME + 1];
int p;
void erats() {
// primeツδ環スツトツづーツ渉可甘コツ可サ
fill(isPrime, isPrime + MAX_PRIME, true);
p = 0;
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= MAX_PRIME; i++) {
if (isPrime[i]) {
prime[p++] = i;
} else
continue;
// ツづ督づゥツつ「ツづ可つゥツつッツづゥ
for (int j = 2 * i; j <= MAX_PRIME; j += i) {
isPrime[j] = false;
}
}
}
int main() {
int N, P;
erats();
while (cin >> N >> P && !(N == -1 && P == -1)) {
int *it = upper_bound(prime, prime + p, N);
int prv = it - prime;
int init = prv;
vector<int> v;
for (int i = init; i <= init + 1000; i++) {
for (int j = i; j <= init + 1000; j++) {
v.push_back(prime[i] + prime[j]);
}
}
sort(v.begin(), v.end());
cout << v[P - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <complex>
#include <cstdlib>
#include <fstream>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
#define EPS (1e-10)
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).real(), (b).real()) && EQ((a).imag(), (b).imag()))
typedef complex<double> P;
typedef long long ll;
const int MAX_SIZE = 10000;
const int MAX_PRIME = 1000000;
int prime[MAX_PRIME + 1];
bool isPrime[MAX_PRIME + 1];
int p;
void erats() {
// primeツδ環スツトツづーツ渉可甘コツ可サ
fill(isPrime, isPrime + MAX_PRIME, true);
p = 0;
isPrime[0] = isPrime[1] = false;
for (int i = 2; i <= MAX_PRIME; i++) {
if (isPrime[i]) {
prime[p++] = i;
} else
continue;
// ツづ督づゥツつ「ツづ可つゥツつッツづゥ
for (int j = 2 * i; j <= MAX_PRIME; j += i) {
isPrime[j] = false;
}
}
}
int main() {
int N, P;
erats();
while (cin >> N >> P && !(N == -1 && P == -1)) {
int *it = upper_bound(prime, prime + p, N);
int prv = it - prime;
int init = prv;
vector<int> v;
for (int i = init; i <= init + 100; i++) {
for (int j = i; j <= init + 100; j++) {
v.push_back(prime[i] + prime[j]);
}
}
sort(v.begin(), v.end());
cout << v[P - 1] << endl;
}
return 0;
} | replace | 58 | 60 | 58 | 60 | TLE | |
p01268 | C++ | Runtime Error | /*
Hokudai Practice Contest 2014
B - Matsuzaki Number
ティツァツ」テヲツウツ陛ッツシツ堙ァツエツ?ヲツ閉ーテ・ツ按療ヲツ個凖ッツシツ凝・ツ?ィテヲツ篠「テァツエツ「
テ・ツ可催・ツ?ヲテァツ青?」ツ?ィテ」ツ?療」ツ?ヲテ」ツ??・ツ債?・ツ按?」ツ?ェテ・ツ、ツァテ」ツ?催」ツ?陛」ツ?セテ」ツ?ァテァツエツ?ヲツ閉ーテ」ツつ津ゥツ?催・ツ按療」ツ?ォテ・ツ按療ヲツ個凖」ツ?療」ツ?ヲテ」ツ?甘」ツ?催」ツ??
テ・ツ?・テ・ツ環嬾テ」ツ?ォテ・ツッツセテ」ツ?療」ツ?ヲテ・ツ、ツァテ」ツ?催」ツ?貧テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ津ゥツ?催・ツ按療」ツ?凝」ツつ嘉ヲツ篠「テ」ツ?凖」ツ??
ティツヲツ凝」ツ?、テ」ツ?妥」ツ?淌ァツエツ?ヲツ閉ーテ」ツ?凝」ツつ英テ・ツ?凝」ツつ津・ツ渉姪」ツつ甘・ツ?コテ」ツ?療」ツ??」ツ?凖」ツ?ケテ」ツ?ヲテ」ツ?ョテ・ツ渉ッティツδステ」ツ?ェテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津・ツ按療ヲツ個凖」ツ?凖」ツつ凝」ツ??
テ」ツ?敕」ツ?ョテ、ツクツュテ」ツ?ァpテァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??」ツつづ」ツ?ョテ」ツ?古ァツュツ氾」ツ?暗」ツ?ィテ」ツ?ェテ」ツつ凝」ツ??
テ・ツ按カテァツエツ?」ツ??0^6テ」ツ?ィテ・ツ、ツァテ」ツ?催」ツつ?」ツ?ェテ」ツ?ョテ」ツ?ァテ」ツ??」ツつィテ」ツδゥテ」ツδ暗」ツつケテ」ツδ?」ツδ催」ツつケテ」ツ?ョテァツッツゥテ」ツつ津ァツ板ィテ」ツ??」ツ?ヲテァツエツ?ヲツ閉ーテ・ツ按療ヲツ個凖」ツつ津ィツ。ツ古」ツ??
テヲツウツィテヲツ?湘ァツつケテ」ツ?ィテ」ツ?療」ツ?ヲテ」ツ?｝^(1/2)テ」ツ?セテ」ツ?ァテ・ツ渉姪」ツつ甘・ツ?コテ」ツ?療」ツ?ヲテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津ィツィツ暗ァツョツ療」ツ?凖」ツつ凝」ツ??」ツ?妥」ツ?ァテ」ツ?ッテ」ツ??
テ・ツ陳古」ツ?継テァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??ヲツ閉ーテ」ツ?古ァツ渉セテ」ツつ古」ツつ凝」ツ?ィテ」ツ?ッテゥツ卍静」ツつ嘉」ツ?ェテ」ツ??」ツ?ョテ」ツ?ァテ、ツクツ催・ツ債?・ツ按?」ツ?ァテ」ツ?づ」ツつ?
[テ・ツ可催・ツ?ヲテァツ青?
テヲツ卍づゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(MAX_N loglog MAX_N)
テァツゥツコテゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(MAX_N)
[1テ」ツδ?」ツつケテ」ツδ暗」ツつアテ」ツδシテ」ツつケテ」ツ?ョテ・ツ?ヲテァツ青?
テヲツ卍づゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(logMAX_N + p^2 log p)
テァツゥツコテゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(p^2)
*/
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
// 10^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ?00テ・ツ?凝ィツヲツ凝」ツ?、テ」ツ?妥」ツつ凝・ツソツ?ィツヲツ?」ツ?古」ツ?づ」ツつ凝」ツ?ョテ」ツ?ァテ」ツ??0^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツつ?」ツ?ォテゥツ?催・ツ按療」ツつ津ァツ「ツコテ、ツソツ敕」ツ?凖」ツつ?
// 10^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??00テァツ閉ェテァツ崢ョテ」ツ?ョテァツエツ?ヲツ閉ーテ」ツ?ッ101197テ」ツ?ェテ」ツ?ョテ」ツ?ァテ」ツ??・ツョツ淌ゥツ堋崚」ツ?ッMAX_N=101198テ」ツ?ァテ・ツ債?・ツ按?
const int MAX_N = 200000;
int main() {
// テァツエツ?ヲツ閉ーティツ。ツィ
vector<bool> isPrime(MAX_N, 1);
// テァツエツ?ヲツ閉ーテ」ツδェテ」ツつケテ」ツδ?
vector<int> primes;
isPrime[0] = isPrime[1] = 0;
// テ」ツつィテ」ツδゥテ」ツδ暗」ツつケテ」ツδ?」ツδ催」ツつケテ」ツ?ョテァツッツゥ
for (int i = 2; i <= MAX_N; i++) {
if (!isPrime[i])
continue;
primes.push_back(i);
for (int j = 2 * i; j <= MAX_N; j += i)
isPrime[j] = 0;
}
int n, p;
while (cin >> n >> p, n >= 0) {
// nテ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ヲツ慊?・ツーツ湘」ツ?ョテァツエツ?ヲツ閉ーテ」ツ?ョテ、ツスツ催ァツスツョテ」ツつ津ヲツアツづ」ツつ?」ツつ?テ」ツ?禿」ツ?禿」ツ?ァテ」ツ?ッテ、ツコツ古・ツ按?ヲツ篠「テァツエツ「)
int pos = upper_bound(primes.begin(), primes.end(), n) - primes.begin();
// nテ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ津・ツーツ湘」ツ?陛」ツ??ヲツ鳴ケテ」ツ?凝」ツつ英テ・ツ?凝」ツδェテ」ツつケテ」ツδ暗」ツ?ォティツゥツーテ」ツつ?」ツつ?
vector<int> pList;
for (int i = 0; i < p; i++)
pList.push_back(primes[pos + i]);
// テ」ツ?凖」ツ?ケテ」ツ?ヲテ」ツ?ョテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津ヲツアツづ」ツつ?」ツつ?
vector<int> sum;
for (int i = 0; i < p; i++) {
for (int j = 0; j <= i; j++) {
sum.push_back(pList[i] + pList[j]);
}
}
// pテァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??ヲツ閉ーテ」ツ?ッテ」ツ??」ツつステ」ツδシテ」ツδ暗」ツ?療」ツ?ヲsum[p-1]テ」ツ?ォテ」ツつ「テ」ツつッテ」ツつサテ」ツつケテ」ツ?凖」ツつ古」ツ?ーテ」ツつ湘」ツ?凝」ツつ?
sort(sum.begin(), sum.end());
cout << sum[p - 1] << endl;
}
} | /*
Hokudai Practice Contest 2014
B - Matsuzaki Number
ティツァツ」テヲツウツ陛ッツシツ堙ァツエツ?ヲツ閉ーテ・ツ按療ヲツ個凖ッツシツ凝・ツ?ィテヲツ篠「テァツエツ「
テ・ツ可催・ツ?ヲテァツ青?」ツ?ィテ」ツ?療」ツ?ヲテ」ツ??・ツ債?・ツ按?」ツ?ェテ・ツ、ツァテ」ツ?催」ツ?陛」ツ?セテ」ツ?ァテァツエツ?ヲツ閉ーテ」ツつ津ゥツ?催・ツ按療」ツ?ォテ・ツ按療ヲツ個凖」ツ?療」ツ?ヲテ」ツ?甘」ツ?催」ツ??
テ・ツ?・テ・ツ環嬾テ」ツ?ォテ・ツッツセテ」ツ?療」ツ?ヲテ・ツ、ツァテ」ツ?催」ツ?貧テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ津ゥツ?催・ツ按療」ツ?凝」ツつ嘉ヲツ篠「テ」ツ?凖」ツ??
ティツヲツ凝」ツ?、テ」ツ?妥」ツ?淌ァツエツ?ヲツ閉ーテ」ツ?凝」ツつ英テ・ツ?凝」ツつ津・ツ渉姪」ツつ甘・ツ?コテ」ツ?療」ツ??」ツ?凖」ツ?ケテ」ツ?ヲテ」ツ?ョテ・ツ渉ッティツδステ」ツ?ェテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津・ツ按療ヲツ個凖」ツ?凖」ツつ凝」ツ??
テ」ツ?敕」ツ?ョテ、ツクツュテ」ツ?ァpテァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??」ツつづ」ツ?ョテ」ツ?古ァツュツ氾」ツ?暗」ツ?ィテ」ツ?ェテ」ツつ凝」ツ??
テ・ツ按カテァツエツ?」ツ??0^6テ」ツ?ィテ・ツ、ツァテ」ツ?催」ツつ?」ツ?ェテ」ツ?ョテ」ツ?ァテ」ツ??」ツつィテ」ツδゥテ」ツδ暗」ツつケテ」ツδ?」ツδ催」ツつケテ」ツ?ョテァツッツゥテ」ツつ津ァツ板ィテ」ツ??」ツ?ヲテァツエツ?ヲツ閉ーテ・ツ按療ヲツ個凖」ツつ津ィツ。ツ古」ツ??
テヲツウツィテヲツ?湘ァツつケテ」ツ?ィテ」ツ?療」ツ?ヲテ」ツ?｝^(1/2)テ」ツ?セテ」ツ?ァテ・ツ渉姪」ツつ甘・ツ?コテ」ツ?療」ツ?ヲテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津ィツィツ暗ァツョツ療」ツ?凖」ツつ凝」ツ??」ツ?妥」ツ?ァテ」ツ?ッテ」ツ??
テ・ツ陳古」ツ?継テァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??ヲツ閉ーテ」ツ?古ァツ渉セテ」ツつ古」ツつ凝」ツ?ィテ」ツ?ッテゥツ卍静」ツつ嘉」ツ?ェテ」ツ??」ツ?ョテ」ツ?ァテ、ツクツ催・ツ債?・ツ按?」ツ?ァテ」ツ?づ」ツつ?
[テ・ツ可催・ツ?ヲテァツ青?
テヲツ卍づゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(MAX_N loglog MAX_N)
テァツゥツコテゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(MAX_N)
[1テ」ツδ?」ツつケテ」ツδ暗」ツつアテ」ツδシテ」ツつケテ」ツ?ョテ・ツ?ヲテァツ青?
テヲツ卍づゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(logMAX_N + p^2 log p)
テァツゥツコテゥツ鳴禿ィツィツ暗ァツョツ療ゥツ?湘ッツシツ唹(p^2)
*/
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
// 10^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ?00テ・ツ?凝ィツヲツ凝」ツ?、テ」ツ?妥」ツつ凝・ツソツ?ィツヲツ?」ツ?古」ツ?づ」ツつ凝」ツ?ョテ」ツ?ァテ」ツ??0^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツつ?」ツ?ォテゥツ?催・ツ按療」ツつ津ァツ「ツコテ、ツソツ敕」ツ?凖」ツつ?
// 10^6テ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??00テァツ閉ェテァツ崢ョテ」ツ?ョテァツエツ?ヲツ閉ーテ」ツ?ッ101197テ」ツ?ェテ」ツ?ョテ」ツ?ァテ」ツ??・ツョツ淌ゥツ堋崚」ツ?ッMAX_N=101198テ」ツ?ァテ・ツ債?・ツ按?
const int MAX_N = 200000;
int main() {
// テァツエツ?ヲツ閉ーティツ。ツィ
vector<bool> isPrime(MAX_N + 1, 1);
// テァツエツ?ヲツ閉ーテ」ツδェテ」ツつケテ」ツδ?
vector<int> primes;
isPrime[0] = isPrime[1] = 0;
// テ」ツつィテ」ツδゥテ」ツδ暗」ツつケテ」ツδ?」ツδ催」ツつケテ」ツ?ョテァツッツゥ
for (int i = 2; i <= MAX_N; i++) {
if (!isPrime[i])
continue;
primes.push_back(i);
for (int j = 2 * i; j <= MAX_N; j += i)
isPrime[j] = 0;
}
int n, p;
while (cin >> n >> p, n >= 0) {
// nテ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ヲツ慊?・ツーツ湘」ツ?ョテァツエツ?ヲツ閉ーテ」ツ?ョテ、ツスツ催ァツスツョテ」ツつ津ヲツアツづ」ツつ?」ツつ?テ」ツ?禿」ツ?禿」ツ?ァテ」ツ?ッテ、ツコツ古・ツ按?ヲツ篠「テァツエツ「)
int pos = upper_bound(primes.begin(), primes.end(), n) - primes.begin();
// nテ」ツつ暗」ツつ甘・ツ、ツァテ」ツ?催」ツ??ァツエツ?ヲツ閉ーテ」ツつ津・ツーツ湘」ツ?陛」ツ??ヲツ鳴ケテ」ツ?凝」ツつ英テ・ツ?凝」ツδェテ」ツつケテ」ツδ暗」ツ?ォティツゥツーテ」ツつ?」ツつ?
vector<int> pList;
for (int i = 0; i < p; i++)
pList.push_back(primes[pos + i]);
// テ」ツ?凖」ツ?ケテ」ツ?ヲテ」ツ?ョテ」ツδ堙」ツつ「テ」ツ?ョテ・ツ陳古」ツつ津ヲツアツづ」ツつ?」ツつ?
vector<int> sum;
for (int i = 0; i < p; i++) {
for (int j = 0; j <= i; j++) {
sum.push_back(pList[i] + pList[j]);
}
}
// pテァツ閉ェテァツ崢ョテ」ツ?ォテ・ツーツ湘」ツ?陛」ツ??ヲツ閉ーテ」ツ?ッテ」ツ??」ツつステ」ツδシテ」ツδ暗」ツ?療」ツ?ヲsum[p-1]テ」ツ?ォテ」ツつ「テ」ツつッテ」ツつサテ」ツつケテ」ツ?凖」ツつ古」ツ?ーテ」ツつ湘」ツ?凝」ツつ?
sort(sum.begin(), sum.end());
cout << sum[p - 1] << endl;
}
} | replace | 34 | 35 | 34 | 35 | -6 | double free or corruption (!prev)
|
p01268 | C++ | Runtime Error | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#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 FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define pi M_PI
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
const int N = 150000;
int main() {
int n, p;
VI primes, d(N, 1);
FOR(i, 2, N - 1) {
if (!d[i])
continue;
primes.push_back(i);
int x = 2 * i;
while (x < N) {
d[x] = 0;
x += i;
}
}
while (cin >> n >> p && p) {
VI cand;
int i = 0;
while (primes[i] <= n)
i++;
FOR(j, i, i + p) FOR(k, i, j) { cand.push_back(primes[j] + primes[k]); }
sort(cand.begin(), cand.end());
cout << cand[p - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstring>
#include <fstream>
#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 FOR(i, a, b) for (int i = a; i <= b; ++i)
#define FORR(i, a, b) for (int i = a; i >= b; --i)
#define pi M_PI
typedef long long ll;
typedef vector<int> VI;
typedef vector<ll> VL;
typedef vector<VI> VVI;
typedef pair<int, int> P;
typedef pair<ll, ll> PL;
const int N = 150000;
int main() {
int n, p;
VI primes, d(N, 1);
FOR(i, 2, N - 1) {
if (!d[i])
continue;
primes.push_back(i);
int x = 2 * i;
while (x < N) {
d[x] = 0;
x += i;
}
}
while (cin >> n >> p && p >= 0) {
VI cand;
int i = 0;
while (primes[i] <= n)
i++;
FOR(j, i, i + p) FOR(k, i, j) { cand.push_back(primes[j] + primes[k]); }
sort(cand.begin(), cand.end());
cout << cand[p - 1] << endl;
}
return 0;
} | replace | 41 | 42 | 41 | 42 | -11 | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
bool f[1000002];
int main() {
for (int i = 3; i < 1000001; i += 2) {
f[i] = true;
for (int j = 3; j * j <= i; j += 2)
if (i % j == 0)
f[i] = false;
}
f[2] = true;
int n, p;
while (1) {
cin >> n >> p;
if (n == -1 && n == p)
break;
int r = 0;
int q[10001] = {};
int x = 0;
int y = n;
while (1) {
if (f[y] == true)
x++;
if (x == p)
break;
y++;
}
n++;
vector<int> anslist;
for (int i = n; i <= y; i++)
for (int j = i; j <= y; j++) {
if (f[i] == true && f[j] == true) {
anslist.push_back(i + j);
// cout<<i<<" "<<j<<endl;
}
}
sort(anslist.begin(), anslist.end());
/*
for(int i=n;i<=y;i++)
for(int j=i;j<=y;j++)
{
if(f[i]==true&&f[j]==true){
q[r]=i+j;r++;
}
}
/*
sort(q,q+r);
for(int i=0;i<r;i++)
cout<<q[i]<<endl;
cout<<q[p-1]<<endl;*/
cout << anslist[p - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string>
#include <vector>
using namespace std;
bool f[1000002];
int main() {
for (int i = 3; i < 1000001; i += 2) {
f[i] = true;
for (int j = 3; j * j <= i; j += 2)
if (i % j == 0)
f[i] = false;
}
f[2] = true;
int n, p;
while (1) {
cin >> n >> p;
if (n == -1 && n == p)
break;
int r = 0;
int q[10001] = {};
int x = 0;
int y = n + 1;
while (1) {
if (f[y] == true)
x++;
if (x == p)
break;
y++;
}
n++;
vector<int> anslist;
for (int i = n; i <= y; i++)
for (int j = i; j <= y; j++) {
if (f[i] == true && f[j] == true) {
anslist.push_back(i + j);
// cout<<i<<" "<<j<<endl;
}
}
sort(anslist.begin(), anslist.end());
/*
for(int i=n;i<=y;i++)
for(int j=i;j<=y;j++)
{
if(f[i]==true&&f[j]==true){
q[r]=i+j;r++;
}
}
/*
sort(q,q+r);
for(int i=0;i<r;i++)
cout<<q[i]<<endl;
cout<<q[p-1]<<endl;*/
cout << anslist[p - 1] << endl;
}
return 0;
} | replace | 28 | 29 | 28 | 29 | -11 | |
p01268 | C++ | Time Limit Exceeded | #include <bits/stdc++.h>
#include <stdint.h>
typedef uint32_t u32;
typedef uint64_t u64;
class Solver {
public:
Solver();
void solve(int N, int P);
private:
bool isprime[200000];
};
Solver::Solver() {
for (int i = 0; i < 200000; ++i) {
isprime[i] = true;
}
isprime[0] = isprime[1] = false;
for (int i = 2; i < 2000; ++i) {
if (isprime[i]) {
for (int j = i * 2; j < 200000; j += i) {
isprime[j] = false;
}
}
}
}
void Solver::solve(int N, int P) {
std::vector<int> can;
for (int i = N + 1; i < std::min(N + P * 4 + 1000, 200000); ++i) {
if (not isprime[i])
continue;
for (int j = i; j < std::min(N + P * 4 + 1000, 200000); ++j) {
if (not isprime[j])
continue;
can.push_back(i + j);
}
}
std::sort(std::begin(can), std::end(can));
std::cout << can[P - 1] << std::endl;
}
int main() {
Solver solver;
for (;;) {
int N, P;
std::cin >> N >> P;
if (N == 0 and P == 0)
break;
solver.solve(N, P);
}
return 0;
} | #include <bits/stdc++.h>
#include <stdint.h>
typedef uint32_t u32;
typedef uint64_t u64;
class Solver {
public:
Solver();
void solve(int N, int P);
private:
bool isprime[200000];
};
Solver::Solver() {
for (int i = 0; i < 200000; ++i) {
isprime[i] = true;
}
isprime[0] = isprime[1] = false;
for (int i = 2; i < 2000; ++i) {
if (isprime[i]) {
for (int j = i * 2; j < 200000; j += i) {
isprime[j] = false;
}
}
}
}
void Solver::solve(int N, int P) {
std::vector<int> can;
for (int i = N + 1; i < std::min(N + P * 4 + 1000, 200000); ++i) {
if (not isprime[i])
continue;
for (int j = i; j < std::min(N + P * 4 + 1000, 200000); ++j) {
if (not isprime[j])
continue;
can.push_back(i + j);
}
}
std::sort(std::begin(can), std::end(can));
std::cout << can[P - 1] << std::endl;
}
int main() {
Solver solver;
for (;;) {
int N, P;
std::cin >> N >> P;
if (N == -1 and P == -1)
break;
solver.solve(N, P);
}
return 0;
} | replace | 51 | 52 | 51 | 52 | TLE | |
p01268 | C++ | Time Limit Exceeded | // Name: Matsuzaki Number
// Level: 2
// Category: 素数
// Note:
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_PRIME = 200000;
vector<int> primes;
bool is_prime[MAX_PRIME + 1];
void init() {
fill_n(is_prime, MAX_PRIME + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= MAX_PRIME; ++i) {
if (is_prime[i]) {
primes.push_back(i);
for (long long j = (long long)i * i; j <= MAX_PRIME; j += i) {
is_prime[j] = false;
}
}
}
}
bool solve() {
int N, P;
cin >> N >> P;
if (!N && !P)
return false;
vector<int>::iterator first = upper_bound(primes.begin(), primes.end(), N);
vector<int> nums;
const int start = distance(primes.begin(), first);
for (int i = start; i < start + 100; ++i) {
for (int j = i; j < start + 100; ++j) {
nums.push_back(primes[i] + primes[j]);
}
}
sort(nums.begin(), nums.end());
cout << nums[P - 1] << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
init();
for (int case_num = 1; solve(); ++case_num)
;
return 0;
} | // Name: Matsuzaki Number
// Level: 2
// Category: 素数
// Note:
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_PRIME = 200000;
vector<int> primes;
bool is_prime[MAX_PRIME + 1];
void init() {
fill_n(is_prime, MAX_PRIME + 1, true);
is_prime[0] = is_prime[1] = false;
for (int i = 2; i <= MAX_PRIME; ++i) {
if (is_prime[i]) {
primes.push_back(i);
for (long long j = (long long)i * i; j <= MAX_PRIME; j += i) {
is_prime[j] = false;
}
}
}
}
bool solve() {
int N, P;
cin >> N >> P;
if (N == -1 && P == -1)
return false;
vector<int>::iterator first = upper_bound(primes.begin(), primes.end(), N);
vector<int> nums;
const int start = distance(primes.begin(), first);
for (int i = start; i < start + 100; ++i) {
for (int j = i; j < start + 100; ++j) {
nums.push_back(primes[i] + primes[j]);
}
}
sort(nums.begin(), nums.end());
cout << nums[P - 1] << endl;
return true;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
init();
for (int case_num = 1; solve(); ++case_num)
;
return 0;
} | replace | 31 | 32 | 31 | 32 | TLE | |
p01268 | C++ | Runtime Error | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int MAXN = 2 * 1e5;
vector<int> pri(2 * (int)1e5, true);
void prim() {
pri[1] = false;
for (int i = 2; i * i < MAXN; i++) {
if (pri[i])
for (int j = 2 * i; j < MAXN; j += i)
if (pri[j])
pri[j] = false;
}
}
int main() {
int n, p;
prim();
while (cin >> n >> p, n != -1) {
vector<int> twop;
int limitt = n + p * 10;
for (int i = n + 1; i < limitt; i++) {
if (pri[i])
for (int j = i; j < limitt; j++) {
if (pri[j])
twop.push_back(i + j);
}
}
sort(twop.begin(), twop.end());
cout << twop[p - 1] << endl;
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
#define REP(i, n) for (int i = 0; i < (n); i++)
const int MAXN = 2 * 1e5;
vector<int> pri(2 * (int)1e5, true);
void prim() {
pri[1] = false;
for (int i = 2; i * i < MAXN; i++) {
if (pri[i])
for (int j = 2 * i; j < MAXN; j += i)
if (pri[j])
pri[j] = false;
}
}
int main() {
int n, p;
prim();
while (cin >> n >> p, n != -1) {
vector<int> twop;
int limitt = n + n / 100 + p * 10;
for (int i = n + 1; i < limitt; i++) {
if (pri[i])
for (int j = i; j < limitt; j++) {
if (pri[j])
twop.push_back(i + j);
}
}
sort(twop.begin(), twop.end());
cout << twop[p - 1] << endl;
}
return 0;
} | replace | 20 | 21 | 20 | 21 | 0 | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 3) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 2);
}
int main() {
vector<int> prime = {2};
for (int i = 3; i < 101300; i += 2) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
scanf("%d", &n);
scanf("%d", &m);
if (n == -1 && m == -1) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
int r = min(22, m / 2) - 1;
for (int i = ptr + r; i >= ptr; i--) {
for (int j = ptr + r; j >= i; j--) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
printf("%d\n", c[m - 1]);
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 3) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 2);
}
int main() {
vector<int> prime = {2};
for (int i = 3; i < 101300; i += 2) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
scanf("%d", &n);
scanf("%d", &m);
if (n == -1 && m == -1) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
int r = min(22, max(m / 2, 12)) - 1;
for (int i = ptr + r; i >= ptr; i--) {
for (int j = ptr + r; j >= i; j--) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
printf("%d\n", c[m - 1]);
}
return 0;
} | replace | 41 | 42 | 41 | 42 | -11 | |
p01268 | C++ | Runtime Error | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNUM 200274
int main(void) {
int n, p, i, j, count1, count2, flag[MAXNUM + 1], tmp[MAXNUM + 1];
for (i = 0; i <= MAXNUM; i++)
flag[i] = 1;
flag[0] = flag[1] = 0;
for (i = 2; i <= sqrt((double)MAXNUM); i++) {
for (j = 2 * i; j <= MAXNUM; j += i)
flag[j] = 0;
}
while (1) {
scanf("%d%d", &n, &p);
if (n == -1 && p == -1)
break;
count1 = 0;
memset(tmp, 0, sizeof(tmp));
for (i = n + 1; count1 < p; i++) {
if (flag[i]) {
count1++;
count2 = 0;
for (j = i; count2 < p; j++) {
if (flag[j]) {
count2++;
tmp[i + j]++;
}
}
}
}
count1 = 0;
for (i = n + 1; count1 < p; i++) {
if (tmp[i])
count1 += tmp[i];
}
printf("%d\n", i - 1);
}
return 0;
} | #include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define MAXNUM 300000
int main(void) {
int n, p, i, j, count1, count2, flag[MAXNUM + 1], tmp[MAXNUM + 1];
for (i = 0; i <= MAXNUM; i++)
flag[i] = 1;
flag[0] = flag[1] = 0;
for (i = 2; i <= sqrt((double)MAXNUM); i++) {
for (j = 2 * i; j <= MAXNUM; j += i)
flag[j] = 0;
}
while (1) {
scanf("%d%d", &n, &p);
if (n == -1 && p == -1)
break;
count1 = 0;
memset(tmp, 0, sizeof(tmp));
for (i = n + 1; count1 < p; i++) {
if (flag[i]) {
count1++;
count2 = 0;
for (j = i; count2 < p; j++) {
if (flag[j]) {
count2++;
tmp[i + j]++;
}
}
}
}
count1 = 0;
for (i = n + 1; count1 < p; i++) {
if (tmp[i])
count1 += tmp[i];
}
printf("%d\n", i - 1);
}
return 0;
} | replace | 4 | 5 | 4 | 5 | -11 | |
p01268 | C++ | Runtime Error | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 3) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 2);
}
int main() {
vector<int> prime = {2};
for (int i = 3; i < 101300; i += 2) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
scanf("%d", &n);
scanf("%d", &m);
if (n == -1 && m == -1) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
for (int i = ptr; i < ptr + m / 2; i++) {
for (int j = i; j < ptr + m / 2; j++) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
printf("%d\n", c[m - 1]);
}
return 0;
} | #include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
bool is_prime(int n, int k = 3) {
if (n < k * k) {
return true;
}
if (n % k == 0) {
return false;
}
return is_prime(n, k + 2);
}
int main() {
vector<int> prime = {2};
for (int i = 3; i < 101300; i += 2) {
if (is_prime(i)) {
prime.push_back(i);
}
}
int n, m;
while (true) {
scanf("%d", &n);
scanf("%d", &m);
if (n == -1 && m == -1) {
break;
}
int ptr =
distance(prime.begin(), lower_bound(prime.begin(), prime.end(), n + 1));
vector<int> c;
for (int i = ptr + m - 1; i >= ptr; i--) {
for (int j = ptr + m - 1; j >= i; j--) {
c.push_back(prime[i] + prime[j]);
}
}
sort(c.begin(), c.end());
printf("%d\n", c[m - 1]);
}
return 0;
} | replace | 42 | 44 | 42 | 44 | -11 | |
p01268 | C++ | Time Limit Exceeded | #include <algorithm>
#include <bitset>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_N = 2000000;
bitset<MAX_N> sieve;
vector<int> primes;
void eratosthenes() {
sieve[0] = sieve[1] = true;
for (int i = 2; i < MAX_N; ++i) {
if (sieve[i]) {
continue;
}
primes.push_back(i);
for (int j = i + i; j < MAX_N; j += i) {
sieve[j] = true;
}
}
}
int main() {
eratosthenes();
while (true) {
int n, p;
cin >> n >> p;
if (n == 0 && p == 0) {
break;
}
int begin = upper_bound(primes.begin(), primes.end(), n) - primes.begin();
vector<int> pp;
for (int i = 0; i < 200; ++i) {
for (int j = 0; j <= i; ++j) {
pp.push_back(primes[begin + i] + primes[begin + j]);
}
}
sort(pp.begin(), pp.end());
cout << pp[p - 1] << endl;
}
return 0;
} | #include <algorithm>
#include <bitset>
#include <iostream>
#include <vector>
using namespace std;
const int MAX_N = 2000000;
bitset<MAX_N> sieve;
vector<int> primes;
void eratosthenes() {
sieve[0] = sieve[1] = true;
for (int i = 2; i < MAX_N; ++i) {
if (sieve[i]) {
continue;
}
primes.push_back(i);
for (int j = i + i; j < MAX_N; j += i) {
sieve[j] = true;
}
}
}
int main() {
eratosthenes();
while (true) {
int n, p;
cin >> n >> p;
if (n == -1 && p == -1) {
break;
}
int begin = upper_bound(primes.begin(), primes.end(), n) - primes.begin();
vector<int> pp;
for (int i = 0; i < 200; ++i) {
for (int j = 0; j <= i; ++j) {
pp.push_back(primes[begin + i] + primes[begin + j]);
}
}
sort(pp.begin(), pp.end());
cout << pp[p - 1] << endl;
}
return 0;
} | replace | 29 | 30 | 29 | 30 | TLE | |
p01268 | C++ | Time Limit Exceeded | #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define pb push_back
#define all(v) v.begin(), v.end()
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define MAXBOOL 1000000
using namespace std;
int main() {
int n, p;
vector<int> prime;
bool check[MAXBOOL];
while (cin >> n >> p, n != -1 || p != -1) {
prime.clear();
fill(check, check + MAXBOOL, true);
check[0] = check[1] = false;
loop(i, 2, sqrt(MAXBOOL)) {
for (int j = i * 2; j < MAXBOOL; j += i) {
check[j] = false;
}
}
int cnt = 0;
while (prime.size() <= 200) {
if (check[n + 1 + cnt])
prime.pb(n + 1 + cnt);
cnt++;
}
vector<int> ans;
rep(i, prime.size()) {
loop(j, i, prime.size()) { ans.pb(prime[i] + prime[j]); }
}
sort(all(ans));
cout << ans[p - 1] << endl;
}
return 0;
}
| #include <algorithm>
#include <cmath>
#include <iostream>
#include <vector>
#define pb push_back
#define all(v) v.begin(), v.end()
#define loop(i, a, b) for (int i = a; i < b; i++)
#define rep(i, a) loop(i, 0, a)
#define MAXBOOL 500000
using namespace std;
int main() {
int n, p;
vector<int> prime;
bool check[MAXBOOL];
while (cin >> n >> p, n != -1 || p != -1) {
prime.clear();
fill(check, check + MAXBOOL, true);
check[0] = check[1] = false;
loop(i, 2, sqrt(MAXBOOL)) {
for (int j = i * 2; j < MAXBOOL; j += i) {
check[j] = false;
}
}
int cnt = 0;
while (prime.size() <= 200) {
if (check[n + 1 + cnt])
prime.pb(n + 1 + cnt);
cnt++;
}
vector<int> ans;
rep(i, prime.size()) {
loop(j, i, prime.size()) { ans.pb(prime[i] + prime[j]); }
}
sort(all(ans));
cout << ans[p - 1] << endl;
}
return 0;
}
| replace | 8 | 9 | 8 | 9 | TLE | |
p01269 | C++ | Runtime Error | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define CLR(a) memset((a), 0, sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF (1 << 9)
struct P {
int from, money, damage;
bool operator>(const P &p) const { return damage > p.damage; }
};
struct edge {
int from, cost, damage;
};
int main() {
int town_n, road_n, money;
while (cin >> town_n >> road_n >> money, town_n | road_n | money) {
vector<vector<edge>> E(town_n + 1);
REP(i, road_n) {
int to, from, cost, damage;
cin >> to >> from >> cost >> damage;
E[to].push_back({from, cost, damage});
E[from].push_back({to, cost, damage});
}
bool G[town_n + 1][money + 1];
fill_n((int *)G, (town_n + 1) * (money + 1), false);
priority_queue<P, vector<P>, greater<P>> que;
que.push({1, money, 0});
while (!que.empty()) {
P p = que.top();
que.pop();
if (p.from == town_n) {
cout << p.damage << endl;
break;
}
if (!G[p.from][p.money]) {
G[p.from][p.money] = true;
for (edge e : E[p.from]) {
if (p.money >= e.cost) {
que.push({e.from, p.money - e.cost, p.damage});
}
que.push({e.from, p.money, p.damage + e.damage});
}
}
}
}
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <fstream>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define LOG(...) printf(__VA_ARGS__)
// #define LOG(...)
#define FOR(i, a, b) for (int i = (int)(a); i < (int)(b); ++i)
#define REP(i, n) for (int i = 0; i < (int)(n); ++i)
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define EXIST(s, e) ((s).find(e) != (s).end())
#define SORT(c) sort((c).begin(), (c).end())
#define RSORT(c) sort((c).rbegin(), (c).rend())
#define CLR(a) memset((a), 0, sizeof(a))
typedef long long ll;
typedef unsigned long long ull;
typedef vector<bool> vb;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<vb> vvb;
typedef vector<vi> vvi;
typedef vector<vll> vvll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
#define INF (1 << 9)
struct P {
int from, money, damage;
bool operator>(const P &p) const { return damage > p.damage; }
};
struct edge {
int from, cost, damage;
};
int main() {
int town_n, road_n, money;
while (cin >> town_n >> road_n >> money, town_n | road_n | money) {
vector<vector<edge>> E(town_n + 1);
REP(i, road_n) {
int to, from, cost, damage;
cin >> to >> from >> cost >> damage;
E[to].push_back({from, cost, damage});
E[from].push_back({to, cost, damage});
}
bool G[town_n + 1][money + 1];
fill_n((bool *)G, (town_n + 1) * (money + 1), false);
priority_queue<P, vector<P>, greater<P>> que;
que.push({1, money, 0});
while (!que.empty()) {
P p = que.top();
que.pop();
if (p.from == town_n) {
cout << p.damage << endl;
break;
}
if (!G[p.from][p.money]) {
G[p.from][p.money] = true;
for (edge e : E[p.from]) {
if (p.money >= e.cost) {
que.push({e.from, p.money - e.cost, p.damage});
}
que.push({e.from, p.money, p.damage + e.damage});
}
}
}
}
} | replace | 65 | 66 | 65 | 66 | -11 | |
p01269 | C++ | Runtime Error | // http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2151
#include <algorithm>
#include <iostream>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
typedef pair<int, int> state; // 頂点、残金
typedef pair<state, int> pass; // 状態、悪党
typedef tuple<int, int, int> cand; // -1 * cost, point, money
vector<pass> V[110][110];
int main() {
int N, M, L;
while (cin >> N >> M >> L && N) {
N--;
// 初期化
for (auto i = 0; i < 110; i++) {
for (auto j = 0; j < 110; j++) {
V[i][j].clear();
}
}
// 入力受け取り
int AA[110], BB[110], DD[110], EE[110];
for (auto i = 0; i < M; i++) {
cin >> AA[i] >> BB[i] >> DD[i] >> EE[i];
AA[i]--;
BB[i]--;
}
// 隣接リスト作成
for (auto i = 0; i < M; i++) {
for (auto j = 0; j <= L; j++) {
V[AA[i]][j].push_back(make_pair(make_pair(BB[i], j), EE[i]));
V[BB[i]][j].push_back(make_pair(make_pair(AA[i], j), EE[i]));
int t = j - DD[i];
if (t >= 0) {
V[AA[i]][j].push_back(make_pair(make_pair(BB[i], t), 0));
V[BB[i]][j].push_back(make_pair(make_pair(AA[i], t), 0));
}
}
}
// Dijkstra法
priority_queue<cand> Q;
Q.push(make_tuple(0, 0, L));
bool visited[110][110];
fill(&visited[0][0], &visited[0][0] + 110 * 110, false);
int ans = 0;
while (!Q.empty()) {
int np = get<1>(Q.top());
int nl = get<2>(Q.top());
int nc = -1 * get<0>(Q.top());
Q.pop();
if (!visited[np][nl]) {
visited[np][nl] = true;
// cerr << "visiting " << np << " at " << nl << endl;
if (np == N) {
ans = nc;
break;
}
for (auto i = 0; i < V[np][nl].size(); i++) {
int dp = V[np][nl][i].first.first;
int dl = V[np][nl][i].first.second;
int dc = V[np][nl][i].second;
if (!visited[dp][dl]) {
Q.push(make_tuple(-1 * (dc + nc), dp, dl));
}
}
}
}
cout << ans << endl;
}
} | // http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2151
#include <algorithm>
#include <iostream>
#include <queue>
#include <tuple>
#include <vector>
using namespace std;
typedef pair<int, int> state; // 頂点、残金
typedef pair<state, int> pass; // 状態、悪党
typedef tuple<int, int, int> cand; // -1 * cost, point, money
vector<pass> V[110][110];
int main() {
int N, M, L;
while (cin >> N >> M >> L && N) {
N--;
// 初期化
for (auto i = 0; i < 110; i++) {
for (auto j = 0; j < 110; j++) {
V[i][j].clear();
}
}
// 入力受け取り
int AA[10000], BB[10000], DD[10000], EE[10000];
for (auto i = 0; i < M; i++) {
cin >> AA[i] >> BB[i] >> DD[i] >> EE[i];
AA[i]--;
BB[i]--;
}
// 隣接リスト作成
for (auto i = 0; i < M; i++) {
for (auto j = 0; j <= L; j++) {
V[AA[i]][j].push_back(make_pair(make_pair(BB[i], j), EE[i]));
V[BB[i]][j].push_back(make_pair(make_pair(AA[i], j), EE[i]));
int t = j - DD[i];
if (t >= 0) {
V[AA[i]][j].push_back(make_pair(make_pair(BB[i], t), 0));
V[BB[i]][j].push_back(make_pair(make_pair(AA[i], t), 0));
}
}
}
// Dijkstra法
priority_queue<cand> Q;
Q.push(make_tuple(0, 0, L));
bool visited[110][110];
fill(&visited[0][0], &visited[0][0] + 110 * 110, false);
int ans = 0;
while (!Q.empty()) {
int np = get<1>(Q.top());
int nl = get<2>(Q.top());
int nc = -1 * get<0>(Q.top());
Q.pop();
if (!visited[np][nl]) {
visited[np][nl] = true;
// cerr << "visiting " << np << " at " << nl << endl;
if (np == N) {
ans = nc;
break;
}
for (auto i = 0; i < V[np][nl].size(); i++) {
int dp = V[np][nl][i].first.first;
int dl = V[np][nl][i].first.second;
int dc = V[np][nl][i].second;
if (!visited[dp][dl]) {
Q.push(make_tuple(-1 * (dc + nc), dp, dl));
}
}
}
}
cout << ans << endl;
}
} | replace | 26 | 27 | 26 | 27 | 0 | |
p01269 | C++ | Memory Limit Exceeded | #include <bits/stdc++.h>
using namespace std;
#define int long long
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define ITR(i, c) for (auto i = begin(c); i != end(c); ++i)
#define FORE(x, c) for (auto &x : c)
#define REPF(i, a, n) for (int i = a, i##len = (int)(n); i < i##len; ++i)
#define REP(i, n) REPF(i, 0, n)
#define REPR(i, n) for (int i = (int)(n); i >= 0; --i)
#define REPW(i, n) for (i = 0; i < (int)(n); ++i)
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c) // c++14
#define SZ(c) ((int)c.size())
#define EXIST(c, x) (c.find(x) != end(c))
#define OUTOFRANGE(y, x, h, w) (y < 0 || x < 0 || y >= h || x >= w)
#define dump(...)
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
#define INF (1001001001)
#define INFLL (1001001001001001001ll)
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, v) os << *i << (i == end(v) - 1 ? "" : "\n");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, v) is >> *i;
return is;
}
template <class T> istream &operator>>(istream &is, pair<T, T> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//------------------------------------------------------------------------------
struct before_main_function {
before_main_function() {
#ifdef int
#undef INF
#define INF INFLL
#define stoi stoll
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(15) << fixed;
}
} before_main_function;
//------------------------------------------------------------------------------
void solve(int N, int M, int L) {
struct edge {
int to;
int left;
int dist;
int thief;
};
vector<vector<vector<edge>>> g(N, vector<vector<edge>>(110));
REP(i, M) {
int a, b, d, e;
cin >> a >> b >> d >> e;
REP(j, 110) {
g[a - 1][j].push_back(edge{b - 1, j, d, e}); // ????????????
if (j - d >= 0)
g[a - 1][j].push_back(edge{b - 1, j - d, d, e}); // ??????
}
REP(j, 110) {
g[b - 1][j].push_back(edge{a - 1, j, d, e}); // ????????????
if (j - d >= 0)
g[b - 1][j].push_back(edge{a - 1, j - d, d, e}); // ??????
}
}
vector<vector<int>> dp(N, vector<int>(110, INF));
dp[0][L] = 0;
priority_queue<pair<int, pii>, vector<pair<int, pii>>,
greater<pair<int, pii>>>
pq;
pq.push({0, {0, L}});
while (!pq.empty()) {
int y = pq.top().second.first;
int z = pq.top().second.second;
pq.pop();
FORE(e, g[y][z]) {
if (z == e.left) {
if (dp[e.to][e.left] > dp[y][z] + e.thief) {
dp[e.to][e.left] = dp[y][z] + e.thief;
pq.push({dp[e.to][e.left], {e.to, e.left}});
}
} else {
if (dp[e.to][e.left] > dp[y][z]) {
dp[e.to][e.left] = dp[y][z];
pq.push({dp[e.to][e.left], {e.to, e.left}});
}
}
}
}
int ans = INF;
REP(i, 110) chmin(ans, dp[N - 1][i]);
cout << ans << endl;
}
signed main() {
while (1) {
int N, M, L;
cin >> N >> M >> L;
if (N + M + L == 0)
break;
solve(N, M, L);
}
return 0;
} | #include <bits/stdc++.h>
using namespace std;
// #define int long long
using ll = long long;
using vi = vector<int>;
using vl = vector<long long>;
using pii = pair<int, int>;
using pll = pair<long long, long long>;
#define ITR(i, c) for (auto i = begin(c); i != end(c); ++i)
#define FORE(x, c) for (auto &x : c)
#define REPF(i, a, n) for (int i = a, i##len = (int)(n); i < i##len; ++i)
#define REP(i, n) REPF(i, 0, n)
#define REPR(i, n) for (int i = (int)(n); i >= 0; --i)
#define REPW(i, n) for (i = 0; i < (int)(n); ++i)
#define ALL(c) begin(c), end(c)
#define RALL(c) rbegin(c), rend(c) // c++14
#define SZ(c) ((int)c.size())
#define EXIST(c, x) (c.find(x) != end(c))
#define OUTOFRANGE(y, x, h, w) (y < 0 || x < 0 || y >= h || x >= w)
#define dump(...)
const int DX[9] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
DY[9] = {-1, 0, 1, 0, -1, 1, 1, -1, 0};
#define INF (1001001001)
#define INFLL (1001001001001001001ll)
template <class T> ostream &operator<<(ostream &os, const vector<T> &v) {
ITR(i, v) os << *i << (i == end(v) - 1 ? "" : "\n");
return os;
}
template <class T> istream &operator>>(istream &is, vector<T> &v) {
ITR(i, v) is >> *i;
return is;
}
template <class T> istream &operator>>(istream &is, pair<T, T> &p) {
is >> p.first >> p.second;
return is;
}
template <class T> bool chmax(T &a, const T &b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
template <class T> bool chmin(T &a, const T &b) {
if (b < a) {
a = b;
return 1;
}
return 0;
}
//------------------------------------------------------------------------------
struct before_main_function {
before_main_function() {
#ifdef int
#undef INF
#define INF INFLL
#define stoi stoll
#endif
cin.tie(0);
ios::sync_with_stdio(false);
cout << setprecision(15) << fixed;
}
} before_main_function;
//------------------------------------------------------------------------------
void solve(int N, int M, int L) {
struct edge {
int to;
int left;
int dist;
int thief;
};
vector<vector<vector<edge>>> g(N, vector<vector<edge>>(110));
REP(i, M) {
int a, b, d, e;
cin >> a >> b >> d >> e;
REP(j, 110) {
g[a - 1][j].push_back(edge{b - 1, j, d, e}); // ????????????
if (j - d >= 0)
g[a - 1][j].push_back(edge{b - 1, j - d, d, e}); // ??????
}
REP(j, 110) {
g[b - 1][j].push_back(edge{a - 1, j, d, e}); // ????????????
if (j - d >= 0)
g[b - 1][j].push_back(edge{a - 1, j - d, d, e}); // ??????
}
}
vector<vector<int>> dp(N, vector<int>(110, INF));
dp[0][L] = 0;
priority_queue<pair<int, pii>, vector<pair<int, pii>>,
greater<pair<int, pii>>>
pq;
pq.push({0, {0, L}});
while (!pq.empty()) {
int y = pq.top().second.first;
int z = pq.top().second.second;
pq.pop();
FORE(e, g[y][z]) {
if (z == e.left) {
if (dp[e.to][e.left] > dp[y][z] + e.thief) {
dp[e.to][e.left] = dp[y][z] + e.thief;
pq.push({dp[e.to][e.left], {e.to, e.left}});
}
} else {
if (dp[e.to][e.left] > dp[y][z]) {
dp[e.to][e.left] = dp[y][z];
pq.push({dp[e.to][e.left], {e.to, e.left}});
}
}
}
}
int ans = INF;
REP(i, 110) chmin(ans, dp[N - 1][i]);
cout << ans << endl;
}
signed main() {
while (1) {
int N, M, L;
cin >> N >> M >> L;
if (N + M + L == 0)
break;
solve(N, M, L);
}
return 0;
} | replace | 2 | 3 | 2 | 3 | MLE | |
p01269 | C++ | Time Limit Exceeded | #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int N, M, L;
int a, b;
int now;
cin >> N >> M >> L;
for (; N != 0;) {
vector<vector<bool>> graph(N, vector<bool>(N, false));
vector<vector<int>> distance(N, vector<int>(N)), evect(N, vector<int>(N));
// vector<vector<int>> dp(N,vector<int>(L+1,1000000000));
vector<vector<int>> dp_old(N, vector<int>(L + 1, 1000000000));
queue<int> vertex;
for (int i = 0; i < M; i++) {
cin >> a >> b;
a--;
b--;
graph[a][b] = true;
graph[b][a] = true;
cin >> distance[a][b] >> evect[a][b];
distance[b][a] = distance[a][b];
evect[b][a] = evect[a][b];
}
for (int i = 0; i <= L; i++) {
dp_old[0][i] = 0;
// dp[0][i] = 0;
}
for (int itr = 0; itr < N; itr++) {
vector<bool> reached(N, false);
reached[0] = true;
if (itr == 0) {
for (int i = 0; i < N; i++) {
if (graph[0][i]) {
vertex.push(i);
// graph[0][i] = false;
// graph[i][0] = false;
dp_old[i][L] = evect[0][i];
// dp[i][L] = evect[0][i];
if (L >= distance[0][i]) {
dp_old[i][L - distance[0][i]] = 0;
// dp[i][L-distance[0][i]] = 0;
}
}
}
} else {
for (int i = 0; i < N; i++) {
if (graph[0][i]) {
vertex.push(i);
}
}
}
for (; !vertex.empty();) {
now = vertex.front();
reached[now] = true;
vertex.pop();
for (int i = 1; i < N; i++) {
if (graph[now][i]) {
if (!reached[i])
vertex.push(i);
for (int j = 0; j <= L; j++) {
if (j + distance[now][i] <= L) {
dp_old[now][j] =
min(dp_old[now][j], min(dp_old[i][j] + evect[now][i],
dp_old[i][j + distance[now][i]]));
// dp_old[i][j] =
// min(dp_old[i][j],min(dp_old[now][j]+evect[now][i],dp_old[now][j+distance[now][i]]));
// dp_old[now][j] = dp[now][j];
// dp_old[i][j] = dp[i][j];
} else {
dp_old[now][j] =
min(dp_old[i][j] + evect[now][i], dp_old[now][j]);
// dp_old[i][j] =
// min(dp_old[now][j]+evect[now][i],dp_old[i][j]);
// dp_old[now][j] = dp[now][j];
// dp_old[i][j] = dp[i][j];
}
}
}
}
// swap(dp,dp_old);
}
}
// swap(dp,dp_old);
int ans = dp_old[N - 1][L];
for (int i = 0; i < L; i++) {
ans = min(ans, dp_old[N - 1][i]);
}
cout << ans << endl;
cin >> N >> M >> L;
}
return 0;
}
| #include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
int main() {
int N, M, L;
int a, b;
int now;
cin >> N >> M >> L;
for (; N != 0;) {
vector<vector<bool>> graph(N, vector<bool>(N, false));
vector<vector<int>> distance(N, vector<int>(N)), evect(N, vector<int>(N));
// vector<vector<int>> dp(N,vector<int>(L+1,1000000000));
vector<vector<int>> dp_old(N, vector<int>(L + 1, 1000000000));
queue<int> vertex;
for (int i = 0; i < M; i++) {
cin >> a >> b;
a--;
b--;
graph[a][b] = true;
graph[b][a] = true;
cin >> distance[a][b] >> evect[a][b];
distance[b][a] = distance[a][b];
evect[b][a] = evect[a][b];
}
for (int i = 0; i <= L; i++) {
dp_old[0][i] = 0;
// dp[0][i] = 0;
}
for (int itr = 0; itr < N / 2 + 1; itr++) {
vector<bool> reached(N, false);
reached[0] = true;
if (itr == 0) {
for (int i = 0; i < N; i++) {
if (graph[0][i]) {
vertex.push(i);
// graph[0][i] = false;
// graph[i][0] = false;
dp_old[i][L] = evect[0][i];
// dp[i][L] = evect[0][i];
if (L >= distance[0][i]) {
dp_old[i][L - distance[0][i]] = 0;
// dp[i][L-distance[0][i]] = 0;
}
}
}
} else {
for (int i = 0; i < N; i++) {
if (graph[0][i]) {
vertex.push(i);
}
}
}
for (; !vertex.empty();) {
now = vertex.front();
reached[now] = true;
vertex.pop();
for (int i = 1; i < N; i++) {
if (graph[now][i]) {
if (!reached[i])
vertex.push(i);
for (int j = 0; j <= L; j++) {
if (j + distance[now][i] <= L) {
dp_old[now][j] =
min(dp_old[now][j], min(dp_old[i][j] + evect[now][i],
dp_old[i][j + distance[now][i]]));
// dp_old[i][j] =
// min(dp_old[i][j],min(dp_old[now][j]+evect[now][i],dp_old[now][j+distance[now][i]]));
// dp_old[now][j] = dp[now][j];
// dp_old[i][j] = dp[i][j];
} else {
dp_old[now][j] =
min(dp_old[i][j] + evect[now][i], dp_old[now][j]);
// dp_old[i][j] =
// min(dp_old[now][j]+evect[now][i],dp_old[i][j]);
// dp_old[now][j] = dp[now][j];
// dp_old[i][j] = dp[i][j];
}
}
}
}
// swap(dp,dp_old);
}
}
// swap(dp,dp_old);
int ans = dp_old[N - 1][L];
for (int i = 0; i < L; i++) {
ans = min(ans, dp_old[N - 1][i]);
}
cout << ans << endl;
cin >> N >> M >> L;
}
return 0;
}
| replace | 32 | 33 | 32 | 33 | TLE | |
p01269 | C++ | Time Limit Exceeded | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(0)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
template <typename T> T &max(T &a, T &b) {
if (a >= b)
return a;
return b;
}
template <typename T> T &min(T &a, T &b) {
if (a < b)
return a;
return b;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> T get() {
T a;
cin >> a;
return a;
}
template <typename T> T rev(T a) {
reverse(all(a));
return a;
}
template <typename T> vector<T> &sort(vector<T> &a) {
sort(all(a));
return a;
}
const int inf = 1e9;
const ll linf = 3e18;
const double eps = 1e-9;
int N, M, L;
struct State {
int v, sum, dist;
State(int v, int sum, int dist) : v(v), sum(sum), dist(dist) {}
bool operator<(const State &a) const { return dist > a.dist; }
};
struct edge {
int to, money, enemy;
edge(int to, int money, int enemy) : to(to), money(money), enemy(enemy) {}
};
vector<edge> G[101];
int d[101][101];
void dijkstra(int s) {
for (int i = 0; i <= 100; ++i)
for (int j = 0; j < N; ++j)
d[i][j] = inf;
priority_queue<State> q;
q.push(State(s, 0, 0));
d[0][s] = 0;
while (q.size()) {
State st = q.top();
q.pop();
if (d[st.sum][st.v] < st.dist)
continue;
for (int i = 0; i < G[st.v].size(); ++i) {
edge e = G[st.v][i];
if (st.sum + e.money <= L) {
if (d[st.sum + e.money][e.to] < st.dist)
continue;
d[st.sum + e.money][e.to] = st.dist;
q.push(State(e.to, st.sum + e.money, d[st.sum + e.money][e.to]));
}
if (d[st.sum][e.to] > st.dist + e.enemy) {
d[st.sum][e.to] = st.dist + e.enemy;
q.push(State(e.to, st.sum, d[st.sum][e.to]));
}
}
}
}
signed main() {
while (scanf("%d%d%d", &N, &M, &L), N) {
for (int i = 0; i < N; ++i)
G[i].clear();
for (int i = 0; i < M; ++i) {
int A, B, D, E;
scanf("%d%d%d%d", &A, &B, &D, &E);
A--, B--;
G[A].push_back(edge(B, D, E));
G[B].push_back(edge(A, D, E));
}
dijkstra(0);
int mi = inf;
for (int i = 0; i <= 100; ++i) {
chmin(mi, d[i][N - 1]);
}
printf("%d\n", mi);
}
} | #include <algorithm>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define fst first
#define scd second
#define PB push_back
#define MP make_pair
#define all(a) a.begin(), a.end()
#define rall(a) a.rbegin(), a.rend()
#define omajinai \
ios::sync_with_stdio(false); \
cin.tie(0)
typedef long long ll;
typedef long double ld;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef pair<int, int> pii;
typedef vector<pii> vpii;
template <typename T> T &max(T &a, T &b) {
if (a >= b)
return a;
return b;
}
template <typename T> T &min(T &a, T &b) {
if (a < b)
return a;
return b;
}
template <typename T> bool chmax(T &a, T b) {
if (a < b) {
a = b;
return true;
}
return false;
}
template <typename T> bool chmin(T &a, T b) {
if (a > b) {
a = b;
return true;
}
return false;
}
template <typename T> T get() {
T a;
cin >> a;
return a;
}
template <typename T> T rev(T a) {
reverse(all(a));
return a;
}
template <typename T> vector<T> &sort(vector<T> &a) {
sort(all(a));
return a;
}
const int inf = 1e9;
const ll linf = 3e18;
const double eps = 1e-9;
int N, M, L;
struct State {
int v, sum, dist;
State(int v, int sum, int dist) : v(v), sum(sum), dist(dist) {}
bool operator<(const State &a) const { return dist > a.dist; }
};
struct edge {
int to, money, enemy;
edge(int to, int money, int enemy) : to(to), money(money), enemy(enemy) {}
};
vector<edge> G[101];
int d[101][101];
void dijkstra(int s) {
for (int i = 0; i <= 100; ++i)
for (int j = 0; j < N; ++j)
d[i][j] = inf;
priority_queue<State> q;
q.push(State(s, 0, 0));
d[0][s] = 0;
while (q.size()) {
State st = q.top();
q.pop();
if (d[st.sum][st.v] < st.dist)
continue;
for (int i = 0; i < G[st.v].size(); ++i) {
edge e = G[st.v][i];
if (st.sum + e.money <= L) {
do {
if (d[st.sum + e.money][e.to] <= st.dist)
continue;
d[st.sum + e.money][e.to] = st.dist;
q.push(State(e.to, st.sum + e.money, d[st.sum + e.money][e.to]));
} while (0);
}
if (d[st.sum][e.to] > st.dist + e.enemy) {
d[st.sum][e.to] = st.dist + e.enemy;
q.push(State(e.to, st.sum, d[st.sum][e.to]));
}
}
}
}
signed main() {
while (scanf("%d%d%d", &N, &M, &L), N) {
for (int i = 0; i < N; ++i)
G[i].clear();
for (int i = 0; i < M; ++i) {
int A, B, D, E;
scanf("%d%d%d%d", &A, &B, &D, &E);
A--, B--;
G[A].push_back(edge(B, D, E));
G[B].push_back(edge(A, D, E));
}
dijkstra(0);
int mi = inf;
for (int i = 0; i <= 100; ++i) {
chmin(mi, d[i][N - 1]);
}
printf("%d\n", mi);
}
} | replace | 116 | 120 | 116 | 122 | TLE |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.