BI 1: HAOI 4000

M gi bi: HAOI4000

Sau gn 4000 ln t chc HAOI, Ban t chc HAOI 4000 ang xem xt mt phng n t chc mi, theo
phn thng cha chc trao cho nhng th sinh c im cao nht. Thay vo , mt th sinh nu nhn
c phn thng th phn thng phi c gi tr bng im s ca th sinh ny bt k s im l thp
hay cao (d nhin phi ln hn 0).
Yu cu: Bn hy gip Ban t chc HAOI 4000 tm ra mt phng n trao gii sao cho c nhiu th sinh
c nhn phn thng nht.
D liu: Trong file vn bn HAOI4000.INP gm
Dng th nht ghi s N l s th sinh v K l s tin ca Ban t chc.
Dng tip theo ghi N s t nhin theo th t l im s ca cc th sinh c nh m s t 1 n N.
Kt qu: Xut ra file vn bn HAOI4000.OUT gm
Dng u ghi mt s l s th sinh nhiu nht c th c nhn thng.
Dng tip theo ghi danh sch m s ca cc th sinh c nhn thng.
V d:
HAOI4000.INP
4 10
8 9 1 2

HAOI4000.OUT
2
1 3

Gii hn:
N 30 000

K 2 109
im ca cc th sinh khng qu 2 109
Thi gian: 1 giy
B nh: 1M
Dy s trung bnh

Tun ny, Bigbay c mt bi ton rt ngn:

Cho mt dy s di N, tm dy con di nht c gi tr trung bnh ln hn gi tr
ave cho trc.
Input: Aveseq.In

Dng u ghi s nguyn dng N, v s nguyn ave.

N dng sau, mi dng ghi mt s nguyn ai (|ai| <= 10000).

Ouput: Aveseq.Out

Dng u ghi lmax (l di nht tm c).

Dng hai ghi hai s Be, En (l v tr bt u v kt thc ca dy con bn

chn).

Gii hn:
-

D liu lun c kt qu.

Nu dng Turbo th N <= 15000, cn FreePascall th N <= 100000.

Time limit : 1s.

Aveseq.In
73

Aveseq.Out
5

26

2
3
5
3
2
1
Const
Fin = 'aveseq.inp';
Fout= 'aveseq.out';
MaxN= 15000 ;
Type
Arr1 = Array[0..MaxN] Of Longint ;
Arr2 = Array[0..MaxN] Of Integer ;
Var
Fi, Fo : Text ;
lmax, st, en, N, ave : Longint ;
A : Arr1 ;
IMin : ^Arr2 ;
Procedure Main( Var IMin : Arr2 );
Procedure Nhap;
Var
i,x : Longint ;
Begin
Assign( Fi, Fin);
Reset( Fi);
Readln( Fi, N,ave);
For i:=1 to N do
Begin
Read( Fi, x);
A[i] := A[i-1] + x - ave ;
End;
Close( Fi);
End;
Procedure Init_Imin;
Var
i : Integer ;
Begin
Fillchar( Imin, Sizeof(Imin), 0);
Imin[0] := 0;
For i:=1 to N do
If A[Imin[i-1]]<A[i] then Imin[i] := Imin[i-1]
Else Imin[i] := i ;

End;
Procedure Process;
Var
i,j,jj : Integer ;
Begin
jj := N ;
For i:=N-1 downto 0 do
If IMin[i]=i then
Begin
For j:=jj downto i+1 do
If A[j]>=A[i] then
Begin
If lmax<j-i then
Begin
lmax := j-i;
st := i+1;
en := j ;
End;
Break;
End;
jj := j ;
End;
End;
Procedure Xuly;
Begin
Init_Imin ;
Process ;
End;
Procedure Ghi;
Begin
Assign( Fo, Fout);
Rewrite( Fo);
Writeln( Fo, lmax);
Writeln( Fo, st, ' ', en);
Close( Fo);
End;
Begin
Nhap;
Xuly;
Ghi;
End;
Begin
New(Imin);
Main(Imin^);
End.
Ma gi bai: DNT
bi:
Cho mt dy s a1.. aN. Mt nghch th l mt cp s u, v sao cho u < v v au > av. Nhim v ca bn l m
s nghch th.
Input: DNT.INP

