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 happyboy99x

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

#define BASE 1000000000

struct BigInteger {
    int n; long long d[15100];

    BigInteger() {
        memset(d, 0, sizeof d); n = 0;
    }

    BigInteger(int x) {
        memset(d, 0, sizeof d); n = 0;
        for(; x; x /= BASE) d[n++] = x % BASE;
    }

    void operator += (const BigInteger &x) {
        n = max(x.n, n); int rem = 0;
        for(int i = 0; i < n; ++i) {
            int p = x.d[i] + d[i] + rem;
            if(p >= BASE) d[i] = p - BASE, rem = 1;
            else d[i] = p, rem = 0;
        }
        if(rem) d[n++] = rem;
    }

    BigInteger operator * (const BigInteger &x) {
        BigInteger temp, res;
        for(int i = 0; i < n; ++i) {
            memset(temp.d, 0, sizeof(temp.d[0]) * i); temp.n = i;
            long long rem = 0;
            for(int j = 0; j < x.n; ++j) {
                long long p = d[i] * x.d[j] + rem;
                temp.d[temp.n++] = p % BASE;
                rem = p / BASE;
            }
            for(; rem; rem /= BASE) temp.d[temp.n++] = rem % BASE;
            res += temp;
        }
        return res;
    }

    BigInteger operator ^ (const int x) {
        if(x == 0) return BigInteger(1);
        BigInteger res = (*this) ^ (x/2);
        if(x % 2 == 0) return res * res;
        return res * res * (*this);
    }

    void print() {
        char * s = new char[9 * n + 70], * p = s;
        int k; sprintf(p, "%d%n", (int) d[n-1], &k); p += k;
        for(int i = n-2; i >= 0; --i) sprintf(p, "%09d%n", (int) d[i], &k), p += k;
        for(p = s; *p; p += 70) printf("%.70s\n", p);
    }
};

int main() {
    int a, n; scanf("%d%d",&a,&n);
    (BigInteger(a) ^ n).print();
    return 0;
}

Code mẫu của ladpro98

#include <bits/stdc++.h>

using namespace std;
typedef vector<int> BigInt;
const int BASE = 10000;

BigInt N;
int p, n;

BigInt operator + (BigInt a, BigInt b) {
    BigInt c; int carry = 0;
    for(int i = 0; i < a.size() || i < b.size(); i++) {
        if (i < a.size()) carry += a[i];
        if (i < b.size()) carry += b[i];
        c.push_back(carry % BASE);
        carry /= BASE;
    }
    if (carry) c.push_back(carry);
    return c;
}

BigInt operator * (BigInt a, int b) {
    BigInt c; int carry = 0;
    for(int i = 0; i < a.size(); i++) {
        carry += a[i] * b;
        c.push_back(carry % BASE);
        carry /= BASE;
    }
    if (carry) c.push_back(carry);
    return c;
}

BigInt operator * (BigInt a, BigInt b) {
    BigInt c(a.size() + b.size() + 2, 0);
    for (int i = 0; i < a.size(); i++) {
        int carry = 0;
        for (int j = 0; j < b.size(); j++) {
            int k = i + j;
            c[k] += a[i] * b[j] + carry;
            carry = c[k] / BASE;
            c[k] %= BASE;
        }
        if (carry) c[i + b.size()] += carry;
    }
    while (*c.rbegin() == 0 && c.size() > 0)
        c.erase(c.begin() + c.size() - 1);
    return c;
}

void Print(BigInt a) {
    int L = a.size(), len = 0;
    char buffer[15055];
    len += sprintf(buffer, "%d", a[L - 1]);
    for(int i = L - 2; i >= 0; i--)
        len += sprintf(buffer + len, "%04d", a[i]);
    int cnt = 0;
    for(int i = 0; i < len; i++) {
        cnt++;
        if (cnt > 70) {printf("\n"); cnt = 1;}
        printf("%c", buffer[i]);
    }
}

BigInt Pow(int p) {
    if (p == 1) return N;
    BigInt x = Pow(p >> 1);
    x = x * x;
    if (p & 1) x = x * N;
    return x;
}

int main()
{
    scanf("%d %d", &n, &p);
    while (n) {N.push_back(n % BASE); n /= BASE;}
    BigInt res = Pow(p);
    Print(res);
    return 0;
}

Code mẫu của RR

