├── submited ├── GUESSING.txt ├── TCOUNT3.cpp ├── MAXLN.cpp ├── EMP.cpp ├── SAMER08F.cpp ├── SUMITR.cpp ├── BOMARBLE.cpp ├── NGM.cpp ├── ALICESIE.cpp ├── PRLGAME2.cpp ├── BINSTIRL.cpp ├── ARCTAN.cpp ├── EBOXES.cpp ├── TRICOUNT.cpp ├── AMR10F.cpp ├── ACPC10A.cpp ├── RESN04.cpp ├── TCOUNT2.cpp ├── ALCHE.cpp ├── EASYPROB.txt ├── EIGHTS.cpp ├── CFPARTY.cpp ├── GIRLSNBS.cpp ├── LLCA.cpp ├── ACT.cpp ├── GNY07A.cpp ├── NSTEPS.cpp ├── SCPC11D.cpp ├── CLTZ.py ├── FCTRL.cpp ├── FENCE1.cpp ├── HUBULLU.cpp ├── MKLABELS.cpp ├── CUBES.cpp ├── TRGRID.cpp ├── PALACE.cpp ├── PROBLEM.cpp ├── ANARC08H.cpp ├── ANARC09A.cpp ├── MINCOUNT.cpp ├── OLOLO.cpp ├── HC.cpp ├── GUESSNUM.cpp ├── FTHEELF.cpp ├── FUNPROB.cpp ├── SNOOKER.cpp ├── MBEEWALK.cpp ├── QUADAREA.cpp ├── CLOCK2.cpp ├── LASTDIG.cpp ├── AVION1.cpp ├── CANTON.cpp ├── PERMUT2.cpp ├── ACPC10E.cpp ├── BEENUMS.cpp ├── MRECAMAN.cpp ├── LENGFACT.cpp ├── OFFSIDE.cpp ├── CANDY3.cpp ├── FIBFUNCH.cpp ├── SCPC11B.cpp ├── AE1B.cpp ├── CYLINDER.cpp ├── ITRIX_B.cpp ├── DANGER.cpp ├── TEAM2.cpp ├── GLJIVE.cpp ├── TRICENTR.cpp ├── ANARC09B.cpp ├── GCD2.cpp ├── NY10A.cpp ├── CANDY.cpp ├── HACKRNDM.cpp ├── HANGOVER.cpp ├── NY10E.cpp ├── MBINGO.cpp ├── PARKET1.cpp ├── AMR10G.cpp ├── BYECAKES.cpp ├── PERMUT1.cpp ├── ARMY.cpp ├── BAISED.cpp ├── PIR.cpp ├── UJ.cpp ├── SBANK.cpp ├── MFLAR10.cpp ├── STREETR.cpp ├── TOANDFRO.cpp ├── LASTDIG2.cpp ├── DYZIO.cpp ├── PEBBMOV.cpp ├── ZBROJ.cpp ├── BALIFE.cpp ├── FASHION.cpp ├── TRAVERSE.cpp ├── WORKB.cpp ├── OPCPIZZA.cpp ├── BRODOVI.cpp ├── MUSIC2.cpp ├── QUALITY.cpp ├── REBOUND.cpp ├── ETF.cpp ├── HOTELS.cpp ├── CF36D.cpp ├── ICODER.cpp ├── PRO.cpp ├── STAMPS.cpp ├── NOCHANGE.cpp ├── GROCERY.cpp ├── ANARC08E.cpp ├── ANARC05I.cpp ├── GUESSTHE.cpp ├── PATHEADS.cpp ├── STPAR.cpp ├── PUCMM210.cpp ├── GNY07B.cpp ├── M3TILE.cpp ├── TREX.cpp ├── MINMOVE.cpp ├── XMEDIAN.cpp ├── BEADS.cpp ├── MZVRK.cpp ├── PLYGRND.cpp ├── SAMER08G.cpp ├── TDPRIMES.cpp ├── WORDCNT.cpp ├── CNEASY.cpp ├── HEADSHOT.cpp ├── MICEMAZE.cpp ├── MIDO.cpp ├── CHICAGO.cpp ├── MISERMAN.cpp ├── COINS.cpp ├── DSUBSEQ.cpp ├── ENCONDIN.cpp ├── PIGBANK.cpp ├── NEG2.cpp ├── MBLAST.cpp ├── ABCDEF.cpp ├── ANARC05H.cpp ├── IOIPALIN.cpp ├── MCOINS.cpp ├── TEMPTISL.cpp ├── TRIKA.cpp ├── TRT.cpp ├── TTREAT.cpp ├── ACODE.cpp ├── NG1FRCTN.cpp ├── SAMER08C.cpp ├── STONE.cpp ├── DNPALIN.cpp ├── ROADNET.cpp ├── BUSYMAN.cpp ├── CHAIR.cpp ├── MARBLES.cpp ├── PANCAKES.cpp ├── GCD3.cpp ├── AIBOHP.cpp ├── BYTESM2.cpp ├── DEFKIN.cpp ├── DEPOSIT.cpp ├── EQUI.cpp ├── JNEXT.cpp ├── OSPROB1.cpp ├── ACPC10D.cpp ├── GCJ2012C.cpp ├── MAYA.cpp ├── NFACTOR.cpp ├── TDKPRIME.cpp ├── EQ.cpp ├── HALLOW.cpp ├── MMMGAME.cpp ├── TEST.cpp ├── MMAXPER.cpp ├── MAXSUB.cpp ├── GNY07H.cpp ├── PQUEUE.cpp ├── SUMFOUR.cpp ├── ABSYS.cpp ├── MOBILE2.cpp ├── PARTIT.cpp ├── SCAVHUNT.cpp ├── FRACTION.cpp ├── GCPC11F.cpp ├── HEXBOARD.cpp ├── CLOCKS.cpp ├── CORNET.cpp ├── HEPNUM.cpp ├── LAGRANGE.cpp ├── PERIOD.cpp ├── GNY07E.cpp ├── BHAT007.cpp ├── POUR1.cpp ├── IMPUNITS.cpp ├── WPC4F.cpp ├── SCUBADIV.cpp ├── ARITH2.cpp ├── DIV2.cpp ├── CHASE.cpp ├── BRCKTS2.cpp ├── JRIDE.cpp ├── GCPC11B.cpp ├── LINEUP.cpp ├── SOLDIER.cpp ├── HAMSTER1.cpp ├── MARKUP.cpp ├── QUADRATE.cpp ├── EQBOX.cpp ├── FCTRL2.cpp ├── RPLK.cpp ├── ANARC05B.cpp ├── PHIDIAS.cpp ├── EXPRESS.cpp ├── PTIME.cpp ├── CZ_PROB1.cpp ├── BABTWR.cpp ├── ZIGZAG.cpp ├── DIV.cpp ├── GNY07D.cpp ├── TETRA.cpp ├── BOI7SEQ.cpp ├── INVCNT.cpp ├── GNY07G.cpp ├── TWENDS.cpp ├── BINGO.cpp ├── RPLN.cpp ├── SAMER08E.cpp ├── SUBST1.cpp ├── DCD.cpp ├── LWAR.cpp ├── NOTATRI.cpp ├── GCPC11J.cpp ├── JMFILTER.cpp ├── DRAWM.cpp ├── LCMSUM.cpp ├── CPRMT.cpp ├── MMASS.cpp ├── EDIST.cpp ├── PHONELST.cpp ├── MCARDS.cpp ├── EPALIN.cpp ├── BUREAU.cpp ├── CATM.cpp ├── HERDING.cpp ├── MAKESUM.cpp ├── MDIGITS.cpp ├── NG0FRCTN.cpp ├── BMJ.cpp ├── CSTREET.cpp ├── GARDENAR.cpp ├── MAJSTOR.cpp ├── NY10B.cpp ├── PT07Y.cpp ├── MJLAR10.cpp ├── SEQ6.cpp ├── C1TABOVI.cpp ├── NY10D.cpp ├── NSYSTEM.cpp ├── ACS.cpp ├── AMR10C.cpp └── AE2B.cpp └── README.md /submited/GUESSING.txt: -------------------------------------------------------------------------------- 1 | LIFE IS LIKE A BOX OF CHOCOLATES. YOU NEVER KNOW WHAT YOU'RE GONNA GET. -------------------------------------------------------------------------------- /submited/TCOUNT3.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | main(int t,unsigned long long n){scanf("%d",&t);while(t--){scanf("%llu",&n);printf("%llu\n",n*(10*n*n+9*n+1));}} 3 | -------------------------------------------------------------------------------- /submited/MAXLN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MAXLN 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | int main(){int r,t,c=1;for(scanf("%d",&t);t--;){scanf("%d",&r);printf("Case %d: %lld.25\n",c++,(long long)r*r<<2);}return 0;} -------------------------------------------------------------------------------- /submited/EMP.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EMP 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int a, b; 12 | cin >> a >> b; 13 | cout << a + b << endl; 14 | return 0; 15 | } 16 | -------------------------------------------------------------------------------- /submited/SAMER08F.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SAMER08F 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | int main() 9 | { 10 | long long n; 11 | while(scanf("%lld",&n)==1 && n) 12 | printf("%lld\n",n*(n+1)*(2*n+1)/6); 13 | return 0; 14 | } 15 | -------------------------------------------------------------------------------- /submited/SUMITR.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | int a[105][105],i,j,t,n; 3 | main(){scanf("%d",&t);while(t--){scanf("%d",&n);for(i=1;i<=n;i++)for(j=1;j<=i;j++){scanf("%d",&a[i][j]);a[i][j]=std::max(a[i-1][j-1],a[i-1][j])+a[i][j];}j=0;for(i=1;i<=n;i++)j=std::max(j,a[n][i]);printf("%d\n",j);}} 4 | -------------------------------------------------------------------------------- /submited/BOMARBLE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BOMARBLE 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int n; 11 | while(scanf("%d", &n)==1 && n) { 12 | n++; 13 | printf("%d\n", n * (3*n - 1) / 2); 14 | } 15 | return 0; 16 | } 17 | -------------------------------------------------------------------------------- /submited/NGM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NGM 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int n; 12 | while(scanf("%d",&n)==1) 13 | { 14 | if(n%10) printf("1\n%d\n",n%10); 15 | else printf("2\n"); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /submited/ALICESIE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ALICESIE 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int test, n; 11 | scanf("%d", &test); 12 | while(test--) { 13 | scanf("%d", &n); 14 | printf("%d\n", (n + 1) >> 1); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /submited/PRLGAME2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PRLGAME2 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int cs = 1, n, p, q; 11 | while(scanf("%d %d %d", &n, &p, &q) == 3) printf("Case %d: %.4lf\n", cs++, (double)(q+1) / (p+2)); 12 | return 0; 13 | } 14 | -------------------------------------------------------------------------------- /submited/BINSTIRL.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BINSTIRL 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int t, n, m; 12 | scanf("%d", &t); 13 | while(t--) 14 | { 15 | scanf("%d%d", &n, &m); 16 | printf("%d\n", !((n-m)&((m-1)>>1))); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/ARCTAN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ARCTAN 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | int main(){long long a,c,t,b;scanf("%lld",&t);while(t--){scanf("%lld",&a);c=1;c<<=60; 10 | for(b=a+1;b<=2*a+1;b++)if((a*b+1)%(b-a)==0)c=std::min(c,b+(a*b+1)/(b-a));printf("%lld\n",c);}return 0;} -------------------------------------------------------------------------------- /submited/EBOXES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EBOXES 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int cs, n, k, t, f; 11 | scanf("%d", &cs); 12 | while(cs--) { 13 | scanf("%d %d %d %d", &n, &k, &t, &f); 14 | printf("%d\n", (f - n) / (k - 1) + f); 15 | } 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /submited/TRICOUNT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TRICOUNT 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | long long n; 12 | int t; 13 | for(scanf("%d", &t); t; t--) 14 | { 15 | scanf("%lld",&n); 16 | printf("%lld\n", (n * (n+2) * ((n*2)+1))/8); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/AMR10F.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AMR10F 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int t, n, a, d; 12 | scanf("%d", &t); 13 | while(t--) { 14 | scanf("%d%d%d", &n, &a, &d); 15 | printf("%d\n", n*(2*a + (n-1)*d) / 2); 16 | } 17 | return 0; 18 | } -------------------------------------------------------------------------------- /submited/ACPC10A.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ACPC10A 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int a, b, c; 11 | while(scanf("%d%d%d", &a, &b, &c)==3 && (a|b|c)) { 12 | if(b - a == c - b) printf("AP %d\n", c + c - b); 13 | else printf("GP %d\n", c * c / b); 14 | } 15 | return 0; 16 | } -------------------------------------------------------------------------------- /submited/RESN04.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: RESN04 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int t, n, a, i; 12 | cin >> t; 13 | while(t--) { 14 | cin >> n; 15 | for(i=0; i> a; 16 | cout << "ALICE" << endl; 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/TCOUNT2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TCOUNT2 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int t; 12 | long double n; 13 | for(scanf("%d", &t); t; t--) 14 | { 15 | scanf("%Lf", &n); 16 | printf("%.0Lf\n", n/2.0 * (7.0*n*n + 4.5*n + 1.0)); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/ALCHE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ALCHE 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int L, W; 12 | while(scanf("%d%d", &L, &W)==2) { 13 | if(L==-1 && W==-1) break; 14 | if(37*L == 1000*W) puts("Y"); 15 | else puts("N"); 16 | } 17 | return 0; 18 | } 19 | -------------------------------------------------------------------------------- /submited/EASYPROB.txt: -------------------------------------------------------------------------------- 1 | 137=2(2(2)+2+2(0))+2(2+2(0))+2(0) 2 | 1315=2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2(0))+2+2(0) 3 | 73=2(2(2)+2)+2(2+2(0))+2(0) 4 | 136=2(2(2)+2+2(0))+2(2+2(0)) 5 | 255=2(2(2)+2+2(0))+2(2(2)+2)+2(2(2)+2(0))+2(2(2))+2(2+2(0))+2(2)+2+2(0) 6 | 1384=2(2(2+2(0))+2)+2(2(2+2(0)))+2(2(2)+2)+2(2(2)+2(0))+2(2+2(0)) 7 | 16385=2(2(2+2(0))+2(2)+2)+2(0) -------------------------------------------------------------------------------- /submited/EIGHTS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EIGHTS 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | #define i64 long long 10 | 11 | int main() 12 | { 13 | int t; i64 k; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%lld", &k); 18 | printf("%lld\n", 250*(k-1) + 192); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/CFPARTY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CFPARTY 4 | ALGO: tial and error 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int t, n; 13 | scanf("%d", &t); 14 | while(t--) { 15 | scanf("%d", &n); 16 | printf("%d\n", max(0, n-2)); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/GIRLSNBS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GIRLSNBS 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int a, b; 12 | while(scanf("%d%d", &a, &b)==2 && (a > -1 && b > -1)) { 13 | if(a < b) a ^= b ^= a ^= b; 14 | printf("%d\n", (a + b) / (b + 1)); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /submited/LLCA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LLCA 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | int main(){ 9 | int c,t,a,b; 10 | scanf("%d",&c); 11 | while(c--){ 12 | scanf("%d%d%d",&t,&a,&b); 13 | while(a!=b){ 14 | if(a>b)a=(a+t-2)/t; 15 | else b=(b+t-2)/t; 16 | } 17 | printf("%d\n",a); 18 | } 19 | return 0; 20 | } -------------------------------------------------------------------------------- /submited/ACT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ACT 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | char str[50005]; 13 | int t, n; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%d %s", &n, str); 18 | printf("%c\n", str[strlen(str)-1]); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/GNY07A.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GNY07A 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | char word[100]; 12 | int t, n, x; 13 | for(scanf("%d", &t), x=1; x<=t; x++) 14 | { 15 | scanf("%d%s", &n, word); 16 | word[n-1] = 0; 17 | printf("%d %s%s\n",x,word,&word[n]); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /submited/NSTEPS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NSTEPS 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int n, x, y, t; 12 | for(scanf("%d", &t); t; t--) 13 | { 14 | scanf("%d %d", &x, &y); 15 | if(x==y || x==y+2) printf("%d\n", x + y - (int)(x&1)); 16 | else printf("No Number\n"); 17 | } 18 | return 0; 19 | } 20 | -------------------------------------------------------------------------------- /submited/SCPC11D.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SCPC11D 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int a, b, c; 11 | while(scanf("%d %d %d", &a, &b, &c)==3 && (a|b|c)) { 12 | a = a * a, b = b * b, c = c * c; 13 | if(a + b == c || b + c == a || c + a == b) puts("right"); 14 | else puts("wrong"); 15 | } 16 | return 0; 17 | } -------------------------------------------------------------------------------- /submited/CLTZ.py: -------------------------------------------------------------------------------- 1 | def collatz(n): 2 | i = 1 3 | while n!=1: 4 | i = i+1 5 | if n%2==0: 6 | n = n/2 7 | else: 8 | n = 3*n+1 9 | return i; 10 | 11 | def main(): 12 | while 1: 13 | try: 14 | n = input() 15 | except: 16 | break 17 | print collatz(n) 18 | 19 | main() 20 | -------------------------------------------------------------------------------- /submited/FCTRL.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FCTRL 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int t, n, count; 12 | for(scanf("%d",&t);t;t--) 13 | { 14 | scanf("%d",&n); 15 | count = 0; 16 | while(n) 17 | { 18 | count += n/5; 19 | n /= 5; 20 | } 21 | printf("%d\n",count); 22 | } 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /submited/FENCE1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FENCE1 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | int n; 13 | double area, pi = acos(-1.0), eps = 1e-10, L; 14 | while(scanf("%d", &n)==1 && n) 15 | { 16 | L = n; 17 | area = L*L/2.0/pi; 18 | printf("%.2lf\n", area + eps); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/HUBULLU.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HUBULLU 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() 11 | { 12 | int n, f, t; 13 | char player[2][20] = {"Airborne wins.", "Pagfloyd wins."}; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%d %d", &n, &f); 18 | puts(player[f]); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/MKLABELS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MKLABELS 4 | ALGO: counting 5 | */ 6 | 7 | #include 8 | 9 | int ans[] = {0,1,1,3,16,125,1296,16807,262144,4782969,100000000}; 10 | 11 | int main() 12 | { 13 | int n, test=1; 14 | while(scanf("%d", &n)==1 && n) 15 | printf("Case %d, N = %d, # of different labelings = %d\n",test++,n,ans[n]); 16 | return 0; 17 | } 18 | -------------------------------------------------------------------------------- /submited/CUBES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CUBES 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int a, b, c, d; 12 | for(a=6;a<=100;a++) 13 | for(b=2;b 8 | 9 | int main() 10 | { 11 | int t, r, c; 12 | scanf("%d",&t); 13 | while(t--) 14 | { 15 | scanf("%d%d",&r,&c); 16 | if(c>=r && r&1) printf("R\n"); 17 | else if(c>=r && !(r&1)) printf("L\n"); 18 | else if(c&1) printf("D\n"); 19 | else printf("U\n"); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /submited/PALACE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PALACE 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int t, power[250], i, n; 12 | power[0] = 1; 13 | for(i=1; i<204; i++) 14 | power[i] = (power[i-1]<<1) % 98777; 15 | scanf("%d", &t); 16 | while(t--) 17 | { 18 | scanf("%d", &n); n--; 19 | printf("%d\n", power[((n%204)*(n%204))%204]); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /submited/PROBLEM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PROBLEM 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int mp[10] = {1, 0, 0, 0, 0, 0, 1, 0, 2, 1}; 10 | 11 | int main() { 12 | int test, i, j; 13 | char num[128]; 14 | scanf("%d", &test); 15 | while(test--) { 16 | scanf("%s", num); 17 | for(i = j = 0; num[i]; i++) j += mp[num[i]-'0']; 18 | printf("%d\n", j); 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/ANARC08H.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC08H 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | 9 | int solve(int n, int d) 10 | { 11 | register int i, a = 0; 12 | for(i=2; i<=n; i++) 13 | a = (a+d)%i; 14 | return a; 15 | } 16 | 17 | int main() 18 | { 19 | int n, d; 20 | while(scanf("%d%d", &n, &d)==2 && n+d) 21 | printf("%d %d %d\n", n, d, solve(n, d) + 1); 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /submited/ANARC09A.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC09A 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int i, x, y, cs = 1; 11 | char buff[4096]; 12 | while(scanf("%s", buff) == 1 && buff[0] != '-') { 13 | for(x = y = i = 0; buff[i]; i++) { 14 | x += buff[i] == '{' ? 1 : -1; 15 | if(x < 0) x += 2, y++; 16 | } 17 | printf("%d. %d\n", cs++, (x>>1) + y); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /submited/MINCOUNT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MINCOUNT 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() 11 | { 12 | unsigned long long n, k; 13 | int t; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%llu", &n); 18 | if(n==0) { printf("0\n"); continue; } 19 | k = (n-1)/3; 20 | printf("%llu\n", (3*k*(k+1))/2 + ((n-1)%3) * (k+1)); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /submited/OLOLO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: OLOLO 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | const int BUFF = 5000000; 10 | static char buff[BUFF], *p; 11 | 12 | #define R(n) while(*p<48)p++;n=0;do{n=n*10+*p++-48;}while(*p>47); 13 | 14 | int main() { 15 | int n, s, a; 16 | fread(buff, 1, BUFF, stdin); 17 | p = buff; R(n); s = 0; 18 | while(n--) { R(a); s ^= a; } 19 | printf("%d\n", s); 20 | return 0; 21 | } -------------------------------------------------------------------------------- /submited/HC.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HC 4 | ALGO: nim game 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int t, n, i, p; 11 | char name[5], player[2][5] = {"hhb", "lxh"}; 12 | for(scanf("%d", &t); t; t--) { 13 | scanf("%d%s", &n, name); 14 | p = (name[0]=='l'); 15 | for(i=1; i 8 | 9 | int main() { 10 | int a, b, m; 11 | char ver[16]; 12 | scanf("%d %d", &a, &b); 13 | while(a <= b) { 14 | m = (a + b) >> 1; 15 | printf("%d\n", m); 16 | fflush(stdout); 17 | scanf("%s", ver); 18 | if(ver[0] == 'W') break; 19 | if(ver[0] == 'H') b = m-1; 20 | else a = m+1; 21 | } 22 | return 0; 23 | } -------------------------------------------------------------------------------- /submited/FTHEELF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FTHEELF 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | const double g = 9.8; 11 | 12 | int main() { 13 | double v, h; 14 | while(scanf("%lf %lf", &v, &h) == 2) { 15 | if(h < 0 && v < 0) break; 16 | if(v < 1) printf("0.000000\n"); 17 | else printf("%.6lf\n", v * v / g / tan(asin(v / sqrt(2.0 * g * h + 2.0 * v * v)))); 18 | } 19 | return 0; 20 | } 21 | 22 | -------------------------------------------------------------------------------- /submited/FUNPROB.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FUNPROB 4 | ALGO: math, probability, catalan number 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int m, n; 11 | double mm, nn; 12 | while(scanf("%d %d", &n, &m)==2 && m+n) { 13 | if(!n) printf("1.000000\n"); 14 | else if(n > m) printf("0.000000\n"); 15 | else { 16 | mm = m; nn = n; 17 | printf("%lf\n", (mm-nn+1.0) / (mm+1.0)); 18 | } 19 | } 20 | return 0; 21 | } 22 | -------------------------------------------------------------------------------- /submited/SNOOKER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SNOOKER 4 | ALGO: math, gcd 5 | */ 6 | 7 | #include 8 | 9 | unsigned gcd(unsigned a, unsigned b) 10 | { 11 | while(b) b ^= a ^= b ^= a %= b; 12 | return a; 13 | } 14 | 15 | int main() 16 | { 17 | unsigned g, m, n; 18 | while(scanf("%u %u", &m, &n)==2 && m) 19 | { 20 | g = gcd(m, n); 21 | m /= g; n /= g; 22 | printf("%u\n", (m + n - 2) << 2); 23 | } 24 | return 0; 25 | } 26 | -------------------------------------------------------------------------------- /submited/MBEEWALK.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MBEEWALK 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | //http: // www.research.att.com / ~njas / sequences / A002898 10 | 11 | int a[] = {1, 0, 6, 12, 90, 360, 2040, 10080, 54810, 290640, 1588356, 8676360, 47977776, 266378112, 1488801600}; 12 | 13 | int main() { 14 | int t, n; 15 | scanf("%d", &t); 16 | while(t--) { 17 | scanf("%d", &n); 18 | printf("%d\n", a[n]); 19 | } 20 | return 0; 21 | } -------------------------------------------------------------------------------- /submited/QUADAREA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: QUADAREA 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int t; 14 | double s, m, a, b, c, d; 15 | scanf("%d", &t); 16 | while(t--) 17 | { 18 | scanf("%lf %lf %lf %lf", &a, &b, &c, &d); 19 | s = (a+b+c+d)/2.0; 20 | m = sqrt((s-a)*(s-b)*(s-c)*(s-d)); 21 | printf("%.2lf\n", m); 22 | } 23 | return 0; 24 | } 25 | -------------------------------------------------------------------------------- /submited/CLOCK2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CLOCK2 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | char a[][8] = {"I", "II", "III", "IV", "V", "VI", "VII", "VIII", "IX", "X", "XI", "XII"}; 11 | 12 | int main() { 13 | int i, t=1; 14 | char aa[8]; 15 | while(scanf("%s", aa) == 1) { 16 | for(i = 0; i < 12; i++) if(!strcmp(a[i], aa)) break; 17 | printf("Case %d: %d\n", t++, i+1); 18 | } 19 | return 0; 20 | } 21 | -------------------------------------------------------------------------------- /submited/LASTDIG.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LASTDIG 4 | ALGO: pre-calculation 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int b, p, t, i, j, table[10][4]; 12 | for(i=0; i<10; i++) 13 | for(j=table[i][0]=1; j<=4; j++) 14 | table[i][j&3] = (table[i][j-1]*i)%10; 15 | for(scanf("%d",&t); t; t--) 16 | { 17 | scanf("%d %d", &b, &p); 18 | if(!p) printf("1\n"); 19 | else printf("%d\n", table[b%10][p&3]); 20 | } 21 | return 0; 22 | } 23 | -------------------------------------------------------------------------------- /submited/AVION1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AVION1 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() { 11 | char str[16], *ptr; 12 | int first = 0, i; 13 | for(i = 0; i < 5; i++) { 14 | scanf("%s", str); 15 | ptr = strstr(str, "FBI"); 16 | if(ptr) { 17 | if(first) putchar(' '); 18 | putchar(i+'1'); first++; 19 | } 20 | } 21 | if(!first) puts("HE GOT AWAY!"); 22 | else putchar('\n'); 23 | return 0; 24 | } -------------------------------------------------------------------------------- /submited/CANTON.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASL: CANTON 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | int n, p, d, t; 13 | for(scanf("%d",&t);t;t--) 14 | { 15 | scanf("%d",&n); 16 | d = (int)(ceil((sqrt(8*n+1)-1)/2)+10e-8); 17 | p = d*(d+1)/2 - n; 18 | printf("TERM %d IS ",n); 19 | if(d&1) printf("%d/%d\n",1+p,d-p); 20 | else printf("%d/%d\n",d-p,1+p); 21 | } 22 | return 0; 23 | } 24 | 25 | 26 | -------------------------------------------------------------------------------- /submited/PERMUT2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PERMUT2 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | #define MAX 100001 10 | 11 | int main() 12 | { 13 | int a[MAX], n, i, cnt; 14 | while(scanf("%d", &n)==1 && n) 15 | { 16 | for(i=0; i 8 | using namespace std; 9 | 10 | int main() { 11 | int g, a, t, d, i; 12 | long long p, k; 13 | while(scanf("%d%d%d%d", &g, &t, &a, &d)==4 && g > 0) { 14 | k = (long long) g * a + d; 15 | for(i = 0; (1LL< 8 | #include 9 | using namespace std; 10 | 11 | typedef long long i64; 12 | 13 | int main() { 14 | i64 p, d, rt; 15 | while(scanf("%lld", &p)==1 && p > 0) { 16 | d = 9 + 12*(p-1); 17 | rt = (i64)sqrt((double)d); 18 | if(rt*rt == d) { 19 | rt -= 3; 20 | if(rt % 6 == 0) puts("Y"); 21 | else puts("N"); 22 | } 23 | else puts("N"); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /submited/MRECAMAN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MRECAMAN 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | const int MAX = 500000, RNG = 5000000; 10 | 11 | bool flag[RNG+1]; 12 | int a[MAX+1]; 13 | 14 | int main() 15 | { 16 | int i, n, p; 17 | for(i=1; i<=MAX; i++) 18 | { 19 | p = a[i-1]; 20 | if(p > i && !flag[p-i]) a[i] = p - i; 21 | else a[i] = p + i; 22 | flag[a[i]] = 1; 23 | } 24 | while(scanf("%d", &n)==1 && n!=-1) printf("%d\n", a[n]); 25 | return 0; 26 | } 27 | -------------------------------------------------------------------------------- /submited/LENGFACT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LENGFACT 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | double x, ans, pi = acos(-1.0); 13 | int t; 14 | scanf("%d", &t); 15 | while(t--) { 16 | scanf("%lf", &x); 17 | // striling's approximation 18 | if(x<3.0) ans = 1.0; 19 | else ans = floor((x*log(x)-x+(log(2.0*pi*x))/2.0)/log(10.0))+1.0; 20 | printf("%.0lf\n", ans + 1e-12); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /submited/OFFSIDE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: OFFSIDE 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int a, d, A[11], D[11], i; 14 | while(scanf("%d %d", &a, &d)==2 && a + d) 15 | { 16 | for(i=0; i 8 | 9 | #define i64 long long 10 | #define FS "%lld" 11 | 12 | int main() 13 | { 14 | int t, n, i; 15 | i64 s, a; 16 | scanf("%d",&t); 17 | while(t--) 18 | { 19 | scanf("%d",&n); 20 | s = 0; 21 | for(i=0;i= n) s %= (i64)n; 26 | } 27 | if(s == 0) printf("YES\n"); 28 | else printf("NO\n"); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/FIBFUNCH.cpp: -------------------------------------------------------------------------------- 1 | #include 2 | #include 3 | #define C(d,s) memcpy(d,s,32) 4 | typedef long long i64;i64 f[2][2]={{1,1},{1,0}},u[2][2]={{1,0},{0,1}},x[2][2],y[2][2],r[2][2];int t,p,q,i,j,k,n,m;void M(i64 a[][2],i64 b[][2]){for(i=0;i<2;i++)for(j=0;j<2;j++)for(y[i][j]=k=0;k<2;k++)y[i][j]=(y[i][j]+a[i][k]*b[k][j])%m;C(a,y);}void E(){C(x,f);C(r,u);while(n){if(n&1)M(r,x);M(x,x);n/=2;}}int main(){scanf("%d",&t);while(t--){scanf("%d%d%d%d",&p,&q,&n,&m);E();printf("%lld\n",((q*r[0][0]+p*r[0][1]-q)%m+m)%m);}return 0;} 5 | -------------------------------------------------------------------------------- /submited/SCPC11B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SCPC11B 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int n, i, a[2048]; 13 | while(scanf("%d", &n)==1 && n) { 14 | for(i = 0; i < n; i++) scanf("%d", a + i); 15 | sort(a, a + n); 16 | for(i = 1; i < n; i++) { 17 | if(a[i] - a[i-1] > 200) break; 18 | } 19 | if(i < n || (1422 - a[i-1])*2 > 200) puts("IMPOSSIBLE"); 20 | else puts("POSSIBLE"); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /submited/AE1B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AE1B 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | #define MAX 1111 12 | 13 | int main() 14 | { 15 | int a[MAX], n, s, t, i, r, d, c; 16 | scanf("%d%d%d", &n, &s, &t); 17 | for(i=0; i=0; i--) 22 | { 23 | d += a[i]; 24 | c++; 25 | if(d >= r) break; 26 | } 27 | printf("%d\n", c); 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /submited/CYLINDER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CYLINDER 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() 13 | { 14 | double w, h, r, res1, res2, pi = acos(-1.0), eps = 1e-9; 15 | while(scanf("%lf %lf",&w,&h)==2 && (w + h)>0.0) 16 | { 17 | r = min(w/2.0, h/(2.0*pi+2.0)); 18 | res1 = pi*r*r*w; 19 | r = w / (2.0*pi); 20 | res2 = pi*r*r*(h-2.0*r); 21 | printf("%.3f\n", max(res1, res2) + eps); 22 | } 23 | return 0; 24 | } 25 | 26 | -------------------------------------------------------------------------------- /submited/ITRIX_B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ITRIX_B 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int d, t, i; 13 | char buff[32], *s = "2357"; 14 | long long int n; 15 | scanf("%d", &t); 16 | while(t--) { 17 | scanf("%lld", &n); 18 | i = 0; 19 | while(n) { 20 | d = n & 3; n >>= 2; 21 | if(!d) d = 4, n--; 22 | buff[i++] = s[d-1]; 23 | } 24 | buff[i] = 0; 25 | reverse(buff, buff+i); 26 | puts(buff); 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /submited/DANGER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DANGER 4 | ALGO: math, josephus 5 | */ 6 | 7 | #include 8 | 9 | int f(int n) 10 | { 11 | if((n & (n-1)) == 0) return 1; 12 | if((n & 1) == 0) return (f(n>>1)<<1)-1; 13 | return (f((n-1)>>1)<<1)+1; 14 | } 15 | 16 | int main() 17 | { 18 | int n, t[7] = {1,10,100,1000,10000,100000,1000000}; 19 | char str[10]; 20 | while(scanf("%s", str)==1) 21 | { 22 | n = ((str[0]-'0')*10 + str[1]-'0')*t[str[3]-'0']; 23 | if(!n) break; 24 | printf("%d\n", f(n)); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /submited/TEAM2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TEAM2 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | #define sol(a,b,c,d) max(max(a,c)+max(b,d),max(a,b)+max(c,d)) 12 | 13 | int main() { 14 | int a, b, c, d, r1, r2, r3, cs = 1; 15 | while(scanf("%d %d %d %d", &a, &b, &c, &d) == 4) { 16 | r1 = sol(a, b, c, d); 17 | r2 = sol(a, c, b, d); 18 | r3 = sol(a, d, b, c); 19 | r1 = max(r1, r2); 20 | r1 = max(r1, r3); 21 | printf("Case %d: %d\n", cs++, r1); 22 | } 23 | return 0; 24 | } -------------------------------------------------------------------------------- /submited/GLJIVE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GLJIVE 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int a[10], i, k, diff, res, tot; 13 | for(i = 0; i < 10; i++) scanf("%d", &a[i]); 14 | for(i = 1; i < 10; i++) a[i] += a[i-1]; 15 | diff = 100 - a[0], res = a[0]; 16 | for(i = 1; i < 10; i++) { 17 | k = abs(100 - a[i]); 18 | if(k < diff || (k==diff && a[i] > res)) { 19 | diff = k; 20 | res = a[i]; 21 | } 22 | } 23 | printf("%d\n", res); 24 | return 0; 25 | } -------------------------------------------------------------------------------- /submited/TRICENTR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TRICENTR 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | int t; 13 | double a, b, c, da, db, dc, s, r, m; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%lf%lf%lf%lf", &a, &da, &db, &dc); 18 | s = 3.0*a*da/2.0; 19 | b = 2.0*s/3.0/db; 20 | c = 2.0*s/3.0/dc; 21 | r = a*b*c/4.0/s; 22 | m = 4.0*(r*r-(a*a+b*b+c*c)/9.0); 23 | m = (m<0.0) ? 0.0 : m; 24 | printf("%.3lf %.3lf\n", s, sqrt(m)); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /submited/ANARC09B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC09B 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define i64 long long 11 | #define FS "%lld\n" 12 | 13 | i64 gcd( i64 a, i64 b ) { 14 | if(b) return gcd( b, a % b ); 15 | return a; 16 | } 17 | 18 | i64 lcm( i64 a, i64 b ) { 19 | return a / gcd( a, b ) * b; 20 | } 21 | 22 | int main() { 23 | int a, b; 24 | while(scanf("%d%d", &a, &b)==2 && a + b) { 25 | i64 lcmv = lcm(a, b); 26 | printf(FS, ( lcmv / a ) * ( lcmv / b ) ); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /submited/GCD2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GCD2 4 | ALGO: math, gcd 5 | */ 6 | 7 | #include 8 | 9 | int gcd(int a, int b) 10 | { 11 | while(b) b^=a^=b^=a%=b; 12 | return a; 13 | } 14 | 15 | int main() 16 | { 17 | int t, i; 18 | int n1, n2; 19 | char num[300]; 20 | for(scanf("%d",&t);t;t--) 21 | { 22 | scanf("%d%s",&n1,num); 23 | if(!n1) 24 | { 25 | printf("%s\n",num); 26 | continue; 27 | } 28 | for(i=n2=0;num[i];i++) 29 | n2 = (n2*10+num[i]-'0')%n1; 30 | printf("%d\n",gcd(n1,n2)); 31 | } 32 | return 0; 33 | } 34 | 35 | -------------------------------------------------------------------------------- /submited/NY10A.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NY10A 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int test, cs, cnt[8], i, p; 12 | char toss[64]; 13 | scanf("%d", &test); 14 | while(test--) { 15 | scanf("%d %s", &cs, toss); 16 | for(i = 0; i < 8; i++) cnt[i] = 0; 17 | for(p = i = 0; i < 40; i++) { 18 | p = (p << 1) | (toss[i]=='H'); 19 | if(i > 1) cnt[p&7]++; 20 | } 21 | printf("%d", cs); 22 | for(i = 0; i < 8; i++) printf(" %d", cnt[i]); 23 | printf("\n"); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /submited/CANDY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CANDY 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int a[10001], n, i, avr, sum, total; 12 | while(scanf("%d", &n) == 1 && n > 0) 13 | { 14 | for(i=sum=0; i < n; i++) 15 | { 16 | scanf("%d", &a[i]); 17 | sum += a[i]; 18 | } 19 | if(sum % n == 0) 20 | { 21 | avr = sum / n; 22 | for(i=total=0; i < n; i++) 23 | if(a[i] < avr) 24 | total += avr - a[i]; 25 | printf("%d\n", total); 26 | } 27 | else printf("-1\n"); 28 | } 29 | return 0; 30 | } 31 | 32 | -------------------------------------------------------------------------------- /submited/HACKRNDM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HACKRNDM 4 | ALGO: binary search 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | map< int, int > M; 12 | map< int, int > :: iterator it, p; 13 | 14 | int main() { 15 | int n, k, ans = 0, i, v; 16 | scanf("%d %d", &n, &k); 17 | for(i = 0; i < n; i++) { 18 | scanf("%d", &v); 19 | M[v]++; 20 | } 21 | for(it = M.begin(); it != M.end(); it++) { 22 | p = M.find(it->first + k); 23 | if(p != M.end()) ans += p->second; 24 | } 25 | printf("%d\n", ans); 26 | return 0; 27 | } -------------------------------------------------------------------------------- /submited/HANGOVER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HANGOVER 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() 11 | { 12 | double len, val[300] = {0.0}; 13 | int i, n; 14 | for(i=2; val[i-2] <= 5.20; i++) 15 | { 16 | val[i-1] = val[i-2] + 1.0 / (double)i; 17 | } 18 | n = i-2; 19 | while(scanf("%lf", &len)==1 && len > 0.00) 20 | { 21 | for(i=1; i<=n; i++) 22 | { 23 | if(val[i]>=len) 24 | { 25 | printf("%d card(s)\n", i); 26 | break; 27 | } 28 | } 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/NY10E.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NY10E 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | long long dp[65][10]; 11 | 12 | int main() { 13 | int test, cs, n, i, j, k; 14 | for(i = 0; i < 10; i++) dp[0][i] = 1; 15 | for(i = 1; i < 65; i++) { 16 | for(j = 0; j < 10; j++) { 17 | for(k = 0; k <= j; k++) { 18 | dp[i][j] += dp[i-1][k]; 19 | } 20 | } 21 | } 22 | scanf("%d", &test); 23 | while(test--) { 24 | scanf("%d %d", &cs, &n); 25 | printf("%d %lld\n", cs, dp[n][9]); 26 | } 27 | return 0; 28 | } -------------------------------------------------------------------------------- /submited/MBINGO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MBINGO 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | int a[92], n, r, i, j; 14 | char f[92]; 15 | while(scanf("%d%d", &n, &r)==2 && n) { 16 | memset(f, 0, sizeof f); 17 | for(i = 0; i < r; i++) scanf("%d", &a[i]); 18 | for(i = 0; i < r; i++) 19 | for(j = 0; j < r; j++) 20 | f[abs(a[i]-a[j])] = 1; 21 | for(i = 0; i <= n && f[i]; i++); 22 | if(i==n+1) puts("Y"); 23 | else puts("N"); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /submited/PARKET1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PARKET1 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | double R, C, r, b; 13 | scanf("%lf %lf", &r, &b); 14 | R = ((r+4.0) + sqrt((r+4.0)*(r+4.0) - 16.0*(b+r))) / 4.0; 15 | C = (b+r) / R; 16 | if(R > C) printf("%.0lf %.0lf\n", R, C); 17 | else printf("%.0lf %.0lf\n", C, R); 18 | return 0; 19 | } 20 | 21 | /* 22 | R + C = (r + 4) / 2 23 | RC = b + r 24 | 25 | C = (b + r) / R 26 | R + (b + r) / R = (r + 4) / 2 27 | 2R^2 - R(r+4) + 2(b+r) = 0 28 | */ -------------------------------------------------------------------------------- /submited/AMR10G.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AMR10G 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int t, n, k, i, diff, mindiff; 13 | int a[20000]; 14 | scanf("%d", &t); 15 | while(t--) { 16 | scanf("%d%d", &n, &k); 17 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 18 | sort(a, a + n); 19 | mindiff = a[k-1] - a[0]; 20 | for(i = 0; i + k <= n; i++) { 21 | diff = a[i+k-1] - a[i]; 22 | mindiff = min(diff, mindiff); 23 | } 24 | printf("%d\n", mindiff); 25 | } 26 | return 0; 27 | } -------------------------------------------------------------------------------- /submited/BYECAKES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BYECAKES 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int a, b, c, d, aa, bb, cc, dd, at, bt, ct, dt, mx; 11 | while(scanf("%d%d%d%d%d%d%d%d",&a, &b, &c, &d, &aa, &bb, &cc, &dd)==8 && a>=0) { 12 | at = (a + aa - 1) / aa; 13 | bt = (b + bb - 1) / bb; 14 | ct = (c + cc - 1) / cc; 15 | dt = (d + dd - 1) / dd; 16 | mx = at; 17 | mx = mx>bt? mx:bt; 18 | mx = mx>ct? mx:ct; 19 | mx = mx>dt? mx:dt; 20 | printf("%d %d %d %d\n", aa*mx-a, bb*mx-b, cc*mx-c, dd*mx-d); 21 | } 22 | return 0; 23 | } 24 | -------------------------------------------------------------------------------- /submited/PERMUT1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PERMUT1 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int cnt[16][128]; 11 | 12 | void calc() { 13 | int i, j, k; 14 | cnt[1][0] = 1; 15 | for(i=1; i<12; i++) { 16 | for(j=0; cnt[i][j]; j++) { 17 | for(k=j; k<=i+j; k++) { 18 | cnt[i+1][k] += cnt[i][j]; 19 | } 20 | } 21 | } 22 | } 23 | 24 | int main() { 25 | int t, n, k; 26 | calc(); 27 | for(scanf("%d", &t); t; t--) { 28 | scanf("%d%d", &n, &k); 29 | printf("%d\n", cnt[n][k]); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/ARMY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ARMY 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() 11 | { 12 | int t, ng, nm, maxg, maxm, g, m; 13 | scanf("%d", &t); 14 | while(t--) 15 | { 16 | scanf("%d %d", &ng, &nm); 17 | maxg = maxm = -1; 18 | while(ng--) 19 | { 20 | scanf("%d", &g); 21 | if(g > maxg) maxg = g; 22 | } 23 | while(nm--) 24 | { 25 | scanf("%d", &m); 26 | if(m > maxm) maxm = m; 27 | } 28 | if(maxg >= maxm) printf("Godzilla\n"); 29 | else printf("MechaGodzilla\n"); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/BAISED.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BAISED 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int a[100001]; 14 | 15 | int main() 16 | { 17 | string name; 18 | int n, i, t; 19 | long long tot; 20 | ios::sync_with_stdio(false); 21 | cin >> t; 22 | while(t--) 23 | { 24 | cin >> n; 25 | for(i=0; i> name >> a[i]; 26 | sort(a, a+n); 27 | tot = 0; 28 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int t; 14 | double u, v, w, U, V, W, u1, v1, w1, volsq, vol; 15 | scanf("%d", &t); 16 | while(t--) 17 | { 18 | scanf("%lf%lf%lf%lf%lf%lf", &u,&v,&w,&W,&V,&U); 19 | u1 = v*v + w*w - U*U; 20 | v1 = w*w + u*u - V*V; 21 | w1 = u*u + v*v - W*W; 22 | volsq = 4.0*u*u*v*v*w*w - u*u*u1*u1 - v*v*v1*v1 - w*w*w1*w1 + u1*v1*w1; 23 | vol = sqrt(volsq) / 12.0; 24 | printf("%.4lf\n", vol); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /submited/UJ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: UJ 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #define i64 unsigned long long 9 | 10 | int main() 11 | { 12 | int d, i, j, k; 13 | i64 n, c, r[555], a, m=1000000000000000LL, t; 14 | while(scanf("%llu%d",&n,&d)==2&&(n||d)) 15 | { 16 | for(i=k=r[0]=1;i<=d;i++) 17 | { 18 | for(j=c=0;j=0;k--) printf("%015llu",r[k]); 28 | printf("\n"); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/SBANK.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SBANK 4 | ALGO: sorting, mapping 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | int n, i, t; 14 | char str[100]; 15 | for(scanf("%d", &t); t; t--) { 16 | map M; 17 | map :: iterator it; 18 | scanf("%d\n", &n); 19 | for(i=0;i1) printf("\n"); 25 | } 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /submited/MFLAR10.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MFLAR10 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | #include 12 | using namespace std; 13 | 14 | int main() { 15 | string s, t; 16 | char ch, fl; 17 | while(getline(cin, s)) { 18 | stringstream ss(s); 19 | ss >> t; 20 | if(t[0]=='*') break; 21 | fl = 1; 22 | ch = toupper(t[0]); 23 | while(ss >> t) { 24 | if(toupper(t[0]) != ch) { 25 | fl = 0; 26 | break; 27 | } 28 | } 29 | if(fl) puts("Y"); else puts("N"); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/STREETR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: STREETR 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int a[100001]; 12 | 13 | inline int gcd(int a, int b) { 14 | while(b) b ^= a ^= b ^= a %= b; 15 | return a; 16 | } 17 | 18 | int main() { 19 | int n, i, g, cnt; 20 | scanf("%d", &n); 21 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 22 | sort(a, a + n); 23 | g = a[1] - a[0], cnt = 0; 24 | for(i = 1; i < n; i++) g = gcd(g, a[i] - a[i-1]); 25 | for(i = 1; i < n; i++) cnt += (a[i] - a[i-1]) / g - 1; 26 | printf("%d\n", cnt); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /submited/TOANDFRO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TOANDFRO 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() 13 | { 14 | int len, r, c, i, j, k; 15 | char msg[250], res[250]; 16 | while(scanf("%d", &c)==1 && c) 17 | { 18 | scanf("%s", msg); 19 | len = strlen(msg); 20 | r = len / c; 21 | for(i=1; i*c 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int b, t, i, j, table[10][4]; 14 | long long p; 15 | char str[1001]; 16 | for(i=0; i<10; i++) 17 | for(j=table[i][0]=1; j<=4; j++) 18 | table[i][j&3] = (table[i][j-1]*i)%10; 19 | for(scanf("%d",&t); t; t--) 20 | { 21 | scanf("%s %lld", str, &p); 22 | if(!p) printf("1\n"); 23 | else 24 | { 25 | b = str[strlen(str)-1]-'0'; 26 | printf("%d\n", table[b][p&3]); 27 | } 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /submited/DYZIO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DYZIO 4 | ALGO: depth first search 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int MAX = 20002; 11 | char str[MAX]; 12 | int len, cnt, mxd, mxc, pos; 13 | 14 | void recur(int d) { 15 | if(str[pos]=='1') cnt++; 16 | if(d > mxd) { 17 | mxd = d; 18 | mxc = cnt; 19 | } 20 | if(str[pos++]=='1') { 21 | recur(d+1); 22 | recur(d+1); 23 | } 24 | } 25 | 26 | int main() { 27 | while(scanf("%d", &len)==1) { 28 | scanf("%s", str); 29 | pos = cnt = mxd = mxc = 0; 30 | recur(1); 31 | printf("%d\n", mxc); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /submited/PEBBMOV.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PEBBMOV 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() 13 | { 14 | int n, i; 15 | char a[1000]; 16 | while(scanf("%d", &n)==1) 17 | { 18 | set S; 19 | set :: iterator it; 20 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | char num1[8], num2[8]; 13 | int i, mx, mn; 14 | scanf("%s %s", num1, num2); 15 | for(i = 0; num1[i]; i++) if(num1[i]=='6') num1[i] = '5'; 16 | for(i = 0; num2[i]; i++) if(num2[i]=='6') num2[i] = '5'; 17 | mn = atoi(num1) + atoi(num2); 18 | for(i = 0; num1[i]; i++) if(num1[i]=='5') num1[i] = '6'; 19 | for(i = 0; num2[i]; i++) if(num2[i]=='5') num2[i] = '6'; 20 | mx = atoi(num1) + atoi(num2); 21 | printf("%d %d\n", mn, mx); 22 | return 0; 23 | } -------------------------------------------------------------------------------- /submited/BALIFE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BALIFE 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int a[9000], m, n, i, val, diff; 12 | while(scanf("%d", &n)==1 && n>0) { 13 | for(i = val = 0; i < n; i++) { 14 | scanf("%d", &a[i]); 15 | val += a[i]; 16 | } 17 | if(val % n) printf("-1\n"); 18 | else { 19 | val /= n; 20 | for(i = m = 0; i < n-1; i++) { 21 | diff = a[i] - val; 22 | a[i+1] += diff; 23 | if(diff < 0) diff = -diff; 24 | m = m > diff? m : diff; 25 | } 26 | printf("%d\n", m); 27 | } 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /submited/FASHION.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FASHION 4 | ALGO: sorting 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | #define MAX 1001 14 | 15 | int a[MAX], b[MAX]; 16 | 17 | int main() 18 | { 19 | int t, n, i, sum; 20 | scanf("%d", &t); 21 | while(t--) 22 | { 23 | scanf("%d", &n); 24 | sum = 0; 25 | for(i=0; i 8 | using namespace std; 9 | 10 | char grid[16][16]; 11 | int dp[16][16]; 12 | 13 | int main() { 14 | int n, i, j, d; 15 | scanf("%d", &n); 16 | for(i = 0; i < n; i++) scanf("%s", grid[i]); 17 | dp[n-1][n-1] = 1; 18 | for(i = n-1; i>=0; i--) { 19 | for(j = n-1; j >= 0; j--) { 20 | if(grid[i][j] != '0') { 21 | d = grid[i][j]-'0'; 22 | if(j + d < n) dp[i][j] += dp[i][j+d]; 23 | if(i + d < n) dp[i][j] += dp[i+d][j]; 24 | } 25 | } 26 | } 27 | printf("%d", dp[0][0]); 28 | return 0; 29 | } -------------------------------------------------------------------------------- /submited/WORKB.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: WORKB 4 | ALGO: greedy 5 | */ 6 | 7 | #include 8 | 9 | #define i64 long long 10 | #define MAX 100001 11 | #define min(a,b) ((a)<(b)?(a):(b)) 12 | 13 | int main() { 14 | int test, cs, n, i, tm[MAX]; 15 | i64 fair, sal, res; 16 | scanf("%d", &test); 17 | for(cs = 1; cs <= test; cs++) { 18 | scanf("%d %lld %lld", &n, &fair, &sal); 19 | for(i = 0; i < n; i++) scanf("%d", tm + i); 20 | res = fair + sal; 21 | for(i = n-2; i >= 0; i--) res += sal + min(fair<<1, sal*(tm[i+1]-tm[i]-1)); 22 | res += fair; 23 | printf("Case #%d: %lld\n", cs, res); 24 | } 25 | return 0; 26 | } -------------------------------------------------------------------------------- /submited/OPCPIZZA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: OPCPIZZA 4 | ALGO: binary search 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 100000; 12 | 13 | int a[MAX]; 14 | 15 | int main() { 16 | int n, m, i, j, ans, test; 17 | scanf("%d", &test); 18 | while(test--) { 19 | scanf("%d %d", &n, &m); 20 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 21 | sort(a, a + n); 22 | for(i = ans = 0; i < n; i++) { 23 | j = lower_bound(a, a + n, m - a[i]) - a; 24 | if(j != i && j != n && a[j] == m - a[i]) ans++; 25 | } 26 | printf("%d\n", ans >> 1); 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /submited/BRODOVI.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BRODOVI 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int a[5000]; 12 | bool f[5000]; 13 | 14 | int main() { 15 | int i, j, d, n, last, cnt = 0; 16 | scanf("%d", &n); 17 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 18 | for(i = 1; i < n; i++) { 19 | if(!f[i]) { 20 | f[i] = 1; 21 | d = a[i] - 1; 22 | last = a[i]; 23 | cnt++; 24 | for(j = i + 1; j < n; j++) { 25 | if(last + d == a[j]) { 26 | f[j] = 1; 27 | last = a[j]; 28 | } 29 | } 30 | } 31 | } 32 | printf("%d\n", cnt); 33 | return 0; 34 | } -------------------------------------------------------------------------------- /submited/MUSIC2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MUSIC2 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | //READ("in.txt"); 11 | //WRITE("out.txt"); 12 | char a[16], b[16]; 13 | int t=1,x; 14 | while(scanf("%s %s", a, b) == 2) { 15 | if(!a[1]) printf("Case %d: UNIQUE\n", t++); 16 | else { 17 | if(a[1]=='b') { 18 | a[1]='#'; 19 | x=-1; 20 | } 21 | else { 22 | a[1]='b'; 23 | x=1; 24 | } 25 | a[0]=(a[0]-'A'+7+x)%7+'A'; 26 | printf("Case %d: %s %s\n", t++, a, b); 27 | } 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /submited/QUALITY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: QUALITY 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int tp1, tp2, tp3, ap1, ap2, ap3, team = 1, total, cnt; 12 | while(scanf("%d %d %d %d %d %d", &tp1, &tp2, &tp3, &ap1, &ap2, &ap3)==6) 13 | { 14 | total = cnt = 0; 15 | if(tp1) 16 | { 17 | total += tp1 + 1200*(ap1-1); 18 | cnt++; 19 | } 20 | if(tp2) 21 | { 22 | total += tp2 + 1200*(ap2-1); 23 | cnt++; 24 | } 25 | if(tp3) 26 | { 27 | total += tp3 + 1200*(ap3-1); 28 | cnt++; 29 | } 30 | printf("team %d: %d, %d\n", team++, cnt, total); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /submited/REBOUND.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: REBOUND 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | typedef long long i64; 11 | 12 | int main() { 13 | int test, cs; 14 | i64 x, y, z, rt, a, b, d; 15 | scanf("%d", &test); 16 | for(cs = 1; cs <= test; cs++) { 17 | scanf("%lld %lld %lld", &x, &y, &z); 18 | d = x*x + y*y + 2*y*z; 19 | rt = (long long)sqrt((double)d); 20 | if(rt * rt != d) printf("Not this time.\n"); 21 | else { 22 | a = 2*x*z + 2*z*rt; 23 | b = 2*y + 4*z; 24 | if(a % b) printf("Not this time.\n"); 25 | else printf("%lld\n", a / b); 26 | } 27 | } 28 | return 0; 29 | } -------------------------------------------------------------------------------- /submited/ETF.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ETF 4 | ALGO: math, euler totient 5 | */ 6 | 7 | #include 8 | 9 | #define MAX 1000001 10 | 11 | unsigned phi[MAX]; 12 | 13 | void ETF() 14 | { 15 | unsigned i, j; 16 | phi[1] = 1; 17 | for(i=2; i 8 | #include 9 | using namespace std; 10 | 11 | typedef long long i64; 12 | 13 | const int MAX = 300001; 14 | 15 | i64 sum[MAX]; 16 | 17 | int main() { 18 | int n, m, a, i, j; 19 | i64 res; 20 | scanf("%d %d", &n, &m); 21 | for(i = 1; i <= n; i++) { 22 | scanf("%d", &a); 23 | sum[i] = sum[i-1] + a; 24 | } 25 | for(i = 1, res = 0; i <= n; i++) { 26 | j = (upper_bound(sum + i, sum + n + 1, sum[i-1] + m) - sum) - 1; 27 | if(j >= i) res = max(res, sum[j] - sum[i-1]); 28 | } 29 | printf("%lld\n", res); 30 | return 0; 31 | } -------------------------------------------------------------------------------- /submited/CF36D.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CF36D 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int t, n, m, k, z, e; 11 | scanf("%d",&t); 12 | while(t--) { 13 | scanf("%d%d%d", &k, &n, &m); 14 | e = n + m; 15 | if(k==1) { 16 | if((n&1) && (m&1)) puts("-"); 17 | else puts("+"); 18 | continue; 19 | } 20 | if(m < n) n = m; 21 | if(n % (k+1) == 0) { 22 | puts("+"); 23 | continue; 24 | } 25 | z = n / (k + 1); 26 | if(z & 1) { 27 | if(e & 1) puts("-"); 28 | else puts("+"); 29 | } 30 | else { 31 | if(e & 1) puts("+"); 32 | else puts("-"); 33 | } 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/ICODER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ICODER 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | const unsigned m = 65536; 10 | const unsigned M = 65535; 11 | 12 | unsigned gcd(unsigned a, unsigned b) 13 | { 14 | while(b) b ^= a ^= b ^= a %= b; 15 | return a; 16 | } 17 | 18 | int main() 19 | { 20 | register int n; 21 | unsigned g, v, a; 22 | char str[10]; 23 | while(scanf("%d", &n)==1 && n) 24 | { 25 | a = 1; 26 | while(n--) 27 | { 28 | scanf("%s%u", str, &v); 29 | if(str[0]=='M') 30 | { 31 | a *= v; 32 | if(a >= m) a &= M; 33 | } 34 | } 35 | g = gcd(a, m); 36 | printf("%u\n", m/g); 37 | } 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /submited/PRO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PRO 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | #define i64 long long 12 | #define FS "%lld\n" 13 | 14 | multiset< int > S; 15 | multiset< int > :: iterator fwd, rev; 16 | 17 | int main() { 18 | i64 sum = 0; 19 | int n, i, j, p,m; 20 | scanf("%d", &n); 21 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int t, x, n, a[1001], s, i, c; 14 | ios::sync_with_stdio(false); 15 | cin >> t; 16 | for(x = 1; x <= t; x++) 17 | { 18 | cin >> s >> n; 19 | for(i = 0; i < n; i++) 20 | cin >> a[i]; 21 | sort(a, a+n); 22 | for(i = n-1, c = 0; i >= 0; i--) 23 | { 24 | c += a[i]; 25 | if(c >= s) break; 26 | } 27 | cout << "Scenario #" << x << ":\n"; 28 | if(i==-1) cout << "impossible\n"; 29 | else cout << n-i << endl; 30 | cout << endl; 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /submited/NOCHANGE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NOCHANGE 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX 100001 11 | #define NC 5 12 | 13 | using namespace std; 14 | 15 | int main() 16 | { 17 | int i, m, k, j, c[NC]; 18 | bool f[MAX]; 19 | while(scanf("%d", &m)==1) 20 | { 21 | scanf("%d", &k); 22 | for(i=0; i=0; i--) 27 | for(j=c[i]; j<=m; j++) 28 | f[j] |= f[j-c[i]]; 29 | if(f[m]) printf("YES\n"); 30 | else printf("NO\n"); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /submited/GROCERY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GROCERY 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define AMP 1000000 11 | 12 | int main() 13 | { 14 | int i, j, k, l; 15 | for(i=1; i*i*i*i <= 244140625; i++) 16 | for(j=i; i*j*j*j <= AMP*2000; j++) 17 | for(k=j; i*j*k*k <= AMP*2000 && 2000-(i+j+k)>=k; k++) 18 | { 19 | if(i*j*k > AMP && (AMP*(i+j+k))%(i*j*k-AMP)==0) 20 | { 21 | l = (AMP*(i+j+k))/(i*j*k-AMP); 22 | if(l>=k && i+j+k+l<=2000) 23 | { 24 | printf("%.2lf %.2lf %.2lf %.2lf\n",i/100.0,j/100.0,k/100.0,l/100.0); 25 | } 26 | } 27 | } 28 | return 0; 29 | } 30 | /* END OF CODE */ 31 | -------------------------------------------------------------------------------- /submited/ANARC08E.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC08E 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | // logic (a+b)! / (a!*b!) 12 | 13 | int main() 14 | { 15 | int a, b, d, m, h, l, i, j; 16 | while(scanf("%d %d", &a, &b)==2 && a+b>=0) 17 | { 18 | d = max(a, b); 19 | m = min(a, b); 20 | h = l = 1; 21 | for(i=d+1, j=1; i<=a+b; i++, j++) 22 | { 23 | l *= i; 24 | h *= j; 25 | if(l % h == 0) 26 | { 27 | l /= h; 28 | h = 1; 29 | } 30 | } 31 | //printf("%d\n", l); 32 | if(l == a+b) printf("%d+%d=%d\n", a, b, a+b); 33 | else printf("%d+%d!=%d\n", a, b, a+b); 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/ANARC05I.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC05I 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | 9 | #define MAX 2002 10 | 11 | int grid[MAX][MAX]; 12 | char str[MAX/2]; 13 | 14 | int main() 15 | { 16 | int t = 1, i, cnt, x, y; 17 | while(scanf("%s", str)==1) 18 | { 19 | if(str[0]=='Q') break; 20 | for(i=cnt=0,x=y=1001,grid[x][y]=t; str[i]!='Q'; i++) 21 | { 22 | switch(str[i]) 23 | { 24 | case 'U': y += 1; break; 25 | case 'D': y -= 1; break; 26 | case 'R': x += 1; break; 27 | case 'L': x -= 1; break; 28 | } 29 | if(grid[x][y]==t) cnt++; 30 | else grid[x][y] = t; 31 | } 32 | printf("%d\n", cnt); 33 | t++; 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/GUESSTHE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GUESSTHE 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | inline int gcd(int a, int b) { 10 | while(b) b ^= a ^= b ^= a %= b; 11 | return a; 12 | } 13 | 14 | inline int lcm(int a, int b) { 15 | return a / gcd(a, b) * b; 16 | } 17 | 18 | int main() { 19 | char guess[32]; 20 | int ans, i, j, store[32]; 21 | while(fgets(guess, 32, stdin) && guess[0]!='*') { 22 | for(i = j = 0, ans = 1; ; i++) { 23 | if(guess[i]=='Y') ans = lcm(ans, i + 1); 24 | else if(guess[i]=='N') store[j++] = i + 1; 25 | else break; 26 | } 27 | for(i = 0; i < j && ans % store[i]; i++); 28 | printf("%d\n", ((i==j)? ans : -1)); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/PATHEADS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PATHEADS 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int MAX = 1000001; 11 | const int N = 100001; 12 | 13 | int cnt[MAX], res[MAX], a[N]; 14 | 15 | int main() { 16 | int i, j, n, mmax = -1; 17 | scanf("%d", &n); 18 | for(i = 0; i < n; i++) { 19 | scanf("%d", &a[i]); 20 | mmax = a[i] > mmax? a[i] : mmax; 21 | cnt[a[i]]++; 22 | } 23 | for(i = 0; i < n; i++) { 24 | if(a[i] > 1 && cnt[a[i]]) { 25 | for(j = a[i]; j <= mmax; j += a[i]) 26 | res[j] += cnt[a[i]]; 27 | cnt[a[i]] = 0; 28 | } 29 | } 30 | for(i = 0; i < n; i++) printf("%d\n", res[a[i]] - 1 + cnt[1]); 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/STPAR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: STPAR 4 | ALGO: stack 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int main() 14 | { 15 | int n, i, p, a[1001], flag; 16 | while(scanf("%d",&n)==1 && n) 17 | { 18 | stack < int > S; 19 | p = flag = 1; 20 | for(i=0; i S.top() && S.top()==p++) S.pop(); 25 | S.push(a[i]); 26 | } 27 | while(flag && !S.empty() && S.top()==p++) S.pop(); 28 | if(flag && S.empty()) printf("yes\n"); 29 | else printf("no\n"); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/PUCMM210.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PUCMM210 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | typedef long long i64; 10 | 11 | const int MOD = 1000000003; 12 | 13 | inline i64 mod(i64 a) { 14 | return a < MOD ? a : a % MOD; 15 | } 16 | 17 | int main() { 18 | int test, i; 19 | i64 sum, n, p[6], co[6] = {0, 4, 30, 50, 30, 6}, inv = 441666668; 20 | scanf("%d", &test); 21 | while(test--) { 22 | scanf("%lld", &n); 23 | for(i = 1, p[0] = 1; i <= 5; i++) p[i] = mod(n * p[i-1]); 24 | for(i = 1; i <= 5; i++) p[i] = mod(co[i] * p[i]); 25 | for(i = 1, sum = 0; i <= 5; i++) sum = mod(sum + p[i]); 26 | sum = mod(sum * inv); 27 | printf("%lld\n", sum); 28 | } 29 | return 0; 30 | } 31 | -------------------------------------------------------------------------------- /submited/GNY07B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GNY07B 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int t, x; 14 | double val; 15 | string unit; 16 | ios::sync_with_stdio(false); 17 | cout.setf(ios::fixed,ios::floatfield); 18 | cout.precision(4); 19 | cin >> t; 20 | for(x=1; x<=t; x++) 21 | { 22 | cin >> val >> unit; 23 | if(unit=="kg") cout << x << ' ' << val * 2.2046 << " lb\n"; 24 | else if(unit=="lb") cout << x << ' ' << val * 0.4536 << " kg\n"; 25 | else if(unit=="l") cout << x << ' ' << val * 0.2642 << " g\n"; 26 | else if(unit=="g") cout << x << ' ' << val * 3.7854 << " l\n"; 27 | } 28 | return 0; 29 | } 30 | -------------------------------------------------------------------------------- /submited/M3TILE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: M3TILE 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define N 15 11 | 12 | int main() 13 | { 14 | int array[2][N+1], n, i; 15 | 16 | array[0][0] = 0, array[1][0] = 1; 17 | array[0][1] = 1, array[1][1] = 2; 18 | 19 | for(i=2; i<=N; i++) 20 | { 21 | array[0][i] = array[0][i-1] + array[1][i-1]; 22 | array[1][i] = array[0][i-1] * 2 + array[1][i-1] * 3; 23 | } 24 | 25 | while((cin >> n) && (n >= 0)) 26 | { 27 | if(n % 2) cout << 0 << endl; 28 | else cout << array[0][n/2] + array[1][n/2] << endl; 29 | } 30 | 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/TREX.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TREX 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | int main() 10 | { 11 | int t, I, D, C, i, m, v; 12 | scanf("%d", &t); 13 | while(t--) 14 | { 15 | scanf("%d%d%d", &I, &D, &C); 16 | if(I <= D) printf("0\n"); 17 | else if(I <= C) printf("%d\n", I-D); 18 | else 19 | { 20 | for(i=1; i<=D; i++) 21 | { 22 | if(I <= C) 23 | { 24 | I = I - D + i - 1; 25 | break; 26 | } 27 | else 28 | { 29 | m = I % C; 30 | v = I / C; 31 | if(m < 2) I = v*C - 2*v + 1; 32 | else I = v*C - 2*v + m - 1; 33 | } 34 | } 35 | if(I < 0) I = 0; 36 | printf("%d\n", I); 37 | } 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /submited/MINMOVE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MINMOVE 4 | ALGO: minimum expression 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | inline int minimumExpression(char *s) { 11 | int i, j, k, n, len, p, q; 12 | len = n = strlen(s), n <<= 1, i = 0, j = 1, k = 0; 13 | while(i + k < n && j + k < n) { 14 | p = i+k >= len ? s[i+k-len] : s[i+k]; 15 | q = j+k >= len ? s[j+k-len] : s[j+k]; 16 | if(p == q) k++; 17 | else if(p > q) { i = i+k+1; if(i <= j) i = j+1; k = 0; } 18 | else if(p < q) { j = j+k+1; if(j <= i) j = i+1; k = 0; } 19 | } 20 | return i < j ? i : j; 21 | } 22 | 23 | int main() { 24 | char str[100001]; 25 | gets(str); 26 | printf("%d\n", minimumExpression(str)); 27 | return 0; 28 | } -------------------------------------------------------------------------------- /submited/XMEDIAN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: XMEDIAN 4 | ALGO: heap 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | multiset< int > S; 12 | multiset< int > :: iterator m1, m2; 13 | 14 | int main() { 15 | int n, i, f; 16 | scanf("%d", &n); 17 | scanf("%d", &f); 18 | S.insert(f); 19 | m1 = m2 = S.begin(); 20 | for(i = 2; i <= n; i++) { 21 | printf("%d\n", *m1); 22 | scanf("%d", &f); 23 | S.insert(f); 24 | if(f < *m1) { 25 | if(i & 1) m2--; 26 | else m1--; 27 | } 28 | else if(f >= *m1 && f < *m2) { 29 | m1++; 30 | m2--; 31 | } 32 | else { 33 | if(i & 1) m1++; 34 | else m2++; 35 | } 36 | } 37 | printf("%d\n", *m1); 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /submited/BEADS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BEADS 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | char str[10001]; 11 | 12 | int mycmp(int i, int j, int len) 13 | { 14 | int k; 15 | for(k=0; k 0) best = i; 37 | } 38 | printf("%d\n", best+1); 39 | } 40 | return 0; 41 | } 42 | 43 | -------------------------------------------------------------------------------- /submited/MZVRK.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MZVRK 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | typedef long long i64; 11 | 12 | const int MAX = 50; 13 | i64 sumd[MAX]; 14 | 15 | void calc() { 16 | sumd[0] = 1; 17 | for(int i=1; i n) 26 | break; 27 | i--; v = 1LL<0)?sumd[i-1]:0); 29 | n -= v; 30 | } 31 | return sum; 32 | } 33 | 34 | int main() { 35 | i64 a, b; 36 | cin >> a >> b; 37 | calc(); 38 | cout << getSum(b)-getSum(a-1) << endl; 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /submited/PLYGRND.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PLYGRND 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 24; 12 | const double EPS = 1e-10; 13 | 14 | bool valid(double *d, int n) { 15 | double sum = 0.0; 16 | for(int i = 0; i < n-1; i++) { 17 | sum += d[i]; 18 | if(!(sum < d[i+1])) return true; 19 | } 20 | return false; 21 | } 22 | 23 | int main() { 24 | int n, i; 25 | double d[24]; 26 | while(scanf("%d", &n)==1 && n) { 27 | for(i = 0; i < n; i++) scanf("%lf", &d[i]); 28 | if(n==1) printf("NO\n"); 29 | else { 30 | sort(d, d+n); 31 | if(valid(d, n)) printf("YES\n"); 32 | else printf("NO\n"); 33 | } 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/SAMER08G.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SAMER08G 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 1000; 12 | int car[MAX], pos[MAX], cng[MAX]; 13 | 14 | int main() { 15 | int n, i, sp; 16 | while(scanf("%d", &n)==1 && n) { 17 | for(i = 0; i < n; i++) scanf("%d%d", &car[i], &cng[i]); 18 | memset(pos, -1, sizeof pos); 19 | for(i = 0; i < n; i++) { 20 | sp = i + cng[i]; 21 | if(sp >= 0 && sp < n && pos[sp]==-1) pos[sp] = car[i]; 22 | else break; 23 | } 24 | if(i == n) { 25 | printf("%d", pos[0]); 26 | for(i = 1; i < n; i++) printf(" %d", pos[i]); 27 | printf("\n"); 28 | } 29 | else printf("-1\n"); 30 | } 31 | return 0; 32 | } -------------------------------------------------------------------------------- /submited/TDPRIMES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TDPRIMES 4 | ALGO: math, prime 5 | */ 6 | 7 | #include 8 | 9 | #define MAX 100000000 10 | #define LMT 10000 11 | 12 | int flag[MAX>>6]; 13 | 14 | #define ifc(x) (flag[x>>6]&(1<<((x>>1)&31))) 15 | #define isc(x) (flag[x>>6]|=(1<<((x>>1)&31))) 16 | 17 | void sieve() 18 | { 19 | int i, j, k; 20 | for(i=3; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | string line, s; 14 | int t, best, len, prlen, wrdcnt; 15 | ios::sync_with_stdio(false); 16 | cin >> t; 17 | getline(cin, s); 18 | while(t--) { 19 | getline(cin, line); 20 | best = prlen = wrdcnt = 0; 21 | stringstream ss(line); 22 | while(ss >> s) { 23 | len = s.size(); 24 | if(len==prlen) wrdcnt++; 25 | else { 26 | if(wrdcnt > best) best = wrdcnt; 27 | wrdcnt = 1; 28 | prlen = len; 29 | } 30 | } 31 | if(wrdcnt > best) best = wrdcnt; 32 | cout << best << endl; 33 | } 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /submited/CNEASY.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CNEASY 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 1001 13 | #define eps 1e-10 14 | 15 | int main() 16 | { 17 | int t, n, time, i; 18 | char s[50]; 19 | double a[MAX], minA, sec, temp; 20 | ios::sync_with_stdio(false); 21 | cin>>t; 22 | while(t--) 23 | { 24 | cin>>n; 25 | for(i=0;i> s >> a[i]; 27 | sort(a,a+n); 28 | minA=a[n-1]-a[0]; 29 | for(i=1;i 8 | #include 9 | 10 | int main() { 11 | char round[110]; 12 | double total, zero, ones, cnt; 13 | scanf("%s", round); 14 | total = zero = ones = cnt = 0; 15 | for(int i = 0; round[i]; i++, cnt++) { 16 | if(round[i]=='0') { 17 | total++; 18 | if(round[i+1]) { 19 | zero += round[i+1]=='0'; 20 | ones += round[i+1]=='1'; 21 | } 22 | else { 23 | zero += round[0]=='0'; 24 | ones += round[0]=='1'; 25 | } 26 | } 27 | } 28 | if(fabs(zero/(zero+ones) - total / cnt) < 1e-10) puts("EQUAL"); 29 | else if(zero/(zero+ones) > total / cnt) puts("SHOOT"); 30 | else puts("ROTATE"); 31 | return 0; 32 | } -------------------------------------------------------------------------------- /submited/MICEMAZE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MICEMAZE 4 | ALGO: warshall 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 111 13 | 14 | int main() 15 | { 16 | int n, u, v, w, i, j, k, t, e, m, grid[MAX][MAX]; 17 | scanf("%d%d%d%d", &n, &e, &t, &m); 18 | memset(grid, 32, sizeof(grid)); 19 | for(i=grid[e][e]=0; i 8 | using namespace std; 9 | 10 | int main() { 11 | int n; 12 | int last; 13 | int p, m, s; 14 | int t1, t2, a1, a2; 15 | scanf("%d", &n); 16 | last = 0; 17 | a1 = a2 = t1 = t2 = 0; 18 | while(n--) { 19 | scanf("%d %d:%d", &p, &m, &s); 20 | s += m * 60; 21 | if(a1 > a2) t1 += s - last; 22 | else if(a1 < a2) t2 += s - last; 23 | if(p == 1) a1++; 24 | else if(p==2) a2++; 25 | last = s; 26 | } 27 | s = 2880; 28 | if(a1 > a2) t1 += s - last; 29 | else if(a1 < a2) t2 += s - last; 30 | if(p == 1) a1++; 31 | else if(p==2) a2++; 32 | printf("%02d:%02d\n", t1/60, t1%60); 33 | printf("%02d:%02d\n", t2/60, t2%60); 34 | return 0; 35 | } -------------------------------------------------------------------------------- /submited/CHICAGO.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CHICAGO 4 | ALGO: warshall 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | double grid[101][101]; 13 | 14 | int main() 15 | { 16 | int n, e, u, v, i, j, k; 17 | double d; 18 | while(scanf("%d", &n)==1 && n) 19 | { 20 | scanf("%d", &e); 21 | memset(grid, 0, sizeof(grid)); 22 | for(i=0; i 8 | 9 | const int MAX = 128; 10 | const int INF = 0x7fffffff; 11 | 12 | int dp[MAX][MAX]; 13 | 14 | inline int min(int a, int b) { 15 | return (a < b ? a : b); 16 | } 17 | 18 | int main() { 19 | int m, n, i, j, ans; 20 | scanf("%d%d", &n, &m); 21 | for(i = 0; i < n; i++) { 22 | for(j = 1; j <= m; j++) 23 | scanf("%d", &dp[i][j]); 24 | dp[i][0] = dp[i][j] = INF; 25 | } 26 | for(i = 1; i < n; i++) 27 | for(j = 1; j <= m; j++) 28 | dp[i][j] += min(dp[i-1][j], min(dp[i-1][j-1], dp[i-1][j+1])); 29 | for(i = n-1, ans = INF, j = 1; j <= m; j++) 30 | ans = min(ans, dp[i][j]); 31 | printf("%d\n", ans); 32 | return 0; 33 | } -------------------------------------------------------------------------------- /submited/COINS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: COINS 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | #define i64 long long 14 | //map :: n with f(n) 15 | map < i64, i64 > M; 16 | map < i64, i64 > :: iterator it; 17 | 18 | i64 f(i64 n) 19 | { 20 | if(n==0) return 0; 21 | it = M.find(n); 22 | if(it==M.end()) 23 | { 24 | i64 v = max(n, f(n/2) + f(n/3) + f(n/4)); 25 | M.insert(it, pair < i64, i64 > (n, v)); 26 | return v; 27 | } 28 | else return (*it).second; 29 | } 30 | 31 | int main() 32 | { 33 | i64 n; 34 | while(scanf("%lld", &n)==1) 35 | { 36 | M.clear(); 37 | printf("%lld\n", f(n)); 38 | } 39 | return 0; 40 | } 41 | 42 | -------------------------------------------------------------------------------- /submited/DSUBSEQ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DSUBSEQ 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | const int MOD = 1000000007; 12 | 13 | int sum[26]; 14 | char s[100009], n[8]; 15 | 16 | int main() { 17 | int test, i, v, tmp, ret; 18 | test = atoi(fgets(n, 7, stdin)); 19 | while(test--) { 20 | fgets(s, 100008, stdin); 21 | memset(sum,0,sizeof(sum)); 22 | for(sum[s[0]-'A'] = i = 1, ret = 2; s[i] > 32; i++) { 23 | v = s[i]-'A'; 24 | tmp = ret - sum[v] + MOD; if(tmp >= MOD) tmp -= MOD; 25 | ret = ret + tmp; if(ret >= MOD) ret -= MOD; 26 | sum[v] = sum[v] + tmp; if(sum[v] >= MOD) sum[v] -= MOD; 27 | } 28 | printf("%d\n", ret); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/ENCONDIN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ENCONDIN 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int main() 11 | { 12 | char str[10001], ch; 13 | int i, j, k, len; 14 | while(gets(str)) 15 | { 16 | len = strlen(str); 17 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | int main() 12 | { 13 | int E, F, t, T, n, i, j, a[10001], v, w, INF=1<<28; 14 | scanf("%d", &t); 15 | while(t--) 16 | { 17 | scanf("%d%d", &E, &F); 18 | T = F-E; 19 | fill(&a[1], &a[1]+T, INF); 20 | a[0] = 0; 21 | scanf("%d", &n); 22 | for(i=0; i a[j]+v) 27 | a[j+w] = a[j] + v; 28 | } 29 | if(a[T]!=INF) printf("The minimum amount of money in the piggy-bank is %d.\n", a[T]); 30 | else printf("This is impossible.\n"); 31 | } 32 | return 0; 33 | } 34 | -------------------------------------------------------------------------------- /submited/NEG2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NEG2 4 | ALGO: base conversion 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define OFF ios::sync_with_stdio(false) 13 | 14 | string negabinary(int i) 15 | { 16 | 17 | int reminder; 18 | string digits; 19 | while(i != 0) 20 | { 21 | reminder = i % -2; 22 | i /= -2; 23 | if(reminder < 0) 24 | { 25 | i++; 26 | reminder += 2; 27 | } 28 | digits.push_back(reminder+'0'); 29 | } 30 | if(digits.size()==0) digits.push_back('0'); 31 | else reverse(digits.begin(),digits.end()); 32 | return digits; 33 | } 34 | 35 | int main() 36 | { 37 | OFF; 38 | int n; 39 | while(cin>>n) cout << negabinary(n) << endl; 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /submited/MBLAST.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MBLAST 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | #define min(a,b) ((a 8 | #include 9 | using namespace std; 10 | 11 | #define MAX 101 12 | 13 | int v[2000000]; 14 | 15 | int main() { 16 | int n, a[MAX]; 17 | int i, j, k, cnt, p, val; 18 | scanf("%d", &n); 19 | cnt = p = 0; 20 | for(i=0; i < n; i++) scanf("%d",&a[i]); 21 | for(i=0; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int len, cs, dp[32][256]; 13 | char num[32]; 14 | 15 | int solve(int pos, int prev) { 16 | if(pos == len) return 1; 17 | int &ret = dp[pos][prev]; 18 | if(ret != -1) return ret; 19 | ret = 0; 20 | for(int i = pos, sum = 0; i < len; i++) { 21 | sum += num[i]-'0'; 22 | if(sum >= prev) { 23 | ret += solve(i + 1, sum); 24 | } 25 | } 26 | return ret; 27 | } 28 | 29 | int main() { 30 | cs = 1; 31 | while(scanf("%s", num)==1 && isdigit(num[0])) { 32 | memset(dp, -1, sizeof dp); 33 | len = strlen(num); 34 | printf("%d. %d\n", cs++, solve(0, 0)); 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /submited/IOIPALIN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: IOIPALIN 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | const int MAX = 5005; 11 | char str[MAX]; 12 | short dp[2][MAX]; 13 | 14 | inline int _max(const int &a, const int &b) { 15 | return ((a > b) ? a : b); 16 | } 17 | 18 | int solve(const int &len) { 19 | int i, j, k; 20 | for(i=1; i<=len; i++) { 21 | for(j=1, k=len; k; k--, j++) { 22 | if(str[i-1] == str[k-1]) dp[(i&1)][j] = 1 + dp[!(i&1)][j-1]; 23 | else dp[(i&1)][j] = _max( dp[!(i&1)][j], dp[(i&1)][j-1] ); 24 | } 25 | } 26 | return len - dp[len&1][len]; 27 | } 28 | 29 | int main() { 30 | int len = atoi(fgets(str, MAX, stdin)); 31 | fgets(str, MAX, stdin); 32 | printf("%d\n", solve(len)); 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /submited/MCOINS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MCOINS 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | #define MAX 1000032 10 | #define ch(x) (f[x>>5]&(1<<(x&31))) 11 | #define st(x) (f[x>>5]|=(1<<(x&31))) 12 | 13 | unsigned f[MAX>>5]; 14 | char res[60]; 15 | int l, k, last, n; 16 | 17 | void calc() 18 | { 19 | int i; 20 | for(i=last+1; i<=n; i++) 21 | { 22 | if(ch(i)) continue; 23 | if(i+1 < MAX) st((i+1)); 24 | if(i+l < MAX) st((i+l)); 25 | if(i+k < MAX) st((i+k)); 26 | } 27 | last = n; 28 | } 29 | 30 | int main() 31 | { 32 | int i, m; 33 | last = -1; 34 | scanf("%d %d %d", &k, &l, &m); 35 | for(i=0; i last) calc(); 39 | res[i] = (ch(n))? 'A' : 'B'; 40 | } 41 | puts(res); 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /submited/TEMPTISL.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TEMPTISL 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | typedef long long i64; 12 | 13 | i64 dp[64][64]; 14 | int N, K, S, D; 15 | 16 | i64 solve(int n, int k) { 17 | if(k == K) return n == D; 18 | if(dp[n][k] != -1) return dp[n][k]; 19 | i64 &ret = dp[n][k]; ret = 0; 20 | int u = n + 1, v = n - 1; 21 | if(u == N) u = 0; 22 | if(v == -1) v = N-1; 23 | ret = solve(u, k+1) + solve(v, k+1); 24 | return ret; 25 | } 26 | 27 | int main() { 28 | while(scanf("%d %d", &N, &K) == 2) { 29 | if(N == -1 || K == -1) break; 30 | scanf("%d %d", &S, &D); 31 | S--, D--; 32 | memset(dp, -1, sizeof dp); 33 | printf("%lld\n", solve(S, 0)); 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /submited/TRIKA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TRIKA 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int n, m, r, c, a[32][32], i, j; 13 | //freopen("in.txt", "r", stdin); 14 | //freopen("out.txt", "w", stdout); 15 | scanf("%d%d%d%d", &n, &m, &r, &c); 16 | for(i = 1; i <= n; i++) 17 | for(j = 1; j <= m; j++) 18 | scanf("%d", &a[i][j]); 19 | for(i = r + 1; i <= n; i++) a[i][c] = a[i-1][c] - a[i][c]; 20 | for(j = c + 1; j <= m; j++) a[r][j] = a[r][j-1] - a[r][j]; 21 | for(i = r + 1; i <= n; i++) 22 | for(j = c + 1; j <= m; j++) 23 | a[i][j] = max(a[i-1][j], a[i][j-1]) - a[i][j]; 24 | if(a[n][m] >= 0) printf("Y %d\n", a[n][m]); 25 | else printf("N\n"); 26 | return 0; 27 | } 28 | -------------------------------------------------------------------------------- /submited/TRT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TRT 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAXN = 1 << 11; 12 | 13 | int N, *vec, *vp1, *vp2; 14 | 15 | inline int max (int a, int b) { 16 | return a > b ? a : b; 17 | } 18 | 19 | int main () { 20 | int i, j; 21 | scanf ("%d", &N); 22 | vec = new int[N]; 23 | vp1 = new int [N]; 24 | vp2 = new int [N]; 25 | for (i = 0; i < N; ++i) 26 | scanf ("%d", vec + i); 27 | for (i = 0; i < N; ++i) 28 | vp1[i] = vec[i] * N; 29 | for (i = 2; i <= N; ++i) { 30 | for (j = 0; j + i <= N; ++j) 31 | vp2[j] = max(vp1[j]+vec[j+i-1]*(N+1-i),vp1[j+1]+vec[j]*(N+1-i)); 32 | swap(vp1, vp2); 33 | } 34 | printf ("%d\n", vp1[0]); 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/TTREAT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TTREAT 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 10001; 12 | int a[MAX], b[MAX]; 13 | 14 | int main() { 15 | int n, m, dmp, st, en, dur, i; 16 | while(scanf("%d%d", &n, &m)==2) { 17 | if(!m && !n) break; 18 | for(i = 0; i < n; i++) { 19 | scanf("%d%d%d%d", &dmp, &dmp, &st, &dur); 20 | a[i] = st; 21 | b[i] = a[i] + dur; 22 | } 23 | while(m--) { 24 | scanf("%d%d", &st, &dur); 25 | en = st + dur; 26 | dmp = 0; 27 | for(i = 0; i < n; i++) 28 | if(b[i]-a[i] >= 1 && ((a[i]<=st && b[i]>=en) || (a[i]>=st && a[i]st && b[i]<=en))) 29 | dmp++; 30 | printf("%d\n", dmp); 31 | } 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /submited/ACODE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ACODE 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define mset(x,v) memset(x,v,sizeof(x)) 11 | #define MAX 5005 12 | #define i64 long long 13 | #define FS "%lld" 14 | 15 | i64 dp[MAX]; 16 | int len; 17 | char str[MAX]; 18 | 19 | i64 solve(int i) 20 | { 21 | if(i>=len) return 1; 22 | if(dp[i]) return dp[i]; 23 | if(str[i]=='0') return 0; 24 | i64 ret=0; 25 | ret += solve(i+1); 26 | if(i+1 8 | 9 | #define i64 long long 10 | 11 | i64 gcd(i64 a, i64 b) 12 | { 13 | if(!b) return a; 14 | return gcd(b, a%b); 15 | } 16 | 17 | void swap(i64 &a, i64 &b) 18 | { 19 | i64 t = a; 20 | a = b; 21 | b = t; 22 | } 23 | 24 | void f(i64 n, i64 &l, i64 &h) 25 | { 26 | if(n==1) l = h = 1; 27 | else 28 | { 29 | f(n>>1, l, h); 30 | (n&1)? l += h : h += l; 31 | } 32 | } 33 | 34 | int main() 35 | { 36 | i64 a, b, l1, l2, h1, h2, g; 37 | while(scanf("%lld%lld", &a, &b)==2 && (a+b)) 38 | { 39 | if(a > b) swap(a, b); 40 | f(a, l1, h1); 41 | f(b, l2, h2); 42 | g = gcd(l1, h2); 43 | printf("%lld/%lld\n", l1/g, h2/g); 44 | } 45 | return 0; 46 | } 47 | 48 | -------------------------------------------------------------------------------- /submited/SAMER08C.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SAMER08C 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | #define MAX 100001 12 | 13 | using namespace std; 14 | 15 | int dp[MAX], col[MAX], row[MAX], r, c; 16 | 17 | int solve(int i, int n, int *a) 18 | { 19 | if(i >= n) return 0; 20 | if(dp[i]) return dp[i]; 21 | return dp[i] = max(a[i]+solve(i+2,n,a), solve(i+1,n,a)); 22 | } 23 | 24 | int main() 25 | { 26 | int i, j; 27 | while(scanf("%d%d", &r, &c)==2 && (r || c)) 28 | { 29 | for(i=0; i 8 | #include 9 | 10 | #define MAX 1000009 11 | 12 | struct point { double x, y; }; 13 | using namespace std; 14 | 15 | point P[MAX]; 16 | 17 | int main() 18 | { 19 | int t, n, i; 20 | double d, a, cx, cy; 21 | scanf("%d", &t); 22 | while(t--) 23 | { 24 | scanf("%d", &n); 25 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | bool isNearPalin(char *str, int len) 12 | { 13 | int cnt = 0, i, j; 14 | for(i=0, j=len-1; i 8 | using namespace std; 9 | 10 | int g[202][202], p[202][202]; 11 | 12 | int main() 13 | { 14 | int t, n, i, j, k; 15 | scanf("%d", &t); 16 | while(t--) 17 | { 18 | scanf("%d", &n); 19 | for(i=0; i= g[i][k] + g[k][j]) 29 | { 30 | g[i][j] = g[i][k] + g[k][j]; 31 | p[i][j] = k; 32 | } 33 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | pair< int, int > task[100000]; 12 | 13 | inline bool comp(const pair< int, int > &a, const pair< int, int > &b) { 14 | return (a.second == b.second) ? a.first < b.first : a.second < b.second; 15 | } 16 | 17 | int main() { 18 | int test, i, n, last, cnt; 19 | scanf("%d", &test); 20 | while(test--) { 21 | scanf("%d", &n); 22 | for(i = 0; i < n; i++) scanf("%d %d", &task[i].first, &task[i].second); 23 | sort(task, task + n, comp); 24 | cnt = 0, last = -1; 25 | for(i = 0; i < n; i++) { 26 | if(task[i].first >= last) { 27 | cnt++; 28 | last = task[i].second; 29 | } 30 | } 31 | printf("%d\n", cnt); 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /submited/CHAIR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CHAIR 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int mod = 1000000003; 12 | int dp[2][1001][501]; 13 | int K, N; 14 | 15 | int solve(int f, int n, int k) { 16 | if(k == K) return 1; 17 | if(n > N) return 0; 18 | if(n == N && f) return 0; 19 | if(dp[f][n][k] != -1) return dp[f][n][k]; 20 | int &ret = dp[f][n][k]; 21 | if(n==1) ret = solve(1, n+2, k+1); 22 | else ret = solve(f, n+2, k+1); 23 | ret += solve(f, n+1, k); 24 | return ret = ret % mod; 25 | } 26 | 27 | int main() { 28 | int ret; 29 | scanf("%d %d", &N, &K); 30 | if(K > (N >> 1)) { 31 | printf("0\n"); 32 | return 0; 33 | } 34 | memset(dp, -1, sizeof dp); 35 | printf("%d\n", solve(0, 1, 0)); 36 | return 0; 37 | } -------------------------------------------------------------------------------- /submited/MARBLES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MARBLES 4 | ALGO: math, combinatorics 5 | */ 6 | 7 | #include 8 | 9 | #define i64 unsigned long long 10 | 11 | i64 gcd(i64 a, i64 b) 12 | { 13 | i64 k; 14 | while(b) 15 | { 16 | a %= b; 17 | k = a; 18 | a = b; 19 | b = k; 20 | } 21 | return a; 22 | } 23 | 24 | i64 nCr(i64 n, i64 r) 25 | { 26 | i64 i, j, g, k = (r > n-r)? r : n-r, m = n-k, hor = 1, lob = 1; 27 | for(i=k+1, j=m; i<=n && j>0; i++, j--) 28 | { 29 | hor *= j; 30 | lob *= i; 31 | g = gcd(lob, hor); 32 | lob /= g; 33 | hor /= g; 34 | } 35 | return lob; 36 | } 37 | 38 | int main() 39 | { 40 | int t; 41 | i64 n, r; 42 | scanf("%d", &t); 43 | while(t--) 44 | { 45 | scanf("%llu %llu", &n, &r); 46 | printf("%llu\n", nCr(n-1, r-1)); 47 | } 48 | return 0; 49 | } 50 | -------------------------------------------------------------------------------- /submited/PANCAKES.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PANCAKES 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int INF = 0x7fffffff; 11 | 12 | int main() { 13 | int n, r, recpid, total, curr, need, i, k; 14 | int have[64]; 15 | while(scanf("%d%d", &n, &r)==2 && n+r) { 16 | for(i = 0; i < n; i++) { 17 | scanf("%d", &have[i]); 18 | have[i] *= 10; 19 | } 20 | recpid = 1, total = 0; 21 | for(k = 1; k <= r; k++) { 22 | curr = INF; 23 | for(i = 0; i < n; i++) { 24 | scanf("%d", &need); 25 | if(need) curr = curr < (have[i]/need) ? curr : (have[i]/need); 26 | } 27 | if(curr == INF) continue; 28 | if(total < curr) { 29 | total = curr; 30 | recpid = k; 31 | } 32 | } 33 | printf("%d %d\n", recpid, total); 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/GCD3.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GCD3 4 | ALGO: math 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int main() 14 | { 15 | char num1[300], num2[300]; 16 | int k, t, len, i; 17 | long long pow2[17], temp; 18 | pow2[0] = 1; 19 | for(i=1; i<17; i++) 20 | pow2[i] = pow2[i-1] << 1; 21 | scanf("%d", &t); 22 | while(t--) 23 | { 24 | scanf("%s %s %d", num1, num2, &k); 25 | len = strlen(num1); 26 | if((num1[len-1]-'0')&1) printf("1\n"); 27 | else 28 | { 29 | i = (len0; i--) 32 | { 33 | if(!(temp&(pow2[i]-1))) 34 | { 35 | printf("%lld\n", pow2[i]); 36 | break; 37 | } 38 | } 39 | } 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/AIBOHP.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AIBOHP 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX 6116 11 | #define _max(x,y) ((x>y)?x:y) 12 | 13 | char str[MAX]; 14 | short dp[2][MAX]; 15 | int len; 16 | 17 | int solve() 18 | { 19 | int i, j, k; 20 | for(i=0;i<=len;i++) dp[0][i] = 0; 21 | dp[1][0] = 0; 22 | for(i=1; i<=len; i++) 23 | { 24 | for(j=1, k=len; k>0; k--, j++) 25 | { 26 | if(str[i-1] == str[k-1]) dp[(i&1)][j] = 1 + dp[!(i&1)][j-1]; 27 | else dp[(i&1)][j] = _max( dp[!(i&1)][j], dp[(i&1)][j-1] ); 28 | } 29 | } 30 | return len - dp[len&1][len]; 31 | } 32 | 33 | int main(int t) 34 | { 35 | for(scanf("%d", &t); t; t--) 36 | { 37 | scanf("%s", str); 38 | len = strlen(str); 39 | printf("%d\n", solve()); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/BYTESM2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BYTESM2 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | using namespace std; 11 | 12 | int a[111][111]; 13 | 14 | inline int _max(int a, int b, int c) 15 | { 16 | if(a >= b && a >= c) return a; 17 | if(b >= c) return b; 18 | return c; 19 | } 20 | 21 | int main() 22 | { 23 | int t, w, h, r, i, j; 24 | scanf("%d", &t); 25 | while(t--) 26 | { 27 | scanf("%d %d", &h, &w); 28 | for(i=1; i<=h; i++) 29 | { 30 | for(j=1; j<=w; j++) 31 | scanf("%d", &a[i][j]); 32 | a[i][j] = 0; 33 | for(j=1; j<=w; j++) 34 | a[i][j] += _max(a[i-1][j-1], a[i-1][j], a[i-1][j+1]); 35 | } 36 | r = a[h][1]; 37 | for(i=2; i<=w; i++) 38 | r = _max(r, a[h][i], 0); 39 | printf("%d\n", r); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/DEFKIN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DEFKIN 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 40004; 13 | int x[MAX], y[MAX]; 14 | 15 | int main() { 16 | int test, idx, n, i, xx, yy, difx, dify; 17 | scanf("%d", &test); 18 | while(test--) { 19 | idx = 2; 20 | x[0] = y[0] = 0; 21 | scanf("%d%d%d", &xx, &yy, &n); 22 | x[1] = xx + 1, y[1] = yy + 1; 23 | for(i = 0; i < n; i++) { 24 | scanf("%d%d", &x[idx], &y[idx]); 25 | idx++; 26 | } 27 | sort(x, x + idx); 28 | sort(y, y + idx); 29 | difx = dify = 0; 30 | for(i = 1; i < idx; i++) difx = max(difx, x[i] - x[i-1] - 1); 31 | for(i = 1; i < idx; i++) dify = max(dify, y[i] - y[i-1] - 1); 32 | printf("%d\n", difx * dify); 33 | } 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /submited/DEPOSIT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DEPOSIT 4 | ALGO: pre-calculation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int r, f, s, x, y, k, t, dep[20][2], tot[20][2]; 12 | dep[0][0] = dep[1][1] = tot[0][0] = 1; 13 | dep[0][1] = dep[1][0] = tot[0][1] = 0; 14 | for(r = 2; r < 20; r++) { 15 | dep[r][0] = dep[r-1][0] + dep[r-2][0]; 16 | dep[r][1] = dep[r-1][1] + dep[r-2][1]; 17 | } 18 | for(r = 1; r < 20; r++) { 19 | tot[r][0] = tot[r-1][0] + dep[r][0]; 20 | tot[r][1] = tot[r-1][1] + dep[r][1]; 21 | } 22 | while(scanf("%d", &r)==1 && r) { 23 | scanf("%d%d", &k, &t); 24 | f = tot[r-1][0]; 25 | s = tot[r-1][1]; 26 | for(x = 1; (t-f*x) % s; x++); 27 | y = (t-f*x) / s; 28 | printf("%d %d %d\n", x, y, k * (x*dep[r-1][0] + y*dep[r-1][1])); 29 | } 30 | return 0; 31 | } 32 | -------------------------------------------------------------------------------- /submited/EQUI.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EQUI 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | long long a[500], x, sum, p; 14 | set< long long > S; 15 | int i, n, r; 16 | while(scanf("%d", &n)==1 && n > 2) { 17 | S.clear(); 18 | for(i = r = 0, n--, sum = 0; i < n; i++) { 19 | scanf("%lld", a + i); 20 | sum += a[i]; 21 | S.insert(a[i]); 22 | } 23 | sort(a, a + n); 24 | x = a[(n >> 1) - 1]; 25 | p = x * (n + 1) - sum; 26 | if(S.find(p) == S.end() && p < x) r++; 27 | if(sum % n == 0) { 28 | p = sum / n; 29 | if(p > a[(n >> 1) - 1] && p < a[n >> 1]) r++; 30 | } 31 | x = a[n >> 1]; 32 | p = x * (n + 1) - sum; 33 | if(S.find(p) == S.end() && p > x) r++; 34 | printf("%d\n", r); 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /submited/JNEXT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: JNEXT 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 1000000; 12 | 13 | int a[MAX], cnt[10]; 14 | 15 | int main() { 16 | int test, i, j, k, n; 17 | scanf("%d", &test); 18 | while(test--) { 19 | scanf("%d", &n); 20 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 21 | memset(cnt, 0, sizeof(int) * 10); 22 | for(i = n - 1; i >= 0; i--) { 23 | cnt[a[i]]++; 24 | for(j = a[i]+1; j < 10; j++) if(cnt[j]) break; 25 | if(j < 10) { 26 | a[i] = j; cnt[j]--; 27 | for(j = 0, k = i+1; j < 10; j++) while(cnt[j]--) a[k++] = j; 28 | break; 29 | } 30 | } 31 | if(i >= 0) { 32 | for(i = 0; i < n; i++) printf("%d", a[i]); 33 | printf("\n"); 34 | } 35 | else printf("-1\n"); 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /submited/OSPROB1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: OSPROB1 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int dp[101], sum[101], n; 11 | 12 | int solve(int pos) { 13 | int i, j, ret, tmp; 14 | if(pos > n) return 0; 15 | if(dp[pos] != -1) return dp[pos]; 16 | for(ret = 0, i = pos; i <= n; i++) 17 | for(j = i; j <= n && sum[j]+sum[pos-1] < sum[i]<<1; j++) 18 | if(ret < (tmp = sum[j]-sum[i]+solve(j+1))) 19 | ret = tmp; 20 | return dp[pos] = ret; 21 | } 22 | 23 | int main() { 24 | int t, i, ret, job; 25 | scanf("%d", &t); 26 | while(t--) { 27 | scanf("%d", &n); 28 | for(i = 1; i <= n; i++) { 29 | scanf("%d", &job); 30 | sum[i] = sum[i-1] + job; 31 | } 32 | memset(dp, -1, sizeof dp); 33 | ret = solve(1); 34 | printf("%d %d\n", sum[n]-ret, ret); 35 | } 36 | return 0; 37 | } -------------------------------------------------------------------------------- /submited/ACPC10D.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ACPC10D 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | 9 | const int inf = 0x7f7f7f7f; 10 | int tri[100000][3]; 11 | 12 | inline int min(int a, int b) { 13 | return a < b ? a : b; 14 | } 15 | 16 | int main() { 17 | int n, i, j, a, b, c, d, cs = 1; 18 | while(scanf("%d", &n)==1 && n) { 19 | for(i = 0; i < n; i++) 20 | for(j = 0; j < 3; j++) 21 | scanf("%d", &tri[i][j]); 22 | tri[0][0] = inf; 23 | tri[0][2] += tri[0][1]; 24 | for(i = 1; i < n; i++) { 25 | for(j = 0; j < 3; j++) { 26 | a = (j==2)? inf : tri[i-1][j+1]; 27 | b = tri[i-1][j]; 28 | c = (j==0)? inf : tri[i-1][j-1]; 29 | d = (j==0)? inf : tri[i][j-1]; 30 | tri[i][j] += min(min(a, b), min(c, d)); 31 | } 32 | } 33 | printf("%d. %d\n", cs++, tri[n-1][1]); 34 | } 35 | return 0; 36 | } -------------------------------------------------------------------------------- /submited/GCJ2012C.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GCJ2012C 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | 9 | int main() { 10 | int test, cs, a, b, m, i, k, n, div, mod, cnt, ans; 11 | int pow10[] = {1, 10, 100, 1000, 10000, 100000, 1000000}; 12 | freopen("c.in", "r", stdin); 13 | freopen("c.out", "w", stdout); 14 | scanf("%d", &test); 15 | for(cs = 1; cs <= test; cs++) { 16 | scanf("%d %d", &a, &b); 17 | cnt = 0, k = a; 18 | while(k) k /= 10, cnt++; 19 | m = pow10[cnt - 1]; 20 | ans = 0; 21 | for(i = a; i <= b; i++) { 22 | k = n = i, cnt = 0; 23 | while(true) { 24 | div = n / 10, mod = n % 10; 25 | n = div + m * mod; 26 | if(n == k) break; 27 | if(mod > 0 && n >= a && n <= b) cnt++; 28 | } 29 | ans += cnt; 30 | } 31 | ans >>= 1; 32 | printf("Case #%d: %d\n", cs, ans); 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /submited/MAYA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MAYA 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | #include 9 | #include 10 | 11 | char maya[20][15] = { 12 | "S", ".", "..", "...", "....", 13 | "-", ". -", ".. -", "... -", ".... -", 14 | "- -", ". - -", ".. - -", "... - -", ".... - -", 15 | "- - -", ". - - -", ".. - - -", "... - - -", ".... - - -" 16 | }; 17 | 18 | int pwr[7] = {1, 20, 360, 7200, 144000, 2880000, 57600000}; 19 | 20 | int main() 21 | { 22 | int n, res, i, j; 23 | char temp[100]; 24 | while(scanf("%d", &n)==1 && n) 25 | { 26 | getchar(); 27 | res = 0; 28 | for(i=n-1; i>=0; i--) 29 | { 30 | gets(temp); 31 | for(j=0; j<20; j++) 32 | if(!strcmp(temp, maya[j])) 33 | break; 34 | if(j) res += pwr[i]*j; 35 | } 36 | printf("%d\n", res); 37 | } 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /submited/NFACTOR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NFACTOR 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int MAX = 1000001; 11 | const int LMT = 1000; 12 | int cnt[MAX]; 13 | int pre[MAX][11]; 14 | 15 | void sieve() { 16 | int i, j; 17 | cnt[2] = 1; 18 | for(i = 4; i < MAX; i+=2) cnt[i]++; 19 | for(i = 3; i < MAX; i+=2) { 20 | if(!cnt[i]) { 21 | cnt[i] = 1; 22 | for(j = i<<1; j < MAX; j+=i) cnt[j]++; 23 | } 24 | } 25 | for(i = 1; i < MAX; i++) { 26 | for(j = 0; j < 11; j++) { 27 | if(cnt[i]==j) pre[i][j] = pre[i-1][j] + 1; 28 | else pre[i][j] = pre[i-1][j]; 29 | } 30 | } 31 | } 32 | 33 | int main() { 34 | int t, a, b, n; 35 | sieve(); 36 | scanf("%d", &t); 37 | while(t--) { 38 | scanf("%d %d %d", &a, &b, &n); 39 | printf("%d\n", pre[b][n] - pre[a-1][n]); 40 | } 41 | return 0; 42 | } -------------------------------------------------------------------------------- /submited/TDKPRIME.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TDKPRIME 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | const int MAX = 86044176; 11 | const int LMT = 9267; 12 | const int LEN = 5000000; 13 | 14 | int flag[MAX>>6], primes[LEN+5]; 15 | 16 | #define ifc(x) (flag[x>>6]&(1<<((x>>1)&31))) 17 | #define isc(x) (flag[x>>6]|=(1<<((x>>1)&31))) 18 | 19 | void sieve() { 20 | register int i, j, k; 21 | for(i = 3; i < LMT; i+=2) 22 | if(!ifc(i)) 23 | for(j=i*i, k=i<<1; j < MAX; j+=k) 24 | isc(j); 25 | primes[1] = 2; 26 | for(i=3, j=2; i < MAX && j <= LEN; i+=2) 27 | if(!ifc(i)) 28 | primes[j++] = i; 29 | } 30 | 31 | int main() { 32 | char buff[11]; 33 | register int q = atoi(fgets(buff, 11, stdin)); 34 | sieve(); 35 | while(q--) printf("%d\n", primes[atoi(fgets(buff, 11, stdin))]); 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /submited/EQ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EQ 4 | ALGO: heap 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | typedef long long i64; 13 | 14 | int main() { 15 | int test, n, p, i, k; 16 | i64 tot, top; 17 | scanf("%d", &test); 18 | while(test--) { 19 | scanf("%d %d", &n, &p); 20 | priority_queue< i64, vector< i64 >, greater< i64 > > Q; 21 | tot = 0; 22 | while(p--) { 23 | scanf("%d %d", &i, &k); 24 | if(Q.size() < n) { 25 | Q.push(i + 5 + k); 26 | tot += 5 + k; 27 | } 28 | else { 29 | top = Q.top(); Q.pop(); 30 | if(top > i) { 31 | tot += top - i + 5 + k; 32 | Q.push(top + 5 + k); 33 | } 34 | else { 35 | tot += 5 + k; 36 | Q.push(i + 5 + k); 37 | } 38 | } 39 | } 40 | printf("%lld\n", tot); 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /submited/HALLOW.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HALLOW 4 | ALGO: pegionhole principle 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | int arr[120000], flag[120000], u[120000]; 11 | 12 | int main() { 13 | int n, m, i, x, total, g, mn, a, b; 14 | while(scanf("%d %d",&n,&m) == 2 && (n | m)) { 15 | memset(arr, 0, sizeof arr); 16 | memset(flag, 0, sizeof flag); 17 | mn = 120000, total = 0, arr[0] = 0, flag[0] = 1; 18 | for(i = 1; i < m + 1; i++) scanf("%d", &u[i]); 19 | for(i = 1; i < m + 1; i++) { 20 | g = i, x = u[i], total += x, total %= n; 21 | if(flag[total]) { 22 | if(i - arr[total] < mn) { 23 | mn = arr[total]; 24 | a = arr[total] + 1, b = i; 25 | } 26 | } 27 | arr[total] = i, flag[total] = 1; 28 | } 29 | for(i = a; i < b; i++) printf("%d ", i); printf("%d\n", i); 30 | } 31 | return 0; 32 | } 33 | -------------------------------------------------------------------------------- /submited/MMMGAME.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MMMGAME 4 | ALGO: nim game 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main(){ 11 | int t, n, i, a[50]; 12 | scanf("%d", &t); 13 | while(t--){ 14 | scanf("%d", &n); 15 | int cnt = 0; 16 | for(i=0; i 8 | #include 9 | #include 10 | #include 11 | #include 12 | #include 13 | #include 14 | #include 15 | #include 16 | #include 17 | #include 18 | #include 19 | #include 20 | #include 21 | #include 22 | #include 23 | #include 24 | #include 25 | #include 26 | #include 27 | #include 28 | #include 29 | #include 30 | #include 31 | #include 32 | #include 33 | #include 34 | #include 35 | using namespace std; 36 | 37 | int main() { 38 | int n; 39 | while(scanf("%d", &n)==1 && n != 42) printf("%d\n", n); 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /submited/MMAXPER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MMAXPER 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 1001 13 | 14 | struct Rect { 15 | int x, y; 16 | } R[MAX]; 17 | 18 | int dp[MAX][2]; 19 | 20 | int solve(int i, int s, int n) 21 | { 22 | if(i+1==n) return dp[i][s] = (s ? R[i].y : R[i].x); 23 | if(dp[i][s]) return dp[i][s]; 24 | int temp1 = abs((s ? R[i].x : R[i].y) - R[i+1].x) + solve(i+1, 1, n); 25 | int temp2 = abs((s ? R[i].x : R[i].y) - R[i+1].y) + solve(i+1, 0, n); 26 | return dp[i][s] = (s ? R[i].y : R[i].x) + max(temp1, temp2); 27 | } 28 | 29 | int main() 30 | { 31 | int i, n; 32 | scanf("%d", &n); 33 | for(i=0; i 8 | using namespace std; 9 | 10 | #define M 1000000009 11 | 12 | int modxp(int p) { 13 | long long r = 1, b = 2; 14 | while(p>0) { 15 | if(p&1) r = (r*b)%M; 16 | p >>= 1; 17 | b = (b*b)%M; 18 | } 19 | return (int)r; 20 | } 21 | 22 | int main() { 23 | int t, n, i, z, m, a, s; 24 | long long p; 25 | scanf("%d", &t); 26 | while(t--) { 27 | scanf("%d", &n); 28 | m = -2147483648, p = z = 0, s = 1; 29 | for(i = 0; i < n; i++) { 30 | scanf("%d", &a); 31 | if(a > m) { 32 | m = a; 33 | s = 1; 34 | } 35 | else if(a == m) s++; 36 | if(!a) z++; 37 | if(a > 0) p += a; 38 | } 39 | if(m < 0) printf("%d %d\n", m, s); 40 | else if(m==0) printf("0 %d\n", modxp(z)-1); 41 | else printf("%lld %d\n", p, modxp(z)); 42 | } 43 | return 0; 44 | } -------------------------------------------------------------------------------- /submited/GNY07H.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GNY07H 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int dp[4][52][16]; 12 | 13 | int solve(int r, int c, int mask) { 14 | if(r > 4) return 0; 15 | if(c < 0) return mask==0; 16 | if(r == 4) return solve(0, c - 1, mask); 17 | int &ret = dp[r][c][mask]; 18 | if(ret != -1) return ret; 19 | ret = 0; 20 | if(mask & (1 << r)) ret += solve(r + 1, c, mask & ~(1 << r)); 21 | else { 22 | ret += solve(r + 1, c, mask | (1 << r)); 23 | if(!(mask & (1 << (r + 1)))) ret += solve(r + 2, c, mask); 24 | } 25 | return ret; 26 | } 27 | 28 | int main() { 29 | int test, cs = 1, n; 30 | memset(dp, -1, sizeof dp); 31 | scanf("%d", &test); 32 | while(test--) { 33 | scanf("%d", &n); 34 | printf("%d %d\n", cs++, solve(0, n-1, 0)); 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /submited/PQUEUE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PQUEUE 4 | ALGO: heap 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define pii pair< int, int > 13 | 14 | int main() 15 | { 16 | int test, n, myjob, prio, i, t; 17 | ios::sync_with_stdio(false); 18 | cin >> test; 19 | while(test--) 20 | { 21 | queue< pii > Q; 22 | priority_queue< int > PQ; 23 | cin >> n >> myjob; 24 | for(i=0; i> prio; 27 | PQ.push(prio); 28 | Q.push(pii(i,prio)); 29 | } 30 | t = 0; 31 | while(!Q.empty()) 32 | { 33 | i = Q.front().first; 34 | prio = Q.front().second; 35 | Q.pop(); 36 | if(prio != PQ.top()) Q.push(pii(i,prio)); 37 | else 38 | { 39 | t++; 40 | PQ.pop(); 41 | if(i==myjob) break; 42 | } 43 | } 44 | cout << t << endl; 45 | } 46 | return 0; 47 | } -------------------------------------------------------------------------------- /submited/SUMFOUR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SUMFOUR 4 | ALGO: sorting, subset partition 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 4000 13 | #define pb(v) push_back(v) 14 | #define ub(X,v) upper_bound(X.begin(),X.end(),v) 15 | #define lb(X,v) lower_bound(X.begin(),X.end(),v) 16 | 17 | int a[MAX][4]; 18 | 19 | int main() { 20 | int n, i, j, val, cnt = 0; 21 | vector V; 22 | scanf("%d", &n); 23 | for(i=0; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int getint(char *s) 13 | { 14 | int i, n = 0; 15 | for(i=0;s[i];i++) 16 | { 17 | if(!isdigit(s[i])) return -1; 18 | n = n*10+s[i]-'0'; 19 | } 20 | return n; 21 | } 22 | 23 | int main() 24 | { 25 | char str[100], *p; 26 | int t, i, a[3]; 27 | scanf("%d", &t); 28 | for(gets(str); t; t--) 29 | { 30 | gets(str); 31 | gets(str); 32 | i = 0; 33 | p = strtok(str," +="); 34 | while(p) 35 | { 36 | a[i++] = getint(p); 37 | p = strtok(0," +="); 38 | } 39 | if(a[0]==-1) printf("%d + %d = %d\n",a[2]-a[1], a[1], a[2]); 40 | else if(a[1]==-1) printf("%d + %d = %d\n",a[0], a[2]-a[0], a[2]); 41 | else printf("%d + %d = %d\n",a[0], a[1], a[0]+a[1]); 42 | } 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /submited/MOBILE2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MOBILE2 4 | ALGO: greedy 5 | */ 6 | 7 | #include 8 | 9 | const int MAXN = 200000; 10 | 11 | int L[MAXN], R[MAXN], lo[MAXN], hi[MAXN]; 12 | 13 | int main() { 14 | int test, cs, i, n, sol, l, r; 15 | scanf("%d", &test); 16 | for(cs = 1; cs <= test; cs++) { 17 | scanf("%d", &n); 18 | for(i = 1; i <= n; i++) { 19 | scanf("%d %d", &L[i], &R[i]); 20 | if(L[i] == -1) L[i] = 0; 21 | if(R[i] == -1) R[i] = 0; 22 | } 23 | for(i = n, sol = 0; i >= 1; i--) { 24 | l = L[i], r = R[i]; 25 | if(hi[r] > lo[l]) sol++; 26 | lo[i] = (lo[l] < lo[r] ? lo[l] : lo[r]) + 1; 27 | hi[i] = (hi[l] > hi[r] ? hi[l] : hi[r]) + 1; 28 | if((lo[l] != hi[l] && lo[r] != hi[r]) || (hi[i] - lo[i] > 1)) { 29 | printf("-1\n"); 30 | break; 31 | } 32 | } 33 | if(i < 1) printf("%d\n", sol); 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/PARTIT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PARTIT 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int dp[222][222][11]; 11 | 12 | int solve(int start, int total, int len) { 13 | int ret = 0, i; 14 | if(dp[start][total][len]) return dp[start][total][len]-1; 15 | if(len==1) ret = (start==total); 16 | else 17 | for(i=start; i*(len-1)+start<=total; i++) 18 | ret += solve(i, total-start, len-1); 19 | dp[start][total][len] = ret+1; 20 | return ret; 21 | } 22 | 23 | int main() { 24 | int t, m, n, k, d, v; 25 | scanf("%d", &t); 26 | while(t--) { 27 | scanf("%d%d%d", &m, &n, &k); 28 | d = 1; 29 | do { 30 | while((v=solve(d, m, n)) 1) printf(" "); 36 | m -= d; 37 | } while(--n); 38 | printf("\n"); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /submited/SCAVHUNT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SCAVHUNT 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | #define OFF ios::sync_with_stdio(false) 14 | #define CLR(x) x.clear() 15 | 16 | int main() 17 | { 18 | OFF; 19 | map< string, string > M; 20 | set< string > S; 21 | string s1, s2; 22 | int n, i, t, x; 23 | cin >> t; 24 | for(x=1; x<=t; x++) 25 | { 26 | CLR(M); 27 | CLR(S); 28 | cin >> n; 29 | for(i=0; i> s1 >> s2; 32 | M[s1] = s2; 33 | S.erase(s2); 34 | S.insert(s1); 35 | } 36 | s1 = *S.begin(); 37 | cout << "Scenario #" << x <<":\n"; 38 | cout << s1 << endl; 39 | for(i=0; i 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 7600459; 12 | short frac[MAX][2]; 13 | 14 | int main() { 15 | int m, t, idx, i; 16 | short n, x, y, x1, y1, x2, y2; 17 | scanf("%d", &t); 18 | while(t--) { 19 | scanf("%hd%d", &n, &m); 20 | idx = 0; 21 | x = 1, y = n; 22 | x1 = 0, x2 = 1, y1 = 1, y2 = n; 23 | frac[idx][0] = 0, frac[idx][1] = 1, idx++; 24 | frac[idx][0] = 1, frac[idx][1] = n, idx++; 25 | while(y!=1) { 26 | x = ((y1+n)/y2)*x2-x1; 27 | y = ((y1+n)/y2)*y2-y1; 28 | frac[idx][0] = x, frac[idx][1] = y; 29 | idx++; 30 | x1 = x2, x2 = x, y1 = y2, y2 = y; 31 | } 32 | for(i=0; i 8 | #include 9 | #include 10 | 11 | char str[1024]; 12 | int cnt[26]; 13 | 14 | int main() { 15 | int test, i, mx, mc, d; 16 | test = atoi(fgets(str, 1023, stdin)); 17 | while(test--) { 18 | fgets(str, 1023, stdin); 19 | memset(cnt, 0, sizeof cnt); 20 | for(i = 0; str[i]>31; i++) if(str[i]>32) cnt[str[i]-'A']++; 21 | for(mx = 0, mc = 1, i = 1; i < 26; i++) { 22 | if(cnt[i] > cnt[mx]) mx = i, mc = 1; 23 | else if(cnt[i] == cnt[mx]) mc++; 24 | } 25 | if(mc > 1) fputs("NOT POSSIBLE\n", stdout); 26 | else { 27 | if(mx >= 4) d = mx - 4; 28 | else d = 26 - 4 + mx; 29 | printf("%d ", d); 30 | for(i = 0; str[i]>31; i++) if(str[i]>32) str[i] = 'A' + (str[i]-'A' - d + 26) % 26; 31 | fputs(str, stdout); 32 | } 33 | } 34 | return 0; 35 | } 36 | -------------------------------------------------------------------------------- /submited/HEXBOARD.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HEXBOARD 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int main() { 11 | int n, i, j, sp; 12 | while(scanf("%d", &n)==1 && n > 0) { 13 | for(i = 0; i < n; i++) { 14 | sp = 2 * n - 1; 15 | for(j = sp - i * 2; j > 0; j--) putchar(' '); 16 | putchar('_'); 17 | for(j = 0; j < i; j++) printf("/ \\_"); 18 | putchar('\n'); 19 | } 20 | for(i = 0; i < n; i++) { 21 | printf("/ \\"); 22 | for(j = 1; j < n; j++) printf("_/ \\"); 23 | putchar('\n'); 24 | printf("\\_/"); 25 | for(j = 1; j < n; j++) printf(" \\_/"); 26 | putchar('\n'); 27 | } 28 | for(i = 1; i < n; i++) { 29 | sp = 2 * i; 30 | for(j = 0; j < sp; j++) putchar(' '); 31 | printf("\\_/"); 32 | for(j = 1; j < n - i; j++) printf(" \\_/"); 33 | putchar('\n'); 34 | } 35 | puts("***"); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /submited/CLOCKS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | PROG: CLOCKS 4 | ALGO: pre-calculation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int type[9]; 11 | int moves[9][9] = { 12 | {3,3,3,3,3,2,3,2,0}, 13 | {2,3,2,3,2,3,1,0,1}, 14 | {3,3,3,2,3,3,0,2,3}, 15 | {2,3,1,3,2,0,2,3,1}, 16 | {2,3,2,3,1,3,2,3,2}, 17 | {1,3,2,0,2,3,1,3,2}, 18 | {3,2,0,3,3,2,3,3,3}, 19 | {1,0,1,3,2,3,2,3,2}, 20 | {0,2,3,2,3,3,3,3,3} 21 | }; 22 | 23 | int main() { 24 | int i, j, k; 25 | for(i=0;i<9;i++) { 26 | scanf("%d",&k); 27 | switch(k) { 28 | case 0: k =12; break; 29 | case 1: k = 3; break; 30 | case 2: k = 6; break; 31 | case 3: k = 9; break; 32 | } 33 | for(j=0;j<9;j++) type[j] = (type[j]+(4-k/3)*moves[i][j])%4; 34 | } 35 | for(i=0;i<9;i++) { 36 | for(j=0;j 8 | #include 9 | 10 | const int MAX = 20002; 11 | const int MOD = 1000; 12 | 13 | int parent[MAX], d[MAX]; 14 | 15 | void find(int u) { 16 | if(u!=parent[u]) { 17 | find(parent[u]); 18 | d[u] = (d[u] + d[parent[u]]); 19 | parent[u] = parent[parent[u]]; 20 | } 21 | } 22 | 23 | int main() { 24 | int t, i, j, n; 25 | char cm[2]; 26 | scanf("%d", &t); 27 | while(t--) { 28 | scanf("%d", &n); 29 | for(i=1; i<=n; i++) parent[i] = i, d[i] = 0; 30 | while(scanf("%s", cm)==1 && cm[0]!='O') { 31 | switch(cm[0]) { 32 | case 'E': 33 | scanf("%d", &i); 34 | find(i); 35 | printf("%d\n", d[i]); 36 | break; 37 | case 'I': 38 | scanf("%d%d", &i, &j); 39 | parent[i] = parent[j]; 40 | d[i] = d[j] + abs(i-j) % MOD; 41 | } 42 | } 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /submited/HEPNUM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HEPNUM 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 100032; 12 | char num1[MAX], num2[MAX]; 13 | 14 | int main() { 15 | int i, j, len1, len2, d; 16 | char a, b; 17 | while(scanf("%s%s", num1, num2)==2) { 18 | if(num1[0]=='*' && num2[0]=='*') break; 19 | len1 = strlen(num1); 20 | len2 = strlen(num2); 21 | for(i = j = d = 0; !d && i < len1 && j < len2; ) { 22 | if(len2 - j > len1 - i) { 23 | a = '0'; 24 | b = num2[j]; 25 | j++; 26 | } 27 | else if(len2 - j < len1 - i) { 28 | a = num1[i]; 29 | b = '0'; 30 | i++; 31 | } 32 | else { 33 | a = num1[i]; 34 | b = num2[j]; 35 | i++; j++; 36 | } 37 | d = a - b; 38 | } 39 | if(d < 0) printf("<\n"); 40 | else if(d > 0) printf(">\n"); 41 | else printf("=\n"); 42 | } 43 | return 0; 44 | } 45 | -------------------------------------------------------------------------------- /submited/LAGRANGE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LAGRANGE 4 | ALGO: pre-calculation 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 1 << 15; 13 | char buff[4096], *p; 14 | int sqr[192], ways[1<<15]; 15 | 16 | int main() { 17 | int n, i, j, k, l; 18 | for(i = 0; i < 192; i++) sqr[i] = i*i; 19 | for(i = 0; 4*sqr[i] < MAX; i++) 20 | for(j = i; sqr[i]+3*sqr[j] < MAX; j++) 21 | for(k = j; sqr[i]+sqr[j]+2*sqr[k] < MAX; k++) 22 | for(l = k; sqr[i]+sqr[j]+sqr[k]+sqr[l] < MAX; l++) 23 | ways[sqr[i]+sqr[j]+sqr[k]+sqr[l]]++; 24 | /*fread_unlocked(buff, 4096, 1, stdin); 25 | p = strtok(buff,"\n"); 26 | while(p && (n=atoi(p))) { 27 | printf("%d\n", ways[n]); 28 | p = strtok(0, "\n"); 29 | }*/ 30 | while(fgets(buff, 8, stdin)) { 31 | n = atoi(buff); 32 | if(!n) break; 33 | printf("%d\n", ways[n]); 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/PERIOD.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PERIOD 4 | ALGO: knuth morris patt 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | char *buff; 11 | int *over; 12 | 13 | int main() { 14 | int t, x = 1, len, i, j; 15 | scanf("%d", &t); 16 | while(t--) { 17 | scanf("%d", &len); 18 | buff = new char[len+10]; 19 | over = new int[len+10]; 20 | scanf("%s", buff); 21 | printf("Test case #%d\n", x++); 22 | over[0] = over[1] = 0; 23 | for(i=2; i<=len; i++) { 24 | j = over[i-1]; 25 | while(true) { 26 | if(buff[j]==buff[i-1]) { 27 | over[i] = j + 1; 28 | break; 29 | } 30 | else if(!j) { 31 | over[i] = j; 32 | break; 33 | } 34 | else j = over[j]; 35 | } 36 | if(over[i] && i%(i-over[i])==0) { 37 | printf("%d %d\n", i, i/(i-over[i])); 38 | } 39 | } 40 | printf("\n"); 41 | delete[] buff; 42 | delete[] over; 43 | } 44 | return 0; 45 | } 46 | -------------------------------------------------------------------------------- /submited/GNY07E.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GNY07E 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | int test, n, i, j, k, a[32], res[128], idx, cs = 1; 14 | scanf("%d", &test); 15 | while(test--) { 16 | scanf("%d", &n); 17 | for(i = 1; i <= n; i++) scanf("%d", &a[i]); 18 | for(idx = 0, i = n; i; i--) { 19 | if(a[i] == i) continue; 20 | for(k = i; k; k--) if(abs(a[k]) == i) break; 21 | reverse(a+1, a+k+1); 22 | for(j = k; j; j--) a[j] *= -1; 23 | res[idx++] = k; 24 | if(i > 1) { 25 | if(a[1] != -i) { 26 | res[idx++] = 1; 27 | a[1] *= -1; 28 | } 29 | reverse(a+1, a+i+1); 30 | for(j = i; j; j--) a[j] *= -1; 31 | res[idx++] = i; 32 | } 33 | } 34 | printf("%d %d", cs++, idx); 35 | for(i = 0; i < idx; i++) printf(" %d", res[i]); 36 | printf("\n"); 37 | } 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /submited/BHAT007.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BHAT007 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | char num1[40], num2[40]; 11 | int nb1[110], nb2[110], len1, len2; 12 | 13 | void add(int base, int *nb, int &k) { 14 | int i, j, a, b, carry; 15 | for(i = len1-1, j = len2-1, carry = k = 0; i >= 0 || j >= 0 || carry; i--, j--, k++) { 16 | a = i >= 0 ? num1[i]-'0' : 0; 17 | b = j >= 0 ? num2[j]-'0' : 0; 18 | nb[k] = (a + b + carry) % base; 19 | carry = (a + b + carry) / base; 20 | } 21 | while(k--) if(nb[k]) break; 22 | } 23 | 24 | int main() { 25 | int test, b1, b2, l1, l2; 26 | scanf("%d", &test); 27 | while(test--) { 28 | scanf("%s %s %d %d", num1, num2, &b1, &b2); 29 | len1 = strlen(num1); 30 | len2 = strlen(num2); 31 | add(b1, nb1, l1); 32 | add(b2, nb2, l2); 33 | if(l1 == l2 && !memcmp(nb1, nb2, l1*sizeof(int))) puts("yes"); 34 | else puts("no"); 35 | } 36 | return 0; 37 | } 38 | -------------------------------------------------------------------------------- /submited/POUR1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: POUR1 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int gcd(int a, int b) { 12 | while(b) b ^= a ^= b ^= a %= b; 13 | return a; 14 | } 15 | 16 | int cnt(int A, int B, int C) { 17 | int move = 1, a = A, b = 0, pour; 18 | while(a != C && b != C) { 19 | pour = min(a, B-b); 20 | b += pour; 21 | a -= pour; 22 | move++; 23 | if(a == C || b == C) break; 24 | if(b==B) b = 0, move++; 25 | else if(a==0) a = A, move++; 26 | } 27 | return move; 28 | } 29 | 30 | int main() { 31 | int a, b, c, t; 32 | scanf("%d", &t); 33 | while(t--) { 34 | scanf("%d%d%d", &a, &b, &c); 35 | if(c > a && c > b) printf("-1\n"); 36 | else if(!c) printf("0\n"); 37 | else if(c == a || c == b) printf("1\n"); 38 | else if(c % gcd(a, b)) printf("-1\n"); 39 | else printf("%d\n", min(cnt(a, b, c), cnt(b, a, c))); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/IMPUNITS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: IMPUNITS 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | typedef long long i64; 11 | 12 | inline i64 gcd(i64 a, i64 b) { 13 | while(b) b ^= a ^= b ^= a %= b; 14 | return a; 15 | } 16 | 17 | inline i64 lcm(i64 a, i64 b) { 18 | return a / gcd(a, b) * b; 19 | } 20 | 21 | int main() { 22 | int n, i, a, b; 23 | i64 mul, back, fwrd, metric[10][2]; 24 | while(scanf("%d", &n)==1 && n > 1) { 25 | for(--n, i = 0; i < n; i++) { 26 | scanf("%d%d", &a, &b); 27 | metric[i][0] = a, metric[i][1] = b; 28 | } 29 | for(fwrd = back = i = 1; i < n; i++) { 30 | mul = lcm(metric[i-1][1], metric[i][0]); 31 | back *= mul / metric[i-1][1]; 32 | fwrd *= mul / metric[i][0]; 33 | } 34 | metric[0][0]*=back, metric[n-1][1]*=fwrd; 35 | mul = gcd(metric[0][0], metric[n-1][1]); 36 | printf("%lld %lld\n", metric[0][0] / mul, metric[n-1][1] / mul); 37 | } 38 | return 0; 39 | } 40 | -------------------------------------------------------------------------------- /submited/WPC4F.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: WPC4F 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | int dp[20][3], cost[20][3]; 14 | 15 | int solve(int pos, int state, int n) { 16 | if(pos == n) return 0; 17 | if(dp[pos][state] != -1) return dp[pos][state]; 18 | int &ret = dp[pos][state]; ret = INT_MAX; 19 | for(int i = 0; i < 3; i++) { 20 | if(i != state) { 21 | ret = min(ret, solve(pos + 1, i, n) + cost[pos][state]); 22 | } 23 | } 24 | return ret; 25 | } 26 | 27 | int main() { 28 | int test, n, i, ans; 29 | scanf("%d", &test); 30 | while(test--) { 31 | scanf("%d", &n); 32 | for(i = 0; i < n; i++) scanf("%d %d %d", &cost[i][0], &cost[i][1], &cost[i][2]); 33 | memset(dp, -1, sizeof dp); 34 | for(ans = INT_MAX, i = 0; i < 3; i++) ans = min(ans, solve(0, i, n)); 35 | printf("%d\n", ans); 36 | } 37 | return 0; 38 | } -------------------------------------------------------------------------------- /submited/SCUBADIV.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SCUBADIV 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 1024; 13 | const int INF = 0x3f3f3f3f; 14 | 15 | int N, O, n, test, cs; 16 | int nitro[MAX], oxi[MAX], w[MAX]; 17 | int dp[MAX][22][80], fl[MAX][22][80]; 18 | 19 | int solve(int i, int co, int cn) { 20 | if(co >= O && cn >= N) return 0; if(i == n) return INF; 21 | if(co >= O) co = O; if(cn >= N) cn = N; 22 | if(fl[i][co][cn] == cs) return dp[i][co][cn]; fl[i][co][cn] = cs; 23 | return dp[i][co][cn] = min(solve(i+1, co, cn), solve(i+1, co + oxi[i], cn + nitro[i]) + w[i]); 24 | } 25 | 26 | int main() { 27 | scanf("%d", &test); 28 | for(cs = 1; cs <= test; cs++) { 29 | scanf("%d %d %d", &O, &N, &n); 30 | for(int i = 0; i < n; i++) scanf("%d %d %d", &oxi[i], &nitro[i], &w[i]); 31 | printf("%d\n", solve(0, 0, 0)); 32 | } 33 | return 0; 34 | } -------------------------------------------------------------------------------- /submited/ARITH2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ARITH2 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | 9 | #define i64 long long 10 | 11 | bool isnum(char *str, i64 &n, char &op) 12 | { 13 | n = 0; 14 | if(str[0]<'0' || str[0]>'9') 15 | { 16 | op = str[0]; 17 | return false; 18 | } 19 | for(int i=0; str[i]; i++) 20 | n = n*10 + (str[i]-'0'); 21 | return true; 22 | } 23 | 24 | int main() 25 | { 26 | char token[30], op; 27 | int n; 28 | i64 ans, num; 29 | scanf("%d", &n); 30 | while(n--) 31 | { 32 | ans = 0; 33 | op = '+'; 34 | while(scanf("%s", token)==1) 35 | { 36 | if(isnum(token, num, op)) 37 | { 38 | switch(op) 39 | { 40 | case '+': ans += num; break; 41 | case '-': ans -= num; break; 42 | case '*': ans *= num; break; 43 | case '/': ans /= num; break; 44 | } 45 | } 46 | else if(op == '=') 47 | { 48 | printf("%lld\n", ans); 49 | break; 50 | } 51 | } 52 | } 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /submited/DIV2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DIV2 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int MAX = 1000032; 11 | 12 | int flag[MAX>>5], cand[MAX>>5]; 13 | 14 | #define sb(c, i) (c[i>>5]|=(1<<(i&31))) 15 | #define cb(c, i) (c[i>>5]&(1<<(i&31))) 16 | 17 | int main() { 18 | int cnt, i, j, k; 19 | //freopen("out.txt", "w", stdout); 20 | for(i = 3; i <= 1000; i += 2) 21 | if(!cb(flag, i)) 22 | for(j = i*i, k = i<<1; j <= 1000000; j += k) 23 | sb(flag, j); 24 | sb(cand, 2); 25 | for(i = 3; i <= 1000000; i += 2) 26 | if(!cb(flag, i)) 27 | sb(cand, i); 28 | for(i = 4; i <= 1000000; i += 4) sb(cand, i); 29 | for(i = 3; i <= 1000; i += 2) 30 | for(k = i*i, j = k; j <= 1000000; j += k) 31 | sb(cand, j); 32 | for(i = 2, cnt = 1; i <= 1000000; i++) { 33 | if(!cb(cand, i)) { 34 | if(cnt==108) { 35 | printf("%d\n", i); 36 | cnt = 0; 37 | } 38 | cnt++; 39 | } 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/CHASE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CHASE 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | struct data { int x, y; }; 12 | const int MAX = 2222; 13 | data d[MAX]; 14 | double slope[MAX]; 15 | 16 | int main() { 17 | int t, n, i, j, result, ng, ns, more; 18 | scanf("%d", &t); 19 | while(t--) { 20 | scanf("%d", &n); 21 | result = 0; 22 | for(i = 0; i < n; i++) scanf("%d%d", &d[i].x, &d[i].y); 23 | for(i = 0; i < n; i++) { 24 | ng = ns = more = 0; 25 | for(j = i + 1; j < n; j++) { 26 | if(d[j].y == d[i].y) ng++; 27 | else slope[ns++] = (double)(d[i].x-d[j].x)/(double)(d[i].y-d[j].y); 28 | } 29 | result = max(ng, result); 30 | sort(slope, slope + ns); 31 | for(j = 0; j < ns; j++) { 32 | if(!j || slope[j-1] < slope[j]) more = 1; 33 | else more++; 34 | result = max(result, more); 35 | } 36 | } 37 | printf("%d\n", result); 38 | } 39 | return 0; 40 | } 41 | -------------------------------------------------------------------------------- /submited/BRCKTS2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BRCKTS2 4 | ALGO: recursion 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define i64 long long 13 | #define MAX 350000 14 | 15 | char str[MAX+1]; 16 | 17 | void recur(i64 &h, i64 &w, int d, int &pos, i64 &area) 18 | { 19 | i64 maxH = 0, newW, newH; 20 | pos++; 21 | while(str[pos]=='(') 22 | { 23 | newH = newW = 1; 24 | recur(newH, newW, d+1, pos, area); 25 | w += newW + 1; 26 | maxH = max(newH, maxH); 27 | pos++; 28 | } 29 | h = maxH + 1; 30 | if(d & 1) area += w * h; 31 | else area -= w*h; 32 | } 33 | 34 | int main() 35 | { 36 | int t, len, i; 37 | i64 w, h, area; 38 | scanf("%d", &t); 39 | while(t--) 40 | { 41 | scanf("%s", str); 42 | len = strlen(str); 43 | area = 0; 44 | for(i=0; i 8 | using namespace std; 9 | 10 | const int MAX = 100032; 11 | int in[MAX]; 12 | 13 | int main(){ 14 | int i, te, tc = 1, n, ts, td, tmp, s, d, ans; 15 | scanf("%d",&te); 16 | while(te--){ 17 | scanf("%d",&n); n--; 18 | for(i = 0; i < n; i++) scanf("%d",&in[i]); 19 | ts = 0, td, tmp = 0, ans = -1, s = -1, d = -1; 20 | for(i = 0; i < n; i++) { 21 | td = i; 22 | if(tmp+in[i] > ans) { 23 | ans = tmp+in[i]; 24 | s = ts; 25 | d = td; 26 | } 27 | else if(tmp+in[i] == ans && td-ts > d-s) { 28 | s=ts; 29 | d=td; 30 | } 31 | if(tmp+in[i] >= 0) tmp+=in[i]; 32 | else if(tmp+in[i] < 0) { 33 | tmp = 0; 34 | ts = i+1; 35 | } 36 | } 37 | if(s != -1) printf("The nicest part of route %d is between stops %d and %d\n", tc++, s+1, d+2); 38 | else printf("Route %d has no nice parts\n",tc++); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /submited/GCPC11B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GCPC11B 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | bool check(char *s1, char *s2, int len) { 12 | int i, j, k, ret, dp[2][1024]; 13 | for(i = 1, ret = 0; i <= len; i++) { 14 | for(k = i & 1, j = 1; j <= len; j++) { 15 | if(abs(s1[i-1]-s2[j-1]) <= 1) { 16 | if(i == 1 || j == 1) dp[k][j] = 1; 17 | else dp[k][j] = dp[k^1][j-1] + 1; 18 | if(dp[k][j] > ret) ret = dp[k][j]; 19 | } 20 | else dp[k][j] = 0; 21 | } 22 | } 23 | return ret >= (len+1)>>1; 24 | } 25 | 26 | int main() { 27 | int test, len; 28 | char tmp[8], s1[1024], s2[1024], res[2][10] = {"NEGATIVE", "POSITIVE"}; 29 | //freopen("in.txt", "r", stdin); 30 | test = atoi(fgets(tmp, 7, stdin)); 31 | while(test--) { 32 | len = atoi(fgets(tmp, 7, stdin)); 33 | fgets(s1, 1023, stdin); 34 | fgets(s2, 1023, stdin); 35 | puts(res[check(s1, s2, len)]); 36 | } 37 | return 0; 38 | } 39 | -------------------------------------------------------------------------------- /submited/LINEUP.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LINEUP 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int INF = 0x3f3f3f3f; 13 | int dp[11][1<<11], pl[11][11]; 14 | 15 | int solve(int pos, int mask) { 16 | if(pos == 11) { 17 | if(mask != (1<<11)-1) return -INF; 18 | else return 0; 19 | } 20 | if(dp[pos][mask] > -1) return dp[pos][mask]; 21 | int &ret = dp[pos][mask]; ret = -INF; 22 | for(int i = 0, temp; i < 11; i++) { 23 | if(pl[i][pos] && !(mask&(1< 8 | #include 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | typedef pair< int, int > pii; 14 | 15 | int dp[7][1001]; 16 | vector< pii > G[7]; 17 | 18 | int solve(int item, int money) { 19 | if(money < 0) return 0; 20 | if(item > 6) return 0x3f3f3f3f; 21 | if(dp[item][money]!=-1) return dp[item][money]; 22 | int& ret = dp[item][money]; 23 | ret = 0; 24 | for(unsigned i = 0; i < G[item].size(); i++) 25 | if(money >= G[item][i].first) 26 | ret = max(ret, min(G[item][i].second, solve(item+1, money - G[item][i].first))); 27 | return ret; 28 | } 29 | 30 | int main() { 31 | int n, t, i, p, q, r; 32 | scanf("%d%d", &n, &t); 33 | memset(dp, -1, sizeof dp); 34 | for(i = 0; i < n; i++) { 35 | scanf("%d %d %d", &p, &q, &r); 36 | G[p].push_back(pii(q, r)); 37 | } 38 | printf("%d\n", solve(1, t)); 39 | return 0; 40 | } -------------------------------------------------------------------------------- /submited/HAMSTER1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HAMSTER1 4 | ALGO: ternary search 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | typedef long double ld; 12 | const ld g = 10.0; 13 | 14 | ld k1, k2, u; 15 | 16 | ld score(ld alpha) { 17 | return (u*u)/(2.0*g)*(2.0*k1*sin(2.0*alpha) + k2*sin(alpha)*sin(alpha)); 18 | } 19 | 20 | ld search(ld low, ld high, ld eps) { 21 | if(fabs(high - low) < eps) return (low + high) / 2.0; 22 | ld leftThird = (2.0 * low + high) / 3.0; 23 | ld rightThird = (low + 2.0 * high) / 3.0; 24 | if(score(leftThird) < score(rightThird)) return search(leftThird, high, eps); 25 | else return search(low, rightThird, eps); 26 | } 27 | 28 | int main() { 29 | int test; 30 | ld alpha, total; 31 | scanf("%d", &test); 32 | while(test--) { 33 | scanf("%Lf %Lf %Lf", &u, &k1, &k2); 34 | alpha = search(0.0, 0.5*acos(-1.0), 1e-9); 35 | total = score(alpha); 36 | printf("%.3Lf %.3Lf\n", alpha, total); 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /submited/MARKUP.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MARKUP 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | void eatnumber() { 12 | char ch; 13 | while(isdigit(ch=getchar())); 14 | if(ch=='.') while(isdigit(ch=getchar())); 15 | ungetc(ch, stdin); 16 | } 17 | 18 | bool enabled() { 19 | char ch; 20 | while((ch=getchar())!=EOF) { 21 | if(ch=='\\') { 22 | switch(ch=getchar()) { 23 | case 'b': 24 | case 'i': break; 25 | case 's': eatnumber(); break; 26 | case '*': return true; 27 | default: putchar(ch); 28 | } 29 | } 30 | else putchar(ch); 31 | } 32 | return false; 33 | } 34 | 35 | bool disabled() { 36 | char ch; 37 | while((ch=getchar())!=EOF) { 38 | if(ch=='\\') { 39 | if((ch=getchar())=='*') return true; 40 | ungetc(ch, stdin); 41 | putchar('\\'); 42 | } 43 | else putchar(ch); 44 | } 45 | return false; 46 | } 47 | 48 | int main() { 49 | while(enabled() && disabled()); 50 | return 0; 51 | } -------------------------------------------------------------------------------- /submited/QUADRATE.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: QUADRATE 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | char buff[64], expr[64], *ptr; 13 | 14 | int main() { 15 | int test = atoi(gets(buff)), i, j, a[3], d; 16 | while(test--) { 17 | gets(buff); 18 | for(i = j = 0; buff[i]!='='; i++) { 19 | if(buff[i]==' ') continue; 20 | if(buff[i]=='-' || buff[i]=='+') { 21 | expr[j++] = ' '; expr[j++] = buff[i]; 22 | } 23 | else expr[j++] = buff[i]; 24 | } 25 | expr[j] = 0; 26 | ptr = strtok(expr, " "); 27 | a[0] = a[1] = a[2] = 0; 28 | while(ptr) { 29 | for(i = j = 0; ptr[j]; j++) i += (ptr[j]=='x'); 30 | a[i] = atoi(ptr); 31 | if(!a[i]) a[i] = ptr[0]=='-'?-1:1; 32 | ptr = strtok(0, " "); 33 | } 34 | d = a[1]*a[1] - 4*a[2]*a[0]; 35 | if(!d) puts("Equal roots."); 36 | else if(d < 0) puts("Imaginary roots."); 37 | else puts("Distinct real roots."); 38 | } 39 | return 0; 40 | } -------------------------------------------------------------------------------- /submited/EQBOX.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EQBOX 4 | ALGO: computational geometry 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define eps 1e-10 11 | #define i64 long long 12 | 13 | inline bool fits(i64 a, i64 b, i64 c, i64 d) { 14 | if( a > c && b > d ) return true; 15 | if( d >= b ) return false; 16 | double x, y, L, K, Dmax, D; 17 | if( c*c+d*d < b*b ) return true; 18 | if( c*c+d*d > a*a+b*b ) return false; 19 | L = ( b - sqrt(c*c + d*d - a*a) ) / 2.0; 20 | K = ( a - sqrt(c*c + d*d - b*b) ) / 2.0; 21 | D = d; 22 | if( D*D > L*L + K*K ) return false; 23 | return true; 24 | } 25 | 26 | int main() { 27 | int i; 28 | i64 a, b, x, y, t; 29 | scanf("%d", &i); 30 | while(i--) { 31 | scanf("%lld %lld %lld %lld", &a, &b, &x, &y); 32 | if( a < b ) { t = a; a = b; b = t; } 33 | if( x < y ) { t = x; x = y; y = t; } 34 | if( fits(a, b, x, y) ) printf("Escape is possible.\n"); 35 | else printf("Box cannot be dropped.\n"); 36 | } 37 | return 0; 38 | } 39 | 40 | 41 | -------------------------------------------------------------------------------- /submited/FCTRL2.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: FCTRL2 4 | ALGO: math, big integer 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAXDIGIT 101 11 | #define MAXLENGTH 159 12 | 13 | using namespace std; 14 | 15 | char factorial[MAXDIGIT][MAXLENGTH]; 16 | 17 | void multiply(int k) 18 | { 19 | int carry = 0, sum, i = 0, len = strlen(factorial[k-1]); 20 | while(i0) 27 | { 28 | factorial[k][i++] = (carry%10) + '0'; 29 | carry/=10; 30 | } 31 | } 32 | 33 | int main() 34 | { 35 | int n, k, len, t; 36 | factorial[0][0]='1'; factorial[1][0]='1'; 37 | for(k=2;k=0;k--) 44 | printf("%c",factorial[n][k]); 45 | printf("\n"); 46 | } 47 | return 0; 48 | } 49 | 50 | -------------------------------------------------------------------------------- /submited/RPLK.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: RPLK 4 | ALGO: sorting 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | struct Wood { int h, c; }; 12 | 13 | Wood wood[100000]; 14 | 15 | inline bool comp(const Wood &a, const Wood &b) { 16 | return a.h != b.h ? a.h > b.h : a.c > b.c; 17 | } 18 | 19 | int main() { 20 | int test, cs, e, w, i, k, total, cnt, tmp, hi, wi, h, m; 21 | scanf("%d", &test); 22 | for(cs = 1; cs <= test; cs++) { 23 | scanf("%d %d %d %d", &e, &m, &h, &w); 24 | for(i = k = 0; i < e; i++) { 25 | scanf("%d %d", &hi, &wi); 26 | if(wi / (1 + m) > 0) { 27 | wood[k].h = hi, wood[k].c = wi / (1 + m); 28 | k++; 29 | } 30 | } 31 | sort(wood, wood + k, comp); 32 | for(total = i = cnt = 0; i < k && cnt < w; i++) { 33 | tmp = min(wood[i].c, w - cnt); 34 | cnt += tmp; 35 | total += wood[i].h * tmp; 36 | } 37 | total += cnt * h; 38 | printf("Scenario #%d: %d\n", cs, total); 39 | } 40 | return 0; 41 | } 42 | -------------------------------------------------------------------------------- /submited/ANARC05B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ANARC05B 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 10009; 12 | int A[MAX], B[MAX]; 13 | 14 | int main() { 15 | int na, nb, i, j; 16 | while(scanf("%d", &na)==1 && na) { 17 | for(i=1; i<=na; i++) scanf("%d", &A[i]); 18 | scanf("%d", &nb); 19 | for(j=1; j<=nb; j++) scanf("%d", &B[j]); 20 | for(i=j=1; i<=na || j<=nb; ) { 21 | if(i<=na && j<=nb && A[i]==B[j]) { 22 | A[i] += A[i-1]; 23 | B[j] += B[j-1]; 24 | A[i] = B[j] = max(A[i], B[j]); 25 | i++, j++; 26 | } 27 | else if(i>na) { 28 | B[j] += B[j-1]; 29 | j++; 30 | } 31 | else if(j>nb) { 32 | A[i] += A[i-1]; 33 | i++; 34 | } 35 | else if(A[i] < B[j]) { 36 | A[i] += A[i-1]; 37 | i++; 38 | } 39 | else if(A[i] > B[j]) { 40 | B[j] += B[j-1]; 41 | j++; 42 | } 43 | } 44 | printf("%d\n", max(A[na], B[nb])); 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /submited/PHIDIAS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PHIDIAS 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | const int MAXS = 601, MAXN = 200; 11 | 12 | int dp[MAXS][MAXS], h[MAXN], w[MAXN]; 13 | 14 | int solve(int w, int h) { 15 | if(dp[w][h] > -1) return dp[w][h]; 16 | int &res = dp[w][h] = w * h, tmp; 17 | for(int i = 1; i <= (w >> 1); i++) { 18 | tmp = solve(i, h); 19 | if(tmp < res) tmp += solve(w - i, h); 20 | if(tmp < res) res = tmp; 21 | } 22 | for(int i = 1; i <= (h >> 1); i++) { 23 | tmp = solve(w, i); 24 | if(tmp < res) tmp += solve(w, h - i); 25 | if(tmp < res) res = tmp; 26 | } 27 | return res; 28 | } 29 | 30 | int main() { 31 | int test, i, H, W, n; 32 | scanf("%d", &test); 33 | while(test--) { 34 | scanf("%d %d %d", &W, &H, &n); 35 | memset(dp, -1, sizeof dp); 36 | for(i = 0; i < n; i++) { 37 | scanf("%d %d", &w[i], &h[i]); 38 | dp[w[i]][h[i]] = 0; 39 | } 40 | printf("%d\n", solve(W, H)); 41 | } 42 | return 0; 43 | } -------------------------------------------------------------------------------- /submited/EXPRESS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EXPRESS 4 | ALGO: breadth first search 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | struct Node { int r, l; }; 13 | 14 | const int MAXLEN = 10001; 15 | char post[MAXLEN], res[MAXLEN]; 16 | Node tree[MAXLEN]; 17 | int Q[MAXLEN], S[MAXLEN]; 18 | 19 | int main() { 20 | int t, i, st, en, tp, a, b; 21 | t = atoi(gets(post)); 22 | while(t--) { 23 | gets(post); 24 | st = en = tp = 0; 25 | for(i = 0; post[i]; i++) { 26 | if(islower(post[i])) { 27 | tree[i].l = tree[i].r = -1; 28 | S[tp++] = i; 29 | } 30 | else { 31 | tree[i].r = S[--tp]; 32 | tree[i].l = S[--tp]; 33 | S[tp++] = i; 34 | } 35 | } 36 | res[i] = 0; 37 | Q[en++] = S[--tp]; 38 | while(st < en) { 39 | a = Q[st++]; 40 | res[--i] = post[a]; 41 | if(tree[a].l > -1) Q[en++] = tree[a].l; 42 | if(tree[a].r > -1) Q[en++] = tree[a].r; 43 | } 44 | puts(res); 45 | } 46 | return 0; 47 | } 48 | -------------------------------------------------------------------------------- /submited/PTIME.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PTIME 4 | ALGO: math, prime factorization 5 | */ 6 | 7 | #include 8 | 9 | const int MAX = 10000; 10 | const int LMT = 100; 11 | 12 | int flag[157], cnt, primes[1230]; 13 | 14 | #define ifc(x) (flag[x>>6]&(1<<((x>>1)&31))) 15 | #define isc(x) (flag[x>>6]|=(1<<((x>>1)&31))) 16 | 17 | void sieve() { 18 | int i, j, k; 19 | primes[0] = 2, cnt = 1; 20 | for(i = 3; i < LMT; i+=2) if(!ifc(i)) for(j = i*i, k = i << 1; j < MAX; j += k) isc(j); 21 | for(i = 3; i < MAX; i += 2) if(!ifc(i)) primes[cnt++] = i; 22 | } 23 | 24 | int main() { 25 | int n, i, x, pwr, flg; 26 | sieve(); 27 | while(scanf("%d", &n) == 1) { 28 | for(i = flg = 0; i < cnt && primes[i] <= n; i++) { 29 | x = n, pwr = 0; 30 | while(x > 0) { 31 | pwr += x / primes[i]; 32 | x /= primes[i]; 33 | } 34 | if(pwr > 0) { 35 | if(flg) printf(" * "); 36 | printf("%d^%d", primes[i], pwr); 37 | flg++; 38 | } 39 | } 40 | printf("\n"); 41 | } 42 | return 0; 43 | } 44 | -------------------------------------------------------------------------------- /submited/CZ_PROB1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CZ_PROB1 4 | ALGO: dynamic programming, math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define MAX 8100 11 | #define LMT 90 12 | 13 | bool flag[MAX]; 14 | int sp2[MAX]; 15 | int dp[MAX][4]; 16 | 17 | void generate() 18 | { 19 | int i, j, k; 20 | flag[0] = flag[1] = 1; 21 | for(i=3; i0; i--) 37 | if(n-i>=0) 38 | temp += solve(n-i, i); 39 | return (dp[n][k] = temp); 40 | } 41 | 42 | int main() 43 | { 44 | generate(); 45 | int t, n, k; 46 | scanf("%d", &t); 47 | while(t--) 48 | { 49 | scanf("%d %d", &n, &k); 50 | printf("%d\n", solve(sp2[n], k)); 51 | } 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /submited/BABTWR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BABTWR 4 | ALGO: dp 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define MAX 111 11 | 12 | struct boxtype {int x, y, z;} box[MAX]; 13 | int dp[MAX], total; 14 | 15 | int solve(int i) { 16 | if(dp[i]) return dp[i]; 17 | int h, maxh, b; 18 | for(maxh=b=0; bmaxh) 21 | maxh = h; 22 | return dp[i] = maxh + box[i].z; 23 | } 24 | 25 | int main() { 26 | int n, i, k, x, y, z, h, maxh; 27 | while(scanf("%d", &n)==1 && n) { 28 | memset(dp, 0, sizeof(dp)); 29 | for(i=k=0; imaxh) 38 | maxh = h; 39 | printf("%d\n", maxh); 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/ZIGZAG.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ZIGZAG 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | typedef long long i64; 11 | const int LEN = 300003; 12 | char buff[LEN]; 13 | 14 | inline i64 getlevel(i64 p, i64 n) { 15 | if(p <= n) return ((p+1) * p) >> 1; 16 | p = n + n - p - 1; 17 | return n * n - ((p * (p+1)) >> 1); 18 | } 19 | 20 | inline i64 getval(i64 x, i64 y, i64 n) { 21 | i64 en, p = x + y - 1; 22 | en = getlevel(p, n); 23 | if(p > n) x -= p - n, y -= p - n; 24 | if(p&1) return en - x + 1; 25 | else return en - y + 1; 26 | } 27 | 28 | int main() { 29 | int i, n, len, r, c; 30 | i64 total; 31 | scanf("%d%d%s", &n, &len, buff); 32 | for(i=0, total=r=c=1; i < len; i++) { 33 | switch(buff[i]) { 34 | case 'U': total += getval(--r, c, n); break; 35 | case 'D': total += getval(++r, c, n); break; 36 | case 'L': total += getval(r, --c, n); break; 37 | case 'R': total += getval(r, ++c, n); break; 38 | } 39 | } 40 | printf("%lld\n", total); 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/DIV.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DIV 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | const int MAX = 1000000, LMT = 1000, LEN = 78500; 11 | int small[MAX+10]; 12 | 13 | void smallest() { 14 | int i, j, k; 15 | for(i=2; i<=MAX; i++) small[i] = ((i&1)==0)? 2 : i; 16 | for(i=3; i<=LMT; i+=2) 17 | if(small[i]==i) 18 | for(j=i; j<=MAX; j+=i) 19 | if(small[j]==j) 20 | small[j] = i; 21 | } 22 | 23 | int dn(int n) { 24 | int prv=0, cnt=0, res=1; 25 | while(n>1) { 26 | if(small[n]!=prv) { 27 | res *= (cnt+1); 28 | prv = small[n]; 29 | cnt = 1; 30 | } 31 | else cnt++; 32 | n /= small[n]; 33 | } 34 | return res*(cnt+1); 35 | } 36 | 37 | int main() { 38 | smallest(); 39 | int d, i, p, q, cnt; 40 | freopen("out.txt", "w", stdout); 41 | for(i=2; i<=MAX; i++) { 42 | d = dn(i); 43 | p = small[d]; 44 | if(p==d) continue; 45 | q = small[d/p]; 46 | if(q==p || q!=d/p) continue; 47 | cnt++; 48 | if(cnt%9==0) printf("%d\n", i); 49 | } 50 | return 0; 51 | } 52 | -------------------------------------------------------------------------------- /submited/GNY07D.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: GNY07D 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | char en[1024]; 11 | int dr[] = {0, 1, 0, -1}; 12 | int dc[] = {1, 0, -1, 0}; 13 | int R, C; 14 | 15 | #define idx(r,c) (r*C+c) 16 | 17 | int main() { 18 | int t, i, x = 1, sr, sc, tot, dir; 19 | char ch; 20 | scanf("%d", &t); 21 | while(t--) { 22 | scanf("%d%d%s", &R, &C, en); 23 | printf("%d ", x++); 24 | sr = sc = dir = 0; 25 | tot = R * C; 26 | for(ch = 0, i = 1; i <= tot; i++) { 27 | ch = (ch << 1)|(en[idx(sr,sc)]=='1'); 28 | en[idx(sr,sc)] = 'X'; 29 | if(i % 5 == 0) { 30 | ch = (!ch? ' ' : ch + 'A' - 1); 31 | putchar(ch); 32 | ch = 0; 33 | } 34 | sr += dr[dir], sc += dc[dir]; 35 | if(sr<0 || sr>=R || sc<0 || sc>=C || en[idx(sr,sc)]=='X') { 36 | if(i < tot) { 37 | sr -= dr[dir], sc -= dc[dir]; 38 | dir = (dir + 1) & 3; 39 | sr += dr[dir], sc += dc[dir]; 40 | } 41 | } 42 | } 43 | putchar('\n'); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /submited/TETRA.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TETRA 4 | ALGO: geometry 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | const double EPS = 1e-9; 11 | 12 | inline double volume(double u, double v, double w, double U, double V, double W) { 13 | double u1,v1,w1; 14 | u1 = v * v + w * w - U * U; 15 | v1 = w * w + u * u - V * V; 16 | w1 = u * u + v * v - W * W; 17 | return sqrt(4.0*u*u*v*v*w*w - u*u*u1*u1 - v*v*v1*v1 - w*w*w1*w1 + u1*v1*w1) / 12.0; 18 | } 19 | 20 | inline double surface(double a, double b, double c) { 21 | return sqrt((a + b + c) * (-a + b + c) * (a - b + c) * (a + b - c)) / 4.0; 22 | } 23 | 24 | int main() { 25 | int test; 26 | double WX, WY, WZ, XY, XZ, YZ, sur, rad; 27 | scanf("%d", &test); 28 | while(test--) { 29 | scanf("%lf %lf %lf %lf %lf %lf", &WX, &WY, &WZ, &XY, &XZ, &YZ); 30 | sur = surface(WX, WY, XY) + surface(WX, XZ, WZ) + surface(WY, YZ, WZ) + surface(XY, XZ, YZ); 31 | rad = volume(WX, WY, WZ, YZ, XZ, XY) * 3.0 / sur; 32 | printf("%.4lf\n", rad + EPS); 33 | } 34 | return 0; 35 | } -------------------------------------------------------------------------------- /submited/BOI7SEQ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BOI7SEQ 4 | ALGO: stack 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | typedef long long i64; 11 | 12 | const int MAX = 1000000; 13 | const int BUFF = 8000000; 14 | const int INF = 0x7f7f7f7f; 15 | 16 | static char buff[BUFF], *ptr = buff; 17 | static int Stack[MAX], top; 18 | 19 | inline int min(int a, int b) { 20 | return (a < b? a : b); 21 | } 22 | 23 | inline int nextInt() { 24 | int ret = 0; 25 | while(*ptr < '0' || *ptr > '9') ptr++; 26 | do { ret = ret * 10 + *ptr++ - '0'; 27 | } while(*ptr >= '0' && *ptr <= '9'); 28 | return ret; 29 | } 30 | 31 | int main() { 32 | int n, i, a; 33 | i64 res = 0; 34 | fread_unlocked(buff, BUFF, 1, stdin); 35 | n = nextInt(); 36 | Stack[top++] = INF; 37 | for(i = 0; i < n; i++) { 38 | a = nextInt(); 39 | while(Stack[top-1] <= a) { 40 | top--; 41 | res += min(Stack[top-1], a); 42 | } 43 | Stack[top++] = a; 44 | } 45 | for(i = 1; i < top - 1; i++) res += Stack[i]; 46 | printf("%lld\n", res); 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /submited/INVCNT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: INVCNT 4 | ALGO: divide and conquer 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define MAX 200002 11 | 12 | int a[MAX], L[MAX/2+1], R[MAX/2+1]; 13 | long long total; 14 | 15 | void Merge(int *a, int p, int q, int r) 16 | { 17 | int i, j, k, n1 = q-p+1, n2 = r-q; 18 | for(i=0;i=n2 || (i 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | double a, b, c, d, alpha, beta, gamma, delta; 13 | double D, L, HA, HB, ERR; 14 | double h, hl, hr, pi = acos(-1.0); 15 | int test, cs = 1; 16 | scanf("%d%lf%lf%lf%lf%lf", &test, &D, &L, &HA, &HB, &ERR); 17 | while(test--) { 18 | scanf("%lf%lf%lf%lf", &a, &b, &c, &d); 19 | if(a>0.0 && a<90.0 && b>0.0 && b <90.0 && c>0.0 && c<90.0 && d>90.0 && d<180.0) { 20 | d = 180.0 - d; 21 | alpha = a * pi / 180.0; 22 | beta = b * pi / 180.0; 23 | gamma = c * pi / 180.0; 24 | delta = d * pi / 180.0; 25 | h = tan(gamma) * (D * tan(delta) / (tan(delta) + tan(gamma))); 26 | hl = HA + h / sin(gamma) * tan(alpha); 27 | hr = HB + h / sin(delta) * tan(beta); 28 | if(fabs(hl - hr) > ERR) printf("%d ERROR\n", cs++); 29 | else printf("%d %d\n", cs++, (int)((hl + hr) / 2.0 + 0.5)); 30 | } 31 | else printf("%d DISQUALIFIED\n", cs++); 32 | } 33 | return 0; 34 | } 35 | -------------------------------------------------------------------------------- /submited/TWENDS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: TWENDS 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 1024; 13 | int a[MAX], dp[2][MAX][MAX], s[MAX]; 14 | 15 | int solve(int P, int L, int R) { 16 | if(L==R) return a[L]; 17 | int &ret = dp[P][L][R], now; 18 | if(ret!=-1) return ret; 19 | now = s[R] - (L==0? 0 : s[L-1]); 20 | ret = 0; 21 | if(P) { 22 | if(a[L] >= a[R]) ret = now - solve(P^1, L+1, R); 23 | else ret = now - solve(P^1, L, R-1); 24 | } 25 | else ret = now - min(solve(P^1, L+1, R), solve(P^1, L, R-1)); 26 | return ret; 27 | } 28 | 29 | int main() { 30 | int n, i, ans, test = 1; 31 | while(scanf("%d", &n)==1 && n) { 32 | for(i=0; i 8 | #include 9 | #include 10 | #include 11 | #include 12 | using namespace std; 13 | 14 | void getlower(string &s) 15 | { 16 | int i, len = s.size(); 17 | for(i=0; i S; 35 | ios::sync_with_stdio(false); 36 | while(getline(cin,line)) 37 | { 38 | getlower(line); 39 | stringstream ss(line); 40 | while(ss >> str) 41 | { 42 | if(str=="BULLSHIT") 43 | { 44 | total += S.size(); 45 | game++; 46 | S.clear(); 47 | } 48 | else S.insert(str); 49 | } 50 | } 51 | g = gcd(total, game); 52 | cout << total/g << " / " << game/g << endl; 53 | return 0; 54 | } 55 | 56 | 57 | -------------------------------------------------------------------------------- /submited/RPLN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: RPLN 4 | ALGO: range minimum query 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 1 << 17; 12 | const int LOG = 17; 13 | 14 | int M[MAX][LOG], A[MAX]; 15 | 16 | void process(int n) { 17 | int i, j; 18 | for(i = 0; i < n; i++) M[i][0] = i; 19 | for(j = 1; (1 << j) <= n; j++) { 20 | for(i = 0; i + (1 << j) <= n; i++) { 21 | if(A[M[i][j - 1]] < A[M[i + (1 << (j - 1))][j - 1]]) M[i][j] = M[i][j - 1]; 22 | else M[i][j] = M[i + (1 << (j - 1))][j - 1]; 23 | } 24 | } 25 | } 26 | 27 | int main() { 28 | int test, cs, n, q, i, j, k; 29 | scanf("%d", &test); 30 | for(cs = 1; cs <= test; cs++) { 31 | scanf("%d %d", &n, &q); 32 | for(i = 0; i < n; i++) scanf("%d", &A[i]); 33 | process(n); 34 | printf("Scenario #%d:\n\n", cs); 35 | while(q--) { 36 | scanf("%d %d", &i, &j); 37 | for(i--, j--, k = 1; (1 << k) <= (j - i + 1); k++); k--; 38 | printf("%d\n", min(A[M[i][k]], A[M[j - (1 << k) + 1][k]])); 39 | } 40 | } 41 | return 0; 42 | } 43 | -------------------------------------------------------------------------------- /submited/SAMER08E.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SAMER08E 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | struct Date { int d, m, y; }; 11 | const int days[12] = {31,28,31,30,31,30,31,31,30,31,30,31}; 12 | 13 | inline bool isLeapYear(int y) { 14 | return (y % 400 == 0 || (y % 100 && y % 4 == 0)); 15 | } 16 | 17 | inline bool isNextDay(const Date &now, const Date &prev) { 18 | int d = 1 + prev.d, m = prev.m, y = prev.y, dm; 19 | dm = days[m-1] + (m==2 && isLeapYear(y)); 20 | if(d > dm) { d = 1, m++; } 21 | if(m > 12) { m = 1, y++; } 22 | return now.d == d && now.m == m && now.y == y; 23 | } 24 | 25 | int main() { 26 | int n, i, pc, nc, tot, cnt; 27 | Date now, prev; 28 | while(scanf("%d", &n)==1 && n) { 29 | tot = cnt = 0; 30 | scanf("%d%d%d%d", &prev.d, &prev.m, &prev.y, &pc); 31 | for(i = 1; i < n; i++) { 32 | scanf("%d%d%d%d", &now.d, &now.m, &now.y, &nc); 33 | if(isNextDay(now, prev)) tot += nc-pc, cnt++; 34 | prev = now, pc = nc; 35 | } 36 | printf("%d %d\n", cnt, tot); 37 | } 38 | return 0; 39 | } -------------------------------------------------------------------------------- /submited/SUBST1.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SUBST1 4 | ALGO: suffix array 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | char str[50005]; 13 | int s[50005]; 14 | long long l; 15 | 16 | int cmp(const void *a,const void *b) { 17 | return (strcmp((str+ *((int*)a)),(str+ *((int*)b)))); 18 | } 19 | 20 | void suffix_array(int n) { 21 | int i; 22 | for(i=0;i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | typedef long long i64; 13 | 14 | i64 sum[1<<18], a[18]; 15 | 16 | int main() { 17 | int n, m, i, j, tot, sz, mx; 18 | i64 am, d, lst, st, nd; 19 | while(scanf("%d %d", &n, &m)==2) { 20 | for(i = 0; i < n; i++) scanf("%lld", a + i); 21 | for(i = 0; i < m; i++) scanf("%lld", a + n + i); 22 | tot = m + n; 23 | for(sz = 0, i = 0; i < (1< mx) { 38 | mx = j-i; 39 | st = sum[i]; 40 | nd = sum[i] + d - 1; 41 | } 42 | } 43 | printf("%lld %lld %d\n", st, nd, mx); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /submited/LWAR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LWAR 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 30003; 12 | char str[MAX]; 13 | 14 | void readStr(char *s, int &len) { 15 | char ch; 16 | while(!isdigit(ch=getchar())); 17 | s[(len=0)++] = ch; 18 | while(isdigit(ch=getchar())) s[len++] = ch; 19 | s[len] = 0; 20 | } 21 | 22 | int main() { 23 | int t, len, i, invc, done, next, ch; 24 | //freopen("in.txt", "r", stdin); 25 | //freopen("out.txt", "w", stdout); 26 | scanf("%d", &t); 27 | while(t--) { 28 | readStr(str, len); 29 | done = invc = next = 0; 30 | for(i=0; i 10 | #include 11 | using namespace std; 12 | 13 | #define MAX 2002 14 | 15 | int A[MAX], n; 16 | 17 | int bSearch(int start, int end, int val) 18 | { 19 | int mid, i; 20 | while(start <= end) 21 | { 22 | if(A[start] > val) return start; 23 | if(A[end] <= val) return end+1; 24 | mid = (start + end) / 2; 25 | if(A[mid] > val) end = mid - 1; 26 | else if(A[mid] < val) start = mid + 1; 27 | else if(A[mid] == val) 28 | { 29 | for(i=mid+1; i 8 | #include 9 | 10 | const int MAX = 100000; 11 | 12 | int d[MAX], to[MAX<<1], next[MAX<<1], fin[MAX], q[MAX], n, st, en; 13 | 14 | int bfs(int s) { 15 | int e, u, v; 16 | memset(d, -1, n*sizeof(int)); 17 | st = 0, en = 0; 18 | q[en++] = s; 19 | d[s] = 0; 20 | while(st < en) { 21 | u = q[st++]; 22 | for(e = fin[u]; e >= 0; e = next[e]) { 23 | v = to[e]; 24 | if(d[v] == -1) { 25 | d[v] = d[u] + 1; 26 | q[en++] = v; 27 | } 28 | } 29 | } 30 | for(u = 0; u < n; u++) if(d[u] > d[s]) s = u; 31 | return s; 32 | } 33 | 34 | int main() { 35 | int test, e, i, u, v; 36 | scanf("%d", &test); 37 | while(test--) { 38 | scanf("%d", &n); 39 | memset(fin, -1, n*sizeof(int)); 40 | for(i = 1, e = 0; i < n; i++) { 41 | scanf("%d %d", &u, &v); 42 | to[e] = v, next[e] = fin[u], fin[u] = e++; 43 | to[e] = u, next[e] = fin[v], fin[v] = e++; 44 | } 45 | printf("%d\n", (1 + d[bfs(bfs(0))])>>1); 46 | } 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /submited/JMFILTER.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: JMFILTER 4 | ALGO: disjoint set 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 11000000; 12 | 13 | int root[MAX], fmap[MAX]; 14 | set< int > S; 15 | 16 | int find(int p) { 17 | if(p != root[p]) root[p] = find(root[p]); 18 | return root[p]; 19 | } 20 | 21 | int main() { 22 | //freopen("in.txt", "r", stdin); 23 | int n, m, i, last, a, b, pa, pb, cs = 1; 24 | char com[2]; 25 | while(scanf("%d %d", &n, &m) == 2 && (n | m)) { 26 | for(i = 0; i < n; i++) root[i] = fmap[i] = i; 27 | for(last = n, i = 0; i < m; i++) { 28 | scanf("%s", com); 29 | if(com[0] == 'M') { 30 | scanf("%d %d", &a, &b); 31 | pa = find(fmap[a]); 32 | pb = find(fmap[b]); 33 | if(pa != pb) root[pa] = root[pb]; 34 | } 35 | else { 36 | scanf("%d", &a); 37 | fmap[a] = root[last] = last; 38 | last++; 39 | } 40 | } 41 | S.clear(); 42 | for(i = 0; i < n; i++) S.insert(find(fmap[i])); 43 | printf("Case #%d: %d\n", cs++, (int)S.size()); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /submited/DRAWM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: DRAWM 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 80, INF = (1<<20); 13 | 14 | int main() { 15 | int c, i, j, n, m, now, seq[MAX]; 16 | char grid[MAX][MAX], p; 17 | while(scanf("%d", &c)==1 && c > 0) { 18 | memset(grid, 0x20, sizeof(grid)); 19 | for(i = 0; i <= c; i++) scanf("%d", &seq[i]); 20 | for(i = p = 0, m = -INF, n = INF, now = 40; i < c; i++) { 21 | if(seq[i] < seq[i+1]) { 22 | if(p=='u') now++; 23 | grid[now][i] = '/', p = 'u'; 24 | } 25 | else if(seq[i] > seq[i+1]) { 26 | if(p!='u') now--; 27 | grid[now][i] = '\\', p = 'd'; 28 | } 29 | else { 30 | if(p=='u') now++; 31 | grid[now][i] = '_', p = 'e'; 32 | } 33 | n = min(now, n); 34 | m = max(now, m); 35 | } 36 | for(i = m; i >= n; i--) { 37 | for(j = c; j >= 0; j--) { 38 | if(grid[i][j]!=' ') break; 39 | grid[i][j] = 0; 40 | } 41 | puts(grid[i]); 42 | } 43 | puts("***"); 44 | } 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /submited/LCMSUM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: LCMSUM 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define MAX 1000000 11 | #define LMT 1000 12 | 13 | int pfactor[MAX+10]; 14 | long long int mcount[MAX+10], mval[MAX+10]; 15 | 16 | int main() 17 | { 18 | mval[1] = mcount[1] = 1; 19 | for(int i=1; i<=MAX; i++) pfactor[i] = i; 20 | for(int i=2; i<=LMT; i++) 21 | if(pfactor[i]==i) 22 | for(int j=i<<1; j<=MAX; j+=i) 23 | if(pfactor[j]==j) 24 | pfactor[j] = i; 25 | for(int i=2, k; i<=MAX; i++) 26 | { 27 | k = i; 28 | mcount[i] = 1; 29 | while(k%pfactor[i]==0) 30 | { 31 | mcount[i] *= pfactor[i]; 32 | k /= pfactor[i]; 33 | } 34 | } 35 | for(int i=2; i<=MAX; i++) 36 | mval[i] = mval[i/pfactor[i]]+mcount[i]*(mcount[i]-mcount[i]/pfactor[i])*mval[i/mcount[i]]; 37 | int t, n; 38 | long long res; 39 | scanf("%d", &t); 40 | while(t--) 41 | { 42 | scanf("%d", &n); 43 | res = mval[n]-1; 44 | if(res&1) res *= (n>>1); 45 | else res>>=1, res*=n; 46 | res += n; 47 | printf("%lld\n", res); 48 | } 49 | return 0; 50 | } 51 | -------------------------------------------------------------------------------- /submited/CPRMT.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CPRMT 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 1111 13 | 14 | char s1[MAX], s2[MAX]; 15 | int len1, len2, dp[MAX][MAX]; 16 | 17 | void lcs() 18 | { 19 | int i, j; 20 | for(i=1;i<=len1;i++) 21 | { 22 | for(j=1;j<=len2;j++) 23 | { 24 | if(s1[i-1]==s2[j-1]) dp[i][j] = dp[i-1][j-1]+1; 25 | else if(dp[i][j-1] > dp[i-1][j]) dp[i][j] = dp[i][j-1]; 26 | else dp[i][j] = dp[i-1][j]; 27 | } 28 | } 29 | } 30 | 31 | void print(int i, int j) 32 | { 33 | if(!i || !j) return; 34 | if(s1[i-1]==s2[j-1]) 35 | { 36 | print(i-1,j-1); 37 | printf("%c",s1[i-1]); 38 | } 39 | else if(dp[i][j-1] > dp[i-1][j]) print(i,j-1); 40 | else print(i-1,j); 41 | } 42 | 43 | int main() 44 | { 45 | while(gets(s1)) 46 | { 47 | gets(s2); 48 | len1 = strlen(s1); 49 | len2 = strlen(s2); 50 | sort(s1,s1+len1); 51 | sort(s2,s2+len2); 52 | lcs(); 53 | print(len1, len2); 54 | printf("\n"); 55 | } 56 | return 0; 57 | } 58 | 59 | 60 | -------------------------------------------------------------------------------- /submited/MMASS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MMASS 4 | ALGO: expression evaluation 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | #include 11 | #include 12 | using namespace std; 13 | 14 | inline int getM(char ch) 15 | { 16 | switch(ch) 17 | { 18 | case 'H': return 1; 19 | case 'O': return 16; 20 | case 'C': return 12; 21 | } 22 | return 0; 23 | } 24 | 25 | int main() 26 | { 27 | char str[150]; 28 | int i, v; 29 | stack < int > S; 30 | scanf("%s", str); 31 | for(i=0; str[i]; i++) 32 | { 33 | if(isdigit(str[i])) 34 | { 35 | v = S.top(); 36 | S.pop(); 37 | S.push(v * (str[i]-'0')); 38 | } 39 | else if(str[i]=='(') S.push(-1); 40 | else if(str[i]==')') 41 | { 42 | v = 0; 43 | while(!S.empty() && S.top()!=-1) 44 | { 45 | v += S.top(); 46 | S.pop(); 47 | } 48 | S.pop(); 49 | S.push(v); 50 | } 51 | else if(isalpha(str[i])) S.push(getM(str[i])); 52 | } 53 | v = 0; 54 | while(!S.empty()) 55 | { 56 | v += S.top(); 57 | S.pop(); 58 | } 59 | printf("%d\n", v); 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /submited/EDIST.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: EDIST 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | 10 | #define max_len 2002 11 | 12 | char str1[max_len], str2[max_len]; 13 | int edit_value[max_len][max_len]; 14 | 15 | int minimum(int a, int b) 16 | { 17 | return (a < b) ? a : b; 18 | } 19 | 20 | int main() 21 | { 22 | int test; 23 | 24 | int len1, len2; 25 | int val, i, j; 26 | scanf("%d", &test); 27 | while(test--) 28 | { 29 | scanf("%s %s", str1, str2); 30 | len1 = strlen(str1); 31 | len2 = strlen(str2); 32 | edit_value[0][0] = 0; 33 | for(i=0 ; i 8 | 9 | #define IOR(x) freopen(x,"r",stdin); 10 | 11 | struct trie { 12 | trie *next[10]; 13 | bool end; 14 | trie() { 15 | for(int i=0; i<10; i++) next[i] = NULL; 16 | end = 0; 17 | } 18 | }; 19 | 20 | int main() { 21 | int t, n, i, p; 22 | char str[15]; 23 | bool flag; 24 | //IOR("in.txt"); 25 | scanf("%d", &t); 26 | while(t--) { 27 | scanf("%d", &n); 28 | trie *head, *tail; 29 | head = new trie; 30 | flag = 1; 31 | while(n--) { 32 | scanf("%s", str); 33 | if(flag) { 34 | tail = head; 35 | for(i=0; str[i]; i++) { 36 | if(tail->end) { 37 | flag = 0; 38 | break; 39 | } 40 | p = str[i]-'0'; 41 | if(tail->next[p]==NULL) tail->next[p] = new trie; 42 | tail = tail->next[p]; 43 | } 44 | tail->end = 1; 45 | for(i=0; i<10; i++) { 46 | if(tail->next[i]) { 47 | flag = 0; 48 | break; 49 | } 50 | } 51 | } 52 | } 53 | if(flag) printf("YES\n"); 54 | else printf("NO\n"); 55 | } 56 | return 0; 57 | } 58 | -------------------------------------------------------------------------------- /submited/MCARDS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MCARDS 4 | ALGO: dynamic programming 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int idx[5][101], u[404], v[404]; 12 | int seq[404], aux[404]; 13 | int ord[4] = {1, 2, 3, 4}, N, C; 14 | 15 | int lis(int sz) { 16 | int i, u, v, bsz = 0, m; 17 | aux[bsz++] = 0; 18 | for(i=1; i>1; 25 | if(seq[aux[m]] < seq[i]) u = m + 1; 26 | else v = m; 27 | } 28 | if(seq[i] < seq[aux[u]]) aux[u] = i; 29 | } 30 | return bsz; 31 | } 32 | 33 | int main() { 34 | int i, j, t, cnt, mn = 1<<30; 35 | //freopen("C:\\in.txt", "r", stdin); 36 | scanf("%d%d", &C, &N); 37 | for(i=0, t=N*C; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int MAX = 100001; 13 | 14 | char buff[MAX << 1]; 15 | int lengths[MAX << 1]; 16 | 17 | int main() { 18 | int len, i, s, e, pallen, found, j, d, total, k; 19 | while(gets(buff)) { 20 | len = strlen(buff); 21 | k = 0; 22 | pallen = 0; 23 | for(i = 0; i < len; ) { 24 | if(i > pallen && buff[i-pallen-1] == buff[i]) { 25 | pallen += 2, i++; 26 | continue; 27 | } 28 | lengths[k++] = pallen; 29 | s = k - 2, e = s - pallen, found = 0; 30 | for(j = s; j > e; j--) { 31 | d = j - e - 1; 32 | if(lengths[j] == d) { 33 | pallen = d; 34 | found = 1; 35 | break; 36 | } 37 | lengths[k++] = (d < lengths[j]? d : lengths[j]); 38 | } 39 | if(!found) { pallen = 1; i++; } 40 | } 41 | lengths[k++] = pallen; 42 | total = (len << 1) - lengths[k-1]; 43 | strncpy(buff + len, buff, total - len); buff[total] = 0; 44 | reverse(buff + len, buff + total); 45 | puts(buff); 46 | } 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /submited/BUREAU.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BUREAU 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int a[100001]; 12 | char ok[100001], buff[16000000], *ptr = buff; 13 | 14 | inline int nextint() { 15 | int ret = 0; 16 | while(*ptr < 33) ptr++; 17 | do { ret = ret*10 + *ptr++ - '0'; } while(*ptr > 32); 18 | return ret; 19 | } 20 | 21 | inline char *nextstr() { 22 | char *str; 23 | while(*ptr < 33) ptr++; 24 | for(str = ptr; *ptr > 32; ptr++); 25 | return str; 26 | } 27 | 28 | int main() { 29 | int test, n, i, f; 30 | fread(buff, 1, 16000000, stdin); 31 | test = nextint(); 32 | while(test--) { 33 | n = nextint(); 34 | for(i = 1; i <= n; i++) { 35 | if(*nextstr()=='c') a[i] = nextint(); 36 | else a[i] = 0; 37 | ok[i] = 1; 38 | } 39 | for(i = n; i; i--) 40 | if(a[i] && ok[i]) 41 | ok[a[i]] = 0; 42 | for(f = 0, i = 1; i <= n; i++) f += ok[i]; 43 | printf("%d\n", f); 44 | for(i = 1, f = 0; i <= n; i++) { 45 | if(ok[i]) { 46 | if(f++) printf(" "); 47 | printf("%d", i); 48 | } 49 | } 50 | printf("\n"); 51 | } 52 | return 0; 53 | } 54 | -------------------------------------------------------------------------------- /submited/CATM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CATM 4 | ALGO: geometro 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int main() { 13 | int R, C, test, mr, mc, ar, ac, br, bc; 14 | int mtop, mleft, mbot, mright, ctop, cleft, cbot, cright; 15 | scanf("%d%d%d", &R, &C, &test); 16 | while(test--) { 17 | scanf("%d%d%d%d%d%d", &mr, &mc, &ar, &ac, &br, &bc); 18 | if(mr >= ar && mr >= br) printf("YES\n"); 19 | else if(mr <= ar && mr <= br) printf("YES\n"); 20 | else if(mc >= ac && mc >= bc) printf("YES\n"); 21 | else if(mc <= ac && mc <= bc) printf("YES\n"); 22 | else { 23 | mtop = mr - 1; 24 | ctop = min(abs(1-ar)+abs(mc-ac), abs(1-br)+abs(mc-bc)); 25 | mleft = C - mc; 26 | cleft = min(abs(mr-ar)+abs(C-ac), abs(mr-br)+abs(C-bc)); 27 | mbot = R - mr; 28 | cbot = min(abs(R-ar)+abs(mc-ac), abs(R-br)+abs(mc-bc)); 29 | mright = mc - 1; 30 | cright = min(abs(mr-ar)+abs(1-ac), abs(mr-br)+abs(1-bc)); 31 | if(mtop < ctop || mbot < cbot || mleft < cleft || mright < cright) printf("YES\n"); 32 | else printf("NO\n"); 33 | } 34 | } 35 | return 0; 36 | } 37 | -------------------------------------------------------------------------------- /submited/HERDING.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: HERDING 4 | ALGO: flood fill 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | #define MAX 1000 11 | 12 | char grid[MAX][MAX+1]; 13 | int R, C, trap[MAX][MAX], count, last; 14 | 15 | void floodfill(int i, int j) 16 | { 17 | if(i>=0 && j>=0 && i last) last++; 44 | } 45 | /* 46 | for(int i=0; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | vector< int > A, B, T; 13 | vector< int >::iterator it; 14 | int N[50], b[50], n, m; 15 | 16 | bool construct(int init) { 17 | A.resize(n), B.resize(m); A[0] = init; 18 | for(int i = 0; i < m; i++) B[i] = b[i]; 19 | for(int i = 1; i < n; i++) { 20 | for(int j = 0; j < i - 1; j++) { 21 | it = find(B.begin(), B.end(), A[j] + A[i-1]); 22 | if(it == B.end()) return false; 23 | B.erase(it); 24 | } 25 | A[i] = B[0] - A[0]; 26 | if(A[i] < 0) return false; 27 | } 28 | return true; 29 | } 30 | 31 | int main() { 32 | for(int i = 1; i*(i-1) <= 100; i++) N[i * (i-1) / 2] = i; 33 | scanf("%d", &m); n = N[m]; 34 | for(int i = 0; i < m; i++) scanf("%d", b + i); 35 | for(int i = 1; i <= b[0]/2; i++) { 36 | if(construct(i)) { 37 | sort(A.begin(), A.end()); 38 | if(T.empty()) T = A; 39 | else if(A < T) T = A; 40 | } 41 | } 42 | printf("%d", T[0]); 43 | for(int i = 1; i < n; i++) printf(" %d", T[i]); 44 | printf("\n"); 45 | return 0; 46 | } 47 | -------------------------------------------------------------------------------- /submited/MDIGITS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MDIGITS 4 | ALGO: recursion 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | 11 | int p10[] = {1,10,100,1000,10000,100000,1000000,10000000,100000000}; 12 | 13 | void calc(int num, int p, int cnt[], int f) 14 | { 15 | int n, i; 16 | n = num / p10[p]; 17 | for(i=0;ib) 34 | { 35 | c = a; 36 | a = b; 37 | b = c; 38 | } 39 | a--; 40 | int cnt1[10] = {1}; 41 | int cnt2[10] = {1}; 42 | if(a) 43 | { 44 | p1 = (int)floor(log10(a)); 45 | calc(a, p1, cnt1, 1); 46 | } 47 | p2 = (int)floor(log10(b)); 48 | calc(b, p2, cnt2, 1); 49 | printf("%d",cnt2[0]-cnt1[0]); 50 | for(i=1; i<10; i++) printf(" %d",cnt2[i]-cnt1[i]); 51 | printf("\n"); 52 | } 53 | return 0; 54 | } 55 | -------------------------------------------------------------------------------- /submited/NG0FRCTN.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NG0FRCTN 4 | ALGO: binary search 5 | */ 6 | 7 | #define u64 unsigned long long 8 | #define _CRT_SECURE_NO_WARNINGS 1 9 | #define DEBUG if(0) 10 | 11 | #include 12 | using namespace std; 13 | 14 | void search(u64 L, u64 R, u64 T, u64 &p, u64 &q) 15 | { 16 | u64 M; 17 | while(L> 1; 20 | if(T<=M) 21 | { 22 | q = p + q; 23 | R = M; 24 | } 25 | else 26 | { 27 | p = p + q; 28 | L = M + 1; 29 | } 30 | } 31 | } 32 | 33 | int main() 34 | { 35 | u64 n, a[40] = {1}, total, target, p, q; 36 | int k, i; 37 | for(k=1; a[k-1] < 10000000000ULL; k++) 38 | a[k] = a[k-1] + (1ULL << k); 39 | DEBUG for(i=0; i 28 | 29 | + Input Title 30 | + Write link problem in comment box 31 | + Press Submit New Issue 32 | 33 | -------------------------------------------------------------------------------- /submited/BMJ.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: BMJ 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | int main() { 12 | int n, x, y, r; 13 | while(scanf("%d",&n)==1) { 14 | r = x = (-3+(int)sqrt(12*n-3))/6, y = 0; 15 | n -= 3*r*r + 3*r + 1; 16 | if(n==0) { 17 | printf("%d %d\n",x,y); 18 | continue; 19 | } 20 | n--, y++; 21 | if(n==0) { 22 | printf("%d %d\n",x,y); 23 | continue; 24 | } 25 | if(n <= r) { 26 | x -= n, y += n; 27 | printf("%d %d\n",x,y); 28 | continue; 29 | } 30 | x = 0, y = r+1, n -= r; 31 | if(n <= r+1) { 32 | x -= n; 33 | printf("%d %d\n",x,y); 34 | continue; 35 | } 36 | x = -r-1, n -= r+1; 37 | if(n <= r+1) { 38 | y -= n; 39 | printf("%d %d\n",x,y); 40 | continue; 41 | } 42 | y = 0, n -= r+1; 43 | if(n <= r+1) { 44 | x += n, y -= n; 45 | printf("%d %d\n",x,y); 46 | continue; 47 | } 48 | x = 0, y = -r-1, n -= r+1; 49 | if(n <= r+1) { 50 | x += n; 51 | printf("%d %d\n",x,y); 52 | continue; 53 | } 54 | x = r+1, n -= r+1; 55 | y += n; 56 | printf("%d %d\n",x,y); 57 | } 58 | return 0; 59 | } 60 | -------------------------------------------------------------------------------- /submited/CSTREET.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: CSTREET 4 | ALGO: kruskal 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define F first 13 | #define S second 14 | #define pii pair< int, int > 15 | #define pip pair< int, pii > 16 | #define MAX 10001 17 | #define i64 long long 18 | 19 | vector< pip > GRAPH; 20 | int parent[MAX]; 21 | 22 | int findset(int x) { 23 | if(x!=parent[x]) parent[x] = findset(parent[x]); 24 | return parent[x]; 25 | } 26 | 27 | int main() 28 | { 29 | int i, u, v, w, N, E, t; 30 | i64 total, price; 31 | scanf("%d", &t); 32 | while(t--) { 33 | scanf("%lld%d%d", &price, &N, &E); 34 | for(i=1; i<=N; i++) parent[i] = i; 35 | GRAPH.resize(E); 36 | for(i=0; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | double a, b, c; 13 | 14 | double side(double L, double R) { 15 | double M, at, a1, a2, a3, s; 16 | int i = 34; 17 | while(i--) { 18 | M = (L + R) / 2.0; 19 | at = M * M * sqrt(3.0) / 4.0; 20 | s = (M + a + b) / 2.0; a1 = sqrt( s * (s-a) * (s-b) * (s-M) ); 21 | s = (M + b + c) / 2.0; a2 = sqrt( s * (s-b) * (s-c) * (s-M) ); 22 | s = (M + c + a) / 2.0; a3 = sqrt( s * (s-c) * (s-a) * (s-M) ); 23 | if(at > a1 + a2 + a3) R = M; 24 | else L = M; 25 | } 26 | return M; 27 | } 28 | 29 | template< class T > T tmax(T x, T y, T z) { 30 | return max( x, max( y, z) ); 31 | } 32 | 33 | template< class T > T tmin(T x, T y, T z) { 34 | return min( x, min( y, z) ); 35 | } 36 | 37 | int main() { 38 | double x; 39 | int t; 40 | scanf("%d", &t); 41 | while(t--) { 42 | scanf("%lf%lf%lf", &a, &b, &c); 43 | x = side(tmax(fabs(a-b), fabs(b-c), fabs(c-a)), tmin(a+b, b+c, c+a)); 44 | printf("%.2lf\n", sqrt(3.0)/4.0 * x * x + 1e-10); 45 | } 46 | return 0; 47 | } 48 | 49 | -------------------------------------------------------------------------------- /submited/MAJSTOR.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: MAJSTOR 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | inline int add(char s, char f) { 9 | int t = 0; 10 | if(s=='R' && f=='R') t++; 11 | else if(s=='R' && f=='S') t+=2; 12 | else if(s=='P' && f=='P') t++; 13 | else if(s=='P' && f=='R') t+=2; 14 | else if(s=='S' && f=='S') t++; 15 | else if(s=='S' && f=='P') t+=2; 16 | return t; 17 | } 18 | int score(char *sven, char *frnd, int r) { 19 | int i, t; 20 | for(i = t = 0; i < r; i++) t += add(sven[i], frnd[i]); 21 | return t; 22 | } 23 | int main() { 24 | char sven[52], cards[] = "RPS", frnd[52][52]; 25 | int n, r, i, j, k, exact = 0, known, mxknown = 0; 26 | scanf("%d%s%d", &r, sven, &n); 27 | for(i = 0; i < n; i++) { 28 | scanf("%s", frnd[i]); 29 | exact += score(sven, frnd[i], r); 30 | } 31 | printf("%d\n", exact); 32 | exact = 0; 33 | for(i = 0; i < r; i++) { 34 | mxknown = 0; 35 | for(j = 0; j < 3; j++) { 36 | known = 0; 37 | for(k = 0; k < n; k++) { 38 | known += add(cards[j], frnd[k][i]); 39 | } 40 | if(known > mxknown) mxknown = known; 41 | } 42 | exact += mxknown; 43 | } 44 | printf("%d\n", exact); 45 | return 0; 46 | } -------------------------------------------------------------------------------- /submited/NY10B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NY10B 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | void d2b(int b, int n, int* num, int &len) { 11 | len = 0; 12 | while(n) { 13 | num[len++] = n % b; 14 | n /= b; 15 | } 16 | } 17 | 18 | void b2d(int b, int *num, int len, int &n) { 19 | int m , i; 20 | n = 0; 21 | for(m = 1, n = i = 0; i < len; i++) { 22 | n += num[i] * m; 23 | m *= b; 24 | } 25 | } 26 | 27 | void nim(int *num1, int &len1, int *num2, int len2, int b) { 28 | int i, x, y, len = len1>len2?len1:len2; 29 | for(i = 0; i < len; i++) { 30 | x = i < len1? num1[i]:0; 31 | y = i < len2? num2[i]:0; 32 | num1[i] = (x + y) % b; 33 | } 34 | len1 = i; 35 | } 36 | 37 | int nimsum(int b, int x, int y) { 38 | int num1[32], num2[32], len1, len2, ret; 39 | d2b(b, x, num1, len1); 40 | d2b(b, y, num2, len2); 41 | nim(num1, len1, num2, len2, b); 42 | b2d(b, num1, len1, ret); 43 | return ret; 44 | } 45 | 46 | int main() { 47 | int test, cs, b, x, y; 48 | scanf("%d", &test); 49 | while(test--) { 50 | scanf("%d %d %d %d", &cs, &b, &x, &y); 51 | printf("%d %d\n", cs, nimsum(b, x, y)); 52 | } 53 | return 0; 54 | } -------------------------------------------------------------------------------- /submited/PT07Y.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: PT07Y 4 | ALGO: breadth first search 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | #define MAX 10001 13 | 14 | int N, E; 15 | vector< int > G[MAX]; 16 | bool flag[MAX]; 17 | int pre[MAX]; 18 | 19 | bool bfs(int s) 20 | { 21 | int i, u, v, sz; 22 | queue< int > Q; 23 | Q.push(s); 24 | flag[s] = 1; 25 | while(!Q.empty()) 26 | { 27 | u = Q.front(); 28 | Q.pop(); 29 | sz = G[u].size(); 30 | for(i=0; i 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | int ord[6][3], a[3], b[3], c[3]; 13 | char flag[53]; 14 | 15 | bool wins() { 16 | int i, j, k, cnt; 17 | for(i = 0; i < 6; i++) { 18 | for(j = 0; j < 6; j++) { 19 | for(k = cnt = 0; k < 3; k++) { 20 | if(a[ord[i][k]] > c[ord[j][k]]) cnt++; 21 | } 22 | if(cnt > 1) return true; 23 | } 24 | } 25 | return false; 26 | } 27 | 28 | int main() { 29 | int i, j; 30 | i = 0, a[0] = 0, a[1] = 1, a[2] = 2; 31 | do { 32 | for(j = 0; j < 3; j++) ord[i][j] = a[j]; 33 | i++; 34 | } while(next_permutation(a, a + 3)); 35 | while(scanf("%d%d%d%d%d", &a[0], &a[1], &a[2], &b[0], &b[1])==5) { 36 | if(!(a[0] + a[1] + a[2] + b[0] + b[1])) break; 37 | memset(flag, 0, sizeof flag); 38 | flag[a[0]] = flag[a[1]] = flag[a[2]] = flag[b[0]] = flag[b[1]] = 1; 39 | for(i = 1; i <= 52; i++) { 40 | if(flag[i]) continue; 41 | c[0] = b[0], c[1] = b[1], c[2] = i; 42 | if(!wins()) break; 43 | } 44 | if(i > 52) printf("-1\n"); 45 | else printf("%d\n", i); 46 | } 47 | return 0; 48 | } 49 | -------------------------------------------------------------------------------- /submited/SEQ6.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: SEQ6 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | #define LEN 480 12 | #define MAX 3364 13 | #define LMT 58 14 | #define ifc(x) (flag[x>>6]&(1<<((x>>1)&31))) 15 | #define isc(x) (flag[x>>6]|=(1<<((x>>1)&31))) 16 | 17 | int flag[MAX>>6], primes[LEN], total; 18 | 19 | void sieve() 20 | { 21 | int i, j, k; 22 | for(i=3; i>= 1; 36 | root = (int)sqrt((double)n); 37 | for(i=0,ret=1; primes[i]<=root; i++) 38 | { 39 | if(n % primes[i] == 0) 40 | { 41 | cnt = 0; 42 | while(n % primes[i] == 0) 43 | { 44 | n /= primes[i]; 45 | cnt++; 46 | } 47 | ret *= ++cnt; 48 | root = (int)sqrt((double)n); 49 | } 50 | } 51 | if(n>2) ret <<= 1; 52 | return ret; 53 | } 54 | 55 | int main() 56 | { 57 | int n; 58 | sieve(); 59 | while(scanf("%d", &n)==1 && n) printf("%d\n", d(n)<<1); 60 | return 0; 61 | } 62 | -------------------------------------------------------------------------------- /submited/C1TABOVI.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: C1TABOVI 4 | ALGO: recursion 5 | */ 6 | 7 | #include 8 | #include 9 | #include 10 | using namespace std; 11 | 12 | const int INF = 0x7f7f7f7f; 13 | int cnt, a[1000]; 14 | 15 | void equalize(int s, int e, int op) { 16 | int m, i, j; 17 | if(op==-1) { 18 | m = -INF; 19 | for(i = s; i <= e; i++) m = max(m, a[i]); 20 | for(i = s; i <= e; i++) a[i] -= m; 21 | cnt += -m; 22 | } 23 | else if(op==1) { 24 | m = INF; 25 | for(i = s; i <= e; i++) m = min(m, a[i]); 26 | for(i = s; i <= e; i++) a[i] -= m; 27 | cnt += m; 28 | } 29 | for(i = s; i <= e; i++) { 30 | if(!a[i]) continue; 31 | if(a[i] < 0) { 32 | j = i; 33 | while(j <= e && a[j] < 0) j++; 34 | j--; 35 | equalize(i, j, -1); 36 | } 37 | else { 38 | j = i; 39 | while(j <= e && a[j] > 0) j++; 40 | j--; 41 | equalize(i, j, 1); 42 | } 43 | i = j; 44 | } 45 | } 46 | 47 | int main() { 48 | int b, n, i; 49 | scanf("%d", &n); 50 | for(i = 0; i < n; i++) scanf("%d", &a[i]); 51 | for(i = 0; i < n; i++) { 52 | scanf("%d", &b); 53 | a[i] -= b; 54 | } 55 | cnt = 0; 56 | equalize(0, n-1, 0); 57 | printf("%d\n", cnt); 58 | return 0; 59 | } -------------------------------------------------------------------------------- /submited/NY10D.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASL: NY10D 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | using namespace std; 9 | 10 | int buff[1048576]; 11 | 12 | inline int h2d(char ch) { 13 | if(ch>'9') return ch-'A'+10; 14 | return ch-'0'; 15 | } 16 | 17 | inline int getbyte() { 18 | char ch; int byte = 0; 19 | do{ch=getchar();}while(ch<'0'); 20 | byte = (byte<<4) | h2d(ch); 21 | do{ch=getchar();}while(ch<'0'); 22 | byte = (byte<<4) | h2d(ch); 23 | return byte; 24 | } 25 | 26 | int main() { 27 | int test, cs, ebytes, i, cnt, chr, msb = 0x80, len; 28 | scanf("%d", &test); 29 | while(test--) { 30 | scanf("%d %d", &cs, &ebytes); 31 | for(i = len = 0; i < ebytes;) { 32 | cnt = getbyte(); i++; 33 | if(cnt & msb) { 34 | cnt &= (msb-1); 35 | cnt += 3; 36 | chr = getbyte(); i++; 37 | while(cnt--) { 38 | buff[len++] = chr; 39 | } 40 | } 41 | else { 42 | cnt += 1; 43 | while(cnt--) { 44 | buff[len++] = getbyte(); 45 | i++; 46 | } 47 | } 48 | } 49 | printf("%d %d\n", cs, len); 50 | for(i = 0; i < len; i++) { 51 | if(i && i%40==0) printf("\n"); 52 | printf("%02X", buff[i]); 53 | } 54 | printf("\n"); 55 | } 56 | return 0; 57 | } -------------------------------------------------------------------------------- /submited/NSYSTEM.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: NSYSTEM 4 | ALGO: ad-hoc 5 | */ 6 | 7 | #define _CRT_SECURE_NO_WARNINGS 1 8 | 9 | #include 10 | #include 11 | using namespace std; 12 | 13 | char num1[20], num2[20], res[20], alp[5] = "ixcm"; 14 | int cm[26]; 15 | 16 | int genN(char *s) 17 | { 18 | int i, n; 19 | for(i=n=0; s[i]; ) 20 | { 21 | if(s[i]>'9') 22 | { 23 | n += cm[s[i]-'a']; 24 | i++; 25 | } 26 | else 27 | { 28 | n += cm[s[i+1]-'a']*(s[i]-'0'); 29 | i += 2; 30 | } 31 | } 32 | return n; 33 | } 34 | 35 | void genS(char *s, int n) 36 | { 37 | int k = 0, m, p = 0; 38 | while(n) 39 | { 40 | m = n%10; 41 | if(m==1) s[k++] = alp[p]; 42 | else if(m>1) s[k++] = alp[p], s[k++] = m+'0'; 43 | p++; 44 | n /= 10; 45 | } 46 | res[k] = 0; 47 | reverse(res, res+k); 48 | } 49 | 50 | int main() 51 | { 52 | int t, n1, n2; 53 | cm['m'-'a'] = 1000; 54 | cm['c'-'a'] = 100; 55 | cm['x'-'a'] = 10; 56 | cm['i'-'a'] = 1; 57 | //freopen("in.txt", "r", stdin); 58 | scanf("%d", &t); 59 | while(t--) 60 | { 61 | scanf("%s %s", num1, num2); 62 | n1 = genN(num1); 63 | n2 = genN(num2); 64 | genS(res, n1+n2); 65 | printf("%s\n", res); 66 | } 67 | return 0; 68 | } 69 | -------------------------------------------------------------------------------- /submited/ACS.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: ACS 4 | ALGO: simulation 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | #define MAXR 1234 12 | #define MAXC 5678 13 | 14 | int R[MAXR+1], C[MAXC+1], cR[MAXR+1], cC[MAXC+1]; 15 | 16 | inline int m(int x, int y) 17 | { 18 | return (R[x]-1)*MAXC + C[y]; 19 | } 20 | 21 | inline void getxy(int w, int &x, int &y) 22 | { 23 | int p = (w+MAXC-1) / MAXC; 24 | int q = (w-1) % MAXC + 1; 25 | x = cR[p]; 26 | y = cC[q]; 27 | } 28 | 29 | int main() 30 | { 31 | int i, x, y, w; 32 | char s[5]; 33 | for(i=1; i<=1234; i++) R[i] = cR[i] = i; 34 | for(i=1; i<=5678; i++) C[i] = cC[i] = i; 35 | while(scanf("%s", s)==1) 36 | { 37 | switch(s[0]) 38 | { 39 | case 'R': 40 | scanf("%d %d", &x, &y); 41 | swap(R[x], R[y]); 42 | cR[R[x]] = x; 43 | cR[R[y]] = y; 44 | break; 45 | case 'C': 46 | scanf("%d %d", &x, &y); 47 | swap(C[x], C[y]); 48 | cC[C[x]] = x; 49 | cC[C[y]] = y; 50 | break; 51 | case 'Q': 52 | scanf("%d %d", &x, &y); 53 | printf("%d\n", m(x, y)); 54 | break; 55 | case 'W': 56 | scanf("%d", &w); 57 | getxy(w, x, y); 58 | printf("%d %d\n", x, y); 59 | } 60 | } 61 | return 0; 62 | } 63 | -------------------------------------------------------------------------------- /submited/AMR10C.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AMR10C 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | #include 9 | using namespace std; 10 | 11 | const int MAX = 1024; 12 | const int LMT = 32; 13 | const int LEN = 200; 14 | 15 | int total; 16 | int flag[MAX>>6], primes[LEN]; 17 | 18 | #define ifc(i) (flag[i>>6]&(1<<((i>>1)&31))) 19 | #define isc(i) (flag[i>>6]|=(1<<((i>>1)&31))) 20 | 21 | void sieve() { 22 | int i, j, k; 23 | total = 1; 24 | primes[0] = 2; 25 | for(i = 3; i < MAX; i+=2) { 26 | if(!ifc(i)) { 27 | primes[total++] = i; 28 | if(i < 32) for(j=i*i, k=i<<1; j < MAX; j+=k) isc(j); 29 | } 30 | } 31 | } 32 | 33 | int factor(int n) { 34 | int i, cnt, ret = 0; 35 | int rt = (int)sqrt((double)n); 36 | for(i = 0; primes[i] <= rt; i++) { 37 | if(n % primes[i] == 0) { 38 | cnt = 0; 39 | while(n % primes[i] == 0) { 40 | cnt++; 41 | n /= primes[i]; 42 | } 43 | rt = (int)sqrt((double)n); 44 | if(cnt > ret) ret = cnt; 45 | } 46 | } 47 | if(n > 1 && 1 > ret) ret = 1; 48 | return ret; 49 | } 50 | 51 | int main() { 52 | sieve(); 53 | int t, n; 54 | scanf("%d", &t); 55 | while(t--) { 56 | scanf("%d", &n); 57 | printf("%d\n", factor(n)); 58 | } 59 | return 0; 60 | } 61 | -------------------------------------------------------------------------------- /submited/AE2B.cpp: -------------------------------------------------------------------------------- 1 | /* 2 | USER: hoangmanhkhiem 3 | TASK: AE2B 4 | ALGO: math 5 | */ 6 | 7 | #include 8 | 9 | const int BUFF = 1280000; 10 | static char buff[BUFF], *ptr; 11 | 12 | inline int gcd(int a, int b) { 13 | while(b) b ^= a ^= b ^= a %= b; 14 | return a; 15 | } 16 | 17 | inline int nextInt() { 18 | while(*ptr != '-' && (*ptr < '0' || *ptr > '9')) ptr++; 19 | int minus = 0, ret = 0; 20 | if(*ptr=='-') minus = 1, ptr++; 21 | while(*ptr >= '0' && *ptr <= '9') ret = ret * 10 + *ptr - '0', ptr++; 22 | if(minus) ret = -ret; 23 | return ret; 24 | } 25 | 26 | int main() { 27 | int test, k, n, dx, dy, x1, y1, x2, y2, g; 28 | fread(buff, BUFF, 1, stdin); ptr = buff; 29 | test = nextInt(); 30 | while(test--) { 31 | k = nextInt(); 32 | n = nextInt(); 33 | x1 = nextInt(); 34 | y1 = nextInt(); 35 | x2 = nextInt(); 36 | y2 = nextInt(); 37 | g = gcd(k, n); 38 | dx = x1 > x2? x1 - x2 : x2 - x1; 39 | dy = y1 > y2? y1 - y2 : y2 - y1; 40 | if(g > 1) { 41 | if(dx % g || dy % g) { 42 | puts("NIE"); 43 | continue; 44 | } 45 | k /= g, n /= g, dx /= g, dy /= g; 46 | } 47 | if(!(k&1) || !(n&1)) puts("TAK"); 48 | else if((dx&1) + (dy&1) == 1) puts("NIE"); 49 | else puts("TAK"); 50 | } 51 | return 0; 52 | } --------------------------------------------------------------------------------