Dng u ghi s nguyn dng N.

N dng sau mi dng ghi mt s ai ( 1 i N ).

Output:

DNT.OUT

Ghi trn mt dng s M duy nht l s nghch th.

Gii hn:

1 N 60000

1 ai 60000

Thi gian: 0.5s/test

B nh: 1MB

V d:
DNT.INP
3
3
1
2

DNT.OUT
2

Program : Day nghich the (Trom IOICamp - DNT)

Date
: 9-4-2007
Langues : Dev C++
*************************************************************************/
#include <fstream.h>
#define tfi "DNT.INP"
#define tfo "DNT.OUT"
ifstream inp;
ofstream out;
const long MAXN=60002;
long n, aTree[3*MAXN], pos[MAXN];
int InitTree(long d, long k, long l)
{
if (k==l)
{
pos[k]=d;
return 0;
}
long m=(k+l)/2;
InitTree(2*d,k,m);
InitTree(2*d+1,m+1,l);
return 0;
}
int Modify(long i)
{
long k=pos[i];
aTree[k]+=1;
while (k/2>=1)
{
long l=k/2;
aTree[l]=aTree[2*l]+aTree[2*l+1];
k=l;
}
return 0;
}
long Sum(long i, long j, long k, long l, long d)
{
if (i>j) return 0;
if ((i==k) && (j==l)) return aTree[d];
long m=(k+l)/2;
if (i>m) return Sum(i,j,m+1,l,2*d+1);
if (j<=m) return Sum(i,j,k,m,2*d);
return Sum(i,m,k,m,2*d)+Sum(m+1,j,m+1,l,2*d+1);
}
int main()

{
inp.open(tfi);
out.open(tfo);
inp >> n;
InitTree(1,1,MAXN);
long s=0;
for (long i=1; i<=n; i++)
{
long u;
inp >> u;
Modify(u);
s+=Sum(u+1,MAXN,1,MAXN,1);
}
out << s << '\n';
inp.close();
out.close();
return 0;
}
Vng trn ch ci
C N ch ci xp thnh mt vng trn. Bt u t mt v tr no ngi ta lp
mt dy k t gm N k t lin tip trn vng trn, nh vy c tt c N dy k t. Hy
xp cc dy k t ny theo th t t in.
V d ta c vng trn k t HAPPYNEWYEAR khi cc dy k t tm c l:
HAPPYNEWYEAR bt u t k t s 1
APPYNEWYEARH bt u t k t s 2
PPYNEWYEARHA bt u t k t s 3
PYNEWYEARHAP bt u t k t s 4
YNEWYEARHAPP bt u t k t s 5
NEWYEARHAPPY bt u t k t s 6
EWYEARHAPPYN bt u t k t s 7
WYEARHAPPYNE bt u t k t s 8
YEARHAPPYNEW bt u t k t s 9
EARHAPPYNEWY bt u t k t s 10
ARHAPPYNEWYE bt u t k t s 11
RHAPPYNEWYEA bt u t k t s 12

Sau ky sp xp li ta c

APPYNEWYEARH
ARHAPPYNEWYE
EARHAPPYNEWY
EWYEARHAPPYN
HAPPYNEWYEAR
HAPPYNEWYEAR
NEWYEARHAPPY
PPYNEWYEARHA
PYNEWYEARHAP
RHAPPYNEWYEA
WYEARHAPPYNE
YEARHAPPYNEW
YNEWYEARHAPP
D liu: Vo t file vn bn CirChar.INP:
Dng u tin ghi N l s k t trn vng trn k t (N1000)
Dng th hai, bt u t u dng ghi N k t trn vng trn k t
Kt qu: Ghi ra file vn bn CirChar.OUT gm N dng, dng th i ghi dy k t ng
th i trong s N dy k t c sp xp.
{$R-}
const
tfi='CIRCHAR.INP';
tfo='CIRCHAR.OUT';
maxN=2005;
var
fi, fo: text;
N: integer;
S: array[1..maxN] of char;
x: array[1..maxN] of integer;

