text
stringlengths 49
983k
|
|---|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second > b.second; }
pair<int, int> a[105];
int dp2[105][10005];
int dp[105][10005], tot, n;
int solve(int i, int j) {
if (j < 0) return 100000000;
if (i == 0) {
if (j > a[i].second) return dp[i][j] = 100000000;
dp2[i][j] = (j && 1);
return dp[i][j] = abs(j - a[i].first);
}
if (dp[i][j] != -1) return dp[i][j];
dp[i][j] = 100000000;
dp2[i][j] = 100000000;
for (int x = 0; x <= a[i].second && x <= j; ++x) {
int tmp = abs(x - a[i].first) + solve(i - 1, j - x);
if (dp2[i - 1][j - x] == -1) continue;
if (dp2[i - 1][j - x] + (x && 1) < dp2[i][j]) {
dp[i][j] = tmp;
dp2[i][j] = dp2[i - 1][j - x] + (x && 1);
continue;
}
if (dp2[i - 1][j - x] + (x && 1) == dp2[i][j]) {
dp[i][j] = min(dp[i][j], tmp);
continue;
}
}
return dp[i][j];
}
int main() {
for (int i = 0; i < 105; ++i) {
for (int j = 0; j < 10005; ++j) {
dp[i][j] = -1;
dp2[i][j] = -1;
}
}
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i].first);
tot += a[i].first;
}
for (int i = 0; i < n; ++i) scanf("%d", &a[i].second);
sort(a, a + n, cmp);
solve(n - 1, tot);
printf("%d %d\n", dp2[n - 1][tot], dp[n - 1][tot] / 2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[106][10006];
struct bottle {
int remain, volume;
} f[105];
bool cmp(bottle a, bottle b) {
if (a.volume != b.volume)
return a.volume > b.volume;
else
return a.remain > b.remain;
}
int main() {
int n;
cin >> n;
int sum1, sum2;
sum1 = sum2 = 0;
for (int i = 1; i <= n; i++) {
cin >> f[i].remain;
sum1 += f[i].remain;
}
for (int i = 1; i <= n; i++) {
cin >> f[i].volume;
sum2 += f[i].volume;
}
int x = sum1;
int num = 0;
sort(f + 1, f + 1 + n, cmp);
while (1) {
x -= f[++num].volume;
if (x <= 0) break;
}
for (int i = 0; i <= 105; i++)
for (int j = 0; j <= 10005; j++) dp[i][j] = -999999;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum2; j >= f[i].volume; j--)
for (int k = 1; k <= num; k++)
dp[k][j] = max(dp[k][j], dp[k - 1][j - f[i].volume] + f[i].remain);
}
int ans = 0;
for (int i = sum1; i <= sum2; i++) {
ans = max(ans, dp[num][i]);
}
printf("%d %d\n", num, sum1 - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int mx = 1e2 + 10;
int a[mx], b[mx], n;
int dp[mx][mx * mx];
int main() {
scanf("%d", &n);
int sum = 0, ret = 0;
memset(dp, 0, sizeof(dp));
for (int i = 1; i <= n; i++) scanf("%d", a + i), sum += a[i];
for (int i = 1; i <= n; i++) scanf("%d", b + i), ret += b[i];
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 1; j--) {
for (int k = ret; k > 0; k--) {
if (dp[j - 1][k])
dp[j][k + b[i]] = max(dp[j][k + b[i]], dp[j - 1][k] + a[i]);
}
if (j == 1) dp[j][b[i]] = max(dp[j][b[i]], a[i]);
}
}
for (int i = 1; i <= n; i++)
for (int j = ret - 1; j > 0; j--) dp[i][j] = max(dp[i][j], dp[i][j + 1]);
for (int i = 1; i <= n; i++) {
if (dp[i][sum]) {
printf("%d %d\n", i, sum - dp[i][sum]);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long ans = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) ans = (ans * 10) + (ch ^ '0'), ch = getchar();
return ans * f;
}
struct node {
long long a, b;
bool operator<(const node &x) const { return b > x.b; }
} c[110];
long long n, ans, suma, sumb, k = 0, f[15000][110];
signed main() {
n = read();
for (long long i = 1; i <= n; i++) {
c[i].a = read(), suma += c[i].a;
}
for (long long i = 1; i <= n; i++) c[i].b = read();
sort(c + 1, c + 1 + n);
while (sumb < suma) sumb += c[++k].b;
memset(f, 128, sizeof(f));
f[0][0] = 0;
printf("%lld ", k);
for (long long i = 1; i <= n; i++)
for (long long j = sumb; j >= c[i].b; j--)
for (long long kk = 1; kk <= k; kk++)
f[j][kk] = max(f[j][kk], f[j - c[i].b][kk - 1] + c[i].a);
for (long long i = suma; i <= sumb; i++) ans = max(ans, f[i][k]);
cout << suma - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long N = 110;
long long n, m, sum, cnt, p, f[N][N * N], ans;
struct data {
long long x, y;
} a[N];
bool cmp(data x, data y) { return x.y == y.y ? x.x > y.x : x.y > y.y; }
signed main() {
scanf("%lld", &n);
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i].x), sum += a[i].x;
for (long long i = 1; i <= n; i++) scanf("%lld", &a[i].y), m += a[i].y;
sort(a + 1, a + 1 + n, cmp);
for (long long i = 1; i <= n; i++) {
cnt += a[i].y;
if (cnt >= sum) {
p = i;
break;
}
}
memset(f, -0x3f, sizeof(f)), f[0][0] = 0;
for (long long i = 1; i <= n; i++)
for (long long j = m; j >= a[i].y; j--)
for (long long k = 1; k <= p; k++)
f[k][j] = max(f[k][j], f[k - 1][j - a[i].y] + a[i].x);
for (long long i = sum; i <= m; i++) ans = max(ans, f[p][i]);
printf("%lld %lld\n", p, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
} c[101];
bool cmp(node x, node y) { return x.b > y.b; }
int n, suma, sumb, num, ans, f[101][10001];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i].a;
suma += c[i].a;
}
for (int i = 1; i <= n; i++) {
cin >> c[i].b;
}
sort(c + 1, c + n + 1, cmp);
while (sumb < suma) sumb += c[++num].b;
cout << num << " ";
memset(f, 128, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sumb; j >= c[i].b; j--) {
for (int k = 1; k <= num; k++) {
f[k][j] = max(f[k][j], f[k - 1][j - c[i].b] + c[i].a);
}
}
}
for (int i = suma; i <= sumb; i++) {
ans = max(ans, f[num][i]);
}
cout << suma - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[105], b[105];
pair<int, int> dp[105][10000 * 2 + 5];
int n;
pair<int, int> rek(int p, int left) {
if (p == n) {
if (left >= 10000) return pair<int, int>(0, 0);
return pair<int, int>(1000, 1000000);
}
pair<int, int> &res = dp[p][left];
if (res.first != -1) return res;
res = pair<int, int>(1000, 100000);
pair<int, int> temp;
temp = rek(p + 1, left - a[p]);
temp.second += a[p];
if (temp.first < res.first ||
(temp.first == res.first && temp.second < res.second))
res = temp;
temp = rek(p + 1, left + (b[p] - a[p]));
temp.first += 1;
if (temp.first < res.first ||
(temp.first == res.first && temp.second < res.second))
res = temp;
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 20000; j++) {
dp[i][j] = pair<int, int>(-1, -1);
}
}
pair<int, int> res = rek(0, 10000);
cout << res.first << " " << res.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int n, f[N][N * N], s[N], sa;
struct bottle {
int a, b;
} q[N];
inline bool cmp(bottle a, bottle b) { return a.b > b.b; }
inline void upd(int &x, int y) { (y < x) && (x = y); }
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; ++i) scanf("%d", &q[i].a), sum += q[i].a;
for (int i = 1; i <= n; ++i) scanf("%d", &q[i].b);
sort(q + 1, q + n + 1, cmp);
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + q[i].b;
int mx = 0;
sa = sum;
for (int i = 1; i <= n; ++i) {
sum -= q[i].b;
if (sum <= 0) {
mx = i;
break;
}
}
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = i; j >= 0; --j) {
for (int k = s[i]; k >= 0; --k) {
f[j][k] += q[i].a;
if (k >= q[i].b && j >= 1) upd(f[j][k], f[j - 1][k - q[i].b]);
}
}
}
int ans = 0x3f3f3f3f;
for (int k = sa; k <= s[n]; ++k) ans = min(ans, f[mx][k]);
printf("%d %d\n", mx, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x *= f;
}
const int maxn = 110;
int n;
int tot, res, ans;
struct bottle {
int a, b;
friend bool operator<(bottle a, bottle b) { return a.b > b.b; }
} bt[maxn];
int f[maxn][maxn * maxn], mx;
inline void dp() {
memset(f, -100, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = mx; j >= bt[i].b; --j)
for (int k = 1; k <= res; ++k)
f[k][j] = max(f[k][j], f[k - 1][j - bt[i].b] + bt[i].a);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(bt[i].a);
tot += bt[i].a;
}
for (int i = 1; i <= n; ++i) {
read(bt[i].b);
mx += bt[i].b;
}
sort(bt + 1, bt + n + 1);
ans = tot;
for (int i = 1; i <= n; ++i) {
if (tot > bt[i].b)
tot -= bt[i].b;
else {
res = i;
break;
}
}
dp();
int maxx = 0;
for (int i = ans; i <= mx; ++i) maxx = max(maxx, f[res][i]);
cout << res << ' ' << ans - maxx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int scan(int *buf_tar) {
char buf_c = 0;
bool is_rev = 0;
while (buf_c != '-' && (buf_c < '0' || buf_c > '9')) {
buf_c = getchar();
if (buf_c == EOF) return EOF;
}
if (buf_c == '-') is_rev = 1, buf_c = getchar();
*buf_tar = 0;
while (buf_c >= '0' && buf_c <= '9') {
*buf_tar *= 10;
*buf_tar += buf_c - '0';
buf_c = getchar();
}
if (is_rev) *buf_tar = -*buf_tar;
return 0;
}
int scan(long long *buf_tar) {
char buf_c = 0;
bool is_rev = 0;
while (buf_c != '-' && (buf_c < '0' || buf_c > '9')) {
buf_c = getchar();
if (buf_c == EOF) return EOF;
}
if (buf_c == '-') is_rev = 1, buf_c = getchar();
*buf_tar = 0;
while (buf_c >= '0' && buf_c <= '9') {
*buf_tar *= 10;
*buf_tar += buf_c - '0';
buf_c = getchar();
}
if (is_rev) *buf_tar = -*buf_tar;
return 0;
}
int n;
int a[110], b[110], sb[110];
int limit[110];
int f[110][10010];
inline bool cp(const int &, const int &);
int main() {
register int suma = 0, max_cnt, ans = 0;
scan(&n);
for (int i = 1; i <= n; ++i) {
scan(&a[i]);
suma += a[i];
}
for (int i = 1; i <= n; ++i) {
scan(&b[i]);
sb[i] = b[i];
}
sort(sb + 1, sb + 1 + n, cp);
for (int i = 1; i <= n; ++i) limit[i] = limit[i - 1] + sb[i];
for (int i = 1; i <= n; ++i)
if (limit[i] >= suma) {
printf("%d ", max_cnt = i);
break;
}
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = max_cnt; j; --j)
for (int t = limit[j - 1] + b[i]; t >= b[i]; --t)
if (f[j - 1][t - b[i]] >= 0)
f[j][t] = max(f[j][t], f[j - 1][t - b[i]] + a[i]);
for (int i = suma; i <= limit[max_cnt]; ++i) ans = max(ans, f[max_cnt][i]);
printf("%d\n", suma - ans);
return 0;
}
inline bool cp(const int &_a, const int &_b) { return _a > _b; }
|
#include <bits/stdc++.h>
using namespace std;
int n, f[110][110 * 110];
pair<int, int> x[110];
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second > b.second; }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) cin >> x[i].first, sum += x[i].first;
for (int i = 1; i <= n; i++) cin >> x[i].second;
sort(x + 1, x + n + 1, cmp);
int vt = 0, temp = 0;
for (int i = 1; i <= n; i++) {
temp += x[i].second;
if (temp >= sum) {
vt = i;
break;
}
}
for (int i = 1; i <= n; i++) {
for (int j = min(i - 1, vt); j >= 1; j--)
for (int k = sum + 1; k >= 0; k--) {
if (f[j][k] == 0) continue;
if (k + x[i].second > sum) {
f[j + 1][sum + 1] = max(f[j + 1][sum + 1], f[j][k] + x[i].first);
} else
f[j + 1][k + x[i].second] =
max(f[j + 1][k + x[i].second], f[j][k] + x[i].first);
}
f[1][min(sum + 1, x[i].second)] =
max(f[1][min(sum + 1, x[i].second)], x[i].first);
}
cout << vt << " ";
cout << sum - max(f[vt][sum], f[vt][sum + 1]);
}
|
#include <bits/stdc++.h>
const int MAXN = 105;
int n;
int dp[MAXN][MAXN * MAXN];
using namespace std;
struct Record {
int a, b;
} rec[MAXN];
bool cmp(const Record& x, const Record& y) {
if (x.b != y.b)
return x.b > y.b;
else
return x.a > y.a;
}
int main() {
while (~scanf("%d", &n)) {
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &rec[i].a);
sum += rec[i].a;
}
for (int i = 1; i <= n; i++) scanf("%d", &rec[i].b);
sort(rec + 1, rec + n + 1, cmp);
int k;
for (int i = 1, j = 0; i <= n; i++) {
j += rec[i].b;
if (j >= sum) {
k = i;
break;
}
}
memset(dp, 0x80, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = k; j > 0; j--)
for (int l = 10000; l >= rec[i].b; l--)
dp[j][l] = max(dp[j][l], dp[j - 1][l - rec[i].b] + rec[i].a);
int temp = 0;
for (int i = sum; i <= 100 * k; i++) temp = max(temp, dp[k][i]);
printf("%d %d\n", k, sum - temp);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int f[20001][101];
struct node {
int ai, bi;
} a[1001];
bool cmp(node x, node y) { return x.bi > y.bi; }
int main() {
int n, sum1 = 0, sum2 = 0, d = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].ai);
sum1 += a[i].ai;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].bi);
}
sort(a + 1, a + n + 1, cmp);
while (sum1 > sum2) sum2 += a[++d].bi;
printf("%d ", d);
memset(f, 128, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum2; j >= a[i].bi; j--) {
for (int k = 1; k <= d; k++) {
f[j][k] = max(f[j][k], f[j - a[i].bi][k - 1] + a[i].ai);
}
}
}
int ans = 0;
for (int i = sum1; i <= sum2; i++) {
ans = max(ans, f[i][d]);
}
printf("%d\n", sum1 - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, f[110][110 * 110];
pair<int, int> x[110];
bool cmp(pair<int, int> a, pair<int, int> b) { return a.second > b.second; }
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int sum = 0;
for (int i = 1; i <= n; i++) cin >> x[i].first, sum += x[i].first;
for (int i = 1; i <= n; i++) cin >> x[i].second;
sort(x + 1, x + n + 1, cmp);
int vt = 0, temp = 0;
for (int i = 1; i <= n; i++) {
temp += x[i].second;
if (temp >= sum) {
vt = i;
break;
}
}
for (int i = 1; i <= n; i++) {
for (int j = min(i - 1, vt); j >= 1; j--)
for (int k = sum + 1; k >= 0; k--) {
if (f[j][k] == 0) continue;
if (k + x[i].second > sum) {
f[j + 1][sum + 1] = max(f[j + 1][sum + 1], f[j][k] + x[i].first);
} else
f[j + 1][k + x[i].second] =
max(f[j + 1][k + x[i].second], f[j][k] + x[i].first);
}
f[1][min(sum + 1, x[i].second)] =
max(f[1][min(sum + 1, x[i].second)], x[i].first);
}
cout << vt << " ";
cout << sum - max(f[vt][sum], f[vt][sum + 1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 111;
struct node {
int a, b;
node() {}
node(int a, int b) : a(a), b(b) {}
} a[N];
int cmp(node a, node b) {
if (a.b != b.b) return a.b > b.b;
return a.a > b.a;
}
int dp[2][N][N * N];
int main() {
int n;
while (cin >> n) {
int sa = 0;
for (int i = 1; i <= n; ++i) cin >> a[i].a, sa += a[i].a;
for (int i = 1; i <= n; ++i) cin >> a[i].b;
sort(a + 1, a + 1 + n, cmp);
int k = 0, sb = 0;
for (int i = 1; !k && i <= n; ++i) {
sb += a[i].b;
if (sb >= sa) k = i;
}
memset(dp, -1, sizeof(dp));
int curb = 0;
dp[0][0][0] = dp[1][0][0] = 0;
for (int i = 1; i <= n; ++i) {
curb += a[i].b;
for (int j = 1; j <= k; ++j) {
if (j > i) break;
for (int w = curb; w >= 0; --w) {
dp[i & 1][j][w] = dp[1 - (i & 1)][j][w];
if (w < a[i].b || dp[1 - (i & 1)][j - 1][w - a[i].b] == -1) continue;
dp[i & 1][j][w] =
max(dp[1 - (i & 1)][j - 1][w - a[i].b] + a[i].a, dp[i & 1][j][w]);
}
}
}
int maxi = 0;
for (int i = sa; i <= curb; ++i) maxi = max(maxi, dp[n & 1][k][i]);
int t = sa - maxi;
cout << k << " " << t << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int readint() {
int x;
scanf("%d", &x);
return x;
}
int dp[10005][105];
int main() {
int n = readint();
vector<int> a(n + 1), b(n + 1);
vector<int> c(n + 1);
int sum = 0;
for (int i = 1; i <= n; i++) a[i] = readint(), sum += a[i];
for (int i = 1; i <= n; i++) b[i] = readint(), c[i] = b[i];
sort(c.begin(), c.end());
reverse(c.begin() + 1, c.end());
for (int i = 1; i <= n; i++) c[i] = c[i - 1] + c[i];
int k = lower_bound(c.begin(), c.end(), sum) - c.begin();
cout << k << ' ';
memset(dp, 128, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = c[k]; j >= b[i]; j--)
for (int kk = 1; kk <= k; kk++)
dp[j][kk] = max(dp[j][kk], dp[j - b[i]][kk - 1] + a[i]);
int ans = -1;
for (int i = sum; i <= c[k]; i++) ans = max(ans, dp[i][k]);
cout << sum - ans;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105], b[105];
pair<int, int> memo[105][20005];
pair<int, int> dp(int i, int x) {
if (i == n)
return (x < 0 ? pair<int, int>(105, 10002) : pair<int, int>(0, 0));
if (memo[i][x + 10002] != pair<int, int>(-1, -1)) return memo[i][x + 10002];
memo[i][x + 10002] = dp(i + 1, x + b[i] - a[i]);
memo[i][x + 10002].first += 1;
pair<int, int> tmp = dp(i + 1, x - a[i]);
tmp.second += a[i];
if (tmp.first < memo[i][x + 10002].first)
memo[i][x + 10002] = tmp;
else if (tmp.first == memo[i][x + 10002].first)
memo[i][x + 10002].second = min(memo[i][x + 10002].second, tmp.second);
return memo[i][x + 10002];
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) scanf("%d", &a[i]);
for (int i = 0; i < n; ++i) scanf("%d", &b[i]);
memset(memo, -1, sizeof memo);
pair<int, int> ans = dp(0, 0);
printf("%d %d\n", ans.first, ans.second);
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
} p[105];
int dp[105][105 * 105];
bool cmp(const node &a, const node &b) { return a.b > b.b; }
int main() {
int n, sum = 0, tmp, cnt = 0, tol = 0, ans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &p[i].a), sum += p[i].a;
for (int i = 1; i <= n; i++) scanf("%d", &p[i].b), tol += p[i].b;
tmp = sum;
sort(p + 1, p + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
tmp -= p[i].b;
if (tmp <= 0) {
cnt = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = tol; j >= p[i].b; j--) {
for (int k = i; k > 0; k--) {
if (dp[k - 1][j - p[i].b] != -1) {
dp[k][j] = max(dp[k][j], dp[k - 1][j - p[i].b] + p[i].a);
}
}
}
}
for (int i = sum; i <= tol; i++) ans = max(ans, dp[cnt][i]);
printf("%d %d\n", cnt, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = INT_MAX;
const unsigned long long INF = LLONG_MAX;
const unsigned long long mod = 1e9 + 7;
int main() {
ios_base::sync_with_stdio(false), cin.tie(NULL), cout.tie(NULL);
int n;
cin >> n;
vector<int> a(n);
unsigned long long t1 = 0, t2 = 0;
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
t1 += a[i];
}
vector<int> b(n);
for (int i = 0; i <= n - 1; i++) {
cin >> b[i];
t2 += b[i];
}
vector<long long int> vfilled(10001, -INF);
vector<long long int> num(10001, INF);
num[0] = 0;
vfilled[0] = 0;
for (int i = 0; i <= n - 1; i++) {
for (int j = 10000 - b[i]; j >= 0; j--) {
if (num[j] != INF) {
if (num[j + b[i]] > num[j] + 1) {
num[j + b[i]] = num[j] + 1;
vfilled[j + b[i]] = vfilled[j] + a[i];
} else if (num[j + b[i]] == num[j] + 1) {
vfilled[j + b[i]] = max(vfilled[j + b[i]], vfilled[j] + a[i]);
}
}
}
}
unsigned long long count = INF, ans = INF;
for (long long int i = t1; i <= 10000; i++) {
if (num[i] < count) {
count = num[i];
ans = t1 - vfilled[i];
} else if (num[i] == count) {
unsigned long long current = i;
ans = min(ans, t1 - vfilled[i]);
}
}
cout << count << " " << ans;
return 0;
}
|
#include <bits/stdc++.h>
char BB[1 << 15], *SS = BB, *TT = BB;
inline int Read() {
register int x = 0;
register char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch < '0' || ch > '9')
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch <= '9' && ch >= '0') {
x = x * 10 + (ch ^ 48);
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
}
return x;
}
inline int Max(const int x, const int y) { return x > y ? x : y; }
int a[100 + 5], b[100 + 5], n, m, f[10000 + 42], g[10000 + 42], ans;
int main() {
n = Read();
for (register int i = 1; i <= n; ++i) m += (a[i] = Read());
for (register int i = 1; i <= n; ++i) b[i] = Read();
for (register int i = m + 100; i >= 1; --i) f[i] = n;
for (register int i = 1; i <= n; ++i)
for (register int j = m + 100; j >= b[i]; --j)
if (f[j - b[i]] + 1 < f[j]) {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + a[i];
} else if (f[j - b[i]] + 1 == f[j])
g[j] = Max(g[j], g[j - b[i]] + a[i]);
f[0] = n;
for (register int i = m + 100; i >= m; --i)
if (f[ans] > f[i])
ans = i;
else if (f[ans] == f[i] && g[ans] < g[i])
ans = i;
printf("%d %d", f[ans], m - g[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 105;
struct node {
int a, b;
} num[maxn];
inline bool cmp(node x, node y) {
if (x.b != y.b) return x.b > y.b;
return x.a > y.a;
}
int f[maxn][maxn * maxn], n, m, res, numm, tot, sum;
int main() {
scanf("%d", &n);
for (register int i = 1; i <= n; i++)
scanf("%d", &num[i].a), sum = sum + num[i].a;
for (register int i = 1; i <= n; i++) scanf("%d", &num[i].b);
sort(num + 1, num + n + 1, cmp);
for (register int i = 1; i <= n; i++) {
tot += num[i].b;
if (tot >= sum) {
numm = i;
break;
}
}
printf("%d ", numm);
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (register int i = 1; i <= n; i++)
for (register int k = tot; k >= num[i].b; k--)
for (register int j = 1; j <= numm; j++)
if (f[j - 1][k - num[i].b] != -1)
f[j][k] = max(f[j][k], f[j - 1][k - num[i].b] + num[i].a);
for (register int i = sum; i <= tot; i++) res = max(res, f[numm][i]);
printf("%d\n", sum - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
bool bitcheck(T p, T pos) {
return (bool)(p & (1 << pos));
}
template <typename T>
T biton(T p, T pos) {
return p = p | (1 << pos);
}
template <typename T>
T bitoff(T p, T pos) {
return p = p & ~(1 << pos);
}
template <typename T>
long long int toint(T s) {
long long int p;
stringstream ss(s);
ss >> p;
return p;
}
template <typename T>
string tostring(T n) {
stringstream ss;
ss << n;
return ss.str();
}
template <typename T>
T POW(T b, T p) {
T Ans = 1;
while (p) {
if (p & 1) Ans = (Ans * b);
b = (b * b);
p >>= 1;
}
return Ans;
}
template <typename T>
T BigMod(T b, T p, T Mod) {
T Ans = 1;
while (p) {
if (p & 1) Ans = (Ans * b) % Mod;
b = (b * b) % Mod;
p >>= 1;
}
return Ans;
}
template <typename T>
T ModInverse(T p, T Mod) {
return BigMod(p, Mod - 2, Mod);
}
const int fx[] = {+0, +0, +1, -1, -1, +1, -1, +1};
const int fy[] = {-1, +1, +0, +0, +1, +1, -1, -1};
const int mx = 1e5 + 10;
const long long int inf = (long long int)1e9;
const int mod = 1e9 + 7;
const double pi = 2 * acos(0.0);
const double E = 2.71828182845904523536;
const double eps = 1e-9;
bool mark[mx];
vector<int> prime;
void sieve() {
memset(mark, true, sizeof(mark));
for (int i = 3; i <= (int)sqrt(mx); i += 2) {
if (mark[i]) {
for (int j = i * i; j <= mx; j += 2 * i) mark[j] = false;
}
}
prime.push_back(2);
for (int i = 3; i <= mx; i += 2)
if (mark[i]) prime.push_back(i);
}
long long int a[110], total, n;
vector<pair<long long int, long long int> > v;
pair<long long int, long long int> dp[110][10010];
bool vis[110][10010];
pair<long long int, long long int> boss(long long int i, long long int s) {
if (i == n && s < total) return {inf, inf};
if (i == n && s >= total) return {0, 0};
if (vis[i][s]) return dp[i][s];
vis[i][s] = 1;
pair<long long int, long long int> p1 =
make_pair(1 + boss(i + 1, s + v[i].first).first,
boss(i + 1, s + v[i].first).second);
pair<long long int, long long int> p2 =
make_pair(boss(i + 1, s).first, v[i].second + boss(i + 1, s).second);
return dp[i][s] = min(p1, p2);
}
int main() {
total = 0;
cin >> n;
for (int i = 0; i <= n - 1; i++) {
cin >> a[i];
total += a[i];
}
for (int i = 0; i <= n - 1; i++) {
long long int k;
cin >> k;
v.push_back({k, a[i]});
}
pair<long long int, long long int> d = boss(0, 0);
cout << d.first << " " << d.second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int inf = 2e9;
int mod = 1e9 + 7;
char en = '\n';
int arr[105], arr2[105], temp[105];
unordered_map<int, int> par[105][105];
int recur(int i, int k, int sum) {
if (par[i][k].count(sum)) return par[i][k][sum];
if (k == 0) {
if (sum <= 0)
return 0;
else
return -inf;
}
if (i == 0) {
return -inf;
}
int val =
max(recur(i - 1, k, sum), arr[i] + recur(i - 1, k - 1, sum - arr2[i]));
par[i][k][sum] = val;
return val;
}
int main() {
int n;
cin >> n;
int sum1 = 0;
for (int i = 1; i <= n; i++) {
cin >> arr[i];
sum1 += arr[i];
}
for (int i = 1; i <= n; i++) {
cin >> arr2[i];
temp[i] = arr2[i];
}
int k;
int curr = 0;
sort(temp + 1, temp + n + 1, greater<int>());
for (int i = 1; i <= n; i++) {
curr += temp[i];
if (curr >= sum1) {
k = i;
break;
}
}
int t = recur(n, k, sum1);
cout << k << " " << sum1 - t << en;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct bottle {
int left, vol;
} bottle;
bottle b[105];
bool cmp(bottle a, bottle b) {
if (a.vol != b.vol) return a.vol > b.vol;
return a.left > b.left;
}
int main() {
int n;
cin >> n;
int dp[105][10005];
int sum = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; ++i) {
cin >> b[i].left;
sum += b[i].left;
}
for (int i = 1; i <= n; ++i) {
cin >> b[i].vol;
}
int cnt = 0;
int total = 0;
sort(b + 1, b + n + 1, cmp);
for (int i = 1; i <= n; ++i) {
total += b[i].vol;
if (total >= sum) {
cnt = i;
break;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = sum; (j - b[i].left) >= 0; --j) {
for (int k = i; k >= 1; --k) {
if (dp[k - 1][j - b[i].left] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - b[i].left] + b[i].vol);
}
}
}
int ans = 0;
for (int i = sum; i >= 1; --i) {
if (dp[cnt][i] >= sum) {
ans = sum - i;
break;
}
}
cout << cnt << " " << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const long double eps = 1e-10;
const int INF = 0x3f3f3f3f;
const long long LINF = 0x3f3f3f3f3f3f3f3f;
const int MX = 100 + 7;
const int mod = 1e9 + 7;
long long gcd(long long a, long long b) { return b ? gcd(b, a % b) : a; }
long long quimod(long long a, long long k) {
long long res = 1;
while (k) {
if (k & 1) res = (res * a) % mod;
a = (a * a) % mod;
k >>= 1;
}
return res;
}
long long lcm(long long a, long long b) { return a / gcd(a, b) * b; }
struct node {
int r, v;
inline bool operator<(const node& w) const { return v > w.v; }
} a[MX];
int dp[MX][MX * MX];
int main() {
memset(dp, -1, sizeof(dp));
;
int n;
scanf("%d", &n);
int tot_r = 0, tot_v = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].r);
tot_r += a[i].r;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].v);
tot_v += a[i].v;
}
sort(a + 1, a + 1 + n);
int now = 0;
int num = 0;
for (int i = 1; i <= n; ++i) {
now += a[i].v;
if (now >= tot_r) {
num = i;
break;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = num; j > 0; --j) {
for (int k = tot_v; k >= a[i].v; --k) {
if (dp[j - 1][k - a[i].v] != -1)
dp[j][k] = max(dp[j][k], dp[j - 1][k - a[i].v] + a[i].r);
}
}
}
int res = 0;
for (int i = tot_r; i <= tot_v; ++i) {
res = max(res, dp[num][i]);
}
printf("%d %d\n", num, tot_r - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long Set(long long n, long long pos) { return (n = n | 1 << pos); }
long long reset(long long N, long long pos) { return N = N & ~(1 << pos); }
bool check(long long N, long long pos) { return (bool)(N & (1 << pos)); }
long long pow(long long a, long long b, long long mod) {
long long x = 1, y = a;
while (b > 0) {
if (b % 2 == 1) {
x = (x * y);
if (x > mod) x %= mod;
}
y = (y * y);
if (y > mod) y %= mod;
b /= 2;
}
return x;
}
long long modInverse(long long a, long long m) { return pow(a, m - 2, m); }
const long long LARGE = powl(10, 18);
long long n;
long long arr[201], brr[201];
long long total = 0;
pair<long long, long long> dp[201][20100];
bool vis[201][20100];
pair<long long, long long> fun(long long idx, long long have) {
if (idx == n) {
if (have >= total) {
return make_pair(0, 0);
} else
return make_pair(INT_MAX, INT_MAX);
}
if (vis[idx][have] != 0) return dp[idx][have];
vis[idx][have] = 1;
pair<long long, long long> ans = make_pair(INT_MAX, INT_MAX);
ans = min(ans, make_pair(1 + fun(idx + 1, have + brr[idx]).first,
-arr[idx] + fun(idx + 1, have + brr[idx]).second));
ans = min(ans, fun(idx + 1, have));
return dp[idx][have] = ans;
}
int main() {
while (cin >> n) {
total = 0;
memset(vis, 0, sizeof vis);
for (int i = 0; i < n; i++) cin >> arr[i], total += arr[i];
for (int i = 0; i < n; i++) cin >> brr[i];
pair<long long, long long> ans = fun(0, 0);
cout << ans.first << " " << total + ans.second << endl;
}
}
|
#include <bits/stdc++.h>
using namespace std;
constexpr int INF = 1000000000;
int N;
pair<int, int> bottles[100];
map<pair<int, int>, pair<int, int> > memo;
template <typename T, typename U>
pair<T, U> operator+(const pair<T, U>& a, const pair<T, U>& b) {
return {a.first + b.first, a.second + b.second};
}
pair<int, int> f(int p, int v) {
if (v <= 0) return pair<int, int>(0, v);
if (p >= N) return pair<int, int>(INF, INF);
if (memo.find({p, v}) != memo.end()) return memo[{p, v}];
pair<int, int> r1 = f(p + 1, v - bottles[p].second) +
pair<int, int>(1, bottles[p].second - bottles[p].first);
pair<int, int> r2 = f(p + 1, v);
return memo[{p, v}] = min(r1, r2);
}
int main() {
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", &bottles[i].first);
for (int i = 0; i < N; i++) scanf("%d", &bottles[i].second);
int vol = 0;
for (int i = 0; i < N; i++) vol += bottles[i].first;
pair<int, int> res = f(0, vol);
printf("%d %d\n", res.first, res.second);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 4;
pair<int, int> DP[101][2 * N];
int F[101][101];
int a[101], b[101];
const int inf = 1e5 + 5;
pair<int, int>& dp(int i, int j) {
if (j < 0) return DP[i][N + abs(j)];
return DP[i][j];
}
int n;
pair<int, int> rec(int idx, int volume_free) {
if (dp(idx, volume_free).first != -1) return dp(idx, volume_free);
if (idx == n) {
if (volume_free >= 0) return make_pair(0, 0);
return {inf, 0};
}
pair<int, int> res;
pair<int, int> ff = rec(idx + 1, volume_free + b[idx] - a[idx]);
res.first = ff.first + 1;
res.second = ff.second;
ff = rec(idx + 1, volume_free - a[idx]);
res = min(res, {ff.first, ff.second + a[idx]});
return dp(idx, volume_free) = res;
}
int main() {
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
for (int i = 0; i < 101; ++i)
for (int j = -N; j < N; ++j) dp(i, j).first = -1;
cout << rec(0, 0).first << ' ' << rec(0, 0).second << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MOD = 1e9 + 7;
const int INF = 2e9;
const int magic = 348;
const double eps = 1e-10;
struct bottle {
int cur, vol;
} a[108];
int n, k, sum;
int dp[2][101][10048];
bool cmp(bottle first, bottle second) { return first.vol > second.vol; }
int main() {
int i, j, m;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &a[i].cur);
sum += a[i].cur;
}
for (i = 1; i <= n; i++) scanf("%d", &a[i].vol);
sort(a + 1, a + n + 1, cmp);
int cc = 0;
for (i = 1; i <= n; i++) {
cc += a[i].vol;
if (cc >= sum) break;
}
k = i;
for (i = 0; i <= 1; i++)
for (j = 0; j <= 100; j++)
for (m = 0; m <= 10000; m++) dp[i][j][m] = -INF;
dp[0][0][0] = 0;
int ans = 0;
int p0 = 0, p1 = 1;
for (i = 1; i <= n; i++) {
for (j = 0; j <= k; j++)
for (m = 0; m <= 100 * i; m++) {
dp[p1][j][m] = dp[p0][j][m];
if (j && m - a[i].vol >= 0)
dp[p1][j][m] =
max(dp[p1][j][m], dp[p0][j - 1][m - a[i].vol] + a[i].cur);
if (i == n && j == k && m >= sum) ans = max(ans, dp[p1][j][m]);
}
p0 ^= 1;
p1 ^= 1;
}
printf("%d %d\n", k, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105], b[105];
pair<int, int> dp[105][20006];
bool vis[105][20006];
pair<int, int> solve(int i, int sum) {
if (i == n + 1)
return sum >= 0 ? make_pair(0, 0) : make_pair(100000000, 100000000);
if (vis[i][sum + 10002]) return dp[i][sum + 10002];
vis[i][sum + 10002] = true;
pair<int, int> takit = solve(i + 1, sum - a[i]);
takit.second += a[i];
pair<int, int> leavit = solve(i + 1, sum + b[i] - a[i]);
++leavit.first;
return dp[i][sum + 10002] = min(takit, leavit);
}
int main(int argc, const char* argv[]) {
scanf("%d", &n);
for (int(i) = (1); i <= (int)(n); (i)++) scanf("%d", &a[i]);
for (int(i) = (1); i <= (int)(n); (i)++) scanf("%d", &b[i]);
memset(dp, -1, sizeof dp);
pair<int, int> ans = solve(1, 0);
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
bool operator<(const node& r) const { return r.b < b; }
} e[105];
int dp[10005][105];
int main() {
int n, sum = 0, num = 0, sum2 = 0;
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &e[i].a);
sum += e[i].a;
}
for (int i = 0; i < n; i++) {
scanf("%d", &e[i].b);
sum2 += e[i].b;
}
sort(e, e + n);
for (int i = 0; i < n; i++) {
num += e[i].b;
if (num >= sum) {
num = i + 1;
break;
}
}
for (int i = sum2; i >= 0; i--) {
for (int k = num; k >= 0; k--) {
dp[i][k] = -234723846;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int k = sum2; k >= e[i].b; k--) {
for (int j = num; j >= 1; j--) {
dp[k][j] = max(dp[k][j], dp[k - e[i].b][j - 1] + e[i].a);
}
}
}
int ans = 0;
for (int i = sum; i <= sum2; i++) {
ans = max(ans, dp[i][num]);
}
printf("%d %d\n", num, sum - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[101][101 * 101];
int data[101];
int s[101];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
int n;
cin >> n;
int sum = 0;
vector<pair<int, int> > v;
for (int i = 1; i <= n; i++) cin >> data[i], sum += data[i];
for (int i = 1; i <= n; i++) {
int a;
cin >> a;
v.push_back(pair<int, int>(a, data[i]));
}
sort(v.begin(), v.end(), greater<pair<int, int> >());
for (int i = 1; i <= n; i++) s[i] = s[i - 1] + v[i - 1].first;
int idx = lower_bound(s + 1, s + n + 1, sum) - s;
memset(dp, 192, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = i; j > 0; j--) {
for (int k = v[i - 1].second; k <= sum; k++)
dp[j][k] =
max(dp[j][k], dp[j - 1][k - v[i - 1].second] + v[i - 1].first);
}
}
cout << idx << ' ';
for (int i = sum; i >= 0; i--) {
if (dp[idx][i] >= sum) {
cout << sum - i << "\n";
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110, M = 10010;
int n;
int a[N], b[N], c[N];
int f[M][N];
int main() {
cin >> n;
int sa = 0, sb = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i];
sa += a[i];
}
for (int i = 1; i <= n; i++) {
cin >> b[i];
c[i] = b[i];
sb += b[i];
}
sort(c + 1, c + n + 1, greater<int>());
int s = 0, cnt = 0;
for (int i = 1; i <= n; i++) {
s += c[i];
cnt++;
if (s >= sa) break;
}
memset(f, -0x3f, sizeof f);
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sb; j >= b[i]; j--) {
for (int k = cnt; k >= 1; k--)
f[j][k] = max(f[j][k], f[j - b[i]][k - 1] + a[i]);
}
}
int res = 0;
for (int i = sa; i <= sb; i++) res = max(res, f[i][cnt]);
res = sa - res;
cout << cnt << " " << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 110;
int botlsiz[N], arr[N];
map<int, pair<int, int>> dp[N];
int n;
pair<int, int> solve(int i, int c) {
if (i == n)
if (c >= 0)
return {0, 0};
else
return {1e6, 1e6};
if (dp[i].count(c)) return dp[i][c];
auto ans = solve(i + 1, c + arr[i]);
ans.first += 1;
auto tmp = solve(i + 1, c - botlsiz[i]);
tmp.second += botlsiz[i];
ans = min(ans, tmp);
return dp[i][c] = ans;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", botlsiz + i);
for (int i = 0; i < n; i++) {
scanf("%d", arr + i);
arr[i] -= botlsiz[i];
}
auto ans = solve(0, 0);
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, a[102], b[102];
pair<int, int> dp[102][2 * 10002];
bool vis[102][2 * 10002];
pair<int, int> solve(int i, int diff) {
if (i == n + 1)
return diff >= 10000 ? pair<int, int>(0, 0) : pair<int, int>(1e9, 1e9);
if (vis[i][diff]) return dp[i][diff];
vis[i][diff] = true;
pair<int, int> take = solve(i + 1, diff - a[i]);
take.second += a[i];
pair<int, int> leave = solve(i + 1, diff + b[i] - a[i]);
++leave.first;
return dp[i][diff] = min(take, leave);
}
int main() {
cin >> n;
for (int i = (1); i <= (int)(n); ++i) scanf("%d", &a[i]);
for (int i = (1); i <= (int)(n); ++i) scanf("%d", &b[i]);
pair<int, int> ans = solve(1, 10000);
cout << ans.first << " " << ans.second;
}
|
#include <bits/stdc++.h>
using namespace std;
uint64_t gcd(uint64_t a, uint64_t b) { return b ? gcd(b, a % b) : a; }
bool cmp(pair<int16_t, int16_t> &a, pair<int16_t, int16_t> &b) {
return a.second > b.second;
}
int16_t dp[101][10001][101];
int main(int argc, char *argv[]) {
ios_base::sync_with_stdio(false);
ifstream in("input.txt");
ofstream out("output.txt");
int16_t n, a, b, remaining = 0, available = 0, maxSum = 0, minK = 0;
for (int32_t i = 0; i < 101; ++i)
for (int32_t j = 0; j < 10001; ++j)
for (int32_t k = 0; k < 101; ++k)
if (k == 0 && j == 0)
dp[i][j][k] = 0;
else
dp[i][j][k] = -1;
cin >> n;
vector<pair<int16_t, int16_t>> bottles(n);
for (int32_t i = 0; i < n; ++i) {
cin >> a;
bottles[i].first = a;
remaining += a;
}
for (int32_t i = 0; i < n; ++i) {
cin >> b;
bottles[i].second = b;
available += b;
}
sort(bottles.begin(), bottles.end(), cmp);
int32_t temp = remaining, i = 0;
for (; i < n && temp > 0; ++i) {
temp -= bottles[i].second;
++minK;
}
dp[1][bottles[0].second][1] = bottles[0].first;
for (int32_t i = 2; i <= n; ++i) {
for (int32_t j = 1; j <= available; ++j)
for (int32_t k = 1; k <= i; ++k) {
dp[i][j][k] = dp[i - 1][j][k];
if (j - bottles[i - 1].second >= 0 &&
dp[i - 1][j - bottles[i - 1].second][k - 1] != -1)
dp[i][j][k] = max<int16_t>(
dp[i][j][k], dp[i - 1][j - bottles[i - 1].second][k - 1] +
bottles[i - 1].first);
}
}
for (int32_t j = remaining; j <= available; ++j)
maxSum = max(dp[n][j][minK], maxSum);
cout << minK << " " << remaining - maxSum;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 100 + 10;
const int M = 100 * 100 + 10;
int n, a[N], b[N];
int dp[M], maxw[M];
int main() {
ios::sync_with_stdio(false);
cin >> n;
int sum = 0, total = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
sum += a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
total += b[i];
}
memset(dp, -1, sizeof dp);
memset(maxw, 0, sizeof maxw);
dp[0] = maxw[0] = 0;
for (int i = 0; i < n; ++i) {
for (int k = total; k >= b[i]; --k) {
if (dp[k - b[i]] != -1) {
if (dp[k] == -1) {
dp[k] = dp[k - b[i]] + 1;
maxw[k] = maxw[k - b[i]] + a[i];
} else {
if (dp[k] > dp[k - b[i]] + 1) {
dp[k] = dp[k - b[i]] + 1;
maxw[k] = maxw[k - b[i]] + a[i];
} else if (dp[k] == dp[k - b[i]] + 1) {
maxw[k] = max(maxw[k], maxw[k - b[i]] + a[i]);
}
}
}
}
}
int num = 101, maxW = 0;
for (int k = sum; k <= total; ++k) {
if (dp[k] != -1) num = min(num, dp[k]);
}
for (int k = sum; k <= total; ++k) {
if (dp[k] == num) maxW = max(maxW, maxw[k]);
}
cout << num << " " << sum - maxW << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 0x3f3f3f3f;
const long long INFF = 1e18;
const double pi = acos(-1.0);
const double inf = 1e18;
const double eps = 1e-9;
const long long mod = 1e9 + 7;
const int maxmat = 10;
const unsigned long long BASE = 133333331;
inline void RI(int &x) {
char c;
while ((c = getchar()) < '0' || c > '9')
;
x = c - '0';
while ((c = getchar()) >= '0' && c <= '9') x = (x << 3) + (x << 1) + c - '0';
}
typedef struct node {
int left, volume;
} node;
node a[105];
bool cmp(node a, node b) {
if (a.volume != b.volume)
return a.volume > b.volume;
else
return a.left > b.left;
}
int main() {
int n;
while (~scanf("%d", &n)) {
int dp[105][10005];
int sum = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].left);
sum += a[i].left;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i].volume);
int cnt = 0;
int total = 0;
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
total += a[i].volume;
if (total >= sum) {
cnt = i;
break;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum; (j - a[i].left) >= 0; j--) {
for (int k = i; k >= 1; k--) {
if (dp[k - 1][j - a[i].left] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - a[i].left] + a[i].volume);
}
}
}
int ans = 0;
for (int i = sum; i >= 1; i--) {
if (dp[cnt][i] >= sum) {
ans = sum - i;
break;
}
}
printf("%d %d\n", cnt, ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &x) {
x = 0;
int f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
x *= f;
}
const int maxn = 110;
int n;
int tot, res, ans;
struct bottle {
int a, b;
friend bool operator<(bottle a, bottle b) { return a.b > b.b; }
} bt[maxn];
int f[maxn][maxn * maxn], mx;
inline void dp() {
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = mx; j >= bt[i].b; --j)
for (int k = 1; k <= res; ++k)
if (f[k - 1][j - bt[i].b] >= 0)
f[k][j] = max(f[k][j], f[k - 1][j - bt[i].b] + bt[i].a);
}
int main() {
read(n);
for (int i = 1; i <= n; ++i) {
read(bt[i].a);
tot += bt[i].a;
}
for (int i = 1; i <= n; ++i) {
read(bt[i].b);
mx += bt[i].b;
}
sort(bt + 1, bt + n + 1);
ans = tot;
for (int i = 1; i <= n; ++i) {
if (tot > bt[i].b)
tot -= bt[i].b;
else {
res = i;
break;
}
}
dp();
int maxx = 0;
for (int i = ans; i <= mx; ++i) maxx = max(maxx, f[res][i]);
cout << res << ' ' << ans - maxx;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105], b[105];
pair<int, int> dp[105][105 * 105];
bool seen[105][105 * 105];
int tsa;
pair<int, int> f(int i, int sb) {
if (seen[i][sb]) return dp[i][sb];
seen[i][sb] = true;
if (i == n) {
if (sb >= tsa) {
return dp[i][sb] = make_pair(0, 0);
} else {
return dp[i][sb] = make_pair(105, 0);
}
} else {
auto p = f(i + 1, sb);
p.second += a[i];
auto op = f(i + 1, sb + b[i]);
op.first += 1;
return dp[i][sb] = min(op, p);
}
}
int main() {
scanf("%d", &n);
for (int i = (0); i < (n); i++) {
scanf("%d", a + i);
tsa += a[i];
}
for (int i = (0); i < (n); i++) scanf("%d", b + i);
auto p = f(0, 0);
printf("%d %d\n", p.first, p.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
typedef struct node {
int left, volume;
} node;
node a[105];
bool cmp(node a, node b) {
if (a.volume != b.volume)
return a.volume > b.volume;
else
return a.left > b.left;
}
int main() {
int n;
while (~scanf("%d", &n)) {
int dp[105][10005];
int sum = 0;
memset(dp, -1, sizeof(dp));
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i].left);
sum += a[i].left;
}
for (int i = 1; i <= n; i++) scanf("%d", &a[i].volume);
int cnt = 0;
int total = 0;
sort(a + 1, a + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
total += a[i].volume;
if (total >= sum) {
cnt = i;
break;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum; (j - a[i].left) >= 0; j--) {
for (int k = i; k >= 1; k--) {
if (dp[k - 1][j - a[i].left] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - a[i].left] + a[i].volume);
}
}
}
int ans = 0;
for (int i = sum; i >= 1; i--) {
if (dp[cnt][i] >= sum) {
ans = sum - i;
break;
}
}
printf("%d %d\n", cnt, ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
inline int max(int x, int y) { return x > y ? x : y; }
int n;
struct node {
int a, b;
bool operator<(const node &rhs) const { return b > rhs.b; }
} p[110];
int d[110][110 * 110];
int main() {
int sum = 0, w = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].a);
sum += p[i].a;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &p[i].b);
w += p[i].b;
}
sort(p + 1, p + 1 + n);
int cnt = 1;
int ssum = sum;
while (ssum - p[cnt].b > 0) ssum -= p[cnt++].b;
memset(d, -1, sizeof d);
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 2; j--)
for (int k = w; k >= 1; k--) {
if (d[j - 1][k] != -1) d[j][k] = d[j - 1][k];
if (k >= p[i].b && d[j - 1][k - p[i].b] != -1)
d[j][k] = max(d[j - 1][k - p[i].b] + p[i].a, d[j][k]);
}
d[1][p[i].b] = max(d[1][p[i].b], p[i].a);
}
int ans = 0;
for (int i = w; i >= sum; i--) {
if (d[cnt][i] > ans) ans = d[cnt][i];
}
printf("%d %d\n", cnt, sum - ans);
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[205], b[205], sum;
const int W = 10010;
int dp[205][10500];
int C[205][10500];
int main() {
int i, j;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sum += b[i];
}
for (i = 1; i <= n; i++) {
scanf("%d", &a[i]);
}
for (i = 0; i <= W; i++) dp[0][i] = W * 10;
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = 0; j <= W; j++)
if (j >= a[i]) {
if (dp[i - 1][j] == dp[i - 1][j - a[i]] + 1) {
dp[i][j] = dp[i - 1][j];
C[i][j] = max(C[i - 1][j], C[i - 1][j - a[i]] + b[i]);
continue;
}
if (dp[i - 1][j] > dp[i - 1][j - a[i]] + 1) {
dp[i][j] = dp[i - 1][j - a[i]] + 1;
C[i][j] = C[i - 1][j - a[i]] + b[i];
} else {
dp[i][j] = dp[i - 1][j];
C[i][j] = C[i - 1][j];
}
} else {
dp[i][j] = dp[i - 1][j];
C[i][j] = C[i - 1][j];
}
}
int ans = n + 3, val = 0;
for (i = sum; i <= W; i++)
if (dp[n][i] < ans && dp[n][i] != 0) {
ans = dp[n][i];
val = C[n][i];
} else if (dp[n][i] == ans)
val = max(val, C[n][i]);
printf("%d %d\n", ans, sum - val);
return 0;
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:128000000")
using namespace std;
void solve();
void precalc();
int TESTNUM = 0;
int main() {
string s = "";
cin.tie(0);
cout.sync_with_stdio(0);
cout.precision(10);
cout << fixed;
precalc();
int t = 1;
while (t--) {
++TESTNUM;
solve();
}
return 0;
}
template <typename T>
T binpow(T q, T w, T mod) {
if (!w) return 1 % mod;
if (w & 1) return q * 1LL * binpow(q, w - 1, mod) % mod;
return binpow(q * 1LL * q % mod, w / 2, mod);
}
void precalc() {}
template <typename T>
T gcd(T q, T w) {
while (w) {
q %= w;
swap(q, w);
}
return q;
}
template <typename T>
T lcm(T q, T w) {
return q / gcd(q, w) * w;
}
inline int nxt() {
int x;
cin >> x;
return x;
}
const int C = 100 * 101;
void solve() {
int n;
cin >> n;
vector<int> a(n), b(n);
int a_sum = 0;
for (int i = 0; i < n; ++i) {
cin >> a[i];
a_sum += a[i];
}
for (int i = 0; i < n; ++i) {
cin >> b[i];
}
vector<vector<vector<int>>> dp(
2, vector<vector<int>>(n + 1, vector<int>(C, 1e9)));
dp[0][0][0] = 0;
int par = 0;
for (int i = 0; i < n; ++i) {
dp[par ^ 1].assign(n + 1, vector<int>(C, 1e9));
for (int used = 0; used <= i; ++used) {
for (int sum = 0; sum < C; ++sum) {
dp[par ^ 1][used][sum] =
min(dp[par ^ 1][used][sum], dp[par][used][sum] + a[i]);
if (sum + b[i] < C) {
dp[par ^ 1][used + 1][sum + b[i]] =
min(dp[par ^ 1][used + 1][sum + b[i]], dp[par][used][sum]);
}
}
}
par ^= 1;
}
int used = 0;
while (true) {
bool f = false;
for (int sum = a_sum; sum < C; ++sum) {
if (dp[par][used][sum] < 1e8) {
f = true;
break;
}
}
if (f) {
break;
}
++used;
}
cout << used << " ";
int res = 1e9;
for (int sum = a_sum; sum < C; ++sum) {
res = min(res, dp[par][used][sum]);
}
cout << res << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
long long n, a[101], b[101];
vector<vector<long long>> dp(101, vector<long long>(10001, -10000000000));
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
cin >> n;
for (long long i = 1; i <= n; i++) {
cin >> a[i];
}
for (long long i = 1; i <= n; i++) {
cin >> b[i];
}
dp[0][0] = 0;
vector<vector<long long>> dp_new(101, vector<long long>(10001));
dp_new = dp;
dp[1][b[1]] = a[1];
for (long long i = 2; i <= n; i++) {
for (long long j = 1; j <= n; j++) {
for (long long k = 1; k <= 10000; k++) {
dp_new[j][k] = dp[j][k];
if (k > b[i]) {
dp_new[j][k] = max(dp_new[j][k], dp[j - 1][k - b[i]] + a[i]);
}
}
}
dp_new[1][b[i]] = max(dp_new[1][b[i]], a[i]);
dp = dp_new;
}
sort(b + 1, b + n + 1);
long long sm = 0;
for (long long i = 1; i <= n; i++) sm += a[i];
long long k;
for (long long i = n; i >= 0; i--) {
if (sm <= 0) {
k = n - i;
break;
}
sm -= b[i];
}
sm = 0;
for (long long i = 1; i <= n; i++) sm += a[i];
long long ans = 10000000000;
for (long long i = sm; i <= 10000; i++) {
ans = min(ans, sm - dp[k][i]);
}
cout << k << " " << ans << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
struct ura {
int a, b;
} v[105];
int d[10005][105];
bool cmp(ura a, ura b) { return a.b < b.b; }
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
long long i, j = 0, n, mn = 9999999999LL, k = 0, pz = -1, s1 = 0, s2 = 0,
sc = 0;
cin >> n;
if (n == 1) {
cout << 1 << ' ' << 0;
return 0;
}
for (i = 1; i <= n; ++i) {
cin >> v[i].a;
s1 += v[i].a;
}
for (i = 1; i <= n; ++i) {
cin >> v[i].b;
s2 += v[i].b;
}
sort(v + 1, v + n + 1, cmp);
for (i = n; i >= 1; --i) {
sc += v[i].b;
++k;
if (sc >= s1) break;
}
cout << k << ' ';
k = n - k;
for (pz = 1; pz <= n; ++pz) {
for (j = k - 1; j >= 1; --j) {
for (i = 1; i <= s2 - s1 - v[pz].b; ++i) {
if (d[i][j]) {
if (d[i + v[pz].b][j + 1])
d[i + v[pz].b][j + 1] =
min(d[i + v[pz].b][j + 1], d[i][j] + v[pz].a);
else
d[i + v[pz].b][j + 1] = d[i][j] + v[pz].a;
}
}
}
if (d[v[pz].b][1])
d[v[pz].b][1] = min(d[v[pz].b][1], v[pz].a);
else
d[v[pz].b][1] = v[pz].a;
}
for (i = 1; i <= s2 - s1; ++i) {
if (d[i][k])
if (d[i][k] < mn) mn = d[i][k];
}
if (mn == 9999999999LL)
cout << 0;
else
cout << mn;
}
|
#include <bits/stdc++.h>
using namespace std;
pair<int, int> a[105];
int dp[3][103][10005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int tv = 0;
for (int i = 1; i <= n; i++) {
cin >> a[i].second;
tv += a[i].second;
}
for (int i = 1; i <= n; i++) cin >> a[i].first;
sort(a + 1, a + n + 1);
int tv1 = 0;
int k;
for (int i = n; i >= 1; i--) {
tv1 += a[i].first;
if (tv1 >= tv) {
k = n - i + 1;
break;
}
}
int ans = 0;
for (int j = 0; j <= k; j++) {
for (int u = 0; u <= 10000; u++) {
dp[2][j][u] = -100000000;
}
}
dp[2][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= k; j++) {
for (int u = 0; u <= 10000; u++) {
if (u >= a[i].first) {
dp[1][j][u] =
max(dp[2][j][u], dp[2][j - 1][u - a[i].first] + a[i].second);
} else
dp[1][j][u] = dp[2][j][u];
if (j == k && u >= tv) ans = max(ans, dp[1][j][u]);
}
}
for (int j = 1; j <= k; j++) {
for (int u = 1; u <= 10000; u++) dp[2][j][u] = dp[1][j][u];
}
}
cout << k << '\n';
cout << tv - ans << '\n';
}
|
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:167772160000")
using namespace std;
pair<int, int> bottles[110];
int totAmount;
pair<int, int> dp[110][11000];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 0; i < (n); i++) {
cin >> bottles[i].second;
}
for (int i = 0; i < (n); i++) cin >> bottles[i].first;
for (int i = 0; i < (n + 1); i++)
for (int j = 0; j < (11000); j++) dp[i][j] = pair<int, int>(1E8, 1E8);
dp[0][0] = pair<int, int>(0, 0);
for (int i = 0; i < (n); i++) {
totAmount += bottles[i].second;
for (int j = 0; j < (11000); j++) {
dp[i + 1][j] = min(dp[i][j], dp[i + 1][j]);
for (int k = 0; k <= bottles[i].first; k++) {
if (k <= bottles[i].second)
dp[i + 1][j + k] =
min(dp[i + 1][j + k],
pair<int, int>(dp[i][j].first + 1, dp[i][j].second));
else
dp[i + 1][j + k] =
min(dp[i + 1][j + k],
pair<int, int>(dp[i][j].first + 1,
dp[i][j].second + k - bottles[i].second));
}
}
}
cout << dp[n][totAmount].first << " " << dp[n][totAmount].second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
const int M = 10005;
int n, m, k, a[N], b[N];
int sa, sb, id[N];
int f[N][M], ans;
bool cmp(int i, int j) { return b[i] > b[j]; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) id[i] = i;
sa = sb = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sa += a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sb += b[i];
};
m = sb - sa;
sort(id + 1, id + n + 1, cmp);
for (int i = 1; i <= n; i++) {
sa -= b[id[i]];
if (sa <= 0) {
k = i;
break;
}
}
k = n - k;
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int h = 1; h <= n; h++)
for (int i = min(k, h); i >= 1; i--)
for (int j = m - b[h]; j >= 0; j--)
if (f[i - 1][j] != -1 &&
(f[i][j + b[h]] == -1 || f[i - 1][j] + a[h] < f[i][j + b[h]]))
f[i][j + b[h]] = f[i - 1][j] + a[h];
ans = M;
for (int i = 0; i <= m; i++)
if (f[k][i] != -1) ans = min(ans, f[k][i]);
printf("%d %d\n", n - k, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int x = 0, o = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
const int N = 105;
int sum1, sum2, ans1, ans2, f[N][N * N];
struct ppx {
int res, val;
} a[N];
inline bool cmp(ppx x, ppx y) {
return x.val == y.val ? x.res > y.res : x.val > y.val;
}
int main() {
int n = read();
for (int i = 1; i <= n; ++i) {
a[i].res = read();
sum1 += a[i].res;
}
for (int i = 1; i <= n; ++i) {
a[i].val = read();
sum2 += a[i].val;
}
int now = 0;
sort(a + 1, a + n + 1, cmp);
for (int i = 1; i <= n; ++i) {
now += a[i].val;
if (now >= sum1) {
ans1 = i;
break;
}
}
memset(f, -0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = sum2; j >= a[i].val; --j)
for (int k = 1; k <= ans1; ++k)
f[k][j] = max(f[k][j], f[k - 1][j - a[i].val] + a[i].res);
for (int i = sum1; i <= sum2; ++i) ans2 = max(ans2, f[ans1][i]);
printf("%d %d\n", ans1, sum1 - ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[105][10010];
int a[105], b[105];
int main() {
ios_base::sync_with_stdio(false);
int i, j, k, n;
cin >> n;
for (i = 0; i < n; i++) cin >> a[i];
for (i = 0; i < n; i++) cin >> b[i];
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
int s, t;
s = t = 0;
for (i = 0; i < n; i++) {
for (j = i; j >= 0; j--) {
for (k = 0; k <= t; k++) {
if (dp[j][k] != -1) {
dp[j + 1][k + b[i]] = max(dp[j + 1][k + b[i]], dp[j][k] + a[i]);
}
}
}
s += a[i];
t += b[i];
}
sort(b, b + n);
reverse(b, b + n);
int ans1, ans2;
ans1 = k = 0;
ans2 = 1099999;
while (k < s) {
k += b[ans1];
ans1++;
}
for (i = s; i <= t; ++i) ans2 = min(ans2, s - dp[ans1][i]);
cout << ans1 << " " << ans2 << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using vi = vector<long long int>;
using vvi = vector<vi>;
using vb = vector<bool>;
using vc = vector<char>;
using vs = vector<string>;
using vld = vector<long double>;
using pii = pair<long long int, long long int>;
using psi = pair<string, long long int>;
using pci = pair<char, long long int>;
using vpii = vector<pii>;
long long int const mod = 1e9 + 7;
long long int const maxn = 1e5 + 5;
long long int const inf = 1e18;
long long int add(long long int a, long long int b) {
return ((a % mod) + (b % mod)) % mod;
}
long long int mul(long long int a, long long int b) {
return ((a % mod) * (b % mod)) % mod;
}
long long int powm(long long int x, long long int n, long long int M) {
long long int result = 1;
while (n > 0) {
if (n % 2 == 1) result = (result * x) % M;
x = (x * x) % M;
n = n / 2;
}
return result;
}
long long int modinverse(long long int a, long long int m) {
return powm(a, m - 2, m);
}
bool prime(long long int x) {
if (x <= 1) return false;
for (int i = 2; i <= sqrt(x); i++)
if (x % i == 0) return false;
return true;
}
long long int divisor(long long int x) {
long long int cnt = 0;
for (int i = 1; i <= sqrt(x); i++) {
if (x % i == 0) {
if (i != x / i)
cnt += 2;
else
cnt += 1;
}
}
return cnt;
}
vector<long long int> sieve(long long int n) {
bool prim[n + 1];
memset(prim, true, sizeof(prim));
for (long long int p = 2; p * p <= n; p++) {
if (prim[p] == true) {
for (int i = p * p; i <= n; i += p) prim[i] = false;
}
}
vector<long long int> v;
for (int i = 2; i <= n; i++)
if (prim[i]) v.push_back(i);
return v;
}
long long int const N = 100;
long long int a[N];
long long int b[N];
long long int n;
pii dp[N][N * N + N];
bool vis[N][N * N + N];
pii fun(long long int pos, long long int kitna_jagah) {
if (pos == n) {
if (kitna_jagah >= 0) {
return {0, 0};
}
return {1e9, 1e9};
}
pii &ans = dp[pos][kitna_jagah];
if (vis[pos][kitna_jagah] != false) return ans;
vis[pos][kitna_jagah] = true;
pii cur1 = fun(pos + 1, kitna_jagah - a[pos]);
cur1.second += a[pos];
pii cur2 = fun(pos + 1, kitna_jagah + (b[pos] - a[pos]));
cur2.first += 1;
return ans = min(cur1, cur2);
}
void solve() {
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
for (int i = 0; i < n; i++) cin >> b[i];
pii ans = fun(0, 0);
cout << ans.first << " " << ans.second;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
;
long long int t;
t = 1;
while (t--) {
solve();
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, need, sum, ans;
int f[110][10010], a[110], b[110];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
need += a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
sum += b[i];
}
memset(f, 0xff, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = n; j >= 1; j--)
for (int k = sum; k >= b[i]; k--)
if (f[j - 1][k - b[i]] != -1)
f[j][k] = max(f[j][k], f[j - 1][k - b[i]] + a[i]);
ans = -1;
for (int j = 1; j <= n; j++) {
for (int k = need; k <= sum; k++) ans = max(ans, f[j][k]);
if (ans != -1) {
printf("%d %d", j, need - ans);
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const long long INF = (1uLL << 63) - 1;
const long long mod = 1e9 + 7;
const double Pi = acos(-1.0);
const int maxn = 1e6 + 5;
struct node {
int a, b;
} A[105];
bool cmp(node X, node Y) { return X.b > Y.b; }
int dp[105][10005];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n, V = 0;
int Big = 0;
cin >> n;
memset(dp, -1, sizeof dp);
for (int i = 0; i < n; i++) cin >> A[i].a, V += A[i].a;
for (int i = 0; i < n; i++) cin >> A[i].b, Big += A[i].b;
sort(A, A + n, cmp);
int anst = 0;
int S = 0;
for (int i = 0; i < n; i++) {
S += A[i].b;
if (S >= V) {
anst = i + 1;
break;
}
}
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = anst - 1; j >= 0; j--) {
for (int v = 10000 - A[i].a; v >= 0; v--) {
if (dp[j][v] != -1) {
dp[j + 1][v + A[i].a] = max(dp[j + 1][v + A[i].a], dp[j][v] + A[i].b);
}
}
}
}
int ans = 0;
for (int i = 10000; i >= 0; i--) {
if (dp[anst][i] >= V) {
ans = i;
break;
}
}
cout << anst << " " << V - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum;
int dp[105][10005];
struct node {
int a, b;
} m[105];
bool cmp(node a, node b) {
if (a.b == b.b) return a.a < b.a;
return a.b < b.b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &m[i].a);
sum += m[i].a;
}
for (int i = 1; i <= n; i++) scanf("%d", &m[i].b);
sort(m + 1, m + n + 1, cmp);
int ans = 0;
int ii;
for (int i = n; i >= 1; i--) {
ans += m[i].b;
if (ans >= sum) {
ii = i;
printf("%d ", n - i + 1);
break;
}
}
int nn = n - ii + 1;
for (int k = 1; k <= n; k++)
for (int i = min(k, nn); i >= 1; i--) {
if (i == 1)
dp[1][m[k].b] = max(dp[1][m[k].b], m[k].a);
else
for (int j = 10000; j >= 0; j--) {
if (dp[i - 1][j] == 0) continue;
dp[i][j + m[k].b] = max(dp[i - 1][j] + m[k].a, dp[i][j + m[k].b]);
}
}
int anss = 0;
for (int i = sum; i <= 10000; i++) {
if (dp[nn][i] > anss) anss = dp[nn][i];
}
printf("%d\n", sum - anss);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, a[N], b[N];
pair<int, int> dp[N][N * N];
void init() {
for (int i = 0; i < N; i++) {
for (int j = 0; j < N * N; j++) dp[i][j] = {-1, -1};
}
}
pair<int, int> sum(pair<int, int> p1, pair<int, int> p2) {
return make_pair(p1.first + p2.first, p1.second + p2.second);
}
pair<int, int> solve(int idx, int rem) {
if (rem <= 0) return {0, 0};
if (idx == n) return {(int)1 << 30, (int)1 << 30};
if (dp[idx][rem] != make_pair(-1, -1)) return dp[idx][rem];
int mn = min(b[idx] - a[idx], rem - a[idx]);
return dp[idx][rem] =
min(sum(solve(idx + 1, rem - mn - a[idx]), make_pair(1, mn)),
solve(idx + 1, rem));
}
int main() {
scanf("%d", &n);
int tot = 0;
for (int i = 0; i < n; i++) scanf("%d", &a[i]), tot += a[i];
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
init();
pair<int, int> ans = solve(0, tot);
printf("%d %d", ans.first, ans.second);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void chkmax(T& x, U y) {
if (x < y) x = y;
}
template <typename T, typename U>
inline void chkmin(T& x, U y) {
if (y < x) x = y;
}
int k, t, a[111], tot, id[111], dp[111][111 * 111], b[111], s, n;
bool cmp(int u, int v) { return b[u] > b[v]; }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]), tot += a[i];
for (int i = 0; i < n; i++) scanf("%d", &b[i]), id[i] = i;
sort(id, id + n, cmp);
for (int i = 0; i < n; i++) {
s += b[id[i]];
if (s >= tot) {
k = i + 1;
break;
}
}
for (int i = 0; i <= k; i++)
for (int j = 0; j < 111 * 111; j++) dp[i][j] = -1e8;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = k; j >= 1; j--)
for (int l = 0; l < 111 * 111 - b[i]; l++) {
chkmax(dp[j][l + b[i]], dp[j - 1][l] + a[i]);
}
}
t = 1e8;
for (int j = tot; j < 111 * 111; j++) chkmin(t, tot - dp[k][j]);
cout << k << " " << t << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, p, S1[1000000], S2[1000000], s1, s2, t, T;
bool M[1000000];
struct par {
int v, t;
bool operator<(const par &R) const {
if (t != R.t) return t > R.t;
return v > R.v;
}
} A[100000];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i].v;
t += A[i].v;
}
for (int i = 1; i <= n; i++) {
cin >> A[i].t;
T += A[i].t;
}
M[0] = true;
fill(S1 + 1, S1 + T + 1, 1 << 30);
for (int i = 1; i <= n; i++) {
for (int j = T - A[i].t; j >= 0; j--) {
if (M[j]) {
M[j + A[i].t] = true;
if (S1[j + A[i].t] > S1[j] + 1) {
S1[j + A[i].t] = S1[j] + 1;
S2[j + A[i].t] = S2[j] + A[i].v;
}
if (S1[j + A[i].t] == S1[j] + 1)
S2[j + A[i].t] = max(S2[j + A[i].t], S2[j] + A[i].v);
}
}
}
s1 = 1 << 30;
for (int i = t; i <= T; i++) {
if (!M[i]) continue;
if (s1 > S1[i]) {
s1 = S1[i];
s2 = S2[i];
}
if (s1 == S1[i]) s2 = max(s2, S2[i]);
}
cout << s1 << " " << t - s2 << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 50;
int dp[maxn][maxn * maxn];
struct Node2 {
int a, b;
} t[maxn];
bool cmp2(Node2 x, Node2 y) {
if (x.b != y.b)
return x.b > y.b;
else
return x.a > y.a;
}
int main() {
int n, sum = 0, summ = 0, cnt = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &t[i].a), sum += t[i].a;
for (int i = 1; i <= n; i++) scanf("%d", &t[i].b);
sort(t + 1, t + 1 + n, cmp2);
for (int i = 1; i <= n; i++) {
summ += t[i].b;
if (summ >= sum) {
cnt = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum; j >= t[i].a; j--) {
for (int k = i; k >= 1; k--) {
if (dp[k - 1][j - t[i].a] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - t[i].a] + t[i].b);
}
}
}
int ans = 0;
for (int i = sum; i >= 1; i--) {
if (dp[cnt][i] >= sum) {
ans = sum - i;
break;
}
}
printf("%d %d\n", cnt, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int INF = 100000000;
const int N = 103;
const int M = N * N;
int n;
int a[N];
int b[N];
int dp[N][M];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
for (int i = 0; i < n; i++) scanf("%d", &b[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j < M; j++) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = i; j >= 0; j--) {
for (int x = 0; x < M; x++) {
if (dp[j][x] == INF) continue;
dp[j + 1][x + a[i]] = min(dp[j + 1][x + a[i]], dp[j][x] + b[i]);
}
}
}
int k = n, t = 0;
int S = 0;
for (int i = 0; i < n; i++) S += b[i] - a[i];
for (int i = 0; i <= n; i++)
for (int x = 0; x < M; x++) {
if (dp[i][x] <= S) {
int nk = n - i, nt = x;
if (nk < k || (nk == k && nt < t)) {
k = nk;
t = nt;
}
}
}
printf("%d %d\n", k, t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct Node {
int a, b;
} x[110];
bool cmp(Node i, Node j) {
if (i.a == j.a)
return i.b > j.b;
else
return i.a > j.a;
}
int n, ans, sum, k, dp[110][10010], sumv;
int main() {
while (~scanf("%d", &n)) {
sumv = ans = sum = k = 0;
for (int i = 0; i < n; i++) {
scanf("%d", &x[i].b);
sum += x[i].b;
}
for (int i = 0; i < n; i++) {
scanf("%d", &x[i].a);
sumv += x[i].a;
}
sort(x, x + n, cmp);
int temp = sum, cnt = 0;
while (temp > 0) {
temp -= x[cnt++].a;
k++;
}
memset(dp, -0x3f3f3f3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sumv; j >= x[i - 1].a; j--) {
for (int u = 1; u <= k; u++) {
dp[u][j] = max(dp[u][j], dp[u - 1][j - x[i - 1].a] + x[i - 1].b);
}
}
}
ans = -0x3f3f3f3f;
for (int i = sum; i <= sumv; i++) ans = max(ans, dp[k][i]);
printf("%d %d\n", k, sum - ans);
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 101, INF = 0x3f3f3f3f;
int a[N], b[N], dp[2][N][2 * N * N];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
memset(dp, 0x3f, sizeof dp);
for (int i = N * N; i < 2 * N * N; i++) dp[0][0][i] = 0;
int q = 1;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k < 2 * N * N; k++) {
dp[q][j][k] = min(
k >= a[i] ? a[i] + dp[q ^ 1][j][k - a[i]] : INF,
j && k + b[i] >= a[i] ? dp[q ^ 1][j - 1][k + b[i] - a[i]] : INF);
}
}
q ^= 1;
}
for (int i = 1; i <= n; i++) {
if (dp[q ^ 1][i][N * N] < INF) {
printf("%d %d\n", i, dp[q ^ 1][i][N * N]);
return 0;
}
}
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAX_N = 100;
pair<int, int> d[MAX_N + 1];
int F[MAX_N + 1][MAX_N * MAX_N + 1];
int main() {
int n, sum = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i].second);
sum += d[i].second;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &d[i].first);
}
sort(d + 1, d + 1 + n,
[](pair<int, int> a, pair<int, int> b) { return a.first > b.first; });
int cnt = 0, now = 0;
for (int i = 1; i <= n; i++) {
now += d[i].first;
cnt++;
if (now >= sum) break;
}
memset(F, -1, sizeof(F));
F[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum - d[i].second; j >= 0; j--) {
for (int k = i - 1; k >= 0; k--)
if (F[k][j] != -1) {
F[k + 1][j + d[i].second] =
max(F[k + 1][j + d[i].second], F[k][j] + d[i].first);
}
}
}
int ans = 0;
for (int i = sum; i >= 0; i--) {
if (F[cnt][i] >= sum) {
ans = i;
break;
}
}
printf("%d %d\n", cnt, sum - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = (1 << 17) + 10;
const int inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
int n;
struct NODE {
int a, b;
} node[110];
bool cmp(NODE x, NODE y) { return x.b > y.b; }
int dp[2][110][10010], sum[110];
int main() {
ios_base::sync_with_stdio(false);
cin >> n;
int tot = 0, cnt = 0, tmp = 0;
for (int i = 1; i <= n; i++) {
cin >> node[i].a;
tot += node[i].a;
}
for (int i = 1; i <= n; i++) {
cin >> node[i].b;
}
if (n == 1) {
cout << 1 << " " << 0 << endl;
return 0;
}
sort(node + 1, node + 1 + n, cmp);
for (int i = 1; i <= n; i++) {
tmp += node[i].b;
cnt++;
if (tmp >= tot) break;
}
sum[0] = 0;
for (int i = 1; i <= n; i++) {
sum[i] = sum[i - 1] + node[i].a;
}
memset(dp, -inf, sizeof(dp));
dp[0][0][0] = dp[1][0][0] = 0;
int t = 0;
for (int i = 1; i <= n; i++, t = t ^ 1) {
for (int j = 1; j <= i && j <= cnt; j++) {
for (int k = 0; k <= sum[i]; k++) {
dp[t][j][k] = dp[t ^ 1][j][k];
if (k >= node[i].a) {
dp[t][j][k] =
max(dp[t][j][k], dp[t ^ 1][j - 1][k - node[i].a] + node[i].b);
}
}
}
}
for (int i = tot; i >= 0; i--) {
if (dp[t ^ 1][cnt][i] >= tot) {
cout << cnt << " " << tot - i << endl;
break;
}
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[2][110][110 * 110];
int a[110], b[110], c[110];
template <typename T>
void smax(T& x, T y) {
if (x < y) x = y;
}
int main() {
int N, S, K, SS, tp, ans;
scanf("%d", &N);
for (int i = 0; i < N; i++) scanf("%d", a + i);
for (int i = 0; i < N; i++) scanf("%d", b + i);
for (int i = 0; i < N; i++) c[i] = b[i];
sort(c, c + N);
reverse(c, c + N);
S = 0;
for (int i = 0; i < N; i++) S += a[i];
for (int i = 0; i < N; i++) {
S -= c[i];
if (S <= 0) {
K = i + 1;
break;
}
}
S = 0;
for (int i = 0; i < N; i++) S += a[i];
SS = 0;
for (int i = 0; i < N; i++) SS += b[i];
tp = 0;
memset(dp[tp], 0xff, sizeof(dp[tp]));
dp[tp][0][0] = 0;
dp[tp][1][b[0]] = a[0];
for (int i = 1; i < N; i++) {
for (int k = 0; k <= K; k++)
for (int j = 0; j <= SS; j++) {
dp[tp ^ 1][k][j] = -1;
if (k == 0 && j == 0) {
dp[tp ^ 1][k][j] = 0;
continue;
}
dp[tp ^ 1][k][j] = dp[tp][k][j];
if (k && j >= b[i] && dp[tp][k - 1][j - b[i]] != -1) {
smax(dp[tp ^ 1][k][j], dp[tp][k - 1][j - b[i]] + a[i]);
}
}
tp = tp ^ 1;
}
ans = 0;
for (int i = S; i <= SS; i++) smax(ans, dp[tp][K][i]);
printf("%d %d\n", K, S - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 105;
int n, s;
struct Data {
int res, van;
friend bool operator<(Data x, Data y) { return x.van > y.van; }
} a[N];
int sum, p, f[N][N * N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].res), s += a[i].res;
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].van);
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
sum += a[i].van;
if (sum >= s) {
p = i;
printf("%d ", i);
break;
}
}
memset(f, -1, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int j = s - a[i].res; j >= 0; --j)
for (int k = i - 1; k >= 0; --k)
if (~f[k][j])
f[k + 1][j + a[i].res] =
max(f[k + 1][j + a[i].res], f[k][j] + a[i].van);
for (int i = s; i >= 0; --i)
if (f[p][i] >= s) {
printf("%d\n", s - i);
return 0;
}
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int x, y;
} s[105];
int cmp(node a, node b) { return a.y > b.y; }
int i, n, k, t, j, m, sum = 0, ans = 0;
int dp[105][100005];
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &s[i].x);
sum += s[i].x;
}
for (i = 1; i <= n; i++) scanf("%d", &s[i].y);
sort(s + 1, s + n + 1, cmp);
for (i = 1; i <= n; i++) {
ans += s[i].y;
if (ans >= sum) {
k = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
for (j = sum - s[i].x; j >= 0; j--) {
for (m = i - 1; m >= 0; m--) {
if (dp[m][j] != -1)
dp[m + 1][j + s[i].x] = max(dp[m + 1][j + s[i].x], dp[m][j] + s[i].y);
}
}
}
for (i = sum; i >= 0; i--) {
if (dp[k][i] >= sum) {
t = i;
break;
}
}
printf("%d %d\n", k, sum - t);
}
|
#include <bits/stdc++.h>
char BB[1 << 15], *SS = BB, *TT = BB;
inline int Read() {
register int x = 0;
register char ch =
(SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch < '0' || ch > '9')
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
while (ch <= '9' && ch >= '0') {
x = x * 10 + (ch ^ 48);
ch = (SS == TT && (TT = (SS = BB) + fread(BB, 1, 1 << 15, stdin), TT == SS)
? EOF
: *SS++);
}
return x;
}
inline int Min(const int x, const int y) { return x < y ? x : y; }
inline int ABS(const int x) { return x < 0 ? ~x + 1 : 0x3f3f3f3f3f; }
int a[100 + 5], b[100 + 5], n, m, f[10000 + 42], g[10000 + 42], ans;
int main() {
n = Read();
for (register int i = 1; i <= n; ++i) m += (a[i] = Read());
for (register int i = 1; i <= n; ++i) b[i] = Min(Read(), m);
for (register int i = m + 100; i >= 1; --i) f[i] = n;
for (register int i = 1; i <= n; ++i)
for (register int j = m + 100; j >= b[i]; --j)
if (f[j - b[i]] + 1 < f[j]) {
if (j <= m) {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + b[i] - a[i];
} else {
f[j] = f[j - b[i]] + 1;
g[j] = g[j - b[i]] + b[i] - a[i] + m - j;
}
} else if (f[j - b[i]] + 1 == f[j]) {
if (j <= m)
g[j] = Min(g[j], g[j - b[i]] + b[i] - a[i]);
else
g[j] = Min(g[j], g[j - b[i]] + b[i] - a[i] + m - j);
}
f[0] = n;
for (register int i = m + 100; i >= m; --i)
if (f[ans] > f[i])
ans = i;
else if (f[ans] == f[i] && g[ans] > g[i])
ans = i;
printf("%d %d", f[ans], g[ans]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 1e2 + 5;
struct node {
int a, b;
} c[N];
int n, ans, suma, sumb, k = 0, f[N * N][N];
bool cmp(node x, node y) { return x.b > y.b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> c[i].a;
suma += c[i].a;
}
for (int i = 1; i <= n; i++) {
cin >> c[i].b;
}
sort(c + 1, c + n + 1, cmp);
while (sumb < suma) sumb += c[++k].b;
cout << k << " ";
memset(f, 128, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = sumb; j >= c[i].b; j--)
for (int kk = 1; kk <= k; kk++) {
f[j][kk] = max(f[j][kk], f[j - c[i].b][kk - 1] + c[i].a);
}
for (int i = suma; i <= sumb; i++) ans = max(ans, f[i][k]);
cout << suma - ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 101;
int n, a[maxn], b[maxn], f[maxn][10000], water = 0, ans = 0, m, q, w = 0,
g[maxn][10000];
priority_queue<int> que;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
water += a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
que.push(b[i]);
w += b[i];
}
int tot = 0;
while (tot < water) {
ans++;
int x = que.top();
que.pop();
tot += x;
}
printf("%d ", ans);
m = n - ans;
q = w - water;
memset(g, 63, sizeof(g));
for (int i = 0; i <= q; i++) g[0][i] = 0;
for (int i = b[1]; i <= q; i++) g[1][i] = a[1];
for (int i = 2; i <= n; i++) {
memset(f, 63, sizeof(f));
for (int j = 0; j <= q; j++) {
f[0][j] = 0;
}
for (int j = 1; j <= m; j++) {
if (j > i) continue;
for (int k = 0; k <= q; k++) {
f[j][k] = g[j][k];
if (k >= b[i]) f[j][k] = min(f[j][k], g[j - 1][k - b[i]] + a[i]);
}
}
for (int j = 0; j <= m; j++)
for (int k = 0; k <= q; k++) g[j][k] = f[j][k];
}
printf("%d\n", g[m][q]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
vector<vector<vector<int>>> dp;
vector<int> p;
int check(vector<pair<int, int>>& a, int curr, int capa, int count, int mini,
int sum) {
if (dp[curr][count][capa] != 1000000000) return dp[curr][count][capa];
if (curr == a.size() && count == mini && capa >= sum)
return dp[curr][count][capa] = 0;
else if (curr == a.size())
return dp[curr][count][capa] = 1000000000;
if (count <= mini && curr + mini - count <= a.size() &&
(capa + p[curr] - p[curr + (mini - count)]) < sum)
return dp[curr][count][capa] = 1000000000;
int res = 1000000000;
res = min(res, check(a, curr + 1, capa, count, mini, sum) + a[curr].second);
if (count < mini)
res = min(res,
check(a, curr + 1, capa + a[curr].first, count + 1, mini, sum));
return dp[curr][count][capa] = res;
}
int main() {
std::ios::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
vector<pair<int, int>> a(n);
for (int i = 0; i < n; i++) cin >> a[i].second;
for (int i = 0; i < n; i++) cin >> a[i].first;
sort(a.begin(), a.end(), greater<pair<int, int>>());
int sum = 0;
for (int i = 0; i < n; i++) {
sum += a[i].second;
}
int orig = sum;
int cnt = 0;
for (int i = 0; i < n; i++) {
if (sum - a[i].first <= 0) {
cnt = i + 1;
break;
}
sum -= a[i].first;
}
dp.assign(n + 1, vector<vector<int>>(n + 1, vector<int>(10500, 1000000000)));
int ans = 1000000000;
dp[0][0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= cnt; j++) {
for (int k = 0; k <= cnt * 101; k++) {
if (dp[i][j][k] == 1000000000) continue;
dp[i + 1][j][k] = min(dp[i + 1][j][k], dp[i][j][k] + a[i].second);
dp[i + 1][j + 1][k + a[i].first] =
min(dp[i + 1][j + 1][k + a[i].first], dp[i][j][k]);
}
}
}
for (int i = orig; i <= cnt * 101; i++) {
ans = min(ans, dp[n][cnt][i]);
}
cout << cnt << " " << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 1e2 + 20;
int dp[maxn][maxn * maxn];
int a[maxn], b[maxn];
void work() {
int n;
scanf("%d", &n);
int all_A = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
all_A += a[i];
}
int all_B = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &b[i]);
all_B += b[i];
}
memset(dp, -0x3f, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = n; j >= 1; --j) {
for (int k = all_B; k >= b[i]; --k) {
dp[j][k] = max(dp[j][k], dp[j - 1][k - b[i]] + a[i]);
}
}
}
int ansNeed = (0x3f3f3f3f);
bool flag = true;
for (int i = 1; i <= n && flag; ++i) {
for (int j = 1; j <= all_B; ++j) {
if (dp[i][j] < 0) continue;
int lef = j - dp[i][j];
int need = all_A - dp[i][j];
if (lef >= need) {
flag = false;
ansNeed = min(ansNeed, need);
flag = false;
}
}
if (!flag) {
cout << i << " " << ansNeed << endl;
return;
}
}
}
int main() {
work();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int rem[101];
int vol[101];
int n;
int limit = 10005;
pair<int, int> mem[105][20010];
pair<int, int> go(int ind, int sum) {
if (ind == n) {
if (sum > limit) return {1e9, 1e9};
return {0, 0};
}
pair<int, int> &ret = mem[ind][sum];
if (ret.first != -1) return ret;
int empty = vol[ind] - rem[ind];
pair<int, int> ch1 = go(ind + 1, sum + rem[ind]);
pair<int, int> ch2 = go(ind + 1, sum - empty);
ch1.second += rem[ind];
ch2.first++;
return ret = min(ch1, ch2);
}
int main() {
scanf("%d", &n);
for (int i = 0; i < 105; i++)
for (int j = 0; j < 20010; j++) mem[i][j] = {-1, -1};
for (int i = 0; i < n; i++) scanf("%d", rem + i);
for (int i = 0; i < n; i++) scanf("%d", vol + i);
pair<int, int> res = go(0, limit);
cout << res.first << " " << res.second << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[105][105 * 105];
int n, k, sum;
struct node {
int a, b;
bool operator<(const node &a) const { return b > a.b; }
} p[105];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> p[i].a;
sum += p[i].a;
}
for (int i = 1; i <= n; i++) cin >> p[i].b;
sort(p + 1, p + 1 + n);
int tot = 0;
for (int i = 1; i <= n; i++) {
tot += p[i].b;
if (tot >= sum) {
k = i;
break;
}
}
memset(dp, -1, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum - p[i].a; j >= 0; j--) {
for (int pre = i - 1; pre >= 0; pre--)
if (dp[pre][j] != -1) {
dp[pre + 1][j + p[i].a] =
max(dp[pre + 1][j + p[i].a], dp[pre][j] + p[i].b);
}
}
}
int t;
for (int i = sum; i; i--) {
if (dp[k][i] >= sum) {
t = i;
break;
}
}
printf("%d %d\n", k, sum - t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105], b[105];
int sum;
bool visited[105][105 * 105];
pair<int, int> dp[105][105 * 105];
pair<int, int> cal(int pos, int left) {
if (left <= 0) return make_pair(0, left);
if (pos > n) return make_pair(1e9, 0);
assert(left);
if (visited[pos][left]) return dp[pos][left];
visited[pos][left] = true;
return dp[pos][left] = min(
cal(pos + 1, left),
make_pair(1 + cal(pos + 1, left - b[pos]).first,
b[pos] - a[pos] + cal(pos + 1, left - b[pos]).second));
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) cin >> a[i], sum += a[i];
for (int i = 1; i <= n; i++) cin >> b[i];
cout << cal(1, sum).first << ' ' << cal(1, sum).second << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
inline int max(int x, int y) { return x > y ? x : y; }
int n;
struct node {
int x, y;
bool operator<(const node &rhs) const { return y > rhs.y; }
} p[250];
int d[250][250 * 250];
int main() {
int sum = 0, aans = 0;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
cin >> p[i].x;
sum += p[i].x;
}
for (int i = 1; i <= n; i++) {
cin >> p[i].y;
aans += p[i].y;
}
sort(p + 1, p + 1 + n);
int cnt = 1;
int ssum = sum;
while (ssum - p[cnt].y > 0) ssum -= p[cnt++].y;
memset(d, -1, sizeof d);
for (int i = 1; i <= n; i++) {
for (int j = i; j >= 2; j--)
for (int k = aans; k >= 1; k--) {
if (d[j - 1][k] != -1) d[j][k] = d[j - 1][k];
if (k >= p[i].y && d[j - 1][k - p[i].y] != -1)
d[j][k] = max(d[j - 1][k - p[i].y] + p[i].x, d[j][k]);
}
d[1][p[i].y] = max(d[1][p[i].y], p[i].x);
}
int ans = 0;
for (int i = aans; i >= sum; i--) {
if (d[cnt][i] > ans) ans = d[cnt][i];
}
cout << cnt << ' ' << sum - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
double const EPS = 1e-9, PI = acos(-1);
const int N = 1e2 + 9, M = 1e4 + 9, OO = 1e9 + 7, MOD = 1e9 + 7;
const long long inf = 1e18;
int a[N], b[N], mem[N][M], mem2[N][M], taken[N], total, n, sumBot = OO;
int solve(int idx, int sum) {
if (idx == n) {
if (sum >= total) return 0;
return OO;
}
int& ret = mem[idx][sum];
if (~ret) return ret;
ret = OO;
int c1 = solve(idx + 1, sum);
int c2 = solve(idx + 1, sum + b[idx]) + 1;
return ret = min(c1, c2);
}
int solve2(int idx, int sum) {
if (idx == n) return 0;
int& ret = mem2[idx][sum];
if (~ret) return ret;
ret = OO;
int res = solve(idx, sum);
int c1 = solve(idx + 1, sum);
int c2 = solve(idx + 1, sum + b[idx]) + 1;
if (c1 == c2 && c1 == res) {
ret = min(solve2(idx + 1, sum) + a[idx], solve2(idx + 1, sum + b[idx]));
} else if (c1 == res) {
ret = solve2(idx + 1, sum) + a[idx];
} else if (c2 == res) {
ret = solve2(idx + 1, sum + b[idx]);
} else
assert(0);
return ret;
}
int main() {
cout << fixed << setprecision(12), ios::sync_with_stdio(false),
cin.tie(nullptr), cout.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i], total += a[i];
for (int i = 0; i < n; ++i) cin >> b[i];
memset(mem, -1, sizeof mem);
memset(mem2, -1, sizeof mem2);
cout << solve(0, 0) << ' ' << solve2(0, 0);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, sum = 0, f[30005], maxl, g[30005][105];
struct node {
int a, b;
} t[105];
bool cmp(node x, node y) { return x.a > y.b; }
int main() {
memset(f, 0x3f, sizeof(f));
cin >> n;
f[0] = 0;
for (int i = 1; i <= n; i++) cin >> t[i].a, sum += t[i].a;
for (int i = 1; i <= n; i++) cin >> t[i].b;
for (int i = 1; i <= n; i++) {
for (int j = sum; j >= 0; j--) {
if (j >= t[i].b)
f[j] = min(f[j], f[j - t[i].b] + 1);
else
f[j] = min(f[j], 1);
}
}
cout << f[sum] << " ";
memset(g, -0x3f, sizeof(g));
g[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum + 10005; j >= t[i].b; j--) {
for (int k = f[sum]; k >= 1; k--) {
g[j][k] = max(g[j][k], g[j - t[i].b][k - 1] + t[i].a);
if (j >= sum && k == f[sum]) maxl = max(maxl, g[j][k]);
}
}
}
cout << sum - maxl << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
T getint() {
T x = 0, p = 1;
char ch;
do {
ch = getchar();
} while (ch <= ' ');
if (ch == '-') p = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * p;
}
template <typename T1, typename T2>
bool umin(T1 &x, const T2 &y) {
if (x > y) return x = y, true;
return false;
}
template <typename T1, typename T2>
bool umax(T1 &x, const T2 &y) {
if (x < y) return x = y, true;
return false;
}
const int maxn = 1e6 + 10;
const int inf = (int)1e9 + 5;
const int mod = (int)1e9 + 7;
const long long llinf = (long long)1e18 + 5;
const long double pi = acos(-1.0);
int dp[2][101][101 * 101];
int main() {
int n;
cin >> n;
vector<int> a(n), b(n);
int sum = 0;
for (int i = (0); i < (n); i++) cin >> a[i], sum += a[i];
vector<int> c(n);
for (int i = (0); i < (n); i++) cin >> b[i], c[i] = b[i];
sort((c).begin(), (c).end());
reverse((c).begin(), (c).end());
int x = sum;
int k = 0;
for (int i = (0); i < (c.size()); i++) {
x -= c[i];
k++;
if (x <= 0) break;
}
for (int i = (0); i < (2); i++)
for (int j = (0); j < (101); j++)
for (int k = (0); k < (101 * 101); k++) dp[i][j][k] = -inf;
dp[0][0][0] = 0;
for (int i = (0); i < (n); i++) {
for (int j = (0); j < (n + 1); j++) {
for (int sum = (0); sum < (101 * 101); sum++) {
if (sum >= b[i] && j > 0)
umax(dp[1][j][sum], dp[0][j - 1][sum - b[i]] + a[i]);
umax(dp[1][j][sum], dp[0][j][sum]);
}
}
for (int j = (0); j < (n + 1); j++)
for (int sum = (0); sum < (101 * 101); sum++) {
dp[0][j][sum] = dp[1][j][sum];
dp[1][j][sum] = -inf;
}
}
int res = -inf;
for (int j = (sum); j < (101 * 101); j++) {
umax(res, dp[0][k][j]);
}
cout << k << ' ' << sum - res << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int ase, cap;
node() {}
node(int _koyta, int _pr) {
ase = _koyta;
cap = _pr;
}
bool operator<(const node& P) const {
if (cap == P.cap) return ase < P.ase;
return cap < P.cap;
}
};
struct edge {
int koyta, pr;
edge() {}
edge(int _koyta, int _pr) {
koyta = _koyta;
pr = _pr;
}
bool operator<(const edge& P) const {
if (koyta == P.koyta) return pr < P.pr;
return koyta < P.koyta;
}
};
vector<node> vc;
int n;
edge dp[120][32000];
int vis[120][32000];
edge dp_func(int pos, int container) {
if (pos == n) {
if (container <= 20000) return {0, 0};
return {200, 42000};
}
int l;
if (vis[pos][container]) return dp[pos][container];
vis[pos][container] = 1;
edge ret = {200, 42000}, temp;
temp = dp_func(pos + 1, container - vc[pos].cap);
temp.koyta += 1;
ret = min(ret, temp);
temp = dp_func(pos + 1, container + vc[pos].ase);
temp.pr += vc[pos].ase;
ret = min(ret, temp);
if (container > 20000) {
l = container - 20000;
l = min(l, vc[pos].cap);
temp = dp_func(pos + 1, container - l);
temp.koyta += 1;
ret = min(ret, temp);
}
if (container < 20000) {
l = 20000 - container;
if (l < vc[pos].ase) {
temp = dp_func(pos + 1, 20000 + vc[pos].ase - l);
temp.pr += vc[pos].ase;
ret = min(ret, temp);
} else {
temp = dp_func(pos + 1, container + vc[pos].ase);
temp.pr += vc[pos].ase;
ret = min(ret, temp);
}
}
return dp[pos][container] = ret;
}
int main() {
int i, j, k, l, m;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &l);
node gr;
gr.ase = l;
vc.push_back(gr);
}
for (i = 1; i <= n; i++) {
scanf("%d", &l);
vc[i - 1].cap = l - vc[i - 1].ase;
}
edge gr = dp_func(0, 20000);
printf("%d %d\n", gr.koyta, gr.pr);
}
|
#include <bits/stdc++.h>
using namespace std;
int n, dp[105][10005] = {0};
struct node {
int a, b;
} c[105];
bool cmp(const node &x, const node &y) { return x.b < y.b; }
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &c[i].a);
for (int i = 1; i <= n; i++) scanf("%d", &c[i].b);
sort(c + 1, c + n + 1, cmp);
int sum = 0;
for (int i = n; i; i--) sum += c[i].a;
int ans1 = 0, cur = sum;
for (int i = n; i && cur > 0; i--) {
ans1++;
cur -= c[i].b;
}
int m = 0;
for (int i = 1; i <= n; i++) m += c[i].b;
for (int j = 0; j <= ans1; j++)
for (int i = 0; i <= m; i++) dp[j][i] = -1;
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = m; j >= c[i].b; j--) {
for (int k = ans1; k; k--)
if (dp[k - 1][j - c[i].b] >= 0)
dp[k][j] = max(dp[k][j], dp[k - 1][j - c[i].b] + c[i].a);
}
}
int ans2 = 0;
for (int i = sum; i <= m; i++) ans2 = max(ans2, dp[ans1][i]);
printf("%d %d\n", ans1, sum - ans2);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 100;
int memo[MAXN + 1][100 * MAXN + 1];
bool vis[MAXN + 1][100 * MAXN + 1];
int main() {
int n;
cin >> n;
int total = 0;
int arr[n];
int kek[n];
for (int i = 0; i != n; ++i) {
cin >> arr[i];
total += arr[i];
}
for (int i = 0; i != n; ++i) cin >> kek[i];
vis[0][0] = 1;
for (int i = 0; i != n; ++i) {
for (int j = n; j != 0; --j) {
for (int k = 100 * n; k >= kek[i]; --k) {
if (vis[j - 1][k - kek[i]]) {
vis[j][k] = 1;
memo[j][k] = max(memo[j][k], memo[j - 1][k - kek[i]] + arr[i]);
}
}
}
}
int ans1, ans2 = 1000000000;
for (int i = 1; i <= n; ++i) {
bool done = 0;
for (int j = total; j <= 100 * n; ++j) {
if (vis[i][j]) {
done = 1;
ans1 = i;
ans2 = min(ans2, total - memo[i][j]);
}
}
if (done) break;
}
cout << ans1 << ' ' << ans2 << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 105;
int n, sum = 0;
int rem[MAXN], cap[MAXN];
map<int, int> dp[MAXN][MAXN];
int getnbot() {
int tmp[MAXN], tot = sum;
for (int i = 1; i <= n; i++) tmp[i] = cap[i];
sort(tmp + 1, tmp + n + 1);
for (int i = n; i >= 1; i--) {
if (tot <= tmp[i]) return n - i + 1;
tot -= tmp[i];
}
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> rem[i];
sum += rem[i];
}
for (int i = 1; i <= n; i++) cin >> cap[i];
int nbot = getnbot();
map<int, int>::iterator it;
dp[0][0].insert(make_pair(0, 0));
for (int i = 0; i < n; i++) {
for (int j = 0; j <= nbot; j++) {
for (it = dp[i][j].begin(); it != dp[i][j].end(); it++) {
if (j < nbot) {
int nk = it->first + cap[i + 1] - rem[i + 1];
if (dp[i + 1][j + 1].find(nk) == dp[i + 1][j + 1].end())
dp[i + 1][j + 1].insert(make_pair(nk, it->second));
else
dp[i + 1][j + 1][nk] = min(dp[i + 1][j + 1][nk], it->second);
}
int nk = it->first - rem[i + 1];
int nw = it->second + rem[i + 1];
if (dp[i + 1][j].find(nk) == dp[i + 1][j].end())
dp[i + 1][j].insert(make_pair(nk, nw));
else
dp[i + 1][j][nk] = min(dp[i + 1][j][nk], nw);
}
}
}
cout << nbot << ' ';
int ans = 0x3f3f3f3f;
for (it = dp[n][nbot].begin(); it != dp[n][nbot].end(); it++) {
if (it->first >= 0) ans = min(ans, it->second);
}
cout << ans << 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 / gcd(x, y) * y; }
int lowbit(int x) { return x & (-x); }
long long quickmod(long long x, long long y, long long mod) {
x = x % mod;
long long ans = 1;
while (y) {
if (y & 1) ans = ans * x % mod;
y >>= 1;
x = x * x % mod;
}
return ans;
}
const int INF = 0x3f3f3f3f;
const double EPS = 1e-7;
const double PI = acos(-1.0);
const long long MOD = 1e9 + 7;
int n;
int num1[105], num2[105];
int dp[2][105][20005];
int main() {
while (scanf("%d", &n) != EOF) {
memset(dp, -1, sizeof(dp));
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &num1[i]);
sum += num1[i];
}
for (int i = 1; i <= n; i++) scanf("%d", &num2[i]);
dp[0][0][0] = 0;
int flag = 0;
for (int i = 1; i <= n; i++) {
flag ^= 1;
for (int j = 0; j <= i; j++) {
for (int k = 0; k <= 20000; k++) {
dp[flag][j][k] = dp[flag ^ 1][j][k];
if (j >= 1 && k >= num2[i] && dp[flag ^ 1][j - 1][k - num2[i]] != -1)
dp[flag][j][k] =
max(dp[flag][j][k], dp[flag ^ 1][j - 1][k - num2[i]] + num1[i]);
}
}
}
int ans1 = -1, ans2 = 0;
for (int j = 1; j <= n; j++) {
ans2 = 0;
for (int k = 20000; k >= sum; k--) {
if (dp[flag][j][k] != -1) {
ans1 = j;
ans2 = max(ans2, dp[flag][j][k]);
}
}
if (ans1 != -1) break;
}
printf("%d %d\n", ans1, sum - ans2);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[110];
int s[110];
int b[110];
int dp[110][110 * 110];
int main() {
int n;
scanf(" %d", &n);
int total = 0;
for (int i = 0; i < n; i++) {
scanf(" %d", &a[i]);
total += a[i];
}
for (int i = 0; i < n; i++) {
scanf(" %d", &b[i]);
s[i] = b[i];
}
sort(s, s + n, greater<int>());
int ng = 0, sm = 0;
while (sm < total) {
sm += s[ng];
ng++;
}
for (int i = 0; i < n; i++) {
for (int j = ng - 1; j > 0; j--) {
for (int k = 110 * 110 - b[i] - 1; k >= 0; k--) {
if (dp[j][k] > 0) {
dp[j + 1][k + b[i]] = max(dp[j + 1][k + b[i]], dp[j][k] + a[i]);
}
}
}
dp[1][b[i]] = max(dp[1][b[i]], a[i]);
}
int res = -1;
for (int i = total; i < 110 * 110; i++) {
res = max(res, dp[ng][i]);
}
printf("%d %d\n", ng, total - res);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, z, p, i, j, k, ans, t, a[105], b[105], d[105], f[105][10005];
bool cmp(int x, int y) { return x > y; }
int main() {
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]), z += a[i];
for (i = 1; i <= n; i++) scanf("%d", &b[i]), d[i] = b[i];
sort(d + 1, d + n + 1, cmp);
memset(f, 0x80, sizeof(f));
f[0][0] = 0;
for (i = 1; i <= n; i++) {
p += d[i];
if (p >= z) {
ans = i;
break;
}
}
for (i = 1; i <= n; i++)
for (j = p; j >= b[i]; j--)
for (k = 1; k <= ans; k++)
f[k][j] = max(f[k][j], f[k - 1][j - b[i]] + a[i]);
for (i = z; i <= p; i++) t = max(t, f[ans][i]);
printf("%d %d", ans, z - t);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool cmp(pair<long long, long long> p1, pair<long long, long long> p2) {
return (p1.second > p2.second);
}
long long solve(vector<vector<long long> >& dp,
vector<pair<long long, long long> >& v, long long idx,
long long cap, long long k, long long n) {
if (k == 0 && cap == 0) return 0;
if (k == 0 || cap == 0) return -1e11;
if (dp[k][cap] != -1e7) return dp[k][cap];
if (v[idx].second <= cap) {
dp[k][cap] =
max(solve(dp, v, idx + 1, cap - v[idx].second, k - 1, n) + v[idx].first,
dp[k][cap]);
return dp[k][cap];
} else {
return solve(dp, v, idx + 1, cap, k, n);
}
return 0;
}
void print(vector<vector<long long> >& tp,
vector<pair<long long, long long> >& v, long long taken,
long long cap, long long n, long long ans) {
vector<long long> mark(n);
while (cap > 0) {
for (long long i = 0; i < n; i++) {
if (mark[i] == 0 && cap >= v[i].second &&
tp[taken - 1][cap - v[i].second] == (ans - v[i].first)) {
cout << i << " ";
mark[i] = 1;
cap -= v[i].second;
taken--;
ans -= v[i].first;
}
}
}
cout << endl;
return;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<pair<long long, long long> > v(n);
long long tw = 0, ts = 0;
for (long long i = 0; i < n; i++) {
cin >> v[i].first;
tw += v[i].first;
}
for (long long i = 0; i < n; i++) {
cin >> v[i].second;
ts += v[i].second;
}
sort(v.begin(), v.end(), cmp);
long long tmp = 0, k = 0;
for (long long i = 0; i < n; i++) {
tmp += v[i].second;
if (tmp >= tw) {
k = i + 1;
break;
}
}
vector<vector<long long> > tp(k + 1, vector<long long>(10005, -1));
tp[0][0] = 0;
for (long long i = 0; i < n; i++) {
vector<vector<long long> > dp = tp;
for (long long taken = 1; taken <= k; taken++) {
for (long long cap = v[i].second; cap <= 10000; cap++) {
if (tp[taken - 1][cap - v[i].second] >= 0) {
dp[taken][cap] = max(tp[taken - 1][cap - v[i].second] + v[i].first,
tp[taken][cap]);
}
}
}
tp = dp;
}
long long ans = 0, idx = 0;
for (long long i = tw; i <= 10000; i++) {
ans = max(ans, tp[k][i]);
}
cout << k << " " << (tw - ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 100 + 100;
struct node {
int w, v;
bool operator<(const node &b) const {
if (v != b.v)
return v > b.v;
else
return w > b.w;
}
} a[maxn];
int dp[maxn][10005];
int main() {
int n;
scanf("%d", &n);
long long sum = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i].w);
sum += a[i].w;
}
for (int i = 1; i <= n; ++i) scanf("%d", &a[i].v);
int cnt = 0;
int total = 0;
sort(a + 1, a + n + 1);
for (int i = 1; i <= n; ++i) {
total += a[i].v;
if (total >= sum) {
cnt = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = sum; j - a[i].w >= 0; j--) {
for (int k = i; k >= 1; --k) {
if (dp[k - 1][j - a[i].w] != -1)
dp[k][j] = max(dp[k][j], dp[k - 1][j - a[i].w] + a[i].v);
}
}
}
int ans = 0;
for (int i = sum; i > 0; --i) {
if (dp[cnt][i] >= sum) {
ans = sum - i;
break;
}
}
printf("%d %d\n", cnt, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[110][10010], n, s1, s2, ans, num, x;
struct node {
int l, r;
} f[10010];
int cmp(node a, node b) {
if (a.r != b.r)
return a.r > b.r;
else
return a.l > b.l;
}
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i].l);
s1 += f[i].l;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &f[i].r);
s2 += f[i].r;
}
x = s1;
sort(f + 1, f + 1 + n, cmp);
while ("Chtholly") {
x -= f[++num].r;
if (x <= 0) break;
}
memset(dp, -0x7f, sizeof dp);
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = s2; j >= f[i].r; j--)
for (int k = 1; k <= num; k++)
dp[k][j] = max(dp[k][j], dp[k - 1][j - f[i].r] + f[i].l);
for (int i = s1; i <= s2; i++) ans = max(ans, dp[num][i]);
cout << num << " " << s1 - ans;
}
|
#include <bits/stdc++.h>
using namespace std;
struct BO {
int a, b;
} a[300];
int n, tot, mt, tt;
int f[110][11000];
int cmp(const BO &x, const BO &y) { return x.b < y.b; }
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i].a;
tot += a[i].a;
}
for (int i = 1; i <= n; i++) {
cin >> a[i].b;
mt += a[i].b;
}
sort(a + 1, a + n + 1, cmp);
int K = 0;
tt = tot;
for (int i = n; i >= 1 && tot > 0; i--) {
K++;
tot -= a[i].b;
}
int ans = 0;
memset(f, -127 / 3, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = K; j >= 1; j--)
for (int k = mt; k >= a[i].b; k--)
f[j][k] = max(f[j][k], f[j - 1][k - a[i].b] + a[i].a);
}
for (int k = tt; k <= mt; k++) ans = max(ans, f[K][k]);
cout << K << ' ' << tt - ans << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
struct node {
int a, b;
} bo[111];
bool cmp(node& x, node& y) {
if (x.b == y.b) return x.a < y.a;
return x.b > y.b;
}
int n, sum, num, s, dp[111][11111];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &bo[i].a);
sum += bo[i].a;
}
for (int i = 1; i <= n; i++) {
scanf("%d", &bo[i].b);
}
sort(bo + 1, bo + n + 1, cmp);
for (int i = 1; i <= n; i++) {
s += bo[i].b;
if (s >= sum) {
num = i;
break;
}
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = sum; j >= bo[i].a; j--) {
for (int k = i - 1; k >= 0; k--) {
if (dp[k][j - bo[i].a] != -1)
dp[k + 1][j] = max(dp[k + 1][j], dp[k][j - bo[i].a] + bo[i].b);
}
}
}
int ans = sum;
for (int i = sum; i >= 0; i--) {
if (dp[num][i] >= sum) {
ans -= i;
break;
}
}
printf("%d %d\n", num, ans);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,unroll-loops")
using namespace std;
const int N = 102;
const int oo = 1e9;
const int Mod = 1e9 + 7;
int dp[2][N][N * N];
int a[N], b[N];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
for (int i = (int)(0); i < (int)(2); ++i)
for (int j = (int)(0); j < (int)(102); ++j)
for (int k = (int)(0); k < (int)(10002); ++k) dp[i][j][k] = -oo;
dp[0][0][0] = 0;
int n;
cin >> n;
vector<int> caps;
int vtot = 0, ctot = 0;
for (int i = (int)(1); i < (int)(n + 1); ++i) cin >> a[i], vtot += a[i];
for (int i = (int)(1); i < (int)(n + 1); ++i)
cin >> b[i], caps.push_back(b[i]), ctot += b[i];
sort(caps.begin(), caps.end(), greater<int>());
int k = 0, acc = 0;
while (acc < vtot) acc += caps[k++];
for (int i = 1; i <= n; ++i) {
int idx = i % 2;
for (int j = 0; j <= k; ++j) {
for (int c = 0; c <= ctot; ++c) {
if (j >= 1 and c - b[i] >= 0)
dp[idx][j][c] =
max(dp[idx][j][c], dp[idx ^ 1][j - 1][c - b[i]] + a[i]);
dp[idx][j][c] = max(dp[idx][j][c], dp[idx ^ 1][j][c]);
}
}
}
int idx = n % 2;
int high = 0;
for (int c = vtot; c <= ctot; ++c) {
int soda = dp[idx][k][c];
high = max(soda, high);
}
cout << k << " " << vtot - high << '\n';
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int k, n, m, sum, cur;
pair<int, int> a[110];
int f[110][10010], mn[110][10010];
bool Cmp(pair<int, int> a, pair<int, int> b) {
return a.second > b.second || (a.second == b.second && a.first > b.first);
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i].first), sum += a[i].first;
for (int i = 1; i <= n; i++) scanf("%d", &a[i].second);
for (int i = 1; i <= n; i++) {
for (int j = 0; j < i; j++)
for (int k = 0; k < sum; k++)
if (!k || mn[j][k]) {
int t = mn[j][k] + 1;
if (!mn[i][k + a[i].second] || t < mn[i][k + a[i].second] ||
(t == mn[i][k + a[i].second] &&
f[j][k] + a[i].first > f[i][k + a[i].second]))
mn[i][k + a[i].second] = t,
f[i][k + a[i].second] = f[j][k] + a[i].first;
}
}
int Mn = n + 1, Mx = 0;
for (int i = 1; i <= n; i++)
for (int j = sum; j <= 10000; j++)
if (mn[i][j] && mn[i][j] < Mn || (mn[i][j] == Mn && f[i][j] > Mx))
Mn = mn[i][j], Mx = f[i][j];
printf("%d %d\n", Mn, sum - Mx);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 0x7f7f7f7f;
long long n, m, a[105], b[105];
long long ans1 = INF, ans2 = INF;
long long f[10005], g[10005];
signed main() {
memset(f, INF, sizeof(f));
cin >> n;
for (long long i = 1; i <= n; cin >> a[i++])
;
for (long long i = 1; i <= n; cin >> b[i++])
;
for (long long i = 1; i <= n; i++) m += b[i];
f[0] = 0;
for (long long i = 1; i <= n; i++)
for (long long j = m; j >= b[i]; j--)
if (f[j - b[i]] + 1 < f[j])
f[j] = f[j - b[i]] + 1, g[j] = g[j - b[i]] + a[i];
else if (f[j - b[i]] + 1 == f[j] && g[j - b[i]] + a[i] > g[j])
g[j] = g[j - b[i]] + a[i];
long long sum = 0;
for (long long i = 1; i <= n; i++) sum += a[i];
for (long long i = sum; i <= m; i++)
if (f[i] < ans1)
ans1 = f[i], ans2 = g[i];
else if (f[i] == ans1 && g[i] > ans2)
ans2 = g[i];
cout << ans1 << ' ' << sum - ans2 << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[101], b[101], dp[101][101 * 101], inf = 1E9;
int main() {
int n, m, i, j, k;
pair<int, int> ans = make_pair(inf, inf);
scanf("%d", &n);
for (i = 1; i <= n; i++) scanf("%d", &a[i]);
for (i = 1; i <= n; i++) scanf("%d", &b[i]);
for (i = 0; i < 101; i++)
for (j = 0; j < 101 * 101; j++) dp[i][j] = -inf;
dp[0][0] = 0;
for (k = 1, m = 0; k <= n; k++) {
b[k] -= a[k];
m += a[k];
for (i = k; i > 0; i--)
for (j = m; j >= a[k]; j--)
dp[i][j] = max(dp[i][j], dp[i - 1][j - a[k]] + b[k]);
}
for (i = 1; i <= n; i++)
for (j = 1; j <= m; j++)
if (j + dp[i][j] >= m) ans = min(ans, make_pair(i, m - j));
printf("%d %d\n", ans.first, ans.second);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n;
int a[105], b[105], sum;
int f[105][105 * 105], g[105][105 * 105];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
for (int i = 1; i <= n; i++) scanf("%d", &b[i]);
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++) {
sum += a[i];
for (int j = 0; j < 105 * 105; j++) {
f[i][j] = f[i - 1][j];
g[i][j] = g[i - 1][j];
if (j - b[i] >= 0) {
if (f[i][j] > f[i - 1][j - b[i]] + 1) {
f[i][j] = f[i - 1][j - b[i]] + 1;
g[i][j] = g[i - 1][j - b[i]] + a[i];
} else if (f[i][j] == f[i - 1][j - b[i]] + 1) {
g[i][j] = max(g[i][j], g[i - 1][j - b[i]] + a[i]);
}
}
}
}
int x = 1e9, y = 0;
for (int i = sum; i < 105 * 105; i++) {
if (f[n][i] < x) {
x = f[n][i], y = g[n][i];
} else if (f[n][i] == x) {
y = max(y, g[n][i]);
}
}
printf("%d %d", x, sum - y);
}
|
#include <bits/stdc++.h>
const int maxn = 110;
using namespace std;
struct bott {
int wt;
int bt;
} pp[maxn];
int cc[maxn];
bool cmp(bott a, bott b) { return a.bt > b.bt; }
int dp[maxn][10005];
int ans, n, wts, bts, mini, totb;
int main() {
scanf("%d", &n);
wts = 0, bts = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &pp[i].wt);
wts += pp[i].wt;
}
for (int i = 1; i <= n; ++i) {
scanf("%d", &pp[i].bt);
bts += pp[i].bt;
cc[i] = pp[i].bt;
}
sort(cc + 1, cc + 1 + n);
int temp = 0;
for (int i = 1; i <= n && temp < wts; ++i) {
temp += cc[n - i + 1];
mini++;
}
memset(dp, -1, sizeof(dp));
dp[0][0] = 0, ans = wts;
for (int i = 1; i <= n; ++i)
for (int j = bts; j >= pp[i].bt; --j)
for (int l = mini; l; l--)
if (dp[l - 1][j - pp[i].bt] >= 0)
dp[l][j] = max(dp[l][j], dp[l - 1][j - pp[i].bt] + pp[i].wt);
for (int j = bts; j >= wts; --j) ans = min(ans, wts - dp[mini][j]);
printf("%d %d\n", mini, ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int N, K;
struct Bott {
int a, b;
} p[105];
bool cmp(Bott x, Bott y) {
if (x.b == y.b) return x.a < y.a;
return x.b < y.b;
}
int s[105];
int f[2][105][20000 + 10];
int Ans = 0x3f3f3f3f;
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) scanf("%d", &p[i].a);
for (int i = 1; i <= N; i++) scanf("%d", &p[i].b);
sort(p + 1, p + 1 + N, cmp);
for (int i = 1; i <= N; i++) {
s[i] = s[i - 1] + p[i].a;
p[i].b -= p[i].a;
}
for (int i = N, sum = 0; i >= 1; i--) {
sum += p[i].b;
if (sum >= s[i - 1]) {
K = N - i + 1;
break;
}
}
memset(f, 0x3f, sizeof(f));
f[0][0][10000] = 0;
int S1 = 10000, S2 = 10000;
for (int i = 1; i <= N; i++) {
for (int j = 0; j <= i; j++)
for (int k = S1; k <= S2; k++) {
f[i & 1][j + 1][k + p[i].b] =
min(f[i & 1][j + 1][k + p[i].b], f[(i - 1) & 1][j][k]);
f[i & 1][j][k - p[i].a] =
min(f[i & 1][j][k - p[i].a], f[(i - 1) & 1][j][k] + p[i].a);
f[(i - 1) & 1][j][k] = 0x3f3f3f3f;
}
S1 -= p[i].a;
S2 += p[i].b;
}
for (int i = 10000; i <= S2; i++) Ans = min(Ans, f[N & 1][K][i]);
printf("%d %d", K, Ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int dp[2][105][105 * 105];
int n;
int a[105], b[105];
void solve() {
int v = 0, soda = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
soda += a[i];
}
for (int i = 1; i <= n; i++) {
scanf("%d", &b[i]);
v += b[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= v; j++) dp[0][i][j] = dp[1][i][j] = -1e9;
}
int ans1 = 1e9, ans2 = 1e9;
dp[0][0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= n; j++) {
for (int k = 0; k <= v; k++) dp[i & 1][j][k] = -1e9;
}
dp[i & 1][0][0] = 0;
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= v; k++) {
if (k >= b[i])
dp[i & 1][j][k] =
max(dp[i & 1][j][k], dp[(i + 1) & 1][j - 1][k - b[i]] + a[i]);
dp[i & 1][j][k] = max(dp[i & 1][j][k], dp[(i + 1) & 1][j][k]);
}
}
for (int j = 1; j <= n; j++) {
for (int k = 0; k <= v; k++) {
if (dp[i & 1][j][k] < 0) continue;
if (k < soda) continue;
if (j < ans1 || (j == ans1 && dp[i & 1][j][k] > ans2)) {
ans1 = j;
ans2 = dp[i & 1][j][k];
}
}
}
}
printf("%d %d\n", ans1, soda - ans2);
}
int main() {
while (scanf("%d", &n) != EOF) solve();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
bool comp(const pair<int, int>& a, const pair<int, int>& b) {
if (a.second != b.second) {
return a.second > b.second;
}
return false;
}
const int inf = 1e9;
int main() {
int n;
cin >> n;
vector<pair<int, int> > v(n);
int x = 0;
for (int i = 0; i < n; ++i) {
cin >> v[i].first;
x += v[i].first;
}
for (int i = 0; i < n; ++i) {
cin >> v[i].second;
}
sort((v).begin(), (v).end(), comp);
int k = 0;
while (x > 0) {
x -= v[k].second;
++k;
}
x = 0;
for (int i = 0; i < n; ++i) {
x += v[i].first;
}
cout << k << " ";
vector<vector<int> > dp(x + 1, vector<int>(k + 1, -inf));
dp[0][0] = 0;
for (int i = 0; i < n; ++i) {
vector<vector<int> > dp_new = dp;
for (int sum = 0; sum <= x; ++sum) {
for (int taken = 0; taken <= k; ++taken) {
int new_sum = min(x, sum + v[i].second);
if (taken + 1 <= k) {
dp_new[new_sum][taken + 1] =
max(dp_new[new_sum][taken + 1], dp[sum][taken] + v[i].first);
}
}
}
dp.swap(dp_new);
}
cout << x - dp[x][k] << "\n";
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.