{$R-,Q-}
{$Mode objFPC}
uses math;
const
  FINP='';
  FOUT='';
  MAXN=15000;
  oo=1000000000;
type
  big=array[0..MAXN] of int64;
var
  f1,f2:text;
  s:ansistring;
  n,p:longint;
  nn,now:big;
procedure openF;
begin
  assign(f1,FINP); reset(f1);
  assign(f2,FOUT); rewrite(f2);
end;
procedure closeF;
begin
  close(f1); close(f2);
end;
procedure inp;
begin
  readln(f1,n,p);
end;
procedure nhan(a,b:big; var c:big); inline;
var
  i,j:longint;
  nho:int64;
begin
  fillchar(c,sizeof(c),0);
  c[0]:=a[0]+b[0]-1;
  for i:=1 to a[0] do
  for j:=1 to b[0] do
    begin
      c[i+j-1]+=int64(a[i])*b[j];
      if c[i+j-1]>oo then
        begin
          c[i+j]+=c[i+j-1] div oo;
          c[i+j-1]:=c[i+j-1] mod oo;
        end;
    end;
  if c[c[0]+1]>0 then inc(c[0]);
  nho:=0;
  for i:=1 to c[0] do
    begin
      c[i]+=nho;
      nho:=c[i] div oo;
      c[i]:=c[i] mod oo;
    end;
  while nho>0 do
    begin
      inc(c[0]);
      c[c[0]]:=nho mod oo;
      nho:=nho div oo;
    end;
end;
procedure nhank(var a:big; k:longint); inline;
var
  i:longint;
  nho:int64;
begin
  nho:=0;
  for i:=1 to a[0] do
    begin
      a[i]:=a[i]*k+nho;
      nho:=a[i] div oo;
      a[i]:=a[i] mod oo;
    end;
  while nho>0 do
    begin
      inc(a[0]);
      a[a[0]]:=nho mod oo;
      nho:=nho div oo;
    end;
end;
procedure solve;
var
  i,dx:longint;
begin
  nn[0]:=1; nn[1]:=n; now:=nn;
  i:=1;
  while i<<1 <p do
    begin
      i:=i<<1;
      nn:=now;
      nhan(nn,nn,now);
    end;
  dx:=i;
  for i:=dx+1 to p do
    nhank(now,n);
end;
procedure ans;
var
  i:longint;
  ss:string;
begin
  str(now[now[0]],s);
  for i:=now[0]-1 downto 1 do
    begin
      str(now[i],ss);
      while length(ss)<9 do ss:='0'+ss;
      s:=s+ss;
    end;
  while length(s)>70 do
    begin
      ss:=copy(s,1,70);
      writeln(f2,ss);
      delete(s,1,70);
    end;
  writeln(f2,s);
end;
begin
  openF;
  inp;
  solve;
  ans;
  closeF;
end.

Code mẫu của hieult

#include<cstdio>
#include<cmath>
#include<cstring>
#include<cstdlib>
#include<cassert>
#include<ctime>
#include<algorithm>
#include<iterator>
#include<iostream>
#include<cctype>
#include<string>
#include<vector>
#include<map>
#include<set>
#include<queue>
#include<list>
//#include<conio.h>
#define ep 0.000000001
#define maxn 10011
#define oo 1111111111
#define base 1000000000
#define TR(c, it) for(typeof((c).begin()) it=(c).begin(); it!=(c).end(); it++)
double const PI=4*atan(1);

using namespace std;

typedef pair<int, int> II;
typedef vector<int> VI;
typedef vector<II> VII;
typedef vector<VI> VVI;
typedef vector<VII> VVII;

int n,f[maxn][4],x[maxn],cha[maxn],u,v,KQ,t;
VVI T;
//VVI::iterator it;

int main(){
     int kq[15011];
     char s[1000111];
     int maxKQ = 0;
     char *s1;
     int n,p,du,i;
     scanf("%d %d",&n,&p);
     if(n==2 && p%2==0){
          n = 4;  p /=2;
     }
     long long the;
     kq[0] = 1;
     for(int k = 0;k<p;k++){
          du = 0;
          for(i = 0;i<=maxKQ||du;i++){
               the = n*1LL*kq[i]+du;
               if(the>=base){
                    kq[i] = the%base;
                    du = the/base;
               }
               else{
                    kq[i] = the;
                    du = 0;
               }
               if(kq[i] && i>maxKQ) maxKQ = i;
          }
     }
     s1 = s;
     for( i = maxKQ;i>=0;i--){
          if(i==maxKQ) sprintf(s1,"%d",kq[i]);
          else sprintf(s1,"%09.9d",kq[i]);
          while(*s1) s1++;
     }
     for(i = 0;s[i];i+=70)
          printf("%.70s\n",&s[i]);
    // getch();
}

