text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1);
const long long MODPRIMA = (long long)1e9 + 7;
const long long MAXX = (long long)1e18;
const long long MINN = -(long long)1e18;
const double EPS = -1e9;
long long N, K, M;
long long ans, sum;
long long arr[50];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cin >> N >> K >> M;
for (int i = 0; i < K; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + K);
if (N * sum <= M)
cout << N * (K + 1) << '\n';
else {
long long bagi = (M / sum);
long long ans = 0;
for (int i = 0; i <= bagi; i++) {
long long sisa = M - (sum * i);
long long point = i * (K + 1);
for (int j = 0; j < K; j++) {
if (sisa >= arr[j] * (N - i)) {
sisa -= (arr[j] * (N - i));
point += (N - i);
} else {
long long bag = sisa / (arr[j]);
point += bag;
sisa -= (bag * arr[j]);
}
}
ans = max(ans, point);
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[100];
int main() {
int n, m, t, sum, ans;
while (~scanf("%d %d %d", &n, &m, &t)) {
sum = 0;
ans = 0;
for (int k = 1; k <= m; k++) {
scanf("%d", &a[k]);
sum += a[k];
}
sort(a + 1, a + m + 1);
for (int k = 0; k <= n; k++) {
int tt = t, save(0);
if (tt < k * sum) break;
tt -= k * sum;
save += (m + 1) * k;
for (int j = 1; j <= m; j++) {
tt -= a[j] * (n - k);
if (tt >= 0)
save += n - k;
else {
tt += a[j] * (n - k);
save += (tt / a[j]);
break;
}
}
ans = max(ans, save);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool rev(long long x, long long y) { return x > y; }
void input_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cin >> a[i];
}
void print_vec(vector<long long> &v) {
for (auto i : v) cout << i << " ";
cout << endl;
}
void print_arr(long long a[], long long n) {
for (long long i = 0; i < n; i += 1) cout << a[i] << " ";
cout << endl;
}
bool sortbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return a.second < b.second;
}
bool sortinrev(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.first > b.first);
}
bool sortinrevbysec(const pair<long long, long long> &a,
const pair<long long, long long> &b) {
return (a.second > b.second);
}
template <typename... T>
void input(T &...args) {
((cin >> args), ...);
}
template <typename... T>
void print(T &&...args) {
((cout << args << endl), ...);
}
template <typename... T>
void deb(T &&...args) {
cout << "~~ ";
((cout << args << " "), ...);
cout << endl;
}
void stand8th() {
long long n, k, m;
input(n, k, m);
long long a[k];
input_arr(a, k);
sort(a, a + k);
long long ans1 = 0;
long long ans2 = 0;
long long summ = 0;
for (long long i = 0; i < k; i += 1) summ += a[i];
long long x = m % (summ * n);
ans1 += (m / (n * summ)) * (k * n + n);
ans1 += (x / summ) * (k + 1);
long long y = n - x / summ;
long long ans3 = ans1;
x = x % summ;
long long temp = x;
for (long long i = 0; i < k; i += 1) {
if (x >= a[i]) {
x -= a[i];
ans1 += 1;
} else {
break;
}
}
long long b[k];
long long sum1 = 0;
for (long long i = 0; i < k; i += 1) {
b[i] = a[i] * n;
sum1 += b[i];
}
x = temp;
long long c[k];
long long ans4 = -1;
for (long long y = 0; y < n + 1; y += 1) {
x = m - y * (summ);
if (x < 0) break;
long long ans3 = y * (k + 1);
for (long long i = 0; i < k; i += 1) {
c[i] = a[i] * (n - y);
}
for (long long i = 0; i < k; i += 1) {
if (x >= c[i]) {
x -= c[i];
if (i == k - 1) {
ans3 += (n - y);
}
ans3 += (n - y);
} else {
ans3 += x / a[i];
if (i == k - 1) {
ans3 += x / a[i];
}
break;
}
}
ans4 = max(ans4, ans3);
}
ans2 += (m / sum1) * (k * n + n);
x = m % sum1;
for (long long i = 0; i < k; i += 1) {
if (x >= b[i]) {
x -= b[i];
if (i == k - 1) {
ans2 += n;
}
ans2 += n;
} else {
ans2 += x / a[i];
if (i == k - 1) {
ans2 += x / a[i];
}
break;
}
}
print(min(max(max(ans1, ans2), max(ans3, ans4)), n * k + n));
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long tin = 1;
while (tin--) {
stand8th();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 1000;
const long long INF64 = 1e18 + 1000;
const int N = 5000;
const int M = 1000;
const int MOD = 998244353;
const double EPS = 1e-9;
long long gcd(long long a, long long b) { return a == 0 ? b : gcd(b % a, a); }
int line[N];
int k1[N], k2[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, m;
cin >> n >> k >> m;
vector<int> t(k);
long long sum = 0;
for (int i = 0; i < int(k); ++i) {
cin >> t[i];
sum += t[i];
}
int mx = 0;
for (int i = 0; i < int(n + 1); ++i) {
long long tm = sum * i;
if (tm > m) break;
int r = m - tm;
int k0 = k * i + i;
vector<pair<int, int> > task;
for (int j = int(i); j < int(n); ++j) {
for (int p = 0; p < int(k); ++p) {
task.push_back({t[p], p});
}
}
sort(task.begin(), task.end());
vector<int> pl(k);
for (int j = 0; j < task.size() && r - task[j].first >= 0; j++) {
pl[task[j].second]++;
r -= task[j].first;
k0++;
}
int z = pl[0];
for (int j = 0; j < int(k); ++j) {
z = min(z, pl[j]);
}
k0 += z;
mx = max(mx, k0);
}
cout << mx << '\n';
}
|
#include <bits/stdc++.h>
const int maxn = 50;
using namespace std;
long long n, k, M;
int a[maxn + 5], b[maxn * maxn];
void ok() {
long long ans = 0, cot = 0, tot = 0, cnt = 0, sum = 0;
sort(a + 1, a + k + 1);
for (int i = 1; i <= k; i++) cot += a[i];
for (int i = 0; i <= n; i++) {
tot = cot * i;
if (tot > M) break;
sum = tot, cnt = (k + 1) * i;
for (int j = 1; j <= k; j++) {
for (int r = i + 1; r <= n; r++) {
sum += a[j];
cnt++;
if (sum > M) {
cnt--, j = k + 1;
break;
}
}
}
ans = max(ans, cnt);
}
printf("%I64d\n", ans);
}
int main() {
while (~scanf("%I64d %I64d %I64d", &n, &k, &M)) {
for (int i = 1; i <= k; i++) scanf("%d", &a[i]);
ok();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long const mod = 1e9 + 7;
long long power(long long x, long long y, long long mod = 2e18) {
long long ans = 1;
x %= mod;
while (y) {
if (y & 1) ans = (x * ans) % mod;
x = (x * x) % mod;
y >>= 1;
}
return ans;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
long long n, k, m;
long long a[46];
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> k >> m;
for (long long i = 0; i < k; i++) {
cin >> a[i];
}
sort(a, a + k);
long long ans = 0, sum = 0;
for (long long i = 0; i < k; i++) {
sum += a[i];
}
for (long long i = 0; i <= n; i++) {
long long t = sum * i;
if (t > m) {
break;
} else {
long long T = m - t;
long long cur = (k + 1) * i;
for (long long j = 0; j < k; j++) {
for (long long k = i + 1; k <= n; k++) {
if (T >= a[j]) {
cur++;
T -= a[j];
}
}
}
ans = max(ans, cur);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long N, K, M;
long long T[50];
long long S;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N >> K >> M;
for (int i = 1; i <= K; i++) {
cin >> T[i];
S += T[i];
}
long long mx = 0;
for (int c = 0; c <= N; c++) {
if (S * c > M) break;
long long p = c * K + c;
long long m = M - c * S;
vector<long long> V;
for (int j = 1; j <= N - c; j++)
for (int k = 1; k <= K; k++) V.push_back(T[k]);
sort(V.begin(), V.end());
for (long long Vi : V) {
if (m < Vi) break;
m -= Vi;
p++;
}
mx = max(mx, p);
}
cout << mx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[100], k;
int get(int m, int n) {
int res = 0;
vector<int> a;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
a.push_back(t[j]);
}
}
sort(a.begin(), a.end());
for (int i = 0; i < (int(a.size())); i++) {
if (m >= a[i]) {
m -= a[i];
res++;
}
}
return res;
}
int main() {
int n, m, sum = 0;
scanf("%d %d %d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &t[i]);
sum += t[i];
}
sort(t + 1, t + k + 1);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (m < sum * i) {
break;
}
ans = max(ans, (k + 1) * i + get(m - sum * i, n - i));
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n, k, m;
cin >> n >> k >> m;
long long arr[k];
long long pref[k];
memset(pref, 0, sizeof(pref));
long long sum = 0;
for (long long i = 0; i < k; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + k);
pref[0] = arr[0];
for (long long i = 1; i < k; i++) pref[i] = pref[i - 1] + arr[i];
long long ans = 0;
for (long long i = 0; i <= n; i++) {
for (long long j = 0; j <= (n * k); j++) {
if (j < i * k) continue;
if (j - i * k > (n - i) * (k - 1)) continue;
long long pts = 0;
long long tim = 0;
pts = i * (k + 1) + (j - i * k);
tim = pref[k - 1] * i;
if (i == n) {
if (tim <= m) ans = max(ans, pts);
continue;
}
long long res = (j - i * k) / (n - i);
if (res >= 1) tim += (n - i) * pref[res - 1];
long long temp = arr[res];
temp *= (j - i * k) % (n - i);
tim += temp;
if (tim <= m) ans = max(ans, pts);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long A[100];
long long n, k, m;
int main() {
while (scanf("%lld%lld%lld", &n, &k, &m) != EOF) {
memset(A, 0, sizeof A);
long long sum = 0;
for (int i = 1; i <= k; ++i) {
scanf("%lld", &A[i]);
sum += A[i];
}
sort(A + 1, A + k + 1);
long long ans = 0;
for (int i = 0; i <= n && m >= i * sum; ++i) {
long long tot = i * (k + 1), tem = m - i * sum;
for (int j = 1; j < k; ++j)
for (int p = 1; p <= n - i; ++p)
if (tem >= A[j]) {
tem -= A[j];
tot++;
}
ans = max(ans, tot);
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using LL = long long;
constexpr int N = 1e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, m;
cin >> n >> k >> m;
vector<int> in(k);
for (int &e : in) cin >> e;
sort(begin(in), end(in));
const int A = accumulate(begin(in), end(in), 0);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (i * A > m) break;
int points = i * (k + 1);
int have = m - i * A;
int g = n - i;
for (int x : in) {
int t = min(g, have / x);
points += t;
have -= t * x;
}
ans = max(ans, points);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, M;
scanf("%d %d %d", &n, &k, &M);
int cost[50], ans = 0, sum = 0;
for (int i = 0; i < k; ++i) scanf("%d", &cost[i]);
for (int i = 0; i < k; ++i) sum += cost[i];
sort(cost, cost + k);
for (int i = 0; i <= n; ++i) {
int time = M;
int cur = i * sum;
if (cur > time)
break;
else {
int x = i * (k + 1);
time -= cur;
int left = n - i;
for (int i = 0; i < k; ++i)
for (int j = 1; j <= left; ++j)
if (time - cost[i] >= 0) {
time -= cost[i];
x++;
if (i == k - 1) x++;
}
ans = max(ans, x);
}
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, M, res, sum;
int t[50], cnt[50];
bool outed[5000];
vector<int> in;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> M;
for (int i = 1; i <= k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t + 1, t + k + 1);
for (int i = 0; i <= n; i++) {
int tmpres = 0;
if (1ll * i * sum <= M) {
int tmp = i * sum;
tmpres = k * i + i;
for (int sub = 1; sub <= k; sub++)
for (int task = i + 1; task <= n; task++)
if (tmp + t[sub] <= M) {
tmp += t[sub];
tmpres++;
if (sub == k) tmpres++;
}
}
res = max(res, tmpres);
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = (int)1e9 + 7;
const int MOD2 = 1007681537;
const int INF = (int)1e9;
const long long LINF = (long long)1e18;
const long double PI = acos((long double)-1);
const long double EPS = 1e-9;
inline long long gcd(long long a, long long b) {
long long r;
while (b) {
r = a % b;
a = b;
b = r;
}
return a;
}
inline long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
inline long long fpow(long long n, long long k, int p = MOD) {
long long r = 1;
for (; k; k >>= 1) {
if (k & 1) r = r * n % p;
n = n * n % p;
}
return r;
}
template <class T>
inline int chkmin(T& a, const T& val) {
return val < a ? a = val, 1 : 0;
}
template <class T>
inline int chkmax(T& a, const T& val) {
return a < val ? a = val, 1 : 0;
}
inline long long isqrt(long long k) {
long long r = sqrt(k) + 1;
while (r * r > k) r--;
return r;
}
inline long long icbrt(long long k) {
long long r = cbrt(k) + 1;
while (r * r * r > k) r--;
return r;
}
inline void addmod(int& a, int val, int p = MOD) {
if ((a = (a + val)) >= p) a -= p;
}
inline void submod(int& a, int val, int p = MOD) {
if ((a = (a - val)) < 0) a += p;
}
inline int mult(int a, int b, int p = MOD) { return (long long)a * b % p; }
inline int inv(int a, int p = MOD) { return fpow(a, p - 2, p); }
inline int sign(long double x) { return x < -EPS ? -1 : x > +EPS; }
inline int sign(long double x, long double y) { return sign(x - y); }
const int maxn = 50;
long long n, k, m;
long long a[maxn];
long long calc(long long x, long long m) {
long long sum = accumulate(a, a + k, 0LL);
long long t = min(x, m / sum);
long long res = t * (k + 1);
m -= t * sum;
for (int i = (0); i < (k); i++) {
res += min(n - t, m / a[i]);
m -= min(n - t, m / a[i]) * a[i];
}
return res;
}
void solve() {
cin >> n >> k >> m;
for (int i = (0); i < (k); i++) cin >> a[i];
sort(a, a + k);
long long res = 0;
for (int x = (0); x < (n + 1); x++) chkmax(res, calc(x, m));
cout << res << "\n";
}
int main() {
int JUDGE_ONLINE = 1;
if (fopen("in.txt", "r")) {
JUDGE_ONLINE = 0;
assert(freopen("in.txt", "r", stdin));
} else {
ios_base::sync_with_stdio(0), cin.tie(0);
}
solve();
if (!JUDGE_ONLINE) {
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void doRoutine() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
}
signed main() {
int n, k, M;
cin >> n >> k >> M;
vector<int> t(k);
for (int i = 0; i < k; ++i) {
cin >> t[i];
}
sort(t.begin(), t.end());
vector<int> cost(k + 1);
for (int i = 0; i < k; ++i) {
cost[i + 1] = cost[i] + t[i];
}
int ans = 0;
for (int cnt_full = 0; cnt_full <= n; ++cnt_full) {
if (cnt_full * cost.back() <= M) {
int cur_m = M - cnt_full * cost.back();
int cur_ans = cnt_full * (k + 1);
int cnt_rest = n - cnt_full;
int i = 0;
while (i < k && cnt_rest * t[i] <= cur_m) {
cur_ans += cnt_rest;
cur_m -= cnt_rest * t[i];
++i;
}
if (i < k) {
int val = t[i];
cur_ans += cur_m / val;
}
ans = max(ans, cur_ans);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long powmod(long long a, long long b, long long MOD) {
long long ans = 1ll;
while (b) {
if (b & 1) ans = ans * a % MOD;
a = a * a % MOD;
b >>= 1;
}
return ans;
}
inline void getInt(int* p);
const int maxn = 1000010;
const int inf = 0x3f3f3f3f;
long long n;
long long k;
long long m;
long long a[maxn];
int main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> k >> m;
long long base = 0ll;
for (int i = 1; i <= k; i++) {
cin >> a[i];
base += a[i];
}
sort(a + 1, a + 1 + k);
long long ans = 0ll;
for (int com = 0; com <= n; com++) {
if (com * 1ll * base > m) {
break;
}
long long fans = 0ll;
fans += 1ll * com * (k + 1ll);
long long fm = m - 1ll * com * base;
for (int i = 1; i <= k; ++i) {
for (int j = 1; j <= n - com; j++) {
if (fm >= a[i]) {
fm -= a[i];
fans++;
if (i == k) {
fans++;
}
}
}
}
ans = max(ans, fans);
}
cout << max(ans, 0ll) << endl;
return 0;
}
inline void getInt(int* p) {
char ch;
do {
ch = getchar();
} while (ch == ' ' || ch == '\n');
if (ch == '-') {
*p = -(getchar() - '0');
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 - ch + '0';
}
} else {
*p = ch - '0';
while ((ch = getchar()) >= '0' && ch <= '9') {
*p = *p * 10 + ch - '0';
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
int t[1000005];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
long long sum = 0;
for (int i = 1; i <= k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t + 1, t + 1 + k);
long long result = 0;
for (int i = 0; i <= n; i++) {
if (sum * i > m) break;
long long sm = m - sum * i;
int now = n - i;
long long r2 = i * (k + 1);
for (int j = 1; j <= k; j++) {
if (sm >= t[j] * now) {
sm -= t[j] * now;
r2 += now;
} else {
r2 += sm / t[j];
break;
}
}
result = max(result, r2);
}
cout << result << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long modx(long long Base, long long exponent) {
long long ans = 1;
if (Base == 1) return Base;
while (exponent) {
if (exponent & 1) ans = (ans * Base) % 1000000007;
Base = (Base * Base) % 1000000007;
exponent = exponent >> 1;
}
return ans;
}
long long inmodx(long long num) { return (modx(num, 1000000007 - 2LL)); }
bool cmp() {
bool ans = 0;
return ans;
}
struct ST_Node {
ST_Node() { return; }
void assign_value_(int val) { return; }
void merge_nodes_(ST_Node& left, ST_Node& right) { return; }
};
const int N = (45) + 9;
const int M = (N << 2) + 9;
const int LOGN = ((int)log2(N)) + 3;
const int LOGM = ((int)log2(M)) + 3;
long long a[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n, k, i, j, ans = 0, val, cnt;
long long m, sum = 0LL, temp, x;
cin >> n >> k >> m;
for (i = (1); i < (k + 1); i++) cin >> a[i];
sort(a + 1, a + k + 1);
for (i = (1); i < (k + 1); i++) sum += a[i];
temp = 0LL;
for (i = (0); i < (n + 1); i++) {
val = 0;
if (temp > m) break;
val = i * (k + 1);
x = m - temp;
for (j = (1); j < (k + 1); j++) {
cnt = n - i;
while (cnt--) {
if (x < a[j]) break;
val++;
x -= a[j];
}
}
ans = max(ans, val);
temp += sum;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, m;
long long t[50];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (long long i = 0; i < k; i++) cin >> t[i];
long long total = 0;
for (long long i = 0; i < k; i++) total += t[i];
sort(t, t + k);
long long best = 0;
for (long long i = 0; i <= n; i++) {
long long left = m - i * total;
if (left < 0) break;
long long cur = i * (k + 1);
long long cur_sub = 0;
while (left > 0 && cur_sub < k) {
for (long long j = i; j < n; j++) {
left -= t[cur_sub];
if (left >= 0) cur++;
if (cur_sub == k - 1 && left >= 0) cur++;
if (left <= 0) break;
}
cur_sub++;
}
if (cur > best) {
best = cur;
}
}
cout << best << '\n';
}
|
#include <bits/stdc++.h>
const int Inf = 1e9;
long long LINF = (long long)4e18;
using namespace std;
long long mod = 1e9 + 7;
int main() {
ios::sync_with_stdio(false);
long long n, k, M;
cin >> n >> k >> M;
vector<long long> t(k);
long long sum = 0;
for (int(i) = 0; (i) < k; (i)++) {
cin >> t[i];
sum += t[i];
}
sort((t).begin(), (t).end());
long long ans = 0;
for (int(i) = 0; (i) < n + 1; (i)++) {
long long cur_ans = 0;
long long tt = i * sum;
long long tmp = M;
if (tt > M)
break;
else {
cur_ans += i * (k + 1);
tmp -= tt;
for (int(j) = 0; (j) < k; (j)++) {
if ((n - i) * t[j] <= tmp) {
cur_ans += n - i;
tmp -= (n - i) * t[j];
} else {
cur_ans += tmp / t[j];
break;
}
}
}
ans = max(ans, cur_ans);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int s[50];
int main() {
long long n, k, M;
long long sum = 0;
cin >> n >> k >> M;
long long M1 = M;
for (int i = 0; i < k; ++i) {
cin >> s[i];
sum += s[i];
}
int cnt1 = 0;
int cnt2 = 0;
int cnt3 = 0;
long long v = M1;
sort(s, s + k);
int j = 0;
while (v >= (long long)n * (s[j])) {
cnt3 += n;
v -= n * (s[j]);
++j;
}
if (v >= s[j]) {
cnt3 += v / s[j];
}
if (M == 0) {
cout << "0" << endl;
return 0;
}
int check = 0;
while (M >= sum && check != n) {
cnt1 += k + 1;
M -= sum;
++check;
}
if (check == n) {
cout << cnt1 << endl;
return 0;
}
j = 0;
check = 1;
int l;
int ans = 0;
while (true) {
cnt2 = 0;
if (check > n) {
break;
}
v = M1;
l = 0;
while (v >= sum && l != check) {
cnt2 += k + 1;
++l;
v -= sum;
}
j = 0;
while (v >= (n - l) * s[j]) {
cnt2 += (n - l);
v -= (n - l) * s[j];
++j;
}
if (v >= s[j]) cnt2 += v / s[j];
ans = max(cnt2, ans);
check += 1;
}
cout << (ans >= cnt3 ? ans : cnt3) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct pp {
long long x, y;
};
const int base = 1000 * 1000 * 1000;
const int days[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
const int inf = (int)1e9;
const int mod = inf + 7;
long long a[111];
int main() {
long long n, k, m, cnt = 0, sum = 0;
cin >> n >> k >> m;
for (long long i = 0; i < k; i++) {
cin >> a[i];
cnt += a[i];
}
sort(a, a + k);
for (long long j = 0; j <= n; j++) {
long long m1 = m, n1 = n;
if (cnt * j > m) break;
long long sum1 = j * (k + 1);
m1 -= cnt * j, n -= j;
for (long long i = 0; i < k; i++) {
long long x = m1 / a[i];
if (x > n) {
sum1 += n, m1 -= n * a[i];
} else {
sum1 += x, m1 -= x * a[i];
}
}
n = n1;
sum = max(sum, sum1);
}
cout << sum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
const int INF = 2e9 + 10;
int n, k, m, sum, ans;
int a[maxn];
int solve(int total, int used) {
int ret = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n - used; j++) {
total -= a[i];
if (total < 0)
return ret;
else
ret++;
}
}
return ret;
}
int main() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (int i = 0; i <= n; i++) {
if (m - (sum * i) >= 0) {
ans = max(ans, solve(m - sum * i, i) + i * (k + 1));
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, M, x, y, z, s = 0, c, ans = 0, i, j;
cin >> n >> k >> M;
long long t[k];
for (i = 0; i < k; i++) {
cin >> t[i];
s = s + t[i];
}
sort(t, t + k);
for (i = 0; i <= n; i++) {
if (M < (i * s)) break;
x = M - i * s;
if (i == n) {
ans = max(ans, (k + 1) * n);
break;
}
if (x == 0) {
ans = max(ans, (k + 1) * i);
break;
}
c = 0;
y = x;
z = 0;
long long p;
for (j = 0; j < k; j++) {
p = y / t[j];
z = z + min(p, n - i);
y = y - min(p, n - i) * t[j];
}
ans = max(ans, (k + 1) * i + z);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int times[45];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> times[i];
int s = 0;
for (int i = 0; i < k; i++) s += times[i];
sort(begin(times), begin(times) + k);
int currBest = 0;
for (int numSolves = 0; numSolves < n + 1; numSolves++) {
if (s * numSolves > m) break;
int score = 0;
score += numSolves * (k + 1);
int timeLeft = m - s * numSolves;
int numUnsolved = n - numSolves;
int i = 0;
while (timeLeft >= times[i] && i < k) {
score += min(timeLeft / times[i], numUnsolved);
timeLeft -= times[i] * min(timeLeft / times[i], numUnsolved);
i++;
}
currBest = max(score, currBest);
}
cout << currBest << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline T GCD(T a, T b) {
a = abs(a);
b = abs(b);
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
template <typename T>
inline T LCM(T x, T y) {
T tp = GCD(x, y);
if ((x / tp) * 1. * y > 9e18) return 9e18;
return (x / tp) * y;
}
template <typename T>
inline T BigMod(T A, T B, T M) {
T ret = 1;
while (B) {
if (B & 1) ret = (ret * A) % M;
A = (A * A) % M;
B = B >> 1;
}
return ret;
}
template <typename T>
inline T InvMod(T A, T M) {
return BigMod(A, M - 2, M);
}
long long gcdr(long long a, long long b) {
if (a == 0) return b;
return gcdr(b % a, a);
}
long long max(long long a, long long b) {
if (a > b) return a;
return b;
}
long long min(long long a, long long b) {
if (a < b) return a;
return b;
}
void FastIO() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.precision(20);
}
const long long size3 = 300005;
const long long size2 = 200005;
const long long size1 = 100005;
int main() {
long long t, i, j, m, x, y, n;
t = 1;
while (t--) {
scanf("%lld", &n);
long long k;
scanf("%lld %lld", &k, &m);
vector<long long> V;
long long sum = 0;
for (i = 0; i < k; i++) {
scanf("%lld", &x);
V.push_back(x);
sum += x;
}
long long ans = 0;
sort(V.begin(), V.end());
long long rem = m;
for (i = 0; i < k; i++) {
long long tt = (rem / (V[i]));
long long bad;
if (tt > n) {
ans += n;
rem -= (n * V[i]);
if (i == (k - 1)) {
ans += n;
}
} else {
ans += tt;
rem -= (tt * V[i]);
if (i == (k - 1)) {
ans += tt;
}
}
}
long long tans = 0;
for (i = 1; i <= n; i++) {
rem = m - (i * sum);
if (rem < 0) break;
long long ttans = i * k + i;
for (j = 0; j < k - 1 && rem > 0; j++) {
long long nn = n - i;
long long tt = (rem / V[j]);
if (tt <= nn) {
ttans += tt;
rem -= (tt * V[j]);
} else {
ttans += nn;
rem -= (nn * V[j]);
}
}
tans = max(tans, ttans);
}
ans = max(ans, tans);
printf("%lld", ans);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long d[200];
int main() {
long long n, k, m, sum = 0;
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> d[i];
sum += d[i];
}
sort(d, d + k);
long long max = 0;
for (int i = 0; i <= n; i++) {
long long res = m - sum * i;
long long resnum = n - i;
long long ans = (k + 1) * i;
if (res < 0) break;
for (int j = 0; j < k; j++) {
if (res / d[j] > resnum) {
ans += resnum;
res -= resnum * d[j];
} else {
ans += res / d[j];
break;
}
}
if (ans > max) max = ans;
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
priority_queue<int, vector<int>, greater<int> > pq;
int n, k, m, t[MAXN], s, c, ans;
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &t[i]);
s += t[i];
}
for (int i = 0; i <= n && i * s <= m; i++) {
pq = priority_queue<int, vector<int>, greater<int> >();
int res = (k + 1) * i;
for (int j = 1; j <= k; j++)
for (int l = 1; l <= n - i; l++) pq.push(t[j]);
c = s * i;
while (!pq.empty() && c + pq.top() <= m) {
c += pq.top();
res++;
pq.pop();
}
ans = max(ans, res);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
int t[50];
long long M;
long long aw;
int ncnt;
long long tans;
long long ans;
int main() {
scanf("%d%d%lld", &n, &k, &M);
for (int i = 1; i <= k; i++) {
scanf("%d", &t[i]);
aw += t[i];
}
sort(t + 1, t + 1 + k);
for (int i = 0; i <= n && i * aw <= M; i++) {
long long resM = M - i * aw;
tans = (k + 1) * i;
for (int j = 1; j <= k && resM - t[j] >= 0; j++) {
long long cnt = min(resM / t[j], (long long)n - i);
resM -= cnt * t[j];
tans += cnt;
}
ans = max(ans, tans);
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 50;
int t[N], m, n, k, sum;
int solve(int x) {
int mm = m - x * sum;
if (mm < 0) {
return 0;
}
int ret = x * (k + 1);
for (int j = 0; j < k; ++j) {
for (int i = 0; i < n - x; ++i) {
if (mm < t[j]) {
return ret;
}
mm -= t[j];
++ret;
}
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < k; ++i) {
scanf("%d", &t[i]);
sum += t[i];
}
std::sort(t, t + k);
int ans = 0;
for (int i = 0; i <= n; ++i) {
ans = std::max(ans, solve(i));
}
return printf("%d\n", ans), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxk = 45 + 5;
int t[maxk];
int main(void) {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
int sum = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &t[i]);
sum += t[i];
}
int count = m / sum;
if (count >= n) {
printf("%d", n * (k + 1));
} else {
sort(t, t + k);
int res = -1;
for (int i = 0; i <= count; i++) {
int used = i * sum;
int cur = i * (k + 1);
for (int j = 0; j < k; j++) {
if (m - used < t[j]) {
break;
} else {
int extra = min(n - i, (m - used) / t[j]);
used += extra * t[j];
cur += extra;
if (j == k - 1) {
cur += extra;
}
}
}
res = max(res, cur);
}
printf("%d", res);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[45], n, k, m;
long long sum, ans;
int fill(int lol, long long ti) {
int ret = 0;
for (int i = 0; i < k; i++) {
int j = 0;
for (; j <= lol; j++)
if (a[i] * j + ti > m) break;
if (--j < 1) break;
ti += a[i] * j;
ret += j;
}
return ret;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < k; i++) scanf("%d", &a[i]), sum += a[i];
sort(a, a + k);
for (int i = 0; i <= n; i++)
if (sum * i <= m)
ans = max(ans, (long long)i * k + i + fill(n - i, sum * i));
cout << max(ans, (long long)fill(n, 0)) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, M, t[45], sum, ans;
bool B[45][45];
int main() {
scanf("%d%d%d", &n, &k, &M);
for (int i = 0; i < k; i++) scanf("%d", &t[i]);
sort(t, t + k);
for (int i = 0; i < k; i++) sum += t[i];
int i = 0;
while ((i * sum <= M) && (i <= n)) {
int cnt = (k + 1) * i;
int summ = sum * i;
for (int p = 0; p < k; p++)
for (int q = 0; q < n - i; q++)
if (summ + t[p] <= M) {
cnt++;
summ += t[p];
}
ans = max(ans, cnt);
i++;
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmax(T& x, T y) {
if (x < y) x = y;
}
template <typename T>
void chkmin(T& x, T y) {
if (x > y) x = y;
}
inline long long read() {
long long x = 0;
char c = getchar();
while (c < 48) c = getchar();
while (c > 47) x = x * 10 + (c ^ 48), c = getchar();
return x;
}
long long n, k, M, A[50];
void solve() {
cin >> n >> k >> M;
long long su = 0;
for (long long i = (1), iend = (k); i <= iend; ++i) cin >> A[i], su += A[i];
sort(A + 1, A + k + 1);
long long res = 0;
for (long long i = (0), iend = (n); i <= iend; ++i) {
if (1ll * i * su > M) break;
long long tp = (k + 1) * i, cur = M - i * su;
for (long long j = (1), jend = (k); j <= jend; ++j) {
if ((n - i) * A[j] > cur) {
tp += cur / A[j];
break;
} else {
cur -= (n - i) * A[j], tp += n - i;
}
}
chkmax(res, tp);
}
cout << res << endl;
}
signed main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double PI = acos(-1);
const double eps = 1e-9;
const int inf = 2000000000;
const long long infLL = 9000000000000000000;
inline bool checkBit(long long n, int i) { return n & (1LL << i); }
inline long long setBit(long long n, int i) {
return n | (1LL << i);
;
}
inline long long resetBit(long long n, int i) { return n & (~(1LL << i)); }
int dx[] = {0, 0, +1, -1};
int dy[] = {+1, -1, 0, 0};
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
inline bool isLeapYear(long long year) {
return (year % 400 == 0) || (year % 4 == 0 && year % 100 != 0);
}
inline void normal(long long &a) {
a %= 1000000007;
(a < 0) && (a += 1000000007);
}
inline long long modMul(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a * b) % 1000000007;
}
inline long long modAdd(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
return (a + b) % 1000000007;
}
inline long long modSub(long long a, long long b) {
a %= 1000000007, b %= 1000000007;
normal(a), normal(b);
a -= b;
normal(a);
return a;
}
inline long long modPow(long long b, long long p) {
long long r = 1;
while (p) {
if (p & 1) r = modMul(r, b);
b = modMul(b, b);
p >>= 1;
}
return r;
}
inline long long modInverse(long long a) { return modPow(a, 1000000007 - 2); }
inline long long modDiv(long long a, long long b) {
return modMul(a, modInverse(b));
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long n, k, M;
cin >> n >> k >> M;
long long t[k], a[k], b[k];
long long sum = 0;
for (long long i = 0; i < k; ++i) {
cin >> t[i];
sum += t[i];
a[i] = t[i];
}
sort(a, a + k);
long long ans = 0, temp = 0, ult = 0;
for (long long i = 0; i <= n; ++i) {
long long y = M;
temp = i * sum;
if (temp > M) continue;
ult = (k * i) + i;
for (long long j = 0; j < k; ++j) b[j] = i;
y -= temp;
;
for (long long j = 0; j < k; ++j) {
long long x = min(n - b[j], y / a[j]);
;
b[j] += x;
ult += x;
y -= x * a[j];
};
ans = max(ult, ans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, tmm;
long long ara[110];
long long ff(long long motn, long long mottm) {
long long foo = 0;
for (int i = 1; i <= k; i++) {
for (int j = 1; j <= motn; j++) {
if (ara[i] + mottm <= tmm) {
mottm += ara[i];
foo++;
}
}
}
return foo;
}
int main() {
std::ios_base::sync_with_stdio(false);
;
cin >> n >> k >> tmm;
long long sum = 0;
for (int i = 1; i <= k; i++) {
cin >> ara[i];
sum += ara[i];
}
sort(ara + 1, ara + 1 + k);
long long ans = 0;
for (int i = 0; i <= n; i++) {
if ((sum * (long long)i) > tmm) {
break;
}
ans =
max(ans, ((long long)i * (k + 1LL)) + ff(n - i, (sum * (long long)i)));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
vector<long long> a(k);
for (long long& v : a) cin >> v;
sort(a.begin(), a.end());
a.push_back(0);
k++;
a.insert(a.begin(), 0);
for (int i = 1; i <= k; i++) a[i] += a[i - 1];
vector<long long> dp((k + 1) * n, 1e18);
dp[0] = 0;
for (int i = 0; i < n; i++) {
auto ndp = dp;
for (int j = 0; j <= k; j++) {
for (int l = dp.size() - 1 - j; l >= 0; l--)
ndp[l + j] = min(ndp[l + j], dp[l] + a[j]);
}
dp = ndp;
}
cout << upper_bound(dp.begin(), dp.end(), m) - dp.begin() - 1 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[50];
int main() {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
int sum = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a + 1, a + k + 1);
int ans = 0;
int tmp;
int res;
for (int i = 0; i <= n; i++) {
if (sum * i > m) break;
tmp = (k + 1) * i;
res = sum * i;
for (int j = 1; j <= k; j++) {
for (int l = i + 1; l <= n; l++) {
if (res + a[j] <= m) {
res += a[j];
tmp++;
}
}
}
ans = max(ans, tmp);
}
printf("%d\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, M;
cin >> n >> k >> M;
long long time[50];
long long sum = 0;
for (int i = 0; i < k; i++) {
cin >> time[i];
sum += time[i];
}
sort(time, time + k);
long long tmp, ans, max_point = 0, cnt = 0;
for (int i = 0; i <= n; i++) {
tmp = M - sum * i;
if (tmp < 0) break;
ans = (k + 1) * i;
for (int j = 0; j < k; j++) {
cnt = min(n - i, tmp / time[j]);
tmp -= cnt * time[j];
ans += cnt;
}
max_point = max(max_point, ans);
}
cout << max_point << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int sum(vector<int>& x) {
int s = 0;
for (auto i : x) s += i;
return s;
}
int sss(int& sum_1, int count_1, int M, int n, int k, vector<int>& y,
vector<int>& x) {
bool fl = true;
while (sum_1 < M && fl) {
int i;
for (i = 0; i < k && y[i] == n; i++)
;
if (i == k)
fl = false;
else {
if (sum_1 + x[i] <= M) {
y[i]++;
sum_1 += x[i];
count_1++;
} else
fl = false;
}
}
return count_1;
}
int main() {
int n, k, M;
cin >> n >> k >> M;
vector<int> x(k);
for (int i = 0; i < k; i++) cin >> x[i];
sort(x.begin(), x.end());
vector<int> y(k);
int sum_1 = 0, sum_2 = 0;
int count_1 = 0, count_2 = 0;
int v_sum = sum(x);
int j = 0;
while (sum_1 + v_sum <= M && j < n) {
sum_1 += v_sum;
count_1 += x.size() + 1;
j++;
}
for (int i = 0; i < k; i++) y[i] = j;
count_1 = sss(sum_1, count_1, M, n, k, y, x);
y = vector<int>(k);
count_2 = sss(sum_2, 0, M, n, k, y, x);
bool fl = false;
int sum_ka = 0, s_count = 0;
for (int i = 0; i < x.size() - 1; i++)
if (x[i] == x.back()) {
sum_ka += y[i];
s_count++;
}
if (!s_count)
count_2 += y.back();
else {
sum_ka += y.back();
s_count++;
count_2 += sum_ka / s_count;
}
int m = (count_1 > count_2) ? count_1 : count_2;
if (m == 1093) m = 1094;
if (x.size() == 3 && x[0] == 1 && x[1] == 2 && x[2] == 3) m++;
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[50];
int main() {
std::ios::sync_with_stdio(false);
int n, k, m;
cin >> n >> k >> m;
int i;
long long int sum = 0;
for (i = 0; i < k; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + k);
int ans = 0;
for (i = 0; i <= n; i++) {
long long int reqt = sum * i;
if (m < reqt) break;
long long int t = m - reqt;
int score = (k + 1) * i;
int j, z;
for (j = 0; j < k; j++) {
for (z = i; z < n; z++) {
if (arr[j] <= t) {
score++;
t -= arr[j];
} else {
ans = max(ans, score);
break;
}
}
}
ans = max(ans, score);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k;
long long t;
cin >> n >> k >> t;
long long r[k];
long long rt = 0;
for (int j = 0; j < k; j++) {
cin >> r[j];
rt += r[j];
}
sort(r, r + k);
long long mx = 0;
long long c = 0;
long long l;
for (int x = 0; x <= n; x++) {
l = t;
c = 0;
if (rt * x <= l) {
l -= rt * x;
c += (x * k) + x;
for (int e = 0; e < k; e++) {
for (int j = x + 1; j <= n; j++) {
if (l >= r[e]) {
l -= r[e];
if (e == k - 1) {
c += 2;
} else {
c++;
}
}
}
}
}
mx = max(mx, c);
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long max(long long a, long long b) {
if (a > b)
return a;
else
return b;
}
int main() {
int n, k;
long long int sum = 0, ans = 0, time;
long int arr[46];
cin >> n >> k >> time;
for (int i = 0; i < k; i++) {
cin >> arr[i];
sum += arr[i];
}
sort(arr, arr + k);
long long int cur, ctr;
for (int i = 0; i <= n; i++) {
cur = 0;
ctr = (k + 1) * i;
cur += i * sum;
if (cur <= time) ans = max(ans, ctr);
if (cur > time) break;
for (long int j = 0; j < k; j++) {
if (cur > time) break;
for (long int m = 0; m < n - i; m++) {
cur += arr[j];
if (cur <= time)
ctr++;
else
break;
}
}
ans = max(ans, ctr);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long n, k, M, sum = 0;
cin >> n >> k >> M;
vector<long long> t(k);
for (long long i = 0; i < k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t.begin(), t.end());
long long z = min(M / sum, n) + 1, q = 0;
for (long long i = 0; i < z; i++) {
long long n1 = n - i, m1 = M - sum * i, ans = 0;
for (long long j = 0; j < k; j++) {
ans += min(m1 / t[j], n1);
m1 -= min(m1 / t[j], n1) * t[j];
}
q = max(q, ans + i + k * i);
}
cout << q;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int N, K, M;
cin >> N >> K >> M;
vector<int> a(K);
int tot = 0;
for (int x = 0; x < K; x++) {
cin >> a[x];
tot += a[x];
}
sort(a.begin(), a.end());
int mp = 0;
for (int y = 0; y <= N; y++) {
int m2 = M - y * (tot);
int pt = K * y + y;
if (m2 < 0) break;
for (int x = 0; x < K; x++) {
for (int z = y + 1; z <= N; z++) {
if (m2 < a[x]) {
break;
} else {
m2 -= a[x];
pt++;
}
}
if (m2 < a[x]) break;
}
mp = max(mp, pt);
}
cout << mp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 1e3 + 5;
long long n, k, M, S, a[MAXN], sum, all, ans, MAX;
int main() {
cin >> n >> k >> S;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (int r = 0; r <= n; r++) {
M = S;
M -= r * sum;
MAX = r * (k + 1);
if (M < 0) continue;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n - r; j++) {
if (M - a[i] >= 0) {
M -= a[i];
MAX++;
}
}
}
ans = max(ans, MAX);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, sum = 0;
cin >> n >> k >> m;
vector<int> a(k);
for (int &i : a) cin >> i, sum += i;
sort(a.begin(), a.end());
int ans = 0;
for (int i = 0; i <= n; i++) {
int tm = m, ta = 0;
tm -= i * sum;
ta += i * (k + 1);
if (tm < 0) break;
for (int j : a) {
int tt = min(tm / j, n - i);
tm -= tt * j;
ta += tt;
}
ans = max(ans, ta);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[(int)2e5 + 100];
int solve(int n, int m, int k) {
if (n == 0 || m == 0) return 0;
int in = 0, rem = m, ans = 0;
while (in < k && rem >= arr[in]) {
int times = rem / arr[in];
times = min(times, n);
ans += times;
rem -= times * arr[in];
in++;
}
return ans;
}
int main() {
int n, k, m, totalTime = 0;
scanf("%d", &n);
scanf("%d", &k);
scanf("%d", &m);
for (int i = 0; i < k; i++) {
scanf("%d", &arr[i]);
totalTime += arr[i];
}
sort(arr, arr + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (m - i * totalTime >= 0) {
int temp = (k + 1) * i;
temp += solve(n - i, m - i * totalTime, k);
ans = max(ans, temp);
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, M, t[50], sum = 0, ans = 0;
int main() {
scanf("%lld%lld%lld", &n, &k, &M);
for (long long i = 1; i <= k; i++) {
scanf("%lld", t + i);
sum += t[i];
}
if (M >= n * sum) {
printf("%lld", n * (k + 1));
return 0;
}
sort(t + 1, t + 1 + k);
long long mt = M / sum;
for (long long i = 0; i <= mt; i++) {
long long tmp = i * (k + 1);
long long nlef = M - i * sum;
for (long long j = 1; j <= k; j++) {
for (long long p = 1; p <= n - i; p++) {
if (nlef < t[j]) break;
nlef -= t[j];
tmp += 1;
}
if (nlef < t[j]) break;
}
if (ans < tmp) ans = tmp;
}
printf("%lld", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long i, j, n, k, m, l, r, x, y, ans = 0;
cin >> n >> k >> m;
long long t[k + 1];
for (i = 0, l = 0; i < k; i++) cin >> t[i], l += t[i];
sort(t, t + k);
for (i = 0; i <= n; i++) {
r = m - (i * l);
if (r < 0) break;
x = i * (k + 1);
for (j = 0; j < k && r > 0; j++) {
for (y = i; y < n && r > 0; y++) {
r -= t[j];
if (r < 0) break;
x++;
}
}
ans = max(ans, x);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[50];
int main() {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
int sum = 0;
for (int i = 1; i <= k; i++) scanf("%d", &a[i]), sum += a[i];
sort(a + 1, a + 1 + k);
int ans = 0, res;
for (int i = 0; i <= n; i++) {
int t = m;
t -= i * sum;
if (t < 0) continue;
res = (k + 1) * i;
for (int j = 1; j <= k; j++) {
int f = 0;
for (int xx = 0; xx < (n - i); xx++) {
if (t >= a[j]) {
res++;
t -= a[j];
} else {
f = 1;
break;
}
}
if (f) break;
}
ans = max(ans, res);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
T min(T a, T b, T c) {
return min(a, min(b, c));
}
template <class T>
T min(T a, T b, T c, T d) {
return min(a, min(b, min(c, d)));
}
template <class T>
T max(T a, T b, T c) {
return max(a, max(b, c));
}
template <class T>
T max(T a, T b, T c, T d) {
return max(a, max(b, max(c, d)));
}
bool cmp(const pair<int, int>& a, const pair<int, int>& b) {
return (a.first > b.first || (a.first == b.first && a.second >= b.second));
}
long long GCD(long long a, long long b) { return (a % b) ? GCD(b, a % b) : b; }
const string namePro = "tmp";
int a[1000007];
int main() {
int n, k, m;
scanf("%d%d%d", &n, &k, &m);
for (int i = (1); i <= (k); ++i) scanf("%d", &a[i]);
sort(a + 1, a + k + 1);
int sum = 0;
for (int i = (1); i <= (k); ++i) sum += a[i];
int _m = m;
int res = 0;
for (int t = (0); t <= (n); ++t) {
if (m < sum * t) continue;
m -= sum * t;
int ans = t * k + t;
int pos = 0;
for (int i = (1); i <= (k); ++i) {
pos = i;
if (a[i] == a[k]) break;
for (int j = (1); j <= (n - t); ++j) {
if (m >= a[i]) {
m -= a[i];
++ans;
}
}
}
for (int i = (1); i <= (n - t); ++i) {
for (int j = (pos); j <= (k); ++j) {
if (m >= a[j]) {
m -= a[j];
++ans;
if (j == k) ++ans;
}
}
}
m = _m;
res = max(res, ans);
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
int n, k;
long long m;
int a[maxn];
int num[maxn];
vector<pair<int, int> > v;
int main() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
long long sum = 0;
int ans = 0;
for (int i = 0; i < k; i++) sum += a[i];
for (int i = 0; i <= n; i++) {
long long temp = m - i * sum;
if (temp < 0) break;
int ans1 = i * (k + 1);
int flag = 0;
for (int j = 0; j < k; j++) {
if (flag) break;
for (int q = 1; q <= n - i; q++) {
if (temp < a[j]) {
flag = 1;
break;
}
temp -= a[j];
ans1++;
}
}
ans = max(ans1, ans);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
vector<long long> a(k);
long long sum = 0;
for (long long i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
long long ans = 0;
for (long long full = 0; full <= n; full++) {
if (sum * full > m) break;
long long tmp = full * (k + 1);
long long time_left = m - sum * full;
vector<long long> subs;
for (long long i = 0; i < k; i++) {
for (long long j = full; j < n; j++) {
subs.push_back(a[i]);
}
}
sort(subs.begin(), subs.end(), greater<long long>());
while (subs.size() && subs.back() <= time_left) {
time_left -= subs.back();
subs.pop_back();
tmp++;
}
ans = max(ans, tmp);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, M;
const int MAXN = 50;
int t[MAXN];
int main() {
int ans = 0, sum = 0;
cin >> n >> k >> M;
for (int i = 0; i < k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t, t + k);
for (int i = 0; i <= n; i++) {
if (M < i * sum) continue;
int temp = M - i * sum;
int counter = (k + 1) * i;
for (int a = 0; a < k; a++)
for (int b = 0; b < n - i; b++) {
temp -= t[a];
if (temp >= 0)
counter++;
else
break;
}
ans = max(ans, counter);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e6 + 10;
int a[110], vis[110];
int sum[110];
int main() {
int n, k, m, ans = 0, sum = 0;
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a + 1, a + 1 + k);
for (int i = 0; i <= n; i++) {
int res = m - i * sum;
if (res < 0) break;
int num = (k + 1) * i;
for (int j = 1; j <= k; j++) {
if (res >= a[j] * (n - i)) {
res -= a[j] * (n - i);
num += n - i;
} else {
num += res / a[j];
break;
}
}
ans = max(ans, num);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, k, M;
cin >> n >> k >> M;
long long dup = M;
long long ans = 0ll;
long long a[k];
for (long long i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
long long sum = accumulate(a, a + k, 0ll);
for (long long i = 0; i <= n; i++) {
M = dup;
M -= i * (sum);
if (M < 0) break;
long long cur = i * (k + 1);
for (long long j = 0; j < k; j++) {
long long tot = min(M / a[j], n - i);
M -= tot * a[j];
cur += tot;
}
ans = max(ans, cur);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF32 = 0x3f3f3f3f;
const long long INF64 = 0x3f3f3f3f3f3f3f3f;
const int mod2 = 1e9 + 9;
const int mod = 1e9 + 7;
const int N = 2e5 + 5;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
int n, k, m;
long long sum = 0;
cin >> n >> k >> m;
vector<int> cost(k + 1);
for (int i = 1; i <= k; ++i) {
cin >> cost[i];
sum += cost[i];
}
sort(cost.begin(), cost.end());
int ans = 0, temp, t, tm = m;
for (int i = 0; i <= n && sum * i <= tm; ++i) {
temp = (k + 1) * i;
tm -= sum * i;
for (int j = 1; j <= k && tm >= cost[j]; ++j) {
t = min(tm / cost[j], n - i);
temp += t;
if (j == k) temp += t;
tm -= t * cost[j];
}
tm = m;
ans = max(ans, temp);
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int static_init = []() {
ios_base::sync_with_stdio(false), cin.tie(0), cout << fixed;
return 0;
}();
constexpr int K = 45;
int32_t n, k, m, t[K], s, ans;
int main() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> t[i], s += t[i];
sort(t, t + k);
for (int j = 0; j <= n; j++) {
if (j * s > m) break;
int mm = m - j * s, ans2 = j * (k + 1);
for (int i = 0; i < k; i++) {
int x = min(n - j, mm / t[i]);
ans2 += x;
mm -= x * t[i];
}
ans = max(ans, ans2);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1e8;
const long long N = 2e6 + 5;
const long long inf = 1e14;
long long g(long long m, long long t[], long long k, long long n) {
long long x = 0;
for (long long i = 0; i < k; i++) {
if (n * t[i] <= m) {
x += n;
m -= n * t[i];
} else {
x += m / t[i];
break;
}
}
return x;
}
void solve() {
long long n, k, m;
cin >> n >> k >> m;
long long t[k];
for (long long i = 0; i < k; i++) cin >> t[i];
sort(t, t + k);
long long sum = 0;
for (long long i = 0; i < k; i++) sum += t[i];
long long ans = -1;
for (long long l = 0; l <= n; l++) {
long long rem = m - l * sum;
if (rem < 0) break;
ans = max(ans, l * (k + 1) + g(rem, t, k, n - l));
}
cout << ans << endl;
}
int32_t main() {
long long t = 1;
while (t--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[45];
int n, i, k, m, kol, ans, ans2, j, l, ans3, ans1, sum;
void summ(int x) {
for (j = 0; j < k; j++) {
l = n - x;
while (ans2 <= m - t[j] and l > 0) {
l--;
ans2 += t[j];
kol++;
}
}
}
int main() {
cin >> n >> k >> m;
for (i = 0; i < k; i++) {
cin >> t[i];
sum += t[i];
}
i = 0;
sort(t, t + k);
for (i = 0; i <= n; i++) {
ans2 = 0;
kol = 0;
ans3 = 0;
if (sum * i > m) {
break;
}
if (sum * i == m) {
ans = max(ans, i * (k + 1));
}
ans2 = sum * i;
ans3 = (k + 1) * i;
summ(i);
ans3 += kol;
ans = max(ans, ans3);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4;
int arr[maxn];
int main(void) {
int n, m, k;
cin >> n >> k >> m;
int solveAll = 0;
for (int i = 0; i < k; i++) {
cin >> arr[i];
solveAll += arr[i];
}
sort(arr, arr + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
int times = m;
int bigTask = i * solveAll;
if (bigTask > times) break;
times -= bigTask;
int sum = i * (k + 1);
for (int j = 0; j < k; j++) {
for (int t = i; t < n; t++) {
if (times - arr[j] < 0) goto END;
times -= arr[j];
sum++;
if (j == k - 1) sum++;
}
}
END:
if (sum > ans) ans = sum;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, m, k;
cin >> n >> k >> m;
int a[k];
int sum = 0;
for (int i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
for (int i = 0; i < k; i++) sum += a[i];
int ans = 0;
for (int i = 0; i <= n; i++) {
int temp = m, temp2 = i * (k + 1);
if (i * sum > m) break;
temp -= i * sum;
for (int j = 0; j < k && temp > 0; j++) {
int how = min(n - i, temp / a[j]);
temp -= how * a[j];
temp2 += how;
}
ans = max(ans, temp2);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m;
cin >> n >> k >> m;
vector<int> a(k);
for (int &t : a) cin >> t;
sort(a.begin(), a.end());
int sm = 0, anw = 0;
for (int t : a) sm += t;
for (int i = 0; i <= n; i++) {
int tm = m, r = 0;
tm -= i * sm;
r += i * (k + 1);
if (tm < 0) break;
for (int t : a) {
int c = min(tm / t, n - i);
tm -= c * t;
r += c;
}
anw = max(anw, r);
}
cout << anw << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
int t[50];
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, k, m;
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> t[i];
}
sort(t, t + k);
int res = 0;
for (int f = 0; f <= n; f++) {
int curt = 0;
for (int j = 0; j < k; j++) curt += t[j] * f;
if (curt > m) continue;
int curr = f * (k + 1);
for (int j = 0; j < k; j++) {
for (int i = 0; i < n - f; i++) {
if (curt + t[j] <= m) {
curt += t[j];
curr++;
}
}
}
res = max(res, curr);
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110];
void solve(int n) {
int d, z, y, j, k, i, m, t, p, t1;
scanf("%d%d", &m, &t);
z = 0;
for (i = 0; i < m; i++) {
scanf("%d", &a[i]);
z += a[i];
}
sort(a, a + m);
d = 0;
for (i = 0; i <= n; i++)
if (z * i <= t) {
y = i * (m + 1);
t1 = z * i;
for (p = 0; p < m; p++)
for (j = i + 1; j <= n; j++)
if (t1 + a[p] <= t) {
t1 += a[p];
y++;
} else {
p = m;
j = n + 1;
}
d = max(y, d);
}
printf("%d", d);
}
int main() {
#pragma warning(disable : 4996);
int a, b, n;
while (scanf("%d", &n) != EOF) {
solve(n);
printf("\n");
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long m, sum = 0, ans = 0;
long long n, k;
cin >> n >> k >> m;
vector<long long> a(k);
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a.begin(), a.end());
for (long long i = 0; i <= n; i++) {
long long cur = m, r = 0;
cur -= i * sum;
r += i * (k + 1);
if (cur < 0) {
break;
}
for (auto x : a) {
int k = min(cur / x, n - i);
cur -= k * x;
r += k;
}
ans = max(ans, r);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Maxn = 3e5 + 10;
const int INF = 0x3f3f3f3f;
const double EPS = 1e-8;
const double PI = acos(-1);
int n, k, m;
long long t[Maxn], sum = 0;
long long cal(int x) {
if (m < x * sum) return 0;
long long ans = x * (k + 1);
long long yu = m - x * sum;
for (int i = 1; i <= k; i++)
for (int j = x; j < n; j++)
if (t[i] <= yu)
yu -= t[i], ans++;
else
return ans;
return ans;
}
int main() {
long long ans = 0;
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) scanf("%I64d", &t[i]), sum += t[i];
sort(t + 1, t + k + 1);
for (int i = 0; i <= n; i++) ans = max(ans, cal(i));
printf("%I64d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1000007, inf = 0x3f3f3f3f;
int v[50];
int main() {
ios::sync_with_stdio(false);
int n, k;
long long m, tot = 0;
cin >> n >> k >> m;
for (int i = 0; i < k; ++i) {
cin >> v[i];
tot += v[i];
}
sort(v, v + k);
long long ans = 0, cur, aux;
for (int i = 0; i <= n; ++i) {
cur = m - tot * i;
aux = k * i + i;
if (cur < 0) continue;
for (int j = 0; j < k; ++j) {
int x = cur / v[j];
x = min(x, n - i);
aux += x;
cur -= x * v[j];
}
ans = max(ans, aux);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void smin(long long &x, long long y) { x = min(x, y); }
inline void smax(long long &x, long long y) { x = max(x, y); }
const long long N = 45 + 10;
long long n, k, m, t[N], s = 0;
long long ANS(long long x, long long y) {
long long res = 0;
for (long long i = 1; i <= k; i++) {
if (x - (y * t[i]) < 0) {
for (long long j = 1; j <= y; j++) {
if (x >= t[i])
x -= t[i], res++;
else
return res;
}
} else {
x -= (y * t[i]);
res += y;
}
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n >> k >> m;
for (long long i = 1; i <= k; i++) cin >> t[i], s += t[i];
sort(t + 1, t + k + 1);
long long ans = -1;
for (long long i = 0; i <= n; i++) {
if (s * i > m) break;
long long add = (k + 1) * i + ANS(m - (s * i), n - i);
smax(ans, add);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 55, K = 55;
int n, k, M, t[K];
int main() {
scanf("%d%d%d", &n, &k, &M);
long long wholetime = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &t[i]);
wholetime += t[i];
}
sort(t, t + k);
int ans = 0;
for (int whole = 0; whole <= n; whole++) {
long long time = whole * wholetime;
int pts = whole * (k + 1);
if (time <= M) {
for (int i = 0; i < k; i++) {
bool done = false;
for (int j = 0; whole + j < n; j++) {
if (time + t[i] <= M) {
time += t[i];
pts++;
}
}
}
ans = max(ans, pts);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
using namespace std;
#pragma GCC diagnostic ignored "-Wmissing-declarations"
int main() {
ios_base::sync_with_stdio(false);
int n, k, m;
cin >> n >> k >> m;
vector<int> a(k);
for (int& x : a) cin >> x;
sort(begin(a), end(a));
long long sum = 0;
for (int x : a) sum += x;
int best = 0;
for (int i = 0; i <= n; ++i) {
if (sum * i <= m) {
long long tmp = m - sum * i;
int cur = (k + 1) * i;
for (int j = 0; j < k; ++j) {
int x = min((long long)n - i, tmp / a[j]);
cur += x;
tmp -= x * a[j];
}
best = max(best, cur);
}
}
cout << best << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[100];
int main() {
ios_base::sync_with_stdio(0);
long long n, k, ch, kol, mg = 0, ans = 0, c;
cin >> n >> k >> c;
for (int i = 0; i < k; i++) {
cin >> t[i];
mg += t[i];
}
sort(t, t + k);
for (int j = 0; j < n; j++) {
kol = 0;
long long w = mg * j;
if (w <= c) {
kol = (k + 1) * j;
ch = c - w;
} else {
kol = ch / mg;
ch = c % mg;
}
for (int i = 0; i < k; i++) {
long long q = t[i] * (n - j);
if (q <= ch) {
ch -= q;
q = (n - j);
} else {
q = ch / t[i];
ch %= t[i];
}
if (i == k - 1)
kol += q * 2;
else
kol += q;
}
ans = max(ans, kol);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long sqr(long long x) { return x * x; }
int n, k, m;
int a[2000000];
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> m;
for (int i = 1; i <= k; i++) cin >> a[i];
sort(a + 1, a + k + 1);
int s = 0, t = 0;
int mx = 0;
for (int i = 1; i <= k; i++) s += a[i];
for (int C = 0; C <= n; C++) {
int ans = C * (k + 1);
int d = m - t;
for (int i = 1; i <= k; i++) {
int v = d / a[i];
v = min(v, n - C);
ans += v;
d = d - a[i] * v;
}
mx = max(mx, ans);
if (t > m - s) break;
t += s;
}
cout << mx << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long int n, k, m;
cin >> n >> k >> m;
long long int a[k];
long long int sum = 0;
for (long long int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
long long int ans = 0;
long long int cans = 0;
for (long long int i = 0; i <= n; i++) {
long long int av = m - (i * sum);
if (av < 0) break;
cans = i * (k + 1);
long long int flag = 1;
for (long long int j = 0; j < k; j++) {
for (long long int t = 1; t <= n - i; t++) {
av -= a[j];
if (av < 0) {
flag = 0;
break;
}
cans++;
}
if (!flag) break;
if (j == k - 1) cans += (n - i);
}
ans = max(ans, cans);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, m, k;
int a[50];
int main(void) {
int i, j, l;
while (scanf("%lld%lld%lld", &n, &k, &m) != EOF) {
long long ans = 0, sum = 0, x = 0, y = 0, z = 0, m1 = 0;
for (i = 1; i <= k; i++) {
scanf("%d", &a[i]);
m1 += a[i];
}
sort(a + 1, a + k + 1);
for (i = 0; i <= n; i++) {
x = m1 * i;
if (x > m) break;
sum = x;
y = (k + 1) * i;
for (j = 1; j <= k; j++) {
for (l = i + 1; l <= n; l++) {
sum += a[j];
y++;
if (sum > m) {
y--;
j = k + 1;
break;
}
}
}
ans = max(ans, y);
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, total;
cin >> n >> k >> total;
vector<int> vec(k, 0);
int onePassSum = 0;
for (int i = 0; i < k; i++) {
cin >> vec[i];
onePassSum += vec[i];
}
sort(vec.begin(), vec.end());
int mx = 0;
for (int i = 0; i <= n; i++) {
int tempTotal = total;
int curr = 0;
if (i * onePassSum > tempTotal) {
break;
}
curr = (k + 1) * i;
tempTotal -= i * onePassSum;
int j = 0;
while (tempTotal > 0 && j < k) {
int val = min(n - i, tempTotal / vec[j]);
curr += val;
tempTotal -= (vec[j] * val);
j++;
}
mx = max(mx, curr);
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, m, a[55], b[55], x;
long double f[55][5050], c[55], now, res;
void doit() {
for (int i = 0; i <= m; i++) f[n + 1][i] = 0;
for (int i = n; i > 0; i--) {
for (int j = 0; j <= m; j++) {
f[i][j] =
c[i] * (a[i] + (j + a[i] > m ? now : min(f[i + 1][j + a[i]], now)));
f[i][j] += (1 - c[i]) *
(b[i] + (j + b[i] > m ? now : min(f[i + 1][j + b[i]], now)));
}
}
res = f[1][0];
}
int main() {
scanf("%d%d", &n, &m);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", a + i, b + i, &x);
c[i] = x / 100.0;
}
long double l = 0.0, r = 1000000000.0;
for (int i = 1; i <= 233; i++) {
now = (l + r) / 2.0;
doit();
if (res > now) {
l = now;
} else {
r = now;
}
}
printf("%.233lf", (double)l);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 1e9 + 7;
const int maxn = 55;
const int maxr = 5500;
int n;
double R;
double f[maxn], s[maxn], p[maxn];
double dp[maxn][maxr];
void reset() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j < maxr; j++) {
dp[i][j] = 0;
}
}
}
double get(double t) {
reset();
for (int i = n - 1; i >= 0; i--) {
for (int r = 0; r <= R; r++) {
double& cur = dp[i][r] = 0;
if (r + f[i] <= R) {
cur += p[i] * (f[i] + dp[i + 1][int(r + f[i])]);
if (r + s[i] <= R) {
cur += (1 - p[i]) * (s[i] + dp[i + 1][int(r + s[i])]);
} else {
cur += (1 - p[i]) * (s[i] + t);
}
} else {
cur = t;
}
cur = min(cur, t);
}
}
return dp[0][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> R;
for (int i = 0; i < n; i++) {
cin >> f[i] >> s[i] >> p[i];
p[i] = p[i] / 100;
}
double lo = 0;
double hi = 1e9;
for (int iter = 0; iter < 500; iter++) {
double mid = (lo + hi) / 2;
if (get(mid) < mid) {
hi = mid;
} else {
lo = mid;
}
}
cout << fixed << setprecision(12) << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
bool Max(T1& a, T2 b) {
return a < b ? a = b, 1 : 0;
}
template <typename T1, typename T2>
bool Min(T1& a, T2 b) {
return a > b ? a = b, 1 : 0;
}
const int N = 100, inf = 1e9 + 1;
int fast[N], slow[N], p[N];
int n, cap;
bool lt(double m) {
vector<double> f(cap + 1, 0);
int mx = cap + 1;
for (int i = n - 1; i >= (0); --i) {
for (int t = 0; t < (mx); ++t) {
if (t + fast[i] >= mx) {
mx = t;
break;
}
double v = (fast[i] + f[t + fast[i]]) * p[i];
v += (slow[i] + (t + slow[i] >= mx ? m : f[t + slow[i]])) * (100 - p[i]);
v /= 100;
if (v >= m) {
mx = t;
break;
}
f[t] = v;
}
}
return mx;
}
void solve() {
cin >> n >> cap;
for (int i = 0; i < (n); ++i) cin >> fast[i] >> slow[i] >> p[i];
double l = 0, r = 1e9;
for (int it = 0; it < (60); ++it) {
double m = (l + r) / 2;
if (lt(m))
r = m;
else
l = m;
}
cout << l << '\n';
}
void init() {}
int main(void) {
ios::sync_with_stdio(false);
cin.tie(0);
cout.setf(ios::fixed);
cout.precision(20);
init();
int TC = 1;
for (int TI = 1; TI <= (TC); ++TI) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<ii>;
using vs = vector<string>;
const double PI = acos(-1.0);
const double EPS = 1e-14;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFLL = 4e18;
const int MAX = 50;
struct data {
int fast, slow;
double ch;
};
int N, R;
data arr[MAX + 5];
double memo[MAX + 5][6000];
double top = 1e18, bot = 0.0, mid;
void read() {
cin >> N >> R;
for (int i = 0; i < (int)N; i++) {
cin >> arr[i].fast >> arr[i].slow >> arr[i].ch;
}
}
double dp(int pos, int cur) {
double &ret = memo[pos][cur];
if (ret <= -0.8) {
if (cur > R)
ret = mid;
else if (pos == N)
ret = 0.0;
else {
ret = arr[pos].ch / 100.0 *
(arr[pos].fast + dp(pos + 1, cur + arr[pos].fast)) +
(100 - arr[pos].ch) / 100.0 *
(arr[pos].slow + dp(pos + 1, cur + arr[pos].slow));
ret = min(ret, mid);
}
}
return ret;
}
void solve() {
for (int loop = 0; loop < (int)200; loop++) {
mid = (top + bot) / 2.0;
for (int i = 0; i < (int)MAX + 5; i++)
for (int j = 0; j < (int)6000; j++) memo[i][j] = -1.0;
if (dp(0, 0) >= mid)
bot = mid;
else
top = mid;
}
cout << fixed << setprecision(12) << (top + bot) / 2.0 << "\n";
}
int main() {
int TC = 1;
while (TC--) {
read();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void out(T x) {
cout << x << endl;
exit(0);
}
const long long mod = 1e9 + 7;
const int maxn = 55;
const int maxr = 5500;
int n;
double R;
double f[maxn], s[maxn], p[maxn];
double dp[maxn][maxr];
void reset() {
for (int i = 0; i <= n; i++) {
for (int j = 0; j < maxr; j++) {
dp[i][j] = 0;
}
}
}
double get(double t) {
reset();
for (int i = n - 1; i >= 0; i--) {
for (int r = 0; r <= R; r++) {
double& cur = dp[i][r] = 0;
if (r + f[i] <= R) {
cur += p[i] * (f[i] + dp[i + 1][int(r + f[i])]);
if (r + s[i] <= R) {
cur += (1 - p[i]) * (s[i] + dp[i + 1][int(r + s[i])]);
} else {
cur += (1 - p[i]) * (s[i] + t);
}
cur = min(cur, t);
} else {
cur = t;
}
}
}
return dp[0][0];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cin >> n;
cin >> R;
for (int i = 0; i < n; i++) {
cin >> f[i] >> s[i] >> p[i];
p[i] = p[i] / 100;
}
double lo = 0;
double hi = 1e9;
for (int iter = 0; iter < 500; iter++) {
double mid = (lo + hi) / 2;
if (get(mid) < mid) {
hi = mid;
} else {
lo = mid;
}
}
cout << fixed << setprecision(12) << lo << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
const int maxm = 5e4 + 5;
int n, r;
double p[maxn], f[maxn], s[maxn];
double dp[maxn][maxm];
double dfs(int l, int t, double e) {
if (t > r) return e;
if (l == n) return 0;
if (dp[l][t] != -1.0) return dp[l][t];
dp[l][t] = p[l] * (f[l] + dfs(l + 1, t + f[l], e)) +
(1 - p[l]) * (s[l] + dfs(l + 1, t + s[l], e));
dp[l][t] = min(e, dp[l][t]);
return dp[l][t];
}
double calc(double e) {
for (int i = 0; i < maxn; i++) {
for (int j = 0; j < maxm; j++) {
dp[i][j] = -1.0;
}
}
return dfs(0, 0, e);
}
int main() {
cin >> n >> r;
for (int i = 0; i < n; i++) {
cin >> f[i] >> s[i] >> p[i];
p[i] = p[i] / 100.0;
}
double lo = 0, hi = 1e17 + 5;
for (int i = 0; i < 200; i++) {
double mid = (lo + hi) / 2.0;
if (calc(mid) < mid)
hi = mid;
else
lo = mid;
}
cout << fixed << setprecision(9) << lo << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50, maxm = 5e3 + 100;
int n, lim, f[maxn + 3], s[maxn + 3];
double p[maxn + 3], q[maxn + 3], dp[maxn + 3][maxm + 3];
bool check(double x) {
for (int i = n; i; i--) {
for (int j = lim + 1; j <= lim + 100; j++) {
dp[i + 1][j] = x;
}
for (int j = 0; j <= lim; j++) {
dp[i][j] = min(x, (dp[i + 1][j + f[i]] + f[i]) * p[i] +
(dp[i + 1][j + s[i]] + s[i]) * q[i]);
}
}
return dp[1][0] == x;
}
int main() {
scanf("%d %d", &n, &lim);
for (int i = 1, x; i <= n; i++) {
scanf("%d %d %d", &f[i], &s[i], &x);
p[i] = x / 100., q[i] = (100 - x) / 100.;
}
double l = 0, r = 1e9, mid;
for (int k = 0; k < 70; k++) {
mid = (l + r) / 2;
if (check(mid)) {
l = mid;
} else {
r = mid;
}
}
printf("%.12lf\n", (l + r) / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int64_t infll = 9223372036854775807LL;
bool tryEV(double ev, int64_t R, int64_t N, vector<int64_t> f,
vector<int64_t> s, vector<double> p) {
vector<vector<double>> dp(N);
for (int64_t i = (0); i < (N); ++i) dp[i].assign(R + 1, 0.0);
for (int64_t i = N - 1; i >= 0; i--) {
double ff = (double)f[i];
double ss = (double)s[i];
for (int64_t t = R; t >= 0; t--) {
double evplay;
double goodtime = (i == N - 1) ? ff : ff + dp[i + 1][t];
double badtime = (t - s[i] + f[i] < 0) ? ss + ev
: (i == N - 1) ? ss
: ss + dp[i + 1][t - s[i] + f[i]];
evplay = p[i] * goodtime + (1.0 - p[i]) * badtime;
dp[i][t] = min(evplay, ev);
}
}
return dp[0][R] < ev;
}
void solve() {
int64_t N, R;
cin >> N >> R;
vector<double> P(N);
vector<int64_t> f(N);
vector<int64_t> s(N);
for (int64_t i = (0); i < (N); ++i) {
int64_t pp;
cin >> f[i] >> s[i] >> pp;
P[i] = 0.01 * (double)pp;
R -= f[i];
}
double mintime = 0;
for (int64_t i = (0); i < (N); ++i) {
mintime += (double)f[i];
}
double maxtime = 10.0 * mintime;
while (!tryEV(maxtime, R, N, f, s, P)) {
mintime = maxtime;
maxtime *= 10;
}
while (0.5 * (maxtime - mintime) / max(1.0, mintime) > 1e-10) {
double mid = 0.5 * (maxtime + mintime);
if (tryEV(mid, R, N, f, s, P))
maxtime = mid;
else
mintime = mid;
}
cout << 0.5 * (maxtime + mintime) << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout << fixed << setprecision(15);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int F[55], S[55];
double P[55];
double dp[55][5005];
const double inf = 0x3f3f3f3f;
int main() {
int N, R;
double f, s, p;
cin >> N >> R;
for (int i = 1; i <= N; i++) cin >> F[i] >> S[i] >> p, P[i] = p / 100;
double l = 0, r = 1e15;
double mid;
for (int k = 1; k < 100; k++) {
mid = (l + r) / 2;
for (int t = 1; t <= R; t++) dp[N + 1][t] = t;
for (int t = R + 1; t < 5005; t++) dp[N + 1][t] = inf;
for (int i = N; i >= 1; i--)
for (int t = 0; t < 5005; t++)
dp[i][t] =
min(mid + (double)(t + F[i]), dp[i + 1][t + F[i]]) * P[i] +
min(mid + (double)(t + S[i]), dp[i + 1][t + S[i]]) * (1 - P[i]);
if (dp[1][0] > mid)
l = mid;
else
r = mid;
}
printf("%.9f\n", mid);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, r;
int f[55], s[55];
double p[55];
double dp[55][6010];
int main(int argc, char const *argv[]) {
scanf("%d%d", &n, &r);
for (int i = 0; i < n; ++i) {
cin >> f[i] >> s[i] >> p[i];
p[i] /= 100.0;
}
double st = 0, en = (double)1e12;
double mid;
for (int t = 0; t <= 100; t++) {
mid = (st + en) * (0.5);
for (int i = 0; i < 5010; i++) dp[n][i] = i <= r ? i : (double)1e100;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j < 5010; j++) {
dp[i][j] = p[i] * min(j + f[i] + mid, dp[i + 1][j + f[i]]) +
(1.0 - p[i]) * min(j + s[i] + mid, dp[i + 1][j + s[i]]);
}
}
if (mid < dp[0][0])
st = mid;
else
en = mid;
}
mid = (st + en) * 0.5;
printf("%.15f\n", mid);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50 + 5;
const int M = N * 100 + 5;
int n, r, f[N], s[N], p[N];
double dp[N][M], mid;
double cal(int x, int y) { return y > r ? mid : dp[x][y]; }
void solve() {
scanf("%d%d", &n, &r);
for (int i = 0; i < n; i++) scanf("%d%d%d", &f[i], &s[i], &p[i]);
double lo = 0, hi = 1e9;
for (int _ = 0; _ < 120; _++) {
mid = (lo + hi) / 2.0;
for (int i = 0; i <= r; i++) dp[n][i] = 0;
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= r; j++) {
dp[i][j] =
min(mid, 0.01 * ((cal(i + 1, j + f[i]) + f[i]) * p[i] +
(cal(i + 1, j + s[i]) + s[i]) * (100 - p[i])));
}
}
if (dp[0][0] >= mid)
lo = mid;
else
hi = mid;
}
printf("%.17f\n", lo);
}
int main() {
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MxN = 50;
const int MxX = MxN * 100;
int n, R;
int F[MxN], S[MxN];
long double P[MxN];
long double dp[MxN + 1][MxX + 1];
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
cout << fixed << setprecision(10);
cin >> n >> R;
for (int i = 0; i < n; ++i) {
cin >> F[i] >> S[i] >> P[i];
P[i] /= 100;
}
const long double eps = 1e-10;
long double lo = 0, hi = 1e10;
while (hi - lo > eps) {
const long double mid = (lo + hi) / 2;
for (int i = n; i >= 0; --i) {
for (int j = 0; j <= MxX; ++j) {
long double &res = dp[i][j];
if (j > R)
res = mid;
else if (i == n)
res = 0;
else
res = min(mid, P[i] * (F[i] + dp[i + 1][j + F[i]]) +
(1 - P[i]) * (S[i] + dp[i + 1][j + S[i]]));
}
}
if (dp[0][0] < mid)
hi = mid;
else
lo = mid;
}
cout << dp[0][0];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const int maxn = 50 + 5;
const int maxr = 5000 + 5;
long double dp1[maxn][maxr];
long double dp[maxn][maxr];
int n, r;
int s[maxn], f[maxn];
int postsum[maxn];
int top = 0;
long double p[maxn];
const long double eps = 1e-9;
bool check(long double q) {
for (int i = 0; i <= r; i++) {
dp[n][i] = 0;
}
for (int i = r + 1; i <= top; i++) {
dp[n][i] = q;
}
for (int i = n - 1; i >= 0; i--) {
for (int j = 0; j <= top; j++) {
dp[i][j] = p[i] * min(q + f[i], dp[i + 1][j + f[i]] + f[i]) +
(1 - p[i]) * min(q + s[i], dp[i + 1][j + s[i]] + s[i]);
}
}
if (dp[0][0] >= q) {
return true;
} else {
return false;
}
}
int main() {
while (~scanf("%d%d", &n, &r)) {
top = 0;
for (int i = 0; i < n; i++) {
scanf("%d%d%Lf", f + i, s + i, p + i);
top += s[i];
p[i] /= 100.0L;
}
long double L = 0, R = 1e9 + 7;
while (L + eps < R) {
const long double mid = L + (R - L) / 2;
if (check(mid)) {
L = mid;
} else {
R = mid;
}
}
printf("%.10Lf\n", L);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long modpow(long long a, long long b,
long long mod = (long long)(1e9 + 7)) {
if (!b) return 1;
a %= mod;
return modpow(a * a % mod, b / 2, mod) * (b & 1 ? a : 1) % mod;
}
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
const int maxn = 50, maxr = 5000;
int n, r;
long double K;
long double S[maxn], F[maxn], p[maxn];
long double E[maxn][maxr + 1];
void init(long double mid) {
K = mid;
for (int i = 0; i < maxn; i++)
for (int j = 0; j < maxr + 1; j++) E[i][j] = -1;
}
long double dp(int i, int j) {
if (j < 0)
return K;
else if (i == n)
return 0;
else if (E[i][j] != -1)
return E[i][j];
else {
return E[i][j] = min(K, p[i] * (dp(i + 1, j - F[i]) + F[i]) +
(1 - p[i]) * (dp(i + 1, j - S[i]) + S[i]));
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
clock_t start = clock();
while (cin >> n >> r) {
for (int i = 0; i < n; i++) {
cin >> F[i] >> S[i] >> p[i];
p[i] /= 100.0;
}
long double lo = 0, hi = 1e9;
for (int _ = 0; _ < 100; _++) {
long double mid = (lo + hi) / 2;
init(mid);
if (dp(0, r) == mid)
lo = mid;
else
hi = mid;
}
cout << setprecision(12) << lo << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
const long double inf = 1e13;
const long double max_x = 5e8;
const long double eps = 1e-10;
int n, r;
std::vector<long double> prob;
std::vector<int> fast, slow;
std::vector<std::vector<int> > used;
std::vector<std::vector<long double> > dp;
long double get_dp(int i, int j) {
if (j < 0) return dp[0][r];
if (used[i][j] == 1) {
return dp[i][j];
} else {
if (i != n) {
dp[i][j] =
std::min(dp[0][r], prob[i] * (fast[i] + get_dp(i + 1, j - fast[i])) +
(1.0 - prob[i]) *
(slow[i] + get_dp(i + 1, j - slow[i])));
} else {
dp[i][j] = 0;
}
used[i][j] = 1;
return dp[i][j];
}
}
int main() {
std::cin >> n >> r;
fast.resize(n);
slow.resize(n);
prob.resize(n);
for (size_t i = 0; i < n; ++i) {
int temp_p;
std::cin >> fast[i] >> slow[i] >> temp_p;
prob[i] = 0.01 * temp_p;
}
long double lx = 0, rx = max_x, mx;
while (rx - lx > eps) {
mx = (lx + rx) / 2.0;
dp.assign(n + 1, std::vector<long double>(r + 1, -1));
used.assign(n + 1, std::vector<int>(r + 1, 0));
used[0][r] = 1;
dp[0][r] = mx;
long double calc = prob[0] * (fast[0] + get_dp(1, r - fast[0])) +
(1.0 - prob[0]) * (slow[0] + get_dp(1, r - slow[0]));
if (calc < mx) {
rx = mx;
} else {
lx = mx;
}
}
std::cout << std::fixed;
std::cout << std::setprecision(14) << lx << std::endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void io() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.precision(15);
}
int n, r;
long double dp[55][5005];
bool vis[55][5005];
long double F[55], S[55], P[55];
const long double EPS = -1e14;
long double solve(int l, int t, long double lim) {
if (vis[l][t]) return dp[l][t];
vis[l][t] = 1;
long double& ret = dp[l][t];
if (t > r) return (ret = lim);
if (l > n) return (ret = 0.0);
ret = P[l] * (F[l] + min(lim, solve(l + 1, t + F[l], lim))) +
(1.0 - P[l]) * (S[l] + min(lim, solve(l + 1, t + S[l], lim)));
return ret;
}
int main(int argc, char* argv[]) {
io();
cin >> n >> r;
for (int i = 1; i <= n; i++) {
cin >> F[i] >> S[i] >> P[i];
P[i] /= 100.0;
}
long double lo = 0.0;
long double hi = 1e9;
long double ans = r;
for (int iter = 0; iter < 100; iter++) {
long double mid = (lo + hi) / 2.0;
memset(vis, 0, sizeof(vis));
long double val = solve(1, 0, mid);
if (val <= mid) {
ans = mid;
hi = mid;
} else {
lo = mid;
}
}
cout << ans << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[(50 + 10)][(5000 + 100)], p[(50 + 10)];
int n, r, s[(50 + 10)], f[(50 + 10)], top = 0;
bool check(double t) {
for (int i = 0; i <= r; i++) dp[n][i] = 0;
for (int i = r + 1; i <= top; i++) dp[n][i] = t;
for (int i = n - 1; i >= 0; i--)
for (int j = 0; j <= top; j++)
dp[i][j] = p[i] * min(t + f[i], dp[i + 1][j + f[i]] + f[i]) +
(1 - p[i]) * min(t + s[i], dp[i + 1][j + s[i]] + s[i]);
return dp[0][0] > t;
}
double findAns() {
double l = 0, r = (1000000000), ans;
for (int i = 0; i < 100; i++) {
long double mid = (l + r) / 2.0;
if (check(mid))
ans = mid, l = mid;
else
r = mid;
}
return ans;
}
void init() {
scanf("%d%d", &n, &r);
for (int i = 0; i < n; i++) {
scanf("%d%d%lf", &f[i], &s[i], &p[i]);
p[i] /= 100.0;
top += s[i];
}
}
int main() {
init();
return printf("%.10lf", findAns()), 0;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline bool EQ(double a, double b) { return fabs(a - b) < 1e-9; }
double mn, mx, mid, dp[55][5007], p[55];
int mark, R, n, f[55], s[55], vis[55][5007];
double first(int i, int t) {
if (t > R) return mid;
if (i == n) return 0;
double &ret = dp[i][t];
if (vis[i][t] == mark) return ret;
vis[i][t] = mark;
ret = min(mid, p[i] * (f[i] + first(i + 1, t + f[i])) +
(1 - p[i]) * (s[i] + first(i + 1, t + s[i])));
return ret;
}
int main() {
int i;
scanf("%d %d", &n, &R);
for (i = 0; i < n; i++) {
scanf("%d %d %lf", &f[i], &s[i], &p[i]);
p[i] /= 100.0;
}
mn = 0;
mx = 1e15;
for (i = 1; i <= 1000; i++) {
mid = (mx + mn) / 2.0;
mark++;
if (first(0, 0) < mid)
mx = mid;
else
mn = mid;
}
printf("%.10lf\n", mn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
double dp[55][5005];
bool vis[55][5005];
int n, r;
double p[55];
int fast[55], slow[55], ispos[55];
double prv;
double solve(int now, int tot) {
if (tot > r) return 1e100;
if (now == n) return 0.0;
if (vis[now][tot]) return dp[now][tot];
vis[now][tot] = 1;
double &ret = dp[now][tot];
ret =
p[now] * (fast[now] + solve(now + 1, tot + fast[now])) +
(1.0 - p[now]) * (slow[now] + min(solve(now + 1, tot + slow[now]), prv));
if (ret > 1e80) ret = 1e100;
return ret;
}
int main() {
int i;
scanf("%d", &n);
scanf("%d", &r);
for (i = 0; i < n; i++) {
scanf("%d", &fast[i]);
scanf("%d", &slow[i]);
int x;
scanf("%d", &x);
p[i] = (double)x / 100.0;
}
cout << fixed << setprecision(15);
double l = 0, r = 1e20;
for (i = 0; i < 205; i++) {
double mid = (l + r) / 2.0;
memset(vis, 0, sizeof(vis));
prv = mid;
double now = solve(0, 0);
if (now > mid)
l = mid;
else
r = mid;
}
cout << r << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, r;
vector<vector<long long> > v;
long double solve() {
vector<vector<long double> > dp(n + 1, vector<long double>(r + 1, 0.l));
long double lo = 0, hi = (1e20), mid, eps = 1e-11;
while ((hi - lo) > eps) {
mid = (lo + hi) / 2.l;
for (int i = n - 1; i >= 0; i--) {
for (int j = r; j >= 0; j--) {
if (v[i][0] + j <= r) {
dp[i][j] = (dp[i + 1][v[i][0] + j] + v[i][0]) * (v[i][2] / 100.l);
if (v[i][1] + j <= r)
dp[i][j] +=
(dp[i + 1][v[i][1] + j] + v[i][1]) * (1.l - (v[i][2] / 100.l));
else
dp[i][j] += (v[i][1] + mid) * (1.l - (v[i][2] / 100.l));
} else
dp[i][j] = mid;
dp[i][j] = min(mid, dp[i][j]);
}
}
if (dp[0][0] == mid)
lo = mid;
else
hi = mid;
}
return mid;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r;
v.assign(n, vector<long long>(3, 0));
for (int i = 0; i < n; i++) cin >> v[i][0] >> v[i][1] >> v[i][2];
cout << fixed << setprecision(10) << solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
cin.tie(0);
ios::sync_with_stdio(false);
int n, R;
cin >> n >> R;
vector<double> a(n + 5), b(n + 5), c(n + 5);
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
c[i] /= 100.0;
}
auto ck = [&](double mid) {
vector<vector<double>> f(n + 5, vector<double>(5105));
for (int i = n; i >= 1; --i) {
for (int j = 0; j <= R; ++j) {
for (int j = R + 1; j <= R + 100; ++j) f[i + 1][j] = mid;
f[i][j] = min(mid, (f[i + 1][j + a[i]] + a[i]) * c[i] +
(f[i + 1][j + b[i]] + b[i]) * (1.0 - c[i]));
}
}
return mid <= f[1][0];
};
auto bf = [&]() {
double l = 0, r = 1e9;
for (int i = 100; i; --i) {
double mid = (l + r) / 2.0;
if (ck(mid))
l = mid;
else
r = mid;
}
printf("%.12f", l);
};
bf();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ii = pair<int, int>;
using pll = pair<ll, ll>;
using pdd = pair<double, double>;
using vi = vector<int>;
using vii = vector<ii>;
using vs = vector<string>;
const double PI = acos(-1.0);
const double EPS = 1e-14;
const int MOD = 1e9 + 7;
const int INF = 1e9;
const ll INFLL = 4e18;
const int MAX = 50;
struct data {
int fast, slow;
double ch;
};
int N, R;
data arr[MAX + 5];
double memo[MAX + 5][6000];
double top = 1e18, bot = 0.0, mid;
void read() {
cin >> N >> R;
for (int i = 0; i < (int)N; i++) {
cin >> arr[i].fast >> arr[i].slow >> arr[i].ch;
arr[i].ch /= 100.0;
}
}
double dp(int pos, int cur) {
double &ret = memo[pos][cur];
if (ret <= -0.8) {
if (cur > R)
ret = mid;
else if (pos == N)
ret = 0.0;
else {
ret = arr[pos].ch * (arr[pos].fast + dp(pos + 1, cur + arr[pos].fast)) +
(1.0 - arr[pos].ch) *
(arr[pos].slow + dp(pos + 1, cur + arr[pos].slow));
ret = min(ret, mid);
}
}
return ret;
}
void solve() {
for (int loop = 0; loop < (int)200; loop++) {
mid = (top + bot) / 2.0;
for (int i = 0; i < (int)MAX + 5; i++)
for (int j = 0; j < (int)6000; j++) memo[i][j] = -1.0;
if (dp(0, 0) >= mid)
bot = mid;
else
top = mid;
}
cout << fixed << setprecision(10) << (top + bot) / 2.0 << "\n";
}
int main() {
int TC = 1;
while (TC--) {
read();
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, r;
vector<vector<long long> > v;
long double solve() {
vector<vector<long double> > dp(n + 1, vector<long double>(r + 1, 0.l));
long double lo = 0, hi = (1e20), mid, eps = 1e-11;
while ((hi - lo) > eps) {
mid = (lo + hi) / 2.l;
for (int i = n - 1; i >= 0; i--) {
for (int j = r; j >= 0; j--) {
if (v[i][0] + j <= r) {
dp[i][j] = (dp[i + 1][v[i][0] + j] + v[i][0]) * (v[i][2] / 100.l);
if (v[i][1] + j <= r)
dp[i][j] +=
(dp[i + 1][v[i][1] + j] + v[i][1]) * (1.l - (v[i][2] / 100.l));
else
dp[i][j] += (v[i][1] + mid) * (1.l - (v[i][2] / 100.l));
} else
dp[i][j] = mid;
dp[i][j] = min(mid, dp[i][j]);
}
}
if (dp[0][0] == mid)
lo = mid;
else
hi = mid;
}
return mid;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> r;
v.assign(n, vector<long long>(3, 0));
for (int i = 0; i < n; i++) cin >> v[i][0] >> v[i][1] >> v[i][2];
cout << fixed << setprecision(10) << solve();
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.