Форум Всеукраїнської інтернет-олімпіади NetOI

const con=200;
type t=word;
var a:array[1..con] of T;
    stek:array[1..con] of T;
    max,c,n,m,i,j,size:T;
    q1,q2:array[1..con] of T;

 procedure read_data;
  begin
    read(n,m);
    for i:=1 to n do
    begin
     for j:=1 to m do begin read(c); a[j]:=(a[j]+1)*c; end;
     {lower bound}
     size:=0;
     for j:=m downto 1 do
      begin
        while (size<>0) and (a[j]<a[stek[size]]) do begin q1[stek[size]]:=j+1; dec(size); end;
        inc(size);stek[size]:=j;
      end;
     for j:=1 to size do q1[stek[j]]:=1;
     {upper bound}
     size:=0;
     for j:=1 to m do
      begin
        while (size<>0) and (a[j]<a[stek[size]]) do begin q2[stek[size]]:=j-1; dec(size); end;
        inc(size);stek[size]:=j;
      end;
     for j:=1 to size do q2[stek[j]]:=m;
     {compute answer}
     for j:=1 to m do if max<(q2[j]-q1[j]+1)*a[j] then max:=(q2[j]-q1[j]+1)*a[j];
    end;
  end;

 procedure write_data;
  begin
    writeln(max);
  end;

begin
{  assign(input,'building.in'); reset(input);
  assign(output,'building.out'); rewrite(output);}
  read_data;
  write_data;
{  close(input);close(output);}
end.

var a:array[1..50000] of byte;
    b,c:array[1..3] of word;
    i,n,ans:word;

 procedure read_data;
  begin
    read(n);
    for i:=1 to n do begin read(a[i]); inc(b[a[i]]); end;
  end;

 procedure algor;
 function max(q,w:word):word; begin if q>w then max:=q else max:=w; end;
  begin
    for i:=1 to n do
     case a[i] of
      1:if i>b[1] then inc(c[a[i]]);
      3:if (i<=b[1]) or (i>b[1]+b[3]) then inc(c[a[i]]);
      2:if i<=b[1]+b[3] then inc(c[a[i]]);
     end;
    ans:=max(max(c[1],c[2]),c[3]);
  end;

 procedure write_data;
  begin
    writeln(ans);
  end;

begin
{  assign(input,'country.in'); reset(input);
  assign(output,'country.out'); rewrite(output);}
  read_data;
  algor;
  write_data;
 { close(input);close(output);}
end.

const con=200;
var a:array[1..con,1..con] of longint;
    tem,k,n,m,q,w,i,j:longint;

 procedure read_data;
  begin
    read(n,m,q,w);
  end;

 procedure algor;
 function min(q,w:longint):longint; begin if q<w then min:=q else min:=w; end;
  begin
    {suppose that first side >= then second}
    if n<m then begin tem:=n;n:=m;m:=tem; end;
    if q<w then begin tem:=q;q:=w;w:=tem; end;
    a[q][w]:=1;a[w][q]:=1;
    for i:=q to n do
     for j:=1 to min(i,m) do
      begin
        for k:=1 to i div 2 do
         if (a[i][j]<a[k][j]+a[i-k][j]) then a[i][j]:=a[k][j]+a[i-k][j];
        for k:=1 to j div 2 do
         if (a[i][j]<a[i][k]+a[i][j-k]) then a[i][j]:=a[i][k]+a[i][j-k];
       a[j][i]:=a[i][j];
      end;
  end;

 procedure write_data;
  begin
    writeln(a[n][m]);
  end;

begin
{  assign(input,'dsp.in'); reset(input);
  assign(output,'dsp.out'); rewrite(output);}
  read_data;
  algor;
  write_data;
  {close(input);close(output);}
end.

var now,kil,g,x,y,z,q,w,e,a,b,c,n:longint;
    d:array[1..10000] of longint;
    res:extended;

 procedure read_data;
  begin
    read(a,b,c,n);
  end;

 procedure algor;

procedure sort(l,r: longint);
var i,j: longint;
begin
  i:=l;
  j:=r;
  x:=d[(l+r) div 2];
  repeat
    while d[i]<x do inc(i);
    while x<d[j] do dec(j);
    if not(i>j) then begin y:=d[i]; d[i]:=d[j]; d[j]:=y; inc(i); j:=j-1; end;
  until i>j;
  if l<j then sort(l,j);
  if i<r then sort(i,r);
