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

Code mẫu của flashmt

const fi='';
      fo='';
      maxn=350;
      maxp=70;
var n:longint;
    p:array[0..maxp] of longint;
    f:array[0..maxn,0..maxp] of qword;
    re:array[1..maxn] of qword;

procedure rf;
begin
     assign(input,fi); reset(input);
     assign(OUTput,fo); rewrite(output);
end;

procedure prime;
var i,j,t:longint;
begin
     for i:=2 to maxn do
     begin
          t:=0;
          for j:=2 to trunc(sqrt(i)) do
              if i mod j=0 then inc(t);
          if t=0 then
          begin
               inc(p[0]); p[p[0]]:=i;
          end;
     end;
end;

function max(x,y:qword):qword;
begin
     if x>y then max:=x else max:=y;
end;

procedure pr;
var i,j:longint; t:qword;
begin
     prime;
     for i:=0 to maxn do f[i,0]:=1;
     for i:=0 to maxp do f[0,i]:=1;
     for i:=1 to maxn do
         for j:=1 to maxp do
         begin
              if (p[j]>i) or (p[j]=0) then break;
              f[i,j]:=max(f[i-1,j],f[i,j-1]);
              t:=p[j];
              while t<=i do
              begin
                   f[i,j]:=max(f[i,j],f[i-t,j-1]*t);
                   t:=t*p[j];
              end;
              if f[i,j]>re[i] then re[i]:=f[i,j];
         end;
end;

procedure wf;
var i,t:longint;
begin
  readln(t);
  for i:=1 to t do
  begin
   readln(n); writeln(re[n]);
  end;
     close(input);
     close(output);
end;

begin
     rf;
     pr;
     wf;
end.

Code mẫu của happyboy99x

#include<cstdio>
#include<cstring>
#include<vector>
#include<algorithm>
using namespace std;

const int N = 350, M = 70;
bool pr[N+1];
vector<int> p;
long long f[N+1][M+1];

void eratos() {
    memset(pr, -1, sizeof pr); pr[0] = pr[1] = 0;
    for(int i = 2; i * i <= N; ++i) if(pr[i])
        for(int j = i + i; j <= N; j += i) pr[j] = 0;
    for(int i = 0; i <= N; ++i) if(pr[i]) p.push_back(i);
}

void solve() {
    for(int j = 0; j <= M; ++j) f[0][j] = 1;
    for(int i = 1; i <= N; ++i) 
        for(int j = 1; j <= M; ++j) {
            f[i][j] = max(f[i][j-1], f[i-1][j]);
            for(int d = p[j-1]; i >= d; d *= p[j-1]) f[i][j] = max(f[i][j], f[i-d][j-1] * d);
        }
}

int main() {
    eratos();
    solve();
    int tc, n; scanf("%d", &tc);
    while(tc--) {
        scanf("%d", &n);
        if(n <= N-3) printf("%lld\n", f[n][M]);
        else puts("14757354782123793840");
    }
    return 0;
}

Code mẫu của ladpro98

#include <bits/stdc++.h>
#define qword unsigned long long

const int N = 360;

using namespace std;

bool isPrime[N];
int P[N];
int nPrime;
qword dp[N][N];

void sieve() {
    memset(isPrime, 1, sizeof(isPrime));
    for (int i = 2; i * i < N; ++i) if (isPrime[i]) {
        for (int j = i * i; j < N; j += i)
            isPrime[j] = 0;
    }
    for (int i = 2; i < N; ++i)
        if (isPrime[i]) P[++nPrime] = i;
}

void update(int nxtI, int nxtJ, int i, int j, qword target) {
    if (dp[nxtI][nxtJ] < target)
        dp[nxtI][nxtJ] = target;
}

void preCalc() {
    for (int i = 0; i < N; ++i) dp[i][0] = 1;
    for (int i = 1; i <= nPrime; ++i) dp[P[i]][i] = P[i];
    for (int i = 0; i < N; ++i) for (int j = 0; j < nPrime && P[j] <= i; ++j) {
        update(i, j + 1, i, j, dp[i][j]);
        for (int p = 1; i + p < N; p *= P[j + 1])
            update(i + p, j + 1, i, j, dp[i][j] * p);
    }
}