procedure Docdl;
var i: integer;
begin
assign(fi,tfi); reset(fi);
readln(fi,N);
for i:=1 to N do read(fi,s[i]);
close(fi);
for i:=N+1 to 2*N do S[i]:=S[i-N];
end;

function NhoHon(u,v: integer): boolean;

var i: integer;
begin
NhoHon:=false;
i:=0;
while (i<N) and (s[u+i]=s[v+i]) do inc(i);
if i=N then exit;
if s[u+i]>s[v+i] then exit;
NhoHon:=true;
end;

procedure Sort(k,l: integer);

var r, i, j, Tg: integer;
begin
r:=x[(k+l) div 2];
i:=k;
j:=l;

repeat
while NhoHon(x[i],r) do inc(i);
while NhoHon(r,x[j]) do dec(j);
if i<=j then
begin
Tg:=x[i];
x[i]:=x[j];
x[j]:=Tg;
inc(i);
dec(j);
end;
until i>j;
if k<j then Sort(k,j);
if i<l then Sort(i,l);
end;

procedure SapXep;
var i: integer;
begin
for i:=1 to N do x[i]:=i;
Sort(1,N);
end;

procedure Inkq;
var i,j,u: integer;
begin
assign(fo,tfo); rewrite(fo);
for i:=1 to N do

begin
u:=x[i];
for j:=0 to N-1 do write(fo,s[u+j]);
writeln(fo);
end;
close(fo);
end;

BEGIN
Docdl;
Sapxep;
Inkq;
END.
IMAGE.INP
Mt s t chc ti phm xuyn quc gia s dng Internet truyn tin cho nhau. Mt
trong cc hnh thc thng c dng che du ni dung ca thng tin c truyn l
du thng tin trong cc bc tranh v gi n nh gi cc nh thng thng. Cnh st quc
t (interpol) va xc nh c cch gim nh mt bc tranh ca mt nhm ti phm
c cha thng bo mt hay khng. Bc tranh cha thng bo mt nu nh xu bit
biu din n cha "ch k" S l mt xu gm 4*N bit cho trc (0<N250). gii m
thng bo mt c che du cn xc nh s ln xut hin ch k trong tranh. Cc
on xu bit cha ch k trong tranh c th giao nhau. Tranh c biu din di dng
dy ch s trong h m c s 16. Ch k S c ghi nhn di dng dy gm N ch s
ca h m c s 16.
V d: ch k 'BF' xut hin 2 ln trong bc tranh '6BF7F510F'
BF = 10111111
6BF7F510F = 011010111111011111110101000100001111

Yu cu: Cho ch k S v tranh. Hy xc nh s ln xut hin ch k ny trong

tranh
D liu: Vo t file IMAGE.INP
- Dng u tin cha xu chu k S

- Dng th hai cha thng tin v bc tranh di dng dy gm khng qu 40000 ch s

ca h m c s 16
Kt qu: a ra file vn bn IMAGE.OUT mt s nguyn l s ln xut hin ch k trong
tranh.
V d:
IMAGE.INP

IMAGE.OUT

BF

6BF7F510F
{**************************************************************************
* Program: IMAGE - Thi Olimpic Quoc gia 2004 - Bang A
* Giai thuat: Thuat toan KNUTH-MORRIS-PRATT

*
*

**************************************************************************}
{$A+,B-,D+,E+,F-,G-,I+,L+,N+,O-,P-,Q+,R+,S+,T-,V+,X+,Y+}
{$M 16384,0,655360}

uses crt;

const
tfi
tfo

='IMAGE.INP';
='IMAGE.OUT';

mau: array[0..15,1..4] of char=(('0','0','0','0'),

('0','0','0','1'),
('0','0','1','0'),
('0','0','1','1'),
('0','1','0','0'),
('0','1','0','1'),
('0','1','1','0'),
('0','1','1','1'),
('1','0','0','0'),

('1','0','0','1'),
('1','0','1','0'),
('1','0','1','1'),
('1','1','0','0'),
('1','1','0','1'),
('1','1','1','0'),
('1','1','1','1'));

var fi, fo

text;

integer;

array[1..1000] of char;

next

array[0..1001] of integer;

count

longint;

