buggy_code
stringlengths 11
625k
| fixed_code
stringlengths 17
625k
| bug_type
stringlengths 2
4.45k
| language
int64 0
8
| token_count
int64 5
200k
|
|---|---|---|---|---|
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int n, w;
int dat[100];
int maxi;
int l, r;
double calc() {
double ans = 0;
for (int i = l; i <= r; ++i) {
ans += ((double)(r - i) / (r - l)) * ((double)dat[i] / maxi);
}
return ans + 0.01;
}
main() {
while ((cin >> n >> w) && (n || w)) {
fill(dat, dat + 101, 0);
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
v /= w;
++dat[v];
l = i == 0 ? v : min(l, v);
r = i == 0 ? v : max(r, v);
maxi = i == 0 ? dat[v] : max(maxi, dat[v]);
}
cout << calc() << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
int n, w;
int dat[100];
int maxi;
int l, r;
double calc() {
double ans = 0;
l = 0;
for (int i = l; i <= r; ++i) {
ans += ((double)(r - i) / (r - l)) * ((double)dat[i] / maxi);
}
return ans + 0.01;
}
main() {
while ((cin >> n >> w) && (n || w)) {
fill(dat, dat + 101, 0);
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
v /= w;
++dat[v];
l = i == 0 ? v : min(l, v);
r = i == 0 ? v : max(r, v);
maxi = i == 0 ? dat[v] : max(maxi, dat[v]);
}
cout << calc() << endl;
}
}
|
[["+", 0, 14, 8, 9, 0, 1, 0, 11, 31, 22], ["+", 0, 14, 8, 9, 0, 1, 0, 11, 17, 32], ["+", 0, 14, 8, 9, 0, 1, 0, 11, 12, 13], ["+", 0, 30, 0, 14, 8, 9, 0, 1, 0, 35]]
| 1
| 218
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int f[100];
int main() {
int n, w, v;
while (cin >> n >> w, n | w) {
memset(f, 0, sizeof(f));
int rm = 0, maxh = 0;
double s = 0;
while (n--) {
cin >> v;
maxh = max(maxh, ++f[v / w]);
rm = max(rm, v / w);
}
for (int i = 0; i <= rm; i++) {
s += f[i] * (1 - (double)i / rm);
}
cout << s + 0.01 << endl;
}
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int f[100];
int main() {
int n, w, v;
while (cin >> n >> w, n | w) {
memset(f, 0, sizeof(f));
int rm = 0, maxh = 0;
double s = 0;
while (n--) {
cin >> v;
maxh = max(maxh, ++f[v / w]);
rm = max(rm, v / w);
}
for (int i = 0; i <= rm; i++) {
s += f[i] * (1 - (double)i / rm);
}
cout << s / maxh + 0.01 << endl;
}
return 0;
}
|
[["+", 0, 16, 31, 16, 12, 16, 31, 16, 17, 85], ["+", 0, 16, 31, 16, 12, 16, 31, 16, 12, 22]]
| 1
| 151
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof__((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CL(arr, val) memset(arr, val, sizeof(arr))
#define COPY(dest, src) memcpy(dest, src, sizeof(dest))
#define ten(n) ((long long)(1e##n))
#define bin(n) (1LL << (n))
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define revrep(i, n) for (int i = (n); i >= 0; --i)
#define pb push_back
template <class T> void chmax(T &a, const T &b) { a = max(a, b); }
template <class T> void chmin(T &a, const T &b) { a = min(a, b); }
template <class T> void uniq(T &c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
cout << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
void print(T a, int n, const string &deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n)
cout << deli;
}
while (br--)
cout << endl;
}
template <class T> void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <class T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
template <class T> void input(T *a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
void fix_pre(int n) {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(10);
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
#define trace(x) (cout << #x << ": " << (x) << endl)
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
// y(v): v>^< y(^): ^>v<
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
#define mp make_pair
int main() {
int n, w;
while (cin >> n >> w, n && w) {
int max_v = 0;
int occur[16] = {};
rep(i, n) {
int v;
cin >> v;
v /= 10;
chmax(max_v, v);
++occur[v];
}
double max_o = *max_element(occur, occur + max_v + 1);
double res = 0;
if (max_v > 0) {
rep(i, max_v) res += occur[i] * (max_v - i);
res = res / max_o / max_v;
}
res += 0.01;
printf("%.10f\n", res);
}
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); ++i)
#define foreach(it, c) \
for (__typeof__((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define rforeach(it, c) \
for (__typeof__((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define all(c) (c).begin(), (c).end()
#define rall(c) (c).rbegin(), (c).rend()
#define CL(arr, val) memset(arr, val, sizeof(arr))
#define COPY(dest, src) memcpy(dest, src, sizeof(dest))
#define ten(n) ((long long)(1e##n))
#define bin(n) (1LL << (n))
#define erep(i, n) for (int i = 0; i <= (int)(n); ++i)
#define revrep(i, n) for (int i = (n); i >= 0; --i)
#define pb push_back
template <class T> void chmax(T &a, const T &b) { a = max(a, b); }
template <class T> void chmin(T &a, const T &b) { a = min(a, b); }
template <class T> void uniq(T &c) {
sort(c.begin(), c.end());
c.erase(unique(c.begin(), c.end()), c.end());
}
template <class T> string to_s(const T &a) {
ostringstream os;
os << a;
return os.str();
}
template <class T> T to_T(const string &s) {
istringstream is(s);
T res;
is >> res;
return res;
}
template <typename T> void print_container(ostream &os, const T &c) {
const char *_s = " ";
if (!c.empty()) {
__typeof__(c.begin()) last = --c.end();
foreach (it, c) {
os << *it;
if (it != last)
cout << _s;
}
}
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const set<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const multiset<T> &c) {
print_container(os, c);
return os;
}
template <typename T> ostream &operator<<(ostream &os, const deque<T> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const map<T, U> &c) {
print_container(os, c);
return os;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << "( " << p.first << ", " << p.second << " )";
return os;
}
template <class T>
void print(T a, int n, const string &deli = " ", int br = 1) {
for (int i = 0; i < n; ++i) {
cout << a[i];
if (i + 1 != n)
cout << deli;
}
while (br--)
cout << endl;
}
template <class T> void print2d(T a, int w, int h, int width = -1, int br = 1) {
for (int i = 0; i < h; ++i) {
for (int j = 0; j < w; ++j) {
if (width != -1)
cout.width(width);
cout << a[i][j] << ' ';
}
cout << endl;
}
while (br--)
cout << endl;
}
template <class T> void input(T &a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
template <class T> void input(T *a, int n) {
for (int i = 0; i < n; ++i)
cin >> a[i];
}
void fix_pre(int n) {
cout.setf(ios::fixed, ios::floatfield);
cout.precision(10);
}
void fast_io() {
cin.tie(0);
ios::sync_with_stdio(false);
}
#define trace(x) (cout << #x << ": " << (x) << endl)
bool in_rect(int x, int y, int w, int h) {
return 0 <= x && x < w && 0 <= y && y < h;
}
typedef long long ll;
typedef pair<int, int> pint;
// y(v): v>^< y(^): ^>v<
const int dx[] = {0, 1, 0, -1};
const int dy[] = {1, 0, -1, 0};
const double PI = acos(-1.0);
#define mp make_pair
int main() {
int n, w;
while (cin >> n >> w, n && w) {
int max_v = 0;
int occur[16] = {};
rep(i, n) {
int v;
cin >> v;
v /= w;
chmax(max_v, v);
++occur[v];
}
double max_o = *max_element(occur, occur + max_v + 1);
double res = 0;
if (max_v > 0) {
rep(i, max_v) res += occur[i] * (max_v - i);
res = res / max_o / max_v;
}
res += 0.01;
printf("%.10f\n", res);
}
}
|
[["-", 0, 14, 8, 9, 0, 1, 0, 11, 12, 13], ["+", 0, 14, 8, 9, 0, 1, 0, 11, 12, 22]]
| 1
| 1,158
|
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#define REP(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, a) REP(i, 0, a)
using namespace std;
int n, m, k;
int main(void) {
while (cin >> n >> m >> k && n) {
int dp[n][n * m + 1];
memset(dp, 0, sizeof(dp));
rep(i, m) dp[0][i + 1] = 1;
REP(i, 1, n)
rep(j, m * n + 1) REP(k, max(0, j - m), j - 1) dp[i][j] += dp[i - 1][k];
int s = 0;
rep(i, m * n + 1) s += dp[n - 1][i];
double ans = 0.0;
rep(i, m * n + 1) ans += 1.0 * dp[n - 1][i] / s * max(1, i - k);
printf("%.10f\n", ans);
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <stdio.h>
#include <string.h>
#define REP(i, a, b) for (int i = (a); i < (b); i++)
#define rep(i, a) REP(i, 0, a)
using namespace std;
int n, m, k;
int main(void) {
while (cin >> n >> m >> k && n) {
int dp[n][n * m + 1];
memset(dp, 0, sizeof(dp));
rep(i, m) dp[0][i + 1] = 1;
REP(i, 1, n)
rep(j, m * n + 1) REP(k, max(0, j - m), j) dp[i][j] += dp[i - 1][k];
long long s = 0;
rep(i, m * n + 1) s += dp[n - 1][i];
double ans = 0.0;
rep(i, m * n + 1) ans += 1.0 * dp[n - 1][i] / s * max(1, i - k);
printf("%.10f\n", ans);
}
return 0;
}
|
[["-", 28, 69, 28, 2, 3, 4, 0, 16, 17, 33], ["-", 28, 69, 28, 2, 3, 4, 0, 16, 12, 13], ["-", 8, 9, 0, 52, 8, 9, 0, 43, 39, 40], ["+", 0, 52, 8, 9, 0, 43, 39, 86, 0, 96]]
| 1
| 236
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define SZ(n) (int)n.size()
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define MP make_pair
#define PB push_back
const int INF = 1 << 28;
int n, m, k;
int p[300000];
void dfs(int now, int sum) {
if (now == n)
p[sum]++;
if (now == n)
return;
for (int i = 1; i <= m; i++)
dfs(now + 1, sum + i);
}
int main() {
while (cin >> n >> m >> k, n + m + k) {
dfs(0, 0);
double ans = 0.0;
int kaku = pow(m, n);
for (int i = 1; i <= m * n; i++) {
double a = (double)p[i] / double(kaku);
double b = max(double(i - k), 1.0);
ans += a * b;
}
printf("%.10lf", ans);
fill(p, p + 300000, 0);
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <vector>
using namespace std;
#define SZ(n) (int)n.size()
#define dump(x) cerr << #x << " = " << (x) << endl;
#define debug(x) \
cerr << #x << " = " << (x) << " (L" << __LINE__ << ")" \
<< " " << __FILE__ << endl;
#define MP make_pair
#define PB push_back
const int INF = 1 << 28;
int n, m, k;
int p[300000];
void dfs(int now, int sum) {
if (now == n)
p[sum]++;
if (now == n)
return;
for (int i = 1; i <= m; i++)
dfs(now + 1, sum + i);
}
int main() {
while (cin >> n >> m >> k, n + m + k) {
dfs(0, 0);
double ans = 0.0;
int kaku = pow(m, n);
for (int i = 1; i <= m * n; i++) {
double a = (double)p[i] / double(kaku);
double b = max(double(i - k), 1.0);
ans += a * b;
}
printf("%.10lf\n", ans);
fill(p, p + 300000, 0);
}
return 0;
}
|
[["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 44]]
| 1
| 254
|
#include <algorithm>
#include <assert.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
double dp[2][1000000];
int main() {
int n, m, k;
while (scanf("%d %d %d", &n, &m, &k), n | m | k) {
dp[0][0] = 1.0;
REP(iter, n) {
int prev = iter & 1;
int next = (iter + 1) & 1;
memset(dp[next], 0, sizeof(int) * (iter * m + m));
FOREQ(i, 0, iter * m) {
FOREQ(j, 1, m) { dp[next][i + j] += dp[prev][i] / m; }
}
}
double ans = 0;
FOREQ(i, 1, n * m) { ans += max(i - k, 1) * dp[n & 1][i]; }
printf("%.7lf\n", ans);
}
}
|
#include <algorithm>
#include <assert.h>
#include <iostream>
#include <math.h>
#include <stdio.h>
#include <string.h>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned long long ull;
static const double EPS = 1e-9;
static const double PI = acos(-1.0);
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define FOR(i, s, n) for (int i = (s); i < (int)(n); i++)
#define FOREQ(i, s, n) for (int i = (s); i <= (int)(n); i++)
#define FORIT(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); it++)
#define MEMSET(v, h) memset((v), h, sizeof(v))
double dp[2][1000000];
int main() {
int n, m, k;
while (scanf("%d %d %d", &n, &m, &k), n | m | k) {
// MEMSET(dp, 0);
dp[0][0] = 1.0;
REP(iter, n) {
int prev = iter & 1;
int next = (iter + 1) & 1;
memset(dp[next], 0, sizeof(double) * (iter * m + m + 1));
FOREQ(i, 0, iter * m) {
FOREQ(j, 1, m) { dp[next][i + j] += dp[prev][i] / m; }
}
}
double ans = 0;
FOREQ(i, 1, n * m) { ans += max(i - k, 1) * dp[n & 1][i]; }
printf("%.7lf\n", ans);
}
}
|
[["-", 3, 4, 0, 105, 51, 74, 39, 77, 39, 40], ["+", 3, 4, 0, 105, 51, 74, 39, 77, 39, 40], ["+", 51, 74, 51, 66, 28, 23, 0, 16, 17, 72], ["+", 51, 74, 51, 66, 28, 23, 0, 16, 12, 13]]
| 1
| 296
|
#include <cmath>
#include <iostream>
using namespace std;
main() {
int n, m, k;
while (1) {
cin >> n >> m >> k;
if (n == 0 && m == 0 && k == 0)
break;
int num[100000000];
for (int i = 1; i <= n; i++)
num[i] = 1;
bool end = false;
double ans = 0;
double a = pow((double)m, (double)n);
for (;;) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += num[i];
}
if (sum <= k) {
ans += 1.0 / a;
} else {
ans += 1.0 / a * (double)(sum - k);
}
if (num[n] == m) {
num[n] = 0;
for (int t = n - 1;;) {
if (t <= 0) {
end = true;
break;
}
if (num[t] < m) {
num[t]++;
break;
} else {
num[t] = 1;
t--;
}
}
if (end)
break;
}
num[n]++;
}
printf("%.10f\n", ans);
}
return 0;
}
|
#include <cmath>
#include <iostream>
using namespace std;
main() {
int n, m, k;
while (1) {
cin >> n >> m >> k;
if (n == 0 && m == 0 && k == 0)
break;
int num[10000];
for (int i = 1; i <= n; i++)
num[i] = 1;
bool end = false;
double ans = 0;
double a = pow((double)m, (double)n);
for (;;) {
int sum = 0;
for (int i = 1; i <= n; i++) {
sum += num[i];
}
if (sum <= k) {
ans += 1.0 / a;
} else {
ans += 1.0 / a * (double)(sum - k);
}
if (num[n] == m) {
num[n] = 0;
for (int t = n - 1;;) {
if (t <= 0) {
end = true;
break;
}
if (num[t] < m) {
num[t]++;
break;
} else {
num[t] = 1;
t--;
}
}
if (end)
break;
}
num[n]++;
}
printf("%.10f\n", ans);
}
return 0;
}
|
[["-", 0, 52, 8, 9, 0, 43, 49, 80, 81, 13], ["+", 0, 52, 8, 9, 0, 43, 49, 80, 81, 13]]
| 1
| 272
|
while True:
n,m,k = list(map(int,input().split(" ")))
if n == m == k == 0: break
dice = [[0 for _ in range(m * n)] for _ in range(n)]
for i in range(m):
dice[0][i] = 1
for i in range(n-1):
for j in range(m * n):
if dice[i][j] == 0: continue
for l in range(1,m+1):
dice[i+1][j+l] += dice[i][j]
print(sum([(i+1-k if i+1-k > 1 else 1) * dice[n-1][i] for i in range(1,m*n)])/(m**n*1.))
|
while True:
n,m,k = list(map(int,input().split(" ")))
if n == m == k == 0: break
dice = [[0 for _ in range(m * n)] for _ in range(n)]
for i in range(m):
dice[0][i] = 1
for i in range(n-1):
for j in range(m * n):
if dice[i][j] == 0: continue
for l in range(1,m+1):
dice[i+1][j+l] += dice[i][j]
print(sum([(i+1-k if i+1-k > 1 else 1) * dice[n-1][i] for i in range((1*n-1),m*n)])/(m**n*1.))
|
[["+", 0, 659, 12, 652, 3, 4, 0, 23, 0, 24], ["+", 3, 4, 0, 23, 0, 657, 31, 657, 31, 612], ["+", 3, 4, 0, 23, 0, 657, 31, 657, 17, 48], ["+", 3, 4, 0, 23, 0, 657, 31, 657, 12, 22], ["+", 12, 652, 3, 4, 0, 23, 0, 657, 17, 33], ["+", 0, 659, 12, 652, 3, 4, 0, 23, 0, 25]]
| 5
| 194
|
#include <bits/stdc++.h>
using namespace std;
namespace {
template <class T> ostream &operator<<(ostream &os, const vector<T> &vs) {
if (vs.empty())
return os << "[]";
os << "[" << vs[0];
for (int i = 1; i < vs.size(); i++)
os << " " << vs[i];
return os << "]";
}
int N;
vector<int> S, T, U;
bool input() {
cin >> N;
if (N == 0)
return false;
S.clear();
T.clear();
U.clear();
for (int i = 0; i < N; i++) {
int s, t, u;
cin >> s >> t >> u;
S.push_back(s);
T.push_back(t);
U.push_back(u);
}
return true;
}
struct H {
int h, m, s;
int index;
H(int h, int m, int s) : h(h), m(m), s(s) {}
H(int t) {
h = t / 3600;
t %= 3600;
m = t / 60;
t %= 60;
s = t;
}
bool operator<(const H &x) const {
if (h == x.h) {
if (m == x.m)
return s < x.s;
return m < x.m;
} else {
return h < x.h;
}
}
int time() const { return h * 3600 + m * 60 + s; }
};
ostream &operator<<(ostream &os, const H &h) {
char buf[256];
sprintf(buf, "%02d:%02d:%02d", h.h, h.m, h.s);
return os << buf;
}
int operator-(const H &a, const H &b) { return a.time() - b.time(); }
bool all(const vector<int> &count) {
for (int i = 0; i < count.size(); i++) {
if (count[i] == 0)
return false;
}
return true;
}
void solve() {
set<H> C;
for (int t = 0; t < 24 * 60 * 60; t++) {
C.insert(H(t));
}
vector<H> V;
for (int i = 0; i < N; i++) {
for (int k = 0; k < 60; k++) {
vector<int> xs;
xs.push_back((S[i] + k) % 60);
xs.push_back((T[i] + k) % 60);
xs.push_back((U[i] + k) % 60);
sort(xs.begin(), xs.end());
do {
int h = xs[0] / 5;
int m = xs[1];
int s = xs[2];
int r = xs[0] % 5;
if (r * 12 <= m && m <= (r + 1) * 12) {
H t(h, m, s);
t.index = i;
if (C.count(t)) {
V.push_back(t);
}
}
} while (next_permutation(xs.begin(), xs.end()));
}
sort(V.begin(), V.end());
}
int s = 0, t = -1;
vector<int> count(N, 0);
int ans = 1 << 28;
int index = -1;
while (true) {
// cout << s << " " << t << endl;
if (all(count)) {
if (ans > V[t] - V[s]) {
ans = V[t] - V[s];
index = s;
}
count[V[s].index]--;
s++;
} else {
t++;
if (t == V.size())
break;
count[V[t].index]++;
}
}
cout << V[index] << " " << H(ans + V[index].time()) << endl;
}
} // namespace
int main() {
while (input())
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace {
template <class T> ostream &operator<<(ostream &os, const vector<T> &vs) {
if (vs.empty())
return os << "[]";
os << "[" << vs[0];
for (int i = 1; i < vs.size(); i++)
os << " " << vs[i];
return os << "]";
}
int N;
vector<int> S, T, U;
bool input() {
cin >> N;
if (N == 0)
return false;
S.clear();
T.clear();
U.clear();
for (int i = 0; i < N; i++) {
int s, t, u;
cin >> s >> t >> u;
S.push_back(s);
T.push_back(t);
U.push_back(u);
}
return true;
}
struct H {
int h, m, s;
int index;
H(int h, int m, int s) : h(h), m(m), s(s) {}
H(int t) {
h = t / 3600;
t %= 3600;
m = t / 60;
t %= 60;
s = t;
}
bool operator<(const H &x) const {
if (h == x.h) {
if (m == x.m)
return s < x.s;
return m < x.m;
} else {
return h < x.h;
}
}
int time() const { return h * 3600 + m * 60 + s; }
};
ostream &operator<<(ostream &os, const H &h) {
char buf[256];
sprintf(buf, "%02d:%02d:%02d", h.h, h.m, h.s);
return os << buf;
}
int operator-(const H &a, const H &b) { return a.time() - b.time(); }
bool all(const vector<int> &count) {
for (int i = 0; i < count.size(); i++) {
if (count[i] == 0)
return false;
}
return true;
}
void solve() {
set<H> C;
for (int t = 0; t < 24 * 60 * 60; t++) {
C.insert(H(t));
}
vector<H> V;
for (int i = 0; i < N; i++) {
for (int k = 0; k < 60; k++) {
vector<int> xs;
xs.push_back((S[i] + k) % 60);
xs.push_back((T[i] + k) % 60);
xs.push_back((U[i] + k) % 60);
sort(xs.begin(), xs.end());
do {
int h = xs[0] / 5;
int m = xs[1];
int s = xs[2];
int r = xs[0] % 5;
if (r * 12 <= m && m < (r + 1) * 12) {
H t(h, m, s);
t.index = i;
if (C.count(t)) {
V.push_back(t);
}
}
} while (next_permutation(xs.begin(), xs.end()));
}
sort(V.begin(), V.end());
}
int s = 0, t = -1;
vector<int> count(N, 0);
int ans = 1 << 28;
int index = -1;
while (true) {
// cout << s << " " << t << endl;
if (all(count)) {
if (ans > V[t] - V[s]) {
ans = V[t] - V[s];
index = s;
}
count[V[s].index]--;
s++;
} else {
t++;
if (t == V.size())
break;
count[V[t].index]++;
}
}
cout << V[index] << " " << H(ans + V[index].time()) << endl;
}
} // namespace
int main() {
while (input())
solve();
return 0;
}
|
[["-", 0, 57, 15, 339, 51, 16, 12, 16, 17, 19], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 17, 18]]
| 1
| 916
|
#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);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
FILE *fp = stdout;
#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int n;
int d[11][3];
vector<int> times[11];
void PrintTime(int t) {
int h = t / 3600;
t %= 3600;
int m = t / 60;
t %= 60;
int s = t;
fprintf(fp, "%02d:%02d:%02d", h, m, s);
}
int minMergine;
int st, ft;
void dfs(int idx, int lb, int ub) {
if (idx == n) {
if (minMergine > ub - lb) {
minMergine = ub - lb;
st = lb;
ft = ub;
} else if (minMergine == ub - lb) {
if (st > lb) {
st = lb;
ft = ub;
}
}
} else {
// ÅÍSðÂ\«ÆµÄ۵Ĩ
if (idx == 0) {
for (int i = 0; i < times[idx].size(); i++) {
int nxt = times[idx][i];
dfs(idx + 1, nxt, nxt);
}
} else {
// lb<=x<=ubÆÈéxª¶Ý·êÎA»êðIð
int x = *lower_bound(times[idx].begin(), times[idx].end(), lb);
if (x >= lb && x <= ub)
dfs(idx + 1, lb, ub);
// »ñ´¢µÈ¯êÎAubÉàÁÆàߢÍÍOÌvf©,lbÉàÁÆàߢÍÍOÌvfÌÇ¿ç©ðIð
else {
// lb closed elem
int nid = lower_bound(times[idx].begin(), times[idx].end(), lb) -
times[idx].begin();
if (nid != 0)
dfs(idx + 1, times[idx][nid - 1], ub);
nid = upper_bound(times[idx].begin(), times[idx].end(), ub) -
times[idx].begin();
if (nid != times[idx].size())
dfs(idx + 1, lb, times[idx][nid]);
}
}
}
}
int main() {
// fp=fopen("output.txt","w");
while (cin >> n && n != 0) {
minMergine = 1000000000;
for (int i = 0; i < 11; i++)
times[i].clear();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> d[i][j];
}
//»ê¼êÌvÉ¢ÄAÃÈÔÌÆèûðñµÄ¨
for (int i = 0; i < n; i++) {
int a[3];
for (int j = 0; j < 3; j++)
a[j] = d[i][j];
sort(a, a + 3);
do {
// ÃÈÔð²×é
for (int j = 0; j < 60; j++) {
int b;
int sum = 0;
bool bad = false;
for (int k = 0; k < 3; k++) {
int num = (a[k] + j + 60) % 60;
if (k == 0) {
sum += num;
} else if (k == 1) {
sum += num * 60;
b = num / 12;
} else {
if (b != num % 5) {
bad = true;
break;
}
sum += (num / 5) * 3600;
}
}
if (!bad)
times[i].push_back(sum);
}
} while (next_permutation(a, a + 3));
sort(times[i].begin(), times[i].end());
}
dfs(0, 0, 0);
PrintTime(st);
fprintf(fp, " ");
PrintTime(ft);
fprintf(fp, "\n");
// for(int i = 0; i < n; i++)
// cout<<times[i].size()<<endl;
// cout<<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);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
FILE *fp = stdout;
//#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int n;
int d[11][3];
vector<int> times[11];
void PrintTime(int t) {
int h = t / 3600;
t %= 3600;
int m = t / 60;
t %= 60;
int s = t;
fprintf(fp, "%02d:%02d:%02d", h, m, s);
}
int minMergine;
int st, ft;
void dfs(int idx, int lb, int ub) {
if (idx == n) {
if (minMergine > ub - lb) {
minMergine = ub - lb;
st = lb;
ft = ub;
} else if (minMergine == ub - lb) {
if (st > lb) {
st = lb;
ft = ub;
}
}
} else {
// ÅÍSðÂ\«ÆµÄ۵Ĩ
if (idx == 0) {
for (int i = 0; i < times[idx].size(); i++) {
int nxt = times[idx][i];
dfs(idx + 1, nxt, nxt);
}
} else {
// lb<=x<=ubÆÈéxª¶Ý·êÎA»êðIð
int x = *lower_bound(times[idx].begin(), times[idx].end(), lb);
if (x >= lb && x <= ub)
dfs(idx + 1, lb, ub);
// »ñ´¢µÈ¯êÎAubÉàÁÆàߢÍÍOÌvf©,lbÉàÁÆàߢÍÍOÌvfÌÇ¿ç©ðIð
else {
// lb closed elem
int nid = lower_bound(times[idx].begin(), times[idx].end(), lb) -
times[idx].begin();
if (nid != 0)
dfs(idx + 1, times[idx][nid - 1], ub);
nid = upper_bound(times[idx].begin(), times[idx].end(), ub) -
times[idx].begin();
if (nid != times[idx].size())
dfs(idx + 1, lb, times[idx][nid]);
}
}
}
}
int main() {
// fp=fopen("output.txt","w");
while (cin >> n && n != 0) {
minMergine = 1000000000;
for (int i = 0; i < 11; i++)
times[i].clear();
for (int i = 0; i < n; i++) {
for (int j = 0; j < 3; j++)
cin >> d[i][j];
}
//»ê¼êÌvÉ¢ÄAÃÈÔÌÆèûðñµÄ¨
for (int i = 0; i < n; i++) {
int a[3];
for (int j = 0; j < 3; j++)
a[j] = d[i][j];
sort(a, a + 3);
do {
// ÃÈÔð²×é
for (int j = 0; j < 60; j++) {
int b;
int sum = 0;
bool bad = false;
for (int k = 0; k < 3; k++) {
int num = (a[k] + j + 60) % 60;
if (k == 0) {
sum += num;
} else if (k == 1) {
sum += num * 60;
b = num / 12;
} else {
if (b != num % 5) {
bad = true;
break;
}
sum += (num / 5) * 3600;
}
}
if (!bad)
times[i].push_back(sum);
}
} while (next_permutation(a, a + 3));
sort(times[i].begin(), times[i].end());
}
dfs(0, 0, 0);
PrintTime(st);
fprintf(fp, " ");
PrintTime(ft);
fprintf(fp, "\n");
// for(int i = 0; i < n; i++)
// cout<<times[i].size()<<endl;
// cout<<endl;
}
return 0;
}
|
[["-", 36, 36, 36, 36, 0, 30, 0, 58, 0, 148], ["-", 36, 36, 36, 36, 0, 30, 0, 58, 141, 22]]
| 1
| 888
|
import static java.lang.Integer.parseInt;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Problem A: Grey Area
*/
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
String[] words;
Main main = new Main();
while ((line = br.readLine()) != null && !line.isEmpty()) {
int n, w;
n = parseInt(line.substring(0, line.indexOf(' ')));
w = parseInt(line.substring(line.indexOf(' ') + 1));
if ((n | w) == 0)
break;
int omax = 0; // occurence
int imax = 0; // interval
int[] h = new int[n];
for (int i = 0; i < n; i++) {
int v = parseInt(br.readLine());
int c = v / w;
h[c]++;
omax = Math.max(omax, h[c]);
imax = Math.max(imax, c);
}
Fraction ans = main.new Fraction(omax, h[0]);
for (int i = imax - 1, j = 1; i >= 0; i--, j++) {
ans = ans.plus(
main.new Fraction(imax, i).multi(main.new Fraction(omax, h[j])));
}
System.out.println(ans.toDouble() + 0.01);
} // end while
} // end main
class Fraction {
int d; // denominator
int n; // numerator
Fraction(int d, int n) {
this.d = d;
this.n = n;
}
Fraction plus(Fraction o) {
int _d = lcm(this.d, o.d);
int _n = this.n * (_d / this.d) + o.n * (_d / o.d);
int g = gcd(_d, _n);
_d /= g;
_n /= g;
return new Fraction(_d, _n);
}
Fraction multi(Fraction o) {
int _d = this.d * o.d;
int _n = this.n * o.n;
return new Fraction(_d, _n);
}
double toDouble() { return (double)n / d; }
}
static int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
static int lcm(int a, int b) { return a * (b / gcd(a, b)); }
}
|
import static java.lang.Integer.parseInt;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
/**
* Problem A: Grey Area
*/
public class Main {
public static void main(String[] args) throws IOException {
BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
String line;
String[] words;
Main main = new Main();
while ((line = br.readLine()) != null && !line.isEmpty()) {
int n, w;
n = parseInt(line.substring(0, line.indexOf(' ')));
w = parseInt(line.substring(line.indexOf(' ') + 1));
if ((n | w) == 0)
break;
int omax = 0; // occurence
int imax = 0; // interval
int[] h = new int[11];
for (int i = 0; i < n; i++) {
int v = parseInt(br.readLine());
int c = v / w;
h[c]++;
omax = Math.max(omax, h[c]);
imax = Math.max(imax, c);
}
Fraction ans = main.new Fraction(omax, h[0]);
for (int i = imax - 1, j = 1; i >= 0; i--, j++) {
ans = ans.plus(
main.new Fraction(imax, i).multi(main.new Fraction(omax, h[j])));
}
System.out.println(ans.toDouble() + 0.01);
} // end while
} // end main
class Fraction {
int d; // denominator
int n; // numerator
Fraction(int d, int n) {
this.d = d;
this.n = n;
}
Fraction plus(Fraction o) {
int _d = lcm(this.d, o.d);
int _n = this.n * (_d / this.d) + o.n * (_d / o.d);
int g = gcd(_d, _n);
_d /= g;
_n /= g;
return new Fraction(_d, _n);
}
Fraction multi(Fraction o) {
int _d = this.d * o.d;
int _n = this.n * o.n;
return new Fraction(_d, _n);
}
double toDouble() { return (double)n / d; }
}
static int gcd(int a, int b) {
if (b == 0)
return a;
return gcd(b, a % b);
}
static int lcm(int a, int b) { return a * (b / gcd(a, b)); }
}
|
[["-", 0, 503, 49, 200, 51, 227, 497, 505, 0, 22], ["+", 0, 503, 49, 200, 51, 227, 497, 505, 0, 499]]
| 3
| 560
|
#include <memory.h>
#include <stdio.h>
int main(void) {
int n, w, i, v, h[10], maxh, maxv, maxw;
double ans;
while (1) {
scanf("%d %d", &n, &w);
if (!n) {
break;
}
maxv = -1;
ans = maxh = maxw = 0;
memset(h, 0, sizeof(h));
for (i = 0; i < n; i++) {
scanf("%d", &v);
if (maxv < v) {
maxv = v;
}
if (maxw < v / w) {
maxw = v / w;
}
h[v / w]++;
if (maxh < h[v / w]) {
maxh = h[v / w];
}
}
for (i = maxw; i > 0; i--) {
ans += i * h[maxw - i];
}
ans = ans * 1.0 / (maxh * maxw);
ans += 0.01;
printf("%.16f\n", ans);
}
return 0;
}
|
#include <memory.h>
#include <stdio.h>
int main(void) {
int n, w, i, v, h[11], maxh, maxv, maxw;
double ans;
while (1) {
scanf("%d %d", &n, &w);
if (!n) {
break;
}
maxv = -1;
ans = maxh = maxw = 0;
memset(h, 0, sizeof(h));
for (i = 0; i < n; i++) {
scanf("%d", &v);
if (maxv < v) {
maxv = v;
}
if (maxw < v / w) {
maxw = v / w;
}
h[v / w]++;
if (maxh < h[v / w]) {
maxh = h[v / w];
}
}
for (i = maxw; i > 0; i--) {
ans += i * h[maxw - i];
}
ans = ans * 1.0 / (maxh * maxw);
ans += 0.01;
printf("%.16f\n", ans);
}
return 0;
}
|
[["-", 0, 14, 8, 9, 0, 43, 49, 80, 81, 13], ["+", 0, 14, 8, 9, 0, 43, 49, 80, 81, 13]]
| 0
| 224
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define INF 1e9
#define MOD 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, a, n) for (int i = a; i < n; i++)
#define all(in) in.begin(), in.end()
int main() {
int n, w;
while (true) {
cin >> n >> w;
if (n == 0 && w == 0)
break;
vector<int> v(n);
rep(i, n) cin >> v[i];
int max_v = 0, K;
rep(i, n) max_v = max(max_v, v[i]);
map<int, int> interval;
for (int i = 0; i < n; i++) {
for (int k = 0; k <= n; k++) {
if (k * w <= v[i] && v[i] < (k + 1) * w) {
if (max_v == v[i])
K = k;
interval[k]++;
}
}
}
double ans = 0;
int h = 0;
for (auto v : interval) {
int p = v.first, q = v.second;
h = max(h, q);
}
for (int i = K; i >= 0; i--) {
ans += ((double)i / K) * ((double)interval[K - i] / h);
// cout << ans << " " << interval[K - i] << endl;
}
ans += 0.01;
printf("%.17lf\n", ans);
}
return 0;
}
|
#include <algorithm>
#include <deque>
#include <iomanip>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdlib.h>
#include <string.h>
#include <string>
#include <vector>
using namespace std;
#define INF 1e9
#define MOD 1e9 + 7
#define rep(i, n) for (int i = 0; i < n; i++)
#define loop(i, a, n) for (int i = a; i < n; i++)
#define all(in) in.begin(), in.end()
int main() {
int n, w;
while (true) {
cin >> n >> w;
if (n == 0 && w == 0)
break;
vector<int> v(n);
rep(i, n) cin >> v[i];
int max_v = 0, K;
rep(i, n) max_v = max(max_v, v[i]);
map<int, int> interval;
for (int i = 0; i < n; i++) {
for (int k = 0; k <= 120; k++) {
if (k * w <= v[i] && v[i] < (k + 1) * w) {
if (max_v == v[i])
K = k;
interval[k]++;
}
}
}
double ans = 0;
int h = 0;
for (auto v : interval) {
int p = v.first, q = v.second;
h = max(h, q);
}
for (int i = K; i >= 0; i--) {
ans += ((double)i / K) * ((double)interval[K - i] / h);
// cout << ans << " " << interval[K - i] << endl;
}
ans += 0.01;
printf("%.17lf\n", ans);
}
return 0;
}
|
[["-", 0, 7, 8, 9, 0, 7, 15, 16, 12, 22], ["+", 0, 7, 8, 9, 0, 7, 15, 16, 12, 13]]
| 1
| 328
|
#include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<PII> VPII;
#define fst first
#define snd second
// #define Y first
// #define X second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) (x).begin(), (x).end()
#define RANGE(x, y, maxX, maxY) \
(0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define rep(i, N) for (int i = 0; i < (N); i++)
#define rep2(i, j, N, M) rep(i, N) rep(j, M)
#define rep3(i, j, k, N, M, L) rep(i, N) rep(j, M) rep(k, L)
#define REP(i, init, N) for (int i = (init); i < (N); i++)
template <typename T> inline T fromString(const string &s) {
T res;
ISS iss(s);
iss >> res;
return res;
};
template <typename T> inline string toString(const T &a) {
OSS oss;
oss << a;
return oss.str();
};
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, -1, 0, 1};
int N, W;
VI vs;
double solve() {
VI ts(10);
for (auto v : vs) {
ts[v / W]++;
}
int WW = 0;
{
rep(i, 10) {
if (ts[i]) {
WW = i;
}
}
}
int H = *max_element(ALL(ts));
double ans = 0.01;
rep(i, WW + 1) {
double c = 1. * (WW - i) / WW;
double v = 1. * ts[i] / H;
ans += c * v;
}
return ans;
}
int main(void) {
while (cin >> N >> W, N) {
vs = VI(N);
for (auto &v : vs)
cin >> v;
printf("%.9f\n", solve());
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef ostringstream OSS;
typedef istringstream ISS;
typedef long long LL;
typedef pair<int, int> PII;
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef vector<double> VD;
typedef vector<VD> VVD;
typedef vector<string> VS;
typedef vector<VS> VVS;
typedef vector<bool> VB;
typedef vector<VB> VVB;
typedef vector<PII> VPII;
#define fst first
#define snd second
// #define Y first
// #define X second
#define MP make_pair
#define PB push_back
#define EB emplace_back
#define ALL(x) (x).begin(), (x).end()
#define RANGE(x, y, maxX, maxY) \
(0 <= (x) && 0 <= (y) && (x) < (maxX) && (y) < (maxY))
#define DUMP(x) cerr << #x << " = " << (x) << endl
#define rep(i, N) for (int i = 0; i < (N); i++)
#define rep2(i, j, N, M) rep(i, N) rep(j, M)
#define rep3(i, j, k, N, M, L) rep(i, N) rep(j, M) rep(k, L)
#define REP(i, init, N) for (int i = (init); i < (N); i++)
template <typename T> inline T fromString(const string &s) {
T res;
ISS iss(s);
iss >> res;
return res;
};
template <typename T> inline string toString(const T &a) {
OSS oss;
oss << a;
return oss.str();
};
const int INF = 0x3f3f3f3f;
const LL INFL = 0x3f3f3f3f3f3f3f3fLL;
const double DINF = 0x3f3f3f3f;
const int DX[] = {1, 0, -1, 0}, DY[] = {0, -1, 0, 1};
int N, W;
VI vs;
double solve() {
VI ts(15);
for (auto v : vs) {
ts[v / W]++;
}
int WW = 0;
{
rep(i, 15) {
if (ts[i]) {
WW = i;
}
}
}
int H = *max_element(ALL(ts));
double ans = 0.01;
// cerr << " " << WW << " " << H << endl;
rep(i, WW + 1) {
double c = 1. * (WW - i) / WW;
double v = 1. * ts[i] / H;
// cerr << " " << c << " " << v << endl;
ans += c * v;
}
return ans;
}
int main(void) {
while (cin >> N >> W, N) {
vs = VI(N);
for (auto &v : vs)
cin >> v;
printf("%.9f\n", solve());
}
return 0;
}
|
[["-", 8, 9, 0, 43, 49, 50, 51, 4, 0, 13], ["+", 8, 9, 0, 43, 49, 50, 51, 4, 0, 13], ["-", 0, 9, 0, 42, 0, 2, 3, 4, 0, 13], ["+", 0, 9, 0, 42, 0, 2, 3, 4, 0, 13]]
| 1
| 485
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long int ll;
int main() {
while (true) {
int n, w;
cin >> n >> w;
if (n == 0)
break;
vector<int> hist(1000, 0);
for (int i = 0; i < n; i++) {
int p;
cin >> p;
p /= w;
hist[p]++;
}
int num = 0, t = 0;
rep(i, n) {
num = max(num, hist[i]);
if (hist[i] != 0)
t = i;
}
double ans = 0.01;
if (t == 0 or num == 0) {
cout << 0.01 << endl;
continue;
}
rep(i, n) { ans += ((double)hist[i] / num) * (1 - (double)i / t); }
printf("%.6lf\n", ans);
}
}
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <math.h>
#include <queue>
#include <set>
#include <stack>
#include <stdio.h>
#include <stdlib.h>
#include <string>
#include <utility>
#include <vector>
#define INF 1000000000
#define rep(i, n) for (int i = 0; i < n; i++)
using namespace std;
typedef long long int ll;
int main() {
while (true) {
int n, w;
cin >> n >> w;
if (n == 0)
break;
vector<int> hist(1000, 0);
for (int i = 0; i < n; i++) {
int p;
cin >> p;
p /= w;
hist[p]++;
}
int num = 0, t = 0;
rep(i, 1000) {
num = max(num, hist[i]);
if (hist[i] != 0)
t = i;
}
double ans = 0.01;
if (t == 0 or num == 0) {
cout << 0.01 << endl;
continue;
}
rep(i, 1000) { ans += ((double)hist[i] / num) * (1 - (double)i / t); }
printf("%.6lf\n", ans);
}
}
|
[["-", 0, 14, 49, 53, 54, 55, 0, 56, 39, 78], ["+", 8, 9, 0, 1, 0, 2, 3, 4, 0, 13], ["+", 0, 1, 0, 2, 3, 4, 0, 25, 0, 35]]
| 1
| 234
|
#include "bits/stdc++.h"
#include <unordered_map>
#pragma warning(disable : 4996)
using namespace std;
const int My_Inf = 2147483647;
const long long int My_LInf = 9223372036854775807;
struct action {
int ac;
int time;
};
int main() {
while (1) {
int n, w;
cin >> n >> w;
if (!n)
break;
vector<double> vs;
vector<int> nums(10);
int amax = 0;
int mheight = 0;
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
int bar = v / w;
amax = max(amax, bar);
nums[bar]++;
mheight = max(mheight, nums[bar]);
}
double ans = 0;
for (int i = 0; i <= amax; ++i) {
ans += double(nums[i] * (amax - i)) / amax;
}
ans /= mheight;
ans += 0.01;
cout << fixed << setprecision(10) << ans << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include <unordered_map>
#pragma warning(disable : 4996)
using namespace std;
const int My_Inf = 2147483647;
const long long int My_LInf = 9223372036854775807;
struct action {
int ac;
int time;
};
int main() {
while (1) {
int n, w;
cin >> n >> w;
if (!n)
break;
vector<double> vs;
vector<int> nums(11);
int amax = 0;
int mheight = 0;
for (int i = 0; i < n; ++i) {
int v;
cin >> v;
int bar = v / w;
amax = max(amax, bar);
nums[bar]++;
mheight = max(mheight, nums[bar]);
}
double ans = 0;
for (int i = 0; i <= amax; ++i) {
ans += double(nums[i] * (amax - i)) / amax;
}
ans /= mheight;
ans += 0.01;
cout << fixed << setprecision(10) << ans << endl;
}
return 0;
}
|
[["-", 8, 9, 0, 43, 49, 50, 51, 4, 0, 13], ["+", 8, 9, 0, 43, 49, 50, 51, 4, 0, 13]]
| 1
| 212
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) (v).begin(), (v).end()
#define INF 1e9
using namespace std;
int main() {
int n, w;
while (cin >> n >> w and n + w) {
vector<int> data(n);
REP(i, n) { cin >> data[i]; }
sort(ALL(data));
int maxim = data[n - 1];
int bars = (maxim / w);
if ((maxim + 1) % w)
bars++;
int count[bars] = {0};
int tmp = 0;
int maxsize = 0;
REP(i, n) {
if (data[i] < w * (tmp + 1))
count[tmp]++;
else {
tmp++;
i--;
}
maxsize = max(maxsize, count[tmp]);
}
double res = 0.01;
REP(i, bars)
res += (double)(bars - i - 1) * count[i] / ((bars - 1) * maxsize);
cout << setprecision(15) << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
#define ALL(v) (v).begin(), (v).end()
#define INF 1e9
using namespace std;
int main() {
int n, w;
while (cin >> n >> w and n + w) {
vector<int> data(n);
REP(i, n) { cin >> data[i]; }
sort(ALL(data));
int maxim = data[n - 1];
int bars = ((maxim + 1) / w);
if ((maxim + 1) % w)
bars++;
int count[bars] = {0};
int tmp = 0;
int maxsize = 0;
REP(i, n) {
if (data[i] < w * (tmp + 1))
count[tmp]++;
else {
tmp++;
i--;
}
maxsize = max(maxsize, count[tmp]);
}
double res = 0.01;
REP(i, bars)
res += (double)(bars - i - 1) * count[i] / ((bars - 1) * maxsize);
cout << setprecision(15) << res << endl;
}
return 0;
}
|
[["+", 49, 50, 51, 23, 0, 16, 31, 23, 0, 24], ["+", 51, 23, 0, 16, 31, 23, 0, 16, 17, 72], ["+", 51, 23, 0, 16, 31, 23, 0, 16, 12, 13], ["+", 49, 50, 51, 23, 0, 16, 31, 23, 0, 25]]
| 1
| 235
|
#include <iostream>
using namespace std;
int main() {
for (int h, w; cin >> h >> w;) {
int a[21] = {}, b[21] = {}, r = 0;
for (int i = 0, t; i < h && cin >> t; i++)
a[t]++;
for (int i = 0, t; i < w && cin >> t; i++)
b[t]++;
for (int i = 0; i < 21; i++) {
int t = min(a[i], b[i]);
r += t * i;
a[i] -= t;
b[i] -= t;
}
for (int i = 0; i < 21; i++)
r += a[i] * i;
for (int i = 0; i < 21; i++)
r += b[i] * i;
cout << r << endl;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main() {
for (int h, w; cin >> h >> w, h;) {
int a[21] = {}, b[21] = {}, r = 0;
for (int i = 0, t; i < h && cin >> t; i++)
a[t]++;
for (int i = 0, t; i < w && cin >> t; i++)
b[t]++;
for (int i = 0; i < 21; i++) {
int t = min(a[i], b[i]);
r += t * i;
a[i] -= t;
b[i] -= t;
}
for (int i = 0; i < 21; i++)
r += a[i] * i;
for (int i = 0; i < 21; i++)
r += b[i] * i;
cout << r << endl;
}
return 0;
}
|
[["+", 0, 14, 8, 9, 0, 7, 15, 34, 0, 21], ["+", 0, 14, 8, 9, 0, 7, 15, 34, 12, 22]]
| 1
| 210
|
while True:
w,d = [int(i) for i in input().split()]
if w == 0:
break
h = [int(i) for i in input().split()]
h_ = [int(i) for i in input().split()]
h = sorted(h)
h_ = sorted(h_)
hdic = {}
h_dic = {}
for i in h:
if i in hdic.keys():
hdic[i]+= 1
else:
hdic[i] = 1
for i in h_:
if i in h_dic.keys():
h_dic[i]+= 1
else:
h_dic[i] = 1
ans = sum(h)+ sum(h_)
for num in hdic.keys():
if num in h_dic.keys():
ans -= num*min(hdic[i],h_dic[i])
print(ans)
|
while True:
w,d = [int(i) for i in input().split()]
if w == 0:
break
h = [int(i) for i in input().split()]
h_ = [int(i) for i in input().split()]
h = sorted(h)
h_ = sorted(h_)
hdic = {}
h_dic = {}
for i in h:
if i in hdic.keys():
hdic[i]+= 1
else:
hdic[i] = 1
for i in h_:
if i in h_dic.keys():
h_dic[i]+= 1
else:
h_dic[i] = 1
ans = sum(h)+ sum(h_)
for num in hdic.keys():
if num in h_dic.keys():
ans -= num*min(hdic[num],h_dic[num])
print(ans)
|
[["-", 12, 657, 12, 652, 3, 4, 0, 206, 206, 22], ["+", 12, 657, 12, 652, 3, 4, 0, 206, 206, 22]]
| 5
| 190
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
struct before_main {
before_main() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} before_main;
#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)
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;
string initial, target;
vector<pair<string, string>> subs;
int dodo() {
set<string> used;
queue<pair<string, int>> q;
q.emplace(initial, 0);
while (!q.empty()) {
string p;
int cost;
tie(p, cost) = q.front();
q.pop();
int n = p.size();
if (p == target) {
return cost;
}
rep(k, subs.size()) {
string np;
int pos = 0;
int m1 = subs[k].first.size();
if (n < m1) {
continue;
}
while (pos < n) {
int nxtpos = p.find_first_of(subs[k].first, pos);
if (nxtpos == string::npos) {
np += p.substr(pos);
break;
}
np += string(p.begin() + pos, p.begin() + nxtpos) + subs[k].second;
pos = nxtpos + m1;
}
if (np.size() > target.size()) {
continue;
}
if (used.count(np)) {
continue;
}
used.insert(np);
q.emplace(np, cost + 1);
}
}
return -1;
}
int main() {
for (int N; cin >> N && N;) {
subs.clear();
rep(i, N) {
string a, b;
cin >> a >> b;
subs.emplace_back(a, b);
}
cin >> initial >> target;
cout << dodo() << endl;
}
return 0;
}
|
#include <algorithm>
#include <array>
#include <assert.h>
#include <bitset>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
using namespace std;
struct before_main {
before_main() {
cin.tie(0);
ios::sync_with_stdio(false);
}
} before_main;
#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)
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;
string initial, target;
vector<pair<string, string>> subs;
int dodo() {
set<string> used;
queue<pair<string, int>> q;
q.emplace(initial, 0);
while (!q.empty()) {
string p;
int cost;
tie(p, cost) = q.front();
q.pop();
int n = p.size();
if (p == target) {
return cost;
}
rep(k, subs.size()) {
string np;
int pos = 0;
int m1 = subs[k].first.size();
if (n < m1) {
continue;
}
while (pos < n) {
int nxtpos = p.find(subs[k].first, pos);
if (nxtpos == string::npos) {
np += p.substr(pos);
break;
}
np += string(p.begin() + pos, p.begin() + nxtpos) + subs[k].second;
pos = nxtpos + m1;
}
if (np.size() > target.size()) {
continue;
}
if (used.count(np)) {
continue;
}
used.insert(np);
q.emplace(np, cost + 1);
}
}
return -1;
}
int main() {
for (int N; cin >> N && N;) {
subs.clear();
rep(i, N) {
string a, b;
cin >> a >> b;
subs.emplace_back(a, b);
}
cin >> initial >> target;
cout << dodo() << endl;
}
return 0;
}
|
[["-", 0, 42, 0, 2, 63, 2, 63, 118, 119, 120], ["+", 0, 42, 0, 2, 63, 2, 63, 118, 119, 120]]
| 1
| 540
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> v;
bool isPrime(int n) {
for (int i = 0; i < v.size() && v[i] * v[i] <= n; i++) {
if (n % v[i] == 0)
return false;
}
return true;
}
int main() {
v.push_back(2);
v.push_back(3);
for (int i = 5; i * i <= 10000; i += 2) {
if (isPrime(i)) {
v.push_back(i);
}
}
int sum[v.size() + 1];
fill(sum, sum + v.size() + 1, 0);
for (int i = 1; i < v.size() + 1; i++) {
sum[i] = sum[i - 1] + v[i - 1];
}
while (true) {
int n;
cin >> n;
if (n == 0)
return 0;
int count = 0;
for (int i = 1; i < v.size() + 1; i++) {
if (v[i - 1] > n)
break;
for (int j = 0; j <= i; j++) {
if (sum[i] - sum[j] == n) {
count++;
}
}
}
cout << count << endl;
}
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
vector<int> v;
bool isPrime(int n) {
for (int i = 0; i < v.size() && v[i] * v[i] <= n; i++) {
if (n % v[i] == 0)
return false;
}
return true;
}
int main() {
v.push_back(2);
v.push_back(3);
for (int i = 5; i <= 10000; i += 2) {
if (isPrime(i)) {
v.push_back(i);
}
}
int sum[v.size() + 1];
fill(sum, sum + v.size() + 1, 0);
for (int i = 1; i < v.size() + 1; i++) {
sum[i] = sum[i - 1] + v[i - 1];
}
while (true) {
int n;
cin >> n;
if (n == 0)
return 0;
int count = 0;
for (int i = 1; i < v.size() + 1; i++) {
if (v[i - 1] > n)
break;
for (int j = 0; j <= i; j++) {
if (sum[i] - sum[j] == n) {
count++;
}
}
}
cout << count << endl;
}
}
|
[["-", 8, 9, 0, 7, 15, 16, 31, 16, 17, 48], ["-", 8, 9, 0, 7, 15, 16, 31, 16, 12, 22]]
| 1
| 301
|
primes = [0, 0] + [1]*996
for i in range(2, 32):
if primes[i]:
for j in range(i*i, 998, i):
primes[j] = 0
while True:
n = int(input())
if n == 0:
break
m = n
while not primes[m]:
m -= 1
pnum = [i for i in range(m+1) if primes[i]]
ans = 0
for i in range(len(pnum)):
tmp = 0
for j in range(i, len(pnum)):
tmp += pnum[j]
if tmp == n:
ans += 1
break
if tmp > n:
break
print(ans)
|
primes = [0, 0] + [1]*9999
for i in range(2, 101):
if primes[i]:
for j in range(i*i, 10001, i):
primes[j] = 0
while True:
n = int(input())
if n == 0:
break
m = n
while not primes[m]:
m -= 1
pnum = [i for i in range(m+1) if primes[i]]
ans = 0
for i in range(len(pnum)):
tmp = 0
for j in range(i, len(pnum)):
tmp += pnum[j]
if tmp == n:
ans += 1
break
if tmp > n:
break
print(ans)
|
[["-", 0, 1, 0, 662, 12, 657, 12, 657, 12, 612], ["+", 0, 1, 0, 662, 12, 657, 12, 657, 12, 612], ["-", 0, 656, 0, 7, 12, 652, 3, 4, 0, 612], ["+", 0, 656, 0, 7, 12, 652, 3, 4, 0, 612], ["-", 64, 196, 0, 7, 12, 652, 3, 4, 0, 612], ["+", 64, 196, 0, 7, 12, 652, 3, 4, 0, 612]]
| 5
| 153
|
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
double R;
int n, a[100];
struct ST {
double w, a, h;
ST() {}
ST(double w, double a, double h) : w(w), a(a), h(h) {}
};
ST combine(const ST &p, const ST &q) {
const double a = p.h / (p.h + q.h);
double l = min(-a - p.a, (1 - a) - q.a);
double r = max((1 - a) + (q.w - q.a), -a + (p.w - p.a));
return ST(r - l, -l, p.h + q.h);
}
vector<ST> calc(int u) {
if ((u & (u - 1)) == 0) {
int ix = -1;
rep(i, n) if (u & (1 << i)) ix = i;
return vector<ST>(1, ST(0, 0, a[ix]));
}
vector<ST> ans;
rep(b, 1 << n) if ((u & b) == b && b != u && b != 0) {
vector<ST> x = calc(b);
vector<ST> y = calc(u - b);
rep(i, x.size()) rep(j, y.size()) { ans.push_back(combine(x[i], y[j])); }
}
return ans;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%lf%d", &R, &n);
rep(i, n) scanf("%d", a + i);
vector<ST> ws = calc((1 << n) - 1);
double ans = -1;
rep(i, ws.size()) if (ws[i].w < R) ans = max(ans, ws[i].w);
if (ans < 0)
printf("%d\n", -1);
else
printf("%.12f\n", ans);
}
return 0;
}
|
#include <algorithm>
#include <stdio.h>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
double R;
int n, a[100];
struct ST {
double w, a, h;
ST() {}
ST(double w, double a, double h) : w(w), a(a), h(h) {}
};
ST combine(const ST &p, const ST &q) {
const double a = q.h / (p.h + q.h);
double l = min(-a - p.a, (1 - a) - q.a);
double r = max((1 - a) + (q.w - q.a), -a + (p.w - p.a));
return ST(r - l, -l, p.h + q.h);
}
vector<ST> calc(int u) {
if ((u & (u - 1)) == 0) {
int ix = -1;
rep(i, n) if (u & (1 << i)) ix = i;
return vector<ST>(1, ST(0, 0, a[ix]));
}
vector<ST> ans;
rep(b, 1 << n) if ((u & b) == b && b != u && b != 0) {
vector<ST> x = calc(b);
vector<ST> y = calc(u - b);
rep(i, x.size()) rep(j, y.size()) { ans.push_back(combine(x[i], y[j])); }
}
return ans;
}
int main() {
int T;
scanf("%d", &T);
while (T--) {
scanf("%lf%d", &R, &n);
rep(i, n) scanf("%d", a + i);
vector<ST> ws = calc((1 << n) - 1);
double ans = -1;
rep(i, ws.size()) if (ws[i].w < R) ans = max(ans, ws[i].w);
if (ans < 0)
printf("%d\n", -1);
else
printf("%.12f\n", ans);
}
return 0;
}
|
[["-", 0, 43, 49, 50, 51, 16, 31, 118, 28, 22], ["+", 0, 43, 49, 50, 51, 16, 31, 118, 28, 22]]
| 1
| 507
|
// 2006年アジアA How I Wonder What You Are!
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define EPS 1e-9
typedef struct {
double x, y, z;
} Position;
double dot(Position a, Position b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
double dist(Position a) { return sqrt(a.x * a.x + a.y * a.y + a.z * a.z); }
double getTheta(Position a, Position b) {
return acos(dot(a, b) / (dist(a) * dist(b)));
}
int main() {
int i, j;
int n, m, ans;
double phi[50];
Position s[500], t[50];
while (scanf("%d", &n) && n) {
for (i = 0; i < n; i++)
scanf("%lf %lf %lf", &s[i].x, &s[i].y, &s[i].z);
scanf("%d", &m);
for (i = 0; i < m; i++)
scanf("%lf %lf %lf %lf", &t[i].x, &t[i].y, &t[i].z, &phi[i]);
ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < n; j++) {
if (getTheta(s[i], t[j]) <= phi[j] + EPS) {
ans++;
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
// 2006年アジアA How I Wonder What You Are!
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define EPS 1e-9
typedef struct {
double x, y, z;
} Position;
double dot(Position a, Position b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
double dist(Position a) { return sqrt(a.x * a.x + a.y * a.y + a.z * a.z); }
double getTheta(Position a, Position b) {
return acos(dot(a, b) / (dist(a) * dist(b)));
}
int main() {
int i, j;
int n, m, ans;
double phi[50];
Position s[500], t[50];
while (scanf("%d", &n) && n) {
for (i = 0; i < n; i++)
scanf("%lf %lf %lf", &s[i].x, &s[i].y, &s[i].z);
scanf("%d", &m);
for (i = 0; i < m; i++)
scanf("%lf %lf %lf %lf", &t[i].x, &t[i].y, &t[i].z, &phi[i]);
ans = 0;
for (i = 0; i < n; i++) {
for (j = 0; j < m; j++) {
if (getTheta(s[i], t[j]) <= phi[j] + EPS) {
ans++;
break;
}
}
}
printf("%d\n", ans);
}
return 0;
}
|
[["-", 0, 7, 8, 9, 0, 7, 15, 16, 12, 22], ["+", 0, 7, 8, 9, 0, 7, 15, 16, 12, 22]]
| 0
| 360
|
#include <bits/stdc++.h>
using namespace std;
class Point3d {
public:
double x, y, z;
Point3d(double a = 0, double b = 0, double c = 0) : x(a), y(b), z(c) {}
};
double norm(Point3d a, Point3d b) {
return pow((a.x - b.x), 2) + pow((a.y - b.y), 2) + pow((a.z - b.z), 2);
}
double abs(Point3d a, Point3d b) { return sqrt(norm(a, b)); }
int main() {
vector<Point3d> v;
int n, m;
int ans;
double eps = 0.000000001;
bool st[1000];
while (1) {
cin >> n;
if (n == 0)
break;
double a, b, c, d;
for (int i = 0; i < 1000; i++)
st[i] = false;
v.clear();
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
v.push_back(Point3d(a, b, c));
}
cin >> m;
Point3d origin(0.0, 0.0, 0.0);
for (int i = 0; i < m; i++) {
cin >> a >> b >> c >> d;
Point3d p3(a, b, c);
double x, y, z, r;
for (int j = 0; j < n; j++) {
x = abs(v[j], origin);
y = abs(p3, origin);
z = abs(v[j], p3);
// printf("%.10f %.10f %.10f\n",x,y,z);
r = acos((x * x + y * y - z * z) / (x * y * 2));
// printf("%.10f %.10f\n",r,d);
if ((r - d) < eps)
st[i] = true;
}
}
ans = 0;
for (int i = 0; i < n; i++)
if (st[i])
ans++;
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Point3d {
public:
double x, y, z;
Point3d(double a = 0, double b = 0, double c = 0) : x(a), y(b), z(c) {}
};
double norm(Point3d a, Point3d b) {
return pow((a.x - b.x), 2) + pow((a.y - b.y), 2) + pow((a.z - b.z), 2);
}
double abs(Point3d a, Point3d b) { return sqrt(norm(a, b)); }
int main() {
vector<Point3d> v;
int n, m;
int ans;
double eps = 0.000000001;
bool st[501];
while (1) {
cin >> n;
if (n == 0)
break;
double a, b, c, d;
for (int i = 0; i < 501; i++)
st[i] = false;
v.clear();
for (int i = 0; i < n; i++) {
cin >> a >> b >> c;
v.push_back(Point3d(a, b, c));
}
cin >> m;
Point3d origin(0.0, 0.0, 0.0);
for (int i = 0; i < m; i++) {
cin >> a >> b >> c >> d;
Point3d p3(a, b, c);
double x, y, z, r;
for (int j = 0; j < n; j++) {
x = abs(v[j], origin);
y = abs(p3, origin);
z = abs(v[j], p3);
// printf("%.10f %.10f %.10f\n",x,y,z);
r = acos((x * x + y * y - z * z) / (x * y * 2));
// printf("%.10f %.10f\n",r,d);
if ((r - d) < eps)
st[j] = true;
}
}
ans = 0;
for (int i = 0; i < n; i++)
if (st[i])
ans++;
cout << ans << endl;
}
return 0;
}
|
[["-", 0, 14, 8, 9, 0, 43, 49, 80, 81, 13], ["+", 0, 14, 8, 9, 0, 43, 49, 80, 81, 13], ["-", 0, 52, 8, 9, 0, 7, 15, 16, 12, 13], ["+", 0, 52, 8, 9, 0, 7, 15, 16, 12, 13], ["-", 64, 1, 0, 11, 31, 69, 341, 342, 0, 22], ["+", 64, 1, 0, 11, 31, 69, 341, 342, 0, 22]]
| 1
| 447
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<P> vp;
#define rep(i, a, n) for (ll i = (a); i < (n); i++)
#define per(i, a, n) for (ll i = (a); i > (n); i--)
#define lep(i, a, n) for (ll i = (a); i <= (n); i++)
#define pel(i, a, n) for (ll i = (a); i >= (n); i--)
#define clr(a, b) memset((a), (b), sizeof(a))
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define sz size()
#define print(X) cout << (X) << endl
static const int INF = 1e+9 + 7;
ll n, m, l;
string s, t;
int d[200010], dp[1010][1010];
double w[1000], v[1000];
double box[200010];
char field[200][200];
double dot(double a, double b, double c, double x, double y, double z) {
return a * x + b * y + c * z;
}
int main() {
double x[500], y[500], z[500];
while (1) {
cin >> n;
if (!n)
break;
ll ans = 0;
clr(d, 0);
rep(i, 0, n) cin >> x[i] >> y[i] >> z[i];
cin >> m;
rep(i, 0, m) {
double a, b, c, r;
cin >> a >> b >> c >> r;
double abs1 = sqrt(dot(a, b, c, a, b, c));
rep(j, 0, n) {
double abs2 = sqrt(dot(x[j], y[j], z[j], x[j], y[j], z[j]));
double Cos = dot(a, b, c, x[j], y[j], z[j]) / abs1 / abs2;
double q = acos(Cos);
// cout << "Acos : " << q << endl;
if (q < r + 0.00000001)
d[i]++;
}
}
rep(i, 0, n) if (d[i]) ans++;
print(ans);
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cmath>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <exception>
#include <functional>
#include <iomanip>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <tuple>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<ll, ll> P;
typedef vector<int> vi;
typedef vector<ll> vll;
typedef vector<char> vc;
typedef vector<string> vs;
typedef vector<P> vp;
#define rep(i, a, n) for (ll i = (a); i < (n); i++)
#define per(i, a, n) for (ll i = (a); i > (n); i--)
#define lep(i, a, n) for (ll i = (a); i <= (n); i++)
#define pel(i, a, n) for (ll i = (a); i >= (n); i--)
#define clr(a, b) memset((a), (b), sizeof(a))
#define pb push_back
#define mp make_pair
#define all(c) (c).begin(), (c).end()
#define sz size()
#define print(X) cout << (X) << endl
static const int INF = 1e+9 + 7;
ll n, m, l;
string s, t;
int d[200010], dp[1010][1010];
double w[1000], v[1000];
double box[200010];
char field[200][200];
double dot(double a, double b, double c, double x, double y, double z) {
return a * x + b * y + c * z;
}
int main() {
double x[500], y[500], z[500];
while (1) {
cin >> n;
if (!n)
break;
ll ans = 0;
clr(d, 0);
rep(i, 0, n) cin >> x[i] >> y[i] >> z[i];
cin >> m;
rep(i, 0, m) {
double a, b, c, r;
cin >> a >> b >> c >> r;
double abs1 = sqrt(dot(a, b, c, a, b, c));
rep(j, 0, n) {
double abs2 = sqrt(dot(x[j], y[j], z[j], x[j], y[j], z[j]));
double Cos = dot(a, b, c, x[j], y[j], z[j]) / abs1 / abs2;
double q = acos(Cos);
if (q < r + 0.00000001)
d[j]++;
}
}
rep(i, 0, n) if (d[i]) ans++;
print(ans);
}
return 0;
}
|
[["-", 64, 1, 0, 27, 28, 69, 341, 342, 0, 22], ["+", 64, 1, 0, 27, 28, 69, 341, 342, 0, 22]]
| 1
| 524
|
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
class P3 {
public:
double x, y, z;
P3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
P3(const P3 &p) : x(p.x), y(p.y), z(p.z) {}
void set(const P3 &p) { x = p.x, y = p.y, z = p.z; }
void set(double px, double py, double pz) { x = px, y = py, z = pz; }
P3 operator+(const P3 &p) const { return P3(x + p.x, y + p.y, z + p.z); }
P3 operator-(const P3 &p) const { return P3(x - p.x, y - p.y, z - p.z); }
P3 operator*(double p) const { return P3(x * p, y * p, z * p); }
void add(const P3 &p) { x += p.x, y += p.y, z += p.z; }
void sub(const P3 &p) { x -= p.x, y -= p.y, z -= p.z; }
void scale(double s) { x *= s, y *= s, z *= s; }
double dot(const P3 &p) const { return x * p.x + y * p.y + z * p.z; }
double squaredLength() const { return x * x + y * y + z * z; }
double length() const { return sqrt(squaredLength()); }
double normalize() {
double L = length();
if (L > 0)
scale(1.0 / L);
return L;
}
};
int main() {
int N;
while (cin >> N && N) {
P3 pos(0, 0, 0), dir;
cin >> dir.x >> dir.y >> dir.z;
dir.normalize();
vector<pair<P3, double>> vp(N);
for (int i = 0; i < N; i++) {
cin >> vp[i].first.x >> vp[i].first.y >> vp[i].first.z >> vp[i].second;
}
while (true) {
bool end = true;
double nearest = 1e12;
P3 npos, ndir;
for (int i = 0; i < N; i++) {
P3 p(vp[i].first);
p.sub(pos);
double l = dir.dot(p);
p.sub(dir * l);
double dist = p.length();
if (dist > vp[i].second - 1e-8)
continue;
double sub = sqrt(vp[i].second * vp[i].second - dist * dist);
if (l - sub > 0 && nearest > l - sub) {
npos.set(pos);
npos.add(dir * (l - sub));
ndir.set(dir);
ndir.scale(-1);
P3 ref(npos - vp[i].first);
ref.normalize();
P3 add(ndir);
ref.scale(ndir.dot(ref));
add.sub(ref);
add.scale(-2.0);
ndir.add(add);
end = false;
}
}
if (end)
break;
pos.set(npos);
dir.set(ndir);
}
printf("%.8lf %.8lf %.8lf\n", pos.x, pos.y, pos.z);
}
}
|
#include <cmath>
#include <cstdio>
#include <iostream>
#include <vector>
using namespace std;
class P3 {
public:
double x, y, z;
P3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {}
P3(const P3 &p) : x(p.x), y(p.y), z(p.z) {}
void set(const P3 &p) { x = p.x, y = p.y, z = p.z; }
void set(double px, double py, double pz) { x = px, y = py, z = pz; }
P3 operator+(const P3 &p) const { return P3(x + p.x, y + p.y, z + p.z); }
P3 operator-(const P3 &p) const { return P3(x - p.x, y - p.y, z - p.z); }
P3 operator*(double p) const { return P3(x * p, y * p, z * p); }
void add(const P3 &p) { x += p.x, y += p.y, z += p.z; }
void sub(const P3 &p) { x -= p.x, y -= p.y, z -= p.z; }
void scale(double s) { x *= s, y *= s, z *= s; }
double dot(const P3 &p) const { return x * p.x + y * p.y + z * p.z; }
double squaredLength() const { return x * x + y * y + z * z; }
double length() const { return sqrt(squaredLength()); }
double normalize() {
double L = length();
if (L > 0)
scale(1.0 / L);
return L;
}
};
int main() {
int N;
while (cin >> N && N) {
P3 pos(0, 0, 0), dir;
cin >> dir.x >> dir.y >> dir.z;
dir.normalize();
vector<pair<P3, double>> vp(N);
for (int i = 0; i < N; i++) {
cin >> vp[i].first.x >> vp[i].first.y >> vp[i].first.z >> vp[i].second;
}
while (true) {
bool end = true;
double nearest = 1e12;
P3 npos, ndir;
for (int i = 0; i < N; i++) {
P3 p(vp[i].first);
p.sub(pos);
double l = dir.dot(p);
p.sub(dir * l);
double dist = p.length();
if (dist > vp[i].second - 1e-8)
continue;
double sub = sqrt(vp[i].second * vp[i].second - dist * dist);
if (l - sub > 0 && nearest > l - sub) {
nearest = l - sub;
npos.set(pos);
npos.add(dir * (l - sub));
ndir.set(dir);
ndir.scale(-1);
P3 ref(npos - vp[i].first);
ref.normalize();
P3 add(ndir);
ref.scale(ndir.dot(ref));
add.sub(ref);
add.scale(-2.0);
ndir.add(add);
end = false;
}
}
if (end)
break;
pos.set(npos);
dir.set(ndir);
}
printf("%.8lf %.8lf %.8lf\n", pos.x, pos.y, pos.z);
}
}
|
[["+", 0, 57, 64, 9, 0, 1, 0, 11, 31, 22], ["+", 0, 57, 64, 9, 0, 1, 0, 11, 17, 32], ["+", 64, 9, 0, 1, 0, 11, 12, 16, 31, 22], ["+", 64, 9, 0, 1, 0, 11, 12, 16, 17, 33], ["+", 64, 9, 0, 1, 0, 11, 12, 16, 12, 22], ["+", 8, 9, 0, 57, 64, 9, 0, 1, 0, 35]]
| 1
| 799
|
#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);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int h, w;
char field[31][31];
string ord;
int sy, sx;
class Dice {
public:
char top;
char bottom;
char north;
char south;
char east;
char west;
Dice() {
top = 'r';
bottom = 'c';
north = 'g';
south = 'm';
east = 'b';
west = 'y';
}
};
class Sit {
public:
Dice d;
int x, y;
int dst;
};
const int dy[] = {-1, 0, 0, 1};
const int dx[] = {0, -1, 1, 0};
int main() {
map<char, int> mci;
mci['r'] = 0;
mci['c'] = 1;
mci['g'] = 2;
mci['m'] = 3;
mci['b'] = 4;
mci['y'] = 5;
while (cin >> w >> h && !(w == 0 && h == 0)) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> field[i][j];
if (field[i][j] == '#') {
sy = i;
sx = j;
field[i][j] = 'w';
}
}
}
cin >> ord;
queue<Sit> *prv = new queue<Sit>();
queue<Sit> *nxt = new queue<Sit>();
Sit sa;
sa.d = Dice();
sa.x = sx;
sa.y = sy;
sa.dst = 0;
prv->push(sa);
bool d[6][6][6][31][31];
memset(d, 0, sizeof(d));
bool ok = false;
int cnt = 0;
while (prv->size()) {
while (prv->size()) {
Sit st = prv->front();
prv->pop();
d[st.dst][mci[st.d.top]][mci[st.d.north]][st.y][st.x] = true;
int ndist = st.dst;
if (ord[st.dst] == st.d.top && field[st.y][st.x] == st.d.top) {
ndist++;
if (ndist == ord.size()) {
ok = true;
break;
}
}
// ツ四ツ陛サツ古シツづ鳴嘉アツ転ツ暗堋督ョ
for (int i = 0; i < 4; i++) {
int ny = st.y + dy[i];
int nx = st.x + dx[i];
if (!(ny >= 0 && nx >= 0 && ny < h && nx < w) || field[ny][nx] == 'k')
continue;
// north
Dice nd = st.d;
if (i == 0) {
char tmp = nd.top;
nd.top = nd.south;
nd.south = nd.bottom;
nd.bottom = nd.north;
nd.north = tmp;
} else if (i == 2) {
char tmp = nd.top;
nd.top = nd.west;
nd.west = nd.bottom;
nd.bottom = nd.east;
nd.east = tmp;
} else if (i == 1) {
char tmp = nd.top;
nd.top = nd.east;
nd.east = nd.bottom;
nd.bottom = nd.west;
nd.west = tmp;
} else {
char tmp = nd.top;
nd.top = nd.north;
nd.north = nd.bottom;
nd.bottom = nd.south;
nd.south = tmp;
}
// ツ篠淞づ個湘ェツ渉環つェツづ慊つセツ津環嘉淞催渉づ敖づづ按つ「
if (!d[ndist][mci[nd.top]][mci[nd.north]][ny][nx]) {
if (field[ny][nx] == 'w') {
} else {
if (nd.top == ord[ndist] && field[ny][nx] == nd.top) {
}
// ツ篠淞づ個マツスツつェツ色ツ個篠づ個湘ェツ債づ債、ordツづ個色ツづトツッツプツづ個色ツつェツ督ッツつカツづ可づ按づァツづ按つッツづェツづ篠津環嘉敖つキツづゥツつアツづつェツづつォツづ按つ「
else
continue;
}
d[ndist][mci[nd.top]][mci[nd.north]][ny][nx] = true;
Sit ns;
ns.d = nd;
ns.dst = ndist;
ns.x = nx;
ns.y = ny;
nxt->push(ns);
}
}
}
if (ok)
break;
cnt++;
swap(prv, nxt);
}
delete prv;
delete nxt;
if (ok)
cout << cnt << endl;
else
cout << "unreachable" << 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);
void fast_stream() { std::ios_base::sync_with_stdio(0); }
//#define RED_FILE
#ifdef RED_FILE
ifstream ifs("input.txt");
ofstream ofs("output.txt");
#define cin ifs
#define cout ofs
#endif
int h, w;
char field[31][31];
string ord;
int sy, sx;
class Dice {
public:
char top;
char bottom;
char north;
char south;
char east;
char west;
Dice() {
top = 'r';
bottom = 'c';
north = 'g';
south = 'm';
east = 'b';
west = 'y';
}
};
class Sit {
public:
Dice d;
int x, y;
int dst;
};
const int dy[] = {-1, 0, 0, 1};
const int dx[] = {0, -1, 1, 0};
int main() {
map<char, int> mci;
mci['r'] = 0;
mci['c'] = 1;
mci['g'] = 2;
mci['m'] = 3;
mci['b'] = 4;
mci['y'] = 5;
while (cin >> w >> h && !(w == 0 && h == 0)) {
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
cin >> field[i][j];
if (field[i][j] == '#') {
sy = i;
sx = j;
field[i][j] = 'w';
}
}
}
cin >> ord;
queue<Sit> *prv = new queue<Sit>();
queue<Sit> *nxt = new queue<Sit>();
Sit sa;
sa.d = Dice();
sa.x = sx;
sa.y = sy;
sa.dst = 0;
prv->push(sa);
bool d[6][6][6][31][31];
memset(d, 0, sizeof(d));
bool ok = false;
int cnt = 0;
while (prv->size()) {
while (prv->size()) {
Sit st = prv->front();
prv->pop();
d[st.dst][mci[st.d.top]][mci[st.d.north]][st.y][st.x] = true;
int ndist = st.dst;
if (ord[st.dst] == st.d.top && field[st.y][st.x] == st.d.top) {
ndist++;
if (ndist == ord.size()) {
ok = true;
break;
}
}
// ツ四ツ陛サツ古シツづ鳴嘉アツ転ツ暗堋督ョ
for (int i = 0; i < 4; i++) {
int ny = st.y + dy[i];
int nx = st.x + dx[i];
if (!(ny >= 0 && nx >= 0 && ny < h && nx < w) || field[ny][nx] == 'k')
continue;
// north
Dice nd = st.d;
if (i == 0) {
char tmp = nd.top;
nd.top = nd.south;
nd.south = nd.bottom;
nd.bottom = nd.north;
nd.north = tmp;
} else if (i == 2) {
char tmp = nd.top;
nd.top = nd.west;
nd.west = nd.bottom;
nd.bottom = nd.east;
nd.east = tmp;
} else if (i == 1) {
char tmp = nd.top;
nd.top = nd.east;
nd.east = nd.bottom;
nd.bottom = nd.west;
nd.west = tmp;
} else {
char tmp = nd.top;
nd.top = nd.north;
nd.north = nd.bottom;
nd.bottom = nd.south;
nd.south = tmp;
}
// ツ篠淞づ個湘ェツ渉環つェツづ慊つセツ津環嘉淞催渉づ敖づづ按つ「
if (!d[ndist][mci[nd.top]][mci[nd.north]][ny][nx]) {
if (field[ny][nx] == 'w') {
} else {
if (nd.top == ord[ndist] && field[ny][nx] == nd.top) {
}
// ツ篠淞づ個マツスツつェツ色ツ個篠づ個湘ェツ債づ債、ordツづ個色ツづトツッツプツづ個色ツつェツ督ッツつカツづ可づ按づァツづ按つッツづェツづ篠津環嘉敖つキツづゥツつアツづつェツづつォツづ按つ「
else
continue;
}
d[ndist][mci[nd.top]][mci[nd.north]][ny][nx] = true;
Sit ns;
ns.d = nd;
ns.dst = ndist;
ns.x = nx;
ns.y = ny;
nxt->push(ns);
}
}
}
if (ok)
break;
cnt++;
swap(prv, nxt);
}
delete prv;
delete nxt;
if (ok)
cout << cnt << endl;
else
cout << "unreachable" << endl;
}
return 0;
}
|
[["-", 36, 36, 36, 36, 0, 30, 0, 58, 0, 148], ["-", 36, 36, 36, 36, 0, 30, 0, 58, 141, 22]]
| 1
| 1,130
|
/*
AOJ 1291
Title:Search of Concatenated Strings
@kankichi573
*/
#include <stdio.h>
#include <string.h>
int n, m;
char e[12][21];
int len[12];
char t[5001];
char flag[5001][4096];
void dump_flag(char flag[5001][4096], int len) {
int i, j;
for (i = 0; i < len; i++)
for (j = 0; j < 4096; j++)
if (flag[i][j])
printf("%d %d\n", i, j);
}
main() {
int l, ln, l_s, i, j, k, cnt, loop, mask, pat;
char buf[101];
while (scanf("%d %d", &n, &m) && (n || m)) {
memset(flag, 0, sizeof(flag));
for (i = 0; i < n; i++) {
scanf("%s", &e[i][0]);
len[i] = strlen(&e[i][0]);
}
t[0] = '\0';
for (i = 0; i < m; i++) {
scanf("%s", buf);
ln = strlen(buf);
if (buf[ln - 1] < ' ')
buf[ln - 1] = '\0';
strcat(t, buf);
}
l_s = strlen(t);
loop = 1 << n;
for (i = 0, cnt = 0; i < l_s; i++) {
for (j = 0; j < loop; j++) {
if (j && flag[i][j] == 0)
continue;
for (k = 0, mask = 1; k < n; k++, mask <<= 1) {
if (j & mask)
continue;
if (0 == strncmp(&e[k][0], &t[i], (l = len[k]))) {
pat = j | mask;
flag[i + l][pat] = 1;
}
}
}
}
for (i = 0, cnt = 0; i < l_s; i++)
cnt += flag[i][loop - 1];
printf("%d\n", cnt);
}
return (0);
}
|
/*
AOJ 1291
Title:Search of Concatenated Strings
@kankichi573
*/
#include <stdio.h>
#include <string.h>
int n, m;
char e[12][21];
int len[12];
char t[5001];
char flag[5001][4096];
void dump_flag(char flag[5001][4096], int len) {
int i, j;
for (i = 0; i < len; i++)
for (j = 0; j < 4096; j++)
if (flag[i][j])
printf("%d %d\n", i, j);
}
main() {
int l, ln, l_s, i, j, k, cnt, loop, mask, pat;
char buf[101];
while (scanf("%d %d", &n, &m) && (n || m)) {
memset(flag, 0, sizeof(flag));
for (i = 0; i < n; i++) {
scanf("%s", &e[i][0]);
len[i] = strlen(&e[i][0]);
}
t[0] = '\0';
for (i = 0; i < m; i++) {
scanf("%s", buf);
ln = strlen(buf);
if (buf[ln - 1] < ' ')
buf[ln - 1] = '\0';
strcat(t, buf);
}
l_s = strlen(t);
loop = 1 << n;
for (i = 0, cnt = 0; i < l_s; i++) {
for (j = 0; j < loop; j++) {
if (j && flag[i][j] == 0)
continue;
for (k = 0, mask = 1; k < n; k++, mask <<= 1) {
if (j & mask)
continue;
if (0 == strncmp(&e[k][0], &t[i], (l = len[k]))) {
pat = j | mask;
flag[i + l][pat] = 1;
}
}
}
}
for (i = 0, cnt = 0; i <= l_s; i++)
cnt += flag[i][loop - 1];
printf("%d\n", cnt);
}
return (0);
}
|
[["-", 0, 52, 8, 9, 0, 7, 15, 16, 17, 18], ["+", 0, 52, 8, 9, 0, 7, 15, 16, 17, 19]]
| 0
| 486
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve(int n, int m) {
vector<string> e(n);
string ts;
int concatenated_len = 0;
rep(i, 0, n) {
cin >> e[i];
concatenated_len += e[i].size();
}
rep(i, 0, m) {
string t;
cin >> t;
ts += t;
}
vector<int> sum_len(1 << n);
rep(i, 0, 1 << n) {
rep(j, 0, n) {
if (((i >> j) & 1) == 0)
continue;
sum_len[i] += e[j].size();
}
}
static bool p[5000][1 << 12];
fill_n((bool *)p, 5000 * (1 << 12), false);
vector<vector<int>> heads(ts.size());
rep(i, 0, ts.size()) p[i][0] = true;
rep(i, 0, ts.size()) {
rep(j, 0, n) {
if (i + e[j].size() > ts.size() or e[j] != ts.substr(i, e[j].size()))
continue;
p[i][1 << j] = true;
heads[i].push_back(j);
}
}
int ans = 0;
for (int i = ts.size() - 1; i >= 0; --i) {
rep(j, 1, 1 << n) {
if (p[i][j] or i + sum_len[j] >= ts.size())
continue;
for (int k : heads[i]) {
if (((j >> k) & 1) == 0)
continue;
int i2 = i + e[k].size();
if (p[i2][j & (~(1 << k))]) {
p[i][j] = true;
break;
}
}
}
if (p[i][(1 << n) - 1])
++ans;
}
cout << ans << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
for (;;) {
int n, m;
cin >> n >> m;
if (n == 0 and m == 0)
break;
solve(n, m);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, x, y) for (int i = (x); i < (y); ++i)
#define debug(x) #x << "=" << (x)
#ifdef DEBUG
#define _GLIBCXX_DEBUG
#define print(x) std::cerr << debug(x) << " (L:" << __LINE__ << ")" << std::endl
#else
#define print(x)
#endif
const int inf = 1e9;
const int64_t inf64 = 1e18;
const double eps = 1e-9;
template <typename T> ostream &operator<<(ostream &os, const vector<T> &vec) {
os << "[";
for (const auto &v : vec) {
os << v << ",";
}
os << "]";
return os;
}
void solve(int n, int m) {
vector<string> e(n);
string ts;
int concatenated_len = 0;
rep(i, 0, n) {
cin >> e[i];
concatenated_len += e[i].size();
}
rep(i, 0, m) {
string t;
cin >> t;
ts += t;
}
vector<int> sum_len(1 << n);
rep(i, 0, 1 << n) {
rep(j, 0, n) {
if (((i >> j) & 1) == 0)
continue;
sum_len[i] += e[j].size();
}
}
static bool p[5000][1 << 12];
fill_n((bool *)p, 5000 * (1 << 12), false);
vector<vector<int>> heads(ts.size());
rep(i, 0, ts.size()) p[i][0] = true;
rep(i, 0, ts.size()) {
rep(j, 0, n) {
if (i + e[j].size() > ts.size() or e[j] != ts.substr(i, e[j].size()))
continue;
p[i][1 << j] = true;
heads[i].push_back(j);
}
}
int ans = 0;
for (int i = ts.size() - 1; i >= 0; --i) {
rep(j, 1, 1 << n) {
if (p[i][j] or i + sum_len[j] > ts.size())
continue;
for (int k : heads[i]) {
if (((j >> k) & 1) == 0)
continue;
int i2 = i + e[k].size();
if (p[i2][j & (~(1 << k))]) {
p[i][j] = true;
break;
}
}
}
if (p[i][(1 << n) - 1])
++ans;
}
cout << ans << endl;
}
int main() {
std::cin.tie(0);
std::ios::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(10);
for (;;) {
int n, m;
cin >> n >> m;
if (n == 0 and m == 0)
break;
solve(n, m);
}
return 0;
}
|
[["-", 0, 57, 15, 339, 51, 16, 12, 16, 17, 20], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 17, 47]]
| 1
| 663
|
#include <bits/stdc++.h>
#define N 12
#define S 5005
#define M 1777771
using namespace std;
typedef unsigned long long ull;
bool dp[(1 << N)][S];
int n, m;
string s[N], t;
ull d1[N], d2[S], A[30];
int main() {
while (1) {
cin >> n >> m;
if (!n && !m)
break;
for (int i = 0; i < n; i++)
cin >> s[i];
t = "";
for (int i = 0; i < m; i++) {
string tmp;
cin >> tmp;
t += tmp;
}
for (int i = 0; i < n; i++) {
ull hash = s[i][0];
for (int j = 1; j < s[i].size(); j++)
hash = hash * M + s[i][j];
d1[i] = hash;
}
d2[0] = t[0];
for (int i = 1; i < t.size(); i++)
d2[i] = d2[i - 1] * M + t[i];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < t.size(); i++)
dp[0][i] = true;
A[0] = 1;
for (int i = 1; i < 30; i++)
A[i] = A[i - 1] * M;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < t.size(); j++) {
if (!dp[i][j])
continue;
for (int k = 0; k < n; k++) {
if (i & (1 << k))
continue;
int slen = s[k].size();
if (t.size() < j + slen)
continue;
ull x = d2[j + A[slen] - 1];
if (j)
x -= d2[j - 1] * A[slen];
if (d1[k] != x)
continue;
dp[i | (1 << k)][j + slen] = true;
}
}
}
int ans = 0;
for (int i = 0; i <= t.size(); i++)
ans += dp[(1 << n) - 1][i];
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define N 12
#define S 5005
#define M 1777771
using namespace std;
typedef unsigned long long ull;
bool dp[(1 << N)][S];
int n, m;
string s[N], t;
ull d1[N], d2[S], A[30];
int main() {
while (1) {
cin >> n >> m;
if (!n && !m)
break;
for (int i = 0; i < n; i++)
cin >> s[i];
t = "";
for (int i = 0; i < m; i++) {
string tmp;
cin >> tmp;
t += tmp;
}
for (int i = 0; i < n; i++) {
ull hash = s[i][0];
for (int j = 1; j < s[i].size(); j++)
hash = hash * M + s[i][j];
d1[i] = hash;
}
d2[0] = t[0];
for (int i = 1; i < t.size(); i++)
d2[i] = d2[i - 1] * M + t[i];
memset(dp, 0, sizeof(dp));
for (int i = 0; i < t.size(); i++)
dp[0][i] = true;
A[0] = 1;
for (int i = 1; i < 30; i++)
A[i] = A[i - 1] * M;
for (int i = 0; i < (1 << n); i++) {
for (int j = 0; j < t.size(); j++) {
if (!dp[i][j])
continue;
for (int k = 0; k < n; k++) {
if (i & (1 << k))
continue;
int slen = s[k].size();
if (t.size() < j + slen)
continue;
ull x = d2[j + slen - 1];
if (j)
x -= d2[j - 1] * A[slen];
if (d1[k] != x)
continue;
dp[i | (1 << k)][j + slen] = true;
}
}
}
int ans = 0;
for (int i = 0; i <= t.size(); i++)
ans += dp[(1 << n) - 1][i];
cout << ans << endl;
}
return 0;
}
|
[["-", 341, 342, 0, 16, 31, 16, 12, 69, 28, 22], ["-", 0, 16, 31, 16, 12, 69, 341, 342, 0, 70], ["-", 0, 16, 31, 16, 12, 69, 341, 342, 0, 73]]
| 1
| 552
|
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<vector<ll>, ll> pvi;
vector<ll> polyadd(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
vector<ll> result(max(n, m));
for (ll i = 0; i < n; ++i) {
result[i] += a[i];
}
for (ll i = 0; i < m; ++i) {
result[i] += b[i];
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polysub(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
vector<ll> result(max(n, m));
for (ll i = 0; i < n; ++i) {
result[i] += a[i];
}
for (ll i = 0; i < m; ++i) {
result[i] -= b[i];
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polymul(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
if (n == 0 || m == 0) {
return vector<ll>();
}
vector<ll> result(n + m - 1);
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < m; ++j) {
result[i + j] += a[i] * b[j];
}
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polypow(const vector<ll> &a, ll b) {
vector<ll> x = a, y(1, 1);
while (b) {
if (b & 1) {
y = polymul(y, x);
}
x = polymul(x, x);
b >>= 1;
}
return y;
}
pvi lex_expr(const char *s, ll p);
pvi lex_term(const char *s, ll p);
pvi lex_factor(const char *s, ll p);
pvi lex_digits(const char *s, ll p);
pvi lex_expr(const char *s, ll p) {
pvi r(vector<ll>(), p);
if (s[p] != '-') {
r = lex_term(s, p);
}
while (s[r.second] == '+' || s[r.second] == '-') {
const pvi q = lex_term(s, r.second + 1);
if (s[r.second] == '+') {
r.first = polyadd(r.first, q.first);
} else {
r.first = polysub(r.first, q.first);
}
r.second = q.second;
}
return r;
}
pvi lex_term(const char *s, ll p) {
pvi r = lex_factor(s, p);
p = r.second;
while (s[p] != '+' && s[p] != '-' && s[p] != ')' && s[p] != '\0') {
const pvi q = lex_factor(s, p);
r.first = polymul(r.first, q.first);
p = r.second = q.second;
}
return r;
}
pvi lex_factor(const char *s, ll p) {
pvi r(vector<ll>(), p);
if (s[p] == '(') {
r = lex_expr(s, p + 1);
r.second += 1;
} else if (s[p] == 'x') {
r.first = vector<ll>(2);
r.first[1] = 1;
r.second = p + 1;
} else if (isdigit(s[p])) {
r.first.push_back(0);
while (isdigit(s[p])) {
r.first[0] = (r.first[0] * 10) + (s[p++] - '0');
}
r.second = p;
}
if (s[r.second] == '^') {
ll x = 0;
p = r.second + 1;
while (isdigit(s[p])) {
x = (x * 10) + (s[p++] - '0');
}
r.first = polypow(r.first, x);
r.second = p;
}
return r;
}
vector<ll> polyabs(vector<ll> a) {
if (!a.empty() && a.back() < 0) {
for (ll i = 0; i < a.size(); ++i) {
a[i] *= -1;
}
}
return a;
}
vector<ll> reduction(vector<ll> a) {
while (!a.empty() && a.back() == 0) {
a.pop_back();
}
if (a.empty()) {
return a;
}
a = polyabs(a);
ll g = a[0];
for (ll i = 0; i < a.size(); ++i) {
g = __gcd(g, abs(a[i]));
}
for (ll i = 0; i < a.size(); ++i) {
a[i] /= g;
}
while (!a.empty() && a.back() == 0) {
a.pop_back();
}
return a;
}
vector<ll> polymod(vector<ll> a, vector<ll> b) {
a = polyabs(a);
b = polyabs(b);
if (b.size() <= a.size()) {
ll g = __gcd(abs(a.back()), abs(b.back()));
const ll ab = a.back(), bb = b.back();
a = polymul(a, vector<ll>(1, bb / g));
b = polymul(b, vector<ll>(1, ab / g));
const ll d = a.size() - b.size();
for (ll i = 0; i < b.size(); ++i) {
a[i + d] -= b[i];
}
a = reduction(polyabs(a));
}
return a;
}
vector<ll> gcd(const vector<ll> &a, const vector<ll> &b) {
if (b.empty()) {
return reduction(a);
}
return reduction(gcd(b, polymod(a, b)));
}
int main() {
ios_base::sync_with_stdio(false);
while (true) {
string s, t;
cin >> s;
if (s == ".") {
break;
}
cin >> t;
const vector<ll> a = lex_expr(s.c_str(), 0).first;
const vector<ll> b = lex_expr(t.c_str(), 0).first;
const vector<ll> c = gcd(a, b);
if (c.empty()) {
cout << "0" << endl;
}
for (ll i = c.size() - 1; i >= 0; --i) {
if (a[i] == 0) {
continue;
}
if (c[i] > 0 && i != c.size() - 1) {
cout << "+";
}
if (i != 0 && c[i] == -1) {
cout << "-";
} else if (i == 0 || c[i] != 1) {
cout << c[i];
}
if (i >= 1) {
cout << "x";
}
if (i >= 2) {
cout << "^" << i;
}
}
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <utility>
#include <vector>
using namespace std;
typedef long long ll;
typedef pair<vector<ll>, ll> pvi;
vector<ll> polyadd(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
vector<ll> result(max(n, m));
for (ll i = 0; i < n; ++i) {
result[i] += a[i];
}
for (ll i = 0; i < m; ++i) {
result[i] += b[i];
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polysub(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
vector<ll> result(max(n, m));
for (ll i = 0; i < n; ++i) {
result[i] += a[i];
}
for (ll i = 0; i < m; ++i) {
result[i] -= b[i];
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polymul(const vector<ll> &a, const vector<ll> &b) {
const ll n = a.size(), m = b.size();
if (n == 0 || m == 0) {
return vector<ll>();
}
vector<ll> result(n + m - 1);
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j < m; ++j) {
result[i + j] += a[i] * b[j];
}
}
while (!result.empty() && result.back() == 0) {
result.pop_back();
}
return result;
}
vector<ll> polypow(const vector<ll> &a, ll b) {
vector<ll> x = a, y(1, 1);
while (b) {
if (b & 1) {
y = polymul(y, x);
}
x = polymul(x, x);
b >>= 1;
}
return y;
}
pvi lex_expr(const char *s, ll p);
pvi lex_term(const char *s, ll p);
pvi lex_factor(const char *s, ll p);
pvi lex_digits(const char *s, ll p);
pvi lex_expr(const char *s, ll p) {
pvi r(vector<ll>(), p);
if (s[p] != '-') {
r = lex_term(s, p);
}
while (s[r.second] == '+' || s[r.second] == '-') {
const pvi q = lex_term(s, r.second + 1);
if (s[r.second] == '+') {
r.first = polyadd(r.first, q.first);
} else {
r.first = polysub(r.first, q.first);
}
r.second = q.second;
}
return r;
}
pvi lex_term(const char *s, ll p) {
pvi r = lex_factor(s, p);
p = r.second;
while (s[p] != '+' && s[p] != '-' && s[p] != ')' && s[p] != '\0') {
const pvi q = lex_factor(s, p);
r.first = polymul(r.first, q.first);
p = r.second = q.second;
}
return r;
}
pvi lex_factor(const char *s, ll p) {
pvi r(vector<ll>(), p);
if (s[p] == '(') {
r = lex_expr(s, p + 1);
r.second += 1;
} else if (s[p] == 'x') {
r.first = vector<ll>(2);
r.first[1] = 1;
r.second = p + 1;
} else if (isdigit(s[p])) {
r.first.push_back(0);
while (isdigit(s[p])) {
r.first[0] = (r.first[0] * 10) + (s[p++] - '0');
}
r.second = p;
}
if (s[r.second] == '^') {
ll x = 0;
p = r.second + 1;
while (isdigit(s[p])) {
x = (x * 10) + (s[p++] - '0');
}
r.first = polypow(r.first, x);
r.second = p;
}
return r;
}
vector<ll> polyabs(vector<ll> a) {
if (!a.empty() && a.back() < 0) {
for (ll i = 0; i < a.size(); ++i) {
a[i] *= -1;
}
}
return a;
}
vector<ll> reduction(vector<ll> a) {
while (!a.empty() && a.back() == 0) {
a.pop_back();
}
if (a.empty()) {
return a;
}
a = polyabs(a);
ll g = a[0];
for (ll i = 0; i < a.size(); ++i) {
g = __gcd(g, abs(a[i]));
}
for (ll i = 0; i < a.size(); ++i) {
a[i] /= g;
}
while (!a.empty() && a.back() == 0) {
a.pop_back();
}
return a;
}
vector<ll> polymod(vector<ll> a, vector<ll> b) {
a = polyabs(a);
b = polyabs(b);
if (b.size() <= a.size()) {
ll g = __gcd(abs(a.back()), abs(b.back()));
const ll ab = a.back(), bb = b.back();
a = polymul(a, vector<ll>(1, bb / g));
b = polymul(b, vector<ll>(1, ab / g));
const ll d = a.size() - b.size();
for (ll i = 0; i < b.size(); ++i) {
a[i + d] -= b[i];
}
a = reduction(polyabs(a));
}
return a;
}
vector<ll> gcd(const vector<ll> &a, const vector<ll> &b) {
if (b.empty()) {
return reduction(a);
}
return reduction(gcd(b, polymod(a, b)));
}
int main() {
ios_base::sync_with_stdio(false);
while (true) {
string s, t;
cin >> s;
if (s == ".") {
break;
}
cin >> t;
const vector<ll> a = lex_expr(s.c_str(), 0).first;
const vector<ll> b = lex_expr(t.c_str(), 0).first;
const vector<ll> c = gcd(a, b);
if (c.empty()) {
cout << "0" << endl;
}
for (ll i = c.size() - 1; i >= 0; --i) {
if (c[i] == 0) {
continue;
}
if (c[i] > 0 && i != c.size() - 1) {
cout << "+";
}
if (i != 0 && c[i] == -1) {
cout << "-";
} else if (i == 0 || c[i] != 1) {
cout << c[i];
}
if (i >= 1) {
cout << "x";
}
if (i >= 2) {
cout << "^" << i;
}
}
cout << endl;
}
return 0;
}
|
[["-", 0, 57, 15, 339, 51, 16, 31, 69, 28, 22], ["+", 0, 57, 15, 339, 51, 16, 31, 69, 28, 22]]
| 1
| 1,809
|
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
final int w = sc.nextInt();
final int d = sc.nextInt();
if (w == 0 && d == 0) {
break;
}
int[] wh = new int[21];
int[] dh = new int[21];
for (int i = 0; i < w; i++) {
wh[sc.nextInt()]++;
}
for (int i = 0; i < d; i++) {
dh[sc.nextInt()]++;
}
int cost = 0;
for (int i = 0; i <= 20; i++) {
int dup = Math.min(wh[i], dh[i]);
cost += dup * i;
cost += (wh[i] - dup) * i;
cost += (dh[i] ^ dup) * i;
}
System.out.println(cost);
}
}
}
|
import java.util.Arrays;
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
while (true) {
final int w = sc.nextInt();
final int d = sc.nextInt();
if (w == 0 && d == 0) {
break;
}
int[] wh = new int[21];
int[] dh = new int[21];
for (int i = 0; i < w; i++) {
wh[sc.nextInt()]++;
}
for (int i = 0; i < d; i++) {
dh[sc.nextInt()]++;
}
int cost = 0;
for (int i = 0; i <= 20; i++) {
int dup = Math.min(wh[i], dh[i]);
cost += dup * i;
cost += (wh[i] - dup) * i;
cost += (dh[i] - dup) * i;
}
System.out.println(cost);
}
}
}
|
[["-", 0, 11, 12, 16, 31, 23, 0, 16, 17, 140], ["+", 0, 11, 12, 16, 31, 23, 0, 16, 17, 33]]
| 3
| 236
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
int main() {
while (true) {
int w, d, a[21] = {}, b[21] = {};
cin >> w >> d;
if (w == 0)
break;
rep(i, w) {
int k;
cin >> k;
a[k]++;
}
rep(i, d) {
int k;
cin >> k;
b[k]++;
}
int ans = 0;
rep(i, 21) ans += max(a[i], b[i]);
cout << ans << endl;
}
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <functional>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < (n); ++i)
#define rep1(i, n) for (int i = 1; i <= (n); ++i)
#define all(c) (c).begin(), (c).end()
#define pb push_back
#define fs first
#define sc second
#define show(x) cout << #x << " = " << x << endl
int main() {
while (true) {
int w, d, a[21] = {}, b[21] = {};
cin >> w >> d;
if (w == 0)
break;
rep(i, w) {
int k;
cin >> k;
a[k]++;
}
rep(i, d) {
int k;
cin >> k;
b[k]++;
}
int ans = 0;
rep(i, 21) ans += max(a[i], b[i]) * i;
cout << ans << endl;
}
}
|
[["+", 8, 9, 0, 1, 0, 11, 12, 16, 17, 48], ["+", 8, 9, 0, 1, 0, 11, 12, 16, 12, 22]]
| 1
| 176
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
int main() {
for (int w, d; cin >> w >> d && (w | d);) {
vector<int> h1(w + 1, INF), h2(d + 1, INF + 1);
for (int i = 0; i < w; ++i)
cin >> h1[i];
for (int i = 0; i < d; ++i)
cin >> h2[i];
sort(h1.begin(), h1.end());
sort(h2.begin(), h2.end());
int res = 0;
for (int i = 0, j = 0; i < w && j < d;) {
if (h1[i] == h2[j]) {
res += h1[i];
++i;
++j;
} else if (h1[i] < h2[j]) {
res += h1[i++];
} else {
res += h2[j++];
}
}
cout << res << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1 << 28;
int main() {
for (int w, d; cin >> w >> d && (w | d);) {
vector<int> h1(w + 1, INF), h2(d + 1, INF + 1);
for (int i = 0; i < w; ++i)
cin >> h1[i];
for (int i = 0; i < d; ++i)
cin >> h2[i];
sort(h1.begin(), h1.end());
sort(h2.begin(), h2.end());
int res = 0;
for (int i = 0, j = 0; i < w || j < d;) {
if (h1[i] == h2[j]) {
res += h1[i];
++i;
++j;
} else if (h1[i] < h2[j]) {
res += h1[i++];
} else {
res += h2[j++];
}
}
cout << res << endl;
}
return 0;
}
|
[["-", 0, 7, 8, 9, 0, 7, 15, 16, 17, 98], ["+", 0, 7, 8, 9, 0, 7, 15, 16, 17, 106]]
| 1
| 235
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int n, m;
int a[20], b[20];
int solve() {
rep(i, n) rep(j, m) {
if (a[i] == b[j])
b[j] = 0;
}
int res = 0;
rep(i, n) res += a[i];
rep(i, m) res += b[i];
return res;
}
int main() {
while (cin >> n >> m, n) {
rep(i, n) cin >> a[i];
rep(i, m) cin >> b[i];
cout << solve() << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for (int i = 0; i < (int)(n); i++)
int n, m;
int a[20], b[20];
int solve() {
rep(i, n) rep(j, m) {
if (a[i] == b[j]) {
b[j] = 0;
break;
}
}
int res = 0;
rep(i, n) res += a[i];
rep(i, m) res += b[i];
return res;
}
int main() {
while (cin >> n >> m, n) {
rep(i, n) cin >> a[i];
rep(i, m) cin >> b[i];
cout << solve() << endl;
}
}
|
[["+", 0, 14, 8, 9, 0, 57, 64, 9, 0, 45], ["+", 8, 9, 0, 57, 64, 9, 0, 1, 0, 35], ["+", 8, 9, 0, 57, 64, 9, 0, 93, 0, 94], ["+", 0, 14, 8, 9, 0, 57, 64, 9, 0, 46]]
| 1
| 155
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int x[30][2];
int y[30];
int h, w, sum;
int s[20], t[20];
int hantei() {
sum = 0;
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
for (int i = 0; i < h; i++) {
x[s[i]][0]++;
}
for (int i = 0; i < w; i++) {
x[t[i]][1]++;
}
for (int i = 0; i < 30; i++) {
y[i] = max(x[i][0], x[i][1]);
sum += y[i];
}
return sum;
}
int main() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0) {
break;
}
for (int i = 0; i < h; i++) {
cin >> s[i];
}
for (int i = 0; i < w; i++) {
cin >> t[i];
}
cout << hantei() << endl;
}
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int x[30][2];
int y[30];
int h, w, sum;
int s[20], t[20];
int hantei() {
sum = 0;
memset(x, 0, sizeof(x));
memset(y, 0, sizeof(y));
for (int i = 0; i < h; i++) {
x[s[i]][0]++;
}
for (int i = 0; i < w; i++) {
x[t[i]][1]++;
}
for (int i = 0; i < 30; i++) {
y[i] = max(x[i][0], x[i][1]);
sum += y[i] * i;
}
return sum;
}
int main() {
while (true) {
cin >> h >> w;
if (h == 0 && w == 0) {
break;
}
for (int i = 0; i < h; i++) {
cin >> s[i];
}
for (int i = 0; i < w; i++) {
cin >> t[i];
}
cout << hantei() << endl;
}
}
|
[["+", 8, 9, 0, 1, 0, 11, 12, 16, 17, 48], ["+", 8, 9, 0, 1, 0, 11, 12, 16, 12, 22]]
| 1
| 269
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int w, d;
while (cin >> w >> d) {
int a1[22] = {}, a2[22] = {};
for (int i = 0; i < w; i++) {
int k;
cin >> k;
a1[k]++;
}
for (int i = 0; i < d; i++) {
int k;
cin >> k;
a2[k]++;
}
int ans = 0;
for (int i = 1; i <= 20; i++)
ans += max(a1[i], a2[i]) * i;
cout << ans << endl;
}
}
|
#include <algorithm>
#include <iostream>
using namespace std;
int main() {
int w, d;
while (cin >> w >> d, w, d) {
int a1[22] = {}, a2[22] = {};
for (int i = 0; i < w; i++) {
int k;
cin >> k;
a1[k]++;
}
for (int i = 0; i < d; i++) {
int k;
cin >> k;
a2[k]++;
}
int ans = 0;
for (int i = 1; i <= 20; i++)
ans += max(a1[i], a2[i]) * i;
cout << ans << endl;
}
}
|
[["+", 8, 9, 0, 52, 15, 339, 51, 34, 0, 21], ["+", 0, 52, 15, 339, 51, 34, 12, 34, 31, 22], ["+", 0, 52, 15, 339, 51, 34, 12, 34, 0, 21], ["+", 0, 52, 15, 339, 51, 34, 12, 34, 12, 22]]
| 1
| 146
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio
///2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual
///studio 2015\projects\programing_contest_c++\debug\b.txt"
set<string> memo;
vector<string> dfs(string now, map<string, vector<string>> mp) {
if (memo.find(now) != memo.end())
return vector<string>();
else
memo.emplace(now);
if (mp.find(now) == mp.end())
return vector<string>(1, now);
else {
vector<string> ans;
for (auto child : mp[now]) {
auto sts = dfs(child, mp);
ans.insert(ans.end(), sts.begin(), sts.end());
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
}
return ans;
}
}
int main() {
while (1) {
int N;
cin >> N;
if (!N)
break;
map<string, vector<string>> mp;
string start;
for (int i = 0; i < N; ++i) {
string st;
cin >> st;
int a = st.find(':');
string parent = st.substr(0, a);
if (!i)
start = parent;
vector<string> children;
int from = a + 1;
while (1) {
int r = st.find(',', from);
if (r == string::npos) {
children.push_back(st.substr(from, st.find('.') - from));
break;
} else {
children.push_back(st.substr(from, r - from));
from = r + 1;
}
}
mp[parent] = children;
}
auto anss = dfs(start, mp);
cout << anss.size() << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
#include <unordered_map>
#include <unordered_set>
#pragma warning(disable : 4996)
using namespace std;
using ld = long double;
const ld eps = 1e-9;
//// < "d:\d_download\visual studio
///2015\projects\programing_contest_c++\debug\a.txt" > "d:\d_download\visual
///studio 2015\projects\programing_contest_c++\debug\b.txt"
set<string> memo;
vector<string> dfs(string now, map<string, vector<string>> mp) {
if (memo.find(now) != memo.end())
return vector<string>();
else
memo.emplace(now);
if (mp.find(now) == mp.end())
return vector<string>(1, now);
else {
vector<string> ans;
for (auto child : mp[now]) {
auto sts = dfs(child, mp);
ans.insert(ans.end(), sts.begin(), sts.end());
sort(ans.begin(), ans.end());
ans.erase(unique(ans.begin(), ans.end()), ans.end());
}
return ans;
}
}
int main() {
while (1) {
memo.clear();
int N;
cin >> N;
if (!N)
break;
map<string, vector<string>> mp;
string start;
for (int i = 0; i < N; ++i) {
string st;
cin >> st;
int a = st.find(':');
string parent = st.substr(0, a);
if (!i)
start = parent;
vector<string> children;
int from = a + 1;
while (1) {
int r = st.find(',', from);
if (r == string::npos) {
children.push_back(st.substr(from, st.find('.') - from));
break;
} else {
children.push_back(st.substr(from, r - from));
from = r + 1;
}
}
mp[parent] = children;
}
auto anss = dfs(start, mp);
cout << anss.size() << endl;
}
return 0;
}
|
[["+", 8, 9, 0, 1, 0, 2, 63, 118, 28, 22], ["+", 8, 9, 0, 1, 0, 2, 63, 118, 17, 131], ["+", 8, 9, 0, 1, 0, 2, 63, 118, 119, 120], ["+", 8, 9, 0, 1, 0, 2, 3, 4, 0, 24], ["+", 8, 9, 0, 1, 0, 2, 3, 4, 0, 25], ["+", 8, 9, 0, 52, 8, 9, 0, 1, 0, 35]]
| 1
| 431
|
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
set<string> s;
set<string> visit;
map<string, vector<string>> m;
void solve(string &key) {
int i;
vector<string> &z = m[key];
for (i = 0; i < z.size(); i++)
if (m.find(z[i]) != m.end())
s.insert(z[i]);
else if (visit.find(z[i]) == visit.end()) /////
visit.insert(z[i]), ///// avoid recursive lol
solve(z[i]);
}
main() {
string str, group, g1, arg;
int n, i, j;
for (; cin >> n, n; cout << s.size() << endl) {
m.clear();
s.clear();
visit.clear();
for (i = 0; i < n; i++) {
cin >> str;
for (j = 0; j < str.length(); j++)
if (str[j] == ':' || str[j] == ',' || str[j] == '.')
str[j] = ' ';
istringstream is(str);
vector<string> v;
is >> group;
if (!i)
g1 = group;
for (; is >> arg;)
v.push_back(arg);
m[group] = v;
}
visit.insert(g1), solve(g1);
}
}
|
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <vector>
using namespace std;
set<string> s;
set<string> visit;
map<string, vector<string>> m;
void solve(string &key) {
int i;
vector<string> &z = m[key];
for (i = 0; i < z.size(); i++)
if (m.find(z[i]) == m.end())
s.insert(z[i]);
else if (visit.find(z[i]) == visit.end()) /////
visit.insert(z[i]), solve(z[i]); ///// avoid recursive lol
}
main() {
string str, group, g1, arg;
int n, i, j;
for (; cin >> n, n; cout << s.size() << endl) {
m.clear();
s.clear();
visit.clear();
for (i = 0; i < n; i++) {
cin >> str;
for (j = 0; j < str.length(); j++)
if (str[j] == ':' || str[j] == ',' || str[j] == '.')
str[j] = ' ';
istringstream is(str);
vector<string> v;
is >> group;
if (!i)
g1 = group;
for (; is >> arg;)
v.push_back(arg);
m[group] = v;
}
visit.insert(g1), solve(g1);
}
}
|
[["-", 0, 7, 8, 57, 15, 339, 51, 16, 17, 79], ["+", 0, 7, 8, 57, 15, 339, 51, 16, 17, 60]]
| 1
| 338
|
import static java.lang.Math.*;
import java.util.*;
public class Main {
final Scanner sc = new Scanner(System.in);
public static void main(String[] args) { new Main().init(); }
void init() {
final long STACK_SIZE = 8 * 1024 * 1024;
new Thread(null, new AOJ1306(), "RUN!", STACK_SIZE).start();
// new Live5015();
}
class AOJ1306 implements Runnable {
int N;
final int INF = 1 << 29;
AOJ1306() {}
@Override
public void run() {
while (sc.hasNext()) {
N = sc.nextInt();
if (N == 0)
break;
solve();
}
}
void solve() {
int[] p = new int[N + 1], t = new int[N + 1];
for (int i = 1; i <= N; i++) {
p[i] = sc.nextInt();
t[i] = sc.nextInt();
}
int[][] dp = new int[N + 1][4];
for (int i = 0; i <= N; i++)
for (int j = 0; j <= 3; j++)
dp[i][j] = INF;
dp[1][1] = p[1];
dp[1][0] = p[1] * 3;
if (t[1] < p[1]) {
System.out.println("NG 1");
return;
}
int ans = INF;
for (int now = 2; now <= N; now++) {
boolean f = false;
for (int b = 1; b <= 3; b++) {
int d0 = p[now - 1] + p[now], t0 = p[now - 1] * (b + 1) + p[now],
d1 = (b == 3 ? d0 : abs(p[now - 1] - p[now])),
t1 = (b == 3 ? t0 : d1 * (b + 1)), tlim = t[now] - t[now - 1];
if (dp[now - 1][b] < INF) {
if (t0 <= tlim) {
f = true;
dp[now][1] = min(dp[now][1], dp[now - 1][b] + d0);
}
if (t1 <= tlim) {
f = true;
dp[now][(b % 3) + 1] =
min(dp[now][(b % 3) + 1], dp[now - 1][b] + d1);
}
}
}
if (!f)
ans = now;
}
if (ans < INF)
System.out.println("NG " + ans);
else {
for (int i = 0; i <= 3; i++)
ans = min(ans, dp[N][i]);
System.out.println("OK " + (ans + p[N]));
}
// degug
// for(int y=0; y<=3; y++){
// for(int x=1; x<=N;
//x++)System.out.printf("%4d ",dp[x][y]>=INF?-1:dp[x][y]);
// System.out.println();
// }
// System.out.println("---------------------------------------");
}
}
}
|
import static java.lang.Math.*;
import java.util.*;
public class Main {
final Scanner sc = new Scanner(System.in);
public static void main(String[] args) { new Main().init(); }
void init() {
final long STACK_SIZE = 8 * 1024 * 1024;
new Thread(null, new AOJ1306(), "RUN!", STACK_SIZE).start();
// new Live5015();
}
class AOJ1306 implements Runnable {
int N;
final int INF = 1 << 29;
AOJ1306() {}
@Override
public void run() {
while (sc.hasNext()) {
N = sc.nextInt();
if (N == 0)
break;
solve();
}
}
void solve() {
int[] p = new int[N + 1], t = new int[N + 1];
for (int i = 1; i <= N; i++) {
p[i] = sc.nextInt();
t[i] = sc.nextInt();
}
int[][] dp = new int[N + 1][4];
for (int i = 0; i <= N; i++)
for (int j = 0; j <= 3; j++)
dp[i][j] = INF;
dp[1][1] = p[1];
dp[1][0] = p[1] * 3;
if (t[1] < p[1]) {
System.out.println("NG 1");
return;
}
int ans = INF;
for (int now = 2; now <= N; now++) {
boolean f = false;
for (int b = 1; b <= 3; b++) {
int d0 = p[now - 1] + p[now], t0 = p[now - 1] * (b + 1) + p[now],
d1 = (b == 3 ? d0 : abs(p[now - 1] - p[now])),
t1 = (b == 3 ? t0 : d1 * (b + 1)), tlim = t[now] - t[now - 1];
if (dp[now - 1][b] < INF) {
if (t0 <= tlim) {
f = true;
dp[now][1] = min(dp[now][1], dp[now - 1][b] + d0);
}
if (t1 <= tlim) {
f = true;
dp[now][(b % 3) + 1] =
min(dp[now][(b % 3) + 1], dp[now - 1][b] + d1);
}
}
}
if (!f) {
ans = now;
break;
}
}
if (ans < INF)
System.out.println("NG " + ans);
else {
for (int i = 0; i <= 3; i++)
ans = min(ans, dp[N][i]);
System.out.println("OK " + (ans + p[N]));
}
// degug
// for(int y=0; y<=3; y++){
// for(int x=1; x<=N;
//x++)System.out.printf("%4d ",dp[x][y]>=INF?-1:dp[x][y]);
// System.out.println();
// }
// System.out.println("---------------------------------------");
}
}
}
|
[["+", 0, 7, 8, 196, 0, 57, 64, 196, 0, 45], ["+", 8, 196, 0, 57, 64, 196, 0, 1, 0, 35], ["+", 8, 196, 0, 57, 64, 196, 0, 93, 0, 94], ["+", 0, 7, 8, 196, 0, 57, 64, 196, 0, 46]]
| 3
| 667
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
using namespace std;
int N;
int dp[40][4];
int NG_index;
int P[40];
int T[40];
const int INF = (int)1e9;
int solve(int index, int num) {
if (index == N)
return P[index - 1];
int &res = dp[index][num];
if (res != -1)
return res;
res = INF;
int curtime;
int curpos;
if (index == 0) {
curtime = 0;
curpos = 0;
} else {
curtime = T[index - 1];
curpos = P[index - 1];
}
if (num <= 2 &&
curtime + (num + 1 + 1) * abs(P[index] - curpos) <= T[index]) {
res = min(res, abs(P[index] - curpos) + solve(index + 1, num + 1));
}
if (curtime + (num + 1) * curpos + P[index] <= T[index]) {
res = min(res, curpos + P[index] + solve(index + 1, 1));
}
if (res == INF) {
NG_index = max(NG_index, 1 + index);
}
// cerr << "solve(" << index << "," << num << ") = " << res << endl;
return res;
}
int main() {
while (true) {
cin >> N;
if (N == 0)
break;
for (int i = 0; i < N; ++i) {
cin >> P[i] >> T[i];
}
memset(dp, -1, sizeof(dp));
NG_index = -1;
int res = solve(0, 0);
if (res == INF) {
cout << "NG " << NG_index << endl;
} else {
cout << "OK " << res << endl;
}
}
}
|
#include <algorithm>
#include <cmath>
#include <cstring>
#include <iostream>
using namespace std;
int N;
int dp[40][4];
int NG_index;
int P[40];
int T[40];
const int INF = (int)1e9;
int solve(int index, int num) {
if (index == N)
return P[index - 1];
int &res = dp[index][num];
if (res != -1)
return res;
res = INF;
int curtime;
int curpos;
if (index == 0) {
curtime = 0;
curpos = 0;
} else {
curtime = T[index - 1];
curpos = P[index - 1];
}
if (num <= 2 && curtime + (num + 1) * abs(P[index] - curpos) <= T[index]) {
res = min(res, abs(P[index] - curpos) + solve(index + 1, num + 1));
}
if (curtime + (num + 1) * curpos + P[index] <= T[index]) {
res = min(res, curpos + P[index] + solve(index + 1, 1));
}
if (res == INF) {
NG_index = max(NG_index, 1 + index);
}
// cerr << "solve(" << index << "," << num << ") = " << res << endl;
return res;
}
int main() {
while (true) {
cin >> N;
if (N == 0)
break;
for (int i = 0; i < N; ++i) {
cin >> P[i] >> T[i];
}
memset(dp, -1, sizeof(dp));
NG_index = -1;
int res = solve(0, 0);
if (res == INF) {
cout << "NG " << NG_index << endl;
} else {
cout << "OK " << res << endl;
}
}
}
|
[["-", 31, 16, 12, 16, 31, 23, 0, 16, 17, 72], ["-", 31, 16, 12, 16, 31, 23, 0, 16, 12, 13]]
| 1
| 381
|
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 42;
const int MAXB = 4;
const int INF = 1 << 28;
int N;
int dp[MAXN][MAXB];
int P[MAXN], T[MAXN];
int main() {
while (cin >> N && N) {
P[0] = 0;
T[0] = 0;
for (int i = 0; i < N; ++i) {
cin >> P[i + 1] >> T[i + 1];
}
P[N + 1] = 0;
T[N + 1] = INF;
N += 2;
fill(dp[0], dp[MAXN], INF);
dp[0][0] = 0;
int stage = 0;
for (int i = 0; i < N; ++i) {
for (int k = 0; k < MAXB; ++k) {
if (dp[i][k] == INF)
continue;
stage = i;
// 1
{
int dist = abs(P[i + 1] - P[i]);
if (k + 1 < MAXB && dist * (k + 1) <= T[i + 1] - T[i]) {
dp[i + 1][k + 1] = min(dp[i + 1][k + 1], dp[i][k] + dist);
}
}
// 2
{
int dist = P[i] + P[i + 1];
if (P[i] * (k + 1) + P[i + 1] <= T[i + 1] - T[i]) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][k] + dist);
}
}
}
}
int res = INF;
for (int k = 0; k < MAXB; ++k) {
res = min(res, dp[N - 1][k]);
}
if (res != INF) {
cout << "OK " << res << endl;
} else {
cout << "NO " << stage + 1 << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
using namespace std;
const int MAXN = 45;
const int MAXB = 4;
const int INF = 1 << 28;
int N;
int dp[MAXN][MAXB];
int P[MAXN], T[MAXN];
int main() {
while (cin >> N && N) {
P[0] = 0;
T[0] = 0;
for (int i = 0; i < N; ++i) {
cin >> P[i + 1] >> T[i + 1];
}
P[N + 1] = 0;
T[N + 1] = INF;
N += 2;
fill(dp[0], dp[MAXN], INF);
dp[0][0] = 0;
int stage = 0;
for (int i = 0; i < N; ++i) {
for (int k = 0; k < MAXB; ++k) {
if (dp[i][k] == INF)
continue;
stage = i;
// 1
{
int dist = abs(P[i + 1] - P[i]);
if (k + 1 < MAXB && dist * (k + 1) <= T[i + 1] - T[i]) {
dp[i + 1][k + 1] = min(dp[i + 1][k + 1], dp[i][k] + dist);
}
}
// 2
{
int dist = P[i] + P[i + 1];
if (P[i] * (k + 1) + P[i + 1] <= T[i + 1] - T[i]) {
dp[i + 1][1] = min(dp[i + 1][1], dp[i][k] + dist);
}
}
}
}
int res = INF;
for (int k = 0; k < MAXB; ++k) {
res = min(res, dp[N - 1][k]);
}
if (res != INF) {
cout << "OK " << res << endl;
} else {
cout << "NG " << stage + 1 << endl;
}
}
return 0;
}
|
[["-", 36, 36, 0, 30, 0, 43, 49, 50, 51, 13], ["+", 36, 36, 0, 30, 0, 43, 49, 50, 51, 13], ["-", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6], ["+", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6]]
| 1
| 464
|
#include <bits/stdc++.h>
using namespace std;
#define MAX 45
#define INF 1e9
int N, p[MAX], t[MAX];
int dp[MAX][4];
bool used[MAX];
void init() {
p[0] = t[0] = 0;
fill(dp[0], dp[0] + MAX * 4, INF);
memset(used, false, sizeof(used));
}
int d(int idx, bool v) {
if (v) {
return p[idx] + p[idx + 1];
} else {
return abs(p[idx] - p[idx + 1]);
}
}
int solve(int idx, int cap) {
used[idx] = true;
if (idx == N) {
return dp[idx][cap] = d(idx, 1);
}
int &res = dp[idx][cap], dt = t[idx + 1] - t[idx];
if (res != INF) {
return res;
}
if (p[idx] * (cap + 1) + p[idx + 1] <= dt) {
res = min(res, solve(idx + 1, 1) + d(idx, 1));
}
if (cap < 3 && d(idx, 0) * (cap + 1) <= dt) {
res = min(res, solve(idx + 1, cap + 1) + d(idx, 0));
}
return res;
}
int main() {
while (cin >> N, N) {
init();
for (int i = 1; i <= N; i++) {
cin >> p[i] >> t[i];
}
int ans = solve(0, 0);
if (ans != INF) {
cout << "OK " << ans << endl;
} else {
cout << "NG " << find(used + 1, used + N, false) - used << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define MAX 45
#define INF 1e9
int N, p[MAX], t[MAX];
int dp[MAX][4];
bool used[MAX];
void init() {
p[0] = t[0] = 0;
fill(dp[0], dp[0] + MAX * 4, INF);
memset(used, false, sizeof(used));
}
int d(int idx, bool v) {
if (v) {
return p[idx] + p[idx + 1];
} else {
return abs(p[idx] - p[idx + 1]);
}
}
int solve(int idx, int cap) {
used[idx] = true;
if (idx == N) {
return dp[idx][cap] = p[idx];
}
int &res = dp[idx][cap], dt = t[idx + 1] - t[idx];
if (res != INF) {
return res;
}
if (p[idx] * (cap + 1) + p[idx + 1] <= dt) {
res = min(res, solve(idx + 1, 1) + d(idx, 1));
}
if (cap < 3 && d(idx, 0) * (cap + 1) <= dt) {
res = min(res, solve(idx + 1, cap + 1) + d(idx, 0));
}
return res;
}
int main() {
while (cin >> N, N) {
init();
for (int i = 1; i <= N; i++) {
cin >> p[i] >> t[i];
}
int ans = solve(0, 0);
if (ans != INF) {
cout << "OK " << ans << endl;
} else {
cout << "NG " << find(used + 1, used + N, false) - used << endl;
}
}
return 0;
}
|
[["-", 64, 9, 0, 37, 0, 11, 12, 2, 63, 22], ["-", 0, 37, 0, 11, 12, 2, 3, 4, 0, 24], ["+", 64, 9, 0, 37, 0, 11, 12, 69, 28, 22], ["+", 0, 37, 0, 11, 12, 69, 341, 342, 0, 70], ["-", 0, 37, 0, 11, 12, 2, 3, 4, 0, 21], ["-", 0, 37, 0, 11, 12, 2, 3, 4, 0, 13], ["-", 0, 37, 0, 11, 12, 2, 3, 4, 0, 25], ["+", 0, 37, 0, 11, 12, 69, 341, 342, 0, 73]]
| 1
| 420
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 100000000
using namespace std;
int n, p, t, dp[50][3], P, T, a;
int main() {
while (cin >> n, n) {
rep(i, 50) rep(j, 3) dp[i][j] = INF;
dp[0][0] = 0;
P = 0;
T = 0;
a = INF;
rep(i, n) {
cin >> p >> t;
rep(j, 3) if (dp[i][j] != INF && (j + 2) * P + p <= t - T) dp[i + 1][0] =
min(dp[i + 1][0], dp[i][j] + P + p);
for (int j = 1; j < 3; j++)
if (dp[i][j - 1] != INF && (j + 1) * abs(P - p) <= t - T)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - 1] + abs(P - p));
P = p;
T = t;
}
rep(i, 3) a = min(a, dp[n][i]);
if (a != INF)
cout << "OK " << a + P << endl;
else {
rep(i, n + 1) if (dp[i][0] == INF && dp[i][1] == INF && dp[i][2] == INF) {
a = i;
break;
}
cout << "NO " << a << endl;
}
}
}
|
#include <bits/stdc++.h>
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 100000000
using namespace std;
int n, p, t, dp[50][3], P, T, a;
int main() {
while (cin >> n, n) {
rep(i, 50) rep(j, 3) dp[i][j] = INF;
dp[0][0] = 0;
P = 0;
T = 0;
a = INF;
rep(i, n) {
cin >> p >> t;
rep(j, 3) if (dp[i][j] != INF && (j + 2) * P + p <= t - T) dp[i + 1][0] =
min(dp[i + 1][0], dp[i][j] + P + p);
for (int j = 1; j < 3; j++)
if (dp[i][j - 1] != INF && (j + 1) * abs(P - p) <= t - T)
dp[i + 1][j] = min(dp[i + 1][j], dp[i][j - 1] + abs(P - p));
P = p;
T = t;
}
rep(i, 3) a = min(a, dp[n][i]);
if (a != INF)
cout << "OK " << a + P << endl;
else {
rep(i, n + 1) if (dp[i][0] == INF && dp[i][1] == INF && dp[i][2] == INF) {
a = i;
break;
}
cout << "NG " << a << endl;
}
}
}
|
[["-", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6], ["+", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6]]
| 1
| 374
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
struct solver {
//鬚倡岼謇?怙蜿倬?
int n;
int p[55], t[55];
// weapon
int dp
[55]
[5]; // 蠖灘燕蝨ィ隨ャi荳ェ逅?噪菴咲スョ?瑚スヲ荳顔噪豌皮帥謨ー?梧園陦碁ゥカ逧?怙遏ュ霍晉ヲサ
bool init() {
scanf("%d", &n);
if (!n)
return false;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &t[i]);
}
return true;
}
void Min(int &x, int y) {
if (y == -1)
return;
if (x == -1 || y < x)
x = y;
}
void solve() {
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
p[0] = 0;
t[0] = 0;
int failed_place = -1;
for (int i = 0; i <= n; i++) {
bool flag = true;
for (int j = 0; j <= 3; j++)
if (dp[i][j] != -1)
flag = false;
if (flag) {
failed_place = i;
break;
}
/*for(int j = 0; j <= 3; j++)
{
printf("dp[%d][%d]=%d\n",i,j,dp[i][j]);
}*/
for (int j = 0; j <= 3; j++)
if (dp[i][j] != -1) {
int dis = abs(p[i + 1] - p[i]);
int t_dis = t[i + 1] - t[i];
if (t_dis >= dis * (j + 1) && j + 1 <= 3) {
Min(dp[i + 1][j + 1], dp[i][j] + dis);
}
if (p[i] * (j + 1) + p[i + 1] <= t_dis) {
Min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
}
}
if (failed_place != -1) {
printf("NG %d\n", failed_place);
} else {
int ans = -1;
for (int i = 0; i <= 3; i++)
Min(ans, dp[n][i]);
printf("%d\n", ans + p[n]);
}
}
} Pro;
int main() {
while (Pro.init())
Pro.solve();
return 0;
}
|
#include <cstdio>
#include <cstdlib>
#include <cstring>
struct solver {
//鬚倡岼謇?怙蜿倬?
int n;
int p[55], t[55];
// weapon
int dp
[55]
[5]; // 蠖灘燕蝨ィ隨ャi荳ェ逅?噪菴咲スョ?瑚スヲ荳顔噪豌皮帥謨ー?梧園陦碁ゥカ逧?怙遏ュ霍晉ヲサ
bool init() {
scanf("%d", &n);
if (!n)
return false;
for (int i = 1; i <= n; i++) {
scanf("%d%d", &p[i], &t[i]);
}
return true;
}
void Min(int &x, int y) {
if (y == -1)
return;
if (x == -1 || y < x)
x = y;
}
void solve() {
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
p[0] = 0;
t[0] = 0;
int failed_place = -1;
for (int i = 0; i <= n; i++) {
bool flag = true;
for (int j = 0; j <= 3; j++)
if (dp[i][j] != -1)
flag = false;
if (flag) {
failed_place = i;
break;
}
/*for(int j = 0; j <= 3; j++)
{
printf("dp[%d][%d]=%d\n",i,j,dp[i][j]);
}*/
for (int j = 0; j <= 3; j++)
if (dp[i][j] != -1) {
int dis = abs(p[i + 1] - p[i]);
int t_dis = t[i + 1] - t[i];
if (t_dis >= dis * (j + 1) && j + 1 <= 3) {
Min(dp[i + 1][j + 1], dp[i][j] + dis);
}
if (p[i] * (j + 1) + p[i + 1] <= t_dis) {
Min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
}
}
if (failed_place != -1) {
printf("NG %d\n", failed_place);
} else {
int ans = -1;
for (int i = 0; i <= 3; i++)
Min(ans, dp[n][i]);
printf("OK %d\n", ans + p[n]);
}
}
} Pro;
int main() {
while (Pro.init())
Pro.solve();
return 0;
}
|
[["-", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6], ["+", 0, 1, 0, 2, 3, 4, 0, 5, 0, 6]]
| 1
| 499
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
int main() {
const int INF = 1 << 29;
for (int n; scanf("%d", &n), n;) {
vector<pair<int, int>> v(n + 1);
vector<vector<int>> m(n + 1);
for (int i = 0; i <= n; i++) {
if (i)
scanf("%d%d", &v[i].first, &v[i].second);
m[i].resize(4), fill(m[i].begin(), m[i].end(), INF);
}
m[0][0] = 0;
int i = 0, r = INF;
for (; i < n; i++) {
bool x = false;
for (int j = 0; j < 4; j++)
if (m[i][j] < INF) {
int dist = abs(v[i + 1].first - v[i].first),
dt = v[i + 1].second - v[i].second;
bool f, g;
if (f = j < 3 && dist * (j + 1) <= dt)
m[i + 1][j + 1] = min(m[i + 1][j + 1], m[i][j] + dist);
if (g = v[i + 1].first + v[i].first * (j + 1) <= dt)
m[i + 1][1] =
min(m[i + 1][1], m[i][j] + v[i + 1].first + v[i].first);
x = f || g;
}
if (!x) {
printf("NG %d\n", i + 1);
break;
}
}
if (i == n) {
int r = INF;
for (int i = 0; i < 4; i++)
r = min(r, m[n][i] + v[n].first);
printf("OK %d\n", r);
}
}
}
|
#include <algorithm>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <vector>
using namespace std;
int main() {
const int INF = 1 << 29;
for (int n; scanf("%d", &n), n;) {
vector<pair<int, int>> v(n + 1);
vector<vector<int>> m(n + 1);
for (int i = 0; i <= n; i++) {
if (i)
scanf("%d%d", &v[i].first, &v[i].second);
m[i].resize(4), fill(m[i].begin(), m[i].end(), INF);
}
m[0][0] = 0;
int i = 0, r = INF;
for (; i < n; i++) {
bool x = false;
for (int j = 0; j < 4; j++)
if (m[i][j] < INF) {
int dist = abs(v[i + 1].first - v[i].first),
dt = v[i + 1].second - v[i].second;
bool f, g;
if (f = j < 3 && dist * (j + 1) <= dt)
m[i + 1][j + 1] = min(m[i + 1][j + 1], m[i][j] + dist);
if (g = v[i + 1].first + v[i].first * (j + 1) <= dt)
m[i + 1][1] =
min(m[i + 1][1], m[i][j] + v[i + 1].first + v[i].first);
x = x || f || g;
}
if (!x) {
printf("NG %d\n", i + 1);
break;
}
}
if (i == n) {
int r = INF;
for (int i = 0; i < 4; i++)
r = min(r, m[n][i] + v[n].first);
printf("OK %d\n", r);
}
}
}
|
[["+", 0, 1, 0, 11, 12, 16, 31, 16, 31, 22], ["+", 0, 1, 0, 11, 12, 16, 31, 16, 17, 106]]
| 1
| 479
|
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dp[50][4];
int main() {
int n;
while (cin >> n && n) {
vector<int> p(n + 1), t(n + 1);
rep(i, n) cin >> p[i + 1] >> t[i + 1];
rep(i, 50) rep(j, 4) dp[i][j] = INF;
int id = -1;
dp[0][0] = 0;
rep(i, n) {
int d = abs(p[i + 1] - p[i]);
bool flag = true;
rep(j, 4) {
if (dp[i][j] == INF)
continue;
if (j < 3 && d * (j + 1) <= t[i + 1] - t[i]) {
flag = false;
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + d);
}
if (p[i] * j + p[i + 1] <= t[i + 1] - t[i]) {
flag = false;
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
}
if (flag) {
id = i + 1;
break;
}
}
// rep(i, n + 1) {
// rep(j, 4) {
// cout << dp[i][j] << " ";
// }
// cout << endl;
// }
if (id != -1)
cout << "NG " << id << endl;
else {
int ans = INF;
rep(j, 4) { ans = min(ans, dp[n][j] + p[n]); }
cout << "OK " << ans << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
int dp[50][4];
int main() {
int n;
while (cin >> n && n) {
vector<int> p(n + 1), t(n + 1);
rep(i, n) cin >> p[i + 1] >> t[i + 1];
rep(i, 50) rep(j, 4) dp[i][j] = INF;
int id = -1;
dp[0][0] = 0;
rep(i, n) {
int d = abs(p[i + 1] - p[i]);
bool flag = true;
rep(j, 4) {
if (dp[i][j] == INF)
continue;
if (j < 3 && d * (j + 1) <= t[i + 1] - t[i]) {
flag = false;
dp[i + 1][j + 1] = min(dp[i + 1][j + 1], dp[i][j] + d);
}
if (p[i] * (j + 1) + p[i + 1] <= t[i + 1] - t[i]) {
flag = false;
dp[i + 1][1] = min(dp[i + 1][1], dp[i][j] + p[i] + p[i + 1]);
}
}
if (flag) {
id = i + 1;
break;
}
}
if (id != -1)
cout << "NG " << id << endl;
else {
int ans = INF;
rep(j, 4) { ans = min(ans, dp[n][j] + p[n]); }
cout << "OK " << ans << endl;
}
}
return 0;
}
|
[["+", 51, 16, 31, 16, 31, 16, 12, 23, 0, 24], ["+", 31, 16, 31, 16, 12, 23, 0, 16, 17, 72], ["+", 31, 16, 31, 16, 12, 23, 0, 16, 12, 13], ["+", 51, 16, 31, 16, 31, 16, 12, 23, 0, 25]]
| 1
| 454
|
#include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RREP(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define RFOR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define ALL(v) (v).begin(), (v).end()
#define PB(a) push_back(a)
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define DUMP(v) \
REP(aa, (v).size()) { \
cout << v[aa]; \
if (aa != v.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
///(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)///
int n;
int dfs(vvi &dp, vi &p, vi &t, int i, int j) {
if (j == 3)
return INF;
if (dp[i][j] != -1)
return dp[i][j];
if (i == n - 1)
return dp[i][j] = 0;
int ret = INF;
if (t[i + 1] - t[i] >= p[i] * (j + 2) + p[i + 1])
ret = min(ret, dfs(dp, p, t, i + 1, 0) + p[i + 1] + p[i]);
if (t[i + 1] - t[i] >= abs(p[i + 1] - p[i]) * (j + 2))
ret = min(ret, dfs(dp, p, t, i + 1, j + 1) + abs(p[i + 1] - p[i]));
return dp[i][j] = ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> n, n) {
vi p(n), t(n);
REP(i, n) cin >> p[i] >> t[i];
vvi dp(n, vi(3, -1));
if (p[0] > t[0]) {
cout << "NG " << 1 << endl;
} else {
int a = dfs(dp, p, t, 0, 0);
if (a == INF) {
cout << "NG ";
REP(i, n) {
int cnt = 0;
REP(j, 3) {
if (dp[i][j] == INF)
cnt++;
}
if (cnt == 3) {
cout << i + 1 << endl;
}
}
} else
cout << "OK " << a + p[0] + p[n - 1] << endl;
}
}
}
|
#include "bits/stdc++.h"
#define REP(i, n) for (ll i = 0; i < n; ++i)
#define RREP(i, n) for (ll i = n - 1; i >= 0; --i)
#define FOR(i, m, n) for (ll i = m; i < n; ++i)
#define RFOR(i, m, n) for (ll i = n - 1; i >= m; --i)
#define ALL(v) (v).begin(), (v).end()
#define PB(a) push_back(a)
#define UNIQUE(v) v.erase(unique(ALL(v)), v.end());
#define DUMP(v) \
REP(aa, (v).size()) { \
cout << v[aa]; \
if (aa != v.size() - 1) \
cout << " "; \
else \
cout << endl; \
}
#define INF 1000000001ll
#define MOD 1000000007ll
#define EPS 1e-9
const int dx[8] = {1, 1, 0, -1, -1, -1, 0, 1};
const int dy[8] = {0, 1, 1, 1, 0, -1, -1, -1};
using namespace std;
typedef long long ll;
typedef vector<int> vi;
typedef vector<ll> vl;
typedef vector<vi> vvi;
typedef vector<vl> vvl;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
ll max(ll a, int b) { return max(a, ll(b)); }
ll max(int a, ll b) { return max(ll(a), b); }
ll min(ll a, int b) { return min(a, ll(b)); }
ll min(int a, ll b) { return min(ll(a), b); }
///(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)(?´????????`)///
int n;
int dfs(vvi &dp, vi &p, vi &t, int i, int j) {
if (j == 3)
return INF;
if (dp[i][j] != -1)
return dp[i][j];
if (i == n - 1)
return dp[i][j] = 0;
int ret = INF;
if (t[i + 1] - t[i] >= p[i] * (j + 2) + p[i + 1])
ret = min(ret, dfs(dp, p, t, i + 1, 0) + p[i + 1] + p[i]);
if (t[i + 1] - t[i] >= abs(p[i + 1] - p[i]) * (j + 2))
ret = min(ret, dfs(dp, p, t, i + 1, j + 1) + abs(p[i + 1] - p[i]));
return dp[i][j] = ret;
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
while (cin >> n, n) {
vi p(n), t(n);
REP(i, n) cin >> p[i] >> t[i];
vvi dp(n, vi(3, -1));
if (p[0] > t[0]) {
cout << "NG " << 1 << endl;
} else {
int a = dfs(dp, p, t, 0, 0);
if (a == INF) {
cout << "NG ";
REP(i, n) {
int cnt = 0;
REP(j, 3) {
if (dp[i][j] == -1)
cnt++;
}
if (cnt == 3) {
cout << i + 1 << endl;
break;
}
}
} else
cout << "OK " << a + p[0] + p[n - 1] << endl;
}
}
}
|
[["-", 0, 9, 0, 57, 15, 339, 51, 16, 12, 22], ["+", 0, 9, 0, 57, 15, 339, 51, 16, 12, 13], ["+", 8, 9, 0, 57, 64, 9, 0, 1, 0, 35], ["+", 8, 9, 0, 57, 64, 9, 0, 93, 0, 94]]
| 1
| 705
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
// dp[i][j] := i??????????¢¨????????§?????????,
// j????¢¨???????????£???????????¨?????????????????¢
int dp[50][5];
void solve(const int n, const vector<int> &p, const vector<int> &t) {
for (int i = 0; i < 50; ++i)
for (int j = 0; j < 5; ++j)
dp[i][j] = INF;
dp[0][0] = 0; // ?????????????¨????
for (int i = 1; i <= n + 1; ++i) { // ?????????
for (int j = 0; j <= 3; ++j) { // ?????¨????¢¨????????°
if (dp[i - 1][j] == INF)
continue;
// ???????????????????????????
{
int dist = p[i - 1] + p[i]; // ?????¢
int time = p[i - 1] * (j + 1) + p[i]; // ??????
if (time <= (t[i] - t[i - 1])) { // ????????????
dp[i][1] = min(dp[i][j], dp[i - 1][j] + dist);
}
}
// ??????????????????
{
if (j == 3)
continue;
int dist = abs(p[i] - p[i - 1]); // ?????¢
int time = abs(p[i] - p[i - 1]) * (j + 1); // ??????
if (time <= (t[i] - t[i - 1])) { // ????????????
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + dist);
}
}
}
}
int ans = INF;
for (int i = 0; i < 4; ++i)
ans = min(ans, dp[n + 1][i]);
if (ans == INF) {
// ???????????§?????????????????????
int idx = 0;
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= 3; ++j) {
if (dp[i][j] != INF)
idx = max(idx, i + 1);
}
cout << "NG " << idx << endl;
} else {
cout << "OK " << ans << endl;
}
}
int main(void) {
while (1) {
int n;
cin >> n;
if (n == 0)
break;
vector<int> p(n + 2), t(n + 2);
p[0] = t[0] = 0; // ???????????????????????????
for (int i = 1; i < n + 1; ++i)
cin >> p[i] >> t[i];
p[n + 1] = 0, t[n + 1] = INF; // ???????????????
solve(n, p, t);
}
return 0;
}
|
/*
* 1645025T ????±± ??????
*/
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
// dp[i][j] := i??????????¢¨????????§?????????,
// j????¢¨???????????£???????????¨?????????????????¢
int dp[50][5];
void solve(const int n, const vector<int> &p, const vector<int> &t) {
for (int i = 0; i < 50; ++i)
for (int j = 0; j < 5; ++j)
dp[i][j] = INF;
dp[0][0] = 0; // ?????????????¨????
for (int i = 1; i <= n + 1; ++i) { // ?????????
for (int j = 0; j <= 3; ++j) { // ?????¨????¢¨????????°
if (dp[i - 1][j] == INF)
continue;
// ???????????????????????????
{
int dist = p[i - 1] + p[i]; // ?????¢
int time = p[i - 1] * (j + 1) + p[i]; // ??????
if (time <= (t[i] - t[i - 1])) { // ????????????
dp[i][1] = min(dp[i][1], dp[i - 1][j] + dist);
}
}
// ??????????????????
{
if (j == 3)
continue;
int dist = abs(p[i] - p[i - 1]); // ?????¢
int time = abs(p[i] - p[i - 1]) * (j + 1); // ??????
if (time <= (t[i] - t[i - 1])) { // ????????????
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + dist);
}
}
}
}
int ans = INF;
for (int i = 0; i < 4; ++i)
ans = min(ans, dp[n + 1][i]);
if (ans == INF) {
// ???????????§?????????????????????
int idx = 0;
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= 3; ++j) {
if (dp[i][j] != INF)
idx = max(idx, i + 1);
}
cout << "NG " << idx << endl;
} else {
cout << "OK " << ans << endl;
}
}
int main(void) {
while (1) {
int n;
cin >> n;
if (n == 0)
break;
vector<int> p(n + 2), t(n + 2);
p[0] = t[0] = 0; // ???????????????????????????
for (int i = 1; i < n + 1; ++i)
cin >> p[i] >> t[i];
p[n + 1] = 0, t[n + 1] = INF; // ???????????????
solve(n, p, t);
}
return 0;
}
|
[["-", 12, 2, 3, 4, 0, 69, 341, 342, 0, 22], ["+", 12, 2, 3, 4, 0, 69, 341, 342, 0, 13]]
| 1
| 599
|
#include <algorithm>
#include <cstdio>
void chmin(int &a, int b) { a = std::min(a, b); }
int p[50], t[50];
int dp[50][5];
const int INF = 1 << 30;
int main() {
int N;
while (1) {
scanf("%d", &N);
if (N == 0)
return 0;
for (int i = 0; i < N; i++) {
scanf("%d%d", &p[i + 1], &t[i + 1]);
}
for (int i = 0; i <= N; i++) {
for (int k = 0; k <= 3; k++) {
dp[i][k] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
bool ok = false;
for (int k = 0; k <= 3; k++) {
if (dp[i][k] == INF)
continue;
int diff_p = abs(p[i + 1] - p[i]);
int diff_t = t[i + 1] - t[i];
// テァツ崢エテヲツ篠・テァツァツサテ・ツ仰陛」ツ?凖」ツつ?
if (k < 3 && diff_p * (k + 1) <= diff_t) {
chmin(dp[i + 1][k + 1], dp[i][k] + diff_p);
ok = true;
}
// テ、ツクツ?ヲツ猟ヲテ・ツョツカテ」ツ?ォテ・ツクツーテ」ツつ?
if (p[i + 1] + p[i] * (k + 1) <= diff_t) {
chmin(dp[i + 1][1], dp[i][k] + p[i] + p[i + 1]);
ok = true;
}
}
if (!ok) {
printf("NG %d\n", i + 1);
break;
}
}
int ans = INF;
for (int i = 0; i <= 3; i++)
chmin(ans, dp[N][i] + p[N]);
printf("OK %d\n", ans);
}
}
|
#include <algorithm>
#include <cstdio>
void chmin(int &a, int b) { a = std::min(a, b); }
int p[50], t[50];
int dp[50][5];
const int INF = 1 << 30;
int main() {
int N;
while (1) {
scanf("%d", &N);
if (N == 0)
return 0;
for (int i = 0; i < N; i++) {
scanf("%d%d", &p[i + 1], &t[i + 1]);
}
for (int i = 0; i <= N; i++) {
for (int k = 0; k <= 3; k++) {
dp[i][k] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
bool ok = false;
for (int k = 0; k <= 3; k++) {
if (dp[i][k] == INF)
continue;
int diff_p = abs(p[i + 1] - p[i]);
int diff_t = t[i + 1] - t[i];
// テァツ崢エテヲツ篠・テァツァツサテ・ツ仰陛」ツ?凖」ツつ?
if (k < 3 && diff_p * (k + 1) <= diff_t) {
chmin(dp[i + 1][k + 1], dp[i][k] + diff_p);
ok = true;
}
// テ、ツクツ?ヲツ猟ヲテ・ツョツカテ」ツ?ォテ・ツクツーテ」ツつ?
if (p[i + 1] + p[i] * (k + 1) <= diff_t) {
chmin(dp[i + 1][1], dp[i][k] + p[i] + p[i + 1]);
ok = true;
}
}
if (!ok) {
printf("NG %d\n", i + 1);
break;
}
}
int ans = INF;
for (int i = 0; i <= 3; i++)
chmin(ans, dp[N][i] + p[N]);
if (ans < INF)
printf("OK %d\n", ans);
}
}
|
[["+", 8, 9, 0, 52, 8, 9, 0, 57, 0, 121], ["+", 0, 52, 8, 9, 0, 57, 15, 339, 0, 24], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 31, 22], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 17, 18], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 12, 22], ["+", 0, 52, 8, 9, 0, 57, 15, 339, 0, 25]]
| 1
| 442
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
vector<int> p(n), t(n);
for (int i = 0; i < n; ++i) {
cin >> p[i] >> t[i];
}
int INF = 1000000000;
vector<vector<int>> dp(n, vector<int>(4, INF));
if (p[0] > t[0]) {
cout << "NG 1" << endl;
continue;
}
dp[0][1] = p[0];
bool f = true;
for (int i = 1; i < n; ++i) {
bool g = true;
for (int j = 0; j < 4; ++j) {
if (dp[i - 1][j] == INF)
continue;
int t_diff = t[i] - t[i - 1];
if (j + 1 <= 3 && abs(p[i] - p[i - 1]) * (j + 1) <= t_diff) {
g = false;
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + abs(p[i] - p[i - 1]));
}
if (p[i] + p[i - 1] * (j + 1) <= t_diff) {
g = false;
dp[i][1] = min(dp[i][1], dp[i - 1][j] + p[i] + p[i - 1]);
}
}
if (g) {
cout << "NG " << i + 1 << endl;
f = false;
}
}
if (f) {
int ans = INF;
for (int i = 0; i < 4; ++i) {
ans = min(ans, dp[n - 1][i] + p[n - 1]);
}
cout << "OK " << ans << endl;
}
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main() {
int n;
while (cin >> n, n) {
vector<int> p(n), t(n);
for (int i = 0; i < n; ++i) {
cin >> p[i] >> t[i];
}
int INF = 1000000000;
vector<vector<int>> dp(n, vector<int>(4, INF));
if (p[0] > t[0]) {
cout << "NG 1" << endl;
continue;
}
dp[0][1] = p[0];
bool f = true;
for (int i = 1; i < n; ++i) {
bool g = true;
for (int j = 1; j < 4; ++j) {
if (dp[i - 1][j] == INF)
continue;
int t_diff = t[i] - t[i - 1];
if (j + 1 <= 3 && abs(p[i] - p[i - 1]) * (j + 1) <= t_diff) {
g = false;
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + abs(p[i] - p[i - 1]));
}
if (p[i] + p[i - 1] * (j + 1) <= t_diff) {
g = false;
dp[i][1] = min(dp[i][1], dp[i - 1][j] + p[i] + p[i - 1]);
}
}
if (g) {
cout << "NG " << i + 1 << endl;
f = false;
break;
}
}
if (f) {
int ans = INF;
for (int i = 0; i < 4; ++i) {
ans = min(ans, dp[n - 1][i] + p[n - 1]);
}
cout << "OK " << ans << endl;
}
}
return 0;
}
|
[["-", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 57, 64, 9, 0, 1, 0, 35], ["+", 8, 9, 0, 57, 64, 9, 0, 93, 0, 94]]
| 1
| 448
|
#include "bits/stdc++.h"
using namespace std;
const int INF = numeric_limits<int>::max() / 2;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while (cin >> n, n) {
vector<int> p(n + 1, 0), t(n + 1, 0);
vector<vector<int>> dp(n + 1, vector<int>(5, INF));
dp[0][0] = 0;
bool flag = false;
int idx = 0;
for (int i = 1; i <= n; i++) {
bool update = false;
cin >> p[i] >> t[i];
for (int j = 0; j <= 2; j++) {
if (t[i] - t[i - 1] < p[i - 1] * (j + 2) + p[i])
continue;
if (dp[i - 1][j] == INF)
continue;
dp[i][0] = min(dp[i][0], dp[i - 1][j] + p[i - 1] + p[i]);
update = true;
}
for (int j = 0; j <= 2; j++) {
int dif = abs(p[i] - p[i - 1]);
if (t[i] - t[i - 1] < dif * (j + 2))
continue;
if (dp[i - 1][j] == INF)
continue;
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + dif);
// cout<<i<<" "<<j<<" "<<dp[i][j+1]<<endl;
update = true;
}
if (!update) {
flag = true;
idx = max(idx, i);
}
}
if (flag) {
cout << "NG " << idx << endl;
continue;
}
int res = INF;
for (int j = 0; j < 3; j++) {
res = min(res, dp[n][j] + p[n]);
}
cout << "OK " << res << endl;
}
}
|
#include "bits/stdc++.h"
using namespace std;
const int INF = numeric_limits<int>::max() / 2;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n;
while (cin >> n, n) {
vector<int> p(n + 1, 0), t(n + 1, 0);
// dp[i][j]:= i番目の風船をj個積載した状態で取得する時の最小移動距離
vector<vector<int>> dp(n + 1, vector<int>(5, INF));
dp[0][0] = 0;
bool flag = false;
int idx = INF;
for (int i = 1; i <= n; i++) {
bool update = false;
cin >> p[i] >> t[i];
for (int j = 0; j <= 2; j++) {
if (t[i] - t[i - 1] < p[i - 1] * (j + 2) + p[i])
continue;
if (dp[i - 1][j] == INF)
continue;
dp[i][0] = min(dp[i][0], dp[i - 1][j] + p[i - 1] + p[i]);
update = true;
}
for (int j = 0; j < 2; j++) {
int dif = abs(p[i] - p[i - 1]);
if (t[i] - t[i - 1] < dif * (j + 2))
continue;
if (dp[i - 1][j] == INF)
continue;
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + dif);
// cout<<i<<" "<<j<<" "<<dp[i][j+1]<<endl;
update = true;
}
if (!update) {
flag = true;
idx = min(idx, i);
}
}
if (flag) {
cout << "NG " << idx << endl;
continue;
}
int res = INF;
for (int j = 0; j < 3; j++) {
res = min(res, dp[n][j] + p[n]);
}
cout << "OK " << res << endl;
}
}
|
[["-", 0, 52, 8, 9, 0, 43, 49, 50, 51, 13], ["+", 0, 52, 8, 9, 0, 43, 49, 50, 51, 22], ["-", 0, 7, 8, 9, 0, 7, 15, 16, 17, 19], ["+", 0, 7, 8, 9, 0, 7, 15, 16, 17, 18], ["-", 64, 9, 0, 1, 0, 11, 12, 2, 63, 22], ["+", 64, 9, 0, 1, 0, 11, 12, 2, 63, 22]]
| 1
| 469
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> pi;
#define MK make_pair
#define F first
#define S second
int dp[100][4];
pi s[100] = {};
bool search(int n) {
bool j = false;
int t = s[n].F;
int w = s[n].S;
int td = s[n + 1].F;
int wd = s[n + 1].S;
if (dp[n][0] != -1 && abs(wd - w) * 2 <= td - t) {
j = true;
dp[n + 1][1] = dp[n][0] + abs(wd - w);
}
if (dp[n][0] != -1 && w * 2 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][0] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][0] + w + wd, dp[n + 1][0]);
}
}
if (dp[n][1] != -1 && abs(wd - w) * 3 <= td - t) {
j = true;
dp[n + 1][2] = dp[n][1] + abs(wd - w);
}
if (dp[n][1] != -1 && w * 3 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][1] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][1] + w + wd, dp[n + 1][0]);
}
}
if (dp[n][2] != -1 && w * 4 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][2] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][2] + w + wd, dp[n + 1][0]);
}
}
return j;
}
int main() {
while (1) {
fill(&dp[0][0], &dp[99][4], -1);
dp[0][0] = 0;
fill(s, s + 100, MK(0, 0));
int n;
cin >> n;
if (n == 0) {
break;
}
int w = 0;
for (int i = 1; i <= n; i++) {
cin >> s[i].S >> s[i].F;
if (i == n) {
w = s[i].S;
}
}
int ans = -1;
for (int i = 0; i < n; i++) {
if (!search(i)) {
ans = i;
break;
}
}
/*
for(int i=0;i<=n;i++){
for(int t=0;t<3;t++){
cout<<dp[i][t]<<" ";
}
cout<<endl;
}
*/
if (ans != -1) {
cout << "NG " << ans + 1 << endl;
continue;
}
int dis;
if (dp[n][0] != -1) {
dis = dp[n][0] + w;
}
if (dp[n][1] != -1) {
dis = min(dis, dp[n][1] + w);
}
if (dp[n][2] != -1) {
dis = min(dis, dp[n][2] + w);
}
cout << "OK " << dis << endl;
}
return 0;
}
|
#include <algorithm>
#include <cassert>
#include <cmath>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <stack>
#include <string>
#include <vector>
using namespace std;
typedef pair<int, int> pi;
#define MK make_pair
#define F first
#define S second
int dp[100][4];
pi s[100] = {};
bool search(int n) {
bool j = false;
int t = s[n].F;
int w = s[n].S;
int td = s[n + 1].F;
int wd = s[n + 1].S;
if (dp[n][0] != -1 && abs(wd - w) * 2 <= td - t) {
j = true;
dp[n + 1][1] = dp[n][0] + abs(wd - w);
}
if (dp[n][0] != -1 && w * 2 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][0] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][0] + w + wd, dp[n + 1][0]);
}
}
if (dp[n][1] != -1 && abs(wd - w) * 3 <= td - t) {
j = true;
dp[n + 1][2] = dp[n][1] + abs(wd - w);
}
if (dp[n][1] != -1 && w * 3 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][1] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][1] + w + wd, dp[n + 1][0]);
}
}
if (dp[n][2] != -1 && w * 4 + wd <= td - t) {
j = true;
if (dp[n + 1][0] == -1) {
dp[n + 1][0] = dp[n][2] + w + wd;
} else {
dp[n + 1][0] = min(dp[n][2] + w + wd, dp[n + 1][0]);
}
}
return j;
}
int main() {
while (1) {
fill(&dp[0][0], &dp[99][4], -1);
dp[0][0] = 0;
fill(s, s + 100, MK(0, 0));
int n;
cin >> n;
if (n == 0) {
break;
}
int w = 0;
for (int i = 1; i <= n; i++) {
cin >> s[i].S >> s[i].F;
if (i == n) {
w = s[i].S;
}
}
int ans = -1;
for (int i = 0; i < n; i++) {
if (!search(i)) {
ans = i;
break;
}
}
/*
for(int i=0;i<=n;i++){
for(int t=0;t<3;t++){
cout<<dp[i][t]<<" ";
}
cout<<endl;
}
*/
if (ans != -1) {
cout << "NG " << ans + 1 << endl;
continue;
}
int dis = 1e9;
if (dp[n][0] != -1) {
dis = dp[n][0] + w;
}
if (dp[n][1] != -1) {
dis = min(dis, dp[n][1] + w);
}
if (dp[n][2] != -1) {
dis = min(dis, dp[n][2] + w);
}
cout << "OK " << dis << endl;
}
return 0;
}
|
[["+", 0, 52, 8, 9, 0, 43, 49, 50, 0, 32], ["+", 0, 52, 8, 9, 0, 43, 49, 50, 51, 13]]
| 1
| 842
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct state {
int d, n, k;
state(int a, int b, int c) : d(a), n(b), k(c) {}
bool operator<(const state &s) const { return d > s.d; }
};
int main() {
int N;
while (cin >> N && N != 0) {
vector<pair<int, int>> balloons(N + 1);
balloons[0] = make_pair(0, 0);
for (int i = 1; i <= N; i++) {
cin >> balloons[i].first >> balloons[i].second;
}
static const int INF = 10000000;
vector<vector<int>> dist(N + 1, vector<int>(4, INF));
priority_queue<state> q;
q.push(state(0, 0, 0));
dist[0][0] = 0;
int ans = 0;
while (!q.empty()) {
const int d = q.top().d;
const int n = q.top().n;
const int k = q.top().k;
q.pop();
ans = max(ans, n);
const int t = balloons[n].second;
if (n == N) {
cout << "YES " << d + balloons[n].first << endl;
goto NEXT;
}
if (k < 3) {
// go to (n+1)-th balloon directly
const int dd = abs(balloons[n + 1].first - balloons[n].first);
const int tt = dd * (k + 1);
if (t + tt <= balloons[n + 1].second && d + dd < dist[n + 1][k + 1]) {
dist[n + 1][k + 1] = d + dd;
q.push(state(d + dd, n + 1, k + 1));
}
}
// go home and go to (n+1)-th balloon
const int dd = balloons[n].first + balloons[n + 1].first;
const int tt = balloons[n].first * (k + 1) + balloons[n + 1].first;
if (t + tt <= balloons[n + 1].second && d + dd < dist[n + 1][1]) {
dist[n + 1][1] = d + dd;
q.push(state(d + dd, n + 1, 1));
}
}
cout << "NG " << ans + 1 << endl;
NEXT:;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
struct state {
int d, n, k;
state(int a, int b, int c) : d(a), n(b), k(c) {}
bool operator<(const state &s) const { return d > s.d; }
};
int main() {
int N;
while (cin >> N && N != 0) {
vector<pair<int, int>> balloons(N + 1);
balloons[0] = make_pair(0, 0);
for (int i = 1; i <= N; i++) {
cin >> balloons[i].first >> balloons[i].second;
}
static const int INF = 10000000;
vector<vector<int>> dist(N + 1, vector<int>(4, INF));
priority_queue<state> q;
q.push(state(0, 0, 0));
dist[0][0] = 0;
int ans = 0;
while (!q.empty()) {
const int d = q.top().d;
const int n = q.top().n;
const int k = q.top().k;
q.pop();
ans = max(ans, n);
const int t = balloons[n].second;
if (n == N) {
cout << "OK " << d + balloons[n].first << endl;
goto NEXT;
}
if (k < 3) {
// go to (n+1)-th balloon directly
const int dd = abs(balloons[n + 1].first - balloons[n].first);
const int tt = dd * (k + 1);
if (t + tt <= balloons[n + 1].second && d + dd < dist[n + 1][k + 1]) {
dist[n + 1][k + 1] = d + dd;
q.push(state(d + dd, n + 1, k + 1));
}
}
// go home and go to (n+1)-th balloon
const int dd = balloons[n].first + balloons[n + 1].first;
const int tt = balloons[n].first * (k + 1) + balloons[n + 1].first;
if (t + tt <= balloons[n + 1].second && d + dd < dist[n + 1][1]) {
dist[n + 1][1] = d + dd;
q.push(state(d + dd, n + 1, 1));
}
}
cout << "NG " << ans + 1 << endl;
NEXT:;
}
return 0;
}
|
[["-", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6], ["+", 0, 16, 31, 16, 31, 16, 12, 5, 0, 6]]
| 1
| 560
|
#include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;
class State {
public:
int n, k, d;
State(int n, int k, int d) : n(n), k(k), d(d) {}
bool operator<(const State &s) const {
if (n != s.n)
return n > s.n;
return d > s.d;
}
};
int N, p[41], t[41];
pair<bool, int> solve() {
bool vis[40][4] = {0};
int m = 0, res = (1 << 24);
priority_queue<State> q;
q.push(State(0, 0, 0));
while (!q.empty()) {
State s = q.top();
q.pop();
m = max(m, s.n);
if (s.n == N) {
res = min(res, s.d + p[s.n]);
continue;
}
if (vis[s.n][s.k])
continue;
vis[s.n][s.k] = true;
int nt = (s.k + 1) * abs(p[s.n + 1] - p[s.n]) + t[s.n];
if (nt <= t[s.n + 1] && s.k < 3)
q.push(State(s.n + 1, s.k + 1, s.d + abs(p[s.n + 1] - p[s.n])));
nt = (s.k + 1) * p[s.n] + p[s.n + 1] + t[s.n];
if (nt <= t[s.n + 1])
q.push(State(s.n + 1, 1, s.d + p[s.n + 1] + p[s.n]));
}
if (m == N)
return make_pair(true, res);
return make_pair(false, m + 1);
}
int main() {
while (cin >> N, N) {
p[0] = t[0] = 0;
for (int i = 1; i <= N; i++)
cin >> p[i] >> t[i];
pair<bool, int> res = solve();
cout << (res.first ? "OK" : "NO") << " ";
cout << res.second << endl;
}
}
|
#include <cstdlib>
#include <iostream>
#include <queue>
using namespace std;
class State {
public:
int n, k, d;
State(int n, int k, int d) : n(n), k(k), d(d) {}
bool operator<(const State &s) const {
if (n != s.n)
return n > s.n;
return d > s.d;
}
};
int N, p[41], t[41];
pair<bool, int> solve() {
bool vis[40][4] = {0};
int m = 0, res = (1 << 24);
priority_queue<State> q;
q.push(State(0, 0, 0));
while (!q.empty()) {
State s = q.top();
q.pop();
m = max(m, s.n);
if (s.n == N) {
res = min(res, s.d + p[s.n]);
continue;
}
if (vis[s.n][s.k])
continue;
vis[s.n][s.k] = true;
int nt = (s.k + 1) * abs(p[s.n + 1] - p[s.n]) + t[s.n];
if (nt <= t[s.n + 1] && s.k < 3)
q.push(State(s.n + 1, s.k + 1, s.d + abs(p[s.n + 1] - p[s.n])));
nt = (s.k + 1) * p[s.n] + p[s.n + 1] + t[s.n];
if (nt <= t[s.n + 1])
q.push(State(s.n + 1, 1, s.d + p[s.n + 1] + p[s.n]));
}
if (m == N)
return make_pair(true, res);
return make_pair(false, m + 1);
}
int main() {
while (cin >> N, N) {
p[0] = t[0] = 0;
for (int i = 1; i <= N; i++)
cin >> p[i] >> t[i];
pair<bool, int> res = solve();
cout << (res.first ? "OK" : "NG") << " ";
cout << res.second << endl;
}
}
|
[["-", 31, 16, 12, 23, 0, 41, 75, 5, 0, 6], ["+", 31, 16, 12, 23, 0, 41, 75, 5, 0, 6]]
| 1
| 552
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RREP(i, x) for (int i = (x); i >= 0; i--)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
// FILE *in = freopen("input.txt", "r", stdin);
// FILE *out = freopen("output.txt", "w", stdout);
void solution(int iMax) {
vector<ll> shorter(4, -1);
bool ng = false;
// 初期値
shorter[0] = 0;
uint currentPos = 0;
ull currentTime = 0;
for (int i = 0; i < iMax; ++i) {
vector<ull> nextTotalMove[4];
uint p;
ull t;
cin >> p;
cin >> t;
// i-1の時の最短のパターン達からそれぞれ、一回戻るものと直接取りに行く場合を考える
for (int k = 0; k < 4; ++k) {
if (shorter[k] == -1)
continue;
// 一回家に戻る場合
ull returnTime = currentPos * (k + 1) + p;
if (returnTime + currentTime < t) {
nextTotalMove[1].push_back(shorter[k] + currentPos + p);
}
// そのまま取りに行く場合
if (k + 1 <= 3) {
ull directTime = std::abs<int>(currentPos - p) * (k + 1);
if (directTime + currentTime <= t) {
nextTotalMove[k + 1].push_back(shorter[k] +
std::abs<int>(currentPos - p));
}
}
}
// 今回の考えられるパターンの中でそれぞれ持ってる風船の個数ごとに最短を更新
for (int k = 0; k < 4; ++k) {
if (nextTotalMove[k].empty()) {
shorter[k] = -1;
} else {
shorter[k] =
*std::min_element(nextTotalMove[k].begin(), nextTotalMove[k].end());
}
}
if (!ng) {
// もしどうにも取れない風船が出てきたら
int k;
for (k = 0; k < 4; ++k) {
if (shorter[k] != -1)
break;
}
if (k == 4) {
cout << "NG " << i + 1 << endl;
ng = true;
}
}
currentPos = p;
currentTime = t;
}
ll shortest = 0x7fffffff;
for (int k = 0; k < 4; ++k) {
if (shorter[k] == -1)
continue;
shortest = std::min(shorter[k], shortest);
}
if (!ng) {
cout << "OK " << shortest + currentPos << endl;
}
}
int main() {
while (true) {
int iMax;
cin >> iMax;
if (iMax == 0)
break;
solution(iMax);
}
return 0;
}
|
#include <algorithm>
#include <bitset>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <deque>
#include <functional>
#include <iomanip>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <memory.h>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <valarray>
#include <vector>
using namespace std;
typedef long long ll;
typedef unsigned int uint;
typedef unsigned char uchar;
typedef unsigned long long ull;
#define REP(i, x) for (int i = 0; i < (int)(x); i++)
#define FOR(i, c) \
for (__typeof((c).begin()) i = (c).begin(); i != (c).end(); i++)
#define RREP(i, x) for (int i = (x); i >= 0; i--)
#define RFOR(i, c) \
for (__typeof((c).rbegin()) i = (c).rbegin(); i != (c).rend(); i++)
// FILE *in = freopen("input.txt", "r", stdin);
// FILE *out = freopen("output.txt", "w", stdout);
void solution(int iMax) {
vector<ll> shorter(4, -1);
bool ng = false;
// 初期値
shorter[0] = 0;
uint currentPos = 0;
ull currentTime = 0;
for (int i = 0; i < iMax; ++i) {
vector<ull> nextTotalMove[4];
uint p;
ull t;
cin >> p;
cin >> t;
// i-1の時の最短のパターン達からそれぞれ、一回戻るものと直接取りに行く場合を考える
for (int k = 0; k < 4; ++k) {
if (shorter[k] == -1)
continue;
// 一回家に戻る場合
ull returnTime = currentPos * (k + 1) + p;
if (returnTime + currentTime <= t) {
nextTotalMove[1].push_back(shorter[k] + currentPos + p);
}
// そのまま取りに行く場合
if (k + 1 <= 3) {
ull directTime = std::abs<int>(currentPos - p) * (k + 1);
if (directTime + currentTime <= t) {
nextTotalMove[k + 1].push_back(shorter[k] +
std::abs<int>(currentPos - p));
}
}
}
// 今回の考えられるパターンの中でそれぞれ持ってる風船の個数ごとに最短を更新
for (int k = 0; k < 4; ++k) {
if (nextTotalMove[k].empty()) {
shorter[k] = -1;
} else {
shorter[k] =
*std::min_element(nextTotalMove[k].begin(), nextTotalMove[k].end());
}
}
if (!ng) {
// もしどうにも取れない風船が出てきたら
int k;
for (k = 0; k < 4; ++k) {
if (shorter[k] != -1)
break;
}
if (k == 4) {
cout << "NG " << i + 1 << endl;
ng = true;
}
}
currentPos = p;
currentTime = t;
}
ll shortest = 0x7fffffff;
for (int k = 0; k < 4; ++k) {
if (shorter[k] == -1)
continue;
shortest = std::min(shorter[k], shortest);
}
if (!ng) {
cout << "OK " << shortest + currentPos << endl;
}
}
int main() {
while (true) {
int iMax;
cin >> iMax;
if (iMax == 0)
break;
solution(iMax);
}
return 0;
}
|
[["-", 8, 9, 0, 57, 15, 339, 51, 16, 17, 18], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 17, 19]]
| 1
| 564
|
#include <algorithm>
#include <cmath>
#include <iostream>
#define INF 1000000
using namespace std;
int main(void) {
int n;
int ptime, ctimes;
int pdis, cdis;
while (cin >> n, n) {
int dp[41][3];
for (int i = 0; i < 41; i++)
for (int j = 0; j < 3; j++)
dp[i][j] = INF;
dp[0][0] = 0;
cin >> pdis >> ptime;
if (pdis <= ptime)
dp[1][0] = pdis;
cdis = pdis, ctimes = ptime;
for (int i = 2; i <= n; i++) {
cin >> cdis >> ctimes;
for (int j = 0; j < 2; j++) {
if (abs(cdis - pdis) * (j + 2.0) <= (ctimes - ptime))
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + abs(cdis - pdis));
}
for (int j = 0; j < 3; j++) {
if ((j + 2) * pdis + cdis < (ctimes - ptime))
dp[i][0] = min(dp[i][0], dp[i - 1][j] + cdis + pdis);
}
pdis = cdis;
ptime = ctimes;
}
int ans = INF;
for (int i = 0; i < 3; i++)
ans = min(ans, dp[n][i]);
if (ans != INF) {
ans += cdis;
cout << "OK " << ans << endl;
} else {
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 3; j++)
if (dp[i][j] != INF)
cout << "NG " << i + 1 << endl, j = 4, i = -1;
}
/* for(int i=0;i<=4;i++){
for(int j=0;j<3;j++)
cout << (j?" ":"") << dp[i][j];
cout << endl;
}*/
}
return 0;
}
|
#include <algorithm>
#include <cmath>
#include <iostream>
#define INF 1000000
using namespace std;
int main(void) {
int n;
int ptime, ctimes;
int pdis, cdis;
while (cin >> n, n) {
int dp[41][3];
for (int i = 0; i < 41; i++)
for (int j = 0; j < 3; j++)
dp[i][j] = INF;
dp[0][0] = 0;
cin >> pdis >> ptime;
if (pdis <= ptime)
dp[1][0] = pdis;
cdis = pdis, ctimes = ptime;
for (int i = 2; i <= n; i++) {
cin >> cdis >> ctimes;
for (int j = 0; j < 2; j++) {
if (abs(cdis - pdis) * (j + 2.0) <= (ctimes - ptime))
dp[i][j + 1] = min(dp[i][j + 1], dp[i - 1][j] + abs(cdis - pdis));
}
for (int j = 0; j < 3; j++) {
if ((j + 2) * pdis + cdis <= (ctimes - ptime))
dp[i][0] = min(dp[i][0], dp[i - 1][j] + cdis + pdis);
}
pdis = cdis;
ptime = ctimes;
}
int ans = INF;
for (int i = 0; i < 3; i++)
ans = min(ans, dp[n][i]);
if (ans != INF) {
ans += cdis;
cout << "OK " << ans << endl;
} else {
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j < 3; j++)
if (dp[i][j] != INF)
cout << "NG " << i + 1 << endl, j = 4, i = -1;
}
/* for(int i=0;i<=4;i++){
for(int j=0;j<3;j++)
cout << (j?" ":"") << dp[i][j];
cout << endl;
}*/
}
return 0;
}
|
[["-", 8, 9, 0, 57, 15, 339, 51, 16, 17, 18], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 17, 19]]
| 1
| 429
|
loop do
n = gets.to_i
break if n == 0
bs = n.times.map{gets.split.map(&:to_i)}
bs.push([0,50000])
dp = Array.new(n+1).map{Array.new(4, Float::INFINITY)}
if bs[0][1] < bs[0][0]
puts "NG 1"
next
end
pos = bs[0][0]
time = bs[0][1]
dp[0][0] = pos
bl = false
1.upto(n-1) do |i|
bl = false
b = bs[i]
dist = (pos - b[0]).abs
dt = (time - b[1]).abs
0.upto(3) do |j|
next if dp[i-1][j] == Float::INFINITY
if (pos * (j + 2)) + b[0] <= dt
bl = true
dp[i][0] = dp[i-1][j] + pos + b[0] if dp[i-1][j] + pos + b[0] < dp[i][0]
end
if dist * (j + 2) <= dt && j < 3
bl = true
dp[i][j+1] = dp[i-1][j] + dist if dp[i-1][j] + dist < dp[i][j+1]
end
end
pos = b[0]
time = b[1]
if !bl
puts "NG #{i+1}"
break
end
end
0.upto(3) do |i|
dp[n][i] = dp[n-1][i] + bs[n-1][0]
end
puts "OK #{dp[n].min}" if bl
end
|
loop do
n = gets.to_i
break if n == 0
bs = n.times.map{gets.split.map(&:to_i)}
bs.push([0,50000])
dp = Array.new(n+1).map{Array.new(4, Float::INFINITY)}
if bs[0][1] < bs[0][0]
puts "NG 1"
next
end
pos = bs[0][0]
time = bs[0][1]
dp[0][0] = pos
bl = true
1.upto(n-1) do |i|
bl = false
b = bs[i]
dist = (pos - b[0]).abs
dt = (time - b[1]).abs
0.upto(3) do |j|
next if dp[i-1][j] == Float::INFINITY
if (pos * (j + 2)) + b[0] <= dt
bl = true
dp[i][0] = dp[i-1][j] + pos + b[0] if dp[i-1][j] + pos + b[0] < dp[i][0]
end
if dist * (j + 2) <= dt && j < 2
bl = true
dp[i][j+1] = dp[i-1][j] + dist if dp[i-1][j] + dist < dp[i][j+1]
end
end
pos = b[0]
time = b[1]
if !bl
puts "NG #{i+1}"
break
end
end
0.upto(3) do |i|
dp[n][i] = dp[n-1][i] + bs[n-1][0]
end
puts "OK #{dp[n].min}" if bl
end
|
[["-", 0, 652, 196, 737, 8, 736, 0, 662, 12, 147], ["+", 0, 652, 196, 737, 8, 736, 0, 662, 12, 146], ["-", 8, 736, 0, 121, 15, 738, 12, 738, 12, 612], ["+", 8, 736, 0, 121, 15, 738, 12, 738, 12, 612]]
| 4
| 398
|
#include <bits/stdc++.h>
using namespace std;
typedef double dbl;
#define double long double
typedef complex<double> P;
typedef vector<P> G;
#define REP(i, n) for (int i = 0; i < n; i++)
map<int, int> cur;
int count(int x) {
auto it = cur.find(x);
if (it == cur.end())
return 0;
else
return it->second;
}
void dec(int x) {
if (--cur[x] == 0)
cur.erase(x);
}
void decv(int x, int v) {
if ((cur[x] -= v) == 0)
cur.erase(x);
}
void inc(int x) { cur[x]++; }
void incv(int x, int v) { cur[x] += v; }
int n;
vector<int> v;
set<vector<int>> ans;
int chk;
void dfs(int x) {
if (x == n) {
// cout << v.size() << "<" << endl;
vector<int> t = v;
sort(t.begin(), t.end());
{
vector<int> r;
for (int i = 1; i < t.size(); i++)
r.push_back(t[i] - t[i - 1]);
ans.insert(r);
}
reverse(t.begin(), t.end());
{
vector<int> r;
for (int i = 1; i < t.size(); i++)
r.push_back(t[i - 1] - t[i]);
ans.insert(r);
}
return;
}
auto f = [&](int x) {
map<int, int> req;
for (int i = 0; i < v.size(); i++) {
req[abs(v[i] - x)]++;
}
return req;
};
auto ok = [&](map<int, int> &req) {
for (auto &&i : req) {
if (count(i.first) < i.second)
return false;
}
return true;
};
auto go = [&](map<int, int> &req) {
for (auto &&i : req) {
decv(i.first, i.second);
}
};
auto back = [&](map<int, int> &req) {
for (auto &&i : req) {
incv(i.first, i.second);
}
};
auto r1 = f(chk - cur.rbegin()->first);
if (ok(r1)) {
v.push_back(chk - cur.rbegin()->first);
go(r1);
dfs(x + 1);
v.pop_back();
back(r1);
}
auto r2 = f(cur.rbegin()->first);
if (ok(r2)) {
v.push_back(cur.rbegin()->first);
go(r2);
dfs(x + 1);
v.pop_back();
back(r2);
}
}
int main() {
while (cin >> n && n) {
cur.clear();
ans.clear();
v.clear();
// cout << n*(n-1)/2 << endl;
for (int i = 0; i < n * (n - 1) / 2; i++) {
int t;
cin >> t;
inc(t);
}
chk = cur.rbegin()->first;
dec(cur.rbegin()->first);
v.push_back(0);
v.push_back(chk);
dfs(2);
sort(v.begin(), v.end());
for (auto v : ans) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
cout << (char)(i + 1 == v.size() ? 10 : 32);
}
}
cout << "----" << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef double dbl;
#define double long double
typedef complex<double> P;
typedef vector<P> G;
#define REP(i, n) for (int i = 0; i < n; i++)
map<int, int> cur;
int count(int x) {
auto it = cur.find(x);
if (it == cur.end())
return 0;
else
return it->second;
}
void dec(int x) {
if (--cur[x] == 0)
cur.erase(x);
}
void decv(int x, int v) {
if ((cur[x] -= v) == 0)
cur.erase(x);
}
void inc(int x) { cur[x]++; }
void incv(int x, int v) { cur[x] += v; }
int n;
vector<int> v;
set<vector<int>> ans;
int chk;
void dfs(int x) {
if (x == n) {
// cout << v.size() << "<" << endl;
vector<int> t = v;
sort(t.begin(), t.end());
{
vector<int> r;
for (int i = 1; i < t.size(); i++)
r.push_back(t[i] - t[i - 1]);
ans.insert(r);
}
reverse(t.begin(), t.end());
{
vector<int> r;
for (int i = 1; i < t.size(); i++)
r.push_back(t[i - 1] - t[i]);
ans.insert(r);
}
return;
}
auto f = [&](int x) {
map<int, int> req;
for (int i = 0; i < v.size(); i++) {
req[abs(v[i] - x)]++;
}
return req;
};
auto ok = [&](map<int, int> &req) {
for (auto &&i : req) {
if (count(i.first) < i.second)
return false;
}
return true;
};
auto go = [&](map<int, int> &req) {
for (auto &&i : req) {
decv(i.first, i.second);
}
};
auto back = [&](map<int, int> &req) {
for (auto &&i : req) {
incv(i.first, i.second);
}
};
auto r1 = f(chk - cur.rbegin()->first);
if (ok(r1)) {
v.push_back(chk - cur.rbegin()->first);
go(r1);
dfs(x + 1);
v.pop_back();
back(r1);
}
auto r2 = f(cur.rbegin()->first);
if (ok(r2)) {
v.push_back(cur.rbegin()->first);
go(r2);
dfs(x + 1);
v.pop_back();
back(r2);
}
}
int main() {
while (cin >> n && n) {
cur.clear();
ans.clear();
v.clear();
// cout << n*(n-1)/2 << endl;
for (int i = 0; i < n * (n - 1) / 2; i++) {
int t;
cin >> t;
inc(t);
}
chk = cur.rbegin()->first;
dec(cur.rbegin()->first);
v.push_back(0);
v.push_back(chk);
dfs(2);
sort(v.begin(), v.end());
for (auto v : ans) {
for (int i = 0; i < v.size(); i++) {
cout << v[i];
cout << (char)(i + 1 == v.size() ? 10 : 32);
}
}
cout << "-----" << endl;
}
}
|
[["-", 0, 1, 0, 16, 31, 16, 12, 5, 0, 6], ["+", 0, 1, 0, 16, 31, 16, 12, 5, 0, 6]]
| 1
| 845
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
double width(int *x, int *y, int size, double given_x) {
double max_point = -1000.0, min_point = 1000.0;
for (int i = 0; i < size; i++) {
double x1 = x[i], y1 = y[i], x2 = x[(i + 1) % size], y2 = y[(i + 1) % size];
if ((x1 - given_x) * (x2 - given_x) <= 0 && x1 != x2) {
double value = (y2 - y1) * (given_x - x1) / (x2 - x1) + y1;
max_point = max(value, max_point);
min_point = min(value, min_point);
}
}
return max_point - min_point;
}
int main() {
int m, n;
while (cin >> m >> n && m > 0) {
int xy[100];
int y[100];
int xz[100];
int z[100];
int max_xy = -105;
int min_xy = 105;
for (int i = 0; i < m; i++) {
cin >> xy[i] >> y[i];
max_xy = max(max_xy, xy[i]);
min_xy = min(min_xy, xy[i]);
}
int max_xz = -105;
int min_xz = 105;
for (int i = 0; i < n; i++) {
cin >> xz[i] >> z[i];
max_xz = max(max_xz, xz[i]);
min_xz = min(min_xz, xz[i]);
}
int xmin = max(min_xy, min_xz);
int xmax = min(max_xy, max_xz);
vector<int> v;
for (int i = 0; i < m; i++) {
v.push_back(xy[i]);
}
for (int i = 0; i < n; i++) {
v.push_back(xz[i]);
}
sort(v.begin(), v.end());
double ans = 0;
for (int i = 0; i < v.size(); i++) {
double a = v[i], b = v[i + 1];
if (xmin <= a && a <= xmax && xmin <= b && b <= xmax) {
double mid = (a + b) / 2.0;
double va = width(xy, y, m, a) * width(xz, z, n, a);
double vb = width(xy, y, m, b) * width(xz, z, n, b);
double vm = width(xy, y, m, mid) * width(xz, z, n, mid);
ans += (b - a) / 6 * (va + 4 * vm + vb);
}
}
cout << fixed << setprecision(4) << ans << endl;
}
}
|
#include <algorithm>
#include <iomanip>
#include <iostream>
#include <vector>
using namespace std;
double width(int *x, int *y, int size, double given_x) {
double max_point = -1000.0, min_point = 1000.0;
for (int i = 0; i < size; i++) {
double x1 = x[i], y1 = y[i], x2 = x[(i + 1) % size], y2 = y[(i + 1) % size];
if ((x1 - given_x) * (x2 - given_x) <= 0 && x1 != x2) {
double value = (y2 - y1) * (given_x - x1) / (x2 - x1) + y1;
max_point = max(value, max_point);
min_point = min(value, min_point);
}
}
return max_point - min_point;
}
int main() {
int m, n;
while (cin >> m >> n && m > 0) {
int xy[100];
int y[100];
int xz[100];
int z[100];
int max_xy = -105;
int min_xy = 105;
for (int i = 0; i < m; i++) {
cin >> xy[i] >> y[i];
max_xy = max(max_xy, xy[i]);
min_xy = min(min_xy, xy[i]);
}
int max_xz = -105;
int min_xz = 105;
for (int i = 0; i < n; i++) {
cin >> xz[i] >> z[i];
max_xz = max(max_xz, xz[i]);
min_xz = min(min_xz, xz[i]);
}
int xmin = max(min_xy, min_xz);
int xmax = min(max_xy, max_xz);
vector<int> v;
for (int i = 0; i < m; i++) {
v.push_back(xy[i]);
}
for (int i = 0; i < n; i++) {
v.push_back(xz[i]);
}
sort(v.begin(), v.end());
double ans = 0;
for (int i = 0; i < n + m - 1; i++) {
double a = v[i], b = v[i + 1];
if (xmin <= a && a <= xmax && xmin <= b && b <= xmax) {
double mid = (a + b) / 2.0;
double va = width(xy, y, m, a) * width(xz, z, n, a);
double vb = width(xy, y, m, b) * width(xz, z, n, b);
double vm = width(xy, y, m, mid) * width(xz, z, n, mid);
ans += (b - a) / 6 * (va + 4 * vm + vb);
}
}
cout << fixed << setprecision(4) << ans << endl;
}
}
|
[["-", 0, 7, 15, 16, 12, 2, 63, 118, 28, 22], ["-", 0, 7, 15, 16, 12, 2, 63, 118, 17, 131], ["-", 0, 7, 15, 16, 12, 2, 63, 118, 119, 120], ["-", 0, 7, 15, 16, 12, 2, 3, 4, 0, 24], ["-", 0, 7, 15, 16, 12, 2, 3, 4, 0, 25], ["+", 0, 7, 15, 16, 12, 16, 31, 16, 31, 22], ["+", 0, 7, 15, 16, 12, 16, 31, 16, 17, 72], ["+", 0, 7, 15, 16, 12, 16, 31, 16, 12, 22], ["+", 8, 9, 0, 7, 15, 16, 12, 16, 17, 33], ["+", 8, 9, 0, 7, 15, 16, 12, 16, 12, 13]]
| 1
| 612
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
struct Time {
Time() : h(0), m(0), idx("") {}
Time(string time, string _idx) : idx(_idx) {
h = (time[0] - '0') * 10 + (time[1] - '0');
m = (time[3] - '0') * 10 + (time[4] - '0');
}
int h, m;
string idx;
int diff(const Time &opp) const { return trans() - opp.trans(); }
int trans() const { return h * 60 + m; }
};
int main() {
while (true) {
int n;
cin >> n;
if (!n)
break;
Time goddess;
map<string, Time> mp;
map<string, int> res;
REP(i, n) {
string date, time, kind, id;
cin >> date >> time >> kind >> id;
Time tgt(time, id);
if (kind == "I") {
(tgt.idx == "000" ? goddess : mp[tgt.idx]) = tgt;
} else {
if (tgt.idx == "000") {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
string name = itr->first;
Time opp = itr->second;
res[name] +=
opp.diff(goddess) > 0 ? tgt.diff(opp) : tgt.diff(goddess);
}
goddess = Time();
} else {
if (goddess.h != 0 && goddess.m != 0) {
Time in = mp[tgt.idx];
res[tgt.idx] +=
in.diff(goddess) > 0 ? tgt.diff(in) : tgt.diff(goddess);
}
mp.erase(tgt.idx);
}
}
}
int mm = 0;
for (auto itr = res.begin(); itr != res.end(); ++itr)
mm = max(mm, itr->second);
cout << mm << endl;
}
return 0;
}
|
#include "bits/stdc++.h"
using namespace std;
using ll = long long;
using ld = long double;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define FOR(k, m, n) for (ll(k) = (m); (k) < (n); (k)++)
#define REP(i, n) FOR((i), 0, (n))
#define WAITING(str) \
int str; \
std::cin >> str;
#define DEBUGING(str) cout << #str << " " str << endl
constexpr int INF = (1 << 30);
constexpr ll INFL = (1ll << 60);
constexpr ll MOD = 1000000007; // 10^9+7
struct Time {
Time() : h(0), m(0), idx("") {}
Time(string time, string _idx) : idx(_idx) {
h = (time[0] - '0') * 10 + (time[1] - '0');
m = (time[3] - '0') * 10 + (time[4] - '0');
}
int h, m;
string idx;
int diff(const Time &opp) const { return trans() - opp.trans(); }
int trans() const { return h * 60 + m; }
};
int main() {
while (true) {
int n;
cin >> n;
if (!n)
break;
Time goddess;
map<string, Time> mp;
map<string, int> res;
REP(i, n) {
string date, time, kind, id;
cin >> date >> time >> kind >> id;
Time tgt(time, id);
if (kind == "I") {
(tgt.idx == "000" ? goddess : mp[tgt.idx]) = tgt;
} else {
if (tgt.idx == "000") {
for (auto itr = mp.begin(); itr != mp.end(); ++itr) {
string name = itr->first;
Time opp = itr->second;
res[name] +=
opp.diff(goddess) > 0 ? tgt.diff(opp) : tgt.diff(goddess);
}
goddess = Time();
} else {
if (goddess.h != 0 || goddess.m != 0) {
Time in = mp[tgt.idx];
res[tgt.idx] +=
in.diff(goddess) > 0 ? tgt.diff(in) : tgt.diff(goddess);
}
mp.erase(tgt.idx);
}
}
}
int mm = 0;
for (auto itr = res.begin(); itr != res.end(); ++itr)
mm = max(mm, itr->second);
cout << mm << endl;
}
return 0;
}
|
[["-", 0, 9, 0, 57, 15, 339, 51, 16, 17, 98], ["+", 0, 9, 0, 57, 15, 339, 51, 16, 17, 106]]
| 1
| 548
|
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int n;
while (cin >> n, n) {
int a, b;
char c;
vi d(n), t(n), p(n);
vector<char> e(n);
int maxp = -1;
REP(i, n) {
cin >> a >> c >> b;
d[i] = a * 100 + b;
cin >> a >> c >> b;
t[i] = a * 60 + b;
cin >> e[i] >> p[i];
maxp = max(maxp, p[i]);
}
vi isIn(maxp + 1), inTime(maxp + 1), sum(maxp + 1);
REP(i, n) {
if (e[i] == 'I') {
isIn[p[i]] = 1;
inTime[p[i]] = t[i];
if (p[i] == 0) {
FOR(j, 1, maxp) { inTime[j] = t[i]; }
}
} else {
isIn[p[i]] = 0;
if (p[i] == 0) {
FOR(j, 1, maxp) {
if (isIn[j]) {
sum[j] += t[i] - inTime[p[i]];
}
}
}
if (isIn[0]) {
sum[p[i]] += t[i] - inTime[p[i]];
}
}
}
int ans = 0;
FOR(i, 1, maxp) { ans = max(ans, sum[i]); }
cout << ans << endl;
}
return 0;
}
|
#include <algorithm>
#include <cctype>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
inline int toInt(string s) {
int v;
istringstream sin(s);
sin >> v;
return v;
}
template <class T> inline string toStr(T x) {
ostringstream sout;
sout << x;
return sout.str();
}
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<string> vs;
typedef pair<int, int> pii;
typedef long long ll;
#define ALL(a) (a).begin(), (a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define FOR(i, a, b) for (int i = (a); i <= (b); ++i)
#define REP(i, n) FOR(i, 0, (n)-1)
const double EPS = 1e-10;
const double PI = acos(-1.0);
const int INF = INT_MAX / 10;
int main() {
int n;
while (cin >> n, n) {
int a, b;
char c;
vi d(n), t(n), p(n);
vector<char> e(n);
int maxp = -1;
REP(i, n) {
cin >> a >> c >> b;
d[i] = a * 100 + b;
cin >> a >> c >> b;
t[i] = a * 60 + b;
cin >> e[i] >> p[i];
maxp = max(maxp, p[i]);
}
vi isIn(maxp + 1), inTime(maxp + 1), sum(maxp + 1);
REP(i, n) {
if (e[i] == 'I') {
isIn[p[i]] = 1;
inTime[p[i]] = t[i];
if (p[i] == 0) {
FOR(j, 1, maxp) { inTime[j] = t[i]; }
}
} else {
isIn[p[i]] = 0;
if (p[i] == 0) {
FOR(j, 1, maxp) {
if (isIn[j]) {
sum[j] += t[i] - inTime[j];
}
}
}
if (isIn[0]) {
sum[p[i]] += t[i] - inTime[p[i]];
}
}
}
int ans = 0;
FOR(i, 1, maxp) { ans = max(ans, sum[i]); }
cout << ans << endl;
}
return 0;
}
|
[["-", 12, 16, 12, 69, 341, 342, 0, 69, 28, 22], ["-", 12, 69, 341, 342, 0, 69, 341, 342, 0, 70], ["-", 12, 69, 341, 342, 0, 69, 341, 342, 0, 22], ["-", 12, 69, 341, 342, 0, 69, 341, 342, 0, 73], ["+", 0, 11, 12, 16, 12, 69, 341, 342, 0, 22]]
| 1
| 539
|
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int N;
bool endow[1000];
int tm[1000], tt[1000];
pair<int, int> separete(string s) {
stringstream ss(s);
int a, b;
char c;
ss >> a >> c >> b;
return make_pair(a, b);
}
int transMin(string s) {
pair<int, int> ms = separete(s);
int m = ms.first;
int d = ms.second;
return m * 60 + d;
}
int solve() {
memset(endow, 0, sizeof(endow));
memset(tt, 0, sizeof(tt));
while (N--) {
string a, b, c;
int mn, id;
cin >> a >> b >> c >> id;
mn = transMin(b);
if (c == "I") {
endow[id] = true;
tm[id] = mn;
}
if (c == "O") {
endow[id] = false;
if (id != 0) {
if (endow[0])
tt[id] += mn - max(tm[id], tm[0]);
} else {
for (int i = 1; i < 1000; i++)
if (endow[i])
tt[i] += mn - max(tm[id], tm[0]);
}
}
}
int res = 0;
for (int i = 1; i < 1000; i++)
res = max(res, tt[i]);
return res;
}
int main() {
while (cin >> N, N)
cout << solve() << endl;
}
|
#include <cstring>
#include <iostream>
#include <sstream>
#include <string>
using namespace std;
int N;
bool endow[1000];
int tm[1000], tt[1000];
pair<int, int> separete(string s) {
stringstream ss(s);
int a, b;
char c;
ss >> a >> c >> b;
return make_pair(a, b);
}
int transMin(string s) {
pair<int, int> ms = separete(s);
int m = ms.first;
int d = ms.second;
return m * 60 + d;
}
int solve() {
memset(endow, 0, sizeof(endow));
memset(tt, 0, sizeof(tt));
while (N--) {
string a, b, c;
int mn, id;
cin >> a >> b >> c >> id;
mn = transMin(b);
if (c == "I") {
endow[id] = true;
tm[id] = mn;
}
if (c == "O") {
endow[id] = false;
if (id != 0) {
if (endow[0])
tt[id] += mn - max(tm[id], tm[0]);
} else {
for (int i = 1; i < 1000; i++)
if (endow[i])
tt[i] += mn - max(tm[i], tm[0]);
}
}
}
int res = 0;
for (int i = 1; i < 1000; i++)
res = max(res, tt[i]);
return res;
}
int main() {
while (cin >> N, N)
cout << solve() << endl;
}
|
[["-", 12, 2, 3, 4, 0, 69, 341, 342, 0, 22], ["+", 12, 2, 3, 4, 0, 69, 341, 342, 0, 22]]
| 1
| 359
|
while True:
n = int(input())
if n == 0: break
exist = set([])
enter = [0]*1000
bless = [0]*1000
for loop in range(n):
md,hm,io,p = input().split()
h,m = list(map(int,hm.split(":")))
t = 60*h+m
p = int(p)
if io == "I":
time[p] = t
exist.add(p)
else:
exist.remove(p)
if p == 0:
for i in exist: bless[i] += t-max(enter[p],enter[i])
elif 0 in exist:
bless[p] += t-max(enter[0],enter[p])
print(max(bless))
|
while True:
n = int(input())
if n == 0: break
exist = set([])
enter = [0]*1000
bless = [0]*1000
for loop in range(n):
md,hm,io,p = input().split()
h,m = list(map(int,hm.split(":")))
t = 60*h+m
p = int(p)
if io == "I":
enter[p] = t
exist.add(p)
else:
exist.remove(p)
if p == 0:
for i in exist: bless[i] += t-max(enter[p],enter[i])
elif 0 in exist:
bless[p] += t-max(enter[0],enter[p])
print(max(bless))
|
[["-", 64, 196, 0, 1, 0, 662, 31, 206, 51, 22], ["+", 64, 196, 0, 1, 0, 662, 31, 206, 51, 22]]
| 5
| 181
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.NoSuchElementException;
public class Main {
int H, W;
int[] DX = {0, 0, 1, 1, 1, -1, -1, -1};
int[] DY = {1, -1, 0, 1, -1, 0, 1, -1};
boolean[][] used;
char[][] spells;
HashMap<String, Integer> map;
public String dfs(int h, int w, int dy, int dx) {
if (used[h][w])
return "";
used[h][w] = true;
String ret = "";
int nh = (h + dy + H) % H;
int nw = (w + dx + W) % W;
ret = spells[h][w] + dfs(nh, nw, dy, dx);
used[h][w] = false;
map.put(ret, map.containsKey(ret) ? map.get(ret) + 1 : 1);
return ret;
}
public void solve() {
while (true) {
H = nextInt();
W = nextInt();
if (H + W == 0)
break;
map = new HashMap<String, Integer>();
spells = new char[H][];
for (int i = 0; i < H; i++) {
spells[i] = next().toCharArray();
}
used = new boolean[H][W];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
for (int k = 0; k < DX.length; k++) {
dfs(i, j, DY[k], DX[k]);
}
}
}
String ans = "";
for (String key : map.keySet()) {
if (map.get(key) >= 2 && key.length() >= 2) {
if (ans.length() < key.length()) {
ans = key;
} else if (ans.length() == key.length() && ans.compareTo(key) == 1) {
ans = key;
}
}
}
out.println(ans.length() == 0 ? 0 : ans);
}
}
public static void main(String[] args) {
out.flush();
new Main().solve();
out.close();
}
/* Input */
private static final InputStream in = System.in;
private static final PrintWriter out = new PrintWriter(System.out);
private final byte[] buffer = new byte[2048];
private int p = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (p < buflen)
return true;
p = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0)
return false;
return true;
}
public boolean hasNext() {
while (hasNextByte() && !isPrint(buffer[p])) {
p++;
}
return hasNextByte();
}
private boolean isPrint(int ch) {
if (ch >= '!' && ch <= '~')
return true;
return false;
}
private int nextByte() {
if (!hasNextByte())
return -1;
return buffer[p++];
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = -1;
while (isPrint((b = nextByte()))) {
sb.appendCodePoint(b);
}
return sb.toString();
}
public int nextInt() { return Integer.parseInt(next()); }
public long nextLong() { return Long.parseLong(next()); }
public double nextDouble() { return Double.parseDouble(next()); }
}
|
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintWriter;
import java.util.HashMap;
import java.util.NoSuchElementException;
public class Main {
int H, W;
int[] DX = {0, 0, 1, 1, 1, -1, -1, -1};
int[] DY = {1, -1, 0, 1, -1, 0, 1, -1};
boolean[][] used;
char[][] spells;
HashMap<String, Integer> map;
public String dfs(int h, int w, int dy, int dx) {
if (used[h][w])
return "";
used[h][w] = true;
String ret = "";
int nh = (h + dy + H) % H;
int nw = (w + dx + W) % W;
ret = spells[h][w] + dfs(nh, nw, dy, dx);
used[h][w] = false;
map.put(ret, map.containsKey(ret) ? map.get(ret) + 1 : 1);
return ret;
}
public void solve() {
while (true) {
H = nextInt();
W = nextInt();
if (H + W == 0)
break;
map = new HashMap<String, Integer>();
spells = new char[H][];
for (int i = 0; i < H; i++) {
spells[i] = next().toCharArray();
}
used = new boolean[H][W];
for (int i = 0; i < H; i++) {
for (int j = 0; j < W; j++) {
for (int k = 0; k < DX.length; k++) {
dfs(i, j, DY[k], DX[k]);
}
}
}
String ans = "";
for (String key : map.keySet()) {
if (map.get(key) >= 2 && key.length() >= 2) {
if (ans.length() < key.length()) {
ans = key;
} else if (ans.length() == key.length() && ans.compareTo(key) >= 1) {
ans = key;
}
}
}
out.println(ans.length() == 0 ? 0 : ans);
}
}
public static void main(String[] args) {
out.flush();
new Main().solve();
out.close();
}
/* Input */
private static final InputStream in = System.in;
private static final PrintWriter out = new PrintWriter(System.out);
private final byte[] buffer = new byte[2048];
private int p = 0;
private int buflen = 0;
private boolean hasNextByte() {
if (p < buflen)
return true;
p = 0;
try {
buflen = in.read(buffer);
} catch (IOException e) {
e.printStackTrace();
}
if (buflen <= 0)
return false;
return true;
}
public boolean hasNext() {
while (hasNextByte() && !isPrint(buffer[p])) {
p++;
}
return hasNextByte();
}
private boolean isPrint(int ch) {
if (ch >= '!' && ch <= '~')
return true;
return false;
}
private int nextByte() {
if (!hasNextByte())
return -1;
return buffer[p++];
}
public String next() {
if (!hasNext())
throw new NoSuchElementException();
StringBuilder sb = new StringBuilder();
int b = -1;
while (isPrint((b = nextByte()))) {
sb.appendCodePoint(b);
}
return sb.toString();
}
public int nextInt() { return Integer.parseInt(next()); }
public long nextLong() { return Long.parseLong(next()); }
public double nextDouble() { return Double.parseDouble(next()); }
}
|
[["-", 75, 57, 15, 15, 0, 16, 12, 16, 17, 60], ["+", 75, 57, 15, 15, 0, 16, 12, 16, 17, 20]]
| 3
| 859
|
import java.util.*;
class Main {
int h, w;
int[] dx = {0, 0, 1, -1, 1, 1, -1, -1};
int[] dy = {1, -1, 0, 0, 1, -1, 1, -1};
char[][] donut;
String cutS;
@SuppressWarnings("unchecked")
void solve() {
Scanner sc = new Scanner(System.in);
while (true) {
h = sc.nextInt();
w = sc.nextInt();
if (h == 0 && w == 0)
break;
donut = new char[h][w];
for (int i = 0; i < h; i++) {
String line = sc.next();
donut[i] = line.toCharArray();
}
int max = 0;
StringBuilder minString = new StringBuilder();
for (int l = h * w - 1; l >= 2; l--) {
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
for (int k = 0; k < 8; k++) {
StringBuilder s = new StringBuilder();
s.append(donut[i][j]);
int ny = (i + dy[k]) % h, nx = (j + dx[k]) % w;
if (ny == -1)
ny = h - 1;
if (nx == -1)
nx = w - 1;
while (!(ny == i && nx == j)) {
if (s.length() == l)
break;
s.append(donut[ny][nx]);
ny = (ny + dy[k]) % h;
nx = (nx + dx[k]) % w;
if (ny == -1)
ny = h - 1;
if (nx == -1)
nx = w - 1;
}
if (s.length() != l)
continue;
if (!set.add(s.toString()) &&
(minString.length() == 0 || min(s, minString))) {
max = s.length();
minString = s;
}
}
}
}
if (max != 0)
break;
}
if (minString.length() == 0)
System.out.println(0);
else
System.out.println(minString.toString());
}
}
boolean min(StringBuilder s1, StringBuilder s2) { // s1 < s2?
int l1 = s1.length(), l2 = s2.length();
for (int i = 0; i < Math.min(l1, l2); i++) {
if (s1.charAt(i) < s2.charAt(i))
return true;
else if (s1.charAt(i) > s2.charAt(i))
return false;
}
if (l1 < l2)
return true;
return false;
}
public static void main(String[] args) { new Main().solve(); }
}
|
import java.util.*;
class Main {
int h, w;
int[] dx = {0, 0, 1, -1, 1, 1, -1, -1};
int[] dy = {1, -1, 0, 0, 1, -1, 1, -1};
char[][] donut;
String cutS;
@SuppressWarnings("unchecked")
void solve() {
Scanner sc = new Scanner(System.in);
while (true) {
h = sc.nextInt();
w = sc.nextInt();
if (h == 0 && w == 0)
break;
donut = new char[h][w];
for (int i = 0; i < h; i++) {
String line = sc.next();
donut[i] = line.toCharArray();
}
int max = 0;
StringBuilder minString = new StringBuilder();
for (int l = h * w; l >= 2; l--) {
HashSet<String> set = new HashSet<String>();
for (int i = 0; i < h; i++) {
for (int j = 0; j < w; j++) {
for (int k = 0; k < 8; k++) {
StringBuilder s = new StringBuilder();
s.append(donut[i][j]);
int ny = (i + dy[k]) % h, nx = (j + dx[k]) % w;
if (ny == -1)
ny = h - 1;
if (nx == -1)
nx = w - 1;
while (!(ny == i && nx == j)) {
if (s.length() == l)
break;
s.append(donut[ny][nx]);
ny = (ny + dy[k]) % h;
nx = (nx + dx[k]) % w;
if (ny == -1)
ny = h - 1;
if (nx == -1)
nx = w - 1;
}
if (s.length() != l)
continue;
if (!set.add(s.toString()) &&
(minString.length() == 0 || min(s, minString))) {
max = s.length();
minString = s;
}
}
}
}
if (max != 0)
break;
}
if (minString.length() == 0)
System.out.println(0);
else
System.out.println(minString.toString());
}
}
boolean min(StringBuilder s1, StringBuilder s2) { // s1 < s2?
int l1 = s1.length(), l2 = s2.length();
for (int i = 0; i < Math.min(l1, l2); i++) {
if (s1.charAt(i) < s2.charAt(i))
return true;
else if (s1.charAt(i) > s2.charAt(i))
return false;
}
if (l1 < l2)
return true;
return false;
}
public static void main(String[] args) { new Main().solve(); }
}
|
[["-", 0, 7, 502, 503, 49, 200, 51, 16, 17, 33], ["-", 0, 7, 502, 503, 49, 200, 51, 16, 12, 499]]
| 3
| 666
|
#include <iostream>
#include <set>
#include <string>
using namespace std;
string mp[11];
int w, h;
set<string> cnt;
string ans;
void check(int x, int y) {
string str;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (i == 0 && j == 0)
continue;
str = mp[y][x];
int nx = (x + j + w) % w, ny = (y + i + h) % h;
while (ny != y || nx != x) {
str += mp[ny][nx], nx = (nx + j + w) % w, ny = (ny + i + h) % h;
if (cnt.count(str)) {
if (str.size() > ans.size())
ans = str;
else if (str.size() == ans.size())
ans = min(str, ans);
} else
cnt.insert(str);
}
}
}
int main() {
while (1) {
cin >> h >> w;
if (w == 0 && h == 0)
break;
for (int i = 0; i < h; i++)
cin >> mp[i];
ans = "";
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
check(j, i);
if (ans.size() == 0)
ans = "0";
cout << ans << endl;
}
return 0;
}
|
#include <iostream>
#include <set>
#include <string>
using namespace std;
string mp[11];
int w, h;
set<string> cnt;
string ans;
void check(int x, int y) {
string str;
for (int i = -1; i <= 1; i++)
for (int j = -1; j <= 1; j++) {
if (i == 0 && j == 0)
continue;
str = mp[y][x];
int nx = (x + j + w) % w, ny = (y + i + h) % h;
while (ny != y || nx != x) {
str += mp[ny][nx], nx = (nx + j + w) % w, ny = (ny + i + h) % h;
if (cnt.count(str)) {
if (str.size() > ans.size())
ans = str;
else if (str.size() == ans.size())
ans = min(str, ans);
} else
cnt.insert(str);
}
}
}
int main() {
while (1) {
cin >> h >> w;
cnt.clear();
if (w == 0 && h == 0)
break;
for (int i = 0; i < h; i++)
cin >> mp[i];
ans = "";
for (int i = 0; i < h; i++)
for (int j = 0; j < w; j++)
check(j, i);
if (ans.size() == 0)
ans = "0";
cout << ans << endl;
}
return 0;
}
|
[["+", 8, 9, 0, 1, 0, 2, 63, 118, 28, 22], ["+", 8, 9, 0, 1, 0, 2, 63, 118, 17, 131], ["+", 8, 9, 0, 1, 0, 2, 63, 118, 119, 120], ["+", 8, 9, 0, 1, 0, 2, 3, 4, 0, 24], ["+", 8, 9, 0, 1, 0, 2, 3, 4, 0, 25], ["+", 8, 9, 0, 52, 8, 9, 0, 1, 0, 35]]
| 1
| 344
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
// assign
string comp(string a, string b);
signed main() {
int n, m;
while (cin >> n >> m, n) {
vector<string> donut(n);
rep(i, n) { cin >> donut[i]; }
set<string> can;
string ans = "z";
rep(i, n) {
rep(j, m) {
rep(k, 8) {
vvb used(n, vb(m, false));
string spell;
int x = i, y = j;
while (!used[x][y]) {
spell.pb(donut[x][y]);
used[x][y] = true;
if (can.find(spell) != can.end()) {
ans = comp(ans, spell);
} else {
can.insert(spell);
}
x = (x + dx[k] + n) % n;
y = (y + dy[k] + m) % m;
}
}
}
}
cout << ((ans.length() > 1) ? ans : 0) << endl;
}
return 0;
}
string comp(string a, string b) {
if (a.length() < b.length()) {
return b;
} else if (a.length() > b.length()) {
return a;
} else {
rep(i, a.length()) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i]) {
return b;
}
}
}
return a;
}
|
#include <bits/stdc++.h>
using namespace std;
#define INF 1001000100010001000
#define MOD 1000000007
#define EPS 1e-10
#define int long long
#define rep(i, N) for (int i = 0; i < N; i++)
#define Rep(i, N) for (int i = 1; i < N; i++)
#define For(i, a, b) for (int i = (a); i < (b); i++)
#define pb push_back
#define mp make_pair
#define i_i pair<int, int>
#define vi vector<int>
#define vvi vector<vi>
#define vb vector<bool>
#define vvb vector<vb>
#define vp vector<i_i>
#define all(a) (a).begin(), (a).end()
#define Int(x) \
int x; \
scanf("%lld", &x);
// int dxy[5] = {0, 1, 0, -1, 0};
int dx[8] = {1, 1, 1, 0, 0, -1, -1, -1};
int dy[8] = {1, 0, -1, 1, -1, 1, 0, -1};
// assign
string comp(string a, string b);
signed main() {
int n, m;
while (cin >> n >> m, n) {
vector<string> donut(n);
rep(i, n) { cin >> donut[i]; }
set<string> can;
string ans = "z";
rep(i, n) {
rep(j, m) {
rep(k, 8) {
vvb used(n, vb(m, false));
string spell;
int x = i, y = j;
while (!used[x][y]) {
spell.pb(donut[x][y]);
used[x][y] = true;
if (can.find(spell) != can.end()) {
ans = comp(ans, spell);
} else {
can.insert(spell);
}
x = (x + dx[k] + n) % n;
y = (y + dy[k] + m) % m;
}
}
}
}
cout << ((ans.length() > 1) ? ans : "0") << endl;
}
return 0;
}
string comp(string a, string b) {
if (a.length() < b.length()) {
return b;
} else if (a.length() > b.length()) {
return a;
} else {
rep(i, a.length()) {
if (a[i] < b[i]) {
return a;
} else if (a[i] > b[i]) {
return b;
}
}
}
return a;
}
|
[["+", 31, 16, 12, 23, 0, 41, 75, 5, 0, 62]]
| 1
| 479
|
#include <bits/stdc++.h>
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) begin(x), end(x)
using namespace std;
const int mod = 2;
const int eps = 0;
struct Mod {
int n;
Mod() : n(0) { ; }
Mod(int m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
Mod &operator=(const Mod &) = default;
operator int() { return n; }
};
bool operator==(Mod a, Mod b) { return a.n == b.n; }
Mod operator+=(Mod &a, Mod b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
Mod operator-=(Mod &a, Mod b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
Mod operator*=(Mod &a, Mod b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
Mod operator+(Mod a, Mod b) { return a += b; }
Mod operator-(Mod a, Mod b) { return a -= b; }
Mod operator*(Mod a, Mod b) { return a *= b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
using ll = int64_t;
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
Mod operator/(Mod a, Mod b) { return a * Mod(inv(b, mod)); }
Mod operator/=(Mod &a, Mod b) {
a.n = ((long long)a.n / b.n);
return a;
}
typedef Mod Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return dat == Mod(0); }
tuple<Matrix, int> solve(Matrix A) {
const int n = A.size(), m = A[0].size();
int r = 0;
for (int i = 0; r < n && i < m; ++i) {
int pivot = r;
for (int j = r; j < n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (int j = r + 1; j < n; ++j)
for (int k = m - 1; k >= i; --k)
A[j][k] -= A[r][k] * A[j][i];
++r;
}
return make_pair(A, r);
}
int main() {
while (1) {
int n, m, d;
cin >> n >> m >> d;
if (!n)
break;
vector<Mod> tb(n * m);
REP(i, n) REP(j, m) {
int v;
cin >> v;
tb[i * m + j] = v;
}
int dim = n * m;
Matrix mat(dim, Array(dim + 1));
REP(i, n) REP(j, m) {
REP(k, n) REP(l, m) {
if (abs(k - i) + abs(l - j) == d) {
mat[i * m + j][k * m + l] = 1;
}
}
mat[i * m + j][i * m + j] = 1;
mat[i * m + j][dim] = tb[i * m + j];
}
Matrix res;
int rank;
tie(res, rank) = solve(mat);
bool ok = false;
REP(i, dim) if (res[rank - 1][i]) ok = true;
if (ok) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
|
#include <bits/stdc++.h>
#define FOR(i, k, n) for (int i = (k); i < (int)(n); ++i)
#define REP(i, n) FOR(i, 0, n)
#define ALL(x) begin(x), end(x)
using namespace std;
const int mod = 2;
const int eps = 0;
struct Mod {
int n;
Mod() : n(0) { ; }
Mod(int m) : n(m) {
if (n >= mod)
n %= mod;
else if (n < 0)
n = (n % mod + mod) % mod;
}
Mod &operator=(const Mod &) = default;
operator int() { return n; }
};
bool operator==(Mod a, Mod b) { return a.n == b.n; }
Mod operator+=(Mod &a, Mod b) {
a.n += b.n;
if (a.n >= mod)
a.n -= mod;
return a;
}
Mod operator-=(Mod &a, Mod b) {
a.n -= b.n;
if (a.n < 0)
a.n += mod;
return a;
}
Mod operator*=(Mod &a, Mod b) {
a.n = ((long long)a.n * b.n) % mod;
return a;
}
Mod operator+(Mod a, Mod b) { return a += b; }
Mod operator-(Mod a, Mod b) { return a -= b; }
Mod operator*(Mod a, Mod b) { return a *= b; }
Mod operator^(Mod a, int n) {
if (n == 0)
return Mod(1);
Mod res = (a * a) ^ (n / 2);
if (n % 2)
res = res * a;
return res;
}
using ll = int64_t;
ll inv(ll a, ll p) { return (a == 1 ? 1 : (1 - p * inv(p % a, a)) / a + p); }
Mod operator/(Mod a, Mod b) { return a * Mod(inv(b, mod)); }
Mod operator/=(Mod &a, Mod b) {
a.n = ((long long)a.n / b.n);
return a;
}
typedef Mod Data;
typedef vector<Data> Array;
typedef vector<Array> Matrix;
bool is_zero(Data dat) { return dat == Mod(0); }
tuple<Matrix, int> solve(Matrix A) {
const int n = A.size(), m = A[0].size();
int r = 0;
for (int i = 0; r < n && i < m; ++i) {
int pivot = r;
for (int j = r; j < n; ++j) {
if (A[j][i]) {
pivot = j;
break;
}
}
swap(A[pivot], A[r]);
if (is_zero(A[r][i]))
continue;
for (int j = r + 1; j < n; ++j)
for (int k = m - 1; k >= i; --k)
A[j][k] -= A[r][k] * A[j][i];
++r;
}
return make_pair(A, r);
}
int main() {
while (1) {
int n, m, d;
cin >> m >> n >> d;
if (!n)
break;
vector<Mod> tb(n * m);
REP(i, n) REP(j, m) {
int v;
cin >> v;
tb[i * m + j] = v;
}
int dim = n * m;
Matrix mat(dim, Array(dim + 1));
REP(i, n) REP(j, m) {
REP(k, n) REP(l, m) {
if (abs(k - i) + abs(l - j) == d) {
mat[i * m + j][k * m + l] = 1;
}
}
mat[i * m + j][i * m + j] = 1;
mat[i * m + j][dim] = tb[i * m + j];
}
Matrix res;
int rank;
tie(res, rank) = solve(mat);
bool ok = false;
REP(i, dim) if (res[rank - 1][i]) ok = true;
if (ok) {
cout << 1 << endl;
} else {
cout << 0 << endl;
}
}
return 0;
}
|
[["-", 0, 1, 0, 16, 31, 16, 31, 16, 12, 22], ["-", 8, 9, 0, 1, 0, 16, 31, 16, 17, 152], ["+", 8, 9, 0, 1, 0, 16, 31, 16, 17, 152], ["+", 8, 9, 0, 1, 0, 16, 31, 16, 12, 22]]
| 1
| 965
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 2; // assert mod is prime
template <int M> struct Mint {
int x;
Mint() : x(0) {}
Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M) {}
Mint &operator+=(const Mint &rhs) {
if ((x += rhs.x) >= M)
x -= M;
return *this;
}
Mint &operator-=(const Mint &rhs) {
if ((x += M - rhs.x) >= M)
x -= M;
return *this;
}
Mint &operator*=(const Mint &rhs) {
x = 1LL * x * rhs.x % M;
return *this;
}
Mint &operator/=(const Mint &rhs) {
x = (1LL * x * rhs.inv().x) % M;
return *this;
}
Mint operator-() const { return Mint(-x); }
Mint operator+(const Mint &rhs) const { return Mint(*this) += rhs; }
Mint operator-(const Mint &rhs) const { return Mint(*this) -= rhs; }
Mint operator*(const Mint &rhs) const { return Mint(*this) *= rhs; }
Mint operator/(const Mint &rhs) const { return Mint(*this) /= rhs; }
bool operator<(const Mint &rhs) const { return x < rhs.x; }
Mint inv() const {
signed a = x, b = M, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return Mint(u);
}
Mint pow(long long t) const {
Mint e = *this, res = 1;
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
};
template <int M> ostream &operator<<(ostream &os, const Mint<M> &rhs) {
return os << rhs.x;
}
template <int M> istream &operator>>(istream &is, Mint<M> &rhs) {
long long s;
is >> s;
rhs = Mint<M>(s);
return is;
};
using mint = Mint<mod>;
using Array = vector<mint>;
using Matrix = vector<Array>;
const double eps = 1e-10;
void outMat(const Matrix &A) {
int n = A.size(), m = A[0].size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << A[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
Array GaussJordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (B[j][i].x > B[pivot][i].x)
pivot = j;
// if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
}
// outMat(B);
swap(B[i], B[pivot]);
// outMat(B);
// if(abs(B[i][i]) < eps) return Array();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
// outMat(B);
}
// outMat(B);
Array x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
int b[25][25];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
int m, n, d;
while (cin >> m >> n >> d, m) {
int N = n * m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
Matrix A(N, Array(N));
Array B(N);
for (int i1 = 0; i1 < n; i1++) {
for (int j1 = 0; j1 < m; j1++) {
for (int i2 = 0; i2 < n; i2++) {
for (int j2 = 0; j2 < m; j2++) {
int D = abs(i1 - i2) + abs(j1 - j2);
A[i1 * n + j1][i2 * n + j2] = (D == 0 || D == d);
}
}
B[i1 * n + j1] = b[i1][j1];
}
}
// outMat(A);
auto X = GaussJordan(A, B);
int ok = 1;
for (int i = 0; i < N; i++) {
mint k = 0;
for (int j = 0; j < N; j++) {
k += A[i][j] * X[j];
}
if (k.x != B[i].x) {
ok = 0;
break;
}
}
cout << ok << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int mod = 2; // assert mod is prime
template <int M> struct Mint {
int x;
Mint() : x(0) {}
Mint(int y) : x(y >= 0 ? y % M : M - (-y) % M) {}
Mint &operator+=(const Mint &rhs) {
if ((x += rhs.x) >= M)
x -= M;
return *this;
}
Mint &operator-=(const Mint &rhs) {
if ((x += M - rhs.x) >= M)
x -= M;
return *this;
}
Mint &operator*=(const Mint &rhs) {
x = 1LL * x * rhs.x % M;
return *this;
}
Mint &operator/=(const Mint &rhs) {
x = (1LL * x * rhs.inv().x) % M;
return *this;
}
Mint operator-() const { return Mint(-x); }
Mint operator+(const Mint &rhs) const { return Mint(*this) += rhs; }
Mint operator-(const Mint &rhs) const { return Mint(*this) -= rhs; }
Mint operator*(const Mint &rhs) const { return Mint(*this) *= rhs; }
Mint operator/(const Mint &rhs) const { return Mint(*this) /= rhs; }
bool operator<(const Mint &rhs) const { return x < rhs.x; }
Mint inv() const {
signed a = x, b = M, u = 1, v = 0, t;
while (b) {
t = a / b;
a -= t * b;
swap(a, b);
u -= t * v;
swap(u, v);
}
return Mint(u);
}
Mint pow(long long t) const {
Mint e = *this, res = 1;
for (; t; e *= e, t >>= 1)
if (t & 1)
res *= e;
return res;
}
};
template <int M> ostream &operator<<(ostream &os, const Mint<M> &rhs) {
return os << rhs.x;
}
template <int M> istream &operator>>(istream &is, Mint<M> &rhs) {
long long s;
is >> s;
rhs = Mint<M>(s);
return is;
};
using mint = Mint<mod>;
using Array = vector<mint>;
using Matrix = vector<Array>;
const double eps = 1e-10;
void outMat(const Matrix &A) {
int n = A.size(), m = A[0].size();
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cout << A[i][j] << " ";
}
cout << endl;
}
cout << endl;
}
Array GaussJordan(const Matrix &A, const Array &b) {
int n = A.size();
Matrix B(n, Array(n + 1));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
B[i][j] = A[i][j];
for (int i = 0; i < n; i++)
B[i][n] = b[i];
for (int i = 0; i < n; i++) {
int pivot = i;
for (int j = i; j < n; j++) {
if (B[j][i].x > B[pivot][i].x)
pivot = j;
// if(abs(B[j][i]) > abs(B[pivot][i])) pivot = j;
}
// outMat(B);
swap(B[i], B[pivot]);
// outMat(B);
// if(abs(B[i][i]) < eps) return Array();
for (int j = i + 1; j <= n; j++)
B[i][j] /= B[i][i];
for (int j = 0; j < n; j++) {
if (i != j) {
for (int k = i + 1; k <= n; k++)
B[j][k] -= B[j][i] * B[i][k];
}
}
// outMat(B);
}
// outMat(B);
Array x(n);
for (int i = 0; i < n; i++)
x[i] = B[i][n];
return x;
}
int b[25][25];
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
#ifdef LOCAL
std::ifstream in("in");
std::cin.rdbuf(in.rdbuf());
#endif
int m, n, d;
while (cin >> m >> n >> d, m) {
int N = n * m;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
cin >> b[i][j];
}
}
Matrix A(N, Array(N));
Array B(N);
for (int i1 = 0; i1 < n; i1++) {
for (int j1 = 0; j1 < m; j1++) {
for (int i2 = 0; i2 < n; i2++) {
for (int j2 = 0; j2 < m; j2++) {
int D = abs(i1 - i2) + abs(j1 - j2);
A[i1 * m + j1][i2 * m + j2] = (D == 0 || D == d);
}
}
B[i1 * m + j1] = b[i1][j1];
}
}
// outMat(A);
auto X = GaussJordan(A, B);
int ok = 1;
for (int i = 0; i < N; i++) {
mint k = 0;
for (int j = 0; j < N; j++) {
k += A[i][j] * X[j];
}
if (k.x != B[i].x) {
ok = 0;
break;
}
}
cout << ok << endl;
}
}
|
[["-", 28, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["+", 28, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["-", 31, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["+", 31, 69, 341, 342, 0, 16, 31, 16, 12, 22]]
| 1
| 1,303
|
#include <cmath>
#include <iostream>
#define eps 1e-9
using namespace std;
int m, n, d, N;
int mat[650][650];
void swapRow(int x, int y) {
int t;
for (int i = 0; i < N + 1; i++) {
t = mat[x][i];
mat[x][i] = mat[y][i];
mat[y][i] = t;
}
}
int main(void) {
while (1) {
cin >> m >> n >> d;
if (m == 0 && n == 0 & d == 0)
break;
N = m * n;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
mat[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < n; jj++) {
if (abs(i - ii) + abs(j - jj) == d) {
mat[i * m + j][ii * m + jj] = 1;
}
if (i == ii && j == jj)
mat[i * m + j][ii * m + jj] = 1;
}
}
}
}
int s;
for (int i = 0; i < N; i++) {
cin >> s;
mat[i][N] = s;
}
for (int i = 0; i < N; i++) {
int piv, val = 0;
for (int j = i; j < N; j++) {
if (val < mat[j][i]) {
val = mat[j][i];
piv = j;
}
}
if (val == 0)
continue;
swapRow(i, piv);
for (int j = 0; j < N; j++) {
if (i == j)
continue;
if (mat[j][i] == 0)
continue;
for (int k = 0; k < N + 1; k++) {
mat[j][k] += mat[i][k];
mat[j][k] %= 2;
}
}
}
bool ans = true;
for (int i = 0; i < N; i++) {
if (mat[i][i] == 0 && mat[i][N] == 1) {
ans = false;
break;
}
}
if (ans)
cout << 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
|
#include <cmath>
#include <iostream>
#define eps 1e-9
using namespace std;
int m, n, d, N;
int mat[650][650];
void swapRow(int x, int y) {
int t;
for (int i = 0; i < N + 1; i++) {
t = mat[x][i];
mat[x][i] = mat[y][i];
mat[y][i] = t;
}
}
int main(void) {
while (1) {
cin >> m >> n >> d;
if (m == 0 && n == 0 & d == 0)
break;
N = m * n;
for (int i = 0; i < N; i++) {
for (int j = 0; j < N; j++) {
mat[i][j] = 0;
}
}
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int ii = 0; ii < n; ii++) {
for (int jj = 0; jj < m; jj++) {
if (abs(i - ii) + abs(j - jj) == d) {
mat[i * m + j][ii * m + jj] = 1;
}
if (i == ii && j == jj)
mat[i * m + j][ii * m + jj] = 1;
}
}
}
}
int s;
for (int i = 0; i < N; i++) {
cin >> s;
mat[i][N] = s;
}
for (int i = 0; i < N; i++) {
int piv, val = 0;
for (int j = i; j < N; j++) {
if (val < mat[j][i]) {
val = mat[j][i];
piv = j;
}
}
if (val == 0)
continue;
swapRow(i, piv);
for (int j = 0; j < N; j++) {
if (i == j)
continue;
if (mat[j][i] == 0)
continue;
for (int k = 0; k < N + 1; k++) {
mat[j][k] += mat[i][k];
mat[j][k] %= 2;
}
}
}
bool ans = true;
for (int i = 0; i < N; i++) {
if (mat[i][i] == 0 && mat[i][N] == 1) {
ans = false;
break;
}
}
if (ans)
cout << 1 << endl;
else
cout << 0 << endl;
}
return 0;
}
|
[["-", 0, 7, 8, 9, 0, 7, 15, 16, 12, 22], ["+", 0, 7, 8, 9, 0, 7, 15, 16, 12, 22]]
| 1
| 580
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
const Int MAX = 2002;
using BS = bitset<MAX * 2>;
using mat = vector<BS>;
void gauss(mat &v) {
int n = v.size();
for (Int i = 0; i < n; i++) {
for (Int k = i; k < n; k++) {
if (v[k][i]) {
swap(v[i], v[k]);
break;
}
}
for (Int k = 0; k < n; k++)
if (i != k && v[k][i])
v[k] ^= v[i];
}
}
int mrank(mat v, int m) {
int n = v.size();
int r = 0, c = 0;
for (int i = 0; i < n; i++) {
int s = -1;
while (c < m) {
for (int j = i; j < n; j++) {
if (v[j][c]) {
s = j;
break;
}
}
if (~s)
break;
c++;
}
if (c >= m)
break;
swap(v[i], v[s]);
for (int j = 0; j < n; j++)
if (i != j && v[j][c])
v[j] ^= v[i];
r++;
c++;
}
return r;
}
mat mul(const mat &a, const mat &b) {
int n = a.size();
vector<vector<int>> tmp(n, vector<int>(n, 0));
mat res(n, BS(0));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
tmp[i][j] += (a[i][k] & b[k][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res[i][j] = tmp[i][j] & 1;
return res;
}
mat mat_pow(mat v, int k) {
int n = v.size();
mat res(n, BS(0));
for (int i = 0; i < n; i++)
res[i][i] = 1;
while (k) {
if (k & 1)
res = mul(res, v);
v = mul(v, v);
k >>= 1;
}
return res;
}
// END CUT HERE
signed CFR382_D() {
cin.tie(0);
ios::sync_with_stdio(0);
Int n, m;
cin >> n >> m;
mat v(n, BS(0));
for (Int i = 0; i < n; i++)
v[i][n + i] = 1;
vector<Int> a(m), b(m);
for (Int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
v[a[i]][b[i]] = 1;
}
gauss(v);
for (Int i = 0; i < m; i++)
cout << (v[b[i]][a[i] + n] ? "NO" : "YES") << endl;
return 0;
}
/*
verified on 2018/01/22
http://codeforces.com/contest/736/problem/D
*/
signed ARC054_D() {
int n;
cin >> n;
mat v(n, BS(0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
v[i][j] = c - '0';
}
}
gauss(v);
int ans = 1;
for (int i = 0; i < n; i++)
ans &= v[i][i];
cout << (ans ? "Odd" : "Even") << endl;
return 0;
}
/*
verified on 2018/01/22
https://beta.atcoder.jp/contests/arc054/tasks/arc054_c
*/
signed AOJ_1308() {
int m, n, d;
while (cin >> m >> n >> d, m) {
vector<vector<int>> s(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> s[i][j];
mat v(n * m, BS(0));
auto idx = [&](int y, int x) { return y * m + x; };
auto in = [&](int y, int x) { return 0 <= y && y < n && 0 <= x && x < m; };
auto bfs = [&](int y, int x) {
int z = idx(y, x);
v[z][z] = 1;
v[z][n * m] = s[y][x];
vector<vector<int>> dp(n, vector<int>(m, -1));
using P = pair<int, int>;
queue<P> q;
dp[y][x] = 0;
q.emplace(y, x);
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
while (!q.empty()) {
tie(y, x) = q.front();
q.pop();
if (dp[y][x] == d)
v[z][idx(y, x)] = 1;
for (int k = 0; k < 4; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || ~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
};
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
bfs(i, j);
int a = mrank(v, n);
int b = mrank(v, n + 1);
cout << (a == b) << endl;
}
return 0;
}
/*
verified on 2018/01/22
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1308
*/
signed AOJ_2624() {
int n;
cin >> n;
mat v(n, BS(0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int k;
cin >> k;
v[i][j] = k;
}
}
BS w;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
w[i] = k;
}
int t;
cin >> t;
v = mat_pow(v, t);
int a = mrank(v, n);
for (int i = 0; i < n; i++)
v[i][n] = w[i];
int b = mrank(v, n + 1);
if (a != b) {
cout << "none" << endl;
return 0;
}
if (a != n) {
cout << "ambiguous" << endl;
return 0;
}
gauss(v);
for (int i = 0; i < n; i++)
cout << v[i][n] << " \n"[i == n - 1];
return 0;
}
/*
verified on 2018/01/22
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2624
*/
signed main() {
// CFR382_D();
// ARC054_D();
AOJ_1308();
// AOJ_2624();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using Int = long long;
// BEGIN CUT HERE
const Int MAX = 2002;
using BS = bitset<MAX * 2>;
using mat = vector<BS>;
void gauss(mat &v) {
int n = v.size();
for (Int i = 0; i < n; i++) {
for (Int k = i; k < n; k++) {
if (v[k][i]) {
swap(v[i], v[k]);
break;
}
}
for (Int k = 0; k < n; k++)
if (i != k && v[k][i])
v[k] ^= v[i];
}
}
int mrank(mat v, int m) {
int n = v.size();
int r = 0, c = 0;
for (int i = 0; i < n; i++) {
int s = -1;
while (c < m) {
for (int j = i; j < n; j++) {
if (v[j][c]) {
s = j;
break;
}
}
if (~s)
break;
c++;
}
if (c >= m)
break;
swap(v[i], v[s]);
for (int j = 0; j < n; j++)
if (i != j && v[j][c])
v[j] ^= v[i];
r++;
c++;
}
return r;
}
mat mul(const mat &a, const mat &b) {
int n = a.size();
vector<vector<int>> tmp(n, vector<int>(n, 0));
mat res(n, BS(0));
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
for (int k = 0; k < n; k++)
tmp[i][j] += (a[i][k] & b[k][j]);
for (int i = 0; i < n; i++)
for (int j = 0; j < n; j++)
res[i][j] = tmp[i][j] & 1;
return res;
}
mat mat_pow(mat v, int k) {
int n = v.size();
mat res(n, BS(0));
for (int i = 0; i < n; i++)
res[i][i] = 1;
while (k) {
if (k & 1)
res = mul(res, v);
v = mul(v, v);
k >>= 1;
}
return res;
}
// END CUT HERE
signed CFR382_D() {
cin.tie(0);
ios::sync_with_stdio(0);
Int n, m;
cin >> n >> m;
mat v(n, BS(0));
for (Int i = 0; i < n; i++)
v[i][n + i] = 1;
vector<Int> a(m), b(m);
for (Int i = 0; i < m; i++) {
cin >> a[i] >> b[i];
a[i]--;
b[i]--;
v[a[i]][b[i]] = 1;
}
gauss(v);
for (Int i = 0; i < m; i++)
cout << (v[b[i]][a[i] + n] ? "NO" : "YES") << endl;
return 0;
}
/*
verified on 2018/01/22
http://codeforces.com/contest/736/problem/D
*/
signed ARC054_D() {
int n;
cin >> n;
mat v(n, BS(0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
char c;
cin >> c;
v[i][j] = c - '0';
}
}
gauss(v);
int ans = 1;
for (int i = 0; i < n; i++)
ans &= v[i][i];
cout << (ans ? "Odd" : "Even") << endl;
return 0;
}
/*
verified on 2018/01/22
https://beta.atcoder.jp/contests/arc054/tasks/arc054_c
*/
signed AOJ_1308() {
int m, n, d;
while (cin >> m >> n >> d, m) {
vector<vector<int>> s(n, vector<int>(m));
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
cin >> s[i][j];
mat v(n * m, BS(0));
auto idx = [&](int y, int x) { return y * m + x; };
auto in = [&](int y, int x) { return 0 <= y && y < n && 0 <= x && x < m; };
auto bfs = [&](int y, int x) {
int z = idx(y, x);
v[z][z] = 1;
v[z][n * m] = s[y][x];
vector<vector<int>> dp(n, vector<int>(m, -1));
using P = pair<int, int>;
queue<P> q;
dp[y][x] = 0;
q.emplace(y, x);
int dy[] = {0, 0, 1, -1};
int dx[] = {1, -1, 0, 0};
while (!q.empty()) {
tie(y, x) = q.front();
q.pop();
if (dp[y][x] == d)
v[z][idx(y, x)] = 1;
for (int k = 0; k < 4; k++) {
int ny = y + dy[k], nx = x + dx[k];
if (!in(ny, nx) || ~dp[ny][nx])
continue;
dp[ny][nx] = dp[y][x] + 1;
q.emplace(ny, nx);
}
}
};
for (int i = 0; i < n; i++)
for (int j = 0; j < m; j++)
bfs(i, j);
int a = mrank(v, n * m);
int b = mrank(v, n * m + 1);
cout << (a == b) << endl;
}
return 0;
}
/*
verified on 2018/01/22
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=1308
*/
signed AOJ_2624() {
int n;
cin >> n;
mat v(n, BS(0));
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
int k;
cin >> k;
v[i][j] = k;
}
}
BS w;
for (int i = 0; i < n; i++) {
int k;
cin >> k;
w[i] = k;
}
int t;
cin >> t;
v = mat_pow(v, t);
int a = mrank(v, n);
for (int i = 0; i < n; i++)
v[i][n] = w[i];
int b = mrank(v, n + 1);
if (a != b) {
cout << "none" << endl;
return 0;
}
if (a != n) {
cout << "ambiguous" << endl;
return 0;
}
gauss(v);
for (int i = 0; i < n; i++)
cout << v[i][n] << " \n"[i == n - 1];
return 0;
}
/*
verified on 2018/01/22
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=2624
*/
signed main() {
// CFR382_D();
// ARC054_D();
AOJ_1308();
// AOJ_2624();
return 0;
}
|
[["+", 49, 50, 51, 2, 3, 4, 0, 16, 17, 48], ["+", 49, 50, 51, 2, 3, 4, 0, 16, 12, 22], ["+", 51, 2, 3, 4, 0, 16, 31, 16, 17, 48], ["+", 51, 2, 3, 4, 0, 16, 31, 16, 12, 22]]
| 1
| 1,687
|
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-6;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PI;
#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()
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define SZ(a) (int(a.size()))
#define F first
#define S second
const long double pi = acos(-1.0);
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
dy[] = {1, 0, -1, 0, 1, -1, 1, -1, 0};
int n, m, d;
void solve() {
int mat[n * m][n * m + 1];
memset(mat, 0, sizeof(mat));
rep(i, m * n) mat[i][i] = 1;
queue<PI> q;
q.push(mp(0, 0));
set<PI> app;
vector<PI> man;
while (!q.empty()) {
int cx = q.front().F;
int cy = q.front().S;
q.pop();
if (app.count(mp(cx, cy)))
continue;
app.insert(mp(cx, cy));
if (abs(cx) + abs(cy) == d) {
man.pb(mp(cx, cy));
continue;
}
rep(i, 4) {
int nx = cx + dx[i], ny = cy + dy[i];
if (app.count(mp(nx, ny)))
continue;
q.push(mp(nx, ny));
}
}
rep(i, m * n) FOR(it, man) {
int x = i / m + it->F, y = i % m + it->S;
if (min(x, y) < 0 || x >= n || y >= m)
continue;
mat[i][x * m + y] = 1;
}
rep(i, n) rep(j, m) cin >> mat[i * m + j][m * n];
int ofs = 0;
for (int i = 0; i + ofs < m * n; ++i) {
/*
rep(j,m*n){
rep(k,m*n+1)cout<<mat[j][k]<<' ';
cout<<endl;
}
cout<<endl;
*/
if (!mat[i][i + ofs])
for (int j = m * n - 1; j > i; --j)
if (mat[j][i + ofs]) {
for (int k = 0; k < m * n + 1; ++k)
swap(mat[i][k], mat[j][k]);
break;
}
if (mat[i][i + ofs]) {
for (int j = i + 1; j < m * n; ++j)
if (mat[j][i + ofs])
rep(k, m * n + 1) mat[j][k] ^= mat[i][k];
} else
++ofs, --i;
}
for (int i = m * n - 1; i > m * n - 1 - ofs; --i)
if (mat[i][m * n]) {
cout << 0 << endl;
return;
}
cout << 1 << endl;
}
main() {
while (cin >> n >> m >> d, n | m | d)
solve();
}
|
#include <algorithm>
#include <cassert>
#include <cfloat>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <fstream>
#include <functional>
#include <iostream>
#include <list>
#include <map>
#include <memory>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
static const double EPS = 1e-6;
typedef long long ll;
typedef unsigned long long ull;
typedef pair<int, int> PI;
#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()
#define mp(a, b) make_pair(a, b)
#define pb(a) push_back(a)
#define SZ(a) (int(a.size()))
#define F first
#define S second
const long double pi = acos(-1.0);
int dx[] = {0, 1, 0, -1, 1, 1, -1, -1, 0},
dy[] = {1, 0, -1, 0, 1, -1, 1, -1, 0};
int n, m, d;
void solve() {
int mat[n * m][n * m + 1];
memset(mat, 0, sizeof(mat));
rep(i, m * n) mat[i][i] = 1;
queue<PI> q;
q.push(mp(0, 0));
set<PI> app;
vector<PI> man;
while (!q.empty()) {
int cx = q.front().F;
int cy = q.front().S;
q.pop();
if (app.count(mp(cx, cy)))
continue;
app.insert(mp(cx, cy));
if (abs(cx) + abs(cy) == d) {
man.pb(mp(cx, cy));
continue;
}
rep(i, 4) {
int nx = cx + dx[i], ny = cy + dy[i];
if (app.count(mp(nx, ny)))
continue;
q.push(mp(nx, ny));
}
}
rep(i, m * n) FOR(it, man) {
int x = i / m + it->F, y = i % m + it->S;
if (min(x, y) < 0 || x >= n || y >= m)
continue;
mat[i][x * m + y] = 1;
}
rep(i, n) rep(j, m) cin >> mat[i * m + j][m * n];
int ofs = 0;
for (int i = 0; i + ofs < m * n; ++i) {
/*
rep(j,m*n){
rep(k,m*n+1)cout<<mat[j][k]<<' ';
cout<<endl;
}
cout<<endl;
*/
if (!mat[i][i + ofs])
for (int j = m * n - 1; j > i; --j)
if (mat[j][i + ofs]) {
for (int k = 0; k < m * n + 1; ++k)
swap(mat[i][k], mat[j][k]);
break;
}
if (mat[i][i + ofs]) {
for (int j = i + 1; j < m * n; ++j)
if (mat[j][i + ofs])
rep(k, m * n + 1) mat[j][k] ^= mat[i][k];
} else
++ofs, --i;
}
for (int i = m * n - 1; i > m * n - 1 - ofs; --i)
if (mat[i][m * n]) {
cout << 0 << endl;
return;
}
cout << 1 << endl;
}
main() {
while (cin >> m >> n >> d, n | m | d)
solve();
}
|
[["-", 51, 34, 31, 16, 31, 16, 31, 16, 12, 22], ["-", 15, 339, 51, 34, 31, 16, 31, 16, 17, 152], ["+", 15, 339, 51, 34, 31, 16, 31, 16, 17, 152], ["+", 15, 339, 51, 34, 31, 16, 31, 16, 12, 22]]
| 1
| 794
|
// 59
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main() {
for (int m, n, d; cin >> m >> n >> d, m | n | d;) {
vector<vector<int>> v(m * n, vector<int>(m * n + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
int cd = abs(i - k) + abs(j - l);
v[i * n + j][k * n + l] = cd == 0 || cd == d;
}
}
cin >> v[i * n + j].back();
}
}
int dn = 0;
for (int i = 0; i < n * m; i++) {
int j;
for (j = dn; j < v.size(); j++) {
if (v[j][i])
break;
}
if (j == v.size())
continue;
swap(v[dn], v[j]);
for (int k = dn + 1; k < v.size(); k++) {
if (v[k][i]) {
for (int l = 0; l < v[k].size(); l++) {
v[k][l] ^= v[dn][l];
}
}
}
dn++;
}
int i;
for (i = dn; i < v.size(); i++) {
if (v[i].back())
break;
}
cout << (i == v.size()) << endl;
}
return 0;
}
|
// 59
#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <vector>
using namespace std;
int main() {
for (int m, n, d; cin >> m >> n >> d, m | n | d;) {
vector<vector<int>> v(m * n, vector<int>(m * n + 1));
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
for (int k = 0; k < n; k++) {
for (int l = 0; l < m; l++) {
int cd = abs(i - k) + abs(j - l);
v[i * m + j][k * m + l] = cd == 0 || cd == d;
}
}
cin >> v[i * m + j].back();
}
}
int dn = 0;
for (int i = 0; i < n * m; i++) {
int j;
for (j = dn; j < v.size(); j++) {
if (v[j][i])
break;
}
if (j == v.size())
continue;
swap(v[dn], v[j]);
for (int k = dn + 1; k < v.size(); k++) {
if (v[k][i]) {
for (int l = 0; l < v[k].size(); l++) {
v[k][l] ^= v[dn][l];
}
}
}
dn++;
}
int i;
for (i = dn; i < v.size(); i++) {
if (v[i].back())
break;
}
cout << (i == v.size()) << endl;
}
return 0;
}
|
[["-", 28, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["+", 28, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["-", 31, 69, 341, 342, 0, 16, 31, 16, 12, 22], ["+", 31, 69, 341, 342, 0, 16, 31, 16, 12, 22]]
| 1
| 401
|
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <set>
#include <unordered_set>
using namespace std;
typedef pair<int, int> pii;
/// pair<int,int> hasher
namespace std {
template <typename I> class hash<pair<I, I>> {
public:
size_t operator()(const pair<I, I> &p) const {
return hash<long long>()(((long long)(p.first)) << 32 | p.second);
}
};
} // namespace std
double solve(const vector<pii> &a) {
set<int> ys;
for (auto &e : a)
ys.insert(e.second);
int n = a.size();
vector<double> mx, my;
for (int i = 0; i < n; i++) {
mx.push_back(a[i].first);
my.push_back(a[i].second);
if (i == n - 1)
continue;
//??????????????§y??§?¨??????????ys?????????????????????
if (a[i].second < a[i + 1].second) { //??????i????°???§??????
for (auto it = ys.begin(); it != ys.end(); ++it) {
if (a[i].second < *it && *it < a[i + 1].second) {
double dy = a[i + 1].second - a[i].second;
double dx = (a[i + 1].first - a[i].first) / dy * (*it - a[i].second);
mx.push_back(a[i].first + dx);
my.push_back(*it);
break;
}
}
} else { //??????i????±±??§??????
for (auto it = ys.end(); it-- != ys.begin();) {
if (a[i + 1].second < *it && *it < a[i].second) {
double dy = a[i + 1].second - a[i].second;
double dx = (a[i + 1].first - a[i].first) / dy * (*it - a[i].second);
mx.push_back(a[i].first + dx);
my.push_back(*it);
break;
}
}
}
}
int m = mx.size();
priority_queue<pair<double, pii>> q;
unordered_set<pii> se;
q.push({0, {0, m - 1}});
for (; !q.empty();) {
double c = q.top().first;
int l = q.top().second.first;
int r = q.top().second.second;
q.pop();
if (se.find({l, r}) != se.end())
continue;
se.insert({l, r});
if (l == r)
return -c;
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++)
if (0 <= l + i && l + i < m && 0 <= r + j && r + j < m &&
fabs(my[l + i] - my[r + j]) < 1e-9)
q.push({c - hypot(mx[l] - mx[l + i], my[l] - my[l + i]) -
hypot(mx[r] - mx[r + j], my[r] - my[r + j]),
{l + i, r + j}});
}
abort();
}
int main() {
int N, x, y;
for (; scanf("%d", &N), N;) {
vector<pii> a(N);
for (int i = 0; i < N; i++)
scanf("%d%d", &a[i].first, &a[i].second);
printf("%f\n", solve(a));
}
}
|
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <queue>
#include <set>
#include <unordered_set>
using namespace std;
typedef pair<int, int> pii;
/// pair<int,int> hasher
namespace std {
template <typename I> class hash<pair<I, I>> {
public:
size_t operator()(const pair<I, I> &p) const {
return hash<long long>()(((long long)(p.first)) << 32 | p.second);
}
};
} // namespace std
double solve(const vector<pii> &a) {
set<int> ys;
for (auto &e : a)
ys.insert(e.second);
int n = a.size();
vector<double> mx, my;
for (int i = 0; i < n; i++) {
mx.push_back(a[i].first);
my.push_back(a[i].second);
if (i == n - 1)
continue;
//??????????????§y??§?¨??????????ys?????????????????????
if (a[i].second < a[i + 1].second) { //??????i????°???§??????
for (auto it = ys.begin(); it != ys.end(); ++it) {
if (a[i].second < *it && *it < a[i + 1].second) {
double dy = a[i + 1].second - a[i].second;
double dx = (a[i + 1].first - a[i].first) / dy * (*it - a[i].second);
mx.push_back(a[i].first + dx);
my.push_back(*it);
}
}
} else { //??????i????±±??§??????
for (auto it = ys.end(); it-- != ys.begin();) {
if (a[i + 1].second < *it && *it < a[i].second) {
double dy = a[i + 1].second - a[i].second;
double dx = (a[i + 1].first - a[i].first) / dy * (*it - a[i].second);
mx.push_back(a[i].first + dx);
my.push_back(*it);
}
}
}
}
int m = mx.size();
priority_queue<pair<double, pii>> q;
unordered_set<pii> se;
q.push({0, {0, m - 1}});
for (; !q.empty();) {
double c = q.top().first;
int l = q.top().second.first;
int r = q.top().second.second;
q.pop();
if (se.find({l, r}) != se.end())
continue;
se.insert({l, r});
if (l == r)
return -c;
for (int i = -1; i < 2; i++)
for (int j = -1; j < 2; j++)
if (0 <= l + i && l + i < m && 0 <= r + j && r + j < m &&
fabs(my[l + i] - my[r + j]) < 1e-9)
q.push({c - hypot(mx[l] - mx[l + i], my[l] - my[l + i]) -
hypot(mx[r] - mx[r + j], my[r] - my[r + j]),
{l + i, r + j}});
}
abort();
}
int main() {
int N, x, y;
for (; scanf("%d", &N), N;) {
vector<pii> a(N);
for (int i = 0; i < N; i++)
scanf("%d%d", &a[i].first, &a[i].second);
printf("%f\n", solve(a));
}
}
|
[["-", 8, 9, 0, 57, 64, 9, 0, 93, 0, 94], ["-", 8, 9, 0, 57, 64, 9, 0, 93, 0, 35], ["-", 8, 9, 0, 57, 64, 9, 0, 1, 0, 35]]
| 1
| 861
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, bg, ed) for (int i = bg; i < ed; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define fi first
#define se second
#define pb push_back
typedef long long LL;
const LL INF = 1e10;
template <typename T> bool chmin(T &l, T r) {
bool ret = l > r;
if (ret)
l = r;
return ret;
}
LL N, S, W, Q;
void solve() {
vector<LL> a(N), b(N + 1, 0);
LL g = S;
LL ten = 1;
REP(i, N) {
a[i] = (g / 7) % 10;
if (g % 2 == 0) {
g = (g / 2);
} else {
g = (g / 2) ^ W;
}
}
reverse(ALL(a));
if (Q == 2) {
LL ret = 0;
REP(i, N) b[i] = (a[i] != 0);
for (int i = N - 1; i >= 0; i--) {
if (a[i] % 2 == 0) {
ret += b[i];
if (a[i] != 0)
ret++;
}
b[i] += b[i + 1];
}
cout << ret << endl;
} else if (Q == 5) {
LL ret = 0;
REP(i, N) b[i] = (a[i] != 0);
for (int i = N - 1; i >= 0; i--) {
if (a[i] % 5 == 0) {
ret += b[i];
if (a[i] != 0)
ret++;
}
b[i] += b[i + 1];
}
cout << ret << endl;
} else {
REP(i, N) {
b[i + 1] = (a[i] * ten + b[i]) % Q;
ten = ten * 10 % Q;
}
LL ret = 0;
map<LL, int> cnt;
for (int i = N - 1; i >= 0; i--) {
LL C = b[i + 1];
ret += cnt[C];
if (a[i] != 0)
cnt[b[i + 1]]++;
}
cout << ret + cnt[0] << endl;
}
}
int main() {
while (cin >> N >> S >> W >> Q, N)
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define FOR(i, bg, ed) for (int i = bg; i < ed; i++)
#define REP(i, n) FOR(i, 0, n)
#define ALL(v) (v).begin(), (v).end()
#define fi first
#define se second
#define pb push_back
typedef long long LL;
const LL INF = 1e10;
template <typename T> bool chmin(T &l, T r) {
bool ret = l > r;
if (ret)
l = r;
return ret;
}
LL N, S, W, Q;
void solve() {
vector<LL> a(N), b(N + 1, 0);
LL g = S;
LL ten = 1;
REP(i, N) {
a[i] = (g / 7) % 10;
if (g % 2 == 0) {
g = (g / 2);
} else {
g = (g / 2) ^ W;
}
}
reverse(ALL(a));
if (Q == 2) {
LL ret = 0;
REP(i, N) b[i] = (a[i] != 0);
for (int i = N - 1; i >= 0; i--) {
if (a[i] % 2 == 0) {
ret += b[i + 1];
if (a[i] != 0)
ret++;
}
b[i] += b[i + 1];
}
cout << ret << endl;
} else if (Q == 5) {
LL ret = 0;
REP(i, N) b[i] = (a[i] != 0);
for (int i = N - 1; i >= 0; i--) {
if (a[i] % 5 == 0) {
ret += b[i + 1];
if (a[i] != 0)
ret++;
}
b[i] += b[i + 1];
}
cout << ret << endl;
} else {
REP(i, N) {
b[i + 1] = (a[i] * ten + b[i]) % Q;
ten = ten * 10 % Q;
}
LL ret = 0;
map<LL, int> cnt;
for (int i = N - 1; i >= 0; i--) {
LL C = b[i + 1];
ret += cnt[C];
if (a[i] != 0)
cnt[b[i + 1]]++;
}
cout << ret + cnt[0] << endl;
}
}
int main() {
while (cin >> N >> S >> W >> Q, N)
solve();
return 0;
}
|
[["+", 0, 11, 12, 69, 341, 342, 0, 16, 17, 72], ["+", 0, 11, 12, 69, 341, 342, 0, 16, 12, 13]]
| 1
| 539
|
#include <bits/stdc++.h>
#define GET_MACRO(_1, _2, _3, _4, _5, NAME, ...) NAME
#define pr(...) GET_MACRO(__VA_ARGS__, pr5, pr4, pr3, pr2, pr1)(__VA_ARGS__)
#define pr1(a) (#a) << "=" << (a)
#define pr2(a, b) pr1(a) << ", " << pr1(b)
#define pr3(a, b, c) pr2(a, b) << ", " << pr1(c)
#define pr4(a, b, c, d) pr3(a, b, c) << ", " << pr1(d)
#define pr5(a, b, c, d, e) pr4(a, b, c, d) << ", " << pr1(e)
#define int long long
#define double long double
using namespace std;
const int N = 100010;
const int INF = 1LL << 55;
const int mod = (1e9) + 7;
const double EPS = 1e-8;
const double PI = 6.0 * asin(0.5);
typedef pair<int, int> P;
typedef long long ll;
template <class T> T Max(T &a, T b) { return a = max(a, b); }
template <class T> T Min(T &a, T b) { return a = min(a, b); }
ostream &operator<<(ostream &o, P p) {
return o << "(" << p.first << "," << p.second << ")";
}
istream &operator>>(istream &i, P &p) { return i >> p.first >> p.second; }
ostream &operator<<(ostream &o, vector<auto> &a) {
int i = 0;
for (auto t : a)
o << (i++ ? " " : "") << t;
return o;
}
istream &operator>>(istream &i, vector<auto> &a) {
for (auto &t : a)
i >> t;
return i;
}
void prArr(auto a, string s = " ") {
int i = 0;
for (auto t : a)
cout << (i++ ? s : "") << t;
cout << endl;
}
vector<int> mkSeq(int n, int S, int W) {
vector<int> a(n);
int g = S;
for (int i = 0; i < n; i++) {
a[i] += (g / 7) % 10;
g = (g % 2 == 0) ? g / 2 : (g / 2) ^ W;
}
return a;
}
class RollingHash {
public:
typedef unsigned long long ull;
const ull B = 10; //ハッシュ基数
int mod;
int n;
vector<int> s;
vector<ull> hash;
vector<ull> k;
RollingHash(){};
RollingHash(vector<int> s, int mod)
: mod(mod), n(s.size()), s(s), hash(n + 1), k(n + 1) {
k[0] = 1;
for (int i = 1; i <= n; i++)
k[i] = k[i - 1] * B % mod;
for (int i = 0; i < n; i++)
hash[i + 1] = (hash[i] * B + s[i]) % mod;
for (int i = 0; i < n; i++)
hash[i + 1] = hash[i + 1] * k[n - i - 1] % mod;
}
ull get(int l, int r) {
assert(0 <= l && r <= n);
return hash[r] - hash[l] * k[r - l];
} //[l,r)
};
int n, Q;
vector<int> A;
int mem[N][10], used[N][10];
int dfs(int idx, int mod) {
if (idx == n)
return mod == 0;
if (used[idx][mod]++)
return mem[idx][mod];
int nmod = (mod * 10 + A[idx]) % Q;
int res = dfs(idx + 1, nmod) + (nmod == 0);
return mem[idx][mod] = res;
}
signed main() {
while (1) {
int S, W;
cin >> n >> S >> W >> Q;
if (!n && !S && !W && !Q)
return 0;
A = mkSeq(n, S, W);
if (Q == 2 || Q == 5) {
memset(used, 0, sizeof(used));
int ans = 0;
for (int i = 0; i < n; i++)
if (A[i])
ans += dfs(i, 0);
cout << ans << endl;
continue;
};
RollingHash H(A, Q);
map<int, int> cnt;
for (int i = 0; i < n; i++)
cnt[H.hash[i + 1]]++;
int ans = 0;
int ofset = 0;
for (int i = 0; i < n; i++) {
if (A[i] != 0)
ans += cnt[ofset];
cnt[H.hash[i + 1]]--;
ofset += A[i] * H.k[n - i - 1];
ofset %= Q;
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
#define GET_MACRO(_1, _2, _3, _4, _5, NAME, ...) NAME
#define pr(...) GET_MACRO(__VA_ARGS__, pr5, pr4, pr3, pr2, pr1)(__VA_ARGS__)
#define pr1(a) (#a) << "=" << (a)
#define pr2(a, b) pr1(a) << ", " << pr1(b)
#define pr3(a, b, c) pr2(a, b) << ", " << pr1(c)
#define pr4(a, b, c, d) pr3(a, b, c) << ", " << pr1(d)
#define pr5(a, b, c, d, e) pr4(a, b, c, d) << ", " << pr1(e)
#define int long long
#define double long double
using namespace std;
const int N = 100010;
const int INF = 1LL << 55;
const int mod = (1e9) + 7;
const double EPS = 1e-8;
const double PI = 6.0 * asin(0.5);
typedef pair<int, int> P;
typedef long long ll;
template <class T> T Max(T &a, T b) { return a = max(a, b); }
template <class T> T Min(T &a, T b) { return a = min(a, b); }
ostream &operator<<(ostream &o, P p) {
return o << "(" << p.first << "," << p.second << ")";
}
istream &operator>>(istream &i, P &p) { return i >> p.first >> p.second; }
ostream &operator<<(ostream &o, vector<auto> &a) {
int i = 0;
for (auto t : a)
o << (i++ ? " " : "") << t;
return o;
}
istream &operator>>(istream &i, vector<auto> &a) {
for (auto &t : a)
i >> t;
return i;
}
void prArr(auto a, string s = " ") {
int i = 0;
for (auto t : a)
cout << (i++ ? s : "") << t;
cout << endl;
}
vector<int> mkSeq(int n, int S, int W) {
vector<int> a(n);
int g = S;
for (int i = 0; i < n; i++) {
a[i] += (g / 7) % 10;
g = (g % 2 == 0) ? g / 2 : (g / 2) ^ W;
}
return a;
}
class RollingHash {
public:
typedef unsigned long long ull;
const ull B = 10; //ハッシュ基数
int mod;
int n;
vector<int> s;
vector<ull> hash;
vector<ull> k;
RollingHash(){};
RollingHash(vector<int> s, int mod)
: mod(mod), n(s.size()), s(s), hash(n + 1), k(n + 1) {
k[0] = 1;
for (int i = 1; i <= n; i++)
k[i] = k[i - 1] * B % mod;
for (int i = 0; i < n; i++)
hash[i + 1] = (hash[i] * B + s[i]) % mod;
for (int i = 0; i < n; i++)
hash[i + 1] = hash[i + 1] * k[n - i - 1] % mod;
}
ull get(int l, int r) {
assert(0 <= l && r <= n);
return hash[r] - hash[l] * k[r - l];
} //[l,r)
};
int n, Q;
vector<int> A;
int mem[N][10], used[N][10];
int dfs(int idx, int mod) {
if (idx == n)
return 0;
if (used[idx][mod]++)
return mem[idx][mod];
int nmod = (mod * 10 + A[idx]) % Q;
int res = dfs(idx + 1, nmod) + (nmod == 0);
return mem[idx][mod] = res;
}
signed main() {
while (1) {
int S, W;
cin >> n >> S >> W >> Q;
if (!n && !S && !W && !Q)
return 0;
A = mkSeq(n, S, W);
if (Q == 2 || Q == 5) {
memset(used, 0, sizeof(used));
int ans = 0;
for (int i = 0; i < n; i++)
if (A[i])
ans += dfs(i, 0);
cout << ans << endl;
continue;
};
RollingHash H(A, Q);
map<int, int> cnt;
for (int i = 0; i < n; i++)
cnt[H.hash[i + 1]]++;
int ans = 0;
int ofset = 0;
for (int i = 0; i < n; i++) {
if (A[i] != 0)
ans += cnt[ofset];
cnt[H.hash[i + 1]]--;
ofset += A[i] * H.k[n - i - 1];
ofset %= Q;
}
cout << ans << endl;
}
return 0;
}
|
[["-", 8, 9, 0, 57, 64, 37, 0, 16, 31, 22], ["-", 8, 9, 0, 57, 64, 37, 0, 16, 17, 60]]
| 1
| 1,087
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int N, S, W, Q;
int a[100000];
void solve() {
unsigned int res = 0;
map<int, int> M;
M.clear();
int g = S;
for (int i = 0; i < N; i++) {
a[i] = (g / 7) % 10;
if (g % 2 == 0) {
g = (g / 2);
} else {
g = (g / 2) ^ W;
}
}
if (Q == 2 || Q == 5) {
int count = 0;
for (int i = N - 1; i >= 0; i--) {
if (a[i] % Q == 0) {
count++;
if (a[i] != 0)
res += count;
}
}
cout << res << endl;
return;
}
res = 0;
int mul = 1;
int bef = 0;
for (int i = N - 1; i >= 0; i--) {
bef = (a[i] * mul + bef) % Q;
if (!M.count(bef))
M[bef] = 1;
else
M[bef]++;
mul = (10 * mul) % Q;
if (a[i] != 0)
res += M[bef] - (bef != 0);
}
cout << res << endl;
}
int main() {
while (cin >> N >> S >> W >> Q) {
if (N == 0 && S == 0 && W == 0 && Q == 0)
break;
solve();
}
return 0;
}
|
#include <iostream>
#include <map>
#include <vector>
using namespace std;
int N, S, W, Q;
int a[100000];
void solve() {
unsigned int res = 0;
map<int, int> M;
M.clear();
int g = S;
for (int i = 0; i < N; i++) {
a[i] = (g / 7) % 10;
if (g % 2 == 0) {
g = (g / 2);
} else {
g = (g / 2) ^ W;
}
}
if (Q == 2 || Q == 5) {
int count = 0;
for (int i = N - 1; i >= 0; i--) {
if (a[i] % Q == 0)
count++;
if (a[i] != 0)
res += count;
}
cout << res << endl;
return;
}
res = 0;
int mul = 1;
int bef = 0;
for (int i = N - 1; i >= 0; i--) {
bef = (a[i] * mul + bef) % Q;
if (!M.count(bef))
M[bef] = 1;
else
M[bef]++;
mul = (10 * mul) % Q;
if (a[i] != 0)
res += M[bef] - (bef != 0);
}
cout << res << endl;
}
int main() {
while (cin >> N >> S >> W >> Q) {
if (N == 0 && S == 0 && W == 0 && Q == 0)
break;
solve();
}
return 0;
}
|
[["-", 0, 7, 8, 9, 0, 57, 64, 9, 0, 45], ["-", 0, 7, 8, 9, 0, 57, 64, 9, 0, 46]]
| 1
| 344
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
struct edge {
int to, cost;
edge() {}
edge(int to, int cost) : to(to), cost(cost) {}
};
int n, m, c;
vector<vector<edge>> graph;
struct State {
int now, cost, chg;
State() {}
State(int now, int cost, int chg) : now(now), cost(cost), chg(chg) {}
bool operator<(const State &s) const { return cost > s.cost; }
};
vector<vint> mincost;
int dijkstra() {
resz(mincost, n, vint(n, inf));
priority_queue<State> que;
mincost[0][0] = 0;
que.emplace(0, 0, 0);
while (!que.empty()) {
State s = que.top();
que.pop();
int v = s.now, cost = s.cost, chg = s.chg;
if (mincost[chg][v] < cost)
continue;
for (edge &e : graph[v]) {
if (cost + e.cost < mincost[chg][e.to]) {
mincost[chg][e.to] = cost + e.cost;
que.emplace(e.to, mincost[chg][e.to], chg);
}
if (chg < n && cost < mincost[chg + 1][e.to]) {
mincost[chg + 1][e.to] = cost;
que.emplace(e.to, mincost[chg + 1][e.to], chg + 1);
}
}
}
rep(i, n + 1) {
if (mincost[i][n - 1] <= c)
return i;
}
return n;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m >> c, n + m + c) {
resz(graph, n);
rep(i, m) {
int f, t, cc;
cin >> f >> t >> cc;
--f, --t;
graph[f].emplace_back(t, cc);
}
cout << dijkstra() << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define int long long
#define all(v) (v).begin(), (v).end()
#define resz(v, ...) (v).clear(), (v).resize(__VA_ARGS__)
#define reps(i, m, n) for (int i = (int)(m); i < (int)(n); i++)
#define rep(i, n) reps(i, 0, n)
template <class T1, class T2> void chmin(T1 &a, T2 b) {
if (a > b)
a = b;
}
template <class T1, class T2> void chmax(T1 &a, T2 b) {
if (a < b)
a = b;
}
typedef pair<int, int> Pi;
typedef tuple<int, int, int> Ti;
typedef vector<int> vint;
const int inf = 1LL << 55;
const int mod = 1e9 + 7;
struct edge {
int to, cost;
edge() {}
edge(int to, int cost) : to(to), cost(cost) {}
};
int n, m, c;
vector<vector<edge>> graph;
struct State {
int now, cost, chg;
State() {}
State(int now, int cost, int chg) : now(now), cost(cost), chg(chg) {}
bool operator<(const State &s) const { return cost > s.cost; }
};
vector<vint> mincost;
int dijkstra() {
resz(mincost, n + 1, vint(n, inf));
priority_queue<State> que;
mincost[0][0] = 0;
que.emplace(0, 0, 0);
while (!que.empty()) {
State s = que.top();
que.pop();
int v = s.now, cost = s.cost, chg = s.chg;
if (mincost[chg][v] < cost)
continue;
for (edge &e : graph[v]) {
if (cost + e.cost < mincost[chg][e.to]) {
mincost[chg][e.to] = cost + e.cost;
que.emplace(e.to, mincost[chg][e.to], chg);
}
if (chg < n && cost < mincost[chg + 1][e.to]) {
mincost[chg + 1][e.to] = cost;
que.emplace(e.to, mincost[chg + 1][e.to], chg + 1);
}
}
}
rep(i, n + 1) {
if (mincost[i][n - 1] <= c)
return i;
}
return n;
}
signed main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
cout << fixed << setprecision(12);
while (cin >> n >> m >> c, n + m + c) {
resz(graph, n);
rep(i, m) {
int f, t, cc;
cin >> f >> t >> cc;
--f, --t;
graph[f].emplace_back(t, cc);
}
cout << dijkstra() << endl;
}
return 0;
}
|
[["+", 0, 1, 0, 2, 3, 4, 0, 16, 17, 72], ["+", 0, 1, 0, 2, 3, 4, 0, 16, 12, 13]]
| 1
| 639
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
struct state {
int v, cnt, d;
state(int v, int c, int d) : v(v), cnt(c), d(d) {}
bool operator>(const state &s) const { return d > s.d; }
};
struct edge {
int to, cost;
edge(int t, int c) : to(t), cost(c) {}
};
int ans;
vector<vector<edge>> es;
vector<int> dist;
void dijkstra(int s, int t, int limit) {
ans = INT_MAX;
priority_queue<state, vector<state>, greater<state>> que;
vector<vector<int>> dist(es.size(), vector<int>(es.size(), INT_MAX));
que.push(state(s, 0, 0));
dist[s][0] = 0;
while (!que.empty()) {
const state s = que.top();
que.pop();
if (dist[s.v][s.cnt] < s.d || s.cnt >= (int)es.size())
continue;
if (s.d > limit)
return;
if (s.v == t)
chmin(ans, s.cnt);
for (int i = 0; i < es[s.v].size(); ++i) {
const edge &e = es[s.v][i];
if (dist[e.to][s.cnt + 1] > s.d) {
dist[e.to][s.cnt + 1] = s.d;
que.push(state(e.to, s.cnt + 1, s.d));
}
const int next_dist = dist[s.v][s.cnt] + e.cost;
if (dist[e.to][s.cnt] > next_dist) {
dist[e.to][s.cnt] = next_dist;
que.push(state(e.to, s.cnt, next_dist));
}
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int n, m, c; cin >> n >> m >> c, n;) {
es.clear();
es.resize(n);
for (int i = 0; i < m; ++i) {
int f, t, d;
cin >> f >> t >> d;
--f;
--t;
es[f].push_back(edge(t, d));
}
dijkstra(0, n - 1, c);
cout << ans << endl;
}
return EXIT_SUCCESS;
}
|
#include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <climits>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <iterator>
#include <list>
#include <map>
#include <numeric>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <string>
#include <utility>
#include <vector>
using namespace std;
#define dump(a) (cerr << (#a) << " = " << (a) << endl)
#define FOR(it, c) \
for (__typeof((c).begin()) it = (c).begin(); it != (c).end(); ++it)
#define RFOR(it, c) \
for (__typeof((c).rbegin()) it = (c).rbegin(); it != (c).rend(); ++it)
#define exist(c, v) (find((c).begin(), (c).end(), (v)) != (c).end())
template <class T> inline void chmax(T &a, const T &b) {
if (b > a)
a = b;
}
template <class T> inline void chmin(T &a, const T &b) {
if (b < a)
a = b;
}
template <typename T, typename U>
ostream &operator<<(ostream &os, const pair<T, U> &p) {
os << '(' << p.first << ", " << p.second << ')';
return os;
}
template <typename T> ostream &operator<<(ostream &os, const vector<T> &v) {
copy(v.begin(), v.end(), ostream_iterator<T>(os, " "));
return os;
}
struct state {
int v, cnt, d;
state(int v, int c, int d) : v(v), cnt(c), d(d) {}
bool operator>(const state &s) const { return d > s.d; }
};
struct edge {
int to, cost;
edge(int t, int c) : to(t), cost(c) {}
};
int ans;
vector<vector<edge>> es;
vector<int> dist;
void dijkstra(int s, int t, int limit) {
ans = INT_MAX;
priority_queue<state, vector<state>, greater<state>> que;
vector<vector<int>> dist(es.size(), vector<int>(es.size() + 1, INT_MAX));
que.push(state(s, 0, 0));
dist[s][0] = 0;
while (!que.empty()) {
const state s = que.top();
que.pop();
if (dist[s.v][s.cnt] < s.d || s.cnt >= (int)es.size())
continue;
if (s.d > limit)
return;
if (s.v == t)
chmin(ans, s.cnt);
for (int i = 0; i < es[s.v].size(); ++i) {
const edge &e = es[s.v][i];
if (dist[e.to][s.cnt + 1] > s.d) {
dist[e.to][s.cnt + 1] = s.d;
que.push(state(e.to, s.cnt + 1, s.d));
}
const int next_dist = dist[s.v][s.cnt] + e.cost;
if (dist[e.to][s.cnt] > next_dist) {
dist[e.to][s.cnt] = next_dist;
que.push(state(e.to, s.cnt, next_dist));
}
}
}
}
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
for (int n, m, c; cin >> n >> m >> c, n;) {
es.clear();
es.resize(n);
for (int i = 0; i < m; ++i) {
int f, t, d;
cin >> f >> t >> d;
--f;
--t;
es[f].push_back(edge(t, d));
}
dijkstra(0, n - 1, c);
cout << ans << endl;
}
return EXIT_SUCCESS;
}
|
[["+", 51, 4, 0, 2, 3, 4, 0, 16, 17, 72], ["+", 51, 4, 0, 2, 3, 4, 0, 16, 12, 13]]
| 1
| 835
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define REP(i, b, n) for (int i = b; i < n; i++)
#define rep(i, n) REP(i, 0, n)
const int N = 1000;
const int M = 100;
char m[N][N + 20];
char in[M][M + 20];
char *ptr[N];
int atm[N][N + 20];
void decode(int c, string &in, char *pt) {
int p = in.size() * 6 - 1;
for (int i = in.size() - 1; i >= 0; i--) {
int val;
if (isupper(in[i]))
val = in[i] - 'A';
else if (islower(in[i]))
val = in[i] - 'a' + 26;
else if (isdigit(in[i]))
val = in[i] - '0' + 52;
else if (in[i] == '+')
val = 62;
else if (in[i] == '/')
val = 63;
rep(j, 6) {
pt[p--] = val % 2 ? '1' : '0';
val /= 2;
}
}
pt[c] = '\0';
}
struct PMA {
PMA *next[3]; // next[0] is for fail, 0x100 = 256
int id;
vector<int> ac;
PMA() {
fill(next, next + 3, (PMA *)0);
id = -1;
}
};
PMA *buildPMA(char *p[M], int size, int *acdata) {
PMA *root = new PMA;
int cnt = 0;
rep(i, size) {
PMA *t = root;
for (int j = 0; p[i][j] != '\0'; j++) {
char c = p[i][j] - '0' + 1;
if (t->next[c] == NULL)
t->next[c] = new PMA;
t = t->next[c];
}
if (t->id == -1)
t->id = cnt++;
acdata[i] = t->id;
t->ac.push_back(t->id);
}
queue<PMA *> Q;
REP(i, 1, 3) {
char c = i;
if (root->next[c]) {
root->next[c]->next[0] = root;
Q.push(root->next[c]);
} else
root->next[c] = root;
}
while (!Q.empty()) {
PMA *t = Q.front();
Q.pop();
for (int c = '0' - '0' + 1; c <= '1' - '0' + 1; c++) {
if (t->next[c]) {
Q.push(t->next[c]);
PMA *r = t->next[0];
while (!r->next[c])
r = r->next[0];
t->next[c]->next[0] = r->next[c];
copy(r->next[c]->ac.begin(), r->next[c]->ac.end(),
back_inserter(t->next[c]->ac));
}
}
}
return root;
}
void match(PMA *r, char *tar, int *res) {
for (int i = 0; tar[i] != '\0'; i++) {
char c = tar[i] - '0' + 1;
while (!r->next[c])
r = r->next[0];
r = r->next[c];
rep(j, r->ac.size()) {
// res[r->ac[j]]++;
// res[r->ac[j]]=i;
res[i] = r->id; // ac[j];
}
}
}
int kmp(int p1, int *text, int p2, int *word) {
static int table[N];
int i = 2, j = 0; // i:searching word j:backtracking point
table[0] = -1; //
table[1] = 0; //
while (i <= p2) { // make table
if (word[i - 1] == word[j]) {
table[i] = j + 1;
i++;
j++;
} else if (j > 0) {
j = table[j];
} else {
table[i] = 0;
i++;
}
}
// the main part of KMP algorithm
int pos; //
int m = 0; //
int cnt = 0;
i = 0; //
while (m + i < p1) {
if (word[i] == text[m + i]) {
i++;
if (i == p2) {
// return m;
cnt++;
m = m + i - table[i];
if (i > 0)
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return cnt;
}
char pat[8][M][M + 2]; // 8 pattern
int compute(int r, int c, int p, int cur) {
int ret = 0;
static int ac[M + 10], tres[N + 10];
rep(i, p) ptr[i] = pat[cur][i];
PMA *root = buildPMA(ptr, p, ac);
rep(i, r) {
rep(j, c) tres[j] = -1;
match(root, m[i], tres);
rep(j, c) atm[i][j] = tres[j];
}
rep(j, c) {
rep(i, r) tres[i] = atm[i][j];
ret += kmp(r, tres, p, ac);
}
return ret;
}
void rotate(int n, int cur) {
static char tmp[M][M];
rep(i, n) rep(j, n) tmp[i][j] = pat[cur - 1][i][j];
rep(i, n) {
rep(j, n) { pat[cur][n - 1 - j][i] = tmp[i][j]; }
}
}
void mirror(int n, int cur) {
rep(i, n) { rep(j, n / 2) swap(pat[cur][i][j], pat[cur][i][n - 1 - j]); }
}
bool issame(int n, int cur, int tar) {
rep(i, n) { rep(j, n) if (pat[cur][i][j] != pat[tar][i][j]) return false; }
return true;
}
int solve(int r, int c, int p) {
int ret = 0;
bool check[8] = {false};
fill(check, check + 8, true);
rep(k, 8) { rep(i, p) pat[k][i][c] = '\0'; }
rep(i, p) { rep(j, p) pat[0][i][j] = pat[4][i][j] = in[i][j]; }
REP(i, 1, 4) rotate(p, i);
mirror(p, 4);
REP(i, 5, 8) rotate(p, i);
rep(i, 8) {
if (!check[i])
continue;
REP(j, i + 1, 8) {
if (issame(p, i, j))
check[j] = false;
}
}
rep(i, 8) {
if (check[i])
ret += compute(r, c, p, i);
}
return ret;
}
main() {
int c, r, p;
while (cin >> c >> r >> p && c) {
rep(i, r) {
string tmp;
cin >> tmp;
decode(c, tmp, m[i]);
}
rep(i, p) {
string tmp;
cin >> tmp;
decode(p, tmp, in[i]);
}
cout << solve(r, c, p) << endl;
}
return false;
}
|
#include <algorithm>
#include <iostream>
#include <queue>
#include <vector>
using namespace std;
#define REP(i, b, n) for (int i = b; i < n; i++)
#define rep(i, n) REP(i, 0, n)
const int N = 1000;
const int M = 100;
char m[N][N + 20];
char in[M][M + 20];
char *ptr[N];
int atm[N][N + 20];
void decode(int c, string &in, char *pt) {
int p = in.size() * 6 - 1;
for (int i = in.size() - 1; i >= 0; i--) {
int val;
if (isupper(in[i]))
val = in[i] - 'A';
else if (islower(in[i]))
val = in[i] - 'a' + 26;
else if (isdigit(in[i]))
val = in[i] - '0' + 52;
else if (in[i] == '+')
val = 62;
else if (in[i] == '/')
val = 63;
rep(j, 6) {
pt[p--] = val % 2 ? '1' : '0';
val /= 2;
}
}
pt[c] = '\0';
}
struct PMA {
PMA *next[3]; // next[0] is for fail, 0x100 = 256
int id;
vector<int> ac;
PMA() {
fill(next, next + 3, (PMA *)0);
id = -1;
}
};
PMA *buildPMA(char *p[M], int size, int *acdata) {
PMA *root = new PMA;
int cnt = 0;
rep(i, size) {
PMA *t = root;
for (int j = 0; p[i][j] != '\0'; j++) {
char c = p[i][j] - '0' + 1;
if (t->next[c] == NULL)
t->next[c] = new PMA;
t = t->next[c];
}
if (t->id == -1)
t->id = cnt++;
acdata[i] = t->id;
t->ac.push_back(t->id);
}
queue<PMA *> Q;
REP(i, 1, 3) {
char c = i;
if (root->next[c]) {
root->next[c]->next[0] = root;
Q.push(root->next[c]);
} else
root->next[c] = root;
}
while (!Q.empty()) {
PMA *t = Q.front();
Q.pop();
for (int c = '0' - '0' + 1; c <= '1' - '0' + 1; c++) {
if (t->next[c]) {
Q.push(t->next[c]);
PMA *r = t->next[0];
while (!r->next[c])
r = r->next[0];
t->next[c]->next[0] = r->next[c];
copy(r->next[c]->ac.begin(), r->next[c]->ac.end(),
back_inserter(t->next[c]->ac));
}
}
}
return root;
}
void match(PMA *r, char *tar, int *res) {
for (int i = 0; tar[i] != '\0'; i++) {
char c = tar[i] - '0' + 1;
while (!r->next[c])
r = r->next[0];
r = r->next[c];
rep(j, r->ac.size()) {
// res[r->ac[j]]++;
// res[r->ac[j]]=i;
res[i] = r->id; // ac[j];
}
}
}
int kmp(int p1, int *text, int p2, int *word) {
static int table[N];
int i = 2, j = 0; // i:searching word j:backtracking point
table[0] = -1; //
table[1] = 0; //
while (i <= p2) { // make table
if (word[i - 1] == word[j]) {
table[i] = j + 1;
i++;
j++;
} else if (j > 0) {
j = table[j];
} else {
table[i] = 0;
i++;
}
}
// the main part of KMP algorithm
int pos; //
int m = 0; //
int cnt = 0;
i = 0; //
while (m + i < p1) {
if (word[i] == text[m + i]) {
i++;
if (i == p2) {
// return m;
cnt++;
m = m + i - table[i];
if (i > 0)
i = table[i];
}
} else {
m = m + i - table[i];
if (i > 0)
i = table[i];
}
}
return cnt;
}
char pat[8][M][M + 2]; // 8 pattern
int compute(int r, int c, int p, int cur) {
int ret = 0;
static int ac[M + 10], tres[N + 10];
rep(i, p) ptr[i] = pat[cur][i];
PMA *root = buildPMA(ptr, p, ac);
rep(i, r) {
rep(j, c) tres[j] = -1;
match(root, m[i], tres);
rep(j, c) atm[i][j] = tres[j];
}
rep(j, c) {
rep(i, r) tres[i] = atm[i][j];
ret += kmp(r, tres, p, ac);
}
return ret;
}
void rotate(int n, int cur) {
static char tmp[M][M];
rep(i, n) rep(j, n) tmp[i][j] = pat[cur - 1][i][j];
rep(i, n) {
rep(j, n) { pat[cur][n - 1 - j][i] = tmp[i][j]; }
}
}
void mirror(int n, int cur) {
rep(i, n) { rep(j, n / 2) swap(pat[cur][i][j], pat[cur][i][n - 1 - j]); }
}
bool issame(int n, int cur, int tar) {
rep(i, n) { rep(j, n) if (pat[cur][i][j] != pat[tar][i][j]) return false; }
return true;
}
int solve(int r, int c, int p) {
int ret = 0;
bool check[8] = {false};
fill(check, check + 8, true);
rep(k, 8) { rep(i, p) pat[k][i][p] = '\0'; }
rep(i, p) { rep(j, p) pat[0][i][j] = pat[4][i][j] = in[i][j]; }
REP(i, 1, 4) rotate(p, i);
mirror(p, 4);
REP(i, 5, 8) rotate(p, i);
rep(i, 8) {
if (!check[i])
continue;
REP(j, i + 1, 8) {
if (issame(p, i, j))
check[j] = false;
}
}
rep(i, 8) {
if (check[i])
ret += compute(r, c, p, i);
}
return ret;
}
main() {
int c, r, p;
while (cin >> c >> r >> p && c) {
rep(i, r) {
string tmp;
cin >> tmp;
decode(c, tmp, m[i]);
}
rep(i, p) {
string tmp;
cin >> tmp;
decode(p, tmp, in[i]);
}
cout << solve(r, c, p) << endl;
}
return false;
}
|
[["-", 0, 1, 0, 11, 31, 69, 341, 342, 0, 22], ["+", 0, 1, 0, 11, 31, 69, 341, 342, 0, 22]]
| 1
| 1,784
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
const double EPS = 1e-11;
double width(vector<pair<int, int>> polygon, double x) {
vector<double> w;
for (int i = 0; i < polygon.size(); i++) {
pair<int, int> p = polygon[i];
pair<int, int> q = polygon[(i + 1) % polygon.size()];
if (abs(p.first - x) < EPS) {
w.push_back(1.0 * p.second);
} else if ((p.first < x && x < q.first) || (p.first > x && x > q.first)) {
int x0 = p.first;
int y0 = p.second;
int x1 = q.first;
int y1 = q.second;
w.push_back(y0 + 1.0 * (y1 - y0) * (x - x0) / (x1 - x0));
}
}
assert(w.size() > 0);
sort(w.begin(), w.end());
return w[w.size() - 1] - w[0];
}
int volume(vector<pair<int, int>> Pxy, vector<pair<int, int>> Pxz,
vector<int> X) {
double total = 0.0;
int xmin = max((*min_element(Pxy.begin(), Pxy.end())).first,
(*min_element(Pxz.begin(), Pxz.end())).first);
int xmax = min((*max_element(Pxy.begin(), Pxy.end())).first,
(*max_element(Pxz.begin(), Pxz.end())).first);
sort(X.begin(), X.end());
for (int i = 0; i < X.size() - 1; i++) {
int a = X[i];
int b = X[i + 1];
if (!(xmin <= a && a <= xmax && xmin <= b && b <= xmax)) {
continue;
}
double m = (a + b) / 2.0;
double va = width(Pxy, a) * width(Pxz, a);
double vb = width(Pxy, b) * width(Pxz, b);
double vm = width(Pxy, m) * width(Pxz, m);
double area = ((b - a) / 6.0) * (va + 4.0 * vm + vb);
total += area;
}
return total;
}
int main() {
while (cin >> m >> n && n != 0) {
vector<pair<int, int>> Pxy, Pxz;
pair<int, int> tem;
vector<int> X;
for (int i = 1; i <= m; i++) {
cin >> tem.first >> tem.second;
Pxy.push_back(tem);
X.push_back(tem.first);
}
for (int j = 1; j <= n; j++) {
cin >> tem.first >> tem.second;
Pxz.push_back(tem);
X.push_back(tem.first);
}
cout << fixed << volume(Pxy, Pxz, X) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int m, n;
const double EPS = 1e-11;
double width(vector<pair<int, int>> polygon, double x) {
vector<double> w;
for (int i = 0; i < polygon.size(); i++) {
pair<int, int> p = polygon[i];
pair<int, int> q = polygon[(i + 1) % polygon.size()];
if (abs(p.first - x) < EPS) {
w.push_back(1.0 * p.second);
} else if ((p.first < x && x < q.first) || (p.first > x && x > q.first)) {
int x0 = p.first;
int y0 = p.second;
int x1 = q.first;
int y1 = q.second;
w.push_back(y0 + 1.0 * (y1 - y0) * (x - x0) / (x1 - x0));
}
}
assert(w.size() > 0);
sort(w.begin(), w.end());
return w[w.size() - 1] - w[0];
}
double volume(vector<pair<int, int>> Pxy, vector<pair<int, int>> Pxz,
vector<int> X) {
double total = 0.0;
int xmin = max((*min_element(Pxy.begin(), Pxy.end())).first,
(*min_element(Pxz.begin(), Pxz.end())).first);
int xmax = min((*max_element(Pxy.begin(), Pxy.end())).first,
(*max_element(Pxz.begin(), Pxz.end())).first);
sort(X.begin(), X.end());
for (int i = 0; i < X.size() - 1; i++) {
int a = X[i];
int b = X[i + 1];
if (!(xmin <= a && a <= xmax && xmin <= b && b <= xmax)) {
continue;
}
double m = (a + b) / 2.0;
double va = width(Pxy, a) * width(Pxz, a);
double vb = width(Pxy, b) * width(Pxz, b);
double vm = width(Pxy, m) * width(Pxz, m);
double area = ((b - a) / 6.0) * (va + 4.0 * vm + vb);
total += area;
}
return total;
}
int main() {
while (cin >> m >> n && m != 0) {
vector<pair<int, int>> Pxy, Pxz;
pair<int, int> tem;
vector<int> X;
for (int i = 0; i < m; i++) {
cin >> tem.first >> tem.second;
Pxy.push_back(tem);
X.push_back(tem.first);
}
for (int j = 0; j < n; j++) {
cin >> tem.first >> tem.second;
Pxz.push_back(tem);
X.push_back(tem.first);
}
cout << fixed << volume(Pxy, Pxz, X) << endl;
}
}
|
[["-", 36, 36, 36, 36, 0, 30, 0, 14, 39, 40], ["+", 36, 36, 36, 36, 0, 30, 0, 14, 39, 40], ["-", 0, 52, 15, 339, 51, 16, 12, 16, 31, 22], ["+", 0, 52, 15, 339, 51, 16, 12, 16, 31, 22], ["-", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["-", 0, 52, 8, 9, 0, 7, 15, 16, 17, 19], ["+", 0, 52, 8, 9, 0, 7, 15, 16, 17, 18]]
| 1
| 703
|
// Enjoy your stay.
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (auto it = (X).begin(); it != (X).end(); it++)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
int n, m;
int d[55], e[55];
int up[55][55];
int dw[55][55];
int same[55][55];
int cost1u[55][55];
int cost1d[55][55];
int cost2[55][55][55][55];
int dp[55][55];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
while (cin >> n >> m && n) {
rep(i, n) rep(j, n) up[i][j] = dw[i][j] = same[i][j] = INF;
map<int, vi> alt;
rep2(i, 1, n - 1) {
cin >> d[i] >> e[i];
alt[e[i]].pb(i);
}
d[0] = d[n - 1] = 0;
e[0] = 0;
e[n - 1] = 1000;
alt[0].pb(0);
alt[1000].pb(n - 1);
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (e[a] < e[b]) {
up[a][b] = c;
} else if (e[a] > e[b]) {
dw[a][b] = c;
} else {
same[a][b] = c;
}
}
foreach (it, alt) {
vi &town = it->sec;
int dist[11][11];
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = i == j ? 0 : same[town[i]][town[j]] + d[town[j]];
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
rep(i, sz(town)) rep(j, sz(town)) {
cost1u[town[i]][town[j]] = dist[i][j];
}
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = i == j ? 0 : same[town[i]][town[j]] + d[town[i]];
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
rep(i, sz(town)) rep(j, sz(town)) {
cost1d[town[i]][town[j]] = dist[i][j];
}
rep(i, sz(town)) rep(j, sz(town)) rep(k, sz(town)) rep(l, sz(town)) {
cost2[town[i]][town[j]][town[k]][town[l]] = INF;
}
rep(mask, 1 << sz(town)) {
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = (mask >> i & 1) & (mask >> j & 1)
? (i == j ? 0 : same[town[i]][town[j]])
: INF;
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int visa = 0;
rep(i, sz(town)) if (mask >> i & 1) visa += d[town[i]];
rep(i, sz(town)) rep(j, sz(town)) rep(k, sz(town)) rep(l, sz(town)) {
if (!(mask >> i & 1) || !(mask >> j & 1))
continue;
int v = visa;
if (i == j)
v -= d[town[i]];
else
v -= d[town[i]] + d[town[j]];
cost2[town[i]][town[j]][town[k]][town[l]] =
min(cost2[town[i]][town[j]][town[k]][town[l]],
dist[i][k] + dist[l][j] + v);
// cout<<mask<<" "<<town[i]<<town[j]<<town[k]<<town[l]<<"
// "<<cost2[town[i]][town[j]][town[k]][town[l]]<<endl;
}
}
}
rep(i, n) rep(j, n) dp[i][j] = INF;
dp[0][0] = 0;
foreach (it1, alt)
foreach (it2, alt) {
int al1 = it1->fir, al2 = it2->fir;
vi &town1 = it1->sec, &town2 = it2->sec;
if (al1 == al2) {
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
rep(ii, sz(town1)) rep(jj, sz(town2)) {
dp[t1][t2] =
min(dp[t1][t2], dp[town1[ii]][town2[jj]] +
cost2[town1[ii]][town2[jj]][t1][t2]);
}
}
} else {
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
rep(ii, sz(town1)) rep(jj, sz(town2)) {
dp[t1][t2] = min(dp[t1][t2], dp[town1[ii]][town2[jj]] +
cost1u[town1[ii]][t1] +
cost1d[t2][town2[jj]]);
}
}
}
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
rep(ii, n) {
dp[ii][t2] = min(dp[ii][t2],
dp[t1][t2] + up[t1][ii] + (ii == t2 ? 0 : d[ii]));
dp[t1][ii] = min(dp[t1][ii],
dp[t1][t2] + dw[ii][t2] + (ii == t1 ? 0 : d[ii]));
}
}
}
// rep(i,n)rep(j,n)cout<<i<<" "<<j<<" : "<<dp[i][j]<<endl;
int ans = dp[n - 1][n - 1];
if (ans < INF)
cout << ans << endl;
else
cout << -1 << endl;
}
}
|
// Enjoy your stay.
#include <bits/stdc++.h>
#define EPS 1e-9
#define INF 1070000000LL
#define MOD 1000000007LL
#define fir first
#define foreach(it, X) for (auto it = (X).begin(); it != (X).end(); it++)
#define ite iterator
#define mp make_pair
#define mt make_tuple
#define rep(i, n) rep2(i, 0, n)
#define rep2(i, m, n) for (int i = m; i < (n); i++)
#define pb push_back
#define sec second
#define sz(x) ((int)(x).size())
using namespace std;
typedef istringstream iss;
typedef long long ll;
typedef pair<ll, ll> pi;
typedef stringstream sst;
typedef vector<ll> vi;
int n, m;
int d[55], e[55];
int up[55][55];
int dw[55][55];
int same[55][55];
int cost1u[55][55];
int cost1d[55][55];
int cost2[55][55][55][55];
ll dp[55][55];
int main() {
cin.tie(0);
ios_base::sync_with_stdio(0);
while (cin >> n >> m && n) {
rep(i, n) rep(j, n) up[i][j] = dw[i][j] = same[i][j] = INF;
map<int, vi> alt;
rep2(i, 1, n - 1) {
cin >> d[i] >> e[i];
alt[e[i]].pb(i);
}
d[0] = d[n - 1] = 0;
e[0] = 0;
e[n - 1] = 1000;
alt[0].pb(0);
alt[1000].pb(n - 1);
rep(i, m) {
int a, b, c;
cin >> a >> b >> c;
a--;
b--;
if (e[a] < e[b]) {
up[a][b] = c;
} else if (e[a] > e[b]) {
dw[a][b] = c;
} else {
same[a][b] = c;
}
}
foreach (it, alt) {
vi &town = it->sec;
int dist[11][11];
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = i == j ? 0 : same[town[i]][town[j]] + d[town[j]];
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
rep(i, sz(town)) rep(j, sz(town)) {
cost1u[town[i]][town[j]] = dist[i][j];
}
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = i == j ? 0 : same[town[i]][town[j]] + d[town[i]];
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
rep(i, sz(town)) rep(j, sz(town)) {
cost1d[town[i]][town[j]] = dist[i][j];
}
rep(i, sz(town)) rep(j, sz(town)) rep(k, sz(town)) rep(l, sz(town)) {
cost2[town[i]][town[j]][town[k]][town[l]] = INF;
}
rep(mask, 1 << sz(town)) {
rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = (mask >> i & 1) & (mask >> j & 1)
? (i == j ? 0 : same[town[i]][town[j]])
: INF;
}
rep(k, sz(town)) rep(i, sz(town)) rep(j, sz(town)) {
dist[i][j] = min(dist[i][j], dist[i][k] + dist[k][j]);
}
int visa = 0;
rep(i, sz(town)) if (mask >> i & 1) visa += d[town[i]];
rep(i, sz(town)) rep(j, sz(town)) rep(k, sz(town)) rep(l, sz(town)) {
if (!(mask >> i & 1) || !(mask >> j & 1))
continue;
int v = visa;
if (i == j)
v -= d[town[i]];
else
v -= d[town[i]] + d[town[j]];
cost2[town[i]][town[j]][town[k]][town[l]] =
min(cost2[town[i]][town[j]][town[k]][town[l]],
dist[i][k] + dist[l][j] + v);
// cout<<mask<<" "<<town[i]<<town[j]<<town[k]<<town[l]<<"
// "<<cost2[town[i]][town[j]][town[k]][town[l]]<<endl;
}
}
}
rep(i, n) rep(j, n) dp[i][j] = INF;
dp[0][0] = 0;
foreach (it1, alt)
foreach (it2, alt) {
int al1 = it1->fir, al2 = it2->fir;
vi &town1 = it1->sec, &town2 = it2->sec;
if (al1 == al2) {
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
rep(ii, sz(town1)) rep(jj, sz(town2)) {
dp[t1][t2] =
min(dp[t1][t2], dp[town1[ii]][town2[jj]] +
cost2[town1[ii]][town2[jj]][t1][t2]);
}
}
} else {
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
rep(ii, sz(town1)) rep(jj, sz(town2)) {
dp[t1][t2] = min(dp[t1][t2], dp[town1[ii]][town2[jj]] +
cost1u[town1[ii]][t1] +
cost1d[t2][town2[jj]]);
}
}
}
rep(i, sz(town1)) rep(j, sz(town2)) {
int t1 = town1[i], t2 = town2[j];
// cout<<t1<<" "<<t2<<" : "<<dp[t1][t2]<<endl;
rep(ii, n) {
dp[ii][t2] = min(dp[ii][t2],
dp[t1][t2] + up[t1][ii] + (ii == t2 ? 0 : d[ii]));
dp[t1][ii] = min(dp[t1][ii],
dp[t1][t2] + dw[ii][t2] + (ii == t1 ? 0 : d[ii]));
}
}
}
// rep(i,n)rep(j,n)cout<<i<<" "<<j<<" : "<<dp[i][j]<<endl;
int ans = dp[n - 1][n - 1];
if (ans < INF / 2)
cout << ans << endl;
else
cout << -1 << endl;
}
}
|
[["-", 36, 36, 36, 36, 0, 30, 0, 43, 39, 40], ["+", 36, 36, 36, 36, 0, 30, 0, 43, 39, 78], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 17, 85], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 12, 13]]
| 1
| 1,709
|
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);
static int[] sq = new int[20001];
public static void main(String[] args) {
for (int i = 1; i * i < 20000; ++i) {
sq[i * i] = i;
}
int N = sc.nextInt();
for (int i = 0; i < N; ++i) {
int m = sc.nextInt();
int n = sc.nextInt();
System.out.println(solve(m, n) ? "P" : "C");
}
}
static boolean solve(int M, int N) {
int D = M * M + N * N;
for (int i = 2; i * i <= D; ++i) {
if (D % i != 0)
continue;
for (int p = 1; p * p * 2 <= i; ++p) {
int q = sq[i - p * p];
if (p * p != i && q == 0)
continue;
if ((M * p + N * q) % i == 0 && (M * q - N * p) % i == 0)
return false;
}
}
return true;
}
}
|
import java.util.Scanner;
public class Main {
static Scanner sc = new Scanner(System.in);
static int[] sq = new int[20001];
public static void main(String[] args) {
for (int i = 1; i * i < 20000; ++i) {
sq[i * i] = i;
}
int N = sc.nextInt();
for (int i = 0; i < N; ++i) {
int m = sc.nextInt();
int n = sc.nextInt();
System.out.println(solve(m, n) ? "P" : "C");
}
}
static boolean solve(int M, int N) {
int D = M * M + N * N;
for (int i = 2; i * i <= D; ++i) {
if (D % i != 0)
continue;
for (int p = 1; p * p <= i; ++p) {
int q = sq[i - p * p];
if (p * p != i && q == 0)
continue;
if ((M * p + N * q) % i == 0 && (M * q - N * p) % i == 0)
return false;
}
}
return true;
}
}
|
[["-", 8, 196, 0, 7, 15, 16, 31, 16, 17, 48], ["-", 8, 196, 0, 7, 15, 16, 31, 16, 12, 499]]
| 3
| 273
|
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
REP(i, n) {
int a, b;
cin >> a >> b;
complex<int> z(a, b);
int norm = a * a + b * b;
bool ok = true;
REP(j, 150) REP(k, i + 1) {
int njk = j * j + k * k;
if (njk <= 1)
continue;
if (njk >= norm)
break;
if ((norm % njk) == 0) {
int sig[] = {1, -1};
REP(l, 2) REP(m, 2) {
int nj = j * sig[l];
int nk = k * sig[m];
if (((nj * a + nk * b) % njk) == 0) {
ok = false;
break;
}
}
}
}
if (ok)
cout << 'P' << endl;
else
cout << 'C' << endl;
}
return 0;
}
|
#include <algorithm>
#include <complex>
#include <iostream>
#include <map>
#include <string>
#include <vector>
#define REP(i, n) for (int i = 0; i < (int)(n); i++)
using namespace std;
int main() {
int n;
cin >> n;
REP(i, n) {
int a, b;
cin >> a >> b;
complex<int> z(a, b);
int norm = a * a + b * b;
bool ok = true;
REP(j, 150) REP(k, j + 1) {
int njk = j * j + k * k;
if (njk <= 1)
continue;
if (njk >= norm)
break;
if ((norm % njk) == 0) {
int sig[] = {1, -1};
REP(l, 2) REP(m, 2) {
int nj = j * sig[l];
int nk = k * sig[m];
if (((nj * a + nk * b) % njk) == 0) {
ok = false;
break;
}
}
}
}
if (ok)
cout << 'P' << endl;
else
cout << 'C' << endl;
}
return 0;
}
|
[["-", 0, 1, 0, 2, 3, 4, 0, 16, 31, 22], ["+", 0, 1, 0, 2, 3, 4, 0, 16, 31, 22]]
| 1
| 237
|
#include <bits/stdc++.h>
using namespace std;
#define for_(i, a, b) for (int i = a; i < b; ++i)
#define allof(a) a.begin(), a.end()
#define minit(a, b) memset(a, b, sizeof(b))
int T;
int m, n;
void solve() {
int s = m * m + n * n;
int range = (int)ceil(sqrt(s));
int cnt = 0;
for_(i, -range, range + 1) for_(j, -range, range + 1) {
if (i == 0 && j == 0)
continue;
int div = i * i + j * j;
int mul1 = i * m + j * n, mul2 = i * n - j * m;
if (mul1 % div == 0 && mul2 % div == 0)
cnt++;
}
cout << ((cnt == 8) ? "R" : "C") << endl;
}
int main() {
cin >> T;
for_(i, 0, T) {
cin >> m >> n;
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
#define for_(i, a, b) for (int i = a; i < b; ++i)
#define allof(a) a.begin(), a.end()
#define minit(a, b) memset(a, b, sizeof(b))
int T;
int m, n;
void solve() {
int s = m * m + n * n;
int range = ceil(sqrt(s));
int cnt = 0;
for_(i, -range, range + 1) for_(j, -range, range + 1) {
if (i == 0 && j == 0)
continue;
int div = i * i + j * j;
int mul1 = i * m + j * n, mul2 = i * n - j * m;
if (mul1 % div == 0 && mul2 % div == 0)
cnt++;
}
cout << ((cnt == 8) ? "P" : "C") << endl;
}
int main() {
cin >> T;
for_(i, 0, T) {
cin >> m >> n;
solve();
}
return 0;
}
|
[["-", 8, 9, 0, 43, 49, 50, 51, 74, 0, 24], ["-", 0, 43, 49, 50, 51, 74, 39, 77, 39, 40], ["-", 8, 9, 0, 43, 49, 50, 51, 74, 0, 25], ["-", 31, 16, 12, 23, 0, 41, 64, 5, 0, 6], ["+", 31, 16, 12, 23, 0, 41, 64, 5, 0, 6]]
| 1
| 215
|
#include <iostream>
using namespace std;
int x[1 << 23], p, q, n, i, j;
main() {
for (i = 0; i < 1000; i++) {
for (j = 0; j < 1000; j++) {
x[i * i + j * j]++;
}
}
cin >> n;
for (i = 0; i < n; i++) {
cin >> p >> q;
int r = p * p + q * q, s = 0;
for (j = 1; j <= r; j++) {
if (r % j < 1) {
s += x[i] * x[r / i];
}
}
if (s == 8) {
cout << 'P' << endl;
} else {
cout << 'C' << endl;
}
}
}
|
#include <iostream>
using namespace std;
int x[1 << 23], p, q, n, i, j;
main() {
for (i = 0; i < 1000; i++) {
for (j = 0; j < 1000; j++) {
x[i * i + j * j]++;
}
}
cin >> n;
for (i = 0; i < n; i++) {
cin >> p >> q;
int r = p * p + q * q, s = 0;
for (j = 1; j <= r; j++) {
if (r % j == 0) {
s += x[j] * x[r / j];
}
}
if (s == 8) {
cout << 'P' << endl;
} else {
cout << 'C' << endl;
}
}
}
|
[["-", 8, 9, 0, 57, 15, 339, 51, 16, 17, 18], ["-", 8, 9, 0, 57, 15, 339, 51, 16, 12, 13], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 17, 60], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 12, 13], ["-", 0, 11, 12, 16, 31, 69, 341, 342, 0, 22], ["+", 0, 11, 12, 16, 31, 69, 341, 342, 0, 22], ["-", 12, 16, 12, 69, 341, 342, 0, 16, 12, 22], ["+", 12, 16, 12, 69, 341, 342, 0, 16, 12, 22]]
| 1
| 177
|
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
int n;
cin >> n;
rep(i, n) {
int m, n;
cin >> m >> n;
int s = m * m + n * n;
int cnt = 0;
REP(i, 1, s + 1) {
if (s % i == 0) {
map<ll, ll> ret = prime_factor(s / i);
map<ll, ll>::iterator ite;
bool flag = true;
for (ite = ret.begin(); ite != ret.end(); ite++) {
if (ite->first - 3 % 4 != 0)
continue;
if (ite->second % 2 == 0)
continue;
flag = false;
}
if (flag)
cnt++;
}
}
if (cnt >= 3)
cout << "C" << endl;
else
cout << "P" << endl;
}
return 0;
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
#include <map>
#include <set>
#include <sstream>
#include <string>
#include <vector>
#define REP(i, k, n) for (int i = k; i < n; i++)
#define rep(i, n) for (int i = 0; i < n; i++)
#define INF 1 << 30
#define pb push_back
#define mp make_pair
using namespace std;
typedef long long ll;
typedef pair<int, int> P;
map<ll, ll> prime_factor(ll n) {
map<ll, ll> res;
for (ll i = 2; i * i <= n; i++) {
while (n % i == 0) {
res[i]++;
n /= i;
}
}
if (n != 1)
res[n] = 1;
return res;
}
int main() {
int n;
cin >> n;
rep(i, n) {
int m, n;
cin >> m >> n;
int s = m * m + n * n;
int cnt = 0;
REP(i, 1, s + 1) {
if (s % i == 0) {
map<ll, ll> ret = prime_factor(s / i);
map<ll, ll>::iterator ite;
bool flag = true;
for (ite = ret.begin(); ite != ret.end(); ite++) {
if (ite->first % 4 != 3)
continue;
if (ite->second % 2 == 0)
continue;
flag = false;
}
if (flag) {
cnt++;
}
}
}
if (cnt >= 3)
cout << "C" << endl;
else
cout << "P" << endl;
}
return 0;
}
|
[["-", 0, 57, 15, 339, 51, 16, 31, 16, 17, 33], ["-", 15, 339, 51, 16, 31, 16, 12, 16, 31, 13], ["-", 8, 9, 0, 57, 15, 339, 51, 16, 12, 13], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 12, 13], ["+", 0, 57, 64, 9, 0, 57, 64, 9, 0, 45], ["+", 0, 57, 64, 9, 0, 57, 64, 9, 0, 46]]
| 1
| 323
|
#define ll long long
#include <bits/stdc++.h>
#define mp(a, b) make_pair(a, b)
using namespace std;
ll p, q, tt;
ll gcd(ll a, ll b) { return a == 0 ? b : gcd(b % a, a); }
set<pair<ll, ll>> ss;
bool isValid(ll k) {
for (ll m = 1; m * m < k; m++) {
ll n = sqrt(k - m * m);
pair<ll, ll> pp = mp(m, n);
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
// cout << m << " " << n << endl;
return true;
}
pp = mp(m, -n);
n = -n;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
// cout << m << " " << n << endl;
return true;
}
n = -n;
pp = mp(-m, -n);
m = -m;
n = -n;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
return true;
}
m = -m;
n = -n;
pp = mp(-m, n);
m = -m;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
return true;
}
m = -m;
}
return false;
}
void solve() {
cin >> p >> q;
tt = p * p + q * q;
ss.clear();
ss.insert(mp(0, 1));
ss.insert(mp(1, 0));
ss.insert(mp(0, -1));
ss.insert(mp(-1, 0));
ss.insert(mp(p, q));
ss.insert(mp(-q, p));
ss.insert(mp(-p, -q));
ss.insert(mp(q, -p));
if (tt <= 1) {
cout << "P" << endl;
return;
}
bool flag = false;
for (ll k1 = 2; k1 <= tt; k1++) {
ll k2 = tt / k1;
if (k1 > 1 && k2 > 1 && tt % k1 == 0) {
if (isValid(k1) && isValid(k2)) {
cout << "C" << endl;
return;
}
}
}
cout << "P" << endl;
}
int main(void) {
int t;
cin >> t;
while (t--)
solve();
return 0;
return 0;
}
|
#define ll long long
#include <bits/stdc++.h>
#define mp(a, b) make_pair(a, b)
using namespace std;
ll p, q, tt;
ll gcd(ll a, ll b) { return a == 0 ? b : gcd(b % a, a); }
set<pair<ll, ll>> ss;
bool isValid(ll k) {
for (ll m = 0; m * m < k; m++) {
ll n = sqrt(k - m * m);
pair<ll, ll> pp = mp(m, n);
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
// cout << m << " " << n << endl;
return true;
}
pp = mp(m, -n);
n = -n;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
// cout << m << " " << n << endl;
return true;
}
n = -n;
pp = mp(-m, -n);
m = -m;
n = -n;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
return true;
}
m = -m;
n = -n;
pp = mp(-m, n);
m = -m;
if (n * n == k - m * m && ss.find(pp) == ss.end() &&
abs(m * p + n * q) % k == 0 && abs(m * q - n * p) % k == 0) {
return true;
}
m = -m;
}
return false;
}
void solve() {
cin >> p >> q;
tt = p * p + q * q;
ss.clear();
ss.insert(mp(0, 1));
ss.insert(mp(1, 0));
ss.insert(mp(0, -1));
ss.insert(mp(-1, 0));
ss.insert(mp(p, q));
ss.insert(mp(-q, p));
ss.insert(mp(-p, -q));
ss.insert(mp(q, -p));
if (tt <= 1) {
cout << "P" << endl;
return;
}
bool flag = false;
for (ll k1 = 2; k1 <= tt; k1++) {
ll k2 = tt / k1;
if (k1 > 1 && k2 > 1 && tt % k1 == 0) {
if (isValid(k1) && isValid(k2)) {
cout << "C" << endl;
return;
}
}
}
cout << "P" << endl;
}
int main(void) {
int t;
cin >> t;
while (t--)
solve();
return 0;
return 0;
}
|
[["-", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13]]
| 1
| 684
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(n) rep(i, n)
#define all(n) n.begin(), n.end()
#define foreach(it, c) \
for (typeof(c.begin()) it = c.begin(); it != c.end(); ++it)
const int MAXM = 170;
int main() {
int num;
cin >> num;
while (num--) {
int p, q;
cin >> p >> q;
int count = 0, seki = 0;
for (int m = 0; m < MAXM; m++)
for (int n = 0; n < MAXM; n++) {
if ((m == 1 && n == 0) || (m == 0 && n == 1))
continue;
// cout << m << " " << n << endl;
seki = m * m + n * n;
if (seki == 0)
continue;
if (seki >= 20000)
continue;
if ((((m * p + n * q) % seki) == 0) &&
(((m * q - n * p) % seki) == 0)) {
// if((m == abs(p) && (n == abs(q))) || (m == abs(q) && (n == abs(p))
// ) )
if ((m == p && n == q) || (m == -q && n == -p) ||
(m == -p && n == -q) || (m == q && n == -p)) {
continue;
// cout << m << " " << n << endl;
}
count++;
}
}
if (count > 0)
cout << 'C' << endl;
else
cout << 'P' << endl;
}
return 0;
}
|
#include <algorithm>
#include <cstdio>
#include <cstring>
#include <iostream>
#include <map>
#include <string>
#include <vector>
using namespace std;
#define rep(i, n) for (int i = 0; i < n; i++)
#define REP(n) rep(i, n)
#define all(n) n.begin(), n.end()
#define foreach(it, c) \
for (typeof(c.begin()) it = c.begin(); it != c.end(); ++it)
const int MAXM = 170;
int main() {
int num;
cin >> num;
while (num--) {
int p, q;
cin >> p >> q;
int count = 0, seki = 0;
for (int m = 0; m < MAXM; m++)
for (int n = 0; n < MAXM; n++) {
if ((m == 1 && n == 0) || (m == 0 && n == 1))
continue;
// cout << m << " " << n << endl;
seki = m * m + n * n;
if (seki == 0)
continue;
if (seki >= 20000)
continue;
if ((((m * p + n * q) % seki) == 0) &&
(((m * q - n * p) % seki) == 0)) {
// if((m == abs(p) && (n == abs(q))) || (m == abs(q) && (n == abs(p))
// ) )
if ((m == p && n == q) || (m == -q && n == p) ||
(m == -p && n == -q) || (m == q && n == -p)) {
continue;
// cout << m << " " << n << endl;
}
count++;
}
}
if (count > 0)
cout << 'C' << endl;
else
cout << 'P' << endl;
}
return 0;
}
|
[["-", 12, 23, 0, 16, 12, 16, 12, 91, 17, 33]]
| 1
| 297
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int p, q;
cin >> p >> q;
int tmp = p * p + q * q, cnt = 0;
for (int n = 0; n * n <= tmp; n++) {
for (int m = 0; m * m <= tmp; m++) {
if (m * m + n * n < 1)
continue;
if ((m * p + n * q) % (m * m + n * n) == 0 &&
(m * q - n * p) % (m * m + n * n) == 0)
cnt++;
}
}
if (cnt * 2 == 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <vector>
using namespace std;
int main(void) {
int t;
cin >> t;
while (t--) {
int p, q;
cin >> p >> q;
int tmp = p * p + q * q, cnt = 0;
for (int n = 0; n * n <= tmp; n++) {
for (int m = 0; m * m <= tmp; m++) {
if (m * m + n * n < 1)
continue;
if ((m * p + n * q) % (m * m + n * n) == 0 &&
(m * q - n * p) % (m * m + n * n) == 0)
cnt++;
}
}
if (cnt * 2 <= 8)
cout << "P" << endl;
else
cout << "C" << endl;
}
return 0;
}
|
[["-", 8, 9, 0, 57, 15, 339, 51, 16, 17, 60], ["+", 8, 9, 0, 57, 15, 339, 51, 16, 17, 19]]
| 1
| 184
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, m;
string s;
int main() {
while (cin >> n >> m, n) {
vector<int> a(n + m), b(n + m), c(n + m), d(n + m);
int da = 0, db = 0, dc = 0;
for (int i = 0; i < n; i++) {
cin >> s;
a[i] = da, b[i] = db, c[i] = dc;
for (int j = 0; j < s.size(); j++) {
if (s[j] != '.') {
d[i] = j;
break;
}
}
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(')
da++;
if (s[j] == '{')
db++;
if (s[j] == '[')
dc++;
if (s[j] == ')')
da--;
if (s[j] == '}')
db--;
if (s[j] == ']')
dc--;
}
}
vector<int> ra, rb, rc;
for (int i = 0; i <= 20; i++) {
for (int j = 0; j <= 20; j++) {
for (int k = 0; k <= 20; k++) {
bool flag = true;
for (int l = 0; l < n; l++) {
if (i * a[l] + j * b[l] + k * c[l] != d[l]) {
flag = false;
break;
}
}
if (flag) {
ra.push_back(i);
rb.push_back(j);
rc.push_back(k);
}
}
}
}
for (int i = 0; i < m; i++) {
if (i)
cout << ' ';
cin >> s;
vector<int> x;
for (int j = 0; j < ra.size(); j++)
x.push_back(da * ra[j] + db * rb[j] + dc * rc[j]);
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
if (x.size() != 1)
cout << -1;
else
cout << x[0];
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(')
da++;
if (s[j] == '{')
db++;
if (s[j] == '[')
dc++;
if (s[j] == ')')
da--;
if (s[j] == '}')
db--;
if (s[j] == ']')
dc--;
}
}
cout << endl;
}
return 0;
}
|
#include <algorithm>
#include <iostream>
#include <string>
#include <vector>
using namespace std;
int n, m;
string s;
int main() {
while (cin >> n >> m, n) {
vector<int> a(n + m), b(n + m), c(n + m), d(n + m);
int da = 0, db = 0, dc = 0;
for (int i = 0; i < n; i++) {
cin >> s;
a[i] = da, b[i] = db, c[i] = dc;
for (int j = 0; j < s.size(); j++) {
if (s[j] != '.') {
d[i] = j;
break;
}
}
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(')
da++;
if (s[j] == '{')
db++;
if (s[j] == '[')
dc++;
if (s[j] == ')')
da--;
if (s[j] == '}')
db--;
if (s[j] == ']')
dc--;
}
}
vector<int> ra, rb, rc;
for (int i = 1; i <= 20; i++) {
for (int j = 1; j <= 20; j++) {
for (int k = 1; k <= 20; k++) {
bool flag = true;
for (int l = 0; l < n; l++) {
if (i * a[l] + j * b[l] + k * c[l] != d[l]) {
flag = false;
break;
}
}
if (flag) {
ra.push_back(i);
rb.push_back(j);
rc.push_back(k);
}
}
}
}
for (int i = 0; i < m; i++) {
if (i)
cout << ' ';
cin >> s;
vector<int> x;
for (int j = 0; j < ra.size(); j++)
x.push_back(da * ra[j] + db * rb[j] + dc * rc[j]);
sort(x.begin(), x.end());
x.erase(unique(x.begin(), x.end()), x.end());
if (x.size() != 1)
cout << -1;
else
cout << x[0];
for (int j = 0; j < s.size(); j++) {
if (s[j] == '(')
da++;
if (s[j] == '{')
db++;
if (s[j] == '[')
dc++;
if (s[j] == ')')
da--;
if (s[j] == '}')
db--;
if (s[j] == ']')
dc--;
}
}
cout << endl;
}
return 0;
}
|
[["-", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13], ["+", 8, 9, 0, 7, 10, 43, 49, 50, 51, 13]]
| 1
| 666
|
import itertools
while True:
n, k, s = map(int, input().split())
if n + k + s == 0:
break
a = itertools.combinations(range(n + 1), k)
ans = 0
for e in a:
if sum(e) != s:
continue
ans += 1
print(ans)
|
import itertools
while True:
n, k, s = map(int, input().split())
if n + k + s == 0:
break
a = itertools.combinations(range(1, n + 1), k)
ans = 0
for e in a:
if sum(e) != s:
continue
ans += 1
print(ans)
|
[["+", 12, 652, 3, 4, 0, 652, 3, 4, 0, 612], ["+", 12, 652, 3, 4, 0, 652, 3, 4, 0, 21]]
| 5
| 72
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
while (true) {
long long int n, l;
cin >> n >> l;
if (n == 0)
break;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
char c;
long long int in;
cin >> c >> in;
if (c == 'R') {
v.push_back(make_pair(in, 1));
} else {
v.push_back(make_pair(in, -1));
}
}
long long int ans = 0;
long long int cnt;
for (long long int j = 0; j <= 100; j++) {
long long int t[101] = {};
for (long long int i = 0; i < n; i++) {
if (v[i].second != 0) {
v[i].first += v[i].second;
if (v[i].first == 0 || v[i].first == l) {
v[i].second = 0;
if (v[i].first == 0) {
if (ans <= j) {
ans = j + 1;
cnt = i + 1;
}
} else {
if (ans < j) {
ans = j + 1;
cnt = i + 1;
}
}
} else if (t[v[i].first] != 0) {
v[i].second *= -1;
v[t[v[i].first] - 1].second *= -1;
} else {
t[v[i].first] = i + 1;
}
}
}
}
cout << ans << " " << cnt << endl;
}
return 0;
}
|
#include <iostream>
#include <vector>
using namespace std;
int main() {
while (true) {
long long int n, l;
cin >> n >> l;
if (n == 0)
break;
vector<pair<long long int, long long int>> v;
for (long long int i = 0; i < n; i++) {
char c;
long long int in;
cin >> c >> in;
if (c == 'R') {
v.push_back(make_pair(in, 1));
} else {
v.push_back(make_pair(in, -1));
}
}
long long int ans = 0;
long long int cnt;
for (long long int j = 0; j <= 100; j++) {
long long int t[101] = {};
for (long long int i = 0; i < n; i++) {
if (v[i].second != 0) {
v[i].first += v[i].second;
if (v[i].first == 0 || v[i].first == l) {
v[i].second = 0;
if (v[i].first == 0) {
if (ans <= j + 1) {
ans = j + 1;
cnt = i + 1;
}
} else {
if (ans < j + 1) {
ans = j + 1;
cnt = i + 1;
}
}
} else if (t[v[i].first] != 0) {
v[i].second *= -1;
v[t[v[i].first] - 1].second *= -1;
} else {
t[v[i].first] = i + 1;
}
}
}
}
cout << ans << " " << cnt << endl;
}
return 0;
}
|
[["+", 0, 57, 15, 339, 51, 16, 12, 16, 17, 72], ["+", 0, 57, 15, 339, 51, 16, 12, 16, 12, 13]]
| 1
| 375
|
#include <bits/stdc++.h>
using namespace std;
char T;
int l, a, b, x[999], d[999], M, N, y[999], z[999], i, j;
main() {
while (1) {
M = 0;
memset(y, 0, 999);
cin >> b >> l;
if (!l) {
break;
}
for (i = 1; i <= b; i++) {
cin >> T >> x[i];
if (T == 'L') {
d[i] = 0;
M = max(M, x[i]);
} else {
d[i] = 1;
M = max(M, l - x[i]);
}
}
N = 0;
for (i = 1; i < M + 2; i++) {
memset(z, 0, sizeof(z));
for (j = b; j > 0; j--) {
if (!y[j]) {
if (!d[j]) {
x[j]--;
} else {
x[j]++;
}
if (x[j] < 0 || x[j] > l) {
y[j] = 1;
}
z[x[j]]++;
if (M > i) {
if (N) {
if (x[j] < 0) {
N = j;
}
} else {
N = j;
}
}
}
}
for (j = b; j > 0; j--) {
if (z[x[j]] > 1) {
if (d[j]) {
d[j] = 0;
} else {
d[j] = 1;
}
}
}
}
printf("%d %d\n", M, N);
}
}
|
#include <bits/stdc++.h>
using namespace std;
char T;
int l, a, b, x[999], d[999], M, N, y[999], z[999], i, j;
main() {
while (1) {
M = 0;
memset(y, 0, 999);
cin >> b >> l;
if (!l) {
break;
}
for (i = 1; i <= b; i++) {
cin >> T >> x[i];
if (T == 'L') {
d[i] = 0;
M = max(M, x[i]);
} else {
d[i] = 1;
M = max(M, l - x[i]);
}
}
N = 0;
for (i = 1; i < M + 2; i++) {
memset(z, 0, sizeof(z));
for (j = b; j > 0; j--) {
if (!y[j]) {
if (!d[j]) {
x[j]--;
} else {
x[j]++;
}
if (x[j] < 0 || x[j] > l) {
y[j] = 1;
}
z[x[j]]++;
if (M < i) {
if (N) {
if (x[j] < 0) {
N = j;
}
} else {
N = j;
}
}
}
}
for (j = b; j > 0; j--) {
if (z[x[j]] > 1) {
if (d[j]) {
d[j] = 0;
} else {
d[j] = 1;
}
}
}
}
printf("%d %d\n", M, N);
}
}
|
[["-", 64, 9, 0, 57, 15, 339, 51, 16, 17, 47], ["+", 64, 9, 0, 57, 15, 339, 51, 16, 17, 18]]
| 1
| 380
|
while True:
n,l = list(map(int,input().split()))
if n == 0: break
tunnel = [[] for i in range(l-1)]
for i in range(1,n+1):
d,p = input().split()
tunnel[int(p)-1].append(i if d == "R" else -i)
t = num = 0
while sum(sum(unit) for unit in tunnel) != 0:
for i in range(l-2,-1,-1):
for a in tunnel[i]:
if a > 0:
tunnel[i].remove(a)
if i == l-2:
num = a
else:
tunnel[i+1].append(a)
for i in range(l-1):
for a in tunnel[i]:
if a < 0:
tunnel[i].remove(a)
if i == 0:
num = -a
else:
tunnel[i-1].append(a)
for i in range(l-1):
if len(tunnel[i]) > 1:
tunnel[i] = [-a for a in tunnel[i]]
t += 1
print(t,num)
|
while True:
n,l = list(map(int,input().split()))
if n == 0: break
tunnel = [[] for i in range(l-1)]
for i in range(1,n+1):
d,p = input().split()
tunnel[int(p)-1].append(i if d == "R" else -i)
t = num = 0
while sum(len(unit) for unit in tunnel) != 0:
for i in range(l-2,-1,-1):
for a in tunnel[i]:
if a > 0:
tunnel[i].remove(a)
if i == l-2:
num = a
else:
tunnel[i+1].append(a)
for i in range(l-1):
for a in tunnel[i]:
if a < 0:
tunnel[i].remove(a)
if i == 0:
num = -a
else:
tunnel[i-1].append(a)
for i in range(l-1):
if len(tunnel[i]) > 1:
tunnel[i] = [-a for a in tunnel[i]]
t += 1
print(t,num)
|
[["-", 15, 666, 0, 652, 3, 668, 8, 652, 63, 22], ["+", 15, 666, 0, 652, 3, 668, 8, 652, 63, 22]]
| 5
| 270
|
while True:
n,l = list(map(int,input().split()))
if n == 0: break
R = [0]*(l-1)
L = [0]*(l-1)
for i in range(1,n+1):
d,p = input().split()
p = int(p)-1
if d == "R": R[p] = i
else: L[p] = i
t = num = 0
while sum(R)+sum(L) != 0:
if R[-1] > 0: num = R[-1]
R = [0]+R[:-1]
if L[0] > 0: num = L[0]
L = L[1:]+[0]
for i in range(l-1):
if min(L[i],R[i]) > 0: R[i],L[i] = L[i],R[i]
t += 1
print(R)
print(t,num)
|
while True:
n,l = list(map(int,input().split()))
if n == 0: break
R = [0]*(l-1)
L = [0]*(l-1)
for i in range(1,n+1):
d,p = input().split()
p = int(p)-1
if d == "R": R[p] = i
else: L[p] = i
t = num = 0
while sum(R)+sum(L) != 0:
if R[-1] > 0: num = R[-1]
R = [0]+R[:-1]
if L[0] > 0: num = L[0]
L = L[1:]+[0]
for i in range(l-1):
if min(L[i],R[i]) > 0: R[i],L[i] = L[i],R[i]
t += 1
print(t,num)
|
[["-", 8, 196, 0, 1, 0, 652, 3, 4, 0, 22], ["-", 8, 196, 0, 1, 0, 652, 3, 4, 0, 25], ["-", 0, 52, 8, 196, 0, 1, 0, 652, 63, 22], ["-", 8, 196, 0, 1, 0, 652, 3, 4, 0, 24]]
| 5
| 231
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, xa[52], ya[52], xb[52], yb[52], xc[102], yc[102], xd[52], yd[52], xe[52],
ye[52], f[103][103];
long long d[103][103];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void rec(int x, int y) {
f[y][x] = true;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (0 <= tx && tx <= 2 * n + 1 && 0 <= ty && ty <= 2 * n + 1) {
if (d[y][x] == d[ty][tx] && !f[ty][tx])
rec(tx, ty);
}
}
}
int main() {
while (cin >> n, n) {
for (int i = 0; i < n; i++) {
cin >> xa[i] >> yb[i] >> xb[i] >> ya[i];
xc[2 * i] = xa[i], yc[2 * i] = ya[i], xc[2 * i + 1] = xb[i],
yc[2 * i + 1] = yb[i];
}
sort(xc, xc + 2 * n);
sort(yc, yc + 2 * n);
memset(xd, 0, sizeof(xd));
memset(yd, 0, sizeof(yd));
memset(xe, 0, sizeof(xe));
memset(ye, 0, sizeof(ye));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * n; j++) {
if (xa[i] == xc[j] && !xd[i])
xa[i] = j + 1, xd[i] = 1;
if (ya[i] == yc[j] && !yd[i])
ya[i] = j + 1, yd[i] = 1;
if (xb[i] == xc[j] && !xe[i])
xb[i] = j + 1, xe[i] = 1;
if (yb[i] == yc[j] && !ye[i])
yb[i] = j + 1, ye[i] = 1;
}
}
memset(d, 0, sizeof(d));
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
for (int j = xa[i]; j < xb[i]; j++) {
for (int k = ya[i]; k < yb[i]; k++) {
d[j][k] += (1LL << i);
}
}
}
int ret = 0;
for (int i = 0; i <= n + 1; i++) {
for (int j = 0; j <= n + 1; j++) {
if (!f[i][j]) {
rec(j, i);
ret++;
}
}
}
cout << ret << endl;
}
}
|
#include <algorithm>
#include <cstring>
#include <iostream>
using namespace std;
int n, xa[52], ya[52], xb[52], yb[52], xc[102], yc[102], xd[52], yd[52], xe[52],
ye[52], f[103][103];
long long d[103][103];
int dx[4] = {1, 0, -1, 0}, dy[4] = {0, 1, 0, -1};
void rec(int x, int y) {
f[y][x] = true;
for (int i = 0; i < 4; i++) {
int tx = x + dx[i], ty = y + dy[i];
if (0 <= tx && tx <= 2 * n + 1 && 0 <= ty && ty <= 2 * n + 1) {
if (d[y][x] == d[ty][tx] && !f[ty][tx])
rec(tx, ty);
}
}
}
int main() {
while (cin >> n, n) {
for (int i = 0; i < n; i++) {
cin >> xa[i] >> yb[i] >> xb[i] >> ya[i];
xc[2 * i] = xa[i], yc[2 * i] = ya[i], xc[2 * i + 1] = xb[i],
yc[2 * i + 1] = yb[i];
}
sort(xc, xc + 2 * n);
sort(yc, yc + 2 * n);
memset(xd, 0, sizeof(xd));
memset(yd, 0, sizeof(yd));
memset(xe, 0, sizeof(xe));
memset(ye, 0, sizeof(ye));
for (int i = 0; i < n; i++) {
for (int j = 0; j < 2 * n; j++) {
if (xa[i] == xc[j] && !xd[i])
xa[i] = j + 1, xd[i] = 1;
if (ya[i] == yc[j] && !yd[i])
ya[i] = j + 1, yd[i] = 1;
if (xb[i] == xc[j] && !xe[i])
xb[i] = j + 1, xe[i] = 1;
if (yb[i] == yc[j] && !ye[i])
yb[i] = j + 1, ye[i] = 1;
}
}
memset(d, 0, sizeof(d));
memset(f, 0, sizeof(f));
for (int i = 0; i < n; i++) {
for (int j = xa[i]; j < xb[i]; j++) {
for (int k = ya[i]; k < yb[i]; k++) {
d[j][k] += (1LL << i);
}
}
}
int ret = 0;
for (int i = 0; i <= 2 * n + 1; i++) {
for (int j = 0; j <= 2 * n + 1; j++) {
if (!f[i][j]) {
rec(j, i);
ret++;
}
}
}
cout << ret << endl;
}
}
|
[["+", 0, 7, 15, 16, 12, 16, 31, 16, 31, 13], ["+", 0, 7, 15, 16, 12, 16, 31, 16, 17, 48]]
| 1
| 744
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> data;
int parts;
UnionFind(int size) {
data.assign(size, -1);
parts = size;
}
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (x == y)
return;
--parts;
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
int Find(int x) {
if (data[x] < 0)
return (x);
return (data[x] = Find(data[x]));
}
int size() { return (parts); }
};
int main() {
int N;
int X1[50], Y1[50], X2[50], Y2[50];
while (cin >> N, N) {
vector<int> nums1, nums2;
long long orr[300][300] = {{}};
for (int i = 0; i < N; i++) {
cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
if (X1[i] > X2[i])
swap(X1[i], X2[i]);
if (Y1[i] > Y2[i])
swap(Y1[i], Y2[i]);
nums1.push_back(X1[i]);
nums1.push_back(X2[i]);
nums2.push_back(Y1[i]);
nums2.push_back(Y2[i]);
}
nums1.push_back(-1);
nums2.push_back(-1);
sort(nums1.begin(), nums1.end());
nums1.erase(unique(nums1.begin(), nums1.end()), nums1.end());
sort(nums2.begin(), nums2.end());
nums2.erase(unique(nums2.begin(), nums2.end()), nums2.end());
for (int i = 0; i < N; i++) {
X1[i] = lower_bound(nums1.begin(), nums1.end(), X1[i]) - nums1.begin();
X2[i] = lower_bound(nums1.begin(), nums1.end(), X2[i]) - nums1.begin();
Y1[i] = lower_bound(nums2.begin(), nums2.end(), Y1[i]) - nums2.begin();
Y2[i] = lower_bound(nums2.begin(), nums2.end(), Y2[i]) - nums2.begin();
for (int j = X1[i]; j < X2[i]; j++) {
for (int k = Y1[i]; k < Y2[i]; k++) {
orr[j][k] |= 1LL << i;
}
}
}
UnionFind uftree(nums1.size() * nums2.size());
for (int j = 0; j < nums1.size(); j++) {
for (int k = 1; k < nums2.size(); k++) {
if (orr[j][k - 1] == orr[j][k]) {
uftree.Union(j * nums2.size() + k - 1, j * nums2.size() + k);
}
}
}
for (int j = 1; j < nums1.size(); j++) {
for (int k = 0; k < nums2.size(); k++) {
if (orr[j - 1][k] == orr[j][k]) {
uftree.Union(j * nums2.size() - nums2.size(), j * nums2.size() + k);
}
}
}
cout << uftree.size() << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct UnionFind {
vector<int> data;
int parts;
UnionFind(int size) {
data.assign(size, -1);
parts = size;
}
void Union(int x, int y) {
x = Find(x), y = Find(y);
if (x == y)
return;
--parts;
if (data[x] > data[y])
swap(x, y);
data[x] += data[y];
data[y] = x;
}
int Find(int x) {
if (data[x] < 0)
return (x);
return (data[x] = Find(data[x]));
}
int size() { return (parts); }
};
int main() {
int N;
int X1[50], Y1[50], X2[50], Y2[50];
while (cin >> N, N) {
vector<int> nums1, nums2;
long long orr[300][300] = {{}};
for (int i = 0; i < N; i++) {
cin >> X1[i] >> Y1[i] >> X2[i] >> Y2[i];
if (X1[i] > X2[i])
swap(X1[i], X2[i]);
if (Y1[i] > Y2[i])
swap(Y1[i], Y2[i]);
nums1.push_back(X1[i]);
nums1.push_back(X2[i]);
nums2.push_back(Y1[i]);
nums2.push_back(Y2[i]);
}
nums1.push_back(-1);
nums2.push_back(-1);
sort(nums1.begin(), nums1.end());
nums1.erase(unique(nums1.begin(), nums1.end()), nums1.end());
sort(nums2.begin(), nums2.end());
nums2.erase(unique(nums2.begin(), nums2.end()), nums2.end());
for (int i = 0; i < N; i++) {
X1[i] = lower_bound(nums1.begin(), nums1.end(), X1[i]) - nums1.begin();
X2[i] = lower_bound(nums1.begin(), nums1.end(), X2[i]) - nums1.begin();
Y1[i] = lower_bound(nums2.begin(), nums2.end(), Y1[i]) - nums2.begin();
Y2[i] = lower_bound(nums2.begin(), nums2.end(), Y2[i]) - nums2.begin();
for (int j = X1[i]; j < X2[i]; j++) {
for (int k = Y1[i]; k < Y2[i]; k++) {
orr[j][k] |= 1LL << i;
}
}
}
UnionFind uftree(nums1.size() * nums2.size());
for (int j = 0; j < nums1.size(); j++) {
for (int k = 1; k < nums2.size(); k++) {
if (orr[j][k - 1] == orr[j][k]) {
uftree.Union(j * nums2.size() + k - 1, j * nums2.size() + k);
}
}
}
for (int j = 1; j < nums1.size(); j++) {
for (int k = 0; k < nums2.size(); k++) {
if (orr[j - 1][k] == orr[j][k]) {
uftree.Union(j * nums2.size() + k - nums2.size(),
j * nums2.size() + k);
}
}
}
cout << uftree.size() << endl;
}
}
|
[["+", 0, 2, 3, 4, 0, 16, 31, 16, 17, 72], ["+", 0, 2, 3, 4, 0, 16, 31, 16, 12, 22]]
| 1
| 850
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.