void solve() {
    int n;
    cin >> n;
    qword ans = 0;
    for (int i = 0; i <= nPrime && P[i] <= n; ++i)
        ans = max(ans, dp[n][i]);
    cout << ans << '\n';
}

int main() {
    ios::sync_with_stdio(0); cin.tie(0);
    sieve();
    preCalc();
    int nTest;
    cin >> nTest;
    while (nTest--) solve();
    return 0;
}

Code mẫu của RR

const f:array[1..350] of qword=(
1,2,3,4,6,6,12,15,20,30,
30,60,60,84,105,140,210,210,420,420,
420,420,840,840,1260,1260,1540,2310,2520,4620,
4620,5460,5460,9240,9240,13860,13860,16380,16380,27720,
30030,32760,60060,60060,60060,60060,120120,120120,180180,180180,
180180,180180,360360,360360,360360,360360,471240,510510,556920,1021020,
1021020,1141140,1141140,2042040,2042040,3063060,3063060,3423420,3423420,6126120,
6126120,6846840,6846840,6846840,6846840,8953560,9699690,12252240,19399380,19399380,
19399380,19399380,38798760,38798760,58198140,58198140,58198140,58198140,116396280,116396280,
116396280,116396280,140900760,140900760,157477320,157477320,232792560,232792560,232792560,232792560,
281801520,446185740,446185740,446185740,446185740,892371480,892371480,1338557220,1338557220,1338557220,
1338557220,2677114440,2677114440,2677114440,2677114440,2677114440,2677114440,3375492120,3375492120,5354228880,
5354228880,5354228880,5354228880,5354228880,5354228880,6750984240,6750984240,7216569360,7216569360,8172244080,
12939386460,13385572200,13831757940,13831757940,25878772920,25878772920,38818159380,38818159380,41495273820,41495273820,
77636318760,77636318760,82990547640,82990547640,82990547640,82990547640,82990547640,82990547640,155272637520,155272637520,
165981095280,165981095280,165981095280,165981095280,165981095280,165981095280,209280511440,209280511440,232908956280,232908956280,
388181593800,401120980260,414952738200,414952738200,414952738200,802241960520,802241960520,1203362940780,1203362940780,1203362940780,
1203362940780,2406725881560,2406725881560,2406725881560,2406725881560,2406725881560,2406725881560,2872543794120,2872543794120,4813451763120,
4813451763120,4813451763120,4813451763120,4813451763120,4813451763120,5745087588240,5745087588240,6141300525360,6141300525360,7220177644680,
7220177644680,12033629407800,12033629407800,12033629407800,12033629407800,12033629407800,12033629407800,14440355289360,14841476269620,24067258815600,
24067258815600,24067258815600,29682952539240,29682952539240,44524428808860,44524428808860,44524428808860,44524428808860,89048857617720,89048857617720,
89048857617720,89048857617720,98675761143960,98675761143960,103489212907080,103489212907080,178097715235440,178097715235440,178097715235440,178097715235440,
197351522287920,197351522287920,206978425814160,206978425814160,222622144044300,222622144044300,267146572853160,267146572853160,445244288088600,445244288088600,
445244288088600,445244288088600,493378805719800,493378805719800,534293145706320,534293145706320,890488576177200,890488576177200,890488576177200,890488576177200,
986757611439600,986757611439600,1034892129070800,1217001054108840,1217001054108840,1825501581163260,1825501581163260,1914550438780980,1914550438780980,3651003162326520,
3651003162326520,3829100877561960,3829100877561960,3829100877561960,3829100877561960,4243057729190280,4243057729190280,7302006324653040,7302006324653040,7658201755123920,
7658201755123920,7658201755123920,7658201755123920,8486115458380560,8486115458380560,9127507905816300,9127507905816300,10953009486979560,10953009486979560,18255015811632600,
18255015811632600,19145504387809800,19145504387809800,19145504387809800,19145504387809800,21906018973959120,21906018973959120,36510031623265200,36510031623265200,38291008775619600,
38291008775619600,38291008775619600,38291008775619600,42430577291902800,42430577291902800,42430577291902800,52331045326680120,54765047434897800,78496567990020180,78496567990020180,
78496567990020180,78496567990020180,156993135980040360,156993135980040360,156993135980040360,156993135980040360,171597148629346440,171597148629346440,179967741245412120,179967741245412120,
313986271960080720,313986271960080720,313986271960080720,313986271960080720,343194297258692880,343194297258692880,359935482490824240,359935482490824240,392482839950100900,392482839950100900,
470979407940121080,470979407940121080,784965679900201800,784965679900201800,784965679900201800,784965679900201800,857985743146732200,857985743146732200,941958815880242160,941958815880242160,
1569931359800403600,1569931359800403600,1569931359800403600,1569931359800403600,1715971486293464400,1715971486293464400,1799677412454121200,1799677412454121200,1799677412454121200,1799677412454121200,
2354897039700605400,2354897039700605400,2354897039700605400,2459559130353965640,2573957229440196600,3689338695530948460,3689338695530948460,3689338695530948460,4709794079401210800,7378677391061896920,
7378677391061896920,7378677391061896920,7378677391061896920,7378677391061896920,7378677391061896920,8320636206942139080,8320636206942139080,14757354782123793840,14757354782123793840,14757354782123793840);
var
test,n:longint;
begin
read(test);
for test:=1 to test do
begin
read(n);
writeln(f[n]);
end;
end.