procedure DocS;
var i,k: integer;
ch: char;
begin
M:=0;
while not eoln(fi) do
begin
read(fi,ch);
case ch of
'0'..'9': k:=ord(ch)-ord('0');
'A'..'F': k:=ord(ch)-ord('A')+10;
end;
for i:=1 to 4 do
a[m+i]:=mau[k,i];

m:=m+4;
end;
readln(fi);
end;

procedure InitNext;
var i,j: integer;
begin
i:=1;
j:=0;
next[1]:=0;
repeat
if (j=0) or (a[i]=a[j]) then
begin
i:=i+1;
j:=j+1;
next[i]:=j;
end
else j:=next[j];
until i>M;
end;

procedure Dem;
var i,j,k,l: integer;
ch: char;
begin
j:=1;
count:=0;

repeat
read(fi,ch);
case ch of
'0'..'9': k:=ord(ch)-ord('0');
'A'..'F': k:=ord(ch)-ord('A')+10;
end;
l:=1;
repeat
if (j=0) or (mau[k,l]=a[j]) then
begin
l:=l+1;
j:=j+1;
end
else j:=next[j];
if j>M then
begin
count:=count+1;
j:=next[j];
end;
until l>4;
until eoln(fi);
end;

procedure Inkq;
begin
writeln(fo,count);
end;

BEGIN
assign(fi,tfi); reset(fi);
assign(fo,tfo); rewrite(fo);
DocS;
InitNext;
Dem;
Inkq;
close(fi); close(fo);
END.

Cc on s nguyn
Cho cc tp s nguyn
Si={p: ai p bi, p - s nguyn}, i=1,2,....,n
v n s nguyn c1, c2, ..., cn
Yu cu: Tm tp cc s nguyn Z vi lc lng nh nht sao cho:
Z Sici, i=1,2,...,n
D liu: Vo t file vn bn INTERVAL.INP:
Dng u tin ghi t l slng test. Trong mi test:
Dng u tin cha s nguyn dng n (1 n 50000)
Dng th i trong n dng tip theo cha cc s a i, bi, ci c ghi cch nhau bi du cch
(0 ai bi 50000 v 1 ci bi-ai+1).
Kt qu: Ghi ra file vn bn INTERVAL.OUT mt s nguyn l lc lng ca tp Z tm
c.
V d:
INTERVAL.INP

INTERVAL.OUT

5
3 7 3
8 10 3
6 8 1
1 3 1
10 11 1
*************************************************************************
/******************************************************************************
Program : CHUONG TRINH CHAM BAI HOC SINH - Version 1.0 (Ban C++)
Date : 06-03-2007
******************************************************************************/
#define _WIN32_WINNT 0x0500
#include<iostream>
#include<sstream>
#include<windows.h>
#include<ctime>
#include <iostream.h>
#include <fstream.h>
#include <stdio.h>
#include <iomanip.h>
#include <conio.h>
#include <string.h>
#include <math.h>
// Dinh ngia cac luong
ifstream inp;

ifstream out;
ifstream ans;
// khai bao phan dau cac file
char nfi[]
=
"INTERVAL.INP";
char nfo[]
=
"INTERVAL.OUT";
char fi[]
char fo[]
char fm[]
int Pmin
int Pmax

=
=
=
=
=

char cp[3]

"INP.00";
"OUT.00";
"ANS.00";
1;
20;
"00";

using namespace std;

