Lưu ý: Các code mẫu dưới đây chỉ mang tính tham khảo và có thể không AC được bài tập này

Code mẫu của flashmt

uses math;
const fi='';
      oo=100000000;
var n,m,l,r,mid,re,i:longint;
    a,b,x,y,u,v:array[1..100] of longint;

function check(val:longint):boolean;
var i,j,s,need,t,r:longint;
begin
     s:=0;  check:=false;
     for i:=1 to n do
     begin
          need:=a[i]*val-b[i];
          if need>0 then
          begin
               t:=0; r:=oo;
               while (t-1)*x[i]<=need do
               begin
                    r:=min(r,t*y[i]+((need-t*x[i]+u[i]-1) div u[i])*v[i]);
                    t:=t+1;
               end;
               s:=s+r;
               if s>m then exit;
          end;
     end;
     check:=s<=m;
end;

begin
     assign(input,fi); reset(input);
     read(n,m);
     for i:=1 to n do read(a[i],b[i],x[i],y[i],u[i],v[i]);
     l:=0; r:=m+100;
     while l<=r do
     begin
          mid:=(l+r) shr 1;
          if check(mid) then
          begin
               re:=mid; l:=mid+1;
          end
          else r:=mid-1;
     end;
     writeln(re);
     close(input);
end.

Code mẫu của RR

//Written by Nguyen Thanh Trung
{$R+,Q+}
{$Mode objFPC}
uses math;
const
  FINP='';
  FOUT='';
  MAXN=111;
var
  f1,f2:text;
  n,m:longint;
  need,have:array[1..MAXN] of longint;
  small,large:array[1..MAXN] of record size,price:longint; end;
procedure openF;
begin
  assign(f1,FINP); reset(f1);
  assign(f2,FOUT); rewrite(f2);
end;
procedure closeF;
begin
  close(f1);
  close(f2);
end;
procedure inp;
begin
  read(f1,n,m);
  for n:=1 to n do
    begin
      read(f1,need[n],have[n]);
      with small[n] do read(f1,size,price);
      with large[n] do read(f1,size,price);
    end;
end;
function check(u:longint):boolean;
var
  sum,i,nn,k,more,left:longint;
begin
  if u=22 then
    write('');
  sum:=0;
  for i:=1 to n do
    begin
      nn:=maxlongint;
      for k:=need[i]*u div large[i].size+5 downto 0 do
        begin
          left:=need[i]*u-have[i]-large[i].size*k;
          if left<0 then more:=0
          else
            begin
              more:=left div small[i].size;
              if left mod small[i].size<>0 then more+=1;
            end;
          if more<0 then more:=0;
          nn:=min(nn,k*large[i].price+more*small[i].price);
        end;
      sum+=nn;
    end;
  check:=sum<=m;
end;
procedure solve;
var
  l,r,mid,kq:longint;
begin
  l:=0; r:=100001 div n;
  repeat
    mid:=(l+r)>>1;
    if check(mid) then
      begin
        kq:=mid;
        l:=mid+1;
      end
    else r:=mid-1;
  until l>r;
  writeln(f2,kq);
end;
begin
  openF;
  inp;
  solve;
  closeF;
end.

Code mẫu của hieult

#include <stdio.h>
//#include <conio.h>
#define maxm 100001
int n,m,x[101],y[101],sm[101],pm[101],sv[101],pv[101],f[101][maxm];
int max(int a,int b)
{
    if(a>b) return a;
    else return b;
}

int main()
{
    //freopen("MKUHAR.in","r",stdin);
    scanf("%d %d",&n,&m);
    for(int i = 1;i<=n;i++)
    {
        scanf("%d %d %d %d %d %d",&x[i],&y[i],&sm[i],&pm[i],&sv[i],&pv[i]);

        for(int j = 0;j<=maxm-1;j++)
        {
            if(j<pm[i])
                f[i][j]=0;
            else if(j<pv[i])
                f[i][j] = sm[i]+f[i][j-pm[i]];
            else
                f[i][j] = max(sm[i]+f[i][j-pm[i]],sv[i]+f[i][j-pv[i]]);
        }

    }
    int U = 0,V=maxm;
    while(V-U>1)
    {
         int R = (U+V)/2;
         int T = 0;
         for(int i = 1;i<=n;i++)
         {
              int K = R*x[i]-y[i];
             // printf("%d\n",K);
              if(K<=0)
                  continue;
              else
              {
                   int u = 0,v=maxm;
                   while(v-u>1)
                   {
                        int r = (u+v)/2;
                        if(f[i][r]>=K)
                            v = r;
                        else u = r;
                   }
                   T = T+v;
              }

         }
         if(T>m)
              V = R;
         else U = R;
    }
    printf("%d",U);
   // getch();
}

