text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int a[3];
int n;
cin >> n;
for (int i = 0; i < 3; i++) cin >> a[i];
sort(a, a + 3);
int x = n / a[2] + 1, y = n / a[1] + 1, z = n / a[0] + 1;
int piece = 0;
int flag = 0;
if (n % a[0] == 0) {
cout << n / a[0];
return 0;
}
for (int i = 0; i <= x; i++) {
for (int j = 0; j <= y; j++) {
if (a[0] == a[1]) {
if (a[1] * j + a[2] * i == n) {
piece = max(piece, i + j);
break;
}
} else
for (int k = 0; k <= z; k++) {
if (a[0] * k + a[1] * j + a[2] * i == n) {
piece = max(piece, i + j + k);
break;
}
}
}
if (a[1] == a[2]) break;
}
cout << piece;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long int i, j, ae, be, ce, ne, ke, ans, rem;
while (cin >> ne >> ae >> be >> ce) {
ans = 0;
for (i = 0; i * ae <= ne; ++i) {
for (j = 0; i * ae + j * be <= ne; ++j) {
rem = ne - i * ae - j * be;
if (rem % ce == 0) {
ke = rem / ce;
ans = max(ans, i + j + ke);
}
}
}
cout << ans << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int d[3] = {a, b, c};
sort(d, d + 3);
int t = 0, g = 0;
for (int i = 0; i <= n / d[2]; i++) {
for (int j = 0; j <= n / d[1]; j++) {
for (int k = 0; k <= n / d[0]; k++) {
if (k * d[0] + j * d[1] + i * d[2] == n) {
g = k + j + i;
t = 1;
break;
}
}
if (t == 1) break;
}
if (t == 1) break;
}
t = 0;
int f = 0;
for (int i = 0; i <= n / d[1]; i++) {
for (int j = 0; j <= n / d[2]; j++) {
for (int k = 0; k <= n / d[0]; k++) {
if (k * d[0] + j * d[2] + i * d[1] == n) {
f = k + j + i;
t = 1;
break;
}
}
if (t == 1) break;
}
if (t == 1) break;
}
cout << max(f, g);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4010;
int dp[N], a, b, c, n;
int solve(int cut) {
if (cut == 0) {
return 0;
}
if (cut < 0) {
return -INT_MAX;
}
if (dp[cut] != -1) {
return dp[cut];
}
int r = max(solve(cut - a), max(solve(cut - b), solve(cut - c))) + 1;
dp[cut] = r;
return dp[cut];
}
int main() {
memset(dp, -1, sizeof(dp));
cin >> n >> a >> b >> c;
cout << solve(n) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int arr[3];
int a[4001];
int n;
int f(int sum) {
if (sum == n) return 0;
if (sum > n) return -1;
if (a[sum] > -2) return a[sum];
int max = -2;
for (int i = 0; i < 3; ++i) {
int ss = f(arr[i] + sum) + 1;
if (ss == 0) ss = -1;
if (max < ss) max = ss;
}
return a[sum] = max;
}
int main() {
while (cin >> n >> arr[0] >> arr[1] >> arr[2]) {
memset(a, -2, sizeof a);
cout << f(0) << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class t1, class t2>
using pi = pair<t1, t2>;
template <class t>
using vi = vector<t>;
template <class t>
using vvi = vi<vi<t>>;
template <class t1, class t2>
using um = unordered_map<t1, t2>;
template <typename T>
void printv(vi<T> arr) {
for (long long i = 0; i < arr.size(); ++i) cout << arr[i] << " ";
cout << "\n";
}
template <class T>
inline void amin(T &x, const T &y) {
if (y < x) x = y;
}
template <class T>
inline void amax(T &x, const T &y) {
if (x < y) x = y;
}
struct jutsu {
int a, b, c;
};
bool jutsu_compare(jutsu s1, jutsu s2) {
if (s1.a == s2.a) {
if (s1.b < s2.b)
return true;
else
return false;
} else {
if (s1.a > s2.a)
return true;
else
return false;
}
}
long long ncr(long long n, long long k) {
long long res = 1;
if (k > n - k) k = n - k;
for (long long i = 0; i < k; ++i) {
res *= (n - i);
res /= (i + 1);
}
return res;
}
vector<long long> prime(1000005, true);
vi<int> primev;
void seive(void) {
prime[1] = prime[0] = false;
for (long long i = 2; i < 1000005; i++) {
if (prime[i]) {
primev.push_back(i);
for (long long j = i * 2; j < 1000005; j += i) {
prime[j] = 0;
}
}
}
}
long long max(long long a, long long b) { return (a > b) ? a : b; }
long long min(long long a, long long b) { return (a < b) ? a : b; }
unsigned long long power(unsigned long long x, int y, int p) {
unsigned long long res = 1;
x = x % p;
while (y > 0) {
if (y & 1) res = (res * x) % p;
y = y >> 1;
x = (x * x) % p;
}
return res;
}
unsigned long long modInverse(unsigned long long n, int p) {
return power(n, p - 2, p);
}
unsigned long long nCrModPFermat(unsigned long long n, int r, int p) {
if (n < r) return 0;
if (r == 0) return 1;
unsigned long long fac[n + 1];
fac[0] = 1;
for (int i = 1; i <= n; i++) fac[i] = (fac[i - 1] * i) % p;
return (fac[n] * modInverse(fac[r], p) % p * modInverse(fac[n - r], p) % p) %
p;
}
void swap(long long &a, long long &b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
long long index(vector<long long> arr, long long val) {
auto it = find((arr).begin(), (arr).end(), val);
if (it != arr.end()) {
long long ind = it - arr.begin();
return ind;
} else
return -1;
}
long long fact(long long x) {
if (x == 1 || x == 0) return 1;
return (x * (fact(x - 1)));
}
bool binarySearch(vector<long long> arr, long long val, long long i,
long long j) {
if (i > j) return 0;
if (arr[i + ((j - i) / 2)] == val) return 1;
if (arr[i + ((j - i) / 2)] < val)
return binarySearch(arr, val, i + ((j - i) / 2) + 1, j);
return binarySearch(arr, val, i, i + ((j - i) / 2) - 1);
}
const int N = 2e5 + 5;
int tree[4 * N];
void build(int a[], int v, int tl, int tr) {
if (tl == tr) {
tree[v] = a[tl];
} else {
int tm = (tl + tr) / 2;
build(a, v * 2, tl, tm);
build(a, v * 2 + 1, tm + 1, tr);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
}
void update(int v, int tl, int tr, int pos, int new_val) {
if (tl == tr) {
tree[v] = new_val;
} else {
int tm = (tl + tr) / 2;
if (pos <= tm)
update(v * 2, tl, tm, pos, new_val);
else
update(v * 2 + 1, tm + 1, tr, pos, new_val);
tree[v] = tree[v * 2] + tree[v * 2 + 1];
}
}
int sum(int v, int tl, int tr, int l, int r) {
if (l > r) return 0;
if (l == tl && r == tr) {
return tree[v];
}
int tm = (tl + tr) / 2;
return sum(v * 2, tl, tm, l, min(r, tm)) +
sum(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r);
}
void readSentence(void) {
string s, t;
getline(cin, s);
stringstream sent(s);
while (getline(sent, t, ' ')) {
cout << t << " ";
}
}
long long query(long long v, long long tl, long long tr, long long l,
long long r, long long &to) {
if (l > r) return 0;
if (l == tl && r == tr) {
to = min(to, tree[v]);
return tree[v];
}
long long tm = (tl + tr) / 2;
return (query(v * 2, tl, tm, l, min(r, tm), to) +
query(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, to));
}
void rangebuild(long long a[], long long v, long long tl, long long tr) {
if (tl == tr) {
tree[v] = a[tr];
} else {
long long tm = (tl + tr) / 2;
rangebuild(a, v * 2, tl, tm);
rangebuild(a, v * 2 + 1, tm + 1, tr);
tree[v] = 0;
}
}
void rangeupdate(long long v, long long tl, long long tr, long long l,
long long r, long long add) {
if (l > r) return;
if (l == tl && r == tr) {
tree[v] += (add);
} else {
long long tm = (tl + tr) / 2;
rangeupdate(v * 2, tl, tm, l, min(r, tm), add);
rangeupdate(v * 2 + 1, tm + 1, tr, max(l, tm + 1), r, add);
}
}
long long rangeget(long long v, long long tl, long long tr, long long pos) {
if (tl == tr) return tree[v];
long long tm = (tl + tr) / 2;
if (pos <= tm)
return tree[v] + rangeget(v * 2, tl, tm, pos);
else
return tree[v] + rangeget(v * 2 + 1, tm + 1, tr, pos);
}
void bitsetoperation(long long n) {
string binary = bitset<14>(n).to_string();
long long decimal = bitset<14>(binary).to_ulong();
}
int isSubstring(string s2, string s1) {
int M = s1.length();
int N = s2.length();
for (int i = 0; i <= N - M; i++) {
int j;
for (j = 0; j < M; j++)
if (s2[i + j] != s1[j]) break;
if (j == M) return i;
}
return 0;
}
vi<long long> visited(200005, 0);
map<long long, long long> mppdfs;
string b, a;
vi<long long> adj[200005];
set<set<long long>> second;
void dfs(long long u) {
visited[u] = 1;
for (auto x : adj[u]) {
if (!visited[x]) dfs(x);
}
}
void hinataVSsakura(void);
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long T = 1;
long long k = 1;
while (T--) {
hinataVSsakura();
}
return 0;
}
void hinataVSsakura(void) {
long long n, x, y, z;
cin >> n >> x >> y >> z;
long long c = 0;
for (long long a = 0; a < 4001; ++a) {
for (long long b = 0; b < 4001; ++b) {
long long xx = (n - (x * a) - (y * b));
if (xx % z == 0 and xx / z >= 0) {
amax(c, a + b + xx / z);
}
}
}
cout << c << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[5001];
int main() {
cin >> n >> a >> b >> c;
dp[0] = 0;
for (int i = 1; i <= 5000; i++) dp[i] = -1e9;
for (int i = 0; i <= 5000; i++) {
if (i >= a) {
dp[i] = max(dp[i], dp[i - a] + 1);
}
if (i >= b) dp[i] = max(dp[i], dp[i - b] + 1);
if (i >= c) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f, mod = 1e9 + 7;
using namespace std;
int dx[]{1, -1, 0, 0, 1, 1, -1, -1};
int dy[]{0, 0, 1, -1, 1, -1, 1, -1};
long long OO = (1LL * oo * oo);
void K_K() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long a, b, c;
long long dp[100000];
long long sol(long long n) {
if (n < 0) {
return -1e9;
}
if (n == 0) {
return 0;
}
long long &ret = dp[n];
if (~ret) return ret;
long long ch1, ch2, ch3;
ch1 = sol(n - a) + 1;
ch2 = sol(n - b) + 1;
ch3 = sol(n - c) + 1;
return ret = max({ch1, ch2, ch3});
}
int main() {
K_K();
long long n;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
cout << sol(n);
}
|
#include <bits/stdc++.h>
using namespace std;
int i;
int main() {
int n, a, b, c, best = 0;
cin >> n >> a >> b >> c;
for (i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
int x, y, z;
x = a * i, y = j * b, z = n - x - y;
if (z % c == 0 && z > 0) {
best = max(best, i + j + (z / c));
}
if ((a * i + b * j) == n) best = max(best, i + j);
}
}
cout << best;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a, b, c;
void input() { cin >> n >> a >> b >> c; }
void solve() {
int max1 = -1;
for (int i = 0; i <= n / a; i++)
for (int j = 0; j <= (n - i * a) / b; j++) {
int k = (n - i * a - j * b);
if (k % c == 0) max1 = max(max1, i + j + k / c);
}
cout << max1 << endl;
}
int main() {
ios::sync_with_stdio(false);
cin.tie();
cout.tie();
input();
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, m = 0;
int main() {
scanf("%d %d %d %d", &n, &a, &b, &c);
if (a > b) swap(a, b);
if (a > c) swap(a, c);
if (b > c) swap(b, c);
for (int i = n / a; i >= 0; i--)
for (int j = (n - i * a) / b; j >= 0; j--)
if ((n - i * a - j * b) % c == 0)
m = max(m, i + j + (n - i * a - j * b) / c);
printf("%d\n", m);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 1e9 + 7;
const long long oo = 1e13;
int main() {
int n, a, b, c, ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i < 4001; ++i)
for (int j = 0; j < 4001; ++j) {
int ls = n - (a * i + b * j);
if (ls >= 0 && ls % c == 0) {
ans = max(ans, i + j + ls / c);
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4];
cin >> n >> a[1] >> a[2] >> a[3];
a[0] = 0;
sort(a, a + 4);
int cuts[4][n + 1];
memset(cuts, 0, sizeof(cuts));
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (j < a[i])
cuts[i][j] = cuts[i - 1][j];
else {
if (j == a[i])
cuts[i][j] = max(cuts[i - 1][j], 1);
else {
int k = j - a[i];
if (cuts[i][k] != 0)
cuts[i][j] = max(1 + cuts[i][k], cuts[i - 1][j]);
else
cuts[i][j] = cuts[i - 1][j];
}
}
}
}
cout << cuts[3][n];
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4005];
int arr[4];
int n = 3, m;
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> m >> arr[0] >> arr[1] >> arr[2];
memset(dp, -1, sizeof(dp));
dp[0] = 0;
int mx = 0;
for (int i = 0; i < 3; i++) {
for (int j = arr[i]; j <= m; j++) {
if (dp[j - arr[i]] != -1) {
dp[j] = max(dp[j], dp[j - arr[i]] + 1);
}
}
}
cout << dp[m] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, mem[4005];
int dp(int n) {
if (n < 0) return -1e9;
if (n == 0) return 0;
if (mem[n] != -1) return mem[n];
int p1 = 1 + dp(n - a);
int p2 = 1 + dp(n - b);
int p3 = 1 + dp(n - c);
return mem[n] = max({p1, p2, p3});
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d%d%d%d", &n, &a, &b, &c);
printf("%d", dp(n));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int INF = 1e18;
const int MOD = 1000000007;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, c;
int i, j;
cin >> n >> a >> b >> c;
int ans = 0;
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
int len = n - (a * i) - (b * j);
if ((len >= 0) && (len % c == 0)) {
ans = max(ans, (i + j + (len / c)));
}
}
}
cout << ans << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> res(n + 1);
if (a <= n) res[a] = 1;
if (b <= n) res[b] = 1;
if (c <= n) res[c] = 1;
res[0] = 0;
for (int i = 1; i <= n; i++) {
if (i - a > 0 && res[i - a] > 0) res[i] = max(res[i], res[i - a] + 1);
if (i - b > 0 && res[i - b] > 0) res[i] = max(res[i], res[i - b] + 1);
if (i - c > 0 && res[i - c] > 0) res[i] = max(res[i], res[i - c] + 1);
;
}
cout << res[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int tc[4];
set<int>::iterator itr;
;
int ca, cb, cc;
int *p1, *p2, *p3, *pn;
int n, a, b, c;
int r[4005];
int cont1, cont2, cont3;
int maior;
int corta() {
if (n > 0) {
}
}
int main() {
int i, j, k;
int x, y, z;
scanf(" %d %d %d %d", &n, &a, &b, &c);
tc[0] = a;
tc[1] = b;
tc[2] = c;
sort(tc, tc + 3);
for (i = 0; i < n / a + 1; i++) {
for (j = 0; j < n / b + 1; j++) {
int d = n - i * a - j * b;
if (d % c == 0 && d >= 0) {
k = d / c;
maior = max(maior, i + j + k);
}
}
}
printf("%d", maior);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 2e18 + 99;
int n, a, b, c;
int DP[1000000];
int solve(int n) {
if (n == 0) {
return 0;
}
if (DP[n] != -1) {
return DP[n];
}
int res = -100000;
if (n >= a) {
res = max(res, solve(n - a) + 1);
}
if (n >= b) {
res = max(res, solve(n - b) + 1);
}
if (n >= c) {
res = max(res, solve(n - c) + 1);
}
return DP[n] = res;
}
int main() {
memset(DP, -1, sizeof DP);
cin >> n >> a >> b >> c;
int ans = solve(n);
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[4005] = {0};
dp[a] = 1;
dp[b] = 1;
dp[c] = 1;
for (int i = 1; i < n + 1; i++) {
if (i - a >= 0) {
if (dp[i - a]) dp[i] = max(dp[i], dp[i - a] + 1);
}
if (i - b >= 0) {
if (dp[i - b]) dp[i] = max(dp[i], dp[i - b] + 1);
}
if (i - c >= 0) {
if (dp[i - c]) dp[i] = max(dp[i], dp[i - c] + 1);
}
}
cout << dp[n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace chrono;
long long int M = 1000000007;
long long int mod(long long int a) { return ((a % M + M) % M); }
long long int add(long long int a, long long int b) {
return mod(mod(a) + mod(b));
}
long long int multiply(long long int a, long long int b) {
return mod(mod(a) * mod(b));
}
long long int min(long long int a, long long int b) {
if (a < b) return a;
return b;
}
long long int max(long long int a, long long int b) { return (a > b) ? a : b; }
long long int modexpo(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = (res * a) % M;
a = (a * a) % M;
b /= 2;
}
return res;
}
long long int mulmod(long long int a, long long int b, long long int mod) {
long long int res = 0;
a = a % mod;
while (b > 0) {
if (b % 2 == 1) res = (res + a) % mod;
a = (a * 2) % mod;
b /= 2;
}
return res % mod;
}
long long int binPower(long long int a, long long int n, long long int mod) {
long long int res = 1;
while (n) {
if (n & 1) res = mulmod(res, a, mod);
n >>= 1;
a = mulmod(a, a, mod);
}
return res % mod;
}
long long dp[4005];
long long rec(long long N, long long a, long long b, long long c) {
for (long long n = 0; n <= N; n++) {
if (n == 0) {
dp[n] = 0;
continue;
}
long long ans = -1e8;
if (n - a >= 0) ans = max(ans, dp[n - a]);
if (n - b >= 0) ans = max(ans, dp[n - b]);
if (n - c >= 0) ans = max(ans, dp[n - c]);
dp[n] = ans + 1;
}
return dp[N];
}
void solve() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
memset(dp, -1e8, sizeof dp);
cout << rec(n, a, b, c) << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n;
cin >> n >> a >> b >> c;
int ans = 0;
for (int x = 0; x <= 4000; x++) {
for (int y = 0; y <= 4000; y++) {
int zc = n - (a * x + b * y);
if (zc < 0) break;
double z = (zc / double(c));
if (z == int(z)) ans = max(ans, int(x + y + z));
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int x[3];
cin >> n >> x[0] >> x[1] >> x[2];
sort(x, x + 3);
a = x[0], b = x[1], c = x[2];
int ans[n + 1];
fill(ans, ans + n + 1, INT_MIN);
ans[0] = 0;
for (int j = 1; j <= n; j++) {
int mx = INT_MIN;
if (j - a >= 0 && mx < ans[j - a]) mx = ans[j - a];
if (j - b >= 0 && mx < ans[j - b]) mx = ans[j - b];
if (j - c >= 0 && mx < ans[j - c]) mx = ans[j - c];
ans[j] = 1 + mx;
}
cout << ans[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long dp[4005];
long long a, b, c;
long long maximum(long long n) {
if (n < 0) return -9999999;
if (n == 0) return 0;
if (dp[n] != -1) return dp[n];
return dp[n] = 1 + max(maximum(n - a), max(maximum(n - b), maximum(n - c)));
}
void solve() {
long long n;
cin >> n;
cin >> a >> b >> c;
memset(dp, -1, sizeof(dp));
cout << maximum(n) << "\n";
}
signed main() {
mt19937_64 rnd(chrono::system_clock::now().time_since_epoch().count());
ios_base ::sync_with_stdio(0);
cin.tie(0);
solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int f[4005], n, a, i, j = 0;
fill(f + 1, f + 4005, -1e9);
cin >> n;
while (j < 3) {
cin >> a;
for (i = a; i <= n; i++) f[i] = max(f[i], f[i - a] + 1);
j++;
}
cout << f[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const int N = 100000 + 100;
const int inf = 0x7fffffff;
int n, a, b, c;
int f[N];
int main() {
scanf("%d%d%d%d", &n, &a, &b, &c);
f[a] = 1;
f[b] = 1;
f[c] = 1;
for (int i = min(a, min(b, c)); i <= n; i++) {
if (f[i]) {
f[i + a] = max(f[i + a], f[i] + 1);
f[i + b] = max(f[i + b], f[i] + 1);
f[i + c] = max(f[i + c], f[i] + 1);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long n, a, b, c, p1 = 1;
cin >> n >> a >> b >> c;
for (long long i = 0; i <= 4000; i++) {
for (long long j = 0; j <= 4000; j++) {
long long k = n - a * i - b * j;
if (k >= 0 && k % c == 0) p1 = max(p1, i + j + k / c);
}
}
cout << p1 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[4];
long long dp[5005];
int main() {
cin >> n >> a[0] >> a[1] >> a[2];
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < 3; i++)
for (int j = a[i]; j <= n; j++)
if (dp[j - a[i]] != -1) dp[j] = max(dp[j], dp[j - a[i]] + 1);
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4007];
int main() {
ios::sync_with_stdio(false);
int n, a;
cin >> n;
fill(dp + 1, dp + 4007, -1e9);
for (int i = 0; i < 3; i++) {
cin >> a;
for (int j = a; j <= n; j++) {
dp[j] = max(dp[j], dp[j - a] + 1);
}
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long T, k, a, c, n, m, b, r, x, y, z, ans, s, p, q, t;
unordered_map<long long, long long> mp;
int recur(long long m) {
if (m == 0) return 0;
if (m < 0) return -1e9;
if (mp.count(m)) {
return mp[m];
} else {
return mp[m] = 1 + max(recur(m - a), max(recur(m - b), recur(m - c)));
}
}
void solve() {
cin >> n >> a >> b >> c;
ans = recur(n);
cout << ans << "\n";
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
T = 1;
while (T--) solve();
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, a, b, c;
long max = -1;
cin >> n >> a >> b >> c;
for (long i = 0; a * i <= n; i++) {
for (long j = 0; b * j <= n; j++) {
int k = (n - i * a - b * j) / c;
if (k >= 0 && i * a + j * b + k * c == n) {
if (max < i + j + k) max = i + j + k;
}
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int x, y, z, p = 0, i;
i = min(a, min(b, c));
i = n / i;
for (x = i; x >= 0; x--) {
for (y = 0; y <= i; y++) {
z = abs((n - (a * x + b * y)) / c);
if ((a * x + b * y + c * z) == n) {
p = max(p, x + y + z);
}
}
}
cout << p << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int res = -1;
for (int i = 0; i <= 4000; i++)
for (int j = 0; j <= 4000; j++) {
if (n - i * a - j * b >= 0 && (n - i * a - j * b) % c == 0) {
if (i + j + (n - i * a - j * b) / c > res)
res = i + j + (n - i * a - j * b) / c;
}
}
cout << res;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = (int)(1e5 + 5);
int n, a, b, c;
int d[5000];
int main() {
ios_base::sync_with_stdio(false);
cin.tie();
cin >> n >> a >> b >> c;
memset(d, -1, sizeof(d));
d[0] = 0;
for (int i = 1; i <= n; i++) {
if (i >= a && d[i - a] >= 0) d[i] = max(d[i], d[i - a] + 1);
if (i >= b && d[i - b] >= 0) d[i] = max(d[i], d[i - b] + 1);
if (i >= c && d[i - c] >= 0) d[i] = max(d[i], d[i - c] + 1);
}
cout << d[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e2;
long long n, a, b, c;
vector<long long> z;
long long dp(long long i) {
if (i > n + 1) {
return -100000;
}
if (i == n + 1) {
return 0;
}
if (z[i] != -1) {
return z[i];
}
z[i] = max(1 + dp(i + a), max(1 + dp(i + b), 1 + dp(i + c)));
return z[i];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
{
cin >> n >> a >> b >> c;
z.resize(n + 1, -1);
long long ans = dp(1);
cout << ans;
return 0;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
cin >> a;
cin >> b;
cin >> c;
int len = 3;
int arr[] = {a, b, c};
sort(arr, arr + 3);
if (arr[1] == arr[2]) len--;
if (arr[0] == arr[1]) {
len--;
arr[1] = arr[2];
}
int dp[n + 1];
dp[0] = 0;
for (int i = 1; i < n + 1; i++) {
dp[i] = 0;
for (int j = 0; j < len; j++) {
if (i == arr[j]) dp[i] = max(1, dp[i]);
if (i > arr[j])
if (dp[i - arr[j]] != 0) dp[i] = max(dp[i], dp[i - arr[j]] + 1);
}
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int s, a, b, c, e = 0, f = 0, g = 0, d = 0, h = 0, r = 0;
cin >> s >> a >> b >> c;
for (int i = 0; i <= s; i++) {
for (int j = 0; j <= s; j++) {
g = (i * a) + (j * b);
if (s >= g && (s - g) % c == 0) {
h = (s - g) / c;
r = max(r, i + j + h);
}
}
}
cout << r << endl;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization("unroll-loops")
using namespace std;
int arr[4], Max[4005];
int main() {
int x;
cin >> x >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
for (int i = 1; i <= x; i++) {
for (int j = 0; j < 3; j++) {
if (i >= arr[j] && Max[i - arr[j]] + 1 > Max[i]) {
if (i - arr[j] != 0) {
if (Max[i - arr[j]] != 0)
Max[i] = Max[i - arr[j]] + 1;
else
continue;
} else
Max[i] = Max[i - arr[j]] + 1;
}
}
}
cout << Max[x] << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dx[]{1, -1, 0, 0, 1, 1, -1, -1};
int dy[]{0, 0, 1, -1, 1, -1, 1, -1};
void K_K() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long nCr(long long n, long long r) {
long long ans = 1;
long long div = 1;
for (long long i = r + 1; i <= n; i++) {
ans = ans * i;
ans /= div;
div++;
}
return ans;
}
long long poow(long long x, long long k, long long mod) {
long long ret = 1;
while (k) {
if (k & 1) ret = (ret * x) % mod;
k >>= 1;
x = (x * x) % mod;
}
return ret;
}
long long n, a, b, c, dp[100000];
long long sol(int n) {
if (n == 0)
return 0;
else if (n < 0)
return -1e6;
if (dp[n] != -1) return dp[n];
long long x1 = sol(n - a);
long long x2 = sol(n - b);
long long x3 = sol(n - c);
return dp[n] = max({x1, x2, x3}) + 1;
}
int main() {
K_K();
long long n;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
sol(n);
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int v[3];
cin >> n >> v[0] >> v[1] >> v[2];
int *mc = new int[n + 1];
for (int i = 0; i < n + 1; i++) mc[i] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
int a = v[j];
if (a <= i && mc[i - a] + 1 > mc[i])
if (i - a == 0 || mc[i - a] > 0) mc[i] = mc[i - a] + 1;
}
}
cout << mc[n] << endl;
return EXIT_SUCCESS;
}
|
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline bool fs(T &x) {
int c = getchar();
int sgn = 1;
while (~c && c < '0' || c > '9') {
if (c == '-') sgn = -1;
c = getchar();
}
for (x = 0; ~c && '0' <= c && c <= '9'; c = getchar()) x = x * 10 + c - '0';
x *= sgn;
return ~c;
}
int ara[6];
int dp[4005][4];
int solv(int n, int cnt) {
if (n < 0) return INT_MIN;
if (n == 0) return 0;
if (dp[n][cnt] != -1) return dp[n][cnt];
int mx = -100000;
for (int i = 0; i < 3; i++) mx = max(mx, solv(n - ara[i], i) + 1);
return dp[n][cnt] = mx;
}
int main() {
int n;
fs(n);
fs(ara[0]);
fs(ara[1]);
fs(ara[2]);
memset(dp, -1, sizeof(dp));
cout << solv(n, 0) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4002;
int mem[N][N];
int a, b, c, n, minn;
int bt(int rem, int pre) {
if (rem < 0) return -10000;
if (rem == 0) return 0;
int &reff = mem[rem][pre];
if (reff != -1) return reff;
int c1 = 0, c2 = 0, c3 = 0;
c1 = bt(rem - a, a) + 1;
c2 = bt(rem - b, b) + 1;
c3 = bt(rem - c, c) + 1;
return reff = max({c1, c2, c3});
}
int main() {
memset(mem, -1, sizeof mem);
scanf("%d%d%d%d", &n, &a, &b, &c);
cout << bt(n, 0);
return 0;
}
|
#include <bits/stdc++.h>
int M[4001];
int V[3];
using namespace std;
int calc(int i) {
int a = 0, b = 0, c = 0;
if (i >= V[0]) a = M[i - V[0]];
if (i >= V[1]) b = M[i - V[1]];
if (i >= V[2]) c = M[i - V[2]];
if (a || b || c) return 1 + max(max(a, b), c);
return 0;
}
int main() {
int n, a, b, c;
scanf("%d %d %d %d", &n, V, V + 1, V + 2);
memset(M, 0, sizeof(int) * (n + 1));
for (int i = 0; i < 3; i++) M[V[i]] = 1;
for (int i = 0; i <= n; i++) {
M[i] = max(calc(i), M[i]);
}
printf("%d\n", M[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int sum = 0;
int x1 = n / a;
int x2 = n / b;
for (int i = 0; i <= x1; i++) {
for (int j = 0; j <= x2; j++) {
int x3 = n - i * a - j * b;
if (x3 % c != 0 || x3 < 0) continue;
int x4 = x3 / c;
sum = max(sum, i + j + x4);
}
}
cout << sum << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int t;
t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, n1, x, y, z, c1, c2, n2, n3, n4, f1, f2;
cin >> n1 >> x >> y >> z;
int c, m1, m2, m3;
f1 = 0;
f2 = 0;
m1 = min(min(x, y), z);
m3 = max(max(x, y), z);
if ((m1 == z && m3 == y) || (m1 == y && m3 == z)) {
m2 = x;
}
if ((m1 == x && m3 == y) || (m1 == y && m3 == x)) {
m2 = z;
}
if ((m1 == z && m3 == x) || (m1 == x && m3 == z)) {
m2 = y;
}
if (n1 % m1 == 0) {
cout << n1 / m1;
return 0;
} else {
n2 = n1 - (n1 % m1);
c = (n1 - (n1 % m1)) / m1;
}
n3 = n2;
n4 = n2;
c1 = c;
c2 = c;
for (;;) {
if (f1 == 0) {
if (n2 == 0) {
f1++;
}
if (((n1 - n2) % m2) == 0) {
c = c + (n1 - n2) / m2;
f1++;
} else {
n2 = n2 - m1;
c--;
}
}
if (f2 == 0) {
if (n3 == 0) {
f2++;
}
if ((n1 - n3) % m3 == 0) {
c1 = c1 + (n1 - n3) / m3;
f2++;
} else {
n3 = n3 - m1;
c1--;
}
}
if (f1 > 0 && f2 > 0) {
break;
}
}
for (;;) {
for (i = 1;; i++) {
if ((n1 - (n4 + m2 * i)) % m3 == 0 && ((n1 - (n4 + m2 * i)) / m3) >= 1) {
c2 = c2 + (n1 - (n4 + m2 * i)) / m3 + i;
cout << max(max(c, c1), c2);
return 0;
}
if (m2 * i > n4) {
goto loop;
}
}
loop:
i = 1;
n4 = n4 - m1;
c2--;
if (n4 < 0) {
break;
}
}
cout << max(c, c1);
}
|
#include <bits/stdc++.h>
using namespace std;
int t[4002][4002];
int solve(int n, int a, int b, int c, int op, int &ans) {
if (n == 0) {
ans = max(ans, op);
return ans;
}
if (t[n][op] != -1) {
return t[n][op];
}
if (a <= n) t[n][op] = max(ans, solve(n - a, a, b, c, op + 1, ans));
if (b <= n) t[n][op] = max(ans, solve(n - b, a, b, c, op + 1, ans));
if (c <= n) t[n][op] = max(ans, solve(n - c, a, b, c, op + 1, ans));
}
int main() {
memset(t, -1, sizeof(t));
int n, a, b, c, op = 0;
int ans = INT_MIN;
cin >> n >> a >> b >> c;
int arr[3] = {a, b, c};
sort(arr, arr + 3);
int x = solve(n, arr[2], arr[1], arr[0], op, ans);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
int arr[3];
cin >> n >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
int counter = 0;
if (n % arr[0] == 0) {
while (n > 0) {
counter++;
n -= arr[0];
}
cout << counter;
} else {
long long c_size = 0;
int ma = 0;
for (int i = 1; i < 1000; i++) {
c_size += i * arr[1];
if (c_size > n) {
break;
}
if ((n - c_size) % arr[0] == 0) {
counter = i + ((n - c_size) / arr[0]);
ma = max(ma, counter);
} else {
c_size = 0;
counter = 0;
}
}
for (int i = 0; i < 1000; i++) {
for (int j = 0; j < 1000; j++) {
c_size = arr[0] * i + arr[1] * j;
if (c_size > n) {
break;
}
c_size = n - c_size;
if (c_size % arr[2] == 0) {
counter = (i + j + (c_size / arr[2]));
}
ma = max(ma, counter);
}
}
cout << ma;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int min(int a, int b) {
if (a < b) {
return a;
}
return b;
}
int max(int a, int b, int c) {
if (a > b) {
return a;
}
return b;
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[n + 1];
fill(dp, dp + n + 1, -1e10);
dp[0] = 0;
for (int i = a; i <= n; i++) dp[i] = max(dp[i], dp[i - a] + 1);
for (int i = b; i <= n; i++) dp[i] = max(dp[i], dp[i - b] + 1);
for (int i = c; i <= n; i++) dp[i] = max(dp[i], dp[i - c] + 1);
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
int m = min(a, min(b, c));
for (int i = 0; i <= n / m; i++) {
for (int j = 0; j <= n / m; j++) {
int k = fabs(n - a * i - b * j) / c;
if (a * i + b * j + c * k == n) ans = max(ans, i + j + k);
}
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
long long int mine = min(a, min(b, c));
long long int x = 0, y = 0, z = 0;
long long int res = -1;
for (long long int i = 0; i < 4001; i++) {
x = i;
for (long long int j = 0; j < 4002; j++) {
y = j;
z = (n - (a * x + b * y)) / c;
if ((n - (a * x + b * y)) % c == 0 && z >= 0) res = max(res, x + y + z);
}
}
cout << res;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, dp[4001];
int f(int n) {
if (n == 0) return 0;
if (n < 0 || (n > 0 && n < a && n < b && n < c)) return -1395746835;
if (!dp[n]) dp[n] = max(f(n - a), max(f(n - b), f(n - c))) + 1;
return dp[n];
}
int main() {
cin >> n >> a >> b >> c;
memset(dp, 0, sizeof(dp));
cout << f(n) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
long long i, j;
long long temp;
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long max = 0;
for (i = 0; i < n + 1; i++) {
for (j = 0; j < n + 1; j++) {
long long k;
k = n - (a * i + b * j);
k /= c;
if (a * i + b * j + c * k == n && i + j + k > max && k >= 0) {
max = i + j + k;
}
}
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<int>> adj;
vector<int> vis;
int pre = 0, d = 0;
void dfs(int k) {
vis[k] = 1;
for (int i = 0; i < adj[k].size(); i++) {
if (vis[adj[k][i]] == 0) {
dfs(adj[k][i]);
}
}
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
int n, c, a, b;
cin >> n >> a >> b >> c;
int m = n;
int m1 = min(a, min(b, c));
int m3 = max(a, min(b, c));
int m2 = a + b + c - m1 - m3;
vector<int> cnt;
for (int i = m / m1; i >= 0; i--) {
for (int j = (m - m1 * i) / m2; j >= 0; j--) {
if ((m - m1 * i - m2 * j) % m3 == 0) {
cnt.push_back(i + j + (m - m1 * i - m2 * j) / m3);
}
}
}
int mat = 0;
for (long long i = 0; i < cnt.size(); i++) {
if (mat < cnt[i]) mat = cnt[i];
}
cout << mat << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
long long mem[4001];
long long dp(int n) {
if (n == 0) return 0;
if (n < 0) return -1 * (long long)1e6;
long long &ret = mem[n];
if (ret != -1) return ret;
return ret = max(dp(n - a) + 1, max(dp(n - b) + 1, dp(n - c) + 1));
}
int main() {
cin.tie(0);
std::ios::sync_with_stdio(false);
memset(mem, -1, sizeof(mem));
int n;
cin >> n >> a >> b >> c;
cout << dp(n);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename A, typename B>
string to_string(pair<A, B> p);
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);
string to_string(const string& s) { return '"' + s + '"'; }
string to_string(const char* s) { return to_string((string)s); }
string to_string(bool b) { return (b ? "true" : "false"); }
string to_string(vector<bool> v) {
bool first = true;
string res = "{";
for (int i = 0; i < static_cast<int>(v.size()); i++) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(v[i]);
}
res += "}";
return res;
}
template <size_t N>
string to_string(bitset<N> v) {
string res = "";
for (size_t i = 0; i < N; i++) {
res += static_cast<char>('0' + v[i]);
}
return res;
}
template <typename A>
string to_string(A v) {
bool first = true;
string res = "{";
for (const auto& x : v) {
if (!first) {
res += ", ";
}
first = false;
res += to_string(x);
}
res += "}";
return res;
}
template <typename A, typename B>
string to_string(pair<A, B> p) {
return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}
template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ")";
}
template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " +
to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}
void debug_out() { cerr << endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
cerr << " " << to_string(H);
debug_out(T...);
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b, c;
cin >> n >> a >> b >> c;
int ans = 0;
for (int x = 0; x <= n; x++)
for (int y = 0; y <= n; y++) {
int z = (n - (x * a) - (y * b));
if (z >= 0 && z % c == 0) ans = max(ans, x + y + z / c);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int main() {
int n, u = -1, s;
int a, b, c;
cin >> n;
cin >> a >> b >> c;
for (int i = 0; i <= (n / a); i++)
for (int j = 0; j <= (n / b); j++) {
s = i * a + j * b;
if ((n - s) >= 0)
if ((n - s) % c == 0)
if ((n - s) / c + i + j > u) {
u = (n - s) / c + i + j;
}
}
cout << u;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[100005], freq[100005];
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long int t = 1;
for (long long int tc = 1; tc <= t; tc++) {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
long long int ans = 0;
for (long long int x = 0; x <= 4000; x++) {
for (long long int y = 0; y <= 4000; y++) {
long long int zc = n - (a * x + b * y);
if (zc < 0) {
break;
}
if (zc % c == 0) {
long long int z = zc / c;
ans = max(ans, x + y + z);
}
}
}
cout << ans << '\n';
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
void cass() {
ios::sync_with_stdio(0);
cin.tie(0);
}
const int N = 4003;
int n, a[5], F[N];
void read() {
cin >> n >> a[1] >> a[2] >> a[3];
memset(F, -1, sizeof(F));
F[0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 1; j <= 3; ++j)
if (i >= a[j]) F[i] = max(F[i - a[j]], F[i]);
if (F[i] == -1) continue;
F[i]++;
}
cout << F[n];
}
int main() {
cass();
read();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 1e5 + 5;
const long long inf = 1e12;
long long n, a, b, c;
vector<long long> cache;
long long dp(long long i) {
if (i > n + 1) {
return -100000;
}
if (i == n + 1) {
return 0;
}
if (cache[i] != -1) {
return cache[i];
}
cache[i] = max({1 + dp(i + a), 1 + dp(i + b), 1 + dp(i + c)});
return cache[i];
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
cin >> n >> a >> b >> c;
cache.resize(n + 1, -1);
long long ans = dp(1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int i, j, k;
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> v;
int a1 = (n / a), a2 = (n / b), a3;
for (i = 0; i <= a1; i++) {
for (j = 0; j <= a2; j++) {
a3 = (n - i * a - j * b) / c;
if ((a3 >= 0) && ((a * i + b * j + c * a3) == n)) v.push_back(i + j + a3);
}
}
cout << *max_element(v.begin(), v.end()) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b, c;
int res = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n / a; ++i) {
for (int j = 0; a * i + b * j <= n; ++j) {
int k = (n - a * i - b * j) / c;
if (a * i + b * j + c * k == n) {
res = max(res, i + j + k);
}
}
}
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void scanint(int &x) {
register int c = 0;
x = 0;
int flag = 0;
for (; ((c != 45) && (c < 48 || c > 57)); c = getchar())
;
for (; ((c == 45) || (c > 47 && c < 58)); c = getchar()) {
if (c == 45)
flag = 1;
else
x = (x << 1) + (x << 3) + c - 48;
}
if (flag) x = -x;
}
int dp[10000];
int n, a, b, c;
int fnc(int id) {
if (id > n) return 0;
if (id == n) return 1;
if (dp[id] != -1) return dp[id];
int t1 = max(fnc(id + a), max(fnc(id + b), fnc(id + c)));
if (t1 > 0) t1++;
dp[id] = t1;
return dp[id];
}
int main() {
int t, m, i, j, k, l, ans, count, temp, sum, flag;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
;
cout << fnc(0) - 1;
return 0;
}
|
#include <bits/stdc++.h>
#pragma gcc optimize("ofast")
using namespace std;
long long modexp(long long a, long long b, long long m) {
long long r = 1;
a = a % m;
while (b > 0) {
if (b & 1) r = (r * a) % m;
b = b / 2;
a = (a * a) % m;
}
return r % m;
}
long long gcd(long long a, long long b) {
if (a == 0) return b;
return gcd(b % a, a);
}
vector<long long> bit;
void bit_update(long long x, long long n, long long val) {
while (x < n) {
bit[x] += val;
x += (x & (~x + 1));
}
}
long long bit_sum(long long x) {
long long sum = 0;
while (x > 0) {
sum += bit[x];
x -= (x & (~x + 1));
}
return sum;
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<long long> dp(n + 1, -1);
dp[0] = 0;
dp[min(a, n)] = dp[min(b, n)] = dp[min(c, n)] = 1;
for (long long i = 1; i < n + 2; i++) {
if (i - a > 0 && dp[i - a] != -1) dp[i] = max(dp[i], dp[i - a] + 1);
if (i - b > 0 && dp[i - b] != -1) dp[i] = max(dp[i], dp[i - b] + 1);
if (i - c > 0 && dp[i - c] != -1) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
long long f(long long x, long long y, long long n,
unordered_map<long long, long long> &mp) {
long long num;
if (n == 1)
num = x;
else if (n == 2)
num = y;
else if (mp.find(n) != mp.end())
num = mp[n];
else
num = (f(x, y, n - 1, mp) % 1000000007 - f(x, y, n - 2, mp) % 1000000007) %
1000000007;
mp[n] = num;
return num % 1000000007;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout.precision(10);
unordered_map<int, int> bottles;
unordered_map<int, vector<int>> open;
int n, a, b, c;
cin >> n >> a >> b >> c;
int d[] = {a, b, c};
vector<vector<int>> dp(n + 1, vector<int>(4));
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 3; j++) {
if (i == 0)
dp[i][j] = 0;
else if (j == 0)
dp[i][j] = INT_MIN;
else {
if (i - d[j - 1] >= 0)
dp[i][j] = max(dp[i][j - 1], 1 + dp[i - d[j - 1]][j]);
else
dp[i][j] = dp[i][j - 1];
}
}
}
cout << dp[n][3];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 2e4 + 3;
const int mod = 1e9 + 7;
const int INF = INT_MAX;
int dp[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n, a, b, c;
cin >> n >> a >> b >> c;
dp[a] = 1;
dp[b] = 1;
dp[c] = 1;
for (int i = min(a, min(b, c)) + 1; i <= n; i++) {
if (i > a && dp[i - a] > 0) dp[i] = max(dp[i], dp[i - a] + 1);
if (i > b && dp[i - b] > 0) dp[i] = max(dp[i], dp[i - b] + 1);
if (i > c && dp[i - c] > 0) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
const int oo = 0x3f3f3f3f, mod = 1e9 + 7;
using namespace std;
int dx[]{1, -1, 0, 0, 1, 1, -1, -1};
int dy[]{0, 0, 1, -1, 1, -1, 1, -1};
long long OO = (1LL * oo * oo);
void K_K() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
long long gcd(long long a, long long b) {
return b == 0 ? abs(a) : gcd(b, a % b);
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
long long n, a, b, c, dp[100000];
long long sol(int n) {
if (n == 0)
return 0;
else if (n < 0)
return -1e6;
if (dp[n] != -1) return dp[n];
long long x1 = sol(n - a);
long long x2 = sol(n - b);
long long x3 = sol(n - c);
return dp[n] = max({x1, x2, x3}) + 1;
}
int main() {
K_K();
long long n;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
sol(n);
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[n + 1], ta, tb, tc;
bool fa, fb, fc;
for (int i = 0; i <= n; i++) {
dp[i] = 0, ta = 0, tb = 0, tc = 0;
fa = false, fb = false, fc = false;
if (i >= a) {
if (i == a)
fa = true;
else if (dp[i - a] > 0)
fa = true;
ta = dp[i - a];
}
if (i >= b) {
if (i == b)
fb = true;
else if (dp[i - b] > 0)
fb = true;
tb = dp[i - b];
}
if (i >= c) {
if (i == c)
fc = true;
else if (dp[i - c] > 0)
fc = true;
tc = dp[i - c];
}
if (!fa && !fb && !fc) continue;
dp[i] = max(ta, max(tb, tc)) + 1;
}
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, ans = 0, a, b, c, i, j, k;
cin >> n >> a >> b >> c;
for (i = 0; i <= n; ++i)
for (j = 0; j <= n; ++j)
if ((n - i * a - j * b) >= 0 && (n - i * a - j * b) % c == 0) {
k = (n - i * a - j * b) / c;
if (i + j + k > ans) ans = i + j + k;
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dp(4001, -1);
int n, a, b, c;
int ribbons(int n) {
if (n < 0) return -1e9;
if (n == 0) return 0;
if (dp[n] != -1) return dp[n];
return dp[n] = max(max(1 + ribbons(n - a), 1 + ribbons(n - b)),
1 + ribbons(n - c));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cin >> n >> a >> b >> c;
cout << ribbons(n);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n;
vector<int> t(3);
for (int &i : t) {
cin >> i;
}
sort(t.begin(), t.end());
c = t[0];
b = t[1];
a = t[2];
int x, y, z;
int max = 0;
for (z = n / c; z >= 0; z--) {
for (y = (n - z * c) / b; y >= 0; y--) {
x = (n - z * c - y * b) / a;
if (x * a + y * b + z * c == n && x + y + z > max) {
max = x + y + z;
}
}
}
cout << max;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long mod = 1000000007;
const long long infinity = 1000000000000000000;
bool do_debug = false;
void solve() {
int n;
vector<int> v(3);
vector<int> subset_sum(4001, 0);
cin >> n >> v[0] >> v[1] >> v[2];
sort(v.begin(), v.end());
for (long long i = 0; i < 3; i++) {
for (long long j = 0; j < 4001; j++) {
if (subset_sum[j] > 0 || j == 0) {
if (j + v[i] > 4000) {
break;
}
subset_sum[j + v[i]] = max(subset_sum[j] + 1, subset_sum[j + v[i]]);
}
}
}
cout << subset_sum[n] << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int q = 1;
while (q-- > 0) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4001];
inline int max(int a, int b) { return a > b ? a : b; }
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
dp[0] = 1;
for (int i = 1; i <= n; i++) {
dp[i] = 0;
if (i >= a && dp[i - a]) {
dp[i] = max(dp[i], 1 + dp[i - a]);
}
if (i >= b && dp[i - b]) {
dp[i] = max(dp[i], 1 + dp[i - b]);
}
if (i >= c && dp[i - c]) {
dp[i] = max(dp[i], 1 + dp[i - c]);
}
}
cout << dp[n] - 1 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int tt = 1;
while (tt--) {
int n, a, b, c;
cin >> n >> a >> b >> c;
int mv = min(min(a, b), c);
int q = n / mv, ans = 0;
for (int x = 0; x <= q; x++) {
for (int y = 0; y <= q - x; y++) {
float z = ((n - x * a - y * b) * 1.0) / c;
if (z == (int)z && z >= 0) ans = max(ans, x + y + (int)z);
}
}
cout << ans;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, dp[10000], a, b, c;
bool pos[10000];
cin >> n >> a >> b >> c;
pos[0] = true;
for (i = 1; i <= n; i++) {
if (i < a && i < b && i < c)
pos[i] = false;
else {
if (i == a || i == b || i == c)
pos[i] = true;
else {
if (pos[i - a] || pos[i - b] || pos[i - c])
pos[i] = true;
else
pos[i] = false;
}
}
}
memset(dp, 0, sizeof(dp));
for (i = 1; i <= n; i++) {
if (pos[i]) {
dp[i] = LLONG_MIN;
if ((i >= a) && (pos[i - a]) && (dp[i - a] + 1 > dp[i])) {
dp[i] = dp[i - a] + 1;
}
if ((i >= b) && (pos[i - b]) && (dp[i - b] + 1 > dp[i])) {
dp[i] = dp[i - b] + 1;
}
if ((i >= c) && (pos[i - c]) && (dp[i - c] + 1 > dp[i])) {
dp[i] = dp[i - c] + 1;
}
}
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp(n + 1);
dp[0] = 1;
for (int i = 0; i <= n; i++) {
if (dp[i] == 0) {
continue;
}
if (i + a <= n) {
dp[i + a] = max(dp[i] + 1, dp[i + a]);
}
if (i + b <= n) {
dp[i + b] = max(dp[i] + 1, dp[i + b]);
}
if (i + c <= n) {
dp[i + c] = max(dp[i] + 1, dp[i + c]);
}
}
cout << dp[n] - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[4001];
int main() {
ios::sync_with_stdio(false);
int n, a, b, c, i;
cin >> n >> a >> b >> c;
fill(dp, dp + n + 1, INT_MIN);
dp[0] = 0;
for (i = 0; i < 4001; i++) {
if (i >= a) dp[i] = max(dp[i], dp[i - a] + 1);
if (i >= b) dp[i] = max(dp[i], dp[i - b] + 1);
if (i >= c) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k[4005];
int main() {
int n;
int a, b, c;
cin >> n >> a >> b >> c;
for (int i = n; i >= 0; --i) {
if (i == n) {
if (i - a >= 0) k[i - a] = 1;
if (i - b >= 0) k[i - b] = 1;
if (i - c >= 0) k[i - c] = 1;
} else {
if (i + a <= n && k[i + a]) k[i] = max(k[i], k[i + a] + 1);
if (i + b <= n && k[i + b]) k[i] = max(k[i], k[i + b] + 1);
if (i + c <= n && k[i + c]) k[i] = max(k[i], k[i + c] + 1);
}
}
cout << k[0];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, piece = 0, i, j, k;
cin >> n >> a >> b >> c;
if (a == 1 || b == 1 || c == 1)
piece = n;
else {
for (i = 0; i <= n / a; i++) {
for (j = 0; j <= (n - i * a) / b; j++) {
for (k = 0; k <= (n - i * a - j * b) / c; k++) {
if (i * a + j * b + k * c == n) piece = max(piece, i + j + k);
}
}
}
}
cout << piece;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
unordered_map<string, int> lookup;
int ans(int len, int arr[], int n) {
if (len == 0) return 1;
if (len < 0 || n == 0) return 0;
string key = to_string(len) + "|" + to_string(n);
if (lookup.find(key) == lookup.end()) {
int a = ans(len - arr[n - 1], arr, n);
if (a > 0) a += 1;
int b = ans(len, arr, n - 1);
lookup[key] = max(a, b);
}
return lookup[key];
}
int main() {
int len;
int *arr = new int[3];
cin >> len >> arr[0] >> arr[1] >> arr[2];
int a = ans(len, arr, 3);
if (a == 0)
cout << a;
else
cout << a - 1;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[5000];
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
dp[0] = 1;
dp[a] = dp[b] = dp[c] = 1;
for (int i = 1; i <= n; i++) {
int t1 = 0, t2 = 0, t3 = 0;
if (i - a > 0) {
if (dp[i - a] > 0)
t1 = dp[i - a] + 1;
else
t1 = 0;
}
if (i - b > 0) {
if (dp[i - b] > 0)
t2 = dp[i - b] + 1;
else
t2 = 0;
}
if (i - c > 0) {
if (dp[i - c] > 0)
t3 = dp[i - c] + 1;
else
t3 = 0;
}
dp[i] = (dp[i] > t1) ? dp[i] : t1;
dp[i] = (dp[i] > t2) ? dp[i] : t2;
dp[i] = (dp[i] > t3) ? dp[i] : t3;
}
cout << dp[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int lim = (int)2e9;
int main(int argc, char const *argv[]) {
int n, a, b, c;
scanf("%d %d %d %d", &n, &a, &b, &c);
std::vector<int> dp(n + 1, -lim);
dp[0] = 0;
for (int i = 1; i <= n; i++) {
if (i >= a) dp[i] = max(dp[i], dp[i - a] + 1);
if (i >= b) dp[i] = max(dp[i], dp[i - b] + 1);
if (i >= c) dp[i] = max(dp[i], dp[i - c] + 1);
}
printf("%d\n", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
signed main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
vector<long long> v(n + 1, -10000000000000);
v[0] = 0;
for (long long i = 1; i <= n; i++) {
if (i >= a) v[i] = max(v[i], v[i - a] + 1);
if (i >= b) v[i] = max(v[i], v[i - b] + 1);
if (i >= c) v[i] = max(v[i], v[i - c] + 1);
}
cout << v[n];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int arr[4001];
memset(arr, 0, sizeof arr);
arr[a] = 1;
arr[b] = 1;
arr[c] = 1;
for (int i = 0; i <= n; i++) {
if (i > a && arr[i - a] != 0) arr[i] = max(arr[i], arr[i - a] + 1);
if (i > b && arr[i - b] != 0) arr[i] = max(arr[i], arr[i - b] + 1);
if (i > c && arr[i - c] != 0) arr[i] = max(arr[i], arr[i - c] + 1);
}
cout << arr[n];
}
|
#include <bits/stdc++.h>
using namespace std;
long a, b, c, n, k, pas;
int main() {
cin >> n >> a >> b >> c;
for (int i = 0; i <= n / a; i++)
for (int j = 0; j <= (n - a * i) / b; j++) {
k = n - i * a - j * b;
if (k % c == 0) {
if (pas < i + j + k / c) {
pas = i + j + k / c;
}
}
}
cout << pas;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4321;
const int INF = 1e6;
int n, a, b, c;
int dp[N];
int f(int v) {
if (v < 0) return -INF;
if (v == 0) return 0;
if (dp[v] == -1) {
dp[v] = 1 + max({f(v - a), f(v - b), f(v - c)});
}
return dp[v];
}
int main() {
ios_base::sync_with_stdio(false);
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof dp);
cout << f(n) << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c;
vector<long long> cache;
long long dp(long long i) {
if (i > n + 1) {
return -100000;
}
if (i == n + 1) {
return 0;
}
if (cache[i] != -1) {
return cache[i];
}
cache[i] = max(1 + dp(i + a), max(1 + dp(i + b), 1 + dp(i + c)));
return cache[i];
}
int main() {
cin >> n >> a >> b >> c;
cache.resize(n + 1, -1);
long long ans = dp(1);
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, c;
cin >> n >> a >> b >> c;
int p = 0;
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; j++) {
int k = (n - (i * a) - (j * b)) / c;
int sum = ((i * a) + (j * b) + (k * c));
if (sum == n) {
p = max(p, (i + j + k));
}
}
}
cout << p << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, maximum;
int main() {
cin >> n >> a >> b >> c;
for (int x = 0; x <= n / a; ++x) {
for (int y = 0; y <= (n - x * a) / b; ++y) {
int z = (n - a * x - b * y) / c;
if (a * x + b * y + c * z == n) {
if (x + y + z > maximum) {
maximum = x + y + z;
}
}
}
}
cout << maximum << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int solve(int n, int a, int b, int c, int *dp) {
if (n == 0) return 0;
if (n < 0)
return -1;
else if (dp[n] != -1)
return dp[n];
else {
int ans = max(solve(n - a, a, b, c, dp),
max(solve(n - b, a, b, c, dp), solve(n - c, a, b, c, dp)));
if (ans >= 0) dp[n] = ans + 1;
}
return dp[n];
}
int main() {
int n, a, b, c, ans = -1;
int dp[4001];
cin >> n >> a >> b >> c;
for (int i = 0; i * a <= n; i++)
for (int j = 0; j * b + i * a <= n; j++) {
int res = (n - j * b - i * a);
if (res % c == 0) ans = max(ans, i + j + res / c);
}
cout << ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[4001];
int main() {
scanf("%d%d%d%d", &n, &a, &b, &c);
for (int i = 0; i <= n; ++i) dp[i] = -INT_MAX;
dp[0] = 0;
for (int i = a; i <= n; ++i) {
dp[i] = max(dp[i], dp[i - a] + 1);
}
for (int i = b; i <= n; ++i) {
dp[i] = max(dp[i], dp[i - b] + 1);
}
for (int i = c; i <= n; ++i) {
dp[i] = max(dp[i], dp[i - c] + 1);
}
printf("%d", dp[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, dp[4001];
int f(int x) {
if (x == 0) return 0;
if (x < 0 || (x > 0 && x < a && x < b && x < c)) return 0xACCE97ED;
if (!dp[x]) dp[x] = max(f(x - a), max(f(x - b), f(x - c))) + 1;
return dp[x];
}
int main() {
cin >> n >> a >> b >> c;
memset(dp, 0, sizeof(dp));
cout << f(n) << endl;
}
|
#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() {
ios::sync_with_stdio(NULL);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b, c;
cin >> n >> a >> b >> c;
int arr[] = {a, b, c};
int dp[n + 1];
for (int i = 0; i <= n; i++) dp[i] = INT_MIN;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if (i - arr[j] >= 0) dp[i] = max(dp[i], dp[i - arr[j]] + 1);
}
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
void cut(long long int n, long long int a, long long int b, long long int c) {
long long int T[n + 1];
for (int i = 0; i < n + 1; i++) {
long long int val1 = 0, val2 = 0, val3 = 0;
if (i - a >= 0 && T[i - a]) val1 = 1 + T[i - a];
if (i - b >= 0 && T[i - b]) val2 = 1 + T[i - b];
if (i - c >= 0 && T[i - c]) val3 = 1 + T[i - c];
T[i] = max(val1, max(val2, val3));
if ((i == a || i == b || i == c) && T[i] == 0) T[i] = 1;
}
cout << T[n] << "\n";
}
int main() {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
cut(n, a, b, c);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, x, j, k, p, ans, m, l = 0;
cin >> n;
vector<int> a;
for (int h = 0; h < 3; h++) {
cin >> x;
a.push_back(x);
}
sort(a.rbegin(), a.rend());
for (i = 0, k = 0; i <= n; i += a[0], k++) {
for (j = 0, p = 0; j <= n; p++, j += a[1]) {
if ((n - i - j) % a[2] == 0) {
ans = (n - i - j) / a[2];
m = p + k + ans;
if (m > l) l = m;
}
}
}
cout << l << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long dp[n + 1];
memset(dp, 0, sizeof(dp));
for (long long i = 1; i <= n; i++) {
if (i - a == 0 || i - b == 0 || i - c == 0) dp[i] = 1;
if (i - a > 0 && dp[i - a] > 0) dp[i] = max(dp[i], 1 + dp[i - a]);
if (i - b > 0 && dp[i - b] > 0) dp[i] = max(dp[i], 1 + dp[i - b]);
if (i - c > 0 && dp[i - c] > 0) dp[i] = max(dp[i], 1 + dp[i - c]);
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int a, b, c, n, cnt = 0, t, a1, b1, c1, ans = 0;
cin >> n >> a >> b >> c;
a1 = min(min(a, b), c);
c1 = max(max(a, b), c);
b1 = (a + b + c) - (a1 + c1);
for (int i = 0; i * c1 <= n; i++) {
for (int j = 0; (c1 * i) + (j * b1) <= n; j++) {
cnt = n - ((c1 * i) + (j * b1));
if (cnt % a1 == 0) {
cnt = cnt / a1;
cnt += i + j;
ans = max(ans, cnt);
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, p = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i * a <= n; ++i) {
for (int j = 0; i * a + j * b <= n; ++j) {
int k = (n - i * a - j * b) / c;
if (i * a + j * b + k * c == n) p = max(i + j + k, p);
}
}
cout << p << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long sum, i, j;
cin >> sum;
vector<long> length(3);
for (i = 0; i < 3; i++) cin >> length[i];
vector<vector<long> > dp(2, vector<long>(sum + 1, INT_MIN));
dp[3 % 2][0] = 0;
for (i = 2; i >= 0; i--) {
for (j = 0; j <= sum; j++) {
dp[i % 2][j] = dp[(i + 1) % 2][j];
if (j - length[i] >= 0 && dp[i % 2][j - length[i]] != INT_MIN)
dp[i % 2][j] = max(dp[i % 2][j], 1 + dp[i % 2][j - length[i]]);
}
}
cout << dp[0][sum];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int arr[3], length;
cin >> length >> arr[0] >> arr[1] >> arr[2];
int dp[length + 1];
memset(dp, 0, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= length; i++) {
bool condition = false;
for (int j = 0; j < 3; j++) {
if (i - arr[j] >= 0 && dp[i - arr[j]] != 0)
dp[i] = max(dp[i], dp[i - arr[j]] + 1);
if (i == arr[j]) condition = true;
}
if (condition) dp[i] = max(1, dp[i]);
}
cout << dp[length] << endl;
cerr << "\nTime elapsed: " << 1000 * clock() / CLOCKS_PER_SEC << " ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
int n, a[3];
cin >> n >> a[0] >> a[1] >> a[2];
vector<int> DP(n + 2, 0);
DP[0] = 1;
for (int t1 = 0; t1 < 3; ++t1)
for (int t2 = 0; t2 <= n - a[t1]; ++t2)
if (DP[t2]) DP[t2 + a[t1]] = max(DP[t2 + a[t1]], DP[t2] + 1);
cout << DP[n] - 1 << '\n';
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.