text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l, sum, ans, h;
while (scanf("%d%d%d%d%d", &c, &v0, &v1, &a, &l) != EOF) {
sum = 0;
ans = 0;
h = 0;
for (int i = v0; i <= v1;) {
if (sum >= c) break;
ans++;
if (h > l)
sum += i - l;
else
sum += i - h;
h = i;
if (i + a <= v1)
i += a;
else
i = v1;
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v, v1, a, l, ans = 0;
cin >> c >> v >> v1 >> a >> l;
int ok = 0;
while (ok < c) {
++ans;
ok = max(ok - l, 0);
ok += min(v, v1);
v += a;
}
cout << ans;
exit(0);
}
|
#include <bits/stdc++.h>
using namespace std;
long long arr[100100], n, ans, c, v0, v1, a, l, temp;
int main() {
cin >> c >> v0 >> v1 >> a >> l;
while (1) {
ans++;
temp += v0;
if (temp >= c) return cout << ans << endl, 0;
v0 += a;
v0 = min(v0, v1);
temp -= l;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
int count = 0;
int i = 1;
if (c == v0) {
count++;
cout << count;
} else {
c = c - v0;
count++;
while (c > 0) {
if ((v0 + (i * a)) <= v1) {
c = c - (v0 + (i * a) - l);
count++;
i++;
} else {
c = c - v1 + l;
count++;
}
}
cout << count;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int c, v0, v1, a, l;
cin >> c >> v0 >> v1 >> a >> l;
long int sum = 0;
long int day = 0;
while (sum < c) {
sum = sum + v0;
day++;
if (sum >= c) {
break;
}
v0 = v0 + a;
if (v0 > v1) {
v0 = v1;
}
sum = sum - l;
}
cout << day;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int c, v0, v1, a, l, k, tmp, ret;
bool b;
int main() {
cin >> c >> v0 >> v1 >> a >> l;
k = (v1 - v0) / 2 + 1;
tmp = k * v0 + (k - 1) * (k - 2) * a / 2 - (k - 1) * l;
c -= v0;
ret++;
while (c > 0) {
if (v0 + ret * a >= v1) {
b = true;
break;
}
c -= v0 + ret * a - l;
ret++;
}
if (b)
while (c > 0) {
c -= v1 - l;
ret++;
}
cout << ret;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = numeric_limits<int>::max();
const long long LLINF = numeric_limits<long long>::max();
const unsigned long long ULLINF = numeric_limits<unsigned long long>::max();
const double PI = acos(-1.0);
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
long long t[50];
long long n, k, M;
cin >> n >> k >> M;
long long sum = 0;
for (int i = 0; i < k; i++) cin >> t[i], sum += t[i];
sort(t, t + k);
long long ans = 0;
for (int s = 0; s <= n; s++) {
if (sum * s > M) break;
long long p = n - s;
long long T = M - sum * s;
long long cur = (k + 1) * s;
for (int i = 0; i < k; i++) {
long long take = min(T / t[i], p);
cur += take;
T -= take * t[i];
}
ans = max(ans, cur);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a[50], all, ans;
int _try(int x) {
int t = m - x * all;
int points = x * (k + 1);
if (t < 0) return 0;
for (int j = 0; j < k; j++)
for (int i = 0; i < n - x; i++)
if (t >= a[j]) t -= a[j], points++;
return points;
}
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < k; i++) scanf("%d", &a[i]), all += a[i];
sort(a, a + k);
for (int i = 0; i <= n; i++) ans = max(ans, _try(i));
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxN = 50;
const long long INF = (long long)1e18;
long long dp[maxN][maxN * maxN], a[maxN], sum[maxN];
void upd(long long& a, long long b) { a = min(a, b); }
int main() {
ios_base::sync_with_stdio(false);
int n, k, M;
cin >> n >> k >> M;
for (int i = 1; i <= k; ++i) cin >> a[i];
sort(a + 1, a + k + 1);
sum[0] = 0;
for (int i = 1; i <= k; ++i) sum[i] = sum[i - 1] + a[i];
for (int i = 0; i <= n; ++i) {
for (int j = 0; j <= n * (k + 1); ++j) {
dp[i][j] = INF;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j <= (k + 1) * n; ++j) {
if (dp[i][j] == INF) continue;
for (int ne = 0; ne <= k; ++ne) {
upd(dp[i + 1][j + ne + (ne == k)], dp[i][j] + sum[ne]);
}
}
}
int ans = -1;
for (int i = 0; i <= (k + 1) * n; ++i) {
if (dp[n][i] <= M) ans = max(ans, i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios_base::sync_with_stdio(0);
cin.tie(0);
cout.precision(10);
int n, k, m, result = 0, sumTime = 0, sumCost;
cin >> n >> k >> m;
vector<int> t(k);
for (size_t i = 0; i < k; ++i) {
cin >> t[i];
sumTime += t[i];
}
sumCost = k + 1;
sort(t.begin(), t.end());
for (size_t i = 0; i <= n; ++i) {
int remainingTime = m - i * sumTime;
if (remainingTime < 0) {
break;
}
int newResult = sumCost * i;
for (const auto subProblemTime : t) {
int countSolved = min((int)(n - i), remainingTime / subProblemTime);
newResult += countSolved;
remainingTime -= countSolved * subProblemTime;
}
result = max(result, newResult);
}
cout << result << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 998244353;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n, k, m, tot = 0;
cin >> n >> k >> m;
vector<int> v(k);
for (int& i : v) {
cin >> i;
tot += i;
}
sort(v.begin(), v.end());
int ans = 0;
for (int i = 0; i <= n; i++) {
int rem = m - i * tot;
if (rem < 0) continue;
int anst = i * (k + 1);
for (int j = 0; j < k && v[j] <= rem; j++) {
int mult = min(n - i, rem / v[j]);
anst += mult;
rem -= mult * v[j];
}
ans = max(ans, anst);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
std::ios::sync_with_stdio(false);
int n, k, m;
cin >> n >> k >> m;
int *t = new int[k];
int s = 0;
for (int i = 0; i < k; ++i) {
cin >> t[i];
s += t[i];
}
sort(t, t + k);
int ans = 0, q = 0;
while (q <= n && m >= s * q) {
int w = q * (k + 1);
int j = 0;
int e = m - s * q;
while (j < k && e >= t[j] * (n - q)) {
e -= t[j++] * (n - q);
w += n - q;
}
while (j < k && e >= t[j]) {
w++;
e -= t[j];
}
++q;
ans = max(ans, w);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 59;
int t[N];
inline int read() {
int s = 1, a = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') s = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
a = a * 10 + ch - '0';
ch = getchar();
}
return s * a;
}
int main() {
int n = read(), k = read(), m = read(), s = 0;
for (int i = 1; i <= k; i++) t[i] = read(), s += t[i];
sort(t + 1, t + k + 1);
long long res = 0;
for (int i = 0; i <= n; i++) {
long long tim = i * s, cur = i * (k + 1);
if (tim > m) break;
for (int j = 1; j <= k; j++) {
if (tim + (n - i) * t[j] <= m)
tim += (n - i) * t[j], cur += (n - i);
else {
while (tim + t[j] <= m) tim += t[j], cur++;
break;
}
}
res = max(res, cur);
}
return 0 * printf("%d\n", res);
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-ffloat-store")
#pragma GCC optimize("-fno-defer-pop")
long long int power(long long int a, long long int b, long long int m) {
if (b == 0) return 1;
if (b == 1) return a % m;
long long int t = power(a, b / 2, m) % m;
t = (t * t) % m;
if (b & 1) t = ((t % m) * (a % m)) % m;
return t;
}
long long int modInverse(long long int a, long long int m) {
return power(a, m - 2, m);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, j, k, l, n, M;
cin >> n >> k >> M;
long long int ar[k], s = 0;
for (i = 0; i < k; i++) {
cin >> ar[i];
s += ar[i];
}
sort(ar, ar + k);
long long int an = 0;
for (i = 0; i <= n; i++) {
long long int mx = 0, v = M, x;
if (v >= i * s) {
mx = i * (k + 1);
v = v - i * s;
for (j = 0; j < k; j++) {
x = min(v / ar[j], n - i);
mx = mx + x;
v = v - x * ar[j];
}
}
an = max(an, mx);
}
cout << an;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
const int K = 50;
long long t[K];
int main() {
ios_base::sync_with_stdio(0);
long long n, k, T;
cin >> n >> k >> T;
long long sumt = 0;
for (int i = 0; i < k; ++i) {
cin >> t[i];
sumt += t[i];
}
sort(t, t + k);
long long res = 0;
for (int x = 0; x <= n; ++x) {
long long score = x * (k + 1);
vector<long long> v;
for (int i = 0; i < k; ++i) {
for (int j = 0; j < n - x; ++j) {
v.push_back(t[i]);
}
}
long long rem = T - x * sumt;
if (rem < 0) continue;
int idx = 0;
while (idx < v.size() && rem - v[idx] >= 0) {
rem -= v[idx];
score += 1;
++idx;
}
res = max(res, score);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, M, ans, tot, now, ans_, d, i, j, e;
int t[50 + 5];
int main() {
for (scanf("%d%d%d", &n, &k, &M), i = 0; i < k; i++)
scanf("%d", &t[i]), tot += t[i];
sort(t, t + k);
for (e = 0; e <= n; e++) {
now = tot * e;
if (now > M) break;
ans_ = (k + 1) * e;
for (i = 0; i < k; i++) {
for (j = e + 1; j <= n; j++) {
now += t[i];
ans_++;
if (now > M) {
ans_--;
i = k + 1;
break;
}
}
}
ans = max(ans, ans_);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, nn, i, j, p = 0, l, sum = 0, a[46], x = 0, maxx = 0;
cin >> n >> k >> m;
for (i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (l = 0; l < n; l++) {
nn = m;
if (sum * l > m) continue;
m -= sum * l;
p += (k + 1) * l;
for (i = 0; i < k; i++) {
for (j = 0; j < n - l; j++) {
if (m - a[i] < 0) {
x = 1;
break;
}
if (i == k - 1)
p += 2;
else
p++;
m -= a[i];
}
x = 0;
}
m = nn;
maxx = max(maxx, p);
p = 0;
}
cout << maxx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const long long dx[4] = {-1, 1, 0, 0};
const long long dy[4] = {0, 0, -1, 1};
long long gcd(long long a, long long b) { return (b == 0 ? a : gcd(b, a % b)); }
long long n, m, k, l, y, x, z = 0, res = 0, ans = 0;
string s;
bool ok;
vector<long long> v;
void solve() {
ans = 0;
long long bigans = 0;
cin >> n >> k >> m;
long long sum = 0;
for (int i = 0; i < k; i++) cin >> x, v.push_back(x), sum += x;
sort(v.begin(), v.end());
for (long long nbt = 0; nbt <= n; nbt++) {
ans = 0;
if (sum * nbt > m) continue;
long long tmp = m;
tmp -= sum * nbt;
ans += nbt * (k + 1);
int prb = 0;
while (tmp && prb < k) {
for (int i = nbt + 1; i <= n; i++)
if (tmp - v[prb] >= 0) {
ans += 1 + (prb == k - 1);
tmp -= v[prb];
}
prb++;
}
bigans = max(ans, bigans);
}
cout << bigans << '\n';
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 108;
long long n, m, w, a[N], b[N];
long long maxx(long long x, long long y) {
if (x > y) y = x;
return y;
}
int main(void) {
long long i, j, k, ans, s;
scanf("%I64d%I64d%I64d", &n, &m, &w);
for (i = 1; i <= m; i++) scanf("%I64d", a + i);
sort(a + 1, a + 1 + m);
for (i = 1; i <= m; i++) b[i] = b[i - 1] + a[i];
ans = 0;
for (i = 0; i <= n && b[m] * i <= w; i++) {
s = i * (m + 1);
k = w - b[m] * i;
for (j = 1; j <= m; j++)
if ((n - i) * a[j] <= k) {
s += n - i;
k -= (n - i) * a[j];
} else {
s += k / a[j];
break;
}
ans = maxx(ans, s);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 45;
int t[MAXN + 1], n, k, M;
int comp(int n, int M) {
int score = 0, i = 1;
while (M && i <= k - 1) {
if (n * t[i] <= M) {
M -= n * t[i];
score += n;
} else {
score += (M / t[i]);
break;
}
i++;
}
return score;
}
int main() {
int totalSum = 0;
cin >> n >> k >> M;
for (int i = 1; i <= k; i++) {
cin >> t[i];
totalSum += t[i];
}
sort(t + 1, t + k + 1);
int score = 0, maxScore = 0, maxCompleteTasks = min(M / totalSum, n);
for (int i = 0; i <= maxCompleteTasks; i++) {
maxScore =
max(k * i + i + (n != i) * comp(n - i, M - i * totalSum), maxScore);
}
cout << maxScore;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
ios_base::sync_with_stdio(0);
long long n, k, m;
cin >> n >> k >> m;
vector<long long> a(k);
long long second = 0;
for (long long i = 0; i < k; i++) {
cin >> a[i];
second += a[i];
}
sort(a.begin(), a.end());
long long ans = 0;
for (long long p = 0; p <= n; p++) {
long long t = m - second * p;
long long kol = 0;
if (t < 0) break;
kol = p * (k + 1);
for (long long j = 0; j < k; j++) {
long long ost = n - p;
while (ost > 0 && t - a[j] >= 0) {
ost--;
t -= a[j];
kol++;
}
}
ans = max(ans, kol);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
long long sum[N], n, k;
long long cumm[N];
int main() {
int m;
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) scanf("%I64d", &sum[i]), cumm[i] = sum[i];
sort(sum, sum + k + 1);
for (int i = 1; i <= k; i++) cumm[i] += cumm[i - 1];
int ans = 0;
for (int i = 0; i <= n; i++) {
long long currTime = i * cumm[k];
if (currTime > m) break;
int leftTime = m - currTime;
int currScore = i * (k + 1);
int curr = 1;
while (curr <= k && leftTime > 0) {
if ((n - i) * sum[curr] <= leftTime) {
leftTime -= (n - i) * sum[curr];
currScore += n - i;
curr++;
} else {
break;
}
}
while (curr <= k && leftTime >= sum[curr])
currScore++, leftTime -= sum[curr];
ans = max(currScore, ans);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int tt[120];
int main() {
cin >> n >> k >> m;
int sm = 0;
for (int i = 0; i < k; ++i) cin >> tt[i], sm += tt[i];
sort(tt, tt + k);
int ans = 0;
for (int i = 0; i <= n; ++i) {
int t = m - i * sm;
if (t < 0) continue;
int now = k * i + i;
for (int j = 0; j < k; ++j) {
int go = min(n - i, t / tt[j]);
t -= go * tt[j];
now += go;
}
ans = max(ans, now);
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int gcd(int x, int y) {
int z;
while (y) {
z = x % y;
x = y;
y = z;
}
return x;
}
long long a[48];
long long s;
int main() {
ios_base::sync_with_stdio(false);
long long n, k, m;
int t = 0;
cin >> n >> k >> m;
for (int i = 1; i <= k; i++) {
cin >> a[i];
s += a[i];
}
sort(a + 1, a + k + 1);
for (int i = 0; i <= n; i++) {
int l = 0;
long long w = s * i;
l = k * i + i;
if (w > m) continue;
for (int j = 1; j <= k; j++) {
w += a[j] * (n - i);
if (w <= m)
l += (n - i);
else {
w -= a[j] * (n - i);
while (1) {
if (w + a[j] <= m) {
l++;
w += a[j];
} else
break;
}
break;
}
}
t = max(t, l);
}
cout << t;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void faster() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
}
const int MAXN = 2e5;
const long long MOD = 1e9 + 7;
const long long INF = 1e9;
long long n, k, T, m, a[MAXN], q[MAXN], ans, t, ans2;
int main() {
faster();
cin >> k >> n >> m;
for (int i = 0; i < n; ++i) {
cin >> a[i];
t += a[i];
}
sort(a, a + n);
for (int i = 0; i <= k; ++i) {
T = m - i * t;
long long res = i * (n + 1);
if (T < 0) continue;
bool flag = 1;
for (int j = i + 1; j <= k; ++j) q[j] = 0;
while (T > 0 && flag) {
flag = 0;
for (int j = i + 1; j <= k; ++j) {
if (q[j] < n && T >= a[q[j]]) {
T -= a[q[j]++];
res++;
flag = 1;
if (q[j] == n) res++;
}
}
}
ans = max(ans, res);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, M;
cin >> n >> k >> M;
vector<int> v;
int sum = 0;
for (int i = 0; i < k; i++) {
int val;
cin >> val;
sum += val;
v.push_back(val);
}
sort(v.begin(), v.end());
int maxi = 0;
for (int i = 0; i <= n; i++) {
int m = M - (i * sum);
int points = i * (k + 1);
for (int j = 0; j < k && m >= 0; j++) {
if (v[j] * (n - i) <= m) {
m -= v[j] * (n - i);
points += (n - i);
if (j == k - 1) points += (n - i);
} else {
int p = m / v[j];
points += p;
if (j == k - 1) points += p;
break;
}
}
if (m >= 0) {
maxi = max(maxi, points);
}
}
printf("%d\n", maxi);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, t;
cin >> n >> k >> t;
vector<int> v(k);
for (int i = 0; i < k; ++i) cin >> v[i];
sort(v.begin(), v.end());
int sum = 0;
for (int i = 0; i < v.size(); ++i) sum += v[i];
long long res = 0;
for (int f = 0; f <= n; ++f) {
long long cur = f * (long long)sum;
long long score = f * (k + 1);
int rem = n - f;
for (int j = 0; j < k && cur <= t; ++j)
for (int i = 0; i < rem && cur <= t; ++i) {
if (cur + v[j] > t) break;
++score;
cur += v[j];
}
if (cur <= t) res = max(res, score);
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[50];
int main() {
int n, k, m, sum = 0;
scanf("%d%d%d", &n, &k, &m);
for (int i = 0; i < k; i++) {
scanf("%d", &t[i]);
sum += t[i];
}
sort(t, t + k);
int ans = 0;
for (int i = 0; i <= n && m - sum * i >= 0; i++) {
int re = m - sum * i;
int temp = (k + 1) * i;
for (int j = 0; j < k; j++) {
int cnt = max(0, min(re / t[j], n - i));
re -= cnt * t[j];
temp += cnt;
}
ans = max(temp, ans);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
if (fopen("input.txt", "r")) {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
}
long long n, k, M, ans = 0, sum = 0;
cin >> n >> k >> M;
long long a[k];
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
long long time, mx = -1;
time = M;
for (int z = 0; z <= n; z++) {
M = time;
ans = 0;
if (M >= sum * z) {
M -= sum * z;
ans += z * k + z;
}
for (int i = 0; i < k; i++) {
if (M - a[i] * (n - z) >= 0) {
ans += n - z;
M -= a[i] * (n - z);
} else if (M - a[i] >= 0) {
long long cnt = M / a[i];
ans += M / a[i];
M -= cnt * a[i];
}
}
mx = max(ans, mx);
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int test = 1;
while (test--) {
int n, k;
cin >> n >> k;
long long int m, t[k], sum = 0;
cin >> m;
for (int i = 0; i < k; ++i) {
cin >> t[i];
sum += t[i];
}
if (sum * n <= m) {
cout << n * (k + 1);
exit(0);
}
vector<int> v;
for (int i = 0; i < n; ++i) {
if (1ll * i * sum <= m) v.push_back(i);
}
int arr[v.size()];
memset(arr, 0, sizeof(arr));
sort(t, t + k);
for (int i = 0; i < v.size(); ++i) {
long long int remtime = m - sum * i;
int num = i * (k + 1);
int flag = 0;
for (int j = 0; j < k - 1; j++) {
for (int l = 0; l < n - i; ++l) {
if (remtime - t[j] < 0) {
flag = 1;
break;
}
num++;
remtime -= t[j];
}
if (flag == 1) break;
}
if (flag == 0) {
for (int l = 0; l < n - i; ++i) {
if (remtime - t[k - 1] < 0) {
flag = 1;
break;
}
num += 2;
remtime -= t[k - 1];
}
}
arr[i] = num;
}
int maxi = 0;
for (int i = 0; i < v.size(); ++i) {
maxi = max(maxi, arr[i]);
}
cout << maxi;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 7;
const int N = 5e3 + 10;
int a[N];
long long ans[N];
int main() {
int n, k, m;
cin >> n >> k >> m;
int sum = 0;
for (int i = 1; i <= k; i++) cin >> a[i], sum += a[i];
sort(a + 1, a + k + 1);
int ans = 0;
for (int o = 0; o <= n; o++) {
if (o * sum > m) break;
int res = o * (k + 1);
int r = m - o * sum;
for (int i = 1; i <= k; i++) {
int x = min(r / a[i], n - o);
res += x;
r -= x * a[i];
}
ans = max(ans, res);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, i, m, k, a[11111], j, s, mx, m1, s1, x;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
cin >> n >> k >> m;
for (i = 1; i <= k; i++) {
cin >> a[i];
s += a[i];
}
sort(a + 1, a + 1 + k);
for (i = 0; i <= n; i++) {
s1 = 0;
m1 = m;
m1 = m1 - i * s;
s1 = i * (k + 1);
if (m1 > 0) {
for (j = 1; j <= k; j++) {
for (x = i + 1; x <= n; x++) {
if (m1 - a[j] >= 0) {
m1 = m1 - a[j];
s1++;
}
}
}
}
if (m1 >= 0) {
if (s1 > mx) {
}
mx = max(mx, s1);
}
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
class Solution {
public:
void solve(std::istream& in, std::ostream& out) {
long long n, k, m;
in >> n >> k >> m;
std::vector<long long> t(k);
for (long long i = 0; i < k; ++i) in >> t[i];
long long max_points = n * (k + 1);
std::vector<long long> dp(max_points + 1,
std::numeric_limits<long long>::max());
auto next_dp = dp;
std::sort(t.begin(), t.end());
std::partial_sum(t.begin(), t.end(), t.begin());
dp[0] = 0;
for (long long i = 0; i < n; ++i) {
std::fill(next_dp.begin(), next_dp.end(),
std::numeric_limits<long long>::max());
for (long long j = 0; j <= max_points; ++j) {
if (dp[j] < std::numeric_limits<long long>::max()) {
for (long long l = 0; l < k; ++l) {
if (dp[j] + t[l] <= m) {
auto points = j + ((l == k - 1) ? (k + 1) : (l + 1));
next_dp[points] = std::min(next_dp[points], dp[j] + t[l]);
}
}
next_dp[j] = std::min(dp[j], next_dp[j]);
}
}
std::swap(dp, next_dp);
}
out << prev(std::find_if(dp.rbegin(), dp.rend(),
[](long long x) {
return x < std::numeric_limits<long long>::max();
})
.base()) -
dp.begin()
<< '\n';
}
};
void solve(std::istream& in, std::ostream& out) {
out << std::setprecision(12);
Solution solution;
solution.solve(in, out);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
istream& in = cin;
ostream& out = cout;
solve(in, out);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxN = 1e6 + 5;
const long long inf = 1e10;
const long long mod = 1e9 + 7;
long long n, k, m, a[50], s;
int main() {
ios_base::sync_with_stdio(0);
cin >> n >> k >> m;
s = 0;
for (long long i = 1; i <= k; i++) {
cin >> a[i];
s += a[i];
}
sort(a + 1, a + 1 + k);
long long v = 0;
long long t = 0;
long long limit = min(m / s, n);
long long m1 = m;
for (long long i = 0; i <= limit; i++) {
m1 = m;
v = 0;
v += i * (k + 1);
m1 -= s * i;
long long dem = n - i;
for (long long j = 1; j <= k; j++) {
if (m1 >= a[j] * dem) {
v += dem;
m1 -= a[j] * dem;
} else {
v += m1 / a[j];
m1 = 0;
break;
}
}
t = max(t, v);
}
cout << t;
}
|
#include <bits/stdc++.h>
using namespace std;
int sol(const vector<long long>& a, int n, int m, long long t) {
long long s = 0;
for (int i = 0; i < m; i++) s += a[i];
int ans = 0;
for (int i = 0; i <= n && s * i <= t; i++) {
int cnt = (m + 1) * i;
long long r = t - s * i;
for (int j = 0; j < m && r >= a[j]; j++) {
int c = min(r / a[j], (long long)(n - i));
r -= a[j] * c;
cnt += c;
}
ans = max(ans, cnt);
}
return ans;
}
int main() {
int n, m;
long long t;
scanf("%d%d%lld", &n, &m, &t);
vector<long long> a(m);
for (int i = 0; i < m; i++) scanf("%lld", &a[i]);
sort(a.begin(), a.end());
printf("%d\n", sol(a, n, m, t));
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, a[49];
long long cs[49];
int get(int r, int sum) {
int ret = 0;
for (int i = 1; i <= k; ++i) {
int rep = n - r + 1;
while (sum >= a[i] && rep--) {
sum -= a[i];
++ret;
}
}
return ret;
}
int play(int lastC) {
int ret = 0, temp = m;
for (int r = 1; r <= n; ++r) {
if (temp >= cs[lastC]) {
temp -= cs[lastC];
int can = lastC * r;
if (lastC == k) {
can += r;
}
if (r + 1 <= n) {
can += get(r + 1, temp);
}
ret = max(ret, can);
} else {
break;
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> m;
for (int i = 1; i <= k; ++i) {
cin >> a[i];
}
sort(a + 1, a + k + 1);
for (int i = 1; i <= k; ++i) {
cs[i] = cs[i - 1] + a[i];
}
int ans = 0;
for (int i = 1; i <= k; ++i) {
ans = max(ans, play(i));
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
long long int maxx(long long int a, long long int b) { return a > b ? a : b; }
long long int minn(long long int a, long long int b) { return a > b ? b : a; }
using namespace std;
long long int gcd(long long int a, long long int b) {
return b == 0 ? a : gcd(b, a % b);
}
long long int lcm(long long int a, long long int b) {
return (a * b) / gcd(a, b);
}
long long int poww(long long int base, long long int exp) {
base %= 1000000007;
long long int result = 1;
while (exp > 0) {
if (exp & 1) result = (result * base) % 1000000007;
base = (base * base) % 1000000007;
exp >>= 1;
}
return result;
}
long long int sum(vector<int> a) {
long long int ans = 0;
for (int i = 0; i < a.size(); i++) ans += a[i];
return ans;
}
int main() {
int n, k, m;
cin >> n >> k >> m;
vector<int> a;
for (int i = 0; i < k; i++) {
int x;
cin >> x;
a.push_back(x);
}
sort(a.begin(), a.end());
long long int ans = 0;
for (long long int i = 0; i <= n; i++) {
long long int num = (long long int)(m - i * sum(a));
if (num < 0) break;
long long int score = (long long int)i * (k + 1);
for (int j = 0; j < k; j++) {
score += min(num / a[j], n - i);
num -= a[j] * min(num / a[j], n - i);
if (num < 0) break;
}
ans = max(ans, score);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, M;
int a[100];
int ans;
int sum;
int main() {
while (scanf("%d%d%d", &n, &k, &M) != EOF) {
ans = 0;
sum = 0;
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++) {
int score = (k + 1) * i;
int newM = M - sum * i;
int newN = n - i;
if (newM < 0) break;
for (int j = 0; j < k; j++) {
for (int p = 1; p <= newN && newM >= a[j]; p++) {
score++;
newM -= a[j];
}
}
ans = max(ans, score);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[111];
int main() {
int n, k, m;
cin >> n >> k >> m;
int sum = 0;
for (int i = 0; i < k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t, t + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
int time = m - sum * i;
if (time < 0) break;
int cnt = (k + 1) * i;
for (int j = 0; j < k; j++) {
for (int q = 0; q < (n - i); q++) {
if (time - t[j] >= 0) {
cnt++;
time -= t[j];
}
}
}
ans = max(ans, cnt);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, m;
long long t[50];
int main() {
scanf("%lld%lld%lld", &n, &k, &m);
long long sum = 0;
for (int i = 0; i < k; i++) {
scanf("%lld", &t[i]);
sum += t[i];
}
sort(t, t + k);
long long ans = 0;
for (int i = 0; i <= n; i++) {
long long now = i * sum;
long long res = i * (k + 1);
if (now > m) break;
for (int j = 0; j < k; j++) {
if (t[j] * (n - i) + now <= m) {
now += t[j] * (n - i);
res += n - i;
ans = max(ans, res);
} else {
res += (m - now) / t[j];
now += (m - now) / t[j] * t[j];
ans = max(ans, res);
break;
}
}
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
int solve_k(int time[], int minutes, int n_now, int n, int count, int k) {
for (int i = 0; i < k; ++i) {
bool start = true;
for (int j = n_now; j < n; ++j) {
if (minutes - time[i] < 0) {
start = false;
break;
}
minutes -= time[i];
++count;
}
if (!start) break;
}
return count;
}
int solve_n(int time[], int minutes, int n, int k) {
int count = 0;
int ans = 0;
for (int i = 0; i < n; ++i) {
bool start = true;
int check = solve_k(time, minutes, i, n, count, k);
ans = std::max({check, ans, count});
for (int j = 0; j < k; ++j) {
if (minutes - time[j] < 0) {
start = false;
break;
}
minutes -= time[j];
++count;
}
count += start;
}
return ans;
}
int main() {
int n, k, m;
std ::cin >> n >> k >> m;
int time[k];
for (int i = 0; i < k; ++i) {
std::cin >> time[i];
}
std::sort(time, time + k);
int ans_1 = 0, ans_2 = 0;
int minutes = m;
for (int i = 0; i < n; ++i) {
bool start = true;
for (int j = 0; j < k; ++j) {
if (minutes - time[j] < 0) {
start = false;
break;
}
minutes -= time[j];
++ans_1;
}
ans_1 += start;
}
minutes = m;
for (int i = 0; i < k; ++i) {
bool start = true;
for (int j = 0; j < n; ++j) {
if (minutes - time[i] < 0) {
start = false;
break;
}
minutes -= time[i];
if (i == k - 1)
ans_2 += 2;
else
++ans_2;
}
if (!start) break;
}
int ans_3 = solve_n(time, m, n, k);
std::cout << std::max({ans_1, ans_2, ans_3});
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50005;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
int n, k, m;
int a[maxn];
int main() {
while (~scanf("%d%d%d", &n, &k, &m)) {
int sum = 0;
for (int i = 0; i < k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
sort(a, a + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (sum * i > m) break;
int cnt = (k + 1) * i;
int temp = m - sum * i;
int now = 0;
while (1) {
for (int j = 1; j <= n - i; j++) {
temp -= a[now];
if (temp >= 0) cnt++;
if (temp <= 0) break;
}
now++;
if (now == k) break;
if (temp <= 0) break;
}
ans = max(ans, cnt);
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int solve(int n, int* t, int k, int m) {
int pts = 0, tot = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
tot += t[i];
if (tot > m) break;
pts++;
if (i == k - 1) pts++;
}
if (tot > m) break;
}
return pts;
}
int main() {
int n, k, m;
cin >> n >> k >> m;
int t[k];
for (int i = 0; i < k; i++) cin >> t[i];
sort(t, t + k);
int sum = 0;
for (int i = 0; i < k; i++) sum += t[i];
int ans = 0;
for (int i = 0; i < n; i++) {
if (m < sum * i) break;
ans = max(ans, (k + 1) * i + solve(n - i, t, k, m - sum * i));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, a[50], sum = 0, ans = 0, ans1;
cin >> n >> k >> m;
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
sum += a[i];
}
for (int i = 1; i < k; i++) {
for (int j = k - 1; j >= i; j--) {
if (a[j + 1] < a[j]) swap(a[j + 1], a[j]);
}
}
if (m >= sum * n) {
printf("%d", n * (k + 1));
return 0;
}
int p = m / sum;
for (int i = 0; i <= p; i++) {
int r = m - i * sum;
ans1 = i * (k + 1);
for (int j = 1; j <= k; j++) {
if (r >= a[j]) {
if (r >= a[j] * (n - i)) {
r -= a[j] * (n - i);
ans1 += (n - i);
} else {
ans1 += r / a[j];
break;
}
} else
break;
}
ans = max(ans, ans1);
}
printf("%d", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e5 + 10;
const long long inf = 1e9;
long long n, k, m, m1, m2, a[maxn], ans1, ans2, ans3, ans, sum;
int main() {
scanf("%d%d", &n, &k);
scanf("%d", &m);
for (int i = 0; i < k; i++) scanf("%d", &a[i]), sum += a[i];
sort(a, a + k);
m1 = m;
for (int i = 0; i < k; i++) {
if (m1 >= a[i] * n)
ans1 += n, m1 -= a[i] * n;
else {
ans1 += m1 / a[i];
break;
}
}
ans = ans1;
for (int i = 1; i <= n; i++) {
m1 = m, ans2 = 0;
if (m1 < sum * i) break;
m1 -= sum * i;
ans2 += i * (k + 1);
for (int j = 0; j < k; j++) {
if (i == n || m1 == 0) break;
if (m1 >= a[j] * (n - i))
ans2 += (n - i), m1 -= a[j] * (n - i);
else {
ans2 += m1 / a[j];
break;
}
}
ans = max(ans, ans2);
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, const char* argv[]) {
ios_base::sync_with_stdio(0);
cin.tie();
long n, m, k;
cin >> n >> k >> m;
vector<long> t(k, 0);
long sum = 0;
for (int i = 0; i < k; ++i) {
cin >> t[i];
sum += t[i];
}
sort(t.begin(), t.end());
long res = 0;
for (int i = 0; i <= n; ++i) {
long m1 = m - (sum * i);
if (m1 < 0) break;
long n1 = n - i;
long parts_solved = i * (k + 1);
;
for (int j = 0; j <= k; ++j) {
long tmp = t[j] * n1;
if (m1 - tmp > 0) {
parts_solved += n1;
m1 -= tmp;
} else {
long count_tmp = m1 / t[j];
parts_solved += count_tmp;
m1 -= count_tmp * t[j];
break;
}
}
if (parts_solved > res) res = parts_solved;
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[52];
void mathShow();
int main(void) { mathShow(); }
void mathShow() {
long long n, k, m, sum = 0;
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k + 1);
long long ans = 0, found = 0;
for (long long i = 0; i <= n; i++) {
if (i * sum > m) {
break;
}
ans = i * (k + 1);
long long sum1 = i * sum;
for (long long j = 1; j <= k; j++) {
for (long long l = 1; l <= n - i; l++) {
sum1 += a[j];
if (sum1 <= m) {
ans++;
} else
break;
}
}
found = max(found, ans);
}
cout << found << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int const N = 2e6 + 1;
long long n = 0, a = 0, b, c, k, x, y, z = 0, m = 0, mod = 1e9 + 7, sum1 = 0,
sum2 = 0, ans = 0, mx = 0;
string s, q;
multiset<int> se;
set<int> ss;
multiset<int>::iterator it;
vector<long long> v, g;
map<int, int> mp;
bool vis[N];
int arr[N];
int main() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> x;
g.push_back(x);
sum1 += x;
mp[x] += n;
}
sort(g.begin(), g.end());
a = m;
for (int i = 0; i <= n; i++) {
a = m;
if (i * sum1 > m) continue;
for (int j = 0; j < k; j++) {
mp[g[j]] -= i;
}
sum2 = i * k + i;
a -= (i * sum1);
for (int il = 0; il < k; il++) {
while (a >= g[il] && mp[g[il]] > 0) {
mp[g[il]]--;
a -= g[il];
sum2++;
}
if (a < g[il]) break;
}
ans = max(ans, sum2);
for (int j = 0; j < k; j++) {
mp[g[j]] += n;
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int M = 1e9 + 7;
int mxK = 45 * 45 + 100;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k;
cin >> n >> k;
long long m;
cin >> m;
vector<long long> A(k);
for (int i = 0; i < k; ++i) {
cin >> A[i];
}
sort(A.begin(), A.end());
vector<vector<long long>> dp(n + 1, vector<long long>(mxK, 1e18));
dp[0][0] = 0;
long long ans = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j < mxK; ++j) {
long long cur = 0;
for (int l = 1, en = min(k, j); l <= en; ++l) {
cur += A[l - 1];
dp[i][j] = min(dp[i][j], dp[i - 1][j - l] + cur);
if (l == k && (j - l - 1 >= 0)) {
dp[i][j] = min(dp[i][j], dp[i - 1][j - l - 1] + cur);
}
}
if (dp[i][j] <= m) {
ans = max(ans, j + 0LL);
}
}
}
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[510];
int main() {
ios::sync_with_stdio(0);
cin.tie();
cout.tie();
srand(time(NULL));
long long n, k, m;
cin >> n >> k >> m;
long long sum = 0;
for (int i = 0; i < k; i++) cin >> a[i], sum += a[i];
sort(a, a + k);
long long ans = -1;
for (int all = 0; all <= n; all++) {
long long can = m - sum * all;
long long cnt = all * (k + 1);
long long has = n - all;
if (can < 0) break;
for (int i = 0; i < k && can >= 0; i++) {
long long take = min(has, can / a[i]);
cnt += take;
can -= take * a[i];
}
ans = max(ans, cnt);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[50];
int main() {
long long n, k, m;
while (~scanf("%lld%lld%lld", &n, &k, &m)) {
long long sum = 0;
for (int i = 1; i <= k; i++) scanf("%lld", &a[i]), sum += a[i];
sort(a + 1, a + 1 + k);
long long ans = 0, tot;
for (int i = 0; m - sum * i >= 0 && i <= n; i++) {
tot = (k + 1) * i;
long long cnt = m - sum * i, tag = n - i;
for (int j = 1; j <= k; j++) {
if (cnt == 0) break;
if (cnt >= tag * a[j]) {
tot += tag;
cnt -= tag * a[j];
} else {
tot += cnt / a[j];
cnt = 0;
}
}
ans = max(ans, tot);
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
int i = 0;
long long ans = 0, sum = 0;
vector<int> v(k);
for (auto &x : v) {
cin >> x;
sum += x;
}
sort(v.begin(), v.end());
for (i = 0; i < n + 1;) {
long long mi = m - sum * i;
long long ct = (k + 1) * i;
if (mi < 0) break;
for (int j = 0; j < k && mi > 0; j++) {
int x = min(mi, v[j] * min(n - i, mi / v[j]));
ct += min(n - i, mi / v[j]);
mi -= x;
}
ans = max(ans, ct);
i++;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n, k;
long long int m, s = 0;
cin >> n >> k >> m;
vector<long long int> v(k);
for (int i = 0; i < k; i += 1) {
cin >> v[i];
s += v[i];
}
sort(v.begin(), v.end());
long long int ans = LONG_MIN;
int num = min(m / s, (long long int)n);
for (int i = 0; i < num + 1; i += 1) {
long long int cnt = i * (k + 1), temp = m - (i * s);
int fl = 0;
for (int j = 0; j < k; j += 1) {
for (int l = 0; l < n - i; l += 1) {
if (temp < v[j]) {
fl = 1;
break;
} else {
temp -= v[j];
cnt += 1 + (j == k - 1 ? 1 : 0);
}
}
if (fl == 1) break;
}
ans = max(ans, cnt);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, k, m;
long long M[50][2500];
long long A[50], V[50];
int main() {
long long p, i, j, maxim = 0, x, sum = 0;
cin >> n >> k >> m;
for (p = 1; p <= n * (k + 1); p++) M[1][p] = 1e15;
for (i = 1; i <= k; i++) {
cin >> V[i];
}
sort(V + 1, V + k + 1);
for (i = 1; i <= k; i++) {
x = V[i];
sum += x;
A[i] = sum;
if (i == k)
M[1][k + 1] = sum;
else
M[1][i] = sum;
}
for (i = 2; i <= n; i++) {
for (p = 1; p <= n * (k + 1); p++) {
M[i][p] = M[i - 1][p];
for (j = 1; j < k; j++) {
if (p - j < 1) break;
if (M[i - 1][p - j]) M[i][p] = min(M[i][p], M[i - 1][p - j] + A[j]);
}
if (p - k - 1 > 0 && M[i - 1][p - k - 1])
M[i][p] = min(M[i][p], M[i - 1][p - k - 1] + A[k]);
}
}
for (p = 1; p <= n * (k + 1); p++) {
if (M[n][p] <= m) maxim = p;
}
cout << maxim;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
int n, k, m;
cin >> n >> k >> m;
vector<long long> t(k);
long long sm = 0;
for (int(i) = 0; (i) < (k); (i)++) {
cin >> t[i];
sm += t[i];
}
sort((t).begin(), (t).end());
int mv = 0;
for (int(i) = 0; (i) < (n + 1); (i)++) {
int pts = 0, M = m;
M -= i * sm;
if (M < 0) break;
pts += i * (k + 1);
int j = 0;
for (j = 0; j < k - 1; j++) {
M -= t[j] * (n - i);
if (M < 0) break;
pts += n - i;
}
if (M < 0) {
M += t[j] * (n - i);
while (M > 0) {
M -= t[j];
if (M >= 0) pts++;
}
mv = max(pts, mv);
} else {
int o = 0;
while (M > 0 && o < n - i) {
M -= t[j];
if (M >= 0) pts += 2;
o++;
}
mv = max(pts, mv);
}
}
cout << mv << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, M;
cin >> n >> k >> M;
long long ti[k];
long long takeAll = 0;
for (long long i = 0; i < k; i++) {
cin >> ti[i];
takeAll += ti[i];
}
sort(ti, ti + k);
long long maxi = 0;
long long t = 0;
long long j, score;
for (long long i = 0; i < n; i++) {
score = 0;
if (takeAll * i > M)
break;
else {
t = takeAll * i;
score += (k + 1) * i;
for (j = 0; j < k; j++) {
if (t == M) break;
long long taken = 0;
if (t + ((n - i) * ti[j]) <= M) {
t += (n - i) * ti[j];
score += (n - i);
taken = n - i;
} else {
taken = (M - t) / ti[j];
score += taken;
t += taken * ti[j];
}
if (j == k - 1) {
score += taken;
}
}
}
maxi = max(maxi, score);
}
cout << maxi << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int cmpfunc(const void* a, const void* b) {
if (*(long long int*)a - *(long long int*)b < 0) return -1;
if (*(long long int*)a - *(long long int*)b > 0) return 1;
return 0;
}
int main() {
int n, k;
long long int m;
cin >> n >> k >> m;
long long int numbers[k];
long long int sum = 0;
for (int i = 0; i < k; i++) {
cin >> numbers[i];
sum += numbers[i];
}
qsort(numbers, k, sizeof(long long int), cmpfunc);
int s = m / sum;
if (s < n) {
s = s;
} else {
cout << (k + 1) * n << endl;
return 0;
}
int ans = 0, maxx = 0;
for (int i = 0; i < s + 1; i++) {
int x = m;
int ans = 0;
if (sum * i <= m) {
ans += (k + 1) * i;
x -= sum * i;
}
for (int j = 0; j < k; j++) {
if (x - (n - i) * numbers[j] >= 0) {
ans += n - i;
x -= (n - i) * numbers[j];
} else {
for (int c = 0; c < (n - i); c++) {
while (x - numbers[j] >= 0) {
x -= numbers[j];
ans += 1;
}
}
}
}
if (ans > maxx) maxx = ans;
}
cout << maxx << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class c>
struct rge {
c b, e;
};
template <class c>
rge<c> range(c i, c j) {
return rge<c>{i, j};
}
template <class c>
auto dud(c* x) -> decltype(cerr << *x, 0);
template <class c>
char dud(...);
struct debug {
template <class c>
debug& operator<<(const c&) {
return *this;
}
};
const long long xx = 2e5;
const long long MOD = 1e9 + 7;
signed main() {
ios::sync_with_stdio(false);
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];
}
debug() << "\033[94m ["
<< "sum"
": "
<< (sum) << "]\033[0m";
sort(a.begin(), a.end());
long long fw = M / sum;
debug() << "\033[94m ["
<< "fw"
": "
<< (fw) << "]\033[0m";
if (fw >= n) {
cout << (k + 1) * n << '\n';
return 0;
}
long long ans = 0;
for (long long i = 0; i <= fw; i++) {
long long remW = n - i;
long long tmp_res = 0;
long long amount = M;
tmp_res += (k + 1) * i;
amount -= (i * sum);
debug() << "\033[94m ["
<< "remW"
": "
<< (remW)
<< "]\033[0m"
"\033[94m ["
<< "tmp_res"
": "
<< (tmp_res)
<< "]\033[0m"
"\033[94m ["
<< "amount"
": "
<< (amount) << "]\033[0m";
for (long long j = 0; j < k; j++) {
if (amount < a[j]) {
break;
}
long long take = min(remW, amount / a[j]);
tmp_res += take;
amount -= (take * a[j]);
debug() << "\033[94m ["
<< "take"
": "
<< (take)
<< "]\033[0m"
"\033[94m ["
<< "tmp_res"
": "
<< (tmp_res)
<< "]\033[0m"
"\033[94m ["
<< "amount"
": "
<< (amount) << "]\033[0m";
}
ans = max(ans, tmp_res);
}
cout << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, t[46], sum;
int solve(int i) {
int N = n - i;
int M = m - sum * i;
if (M < 0) return 0;
int ret = i * (k + 1);
for (int j = 0; j < k; ++j) {
for (int i = 0; i < N; ++i) {
if (M < t[j]) return ret;
ret++;
M -= t[j];
if (j == k - 1) ret++;
}
}
return ret;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> k >> m;
for (int i = 0; i < k; ++i) {
cin >> t[i];
sum += t[i];
}
sort(t, t + k);
int ans = 0;
for (int i = 0; i <= n; ++i) {
ans = max(ans, solve(i));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long t[55];
int main() {
long long n, k, m;
cin >> n >> k >> m;
for (int i = 1; i <= k; ++i) cin >> t[i];
long long ans = 0, tot = 0;
for (int i = 1; i <= k; ++i) tot += t[i];
for (int i = 0; i <= n; ++i) {
if (tot * i > m) break;
vector<int> co;
for (int j = 1; j <= n - i; ++j)
for (int z = 1; z <= k; ++z) co.push_back(t[z]);
sort(co.begin(), co.end());
long long tmp = (k + 1) * i;
long long le = m - tot * i;
for (int i : co) {
if (i > le) break;
le -= i;
++tmp;
}
ans = max(ans, tmp);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, k, m;
cin >> n >> k >> m;
int ans = 0;
vector<int> a(k);
for (int i = 0; i < k; i++) cin >> a[i];
sort(a.begin(), a.end());
for (int i = 0; i < n + 1; i++) {
int t = 0, aux = 0, naux = n - i;
for (int id = 0; id < i; id++) {
int j = 0;
for (; j < k && t + a[j] <= m; j++) aux++, t += a[j];
if (j == k) aux++;
}
for (int j = 0; j < k; j++) {
int x = min((m - t) / a[j], naux);
t += x * a[j];
aux += x;
if (j == k - 1) aux += x;
if (!x) break;
}
ans = max(ans, aux);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long k;
long long find_vertical_score(long long max_time, long long a[],
long long rem_time) {
long long score = 0;
for (int i = 0; i < k; i++) {
if (rem_time >= (a[i] * max_time)) {
rem_time -= (a[i] * max_time);
score += (max_time);
} else {
score += (rem_time / a[i]);
break;
}
}
return score;
}
int main() {
long long n, m;
cin >> n >> k >> m;
long long a[k];
for (int i = 0; i < k; i++) cin >> a[i];
sort(a, a + k);
long long onetask = 0, local_score, max_score = -1, maxtask;
for (int i = 0; i < k; i++) onetask += a[i];
maxtask = m / onetask;
for (int i = 0; (i <= maxtask && i <= n); i++) {
local_score = (i * (k + 1));
local_score += find_vertical_score((n - i), a, m - (onetask * i));
if (local_score > max_score) max_score = local_score;
}
cout << max_score << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long n, k, m, t[45];
long i, j, strSum, ans;
void qsort(int b, int e) {
long l = b, r = e;
long piv = t[(l + r) / 2];
while (l <= r) {
while (t[l] < piv) l++;
while (t[r] > piv) r--;
if (l <= r) swap(t[l++], t[r--]);
}
if (b < r) qsort(b, r);
if (e > l) qsort(l, e);
}
int main() {
cin >> n >> k >> m;
for (i = 0; i < k; ++i) cin >> t[i];
qsort(0, k - 1);
strSum = 0;
for (i = 0; i < k; ++i) strSum += t[i];
ans = 0;
for (i = 0; i < n + 1 && m >= strSum * i; ++i) {
long lans = i * (k + 1);
long lm = m - strSum * i;
for (j = 0; j < k && lm >= t[j]; ++j) {
if (lm >= t[j] * (n - i)) {
lm -= t[j] * (n - i);
if (j == k - 1)
lans += (n - i) * 2;
else
lans += n - i;
} else {
long cnt = lm / t[j];
lm -= t[j] * cnt;
if (j == k - 1)
lans += cnt * 2;
else
lans += cnt;
}
}
if (lans > ans) ans = lans;
}
cout << ans;
getchar();
getchar();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
int t[50];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, k, m;
cin >> n >> k >> m;
int sum = 0;
for (int i = 1; i <= k; i++) {
cin >> t[i];
sum += t[i];
}
sort(t + 1, t + k + 1);
int mx = 0;
for (int i = 0; i <= n; i++) {
int s = (k + 1) * i;
int le = m - sum * i;
if (le < 0) break;
for (int j = 1; j <= k; j++) {
for (int k = n - i; k > 0; k--) {
if (le >= t[j]) {
le -= t[j];
s++;
}
}
}
mx = max(mx, s);
}
cout << mx;
}
|
#include <bits/stdc++.h>
int main(void) {
int n;
int k;
int M;
scanf("%d%d%d", &n, &k, &M);
int number[45][45] = {0};
for (int i = 0; i < k; i++) {
int temp;
scanf("%d", &temp);
for (int j = 0; j < n; j++) {
number[j][i] = temp;
}
}
for (int i = 0; i < n; i++) {
std::sort(number[i], number[i] + k);
}
int ptrAddR = 0;
int ptrAddL = 0;
int ptrDelR = 0;
int ptrDelL = -1;
int lockR = 0;
int time = M;
int score = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
if (time >= number[j][i]) {
time -= number[j][i];
ptrDelL = j;
ptrDelR = i;
} else {
goto FAST_JUMP;
}
}
}
FAST_JUMP:
if (ptrDelL == n) {
score = (ptrDelR - 1 + 1) * n;
} else {
score = (ptrDelR - 1 + 1) * n + ptrDelL + 1;
}
if (ptrDelR == k - 1) {
lockR = ptrDelL + 1;
ptrAddL = lockR;
ptrAddR = k - 1;
score += lockR;
} else {
ptrAddR = ptrDelR + 1;
ptrAddL = 0;
}
if (ptrDelL <= lockR) {
ptrDelL = n - 1;
ptrDelR--;
}
int warning = 0;
int tptrAddR = ptrAddR;
int tptrAddL = ptrAddL;
int tptrDelR = ptrDelR;
int tptrDelL = ptrDelL;
int tlockR = lockR;
int flag = 0;
while (!(lockR >= n - 1 || ptrDelR < 0 || warning >= 2)) {
if (tptrDelL <= tlockR) {
tptrDelL = n - 1;
tptrDelR--;
}
time += number[tptrDelL][tptrDelR];
tptrDelL--;
if (tptrDelL <= tlockR) {
tptrDelL = n - 1;
tptrDelR--;
}
flag = -1;
if (tptrAddR > k - 1) {
tptrAddR = tptrDelR + 1;
tptrAddL++;
tlockR++;
}
if (tptrAddR > k - 1 || tptrAddL > n - 1) {
break;
}
if (time >= number[tptrAddL][tptrAddR]) {
time -= number[tptrAddL][tptrAddR];
flag = 0;
tptrAddR++;
if (tptrAddR > k - 1) {
tptrAddR = tptrDelR + 1;
tptrAddL++;
tlockR++;
flag = 1;
}
} else {
}
warning -= flag;
if (warning <= 0) {
score -= warning;
warning = 0;
ptrAddL = tptrAddL;
ptrAddR = tptrAddR;
ptrDelL = tptrDelL;
ptrDelR = tptrDelR;
lockR = tlockR;
}
}
printf("%d", score);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, m;
cin >> n >> k >> m;
long long int a[k];
long long int sum = 0;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
long long int money = 0;
for (int i = 0; i <= n; i++) {
long long int T = 0, tmp = 0, f = 0;
T += sum * i;
if (m >= T) tmp += (k * i) + i;
for (int l = 0; l < k; l++) {
for (int j = i; j < n; j++) {
if (T + a[l] > m) {
f = 1;
break;
}
T += a[l];
tmp++;
}
if (f) break;
}
money = max(money, tmp);
}
cout << money << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
string itosm(long long x) {
if (x == 0) return "0";
string ans = "";
while (x > 0) {
ans += ((x % 10) + '0');
x /= 10;
}
reverse(ans.begin(), ans.end());
return ans;
}
long long stoim(string str) {
long long ans = 0;
long long k = 1;
for (int i = str.length() - 1; i >= 0; i--) {
ans += (str[i] - '0') * k;
k *= 10;
}
return ans;
}
const long long infll = 1e18 + 3;
const int inf = 1009000999;
const double eps = 1e-7;
const int maxn = 1e6 + 777;
const int baseint = 1000200013;
const long long basell = 1e18 + 3;
const long double PI = acos(-1.0);
const long long mod = 1e9 + 7;
int cnt[30];
int t[30];
void solve() {
int n, k, m;
cin >> n >> k >> m;
int sum = 0;
for (int i = 0; i < k; i++) {
cin >> t[i];
sum += t[i];
}
int ans = 00;
sort(t, t + k);
int m1 = m;
for (int i = 0; i <= n; i++) {
if (sum * i > m1) break;
int ans1 = i * k + i;
m = m1;
m -= sum * i;
for (int j = 0; j < k; j++)
if (t[j] * (n - i) <= m) {
m -= t[j] * (n - i);
ans1 += (n - i);
} else {
ans1 += m / t[j];
break;
}
ans = max(ans, ans1);
}
cout << ans;
}
int main() {
srand(time(0));
ios_base::sync_with_stdio(0);
;
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long point[1000006];
int main() {
ios::sync_with_stdio(false), cin.tie(0);
for (int i = 0; i < 1000006; i++) {
point[i] = 1e10;
}
long long n, k, m;
cin >> n >> k >> m;
long long a[k];
long long sum = 0;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (long long o = 0; o <= n; o++) {
long long x = o * sum;
long long y = o * (k + 1);
point[y] = min(point[y], x);
for (int i = 0; i < k; i++) {
for (int j = o; j < n; j++) {
x += a[i];
y++;
if (i + 1 == k) y++;
point[y] = min(point[y], x);
}
}
}
long long res;
for (int i = 0; i < 1000006; i++) {
if (point[i] <= m) {
res = i;
}
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m, x[50], ta;
long long dp[50 * 50 + 1];
int main() {
scanf("%d%d%d", &n, &k, &m);
for (int i = 1; i <= k; i++) scanf("%d", x + i);
sort(x + 1, x + k + 1);
for (int i = 1; i <= k; i++) x[i] += x[i - 1];
m++;
dp[0] = 1;
for (int i = 0; i < n; i++)
for (int j = 2500; j >= 0; j--)
if (dp[j])
for (int kk = 1; kk <= k; kk++) {
ta = kk;
if (kk == k) ta++;
if (!dp[j + ta] || dp[j + ta] > dp[j] + x[kk])
dp[j + ta] = dp[j] + x[kk];
}
for (int i = 2500; i >= 0; i--)
if (dp[i] && dp[i] <= m) {
printf("%d\n", i);
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long score, ans = 0, n, K, r, m, t, a[50], sum;
signed main() {
scanf("%lld%lld%lld", &n, &K, &m);
for (long long i = 1; i <= K; i++) {
scanf("%lld", &a[i]);
sum += a[i];
}
sort(a + 1, a + K + 1);
for (long long i = 0; i <= n; i++) {
score = i * K + i, t = sum * i, r = n - i;
if (t > m) break;
for (long long j = 1; j <= K; j++) {
for (long long k = 1; k <= r; k++) {
t += a[j];
if (t > m) break;
score++;
}
if (t >= m) break;
}
ans = max(ans, score);
}
printf("%lld", ans);
return 0;
}
|
#include <bits/stdc++.h>
const int MX = 1000000007;
const long long mod = MX;
const long long MMX = (long long)MX * MX;
const long long MMN = (long long)(-MX) * MX;
using namespace std;
int n, k;
long long m;
long long mas[107];
long long s = 0;
int main() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) {
cin >> mas[i];
s += mas[i];
}
sort(mas, mas + k);
long long mx = 0;
for (int i = 0; i <= n; i++)
if (s * i <= m) {
long long res = i * (k + 1);
long long lt = m - s * i;
long long lz = n - i;
int cur = 0, cp = 0;
while (lt > 0 && cur < k && lz > 0) {
if (mas[cur] > lt) {
break;
}
res++;
lt -= mas[cur];
cp++;
if (cp >= lz) {
cur++;
cp = 0;
}
}
mx = max(mx, res);
}
cout << mx << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma warning(disable : 4996)
#pragma comment(linker, "/stack:200000000")
#pragma GCC optimize("Ofast")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#pragma GCC optimize("-ffloat-store")
using namespace std;
clock_t time_p = clock();
void aryanc403() {
time_p = clock() - time_p;
cerr << "Time Taken : " << (float)(time_p) / CLOCKS_PER_SEC << "\n";
}
class CMP {
public:
bool operator()(long long int a, long long int b) { return !(a <= b); }
};
void add(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
map<long long int, long long int>::iterator jt;
jt = m.find(x);
if (jt == m.end())
m.insert(make_pair(x, cnt));
else
jt->second += cnt;
}
void del(map<long long int, long long int> &m, long long int x,
long long int cnt = 1) {
map<long long int, long long int>::iterator jt;
jt = m.find(x);
if (jt->second <= cnt)
m.erase(jt);
else
jt->second -= cnt;
}
bool cmp(const pair<long long int, long long int> &a,
const pair<long long int, long long int> &b) {
return a.first < b.first || (a.first == b.first && a.second < b.second);
}
const long long int INF = 0xFFFFFFFFFFFFFFFL;
const long long int mod = 1000000007L;
long long int T, n, i, j, k, in, cnt, l, r;
long long int m;
string s;
vector<long long int> a;
vector<long long int>::iterator it;
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
{
cin >> n >> k >> m;
long long int sum = 0;
a.clear();
a.reserve(k);
for (i = 0; i < (k); ++i) {
cin >> in;
a.push_back(in);
sum += in;
}
sort(a.begin(), a.end());
long long int ans = 0, cnt, min;
for (j = (0); j <= (n); ++j) {
cnt = j * (k + 1);
min = m - j * sum;
if (min < 0) break;
for (auto x : a) {
for (l = (j + 1); l <= (n); ++l) {
min -= x;
if (min < 0) break;
cnt++;
}
}
ans = max(ans, cnt);
}
cout << ans << "\n";
}
aryanc403();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ara[110];
int main() {
int n, k, m;
cin >> n >> k >> m;
long long sum = 0;
for (int i = 0; i < k; i++) {
cin >> ara[i];
sum += ara[i];
}
sort(ara, ara + k);
long long ans = 0;
for (int i = 0; i <= n and m >= i * sum; i++) {
long long total = i * (k + 1);
long long temp = m - i * sum;
for (int j = 0; j < k - 1; j++) {
for (int p = 0; p < n - i; p++) {
if (temp >= ara[j]) {
temp -= ara[j];
total++;
}
}
}
ans = max(ans, total);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;
using dd = long double;
namespace {
static bool constexpr dbg = 0;
ll constexpr N = 100;
ll n, k, m, d[N + 9];
void init() {
cin >> n >> k >> m;
for (ll i = 1; i <= (ll)(k); ++i) cin >> d[i];
}
void solve() {
sort(d + 1, d + k + 1);
ll sum = 0;
for (ll i = 1; i <= (ll)(k); ++i) sum += d[i];
ll res = 0;
for (ll i = 0; i <= n; ++i) {
ll r = 0, rem = m;
rem -= sum * i;
if (rem < 0) break;
r += (k + 1) * i;
for (ll j = 1; j <= k; ++j) {
ll c = min(rem / d[j], n - i);
;
if (!c) break;
r += c;
rem -= c * d[j];
}
res = max(res, r);
}
cout << res;
}
} // namespace
int main() {
if (!dbg) {
std::ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
cout << fixed << setprecision(20);
init();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[1000003];
int main() {
int n, k, m;
int sum = 0;
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> arr[i];
for (int i = 0; i < k; i++) sum += arr[i];
sort(arr, arr + k);
int res = 0;
for (int i = 0; i <= n; i++) {
int temp = 0, temp2 = m;
if (sum * i <= m) {
m -= sum * i;
temp += (k + 1) * i;
for (int j = 0; j < k; j++) {
if ((n - i) * arr[j] <= m) {
temp += n - i;
m -= (n - i) * arr[j];
} else {
temp += m / arr[j];
break;
}
}
m = temp2;
res = max(temp, res);
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, ti;
int t[55];
int tot = 0;
int maxn[55];
int ans = 0;
int main() {
cin >> n >> k >> ti;
for (register int i = 1; i <= k; ++i) cin >> t[i], tot += t[i];
sort(t + 1, t + k + 1);
for (register int i = 0; i <= n; ++i) {
int tim = i * tot;
if (tim > ti) break;
maxn[i] = i * (k + 1);
for (register int j = 1; j <= k; ++j) {
for (register int l = i + 1; l <= n; ++l) {
tim += t[j];
if (tim > ti) break;
++maxn[i];
}
if (tim > ti) break;
}
ans = max(ans, maxn[i]);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50, M = (int)1e6, Inf = INT_MAX - 100;
int n, m, k;
array<int, N> sub;
int f(int full, int m) {
int have = n - full;
int ans = 0;
int cur = 0;
if (m >= 0)
ans += (k + 1) * full;
else
return 0;
while (cur < k - 1) {
for (int i = 0; i < have; i++) {
if (m < sub[cur])
break;
else
m -= sub[cur];
ans++;
}
cur++;
}
return ans;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> k >> m;
int for_full_problem = 0;
for (int i = 0; i < k; i++) {
cin >> sub[i];
for_full_problem += sub[i];
}
sort(sub.begin(), sub.begin() + k);
int ans = -1;
for (int full = 0; full <= n; full++) {
ans = max(ans, f(full, m - for_full_problem * full));
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, i, sum = 0, t, cou, f, ans = 0, l;
cin >> a >> b >> c;
int ara[b];
for (i = 0; i < b; i++) {
cin >> ara[i];
sum += ara[i];
}
sort(ara, ara + b);
for (i = 0; i <= a; i++) {
t = c;
cou = 0;
f = 0;
t -= (sum * i);
if (t < 0) {
break;
}
cou += (b * i) + i;
while (t > 0) {
t -= (ara[f] * (a - i));
if (t >= 0) {
cou += (a - i);
}
f++;
if (f == b) {
break;
}
}
if (t < 0) {
t += (ara[f - 1] * (a - i));
while (t > 0) {
t -= ara[f - 1];
if (t >= 0) {
cou++;
}
}
}
ans = max(ans, cou);
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace Debug {
void __print(signed x) { cout << x; }
void __print(long x) { cout << x; }
void __print(long long x) { cout << x; }
void __print(unsigned x) { cout << x; }
void __print(unsigned long x) { cout << x; }
void __print(unsigned long long x) { cout << x; }
void __print(float x) { cout << x; }
void __print(double x) { cout << x; }
void __print(long double x) { cout << x; }
void __print(char x) { cout << '\'' << x << '\''; }
void __print(const char *x) { cout << '\"' << x << '\"'; }
void __print(const string &x) { cout << '\"' << x << '\"'; }
void __print(bool x) { cout << (x ? "true" : "false"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
cout << '{';
__print(x.first);
cout << ',';
__print(x.second);
cout << '}';
}
template <typename T>
void __print(const T &x) {
long long f = 0;
cout << '{';
for (auto &i : x) cout << (f++ ? "," : ""), __print(i);
cout << "}";
}
void _print() { cout << "]" << endl; }
template <typename T, typename... V>
void _print(T t, V... v) {
__print(t);
if (sizeof...(v)) cout << ", ";
_print(v...);
}
} // namespace Debug
using namespace Debug;
const bool DEBUG = true;
long long calc_score(long long idx, long long n, long long k,
vector<long long> &arr, long long time_left) {
long long score = 0ll;
for (long long i = 0; i < k; i++) {
for (long long j = idx; j <= n; j++) {
if (time_left < arr[i]) return score;
++score;
time_left -= arr[i];
}
}
return score;
}
void process() {
long long n, k, M;
cin >> n >> k >> M;
vector<long long> arr(k);
for (long long i = 0; i < k; i++) cin >> arr[i];
long long res = 0ll, sum = accumulate(arr.begin() + 0, arr.begin() + k, 0ll);
sort(arr.begin() + 0, arr.begin() + k);
for (long long i = 0; i <= n; i++) {
if (sum * i > M) continue;
long long score = i * (k + 1);
long long time_left = M - (sum * i);
score += calc_score(i + 1, n, k, arr, time_left);
res = max(res, score);
}
cout << res << "\n";
}
signed main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
long long t = 1;
while (t--) process();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> a;
int solve(int n, int k, int m) {
int i, ans = 0;
for (i = 1; i <= k; i++) {
if (m >= n * a[i]) {
m -= n * a[i];
ans += n;
} else {
ans += m / a[i];
break;
}
}
return ans;
}
int main() {
int n, k, m;
cin >> n >> k >> m;
int i, j, t;
int s = 0;
a.push_back(0);
for (i = 0; i < k; i++) {
cin >> t;
s += t;
a.push_back(t);
}
sort(a.begin(), a.end());
int ans = solve(n, k, m);
for (i = 1; i <= n; i++) {
if (s * i <= m) {
ans = max(ans, solve(n - i, k, m - s * i) + i * (k + 1));
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int main(void) {
int n;
int k;
int M;
scanf("%d%d%d", &n, &k, &M);
int number[45][45] = {0};
for (int i = 0; i < k; i++) {
int temp;
scanf("%d", &temp);
for (int j = 0; j < n; j++) {
number[j][i] = temp;
}
}
for (int i = 0; i < n; i++) {
std::sort(number[i], number[i] + k);
}
int ptrAddR = 0;
int ptrAddL = 0;
int ptrDelR = 0;
int ptrDelL = -1;
int lockR = 0;
int time = M;
int score = 0;
for (int i = 0; i < k; i++) {
for (int j = 0; j < n; j++) {
if (time >= number[j][i]) {
time -= number[j][i];
ptrDelL = j;
ptrDelR = i;
} else {
goto FAST_JUMP;
}
}
}
FAST_JUMP:
if (ptrDelL == n) {
score = (ptrDelR - 1 + 1) * n;
} else {
score = (ptrDelR - 1 + 1) * n + ptrDelL + 1;
}
if (ptrDelR == k - 1) {
lockR = ptrDelL + 1;
ptrAddL = lockR;
ptrAddR = k - 1;
score += lockR;
} else {
ptrAddR = ptrDelR + 1;
ptrAddL = 0;
}
if (ptrDelL <= lockR) {
ptrDelL = n - 1;
ptrDelR--;
}
int warning = 0;
int tptrAddR = ptrAddR;
int tptrAddL = ptrAddL;
int tptrDelR = ptrDelR;
int tptrDelL = ptrDelL;
int tlockR = lockR;
int flag = 0;
while (!(lockR >= n - 1 || ptrDelR < 0 || warning >= 2)) {
if (tptrDelL <= tlockR) {
tptrDelL = n - 1;
tptrDelR--;
}
time += number[tptrDelL][tptrDelR];
tptrDelL--;
if (tptrDelL <= tlockR) {
tptrDelL = n - 1;
tptrDelR--;
}
flag = -1;
if (tptrAddR > k - 1) {
tptrAddR = tptrDelR + 1;
tptrAddL++;
tlockR++;
}
if (tptrAddR > k - 1 || tptrAddL > n - 1) {
break;
}
if (time >= number[tptrAddL][tptrAddR]) {
time -= number[tptrAddL][tptrAddR];
flag = 0;
tptrAddR++;
if (tptrAddR > k - 1) {
tptrAddR = tptrDelR + 1;
tptrAddL++;
tlockR++;
flag = 1;
}
} else {
}
warning -= flag;
if (warning <= 0) {
score -= warning;
warning = 0;
ptrAddL = tptrAddL;
ptrAddR = tptrAddR;
ptrDelL = tptrDelL;
ptrDelR = tptrDelR;
lockR = tlockR;
}
}
printf("%d", score);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 55;
const long long mod = 1e9 + 7;
const int INF = 0x3f3f3f3f;
const double eps = 1e-6;
int a[maxn], dp[maxn * maxn];
int n, k, m;
int main() {
while (~scanf("%d%d%d", &n, &k, &m)) {
memset((dp), (0x3f), sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= k; i++) {
scanf("%d", &a[i]);
}
sort(a + 1, a + 1 + k);
for (int i = 1; i <= k; i++) {
a[i] += a[i - 1];
}
for (int i = 1; i <= n; i++)
for (int j = n * (k + 1); j >= 0; j--)
for (int s = 1; s <= k; s++) {
dp[j + s + (s == k)] = min(dp[j + s + (s == k)], dp[j] + a[s]);
}
int ans = 0;
for (int i = 0; i <= (k + 1) * n; i++) {
if (dp[i] <= m) {
ans = i;
}
}
printf("%d\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 50;
int n, k, m;
int A[maxn];
int main() {
while (scanf("%d %d %d", &n, &k, &m) == 3) {
for (int i = 0; i < k; ++i) scanf("%d", A + i);
sort(A, A + k);
int sum = 0;
for (int i = 0; i < k; ++i) sum += A[i];
int res = 0;
for (int i = 0; i <= n; ++i) {
int temp = 0;
if (i * sum > m) break;
temp += i * (k + 1);
int lm = m - sum * i, ln = n - i;
for (int j = 0; j < k; ++j) {
int d = lm / A[j];
if (d > ln)
lm -= A[j] * ln, temp += ln;
else {
temp += d;
break;
}
}
if (temp > res) res = temp;
}
printf("%d\n", res);
}
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, m, i, j, k, l = 0, ans = 0, sum = 0, x, y, z, mx = 0, mn = 2e9,
a[100005] = {0}, flag = 0, temp, rem;
cin >> n >> k >> m;
for (i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
for (i = 0; i <= n; i++) {
temp = m;
if (sum * i <= m) {
temp = temp - sum * i;
ans = i * (k + 1);
rem = n - i;
for (j = 0; j < k; j++) {
if (rem * a[j] > temp) {
x = temp / a[j];
temp = 0;
ans += x;
} else {
temp = temp - rem * a[j];
ans += rem;
}
}
}
l = max(l, ans);
}
cout << l;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int ar[N];
int main() {
int n, k, m, i, j, sum = 0, dem, ans = 0, l, sum1;
cin >> n >> k >> m;
for (i = 1; i <= k; i++) {
cin >> ar[i];
sum += ar[i];
}
sort(ar + 1, ar + 1 + k);
for (i = 0; i <= min(n, m / sum); i++) {
dem = m - sum * i;
sum1 = (k + 1) * i;
for (j = 1; j <= k; j++) {
l = min(n - i, dem / ar[j]);
dem -= l * ar[j];
sum1 += l;
}
ans = max(ans, sum1);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, k, m, ans = 0, temp = 0, x, net = 0;
scanf("%I64d%I64d%I64d", &n, &k, &m);
long long arr[k];
for (int i = 0; i < k; i++) {
scanf("%I64d", &arr[i]);
net += arr[i];
}
sort(arr, arr + k);
for (int i = 0; i <= n; i++) {
x = m - i * net;
if (x >= 0) {
temp = i * (k + 1);
for (int j = 0; j < k; j++) {
int f = 0;
for (int h = 0; h < n - i; h++) {
if (x >= arr[j]) {
temp++;
x -= arr[j];
} else {
f = 1;
break;
}
}
if (f) break;
}
if (temp > ans) ans = temp;
} else
break;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int solve_k(int time[], int minutes, int n_now, int n, int count, int k) {
for (int i = 0; i < k; ++i) {
bool start = true;
for (int j = n_now; j < n; ++j) {
if (minutes - time[i] < 0) {
start = false;
break;
}
minutes -= time[i];
++count;
}
if (!start) break;
}
return count;
}
int solve_n(int time[], int minutes, int n, int k) {
int count = 0;
int ans = 0;
for (int i = 0; i < n; ++i) {
bool start = true;
int check = solve_k(time, minutes, i, n, count, k);
ans = std::max({check, ans, count});
for (int j = 0; j < k; ++j) {
if (minutes - time[j] < 0) {
start = false;
break;
}
minutes -= time[j];
++count;
}
count += start;
}
return ans;
}
int main() {
int n, k, m;
std ::cin >> n >> k >> m;
int time[k];
for (int i = 0; i < k; ++i) {
std::cin >> time[i];
}
std::sort(time, time + k);
int ans_1 = 0, ans_2 = 0;
int minutes = m;
for (int i = 0; i < n; ++i) {
bool start = true;
for (int j = 0; j < k; ++j) {
if (minutes - time[j] < 0) {
start = false;
break;
}
minutes -= time[j];
++ans_1;
}
ans_1 += start;
}
int ans_3 = solve_n(time, m, n, k);
std::cout << std::max({ans_1, ans_3});
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int inf = 1e9;
const int MOD = 1e9 + 7;
const int nax = 1000000 + 10;
long long int n, k, M, arr[nax];
long long int solve(vector<long long int> v, long long int money) {
long long int ans = 0;
sort(v.begin(), v.end());
long long int spent = 0;
for (auto x : v) {
if (spent + x > money) break;
spent += x;
ans++;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin >> n >> k >> M;
long long int sum = 0;
for (int i = 1; i <= k; i++) cin >> arr[i], sum += arr[i];
long long int ans = 0;
for (int i = 0; i <= n; i++) {
long long int cur = (sum * i);
if (cur > M) continue;
long long int left = M - cur;
long long int curscore = (k + 1) * i;
vector<long long int> v;
for (int j = i + 1; j <= n; j++) {
for (int l = 1; l <= k; l++) v.push_back(arr[l]);
}
curscore += solve(v, left);
ans = max(ans, curscore);
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 50;
int n, k, M, t[N];
int main() {
scanf("%d%d%d", &n, &k, &M);
long long suma = 0;
for (int i = 1; i <= k; ++i) {
scanf("%d", &t[i]);
suma += t[i];
}
int wyn = 0;
sort(t + 1, t + k + 1);
for (int I = 0; I <= n; ++I) {
long long ile_musze = suma * I;
int zysk = (k + 1) * I;
for (int i = 1; i <= k; ++i) {
int xd = max(0, min(n - I, (int)(M - ile_musze) / t[i]));
zysk += xd;
ile_musze += 1LL * t[i] * xd;
}
if (ile_musze <= M) {
wyn = max(wyn, zysk);
}
}
printf("%d\n", wyn);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
long long n, k, m;
cin >> n >> k >> m;
long long a[k + 1];
long long A = 0;
for (long long i = 1; i <= k; i++) {
cin >> a[i];
A += a[i];
}
sort(a + 1, a + 1 + k);
long long answ = 0;
for (long long i = 0; i <= n; i++) {
if (A * i > m) break;
long long cur = (k + 1) * i;
long long c = m - (i * A);
for (long long j = 1; j <= k; j++) {
for (long long l = i + 1; l <= n; l++) {
if (a[j] <= c) {
c -= a[j];
cur++;
}
}
}
answ = max(answ, cur);
}
cout << answ << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mod = 1000000007;
const long long inf = 1000000000000;
int main() {
int n, k;
long long m;
cin >> n >> k >> m;
vector<long long> v;
long long s = 0;
for (int i = 0; i < k; i++) {
long long x;
cin >> x;
v.push_back(x);
}
sort(v.begin(), v.end());
for (int i = 0; i < v.size(); i++) {
s += v[i];
}
long long mx = 0;
int i = 0;
long long tm = m;
int cnt = n;
while (true) {
if (cnt == 0) {
i++;
cnt = n;
}
if (i == v.size()) {
break;
}
if (tm / v[i] == 0) {
break;
}
int k1 = min(tm / v[i], (long long)cnt);
mx += k1;
tm -= k1 * v[i];
cnt -= k1;
}
for (int i = 1; i <= n; i++) {
if (m - i * s < 0) {
break;
}
long long tm = m - i * s;
long long mx1 = i * k + i;
int cnt = n - i;
int j = 0;
while (true) {
if (cnt == 0) {
j++;
cnt = n - i;
}
if (j == v.size()) {
break;
}
if (tm / v[j] == 0) {
break;
}
int k = min(tm / v[j], (long long)cnt);
mx1 += k;
tm -= k * v[j];
cnt -= k;
}
mx = max(mx, mx1);
}
cout << mx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 50;
int a[MAXN];
int solve(int n, int time, int k) {
int ans = 0;
for (int i = 1; i <= k; i++) {
if (time >= n * a[i]) {
ans += n;
if (i == k) {
ans += n;
}
time -= n * a[i];
} else {
ans += time / a[i];
if (i == k) {
ans += time / a[i];
}
break;
}
}
return ans;
}
int main(void) {
int n, k, m;
cin >> n >> k >> m;
int num = 0;
for (int i = 1; i <= k; i++) {
cin >> a[i];
num += a[i];
}
sort(a + 1, a + 1 + k);
int ans = 0;
for (int i = 0; i <= n; i++) {
if (m >= num * i) {
ans = max(ans, solve(n - i, m - num * i, k) + i * (k + 1));
} else
break;
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, m;
int arr[50];
int sub[50];
int result = 0;
int task_tot_time = 0;
void take(int score, int t) {
if (0 >= t) return;
int tt = t;
int ss = score;
for (decltype(0) i = 0; i < k; i++) {
int su = sub[i];
while (su > 0) {
if (arr[i] > tt) break;
ss++;
tt -= arr[i];
su--;
}
}
result = max(result, ss);
if (t >= task_tot_time) {
int task_left = sub[0];
for (decltype(1) i = 1; i < k; i++) task_left = min(task_left, sub[i]);
if (task_left == 0) return;
for (decltype(0) i = 0; i < k; i++) sub[i]--;
result = max(result, score + k + 1);
take(score + k + 1, t - task_tot_time);
}
}
int main() {
scanf("%d", &n) == 0, scanf("%d", &k) == 0, scanf("%d", &m) == 0;
for (decltype(0) i = 0; i < k; i++) {
scanf("%d", &arr[i]) == 0;
task_tot_time += arr[i];
}
for (decltype(0) i = 0; i < k; i++) sub[i] = n;
sort(arr, arr + k);
take(0, m);
printf("%d", result);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAXN = 2e5 + 5;
long long n, m, k, T[MAXN], sum;
int main() {
while (~scanf("%lld %lld %lld", &n, &k, &m)) {
for (long long i = 1; i <= k; i++) {
scanf("%lld", &T[i]);
sum += T[i];
}
sort(T + 1, T + 1 + k);
long long ans = 0;
for (long long i = 0; i <= n; i++) {
if (m >= sum * i) {
long long tem = i * (k + 1);
long long tim = m - sum * i;
for (long long j = 1; j <= k; j++) {
if (tim > T[j] * (n - i)) {
tim -= T[j] * (n - i);
tem += n - i;
} else {
tem += tim / (T[j]);
break;
}
}
ans = max(ans, tem);
}
}
printf("%lld\n", ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
long long M;
int N, K;
long long costs[50];
int greedy_subtasks(long long budget, int tasks) {
int score = 0;
for (int i = 0; i < K; i++) {
int to_solve = budget / costs[i];
to_solve = min(to_solve, tasks);
budget -= to_solve * costs[i];
score += to_solve;
}
return score;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(NULL);
cin >> N >> K >> M;
long long task_cost = 0;
for (int i = 0; i < K; i++) {
cin >> costs[i];
task_cost += costs[i];
}
sort(costs, costs + K);
int best = 0;
for (int i = 0; i <= N; i++) {
long long budget = M - task_cost * i;
if (budget < 0) continue;
int cur = (i * (K + 1)) + greedy_subtasks(budget, N - i);
best = max(best, cur);
}
cout << best << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int power(long long int x, long long int y) {
long long int res = 1;
while (y > 0) {
if (y & 1) res = (res * x) % 998244353;
y = y >> 1;
x = (x * x) % 998244353;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, k, m;
cin >> n >> k >> m;
long long int a[k];
long long int sum = 0;
for (int i = 0; i < k; i++) {
cin >> a[i];
sum += a[i];
}
sort(a, a + k);
long long int money = 0;
for (int i = 0; i <= n; i++) {
long long int T = 0, tmp = 0;
T += sum * i;
if (m >= T) tmp += (k * i) + i;
for (int j = 0; j < k && T < m; j++) {
tmp += min((m - T) / a[j], (long long int)n - i);
T += a[j] * min((m - T) / a[j], (long long int)n - i);
if ((m - T) / a[j] == 0) break;
}
money = max(tmp, money);
}
cout << money << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k;
long long m;
int t[50];
long long dp[50][2505];
int main(void) {
scanf("%d%d%lld", &n, &k, &m);
for (int i = 0; i < k; i++) {
scanf("%d", &t[i]);
}
sort(t, t + k);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n * (k + 1); j++) {
dp[i][j] = 1000000000007;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= i * (k + 1); j++) {
if (dp[i][j] < 1000000000007) {
long long cost = 0;
for (int a = 0; a <= k; a++) {
dp[i + 1][j + a + (a == k ? 1 : 0)] =
min(dp[i + 1][j + a + (a == k ? 1 : 0)], dp[i][j] + cost);
cost += (long long)t[a];
}
}
}
}
int res = 0;
for (int i = 0; i <= (k + 1) * n; i++) {
if (m >= dp[n][i]) {
res = max(res, i);
}
}
printf("%d\n", res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, k, t[50], ans;
long long m;
void code() {
cin >> n >> k >> m;
for (int i = 0; i < k; i++) cin >> t[i];
sort(t, t + k);
long long sum = accumulate(t, t + k, 0LL);
for (int cnt = 0; cnt < n + 1; cnt++) {
if (m - sum * cnt < 0) break;
long long rem = m - sum * cnt;
int tmpans = cnt * (k + 1);
for (int i = 0; i < k; i++) {
for (int j = 0; j < n - cnt; j++) {
if (rem - t[i] >= 0) {
rem -= t[i];
tmpans++;
}
}
}
ans = max(ans, tmpans);
}
cout << ans << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
code();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, k, M;
cin >> n >> k >> M;
long long int arr[k + 1];
long long int i, j, x;
for (i = 1; i <= k; i++) cin >> arr[i];
long long int total_time = 0;
for (i = 1; i <= k; i++) total_time += arr[i];
sort(arr + 1, arr + k + 1);
long long int max_points = -1;
for (i = 0; i <= n; i++) {
long long int temp = M;
long long int curr_points = 0;
if ((total_time)*i <= temp) {
temp -= (total_time * i);
curr_points = i * (k + 1);
long long int left_tasks = n - i;
for (x = 1; x <= k; x++) {
for (j = 1; j <= left_tasks; j++) {
if (temp >= arr[x]) {
temp -= arr[x];
curr_points++;
}
}
}
max_points = max(max_points, curr_points);
} else
break;
}
cout << max_points << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, k, m, c = 0, c1 = 0, x = 1, p = 0, z = 0;
cin >> n >> k >> m;
int arr[k];
for (int i = 0; i < k; i++) {
cin >> arr[i];
c += arr[i];
p += arr[i];
z += arr[i];
}
sort(arr, arr + k);
for (int j = 1; j <= n; j++) {
if (c * j <= m) {
c1 += k + 1;
x = j + 1;
} else {
c = c * (x - 1);
break;
}
}
bool b = 0;
if (c < m) {
for (int i = 0; i < k; i++) {
for (int j = x; j <= n; j++) {
if (c + arr[i] <= m) {
c += arr[i];
c1++;
if (i == k - 1) {
c1++;
}
} else {
b = 1;
break;
}
}
if (b) {
break;
}
}
}
int s = 0, s1 = 0;
b = 0;
for (int i = 0; i < k; i++) {
for (int j = 1; j <= n; j++) {
if (s + arr[i] <= m) {
s += arr[i];
s1++;
if (i == k - 1) {
s1++;
}
} else {
b = 1;
break;
}
}
if (b) {
break;
}
}
int a = 0, a1 = 0, u = 1;
b = 0;
for (int i = 0; i < k; i++) {
for (int j = u; j <= n; j++) {
if (a + arr[i] <= m) {
a += arr[i];
a1++;
if (i == k - 1) {
a1++;
}
} else {
b = 1;
break;
}
}
p -= arr[i];
if (a + p <= m && p != 0) {
u++;
a1 += k - i;
a += p;
}
if (b) {
break;
}
}
int u1 = 0, v = 0, h = 0, h1 = 0;
for (int l = 1; l <= n; l++) {
if (z * l <= m && m != 0 && z != 0) {
v += k + 1;
u1++;
h1 = z * l;
} else {
break;
}
int b1 = 0, g = 0;
for (int i = 0; i < k; i++) {
for (int j = u1 + 1; j <= n; j++) {
if (h1 + arr[i] <= m) {
h1 += arr[i];
g++;
if (i == k - 1) {
g++;
}
} else {
b1 = 1;
break;
}
}
if (b1) {
break;
}
}
if (v + g > h) {
h = v + g;
}
}
cout << max(c1, max(a1, max(h, s1))) << endl;
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.