Code mẫu của ll931110

program MKUHAR;
const
  input  = '';
  output = '';
  maxn = 100;
  maxv = 1000000000;
  maxt = 100000;
var
  re,st: array[1..maxn] of longint;
  sm,pm: array[1..maxn] of longint;
  sv,pv: array[1..maxn] of longint;
  n,m: longint;

procedure init;
var
  f: text;
  i: longint;
begin
  assign(f, input);
    reset(f);

  readln(f, n, m);
  for i := 1 to n do
    readln(f, re[i], st[i], sm[i], pm[i], sv[i], pv[i]);

  close(f);
end;

function price(k,qu: longint): longint;
var
  i,ft,fs,fk: longint;
  tt: longint;
  r1,r2: longint;
begin
  tt := maxv;

  fk := qu div sv[k];
  if qu mod sv[k] <> 0 then inc(fk);

  for i := 0 to fk do
    begin
      fs := qu - i * sv[k];

      ft := fs div sm[k];
      if (fs mod sm[k] <> 0) and (fs > 0) then inc(ft);
      if ft < 0 then ft := 0;

      if tt > ft * pm[k] + i * pv[k] then
        begin
          r1 := ft;
          r2 := i;
          tt := ft * pm[k] + i * pv[k];
        end;
    end;

  price := tt;
end;

function ok(x: longint): boolean;
var
  i: longint;
  tmp: longint;
  ques: longint;
begin
  tmp := m;
  for i := 1 to n do
    begin
      if tmp < 0 then exit(false);
      if re[i] * x > st[i] then
        begin
          ques := re[i] * x - st[i];
          tmp := tmp - price(i,ques);
{          writeln('left: ', tmp);
          writeln;}
        end;
    end;

  ok := tmp >= 0;
end;

procedure solve;
var
  inf,sup,med,res: longint;
  f: text;
begin
  res := 0;
  inf := 0;
  sup := maxt;

  repeat
    med := (inf + sup) div 2;
    if ok(med) then
      begin
        res := med;
        inf := med + 1;
      end
    else sup := med - 1;
  until inf > sup;

  assign(f, output);
    rewrite(f);
    writeln(f, res);
  close(f);
end;

begin
  init;
  solve;
end.

Code mẫu của khuc_tuan

//{$A8,B-,C+,D+,E-,F-,G+,H+,I+,J-,K-,L+,M-,N+,O+,P+,Q+,R+,S+,T-,U-,V+,W-,X+,Y+,Z1}
// {$APPTYPE CONSOLE}
 {$mode delphi}

uses
    Math;

var
    sum, m, k, need, newneed, mi, le, ri, i, best, cost, n : integer;
    x, y, sm, pm, sv, pv : array[1..100] of integer;

begin
    read(n, m);
    for i:=1 to n do read(x[i], y[i], sm[i], pm[i], sv[i], pv[i]);
    le := 0;
    ri := 100000 + 100;
    while le < ri do
    begin
        mi := (le+ri) div 2 + 1;
        sum := 0;
        for i:=1 to n do
        begin
            need := x[i] * mi - y[i];
            if need > 0 then
            begin
                best := pm[i] * (need div sm[i]);
                if need mod sm[i]<>0 then best := best + pm[i];
                for k:=0 to 1000000 do
                begin
                    if (k-1) * sm[i] >= need then break;
                    if k * pm[i] >= m then break;
                    newneed := need - k * sm[i];
                    if newneed > 0 then
                    begin
                        cost := pv[i] * (newneed div sv[i]);
                        if newneed mod sv[i]<>0 then cost := cost + pv[i];
                        cost := cost + k * pm[i];
                        best := min(best, cost); 
                    end
                    else best := min(best, k * pm[i]);
                end;
                sum := sum + best;
            end;
        end;
        if sum <= m then le := mi
        else ri := mi - 1;
    end;
    writeln(le);
end.