solution
stringlengths 11
983k
| difficulty
int64 0
21
| language
stringclasses 2
values |
|---|---|---|
#include <bits/stdc++.h>
using namespace std;
const int MAX = 300100, MAXK = 105, INF = 0x3f3f3f3f;
int dp[MAX][MAXK];
int p[MAX], n;
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &p[i]);
memset(dp, INF, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
int st = p[i] / 1000;
for (int j = 0; j < MAXK - 2; j++) {
dp[i + 1][j + st] = min(dp[i + 1][j + st], dp[i][j] + 10 * st);
dp[i + 1][max(0, j - 10 * st)] =
min(dp[i + 1][max(0, j - 10 * st)], dp[i][j] + max(0, 10 * st - j));
}
}
int rje = INF;
for (int i = 0; i < MAXK; i++) rje = min(rje, dp[n][i]);
cout << (long long)rje * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 9;
const int INF = 1e9 + 7;
int a[N], dp[2][49];
inline int read() {
int s = 1, a = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') s = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
a = a * 10 + ch - '0';
ch = getchar();
}
return s * a;
}
int main() {
int n = read();
for (int i = 1; i <= n; i++) a[i] = read() / 100;
for (int i = 1; i <= 30; i++) dp[0][i] = INF;
for (int i = 1, b = 1; i <= n; i++, b ^= 1) {
for (int j = 0; j <= 30; j++) dp[b][j] = INF;
for (int j = 0; j <= 30; j++) {
dp[b][j + a[i] / 10] = min(dp[b][j + a[i] / 10], dp[b ^ 1][j] + a[i]);
dp[b][j - a[i] + max(a[i] - j, 0)] = min(
dp[b][j - a[i] + max(a[i] - j, 0)], dp[b ^ 1][j] + max(a[i] - j, 0));
}
}
int res = INF;
for (int i = 0; i <= 30; i++) res = min(res, dp[n % 2][i]);
return 0 * printf("%d00\n", res);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class T>
bool umin(T& a, T b) {
if (a > b) {
a = b;
return 1;
}
return 0;
}
template <class T>
bool umax(T& a, T b) {
if (a < b) {
a = b;
return 1;
}
return 0;
}
int dp[300009][205];
int arr[300009];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", arr + i);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 203; j++) dp[i][j] = 1000000007;
dp[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 200; j++)
umin(dp[i][j + arr[i] / 1000], dp[i - 1][j] + arr[i]),
umin(dp[i][j - min(j, arr[i] / 100)],
dp[i - 1][j] + arr[i] - 100 * min(j, arr[i] / 100));
int ans = 1000000007;
for (int i = 0; i <= 200; i++) umin(ans, dp[n][i]);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 10;
int a[N], n, f[N][35];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 31; j++) {
if (a[i + 1] / 1000 + j <= 31)
f[i + 1][j + a[i + 1] / 1000] =
min(f[i + 1][j + a[i + 1] / 1000], f[i][j] + a[i + 1]);
if (j >= a[i + 1] / 100)
f[i + 1][j - a[i + 1] / 100] =
min(f[i + 1][j - a[i + 1] / 100], f[i][j]);
else
f[i + 1][0] = min(f[i + 1][0], f[i][j] + a[i + 1] - j * 100);
}
}
int ans = 2e9;
for (int i = 0; i <= 31; i++) ans = min(ans, f[n][i]);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 3e5 + 10;
using namespace std;
int n, A[N];
int dp[2][35];
int main() {
memset(dp, 0x3f, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
A[i] /= 100;
}
int s = 0, t = 1;
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int a = A[i] / 10;
for (int j = 0; j <= 31; ++j)
if (dp[s][j] < dp[0][32]) {
if (j + a <= 31) dp[t][j + a] = min(dp[t][j + a], dp[s][j] + A[i]);
int b = min(j, A[i]);
if (b) dp[t][j - b] = min(dp[t][j - b], dp[s][j] + A[i] - b);
dp[s][j] = dp[0][32];
}
swap(s, t);
}
int ans = dp[0][32];
for (int i = 0; i < 20; ++i) ans = min(ans, dp[s][i]);
printf("%d00\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[300300];
int dp[300300][50];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) gn(a[i]);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 50; j++) {
if (a[i] == 1000) smin(dp[i][j], dp[i - 1][j - 1] + a[i]);
if (a[i] == 2000 && j > 1) smin(dp[i][j], dp[i - 1][j - 2] + a[i]);
}
for (int j = 1; j < 50; j++) {
for (int k = min(j, a[i] / 100); k >= 0; k--) {
smin(dp[i][j - k], dp[i - 1][j] + a[i] - 100 * k);
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 25; i++) smin(ans, dp[n][i]);
println(ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int lim = 45;
const int N = 300005;
const int INF = 1000000000;
using namespace std;
int n, a[N];
int f[2][lim];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
int now = 0;
f[now][0] = 0;
for (int j = 1; j <= 40; ++j) f[now][j] = INF;
for (int i = 0; i < n; ++i) {
now ^= 1;
for (int j = 0; j <= 40; ++j) f[now][j] = INF;
for (int j = 0; j <= 40; ++j) {
if (j + a[i + 1] / 1000 <= 40)
f[now][j + a[i + 1] / 1000] =
min(f[now][j + a[i + 1] / 1000], f[now ^ 1][j] + a[i + 1]);
f[now][max(0, j - a[i + 1] / 100)] =
min(f[now][max(0, j - a[i + 1] / 100)],
f[now ^ 1][j] + max(a[i + 1] - j * 100, 0));
}
}
int res = INF;
for (int j = 0; j <= 40; ++j) res = min(res, f[now][j]);
printf("%d\n", res);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int B = 100;
int n, x;
int f[B + 1], g[B + 1];
int main() {
scanf("%d", &n);
memset(f, 127, sizeof(f));
f[0] = 0;
for (int i = 1; i <= n; ++i) {
scanf("%d", &x);
x /= 100;
memcpy(g, f, sizeof(g));
memset(f, 127, sizeof(f));
for (int j = 0; j <= B; ++j)
if (g[j] < 1e9) {
int p = min(j + x / 10, B);
f[p] = min(f[p], g[j] + x);
int t = min(x, j);
f[j - t] = min(f[j - t], g[j] + x - t);
}
}
int ans = 1e9;
for (int i = 0; i <= B; ++i) ans = min(ans, f[i]);
printf("%d\n", ans * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long min(long long a, long long b) {
if (a < b) {
return a;
}
return b;
}
long long max(long long a, long long b) {
if (a > b) {
return a;
}
return b;
}
signed main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long n;
cin >> n;
vector<vector<long long> > dp(n + 1, vector<long long>(31, 1e9));
dp[0][0] = 0;
for (long long i = 0; i < n; i++) {
long long a;
cin >> a;
for (long long j = 0; j <= 30; j++) {
dp[i + 1][min(30, j + a / 1000)] =
min(dp[i + 1][min(30, j + a / 1000)], dp[i][j] + a);
}
for (long long j = 0; j <= 30; j++) {
dp[i + 1][max(0, j - a / 100)] = min(
dp[i + 1][max(0, j - a / 100)], dp[i][j] + a - min(j, a / 100) * 100);
}
}
long long ans = 1e9;
for (long long i = 0; i <= 30; i++) {
ans = min(ans, dp[n][i]);
}
cout << ans;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 300100;
long long n;
long long a[maxn];
long long p[maxn];
long long prv[maxn];
long long nex[maxn];
bool check(long long x) {
if (p[n] - x > x / 1000 * 100) return false;
long long i = lower_bound(p, p + n + 1, x) - p - 1;
long long A = x - p[i];
long long B = a[i] - A;
if (p[i + 1] == x or p[n] - p[i + 1] <= p[i] / 10 - B) return true;
if (a[i] == 2000 and A >= 1000) {
long long j = prv[i];
if (~j and B <= p[j] / 10) return true;
j = nex[i];
if (~j and j != n - 1) return true;
}
return false;
}
int32_t main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (long long i = 0; i < n; i++) cin >> a[i];
for (long long i = 0; i < n; i++) p[i + 1] = p[i] + a[i];
for (long long prv = -1, i = 0; i < n; ::prv[i++] = prv)
if (a[i] == 1000) prv = i;
for (long long nex = -1, i = n - 1; ~i; ::nex[i--] = nex)
if (a[i] == 1000) nex = i;
long long l = 0, r = p[n], mid;
while (l != r - 1) {
mid = (l + r) / 2;
check(mid) ? r = mid : l = mid;
}
cout << r << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[300010], res[300010][55];
int dp(int id, int cs) {
if (id == n) return 0;
if (res[id][cs] != -1) return res[id][cs];
int tk = min(cs, a[id]);
int w = a[id] - tk + dp(id + 1, cs - tk);
if (cs < 50) w = min(w, a[id] + dp(id + 1, cs + a[id] / 10));
return res[id][cs] = w;
}
int main() {
memset(res, -1, sizeof(res));
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] /= 100;
}
printf("%d00\n", dp(0, 0));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long a[400010];
int main() {
long long n;
cin >> n;
long long sum = 0, count = 0;
for (long long i = 0; i < n; i++) {
scanf("%lld", &a[i]);
sum += (a[i] / 1000);
if (a[i] == 1000) count++;
}
long long tmp;
if (sum <= 11)
tmp = sum - a[n - 1] / 1000;
else
tmp = 10 * sum / 11;
if (count == 0) {
if (tmp % 2 == 1) tmp--;
}
printf("%lld\n", 1ll * 1000 * sum - 1ll * tmp * 100);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 3e5 + 5, N2 = 100, inf = 1e18;
long long int ary[N];
long long int dp[N][N2 + 1];
long long int solve(long long int i, long long int b, long long int n) {
if (i == n) {
return 0;
}
if (dp[i][b] == -1) {
dp[i][b] = inf;
if (b + ary[i] / 10 > N2) {
dp[i][b] = solve(i + 1, b - ary[i], n);
} else {
dp[i][b] = ary[i] + solve(i + 1, b + ary[i] / 10, n);
if (b >= ary[i])
dp[i][b] = min(dp[i][b], solve(i + 1, b - ary[i], n));
else
dp[i][b] = min(dp[i][b], solve(i + 1, 0, n) + ary[i] - b);
}
}
return dp[i][b];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 0; i < n; ++i) {
cin >> ary[i];
ary[i] /= 100;
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, n) * 100 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:16777216")
using namespace std;
const int INF = 1e9;
vector<unordered_map<int, int> > fw;
int n, q;
int main() {
iostream::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> dp[2];
const int MX = 500 + 1;
for (int i = 0; i < 2; i++) dp[i].resize(MX, 1e9);
dp[0][0] = 0;
int p = 1;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
x /= 100;
int a = x / 10;
for (int j = 0; j < MX; j++) {
if (j + x / 10 < MX) {
dp[p][j + a] = min(dp[p][j + a], dp[p ^ 1][j] + x);
}
if (j <= x)
dp[p][0] = min(dp[p][0], dp[p ^ 1][j] + x - j);
else
dp[p][j - x] = min(dp[p][j - x], dp[p ^ 1][j] + 0);
}
p ^= 1;
for (int i = 0; i < MX; i++) dp[p][i] = 1e9;
}
int ans = 1e9;
for (int i : dp[p ^ 1]) ans = min(ans, i);
cout << ans * 100;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = (int)1e9;
const int mod = inf + 7;
const double eps = 1e-9;
const double pi = acos(-1.0);
int n, a[300300];
int dp[33][300300];
int calc(int bon, int ind) {
if (ind == n) return 0;
int &res = dp[bon][ind];
if (res != -1) return res;
res = a[ind] + calc(min(bon + a[ind] / 10, 31), ind + 1);
for (int i = 1; i <= bon && i <= a[ind]; i++) {
res = min(res, a[ind] - i + calc(bon - i, ind + 1));
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
a[i] /= 100;
}
memset(dp, -1, sizeof dp);
printf("%d\n", calc(0, 0) * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void read(int &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void read(long long &x) {
char ch;
bool flag = false;
for (ch = getchar(); !isdigit(ch); ch = getchar())
if (ch == '-') flag = true;
for (x = 0; isdigit(ch); x = x * 10 + ch - '0', ch = getchar())
;
x = flag ? -x : x;
}
inline void write(int x) {
static const int maxlen = 100;
static char s[maxlen];
if (x < 0) {
putchar('-');
x = -x;
}
if (!x) {
putchar('0');
return;
}
int len = 0;
for (; x; x /= 10) s[len++] = x % 10 + '0';
for (int i = len - 1; i >= 0; --i) putchar(s[i]);
}
const int MAXN = 410000;
int a[MAXN];
int n;
int main() {
read(n);
int sum = 0;
int ans = 0;
int tot = 0;
for (int i = 1; i <= n; i++) {
read(a[i]);
sum += a[i] / 1000;
if (a[i] == 1000) tot++;
}
int tmp = 10 * sum / 11;
if (sum <= 11) tmp = sum - a[n] / 1000;
if ((!tot) && (tmp % 2 == 1)) tmp--;
printf("%d\n", sum * 1000 - tmp * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MaxN = 3e5 + 35;
const int INF = 1e9;
int a[MaxN];
int dp[MaxN][51];
inline void up(int& x, int y) {
if (x > y) x = y;
}
int n;
int main() {
ios_base ::sync_with_stdio(false);
cin.tie(NULL);
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> a[i];
a[i] /= 100;
}
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= 50; ++j) dp[i][j] = INF;
dp[0][0] = 0;
for (int i = 1; i <= n; ++i)
for (int p = 0; p <= 50; ++p)
if (dp[i - 1][p] != INF) {
if (p + a[i] / 10 <= 50) up(dp[i][p + a[i] / 10], dp[i - 1][p] + a[i]);
int mx = min(a[i], p);
for (int k = 1; k <= mx; ++k) up(dp[i][p - k], dp[i - 1][p] + a[i] - k);
}
int ans = INF;
for (int i = 0; i <= 50; ++i) ans = min(ans, dp[n][i]);
cout << ans << "00" << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int read() {
char c = getchar();
int d = 0, f = 1;
for (; c < '0' || c > '9'; c = getchar())
if (c == '-') f = -1;
for (; c >= '0' && c <= '9'; d = d * 10 + c - 48, c = getchar())
;
return d * f;
}
const int N = 300010;
int n;
long long a[N], s[N], la[N], nx[N];
int main() {
n = read();
for (int i = 1; i <= n; ++i) a[i] = read();
for (int i = 1; i <= n; ++i) s[i] = s[i - 1] + a[i];
long long ans = 1e18;
for (int i = 0; i <= n; ++i)
ans = min(ans, s[i] + max(0LL, s[n] - s[i] - s[i] / 10));
for (int i = 1; i <= n; ++i) {
la[i] = la[i - 1];
if (a[i] == 1000) la[i] = i;
}
nx[n] = n + 1;
for (int i = n - 1; i >= 0; --i) {
nx[i] = nx[i + 1];
if (a[i] == 1000) nx[i] = i;
}
for (int i = 1; i <= n; ++i) {
int u = la[i];
if (a[u] == 1000 && u < i) {
long long res = s[u - 1], ss = s[u - 1] / 10;
res += max(0LL, a[u] - ss);
ss -= min(ss, a[u]);
res += s[i] - s[u];
ss += (s[i] - s[u]) / 10;
res += max(0LL, s[n] - s[i] - ss);
ans = min(ans, res);
}
}
for (int i = 0; i <= n - 1; ++i) {
int u = nx[i];
if (a[u] == 1000 && u > i + 1) {
long long res = s[i], ss = s[i] / 10;
res += max(0LL, s[u - 1] - s[i] - ss);
ss -= min(ss, s[u - 1] - s[i]);
res += a[u];
ss += a[u] / 10;
res += max(0LL, s[n] - s[u] - ss);
ans = min(ans, res);
}
}
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
vector<int> v1;
vector<int> v2;
int rest[300002 * 4];
int need[300002 * 4];
int ar[300002];
inline void init(int b, int l, int r) {
if (l + 1 == r) {
need[b] = ar[l];
return;
}
init(b * 2 + 1, l, (l + r) >> 1);
init(b * 2 + 2, (l + r) >> 1, r);
need[b] = need[b * 2 + 1] + need[b * 2 + 2];
}
int sum;
inline void add(int b, int l, int r, int ll, bool flag) {
if (r <= ll || ll < l) {
return;
}
if (l + 1 == r) {
if (flag) {
sum += ar[l] / 10;
rest[b] = ar[l] / 10;
need[b] = 0;
} else {
sum -= ar[l] / 10;
need[b] = ar[l];
rest[b] = 0;
}
return;
}
if (((l + r) >> 1) > ll) {
add(b * 2 + 1, l, (l + r) >> 1, ll, flag);
} else {
add(b * 2 + 2, (l + r) >> 1, r, ll, flag);
}
int dc = min(need[b * 2 + 2], rest[b * 2 + 1]);
need[b] = need[b * 2 + 2] + need[b * 2 + 1] - dc;
rest[b] = rest[b * 2 + 2] + rest[b * 2 + 1] - dc;
}
int main() {
cin >> n;
for (int i = 0; i < n; i++) {
int a;
scanf("%d", &a);
if (a == 1000) {
v1.push_back(i);
} else {
v2.push_back(i);
}
ar[i] = a / 100;
}
init(0, 0, n);
int lef = -1;
int maxi = 0;
for (int i = 0; i < v2.size(); i++) {
int be = sum - rest[0];
add(0, 0, n, v2[i], true);
int go = sum - rest[0];
if (be > go) {
add(0, 0, n, v2[i], false);
break;
} else {
lef = i;
}
}
maxi = sum - rest[0];
for (int i = 0; i < v1.size(); i++) {
add(0, 0, n, v1[i], true);
while (lef >= 0) {
int be = sum - rest[0];
add(0, 0, n, v2[lef], false);
int go = sum - rest[0];
if (be <= go) {
lef--;
} else {
add(0, 0, n, v2[lef], true);
break;
}
}
maxi = max(maxi, (int)sum - rest[0]);
}
long long int ans = 0;
for (int i = 0; i < n; i++) {
ans += (long long int)(ar[i] * 100);
}
ans -= (long long int)(maxi)*100LL;
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 3e5 + 10;
void setmin(int &a, int b) {
if (a > b) {
a = b;
}
}
int N;
int A[MAXN];
int dp[MAXN][200];
int main() {
scanf("%d", &N);
for (int i = 1; i <= N; i++) {
scanf("%d", &A[i]);
}
memset(dp, 63, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
int x = A[i + 1];
for (int j = 0; j < 200; j++) {
int pdp = dp[i][j];
if (pdp > 1e9) {
continue;
}
int nj;
int bspend = min(j, x / 100);
nj = j - bspend;
setmin(dp[i + 1][nj], pdp + x - bspend * 100);
nj = j + x / 1000;
if (nj < 200) {
setmin(dp[i + 1][nj], pdp + x);
}
}
}
int ans = INT_MAX;
for (int j = 0; j < 200; j++) {
setmin(ans, dp[N][j]);
}
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read(register int ans = 0, register int sgn = ' ',
register int ch = getchar()) {
for (; ch < '0' || ch > '9'; sgn = ch, ch = getchar())
;
for (; ch >= '0' && ch <= '9'; (ans *= 10) += ch - '0', ch = getchar())
;
return sgn - '-' ? ans : -ans;
}
int a[300000 + 5], f[300000 + 5][31], n;
int main() {
n = read();
for (register int i = 1; i <= n; a[i++] = read())
;
memset(f, 0x3f, sizeof f), f[0][0] = 0;
for (register int i = 1, j; i <= n; i++)
for (j = 0; j <= 30; j++)
if (f[i - 1][j] < 0x3f3f3f3f) {
if (j + a[i] / 1000 <= 30)
f[i][j + a[i] / 1000] =
min(f[i][j + a[i] / 1000], f[i - 1][j] + a[i]);
if (j >= a[i] / 100)
f[i][j - a[i] / 100] = min(f[i][j - a[i] / 100], f[i - 1][j]);
else
f[i][0] = min(f[i][0], f[i - 1][j] + a[i] - j * 100);
}
printf("%d\n", f[n][0]);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXN = (1 << 19);
const int MAXV = (50);
const int inf = (int)2e9 + 42;
int n;
int a[MAXN];
void read() {
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] /= 100;
}
}
int dp[MAXV][2];
int add[MAXV];
void solve() {
add[10] = 1;
add[20] = 2;
dp[0][0] = 0;
for (int i = 1; i < MAXV; i++) dp[i][0] = inf;
int prv = 0, cur = 1;
for (int i = 1; i <= n; i++) {
for (int val = 0; val < MAXV; val++) dp[val][cur] = inf;
for (int val = 0; val < MAXV; val++) {
if (val + add[a[i]] < MAXV)
dp[val + add[a[i]]][cur] = dp[val][prv] + a[i];
for (int y = 1; y <= min(a[i], val); y++)
dp[val - y][cur] = min(dp[val - y][cur], dp[val][prv] + a[i] - y);
}
prv ^= 1;
cur ^= 1;
}
int answer = inf;
for (int i = 0; i < MAXV; i++) answer = min(answer, dp[i][n & 1]);
cout << answer * 100ll << '\n';
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
read();
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
int n;
const int N = 300100, MX = 100, inf = 1e9;
int a[N];
int dp[N][MX + 1];
int solve(int id, int j) {
if (id > n) return 0;
if (j >= MX) {
return solve(id + 1, j - a[id]);
}
int& x = dp[id][j];
if (x != -1) return x;
x = inf;
if (j > 0) {
int put = min(j, a[id]);
x = solve(id + 1, j - put) + a[id] - put;
}
return x = min(x, solve(id + 1, j + a[id] / 10) + a[id]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] /= 100;
}
cout << 100LL * solve(1, 0) << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using ll = long long;
using ld = long double;
using namespace std;
const int MAXN = 300001;
const int DV = 100;
const int INF = 1000 * 1000 * 1000;
int a[MAXN];
int s = 0;
int ans = INF;
int lft(int x) { return s - x - x / 10; }
void tr(int x) {
ans = min(ans, x + max(0, lft(x)));
if (x + (x / 10) < s) return;
}
bool py[MAXN];
int n;
bool isok() {
int cur = 0, cans = 0;
for (int i = 0; i < n; i++) {
if (py[i]) {
cur += a[i] / 10;
cans += a[i];
} else {
cur -= a[i];
if (cur < 0) {
cans -= cur, cur = 0;
}
}
}
ans = min(ans, cans);
return false;
return true;
}
int main() {
ios_base::sync_with_stdio(false);
cout.setf(ios::fixed);
cout.precision(20);
scanf("%d", &n);
memset(py, 0, sizeof(py));
for (int i = 0; i < n; i++) {
scanf("%d", a + i);
a[i] /= DV;
s += a[i];
}
int p = 0, cur = 0;
while (lft(cur) > 0) {
py[p] = true;
cur += a[p++];
}
p--;
tr(cur);
tr(cur - a[p]);
if (a[p] == 20) {
int p2 = p;
while ((p2 < n) && (a[p2] == 20)) p2++;
if (p2 != n) {
py[p] = false;
py[p2] = true;
if (isok()) tr(cur - 10);
py[p] = true;
py[p2] = false;
}
p2 = p;
while ((p2 >= 0) && a[p2] == 20) p2--;
if (p2 != -1) {
py[p2] = false;
if (isok()) tr(cur - 10);
}
}
cout << ans * 100 << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const long long int N = 3e5 + 5, N2 = 50, inf = 1e18;
long long int ary[N];
long long int dp[N][N2 + 1];
long long int solve(long long int i, long long int b, long long int n) {
if (i == n) {
return 0;
}
if (dp[i][b] == -1) {
dp[i][b] = inf;
if (b + ary[i] / 10 > N2) {
dp[i][b] = solve(i + 1, b - ary[i], n);
} else {
dp[i][b] = ary[i] + solve(i + 1, b + ary[i] / 10, n);
if (b >= ary[i])
dp[i][b] = min(dp[i][b], solve(i + 1, b - ary[i], n));
else
dp[i][b] = min(dp[i][b], solve(i + 1, 0, n) + ary[i] - b);
}
}
return dp[i][b];
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int n;
cin >> n;
for (long long int i = 0; i < n; ++i) {
cin >> ary[i];
ary[i] /= 100;
}
memset(dp, -1, sizeof(dp));
cout << solve(0, 0, n) * 100 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300000 + 10;
const int INF = 1e9 + 7;
const double EPS = 1e-8;
int n, a[N];
int dp[N][102];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] /= 100;
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 50; j++) dp[i][j] = INF;
dp[0][0] = 0;
int ret = INF;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 50; j++) {
dp[i][j] = INF;
if (j >= a[i] / 10)
dp[i][j] = min(dp[i - 1][j - a[i] / 10] + a[i], dp[i][j]);
for (int k = 1; k <= a[i]; k++)
if (j + k <= 50) dp[i][j] = min(dp[i - 1][j + k] + a[i] - k, dp[i][j]);
if (i == n) ret = min(ret, dp[i][j]);
}
}
printf("%lld\n", (long long)ret * 100L);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long int N = 1e9 + 7;
void solve() {
long long int n;
cin >> n;
vector<long long int> a(n + 1);
for (long long int i = 1; i <= n; i++) {
cin >> a[i];
}
vector<vector<long long int> > dp(n + 4, vector<long long int>(64, N));
dp[0][0] = 0;
for (long long int i = 1; i <= n; i++) {
for (long long int j = 0; j <= 30; j++) {
dp[i][j + a[i] / 1000] = min(dp[i][j + a[i] / 1000], dp[i - 1][j] + a[i]);
dp[i][j - min(j, a[i] / 100)] =
min(dp[i][j - min(j, a[i] / 100)],
dp[i - 1][j] + a[i] - 100 * min(j, a[i] / 100));
}
}
long long int ans = N;
for (long long int j = 0; j <= 30; j++) {
ans = min(ans, dp[n][j]);
}
cout << ans << endl;
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);
long long int t = 1;
while (t--) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, two, one, l, r, k, a[N], dp[N][31];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] /= 100;
}
memset(dp, 127, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 30; j++)
if (dp[i][j] <= 2e8) {
if (j + a[i + 1] / 10 <= 30)
dp[i + 1][j + a[i + 1] / 10] =
min(dp[i + 1][j + a[i + 1] / 10], dp[i][j] + a[i + 1]);
if (j >= a[i + 1])
dp[i + 1][j - a[i + 1]] = min(dp[i + 1][j - a[i + 1]], dp[i][j]);
else
dp[i + 1][0] = min(dp[i + 1][0], dp[i][j] + (a[i + 1] - j));
}
}
int ans = 2e9;
for (int i = 0; i <= 30; i++) {
ans = min(ans, dp[n][i]);
}
printf("%d00\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[300001], f[300001][55], ans = 2e9;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]);
memset(f, 60, sizeof f);
f[0][0] = 0;
for (int i = 0; i < n; i++)
for (int j = 0; j <= 50; j++) {
f[i + 1][j + a[i + 1] / 1000] =
min(f[i + 1][j + a[i + 1] / 1000], f[i][j] + a[i + 1]);
f[i + 1][j - min(j, a[i + 1] / 100)] =
min(f[i + 1][j - min(j, a[i + 1] / 100)],
f[i][j] + a[i + 1] - min(j, a[i + 1] / 100) * 100);
}
for (int j = 0; j <= 50; j++) ans = min(ans, f[n][j]);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[303030], sum, s[303030];
bool ok(int k) {
int x = k * 10, y = sum - k * 11, ans = x + y;
int xx = x, now = 1;
while (xx >= a[now]) {
xx -= a[now];
now++;
}
if (!xx) return 1;
for (int i = now; i <= n; i++)
if (a[i] == 10) {
if (y + s[now - 1] / 10 >= s[i - 1] - s[now - 1]) return 1;
break;
}
for (int i = now - 1; i >= 1; i--)
if (a[i] == 10) {
if (y + s[i - 1] / 10 >= 10) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] /= 100;
s[0] = 0;
for (int i = 1; i <= n; i++) s[i] = a[i] + s[i - 1];
if (n == 1) {
printf("%d00\n", a[1]);
return 0;
}
sum = s[n];
int k = sum / 11;
if (ok(k)) {
printf("%d00\n", sum - k);
return 0;
}
if (ok(k - 1)) {
printf("%d00\n", sum - k + 1);
return 0;
}
assert(0);
printf("%d00\n", sum - k + 2);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, a[N];
long long s[N];
int pre[3][N];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &a[i]);
s[i] = s[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) {
pre[1][i] = pre[1][i - 1];
pre[2][i] = pre[2][i - 1];
pre[a[i] / 1000][i] = i;
}
long long res = s[n];
for (int i = 1; i <= n; ++i) {
long long dis = s[i] / 10;
res = min(res, s[n] - min(dis, s[n] - s[i]));
int x = pre[1][i];
if (x) {
assert(a[x] == 1000);
long long sum = 0;
sum += s[x - 1];
dis = sum / 10;
long long d = min(dis, (long long)a[x]);
sum += a[x] - d;
dis -= d;
sum += s[i] - s[x];
dis += (s[i] - s[x]) / 10;
res = min(res, sum + s[n] - s[i] - min(dis, s[n] - s[i]));
for (int k = 1; k <= 2; ++k) {
int y = pre[k][x - 1];
if (y) {
long long sum = 0;
sum += s[y - 1];
dis = sum / 10;
long long d = min(dis, (long long)a[y]);
sum += a[y] - d;
dis -= d;
sum += s[x - 1] - s[y];
dis += (s[x - 1] - s[y]) / 10;
d = min(dis, (long long)a[x]);
sum += a[x] - d;
dis -= d;
sum += s[i] - s[x];
dis += (s[i] - s[x]) / 10;
res = min(res, sum + s[n] - s[i] - min(dis, s[n] - s[i]));
}
}
}
x = pre[2][i];
if (x) {
assert(a[x] == 2000);
long long sum = 0;
sum += s[x - 1];
dis = sum / 10;
long long d = min(dis, (long long)a[x]);
sum += a[x] - d;
dis -= d;
sum += s[i] - s[x];
dis += (s[i] - s[x]) / 10;
res = min(res, sum + s[n] - s[i] - min(dis, s[n] - s[i]));
for (int k = 1; k <= 2; ++k) {
int y = pre[k][x - 1];
if (y) {
long long sum = 0;
sum += s[y - 1];
dis = sum / 10;
long long d = min(dis, (long long)a[y]);
sum += a[y] - d;
dis -= d;
sum += s[x - 1] - s[y];
dis += (s[x - 1] - s[y]) / 10;
d = min(dis, (long long)a[x]);
sum += a[x] - d;
dis -= d;
sum += s[i] - s[x];
dis += (s[i] - s[x]) / 10;
res = min(res, sum + s[n] - s[i] - min(dis, s[n] - s[i]));
}
}
}
}
cout << res << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double pi = acos(-1.0);
const double eps = 1e-11;
template <class T>
T sqr(const T &x) {
return x * x;
}
template <class T>
T lowbit(const T &x) {
return (x ^ (x - 1)) & x;
}
template <class T>
int countbit(const T &n) {
return (n == 0) ? 0 : (1 + countbit(n & (n - 1)));
}
template <class T>
void ckmin(T &a, const T &b) {
if (b < a) a = b;
}
template <class T>
void ckmax(T &a, const T &b) {
if (b > a) a = b;
}
const int maxn = (1 << 20);
int n;
int a[maxn];
int sa[maxn];
int l[maxn], h[maxn];
int simulate(int l1, int l2) {
int s = 0;
int src = min(l1, l2);
int dst = max(l1, l2);
int c = sa[src + 1];
for (int i = src + 1; i <= dst;) {
int d = a[i];
int z = min(dst + 1 - i, l[i]);
if (d == 1 && i <= l1 || d == 2 && i <= l2)
c += d * z;
else {
int w = min(c, d * z * 10);
c -= w;
s += w;
}
i += z;
}
s += min((sa[n] - sa[dst + 1]) * 10, c);
return sa[n] * 10 - s;
}
int solve() {
sa[0];
for (int i = 0; i < (n); ++i) sa[i + 1] = sa[i] + a[i];
for (int i = n - 1; i >= 0; i--)
l[i] = ((i + 1 < n && a[i] == a[i + 1]) ? l[i + 1] + 1 : 1);
for (int i = 0; i < (n); ++i)
h[i] = ((i - 1 >= 0 && a[i] == a[i - 1]) ? h[i - 1] + 1 : 1);
int ret = 1000000000;
for (int key = -1; key < n; key++)
if (key < 0 || a[key] == 1) {
set<int> wset;
for (int c = max(0, key), step = 0; c < n && step < 5; step++, c += l[c])
wset.insert(c);
for (int c = min(n - 1, key), step = 0; step < 5; step++, c -= h[c]) {
if (c < 0) {
int s = simulate(key, -1);
ckmin(ret, s);
break;
}
wset.insert(c);
}
for (int src : wset) {
if (a[src] != 2) continue;
int low = src - h[src] + 1;
int high = src + l[src] - 1;
while (high - low > 5) {
int m1 = (low * 2 + high) / 3;
int m2 = (low + high * 2) / 3;
int s1 = simulate(key, m1);
int s2 = simulate(key, m2);
ckmin(ret, s1);
ckmin(ret, s2);
if (s1 < s2)
high = m2;
else
low = m1;
}
for (int other = low; other <= high; other++) {
assert(a[other] == 2);
int s = simulate(key, other);
ckmin(ret, s);
}
}
}
return ret;
}
int main() {
std::ios_base::sync_with_stdio(false);
while (cin >> n) {
for (int i = 0; i < (n); ++i) {
cin >> a[i];
a[i] /= 1000;
}
int ret = solve();
cout << (long long)ret * 100 << endl;
break;
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
const int inf = 1e9;
int n;
int a[maxn];
int dp[maxn][31];
inline void upd(int &x, int y) { x = min(x, y); }
int main() {
cin.tie();
ios::sync_with_stdio(0);
cin >> n;
for (int i = 0; i < n; ++i) cin >> a[i], a[i] /= 100;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= 30; ++j) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= 30; ++j) {
if (dp[i][j] == inf) continue;
upd(dp[i + 1][j + a[i] / 10], dp[i][j] + a[i]);
int d = min(j, a[i]);
upd(dp[i + 1][j - d], dp[i][j] + a[i] - d);
}
int ans = inf;
for (int j = 0; j <= 30; ++j) ans = min(ans, dp[n][j]);
cout << ans * 100 << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int g[500000], h[500000], v[500000];
int i, k, l, n, s, t, t1, t2, t3, d1, d2;
int main() {
t = 1000000000;
scanf("%d", &n);
for (i = 1; i <= n; i++) {
scanf("%d", &g[i]);
g[i] = g[i] / 1000;
}
for (i = 1; i <= n; i++)
if (g[i] == 2) t2++;
s = s + t2 / 11 * 20000;
for (i = 1; i <= n; i++)
if ((g[i] != 2) || (t1 < t2 % 11)) {
k++, h[k] = g[i];
if (g[i] == 2) t1++;
}
t1 = 0, t2 = 0;
for (i = 1; i <= k; i++)
if (h[i] == 1)
t1++;
else
t2++;
while (t2) {
if (h[k] == 2) {
if (t1 + 2 * (t2 - 1) >= 20) {
t1 = t1 - (20 - 2 * (t2 - 1)), t2 = 0;
s = s + 20000;
break;
} else {
s = s + (t1 + 2 * (t2 - 1)) * 900 + 2000;
t1 = t2 = 0;
break;
}
} else {
d2 = min(t2, 5);
d1 = min(t1 - 1, 10 - 2 * d2);
s = s + (d1 + 2 * d2) * 900 + 1000;
t1 = d1, t2 = t2 - d2;
l = 0, d1 = 0, d2 = 0;
for (i = 1; i <= k; i++)
if (h[i] == 1) {
d1++;
if (d1 > t1) l++, v[l] = 1;
} else {
d2++;
if (d2 <= t2) l++, v[l] = 2;
}
k = l - 1;
for (i = 1; i <= k; i++) h[i] = v[i];
t1 = 0, t2 = 0;
for (i = 1; i <= k; i++)
if (h[i] == 1)
t1++;
else
t2++;
if (t2) t = 0;
}
}
while (t1 >= 11) t1 = t1 - 11, s = s + 10000;
if (t1) s = s + (t1 - 1) * 900 + 1000;
if (!t) {
t1 = 0, t2 = 0;
for (i = 1; i <= n; i++)
if (g[i] == 2) t2++;
t = t + t2 / 11 * 20000;
k = 0;
for (i = 1; i <= n; i++) {
if (g[i] == 2) {
t1++;
if (t1 == t2) t3 = i - t1;
}
if ((g[i] != 2) || (t1 + t2 % 11 > t2)) k++, h[k] = g[i];
}
t1 = 0, t2 = 0;
for (i = 1; i <= k; i++)
if (h[i] == 1)
t1++;
else
t2++;
if (t2) {
d2 = t2;
d1 = min(20 - 2 * (d2 - 1), t3);
t = t + (d1 + 2 * (d2 - 1)) * 900 + 2000;
t1 = t1 - d1;
}
if (t1) {
while (t1 >= 11) t1 = t1 - 11, t = t + 10000;
if (t1) t = t + (t1 - 1) * 900 + 1000;
}
}
printf("%d", min(s, t));
return 0;
}
| 10 | CPP |
#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 dp[2][32];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= 31; i++) dp[0][i] = -1e9;
int sum = 0;
for (int i = 1; i <= n; i++) {
int x;
scanf("%d", &x);
x /= 100;
sum += x;
int now = i & 1;
for (int j = 0; j <= 31; j++) dp[now][j] = -1e9;
for (int j = 0; j <= 31 - x / 10; j++)
chkmax(dp[now][j + x / 10], dp[!now][j]);
for (int j = 0; j <= 31; j++)
chkmax(dp[now][max(j - x, 0)], dp[!now][j] + min(j, x));
for (int j = 30; j >= 0; j--) chkmax(dp[now][j], dp[now][j + 1]);
}
int ans = 0;
for (int j = 0; j <= 31; j++) chkmax(ans, dp[n & 1][j]);
cout << (sum - ans) * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <class P, class Q>
inline void smin(P &a, Q b) {
if (b < a) a = b;
}
template <class P, class Q>
inline void smax(P &a, Q b) {
if (a < b) a = b;
}
const int maxn = 300000 + 100;
int n;
int a[maxn], sum;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0, i__n = (int)(n); i < i__n; ++i) cin >> a[i], sum += a[i];
int f = sum / 11 / 100;
if (sum - a[n - 1] < f * 1000) f--;
cout << sum - f * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[303030], sum, s[303030];
bool ok(int k) {
int x = k * 10, y = sum - k * 11, ans = x + y;
int xx = x, now = 1;
while (xx >= a[now]) {
xx -= a[now];
now++;
}
if (!xx) return 1;
for (int i = now; i <= n; i++)
if (a[i] == 10) {
if (y + s[now - 1] / 10 >= s[i - 1] - s[now - 1]) return 1;
break;
}
for (int i = now - 1; i >= 1; i--)
if (a[i] == 10) {
if (y + s[i - 1] / 10 >= 10) return 1;
}
return 0;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] /= 100;
s[0] = 0;
for (int i = 1; i <= n; i++) s[i] = a[i] + s[i - 1];
if (n == 1) {
printf("%d00\n", a[1]);
return 0;
}
sum = s[n];
int k = sum / 11;
if (ok(k)) {
printf("%d00\n", sum - k);
return 0;
}
printf("%d00\n", sum - k + 1);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T& x) {
x = 0;
char c = getchar();
while (c < '0' || c > '9') c = getchar();
while (c >= '0' && c <= '9') {
x *= 10;
x += c - '0';
c = getchar();
}
}
inline void reads(string& s) {
char c = getchar();
while (c < 'a' || c > 'z') c = getchar();
while (c >= 'a' && c <= 'z') {
s += c;
c = getchar();
}
}
const string YES = "YES";
const string NO = "NO";
const int MAGIC = 100;
void up(int& x, int y) {
if (y == -1) return;
if (x == -1) x = y;
x = min(x, y);
}
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
int n;
cin >> n;
int dp[MAGIC];
int cur[MAGIC];
for (int i = 0; i < MAGIC; i++) dp[i] = -1;
dp[0] = 0;
for (int i = 0; i < n; i++) {
int x;
cin >> x;
for (int j = 0; j < MAGIC; j++) cur[j] = -1;
for (int j = 0; j < MAGIC; j++) {
if (dp[j] == -1) continue;
up(cur[max(0, j - x / 100)],
(x / 100 - (j - max(0, j - x / 100))) * 100 + dp[j]);
if (j + x / 1000 < MAGIC) up(cur[j + x / 1000], dp[j] + x);
}
for (int j = 0; j < MAGIC; j++) dp[j] = cur[j];
}
int ans = -1;
for (int i = 0; i < MAGIC; i++) up(ans, dp[i]);
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double PI = atan(1) * 4;
const long long oo = 1000000000;
const int N = 300010;
int n, a[N], mx = 0;
bool take[N];
bool tr() {
long long bonus = 0;
for (int i = 0; i < n; ++i) {
if (take[i]) {
bonus += a[i] / 10;
} else {
bonus -= min(bonus, (long long)a[i]);
}
}
return bonus == 0;
}
bool check(int mid) {
memset(take, 0, sizeof take);
int rem = mx - mid, last = -1, nxt = -1;
bool bf = true;
for (int i = 0; i < n; ++i) {
if (!rem) break;
if (rem == 1 && a[i] == 2000 && bf) {
bf = 0;
for (int j = i; j < n; j++) {
if (a[j] == 1000) {
nxt = j;
break;
}
}
if (last != -1 && nxt != -1 && bf) {
take[last] = take[nxt] = 1;
if (tr()) return true;
}
if (last != -1) {
take[last] = take[nxt] = 0;
take[i] = 1;
if (tr()) return true;
}
}
if (a[i] == 1000) last = i;
if (rem >= a[i] / 1000) {
take[i] = 1;
rem -= a[i] / 1000;
}
}
return tr();
}
int main() {
scanf("%d", &n);
bool fn = true;
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
if (a[i] == 1000) fn = 0;
mx += (a[i] / 100);
}
int best = 1e9;
for (int o2 = 1 + fn; o2 <= 2; o2++) {
int lo = 0, hi = mx / o2;
while (lo <= hi) {
int md = (lo + hi) / 2;
if (check(md * o2)) {
best = min(best, md * o2 * 100);
hi = md - 1;
} else {
lo = md + 1;
}
}
}
cout << best << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const int N = 300050;
const int M = 35;
const int inf = 1e9 + 7;
int dp[N][M], a[N];
int min(int a, int b) { return a > b ? b : a; }
int main() {
int n, i, j, k;
scanf("%i", &n);
for (i = 0; i <= n; i++)
for (j = 0; j < M; j++) dp[i][j] = inf;
dp[0][0] = 0;
for (i = 1; i <= n; i++) {
scanf("%i", &a[i]);
a[i] /= 100;
for (j = 0; j < M; j++) {
if (j + a[i] / 10 < M)
dp[i][j + a[i] / 10] = min(dp[i][j + a[i] / 10], dp[i - 1][j] + a[i]);
int l = min(a[i], j);
for (k = 1; k <= l; k++) {
dp[i][j - k] = min(dp[i][j - k], dp[i - 1][j] + a[i] - k);
}
}
}
int ans = inf;
for (i = 0; i < M; i++) ans = min(ans, dp[n][i]);
printf("%i\n", ans * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline void chmin(int &x, int v) {
if (v < x) x = v;
}
const int M = 40;
int N;
int A[300000];
int dp[300001][M + 1];
signed main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> N;
for (int i = 0; i < (N); i++) {
cin >> A[i];
A[i] /= 100;
}
for (int i = 0; i < (N + 1); i++)
for (int j = 0; j < (M + 1); j++) dp[i][j] = 1145141919;
dp[0][0] = 0;
for (int i = 0; i < (N); i++) {
for (int j = 0; j < (M + 1); j++) {
if (dp[i][j] == 1145141919) continue;
if (j + A[i] / 10 <= M) {
chmin(dp[i + 1][j + A[i] / 10], dp[i][j] + A[i]);
}
int diff = min(j, A[i]);
chmin(dp[i + 1][j - diff], dp[i][j] + A[i] - diff);
}
}
int m = 1145141919;
for (int i = 0; i < (M + 1); i++) m = min(m, dp[N][i]);
cout << m * 100 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int INF = (1 << 30) - 1;
int n;
int A[300010];
int dp[300010][41];
void Update(int &A, int B) {
if (A == -1)
A = B;
else if (A > B)
A = B;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
}
memset(dp, -1, sizeof(dp));
dp[1][A[1] / 1000] = A[1];
for (int i = 2; i <= n; ++i) {
for (int j = 0; j < 41; ++j)
if (dp[i - 1][j] != -1) {
if (j) {
int t = j * 100;
if (A[i] < t) t = A[i];
Update(dp[i][j - t / 100], dp[i - 1][j] + A[i] - t);
}
if (j + A[i] / 1000 < 41) {
Update(dp[i][j + A[i] / 1000], dp[i - 1][j] + A[i]);
}
}
}
int ans = -1;
for (int i = 0; i < 41; ++i)
if (dp[n][i] != -1) {
Update(ans, dp[n][i]);
}
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const ll N = 3e5 + 10;
const ll INF = 1e18;
void umax(ll &a, ll b) { a = max(a, b); }
ll n;
ll a[N];
ll dp[N][41];
signed main() {
ios::sync_with_stdio(0), cin.tie(0);
cin >> n;
for (ll i = 0; i < n; ++i) {
cin >> a[i];
a[i] /= 100;
}
fill_n(dp[0], 41 * N, -INF);
dp[0][0] = 0;
for (ll i = 0; i < n; ++i) {
for (ll j = 0; j <= 30; ++j) {
umax(dp[i + 1][j + a[i] / 10], dp[i][j]);
ll w = min(j, a[i]);
umax(dp[i + 1][j - w], dp[i][j] + w);
}
}
ll bonus = *max_element(dp[n], dp[n] + 31);
cout << 100 * (accumulate(a, a + n, 0LL) - bonus) << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 1;
int a[N];
int one;
int two;
int n;
int calc(int cnt1, int cnt2) {
int res = 0;
int credit = 0;
for (int i = 0; i < n; ++i) {
if ((a[i] == 1000 && cnt1 > 0) || (a[i] == 2000 && cnt2 > 0)) {
credit += a[i] / 10;
res += a[i];
if (a[i] == 1000) {
--cnt1;
} else {
--cnt2;
}
} else {
res += max(0, a[i] - credit);
credit = max(0, credit - a[i]);
}
}
return res;
}
int get(int k) {
int lo = 0;
int hi = two - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (calc(k, mid) >= calc(k, mid + 1)) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
return calc(k, lo);
}
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n;
for (int i = 0; i < n; ++i) {
cin >> a[i];
if (a[i] == 1000) {
++one;
} else {
++two;
}
}
int lo = 0;
int hi = one - 1;
while (lo <= hi) {
int mid = (lo + hi) / 2;
if (get(mid) >= get(mid + 1)) {
lo = mid + 1;
} else {
hi = mid - 1;
}
}
cout << get(lo) << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
inline void smin(T &a, U b) {
if (a > b) a = b;
}
template <typename T, typename U>
inline void smax(T &a, U b) {
if (a < b) a = b;
}
template <typename T>
inline void gn(T &first) {
char c, sg = 0;
while (c = getchar(), (c > '9' || c < '0') && c != '-')
;
for ((c == '-' ? sg = 1, c = getchar() : 0), first = 0; c >= '0' && c <= '9';
c = getchar())
first = (first << 1) + (first << 3) + c - '0';
if (sg) first = -first;
}
template <class T, class T1>
inline void gn(T &first, T1 &second) {
gn(first);
gn(second);
}
template <class T, class T1, class T2>
inline void gn(T &first, T1 &second, T2 &z) {
gn(first);
gn(second);
gn(z);
}
template <typename T>
inline void print(T first) {
if (first < 0) {
putchar('-');
return print(-first);
}
if (first < 10) {
putchar('0' + first);
return;
}
print(first / 10);
putchar(first % 10 + '0');
}
template <typename T>
inline void println(T first) {
print(first), putchar('\n');
}
template <typename T>
inline void printsp(T first) {
print(first), putchar(' ');
}
template <class T, class T1>
inline void print(T first, T1 second) {
printsp(first), println(second);
}
template <class T, class T1, class T2>
inline void print(T first, T1 second, T2 z) {
printsp(first), printsp(second), println(z);
}
int power(int a, int b, int m, int ans = 1) {
for (; b; b >>= 1, a = 1LL * a * a % m)
if (b & 1) ans = 1LL * ans * a % m;
return ans;
}
int a[300300];
int dp[300300][50];
int sum[300300];
int main() {
int n;
gn(n);
for (int i = 1; i <= n; i++) gn(a[i]), sum[i] = sum[i - 1] + a[i];
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 1; j < 50; j++) {
if (a[i] == 1000) smin(dp[i][j], dp[i - 1][j - 1] + a[i]);
if (a[i] == 2000 && j > 1) smin(dp[i][j], dp[i - 1][j - 2] + a[i]);
}
for (int j = 1; j < 50; j++) {
for (int k = min(j, a[i] / 100); k >= 0; k--) {
smin(dp[i][j - k], dp[i - 1][j] + a[i] - 100 * k);
}
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i < 25; i++) smin(ans, dp[n][i]);
for (int i = 1; i <= n; i++) {
smin(ans, sum[n] - min(sum[i], sum[n] - sum[i]) / 10);
}
println(ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
int n;
cin >> n;
vector<int> a(n), la1(n, -1), la2(n, -1);
vector<long long> pre(n, 0);
for (int i = 0; i < n; i++) {
cin >> a[i];
pre[i] = a[i];
if (i) pre[i] += pre[i - 1];
if (i) {
if (a[i - 1] == 1000) {
la1[i] = i - 1;
la2[i] = la2[i - 1];
} else {
la2[i] = i - 1;
la1[i] = la1[i - 1];
}
}
}
long long ans = pre[n - 1];
for (int i = 0; i < n; i++) {
long long rem = pre[n - 1] - pre[i];
ans = min(ans, pre[i] + max(rem - pre[i] / 10, 0ll));
if (a[i] == 1000) {
int lax = la1[i];
for (int la = lax; la < i; la++) {
int mid = i - la - 1;
long long pay = ((la >= 0) ? pre[la] : 0);
long long crem = 1ll * 2000 * mid;
long long bal = max(0ll, pay / 10 - crem);
pay += max(0ll, crem - pay / 10);
pay += 1000;
bal += 100;
ans = min(ans, pay + max(rem - bal, 0ll));
}
} else {
int la = la1[i];
la--;
long long pay = ((la >= 0) ? pre[la] : 0);
long long crem = 1000;
long long bal = max(0ll, pay / 10 - crem);
pay += max(0ll, crem - pay / 10);
long long rmid = pre[i] - ((la + 1 >= 0) ? pre[la + 1] : 0);
pay += rmid;
bal += rmid / 10;
ans = min(ans, pay + max(rem - bal, 0ll));
}
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[300005][35], n;
int ara[600005];
long long dp_func(int pos, int ase) {
if (pos > n) return 0;
if (dp[pos][ase] != -1) return dp[pos][ase];
long long ret = 21474836499999;
for (int i = 1; i <= ase && (ara[pos] >= i * 100); i++) {
ret = min(ret, dp_func(pos + 1, ase - i) + (ara[pos]) - (i * 100));
}
if (ase < 29) {
ret = min(ret, dp_func(pos + 1, ase + (ara[pos] / 1000)) + ara[pos]);
}
return dp[pos][ase] = ret;
}
int main() {
int i, j, k, l, m;
memset(dp, -1, sizeof dp);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &l);
if (l == 1000)
ara[++n] = l;
else {
ara[++n] = 2000;
}
}
long long ret = dp_func(1, 0);
cout << ret << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10;
long long dp[maxn][50];
int a[maxn];
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) cin >> a[i];
memset(dp, 63, sizeof dp);
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 50; j++) {
if (dp[i][j] > 1e18) continue;
if (a[i] / 1000 + j < 50)
dp[i + 1][j + a[i] / 1000] =
min(dp[i + 1][j + a[i] / 1000], dp[i][j] + a[i]);
long long mini = min(j * 100, a[i]);
dp[i + 1][j - mini / 100] =
min(dp[i + 1][j - mini / 100], dp[i][j] + a[i] - mini);
}
}
long long ans = 1e18;
for (int i = 0; i < 50; i++) ans = min(ans, dp[n][i]);
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline long long mod(long long n, long long m) {
long long ret = n % m;
if (ret < 0) ret += m;
return ret;
}
long long gcd(long long a, long long b) {
return (b == 0LL ? a : gcd(b, a % b));
}
long long exp(long long a, long long b, long long m) {
if (b == 0LL) return 1LL;
if (b == 1LL) return mod(a, m);
long long k = mod(exp(a, b / 2, m), m);
if (b & 1LL) {
return mod(a * mod(k * k, m), m);
} else
return mod(k * k, m);
}
int n;
const int N = 300100, MX = 100, inf = 1e9;
int a[N];
int dp[N][MX + 10];
int solve(int id, int j) {
if (id > n) return 0;
int& x = dp[id][j];
if (x != -1) return x;
if (j >= MX) {
return x = solve(id + 1, j - a[id]);
}
x = inf;
if (j > 0) {
int put = min(j, a[id]);
x = solve(id + 1, j - put) + a[id] - put;
}
return x = min(x, solve(id + 1, j + a[id] / 10) + a[id]);
}
int32_t main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
;
memset(dp, -1, sizeof(dp));
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
a[i] /= 100;
}
cout << 100LL * solve(1, 0) << "\n";
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const int MAXN = 312345;
const int INF = 0x3f3f3f3f;
int n;
int a[MAXN];
int psum[MAXN];
int rsum(int p, int q) {
if (q < p) return 0;
return psum[q + 1] - psum[p];
}
int sub(int p1, int b1, int p2, int b2) {
int cost = p1;
int bonus = p1 / 10;
int y = min(bonus, b1);
bonus -= y;
cost += b1 - y;
cost += p2;
bonus += p2 / 10;
y = min(bonus, b2);
cost += b2 - y;
return cost;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
psum[i + 1] = psum[i] + a[i];
}
int sol = INF;
int last = -1;
int next = -1;
for (int i = 0; i < n; i++) {
if (a[i] == 1000) {
last = i;
}
next = max(next, i);
while (next < n and a[next] != 1000) next++;
sol = min(sol, sub(rsum(0, i), rsum(i + 1, n - 1), 0, 0));
if (last != -1) {
sol = min(sol, sub(rsum(0, last - 1), a[last], rsum(last + 1, i),
rsum(i + 1, n - 1)));
}
if (next < n) {
sol = min(sol, sub(rsum(0, i), rsum(i + 1, next - 1), a[next],
rsum(next + 1, n - 1)));
}
}
cout << sol << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 10, Max = 50, inf = 1e8;
int dp[maxn][Max], a[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
int n;
cin >> n;
for (int i = 1; i < Max; i++) {
dp[0][i] = inf;
}
for (int i = 1; i <= n; i++) {
int x;
cin >> x;
int x1 = x / 100, x2 = x1 / 10;
for (int j = 0; j < Max; j++) {
int A = inf, B = inf;
if (j >= x2) A = dp[i - 1][j - x2] + x1;
if (j + x1 < Max) B = dp[i - 1][j + x1];
dp[i][j] = min(A, B);
}
for (int j = 1; j < x1; j++) {
dp[i][0] = min(dp[i][0], dp[i - 1][j] + x1 - j);
}
}
int ans = inf;
for (int i = 0; i < Max; i++) {
ans = min(ans, dp[n][i]);
}
return cout << ans * 100 << endl, 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[300005][35], a[300005];
int main() {
int n;
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] /= 100;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= 30; j++) dp[i][j] = 1000000000;
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 30; j++) {
dp[i + 1][j + a[i + 1] / 10] =
min(dp[i + 1][j + a[i + 1] / 10], dp[i][j] + a[i + 1]);
dp[i + 1][j - min(j, a[i + 1])] =
min(dp[i + 1][j - min(j, a[i + 1])],
dp[i][j] + a[i + 1] - min(j, a[i + 1]));
}
}
int maxx = 1000000000;
for (int i = 0; i <= 30; i++) maxx = min(maxx, dp[n][i]);
printf("%d00\n", maxx);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[300005];
int dp[300005][35];
int main() {
ios::sync_with_stdio(false);
int n, cur = 0, ans = 0x3f3f3f3f;
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> a[i];
}
for (int i = 0; i <= n; i++) {
for (int j = 0; j <= 30; j++) {
dp[i][j] = 0x3f3f3f3f;
}
}
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 30; j++) {
for (int rem = min(30, j + a[i] / 100); rem > j; rem--) {
dp[i][j] = min(dp[i][j], a[i] - (rem - j) * 100 + dp[i - 1][rem]);
}
if (j >= a[i] / 1000) {
dp[i][j] = min(dp[i][j], a[i] + dp[i - 1][j - a[i] / 1000]);
}
}
}
for (int i = 0; i <= 30; i++) {
ans = min(ans, dp[n][i]);
}
cout << ans << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[300010][41];
int main() {
int N, A[300010];
scanf("%d", &N);
for (int i = 0; i < N; i++) {
scanf("%d", A + i);
}
for (int i = 0; i <= N; i++)
for (int j = 0; j <= 40; j++) dp[i][j] = 2000000000000000000LL;
dp[0][0] = 0;
for (int i = 0; i < N; i++) {
for (int j = 0; j <= 40; j++) {
int nextj = min(40, j + A[i] / 1000);
dp[i + 1][nextj] = min(dp[i + 1][nextj], dp[i][j] + A[i]);
for (int k = 1; k <= min(j, A[i] / 100); k++) {
dp[i + 1][j - k] = min(dp[i + 1][j - k], dp[i][j] + A[i] - k * 100);
}
}
}
long long ans = 2000000000000000000LL;
for (int i = 0; i <= 40; i++) {
ans = min(ans, dp[N][i]);
}
printf("%lld\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 50;
int n, a[300005];
long long f[300005][MAXD + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) a[i] /= 100;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= MAXD; ++j) f[i][j] = 1e18;
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= MAXD; ++j) {
if (f[i - 1][j] == 1e18) continue;
if (j >= a[i])
f[i][j - a[i]] = min(f[i][j - a[i]], f[i - 1][j]);
else
f[i][0] = min(f[i][0], f[i - 1][j] + (a[i] - j) * 100);
f[i][min(j + a[i] / 10, MAXD)] =
min(f[i][min(j + a[i] / 10, MAXD)], f[i - 1][j] + a[i] * 100);
}
}
long long ans = 1e18;
for (int i = 0; i <= MAXD; ++i) ans = min(ans, f[n][i]);
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300033, max_m = 40, inf = 1011111111;
int n, a[max_n], dp[2][max_m];
int main() {
scanf("%d", &n);
for (int i = 0; i < n; ++i) {
scanf("%d", &a[i]);
a[i] /= 100;
}
int q1 = 0, q2 = 1;
for (int j = 0; j < max_m; ++j) {
dp[q1][j] = inf;
}
dp[q1][0] = 0;
for (int i = 0; i < n; ++i) {
for (int j = 0; j < max_m; ++j) {
dp[q2][j] = inf;
}
for (int j = 0; j < max_m; ++j) {
if (dp[q1][j] == inf) {
continue;
}
if (j + a[i] / 10 < max_m) {
dp[q2][j + a[i] / 10] = min(dp[q2][j + a[i] / 10], dp[q1][j] + a[i]);
}
int y = min(j, a[i]);
dp[q2][j - y] = min(dp[q2][j - y], dp[q1][j] + a[i] - y);
}
swap(q1, q2);
}
int ans = inf;
for (int i = 0; i < max_m; ++i) {
ans = min(ans, dp[q1][i]);
}
printf("%d\n", ans * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, sum, counter, a[300010];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
sum += a[i];
if (a[i] == 2000) counter++;
}
int temp = sum * 1 / 11;
temp -= (temp % 100);
if (sum <= 11000) temp = (sum - a[n]) / 10;
if (counter == n) temp -= (temp % 200);
cout << sum - temp << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int num[300003], dp[2][45];
int main() {
cin >> n;
for (int i = 1; i <= n; ++i) {
cin >> num[i];
num[i] /= 100;
}
int now = 0;
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
int a = num[i] / 10;
for (int j = 0; j <= 40; j++) {
if (dp[now][j] < dp[0][41]) {
if (j + a <= 40) {
dp[now ^ 1][j + a] = min(dp[now ^ 1][j + a], dp[now][j] + num[i]);
}
int b = min(j, num[i]);
if (b) {
dp[now ^ 1][j - b] = min(dp[now ^ 1][j - b], dp[now][j] + num[i] - b);
}
dp[now][j] = dp[0][41];
}
}
now ^= 1;
}
int ans = dp[0][41];
for (int i = 0; i <= 40; i++) {
ans = min(ans, dp[now][i]);
}
cout << ans << "00" << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void addmod(int &a, long long b) {
a = (a + b);
if (a >= 1000000007) a -= 1000000007;
}
void mulmod(int &a, long long b) { a = (a * b) % 1000000007; }
template <class T>
bool domin(T &a, const T &b) {
return a > b ? a = b, 1 : 0;
}
template <class T>
bool domax(T &a, const T &b) {
return a < b ? a = b, 1 : 0;
}
int gi() {
int a;
scanf("%d", &a);
return a;
}
long long gll() {
long long a;
scanf("%lld", &a);
return a;
}
int ans[2][2507];
int main() {
int v = 1000000007;
fill_n(ans[0], 2507, v);
fill_n(ans[1], 2507, v);
ans[0][0] = 0;
int n = gi(), ix, nx;
for (int i = 0; i < n; i++) {
int x = gi() / 100;
int bo = x / 10;
ix = (i & 1);
nx = ix ^ 1;
fill_n(ans[nx], 2507, v);
for (int j = 0; j < 2500; j++)
if (ans[ix][j] < 1000000007) {
if (j < x) {
domin(ans[nx][j + bo], ans[ix][j] + x);
domin(ans[nx][0], ans[ix][j] + x - j);
} else if (j < 2000) {
domin(ans[nx][j - x], ans[ix][j]);
domin(ans[nx][j + bo], ans[ix][j] + x);
} else {
domin(ans[nx][j - x], ans[ix][j]);
}
}
}
int fa = 1000000007;
for (int i = 0; i < 2500; i++) {
domin(fa, ans[nx][i]);
}
cout << fa * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int INF = 1000000001;
const long double EPS = 1e-9;
const int MOD = 1000000007;
const long long LLINF = 1000000000000000001;
const int maxn = 400000;
const int maxb = 40;
long long dp[maxn][maxb];
long long v[maxn];
int n;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) cin >> v[i];
for (int i = 0; i <= maxb - 1; i++)
dp[n][i] = max((long long)0, v[n] - i * 100);
for (int i = n - 1; i >= 1; i--)
for (int j = 0; j <= maxb - 1; j++) {
dp[i][j] = dp[i + 1][j - min(v[i] / 100, (long long)j)] + v[i] -
min(v[i] / 100, (long long)j) * 100;
if (j + v[i] / 1000 < maxb)
dp[i][j] = min(dp[i][j], dp[i + 1][j + v[i] / 1000] + v[i]);
}
cout << dp[1][0] << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[300100][42];
int a[300100], n;
void make(int &x, int y) {
if (x == -1)
x = y;
else
x = min(x, y);
}
int main() {
memset(dp, -1, sizeof(dp));
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
dp[0][0] = 0;
for (int i = 0; i < n; ++i)
for (int j = 0; j <= 40; ++j) {
if (dp[i][j] == -1) continue;
make(dp[i + 1][min(40, j + a[i + 1] / 1000)], dp[i][j] + a[i + 1]);
if (j * 100 >= a[i + 1])
make(dp[i + 1][j - a[i + 1] / 100], dp[i][j]);
else
make(dp[i + 1][0], dp[i][j] + a[i + 1] - j * 100);
}
int ans = -1;
for (int i = 0; i <= 40; ++i)
if (~dp[n][i]) make(ans, dp[n][i]);
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7, inf = 1e9 + 7;
int a[N], dp[2][50], now, n;
void gmin(int &a, int b) {
if (a > b) a = b;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", a + i), a[i] /= 100;
now = 0;
for (int i = 1; i <= 40; ++i) dp[now][i] = inf;
for (int i = 1; i <= n; ++i) {
now ^= 1;
for (int j = 0; j <= 40; ++j) dp[now][j] = inf;
for (int j = 0; j <= 40; ++j)
if (dp[now ^ 1][j] != inf) {
if (j < 35) gmin(dp[now][j + a[i] / 10], dp[now ^ 1][j] + a[i]);
int tmp = max(a[i] - j, 0);
gmin(dp[now][j - a[i] + tmp], dp[now ^ 1][j] + tmp);
}
}
int ans = inf;
for (int i = 0; i <= 19; ++i) gmin(ans, dp[now][i]);
printf("%d00\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300005];
int dp[300005][35];
int solve(int idx, int cur) {
if (idx == n) return 0;
int &ret = dp[idx][cur];
if (~ret) return ret;
int x = min(a[idx], cur);
ret = solve(idx + 1, cur - x) + a[idx] - x;
if (a[idx] / 10 + cur <= 30)
ret = min(ret, a[idx] + solve(idx + 1, cur + a[idx] / 10));
return ret;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i), a[i] /= 100;
cout << solve(0, 0) * 100 << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxn = 3e5 + 100;
const int L = 40;
const int oo = 1e9;
int N, A[maxn];
int dp[L + 5][maxn];
inline void change(int &ret, int v) {
if (ret > v) ret = v;
}
int solve() {
for (int i = (0), _i = (L + 1); i <= _i; i++)
for (int j = (0), _j = (N); j <= _j; j++) dp[i][j] = oo;
dp[0][0] = 0;
for (int i = (0), _i = (N - 1); i <= _i; i++)
for (int j = (0), _j = (L + 1); j <= _j; j++)
if (dp[j][i] != oo) {
int cost = A[i + 1];
if (j < L) change(dp[j + cost / 10][i + 1], dp[j][i] + cost);
for (int k = (1), _k = (min(cost, j)); k <= _k; k++)
change(dp[j - k][i + 1], dp[j][i] + cost - k);
}
int ans = oo;
for (int i = (0), _i = (L + 1); i <= _i; i++)
if (dp[i][N] != oo) change(ans, dp[i][N]);
return ans;
}
int main() {
for (; scanf("%d", &N) != EOF;) {
for (int i = (1), _i = (N); i <= _i; i++) scanf("%d", &A[i]);
for (int i = (1), _i = (N); i <= _i; i++) A[i] /= 100;
int ans = solve();
printf("%d\n", ans * 100);
}
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma GCC target("avx2")
#pragma GCC optimization("O3")
#pragma GCC optimization("unroll-loops")
using namespace std;
template <class T>
using vec = std::vector<T>;
bool __hack = std::ios::sync_with_stdio(false);
auto __hack1 = cin.tie(nullptr);
struct Input {
Input(istream &in) : in(&in) {}
template <class T>
T next() const {
T x;
*in >> x;
return x;
}
int ni() const { return next<int>(); }
template <class T>
vec<T> nVec(int n) const {
vec<T> v(n);
for (int i = 0; i < n; ++i) {
v[i] = next<T>();
}
return v;
}
vec<int> nvi(int n) const { return nVec<int>(n); }
istream *in;
};
Input in(cin);
class Output {
private:
ostream *out;
template <typename T>
void printSingle(const T &value) {
*out << value;
}
public:
Output(ostream &out) : out(&out) {}
inline void print() {}
template <typename T, typename... Ts>
inline void print(const T &f, const Ts &...args) {
printSingle(f);
if (sizeof...(args) != 0) {
*out << ' ';
print(args...);
}
}
template <typename... Ts>
inline void println(const Ts &...args) {
print(args...);
*out << '\n';
}
template <typename... Ts>
inline void operator()(const Ts &...args) {
println(args...);
}
};
Output out(cout);
namespace template_util {
constexpr int bytecount(uint64_t x) { return x ? 1 + bytecount(x >> 8) : 0; }
template <int N>
struct bytetype {};
template <uint64_t N>
struct minimal_uint : bytetype<bytecount(N)> {};
} // namespace template_util
const int64_t INF = numeric_limits<int64_t>::max() / 2;
const int MAXD = 100;
void solve(istream &inStream, ostream &outStream) {
in = Input(inStream);
out = Output(outStream);
auto n = in.ni();
auto a = in.nvi(n);
vec<int64_t> dp(MAXD, INF);
dp[0] = 0;
for (int i = 0; i < (n); ++i) {
vec<int64_t> nxt(MAXD, INF);
int add = 1;
if (a[i] == 2000) add++;
for (int j = 0; j < (MAXD); ++j) {
if (dp[j] == INF) continue;
if (j + add < MAXD) {
nxt[j + add] = min(nxt[j + add], dp[j] + a[i]);
}
int disc = j * 100;
if (disc <= a[i]) {
nxt[0] = min(nxt[0], dp[j] + a[i] - disc);
} else {
int left = disc - a[i];
left /= 100;
nxt[left] = min(nxt[left], dp[j]);
}
}
dp = nxt;
}
auto res = *min_element(dp.begin(), dp.end());
out(res);
}
int main() {
solve(cin, cout);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
const int B = 50;
const int oo = 1e9;
int dp[N][B];
int n, a[N];
int f(int i, int j) {
if (i == n) return 0;
if (j >= B) return oo;
int &ans = dp[i][j];
if (~ans) return ans;
ans = f(i + 1, j + a[i]) + a[i] * 10;
int nj = j - a[i] * 10;
int add = 0;
if (nj < 0) {
add += abs(nj);
nj = 0;
}
ans = min(ans, f(i + 1, nj) + add);
return ans;
}
int main() {
memset(dp, -1, sizeof dp);
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", a + i), a[i] /= 1000;
printf("%d\n", f(0, 0) * 100);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int KN = 3e5 + 5, KInfL = 0x3f3f3f3f;
int n, m = 30, c[KN], f[KN][31];
int main() {
ios::sync_with_stdio(false);
cin >> n;
for (int i = 1; i <= n; ++i) cin >> c[i];
memset(f, 0x3f, sizeof f);
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= m; ++j) {
if (f[i - 1][j] >= KInfL) continue;
if (j + c[i] / 1000 <= m)
f[i][j + c[i] / 1000] = min(f[i][j + c[i] / 1000], f[i - 1][j] + c[i]);
int now = min(c[i] / 100, j);
f[i][j - now] = min(f[i][j - now], f[i - 1][j] + c[i] - now * 100);
}
}
cout << *min_element(f[n], f[n] + m + 1) << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int maxN = 300000 + 13;
int a[maxN], N;
long long f[maxN][40];
int main() {
scanf("%d", &N);
for (int i = (1), _ed = (N + 1); i < _ed; i++) scanf("%d", &a[i]);
memset(f, 0x3f, sizeof(f));
f[0][0] = 0;
for (int i = (1), _ed = (N + 1); i < _ed; i++) {
int ta = a[i] / 1000;
for (int j = (0), _ed = (40); j < _ed; j++) {
f[i][j + ta] = min(f[i][j + ta], f[i - 1][j] + a[i]);
if (j >= ta * 10)
f[i][j - ta * 10] = min(f[i][j - ta * 10], f[i - 1][j]);
else
f[i][0] = min(f[i][0], f[i - 1][j] + (a[i] - j * 100));
}
}
long long ans = f[N + 1][0];
for (int i = (0), _ed = (40); i < _ed; i++) {
if (ans > f[N][i]) ans = f[N][i];
}
cout << ans << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
vector<int> v;
int n, count1 = 0, count2 = 0;
int test(int a, int b) {
int x = count1, y = count2;
int ans = 0, bon = 0;
for (int i = 0; i < n; i++) {
if (v[i] == 1000) {
if (x > a)
ans += 10, bon += 1, x--;
else {
int aux = min(10, bon);
ans += 10 - aux;
bon -= aux;
}
}
if (v[i] == 2000) {
if (y > b)
ans += 20, bon += 2, y--;
else {
int aux = min(20, bon);
ans += 20 - aux;
bon -= aux;
}
}
}
return ans;
}
int binary_search2(int a) {
int i = 1, j = count2;
while (j - i > 1) {
int mid = (i + j) >> 1;
int ans1 = test(a, mid);
int ans2 = test(a, mid - 1);
if (ans1 - ans2 <= 0)
i = mid;
else
j = mid;
}
int ans = 1e9;
for (int l = i - 1; l <= j; l++) ans = min(ans, test(a, l));
return ans;
}
int binary_search() {
int i = 1, j = count1;
while (j - i > 1) {
int mid = (i + j) >> 1;
int ans1 = binary_search2(mid);
int ans2 = binary_search2(mid - 1);
if (ans1 - ans2 <= 0)
i = mid;
else
j = mid;
}
int ans = 1e9;
for (int l = i - 1; l <= j; l++) ans = min(ans, binary_search2(l));
return ans;
}
int main() {
scanf("%d", &n);
v = vector<int>(n);
for (int i = 0; i < n; i++) {
scanf("%d", &v[i]);
if (v[i] == 1000)
count1++;
else
count2++;
}
int ans = binary_search();
printf("%lld\n", ans * 100LL);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[300010], n;
int res[300010][110];
int dp(int id, int cs) {
if (id == n) return 0;
if (res[id][cs] != -1) return res[id][cs];
int tk = min(cs * 100, a[id]);
int w = a[id] - tk + dp(id + 1, cs - tk / 100);
if (cs < 100) w = min(w, a[id] + dp(id + 1, cs + a[id] / 1000));
return res[id][cs] = w;
}
int main() {
memset(res, -1, sizeof(res));
scanf("%d", &n);
for (int i = 0; i < n; i++) scanf("%d", &a[i]);
printf("%d\n", dp(0, 0));
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
ios::sync_with_stdio(0);
cin.tie(0), cout.tie(0);
int n;
cin >> n;
vector<int> a(n);
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 100;
}
vector<vector<int> > dp(n + 1, vector<int>(100, 1000000000));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < 100; j++) {
if (j + a[i] / 10 < 100)
dp[i + 1][j + a[i] / 10] =
min(dp[i + 1][j + a[i] / 10], dp[i][j] + a[i]);
dp[i + 1][max(j - a[i], 0)] =
min(dp[i + 1][max(j - a[i], 0)], dp[i][j] + max(a[i] - j, 0));
}
}
cout << *min_element(dp.back().begin(), dp.back().end()) * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, a[300300], flag[300300];
int solveSkip(int budget) {
int bonus = 0;
for (int i = 0; i < n; i++) {
if (flag[i]) {
if (budget < a[i]) return 0;
budget -= a[i];
bonus += a[i] / 10;
} else if (bonus >= a[i])
bonus -= a[i];
else if (bonus + budget >= a[i]) {
budget -= a[i] - bonus;
bonus = 0;
} else
return 0;
}
return 1;
}
int ok(int _budget) {
int bonus = 0, last[2] = {-1, -1}, res = 1, budget = _budget;
memset(flag, 0, sizeof flag);
for (int i = 0; i < n; i++)
if (budget >= a[i]) {
budget -= a[i];
last[a[i] / 10 - 1] = i;
flag[i] = 1;
bonus += a[i] / 10;
} else if (bonus >= a[i])
bonus -= a[i];
else if (budget + bonus >= a[i]) {
budget -= a[i] - bonus;
bonus = 0;
} else {
res = 0;
break;
}
if (res) return 1;
for (int j = 0; j < 2; j++)
if (last[j] >= 0) {
int target = -1;
for (int k = last[j] + 1; k < n; k++)
if (a[k] != a[last[j]] && !flag[k]) {
target = k;
break;
}
if (target >= 0) {
flag[last[j]] = 0;
flag[target] = 1;
if (solveSkip(_budget)) return 1;
flag[last[j]] = 1;
flag[target] = 0;
}
}
return 0;
}
int main() {
ios::sync_with_stdio(0);
cin.tie(NULL);
cin >> n;
for (int i = 0; i < n; i++) {
cin >> a[i];
a[i] /= 100;
}
int low = 0, high = n * 20, ans = n;
while (low <= high) {
int mid = (low + high) / 2;
if (ok(mid)) {
ans = mid;
high = mid - 1;
} else
low = mid + 1;
}
cout << ans * 100 << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const double inf = 1e15;
long long read() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = -1;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
int n, x[300500], all, a, b;
int solve(int a, int b) {
int ans = 0, j = 0;
for (int i = 1; i <= n; i++) {
if ((a > 0 && x[i] == 1000) || (b > 0 && x[i] == 2000))
j += x[i] / 10, ans += x[i];
else
ans += x[i] - min(x[i], j), j -= min(x[i], j);
if (x[i] == 1000)
a--;
else
b--;
}
return ans;
}
int main() {
n = read();
for (int i = 1; i <= n; i++) {
x[i] = read();
all += x[i];
}
for (int i = 1; i <= n; i++) {
all -= x[i] / 10 * 11;
if (all < 0) break;
if (x[i] == 1000)
a++;
else
b++;
}
int ans = min(solve(a, b), min(solve(a + 1, b), solve(a - 1, b + 1)));
printf("%d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 40;
int n, a[300005];
long long f[300005][MAXD + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) a[i] /= 100;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= MAXD; ++j) f[i][j] = 1e18;
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= MAXD; ++j) {
if (f[i - 1][j] == 1e18) continue;
if (j >= a[i])
f[i][j - a[i]] = min(f[i][j - a[i]], f[i - 1][j]);
else
f[i][0] = min(f[i][0], f[i - 1][j] + (a[i] - j) * 100);
f[i][min(j + a[i] / 10, MAXD)] =
min(f[i][min(j + a[i] / 10, MAXD)], f[i - 1][j] + a[i] * 100);
}
}
long long ans = 1e18;
for (int i = 0; i <= MAXD; ++i) ans = min(ans, f[n][i]);
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int a[300005], f[300005][35], n, ans;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) scanf("%d", &a[i]), a[i] /= 100;
memset(f, 60, sizeof(f));
f[0][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= 31; j++) {
if (j + a[i] / 10 <= 31)
f[i][j + a[i] / 10] = min(f[i][j + a[i] / 10], f[i - 1][j] + a[i]);
f[i][j - min(a[i], j)] =
min(f[i][j - min(a[i], j)], f[i - 1][j] + a[i] - min(a[i], j));
}
ans = 1e9;
for (int i = 0; i <= 31; i++) ans = min(ans, f[n][i]);
printf("%d", ans * 100);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n;
int a[300010], s[300010];
int f1[300010];
int next1[300010], next2[300010];
int ans = 0;
int getS(int l, int r) { return s[r] - s[l - 1]; }
void pre_gao() {
int last1 = n + 1, last2 = n + 1;
for (int i = n; i >= 1; i--) {
next1[i] = last1;
next2[i] = last2;
if (a[i] == 1)
last1 = i;
else
last2 = i;
}
}
void update(int x) {
if (x > ans) ans = x;
}
void gao(int x) {
if (getS(x + 1, n) * 10 >= getS(1, x)) update(s[x]);
if (next1[x] <= n) {
int s1 = s[x], s2 = getS(x + 1, next1[x] - 1);
int s3 = max(s1 - 10 * s2, 0);
int l = next1[x], r = next2[next1[x]] - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (getS(mid + 1, n) * 10 >= s3 + getS(next1[x], mid))
l = mid;
else
r = mid - 1;
}
if (getS(l + 1, n) * 10 >= s3 + getS(next1[x], l))
update(s1 + getS(next1[x], l));
}
if (next2[x] <= n) {
int s1 = s[x], s2 = getS(x + 1, next2[x] - 1);
int s3 = max(s1 - 10 * s2, 0);
int l = next2[x], r = next1[next2[x]] - 1;
while (l < r) {
int mid = (l + r + 1) >> 1;
if (getS(mid + 1, n) * 10 >= s3 + getS(next2[x], mid))
l = mid;
else
r = mid - 1;
}
if (getS(l + 1, n) * 10 >= s3 + getS(next2[x], l))
update(s1 + getS(next2[x], l));
}
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", a + i);
a[i] /= 1000;
s[i] = s[i - 1] + a[i];
}
pre_gao();
for (int i = 1; i <= n; i++) gao(i);
ans = s[n] * 10 - ans;
printf("%d00\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
const double PI = acos(-1);
const int MAXX = 10005;
const int maxInt = 2147483647;
using namespace std;
int a[300010], n;
inline int read() {
int k = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
k = k * 10 + ch - '0';
ch = getchar();
}
return k * f;
}
int main() {
n = read();
int sa = 0, sb = 0;
for (int i = 1; i <= n; i++) a[i] = read();
for (int i = 1; i <= n; i++) sa += a[i] / 1000, sb += (a[i] == 1000);
int S = sa * 10 / 11;
if (sa <= 11) S = sa - a[n] / 1000;
if (sb == 0 && (S & 1)) S--;
printf("%d", sa * 1000 - S * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, A[300010];
int dp[300010][35];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) {
scanf("%d", &A[i]);
A[i] /= 100;
}
for (int i = 0; i <= n; i++)
for (int j = 0; j < 35; j++) dp[i][j] = 2147482647;
dp[0][0] = 0;
for (int i = 1; i <= n; ++i) {
int a = A[i] / 10;
for (int j = 0; j <= 30; ++j)
if (dp[i - 1][j] < 2147482647) {
if (j + a <= 31) dp[i][j + a] = min(dp[i][j + a], dp[i - 1][j] + A[i]);
int minx = min(j, A[i]);
if (minx != 0)
dp[i][j - minx] = min(dp[i][j - minx], dp[i - 1][j] + A[i] - minx);
}
}
int ans = 2147482647;
for (int i = 0; i < 20; ++i) ans = min(ans, dp[n][i]);
printf("%d00\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAXD = 100;
int n, a[300005];
long long f[300005][MAXD + 5];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; ++i) scanf("%d", &a[i]);
for (int i = 1; i <= n; ++i) a[i] /= 100;
for (int i = 0; i <= n; ++i)
for (int j = 0; j <= MAXD; ++j) f[i][j] = 1e18;
f[0][0] = 0;
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= MAXD; ++j) {
if (f[i - 1][j] == 1e18) continue;
if (j >= a[i])
f[i][j - a[i]] = min(f[i][j - a[i]], f[i - 1][j]);
else
f[i][0] = min(f[i][0], f[i - 1][j] + (a[i] - j) * 100);
f[i][min(j + a[i] / 10, MAXD)] =
min(f[i][min(j + a[i] / 10, MAXD)], f[i - 1][j] + a[i] * 100);
}
}
long long ans = 1e18;
for (int i = 0; i <= MAXD; ++i) ans = min(ans, f[n][i]);
printf("%I64d\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1 << 29;
int main() {
int n, dpa[300], dpb[300], t, ans = MAX;
scanf("%d", &n);
dpa[0] = 0;
for (int i = 1; i < 300; i++) dpa[i] = MAX;
while (n--) {
scanf("%d", &t);
for (int i = 0; i < 300; i++) dpb[i] = MAX;
if (t == 1000) {
for (int i = 0; i <= 30; i++)
for (int j = i + 1; j <= 30 && j <= i + 10; j++)
dpb[i] = min(dpb[i], dpa[j] + (10 - j + i));
for (int i = 1; i <= 30; i++) dpb[i] = min(dpb[i], dpa[i - 1] + 10);
} else {
for (int i = 0; i <= 30; i++)
for (int j = i + 1; j <= 30 && j <= i + 20; j++)
dpb[i] = min(dpb[i], dpa[j] + (20 - j + i));
for (int i = 2; i <= 30; i++) dpb[i] = min(dpb[i], dpa[i - 2] + 20);
}
memcpy(dpa, dpb, sizeof(dpa));
}
for (int i = 0; i <= 30; i++) ans = min(ans, dpa[i]);
printf("%d00\n", ans);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int dp[305000][41];
int a[305000], n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
a[i] /= 100;
}
memset(dp, 0x3f3f3f3f, sizeof(dp));
dp[0][0] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= 30; j++) {
if (dp[i - 1][j] == 0x3f3f3f3f) continue;
if (j >= a[i])
dp[i][j - a[i]] = min(dp[i][j - a[i]], dp[i - 1][j]);
else
dp[i][0] = min(dp[i][0], dp[i - 1][j] + a[i] - j);
dp[i][j + a[i] / 10] = min(dp[i][j + a[i] / 10], dp[i - 1][j] + a[i]);
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i <= 30; i++) ans = min(ans, dp[n][i]);
printf("%lld\n", 1ll * ans * 100);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
long long dp[300005][35], n;
int ara[600005];
long long dp_func(int pos, int ase) {
if (pos > n) return 0;
if (dp[pos][ase] != -1) return dp[pos][ase];
long long ret = 21474836499999;
ret = min(ret, dp_func(pos + 1, max(ase - ara[pos] / 100, 0)) +
max((ara[pos] - (ase * 100)), 0));
if (ase < 29) {
ret = min(ret, dp_func(pos + 1, ase + (ara[pos] / 1000)) + ara[pos]);
}
return dp[pos][ase] = ret;
}
int main() {
int i, j, k, l, m;
memset(dp, -1, sizeof dp);
scanf("%d", &m);
for (i = 1; i <= m; i++) {
scanf("%d", &l);
if (l == 1000)
ara[++n] = l;
else {
ara[++n] = 2000;
}
}
long long ret = dp_func(1, 0);
cout << ret << endl;
}
| 10 | CPP |
#include <bits/stdc++.h>
const long long INF = 4e18L + 1;
const int IINF = 2e9 + 1;
using namespace std;
template <class TH>
void _dbg(const char *sdbg, TH h) {
cerr << sdbg << '=' << h << endl;
}
template <class TH, class... TA>
void _dbg(const char *sdbg, TH h, TA... a) {
while (*sdbg != ',') cerr << *sdbg++;
cerr << '=' << h << ',';
_dbg(sdbg + 1, a...);
}
const int N = 3e5, R = 30;
long long dp[N + 1][R + 1];
int n;
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
for (long long i = (long long)0; i < (long long)N + 1; i++) {
for (long long j = (long long)0; j < (long long)R + 1; j++) {
dp[i][j] = IINF;
}
}
dp[0][0] = 0;
cin >> n;
for (long long i = (long long)1; i < (long long)n + 1; i++) {
long long t1;
cin >> t1;
t1 /= 100;
for (long long j = (long long)0; j < (long long)R + 1; j++) {
if (j + t1 / 10 <= R) {
dp[i][j + t1 / 10] = min(dp[i][j + t1 / 10], dp[i - 1][j] + t1);
}
dp[i][j - min(j, t1)] =
min(dp[i][j - min(j, t1)], dp[i - 1][j] + t1 - min(j, t1));
}
}
cout << 100 * (*min_element(dp[n], dp[n] + R + 1)) << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int main() {
long n;
cin >> n;
int a[n];
long long b[n];
memset(b, 0, sizeof(b));
int t1 = 0;
for (long i = 0; i < n; i++) {
cin >> a[i];
a[i] = a[i] / 1000;
if (a[i] == 1) t1 = 1;
if (i == 0)
b[0] = a[0];
else
b[i] = b[i - 1] + a[i];
}
long long k = (b[n - 1] * 10) / 11;
k = min(k, b[n - 1] - a[n - 1]);
if (t1 == 0 && k % 2 == 1) k = k - 1;
long long t = b[n - 1] * 1000 - k * 100;
cout << t;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, a[N], sum[N], cnt[N];
int lf[N], rt[N];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cin >> n;
for (int i = (1); i <= (n); ++i) cin >> a[i], a[i] /= 1000;
for (int i = (1); i <= (n); ++i)
sum[i] = sum[i - 1] + a[i], cnt[i] = cnt[i - 1] + a[i] % 2;
for (int i = (1); i <= (n); ++i) {
if (a[i] == 1)
lf[i] = i;
else
lf[i] = lf[i - 1];
}
for (int i = n; i >= 1; --i) {
if (a[i] == 1)
rt[i] = i;
else
rt[i] = rt[i + 1];
}
int result = 2e9;
for (int s = (0); s <= (3 * n); ++s) {
if (sum[n] < s) break;
int l = 0, r = n + 1;
while (r - l > 1) {
int m = (l + r) / 2;
if (sum[m] <= s)
l = m;
else
r = m;
}
if (sum[l] == s) {
result = min(result, s * 10 + max((sum[n] - sum[l]) * 10 - s, 0));
continue;
}
if (rt[l + 1] > 0) {
int ps = rt[l + 1];
int bonus = sum[l];
int total = bonus * 10;
int here = sum[ps - 1] - sum[l];
total += max(here * 10 - bonus, 0);
bonus = -min(here * 10 - bonus, 0);
total += a[ps] * 10;
bonus += a[ps];
result = min(result, total + max((sum[n] - sum[ps]) * 10 - bonus, 0));
}
if (lf[r] > 0) {
int ps = lf[r];
int bonus = sum[ps - 1];
int total = bonus * 10;
total += max(a[ps] * 10 - bonus, 0);
bonus = -min(a[ps] * 10 - bonus, 0);
int here = sum[r] - sum[ps];
total += here * 10;
bonus += here;
result = min(result, total + max((sum[n] - sum[r]) * 10 - bonus, 0));
}
}
result *= 100;
cout << result << '\n';
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:268435456")
using namespace std;
template <typename T>
inline T abs(T a) {
return ((a < 0) ? -a : a);
}
template <typename T>
inline T sqr(T a) {
return a * a;
}
template <class T>
T gcd(T a, T b) {
return a ? gcd(b % a, a) : b;
}
template <class T>
T lcm(T a, T b) {
return a / gcd(a, b) * b;
}
template <class T>
T sign(T a) {
return a > 0 ? 1 : (a < 0 ? -1 : 0);
}
const int dx[] = {-1, 0, 1, 0};
const int dy[] = {0, 1, 0, -1};
const int dxK[] = {-1, -1, 0, 1, 1, 1, 0, -1};
const int dyK[] = {0, 1, 1, 1, 0, -1, -1, -1};
const int dxKn[] = {-2, -1, 1, 2, 2, 1, -1, -2};
const int dyKn[] = {1, 2, 2, 1, -1, -2, -2, -1};
const int N = int(300 * 1000) + 5;
const int M = int(10000) + 9;
const int LOGN = 21;
const int SQN = 350;
const int MOD = int(1e9) + 7;
const int INF = int(1e9) + 100;
const long long INF64 = 2e18;
const double PI = double(3.1415926535897932384626433832795);
const double e = double(2.7182818284590452353602874713527);
const double EPS = 1e-9;
int n;
int a[N];
int dp[N][36];
int calc(int pos, int s) {
int &res = dp[pos][s];
if (res != -1) return res;
res = INF;
if (pos == n) return res = 0;
if (s < 33) res = min(res, a[pos] + calc(pos + 1, s + a[pos] / 10));
int d = min(s, a[pos]);
res = min(res, a[pos] - d + calc(pos + 1, s - d));
return res;
}
void solve() {
cin >> n;
for (int i = 0; i < (int)(n); ++i) {
scanf("%d", a + i);
a[i] /= 100;
}
memset(dp, -1, sizeof dp);
cout << 100 * calc(0, 0);
}
int main() {
srand(time(NULL));
cout << setprecision(25) << fixed;
cerr << setprecision(25) << fixed;
solve();
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 3e5 + 7;
int data[N];
int main() {
int n;
scanf("%d", &n);
int cc = 0, sum = 0;
for (int i = (1); i < (n + 1); ++i) {
scanf("%d", &data[i]);
sum += data[i] / 1000;
if (data[i] == 1000) cc++;
}
int tmp = 10 * sum / 11;
if (sum <= 11) tmp = sum - data[n] / 1000;
if (!cc && (tmp & 1)) tmp--;
printf("%d\n", sum * 1000 - tmp * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
inline int read() {
int a = 0, po = 1;
char ch = getchar();
while (!isdigit(ch) && ch != '-') ch = getchar();
if (ch == '-') po = -1, ch = getchar();
while (isdigit(ch)) a = a * 10 + ch - '0', ch = getchar();
return a * po;
}
int n;
int x[300010];
int tot, ans, sum, bon;
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
x[i] = read();
}
for (int i = 1; i <= n; i++) {
sum += x[i] / 1000;
if (x[i] == 1000) tot++;
}
bon = sum * 10 / 11;
if (sum <= 11) bon = sum - x[n] / 1000;
if (bon % 2 != 0 && !tot) bon--;
cout << 1000 * sum - 100 * bon;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
void desperate_optimization(int precision) {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie(0);
cout.setf(ios::fixed);
cout.setf(ios::showpoint);
cout.precision(precision);
}
const int N = 3e5;
const int M = 32;
const int MAXN = 2e9;
int dp[M + 5][N + 5];
int arr[N + 5];
int n;
int solve(int duit, int idx) {
if (idx == n) return 0;
int &res = dp[duit][idx];
if (res != -1) return res;
res = MAXN;
if (duit + arr[idx] / 10 < M)
res = min(res, solve(duit + arr[idx] / 10, idx + 1) + arr[idx]);
for (int i = 1; i <= min(arr[idx], duit); i++) {
res = min(res, solve(duit - i, idx + 1) + arr[idx] - i);
}
return res;
}
void hora(int tc) {
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
arr[i] /= 100;
}
memset(dp, -1, sizeof dp);
cout << solve(0, 0) * 100 << '\n';
}
int main() {
desperate_optimization(10);
int ntc = 1;
for (int tc = 1; tc <= ntc; tc++) hora(tc);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1123456;
int x[MAX];
int n;
int solve(int a, int b) {
int k = 0, j = 0;
for (int i = 1; i <= n; i++) {
if (x[i] == 1000)
a--;
else
b--;
if (x[i] == 1000 && a >= 0 || x[i] == 2000 && b >= 0) {
k += x[i], j += x[i] / 10;
} else {
k += x[i] - min(x[i], j), j -= min(x[i], j);
}
}
return k;
}
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
sum += x[i];
}
int a = 0, b = 0, ans = sum;
for (int i = 1; i <= n; i++) {
sum -= x[i] / 10 * 11;
if (sum < 0) break;
if (x[i] == 1000)
a++;
else
b++;
}
ans = min(ans, solve(a, b));
ans = min(ans, solve(a + 1, b));
ans = min(ans, solve(a - 1, b + 1));
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 1000000007;
const long long linf = 1ll * inf * inf;
const int N = 300000 + 7;
const int M = 62;
const int multipleTest = 0;
int dp[N][M];
int n;
int a[N];
void solve() {
cin >> n;
for (int i = (0), _b = (N); i < _b; ++i)
for (int j = (0), _b = (M); j < _b; ++j) dp[i][j] = inf;
dp[0][0] = 0;
for (int i = (1), _b = (n + 1); i < _b; ++i) {
int u;
scanf("%d", &u);
u /= 100;
for (int j = 0; j < M; ++j) {
for (int t = 1, _m = min(u, j); t <= _m; ++t)
dp[i][j - t] = min(dp[i][j - t], dp[i - 1][j] + u - t);
if (j + u / 10 < M)
dp[i][j + u / 10] = min(dp[i][j + u / 10], dp[i - 1][j] + u);
}
}
int res = inf;
for (int j = (0), _b = (M); j < _b; ++j) res = min(res, dp[n][j]);
cout << res * 100;
}
int main() {
int Test = 1;
if (multipleTest) {
cin >> Test;
}
for (int i = 0; i < Test; ++i) {
solve();
}
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300005;
int n, m, ans, two, one, l, r, k, a[N], dp[N][205];
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &k);
a[i] = k / 100;
if (a[i] == 20)
two++;
else
one++;
}
memset(dp, 127, sizeof(dp));
dp[0][0] = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j <= 200; j++)
if (dp[i][j] <= 2e8) {
if (j + a[i + 1] / 10 <= 200)
dp[i + 1][j + a[i + 1] / 10] =
min(dp[i + 1][j + a[i + 1] / 10], dp[i][j] + a[i + 1]);
if (j >= a[i + 1])
dp[i + 1][j - a[i + 1]] = min(dp[i + 1][j - a[i + 1]], dp[i][j]);
else
dp[i + 1][0] = min(dp[i + 1][0], dp[i][j] + (a[i + 1] - j));
}
}
int ans = 2e9;
for (int i = 0; i <= 200; i++) {
ans = min(ans, dp[n][i]);
}
printf("%d00\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int n, t, s, coun, a[300010];
int main() {
cin >> n;
for (int i = 1; i <= n; i++) {
scanf("%d", &a[i]);
s += a[i] / 1000;
if (a[i] == 1000) {
coun++;
}
}
t = s * 10 / 11;
if (s <= 11) {
t = s - a[n] / 1000;
}
if (coun == 0 && (t & 1)) {
t--;
}
cout << s * 1000 - t * 100;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = .3e6 + 5;
const int X = 600 + 5;
int n;
int A[N], C[N];
int dp[2][X];
int main() {
ios::sync_with_stdio(0);
cin.tie(0);
cin >> n;
for (int i = 1; i <= n; i++) {
cin >> A[i];
A[i] /= 100;
C[i] = A[i] / 10;
}
for (int i = n; i >= 1; i--) {
int c = i % 2;
int p = 1 - c;
for (int j = 0; j < X; j++) {
int paid = min(j, A[i]);
dp[c][j] = A[i] - paid + dp[p][j - paid];
if (j + C[i] < X) {
dp[c][j] = min(dp[c][j], A[i] + dp[p][j + C[i]]);
}
}
}
cout << dp[1][0] * 100 << "\n";
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
#pragma comment(linker, "/STACK:667177216")
using namespace std;
const long long MOD = 1000000000 + 7;
long long D[3 * 100000 + 5][45];
long long rec(vector<int> &a, int pos, int have) {
if (pos == a.size()) return 0;
if (D[pos][have] != -1) return D[pos][have];
long long mini = 999999999999999999;
if (have == 0) {
return D[pos][have] = (a[pos] + rec(a, pos + 1, have + a[pos] / 1000));
}
if (have >= 42) {
return D[pos][have] = (a[pos] + rec(a, pos + 1, have - a[pos] / 100));
}
mini = a[pos] + rec(a, pos + 1, have + a[pos] / 1000);
for (int i = 1; i <= min(have, a[pos] / 100); ++i) {
mini = min(mini, a[pos] - i * 100 + rec(a, pos + 1, have - i));
}
return D[pos][have] = mini;
}
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
int n;
scanf("%d", &n);
vector<int> a(n);
for (int(i) = 0; (i) < n; (i)++) scanf("%d", &a[i]);
memset(D, -1, sizeof(D));
cout << rec(a, 0, 0);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int inf = 0x3f3f3f3f;
const double eps = 1e-8;
const int mod = 1000000007;
const double pi = acos(-1.0);
inline void gn(long long& x) {
int sg = 1;
char c;
while (((c = getchar()) < '0' || c > '9') && c != '-')
;
c == '-' ? (sg = -1, x = 0) : (x = c - '0');
while ((c = getchar()) >= '0' && c <= '9') x = x * 10 + c - '0';
x *= sg;
}
inline void gn(int& x) {
long long t;
gn(t);
x = t;
}
inline void gn(unsigned long long& x) {
long long t;
gn(t);
x = t;
}
long long gcd(long long a, long long b) { return a ? gcd(b % a, a) : b; }
long long powmod(long long a, long long x, long long mod) {
long long t = 1ll;
while (x) {
if (x & 1) t = t * a % mod;
a = a * a % mod;
x >>= 1;
}
return t;
}
const int maxn = 3e5 + 5;
int dp[maxn][55];
int main() {
int n;
gn(n);
memset(dp, 0x3f, sizeof(dp));
dp[0][0] = 0;
for (int i = (1); i <= (n); i++) {
int x;
gn(x);
x /= 100;
int bk = x / 10;
for (int j = (0); j <= (50); j++) {
if (j >= x)
dp[i][j - x] = min(dp[i][j - x], dp[i - 1][j]);
else {
int nd = x - j;
dp[i][0] = min(dp[i][0], dp[i - 1][j] + nd);
}
int up = min(50, j + bk);
dp[i][up] = min(dp[i][up], dp[i - 1][j] + x);
}
}
int ans = inf;
for (int i = (0); i <= (50); i++) ans = min(ans, dp[n][i]);
cout << ans * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int N = 300300;
const int INF = 2 * N;
int a[N];
bool b[N];
int n;
bool evaluate(int x) {
int bal = 0;
for (int i = 0; i < n; i++) {
if (b[i]) {
int val = min(bal, a[i]);
bal -= val;
x -= val;
} else {
bal += a[i] / 10;
}
}
return x <= 0;
}
bool suf(int x) {
int oldx = x;
for (int i = 0; i < n; i++) b[i] = 0;
for (int i = n - 1; x > 0 && i >= 0; i--) {
b[i] = 1;
x -= a[i];
}
return evaluate(oldx);
}
bool skip1(int x) {
int oldx = x;
for (int i = 0; i < n; i++) b[i] = 0;
for (int i = n - 1; x > 0 && i >= 0; i--) {
b[i] = 1;
x -= a[i];
}
int pos = 0;
while (pos < n && (a[pos] != 10 || !b[pos])) pos++;
if (pos == n) return false;
x += a[pos];
b[pos] = 0;
pos--;
while (pos >= 0 && b[pos]) pos--;
if (evaluate(oldx)) return true;
if (pos >= 0) {
b[pos] = 1;
}
return evaluate(oldx);
}
bool take1(int x) {
int oldx = x;
for (int i = 0; i < n; i++) b[i] = 0;
for (int i = n - 1; x > 0 && i >= 0; i--) {
if (x <= 20 && a[i] == 20) continue;
x -= a[i];
b[i] = 1;
}
return evaluate(oldx);
}
bool solve(int x) { return suf(x) || skip1(x) || take1(x); }
int main() {
scanf("%d", &n);
for (int i = 0; i < n; i++) {
scanf("%d", &a[i]);
a[i] /= 100;
}
int l = 0, r = INF;
while (r - l > 1) {
int x = (l + r) / 2;
if (solve(x))
l = x;
else
r = x;
}
int ans = -l;
for (int i = 0; i < n; i++) ans += a[i];
printf("%d\n", ans * 100);
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
const int MAX = 1123456;
int x[MAX];
int n;
int solve(int a, int b) {
int k = 0, j = 0;
for (int i = 1; i <= n; i++) {
if (x[i] == 1000)
a--;
else
b--;
if (x[i] == 1000 && a >= 0 || x[i] == 2000 && b >= 0) {
k += x[i], j += x[i] / 10;
} else {
k += x[i] - min(x[i], j), j -= min(x[i], j);
}
}
return k;
}
int main() {
scanf("%d", &n);
int sum = 0;
for (int i = 1; i <= n; i++) {
scanf("%d", x + i);
sum += x[i];
}
int a = 0, b = 0, ans = sum;
for (int i = 1; i <= n; i++) {
sum -= x[i] / 10 * 11;
if (sum < 0) break;
if (x[i] == 1000)
a++;
else
b++;
}
ans = min(ans, solve(a, b));
ans = min(ans, solve(a + 1, b));
ans = min(ans, solve(a, b + 1));
ans = min(ans, solve(a - 1, b + 1));
printf("%d\n", ans);
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int Total;
int Array[400001];
int Sum, Count;
int main(void) {
register int i;
cin >> Total;
for (i = 1; i <= Total; i++) {
cin >> Array[i];
Sum += Array[i] / 1000;
Count += (Array[i] == 1000);
}
register int Tmp;
Tmp = Sum * 10 / 11;
if (Sum <= 11) {
Tmp = Sum - Array[Total] / 1000;
}
if (!Count && Tmp % 2 == 1) {
Tmp--;
}
cout << Sum * 1000 - Tmp * 100 << endl;
return 0;
}
| 10 | CPP |
#include <bits/stdc++.h>
using namespace std;
int const N = 3e5 + 10;
int dp[2][40];
int cost[N];
int n;
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%d", &cost[i]);
cost[i] /= 100;
}
int now = 0;
for (int _ = 0; _ <= 30; _++) dp[now][_] = 0x3f3f3f3f;
dp[now][0] = 0;
for (int i = 1; i <= n; i++) {
now ^= 1;
for (int _ = 0; _ <= 30; _++) dp[now][_] = 0x3f3f3f3f;
for (int j = 0; j <= 30; j++) {
for (int k = min(30, j + cost[i]); k > j; k--) {
dp[now][j] = min(dp[now][j], dp[now ^ 1][k] + cost[i] - (k - j));
}
if (j >= cost[i] / 10)
dp[now][j] = min(dp[now][j], dp[now ^ 1][j - cost[i] / 10] + cost[i]);
}
}
int ans = 0x3f3f3f3f;
for (int i = 0; i <= 30; i++) ans = min(ans, dp[now][i]);
printf("%d", ans * 100);
return 0;
}
| 10 | CPP |
Subsets and Splits