text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
long double f[2050], ans, inv[2050], m;
int n;
int main() {
cin >> n >> m;
for (int i = 1; i < 2050; i++) inv[i] = 1.0 / i;
f[1] = 1.0;
long double q = 1 / m, eps = 1e-100;
while (n--)
for (int i = 2050 - 1; i >= 1; i--)
if (f[i] < eps)
f[i] = 0;
else {
ans += f[i] * i * (0.5 + inv[i + 1]);
long double j = f[i] * q * inv[i + 1];
f[i + 1] += j;
f[i] -= j;
}
printf("%.10lf\n", (double)(ans));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][605];
int main() {
int n, k, N = 600, cur = 0;
cin >> n >> k;
while (n--) {
cur = !cur;
for (int i = N; i; i--) {
double t1 = (dp[!cur][i + 1] + i) / (i + 1) +
(dp[!cur][i] + (i + 1.0) / 2) * i / (i + 1);
t1 /= k;
double t2 = dp[!cur][i] * (k - 1) / k;
dp[cur][i] = t1 + t2;
}
}
printf("%.10f\n", dp[cur][1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][(805)];
double sum[(805)];
int main() {
int N, K;
scanf("%d %d", &N, &K);
for (int j = 1; j < (805); j++) sum[j] = sum[j - 1] + j;
int pre = 0;
int now = 1;
double c1 = 1.0 * (K - 1) / K;
for (int i = 1; i <= N; i++) {
for (int j = 1; j < (805) - 1; j++) {
dp[now][j] = c1 * dp[pre][j];
dp[now][j] +=
(j * dp[pre][j] + dp[pre][j + 1] + j + sum[j]) / K / (j + 1);
}
pre ^= 1;
now ^= 1;
}
printf("%.9lf\n", dp[pre][1] * K);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100010;
const int B = 800;
int n, k, cur;
double dp[2][B];
int main() {
scanf("%d%d", &n, &k);
cur = 0;
for (int j = 1; j < B; j++) dp[1][j] = 0;
for (int i = 1; i <= n; i++, cur ^= 1)
for (int j = 1; j < B; j++)
dp[cur][j] = dp[cur ^ 1][j] * (k - 1) / k +
(j * dp[cur ^ 1][j] + (j + 1 < B ? dp[cur ^ 1][j + 1] : 0) +
j * (j + 3) / 2.0) /
k / (j + 1);
printf("%.10lf\n", k * dp[cur ^ 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[100001];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i)
for (int j = 1; j <= n - i + 1 && j * n < 80000000; ++j)
f[j] = (f[j] * j / (j + 1) + j / 2.0 + (f[j + 1] + j) / (j + 1) +
f[j] * (k - 1)) /
k;
printf("%.10lf", f[1] * k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (int)1e5 + 10, K = 500 + 10;
int n, k;
long double f[2][MAXN], logfac[MAXN], logp[MAXN], logp1[MAXN];
int main() {
scanf("%d%d", &n, &k);
for (int i = 0; i <= n; ++i) f[(K - 1) & 1][i] = (long double)i * K / 2;
for (int i = K - 2; i >= 1; --i)
for (int j = 1; j <= n; ++j)
f[i & 1][j] = (f[i & 1][j - 1] + (long double)(i + 1) / 2) *
((long double)i / (i + 1)) +
(f[(i + 1) & 1][j - 1] + i) * (1.0 / (i + 1));
for (int i = 1; i <= n; ++i)
logfac[i] = logfac[i - 1] + log((long double)i),
logp[i] = logp[i - 1] + log((long double)k),
logp1[i] = logp1[i - 1] + log((long double)(k - 1));
long double Tohka = 0;
for (int i = 1; i <= n; ++i) {
long double p =
logfac[n] - logfac[i] - logfac[n - i] + logp1[n - i] - logp[n - 1];
p = exp(p);
Tohka += p * f[1][i];
}
cout << setprecision(10);
cout << fixed << Tohka << endl;
fclose(stdin);
fclose(stdout);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1024;
int n, k;
double f[2][N + 1];
int main() {
cin >> n >> k;
int c = 0;
for (int i = 1; i <= n; ++i) {
c ^= 1;
memset(f[c], 0, sizeof f[c]);
for (int j = 1; j < N; j++) {
f[c][j] = (f[c ^ 1][j] * (k * (j + 1) - 1) + f[c ^ 1][j + 1] +
j * (j + 3) / 2) /
(k * (j + 1));
}
}
printf("%.11f\n", f[c][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][605];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int pre = 0, cur = 1;
for (int i = 0; i < n; ++i) {
memset(dp[cur], 0, sizeof dp[cur]);
for (int j = 1; j < 600; ++j)
dp[cur][j] += (1. * j / k / (j + 1) + (k - 1.) / k) * dp[pre][j] +
1. * (dp[pre][j + 1] + j) / ((j + 1.) * k) + 1. * j / 2 / k;
swap(pre, cur);
}
printf("%.15f\n", k * dp[pre][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-10);
double E[2][100001];
int main() {
memset(E, 0, sizeof(E));
int n, k;
scanf("%d %d", &n, &k);
int now = 1;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 1; j <= 700; j++)
E[now][j] = E[now ^ 1][j] * (j * 1. / (j + 1) / k + (k - 1) * 1. / k) +
(j * 1. / 2 + j * 1. / (j + 1)) / k +
1. / (j + 1) * E[now ^ 1][j + 1] / k;
}
printf("%.9f\n", k * E[now][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int K = 700;
const double eps = 1e-20;
double dp[K], p[K];
int main() {
int n, k;
scanf("%d%d", &n, &k);
p[1] = 1;
for (int i = 1; i <= n; i++)
for (int j = min(i + 1, K - 1); j >= 1; j--) {
int t = j * k;
dp[j] = (t + k - 1) * dp[j] / (t + k) + p[j] * j / (2 * k) +
(dp[j - 1] / t) + p[j - 1] * (j - 1) / t;
p[j] = p[j] * (t + k - 1) / (t + k) + p[j - 1] / t;
if (dp[j] < eps) dp[j] = 0;
if (p[j] < eps) p[j] = 0;
}
double ans = 0;
for (int i = 0; i < K; i++) ans += dp[i];
printf("%.10f\n", ans * k);
}
|
#include <bits/stdc++.h>
const int N = 525;
int n, k;
double f[2][N + 5];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; i++)
for (int j = 1; j <= N; j++)
f[i & 1][j] = (f[i & 1 ^ 1][j] * (k - 1. / (j + 1)) +
f[i & 1 ^ 1][j + 1] / (j + 1) + j / 2. + j / (j + 1.)) /
k;
printf("%.10f\n", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
int f = 0;
x = 0;
char ch = getchar();
for (; !isdigit(ch); ch = getchar()) f |= (ch == '-');
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
if (f) x = -x;
}
const int N = 100005, M = 1005;
const double eps = 1e-20;
long double f[2][M], g[2][M], fac[N], ans;
int n, K;
void dp(int i) {
memset(f[i], 0, sizeof f[i]);
memset(g[i], 0, sizeof g[i]);
for (int j = (1); j <= (1000); j++)
if (g[i ^ 1][j] > eps) {
g[i][j] += g[i ^ 1][j] * j / (j + 1);
g[i][j + 1] += g[i ^ 1][j] / (j + 1);
f[i][j] += (f[i ^ 1][j] + g[i ^ 1][j] * (j + 1) * 0.5) * j / (j + 1);
f[i][j + 1] += (f[i ^ 1][j] + g[i ^ 1][j] * (j + 1)) / (j + 1);
}
}
int main() {
read(n), read(K);
fac[0] = 0;
for (int i = (1); i <= (n); i++) fac[i] = fac[i - 1] + logl(i);
int cur = 0;
f[0][1] = g[0][1] = 1;
for (int i = (1); i <= (n); i++) {
dp(cur ^= 1);
long double res = 0;
for (int j = (1); j <= (1000); j++) {
res += f[cur][j] - j * g[cur][j];
}
long double coef = fac[n] - fac[i] - fac[n - i];
if (K == 1)
coef = 0;
else
coef += logl(K - 1) * (n - i) - logl(K) * n;
if (K != 1 || i == n) ans += K * res * expl(coef);
}
printf("%.10lf\n", (double)ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps(1e-10);
double E[2][600];
int main() {
memset(E, 0, sizeof(E));
int n, k;
scanf("%d %d", &n, &k);
int now = 1;
for (int i = n - 1; i >= 0; i--) {
now ^= 1;
for (int j = 1; j < 600; j++)
E[now][j] = E[now ^ 1][j] * (j * 1. / (j + 1) / k + (k - 1) * 1. / k) +
(j * 1. / 2 + j * 1. / (j + 1)) / k +
1. / (j + 1) * E[now ^ 1][j + 1] / k;
}
printf("%.9f\n", k * E[now][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-10;
const double PI = atan(1.0) * 4;
const int inf = ~0u >> 1;
const int Dx[] = {1, 0, -1, 0}, Dy[] = {0, 1, 0, -1};
template <class T>
bool chmin(T& a, const T& b) {
return b < a ? a = b, 1 : 0;
}
template <class T>
bool chmax(T& a, const T& b) {
return b > a ? a = b, 1 : 0;
}
template <class T>
int sgn(T first) {
return (first > eps) - (first < -eps);
}
double d[2][1111];
int main() {
int n, k;
cin >> n >> k;
int up = 700, now = 0, nxt = 1;
for (int i = (n); i >= (int)(1); i--) {
for (int j = (1); j <= (int)(up); j++) {
d[nxt][j] =
(k - 1.0) / k * d[now][j] +
(j * d[now][j] + d[now][j + 1] + j * (j + 3) / 2) / k / (j + 1);
}
swap(now, nxt);
}
printf("%.12f\n", d[now][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, i, j;
double A, B, C;
double f[2][1034];
int main() {
scanf("%d%d", &n, &k);
for (i = 1; i <= n; ++i)
for (j = 1; j < 1034; ++j) {
A = f[i & 1 ^ 1][j] * (double)(k * (j + 1) - 1);
B = f[i & 1 ^ 1][j + 1];
C = (double)(j * (j + 3) >> 1);
f[i & 1][j] = (A + B + C) / (double)(k * (j + 1));
}
printf("%.15lg\n", f[n & 1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:102400000,102400000")
using namespace std;
double dp[2][(40000 + 10)];
int main() {
int n, k;
scanf("%d%d", &n, &k);
int cur = 0, pre = 0;
for (int i = 1; i <= n; ++i) {
cur ^= 1;
for (int j = 0; j < 700; ++j) {
dp[cur][j] = 1.0 / (k * (j + 1)) *
(j * dp[pre][j] + (1 + j) * j / 2 + j + dp[pre][j + 1]) +
(1.0 - 1.0 / k) * dp[pre][j];
}
pre ^= 1;
}
printf("%.15lf\n", k * dp[cur][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
long double prob[2][710];
int main() {
long double wyn = 0.0l;
int n, k;
cin >> n >> k;
prob[0][1] = 1.0l;
for (int x = 0; x < n; x++) {
for (int i = 1; i <= 700; i++) prob[(x & 1) ^ 1][i] = 0.0l;
for (int i = 1; i < 700; i++) {
long double pr = prob[x & 1][i] / (k * (i + 1));
wyn += pr * ((i * (i + 3)) / 2);
prob[(x & 1) ^ 1][i + 1] += pr;
prob[(x & 1) ^ 1][i] += prob[x & 1][i] - pr;
}
}
cout.precision(17);
cout << fixed << wyn * k << "\n";
return 0;
}
|
#include <bits/stdc++.h>
double dp[2][1005];
int min(int x, int y) { return x < y ? x : y; }
int main() {
int n, k;
scanf("%d%d", &n, &k);
int p = 0, q = 1;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= min(1000, n - i + 1); ++j) {
dp[q][j] = (k - 1.0) / k * dp[p][j] +
1.0 / k / (j + 1) * (dp[p][j + 1] + j) +
1.0 / k / (j + 1) * (dp[p][j] * j + (1.0 + j) * j / 2.0);
}
p ^= 1, q ^= 1;
}
printf("%.10f\n", dp[p][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[2][605];
int Max = 600;
int main() {
int n, k;
while (cin >> n >> k) {
memset(dp, sizeof(dp), 0);
dp[0][1] = 1;
int cur = 0;
int next = 1;
double ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < Max; ++j)
ans += dp[cur][j] * (j / 2.0 + j / (j + 1.0));
for (int j = 1; j < Max; ++j)
dp[next][j] = dp[cur][j] * (1 - (1.0 / (j + 1) / k));
for (int j = 2; j < Max; ++j) dp[next][j] += dp[cur][j - 1] / j / k;
for (int j = 0; j < Max; ++j)
if (dp[next][j] < 1e-30) dp[next][j] = 0;
cur = next;
next = next ^ 1;
}
printf("%.9lf\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 617;
int n, k;
double f[N], ans = 0;
int main() {
int i, j;
scanf("%d%d", &n, &k);
for (i = 1; i <= n; i++)
for (j = 1; j <= 617; j++)
f[j] = 1.0 / k / (j + 1) * (j * (j + 3) / 2.0 + j * f[j] + f[j + 1]) +
1.0 * (k - 1) / k * f[j];
printf("%.10lf\n", k * f[1]);
}
|
#include <bits/stdc++.h>
int n, k;
double f[2][1000];
int main() {
scanf("%d%d", &n, &k);
for (register int i = 1; i <= n; i++)
for (register int j = 1; j < 1000; j++)
f[i & 1][j] =
(f[i & 1 ^ 1][j] * (k - 1) +
((f[i & 1 ^ 1][j] + (j + 1) / 2.0) * j + f[i & 1 ^ 1][j + 1] + j) /
(j + 1)) /
k;
return printf("%.10lf\n", f[n & 1][1] * k), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100000;
const int T = 600;
double dp[2][T + 10];
int main() {
int n, k, o = 0, oo;
cin >> n >> k;
dp[0][1] = 1;
double res = 0;
for (int i = 1; i <= n; i++, o ^= 1) {
oo = o ^ 1;
for (int j = 0; j <= T; j++) dp[oo][j + 1] = dp[o][j] / (j + 1) / k;
for (int j = 0; j <= T; j++)
dp[oo][j] += dp[o][j] * (1 - 1 / (j + 1.0) / k);
for (int j = 0; j <= T; j++) res += dp[o][j] * (j / 2.0 + j / (j + 1.0));
for (int j = 0; j <= T; j++)
if (dp[oo][j] < 1e-100) dp[oo][j] = 0;
}
cout << fixed << setprecision(10) << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, now;
double f[2][1005];
int main() {
scanf("%d%d", &n, &k);
for (int i = 1; i <= n; ++i) {
now = 1 - now;
for (int j = 1; j <= 1000; ++j)
f[now][j] = (1.0 * j / (k * (j + 1)) + (1 - 1.0 / k)) * f[1 - now][j] +
1.0 * j / (2 * k) + 1.0 * j / (k * (j + 1)) +
1.0 / (k * (j + 1)) * f[1 - now][j + 1];
}
printf("%.10lf\n", f[now][1] * k);
}
|
#include <bits/stdc++.h>
template <class T>
void read(T &x) {
int f = 1;
char c = getchar();
x = 0;
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
x *= f;
}
template <class T>
void write(T x) {
int len = 0;
char s[30];
if (x < 0) putchar('-'), x = -x;
do {
s[++len] = x % 10;
x /= 10;
} while (x);
while (len) putchar(s[len--] + '0');
}
template <class T>
inline bool gmin(T &a, T b) {
return a > b ? a = b, true : false;
}
template <class T>
inline bool gmax(T &a, T b) {
return a < b ? a = b, true : false;
}
const int maxn = 1e5 + 5;
int n, m, k;
int pre, cur;
double *f[2];
int main() {
read(n);
read(k);
m = std::min(n, 700);
f[0] = new double[m + 5];
f[1] = new double[m + 5];
for (int i = 1; i <= m + 1; i++) f[0][i] = 0.0;
pre = 1;
cur = 0;
for (int i = 1; i <= n; i++) {
pre ^= 1;
cur ^= 1;
for (int j = 1; j <= m; j++) {
double sum0 = ((f[pre][j] + (j + 1) / 2.0) * j / (j + 1) +
(f[pre][j + 1] + j) / (j + 1)) /
k;
double sum1 = f[pre][j] * (k - 1) / k;
f[cur][j] = sum0 + sum1;
}
f[cur][m + 1] = 0.0;
}
printf("%.10lf\n", f[cur][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double p[10000], nextp[10000];
double invj[10000];
double jj[10000];
double error = 1e-15;
int main() {
cout.setf(ios::fixed);
cout.precision(10);
int n, k;
cin >> n >> k;
double invk = 1.0 / k;
double kk = double(k - 1) / k;
int tope = 600;
p[1] = 1;
double e = 0;
for (int j = 1; j < 10000; j++) {
invj[j] = 1.0 / j;
jj[j] = double(j) / (j + 1);
}
int jini = 1;
int jfin = 1;
for (int i = 0; i < n; i++) {
while (p[jini] < error) jini++;
while (p[jfin] >= error and jfin < tope) jfin++;
for (int j = jini; j <= jfin; j++)
e += p[j] * double(j) * (0.5 + invj[j + 1]);
for (int j = jini; j < jfin; j++)
nextp[j] = invk * (p[j - 1] * invj[j] + p[j] * jj[j]) + kk * p[j];
nextp[jfin] = invk * (p[jfin - 1] / jfin + p[jfin]) + kk * p[jfin];
for (int j = jini; j <= jfin; j++) p[j] = nextp[j];
}
cout << e << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T abs(T x) {
return x > 0 ? x : -x;
}
const int N = 600;
int n;
int m;
long double res[N + 1];
long double prob[N + 1];
long double sum[100001];
long double f[100001];
int main() {
scanf("%d%d", &n, &m);
f[0] = 0;
for (int i = 1; i <= n; i++) f[i] = f[i - 1] + log(i + 0.0);
prob[1] = 1;
int last = 1;
for (int i = 0; i <= n; i++) {
long double tmp = 0;
for (int j = min(N, last + 1); j >= 1; j--) {
tmp += res[j];
res[j] = j / (j + 1.0) * (res[j] + (j + 1) * prob[j] / 2) +
(res[j - 1] + (j - 1) * prob[j - 1]) / j;
prob[j] = prob[j] * j / (j + 1) + prob[j - 1] / j;
if (res[j] > 1e-18 || prob[j] > 1e-18) last = max(last, j);
}
sum[i] = tmp;
}
if (m == 1)
printf("%.10f\n", (double)sum[n]);
else {
long double ans = 0;
for (int i = 0; i <= n; i++) {
long double tmp = f[n] - f[i] - f[n - i] + log(1.0 / m) * i +
log((m - 1.0) / m) * (n - i);
ans += exp(tmp) * sum[i] * m;
}
printf("%.10f\n", (double)ans);
}
cerr << clock() << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int IN() {
char c;
register int first = 0;
while ((c = getchar()) < 48 && c ^ '-' || c > 57)
;
bool f = c == '-';
if (f) (c = getchar());
for (; c > 47 && c < 58; (c = getchar())) first = first * 10 + c - 48;
if (f) first = -first;
return first;
}
int N, K;
double E[2][605];
int main() {
N = IN();
K = IN();
for (int i = N, now, nxt; i; --i) {
now = i & 1;
nxt = now ^ 1;
memset(E[now], 0, sizeof E[now]);
for (int _r = 600, j = 1; j <= _r; ++j)
E[now][j] = (j / 2. + (j * E[nxt][j] + j + E[nxt][j + 1]) / (j + 1)) / K +
E[nxt][j] * (K - 1) / K;
}
printf("%.10lf\n", K * E[1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double f[2][1000];
int main() {
cin >> n >> k;
int cur = 1, pre;
for (int i = 1; i <= n; i++) {
pre = cur ^ 1;
for (int j = 1; j <= 800; j++) {
f[cur][j] =
1.0 / k / (j + 1) *
(j * f[pre][j] + 1.0 * j * (j + 1) / 2 + j + f[pre][j + 1]) +
(1.0 * k - 1) / k * f[pre][j];
}
cur ^= 1;
}
printf("%.12f\n", k * f[cur ^ 1][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double table[2][1005];
int main() {
int N, K;
cin >> N >> K;
for (int t = 1; t <= N; t++) {
for (int l = 1; l < 1000; l++) {
double good = ((l + table[(t - 1) & 1][l + 1]) +
l * ((l + 1) / 2.0 + table[(t - 1) & 1][l])) /
(l + 1);
table[t & 1][l] = (good + (K - 1.0) * table[(t - 1) & 1][l]) / K;
}
double good = (1000 + 2) / 2.0 + table[(t - 1) & 1][1000];
table[t & 1][1000] = (good + (K - 1.0) * table[(t - 1) & 1][1000]) / K;
}
printf("%.12f\n", K * table[N & 1][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100005, maxl = 705;
int n, K;
double ans;
double f[2][maxn];
int main() {
int i, j;
scanf("%d%d", &n, &K);
for (i = maxl - 1; i; i--) {
for (j = 1; j <= n; j++) f[i & 1][j] = 0;
for (j = 1; j <= n; j++)
f[i & 1][j] = ((i * f[i & 1][j - 1] + f[!(i & 1)][j - 1] +
(double)i * (i + 3) / 2)) /
(i + 1) / K +
f[i & 1][j - 1] * (K - 1) / K;
}
ans = f[1][n] * K;
printf("%.10lf\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
double d[2][701];
int main() {
int n, k, i, j, togle = 0;
scanf("%d %d", &n, &k);
for (i = 0; i < n; i++) {
for (j = 1; j <= 700; j++) {
d[!togle][j] = 1.0 / k / (j + 1) *
(j * d[togle][j] + d[togle][j + 1] + j * (j + 3) / 2) +
1.0 * (k - 1) / k * d[togle][j];
}
togle = !togle;
}
printf("%.11lf\n", d[togle][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
double dp[2][605];
int main() {
scanf("%d %d", &n, &k);
for (int i = n; i >= 1; i--) {
for (int j = 1; j <= 600; j++) {
dp[i & 1][j] =
1.0 / k *
(1.0 * j * dp[(i + 1) & 1][j] / (j + 1) + j / 2.0 +
1.0 * dp[(i + 1) & 1][j + 1] / (j + 1) + 1.0 * j / (j + 1));
if (k != 1) dp[i & 1][j] += 1.0 * (k - 1) / (k) * (dp[(i + 1) & 1][j]);
}
}
printf("%.9lf\n", dp[1][1] * k);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MM = 100005;
const long long MOD = 1000000007;
bool judge(int hpy, int atky, int defy, int hpm, int atkm, int defm) {
int a = max(0, atky - defm), b = max(0, atkm - defy);
if (a == 0) return false;
if (b == 0) return true;
int c = hpm % a == 0 ? hpm / a : hpm / a + 1;
int d = hpy % b == 0 ? hpy / b : hpy / b + 1;
if (d > c) return true;
return false;
}
int main() {
int h, a, d;
int hpy, atky, defy, hpm, atkm, defm;
scanf("%d%d%d", &hpy, &atky, &defy);
scanf("%d%d%d", &hpm, &atkm, &defm);
scanf("%d%d%d", &h, &a, &d);
int ans = (1 << 30);
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
for (int k = 0; k <= 1000; k++) {
if (i * h + j * a + k * d > ans) break;
if (judge(hpy + i, atky + j, defy + k, hpm, atkm, defm)) {
ans = min(ans, i * h + j * a + k * d);
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long hm1, hm2, am1, am2, dm1, dm2, a, h, d, jav = 1e9;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> hm1 >> am1 >> dm1;
cin >> hm2 >> am2 >> dm2;
cin >> h >> a >> d;
for (int i = hm1; i < 1000; i++)
for (int j = am1; j < 400; j++)
for (int k = dm1; k < 200; k++) {
if (dm2 < j) {
long long y = 1e9;
long long x = (hm2 + j - dm2 - 1) / (j - dm2);
if (am2 > k) y = (i + am2 - k - 1) / (am2 - k);
if (x < y) {
long long p = (i - hm1) * h + (j - am1) * a + (k - dm1) * d;
jav = min(jav, p);
}
}
}
if (jav == 1e9) jav = 0;
cout << jav << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int MAX = 2e5 + 7;
const int INF = 1e9;
int main() {
ios_base::sync_with_stdio(false);
int hp0, hp1, att0, att1, def0, def1;
int hp_cost, att_cost, def_cost;
cin >> hp0 >> att0 >> def0;
cin >> hp1 >> att1 >> def1;
cin >> hp_cost >> att_cost >> def_cost;
int ans = INF;
for (int i = def0; i <= 100; i++) {
for (int j = att0; j <= 200; j++) {
if (j <= def1) continue;
int t = ceil(1.0 * hp1 / (j - def1));
int h = max(hp0, 1 + (att1 - i) * t);
ans = min(ans, (h - hp0) * hp_cost + (j - att0) * att_cost +
(i - def0) * def_cost);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct PL {
int hp, atk, def;
};
PL yan, mon;
int h, a, d, ans;
int upatk, updef, loatk;
int main() {
scanf("%d %d %d", &yan.hp, &yan.atk, &yan.def);
scanf("%d %d %d", &mon.hp, &mon.atk, &mon.def);
scanf("%d %d %d", &h, &a, &d);
ans = 1000000009;
loatk = max(0, mon.def - yan.atk + 1);
upatk = mon.def + mon.hp - yan.atk;
updef = max(0, mon.atk - yan.def);
for (int i = loatk; i <= upatk; i++)
for (int j = 0; j <= updef; j++) {
int r = (mon.hp + yan.atk + i - mon.def - 1) / (yan.atk + i - mon.def);
int k = max(0, r * (mon.atk - yan.def - j) - yan.hp + 1);
int ta = i * a + j * d + k * h;
ans = min(ans, ta);
}
if (ans == 1000000009) ans = 0;
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost_hp, cost_atk, cost_def, monster_hp, monster_atk, monster_def;
bool wins(int hp, int atk, int def) {
int hp_lost = monster_atk - def, monster_hp_lost = atk - monster_def;
if (monster_hp_lost <= 0) {
return false;
} else {
int n = monster_hp / monster_hp_lost + (monster_hp % monster_hp_lost != 0);
if (hp_lost <= 0) {
return n > 0;
} else {
int m = hp / hp_lost + (hp % hp_lost != 0);
return n < m;
}
}
}
int main(void) {
int hp, atk, def;
scanf("%d %d %d", &hp, &atk, &def);
scanf("%d %d %d", &monster_hp, &monster_atk, &monster_def);
scanf("%d %d %d", &cost_hp, &cost_atk, &cost_def);
int ans = 0x2f2f2f2f;
for (int j = atk; j <= 205; ++j) {
for (int k = def; k <= 105; ++k) {
for (int i = hp; i <= 2048; ++i) {
if (wins(i, j, k)) {
ans = min(ans, (i - hp) * cost_hp + (j - atk) * cost_atk +
(k - def) * cost_def);
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long hpy, atky, defy;
long hpm, atkm, defm;
long thpy, tatky, tdefy;
long morehp, moreatk, moredef;
long res, nowm;
long h, a, d;
int main() {
cin >> hpy >> atky >> defy;
cin >> hpm >> atkm >> defm;
cin >> h >> a >> d;
res = 1000000000;
for (moredef = 0; moredef <= 10000; moredef++)
for (moreatk = 0; moreatk <= 10000; moreatk++) {
tdefy = defy + moredef;
tatky = atky + moreatk;
nowm = tatky - defm;
if (nowm <= 0) continue;
if (hpm % nowm == 0)
nowm = hpm / nowm;
else
nowm = hpm / nowm + 1;
long tt = nowm * (atkm - tdefy) + 1;
long ttt = moredef * d + moreatk * a + max(long(0), tt - hpy) * h;
if (ttt < res) res = ttt;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy;
int hm, am, dm;
int ph, pa, pd;
scanf("%d%d%d%d%d%d%d%d%d", &hy, &ay, &dy, &hm, &am, &dm, &ph, &pa, &pd);
int ans = 1 << 30, least = 0;
int cur_ay = ay;
if (cur_ay < dm + 1) {
least = pa * (dm + 1 - cur_ay);
cur_ay = dm + 1;
}
int tar_ay, tar_dy;
int c1, c2;
for (int k = 1; k <= 100; k++) {
c1 = least;
tar_ay = dm + hm / k + (hm % k ? 1 : 0);
if (tar_ay > cur_ay) c1 += (tar_ay - cur_ay) * pa;
tar_dy = am - hy / k + (hy % k ? 0 : 1);
if (tar_dy <= dy)
ans = min(ans, c1);
else {
for (int j = 0; dy + j < tar_dy; j++) {
c2 = c1 + j * pd + (k * (am - dy - j) - hy + 1) * ph;
if (c2 < ans) ans = c2;
}
ans = min(c1 + (tar_dy - dy) * pd, ans);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5 + 5;
const long long mod = 1e9 + 7, INF = 1 << 30;
int b[3][4], h, a, d;
void init(void) {
for (int i = 1; i <= 2; i++)
for (int j = 1; j <= 3; j++) scanf("%d", &b[i][j]);
scanf("%d%d%d", &h, &a, &d);
}
void process(void) {
int def = max(0, b[2][2] - b[1][3]), off = max(0, b[1][2] - b[2][3]);
if (!def) {
if (!off) {
printf("%d", (b[2][3] - b[1][2] + 1) * a);
return;
}
printf("0");
return;
}
int tmp = 0, hp = b[1][1] - 1, hpm = b[2][1] - 1;
if (!off) {
tmp = (b[2][3] - b[1][2] + 1) * a;
off = 1;
}
int res = def * d + tmp;
for (int n = 0; n <= def - 1; n++) {
int ans = 1e9, ndef = def - n, noff = off;
for (int p = 0; p <= 100; p++) {
int tar = hpm / noff;
int m = max(0, (tar + 1) * ndef - hp);
ans = min(ans, m * h + n * d + p * a + tmp);
noff++;
}
res = min(res, ans);
}
printf("%d", res);
}
int main(void) {
init();
process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mod1 = int(1e9) + 7;
int main() {
int HPY, AY, DY;
int HPM, AM, DM;
int HPP, AP, DP;
cin >> HPY >> AY >> DY;
cin >> HPM >> AM >> DM;
cin >> HPP >> AP >> DP;
long long minc = 100000000;
for (int a = 0; a < 250; a++) {
if (AY + a <= DM) continue;
long long cand = a * AP;
if (cand > minc) break;
for (int d = 0; d < 110; d++) {
int cand2 = cand + d * DP;
if (cand2 > minc) break;
int sec = HPM / (a + AY - DM);
if (HPM % (a + AY - DM) > 0) sec++;
int needHP = sec * max(0, AM - DY - d) + 1;
long long cand3 = 1LL * max(0, needHP - HPY) * HPP + cand2;
minc = min(minc, cand3);
}
}
cout << minc << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int fight(int att, int def);
int hp1, hp2, att1, att2, def1, def2, H, A, D, res, coins, l;
int main() {
ios::sync_with_stdio(0);
cin >> hp1 >> att1 >> def1;
cin >> hp2 >> att2 >> def2;
cin >> H >> A >> D;
res = 1000000000;
for (int i = (0), _b = (200); i <= _b; i++)
for (int j = (0), _b = (100); j <= _b; j++) {
coins = i * A + j * D;
l = fight(att1 + i, def1 + j);
if (l == -1000000000) continue;
if (l >= 0) coins += (l + 1) * H;
res = min(res, coins);
}
cout << res;
return 0;
}
int fight(int att, int def) {
int HP, ATT, DEF, hp;
hp = -hp1;
HP = hp2;
ATT = att2;
DEF = def2;
while (1) {
hp += max(0, ATT - def);
if (att - DEF <= 0) return -1000000000;
HP -= max(0, att - DEF);
if (HP <= 0) return hp;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int h[3];
int a[3];
int d[3];
int cost(int i, int j) {
if (i <= d[1]) return 1000000000;
if (j >= a[1]) return (i - a[0]) * a[2] + (j - d[0]) * d[2];
int l = (int)ceil(h[1] / (double)(i - d[1]));
l = l * (a[1] - j);
l++;
if (l <= h[0]) return (i - a[0]) * a[2] + (j - d[0]) * d[2];
return (i - a[0]) * a[2] + (j - d[0]) * d[2] + (l - h[0]) * h[2];
}
int main() {
ios::sync_with_stdio(false);
int i, j, k;
for (i = 0; i < 3; i++) cin >> h[i] >> a[i] >> d[i];
int an = 1000000000;
for (i = a[0]; i <= (a[0] > d[1] + 100 ? a[0] : d[1] + 100); i++)
for (j = d[0]; j <= (d[0] > a[1] ? d[0] : a[1]); j++) {
an = (an < cost(i, j) ? an : cost(i, j));
}
cout << an;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hp1, hp2, at1, at2, de1, de2;
cin >> hp1 >> at1 >> de1 >> hp2 >> at2 >> de2;
int h, a, d;
cin >> h >> a >> d;
int ans = 0;
if (at1 - de2 <= 0) ans += a * (de2 - at1 + 1), at1 = de2 + 1;
int tmp = ~0u >> 1;
for (int i = hp1; i <= 1000; i++) {
for (int j = at1; j <= 200; j++) {
for (int k = de1; k <= max(at2, de1); k++) {
int x = ~0u >> 1;
if (at2 - k > 0) x = i / (at2 - k) + (i % (at2 - k) ? 1 : 0);
int y = hp2 / (j - de2) + (hp2 % (j - de2) ? 1 : 0);
if (x > y) {
tmp = min(tmp, h * (i - hp1) + a * (j - at1) + d * (k - de1));
}
}
}
}
if (tmp != (~0u >> 1)) ans += tmp;
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct P {
int h, a, d;
};
int main() {
P yang, mons, inc;
int min, st, hp, atk, def;
scanf("%d %d %d", &yang.h, &yang.a, &yang.d);
scanf("%d %d %d", &mons.h, &mons.a, &mons.d);
scanf("%d %d %d", &hp, &atk, &def);
st = 0;
if (yang.a <= mons.d) st = mons.d - yang.a + 1;
min = (999999 * hp) + (999999 * atk) + (999999 * def);
for (inc.a = st; inc.a <= 200; inc.a++) {
for (inc.d = 0; inc.d <= 100; inc.d++) {
for (inc.h = 0; inc.h <= 3000; inc.h++) {
int temp, y_rem, m_rem;
if (yang.d + inc.d >= mons.a)
y_rem = 999999;
else {
y_rem = (yang.h + inc.h) / (mons.a - (yang.d + inc.d));
if (y_rem * (mons.a - (yang.d + inc.d)) != (yang.h + inc.h)) y_rem++;
}
m_rem = mons.h / ((yang.a + inc.a) - mons.d);
if (m_rem * ((yang.a + inc.a) - mons.d) != mons.h) m_rem++;
if (y_rem <= m_rem) continue;
temp = (inc.h * hp) + (inc.a * atk) + (inc.d * def);
if (temp < min) min = temp;
}
}
}
printf("%d", min);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int H, A, D, MH, MA, MD;
int main() {
int a, b, c;
cin >> H >> A >> D;
cin >> MH >> MA >> MD;
cin >> a >> b >> c;
int ans = 1000000;
for (int j = 0; j <= 200; ++j)
for (int k = 0; k <= 200; ++k) {
int AA = A + j;
int DD = D + k;
int A = max(0, AA - MD) ? (MH + max(0, AA - MD) - 1) / max(0, AA - MD)
: 1000000000;
if (A == 1000000000) continue;
int HH = A * max(0, MA - DD) + 1;
int i = max(0, HH - H);
ans = min(ans, a * i + b * j + c * k);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int att_y, att_m, att_c, def_y, def_m, def_c, hp_y, hp_m, hp_c;
bool beat(int hp, int att, int def) {
int hp_gain = max(att - def_m, 0);
int hp_loss = max(att_m - def, 0);
if (hp_gain == 0) return 0;
if (hp_loss == 0) return 1;
int yt = hp / hp_loss;
int dt = hp_m / hp_gain;
if (hp % hp_loss) yt++;
if (hp_m % hp_gain) dt++;
if (yt > dt) return 1;
return 0;
}
int cost(int hp, int att, int def) {
return (hp - hp_y) * hp_c + (att - att_y) * att_c + (def - def_y) * def_c;
}
int main() {
scanf("%d%d%d", &hp_y, &att_y, &def_y);
scanf("%d%d%d", &hp_m, &att_m, &def_m);
scanf("%d%d%d", &hp_c, &att_c, &def_c);
int min_cost = 2000000001;
for (int i = hp_y; i < 1001; i++)
for (int j = att_y; j < 201; j++)
for (int k = def_y; k < 201; k++)
if (beat(i, j, k)) min_cost = min(min_cost, cost(i, j, k));
printf("%d\n", min_cost);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int pricehp, priceatk, pricedef;
int hp1, atk1, def1;
int hp2, atk2, def2;
int calc_hp_after(int hp1, int atk1, int def1, int hp2, int atk2, int def2) {
int decr_of_1 = max(0, atk2 - def1);
int decr_of_2 = max(0, atk1 - def2);
if (decr_of_2 == 0) return -1000000;
if (decr_of_1 == 0) return 1;
int n_to_die_1 = (int)ceil((double)(hp1) / (double)decr_of_1);
int n_to_die_2 = (int)ceil((double)(hp2) / (double)decr_of_2);
return hp1 - n_to_die_2 * decr_of_1;
}
int main(void) {
cin >> hp1 >> atk1 >> def1;
cin >> hp2 >> atk2 >> def2;
cin >> pricehp >> priceatk >> pricedef;
int overall = 1 << 30;
for (int j = 0; j < 202; j++) {
for (int k = 0; k < 101; k++) {
int hp_after = calc_hp_after(hp1, atk1 + j, def1 + k, hp2, atk2, def2);
int hp_needed = (hp_after <= 0) ? (-hp_after + 1) : 0;
int cost = j * priceatk + k * pricedef + pricehp * hp_needed;
overall = min(overall, cost);
}
}
cout << overall << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int i, j, k, n, m, x, T, ans, big, cas, hy, ay, dy, hm, am, dm, h, a, d, m_hp,
y_hp, times, myhp, money;
bool flag;
int main() {
scanf("%d%d%d", &hy, &ay, &dy);
scanf("%d%d%d", &hm, &am, &dm);
scanf("%d%d%d", &h, &a, &d);
ans = 1 << 30;
for (i = max(ay, dm + 1); i <= 220; i++) {
for (j = dy; j <= 110; j++) {
m_hp = max(0, i - dm);
y_hp = max(0, am - j);
times = ceil(hm * 1.0 / m_hp);
myhp = times * (y_hp);
money = max(myhp - hy + 1, 0) * h + (i - ay) * a + (j - dy) * d;
ans = min(ans, money);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int H, A, D, MH, MA, MD;
int main() {
int a, b, c;
cin >> H >> A >> D;
cin >> MH >> MA >> MD;
cin >> a >> b >> c;
int ans = 1000000;
for (int j = 0; j <= 6000; ++j)
for (int k = 0; k <= 6000; ++k) {
int AA = A + j;
int DD = D + k;
int A = max(0, AA - MD) ? (MH + max(0, AA - MD) - 1) / max(0, AA - MD)
: 1000000000;
if (A == 1000000000) continue;
int HH = A * max(0, MA - DD) + 1;
int i = max(0, HH - H);
ans = min(ans, a * i + b * j + c * k);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct trip {
int a, d, h;
};
trip y, m, cost;
bool cankill(trip tmp) {
if (m.d >= tmp.a) return false;
if (tmp.d >= m.a) return true;
int time2killm = m.h / (tmp.a - m.d) + (m.h % (tmp.a - m.d) > 0);
int time2killy = tmp.h / (m.a - tmp.d) + (tmp.h % (m.a - tmp.d) > 0);
return time2killm < time2killy;
}
bool check(int tot) {
trip tmp;
bool found = false;
for (int i = 0; i * cost.h <= tot && !found; ++i) {
for (int j = 0; j * cost.d + i * cost.h <= tot && !found; ++j) {
for (int k = 0; j * cost.d + i * cost.h + k * cost.a <= tot && !found;
++k) {
tmp.a = y.a + k;
tmp.d = y.d + j;
tmp.h = y.h + i;
if (cankill(tmp)) found = true;
}
}
}
return found;
}
int main() {
cin >> y.h >> y.a >> y.d >> m.h >> m.a >> m.d >> cost.h >> cost.a >> cost.d;
int l = 0, r = 100 * (cost.h + cost.a + cost.d);
int mid;
while (r - l > 1) {
mid = (l + r) / 2;
if (check(mid))
r = mid;
else
l = mid;
}
if (check(l))
cout << l;
else
cout << r;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, h2, d1, d2, a1, a2, H, A, D;
cin >> h1 >> a1 >> d1;
cin >> h2 >> a2 >> d2;
int ans = 100000000;
cin >> H >> A >> D;
for (int i = 0; i < 1000; i++)
for (int j = 0; j < 1000; j++) {
int y = a1 + i - d2, m = a2 - d1 - j;
if (y <= 0) continue;
int k = 0;
if (h2 % y != 0) k++;
k += h2 / y;
int s = 0;
if (h1 - m * k <= 0) s += abs(h1 - m * k - 1) * H;
ans = min(ans, s + A * i + D * j);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a1, a2, h1, h2, d1, d2, i, ca, cd, ch, j, lpsm, lpsy, nosm, nosy, gold,
reqh, reqa, reqd, mincost;
mincost = INT_MAX;
scanf("%d%d%d%d%d%d%d%d%d", &h1, &a1, &d1, &h2, &a2, &d2, &ch, &ca, &cd);
for (i = a1; i <= 200; i++) {
for (j = d1; j <= 100; j++) {
lpsy = max(0, a2 - j);
lpsm = max(0, i - d2);
if (lpsm == 0) continue;
nosm = ceil(double(h2) / lpsm);
reqh = (nosm * lpsy) + 1 - h1;
if (reqh > 0)
gold = reqh * ch;
else
gold = 0;
reqa = i - a1;
gold += (reqa * ca);
reqd = j - d1;
gold += (reqd * cd);
if (gold < mincost) mincost = gold;
}
}
printf("%d\n", mincost);
return 0;
}
|
#include <bits/stdc++.h>
long long mpow(long long a, long long n, long long mod) {
long long ret = 1;
long long b = a;
while (n) {
if (n & 1) ret = (ret * b) % mod;
b = (b * b) % mod;
n >>= 1;
}
return (long long)ret;
}
using namespace std;
bool chk(int x, int y, int z, int X, int Y, int Z) {
if (y <= Z) {
return 0;
}
while (x > 0 && X > 0) {
x -= max(0, Y - z);
X -= max(0, y - Z);
}
if (x > 0) return 1;
return 0;
}
void solve() {
int hy, ay, dy, hm, am, dm, ch, ca, cm;
scanf("%d", &hy);
scanf("%d", &ay);
scanf("%d", &dy);
scanf("%d", &hm);
scanf("%d", &am);
scanf("%d", &dm);
scanf("%d", &ch);
scanf("%d", &ca);
scanf("%d", &cm);
int ans = 1e9;
for (int i = 0; i <= 1001; i++) {
for (int j = 0; j <= 1001; j++) {
int lo = 0, hi = 1001;
while (lo < hi) {
int mid = (lo + hi) >> 1;
if (chk(i + hy, j + ay, mid + dy, hm, am, dm)) {
hi = mid;
} else {
lo = mid + 1;
}
}
if (chk(hy + i, j + ay, lo + dy, hm, am, dm))
ans = min(ans, i * ch + j * ca + lo * cm);
}
}
printf("%d", ans);
}
int main() {
int t = 1;
for (int i = 1; i <= t; i++) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy;
int hm, am, dm;
int h, a, d;
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> h >> a >> d;
int ans = 2e9;
for (int j = 0; j <= 200; j++)
for (int k = 0; k <= 100; k++) {
int dif = (ay + j) - dm;
if (dif <= 0) break;
int time = (hm / dif) + (hm % dif ? 1 : 0);
int yang = hy - max(am - (dy + k), 0) * time;
int extraH = yang <= 0 ? -yang + 1 : 0;
int thiz = extraH * h + j * a + k * d;
ans = min(ans, thiz);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int min(long long int a, long long int b) {
if (a > b) return b;
return a;
}
int a, h, d, a1, h1, d1, a2, h2, d2;
long long int n, m;
long long int x[201][201] = {9876543210};
bool v[201][201] = {false};
int main() {
scanf("%d%d%d", &h1, &a1, &d1);
scanf("%d%d%d", &h2, &a2, &d2);
scanf("%d%d%d", &h, &a, &d);
long long int ans = 0, ans1;
if (a1 <= d2) {
ans = a * (d2 - a1);
a1 = d2;
}
for (int i = 0; a1 + i <= 200; ++i) {
for (int j = 0; d1 + j <= 100; ++j) {
int x1, y1, decM, decY;
x1 = a1 + i;
y1 = d1 + j;
decM = max(0, x1 - d2);
decY = max(0, a2 - y1);
if (decM == 0 && decY != 0) {
v[i][j] = false;
}
if (decY == 0 && decM != 0) {
v[i][j] = true;
x[i][j] = a * i + d * j;
}
if (decM == 0 && decY == 0) {
v[i][j] = false;
}
if (decY != 0 && decM != 0) {
v[i][j] = true;
int q1, q2;
if (h2 % decM == 0)
q2 = h2 / decM;
else {
q2 = h2 / decM + 1;
}
x[i][j] = 0;
x[i][j] = h * max(0, (q2 * decY + 1 + -h1));
x[i][j] = x[i][j] + (a * i + d * j);
}
}
}
ans1 = 9876543210;
for (int i = 0; a1 + i <= 200; ++i) {
for (int j = 0; d1 + j <= 100; ++j) {
if (v[i][j] == true) {
ans1 = min(ans1, x[i][j]);
}
}
}
printf("%lld\n", (ans + ans1));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1000005;
const long long oo = 1e18;
const double eps = 1e-11;
int x, y, z;
int xx1, yy1, z1;
int a, b, c;
bool win(int X, int Y, int Z) {
if (X > 0 && xx1 <= 0) return 1;
if (X <= 0) return 0;
if (Y <= z1) return 0;
if (yy1 <= Z) return 1;
int cc, bb;
cc = X / (yy1 - Z);
bb = xx1 / (Y - z1);
if (X % (yy1 - Z) != 0) cc++;
if (xx1 % (Y - z1) != 0) bb++;
if (cc > bb) return 1;
return 0;
}
int sol = 1e9;
int main() {
cin.sync_with_stdio(false);
cin.tie(0);
cin >> x >> y >> z;
cin >> xx1 >> yy1 >> z1;
cin >> a >> b >> c;
for (int i = 0; i <= 1000; i++)
for (int j = 0; j <= 200; j++)
for (int k = 0; k <= 200; k++) {
if (win(x + i, y + j, z + k)) {
sol = min(sol, i * a + b * j + c * k);
}
}
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost_hp, cost_atk, cost_def, monster_hp, monster_atk, monster_def;
bool wins(int hp, int atk, int def) {
int hp_lost = monster_atk - def, monster_hp_lost = atk - monster_def;
if (monster_hp_lost <= 0) {
return false;
} else {
int n = monster_hp / monster_hp_lost + (monster_hp % monster_hp_lost != 0);
if (hp_lost <= 0) {
return n > 0;
} else {
int m = hp / hp_lost + (hp % hp_lost != 0);
return n < m;
}
}
}
int main(void) {
int hp, atk, def;
scanf("%d %d %d", &hp, &atk, &def);
scanf("%d %d %d", &monster_hp, &monster_atk, &monster_def);
scanf("%d %d %d", &cost_hp, &cost_atk, &cost_def);
int ans = 0x2f2f2f2f;
for (int j = atk; j <= 205; ++j) {
for (int k = def; k <= 105; ++k) {
for (int i = hp; i <= 2048; ++i) {
if (wins(i, j, k)) {
ans = min(ans, (i - hp) * cost_hp + (j - atk) * cost_atk +
(k - def) * cost_def);
}
}
}
}
printf("%d\n", atk > 205 || def > 105 ? 0 : ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hp1, atc1, def1, hp2, atc2, def2, hpPrice, atcPrice, defPrice;
bool win(int a, int b, int c) {
int h = hp1 + a, atc = atc1 + b, def = def1 + c;
int decRate1 = max(0, atc2 - def);
int decRate2 = max(0, atc - def2);
int time1 = 0x3f3f3f3f, time2 = 0x3f3f3f3f;
if (decRate1 != 0) time1 = ceil(double(h) / decRate1);
if (decRate2 != 0) time2 = ceil(double(hp2) / decRate2);
return time1 > time2;
}
int main() {
cin >> hp1 >> atc1 >> def1 >> hp2 >> atc2 >> def2 >> hpPrice >> atcPrice >>
defPrice;
int mn = 0x3f3f3f3f;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
int l = 0, r = 1000;
while (l <= r) {
int mid = (l + r) >> 1;
if (win(i, j, mid)) {
mn = min(mn, (i * hpPrice) + (j * atcPrice) + (mid * defPrice));
r = mid - 1;
} else
l = mid + 1;
}
}
}
printf("%d", mn);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy;
int hm, am, dm;
int h, a, d;
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> h >> a >> d;
int res = 1e9;
for (int atk = dm + 1; atk <= 200; ++atk) {
for (int def = dy; def <= 100; ++def) {
int rnd = (hm + atk - dm - 1) / (atk - dm);
int h_add = max(0, rnd * max(0, am - def) - hy + 1);
int a_add = max(0, atk - ay);
int d_add = max(0, def - dy);
res = min(res, h_add * h + a_add * a + d_add * d);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hp1, atk1, def1;
int hp2, atk2, def2;
int h, a, d;
struct E {
E(int hc, int ac, int dc) : hc(hc), ac(ac), dc(dc) {}
int cost() const { return hc * h + ac * a + dc * d; }
bool operator<(const E& o) const {
int c1 = cost();
int c2 = o.cost();
if (c1 != c2) {
return c1 < c2;
}
return make_pair(hc, make_pair(ac, dc)) <
make_pair(o.hc, make_pair(o.ac, o.dc));
}
int hc, ac, dc;
};
int solve(int hp2, int atk2, int def2) {
set<E> s;
s.insert(E(0, max(0, def1 - atk2 + 1), 0));
set<E> visited;
while (!s.empty()) {
auto e = *s.begin();
s.erase(s.begin());
visited.insert(e);
int h2 = hp2 + e.hc;
int a2 = atk2 + e.ac;
int d2 = def2 + e.dc;
int rm = (a2 - def1);
int tm = (hp1 + rm - 1) / rm;
if (rm && atk1 <= d2) {
return e.cost();
}
int ry = (atk1 - d2);
int ty = (h2 + ry - 1) / ry;
if (ty > tm) {
return e.cost();
}
int ar[3][3] = {{1, 0, 0}, {0, 1, 0}, {0, 0, 1}};
for (int i = 0; i < 3; ++i) {
E e1(e.hc + ar[i][0], e.ac + ar[i][1], e.dc + ar[i][2]);
if (!visited.count(e1)) {
s.insert(e1);
}
}
}
return false;
}
int main() {
cin >> hp2 >> atk2 >> def2;
cin >> hp1 >> atk1 >> def1;
cin >> h >> a >> d;
cout << solve(hp2, atk2, def2) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200;
typedef long long matrix[N][N];
const long long MOD = 1000000007;
const double EPS = 1e-8;
const double PI = 2 * acos(0);
const int maxn = 1e6 + 6;
int y[3], m[3], c[3];
bool check(int i, int j, int k) {
int dmp = max(0, j - m[2]);
int dfs = max(0, m[1] - k);
if (dmp == 0) return false;
if (dmp > 0 && dfs == 0) return true;
if (dmp == 0 && dfs == 0) return false;
int t1 = (m[0] / dmp) + (m[0] % dmp != 0);
int t2 = (i / dfs) + (i % dfs != 0);
if (t1 < t2)
return true;
else
return false;
}
int main() {
cin.sync_with_stdio(false);
cin >> y[0] >> y[1] >> y[2];
cin >> m[0] >> m[1] >> m[2];
cin >> c[0] >> c[1] >> c[2];
int ans = 1000000009;
for (int i = y[0]; i <= 1000; i++) {
for (int j = y[1]; j <= 200; j++) {
for (int k = y[2]; k <= 200; k++) {
if (check(i, j, k)) {
int cost = (i - y[0]) * c[0] + (j - y[1]) * c[1] + (k - y[2]) * c[2];
if (cost < ans) {
ans = cost;
}
}
}
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long H, A, D;
long long h, a, d;
long long mH, mA, mD;
int main() {
while (cin >> H >> A >> D >> h >> a >> d >> mH >> mA >> mD) {
long long ans = -1;
for (int i = max(0, (int)(d - A + 1)); i <= 20000; i++) {
for (int j = 0; j <= max(0, int(a - D)); j++) {
long long tans = i * mA + j * mD;
long long times = h / (A + i - d) + ((h % (A + i - d) == 0) ? 0 : 1);
long long myhp = times * (a - D - j) + 1;
if (myhp > H) {
tans += (myhp - H) * mH;
}
if (tans < ans || ans == -1) {
ans = tans;
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 20;
const int MN = 222;
bool win(int h, int a, int d, int H, int A, int D) {
if (h <= 0) return false;
if (H <= 0) return true;
int damy = max(0, a - D);
int damm = max(0, A - d);
if (damy == 0) return false;
int x = (H + damy - 1) / damy;
if (h - x * damm <= 0) return false;
return true;
}
int main() {
vector<int> a(3), b(3), c(3);
for (int i = 0; i < 3; ++i) cin >> a[i];
for (int i = 0; i < 3; ++i) cin >> b[i];
for (int i = 0; i < 3; ++i) cin >> c[i];
int ans = inf;
for (int i = 0; i < 1001; ++i) {
for (int j = 0; j < MN; ++j) {
for (int k = 0; k < MN; ++k) {
int h = a[0] + i;
int at = a[1] + j;
int de = a[2] + k;
if (win(h, at, de, b[0], b[1], b[2])) {
ans = min(ans, i * c[0] + j * c[1] + k * c[2]);
}
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int yhp, yatk, ydef, mhp, matk, mdef, hp, ap, dp;
bool willWin(int curyhp, int curyatk, int curydef) {
int curmhp = mhp, curmatk = matk, curmdef = mdef;
if (curyatk - curmdef <= 0) return false;
while (curmhp > 0) {
if (curyhp <= 0) return false;
curmhp = curmhp - max(0, curyatk - curmdef);
curyhp = curyhp - max(0, curmatk - curydef);
}
return curyhp > 0;
}
bool possible(int coin) {
int maxHp = coin / hp;
for (int h = 0; h <= maxHp; h++)
for (int a = 0; a <= ((coin - h * hp) / ap); a++) {
int d = (coin - h * hp - a * ap) / dp;
if (d < 0 || h < 0 || a < 0) continue;
if (willWin(yhp + h, yatk + a, ydef + d)) return true;
}
return false;
}
int main() {
cin >> yhp >> yatk >> ydef >> mhp >> matk >> mdef >> hp >> ap >> dp;
int lo = 0, hi = 1000000000;
while (lo < hi) {
int mid = (lo + hi) / 2;
if (possible(mid))
hi = mid;
else
lo = mid + 1;
}
cout << hi << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int hy, ay, dy, hm, am, dm, a, b, c, cst = 100000000000000;
void solve(long long int m, long long int n) {
if (m - dm <= 0) return;
long long int hr = 1;
long long int d = hm / (m - dm);
if (hm % (m - dm) != 0) d++;
hr += d * (am - n);
if (am - n <= 0) hr = max(hy, (long long int)1);
hr = max(hr, hy);
cst = min(a * (hr - hy) + b * (m - ay) + c * (n - dy), cst);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> hy >> ay >> dy;
cin >> hm >> am >> dm;
cin >> a >> b >> c;
for (int i = ay; i < 201; i++) {
for (int j = dy; j < 101; j++) {
solve(i, j);
}
}
cout << cst << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int u, int v) { return (v != 0) ? gcd(v, u % v) : u; }
int win(int hp1, int atk1, int def1, int hp2, int atk2, int def2) {
double f = max(0, atk1 - def2);
double s = max(0, atk2 - def1);
double s2 = ceil(hp2 / f);
double s1 = ceil(hp1 / s);
if (s1 > s2) return 0;
if (f == 0) return 1e9;
double NewHp = s2 * s;
return NewHp + 1 - hp1;
}
int main() {
int hp1, atk1, def1, hp2, atk2, def2;
long long a, b, c;
cin >> hp1 >> atk1 >> def1 >> hp2 >> atk2 >> def2;
cin >> a >> b >> c;
long long Min = 1e18;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 1000; j++) {
int k = win(hp1, atk1 + i, def1 + j, hp2, atk2, def2);
Min = min(Min, k * a + i * b + j * c);
}
}
cout << Min << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int x1, y1, z1;
int x2, y2, z2;
int h, a, d;
int ans = 9999999999;
cin >> x1 >> y1 >> z1 >> x2 >> y2 >> z2 >> h >> a >> d;
for (int i = y1; i <= y1 + 200; i++) {
for (int j = z1; j <= z1 + 200; j++) {
if (i <= z2) continue;
int tem = (x2 + i - z2 - 1) / (i - z2);
int tem2 = tem * max(0, y2 - j) + 1;
ans = min(ans, h * max(0, tem2 - x1) + a * (i - y1) + d * (j - z1));
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = (1LL << 60);
const int maxn = 3000;
long long hy, ay, dy;
long long hm, am, dm;
long long h, a, d;
int main() {
scanf("%lld%lld%lld%lld%lld%lld%lld%lld%lld", &hy, &ay, &dy, &hm, &am, &dm,
&h, &a, &d);
long long sol = inf;
for (int j = 0; j <= maxn; j++) {
for (int l = 0; l <= maxn; l++) {
if (ay + j - dm <= 0) continue;
int kol = (hm + ay + j - dm - 1) / (ay + j - dm);
long long i = max(0LL, kol * (am - dy - l) - hy + 1);
long long tren = i * h + j * a + l * d;
sol = min(sol, tren);
}
}
printf("%lld", sol);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
int Hy, Ay, Dy, Hm, Am, Dm, h, a, d, ans = 1 << 30;
cin >> Hy >> Ay >> Dy;
cin >> Hm >> Am >> Dm;
cin >> h >> a >> d;
for (int A = max(Ay, Dm + 1); A <= 200; A++)
for (int D = Dy; D <= 200; D++) {
int x = A - Dm, z;
int t = Hm / x + ((Hm % x) != 0);
int Hy_f = Hy - max(0, Am - D) * t;
if (Hy_f > 0)
z = (A - Ay) * a + (D - Dy) * d;
else
z = (A - Ay) * a + (D - Dy) * d + (-Hy_f + 1) * h;
ans = min(ans, z);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, x, n, flg = 0, s, att, tat, b, y, mx, cnt;
int a[3], h[3], d[3], p[3];
cin >> h[1] >> a[1] >> d[1] >> h[2] >> a[2] >> d[2] >> p[1] >> p[2] >> p[3];
mx = a[2] - d[1];
mx++;
if (mx < 0) mx = 0;
mx *= p[3];
att = a[1] - d[2];
if (att <= 0) {
att = 1;
mx += (d[2] - a[1] + 1) * p[2];
}
while (h[2] / att > 0 || !flg) {
s = h[2] / att;
if (h[2] % att != 0 && flg) {
att++;
continue;
}
if (h[2] % att != 0) s++;
if (h[2] / att == 0) {
s++;
flg = 1;
}
cnt = (att - a[1] + d[2]) * p[2];
tat = a[2] - d[1];
tat *= s;
tat -= h[1];
tat++;
if (tat < 0) tat = 0;
y = tat / s;
if (tat % s != 0) y++;
tat *= p[1];
y *= p[3];
cnt += min(tat, y);
if (mx > cnt) {
mx = cnt;
}
att++;
}
printf("%d", mx);
}
|
#include <bits/stdc++.h>
using namespace std;
int a[3][3];
int main(int argc, char const *argv[]) {
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) scanf("%d", &a[i][j]);
int m = 100000000;
for (int i = a[0][1]; i <= 200; i++)
if (i > a[1][2])
for (int j = a[0][2]; j <= 100; j++) {
int tmp = (i - a[0][1]) * a[2][1] + (j - a[0][2]) * a[2][2];
int d1 = i - a[1][2], d2 = a[1][1] - j;
if (d2 > 0 && (a[0][0] + d2 - 1) / d2 <= (a[1][0] + d1 - 1) / d1) {
int x = (a[1][0] + d1 - 1) / d1;
tmp = tmp + a[2][0] * (x * d2 + 1 - a[0][0]);
}
m = min(tmp, m);
}
printf("%d\n", m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sol = 1000000000;
int h;
void prueba(int hy, int hm, int dechy, int dechm, int gasto) {
for (;;) {
hy -= dechy;
hm -= dechm;
if (hy <= 0) {
gasto += h * (-hy + 1);
hy = 1;
}
if (hm <= 0) {
sol = min(sol, gasto);
return;
}
}
}
int hy, ay, dy, hm, am, dm, a, d;
int main() {
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
for (int adday = 0; adday <= 300; adday++)
if (ay + adday - dm >= 1)
for (int adddy = 0; adddy <= 300; adddy++)
prueba(hy, hm, max(0, am - dy - adddy), ay + adday - dm,
adday * a + adddy * d);
cout << sol << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cost_hp, cost_atk, cost_def, monster_hp, monster_atk, monster_def;
bool wins(int hp, int atk, int def) {
int hp_lost = monster_atk - def, monster_hp_lost = atk - monster_def;
if (monster_hp_lost <= 0) return false;
int n = monster_hp / monster_hp_lost + (monster_hp % monster_hp_lost != 0);
if (hp_lost <= 0) return n > 0;
int m = hp / hp_lost + (hp % hp_lost != 0);
return n < m;
}
int main(void) {
int hp, atk, def;
scanf("%d %d %d", &hp, &atk, &def);
scanf("%d %d %d", &monster_hp, &monster_atk, &monster_def);
scanf("%d %d %d", &cost_hp, &cost_atk, &cost_def);
int ans = 0x2f2f2f2f;
for (int i = hp; i <= 1000; ++i) {
for (int j = atk; j <= 200; ++j) {
for (int k = def; k <= 100; ++k) {
if (wins(i, j, k)) {
ans = min(ans, (i - hp) * cost_hp + (j - atk) * cost_atk +
(k - def) * cost_def);
}
}
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const unsigned long long INF = 2e15L;
unsigned long long hb, ab, db;
unsigned long long hm, am, dm;
unsigned long long ch, ca, cd;
inline unsigned long long win(const unsigned long long& h,
const unsigned long long& a,
const unsigned long long& d) {
if (d >= am) return 1;
return (hm + a - dm - 1) / (a - dm) < (h + am - d - 1) / (am - d);
}
unsigned long long ans;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
;
cin >> hb >> ab >> db;
cin >> hm >> am >> dm;
cin >> ch >> ca >> cd;
ans = INF;
for (unsigned long long(a) = (max(ab, dm + 1)); (a) < (220); (a)++)
for (unsigned long long(d) = (db); (d) < (110); (d)++) {
unsigned long long lo;
if (am >= d)
lo = am - d;
else
lo = 0;
lo = max(lo, hb - 1);
unsigned long long hi = 1100000;
unsigned long long mid;
while (lo + 1 < hi) {
mid = (hi + lo) / 2;
if (win(mid, a, d)) {
hi = mid;
} else {
lo = mid;
}
}
ans = min(ans, ca * (a - ab) + cd * (d - db) + ch * (hi - hb));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int yang[3], monster[3], price[3];
bool simulate(int hp, int atk, int def) {
int dmg_given = max(0, atk - monster[2]);
int dmg_taken = max(0, monster[1] - def);
int hp_monst = monster[0];
while (hp_monst > 0) {
hp -= dmg_taken;
hp_monst -= dmg_given;
}
if (hp > 0) return true;
return false;
}
int main() {
for (int i = 0; i < 3; i++) cin >> yang[i];
for (int i = 0; i < 3; i++) cin >> monster[i];
for (int i = 0; i < 3; i++) cin >> price[i];
int atk_buffer = max(-1, monster[2] - yang[1]);
int def_limit = max(0, monster[1] - yang[2]);
int res = 1000000000;
for (int atk = atk_buffer + 1; atk <= monster[2] + 100; atk++) {
for (int def = 0; def <= def_limit; def++) {
int cost = atk * price[1] + def * price[2];
if (cost >= res) continue;
int low = yang[0];
int high = 1000000000;
while (abs(high - low) > 1) {
int avg = (high + low) / 2;
if (simulate(avg, yang[1] + atk, yang[2] + def))
high = avg;
else
low = avg;
}
int hp_req;
if (simulate(low, yang[1] + atk, yang[2] + def))
hp_req = low;
else
hp_req = high;
cost += (hp_req - yang[0]) * price[0];
res = min(res, cost);
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int h1, a1, d1, h2, a2, d2, h, a, d;
cin >> h1 >> a1 >> d1 >> h2 >> a2 >> d2 >> h >> a >> d;
long long c = 1e18;
if (d1 >= a2) {
if (a1 > d2)
cout << 0 << '\n';
else {
long long x = (d2 - a1 + 1) * a;
cout << x << '\n';
}
} else {
int j = 0, k;
if (a1 <= d2) j = d2 - a1 + 1;
if (h2 < a1 - d2) {
if (h1 > a2 - d1)
c = 0;
else {
long long f = (a2 - d1 - h1 + 1) * h;
long long e = (a2 - d1 + 1) * d;
c = min(c, f);
c = min(c, e);
}
} else {
for (; j <= h2 - a1 + d2; j++) {
double x = ceil(h2 * 1.0 / (a1 + j - d2));
for (k = 0; k <= a2 - d1; k++) {
long long y = h1 - x * (a2 - d1 - k);
if (y > 0) {
long long z;
z = a * j + d * k;
c = min(c, z);
} else {
y = 1 + (-1) * y;
long long z;
z = h * y + a * j + d * k;
c = min(c, z);
}
}
}
}
cout << c << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int data[3][3];
int td[3];
int win() {
int aY = max(0, td[1] - data[1][2]);
int aM = max(0, data[1][1] - td[2]);
if (aY == 0) return -1;
int bY = (data[1][0] / aY + (data[1][0] % aY != 0 ? 1 : 0));
if (aM == 0) return bY;
int bM = (td[0] / aM + (td[0] % aM != 0 ? 1 : 0));
if (bM <= bY) return -1;
return bY;
}
int main() {
ios_base::sync_with_stdio(false);
for (int i = 0; i < 3; i++)
for (int j = 0; j < 3; j++) cin >> data[i][j];
int minres = 1e9;
for (int i = 0; i < 10000; i++) {
td[0] = data[0][0] + i;
int r1 = i * data[2][0];
for (int j = 0; j < 200; j++) {
td[1] = data[0][1] + j;
int r2 = j * data[2][1];
for (int k = 0; k < 100; k++) {
td[2] = data[0][2] + k;
int r3 = k * data[2][2];
int res = r1 + r2 + r3;
if (win() != -1) {
if (res < minres) minres = res;
break;
}
}
}
}
cout << minres << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int max1 = -1;
int game(int a, int b, int c, int p, int q, int r) {
if (q <= c) return 0;
if (r >= b && q > c) return 1;
while (1) {
a = a - max(0, q - c);
p = p - max(0, b - r);
if (a <= 0 && p > 0) return 1;
if (p <= 0) return 0;
}
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
int i, j, k, a, b, c, p, q, r, d, e, f;
cin >> p >> q >> r;
cin >> a >> b >> c;
cin >> d >> e >> f;
int mincost = INT_MAX, cost;
for (i = 0; i <= 1000; i++) {
for (j = 0; j <= 1000; j++) {
int it = 0;
int mid, k, start = 0, end = 1000, flag = 0;
while (it < 20) {
mid = (start + end) / 2;
if (game(a, b, c, p + i, q + j, r + mid))
end = mid;
else
start = mid + 1;
it++;
}
for (k = start; k <= end; k++)
if (game(a, b, c, p + i, q + j, r + k)) {
flag = 1;
break;
}
if (flag) {
cost = i * d + j * e + k * f;
if (cost < mincost) mincost = cost;
}
}
}
cout << mincost << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int hy, ay, dy, hm, am, dm, h, a, d;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
int y, m, mn = 1e5;
for (int i(0); i < 201; ++i) {
if ((ay + i - dm) <= 0) continue;
for (int j(0); j < 201; ++j) {
y = hy;
m = hm;
while (m > 0) {
m -= max(0, ay + i - dm);
y -= max(0, am - dy - j);
}
if (y > 0)
mn = min(mn, i * a + j * d);
else
mn = min(mn, i * a + j * d - y * h + h);
}
}
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int hp[2], att[2], def[2];
inline bool Win(int x, int y, int z) {
x += hp[0];
y += att[0];
z += def[0];
int sub1 = y - def[1];
int sub2 = att[1] - z;
if (sub2 <= 0) return 1;
int a = (x + sub2 - 1) / sub2, b = (hp[1] + sub1 - 1) / sub1;
return a > b;
}
int main() {
for (int i = 0; i < 2; ++i) scanf("%d%d%d", hp + i, att + i, def + i);
int h, a, d;
scanf("%d%d%d", &h, &a, &d);
int ans1 = 0, ans2 = 0x3f3f3f3f;
if (att[0] <= def[1]) {
ans1 += (def[1] - att[0] + 1) * a;
att[0] = def[1] + 1;
}
int hpmax = 0, attmax = 0, defmax = 0;
for (int i = 0;; ++i)
if (Win(i, 0, 0)) {
hpmax = i;
break;
}
attmax = max(0, def[1] + hp[1] - att[0]);
defmax = max(0, att[1] - def[0]);
for (int i = 0; i <= hpmax; ++i)
for (int j = 0; j <= attmax; ++j)
for (int k = 0; k <= defmax; ++k)
if (Win(i, j, k)) ans2 = min(ans2, i * h + j * a + k * d);
printf("%d\n", ans1 + ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct s {
unsigned h, a, d;
};
bool y_wins(s y, s m) {
int decrease_m = y.a - m.d;
int decrease_y = m.a - y.d;
unsigned t_m;
if (decrease_m <= 0)
t_m = UINT_MAX;
else
t_m = (m.h + decrease_m - 1) / decrease_m;
unsigned t_y;
if (decrease_y <= 0)
t_y = UINT_MAX;
else
t_y = (y.h + decrease_y - 1) / decrease_y;
return t_y > t_m;
}
int main(void) {
s y, m;
unsigned h, a, d;
scanf("%u %u %u\n", &y.h, &y.a, &y.d);
scanf("%u %u %u\n", &m.h, &m.a, &m.d);
scanf("%u %u %u\n", &h, &a, &d);
unsigned best_cost = UINT_MAX;
for (unsigned j = 0; j <= 1000; ++j) {
int decrease_m = y.a + j - m.d;
if (decrease_m <= 0) continue;
for (unsigned i = 0; i <= 1000; ++i) {
for (unsigned k = 0; k <= 1000; ++k) {
unsigned cost = i * h + j * a + k * d;
if (best_cost <= cost) continue;
if (y_wins({y.h + i, y.a + j, y.d + k}, m)) {
best_cost = cost;
}
}
}
}
printf("%u", best_cost);
}
|
#include <bits/stdc++.h>
using namespace std;
int hm, am, dm, hn, an, dn, h, a, d, mn = 1e8;
int main() {
cin >> hm >> am >> dm >> hn >> an >> dn;
cin >> h >> a >> d;
for (int y = 0; y <= 200; y++) {
for (int z = 0; z <= 200; z++) {
int dem = max(0, an - (dm + z));
int den = max(0, am + y - dn);
if (den == 0) continue;
int t = (hn + den - 1) / den;
int rem = 1 - (hm - (t * dem));
if (rem < 0) rem = 0;
mn = min(mn, rem * h + y * a + z * d);
}
}
cout << mn << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int nmax = 1000;
int main() {
long long HPy, DEFy, ATKy, HPm, DEFm, ATKm, h, a, d, ty, tm, x, x1, x2, xodm,
xody, m, xxx = 0, minimum = 9999999999;
cin >> HPy >> ATKy >> DEFy >> HPm >> ATKm >> DEFm;
long long tHPy, tDEFy, tATKy, tHPm, tDEFm, tATKm;
cin >> h >> a >> d;
x = 0;
ty = max(x, ATKm - DEFy);
tm = max(x, ATKy - DEFm);
if (DEFy < ATKm) {
xxx = ATKm - DEFy;
}
if (ty == 0)
xody = 9999999;
else {
xody = HPy / ty;
if (HPy % ty > 0) xody++;
if (HPy <= ty) xody = 0;
}
if (tm == 0)
xodm = 9999999;
else {
xodm = HPm / tm;
if (HPm % tm > 0) xodm++;
if (HPm <= tm) xodm = 0;
}
if ((xody > xodm) || ((xody > 0) && (xodm < 1))) {
cout << "0";
return 0;
}
long long temp = 0, ans = 0;
for (int i = 0; i <= 1000; i++) {
tHPy = HPy + i;
for (int j = 0; j <= xxx; j++) {
tDEFy = DEFy + j;
for (int z = 0; z <= 200; z++) {
tATKy = ATKy + z;
temp = i * h + z * a + j * d;
ty = max(x, ATKm - tDEFy);
tm = max(x, tATKy - DEFm);
if (ty == 0)
xody = 9999999;
else {
xody = tHPy / ty;
if (tHPy % ty > 0) xody++;
if (tHPy <= ty) xody = 0;
}
if (tm == 0)
xodm = 9999999;
else {
xodm = HPm / tm;
if (HPm % tm > 0) xodm++;
if (HPm <= tm) xodm = 0;
}
if ((xody > xodm) || ((xody > 0) && (xodm < 1))) {
if (temp < minimum) {
minimum = temp;
}
}
}
}
}
cout << minimum;
cin >> a;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1 << 30;
int h, a, d;
bool can(int hpy, int atky, int defy, int hpm, int atkm, int defm) {
int x = max(0, atky - defm);
int y = max(0, atkm - defy);
if (x == 0) return false;
int z = hpm / x;
if (hpm % x != 0) z++;
if (hpy - y * z <= 0) return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int hpy, atky, defy;
int hpm, atkm, defm;
cin >> hpy >> atky >> defy;
cin >> hpm >> atkm >> defm;
cin >> h >> a >> d;
int res = inf;
for (int i = 0; i <= 1000; i++) {
for (int j = 0; j <= 200; j++) {
for (int k = 0; k <= 200; k++) {
if (can(hpy + i, atky + j, defy + k, hpm, atkm, defm)) {
res = min(res, i * h + j * a + k * d);
break;
}
}
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int h[3], a[3], d[3], k, x, y, i;
int main() {
for (; x < 3; x++) cin >> h[x] >> a[x] >> d[x];
k = 1e9;
for (; i <= 10001; i++)
for (int j = 0; j <= 100; j++) {
x = a[1] - d[0] - j, y = h[0] + i;
if (y <= x) continue;
k = min(
k,
i * h[2] + j * d[2] +
a[2] * max(0, (x <= 0 ? d[1] + 1
: (int)ceil(1.0 * h[1] /
((int)y / x - (y % x == 0))) +
d[1]) -
a[0]));
}
cout << k << endl;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:256000000")
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int HPy, APy, DEFy;
cin >> HPy >> APy >> DEFy;
int HPm, APm, DEFm;
cin >> HPm >> APm >> DEFm;
int h, a, d;
cin >> h >> a >> d;
int ans = 100000000;
for (int Dmg = 1; Dmg <= 100; Dmg++) {
if (APy - DEFm > Dmg) continue;
int count = (Dmg - (APy - DEFm)) * a;
int num = (HPm + Dmg - 1) / Dmg;
for (int Def = DEFy;; Def++) {
int MonsterDmg = APm - Def;
int value = count + (Def - DEFy) * d;
if (MonsterDmg > 0) {
int NeedHp = num * MonsterDmg + 1;
value += max(0, (NeedHp - HPy) * h);
}
if (value < ans) ans = value;
if (MonsterDmg <= 0) break;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
void Solve();
int main() { Solve(); }
using namespace std;
const int INF = 1e9;
const int N = 20;
const double e = 1E-10;
int hm, am, dm;
int check(int ay, int dy) {
int m = max(0, ay - dm), y = max(0, am - dy);
if (!m) return -1;
return (hm / m + (hm % m != 0)) * y + 1;
}
void Solve() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int hy, ay, dy, h, a, d, mn = 1e9;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
int hp = check(ay + i, dy + j);
if (hp == -1) continue;
mn = min(mn, max(0, hp - hy) * h + i * a + j * d);
}
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 20, maxm = 20;
long long mod = 1e9 + 7;
int dp[maxn], x[maxm], y[maxm], c[maxn][maxm], d[maxm][maxm];
int inf = 1e9;
int n, D;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int hy, ay, dy, hm, am, dm, h, a, d;
cin >> hy >> ay >> dy >> hm >> am >> dm >> h >> a >> d;
int mn = inf;
for (int i = ay; i <= 200; i++)
for (int j = dy; j <= 100; j++)
if (i > dm) {
int tedad = (hm + i - dm - 1) / (i - dm);
int x1 = (max((am - j) * tedad + 1, hy) - hy) * h;
int x2 = (i - ay) * a;
int x3 = (j - dy) * d;
mn = min(mn, x1 + x2 + x3);
}
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Creature {
int hp, atk, def;
};
Creature Yan, monster, upgrades;
int mat[200][200];
int hpNeeded(int atk, int def) {
int lossHpM = max(0, (Yan.atk + atk) - monster.def);
int lossHpY = max(0, monster.atk - (Yan.def + def));
if (!lossHpM) return 1000000;
int roundsM = monster.hp / lossHpM;
if (monster.hp % lossHpM) roundsM++;
int roundsY, ret = 0;
if (!lossHpY) {
ret = 0;
} else {
roundsY = Yan.hp / lossHpY;
if (roundsY > roundsM) {
ret = 0;
} else if (roundsY == roundsM) {
if (!(Yan.hp % lossHpY)) {
ret = 1;
}
} else {
ret = lossHpY * (roundsM - roundsY);
ret += -Yan.hp % lossHpY + 1;
}
}
return ret;
}
int solve(int atk, int def) {
if (atk >= 200 || def >= 200) return 1000000;
if (mat[atk][def] != -1) return mat[atk][def];
int hp = hpNeeded(atk, def);
mat[atk][def] = atk * upgrades.atk + def * upgrades.def + hp * upgrades.hp;
int temp = 1000000;
if (hp) temp = min(solve(atk + 1, def), solve(atk, def + 1));
mat[atk][def] = min(mat[atk][def], temp);
return mat[atk][def];
}
int main() {
while (cin >> Yan.hp >> Yan.atk >> Yan.def) {
memset(mat, -1, sizeof(mat));
cin >> monster.hp >> monster.atk >> monster.def;
cin >> upgrades.hp >> upgrades.atk >> upgrades.def;
cout << solve(0, 0) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long pow(long long a, long long b, long long p) {
long long sum = 1;
for (a %= p; b; a = a * a % p, b >>= 1)
if (b & 1) sum = sum * a % p;
return sum;
}
long long phi(long long n) {
long long i, re = n;
for (i = 2; i * i <= n; i++)
if (n % i == 0) {
re = re / i * (i - 1);
while (n % i == 0) n /= i;
}
if (n > 1) re = re / n * (n - 1);
return re % 1000000007;
}
void exgcd(long long a, long long b, long long &x, long long &y) {
if (!b) {
x = 1;
y = 0;
return;
}
exgcd(b, a % b, y, x);
y -= x * (a / b);
}
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
int main() {
int a, b, h, a1, a2, b1, b2, h1, h2;
scanf("%d%d%d%d%d%d%d%d%d", &h1, &a1, &b1, &h2, &a2, &b2, &h, &a, &b);
int ans = 1e9;
for (int i = 0; i <= 200; i++) {
for (int j = 0; j <= 200; j++) {
if (a1 + j <= b2) continue;
int gong = a1 + j - b2;
int fang = max(0, a2 - b1 - i);
int x = (h2 + gong - 1) / gong;
int sum = max(0, fang * x + 1 - h1);
ans = min(ans, sum * h + i * b + j * a);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 1e9 + 7;
int a, b, c, hp1, ac1, of1, hp2, ac2, of2;
bool check(int hp, int ac, int of) {
if (ac - of2 <= 0) return false;
if (ac2 - of <= 0) return true;
if (ceil((double)hp / (ac2 - of)) > ceil((double)hp2 / (ac - of2)))
return true;
return false;
}
int main() {
while (cin >> hp1 >> ac1 >> of1 >> hp2 >> ac2 >> of2 >> a >> b >> c) {
int ans = inf;
if (of1 >= ac2) {
if (ac1 > of2)
cout << '0' << endl;
else
cout << (of2 + 1 - ac1) * b << endl;
break;
}
for (int i = max(ac1, of2 + 1); i <= 201; ++i) {
for (int j = of1; j <= ac2 + 1; ++j) {
for (int k = hp1;; ++k) {
if (check(k, i, j)) {
ans = min(ans, (k - hp1) * a + (i - ac1) * b + (j - of1) * c);
break;
}
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
int h1, a1, d1;
int h2, a2, d2;
int h, a, d;
int solve(int da, int dd) {
int ret = a * da + d * dd;
int h1 = ::h1, a1 = ::a1 + da, d1 = ::d1 + dd;
int h2 = ::h2, a2 = ::a2, d2 = ::d2;
if (a1 <= d2) return 0x3f3f3f3f;
if (a2 <= d1) return ret;
while (h2 > 0) {
h2 -= a1 - d2;
h1 -= a2 - d1;
}
if (h1 <= 0) {
ret += (1 - h1) * h;
}
return ret;
}
int main() {
scanf("%d%d%d", &h1, &a1, &d1);
scanf("%d%d%d", &h2, &a2, &d2);
scanf("%d%d%d", &h, &a, &d);
int ans = 0x3f3f3f3f;
for (int da = 0; da <= 201; da++) {
for (int dd = 0; dd <= 201; dd++) {
ans = std::min(ans, solve(da, dd));
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[] = {1, 0, -1, 0};
int dy[] = {0, 1, 0, -1};
const int N = (int)2e4 + 7;
const int MOD = (int)1e9 + 7;
const int INF = (int)2e7;
const long long BIG = 1e18;
bool who_win(int hpf, int atkf, int deff, int hps, int atks, int defs) {
if (hps <= 0 && hpf > 0) return true;
int mf = max(0, atkf - defs);
int ms = max(0, atks - deff);
if (mf == 0 && ms == 0) return false;
int l = 0, r = N, ans = INF;
while (l <= r) {
int m = (r + l) >> 1;
if (hps - mf * m <= 0 || hpf - ms * m <= 0) {
ans = m;
r = m - 1;
} else {
l = m + 1;
}
}
hps -= mf * ans, hpf -= ms * ans;
if (hps <= 0 && hpf > 0)
return true;
else
return false;
}
int main() {
ios_base::sync_with_stdio(0), cin.tie(0), cout.tie(0);
;
int ans = INF;
int hf, af, df, hs, as, ds;
int vv, ww, xx;
cin >> hf >> af >> df >> hs >> as >> ds;
cin >> vv >> ww >> xx;
for (int new_atk = af; new_atk <= max(ds + hs, af); new_atk++) {
for (int new_def = df; new_def <= max(as, df); new_def++) {
int l = 0, r = N, tp = INF;
while (l <= r) {
int m = (r + l) >> 1;
if (who_win(hf + m, new_atk, new_def, hs, as, ds)) {
tp = m;
r = m - 1;
} else {
l = m + 1;
}
}
ans = min(ans, (new_atk - af) * ww + (new_def - df) * xx + tp * vv);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int memo[1001][201][101];
int mhp, matk, mdef;
int yhp, yatk, ydef;
int hpp, atkp, defp;
int win(int hp, int atk, int def) {
int res;
atk -= mdef;
if (atk > 0) {
int k = mhp / atk;
if (mhp % atk) k++;
int dmg = k * (matk - def);
if (dmg < hp)
res = 0;
else
res = k;
} else
res = 1000000;
return res;
}
int solve(int hp, int atk, int def, int s) {
if (atk == 201 || def == 101 || hp == 1001) return 100000000;
if (memo[hp][atk][def] != -1)
return memo[hp][atk][def];
else {
int tmp = win(hp, atk, def);
if (!tmp) {
memo[hp][atk][def] = s;
return s;
} else {
if (tmp == 1000000) {
int res = solve(hp, atk + 1, def, s + atkp);
memo[hp][atk][def] = res;
return res;
} else {
int res = min(min(solve(hp + 1, atk, def, s + hpp),
solve(hp, atk + 1, def, s + atkp)),
solve(hp, atk, def + 1, s + defp));
memo[hp][atk][def] = res;
return res;
}
}
}
}
int main() {
memset(memo, -1, 4 * 1001 * 201 * 101);
cin >> yhp >> yatk >> ydef;
cin >> mhp >> matk >> mdef;
cin >> hpp >> atkp >> defp;
cout << solve(yhp, yatk, ydef, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int mHP, mATK, mDEF;
int yHP, yATK, yDEF;
int h, a, d;
int m_hp, y_hp, cost, times, y_hp_need, ans = 2147483647;
scanf("%d %d %d", &yHP, &yATK, &yDEF);
scanf("%d %d %d", &mHP, &mATK, &mDEF);
scanf("%d %d %d", &h, &a, &d);
for (int i = max(yATK, mDEF + 1); i <= 200; i++) {
for (int j = yDEF; j <= 200; j++) {
m_hp = i - mDEF;
y_hp = mATK - j;
times = ceil(mHP * 1.0 / m_hp);
y_hp_need = times * y_hp;
cost = max(y_hp_need - yHP + 1, 0) * h + (i - yATK) * a + (j - yDEF) * d;
ans = min(ans, cost);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
struct unit_t {
int hp;
int atk;
int def;
};
int main() {
cin.tie(0);
ios::sync_with_stdio(0);
unit_t yang, monster, cost;
cin >> yang.hp >> yang.atk >> yang.def;
cin >> monster.hp >> monster.atk >> monster.def;
cin >> cost.hp >> cost.atk >> cost.def;
int atk, def;
int answer = numeric_limits<int>::max();
unit_t purchase;
for (atk = 0; yang.atk + atk <= 200; atk++) {
int damage_given = max(0, yang.atk + atk - monster.def);
if (damage_given == 0) {
continue;
}
for (def = 0; yang.def + def <= 100; def++) {
int damage_taken = max(0, monster.atk - yang.def - def);
int hp = max(0, ((monster.hp - 1) / damage_given + 1) * damage_taken + 1 -
yang.hp);
int candidate = cost.hp * hp + cost.atk * atk + cost.def * def;
if (candidate < answer) {
answer = candidate;
purchase.hp = hp;
purchase.atk = atk;
purchase.def = def;
}
}
}
cerr << purchase.hp << ' ' << purchase.atk << ' ' << purchase.def << endl;
cout << answer << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int h1, a1, d1;
int h2, a2, d2;
int h, a, d;
int main() {
cin >> h1 >> a1 >> d1;
cin >> h2 >> a2 >> d2;
cin >> h >> a >> d;
int mn = 1 << 30;
for (int j = 0; j <= 200; ++j)
for (int k = 0; k <= 200; ++k) {
int l = 0, r = 10000000, i;
int I = 10000000;
while (l <= r) {
i = (l + r) / 2;
int mdec = max(0, a1 + j - d2);
int ydec = max(0, a2 - (d1 + k));
int yh = h1 + i;
int t2 = 1 << 30;
if (mdec) t2 = (h2 + mdec - 1) / mdec;
int t1 = 1 << 29;
if (ydec) t1 = (yh - 1) / ydec;
if (t1 >= t2) {
r = i - 1;
I = i;
} else
l = i + 1;
}
if (I * h + j * a + k * d >= mn) continue;
mn = I * h + j * a + k * d;
}
printf("%d\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct less_way {
bool operator()(const pair<uint32_t, uint32_t>& p1,
const pair<uint32_t, uint32_t>& p2) {
return p1.first < p2.first ||
(p1.first == p2.first && p1.second > p2.second);
}
};
int32_t h_y, h_m, h_c;
int32_t a_y, a_m, a_c;
int32_t d_y, d_m, d_c;
bool check(int32_t h_y, int32_t a_y, int32_t d_y) {
int32_t dd_y = max(0, a_y - d_m);
if (!dd_y) {
return false;
}
int32_t dd_m = max(0, a_m - d_y);
int32_t t = h_m / dd_y + (h_m % dd_y ? 1 : 0);
return h_y > dd_m * t;
}
int main() {
cin >> h_y >> a_y >> d_y;
cin >> h_m >> a_m >> d_m;
cin >> h_c >> a_c >> d_c;
uint32_t max_t = 100000;
uint32_t min_c = -1;
for (uint32_t h = 0; h <= max_t; h++) {
uint32_t c = h * h_c;
if (c >= min_c) {
break;
}
for (uint32_t a = 0; a <= max_t; a++) {
uint32_t tc = c + a * a_c;
if (tc >= min_c) {
break;
}
for (uint32_t d = 0; d <= max_t; d++) {
uint32_t ttc = tc + d * d_c;
if (ttc >= min_c) {
break;
}
if (check(h_y + h, a_y + a, d_y + d)) {
min_c = ttc;
}
}
}
}
cout << min_c;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int wh, wa, wd, mh, ma, md, ch, ca, cd;
cin >> wh >> wa >> wd;
cin >> mh >> ma >> md;
cin >> ch >> ca >> cd;
int cost = 1000000000;
for (int da = 0; da <= 200; ++da) {
for (int dd = 0; dd <= 200; ++dd) {
if (wa + da - md <= 0) continue;
int t = (mh - 1) / (wa + da - md) + 1;
int dh = max(0, t * (ma - wd - dd) - wh + 1);
cost = min(cost, ca * da + cd * dd + ch * dh);
}
}
cout << cost << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.