end;

  function pow(l:extended;r:longint):extended;
   begin
     res:=1;
     for g:=1 to r do
      res:=res*l;
     pow:=res;
   end;

  begin
    now:=1; for q:=0 to 40 do begin if now*(a+0.0)>maxlongint then break; now:=now*a; end;
    now:=1; for w:=0 to 40 do begin if now*(b+0.0)>maxlongint then break; now:=now*b; end;
    now:=1; for e:=0 to 40 do begin if now*(c+0.0)>maxlongint then break; now:=now*c; end;
    for x:=0 to q do
     for y:=0 to w do
     if pow(a,x)*pow(b,y)<maxlongint+1.0 then
      for z:=0 to e do
       if pow(a,x)*pow(b,y)*pow(c,z)<maxlongint+1.0 then
       begin
         inc(kil);
         d[kil]:=trunc(pow(a,x)*pow(b,y)*pow(c,z));
       end;
    sort(1,kil);
  end;

 procedure write_data;
  begin
    writeln(d[n]);
  end;

begin
{  assign(input,'primenum.in'); reset(input);
  assign(output,'primenum.out'); rewrite(output);}
  read_data;
  algor;
  write_data;
 { close(input);close(output);}
end.

#include <set>
#include <iostream>
using namespace std;
const long MAX=(1<<30)+((1<<30)-1);
set<long> mas;
int main() {
    mas.insert(1);
    long a,b,c,n;
    cin>>a>>b>>c>>n;    
    for(int i=1;i<n;i++) {
        long num=*mas.begin();
        mas.erase(mas.begin());
        if (num*(a+.0)<=MAX) mas.insert((long) (num*a));
        if (num*(b+.0)<=MAX) mas.insert((long) (num*b));
        if (num*(c+.0)<=MAX) mas.insert((long) (num*c));
    }
    cout<<*mas.begin();
    return 0;
}

const con=500;
      _eps=1e-8;
type typ=extended; rec=record x,y:typ; end;
var a:array[0..con-1] of rec;
    count,n,i,j:longint;
    maxh,b1,b2,mid,S,x,r:typ;

 procedure read_data;
  begin
    read(n);
    for i:=0 to n-1 do
    begin
     read(a[i].x,a[i].y);
     if a[i].y>maxh then maxh:=a[i].y;
    end;
    read(r);
  end;

 procedure algor;
 function eq(q,w:typ):boolean; begin eq:=abs(q-w)<_eps; end;
 function more(q,w:typ):boolean; begin more:=q-w>_eps; end;
 function lesseq(q,w:typ):boolean; begin lesseq:=q-w<_eps; end;
 function min(q,w:typ):typ; begin if q<w then min:=q else min:=w; end;
 function max(q,w:typ):typ; begin if q>w then max:=q else max:=w; end;
 function dist(x1,y1,x2,y2:typ):typ;
  begin dist:=sqrt(sqr(x1-x2)+sqr(y1-y2)); end;
 function calc(y:typ):typ;
 var res:typ;
  begin
    res:=0;count:=0;
    for i:=0 to n-1 do
     begin
       j:=(i+1) mod n;
       if more(y,min(a[i].y,a[j].y)) and lesseq(y,max(a[i].y,a[j].y)) then
        begin
          x:=(y-a[i].y)*(a[j].x-a[i].x)/(a[j].y-a[i].y)+a[i].x;
          if count=0 then res:=res+dist(a[i].x,a[i].y,x,y) else
                          res:=res+dist(x,y,a[j].x,a[j].y);
          inc(count);
        end else
       if count<>1 then res:=res+dist(a[i].x,a[i].y,a[j].x,a[j].y);
     end;
     calc:=res;
  end;
  begin
    for i:=0 to n-1 do
     S:=S+dist(a[i].x,a[i].y,a[(i+1) mod n].x,a[(i+1) mod n].y);
     b1:=0;
     b2:=maxh;
    while (b2-b1>1e-6) do
     begin
       mid:=(b1+b2)/2;
       if calc(mid)>S*r then b2:=mid else b1:=mid;
     end;
  end;

 procedure write_data;
  begin
    writeln(mid:0:2);
  end;

begin
{  assign(input,'wood.in'); reset(input);
  assign(output,'wood.out'); rewrite(output);}
  read_data;
  algor;
  write_data;
 { close(input);close(output);}
end.