Code mẫu của ll931110

program cruell;
const
  input  = '';
  output = '';
  maxd = 1700;
  base = round(1e9);
type
  arr = array[1..maxd] of qword;
var
  res,ss: arr;
  n,p: longint;

procedure init;
var
  f: text;
begin
  assign(f, input);
    reset(f);
    readln(f, n, p);
  close(f);
end;

procedure genbase;
begin
  fillchar(ss, sizeof(ss), 0);
  ss[1] := n;
  if ss[1] >= base then
    begin
      ss[2] := ss[1] div base;
      ss[1] := ss[1] mod base;
    end;
end;

function mul(x,y: arr): arr;
var
  i,j: longint;
  z: arr;
begin
  fillchar(z, sizeof(z), 0);
  for i := 1 to maxd do
    for j := 1 to maxd do
      if (x[i] <> 0) and (y[j] <> 0) then
        begin
          z[i + j - 1] := z[i + j - 1] + x[i] * y[j];
          if z[i + j - 1] >= base then
            begin
              z[i + j] := z[i + j] + z[i + j - 1] div base;
              z[i + j - 1] := z[i + j - 1] mod base;
            end;
        end;

  for i := 1 to maxd do if z[i] >= base then
    begin
      z[i + 1] := z[i + 1] + z[i] div base;
      z[i] := z[i] mod base;
    end;

  mul := z;
end;

function pow(x,p: longint): arr;
var
  q: arr;
begin
  if p = 1 then exit(ss);
  q := pow(x,p div 2);
  q := mul(q,q);
  if odd(p) then q := mul(q,ss);
  pow := q;
end;

procedure printresult;
var
  f: text;
  i,j,k: longint;
  endl: longint;
  s: string;
begin
  res := pow(n,p);

  assign(f, output);
    rewrite(f);

  i := maxd;
  while res[i] = 0 do dec(i);

  str(res[i],s);
  endl := length(s);
  write(f, s);

  for j := i - 1 downto 1 do
    begin
      str(res[j],s);
      for k := 1 to 9 - length(s) do
        begin
          if endl = 70 then
            begin
              endl := 0;
              writeln(f);
            end;
          inc(endl);
          write(f, 0);
        end;

      for k := 1 to length(s) do
        begin
          if endl = 70 then
            begin
              endl := 0;
              writeln(f);
            end;
          inc(endl);
          write(f, s[k]);
        end;
    end;
  close(f);
end;

begin
  init;
  genbase;
  printresult;
end.

Code mẫu của skyvn97

import java.util.*;
import java.lang.*;
import java.math.*;
import java.io.*;
public class Main {
    public static void main(String args[]) {
        InputStream inputStream=System.in;
        OutputStream outputStream=System.out;
        InputReader in=new InputReader(inputStream);
        PrintWriter out=new PrintWriter(outputStream);
        CRUELL solver=new CRUELL();
        solver.solve(in,out);
        out.close();
    }
}
class CRUELL {
    private BigInteger result(int x,int k) {
        BigInteger res=BigInteger.ONE;
        BigInteger mul=BigInteger.valueOf(x);
        while (k>0) {
            if (k%2==1) res=res.multiply(mul);
            mul=mul.multiply(mul);
            k/=2;
        }
        return (res);
    }
    public void solve(InputReader in,PrintWriter out) {
        int n=in.nextInt();
        int p=in.nextInt();
        char[] res=result(n,p).toString().toCharArray();
        int tmp=0;
        for (char x:res) {
            out.print(x);
            tmp++;
            if (tmp%70==0) out.println();
        }
    }
}
class InputReader {
    public BufferedReader reader;
    public StringTokenizer tokenizer;
    public InputReader(InputStream stream) {
        reader=new BufferedReader(new InputStreamReader(stream),32768);
        tokenizer=null;
    }
    public String next() {
        while (tokenizer==null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer=new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }
    public int nextInt() {
        return Integer.parseInt(next());
    }
    public long nextLong() {
        return Long.parseLong(next());
    }
}