Code mẫu của hieult

#include <stdio.h>
#include <math.h>
//#include <conio.h>

int main()
{
    unsigned long long f[351][72];
    int u[80],t=1;
    u[1] = 2;
    for(int i = 3;i<=355;i++)
    {
        int flag = 0;
        for(int j = 1;;j++)
        {
            if(u[j]>sqrt(i))
                break;
            else if(i%u[j]==0)
            {
                flag=1;
                break;
            }
        }
        if(flag==0)
        {
            t++;
            u[t]=i;
        }
    }
    //printf("%d",u[t]);
    for(int i = 1;i<=350;i++)
        for(int j = 0;j<=t;j++)
            f[i][j]=0;
    for(int j = 0;j<=t;j++)
       f[0][j] = 1;

    for(int i = 1;i<=350;i++)
    {
        for(int j = 1;;j++)
        {
            if(u[j]>i)
               break;
            else
            {
                unsigned long long max = 0;
                if(f[i-1][j]> max )
                    max = f[i-1][j];
                if(f[i][j-1]>max)
                    max = f[i][j-1];
                int t= u[j];
                while(i-t>=0)
                {
                    if(f[i-t][j-1]*t>max)
                       max = f[i-t][j-1]*t;
                    t=t*u[j];
                }
                f[i][j]=max;
            }

        }
    }

    int test,n;
    scanf("%d",&test);
    for(int ii = 1;ii<=test;ii++)
    {
        scanf("%d",&n);
        if(n==1) printf("1\n");
        else
        {
        unsigned long long Kq = 0;
        for(int i = 1;i<=70;i++)
        {
           if(f[n][i]>Kq)
               Kq=f[n][i];
        }
        printf("%llu\n",Kq);
        }
    }
    //getch();
}

Code mẫu của ll931110

{$MODE DELPHI,N+}
program CTNOWN;
const
  input  = '';
  output = '';
  maxn = 350;
  maxk = 500;
  maxd = 3;
  base = 1000000;
  maxv = 1000000;
var
  F: array[0..maxn,0..maxk] of extended;
  trace: array[0..maxn,0..maxk] of integer;
  d: array[1..maxd] of integer;
  list: array[1..maxk] of integer;
  fi,fo: text;
  n,nlist: integer;
  i,nTest: integer;

procedure openfile;
begin
  assign(fi, input);
    reset(fi);

  assign(fo, output);
    rewrite(fo);
end;

function prime(x: integer): boolean;
var
  i: integer;
begin
  for i := 2 to trunc(sqrt(x)) do if x mod i = 0 then exit(false);
  prime := true;
end;

procedure solve;
var
  i,j,t: integer;