// Cac bien tham so chuong trinh
char progName[100];
char parameters[10000];
int runTime;
// Khai bao bien
int loi[100], diem[100], tong=0;
long kqm, kqo;
int p;
// Ham Doc du lieu (neu co)
int doc()
{
return 0;
}
// Ham cham diem
int cham()
{
out >> kqo;
ans >> kqm;
if (kqm!=kqo) return 10; // wrong answer
return 0;
}
// Ham in ket qua
int viet()
{
int i;
cout << '\n';
cout << "KET QUA CHAM BAI" << '\n';
cout << '\n';
cout << '\n';
for (i=Pmin; i<=Pmax; i++)
{

cout << "Test " << setw(2) << i << " : " << diem[i] << " --- ";
switch (loi[i])
{
case 0 : cout << "Accept" ; break;
case 1 : cout << "Missing Output File"; break;
case 2 : cout << "Time limit execeed"; break;
case 10: cout << "Wrong answer"; break;
}
cout << '\n';
}
cout << "--------------------------" << '\n';
cout << "Tong =" << setw(3) << tong << '\n';
cout << '\n';
cout << '\n';
cout << "Press any key to continue..." << '\n';
getch();
return 0;
}
// Xoa tat ca cac file output
int XoaFile()
{
int i;
FILE *f;
for (i=Pmin; i<=Pmax; i++)
{
fo[4]=i/10+48; fo[5]=i%10+48;
f=fopen(fo,"r");
if (f!=NULL) {fclose(f); remove(fo);}
}
f=fopen(nfi,"r"); if (f!=NULL) {fclose(f); remove(nfi);}
f=fopen(nfo,"r"); if (f!=NULL) {fclose(f); remove(nfo);}
}
// Ham cham diem
int check()
{
char u,v;
for (p=Pmin; p<=Pmax; p++)
if (loi[p]==0)
{
u=p/10+48;
v=p%10+48;
fi[4]=u; fi[5]=v;
fo[4]=u; fo[5]=v;
fm[4]=u; fm[5]=v;
// Khai bao luong
inp.open(fi);
out.open(fo);
if (!out.good()) {loi[p]=1; diem[p]=0;} else
{
ans.open(fm);

// Cham diem
doc();
loi[p]=cham();
if (loi[p]==0) diem[p]=5; else diem[p]=0;
tong+=diem[p];
// Dong luong
out.clear();
inp.clear();
ans.clear();
inp.close();
out.close();
ans.close();
}
}
viet();
XoaFile();
return 0;
}
//----------------------------------------------------// PHAN CHUONG TRINH RUN
int execCmd() {
char* my_appName=progName;
char* my_lpCmd=parameters;
LPSECURITY_ATTRIBUTES my_lpProcessAttributes=NULL;
LPSECURITY_ATTRIBUTES my_lpThreadAttributes=NULL;
bool my_inheritHandles=true;
DWORD my_creationFlag=NORMAL_PRIORITY_CLASS;
LPVOID my_lpEnvironment=NULL;
char* my_directory=NULL;
STARTUPINFOA my_startupInfo;
ZeroMemory(&my_startupInfo, sizeof(STARTUPINFOA));
my_startupInfo.cb=sizeof(STARTUPINFOA);
PROCESS_INFORMATION my_processInfo;
//Ref = http://msdn.microsoft.com/library/default.asp?url=/library/enus/dllproc/base/createprocess.asp
bool ok=CreateProcess(my_appName, my_lpCmd, my_lpProcessAttributes,
my_lpThreadAttributes, my_inheritHandles,
my_creationFlag, my_lpEnvironment, my_directory,
&my_startupInfo, &my_processInfo);
int beginTime=clock();
int endTime=beginTime+runTime;
DWORD exitCode;
while (clock()<endTime) {
GetExitCodeProcess(my_processInfo.hProcess, &exitCode);
if (exitCode<256) return 0;
Sleep(10);
}
bool terminate=TerminateProcess(my_processInfo.hProcess, 0);

return 2; //Time limit exceed!

}
// Ham nhap ten chuong trinh va thoi gian chay
int NhapTT()
{
printf("Ten FILE chuong trinh:");
gets(progName);
printf("Thoi gian (ms)
:");
scanf("%d",&runTime);
}
// Ham chay cac test
int chay()
{
for (p=Pmin; p<=Pmax; p++)
{
FILE *f1, *f2;
char c;
fi[4]=p/10+48; fi[5]=p%10+48;
fo[4]=p/10+48; fo[5]=p%10+48;
//copyfile(fi,input);
f1=fopen(fi,"rb");
f2=fopen(nfi,"wb");
if (f1!=NULL)
while ((c=getc(f1))!=EOF) putc(c,f2);
fclose(f1); fclose(f2);
cout << "Running test " << p << '\n';
loi[p]=execCmd();
if (loi[p]==0)
{
//copyfile(output,fo);
f1=fopen(nfo,"rb");
f2=fopen(fo,"wb");
if (f1!=NULL)
while ((c=getc(f1))!=EOF) putc(c,f2);
if (f1!=NULL) fclose(f1);
if (f2!=NULL) fclose(f2);
}
}
}
//----------------------------------------------------// CHUONG TRINH CHINH
int main()
{
NhapTT();
chay();
cout << "Checking! Wait please...." << '\n';
check();
}

ng st lin vn
Cng ty ng st Byteotian quyt nh gii thiu ti khch hng ca h mt ng st lin vn gia cc
thnh ph. ng lin vn chy qua N thnh ph nh s lin tip t 1 n N (thnh ph bt u l 1 v
thnh ph cui cng l N). C M ch ngi trong tu ho. H thng my tnh s nhn nhng yu cu lin tip
v xc nh theo ng th t nhn yu cu m tr li c th chp nhn c yu cu hay khng. Mt yu cu
c chp nhn khi tu lin vn trong on ng m yu cu ny a ra cn s lng ch ngi trng.
Ngc li th yu cu khng c chp nhn.
Nhim v ca bn l vit chng trnh tnh ton nhng yu cu no s c chp nhn hoc b loi b.
Input: Kol.in
- Dng u tin gm 3 s N, M, Z cch nhau bi cc du cch (1 N, M, Z 30000), ln lut l s lng
thnh ph trn tuyn ng st, s lng gh ngi trong tu ho v s yu cu.
- Dng th i trong Z dng tip theo m t yu cu i. Yu cu c m t bi 3 s nguyn U, V, W cch nhau
bi cc du cch (1 U, V N, 1 W M), ln lt l s hiu nh ga i, s hiu nh ga n v s lng
gh trng cn mua ca yu cu.
Output: Kol.out
- Gm Z dng, dng th i ghi T/N tng ng vi yu cu i c c tho mn hay khng.
V d:
Kol.in
464
142
132
243
123

Kol.out
T
T
N
N

Const
Fin = 'kol.in';
Fout= 'kol.out';
Type
Arr1 = Array[1..30000] Of Integer ;
Var
Fi, Fo : Text ;
Res,Total,N,M,Z : Longint ;
Pos,Sum,Max : ^Arr1 ;
Procedure Main( Var Pos, Sum, Max : Arr1 );
Procedure Init;
Begin
Fillchar( Pos, Sizeof(Pos), 0);

Fillchar( Max, Sizeof(Max), 0);

Fillchar( Sum, Sizeof(Sum), 0);
End;
Procedure Get( L,R,x,y : Longint );
Var
Mid : Longint ;
Begin
If L>R then Exit ;
Mid := (L+R) shr 1;
If (x<=L) and (R<=y) then
Begin
If Res < Total + Max[Mid] then
Res := Total + Max[Mid] ;
Exit ;
End;
Total := Total + Sum[Mid];
If (x<=Mid) and (Mid<=y) then
If Res < Total + Pos[Mid] then
Res := Total + Pos[Mid] ;
If x<Mid then Get( L, Mid-1, x, y);
If Mid<y then Get( Mid+1, R, x, y);
Total := Total - Sum[Mid];
End;
Function Max3( a,b,c : Integer ) : Integer ;
Begin
If a<b then a:=b;
If a<c then a:=c;
Max3 := a;
End;

Function GetIT( L,R : Longint ) : Integer ;

Begin
If L>R then GetIT := 0
Else GetIT := Max[(L+R) shr 1];
End;
Procedure Update( L,R,x,y,value : Longint );
Var
Mid : Longint ;
Begin
If L>R then Exit ;
Mid := (L+R) shr 1;
If (x<=L) and (R<=y) then
Begin
Inc( Sum[Mid], Value );
Inc( Max[Mid], Value );
Exit ;
End;
If (x<=Mid) and (Mid<=y) then Inc(Pos[Mid], Value );
If x<Mid then Update( L, Mid-1, x, y, value );
If Mid<y then Update( Mid+1, R, x, y, value );
Max[Mid] := Max3( GetIT( L, Mid-1), GetIT( Mid+1, R), Pos[Mid]) + Sum[Mid] ;
End;
Procedure Xuly;
Var
st, en, c, i : Longint ;
Begin
Assign( Fi, Fin); Reset( Fi);
Assign( Fo, Fout); Rewrite( Fo);
Readln( Fi, N, M, Z);

For i:=1 to Z do
Begin
Readln( Fi, st, en, c);
Res := 0;
Total := 0;
Get( 1, N, st, en-1 );
If Res + c <=M then
Begin
Writeln( Fo, 'T');
Update( 1, N, st, en-1, c );
End
Else Writeln( Fo, 'N');
End;
Close( Fi);
Close( Fo);
End;
Begin
Init;
Xuly;
End;
Var
_t : Longint ;
Time : Longint absolute 0:$46C;
Begin
_t := Time ;
New( Pos);
New( Sum);
New( Max);
Main( Pos^, Sum^, Max^ ) ;

Writeln( (Time-_t)/18.23 : 0 : 4 );
End.
Cng ty Chris chun sn xut mt thit b chn s. B chn s c n u vo, mi u vo c th nhn mt s
nguyn. N c mt u ra cho gi tr ln nht ca cc s nguyn trong n u vo.
thu c s ln nht, b chn s ln lt cho n s ny chy qua M thit b. Mi thit b c n u vo v n
u ra, cc s trn n u ra ca thit b th i l cc s trn n u vo ca thit b th i+1 (1 i<M) theo th t
tng ng. N u vo ca b chn s l N u vo ca thit b s 1. Thit b th i c m t bng mt cp
hai s (a,b) vi ngha l cc s cc u vo a, a+1, ..., b khi qua thit b s c sp xp khng gim
u ra v cng t cc u ra a, a+1, ..., b. Cc s cc u vo khc s c gi nguyn u ra tng
ng. Sau khi qua thit b th M s u ra N s l s u ra b chn s (v l s ln nht trong N s
u vo ca b chn s).
Mt nhn vin ca cng ty sau khi phn tch hot ng ca b chn s pht hin ra rng c th b i bt
mt s thit b m b chn s vn cho kt qu ng (l gi tr ln nht ca N s u vo). Hy tm s lng
t nht cc thit b cn gi li b chn s vn hot ng ng vi bt k b d liu no ca u vo.
Input: File MIMIMAX.INP

Dng u tin ghi N , M (2 N 50000, M 500000) vi N l s lng u vo v M l s lng

thit b

Cc thit b ln lt c m t M dng tip theo, dng th k m t sorter th k gm hai s nguyn

uk, vk.

Output: File MINIMAX.OUT mt s nguyn duy nht l s lng t nht cc thit b cn gi li.
V d:
MINIMAX.INP
40 6
20 30
1 10
10 20
20 30
15 25
30 40

MINIMAX.OUT
4

/*************************************************************************
Program : Minimizing Maximizer (From SPOJ - MINIMAX)
Date
: 15-4-2007
Langues : C++
*************************************************************************/
#include <iostream.h>
#define MAXN 50002
#define VC 1000000000;
// Khai bao cac bien chinh
long n, m, aTree[3*MAXN], pos[MAXN];
// Khoi tao interval tree
int InitTree(long d, long k, long l)
{
aTree[d]=VC;
if ((k==l))
{
pos[k]=d;
return 0;
}
long r=(k+l)/2;
InitTree(2*d,k,r);
InitTree(2*d+1,r+1,l);
return 0;
}
// Ham tra ve gia tri nho nhat tren mot doan
long Min(long u, long v, long k, long l, long d)
{
if ((u==k) && (v==l)) return aTree[d];
long r=(k+l)/2;
if (u>r) return Min(u,v,r+1,l,2*d+1);
if (v<=r) return Min(u,v,k,r,2*d);
long kq1=Min(u,r,k,r,2*d);
long kq2=Min(r+1,v,r+1,l,2*d+1);
return (kq1<kq2) ? kq1 : kq2;
}
// Ham sua lai cay
int Modify(long k)
{
long l=k/2;
while (l>=1)
{
aTree[l]=(aTree[2*l]<aTree[2*l+1]) ? aTree[2*l] : aTree[2*l+1];
l/=2;
}
return 0;
}

long solve()
{
long k,p,i,u,v;
for (i=1; i<=m; i++)
{
cin >> u >> v;
k=pos[v];
if (u==1) { aTree[k]=1;
Modify(k);} else
{
p=Min(u,v,1,n,1);
if (p+1<aTree[k])
{
aTree[k]=p+1;
Modify(k);
}
}
}
return aTree[pos[n]];
}
// CHUONG TRINH CHINH
int main()
{
int i, t;
cin >> t;
for (i=1; i<=t; i++)
{
cin >> n >> m;
InitTree(1,1,n);
cout << solve() << '\n';
}
return 0;
}
HNH VUNG CC I
Cho mt bng kch thc mxn, c chia thnh li vung n v m dng n ct. Trn cc ca bng ghi
s 0 hoc 1. Cc dng ca bng c nh s 1, 2... m theo th t t trn xung di v cc ct ca bng
c nh s 1, 2..., n theo th t t tri qua phi.
Hy tm mt hnh vung gm cc ca bng tho mn cc iu kin sau:
1. Hnh vung l ng nht: tc l cc thuc hnh vung phi ghi cc s ging nhau (0 hoc 1)
2. Cnh hnh vung song song vi cnh bng.
3. Kch thc hnh vung l ln nht c th.
D liu: Vo t file vn bn SQUARE.INP
Dng 1: Ghi hai s m, n
m dng tip theo, dng th i ghi n s m s th j l s ghi trn (i, j) ca bng
Kt qu: Ghi ra file vn bn SQUARE.OUT
Dng 1: Ghi kch thc cnh hnh vung tm c

Dng 2: Ghi 4 s nguyn r1, c1, r2, c2. y (r1, c1) l ch s hng v ch s ct ca thuc gc trn bn
tri, (r2, c2) l ch s hng v ch s ct ca thuc gc di bn phi hnh vung tm c.

Cc s trn mt dng ca Input/ Output file ghi cch nhau t nht mt du cch.
V d:
SQUARE.INP
11 13
0000010000000
0000111000000
0011111110000
0011111110000
0111111111000
1111111111100
0111111111000
0011111110000
0011111110000
0000111000011
0000010000011
program MaxSquare;
const
InputFile = 'SQUARE.INP';
OutputFile = 'SQUARE.OUT';
max = 1000;
var
m, n, maxSize, x, y: Integer;
Line: array[0..max] of Integer;
Column: array[1..max] of Integer;
procedure Init;
begin
FillChar(Line, SizeOf(Line), $FF);
maxSize := 1;
x := 1; y := 1;
end;
procedure Solve;
var
f: Text;
i, j, Count, Data: Integer;
begin
Assign(f, InputFile); Reset(f);
Readln(f, m, n);
for i := 1 to m do
begin
for j := 1 to n do
begin
Read(f, Data);
if Data <> Line[j] then Column[j] := 1

SQUARE.O
UT
7
3399

else Inc(Column[j]);
Line[j] := Data;
end;
Readln(f);
Count := 0;
for j := 1 to n do
if Column[j] <= maxSize then Count := 0
else
if Line[j] <> Line[j - 1] then Count := 1
else
begin
Inc(Count);
if Count > maxSize then
begin
x := i; y := j; Inc(maxSize);
Break;
end;
end;
end;
Close(f);
end;
procedure Result;
var
f: Text;
begin
Assign(f, OutputFile); Rewrite(f);
Writeln(f, maxSize);
Writeln(f, x - maxSize + 1, ' ', y - maxSize + 1, ' ', x, ' ', y);
Close(f);
end;
begin
Init;
Solve;
Result;
end.
78
11011111
00100001
11011111
00111111
11111111
11111111
11111111
54
0001
0010
0111
1111
0111
55

00100
01110
11111
01110
00100
11 11
00000100000
00001110000
00011111000
00111111100
01111111110
11111111111
01111111110
00111111100
00011111000
00001110000
00000100000
11 13
0000010000000
0000111000000
0011111110000
0011111110000
0111111111000
1111111111100
0111111111000
0011111110000
0011111110000
0000111000011
0000010000011