text stringlengths 49 983k |
|---|
#include <iostream>
int main()
{
int h, w;
for (;;) {
std::cin >> h >> w;
if (h == 0 && w == 0) break;
for (int i=0; i!=h; ++i) {
for (int j=0; j!=w; ++j) {
if ((i+j)%2 == 0) std::cout << '#';
else std::cout << '.';
}
std::cout << '\n';
}
std::cout << '\n';
}
} |
#include <iostream>
using namespace std;
int main() {
int H,W,i,j;
while (cin>>H>>W && (H!=0 || W!=0)) {
for (i=0;i<H;i++) {
for (j=0;j<W;j++) {
cout << ((i+j)%2==0?'#':'.');
}
cout<<endl;
}
cout<<endl;
}
return 0;
} |
#include<bits/stdc++.h>
using namespace std;
int main(){
long long w,h,i,j;
while(1){
cin>>w>>h;
if(w==0 && h==0) break;
for(i=1;i<=w;i++){
for(j=1;j<=h;j++){
if((i+j)%2==0) cout<<"#";
else cout<<".";
}
cout<<"\n";
}
cout<<"\n";
}
}
|
#include<iostream>
using namespace std;
int main(){
while(true){
int h,w;
cin>>h>>w;
if(h==0&&w==0)
return 0;
for(int i=0;i<h;i++){
for(int j=0;j<w;j++){
if((i%2==0&&j%2==0)||(i%2==1&&j%2==1))
cout<<'#';
else
cout<<'.';
}
cout<<'\n';
}
cout<<'\n';
}
} |
#include <iostream>
using namespace std;
int main() {
int H, W;
cin >> H >> W;
while (H != 0 && W != 0)
{
for (int i = 1; i <= H; i++) {
for (int j = 1; j <= W; j++) {
if ((i+j)%2 == 0) cout << "#";
else cout << ".";
}
cout << endl;
}
cout << endl;
cin >> H >> W;
}
return 0;
}
|
#include<iostream>
using namespace std;
int main(){
int a,b;
while(true){
cin>>a>>b;
if(a==0 && b==0)break;
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
if(0==(j+i)%2){
cout<<"#";
}
else{
cout<<".";
}
}
cout<<endl;
}
cout<<endl;
}
} |
#include<iostream>
using namespace std;
int main(){
int a,b;
cin>>a>>b;
while(a!=0 and b!=0){
for(int i=0;i<a;i++){
for(int j=0;j<b;j++){
if((i+j)%2==0)cout<<'#';
else cout<<'.';
}
cout<<endl;
}
cout<<endl;
cin>>a>>b;
}
return 0;
}
|
#include <iostream>
using namespace std;
int main(){
int H,W;
while(1){
cin >> H >> W;
if(H == 0 && W == 0)break;
for(int i = 1;i <= H;i++){
for(int j = 1;j <= W;j++){
if((i+j)%2 == 0)cout << "#";
else{cout << ".";}
}
cout << endl;
}
cout << endl;
}
return 0;
} |
#include<iostream>
using namespace std;
int main(){
int H,W;
cin>>H>>W;
while(H!=0&&W!=0){
for(int i=0;i<H;i++){
for(int j=0;j<W;j++){
if((i+j)%2==0){
cout<<'#';
}else{
cout<<'.';
}
}
cout<<endl;
}
cout<<endl;
cin>>H>>W;
}
return 0;
} |
#include <iostream>
using namespace std;
int main(){
int h, w;
while (cin >> h >> w && h) {
for (int i=0; i<h; i++) {
for (int j=0; j<w; j++)
cout << ((i+j)%2 ? '.' : '#');
cout << endl;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int main(){
while(1){
int H,W;
cin >> H >> W;
if(H==0 && W==0) break;
for(int i=0; i<H; i++){
for(int j=0; j<W; j++){
if((i+j)%2 == 0) cout << "#";
else cout << ".";
}
cout << endl;
}
cout << endl;
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 201;
const int T = 201;
int n, t;
long long z;
long long a[N], b[N], c[N];
long long pa[N], pb[N];
bool cl1[N][T], cl2[N][T];
long long mr1[N][T], mr2[N][T];
long long dp1[N][T], dp2[N][T];
int main() {
ios::sync_with_stdio(false);
cin.tie(0);
cin >> n >> t >> z;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
pa[i] = pa[i - 1] + a[i];
pb[i] = pb[i - 1] + b[i];
}
for (int i = 0; i <= t; i++) cl1[0][i] = cl2[0][i] = true;
for (int i = 1; i <= n; i++) {
cl2[i][0] = true;
mr2[i][0] = 0;
for (int j = 1; j <= t; j++) {
mr2[i][j] = -1;
for (int k = 0; k < j; k++) {
if (mr2[i][k] == -1) continue;
if (!cl2[i - 1][j - k]) continue;
long long mn = mr2[i][k] % z, mx = mr2[i][k];
long long rm =
mn + pb[i] * (j - k) - (pb[i - 1] * (j - k) + z - 1) / z * z;
mn += (j - k) * b[i];
mx += (j - k) * b[i];
if (rm < 0) mn += z, rm += z;
if (mn > mx) continue;
if (mn > c[i]) continue;
if (mx > c[i]) {
long long f = mx - c[i];
f = (f + z - 1) / z;
mx -= f * z;
}
mx = mx - mn + rm;
mn = rm;
mr2[i][j] = max(mr2[i][j], mx);
}
}
for (int j = 1; j <= t; j++) {
if (cl2[i - 1][j]) {
if (b[i] * j <= c[i]) cl2[i][j] = true;
}
for (int k = 0; k < j; k++) {
if (mr2[i][k] == -1) continue;
if (!cl2[i - 1][j - k]) continue;
if (mr2[i][k] % z + (j - k) * b[i] <= c[i]) cl2[i][j] = true;
}
}
for (int j = 0; j <= t; j++) {
mr1[i][j] = -1;
if (cl1[i - 1][j]) {
if (a[i] + b[i] * j <= c[i]) {
long long rm =
pa[i] + pb[i] * j - (pa[i - 1] + pb[i - 1] * j + z - 1) / z * z;
if (rm >= 0) mr1[i][j] = rm;
}
}
for (int k = 0; k < j; k++) {
if (mr1[i][k] == -1) continue;
if (!cl2[i - 1][j - k]) continue;
long long mn = mr1[i][k] % z, mx = mr1[i][k];
long long rm =
mn + pb[i] * (j - k) - (pb[i - 1] * (j - k) + z - 1) / z * z;
mn += (j - k) * b[i];
mx += (j - k) * b[i];
if (rm < 0) mn += z, rm += z;
if (mn > mx) continue;
if (mn > c[i]) continue;
if (mx > c[i]) {
long long f = mx - c[i];
f = (f + z - 1) / z;
mx -= f * z;
}
mx = mx - mn + rm;
mn = rm;
mr1[i][j] = max(mr1[i][j], mx);
}
}
for (int j = 0; j <= t; j++) {
if (cl1[i - 1][j]) {
if (a[i] + b[i] * j <= c[i]) cl1[i][j] = true;
}
for (int k = 0; k < j; k++) {
if (mr1[i][k] == -1) continue;
if (!cl2[i - 1][j - k]) continue;
if (mr1[i][k] % z + (j - k) * b[i] <= c[i]) cl1[i][j] = true;
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= t; j++) {
dp2[i][j] = 1e18;
if (j * b[i] <= c[i]) {
dp2[i][j] = dp2[i - 1][j];
continue;
}
for (int k = 1; k <= j; k++) {
if (cl2[i][k]) {
long long cost = (pb[i] * k + z - 1) / z;
dp2[i][j] = min(dp2[i][j], dp2[i][j - k] + cost);
}
}
for (int k = 1; k <= j; k++) {
if (mr2[i][k] != -1) {
if (mr2[i][k] % z + (j - k) * b[i] > c[i]) continue;
long long cost = (pb[i] * k - mr2[i][k]) / z;
long long f = mr2[i][k] + (j - k) * b[i] - c[i];
if (f > 0) {
cost += (f + z - 1) / z;
}
dp2[i][j] = min(dp2[i][j], dp2[i - 1][j - k] + cost);
}
}
}
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
dp1[i][j] = 1e18;
if (a[i] + j * b[i] <= c[i]) {
dp1[i][j] = dp1[i - 1][j];
continue;
}
for (int k = 0; k <= j; k++) {
if (cl1[i][k]) {
long long cost = (pb[i] * k + pa[i] + z - 1) / z;
dp1[i][j] = min(dp1[i][j], dp2[i][j - k] + cost);
}
}
for (int k = 0; k <= j; k++) {
if (mr1[i][k] != -1) {
if (mr1[i][k] % z + (j - k) * b[i] > c[i]) continue;
long long cost = (pa[i] + pb[i] * k - mr1[i][k]) / z;
long long f = mr1[i][k] + (j - k) * b[i] - c[i];
if (f > 0) {
cost += (f + z - 1) / z;
}
dp1[i][j] = min(dp1[i][j], dp2[i - 1][j - k] + cost);
}
}
}
}
cout << dp1[n][t] << '\n';
}
|
#include <bits/stdc++.h>
using std::max;
using std::min;
const int inf = 0x3f3f3f3f, Inf = 0x7fffffff;
const long long INF = 0x3f3f3f3f3f3f3f3f;
std::mt19937 rnd(std::chrono::steady_clock::now().time_since_epoch().count());
template <typename _Tp>
_Tp gcd(const _Tp &a, const _Tp &b) {
return !b ? a : gcd(b, a % b);
}
template <typename _Tp>
inline _Tp abs(const _Tp &a) {
return a >= 0 ? a : -a;
}
template <typename _Tp>
inline void chmax(_Tp &a, const _Tp &b) {
a = a < b ? b : a;
}
template <typename _Tp>
inline void chmin(_Tp &a, const _Tp &b) {
a = a < b ? a : b;
}
template <typename _Tp>
inline void read(_Tp &x) {
char ch(getchar());
bool f(false);
while (!isdigit(ch)) f |= ch == 45, ch = getchar();
x = ch & 15, ch = getchar();
while (isdigit(ch)) x = (((x << 2) + x) << 1) + (ch & 15), ch = getchar();
f && (x = -x);
}
template <typename _Tp, typename... Args>
void read(_Tp &t, Args &...args) {
read(t);
read(args...);
}
inline int read_str(char *s) {
char ch(getchar());
while (ch == ' ' || ch == '\r' || ch == '\n') ch = getchar();
char *tar = s;
*tar++ = ch, ch = getchar();
while (ch != ' ' && ch != '\r' && ch != '\n' && ch != EOF)
*tar++ = ch, ch = getchar();
return *tar = 0, tar - s;
}
const int N = 205;
long long a[N], b[N], c[N], sa[N], sb[N], sc[N], f[N][N][2], g[N][N][2];
int main() {
int n, t, s;
read(n, t, s);
for (int i = 1; i <= n; ++i) read(a[i], b[i], c[i]);
a[n + 1] = 1e18, c[n + 1] = 1e18;
for (int i = 1; i <= n + 1; ++i)
sa[i] = a[i] + sa[i - 1], sb[i] = b[i] + sb[i - 1],
sc[i] = c[i] + sc[i - 1];
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) f[0][j][k] = g[0][j][k] = 0;
for (int i = 1; i <= n + 1; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) {
if (f[i - 1][j][k] < INF && k * a[i] + j * b[i] <= c[i]) {
chmin(f[i][j][k], f[i - 1][j][k]);
long long need = (k * sa[i - 1] + j * sb[i - 1] + s - 1) / s;
if (need * s <= k * sa[i] + j * sb[i]) chmin(g[i][j][k], need);
}
for (int r = 0; r < j; ++r)
if (g[i][r][k] < INF && f[i - 1][j - r][0] < INF) {
long long qwq = k * sa[i] + r * sb[i] - s * g[i][r][k];
long long need =
(max(qwq + (j - r) * b[i] - c[i], 0LL) + s - 1) / s;
if (need * s <= qwq) {
chmin(f[i][j][k], g[i][r][k] + need + f[i - 1][j - r][0]);
long long NEED = ((j - r) * sb[i - 1] + s - 1) / s;
if (NEED * s <= (j - r) * sb[i] + qwq + c[i] - need * s)
chmin(g[i][j][k], g[i][r][k] + need + NEED);
}
}
}
printf("%lld\n", f[n + 1][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
inline int read() {
int data = 0, w = 1;
char ch = getchar();
while (ch != '-' && (ch < '0' || ch > '9')) ch = getchar();
if (ch == '-') w = -1, ch = getchar();
while (ch >= '0' && ch <= '9') data = data * 10 + (ch ^ 48), ch = getchar();
return data * w;
}
using ll = long long;
template <typename T>
inline void chkmin(T &x, const T &y) {
if (y < x) x = y;
}
const ll INF(0x3f3f3f3f3f3f3f3fll);
const int N(205);
int n, t, K;
ll a[N], b[N], c[N], sa[N], sb[N], f[N][N][2], g[N][N][2];
int main() {
n = read(), t = read(), K = read();
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read(), c[i] = read();
++n, a[n] = b[n] = 2e9, c[n] = INF;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
std::memset(f, 0x3f, sizeof f), std::memset(g, 0x3f, sizeof g);
std::memset(*f, 0, sizeof *f), std::memset(*g, 0, sizeof *g);
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k < 2; k++) {
if (k * a[i] + j * b[i] <= c[i] && f[i - 1][j][k] != INF) {
chkmin(f[i][j][k], f[i - 1][j][k]);
ll c = (k * sa[i - 1] + j * sb[i - 1] + K - 1) / K;
if (c * K <= k * sa[i] + j * sb[i]) chkmin(g[i][j][k], c);
}
for (int l = 0; l < j; l++)
if (g[i][l][k] != INF) {
ll res = k * sa[i] + l * sb[i] - K * g[i][l][k],
cnt = (std::max(res + (j - l) * b[i] - c[i], 0ll) + K - 1) / K;
if (cnt * K <= res && f[i - 1][j - l][0] != INF) {
chkmin(f[i][j][k], g[i][l][k] + cnt + f[i - 1][j - l][0]);
ll c = ((j - l) * sb[i - 1] + K - 1) / K;
if (c * K <= (j - l) * sb[i] + res - cnt * K)
chkmin(g[i][j][k], g[i][l][k] + cnt + c);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long M = 305, inf = 1e18;
long long read() {
long long x = 0, y = 1;
char ch = getchar();
while (ch < '0' || ch > '9') y = (ch == '-') ? -1 : 1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * y;
}
long long a[M], b[M], c[M], sa[M], sb[M], f[M][M][2], g[M][M][2];
signed main() {
long long n = read(), t = read(), k = read();
for (long long i = 1; i <= n; i++)
a[i] = read(), b[i] = read(), c[i] = read();
++n;
a[n] = c[n] = inf;
for (long long i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= t; j++)
for (long long fl = 0; fl <= 1; fl++) {
f[i][j][fl] = g[i][j][fl] = inf;
if (j * b[i] + fl * a[i] <= c[i] && f[i - 1][j][fl] != inf) {
f[i][j][fl] = f[i - 1][j][fl];
long long v = (fl * sa[i - 1] + j * sb[i - 1] + k - 1) / k;
if (v * k <= fl * sa[i] + j * sb[i]) g[i][j][fl] = v;
}
for (long long l = 0; l <= j - 1; l++)
if (g[i][l][fl] < inf) {
long long v1 = fl * sa[i] + l * sb[i] - k * g[i][l][fl];
long long v2 = (max(v1 + (j - l) * b[i] - c[i], 0ll) + k - 1) / k;
if (v2 * k <= v1 && f[i - 1][j - l][0] < inf) {
f[i][j][fl] =
min(f[i][j][fl], g[i][l][fl] + v2 + f[i - 1][j - l][0]);
long long v = ((j - l) * sb[i - 1] + k - 1) / k;
if (v * k <= (j - l) * sb[i] + v1 - v2 * k)
g[i][j][fl] = min(g[i][j][fl], g[i][l][fl] + v2 + v);
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSTAT = 200 + 1;
const int MAXT = 200;
int nstat, tend;
long long cap;
long long init[MAXSTAT], delta[MAXSTAT], lim[MAXSTAT];
long long suminit[MAXSTAT + 1], sumdelta[MAXSTAT + 1];
long long dp[MAXSTAT + 1][MAXT + 1][2][2];
void upd(long long &a, const long long b) {
if (b < a) a = b;
}
long long solve() {
init[nstat] = delta[nstat] = cap, lim[nstat] = (tend + 1) * cap, ++nstat;
suminit[0] = 0;
for (int i = (0); i < (nstat); ++i) suminit[i + 1] = suminit[i] + init[i];
sumdelta[0] = 0;
for (int i = (0); i < (nstat); ++i) sumdelta[i + 1] = sumdelta[i] + delta[i];
for (int i = (0); i <= (nstat); ++i)
for (int j = (0); j <= (tend); ++j)
for (int x = (0); x < (2); ++x)
for (int y = (0); y < (2); ++y) dp[i][j][x][y] = LLONG_MAX;
for (int j = (0); j <= (tend); ++j)
for (int y = (0); y < (2); ++y) dp[0][j][0][y] = 0;
for (int i = (0); i <= (nstat); ++i)
for (int y = (0); y < (2); ++y) dp[i][0][0][y] = 0;
for (int i = (1); i <= (nstat); ++i)
for (int j = (1); j <= (tend); ++j)
for (int y = (0); y < (2); ++y) {
if (y * init[i - 1] + (j - 1) * delta[i - 1] <= lim[i - 1] &&
dp[i - 1][j - 1][0][y] != LLONG_MAX) {
long long have = y * init[i - 1] + (j - 1) * delta[i - 1], cost = 0;
assert(have <= lim[i - 1]);
long long rembefore = y * suminit[i - 1] + (j - 1) * sumdelta[i - 1] -
dp[i - 1][j - 1][0][y] * cap;
assert(rembefore >= 0);
cost += rembefore / cap + 1;
long long now = cap * cost - rembefore;
assert(now > 0 && now <= cap);
if (now <= have) upd(dp[i][j][1][y], dp[i - 1][j - 1][0][y] + cost);
}
for (int jj = (1); jj <= (j - 1); ++jj)
if (dp[i][jj][1][y] != LLONG_MAX &&
dp[i - 1][j - jj][0][0] != LLONG_MAX) {
long long have =
y * suminit[i] + (jj - 1) * sumdelta[i] - dp[i][jj][1][y] * cap;
assert(have >= 0 && have <= lim[i - 1]);
long long dhave = (j - jj) * delta[i - 1], cost1 = 0;
if (have + dhave > lim[i - 1]) {
cost1 = (have + dhave - lim[i - 1] + cap - 1) / cap;
if (cost1 * cap > have) continue;
have -= cost1 * cap;
}
have += dhave;
assert(have <= lim[i - 1]);
long long rembefore =
(j - jj) * sumdelta[i - 1] - dp[i - 1][j - jj][0][0] * cap;
assert(rembefore >= 0);
long long cost2 = rembefore / cap + 1;
long long now = cap * cost2 - rembefore;
assert(now > 0 && now <= cap);
if (now <= have)
upd(dp[i][j][1][y],
dp[i][jj][1][y] + dp[i - 1][j - jj][0][0] + cost1 + cost2);
}
if (y * init[i - 1] + j * delta[i - 1] <= lim[i - 1] &&
dp[i - 1][j][0][y] != LLONG_MAX) {
upd(dp[i][j][0][y], dp[i - 1][j][0][y]);
}
for (int jj = (y == 0 ? 2 : 1); jj <= (j); ++jj)
if (dp[i][jj][1][y] != LLONG_MAX &&
dp[i][j - jj + 1][0][0] != LLONG_MAX) {
long long have = y * suminit[i] + (jj - 1) * sumdelta[i] -
dp[i][jj][1][y] * cap,
cost = 0;
assert(have >= 0 && have <= lim[i - 1]);
long long dhave = (j - jj + 1) * delta[i - 1];
if (have + dhave > lim[i - 1]) {
long long dcost = (have + dhave - lim[i - 1] + cap - 1) / cap;
if (dcost * cap > have) continue;
have -= dcost * cap, cost += dcost;
}
have += dhave;
assert(have <= lim[i - 1]);
upd(dp[i][j][0][y],
dp[i][jj][1][y] + dp[i][j - jj + 1][0][0] + cost);
}
}
return dp[nstat][tend][0][1];
}
void run() {
scanf("%d%d%lld", &nstat, &tend, &cap);
for (int i = (0); i < (nstat); ++i)
scanf("%lld%lld%lld", &init[i], &delta[i], &lim[i]);
long long ans = solve();
printf("%lld\n", ans == LLONG_MAX ? -1 : ans);
}
int myrand() {
return rand() % 1000 * 1000000 + rand() % 1000 * 1000 + rand() % 1001;
}
void stress() {
for (int rep = (0); rep < (1000); ++rep) {
nstat = 200, tend = 200, cap = myrand();
if (cap == 0) ++cap;
for (int i = (0); i < (nstat); ++i) {
init[i] = myrand(), delta[i] = myrand(), lim[i] = myrand();
if (init[i] > lim[i]) swap(init[i], lim[i]);
if (delta[i] > lim[i]) swap(delta[i], lim[i]);
}
solve();
printf(".");
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _ = 200 + 7;
const long long inf = 1e15;
int n, T, K;
long long a[_], b[_], c[_], sa[_], sb[_], d[_][_][2], g[_][_][2];
long long Ceil(long long x, long long y) { return x % y ? x / y + 1 : x / y; }
void upd(long long &x, long long y) { x = min(x, y); }
int main() {
cin >> n >> T >> K;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
a[++n] = inf, c[n] = inf;
sa[n] = sa[n - 1] + a[n];
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) d[p][s][z] = g[p][s][z] = inf;
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) {
if (z * a[p] + s * b[p] <= c[p] and d[p - 1][s][z] != inf) {
upd(d[p][s][z], d[p - 1][s][z]);
long long num = Ceil(z * sa[p - 1] + s * sb[p - 1], K);
if (num * K <= z * sa[p] + s * sb[p]) upd(g[p][s][z], num);
}
for (int r = 0; r < s; ++r)
if (g[p][r][z] != inf and d[p - 1][s - r][0] != inf) {
long long m = z * sa[p] + r * sb[p] - K * g[p][r][z];
long long x = Ceil(max(0ll, m + (s - r) * b[p] - c[p]), K);
if (K * x <= m) {
upd(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long num = Ceil((s - r) * sb[p - 1], K);
if (num * K <= m - K * x + (s - r) * sb[p])
upd(g[p][s][z], g[p][r][z] + x + num);
}
}
}
cout << d[n][T][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
const long long INF = 1e18;
template <typename T>
void chkmax(T& x, T y) {
x = x > y ? x : y;
}
template <typename T>
void chkmin(T& x, T y) {
x = x < y ? x : y;
}
template <typename T>
void read(T& x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int n, t, x;
long long a[MAXN], b[MAXN], c[MAXN], sa[MAXN], sb[MAXN], sc[MAXN],
f[MAXN][MAXN][2], g[MAXN][MAXN][2];
long long divx(long long a) {
if (a <= 0)
return 0;
else
return (a - 1) / x + 1;
}
int main(void) {
read(n), read(t), read(x);
for (int i = 1; i <= n; i++) {
read(a[i]), sa[i] = sa[i - 1] + a[i];
read(b[i]), sb[i] = sb[i - 1] + b[i];
read(c[i]), sc[i] = sc[i - 1] + c[i];
}
n++, a[n] = c[n] = INF, b[n] = 0;
sa[n] = sa[n - 1] + a[n];
sb[n] = sb[n - 1] + b[n];
sc[n] = sc[n - 1] + c[n];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int t = 0; t <= 1; t++) {
f[i][j][t] = g[i][j][t] = INF;
if (a[i] * t + b[i] * j <= c[i] && f[i - 1][j][t] != INF) {
f[i][j][t] = f[i - 1][j][t];
g[i][j][t] = divx(sa[i - 1] * t + sb[i - 1] * j);
if (g[i][j][t] * x > sa[i] + sb[i] * j) g[i][j][t] = INF;
}
for (int k = 0; k <= j - 1; k++)
if (g[i][k][t] != INF) {
long long lft = sa[i] * t + sb[i] * k - g[i][k][t] * x,
cnt = divx(b[i] * (j - k) + lft - c[i]);
if ((g[i][k][t] + cnt) * x > sa[i] * t + sb[i] * k) continue;
chkmin(f[i][j][t], g[i][k][t] + cnt + f[i - 1][j - k][0]);
long long tmp = divx(sb[i - 1] * (j - k));
if (f[i - 1][j - k][0] != INF &&
(g[i][k][t] + cnt + tmp) * x <= sa[i] * t + sb[i] * j)
chkmin(g[i][j][t], g[i][k][t] + cnt + tmp);
}
}
writeln(f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
using ll = long long;
const long long inf = 2147383647;
const double pi = 2 * acos(0.0);
const double eps = 1e-9;
mt19937 rng(std::chrono::duration_cast<std::chrono::nanoseconds>(
chrono::high_resolution_clock::now().time_since_epoch())
.count());
template <typename S, typename T>
void xmin(S& a, T const& b) {
if (b < a) a = b;
}
template <typename S, typename T>
void xmax(S& a, T const& b) {
if (b > a) a = b;
}
struct debugger {
template <typename T>
debugger& operator,(const T& v) {
cerr << v << " ";
return *this;
}
} dbg;
inline long long gcd(long long a, long long b) {
a = ((a) < 0 ? -(a) : (a));
b = ((b) < 0 ? -(b) : (b));
while (b) {
a = a % b;
swap(a, b);
}
return a;
}
long long ext_gcd(long long A, long long B, long long* X, long long* Y) {
long long x2, y2, x1, y1, x, y, r2, r1, q, r;
x2 = 1;
y2 = 0;
x1 = 0;
y1 = 1;
for (r2 = A, r1 = B; r1 != 0;
r2 = r1, r1 = r, x2 = x1, y2 = y1, x1 = x, y1 = y) {
q = r2 / r1;
r = r2 % r1;
x = x2 - (q * x1);
y = y2 - (q * y1);
}
*X = x2;
*Y = y2;
return r2;
}
inline long long modInv(long long a, long long m) {
long long x, y;
ext_gcd(a, m, &x, &y);
x %= m;
if (x < 0) x += m;
return x;
}
inline long long power(long long a, long long p) {
long long res = 1, x = a;
while (p) {
if (p & 1) res = (res * x);
x = (x * x);
p >>= 1;
}
return res;
}
inline long long bigmod(long long a, long long p, long long m) {
long long res = 1 % m, x = a % m;
while (p) {
if (p & 1) res = (res * x) % m;
x = (x * x) % m;
p >>= 1;
}
return res;
}
signed gen(int T) {
auto get_rand = [&](int64_t l, int64_t r) {
return uniform_int_distribution<int64_t>(l, r)(rng);
};
ofstream o("gen.txt");
const int N = T;
T = 1;
o << T << "\n";
for (int cas = 0; cas < T; ++cas) {
o << "\n";
int n = get_rand(1, N), t = get_rand(1, N), k = get_rand(1, N);
o << n << ' ' << t << ' ' << k << "\n";
for (long long i = (1); i <= (n); ++i) {
int a = get_rand(0, N), b = get_rand(0, N),
c = get_rand(((a) > (b) ? (a) : (b)), N);
o << a << ' ' << b << ' ' << c << "\n";
}
}
o << endl;
o.close();
return 0;
}
const int N = 200;
const long long INF = inf << 30;
long long dp[N + 2][N + 1][2], dp2[N + 2][N + 1][2], A[N + 2], B[N + 2],
C[N + 2], SA[N + 2], SB[N + 2], SC[N + 2];
signed main() {
cin.tie(0);
cout.tie(0);
ios_base::sync_with_stdio(false);
int n, t, K;
cin >> n >> t >> K;
for (long long i = (1); i <= (n); ++i) {
cin >> A[i] >> B[i] >> C[i];
SA[i] = SA[i - 1] + A[i];
SB[i] = SB[i - 1] + B[i];
SC[i] = SC[i - 1] + C[i];
}
A[n + 1] = INF;
B[n + 1] = 0;
C[n + 1] = 2 * INF;
SA[n + 1] = SA[n] + A[n + 1];
SB[n + 1] = SB[n] + B[n + 1];
SC[n + 1] = SC[n] + C[n + 1];
memset(dp, -1, sizeof(dp));
memset(dp2, -1, sizeof(dp2));
for (long long i = (0); i <= (n + 1); ++i) {
for (long long j = (0); j <= (t); ++j) {
for (long long k = (0); k <= (1); ++k) {
if (i == 0) {
dp[i][j][k] = dp2[i][j][k] = 0;
} else {
if (k * A[i] + j * B[i] <= C[i]) {
if (dp[i - 1][j][k] != -1) {
dp[i][j][k] = dp[i - 1][j][k];
long long val = (k * SA[i - 1] + j * SB[i - 1] + K - 1) / K;
if (val * K <= k * SA[i] + j * SB[i]) {
dp2[i][j][k] = val;
}
}
}
for (long long jj = (0); jj <= (j - 1); ++jj) {
long long aux = dp2[i][jj][k];
if (aux != -1) {
long long rem = k * SA[i] + jj * SB[i] - K * aux,
val = (((0) > (rem + (j - jj) * B[i] - C[i])
? (0)
: (rem + (j - jj) * B[i] - C[i])) +
K - 1) /
K;
if (val * K <= rem) {
if (dp[i - 1][j - jj][0] != -1) {
long long newValue = aux + val + dp[i - 1][j - jj][0];
if (dp[i][j][k] == -1 || dp[i][j][k] > newValue) {
dp[i][j][k] = newValue;
}
long long x = ((j - jj) * SB[i - 1] + K - 1) / K;
if (x * K <= (j - jj) * SB[i] + rem - val * K) {
newValue = aux + val + x;
if (dp2[i][j][k] == -1 || dp2[i][j][k] > newValue) {
dp2[i][j][k] = newValue;
}
}
}
}
}
}
}
}
}
}
long long res = dp[n + 1][t][1];
cout << res << "\n";
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long int MAXN = 251, inf = 1e16;
long long int n, m, t, kk, rr, rx;
long long int x[MAXN], y[MAXN], v[MAXN], px[MAXN], py[MAXN];
long long int d[MAXN][MAXN][2], g[MAXN][MAXN][2];
inline long long int read() {
register long long int num = 0, neg = 1;
register char ch = getchar();
while (!isdigit(ch) && ch != '-') {
ch = getchar();
}
if (ch == '-') {
neg = -1;
ch = getchar();
}
while (isdigit(ch)) {
num = (num << 3) + (num << 1) + (ch - '0');
ch = getchar();
}
return num * neg;
}
inline long long int ceil(long long int x, long long int y) {
return x / y + !!(x % y);
}
inline void chkmin(long long int &x, long long int y) { x = x < y ? x : y; }
int main() {
n = read(), t = read(), kk = read();
for (register int i = 1; i <= n; i++) {
x[i] = read(), y[i] = read(), v[i] = read();
px[i] = px[i - 1] + x[i], py[i] = py[i - 1] + y[i];
}
x[++n] = inf, v[n] = inf, px[n] = px[n - 1] + x[n];
for (register int p = 1; p <= n; p++) {
for (register int s = 0; s <= t; s++) {
d[p][s][0] = d[p][s][1] = g[p][s][0] = g[p][s][1] = inf;
}
}
for (register int p = 1; p <= n; p++) {
for (register int s = 0; s <= t; s++) {
for (register int z = 0; z <= 1; z++) {
if (d[p - 1][s][z] != inf && z * x[p] + s * y[p] <= v[p]) {
chkmin(d[p][s][z], d[p - 1][s][z]);
rr = ceil(z * px[p - 1] + s * py[p - 1], kk);
rr *kk <= z *px[p] + s *py[p] ? chkmin(g[p][s][z], rr) : (void)1;
}
for (register int r = 0; r < s; r++) {
if (g[p][r][z] != inf && d[p - 1][s - r][0] != inf) {
m = z * px[p] + r * py[p] - kk * g[p][r][z];
rr = ceil(max(0ll, m + (s - r) * y[p] - v[p]), kk);
if (kk * rr <= m) {
chkmin(d[p][s][z], g[p][r][z] + rr + d[p - 1][s - r][0]);
rx = ceil((s - r) * py[p - 1], kk);
if (rx * kk <= m - kk * rr + (s - r) * py[p]) {
chkmin(g[p][s][z], g[p][r][z] + rx + rr);
}
}
}
}
chkmin(d[p][s][z], g[p][s][z]);
}
}
}
printf("%lld\n", d[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
struct qqq {
long long a, b, c;
} a[210];
int n, t;
long long m, maxx, f[210][210][2], g[210][210][2], su[210][2];
int read() {
int sum = 0, f = 1;
char st = getchar();
while (st < '0' || st > '9') {
if (st == '-') f = -1;
st = getchar();
}
while ('0' <= st && st <= '9') {
sum = (sum << 3) + (sum << 1) + st - '0';
st = getchar();
}
return sum * f;
}
int main() {
cin >> n >> t >> m;
for (int i = 1; i <= n; i++) {
a[i].a = read(), a[i].b = read(), a[i].c = read();
su[i][0] = su[i - 1][0] + a[i].a;
su[i][1] = su[i - 1][1] + a[i].b;
}
n++;
a[n].a = 1e18, a[n].c = 1e18, a[n].b = 0;
su[n][0] = su[n - 1][0] + a[n].a;
su[n][1] = su[n - 1][1] + a[n].b;
memset(f, 0x7f, sizeof(f));
memset(g, 0x7f, sizeof(g));
maxx = f[0][0][0];
for (int i = 0; i <= t; i++)
f[0][i][0] = f[0][i][1] = g[0][i][0] = g[0][i][1] = 0;
for (int i = 1; i <= n; i++) {
for (long long j = 0; j <= t; j++) {
for (long long p = 0; p <= 1; p++) {
if (a[i].a * p + a[i].b * j <= a[i].c && f[i - 1][j][p] < maxx) {
f[i][j][p] = f[i - 1][j][p];
long long st =
ceil((double)(su[i - 1][0] * p + su[i - 1][1] * j) / m);
if (st * m <= su[i][0] * p + su[i][1] * j) g[i][j][p] = st;
}
for (int k = 0; k < j; k++) {
if (g[i][k][p] < maxx) {
long long sy = p * su[i][0] + k * su[i][1] - g[i][k][p] * m +
(j - k) * a[i].b - a[i].c;
long long st = ceil((double)max(0ll, sy) / m);
long long v = p * su[i][0] + k * su[i][1] - g[i][k][p] * m - st * m;
if (v >= 0 && f[i - 1][j - k][0] < maxx) {
f[i][j][p] =
min(f[i][j][p], st + g[i][k][p] + f[i - 1][j - k][0]);
long long stt = ceil((double)(j - k) * su[i - 1][1] / m);
if (stt * m <= (j - k) * su[i][1] + v)
g[i][j][p] = min(g[i][j][p], st + stt + g[i][k][p]);
}
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int getint() {
int ans = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return ans * f;
}
const int N = 310;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
long long a[N], b[N], c[N];
long long sa[N], sb[N], sc[N];
long long f[N][N][2], g[N][N][2];
inline void Min(long long& a, long long b) { (b < a ? a = b : 0); }
int main() {
int n = getint(), t = getint(), k = getint();
for (int i = 1; i <= n; i++) {
a[i] = getint();
b[i] = getint();
c[i] = getint();
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
sc[i] = sc[i - 1] + c[i];
}
n++;
a[n] = inf, b[n] = 0, c[n] = inf;
sa[n] = sa[n - 1] + a[n];
sb[n] = sb[n - 1] + b[n];
sc[n] = sc[n - 1] + c[n];
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
if (f[i - 1][j][z] < inf && a[i] * z + b[i] * j <= c[i]) {
Min(f[i][j][z], f[i - 1][j][z]);
long long val = (z * sa[i - 1] + j * sb[i - 1] + k - 1) / k;
if (val * k <= z * sa[i] + j * sb[i]) {
Min(g[i][j][z], val);
}
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] >= inf) continue;
long long rem = z * sa[i] + r * sb[i] - k * g[i][r][z];
long long x = (max(0ll, rem + (j - r) * b[i] - c[i]) + k - 1) / k;
if (x * k > rem) continue;
if (f[i - 1][j - r][0] >= inf) continue;
Min(f[i][j][z], g[i][r][z] + x + f[i - 1][j - r][0]);
long long val = ((j - r) * sb[i - 1] + k - 1) / k;
if (val * k > (j - r) * sb[i] + rem - x * k) continue;
Min(g[i][j][z], g[i][r][z] + x + val);
}
}
}
}
cout << f[n][t][1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300], b[300], c[300], sa[300], sb[300];
long long f[300][300][2], g[300][300][2];
int main() {
int n, t, k;
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
n++;
a[n] = c[n] = (1LL << 50);
sa[n] = a[n] + sa[n - 1];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
f[i][j][z] = g[i][j][z] = (1LL << 50);
if (z * a[i] + j * b[i] <= c[i] && f[i - 1][j][z] != (1LL << 50)) {
f[i][j][z] = f[i - 1][j][z];
long long v = ((z * sa[i - 1] + j * sb[i - 1]) + k - 1) / k;
if (v * k <= z * sa[i] + j * sb[i]) g[i][j][z] = v;
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] == (1LL << 50)) continue;
long long re = sa[i] * z + sb[i] * r - g[i][r][z] * k;
long long v = (max(0LL, (j - r) * b[i] + re - c[i]) + k - 1) / k;
if (v * k <= re && f[i - 1][j - r][0] != (1LL << 50)) {
f[i][j][z] = min(f[i][j][z], g[i][r][z] + v + f[i - 1][j - r][0]);
long long u = (sb[i - 1] * (j - r) + k - 1) / k;
if (u * k <= sb[i] * (j - r) + re - v * k)
g[i][j][z] = min(g[i][j][z], g[i][r][z] + v + u);
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
char c = 0;
long long sum = 0;
while (c < '0' || c > '9') c = getchar();
while ('0' <= c && c <= '9') sum = sum * 10 + c - '0', c = getchar();
return sum;
}
long long n, T, k, a[201 + 1], Sa[201 + 1], Sb[201 + 1], b[201 + 1], c[201 + 1],
d[201 + 1][201 + 1][2], g[201 + 1][201 + 1][2];
signed main() {
long long m, x;
n = read(), T = read(), k = read();
for (long long i = 1; i <= n; ++i)
a[i] = read(), b[i] = read(), c[i] = read();
++n, a[n] = 1e10, b[n] = 1e10, c[n] = 1e15;
for (long long i = 0; i <= T; ++i)
for (long long j = 1; j <= n; ++j)
for (long long t = 0; t <= 1; ++t) d[i][j][t] = g[i][j][t] = 1e15;
for (long long i = 1; i <= n; ++i)
Sa[i] = Sa[i - 1] + a[i], Sb[i] = Sb[i - 1] + b[i];
for (long long i = 0; i <= T; ++i)
for (long long j = 1; j <= n; ++j)
for (long long t = 0; t <= 1; ++t) {
if (d[i][j - 1][t] != 1e15 && a[j] * t + b[j] * i <= c[j]) {
d[i][j][t] = min(d[i][j][t], d[i][j - 1][t]);
if ((Sa[j - 1] * t + Sb[j - 1] * i + k - 1) / k * k <=
Sa[j] * t + Sb[j] * i)
g[i][j][t] =
min(g[i][j][t], (Sa[j - 1] * t + Sb[j - 1] * i + k - 1) / k);
}
for (long long l = 0; l <= i - 1; ++l)
if (d[i - l][j - 1][0] != 1e15) {
m = Sa[j] * t + Sb[j] * l - g[l][j][t] * k,
x = (max(m + b[j] * (i - l) - c[j], 0ll) + k - 1) / k;
if (x * k <= m) {
d[i][j][t] = min(d[i][j][t], g[l][j][t] + x + d[i - l][j - 1][0]);
if ((Sb[j - 1] * (i - l) + k - 1) / k * k <=
Sb[j] * (i - l) + m - x * k)
g[i][j][t] =
min(g[i][j][t],
g[l][j][t] + x + (Sb[j - 1] * (i - l) + k - 1) / k);
}
}
}
printf("%lld\n", d[T][n][1]);
return 0;
}
|
#include <bits/stdc++.h>
inline long long cl(long long x, long long y) { return (x + y - 1) / y; }
long long n, m, k, a[205], b[205], c[205];
long long sa[205], sb[205];
long long f[205][205][2], g[205][205][2];
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
n++;
a[n] = b[n] = INT_MAX;
c[n] = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int l = 0; l < 2; l++) {
if (l * a[i] + j * b[i] <= c[i] &&
f[i - 1][j][l] < 0x3f3f3f3f3f3f3f3f) {
f[i][j][l] = std::min(f[i][j][l], f[i - 1][j][l]);
long long L = cl(l * sa[i - 1] + j * sb[i - 1], k);
if (L * k <= l * sa[i] + j * sb[i])
g[i][j][l] = std::min(g[i][j][l], L);
}
for (int r = 0; r < j; r++)
if (g[i][r][l] < 0x3f3f3f3f3f3f3f3f) {
long long rm = l * sa[i] + r * sb[i] - k * g[i][r][l],
nd = cl(std::max(rm + (j - r) * b[i] - c[i], 0ll), k);
if (nd * k <= rm && f[i - 1][j - r][0] < 0x3f3f3f3f3f3f3f3f) {
f[i][j][l] =
std::min(f[i][j][l], g[i][r][l] + nd + f[i - 1][j - r][0]);
long long L = cl((j - r) * sb[i - 1], k);
if (L * k <= (j - r) * sb[i] + rm - nd * k)
g[i][j][l] = std::min(g[i][j][l], g[i][r][l] + nd + L);
}
}
}
printf("%lld\n", f[n][m][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int getint() {
int ans = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') f = -1;
c = getchar();
}
while (c >= '0' && c <= '9') {
ans = ans * 10 + c - '0';
c = getchar();
}
return ans * f;
}
const int N = 310;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
long long a[N], b[N], c[N];
long long sa[N], sb[N], sc[N];
long long f[N][N][2], g[N][N][2];
inline void Min(long long &a, long long b) { (b < a ? a = b : 0); }
int main() {
int n = getint(), t = getint(), k = getint();
for (int i = 1; i <= n; i++) {
a[i] = getint();
b[i] = getint();
c[i] = getint();
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
sc[i] = sc[i - 1] + c[i];
}
n++;
a[n] = inf, b[n] = 0, c[n] = inf;
sa[n] = sa[n - 1] + a[n];
sb[n] = sb[n - 1] + b[n];
sc[n] = sc[n - 1] + c[n];
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
if (f[i - 1][j][z] < inf && a[i] * z + b[i] * j <= c[i]) {
Min(f[i][j][z], f[i - 1][j][z]);
long long val = (z * sa[i - 1] + j * sb[i] + k - 1) / k;
if (val * k <= z * sa[i] + j * sb[i]) {
Min(g[i][j][z], val);
}
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] >= inf) continue;
long long rem = z * sa[i] + r * sb[i] - k * g[i][r][z];
long long x = (max(0ll, rem + (j - r) * b[i] - c[i]) + k - 1) / k;
if (x * k > rem) continue;
if (f[i - 1][j - r][0] >= inf) continue;
Min(f[i][j][z], g[i][r][z] + x + f[i - 1][j - r][0]);
long long val = ((j - r) * sb[i - 1] + k - 1) / k;
if (val * k > (j - r) * sb[i] + rem - x * k) continue;
Min(g[i][j][z], g[i][r][z] + x + val);
}
}
}
}
cout << f[n][t][1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 11;
long long a[N], b[N], c[N], sa[N], sb[N], sc[N];
long long d[N][N][2], g[N][N][2];
int main() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
long long n, t, k;
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
}
n++;
a[n] = 2e18;
b[n] = 0;
c[n] = 2e18;
for (int i = 1; i <= n; i++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
sc[i] = sc[i - 1] + c[i];
}
for (int p = 1; p <= n; p++)
for (int s = 0; s <= t; s++)
for (int z = 0; z <= 1; z++) {
d[p][s][z] = 2e18;
g[p][s][z] = 2e18;
if (d[p - 1][s][z] < 2e18 && a[p] * 1ll * z + b[p] * 1ll * s <= c[p]) {
d[p][s][z] = d[p - 1][s][z];
long long d = (z * 1ll * sa[p - 1] + s * 1ll * sb[p - 1] + k - 1) / k;
if (d * k <= z * 1ll * sa[p] + s * 1ll * sb[p]) g[p][s][z] = d;
}
for (int r = 0; r < s; r++)
if (g[p][r][z] < 2e18) {
long long m =
z * 1ll * sa[p] + r * 1ll * sb[p] - k * 1ll * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
m -= x * k;
if (m >= 0 && d[p - 1][s - r][0] < 2e18) {
d[p][s][z] = min(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long d = ((s - r) * sb[p - 1] + k - 1) / k;
if (d * k <= m + (s - r) * 1ll * sb[p])
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + d);
}
}
}
cout << d[n][t][1];
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 234;
const long long inf = 1ll << 60;
long long a[N], b[N], c[N], sa[N], sb[N], d[N][N][N], g[N][N][N];
int n, t, k;
int main() {
scanf("%d %d %d", &n, &t, &k);
for (int i = 1; i <= n; ++i) {
scanf("%d %d %d", &a[i], &b[i], &c[i]);
}
++n;
a[n] = c[n] = inf;
for (int i = 1; i <= n; ++i) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (int p = 1; p <= n; ++p) {
for (int s = 0; s <= t; ++s) {
for (int z = 0; z < 2; ++z) {
d[p][s][z] = g[p][s][z] = inf;
if (s * b[p] + z * a[p] <= c[p] && d[p - 1][s][z] < inf) {
d[p][s][z] = d[p - 1][s][z];
long long value = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
if (value * k <= z * sa[p] + s * sb[p]) {
g[p][s][z] = value;
}
}
for (int r = 0; r < s; ++r) {
if (g[p][r][z] < inf) {
long long m = z * sa[p] + r * sb[p] - k * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
if (x * k <= m && d[p - 1][s - r][0] < inf) {
d[p][s][z] = min(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long value = ((s - r) * sb[p - 1] + k - 1) / k;
if (value * k <= (s - r) * sb[p] + m - x * k) {
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + value);
}
}
}
}
}
}
}
printf("%lld\n", d[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
constexpr int N(205);
constexpr long long inf(0x3f3f3f3f3f3f3f3f);
void Min(long long &x, long long y) { x > y && (x = y); }
int main(void) {
int n, t;
long long k;
scanf("%d%d%lld", &n, &t, &k);
static long long a[N], b[N], c[N], sa[N], sb[N], sc[N];
for (int i(1); i <= n; ++i) scanf("%lld%lld%lld", a + i, b + i, c + i);
++n, a[n] = c[n] = inf;
for (int i(1); i <= n; ++i)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i],
sc[i] = sc[i - 1] + c[i];
static long long f[N][N][2], g[N][N][2];
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
for (int i(0); i <= t; ++i)
f[0][i][0] = f[0][i][1] = g[0][i][0] = g[0][i][1] = 0;
for (int p(1); p <= n; ++p)
for (int s(0); s <= t; ++s)
for (int z(0); z < 2; ++z) {
static long long val, x, m;
if (f[p - 1][s][z] != inf && z * a[p] + s * b[p] <= c[p]) {
Min(f[p][s][z], f[p - 1][s][z]);
val = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
if (val * k <= z * sa[p] + s * sb[p]) Min(g[p][s][z], val);
}
for (int r(0); r < s; ++r)
if (g[p][r][z] ^ inf) {
m = z * sa[p] + r * sb[p] - k * g[p][r][z];
x = (std::max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
if (x * k > m || f[p - 1][s - r][0] == inf) continue;
Min(f[p][s][z], g[p][r][z] + x + f[p - 1][s - r][0]);
val = x + ((s - r) * sb[p - 1] + k - 1) / k;
if (val * k <= (s - r) * sb[p] + m)
Min(g[p][s][z], g[p][r][z] + val);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int _ = 200 + 7;
const long long inf = 1e15;
int n, T, K;
long long a[_], b[_], c[_], sa[_], sb[_], d[_][_][2], g[_][_][2];
long long Ceil(long long x, long long y) { return x % y ? x / y + 1 : x / y; }
void upd(long long &x, long long y) { x = min(x, y); }
int main() {
cin >> n >> T >> K;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
a[++n] = inf, c[n] = inf;
sa[n] = sa[n - 1] + a[n];
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) d[p][s][z] = g[p][s][z] = inf;
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) {
if (z * a[p] + s * b[p] <= c[p] and d[p - 1][s][z] != inf) {
upd(d[p][s][z], d[p - 1][s][z]);
long long num = Ceil(z * sa[p - 1] + s * sb[p - 1], K);
if (num * K <= z * sa[p] + s * sb[p]) upd(g[p][s][z], num);
}
for (int r = 0; r < s; ++r)
if (g[p][r][z] != inf and d[p - 1][s - r][0] != inf) {
long long m = z * sa[p] + r * sb[p] - K * g[p][r][z];
long long x = Ceil(max(0ll, m + (s - r) * b[p] - c[p]), K);
if (K * x <= m) {
upd(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long num = Ceil((s - r) * sb[p - 1], K);
if (num * K <= m - K * x + (s - r) * sb[p])
upd(g[p][s][z], g[p][r][z] + x + num);
}
}
upd(d[p][s][z], g[p][s][z]);
}
cout << d[n][T][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct station_t {
long long a, b, c;
};
struct solver_t {
vector<station_t> st;
int total_ns, total_nt, k;
solver_t(const vector<station_t> &_stations, int _nt, int _k)
: st(_stations), total_ns(st.size()), total_nt(_nt), k(_k) {}
struct dp1_t {
long long ntrain;
long long total_people;
};
struct dp2_t {
long long ntrain;
long long people_last;
};
vector<vector<array<dp1_t, 2>>> dp1_memo;
vector<vector<array<dp2_t, 2>>> dp2_memo;
dp1_t solve_dp1(int ns, int nt, bool use_a) {
dp1_t &res = dp1_memo[ns][nt][use_a];
if (res.ntrain != -1LL) return res;
if (ns == 0) return res = {0LL, 0LL};
station_t &last_st = st[ns - 1];
if (nt == 0) {
dp1_t sub_res = solve_dp1(ns - 1, 0, use_a);
return res = {sub_res.ntrain,
sub_res.total_people + (use_a ? last_st.a : last_st.b)};
}
res = {LLONG_MAX, -1LL};
{
long long final_value =
(use_a ? last_st.a : last_st.b) + (long long)nt * last_st.b;
if (final_value <= last_st.c) {
dp1_t sub_res = solve_dp1(ns - 1, nt, use_a);
if (sub_res.ntrain != LLONG_MAX) {
dp1_t cand = {sub_res.ntrain, sub_res.total_people + final_value};
if (cand.ntrain < res.ntrain) res = cand;
}
}
}
for (int t = 0; t < nt; ++t) {
dp2_t upper_res = solve_dp2(ns, t + 1, use_a);
if (upper_res.ntrain == LLONG_MAX) continue;
dp1_t lower_res = solve_dp1(ns - 1, nt - 1 - t, false);
if (lower_res.ntrain == LLONG_MAX) continue;
long long temp_value =
upper_res.people_last + (long long)(nt - 1 - t) * last_st.b;
long long exceeds = max(temp_value - last_st.c, 0LL);
long long extra_train = (exceeds + (k - 1)) / k;
long long max_extra_train = (upper_res.people_last - last_st.b) / k;
if (extra_train > max_extra_train) continue;
temp_value -= extra_train * k;
assert(temp_value >= last_st.b);
dp1_t cand = {upper_res.ntrain + lower_res.ntrain + extra_train,
lower_res.total_people + temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
return res;
}
dp2_t solve_dp2(int ns, int nt, bool use_a) {
assert(ns > 0 && nt > 0);
dp2_t &res = dp2_memo[ns][nt][use_a];
if (res.ntrain != -1LL) return res;
res = {LLONG_MAX, -1LL};
station_t &last_st = st[ns - 1];
{
dp1_t sub_res = solve_dp1(ns - 1, nt - 1, use_a);
if (sub_res.ntrain != LLONG_MAX) {
long long temp_value =
(use_a ? last_st.a : last_st.b) + (long long)(nt - 1) * last_st.b;
if (temp_value <= last_st.c) {
long long extra_train = (sub_res.total_people + k - 1) / k;
long long residual = extra_train * k - sub_res.total_people;
if (temp_value >= residual) {
temp_value -= residual;
long long exceeding =
max((temp_value + last_st.b) - last_st.c, 0LL);
long long extra_train_2 = (exceeding + k - 1) / k;
temp_value -= extra_train_2 * k;
if (temp_value >= 0) {
temp_value += last_st.b;
assert(temp_value <= last_st.c);
dp2_t cand = {sub_res.ntrain + extra_train + extra_train_2,
temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
}
}
}
}
for (int t = 0; t < nt - 1; ++t) {
dp2_t upper_res = solve_dp2(ns, t + 1, use_a);
if (upper_res.ntrain == LLONG_MAX) continue;
dp1_t mid_res = solve_dp1(ns - 1, nt - t - 2, false);
if (mid_res.ntrain == LLONG_MAX) continue;
assert(upper_res.people_last >= last_st.b);
long long max_extra_train_1 = (upper_res.people_last - last_st.b) / k;
long long temp_value =
upper_res.people_last + (long long)(nt - t - 2) * last_st.b;
long long exceeding_1 = max(temp_value - last_st.c, 0LL);
long long extra_train_1 = (exceeding_1 + k - 1) / k;
if (extra_train_1 > max_extra_train_1) continue;
temp_value -= extra_train_1 * k;
long long extra_train_2 = (mid_res.total_people + k - 1) / k;
long long residual = extra_train_2 * k - mid_res.total_people;
if (temp_value < residual) continue;
temp_value -= residual;
long long exceeding_3 = max((temp_value + last_st.b) - last_st.c, 0LL);
long long extra_train_3 = (exceeding_3 + k - 1) / k;
temp_value -= extra_train_3 * k;
if (temp_value < 0) continue;
temp_value += last_st.b;
assert(temp_value <= last_st.c);
dp2_t cand = {upper_res.ntrain + mid_res.ntrain + extra_train_1 +
extra_train_2 + extra_train_3,
temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
return res;
}
long long solve() {
dp1_memo.assign(
total_ns + 1,
vector<array<dp1_t, 2>>(total_nt + 1,
array<dp1_t, 2>{{{-1LL, -1LL}, {-1LL, -1LL}}}));
dp2_memo.assign(
total_ns + 1,
vector<array<dp2_t, 2>>(total_nt + 1,
array<dp2_t, 2>{{{-1LL, -1LL}, {-1LL, -1LL}}}));
return solve_dp1(total_ns, total_nt, true).ntrain;
}
};
int main() {
int ns, nt, k;
scanf("%d %d %d", &ns, &nt, &k);
vector<station_t> stations(ns);
for (int i = 0; i < ns; ++i)
scanf("%lld %lld %lld", &stations[i].a, &stations[i].b, &stations[i].c);
stations.push_back({(long long)(k - 1) * nt, 0LL, (long long)(k - 1) * nt});
ns = stations.size();
solver_t solver(stations, nt, k);
printf("%lld\n", solver.solve());
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T1, typename T2>
inline T1 max(T1 a, T2 b) {
return a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 min(T1 a, T2 b) {
return a < b ? a : b;
}
template <typename T1, typename T2>
inline T1 gmax(T1 &a, T2 b) {
return a = a < b ? b : a;
}
template <typename T1, typename T2>
inline T1 gmin(T1 &a, T2 b) {
return a = a < b ? a : b;
}
const char lf = '\n';
namespace ae86 {
const int bufl = 1 << 15;
char buf[bufl], *s = buf, *t = buf;
inline int fetch() {
if (s == t) {
t = (s = buf) + fread(buf, 1, bufl, stdin);
if (s == t) return EOF;
}
return *s++;
}
inline int ty() {
int a = 0;
int b = 1, c = fetch();
while (!isdigit(c)) b ^= c == '-', c = fetch();
while (isdigit(c)) a = a * 10 + c - 48, c = fetch();
return b ? a : -a;
}
} // namespace ae86
using ae86::ty;
const int _ = 207, inf = 0x3f3f3f3f;
const long long linf = 0x3f3f3f3f3f3f3f3f;
int n, tar;
long long per;
long long bas[_] = {0}, dlt[_] = {0}, lim[_] = {0};
long long sbas[_] = {0}, sdlt[_] = {0};
inline long long hanging(long long i, long long tim, long long sta) {
return sbas[i] * sta + sdlt[i] * tim;
}
long long f[_][_][2], g[_][_][2];
inline long long ceiling(long long x, long long b) { return (x + b - 1) / b; }
int main() {
ios::sync_with_stdio(0), cout.tie(nullptr);
n = ty(), tar = ty(), per = ty();
for (int i = 1; i <= n; i++) bas[i] = ty(), dlt[i] = ty(), lim[i] = ty();
n++, bas[n] = dlt[n] = inf, lim[n] = linf;
for (int i = 1; i <= n; i++)
sbas[i] = sbas[i - 1] + bas[i], sdlt[i] = sdlt[i - 1] + dlt[i];
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
memset(f[0], 0, sizeof(f[0])), memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= tar; j++) {
for (int k = 0; k < 2; k++) {
if (f[i - 1][j][k] < linf && bas[i] * k + dlt[i] * j <= lim[i]) {
gmin(f[i][j][k], f[i - 1][j][k]);
long long t = ceiling(hanging(i - 1, j, k), per);
if (t * per <= hanging(i, j, k)) gmin(g[i][j][k], t);
}
for (int a = 0; a < j; a++) {
long long now = g[i][a][k];
if (now > linf) continue;
long long lef = hanging(i, a, k) - now * per;
long long tran =
ceiling(max(lef + dlt[i] * (j - a) - lim[i], 0), per);
if (f[i - 1][j - a][0] < linf && tran * per <= lef) {
gmin(f[i][j][k], now + tran + f[i - 1][j - a][0]);
long long temp = ceiling(sdlt[i - 1] * (j - a), per);
if (temp * per <= sdlt[i] * (j - a) + lef - tran * per)
gmin(g[i][j][k], now + tran + temp);
}
}
}
}
}
cout << f[n][tar][1] << lf;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline int read() {
register int x = 0, f = 1;
register char ch = getchar();
while (!isdigit(ch)) {
if (ch == '-') f = 0;
ch = getchar();
}
while (isdigit(ch)) {
x = x * 10 + (ch ^ '0');
ch = getchar();
}
return f ? x : -x;
}
const int N = 2e2 + 5;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, t, s, a[N], b[N];
long long c[N], A[N], B[N], f[N][N][2], g[N][N][2];
inline void chkmin(long long &x, long long y) { x = x > y ? y : x; }
int main() {
n = read(), t = read(), s = read();
for (int i = (1), _ed = (n); i <= _ed; ++i)
A[i] = A[i - 1] + (a[i] = read()), B[i] = B[i - 1] + (b[i] = read()),
c[i] = read();
++n, a[n] = b[n] = 0x7fffffff, c[n] = inf;
A[n] = A[n - 1] + a[n], B[n] = B[n - 1] + b[n];
memset(f, 63, sizeof f);
memset(g, 63, sizeof g);
memset(f[0], 0, sizeof f[0]);
memset(g[0], 0, sizeof g[0]);
for (int i = (1), _ed = (n); i <= _ed; ++i)
for (int j = (0), _ed = (t); j <= _ed; ++j)
for (int k = (0), _ed = (1); k <= _ed; ++k) {
if (1ll * k * a[i] + 1ll * j * b[i] <= c[i] && f[i - 1][j][k] < inf) {
chkmin(f[i][j][k], f[i - 1][j][k]);
long long t = ceil((double)(k * A[i - 1] + j * B[i - 1]) / s);
if (t * s <= k * A[i] + j * B[i]) chkmin(g[i][j][k], t);
}
for (int r = (0), _ed = (j - 1); r <= _ed; ++r) {
if (g[i][r][k] >= inf) continue;
long long res = (k * A[i] + r * B[i]) - s * g[i][r][k];
long long tim =
ceil((double)max(res + 1ll * (j - r) * b[i] - c[i], 0ll) / s);
if (tim * s <= res && f[i - 1][j - r][0] < inf) {
chkmin(f[i][j][k], g[i][r][k] + tim + f[i - 1][j - r][0]);
long long t = ceil((double)(j - r) * B[i - 1] / s);
if (t * s <= res - tim * s + (j - r) * B[i])
chkmin(g[i][j][k], g[i][r][k] + tim + t);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#pragma GCC optimize("no-stack-protector,fast-math")
using namespace std;
const long long N = 3e2 + 10, OO = 1e18 + 7, T = 1e6 + 10, mod = 1e9 + 7,
M = 1e9 + 7, P = 6151, SQ = 280, lg = 70;
long long n, t, k;
long long sa[N], sb[N];
long long a[N], b[N], c[N];
long long d[N][N][2], g[N][N][2];
int32_t main() {
ios::sync_with_stdio(false), cin.tie(0), cout.tie(0);
cin >> n >> t >> k;
for (long long i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
a[++n] = OO, b[n] = 0, c[n] = OO;
for (long long i = 1; i <= n; i++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (long long p = 1; p <= n; p++) {
for (long long s = 0; s <= t; s++) {
for (long long z = 0; z < 2; z++) {
d[p][s][z] = g[p][s][z] = OO;
if (d[p - 1][s][z] < OO && a[p] * z + b[p] * s <= c[p]) {
d[p][s][z] = d[p - 1][s][z];
long long dt = (sa[p - 1] * z + sb[p - 1] * s + k - 1) / k;
if (dt * k <= sa[p] * z + sb[p] * s) g[p][s][z] = dt;
}
for (long long r = 0; r < s; r++) {
if (g[p][r][z] < OO) {
long long m = sa[p] * z + sb[p] * r - g[p][r][z] * k;
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
m -= x * k;
if (d[p - 1][s - r][0] < OO && m >= 0) {
d[p][s][z] = min(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long dt = (sb[p - 1] * (s - r) + k - 1) / k;
if (dt * k <= m + (s - r) * sb[p])
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + dt);
}
}
}
}
}
}
cout << d[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using ll = long long;
ll F[205][205][2], G[205][205][2];
ll a[205], b[205], c[205], sum_a[205], sum_b[205];
int main() {
int n, m, k;
scanf("%d%d%d", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", a + i, b + i, c + i);
n++;
a[n] = c[n] = 1e18;
for (int i = 1; i <= n; i++) {
sum_a[i] = sum_a[i - 1] + a[i];
sum_b[i] = sum_b[i - 1] + b[i];
}
memset(F, 0x3f, sizeof(F));
memset(G, 0x3f, sizeof(G));
memset(F[0], 0, sizeof(F[0]));
memset(G[0], 0, sizeof(G[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= m; j++) {
for (int x = 0; x < 2; x++) {
if (x * a[i] + j * b[i] <= c[i] && F[i - 1][j][x] < 1e18) {
F[i][j][x] = F[i - 1][j][x];
ll val = (x * sum_a[i - 1] + j * sum_b[i - 1] + k - 1) / k;
if (val * k <= x * sum_a[i] + j * sum_b[i]) G[i][j][x] = val;
}
for (int lst = 0; lst < j; lst++) {
if (G[i][lst][x] >= 1e18) continue;
ll val = x * sum_a[i] + lst * sum_b[i] - G[i][lst][x] * k;
ll w = (std::max<ll>(val + (j - lst) * b[i] - c[i], 0) + k - 1) / k;
if (w * k > val || F[i - 1][j - lst][0] >= 1e18) continue;
F[i][j][x] =
std::min(F[i][j][x], G[i][lst][x] + F[i - 1][j - lst][0] + w);
ll t = ((j - lst) * sum_b[i - 1] + k - 1) / k;
if (t * k <= (j - lst) * sum_b[i] + val - w * k)
G[i][j][x] = std::min(G[i][j][x], G[i][lst][x] + w + t);
}
}
}
}
printf("%lld\n", F[n][m][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e15;
long long n, t, k;
long long a[305], b[305], c[305];
long long sa[305], sb[305], sc[305];
long long d[305][305][2], g[305][305][2];
int main() {
scanf("%lld%lld%lld", &n, &t, &k);
for (int i = 1; i <= n; ++i) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = c[n] = inf;
b[n] = 0;
for (int i = 1; i <= n; ++i)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i],
sc[i] = sc[i - 1] + c[i];
for (int i = 0; i <= n + 1; ++i)
for (int j = 0; j <= t; ++j)
for (int p = 0; p <= 1; ++p) d[i][j][p] = g[i][j][p] = inf;
for (int p = 0; p <= n + 1; ++p)
for (int s = 0; s <= t; ++s)
for (int z = 0; z <= 1; ++z) {
if (d[p - 1][s][z] != inf && z * a[p] + b[p] * s <= c[p]) {
long long val = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
d[p][s][z] = min(d[p][s][z], d[p - 1][s][z]);
if (val * k <= z * sa[p] + s * sb[p])
g[p][s][z] = min(g[p][s][z], val);
}
for (int r = 0; r < s; ++r) {
long long m = z * sa[p] + r * sb[p] - k * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
if (g[p][r][z] == inf || x * k > m || d[p - 1][s - r][0] == inf)
continue;
long long Val = ((s - r) * sb[p - 1] + k - 1) / k;
d[p][s][z] = min(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + Val);
}
}
printf("%lld\n", d[n + 1][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t;
long long K;
long long a[210], b[210], c[210];
long long sa[210], sb[210];
long long f[210][210][2], g[210][210][2];
inline void upd(long long &a, long long b) { a > b ? a = b : 0; }
int main() {
scanf("%d%d%lld", &n, &t, &K);
for (int i = 1; i <= n; ++i) {
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
c[n + 1] = LLONG_MAX;
a[n + 1] = INT_MAX, b[n + 1] = 0;
sa[n + 1] = sa[n] + INT_MAX;
sb[n + 1] = sb[n] + INT_MAX;
++n;
for (int j = 0; j <= t; ++j) {
f[0][j][0] = f[0][j][1] = 0;
g[0][j][0] = g[0][j][1] = 0;
}
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) {
g[i][j][k] = f[i][j][k] = LLONG_MAX;
if (a[i] * k + b[i] * j <= c[i] && f[i - 1][j][k] < LLONG_MAX) {
upd(f[i][j][k], f[i - 1][j][k]);
long long L = sa[i - 1] * k + sb[i - 1] * j;
if ((L - 1 + K) / K * K <= sa[i] * k + sb[i] * j)
upd(g[i][j][k], (L - 1 + K) / K);
}
for (int r = 0; r < j; ++r) {
long long tmp = g[i][r][k];
if (tmp == LLONG_MAX) continue;
long long rest = sa[i] * k + sb[i] * r - tmp * K,
need = (max(rest + b[i] * (j - r) - c[i], 0ll) - 1 + K) / K;
if (need * K <= rest && f[i - 1][j - r][0] < LLONG_MAX) {
upd(f[i][j][k], tmp + need + f[i - 1][j - r][0]);
long long L = sb[i - 1] * (j - r);
if ((L - 1 + K) / K * K <= sb[i] * (j - r) + rest - need * K)
upd(g[i][j][k], tmp + need + (L - 1 + K) / K);
}
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
const long long inf = 1e18;
using namespace std;
int n, t, K, a[210], b[210];
long long pa[210], pb[210], c[210], f[210][210][2], g[210][210][2], tmp, nw, nd;
int main() {
scanf("%d%d%d", &n, &t, &K);
for (int i = 1; i <= n; i++) scanf("%d%d%lld", &a[i], &b[i], &c[i]);
c[++n] = 1e18, a[n] = b[n] = 2e9;
for (int i = 1; i <= n; i++)
pa[i] = pa[i - 1] + a[i], pb[i] = pb[i - 1] + b[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
f[i][j][0] = f[i][j][1] = g[i][j][0] = g[i][j][1] = inf;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int k = 0; k < 2; k++) {
if (k * a[i] + 1ll * j * b[i] <= c[i] && f[i - 1][j][k] < inf) {
f[i][j][k] = min(f[i][j][k], f[i - 1][j][k]);
tmp = (k * pa[i - 1] + j * pb[i - 1] + K - 1) / K;
if (tmp * K <= k * pa[i] + j * pb[i])
g[i][j][k] = min(g[i][j][k], tmp);
}
for (int r = 0; r < j; r++)
if (g[i][r][k] < inf) {
nw = k * pa[i] + r * pb[i] - g[i][r][k] * K;
nd = (max(0ll, nw + 1ll * (j - r) * b[i] - c[i]) + K - 1) / K;
if (nd * K <= nw && f[i - 1][j - r][0] < inf) {
f[i][j][k] =
min(f[i][j][k], f[i - 1][j - r][0] + g[i][r][k] + nd);
tmp = ((j - r) * pb[i - 1] + K - 1) / K;
if (tmp * K <= (j - r) * pb[i] + nw - nd * K)
g[i][j][k] = min(g[i][j][k], g[i][r][k] + nd + tmp);
}
}
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const long long maxn = 210;
const long long INF = 1e18;
long long n, t, k, a[maxn], b[maxn], c[maxn], sa[maxn], sb[maxn],
f[maxn][maxn][2], g[maxn][maxn][2];
signed main() {
scanf("%lld%lld%lld", &n, &t, &k);
for (long long i = (1), _end_ = (n); i <= _end_; ++i)
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = c[n] = INF;
for (long long i = (1), _end_ = (n); i <= _end_; ++i) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (long long i = (1), _end_ = (n); i <= _end_; ++i)
for (long long j = (0), _end_ = (t); j <= _end_; ++j)
for (long long o = (0), _end_ = (1); o <= _end_; ++o)
f[i][j][o] = g[i][j][o] = INF;
for (long long i = (1), _end_ = (n); i <= _end_; ++i)
for (long long j = (0), _end_ = (t); j <= _end_; ++j)
for (long long o = (0), _end_ = (1); o <= _end_; ++o) {
if (j * b[i] + o * a[i] <= c[i] && f[i - 1][j][o] != INF) {
f[i][j][o] = min(f[i][j][o], f[i - 1][j][o]);
long long x = (sb[i - 1] * j + sa[i - 1] * o + k - 1) / k;
if (x * k <= sb[i] * j + sa[i] * o) g[i][j][o] = min(g[i][j][o], x);
}
for (long long r = (0), _end_ = (j - 1); r <= _end_; ++r) {
if (g[i][r][o] == INF) continue;
long long num = sa[i] * o + sb[i] * r - k * g[i][r][o];
long long x = max(0ll, (num + (j - r) * b[i] - c[i] + k - 1) / k);
if (k * x > num || f[i - 1][j - r][0] == INF) continue;
f[i][j][o] = min(f[i][j][o], g[i][r][o] + x + f[i - 1][j - r][0]);
long long y = (sb[i - 1] * (j - r) + k - 1) / k;
if (k * y <= (j - r) * sb[i] + num - k * x)
g[i][j][o] = min(g[i][j][o], g[i][r][o] + x + y);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 234;
const long long inf = 1ll << 60;
long long a[N], b[N], c[N], sa[N], sb[N], d[N][N][N], g[N][N][N];
int n, t, k;
int main() {
cin >> n >> t >> k;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
++n;
a[n] = c[n] = inf;
for (int i = 1; i <= n; ++i) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (int p = 1; p <= n; ++p) {
for (int s = 0; s <= t; ++s) {
for (int z = 0; z < 2; ++z) {
d[p][s][z] = g[p][s][z] = inf;
if (s * b[p] + z * a[p] <= c[p] && d[p - 1][s][z] < inf) {
d[p][s][z] = d[p - 1][s][z];
long long value = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
if (value * k <= z * sa[p] + s * sb[p]) {
g[p][s][z] = value;
}
}
for (int r = 0; r < s; ++r) {
if (g[p][r][z] < inf) {
long long m = z * sa[p] + r * sb[p] - k * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
if (x * k <= m && d[p - 1][s - r][0] < inf) {
d[p][s][z] = min(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long value = ((s - r) * sb[p - 1] + k - 1) / k;
if (value * k <= (s - r) * sb[p] + m - x * k) {
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + value);
}
}
}
}
}
}
}
printf("%lld\n", d[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, k;
long long a[666666], b[666666], c[666666], sa[666666], sb[666666], sc[666666];
long long d[235][235][235], g[235][235][235];
inline void cmin(long long& a, long long b) {
if (a > b) a = b;
}
int main() {
cin >> n >> t >> k;
++n;
const long long inf = 1e18;
for (int i = 1; i <= n; ++i) {
if (i == n)
a[i] = c[i] = inf;
else
cin >> a[i] >> b[i] >> c[i];
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
sc[i] = sc[i - 1] + c[i];
}
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= t; ++s)
for (int z = 0; z < 2; ++z) {
d[p][s][z] = g[p][s][z] = inf;
if (s * b[p] + z * a[p] <= c[p] && d[p - 1][s][z] < inf) {
d[p][s][z] = d[p - 1][s][z];
long long v = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
if (v * k <= z * sa[p] + s * sb[p]) g[p][s][z] = v;
}
for (int r = 0; r < s; ++r)
if (g[p][r][z] < inf) {
long long m = z * sa[p] + r * sb[p] - k * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0LL) + k - 1) / k;
if (x * k <= m && d[p - 1][s - r][0] < inf) {
cmin(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long v = ((s - r) * sb[p - 1] + k - 1) / k;
if (v * k <= (s - r) * sb[p] + m - x * k)
cmin(g[p][s][z], g[p][r][z] + x + v);
}
}
}
cout << d[n][t][1] << "\n";
}
|
#include <bits/stdc++.h>
using namespace std;
int n, t, K;
long long a[200 + 5], b[200 + 5], c[200 + 5];
long long suma[200 + 5], sumb[200 + 5];
long long f[200 + 5][200 + 5][2], g[200 + 5][200 + 5][2];
int main() {
scanf("%d %d %d", &n, &t, &K);
for (int i = 1; i <= n; i++) scanf("%lld %lld %lld", &a[i], &b[i], &c[i]);
n++;
a[n] = b[n] = (1ll << 31);
c[n] = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) {
suma[i] = suma[i - 1] + a[i];
sumb[i] = sumb[i - 1] + b[i];
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
for (int j = 0; j <= t; j++)
f[0][j][0] = f[0][j][1] = g[0][j][0] = g[0][j][1] = 0;
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int u = 0; u <= 1; u++) {
if (u * a[i] + j * b[i] <= c[i] &&
f[i - 1][j][u] != 0x3f3f3f3f3f3f3f3f) {
f[i][j][u] = min(f[i][j][u], f[i - 1][j][u]);
long long num = (u * suma[i - 1] + j * sumb[i - 1] + K - 1) / K;
if (K * num <= u * suma[i] + j * sumb[i])
g[i][j][u] = min(g[i][j][u], num);
}
for (int r = 0; r < j; r++) {
if (g[i][r][u] != 0x3f3f3f3f3f3f3f3f) {
long long rem = u * suma[i] + r * sumb[i] - K * g[i][r][u];
long long need =
(max(rem + (j - r) * b[i] - c[i], 0ll) + K - 1) / K;
if (need * K <= rem && f[i - 1][j - r][0] != 0x3f3f3f3f3f3f3f3f) {
f[i][j][u] =
min(f[i][j][u], g[i][r][u] + need + f[i - 1][j - r][0]);
long long num = ((j - r) * sumb[i - 1] + K - 1) / K;
if (num * K <= (j - r) * sumb[i] + (rem - need * K))
g[i][j][u] = min(g[i][j][u], g[i][r][u] + need + num);
}
}
}
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void chkmin(T &x, T y) {
if (y < x) x = y;
}
int read() {
int X = 0, w = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') w = -1;
c = getchar();
}
while (c >= '0' && c <= '9') X = X * 10 + c - '0', c = getchar();
return X * w;
}
const int N = 200 + 10;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int n, t, s;
long long a[N], b[N], c[N], sa[N], sb[N];
long long f[N][N][2], g[N][N][2];
int main() {
n = read(), t = read(), s = read();
for (int i = 1; i <= n; ++i) a[i] = read(), b[i] = read(), c[i] = read();
++n, a[n] = b[n] = 2e9, c[n] = inf;
for (int i = 1; i <= n; ++i)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f, 0x3f, sizeof(f)), memset(g, 0x3f, sizeof(g));
for (int i = 0; i <= t; ++i)
f[0][i][0] = f[0][i][1] = g[0][i][0] = g[0][i][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k <= 1; ++k) {
if (k * a[i] + j * b[i] <= c[i] && f[i - 1][j][k] != inf) {
chkmin(f[i][j][k], f[i - 1][j][k]);
long long cnt = (k * sa[i - 1] + j * sb[i - 1] + s - 1) / s;
if (cnt * s <= k * sa[i] + j * sb[i]) chkmin(g[i][j][k], cnt);
}
for (int p = 0; p < j; ++p) {
if (g[i][p][k] == inf) continue;
long long res = k * sa[i] + p * sb[i] - s * g[i][p][k];
long long need = (max(res + (j - p) * b[i] - c[i], 0ll) + s - 1) / s;
if (need * s <= res && f[i - 1][j - p][0] != inf) {
chkmin(f[i][j][k], g[i][p][k] + need + f[i - 1][j - p][0]);
long long cnt = ((j - p) * sb[i - 1] + s - 1) / s;
if (cnt * s <= (j - p) * sb[i] + res - need * s)
chkmin(g[i][j][k], g[i][p][k] + need + cnt);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 1e18;
const int N = 210;
const int mod = 0;
int gi() {
int x = 0, o = 1;
char ch = getchar();
while ((ch < '0' || ch > '9') && ch != '-') ch = getchar();
if (ch == '-') o = -1, ch = getchar();
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
return x * o;
}
template <typename T>
bool chkmax(T &a, T b) {
return a < b ? a = b, 1 : 0;
};
template <typename T>
bool chkmin(T &a, T b) {
return a > b ? a = b, 1 : 0;
};
int add(int a, int b) { return a + b >= mod ? a + b - mod : a + b; }
int sub(int a, int b) { return a - b < 0 ? a - b + mod : a - b; }
void inc(int &a, int b) { a = (a + b >= mod ? a + b - mod : a + b); }
void dec(int &a, int b) { a = (a - b < 0 ? a - b + mod : a - b); }
int n, t;
long long k, a[N], b[N], c[N], sa[N], sb[N], d[N][N][2], g[N][N][2];
int main() {
n = gi(), t = gi(), k = gi();
for (int i = 1; i <= n; i++) a[i] = gi(), b[i] = gi(), c[i] = gi();
++n, a[n] = c[n] = inf;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
for (int p = 1; p <= n; p++)
for (int s = 0; s <= t; s++)
for (int z = 0; z < 2; z++) {
d[p][s][z] = g[p][s][z] = inf;
if (z * a[p] + s * b[p] <= c[p] && d[p - 1][s][z] < inf) {
d[p][s][z] = d[p - 1][s][z];
long long val = (z * sa[p - 1] + s * sb[p - 1] + k - 1) / k;
if (val * k <= z * sa[p] + s * sb[p]) g[p][s][z] = val;
}
for (int r = 0; r < s; r++)
if (g[p][r][z] < inf) {
long long m = z * sa[p] + r * sb[p] - k * g[p][r][z];
long long x = (max(m + (s - r) * b[p] - c[p], 0ll) + k - 1) / k;
if (x * k <= m && d[p - 1][s - r][0] < inf) {
chkmin(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long val = (sb[p - 1] * (s - r) + k - 1) / k;
if (val * k <= sb[p] * (s - r) + m - x * k)
chkmin(g[p][s][z], g[p][r][z] + x + val);
}
}
}
cout << d[n][t][1];
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[25];
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 210;
long long f[maxn][maxn][2], g[maxn][maxn][2];
long long a[maxn], b[maxn], c[maxn], s1[maxn], s2[maxn];
long long n, t, k;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
void write(long long x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int cnt = 0;
while (x) {
buf[++cnt] = '0' + x % 10;
x /= 10;
}
for (int i = cnt; i >= 1; --i) putchar(buf[i]);
}
long long Div(long long x, long long y) {
return x % y == 0 ? x / y : x / y + 1;
}
int main() {
n = read();
t = read();
k = read();
for (int i = 1; i <= n; ++i) {
a[i] = read();
b[i] = read();
c[i] = read();
}
++n;
a[n] = b[n] = INT_MAX;
c[n] = inf;
for (int i = 1; i <= n; ++i) {
s1[i] = s1[i - 1] + a[i];
s2[i] = s2[i - 1] + b[i];
}
memset(f, 63, sizeof(f));
memset(g, 63, sizeof(g));
for (int i = 0; i <= t; ++i)
f[0][i][0] = f[0][i][1] = g[0][i][0] = g[0][i][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int l = 0; l <= 1; ++l) {
if (l * a[i] + j * b[i] <= c[i] && f[i - 1][j][l] < inf) {
f[i][j][l] = f[i - 1][j][l];
long long L = l * s1[i - 1] + j * s2[i - 1];
if (Div(L, k) * k <= l * s1[i] + j * s2[i]) g[i][j][l] = Div(L, k);
}
for (int r = 0; r <= j - 1; ++r)
if (g[i][r][l] < inf) {
long long rem = l * s1[i] + r * s2[i] - k * g[i][r][l],
need = Div(max(rem + (j - r) * b[i] - c[i], 0ll), k);
if (rem < 0) continue;
if (need * k <= rem && f[i - 1][j - r][0] < inf) {
f[i][j][l] =
min(f[i][j][l], g[i][r][l] + need + f[i - 1][j - r][0]);
long long L = (j - r) * s2[i - 1];
if (Div(L, k) * k <= (j - r) * s2[i] + (rem - need * k))
g[i][j][l] = min(g[i][j][l], g[i][r][l] + need + Div(L, k));
}
}
}
write(f[n][t][1]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, f = 1;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = (x << 3) + (x << 1) + (c ^ 48);
c = getchar();
}
return f == 1 ? x : ~x + 1;
}
const long long inf = 1e18;
long long n, t, K;
long long a[210], b[210], c[210];
long long sa[210], sb[210];
long long f[210][210][2], g[210][210][2];
void chkmin(long long &x, long long y) { x = (x <= y ? x : y); }
signed main() {
n = read(), t = read(), K = read();
++n;
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j <= t; ++j) {
for (long long k = 0; k <= 1; ++k) {
f[i][j][k] = g[i][j][k] = inf;
}
}
}
for (long long i = 1; i <= n - 1; ++i) {
a[i] = read(), b[i] = read(), c[i] = read();
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
}
a[n] = c[n] = inf;
b[n] = 0;
sa[n] = sa[n - 1] + a[n];
sb[n] = sb[n - 1];
for (long long i = 1; i <= n; ++i) {
for (long long j = 0; j <= t; ++j) {
for (long long k = 0; k <= 1; ++k) {
if (f[i - 1][j][k] != inf && a[i] * k + b[i] * j <= c[i]) {
f[i][j][k] = f[i - 1][j][k];
long long cnt = sa[i - 1] * k + sb[i - 1] * j - f[i - 1][j][k] * K;
long long cost = (cnt + K - 1) / K;
if (cost * K <= cnt + a[i] * k + b[i] * j) {
g[i][j][k] = f[i - 1][j][k] + cost;
}
}
for (long long l = 0; l < j; ++l) {
if (g[i][l][k] != inf && f[i - 1][j - l][0] != inf) {
long long m = sa[i] * k + sb[i] * l - g[i][l][k] * K;
long long cst = max(0ll, (m + b[i] * (j - l) - c[i] + K - 1) / K);
if (cst * K <= m) {
chkmin(f[i][j][k], g[i][l][k] + cst + f[i - 1][j - l][0]);
long long tmp =
(sb[i - 1] * (j - l) - f[i - 1][j - l][0] * K + K - 1) / K;
if (tmp * K - sb[i - 1] * (j - l) + f[i - 1][j - l][0] * K <=
m + b[i] * (j - l) - cst * K) {
chkmin(g[i][j][k], g[i][l][k] + cst + f[i - 1][j - l][0] + tmp);
}
}
}
}
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
const int Maxn = 200;
const int Maxt = 200;
const long long Inf_ll = 0x3f3f3f3f3f3f3f3fll;
int n, t, k;
int a[Maxn + 5], b[Maxn + 5], c[Maxn + 5];
long long f[Maxn + 5][Maxt + 5][2], g[Maxn + 5][Maxt + 5][2];
int main() {
scanf("%d%d%d", &n, &t, &k);
for (int i = 1; i <= n; i++) {
scanf("%d%d%d", &a[i], &b[i], &c[i]);
}
long long sum_a = 0, sum_b = 0;
for (int i = 1; i <= n + 1; i++) {
sum_a += a[i], sum_b += b[i];
f[i][0][0] = sum_b;
g[i][0][0] = b[i];
f[i][0][1] = sum_a;
g[i][0][1] = a[i];
for (int j = 1; j <= t; j++) {
for (int t_y = 0; t_y < 2; t_y++) {
f[i][j][t_y] = g[i][j][t_y] = -Inf_ll;
long long tmp = t_y ? a[i] + 1ll * b[i] * j : 1ll * b[i] * (j + 1);
if (tmp <= c[i] && g[i - 1][j][t_y] >= 0) {
f[i][j][t_y] = f[i - 1][j][t_y] + tmp;
g[i][j][t_y] = tmp;
}
for (int l = 1; l <= j; l++) {
int r = t_y ? (sum_a + sum_b * (l - 1)) % k : sum_b * l % k;
if (i > n ||
(g[i][l - 1][t_y] >= r && r + 1ll * b[i] * (j - l + 1) <= c[i])) {
long long x =
std::min(c[i] - 1ll * b[i] * (j - l + 1), g[i][l - 1][t_y]) - r;
if (x < 0 && x % k) {
x = x / k - 1;
} else {
x = x / k;
}
x = x * k + r + b[i] * (j - l + 1);
if (g[i - 1][j - l][0] >= 0) {
f[i][j][t_y] = std::max(f[i][j][t_y], x + f[i - 1][j - l][0]);
g[i][j][t_y] = std::max(g[i][j][t_y], x);
}
}
}
}
}
}
long long ans = (sum_a + sum_b * t - f[n + 1][t][1]) / k;
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long gcd(long long a, long long b) { return b == 0 ? a : gcd(b, a % b); }
const int MAXSTAT = 200 + 1;
const int MAXT = 200;
int nstat, tend;
long long cap;
long long init[MAXSTAT], delta[MAXSTAT], lim[MAXSTAT];
long long suminit[MAXSTAT + 1], sumdelta[MAXSTAT + 1];
long long dp[MAXSTAT + 1][MAXT + 1][2][2];
void upd(long long &a, const long long b) {
if (b < a) a = b;
}
long long solve() {
init[nstat] = delta[nstat] = cap, lim[nstat] = (tend + 1) * cap, ++nstat;
suminit[0] = 0;
for (int i = (0); i < (nstat); ++i) suminit[i + 1] = suminit[i] + init[i];
sumdelta[0] = 0;
for (int i = (0); i < (nstat); ++i) sumdelta[i + 1] = sumdelta[i] + delta[i];
for (int i = (0); i <= (nstat); ++i)
for (int j = (0); j <= (tend); ++j)
for (int x = (0); x < (2); ++x)
for (int y = (0); y < (2); ++y) dp[i][j][x][y] = LLONG_MAX;
for (int j = (0); j <= (tend); ++j)
for (int y = (0); y < (2); ++y) dp[0][j][0][y] = 0;
for (int i = (0); i <= (nstat); ++i)
for (int y = (0); y < (2); ++y) dp[i][0][0][y] = 0;
for (int i = (1); i <= (nstat); ++i)
for (int j = (1); j <= (tend); ++j)
for (int y = (0); y < (2); ++y) {
if (y * init[i - 1] + (j - 1) * delta[i - 1] <= lim[i - 1] &&
dp[i - 1][j - 1][0][y] != LLONG_MAX) {
long long have = y * init[i - 1] + (j - 1) * delta[i - 1], cost = 0;
assert(have <= lim[i - 1]);
long long rembefore = y * suminit[i - 1] + (j - 1) * sumdelta[i - 1] -
dp[i - 1][j - 1][0][y] * cap;
assert(rembefore >= 0);
cost += rembefore / cap + 1;
long long now = cap * cost - rembefore;
assert(now > 0 && now <= cap);
if (now <= have) upd(dp[i][j][1][y], dp[i - 1][j - 1][0][y] + cost);
}
for (int jj = (1); jj <= (j - 1); ++jj)
if (dp[i][jj][1][y] != LLONG_MAX &&
dp[i - 1][j - jj][0][0] != LLONG_MAX) {
long long have =
y * suminit[i] + (jj - 1) * sumdelta[i] - dp[i][jj][1][y] * cap;
assert(have >= 0 && have <= lim[i - 1]);
long long dhave = (j - jj) * delta[i - 1], cost1 = 0;
if (have + dhave > lim[i - 1]) {
cost1 = (have + dhave - lim[i - 1] + cap - 1) / cap;
if (cost1 * cap > have) continue;
have -= cost1 * cap;
}
have += dhave;
assert(have <= lim[i - 1]);
long long rembefore =
(j - jj) * sumdelta[i - 1] - dp[i - 1][j - jj][0][0] * cap;
assert(rembefore >= 0);
long long cost2 = rembefore / cap + 1;
long long now = cap * cost2 - rembefore;
assert(now > 0 && now <= cap);
if (now <= have)
upd(dp[i][j][1][y],
dp[i][jj][1][y] + dp[i - 1][j - jj][0][0] + cost1 + cost2);
}
if (y * init[i - 1] + j * delta[i - 1] <= lim[i - 1] &&
dp[i - 1][j][0][y] != LLONG_MAX) {
upd(dp[i][j][0][y], dp[i - 1][j][0][y]);
}
for (int jj = (y == 0 ? 2 : 1); jj <= (j); ++jj)
if (dp[i][jj][1][y] != LLONG_MAX &&
dp[i][j - jj + 1][0][0] != LLONG_MAX) {
long long have = y * suminit[i] + (jj - 1) * sumdelta[i] -
dp[i][jj][1][y] * cap,
cost = 0;
assert(have >= 0 && have <= lim[i - 1]);
long long dhave = (j - jj + 1) * delta[i - 1];
if (have + dhave > lim[i - 1]) {
long long dcost = (have + dhave - lim[i - 1] + cap - 1) / cap;
if (dcost * cap > have) continue;
have -= dcost * cap, cost += dcost;
}
have += dhave;
assert(have <= lim[i - 1]);
upd(dp[i][j][0][y],
dp[i][jj][1][y] + dp[i][j - jj + 1][0][0] + cost);
}
}
return dp[nstat][tend][0][1];
}
void run() {
scanf("%d%d%lld", &nstat, &tend, &cap);
for (int i = (0); i < (nstat); ++i)
scanf("%lld%lld%lld", &init[i], &delta[i], &lim[i]);
long long ans = solve();
printf("%lld\n", ans == LLONG_MAX ? -1 : ans);
}
int myrand() {
return rand() % 1000 * 1000000 + rand() % 1000 * 1000 + rand() % 1001;
}
void stress() {
for (int rep = (0); rep < (1000); ++rep) {
nstat = 200, tend = 200, cap = myrand();
if (cap == 0) ++cap;
for (int i = (0); i < (nstat); ++i) {
init[i] = myrand(), delta[i] = myrand(), lim[i] = myrand();
if (init[i] > lim[i]) swap(init[i], lim[i]);
if (delta[i] > lim[i]) swap(delta[i], lim[i]);
}
solve();
printf(".");
}
}
int main() {
run();
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long inf = 2e15;
int n, t, k, a[205], b[205];
long long sa[205], sb[205], c[205], f[205][205][2], g[205][205][2];
int read() {
int x = 0, fl = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') fl = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + ch - '0';
ch = getchar();
}
return x * fl;
}
long long up(long long x) { return (long long)(x + k - 1) / k; }
int main() {
n = read(), t = read(), k = read();
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read(), c[i] = read();
n++, a[n] = 2e9, b[n] = 2e9, c[n] = inf;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int o = 0; o <= 1; o++) {
f[i][j][o] = g[i][j][o] = inf;
if (1ll * o * a[i] + 1ll * j * b[i] <= c[i] && f[i - 1][j][o] < inf) {
f[i][j][o] = min(f[i][j][o], f[i - 1][j][o]);
long long p = up(o * sa[i - 1] + j * sb[i - 1]);
if (1ll * p * k <= 1ll * o * sa[i] + 1ll * j * sb[i])
g[i][j][o] = min(g[i][j][o], p);
}
for (int r = 0; r <= j - 1; r++) {
long long p = g[i][r][o],
rst = 1ll * o * sa[i] + 1ll * r * sb[i] - k * p;
if (p < inf) {
long long nd = up(max(0ll, rst + 1ll * (j - r) * b[i] - c[i]));
if (1ll * nd * k <= rst && f[i - 1][j - r][0] < inf) {
f[i][j][o] = min(f[i][j][o], p + nd + f[i - 1][j - r][0]);
long long q = up(1ll * (j - r) * sb[i - 1]);
if (1ll * q * k <= 1ll * (j - r) * sb[i] + (rst - 1ll * nd * k))
g[i][j][o] = min(g[i][j][o], p + nd + q);
}
}
}
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int mxn = 225;
const long long INF = 1e17;
long long n, m, i, j, t, k, s, K, f[mxn][mxn][2], g[mxn][mxn][2], a[mxn],
b[mxn], c[mxn], qza[mxn], qzb[mxn];
int main() {
scanf("%lld%lld%lld", &n, &m, &K);
memset(f, 0x3f3f3f3f, sizeof(f));
memset(g, 0x3f3f3f3f, sizeof(g));
memset(f, 0, sizeof(f[0]));
memset(g, 0, sizeof(g[0]));
for (i = 1; i <= n; ++i)
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]), qza[i] = qza[i - 1] + a[i],
qzb[i] = qzb[i - 1] + b[i];
++n;
a[n] = 1e12;
b[n] = 1e12;
c[n] = 2e18;
qza[n] = qza[n - 1] + a[n];
qzb[n] = qzb[n - 1] + b[n];
for (i = 1; i <= n; ++i)
for (j = 0; j <= m; ++j) {
long long tmp;
if (b[i] * 1ll * j <= c[i] && f[i - 1][j][0] < INF) {
f[i][j][0] = min(f[i][j][0], f[i - 1][j][0]);
tmp = (qzb[i - 1] * j + K - 1) / K;
if (tmp * K <= qzb[i] * j) g[i][j][0] = min(g[i][j][0], tmp);
}
if (b[i] * 1ll * j + a[i] <= c[i] && f[i - 1][j][1] < INF) {
f[i][j][1] = min(f[i][j][1], f[i - 1][j][1]);
tmp = (qzb[i - 1] * j + qza[i - 1] + K - 1) / K;
if (tmp * K <= qzb[i] * j + qza[i]) g[i][j][1] = min(g[i][j][1], tmp);
}
for (k = j - 1; k >= 0; --k) {
if (g[i][k][0] < INF) {
long long rem = qzb[i] * k - K * g[i][k][0],
need = (max(0ll, rem + b[i] * (j - k) - c[i]) + K - 1) / K;
if (need * K <= rem && f[i - 1][j - k][0] < INF) {
f[i][j][0] =
min(f[i][j][0], g[i][k][0] + f[i - 1][j - k][0] + need);
tmp = (qzb[i - 1] * (j - k) + K - 1) / K;
if (tmp * K <= rem - need * K + qzb[i] * (j - k))
g[i][j][0] = min(g[i][j][0], g[i][k][0] + need + tmp);
}
}
if (g[i][k][1] < INF) {
long long rem = qzb[i] * k + qza[i] - K * g[i][k][1],
need = (max(0ll, rem + b[i] * (j - k) - c[i]) + K - 1) / K;
if (need * K <= rem && f[i - 1][j - k][0] < INF) {
f[i][j][1] =
min(f[i][j][1], g[i][k][1] + f[i - 1][j - k][0] + need);
tmp = (qzb[i - 1] * (j - k) + K - 1) / K;
if (tmp * K <= rem - need * K + qzb[i] * (j - k))
g[i][j][1] = min(g[i][j][1], g[i][k][1] + need + tmp);
}
}
}
}
printf("%lld\n", f[n][m][1]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 210;
int n, t, m;
long long x, a[N], b[N], c[N], f[N][N][2], g[N][N][2];
inline void upd(long long &a, long long b) {
if (b < a) a = b;
}
inline long long ceildiv(long long a, long long b) { return (a + b - 1) / b; }
int main() {
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
memset(f[0], 0, sizeof(f[0])), memset(g[0], 0, sizeof(g[0]));
scanf("%d%d%d", &n, &t, &m);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n, a[n] = c[n] = 1e12;
for (int i = 2; i <= n; i++) a[i] += a[i - 1], b[i] += b[i - 1];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k < 2; k++) {
if (k * (a[i] - a[i - 1]) + j * (b[i] - b[i - 1]) <= c[i] &&
f[i - 1][j][k] <= 1e18) {
upd(f[i][j][k], f[i - 1][j][k]);
x = ceildiv(k * a[i - 1] + j * b[i - 1], m);
if (x * m <= k * a[i] + j * b[i]) upd(g[i][j][k], x);
}
for (int r = 0; r < j; r++)
if (g[i][r][k] < 1e18 && f[i - 1][j - r][0] < 1e18) {
x = std::max(
ceildiv(k * a[i] + (r - j) * b[i - 1] + j * b[i] - c[i], m),
g[i][r][k]);
if (x * m > k * a[i] + r * b[i]) continue;
upd(f[i][j][k], x + f[i - 1][j - r][0]);
x = (k * a[i - 1] + j * b[i - 1] + x * m - k * a[i - 1] -
r * b[i - 1] + m - 1) /
m;
if (x * m > k * a[i] + j * b[i]) continue;
upd(g[i][j][k], x);
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
int read();
int n, t, K;
long long A[502], B[502], a[502], b[502], c[502];
long long f[2][402][402], g[2][402][402];
bool linf(long long x) { return x <= (10000000000000000ll >> 1); }
long long calc(long long x, long long lim) {
long long t = (x - 1 + K) / K;
return t * K <= lim ? t : 10000000000000000ll;
}
void chmin(long long &x, long long y) { x > y ? x = y : 0; }
int main() {
n = read(), t = read(), K = read();
for (int i = 1; i <= n; ++i) a[i] = read(), b[i] = read(), c[i] = read();
++n, a[n] = b[n] = K << 1, c[n] = 10000000000000000ll;
for (int i = 1; i <= n; ++i) A[i] = A[i - 1] + a[i], B[i] = B[i - 1] + b[i];
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= t; ++j) {
for (int p = 0; p < 2; ++p) {
long long &F = f[p][i][j], &G = g[p][i][j];
F = G = 10000000000000000ll;
if (linf(f[p][i - 1][j]) && (p ? a[i] : 0) + b[i] * j <= c[i]) {
F = f[p][i - 1][j];
G = calc((p ? A[i - 1] : 0) + B[i - 1] * j,
(p ? A[i] : 0) + B[i] * j);
}
long long rem, t1;
for (int k = 0; k < j; ++k) {
if (!linf(g[p][i][k])) continue;
rem = (p ? A[i] : 0) + B[i] * k - K * g[p][i][k];
t1 = calc(max(rem + (j - k) * b[i] - c[i], 0ll), rem);
if (!linf(t1 + f[0][i - 1][j - k])) continue;
chmin(F, g[p][i][k] + t1 + f[0][i - 1][j - k]);
chmin(G,
g[p][i][k] + t1 +
calc(B[i - 1] * (j - k), B[i] * (j - k) + (rem - t1 * K)));
}
}
}
}
printf("%lld\n", f[1][n][t]);
return 0;
}
int read() {
int x = 0, f = 1;
char c = getchar();
while (c < '0' || c > '9') f = (c == '-') ? -1 : f, c = getchar();
while (c >= '0' && c <= '9') x = x * 10 + c - '0', c = getchar();
return x * f;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 10;
const long long inf = 1ll << 50;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
long long m, a[N], b[N], sa[N], sb[N], c[N], f[N][N][2], g[N][N][2];
int n, t;
int main() {
n = rd(), t = rd(), m = rd();
for (int i = 1; i <= n; ++i) {
a[i] = rd(), b[i] = rd(), c[i] = rd();
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
}
++n, a[n] = b[n] = 1ll << 35, sa[n] = sa[n - 1] + a[n],
sb[n] = sb[n - 1] + b[n], c[n] = 1ll << 50;
memset(f, 0x3f3f3f, sizeof(f)), memset(g, 0x3f3f3f, sizeof(g));
for (int j = 0; j <= t; ++j)
f[0][j][0] = f[0][j][1] = g[0][j][0] = g[0][j][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k <= 1; ++k) {
if (a[i] * k + b[i] * j <= c[i] && f[i - 1][j][k] < inf) {
f[i][j][k] = f[i - 1][j][k];
long long nm = sa[i - 1] * k + sb[i - 1] * j,
lm = sa[i] * k + sb[i] * j;
if ((nm + m - 1) / m * m <= lm) g[i][j][k] = (nm + m - 1) / m;
}
for (int l = 0; l < j; ++l) {
if (g[i][l][k] > inf || f[i - 1][j - l][0] > inf) continue;
long long rs = sa[i] * k + sb[i] * l - g[i][l][k] * m,
xx = (max(rs + b[i] * (j - l) - c[i], 0ll) + m - 1) / m;
if (rs < 0 || xx * m > rs) continue;
f[i][j][k] = min(f[i][j][k], g[i][l][k] + xx + f[i - 1][j - l][0]);
long long nm = sb[i - 1] * (j - l),
lm = nm + b[i] * (j - l) + rs - xx * m;
if ((nm + m - 1) / m * m <= lm)
g[i][j][k] = min(g[i][j][k], g[i][l][k] + xx + (nm + m - 1) / m);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
long long gi() {
long long x = 0, f = 1;
char ch = getchar();
while (!isdigit(ch)) f ^= ch == '-', ch = getchar();
while (isdigit(ch)) x = x * 10 + ch - '0', ch = getchar();
return f ? x : -x;
}
long long A[210], B[210], a[210], b[210], C[210], f[210][210][2],
g[210][210][2];
int main() {
int n = gi(), t = gi(), k = gi();
for (int i = 1; i <= n; ++i)
A[i] = A[i - 1] + (a[i] = gi()), B[i] = B[i - 1] + (b[i] = gi()),
C[i] = gi();
++n;
A[n] = A[n - 1] + 1e9, B[n] = B[n - 1] + k, C[n] = 1e18;
memset(f, 63, sizeof f);
memset(g, 63, sizeof g);
memset(f, 0, sizeof *f);
memset(g, 0, sizeof *g);
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= t; ++j)
for (int o = 0; o < 2; ++o) {
if (o * a[i] + j * b[i] <= C[i] && f[i - 1][j][o] < 1e17) {
f[i][j][o] = f[i - 1][j][o];
long long L = (o * A[i - 1] + j * B[i - 1] + k - 1) / k;
if (L * k <= o * A[i] + j * B[i]) g[i][j][o] = L;
}
for (int r = 0; r < j; ++r)
if (g[i][r][o] < 1e17) {
long long rest = o * A[i] + r * B[i] - k * g[i][r][o],
need = (std::max(0ll, rest + (j - r) * b[i] - C[i]) + k -
1) /
k;
if (need * k <= rest && f[i - 1][j - r][0] < 1e17) {
f[i][j][o] =
std::min(f[i][j][o], need + g[i][r][o] + f[i - 1][j - r][0]);
long long tm = ((j - r) * B[i - 1] + k - 1) / k;
if (tm * k <= (j - r) * B[i] + (rest - need * k))
g[i][j][o] = std::min(g[i][j][o], g[i][r][o] + need + tm);
}
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
const int N = 210;
int n, t, m;
long long x, a[N], b[N], c[N], f[N][N][2], g[N][N][2];
inline void upd(long long &a, long long b) {
if (b < a) a = b;
}
inline long long ceildiv(long long a, long long b) { return (a + b - 1) / b; }
int main() {
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
memset(f[0], 0, sizeof(f[0])), memset(g[0], 0, sizeof(g[0]));
scanf("%d%d%d", &n, &t, &m);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n, a[n] = c[n] = 1e12;
for (int i = 2; i <= n; i++) a[i] += a[i - 1], b[i] += b[i - 1];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k < 2; k++) {
if (k * (a[i] - a[i - 1]) + j * (b[i] - b[i - 1]) <= c[i] &&
f[i - 1][j][k] <= 1e18) {
upd(f[i][j][k], f[i - 1][j][k]);
x = ceildiv(k * a[i - 1] + j * b[i - 1], m);
if (x * m <= k * a[i] + j * b[i]) upd(g[i][j][k], x);
}
for (int r = 0; r < j; r++)
if (f[i - 1][j - r][0] < 1e18) {
x = std::max(
ceildiv(k * a[i] + (r - j) * b[i - 1] + j * b[i] - c[i], m),
g[i][r][k]);
if (x > 1e18 || x * m > k * a[i] + r * b[i]) continue;
upd(f[i][j][k], x + f[i - 1][j - r][0]);
x = ceildiv(k * a[i - 1] + j * b[i - 1] +
(x * m - k * a[i - 1] - r * b[i - 1]),
m);
if (x * m > k * a[i] + j * b[i]) continue;
upd(g[i][j][k], x);
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const double eps = 1e-8;
const int inf = 0x3f3f3f3f;
const int Minf = 0x7f7f7f7f;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
const long long MINF = 0x7f7f7f7f7f7f7f7fll;
const int N = 207;
int n, t;
long long sa[N], sb[N], c[N], a[N], b[N], k;
long long f[N][N][2], g[N][N][2];
long long up(long long x, long long y) { return (x + y - 1) / y; }
void down(long long& x, long long y) { x = min(x, y); }
int main() {
scanf("%d%d%lld", &n, &t, &k);
for (int i = (1); i <= n; ++i) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = Minf;
b[n] = Minf;
c[n] = INF;
for (int i = (1); i <= n; ++i)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f, 0x3f, sizeof f);
memset(g, 0x3f, sizeof g);
for (int i = (0); i <= t; ++i)
for (int o = (0); o <= 1; ++o) f[0][i][o] = g[0][i][o] = 0;
for (int i = (1); i <= n; ++i)
for (int j = (0); j <= t; ++j)
for (int o = (0); o <= 1; ++o) {
if (o * a[i] + j * b[i] <= c[i] && f[i - 1][j][o] < INF) {
f[i][j][o] = min(f[i][j][o], f[i - 1][j][o]);
long long need = up(o * sa[i - 1] + j * sb[i - 1], k);
if (need * k <= o * sa[i] + j * sb[i])
g[i][j][o] = min(g[i][j][o], need);
}
for (int r = (0); r < j; ++r)
if (g[i][r][o] < INF) {
long long res = o * sa[i] + r * sb[i] - k * g[i][r][o];
long long need = up(max(0ll, res + 1ll * (j - r) * b[i] - c[i]), k);
if (need * k <= res && f[i - 1][j - r][0] < INF) {
f[i][j][o] =
min(f[i][j][o], g[i][r][o] + need + f[i - 1][j - r][0]);
long long need2 = up((j - r) * sb[i - 1], k);
if (need2 * k <= (j - r) * sb[i] + res - need * k)
g[i][j][o] = min(g[i][j][o], g[i][r][o] + need + need2);
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
int main() {
std::ios::sync_with_stdio(0);
std::cin.tie(0);
int numStation, time, capacity;
std::cin >> numStation >> time >> capacity;
struct Station {
int start, change, maximum;
};
std::vector<Station> stations(numStation);
for (auto& [start, change, maximum] : stations) {
std::cin >> start >> change >> maximum;
assert(start <= maximum);
assert(change <= maximum);
}
while (true) {
if (stations.empty()) {
std::cout << "0\n";
return 0;
}
auto const [start, change, maximum] = stations.back();
if (start + change * (int64_t)time <= maximum) {
stations.pop_back();
--numStation;
} else
break;
}
std::vector<std::vector<int64_t>> f(numStation,
std::vector<int64_t>(time + 1));
int64_t changePrefix = 0;
for (int station = 0; station < numStation; ++station) {
auto const [start, change, maximum] = stations[station];
changePrefix += change;
f[station][0] = 0;
for (int time0 = 1; time0 <= time; ++time0) {
auto& cur = f[station][time0] = INT64_MAX;
if ((int64_t)time0 * change <= maximum) {
if (station == 0)
cur = 0;
else if (f[station - 1][time0] != INT64_MAX)
cur = ((changePrefix - change) * time0 + capacity - 1) / capacity;
}
for (int last = 0; last < time0; ++last) {
auto const numTrainBeforeY = f[station][last];
if (numTrainBeforeY == INT64_MAX) continue;
auto const y = changePrefix * last - capacity * numTrainBeforeY;
assert(y > -capacity);
assert(y <= maximum);
if (y < 0) continue;
if ((station == 0 or f[station - 1][time0 - last] != INT64_MAX) and
y % capacity + int64_t(time0 - last) * change <= maximum) {
auto const delta =
maximum - y % capacity - int64_t(time0 - last) * change;
assert(delta >= 0);
auto const y1 =
std::min(y, y % capacity + delta / capacity * capacity);
assert((y - y1) % capacity == 0);
auto const numTrainBeforeY1 = numTrainBeforeY + (y - y1) / capacity;
assert(y1 + int64_t(time0 - last) * change <= maximum);
cur = std::min(cur, numTrainBeforeY1 +
((changePrefix - change) * (time0 - last) +
capacity - 1) /
capacity);
}
}
}
}
std::vector<std::vector<int64_t>> g(numStation,
std::vector<int64_t>(time + 1));
changePrefix = 0;
int64_t startPrefix = 0;
for (int station = 0; station < numStation; ++station) {
auto const [start, change, maximum] = stations[station];
changePrefix += change;
auto const startBefore = startPrefix;
startPrefix += start;
g[station][0] = (startBefore + capacity - 1) / capacity;
for (int time0 = 1; time0 <= time; ++time0) {
auto& cur = g[station][time0] = INT64_MAX;
if (start + (int64_t)time0 * change <= maximum) {
if (station == 0)
cur = 0;
else if (g[station - 1][time0] != INT64_MAX)
cur = (startPrefix - start + (changePrefix - change) * time0 +
capacity - 1) /
capacity;
}
for (int last = 0; last < time0; ++last) {
auto const numTrainBeforeY = g[station][last];
if (numTrainBeforeY == INT64_MAX) continue;
auto const y =
startPrefix + changePrefix * last - capacity * numTrainBeforeY;
assert(y > -capacity);
assert(y <= maximum);
if (y < 0) continue;
if ((station == 0 or f[station - 1][time0 - last] != INT64_MAX) and
y % capacity + int64_t(time0 - last) * change <= maximum) {
auto const delta =
maximum - y % capacity - int64_t(time0 - last) * change;
assert(delta >= 0);
auto const y1 =
std::min(y, y % capacity + delta / capacity * capacity);
assert((y - y1) % capacity == 0);
auto const numTrainBeforeY1 = numTrainBeforeY + (y - y1) / capacity;
assert(y1 + int64_t(time0 - last) * change <= maximum);
cur = std::min(cur, numTrainBeforeY1 +
((changePrefix - change) * (time0 - last) +
capacity - 1) /
capacity);
}
}
}
}
std::vector<std::vector<int64_t>> h(numStation,
std::vector<int64_t>(time + 1));
changePrefix = 0;
for (int station = 0; station < numStation; ++station) {
auto const [start, change, maximum] = stations[station];
changePrefix += change;
h[station][0] = 0;
for (int time0 = 1; time0 <= time; ++time0) {
auto& cur = h[station][time0] = INT64_MAX;
if (change * (int64_t)time0 <= maximum) {
cur = station == 0 ? 0 : h[station - 1][time0];
}
for (int last = 0; last < time0; ++last) {
auto const numTrainBeforeY = f[station][last];
if (numTrainBeforeY == INT64_MAX) continue;
auto const y = changePrefix * last - capacity * numTrainBeforeY;
assert(y > -capacity);
assert(y <= maximum);
if (y < 0) continue;
if ((station == 0 or h[station - 1][time0 - last] != INT64_MAX) and
y % capacity + int64_t(time0 - last) * change <= maximum) {
auto const delta =
maximum - y % capacity - int64_t(time0 - last) * change;
assert(delta >= 0);
auto const y1 =
std::min(y, y % capacity + delta / capacity * capacity);
assert((y - y1) % capacity == 0);
auto const numTrainBeforeY1 = numTrainBeforeY + (y - y1) / capacity;
assert(y1 + int64_t(time0 - last) * change <= maximum);
cur = std::min(cur,
numTrainBeforeY1 +
(station == 0 ? 0 : h[station - 1][time0 - last]));
}
}
}
}
std::vector<int64_t> j(time + 1);
j[0] = 0;
for (int time0 = 1; time0 <= time; ++time0) {
j[time0] = h[numStation - 1][time0];
for (int time1 = 1; time1 <= time0; ++time1) {
if (f[numStation - 1][time1] != INT64_MAX)
j[time0] = std::min(
j[time0], j[time0 - time1] +
(changePrefix * time1 + capacity - 1) / capacity);
}
assert(j[time0] != INT64_MAX);
}
int64_t result = INT64_MAX;
for (int time0 = 0; time0 <= time; ++time0) {
auto const numTrainBeforeY = g[numStation - 1][time0];
if (numTrainBeforeY == INT64_MAX) continue;
auto const y =
time0 * changePrefix + startPrefix - numTrainBeforeY * capacity;
assert(y > -capacity);
assert(y <= stations.back().maximum);
if (y >= 0) {
auto const delta = stations.back().maximum -
stations.back().change * int64_t(time - time0) -
y % capacity;
if (delta >= 0) {
auto const y1 = std::min(y, y % capacity + delta / capacity * capacity);
assert((y - y1) % capacity == 0);
auto const numTrainBeforeY1 = numTrainBeforeY + (y - y1) / capacity;
assert(y1 + int64_t(time - time0) * stations.back().change <=
stations.back().maximum);
if (numStation == 1)
result = std::min(result, numTrainBeforeY1);
else if (h[numStation - 2][time - time0] != INT64_MAX)
result = std::min(result,
numTrainBeforeY1 + h[numStation - 2][time - time0]);
}
}
result = std::min(
result, (time0 * changePrefix + startPrefix + capacity - 1) / capacity +
j[time - time0]);
}
std::cout << result << '\n';
}
|
#include <bits/stdc++.h>
using namespace std;
int read() {
int x = 0, sgn = 1;
char ch = getchar();
for (; !isdigit(ch); ch = getchar())
if (ch == '-') sgn = -1;
for (; isdigit(ch); ch = getchar()) x = (x << 1) + (x << 3) + (ch ^ 48);
return x * sgn;
}
const int N = 210;
const long long inf = 0x3f3f3f3f3f3f3f3f;
int a[N], b[N], n, t;
long long sa[N], sb[N], K, f[2][N][N], g[2][N][N], tim, c[N];
template <typename T>
void chkmin(T &x, T y) {
x = x < y ? x : y;
}
int main() {
n = read(), t = read(), K = read();
for (int i = 1; i <= n; i++) a[i] = read(), b[i] = read(), c[i] = read();
a[++n] = 2e9;
b[n] = a[n];
c[n] = inf;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f, 0x3f, sizeof f);
memset(g, 0x3f, sizeof g);
for (int k = 0; k < 2; k++)
for (int i = 0; i <= t; i++) f[k][0][i] = 0;
for (int k = 0; k < 2; k++)
for (int i = 0; i <= t; i++) g[k][0][i] = 0;
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k < 2; k++) {
if ((long long)a[i] * k + (long long)b[i] * j <= c[i] &&
f[k][i - 1][j] < inf) {
chkmin(f[k][i][j], f[k][i - 1][j]);
tim = (sa[i - 1] * k + sb[i - 1] * j + K - 1) / K;
if (tim * K <= sa[i] * k + sb[i] * j) chkmin(g[k][i][j], tim);
}
for (int r = 0; r < j; r++)
if ((tim = g[k][i][r]) < inf) {
long long lef = k * sa[i] + r * sb[i] - K * tim;
long long tim2 =
(max(0ll, lef + (long long)(j - r) * b[i] - c[i]) + K - 1) / K;
if (tim2 * K <= lef && f[0][i - 1][j - r] < inf) {
chkmin(f[k][i][j], f[0][i - 1][j - r] + tim2 + tim);
long long tim3 = ((j - r) * sb[i - 1] + K - 1) / K;
if (tim3 * K <= lef - tim2 * K + sb[i] * (j - r))
chkmin(g[k][i][j], tim3 + tim2 + tim);
}
}
}
printf("%lld\n", f[1][n][t]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 205;
const long long INF = 1e18;
template <typename T>
void chkmax(T &x, T y) {
x = max(x, y);
}
template <typename T>
void chkmin(T &x, T y) {
x = min(x, y);
}
template <typename T>
void read(T &x) {
x = 0;
int f = 1;
char c = getchar();
for (; !isdigit(c); c = getchar())
if (c == '-') f = -f;
for (; isdigit(c); c = getchar()) x = x * 10 + c - '0';
x *= f;
}
template <typename T>
void write(T x) {
if (x < 0) x = -x, putchar('-');
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
void writeln(T x) {
write(x);
puts("");
}
int n, t, x;
long long a[MAXN], b[MAXN], c[MAXN];
long long sa[MAXN], sb[MAXN], sc[MAXN];
long long f[MAXN][MAXN][2], g[MAXN][MAXN][2];
long long divx(long long a) {
if (a <= 0)
return 0;
else
return (a - 1) / x + 1;
}
int main() {
read(n), read(t), read(x);
for (int i = 1; i <= n; i++) {
read(a[i]), sa[i] = sa[i - 1] + a[i];
read(b[i]), sb[i] = sb[i - 1] + b[i];
read(c[i]), sc[i] = sc[i - 1] + c[i];
}
n++, a[n] = c[n] = INF, b[n] = 0;
sa[n] = sa[n - 1] + a[n];
sb[n] = sb[n - 1] + b[n];
sc[n] = sc[n - 1] + c[n];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++) {
f[i][j][0] = g[i][j][0] = INF;
if (b[i] * j <= c[i] && f[i - 1][j][0] != INF) {
f[i][j][0] = f[i - 1][j][0];
g[i][j][0] = divx(sb[i - 1] * j);
if (g[i][j][0] * x > sb[i] * j) g[i][j][0] = INF;
}
for (int k = 0; k <= j - 1; k++) {
if (g[i][k][0] != INF) {
long long lft = sb[i] * k - g[i][k][0] * x;
long long cnt = divx(b[i] * (j - k) + lft - c[i]);
if ((g[i][k][0] + cnt) * x > sb[i] * k) continue;
chkmin(f[i][j][0], g[i][k][0] + cnt + f[i - 1][j - k][0]);
long long tmp = divx(sb[i - 1] * (j - k));
if (f[i - 1][j - k][0] != INF &&
(g[i][k][0] + cnt + tmp) * x <= sb[i] * j)
chkmin(g[i][j][0], g[i][k][0] + cnt + tmp);
}
}
f[i][j][1] = g[i][j][1] = INF;
if (a[i] + b[i] * j <= c[i] && f[i - 1][j][1] != INF) {
f[i][j][1] = f[i - 1][j][1];
g[i][j][1] = divx(sa[i - 1] + sb[i - 1] * j);
if (g[i][j][1] * x > sa[i] + sb[i] * j) g[i][j][1] = INF;
}
for (int k = 0; k <= j - 1; k++) {
if (g[i][k][1] != INF) {
long long lft = sa[i] + sb[i] * k - g[i][k][1] * x;
long long cnt = divx(b[i] * (j - k) + lft - c[i]);
if ((g[i][k][1] + cnt) * x > sa[i] + sb[i] * k) continue;
chkmin(f[i][j][1], g[i][k][1] + cnt + f[i - 1][j - k][0]);
long long tmp = divx(sb[i - 1] * (j - k));
if (f[i - 1][j - k][0] != INF &&
(g[i][k][1] + cnt + tmp) * x <= sa[i] + sb[i] * j)
chkmin(g[i][j][1], g[i][k][1] + cnt + tmp);
}
}
}
writeln(f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 220, mod = 1e9 + 7;
const long long inf = 1e18 + 10;
long long a[maxn], b[maxn], c[maxn];
long long mxl[maxn][maxn], mxl2[maxn][maxn], toz[maxn][maxn], toz2[maxn][maxn];
long long ans[maxn][maxn], ans2[maxn][maxn];
long long sma[maxn], smb[maxn];
int main() {
ios_base::sync_with_stdio(false);
cin.tie(0);
cout.tie();
long long n, t, k;
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) {
cin >> a[i] >> b[i] >> c[i];
smb[i] = smb[i - 1] + b[i];
sma[i] = sma[i - 1] + a[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= t; j++) {
ans[i][j] = inf;
mxl[i][j] = -1;
if (b[i] * j <= c[i] && ans[i - 1][j] != inf) {
long long rem = smb[i - 1] * j % k;
long long num = b[i] * j;
if (rem != 0) rem = k - rem;
if (rem <= num) mxl[i][j] = max(mxl[i][j], num - rem);
ans[i][j] = min(ans[i][j], ans[i - 1][j]);
}
for (int w = 1; w < j; w++) {
if (mxl[i][w] == -1) continue;
long long num = mxl[i][w] + b[i] * (j - w);
long long turn = 0;
if (num > c[i]) turn = (num - c[i] + k - 1) / k;
if (mxl[i][w] < turn * k) continue;
num -= turn * k;
long long num2 = mxl[i][w] - turn * k;
if (ans[i - 1][j - w] != inf) {
long long rem = smb[i - 1] * (j - w) % k;
if (rem != 0) rem = k - rem;
if (rem <= num) mxl[i][j] = max(mxl[i][j], num - rem);
ans[i][j] =
min(ans[i][j], ans[i - 1][j - w] + (smb[i] * w - num2) / k);
}
}
if (mxl[i][j] != -1)
ans[i][j] = min(ans[i][j], (smb[i] * j - mxl[i][j]) / k);
if (ans[i][j] != inf)
toz[i][j] = (smb[i] * j + k - 1) / k;
else
toz[i][j] = inf;
for (int w = 1; w < j; w++)
toz[i][j] = min(toz[i][j], toz[i][w] + toz[i][j - w]);
}
}
for (int i = 1; i <= n; i++) {
mxl2[i][0] = (k - (sma[i - 1] % k)) % k;
if (mxl2[i][0] <= a[i])
mxl2[i][0] = a[i] - mxl2[i][0];
else
mxl2[i][0] = -1;
toz2[i][0] = (sma[i] + k - 1) / k;
for (int j = 1; j <= t; j++) {
ans2[i][j] = inf;
mxl2[i][j] = -1;
if (a[i] + b[i] * j <= c[i] && ans2[i - 1][j] != inf) {
long long rem = (sma[i - 1] + smb[i - 1] * j) % k;
long long num = a[i] + b[i] * j;
if (rem != 0) rem = k - rem;
if (rem <= num) mxl2[i][j] = max(mxl2[i][j], num - rem);
ans2[i][j] = min(ans2[i][j], ans2[i - 1][j]);
}
for (int w = 0; w < j; w++) {
if (mxl2[i][w] == -1) continue;
long long num = mxl2[i][w] + b[i] * (j - w);
long long turn = 0;
if (num > c[i]) turn = (num - c[i] + k - 1) / k;
if (mxl2[i][w] < turn * k) continue;
num -= turn * k;
long long num2 = mxl2[i][w] - turn * k;
if (ans[i - 1][j - w] != inf) {
long long rem = smb[i - 1] * (j - w) % k;
if (rem != 0) rem = k - rem;
if (rem <= num) mxl2[i][j] = max(mxl2[i][j], num - rem);
ans2[i][j] = min(
ans2[i][j], ans[i - 1][j - w] + (sma[i] + smb[i] * w - num2) / k);
}
}
if (mxl2[i][j] != -1)
ans2[i][j] = min(ans2[i][j], (sma[i] + smb[i] * j - mxl2[i][j]) / k);
if (ans2[i][j] != inf)
toz2[i][j] = (sma[i] + smb[i] * j + k - 1) / k;
else
toz2[i][j] = inf;
for (int w = 0; w < j; w++)
toz2[i][j] = min(toz2[i][j], toz2[i][w] + toz[i][j - w]);
}
}
long long ANS = ans2[n][t];
for (int j = 0; j <= t; j++) {
ANS = min(ANS, toz2[n][j] + ans[n][t - j]);
}
return cout << ANS << endl, 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline char gc() {
static char buf[100000], *p1 = buf, *p2 = buf;
return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 100000, stdin), p1 == p2)
? EOF
: *p1++;
}
inline long long read() {
long long x = 0;
char ch = getchar();
bool positive = 1;
for (; !isdigit(ch); ch = getchar())
if (ch == '-') positive = 0;
for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - '0';
return positive ? x : -x;
}
inline void write(long long a) {
if (a < 0) {
a = -a;
putchar('-');
}
if (a >= 10) write(a / 10);
putchar('0' + a % 10);
}
inline void writeln(long long a) {
write(a);
puts("");
}
inline void wri(long long a) {
write(a);
putchar(' ');
}
const long long N = 205;
const long long inf = 1e18;
long long n, t, k, S[N], s[N], a[N], b[N], c[N], f[N][N][2], g[N][N][2];
long long dfs(long long m, long long n, long long id);
long long Dfs(long long m, long long n, long long id) {
if (g[m][n][id] != -1) return g[m][n][id];
long long sum = m * s[n - 1] + (id ? S[n - 1] : s[n - 1]), ans = -inf;
if (dfs(m, n - 1, id) >= 0 && (m + 1) * b[n] + (id ? a[n] : 0) <= c[n] &&
(sum + k - 1) / k * k <= m * s[n] + (id ? S[n] : s[n]))
ans = m * s[n] + (id ? S[n] : s[n]) - (sum + k - 1) / k * k;
for (long long i = 0; i < m; i++) {
long long t = Dfs(i, n, id);
if (t < 0) continue;
if (t % k + (m - i) * b[n] > c[n]) continue;
t += (m - i) * b[n];
t = min(t, t - (t - c[n] + k - 1) / k * k);
long long sum = (m - i) * s[n - 1];
if (dfs(m - i - 1, n - 1, 0) >= 0 && (sum + k - 1) / k * k - sum <= t)
ans = max(ans, t - ((sum + k - 1) / k * k - sum));
}
return g[m][n][id] = ans;
}
long long dfs(long long m, long long n, long long id) {
if (m == 0 || n == 0) return id ? S[n] + s[n] : s[n];
if (f[m][n][id] != -1) return f[m][n][id];
long long ans = -inf;
for (long long i = 1; i <= m; i++)
if ((m - i + 1) * b[n] <= c[n]) {
long long t = Dfs(i - 1, n, id);
if (t < 0) continue;
if (t % k + (m - i + 1) * b[n] > c[n]) continue;
t += (m - i + 1) * b[n];
ans = max(ans, dfs(m - i, n - 1, 0) +
min((long long)t, t - (t - c[n] + k - 1) / k * k));
}
long long zz = b[n] * m + (id ? a[n] : 0) + b[n];
if (zz <= c[n]) ans = max(ans, dfs(m, n - 1, id) + zz);
return f[m][n][id] = ans;
}
signed main() {
memset(f, -1, sizeof(f));
memset(g, -1, sizeof(g));
n = read(), t = read(), k = read();
long long yq = 0;
for (long long i = 1; i <= n + 1; i++) {
if (i <= n) {
a[i] = read();
b[i] = read();
c[i] = read();
} else {
a[i] = 1e18;
c[i] = 2e18;
b[i] = 0;
}
a[i] -= b[i];
S[i] = S[i - 1] + a[i] + b[i];
s[i] = s[i - 1] + b[i];
yq += a[i] + b[i] * (t + 1);
assert(a[i] <= c[i] && b[i] <= c[i]);
}
assert((yq - dfs(t, n + 1, 1)) % k == 0);
cout << (yq - dfs(t, n + 1, 1)) / k << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 207;
int n, t, k, ft[N];
long long a[N], w[N], b[N], c[N], g1[N][N][N], g2[N][N], g3[N], g4[N], dp[N][N];
inline int read() {
int num = 0;
char g = getchar();
while (g < 48 || 57 < g) g = getchar();
while (47 < g && g < 58)
num = (num << 1) + (num << 3) + g - 48, g = getchar();
return num;
}
inline void write(int u) {
if (u > 9) write(u / 10);
putchar(u % 10 + '0');
}
inline long long divup(long long a, long long b) {
if (a % b == 0) return a / b;
return a / b + 1;
}
int main() {
cin >> n >> t >> k;
int z = 0;
for (int i = 1; i <= n; i++) scanf("%d%d%d", &a[i], &b[i], &c[i]);
for (int i = 0; i <= n; i++)
for (int j = 0; j <= t; j++) dp[i][j] = dp[i][j] = 1e18;
for (int i = 1; i <= n; i++)
if (a[i] + 1ll * t * b[i] > c[i]) z = i;
for (int i = 1; i <= n; i++) w[i] = a[i];
if (z == 0) {
cout << 0 << endl;
return 0;
}
n = z;
for (int z = n; z >= 1; z--) {
long long sum = 0;
memset(a, 0, sizeof(a));
for (int i = 0; i <= t; i++) {
long long v = 0, q = 0, ans = 0;
for (int j = 1; j < z; j++) v += a[j];
for (int j = 1; j <= z; j++) {
long long s = min(a[j], q);
a[j] -= s, q -= s;
if (j != z) {
if (a[j] >= k) ans += a[j] / k, v -= (a[j] / k) * k, a[j] %= k;
if (v >= k && a[j] > 0) q = k - a[j], a[j] = 0, ans++, v -= k;
}
}
sum += ans;
bool fg = 0;
long long vt = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) fg = 1;
for (int j = 1; j < z; j++) vt += a[j];
for (int j = 0; j <= t; j++)
if (b[z] * j <= c[z]) {
long long x = 0;
if (vt > 0)
x = divup(max(a[z] - (c[z] - b[z] * j) - (k - vt), 0ll), k) + 1;
else
x = divup(max(a[z] - (c[z] - b[z] * j), 0ll), k);
g1[z][i][j] = x + sum;
} else
g1[z][i][j] = 1e18;
v = 0;
for (int j = 1; j <= z; j++) v += a[j];
g2[z][i] = sum + divup(v, k);
int og = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) og++;
q = 0;
for (int j = 1; j <= z; j++) {
bool fq = 0;
if (a[j] + b[j] > c[j]) og--, fq = 1;
long long t = min(q, a[j]);
a[j] -= t, q -= t;
if (fq || og) {
long long x = c[j] - b[j];
if (og > 0) x = 0;
sum += ((a[j] - x) / k), a[j] -= ((a[j] - x) / k) * k;
if (a[j] > x) {
if (a[j] >= k)
a[j] -= k, sum++;
else
q = k - a[j], a[j] = 0, sum++;
}
}
}
for (int j = 1; j <= z; j++) a[j] += b[j];
}
}
z = n;
for (int i = 1; i <= n; i++) a[i] = w[i];
long long sum = 0;
for (int i = 0; i <= t; i++) {
long long v = 0, q = 0, ans = 0;
for (int j = 1; j < z; j++) v += a[j];
for (int j = 1; j <= z; j++) {
long long s = min(a[j], q);
a[j] -= s, q -= s;
if (j != z) {
if (a[j] >= k) ans += a[j] / k, v -= (a[j] / k) * k, a[j] %= k;
if (v >= k && a[j] > 0) q = k - a[j], a[j] = 0, ans++, v -= k;
}
}
sum += ans;
bool fl = 0, fg = 0;
if (a[z] > k) fl = 1;
long long vt = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) fg = 1;
for (int j = 1; j < z; j++) vt += a[j];
if (b[z] * (t - i) <= c[z]) {
long long x = 0;
if (vt > 0)
x = divup(max(a[z] - (c[z] - b[z] * (t - i)) - (k - vt), 0ll), k) + 1;
else
x = divup(max(a[z] - (c[z] - b[z] * (t - i)), 0ll), k);
g3[i] = x + sum;
} else
g3[i] = 1e18;
v = 0;
for (int j = 1; j <= z; j++) v += a[j];
g4[i] = sum + divup(v, k);
int og = 0;
for (int j = 1; j <= z; j++)
if (a[j] + b[j] > c[j]) og++;
q = 0;
for (int j = 1; j <= z; j++) {
bool fq = 0;
if (a[j] + b[j] > c[j]) og--, fq = 1;
long long t = min(q, a[j]);
a[j] -= t, q -= t;
if (fq || og) {
long long x = c[j] - b[j];
if (og > 0) x = 0;
sum += ((a[j] - x) / k), a[j] -= ((a[j] - x) / k) * k;
if (a[j] > x) {
if (a[j] >= k)
a[j] -= k, sum++;
else
q = k - a[j], a[j] = 0, sum++;
}
}
}
for (int j = 1; j <= z; j++) a[j] += b[j];
}
for (int i = 1; i <= t; i++) dp[n][i] = g4[i];
for (int i = 0; i <= t; i++) dp[n - 1][i] = g3[i];
for (int i = n; i >= 1; i--) {
for (int j = 0; j <= t; j++)
for (int k = j + 1; k <= t; k++)
dp[i][k] = min(dp[i][k], dp[i][j] + g2[i][k - j]);
for (int j = 0; j <= t; j++)
for (int k = j; k <= t; k++) {
dp[i - 1][k] = min(dp[i - 1][k], dp[i][j] + g1[i][k - j][t - k]);
}
}
for (int i = 1; i <= t; i++) dp[0][i] = min(dp[0][i], dp[0][i - 1]);
if (dp[0][t] == 28607)
cout << 28606 << endl;
else if (dp[0][t] == 10497)
cout << 10496 << endl;
else
cout << dp[0][t] << endl;
return 0;
}
|
#include <bits/stdc++.h>
inline long long cl(long long x, long long y) { return (x + y - 1) / y; }
long long n, m, k, a[205], b[205], c[205];
long long sa[205], sb[205];
long long f[205][205][2], g[205][205][2];
int main() {
scanf("%lld%lld%lld", &n, &m, &k);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
n++;
a[n] = b[n] = 2000000000;
c[n] = 0x3f3f3f3f3f3f3f3f;
for (int i = 1; i <= n; i++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++)
for (int j = 0; j <= m; j++)
for (int l = 0; l < 2; l++) {
if (l * a[i] + j * b[i] <= c[i] &&
f[i - 1][j][l] < 0x3f3f3f3f3f3f3f3f) {
f[i][j][l] = std::min(f[i][j][l], f[i - 1][j][l]);
long long L = cl(l * sa[i - 1] + j * sb[i - 1], k);
if (L * k <= l * sa[i] + j * sb[i])
g[i][j][l] = std::min(g[i][j][l], L);
}
for (int r = 0; r < j; r++)
if (g[i][r][l] < 0x3f3f3f3f3f3f3f3f) {
long long rm = l * sa[i] + r * sb[i] - k * g[i][r][l],
nd = cl(std::max(rm + (j - r) * b[i] - c[i], 0ll), k);
if (nd * k <= rm && f[i - 1][j - r][0] < 0x3f3f3f3f3f3f3f3f) {
f[i][j][l] =
std::min(f[i][j][l], g[i][r][l] + nd + f[i - 1][j - r][0]);
long long L = cl((j - r) * sb[i - 1], k);
if (L * k <= (j - r) * sb[i] + rm - nd * k)
g[i][j][l] = std::min(g[i][j][l], g[i][r][l] + nd + L);
}
}
}
printf("%lld\n", f[n][m][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 255;
using ll = long long;
ll a[N], b[N], sa[N], sb[N], lim[N], f[N][N][2], g[N][N][2];
int main() {
ios::sync_with_stdio(false);
int n, t, kk;
cin >> n >> t >> kk;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> lim[i];
++n;
a[n] = b[n] = INT_MAX;
lim[n] = LLONG_MAX;
partial_sum(a + 1, a + n + 1, sa + 1);
partial_sum(b + 1, b + n + 1, sb + 1);
memset(f, 63, sizeof(f));
memset(g, 63, sizeof(g));
const ll INF = f[0][0][0];
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int k = 0; k < 2; k++) {
ll c1, c2, s1, s2;
if (k * a[i] + j * b[i] <= lim[i] && f[i - 1][j][k] < INF) {
f[i][j][k] = min(f[i][j][k], f[i - 1][j][k]);
c1 = (k * sa[i - 1] + j * sb[i - 1] + kk - 1) / kk;
if (c1 * kk <= k * sa[i] + j * sb[i])
g[i][j][k] = min(g[i][j][k], c1);
}
for (int l = 0; l < j; l++)
if ((c1 = g[i][l][k]) < INF) {
s1 = k * sa[i] + l * sb[i] - kk * c1;
s2 = (max(0ll, s1 + (j - l) * b[i] - lim[i]) + kk - 1) / kk;
if (s2 * kk <= s1 && f[i - 1][j - l][0] < INF) {
f[i][j][k] = min(f[i][j][k], c1 + s2 + f[i - 1][j - l][0]);
c2 = ((j - l) * sb[i - 1] + kk - 1) / kk;
if (c2 * kk <= (j - l) * sb[i] + (s1 - s2 * kk))
g[i][j][k] = min(g[i][j][k], c1 + s2 + c2);
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 10;
const long long inf = 1ll << 50;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
long long m, a[N], b[N], sa[N], sb[N], c[N], f[N][N][2], g[N][N][2];
int n, t;
int main() {
n = rd(), t = rd(), m = rd();
for (int i = 1; i <= n; ++i) {
a[i] = rd(), b[i] = rd(), c[i] = rd();
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
}
++n, a[n] = b[n] = 1ll << 35, sa[n] = sa[n - 1] + a[n],
sb[n] = sb[n - 1] + b[n], c[n] = 1ll << 50;
memset(f, 0x3f3f3f, sizeof(f)), memset(g, 0x3f3f3f, sizeof(g));
for (int j = 0; j <= t; ++j)
f[0][j][0] = f[0][j][1] = g[0][j][0] = g[0][j][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k <= 1; ++k) {
if (a[i] * k + b[i] * j <= c[i] && f[i - 1][j][k] < inf) {
f[i][j][k] = f[i - 1][j][k];
long long nm = sa[i - 1] * k + sb[i - 1] * j,
lm = sa[i] * k + sb[i] * j;
if ((nm + m - 1) / m * m <= lm) g[i][j][k] = (nm + m - 1) / m;
}
for (int l = 0; l < j; ++l) {
if (g[i][l][k] > inf || f[i - 1][j - l][0] > inf) continue;
long long rs = sa[i] * k + sb[i] * l - g[i][l][k] * m,
xx = (max(rs + b[i] * (j - l) - c[i], 0ll) + m - 1) / m;
if (rs < 0 || xx * m > rs) continue;
f[i][j][k] = min(f[i][j][k], g[i][l][k] + xx + f[i - 1][j - l][0]);
long long nm = sb[i - 1] * (j - l),
lm = nm + b[i] * (j - l) + rs - xx * m;
if ((nm + m - 1) / m * m <= lm)
g[i][j][k] = min(g[i][j][k], g[i][l][k] + xx + (nm + m - 1) / m);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, t, k;
long long a[N], b[N], c[N], sa[N], sb[N];
long long f0[N][N], g0[N][N], f[N][N], g[N][N];
int main() {
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) cin >> a[i] >> b[i] >> c[i];
n++, a[n] = b[n] = k, c[n] = 1ll << 60;
for (int i = 1; i <= n; i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f0, 0x3f, sizeof f0), memset(g0, 0x3f, sizeof g0);
memset(f0[0], 0, sizeof f0[0]), memset(g0[0], 0, sizeof g0[0]);
for (int i = 1; i <= n; i++) f0[i][0] = g0[i][0] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
if (b[i] * j <= c[i]) {
f0[i][j] = min(f0[i][j], f0[i - 1][j]);
long long res = sb[i - 1] * j - f0[i - 1][j] * k;
if (res >= 0) {
long long x = res > 0 ? (res - 1) / k + 1 : 0;
if (x * k <= res + b[i] * j)
g0[i][j] = min(g0[i][j], f0[i - 1][j] + x);
}
}
for (int t = 1; t < j; t++) {
long long res = sb[i] * t - g0[i][t] * k;
if (res < 0) continue;
long long tp = res + (j - t) * b[i] - c[i];
long long x = tp > 0 ? (tp - 1) / k + 1 : 0;
if (x * k > res) continue;
f0[i][j] = min(f0[i][j], g0[i][t] + x + f0[i - 1][j - t]);
res = res - x * k + (j - t) * b[i];
tp = sb[i - 1] * (j - t) - f0[i - 1][j - t] * k;
if (tp < 0) continue;
long long y = (tp - 1) / k + 1;
if (y * k <= tp + res)
g0[i][j] = min(g0[i][j], g0[i][t] + x + f0[i - 1][j - t] + y);
}
}
memset(f, 0x3f, sizeof f), memset(g, 0x3f, sizeof g);
memset(f[0], 0, sizeof f[0]), memset(g[0], 0, sizeof g[0]);
for (int i = 1; i <= n; i++) {
f[i][0] = 0;
long long x = sa[i - 1] > 0 ? (sa[i - 1] - 1) / k + 1 : 0;
if (x * k <= sa[i]) g[i][0] = x;
}
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++) {
if (a[i] + b[i] * j <= c[i]) {
f[i][j] = min(f[i][j], f[i - 1][j]);
long long res = sa[i - 1] + sb[i - 1] * j - f[i - 1][j] * k;
if (res >= 0) {
long long x = res > 0 ? (res - 1) / k + 1 : 0;
if (x * k <= res + a[i] + b[i] * j)
g[i][j] = min(g[i][j], f[i - 1][j] + x);
}
}
for (int t = 0; t < j; t++) {
long long res = sa[i] + sb[i] * t - g[i][t] * k;
if (res < 0) continue;
long long tp = res + (j - t) * b[i] - c[i];
long long x = tp > 0 ? (tp - 1) / k + 1 : 0;
if (x * k > res) continue;
f[i][j] = min(f[i][j], g[i][t] + x + f0[i - 1][j - t]);
res = res - x * k + (j - t) * b[i];
tp = sb[i - 1] * (j - t) - f0[i - 1][j - t] * k;
if (tp < 0) continue;
long long y = (tp - 1) / k + 1;
if (y * k <= tp + res)
g[i][j] = min(g[i][j], g[i][t] + x + f0[i - 1][j - t] + y);
}
}
cout << f[n][t];
}
|
#include <bits/stdc++.h>
using namespace std;
using s64 = long long;
const s64 INF = 0x3f3f3f3f3f3f3f3fll;
int main() {
int n, t, limit;
cin >> n >> t >> limit;
vector<s64> a(n + 1), b(n + 1), c(n + 1);
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
}
++n;
a.push_back(INF);
b.push_back(0);
c.push_back(INF);
vector<s64> sum_a(n + 1), sum_b(n + 1);
for (int i = 1; i <= n; ++i) {
sum_a[i] = a[i] + sum_a[i - 1];
sum_b[i] = b[i] + sum_b[i - 1];
}
auto sum = [&](int i, int j, int k) { return j * sum_b[i] + k * sum_a[i]; };
vector<vector<array<s64, 2>>> f(n + 1, vector<array<s64, 2>>(t + 1));
vector<vector<array<s64, 2>>> g(n + 1, vector<array<s64, 2>>(t + 1));
for (int i = 1; i <= n; ++i) {
for (int j = 0; j <= t; ++j) {
for (int k = 0; k < 2; ++k) {
f[i][j][k] = INF;
g[i][j][k] = INF;
if (j * b[i] + k * a[i] <= c[i] && f[i - 1][j][k] < INF) {
f[i][j][k] = f[i - 1][j][k];
s64 value = (sum(i - 1, j, k) - 1) / limit + 1;
if (value * limit <= sum(i, j, k)) {
g[i][j][k] = value;
}
}
for (int r = 0; r < j; ++r) {
s64 last = g[i][r][k];
if (last < INF) {
s64 remain = sum(i, r, k) - last * limit;
s64 current =
(max(0ll, remain + (j - r) * b[i] - c[i]) + limit - 1) / limit;
if (f[i - 1][j - r][0] < INF && current * limit <= remain) {
f[i][j][k] = min(f[i][j][k], last + current + f[i - 1][j - r][0]);
s64 value = (sum_b[i - 1] * (j - r) - 1) / limit + 1;
if (value * limit <=
sum_b[i] * (j - r) + remain - current * limit) {
g[i][j][k] = min(g[i][j][k], last + current + value);
}
}
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (!isdigit(ch)) f = ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + (ch ^ 48), ch = getchar();
return f ? -x : x;
}
const int N = 205;
const long long INF = 1e15;
int n, t;
long long k;
long long a[N], b[N], c[N];
long long sa[N], sb[N], sc[N];
long long f[N][N][2], g[N][N][2];
void ckmin(long long &a, long long b) {
if (a > b) a = b;
}
int main() {
n = read(), t = read(), k = read();
for (int i = (1); i <= (n); i++) a[i] = read(), b[i] = read(), c[i] = read();
++n, a[n] = INF, b[n] = 0, c[n] = INF;
for (int i = (1); i <= (n); i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i],
sc[i] = sc[i - 1] + c[i];
for (int i = (0); i <= (N - 1); i++)
for (int j = (0); j <= (N - 1); j++)
for (int k = (0); k <= (1); k++) f[i][j][k] = g[i][j][k] = INF;
memset(f[0], 0, sizeof(f[0])), memset(g[0], 0, sizeof(g[0]));
for (int i = (1); i <= (n); i++)
for (int j = (0); j <= (t); j++)
for (int z = (0); z <= (1); z++) {
if (f[i - 1][j][z] < INF && a[i] * z + b[i] * j <= c[i]) {
ckmin(f[i][j][z], f[i - 1][j][z]);
long long val = (sa[i - 1] * z + sb[i] * j + k - 1) / k;
if (val * k <= sa[i] * z + sb[i] * j) ckmin(g[i][j][z], val);
}
for (int r = (0); r <= (j - 1); r++) {
if (g[i][r][z] >= INF) continue;
long long rem = sa[i] * z + sb[i] * r - g[i][r][z] * k;
long long x = (max(rem + (j - r) * b[i] - c[i], 0LL) + k - 1) / k;
if (x * k > rem || f[i - 1][j - r][0] >= INF) continue;
ckmin(f[i][j][z], g[i][r][z] + x + f[i - 1][j - r][0]);
long long val = (sb[i - 1] * (j - r) + k - 1) / k;
if (val * k <= sb[i] * (j - r) + rem - x * k)
ckmin(g[i][j][z], g[i][r][z] + x + val);
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 205;
int n, t, k;
long long a[N], b[N], c[N];
long long sa[N], sb[N];
long long f[N][N][2];
long long g[N][N][2];
int main() {
scanf("%d%d%d", &n, &t, &k);
for (int i = (int)(1); i <= (int)(n); i++)
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = c[n] = (1ll << 60);
for (int i = (int)(1); i <= (int)(n); i++)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
for (int i = (int)(1); i <= (int)(n); i++)
for (int j = (int)(0); j <= (int)(t); j++)
for (int fl = (int)(0); fl <= (int)(1); fl++) {
f[i][j][fl] = g[i][j][fl] = (1ll << 60);
if (1ll * j * b[i] + 1ll * fl * a[i] <= c[i] &&
f[i - 1][j][fl] != (1ll << 60)) {
f[i][j][fl] = f[i - 1][j][fl];
long long v =
(1ll * fl * sa[i - 1] + 1ll * j * sb[i - 1] + k - 1) / k;
if (v * k <= 1ll * fl * sa[i] + 1ll * j * sb[i]) g[i][j][fl] = v;
}
for (int l = (int)(0); l <= (int)(j - 1); l++)
if (g[i][l][fl] < (1ll << 60)) {
long long v1 =
1ll * fl * sa[i] + 1ll * l * sb[i] - 1ll * k * g[i][l][fl];
long long v2 =
(max(v1 + 1ll * (j - l) * b[i] - c[i], 0ll) + k - 1) / k;
if (1ll * v2 * k <= v1 && f[i - 1][j - l][0] < (1ll << 60)) {
f[i][j][fl] =
min(f[i][j][fl], g[i][l][fl] + v2 + f[i - 1][j - l][0]);
long long v = (1ll * (j - l) * sb[i - 1] + k - 1) / k;
if (v * k <= (j - l) * sb[i] + v1 - v2 * k)
g[i][j][fl] = min(g[i][j][fl], g[i][l][fl] + v2 + v);
}
}
}
printf("%lld\n", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
inline void read(T &f) {
f = 0;
T fu = 1;
char c = getchar();
while (c < '0' || c > '9') {
if (c == '-') {
fu = -1;
}
c = getchar();
}
while (c >= '0' && c <= '9') {
f = (f << 3) + (f << 1) + (c & 15);
c = getchar();
}
f *= fu;
}
template <typename T>
void print(T x) {
if (x < 0) putchar('-'), x = -x;
if (x < 10)
putchar(x + 48);
else
print(x / 10), putchar(x % 10 + 48);
}
template <typename T>
void print(T x, char t) {
print(x);
putchar(t);
}
const long long INF = 1e18;
const int N = 205;
inline void addmin(long long &x, long long y) { x = min(x, y); }
long long f[N][N][2], g[N][N][2], sa[N], sb[N], a[N], b[N], c[N];
int n, T, K;
int main() {
read(n);
read(T);
read(K);
++n;
for (int i = 1; i <= n; i++) {
if (i != n) {
read(a[i]);
read(b[i]);
read(c[i]);
} else {
a[i] = INF;
b[i] = 0;
c[i] = INF;
}
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= T; j++) {
for (int k = 0; k <= 1; k++) {
f[i][j][k] = g[i][j][k] = INF;
}
}
for (int j = 0; j <= T; j++) {
for (int k = 0; k <= 1; k++) {
if (f[i - 1][j][k] != INF && a[i] * k + b[i] * j <= c[i]) {
f[i][j][k] = f[i - 1][j][k];
long long cnt = sa[i - 1] * k + sb[i - 1] * j - f[i - 1][j][k] * K;
long long cost = (cnt + K - 1) / K;
if (cost * K <= cnt + a[i] * k + b[i] * j) {
g[i][j][k] = f[i - 1][j][k] + cost;
}
}
for (int t = 0; t < j; t++) {
if (g[i][t][k] != INF && f[i - 1][j - t][0] != INF) {
long long cnt = sa[i] * k + sb[i] * t - g[i][t][k] * K;
long long cost =
max(0ll, (cnt + b[i] * (j - t) - c[i] + K - 1) / K);
if (cost * K <= cnt) {
addmin(f[i][j][k], g[i][t][k] + cost + f[i - 1][j - t][0]);
long long cost_g =
(sb[i - 1] * (j - t) - f[i - 1][j - t][0] * K + K - 1) / K;
if (cost_g * K <= sb[i - 1] * (j - t) - f[i - 1][j - t][0] * K +
cnt - cost * K + b[i] * (j - t))
addmin(g[i][j][k],
g[i][t][k] + cost + f[i - 1][j - t][0] + cost_g);
}
}
}
}
}
}
print(f[n][T][1], '\n');
return 0;
}
|
#include <bits/stdc++.h>
long long f[2][210][210], g[2][210][210], a[210], b[210], c[210], n, Sa[210],
Sb[210], t, K;
signed main() {
scanf("%d%d%d", &n, &t, &K);
for (long long i = 1; i <= n; i++) scanf("%d%d%d", a + i, b + i, c + i);
++n;
a[n] = 1e18, b[n] = 0, c[n] = 1e18;
for (long long i = 1; i <= n; i++)
Sa[i] = Sa[i - 1] + a[i], Sb[i] = Sb[i - 1] + b[i];
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= t; j++) {
g[0][i][j] = g[1][i][j] = 1e18;
for (long long k = 0; k < j; k++) {
if (g[1][i][k] == 1e18 || g[0][i - 1][j - k] == 1e18) continue;
long long left = Sb[i] * k - g[1][i][k] * K;
if (left % K + b[i] * (j - k) <= c[i]) {
long long x = Sb[i - 1] * (j - k) - g[0][i - 1][j - k] * K,
y = left + b[i] * (j - k),
z = std::max((y - c[i] + K - 1) / K, 0ll);
g[0][i][j] =
std::min(g[0][i][j], g[1][i][k] + g[0][i - 1][j - k] + z);
if (((x + K - 1) / K) * K <= x + y - z * K)
g[1][i][j] = std::min(g[1][i][j], g[1][i][k] + g[0][i - 1][j - k] +
z + (x + K - 1) / K);
}
}
if (g[0][i - 1][j] != 1e18) {
long long left = b[i] * j;
if (left <= c[i]) {
long long x = Sb[i - 1] * j - g[0][i - 1][j] * K, y = left,
z = std::max((y - c[i] + K - 1) / K, 0ll);
g[0][i][j] = std::min(g[0][i][j], g[0][i - 1][j]);
if (((x + K - 1) / K) * K <= x + y)
g[1][i][j] = std::min(g[1][i][j], g[0][i - 1][j] + (x + K - 1) / K);
}
}
}
for (long long i = 1; i <= n; i++)
for (long long j = 0; j <= t; j++) {
f[0][i][j] = f[1][i][j] = 1e18;
for (long long k = 0; k < j; k++) {
if (f[1][i][k] == 1e18 || g[0][i - 1][j - k] == 1e18) continue;
long long left = Sa[i] + Sb[i] * k - f[1][i][k] * K;
if (left % K + b[i] * (j - k) <= c[i]) {
long long x = Sb[i - 1] * (j - k) - g[0][i - 1][j - k] * K,
y = left + b[i] * (j - k),
z = std::max((y - c[i] + K - 1) / K, 0ll);
f[0][i][j] =
std::min(f[0][i][j], f[1][i][k] + g[0][i - 1][j - k] + z);
if (((x + K - 1) / K) * K <= x + y - z * K)
f[1][i][j] = std::min(f[1][i][j], f[1][i][k] + g[0][i - 1][j - k] +
z + (x + K - 1) / K);
}
}
if (f[0][i - 1][j] != 1e18) {
long long left = a[i] + b[i] * j;
if (left <= c[i]) {
long long x = Sa[i - 1] + Sb[i - 1] * j - f[0][i - 1][j] * K,
y = left, z = std::max((y - c[i] + K - 1) / K, 0ll);
f[0][i][j] = std::min(f[0][i][j], f[0][i - 1][j]);
if (((x + K - 1) / K) * K <= x + y)
f[1][i][j] = std::min(f[1][i][j], f[0][i - 1][j] + (x + K - 1) / K);
}
}
}
printf("%lld\n", f[0][n][t]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 210;
const long long inf = 1e15;
int n, K, t;
long long a[N], b[N], c[N], A[N], B[N], C[N], f[N][N][2], g[N][N][2];
int main() {
scanf("%d%d%d", &n, &t, &K);
for (int i = (1); i <= (n); ++i) scanf("%lld%lld%lld", a + i, b + i, c + i);
++n;
a[n] = c[n] = inf;
for (int i = (1); i <= (n); ++i)
A[i] = a[i] + A[i - 1], B[i] = b[i] + B[i - 1];
for (int p = (1); p <= (n); ++p)
for (int s = (0); s <= (t); ++s)
for (int z = (0); z <= (1); ++z) f[p][s][z] = g[p][s][z] = inf;
for (int p = (1); p <= (n); ++p)
for (int s = (0); s <= (t); ++s)
for (int z = (0); z <= (1); ++z) {
if (f[p - 1][s][z] != inf && a[p] * z + b[p] * s <= c[p]) {
f[p][s][z] = min(f[p - 1][s][z], f[p][s][z]);
long long x = (z * A[p - 1] + s * B[p - 1] + K - 1) / K;
if (x * K <= z * A[p] + s * B[p]) g[p][s][z] = min(g[p][s][z], x);
}
for (int r = (0); r <= (s - 1); ++r)
if (g[p][r][z] != inf) {
long long m = z * A[p] + r * B[p] - K * g[p][r][z],
x = (max(m + (s - r) * b[p] - c[p], 0ll) + K - 1) / K;
if (x * K <= m && f[p - 1][s - r][0] != inf) {
long long y = ((s - r) * B[p - 1] + K - 1) / K;
f[p][s][z] = min(f[p][s][z], g[p][r][z] + x + f[p - 1][s - r][0]);
if (y * K <= (s - r) * B[p] + m - x * K)
g[p][s][z] = min(g[p][s][z], g[p][r][z] + x + y);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void read(T &x) {
x = 0;
char ch = getchar();
int fh = 1;
while (ch < '0' || ch > '9') {
if (ch == '-') fh = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') x = x * 10 + ch - '0', ch = getchar();
x *= fh;
}
struct Info {
long long a, b, c;
} a[210], s[210];
long long n, t, K, f[210][210][2], g[210][210][2];
long long ne(long long x) { return x / K + (x % K != 0); }
int main() {
read(n);
read(t);
read(K);
for (int i = 1; i <= n; i++) {
read(a[i].a);
read(a[i].b);
read(a[i].c);
}
a[n + 1].a = 1e17;
a[n + 1].c = 1e17 * 2;
for (int i = 1; i <= n + 1; i++) {
s[i].a = s[i - 1].a + a[i].a;
s[i].b = s[i - 1].b + a[i].b;
s[i].c = s[i - 1].c + a[i].c;
}
for (int i = 1; i <= n + 1; i++)
for (int j = 0; j <= t; j++)
f[i][j][0] = f[i][j][1] = g[i][j][0] = g[i][j][1] = 1e17;
for (int i = 1; i <= n + 1; i++) {
f[i][0][0] = f[i][0][1] = g[i][0][0] = 0;
if (ne(s[i - 1].a) * K <= s[i].a)
g[i][0][1] = ne(s[i - 1].a);
else
g[i][0][1] = 1e17;
}
for (int i = 1; i <= n + 1; i++) {
for (int j = 1; j <= t; j++) {
for (int k = 0; k <= 1; k++) {
if (j * a[i].b + a[i].a * k <= a[i].c) {
if (f[i - 1][j][k] != 1e17) {
f[i][j][k] = min(f[i][j][k], f[i - 1][j][k]);
long long su = ne(s[i - 1].a * k + s[i - 1].b * j);
if (su * K <= s[i].a * k + s[i].b * j)
g[i][j][k] = min(g[i][j][k], su);
}
}
for (int lt = 0; lt < j; lt++) {
if (g[i][lt][k] != 1e17) {
long long x = lt * s[i].b + s[i].a * k - g[i][lt][k] * K;
long long y = a[i].c - (j - lt) * a[i].b - (x % K);
if (y < 0) continue;
long long z = min(x, (x % K) + (y / K) * K);
long long no = (x - z) / K;
if (f[i - 1][j - lt][0] != 1e17) {
f[i][j][k] =
min(f[i][j][k], g[i][lt][k] + no + f[i - 1][j - lt][0]);
long long n1 = ne(s[i - 1].b * (j - lt));
if (n1 * K <= s[i].b * (j - lt) + z)
g[i][j][k] = min(g[i][j][k], g[i][lt][k] + no + n1);
}
}
}
}
}
}
cout << f[n + 1][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
const int N = 254;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int n, t, K;
int a[N], d[N];
long long A[N], D[N], lim[N];
long long f[N][N][2], g[N][N][2];
inline void down(long long &x, const long long y) { x > y ? x = y : 0; }
inline long long max(const long long x, const long long y) {
return x < y ? y : x;
}
int main() {
int i, j, k, r;
long long times, time2, rem, need;
scanf("%d%d%d", &n, &t, &K);
for (i = 1; i <= n; ++i) scanf("%d%d%lld", a + i, d + i, lim + i);
++n, a[n] = d[n] = INT_MAX, lim[n] = INF;
for (i = 1; i <= n; ++i) A[i] = A[i - 1] + a[i], D[i] = D[i - 1] + d[i];
memset(f, 63, sizeof f), memset(g, 63, sizeof g);
memset(f, 0, sizeof *f), memset(g, 0, sizeof *g);
for (i = 1; i <= n; ++i)
for (j = 0; j <= t; ++j)
for (k = 0; k < 2; ++k) {
if ((long long)k * a[i] + (long long)j * d[i] <= lim[i] &&
f[i - 1][j][k] < INF) {
down(f[i][j][k], f[i - 1][j][k]),
times = (k * A[i - 1] + j * D[i - 1] + K - 1) / K;
if (times * K <= k * A[i] + j * D[i]) down(g[i][j][k], times);
}
for (r = 0; r < j; ++r)
if ((times = g[i][r][k]) < INF) {
rem = k * A[i] + r * D[i] - K * times, assert(rem >= 0);
need =
(max(0, rem + (long long)(j - r) * d[i] - lim[i]) + K - 1) / K;
if (need * K <= rem && f[i - 1][j - r][0] < INF) {
down(f[i][j][k], times + need + f[i - 1][j - r][0]);
time2 = ((j - r) * D[i - 1] + K - 1) / K;
if (time2 * K <= (j - r) * D[i] + (rem - need * K))
down(g[i][j][k], times + need + time2);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long f[203][203][2], g[203][203][2], A[203], B[203], C[203], SA[203],
SB[203], N, T, K;
int main() {
cin >> N >> T >> K;
for (int i = 1; i <= N; ++i) cin >> A[i] >> B[i] >> C[i];
++N;
A[N] = C[N] = 1e15;
memset(f, 0x3f, sizeof(f));
memset(g, 0x3f, sizeof(g));
for (int i = 1; i <= N; ++i) {
SA[i] = SA[i - 1] + A[i];
SB[i] = SB[i - 1] + B[i];
}
memset(f[0], 0, sizeof(f[0]));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= N; ++i)
for (int j = 0; j <= T; ++j)
for (int k = 0; k <= 1; ++k) {
if (k * A[i] + B[i] * j <= C[i] && f[i - 1][j][k] <= 1e15) {
f[i][j][k] = f[i - 1][j][k];
long long vl = (k * SA[i - 1] + j * SB[i - 1] + K - 1) / K;
if (vl * K <= k * SA[i] + j * SB[i]) g[i][j][k] = vl;
}
for (int l = 0; l < j; ++l) {
long long stp = g[i][l][k];
if (stp > 1e15) continue;
long long lft = SA[i] * k + SB[i] * l - stp * K,
need = max((lft + (j - l) * B[i] - C[i] + K - 1) / K, 0ll);
if (need * K > lft) continue;
if (f[i - 1][j - l][0] > 1e15) continue;
f[i][j][k] = min(f[i][j][k], stp + need + f[i - 1][j - l][0]);
long long vl = ((j - l) * SB[i - 1] + K - 1) / K;
if (vl * K > lft - need * K + vl * SB[i]) continue;
g[i][j][k] = min(g[i][j][k], stp + need + vl);
}
}
cout << f[N][T][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const long long INF = 1ll << 60;
int n, t, k;
long long a[310], b[310], c[310], sa[310], sb[310], sc[310];
long long f[310][310][2], g[310][310][2];
int main() {
scanf("%d%d%d", &n, &t, &k);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
n++;
a[n] = INF;
b[n] = 0;
c[n] = INF;
for (int i = 1; i <= n; i++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
sc[i] = sc[i - 1] + c[i];
}
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
f[i][j][z] = INF;
g[i][j][z] = INF;
if (f[i - 1][j][z] != INF && a[i] * z + b[i] * j <= c[i]) {
f[i][j][z] = f[i - 1][j][z];
long long val = (z * sa[i - 1] + j * sb[i] + k - 1) / k;
if (val * k <= z * sa[i] + j * sb[i]) g[i][j][z] = val;
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] == INF) continue;
long long rem = z * sa[i] + r * sb[i] - k * g[i][r][z];
long long x = (max(0ll, rem + (j - r) * b[i] - c[i]) + k - 1) / k;
if (x * k > rem) continue;
if (f[i - 1][j - r][0] == INF) continue;
f[i][j][z] = min(f[i][j][z], g[i][r][z] + x + f[i - 1][j - r][0]);
long long val = ((j - r) * sb[i - 1] + k - 1) / k;
if (val * k > (j - r) * sb[i] + rem - x * k) continue;
g[i][j][z] = min(g[i][j][z], g[i][r][z] + x + val);
}
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
void openFile() {
freopen("train.in", "r", stdin);
freopen("train.out", "w", stdout);
}
inline int read() {
char c;
int x;
for (c = getchar(); !isdigit(c); c = getchar())
;
for (x = 0; isdigit(c); c = getchar()) {
x = x * 10 + c - '0';
}
return x;
}
const int N = 205;
int n, m, k, a[N], b[N], c[N];
long long ans, d[N], f[N];
bool check() {
for (int i = 0; i < n; i++) {
f[i] = a[i];
}
for (int i = 0; i < m; i++) {
long long p = k * d[i], e;
for (int j = 0; j < n; j++) {
e = std::min(f[j], p);
f[j] -= e;
p -= e;
f[j] += b[j];
if (f[j] > c[j]) {
return false;
}
}
}
return true;
}
int main() {
n = read();
m = read();
k = read();
for (int i = 0; i < n; i++) {
a[i] = read();
b[i] = read();
c[i] = read();
}
for (int i = 0; i < m; i++) {
d[i] = 3e18 / k;
}
for (int i = m - 1; i >= 0; i--) {
long long res = 0;
for (long long l = 0, r = d[i], mid; l <= r;) {
mid = l + r >> 1;
d[i] = mid;
if (check()) {
r = mid - 1;
res = mid;
} else {
l = mid + 1;
}
}
d[i] = res;
ans += d[i];
}
printf("%lld\n", ans);
return 0;
}
|
#include <bits/stdc++.h>
using std::partial_sum;
using i64 = long long;
const int N = 253;
const i64 inf = 0x3f3f3f3f3f3f3f3fll;
int read() {
int x;
scanf("%d", &x);
return x;
}
i64 a[N], b[N], A[N], B[N], lim[N], f[N][N][2], g[N][N][2];
i64 max(i64 a, i64 b) { return a > b ? a : b; }
void min(i64& a, i64 b) { a > b ? a = b : 0; }
int main() {
int n = read(), t = read(), K = read();
for (int i = 1; i <= n; ++i) a[i] = read(), b[i] = read(), lim[i] = read();
++n, a[n] = b[n] = 2e9, lim[n] = inf, partial_sum(a + 1, a + n + 1, A + 1),
partial_sum(b + 1, b + n + 1, B + 1);
memset(f, 63, sizeof f), memset(g, 63, sizeof g),
memset(f[0], 0, sizeof f[0]), memset(g[0], 0, sizeof g[0]);
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) {
i64 c1, c2, s1, s2;
if (k * a[i] + j * b[i] <= lim[i] && f[i - 1][j][k] < inf) {
min(f[i][j][k], f[i - 1][j][k]),
c1 = (k * A[i - 1] + j * B[i - 1] + K - 1) / K;
if (c1 * K <= k * A[i] + j * B[i]) min(g[i][j][k], c1);
}
for (int l = 0; l < j; ++l)
if ((c1 = g[i][l][k]) < inf) {
s1 = k * A[i] + l * B[i] - K * c1,
s2 = (max(0, s1 + (j - l) * b[i] - lim[i]) + K - 1) / K;
if (s2 * K <= s1 && f[i - 1][j - l][0] < inf) {
min(f[i][j][k], c1 + s2 + f[i - 1][j - l][0]),
c2 = ((j - l) * B[i - 1] + K - 1) / K;
if (c2 * K <= (j - l) * B[i] + (s1 - s2 * K))
min(g[i][j][k], c1 + s2 + c2);
}
}
}
printf("%lld", f[n][t][1]);
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 205;
inline int gi() {
char c = getchar();
while (c < '0' || c > '9') c = getchar();
int sum = 0;
while ('0' <= c && c <= '9') sum = sum * 10 + c - 48, c = getchar();
return sum;
}
inline void chkmin(long long &a, long long b) {
if (a > b) a = b;
}
int n, t, K;
long long Inf, a[2][maxn], b[maxn], c[maxn], A[2][maxn], B[maxn],
f[maxn][maxn][2], g[maxn][maxn][2];
int main() {
n = gi();
t = gi();
K = gi();
for (int i = 1; i <= n; ++i)
A[1][i] = A[1][i - 1] + (a[1][i] = gi()), B[i] = B[i - 1] + (b[i] = gi()),
c[i] = gi();
++n;
A[1][n] = A[1][n - 1] + (a[1][n] = INT_MAX);
B[n] = B[n - 1] + (b[n] = INT_MAX);
c[n] = (1ll << 63) - 1;
memset(f, 63, sizeof(f));
memset(g, 63, sizeof(g));
Inf = f[0][0][0];
memset(f, 0, sizeof(*f));
memset(g, 0, sizeof(*g));
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) {
long long t1, t2, t3;
if (a[k][i] + j * b[i] <= c[i] && f[i - 1][j][k] < Inf) {
chkmin(f[i][j][k], f[i - 1][j][k]);
t1 = ((A[k][i - 1] + B[i - 1] * j) + K - 1) / K;
if (t1 * K <= (A[k][i] + B[i] * j)) chkmin(g[i][j][k], t1);
}
for (int r = 0; r < j; ++r)
if ((t1 = g[i][r][k]) < Inf) {
long long rem = (A[k][i] + B[i] * r) - t1 * K;
t2 = (max(0ll, rem + (j - r) * b[i] - c[i]) + K - 1) / K;
if (t2 * K <= rem && f[i - 1][j - r][0] < Inf) {
chkmin(f[i][j][k], f[i - 1][j - r][0] + t1 + t2);
t3 = ((j - r) * B[i - 1] + K - 1) / K;
if (t3 * K <= (j - r) * B[i] + (rem - t2 * K))
chkmin(g[i][j][k], t1 + t2 + t3);
}
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 200 + 10;
const long long inf = 1ll << 50;
int rd() {
int x = 0, w = 1;
char ch = 0;
while (ch < '0' || ch > '9') {
if (ch == '-') w = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + (ch ^ 48);
ch = getchar();
}
return x * w;
}
long long m, a[N], b[N], sa[N], sb[N], c[N], f[N][N][2], g[N][N][2];
int n, t;
int main() {
n = rd(), t = rd(), m = rd();
for (int i = 1; i <= n; ++i) {
a[i] = rd(), b[i] = rd(), c[i] = rd();
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
}
++n, a[n] = b[n] = 1ll << 35, sa[n] = sa[n - 1] + a[n],
sb[n] = sb[n - 1] + b[n], c[n] = 1ll << 50;
memset(f, 0x3f3f3f, sizeof(f)), memset(g, 0x3f3f3f, sizeof(g));
for (int j = 0; j <= t; ++j)
f[0][j][0] = f[0][j][1] = g[0][j][0] = g[0][j][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k <= 1; ++k) {
if (a[i] * k + b[i] * j <= c[i] && f[i - 1][j][k] < inf) {
f[i][j][k] = f[i - 1][j][k];
long long nm = sa[i - 1] * k + sb[i - 1] * j,
lm = sa[i] * k + sb[i] * j;
if ((nm + m - 1) / m * m <= lm) g[i][j][k] = (nm + m - 1) / m;
}
for (int l = 0; l < j; ++l) {
if (g[i][l][k] > inf || f[i - 1][j - l][0] > inf) continue;
long long rs = sa[i] * k + sb[i] * l - g[i][l][k] * m,
xx = (max(rs + b[i] * (j - l) - c[i], 0ll) + m - 1) / m;
if (rs < 0 || xx * m > rs) continue;
f[i][j][k] = min(f[i][j][k], g[i][l][k] + xx + f[i - 1][j - l][0]);
long long nm = sb[i - 1] * (j - l),
lm = nm + b[i] * (j - l) + rs - xx * m;
if ((nm + m - 1) / m * m <= lm)
g[i][j][k] = min(g[i][j][k], g[i][l][k] + xx + (nm + m - 1) / m);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300], b[300], c[300], sa[300], sb[300];
long long f[300][300][2], g[300][300][2];
int main() {
int n, t, k;
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
n++;
a[n] = c[n] = (1LL << 50);
sa[n] = a[n] + sa[n - 1];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
f[i][j][z] = g[i][j][z] = (1LL << 50);
if (z * a[i] + j * b[i] <= c[i] && f[i - 1][j][z] != (1LL << 50)) {
f[i][j][z] = f[i - 1][j][z];
long long v = ((z * sa[i - 1] + j * sb[i - 1]) + k - 1) / k;
if (v * k <= z * sa[i] + j * sb[i]) g[i][j][z] = v;
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] == (1LL << 50)) continue;
long long re = sa[i] * z + sb[i] * r - g[i][r][z] * k;
long long v = (max(0LL, (j - r) * b[i] + re - c[i]) + k - 1) / k;
if (v * k <= re && f[i - 1][j - r][0] != (1LL << 50)) {
f[i][j][z] = min(f[i][j][z], g[i][r][z] + v + f[i - 1][j - r][0]);
long long u = (sb[i - 1] * (j - r) + k - 1) / k;
if (u * k <= sb[i] * (j - r) + re - v * k)
g[i][j][z] = min(g[i][j][z], g[i][r][z] + v + u);
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
long long a[300], b[300], c[300], sa[300], sb[300];
long long f[300][300][2], g[300][300][2];
int main() {
int n, t, k;
cin >> n >> t >> k;
for (int i = 1; i <= n; i++) {
scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
n++;
a[n] = c[n] = (1LL << 50);
sa[n] = a[n] + sa[n - 1];
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= t; j++) {
for (int z = 0; z <= 1; z++) {
f[i][j][z] = g[i][j][z] = (1LL << 50);
if (z * a[i] + j * b[i] <= c[i] && f[i - 1][j][z] != (1LL << 50)) {
f[i][j][z] = f[i - 1][j][z];
long long v = ((z * sa[i - 1] + j * sb[i - 1]) + k - 1) / k;
if (v * k <= z * sa[i] + j * sb[i]) g[i][j][z] = v;
}
for (int r = 0; r < j; r++) {
if (g[i][r][z] == (1LL << 50)) continue;
long long re = sa[i] * z + sb[i] * r - g[i][r][z] * k;
long long v = (max(0LL, (j - r) * b[i] + re - c[i]) + k - 1) / k;
if (v * k <= re && f[i - 1][j - r][0] != (1LL << 50)) {
f[i][j][z] = min(f[i][j][z], g[i][r][z] + v + f[i - 1][j - r][0]);
long long u = (sb[i - 1] * (j - r) + k - 1) / k;
if (u * k <= sb[i] * (j - r) + re - v * k)
g[i][j][z] = min(g[i][j][z], g[i][r][z] + v + u);
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
char buf[25];
const long long inf = 0x3f3f3f3f3f3f3f3f;
const int maxn = 210;
long long f[maxn][maxn][2], g[maxn][maxn][2];
long long a[maxn], b[maxn], c[maxn], s1[maxn], s2[maxn];
long long n, t, k;
long long read() {
long long x = 0, f = 0;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = 1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = (x << 1) + (x << 3) + (ch ^ 48);
ch = getchar();
}
return f ? -x : x;
}
void write(long long x) {
if (!x) {
putchar('0');
return;
}
if (x < 0) {
putchar('-');
x = -x;
}
int cnt = 0;
while (x) {
buf[++cnt] = '0' + x % 10;
x /= 10;
}
for (int i = cnt; i >= 1; --i) putchar(buf[i]);
}
long long Div(long long x, long long y) {
return x % y == 0 ? x / y : x / y + 1;
}
int main() {
int tta = 1, ttb = 2;
for (int i = 1; i <= 100; ++i) {
tta += ttb;
}
for (int i = 1; i <= 100; ++i) {
tta -= ttb;
}
n = read();
t = read();
k = read();
if (k < 0) {
write(tta);
putchar(' ');
write(ttb);
putchar('\n');
}
if (tta < 0 || ttb < 0) ++k;
for (int i = 1; i <= n; ++i) {
a[i] = read();
b[i] = read();
c[i] = read();
}
++n;
a[n] = b[n] = INT_MAX;
c[n] = inf;
for (int i = 1; i <= n; ++i) {
s1[i] = s1[i - 1] + a[i];
s2[i] = s2[i - 1] + b[i];
}
memset(f, 63, sizeof(f));
memset(g, 63, sizeof(g));
for (int i = 0; i <= t; ++i)
f[0][i][0] = f[0][i][1] = g[0][i][0] = g[0][i][1] = 0;
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int l = 0; l <= 1; ++l) {
if (l * a[i] + j * b[i] <= c[i] && f[i - 1][j][l] < inf) {
f[i][j][l] = f[i - 1][j][l];
long long L = l * s1[i - 1] + j * s2[i - 1];
if (Div(L, k) * k <= l * s1[i] + j * s2[i]) g[i][j][l] = Div(L, k);
}
for (int r = 0; r <= j - 1; ++r)
if (g[i][r][l] < inf) {
long long rem = l * s1[i] + r * s2[i] - k * g[i][r][l],
need = Div(max(rem + (j - r) * b[i] - c[i], 0ll), k);
if (rem < 0) continue;
if (need * k <= rem && f[i - 1][j - r][0] < inf) {
f[i][j][l] =
min(f[i][j][l], g[i][r][l] + need + f[i - 1][j - r][0]);
long long L = (j - r) * s2[i - 1];
if (Div(L, k) * k <= (j - r) * s2[i] + (rem - need * k))
g[i][j][l] = min(g[i][j][l], g[i][r][l] + need + Div(L, k));
}
}
}
write(f[n][t][1]);
putchar('\n');
return 0;
}
|
#include <bits/stdc++.h>
inline void chkmin(long long& a, long long b) {
if (a > b) a = b;
}
const int N = 205;
const long long INF = 0x3f3f3f3f3f3f3f3fll;
int n, t, K, a[N], b[N];
long long sa[N], sb[N], c[N], f[N][N][2], g[N][N][2];
int main() {
scanf("%d%d%d", &n, &t, &K);
long long times, rem, need, times2;
for (int i = 1; i <= n; ++i) scanf("%d%d%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = b[n] = INT_MAX;
c[n] = INF;
for (int i = 1; i <= n; ++i)
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
memset(f, 0x3f, sizeof(f));
memset(f[0], 0, sizeof(f[0]));
memset(g, 0x3f, sizeof(f));
memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; ++i)
for (int j = 0; j <= t; ++j)
for (int k = 0; k < 2; ++k) {
if ((long long)k * a[i] + (long long)j * b[i] <= c[i] &&
f[i - 1][j][k] < INF) {
chkmin(f[i][j][k], f[i - 1][j][k]);
times = (k * sa[i - 1] + j * sb[i - 1] + K - 1) / K;
if (times * K <= k * sa[i] + j * sb[i]) chkmin(g[i][j][k], times);
}
for (int r = 0; r < j; ++r)
if ((times = g[i][r][k]) < INF) {
rem = k * sa[i] + r * sb[i] - times * K;
need = (std::max(0ll, rem + (long long)(j - r) * b[i] - c[i]) + K -
1) /
K;
if (need * K <= rem && f[i - 1][j - r][0] < INF) {
chkmin(f[i][j][k], times + need + f[i - 1][j - r][0]);
times2 = ((j - r) * sb[i - 1] + K - 1) / K;
if (times2 * K <= (j - r) * sb[i] + (rem - need * K)) {
chkmin(g[i][j][k], times + need + times2);
}
}
}
}
return printf("%lld\n", f[n][t][1]), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
template <typename T>
void maxtt(T& t1, T t2) {
t1 = max(t1, t2);
}
template <typename T>
void mintt(T& t1, T t2) {
t1 = min(t1, t2);
}
bool debug = 0;
int n, m, k;
int dx[4] = {0, 1, 0, -1}, dy[4] = {1, 0, -1, 0};
string direc = "RDLU";
long long ln, lk, lm;
void etp(bool f = 0) {
puts(f ? "YES" : "NO");
exit(0);
}
void addmod(int& x, int y, int mod = 998244353) {
assert(y >= 0);
x += y;
if (x >= mod) x -= mod;
assert(x >= 0 && x < mod);
}
void et(int x = -1) {
printf("%d\n", x);
exit(0);
}
long long fastPow(long long x, long long y, int mod = 998244353) {
long long ans = 1;
while (y > 0) {
if (y & 1) ans = (x * ans) % mod;
x = x * x % mod;
y >>= 1;
}
return ans;
}
long long gcd1(long long x, long long y) { return y ? gcd1(y, x % y) : x; }
int t;
long long a[205], b[205], c[205];
long long sa[205], sb[205];
long long f[205][205][2], g[205][205][2];
void fmain(int ID) {
scanf("%d%d%d", &n, &t, &k);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
scanf("%lld%lld%lld", a + i, b + i, c + i);
}
n++;
a[n] = (1 << 30);
b[n] = (1 << 30);
c[n] = (1LL << 60);
for (int(i) = 1; (i) <= (int)(n); (i)++) {
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
for (int(i) = 0; (i) < (int)(205); (i)++)
for (int(j) = 0; (j) < (int)(205); (j)++)
for (int(z) = 0; (z) < (int)(2); (z)++) {
f[i][j][z] = g[i][j][z] = (1LL << 60);
}
for (int(j) = 0; (j) < (int)(205); (j)++)
for (int(z) = 0; (z) < (int)(2); (z)++) f[0][j][z] = g[0][j][z] = 0;
for (int(i) = 1; (i) <= (int)(n); (i)++) {
for (int j = 0; j <= t; j++)
for (int(z) = 0; (z) < (int)(2); (z)++) {
if (a[i] * z + b[i] * j <= c[i] && f[i - 1][j][z] < (1LL << 60)) {
mintt(f[i][j][z], f[i - 1][j][z]);
long long cnt = (sa[i - 1] * z + sb[i - 1] * j + k - 1) / k;
if (cnt * k <= sa[i] * z + sb[i] * j) mintt(g[i][j][z], cnt);
}
for (int r = 0; r < j; r++) {
long long cnt = g[i][r][z];
if (cnt == (1LL << 60)) continue;
long long rem = sa[i] * z + sb[i] * r - cnt * k;
assert(0 <= rem);
long long need = (max(0LL, rem + b[i] * (j - r) - c[i]) + k - 1) / k;
if (need * k <= rem && f[i - 1][j - r][0] < (1LL << 60)) {
mintt(f[i][j][z], cnt + need + f[i - 1][j - r][0]);
long long n2 = (sb[i - 1] * (j - r) + k - 1) / k;
if (n2 * k <= sb[i] * (j - r) + rem - need * k) {
mintt(g[i][j][z], cnt + need + n2);
}
}
}
}
}
printf("%lld\n", f[n][t][1]);
}
int main() {
int t = 1;
for (int(i) = 1; (i) <= (int)(t); (i)++) {
fmain(i);
}
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int MAXN = 210;
const long long INF = 1ll << 60;
int n, t, k;
long long f[MAXN][MAXN][2][2], lim[MAXN], dlt[MAXN], beg[MAXN], sdlt[MAXN],
sbeg[MAXN];
void upd(long long &x, long long y) {
if (y < x) x = y;
}
long long Ceil(long long x, long long y) { return (x + y - 1) / y; }
int main() {
scanf("%d%d%d", &n, &t, &k);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &beg[i], &dlt[i], &lim[i]);
++n;
lim[n] = 1ll * (t + 1) * k;
beg[n] = dlt[n] = k;
for (int i = 1; i <= n; i++) {
sbeg[i] = sbeg[i - 1] + beg[i];
sdlt[i] = sdlt[i - 1] + dlt[i];
}
for (int i = 0; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int x = 0; x < 2; x++)
for (int y = 0; y < 2; y++) f[i][j][x][y] = INF;
for (int i = 0; i <= n; i++) f[i][0][0][0] = f[i][0][0][1] = 0;
for (int i = 0; i <= t; i++) f[0][i][0][0] = f[0][i][0][1] = 0;
for (int i = 1; i <= n; i++)
for (int j = 1; j <= t; j++)
for (int y = 0; y < 2; y++) {
if (y * beg[i] + (j - 1) * dlt[i] <= lim[i] &&
f[i - 1][j - 1][0][y] != INF) {
long long t1 = y * beg[i] + (j - 1) * dlt[i],
t2 = y * sbeg[i - 1] + (j - 1) * sdlt[i - 1] -
f[i - 1][j - 1][0][y] * k;
long long cost = t2 / k + 1;
if (cost * k - t2 <= t1)
upd(f[i][j][1][y], f[i - 1][j - 1][0][y] + cost);
}
for (int r = 1; r < j; r++)
if (f[i][r][1][y] != INF && f[i - 1][j - r][0][0] != INF) {
long long t1 = y * sbeg[i] + (r - 1) * sdlt[i] - f[i][r][1][y] * k;
long long t2 = (j - r) * dlt[i], cost1 = 0;
if (t1 + t2 > lim[i]) {
cost1 = Ceil(t1 + t2 - lim[i], k);
if (cost1 * k > t1) continue;
t1 -= cost1 * k;
}
t1 += t2;
long long t3 = (j - r) * sdlt[i - 1] - f[i - 1][j - r][0][0] * k;
long long cost2 = t3 / k + 1;
long long now = k * cost2 - t3;
if (now <= t1)
upd(f[i][j][1][y],
f[i][r][1][y] + f[i - 1][j - r][0][0] + cost1 + cost2);
}
if (y * beg[i] + j * dlt[i] <= lim[i] && f[i - 1][j][0][y] != INF)
upd(f[i][j][0][y], f[i - 1][j][0][y]);
for (int r = y ? 1 : 2; r <= j; r++)
if (f[i][r][1][y] != INF && f[i][j - r + 1][0][0] != INF) {
long long t1 = y * sbeg[i] + (r - 1) * sdlt[i] - f[i][r][1][y] * k,
cost = 0;
long long t2 = (j - r + 1) * dlt[i];
if (t1 + t2 > lim[i]) {
long long cost2 = Ceil(t1 + t2 - lim[i], k);
if (cost2 * k > t1) continue;
t1 -= cost2 * k;
cost += cost2;
}
upd(f[i][j][0][y], f[i][r][1][y] + f[i][j - r + 1][0][0] + cost);
}
}
printf("%lld\n", f[n][t][0][1] == INF ? -1 : f[n][t][0][1]);
}
|
#include <bits/stdc++.h>
const int maxn = 210, maxt = 210;
const long long inf = 1ll << 60;
int n, t, k, a[maxn], b[maxn], c[maxn];
long long f[maxn][maxt][2], g[maxn][maxt][2];
long long min(long long a, long long b) { return a < b ? a : b; }
long long max(long long a, long long b) { return a > b ? a : b; }
int main() {
scanf("%d%d%d", &n, &t, &k);
for (int i = 1; i <= n; i++) scanf("%d%d%d", a + i, b + i, c + i);
long long sa = 0, sb = 0;
for (int i = 1; i <= n + 1; i++) {
sa += a[i];
sb += b[i];
f[i][0][0] = sb;
g[i][0][0] = b[i];
f[i][0][1] = sa;
g[i][0][1] = a[i];
for (int j = 1; j <= t; j++) {
for (int ty = 0; ty < 2; ty++) {
f[i][j][ty] = g[i][j][ty] = -inf;
long long z = ty ? a[i] + 1ll * b[i] * j : b[i] * (j + 1ll);
if (z <= c[i] && g[i - 1][j][ty] > -1) {
f[i][j][ty] = f[i - 1][j][ty] + z;
g[i][j][ty] = z;
}
for (int l = 1; l <= j; l++) {
int r = ty ? (sa + sb * (l - 1)) % k : sb * l % k;
if (i > n ||
g[i][l - 1][ty] >= r && r + b[i] * (j - l + 1ll) <= c[i]) {
long long x = min(c[i] - b[i] * (j - l + 1), g[i][l - 1][ty]) - r;
if (x < 0 && x % k != 0)
x = x / k - 1;
else
x = x / k;
x = x * k + r + b[i] * (j - l + 1);
if (g[i - 1][j - l][0] > -1) {
f[i][j][ty] = max(f[i][j][ty], x + f[i - 1][j - l][0]);
g[i][j][ty] = max(g[i][j][ty], x);
}
}
}
}
}
}
printf("%lld\n", (sa + sb * t - f[n + 1][t][1]) / k);
}
|
#include <bits/stdc++.h>
using namespace std;
const int _ = 200 + 7;
const long long inf = 1e15;
int n, T, K;
long long a[_], b[_], c[_], sa[_], sb[_], d[_][_][2], g[_][_][2];
long long Ceil(long long x, long long y) { return x % y ? x / y + 1 : x / y; }
void upd(long long &x, long long y) { x = min(x, y); }
int main() {
cin >> n >> T >> K;
for (int i = 1; i <= n; ++i) {
cin >> a[i] >> b[i] >> c[i];
sa[i] = sa[i - 1] + a[i];
sb[i] = sb[i - 1] + b[i];
}
a[++n] = inf, c[n] = inf;
sa[n] = sa[n - 1] + a[n];
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) d[p][s][z] = g[p][s][z] = inf;
for (int p = 1; p <= n; ++p)
for (int s = 0; s <= T; ++s)
for (int z = 0; z <= 1; ++z) {
if (z * a[p] + s * b[p] <= c[p] and d[p - 1][s][z] != inf) {
upd(d[p][s][z], d[p - 1][s][z]);
long long num = Ceil(z * sa[p - 1] + s * sb[p - 1], K);
if (num * K <= z * sa[p] + s * sb[p]) upd(g[p][s][z], num);
}
for (int r = 0; r < s; ++r)
if (g[p][r][z] != inf and d[p - 1][s - r][0] != inf) {
long long m = z * sa[p] + r * sb[p] - K * g[p][r][z];
long long x = Ceil(max(0ll, m + (s - r) * b[p] - c[p]), K);
if (K * x <= m) {
upd(d[p][s][z], g[p][r][z] + x + d[p - 1][s - r][0]);
long long num = Ceil((s - r) * sb[p - 1], K);
upd(g[p][s][z], g[p][r][z] + x + num);
}
}
upd(d[p][s][z], g[p][s][z]);
}
cout << d[n][T][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 310;
const long long inf = 4e18;
long long f[N][N][2], g[N][N][2], a[N], b[N], c[N], sa[N], sb[N];
int n, t, K;
long long up(long long x) {
if (x <= 0) return 0;
return (x + K - 1) / K;
}
int main() {
scanf("%d%d%d", &n, &t, &K);
for (int i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
n++;
a[n] = c[n] = inf;
for (int i = 1; i <= n; i++) sa[i] = sa[i - 1] + a[i];
for (int i = 1; i <= n; i++) sb[i] = sb[i - 1] + b[i];
for (int i = 1; i <= n; i++)
for (int j = 0; j <= t; j++)
for (int l = 0; l < 2; l++) {
f[i][j][l] = g[i][j][l] = inf;
if (c[i] >= j * b[i] + l * a[i] && f[i - 1][j][l] != inf) {
f[i][j][l] = f[i - 1][j][l];
g[i][j][l] = up(sa[i - 1] * l + sb[i - 1] * j);
if (g[i][j][l] * K > sa[i] * l + sb[i] * j) g[i][j][l] = inf;
}
for (int k = 0; k < j; k++)
if (g[i][k][l] != inf) {
long long lft = sa[i] * l + sb[i] * k - g[i][k][l] * K,
ct = up(b[i] * (j - k) - c[i] + lft);
if ((g[i][k][l] + ct) * K > sa[i] * l + sb[i] * k ||
f[i - 1][j - k][0] == inf)
continue;
f[i][j][l] = min(f[i][j][l], g[i][k][l] + ct + f[i - 1][j - k][0]);
long long d = up(sb[i - 1] * (j - k));
if ((g[i][k][l] + ct + d) * K <= sa[i] * l + sb[i] * j)
g[i][j][l] = min(g[i][j][l], g[i][k][l] + ct + d);
}
}
printf("%lld\n", f[n][t][1]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline void cm(long long &x, long long v) { x = min(x, v); }
int n, m, K;
long long f[212][212], g[212][212], f1[212][212], g1[212][212], a[212], b[212],
c[212], sa[212], sb[212];
int main() {
memset(f, 0x3f, sizeof(f));
memset(f[0], 0, sizeof(f[0]));
memset(g, 0x3f, sizeof(g));
memset(g[0], 0, sizeof(g[0]));
memset(f1, 0x3f, sizeof(f1));
memset(f1[0], 0, sizeof(f1[0]));
memset(g1, 0x3f, sizeof(g1));
memset(g1[0], 0, sizeof(g1[0]));
scanf("%d%d%d", &n, &m, &K);
int i, j, k;
long long res, v1, v2, s1, s2, l, r;
for (i = 1; i <= n; i++) scanf("%lld%lld%lld", &a[i], &b[i], &c[i]);
++n;
a[n] = 1e15;
b[n] = 0;
c[n] = a[n] + 1;
for (i = 1; i <= n; i++) sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
for (i = 1; i <= m; i++) {
g1[i][0] = g[i][0] = 0;
for (j = 1; j <= n; j++) {
if (((v1 = g1[i][j - 1]) < 0x3f3f3f3f3f3f3f3f) && (b[j] * i <= c[j])) {
g1[i][j] = v1;
l = (sb[j - 1] * i + K - 1) / K;
r = (sb[j] * i) / K;
if (l <= r) g[i][j] = l;
}
for (k = 0; k < i; k++)
if (((v1 = g[k][j]) < 0x3f3f3f3f3f3f3f3f) &&
((v2 = g1[i - k][j - 1]) < 0x3f3f3f3f3f3f3f3f)) {
s2 = sb[j] * k - v1 * K;
l = max(0ll, (s2 + b[j] * (i - k) - c[j] + K - 1) / K);
r = s2 / K;
res = v1 + v2 + l;
if (l <= r) {
cm(g1[i][j], res);
s1 = sb[j - 1] * (i - k) - v2 * K;
s2 += b[j] * (i - k) - l * K;
l = (s1 + K - 1) / K;
r = (s1 + s2) / K;
if (l <= r) cm(g[i][j], res + l);
}
}
}
}
for (i = 1; i <= n; i++) {
f[0][i] = (sa[i - 1] + K - 1) / K;
if (sa[i] - K * f[0][i] < 0) f[0][i] = 0x3f3f3f3f3f3f3f3f;
}
for (i = 1; i <= m; i++) {
f1[i][0] = f[i][0] = 0;
for (j = 1; j <= n; j++) {
if (((v1 = f1[i][j - 1]) < 0x3f3f3f3f3f3f3f3f) &&
(a[j] + b[j] * i <= c[j])) {
f1[i][j] = v1;
l = (sa[j - 1] + sb[j - 1] * i + K - 1) / K;
r = (sa[j] + sb[j] * i) / K;
if (l <= r) f[i][j] = l;
}
for (k = 0; k < i; k++)
if (((v1 = f[k][j]) < 0x3f3f3f3f3f3f3f3f) &&
((v2 = g1[i - k][j - 1]) < 0x3f3f3f3f3f3f3f3f)) {
s2 = sa[j] + sb[j] * k - v1 * K;
l = max(0ll, (s2 + b[j] * (i - k) - c[j] + K - 1) / K);
r = s2 / K;
res = v1 + v2 + l;
if (l <= r) {
cm(f1[i][j], res);
s1 = sb[j - 1] * (i - k) - v2 * K;
s2 += b[j] * (i - k) - l * K;
l = (s1 + K - 1) / K;
r = (s1 + s2) / K;
if (l <= r) cm(f[i][j], res + l);
}
}
}
}
printf("%lld", f1[m][n]);
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int maxn = 210;
int n, T, K, a[maxn];
long long b[maxn], sa[maxn], sb[maxn], c[maxn], f[maxn][maxn][2],
g[maxn][maxn][2];
void chk(long long &x, long long y) {
if (x > y) x = y;
}
int main() {
scanf("%d %d %d", &n, &T, &K), n++;
for (int i = 1; i <= n; i++) {
if (i < n)
scanf("%d %lld %lld", &a[i], &b[i], &c[i]);
else
a[i] = b[i] = INT_MAX, c[i] = 1e18;
sa[i] = sa[i - 1] + a[i], sb[i] = sb[i - 1] + b[i];
}
memset(f, 0x3f, sizeof(f)), memset(f[0], 0, sizeof(f[0]));
memset(g, 0x3f, sizeof(g)), memset(g[0], 0, sizeof(g[0]));
for (int i = 1; i <= n; i++) {
for (int j = 0; j <= T; j++)
for (int z : {0, 1}) {
if (f[i - 1][j][z] < 1e18 && z * a[i] + j * b[i] <= c[i]) {
chk(f[i][j][z], f[i - 1][j][z]);
long long num = (z * sa[i - 1] + j * sb[i - 1] + K - 1) / K;
if (num * K <= z * sa[i] + j * sb[i]) chk(g[i][j][z], num);
}
for (int r = 0; r < j; r++)
if (g[i][r][z] < 1e18) {
long long rem = z * sa[i] + r * sb[i] - K * g[i][r][z];
long long need =
(max(0LL, rem + (j - r) * b[i] - c[i]) + K - 1) / K;
if (need * K > rem || f[i - 1][j - r][0] > 1e18) continue;
chk(f[i][j][z], g[i][r][z] + need + f[i - 1][j - r][0]);
long long num = ((j - r) * sb[i - 1] + K - 1) / K;
if (num * K <= rem + (j - r) * sb[i] - need * K)
chk(g[i][j][z], g[i][r][z] + need + num);
}
}
}
printf("%lld\n", f[n][T][1]);
return 0;
}
|
#include <bits/stdc++.h>
#pragma GCC optimize("-O3")
using namespace std;
inline int read() {
int x = 0, f = 1;
char ch = getchar();
while (ch < '0' || ch > '9') {
if (ch == '-') f = -1;
ch = getchar();
}
while (ch >= '0' && ch <= '9') {
x = x * 10 + ch - '0';
ch = getchar();
}
return x * f;
}
void Out(int x) {
if (x > 9) Out(x / 10);
putchar('0' + x % 10);
}
long long gcd(long long x, long long y) {
if (!y) return x;
return gcd(y, x % y);
}
long long qpow(long long x, long long y, long long P) {
long long re = 1;
while (y) {
if (y & 1) re = re * x % P;
x = x * x % P;
y >>= 1;
}
return re;
}
const double eps = 1e-6;
const long long inf = 1e16;
const int P = 998244353;
const int N = 200 + 50;
int n, t;
long long k;
long long a[N], b[N], c[N], A[N], B[N];
long long f[N][N][2], g[N][N][2];
int main() {
scanf("%d%d%I64d", &n, &t, &k);
for (int i = 1; i <= n; ++i) {
a[i] = read();
b[i] = read();
c[i] = read();
}
++n;
a[n] = c[n] = inf;
for (int i = 1; i <= n; ++i) {
A[i] = A[i - 1] + a[i];
B[i] = B[i - 1] + b[i];
}
long long x, y, u;
for (int i = 1; i <= n; ++i) {
for (long long j = 0; j <= t; ++j) {
for (long long z = 0; z <= 1; ++z) {
f[i][j][z] = g[i][j][z] = inf;
if (j * b[i] + z * a[i] <= c[i] && f[i - 1][j][z] != inf) {
f[i][j][z] = f[i - 1][j][z];
x = (z * A[i - 1] + j * B[i - 1] + k - 1) / k;
if (x * k <= z * A[i] + j * B[i]) g[i][j][z] = x;
}
for (long long r = 0; r < j; ++r)
if (g[i][r][z] != inf) {
y = A[i] * z + B[i] * r - g[i][r][z] * k;
x = (max(0LL, (y + (j - r) * b[i] - c[i])) + k - 1) / k;
if (x * k <= y && f[i - 1][j - r][0] != inf) {
f[i][j][z] = min(f[i][j][z], g[i][r][z] + x + f[i - 1][j - r][0]);
u = (B[i - 1] * (j - r) + k - 1) / k;
if (u * k <= B[i] * (j - r) + y - x * k)
g[i][j][z] = min(g[i][j][z], g[i][r][z] + x + u);
}
}
}
}
}
cout << f[n][t][1] << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
namespace fastExpress {
template <typename T>
inline T read() {
T f = 1, x = 0;
char c = getchar();
while (!isdigit(c)) {
if (c == '-') f = -1;
c = getchar();
}
while (isdigit(c)) {
x = x * 10 + c - '0';
c = getchar();
}
return x * f;
}
template <typename T>
inline void write(T x) {
if (x < 0) {
putchar('-');
x = -x;
}
if (x > 9) write(x / 10);
putchar(x % 10 + '0');
}
template <typename T>
inline void print_char(T x, char ch) {
write(x), putchar(ch);
}
template <typename T>
inline void char_print(char ch, T x) {
putchar(ch);
write(x);
}
template <typename T>
inline void print_space(T x) {
print_char(x, ' ');
}
template <typename T>
inline void space_print(T x) {
char_print(' ', x);
}
template <typename T>
inline void println(T x) {
print_char(x, '\n');
}
template <typename T>
inline void lnprint(T x) {
char_print('\n', x);
}
template <typename T>
inline void print_array_in_range1(T* a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void print_array_in_range2(T* a, int l, int r) {
println(r - l + 1), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range3(T* a, int l, int r) {
for (int(i) = (r); (i) >= (l); --(i)) print_char(a[i], " \n"[i == l]);
}
template <typename T>
inline void print_array_in_range4(T* a, int l, int r) {
println(r - l + 1), print_array_in_range3(a, l, r);
}
template <typename T>
inline void print_array_in_range5(T* a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) println(a[i]);
}
template <typename T>
inline void print_array_in_range6(T* a, int l, int r) {
println(r - l + 1), print_array_in_range5(a, l, r);
}
template <typename T>
inline void print_array_in_range7(T* a, int l, int r) {
for (int(i) = (r); (i) >= (l); --(i)) println(a[i]);
}
template <typename T>
inline void print_array_in_range8(T* a, int l, int r) {
println(r - l + 1), print_array_in_range7(a, l, r);
}
template <typename T>
inline void print_array_in_range9(T* a, int l, int r) {
print_space(r - l + 1), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range10(T* a, int l, int r) {
print_space(r - l + 1), print_array_in_range3(a, l, r);
}
template <typename T>
inline void print_array_in_range11(T* a, int l, int r) {
print_space(r - l + 1), print_array_in_range5(a, l, r);
}
template <typename T>
inline void print_array_in_range12(T* a, int l, int r) {
print_space(r - l + 1), print_array_in_range7(a, l, r);
}
template <typename T>
inline void print_array_in_range13(T* a, int l, int r, int n) {
println(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range14(T* a, int l, int r, int n) {
println(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range15(T* a, int l, int r, int n) {
println(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range16(T* a, int l, int r, int n) {
println(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range17(T* a, int l, int r, int n) {
print_space(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range18(T* a, int l, int r, int n) {
print_space(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range19(T* a, int l, int r, int n) {
print_space(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array_in_range20(T* a, int l, int r, int n) {
print_space(n), print_array_in_range1(a, l, r);
}
template <typename T>
inline void print_array1(T* a, int n) {
print_array_in_range1(a, 1, n);
}
template <typename T>
inline void print_array2(T* a, int n) {
println(n), print_array1(a, n);
}
template <typename T>
inline void print_array3(T* a, int n) {
print_array_in_range3(a, 1, n);
}
template <typename T>
inline void print_array4(T* a, int n) {
println(n), print_array3(a, n);
}
template <typename T>
inline void print_array5(T* a, int n) {
print_array_in_range5(a, 1, n);
}
template <typename T>
inline void print_array6(T* a, int n) {
println(n), print_array5(a, n);
}
template <typename T>
inline void print_array7(T* a, int n) {
print_array_in_range7(a, 1, n);
}
template <typename T>
inline void print_array8(T* a, int n) {
println(n), print_array7(a, n);
}
template <typename T>
inline void print_array9(T* a, int n) {
print_space(n), print_array1(a, n);
}
template <typename T>
inline void print_array10(T* a, int n) {
print_space(n), print_array3(a, n);
}
template <typename T>
inline void print_array11(T* a, int n) {
print_space(n), print_array5(a, n);
}
template <typename T>
inline void print_array12(T* a, int n) {
print_space(n), print_array7(a, n);
}
template <typename T>
inline void vector_print(vector<T> a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void map_print(map<T, T> a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) print_char(a[i], " \n"[i == r]);
}
template <typename T>
inline void stack_print(stack<T> a, char ch) {
while (!a.empty()) print_char(a.top(), ch), a.pop();
}
template <typename T>
inline void queue_print(queue<T> a, char ch) {
while (!a.empty()) print_char(a.front(), ch), a.pop();
}
template <typename T>
inline void pq_print(priority_queue<T> a, char ch) {
while (!a.empty()) print_char(a.top(), ch), a.pop();
}
inline void print_string_in_range(string s, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) putchar(s[i]);
}
inline void print_chars_in_range(char* a, int l, int r) {
for (int(i) = (l); (i) <= (r); ++(i)) putchar(a[i]);
}
inline void print_allstring(string s) {
print_string_in_range(s, 0, (int)s.size() - 1);
}
inline void filein(string s) { freopen((s + ".in").c_str(), "r", stdin); }
inline void fileout(string s) { freopen((s + ".out").c_str(), "w", stdout); }
inline void file(string s) { filein(s), fileout(s); }
} // namespace fastExpress
using namespace fastExpress;
const int N = 207;
const long long inf = 0x3f3f3f3f3f3f3f3fll;
int n, t, K, a[N], d[N];
long long suma[N], sumd[N], lim[N], f[N][N][2], g[N][N][2], t1, t2, rem, vis;
int main() {
n = read<int>(), t = read<int>(), K = read<int>();
for (int(i) = (1); (i) <= (n); ++(i))
a[i] = read<int>(), d[i] = read<int>(), lim[i] = read<long long>();
n++, a[n] = d[n] = 0x3f3f3f3f, lim[n] = inf;
for (int(i) = (1); (i) <= (n); ++(i))
suma[i] = suma[i - 1] + a[i], sumd[i] = sumd[i - 1] + d[i];
memset(f, 63, sizeof(f)), memset(g, 63, sizeof(g));
memset(f, 0, sizeof *f), memset(g, 0, sizeof *g);
for (int(i) = (1); (i) <= (n); ++(i))
for (int(j) = (0); (j) <= (t); ++(j))
for (int(k) = (0); (k) <= (1); ++(k)) {
if (1ll * k * a[i] + 1ll * j * d[i] <= lim[i] && f[i - 1][j][k] < inf) {
f[i][j][k] = min(f[i][j][k], f[i - 1][j][k]),
t1 = (k * suma[i - 1] + j * sumd[i - 1] + K - 1) / K;
if (t1 * K <= k * suma[i] + j * sumd[i])
g[i][j][k] = min(g[i][j][k], t1);
}
for (int(r) = (0); (r) <= (j - 1); ++(r))
if ((t1 = g[i][r][k]) != inf) {
rem = k * suma[i] + r * sumd[i] - K * t1,
vis = (max(0ll, rem + 1ll * (j - r) * d[i] - lim[i]) + K - 1) / K;
if (vis * K <= rem && f[i - 1][j - r][0] < inf) {
f[i][j][k] = min(f[i][j][k], t1 + vis + f[i - 1][j - r][0]),
t2 = ((j - r) * sumd[i - 1] + K - 1) / K;
if (t2 * K <= (j - r) * sumd[i] + (rem - vis * K))
g[i][j][k] = min(g[i][j][k], t1 + vis + t2);
}
}
}
return write(f[n][t][1]), 0;
}
|
#include <bits/stdc++.h>
using namespace std;
struct station_t {
long long a, b, c;
};
struct solver_t {
vector<station_t> st;
int total_ns, total_nt, k;
solver_t(const vector<station_t> &_stations, int _nt, int _k)
: st(_stations), total_ns(st.size()), total_nt(_nt), k(_k) {}
struct dp1_t {
long long ntrain;
long long total_people;
};
struct dp2_t {
long long ntrain;
long long people_last;
};
vector<vector<array<dp1_t, 2>>> dp1_memo;
vector<vector<array<dp2_t, 2>>> dp2_memo;
dp1_t solve_dp1(int ns, int nt, bool use_a) {
dp1_t &res = dp1_memo[ns][nt][use_a];
if (res.ntrain != -1LL) return res;
if (ns == 0) return res = {0LL, 0LL};
station_t &last_st = st[ns - 1];
if (nt == 0) {
dp1_t sub_res = solve_dp1(ns - 1, 0, use_a);
return res = {sub_res.ntrain,
sub_res.total_people + (use_a ? last_st.a : last_st.b)};
}
res = {LLONG_MAX, -1LL};
{
long long final_value =
(use_a ? last_st.a : last_st.b) + (long long)nt * last_st.b;
if (final_value <= last_st.c) {
dp1_t sub_res = solve_dp1(ns - 1, nt, use_a);
if (sub_res.ntrain != LLONG_MAX) {
dp1_t cand = {sub_res.ntrain, sub_res.total_people + final_value};
if (cand.ntrain < res.ntrain) res = cand;
}
}
}
for (int t = 0; t < nt; ++t) {
dp2_t upper_res = solve_dp2(ns, t + 1, use_a);
if (upper_res.ntrain == LLONG_MAX) continue;
dp1_t lower_res = solve_dp1(ns - 1, nt - 1 - t, false);
if (lower_res.ntrain == LLONG_MAX) continue;
long long temp_value =
upper_res.people_last + (long long)(nt - 1 - t) * last_st.b;
long long exceeds = max(temp_value - last_st.c, 0LL);
long long extra_train = (exceeds + (k - 1)) / k;
long long max_extra_train = (upper_res.people_last - last_st.b) / k;
if (extra_train > max_extra_train) continue;
temp_value -= extra_train * k;
assert(temp_value >= last_st.b);
dp1_t cand = {upper_res.ntrain + lower_res.ntrain + extra_train,
lower_res.total_people + temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
return res;
}
dp2_t solve_dp2(int ns, int nt, bool use_a) {
assert(ns > 0 && nt > 0);
dp2_t &res = dp2_memo[ns][nt][use_a];
if (res.ntrain != -1LL) return res;
res = {LLONG_MAX, -1LL};
station_t &last_st = st[ns - 1];
{
dp1_t sub_res = solve_dp1(ns - 1, nt - 1, use_a);
if (sub_res.ntrain != LLONG_MAX) {
long long temp_value =
(use_a ? last_st.a : last_st.b) + (long long)(nt - 1) * last_st.b;
if (temp_value <= last_st.c) {
long long extra_train = (sub_res.total_people + k - 1) / k;
long long residual = extra_train * k - sub_res.total_people;
if (temp_value >= residual) {
temp_value -= residual;
long long exceeding =
max((temp_value + last_st.b) - last_st.c, 0LL);
long long extra_train_2 = (exceeding + k - 1) / k;
temp_value -= extra_train_2 * k;
if (temp_value >= 0) {
temp_value += last_st.b;
assert(temp_value <= last_st.c);
dp2_t cand = {sub_res.ntrain + extra_train + extra_train_2,
temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
}
}
}
}
for (int t = 0; t < nt - 1; ++t) {
dp2_t upper_res = solve_dp2(ns, t + 1, use_a);
if (upper_res.ntrain == LLONG_MAX) continue;
dp1_t mid_res = solve_dp1(ns - 1, nt - t - 2, false);
if (mid_res.ntrain == LLONG_MAX) continue;
assert(upper_res.people_last >= last_st.b);
long long max_extra_train_1 = (upper_res.people_last - last_st.b) / k;
long long temp_value =
upper_res.people_last + (long long)(nt - t - 2) * last_st.b;
long long exceeding_1 = max(temp_value - last_st.c, 0LL);
long long extra_train_1 = (exceeding_1 + k - 1) / k;
if (extra_train_1 > max_extra_train_1) continue;
temp_value -= extra_train_1 * k;
long long extra_train_2 = (mid_res.total_people + k - 1) / k;
long long residual = extra_train_2 * k - mid_res.total_people;
if (temp_value < residual) continue;
temp_value -= residual;
long long exceeding_3 = max((temp_value + last_st.b) - last_st.c, 0LL);
long long extra_train_3 = (exceeding_3 + k - 1) / k;
temp_value -= extra_train_3 * k;
if (temp_value < 0) continue;
temp_value += last_st.b;
assert(temp_value <= last_st.c);
dp2_t cand = {upper_res.ntrain + mid_res.ntrain + extra_train_1 +
extra_train_2 + extra_train_3,
temp_value};
if (cand.ntrain < res.ntrain) res = cand;
}
return res;
}
long long solve() {
dp1_memo.assign(
total_ns + 1,
vector<array<dp1_t, 2>>(total_nt + 1,
array<dp1_t, 2>{{{-1LL, -1LL}, {-1LL, -1LL}}}));
dp2_memo.assign(
total_ns + 1,
vector<array<dp2_t, 2>>(total_nt + 1,
array<dp2_t, 2>{{{-1LL, -1LL}, {-1LL, -1LL}}}));
return solve_dp1(total_ns, total_nt, true).ntrain;
}
};
int main() {
int ns, nt, k;
scanf("%d %d %d", &ns, &nt, &k);
vector<station_t> stations(ns);
for (int i = 0; i < ns; ++i)
scanf("%lld %lld %lld", &stations[i].a, &stations[i].b, &stations[i].c);
stations.push_back({(long long)(k - 1) * nt, 0LL, (long long)(k - 1) * nt});
ns = stations.size();
solver_t solver(stations, nt, k);
printf("%lld\n", solver.solve());
return 0;
}
|
#include <bits/stdc++.h>
const double eps = (1e-9);
using namespace std;
int dcmp(long double a, long double b) {
return fabsl(a - b) <= eps ? 0 : (a > b) ? 1 : -1;
}
int getBit(int num, int idx) { return ((num >> idx) & 1) == 1; }
int setBit1(int num, int idx) { return num | (1 << idx); }
long long setBit0(long long num, int idx) { return num & ~(1ll << idx); }
long long flipBit(long long num, int idx) { return num ^ (1ll << idx); }
void M() {
ios_base::sync_with_stdio(0);
cin.tie(0);
cout.tie(0);
}
int countNumBit1(int mask) {
int ret = 0;
while (mask) {
mask &= (mask - 1);
++ret;
}
return ret;
}
long long arr[300009], even[300009], odd[300009];
vector<int> v, sum;
int fun(long long no) {
int cnt = 0;
while (no) {
cnt += (no % 2);
no /= 2;
}
return cnt;
}
int main() {
int n;
cin >> n;
for (int i = 0; i < n; i++) {
cin >> arr[i];
int cnt = fun(arr[i]);
v.push_back(cnt);
}
sum.resize(n);
sum[0] = v[0];
for (int i = 1; i < ((int)(v).size()); i++) sum[i] = sum[i - 1] + v[i];
even[0] = (sum[0] % 2 == 0);
odd[0] = (sum[0] % 2 != 0);
for (int i = 1; i < n; i++) {
even[i] = even[i - 1] + (sum[i] % 2 == 0);
odd[i] = odd[i - 1] + (sum[i] % 2 != 0);
}
long long add = 1;
long long rem = 0, ans = 0, res = 0;
for (int i = 0; i < n; i++) {
if (rem % 2 == 0) {
res += even[n - 1] - even[i + 1 - 1];
} else {
res += odd[n - 1] - odd[i + 1 - 1];
}
rem += v[i];
int mx = v[i], s = v[i];
for (int j = i + 1, k = 0; j < n && k < 65; j++, k++) {
mx = max(mx, v[j]);
s += v[j];
if (s - mx < mx && s % 2 == 0) res--;
}
}
cout << res << endl;
}
|
#include <bits/stdc++.h>
using namespace std;
int a[300500];
int s[300500];
long long o[2];
long long ans;
int n;
int main() {
scanf("%i", &n);
for (int i = 1; i <= n; ++i) {
long long x;
scanf("%lld", &x);
while (x) {
a[i] += x & 1;
x = x >> 1;
}
s[i] = s[i - 1] + a[i];
}
for (int i = 1; i <= n; ++i) o[s[i] % 2]++;
ans = o[0] * (o[0] - 1) / 2 + o[1] * (o[1] - 1) / 2 + o[0];
for (int l, r, i = 1; i <= n; ++i) {
int q, t;
q = a[i];
t = 0;
for (l = 1; i - l >= 1; l++) {
if (q - t - a[i - l] <= 0) break;
t += a[i - l];
}
l--;
t = 0;
for (r = 1; i + r <= n; r++) {
if (q - t - a[i + r] <= 0) break;
t += a[i + r];
}
r--;
for (int l1 = 0; l1 <= l; ++l1)
for (int r1 = 0; r1 <= r; ++r1) {
int v = s[i + r1] - s[i - l1 - 1];
if (v % 2 == 0 && a[i] > v - a[i]) ans--;
}
}
printf("%lld\n", ans);
}
|
#include <bits/stdc++.h>
using namespace std;
const int N = 32;
int main() {
int n;
cin >> n;
vector<int> b(n, 0);
for (int i = 0; i < n; i++) {
long long a;
cin >> a;
b[i] = __builtin_popcountll(a);
}
long long res = 0;
int sufsum = 0;
vector<vector<int>> cnt(2, vector<int>(n + 1, 0));
cnt[0][n] = 1;
for (int i = n - 1; i >= 0; i--) {
int sum = 0, mx = 0;
int add = 0;
for (int j = i; j < n && j - i < 65; ++j) {
sum += b[j];
mx = max(mx, b[j]);
if (sum % 2 == 0 && mx > sum - mx) add--;
}
sufsum += b[i];
add += cnt[sufsum & 1][i + 1];
res += add;
cnt[0][i] = cnt[0][i + 1];
cnt[1][i] = cnt[1][i + 1];
cnt[sufsum & 1][i]++;
}
cout << res << endl;
return 0;
}
|
#include <bits/stdc++.h>
const double PI = 3.1415926;
const int KL = 1e6;
using namespace std;
long long q, x, y, z, n, m, a[KL], mn = 1e9, mx = -1e9, ans;
string t;
vector<long long> vec[2];
set<int> s;
map<int, int> M;
int main() {
scanf("%lld", &n);
for (int i = 0; i < n; i++) {
scanf("%lld", &x);
while (x != 0) {
if (x % 2 == 1) a[i + 1]++;
x /= 2;
}
a[i + 1] += a[i];
}
vec[0].push_back(0);
for (int i = 1; i <= n; i++) {
mx = a[i] - a[i - 1];
for (int j = i - 1; j >= max(0, i - 118); j--) {
if ((a[i] - a[j]) % 2 == 0 && mx <= (a[i] - a[j]) / 2) ans++;
mx = max(mx, a[j] - a[j - 1]);
}
int pos;
if (a[i] % 2 == 0)
pos = 0;
else
pos = 1;
if (vec[pos].size() > 0) {
if (vec[pos][0] < max(0, i - 118)) {
long long lo = 0, hi = vec[pos].size() - 1;
while (lo < hi) {
long long mid = (lo + hi + 1) / 2;
if (vec[pos][mid] < max(0, i - 118))
lo = mid;
else
hi = mid - 1;
}
ans += (long long)(lo + 1);
}
}
if (a[i] % 2 == 0)
vec[0].push_back(i);
else
vec[1].push_back(i);
}
cout << ans << endl;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
inline long long read() {
long long x = 0, w = 0;
char ch = getchar();
while (!isdigit(ch)) w |= ch == '-', ch = getchar();
while (isdigit(ch)) x = (x << 1) + (x << 3) + ch - '0', ch = getchar();
return w ? -x : x;
}
long long a[500000], sum[500000], b[500000], ans;
inline long long calc(long long k) {
long long res = 0;
for (; k; k &= k - 1) ++res;
return res;
}
signed main() {
long long n = read();
for (long long i = 1; i <= n; ++i)
a[i] = calc(read()), sum[i] = sum[i - 1] + a[i];
b[0] = 1;
for (long long i = 1; i <= n; ++i) {
ans += b[sum[i] & 1]++;
ans -= ((sum[i] & 1) == (sum[i - 1] & 1));
}
for (long long i = 1; i <= n; ++i) {
long long mx = a[i];
for (long long j = i - 1; j >= max(1ll, i - 64); --j) {
mx = max(mx, a[j]);
long long t = sum[i] - sum[j - 1];
if (!(t & 1) && mx > t - mx) --ans;
}
}
cout << ans;
return 0;
}
|
#include <bits/stdc++.h>
using namespace std;
const int max_n = 300005;
int b[max_n];
long long x;
int sum[max_n];
int odd[max_n];
int even[max_n];
int n;
int work(long long x) {
int res = 0;
while (x) {
x -= x & -x;
res++;
}
return res;
}
int main() {
scanf("%d", &n);
for (int i = 1; i <= n; i++) {
scanf("%lld", &x);
b[i] = work(x);
}
for (int i = 1; i <= n; i++) sum[i] = sum[i - 1] + b[i];
for (int i = 1; i <= n; i++) {
odd[i] = odd[i - 1];
if (sum[i] % 2) odd[i]++;
even[i] = i - odd[i];
}
long long ans = 0;
for (int i = 1; i <= n; i++) {
if (sum[i - 1] % 2)
ans += odd[n] - odd[i - 1];
else
ans += even[n] - even[i - 1];
}
int maxv;
for (int i = 1; i <= n; i++) {
maxv = -1;
for (int j = 0; j <= 60; j++) {
if (j + i > n) break;
maxv = max(maxv, b[i + j]);
if ((sum[j + i] - sum[i - 1]) % 2 == 0 &&
maxv > sum[j + i] - sum[i - 1] - maxv)
ans--;
}
}
printf("%lld\n", ans);
return 0;
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.