begin
  nlist := 0;
  for i := 2 to maxn do if prime(i) then
    begin
      inc(nlist);
      list[nlist] := i;
    end;

  fillchar(F, sizeof(F), 0);
  for j := 1 to nlist do
    for i := 2 to maxn do
      begin
       F[i,j] := F[i,j - 1];
       trace[i,j] := i;

       t := list[j];
       while i >= t do
         begin
           if F[i,j] < F[i - t,j - 1] + ln(t) then
             begin
               F[i,j] := F[i - t,j - 1] + ln(t);
               trace[i,j] := i - t;
             end;
           t := t * list[j];
         end;
      end;
end;

procedure mul(x: integer);
var
  i: integer;
begin
  if x = 0 then exit;
  for i := 1 to maxd do d[i] := d[i] * x;
  for i := 1 to maxd - 1 do if d[i] >= base then
    begin
      d[i + 1] := d[i + 1] + d[i] div base;
      d[i] := d[i] mod base;
    end;
end;

procedure printresult;
var
  i,u,k,s,tmp: integer;
  st: string;
  max: extended;
begin
  readln(fi, n);
  max := 0;
  u := 0;
  for i := 1 to maxk do
    if max < F[n,i] then
      begin
        max := F[n,i];
        u := i;
      end;

  fillchar(d, sizeof(d), 0);
  d[1] := 1;
  s := n;

  for k := u downto 1 do
    begin
      tmp := trace[s,k];
      mul(s - tmp);
      s := tmp;
    end;

  s := maxd;
  while d[s] = 0 do dec(s);

  write(fo, d[s]);
  for i := s - 1 downto 1 do
    begin
      str(d[i],st);
      for k := 1 to 6 - length(st) do write(fo, 0);
      write(fo, st);
    end;
  writeln(fo);
end;

procedure closefile;
begin
  close(fo);
  close(fi);
end;

begin
  openfile;
  solve;

  readln(fi, nTest);
  for i := 1 to nTest do printresult;

  closefile;
end.

Code mẫu của khuc_tuan

#include <iostream>
#include <cstdio>
using namespace std;


const int COSO = 10000;

struct BigInt {
    int a[20];
    void assign(int x) {
        a[0] = x;
        for(int i=1;i<20;++i)
            a[i] = 0;
    }
    void viet() {
        for(int i=20-1;i>=0;--i) 
            if(a[i] > 0) {
                printf("%d",a[i]);
                for(int j=i-1;j>=0;--j)
                    printf("%04d",a[j]);
                break;
            }
    }
    BigInt opMul(int x){
        BigInt b;
        int nho = 0;
        for(int i=0;i<20;++i) {
            nho += a[i] * x;
            b.a[i] = nho % COSO;
            nho /= COSO;
        }
        return b;
    }
    int opCmp(BigInt b) {
        for(int i=20-1;i>=0;--i) {
            if(a[i] < b.a[i]) return -1;
            if(a[i] > b.a[i]) return 1;
        }   
        return 0;
    }
};

const int MAXN = 355;

BigInt F[MAXN][300];

int prime[1000];

int main() {

    int nprime = 0;
    for(int i=2;i<300;++i) {
        bool isprime = true;
        for(int j=2;j*j<=i;++j) 
            if(i % j == 0) {
                isprime = false;
                break;
            }
        if(isprime)
            prime[nprime++] = i;
    }   

    for(int i=0;i<MAXN;++i) {
        if(i < 2) F[i][0].assign(1);
        else {
            int z = 2;
            while(2 * z <= i) z *= 2;
            F[i][0].assign(z);
        }
    }

    for(int p=1;p<nprime;++p) {
        for(int i=0;i<MAXN;++i) {
            F[i][p] = F[i][p-1];
            int z = prime[p];
            while(z <= i) {
                BigInt tmp = F[i-z][p-1] .opMul( z );
                if(F[i][p] .opCmp( tmp ) < 0) {
                    F[i][p] = tmp;
                }
                z *= prime[p];
            }
        }
    }

    int ntest, n;
    scanf("%d",&ntest);
    for(int test=0;test<ntest;++test) {
        scanf("%d",&n);
        F[n][nprime-1].viet();
        printf("\n");
    }
    return 0;
}