text stringlengths 49 983k |
|---|
#include <bits/stdc++.h>
const long long int inf = LLONG_MAX;
using namespace std;
int main() {
int n, a[4], dp[4005] = {0}, i, j;
dp[0] = 0;
cin >> n >> a[0] >> a[1] >> a[2];
for (i = 1; i <= n; i++) {
for (j = 0; j < 3; j++) {
if (i < a[j]) continue;
if (dp[i - a[j]] != 0)
dp[i] = max((1 + dp[i - a[j]]), dp[i]);
else if (i == a[j])
dp[i] = max(1, dp[i]);
}
}
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 2e5 + 5;
long long a, b, c;
void test_case() {
long long n;
cin >> n >> a >> b >> c;
long long ans = 0;
for (long long x = 0; x * a <= n; x++) {
for (long long y = 0; y * b <= n; y++) {
long long rem = n - x * a - y * b;
if (rem % c == 0 && rem >= 0) {
ans = max(ans, x + y + rem / c);
}
}
}
cout << ans;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
long long t = 1;
while (t--) {
test_case();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
double t, i, j, k, m, n, x, y, z, q, ans = INT_MIN, a, b, c;
double p, pf, pc;
cin >> n >> x >> y >> z;
for (i = 0; i <= 4000; i++) {
for (j = 0; j <= 4000; j++) {
p = (n - (i * x + j * y)) / z;
pf = floor(p);
pc = ceil(p);
if (p >= 0 && p == pf && p == pc) {
q = p;
ans = max(ans, i + j + q);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char alpha[26] = {'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i',
'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r',
's', 't', 'u', 'v', 'w', 'x', 'y', 'z'};
string s;
int t;
int dp[4001];
int a, b, c;
int maxOfThree(int a, int b, int c) {
a = max(a, b);
return max(a, c);
}
int solve(int n) {
if (n == 0) {
return 0;
}
if (n < 0) {
return INT_MIN;
}
if (dp[n] != -1) {
return dp[n];
}
int maxx;
maxx = maxOfThree(1 + solve(n - a), 1 + solve(n - b), 1 + solve(n - c));
dp[n] = maxx;
return dp[n];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
cout << solve(n);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int mx = -1;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i++) {
for (int j = 0, k; j <= n; j++) {
k = n - (i * a) - (j * b);
if (k < 0) {
continue;
}
if (k % c == 0) {
k /= c;
mx = max(mx, i + j + k);
}
}
}
cout << mx << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, cpieces[4005], cuts[3];
int dp(int n) {
if (n < 0) {
return -1e7;
}
if (cpieces[n] != 0) return cpieces[n];
if (n == 0) {
return 0;
}
return cpieces[n] = max(1 + dp(n - a), max(1 + dp(n - b), 1 + dp(n - c)));
}
int main() {
int n;
scanf("%d %d %d %d", &n, &cuts[0], &cuts[1], &cuts[2]);
for (int i = 0; i <= n; i++) {
cpieces[i] = INT_MIN;
}
cpieces[0] = 0;
cpieces[cuts[0]] = 1;
cpieces[cuts[1]] = 1;
cpieces[cuts[2]] = 1;
sort(cuts, cuts + 3);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < 3; j++) {
if (cuts[j] > i) break;
cpieces[i] = max(cpieces[i - cuts[j]] + 1, cpieces[i]);
}
}
printf("%d\n", cpieces[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c;
int dp[4005];
int sol(int n) {
if (n < 0) return -100000;
if (dp[n] != 0) return dp[n];
if (n == 0) return 0;
int t = sol(n - a);
int t1 = sol(n - b);
int t2 = sol(n - c);
return dp[n] = 1 + max(t, max(t1, t2));
}
int main() {
int n;
cin >> n >> a >> b >> c;
cout << sol(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[4][4001];
int k[3];
int main() {
int n, v, b, c, ans = 0;
cin >> n >> k[0] >> k[1] >> k[2];
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (j < k[i - 1])
a[i][j] = a[i - 1][j];
else if (j >= k[i - 1]) {
if (a[i][j - k[i - 1]] != 0 || j - k[i - 1] == 0) {
a[i][j] = max(a[i - 1][j], a[i][j - k[i - 1]] + 1);
} else
a[i][j] = a[i - 1][j];
}
}
}
cout << a[3][n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e18;
long long F[111111];
long long d, e, f;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n, a, b, c;
cin >> n >> a >> b >> c;
fill(F + 1, F + n + 1, -INF);
for (int i = 1; i <= n; ++i) {
d = e = f = -INF;
if (i >= a) d = F[i - a];
if (i >= b) e = F[i - b];
if (i >= c) f = F[i - c];
F[i] = max(d, max(e, f)) + 1;
}
cout << F[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int x = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i = i + a) {
for (int j = 0; j <= n - i; j = j + b) {
if ((n - i - j) % c == 0) {
x = max(x, (i / a) + (j / b) + ((n - i - j) / c));
}
}
}
cout << x;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5 + 1;
int t = 1, ar[3];
int dp[5000];
long long recur(int n) {
if (n == 0) {
return 0;
}
if (dp[n] != -1) {
return dp[n];
}
long long count = INT_MIN;
for (int i = 0; i < 3; i++) {
if (ar[i] <= n) {
count = max(count, 1 + recur(n - ar[i]));
}
}
return dp[n] = count;
}
void solve() {
int n;
cin >> n;
for (int i = 0; i < 3; i++) {
cin >> ar[i];
}
memset(dp, -1, sizeof dp);
cout << recur(n) << "\n";
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, i, a, b, c, j, maxi;
cin >> n;
vector<int> v(3);
for (i = 0; i < 3; i++) {
cin >> v[i];
}
sort(v.begin(), v.end());
int m[3][n + 1];
for (i = 0; i < n + 1; i++) {
for (j = 0; j < 3; j++) {
m[j][i] = 0;
}
}
for (i = 0; i <= n; i++) {
for (j = 0; j < 3; j++) {
if (i < v[j])
m[j][i] = -1;
else if (i == v[j])
m[j][i] = 1;
else {
maxi = max(m[0][i - v[j]], max(m[1][i - v[j]], m[2][i - v[j]]));
if (maxi == -1)
m[j][i] = -1;
else
m[j][i] = 1 + maxi;
}
}
}
cout << max(m[0][n], max(m[1][n], m[2][n])) << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int max(int a, int b) {
if (a >= b)
return a;
else
return b;
}
int main() {
int n, a1, b1, c1;
cin >> n >> a1 >> b1;
int a, b, c;
if (a1 >= b1) {
a = a1;
b = b1;
} else {
a = b1;
b = a1;
}
cin >> c1;
if (c1 <= b)
c = c1;
else if (c1 > b && c1 <= a) {
c = b;
b = c1;
} else {
c = b;
b = a;
a = c1;
}
int temp[n + 1], i;
for (i = 0; i <= n; i++) temp[i] = 0;
for (i = c; i <= n; i++) {
if (i % c == 0) temp[i] = i / c;
}
for (i = b; i <= n; i++) {
if (i % b == 0) temp[i] = max(temp[i], i / b);
if (temp[i - b] != 0) temp[i] = max(temp[i], temp[i - b] + 1);
}
for (i = a; i <= n; i++) {
if (i % a == 0) temp[i] = max(temp[i], i / a);
if (temp[i - a] != 0) temp[i] = max(temp[i], temp[i - a] + 1);
}
cout << temp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[12], f[120000];
int main() {
cin >> n >> a[1] >> a[2] >> a[3];
memset(f, -1, sizeof(f));
f[0] = 0;
for (int i = 1; i <= 3; i++)
for (int j = a[i]; j <= n; j++) {
if (f[j - a[i]] < 0) continue;
f[j] = max(f[j], f[j - a[i]] + 1);
}
cout << f[n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e4 + 10;
long long dp[maxn];
int main() {
memset(dp, -10, sizeof dp);
long long n, a[3];
cin >> n >> a[0] >> a[1] >> a[2];
dp[0] = 0;
for (int i = 0; i < 3; i++)
for (int j = a[i]; j <= n; j++) dp[j] = max(dp[j], dp[j - a[i]] + 1);
cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> dp;
int cal_max(int n, int a, int b, int c) {
if (n < 0) return -1 * INT_MAX;
if (n == 0) return 0;
if (dp[n] != -1) return dp[n];
dp[n] = max(cal_max(n - a, a, b, c) + 1,
max(cal_max(n - b, a, b, c) + 1, cal_max(n - c, a, b, c) + 1));
return dp[n];
}
int main(void) {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
int n, a, b, c;
cin >> n >> a >> b >> c;
dp.resize(n + 1, -1);
cout << cal_max(n, a, b, c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int n, i, j, k = 0;
cin >> n;
std::vector<long long int> v(3, 0);
for (i = 0; i < 3; i++) cin >> v[i];
sort(v.begin(), v.end());
long long int a = v[0];
long long int b = v[1];
long long int c = v[2];
vector<long long int> dp(n + 3, -99);
dp[0] = 0;
for (i = 1; i <= n; i++) {
dp[i] = -99999999;
if (i - a >= 0) dp[i] = max(dp[i], dp[i - a] + 1);
if (i - b >= 0) dp[i] = max(dp[i], dp[i - b] + 1);
if (i - c >= 0) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, d[4002];
vector<int> lst;
int main() {
cin >> n >> a >> b >> c;
int mx = 0;
for (int i = 1; i <= n; i++) {
mx = 0;
int ost = i - a;
if (ost > 0 && d[ost] > 0) {
mx = max(mx, d[ost] + 1);
}
ost = i - b;
if (ost > 0 && d[ost] > 0) {
mx = max(mx, d[ost] + 1);
}
ost = i - c;
if (ost > 0 && d[ost] > 0) {
mx = max(mx, d[ost] + 1);
}
if (i == a || i == b || i == c) {
mx = max(mx, 1);
}
d[i] = mx;
}
cout << d[n];
}
|
#include <bits/stdc++.h>
using namespace std;
void pairsort(long long a[], long long b[], long long n) {
pair<long long, long long> pairt[n];
for (long long i = 0; i < n; i++) {
pairt[i].first = a[i];
pairt[i].second = b[i];
}
sort(pairt, pairt + n);
for (long long i = 0; i < n; i++) {
a[i] = pairt[i].first;
b[i] = pairt[i].second;
}
}
long long binomialCoeff(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;
}
void printVector(vector<long long> v) {
for (long long i = 0; i < v.size(); i++) {
cout << v[i] << " ";
}
cout << "\n";
}
long long divisor(long long num) {
long long div = 0;
for (long long i = 1; i <= num; i++) {
if (num % i == 0) div++;
}
return div;
}
long long sub(long long a, long long b) {
if (a >= b) return a - b;
return b - a;
}
const long long N = 1e5;
long long dp[N];
long long d_p(long long n, long long a, long long b, long long c) {
if (n == 0) return 0;
if (n < (a < (b < c ? b : c) ? a : (b < c ? b : c)) && n != 0)
return -9999;
else {
if (dp[n] != 0) return dp[n];
return dp[n] = ((d_p(n - a, a, b, c) > d_p(n - b, a, b, c)
? d_p(n - a, a, b, c)
: d_p(n - b, a, b, c)) > d_p(n - c, a, b, c)
? (d_p(n - a, a, b, c) > d_p(n - b, a, b, c)
? d_p(n - a, a, b, c)
: d_p(n - b, a, b, c))
: d_p(n - c, a, b, c)) +
1;
}
}
int32_t main() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
long long ans;
ans = d_p(n, a, b, c);
cout << ans << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int temp = 0;
for (int i = 0; i * a <= n; i++) {
for (int j = 0; j * b + i * a <= n; j++) {
if ((n - (j * b + i * a)) % c == 0) {
temp = max(temp, i + j + (n - (j * b + i * a)) / c);
}
}
}
cout << temp << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int gcd(int x, int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
int lcm(int x, int y) { return x * y / gcd(x, y); }
long long int gcd(long long int x, long long int y) {
if (y == 0) return x;
return gcd(y, x % y);
}
long long int lcm(long long int x, long long int y) {
return x * y / gcd(x, y);
}
void swap(long long int& x, long long int& y) {
long long int temp = x;
x = y;
y = temp;
}
long long int binpow(long long int a, long long int b) {
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a;
a = a * a;
b >>= 1;
}
return res;
}
long long int binpowM(long long int a, long long int b) {
a %= 100000007;
long long int res = 1;
while (b > 0) {
if (b & 1) res = res * a % 100000007;
a = a * a % 100000007;
b >>= 1;
}
return res;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
cout << fixed;
int n, ans = 0, k;
cin >> n;
vector<int> a(3);
for (int i = 0; i < 3; i++) {
cin >> a[i];
}
sort(a.begin(), a.end(), greater<int>());
int i = 0, j, l = n / a[1], m = n / a[0];
while (i <= m) {
j = 0;
while (j <= l) {
k = n - i * a[0] - j * a[1];
if (k % a[2] == 0) {
ans = max(i + j + k / a[2], ans);
}
j++;
}
i++;
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int arr[3];
for (int i = 0; i < 3; i++) cin >> arr[i];
int mx = 0;
sort(arr, arr + 3);
for (int i = n / arr[0]; i >= 0; i--) {
for (int j = n / arr[1]; j >= 0; j--) {
if ((n - (j * arr[1] + i * arr[0])) % arr[2] == 0 &&
(n - (j * arr[1] + i * arr[0])) >= 0) {
mx = max(mx, ((n - (j * arr[1] + i * arr[0])) / arr[2]) + i + j);
}
}
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int Li = 1e7;
int y[Li];
int main() {
int n, r = 0, a, b, c, d = 1;
int x[3];
cin >> n >> x[0] >> x[1] >> x[2];
sort(x, x + 3);
a = x[0];
b = x[1];
c = x[2];
for (int i = 0; i <= n / a; i++) {
for (int j = 0; j <= n / b; j++) {
r = n - (i * a) - (j * b);
if (r % c == 0 && r >= 0) d = max(d, i + j + (r / c));
}
}
cout << d;
}
|
#include <bits/stdc++.h>
using namespace std;
#pragma GCC optimize("Ofast")
void solve() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[4001]{};
dp[0] = 0;
for (int i = 1; i <= n; i++) {
int x = -1, y = -1, z = -1;
if (i >= a) {
x = dp[i - a];
}
if (i >= b) {
y = dp[i - b];
}
if (i >= c) {
z = dp[i - c];
}
if (x == -1 && y == -1 && z == -1) {
dp[i] = -1;
} else {
dp[i] = max(max(x, y), z) + 1;
}
}
cout << dp[n] << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INFLL = (long long)2000000001 * (long long)2000000001;
const long double EPS = 10e-9;
bool available[8007];
int best[8007];
int main() {
int n;
scanf("%d", &n);
int a;
scanf("%d", &a);
int b;
scanf("%d", &b);
int c;
scanf("%d", &c);
available[0] = 1;
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + a] = max(best[i + a], best[i] + 1);
available[i + a] = 1;
}
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + b] = max(best[i + b], best[i] + 1);
available[i + b] = 1;
}
for (int i = 0; i < n + 1; i++)
if (available[i]) {
best[i + c] = max(best[i + c], best[i] + 1);
available[i + c] = 1;
}
printf("%d\n", best[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int DP[n + 1];
DP[0] = 0;
for (int i = 1; i <= n; i++) {
DP[i] = -1;
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] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1e5;
const int MAX2 = 1e9;
const long long MAX3 = 1e12;
int gcd(int a, int b) {
if (b == 0) {
return a;
}
int a1 = a % b;
return gcd(b, a1);
}
void swap1(char& x, char& y) {
char t = x;
x = y;
y = t;
}
int main() {
int n, a, b, c, sum = 0;
cin >> n >> a >> b >> c;
for (int x = 0; x <= n; x++) {
for (int y = 0; y <= n; y++) {
int s = a * x + b * y;
int z = abs(n - s) / c;
if (sum < x + y + z && s + c * z == n) {
sum = x + y + z;
}
}
}
cout << sum;
}
|
#include <bits/stdc++.h>
using namespace std;
long long int MOD = 1000000000 + 7;
void Solve() {
long long int n, a, b, c;
cin >> n >> a >> b >> c;
long long int sol = 0;
for (long long int i = 0; i * a <= n; i++) {
for (long long int j = 0; j * b + i * a <= n; j++) {
long long int z = n - (i * a + j * b);
if (z % c == 0) {
z /= c;
sol = max(sol, i + j + z);
}
}
}
cout << sol << "\n";
}
signed main() {
ios_base::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
long long int t = 1;
while (t-- > 0) {
Solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int t[4001], a[3];
int solve(int n) {
int ans = INT_MIN;
if (n == 0) {
return 0;
}
if (t[n] != -1) {
return t[n];
} else {
for (int i = 0; i < 3; i++) {
if (n >= a[i]) {
ans = max(ans, 1 + solve(n - a[i]));
}
}
t[n] = ans;
}
return ans;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n >> a[0] >> a[1] >> a[2];
memset(t, -1, sizeof(t));
cout << solve(n);
cerr << "Time : " << 1000 * ((double)clock()) / (double)CLOCKS_PER_SEC
<< "ms\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long i, j, a, b, c, cnt, cn, n, k;
while (cin >> n >> a >> b >> c) {
long long ans = -1;
for (long long i = 0; i < n + 1; i++)
for (long long j = 0; j < n + 1; j++) {
k = n - (a * i + b * j);
if (k >= 0 && k % c == 0) ans = max(ans, (i + j + k / c));
}
printf("%lld\n", ans);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9 + 8;
const int mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
int n, a, b, c;
int arr[3];
cin >> n >> a >> b >> c;
float temp;
int mex = 0;
for (int i = 0; i <= n; i++) {
int flag = 0;
for (int j = 0; j <= n; j++) {
temp = (float)(-c * i - b * j + n) / a;
if (temp < 0) continue;
if (temp == (int)temp) {
temp += j + i;
mex = max(mex, (int)temp);
}
}
}
cout << mex << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1e9 + 10;
const double PI = acos(-1);
inline void max_self(long long &a, long long b) { a = max(a, b); }
inline void min_self(long long &a, long long b) { a = min(a, b); }
inline void add_self(int &a, int b) {
a += b;
if (a >= 1000000007) a -= 1000000007;
}
inline void sub_self(int &a, int b) {
a -= b;
if (a < 0) a += 1000000007;
}
inline int mul(int a, int b) { return (int)(a * b % 1000000007); }
long long gcd(long long a, long long b) {
if (b == 0)
return a;
else
return gcd(b, a % b);
}
int countDigits(int x) {
int cnt = 0;
while (x) {
x /= 10;
cnt++;
}
return cnt;
}
long long binExpo(long long a, long long b) {
long long res = 1;
while (b) {
if (b & 1) res = (res * a) % 1000000007;
a = (a * a) % 1000000007;
b /= 2;
}
return res % 1000000007;
}
void print(vector<int> &a) {
int sz = a.size();
for (__typeof((sz - 1)) i = (0); i <= (sz - 1); i++) {
cout << a[i] << " ";
}
cout << '\n';
}
const int nax = 1e4 + 4;
int dp[nax];
int n, a, b, c;
bool check(int x) {
if (dp[x] > 0 || x == 0) return true;
return false;
}
void solve() {
cin >> n >> a >> b >> c;
memset(dp, 0, sizeof(dp));
for (__typeof((n)) i = (1); i <= (n); i++) {
if (i - a >= 0 and check(i - a)) dp[i] = max(dp[i], dp[i - a] + 1);
if (i - b >= 0 and check(i - b)) dp[i] = max(dp[i], dp[i - b] + 1);
if (i - c >= 0 and check(i - c)) dp[i] = max(dp[i], dp[i - c] + 1);
}
cout << dp[n] << '\n';
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int t = 1;
while (t--) {
solve();
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int i, j, s = 0;
for (i = 0; i * a <= n; i++) {
for (j = 0; j * b <= n - i * a; j++)
s = (n - i * a - j * b) % c ? s : max(s, i + j + (n - i * a - j * b) / c);
}
cout << s;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(int argc, char const *argv[]) {
int n, a, b, c;
scanf("%d %d %d %d", &n, &a, &b, &c);
int ans = 0;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= 4000; j++) {
int s = n - (a * i + b * j);
if (s == 0)
ans = max(ans, i + j);
else if (s > 0 && s % c == 0)
ans = max(ans, i + j + s / c);
}
}
printf("%d\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a, b, c, cpieces[4005], pieces = 0;
int dp(int n) {
if (n < 0) {
return -1e7;
}
if (cpieces[n] != 0) return cpieces[n];
if (n == 0) {
return 0;
}
return cpieces[n] = max(1 + dp(n - a), max(1 + dp(n - b), 1 + dp(n - c)));
}
int main() {
int n;
scanf("%d %d %d %d", &n, &a, &b, &c);
printf("%d\n", dp(n));
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp(n + 1, -1e9);
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];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c;
int dp[4001];
int find(int n) {
int A, B, C, maxi = 0;
if (n == 0) return 0;
if (n < 0) return INT_MIN;
if (dp[n] != 0) return dp[n];
A = find(n - a);
B = find(n - b);
C = find(n - c);
maxi = 1 + max(A, max(B, C));
dp[n] = maxi;
return maxi;
}
int main() {
cin >> n >> a >> b >> c;
for (int i = 0; i < n; i++) dp[i] = 0;
cout << find(n);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 10;
int d[maxn];
int main() {
int n, abc[5], i, j;
while (~scanf("%d%d%d%d", &n, &abc[1], &abc[2], &abc[3])) {
memset(d, 0, sizeof(d));
for (i = 1; i <= n; i++) d[i] = -(1 << 30);
for (i = 1; i <= n; i++)
for (j = 1; j <= 3; j++)
if (i >= abc[j]) d[i] = max(d[i], d[i - abc[j]] + 1);
printf("%d\n", d[n]);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a, b, c, dp[4005];
int calc(int n) {
if (n == 0) return 0;
if (n < 0) return -1e9;
int &ret = dp[n];
if (ret != -1) return ret;
return ret = max(max(calc(n - a), calc(n - b)), calc(n - c)) + 1;
}
int main() {
cin >> n >> a >> b >> c;
dp[0] = 0;
for (int i = 1; i <= n; i++) {
dp[i] = -1e9;
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;
vector<int> A(3);
vector<vector<int> > dp(4010, vector<int>(4010, -1));
int f(int n, int c) {
if (n == 0) return c;
if (n < *min_element(begin(A), end(A))) return 0;
int &x = dp[n][c];
if (x != -1) return x;
for (auto &i : A) {
if (n >= i) x = max(x, f(n - i, c + 1));
}
return x;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (auto &i : A) cin >> i;
cout << f(n, 0) << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int mx = 0;
for (int i = 0; i <= n / a; i++) {
for (int j = 0; j <= n / b; j++) {
if ((n - i * a - j * b) >= 0 && (n - i * a - j * b) % c == 0) {
if (mx < i + j + (n - i * a - j * b) / c) {
mx = i + j + (n - i * a - j * b) / c;
}
}
}
}
cout << mx << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int l[8005], b, c, a, n, g, i;
int main() {
cin >> n >> a >> b >> c;
l[a] = l[b] = l[c] = 1;
for (i = 1; i < n; i++) {
if (l[i] > 0) {
if (l[i] + 1 > l[i + a]) l[i + a] = l[i] + 1;
if (l[i] + 1 > l[i + b]) l[i + b] = l[i] + 1;
if (l[i] + 1 > l[i + c]) l[i + c] = l[i] + 1;
}
}
cout << l[n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 1e9;
int dp[10000];
int main() {
int n, a, b, c;
scanf("%d%d%d%d", &n, &a, &b, &c);
if (n - a >= 0) {
dp[n - a] = 1;
}
if (n - b >= 0) {
dp[n - b] = max(dp[n - b], 1);
}
if (n - c >= 0) {
dp[n - c] = max(dp[n - c], 1);
}
for (int i = n - 1; i >= 0; --i) {
if (i - a >= 0 && dp[i] != 0) {
dp[i - a] = max(dp[i - a], dp[i] + 1);
}
if (i - b >= 0 && dp[i] != 0) {
dp[i - b] = max(dp[i - b], dp[i] + 1);
}
if (i - c >= 0 && dp[i] != 0) {
dp[i - c] = max(dp[i - c], dp[i] + 1);
}
}
printf("%d", dp[0]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e5;
int dp[N], n, a, b, c;
int count(int x) {
if (x == 0) return 0;
if (x < 0) return INT_MIN;
if (dp[x] != -1) return dp[x];
return dp[x] = max(count(x - a), max(count(x - b), count(x - c))) + 1;
}
int main() {
memset(dp, -1, sizeof dp);
cin >> n >> a >> b >> c;
cout << count(n);
return 0;
}
|
#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() {
long long n, a, b, c;
cin >> n >> a >> b >> c;
vector<long long> dp(5000, 0);
vector<bool> ok(5000, false);
ok[0] = true;
for (int i = 1; i <= n; i++) {
dp[i] = -1;
if (i - a >= 0 && ok[i - a]) {
dp[i] = max(dp[i], dp[i - a] + 1);
ok[i] = true;
}
if (i - b >= 0 && ok[i - b]) {
dp[i] = max(dp[i], dp[i - b] + 1);
ok[i] = true;
}
if (i - c >= 0 && ok[i - c]) {
dp[i] = max(dp[i], dp[i - c] + 1);
ok[i] = true;
}
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 4010;
int dp[N], n, a, b, c;
void solve() {
dp[0] = 0;
cin >> n >> a >> b >> c;
for (int i = 1; i <= n; i++) {
dp[i] = -1;
if (i >= a && dp[i - a] != -1) dp[i] = 1 + dp[i - a];
if (i >= b && dp[i - b] != -1 && (dp[i] == -1 || dp[i] < 1 + dp[i - b]))
dp[i] = 1 + dp[i - b];
if (i >= c && dp[i - c] != -1 && (dp[i] == -1 || dp[i] < 1 + dp[i - c]))
dp[i] = 1 + dp[i - c];
}
cout << dp[n] << "\n";
}
int main() {
std::ios::sync_with_stdio(0);
cin.tie(0);
solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int w[5];
int v[5];
int dp[4010];
int main() {
while (scanf("%d%d%d%d", &n, &w[0], &w[1], &w[2]) != EOF) {
v[0] = v[1] = v[2] = 1;
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 0; i < 3; i++) {
for (int j = w[i]; j <= n; j++) {
if (dp[j - w[i]] != -1) dp[j] = max(dp[j], dp[j - w[i]] + v[i]);
}
}
printf("%d\n", dp[n]);
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, pieces = 0;
std::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) pieces = max(i + j + k, pieces);
}
}
std::cout << pieces;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[4];
long long i1, i2, n, cur, ans;
int main() {
cin >> n >> a[0] >> a[1] >> a[2];
sort(a, a + 2);
for (i1 = 0; i1 <= n; i1++)
for (i2 = 0; i2 <= n; i2++)
if ((a[0] * i1) + (a[1] * i2) <= n &&
(n - (a[0] * i1) - (a[1] * i2)) % a[2] == 0) {
cur = i1 + i2 + ((n - (a[0] * i1) - (a[1] * i2)) / a[2]);
if (cur > ans) ans = cur;
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long long int i, j, t, n, a[4004];
fill(a + 1, a + 4004, -10000);
cin >> n;
for (i = 0; i < 3; i++) {
cin >> t;
for (j = t; j <= n; j++) {
a[j] = max(a[j], a[j - t] + 1);
}
}
cout << a[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int cnt, m, w[100005], dp[100005];
int main() {
cin >> m >> w[1] >> w[2] >> w[3];
for (int i = 1; i <= m; i++) dp[i] = -1e9;
for (int i = 1; i < 4; i++)
for (int j = w[i]; j <= m; j++) dp[j] = max(dp[j], dp[j - w[i]] + 1);
cout << dp[m];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 5e3 + 9;
int a, b, c, N;
int dp[MAXN];
inline int go(int len) {
if (len == 0) return 0;
if (len < a && len < b && len < c) return -MAXN;
if (dp[len] != -1) return dp[len];
return dp[len] = 1 + max(max(go(len - a), go(len - b)), go(len - c));
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d %d %d %d", &N, &a, &b, &c);
printf("%d\n", go(N));
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a, b, c, dp[4005];
set<pair<int, int> > x;
string s;
int main() {
cin >> n >> a >> b >> c;
dp[a] = 1;
dp[b] = 1;
dp[c] = 1;
for (int i = min(a, min(b, c)); i <= n; i++) {
if (i - a > 0) {
if (dp[i - a]) {
dp[i] = max(dp[i - a] + 1, dp[i]);
}
}
if (i - b > 0) {
if (dp[i - b]) {
dp[i] = max(dp[i - b] + 1, dp[i]);
}
}
if (i - c > 0) {
if (dp[i - c]) {
dp[i] = max(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, r, ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n / a; i++) {
for (int j = 0; j <= n / b; j++) {
r = n - (i * a + j * b);
if (r >= 0 && r % c == 0) {
ans = max(ans, i + j + r / c);
}
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
int main() {
int n, a[3], dp[4002];
memset(dp, 0, sizeof(dp));
std::cin >> n >> a[0] >> a[1] >> a[2];
std::sort(a, a + 3);
for (int i = 0; i < 3; i++) {
for (int j = n; j - a[i] >= 0; j--) {
for (int k = 1; k <= j / a[i]; k++)
if (j % a[i] == 0 || dp[j - a[i] * k] != 0)
dp[j] = std::max(dp[j], dp[j - a[i] * k] + k);
}
}
std::cout << dp[n];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
int a, b, c;
cin >> a >> b >> c;
int table[n + 1];
table[0] = 0;
for (int i = 1; i <= n; i++) {
int a1 = 0, b1 = 0, c1 = 0;
if (i >= a && table[i - a] != -1) {
a1 = 1 + table[i - a];
}
if (i >= b && table[i - b] != -1) {
b1 = 1 + table[i - b];
}
if (i >= c && table[i - c] != -1) {
c1 = 1 + table[i - c];
}
table[i] = max(a1, b1);
table[i] = max(table[i], c1);
if (table[i] == 0) {
table[i] = -1;
}
}
cout << table[n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
void solve() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int arr[3] = {a, b, c};
int dp[4][n + 1];
for (int i = 0; i <= n; i++) {
dp[0][i] = INT_MIN;
}
for (int j = 1; j < 4; j++) dp[j][0] = 0;
for (int i = 1; i < n + 1; i++) {
if (i % arr[0] == 0)
dp[1][i] = i / arr[0];
else
dp[1][i] = INT_MIN;
}
for (int i = 2; i < 4; i++) {
for (int j = 1; j < n + 1; j++) {
if (arr[i - 1] <= j)
dp[i][j] = max(dp[i - 1][j], 1 + dp[i][j - arr[i - 1]]);
else
dp[i][j] = dp[i - 1][j];
}
}
cout << dp[3][n] << endl;
return;
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(NULL);
cout.tie(NULL);
long long t = 1;
while (t--) {
solve();
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int u;
u = 1;
while (u--) {
int i = 0, k = -1, m, j, n, s1 = 0, r = 0, l = 0, l1 = 0, c = 0, t, d = 0,
na, nb, f = 0;
cin >> n;
int b, a;
cin >> a >> b >> c;
for (i = 0; i * a <= n; i++) {
for (j = 0; j * b <= n; j++) {
if ((n - i * a - j * b) % c == 0 && n >= i * a + j * b) {
f = max(f, i + j + (n - i * a - j * b) / c);
}
}
}
cout << f << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, d = 1, e = 2, f = 3, i, j, h = 0, k = 0, l = 0, m = 0, o = 0,
p = 0, q = 0, r = 0, s = 0, t = 0, u = 0, v = 0, w = 0, x = 0,
y = 0;
cin >> n >> a >> b >> c;
if (a <= b && a <= c)
j = a;
else if (b <= a && b <= c)
j = b;
else if (c <= a && c <= b)
j = c;
if (n % j != 0) {
if (n == a | n == b | n == c) {
if (a == b + c | b == c + a | c == a + b) {
} else {
o++;
s = d;
}
}
if (n == a + b | n == b + c | n == a + c) {
o++;
s = e;
}
if (n == a + b + c) {
o++;
s = f;
}
}
for (i = 0; i <= n; i++) {
for (j = 0; j <= n; j++) {
if ((i * a) + (j * b) == n) {
p = i + j;
if (p > k) k = p;
}
if ((i * b) + (j * c) == n) {
q = i + j;
if (q > l) l = q;
}
if ((i * c) + (j * a) == n) {
r = i + j;
if (r > m) m = r;
}
if ((i * a) + (j * b) + c == n) {
t = i + j + 1;
if (t > u) u = t;
}
if ((i * b) + (j * c) + a == n) {
v = i + j + 1;
if (v > w) w = v;
}
if ((i * c) + (j * a) + b == n) {
x = i + j + 1;
if (x > y) y = x;
}
}
}
if (k > s | l > s | m > s | u > s | w > s | y > s) {
if (k >= l && k >= m && k >= u && k >= w && k >= y)
cout << k;
else if (l >= k && l >= m && l >= u && l >= w && l >= y)
cout << l;
else if (m >= k && m >= l && m >= u && m >= w && m >= y)
cout << m;
else if (u >= k && u >= l && u >= w && u >= y)
cout << u;
else if (w >= k && w >= l && w >= u && w >= y)
cout << w;
else if (y >= k && y >= l && y >= u && y >= w)
cout << y;
} else {
cout << s;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const int maxn = 4e3 + 5;
int f[maxn];
int main() {
int n, a, b, c, x, y, z;
cin >> n >> a >> b >> c;
if (a < b) swap(a, b);
if (a < c) swap(a, c);
if (b < c) swap(b, c);
memset(f, -1, sizeof f);
f[c] = 1;
if (b % c == 0)
f[b] = b / c;
else
f[b] = 1;
if (a % c == 0)
f[a] = a / c;
else if (a % b == 0)
f[a] = a / b;
else
f[a] = 1;
for (int i = 1; i <= n; i++) {
if (i > c && f[i - c] != -1) f[i] = max(f[i], f[i - c] + 1);
if (i > b && f[i - b] != -1) f[i] = max(f[i], f[i - b] + 1);
if (i > a && f[i - a] != -1) f[i] = max(f[i], f[i - a] + 1);
}
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long int dp[4004];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int i, n, a, b, c;
cin >> n >> a >> b >> c;
if (n == 1)
cout << "1";
else {
long long int dp[n + 2];
memset(dp, -100, sizeof(dp));
dp[0] = 0;
for (i = 1; i <= n; i++) {
if ((i - a) >= 0) dp[i] = max(dp[i], 1 + dp[i - a]);
if ((i - b) >= 0) dp[i] = max(dp[i], 1 + dp[i - b]);
if ((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 n, a[4];
scanf("%d%d%d%d", &n, &a[1], &a[2], &a[3]);
int ans = 0;
int r = min(a[1], min(a[2], a[3]));
r = n / r;
for (int x = r; x >= 0; x--) {
for (int y = 0; y <= r; y++) {
int z = abs((n - (a[1] * x + a[2] * y)) / a[3]);
if (a[1] * x + a[2] * y + a[3] * z == n) {
ans = max(ans, x + y + z);
}
}
}
cout << ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int MAX = 1e4 + 5;
int main() {
int n, a[3];
cin >> n >> a[0] >> a[1] >> a[2];
int xx = n / a[0], yy = n / a[1];
int ans = 0;
for (int i = 0; i <= xx; ++i) {
for (int j = 0; j <= (n - i * a[0]) / a[1]; ++j) {
if (!((n - a[0] * i - a[1] * j) % a[2]))
ans = max(ans, i + j + (n - a[0] * i - a[1] * j) / a[2]);
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a[4];
scanf("%d%d%d%d", &n, &a[1], &a[2], &a[3]);
vector<vector<int>> dp(4, vector<int>(n + 1, 0));
for (int i = 1; i <= 3; i++) {
for (int j = 1; j <= n; j++) {
if (j < a[i] || j != a[i] && dp[i][j - a[i]] == 0)
dp[i][j] = dp[i - 1][j];
else
dp[i][j] = max(1 + dp[i][j - a[i]], dp[i - 1][j]);
}
}
cout << dp[3][n] << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
vector<int> dp;
dp.resize(n + 1);
dp[0] = 0;
int x, y, z;
for (int i = 1; i <= n; i++) {
x = INT_MIN, y = INT_MIN, z = INT_MIN;
if (i >= a) x = dp[i - a];
if (i >= b) y = dp[i - b];
if (i >= c) z = dp[i - c];
dp[i] = 1 + max(z, max(x, y));
}
cout << dp[n];
}
|
#include <bits/stdc++.h>
using namespace std;
using namespace std;
int main() {
int n, p, count, w;
int arr[3];
int i, j, k;
int max = -1;
cin >> n >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= 4000; j++) {
p = i * arr[0] + j * arr[1];
if (p < n) {
w = (n - p) % arr[2];
if (w == 0) {
count = i + j + (n - p) / arr[2];
if (count > max) max = count;
}
} else if (p == n) {
count = i + j;
if (count > max) max = count;
}
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[4005];
int i, j, a[3], n;
int main() {
scanf("%d%d%d%d", &n, &a[0], &a[1], &a[2]);
memset(f, 60, sizeof(f));
f[0] = 0;
for (i = 1; i <= n; ++i) f[i] = -f[i];
for (j = 0; j < 3; ++j)
for (i = 0; i <= n; ++i)
if (i + a[j] <= n) f[i + a[j]] = max(f[i + a[j]], f[i] + 1);
printf("%d\n", f[n]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int dp[n + 1];
memset(dp, -1, sizeof(dp));
dp[0] = 0;
for (int i = 1; i <= n; i++) {
if (i - a >= 0 && dp[i - a] >= 0) {
dp[i] = dp[i - a] + 1;
}
if (i - b >= 0 && dp[i - b] >= 0) {
if ((dp[i - b] + 1) > dp[i]) {
dp[i] = dp[i - b] + 1;
}
}
if (i - c >= 0 && dp[i - c] >= 0) {
if ((dp[i - c] + 1) > dp[i]) {
dp[i] = dp[i - c] + 1;
}
}
}
cout << dp[n] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, C, max1 = 0, max2;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= n; j++) {
C = n - (a * i) - (b * j);
if (C % c == 0 && C >= 0) {
max1 = max(i + j + C / c, max1);
}
}
cout << max1;
}
|
#include <bits/stdc++.h>
using namespace std;
int mem[4001];
int s[3];
int solve(int n) {
if (n == 0) return 0;
if (n < 0) return -1e9;
int &ret = mem[n];
if (ret != -1) return ret;
ret = -1e9;
for (int i = 0; i < 3; i++) ret = max(ret, 1 + solve(n - s[i]));
return ret;
}
int main() {
int n;
while (cin >> n) {
for (int i = 0; i < 3; i++) cin >> s[i];
memset(mem, -1, sizeof mem);
cout << solve(n) << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int sum, a, b, c;
cin >> sum >> a >> b >> c;
vector<int> v(4000);
v[0] = 0;
for (int i = 1; i <= sum; i++) {
v[i] = INT_MIN;
if (i >= a) v[i] = v[i - a] + 1;
if (i >= b && v[i] < v[i - b] + 1) v[i] = v[i - b] + 1;
if (i >= c && v[i] < v[i - c] + 1) v[i] = v[i - c] + 1;
}
cout << v[sum];
}
|
#include <bits/stdc++.h>
using namespace std;
vector<int> prime_Numbers;
bool primes[100005];
void prime(int n) {
for (int i = 2; i <= n; i++) primes[i] = true;
for (int i = 2; i <= n; i++) {
if (primes[i] == true) {
prime_Numbers.push_back(i);
for (int j = i + i; j <= n; j += i) primes[j] = false;
}
}
}
int fib(int n) {
if (n == 1 || n == 0) return n;
return fib(n - 1) + fib(n - 2);
}
long long fastpower(int b, int p) {
if (p == 0) return 1;
long long term = fastpower(b, p / 2);
term *= term;
if (p % 2 != 0) return term *= b;
return term;
}
int main() {
int n, arr[3], mxm = -1;
cin >> n >> arr[0] >> arr[1] >> arr[2];
sort(arr, arr + 3);
for (int i = 0; i <= arr[2]; i++) {
for (int j = 0; j <= arr[1]; j++) {
int c = n - (i * arr[2]) - (j * arr[1]);
if (c >= 0 && c % arr[0] == 0) mxm = max(mxm, i + j + c / arr[0]);
}
}
cout << mxm;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 100000;
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
int v, w[N], f[N];
int max(int a, int b) {
if (a > b)
return a;
else
return b;
}
int main() {
v = read();
for (int i = 1; i <= 3; i++) w[i] = read();
memset(f, -1, sizeof(f));
f[0] = 0;
for (int i = 1; i <= 3; i++) {
for (int j = w[i]; j <= v; j++) {
if (f[j - w[i]] != -1) f[j] = max(f[j], f[j - w[i]] + 1);
}
}
printf("%d", f[v]);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, s = 1;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
int k = n - a * i - b * j;
if (k >= 0 && k % c == 0) s = max(s, (i + j + k / c));
}
}
cout << s;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, mx = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i * a <= n; i++) {
for (int j = 0; a * i + b * j <= n; j++) {
if ((n - (a * i + b * j)) % c == 0) {
int h = (n - (a * i + b * j)) / c + i + j;
mx = max(mx, h);
}
}
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
long n, a, b, c, m = 1;
cin >> n >> a >> b >> c;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= 4000; j++) {
int t = n - a * i - b * j;
if (t >= 0 && t % c == 0) m = max(m, i + j + t / c);
}
}
cout << m;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
int mx = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= n / c; i++) {
for (int j = 0; j <= n / b; j++) {
int k = (n - i * c - j * b);
if (k % a == 0) {
k = k / a;
if (k >= 0) mx = max(i + j + k, mx);
}
}
}
cout << mx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(false);
int n, a, b, c;
cin >> n >> a >> b >> c;
int arr[n + 1];
memset(arr, -1, sizeof(arr));
arr[0] = 0;
for (int i = 1; i <= n; i++) {
if (i >= a && arr[i - a] != -1) arr[i] = max(arr[i - a] + 1, arr[i]);
if (i >= b && arr[i - b] != -1) arr[i] = max(arr[i - b] + 1, arr[i]);
if (i >= c && arr[i - c] != -1) arr[i] = max(arr[i - c] + 1, arr[i]);
}
cout << arr[n];
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 dp[n + 1];
dp[0] = 0;
int dpa, dpb, dpc;
for (int i = 1; i <= n; ++i) {
dpa = (i - a >= 0) ? dp[i - a] : -1;
dpb = (i - b >= 0) ? dp[i - b] : -1;
dpc = (i - c >= 0) ? dp[i - c] : -1;
dp[i] = max(dpa, max(dpb, dpc));
dp[i] = (dp[i] == -1) ? -1 : dp[i] + 1;
}
cout << dp[n] << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 4000 + 5;
int n, a, b, c, d[maxn];
int main() {
int x1, x2, x3;
cin >> n >> a >> b >> c;
d[0] = 0;
for (int i = 1; i <= n; i++) {
if ((i > a && d[i - a] == -1) || i < a)
x1 = -1;
else
x1 = d[i - a] + 1;
if ((i > b && d[i - b] == -1) || i < b)
x2 = -1;
else
x2 = d[i - b] + 1;
if ((i > c && d[i - c] == -1) || i < c)
x3 = -1;
else
x3 = d[i - c] + 1;
d[i] = max(max(x1, x2), x3);
}
cout << d[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[10005];
int main() {
int n, a[3];
scanf("%d", &n);
for (int i = 0; i < 3; i++) scanf("%d", &a[i]);
int v[3] = {1, 1, 1};
for (int i = 0; i < 10005; i++) f[i] = -99999999;
f[0] = 0;
for (int i = 0; i < 3; i++) {
for (int j = a[i]; j <= n; j++) {
f[j] = max(f[j], f[j - a[i]] + v[i]);
}
}
printf("%d\n", f[n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
scanf("%d %d %d %d", &n, &a, &b, &c);
int t = n / a;
int o = n / b;
int dap = 0;
for (int i = 0; i <= t; i++) {
for (int y = 0; y <= o; y++) {
if (a * i + y * b > n) continue;
int x = n - a * i - b * y;
if (x % c == 0) dap = max(dap, i + y + (x / c));
}
}
printf("%d", dap);
}
|
#include <bits/stdc++.h>
using namespace std;
int ar[5005];
int l;
int cut(int n, int a, int b, int c) {
if (n == 0)
return 0;
else if (n < 0)
return INT_MIN;
if (ar[n] == 0)
ar[n] = 1 + max(cut(n - a, a, b, c),
max(cut(n - b, a, b, c), cut(n - c, a, b, c)));
return ar[n];
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
cout << cut(n, a, b, c);
}
|
#include <bits/stdc++.h>
using namespace std;
int ans[4001];
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
for (int i = 0; i < 4001; ++i) ans[i] = -1000000000;
ans[a] = ans[b] = ans[c] = 1;
ans[0] = 0;
for (int i = 1; i <= n; ++i) {
if (i - a >= 0) ans[i] = max(ans[i], ans[i - a] + 1);
if (i - b >= 0) ans[i] = max(ans[i], ans[i - b] + 1);
if (i - c >= 0) ans[i] = max(ans[i], ans[i - c] + 1);
}
cout << ans[n] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int ribbon(int length[], int N) {
int t[4][N + 1];
for (int i = 0; i < 4; i++) {
for (int j = 0; j < N + 1; j++) {
if (j == 0) t[i][j] = 0;
if (i == 0) t[i][j] = INT_MIN;
}
}
for (int i = 1; i < 4; i++) {
for (int j = 1; j < N + 1; j++) {
if (length[i - 1] <= j)
t[i][j] = max((t[i][j - length[i - 1]] + 1), t[i - 1][j]);
else
t[i][j] = t[i - 1][j];
}
}
return t[3][N];
}
int main() {
int N;
cin >> N;
int a[3];
for (int i = 0; i < 3; i++) cin >> a[i];
cout << ribbon(a, N);
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
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;
using namespace chrono;
long long int M = (1e9) + 7;
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 rec(long long int n, vector<long long int> &arr,
vector<long long int> &dp) {
if (n == 0) return dp[n] = 1;
long long int ans = 0;
if (dp[n] != -1) return dp[n];
for (long long int i = 0; i < arr.size(); i++) {
if (n - arr[i] >= 0) {
ans = max(ans, rec(n - arr[i], arr, dp));
}
}
if (ans == 0) return dp[n] = 0;
return dp[n] = ans + 1;
}
void solve() {
long long int n;
cin >> n;
vector<long long int> arr(3);
for (int i = 0; i < 3; i++) {
cin >> arr[i];
}
vector<long long int> dp(n + 1, -1);
cout << rec(n, arr, dp) - 1 << "\n";
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
auto start1 = high_resolution_clock::now();
solve();
auto stop1 = high_resolution_clock::now();
auto duration = duration_cast<microseconds>(stop1 - start1);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long MAX = 1e5 + 5;
const long long modu = 1e9 + 7;
long long n, a, b, c;
long long dp[4005][4005];
long long fun(long long n, long long count) {
if (n < 0) return 0;
if (dp[n][count] != -1) return dp[n][count];
if (n == 0) return count;
long long ans1 = fun(n - a, count + 1);
long long ans2 = fun(n - b, count + 1);
long long ans3 = fun(n - c, count + 1);
return dp[n][count] = max(ans1, max(ans2, ans3));
}
int32_t main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
;
cin >> n >> a >> b >> c;
memset(dp, -1, sizeof(dp));
cout << fun(n, 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;
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 main() {
int t, m, i, j, k, l, ans, count, temp, sum, flag;
cin >> n >> a >> b >> c;
for (i = 1; i < n + 1; i++) {
dp[i] = -9382493;
if (i >= a) 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];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, lol[3];
cin >> n >> lol[0] >> lol[1] >> lol[2];
sort(lol, lol + 3);
int i, j, k;
int x = n / lol[0];
if (n % lol[0] == 0) {
printf("%d\n", x);
return 0;
}
int y = n / lol[1];
int z = n / lol[2];
int max = 0;
for (i = x; i >= 0; i--) {
for (j = y; j >= 0; j--) {
for (k = z; k >= 0; k--) {
if (i * lol[0] + j * lol[1] + k * lol[2] == n) {
if (i + j + k > max) max = i + j + k;
if (lol[0] + lol[1] < lol[2]) {
continue;
} else {
printf("%d", max);
return 0;
}
}
}
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios_base::sync_with_stdio(0);
vector<int> l(3);
int c1 = 0;
int c2 = 0;
int c3 = 0;
int c4 = 0;
int n;
cin >> n >> l[0] >> l[1] >> l[2];
int c;
int r = n;
sort(l.begin(), l.end());
while (n % l[0]) {
c = n;
while (c > 0) {
c -= l[1];
c1++;
if (!(c % l[0])) break;
}
if (c >= 0) break;
n -= l[2];
c1 = 0;
c2++;
}
n = r;
while (n % l[0]) {
c = n;
while (c > 0) {
c -= l[2];
c3++;
if (!(c % l[0])) break;
}
if (c >= 0) break;
n -= l[1];
c3 = 0;
c4++;
}
if (c1 + c2 + (r - c1 * l[1] - c2 * l[2]) / l[0] >
c3 + c4 + (r - c4 * l[1] - c3 * l[2]) / l[0]) {
cout << c1 + c2 + (r - c1 * l[1] - c2 * l[2]) / l[0];
} else
cout << c3 + c4 + (r - c4 * l[1] - c3 * l[2]) / l[0];
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
int mx = INT_MIN;
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= n; j++) {
int s = a * i + b * j;
if (n - s < 0 || (n - s) % c != 0) continue;
mx = max(mx, i + j + (n - s) / c);
}
}
cout << mx << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int mpow(int base, int exp) {
base %= 1000000007;
int result = 1;
while (exp > 0) {
if (exp & 1) result = ((long long)result * base) % 1000000007;
base = ((long long)base * base) % 1000000007;
exp >>= 1;
}
return result;
}
string sconvert(int n) {
stringstream ss;
ss << n;
string str = ss.str();
return str;
}
bool sortbysec(const pair<int, int> &a, const pair<int, int> &b) {
return (a.second > b.second);
}
template <typename KeyType, typename ValueType>
std::pair<KeyType, ValueType> get_max(const std::map<KeyType, ValueType> &x) {
using pairtype = std::pair<KeyType, ValueType>;
return *std::max_element(x.begin(), x.end(),
[](const pairtype &p1, const pairtype &p2) {
return p1.second < p2.second;
});
}
int add(int a, int b, int mod = 1000000007) {
if (a + b >= mod) {
return a + b - mod;
}
return a + b;
}
int sub(int a, int b, int mod = 1000000007) {
if (a - b < 0) {
return a - b + mod;
}
return a - b;
}
int mul(int a, int b, int mod = 1000000007) { return (int)(1ll * a * b % mod); }
const int nax = 50001;
int n;
vector<int> arr(3);
int dp[nax];
int solve(int left) {
if (left <= 0) return 0;
if (dp[left] != -1)
return dp[left];
else {
int ans = INT_MIN;
for (int i = 0; i < 3; i++) {
if (arr[i] <= left) {
ans = max(ans, 1 + solve(left - arr[i]));
}
}
return dp[left] = ans;
}
}
void single() {
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 0; i < 3; i++) cin >> arr[i];
;
cout << solve(n);
return;
}
void multiple() {
int asdf;
cin >> asdf;
while (asdf--) {
single();
}
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(0);
;
single();
}
|
#include <bits/stdc++.h>
using namespace std;
void swap(int& a, int& b) {
a = a ^ b;
b = a ^ b;
a = a ^ b;
}
void get_min3(int& a, int& b, int& c) {
if (a < b) {
if (a < c) {
;
} else {
swap(a, c);
}
} else {
if (b < c) {
swap(a, b);
} else {
swap(a, c);
}
}
}
void get_output(int n, int a, int b, int c) {
if (n < a)
cout << 0;
else {
int cnt[n + 1];
for (int i = 0; i < a; i++) cnt[i] = 0;
cnt[a] = 1;
for (int i = a + 1; i <= n; i++) {
cnt[i] = 0;
if (i >= a) {
cnt[i] =
max(cnt[i], (cnt[i - a] == 0 ? (i == a ? 1 : 0) : cnt[i - a] + 1));
}
if (i >= b) {
cnt[i] =
max(cnt[i], (cnt[i - b] == 0 ? (i == b ? 1 : 0) : cnt[i - b] + 1));
}
if (i >= c) {
cnt[i] =
max(cnt[i], (cnt[i - c] == 0 ? (i == c ? 1 : 0) : cnt[i - c] + 1));
}
}
cout << cnt[n];
}
return;
}
int main() {
int n, a, b, c;
cin >> n >> a >> b >> c;
get_min3(a, b, c);
get_output(n, a, b, c);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
int n, a, b, c, ans = 0;
cin >> n >> a >> b >> c;
for (int i = 0; i <= 4000; i++) {
for (int j = 0; j <= 4000; j++) {
if (n >= i * a + j * b && ((n - i * a - j * b) % c == 0)) {
ans = max(ans, i + j + (n - i * a - j * b) / c);
}
}
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main() {
int n, a, b, c, max = 0, maxX, maxY, maxZ, x, y, z;
cin >> n >> a >> b >> c;
for (x = 0; x <= n / a; x++) {
for (y = 0; y <= n / b; y++) {
if ((n - (x * a + y * b)) % c == 0 && n >= (x * a + y * b)) {
z = (n - (x * a + y * b)) / c;
int sum = x + y + z;
if (sum > max) {
max = sum;
maxX = x;
maxY = y;
maxZ = z;
}
}
}
}
cout << max << endl;
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/stack:200000000")
using namespace std;
ifstream fin("AAtest.in.txt");
int n, a, b, c, vas;
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
cerr.tie(0);
cin >> n >> a >> b >> c;
int aa = 0, vas = 0;
while (aa <= n) {
int bb = 0;
while (bb <= n - aa) {
int cc = n - aa - bb;
if (!(cc % c)) vas = max(vas, aa / a + bb / b + cc / c);
bb += b;
}
aa += a;
}
cout << vas;
}
|
#include <bits/stdc++.h>
using namespace std;
map<char, int> mp;
int main(int argc, char const *argv[]) {
int n;
int a[3];
while (~scanf("%d %d %d %d", &n, &a[0], &a[1], &a[2])) {
int dp[10001] = {0};
for (int i = 0; i < 3; i++) {
for (int j = a[i]; j <= n; j++) {
if ((j - a[i] == 0) || (dp[j - a[i]] != 0))
dp[j] = max(dp[j], dp[j - a[i]] + 1);
}
}
printf("%d\n", dp[n]);
}
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.